Beste svaret
Kort fortalt
Hvert filsystem har en superblokk, som inneholder informasjon om filsystem som:
- Filsystemtype
- Størrelse
- Status
- Informasjon om andre metadatastrukturer
I detalj
Superblokken er en struktur som representerer et filsystem. Den inneholder nødvendig informasjon for å administrere filsystemet under drift. Det inkluderer filsystemnavnet (for eksempel ext4), størrelsen på filsystemet og dets tilstand, en referanse til blokkeringsenheten og metadatainformasjon (for eksempel gratis lister og så videre). Superblokken er vanligvis lagret på lagringsmediet, men kan opprettes i sanntid hvis en ikke finnes. Du finner superblokkstrukturen i ./linux/include/linux/fs.h.
One viktig element i superblokken er en definisjon av superblokkoperasjonene. Denne strukturen definerer settet med funksjoner for administrering av inoder i filsystemet. For eksempel kan inoder tildeles med alloc\_inode eller slettes med destroy\_inode. Du kan lese og skrive inoder med read\_inode og write\_inode eller synkronisere filen system med sync\_fs. Du finner super\_operations strukturen i ./linux/include/linux/fs.h. Hvert filsystem gir sin egne inode-metoder, som implementerer operasjonene og gir den vanlige abstraksjonen til VFS-laget.
Fysisk struktur
Den fysiske strukturen til Ext2-filsystemer har blitt sterkt påvirket av oppsettet av BSD-filsystemet. Et filsystem består av blokkeringsgrupper. Blokkgrupper er analoge med BSD FFSs sylindergrupper. Blokkgrupper er imidlertid ikke knyttet til den fysiske utformingen av blokkene på disken, siden moderne stasjoner har en tendens til å være optimalisert for sekvensiell tilgang og skjule deres fysiske geometri til operativsystemet.
,---------+---------+---------+---------+---------,
| Boot | Block | Block | ... | Block |
| sector | group 1 | group 2 | | group n |
`---------+---------+---------+---------+---------"
Hver blokkgruppe inneholder en overflødig kopi av viktige informasjoner om filsystemkontroll (superblokk og filsystemet beskrivelser) og inneholder også en del av filsystemet (en blokkbitmappe, en inode bitmappe, et stykke av inodetabellen og datablokker). Strukturen til en blokkgruppe er representert i denne tabellen:
,---------+---------+---------+---------+---------+---------,
| Super | FS | Block | Inode | Inode | Data |
| block | desc. | bitmap | bitmap | table | blocks |
`---------+---------+---------+---------+---------+---------"
Bruk av blokkgrupper er en stor gevinst når det gjelder pålitelighet: siden kontrollstrukturene replikeres i hver blokkgruppe, er det jeg forstår asy å gjenopprette fra et filsystem der superblokken er ødelagt. Denne strukturen hjelper også til å oppnå gode ytelser: ved å redusere avstanden mellom inodetabellen og datablokkene er det mulig å redusere diskhodesøkene under I / O på filer.
Referanse: – Utvidede filsystemer (Ext, Ext2, Ext3)
Svar
Filsystemer i Linux fungerer i flere lag: A) a sett med primitive rutiner for å samhandle med enheten (dvs. driveren), B) et sett med poster på disken som tilsvarer det vi kaller filer, og C) metadatainformasjon om hver fil som kalles inoder, det er 1 inode for hver fil. Disse inodene sporer ting som hva filattributtene dine er, hvordan lesing / skriving på filene dine er definert osv.
Det viser seg at dette bare er et ufullstendig bilde. Det er før hver type filsystem kan velge å ordne inodene på den måten de liker på disken. Selv representasjonen på inoden på inoden kan variere mellom forskjellige filsystemer – det som betyr noe er bare at visning VFS er utstyrt med av inodestrukturene er enige. Så Linux gjør ikke i seg selv hvordan de enkelte filene / inodene i et filsystem kan nås.
Problemet håndteres pent ved bruk av struct file\_system og struct super\_block typer. Sistnevnte bor på disken mens førstnevnte bare lever i minnet. Når du monterer et filsystem ved hjelp av si,
monterer -t ext4 / dev / usb1 / mnt / usb1
file\_system objektet som definerer ext4-typen inneholder et mount () rutine som spesifiserer hvordan du skal lese superblokk-objektet fra disken. Dette superblokkobjektet spesifiserer alt du trenger for å få tilgang (tildel, slett, les, rett, synkroniser mellom enhet og minne osv.) Inodene i enheten.Når dette superblokkobjektet er hentet til minnet, bruker vi dets oppslag () til å lese inoder fra disken i minnet. Deretter bruker vi disse inodene i sin tur for å komme til filsystemene. Det er hierarkisk, virkelig og ganske pent på det!