Método terminal de formatação da unidade de armazenamento

Quero saber como formatar uma unidade de armazenamento a partir do terminal. Coisas úteis a serem fornecidas na resposta seriam opções frequentemente usadas para comandos e baseiam o conhecimento que se pode usar para extrapolar usos futuros. Especificamente, eu gostaria de saber como formatar nos diferentes sistemas de arquivos, como NTFS, FAT32, EXT4, etc. Também são necessárias informações sobre como particionar a unidade via terminal.

Estou tentando formatar um disco rígido externo de alta capacidade (EHDD) em NTFS - a partir do terminal.

Eu sei que posso usar o gparted para isso, assim como para outros programas da GUI, mas ainda quero agora como fazê-lo no terminal.

Existem algumas opções disponíveis:

1. fdisk(mais antigo, não suporta GPT ⁴ ).
2. parted (o irmão CLI da GParted).
3. Os vários mkfsprogramas, se você já possui partições e deseja formatar.

fdiske partedsão interativos e têm comandos de ajuda, para que você possa sempre procurar ajuda dentro do programa. Ambos também são programáveis. Os mkfscomandos não são interativos.

fdisk

fdiskespera um dispositivo (como /dev/sda) como argumento. Possui os seguintes comandos:

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)

Eu não uso fdiskmuito. Vou me concentrar apenas em:

parted

partednão precisa de argumento (ele tenta "adivinhar"), mas você sempre deve especificar o disco. Dada a escolha, partedé o programa que você deve preferir. Possui os seguintes comandos:

  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

Os comandos podem ser contratados para um prefixo único (por exemplo, hé abreviação de help).

Vou usar um arquivo temporário ( /tmp/part) que criei para mostrar os comandos, para que os tamanhos sejam um pouco pequenos. Você deve substituí-lo pelo dispositivo necessário ( /dev/sdapor exemplo).

Primeiro, se o seu disco não tiver uma tabela de partição, devemos criar uma:

parted /tmp/part mklabel gpt

ou mklabel msdos, se você quiser a coisa antiga da partição primária 4 (chamada tabela de partição MBR ou MSDOS ). Em seguida, criamos, digamos, uma partição ext4 iniciando em 3 GB (ou seja, deixando o 3G inicial livre) e com tamanho 2 GB (ou seja, terminando em 5 GB). partedespera locais em MB para mkpartfs, mas podemos especificar o sufixo:

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

E outro, agora uma partição NTFS de 1 GB:

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

Resultado:

# 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

Observe como ele usa prefixos de SI, enquanto o GParted usa firmemente prefixos binários (enquanto elimina o bobo i). Vou rotular as partições:

# 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

Embora partedpossa criar partições do sistema de arquivos ntfsperfeitamente, ele não pode formatar uma partição existente (!) Para 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".

De fato, o parted lhe dirá que você deve usá-lo para manipular partições, não sistemas de arquivos , o que me leva a:

mkfs

mkfs, como fsck, é essencialmente uma interface para vários comandos específicos do sistema de arquivos. No meu sistema, por exemplo, mkfs.bfs, mkfs.cramfs, mkfs.ext2, mkfs.ext3, mkfs.ext4, mkfs.ext4dev, mkfs.fat, mkfs.minix, mkfs.msdos, mkfs.ntfs, mkfs.vfatestão disponíveis.

Agora, infelizmente, embora partedfuncione bem em um arquivo, como o que usei acima, mkfsnão pode procurar partições nesses arquivos. Na verdade, ele espera bloquear dispositivos, então se eu vou usar um novo arquivo /tmp/filepara mkfs, eu tenho que forçá-lo fazê-lo. Você usará o dispositivo de bloco correspondente à partição que deseja formatar, como /dev/sda2. A sintaxe geral para 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).

Como você pode ver, o -tsinalizador permite passar sinalizadores específicos do sistema de arquivos. Por exemplo, sinalizadores 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: [email protected]
News, support and information:  http://tuxera.com

Então, vamos criar uma partição NTFS, com formatação rápida ( -Q), forçando-a a operar em um arquivo sem dispositivo de bloco ( -F) e definindo um rótulo ( -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.

Claramente, não gostava de trabalhar em um arquivo. :) Não se preocupe, ele deve detectar automaticamente a maioria dos valores ao trabalhar em um disco real. Mesmo esse "arquivo" funciona bem como um sistema de arquivos:

# 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

(Veja as permissões estranhas?)

Notas:

