104.1 Lezione 1

Certificazione:

LPIC-1

Versione:

5.0

Argomento:

104 Dispositivi, Il Filesystem Linux, Filesystem Hierarchy Standard

Obiettivo:

104.1 Creare partizioni e filesystem

Lezione:

1 di 1

Introduzione

Su qualsiasi sistema operativo, un disco deve essere partizionato prima di poter essere utilizzato. Una partizione è un sottoinsieme logico del disco fisico; le informazioni sulle partizioni sono archiviate in una tabella delle partizioni. Questa tabella include informazioni sul primo e sull’ultimo settore della partizione e sul suo tipo e ulteriori dettagli su ciascuna partizione.

Di solito ogni partizione è vista da un sistema operativo come un “disco” separato, anche se risiedono tutte nello stesso supporto fisico. Su sistemi Windows vengono assegnate lettere come C: (storicamente il disco principale), D: e così via. Su Linux ogni partizione è assegnata a una directory sotto /dev, come /dev/sda1 o /dev/sda2.

In questa lezione imparerai come creare, eliminare, ripristinare e ridimensionare le partizioni usando le tre utilità più comuni (fdisk, gdisk e parted), come creare un filesystem su di esse e come creare e impostare una partizione di swap o un file di swap da utilizzare come memoria virtuale.

Note	Per ragioni storiche, in questa lezione faremo riferimento ai supporti di archiviazione come “dischi”, anche se i sistemi di archiviazione moderni, come gli SSD e i Flash Storage, non contengono affatto “dischi”.

Comprendere MBR e GPT

Esistono due modi principali per memorizzare le informazioni delle partizioni sui dischi rigidi. Il primo è MBR (Master Boot Record) e il secondo è GPT (GUID Partition Table)

MBR: Questo è un residuo degli albori di MS-DOS (più specificamente, PC-DOS 2.0 del 1983) e per decenni è stato lo schema di partizionamento standard sui PC. La tabella delle partizioni è memorizzata sul primo settore di un disco, chiamato Boot Sector, insieme a un boot loader, che sui sistemi Linux è solitamente il bootloader GRUB. Ma MBR ha una serie di limitazioni che ne ostacolano l’uso sui sistemi moderni, come l’incapacità di indirizzare dischi di dimensioni superiori a 2 TB e il limite di sole 4 partizioni primarie per disco.
GUID: Un sistema di partizionamento che risolve molti dei limiti di MBR. Non esiste un limite pratico alla dimensione del disco e il numero massimo di partizioni è limitato solo dal sistema operativo stesso. Si trova più comunemente su macchine più moderne che utilizzano UEFI invece del vecchio BIOS del PC.

Durante le attività di amministrazione del sistema è altamente probabile che troverai entrambi gli schemi in uso, quindi è importante sapere come utilizzare gli strumenti associati a ciascuno per creare, eliminare o modificare le partizioni.

Gestire Partizioni MBR con FDISK

L’utilità standard per la gestione delle partizioni MBR su Linux è fdisk. Questa è un’utilità interattiva basata su menu. Per usarla digita fdisk e il nome del dispositivo corrispondente al disco che desideri modificare. Per esempio, il comando

# fdisk /dev/sda

modifica la tabella delle partizioni del primo dispositivo connesso a SATA (sda) sul sistema. Tieni presente che devi specificare il dispositivo corrispondente al disco fisico, non una delle sue partizioni (come /dev/sda1).

Note	Tutte le operazioni relative al disco in questa lezione devono essere eseguite come utente `root` (l’amministratore di sistema), o con privilegi di root usando `sudo`.

Quando invocato, fdisk mostrerà un saluto, quindi un avviso e attenderà i tuoi comandi.

# fdisk /dev/sda
Welcome to fdisk (util-linux 2.33.1).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.

Command (m for help):

L’avvertimento è importante. È possibile creare, modificare o eliminare partizioni a piacere, ma nulla verrà scritto su disco a meno che non si utilizzi il comando write (w). Quindi puoi “esercitarti” senza il rischio di perdere dati, a patto di stare lontano dal tasto w. Per uscire da fdisk senza salvare le modifiche, utilizzare il comando q.

Note	Detto questo, non dovresti mai esercitarti su un disco importante, poiché ci sono sempre dei rischi. Utilizzare invece un disco esterno di riserva o un’unità flash USB.

Stampare la Tabella delle Partizioni Corrente

Il comando p viene utilizzato per stampare la tabella delle partizioni corrente. L’output è qualcosa del genere:

Command (m for help): p
Disk /dev/sda: 111.8 GiB, 120034123776 bytes, 234441648 sectors
Disk model: CT120BX500SSD1
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x97f8fef5

Device     Boot     Start       End   Sectors   Size Id Type
/dev/sda1            4096 226048942 226044847 107.8G 83 Linux
/dev/sda2       226048944 234437550   8388607     4G 82 Linux swap / Solaris

Ecco il significato di ogni colonna:

Device: Il dispositivo assegnato alla partizione.
Boot: Mostra se la partizione è “avviabile” o meno.
Start: Il settore in cui inizia la partizione.
End: Il settore in cui finisce la partizione.
Sectors: Il numero totale di settori nella partizione. Moltiplicalo per la dimensione del settore per ottenere la dimensione della partizione in byte.
Size: La dimensione della partizione nel formato “human readable”. Nell’esempio sopra, i valori sono in gigabyte.
Id: Il valore numerico che rappresenta il tipo di partizione.
Type: La descrizione per il tipo di partizione.

Partizioni Primarie ed Estese a Confronto

Su un disco MBR puoi avere 2 tipi principali di partizioni, primarie ed estese. Come abbiamo detto prima, puoi avere solo 4 partizioni primarie sul disco, e se vuoi rendere il disco “avviabile”, la prima partizione deve essere primaria.

Un modo per aggirare questa limitazione è creare una partizione estesa che funge da contenitore per le partizioni logiche. Si potrebbe avere, per esempio, una partizione primaria, una partizione estesa che occupa il resto dello spazio su disco e cinque partizioni logiche al suo interno.

Per un sistema operativo come Linux le partizioni primarie ed estese sono trattate esattamente allo stesso modo, quindi non ci sono “vantaggi” nell’usare una rispetto all’altra.

Creare una Partizione

Per creare una partizione usa il comando n. Per impostazione predefinita le partizioni verranno create all’inizio dello spazio non allocato sul disco. Ti verrà chiesto il tipo di partizione (primaria o estesa), primo settore e ultimo settore.

Per il primo settore, di solito puoi accettare il valore predefinito suggerito da fdisk, a meno che tu non abbia bisogno di una partizione per iniziare in un settore specifico. Invece di specificare l’ultimo settore, è possibile specificare una dimensione seguita dalle lettere K, M, G, T o P(Kilo, Mega, Giga, Tera o Peta). Quindi, se vuoi creare una partizione da 1 GB, puoi specificare +1G come Ultimo settore e fdisk ridimensionerà la partizione di conseguenza. Vedi questo esempio per la creazione di una partizione primaria:

Command (m for help): n
Partition type
   p   primary (0 primary, 0 extended, 4 free)
   e   extended (container for logical partitions)
Select (default p): p
Partition number (1-4, default 1): 1
First sector (2048-3903577, default 2048): 2048
Last sector, +/-sectors or +/-size{K,M,G,T,P} (2048-3903577, default 3903577): +1G

Verifica dello Spazio non Allocato

Se non sai quanto spazio libero c’è sul disco, puoi usare il comando F per mostrare lo spazio non allocato, in questo modo:

Command (m for help): F
Unpartitioned space /dev/sdd: 881 MiB, 923841536 bytes, 1804378 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes

  Start     End Sectors  Size
2099200 3903577 1804378  881M

Cancellare Partizioni

Per eliminare una partizione usa il comando d. fdisk ti chiederà il numero della partizione che desideri eliminare, a meno che non ci sia una sola partizione sul disco. In questo caso, questa partizione verrà selezionata ed eliminata immediatamente.

