Linux Professional Institute Learning Logo.
Ir para o conteúdo principal
  • Home
    • Todos os recursos
    • LPI Materiais Didáticos
    • Colabore Conosco
    • Publishing Partners
    • Seja um Publishing Partner
    • Quem Somos
    • FAQ
    • Colaboradores
    • Contato
  • LPI.org
104.1 Lição 1
Tópico 101: Arquitetura de Sistema
101.1 Identificar e editar configurações de hardware
  • 101.1 Lição 1
101.2 Início (boot) do sistema
  • 101.2 Lição 1
101.3 Alternar runlevels/boot targets, desligar e reiniciar o sistema
  • 101.3 Lição 1
Tópico 102: Instalação do Linux e administração de Pacotes
102.1 Dimensionar partições de disco
  • 102.1 Lição 1
102.2 Instalar o gerenciador de inicialização
  • 102.2 Lição 1
102.3 Controle de bibliotecas compartilhadas
  • 102.3 Lição 1
102.4 Utilização do sistema de pacotes Debian
  • 102.4 Lição 1
102.5 Utilização do sistema de pacotes RPM e YUM
  • 102.5 Lição 1
102.6 Linux virtualizado
  • 102.6 Lição 1
Tópico 103: Comandos GNU e Unix
103.1 Trabalhar na linha de comando
  • 103.1 Lição 1
  • 103.1 Lição 2
103.2 Processar fluxos de texto usando filtros
  • 103.2 Lição 1
103.3 Gerenciamento básico de arquivos
  • 103.3 Lição 1
  • 103.3 Lição 2
103.4 Fluxos, pipes (canalização) e redirecionamentos de saída
  • 103.4 Lição 1
  • 103.4 Lição 2
103.5 Criar, monitorar e finalizar processos
  • 103.5 Lição 1
  • 103.5 Lição 2
103.6 Modificar a prioridade de execução de um processo
  • 103.6 Lição 1
103.7 Procurar em arquivos de texto usando expressões regulares
  • 103.7 Lição 1
  • 103.7 Lição 2
103.8 Edição básica de arquivos com o vi
  • 103.8 Lição 1
Tópico 104: Dispositivos, sistemas de arquivos Linux e padrão FHS
104.1 Criar partições e sistemas de arquivos
  • 104.1 Lição 1
104.2 Manutenção da integridade de sistemas de arquivos
  • 104.2 Lição 1
104.3 Controle da montagem e desmontagem dos sistemas de arquivos
  • 104.3 Lição 1
104.5 Controlar permissões e propriedades de arquivos
  • 104.5 Lição 1
104.6 Criar e alterar links simbólicos e hardlinks
  • 104.6 Lição 1
104.7 Encontrar arquivos de sistema e conhecer sua localização correta
  • 104.7 Lição 1
How to get certified
  1. Tópico 104: Dispositivos, sistemas de arquivos Linux e padrão FHS
  2. 104.1 Criar partições e sistemas de arquivos
  3. 104.1 Lição 1

104.1 Lição 1

Certificação:

LPIC-1

Versão:

5.0

Tópico:

104 Dispositivos, sistemas de arquivos do Linux, hierarquia padrão de sistemas de arquivos

Objetivo:

104.1 Criação de partições e sistemas de arquivos

Lição:

1 de 1

Introdução

Em qualquer sistema operacional, um disco precisa ser particionado antes de poder ser usado. Uma partição é um subconjunto lógico do disco físico; as informações sobre as partições são armazenadas em uma tabela de partições. Essa tabela inclui informações sobre o primeiro e o último setores da partição e seu tipo, além de mais detalhes sobre cada partição.

Normalmente, cada partição é vista por um sistema operacional como um “disco” separado, mesmo que todas residam na mesma mídia física. Nos sistemas Windows, elas recebem letras como C: (historicamente o disco principal), D: e assim por diante. No Linux, cada partição recebe um diretório em /dev, como /dev/sda1 ou /dev/sda2.

Nesta lição, você aprenderá a criar, excluir, restaurar e redimensionar partições usando os três utilitários mais comuns (fdisk, gdisk e parted), a criar um sistema de arquivos nelas e a criar e definir uma partição de troca ou arquivo de troca para ser usado como memória virtual.

Note

Por razões históricas, nesta lição nos referimos às mídias de armazenamento como “discos”, mesmo que os sistemas de armazenamento modernos, como SSDs e armazenamento flash, não contenham mais nenhum “disco”.

Entendendo MBR e GPT

Existem duas maneiras principais de armazenar informações sobre partições em discos rígidos. A primeira é o MBR (Master Boot Record, ou Registro Mestre de Inicialização) e a segunda é a GPT (GUID Partition Table, ou Tabela de Partição GUID).

MBR

Um remanescente dos primeiros dias do MS-DOS (mais especificamente, o PC-DOS 2.0 de 1983) que, por décadas, foi o esquema de particionamento padrão dos PCs. A tabela de partição é armazenada no primeiro setor de um disco, chamado setor de inicialização, junto com um carregador de inicialização, que em sistemas Linux geralmente é o bootloader GRUB. Mas o MBR tem uma série de limitações que dificultam seu uso em sistemas modernos, como a incapacidade de endereçar discos com mais de 2 TB de tamanho e o limite de apenas 4 partições primárias por disco.

GUID

Um sistema de particionamento que aborda muitas das limitações do MBR. Não há limite prático para o tamanho do disco, e o número máximo de partições é limitado apenas pelo próprio sistema operacional. É mais comumente encontrado em máquinas mais modernas que usam UEFI em vez da antiga BIOS.

Durante as tarefas de administração do sistema, é bastante possível que você encontre ambos os esquemas em uso, por isso é importante saber como usar as ferramentas associadas a cada um para criar, excluir ou modificar partições.

Gerenciando partições MBR com o FDISK

O utilitário padrão para gerenciar partições MBR no Linux é o fdisk. Trata-se de um utilitário interativo com menu. Para usá-lo, digite fdisk seguido pelo nome do dispositivo correspondente ao disco que deseja editar. Por exemplo, o comando

# fdisk /dev/sda

serve para editar a tabela de partição do primeiro dispositivo conectado por SATA (sda) no sistema. Lembre-se de que é preciso especificar o dispositivo correspondente ao disco físico, não uma de suas partições (como /dev/sda1).

Note

Todas as operações de disco desta lição devem ser realizadas com o usuário root (o administrador do sistema), ou com privilégios de root usando sudo.

Quando invocado, fdisk mostra uma saudação seguida de um aviso e espera pelos seus comandos.

# fdisk /dev/sda
Welcome to fdisk (util-linux 2.33.1).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.

Command (m for help):

O aviso é importante. Você pode criar, editar ou remover partições à vontade, mas nada será gravado no disco a menos que você use o comando write (w). Assim, você pode “praticar” sem o risco de perder dados, desde que mantenha distância da tecla w. Para sair do fdisk sem salvar as alterações, use o comando q.

Note

Dito isso, jamais pratique em um disco importante, pois sempre haverá riscos. Use um disco externo sobressalente ou um pendrive.

Imprimindo a tabela de partição atual

O comando p é usado para imprimir a tabela de partição atual. A saída é mais ou menos assim:

Command (m for help): p
Disk /dev/sda: 111.8 GiB, 120034123776 bytes, 234441648 sectors
Disk model: CT120BX500SSD1
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x97f8fef5

Device     Boot     Start       End   Sectors   Size Id Type
/dev/sda1            4096 226048942 226044847 107.8G 83 Linux
/dev/sda2       226048944 234437550   8388607     4G 82 Linux swap / Solaris

Este é o significado de cada coluna:

Device

O dispositivo atribuído à partição.

Boot

Mostra se a partição é “inicializável” ou não.

Start

O setor em que a partição começa.

End

O setor em que a partição termina.

Sectors

O número total de setores na partição. Deve ser multiplicado pelo tamanho dos setores para se obter o tamanho da partição em bytes.

Size

O tamanho da partição em formato “legível por humanos”. No exemplo acima, os valores estão em gigabytes.

Id

O valor numérico que representa o tipo de partição.

Type

A descrição do tipo de partição.

Partições primárias e estendidas

Em um disco MBR, podemos ter 2 tipos principais de partições, primária e estendida. Como já dissemos, só é possível ter 4 partições primárias no disco e, para que o disco seja “inicializável”, a primeira partição deve ser primária.

