Jump to content

# LVM (Português)

From ArchWiki
Status de tradução: Esse artigo é uma tradução de LVM. Data da última tradução: 2025-01-20. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglês.

Artigos relacionados

- Software RAID and LVM
- LUKS dentro do LVM
- Instalar Arch Linux em LVM
- Resizing LVM-on-LUKS
- Create root filesystem snapshots with LVM

De Wikipédia: Gerenciador de Volume Lógico (Linux):

  O Gerenciador de Volume Lógico (LVM) é um mapeador de dispositivos que fornece gerenciamento de volume lógico para o kernel Linux.

## Conceitos básicos

### Blocos de construção do LVM

O gerenciador de volumes lógicos (LVM) utiliza um recurso do kernel chamado de mapeador de dispositivo (do inglês device mapper) para fornecer um sistema de partições independente do layout subjacente do disco. Com o LVM você abstrai seu dispositivo de armazenamento e passa a ter "partições virtuais", tornando a tarefa de estender/diminuir volumes mais fácil (embora isto esteja sujeito a potenciais limitações do sistema de arquivos).

Partições virtuais permitem adição e remoção sem a preocupação de haver ou não espaço contíguo suficiente em um disco em particular. Evita aquelas situações de tentar manipular partições pelo fdisk com um disco em uso (e ficar com apreensão imaginando se o kernel está usando a tabela de partições nova ou velha), ou ainda, precisar mover outras partições para outras regiões ao longo do disco.

Construção básica dos blocos pelo LVM:

Volume físico ou Physical Volume (PV)
  Um node de dispositivo em bloco Unix, usável para armazenamento pelo LVM. Exemplos: um disco rígido, uma partição MBR ou GPT, um arquivo de loopback, um mapeador de dispositivo (por exemplo, dm-crypt). É responsável por hospedar um cabeçalho do LVM.
Grupo de volume ou Volume Group (VG)
  Grupo de PVs que serve como contêiner para LVs (volumes lógicos, de Logical Volumes). PEs (Phisical Extents, ou extensões físicas são alocadas de um VG para um LV).
Volume lógico ou Logical Volume (LV)
  Uma partição virtual/lógica que reside em um VG e é composta de PEs. LVs são dispositivos de bloco Unix análogos a partições físicas, ou seja, podem ser diretamente formatadas com um sistema de arquivos.
Extensão física ou Physical Extent (PE)
  A menor extensão física contígua (4 MiB, por padrão) em um PV que pode ser atribuída para um LV. Pense em PEs como sendo partes de PVs que podem ser alocadas para qualquer LV.

Exemplo:

    Discos físicos

      Disco1 (/dev/sda):
        ┌──────────────────────────────────────┬─────────────────────────────────────┐
        │ Partição1  50 GiB (Volume físico)    │ Partição2 80 GiB (Volume físico)    │
        │ /dev/sda1                            │ /dev/sda2                           │
        └──────────────────────────────────────┴─────────────────────────────────────┘

      Disco2 (/dev/sdb):
        ┌──────────────────────────────────────┐
        │ Partição1 120 GiB (Volume físico)    │
        │ /dev/sdb1                            │
        └──────────────────────────────────────┘

    Volumes lógicos do LVM

      Grupo de volume1 (/dev/MeuGrupoVol/ = /dev/sda1 + /dev/sda2 + /dev/sdb1):
        ┌─────────────────────────┬─────────────────────────┬──────────────────────────┐
        │ Volume lógico1 15 GiB   │ Volume lógico2 35 GiB   │ Volume lógico3 200 GiB   │
        │ /dev/MeuGrupoVol/rootvol│ /dev/MeuGrupoVol/homevol│ /dev/MeuGrupoVol/mediavol│
        └─────────────────────────┴─────────────────────────┴──────────────────────────┘

Nota Volumes lógicos são acessíveis tanto como `/dev/NomeGrupoVolume/NomeVolumeLogico` quanto pelo formato `/dev/mapper/NomeGrupoVolume-NomeVolumeLogico`. Porém lvm(8) § VALID NAMES recomenda o primeiro formato para "softwares e scripts" (por exemplo fstab), pois o segundo é destinado ao "uso interno" e está sujeito a possivelmente "mudar entre lançamentos e distribuições".

### Vantagens

O LVM proporciona mais flexibilidade do que usar partições normais no disco rígido, pois permite:

- Usar qualquer quantidade de discos como se fosse um único grande disco;
- Ter volumes lógicos estendidos sobre vários discos (Como em RAID, que os volumes podem espelhar ou distribuir dados entre os discos. Tais opções podem oferecer vantagens como resiliência adicional e desempenho [1]);
- Criar pequenos volumes lógicos e estendê-los "dinamicamente" à medida em que eles forem ficando cheios;
- Redimensionar volumes lógicos independentemente da ordem que estão dispostos fisicamente no disco. Isto não depende da posição do LV dentro do VG, não havendo nem mesmo necessidade de liberar espaço disponível ao redor destes;
- Redimensionar/criar/excluir volumes lógicos e físicos online. Os sistemas de arquivos neles ainda precisam ser redimensionados, mas alguns (como Ext4 e Btrfs) suportam redimensionamento online;
- Migração de um LV (ou segmentos) em uso online/em tempo real por serviços para diferentes discos sem necessidade de reinicializar os serviços;
- Criação de snapshots que permitem o backup de uma cópia congelada de um sistema de arquivos, ao mesmo tempo que minimiza o tempo de indisponibilidade dos serviços e o snapshot pode ser facilmente mesclado/fundido ao volume original mais tarde;
- Suporte ao desbloqueio de volumes criptografados separados, sem necessidade de informar uma chave múltiplas vezes durante o boot ao criar um LVM dentro do LUKS;
- Suporte integrado de criação de cache dos dados usados frequentemente (lvmcache(7));

### Desvantagens

- Etapas adicionais em configurar o sistema (provavelmente requerendo ajustes na configuração de mkinitcpio) tornam o processo mais complicado. Precisa executar constantemente (múltiplos) daemons;

