Come estendere partizioni logiche ed estese con fdisk

Con fdisk non si “allarga” una partizione logica in modo magico: si lavora prima sulla partizione estesa che la contiene, poi si verifica che lo spazio libero sia davvero contiguo, e solo dopo si interviene sul filesystem. È il punto che spesso crea confusione: la partizione estesa non contiene dati utente, ma fa da contenitore alle partizioni logiche. Se il contenitore resta piccolo, la logica non cresce nemmeno se il disco ha spazio libero.

Il caso tipico è un disco con schema MBR/legacy, dove trovi una partizione estesa, ad esempio /dev/sda2, e dentro una o più partizioni logiche come /dev/sda5. Se hai esaurito spazio su /dev/sda5, devi prima capire se lo spazio non allocato è subito dopo la logica oppure dopo la fine della partizione estesa. Se non è contiguo, fdisk da solo non risolve: serve ripianificare il layout o usare strumenti di migrazione come parted, gparted o un clone su nuovo disco.

Quando fdisk è lo strumento giusto

Usa fdisk quando il disco è in MBR e devi modificare partizioni primarie, estese o logiche con un intervento controllato. È adatto se vuoi mantenere la stessa macchina, lo stesso disco e lo stesso layout, aggiungendo spazio già disponibile in coda al disco. Non è invece lo strumento ideale per dischi GPT moderni: lì la procedura cambia e, se il problema nasce da un disco GPT, forzare il ragionamento MBR è un errore di categoria.

La regola pratica è semplice: prima il contenitore, poi il contenuto. Se la partizione estesa è troppo corta, i logici non possono espandersi oltre il suo limite. Se la logica è già all’interno di uno spazio libero contiguo, puoi ridimensionare la partizione logica e poi il filesystem. In molti ambienti Linux vecchi o virtual machine migrate da anni, questa è ancora una situazione comune.

Verificare la geometria prima di toccare nulla

Prima di qualsiasi modifica, fotografa lo stato del disco. Non basta vedere “c’è spazio libero”: serve sapere dove si trova. I comandi minimi sono questi:

lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINTS,PARTTYPE,PARTLABEL
fdisk -l /dev/sda
parted -s /dev/sda unit s print free

Con lsblk controlli la relazione tra disco, partizioni e mountpoint. Con fdisk -l vedi il tipo di tabella partizioni e gli start/end delle partizioni. Con parted -s ... print free ottieni una vista utile degli spazi liberi, anche se poi l’intervento lo farai con fdisk. Se il disco è /dev/sda e la partizione estesa è /dev/sda2, cerca la fine della estesa e confrontala con la fine della logica da espandere.

Il punto critico è la contiguità. Se la partizione logica /dev/sda5 termina prima della fine della partizione estesa e lo spazio libero è subito dopo /dev/sda5, il caso è buono. Se invece tra la logica e lo spazio libero c’è un’altra partizione, o se la estesa finisce prima dello spazio libero, non puoi semplicemente aumentare i numeri in fdisk e aspettarti che tutto funzioni.

Ridimensionare la partizione estesa con fdisk

La partizione estesa si modifica come una normale partizione MBR, ma il suo ruolo è solo di contenitore. In pratica, la cancelli e la ricrei con gli stessi parametri iniziali e un end più avanti, facendo attenzione a non cambiare lo start. È il dettaglio decisivo: lo start deve restare identico, altrimenti sposti l’intero contenitore e perdi l’allineamento con le partizioni logiche interne.

Flusso operativo tipico:

1. Annota start e end della partizione estesa e della logica da espandere.
2. Verifica che ci sia spazio libero contiguo dopo la estesa.
3. Avvia fdisk /dev/sda.
4. Stampa la tabella con p e ricontrolla i numeri.
5. Elimina la partizione estesa con d e selezione del numero corretto.
6. Ricreala con n, scegliendo extended, stesso start e nuovo end più ampio.
7. Scrivi le modifiche con w.

Un esempio operativo, da adattare ai tuoi numeri reali, può essere questo:

fdisk /dev/sda

Command (m for help): p

Device     Boot   Start      End  Sectors  Size Id Type
/dev/sda1  *       2048  1050623 1048576  512M 83 Linux
/dev/sda2       1052670 41943039 40890370 19.5G  5 Extended
/dev/sda5       1052672 20973567 19920896  9.5G 83 Linux

Se il disco è stato esteso e ora c’è spazio libero fino a fine dispositivo, puoi eliminare e ricreare /dev/sda2 con lo stesso start 1052670 e un end più avanti, ad esempio il nuovo ultimo settore disponibile. Dopo la scrittura, il kernel potrebbe non rileggerla subito: in quel caso può servire un reboot controllato, soprattutto se la partizione è in uso. Su sistemi di produzione è meglio pianificare questa fase come change con finestra di manutenzione.

Espandere la partizione logica

Una volta che il contenitore esteso è abbastanza grande, puoi lavorare sulla logica. Anche qui la logica è la stessa: cancelli e ricrei la partizione mantenendo lo stesso start, ma con end più ampio. La tabella partizioni conserva il riferimento ai settori, quindi se lo start cambia rompi il filesystem e i dati diventano irrecuperabili senza interventi forensi.

Procedura essenziale:

1. Assicurati che la partizione non sia montata o che il filesystem supporti il resize online.
2. In fdisk, elimina la partizione logica da espandere.
3. Ricreala come partizione logica con lo stesso start e nuovo end.
4. Scrivi la tabella e fai rileggere le partizioni al kernel.
5. Espandi il filesystem sopra la nuova dimensione della partizione.