Uma maneira de contornar essa limitação é criar uma partição estendida que atue como um contêiner para partições lógicas. Seria possível ter, por exemplo, uma partição primária, uma partição estendida ocupando o restante do espaço em disco e cinco partições lógicas dentro dela.

Para um sistema operacional como o Linux, as partições primárias e estendidas são tratadas exatamente da mesma maneira, então não há “vantagens” em se usar uma ou outra.

Criando uma partição

Para criar uma partição, use o comando n. Por padrão, as partições serão criadas no início do espaço não alocado no disco. Você será questionado sobre o tipo de partição (primária ou estendida), primeiro setor e último setor.

Para o primeiro setor, geralmente podemos aceitar o valor padrão sugerido pelo fdisk, a menos que você precise que uma partição inicie em um setor específico. Em vez de especificar o último setor, dá para especificar um tamanho seguido das letras K, M, G, T ou P (Kilo, Mega, Giga, Tera ou Peta). Assim, se você quiser criar uma partição de 1 GB, pode especificar +1G como Last sector e o fdisk redimensiona a partição de acordo. Veja este exemplo para a criação de uma partição primária:

Command (m for help): n
Partition type
   p   primary (0 primary, 0 extended, 4 free)
   e   extended (container for logical partitions)
Select (default p): p
Partition number (1-4, default 1): 1
First sector (2048-3903577, default 2048): 2048
Last sector, +/-sectors or +/-size{K,M,G,T,P} (2048-3903577, default 3903577): +1G
Verificando o espaço não alocado

Se você não souber quanto espaço livre resta no disco, pode usar o comando F para mostrar o espaço não alocado, desta maneira:

Command (m for help): F
Unpartitioned space /dev/sdd: 881 MiB, 923841536 bytes, 1804378 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes

  Start     End Sectors  Size
2099200 3903577 1804378  881M
Removendo partições

Para remover uma partição, use o comando d. O fdisk irá pedir o número da partição a remover, a menos que haja apenas uma partição no disco. Neste caso, essa partição será selecionada e excluída imediatamente.

Esteja ciente de que se você excluir uma partição estendida, todas as partições lógicas dentro dela também serão excluídas.

Lacunas

Tenha em mente que, ao criar uma nova partição com fdisk, o tamanho máximo será limitado pela quantidade máxima de espaço contíguo não alocado no disco. Digamos, por exemplo, que você tenha o seguinte mapa de partições:

Device     Boot   Start     End Sectors  Size Id Type
/dev/sdd1          2048 1050623 1048576  512M 83 Linux
/dev/sdd2       1050624 2099199 1048576  512M 83 Linux
/dev/sdd3       2099200 3147775 1048576  512M 83 Linux

Em seguida, você exclui a partição 2 e verifica o espaço livre:

Command (m for help): F
Unpartitioned space /dev/sdd: 881 MiB, 923841536 bytes, 1804378 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes

  Start     End Sectors  Size
1050624 2099199 1048576  512M
3147776 3903577  755802  369M

Somando o tamanho do espaço não alocado, em teoria teríamos 881 MB disponíveis. Mas veja o que acontece quando tentamos criar uma partição de 700 MB:

Command (m for help): n
Partition type
   p   primary (2 primary, 0 extended, 2 free)
   e   extended (container for logical partitions)
Select (default p): p
Partition number (2,4, default 2): 2
First sector (1050624-3903577, default 1050624):
Last sector, +/-sectors or +/-size{K,M,G,T,P} (1050624-2099199, default 2099199): +700M
Value out of range.

Isso acontece porque o maior espaço contíguo não alocado no disco é o bloco de 512 MB que pertencia à partição 2. Sua nova partição não pode “pular por cima” da partição 3 para usar parte do espaço não alocado existente depois dela.

Mudando o tipo da partição

Ocasionalmente, pode ser necessário alterar o tipo da partição, especialmente ao lidar com discos que serão usados em outros sistemas operacionais e plataformas. Isso é feito com o comando t, seguido pelo número da partição que se deseja alterar.

O tipo de partição deve ser especificado por seu código hexadecimal correspondente. Para ver uma lista de todos os códigos válidos, use o comando l.

Não confunda o tipo de partição com o sistema de arquivos usado nela. Embora no início houvesse uma relação entre eles, hoje não é possível presumir que isso seja verdade. Uma partição Linux, por exemplo, pode conter qualquer sistema de arquivos nativo do Linux, como ext4 ou ReiserFS.

Tip

As partições do Linux são do tipo 83 (Linux). As partições de troca são do tipo 82 (Linux Swap).

Gerenciando partições GUID com o GDISK

O utilitário gdisk é o equivalente do fdisk para lidar com discos particionados GPT. Na verdade, a interface foi criada a partir do fdisk, com um prompt interativo e os mesmos comandos (ou muito semelhantes).

Imprimindo a tabela de partição atual

O comando p é usado para imprimir a tabela de partição atual. A saída é mais ou menos assim:

Command (? for help): p
Disk /dev/sdb: 3903578 sectors, 1.9 GiB
Model: DataTraveler 2.0
Sector size (logical/physical): 512/512 bytes
Disk identifier (GUID): AB41B5AA-A217-4D1E-8200-E062C54285BE
Partition table holds up to 128 entries
Main partition table begins at sector 2 and ends at sector 33
First usable sector is 34, last usable sector is 3903544
Partitions will be aligned on 2048-sector boundaries
Total free space is 1282071 sectors (626.0 MiB)

Number  Start (sector)    End (sector)  Size       Code  Name
   1            2048         2099199   1024.0 MiB  8300  Linux filesystem
   2         2623488         3147775   256.0 MiB   8300  Linux filesystem

Já de cara, notamos algumas coisas diferentes:

  • Cada disco possui um Identificador de Disco (GUID) exclusivo. Este é um número hexadecimal de 128 bits, atribuído aleatoriamente quando a tabela de partição é criada. Como há 3.4 × 1038 valores possíveis para esse número, as chances de que 2 discos aleatórios tenham o mesmo GUID são muito pequenas. O GUID pode ser usado para identificar quais sistemas de arquivos montar no momento da inicialização (e onde), eliminando a necessidade de usar o caminho do dispositivo para fazer isso (como /dev/sdb).

  • Notou a frase Partition table holds up to 128 entries? É isso mesmo, dá para ter até 128 partições em um disco GPT. Por causa disso, não há necessidade de partições primárias e estendidas.

  • O espaço livre é listado na última linha, então não precisamos de um equivalente ao comando F do fdisk.

Criando uma partição

O comando para criar uma partição é n, assim como em fdisk. A principal diferença é que, além do número da partição e do primeiro e último setores (ou o tamanho), também podemos especificar o tipo de partição durante a criação. As partições GPT suportam muitos mais tipos do que as MBR. Para ver uma lista de todos os tipos suportados, use o comando l.

Removendo uma partição

Para excluir uma partição, digite d e o número da partição. Ao contrário do fdisk, a primeira partição não será selecionada automaticamente se for a única no disco.

Em discos GPT, as partições podem ser facilmente reordenadas ou “classificadas” para evitar lacunas na sequência de numeração. Para isso, basta usar o comando s. Por exemplo, imagine um disco com a seguinte tabela de partição:

Number  Start (sector)    End (sector)  Size       Code  Name
   1            2048         2099199   1024.0 MiB  8300  Linux filesystem
   2         2099200         2361343   128.0 MiB   8300  Linux filesystem
   3         2361344         2623487   128.0 MiB   8300  Linux filesystem

Se excluirmos a segunda partição, a tabela fica assim:

Number  Start (sector)    End (sector)  Size       Code  Name
   1            2048         2099199   1024.0 MiB  8300  Linux filesystem
   3         2361344         2623487   128.0 MiB   8300  Linux filesystem

Se usarmos o comando s, ela se torna:

Number  Start (sector)    End (sector)  Size       Code  Name
   1            2048         2099199   1024.0 MiB  8300  Linux filesystem
   2         2361344         2623487   128.0 MiB   8300  Linux filesystem

Observe que a terceira partição se tornou a segunda.

Lacuna? Que lacuna?

Ao contrário dos discos MBR, ao criar uma partição em discos GPT, o tamanho não é limitado pela quantidade máxima de espaço contíguo não alocado. Você pode usar até o último pedacinho de um setor livre, não importa onde ele esteja localizado no disco.

