Esercizio - Frammentazione interna di un file con stat e statvfs (laboratorio 10)

Il comando stat

stat nomefile stampa (tra le altre cose) la dimensione in byte, il numero di blocchi allocati e la dimensione del blocco di I/O:

  File: abcde.txt
  Size: 1948        Blocks: 8          IO Block: 4096   regular file

Per ragioni storiche i blocchi contati da stat (campo st_blocks) sono sempre unità da 512 byte, mentre il blocco fisico di I/O del file system (campo IO Block, st_blksize, e f_bsize di statvfs) è di 4096 byte. Una unità fisica corrisponde quindi a $4096/512=8$ blocchi contati.

Task 1

File da 1 byte. Occupa comunque un blocco fisico da 4096 byte: Blocks: 8 (8 blocchi da 512), 4095 byte sprecati. Un file vuoto ha invece Blocks: 0.

File ENIAC_Penn1.jpg. La dimensione è 1 981 975 byte e il blocco fisico 4096 byte:

$$\left\lceil\frac{1\,981\,975}{4096}\right\rceil=\lceil483{,}89\rceil=484\ \text{blocchi fisici}\ (=3872\ \text{blocchi da 512}).$$

La memoria allocata è $484\cdot4096=1\,982\,464$ byte e la frammentazione interna

$$1\,982\,464-1\,981\,975=\mathbf{489\ byte}.$$

Il risultato coincide con la soluzione del corso (nell'ultimo blocco sono usati $1\,981\,975-483\cdot4096=3607$ byte su 4096, ne avanzano $4096-3607=489$).

Task 2: fraginfo.c

Si parte da fileinfo.c, che chiama lstat(argv[1], &sfile) (come stat, ma non segue i link simbolici) e statvfs(argv[1], &sdisk):

• sdisk.f_bsize è la dimensione del blocco del file system;
• sfile.st_size è la dimensione in byte del file.

Il numero di blocchi occupati è $\lceil\text{dimensione}/\text{blocco}\rceil$, e la frammentazione interna è lo spazio allocato meno quello usato:

$$\text{frammentazione}=\left\lceil\frac{\text{dim}}{B}\right\rceil B-\text{dim}.$$

/* fraginfo.c - frammentazione interna dell'ultimo blocco di un file.
 * Compilare:  gcc -Wall -Wextra -o fraginfo fraginfo.c
 * Usare:      ./fraginfo abcde.txt
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/stat.h>
#include <sys/statvfs.h>

int main(int argc, char *argv[]) {
    struct stat sf;
    struct statvfs sv;
    if (argc != 2) { fprintf(stderr, "uso: %s file\n", argv[0]); return EXIT_FAILURE; }
    if (lstat(argv[1], &sf) < 0) { perror("lstat"); return EXIT_FAILURE; }
    if (statvfs(argv[1], &sv) < 0) { perror("statvfs"); return EXIT_FAILURE; }

    intmax_t blocco = (intmax_t)sv.f_bsize; /* blocco del file system */
    intmax_t dim = (intmax_t)sf.st_size;    /* byte del file */
    intmax_t blocchi = (dim + blocco - 1) / blocco; /* blocchi occupati, per eccesso */
    intmax_t sprecati = blocchi * blocco - dim;     /* 0 se la dimensione e' multipla */

    printf("blocco del file system:  %jd byte\n", blocco);
    printf("dimensione del file:     %jd byte\n", dim);
    printf("blocchi necessari:       %jd (stat dice %jd da 512 byte)\n", blocchi, (intmax_t)sf.st_blocks);
    printf("frammentazione interna:  %jd byte\n", sprecati);
    return EXIT_SUCCESS;
}

Compilato con zig cc per Linux, senza avvisi; non eseguito. Per ENIAC_Penn1.jpg l'uscita attesa è: blocco 4096, dimensione 1981975, blocchi necessari 484, frammentazione 489.

Differenza dalla soluzione del corso. La soluzione distribuita calcola

int wasted = sdisk.f_bsize - sfile.st_size % sdisk.f_bsize;

cioè $B-(\text{dim}\bmod B)$. Per quasi tutti i file dà il risultato giusto (per esempio 4096 − 3607 = 489 per il file del laboratorio) ma è sbagliata quando la dimensione è un multiplo del blocco: per un file di 4096 byte il resto è 0 e wasted vale 4096, mentre la frammentazione è 0; lo stesso per un file vuoto (0 blocchi, nessuno spreco). Il calcolo $\lceil\text{dim}/B\rceil B-\text{dim}$ è corretto in tutti i casi. In più, il programma del corso usa int per un valore che arriva a intmax_t e non controlla gli argomenti.

Altre osservazioni: st_blocks può essere maggiore del valore calcolato se il file system ha allocato blocchi aggiuntivi (per esempio blocchi di indirezione per file grandi, o preallocazione); per file piccoli o medi su ext4 il valore coincide con quello calcolato qui. Il numero st_blocks è la verifica incrociata richiesta dal testo: $484\cdot8=3872$.

Errori tipici

• Contare i blocchi di stat come da 4096 (sono da 512).
• Usare la divisione per difetto: servono i blocchi per eccesso (dim / blocco perde l'ultimo blocco parziale).
• Dimenticare il caso di un file lungo esattamente un multiplo del blocco (frammentazione 0, non $B$).
• Confondere la dimensione del file (st_size) con lo spazio allocato (st_blocks$\cdot512$).
• Scambiare lstat e stat su un link simbolico: lstat descrive il link, stat il file puntato.