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

51

Eu quero saber como formatar uma unidade de armazenamento do terminal. Coisas úteis para fornecer na resposta seriam freqüentemente usadas opções para comandos e conhecimento básico que podem ser usados para extrapolar usos futuros. Especificamente, gostaria de saber como formatar os diferentes sistemas de arquivos, como NTFS, FAT32, EXT4, etc. Também é desejável obter informações sobre como particionar o drive 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 outros programas GUI, mas ainda quero agora como fazer isso a partir do terminal.

    
por GoProCameraByGoPro 29.08.2014 / 01:53

2 respostas

55

Existem algumas opções disponíveis:

  1. fdisk (mais antigo, não suporta GPT 4 ).
  2. parted (o CLI irmão do GParted).
  3. Os vários programas mkfs , se você já tiver partições e deseja formatar.

fdisk e parted são interativos e têm comandos de ajuda, para que você sempre possa procurar ajuda no programa. Ambos também são roteirizáveis. Os comandos mkfs não são interativos.

fdisk

fdisk espera um dispositivo (como /dev/sda ) como um argumento. Tem 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 muito fdisk . Vou focar apenas em:

parted

parted não precisa de um argumento (tenta "adivinhar"), mas você deve sempre especificar o disco. Dada a escolha, parted é o programa que você deve preferir. Tem 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 exclusivo (por exemplo, h é a 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 substituir isso pelo dispositivo que você precisa ( /dev/sda , por exemplo).

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

parted /tmp/part mklabel gpt

ou mklabel msdos , se você quiser a coisa da antiga partição 4 primária (chamada tabela de partições MBR ou MSDOS ). Então, fazemos, digamos, uma partição ext4 começando com 3 GB (ou seja, deixando o 3G inicial livre) e com tamanho de 2 GB (isto é, terminando em 5 GB). parted espera localizações em MB para mkpartfs , mas podemos especificar o sufixo:

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

E outra, 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 os prefixos do SI, enquanto o GParted usa firmemente os prefixos binários (enquanto descarta o bobo%) código%). 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

Enquanto i pode criar partições do sistema de arquivos parted , não é possível 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 dirá a você que você deve usá-lo para manipular partições, não sistemas de arquivos , o que me leva a:

ntfs

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

Agora, infelizmente, enquanto mkfs.vfat funciona muito bem em um arquivo, como o que usei acima, parted não pode procurar por partições nesses arquivos. Na verdade, ele espera dispositivos de bloco, por isso, se for usar um novo arquivo mkfs para /tmp/file , preciso forçá-lo a fazer isso. Você usará o dispositivo de bloco correspondente à partição que deseja formatar, como mkfs . A sintaxe geral para /dev/sda2 é:

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

# 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.

É evidente que não gostou de trabalhar em um arquivo. :) Não se preocupe, ele deve detectar automaticamente a maioria dos valores ao trabalhar em um disco real. Mesmo este "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 -L "hello world" em nenhuma parte dessa resposta. Como eu estava operando em arquivos e arquivos de minha propriedade, não precisei de sudo . sudo avisará sobre isso. Para dispositivos de bloco, que geralmente são sempre de propriedade de parted , você precisará de root (ou você precisará usar um shell de raiz via sudo ou sudo -i ).
  2. sudo su - é um programa GNU e, como muitos programas GNU, possui extensa documentação no formato parted . Instale info ( parted-doc ) e, em seguida, execute sudo apt-get install parted-doc . Você também pode fazer o checkout do manual do usuário on-line .
  3. O GParted pode formatar uma partição para NTFS, pois ela chama diretamente o programa info parted apropriado ( mkfs , nesse caso - mkntfs é apenas um link para mkfs.ntfs ). Também define vários parâmetros. Na verdade, para a maioria das operações, você pode examinar os detalhes das mensagens do GParted para ver quais comandos foram executados.
  4. Não vou entrar nos méritos das tabelas de partição GPT vs MBR / MSDOS, mas a GPT provavelmente será encontrada 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 o GPT.
  5. LVM, ZFS e btrfs são um outro jogo. Todos eles têm suas ferramentas de acompanhamento, e você deve usá-los em vez de mkntfs ou parted (exceto, talvez, para uma etapa inicial de criação de partições para uso).

Observação sobre fdisk usage:

A sintaxe do programa parted é:

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

Quando você executa parted sem um comando, como:

parted /tmp/parted

Você será apresentado a um shell simples, onde você pode executar os comandos acima. No entanto, esses comandos também podem ser executados diretamente usando o programa parted . Então, 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

Note também que, ao criar partições com parted , um indicador útil do fim das partições é parted (isto é "1" entre o hífen e o "s"). Isso é útil se você quiser que sua partição se estenda de um início especificado para o restante do disco. Para ser mais específico, executando

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

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

    
por muru 29.08.2014 / 03:15
9

Primeiro você 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.

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

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

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

Os comandos básicos do fdisk que você precisa 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 que você faz na tabela de partição não entram em vigor até você emitir o comando write (w).

Aqui está uma tabela de partições 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 em 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ções é 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

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

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

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

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

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

Se não for encontrado, finalmente ele procura 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

Construa 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 arquivo do dispositivo e tipo do sistema de arquivos, como mostrado abaixo.

O exemplo a seguir cria o 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   

Por favor, note que o tipo de sistema de arquivos padrão para o comando mkfs é ext2.

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

Além disso, você pode usar o método que discutimos 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, portanto, instale o ntfsprogs:

sudo su 
apt-get install ntfs-3g

Segundo, você remove 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, você desmonta a partição, porque o Ubuntu montou-a novamente automaticamente para você.

Agora, você precisa criar o sistema de arquivos. Há duas maneiras de fazer isso: a maneira impaciente (formato rápido) ou a maneira melhor, mas muito mais longa (formato completo).

Formato rápido

Isso apenas aloca o espaço em disco, mas não zera a unidade ou verifica se há 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 em esperar, faça um formato completo.

Isso pode levar algumas horas para zerar uma grande unidade!

sudo su 
mkfs.ntfs /dev/sdb1
    
por kyodake 29.08.2014 / 02:26