Ext4 Bestandssysteem

IOException

Gerry Hendrickx (s0191068): Mens-Machine CommunicatieAlbert Jorissen (s0188848): Artificiële Intelligentie

Li Quan (s0194258): Artificiële Intelligentie

16 december 2010

1 InleidingIn het kader van het vak ‘Besturingssystemen’ bestudeerden we het ext4 be-standssysteem. Deze paper bevat de bevindingen van deze studie. Eerst gevenwe een algemene beschrijving van ext4. Vervolgens lichten we de belangrijkstegegevensstructuren en functies toe aan de hand van de broncode. Daarna makenwe een korte evaluatie van ext4. Ten slotte bespreken we enkele benchmarks.

Waar mogelijk, gebruiken we in deze paper de Nederlandse termen. Bijnamen van algoritmen, functies, gegevensstructuren is dit echter niet steedsmogelijk. In die gevallen gebruiken we de Engelse benaming.

In deze paper bedoelen we met het woord fragmentatie steeds externe fragmen-tatie. Op interne fragmentatie heeft een bestandssysteem (eenmaal aangemaakt)geen invloed.

2 BeschrijvingExt4 staat voor fourth extended file system en is een bestandssysteem voor Linux.Het ext4 bestandssysteem is de opvolger van het ext3 bestandssysteem en isachterwaards compatibel met vorige versies van het extended file system, ext2 enext3. Men kan zelfs een ext4 bestandssysteem mounten als ext3, op voorwaardedat deze geen extents gebruikt (zie sectie 2.4).

Het grootste direct merkbare verschil voor de eindgebruiker met ext3 is demaximale bestands- en bestandssysteemgrootte. Deze en nog andere eigenschap-pen zullen we in deze sectie bespreken.

2.1 Bestands- en bestandssysteemgrooteDaar waar ext3 beperkt is tot bestanden met maximaal 2TiB en een maximalebestandssysteemgrootte van 32TiB, heeft ext4 respectievelijk 16TiB en 1EiB alslimieten. Dit is het gevolg van de 48-bit block-adressering die in ext4 gebruiktwordt, in tegenstelling tot de 32-bit block-adressering van ext3[9].

2.2 SuperblockEen superblock bevat alle algemene informatie over een bestandssysteem: degrootte, de mount-status, het type (vb. ext4) en heel wat metadata zoals aantalblocks, aantal vrije blocks, aantal inodes, etc. Het superblock bevindt zichop het eerste block van een bestandssysteem. De superblock van ext4 wordtuitgebreider besproken in sectie 3.1.1[18].

Aangezien een superblock heel wat belangrijke informatie bevat, is het cruciaalvoor een goede werking van het bestandssysteem. Daarom worden er steedsmeerdere kopies bijgehouden (op verschillende block groups, zie sectie 2.3) vandit superblock zodat herstel mogelijk is in geval van beschadiging[15].

2.3 Block groupsEen bestandssysteem is een verzameling van blocks. Deze blocks worden gegroe-peerd in block groups. Bestandssystemen proberen in de mate van het mogelijkebestanden binnen één block group te houden. Dit voorkomt fragmentatie enversnelt de toegang tot deze bestanden[18].

1

2.4 ExtentsEén van de grootste vernieuwingen van ext4 is de introductie van extents. Eenextent is een zone van aaneensluitende blocks (binnen één block group) bestemdvoor één bestand en kan tot 128MB groot zijn[1].

Het gebruik van extents voorkomt de fragmentatie die zich voordoet bij hetgebruik van block mapping. Kleinere bestanden passen immers vaak in één extent.Het bestand staat dus slechts op één plaats op de schijf i.p.v. verspreid. Groterebestanden hebben meerdere extents nodig. Deze extents kunnen verspreid staan,maar maken het geheel minder gefragmenteerd zijn dan wanneer men block-mapping zou gebruiken. Met extent-mapping wordt een bestand immers naarzones gemapped (van aansluitende blocks), terwijl block-mapping een bestandnaar individuele blocks mapt die niet gegarandeerd aansluitend zijn.

Het gebruik van extents verlaagt niet alleen de fragmentatie, het maakt demapping ook compacter. Er zijn immers veel minder verwijzingen nodig.

De adressen van de extents worden opgeslaan in de inode van het bestandin kwestie. Een inode (zie sectie 2.5) kan tot vier verwijzingen naar extentsbevatten. Indien een bestand meer extents nodig heeft, maakt ext4 gebruik vaneen Htree — dit is een speciale boomstructuur voor indexing met één of tweeniveaus[21]. Secties 3.1.3 en 3.1.4 gaan hier uitgebreider op in.

