Un filesystem virtuale è un filesystem che esiste in un file, che a sua volta esiste su un disco fisico. Ci sono molte cose fantastiche che puoi fare con i file system virtuali; il motivo per cui stavo scherzando con loro era configurare una macchina virtuale su un host Linux. Altri usi includono la crittografia di filesystem senza crittografia di interi dischi; File Vault di Mac OS X crittografa le directory home degli utenti in questo modo. Forse sei andato avanti e hai creato una partizione gigante e poi hai realizzato, per un motivo o per l'altro, che vuoi partizioni multiple! I filesystem virtuali possono aiutare (in una certa misura) anche in questo.
Quindi, come si crea un file system virtuale? Facile. La prima cosa che devi fare è creare un file per il filesystem in cui vivere. Qui è dove inizia a comparire 'dd'. Considera, ad esempio, il seguente comando:
dd if = / dev / zero of = ~ / myFileSystem.img bs = 1024 count = 1048576
Questo comando leggerà 1.048.576 blocchi da / dev / zero e li scriverà in ~ / myFileSystem.img; ogni blocco ha 1024 byte, risultando in un file da 1 gigabyte contenente tutti gli zero. I valori effettivi che usi per la dimensione dei blocchi (bs) e il conteggio non sono molto importanti, la chiave è di capire bene la tua matematica: bs * count = imageSize.
Quindi ora hai il tuo file; grande. È tempo di creare un file system! questa parte è ancora più semplice ... creeremo un filesystem EXT2, usando il seguente comando:
mke2fs myFileSystem.img
È possibile che venga visualizzato un messaggio di avviso in cui si dice che myFileSystem.img non è un dispositivo a blocchi, si desidera procedere? Ci arriveremo tra un secondo, per ora, vai avanti e dici di sì. Tutto dovrebbe andare liscio, sembrerà come se avessi creato un filesystem su una vera unità disco. Ora hai un file system virtuale! L'unica cosa che resta da fare è montare il tuo filesystem in modo che tu possa accedervi ...
mkdir / mnt / virtual
mount -o loop ~ / myFileSystem.img / mnt / virtual
Ora qualsiasi file che inserisci in / mnt / virtual viene effettivamente inserito direttamente in myFileSystem.img! Non è stato facile?
Fantastico. Ora che sai come creare un filesytsem virtuale, perché non creare un po 'l'immagine del disco virtuale? Qual è la differenza che chiedi? Un'immagine del disco avrà una tabella delle partizioni che definisce un numero di partizioni e ogni partizione contiene il proprio filesystem; quindi un filesystem virtuale è essenzialmente una "partizione virtuale" di un'immagine di disco virtuale; l'immagine del disco virtuale contiene più filesystem virtuali e una tabella delle partizioni virtuali che descrive dove si trovano i limiti di ciascuna partizione.
La creazione di un'immagine del disco virtuale inizia allo stesso modo; la prima cosa che ti serve è un grosso file vuoto, appena creato sopra. Questa volta, invece di creare un file system, vorremmo partizionare il file usando fdisk. Per rendere le cose un po 'più belle, però, inseriremo dispositivi di loopback nel mix. Dovresti assicurarti di avere il supporto del dispositivo di loopback abilitato nel tuo kernel (la maggior parte delle distribuzioni lo fanno di default; ma se sei un kernel compilando linux junky, potresti voler controllare). Quindi creeremo un file di grandi dimensioni e lo allegheremo a un dispositivo di loopback, come segue:
dd if = / dev / zero of = ~ / myDisk.img bs = 1024 count = 1048576
losetup / dev / loop0 ~ / myDisk.img
Collegando l'immagine del disco al dispositivo di loopback, possiamo usare / dev / loop0 nello stesso modo in cui useremmo ~ / myDisk.img; la differenza principale è che / dev / loop0 è un cosiddetto "dispositivo a blocchi". Dovresti chiedere a qualcuno con più esperienza di quanta ne abbia io di preciso, ma quello che so è che le utilità del filesystem funzionano meglio con i dispositivi a blocchi piuttosto che con i file flat. Inoltre, è divertente.
Bene, abbiamo un grosso file vuoto allegato a un dispositivo di loopback (/ dev / loop0) ... ora è il momento di creare partizioni nell'immagine del disco. Per fare ciò, eseguiremo fdisk sul nostro dispositivo di loopback:
fdisk / dev / loop0
Consente di creare tre partizioni ... se stai seguendo questo, dovresti già avere familiarità con fdisk, quindi vai avanti e crea quanto segue: Avvio dispositivo Fine blocchi Blocchi ID Sistema
/ dev / loop0p1 1 17 136521 83 Linux
/ dev / loop0p2 18 80 506047+ 82 Linux swap
/ dev / loop0p3 81 130 401625 83 Linux
Dopo aver effettuato le partizioni, scrivi le modifiche e esci da fdisk. Quello che dovremo fare dopo è creare filesystem su ogni partizione. Ricordi quanto era facile tornare con i filesystem virtuali? Non molto più ...
Non preoccuparsi però ... il problema è che "mkfs" non può "raggiungere" l'immagine del nostro disco virtuale e creare un filesystem solo su una singola partizione. Infatti, se ci provi, probabilmente finirai per cancellare la nostra immagine del disco virtuale e dover eseguire nuovamente fdisk. Quindi cosa fare ... cosa fare ?? Dispositivi di loopback in soccorso. Quello che faremo è collegare un dispositivo di loopback al file myDisk.img negli offset specifici in cui inizia ogni partizione.
È utile quindi guardare le partizioni in termini di blocchi. Eseguire il comando seguente:
fdisk -ul / dev / loop0
dovrebbe apparire (si spera esattamente) così:
Disco / dev / loop0: 1073 MB, 1073741824 byte
255 teste, 63 settori / binario, 130 cilindri, totale 2097152 settori
Unità = settori di 1 * 512 = 512 byte
Device Boot Start End Blocks Id System
/ dev / loop0p1 63 273104 136521 83 Linux
/ dev / loop0p2 273105 1285199 506047+ 82 Linux swap
/ dev / loop0p3 1285200 2088449 401625 83 Linux
Questi numeri sono importanti per la matematica ... useremo il comando losetup come abbiamo fatto prima, solo che questa volta arriveremo specificamente all'inizio di ciascuna delle tre partizioni. losetup accetta gli offset come numero di byte da saltare all'inizio del file. L'output di fdisk -ul / dev / loop0 ci mostra che la prima partizione inizia dal blocco 63 e che ogni blocco è di 512 byte. Quindi la partizione 1 inizia al byte 32.256
losetup -o 32256 / dev / loop1 / dev / loop0
Quel comando raggiunge 32.256 byte in / dev / loop0 e lo monta su / dev / loop1. Ricorda che dal momento che / dev / loop0 è allegato al file myDisk.img, questo equivale a raggiungere 32.256 byte in quel file ... segui? Ok bene. Stessa logica per le partizioni 2 e 3:
losetup -o 139829760 / dev / loop2 / dev / loop0
losetup -o 658022400 / dev / loop3 / dev / loop0
Quindi ora abbiamo quattro dispositivi loopback impostati; / dev / loop0 è allegato al file myDisk.img. / dev / loop1 è la prima partizione del disco virtuale rappresentata da / dev / loop0; / dev / loop2 è il 2 ° e / dev / loop3 è il 3 °.
Ora è finalmente il momento di creare quei file system! Questo è ora facile come creare un normale filesystem, dato che è tutto ciò che stiamo facendo. Ricorda, mkfs non sa che il dispositivo non è un dispositivo fisico! Realizzeremo tre tipi di file system, un file system ext2 per la partizione 1, un file system di scambio per la partizione 2 e un file system XFS per la partizione 3:
mkfs / dev / loop1
mkswap / dev / loop2
mkfs.xfs / dev / loop3
Poiché loop1, loop2 e loop3 sono collegati direttamente a loop0 e loop0 è ~ / myDisk.img, tutto ciò che abbiamo appena fatto su loop1, loop2 e loop3 ha influenzato direttamente myDisk.img! Ora possiamo montare / dev / loop3, ad esempio, su / mnt / virtual come file system XFS e usarlo come un normale file system!
Quindi spero che tu l'abbia trovato utile ... puoi fare cose piuttosto ordinate con i file system virtuali e le immagini del disco virtuale; e i dispositivi loopback fanno la differenza per rendere le cose più fluide.