1. Ainda não usei sudonenhum lugar nesta resposta. Como eu estava operando em arquivos e arquivos pertencentes a mim, não precisei sudo. partedirá avisá-lo sobre isso. Para dispositivos de bloco, geralmente pertencentes a root, você precisará sudo(ou precisará usar um shell raiz via sudo -iou sudo su -).
2. partedé um programa GNU e, como muitos programas GNU, possui extensa documentação no infoformato. Instale parted-doc( sudo apt-get install parted-doc) e depois execute info parted. Você também pode verificar o manual do usuário on - line .
3. O GParted pode formatar uma partição para o NTFS, pois chama o mkfsprograma apropriado diretamente ( mkntfsneste caso - mkfs.ntfsé apenas um link para mkntfs). Ele também define vários parâmetros. De fato, para a maioria das operações, você pode examinar os detalhes das mensagens GParted para ver quais comandos foram executados.
4. Não vou entrar no mérito das tabelas de partição GPT vs MBR / MSDOS, mas é provável que o GPT seja encontrado em novos dispositivos com UEFI, especialmente se você tiver o Windows 8 neles. O estado das ferramentas de particionamento? discute quais ferramentas estão disponíveis se você estiver enfrentando a GPT.
5. LVM, ZFS e btrfs são outro jogo. Todos eles têm as ferramentas que os acompanham e você deve usá-los em vez de partedou fdisk(exceto talvez para uma etapa inicial da criação de partições para seu uso).

Nota sobre o parteduso:

A sintaxe do partedprograma é:

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

Quando você executa partedsem um comando, como:

parted /tmp/parted

Você verá um shell simples, onde poderá executar os comandos acima. No entanto, esses comandos também podem ser executados diretamente usando o partedprograma. Portanto, esses três são equivalentes:

# 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

Observe também que, ao criar partições com parted, é um indicador útil do final das partições -1s(este é "1" entre o hífen e o "s"). Isso é útil se você deseja que sua partição abranja desde um início especificado até o restante do disco. Para ser mais específico, executando

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

criará uma partição /dev/sdaque começa em 3G e termina no último setor do /dev/sdadisco (ou seja, se estende de 3G para todo o restante do disco). Observe que --é necessário, para 1snão ser interpretado como uma opção inválida.

Primeiro, como particionar seu disco rígido com o utilitário fdisk.

O Linux permite apenas 4 partições primárias. Você pode ter um número muito maior de partições lógicas subdividindo uma das partições primárias.

Somente uma das partições primárias pode ser subdividida.

O fdisk é iniciado digitando como dispositivo fdisk raiz no prompt de comando.

O dispositivo pode ser algo como / dev / sda ou / dev / sdb

Os comandos básicos do fdisk necessários são:

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

As alterações feitas na tabela de partição não terão efeito até você emitir o comando write (w).

Aqui está uma tabela de partição de amostra:

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

Exemplo:

Inicie o fdisk no prompt do shell:

sudo su
fdisk /dev/sdb 

O que indica que você está usando a segunda unidade no seu controlador 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

Agora a tabela de partição fica assim:

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

Por fim, você torna a primeira partição inicializável:

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

O resultado final:

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

Por fim, você emite o comando write (w) para gravar a tabela no disco.

O utilitário mkfs é usado para criar um sistema de arquivos (ext2, ext3, ext4, etc) no seu sistema Linux.

Você deve especificar o nome do dispositivo para mkfs no qual o sistema de arquivos será criado.

Exibir os comandos disponíveis do construtor do sistema de arquivos

Os construtores de sistema de arquivos (comandos mkfs *) geralmente são pesquisados ​​em diretórios como / sbin /, / sbin / fs, /sbin/fs.d, / etc / fs e / etc.

Se não for encontrado, finalmente ele pesquisa os diretórios encontrados na variável PATH.

A lista a seguir mostra os comandos mkfs * disponíveis em um 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

Construir um sistema de arquivos em um dispositivo específico

Para construir o sistema de arquivos usando o comando mkfs, os argumentos necessários são nome do dispositivo e nome do sistema de arquivos, como mostrado abaixo.

O exemplo a seguir cria um sistema de arquivos ext4 na partição / 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   

Observe que o tipo de sistema de arquivos padrão para o comando mkfs é ext2.

Se você não especificar a opção "-t", ele criará o sistema de arquivos ext2.

Além disso, você pode usar o método discutido anteriormente para identificar se você possui o sistema de arquivos ext2 ou ext3 ou ext4.

Formatar uma unidade NTFS

Primeiro, você precisará da capacidade de criar sistemas de arquivos NTFS, então instale o ntfsprogs:

sudo su 
apt-get install ntfs-3g

Segundo, você explode a partição e a recria como 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

Na última etapa, desmonte a partição, porque o Ubuntu montou automaticamente novamente para você.

Agora, você precisa criar o sistema de arquivos. Existem duas maneiras de fazer isso: a maneira impaciente (Quick Format) ou a melhor, mas muito mais longa (Full Format).

Formatação rápida

Isso apenas aloca o espaço em disco, mas não zera a unidade nem verifica setores defeituosos. Isso significa que levará alguns segundos.

sudo su 
mkfs.ntfs -f /dev/sdb1

Formato completo

Se você está muito mais preocupado com a integridade dos dados e não se importa de esperar, faça um formato completo.

Pode levar algumas horas para zerar uma unidade grande!

sudo su 
mkfs.ntfs /dev/sdb1