- Em dual boot, note que o Windows não suporta LVM; é impossibilitado o acesso de quaisquer partições LVM à partir do Windows. Softwares de terceiros talvez permitam a montagem de certos tipos de sistemas configurados com LVM; [2]

- Se seus volumes físicos não estão em uma RAID-1, RAID-5 ou RAID-6 um dos discos pode perder um ou mais volumes lógicos se você espalhar (ou expandir) seus volumes lógicos entre múltiplos discos não redundantes;

- Não é sempre fácil encolher o espaço usado pelo gerenciador de volumes lógicos, no caso os volumes físicos usados para os volumes lógicos. Se as extensões físicas são dispersas pelo volume físico até o final, você pode precisar inspecionar os segmentos e movê-los (potencialmente para outro dispositivo físico), ou mover o mesmo dispositivo com a alocação personalizada (por exemplo, `--alloc anywhere`). Se você quiser configurar dual boot com outros sistemas operacionais (em exemplo o Microsoft Windows), o único espaço restante no dispositivo com Microsoft Windows será o espaço não usado pelo LVM, ou o que não foi usado como um volume físico;

- Potencial piora de desempenho em comparação às partições simples; [3]

- Pode não funcionar bem com todos os sistema de arquivos, especialmente aqueles projetados para gestão de vários dispositivos. Por exemplo, Btrfs oferece algumas das mesmas funcionalidades (suporte a múltiplos dispositivos , (sub)volumes, snapshots e RAID), e com isso pode existir conflito (leia com mais profundidade sobre os problemas com snapshots em LVM com Btrfs);

## Instalação

Certifique-se que o pacote lvm2 está instalado.

Se você tem volumes LVM não ativados via initramfs, ative o `lvm2-monitor.service`, do qual é fornecido pelo pacote lvm2.

## Operações com volumes

### Volumes físicos

#### Criação

Ao criar o PV em `/dev/sda1`, execute:

    # pvcreate /dev/sda1

Você pode verificar se o PV foi criado ao usar o seguinte comando:

    # pvs

#### Expansão

Ao estender, ou antes de reduzir, o tamanho de um dispositivo que possui um volume físico sobre ele, você precisará expandir ou encolher o PV usando pvresize(8).

Para expandir o PV em `/dev/sda1`, logo após de aumentar a partição, execute:

    # pvresize /dev/sda1

Com isso será automaticamente detectado o novo tamanho do dispositivo, e por fim o PV irá estender ao seu máximo.

Nota Este comando pode ser usado enquanto o volume estiver online.

#### Encolhimento

Para encolher um volume físico antes de reduzir seu dispositivo subjacente, adicione os parâmetros `--setphysicalvolumesize tamanho_aqui` no comando. Em exemplo:

    # pvresize --setphysicalvolumesize 40G /dev/sda1

O comando acima talvez mostre-lhe o seguinte erro:

    /dev/sda1: cannot resize to 25599 extents as later ones are allocated.
    0 physical volume(s) resized / 1 physical volume(s) not resized

Ou de forma traduzida:

    /dev/sda1: não foi possível redimensionar para 25599 extensões, pois há extensões posteriormente já alocadas.
    0 volume(s) físico(s) redimensionados / 1 volume(s) físico(s) não redimensionado(s).

Realmente, pvresize se negará a encolher um PV se o mesmo estiver com as extensões alocadas após o local que as novas últimas alocações do volume deveriam estar. É necessário executar pvmove de antemão para realocá-las em outro lugar no grupo de volume, e para tal deve haver espaço livre disponível.

##### Movendo extensões físicas

Antes de liberar as extensões físicas que estão no final do volume, deve-se executar `pvdisplay -v -m` para vê-las. Uma alternativa seria ver os segmentos de forma tabular com `pvs --segments -v`.

No exemplo abaixo, há um volume físico em `/dev/sdd1`, um grupo de volume como `vg1` e um volume lógico chamado `backup`.

    # pvdisplay -v -m

        Finding all volume groups.
        Using physical volume(s) on command line.
      --- Physical volume ---
      PV Name               /dev/sdd1
      VG Name               vg1
      PV Size               1.52 TiB / not usable 1.97 MiB
      Allocatable           yes
      PE Size               4.00 MiB
      Total PE              399669
      Free PE               153600
      Allocated PE          246069
      PV UUID               MR9J0X-zQB4-wi3k-EnaV-5ksf-hN1P-Jkm5mW

      --- Physical Segments ---
      Physical extent 0 to 153600:
        FREE
      Physical extent 153601 to 307199:
        Logical volume	/dev/vg1/backup
        Logical extents	1 to 153599
      Physical extent 307200 to 307200:
        FREE
      Physical extent 307201 to 399668:
        Logical volume	/dev/vg1/backup
        Logical extents	153601 to 246068

Observe que o espaço sinalizado como `FREE` foi distribuído para outro local ao longo do volume. Nós devemos primeiramente mover todos os segmentos usados para o começo do volume.

Aqui o primeiro segmento livre é de 0 a 153600, desta forma são 153601 extensões livres. Nós agora podemos mover esse número de segmentos da última extensão física para a primeira extensão. O comando portanto será:

    # pvmove --alloc anywhere /dev/sdd1:307201-399668 /dev/sdd1:0-92467

    /dev/sdd1: Moved: 0.1 %
    /dev/sdd1: Moved: 0.2 %
    ...
    /dev/sdd1: Moved: 99.9 %
    /dev/sdd1: Moved: 100.0 %

Nota

- Este comando move 399668 - 307201 + 1 = 92468 PEs do último segmento até o primeiro segmento. Isto é possível porque o primeiro segmento contém 153600 PEs livres, do qual pode alocar os PEs movidos, ou seja, 92467 - 0 + 1 = 92468.
- A opção `--alloc anywhere` é usada enquanto movemos os PEs para dentro da mesma partição. Em caso de diferentes partições, o comando pode parecer-se com:

      # pvmove /dev/sdb1:1000-1999 /dev/sdc1:0-999

