linux user group brescia

On Thu, Nov 23, 2006 at 11:30:42AM +0100, Andrea Gelmini wrote:
> 
> > ma poi penso che la hole la crea solo quando c'e' tutto un blocco vuoto,
> > e non solo una sequenza alcuni byte.
> e per quale ragione dovrebbe avere un comportamento così buffo?

vediamo prima il caso di un file 'non sparso', ovvero senza hole.

supponiamo i blocchi di 4096byte.
supponiamo di avere un file gia' esistente, della dimensione di
40950byte ovvero supponiamo che tale file occupi 10 blocchi.

ovviamente questi blocchi non sono contigui ma sono sparsi in giro per
il disco in maniera casuale.

nell'inode e' salvato l'elenco (come lista o come albero, penso dipenda
dal fs) dei blocchi in cui viene mappato il file:

+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
+---+---+---+---+---+---+---+---+---+---+

il riferimento 0 conterra' l'indirizzo del blocco fisico su cui i primi
4096 byte sono scritti, 
il riferimento 1 conterra' l'indirizzo del blocco fisico su cui i
successivi 4096 byte sono scritti, 
il riferimento 2 conterra' l'indirizzo del blocco fisico su cui i
successivi 4096 byte sono scritti, 
il riferimento 3 conterra' l'indirizzo del blocco fisico su cui i
successivi 4096 byte sono scritti, etc etc.

ora, se tu in questo file ci vuoi scrivere qualcosa, supponiamo 
il carattere 'x' al 10000esimo byte, il sistema si prende carico di
calcolare l'offset della scrittura e di decidere a che blocco appartiene
quell'offset: in questo caso avendo il blocco da 4096 il carattere
dobbiamo andare a scriverlo nel blocco 2.

il caso di un file sparso e' molto simile, con la sola differenza che la
scrittura non avviene immediatamente ma prima deve essere verificato che
il blocco corrispondente sia gia' stato scritto:

supponiamo che il file inizialmente sia composto da un solo blocco, e di
conseguenza nell'inode ci sara' una lista contenente un solo riferimento
verso tale blocco di disco scritto:

+---+
| 0 |
+---+

dovendo noi andare a scrivere nel blocco 2, il sistema prima deve
allungare la dimensione del file

+---+---+---+
| 0 | 1 | 2 |
+---+---+---+

ora, a questo punto pero' l'unico blocco scritto su disco e' quello
associato al blocco 0.

quando il sistema vuole andare a scrivere da qualche parte, deve 

if(il blocco 2 e' marcato come non scritto){
  alloca un blocco di disco prendendolo dalla lista dei blocchi liberi;
  resetta il blocco 2 con tutti 0;
  marca il blocco 2 come scritto 
  scrive all'offset (10000 - 4096*2) del blocco 2 il carattere 'x';
}

il risultato e' che soltanto il blocco 0 e il blocco 2 sono stati
effettivamente scritti sul disco, mentre invece il blocco 1 non e'
ancora scritto da nessuna parte (e si considera il suo contenuto tutti
0).

quindi il file deve alla fine occupare sempre un multiplo di 4096 byte.

spero ci si capisca qualcosa. :)