2.5 InodesEen inode kan gezien worden als het Process Control Block (PCB) van eenbestand. Waar een PCB informatie bijhoudt over een proces, zoals de identificatoren de adresruimte, zal een inode alle informatie bijhouden over een bestand. Dithoudt informatie in zoals toegangsrechten (lees-, schrijf- of uitvoerrechten pergroep of gebruiker), het bestandstype en de extent(s) waarin het bestand zitopgeslaan[22]. Een bestandssysteem heeft na zijn creatie een vast aantal inodes,wat het maximaal aantal bestanden dat op het bestandssysteem vastlegt[9].

De inodes gebruikt in ext4 hebben een grotere standaardgrootte dan deze inext3: in ext3 is de standaardgrootte 128 bytes; in ext4 is deze 256 bytes. Hierdoorkan men heel wat extra informatie in een inode opslaan[1]. Een voorbeeld van dezeextra informatie is het gebruik van nanosecond timestamps. Deze timestampsleveren een veel hogere precisie dan de timestamps van ext3 (nauwkeurig op éénseconde)[9].

Een ander voorbeeld van extra informatie, die in de extra ruimte van de inodeopgeslaan kan worden, zijn de fast extended attributes. Deze laten snelle toegangtoe tot extend attributes. Dit zijn attributen van een bestand die gebruiker-gedefinieerd zijn en dus niet door het bestandssysteem zelf geïnterpreteerdworden[20].

2.6 AllocatieExt4 gebruikt een combinatie van contiguous en indexed allocation: bestandenbestaan uit extents (contiguous). Zoals vermeld in sectie 2.4 worden extentsgeïndexeerd in een Htree indien een bestand er meer dan 4 nodig heeft (indexed).

Verder heeft de allocatie in ext4 drie belangrijke eigenschappen[9]:

1. Ext4 maakt gebruik van multiblock allocatie.

2

2. Ext4 maakt ook gebruik van vertraagde allocatie.

3. Ext4 ondersteunt persistente preallocatie.

2.6.1 Multiblock allocatie

Bij multiblock allocatie zal de allocator meerdere blocks in één keer kunnentoewijzen. Dit heeft als voordeel dat indien een groot bestand (dat duizendenblocks inneemt) aangemaakt wordt, de allocator slechts één keer moet werkenvoor alle blocks samen, in plaats van voor elk block apart. Dit vermijdt dus heelwat overhead.

Een bijkomend voordeel is dat de allocator op deze manier beter fragmentatiekan voorkomen. Aangezien de allocator weet hoeveel blocks er toegewezenmoeten worden, kan hij deze allemaal in eenzelfde vrije ruimte plaatsen die grootgenoeg is[10].

2.6.2 Vertraagde allocatie

Vertraagde allocatie (delayed allocation) houdt in dat de allocator niet onmid-dellijk blocks zal toewijzen, maar pas op het moment dat de data effectiefweggeschreven worden naar het bestandssysteem. Dit maakt het mogelijk eenbetere allocatie uit te voeren, dan wanneer iedere schrijfactie (die het bestand gro-ter maakt) naar een bestand onmiddellijk gealloceerd zou worden. De allocatorkent immers het totaal aantal blocks die hij moet alloceren[10].

Vertraagde allocatie gaat goed samen met extents en multiblock allocatie.Het voorkomt ook fragmentatie. Een nadeel aan vertraagde allocatie is een hogerrisico op gegevensverlies. Indien er iets1 mis gaat, is de kans groter dat er nogdata nog in de cache staan, die nog niet zijn weggeschreven op schijf. Deze datazijn dan verloren[19].

2.6.3 Persistente preallocatie

Persistente preallocatie laat gebruikers toe om plaats te reserveren voor een(groot) bestand. Op deze manier kunnen grote bestanden in één keer gealloceerdworden. Dit laat toe om een beter allocatieschema te vinden.

Tot nu voerden applicaties preallocatie meestal zelf uit door een groot bestandmet nullen te vullen. De nieuwe feature van ext4 maakt dit proces echter veelefficiënter. Persistente preallocatie gaat goed samen met extents en multiblockallocatie[9].

2.7 JournalingExt4 is een journaling bestandssysteem. Een journaling bestandssysteem houdteen journal bij. Dat is een soort logboek op de schijf waarin alle wijzigingen(transacties) worden opgeslaan alvorens ze echt uit te voeren op het bestands-systeem. Een journal laat toe om in geval van een crash het bestandssysteemeenvoudig terug in een consistente toestand te brengen. In dat geval hoeftenkel de journal overlopen te worden in plaats van alle datastructuren van hetbestandsysteem[23].

1Uitval, crash, . . .

3