- A execução deste comando pode demorar (entre uma a duas horas) em caso de volumes extensos. É provável que seja uma boa ideia executar o comando em um tmux ou em uma sessão de GNU Screen. Qualquer parada indesejada do processo é capaz de ser fatal.
- Quando a operação for concluída, execute fsck para averiguar se o seu sistema de arquivos é válido.

##### Redimensionando um volume físico

Uma vez que todos os segmentos físicos livres estejam nas últimas extensões físicas, execute `vgdisplay` com privilégios de root e veja sua PE livre.

Você pode agora executar novamente o comando:

    # pvresize --setphysicalvolumesize tamanho VolumeFísico

Veja o resultado:

    # pvs

      PV         VG   Fmt  Attr PSize    PFree
      /dev/sdd1  vg1  lvm2 a--     1t     500g

##### Redimensionando a partição

Por fim, você deve diminuir a partição com sua ferramenta de particionamento favorita.

### Grupos de volume

#### Criando um grupo de volume

Para criar uma VG `MeuGrupoVol` com um PV associado ao `/dev/sdb1`, execute:

    # vgcreate MeuGrupoVol /dev/sdb1

Você pode verificar se foi criado o VG `MeuGrupoVol` usando o seguinte comando:

    # vgs

Você pode vincular múltiplos PVs ao criar um VG como este:

    # vgcreate MeuGrupoVol /dev/sdb1 /dev/sdb2

#### Ativando um grupo de volume

Nota Você pode limitar os volumes que serão ativados automaticamente ao configurar o `auto_activation_volume_list` em `/etc/lvm/lvm.conf`. Em caso de dúvida, mantenha esta opção comentada.

    # vgchange -a y MeuGrupoVol

Por padrão, quando aplicável, isto vai reativar o grupo de volume. Por exemplo, quando houve uma falha de um drive espelho e você fez a substituição da unidade e executou os passos: (1) `pvcreate`, (2) `vgextend` e (3) `vgreduce --removemissing --force`.

#### Reparando um grupo de volume

Para começar o processo de reconstrução do arranjo (array) deteriorado de um espelhamento neste exemplo, você deve executar:

    # lvconvert --repair /dev/MeuGrupoVol/mirror

Você pode monitorar o processo de reconstrução (Cpy%Sync Column output) com:

    # lvs -a -o +devices

#### Desativando um grupo de volume

Apenas invoque:

    # vgchange -a n MeuGrupoVol

Isto irá desativar o grupo de volume e permitir-lhe a desmontagem do contêiner que está armazenando-o.

#### Renomeando um grupo de volume

Use o comando vgrename(8) para renomear um grupo de volume existente.

Ambos os comandos a seguir renomeiam o grupo de volume existente de `MeuGrupoVol` para `meu_grupo_volume`:

    # vgrename /dev/MeuGrupoVol /dev/meu_grupo_volume

    # vgrename MeuGrupoVol meu_grupo_volume

Garanta a atualização de todos os arquivos de configuração (por exemplo `/etc/fstab` ou `/etc/crypttab`) que referenciam o grupo de volume renomeado.

#### Adicionando um volume físico em um grupo de volume

Primeiro, crie um novo volume físico no bloco do dispositivo que você deseja usar, então estenda o grupo de volume do mesmo:

    # pvcreate /dev/sdb1
    # vgextend MeuGrupoVol /dev/sdb1

Isto, é claro, irá aumentar o número total de extensões físicas no seu grupo de volume, e que podem ser alocadas por volumes lógicos da forma que você achar melhor.

Nota É considerado algo bom ter uma tabela de partição abaixo do LVM na sua mídia de armazenamento. Para usar o tipo apropriado da partição, busque por: `8e` para MBR, e `E6D6D379-F507-44C2-A23C-238F2A3DF928` para partições GPT (código do tipo é `8e00` em gdisk, tal qual é também conhecido por `lvm` em fdisk).

#### Removendo uma partição de um grupo de volume

Se você criou um volume lógico na partição, antes de tudo a remova

Todos os dados daquela partição precisam ser movidos para outra partição. Felizmente, LVM torna isto fácil:

    # pvmove /dev/sdb1

Se você quiser mover os dados para um volume físico em específico, determine o armazenamento de destino como o segundo argumento em `pvmove`:

    # pvmove /dev/sdb1 /dev/sdf1

E então o volume físico precisa ser removido do grupo de volume:

    # vgreduce MeuGrupoVol /dev/sdb1

Ou remova todos os volumes físicos vazios:

    # vgreduce --all MeuGrupoVol

Por exemplo: Se você tiver um disco ruim em um grupo que não pode ser encontrado porque ele foi removido ou apresenta falha:

    # vgreduce --removemissing --force MeuGrupoVol

E finalmente, se você quiser usar a partição para outra coisa, e quer evitar que o LVM pense que a partição é um volume físico:

    # pvremove /dev/sdb1

### Volumes lógicos

Nota lvresize(8) fornece mais ou menos as mesmas opções dos comandos especializados lvextend(8) e lvreduce(8), enquanto que ao mesmo tempo permite ambos os tipos de operação. Não obstante, esses utilitários oferecem uma opção `-r`/`--resizefs` que permite redimensionar o sistema de arquivos em conjunto do LV ao usar fsadm(8) (com suporte a ext2, ext3, ext4, ReiserFs e XFS). Portanto, pode ser mais fácil e simples usar `lvresize` para ambas as operações e usar `--resizefs` para simplificar um pouco as coisas. A não ser que você tenha necessidades específicas ou queira total controle sobre o processo.
Atenção Enquanto que alargar um sistema de arquivos pode ser feito frequentemente online (isto é, enquanto estiver montado), mesmo para partições root, encolher irá quase sempre requerer primeiramente desmontar o sistema de arquivos para prevenir a perda de dados. Garanta que seu sistema de arquivos possui suporte para o que você está tentando fazer.
Dica Se um volume lógico será formatado em ext4, deixe pelo menos 256 MiB de espaço livre em seu grupo de volume para permitir o uso de e2scrub(8). Após a criação do último volume com `-l 100%FREE`, isto pode ser alcançado ao reduzir o tamanho com `lvreduce -L -256M grupo_volume/volume_logico`.

