Premessa.

Questa guida è rivolta a quanti utilizzano la chiavetta USB come media di installazione per altri sistemi operativi, e quando tentano di recuperarla si ritrovano con una capacità del dispositivo ridotta e con partizioni che, in qualche modo, non vengono “viste” da nessun programma di partizione.

Esempio: ho utilizzato una chiavetta USB da 4.0GB per provare Haiku OS Alpha 3, e quando ho deciso di formattarla per riutilizzarla mi sono ritrovato con una capacità ridotta a circa 3.7GB, e nessun programma di partizione era in grado di mostrare quei 300MB mancanti.

Come fare?

Per praticità sarebbe meglio acquisire i privilegi di root con

sudo su -

Poichè tutti i comandi che andremo ad utilizzare richiederebbero l’anteposizione di “sudo”. Ovviamente, prima di procedere con qualsiasi operazione, consiglio caldamente di leggere fino in fondo la guida e di valutare per bene ogni singola operazione. In particolar modo, bisogna identificare con estrema sicurezza qual’è il nome del dispositivo USB su cui andremo a mettere le mani alla fine: il rischio, in caso di errore, è quello di andare a scrivere nella Partition Table di un qualsiasi altro disco (persino quello del Sistema Operativo), andando di fatto a cancellare o rendere inservibili i dati che contiene.

Il primo passo è, dunque, quello di acquisire correttamente il nome del dispositivo in questione. Per esserne assolutamente certi, rimuovere la chiavetta e reinserirla, e subito dopo digitare:

dmesg

L’output di questo comando è piuttosto verboso, ma la parte che ci interessa risiede (in questo caso, avendo appena attaccato la nostra chiavetta USB) nelle ultime righe:

[44644.758945] usb 2-6: new high speed USB device number 8 using ehci_hcd
[44644.885119] scsi10 : usb-storage 2-6:1.0
[44645.883580] scsi 10:0:0:0: Direct-Access     TDKMedia Trans-It Drive   PMAP PQ: 0 ANSI: 0 CCS
[44645.883864] sd 10:0:0:0: Attached scsi generic sg2 type 0
[44646.280943] sd 10:0:0:0: [sdb] 7815168 512-byte logical blocks: (4.00 GB/3.72 GiB)
[44646.281569] sd 10:0:0:0: [sdb] Write Protect is off
[44646.281572] sd 10:0:0:0: [sdb] Mode Sense: 23 00 00 00
[44646.282183] sd 10:0:0:0: [sdb] No Caching mode page present
[44646.282186] sd 10:0:0:0: [sdb] Assuming drive cache: write through
[44646.285185] sd 10:0:0:0: [sdb] No Caching mode page present
[44646.285190] sd 10:0:0:0: [sdb] Assuming drive cache: write through
[44646.286069]  sdb:
[44646.288698] sd 10:0:0:0: [sdb] No Caching mode page present
[44646.288703] sd 10:0:0:0: [sdb] Assuming drive cache: write through
[44646.288706] sd 10:0:0:0: [sdb] Attached SCSI removable disk

Questo blocco ci informa che il Kernel ha rilevato la presenza del “new high speed USB device”, ovvero la nostra chiavetta. Nel mio caso, la terza riga riporta marca e modello del dispositivo, altro segno che ci fa essere sicuri, e dalla quarta riga in poi in parentesi quadra rileviamo il nome del dispositivo assegnato da UDEV, ovvero “sdb”. Ciò vuol dire che la nostra chiavetta è inequivocabilmente il disco raggiungibile all’inode

/dev/sdb

Prendiamo dunque nota, magari scrivendo questo dato su un foglio di carta, e andiamo avanti. Ribadisco, da questo punto in poi è bene leggere interamente la guida prima di iniziare ad operare, in modo da aver ben chiaro cosa andremo a fare in seguito.

Assicuriamoci di avere a disposizione lo spazio necessario (nell’esempio 4.0GB) e posizioniamoci in una directory sicura, che non contenga files cruciali. Quindi, creiamo un file vuoto. Io, ad esempio, ho scelto /tmp:

