Most leírjuk a Linux legnépszerűbb lemez-fájlrendszerét - ext2. A Linux első kiadása a Minix 1 fájlrendszert használta, amelynek rövid fájlnevei és a maximális fájlmérete 64 MB. A Minix 1 fájlrendszer végül az első kiterjesztett ext fájlrendszer váltotta fel, amely hosszabb fájlneveket és nagyobb fájlméretet használhat. Köszönhetően alacsony hatékonyság (abban az értelemben, a teljesítmény), az EXT rendszer váltotta annak EXT2 szekvenciáját, amely még mindig széles körben használják.

Az EXT2 lemezpartíció tartalmazza az 1. ábrán látható fájlrendszert. 10.17 Elrendezés. A 0 blokkot a Linux rendszer nem használja, és számítógépes terhelési kódot tartalmaz. A 0 blokkot követően a lemezpartíció blokkok tömbökre oszlik (kivéve a lemezhenger határait). Minden csoport a következőképpen szerveződik.

Az első blokk Superblock (Superblock), amely információt tárol a fájlrendszer elrendezéséről, beleértve az i-csomópontok számát, a lemezblokkok számát, a szabad lemezblokkok listájának kezdetét (ez általában több száz elem) ). Ezután követi a csoportos leírót, amely tartalmazza a bit-tömbök helyéről, a csoportban lévő szabad blokkok és I-csomópontok számát, valamint a csoportban lévő könyvtárak számát. Ez az információ fontos, mivel az EXT2 fájlrendszer megpróbálja elosztani a könyvtárakat egyenletesen a lemezen.

Két bites tömbökben, szabad blokkok és ingyenes I-csomópontok rögzítve (ez a minix 1 fájlrendszerből is megkülönbözteti, és megkülönbözteti a legtöbb Unix fájlrendszerből, amelyben a listát szabad blokkokra használják). Az egyes bits tömb mérete egyenlő egy blokkkal. Az 1 KB blokk méretével ez a rendszer korlátozza a blokkblokkok 8192 blokkok és 8192 i-csomópont méretét. Az első szám valódi korlátozás, és a második gyakorlatilag nem. 4 kb-os blokkokkal négyszer többet.

Ezután az i-csomópontok maguk is találhatók. Ezek az 1-ről néhány maximumra vannak számezve. Az egyes i-csomópontok mérete 128 bájt, és pontosan egy fájlt ír le. Az i-csomópont tartalmazza a fiókadatokat (beleértve a teljes visszatérési hívást is, amely egyszerűen az I-csomópontból), valamint elegendő mennyiségű információt tartalmaz, hogy meghatározza a fájladatokat tartalmazó lemezblokkok helyét.

Az I-csomópontok után adatblokkok. Itt minden fájl és könyvtár tárolódik. Ha a fájl vagy könyvtár több blokkból áll, akkor ezek a blokkok nem szükségesek a lemezen. Valójában a nagy fájl blokkjai valószínűleg szétszóródnak a lemezen.

A megfelelő katalógusok I-csomópontok szétszóródnak a lemezblokkok összes csoportjával. Az EXT2 megpróbálta rendes fájlokat szervezni ugyanabban a blokkokban, mint a szülői könyvtár, és az adatfájlok ugyanabban a blokkban vannak, mint a forráskód I-csomópont (feltéve, hogy van elég hely). Ezt az elképzelést a Berkeley Fast File System fájlrendszerből (Mckusick et al., 1984) kölcsönzötték. A bit tömböket használják a válogatott döntések meghozatalára

helyek az új fájlrendszer adatokhoz.

Amikor új fájlblokkok vannak kiemelve, az EXT2 több (nyolc) további blokkot is előzetesen kiválaszt egy (nyolc) további blokkot (a fájl töredezettségének minimalizálása a jövőbeni rögzítési műveletek miatt). Ez a rendszer elosztja a fájlrendszert a lemezen. Jó teljesítményt is tartalmaz (a kapcsolódó hely és a csökkent fragmentáció felé irányuló tendenciája miatt).

A fájl eléréséhez először használnia kell az egyik Linux rendszerhívást (például nyitott), amelyre meg szeretné adni a fájl elérési útját. Ez az út szétszerelve, és a katalógusok összetevői kivonják. Ha a relatív útvonal meg van adva, a keresés a folyamat aktuális katalógusából kezdődik, különben - a gyökérkönyvtárból. Mindenesetre az első könyvtár i-csomópontja könnyen megtalálható: a folyamatleíróban van egy mutató, vagy (gyökérkönyvtár esetében), amelyet egy adott lemezen tárolnak a lemezen.

A könyvtár lehetővé teszi a fájlnevek legfeljebb 255 karakterből (10.18 ábra). Minden könyvtár egy bizonyos számú lemezblokkból áll (így a könyvtár írható a lemez atomino). A könyvtárban a fájlok és könyvtárak elemei nem egy nemorvosi sorrendben vannak (mindegyik elem közvetlenül követi az előzőt). Az elemek nem térhetnek át a blokkok határait, így az egyes lemezek blokkjának végén számos fel nem használt bájt van.

Minden egyes könyvtárbejegyzés az 1. ábrán látható. 10.18 négy fix hosszúságú mezőből és egy változó hosszúságból áll. Az első mező egy 19-es I-csomópontszám a Colossal fájlhoz, 42 a Bigdir könyvtár nagyszerű és 88 fájljához. Az alábbiakban a REC_LEN mező, amely a teljes könyvtár bejegyzés méretét tartalmazza bájtban (esetleg, a név után további helyőrzők mellett). Ez a mező szükséges a következő bejegyzés megtalálásához (abban az esetben, ha a fájlnevet ismeretlen számú bájt kiegészíti). Az ábrán látható, ezt a mezőt a nyíl jelzi. Ezután van egy mezőtípus mező, egy könyvtár, stb. A rögzített hosszúság utolsó mezője tartalmazza a fájlnév hosszát a bájtokban (8, 10 és 6 ehhez a példához). Végül a fájlnév a nulla bájtba kerül, és kiegészítve egy 32 bites határt. További postafiók bájtok követhetők.

Ábrán. A 10.18., B értéket ugyanazt a könyvtárat mutatja, miután a nagy mennyiségű eltávolításra került. Mindez, ami a katalógusban történik - növeli az előző Colossal fájl felvételi méretét, és a távoli térfájlos fájl könyvtári bejárati bájtja az első rekord töltőanyagokká alakul. Ezt követően ezeket a bájtokat új fájl létrehozásakor rögzíthetjük.

Mivel a könyvtárak keresése lineárisan történik, akkor a nagy könyvtár végén lévő rekord keresése sokáig tarthat. Ezért a rendszer támogatja a gyorsítótár-könyvtárakat, amelyekhez a közelmúltban történt hozzáférést. A gyorsítótár keresése fájlnévvel történik, és ha megtalálható, akkor a drága lineáris keresés már nem szükséges. A Dentry objektumot a könyvtár elemek gyorsítótárába írja be az egyes útvonalkomponensek számára, és (az I-csomóponton keresztül) a későbbi útvonalelemek könyvtárában keres (amíg a tényleges i-csomópont megtalálható).

Például az abszolút útvonal (például / usr / AST / fájl) által megadott fájl megtalálásához a következő lépéseket kell végrehajtani. Először is, a rendszer megtalálja a gyökérkönyvtárat, amely általában egy 2-es számú I-csomópontot használ (különösen akkor, ha az 1. számú I-csomópont rossz blokkokkal működik). A megfelelő elemet a könyvtárak gyorsítótárába helyezi (a jövőbeni gyökérkatalóguskeresésekhez). Ezután keres egy "usr" karakterláncot a gyökérkönyvtárban, hogy megkapja az I-csomópont számát a / usr könyvtárba (amely a könyvtár elemek gyorsítótárába is beírja). Ezt az I-csomópontot ezután olvassuk, és a lemezblokkok letöltésre kerülnek, így elolvashatja a / usr könyvtárat, és keresheti az AST vonalat. A megfelelő elem megtalálása után meghatározhatja az I-csomópont számát a / usr / ast. Az I-csomópont számával elolvashatja és megtalálhatja a könyvtár blokkokat. Végül keresünk "fájlt", és megtaláljuk az i-csomópont számát. Így a relatív útvonal használata nemcsak kényelmesebb a felhasználó számára, hanem csökkenti a rendszer működési mennyiségét is.

Ha a fájl elérhető, a rendszer megkerüli az I-csomópont számát, és az I-csomópont táblázat indexként használja (a lemezen) a megfelelő I-csomópont kereséséhez, és olvassa el a memóriába. Ez az I-csomópont az I-csomópont táblázatba kerül (I-csomópont táblázat) - a rendszermag adatszerkezete, amely tartalmazza az összes I-csomópontot a jelenleg nyitott fájlok és könyvtárak számára. Az I-csomópontok formátumának tartalmaznia kell (legalábbis) minden olyan mezőt, amely visszaadja a rendszerhívás statot, hogy a stat hívás működjön (lásd 10.10. Táblázat). A lapon. 10.13 mutatja a Linux fájlrendszerben támogatott I-csomópont szerkezet mezőket. Az I-csomópont tényleges szerkezete sokkal több mezőt tartalmaz, mivel ugyanezt a struktúrát használják a könyvtárak, eszközök és egyéb speciális fájlok képviseletére. Az I-csomópont szerkezete szintén a mező jövőbeni használatára is fenntartja. A történet kimutatta, hogy a fel nem használt bitek hosszúak maradnak.

Most nézzük meg, hogy a rendszer elolvassa a fájlt. Emlékszel arra, hogy a könyvtári eljárás tipikus felhívása a rendszerhívás elindításához az alábbiak szerint olvasható:

n \u003d olvasás (FD, puffer, nbytes);

Amikor a kernel megkapja az irányítást, akkor mindent elindíthat - ez a három paraméter és információ belső tábláiban (a felhasználóhoz kapcsolódik). Ezeknek a belső tábláknak az egyik eleme a fájlleírók tömbje. A fájlleírók indexelve, és egy elemet tartalmaz minden egyes megnyitott fájlhoz (a maximális összeghez, az alapértelmezés általában 32).

Az ötlet az, hogy elkezdje ezt a fájlleíróval, és befejezze a megfelelő buborékot. Nézzünk egy teljesen lehetséges rendszert: Helyezzük el a Pozel mutatót a fájlleírók táblázatba. Az egyszerűség ellenére ez a módszer (sajnos) nem működik. A probléma a következő. Minden egyes fájlleíróval egy mutatót kell csatlakoztatni a fájlban, amely meghatározza a bájtot a fájlban, ahonnan a következő olvasási vagy felvételi művelet kezdődik. Hol kell tárolni ezt a mutatót? Az egyik lehetőség az, hogy a buszok asztalába helyezzük. Ez a megközelítés azonban nem fog működni, ha több olyan folyamat, amely egyidejűleg nem kapcsolódik egymáshoz, ugyanazt a fájlt nyitja meg, hiszen minden folyamatnak saját mutatójával kell rendelkeznie.

A megoldás második megoldása az, hogy a mutatót a táblázat leírásaiba helyezzük. Ebben az esetben minden egyes fájl megnyitja a folyamat saját pozícióját a fájlban. Sajnálatos módon egy ilyen rendszer nem működik, de a hiba oka ebben az esetben nem olyan nyilvánvaló, és a fájlok megosztása a Linux rendszerben. Tekintsük az 5 shell parancsfájlt, amely két parancsból áll (P1 és P2), amelyet viszont meg kell végezni. Ha a parancsfájlt a parancssor hívja

várható, hogy a P1 parancs kiírja a kimenetét az X fájlt, majd a P2 parancs is írja a kimenetét az X fájlt, kezdve attól a helytől, ahol a P1 parancs megállt.

Amikor a héj elindítja a P1 folyamatot, az X fájl először üres lesz, így a P1 parancs egyszerűen elindul a 0. pozícióban lévő fájlba. Azonban, amikor a P1 befejezi munkáját, egy bizonyos mechanizmusnak szüksége lesz arra, hogy a P2-folyamat Lásd, mint egy kezdeti pozíciót, nem 0 (és ez hogyan fog megtörténni, ha a fájlban szereplő fájlleírók helyzete a táblázatban van), és a PI értékének értéke.

