Metodo terminale di formattazione dell'unità di archiviazione


59

Voglio sapere come formattare un'unità di archiviazione dal terminale. Le cose utili da fornire nella risposta sarebbero spesso utilizzate opzioni per comandi e conoscenze di base che è possibile utilizzare per estrapolare usi futuri. In particolare, vorrei sapere come formattare nei diversi file system come NTFS, FAT32, EXT4, ecc. Sono anche richieste informazioni su come partizionare l'unità tramite terminale.

Sto cercando di formattare un disco rigido esterno ad alta capacità (EHDD) in NTFS - dal terminale.

So che posso usare gparted per questo così come altri programmi della GUI, ma voglio ancora ora come farlo dal terminale.


1
A chiunque risponderà: assicurati di spiegare l'opzione -mnello spazio riservato - è rilevante, perché è intuitivo.
Volker Siegel,

Risposte:


66

Sono disponibili alcune opzioni:

  1. fdisk(più vecchio, non supporta GPT 4 ).
  2. parted (il fratello CLI di GParted).
  3. I vari mkfsprogrammi, se hai già partizioni e desideri formattare.

fdiske partedsono interattivi e hanno comandi di aiuto, così puoi sempre cercare aiuto all'interno del programma. Entrambi sono anche scriptabili. I mkfscomandi non sono interattivi.


fdisk

fdisksi aspetta un dispositivo (come /dev/sda) come argomento. Ha i seguenti comandi:

Command action
   a   toggle a bootable flag
   b   edit bsd disklabel
   c   toggle the DOS compatibility flag
   d   delete a partition
   l   list known partition types
   m   print this menu
   n   add a new partition
   o   create a new empty DOS partition table
   p   print the partition table
   q   quit without saving changes
   s   create a new empty Sun disklabel
   t   change a partition's system id
   u   change display/entry units
   v   verify the partition table
   w   write table to disk and exit
   x   extra functionality (experts only)

Non uso fdiskmolto. Mi concentrerò solo su:


parted

partednon ha bisogno di un argomento (prova a "indovinare"), ma dovresti sempre specificare il disco. Data la scelta, partedè il programma che dovresti preferire. Ha i seguenti comandi:

  align-check TYPE N                        check partition N for TYPE(min|opt) alignment
  check NUMBER                             do a simple check on the file system
  cp [FROM-DEVICE] FROM-NUMBER TO-NUMBER   copy file system to another partition
  help [COMMAND]                           print general help, or help on COMMAND
  mklabel,mktable LABEL-TYPE               create a new disklabel (partition table)
  mkfs NUMBER FS-TYPE                      make a FS-TYPE file system on partition NUMBER
  mkpart PART-TYPE [FS-TYPE] START END     make a partition
  mkpartfs PART-TYPE FS-TYPE START END     make a partition with a file system
  resizepart NUMBER END                    resize partition NUMBER
  move NUMBER START END                    move partition NUMBER
  name NUMBER NAME                         name partition NUMBER as NAME
  print [devices|free|list,all|NUMBER]     display the partition table, available devices, free space, all found partitions, or a particular partition
  quit                                     exit program
  rescue START END                         rescue a lost partition near START and END
  resize NUMBER START END                  resize partition NUMBER and its file system
  rm NUMBER                                delete partition NUMBER
  select DEVICE                            choose the device to edit
  set NUMBER FLAG STATE                    change the FLAG on partition NUMBER
  toggle [NUMBER [FLAG]]                   toggle the state of FLAG on partition NUMBER
  unit UNIT                                set the default unit to UNIT
  version                                  display the version number and copyright information of GNU Parted