Opções de recuperação

Os discos GPT armazenam cópias de backup do cabeçalho GPT e da tabela de partição, facilitando a recuperação dos discos caso esses dados tenham sido danificados. O gdisk fornece recursos para auxiliar nessas tarefas de recuperação, acessadas com o comando r.

Para reconstruir um cabeçalho GPT principal corrompido ou uma tabela de partição, usamos b e c, respectivamente, ou usamos o cabeçalho principal e a tabela para reconstruir um backup com d e e. Também dá para converter um MBR em GPT com f e fazer o oposto com g, entre outras operações. Digite ? No menu de recuperação para obter uma lista de todos os comandos de recuperação disponíveis e descrições sobre o que eles fazem.

Criando sistemas de arquivos

O particionamento é apenas o primeiro passo para poder usar um disco. Depois disso, é necessário formatar a partição com um sistema de arquivos antes que se possa usá-lo para armazenar dados.

Um sistema de arquivos controla como os dados são armazenados e acessados no disco. O Linux suporta muitos sistemas de arquivos, alguns nativos, como a família ext (Extended Filesystem), enquanto outros vêm de outros sistemas operacionais como o FAT do MS-DOS, o NTFS do Windows NT, HFS e HFS + do Mac OS etc.

A ferramenta padrão usada para criar um sistema de arquivos no Linux é o mkfs, que vem em muitos “sabores” de acordo com o sistema de arquivos com o qual ele precisa trabalhar.

Criando um sistema de arquivos ext2/ext3/ext4

O Extended Filesystem (ext) foi o primeiro sistema de arquivos para Linux, tendo sido substituído ao longo dos anos por novas versões chamadas ext2, ext3 e ext4. Este último é atualmente o sistema de arquivos padrão de muitas distribuições Linux.

Os utilitários mkfs.ext2, mkfs.ext3 e mkfs.ext4 são usados para criar sistemas de arquivos ext2, ext3 e ext4. De fato, todos esses “utilitários” existem apenas como links simbólicos para outro utilitário chamado mke2fs. O mke2fs altera seus padrões de acordo com o nome pelo qual é chamado. Dessa forma, todos eles têm o mesmo comportamento e parâmetros na linha de comando.

A forma de uso mais simples é:

# mkfs.ext2 TARGET

Onde TARGET é o nome da partição na qual o sistema de arquivos deve ser criado. Por exemplo, para criar um sistema de arquivos ext3 em /dev/sdb1, o comando seria:

# mkfs.ext3 /dev/sdb1

Em vez de usar o comando correspondente ao sistema de arquivos que deseja criar, você pode passar o parâmetro -t para mke2fs seguido do nome do sistema de arquivos. Por exemplo, os comandos a seguir são equivalentes e irão criar um sistema de arquivos ext4 em /dev/sdb1.

# mkfs.ext4 /dev/sdb1
# mke2fs -t ext4 /dev/sdb1
Parâmetros de linha de comando

O mke2fs suporta uma ampla gama de parâmetros e opções de linha de comando. Eis alguns dos mais significativos. Todos eles também se aplicam a mkfs.ext2, mkfs.ext3 e mkfs.ext4:

-b SIZE

Define o tamanho dos blocos de dados no dispositivo para SIZE, que pode ser de 1024, 2048 ou 4096 bytes por bloco.

-c

Verifica se existem blocos defeituosos no dispositivo de destino antes de criar o sistema de arquivos. Para fazer uma verificação mais detalhada, porém muito mais lenta, aplique esse parâmetro duas vezes, como em mkfs.ext4 -c -c TARGET.

-d DIRECTORY

Copia o conteúdo do diretório especificado para a raiz do novo sistema de arquivos. Útil quando se precisa “pré-preencher” o disco com um conjunto de arquivos predefinido.

-F

Perigo, Will Robinson! Esta opção força o mke2fs a criar um sistema de arquivos, mesmo se as outras opções passadas para ele ou para o alvo forem perigosas ou não fizerem nenhum sentido. Se especificado duas vezes (como em -F -F), pode inclusive ser usado para criar um sistema de arquivos em um dispositivo montado ou em uso, o que é uma coisa muito, mas muito ruim de se fazer.

-L VOLUME_LABEL

Define o rótulo do volume conforme especificado em VOLUME_LABEL. Esse rótulo deve ter ao menos 16 caracteres.

-n

Esta é uma opção utilíssima que simula a criação do sistema de arquivos e mostra o que seria feito se executado sem a opção n. Pense nele como um modo de “teste”. É bom verificar as coisas antes de realmente efetuar quaisquer alterações no disco.

-q

Modo silencioso. O mke2fs será executado normalmente, mas não produzirá nenhuma saída para o terminal. Útil ao executar mke2fs a partir de um script.

-U ID

Este parâmetro define o UUID (Universally Unique Identifier, ou Identificador único universal) de uma partição para o valor especificado como ID. Os UUIDs são números de 128 bits em notação hexadecimal que servem para identificar uma partição para o sistema operacional. Esse número é especificado como uma string de 32 dígitos no formato 8-4-4-4-12, ou seja, 8 dígitos, hífen, 4 dígitos, hífen, 4 dígitos, hífen, 4 dígitos, hífen, 12 dígitos, como D249E380-7719-45A1-813C-35186883987E. Em vez de um ID, você também pode especificar parâmetros como clear para remover o UUID do sistema de arquivos, random para usar um UUID gerado aleatoriamente, ou time para criar um UUID baseado em tempo.

-V

Modo detalhado (ou verboso), exibe muito mais informações durante a operação do que normalmente. Útil para fins de depuração.

Criando um sistema de arquivos XFS

O XFS é um sistema de arquivos de alto desempenho originalmente desenvolvido pela Silicon Graphics em 1993 para seu sistema operacional IRIX. Graças a seu desempenho e recursos de confiabilidade, ele é comumente usado para servidores e outros ambientes que exigem largura de banda alta (ou garantida) do sistema de arquivos.

As ferramentas para gerenciar os sistemas de arquivos XFS são parte do pacote xfsprogs. Pode ser preciso instalar esse pacote manualmente, pois ele não vem incluído por padrão em algumas distribuições Linux. Outras, como o Red Hat Enterprise Linux 7, usam o XFS como sistema de arquivos padrão.

Os sistemas de arquivos XFS são divididos em pelo menos 2 partes, uma seção de log, onde é mantido um log de todas as operações do sistema de arquivos (comumente chamadas de Journal, ou diário), e a seção de dados. A seção de log pode estar localizada dentro da seção de dados (que é o comportamento padrão), ou mesmo em um disco separado, para melhor desempenho e confiabilidade.

O comando mais básico para criar um sistema de arquivos XFS é mkfs.xfs TARGET, onde TARGET é a partição na qual você deseja que o sistema de arquivos seja criado. Por exemplo: mkfs.xfs /dev/sda1.

Como no caso do mke2fs, o mkfs.xfs suporta uma série de opções de linha de comando. Eis algumas das mais comuns.

-b size=VALUE

Define o tamanho do bloco no sistema de arquivos, em bytes, para aquele especificado em VALUE. O valor padrão é 4096 bytes (4 KiB), o mínimo é 512 e o máximo é 65536 (64 KiB).

-m crc=VALUE

Os parâmetros iniciados com -m são opções de metadados. Este aqui habilita (se VALUE for 1) ou desabilita (se VALUE for 0) o uso de verificações CRC32c para checar a integridade de todos os metadados no disco. Isso permite uma melhor detecção de erros e recuperação de travamentos relacionados a problemas de hardware e, portanto, ele vem habilitado por padrão. O impacto dessa verificação no desempenho costuma ser mínimo e, portanto, normalmente não há razão para desativá-lo.

-m uuid=VALUE

Define o UUID da partição conforme o especificado em VALUE. Lembre-se de que UUIDs são números de 32 caracteres (128 bits) em base hexadecimal, especificados em grupos de 8, 4, 4, 4 e 12 dígitos separados por hífens, como 1E83E3A3-3AE9-4AAC-BF7E-29DFFECD36C0.

-f

Força a criação de um sistema de arquivos no dispositivo de destino, mesmo se um sistema de arquivos for detectado nele.

-l logdev=DEVICE