Az a mód, ahogy az az 1. ábrán látható. 10.19. A hangsúly az új táblázatba való belépéshez - az Open File Leírás Táblázat (Open File Leírás Táblázat) - A fájlleírók és az i-csomópontok táblázata között, és tárolja a mutatót a fájlban (valamint az olvasási / írási bit) . Az ábrán a szülői folyamat a héj, és a lánya először a PI-folyamat, majd a P2 folyamat. Amikor a shell létrehozza a PI folyamat a felhasználó struktúrával (ideértve az fájlleírókkal táblázat) pontos másolata az azonos membrán szerkezet, így mindkettő tartalmazza a mutató azonos táblázata leírása a megnyitott fájlokat. Amikor a feldolgozó befejezi munkáját, a Shell fájlleíró továbbra is megadja a nyílt fájlok leírás táblázatát, amely tartalmazza a fájl P1 pozícióját. Amikor most a Shell létrehozza a P2 folyamatot, akkor az új gyermekfolyamat automatikusan örökli a fájl pozícióját, míg nem egy új folyamat, sem a héj köteles megismerni a pozíció aktuális értékét.

Ha bármilyen idegen folyamat megnyitja a fájlt, akkor megkapja a saját bejegyzését a táblázatban leírási táblázatban a fájl pozíciójával, nevezetesen szükséges. Így a nyitott fájl leírásának táblázatának feladata, hogy lehetővé tegye a szülő és a gyermekfolyamatok megosztását egy mutató megosztása a fájlban, de a külföldi folyamatok személyes mutatókat osztanak ki.