I comandi possono essere assegnati a un prefisso univoco (ad esempio, hè l'abbreviazione di help).

Userò un file temporaneo ( /tmp/part) che ho creato per mostrarti i comandi, quindi le dimensioni saranno piuttosto ridotte. È necessario sostituirlo con il dispositivo necessario ( /dev/sdaad esempio).

Innanzitutto, se il tuo disco non ha una tabella delle partizioni, dobbiamo crearne una:

parted /tmp/part mklabel gpt

oppure mklabel msdos, se si desidera la cosa della partizione primaria 4 della vecchia scuola (chiamata tabella delle partizioni MBR o MSDOS ). Quindi creiamo, diciamo, una partizione ext4 che inizia a partire da 3 GB (ovvero, lasciando libero il 3G iniziale) e di dimensioni 2 GB (ovvero, terminando a 5 GB). partedsi aspetta posizioni in MB per mkpartfs, ma possiamo specificare il suffisso:

parted /tmp/part mkpart primary ext4 3G 5G

E un altro, ora una partizione NTFS da 1 GB:

parted /tmp/part mkpart primary ntfs 5G 6G

Risultato:

# parted /tmp/part print
Model:  (file)
Disk /tmp/blah: 10.4GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt

Number  Start   End     Size    File system  Name     Flags
 1      3000MB  5000MB  2000MB               primary
 2      5000MB  6000MB  1000MB               primary  msftdata

Nota come usa i prefissi SI, mentre GParted usa fermamente prefissi binari (lasciando cadere lo sciocco i). Etichetta le partizioni:

# parted /tmp/part name 1 hello
# parted /tmp/part name 2 world
# parted /tmp/part print
Model:  (file)
Disk /tmp/blah: 10.4GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt

Number  Start   End     Size    File system  Name   Flags
 1      3000MB  5000MB  2000MB               hello
 2      5000MB  6000MB  1000MB               world  msftdata

Mentre partedpuò creare partizioni del filesystem ntfsbene, non può formattare una partizione esistente (!) Su NTFS:

mkfs partition fs-type
         Make a filesystem fs-type on partition. fs-type can be one 
         of "fat16", "fat32", "ext2", "linux-swap", or "reiserfs".

Infatti, parted ti dirà che dovresti usarlo per manipolare le partizioni, non i filesystem , il che mi porta a:


mkfs

mkfs, come fsck, è essenzialmente un frontend per vari comandi specifici del filesystem. Sul mio sistema, ad esempio, mkfs.bfs, mkfs.cramfs, mkfs.ext2, mkfs.ext3, mkfs.ext4, mkfs.ext4dev, mkfs.fat, mkfs.minix, mkfs.msdos, mkfs.ntfs, mkfs.vfatsono disponibili.

Ora, sfortunatamente, mentre partedfunziona bene su un file, come quello che ho usato sopra, mkfsnon posso andare a caccia di partizioni in tali file. In effetti, prevede dispositivi a blocchi, quindi se ho intenzione di utilizzare un nuovo file /tmp/fileper mkfs, devo forzarlo. Utilizzerai il dispositivo a blocchi corrispondente alla partizione che desideri formattare, ad esempio /dev/sda2. La sintassi generale per mkfsè:

# mkfs --help
Usage: mkfs [options] [-t type fs-options] device [size]

Options:
 -t, --type=TYPE  file system type, when undefined ext2 is used
     fs-options   parameters to real file system builder
     device       path to a device
     size         number of blocks on the device
 -V, --verbose    explain what is done
                  defining -V more than once will cause a dry-run
 -V, --version    output version information and exit
                  -V as version must be only option
 -h, --help       display this help and exit

For more information, see mkfs(8).

Come puoi vedere, il -tflag ci consente di passare flag specifici del filesystem. Ad esempio, flag NTFS:

# mkfs.ntfs --help 
Usage: mkntfs [options] device [number-of-sectors]

Basic options:
    -f, --fast                      Perform a quick format
    -Q, --quick                     Perform a quick format
    -L, --label STRING              Set the volume label
    -C, --enable-compression        Enable compression on the volume
    -I, --no-indexing               Disable indexing on the volume
    -n, --no-action                 Do not write to disk

Advanced options:
    -c, --cluster-size BYTES        Specify the cluster size for the volume
    -s, --sector-size BYTES         Specify the sector size for the device
    -p, --partition-start SECTOR    Specify the partition start sector
    -H, --heads NUM                 Specify the number of heads
    -S, --sectors-per-track NUM     Specify the number of sectors per track
    -z, --mft-zone-multiplier NUM   Set the MFT zone multiplier
    -T, --zero-time                 Fake the time to be 00:00 UTC, Jan 1, 1970
    -F, --force                     Force execution despite errors

Output options:
    -q, --quiet                     Quiet execution
    -v, --verbose                   Verbose execution
        --debug                     Very verbose execution

Help options:
    -V, --version                   Display version
    -l, --license                   Display licensing information
    -h, --help                      Display this help

Developers' email address: ntfs-3g-devel@lists.sf.net
News, support and information:  http://tuxera.com

Quindi creiamo una partizione NTFS, con formattazione rapida ( -Q), costringendola a operare su un file non-block-device ( -F) e impostando un'etichetta ( -L "hello world").

# mkfs -t ntfs -F -Q -L "hello world" /tmp/file
/tmp/file is not a block device.
mkntfs forced anyway.
The sector size was not specified for /tmp/file and it could not be obtained automatically.  It has been set to 512 bytes.
The partition start sector was not specified for /tmp/file and it could not be obtained automatically.  It has been set to 0.
The number of sectors per track was not specified for /tmp/file and it could not be obtained automatically.  It has been set to 0.
The number of heads was not specified for /tmp/file and it could not be obtained automatically.  It has been set to 0.
Cluster size has been automatically set to 4096 bytes.
To boot from a device, Windows needs the 'partition start sector', the 'sectors per track' and the 'number of heads' to be set.
Windows will not be able to boot from this device.
Creating NTFS volume structures.
mkntfs completed successfully. Have a nice day.

Chiaramente non è piaciuto lavorare su un file. :) Non preoccuparti, dovrebbe rilevare automaticamente la maggior parte dei valori quando si lavora su un disco reale. Anche questo "file" funziona bene come filesystem:

# mount -t ntfs-3g /tmp/file /mnt
# touch "/mnt/a file in mnt"
# ls -l /mnt
total 0
-rwxrwxrwx 1 root root 0 Aug 29 06:43 a file in mnt
# umount /mnt
# ls -l /mnt
total 0

(Vedi le strane autorizzazioni?)


Appunti:

  1. Non ho ancora usato da sudonessuna parte in questa risposta. Dato che stavo operando su file e file di mia proprietà, non ne avevo bisogno sudo. partedti avvertirà di questo. Per i dispositivi a blocchi, che di solito sono sempre di proprietà di root, dovrai sudo(o dovrai usare una shell di root tramite sudo -io sudo su -).
  2. partedè un programma GNU e, come molti programmi GNU, ha una vasta documentazione nel infoformato. Installa parted-doc( sudo apt-get install parted-doc) e quindi esegui info parted. Puoi anche consultare il manuale dell'utente online .
  3. GParted è in grado di formattare una partizione su NTFS come chiama mkfsdirettamente il programma appropriato ( mkntfs, in questo caso - mkfs.ntfsè solo un collegamento a mkntfs). Imposta anche un numero di parametri. In effetti, per la maggior parte delle operazioni, puoi esaminare i dettagli dei messaggi GParted per vedere quali comandi sono stati eseguiti.
  4. Non entrerò nei meriti delle tabelle di partizione GPT vs MBR / MSDOS, ma è probabile che GPT si trovi su nuovi dispositivi con UEFI, specialmente se hai Windows 8 su di essi. Lo stato degli strumenti di partizionamento? discute quali strumenti sono disponibili se stai affrontando GPT.
  5. LVM, ZFS e btrfs sono un altro gioco. Tutti hanno i loro strumenti di accompagnamento e dovresti usarli al posto di partedo fdisk(tranne forse per un passaggio iniziale di creazione di partizioni per il loro uso).

Nota partedsull'uso:

La sintassi del partedprogramma è:

parted [options] [device [command [options...]...]]

Quando si esegue partedsenza un comando, come:

parted /tmp/parted