Coloca a seção de log do sistema de arquivos no dispositivo especificado, em vez de dentro da seção de dados.

-l size=VALUE

Define o tamanho da seção de log conforme o especificado em VALUE. O tamanho pode ser especificado em bytes, e também é possível usar sufixos como m ou g. -l size=10m, por exemplo, limita a seção de log a 10 Megabytes.

-q

Modo silencioso. Neste modo, o mkfs.xfs não imprime os parâmetros do sistema de arquivos que está sendo criado.

-L LABEL

Define o rótulo do sistema de arquivos, que pode ter no máximo 12 caracteres.

-N

Semelhante ao parâmetro -n do mke2fs, faz com que o mkfs.xfs exiba todos os parâmetros para a criação do sistema de arquivos, sem realmente criá-lo.

Criando um sistema de arquivos FAT ou VFAT

O sistema de arquivos FAT originou-se no MS-DOS e, ao longo dos anos, recebeu muitas revisões, culminando no formato FAT32 lançado em 1996 com o Windows 95 OSR2.

O VFAT é uma extensão do formato FAT16 com suporte para nomes de arquivo longos (até 255 caracteres). Ambos os sistemas de arquivos são controlados pelo mesmo utilitário, mkfs.fat. mkfs.vfat é um nome alternativo para ele.

O sistema de arquivos FAT tem desvantagens importantes que restringem seu uso em discos grandes. O FAT16, por exemplo, suporta volumes de no máximo 4 GB e um tamanho máximo de arquivo de 2 GB. O FAT32 aumenta o tamanho do volume para até 2 PB e o tamanho máximo do arquivo para 4 GB. Por causa disso, os sistemas de arquivos FAT são hoje mais comumente usados em pequenos drives USB ou cartões de memória (de até 2 GB), ou dispositivos e sistemas operacionais legados que não oferecem suporte a sistemas de arquivos mais avançados.

O comando mais básico para a criação de um sistema de arquivos FAT é mkfs.fat TARGET, onde TARGET é a partição em que você deseja que o sistema de arquivos seja criado. Por exemplo: mkfs.fat /dev/sdc1.

Como outros utilitários, o mkfs.fat suporta uma série de opções de linha de comando. Abaixo estão as mais importantes. Uma lista completa com a descrição de cada opção pode ser lida no manual do utilitário, com o comando man mkfs.fat.

-c

Verifica se existem blocos defeituosos no dispositivo de destino antes de criar o sistema de arquivos.

-C FILENAME BLOCK_COUNT

Cria o arquivo especificado em FILENAME e em seguida cria um sistema de arquivos FAT dentro dele, produzindo assim uma “imagem de disco” vazia que pode ser posteriormente gravada em um dispositivo usando um utilitário como o dd ou montada como um dispositivo de loopback. Ao usar esta opção, o número de blocos no sistema de arquivos (BLOCK_COUNT) deve ser especificado após o nome do dispositivo.

-F SIZE

Seleciona o tamanho do FAT (File Allocation Table ou Tabela de Alocação de Arquivos), entre 12, 16 ou 32, ou seja, entre FAT12, FAT16 ou FAT32. Se isso não for especificado, o mkfs.fat seleciona a opção apropriada com base no tamanho do sistema de arquivos.

-n NAME

Define o rótulo do volume, ou nome, do sistema de arquivos. Pode ter até 11 caracteres e o padrão é sem nome.

-v

Modo detalhado. Imprime muito mais informações do que o normal, útil para depuração.

Note

O mkfs.fat não pode criar um sistema de arquivos “iniciável” De acordo com a página de manual, “isso não é tão fácil quanto você pensa” e não será implementado.

Criando um sistema de arquivos exFAT

O exFAT é um sistema de arquivos criado pela Microsoft em 2006 que aborda uma das limitações mais importantes do FAT32: o tamanho do arquivo e do disco. No exFAT, o tamanho máximo do arquivo é de 16 exabytes (no FAT32 eram 4 GB) e o tamanho máximo do disco é de 128 petabytes.

Como é bem suportado pelos três principais sistemas operacionais (Windows, Linux e macOS), trata-se de uma boa escolha nos casos em que a interoperabilidade é necessária, como em drives flash de grande capacidade, cartões de memória e discos externos. Na verdade, esse é o sistema de arquivos padrão, conforme definido pela SD Association, para os cartões de memória SDXC com mais de 32 GB.

O utilitário padrão para criar sistemas de arquivos exFAT é mkfs.exfat, que é um link para mkexfatfs. O comando mais básico é mkfs.exfat TARGET, onde TARGET é a partição em que você deseja que o sistema de arquivos seja criado. Por exemplo: mkfs.exfat /dev/sdb2.

Ao contrário dos outros utilitários discutidos nesta lição, o mkfs.exfat tem pouquíssimas opções de linha de comando. Elas são:

-i VOL_ID

Define o ID do Volume para o valor especificado em VOL_ID. Este é um número hexadecimal de 32 bits. Se não for definido, é criado um ID com base na hora atual.

-n NAME

Define o rótulo ou nome do volume. Pode ter até 15 caracteres e o padrão é sem nome.

-p SECTOR

Especifica o primeiro setor da primeira partição no disco. Este é um valor opcional e o padrão é zero.

-s SECTORS

Define o número de setores físicos por cluster de alocação. Deve ser uma potência de dois, como 1, 2, 4, 8 e assim por diante.

Conhecendo melhor o sistema de arquivos Btrfs

O Btrfs (oficialmente o B-Tree Filesystem: pronuncia-se “Butter FS”, “Better FS” ou mesmo “Butterfuss”, como preferir) é um sistema de arquivos que está em desenvolvimento desde 2007 especificamente para o Linux pela Oracle Corporation e outras empresas, incluindo Fujitsu, Red Hat, Intel e SUSE, entre outras.

Existem muitos recursos que tornam o Btrfs atraente nos sistemas modernos em que é comum haver grandes quantidades de armazenamento. Dentre esses recursos estão o suporte a múltiplos dispositivos (incluindo striping, mirroring e striping + mirroring, como em uma configuração RAID), compressão transparente, otimizações SSD, backups incrementais, instantâneos, desfragmentação online, verificações offline, suporte para subvolumes (com cotas), deduplicação e muito mais.

Por ser um sistema de arquivos cópia em gravação (copy-on-write), ele é muito resistente a travamentos. Além disso, o Btrfs é simples de usar e bem suportado por muitas distribuições Linux. Algumas delas, como o SUSE, o usam como sistema de arquivos padrão.

Note

Em um sistema de arquivos tradicional, quando você deseja sobrescrever parte de um arquivo, os novos dados são colocados diretamente sobre os dados antigos que estão substituindo. Em um sistema de arquivos cópia em gravação os novos dados são gravados para liberar espaço em disco, em seguida os metadados originais do arquivo são atualizados para se referir aos novos dados e somente então os dados antigos são liberados, já que não são mais necessários. Isso reduz as chances de perda de dados em caso de travamento, já que os dados antigos só são descartados depois que o sistema de arquivos tem absoluta certeza de que não são mais necessários e os novos dados estão no lugar.

Criando um sistema de arquivos Btrfs

O utilitário mkfs.btrfs é usado para criar um sistema de arquivos Btrfs. Se o comando for usado sem nenhuma opção, ele cria um sistema de arquivos Btrfs em um determinado dispositivo, assim:

# mkfs.btrfs /dev/sdb1
Tip

Caso não tenha o utilitário mkfs.btrfs em seu sistema, procure por btrfs-progs no gerenciador de pacotes de sua distribuição.

Você pode usar -L para definir um rótulo (ou nome) para o seu sistema de arquivos. Os rótulos Btrfs podem ter até 256 caracteres, exceto por quebras de linha:

# mkfs.btrfs /dev/sdb1 -L "New Disk"
Tip

Coloque o rótulo entre aspas (como acima) se contiver espaços.

O Btrfs tem uma coisa peculiar: é possível incluir múltiplos dispositivos no comando mkfs.btrfs. Quando passamos mais de um dispositivo, o sistema de arquivos se estenderá por todos os dispositivos, numa configuração semelhante à de um RAID ou LVM. Para especificar como os metadados serão distribuídos na matriz de disco, use o parâmetro -m. Os parâmetros válidos são raid0, raid1, raid5, raid6, raid10, single e dup.