Het journal is het meest gebruikte deel van een schijf. Bijgevolg is dit deelhet meest gevoelig voor fouten. Indien herstel van het bestandssysteem nodigis en er een corrupte journal gebruikt wordt om het bestandssysteem in eenjuiste staat te herstellen, kan dit zware gevolgen hebben op de integriteit vanhet bestandssysteem. Men probeert dan immers met inconsistente data andereinconsistente data te corrigeren.

Een mogelijke oplossing om inconsistente journals te vermijden is het ge-bruik van checksums: De journal wordt gechecksumd zodat er later eenvoudiggecontroleerd kan worden of de journal nog consistent is[1]. Ext4 implementeertjournal checksumming door aan het commit-block van elke transactie een CRC32checksum toe te voegen. Indien de checksum bij herstel niet klopt, worden decorrupte transactie en transacties die op deze transactie volgen genegeerd bijherstel.

Het toevoegen van deze checksum laat ook toe het twee-fasen-commitprotocol(waar het commit-block slechts naar de schijf geschreven mag worden als deandere transactie-blocks reeds op de schijf staan) te vervangen door een een-voudiger één-fase-commitprotocol. Ontbrekende blocks kunnen immers ookgedetecteerd worden door de checksum. Deze vervanging laat bijgevolg toe eenhogere performantie te realiseren[13].

Standaard kan een ext4 bestandssysteem deze mogelijke performantiewinstniet waarmaken, daar het ook gebruikt maakt barriers. Barriers laten toe eenstrikte volgorde op te leggen aan acties en zo de betrouwbaarheid van het systeem(in dit geval het bestandssysteem) te verhogen (kleinere kans op inconsistentie).Ext4 gebruikt barriers om te zorgen dat dat de journal op de harde schijfvolledig up-to-date is alvorens het commit-record geschreven wordt. Hierdoorontstaat dus opnieuw een soort twee-fasen-commitprotocol. (Ext4 biedt wel demogelijkheid om het gebruik van barriers uit te schakelen[1].)

3 Implementatie3.1 Gegevensstructuren3.1.1 Superblock

Wanneer een bestand naar het bestandssysteem geschreven wordt, moetenmogelijk een inode en disk blocks gealloceerd worden; de informatie in hetsuperblock helpt bij dit proces[11].

In een superblock wordt basisinformatie opgeslaan over het bestandssysteemzoals de grootte van een block, de grootte van het bestandssyteem zelf, aantalblocks, aantal inodes en hun locatie, aantal vrije blocks, index van de volgendevrije block in de free block list en van de volgende vrije inode in de inode cache, . . .Zoals reeds beschreven in sectie 2.2 worden er meerdere superblocks bijgehouden;hiervoor heeft een superblock het block group nummer nodig./** Structure of the super block*/

struct ext4_super_block {/*00*/ __le32 s_inodes_count; /* Inodes count */__le32 s_blocks_count_lo; /* Blocks count */__le32 s_r_blocks_count_lo; /* Reserved blocks count */__le32 s_free_blocks_count_lo; /* Free blocks count *//*10*/ __le32 s_free_inodes_count; /* Free inodes count */

4

__le32 s_first_data_block; /* First Data Block */__le32 s_log_block_size; /* Block size */

__le32 s_first_ino; /* First non-reserved inode */__le16 s_inode_size; /* size of inode structure */__le16 s_block_group_nr; /* block group # of this superblock */(...)

};

Het superblock bevat ook informatie over de feature set van het bestandssys-teem: als de kernel een bepaalde incompatibele feature (die ingesteld is) nietkent, moet deze weigeren het bestandssysteem te mounten.__le32 s_feature_compat; /* compatible feature set *//*60*/ __le32 s_feature_incompat; /* incompatible feature set */__le32 s_feature_ro_compat; /* readonly-compatible feature set */

Verder is er ook informatie aanwezig voor de preallocatie, zoals het aantal tereserveren blocks. Voor de ondersteuning van journaling wordt het uuid van dejournal superblock bijgehouden en het inode-nummer van de journal file; ook degrootte van de group descriptor is aanwezig (zie sectie 3.1.2)./** Performance hints.*/

__u8 s_prealloc_blocks; /* Nr of blocks to try to preallocate*/__u8 s_prealloc_dir_blocks; /* Nr to preallocate for dirs */__le16 s_reserved_gdt_blocks; /* Per group desc for online growth */

/** Journaling support valid if EXT4_FEATURE_COMPAT_HAS_JOURNAL set.*/

__u8 s_journal_uuid[16]; /* uuid of journal superblock */__le32 s_journal_inum; /* inode number of journal file */__le16 s_desc_size; /* size of group descriptor */(...)