cd /tmp/
touch new-virtual-disk.img

Il passo successivo, è riempire questo file in modo tale da raggiungere una dimensione desiderata, e che corrisponda esattamente alle dimensioni della chiavetta USB che andremo a recuperare:

dd if=/dev/zero of=/tmp/new-virtual-disk.img bs=1M count=4096

Spiegazione:

if=/dev/zero : riempiamo questo file con una sequenza di zero, come se fosse un disco vuoto.

bs=1M : non ha importanza per ora il BlockSize. Ho scelto 1MB (1024*1024 Bytes) per facilità di calcolo

count=4096 : ovvero 1MB * 4096 = 4GB

Questa operazione richiederà diversi minuti (specie in presenza di dischi più lenti) e produrrà output solo ad operazione ultimata. Attendere con prazienza l’output con le statistiche:

4096+0 records in
4096+0 records out
4294967296 bytes (4.3 GB) copied, 54.9492 s, 78.2 MB/s

Una volta creato il file, possiamo utilizzarlo come se fosse un hard disk. Ovvero, possiamo crearci una partizione, formattarla e montarla (attraverso il loop device). Possiamo usare fdisk, poichè non sono certo che altri programmi grafici riescano a “trattare” il file immagine come se fosse un disco. Una volta lanciato:

fdisk /tmp/new-virtual-disk.img

Digitare i seguenti comandi:

n (per creare una nuova partizione)

p (partizione primaria)

1 (numero di partizione)

start ed ending block li lasciamo di default poichè la partizione dovrà occupare l’intero “disco”.

E’ interessante notare che il settore di partenza è il 2048 e non l’1. Questo perchè i primi settori 2Mb (ovvero, 512Bytes * 2048 = 1M) sono riservati al Master Boot Record ed al suo settore di Backup, perciò non utilizzabili.

Prima di terminare, assegnamo alla partizione il flag identificativo del tipo di partizione (di default viene creata con 0×83, Linux):

digitare t (per assegnare il tipo)

digitare L (per una lista di tipi)

digitare 7 (HPFS+ / NTFS)

Infine, digitare “p” per visualizzare la partizione appena creata:

Disk new-virtual-disk.img: 4294 MB, 4294967296 bytes
255 heads, 63 sectors/track, 522 cylinders, total 8388608 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x2fe6be7b

               Device Boot      Start         End      Blocks   Id  System
new-virtual-disk.img1            2048     8388607     4193280    7  HPFS/NTFS/exFAT

Command (m for help):

Per applicare i cambiamenti appena effettuati ed uscire da fdisk, digitare “w”.

A questo punto possiamo creare il filesystem (formattare) nel nostro “disco” virtuale. Qualora non l’aveste, dovreste installare ‘dosfstools’, o qualunque sia il nome che la vostra distribuzione usa. Ciò che conta è avere a disposizione il comando mkfs.vfat, qualora abbiate intenzione di usare il filesystem FAT32.

Digitiamo dunque:

mkfs.vfat -n “nome-del-volume” new-virtual-disk.img

A questo punto montiamo il “disco” virtuale e, per prova e verifica successiva, ci scriveremo qualcosa dentro:

mkdir /mnt/new-disk
mount -t auto -orw,loop /tmp/new-virtual-disk.img /mnt/new-disk
cd /mnt/new-disk
mkdir test-001
touch test-002
ls -al

total 8
drwxr-xr-x 3 root root 4096 Aug 30 10:07 .
drwxr-xr-x 8 root root   76 Aug 30 10:06 ..
drwxr-xr-x 2 root root 4096 Aug 30 10:07 test-001
-rwxr-xr-x 1 root root    0 Aug 30 10:07 test-002

cd /tmp/
umount /mnt/new-disk
rm -rf /mnt/new-disk

Per sicurezza, è bene smontare il filesystem appena creato. A questo punto, siamo giunti alla fine: prendete in mano la nota presa precedentemente, ovvero identificate correttamente il vostro dispositivo da recuperare. Attenzione, io utilizzerò /dev/sdb come esempio, non copiate/incollate il comando esattamente così e pensatici tre volte prima di premere invio.