Tieni presente che se elimini una partizione estesa, verranno eliminate anche tutte le partizioni logiche al suo interno.

Attenzione allo Spazio!

Tieni presente che quando crei una nuova partizione con fdisk, la dimensione massima sarà limitata alla quantità massima di spazio contiguo non allocato sul disco. Supponiamo, per esempio, di avere la seguente tabella delle partizioni:

Device     Boot   Start     End Sectors  Size Id Type
/dev/sdd1          2048 1050623 1048576  512M 83 Linux
/dev/sdd2       1050624 2099199 1048576  512M 83 Linux
/dev/sdd3       2099200 3147775 1048576  512M 83 Linux

Quindi elimini la partizione 2 e controlli lo spazio libero:

Command (m for help): F
Unpartitioned space /dev/sdd: 881 MiB, 923841536 bytes, 1804378 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes

  Start     End Sectors  Size
1050624 2099199 1048576  512M
3147776 3903577  755802  369M

Sommando la dimensione dello spazio non allocato, in teoria abbiamo 881 MB disponibili. Ma guarda cosa succede quando proviamo a creare una partizione da 700 MB:

Command (m for help): n
Partition type
   p   primary (2 primary, 0 extended, 2 free)
   e   extended (container for logical partitions)
Select (default p): p
Partition number (2,4, default 2): 2
First sector (1050624-3903577, default 1050624):
Last sector, +/-sectors or +/-size{K,M,G,T,P} (1050624-2099199, default 2099199): +700M
Value out of range.

Ciò accade perché il più grande spazio contiguo non allocato sul disco è il blocco di 512 MB che apparteneva alla partizione 2. La tua nuova partizione non può “oltrepassare” la partizione 3 per utilizzare parte dello spazio non allocato dopo di essa.

Cambiare il Tipo di PartizioneN

Occasionalmente, potrebbe essere necessario modificare il tipo di partizione, soprattutto quando si tratta di dischi che verranno utilizzati su altri sistemi operativi e piattaforme. Questo viene fatto con il comando t, seguito dal numero della partizione che desideri modificare.

Il tipo di partizione deve essere specificato dal suo codice esadecimale corrispondente e puoi vedere un elenco di tutti i codici validi usando il comando l.

Non confondere il tipo di partizione con il filesystem utilizzato su di essa. Sebbene all’inizio ci fosse una relazione tra loro, oggi non puoi presumere che sia così. Una partizione Linux, per esempio, può contenere qualsiasi file system nativo di Linux, come ext4 o ReiserFS.

Tip	Le partizioni Linux sono di tipo `83` (Linux). Le partizioni di swap sono di tipo `82` (Linux Swap).

Gestire Partizioni GUID con GDISK

L’utilità gdisk è l’equivalente di fdisk quando si ha a che fare con dischi partizionati GPT. In effetti, l’interfaccia è modellata su fdisk, con un prompt interattivo e gli stessi (o molto simili) comandi.

Stampare la Tabella delle Partizioni Corrente

Il comando p viene utilizzato per stampare la tabella delle partizioni corrente. L’output è qualcosa del genere:

Command (? for help): p
Disk /dev/sdb: 3903578 sectors, 1.9 GiB
Model: DataTraveler 2.0
Sector size (logical/physical): 512/512 bytes
Disk identifier (GUID): AB41B5AA-A217-4D1E-8200-E062C54285BE
Partition table holds up to 128 entries
Main partition table begins at sector 2 and ends at sector 33
First usable sector is 34, last usable sector is 3903544
Partitions will be aligned on 2048-sector boundaries
Total free space is 1282071 sectors (626.0 MiB)

Number  Start (sector)    End (sector)  Size       Code  Name
   1            2048         2099199   1024.0 MiB  8300  Linux filesystem
   2         2623488         3147775   256.0 MiB   8300  Linux filesystem

Fin dall’inizio, notiamo alcune cose diverse:

Ogni disco ha un identificatore disco (GUID) univoco. Si tratta di un numero esadecimale a 128 bit, assegnato in modo casuale quando viene creata la tabella delle partizioni. Poiché ci sono 3.4 × 10³⁸ valori possibili per questo numero, le possibilità che 2 dischi casuali abbiano lo stesso GUID sono piuttosto scarse. Il GUID può essere usato per identificare quali filesystem montare all’avvio (e dove), eliminando la necessità di usare il percorso del dispositivo per farlo (come /dev/sdb).
Vedi la frase Partition table holds up to 128 entries? Esatto, puoi avere fino a 128 partizioni su un disco GPT. Per questo motivo, non sono necessarie le partizioni primarie e estese.
Lo spazio libero è elencato nell’ultima riga, quindi non è necessario un equivalente del comando F da fdisk.

Creare una Partizione

Il comando per creare una partizione è n, proprio come in fdisk. La differenza principale è che oltre al numero di partizione e al primo e all’ultimo settore (o dimensione), è anche possibile specificare il tipo di partizione durante la creazione. Le partizioni GPT supportano molti più tipi rispetto a MBR. Puoi controllare un elenco di tutti i tipi supportati usando il comando l.

Cancellare una Partizione

Per eliminare una partizione, digitare d e il numero della partizione. A differenza di fdisk, la prima partizione non verrà selezionata automaticamente se è l’unica sul disco.

Sui dischi GPT le partizioni possono essere facilmente riordinate, o riorganizzate, per evitare lacune nella sequenza di numerazione. Per fare ciò usa semplicemente il comando s. Per esempio, immagina un disco con la seguente tabella delle partizioni

Number  Start (sector)    End (sector)  Size       Code  Name
   1            2048         2099199   1024.0 MiB  8300  Linux filesystem
   2         2099200         2361343   128.0 MiB   8300  Linux filesystem
   3         2361344         2623487   128.0 MiB   8300  Linux filesystem

Se elimini la seconda partizione, la tabella diventerà:

Number  Start (sector)    End (sector)  Size       Code  Name
   1            2048         2099199   1024.0 MiB  8300  Linux filesystem
   3         2361344         2623487   128.0 MiB   8300  Linux filesystem

Se usi il comando s, diventerebbe:

Number  Start (sector)    End (sector)  Size       Code  Name
   1            2048         2099199   1024.0 MiB  8300  Linux filesystem
   2         2361344         2623487   128.0 MiB   8300  Linux filesystem

Notare che la terza partizione è diventata la seconda.

Spazio? Quale Spazio?

A differenza dei dischi MBR, quando si crea una partizione su dischi GPT la dimensione non è limitata dalla quantità massima di spazio contiguo non allocato. È possibile utilizzare fino all’ultimo bit di un settore libero, indipendentemente da dove si trova sul disco.

Opzioni di Ripristino

I dischi GPT archiviano copie di backup dell’intestazione GPT e della tabella delle partizioni, semplificando il ripristino dei dischi nel caso in cui questi dati siano stati danneggiati. gdisk fornisce funzionalità per aiutare nelle attività di ripristino, accessibili con il comando r.

È possibile ricostruire un’intestazione GPT principale o una tabella delle partizioni danneggiata rispettivamente con b e c, oppure utilizzare l’intestazione e la tabella principali per ricostruire un backup con d e e. Puoi anche convertire un MBR in un GPT con f e fare l’opposto con g, tra le altre operazioni. Digita ? nel menu di ripristino per ottenere un elenco di tutti i comandi di ripristino disponibili e le descrizioni di ciò che fanno.

Creare un File System

Il partizionamento del disco è solo il primo passo per poterlo utilizzare. Dopodiché, dovrai formattare la partizione con un filesystem prima di utilizzarlo per memorizzare i dati.

Un filesystem controlla il modo in cui i dati vengono archiviati e acceduti sul disco. Linux supporta molti filesystem: alcuni nativi, come la famiglia ext (Extended Filesystem); altri provengono da sistemi operativi differenti come FAT da MS-DOS, NTFS da Windows NT, HFS e HFS+ da Mac OS, ecc.