Ten slotte houdt het superblock ook informatie bij over fouten van hetbestandssysteem zoals aantal fouten, de betrokken inodes en blocks en hettijdstip waarop ze plaatsvonden.#define EXT4_S_ERR_START offsetof(struct ext4_super_block, s_error_count)__le32 s_error_count; /* number of fs errors */__le32 s_first_error_time; /* first time an error happened */__le32 s_first_error_ino; /* inode involved in first error */__le64 s_first_error_block; /* block involved of first error */(...)

De kernel houdt informatie van het superblock in het geheugen en schrijftdeze periodiek terug op de schijf. Hiervoor maakt de kernel gebruik van deext4_sb_info struct. Deze struct bevat, net zoals het superblock zelf, algemeneinformatie over het bestandssysteem, zoals grootte van de group descriptor,aantal inodes per block, aantal blocks per group, aantal inodes in een group, . . .De struct bevat ook een verwijzing naar de buffer waarin het superblock zelfzich bevindt, evenals een verwijzing naar het superblock zelf in deze buffer./** fourth extended-fs super-block data in memory*/

struct ext4_sb_info {unsigned long s_desc_size; /* Size of a group descriptor in bytes */unsigned long s_inodes_per_block;/* Number of inodes per block */unsigned long s_blocks_per_group;/* Number of blocks in a group */unsigned long s_inodes_per_group;/* Number of inodes in a group */unsigned long s_itb_per_group; /* Number of inode table blocks per group */unsigned long s_gdb_count; /* Number of group descriptor blocks */

5

unsigned long s_desc_per_block; /* Number of group descriptors per block */ext4_group_t s_groups_count; /* Number of groups in the fs */(...)struct buffer_head * s_sbh; /* Buffer containing the super block */struct ext4_super_block *s_es; /* Pointer to the super block in the buffer */(...)

};

De block allocator van ext4 maakt gebruik van buddy allocation. Dit houdtin dat de (aaneensluitende) vrij ruimte steeds in twee buddies verdeeld wordt.De ext_sb_info struct houdt ook informatie bij die dit algoritme nodig heeft:de block group waarin gealloceerd wordt, de inode van de buddy cache en degrootte van het aangevraagde geheugen — afgerond tot de volgende macht van2, vandaar ook de naam power-of-2 allocator [16, 8]./* for buddy allocator */struct ext4_group_info ***s_group_info;struct inode *s_buddy_cache;long s_blocks_reserved;(...)

3.1.2 Group descriptor en bitmap

Elke block group wordt beschreven door een group descriptor; deze bevat devolgende informatie:

• Blocks bitmap block: het block nummer van de block allocatie bitmap.Dat block wordt gebruikt bij block allocatie en deallocatie.

• Inode bitmap block: het block nummer van de inode allocatie bitmap. Datblock wordt gebruikt bij inode allocatie en deallocatie.

• Inode table block: het block nummer van het eerste block van de inodetable (zie sectie 3.1.3) van deze block group.

• Free blocks: aantal vrije blocks in de deze group.

• Free inodes: aantal vrije inodes in de deze group.

Om vrije ruimte op de schijf bij te houden, moet het systeem een free-spacelist bijhouden[16]. Deze wordt geïmplementeerd als een bit vector of bitmap. Elkeblock wordt hierbij voorgesteld door één bit die aangeeft of het block gealloceerdis[16].

/** Structure of a blocks group descriptor*/

struct ext4_group_desc{

__le32 bg_block_bitmap_lo; /* Blocks bitmap block */__le32 bg_inode_bitmap_lo; /* Inodes bitmap block */__le32 bg_inode_table_lo; /* Inodes table block */__le16 bg_free_blocks_count_lo;/* Free blocks count */__le16 bg_free_inodes_count_lo;/* Free inodes count */(...)

};

6

3.1.3 Inode

Een inode (zie ook sectie 2.5) is een gegevenstructuur die alle informatie over eenbestand behalve zijn naam en de feitelijke data bevat[17]. Dit omhelst informatieover toegangsrechten, tijden van wijziging, toegang, verwijdering,. . ./** Structure of an inode on the disk*/

struct ext4_inode {__le16 i_mode; /* File mode */__le16 i_uid; /* Low 16 bits of Owner Uid */__le32 i_size_lo; /* Size in bytes */__le32 i_atime; /* Access time */__le32 i_ctime; /* Inode Change time */__le32 i_mtime; /* Modification time */__le32 i_dtime; /* Deletion Time */__le16 i_gid; /* Low 16 bits of Group Id */__le16 i_links_count; /* Links count */__le32 i_blocks_lo; /* Blocks count */__le32 i_flags; /* File flags */(...)

};

3.1.4 Extent

Zoals beschreven in sectie 2.4 is een extent een aaneensluitende zone van blocks,specifiek gereserveerd voor één bestand. De mapping tussen de data van hetbestand en de ruimte de harde schijf via de extents is weergegeven in figuur 1.