Por exemplo, para criar um sistema de arquivos abrangendo /dev/sdb1 e /dev/sdc1, concatenando as duas partições em uma maior, use:

# mkfs.btrfs -d single -m single /dev/sdb /dev/sdc
Warning

Os sistemas de arquivos abrangendo várias partições, como exemplificado acima, podem parecer vantajosos no início, mas não são uma boa ideia do ponto de vista da segurança de dados, pois uma falha em um único disco da matriz implica em perda de dados com certeza. O risco fica maior quanto mais discos você usa, pois também haverá mais pontos de falha possíveis.

Gerenciando subvolumes

Subvolumes são como sistemas de arquivos dentro de sistemas de arquivos. Pense neles como um diretório que pode ser montado (e tratado como) um sistema de arquivos independente. Os subvolumes facilitam a organização e a administração do sistema, pois cada um deles pode ter cotas ou regras de snapshot separadas.

Note

Subvolumes não são partições. Uma partição aloca um espaço fixo em uma unidade. Isso pode levar a problemas mais adiante, como uma partição ficando sem espaço quando outra tem bastante espaço restante. Não é assim com subvolumes, já que eles “compartilham” o espaço livre de seu sistema de arquivos raiz e aumentam conforme necessário.

Suponha que você tenha um sistema de arquivos Btrfs montado em /mnt/disk e deseja criar um subvolume dentro dele para armazenar seus backups. Vamos chamá-lo de BKP:

# btrfs subvolume create /mnt/disk/BKP

A seguir, listamos o conteúdo do sistema de arquivos /mnt/disk. Você verá que temos um novo diretório com o mesmo nome do subvolume.

$ ls -lh /mnt/disk/
total 0
drwxr-xr-x 1 root   root     0 jul 13 17:35 BKP
drwxrwxr-x 1 carol carol 988 jul 13 17:30 Images
Note

Pois é, os subvolumes também podem ser acessados como qualquer outro diretório.

Podemos verificar se o subvolume está ativo com o comando:

# btrfs subvolume show /mnt/disk/BKP/
	Name: 			BKP
	UUID: 			e90a1afe-69fa-da4f-9764-3384f66fa32e
	Parent UUID: 		-
	Received UUID: 		-
	Creation time: 		2019-07-13 17:35:40 -0300
	Subvolume ID: 		260
	Generation: 		23
	Gen at creation: 	22
	Parent ID: 		5
	Top level ID: 		5
	Flags: 			-
	Snapshot(s):

Você pode montar o subvolume em /mnt/BKP passando o parâmetro -t btrfs -o subvol = NAME para o comando mount:

# mount -t btrfs -o subvol=BKP /dev/sdb1 /mnt/bkp
Note

O parâmetro -t especifica o tipo de sistema de arquivos a ser montado.

Trabalhando com instantâneos

Os instantâneos (snapshots) são como subvolumes, mas pré-preenchidos com o conteúdo do volume a partir do qual o instantâneo foi obtido.

Quando criado, um instantâneo e o volume original têm exatamente o mesmo conteúdo. Mas a partir desse momento, eles irão divergir. As alterações feitas no volume original (como arquivos adicionados, renomeados ou excluídos) não serão refletidas no instantâneo e vice-versa.

Lembre-se de que um instantâneo não duplica os arquivos e, inicialmente, praticamente não ocupa espaço em disco. Ele simplesmente duplica a árvore do sistema de arquivos enquanto aponta para os dados originais.

O comando para criar um snapshot é o mesmo usado para criar um subvolume, bastando adicionar o parâmetro snapshot após btrfs subvolume. O comando abaixo cria, em /mnt/disk/snap, um instantâneo do sistema de arquivos Btrfs montado em /mnt/disk:

# btrfs subvolume snapshot /mnt/disk /mnt/disk/snap

Agora, imagine que temos o seguinte conteúdo em /mnt/disk:

$ ls -lh
total 2,8M
-rw-rw-r-- 1 carol carol 109K jul 10 16:22 Galaxy_Note_10.png
-rw-rw-r-- 1 carol carol 484K jul  5 15:01 geminoid2.jpg
-rw-rw-r-- 1 carol carol 429K jul  5 14:52 geminoid.jpg
-rw-rw-r-- 1 carol carol 467K jul  2 11:48 LG-G8S-ThinQ-Mirror-White.jpg
-rw-rw-r-- 1 carol carol 654K jul  2 11:39 LG-G8S-ThinQ-Range.jpg
-rw-rw-r-- 1 carol carol  94K jul  2 15:43 Mimoji_Comparativo.jpg
-rw-rw-r-- 1 carol carol 112K jul 10 16:20 Note10Plus.jpg
drwx------ 1 carol carol  366 jul 13 17:56 snap
-rw-rw-r-- 1 carol carol 118K jul 11 16:36 Twitter_Down_20190711.jpg
-rw-rw-r-- 1 carol carol 324K jul  2 15:22 Xiaomi_Mimoji.png

Observe o diretório de snap que contém o instantâneo. Agora vamos remover alguns arquivos e verificar o conteúdo do diretório:

$ rm LG-G8S-ThinQ-*
$ ls -lh
total 1,7M
-rw-rw-r-- 1 carol carol 109K jul 10 16:22 Galaxy_Note_10.png
-rw-rw-r-- 1 carol carol 484K jul  5 15:01 geminoid2.jpg
-rw-rw-r-- 1 carol carol 429K jul  5 14:52 geminoid.jpg
-rw-rw-r-- 1 carol carol  94K jul  2 15:43 Mimoji_Comparativo.jpg
-rw-rw-r-- 1 carol carol 112K jul 10 16:20 Note10Plus.jpg
drwx------ 1 carol carol  366 jul 13 17:56 snap
-rw-rw-r-- 1 carol carol 118K jul 11 16:36 Twitter_Down_20190711.jpg
-rw-rw-r-- 1 carol carol 324K jul  2 15:22 Xiaomi_Mimoji.png

No entanto, se você verificar dentro do diretório snap, os arquivos excluídos ainda estarão lá e poderão ser restaurados, se necessário.

$ ls -lh snap/
total 2,8M
-rw-rw-r-- 1 carol carol 109K jul 10 16:22 Galaxy_Note_10.png
-rw-rw-r-- 1 carol carol 484K jul  5 15:01 geminoid2.jpg
-rw-rw-r-- 1 carol carol 429K jul  5 14:52 geminoid.jpg
-rw-rw-r-- 1 carol carol 467K jul  2 11:48 LG-G8S-ThinQ-Mirror-White.jpg
-rw-rw-r-- 1 carol carol 654K jul  2 11:39 LG-G8S-ThinQ-Range.jpg
-rw-rw-r-- 1 carol carol  94K jul  2 15:43 Mimoji_Comparativo.jpg
-rw-rw-r-- 1 carol carol 112K jul 10 16:20 Note10Plus.jpg
-rw-rw-r-- 1 carol carol 118K jul 11 16:36 Twitter_Down_20190711.jpg
-rw-rw-r-- 1 carol carol 324K jul  2 15:22 Xiaomi_Mimoji.png

Também é possível criar instantâneos somente leitura. Eles funcionam exatamente como os instantâneos graváveis, com a diferença de que o conteúdo do instantâneo não pode ser alterado, eles são “congelados” no tempo. Basta adicionar o parâmetro -r ao criar o instantâneo:

# btrfs subvolume snapshot -r /mnt/disk /mnt/disk/snap
Algumas palavras sobre compactação

O Btrfs suporta a compactação transparente de arquivos, com três algoritmos diferentes disponíveis para o usuário. Isso é feito automaticamente arquivo por arquivo, contanto que o sistema de arquivos seja montado com a opção -o compress. Os algoritmos são inteligentes o bastante para detectar arquivos incompressíveis e não tentarão compactá-los, economizando recursos do sistema. Assim, em um único diretório, você pode ter arquivos compactados e descompactados juntos. O algoritmo de compressão padrão é o ZLIB, mas o LZO (mais rápido, taxa de compressão pior) ou o ZSTD (mais rápido que o ZLIB, compressão comparável) estão disponíveis, com diversos níveis de compressão (veja o objetivo correspondente nas opções de montagem).

Gerenciando Partições com o GNU Parted

O GNU Parted é um editor de partição muito poderoso (daí o nome) que pode ser usado para criar, excluir, mover, redimensionar, resgatar e copiar partições. Ele trabalha com discos GPT e MBR e é capaz de cobrir quase todas as suas necessidades de gerenciamento de disco.

