Bästa svaret
Kort sagt
Varje filsystem har ett superblock som innehåller information om filsystem såsom:
- Filsystemstyp
- Storlek
- Status
- Information om andra metadatastrukturer
I detalj
Superblocket är en struktur som representerar ett filsystem. Den innehåller nödvändig information för att hantera filsystemet under drift. Det inkluderar filsystemets namn (t.ex. ext4), filsystemets storlek och dess tillstånd, en hänvisning till blockenheten och metadatainformation (t.ex. gratis listor och så vidare). Superblocken lagras vanligtvis på lagringsmediet men kan skapas i realtid om det inte finns. Du hittar superblockstrukturen i ./linux/include/linux/fs.h.
En viktigt element i superblocken är en definition av superblockoperationerna. Denna struktur definierar uppsättningen funktioner för hantering av inoder i filsystemet. Till exempel kan inoder allokeras med alloc\_inode med destroy\_inode. Du kan läsa och skriva inoder med read\_inode och write\_inode eller synkronisera filen system med sync\_fs. Du hittar super\_operations strukturen i ./linux/include/linux/fs.h. Varje filsystem tillhandahåller sin egna inodmetoder som implementerar operationerna och tillhandahåller den gemensamma abstraktionen till VFS-lagret.
Fysisk struktur
Den fysiska strukturen i Ext2-filsystem har påverkats starkt av layouten av BSD-filsystemet. Ett filsystem består av blockgrupper. Blockgrupper är analoga med BSD FFSs cylindergrupper. Blockgrupper är dock inte knutna till blockens fysiska layout, eftersom moderna enheter tenderar att vara optimerade för sekventiell åtkomst och dölja deras fysiska geometri för operativsystemet.
,---------+---------+---------+---------+---------,
| Boot | Block | Block | ... | Block |
| sector | group 1 | group 2 | | group n |
`---------+---------+---------+---------+---------"
Varje blockgrupp innehåller en redundant kopia av viktiga informationssystem för filsystemkontroll (superblock och filsystemet beskrivningar) och innehåller också en del av filsystemet (en blockbitmapp, en inodebitmapp, en bit av inodtabellen och datablock). Strukturen för en blockgrupp representeras i denna tabell:
,---------+---------+---------+---------+---------+---------,
| Super | FS | Block | Inode | Inode | Data |
| block | desc. | bitmap | bitmap | table | blocks |
`---------+---------+---------+---------+---------+---------"
Att använda blockgrupper är en stor vinst när det gäller tillförlitlighet: eftersom kontrollstrukturerna replikeras i varje blockgrupp är det är e asy att återhämta sig från ett filsystem där superblocken har skadats. Denna struktur hjälper också till att få bra prestanda: genom att minska avståndet mellan inodtabellen och datablocken är det möjligt att minska skivhuvudets sökningar under I / O på filer.
Referens: – Utökade filsystem (Ext, Ext2, Ext3)
Svar
Filsystem i Linux fungerar i flera lager: A) a uppsättning primitiva rutiner för att interagera med enheten (dvs. drivrutinen), B) en uppsättning poster på disken som motsvarar vad vi kallar filer och C) metadatainformation om varje fil som kallas inoder, det finns 1 inod för varje fil. Dessa inoder spårar saker som vad dina filattribut är, hur läs / skriv på dina filer definieras etc.
Visar sig att detta bara är en ofullständig bild. Det är innan varje typ av filsystem kan välja att ordna inoderna på något sätt som de gillar på disken. Till och med on-diskrepresentationen av inoder kan variera mellan olika filsystem – det som är viktigt är bara att vy VFS är försedd med av inodstrukturerna överens. Så Linux gör inte i sig hur de enskilda filerna / inoderna i ett filsystem kan nås.
Problemet hanteras snyggt med hjälp av struct file\_system och struct super\_block -typer. Den senare lever på skivan medan den förra bara lever i minnet. När du monterar ett filsystem med hjälp av säg,
monterar -t ext4 / dev / usb1 / mnt / usb1
file\_system objekt som definierar ext4-typen innehåller ett mount () rutin som anger hur superblock-objektet ska läsas från disken. Detta superblock-objekt specificerar allt du behöver för att komma åt (allokera, radera, läsa, höger, synkronisera mellan enhet och minne, etc.) inoderna i enheten.När detta superblock-objekt har hämtats i minnet använder vi dess lookup () -åtgärder för att läsa inoder från disken i minnet. Sedan använder vi dessa inoder i sin tur för att komma till filsystemen. Det är hierarkiskt, riktigt och ganska snyggt på det!