#### Criando um volume lógico

Para criar um LV `homevol` em um VG `MeuGrupoVol` com 300 GiB de capacidade, execute:

    # lvcreate -L 300G MeuGrupoVol -n homevol

Ou para criar um LV `homevol` em um VG `MeuGrupoVol` com o restante da capacidade, execute:

    # lvcreate -l 100%FREE MeuGrupoVol -n homevol

Para criar o LV enquanto o restringe para PVs específicos em um determinado VG, acrescente os volumes físicos ao comando:

    # lvcreate -L 300G MeuGrupoVol -n homevol /dev/sda1

O novo LV irá aparecer como `/dev/MeuGrupoVol/homevol`. Agora você pode formatar o LV com um sistema de arquivos apropriado.

Você pode verificar o LV criado usando o seguinte comando:

    # lvs

#### Renomeando um volume lógico

Para renomear um volume lógico existente, use o comando lvrename(8).

Ambos os comandos a seguir renomeiam o volume lógico `vol_velho` no grupo de volume `MeuGrupoVol` para `vol_novo`.

    # lvrename /dev/MeuGrupoVol/vol_velho /dev/MeuGrupoVol/vol_novo

    # lvrename MeuGrupoVol vol_velho vol_novo

Garanta a atualização de todos os arquivos de configuração (por exemplo `/etc/fstab` ou `/etc/crypttab`) que referenciam o volume lógico renomeado.

#### Redimensionando um volume lógico e um sistema de arquivos de uma só vez

Nota Apenas os sistemas de arquivos ext2, ext3, ext4, ReiserFS e XFS são suportados. Para um tipo diferente de sistema de arquivos veja como redimensionar separadamente.

Estenda o volume lógico `mediavol` em `MeuGrupoVol` para 10 GiB e redimensione o sistema de arquivos de uma só vez:

    # lvresize -L +10G --resizefs MeuGrupoVol/mediavol

Defina o tamanho do volume lógico `mediavol` em `MeuGrupoVol` para 15 GiB e redimensione o sistema de arquivos de uma só vez:

    # lvresize -L 15G --resizefs MeuGrupoVol/mediavol

Se você quiser encher todo o espaço livre disponível no grupo de volume, use o seguinte comando:

    # lvresize -l +100%FREE --resizefs MeuGrupoVol/mediavol

Veja lvresize(8) para mais opções detalhadas.

#### Redimensionando o volume lógico e o sistema de arquivos separadamente

Para sistemas de arquivos não suportados por fsadm(8), será necessário usar utilitários apropriados para redimensionar o sistema de arquivos antes de encolher o volume lógico ou depois de expandi-lo.

Para estender um volume lógico `mediavol` por dentro de um grupo de volume `MeuGrupoVol` para 2 GiB sem encostar no sistema de arquivos:

    # lvresize -L +2G MeuGrupoVol/mediavol

Agora expanda o sistema de arquivos (Ext4 neste exemplo) para o tamanho máximo do volume lógico subjacente:

    # resize2fs /dev/MeuGrupoVol/mediavol

Para Btrfs, o btrfs-filesystem(8) espera o ponto de montagem ao invés do dispositivo. O equivalente seria:

    # btrfs filesystem resize max /mnt/meu-ponto-de-montagem

Para reduzir o tamanho do volume lógico `mediavol` em `MeuGrupoVol` para 500 MiB, primeiramente calcule o tamanho resultante do sistema de arquivos, em seguida encolha o sistema de arquivos (Ext4 neste exemplo) para o novo tamanho:

    # resize2fs /dev/MeuGrupoVol/mediavol NovoTamanho

Ao contrário do Ext4, Btrfs oferece suporte ao encolhimento online (novamente, o ponto de montagem deverá ser especificado). Por exemplo:

    # btrfs filesystem resize -500M /mnt/meu-ponto-de-montagem

Quando o sistema de arquivos for encolhido, reduza o tamanho do volume lógico:

    # lvresize -L -500M MeuGrupoVol/mediavol

Para calcular o exato tamanho do volume lógico para os sistemas de arquivos ext2, ext3, ext4, use uma formula simples:

`LVM_EXTENTS = FS_BLOCKS × FS_BLOCKSIZE ÷ LVM_EXTENTSIZE`.

Ou de forma traduzida:

`LVM_EXTENSÕES = SA_BLOCOS × SA_TAMANHO-DO-BLOCO ÷ LVM_TAMANHO-DA-EXTENSÃO`.

    # tune2fs -l /dev/MeuGrupoVol/mediavol | grep Block

    Block count:              102400000
    Block size:               4096
    Blocks per group:         32768

    # vgdisplay MeuGrupoVol | grep "PE Size"

    PE Size               4.00 MiB

Nota O tamanho do block do sistema de arquivos é em bytes. Garanta as mesmas unidades para ambos, ou seja, para o bloco e para o tamanho da extensão.

    102400000 blocos × 4096 bytes/blocos ÷ 4 MiB/extensões = 100000 extensões

Ao passar `--resizefs` será confirmado com a correção.

    # lvreduce -l 100000 --resizefs /dev/MyVolGroup/mediavol

    ...
    The filesystem is already 102400000 (4k) blocks long.  Nothing to do!
    ...
    Logical volume sysvg/root successfully resized.

Ou de forma traduzida:

    # lvreduce -l 100000 --resizefs /dev/MeuGrupoVol/mediavol

    ...
    O sistema de arquivos já está alongado para 102400000 (4k) blocos. Não há nada para fazer!
    ...
    Volume lógico sysvg/root foi redimensionado com sucesso.

Veja lvresize(8) para mais opções detalhadas.

#### Removendo um volume lógico

Atenção Antes de remover o volume lógico, tenha certeza que moveu todos os dados que você gostaria de manter para outro lugar, caso o contrário você perderá tudo!