Lo strumento standard usato per creare un filesystem su Linux è mkfs, disponibile in molte “varianti” a seconda del filesystem con cui deve lavorare.

Creare un Filesystem ext2/ext3/ext4

L' Extended Filesystem (ext) è stato il primo filesystem per Linux e nel corso degli anni è stato sostituito da nuove versioni chiamate ext2, ext3 ed ext4, che attualmente è il filesystem predefinito per molte distribuzioni Linux.

Le utilità mkfs.ext2, mkfs.ext3 e mkfs.ext4 sono usate per creare filesystem ext2, ext3 ed ext4. In effetti, tutte queste “utilità” esistono solo come collegamenti simbolici a un’altra utilità chiamata mke2fs. mke2fs altera i suoi valori predefiniti in base al nome con cui è chiamato. In quanto tali, hanno tutti lo stesso comportamento e parametri della riga di comando.

La forma più semplice di utilizzo è:

# mkfs.ext2 TARGET

Dove TARGET è il nome della partizione in cui deve essere creato il filesystem. Per esempio, per creare un filesystem ext3 su /dev/sdb1 il comando sarebbe:

# mkfs.ext3 /dev/sdb1

Invece di usare il comando corrispondente al filesystem che desideri creare, puoi passare il parametro -t a mke2fs seguito dal nome del filesystem. Per esempio, i seguenti comandi sono equivalenti e creeranno un filesystem ext4 su /dev/sdb1

# mkfs.ext4 /dev/sdb1
# mke2fs -t ext4 /dev/sdb1

Parametri da Linea di Comando

mke2fs supporta un’ampia gamma di parametri e opzioni dalla riga di comando. Ecco alcuni dei più significativi. Tutti si applicano anche a mkfs.ext2, mkfs.ext3 e mkfs.ext4:

-b SIZE: Imposta la dimensione dei blocchi di dati nel dispositivo su SIZE, che può essere 1024, 2048 o 4096 byte per blocco.
-c: Controlla il dispositivo di destinazione per i blocchi danneggiati prima di creare il filesystem. È possibile eseguire un controllo completo, ma molto più lento, passando questo parametro due volte, come in mkfs.ext4 -c -c TARGET.
-d DIRECTORY: Copia il contenuto della directory specificata nella radice del nuovo filesystem. Utile se hai bisogno di “pre-popolare” il disco con un insieme predefinito di file.
-F: Pericolo, Will Robinson! Questa opzione forza (force) mke2fs a creare un filesystem, anche se le altre opzioni passate a esso o l’obiettivo sono pericolose o non hanno alcun senso. Se specificato due volte (come in -F -F) può anche essere usato per creare un filesystem su un dispositivo che è montato o in uso: una cosa molto, molto brutta da farsi!
-L VOLUME_LABEL: Imposta l’etichetta del volume su quella specificata in VOLUME_LABEL. Questa etichetta deve contenere al massimo 16 caratteri.
-n: Questa è un’opzione veramente utile che simula la creazione del filesystem e mostra cosa verrebbe fatto se eseguito senza l’opzione n. Considerala come una modalità prova. È utile controllare le cose prima di eseguire effettivamente la commit delle modifiche sul disco.
-q: Modalità silenziosa. mke2fs verrà eseguito normalmente, ma non produrrà alcun output al terminale. Utile quando si esegue mke2fs da uno script.
-U ID: Ciò imposterà l’UUID (Universally Unique Identifier) di una partizione sul valore specificato come ID. Gli UUID sono numeri a 128 bit in notazione esadecimale che servono a identificare in modo univoco una partizione per il sistema operativo. Questo numero è specificato come una stringa di 32 cifre nel formato 8-4-4-4-12, che significa 8 cifre, trattino, 4 cifre, trattino, 4 cifre, trattino, 4 cifre, trattino, 12 cifre, come D249E380 -7719-45A1-813C-35186883987E. Invece di un ID puoi anche specificare parametri come clear per cancellare l’UUID del filesystem, random, per usare un UUID generato casualmente, o time per creare un UUID basato sul tempo.
-V: Modalità dettagliata, stampa molte più informazioni rispetto al normale durante il funzionamento. Utile per scopi di debug.

Creare un Filesystem XFS

XFS è un filesystem ad alte prestazioni originariamente sviluppato da Silicon Graphics nel 1993 per il suo sistema operativo IRIX. A causa delle sue caratteristiche di prestazioni e affidabilità, è comunemente usato per server e altri ambienti che richiedono una larghezza di banda del filesystem elevata (o garantita).

Gli strumenti per la gestione dei filesystem XFS fanno parte del pacchetto xfsprogs. Potrebbe essere necessario installare questo pacchetto manualmente, poiché non è sempre incluso di default. In Red Hat Enterprise Linux 7, XFS è usato come filesystem predefinito.

I filesystem XFS sono divisi in almeno 2 parti, una sezione di log dove viene mantenuto un registro di tutte le operazioni del filesystem (comunemente chiamato Journal) e la data section. La sezione di log può trovarsi all’interno della sezione dati (il comportamento predefinito), o anche su un disco separato del tutto, per migliori prestazioni e affidabilità.

Il comando più semplice per creare un filesystem XFS è mkfs.xfs TARGET, dove TARGET è la partizione in cui vuoi che venga creato il filesystem. Per esempio: mkfs.xfs /dev/sda1.

Come in mke2fs, mkfs.xfs supporta un certo numero di opzioni dalla riga di comando. Ecco alcuni dei più comuni.

-b size=VALUE: Imposta la dimensione del blocco sul filesystem, in byte, a quella specificata in VALUE. Il valore predefinito è 4096 byte (4 KiB), il minimo è 512 e il massimo è 65536 (64 KiB).
-m crc=VALUE: I parametri che iniziano con -m sono opzioni di metadati. Questo abilita (se VALUE è 1) o disabilita (se VALUE è 0) l’uso dei controlli CRC32c per verificare l’integrità di tutti i metadati sul disco. Ciò consente un migliore rilevamento degli errori e ripristino da arresti anomali relativi a problemi hardware, quindi è abilitato per impostazione predefinita. L’impatto sulle prestazioni di questo controllo dovrebbe essere minimo, quindi normalmente non c’è motivo per disabilitarlo.
-m uuid=VALUE: Imposta l’UUID della partizione su quello specificato come VALUE. Ricorda che gli UUID sono numeri di 32 caratteri (128 bit) in base esadecimale, specificati in gruppi di 8, 4, 4, 4 e 12 cifre separati da trattini, come 1E83E3A3-3AE9-4AAC-BF7E-29DFFECD36C0.
-f: Forza la creazione di un filesystem sul dispositivo di destinazione anche se viene rilevato un altro filesystem su di esso.
-l logdev=DEVICE: Questo metterà la sezione di registro del filesystem sul dispositivo specificato, invece che all’interno della sezione dati.
-l size=VALUE: Questo imposterà la dimensione della sezione del registro a quella specificata in VALUE. La dimensione può essere specificata in byte e possono essere usati suffissi come m o g. -l size=10m, per esempio, limiterà la sezione del registro a 10 Megabyte.
-q: Modalità silenziosa. In questa modalità, mkfs.xfs non visualizzerà a schermo i parametri del file system che si sta creando.
-L LABEL: Imposta l’etichetta del filesystem, che può essere lunga al massimo 12 caratteri.
-N: Simile al parametro -n di mke2fs, farà in modo che mkfs.xfs visualizzi tutti i parametri per la creazione del file system, senza crearlo effettivamente.

Creare un Filesystem FAT o VFAT

Il filesystem FAT ha avuto origine da MS-DOS, e negli anni ha ricevuto molte revisioni culminate nel formato FAT32 rilasciato nel 1996 con Windows 95 OSR2.