Figuur 1: De mapping van data via extents naar de harde schijf[5].

De definitie van extent staat in de ext4_extent struct. Deze struct bevat alleinformatie om een extent te beschrijven: het nummer van het eerste logischeblock van de extent, het nummer van het eerste fysische block en het aantalblocks in de extent./** This is the extent on-disk structure.* It’s used at the bottom of the tree.*/struct ext4_extent {

__le32 ee_block; /* first logical block extent covers */__le16 ee_len; /* number of blocks covered by extent */__le16 ee_start_hi; /* high 16 bits of physical block */__le32 ee_start_lo; /* low 32 bits of physical block */

};

De extent mapping van een bestand wordt opgeslaan in de i_data array van

7

de inode van het bestand2. In deze array (60 bytes) kunnen vier extentdefinities(12 bytes) en een extent header (12 bytes) opgeslaan worden. De extent headerbevat informatie over de structuur van de extent mapping (zie verder)[3]./** Each block (leaves and indexes), even inode-stored has header.*/

struct ext4_extent_header {__le16 eh_magic; /* probably will support different formats */__le16 eh_entries; /* number of valid entries */__le16 eh_max; /* capacity of store in entries */__le16 eh_depth; /* has tree real underlying blocks? */__le32 eh_generation; /* generation of the tree */

};

Figuur 2: Extent tree[5].

Indien een bestand meer dan vier extents nodig heeft, worden de extentsgeïndexeerd in een Htree (figuur 2). De non-leaf-knopen van deze boom zijnblocks van het bestanssysteem waarin ext4_extent_idx structs opgeslaan zijn.Deze bevatten informatie de locatie over het volgende niveau van de boom. Elkeknoop begint met een ext4_header. De root-knoop van de Htree is steeds i_data.In het geval een bestand slechts 4 (of minder) extents nodig heeft, wordt dei_data array als een leaf-knoop behandeld[3]./* This is index on-disk structure.* It’s used at all the levels except the bottom.*/struct ext4_extent_idx {

__le32 ei_block; /* index covers logical blocks from ’block’ */__le32 ei_leaf_lo; /* pointer to the physical block of the next *

* level. leaf or next index could be there */__le16 ei_leaf_hi; /* high 16 bits of physical block */__u16 ei_unused;

};

2In de voorgangers van ext4 werden in deze array de pointers voor de indirecte block-mapping opgeslaan. Het formaat van deze array wordt aangeduid door middel van een vlag inde variabele i_flags in de inode struct.

8

3.2 FunctiesIn deze sectie lichten we kort enkele belangrijke functies van het ext4 bestands-systeem toe.

3.2.1 Een inode vrijgeven

// ialloc.c: line 178void ext4_free_inode(handle_t *handle, struct inode *inode)

Bij het verwijderen van een file van het bestandssysteem wordt de inode vrijge-geven. De belangrijkste stappen in dit proces zijn de volgende:

• Eerst gebeuren er enkele checks om te controleren of de file waarnaar deinode verwijst al goed verwijderd is. (Ext4 geeft de inode pas vrij nadatde file al uit de directory is verwijderd.)

• De extended attributes worden verwijderd uit de inode en het quota wordtaangepast.dquot_initialize(inode);ext4_xattr_delete_inode(handle, inode);dquot_free_inode(inode);dquot_drop(inode);

• De functie controleert of het om een directory gaat en onthoudt dit voorlater.is_directory = S_ISDIR(inode->i_mode);

• De inode bitmap van de bijhorende block group wordt geladen. Eveneenswordt de te resetten bit in deze inode bitmap bepaald.block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);bitmap_bh = ext4_read_inode_bitmap(sb, block_group);

• De juiste bit wordt gecleared zodat de inode al vrij gemarkeerd wordt.cleared = ext4_clear_bit(bit, bitmap_bh->b_data);

• Het aantal vrije inodes wordt verhoogd en indien het om een directoryging, wordt het aantal gebruikte directories verlaagd. Ook te teller voorde CPU wordt aangepast.count = ext4_free_inodes_count(sb, gdp) + 1;ext4_free_inodes_set(sb, gdp, count);if (is_directory) {

count = ext4_used_dirs_count(sb, gdp) - 1;ext4_used_dirs_set(sb, gdp, count);percpu_counter_dec(&sbi->s_dirs_counter);

}...percpu_counter_inc(&sbi->s_freeinodes_counter);

9

3.2.2 Een nieuwe inode alloceren

// ialloc.c: line 788struct inode *ext4_new_inode(handle_t *handle, struct inode *dir, int mode,

const struct qstr *qstr, __u32 goal)