Existem muitos front-ends gráficos que tornam o trabalho com o parted muito mais fácil, como o GParted para ambientes de desktop baseados no GNOME e o KDE Partition Manager para desktops KDE. No entanto, você deve aprender a usar o parted na linha de comando, já que em uma configuração de servidor nunca podemos contar com a presença de um ambiente gráfico.

Warning

Diferente de fdisk e gdisk, o parted faz alterações no disco imediatamente após o comando ser emitido, sem esperar por outro comando para gravar as alterações. Ao praticar, é aconselhável fazê-lo em um disco ou unidade flash vazio ou sobressalente, para que não haja risco de perda de dados caso você cometa um erro.

A maneira mais simples de começar a usar o parted é digitando parted DEVICE, onde DEVICE é o dispositivo que se deseja gerenciar (parted /dev/sdb). O programa inicia uma interface de linha de comando interativa, como fdisk e gdisk, com um prompt (parted) para você inserir os comandos.

# parted /dev/sdb
GNU Parted 3.2
Using /dev/sdb
Welcome to GNU Parted! Type 'help' to view a list of commands.

(parted)
Warning

Tenha cuidado! Se você não especificar um dispositivo, o parted seleciona automaticamente o disco primário (normalmente /dev/sda) para operar.

Selecionando discos

Para mudar para um disco diferente do especificado na linha de comando, usamos o comando select, seguido pelo nome do dispositivo:

(parted) select /dev/sdb
Using /dev/sdb

Obtendo informações

O comando print pode ser usado para obter mais informações sobre uma partição específica ou até mesmo todos os dispositivos de bloco (discos) conectados ao seu sistema.

Para obter informações sobre a partição atualmente selecionada, basta digitar print:

(parted) print
Model: ATA CT120BX500SSD1 (scsi)
Disk /dev/sda: 120GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:

Number  Start   End    Size    Type     File system     Flags
 1      2097kB  116GB  116GB   primary  ext4
 2      116GB   120GB  4295MB  primary  linux-swap(v1)

Use print devices para obter uma lista de todos os dispositivos de bloco conectados ao seu sistema:

(parted) print devices
/dev/sdb (1999MB)
/dev/sda (120GB)
/dev/sdc (320GB)
/dev/mapper/cryptswap (4294MB)

Para obter informações sobre todos os dispositivos conectados de uma vez, usamos print all. Se quiser saber quanto espaço livre existe em cada um deles, o comando é print free:

(parted) print free
Model: ATA CT120BX500SSD1 (scsi)
Disk /dev/sda: 120GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:

Number  Start   End     Size    Type     File system     Flags
        32.3kB  2097kB  2065kB           Free Space
 1      2097kB  116GB   116GB   primary  ext4
        116GB   116GB   512B             Free Space
 2      116GB   120GB   4295MB  primary  linux-swap(v1)
        120GB   120GB   2098kB           Free Space

Criando uma tabela de partição em um disco vazio

Para criar uma tabela de partição em um disco vazio, use o comando mklabel, seguido pelo tipo de tabela de partição que deseja usar.

Existem muitos tipos suportados de tabelas de partição, mas os principais que você deve conhecer são msdos, usado aqui para se referir a uma tabela de partição MBR, e gpt para se referir a uma tabela de partição GPT. Para criar uma tabela de partição MBR, digite:

(parted) mklabel msdos

E para criar uma tabela de partição GPT, o comando é:

(parted) mklabel gpt

Criando uma partição

Para criar uma partição, usamos o comando mkpart com a sintaxe mkpart PARTTYPE FSTYPE START END, onde:

PARTTYPE

É o tipo de partição, que pode ser primary, logical ou extended no caso de uma tabela de partição MBR.

FSTYPE

Especifica qual sistema de arquivos será usado nesta partição. Note que parted não cria o sistema de arquivos. Ele apenas define um sinalizador na partição que informa ao sistema operacional que tipo de dados esperar dela.

START

Especifica o ponto exato no dispositivo onde a partição começa. Você pode usar unidades diferentes para especificar esse ponto. 2s pode ser usado para se referir ao segundo setor do disco, ao passo que 1m se refere ao início do primeiro megabyte do disco. Outras unidades comuns são B (bytes) e % (porcentagem do disco).

END

Especifica o fim da partição. Observe que este não é o tamanho da partição, este é o ponto no disco onde ele termina. Por exemplo, se você especificar 100m, a partição terminará 100 MB após o início do disco. Podemos usar as mesmas unidades do parâmetro START.

Assim, o comando:

(parted) mkpart primary ext4 1m 100m

Cria uma partição primária do tipo ext4, começando no primeiro megabyte do disco e terminando após o 100º megabyte.

Removendo uma partição

Para remover uma partição, use o comando rm seguido pelo número da partição, que você pode exibir usando o comando print. Portanto, rm 2 removeria a segunda partição no disco atualmente selecionado.

Recuperando partições

O parted é capaz de recuperar uma partição excluída. Considere que temos a seguinte estrutura de partição:

Number  Start   End     Size    File system  Name     Flags
 1      1049kB  99.6MB  98.6MB  ext4         primary
 2      99.6MB  200MB   100MB   ext4         primary
 3      200MB   300MB   99.6MB  ext4         primary

Por acidente, você removeu a partição 2 usando rm 2. Para recuperá-la, pode-se usar o comando rescue, com a sintaxe rescue START END, onde START é o local aproximado onde a partição começava e END o local aproximado onde terminava.

O parted irá analisar o disco em busca de partições e se oferecer para restaurar as que forem encontradas. No exemplo acima, a partição 2 começava em 99,6 MB e terminava em 200 MB. Portanto, você pode usar o seguinte comando para recuperar a partição:

(parted) rescue 90m 210m
Information: A ext4 primary partition was found at 99.6MB -> 200MB.
Do you want to add it to the partition table?

Yes/No/Cancel? y

A partição e seu conteúdo serão recuperados dessa forma. Note que o rescue só pode recuperar partições em que haja um sistema de arquivos instalado. Partições vazias não são detectadas.

Redimensionando partições ext2/3/4

O parted pode ser usado para redimensionar partições, tornando-as maiores ou menores. No entanto, existem algumas ressalvas:

  • Durante o redimensionamento, a partição deve estar desmontada e não estar em uso.

  • É preciso ter espaço livre suficiente após a partição para que ela possa ser ampliada no tamanho que se deseja.

O comando é resizepart, seguido pelo número da partição e o ponto onde deve terminar. Por exemplo, se tivermos a seguinte tabela de partição:

Number  Start   End     Size    File system  Name     Flags
 1      1049kB  99.6MB  98.6MB  ext4         primary
 2      99.6MB  200MB   100MB   ext4
 3      200MB   300MB   99.6MB  ext4         primary

Se tentarmos aumentar a partição 1 usando resizepart, uma mensagem de erro seria disparada, já que, com o novo tamanho, a partição 1 se sobreporia à partição 2. No entanto, a partição 3 pode ser redimensionada, já que há espaço livre depois dela, o que pode ser verificado com o comando print free:

(parted) print free
Model: Kingston DataTraveler 2.0 (scsi)
Disk /dev/sdb: 1999MB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:

 Number  Start   End     Size    File system  Name     Flags
        17.4kB  1049kB  1031kB  Free Space
 1      1049kB  99.6MB  98.6MB  ext4         primary
 2      99.6MB  200MB   100MB   ext4
 3      200MB   300MB   99.6MB  ext4         primary
        300MB   1999MB  1699MB  Free Space

Portanto, podemos usar o seguinte comando para redimensionar a partição 3 para 350 MB:

(parted) resizepart 3 350m

(parted) print
Model: Kingston DataTraveler 2.0 (scsi)
Disk /dev/sdb: 1999MB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:

Number  Start   End     Size    File system  Name     Flags
 1      1049kB  99.6MB  98.6MB  ext4         primary
 2      99.6MB  200MB   100MB   ext4
 3      200MB   350MB   150MB   ext4         primary

Lembre-se de que o novo ponto final é especificado a partir do início do disco. Então, como a partição 3 terminava em 300 MB, agora ela precisa terminar em 350 MB.