VFAT è un’estensione del formato FAT16 con supporto per nomi di file lunghi (fino a 255 caratteri). Entrambi i filesystem sono gestiti dalla stessa utility, mkfs.fat. mkfs.vfat è un alias.

Il filesystem FAT ha importanti svantaggi che ne limitano l’uso su dischi di grandi dimensioni. FAT16, per esempio, supporta volumi di massimo 4 GB e una dimensione massima del file di 2 GB. FAT32 aumenta la dimensione del volume fino a 2 PB e la dimensione massima del file a 4 GB. Per questo motivo, i filesystem FAT sono oggi più comunemente usati su piccole unità flash o schede di memoria (fino a 2 GB di dimensione), o dispositivi legacy e sistemi operativi che non supportano filesystem più avanzati.

Il comando più semplice per la creazione di un filesystem FAT è mkfs.fat TARGET, dove TARGET è la partizione in cui vuoi che venga creato il filesystem. Per esempio: mkfs.fat /dev/sdc1.

Come altre utilità, mkfs.fat supporta una serie di opzioni della riga di comando. Di seguito sono riportati i più importanti. Un elenco completo e una descrizione di ogni opzione può essere trovato nel manuale dell’utilità, con il comando man mkfs.fat.

-c: Controlla il dispositivo di destinazione per i blocchi danneggiati prima di creare il filesystem.
-C FILENAME BLOCK_COUNT: Creerà il file specificato in FILENAME e quindi creerà un filesystem FAT al suo interno, creando effettivamente una “immagine disco” vuota, che può essere successivamente scritta su un dispositivo usando un’utilità come dd o montata come dispositivo loop. Quando si utilizza questa opzione, il numero di blocchi nel filesystem (BLOCK_COUNT) deve essere specificato dopo il nome del dispositivo.
-F SIZE: Seleziona la dimensione della FAT (File Allocation Table), tra 12, 16 o 32, ovvero tra FAT12, FAT16 o FAT32. Se non specificato, mkfs.fat selezionerà l’opzione appropriata in base alla dimensione del filesystem.
-n NAME: Imposta l’etichetta del volume, o il nome, per il filesystem. Può essere lunga fino a 11 caratteri e l’impostazione predefinita è nessun nome.
-v: Modalità dettagliata (Verbose mode). Visualizza molte più informazioni del solito, utili per il debug

Note	`mkfs.fat` non può creare un filesystem “avviabile”. Secondo la pagina del manuale “non è così facile come potresti pensare” e non sarà implementato.

Creare un Filesystem exFAT

exFAT è un filesystem creato da Microsoft nel 2006 che affronta uno dei limiti più importanti di FAT32: file e dimensioni del disco. In exFAT, la dimensione massima del file è di 16 exabyte (da 4 GB su FAT32) e la dimensione massima del disco è di 128 petabyte.

Poiché è ben supportato da tutti e tre i principali sistemi operativi (Windows, Linux e Mac OS), è una buona scelta dove è necessaria l’interoperabilità, come su unità flash di grande capacità, schede di memoria e dischi esterni. In effetti, è il filesystem predefinito, come definito dalla SD Association, per le schede di memoria SDXC più grandi di 32 GB.

L’utilità predefinita per la creazione di filesystem exFAT è mkfs.exfat, che è un collegamento a mkexfatfs. Il comando più semplice è mkfs.exfat TARGET, dove TARGET è la partizione in cui vuoi creare il filesystem. Per esempio: mkfs.exfat /dev/sdb2.

Contrariamente alle altre utilità discusse in questa lezione, mkfs.exfat ha pochissime opzioni della riga di comando. Sono:

-i VOL_ID: Imposta l’ID del volume sul valore specificato in VOL_ID. Questo è un numero esadecimale a 32 bit. Se non definito, viene impostato un ID basato sull’ora corrente.
-n NAME: Imposta l’etichetta o il nome del volume. Può contenere fino a 15 caratteri e l’impostazione predefinita è nessun nome.
-p SECTOR: Specifica il primo settore della prima partizione sul disco. Questo è un valore facoltativo e il valore predefinito è zero.
-s SECTORS: Definisce il numero di settori fisici per cluster di allocazione. Deve essere una potenza di due, come 1, 2, 4, 8 e così via.

Conoscere il Filesystem Btrfs

Btrfs (ufficialmente B-Tree Filesystem, pronunciato come “Butter FS”, “Better FS” o anche “Butterfuss”, a tua scelta) è un filesystem in sviluppo dal 2007 realizzato specificamente per Linux da Oracle Corporation e altre società, tra cui Fujitsu, Red Hat, Intel e SUSE.

Ci sono molte caratteristiche che rendono Btrfs attraente sui sistemi moderni in cui sono comuni enormi quantità di spazio di archiviazione. Tra questi ci sono il supporto di più dispositivi (inclusi striping, mirroring e striping + mirroring, come in una configurazione RAID), compressione trasparente, ottimizzazioni SSD, backup incrementali, snapshot, deframmentazione online, controlli offline, supporto per volumi secondari (con quote), deduplicazione e molto altro.

Essendo un filesystem copy-on-write è molto resistente ai crash. Inoltre, Btrfs è semplice da usare e ben supportato da molte distribuzioni Linux. E alcuni di loro, come SUSE, lo usano come filesystem predefinito.

Note

In un filesystem tradizionale, quando si desidera sovrascrivere una parte di un file, i nuovi dati vengono inseriti direttamente sui vecchi dati che sta sostituendo. Su un filesystem copy-on-write i nuovi dati vengono scritti nello spazio libero su disco, quindi i metadati originali del file vengono aggiornati per fare riferimento ai nuovi dati e solo allora i vecchi dati vengono liberati, poiché non sono più necessari. Ciò riduce le possibilità di perdita di dati in caso di arresto anomalo, poiché i vecchi dati vengono eliminati solo dopo che il filesystem è assolutamente sicuro che non sono più necessari e i nuovi dati sono al posto giusto.

Creare un Filesystem Btrfs

L’utilità mkfs.btrfs viene utilizzata per creare un filesystem Btrfs. L’uso del comando senza alcuna opzione crea un file system Btrfs su un determinato dispositivo, in questo modo:

# mkfs.btrfs /dev/sdb1

Tip	Se non hai l’utility `mkfs.btrfs` sul tuo sistema, cerca `btrfs-progs` nel gestore dei pacchetti della tua distribuzione.

Puoi usare -L per impostare un’etichetta (o un nome) per il tuo filesystem. Le etichette Btrfs possono contenere fino a 256 caratteri, ad eccezione di nuove righe:

# mkfs.btrfs /dev/sdb1 -L "New Disk"

Tip	Racchiudi l’etichetta tra virgolette (come sopra) se contiene spazi.

Tieni in considerazione questa cosa peculiare di Btrfs: puoi passare dispositivi multipli al comando mkfs.btrfs. Il passaggio di più di un dispositivo estenderà il filesystem su tutti i dispositivi che è simile a una configurazione RAID o LVM. Per specificare come verranno distribuiti i metadati nell’array di dischi, utilizzare il parametro -m. I parametri validi sono raid0, raid1, raid5, raid6, raid10, single e dup.

Per esempio, per creare un filesystem che si estende su /dev/sdb1 e /dev/sdc1, concatenando le due partizioni in una più grande, usa:

# mkfs.btrfs -d single -m single /dev/sdb /dev/sdc

Warning

I filesystem che si estendono su più partizioni, come sopra, potrebbero sembrare vantaggiosi all’inizio, ma non sono una buona idea dal punto di vista della sicurezza dei dati, poiché un guasto su un singolo disco dell’array significa una perdita certa di dati. Il rischio aumenta con l’aumentare del numero di dischi utilizzati, poiché si hanno anche più possibili punti in cui l’errore possa verificarsi.

Gestire i Subvolume

I subvolume sono come filesystem all’interno di altri filesystem. Pensa a loro come a una directory che può essere montata come (e trattata come) un filesystem separato. I subvolume semplificano l’organizzazione e l’amministrazione del sistema, poiché ognuno di essi può avere quote separate o regole di snapshot.

