Mint minden UNIX fájlrendszernél, az ext2 is a következő összetevőkre osztható:
− blokkok és blokkcsoportok;
− indexleíró;
− szuperblokk.
A teljes lemezpartíciós terület fix méretű blokkokra van osztva, amelyek a szektorméret többszörösei: 1024, 2048, 4096 vagy 8192 bájt. A blokk mérete a lemezpartíción lévő fájlrendszer létrehozásakor kerül megadásra. A kisebb blokkméret helyet takarít meg a merevlemezen, de korlátozza a fájlrendszer maximális méretét is. Minden blokknak van sorozatszáma. A töredezettség és a merevlemez fejmozgások számának csökkentése érdekében nagy adattömbök olvasásakor a blokkokat blokkcsoportokba vonják össze.
A fájlrendszer alapkoncepciója az inode, vagy inode (információs csomópont). Ez egy speciális struktúra, amely információkat tartalmaz egy fájl attribútumairól és fizikai helyéről. Az inode-ok egy táblázatba vannak rendezve, amely az egyes blokkcsoportok elején található.
10. ábra - Az FS ext2 általánosított blokkvázlata
A szuperblokk az ext2 fájlrendszer fő eleme. Általános információkat tartalmaz a fájlrendszerről:
a blokkok és inódok teljes száma a fájlrendszerben,
a szabad blokkok és inódok száma a fájlrendszerben,
fájlrendszer blokk mérete,
a blokkok és inódok száma egy blokkcsoportban,
inode mérete,
fájlrendszer azonosítója.
A szuperblokk 1024 bájt a szakasz elejétől számítva. A fájlrendszer állapota közvetlenül függ a szuperblokk integritásától. Az operációs rendszer több biztonsági másolatot készít a szuperblokkról, ha a partíció megsérül. A szuperblokk után következő blokk tartalmazza a globális leíró táblát - a blokkcsoportok leírását, amely egy tömb, amely általános információkat tartalmaz a szakasz összes blokkcsoportjáról.
Az ext2 partíción lévő összes blokk blokkcsoportokra van osztva. Minden csoporthoz külön bejegyzés jön létre a globális leíró táblában, amely a fő paramétereket tárolja:
blokkszám a blokk bittérképen,
a blokkszám az inode bittérképben,
blokkszám az inode táblában,
a csoportban lévő szabad blokkok száma,
a könyvtárakat tartalmazó inode száma.
A blokk bittérkép egy olyan struktúra, amelynek minden bitje jelzi, hogy a megfelelő blokk hozzá van-e rendelve valamelyik fájlhoz. Ha a bit 1, akkor a blokk foglalt. Hasonló funkciót lát el az inode bitmap, amely megmutatja, hogy mely inódok foglaltak és melyek nem. Linux kernel, a könyvtárakat tartalmazó inode-ok számát felhasználva igyekszik egyenletesen elosztani a könyvtár-inódákat a csoportok között, és lehetőség szerint megpróbálja áthelyezni a fájlinódákat a szülőkönyvtárral rendelkező csoportba. A táblázatban adatként feltüntetett összes fennmaradó hely a fájlok tárolására van fenntartva.
Fájlrendszer Az ext2 a következő fájlblokk-címzési sémát használja. A fájl címének tárolásához 15 mező van lefoglalva, amelyek mindegyike 4 bájtból áll. Ha a fájl 12 blokkba illeszkedik, akkor a megfelelő klaszterek száma közvetlenül a cím első tizenkét mezőjében jelenik meg. Ha a fájl mérete meghaladja a 12 blokkot, akkor a következő mező annak a klaszternek a címét tartalmazza, amelyben a fájl következő blokkjainak száma található. Így a 13. mezőt indirekt címzésre használjuk.
A 4096 bájt maximális blokkméret mellett a 13. mezőnek megfelelő fürt legfeljebb 1024 következő blokkszámot tartalmazhat a fájlban. Ha a fájl mérete meghaladja a 12+1024 blokkot, akkor a 14. mező kerül felhasználásra, amely egy 1024 fürtszámot tartalmazó fürt címét tartalmazza, amelyek mindegyike a fájl 1024 blokkjára vonatkozik. Itt kettős indirekt címzést használnak. Végül, ha a fájl több mint 12+1024+1048576 blokkot tartalmaz, akkor az utolsó 15. mezőt a hármas átirányításra használjuk.
Ez a rendszer A címzés 4096 bájt maximális blokkméret mellett lehetővé teszi, hogy 2 TB-nál nagyobb fájlok legyenek.
Az ext3 vagy ext3fs egy naplózó fájlrendszer, amelyet Linux kernelen alapuló operációs rendszerekben használnak. FS ext2 alapján.
A fő különbség az ext2-től az, hogy az ext3 naplózott, vagyis olyan adatot ír, amely lehetővé teszi a fájlrendszer visszaállítását, ha a számítógép összeomlik.
A szabvány három naplózási módot biztosít:
visszaírás: a naplóba csak a fájlrendszer metaadatai, vagyis a változásáról szóló információk kerülnek beírásra. Nem tudja garantálni az adatok integritását, de már észrevehetően csökkenti az ellenőrzési időt az ext2-hez képest;
Rendezett: ugyanaz, mint a visszaírás, de az adatok a fájl módosítására vonatkozó információk írása előtt kerülnek a fájlba. Kissé csökkenti a teljesítményt, és nem garantálja az adatok integritását (bár növeli a biztonságuk valószínűségét, ha egy meglévő fájl végéhez fűzi őket);
napló: Az FS metaadatok és a felhasználói adatok teljes naplózása. A leglassabb, de egyben a legtöbb is biztonságos mód; garantálni tudja az adatok integritását, ha a naplót külön partíción (vagy jobb esetben külön merevlemezen) tárolja.
Az ext3 fájlrendszer legfeljebb 1 TB méretű fájlokat képes támogatni. A 2.4-es Linux kernel esetében a fájlrendszer méretét a blokkeszköz maximális mérete korlátozza, ami 2 terabájt. A Linux 2.6-ban (32 bites processzorokhoz) a blokkeszköz maximális mérete 16 TB, az ext3 azonban csak 4 TB-ot támogat.
Az ext4 az ext3-on alapuló és azzal kompatibilis fájlrendszer (előre és hátra). Eltér az ext3-tól a kiterjedések támogatásában, az összefüggő fizikai blokkok egészében kezelt csoportjaiban, a megnövelt integritás-ellenőrzési sebességben és számos egyéb fejlesztésben.
Új ext4 funkciók (az ext3-hoz képest):
Kiterjedések használata. Az ext3 fájlrendszerben a hagyományos módon, blokkonként címezték meg az adatokat. Ez a címzési módszer a fájlméret növekedésével kevésbé hatékony. A kiterjedések lehetővé teszik nagyszámú (akár 128 MB) összefüggő blokk megcímzését egyetlen leíróval. Akár 4 kiterjedésű mutatót is elhelyezhetünk közvetlenül az inode-ban, ami elegendő kis és közepes méretű fájlokhoz.
48 bites blokkszámok. 4K blokkmérettel ez legfeljebb egy exabájt címzést tesz lehetővé (2 48 * 4 KB = 2 50 * 1 KB = 2 60 B = 1 EB).
Blokkok csoportos kiosztása (többblokk kiosztás). A fájlrendszer nemcsak a szabad blokkok helyére vonatkozó információkat tárol, hanem az egymást követő szabad blokkok számát is. A helykiosztás során a fájlrendszer talál egy töredéket, amelybe töredezettség nélkül lehet adatokat írni. Ez csökkenti a fájlrendszer egészének töredezettségét.
Késleltetett blokkok kiosztása. A fájladatok tárolására szolgáló blokkok kiosztása közvetlenül a lemezre való fizikai írás előtt történik (például a szinkronizálás hívásakor), és nem az írás hívásakor. Ennek eredményeként a blokk-allokációs műveletek nem egyenként, hanem csoportosan hajthatók végre, ami viszont minimalizálja a töredezettséget és felgyorsítja a blokkkiosztási folyamatot. Másrészt növeli az adatvesztés kockázatát hirtelen áramszünet esetén.
Túllépték a 32 000-es címtárak korlátját.
Inode lefoglalása könyvtár létrehozásakor (könyvtár inodes foglalása) Könyvtár létrehozásakor több inode le van foglalva. Ezt követően, amikor fájlokat hozunk létre ebben a könyvtárban, először a lefoglalt inode-okat használjuk, és ha ezek nem maradnak, a szokásos eljárást követjük.
inode mérete. Az inode mérete (alapértelmezett) 128 bájtról 256 bájtra nőtt. Ez lehetővé tette az alább felsorolt előnyök realizálását.
Időbélyegek nanoszekundumos pontossággal (nanoszekundumos időbélyegek). Az inode-ban tárolt idők nagyobb pontossága. A tárolt idők köre is bővült: ha korábban 2038. január 18-a volt a tárolt idő felső határa, most 2514. április 25.
inode verzió. Az inode-nak van egy száma, amely minden alkalommal növekszik, amikor a fájl inode-ját módosítják.
Kibővített attribútumok tárolása inode-ban (EA inode). A kiterjesztett attribútumok, például ACL-ek, SELinux-attribútumok és így tovább tárolása javíthatja a teljesítményt. Azok az attribútumok, amelyekhez nincs elég inode terület, egy külön 4 KB-os blokkban tárolódnak.
Napló ellenőrző összegzés. A naplótranzakciók ellenőrző összegei. Lehetővé teszi a hibák jobb megtalálását és (néha) kijavítását a rendszer integritásának ellenőrzése során egy összeomlás után.
Előzetes kiosztás (tartós előkiosztás). Most, hogy az alkalmazás garantáltan helyet foglaljon a fájlrendszerben, nullákkal tölti fel. Az ext4-ben lehetővé vált sok blokkot lefoglalni az íráshoz, és nem kell túl sok időt tölteni az inicializálással. Ha az alkalmazás megpróbálja beolvasni az adatokat, akkor üzenetet kap, hogy nincs inicializálva. Így a törölt adatok illetéktelen beolvasása nem fog működni.
Töredezettségmentesítés leválasztás nélkül (online töredezettségmentesítés).
Inicializálatlan blokkok. Lehetővé teszi a fájlrendszer-ellenőrzés felgyorsítását. A használaton kívüliként megjelölt blokkokat csoportosan ellenőrzik, részletes ellenőrzésre csak akkor kerül sor, ha a csoport ellenőrzése során kiderült, hogy belül sérülés van.
12. előadás
Tárgy: Címtárrendszerek
A fájlkezelő rendszer és a fájlkészlet közötti kapcsolat az fájl könyvtárat. A címtárrendszer legegyszerűbb formája az, hogy van egy könyvtár, amely az összes fájlt tartalmazza. A könyvtár információkat tartalmaz a fájlokról, beleértve az attribútumokat, a helyet és a tulajdonjogot. A felhasználók szimbolikus nevekkel hivatkoznak a fájlokra. Az emberi memória kapacitása azonban korlátozza azon objektumnevek számát, amelyekre a felhasználó név szerint hivatkozhat. A névtér hierarchikus felépítése lehetővé teszi ezen határok jelentős kiterjesztését. Ezért van a címtárrendszereknek hierarchikus struktúra. A címtárhierarchiát leíró grafikon lehet fa vagy hálózat. A könyvtárak fát alkotnak, ha egy fájl csak egy könyvtárban lehet (7.11. ábra), és hálózatot, ha egy fájl egynél több könyvtárban is lehet.
Például az Ms-Dosban és Windows könyvtárak fastruktúrát alkotnak, UNIX-ban pedig hálózati struktúrát. Általában számítástechnikai rendszer több lemezes eszköz is lehet, még egy PC-nek is mindig több lemeze van: rugalmas, merevlemez, CD-ROM (DVD). Hogyan lehet ilyenkor megszervezni a fájltárolást?
Rizs. Címtárrendszerek
Az első megoldás az, hogy minden eszközön egy offline fájlrendszert kell tárolni, pl. Az ezen az eszközön lévő fájlokat egy könyvtárfa írja le, amelynek semmi köze más eszközökön lévő könyvtárfákhoz. Ebben az esetben a fájl egyedi azonosításához a felhasználónak meg kell adnia a logikai eszközazonosítót az összetett szimbolikus fájlnévvel együtt. Ilyen autonóm létezésre példa az MS-DOS, a Windows 95/98/Me/XP.
Egy másik megoldás a fájltárolás oly módon történő megszervezése, hogy a felhasználónak lehetősége legyen kombinálni a rajta található fájlrendszereket különböző eszközök, egyetlen fájlrendszerbe, amelyet egyetlen könyvtárfa ír le. Ezt a műveletet szerelésnek nevezik.
UNIX rendszeren a rögzítés a következőképpen történik. Az összes elérhető logikai lemezeszköz közül kiemelkedik egy, az úgynevezett rendszer. Legyen két fájlrendszer különböző logikai lemezeken, és az egyik lemez egy rendszer (7.12. ábra).
A fájlrendszer található rendszermeghajtó, gyökérnek nevezzük. A gyökérfájlrendszer fájlhierarchiáinak összekapcsolásához ki kell jelölni néhány meglévő könyvtárat, ebben a példában a loc könyvtárat. A beillesztés befejeztével a kiválasztott loc könyvtár a második fájlrendszer gyökérkönyvtárává válik. Ezen a könyvtáron keresztül a csatolt fájlrendszer részfaként kapcsolódik az általános fához.
Rizs. Beépítési
Tulajdonság
A fájl fogalma nemcsak az általa tárolt adatokat és a nevét tartalmazza, hanem a fájl tulajdonságait leíró információkat is. Ez az információ alkotja a fájl attribútumait. Az attribútumok listája a különböző operációs rendszerekben eltérő lehet. Az alábbiakban látható egy példa a lehetséges attribútumokra.
| Tulajdonság | Jelentése |
| Fájltípus | Normál, katalógus, különleges stb. |
| A fájl tulajdonosa | Jelenlegi tulajdonos |
| Fájlkészítő | A fájlt létrehozó felhasználó azonosítója |
| Jelszó | Jelszó a fájl eléréséhez |
| Idő | Létrehozás, utolsó hozzáférés, utolsó változtatás |
| Jelenlegi fájlméret | Bájtok száma bejegyzésenként |
| Maximális méret | A bájtok száma, amelyre a fájl mérete növelhető |
| Csak olvasható jelző | 0 - olvasás / írás, 1 - csak olvasható |
| "rejtett" zászló | 0 - normál, 1 - nem jelenik meg a katalógusfájllistában |
| „rendszer” megjelölése | 0 - normál, 1 - rendszer |
| „archivált” megjelölés | 0 - archivált, 1 - archívum szükséges |
| ASCII jelző/bináris | 0 - ASCII, 1 - bináris |
| Véletlen hozzáférésű zászló | 0 - csak szekvenciális hozzáférés, 1 - véletlen hozzáférés |
| "ideiglenes" zászló | 0 - normál, 1 - törlés a folyamat befejezése után |
| Kulcspozíció | Eltolás a bejegyzésben lévő kulcshoz |
| Kulcs hossza | Bájtok száma a kulcsmezőben |
A felhasználó hozzáférhet az attribútumokhoz a fájlrendszer által erre a célra biztosított lehetőségekkel. Általában megengedett bármely attribútum értékének kiolvasása, és csak néhány megváltoztatása.
A fájlattribútumok értékei lehetnek könyvtárakban, mint például az MS-DOS-ban (7.7. ábra). Egy másik lehetőség, hogy az attribútumokat speciális táblákba helyezzük, ebben az esetben a könyvtárak hivatkozásokat tartalmaznak ezekre a táblákra.
Rizs. 7. MS DOS fájlattribútumok
ext2(más néven ext2fs) - Második kiterjesztett Fájlrendszer (Second Extended File System) egy Linux kernelre épülő fájlrendszer. Az ext2 megalkotója és fejlesztője a Remy Card. Az ext2 fájlrendszert ő építette a régi helyére, előző verzió- ext.
Az olyan mutatók tekintetében, mint a sebesség és a teljesítmény, ez a fájlrendszer viszonyítási alapként szolgálhat. Ezt bizonyítják a fájlrendszer-teljesítménytesztek eredményei. Például a Dell Tech Center szekvenciális olvasási/írási sebességtesztjeiben az ext2 jobban teljesít, mint az ext3, és csak olvasási sebességben múlja felül a modernebb ext4-et.
Az ext2 fő hátránya, hogy nem naplózó fájlrendszer. Ezt a hiányosságot azonban a következő fájlrendszer - ext3 - megszüntette.
Az ext2 flash kártyákon és szilárdtestalapú meghajtók(SSD), mivel a naplózás hiánya előnyt jelent, ha írási cikluskorlátokkal rendelkező meghajtókkal dolgozik.
A Linux rendszer rohamos fejlődése idején a Minix OS fájlrendszert használta. Elég stabil volt, de 16 bites. Ennek eredményeként partíciónként 64 Mb-os szigorú korlátja volt. Ezenkívül korlátozták a fájlnév maximális hosszát, amely 14 karakter volt.
Ezek a korlátok együttesen indokolták a "bővített fájlrendszer" kifejlesztését (innen a " Bővített fájlrendszer »). Azt a feladatot kapta, hogy oldja meg Minix két kulcsfontosságú problémáját. Az új fájlrendszert 1992 áprilisában hozták nyilvánosságra. Ez volt az Ext, amely a fájl méretkorlátját 2 gigabájtra terjesztette ki, a fájlnév-korlátot pedig 255 karakterre állította.
Az új fájlrendszer sikere ellenére azonban még mindig maradt jó néhány megoldatlan probléma. Például nem támogatták a külön hozzáférést, nem voltak időbélyegek az adatok módosításához. Ezeknek a problémáknak a megoldása volt az indítéka a kiterjesztett ext2 fájlrendszer következő verziójának (" Második kiterjesztett fájlrendszer). Az ext2-t 1993 januárjában fejlesztették ki, és POSIX-kompatibilis ACL-eket és kiterjesztett fájlattribútumokat is megvalósított.
Az ext2 címtárhierarchia gráf hálózatként jelenik meg. Ez annak köszönhető, hogy egy fájl egyszerre több könyvtárba is bekerülhet.
Minden fájltípusnak szimbolikus neve van. A hierarchikusan szervezett fájlrendszerekben általában háromféle nevet használnak: egyszerű, összetett és relatív. Ugyanez az ext2-vel. Egyszerű név esetén a korlátozás az, hogy hossza ne haladja meg a 255 karaktert, emellett a név ne tartalmazzon NULL karaktert és perjelet.
Ami a NULL karaktert illeti, a korlátok a karakterláncok C nyelvi megjelenítéséhez kapcsolódnak, a perjel karakter esetében minden abban rejlik, hogy elválasztó karakterként használják a könyvtárak között.
A teljesen minősített név az összes könyvtár egyszerű szimbolikus neveinek lánca, amelyen keresztül az elérési út a gyökértől a adott fájl. Az ext2-ben egy fájl több könyvtárban is lehet, ami azt jelenti, hogy több teljes neve is lehet (egy fájl, több teljes név). De egyébként is a teljes név határozza meg a fájlt.
ext2 attribútumok:
A fájlattribútumok speciális táblákban tárolódnak, nem könyvtárakban, ahogy az egyszerű fájlrendszerekben megszokott. Ennek eredményeként a katalógusnak nagyon egyszerű szerkezet, amely két részből áll: egy inode számból és egy névből.
Lemezpartíció szerkezete
Az ext2 részeként a következők különböztethetők meg:
A teljes lemezpartíció fix méretű blokkokra van osztva, amelyek a szektorméret többszörösei (1024, 2048, 4096 vagy 8192 bájt). A blokk mérete a lemezpartíción lévő fájlrendszer létrehozásakor kerül megadásra. Minden blokk sorozatszámot kap. A töredezettség és a fej mozgásának csökkentésére merevlemez nagy adattömbök olvasásakor a blokkokat csoportokba vonják össze.
A fájlrendszer alapkoncepciója az inode (más néven inode - információs csomópont). Ez egy speciális struktúra, amely információkat tartalmaz a fájl tulajdonságairól és fizikai helyéről. Az index-dekódolókat egy táblázatba egyesítik, amely az egyes blokkcsoportok elején található. A szuperblokk az ext2 fájlrendszer fő eleme. Általános információkat tartalmaz a fájlrendszerről. A szuperblokk 1024 bájtra található a szakasz elejétől számítva. A szuperblokk integritása határozza meg a fájlrendszer állapotát. Az operációs rendszer több biztonsági másolatot készít a szuperblokkról - arra az esetre, ha a partíció megsérül. A szuperblokk után következő blokk egy globális leíró táblát tartalmaz - a blokkcsoportok leírása tömb formájában, általános információkkal az összes blokkcsoportról.
Csoport blokkolása
Az ext2 partíción lévő összes blokk csoportokra van osztva. Minden csoporthoz külön bejegyzés jön létre a globális leíró táblában. Ez a bejegyzés az alapvető paramétereket tárolja, mint például: a blokkszám bittérképekben és táblázatokban, a szabad blokkok száma a csoportban, a könyvtárakat tartalmazó inode-ok száma.
Bittérkép blokkolása egy olyan rendszer, amelyben minden bit tájékoztat arról, hogy a neki megfelelő blokk hozzá van-e rendelve valamelyik fájlhoz. Ha a bit 1, akkor a blokk foglalt. Az inode bitmap hasonló funkciót lát el: megmutatja, hogy mely inódok foglaltak és melyek nem. A Linux kernel megpróbálja egyenletesen elosztani a könyvtári inódákat csoportokba, és áthelyezi a fájlinódákat a szülőkönyvtárral rendelkező csoportba. Az összes fennmaradó terület, amely a táblázatban adatként jelenik meg, a fájlok tárolására van lefoglalva.
Adatcímző rendszer
Az adatcímző rendszer a fájlrendszer egyik legkomolyabb és legfontosabb összetevője. Ennek köszönhetően a kívánt fájl a lemezen található sok üres vagy foglalt blokk között található.
Az ext2 a következő fájlblokk-címzési sémát használja. A fájl címének tárolásához 15 mező van lefoglalva, amelyek mindegyike 4 bájtból áll. Ha a fájl 12 blokkba illeszkedik, akkor a megfelelő klaszterek számai a cím első tizenkét mezőjében szerepelnek. Ha a fájl mérete meghaladja a 12 blokkot, akkor a következő mező annak a klaszternek a címét tartalmazza, amelyben a fájl következő blokkjainak száma található. Így a tizenharmadik mezőt indirekt címzésre használjuk.
A 4096 bájt maximális blokkméret mellett a 13. mezőnek megfelelő fürt legfeljebb 1024 következő blokkszámot tartalmazhat a fájlban. Ha a fájl mérete meghaladja a 12+1024 blokkot, akkor a 14. mező kerül felhasználásra, amely egy 1024 fürtszámot tartalmazó fürt címét tartalmazza, amelyek mindegyike a fájl 1024 blokkjára vonatkozik. Itt kettős indirekt címzést használnak. És ha a fájl több mint 12 + 1024 + 1048576 blokkot tartalmaz, akkor az utolsó 15. mező a hármas közvetett címzésre szolgál.
Egy ilyen címzési rendszer 4096 bájt maximális blokkméret mellett lehetővé teszi a 2 TB-nál nagyobb fájlok használatát.
Tekintsük az ext2fs fájlrendszer logikai felépítését. Fizikailag HDD 512 bájtos szektorokra osztva. Bármely fájlrendszerben a lemezpartíció első szektora tekinthető rendszerindítási területnek. Az elsődleges partícióban ez a terület egy rendszerindítási bejegyzést tartalmaz, egy kódrészletet, amely elindítja az operációs rendszer rendszerindítási folyamatát az indításkor. Ezt a területet más szakaszokon nem használják. A fennmaradó szektorok 1, 2 vagy 4 kilobyte-os logikai blokkokba vannak kombinálva. A logikai blokk a legkisebb címezhető adatrész: minden fájl adata egész számú blokkot foglal el. A blokkokat pedig blokkcsoportokká egyesítik. A blokkcsoportok és a csoporton belüli blokkok sorszámozása 1-től kezdődően történik.
Az ext2fs fájlrendszerrel végzett munka során használt adatszerkezetek leírása az /usr/include/linux/ext2fs .h fejlécfájlban található.
A szuperblokk a fájlrendszer kiindulópontjaként szolgál, és mindent tárol
információkat róla. Mérete 1024 bájt, és a fájlrendszer kezdetétől 1024 bájtnyi eltolásban található. Minden blokkcsoportban megduplázódik, ami lehetővé teszi, hogy gyorsan visszaállítsa a hibák után. A szuperblokk meghatározza a fájlrendszer méretét, a fájlok maximális számát a partícióban, a szabad terület mennyiségét, és információkat tartalmaz arról, hogy hol kell keresni a fel nem osztott területeket. Amikor az operációs rendszer elindul, a szuperblokk beolvassa a memóriába, és a fájlrendszer minden változása először az operációs rendszerben található szuperblokk másolatában jelenik meg, és csak időszakonként íródik a lemezre. Ez javítja a rendszer teljesítményét, mivel sok felhasználó és folyamat folyamatosan frissíti a fájlokat. Másrészt, amikor a rendszer leáll, a szuperblokkot lemezre kell írni, ami nem teszi lehetővé a számítógép kikapcsolását egyszerűen az áramellátás kikapcsolásával. Ellenkező esetben a következő indításkor a sunerblockban rögzített információk nem lesznek meg
megfelel a fájlrendszer aktuális állapotának.
A blokkcsoport leírása (leírója) a szuperblokkot követi. A benne tárolt információk segítségével blokk- és inode-bittérképeket, valamint inode-táblázatot találhatunk.
A blokk bittérkép egy olyan struktúra, amelynek minden bitje jelzi, hogy azonos számú blokk van-e hozzárendelve bármely fájlhoz. Az 1-es érték azt jelzi, hogy a blokk foglalt. Ez a térkép szabad blokkok keresésére szolgál olyan esetekben, amikor helyet kell lefoglalni egy fájl számára..
Az inode bitmap hasonló funkciót lát el, mint az inode tábla: megmutatja, mely inode-ok foglaltak.
Minden fájlnak egy és csak egy inode van (inode, i-node, információs csomópont), amelyet a sorozatszáma - a fájl indexe - azonosít. Az inode tartalmazza a fájl metaadatait. Ezek között megtalálható a fájl összes attribútuma, kivéve a nevét és a fájl adataira mutató mutatót.
Normál fájl vagy könyvtár esetén ez a mutató egy 15 blokkcímből álló tömb. Ebben a tömbben az első 12 cím közvetlen hivatkozás a blokkszámokhoz, ahol a fájladatokat tárolják. Ha az adatok nem férnek el 12 blokkba, akkor az indirekt címzési mechanizmus aktiválódik. A következő cím ebben a tömbben egy közvetett hivatkozás, vagyis egy blokk címe, amely a következő blokkok címlistáját tárolja az ebből a fájlból származó adatokkal.
Hány adatblokkot lehet így megcímezni? A blokk címe 4 bájt, a blokk, mint már említettük, 1, 2 vagy 4 kilobájt. Ez azt jelenti, hogy 256 - 1024 blokk helyezhető el indirekt címzéssel.
Mi van, ha a fájl még hosszabb? A mutatótömb következő címe a kettős indirekt blokkra mutat. (dupla blokk közvetett). Ez a blokk a blokkcímek listáját tartalmazza, amelyek viszont a következő adatblokkok címlistáit tartalmazzák.
És végül, a mutatótömb utolsó címe egy hármas indirekt blokk címét adja meg, vagyis egy olyan blokk címét, amelyen a blokkcímek listája kettős indirekt blokkok.
Egyelőre nem világos, hol található a fájlnév, ha nem szerepel sem a fájladatok között, sem a metaadatai között. UNIX-szerű rendszerekben a fájlnév nem magának a fájlnak, hanem a fájlrendszernek az attribútuma, ami logikai könyvtárszerkezetként értendő. A fájlnév csak abban a könyvtárban tárolódik, amelyhez a fájl hozzá van rendelve, és sehol máshol. Ebből furcsa következmények következnek.
Először is, tetszőleges számú, különböző könyvtárakhoz rendelt név megfelelhet egy inode-nak, és mindegyik valódi. A nevek (kemény hivatkozások) számát az inode számolja. Ez az az összeg, amelyet az Is -1 paranccsal láthat.
Másodszor, egy fájl törlése egyszerűen azt jelenti, hogy törli a bejegyzését a könyvtáradatokból, és 1-gyel csökkenti a hivatkozások számát.
Harmadszor, egy név csak ugyanazon a fájlrendszeren belül párosítható egy inode számmal, ezért nem hozható létre merev hivatkozás egy másik fájlrendszerre (szimbolikusan - lehet, annak más a tárolási mechanizmusa).
Maga a könyvtár szintén hozzá van rendelve a szülőkönyvtárához. A gyökérkönyvtár mindig a 2-es számú inode-ba íródik (az 1-es szám a hibás blokkcímlistához van fenntartva). Minden könyvtár tartalmaz egy hivatkozást önmagára és a szülőkönyvtárára – ezek a "" pszeudo-alkönyvtárak. És "...".
Így egy könyvtárra mutató hivatkozások száma megegyezik az alkönyvtárak számával plusz kettővel.
A címtáradatok egy csatolt lista változó hosszúságú bejegyzésekkel, és így néz ki:
Az ext2fs könyvtárszerkezete
Mi a helyzet a fizikai eszköz fájljaival? Ugyanolyan könyvtárakban is elhelyezkedhetnek, mint a hagyományos fájlok: a könyvtárban nincs olyan adat, amely jelezné, hogy a név lemezen lévő fájlhoz vagy eszközhöz tartozik-e. A különbség az inode szinten van. Ha egy normál fájl i-csomópontja azokra a lemezblokkokra mutat, ahol az adatait tárolják, akkor az eszközfájl i-csomópontja tartalmaz egy mutatót a kernelben lévő eszközillesztő-listára - a lista azon elemére, amelyik megfelel fő eszközszám:
Különbség a normál fájl és az eszközfájl között
Az ext2fs fájlrendszer tulajdonságai:
A fájlrendszer maximális mérete 4 TB.
A maximális fájlméret 2 GB.
A fájlnév maximális hossza 255 karakter.
A minimális blokkméret 1024 bájt.
A lefoglalt inódok száma a partíció 4096 bájtjaként 1.
VLADIMIR MESKOV
ext2 fájlrendszer architektúra
A cikk az ext2, a Linux operációs rendszer fájlrendszerének logikai felépítését tárgyalja.
Az ext2 fájlrendszer alapvető összetevői
Mint minden UNIX fájlrendszerben, az ext2 fájlrendszerben is a következő összetevők különböztethetők meg:
Blokkok és blokkcsoportok
A teljes lemezpartíció fix méretű blokkokra van osztva, amelyek a szektorméret többszörösei - 1024, 2048 és 4096 bájt. A blokk méretét a merevlemez-partíción lévő fájlrendszer létrehozásakor adja meg. A kisebb blokkméret helyet takarít meg a merevlemezen, de korlátozza a fájlrendszer maximális méretét is. Minden blokknak van sorozatszáma. A töredezettség és a merevlemez fejmozgások számának csökkentése érdekében nagy adattömbök olvasásakor a blokkokat csoportokba egyesítik.
Információs csomópont
A fájlrendszer alapkoncepciója egy információs csomópont, információs csomópont vagy inode. Ez egy speciális struktúra, amely információkat tartalmaz egy fájl attribútumairól és fizikai helyéről. A fájl attribútumai a típusa (normál fájl, könyvtár stb.), a hozzáférési jogosultságok, a tulajdonos azonosítója, mérete, létrehozási ideje. A fizikai hely információ fájladatokat tartalmazó abszolút blokkszámok sorozata.
Superblock
A szuperblokk az ext2 fájlrendszer fő eleme. A következő információkat tartalmazza a fájlrendszerről (a lista nem teljes):
Más szóval, ez a szuperblokkot tartalmazó blokk száma. Ez a szám mindig 0, ha a fájlrendszer blokkmérete nagyobb, mint 1024 bájt, és 1, ha a blokk mérete 1024 bájt.
A fájlrendszer állapota közvetlenül függ a szuperblokk integritásától. Az operációs rendszer több biztonsági másolatot készít a szuperblokkról, hogy sérülés esetén visszaállítható legyen. A főpéldány 1024 bájtnyi eltolásban található annak a partíciónak a kezdetétől, amelyen a fájlrendszer létrejött (az első 1024 bájt az operációs rendszer betöltője számára van fenntartva).
Az ext2 fájlrendszer korai verziói szuperblokk-másolatokat hoztak létre minden blokkcsoport elején. Ez nagy veszteségeket eredményezett. lemez terület, így később a szuperblokk-mentések számát csökkentették, és ezek elhelyezésére a 0, 1, 3, 5 és 7 blokkcsoportokat osztották ki.
Blokkcsoport formátuma
ábrán látható az ext2 fájlrendszer általánosított blokkdiagramja. 1.
Szinte minden blokkcsoportnak azonos a formátuma. Minden csoportban az információs blokkok mellett bittérkép formájában tárolják a csoport blokkjainak és inódjainak foglaltságára vonatkozó információkat. A 0. blokkcsoport egy szuperblokkot és egy csoportleíró táblázatot is tartalmaz, amelyeket az alábbiakban tárgyalunk.
A blokk foglalt bittérkép általában a csoport első blokkjában található. Ha a csoportban van tartalék szuperblokk, akkor a bittérkép a csoport második blokkjában található. A bittérkép mérete egy blokk. Ennek a térképnek minden bitje a blokk állapotát jelzi. Ha a bit be van állítva (1), akkor a blokk foglalt, ha visszaállítja (0), akkor a blokk szabad. A csoport első blokkja a térkép nulla bitjének, a második blokk az első bitnek felel meg, és így tovább.
Az azonos csoporton belüli inódákat egy táblázatba gyűjtjük. Egy csoport inode foglaltsági bittérképében minden bit egy elem állapotát jelenti a csoport inode táblájában.
Minden blokkcsoportot egy blokkcsoport-leíró ír le. A csoportleíró egy olyan struktúra, amely információkat tartalmaz a megfelelő csoport blokk foglalt bittérképének, foglalt inode bittérképének és inode táblájának címeiről. Az összes csoportleírót egy csoportleíró táblába gyűjtjük, amely a 0. blokkcsoportban van tárolva. Ugyanaz, mint a szuperblokknál, operációs rendszer létrehozza biztonsági mentések csoportleíró táblázatok.
Fájlolvasási algoritmus
Minden inode, mint egy blokk, rendelkezik egy sorszámmal, amely egyedi a fájlrendszeren belül, és csak egy fájlról tartalmaz információt. Így egy fájl tartalmához való hozzáféréshez ismerni kell a hozzá tartozó inode sorszámát.
Mint fentebb említettük, a fájl fizikai helyére vonatkozó információkat az inode tartalmazza. Ez az információ a fájladatokat tartalmazó 32 bites blokkszámok sorozata (1. ábra). Az első 12 szám közvetlen hivatkozás az információs blokkokhoz (közvetlen blokkszám). A 13. szám egy közvetett blokkszám. A blokk címét tartalmazza, amely az információs blokkok címeit tárolja. A 14. szám egy dupla indirekt link (dupla blokkszám), a 15. szám egy hármas közvetett kapcsolat (hármas blokkszám).
A fájlnév nem része az inode-nak, a fájlnevek és az inode sorszámok közötti leképezés könyvtárakon keresztül történik.
Katalógusok
A UNIX és POSIX rendszereken található fájlok egy faszerű hierarchikus fájlrendszerben tárolódnak. A fájlrendszer gyökere a gyökérkönyvtár, amelyet a "/" szimbólum jelöl. A fájlrendszerfa minden köztes csomópontja egy könyvtár. A fájlrendszerfa levélcsomópontjai vagy üres könyvtárak vagy fájlok. A fájl abszolút elérési útja a megadott fájlhoz vezető összes könyvtár nevéből áll, a gyökérkönyvtártól kezdve. Például a /home/test.file elérési út azt jelenti, hogy a test.file fájl a kezdőkönyvtárban található, amely viszont a gyökérkönyvtárban található "/".
A könyvtárakat, akárcsak a fájlokat, inode írja le. A könyvtár tartalma bejegyzések tömbje, amelyek mindegyike az aktuális könyvtárban "belül" lévő fájlról tartalmaz információt.
A címtárbejegyzés formátuma a következő:
A fájl inode-számának keresése mindig a gyökérkönyvtárban kezdődik. Például a gyökérkönyvtárban található fájl inode számának lekéréséhez az operációs rendszernek be kell szereznie a gyökérkönyvtár tartalmát, meg kell találnia benne egy bejegyzést a fájl nevével, és ebből a bejegyzésből ki kell bontania a fájl inode számát. .
Az első néhány inode-ot a fájlrendszer lefoglalja, és a fejlécfájlban vannak felsorolva:
*Speciális inode számok
#define EXT2_BAD_INO 1 /* Hibás 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 loader inode */
#define EXT2_UNDEL_DIR_INO 6 /* Inode könyvtár törlésének visszavonása */
A 2. számú inode (root inode) a gyökérkönyvtár bejegyzés számára van fenntartva. Ez az inode a 0. blokkcsoportban található, és a második pozíció a csoport inode táblájában. Az első lefoglalt inode száma a szuperblokkban tárolódik.
Miután meghatározta a fájl inode sorszámát, a kernel kiszámítja annak a csoportnak a számát, amelyben ez az inode található, és annak helyét a csoport inode táblájában. Ebből az inode pozícióból olvasva az operációs rendszer teljes információt kap a fájlról, beleértve azon blokkok címét is, amelyekben a fájl tartalma tárolva van.
A blokkcsoport számát, amelyben az inode található, a következő képlettel számítjuk ki:
csoport = (inode_szám - 1) / inodes_per_group
Ahol:
Az inode pozícióját a csoport inode táblázatában a következő képlet határozza meg:
index = (inode_szám - 1) % inodes_per_groupe
ahol az index az inode pozíciója a táblázatban.
Vegyünk egy példát a gyökérkönyvtárban található test.file fájl tartalmának lekérésére. A /test.file fájl olvasásához a következőket kell tennie:
ábrán. A 2. ábra a /test.file olvasásának lépéseit mutatja be részletesen.
1-6 lépések – a gyökérkönyvtár olvasása:
Az inode szám megadásával elérhetők a fájl információs blokkjai (7-11. lépések):
A fájlolvasási algoritmus szoftveres megvalósítása
Kezdeti adatok: van egy merevlemez-partíció, amelyen az ext2 fájlrendszer létrejön. Ez a partíció a /dev/hda3 eszközfájlnak felel meg. A home alkönyvtár a partíció gyökérkönyvtárában lett létrehozva, és a következő tartalommal tartalmazza a test.file fájlt:
A citrusfélék élnének a déli bozótosban?
Igen, de hamis másolat!
1234567890-=
Ne gondolj rosszra, ez nem hülyeség, hanem próbagyakorlat a volt Szovjetunió jelzőcsapatainak távíró-kezelői tanfolyamáról!
Figyelem! Figyelembe kell venni fontos pont. A létrehozott fájl nem kerül azonnal a lemezre, hanem először a lemez pufferébe kerül. A fájl tartalmának azonnali lekérésére tett kísérlet a fenti algoritmussal nem vezet semmire, mivel a lemezen fizikailag nincs információ erről a fájlról. „Kényszeríteni” kell a rendszert, hogy a lemezpuffert lemezre írja. 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.
A feladatunk az, hogy a /dev/hda3 eszközfájl segítségével olvassuk be a /home/test.file fájlt, közvetlenül hozzáférve az információs blokkjaihoz.
Fontolja meg a műveletet végrehajtó modul szoftveres megvalósítását.
Fejléc fájlok:
#beleértve
#beleértve
#beleértve
#beleértve
#beleértve
#beleértve
A fejlécfájl olyan szerkezeti típusokat határoz meg, amelyek leírják az ext2 fájlrendszer fő összetevőit - szuperblokk, blokkcsoport-leíró, információs csomópont, könyvtárbejegyzés.
Tekintsük röviden azokat a mezőket, amelyeket ezek a struktúrák tartalmaznak:
Az EXT2_N_BLOCKS értéke a következő fájlban van megadva:
* Az adatblokkokhoz viszonyított állandók
#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)
#define EXT2_NAME_LEN 255
Határozzuk meg a partíció nevét, amelyen a fájlrendszer létrejött, a globális struktúrákat és a változókat.
#define PART_NAME "/dev/hda3"
struct ext2_super_block sb;
/* puffer a csoportleíró táblázat tárolására */
unsigned char buff_grp;
unsigned char buff; /* információs puffer */
int indev; /* eszközfájl-leíró */
int BLKSIZE; /* fájlrendszer blokk mérete */
Határozunk meg néhány funkciót, amelyek működéséhez szükségünk van:
Superblock olvasási funkció:
void read_sb()
memset(&sb,0,1024);
1024 bájtot tolunk el a szakasz elejétől, és beolvassuk a szuperblokkot a struct ext2_super_block sb struktúrába:
If(lseek(indev;1024;0)< 0) {
error("lseek");
Kilépés(-1);
If(read(indev,(char *)&sb,sizeof(sb))< 0) {
error("olvasás");
Kilépés(-1);
A fájlrendszer azonosítójának ellenőrzése:
If(sb.s_magic != EXT2_SUPER_MAGIC) (
Printf("Ismeretlen fájlrendszer típus!");
Kilépés(-1);
Az EXT2_SUPER_MAGIC értéket a fejlécfájl határozza meg.
Információkat jelenítünk meg a szuperblokkban lévő fájlrendszerről:
printf(" Superblock info ----------- ");
Printf("Inodes count - %u ",sb.s_inodes_count);
Printf("Blokkszám - %u ",sb.s_blocks_count);
Printf("Blokkméret - %u ",1024<< sb.s_log_block_size);
Printf("Első inode - %d ",sb.s_first_ino);
Printf("Magic - 0x%X ",sb.s_magic);
Printf("Inode mérete - %d ",sb.s_inode_size);
Printf("Inódok csoportonként - %u ",sb.s_inodes_per_group);
Printf("Blokok csoportonként - %u ",sb.s_blocks_per_group);
Printf("Első adatblokk - %u ",sb.s_first_data_block);
Visszatérés;
Csoportleíró táblázat olvasási funkciója:
void read_gdt()
Számítsa ki a fájlrendszer blokkméretét:
BLKSIZE = 1024<< sb.s_log_block_size
A csoportleíró tábla az első adatblokkot közvetlenül követő blokkban (a szuperblokk mögött) található.
A táblázat olvasása:
If(lseek(indev, (sb.s_first_data_block + 1) * BLKSIZE, 0)< 0) {
error("lseek");
Kilépés(-1);
If(read(indev,buff_grp,BLKSIZE)< 0) {
error("olvasás");
Kilépés(-1);
Visszatérés;
A függvény, amely egy inode tartalmát a száma alapján kapja meg:
void get_inode(int inode_num, struct ext2_inode *in)
A függvény bemeneti paraméterei az inode száma és a struct ext2_inode struktúra.
Struct ext2_group_desc gd;
U64 csoport, index, poz.
Kiszámoljuk annak a blokkcsoportnak a számát, amelyben az inode_num sorszámú inode található:
Csoport = (inode_szám - 1) / sb.s_inodes_per_group;
Bontsa ki a csoportleírót a csoportleíró táblából, és másolja a struct ext2_group_desc gd szerkezetébe:
Memset((void *)&gd, 0, sizeof(gd));
Memcpy((void *)&gd, buff_grp + (csoport * (sizeof(gd))), sizeof(gd));
Kiszámoljuk az inode_num sorszámú inode pozícióját a csoportcsoport inode táblájában, és beolvassuk ezt az inode-ot az ext2_inode struktúrába:
index = (inode_szám - 1) % sb.s_inodes_per_group;
Pos = ((__u64)gd.bg_inode_table) * BLKSIZE + (index * sb.s_inode_size);
Preread64(indev, in, sb.s_inode_size, pos);
Visszatérés;
Adatblokk olvasási funkciója:
void read_iblock(struct ext2_inode *in, int blk_num)
U64pos;
A függvény bemeneti paraméterei az inode struktúra és a blokkszám (értsd: az inode-ban található címblokkok sorozatából származó szám).
Kiszámoljuk az eltolást a partíció információs blokkjához, és beolvassuk ezt a blokkot a globális pufferbe:
Pos = ((__u64)in->i_block) * BLKSIZE;
Preread64(indev, buff, BLKSIZE, poz);
Visszatérés;
A gyökérkönyvtár tartalmának lekérésére szolgáló függvény:
void get_root_dentry()
Az ext2_inode szerkezete in;
A gyökérkönyvtár inode száma ismert, ezért megkapjuk a gyökérkönyvtár inode tartalmát, és beolvassuk a tartalmát a puffer pufferbe:
get_inode(EXT2_ROOT_INO, &in);
Read_iblock(&in, 0);
A puffer puffer tartalmazza a gyökérkönyvtár tartalmát.
Visszatérés;
Funkció az inode szám lekéréséhez a fájlnévből:
int get_i_num(char *name)
A függvény bemeneti paraméterei a fájlnév. A visszatérési érték a fájl inode száma.
int i = 0, rec_len = 0;
Struct ext2_dir_entry_2dent;
A puffer puffer könyvtárbejegyzések tömbjét tartalmazza. Egy fájl inode számának meghatározásához meg kell találnia egy bejegyzést ebben a tömbben a fájl nevével:
For(; i< 700; i++) {
Memcpy((void *)&dent, (buff + rec_len), sizeof(dent));
If(!memcmp(dent.name, name, dent.name_len)) break;
Rec_len += dent.rec_len;
Return dent.inode;
Most írjuk fel a fő függvényt:
int main()
Változók és struktúrák:
struct ext2_inode in;
// a fájl abszolút elérési útja
Unsigned char *full_path = "/home/test.file";
unsigned char buff1;
Statikus int i = 1;
int n, i_num, outf, type;
A fájl abszolút elérési útjában az első karakternek perjelnek (/) kell lennie. Nézzük meg:
If(teljes_útvonal != "/") (
error("perjel");
Kilépés(-1);
Nyissa meg az eszközfájlt, olvassa el a szuperblokk- és csoportleíró táblázatot:
indev = open(PART_NAME,O_RDONLY);
if(indev< 0) {
error("nyitva");
Kilépés(-1);
Read_sb();
Read_gdt();
Szerezd meg a gyökérkönyvtár tartalmát:
get_root_dentry();
A buff puffer mostantól a gyökérkönyvtár összes bejegyzését tartalmazza (ha szeretné, külön fájlba mentheti). Most, hogy megvannak a gyökérkönyvtár bejegyzései, a fenti fájlolvasási algoritmus segítségével elérhetjük a test.file tartalmát. Ennek érdekében ciklust szervezünk. A ciklus törzsében elemezzük a fájl abszolút elérési útját, kiemelve annak elemeit - alkönyvtárakat (van ilyenünk, home) és a kívánt fájl nevét (test.file). Minden elemhez meghatározzuk az inode sorszámát, kiolvassuk ezt az inode-ot, majd megkapjuk a nulla blokk tartalmát (az inode-ban található címblokkok sorozatából):
míg(1) (
memset(buff1,0,sizeof(buff1));
For(n = 0 ; n< EXT2_NAME_LEN; n++, i++) {
Buff1[n] = teljes_útvonal[i];
If((buff1[n] == "/") || (buff1[n] == "?")) (
I++;
szünet;
buff1[n] = "?";
A fájl abszolút elérési útjának minden eleméhez meghatározzuk az inode sorszámát, beolvassuk a memóriába, majd megkapjuk a nulla blokk tartalmát:
I_szám = get_i_num(buff1);
Get_inode(i_num, &in);
Read_iblock(&in, 0);
Mutassunk információkat a fájlról (név, inode száma, fájlméret és típus):
Printf("Inode szám - %u ", i_szám);
Printf("Fájlnév - %s ", buff1);
Printf("Fájlméret - %u ",in.i_size);
A fájltípust a struct ext2_inode struktúra i_mode mezőjének felső négy bitje határozza meg:
type = ((in.i_mode & 0xF000) >> 12);
Printf("Típus - %d ",típus);
kapcsoló(típus) (
Case (0x04):
Printf("(könyvtár)");
szünet;
Case (0x08):
Printf("(normál fájl)");
szünet;
Case (0x06):
Printf("(eszközfájl blokkolása)");
szünet;
Case (0x02):
Printf("(char eszközfájl) ");
szünet;
alapértelmezett:
Printf("(ismeretlen típus)");
szünet;
A fájl típusának ellenőrzése. Ha ez egy normál fájl, megtörjük a hurkot:
if(type & 0x08) (
A puffer puffer tartalmazza a /home/test.file fájl információs blokkjaiból kiolvasott információkat. Írjuk ezt az információt egy fájlba:
Outf = open("out",O_CREAT|O_RDWR,0600);
Write(outf, buff, sizeof(buff));
bezár(outf);
szünet;
Kijárat:
bezár(indev);
visszatérés 0;
Ezzel befejeztük az ext2 fájlrendszer logikai szerkezetének vizsgálatát.
Most leírjuk a legnépszerűbb Linux lemezfájlrendszert, az ext2-t. A Linux első kiadása a MINIX 1 fájlrendszert használta, amely rövid fájlnevekkel és 64 MB maximális fájlmérettel rendelkezett. A MINIX 1 fájlrendszert végül felváltotta az első kiterjesztett fájlrendszer, az ext, amely hosszabb fájlneveket és nagyobb fájlméreteket tett lehetővé. Az ext rendszert alacsony hatékonysága miatt (teljesítmény szempontjából) felváltotta a ma is széles körben használt ext2 utódja.
Az ext2-vel rendelkező lemezpartíció az ábrán látható fájlrendszert tartalmazza. 10.17 elrendezés. A 0-s blokkot a Linux rendszer nem használja, és a számítógép indítókódját tartalmazza. A 0. blokkot követően a lemezpartíció blokkcsoportokra van osztva (figyelmen kívül hagyva a lemezhenger határait). Minden csoport a következőképpen van felszerelve.
Az első blokk a szuperblokk, amely információkat tárol a fájlrendszer elrendezéséről, beleértve az i-node-ok számát, a lemezblokkok számát, a szabad lemezblokkok listájának elejét (általában több száz elem). Ezt követi egy csoportleíró, amely információkat tartalmaz a bittérképek helyéről, a csoportban lévő szabad blokkok és i-csomópontok számáról, valamint a csoportban lévő könyvtárak számáról. Ez az információ azért fontos, mert az ext2 fájlrendszer megpróbálja egyenletesen elosztani a könyvtárakat a lemezen.
A két bittérkép nyomon követi a szabad blokkokat és a szabad i-csomópontokat (ez szintén a MINIX 1 fájlrendszertől származik, és megkülönbözteti a legtöbb UNIX fájlrendszertől, amely listát használ a szabad blokkokhoz). Minden bittérkép mérete egy blokk. 1 KB-os blokkmérettel ez a séma 8192 blokkra és 8192 i-csomópontra korlátozza a blokkcsoport méretét. Az első szám valódi határ, a második pedig gyakorlatilag semmi. 4 KB-os blokkokkal a számok négyszer nagyobbak.
Ezután maguk az i-csomópontok találhatók. 1-től maximumig vannak számozva. Minden i-csomópont 128 bájt méretű, és pontosan egy fájlt ír le. Az i-csomópont könyvelési információkat tartalmaz (beleértve mindazt, amit a stat hívás visszaadott, amely egyszerűen átveszi azt az i-node-tól), valamint elegendő információt a fájladatokat tartalmazó lemezblokkok megtalálásához.
Az i-csomópontokat adatblokkok követik. Az összes fájl és könyvtár itt tárolódik. Ha egy fájl vagy könyvtár több blokkból áll, akkor ezeknek a blokkoknak nem kell egymás mellett lenniük a lemezen. Valójában a blokkok nagy fájl valószínűleg szétszórva vannak a lemezen.
A könyvtáraknak megfelelő i-csomópontok szétszórva vannak az összes lemezblokk-csoportban. Az Ext2 megpróbálja a normál fájlokat ugyanabba a blokkcsoportba helyezni, mint a szülőkönyvtár, az adatfájlokat pedig ugyanabba a blokkba, mint a forrásfájl i-csomópontja (feltéve, hogy van ott elég hely). Ezt az ötletet a Berkeley Fast File System-től kölcsönözték (McKusick et al., 1984). Fogadásra bittérképeket használnak gyors javítások a kiválasztással kapcsolatban
helyek az új fájlrendszeradatok számára.
Új fájlblokkok lefoglalásakor az ext2 néhány (nyolc) további blokkot is előre lefoglal ugyanahhoz a fájlhoz (hogy minimalizálja a fájl töredezettségét a jövőbeni írások miatt). Ez a séma szétosztja a fájlrendszert a lemezen. Jó a teljesítménye is (összefüggő jellegének és csökkentett töredezettségének köszönhetően).
Egy fájl eléréséhez először az egyik Linux rendszerhívást (például open) kell használnia, amelyhez meg kell adnia a fájl elérési útját. Ezt az elérési utat a rendszer elemzi, és az alkotó könyvtárakat kivonja belőle. Ha relatív elérési út van megadva, akkor a keresés a folyamat aktuális könyvtárából indul, ellenkező esetben a gyökérkönyvtárból. Mindenesetre az első könyvtár i-node-ja könnyen megtalálható: a folyamatleíróban van rá mutató, vagy (a gyökérkönyvtár esetében) egy adott blokkban van eltárolva a lemezen.
A könyvtár legfeljebb 255 karakter hosszú fájlneveket tesz lehetővé (10.18. ábra). Minden könyvtár számos lemezblokkból áll (így a könyvtárat atomosan lehet lemezre írni). Egy könyvtárban a fájlok és könyvtárak elemei rendezetlen sorrendben vannak (minden elem közvetlenül követi az előzőt). Az elemek nem léphetik át a blokkhatárokat, ezért általában minden lemezblokk végén van némi fel nem használt bájt.
ábrán látható minden egyes címtárbejegyzés. A 10.18 négy fix hosszúságú mezőből és egy változó hosszúságú mezőből áll. Az első mező az i-node száma, amely 19 a kolosszális fájlnál, 42 a terjedelmes fájlnál és 88 a bigdir könyvtárnál. Ezután jön a rec_len mező, amely a teljes könyvtárbejegyzés méretét adja meg bájtokban (esetleg a név után további kitöltő bájtokkal). Ez a mező a következő bejegyzés megkereséséhez szükséges (abban az esetben, ha a fájlnév ismeretlen számú bájttal van kitöltve). Az ábrán ezt a mezőt nyíl jelzi. Ezután van egy fájl típusú mező, könyvtár stb. Az utolsó rögzített hosszúságú mező a fájlnév hosszát tartalmazza bájtokban (8, 10 és 6 ezt a példát). Végül ott van maga a fájlnév, amelyet egy null bájt zár le, és egy 32 bites határra van kitömve. Ezt további kitöltési bájtok követhetik.
ábrán. A 10.18b ugyanazt a könyvtárat mutatja, miután a voluminous elemet eltávolították. A címtárban mindössze annyit kell tenni, hogy növeljük a rekordméret mezőben a számot. előző fájl kolosszális, és a címtárbejegyzés bájtjait távoli fájl terjedelmes fordulat az első rekord helyőrzőivé. Ezt követően ezek a bájtok használhatók írásra új fájl létrehozásakor.
Mivel a könyvtárak keresése lineárisan történik, sok időbe telhet egy olyan bejegyzés megtalálása, amely egy nagy könyvtár végén található. Ezért a rendszer gyorsítótárat tart fenn a legutóbb elért könyvtárakról. A gyorsítótárban fájlnév alapján keresnek, és ha megtalálják, akkor már nincs szükség a drága lineáris keresésre. Minden egyes elérési út-összetevőhöz bekerül egy dentry objektum a címtárbejegyzés gyorsítótárába, és (az i-csomópontján keresztül) a könyvtárban megkeresi a következő elérési út bejegyzéseket (amíg meg nem találják a fájl tényleges i-csomópontját).
Például egy abszolút elérési út (például /usr/ast/file) által meghatározott fájl megkereséséhez a következő lépéseket kell követni. Először is, a rendszer megkeresi azt a gyökérkönyvtárat, amelyet a 2-es számú i-node általában használ (különösen, ha az 1-es számú i-node hibás blokkok számára van fenntartva). A megfelelő bejegyzést a címtárbejegyzés gyorsítótárába helyezi (a gyökérkönyvtár jövőbeli kereséseihez). Ezután megkeresi a gyökérkönyvtárban az "usr" karakterláncot, hogy megkapja a /usr könyvtár i-node számát (amely szintén bekerül a könyvtár elem-gyorsítótárába). Ezt az i-csomópontot ezután beolvassa, és lemezblokkokat bont ki belőle, így a /usr könyvtár olvasható és kereshető az "ast" karakterlánc után. Miután megtalálta a megfelelő bejegyzést, az /usr/ast könyvtár i-node száma meghatározható belőle. Ha ezt az i-node számot kapja, akkor ez olvasható és könyvtárblokkok találhatók. Végül megkeressük a "file" szót, és megtaláljuk az i-node számát. Így a relatív elérési út használata nemcsak kényelmesebb a felhasználó számára, hanem csökkenti a rendszer munkáját is.
Ha a fájl jelen van, a rendszer lekéri az i-node számát, és az i-node tábla indexeként használja (a lemezen), hogy megkeresse a megfelelő i-node-ot, és beolvassa a memóriába. Ez az i-csomópont az i-node táblában van elhelyezve, egy kernel adatszerkezetben, amely tartalmazza az összes i-csomópontot a megnyitáshoz Ebben a pillanatban fájlok és könyvtárak. Az i-node elemformátumnak tartalmaznia kell (legalább) a stat rendszerhívás által visszaadott összes mezőt, hogy a stat hívás működjön (lásd: 10.10. táblázat). táblázatban. A 10-13. ábra a Linux fájlrendszer által támogatott i-node szerkezet néhány mezőjét mutatja be. A tényleges i-node szerkezet sokkal több mezőt tartalmaz, mivel ugyanazt a struktúrát használják a könyvtárak, eszközök és egyéb speciális fájlok megjelenítésére. Az i-node struktúra jövőbeli használatra fenntartott mezőket is tartalmaz. A történelem azt mutatja, hogy a fel nem használt bitek nem maradnak sokáig tétlenül.
Most nézzük meg, hogyan olvassa be a rendszer a fájlt. Ne feledje, hogy egy tipikus könyvtári eljáráshívás az olvasási rendszerhívás futtatására így néz ki:
n = read(fd, puffer, nbyte);
Amikor a kernel átveszi az irányítást, csak ezzel a három paraméterrel és a belső tábláiban található információkkal tud kezdeni (a felhasználóra vonatkozóan). E belső táblák egyik eleme a fájlleírók tömbje. Fájlleírók indexelik, és megnyitott fájlonként egy elemet tartalmaz (legfeljebb bizonyos számú, alapértelmezés szerint általában 32-ig).
Az ötlet az, hogy ezzel a fájlleíróval kezdjük, és a megfelelő bnode-dal fejezzük be. Nézzünk meg egy lehetséges sémát: tegyünk egy mutatót egy csomópontra a fájlleírók táblázatában. Az egyszerűség ellenére ez a módszer(sajnos) nem működik. A probléma ez. Minden fájlleírónak rendelkeznie kell egy társított fájlmutatóval, amely meghatározza azt a bájtot a fájlban, ahol a következő olvasási vagy írási művelet kezdődik. Hol kell ezt a mutatót tárolni? Az egyik lehetőség az, hogy a csomóponttáblázatba helyezi. Ez a megközelítés azonban nem működik, ha több, egymástól független folyamat egyszerre nyitja meg ugyanazt a fájlt, mivel minden folyamatnak saját mutatóval kell rendelkeznie.
A második megoldás egy mutató elhelyezése a fájlleíró táblában. Minden fájlt megnyitó folyamatnak megvan a maga pozíciója a fájlban. Sajnos ez a séma sem működik, de a kudarc oka igen ez az eset nem annyira nyilvánvaló és a természettel kapcsolatos megosztás fájlokat Linux rendszeren. Tekintsük az 5. shell scriptet, amely két parancsból (p1 és p2) áll, amelyeket egymás után kell végrehajtani. Ha a parancsfájlt a parancssorból hívják meg
akkor p1 várhatóan az x fájlba írja a kimenetét, majd a p2 szintén az x fájlba írja, ahol a p1 abbamaradt.
Amikor a shell elindítja a p1-et, az x fájl eleinte üres lesz, így a p1 egyszerűen elkezd írni a fájlba a 0 pozícióban. Amikor azonban a p1 kész, szükség van valamilyen mechanizmusra annak biztosítására, hogy a p2 a kezdőpozíciót ne 0-t lássa (hanem pontosan ez történik, ha a fájl pozíciója a fájlleíró táblában van tárolva), de az az érték, amelynél a pi megállt.
Ennek módja az ábrán látható. 10.19. A trükk egy új tábla bevezetése – a leírás táblázat nyissa meg a fájlokat(fájlleíró tábla megnyitása) - a fájlleíró tábla és az i-node tábla közé, és abban tárolja a fájlmutatót (valamint az olvasási/írási bitet). Az ábrán a szülő folyamat a shell, a gyermek pedig először a pi folyamat, majd a p2 folyamat. Amikor a shell létrehozza a pi folyamatot, annak felhasználói szerkezete (beleértve a fájlleíró táblát is) ugyanannak a shell-struktúrának a pontos másolata, tehát mindkettő ugyanarra a nyitott fájlleíró táblára mutat mutatókat. Amikor a pi folyamat kilép, a shell fájlleírója továbbra is a megnyitott fájlleíró táblázatra mutat, amely tartalmazza a p1 folyamat pozícióját a fájlban. Amikor a shell most létrehozza a p2 folyamatot, az új gyermekfolyamat automatikusan örökli a fájlban lévő pozíciót, anélkül új folyamat, és a shellnek sem szükséges tudnia az adott pozíció aktuális értékét.
Ha valamilyen idegen folyamat megnyitja a fájlt, akkor a megnyitott fájlleíró táblában saját bejegyzést kap a fájlban elfoglalt pozíciójával, amire pontosan szükség van. Így a megnyitott fájlleíró tábla célja, hogy a szülő- és utódfolyamatok egyetlen mutatót oszthassanak meg egy fájlban, de az idegen folyamatokhoz személyes mutatókat rendeljenek.
Tehát (visszatérve az olvasás végrehajtásának problémájához) megmutattuk, hogyan határozzák meg a fájl pozícióját és az i-node-ot. Az I-csomópont tartalmazza a fájl első 12 blokkjának lemezcímét. Ha a fájl pozíciója az első 12 blokkba esik, akkor olvassa el kívánt blokk a fájl és az adatok a felhasználóhoz másolódnak. A 12 blokknál hosszabb fájlok esetén az i-node egyetlen indirekt blokk lemezcímét tartalmazza (10.19. ábra). Ez a blokk további lemezblokkok lemezcímeit tartalmazza. Például, ha a blokk mérete 1 KB és a lemezcím 4 bájt, akkor egyetlen közvetett blokk legfeljebb 256 lemezcímet tárolhat. Ez a séma legfeljebb 268 KB méretű fájlok támogatását teszi lehetővé.