• Eerst zoekt ext4 een block group waar het bestand gelinkt aan de inodekan komen te staan.

• De inode bitmap voor de gevonden block group wordt ingelezen en eenvrije inode wordt gezocht. Dit zoeken is een iteratief proces (dat we nietvolledig overnemen).inode_bitmap_bh = ext4_read_inode_bitmap(sb, group);if (!inode_bitmap_bh)

goto fail;

repeat_in_this_group:ino = ext4_find_next_zero_bit((unsigned long *)

inode_bitmap_bh->b_data,EXT4_INODES_PER_GROUP(sb), ino);

... // Hier gebeurt de volgende stap die hieronder uitgelegd staat.if (++ino < EXT4_INODES_PER_GROUP(sb))

goto repeat_in_this_group;

• Ext4 claimt de lege inode. Dit stelt de juiste bit in de inode bitmap in.// we hebben het omsluitende if(...) verwijderd.ext4_claim_inode(sb, inode_bitmap_bh, ino, group, mode)

• De tellers in de nodige datastructuren worden aangepast:free = ext4_free_blocks_after_init(sb, group, gdp);...ext4_free_blks_set(sb, gdp, free);...percpu_counter_dec(&sbi->s_freeinodes_counter);if (S_ISDIR(mode))

percpu_counter_inc(&sbi->s_dirs_counter);...if (sbi->s_log_groups_per_flex) {

flex_group = ext4_flex_group(sbi, group);atomic_dec(&sbi->s_flex_groups[flex_group].free_inodes);

}

• De inode wordt geïnitialiseerd: de verschillende eigenschappen van eeninode worden ingesteld. We tonen hier enkel het deel dat de user, groupen mode instelt.if (test_opt(sb, GRPID)) {

inode->i_mode = mode;inode->i_uid = current_fsuid();inode->i_gid = dir->i_gid;

} elseinode_init_owner(inode, dir, mode);

3.2.3 Een file vrijgeven

// file.c: line 37static int ext4_release_file(struct inode *inode, struct file *filp)

10

• De blocks die via delayed allocation werden toegewezen worden (geforceerd)toegewezen.ext4_alloc_da_blocks(inode);}

• Indien het bestand voor schrijven was geopend, worden alle niet gebruiktegeprealloceerde blocks vrijgegeven:/* if we are the last writer on the inode, drop the block reservation */if ((filp->f_mode & FMODE_WRITE) &&

(atomic_read(&inode->i_writecount) == 1) &&!EXT4_I(inode)->i_reserved_data_blocks)

{down_write(&EXT4_I(inode)->i_data_sem);ext4_discard_preallocations(inode);up_write(&EXT4_I(inode)->i_data_sem);

}

3.3 Open een bestand

// file.c: line 103static int ext4_file_open(struct inode * inode, struct file * filp)

• Indien het bestandsysteem nog niet gesampled is en het niet alleen-lezengemount is, samplet ext4 waar het bestandssysteem gemount is en slaatdit op in het superblock. (Dit gebeurt dus bij het openen van de eerste fileop een bestandsysteem.). Deze code werd achterwege gelaten.

• Het openen van een bestand wordt gedelegeerd aan een helperfunctie voorbestandssystemen die quota ondersteunen:return dquot_file_open(inode, filp);

3.4 Prellocatie van de schijfruimte voor een bestandExt4 ondersteunt het prealloceren van ruimte voor een bestand. We besprekennu beknopt hoe dit geïmplementeerd is.// extents.c: line 3676long ext4_fallocate(struct inode *inode, int mode, loff_t offset, loff_t len)

• Er wordt gecontroleerd of de file extent-gebaseerd is. (Dit is niet hetgeval voor bestanden van een ext3 systeem dat als ext4 gemount is, dezebestanden zijn block-mapped.)/** currently supporting (pre)allocate mode for extent-based* files _only_*/if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))

return -EOPNOTSUPP;

• Ext4 controleert of de nieuwe bestandsgrootte OK is.

11

mutex_lock(&inode->i_mutex);ret = inode_newsize_ok(inode, (len + offset));if (ret) {

mutex_unlock(&inode->i_mutex);return ret;

}

• Ext4 probeert alle gevraagde blocks te alloceren. Het doet dit door iteratiefblocks aan te vragen totdat het gevraagde aantal blocks gealloceerd is.Bij elke stap updatet ext4 de gegevens (timestamp en grootte) in deinode-struct en markeert het de inode zelf als dirty.while (ret >= 0 && ret < max_blocks) {

...ret = ext4_map_blocks(handle, inode, &map,

EXT4_GET_BLOCKS_CREATE_UNINIT_EXT);...ext4_falloc_update_inode(inode, mode, new_size,

(map.m_flags & EXT4_MAP_NEW));ext4_mark_inode_dirty(handle, inode);...

}