Note

I sottovolumi non sono partizioni. Una partizione alloca uno spazio fisso su un’unità. Questo può portare a problemi vari, come per esempio una partizione che esaurisce lo spazio quando un’altra invece ne ha molto a disposizione. Non così con i sottovolumi, poiché “condividono” lo spazio libero dal loro filesystem di root e crescono secondo necessità.

Supponiamo di avere un filesystem Btrfs montato su /mnt/disk e di voler creare un sottovolume al suo interno per memorizzare i vostri backup. Chiamiamolo BKP:

# btrfs subvolume create /mnt/disk/BKP

Successivamente elenchiamo i contenuti del filesystem /mnt/disk. Vedrai che abbiamo una nuova directory, che prende il nome dal nostro sottovolume

$ ls -lh /mnt/disk/
total 0
drwxr-xr-x 1 root   root     0 jul 13 17:35 BKP
drwxrwxr-x 1 carol carol 988 jul 13 17:30 Images

Note	Sì, è anche possibile accedere ai sottovolumi come ad una qualsiasi altra directory.

Possiamo verificare che il sottovolume sia attivo, con il comando:

# btrfs subvolume show /mnt/disk/BKP/
	Name: 			BKP
	UUID: 			e90a1afe-69fa-da4f-9764-3384f66fa32e
	Parent UUID: 		-
	Received UUID: 		-
	Creation time: 		2019-07-13 17:35:40 -0300
	Subvolume ID: 		260
	Generation: 		23
	Gen at creation: 	22
	Parent ID: 		5
	Top level ID: 		5
	Flags: 			-
	Snapshot(s):

Puoi montare il sottovolume su /mnt/BKP passando il parametro -t btrfs -o subvol=NAME al comando mount:

# mount -t btrfs -o subvol=BKP /dev/sdb1 /mnt/bkp

Note	Il parametro `-t` specifica il tipo di filesystem da montare.

Lavorare con le Snapshot

Le snapshot sono come volumi secondari, ma precompilate con i contenuti del volume su cui è stata scattata un’istantanea.

In fase di creazione, una snapshot e il volume originale hanno esattamente lo stesso contenuto. Ma da quel momento in poi, divergeranno. Le modifiche apportate al volume originale (come i file aggiunti, rinominati o eliminati) non si rifletteranno sull’istantanea e viceversa.

Tieni presente che una snapshot non duplica i file e inizialmente occupa quasi nessuno spazio su disco. Duplica semplicemente l’albero del filesystem, mentre punta ai dati originali.

Il comando per creare una snapshot è lo stesso usato per creare un sottovolume, basta aggiungere il parametro snapshot dopo btrfs subvolume. Il comando seguente creerà un’istantanea del filesysten Btrfs montato in /mnt/disk in /mnt/disk/snap:

# btrfs subvolume snapshot /mnt/disk /mnt/disk/snap

Ora, immagina di avere i seguenti contenuti in /mnt/disk:

$ ls -lh
total 2,8M
-rw-rw-r-- 1 carol carol 109K jul 10 16:22 Galaxy_Note_10.png
-rw-rw-r-- 1 carol carol 484K jul  5 15:01 geminoid2.jpg
-rw-rw-r-- 1 carol carol 429K jul  5 14:52 geminoid.jpg
-rw-rw-r-- 1 carol carol 467K jul  2 11:48 LG-G8S-ThinQ-Mirror-White.jpg
-rw-rw-r-- 1 carol carol 654K jul  2 11:39 LG-G8S-ThinQ-Range.jpg
-rw-rw-r-- 1 carol carol  94K jul  2 15:43 Mimoji_Comparativo.jpg
-rw-rw-r-- 1 carol carol 112K jul 10 16:20 Note10Plus.jpg
drwx------ 1 carol carol  366 jul 13 17:56 snap
-rw-rw-r-- 1 carol carol 118K jul 11 16:36 Twitter_Down_20190711.jpg
-rw-rw-r-- 1 carol carol 324K jul  2 15:22 Xiaomi_Mimoji.png

Notare la directory snap, contenente l’istantanea. Ora rimuoviamo alcuni file e controlliamo il contenuto della directory:

$ rm LG-G8S-ThinQ-*
$ ls -lh
total 1,7M
-rw-rw-r-- 1 carol carol 109K jul 10 16:22 Galaxy_Note_10.png
-rw-rw-r-- 1 carol carol 484K jul  5 15:01 geminoid2.jpg
-rw-rw-r-- 1 carol carol 429K jul  5 14:52 geminoid.jpg
-rw-rw-r-- 1 carol carol  94K jul  2 15:43 Mimoji_Comparativo.jpg
-rw-rw-r-- 1 carol carol 112K jul 10 16:20 Note10Plus.jpg
drwx------ 1 carol carol  366 jul 13 17:56 snap
-rw-rw-r-- 1 carol carol 118K jul 11 16:36 Twitter_Down_20190711.jpg
-rw-rw-r-- 1 carol carol 324K jul  2 15:22 Xiaomi_Mimoji.png

Tuttavia, se controlli all’interno della directory snap, i file eliminati sono ancora lì e possono essere ripristinati se necessario.

$ ls -lh snap/
total 2,8M
-rw-rw-r-- 1 carol carol 109K jul 10 16:22 Galaxy_Note_10.png
-rw-rw-r-- 1 carol carol 484K jul  5 15:01 geminoid2.jpg
-rw-rw-r-- 1 carol carol 429K jul  5 14:52 geminoid.jpg
-rw-rw-r-- 1 carol carol 467K jul  2 11:48 LG-G8S-ThinQ-Mirror-White.jpg
-rw-rw-r-- 1 carol carol 654K jul  2 11:39 LG-G8S-ThinQ-Range.jpg
-rw-rw-r-- 1 carol carol  94K jul  2 15:43 Mimoji_Comparativo.jpg
-rw-rw-r-- 1 carol carol 112K jul 10 16:20 Note10Plus.jpg
-rw-rw-r-- 1 carol carol 118K jul 11 16:36 Twitter_Down_20190711.jpg
-rw-rw-r-- 1 carol carol 324K jul  2 15:22 Xiaomi_Mimoji.png

È anche possibile creare istantanee di sola lettura. Funzionano esattamente come le istantanee scrivibili, con la differenza che i contenuti dell’istantanea non possono essere modificati, sono “congelati” nel tempo. Aggiungi semplicemente il parametro -r durante la creazione dell’istantanea:

# btrfs subvolume snapshot -r /mnt/disk /mnt/disk/snap

Accenni sulla Compressione

Btrfs supporta la compressione trasparente dei file, con tre diversi algoritmi a disposizione dell’utente. Questo viene fatto automaticamente per file, fintanto che il filesystem è montato con l’opzione -o compress. Gli algoritmi sono abbastanza intelligenti da rilevare file incomprimibili e non tenteranno di comprimerli, risparmiando risorse di sistema. Quindi su una singola directory potresti avere file compressi e non compressi insieme. L’algoritmo di compressione predefinito è ZLIB, ma sono disponibili LZO (più veloce, rapporto di compressione peggiore) o ZSTD (più veloce di ZLIB, compressione comparabile), con più livelli di compressione (vedere la parte corrispettiva sulle opzioni di montaggio).

Gestire le Partizioni con GNU Parted

GNU Parted è un potente editor di partizioni (da cui il nome) che può essere utilizzato per creare, eliminare, spostare, ridimensionare, salvare e copiare partizioni. Può funzionare con dischi GPT e MBR e coprire quasi tutte le esigenze di gestione del disco.

Ci sono molti front-end grafici che rendono molto più facile lavorare con parted, come GParted per ambienti desktop basati su GNOME e KDE Partition Manager per desktop KDE. Tuttavia, dovresti imparare come usare parted dalla riga di comando, poiché in un sistema server non puoi contare sulla disponibilità di un ambiente desktop grafico.