Primeiro, encontre o nome do volume lógico que você quer remover. Você pode pegar uma lista de todos os volumes lógicos presentes com:

    # lvs

Depois, procure o ponto de montagem do volume lógico escolhido:

    $ lsblk

Então, desmonte o sistema de arquivos do volume lógico:

    # umount /ponto-de-montagem

Por fim, remova o volume lógico:

    # lvremove grupo_volume/volume_logico

Por exemplo:

    # lvremove MeuGrupoVol/homevol

Confirme a operação digitando `y`.

Garanta a atualização de todos os arquivos de configuração (por exemplo `/etc/fstab` ou `/etc/crypttab`) que referenciam o volume lógico removido.

Você pode verificar a remoção do volume lógico ao digitar `lvs` como root novamente (veja o primeiro passo desta seção).

## Snapshots

LVM permite suporte aos CoW snapshots (Cópia em Gravação, do inglês Copy-on-Write). Um CoW snapshot inicialmente cria um apontamento para os dados originais; quando os blocos de dados são sobrescritos a cópia original permanece intacta, enquanto que os novos blocos são gravados em outro lugar no disco. Isto possui diversas propriedades cobiçáveis:

- Criar um snapshot é rápido, pois não há cópia de dados (apenas cria uma lista bem curta de ponteiros, dos quais apontam para outras localizações no disco);
- Snapshots requerem apenas o espaço livre suficiente para armazenar os novos blocos de dados (mais uma quantidade de armazenamento, entretanto negligenciável, para o apontamento de novos blocos). Por exemplo, para um snapshot de 35 GiB se utiliza apenas 2 GiB (incluso os dados do ponto de origem e do snapshot), portanto requer apenas 2 GiB de espaço livre;

Os snapshots do LVM estão a nível de bloco; eles criam um novo dispositivo de bloco sem aparente relação com o original, exceto ao lidar com as ferramentas do LVM, logo, ao deletar arquivos na cópia original não será liberado espaço nos snapshots. Se você precisa de snapshots a nível de sistema de arquivos, é necessário que use btrfs, ZFS ou bcachefs.

Atenção

- Um CoW snapshot não é um backup porque o mesmo não faz uma segunda cópia dos dados originários. Como exemplo, um setor danificado do disco que afete os dados originais também afetará os snapshots. Com isto dito, um snapshot pode ser útil enquanto outra ferramenta gerencia um backup, como destacado logo abaixo.
- Btrfs espera que diferentes sistemas de arquivos tenham diferentes UUIDs. Se você tirar um snapshot de um volume LVM que contem um sistema de arquivos btrfs, lembre-se de alterar o UUID do sistema de arquivos original ou da cópia antes de ambos serem montados (ou faça ser visível para o kernel; em exemplo, em caso de um daemon sem relação engatilhar um escaneamento do dispositivo btrfs). Para detalhes veja sobre btrfs na wiki Gotcha's.

### Configuração

É criado um snapshot de volumes lógicos da mesma forma que cria-se volumes lógicos normais.

    # lvcreate --size 100M --snapshot --name snap01vol /dev/MeuGrupoVol/lvol

Com este volume você pode modificar menos que 100 MiB de dados, antes que o volume de snapshot encha por completo.

A reversão do volume lógico `lvol` modificado para o estado que o snapshot `snap01vol` foi criado pode ser feita com:

    # lvconvert --merge /dev/MyVolGroup/snap01vol

Em caso do volume lógico original estar ativo, haverá uma mesclagem no próximo reboot (esta fusão pode ser feita a partir de um LiveCD).

Nota O snapshot não existirá após a mesclagem/fusão.

Além disso, múltiplos snapshots podem ser tirados e cada um pode ser mesclado com o volume lógico original à vontade.

### Backups

Um snapshot fornece uma cópia congelada de um sistema de arquivos para a criação de backups. Por exemplo, um backup que leve duas horas fornece uma maior consistência de imagem do sistema de arquivos, isto em comparação a um backup feito diretamente na partição.

O snapshot pode ser montado e feito o backup com dd ou tar. O tamanho do arquivo de backup feito pelo dd será igual ao tamanho dos arquivos que residem no volume de snapshot.

Para restauração é preciso apenas criar um snapshot, montá-lo, gravar ou extrair o backup nele, e por fim mesclar/fundir com a origem.

Veja a página em inglês sobre Criação de snapshots do sistema de arquivos root com LVM para automatizar a criação e limpeza de snapshots do root, além de criar durante o processo de inicialização do sistema os backups ou os rollbacks (reversões).

## Criptografia

Veja os tópicos LVM dentro do LUKS e LUKS dentro do LVM para conhecer os possíveis esquemas ao combinar LUKS com LVM.

## Cache

De lvmcache(7):

  O cache de volumes lógicos usa um LV pequeno e rápido para melhorar o desempenho de um LV grande e lento. Isto é feito armazenando os blocos usados frequentemente em um LV mais rápido. O LVM então refere-se ao LV pequeno e rápido como um LV de cache. O LV grande e lento é chamado de LV de origem. Devido às requisições do dm-cache (o driver do kernel), o LVM divide adicionalmente o LV de cache em dois dispositivos - um LV de cache de dados e um LV de cache de metadados. O LV de cache de dados é o local onde cópias dos blocos de dados são mantidos à partir do LV de origem para aumentar a velocidade. O LV de cache de metadados mantém informações que especificam onde os blocos de dados estão armazenados (por exemplo, no LV de origem ou no LV de cache de dados). Usuários devem familiarizar-se com esses LVs se desejarem criar volumes de cache melhores e mais robustos. Todos estes LVs associados devem residir no mesmo VG.

### Criar cache

Converta seu disco rápido (`/dev/disco-rápido`) para um PV e adicione-o ao seu VG (`MeuGrupoVol`) existente:

    # vgextend MeuGrupoVol /dev/disco-rápido