Se il filesystem è ext4, la crescita è in genere semplice dopo il resize della partizione. Se è XFS, non si riduce, ma si allarga online solo se il mountpoint è attivo. Se è ext3/ext4, il comando di crescita è resize2fs; per XFS è xfs_growfs. La partizione cresce con fdisk, il filesystem con l’utility corretta: non confondere i due livelli.

# esempio ext4
resize2fs /dev/sda5

# esempio XFS
xfs_growfs /mountpoint

Per un filesystem ext4 non montato, spesso è utile prima verificare l’integrità con e2fsck -f /dev/sda5. Non è un passaggio estetico: se il filesystem ha inconsistenze pregresse, allargarlo sopra una base sporca peggiora solo il recupero. Su sistemi in produzione, fai attenzione a non lanciare controlli distruttivi o prolungati senza finestra e senza backup recente.

Perché la partizione estesa va trattata con cautela

La partizione estesa è un vecchio meccanismo, ma è ancora presente in molti server e ambienti virtualizzati. Il rischio non è teorico: quando la elimini e la ricrei, stai riscrivendo la struttura che contiene i riferimenti alle partizioni logiche. Se sbagli il numero, lo start o l’ordine, il sistema non trova più i logici oppure li vede con geometria errata. È per questo che conviene salvare prima l’output di fdisk -l e, se possibile, esportare anche il layout con sfdisk --dump /dev/sda.

sfdisk --dump /dev/sda > /root/sda-partitions.backup

Questo backup testuale non sostituisce un vero backup dei dati, ma aiuta molto nel ripristino del layout se devi ricreare la tabella. In caso di errore, il rollback più rapido è spesso reinstallare la vecchia tabella partizioni a partire dai dati annotati o dal dump, poi riavviare e verificare che i device tornino visibili come prima. Se il disco ospita dati critici, il passaggio va trattato come operazione a blast radius alto.

Quando il resize fallisce

Ci sono tre scenari frequenti in cui la procedura non va avanti. Primo: lo spazio libero non è contiguo alla partizione estesa o logica. Secondo: il kernel non rilegge la tabella perché la partizione è occupata in modo non compatibile con il resize online. Terzo: il filesystem non supporta l’espansione live o richiede un tool diverso. In questi casi il sintomo non è “fdisk non funziona”, ma “il layout non consente quel tipo di modifica”.

Per falsificare rapidamente le ipotesi, usa questi controlli:

1. Contiguità: parted -s /dev/sda unit s print free e confronto con start/end.
2. Visibilità kernel: partprobe /dev/sda oppure blockdev --rereadpt /dev/sda, poi lsblk.
3. Filesystem: df -T e blkid /dev/sda5 per confermare tipo e mountpoint.

Se il kernel non aggiorna la tabella, non forzare a caso: valuta un reboot pianificato. Se il filesystem è in uso e non supporta il resize online, il change va spostato in manutenzione. Se non c’è spazio contiguo, la soluzione strutturale è migrare i dati su una nuova partizione o su un nuovo disco con layout corretto.

Sequenza operativa completa su un caso reale

Supponiamo di avere /dev/sda2 come estesa e /dev/sda5 come root filesystem ext4. Il disco è stato aumentato da virtualizzazione o da nuovo storage, e ora c’è spazio libero in coda. La sequenza prudente è questa:

1. Salva il layout attuale: fdisk -l /dev/sda e sfdisk --dump /dev/sda > /root/sda.dump.
2. Controlla il tipo filesystem: df -T / e blkid /dev/sda5.
3. Verifica che lo spazio libero sia in coda e contiguo alla estesa.
4. Apri fdisk /dev/sda, elimina e ricrea la estesa con stesso start.
5. Elimina e ricrea la logica con stesso start e nuovo end, sempre dentro la estesa.
6. Rileggi la tabella con partprobe /dev/sda o riavvia se necessario.
7. Esegui resize2fs /dev/sda5 per ext4 oppure il comando adatto al filesystem.
8. Verifica con df -h e con i log di sistema se ci sono warning sul device.

Questo approccio minimizza l’errore umano perché separa chiaramente tabella partizioni e filesystem. La tentazione di saltare direttamente al resize del filesystem è forte, ma sbagliata: se la partizione sottostante non è stata allargata, il filesystem non ha dove crescere. Al contrario, se allarghi la partizione ma dimentichi il filesystem, lo spazio resta inutilizzato e il problema sembra risolto solo in apparenza.

Controlli finali e criteri di successo

A operazione conclusa, il criterio minimo di successo è semplice: il device deve mostrare la nuova dimensione, il filesystem deve riportare spazio aggiuntivo e non devono comparire errori nel kernel log. Verifica con:

lsblk -o NAME,SIZE,TYPE,MOUNTPOINTS /dev/sda
fdisk -l /dev/sda
journalctl -k -n 50 | tail -n 20

df -hT /

Se tutto è coerente, conserva il dump della tabella partizioni aggiornato e annota data, finestra di cambio e motivo dell’intervento. In ambienti con audit o compliance, questa documentazione vale quasi quanto il comando eseguito. Se invece il resize ha richiesto reboot, verifica al riavvio che il mountpoint sia tornato online e che il filesystem sia integro.

La regola finale è sempre la stessa: non fidarti della sola modifica della tabella. La crescita reale si vede solo quando il kernel riconosce la nuova geometria e il filesystem la assorbe. Se uno dei due passaggi manca, hai solo spostato il problema più avanti.