Il comando da utilizzare è molto simile a quello precedente, ma questa volta if= sarà il nuovo “disco” virtuale appena creato, mentre of= sarà il dispositivo. Ancora una volta, ATTENZIONE.

dd if=/tmp/new-virtual-disk.img of=/dev/sdb bs=512

Come noterete, non ho utilizzato il “count”, ed il parametro BS questa volta è pari a 512 Bytes e non 1M. Questo per conformità ai Bytes-per-settore del filesystem FAT32 (di default sono 512). Non solo, anche l’output di fdisk (vedi sopra) ci informa che i bytes per settore per un “Optimal I/O” sono 512.

Prima di procedere con il comando dd, controlliamo attentamente che il nostro dispositivo non sia montato, e nel caso smontiamolo; ricordiamoci di essere root, e di essere cauti, e soprattutto teniamo bene a mente qual’è il dispositivo su cui andremo ad operare (nell’esempio è /dev/sdb, ma potrebbe differire nel vostro caso!):

mount | grep /dev/sdb
umount /dev/sdb1

Lanciamo dunque il comando dd come sotto, e anche (e soprattutto) in questo caso, attendere con estrema pazienza l’output del comando dd: pur avendo un dispositivo USB 2.0, l’operazione può richiedere anche una mezz’oretta. L’output dovrebbe essere molto simile a questo:

7815169+0 records in
7815168+0 records out
4001366016 bytes (4.0 GB) copied, 2091.16 s, 1.9 MB/s

Terminata l’operazione, non ci resta che rimuovere la chiavetta, re-inserirla e controllare che sia accessibile, che contenga la directory ed il file creati in precedenza nel new-virtual-disk.img, e che sia scrivibile. Se usate UDEV (e anche se non lo doveste sapere, lo usate…) e siete in un ambiente grafico, non è necessario montare la chiavetta e, tantomeno, operare in console: dovrebbe comparirvi il nuovo dispositivo (nel mio esempio, gli ho dato il nome “trans-it”) nel file manager. Ma se volete continuare ad usare la console:

mount | grep /dev/sdb
/dev/sdb on /media/trans-it type vfat (rw,nosuid,nodev,uhelper=udisks,uid=1000,gid=1000,shortname=mixed,dmask=0077,utf8=1,showexec,flush)
cd /media/trans-it
ls -la
total 8
drwx------ 3 harlock harlock 4096 Jan  1  1970 .
drwxr-xr-x 8 root    root      85 Aug 30 10:55 ..
drwx------ 2 harlock harlock 4096 Aug 30 10:07 test-001
-rw-r--r-- 1 harlock harlock    0 Aug 30 10:07 test-002
touch test-003
ls -la
total 8
drwx------ 3 harlock harlock 4096 Aug 30 10:56 .
drwxr-xr-x 8 root    root      85 Aug 30 10:55 ..
drwx------ 2 harlock harlock 4096 Aug 30 10:07 test-001
-rw-r--r-- 1 harlock harlock    0 Aug 30 10:07 test-002
-rw-r--r-- 1 harlock harlock    0 Aug 30 10:56 test-003
cd
exit
exit

(ricordiamoci che all’inizio abbiamo acquisito i privilegi di root con sudo su -, e quindi a operazioni concluse è bene ritornare semplici unprivileged users).

Nota.

Ho preferito creare prima un file immagine contenente il filesystem piuttosto che operare direttamente sul dispositivo poichè, inizialmente, avevo fatto in questa maniera ma, non so per quale motivo, fdisk non vedeva correttamente le dimensioni del dispositivo. Inoltre, la prima parte della guida tornerà utile a quanti vogliano sperimentare la creazione di file-immagine per “comporre” CD o DVD da masterizzare successivamente, o per poterle utilizzare in virtual machines come QEMU. O, se non altro, imparare in tutta sicurezza l’uso di fdisk e dd.