Warning

A differenza di fdisk e gdisk, parted apporta modifiche al disco immediatamente dopo che il comando è stato dato, senza attendere che un altro comando scriva le modifiche sul disco. Quando ti eserciti, è consigliabile farlo su un disco vuoto o di riserva o su un’unità flash, così che non ci sia rischio di perdita di dati in caso di errore.

Il modo più semplice per iniziare a usare parted è digitare parted DEVICE, dove DEVICE è il dispositivo che vuoi gestire (parted /dev/sdb). Il programma avvia un’interfaccia a riga di comando interattiva come fdisk e gdisk con un prompt (parted) per inserire i comandi.

# parted /dev/sdb
GNU Parted 3.2
Using /dev/sdb
Welcome to GNU Parted! Type 'help' to view a list of commands.

(parted)

Warning

Stai attento! Se non specifichi un dispositivo, parted selezionerà automaticamente il disco principale (di solito /dev/sda) con cui lavorare.

Selezionare i Dischi

Per passare a un disco diverso da quello specificato sulla riga di comando puoi utilizzare il comando select, seguito dal nome del dispositivo:

(parted) select /dev/sdb
Using /dev/sdb

Ottenere Informazioni

Il comando print può essere usato per ottenere maggiori informazioni su una specifica partizione o anche su tutti i dispositivi a blocchi (dischi) collegati al tuo sistema.

Per ottenere informazioni sulla partizione attualmente selezionata, digita semplicemente print:

(parted) print
Model: ATA CT120BX500SSD1 (scsi)
Disk /dev/sda: 120GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:

Number  Start   End    Size    Type     File system     Flags
 1      2097kB  116GB  116GB   primary  ext4
 2      116GB   120GB  4295MB  primary  linux-swap(v1)

Puoi ottenere un elenco di tutti i dispositivi a blocchi collegati al tuo sistema usando print devices:

(parted) print devices
/dev/sdb (1999MB)
/dev/sda (120GB)
/dev/sdc (320GB)
/dev/mapper/cryptswap (4294MB)

Per ottenere informazioni su tutti i dispositivi collegati contemporaneamente puoi usare print all. Se desideri sapere quanto spazio libero c’è in ognuno di essi, puoi usare print free:

(parted) print free
Model: ATA CT120BX500SSD1 (scsi)
Disk /dev/sda: 120GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:

Number  Start   End     Size    Type     File system     Flags
        32.3kB  2097kB  2065kB           Free Space
 1      2097kB  116GB   116GB   primary  ext4
        116GB   116GB   512B             Free Space
 2      116GB   120GB   4295MB  primary  linux-swap(v1)
        120GB   120GB   2098kB           Free Space

Creare una Tabella delle Partizioni su un Disco Vuoto

Per creare una tabella delle partizioni su un disco vuoto, utilizzare il comando mklabel, seguito dal tipo di tabella delle partizioni che si desidera utilizzare.

Esistono molti tipi di tabelle delle partizioni supportate, ma i tipi principali di cui dovresti essere a conoscenza sono msdos che viene utilizzato qui per fare riferimento a una tabella delle partizioni MBR e gpt per fare riferimento a una tabella delle partizioni GPT. Per creare una tabella delle partizioni MBR, digita:

(parted) mklabel msdos

E per creare una tabella delle partizioni GPT, il comando è:

(parted) mklabel gpt

Creare una Partizione

Per creare una partizione viene utilizzato il comando mkpart, utilizzando la sintassi mkpart PARTTYPE FSTYPE START END, dove:

PARTTYPE: È il tipo di partizione, che può essere primary, logical o extended nel caso in cui venga utilizzata una tabella delle partizioni MBR.
FSTYPE: Specifica quale file system verrà utilizzato su questa partizione. Nota che parted non creerà il filesystem. Imposta solo un flag sulla partizione che dice al sistema operativo che tipo di dati aspettarsi da esso.
START: Specifica il punto esatto sul dispositivo in cui inizia la partizione. È possibile utilizzare unità diverse per specificare questo punto. 2s può essere utilizzato per fare riferimento al secondo settore del disco, mentre 1m si riferisce all’inizio del primo megabyte del disco. Altre unità comuni sono B (byte) e % (percentuale del disco).
END: Specifica la fine della partizione. Nota che questa non è la dimensione della partizione, ma il punto del disco dove finisce. Per esempio, se specifichi 100m, la partizione terminerà 100 MB dopo l’inizio del disco. È possibile utilizzare le stesse unità del parametro START.

Così, il comando:

(parted) mkpart primary ext4 1m 100m

Crea una partizione primaria di tipo ext4, iniziando dal primo megabyte del disco e terminando dopo il centesimo megabyte.

Eliminare una Partizione

Per rimuovere una partizione, usa il comando rm seguito dal numero della partizione, che puoi visualizzare usando il comando print. Quindi, rm 2 rimuove la seconda partizione sul disco attualmente selezionato.

Recuperare Partizioni

parted può recuperare una partizione cancellata. Considera di avere la seguente struttura delle partizioni:

Number  Start   End     Size    File system  Name     Flags
 1      1049kB  99.6MB  98.6MB  ext4         primary
 2      99.6MB  200MB   100MB   ext4         primary
 3      200MB   300MB   99.6MB  ext4         primary

Per sbaglio, hai rimosso la partizione 2 usando rm 2. Per ripristinarlo, puoi usare il comando rescue, con la sintassi rescue START END, dove START è la posizione approssimativa in cui iniziava la partizione e END la posizione approssimativa in cui finiva.

parted eseguirà la scansione del disco alla ricerca di partizioni e si offrirà di ripristinare quelle trovate. Nell’esempio sopra, la partizione 2 iniziava con 99,6 MB e si concludeva con 200 MB. Quindi puoi usare il seguente comando per ripristinare la partizione:

(parted) rescue 90m 210m
Information: A ext4 primary partition was found at 99.6MB -> 200MB.
Do you want to add it to the partition table?

Yes/No/Cancel? y

Ciò ripristinerà la partizione e il suo contenuto. Notare che rescue può recuperare solo partizioni su cui è installato un filesystem. Le partizioni vuote non vengono rilevate.

Ridimensionamento Partizioni ext2/3/4

parted può essere utilizzato per ridimensionare le partizioni al fine di renderle più grandi o più piccole. Tuttavia, ci sono alcuni avvertimenti:

Durante il ridimensionamento, la partizione deve essere inutilizzata e smontata.
Hai bisogno di spazio libero sufficiente dopo la partizione per ingrandirla fino alla dimensione desiderata.

Il comando è resizepart, seguito dal numero di partizione e dove dovrebbe finire. Per esempio, se hai la seguente tabella delle partizioni:

Number  Start   End     Size    File system  Name     Flags
 1      1049kB  99.6MB  98.6MB  ext4         primary
 2      99.6MB  200MB   100MB   ext4
 3      200MB   300MB   99.6MB  ext4         primary

Cercare di aumentare la partizione 1 usando resizepart attiverebbe un messaggio di errore, perché con la nuova dimensione la partizione 1 si sovrapporrebbe alla partizione 2. Tuttavia la partizione 3 può essere ridimensionata in quanto c’è spazio libero dopo di essa, che può essere verificato con il comando print free:

(parted) print free
Model: Kingston DataTraveler 2.0 (scsi)
Disk /dev/sdb: 1999MB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:

 Number  Start   End     Size    File system  Name     Flags
        17.4kB  1049kB  1031kB  Free Space
 1      1049kB  99.6MB  98.6MB  ext4         primary
 2      99.6MB  200MB   100MB   ext4
 3      200MB   300MB   99.6MB  ext4         primary
        300MB   1999MB  1699MB  Free Space

Quindi puoi usare il seguente comando per ridimensionare la partizione 3 a 350 MB:

(parted) resizepart 3 350m