Mas redimensionar a partição é apenas parte da tarefa. Você também precisa redimensionar o sistema de arquivos que reside nela. Para sistemas de arquivos ext2/3/4, isso é feito com o comando resize2fs. No caso do exemplo acima, a partição 3 ainda mostra o tamanho “antigo” quando montada:

$ df -h /dev/sdb3
Filesystem      Size  Used Avail Use% Mounted on
/dev/sdb3        88M  1.6M   80M   2% /media/carol/part3

Para ajustar o tamanho, o comando resize2fs DEVICE SIZE pode ser usado, onde DEVICE corresponde à partição que você deseja redimensionar e SIZE é o novo tamanho. Se você omitir o parâmetro de tamanho, ele usará todo o espaço disponível da partição. Antes de redimensionar, é aconselhável desmontar a partição.

No exemplo acima:

$ sudo resize2fs /dev/sdb3
resize2fs 1.44.6 (5-Mar-2019)
Resizing the filesystem on /dev/sdb3 to 146212 (1k) blocks.
The filesystem on /dev/sdb3 is now 146212 (1k) blocks long.

$ df -h /dev/sdb3
Filesystem      Size  Used Avail Use% Mounted on
/dev/sdb3       135M  1.6M  123M   2% /media/carol/part3

Para encolher uma partição, o processo deve ser feito na ordem inversa. Primeiro você redimensiona o sistema de arquivos para um tamanho novo e menor, em seguida redimensiona a própria partição usando parted.

Warning

Preste atenção ao reduzir partições. Se errar na ordem das coisas, você vai perder dados!

Em nosso exemplo:

# resize2fs /dev/sdb3 88m
resize2fs 1.44.6 (5-Mar-2019)
Resizing the filesystem on /dev/sdb3 to 90112 (1k) blocks.
The filesystem on /dev/sdb3 is now 90112 (1k) blocks long.

# parted /dev/sdb3
(parted) resizepart 3 300m
Warning: Shrinking a partition can cause data loss, are you sure
you want to continue?

Yes/No? y

(parted) print
Model: Kingston DataTraveler 2.0 (scsi)
Disk /dev/sdb: 1999MB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:

Number  Start   End     Size    File system  Name     Flags
 1      1049kB  99.6MB  98.6MB  ext4         primary
 2      99.6MB  200MB   100MB   ext4
 3      200MB   300MB   99.7MB  ext4         primary
Tip

Em vez de especificar um novo tamanho, você pode usar o parâmetro -M de resize2fs para ajustar o tamanho do sistema de arquivos, deixando-o grande o suficiente para os arquivos que contém.

Criando partições de troca

No Linux, o sistema pode passar páginas de memória da RAM para o disco conforme necessário, armazenando-as em um espaço separado, geralmente implementado como uma partição separada em um disco, chamada de partição de troca ou simplesmente troca (swap, em inglês). Esta partição precisa ser de um tipo específico e configurada com um utilitário apropriado (mkswap) antes de poder ser usada.

Para criar a partição swap usando fdisk ou gdisk, proceda como se estivesse criando uma partição normal, conforme explicado anteriormente. A única diferença é que você precisará alterar o tipo de partição para Linux swap.

  • No fdisk, use o comando t. Selecione a partição que deseja usar e mude seu tipo para 82. Grave as alterações no disco e saia com w.

  • No gdisk, o comando para alterar o tipo de partição também é t, mas o código é 8200. Grave as alterações no disco e saia com w.

Se estiver usando o parted, a partição deve ser identificada como uma partição de troca durante a criação, apenas use linux-swap como tipo de sistema de arquivos. Por exemplo, o comando para criar uma partição de troca de 500 MB, começando com 300 MB no disco é:

(parted) mkpart primary linux-swap 301m 800m

Assim que a partição for criada e devidamente identificada, basta usar mkswap seguido do dispositivo que representa a partição que deseja usar, como:

# mkswap /dev/sda2

Para habilitar a troca nesta partição, use swapon seguido do nome do dispositivo:

# swapon /dev/sda2

Da mesma forma, swapoff, seguido pelo nome do dispositivo, desabilita a troca naquele dispositivo.

O Linux também suporta o uso de arquivos de troca em vez de partições. Basta criar um arquivo vazio do tamanho que desejar usando dd e então usar mkswap e swapon tendo esse arquivo como destino.

Os comandos a seguir criam um arquivo de 1 GB chamado myswap no diretório atual, preenchido com zeros, e então o configuram e habilitam como um arquivo de troca.

Crie o arquivo de troca:

$ dd if=/dev/zero of=myswap bs=1M count=1024
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 7.49254 s, 143 MB/s

if = é o arquivo de entrada, a fonte dos dados que serão gravados no arquivo. Neste caso, é o dispositivo /dev/zero, que fornece tantos caracteres NULL quanto solicitados. of = é o arquivo de saída, o arquivo que será criado. bs = é o tamanho dos blocos de dados, especificados aqui em Megabytes, e count = é a quantidade de blocos a serem gravados na saída. 1.024 blocos de 1 MB cada equivalem a 1 GB.

# mkswap myswap
Setting up swapspace version 1, size = 1024 MiB (1073737728 bytes)
no label, UUID=49c53bc4-c4b1-4a8b-a613-8f42cb275b2b

# swapon myswap

Usando os comandos acima, este arquivo de troca será usado apenas durante a sessão atual do sistema. Se a máquina for reinicializada, o arquivo ainda estará disponível, mas não será carregado automaticamente. Você pode automatizar esse processo adicionando o novo arquivo de troca a /etc/fstab, que discutiremos em uma lição posterior.

Tip

Tanto o mkswap quanto o swapon vão reclamar se seu arquivo de troca tiver permissões inseguras. O sinalizador de permissão de arquivo recomendado é 0600. O proprietário e o grupo devem ser root.

Exercícios Guiados

  1. Qual esquema de particionamento deve ser usado para particionar um disco rígido de 3 TB em três partições de 1 GB? Por quê?

  2. No gdisk, como podemos descobrir quanto espaço está disponível no disco?

  3. Qual seria o comando para criar um sistema de arquivos ext3, verificando antes se há setores defeituosos, com o rótulo MyDisk e um UUID aleatório, no dispositivo /dev/sdc1?

  4. Usando o parted, qual seria o comando para criar uma partição ext4 de 300 MB, começando com 500 MB no disco?

  5. Imagine que você tenha 2 partições, uma em /dev/sda1 e outra em /dev/sda2, ambas com 20 GB de tamanho. Como você pode usá-las em um único sistema de arquivos Btrfs, de forma que o conteúdo de uma partição seja automaticamente espelhado na outra, como em uma configuração RAID1? Qual será o tamanho do sistema de arquivos?

Exercícios Exploratórios

  1. Considere um disco de 2 GB com uma tabela de partição MBR e o seguinte layout:

    Disk /dev/sdb: 1.9 GiB, 1998631936 bytes, 3903578 sectors
    Disk model: DataTraveler 2.0
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: dos
    Disk identifier: 0x31a83a48
    
    Device     Boot   Start     End Sectors  Size Id Type
    /dev/sdb1          2048 1050623 1048576  512M 83 Linux
    /dev/sdb3       2099200 3147775 1048576  512M 83 Linux

    É possível criar uma partição de 600 MB nele? Por quê?

  2. Em um disco em /dev/sdc, temos uma primeira partição de 1 GB contendo cerca de 256 MB de arquivos. Usando parted, como podemos reduzi-la para que tenha somente espaço suficiente para os arquivos?

  3. Imagine que você tem um disco em /dev/sdb e deseja criar uma partição swap de 1 GB no início dele. Assim, usando parted, você cria a partição com mkpart primary linux-swap 0 1024M. A seguir, você habilita o swap (troca) nesta partição com swapon /dev/sdb1, mas obtém a seguinte mensagem de erro:

    swapon: /dev/sdb1: read swap header failed

    O que deu errado?

  4. Ao longo desta lição, você experimentou alguns comandos no parted mas, por engano, excluiu a 3ª partição do seu disco rígido. Você sabe que ela vinha depois de uma partição UEFI de 250 MB e de uma partição de troca de 4 GB, e tinha 10 GB de tamanho. Qual comando você pode usar para recuperá-la?

  5. Imagine que você tenha uma partição não utilizada de 4 GB em /dev/sda3. Usando fdisk, qual seria a sequência de operações para transformá-lo em uma partição swap ativa?