• Tenslotte geeft ext4 de mutexlock, die in het begin aangevraagd is, vrij.mutex_unlock(&inode->i_mutex);

4 BenchmarksWe voerden enkele eenvoudige benchmarks uit om het ext4 bestandsysteem tekunnen evalueren. We maakten hiervoor gebruik van Iozone3, een eenvoudigebenchmarktool. Deze benchmarks werden uitgevoerd op een laptop waaropUbuntu 10.10 geïnstalleerd was. De benchmarks zelf vonden plaats op eenexterne harde schijf (Iomega MMHDC 500GB), die met FireWire aan de laptopaangesloten was. Deze schijf werd geformatteerd met ext3 en ext4, telkens metde standaardinstellingen.

We voerden volgende benchmarks uit: sequentieel schrijven naar een nieuwbestand, sequentieel lezen vanuit een bestand en random schrijven naar en lezenvan een bestaand bestand. Deze acties gebeurden steeds per 64 byte.

De resultaten van deze benchmarks staan in figuren 3, 4, 5 en 6. De plotsedaling in de grafieken van het schrijven ligt hoogstwaarschijnlijk aan beperkingenvan onze benchmarkopstelling. De exacte oorzaak hebben we niet kunnenachterhalen, maar we vermoeden dat het aan een volle buffer ligt.

In tegenstelling tot onze oorspronkelijke verwachtingen blinkte ext4 enkel uitin het sequentieel schrijven. Het uitblinken in deze benchmark is te verklaren doorhet gebruik van multiblock en vertraagde allocatie. Bij de andere benchmarksdoen ext4 en ext3 het ongeveer even goed (afhankelijk van de bestandsgrootte),of is ext3 zelfs beter.

Dit komt waarschijnlijk omdat er voor de benchmarks gebruik werd gemaaktvan een lege harde schijf waar telkens slechts één bestand op geplaatst werd.Hierdoor treedt er geen externe fragmentatie op. Aangezien ext4 beter is dan ext3in het voorkomen van externe fragmentatie, kwam ext4 tijdens deze benchmark

3http://www.iozone.org

12

Figuur 3: Benchmark: sequentieel schrijven.

Figuur 4: Benchmark: sequentieel lezen.

Figuur 5: Benchmark: random schrijven.

13

Figuur 6: Benchmark: random lezen.

dus niet tot zijn recht. We beschikten helaas niet over de mogelijkheid om zowelext3 als ext4 te benchmarken op een niet-lege harde schijf.

5 BesluitHet ext4 bestandssysteem biedt heel wat voordelen ten opzichte van zijn voorgan-ger: grotere bestanden en bestandssystemen, een kleinere fragmentatie door hetgebruik van vertraagde, multiblock en persistente (pre)allocatie. Deze reductievan fragmentatie heeft een positieve invloed op de toegangssnelheid tot datain de bestanden. Door het gebruik van nanosecond timestamps komt ext4 ooktegemoet aan de precisievereisten van huidige applicaties. Bij deze voordelenhoort wel een nadeel: er is een groter risico op verlies van data.

De benchmarks toonden aan dat deze wijzigingen een positieve invloed haddenop het schrijven naar vergrotend bestand. De voordelen van de reductie aanfragmentatie kwamen niet naar boven tijdens de benchmarks. Dit lag aan demanier waarop de benchmarks werden uitgevoerd.

14

Referenties[1] Michael Blizek. Ext4. Dec. 2010. url: http://kernelnewbies.org/Ext4.[2] Daniel P. Bovet en Marco Cesati Ph. Understanding the Linux Kernel.

Third. O’Reilly Media, nov. 2005. isbn: 0596005652.[3] Mingming Cao. Extent maps. Juli 2005. url: http://ext2.sourceforge.

net/2005-ols/paper-html/node19.html.[4] Mingming Cao et al. Ext4: The Next Generation of Ext2/3 Filesystem. Dec.

2010. url: http://www.usenix.org/event/lsf07/tech/cao_m.pdf.[5] Datarecoverytools. Learn more about Ext4: The Next Generation of Ext2/3

Filesystem. Dec. 2010. url: http://www.datarecoverytools.co.uk/2009/11/16/learn-more-about-ext4/.

[6] Ext2read. How Ext4 Extents Work? Dec. 2010. url: http://ext2read.blogspot.com/2010/03/how-ext4-extents-work-earlier-ext2-and.html.

[7] M. Tim Jones. “Anatomy of ext4: get to know the fourth extended filesystem”. In: (feb. 2009). url: http://download.boulder.ibm.com/ibmdl/pub/software/dw/linux/l-anatomy-ext4/l-anatomy-ext4-pdf.pdf.

