Ha a (grafikus) konzol kimenete nem túl nagy, egyszerűen kiválaszthat egy darabot az egérrel, és a középső gombra kattintva beillesztheti az üzenetbe. Ellenkező esetben használhatja a kimenetet egy "tölcséren" keresztül egy fájlba irányítva, például:
Some_command paraméterek > logfile.txt
Ha látni szeretné a végrehajtás eredményét a képernyőn, és egyidejűleg fájlba szeretne írni, használja a tee parancsot:
Some_command paraméterek | tee -a logfile.txt
A setterm -dump parancs pillanatképet hoz létre az aktuális virtuális konzolpufferről egyszerű szöveges fájlként a screen.dump alapértelmezett névvel. Argumentumaként használhatja annak a konzolnak a számát, amelyet kiírni szeretne. És a -file filename opció hozzáadása átirányítja ezt a kiíratást a megadott nevű fájlba. Az -append opció hozzáfűzi az új kiíratást egy meglévő fájlhoz - az "alapértelmezett" screen.dump-hoz vagy a -file kapcsolóval elnevezett fájlhoz.
Azok. a like parancs használata után
Setterm -dump -file /root/screenlog
illetve a fájlban /root/screenlog egy konzololdal tartalma lesz.
Találtam egy másik megoldást a szöveg másolására/beillesztésére egy szövegkonzolon egér nélkül. Szöveget is másolhat a görgetőpufferből (azaz mindent, ami a képernyőn és a képernyő felett van). A jobb megértés érdekében olvassa el a konzol alapú ablakkezelő képernyőt . Hasznos lehet a görgetőpuffer méretének növelése is.
1) Futtassa a képernyőt
2) Nyomja meg az Enter billentyűt. Minden. A nulla konzol ablakban vagyunk.
3) Végrehajtjuk a szükséges parancsokat, amelyek kimenetét át kell másolni.
4) Ctrl+A, Ctrl+[ - másolás módban vagyunk. A kurzort a kijelölés elejére tesszük, nyomjuk meg a szóköz billentyűt, majd tegyük a kurzort a kijelölés végére, nyomjuk meg a szóközt. A szöveg a vágólapra másolva.
5) Ctrl+A, c - létrehoztunk egy új 1. ablakot.
6) Ctrl+A, 1 - átváltunk az 1. ablakra.
7) Nyissa meg bármelyik (?) szövegszerkesztőt (Mc-ben próbáltam), és nyomja meg a Ctrl + A, Ctrl +] - a szöveg beillesztése megtörténik. spórolunk.
8) Ctrl+A, Ctrl+0 – visszalépés a nulladik ablakhoz.
Hogyan lehet növelni a visszagörgetési puffert?
Az első megoldás az alapértelmezett (alapértelmezett) pufferméret növelése a kernelforrásokban, és újrafordítása. Hadd feltételezzem, hogy Ön éppolyan vonakodik ettől, mint én, és rugalmasabb médiumot keres.
És van egy ilyen eszköz, de ennek a neve framebuffer console , röviden fbcon. Ez az eszköz rendelkezik egy dokumentációs fájllal fbcon.txt; ha telepítette a kernel dokumentációját, akkor megvan. Keress valahol a környéken /usr/shareágak (a disztribúciók eltérései miatt nem tudom megadni a pontos elérési utat).
Ezen a ponton elnézést kérek: kicsit el kell térnünk, és beszélnünk kell egy kicsit a videó pufferről ( framebuffer ).
A videopuffer egy puffer a kijelző és a videoadapter között. Szépsége, hogy manipulálható: olyan trükköket tesz lehetővé, amelyek nem működnének, ha az adaptert közvetlenül a kijelzőre csatlakoztatnák.
Az egyik ilyen trükk a scroll pufferrel kapcsolatos; Kiderül, hogy „megkérheti” a videopuffert, hogy foglaljon több memóriát a görgetőpuffernek. Ez a kernel rendszerindítási paramétereivel érhető el. Először igényel framebuffer(videó puffer); Ezután nagyobb scroll puffert kér.
A következő példa a GRUB-ra vonatkozik, de könnyen adaptálható LILO-ra. A GRUB konfigurációs fájlban - menü.lst- keresse meg a kernelnek megfelelő sort, majd: Távolítsa el a vga=xxx opciót, ha van. Adja hozzá a video=vesabf opciót vagy bármit, ami megfelel a hardvernek. Adja hozzá az fbcon=scrollback:128 beállítást. Az eljárás után a kernel paramétersorának valahogy így kell kinéznie:
Kernel /vmlinuz root=/dev/sdb5 video=radeonfb fbcon=scrollback:128
A kérdés az, hogy miért kell eltávolítani a vga=xxx opciót? A videó opcióval való esetleges ütközések miatt. Az ATI adapteremen nem tudom megváltoztatni a görgetőpuffert, ha a vga=xxx szerepel a listán. Talán a te esetedben ez nem így van. Ha a fenti lehetőségek működnek - jó; de mi van, ha növelni szeretné a sorok számát, vagy kisebb betűtípust szeretne beállítani a képernyőn? Mindig ezt csináltad a vga=xxx opcióval, és ez az, ami eltűnt. Ne aggódjon – ugyanezt érhetjük el az fbcon paramétereinek a fájlban leírtak szerint történő megváltoztatásával fbcon.txt(de ebben a cikkben nincs leírva).
Az fbcon=scrollback:128 opcióval a görgetőpufferem 17 képernyőre nőtt (35-ször Shift+PgUp fél képernyőn). A 128 egyébként egy kilobájt. A cikk szerzője azt állítja, hogy ennél többet nem lehet megállapítani. nem próbáltam.
Használhatja a szkriptet.
Parancsfájlnév.log
amikor az összes szükséges parancs végrehajtásra kerül -
Minden a filename.log fájlba van írva
A FreeBSD-nek van egy csodálatos watch segédprogramja, amivel lehet a terminálokat figyelni, de mint kiderült Linuxban teljesen más funkciókat lát el =\ Érdemes guglizni ebben a témában, van valami...
Az egyik legérdekesebb és leghasznosabb téma a rendszergazdák és az új felhasználók számára, akik csak most kezdik megérteni a terminállal való munkát, a Linux I/O átirányítás. A terminál ezen funkciója lehetővé teszi a parancsok kimenetének átirányítását egy fájlba, vagy a fájl tartalmát egy parancs bemenetére, a parancsok összefűzését és a parancsfolyamatokat.
Ebben a cikkben megnézzük, hogyan működik a Linux I/O átirányítás, milyen operátorokat használnak ehhez, és hol lehet mindezt alkalmazni.
Az általunk végrehajtott összes parancs háromféle adatot ad vissza nekünk:
- A parancs végrehajtásának eredménye, általában a felhasználó által kért szöveges adat;
- Hibaüzenetek - tájékoztatják a parancs végrehajtásának folyamatáról és a felmerült előre nem látható körülményekről;
- A visszatérési kód egy szám, amely lehetővé teszi annak értékelését, hogy a program megfelelően működött-e.
Linux alatt minden anyag fájlnak minősül, beleértve a linux I/O adatfolyamokat is. Minden disztribúció három fő adatfolyam-fájllal rendelkezik, amelyeket a programok használhatnak, ezeket a shell határozza meg, és egy fájlleíró szám azonosítja:
- STDIN vagy 0- ez a fájl a billentyűzethez van társítva, és a legtöbb parancs innen kapja az adatokat, hogy működjenek;
- STDOUT vagy 1- ez a szabványos kimenet, ide küldi a program munkája összes eredményét. A képernyőhöz, pontosabban a terminálhoz van társítva, amelyben a program végrehajtódik;
- STDERR vagy 2- minden hibaüzenet ebbe a fájlba kerül.
Az I/O átirányítás lehetővé teszi, hogy ezen fájlok egyikét lecserélje a sajátjára. Például megteheti, hogy a program a billentyűzet helyett a fájlrendszerben lévő fájlból olvassa be az adatokat, a hibákat a képernyő helyett a fájlba is írhatja, stb. Mindez szimbólumok segítségével történik "<" és ">" .
A kimenet átirányítása fájlba
Minden nagyon egyszerű. A kimenetet a > szimbólum használatával átirányíthatja egy fájlba. Például tároljuk a top parancs kimenetét:
top -bn 5 > top.log
A -b kapcsoló hatására a program nem interaktív kötegelt módban fut, az n opció pedig ötször megismétli a műveletet, hogy információkat kapjon az összes folyamatról. Most pedig lássuk, mi történik a macskával:
Szimbólum ">" felülírja a fájlból származó információkat, ha már van ott valami. Az adatok végére történő hozzáadásához használja a ">>" . Például irányítsa át a kimenetet egy linux-fájlba:
top -bn 5 >> top.log
Az átirányítás alapértelmezése a szabványos kimeneti fájlleíró használata. De ezt kifejezetten megadhatod. Ez a parancs ugyanazt az eredményt adja:
top -bn 5 1>top.log
A hibák átirányítása egy fájlba
A hibakimenet fájlra való átirányításához kifejezetten meg kell adnia az átirányítani kívánt fájlleírót. Hibák esetén ez a 2-es szám. Például, amikor megpróbál hozzáférni a gyökérkönyvtárhoz, az ls hibát dob:
A szabványos hibát átirányíthatja egy fájlba, például:
ls -l /root/ 2> ls-error.log
$ cat ls-error.log
Ha adatokat szeretne hozzáadni egy fájl végéhez, használja ugyanazt a szimbólumot:
ls -l /root/ 2>>ls-error.log
A szabványos kimenet és a hibák átirányítása egy fájlba
Az összes kimenetet, hibát és szabványos kimenetet egyetlen fájlba is átirányíthatja. Ennek két módja van. Az első, a régebbi, mindkét leírót átadja:
ls -l /root/ >ls-error.log 2>&1
Először is, az ls parancs kimenete az ls-error.log fájlba kerül az első átirányítási karakter használatával. Továbbá minden hiba ugyanabba a fájlba kerül. A második módszer egyszerűbb:
ls -l /root/ &> ls-error.log
Felülírás helyett használhatja a hozzáfűzést is:
ls -l /root/ &>> ls-error.log
szabványos bemenet fájlból
A legtöbb program – a szolgáltatások kivételével – szabványos bemeneten keresztül kap adatokat a munkájához. Alapértelmezés szerint a normál bevitel a billentyűzetről várja a bevitelt. De kényszerítheti a programot, hogy adatokat olvasson ki egy fájlból az utasítással "<" :
macska A kimenetet azonnal átirányíthatja egy fájlba is. Például rendezzük át a listát: fajta Így egyetlen paranccsal átirányítjuk a linux bemeneti kimenetét. Nemcsak fájlokkal dolgozhat, hanem egy parancs kimenetét is átirányíthatja bemenetként egy másikra. Ez nagyon hasznos összetett műveleteknél. Például nyomtassunk ki öt nemrégiben módosított fájlt: ls -lt | fej -n 5 Az xargs segédprogrammal kombinálhatja a parancsokat úgy, hogy a szabványos bemenet paraméterként kerüljön átadásra. Például másoljunk egy fájlt több mappába: echo teszt/tmp/ | xargs -n 1 cp -v testfile.sh Itt az -n 1 kapcsoló megadja, hogy egy parancsot csak egy paraméter helyettesítsen, a cp -v kapcsolója pedig lehetővé teszi a mozgásokról részletes információk nyomtatását. Egy másik ilyenkor hasznos parancs a tee. Adatokat olvas a szabványos bemenetről, és szabványos kimenetre vagy fájlokra ír. Például: echo "Tee teszt" | tee fájl1 Mindezt más parancsokkal kombinálva több parancsból összetett utasítások hozhatók létre. Ebben a cikkben a Linux I/O adatfolyam-átirányításának alapjait ismertettük. Most már tudja, hogyan irányíthatja át a kimenetet egy linux-fájlba vagy egy fájlból. Nagyon egyszerű és kényelmes. Ha kérdésed van, tedd fel kommentben! Alapértelmezés szerint mindig három "fájl" van nyitva a rendszerben - (billentyűzet), (képernyő) és (hibaüzenetek megjelenítése a képernyőn). Ezeket és minden más megnyitott fájlt át lehet irányítani. Ebben az esetben az "átirányítás" kifejezés azt jelenti, hogy a kimenetet egy fájlból, parancsból, programból, szkriptből vagy akár egyetlen blokkból kell átvenni a szkriptben (lásd a 3-1. példát és a 3-2. példát), és bemenetként továbbítjuk egy másik fájl, parancs, program vagy parancsfájl. Minden megnyitott fájlhoz tartozik egy fájlleíró. A és a fájlleírók 0, 1 és 2. További fájlok megnyitásakor a 3–9. leírók üresen maradnak. Néha a további leírók jó munkát végeznek, ha ideiglenesen megtartják a hivatkozást, ill. Ez megkönnyíti a fogantyúk normál állapotba állítását összetett átirányítási és permutációs manipulációk után (lásd a 16-1. példát). COMMAND_OUTPUT > # Az stdout (kimenet) átirányítása egy fájlba. # Ha a fájl hiányzik, akkor létrejön, ellenkező esetben felülírja. ls -lR > dir-tree.list # Létrehoz egy könyvtárfa listát tartalmazó fájlt. : > fájlnév # A művelet > a "fájlnév" fájlt nullára csökkenti. # Ha a fájl nem létezett a művelet előtt, # egy új nulla hosszúságú fájl jön létre (a "touch" parancsnak ugyanaz a hatása). # Szimbólum: itt helyőrzőként működik, és nem ad ki semmit. > fájlnév # A művelet > a "fájlnév" fájlt nullára vágja le. # Ha a fájl nem létezett a művelet előtt, # egy új nulla hosszúságú fájl jön létre (a "touch" parancsnak ugyanaz a hatása). # (Ugyanaz az eredmény, mint fent - ": >", de ez a beállítás # nem működik egyes shellekben.) COMMAND_OUTPUT >> # Az stdout (kimenet) átirányítása egy fájlra. # Új fájlt hoz létre, ha hiányzik, ellenkező esetben hozzáfűzi a fájl végéhez. # Egysoros átirányítási parancsok # (csak azt a sort érintik, amelyen előfordulnak): # ———————————————————————— 1>fájlnév # Kimeneti átirányítás (stdout) a "fájlnév" fájlba. 1>>fájlnév # A kimenet (stdout) átirányítása a "fájlnév" fájlba, a fájl hozzáfűzés módban nyílik meg. 2>fájlnév # Az stderr átirányítása a "fájlnév" fájlra. 2>>fájlnév # Az stderr átirányítása a "fájlnév" fájlra, a fájl hozzáfűzés módban nyílik meg. &>fájlnév # Az stdout és az stderr átirányítása a "fájlnév" fájlra. #================================================= ============================ # Átirányítás stdout, csak egy sorra. LOGFILE=script.log echo "Ez a sor a \"$LOGFILE\" fájlba lesz írva." 1>$LOGFILE echo "Ez a sor a \"$LOGFILE\" végéhez lesz hozzáadva." 1>>$LOGFILE echo "Ez a sor a \"$LOGFILE\" végéhez is hozzáadódik." 1>>$LOGFILE echo "Ez a sor ki lesz nyomtatva a képernyőre, és nem kerül bele a \"$LOGFILE\" mappába." # Minden sor után a végrehajtott átirányítás automatikusan "visszaáll". # Az stderr átirányítása csak egy sorra. ERRORFILE=script.errors bad_command1 2>$ERRORFILE # A hibaüzenet a $ERRORFILE mappába kerül. bad_command2 2>>$ERRORFILE # A hibaüzenet a $ERRORFILE végére kerül. bad_command3 # A hibaüzenet a stderr, #+ állományba kerül, és nem megy a $ERRORFILE fájlba. # Minden sor után a végrehajtott átirányítás is automatikusan "reset". #================================================= =========================== 2>&1 # Az stderr átirányítása az stdoutba. # A hibaüzenetek ugyanarra a helyre kerülnek, mint az stdout. i> én ban ben j. # Kimenet a fájlba leíróval énát a fájlba leíróval j. >&j # Fájl átirányítása leíróval 1
(stdout) fájlba a leíróval j. # Az stdout kimenete egy leíró fájlba kerül j. 0< FILENAME < FILENAME # Ввод из файла. # Парная команде ">", gyakran együtt található vele. # # grep keresőszó Az átirányítási műveletek és/vagy folyamatok ugyanabban a parancssorban kombinálhatók. parancs< input-file >output-file parancs1 | parancs2 | parancs3 > kimeneti fájl Lásd a 12-23. példát és az A-17. példát. Több adatfolyam is átirányítható egyetlen fájlba. ls -yz >> command.log 2>&1 # Az "ls" parancs érvénytelen "yz" opciója a "command.log" fájlba kerül. # Mert az stderr át van irányítva egy fájlba. Fájlleírók bezárása Zárja be a bemeneti fájl leíróját. 0<&-, <&-
Zárja be a kimeneti fájl leíróját. 1>&-, >&-
A gyermekfolyamatok öröklik a nyitott fájlleírókat. Ezért működnek a csővezetékek. A fogantyúk öröklődésének megelőzése érdekében zárja be őket az alárendelt folyamat elindítása előtt. # Csak az stderr kerül átadásra a folyamatba. exec 3>&1 # Mentse el az stdout aktuális "állapotát". ls -l 2>&1 >&3 3>&- | grep bad 3>&- # Leírás bezárása. 3 a "grep"-hez (de nem az "ls"-hez). # ^^^^ ^^^^ exec 3>&- # Most zárja be a szkript többi részére. # Köszönöm S.C. Az I/O átirányítással kapcsolatos további információkért lásd a D függeléket. Csapat végrehajtó 16-1. példa. Átirányítás az exec #!/bin/bash # Az stdin átirányítása az "exec"-el. végrehajtó 6<&0 # Связать дескр. #6 со стандартным вводом (stdin). # Сохраняя stdin. exec < data-file # stdin заменяется файлом "data-file" read a1 # Читается первая строка из "data-file". read a2 # Читается вторая строка из "data-file." echo echo "Следующие строки были прочитаны из файла." echo "——————————————" echo $a1 echo $a2 echo; echo; echo exec 0<&6 6<&- # Восстанавливается stdin из дескр. #6, где он был предварительно сохранен, #+ и дескр. #6 закрывается (6<&-) освобождая его для других процессов. # # <&6 6<&- дает тот же результат. echo -n "Введите строку " read b1 # Теперь функция "read", как и следовало ожидать, принимает данные с обычного stdin. echo "Строка, принятая со stdin." echo "—————————" echo "b1 = $b1" echo exit 0 Ugyanígy az építkezés exec>fájlnévátirányítja a kimenetet a megadott fájlra. Ezt követően a parancsok összes kimenete, amelyre általában irányulna, most ebbe a fájlba kerül. Példa 16-2. Átirányítás az exec #!/bin/bash # reassign-stdout.sh LOGFILE=logfile.txt exec 6>&1 # Leírás hozzárendelése. #6 stdouttal. # Stdout mentése. exec > $LOGFILE # stdout helyére "logfile.txt" lép. # ———————————————————— # # Az ebben a blokkban lévő parancsok összes kimenete a $LOGFILE fájlba kerül. echo -n "Logfile: " date echo "—————————————-" echo echo "Parancs kimenet \"ls -al\"" echo ls -al echo; echo echo "A \"df\" parancs kimenete" echo df # ————————————————————# exec 1>&6 6>&- # Stdout visszaállítása és a leírás bezárása . #6. echo echo "== stdout visszaállítva az alapértelmezett értékre == " echo ls -al echo kilépés 0 Példa 16-3. Az eszközök egyidejű átirányítása és az exec parancs használatával #!/bin/bash # felsőconv.sh # A bemeneti fájlban lévő karakterek konvertálása nagybetűssé. E_FILE_ACCESS=70 E_WRONG_ARGS=71, ha [ ! -r "$1" ] # Olvasható a fájl? majd echo "Nem lehet olvasni a megadott fájlból!" echo "Használat: $0 input-file output-file" exit $E_FILE_ACCESS fi # Ha a bemeneti fájl ($1) nincs megadva #+ a kilépési kód ugyanaz lesz. if [ -z "$2" ] then echo "Meg kell adnia egy kimeneti fájlt." echo "Használat: $0 input-file output-file" kilépés $E_WRONG_ARGS fi exec 4<&0 exec < $1 # Назначить ввод из входного файла. exec 7>&1 exec > $2 # Kimenet hozzárendelése a kimeneti fájlhoz. # Feltételezi, hogy a kimeneti fájl írható # (ellenőrzés hozzáadása?). # ———————————————— macska — | tr a-z A-Z # Konvertálás nagybetűsre # ^^^^^ # Olvasás stdin-ből. # ^^^^^^^^^^ # Írás a stdoutba. # Az stdin és az stdout azonban át lett irányítva. # ———————————————— exec 1>&7 7>&- # Stdout visszaállítása. végrehajtó 0<&4 4<&- # Восстановить stdin. # После восстановления, следующая строка выводится на stdout, чего и следовало ожидать. echo "Символы из \"$1\" преобразованы в верхний регистр, результат записан в \"$2\"." exit 0 Következő: A hibák átirányítása egy fájlba fel: I/O átirányítás Előző: Bemenet átirányítása fájlból tartalom Index
A szabványos kimenet fájlba való átirányításához használja a `>' operátort. Adja meg a > operátort a parancs neve után, majd a kimeneti célként szolgáló fájl nevét. Például egy program kimenetének fájlba írásához írja be: Ha átirányítja a szabványos kimenetet egy már létező fájlra, akkor az elejétől fogva felül lesz írva. Ha szabványos kimenetet szeretne hozzáadni egy meglévő fájl tartalmához, akkor a `»' operátort kell használnia. Például a munka eredményének hozzáadásához a program ismételt futtatásakor egy fájlhoz írja be: Alex Otwagin 2002.12.16 Egy program általában azért értékes, mert képes feldolgozni az adatokat: elfogad egy dolgot, ad egy másik kimenetet, és szinte bármi tud adatként működni: szöveg, számok, hang, videó ... A parancs bemeneti és kimeneti adatfolyamait ún. bemenetés következtetés. Minden programnak több bemeneti és kimeneti adatfolyama lehet. Minden folyamat, amikor létrejön, hiba nélkül megkapja az ún szabványos bemenet(standard bemenet, stdin) és szabványos kimenet(standard kimenet, stdout) és szabványos hibakimenet(standard hiba, stderr). A szabványos bemeneti/kimeneti adatfolyamokat elsősorban szöveges információk cseréjére tervezték. Még az sem mindegy, hogy ki kommunikál szövegeken keresztül: egy olyan személy, akinek van egy programja vagy műsorai egymás között - a lényeg, hogy legyen adatátviteli csatornája, és „ugyanazt a nyelvet” beszéljék. A géppel való munkavégzés szöveges elve lehetővé teszi, hogy elvonatkoztasson a számítógép bizonyos részeitől, mint például a rendszerbillentyűzet és a monitorral ellátott videokártya, egyetlen terminál eszköz, amelyen keresztül a felhasználó szöveget (parancsokat) ír be és továbbítja a rendszernek, a rendszer pedig megjeleníti a felhasználó számára szükséges adatokat, üzeneteket (diagnosztika és hibák). Az ilyen készüléket ún terminál. Általában a terminál a felhasználó belépési pontja a rendszerbe, amely képes szöveges információkat továbbítani. A terminál lehet egy különálló külső eszköz, amely soros adatporton keresztül (a személyi számítógépben „COM port”-nak) csatlakozik a számítógéphez. Egy program (például xterm vagy ssh) terminálként is működhet (a rendszer bizonyos támogatásával). Végül, virtuális konzolok- terminálok is, csak programozottan, egy modern számítógép megfelelő eszközei segítségével szervezve. Amikor a parancssorral dolgozik, a shell szabványos bemenete a billentyűzethez, a szabványos kimenet és hibakimenet pedig a monitor képernyőjéhez (vagy terminálemulátor ablakához) van társítva. Mutassuk meg a legegyszerűbb parancs példáján - cat. Általában a parancs macska beolvassa az adatokat az összes paraméterként megadott fájlból, és az olvasást közvetlenül a szabványos kimenetre (stdout) küldi. Ezért a parancs /home/larry/papers# macskatörténet-záró mesterdolgozat először a fájl tartalmát jeleníti meg, majd a fájlt. Ha azonban nincs megadva fájlnév, akkor a program macska beolvassa az stdin bemenetét, és azonnal visszaadja az stdout-ba (anélkül, hogy bármilyen módon megváltoztatná). Az adatok áthaladnak macska mint egy csövön keresztül. Vegyünk egy példát: /home/larry/papers# macska Hello. Szia. Viszlát. Viszlát. ctrl—D/home/larry/papers# A billentyűzetről beírt sorokat a macskaprogram azonnal visszaadja a képernyőre. Normál bevitelről történő információbevitelkor a szöveg végét általában egy speciális billentyűkombináció beírása jelzi ctrl—D. Vegyünk egy másik példát. Csapat fajta beolvassa a bemeneti szöveg sorait (az stdin-ből is, ha nincs megadva fájlnév), és ezekből a sorokból rendezett formában adja ki az stdout-ba. Vizsgáljuk meg a működését. /home/larry/papers# banán rendezés sárgarépa alma Ctrl+D alma banán sárgarépa /home/larry/papers# Mint látható, megnyomása után ctrl—D, fajtaábécé sorrendben nyomtatta ki a sorokat. Tegyük fel, hogy a sort parancs kimenetét egy fájlba szeretné átvezetni, hogy ábécé sorrendben rendezett listát tároljon a lemezen. A shell lehetővé teszi a parancs szabványos kimenetének átirányítását egy karakter segítségével egy fájlba. Vegyünk egy példát: /home/larry/papers# sort > shopping-list bananas carrots apples ctrl—D/home/larry/papers# Látható, hogy a rendezési parancs kimenete nem jelenik meg, hanem el van mentve egy nevű fájlba. Mutassuk meg ennek a fájlnak a tartalmát: /home/larry/papers# macska bevásárlólista alma banán sárgarépa /home/larry/papers# Most legyen az eredeti rendezetlen lista a fájlban. Ez a lista a paranccsal rendelhető fajta, ha azt mondod neki, hogy az adott fájlból olvassa, és ne a szabványos bemenetéről, és ezen felül a szabványos kimenetet átirányítsd egy fájlba, ahogyan fentebb is történt. Példa: /home/larry/papers# tételek rendezése bevásárlólista /home/larry/papers# macska bevásárlólista alma banán sárgarépa /home/larry/papers# Megteheti azonban másként is, ha nem csak a szabványos kimenetet irányítja át, hanem azt is szabványos bemenet segédprogramokat egy fájlból, a szimbólum használatával: /home/larry/papers# rendezés< items apples bananas carrots /home/larry/papers# parancs eredménye fajta< items
egyenértékű a paranccsal tételek rendezése, de az első a következőt mutatja: a parancs kiadásakor fajta< items
a rendszer úgy viselkedik, mintha a fájlban lévő adatokat szabványos bemenetről írták volna be. Az átirányítást a shell végzi. csapat fajta nincs fájlnév jelentve: ez a parancs úgy olvassa be az adatokat a szabványos bemenetéről, mintha a billentyűzetről írnánk be. Mutassuk be a fogalmat szűrő. A szűrő olyan program, amely a szabványos bemenetről adatokat olvas be, azokat valamilyen módon feldolgozza, és az eredményt a szabványos kimenetre küldi. Átirányítás használata esetén a szabványos bemenet és kimenet fájlok lehetnek. Ahogy fentebb említettük, alapértelmezés szerint az stdin és az stdout a billentyűzetre, illetve a képernyőre utal. A rendezési program egy egyszerű szűrő - rendezi a bemenetet, és elküldi az eredményt a szabványos kimenetre. Egy nagyon egyszerű szűrő a program macska- nem csinál semmit a bemeneti adatokkal, hanem egyszerűen elküldi a kimenetre. Fentebb már bemutattuk, hogyan lehet a rendezési programot szűrőként használni. Ezek a példák azt feltételezik, hogy a forrásadatok valamilyen fájlban vannak, vagy a forrásadatokat a billentyűzetről kell bevinni (normál bevitel). De mi van akkor, ha olyan adatokat szeretne rendezni, amelyek valamilyen más parancs eredménye, például ls? Az adatokat fordított ábécé sorrendbe rendezzük; ez a parancs opcióval történik fajta. Ha az aktuális könyvtár fájljait fordított ábécé sorrendben szeretné felsorolni, akkor ennek egyik módja a következő. Először futtassuk a parancsot ls: /home/larry/papers# ls english-list history-final masters-thesis notes /home/larry/papers# Most átirányítjuk a parancs kimenetét ls egy file-list nevű fájlba /home/larry/papers# ls > file-list /home/larry/papers# sort -r file-list notes masters-thesis history-final english-list /home/larry/papers# Itt van a parancs kimenete ls fájlba mentve, majd ezt követően ezt a fájlt a parancs feldolgozta fajta. Ez az elérési út azonban nem elegáns, és egy ideiglenes fájl használatát igényli a program kimenetének tárolásához. ls. A megoldás ebben a helyzetben az alkotás dokkolt csapatok(csövek). A dokkolást a shell végzi, amely az első parancs stdout-ját a második parancs stdin-jére irányítja. Ebben az esetben a parancs stdout-ját szeretnénk elküldeni ls stdin parancsokon fajta. A dokkoláshoz szimbólumot használunk, amint az a következő példában látható: /home/larry/papers# ls | sort -r notes masters-thesis history-final english-list /home/larry/papers# Ez a parancs rövidebb, mint a parancskészlet, és könnyebben begépelhető. Nézzünk egy másik hasznos példát. Csapat /home/larry/papers# ls /usr/bin hosszú fájllistát állít elő. A lista nagy része túl gyorsan repül át a képernyőn ahhoz, hogy a lista tartalma olvasható legyen. Próbáljuk meg a more paranccsal megjeleníteni ezt a listát részenként: /home/larry/papers# ls /usr/bin | több Most már görgetheti ezt a listát. Továbbléphet, és kettőnél több parancsot rögzíthet. Fontolja meg a parancsot fej, amely a következő tulajdonság szűrője: a bemeneti adatfolyam első sorait jeleníti meg (esetünkben több dokkolt parancs kimenete lesz a bemenet). Ha az aktuális könyvtár utolsó alfabetikus fájlnevét szeretnénk megjeleníteni, akkor a következő hosszú parancsot használhatjuk: /home/larry/papers# ls | sort-r | fej -1 jegyzetek /home/larry/papers\# hol van a csapat fej a kapott sorok bemeneti adatfolyamának első sorát jeleníti meg (esetünkben a folyam a parancsból származó adatokból áll ls), fordított ábécé sorrendbe rendezve. Egy karakter használata a fájlkimenet átirányítására romboló hatású; más szóval a parancs /home/larry/papers# ls > file-list megsemmisíti a fájl tartalmát, ha a fájl korábban létezett, és új fájlt hoz létre a helyére. Ha az átirányítás helyett szimbólumokkal történik, akkor a kimenet a megadott fájl végéhez fűződik anélkül, hogy a fájl eredeti tartalma megsemmisülne. Például a parancs /home/larry/papers# ls >> file-list tulajdonítsa a parancs kimenetét ls a fájl végére. Vegye figyelembe, hogy a bemeneti és kimeneti átirányítást, valamint a parancsillesztést olyan shell-ek kezelik, amelyek támogatják a és karakterek használatát. Maguk a parancsok nem képesek észlelni és értelmezni ezeket a karaktereket. Valami ilyesminek meg kell tennie azt, amire szüksége van? Nézd meg: Wintee Nem kell cygwin. Azonban találkoztam és jelentettem néhány problémát. Ellenőrizheti a http://unxutils.sourceforge.net/ címet is, mert pólót tartalmaz (és nem kell hozzá cygwin), de ügyeljen arra, hogy az EOL kimenetei UNIX-szerűek. Végül, de nem utolsósorban, ha rendelkezik PowerShell-lel, kipróbálhatja a Tee-Object-et. További információkért írja be a PowerShell-konzolba. Ez működik, bár kicsit csúnya: Ez egy kicsit rugalmasabb, mint néhány más megoldás, mivel a maga módján működik, így hozzáadhatja. Ezt elég gyakran használom kötegfájlokban üzenetek naplózására és megjelenítésére: Igen, megismételheti az ECHO utasítást (egyszer a képernyőhöz, másodszor pedig átirányítás a naplófájlhoz), de ez ugyanolyan rosszul néz ki, és karbantartási probléma. Így legalább nem kell két helyen módosítania az üzeneteket. Vegye figyelembe, hogy a _ csak egy rövid fájlnév, ezért el kell távolítania a kötegfájl végéről (ha kötegfájlt használ). Ez létrehoz egy naplófájlt az aktuális idővel és idővel, és a folyamat során használhatja a konzolsorokat Ha a cygwin szerepel a Windows környezet elérési útjában, használhatja: Egy egyszerű C# konzolalkalmazás megteszi a trükköt: Ennek használatához egyszerűen vezesse be az eredeti parancsot a programba, és adja meg az elérési utat minden olyan fájlhoz, amelynek kimenetét meg szeretné másolni. Például: Megjeleníti a keresési eredményeket, és elmenti az eredményeket files1.txt és files2.txt fájlokban. Vegye figyelembe, hogy nincs sok (semmi!) a hibakezelés útjában, és előfordulhat, hogy több fájl támogatása sem szükséges. Én is kerestem ugyanezt a megoldást, kis próbálkozás után ezt sikerrel tudtam végrehajtani parancssorban. Íme a megoldásom: Még bármilyen PAUSE parancsot is rögzít. Egy másik lehetőség, ha a programjában a tee stdout-ot stderr-re helyezi: Ezután a dos batchfile-ben: Az Stdout a naplófájlba lép, és az stderr (ugyanaz az adat) jelenik meg a konzolon. A kimenet megjelenítése és átirányítása egy fájlba. Tegyük fel, hogy ha a dos parancsot használom (dir > test.txt), akkor ez a parancs átirányítja a kimenetet a teszt.txt fájlba anélkül, hogy megjelenítené az eredményeket. hogyan írjunk parancsot a kimenet kinyomtatására és a kimenet átirányítására DOS, azaz Windows parancssor használatával, nem UNIX/LINUX használatával. Hasznosnak találhatja ezeket a parancsokat a biterscripting (http://www.biterscripting.com) webhelyen. Ez az MTS korábbi válaszának egy változata, azonban olyan funkciókat ad hozzá, amelyeket mások hasznosnak találhatnak. Itt van az általam használt módszer: Íme a parancsok sorrendje: Íme egy példa: Így a parancs csak hozzáadható a kötegfájl későbbi parancsaihoz, ami sokkal tisztábbnak tűnik: Más parancsok végére is hozzáadható. Amennyire meg tudom állapítani, ez akkor működik, ha az üzeneteknek több sora van. Például a következő parancs két sort nyomtat, ha hibaüzenet jelenik meg: Egyetértek Brian Rasmussennel, az unxutils port a legegyszerűbb módja ennek. Rob van der Woude Scripting oldalainak Batch Files részében rengeteg információval szolgál az MS-DOS és CMD parancsok használatáról. Azt hittem, hogy megvan a maga megoldása a problémádra, és miután átkutattam a TEE.BAT-ban, rátaláltam a TEE.BAT-ra, amely úgy tűnik, hogy ez csak egy MS-DOS-os nyelvi csomag. Ez egy meglehetősen összetett kötegfájl, és hajlamos vagyok az unxutils portot használni. A legtöbb gépemre perl-t telepítek, így a válasz a perl: tee.pl dir | perl tee.pl vagy könyvtár | perl tee.pl dir.bat nyers és nem tesztelt. Míg általában, mint már említettük, a program I/O szabványos adatfolyamokhoz van kötve, a shellben speciális lehetőségek vannak az I/O átirányítására. A " szimbólumok az átirányítást jelzik. >
", "<
"és" >>
". A leggyakrabban a parancs kimenetének átirányítása egy fájlba. Íme egy releváns példa: $ ls -l > /home/jim/dir.txt Ez a parancs elmenti a /home/jim/dir.txt fájlba azon fájlok és alkönyvtárak listáját, amelyek a parancs végrehajtásának időpontjában aktuálisak voltak. ls; ugyanakkor, ha a megadott fájl nem létezett, akkor létrejön; ha létezett, akkor felül lesz írva; ha azt szeretné, hogy a parancs kimenete egy létező fájl végéhez legyen hozzáfűzve, akkor a szimbólum helyett >
használat >>
. Ebben az esetben a szóközök jelenléte a karakterek előtt vagy után >
vagy >>
lényegtelen, és kizárólag a felhasználó kényelmét szolgálja. A kimenetet nem csak egy fájlra irányíthatja, hanem egy másik parancs bemenetére vagy egy eszközre (például nyomtatóra) is. Például a /home/jim/report.txt fájlban lévő szavak számának megszámlálásához használja a következő parancsot: $ cat /home/jim/report.txt > wc -w és a fájl kinyomtatásához a parancsot: $ cat /home/jim/report.txt > lpr Amint látja, az operátor >
a kimeneti adatfolyam átirányítására szolgál. A bemeneti adatfolyammal kapcsolatban hasonló funkciót lát el az operátor <
. A fenti példaparancs egy adott fájlban lévő szavak számának megszámlálására a következőképpen írható át (figyelje meg a parancs hiányát macska): $ wc -w< /home/jim/report.txt
Ezt a fajta átirányítást gyakran használják különféle szkriptekben olyan parancsokhoz, amelyek általában elfogadják (vagy bevitelt várnak tőle) a billentyűzetről. Egy olyan szkriptben, amely egyes rutinműveleteket automatizál, megadhatja a parancsnak a szükséges információkat egy fájlból, amely tartalmazza azt, amit a parancs végrehajtásához meg kell adni. Mert a szimbólumok <
,
>
és >>
szabványos streameken működjenek, nem csak a szokásos módon használhatók, mint általában, hanem kissé eltérő módon is. Tehát a következő parancsok egyenértékűek: $ macska > fájl $cat>fájl $ >filecat $ > fájl kat Önmagában azonban (minden olyan parancs nélkül, amelyhez szabványos adatfolyamok vannak definiálva) az átirányító karakter nem használható, így például a parancssorba gépelve nem $ fájl1 > fájl2 szerezzen másolatot valamelyik fájlról. Ez azonban nem csökkenti ennek a mechanizmusnak az értékét, mivel minden parancshoz szabványos adatfolyamok vannak meghatározva. Ebben az esetben nem csak a szabványos bemenetet és kimenetet, hanem más adatfolyamokat is átirányíthat. Ehhez meg kell adnia az átirányítandó adatfolyam számát az átirányítási szimbólum előtt. A szabványos bemeneti stdin a 0, a szabványos kimeneti stdout az 1, az stderr szabványos hibaüzenet-folyam száma a 2. Vagyis az átirányítási parancs teljes formátuma (ne feledje, hogy a > melletti szóköz nem szükséges): parancs N > M ahol Nés M— a szabványos adatfolyamok száma (0,1,2) vagy fájlnevek. Egyes esetekben szimbólumok használata <
,
>
és >>
csatornaszám vagy fájlnév megadása nélkül csak azért lehetséges, mert a hiányzó szám helyett alapértelmezésben 1, azaz standard kimenet van helyettesítve. Igen, az üzemeltető >
szám nélkül úgy értelmezik 1
>
. A szabványos adatfolyamok egyszerű átirányítása mellett lehetőség van arra is, hogy ne csak egy adatfolyamot irányítsunk át egy adott csatornára, hanem másolatot készítsünk egy szabványos adatfolyam tartalmáról. Ehhez van egy speciális karakter. &
, amely annak a csatornának a száma elé kerül, amelyre az adatfolyamot átirányítják: parancs N > &M Ez a parancs azt jelenti, hogy a csatorna kimenete a számmal N a szabványos kimenetre is elküldésre kerül, és a számmal megkettőződik a csőben M. Például ahhoz, hogy a hibaüzenetek a szabványos kimeneten duplikálódjanak, ki kell adnia a parancsot 2>&1,
míg 1>&2
megkettőzi az stdout fájlt az stderr-be. Ez a funkció különösen akkor hasznos, ha a kimenetet fájlba irányítjuk át, mivel ekkor mindketten látjuk az üzeneteket a képernyőn, és fájlba mentjük őket. A kimeneti átirányítás speciális változata egy programcsatorna szervezése (ezt néha pipeline-nek vagy pipeline-nek nevezik). Ehhez két vagy több parancsot kell összekötni (vagy elválasztani, ha úgy tetszik) egy függőleges sáv szimbólummal - "|". Ebben az esetben a parancs szabványos kimeneti adatfolyama, amely a szimbólumtól balra található |
, a program szabványos bemenetére irányul, amely a karaktertől jobbra található |
. Például: $ cat myfile | grep Linux | wc -l Ez a sor azt jelenti, hogy a parancs kimenete macska, azaz a myfile fájl szövege a parancs bemenetére lesz irányítva grep, amely csak a "Linux" szót tartalmazó sorokat választja ki. parancs kimenet grep viszont a parancs bemenetére lesz irányítva wc -l, amely számolja az ilyen sorok számát. A programcsöveket több kis program kombinálására használják, amelyek mindegyike csak bizonyos transzformációkat hajt végre a bemeneti adatfolyamán, hogy általános parancsot hozzon létre, amelynek eredménye egy bonyolultabb átalakítás. Meg kell jegyezni, hogy a shell egyszerre hívja meg a folyamatban lévő összes parancsot, és minden parancshoz külön példányt futtat a shellből, így amint az első program elkezd valamit kiadni a kimeneti adatfolyamának, a következő parancs elkezdi feldolgozni. Ugyanígy minden következő parancs végrehajtja a működését, várva az előző parancs adatait, és az eredményét bemenetként adja meg a következőnek. Ha azt szeretné, hogy az egyik parancs teljesen befejeződjön a következő végrehajtása előtt, használhatja ugyanabban a sorban csőszimbólumként |
, és egy pontosvessző ;
. Minden pontosvessző előtt a shell leáll, és megvárja, amíg a folyamatban lévő összes korábbi parancs végrehajtása befejeződik. A kilépési állapot (a program befejezésekor visszaadott logikai érték) megegyezik a folyamat utolsó parancsa által visszaadott kilépési állapottal. A folyamat első parancsa előtt elhelyezheti a "!" szimbólumot, ekkor a folyamat kilépési állapota az utolsó parancs kilépési állapotának logikai negációja lesz. A shell megvárja az összes folyamatparancs befejezését, mielőtt beállítja a visszatérési értéket. A fenti példák közül az utolsó (a paranccsal grep) egy másik fontos fogalom, mégpedig a szűrőprogram illusztrálására használható. A szűrők olyan parancsok (vagy programok), amelyek elfogadnak egy bemeneti adatfolyamot, bizonyos átalakításokat hajtanak végre rajta, és az eredményt a szabványos kimenetre adják ki (ahonnan a felhasználó kérésére átirányítható máshová). A szűrőparancsok közé tartoznak a fentebb már említett parancsok. macska, több, kevesebb, wc, cmp, diff,
valamint a következő parancsokat. 5.1. táblázat. Szűrési parancsok
Csapat
Rövid leírás
grep,
fgrep,
egrep Keresse meg a bemeneti fájlban vagy a szabványos bemenetben a megadott mintát tartalmazó sorokat, és írja be azokat a szabványos kimenetre A bemeneti adatfolyamban a megadott listában felsorolt karakterek minden előfordulását lecseréli a második megadott lista megfelelő karaktereire comm Soronként összehasonlít két fájlt, és 3 oszlopot ír az stdout-ba: az egyik olyan sorokat tartalmaz, amelyek csak az 1. fájlban fordulnak elő, a második olyan sorokat tartalmaz, amelyek csak a 2. fájlban fordulnak elő: a harmadik pedig olyan sorokat tartalmaz, amelyek mindkét fájlban megjelennek Formázza a szöveges fájlt vagy a szabványos bemenet tartalmát nyomtatáshoz. sed Vonalszerkesztő, amely bizonyos átalakítások végrehajtására szolgál a bemeneti adatfolyamon (fájlból vagy szabványos bemenetről) A speciális szűrő a parancs póló, amely "duplázza" a bemeneti adatfolyamot, egyrészt a szabványos kimenetre irányítja, másrészt egy fájlba (amelynek a nevét meg kell adnia). Könnyen belátható, hogy működésében a parancs póló hasonló az átirányítási operátorhoz 1>&fájl. A szűrők lehetőségei jelentősen bővíthetők reguláris kifejezések használatával, amelyek lehetővé teszik például a keresés megszervezését különféle, gyakran nagyon összetett minták segítségével. Sokat lehetne mondani az átirányításról és a szűrőkről. De ez az anyag megtalálható a legtöbb UNIX- és Linux-könyvben, mint például a Petersen [A1.4] és a Kelly-Bootle [A1.8]. Ezért korlátozzuk magunkat az elmondottakra, és folytatjuk az úgynevezett környezet vagy a héj által létrehozott környezet vizsgálatát. I/O rendszer LINUX rendszerben.
Az I/O rendszerben minden külső eszközt fájlként kezel, amelyen megengedett a normál fájlműveletek. Természetesen vannak eszközmeghajtók is, de a velük lévő interfész egy speciális fájl hívásaként van kialakítva a felhasználó számára. A speciális fájlok az I/O rendszer egységesítésének eszközei. Minden csatlakoztatott eszközhöz (terminálhoz, lemezekhez, nyomtatóhoz stb.) tartozik legalább egy speciális fájl. Ezen speciális fájlok többsége a /dev könyvtárban található: Amikor egy program egy ilyen speciális fájlba ír, az operációs rendszer elfogja és elküldi egy eszközre, például nyomtatóra). Amikor ilyen típusú fájlból olvassa be az adatokat, akkor azok valójában egy eszközről, például lemezről érkeznek. A programnak nem szabad figyelembe vennie az I / O eszköz sajátosságait. Erre a célra speciális fájlok (illesztőprogramok) szolgálnak, amelyek interfészként szolgálnak az OS kernel összetevői és az általános célú alkalmazási programok között. A rendszer csak azután észleli a különbséget egy normál és egy speciális fájl között, miután elemezte a megfelelő inode-ot, amelyre a könyvtárbejegyzés hivatkozik. Az eszköz típusa és száma egyben a speciális fájlok fő jellemzője is (a hossz mezőben a megfelelő eszköz fő és mellékszáma található). Az első az eszköz típusát határozza meg, a második - a hasonló eszközök között azonosítja. Az operációs rendszer egyszerre több tucat, sőt több száz terminált is kiszolgálhat. Mindegyiknek saját speciális fájllal kell rendelkeznie, így a fő- és mellékszámok jelenléte lehetővé teszi a szükséges megfeleltetés létrehozását az eszköz és egy ilyen fájl között. Egy lemezen több fájlrendszert is létrehozhat. Egyes rendszerek egy fájlrendszert használnak lemezenként, míg mások több. Az mkfs (make file system) paranccsal új fájlrendszer hozható létre. Például a # /sbin/mkfs /dev/dsk/fl1 512 kifejezés jelentése: létrehozás hajlékonylemezen b: 512 blokk méretű. Opcionálisan beállíthatja a fájlrendszer méretét blokkban és az i-node-ok számát (azaz a fájlrendszerben tárolható fájlok maximális számát). Alapértelmezés szerint az i-csomópontok száma megegyezik a blokkok számával osztva néggyel. Az i-csomópontok maximális száma egyetlen fájlrendszerben 65 000. Ha valamilyen okból több mint 65 000 i-csomópontra van szüksége egy lemezen, akkor két vagy több fájlrendszert kell létrehoznia azon a lemezen. Bármilyen fájlrendszer csatlakoztatható (csatolható) egy közös könyvtárfához, annak bármely pontján. Például a / könyvtár a rendszer gyökérkönyvtára, emellett a fájlrendszer alapja, amely mindig fel van csatolva. A /usr1 könyvtár a / könyvtárban található, de ebben az esetben a gyökér fájlrendszertől különálló fájlrendszerről van szó, mivel a benne lévő összes fájl a lemez külön részén, vagy akár külön lemezen található. A /usr1 fájlrendszer egy csatolt fájlrendszer – azon a ponton gyökerezik, ahol az /usr1 könyvtár létezik a teljes hierarchiában (1. és 2. ábra). Rizs. 1. Fájlrendszer előtt Rizs. 2. Fájlrendszer után A /sbin/mount parancs a fájlrendszer csatlakoztatására szolgál. Ezzel a paranccsal az adott fájlrendszer bárhová elhelyezhető a meglévő könyvtárstruktúrában: Ha olyan lemezekre szeretne fájlrendszert csatlakoztatni, amelyeknek írásvédettnek kell lenniük ahhoz, hogy a rendszer csak olvasható legyen, akkor hozzá kell adnia az -r kapcsolót a /sbin/mount parancshoz. Ha információt szeretne kapni a felcsatolt fájlrendszerekről, például egy LINUX rendszeren, használhatja a /sbin/mount parancsot argumentumok nélkül (3. ábra). Rizs. 3. Ez a parancs kiírja azt a könyvtárat, amelybe a fájlrendszert felcsatolták (pl. usrl), a /dev eszközt, amelyen található, a csatlakoztatás időpontját és dátumát. A /sbin/umount parancs a fájlrendszer leválasztására szolgál, ami a mount parancs ellentéte. Felszabadítja a fájlrendszert, és mintegy kiveszi a teljes könyvtárszerkezetéből, így az összes saját fájlja és könyvtára nem érhető el: A gyökér fájlrendszert nem lehet leválasztani. Az umount parancs akkor is meghiúsul, ha valaki a lecsatolt fájlrendszer fájlját használja (ez akár olyan egyszerű is lehet, hogy a felhasználó a fájlrendszer valamelyik könyvtárában van lecsatolva). A mount és umount parancsokban a felhasználó a fizikai lemezeszköz rövidítését használja. A fizikai eszközökhöz a LINUX rendelkezik a dsk és az rdsk könyvtárakkal, amelyek a lemezeszközöknek megfelelő fájlokat tartalmaznak. Általában a fájlnevek ezekben a könyvtárakban megegyeznek, és az egyetlen különbség közöttük az, hogy az rdsk könyvtár speciális hozzáférésű (raw) lemezeszközöket tartalmaz, amelyeket egyes rendszereszközök a gyorsabb lemezelérés érdekében használnak. Egy tipikus dsk-könyvtár a következő eszközöket tartalmazza: A LINUX rendszerben a lemezeszközök logikailag partíciókra vannak osztva, hasonlóan a MasterBoot MS DOS partíciós táblázatában meghatározott partíciókhoz. A 0s1, 0s2, 0s3 stb. fájlok a 0 lemezszám első, második, harmadik stb. szakaszának felelnek meg. Az 1s0, 1sl, 1s2 stb. fájlok az 1. számú lemez első, második, harmadik stb. szakaszainak felelnek meg. Ha a rendszernek több lemeze van, a partíciók számozása ns0, nsl stb. lesz minden n lemezszámhoz. A sok lemezmeghajtóval rendelkező rendszerek a következő számozási rendszert használják: ahol vezérlő - lemezvezérlő száma; lemez - lemez száma; szakasz - lemez szakasz száma. Az f betűvel kezdődő fájlok különböző típusú hajlékonylemezeket határoznak meg. Az rmt könyvtár a szalagos eszközökön lévő fájlokat tartalmazza: A c0s0, cls0, c2s0 és c3s0 fájlok négy kazettás tárolóeszközt határoznak meg. A fájlszalag és a szalag két tekercses mágneses tárolóeszközöket határoz meg. Az n-nel kezdődő fájlok ugyanarra az eszközre vonatkoznak, csak a szalag nem kerül visszatekerésre használat után, míg más fájlok használata esetén a szalag visszatekerése történik, amikor az azt használó program leáll. Egyes rendszereken ezeknek a fájloknak más a neve, de mindig a /dev könyvtárban találhatók, és a rendszerrel együtt járó szótár részletes leírást tartalmaz az eszközökről és a hozzájuk tartozó fájlokról. Az extX fájlrendszer adatpufferelést használ az I/O műveletekhez. Egy információblokk beolvasásakor a kernel I/O műveleti kérést ad ki több szomszédos blokknak. Az ilyen műveletek nagymértékben felgyorsítják az adatok visszakeresését a fájlok egymás utáni olvasásakor. Adatok fájlba írásakor az extX fájlrendszer új blokkot írva előre legfeljebb 8 szomszédos blokkot helyez egymás mellé. Ez a módszer lehetővé teszi a fájlok összefüggő blokkokba helyezését, ami felgyorsítja az olvasást, és lehetővé teszi a rendszer magas teljesítményének elérését.
Alagutak használata
következtetéseket
16.1. A paranccsal végrehajtó
A kimenet átirányítása egy fájlba
I/O átirányítás Linuxban
Normál bemenet és standard kimenet
I/O átirányítás
Rögzített parancsok használata (csővezeték)
Roncsolásmentes kimenet átirányítás
Bemenet és kimenet átirányítása
5.5.1 Operátorok >,< и >>
5.5.2 Üzemeltető |
5.5.3 Szűrők
$ cd /dev
$ ls -l
a talpon lévő rendszer vezérlőpultja
dsk darabok a lemezen
fd0 hajlékonylemez 1
mem memória
lp nyomtató
lp0 párhuzamos port 0
. . .
gyökér rész a lemezen a gyökér fájlrendszer számára
csere csere részt
syscon konzol alternatív neve
A systty a rendszerkonzol másik neve
terminálcímtár
ttyS0 soros port 0 (COM1)
. . .
A speciális fájl inode-ja információkat tartalmaz az eszköz osztályáról, típusáról és számáról. Az eszközosztály karakterenként és blokkonként határozza meg az eszközöket. Példa a karakterenkénti cserével rendelkező eszközre a billentyűzet. Az ilyen típusú eszközökkel kommunikációt biztosító speciális fájlokat bájtorientáltnak nevezzük. A blokkeszközöket nagy információtömbök cseréje jellemzi, ami felgyorsítja és hatékonyabbá teszi az adatcserét. Minden lemezeszköz támogatja a blokkcserét, az őket kiszolgáló speciális fájlokat blokkorientáltnak nevezzük. A speciális fájlok nem tartalmaznak karakterinformációkat, így a hosszuk nincs feltüntetve a könyvtár listában.
a /dev/dsk/os1 csatolása
mount /dev/dsk/os1 mint /usr/
A #/sbin/mount/dev/dsk/osl/usr1 a /dev/dsk/osl fájlt a /usr1-re csatlakoztatja
#/sbin/mount/dev/dsk/flt/a a /dev/dsk/flt az /a-ra csatlakozik
Annak a könyvtárnak, amelyhez a csatolt fájlrendszer csatolva van, jelenleg üresnek kell lennie, mivel a tartalma nem lesz elérhető a fájlrendszer csatlakoztatása közben.
# /sbin/umount /b
# /sbin/umount /dev/dsk/0s2
A LINUX rendszerben a lemezmeghajtóknak sajátos jelölései vannak. LINUX rendszerben a felhasználó soha nem szembesül azzal a problémával, hogy pontosan meg kell adnia azt a fizikai eszközt, amelyen az információ található. LINUX-ban tetszőleges számú külső eszköz nagyon nagy lehet, így a felhasználónak csak a könyvtár nevével kell foglalkoznia, ahol a számára szükséges fájlok találhatók. Minden fájlrendszert egyszer csatolnak, általában a rendszerindításkor. A fájlrendszerek távoli számítógépekről is felszerelhetők bizonyos könyvtárakra.
$ 1s /dev/dsk
0s0 1s0 c0t0d0s0 c0tld0s0 f0 f05q f13dt fld8d
0sl 1sl c0t0d0sl c0tld0sl f03d f05qt f13h fld8dt
0s2 1s2 c0t0d0s2 c0tld0s2 f03dt f0d8d f13ht fld8t
. . .
$
vezérlővel d lemez s rész
Tehát a 0s0 általában egyenértékű a c0t0d0s0-val, a 0sl pedig a c0t0d0sl, és a háromkarakteres partíciónevek csak a 0 számú lemezvezérlő rövidítése.
$ 1s /dev/rmt
c0s0 cls0 c3s0 ntape ntapel szalagszalag