(parted) print
Model: Kingston DataTraveler 2.0 (scsi)
Disk /dev/sdb: 1999MB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:

Number  Start   End     Size    File system  Name     Flags
 1      1049kB  99.6MB  98.6MB  ext4         primary
 2      99.6MB  200MB   100MB   ext4
 3      200MB   350MB   150MB   ext4         primary

Ricorda che il nuovo punto finale viene specificato contando dall’inizio del disco. Quindi, poiché la partizione 3 è terminata a 300 MB, ora deve terminare a 350 MB.

Ma il ridimensionamento della partizione è solo una parte dell’attività. È inoltre necessario ridimensionare il filesystem che risiede al suo interno. Per i filesystem ext2/3/4 questo viene fatto con il comando resize2fs. Nel caso dell’esempio sopra, la partizione 3 mostra ancora la dimensione “vecchia” quando montata:

$ df -h /dev/sdb3
Filesystem      Size  Used Avail Use% Mounted on
/dev/sdb3        88M  1.6M   80M   2% /media/carol/part3

Per regolare la dimensione, è possibile utilizzare il comando resize2fs DEVICE SIZE, dove DEVICE corrisponde alla partizione che si desidera ridimensionare e SIZE è la nuova dimensione. Se ometti il parametro size, utilizzerà tutto lo spazio disponibile della partizione. Prima di ridimensionare, si consiglia di smontare la partizione.

Nell’esempio seguente:

$ sudo resize2fs /dev/sdb3
resize2fs 1.44.6 (5-Mar-2019)
Resizing the filesystem on /dev/sdb3 to 146212 (1k) blocks.
The filesystem on /dev/sdb3 is now 146212 (1k) blocks long.

$ df -h /dev/sdb3
Filesystem      Size  Used Avail Use% Mounted on
/dev/sdb3       135M  1.6M  123M   2% /media/carol/part3

Per restringere una partizione, il processo deve essere eseguito nell’ordine inverso. Prima ridimensionate il filesystem alla nuova dimensione più piccola, poi ridimensionate la partizione stessa usando parted.

Warning

Prestare attenzione quando si restringono le partizioni. Se sbagli l’ordine delle cose, perderai i dati!

Nel nostro esempio:

# resize2fs /dev/sdb3 88m
resize2fs 1.44.6 (5-Mar-2019)
Resizing the filesystem on /dev/sdb3 to 90112 (1k) blocks.
The filesystem on /dev/sdb3 is now 90112 (1k) blocks long.

# parted /dev/sdb3
(parted) resizepart 3 300m
Warning: Shrinking a partition can cause data loss, are you sure
you want to continue?

Yes/No? y

(parted) print
Model: Kingston DataTraveler 2.0 (scsi)
Disk /dev/sdb: 1999MB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:

Number  Start   End     Size    File system  Name     Flags
 1      1049kB  99.6MB  98.6MB  ext4         primary
 2      99.6MB  200MB   100MB   ext4
 3      200MB   300MB   99.7MB  ext4         primary

Tip	Invece di specificare una nuova dimensione, puoi usare il parametro `-M` di `resize2fs` per regolare la dimensione del filesystem in modo che sia abbastanza grande per i file su di esso.

Creare Partizioni di Swap

Su Linux, il sistema può scambiare le pagine di memoria dalla RAM al disco secondo necessità, memorizzandole in uno spazio separato solitamente implementato come partizione separata su un disco, chiamata partizione di swap o semplicemente swap. Questa partizione deve essere di un tipo specifico e configurata con un’utilità appropriata (mkswap) prima di poter essere utilizzata.

Per creare la partizione di swap usando fdisk o gdisk, procedi come se stessi creando una partizione normale, come spiegato prima. L’unica differenza è che dovrai cambiare il tipo di partizione in Linux swap.

Su fdisk usa il comando t. Seleziona la partizione che desideri utilizzare e cambia il suo tipo in 82. Scrivi le modifiche su disco ed esci con w.
Su gdisk il comando per cambiare il tipo di partizione è sempre t, ma il codice è 8200. Scrivi le modifiche su disco ed esci con w.

Se stai usando parted, la partizione dovrebbe essere identificata come partizione di swap durante la creazione, usa semplicemente linux-swap come tipo di filesystem. Per esempio, il comando per creare una partizione di swap da 500 MB, a partire da 300 MB su un disco è:

(parted) mkpart primary linux-swap 301m 800m

Una volta che la partizione è stata creata e correttamente identificata, usa semplicemente mkswap seguito dal dispositivo che rappresenta la partizione che vuoi usare, come per esempio:

# mkswap /dev/sda2

Per abilitare lo swap su questa partizione, usa swapon seguito dal nome del dispositivo:

# swapon /dev/sda2

Allo stesso modo, swapoff, seguito dal nome del dispositivo, disabiliterà lo swap su quel dispositivo.

Linux supporta anche l’uso di file di swap invece delle partizioni. Basta creare un file vuoto della dimensione che si desidera utilizzando dd e quindi utilizzare mkswap e swapon con questo file come destinazione.

I seguenti comandi creeranno un file da 1 GB chiamato myswap nella directory corrente, riempito di “zeri”, quindi lo configureranno e lo abiliteranno come file di swap.

Crea il file di swap:

$ dd if=/dev/zero of=myswap bs=1M count=1024
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 7.49254 s, 143 MB/s

if= è il file di input, l’origine dei dati che verranno scritti nel file. In questo caso è il dispositivo /dev/zero, che fornisce tanti caratteri NULL quanti sono richiesti. of = è il file di output, il file che verrà creato. bs= è la dimensione dei blocchi di dati, qui specificata in Megabyte, e count= è la quantità di blocchi da scrivere nell’output. 1024 blocchi da 1 MB ciascuno equivalgono a 1 GB.

# mkswap myswap
Setting up swapspace version 1, size = 1024 MiB (1073737728 bytes)
no label, UUID=49c53bc4-c4b1-4a8b-a613-8f42cb275b2b

# swapon myswap

Utilizzando i comandi precedenti, questo file di swap verrà utilizzato solo durante la sessione di sistema corrente. Se la macchina viene riavviata, il file sarà ancora disponibile, ma non verrà caricato automaticamente. Puoi automatizzarlo aggiungendo il nuovo file di swap a /etc/fstab, di cui parleremo in una lezione successiva.

Tip	Sia `mkswap` che `swapon` obietteranno se il tuo file di swap ha permessi non sicuri. Il security mode di autorizzazione file consigliato è `0600`. Il proprietario e il gruppo dovrebbero essere `root`.

Esercizi Guidati

Quale schema di partizionamento dovrebbe essere utilizzato per partizionare un disco rigido da 3 TB in tre partizioni da 1 GB? Perché?
Su gdisk, come possiamo sapere quanto spazio è disponibile sul disco?
Quale è il comando per creare un filesystem ext3, controllando prima la presenza di blocchi danneggiati, con l’etichetta MyDisk e un UUID casuale, sul dispositivo /dev/sdc1?
Utilizzando parted, qual è il comando per creare una partizione ext4 da 300 MB, a partire da 500 MB sul disco?
Immagina di avere 2 partizioni, una su /dev/sda1 e l’altra su /dev/sda2, entrambe di 20 GB. Come puoi usarli su un singolo filesystem Btrfs, in modo tale che il contenuto di una partizione venga automaticamente duplicato sull’altra, come su una configurazione RAID1? Quanto sarà grande il filesystem?

Esercizi Esplorativi

Considera un disco da 2 GB con una tabella delle partizioni MBR e il seguente layout:

Disk /dev/sdb: 1.9 GiB, 1998631936 bytes, 3903578 sectors
Disk model: DataTraveler 2.0
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x31a83a48

Device     Boot   Start     End Sectors  Size Id Type
/dev/sdb1          2048 1050623 1048576  512M 83 Linux
/dev/sdb3       2099200 3147775 1048576  512M 83 Linux