Crie uma área de cache com metadado automático em `dev/disco-rápido` e converta o LV existente `MeuGrupoVol/rootvol` para um volume de cache. Tudo isso é feito em um único passo:

    # lvcreate --type cache --cachemode writethrough -l 100%FREE -n root_cachepool MeuGrupoVol/rootvol /dev/disco-rápido

Dica Ao invés de usar `-l 100%FREE` para alocar 100% do espaço disponível do PV `/dev/disco-rápido`, você poderia usar `-L 20G` para alocar apenas 20 GiB para a área de cache.

O modo de cache (do inglês Cachemode) possui duas possibilidades de opções:

- `writethrough` garante que, quaisquer que sejam os dados escritos, tudo seja armazenado no LV de cache e no LV de origem. A perda do dispositivo associado ao LV de cache, neste caso, não significará a perda dos dados.
- `writeback` garante melhor desempenho, ao custo de maior risco de perda de dados em caso do dispositivo usado para cache falhar.

Se não for indicado um `--cachemode` específico, o sistema irá assumir a opção `writethrough` por padrão.

Dica A contagem da perda de cache pode ser vista com lvdisplay, ou de forma similar com lvm-cache-stats do pacote libblockdev-lvm, do qual também mostrará a perda em porcentagem.

### Remover cache

Se por algum motivo você precisar desfazer a operação de criação acima:

    # lvconvert --uncache MeuGrupoVol/rootvol

Isto sujeita qualquer escrita ainda pendente no cache de volta para o LV de origem, e então o deleta. Outras opções disponíveis são descritas em lvmcache(7).

## RAID

LVM pode ser usado para criar um RAID em software. É uma boa escolha se o usuário não tiver RAID em hardware e já estava planejando usar LVM de qualquer forma. De lvmraid(7):

  lvm(8) RAID é uma maneira de criar um volume lógico (LV) que usa múltiplos dispositivos físicos para aumentar performance ou tolerar falhas em dispositivos. Em LVM, os dispositivos físicos são, na verdade, volumes físicos (PVs) em um único grupo de volume (VG).

LVM RAID tem suporte para RAID 0, RAID 1, RAID 4, RAID 5, RAID 6 e RAID 10. Veja em Wikipedia:Standard RAID levels para conhecer os detalhes de cada nível.

Dica mdadm pode também ser usado para criar RAID em software. De fato é mais simples, mais popular e mais fácil de configurar.

### Configurando RAID

Crie os volumes físicos:

    # pvcreate /dev/sda2 /dev/sdb2

Crie um grupo de volume nos volumes físicos:

    # vgcreate MeuGrupoVol /dev/sda2 /dev/sdb2

#### Novos volumes

Crie os volumes lógicos com `lvcreate --type raidnível`. Veja lvmraid(7) e lvcreate(8) para mais opções.

    # lvcreate --type RaidNível [OPTIONS] -n Nome -L Tamanho VG [PVs]

##### RAID 0

Por exemplo:

    # lvcreate -n meuraid1vol -i 2 -I 64 -L 70G GrupoVol00 /dev/nvme1n1p1 /dev/nvme0n1p1

O comando acima irá criar e separar 70 GiB (raid0) do volume lógico nomeado como "meuraid1vol" em GrupoVol00. A disjunção dos dados será distribuída entre `/dev/nvme1n1p1` e `/dev/nvme0n1p1`. O tamanho de cada parte dividida está definido para ser 64K.

##### RAID 1

Por exemplo:

    # lvcreate --type raid1 --mirrors 1 -L 20G -n meuraid1vol MeuGrupoVol /dev/sda2 /dev/sdb2

O comando acima irá criar um volume lógico espelhado, nomeado como "meuraid1vol" em GrupoVol00, com 20 GiB de dados em `/dev/sda2` e `/dev/sdb2`.

##### RAID 10

Por exemplo:

    # lvcreate -n meuraid1vol -L 100G --type raid10 -m 1 -i 2 MeuGrupoVol /dev/sdd1 /dev/sdc1 /dev/sdb1 /dev/sda5

O comando acima irá criar um volume lógico RAID10 de 100 GiB, nomeado como "meuraid1vol" em GrupoVol00, entre `/dev/sdd1`, `/dev/sdc1`, `/dev/sdb1` e `/dev/sda5`.

#### Volumes existentes

Você pode converter facilmente um volume "não RAID" (por exemplo, linear) para basicamente qualquer configuração raid, contanto que você tenha dispositivos físicos suficientes para satisfazer os critérios de criação de RAID. Alguns irão requisitar seguir passos intermediários, do qual o comando `lvconvert` informará a você na linha de comando para aceitar. O `raid10` abaixo pode ser substituído por `raid0`, `raid1`, `raid5`, etc.

    # lvconvert --type raid10 /dev/vg01/lv01

Para usar PVs específicos:

    # lvconvert --type raid10 /dev/vg01/lv01 /dev/sda1 /dev/sdb2 /dev/nvme0n1p1 ...

Você pode rastrear o processo de conversão com:

    # watch lvs -o name,vg_name,copy_percent

## Provisionamento fino

Nota Quando estiver montando um sistema de arquivos em um LV fino, sempre lembre de usar a opção `discard` ou usar fstrim regularmente para permitir que o LV fino encolha a medida que arquivos forem deletados.

De lvmthin(7):

  Blocos em um volume lógico (LV) padrão lvm(8) são alocados a partir do momento que o LV é criado, porém blocos em um LV de provisionamento fino são alocados a medida que há a escritura/gravação dos dados. Por conta disto, é oferecido para um LV de provisão fina um tamanho virtual, e o mesmo pode ser maior do que é fisicamente disponibilizado no armazenamento. A quantidade de armazenamento físico providenciada para LVs de provisão fina pode ao decorrer do tempo aumentar a medida que for necessário.

### Exemplo: implementando servidores privados virtuais