Ti verrà presentata una semplice shell, dove puoi eseguire i comandi sopra. Tuttavia, questi comandi possono anche essere eseguiti direttamente utilizzando il partedprogramma. Quindi questi tre sono equivalenti:

# parted /tmp/parted
GNU Parted 2.3
Using /tmp/parted
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) mklabel gpt

E

# parted
GNU Parted 2.3
Using /dev/sda
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) select /tmp/parted
Using /tmp/parted
(parted) mklabel gpt

E

parted /tmp/parted mklabel gpt

Si noti inoltre che, quando si creano partizioni con parted, un utile indicatore della fine delle partizioni è -1s(questo è "1" tra il trattino e la "s"). Ciò è utile se si desidera che la partizione si estenda da un inizio specificato al resto del disco. Per essere più specifici, in esecuzione

parted /dev/sda -- mkpart primary ext4 3G -1s

creerà una partizione /dev/sdache inizia a 3G e termina all'ultimo settore del /dev/sdadisco (ovvero si estende da 3G a tutto il resto del disco). Si noti che --è necessario, per 1snon essere interpretato come un'opzione non valida.


IMHO, gdisk, alias GPD fdisk, è superiore alla
separazione

1
@FireLizzard eccellente! Si prega di inviare una risposta in dettaglio come usarlo.
muru,

mentre la domanda è chiaramente su come formattare un disco, perché stai addirittura citando parted e fdisk? Ti accenni persino a te stesso, che non puoi formattare un disco con parted.
Zunder

@kreide rilegge: "Sono anche richieste informazioni su come partizionare il disco tramite il terminale."
muru,

11

Prima di tutto come partizionare il disco rigido con l'utility fdisk.

Linux consente solo 4 partizioni primarie. È possibile avere un numero molto maggiore di partizioni logiche suddividendo una delle partizioni primarie.

Solo una delle partizioni primarie può essere suddivisa.

fdisk viene avviato digitando come dispositivo fdisk root al prompt dei comandi.

Il dispositivo potrebbe essere qualcosa come / dev / sda o / dev / sdb

I comandi di base di fdisk necessari sono:

p print the partition table

n create a new partition

d delete a partition

q quit without saving changes

w write the new partition table and exit

Le modifiche apportate alla tabella delle partizioni non hanno effetto fino a quando non si emette il comando write (w).

Ecco una tabella delle partizioni di esempio:

Disk /dev/sdb: 64 heads, 63 sectors, 621 cylinders
Units = cylinders of 4032 * 512 bytes

   Device Boot    Start       End    Blocks   Id  System
/dev/sdb1   *         1       184    370912+  83  Linux
/dev/sdb2           185       368    370944   83  Linux
/dev/sdb3           369       552    370944   83  Linux
/dev/sdb4           553       621    139104   82  Linux swap

Esempio:

Avvia fdisk dal prompt della shell:

sudo su
fdisk /dev/sdb 

Il che indica che stai utilizzando la seconda unità sul controller SATA.

Command (m for help): p

Disk /dev/hdb: 64 heads, 63 sectors, 621 cylinders
Units = cylinders of 4032 * 512 bytes

That makes for 384Mb per partition. 
Now You get to work.


Command (m for help): n
Command action
   e   extended
   p   primary partition (1-4)
p
Partition number (1-4): 1
First cylinder (1-621, default 1):<RETURN>
Using default value 1
Last cylinder or +size or +sizeM or +sizeK (1-621, default 621): +384M

Next, You set up the partition You want to use for swap:


Command (m for help): n
Command action
   e   extended
   p   primary partition (1-4)
p
Partition number (1-4): 2
First cylinder (197-621, default 197):<RETURN>
Using default value 197
Last cylinder or +size or +sizeM or +sizeK (197-621, default 621): +128M

Ora la tabella delle partizioni è simile alla seguente:

 Device Boot      Start       End    Blocks   Id  System
/dev/sdb1             1       196    395104   83  Linux
/dev/sdb2           197       262    133056   83  Linux

Infine, rendi avviabile la prima partizione:

Command (m for help): a
Partition number (1-4): 1

And You make the second partition of type swap:


Command (m for help): t
Partition number (1-4): 2
Hex code (type L to list codes): 82
Changed system type of partition 2 to 82 (Linux swap)      
Command (m for help): p

Il risultato finale:

Disk /dev/sdb: 64 heads, 63 sectors, 621 cylinders
Units = cylinders of 4032 * 512 bytes

   Device Boot    Start       End    Blocks   Id  System
/dev/sdb1   *         1       196    395104+  83  Linux
/dev/sdb2           197       262    133056   82  Linux swap

Infine, si emette il comando write (w) per scrivere la tabella sul disco.


L'utility mkfs è usata per creare filesystem (ext2, ext3, ext4, ecc.) sul tuo sistema Linux.

Dovresti specificare il nome del dispositivo in mkfs su cui creare il filesystem.

Visualizza i comandi disponibili di Filesystem Builder

I costruttori di filesystem (comandi mkfs *) vengono generalmente cercati in directory come / sbin /, / sbin / fs, /sbin/fs.d, / etc / fs e / etc.

Se non trovato, infine cerca le directory trovate nella variabile PATH.

L'elenco seguente mostra i comandi mkfs * disponibili in un sistema.

sudo su
cd /sbin
ls mkfs*

mkfs  mkfs.bfs  mkfs.cramfs  mkfs.ext2  mkfs.ext3  mkfs.ext4  mkfs.ext4dev  
mkfs.minix  mkfs.msdos  mkfs.ntfs  mkfs.vfat

Costruisci un filesystem su un dispositivo specifico

Per costruire il filesystem usando il comando mkfs, gli argomenti richiesti sono device-filename e filesystem-type come mostrato sotto.

L'esempio seguente crea il filesystem ext4 sulla partizione / dev / sdb1.

sudo su
mkfs -t ext4 /dev/sdb1 

mke2fs 1.42 (29-Nov-2011)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
1120112 inodes, 4476416 blocks
223820 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=0
137 block groups
32768 blocks per group, 32768 fragments per group
8176 inodes per group
Superblock backups stored on blocks: 
    32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208, 
    4096000

Allocating group tables: done                            
Writing inode tables: done                            
Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information: done   

Si noti che il tipo di filesystem predefinito per il comando mkfs è ext2.

Se non specifichi l'opzione "-t", verrà creato il filesystem ext2.

Inoltre, è possibile utilizzare il metodo descritto in precedenza per identificare se si dispone del file system ext2 o ext3 o ext4.


Formatta un'unità NTFS

Innanzitutto, avrai bisogno della possibilità di creare file system NTFS, quindi installa ntfsprogs:

sudo su 
apt-get install ntfs-3g

Secondo, fai saltare la partizione e ricreala come NTFS.

sudo su 
umount /dev/sdb1
fdisk /dev/sdb

Options to select:

    ‘d’ to delete the partition
    ‘n’ to create a new partition
    ‘p’ for primary
    ‘1’ for partition number
    ‘Enter’ for first cylinder (default 1)
    ‘Enter’ for last cylinder (default of max size)
    ‘t’ for type
    ‘L’ to list codes, and enter code for HPFS/NTFS. In my case, it’s ‘7’
    ‘w’ to write changes to disk, and exit

umount /dev/sdb1

Nell'ultimo passaggio, smonta la partizione, perché Ubuntu l'ha montata di nuovo automaticamente.

Ora, è necessario creare il file system. Ci sono due modi per farlo: il modo impaziente (Quick Format) o il modo migliore ma molto più lungo (Full Format).

Formattazione veloce

Questo alloca solo lo spazio su disco, ma non azzera l'unità o verifica la presenza di settori danneggiati. Ciò significa che ci vorranno alcuni secondi.

sudo su 
mkfs.ntfs -f /dev/sdb1

Formato completo

Se sei molto più preoccupato per l'integrità dei dati e non ti dispiace aspettare, fai un formato completo.

Potrebbero essere necessarie alcune ore per azzerare un disco di grandi dimensioni!

sudo su 
mkfs.ntfs /dev/sdb1
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.