Resumo

Nesta lição, você aprendeu:

  • Como criar uma tabela de partição MBR em um disco com fdisk e como usá-la para criar e deletar partições.

  • Como criar uma tabela de partição MBR em um disco com gdisk e como usá-la para criar e deletar partições.

  • Como criar partições ext2, ext3, ext4, XFS, VFAT e exFAT.

  • Como usar o parted para criar, excluir e recuperar partições em discos MBR e GPT.

  • Como usar e redimensionar partições ext2, ext3, ext4 e Brts.

  • Como criar, configurar e ativar partições de swap e arquivos de swap.

Os seguintes comandos foram abordados nesta lição:

  • fdisk

  • gdisk

  • mkfs.ext2, mkfs.ext3, mkfs.ext4, mkfs.xfs, mkfs.vfat e mkfs.exfat

  • parted

  • btrfs

  • mkswap

  • swapon e swapoff

Respostas aos Exercícios Guiados

  1. Qual esquema de particionamento deve ser usado para particionar um disco rígido de 3 TB em três partições de 1 GB? Por quê?

    GPT, já que o MBR suporta discos rígidos de no máximo 2 TB.

  2. No gdisk, como podemos descobrir quanto espaço está disponível no disco?

    Usamos p (print). O espaço livre total será mostrado como a última linha de informação antes da própria tabela de partição.

  3. Qual seria o comando para criar um sistema de arquivos ext3, verificando antes se há setores defeituosos, com o rótulo MyDisk e um UUID aleatório, no dispositivo /dev/sdc1?

    O comando seria mkfs.ext3 -c -L MyDisk -U random /dev/sdc1. Também seria possível usar mke2fs -t ext3 em vez de mkfs.ext3.

  4. Usando o parted, qual seria o comando para criar uma partição ext4 de 300 MB, começando com 500 MB no disco?

    O comando seria mkpart primary ext4 500m 800m. Lembre-se de que é necessário criar o sistema de arquivos usando mkfs.ext4, já que o parted não faz isso.

  5. Imagine que você tenha 2 partições, uma em /dev/sda1 e outra em /dev/sda2, ambas com 20 GB de tamanho. Como você pode usá-las em um único sistema de arquivos Btrfs, de forma que o conteúdo de uma partição seja automaticamente espelhado na outra, como em uma configuração RAID1? Qual será o tamanho do sistema de arquivos?

    O comando seria mkfs.btrfs /dev/sda1 /dev/sdb1 -m raid1. O sistema de arquivos resultante teria um tamanho de 20 GB, já que uma partição age simplesmente como um espelho da outra.

Respostas aos Exercícios Exploratórios

  1. Considere um disco de 2 GB com uma tabela de partição MBR e o seguinte layout:

    Disk /dev/sdb: 1.9 GiB, 1998631936 bytes, 3903578 sectors
    Disk model: DataTraveler 2.0
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: dos
    Disk identifier: 0x31a83a48
    
    Device     Boot   Start     End Sectors  Size Id Type
    /dev/sdb1          2048 1050623 1048576  512M 83 Linux
    /dev/sdb3       2099200 3147775 1048576  512M 83 Linux

    É possível criar uma partição de 600 MB nele? Por quê?

    Não, pois não há espaço contíguo suficiente. A primeira pista de que tem algo “errado” é a lista de dispositivos: temos /dev/sdb1 e /dev/sdb3, mas não /dev/sdb2. Então, algo está faltando.

    Em seguida, precisamos ver onde uma partição termina e onde a outra começa. A partição um termina no setor 1050623, e a partição 2 no 2099200. Há uma “lacuna” de 1048577 setores. Como cada setor tem 512 bytes, o total seriam 536.871.424 bytes. Dividindo por 1024, obtemos 524.288 Kilobytes. Dividimos por 1024 novamente e obtemos…​ 512 MB. Esse é o tamanho da “lacuna”.

    Se o disco tem 2 GB, resta então um máximo de 512 MB após a partição 3. Mesmo que no total haja cerca de 1 GB não-alocado, o maior bloco contíguo tem 512 MB. Portanto, não há espaço para uma partição de 600 MB.

  2. Em um disco em /dev/sdc, temos uma primeira partição de 1 GB contendo cerca de 256 MB de arquivos. Usando parted, como podemos reduzi-la para que tenha somente espaço suficiente para os arquivos?

    Essa operação teria várias etapas. Primeiro, encolhemos o sistema de arquivos usando resize2fs. Ao invés de especificar o novo tamanho diretamente, podemos usar o parâmetro -M para que ele fique “grande o bastante”. Assim: resize2fs -M /dev/sdc1.

    Em seguida, redimensionamos a própria partição com o parted usando resizepart. Como se trata da primeira partição, podemos pressupor que ela começa em zero e termina em 241 MB. Assim, o comando seria resizepart 1 241M.

  3. Imagine que você tem um disco em /dev/sdb e deseja criar uma partição swap de 1 GB no início dele. Assim, usando parted, você cria a partição com mkpart primary linux-swap 0 1024M. A seguir, você habilita o swap (troca) nesta partição com swapon /dev/sdb1, mas obtém a seguinte mensagem de erro:

    swapon: /dev/sdb1: read swap header failed

    O que deu errado?

    Você criou uma partição do tipo correto (linux-swap), mas lembre-se de que o mkpart não cria um sistema de arquivos. Você esqueceu de configurar a partição como espaço de troca com mkswap antes de usá-la.

  4. Ao longo desta lição, você experimentou alguns comandos no parted mas, por engano, excluiu a 3ª partição do seu disco rígido. Você sabe que ela vinha depois de uma partição UEFI de 250 MB e de uma partição de troca de 4 GB, e tinha 10 GB de tamanho. Qual comando você pode usar para recuperá-la?

    Não entre em pânico, você tem todas as informações necessárias para recuperar a partição. Basta usar rescue e fazer as contas. Você tinha 250 MB + 4096 MB (4*1024) antes, então o ponto inicial deve ser em torno de 4346 MB. Juntando com 10.240 MB (10*1024) de tamanho, ela deve terminar em 14.586 MB. Então, rescue 4346m 14586m deve resolver o problema. Pode ser preciso dar um pouco de “folga” ao rescue, começando um pouco antes e terminando um pouco depois, dependendo da geometria do seu disco.

  5. Imagine que você tenha uma partição não utilizada de 4 GB em /dev/sda3. Usando fdisk, qual seria a sequência de operações para transformá-lo em uma partição swap ativa?

    Primeiro, altere o tipo de partição para “Linux Swap” (82), grave suas alterações no disco e saia. Depois, use mkswap para configurar a partição como área de troca. Em seguida, use swapon para habilitá-la.

Linux Professional Insitute Inc. Todos os direitos reservados. Visite o site dos Materiais Didáticos: https://learning.lpi.org
31/5000 Este trabalho está licenciado sob a Licença Creative Commons Atribuição-Uso Não-Comercial-NãoDerivativos 4.0 Internacional.

Próxima Lição

104.2 Manutenção da integridade de sistemas de arquivos (104.2 Lição 1)

Ir para a próxima lição

Linux Professional Insitute Inc. Todos os direitos reservados. Visite o site dos Materiais Didáticos: https://learning.lpi.org
31/5000 Este trabalho está licenciado sob a Licença Creative Commons Atribuição-Uso Não-Comercial-NãoDerivativos 4.0 Internacional.

A LPI é uma organização sem fins lucrativos.

© 2023 O Linux Professional Institute (LPI) é um organismo de apoio aos profissionais de Open Source e referência mundial em certificação. Com mais de 200.000 pessoas certificadas, somos o principal organismo de certificação independente para Linux e Open Source do mundo. O LPI certificou profissionais de mais de 180 países, oferece exames em diversos idiomas e tem centenas de parcerias de formação em todo o globo.

Nossa missão é proporcionar oportunidades econômicas e criativas para todos, tornando universalmente acessível a certificação de conhecimentos e competências em matéria de Open Source.

  • LinkedIn
  • flogo-RGB-HEX-Blk-58 Facebook
  • Twitter
  • Entre em Contato
  • Política de Privacidade e Cookies

Encontrou um erro ou quer ajudar a aprimorar esta página? Escreva pra nós.

© 1999–2023 The Linux Professional Institute Inc. Todos os direitos reservados.