Tehát (Visszatérve az olvasás olvasásának problémájához), megmutattuk, hogy a fájl és az I-csomópont helyzetét meghatározzuk. Az I-csomópont az első 12 fájlblokkok lemezcímét tartalmazza. Ha a fájl helyzete az első 12 blokkba esik, a kívánt fájlblokk olvasható, és az adatok átmásolódnak a felhasználóra. A fájlok esetében a hossza meghaladja a 12 blokkot, az I-csomópont tartalmazza az egyetlen közvetett blokk (egy közvetett blokk) lemez címét (10.19. Ez a blokk tartalmaz további lemezblokkok lemez címét. Például, ha a blokk mérete 1 kb, és a lemezcím 4 bájtot vesz igénybe, az egyetlen közvetett egység akár 256 lemezcímet is tárolhat. Ez a rendszer lehetővé teszi a 268 kb-ig terjedő fájlokat.

ext2. (másnak is nevezik ext2fs.) - Második kiterjesztett fájlrendszer(A második kiterjesztett fájlrendszer) a Linux kernelre épülő fájlrendszer. A Teremtő és a Developer Ext2 remy kártya. Az EXT2 fájlrendszert a régi, az előző verzióért cserébe építették.

Az ilyen mutatók szerint a sebesség és a teljesítmény, ez a fájlrendszer referenciaként szolgálhat. Ezt mondják a fájlrendszer teljesítményének eredményeiről. Például a Dell Technikai Központot végző következetes olvasás és írás sebességének vizsgálata során az EXT2 fájlrendszer meghaladja az ext3-at, és alacsonyabb az olvasási sebességnél, csak a modernebb ext4-ben.

Az Ext2 fő hátránya, hogy nem naplózási fájlrendszer. Ez a hátrány azonban a következő fájlrendszerben történt - ext3.

az EXT2-t flash kártyákon és szilárdtest-state meghajtókon (SSD) használják, mivel a naplózás hiánya előnyös, ha a rögzítési ciklusok számának korlátozásával rendelkező meghajtókkal való együttműködés.

Az ext2 létrehozásának története.

A Linux rendszer gyors fejlődésének idején a Minix fájlrendszert használta. Nagyon nagy stabilitás volt, de 16 bites volt. Ennek eredményeképpen szigorú korlátozást létezett 64 MB-ben a szakaszba. Ezenkívül a fájlnév maximális hossza volt, amely 14 karakter volt.

Ezek az aggregátum korlátozásai voltak a "fokozott fájlrendszer" (tehát a kifejezés "fejlesztésének oka Bővített fájlrendszer »). Volt egy feladata, hogy megoldja a két minix kulcsproblémát. Az új fájlrendszer 1992 áprilisában jelent meg. EXT volt, kiterjesztette a fájl méretét 2 gigabájtra, és a fájlnév határidejét 255 karakterben telepítette.

Az új fájlrendszer sikere ellenére azonban nagyon sok megoldatlan probléma maradt. Például nem volt támogatás külön hozzáférésre, nincs időbélyeg az adatmódosításról. A szükséges EXT2 fájlrendszer következő verziójának létrehozására szolgáló motívum (" Második kiterjesztett fájlrendszer »). Ext2 alakult 1993 januárjában, akkor is végrehajtja a megfelelő ACL hozzáférés-vezérlési listák és a kiterjesztett fájlattribútumokat.

Logikai szervezet EXT2.

Az ext2 könyvtári hierarchia grafikonja hálózat formájában jelenik meg. Ez annak köszönhető, hogy az egyik fájl azonnal beírhat több könyvtárba.

Minden fájltípus szimbolikus nevekkel rendelkezik. Hierarchikusan szervezett fájlrendszerekben háromféle nevet használnak: egyszerű, kompozit és rokon. Így az ext2-ben. Egyszerű név esetén a korlátozás az, hogy hossza nem haladhatja meg a 255 karaktert, emellett a NULL Symbol és a Slash-nak jelen kell lennie a névben.

Ami a Null Symbol-t illeti, a korlátozások a SI nyelv soraiban szereplő sorok ábrázolásához kapcsolódnak, egy Slash szimbólum esetében minden, hogy a könyvtárak közötti elválasztó jellegű.

A teljes név az összes könyvtár egyszerű szimbolikus nevének lánca, amelyen keresztül a gyökérből származó útvonal fut a fájlhoz. Az Ext2-ben a fájl több könyvtárba léphet, ez azt jelenti, hogy több teljes név is lehet (egy fájl néhány teljes név). De egyébként, a teljes név meghatározza a fájlt.

EXT2 attribútumok:

• típus és hozzáférési jogok a fájlhoz,
• tulajdonos, hozzáférési csoport,
• információk az engedélyezett műveletekről,
• létrehozási idő, utolsó hozzáférési dátum, utolsó változás dátuma és az utolsó eltávolítási idő,
• aktuális fájlméret
• fájl specifikáció:

• rendszeres fájl
• katalógus,
• a készülék byte-orientált eszköz,
• fájlblokk-orientált eszköz,
• nevezett csatorna
• szimbolikus link

• a megszállt blokkok száma,
• mások

A fájlok attribútumai speciális táblázatokban vannak, és nem könyvtárakban, mivel egyszerű fájlrendszerekben lehet. Ennek eredményeképpen a könyvtárnak van egy nagyon egyszerű szerkezete, amely két részből áll: az indexleíró és a név száma.

Fizikai szervezet EXT2.

A lemezszakasz szerkezete

Az ext2 részeként megkülönböztethető a következők:

• blokkok és blokkok blokkjai;
• index leíró;
• superblock.

A teljes lemezmegosztási hely rögzített blokkokra van osztva, blokkolja több szektor méretét (1024, 2048, 4096 vagy 8192 bájt). A blokk mérete akkor van megadva, amikor fájlrendszert hoz létre a lemezszakaszon. Minden blokk hozzárendelt sorszám. A fragmentáció csökkentése és a merevlemezfejek mozgásainak száma, nagy adathordozók olvasásakor a blokkok csoportokba vannak kombinálva.

A fájlrendszer alapkoncepciója egy indexleíró (más néven is) inode - információs csomópont.). Ez egy speciális szerkezet, amely információt tartalmaz az attribútumokról és a fizikai fájl helyéről. Az index dekapcsait egy blokk blokkok elején lévő táblázatba sorolják. A Superblock az EXT2 fájlrendszer fő eleme. Általános információkat tartalmaz a fájlrendszerről. A Superblock 1024 bájtban található a szakasz kezdetétől. A szuperblokk integritásának meghatározza a fájlrendszer funkcionalitását. Az OS számos biztonsági másolatot készít a szuperblokkról - a partíció sérülése esetén. A Superblock után a következő blokkban van egy globális leíró asztal - A blokkcsoportok leírása egy tömb formájában, általános információkkal az összes blokkcsoportról.

Blok csoport

Minden ext2 blokk blokk csoportba kerül. Minden csoport esetében külön bejegyzés jön létre a globális leíró táblázatban. Ez a bejegyzés tárolja a fő paramétereket, például: a bittérképek és táblázatok blokkszáma, a csoportok szabad blokkjai száma, a könyvtárakat tartalmazó index leírások száma.

Bit térkép blok - Ez egy olyan rendszer, amelyben minden bit tájékoztatja, hogy a fájlnak megfelelő fájl van-e. Ha a bit 1, akkor a blokk elfoglalt. Hasonló funkciót végeznek az indexleírók bitképe: azt mutatja, hogy mely index leírók foglaltak, és ami nem. A Linux kernel a csoportok inode könyvtárát is elosztja csoportokban, és az inode fájlokat - a szülői katalógushoz tartozó csoportba lép. A hátralévő hely megjelenik a táblázatban, mivel az adatok a fájlok tárolásához vannak hozzárendelve.

Adatvédelmi rendszer

Az adatok címzési rendszere a fájlrendszer egyik legsúlyosabb és legfontosabb eleme. Köszönjük, hogy a kívánt fájl a lemezen található számos üres vagy foglalt blokk között van.

az EXT2 a következő fájlblokk címzési rendszert alkalmazza. A fájl címének tárolásához 15 mezőt izolálunk, amelyek mindegyike 4 bájtból áll. Ha a fájl 12 blokkba illeszkedik, az adott klaszterek száma az első tizenkét címben szerepel. Ha a fájlméret meghaladja a 12 blokkot, a következő mező tartalmazza a következő fürtcímet, amelyben a következő fájlblokkok száma található. Tehát a tizenharmadik mezőt közvetett címzésre használják.

A blokk maximális méretével 4096 bájtban a 13. mezőnek megfelelő klaszter legfeljebb 1024 számot tartalmazhat a következő fájlblokkokhoz. Ha a fájlmérete meghaladja a 12 + 1024 blokkot, akkor a 14. mezőt használják, amelyben a 1024 klaszterszámot tartalmazó klasztercím található, amelyek mindegyike 1024 fájlblokkra vonatkozik. Már van kettős közvetett címzés. És ha a fájl több mint 12 + 1024 + 1048576 blokkot tartalmaz, akkor az utolsó 15. mezőt hármas közvetett címzésre alkalmazzák.

Az ilyen címzési rendszer lehetővé teszi, hogy fájlokat készítsen, több mint 2 TB, maximális blokkmérettel 4096 bájtban.

Ha két operációs rendszere van, a Windows és a Linux telepítve van, akkor valószínűleg azt szeretné, hogy az ingyenes operációs rendszer részei közvetlenül a Windows alatt közvetlenül a számítógépen keresztül kerüljenek be.

Sajnos a Linux OS szakaszok támogatását nem biztosítják. És hiába. Úgy tűnik számomra, hogy lehet, hogy egy gyönyörű gesztus a Microsoftból.

A probléma lényege az, hogy a Windows az NTFS fájlrendszert használja, és a Linuxnak saját módja van a fájlok megszervezésére, a kiterjesztett fájlrendszerre, amelynek legújabb verziója van a 4. sorszámmal.

A Linux jobban barátságos a felhasználóknak, nem pedig a kereskedelmi húgának: Linux alatt, az alapértelmezettet a Windows NTFS fájlrendszer támogatja. Természetesen nem tudod telepíteni a Linuxot az NTFS részre, de ebből olvashat és írhat adatokat.

Ext2 IFS.

Az EXT2 IFS támogatja a Windows NT4.0 / 2000/2000/2003/2003 / Vista / 2008 verzióit az x86 és az x64, és lehetővé teszi a Linux ext2 szakaszok tartalmát, és rögzítheti rájuk is. A segédprogram beállítja a EXT2FS.SYS rendszer vezető, amely kitágul Windows képességek, és magában foglalja a teljes mértékben támogatja a EXT2 benne: partíciók ext2 vannak rendelve a betűket lemezek, valamint a fájlok és mappák jelennek meg őket a dialógusok az összes alkalmazást, például a , az Explorerben.

Ext2 fsd.

Az EXT2 FSD ingyenes illesztőprogramja a Windows rendszerekhez (2K / XP / VISTA / 7 VERSIONS X86 és X64). Mint az előző segédprogram, amely lényegében is a vezető, magában foglalja az ext2 fájlrendszer teljes támogatását az ablakokban.

LTOOLS - egy parancssori segédprogramkészlet, amely lehetővé teszi az adatok olvasását a Linux ext2, az ext3 és a Reiserfs (Standard Linux fájlrendszerek) a DOS vagy a Windows-ból.

A program egy változata grafikus héjjal (Java-on írt) - az LTOOOLSGUI, valamint egy grafikus héjú változat.

Ext2read.

A desszert mindig a leginkább finom.

Az Ext2Read egy vezetőfájlon alapuló segédprogram, amely lehetővé teszi az ext2 / ext3 / ext4 szakaszok megtekintését és írását. Támogatja az LVM2-et, és amely megkülönbözteti a felülvizsgálat egyéb programjait, az EXT4 fájlrendszert. Beágyazott támogatás rekurzív másolási könyvtárakhoz.

És itt van a második desszert. Kezdetben azt mondták, hogy a Microsoftból származó jó gesztus alapértelmezés szerint a Windows Linux szakaszok támogatását tartalmazza.

A gesztus még mindig a Linux 20. évfordulóján készült. Nézd meg magad.

Ez minden. Kösz a figyelmet. Fogok harcolni a májusi bogarakból. Ez a tavasz sok sooo. 🙂

Vladimir Miskov

Fájlrendszer-architektúra ext2

A cikk megvitatja a Linux operációs rendszer EXT2 fájlrendszerének logikai struktúráját.

Az EXT2 fájlrendszer alapvető összetevői

Mint minden Unix fájlrendszerben, az alábbi összetevők különböztethetők meg az EXT2 fájlrendszer részeként:

• blokkok és blokkok blokkjai;
• információs csomópont;
• superblock.

Blokkok és blokkok blokkjai

A teljes lemezmegosztási hely rögzített méretű blokkok, többszektor méret - 1024, 2048 és 4096 bájt. A blokk mérete akkor jelenik meg, amikor fájlrendszert hoz létre a merevlemezen. A kisebb blokkméret helyet takarít meg a merevlemezen, de korlátozza a maximális fájlrendszer méretét is. Minden blokk szekvenciaszámmal rendelkezik. A merevlemezfejek széttöredezettségének és mozgásának csökkentése érdekében a nagy adathordozók olvasásakor a blokkokat csoportokba csoportosítják.

Információs csomópont

A fájlrendszer alapkoncepciója az információs csomópont, az információs csomópont vagy az inode. Ez egy speciális szerkezet, amely információkat tartalmaz az attribútumokról és a fizikai fájl helyéről. A fájl attribútuma a típus (normál fájl, könyvtár stb.), Hozzáférési jogok, tulajdonos azonosító, méret, létrehozási idő. A fizikai helyről szóló információk a fájladatok tartalmazó abszolút blokkszámok sorozata.

Szuperblock

A Superblock az EXT2 fájlrendszer fő eleme. A következő fájlrendszer információi (hiányos lista) tartalmazza:

• a blokkok és inodódok száma a fájlrendszerben;
• a szabad blokkok száma és inode a fájlrendszerben;
• fájlrendszer blokk mérete;
• blokkok száma és inode a csoportban;
• méret inode;
• fájlrendszer azonosítója;
• az első adatblokk száma.

Más szóval, ez egy szuperblokkot tartalmazó blokkszám. Ez a szám mindig egyenlő 0, ha a fájlrendszer blokkjának mérete nagyobb, mint 1024 bájt, és 1, ha a blokk mérete 1024 bájt.

A fájlrendszer funkcionalitása közvetlenül a szuplock integritásától függ. Az operációs rendszer számos biztonsági másolatot készít a Superblock-ról, hogy képes legyen visszaállítani azt kárfogyasztás esetén. A fő másolat található az offset 1024 bájt a kezdetektől a szakasz, amelyen a fájlrendszer létrehozásakor (az első 1024 bájt van fenntartva az operációs rendszer bootloader).

Az EXT2 fájlrendszer korai verziói a szuperblokk másolatát hozták létre minden blokkblokk elején. Ez a lemezterület nagy veszteségéhez vezetett, így később csökkentették a szuperblokk biztonsági másolatának számát, és a 0, 1, 3, 5 és 7 blokkok csoportjait elhelyezésükhöz rendeztük.

Blok csoport formátuma

Az ext2 fájlrendszer általánosított szerkezeti diagramját az 1. ábrán mutatjuk be. egy.

Majdnem minden blokkcsoport azonos formátumú. Mindegyik csoportban az információs blokkok mellett a blokkok és inódcsoportok foglalkoztatására vonatkozó információkat bitkép formájában tárolják. A 0 blokkok blokkja magában foglalja a csoportok szuperblokkjait és asztalleíróit, amelyeket az alábbiakban figyelembe vesszük.

A foglalkoztatási blokkok betitása általában a csoport első blokkjában található. Ha a csoportban lévő biztonsági másolat jelen van, a bitmap a csoport második blokkjában található. A bitmap mérete egy blokk. A kártya minden egyes bitje a blokk állapotát jelöli. Ha a bit be van állítva (1), a blokk foglalt, ha a blokk visszaáll (0) - A blokk ingyenes. A csoport első blokkja megfelel a kártya nulla bitjének, a második blokknak - az első bit stb.

Az azonos csoportban található inode-ot az asztalban gyűjtik össze. A BITE foglalkoztatási térkép inode csoportban minden bit jellemzi az elem állapotát az inode csoportasztal táblázatában.

A blokkok minden blokkját a blokkcsoport leíró segítségével írják le. A csoportos fogantyú olyan szerkezet, amely információt tartalmaz a blokkok blokkok bitképeinek címével, az inode elfoglalt bitmap és a megfelelő csoport beadási táblázata. Az összes csoportos leírót a csoportos leírók táblázatban gyűjtik össze, amely egy blokkcsoportban van tárolva.

Fájl olvasási algoritmus

Mindegyik inode, valamint a blokknak van egy sorszáma, amely egyedi a fájlrendszeren belül, és csak egyfájlt tartalmaz információkat. Így a fájl tartalmának eléréséhez ismernie kell a megfelelő beadott inode sorszámát.

Mint már említettük, a fizikai fájl helyéről szóló információ az inode-ban található. Ez az információ 32 bites blokkszámok sorozatát tartalmazza, amelyek fájladatokat tartalmaznak (1. ábra). Az első 12 szám közvetlen linkek az információs blokkokhoz (közvetlen blokkok száma). A 13. szám közvetett link (közvetett blokkszám). Tartalmazza a blokk címét, amelyben az információs blokkok címét tárolják. A 14. szobában kettős közvetett link (kettős blokkszám), a 15. szám egy hármas közvetett kapcsolat (hármas blokkok száma).

Az inode fájlnév nem szerepel, a fájlnevek és az inode szekvenciaszámok közötti megfelelőség beállítása a könyvtárakon keresztül történik.

Katalógusok

A UNIX és POSIX rendszerekben található fájlokat egy fa hierarchikus fájlrendszerben tárolják. A fájlrendszer gyökere a "/" szimbólum által jelzett gyökérkönyvtár. A fájlrendszerben lévő összes közbenső csomópont egy könyvtár. A fájlrendszer fa végső csúcsai üres könyvtárak vagy fájlok. A fájl abszolút útjának neve a megadott fájlhoz vezető könyvtárak nevét tartalmazza, a gyökérkönyvtárral kezdődően. Tehát a pálya neve /home/test.file azt jelenti, hogy a Test.file fájl található a home könyvtár, amely viszont, található a gyökér katalógusban „/”.

A katalógus, valamint a fájl, az inode használatával történik. A könyvtár tartalma a rekordok tömbje, amelyek mindegyike tartalmaz információt az aktuális könyvtár "belsejében" fájlról.

A könyvtár rekordja a következő formátumban van:

• szekvencia szám inode fájl;
• rögzítési hossz bájtban;
• fájl név;
• a fájlnév hossza.

Az inode fájl keresése mindig a gyökérkönyvtárral kezdődik. Például annak érdekében, hogy az inode sorszám a gyökérkönyvtárban, az operációs rendszernek kell szerezni az a root könyvtárban találja meg azt a fájl nevét, és távolítsa el a fájlt inode szám a lemezen.

A több inódszámszámot a fájlrendszer fenntartja, listájukat a fejléc fájl tartalmazza:

* Különleges inodh számok

#Define ext2_bad_ino 1 / * rossz blokkok inode * /

#Define ext2_root_in 2 / * root inode * /

#Define ext2_acl_idx_in 3 / * ACL inode * /

#Define ext2_acl_data_ino 4 / * ACL inode * /

#Define ext2_boot_loader_ino 5 / * boot betöltő inode * /

#Define ext2_undel_dir_ino 6 / * undelete könyvtár inode * /

A gyökérkönyvtár rögzítéséhez az inode a 2. számon (root inode) van fenntartva. Ez az inode a 0 blokk blokkjában van, és a második pozíciót veszi a csoport inode táblázatában. Az első nem kötelező inode számát a szuperblokkban tárolják.

Az inode szekvencia számának meghatározása után a rendszermag kiszámítja azt a csoportszámot, amelyben ez az inode található, és pozíciója az inode csoportasztalnál. Figyelembe véve az inode-ot ebből a pozícióból, az operációs rendszer teljes fájlinformációkat kap, beleértve a fájlokat, amelyekben a fájl tartalmát tárolják.

Az inode-inodén található blokk számát a képlet alapján számítjuk ki:

csoport \u003d (inode_num - 1) / inodes_per_group

hol:

• csoport.- a blokkblokk kívánt számát;
• inode_num - a fájl meghatározó sorszáma;
• inOodes_per_csoport - A csoport inode száma (ez az információ a szuperblokkban van).

Az inode-pozíciót az inode csoport táblázatban a képlet határozza meg:

index \u003d (inode_num - 1)% inOodes_per_grupa

ahol az index egy inode pozíció a táblázatban.

Tekintsünk egy példát a Test.file fájl tartalmának megszerzésére a gyökérkönyvtárban. A /test.file fájl elolvasása:

• a gyökérkönyvtárak sorában talál egy bejegyzést a fájlról;
• kivonja az inode fájl sorszámát, kiszámolja a csoportszámot, amelyben ez az inode található;
• a csoport leírójából kivonja az inode csoportasztal címét;
• kiszámolja az inode pozíciót ebben a táblázatban;
• olvassa el az inode fájlt;
• az inode-ból a címblokk címeinek kivonásához és a blokkokban található információk olvasása.

Ábrán. 2 Részletek Megjeleníti a / tesztfájl olvasását. Fájl.

1-6. Lépés - A gyökérkatalógus olvasása:

1. A 0 blokkok csoportjától a táblázat leírásai olvashatók.
2. Az asztalleíró táblázatból a 0 blokkcsoport csoportja letöltésre kerül, és az inode csoport címe olvasható.
3. A 0 blokkcsoportból 0 elolvassa az inode asztalt.
4. A gyökérkönyvtár beágyazási sorszáma rögzítve van és 2, így a második elem a 0 inode csoportból olvasható, amely tartalmazza a blokkcímet a gyökérkönyvtár tartalmával. Tegyük fel, hogy ez a készülék az A. blokkok blokkjában található.
5. Az A blokkok csoportjától a gyökérkönyvtár rekordjait tartalmazó blokk olvasja.
6. A "TEST.FILE" nevű bejegyzés rekordját keresik. Ha ilyen rekord található, a "Test.file" inode sorozat került letöltésre.

Az inode szám meghatározásával hozzáférhet a fájl információs blokkjaihoz (7-11. Lépés):

7. A csoport száma számítják, amelyben ezt a inode található, és pozícióját a inode-táblázat (tegyük fel, hogy a csoport szám egyenlő a B, és a helyzet a táblázatban - x).
8. A csoportos leírók táblázatból távolítsa el a B részcsoport leíróját, és a blokk blokkjának beadási táblázatának címét olvassa el.
9. Az inode táblázat a B blokkcsoportból olvasható.
10. A blokkok blokkok beolvasási táblájából B inode, az X pozícióban helyezkedik el.
11. A READ inode-ból a tartalomfájl / test.file blokk címe lekérhető, és az információ a blokkról a megadott címmel olvasható.

A fájl olvasási algoritmus szoftverének megvalósítása

Forrásadatok: A merevlemez partíciója van, amelyen az EXT2 fájlrendszer létrejön. Ez a rész megfelel az eszköz / dev / hda3 fájlnak. A szakasz gyökérkönyvtárában a Home Subdirectory létrejön, és tartalmazza a következő tartalom tesztét.

A citrus délen élne?

Igen, de hamis eset!

1234567890-=

Nem hiszem, hogy rossz, nem értelmetlen, hanem a Telegráfiák képzésének folyamata a korábbi Szovjetunió kommunikációjának csapataiban!

Figyelem! Figyelembe kell venni egy fontos pontot. A létrehozott fájl nem kerül azonnal rögzítve a lemezen, és először a lemezpufferbe esik. A fenti algoritmus szerint azonnali megpróbáltatás, hogy a fájl tartalmának megszerzése ne vezessen semmit, mivel a fájlról szóló információ nem fizikailag a lemezen. Szükséges "kényszeríteni" a rendszert a lemez puffer rögzítésére a lemezen. Ennek legegyszerűbb módja az újraindítási művelet végrehajtása. Ezért a fájl létrehozása után indítsa újra a rendszert.

Feladatunk az eszköz / dev / hda3 fájlt használja, hogy elolvassa az /home/test.file fájlt az információs blokkokhoz való közvetlen hozzáféréssel.

Tekintsük a program végrehajtását, amely végrehajtja ezt a műveletet.

Fejléc fájlok:

#Inlude.

#Inlude.

#Inlude.

#Inlude.

#Inlude.

#Inlude.

A fejléc fájl meghatározza az ext2 fájlrendszer - szuperblokk, a blokkcsoport leíró, információs csomópont, könyvtár belépés fő összetevőit leíró szerkezeti típusokat.

Tekintsük röviden az egyes struktúrákban szereplő mezőket:

1. Struct ext2_super_block Superblock struktúra:
   • __U32 S_INODES_COUNT- a fájlrendszerben lévő inode teljes száma;
   • __U32 S_Blocks_Count.- a fájlrendszerben lévő blokkok teljes száma;
   • __U32 S_Free_blocks_Count.- a szabad blokkok száma;
   • __U32 S_Free_inodes_Count.- a szabad inode száma;
   • __U32 S_FIRST_DATA_BLOCK- az első adatblokk száma (a blokkszám, amelyben a szuperblokk található);
   • __U32 S_LOG_BLOCK_SIZE. - Ez az érték a blokk méretének kiszámításához használható. A blokk méretét a következő képlet határozza meg: blokk méret \u003d 1024<< s_log_block_size;
   • __U32 S_Blocks_per_Group - a csoport blokkjai száma;
   • __U32 S_INODES_PER_GROUP - a csoport inode száma;
   • __U16 S_Magic - ext2 fájlrendszer-azonosító (0xef53 aláírás);
   • __U16 s_inode_size - az információs csomópont (inode) mérete;
   • __U32 S_First_ino. - Az első nem felmérett inode száma.
2. Struct ext2_group_desc csoport leíró tervezési struktúra:
   • __U32 bg_block_bitmap- a csoportblokkok foglalkoztatásának bitképe;
   • __U32 bg_inode_bitmap- a foglalkoztatás inode csoportjának betitása;
   • __U32 bg_inode_table - Az inode asztal címe.
3. Struct Ext2_inode Információs csomópont szerkezet:
   • __U16 I_MODE a fájl típusát és a hozzáférési jogokat. A fájl típusának beállítása a mező 12-15 bitjei:
     • 0xa000.- szimbolikus kapcsolat;
     • 0x8000.- normál fájl;
     • 0x6000.- blokk blokk eszköz;
     • 0x4000- katalógus;
     • 0x2000.- szimbolikus eszközfájl;
     • 0x1000- FIFO csatorna.
   • __U32 I_SIZE. - méret bájtban;
   • __U32 i_atime.- az utolsó fájl hozzáférési idő;
   • __U32 i_cime - Fájlteremtési idő;
   • __U32 i_mtime.- az utolsó módosítás ideje;
   • __U32 i_blocks. - a fájl által elfoglalt blokkok száma;
   • __U32 i_block - Az információs blokkok címei (beleértve az összes közvetett linket is).

Az ext2_n_blocks érték a fájlban található:

* Az adatblokkokhoz viszonyított konstansok

#Define ext2_ndir_blocks 12.

#Define ext2_ind_block ext2_ndir_blocks.

#define ext2_dind_block (ext2_ind_block + 1)

#Define ext2_tind_block (ext2_dind_block + 1)

#Define ext2_n_blocks (ext2_tind_block + 1)

4. Struct ext2_dir_entry_2 Directory belépési struktúra:

#Define ext2_name_len 255.

• __U32 inode - inode számfájl;
• __U16 REC_LEN. - a könyvtár rögzítési hossza;
• __U8 NAME_LEN.- a fájlnév hossza;
• char név. – fájl név.

Meghatározzuk a fájlrendszer nevét, amelyen a fájlrendszer létrehozása, globális struktúrák és változók.

#Define part_name "/ dev / hda3"

struktúra ext2_super_block sb;

/ * Buffer asztalleírók tárolására * /

nem jelölt char buff_grp;

aláírás nélküli char buff; / * Információs puffer * /

int indev; / * Eszközfájl fogantyú * /

int blksize; / * Fájlrendszer blokk mérete * /

Számos olyan funkciót határozunk meg, amelyeket meg kell dolgoznunk:

Superblock olvasási funkció:

void Read_SB ()

Memet (& sb, 0,1024);

A szakasz kezdetétől 1024 bájtra tolódik, és elolvassa a szuperblokkot a struktúra ext2_super_block sb szerkezetéhez:

Ha (LSEEK (INDEV, 1024.0)< 0) {

Perror ("lseek");

Kilépés (-1);

Ha (Olvasás (Indev, Char * & SB, Sizeof (SB))< 0) {

Perror ("Olvasás");

Kilépés (-1);

Ellenőrizze a fájlrendszer azonosítóját:

Ha (sb.s_magic! \u003d Ext2_super_magic) (

Printf ("Ismeretlen fájlrendszer típusa!");

Kilépés (-1);

Az EXT2_SUPER_MAGIC értéke a fejléc fájlban van meghatározva.

Megjeleníti a szuperblockban található fájlrendszerről szóló információkat:

printf ("Superblock info -----------");

Printf ("inodes count -% u", sb.s_inodes_count);

Printf ("blokkok száma -% u", sb.s_blocks_count);

Printf ("Blokk méret -% U", 1024<< sb.s_log_block_size);

Printf ("első inóda -% d", sb.s_first_ino);

Printf ("mágia - 0x% x", sb.s_magic);

Printf ("inode méret -% d", sb.s_inode_size);

Printf ("inodes per csoportonként -% u", sb.s_inodes_per_group);

Printf ("blosks per csoport -% u", sb.s_blocks_per_group);

Printf ("első adatblokk -% u", sb.s_first_data_block);

Visszatérés;

Funkció olvasási táblázatleírók:

void Read_GDT ()

Számítsa ki a fájlrendszer blokk méretét:

Blksize \u003d 1024.<< sb.s_log_block_size

A csoportleíró táblázat egy blokkban található, amely közvetlenül az első adatblokk mögött található (szuperblokk esetén).

Olvassa el az asztalt:

Ha (lseek (indev, (sb.s_first_data_block + 1) * blksize, 0)< 0) {

Perror ("lseek");

Kilépés (-1);

Ha (olvasás (indev, buff_grp, blksize)< 0) {

Perror ("Olvasás");

Kilépés (-1);

Visszatérés;

Az inode tartalom funkciója számával:

void get_inode (int inode_num, struct ext2_inode * in)

A funkció bemeneti funkciói - Az inode szekvencia száma és a struktúra ext2_inode szerkezete.

Struktúra ext2_group_desc gd;

U64 csoport, index, pos;

Számítsa ki a blokkcsoport számát, amelyben az inode az inode_num szekvencia számmal van elhelyezve:

Csoport \u003d (inode_num - 1) / sb.s_inodes_per_csoport;

Az asztalleíróból távolítsa el a csoportleíró leírót, és másolja át a Struct Ext2_group_desc GD struktúrához:

Memet ((void *) & gd, 0, sizeof (gd));

Memcy ((void *) & gd, buff_grp + (csoport * (sizeof (GD)), sizeof (GD));

Számítsuk ki a inode helyzetben a inode_num sorszám a Inode táblázatban a csoport csoport, és olvassa ezt a inode a szerkezet a STRUCT EXT2_INODE:

index \u003d (inode_num - 1)% sb.s_inodes_per_csoport;

POS \u003d ((__U64) gd.bg_inode_table) * BlkSize + (index * sb.s_inode_size);

Pread64 (indev, in, sb.s_inode_size, pos);

Visszatérés;

Adatblokk olvasási funkció:

void Read_iblock (Struct EXT2_INODE * IN, INT BLK_NUM)

U64 POS;

Bemeneti funkcióparaméterek - inode struktúra és blokkszám (az inode-ban található címblokk szekvenciájából származó szám).

Számítsa ki az eltolódást az információs blokkhoz a szakaszon, és olvassa el ezt a készüléket a globális pufferbe:

POS \u003d ((__U64) in-\u003e i_block) * Blksize;

Pread64 (INDEV, BUFF, BLKSIZE, POS);

Visszatérés;

Funkció a gyökérkönyvtár tartalmának fogadására:

void get_root_dentry ()

Struktúra ext2_inode in;

A gyökérkönyvtár inode sorszáma ismert, ezért megkapjuk a gyökérkönyvtár inode tartalmát, és olvassuk el a tartalmát a pufferben:

get_inode (ext2_root_ino, & in);

Read_iblock (& \u200b\u200bin, 0);

A buff puffer tartalmazza a gyökérkönyvtár tartalmát.

Visszatérés;

A beadási szám beérkezésének funkciója fájlnévvel:

int get_i_num (char * név)

Bemeneti funkció paraméterek - fájlnév. Visszatérési érték - a szekvencia szám inode fájl.

Int i \u003d 0, rec_len \u003d 0;

Struct ext2_dir_entry_2 dent;

A puffart pufferben van egy sor könyvtári bejegyzések. Az inode fájl sorszámának meghatározásához ebben a fájlban találja meg a fájl nevét:

Mert (; én< 700; i++) {

Memcy ((void *) és dent, (Buff + REC_LEN), sizeof (dent));

Ha (! Memcmp (dent.name, név, dent.name_len)) törés;

REC_LEN + \u003d DENT.REC_LEN;

Visszatérés dent.inode;

És most leírjuk a fő funkciót:

int Main ()

Változók és struktúrák:

struktúra ext2_inode in;

// abszolút utazási fájlnév

Unsigned char * full_path \u003d "/home/test.file";

Aláírás nélküli char buff1;

Statikus int i \u003d 1;

Int n, i_num, outf, típus;

A fájl abszolút útvonalának első karakterének közvetlen slash (/) kell lennie. Ellenőrizd:

Ha (full_path! \u003d "/") (

Perror ("slash");

Kilépés (-1);

Nyissa meg az eszközfájlt, olvassa el a szuperblocks és a táblázat leírásait:

Indev \u003d nyitott (part_name, o_rdonly);

Ha (INDEV.< 0) {

Perror ("nyitott");

Kilépés (-1);

Read_sb ();

Read_gdt ();

A gyökérkatalógus tartalmát kapjuk:

get_root_dentry ();

Most a buff puffer tartalmazza a gyökérkönyvtár összes rekordját (ha szeretné, megmentheti őket külön fájlba). Most, a gyökérkönyvtárak rögzítésével, a Test.file fájl tartalmához juthatunk a fenti fájl olvasási algoritmus segítségével. Ebből a célból egy ciklust szervezünk. A ciklus testében elemezzük a fájl abszolút útvonal nevét, kiemelve elemeit - alkönyvtárak (ez egy, otthon) és a keresési fájl neve (teszt.file). Minden olyan elem, mi határozza meg a Inode sorszámával, úgy véljük, ez az inode majd szerezni az a nullás (a szekvencia cím blokkok található Inode):

míg (1) (

Memet (buff1.0, sizeof (buff1));

(N \u003d 0; n)< EXT2_NAME_LEN; n++, i++) {

Buff1 [n] \u003d full_path [i];

Ha (((buff1 [n] \u003d\u003d "/") || (buff1 [n] \u003d\u003d "?"))) (

I ++;

Szünet;

buff1 [n] \u003d "?";

A fájl abszolút útvonalának minden eleméhez meghatározzuk az inode szekvencia számát, olvassuk el ezt az inode-ot a memóriában, majd megkapjuk a nulla blokk tartalmát:

I_num \u003d get_i_num (buff1);

Get_inode (i_num, & in);

Read_iblock (& \u200b\u200bin, 0);

A fájlinformációk megjelenítése (név, inódszám, fájlméret és típus):

Printf ("inódszám -% u", i_num);

Printf ("fájlnév -% s", buff1);

Printf ("fájlméret -% u", in.i_size);

A fájltípust az I_MODE mezőszerkezet EXT2_INODE négy bitje határozza meg:

típus \u003d ((in.i_mode & 0xf000) \u003e\u003e 12);

Printf ("Type -% d", típus);

Kapcsoló (típus) (

Case (0x04):

Printf ("(katalógus)");

Szünet;

Case (0x08):

Printf ("(normál fájl)");

Szünet;

Case (0x06):

Printf ("(blokkegység)");

Szünet;

Case (0x02):

Printf ("(szimbolikus eszköz)");

Szünet;

Alapértelmezett:

Printf ("(ismeretlen típus)");

Szünet;

Ellenőrizze a fájl típusát. Ha ez rendszeres fájl - megszakítja a ciklust:

Ha (Type & 0x08) (

A buff puffer az /Home/test.file fájl információs blokkjaiból olvasható. Ezt az információt a fájlhoz írjuk:

Outf \u003d nyitott ("out", o_creat | o_rdwr, 0600);

Írás (outf, buff, sizeof (buff));

Szoros (outf);

Szünet;

Távozunk:

Közel (INDEV);

Vissza 0;

Az EXT2 fájlrendszer logikai szerkezetének figyelembevételével.

(Második kiterjesztett fájlrendszer).

· A Linux fájlrendszerek erdészete

· Az ext2fs lemezmegmunkálási struktúrája

·

· Katalógusok

· Fájlok eszközök

·

·

· Könyvtár ext2fs

· Az EXT2FS rendszer szakasza

· A magánélet kiszámítása

Matfak

PROG.

2. kurzus 5. gramm.

Chichirov Andrey

Falomethem EXT2FS (második kiterjesztett fájlrendszer).

Linux fájlrendszerek lejáratait

A Linux változók a Minix operatív rendszer alapján adatbázisok voltak. Két rendszer között kijelölt lemezek lennének, mint új fájlrendszer, így a Linus Torvalds követte a Linux Minix fájlrendszer alfejezetét. Míg ez a fájlrendszer nagyon hatékony volt egy viszonylag kis mennyiségű hibával.

Azonban a villog társított MINIX fájlrendszer igen magas, ezért elkezdett gondolkodni az új fájlrendszer Linux.

A Linux Poison új fájlrendszerének megvalósításának ellenőrzése érdekében virtuális fájlrendszert (VFS) használtunk. A VFS-t Chris Provenzano írta, majd a Linus Torvalds a méregbe integrálta.

A VFS Poison telepítése után az új FAL System System (kiterjesztett fájlrendszer) könnyen és hozzáadva a Linux 0.96c Vexa-hoz. Az új fájlrendszerben két lényeges minixrendszert eltávolítottak: maximális hangereje elérheti a 2 gigabájtot, és a maximális fájlnév 255 karakter. A minix fájlrendszerrel való elérés volt, bár az egyszerűen nyilvánvalóan még mindig gépelés. Nem volt függőleges hozzáférés, az Index Descippet módosítása, és módosítja a fájlváltozás sejtjeit. Ez használt fájlrendszer kapcsolódó listák megnyitásához ingyenes blokkok és index descppings, ami nagyban befolyásolja a rendszer a rendszer: a listákat a listákat vált meghatározatlan és eloltására, amely korábban a fájl egy fájlrendszer.

A szonda döntése 1993 januárjában két új fájlrendszer felszabadulása volt: Xia és EXT2FS (második kiterjesztett fájlrendszer). A XIA fájlrendszer nagyrészt a Minix-en alapult, több új funkció hozzáadásával. Alapvetően ez volt a hosszú fájlnevek gyakorlásának lehetősége, a nagyobb térfogatú lemezek jóváhagyása és a fájl sejtjeinek feszültsége. A finom kövekkel az Ext2fs számos fejlesztéssel és kiegészítéssel rendelkező Extfs-en alapult. Ő is volt lehetőség a jövőre is.

Amikor ezek a két fájlrendszer felszabadult, funkcionálisan határozottan volt. A XIA rendszer megbízhatóbb volt, mint az ext2fs, minimalizálása miatt. Az EXT2FS rendszer hibái nem voltak elpusztítva a csendes alkalmazásukon, és számos új funkciót és fejlesztést adtak hozzá. A jelenlegi EXT2FS fájlrendszer nagyon megbízható, és de facto Linux fájlrendszerré vált.

Az alábbi táblázat közös információkat szolgáltat a funkcionális funkciók funkcionalitásáról, amelyek szaggatott fájlrendszerekkel vannak ellátva.

	Minix FS.	EXT FS.	Ext2 fs.	Xia FS.
Maximális fájlrendszer
Maximális fájlhossz
Maximális fájlnév hossza
A fájlok változásainak tornyának alja
A tempó képessége
Változtatható pazmp blokk
Az infoment védelme

Ha szüksége van a fájlnév hosszára Ext 2. 1012-re növelhető.

Az EXT2FS behatol a root felhasználó néhány blokkjában. Általában ez 5% -át, amely lehetővé teszi a rendszer adminisztráció, hogy elkerüljék hiányzik egy merevlemez körét feltöltése felhasználásával felhasználók dpuugi felhasználók.

Lemezpartícióstruktúra EXT2FS-ben

A merevlemezgyártók általában alacsony szinten formázott termékeiket. Amennyire tudom, ez azt jelenti, hogy a speciális címkék segítségével minden lemezterületet az "ágazatok", az 512 bájt méretének megszakítja. Az ilyen lemez (vagy lemezszakasz) egy adott operációs rendszerben történő használatra kell készíteni. MS-DOS-ban vagy ablakokban az előkészítési eljárást formázásnak és Linuxnak nevezik - fájlrendszer létrehozása. Fájlrendszer létrehozása ext2fs. Az adott logikai struktúra lemezszakaszában létre kell hoznia. Ez a szerkezet a következőképpen épül fel. Először is, a boot terület a lemezen van elosztva. A boot terület bármely fájlrendszerben jön létre. Az elsődleges partíción tartalmaz egy rendszerindító bejegyzést - olyan kódfragmséttel, amely elindítja az operációs rendszer betöltését az indításkor. Más szakaszokon ezt a területet nem használják. A lemezterület többi részét blokkokra osztják. Az egység mérete 1, 2 vagy 4 kilobájt. A blokk a lemezterület egységével címezhető. A helyfájlok kiválasztása teljes blokkokat hajt végre, így a blokk méretének kiválasztásakor kompromisszumot kell tennie. A blokk nagyméretét szabályként csökkenti a lemez elolvasása vagy írása során a lemezre való felkérés számát, de növeli a ritkán használt tér arányát, különösen akkor, ha nagy számú kis fájl létezik.

A blokkok, a területen blokkok csoportjai. A csoportban lévő fájlrendszerben és blokkokban lévő blokkcsoportok egymás után vannak számozva, az 1. indítással. Az első blokk a lemezen 1-es számmal rendelkezik, és az 1. számmal tartozik a csoporthoz (a lemezen lévő blokkok száma) szakasz) az ágazatokban kifejezett lemezmennyiség osztó. És a blokkcsoportok száma nem szükséges megosztani a blokkok számát, mert a blokkok utolsó csoportja nem lehet teljes. Az elején minden blokkja blokknak van egy cím, amely lehet beszerezni, mint ((csoport száma - 1) * (a blokkok számát a csoportban)).

Minden blokkcsoportnak ugyanolyan szerkezete van. A szerkezetét a következő tabletta mutatja be.

A lemezpartíció blokkok csoportja ext2fs.

Ennek a szerkezetnek az első eleme (Superblock) minden csoport esetében megegyezik, és minden más az egyes csoportok számára egyedi. A szuperblokkot az első blokkok első blokkjában tárolják (az 1. csoport kivételével, amelyben a betöltő rekord az első egységben található). Szuperblock Ez a fájlrendszer kiindulópontja. 1024 bájt és mindig a fájlrendszer kezdetétől 1024 bájt eltolásán található. A szuperblokk több példányának jelenléte a fájlrendszer elemének rendkívüli fontosságának köszönhető. Superblock Duplikátumokat használnak a fájlrendszer hibáinak visszaállításakor.

A Superbockban tárolt információkat a lemez egyéb adatainak elérésére használják. A superblock meghatározza a méret a fájlrendszer, a fájlok maximális számát a részben, az összeg a szabad hely, és információkat tartalmaz, hogy hol keresse üres térben. Amikor elkezdi az operációs rendszer, szuperblokkot olvasni a memóriába, és minden változást a fájlrendszer először megtalálni a kijelzőn a másolatot a superblock található az OP és felvételére csak időszakosan. Ez lehetővé teszi a rendszer teljesítményének növelését, annyi felhasználót és folyamatot, amely folyamatosan frissíti a fájlokat. Másrészt, amikor a szuperblokk ki van kapcsolva, meg kell írni a lemezre, amely nem teszi lehetővé, hogy kikapcsolja a számítógépet egyszerűen kikapcsolja a teljesítményt. Ellenkező esetben a következő terhelésnél a szuperblokkban rögzített információk nem alkalmasak a fájlrendszer valós állapotára.

A Superblock a következő struktúrával rendelkezik

A mező neve	Egy típus	Megjegyzés
s_inodes_count	Ulong	Az index leírók száma a fájlrendszerben
s_blocks_count.	Ulong	A fájlrendszer blokkjai száma
s_r_blocks_count.	Ulong	A superuser számára fenntartott blokkok száma
s_free_blocks_count.	Ulong	A szabad blokkok száma
s_free_inodes_count.	Ulong	A szabad index leírók számának számlálása
s_first_data_block	Ulong	Az adatokat tartalmazó első blokk. A készülék méretétől függően ez a mező 0 vagy 1 értéke lehet.
s_log_block_size.	Ulong	Logikai blokk méret jelző: 0 \u003d 1 KB; 1 \u003d 2 kb; 2 \u003d 4 kb.
s_LOG_FRAG_SIZE.	Hosszú.	Fragment méretű kijelző (Úgy tűnik, a fragmens fogalmát jelenleg nem használják)
s_blocks_per_Group.	Ulong	Blokkok száma minden blokkban
s_FRAGS_PER_GROUP.	Ulong	Az egyes blokkblokkok töredékeinek száma
s_INODES_PER_GROUP	Ulong	Az index leírók száma (inodes) minden blokkblokkban
s_mtime.	Ulong	Az idő, amikor a fájlrendszert utoljára szerelték.
s_wtime.	Ulong	Az utolsó alkalom, amikor az utolsó alkalommal rögzítették a fájlrendszerben
s_mnt_count.	Ushort.	A rögzítő fájlrendszer mérete. Ha ez a számláló eléri a következő mezőben megadott értéket (S_MAX_MNT_COUNT), a fájlrendszert ellenőrizni kell (ez az újraindításkor történik), és a számláló visszaáll.
s_MAX_MNT_COUNT.	Rövid	A fájl, amely meghatározza, hogy hányszor szerelhető a fájlrendszer
s_magic	Ushort.	"Magic szám" (0xef53), jelezve, hogy a fájlrendszer az EX2FS típushoz tartozik
s_State.	Ushort.	Zászlók, amelyek jelzik a fájlrendszer aktuális állapotát (függetlenül attól, hogy tiszta (tiszta) stb.)
s_Errors.	Ushort.	Zenák, amelyek hibaüzenetkezelési eljárásokat adnak meg (mit kell tenni, ha hibákat találnak).
s_pad.	Ushort.	Töltő
s_LASTCHECK.	Ulong	Az utolsó fájlrendszer ellenőrzése
s_checkinteral	Ulong	A fájlrendszer ellenőrzése közötti maximális időtartam
s_creator_os.	Ulong	Az OS típusának megadása, amelyben a fájlrendszer létrejön
s_REV_LEVEL.	Ulong	Felülvizsgálati szint fájlrendszer.
s_Rerved	Ulong	Legfeljebb 1024 bájt kitöltése

A Superblock után a blokkcsoport leírása (csoportleírók) található. Ez a leírás egy tömb, amelynek a következő struktúrája van.

A mező neve	Egy típus	Célja
bg_block_bitmap	Ulong	A blokk címe, amely a csoport bitkártyablokkjait tartalmazza (blokk bitmap)
bg_inode_bitmap	Ulong	A csoport bitmapját tartalmazó blokk címe (inode bitmap)
bg_inode_table	Ulong	A csoport indexleíró táblázata (inode táblázat) táblázata címe
bg_free_blocks_count.	Ushort.	A csoportban lévő szabad blokkok számának számlálása
bG_FREE_INODES_COUNT	Ushort.	Az ingyenes index leírások száma ebben a csoportban
bG_USED_DIRS_COUNT	Ushort.	Az index leírók száma ebben a csoportban, amelyek katalógusok
bG_PAD.	Ushort.	Töltő
bG_REServed.	Ulong	Töltő

A blokk leírásának mérete kiszámítható (Méret_group_blok_v_ext2 * number_groups) / size_block (Ha szükséges, lekerekített).

A csoport leírásában tárolt információkat a blokkok és az index leírók bitkártyái, valamint az indexleírók táblázatát találják. Ne felejtsük el, hogy blokkok és blokkok blokkok száma 1.

A Bit Térképblokk (blokk bitmap) egy szerkezet, amelynek minden egyes bitje azt jelzi, hogy a megfelelő blokk hozzárendeli-e hozzá. Ha a bit 1, akkor a blokk elfoglalt. Ez a kártya ingyenes blokkok keresésére szolgál olyan esetekben, amikor kiemelni kell a fájl alatti helyet, a blokkok bitképe elfoglalja a blokkok számát (NUMBER_BLOCK_V_GROUP / 8) / size_block (Ha szükséges, lekerekített).

Az indexleírók bitképe hasonló funkciót hajt végre az indexleírók táblázatához képest: azt mutatja, hogy melyik leíró foglalt.

A blokkszerkezet struktúrájának következő területe az indexfájlleírók táblázatának tárolására szolgál. Az indexleíró szerkezetét a következő alfejezetben figyelembe veszik.

Nos, végül a blokkcsoport fennmaradó helyét a ténylegesen tárolják.

FájlrendszerExt. A 2-et jellemzi:

• hierarchikus struktúra
• az adatgyűjtő feldolgozás,
• dinamikus fájlkiterjesztés,
• információbiztonság a fájlokban
• a perifériás eszközök (például terminálok és szalagos eszközök) értelmezése fájlként.

A fájlok belső nézete

Az EXT 2 rendszer minden egyes fájlja egyedi indexgel rendelkezik. Az index olyan információkat tartalmaz, amelyekhez bármilyen folyamatra hivatkozhat a fájlra. Folyamatokat lásd a fájlokat egy egyértelműen meghatározott rendszer hívások és azonosítja a fájlt húr fájlt meghatalmazotti összetett fájl nevét. Minden összetett név feltétlenül határozza meg a fájlt, hogy a rendszer kernel alakítja ezt a nevet a fájl indexe. INDEX tartalmaz egy táblázatot a címet a fájl helyét információ a lemezen. Mivel a lemez minden blokkja a számának címzettje, ez a táblázat tárolja a lemezblokkszámok sorát. A rugalmasság növelése érdekében a rendszermag egy blokkhoz kapcsolódik a fájlhoz, lehetővé téve a fájlinformációkat, hogy szétszóródjanak az egész fájlrendszeren keresztül. De ez az elhelyezési rendszer bonyolítja az adatkeresési feladatot. A címeket tartalmazó lista blokk számok fájlt tartalmazó tulajdonosa a fájlt, azonban az egyszerű számítások azt mutatják, hogy a lineáris listát fájl blokkolja az index nehéz ellenőrizni. Annak érdekében, hogy egy kis indexszerkezet nagy fájlokkal dolgozzon, a lemezblokk címe táblázata összhangba kerül az 1. ábrán bemutatott szerkezethez

Az EXT 2 rendszer legtöbb fájlja olyan méretű, amely nem haladja meg a 10 kb-ot, és akár 1 kb-ot is, mivel a 10 kb-os fájl a közvetlen címzési blokkokban található, a fájlokban tárolt adatok nagy részéhez, a hozzáférést egy fellebbezésben a lemezre. Ezért, ellentétben a nagy fájlokhoz való hozzáféréssel, a standard méretű fájlokkal való együttműködés gyorsan folytatódik.

Index fájlleírók

A lemezen lévő minden fájl megfelel az egy és egyetlen indexfájl-fogantyúnak, amelyet a szekvencia száma - a fájl index. Ez azt jelenti, hogy a fájlok számát, hogy lehet létrehozni a fájlrendszerben korlátozott száma index leírásokat, amelyek egyszerűen meghatározni egy fájl létrehozásakor a rendszer, vagy alapján kerül kiszámításra a fizikai mennyisége az a partíció. Indiai Descpportok léteznek a lemezen statikus formában, és a rendszermag elolvassa őket a memóriában, mielőtt elkezdene dolgozni.

Az indexfájl fogantyúja a következő struktúrával rendelkezik:

A mező neve	Egy típus	Leírás
I_mode.	Ushort.	Típus és hozzáférési jogok ehhez a fájlhoz.
I_uid	Ushort.	Fájl tulajdonos azonosítója (tulajdonos UID).
I_SIZE.	Ulong	Fájlméret bájtban.
I_atime.	Ulong	Az utolsó hozzáférés ideje a fájlhoz (hozzáférési idő).
I_cime.	Ulong	Fájl létrehozás ideje.
I_mtime.	Ulong	A fájl utolsó módosításának időpontja.
I_dtime.	Ulong	Fájl törlési idő.
I_gid	Ushort.	Csoportazonosító (GID).
I_links_count	Ushort.	Kapcsolatok számláló (linkek száma).
I_blocks.	Ulong	A fájl által elfoglalt blokkok száma.
I_flags.	Ulong	Fájl zászlók Fájl zászlók)
I_rerved1	Ulong	Fenntartva az operációs rendszerhez.
I_block	Ulong	A mutatók, amelyek blokkolják a fájladatok rögzítését (az 1. ábrán a közvetlen és közvetett címzés példája)
I_version.	Ulong	Fájlverzió (NFS esetén)
I_file_acl	Ulong	ACL fájl.
I_dir_acl	Ulong	ACL katalógus
I_faddr.	Ulong	Fragment cím (fragmentcím)
I_frag	Uchar.	Fragment szám (töredékszám)
I_fsize.	Uchar.	Fragment méret (fragment méret)
I_pad1	Ushort.	Töltő
I_rerved2.	Ulong	Fenntartott

A típus a területen, és a hozzáférési jogokat a fájl egy két bájtos szó, minden egyes darab, amely arra szolgál, mint egy zászló jelzi a fájl aránya egy bizonyos típusú vagy telepítését egy adott jogot a fájlt.

Azonosító	Érték	Kinevezési zászló (mezők)
S_IFMT.	F000.	Fájltípus maszk
S_ifsock.	A000.	Domainfészek (aljzat)
S_IFLNK.	C000
S_IFREG.	8000	Normál (rendszeres) fájl
S_IFBLK.	6000	Blokk-orientált eszköz
S_IFDIR.	4000	Katalógus
S_IFCHR	2000	Byte-orientált (szimbolikus) eszköz
S_IFIFO.	1000	Nevezett csatorna (FIFO)
S_isuid	0800	Suid - Bit Shift tulajdonos
S_isgid.	0400	SGID - Csoport Shift bitek
S_isvtx	0200	Feladatvédelem bit (ragadós bit)
S_irwxu.	01c0.	Fájl tulajdonos jogai maszkja
S_irusr.	0100	Olvasási jog
S_iwusr.	0080	A felvételhez való jog
S_IXUSR.	0040	A végrehajtás joga
S_irwxg.	0038	Csoport maszk csoport
S_irgrp.	0020	Olvasási jog
S_iwgrp.	0010	A felvételhez való jog
S_ixgrp.	0008	A végrehajtás joga
S_irwxo.	0007	Más felhasználók jogainak maszkja
S_iroth	0004	Olvasási jog
S_iwoth	0002	A felvételhez való jog
S_ixoth	0001	A végrehajtás joga

Az index leírók között számos leíró van, amelyek speciális célokra vannak fenntartva, és speciális szerepet játszanak a fájlrendszerben. Ezek a következő leírások

Azonosító	Érték	Leírás
Ext2_bad_ino.		Az indexleíró, amelyben a lemezen lévő hibás blokkok címei szerepelnek (rossz blokk inode)
Ext2_root_ino		Fájlrendszer gyökérkönyvtár index leírója (gyökér inode)
Ext2_acl_idx_ino.		ACL inode
Ext2_acl_data_ino.		ACL inode
Ext2_boot_loader_ino.		Loader index leíró (boot betöltő inode)
Ext2_undel_dir_ino.		Undelete könyvtár inode.
Ext2_first_ino.		Az első nem pro-index leíró

A lista legfontosabb fogantyúja a gyökérkönyvtár leírója. Ez a leíró a gyökérkönyvtárra mutat, amely, mint az összes könyvtár, a következő struktúra nyilvántartásaiból áll:

A mező neve	Egy típus	Leírás
Inode	Ulong	fájlindex leíró száma (index)
rEC_LEN.	Ushort.	A rekord hossza
nAME_LEN.	Ushort.	Fájlnév hossza
Név.	Char.	Fájl név

A katalógusban lévő külön bejegyzés nem haladhatja át a blokk határát (vagyis teljesen egy blokkban kell elhelyezni). Ezért, ha a következő bejegyzés nem illik teljesen ebben a blokkban, akkor átkerül a következő blokk, és a korábbi rekordot továbbra oly módon, hogy töltse ki a blokkot a végén.

1. ábra A közvetlen és közvetett címzés blokkja az indexben

2. ábra A fájl mennyisége bájtban 1 kb blokk méretben

3. ábra. Példa a lemezindexre

A 3. ábra egy bizonyos fájl lemezindexét mutatja. Ez az index a szokásos fájlhoz tartozik, amelynek tulajdonosa az "MJB" és a mérete 6030 bájt. A rendszer lehetővé teszi az "MJB" felhasználót a fájl olvasásához, írásához és végrehajtásához; Az "OS" csoport tagjai és az összes többi felhasználó csak a fájl elolvasásához vagy végrehajtásához engedélyezhető, de nem rögzíti az adatokat. Az utolsó alkalommal, amikor a fájl 1984. október 23-án, 13: 45-kor, a rekord volt az utolsó alkalom, hogy 1984. október 22-én, 10: 30-kor készült. Az index 1984. október 23-án, 13:30 órakor változott, bár ebben az időben nem volt információ. A kernel az index összes fenti adatait kódolja. Figyeljen a különbségre az index tartalmának és a fájl tartalmának nyilvántartásának különbségére. A fájl tartalma csak akkor változik, ha a fájlt rögzíti. Az index tartalma mind a fájl tartalmának megváltoztatásakor, mind a fájl tulajdonosának megváltoztatásakor változik, hozzáférési jogok és mutató készletek. A fájl tartalmának megváltoztatása automatikusan az index korrekciót okozza, de az index korrekció nem jelenti azt, hogy megváltoztatja a fájl tartalmát.

Katalógusok

A katalógusok olyan fájlok, amelyekből a fájlrendszer hierarchikus struktúrája épül; Fontos szerepet játszanak a fájlnévnek az indexszámra történő forgatásához. A könyvtár olyan fájl, amely tartalmazza az indexszámból és a könyvtárban szereplő fájlnevét. Az összetett név egy szimbólum karakterlánc, amelyet egy üres szimbólum és a ferde vonal megosztott ("/") több összetevőbe. Minden egyes komponens, az utóbbi mellett, könyvtárnévnek kell lennie, de az utolsó összetevő lehet olyan fájl, amely nem könyvtár. A UNIX rendszer V verziójában az egyes komponens hossza 14 karakterre korlátozódik; Így 2 bájtal együtt, az indexszámhoz rendelt, a könyvtár felvételi mérete 16 bájt.

Ellenőrizze a bájtokat A katalógusban	Index szám (2 byte)	Névfájl
	1798	benne
	1276	fsck.
		clri
	1268	mOTD.
	1799	hegy
		mKNOD.
	2114	passwd.
	1717	umount
	1851	ellenőrző lista.
		fsdbld
		config
	1432	getty.
		Összeomlik.
		mkfs.

4. ábra Katalógus formátum / stb

A 4. ábra az "ETC" könyvtár formátumát mutatja. Minden könyvtárnak fájlokat, a nevét, amelyek jelzett pont és két pontot ( „” És a „..”) és az index számokat, melyek megfelelnek a mutatószámok a katalógus és a szülő katalógus, ill. Indexszám fájl "." A "/ etc" könyvtárnak van egy címe az Offset 0 és a 83-as értékkel. A ".." .. "fájl indexszáma a könyvtár kezdetétől kezdve a 16-as értékkel rendelkezik. , és a mérőszám 0. például Felvétel a cím 224 a „/ etc” könyvtár üres, annak ellenére, hogy egyszer tartalmazta a belépési pont a fájl neve „Crash”. Az MKFS program inicializálja a fájlrendszert oly módon, hogy az indexszámokat a fájlok "." És ".." A gyökérkönyvtár egybeesik a fájlrendszer root indexszámával.

A rendszermag a könyvtárban lévő adatokat ugyanúgy tárolja, mint a normál típusú fájlban az indexstruktúrával és blokkokkal a közvetlen és közvetett címzés szintjével. Folyamatok olvashat adatokat könyvtárak ugyanúgy, ahogy olvasni rendes fájlokat, de a kizárólagos belépési jogot, hogy a könyvtár által fenntartott mag, amely biztosítja a helyességét a könyvtár struktúrát. Katalógus A hozzáférési jogok a következő jelentéssel bírnak: Az olvasási jog lehetővé teszi a folyamatok lehetőséget, hogy az adatokat a katalógusból olvassa el; Felvételi jog Lehetővé teszi a folyamat új bejegyzését a könyvtárban, vagy törölje a régi (Creat, MKNOD, LINK és NINCK OLDISINGS), amelynek eredményeképpen a katalógus tartalma megváltozik; A végrehajtás joga lehetővé teszi, hogy a könyvtárat a fájlnév (mivel a "végrehajtás" a katalógus értelmetlen).

Ha bármely program a fájl elérési útját használja, a megfelelő Nomep of the Index Descip tartalmazza a katalógusokat. Miután a fájlnevet használták az index leírási számában, ez a Descippot a memóriába kerül, majd a következő zAP-ban használható.

A Unix fájlrendszerek fogalma tartalmazza a referencia fogalmát. Az egyik index descipboard társítható több fájlnévvel. A Deskpottot egy mező, egy Hinner segíti, amellyel a fájl társult. Hozzáadása link könyvtárat létrehozni bejegyzést, ahol az index descippet szám jelzi a diskpot, és növekedett a referencia számlálót a descpport. Meg kell törölni a linkeket a méreg csökkenti a referencia számlálót és törli a desqpot, ha ez a mérő válik null.

Az ilyen linkeket merevnek nevezik, és csak egy fájlrendszerben lehet használni (nem hozhat létre linket egy fájlrendszerhez egy flip fájlrendszerből). Ezenkívül a merev link csak egy fájlt is megadhat (szigorú hivatkozás a könyvtárra a fájlrendszerbe való fókuszáláshoz).

A legtöbb UNIX rendszerben van egy másik típusú kapcsolat. Ezeket a hivatkozásokat, amelyek csak a fájlnevet népszerűsítik, szimbolikusnak nevezik. Az ilyen linkek szegényebbé válik, miközben a fájl elérési útját használja az index descipboardhoz, a méreg helyettesíti a leállt szoftverre való hivatkozás nevét (azaz a célfájl nevében) és újra internetes útvonalak elérési út a fájlhoz. Mivel a szimbolikus link nem jelzi az Index desqpot-ot, lehetőség van olyan linkekre létrehozni, amelyek fertőtlenített fájlrendszerben találhatók. Ezek a hivatkozások bármilyen típusú fájlt jelezhetnek, még nem is léteznek. A szimbolikus hivatkozások annyira használatosak, mivel nincsenek olyan tüzek, amelyeknek kemény linkje van. Azonban olyan kötetet foglalnak el a lemezen, ahol az index descipboard és adatblokkok megengedettek. Használatuk lehet használni, hogy a mentesítési kapcsolatos módon használja a fájl elérési útját az index descipboard, ami annak köszönhető, hogy az a tény, hogy a szimbolizációt a szimbolikus linkeket a méreg újra meg kell adja meg a fájl elérési útvonalát.

Fájlok eszközök

Az UNIX-szerű operációs rendszerekben az eszközökhöz való hozzáférés speciális fájlokon keresztül történik. Ez a fájl nem történik meg a fájlrendszerben. Ez csak egy hozzáférési pont az eszköz meghajtójához.

Kétféle eszközfájl van: szimbolikus és blokk. Ha egy szimbolikus típusú, lehetséges, hogy adatokat cseréljen a készülék csak karakteres üzemmódban, míg blokk típusú eszközök fájlok lehetővé teszik, hogy kicseréljék csak blokk puffer alkalmazásával. Ha az I / O kérelmet kéri az eszközfájlba, akkor ezt a lekérdezést átirányítja a megfelelő eszköz vezetőjére. Minden hasonló fájl megfelel egy olyan vezető számnak, amely meghatározza az eszköz típusát, és a fiatalabb szobát, amely meghatározza a készüléket.

További funkciók EXT2FS.

A Unix, az EXT2FS mellett vannak olyan további funkciók, amelyeket általában nem közelítenek meg a Unix fájlrendszerek.

A fájlok ATPIBUTS lehetővé teszi, hogy a Polar fájlok segítségével módosítsa a fájlokat. Telepítheti a fájlt vagy a könyvtárat. A második esetben a könyvtárban létrehozott fájlok örökölnek ezeket az atiometikusokat.

A rendszer montizációja során egyes funkciókat lehet telepíteni a fájl atiquotes-hez. A Mount opció lehetővé teszi az adminisztráció kiválasztásához a fájlok létrehozásának funkcióit. A BSD funkcióval rendelkező fájlrendszerben a fájlok ugyanazzal az azonosítóval rendelkeznek, mint a GPPP, valamint az apartmankatalógus. Jellemzői rendszer V kissé bonyolultabb. Ha a setgid bit katalógusban van állítva, a fájlok által létrehozott azonosítója GPPS a könyvtár kapott, és az alkönyvtárak öröklik a azonosítja a GPPP és setgid biteket. A jelen esetben fájlok és katalógusok jönnek létre a gppp alapvető azonosítójával, amely az okozó ppcress.

Az EXT2FS rendszer a BSD rendszerhez hasonló szinkron adatmódosítást használhat. A mount opció lehetővé teszi az adminisztrációt, hogy adja meg az összes adatot (index descplists, bitek, indirekt blokkok és a könyvtár blokkok) rögzítve a DC szinkronban azok módosításait. Ez a magas információs rekordok eléréséhez használható, de a papság romlását is magába foglalja. Tény, hogy ez a funkció általában nem használják, mivel a romló proliferáció, ezt fel lehet használni, hogy izzad a felhasználók a felhasználók, amelyek nincsenek jelölve a fájlrendszert.

Az EXT2FS lehetővé teszi, hogy létrehozzon egy fájlrendszert egy logikai blokk kiválasztásához. Ez lehet egy Pazmer 1024, 2048 vagy 4096 bájt. A használata nagy mennyiségű blokkok az I / O optiating (mint a mennyisége a szar, hogy a lemez csökken), és ezért, hogy egy kisebb fejléc a fejek. A blokk másik oldalán egy nagy blokkblokkok használata a lemez nyugdíj tárcsájához. Jellemzően az utolsó blokk a fájl használható nem teljesen a tájékoztatás terén, ezért egy mennyiségének növekedése a blokk, a kötet a teped lemez lyukasztó megnő.

Az EXT2FS lehetővé teszi az ösvény szimbolikus hivatkozások használatát. Az ilyen linkek használatával blokk adatblokkok nem használhatók. A célfájl neve nem az adatblokkban van, hanem az Index Descipboardban. Ilyen szerkezet lehetővé teszi, hogy fenntartsák a lemez ütését és elpárologtatják a szimbolikus kapcsolatok skótát. Persze, van egy csővezeték, deskted alatt descite, pelyhes, így nem minden kapcsolat lehet az elvállalt, mint hersal. A fájlnév maximális hossza másodlagos linkben 60 karakter. A közeljövőben tervezik, hogy szüneteltesse ezt a rendszert kis mennyiségű fájlokra.

Az EXT2FS követi a fájlrendszer állapotát. A szegények külön mezőt használnak a szuszpenzióban, hogy jelezzék a fájlrendszer állapotát. Ha a fájlrendszer olvasás / írásban van felszerelve, az állapot "nem tiszta". Ha a csak olvasható élvezetben lebontott vagy fel van szerelve, akkor a feltétele "tiszta". Amikor a rendszer és a fájlrendszer rendszere folyamatban van, ezt az információt a fájlrendszer szükségességének kezelésére használják. A szegények néhány huncut hibát is helyeznek ezen a területen. Megnyitott nem megfelelőségi mérgező, a fájlrendszer "hibás" jelöléssel van ellátva. A fájlrendszer szimulátora teszteli ezt az információt a rendszer rendszeréhez, még akkor is, ha az állapota valójában "tiszta".

A fájlrendszer tesztelése néha néha bizonyos elegendősé válhat, így az EXT2FS kétféle módszert tartalmaz a szabályozási rendszerhez. A SpearLockot a rendszer rögzítő számlálója elősegíti. Ez a számláló minden egyes PA-t növeli, ha a rendszer olvasási / írási funkcióba van szerelve. Ha értéke eléri a maximumot (a felfüggesztésben is huded), akkor a fájlrendszer tesztelését a pénztár elindítja, még akkor is, ha az állapota "tiszta". Az utóbbi, az első alkalommal és az első legmagasabb intelligens a felfüggesztésben is huded. Ha a PINKS között a maximális intelligencia érhető el, a fájlrendszer állapota figyelmen kívül hagyja, és az ellenőrzőpont elindul.

Az EXT2FS rendszert a jelenlegi. A TUNE2FS BRAMMA használható:

• cselekvés PRI hiba kicsomagolással. Megnyitott egy nem megfelelőségi méreg, a fájlrendszer "hibás", és az alábbi lépések egyike elvégezhető: a végrehajtás végrehajtása, a fájlrendszer frissítése az olvasható élvezetben annak elkerülése érdekében Csatlakozás, a rendszer paging rendszere a fájlrendszerhez.
• maximális szerelt érték.
• maximális intelligencia a csapok között.
• a root felhasználó számára a logikai blokkok száma.

A felépített opciók is használhatók a hiba méregének kötelezettségének módosítására is.

Az Atpibut használatával lehetővé teszi a felhasználók számára, hogy töröljék a szekvenciális fájlokat. Törölhet egy hasonló fájlt, a fájl használatához használt blokkokban, véletlenszerű információkkal rögzítve. Ezt fogják előmozdítani, hogy hozzáférjenek a fájl első részéhez a Hatóságban, és a lemez tárcsázása.

Az EXT2FS rendszer a közelmúltban új típusú fájlok 4,4 BSD fájlrendszerből készült. A típusú fájlok csak olvasásra használhatók: Senki sem kell megváltoztatnia őket, vagy törölnie őket. Ez a fontos konfigurációs fájlok védelmére használható. A fájlok típusát, ezek olyan fájlok, amelyek rögzítési funkciókká válhatnak, és az adatok csak a fájl végéhez adhatók hozzá. Ez a típusú fájlok eltávolíthatók vagy állandóak. Ezek olyan zeperes fájlokként használhatók, amelyek csak a köteten növelhetők.

A magánjog optimalizálása

Az EXT2FS rendszert olyan funkciók megkönnyítik, amelyek optimalizálják profilját, ami az olvasási és írási fájlokról szóló információk cseréjének növekedéséhez vezet.

Az EXT2FS aktívan használ egy lemez puffert. Amikor a készüléket el kell olvasni, a méreg megjeleníti az I / O opt / kimenet átlátszatlan. Így a szegényebb megpróbálja meggyőződni arról, hogy a következő blokk, amelyet el kell olvasni, már a lemez pufferért felelős. Az ilyen lehetőségeket általában soros olvasási fájlok segítségével végzik.

Az EXT2FS rendszer nagy mennyiségű információmódosítást is biztosít. A blokkokat a megfelelő index descippets és adatblokkok kombinálására használják. A méreg mindig megpróbálja nyomni az egyik fájl adatblokkjait egy gpupban, valamint a desqpot-ban. Ez a fejlécfejek és a leíró leírások és a megfelelő adatblokkok csökkentésére alkalmazzák.

Ezek az adatrekordok a fájlban, az Ext2fs legfeljebb 8 szomszédos blokkot erősít az új blokk segítségével. Az ilyen módszer lehetővé teszi a rendszer erősségeinek nagymértékű folyamatos javítását. Ezenkívül lehetővé teszi a fájlok szomszédos blokkjainak használatát, amelyek megfelelnek a következő olvasatnak.

Könyvtár ext2fs.

Kihasználni a használatát EXT2FS kártevők és a kontroll a kapcsolati stroits E fájlrendszer, LIBEXT2FS könyvtár volt könnyű. Ez a könyvtár olyan funkciókat biztosít, amelyek használhatók az EXT2 fájlrendszer működtetéséhez és módosításához, a fizikailag kiküszöbölve.

A legtöbb EXT2FS segédprogramok (MKE2FS, E2FSCK, TUNE2FS, DUMPE2FS, DEBUGFS és DP) Használja ezt a könyvtárat. Erősen kiegészíti ezeket a segédprogramok módosítását, mivel az EXT2FS-fájlrendszer további funkcióinak beillesztésének módosítása csak az EXT2FS könyvtárban kell lennie.

Mivel az EXT2FS internetes könyvtár elegendően shiyky és segéd, könnyen írható a segítségével, amely könnyen írható, mivel a fájlrendszer használható. Alkalmazzák, az EXT2FS könyvtárat a 4.4 BSD dump és egyes segédprogramok visszanyerése használta. Megölték, hogy nagyon kevés változást alakítson ki ezeknek a felhasználásoknak a Linuxhoz való hozzáigazításához (több olyan funkciót kellett cserélni, amely kölcsönhatásba lép a fájlrendszerrel, hogy hívjon az EXT2FS könyvtárba).

Az EXT2FS könyvtár magában foglalja a több osztály működését. A pubertás osztály a fájlrendszerhez kapcsolódó átlátszatlan. Bármilyen shampoam nyithat vagy tegye a fájlrendszer olvasását és írását bites blokk, hozzon létre egy új fájlrendszer a lemezen. A rossz blokk blokk blokkok listájának funkciói is vannak.

Az átlátszatlan második osztály katalógusokat fog használni. Propamma a EXT2FS könyvtár létrehozásához vagy cserkész egy könyvtárat, valamint hozzáadni vagy törölni feljegyzések a könyvtárban. Vannak olyan funkciók, mint a progellánsok az indexben a fájlba, és a fájl elérési útjának elérési útja a megadott descip.

Az áttetsző utolsó osztálya az Index Descilepts-szel nyílik meg. Lehetőség van olvasni a Descpport tábla, számolhatja meg vagy írja le a Descpotp, PP-t a megadott desqpot összes blokkjának megtekintése. Lehetőség van a blokkok és a Descpports képződésének és felszabadulásának funkcióinak megvalósításában.

Az EXT2FS rendszer szakasza

Az EXT2FS rendszerhez a kiegészítő felhasználás hatékony felhasználását alkalmaztuk. Ezeket a felhasználásokat az EXT2FS fájlrendszerek bármilyen ellentmondásainak létrehozására, módosítására és coppére használjuk. Az MKE2FS programot olyan lemezpasztász telepítésére használják, amely üres EXT2FS fájlrendszert biztosít.

A tune2fs alkalmazás lehet használni az erejét a fájlrendszer papalmet .cc meg lehet változtatni kell változtatni felmerülő hibákat, a maximális számú rendszer szerelés, a tervezett maximális között a rendszer előrehaladtával, és a több logikai blokkok hajtott a root felhasználó.

Talán a leginkább intelligens felhasználás az egyszerűsített fájlrendszer. Az E2FSCK a teljes rendszer átvételének beérkezését követő fájlrendszer befejezését követően komponálja. Az E2FSCK propamma kezdeti verziója a Linus Torvald FSCK fájlon alapul a Minix fájlrendszerhez. Ugyanakkor a jelenlegi változata a transmanent időszakra vonatkozóan a EXT2FS könyvtár és több gyors és csak akkor lehet végrehajtani egy nagyobb hibák száma terén végzett vizsgálatának szerint a készítmény egy papaling vexa.

Az E2FSCK szégyenét olyan idő alatt tanulmányozták, hogy a maximális sebességgel végezzük. Mivel a fájlrendszer tüskéjét a lemezfejnek hívják, optimalizálni kell az E2FSCK villogó algoritmusait, hogy a fájlrendszerre vonatkozó eljárást sokkal könnyebben kell használni. És emellett az index dezcts és könyvtárak szándékosai a blokkszám szerint kerülnek végrehajtásra a lemezmeghajtó fejének csökkentése érdekében.

Az E2FSCK törése során a fájlrendszert minden index descipient, és az egyik Descipputs a rendszer külön eleme. Ilyen alkalom, ezek a tesztelés nem illeszkedik a fájlrendszer objektumainak. Az ilyen csapok egyik célja a fájltípus típusának létezésének bemenete, valamint a Descpeppet összes blokkjának levelezése meglévő számokkal rendelkező blokkokkal. A kapcsolásban a bitek működnek, jelezve a blokkok és a desclisták használatát.

Ha az e2fsck találja az adatokat blokk, a noms amelyek összegyűjtött több mint egy descipping, akkor az 1B 1d utakat kezdett, hogy meghatározza a következetlenségeket - vagy növeli a hordozható blokkot vagy eltávolítása egy vagy több descipputs.

A legközelebbi Pepping a legtöbbet veszi fel, mivel az index Descippets-t el kell olvasni a memóriába és elválaszthatatlan. A későbbi testek bemeneti / kimeneti opcióinak csökkentése érdekében az összes szükséges információs mozgalom a pufferben marad. Ennek a rendszernek a boldogabb olvasása a fájlrendszer könyvtárának összes blokkjának keresése. Az információ beszerzéséhez az összes fájlrendszer könyvtárának szekvenciái a második utakon olvashatók.

A második díszítésben a könyvtárak a fájlrendszer egyedi elemeként íródnak. Az egyes könyvtárak blokkja különálló, a DPUCH könyvtár blokkjaira való hivatkozás nélkül. Ez lehetővé teszi az E2FSCK-ot, hogy leválasztja a könyvtárak összes blokkját a blokkok számán, és lépjen kapcsolatba velük a futási időben, olyan idővel, amely csökkenti a lemezhez való hozzáférést. A katalógusblokkokat a nyilvántartások valóságának levelezésére tesztelik, és hozzájárulnak a meglévő számmal rendelkező mezőkre való hivatkozásokhoz (ahogy bekapcsolták a törés során).

A könyvtár minden menetrendjében a könyvtár minden ütemezéséhez a bejegyzések létezése létezik. "." és "..", és hogy a Descpet szám a felvételre szolgál. " Megfelel az aktuális könyvtárnak. (Az ütemező szám a felvételhez ".." nem tesztel, amíg megfordul.)

A második fód végrehajtásakor az apartmankatalógusnak megfelelő információs mozgalom mentésre kerül a pufferbe.

Meg kell jegyezni, hogy a második pchoda végére szinte minden bemeneti / kimeneti opciót tartalmaz egy lemezen. Minden információ a mozgás, amely megpróbálja ezer negyedik és ötödik utak, elősegíti a memóriában, azonban a fennmaradó gödrök a PPPSSOP és kevesebb, mint 5-10% -át e2fsck végrehajtását.

A katalóguskapcsolatok a Trinketben találhatók. Az E2FSCK az egyes könyvtárak útvonalait az ágyba inni, a második fód által kapott információk felhasználásával. Itt van a rekord ".." .. Minden katalógus az első és a kapcsolatok nem kerül az / Lost + található könyvtárba.

A negyedik, az E2FSCK utazások, a referencia-számlálók minden index Descip tartalmazza az összes Descpports PPPlaying-t, és tükrözi a referencia mérőket (ezt az információt keresztfigurákból tartják) belső mérőkkel, amelyeket az értékek a Sub-Second és Trunks. Minden sikertelen fájl nulla referenciaóra is elhelyezhető az / elveszett + található könyvtárba.

És végül, az ötödikben az E2FSCK a fájlrendszer összes információs információjának levelezése. Itt vannak a blokkok és a desclisták bitjei, amelyeket az első előrejelzésben kaptak, érvényes értékekkel, és ha szükséges, a lemezinformáció a megfelelő lemezen található.

Használja a fájlrendszer hibakeresési hasznos használatát. A Debugfs egy erőteljes hiúság, amely lehetővé teszi, hogy leereszkedjen és állítsa be a fájlrendszer állapotát. Lényegében, ez egy interaktív internet az EXT2FS könyvtárhoz, azaz a tipikus parancsok, amelyek a könyvtári funkciókat hívják.

A Debugfs használható belső fájlrendszer-szűkület működtetésére, a helyreállítási rendszert, vagy az E2FSCK feltételes tesztjeit. Sajnos ez a Jammy megnyerheti a fájlrendszert, ha nem tudja, hogyan kell használni. Ezzel az erővel elegendő elpusztítani a fájlrendszert. Ezért a Debugfs a fájlrendszert az alapértelmezett csak olvasható helyzetben fordítja. Az olvasási / írási boríték eléréséhez meg kell adnia a -w opciót.

A magánélet kiszámítása

A Bonnie teszt eredményei az alábbi táblázatból láthatóak:

	Sugar felvétel (CB / S)	Patch bejegyzés (CB / S)	Teljesítmény (kb / s)	Cukor olvasás (CB / S)	Piece Reading (KB / s)
BSD Async.
BSD szinkronizálása.
Ext2 fs.		1237			1033
Xia FS.

Az eredmények elég ismerik a blokk bemenet / kimenet: Az EXT2FS rendszer a referenciarendszeren nyer. Ez a PA közelítésben szereplő optimalizálásnak köszönhető. A bejegyzés is elég gyors ahhoz, hogy az a tény, hogy a kölyök a Gupiene Puremben. A nagy sebességű olvasás összefügg azzal a ténnyel, hogy a blokkokat beálltunk egy fájlt, így a cím fejeket nem végzett két mérés között, és az optimalizálás az első olvasat teljesen teljes mértékben.

Az oldal másik oldalán a FreeBSD rendszer a fenti referenciaérték szimbolikus bemenetét / kimenetét tartalmazza. Talán ez annak a ténynek köszönhető, hogy a FreeBSD és a Linux megfelelő a megfelelő C könyvtáraknak megfelelő könyvtárakkal. Ezen kívül, a FreeBSD-ben, annál optimalizáltabb szimbolikus olvasási könyvtár, ezért van egy kicsit jobb itt.

Vizsgálati eredmények andrew.

Andrew teszt eredményei láthatóak az alábbi táblázatból:

	Pápa 1 létrehozása	Vízvezeték 2 másolás	Vízvezetés 3 állapot	Vízvezeték 4 Bapti	Vízvezeték-szerelő 5 Összeállítás
	2203	7391	6319	17466	75314
BSD szinkronizálása.	2330	7732	6317	17499	75681
Ext2 fs.

Az elmúlt két gödrum eredményei azt mutatják, hogy a Linux megnyeri aszinkron adatcserét. A könyvtárakat és fájlokat hozza létre, a BSD rendszer szinkronban rögzíti a Descpports és a könyvtárak nyilvántartását. Van egy hívás, hogy az Asynchpone-t a FreeBSD-hez még nem hajtották végre teljesen.

A Linux és a BSD értékének tiszteletben tartása nagyon hasonló. Míg a BSD fent leírásakor, hozzáadunk egy csokrot a fájlnevekhez a Linux VFS rendszerhez, az erre a típusra van állítva.

Az ötödik és ötödik PPOD-kben a Linux gyorsan ingyenes, elsősorban a kombinált csokor használatára. A puffer térfogata több memóriát vehet igénybe, és több memóriát vehet igénybe, mint a FreeBSD-ben, ahol a rögzített kötetet használják. Az EXT2FS és a XIA FS válaszok eredményei azt mutatják, hogy az Ext2fs-ben tapasztalt optimalizálás valóban alkalmazható: ezeknek a rendszereknek az elkövetője körülbelül 5-10%.

Következtetés

Az EXT2 fájlrendszer a leginkább a Linux felhasználók számára készült. UNIX szabványos funkciókat és további funkciókat biztosít. Ráadásul a méregben szereplő optimalizálásnak köszönhetően kiváló válaszeredményeket mutat.

Az EXT2FS rendszer tartalmazza az új funkciók hozzáadását. Egyesek vigyázni a használata a PAS a valódi fájlrendszert: az beléptető, a megfelelő POSIX Standa helyreállítása távoli fájlok fájlok tömörítésére és egy hosszú méretű lakóhely.

Először is az EXT2FS rendszert beépítették a Linux méregbe, és aktívan mozog az operációs rendszerek működésénél. Az EXT2FS szintén fontos eleme a Masix operációs rendszernek, amelyet jelenleg az egyik autopsz.