Aqui vai um caso clássico de uso. Suponha que você queira começar seu próprio serviço de VPS, inicialmente hospedando cerca de 100 VPSes em um único computador com disco rígido de 930 GiB. Dificilmente qualquer um dos VPSes irá realmente usar todo o armazenamento que eles foram alocados, então ao invés de alocar 9 GiB para cada VPS, você poderia permitir que cada VPS tenha um tamanho máximo de 30 GiB e que usem provisionamento fino para somente alocar o espaço que cada VPS estará de fato usando no disco rígido. Presuma que o disco rígido de 930 GiB é `/dev/sdb`. Esta seria a configuração:

Prepare o grupo de volume, `MeuGrupoVol`.

    # vgcreate MeuGrupoVol /dev/sdb

Crie a área fina (ou, do inglês pool) do LV, `MeuPoolFino`. Este LV irá providenciar os blocos para armazenamento.

    # lvcreate --type thin-pool -n MeuPoolFino -l 95%FREE MeuGrupoVol

A pool é composta de dois sub-volumes, o LV de dado e o LV de metadado; este comando cria ambos automaticamente, porém o espaço fino para de funcionar se ambos encherem completamente, e atualmente LVM não possui suporte para encolhimento de nenhum destes volumes. É por isso que o comando acima permite 5% de espaço extra, em caso de você precisar eventualmente expandir os sub-volumes de dado ou de metadado da área fina.

Para cada VPS, crie um LV fino. Este é o dispositivo de bloco exposto ao usuário para a partição root.

    # lvcreate -n AlgunsClientesRoot -V 30G --thinpool MeuPoolFino MeuGrupoVol

O dispositivo de bloco `/dev/MeuGrupoVol/AlgunsClientesRoot` pode então ser usado por uma instância de VirtualBox como partição root.

#### Usando snapshots finos para salvar mais espaço

Snapshots finos são muito mais poderosos do que snapshots convencionais, por conta de serem propriamente LVs finos. Veja o guia da Red Hat [4] para uma lista completa de vantagens que estes snapshots possuem.

Ao invés de instalar um Linux do zero toda vez que um VPS é criado, é mais eficiente em espaço começar com apenas um LV fino contendo uma instalação básica do Linux:

    # lvcreate -n RootGenérico -V 30G --thinpool MeuPoolFino MeuGrupoVol
    *** instalado um Linux em /dev/MeuGrupoVol/RootGenérico ***

Então crie snapshots disso para cada VPS:

    # lvcreate -s MeuGrupoVol/RootGenérico -n AlgunsClientesRoot

Desta forma, na área fina há apenas uma cópia de dado comum para todos os VPSes, pelo menos inicialmente. Como uma adição bônus, a criação de um novo VPS é instantânea.

Em razão destes snapshots serem finos, uma operação de escrita em `RootGenérico` faz apenas uma operação CoW no total, em vez de uma operação CoW por snapshot. Isto permite-lhe atualizar o `RootGenérico` de maneira mais eficiente do que se cada VPS fosse um snapshot regular.

### Exemplo: atualização de armazenamento com zero tempo de inatividade (zero-downtime)

Existem aplicações de provisionamento fino por fora de uma hospedagem VPS, e existe um jeito de como você pode usá-las para crescer efetivamente a capacidade de um sistema de arquivos previamente montado, sem precisar desmontá-lo. Suponha, de novo, que o servidor possui somente um disco rígido de 930 GiB. A configuração é a mesma feita para a hospedagem de VPS, exceto que há somente um LV fino e o tamanho do LV é muito maior do que o tamanho da área fina.

    # lvcreate -n MeuLVFino -V 16T --thinpool MeuPoolFino MeuGrupoVol

Este espaço virtual extra pode ser preenchido com um armazenamento real mais tarde, ao estender a pool fina.

Presuma agora que, depois de um certo tempo, uma atualização de armazenamento é necessária, e o novo disco rígido, `/dev/sdc`, está conectado ao servidor. Para atualizar a capacidade da área fina, adicione o novo disco rígido ao VG:

    # vgextend MeuGrupoVol /dev/sdc

Agora, estenda a pool fina:

    # lvextend -l +95%FREE MeuGrupoVol/MeuPoolFino

Em razão do tamanho do LV fino ser de 16 TiB, você poderia adicionar outro disco rígido com espaço de 15.09 TiB antes de finalmente precisar desmontar e redimensionar o sistema de arquivos.

Nota Você provavelmente irá querer usar blocos reservados ou um disk quota para prevenir aplicações de tentarem usar mais armazenamento físico do que há de fato.

## Customização

Algumas customizações estão disponíveis ao editar `/etc/lvm/lvm.conf`. Você talvez ache útil customizar a saída de `lvs` e `pvs`, que por padrão não incluem a sincronização em % (vantajoso para ver o progresso de conversão entre, por exemplo, um volume linear para um tipo raid) e o tipo de volume lógico.

    /etc/lvm/lvm.conf

    report {
     	lvs_cols = "lv_name,lv_attr,lv_active,vg_name,lv_size,lv_layout,lv_allocation_policy,copy_percent,chunk_size"
    	pvs_cols = "pv_name,vg_name,pv_size,pv_free,pv_used,dev_size"
    }

## Solução de problemas

### Comandos de LVM não funcionam

- Carregue o módulo adequado:

    # modprobe dm_mod

O módulo `dm_mod` deveria ser automaticamente carregado. No caso de não acontecer, carregue o módulo durante o boot.

- Tente antecipar comandos com lvm desta forma:

    # lvm pvdisplay

### Volumes lógicos não aparecem

Se você está tentando montar volumes lógicos existentes, porém não aparecem em `lvscan`, você pode usar os comandos a seguir para ativá-los:

    # vgscan
    # aay

### LVM em mídia removível

Sintomas:

    # vgscan

      Reading all physical volumes.  This may take a while...
      /dev/backupdrive1/backup: read failed after 0 of 4096 at 319836585984: Input/output error
      /dev/backupdrive1/backup: read failed after 0 of 4096 at 319836643328: Input/output error
      /dev/backupdrive1/backup: read failed after 0 of 4096 at 0: Input/output error
      /dev/backupdrive1/backup: read failed after 0 of 4096 at 4096: Input/output error
      Found volume group "backupdrive1" using metadata type lvm2
      Found volume group "networkdrive" using metadata type lvm2

