4.6.1 Struttura di base

Il filesystem ext2 definisce la minima unità di memorizzazione dei dati, il blocco (block), generalmente delle dimensioni di 1024 byte, ma la sua dimensione può essere scelta tra 1024, 2 048 o 4096 byte in fase di creazione del filesystem.

Figura 4.5: Struttura del filesystem ext2.

I blocchi vengono raggruppati in cylinder group (v. fig. 4.5) in modo da suddividere l’intero filesystem in entità autonome allo scopo di limitare eventuali errori che possono verificarsi nella struttura del filesystem (un errore è limitato all’interno di un cylinder group e non compromette l’intero filesystem) e per ridurre i tempi di accesso alle informazioni memorizzando i file nelle vicinanze delle directory che li contengono. Ogni cylinder group si suddivide a sua volta in

• Superblock contiene informazioni relative all’intero filesystem, secondo le seguenti tipologie
  • • caratteristiche tipiche (identificazione del filesystem¹¹, dimensioni, struttura, ...) - valori stabiliti al momento della creazione del filesystem e non possono essere più modificati, se non distruggendo il filesystem e creandone un altro (perdendo in questo modo le informazioni in esso eventualmente memorizzate);
  • • parametri modificabili (massimo numero di mount, massimo numero di mount prima di effettuare il controllo di errori, ...) - valori modificabili dal superuser per mezzo del comando tune2fs;
  • • stato (stato di montaggio del filesystem, numero di blocchi liberi, numero di mount correnti, ...) - informazioni relative all’uso corrente del filesystem;
  Il superblock di riferimento è memorizzato a partire dal 1024^o byte del disco e la sua dimensione è 1024 byte, ma per scopi di backup viene copiato in ogni cylinder group, anche se il kernel utilizza sempre quello di riferimento (l’originale).

  La struttura del superblock è riportata di seguito (sintassi C)

    struct ext2_super_block
    {
           __u32   s_inodes_count;         /* Inodes count */
           __u32   s_blocks_count;         /* Blocks count */
           __u32   s_r_blocks_count;       /* Superuser reserved blocks count */
           __u32   s_free_blocks_count;    /* Free blocks count */
           __u32   s_free_inodes_count;    /* Free inodes count */
           __u32   s_first_data_block;     /* First Data Block */
           __u32   s_log_block_size;       /* Block size */
           __s32   s_log_frag_size;        /* Fragment size */
           __u32   s_blocks_per_group;     /* # Blocks per group */
           __u32   s_frags_per_group;      /* # Fragments per group */
           __u32   s_inodes_per_group;     /* # Inodes per group */
           __u32   s_mtime;                /* Mount time */
           __u32   s_wtime;                /* Write time */
           __u16   s_mnt_count;            /* Mount count */
           __s16   s_max_mnt_count;        /* Maximal mount count */
           __u16   s_magic;                /* Magic signature */
           __u16   s_state;                /* File system state */
           __u16   s_errors;               /* Behaviour when detecting errors */
           __u16   s_pad;
           __u32   s_lastcheck;            /* time of last check */
           __u32   s_checkinterval;        /* max. time between checks */
                                                                          
                                                                          
           __u32   s_creator_os;           /* OS */
           __u32   s_rev_level;            /* Revision level */
           __u16   s_def_resuid;           /* Default UID for reserved blocks */
           __u16   s_def_resgid;           /* Default GID for reserved blocks */
           __u32   s_reserved[235];        /* Padding to the end of the block */
    }
    

  Il campo s_magic è un valore che indica in maniera univoca il tipo di filesystem utilizzato. Ogni filesystem ha un proprio valore caratteristico, tramite il quale può essere riconosciuto. Ext2 utilizza il valore EF53H.

  Il campo s_log_block_size contiene la dimensione dei blocchi del filesystem espressa in termini della potenza di 2 relativa alla base di 1024, cioè la dimensione dei blocchi, espressa in byte, è data da

  

  per cui se s_log_block_size contiene il valore 0, significa che la dimensione dei blocchi del filesystem è 1024 byte, se contiene il valore 1 è 2048 byte, ...;