Puoi creare una partizione da 600 MB su di essa? Perché?

Su un disco in /dev/sdc, abbiamo una prima partizione di 1 GB, contenente circa 256 MB di file. Usando parted, come puoi ridurlo in modo che abbia spazio appena sufficiente per i file?
Immagina di avere un disco in /dev/sdb e di voler creare una partizione di swap da 1 GB all’inizio. Quindi, usando parted, crei la partizione con mkpart primary linux-swap 0 1024M. Quindi, abiliti lo swap su questa partizione con swapon /dev/sdb1, ma ottieni il seguente messaggio di errore:

swapon: /dev/sdb1: read swap header failed

Che cosa non ha funzionato?
Nel corso di questa lezione, stavi provando alcuni comandi in parted ma, per errore, hai cancellato la terza partizione sul tuo disco rigido. Sai che era dopo una partizione UEFI da 250 MB e una partizione di swap da 4 GB e aveva una dimensione di 10 GB. Quale comando puoi usare per ripristinarlo?
Immagina di avere una partizione inutilizzata da 4 GB su /dev/sda3. Usando fdisk, quale sarebbe la sequenza di operazioni per trasformarlo in una partizione di swap attiva?

Sommario

In questa lezione abbiamo imparato:

Come creare una tabella delle partizioni MBR su un disco con fdisk e come usarlo per creare ed eliminare partizioni.
Come creare una tabella delle partizioni MBR su un disco con gdisk e come usarlo per creare ed eliminare partizioni.
Come creare partizioni ext2, ext3, ext4, XFS, VFAT ed exFAT.
Come utilizzare parted per creare, eliminare e ripristinare partizioni su entrambi i dischi MBR e GPT.
Come utilizzare il ridimensionamento delle partizioni ext2, ext3, ext4 e Brts.
Come creare, impostare e attivare partizioni e file di swap.

In questa lezione sono stati discussi i seguenti comandi:

fdisk
gdisk
mkfs.ext2, mkfs.ext3, mkfs.ext4, mkfs.xfs, mkfs.vfat and mkfs.exfat
parted
btrfs
mkswap
swapon e swapoff

Risposte agli Esercizi Guidati

Quale schema di partizionamento dovrebbe essere utilizzato per partizionare un disco rigido da 3 TB in tre partizioni da 1 GB? Perché?

GPT, poiché MBR supporta al massimo dischi rigidi da 2 TB.
Su gdisk, come possiamo sapere quanto spazio è disponibile sul disco?

Usa p (print). Lo spazio libero totale verrà visualizzato come ultima riga di informazioni prima della tabella delle partizioni stessa.
Quale è il comando per creare un filesystem ext3, controllando prima la presenza di blocchi danneggiati, con l’etichetta MyDisk e un UUID casuale, sul dispositivo /dev/sdc1?

Il comando sarebbe mkfs.ext3 -c -L MyDisk -U random /dev/sdc1. In alternativa, si può usare anche mke2fs -t ext3 al posto di mkfs.ext3
Utilizzando parted, qual è il comando per creare una partizione ext4 da 300 MB, a partire da 500 MB sul disco?

Usa mkpart primary ext4 500m 800m. Ricorda che dovrai creare il filesystem usando mkfs.ext4, poiché parted non lo fa.
Immagina di avere 2 partizioni, una su /dev/sda1 e l’altra su /dev/sda2, entrambe di 20 GB. Come puoi usarli su un singolo filesystem Btrfs, in modo tale che il contenuto di una partizione venga automaticamente duplicato sull’altra, come su una configurazione RAID1? Quanto sarà grande il filesystem?

Usa mkfs.btrfs /dev/sda1 /dev/sdb1 -m raid1. Il filesystem risultante avrà una dimensione di 20 GB, poiché una partizione funge semplicemente da duplicato dell’altra.

Risposte agli Esercizi Esplorativi

Considera un disco da 2 GB con una tabella delle partizioni MBR e il seguente layout:
```
Disk /dev/sdb: 1.9 GiB, 1998631936 bytes, 3903578 sectors
Disk model: DataTraveler 2.0
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x31a83a48

Device     Boot   Start     End Sectors  Size Id Type
/dev/sdb1          2048 1050623 1048576  512M 83 Linux
/dev/sdb3       2099200 3147775 1048576  512M 83 Linux
```
Puoi creare una partizione da 600 MB su di essa? Perché?

Non puoi, perché non c’è abbastanza spazio contiguo. Il primo indizio che qualcosa “non va” è l’elenco dei dispositivi: hai /dev/sdb1 e /dev/sdb3, ma non /dev/sdb2. Quindi, manca qualcosa.

Devi guardare dove finisce una partizione e inizia l’altra. La partizione uno termina al settore 1050623 e la partizione 2 inizia al 2099200. Questo è un vuoto di 1048577 settori. A 512 byte per settore, corrisponde a 536.871.424 byte. Se lo dividi per 1024 ottieni 524,288 kilobyte. Dividi di nuovo per 1024 e ottieni … 512 MB. Questa è la dimensione del “vuoto”.

Se il disco è da 2 GB, allora abbiamo al massimo altri 512 MB dopo la partizione 3. Anche se abbiamo in totale circa 1 GB non allocato, il blocco contiguo più grande è 512 MB. Quindi, non c’è spazio per una partizione da 600 MB.
Su un disco in /dev/sdc, abbiamo una prima partizione di 1 GB, contenente circa 256 MB di file. Usando parted, come puoi ridurlo in modo che abbia spazio appena sufficiente per i file?

Questa è un’operazione in più parti. Per prima cosa devi ridurre il filesystem usando resize2fs. Invece di specificare direttamente la nuova dimensione, puoi usare il parametro -M in modo che sia semplicemente “abbastanza grande”. Quindi: resize2fs -M / dev / sdc1.

Quindi, ridimensiona la partizione stessa con parted usando resizepart. Poiché è la prima partizione, possiamo supporre che inizi da zero e termini a 241 MB. Quindi il comando è resizepart 1 241M.
Immagina di avere un disco in /dev/sdb e di voler creare una partizione di swap da 1 GB all’inizio. Quindi, usando parted, crei la partizione con mkpart primary linux-swap 0 1024M. Quindi, abiliti lo swap su questa partizione con swapon /dev/sdb1, ma ottieni il seguente messaggio di errore:

swapon: /dev/sdb1: read swap header failed

Che cosa non ha funzionato?

Hai creato una partizione del tipo corretto (linux-swap), ma ricorda che mkpart non crea un filesystem. Hai dimenticato di impostare la partizione come spazio di swap con mkswap prima di usarla.
Nel corso di questa lezione, stavi provando alcuni comandi in parted ma, per errore, hai cancellato la terza partizione sul tuo disco rigido. Sai che era dopo una partizione UEFI da 250 MB e una partizione di swap da 4 GB e aveva una dimensione di 10 GB. Quale comando puoi usare per ripristinarlo?

Niente panico, hai tutte le informazioni necessarie per ripristinare la partizione, usa semplicemente rescue e fai i conti. Avevi 250 MB + 4.096 MB (4 * 1024) prima, quindi il punto di inizio dovrebbe essere di circa 4346 MB. Più 10,240 MB (10 * 1024) di dimensione, dovrebbe terminare a 14,586 MB. Quindi, rescue 4346m 14586m dovrebbe andare. Potrebbe essere necessario dare un po' di margine di flessibilità per il salvataggio, iniziando un po' prima e terminando un po' dopo, a seconda della geometria del disco.
Immagina di avere una partizione inutilizzata da 4 GB su /dev/sda3. Usando fdisk, quale sarebbe la sequenza di operazioni per trasformarlo in una partizione di swap attiva?

Per prima cosa, cambia il tipo di partizione in “Linux Swap” (82), scrivi le modifiche sul disco ed esci. Quindi, usa mkswap per impostare la partizione come area di swap. Quindi, usa swapon per attivarla.