Ou de forma traduzida:

    # vgscan

      Lendo todos os volumes físicos.  Isto pode levar um tempo...
      /dev/backupdrive1/backup: leitura falhou logo após 0 de 4096 em 319836585984: erro de Entrada/Saída
      /dev/backupdrive1/backup: leitura falhou logo após 0 de 4096 em 319836643328: erro de Entrada/Saída
      /dev/backupdrive1/backup: leitura falhou logo após 0 de 4096 em 0: erro de Entrada/Saída
      /dev/backupdrive1/backup: leitura falhou logo após 0 de 4096 em 4096: erro de Entrada/Saída
      Encontrado grupo de volume "backupdrive1" usando metadata tipo lvm2
      Encontrado grupo de volume "networkdrive" usando metadata tipo lvm2

Causa: remover um drive LVM externo sem desativar o(s) grupo(s) de volume antes. Antes de desconectar, se assegure de fazer:

    # vgchange -an nome_grupo_volume

Correção: supondo que você já tentou ativar o grupo de volume com `vgchange -ay vg`, e está recebendo erros de Entrada/Saída:

    # vgchange -an nome_grupo_volume

Desconecte o dispositivo externo e espere alguns minutos:

    # vgscan
    # vgchange -ay nome_grupo_volume

#### Suspensão/retorno com LVM e mídia removível

The factual accuracy of this article or section is disputed.

Reason: A solução em questão não funciona em setups mais complexos, como LVM dentro de LUKS. (Discuss in talk:LVM)

Para que o LVM funcione adequadamente com mídias removíveis - como em uma unidade USB externa - o grupo de volume da unidade externa precisa ser desativado antes de suspender. Se isso não for feito, você pode acabar com erros de Entrada/Saída no buffer do dispositivo mapeado (após o retorno). Por esta razão, não é recomendado misturar drives externos com internos no mesmo grupo de volume.

Para automaticamente desativar os grupos de volume com unidades USB externas, marque cada um dos grupos de volume com a tag `sleep_umount`, sendo desta forma:

    # vgchange --addtag sleep_umount vg_externo

Uma vez que a marcação é definida, use o seguinte arquivo unit do systemd para desativar apropriadamente os volumes antes da suspensão. Ao retornar o sistema, os drives serão automaticamente ativados pelo LVM.

    /etc/systemd/system/ext_usb_vg_desativar.service

    [Unit]
    Description=Desativar grupos de volume de USB externo ao suspender
    Before=sleep.target

    [Service]
    Type=oneshot
    ExecStart=-/etc/systemd/system/desativar_sleep_vgs.sh

    [Install]
    WantedBy=sleep.target

Este é o script:

    /etc/systemd/system/deactivate_sleep_vgs.sh

    #!/bin/sh

    TAG=@sleep_umount
    vgs=$(vgs --noheadings -o vg_name $TAG)

    echo "Desativando grupos de volume com a tag $TAG: $vgs"

    # Desmonte volumes lógicos que pertencem ao grupos de volumes com a tag $TAG
    for vg in $vgs; do
        for lv_dev_path in $(lvs --noheadings  -o lv_path -S lv_active=active,vg_name=$vg); do
            echo "Desmontando volume lógico $lv_dev_path"
            umount $lv_dev_path
        done
    done

    # Desative grupos de volumes marcados com sleep_umount
    for vg in $vgs; do
        echo "Desativando grupo de volume $vg"
        vgchange -an $vg
    done

Por fim, ative a unit.

### Redimensionando um volume lógico contíguo que falha

Se estiver tentando estender um volume lógico e houver erros com:

    " Insufficient suitable contiguous allocatable extents for logical volume "

Ou de forma traduzida:

    " Extensões alocáveis contíguas e adequadas insuficientes para o volume lógico "

A razão é que o volume lógico foi criado com uma restrição explícita (ou, do inglês policy) de alocação contígua (definido por opções como `-C y` ou `--alloc contiguous`), e nenhuma extensão contígua adjacente está disponível. [5][link inativo 2025-11-17 ⓘ]

Para corrigir, principalmente para estender o volume lógico, modifique a restrição de alocação com `lvchange --alloc inherit volume_lógico`. Se você precisar manter a restrição de alocação contígua, uma alternativa seria mover o volume para uma área do disco com extensões livres suficientes. Veja [6].

### Comando "grub-mkconfig" reporta erros de "unknown filesystem"

Lembre-se de remover volumes snapshot antes de gerar o grub.cfg, pois GRUB não conseguirá reconhecer estes volumes como um sistema de arquivos.

### Tempo de volume root com dispositivo de provisão fina expira (time out)

Com um grande número de snapshots, `thin_check` executará por um tempo longo o suficiente para que o tempo de espera pelo dispositivo root expire. Para compensar isso, adicione o parâmetro de inicialização do kernel `rootdelay=60` nas configurações do seu bootloader. Ou faça com que `thin_check` pule a verificação de mapeamento de blocos (veja [7]) e gere novamente o initramfs:

    /etc/lvm/lvm.conf

    thin_check_options = [ "-q", "--clear-needs-check-flag", "--skip-mappings" ]

### Lentidão ao desligar

Se você usa RAID, snapshots ou provisionamento fino e estiver experienciando uma lentidão ao desligar, garanta que `lvm2-monitor.service` esteja iniciado. Veja FS#50420.

### Hibernação em um volume swap de provisionamento fino

Veja em Gestão de energia#hibernação em volume LVM de provisionamento fino.

## Veja também

- LVM2 Resource Page em SourceWare.org
- Gentoo:LVM
- Red Hat Enterprise 9: Configuração e gerenciamento de volumes lógicos
- Guia do Ubuntu sobre LVM Parte 1 detalhes sobre snapshots Parte 2

Category:

- Storage virtualization (Português)

Hidden categories:

- Pages or sections flagged with Template:Accuracy
- Pages with dead links

LVM (Português)
Add topic