• Group descriptor ogni group descriptor contiene informazioni relative al cylinder group a cui si riferisce (un riferimento alla blocks bitmap, uno alla inode bitmap, uno alla inode table, il numero dei blocchi liberi, quello degli inode liberi e delle directory presenti nel cylinder group).

  Il numero dei group descriptor è dato da

  

  dove s_blocks_count e s_blocks_per_group sono campi del superblock.

  La struttura dei group descriptor è riportata di seguito (sintassi C)

                                                                          
                                                                          
    struct ext2_group_desc
    {
           unsigned long bg_block_bitmap;          /* Blocks bitmap block */
           unsigned long bg_inode_bitmap;          /* Inodes bitmap block */
           unsigned long bg_inode_table;           /* Inodes table block */
           unsigned short bg_free_blocks_count;    /* Free blocks count */
           unsigned short bg_free_inodes_count;    /* Free inodes count */
           unsigned short bg_used_dirs_count;      /* Directories count */
           unsigned short bg_pad;
           unsigned long bg_reserved[3];
    }
    

  Il campo bg_inode_table contiene il numero che identifica il primo blocco della inode table.

  Anche i group descriptor vengono copiati in ogni cylinder group per scopi di backup;

  In particolare, il numero delle directory presenti nel cylinder group viene utilizzato dal filesystem alla creazione di una nuova directory. Per velocizzare gli accessi, ext2 tenta di memorizzare i file nello stesso cylinder group in cui è memorizzata la directory che li contiene, quindi la nuova directory verrà creata nel cylinder group che risulta più libero.

• Data block bitmap è una sequenza di bit, ognuno dei quali indica se il corrispondente data block del cylinder group è libero o allocato. La sua dimensione è quella di un blocco (tipicamente 1024 byte) e quindi saranno individuati 8192 (1024 × 8) data block per ogni cylinder group;

  Il kernel effettua automaticamente un’ottimizzazione dell’utilizzo del filesystem, raggruppando i dati nei blocchi fisicamente adiacenti, per cui generalmente nel data block bitmap, tutti i bit di un byte contengono il valore 0 o 1, ovvero i byte sono 00H o FFH. Per questo motivo GNU/Linux non necessita di alcun tool di deframmentazione del filesystem.

• Inode bitmap analogo al data block bitmap ma si riferisce agli inode (che generalmente sono in numero minore dei data block). Per il ragionamento effettuato precedentemente, con blocchi di 1024 byte, possono esistere al massimo 8192 inode per cylinder group;
• Inode table è la porzione del filesystem che contiene gli inode del cylinder group, ovvero strutture adibite alla memorizzazione delle proprietà degli oggetti del filesystem (file, directory, ...).

  Un inode è costituito da una struttura di 128 byte, che è riportata di seguito (sintassi C)

                                                                          
                                                                          
    struct ext2_inode
    {
           unsigned short i_mode;          /* File mode (file type and access rights) */
           unsigned short i_uid;           /* Owner UID */
           unsigned long i_size;           /* Size in bytes */
           unsigned long i_atime;          /* Last access time */
           unsigned long i_ctime;          /* Last inode change time */
           unsigned long i_mtime;          /* Last data modification time */
           unsigned long i_dtime;          /* Deletion Time */
           unsigned short i_gid;           /* Owner GID */
           unsigned short i_links_count;   /* Links count, max 32000 */
           unsigned long i_blocks;         /* Blocks count (in 521 bytes units) */
           unsigned long i_flags;          /* File flags (special attributes) */
           unsigned long i_reserved1;
           unsigned long i_block[15];      /* Pointers to data blocks */
           unsigned long i_generation;     /* File version (for NFS) */
           unsigned long i_file_acl;       /* File ACL */
           unsigned long i_dir_acl;        /* Directory ACL */
           unsigned long i_faddr;          /* Fragment address */
           unsigned char i_frag;           /* Fragment number */
           unsigned char i_fsize;          /* Fragment size */
           unsigned short i_pad1;
           __u16   l_i_uid_high;           /* High order part of UID */
           __u16   l_i_gid_high;           /* High order part of GID */
           __u32   l_i_reserved2;
    }
    

• Data blocks è la porzione del filesystem che contiene i blocchi (data blocks) del cylinder group, adibiti alla memorizzazione delle informazioni contenute all’interno dei file.