[8] Jan Kara. Ext4, btrfs, and the others. url: http://atrey.karlin.mff.cuni.cz/~jack/papers/lk2009-ext4-btrfs.pdf.

[9] Kernel.org. Ext4 Howto. Dec. 2010. url: https://ext4.wiki.kernel.org/index.php/Ext4_Howto.

[10] Aneesh Kumar et al. “Ext4 block and inode allocator improvements”. In:Linux Symposium 1 (juli 2008), p. 263-274.

[11] Linfo. Superblock Definition. Dec. 2010. url: http://www.linfo.org/superblock.html.

[12] Avantika Mathur, Mingming Cao en Andreas Dilger. “ext4: the nextgeneration of the ext3 file system”. In: Login 31 (juni 2007), p. 25-30.

[13] Avantika Mathur et al. “The new ext4 filesystem: current status and futureplans”. In: Linux Symposium 2 (juni 2007), p. 21-34.

[14] David Moore. Ext4. Dec. 2010. url: http://linuxsoftware.co.nz/wiki/ext4.

[15] nixCraft. Understanding UNIX / Linux file system. Dec. 2010. url: http://www.cyberciti.biz/tips/understanding-unixlinux-file-system-part-i.html.

[16] Abraham Silberschatz, Peter Baer Galvin en Greg Gagne. Operating SystemConcepts. Eighth. Wiley Publishing, 2008. isbn: 0470128720.

[17] tux4u. Free Unix Documentation. Dec. 2010. url: http://www.tux4u.nl/freedocs/unix/uxindex_en.html.

[18] Wikipedia. ext2. Dec. 2010. url: http://en.wikipedia.org/wiki/Ext2.[19] Wikipedia. Ext4. Dec. 2010. url: http://en.wikipedia.org/wiki/Ext4.[20] Wikipedia. Extended file attributes. Dec. 2010. url: http://en.wikipedia.

org/wiki/Extended_file_attributes.

15

[21] Wikipedia. Htree. Dec. 2010. url: http://en.wikipedia.org/wiki/Htree.

[22] Wikipedia. Inode. Dec. 2010. url: http://en.wikipedia.org/wiki/Inode.

[23] Wikipedia. Journaling file system. Dec. 2010. url: http://en.wikipedia.org/wiki/Journaling_file_system.

16

A Logboek

Datum Tijdstip Taak Persoon28/10/2010 18u00–18u30 Opzoeken Internet Li05/11/2010 13u30–16u00 Opzoeken Internet Albert05/11/2010 17u00–19u30 Opzoeken Internet Li07/11/2010 20u00–23u00 Opzoeken Internet Gerry28/11/2010 09u00–13u00 Opzoeken Internet Albert28/11/2010 15u00–17u00 Beschrijving journaling en allocatie Albert29/11/2010 20u00–22u00 Analyseren broncode Albert03/12/2010 10u00–10u45 Bespreking verder verloop Iedereen03/12/2010 18u00–19u00 Analyseren broncode Li03/12/2010 20u00–23u00 Implementatie superblock Li06/12/2010 21u00–22u30 Analyseren broncode Albert11/12/2010 19u00–21u30 Beschrijving algemene kenmerken Gerry11/12/2010 21u30–23u00 Analyseren broncode Gerry12/12/2010 13u00–15u00 Implementatie superblock Li12/12/2010 15u00–15u30 Implementatie group descriptor Li12/12/2010 15u30–16u00 Implementatie bitmap Li12/12/2010 16u00–16u30 Nalezen en verbeteren Li13/12/2010 15u00–18u00 Implementatie inode en extent Li13/12/2010 18u00–22u00 Beschrijving functies Albert13/12/2010 22u00–00u00 Uitvoeren benchmarks Albert13/12/2010 22u00–00u00 Beschrijving algemene kenmerken Gerry14/12/2010 19u00–20u30 Beschrijving functies Albert14/12/2010 21u00–22u00 Beschrijving benchmarks Albert14/12/2010 20u00–23u00 Implementatie inode en extent Li15/12/2010 12u30–15u30 Nalezen en herformuleren Albert15/12/2010 20u00–23u00 Implementatie inode en extent Li15/12/2010 23u00–00u30 Nalezen en verbeteren Li15/12/2010 19u00–20u30 Analyseren broncode (extents) Albert15/12/2010 20u30–22u00 Nalezen en verbeteren Albert15/12/2010 22u00–00u30 Nalezen en verbeteren Gerry16/12/2010 11u00–14u00 Verbeteren en besluit Li16/12/2010 09u00–13u00 Nalezen en verbeteren en vervolledigen Albert

17