RAID e LVM2

Dominando LinuxUsando RAID e LVM2

versão 0.5

Fernando Antunes

Este trabalho está licenciado sob uma Licença Creative Commons Atribuição-Uso Não-Comercial-Vedada a Criação de Obras Derivadas 2.5 Brasil. Para ver uma cópia desta licença, visite http://creativecommons.org/licenses/by-nc-nd/2.5/br/ ou envie uma carta para Creative Commons, 171 Second Street, Suite 300, San Francisco, Califórnia 94105, USA.

2

ConteúdoVisão geral do curso.............................................................................................................................4RAID....................................................................................................................................................5

Preparando um computador para este curso...............................................................................6Identificando o suporte a RAID no kernel Linux.......................................................................7Habilitando RAID em um kernel Linux.....................................................................................8Detecção de discos RAID durante a carga do kernel..................................................................9Instalando as ferramentas de gerenciamento RAID..................................................................10Dispositivos de bloco para uso do RAID..................................................................................10Criando uma partição em RAID-1 (mirror)..............................................................................12Testando a autodetecção............................................................................................................14Ativando RAID manualmente..................................................................................................15Examinando detalhes sobre os RAID configurados.................................................................17Utilizando o RAID....................................................................................................................18Substituindo um disco ou uma partição em um RAID-1 íntegro..............................................19Removendo permanentemente uma partição do RAID............................................................23Substituindo um disco ou uma partição em um RAID-1 danificado........................................24Aumentando o número de discos ativos em um RAID.............................................................27Diminuindo o número de discos do RAID................................................................................29Monitorando um RAID.............................................................................................................30Removendo um RAID..............................................................................................................32Criando um RAID-5..................................................................................................................33Criando um RAID-0..................................................................................................................35Criando um RAID Linear.........................................................................................................37Criando um RAID-6..................................................................................................................39Criando um RAID-10................................................................................................................41Criando um RAID-0+1.............................................................................................................45Criando um RAID-50................................................................................................................48Removendo as partições para reutilizarmos os discos nos módulos seguintes.........................51

Device Mapper...................................................................................................................................52Identificando o suporte ao Device Mapper no kernel Linux.....................................................53Habilitando Device Mapper no kernel Linux...........................................................................53Instalando a biblioteca e ferramentas Device Mapper..............................................................55Criando um volume lógico de bloco usando Device Mapper...................................................55Criando um segundo volume em um mesmo disco..................................................................56Obtendo informações sobre os volumes...................................................................................57Ativando o volume após a inicialização da máquina................................................................57Removendo um volume............................................................................................................58

LVM2..................................................................................................................................................59Preparando os discos para usarmos com LVM2 neste curso....................................................60Instalando as ferramentas LVM2..............................................................................................60Criando Physical Volumes (PV) ...............................................................................................60Visualizando informações sobre os PV.....................................................................................61Removendo um PV não alocado...............................................................................................62

Dominando Linux - Usando RAID e LVM2

3

Criando Volume Group (VG)....................................................................................................62Visualizando informações sobre os VG....................................................................................63Removendo um VG que não contém Logical Volumes (LV)....................................................64Criando um segundo VG...........................................................................................................64Criando um Logical Volume (LV).............................................................................................65Visualizando informações sobre um LV...................................................................................67Utilizando um LV......................................................................................................................67Aumentando o LV usando área disponível no VG....................................................................68Ampliando um VG e um LV usando um novo PV....................................................................70Criando um novo LV em um mesmo VG..................................................................................73Reduzindo o tamanho de um LV...............................................................................................73Removendo um PV sem alocação.............................................................................................74Retirando um PV com dados alocados......................................................................................74Realizando Snapshots...............................................................................................................76Removendo um Snapshot ou um Logical Volume (LV)...........................................................80

Loop Devices......................................................................................................................................81Identificando o suporte a Loop Device no kernel Linux..........................................................82Habilitando Loop Device no kernel Linux...............................................................................82Localizando e criando Loop Devices........................................................................................83Preparando um Loop Device para uso......................................................................................84Identificando que Loop Device estão associados......................................................................85Utilizando um Loop Device......................................................................................................85Associando os Loop Devices na inicialização da máquina.......................................................85Desfazendo a associação com um Loop Device.......................................................................86Criando um RAID com Loop Devices......................................................................................87

DM_CRYPT.......................................................................................................................................88Identificando o suporte ao DM_CRYPT e aos algoritmos de criptografia no kernel Linux.....89Habilitando DM_CRYPT no kernel Linux...............................................................................89Verificando os algoritmos de criptografia disponíveis em um kernel em execução.................90Criptografando com LUKS.......................................................................................................91Obtendo informações com LUKS.............................................................................................91Usando uma partição ou Device Loop criptografado...............................................................92Encerrando o uso.......................................................................................................................93Adicionando senhas..................................................................................................................93Removendo senhas....................................................................................................................94Usando um arquivo arquivo para armazenar as senhas............................................................94Usando os volumes após reiniciar a máquina...........................................................................95


4

Visão geral do curso

RAID e LVM2 permitem aos administradores Linux maior flexibilidade e segurança no armazenamento dos dados do que o método tradicional de particionamento de discos locais, permitindo alterar o tamanho das áreas alocadas e proteção em caso de falhas dos dispositivos de armazenamentos.


5

RAID

Em 1988, foi publicado na Universidade de Berkeley um documento chamado A Case for Redundant Arrays of Inexpensive Disks (RAID), descrevendo cinco técnicas para combinar múltiplos discos pequenos para prover tolerância a falhas, cada uma com um conjunto diferente de características e diferentes impactos em performance.

Estas cinco tecnologias são conhecidas como RAID-1 a RAID-5. Com o passar do tempo outras combinações como RAID-0, RAID-6, RAID-10, RAID-50 e RAID-0+1 foram adicionadas às originais e estão disponíveis em hardwares de diversos fabricantes de dispositivos de armazenamento.

Uma boa visualização do funcionamento destas diferentes combinações pode ser vista no tutorial existente no site do fabricante AC&NC (http://www.acnc.com/04_00.html).

Linux contempla suporte a RAID por software desde o kernel 2.0 através do driver MD, permitindo sua utilização sem a necessidade de equipamentos especializados. Na atual versão 2.6, as diversas tecnologias são chamadas de personalidades e as possíveis para uso são RAID-0, RAID-1, RAID-4, RAID-5, RAID-6 e RAID-10, além de uma chamada Linear, onde um disco é concatenado ao fim do outro sem prover tolerância a falhas. O suporte a RAID 0+1 e 50 são possíveis através de combinações de RAID-0 e RAID-1.

Este curso permite a compreensão das ferramentas para gestão de RAID por software em Linux e da configuração do kernel 2.6 para dar suporte a este recurso. Fora de seu escopo está a discussão do funcionamento conceitual das tecnologias RAID, bem como uma avaliação dos prós e contras de cada uma.


6

Preparando um computador para este curso

Neste curso usaremos uma máquina virtual para prover recursos de vários discos ao sistema operacional Linux. Comecemos pela configuração de nossa máquina virtual com três discos adicionais aos usados para a instalação de softwares e dados.

Neste curso, usamos o virtualizador Virtualbox da SUN, mas qualquer outro software de virtualização pode ser usado em seu lugar, desde que forneça suporte até a cinco discos SATA. Através da propriedade da máquina virtual, configure os discos conforme o esquema abaixo.

Nosso disco gentoo-lvm2-raid.vdi, contendo os software e dados, será o disco sda. O disco virtual rd1 será visto pelo Linux como sdb, o rd2 como sdc e rd3 como sdd. Este últimos serão usados nos laboratórios de RAID.

Inicie a máquina virtual escolhendo a primeira opção, Gentoo Kernel 2.6.30-r6, no menu do GRUB. Acesse a console como root, senha totonick.

login: rootPassword: totonick


7

Identificando o suporte a RAID no kernel Linux

Para ter suporte a RAID por software em Linux, é preciso que o kernel esteja compilado com este recurso habilitado. Isto pode ser verificado avaliando o arquivo /proc/config.gz, que contém a configuração do kernel em execução. Procure por CONFIG_MD para ver o suporte a RAID e as personalidades habilitadas. Se o recurso foi compilado como módulo, haverá um valor m no lugar de y.

# zcat /proc/config.gz | grep CONFIG_MDCONFIG_MD=y CONFIG_MD_AUTODETECT=y CONFIG_MD_LINEAR=y CONFIG_MD_RAID0=y CONFIG_MD_RAID1=y CONFIG_MD_RAID10=y CONFIG_MD_RAID456=y CONFIG_MD_RAID6_PQ=y # CONFIG_MD_MULTIPATH is not set # CONFIG_MD_FAULTY is not set

Se seu kernel não expõe o arquivo /proc/config.gz, você pode identificar o suporte através das informações exibidas durante sua carga pelo driver md.

# dmesg | grep ^mdmd: raid0 personality registered for level 0 md: raid1 personality registered for level 1 md: raid6 personality registered for level 6 md: raid5 personality registered for level 5 md: raid4 personality registered for level 4 md: Waiting for all devices to be available before autodetect md: If you don't use raid, use raid=noautodetect md: Autodetecting RAID arrays. md: Scanned 0 and added 0 devices. md: autorun ... md: ... autorun DONE.

Outra forma é observar o conteúdo do arquivo /proc/mdstat, que existe apenas quando o suporte RAID esta habilitado. Este arquivo mostra as personalidades habilitadas no kernel e os RAID ativos no sistema.

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] unused devices: <none>


8

Habilitando RAID em um kernel Linux

Para habilitar o suporte RAID em um kernel Linux ou adicionar personalidades não habilitadas em sua instalação, é preciso compilá-lo.

Carregue o menu de configuração do kernel.

# cd /usr/src/linux

# make menuconfig

Selecione a opção de menu Device Drivers e configure seu kernel usando a configuração abaixo como modelo.

Device Drivers --->[*] Multiple devices driver support (RAID and LVM) -->

<*> RAID support (NEW)<*> Autodetect RAID arrays during kernel boot (NEW)<*> Linear (append mode)<*> RAID-0 (striping) mode (NEW)<*> RAID-1 (mirroring) mode (NEW)<*> RAID-10 (mirroring striping) mode (NEW)<*> RAID-4/RAID-5/RAID-6 mode (NEW)< > Multipath I/O support (NEW)< > Faulty test module for MD (NEW)

Saia do menu, salve a configuração e compile o novo kernel

# make bzImage

# make modules

Faça a instalação do kernel e seus módulos para que possamos usá-lo e depois configure o GRUB para tê-lo como padrão. Neste curso o menu do GRUB já está configurado para carregar um kernel de nome kernel-2.6.30-raid, cujo title é Gentoo Kernel 2.6.30-r6 (with RAID).

# make modules_install

# cp arch/x86/boot/bzImage /boot/kernel-2.6.30-r6-raid

# cat /boot/grub/menu.lstdefault 1 timeout 30 color black/white

splashimage=(hd0,0)/grub/robin.xpm.gz


9

title Gentoo Kernel 2.6.30-r6 root (hd0,0) kernel /kernel-2.6.30-r6 root=/dev/sda3 video=vesafb:ywrap,mtrr:3 vga=0x303

title Gentoo Kernel 2.6.30-r6 (with RAID) root (hd0,0) kernel /kernel-2.6.30-r6-raid root=/dev/sda3 video=vesafb:ywrap,mtrr:3 vga=0x303

title Gentoo Kernel 2.6.30-r6 (with RAID and LVM2) root (hd0,0) kernel /kernel-2.6.30-r6-raid-lvm2 root=/dev/sda3 video=vesafb:ywrap,mtrr:3 vga=0x303

Reinicialize a máquina e de carga no sistema através da opção Gentoo Kernel 2.6.30-r6 (with RAID). Note as informações exibidas pelo driver MD durante a carga.

md: linear personality registered for level -1 md: raid0 personality registered for level 0 md: raid1 personality registered for level 1 md: raid10 personality registered for level 10 md: raid6 personality registered for level 6 md: raid5 personality registered for level 5 md: raid4 personality registered for level 4 md: Waiting for all devices to be available before autodetect md: If you don't use raid, use raid=noautodetect md: Autodetecting RAID arrays. md: Scanned 0 and added 0 devices. md: autorun ... md: ... autorun DONE.

O driver começa exibindo as personalidades habilitadas e que level deve usado como parâmetro ao se criar um RAID deste tipo com o comando mdadm e depois procura por partições do tipo Linux raid auto para iniciá-las automaticamente.

Detecção de discos RAID durante a carga do kernel

Se você possui um kernel compilado com suporte a autodetecção de discos array como em nosso laboratório, CONFIG_MD_AUTODETECT=y, RAID criados em seu computador serão ativados pelo kernel durante sua carga e estarão disponíveis para uso. Caso seu kernel não suporte isto, você terá que ativar os RAID manualmente ou através de um script a cada inicialização. Contudo, para que a autodetecção funcione, as partições criadas tem que serem do tipo fd, Linux raid auto, e não o usual 83, Linux.


10

Entretanto, em um computador com o recurso habilitado, mas nenhum RAID criado, o tempo de inicialização do kernel é impactado, pois ele demanda recursos procurando por estes discos arrays que não existem. Para diminuir este tempo em máquinas com autodetecção e sem RAID configurados, adicione o parâmetro raid=noautodetect à linha de configuração do kernel no arquivo de configuração do GRUB para que fique semelhante ao exemplo abaixo.

(não prossiga no curso com esta opção inserida como parâmetro em seu kernel)kernel /kernel-2.6.30-r6-raid root=/dev/sda3 raid=noautodetect

Durante a carga do kernel, você verá a mensagem dizendo que a autodetecção foi inibida.

md: linear personality registered for level -1 md: raid0 personality registered for level 0 md: raid1 personality registered for level 1 md: raid10 personality registered for level 10 md: raid6 personality registered for level 6 md: raid5 personality registered for level 5 md: raid4 personality registered for level 4 md: Skipping autodetection of RAID arrays. (raid=autodetect will force)

Instalando as ferramentas de gerenciamento RAID

Para gerenciar RAID em um computador Linux, é preciso instalar as ferramentas contidas no pacote mdadm. Utilize o gerenciador de pacotes de sua distribuição para ver se ele já está instalado ou procure pela existência do programa mdadm em sua máquina.

# mdadm -bash: mdadm: command not found

Em Gentoo,# emerge sys-fs/mdadm

Dispositivos de bloco para uso do RAID

Para que Linux possa usar um RAID, é preciso ter um arquivo no /dev/ que o represente. Arquivos no diretório /dev devem ser criados pelo comando mknod e devem ser informados seu tipo de acesso, caractere ou bloco, além dos números MAJOR e MINOR para que Linux saiba para que finalidade eles serão usados. As especificações dos nomes, tipos e números podem ser encontradas no arquivo /usr/src/linux/Documentation/devices.txt.


11

Ao verificarmos seu conteúdo, identificamos que o nome mdX deve ser usado para representar arquivos do tipo bloco para uso de RAID e que o MAJOR number é 9 e o MINOR um sequencial iniciando de 0.

# grep --max-count=1 -A7 '9 block' /usr/src/linux/Documentation/devices.txt

9 block Metadisk (RAID) devices 0 = /dev/md0 First metadisk group 1 = /dev/md1 Second metadisk group ...

The metadisk driver is used to span a filesystem across multiple physical disks.

Verifique se sua distribuição já criou algum arquivo destes em seu computador.

# ls -l /dev/md?brw-r--r-- 1 root root 9, 0 2009-09-26 17:58 /dev/md0

Ao criarmos um RAID com a ferramenta mdadm, estes arquivos são criados automaticamente. Mas caso queira criá-los antecipadamente, basta usar o comando mknod.

# mknod /dev/md1 b 9 1# mknod /dev/md1 b 9 2

# ls -l /dev/md? brw-r--r-- 1 root root 9, 0 2009-09-26 17:58 /dev/md0 brw-r--r-- 1 root root 9, 1 2009-09-26 17:58 /dev/md1 brw-r--r-- 1 root root 9, 2 2009-09-26 17:58 /dev/md2


12

Criando uma partição em RAID-1 (mirror)

RAID-1 permite que os dados de gravados em uma partição sejam duplicados em uma outra partição e que os acessos de leitura sejam realizados em qualquer um dos discos.

Vamos criar um RAID-1 com duas partições de 50MB. Use o comando fdisk para criar as partições sdb1 e sdc1. Modifique o tipo para fd, Linux raid auto, para permitir autodetecção.

# fdisk /dev/sdbnp1ENTER6L (exibe os tipos de partição)tfdp (exibe a tabela de partição)w

# fdisk /dev/sdcnp1ENTER6tfdw

Uma vez criada as partições, vamos combiná-las em um RAID-1 chamado md0 usando o comando mdadm no modo Create com os parâmetros level igual a 1, para indicar a personalidade registrada como RAID-1, e com duas partições, raid-devices=2, em sua composição, sdb1 e sdc1.

# mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sdb1 /dev/sdc1


13

mdadm: array /dev/md0 started.

mdadm suporta uma sintaxe que permite agrupar as partições. A comando abaixo é equivalente ao anterior,

# mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sd{b,c}1

Uma vez iniciado o processo de criação do array, podemos ver o progresso de sua construção através do arquivo /proc/mdstat.

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid1 sdc1[1] sdb1[0] 48064 blocks [2/2] [UU] [============>........] resync = 60.6% (29184/48064) finish=0.0min speed=5836K/sec unused devices: <none>

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid1 sdc1[1] sdb1[0] 48064 blocks [2/2] [UU] [=================>...] resync = 87.2% (42112/48064) finish=0.0min speed=5264K/sec unused devices: <none>

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid1 sdc1[1] sdb1[0] 48064 blocks [2/2] [UU] unused devices: <none>

O RAID-1 está pronto e ativado pelo kernel. Note que as duas partições estão ativas, Up, [UU].


14

Testando a autodetecção

Vamos reiniciar a máquina para testarmos o recurso de autodetecção.

# shutdown -r 0

Note a inicialização do driver MD durante a carga do kernel.

md: Waiting for all devices to be available before autodetect md: If you don't use raid, use raid=noautodetect md: Autodetecting RAID arrays. md: Scanned 2 and added 2 devices. md: autorun ... md: considering sdc1 ... md: adding sdc1 ... md: adding sdb1 ... md: created md0 md: bind<sdb1> md: bind<sdc1> md: running: <sdc1><sdb1> md: ... autorun DONE.

Você pode ver isto mais calmamente com o comando dmesg após o login.

# dmesg# dmesg | grep md:# dmesg | less

Note que o RAID-1 md0 foi criado e ativado. O que pode ser constatado no arquivo /proc/mdstat.



15

Ativando RAID manualmente

Em um cenário onde a autodetecção não está habilitada no kernel ou desabilitada pelo parâmetro raid=noautodetect ou em partições com tipo diferente de fd, é necessário ativar os RAID manualmente.

Vamos inibir a inicialização automática do RAID mudando o tipo das partições para 83.

# fdisk /dev/sdbt83w

# fdisk /dev/sdct83w

Reinicie o computador.

# shutdown -r 0

Veja que o kernel não mais ativa o RAID-1 md0.

md: Waiting for all devices to be available before autodetect md: If you don't use raid, use raid=noautodetect md: Autodetecting RAID arrays. md: Scanned 0 and added 0 devices. md: autorun ... md: ... autorun DONE.


Para podermos usar o RAID-1, é preciso ativá-lo manualmente com o comando mdadm no modo Assemble.

# mdadm --assemble /dev/md0 /dev/sdb1 /dev/sdc1mdadm: /dev/md0 has been started with 2 drives.


16

O RAID-1 foi iniciado, veja o log.

# dmesg | tailmd: md0 stopped. md: bind<sdc1> md: bind<sdb1> raid1: raid set md0 active with 2 out of 2 mirrors md0: unknown partition table


O ruim desta abordagem é que precisamos saber quais RAID existem e que partições os compõe para podermos ativá-los. Para simplificar este processo, é possível armazenar as informações sobre eles no arquivo /etc/mdadm.conf. A sintaxe mínima deste arquivo é bem simples.

Adicione uma linha começando com DEVICE contendo todas as partições que compõe algum RAID existente.

# echo DEVICE /dev/sbd1 /dev/sdc1 >> /etc/mdadm.conf

Depois uma linha começando com ARRAY contendo os detalhes do RAID. Estas informações podem ser obtidas através do comando mdadm os parâmetros detail e scan.

# mdadm --detail --scanARRAY /dev/md0 level=raid1 num-devices=2 metadata=0.90 UUID=3d981197:4cba768c:9e68b2c8:17b61269

Desvie a saída do comando para o arquivo /etc/mdadm.conf para registrá-las.

# mdadm --detail --scan >> /etc/mdadm.conf

Reinicie o computador para testarmos o uso do arquivo de configuração.

# shutdown -r 0

Se sua distribuição executa algum script de inicialização de array disparado durante a carga da máquina, o RAID será ativado por ele usando o arquivo de configuração. Caso não, você poderá ativá-lo usando uma sintaxe mais simples agora.

# mdadm --assemble --scan /dev/md0


17

A desvantagem deste modelo manual é a manutenção do arquivo de configuração para refletir as futuras alterações. Vamos evitar isto no curso voltando nossas partições para o tipo fd.

# fdisk /dev/sdbtfdw

# fdisk /dev/sdctfdw

Remova as duas linhas inseridas em /etc/mdadm.conf para manter o arquivo com seu conteúdo original, evitando comportamentos não esperados no curso.

# vi /etc/mdadm.confGdddd:wq

Examinando detalhes sobre os RAID configurados

Podemos verificar informações sobre o RAID configurado usando o comando mdadm e o parâmetro detail.

# mdadm --detail /dev/md0

/dev/md0: Version : 0.90 Creation Time : Sun Sep 27 22:41:35 2009 Raid Level : raid1 Array Size : 48064 (46.95 MiB 49.22 MB) Used Dev Size : 48064 (46.95 MiB 49.22 MB) Raid Devices : 2 Total Devices : 2 Preferred Minor : 0

Persistence : Superblock is persistent

Update Time : Mon Sep 28 00:23:22 2009 State : clean Active Devices : 2 Working Devices : 2 Failed Devices : 0 Spare Devices : 0


18

UUID : 3d981197:4cba768c:9e68b2c8:17b61269 Events : 0.34

Number Major Minor RaidDevice State 0 8 17 0 active sync /dev/sdb1 1 8 33 1 active sync /dev/sdc1

As informações revelam o tipo do RAID, o tamanho da área para uso, se está íntegro (clean), quantas e que partições o compõe e se há alguma falha.

As mesmas informações podem ser obtidas se examinarmos as partições que compõe o RAID.

# mdadm --examine /dev/sdb1# mdadm --examine /dev/sdc1

Utilizando o RAID

Uma vez criado o RAID e ativado, podemos utilizá-lo para armazenar dados da mesma forma que usamos uma partição comum. Inicialmente, formate-o com um sistema de arquivos desejado e depois monte-o em algum lugar.

# mkfs -t ext4 /dev/md0# mkdir /mnt/docs# mount /dev/md0 /mnt/docs

Caso queira que o RAID seja montado durante a inicialização da máquina, adicione as informações de montagem ao arquivo /etc/fstab.

# vi /etc/fstab(posicione o cursor na linha /dev/cdrom)O(digite a linha abaixo)/dev/md0 /mnt/docs ext4 auto 0 0 ESC:wq

Teste a montagem e crie um arquivo para teste.

# umount /mnt/docs# mount /mnt/docs

# ls -l /mnt/docstotal 12 drwx------ 2 root root 12288 2009-09-28 00:14 lost+found

# echo ola > /mnt/docs/ola


19

Substituindo um disco ou uma partição em um RAID-1 íntegro

Podemos substituir partições que compõe um RAID-1 existente e íntegro. Inicialmente é preciso criar na máquina a partição substituta, seja no mesmo disco ou em um novo. No curso usaremos o disco sdd.

# fdisk /dev/sddnp1ENTER6tfdw

Adicione a partição ao RAID.

# mdadm /dev/md0 --add /dev/sdd1mdadm: hot added /dev/sdd1

Veja os detalhes do RAID e perceba que o disco foi incluído como sobressalente (spare).

# mdadm --detail /dev/md0/dev/md0: Version : 0.90 Creation Time : Sun Sep 27 22:41:35 2009 Raid Level : raid1 Array Size : 48064 (46.95 MiB 49.22 MB) Used Dev Size : 48064 (46.95 MiB 49.22 MB) Raid Devices : 2 Total Devices : 3 Preferred Minor : 0 Persistence : Superblock is persistent





20

2 8 49 - spare /dev/sdd1

Tal informação também pode ser vista em /proc/mdstat. Note a partição sdd1 marcada como sobressalente (S) e que as duas primeiras estão ativos (U).

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid1 sdd1[2](S) sdb1[0] sdc1[1] 48064 blocks [2/2] [UU] unused devices: <none>

Para retirar uma das partições originais, é preciso marcá-la como falha antes de removê-la. Vamos retirar a sdb1. Ao fazê-lo, o disco sobressalente será automaticamente sincronizado e posto em uso. Podemos verificar o progresso desta troca no arquivo /proc/mdstat.

# mdadm /dev/md0 --fail /dev/sdb1mdadm: set /dev/sdb1 faulty in /dev/md0

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid1 sdd1[2] sdb1[3](F) sdc1[1] 48064 blocks [2/1] [_U] [===========>.........] recovery = 56.3% (27136/48064) finish=0.0min speed=13568K/sec unused devices: <none>

Ao final do processo, verificamos a troca concluída e que a partição sdb1 está marcada como falha (F).

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid1 sdd1[0] sdb1[2](F) sdc1[1] 48064 blocks [2/2] [UU] unused devices: <none>

# mdadm --detail /dev/md0/dev/md0: Version : 0.90 Creation Time : Sun Sep 27 22:41:35 2009 Raid Level : raid1 Array Size : 48064 (46.95 MiB 49.22 MB) Used Dev Size : 48064 (46.95 MiB 49.22 MB) Raid Devices : 2 Total Devices : 3 Preferred Minor : 0


21

Persistence : Superblock is persistent



Number Major Minor RaidDevice State 0 8 49 0 active sync /dev/sdd1 1 8 33 1 active sync /dev/sdc1

2 8 17 - faulty spare /dev/sdb1

Agora podemos remover a partição do RAID.

# mdadm /dev/md0 --remove /dev/sdb1mdadm: hot remove /dev/sdb1

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid1 sdd1[0] sdc1[1] 48064 blocks [2/2] [UU] unused devices: <none>

# mdadm --detail /dev/sdb1/dev/md0: Version : 0.90 Creation Time : Sun Sep 27 22:41:35 2009 Raid Level : raid1 Array Size : 48064 (46.95 MiB 49.22 MB) Used Dev Size : 48064 (46.95 MiB 49.22 MB) Raid Devices : 2 Total Devices : 2 Preferred Minor : 0 Persistence : Superblock is persistent



22



Caso queira manter esta partição como sobressalente, basta adicioná-la novamente.

# mdadm /dev/md0 -add /dev/sdb1 mdadm: added /dev/sdb1

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid1 sdb1[2](S) sdd1[0] sdc1[1] 48064 blocks [2/2] [UU] unused devices: <none>





2 8 17 - spare /dev/sdb1


23

Removendo permanentemente uma partição do RAID

Ao remover uma partição do RAID é preciso limpar seus dados e as informações sobre a configuração do RAID contida nela.

Se a partição a ser removida for uma sobressalente, não é preciso marcá-la como falha. Caso contrário, este passo é mandatório. Vamos remover permanentemente a partição sdb1 de nosso RAID.

Como ela está como sobressalente, não é preciso marcá-la como falha primeiro.

# mdadm /dev/md0 --remove /dev/sdb1mdadm: hot removed /dev/md0

Os dados do RAID são armazenados no superblock da partição e removê-la do RAID não apaga estes dados, o que permite adicioná-la novamente ao mesmo original RAID sem maiores esforços para o kernel. Isto pode ser comprovado quando examinamos a partição removida e vemos que as configurações do RAID ainda estão lá.

# mdadm --examine /dev/sdb1/dev/md0: Version : 0.90.00 UUID : 3d981197:4cba768c:9e68b2c8:17b61269 Creation Time : Sun Sep 27 22:41:35 2009 Raid Level : raid1 Used Dev Size : 48064 (46.95 MiB 49.22 MB) Array Size : 48064 (46.95 MiB 49.22 MB) Raid Devices : 2 Total Devices : 3 Preferred Minor : 0

Update Time : Mon Sep 28 01:20:07 2009 State : clean Active Devices : 2 Working Devices : 3 Failed Devices : 0 Spare Devices : 1 Checksum : 7f1da86d - correct Events : 194

Number Major Minor RaidDevice State this 2 8 17 2 spare /dev/sdb1

0 0 8 49 0 active sync /dev/sdd1 1 1 8 33 1 active sync /dev/sdc1 2 2 8 17 2 spare /dev/sdb1


24

Para remover as informações, é preciso limpar o superblock da partição.

# mdadm --zero-superblock /dev/sdb1

# mdadm --examine /dev/sdb1mdadm: No md superblock detected on /dev/sdb1.

Para finalizar, remova a partição do disco. Caso queira limpar os dados da partição e não somente apagar a tabela de partição do disco, escreva zeros ou valores aleatórios nela antes de removê-la.

# dd if=/dev/zero of=/dev/sdb1# dd if=/dev/urandom of=/dev/sdb1

# fdisk /dev/sdbdw

Substituindo um disco ou uma partição em um RAID-1 danificado

Uma das formas de danificar um RAID-1 é através de uma falha em um dos discos que o compõe. No curso, agiremos como se o disco sdc falhou e substituído por outro.

# shutdown -h 0

Acesse as configurações de sua máquina virtual. Na opção Discos Rígidos (Hard Disks), substitua o disco rd2.vdi no Slot SATA Port 2 pelo disco rd4.vdi. Isto fará com que o disco sdc seja iniciado pleo kernel epor ser novo, sem nenhuma informação sobre o RAID-1


25

Salve a configuração, clique em Ok e inicie a máquina virtual. Note que o RAID-1 está disponível.

# cat /mnt/docs/olaola

Contudo, ele está danificado pela falta de um dos discos que o compõe. Note que apenas um dos dois discos está sinalizado como up [U_]. ,

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid1 sdd1[0] 48064 blocks [2/1] [U_] unused devices: <none>


Update Time : Tue Oct 13 22:27:06 2009 State : clean, degraded Active Devices : 1 Working Devices : 1 Failed Devices : 0 Spare Devices : 0


Number Major Minor RaidDevice State 0 8 49 0 active sync /dev/sdd1 1 0 0 1 removed

Durante a inicialização automática do raid, o kernel registrou a falha.

# dmesg | grep md:(listagem parcial)md: Autodetecting RAID arrays. md: invalid raid superblock magic on sdb1 md: sdb1 does not have a valid v0.90 superblock, not importing!


26

md: Scanned 2 and added 1 devices. md: autorun ... md: considering sdd1 ... md: adding sdd1 ... md: created md0 md: bind<sdd1> md: running: <sdd1>

Vamos restaurar o RAID-1 adicionando uma partição ao RAID. Comece criando a partição.

# fdisk /dev/sdcnp1ENTER6tfdw

# mdadm /dev/md0 --add /dev/sdc1mdadm: added /dev/sdc1

Verifique que o RAID-1 está íntegro.

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid1 sdc1[1] sdd1[0] 48064 blocks [2/2] [UU] unused devices: <none>


Update Time : Tue Oct 13 22:41:10 2009 State : clean Active Devices : 2 Working Devices : 2


27

Failed Devices : 0 Spare Devices : 0



Aumentando o número de discos ativos em um RAID

Com Linux é possível adicionar discos aos RAID 1, 4, 5 e 6 usando o modo Grow para modificar o atributo raid-devices. Vamos fazer um RAID-1 com três discos para obter maior desempenho de leitura em nosso sistema.

# mdadm --grow /dev/md0 --raid-devices=3

Note que agora o kernel espera três discos no RAID md0, mas apenas dois deles estão UP, o que o torna degradado.

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid1 sdc1[1] sdd1[0] 48064 blocks [3/2] [UU_] unused devices: <none> # mdadm --detail /dev/md0/dev/md0: Version : 0.90 Creation Time : Sun Sep 27 22:41:35 2009 Raid Level : raid1 Array Size : 48064 (46.95 MiB 49.22 MB) Used Dev Size : 48064 (46.95 MiB 49.22 MB) Raid Devices : 3 Total Devices : 2 Preferred Minor : 0 Persistence : Superblock is persistent

Update Time : Tue Oct 13 22:58:57 2009 State : clean, degraded Active Devices : 2 Working Devices : 2 Failed Devices : 0 Spare Devices : 0

UUID : 3d981197:4cba768c:9e68b2c8:17b61269


28

Events : 0.380

Number Major Minor RaidDevice State 0 8 49 0 active sync /dev/sdd1 1 8 33 1 active sync /dev/sdc1 2 0 0 2 removed

Vamos establizar o RAID inserindo uma nova partição. Crie uma nova partição no disco sdb e a adicione ao RAID.

# fdisk /dev/sdbnp1ENTER6tfdw

# mdadm /dev/md0 --add /dev/sdb1mdadm: added /dev/sdb1

Veja que a nova partição não entrou como spare (sobressalente) e sim como um disco ativo [UUU].

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid1 sdb1[2] sdc1[1] sdd1[0] 48064 blocks [3/3] [UUU] unused devices: <none>


Update Time : Tue Oct 13 23:03:58 2009 State : clean Active Devices : 3 Working Devices : 3


29

Failed Devices : 0 Spare Devices : 0


Number Major Minor RaidDevice State 0 8 49 0 active sync /dev/sdd1 1 8 33 1 active sync /dev/sdc1 2 8 17 2 active sync /dev/sdb1

Diminuindo o número de discos do RAID

Também podemos reduzir o número de discos do RAID estabelecendo um novo valor para o atributo raid-devices através do modo Grow.

Inicialmente, é preciso remover as partições a serem retiradas deixando apenas a quantidade condizente ao novo tamanho do RAID. Vamos remover a partição sdb1 para deixar nosso RAID com tamanho dois.

# mdadm /dev/md0 --fail /dev/sdb1mdadm: set /dev/sdb1 faulty in /dev/md0

# mdadm /dev/md0 --remove /dev/sdb1mdadm: hot removed /dev/sdb1

Agora diminua o número de partições do RAID para dois.

# mdadm --grow /dev/md0 --raid-devices=2

Note que o RAID está íntegro.


Update Time : Tue Oct 13 23:12:06 2009 State : clean Active Devices : 2


30

Working Devices : 2 Failed Devices : 0 Spare Devices : 0



Monitorando um RAID

mdadm oferece recursos para monitorar eventos que ocorrem com os RAID. Através do modo monitor é possível enviar e-mails, executar programas ou enviar os eventos para o syslog. Em seu modo mais simples, o monitoramento põe o programa executando como um processo em foreground (primeiro plano) e envia mensagens para a tela.

# mdadm --monitor /dev/md0

Em outro terminal, logue como root e execute as atividades abaixo no RAID para vermos os eventos capturados pelo monitoramento.

<ALT><F2>

# mdadm /dev/md0 --fail /dev/sdc1

<ALT> <F1>(mensagem exibida por mdadm em monitoramento)Oct 18 19:31:20: Fail on /dev/md0 /dev/sdc1

<ALT><F2># mdadm /dev/md0 --remove /dev/sdc1

<ALT> <F1>(mensagem exibida por mdadm em monitoramento)Oct 18 19:31:20: Fail on /dev/md0 /dev/sdc1

<ALT><F2># mdadm /dev/md0 --add /dev/sdc1

<ALT> <F1>(mensagem exibida por mdadm em monitoramento)Oct 18 19:31:20: Fail on /dev/md0 /dev/sdc1Oct 18 19:33:15: RebuildStarted on /dev/md0 unknown device Oct 18 19:33:16: RebuildFinished on /dev/md0 unknown device


31

Oct 18 19:33:16: SpareActive on /dev/md0 /dev/sdc1

<CTRL><C>

Caso queira enviar os eventos para o syslog, use o parâmetro syslog.

# mdadm --monitor --syslog /dev/md0

<ALT><F2># mdadm /dev/md0 --fail /dev/sdc1# mdadm /dev/md0 --remove /dev/sdc1# mdadm /dev/md0 --add /dev/sdc1

# tail /var/log/messages(listagem parcial)Oct 18 19:39:44 virtualtoto mdadm[5115]: RebuildFinished event detected on md device /dev/md0 Oct 18 19:39:44 virtualtoto mdadm[5115]: SpareActive event detected on md device /dev/md0, component device /dev/sdc1 Oct 18 19:39:44 virtualtoto mdadm[5172]: RebuildFinished event detected on md device /dev/md0 Oct 18 19:39:44 virtualtoto mdadm[5172]: SpareActive event detected on md device /dev/md0, component device /dev/sdc1 Oct 18 19:40:01 virtualtoto cron[5180]: (root) CMD (test -x /usr/sbin/run-crons && /usr/sbin/run-crons )

Caso queira que os eventos sejam enviados por e-mail, use o parâmetro mail seguido do e-mail de destino. Um servidor local SMTP será necessário para enviar a mensagem

# mdadm --monitor --mail [email protected] /dev/md0# mdadm --monitor --syslog --mail [email protected] /dev/md0

Quando temos vários RAID a serem monitorados, é possível usar o parâmetro scan para localizá-los automaticamente.

# mdadm --monitor --syslog --mail [email protected] --scan

Caso queira executar o mdadm em backgroud (segundo plano), use o parâmetro daemonise. A número exibido é o PID do processo.

# mdadm --monitor --daemonise --syslog --mail [email protected] --scan5515

Uma boa prática é adicionar este comando em um script de inicialização de seu computador.

Em Gentoo.# echo “mdadm --monitor --daemonise --syslog --mail [email protected] --scan” > /etc/conf.d/local.start


32

Caso queira encerrar o monitoramento, basta enviar uma mensagem TERM ao processo.

# kill -TERM 5515

Removendo um RAID

Para remover um RAID de nosso computador, é preciso garantir que ele não esteja em uso.

# umount /dev/md0

Depois, remova o RAID.

# mdadm --stop /dev/md0mdadm: stopped /dev/md0

Note que o RAID não existe mais.


Atenção, as partições que compunham o RAID ainda mantém os dados armazenados nelas. Se você recriar o mesmo RAID com estas mesmas partições, os dados estarão lá disponíveis para uso. Para retirar todas as informações, escreva zeros ou dados aleatórios na partição e apague os superblock.

# dd if=/dev/zero of=/dev/sdb1# dd if=/dev/urandom of=/dev/sdc1# dd if=/dev/zero of=/dev/sdd1

# mdadm --zero-superblock /dev/sdb1# mdadm --zero-superblock /dev/sdc1# mdadm --zero-superblock /dev/sdd1

E depois remova as partições. Não faça isto neste curso pois as usaremos no RAID-5 a seguir.

# fdisk /dev/sdbdw

# fdisk /dev/sdcdw

# fdisk /dev/sdddw


33

Criando um RAID-5

RAID-5 é um esquema onde uma paridade é calculada a cada faixa de dados e distribuída em todos os discos. Tal mecanismo permite que o RAID esteja operacional, mesmo em caso de quebra de um dos discos.

As operações realizadas com o mdadm para o RAID-1 são iguais para RAID-5, apenas variando a os valores do parâmetros em sua criação. Vamos criar um RAID-5 com três partições usando a sintaxe abaixo.

# mdadm --create /dev/md0 --level=5 --raid-devices=3 /dev/sd{b,c,d}1mdadm: /dev/md0 stared

Veja que o RAID-5 está ativo.

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid5 sdd1[2] sdc1[1] sdb1[0] 96128 blocks level 5, 64k chunk, algorithm 2 [3/3] [UUU] unused devices: <none>

# mdadm --detail /dev/md0/dev/md0: Version : 0.90 Creation Time : Wed Oct 14 00:28:32 2009 Raid Level : raid5 Array Size : 96128 (93.89 MiB 98.44 MB) Used Dev Size : 48064 (46.95 MiB 49.22 MB) Raid Devices : 3 Total Devices : 3 Preferred Minor : 0 Persistence : Superblock is persistent

Update Time : Wed Oct 14 00:28:46 2009 State : clean


34

Active Devices : 3 Working Devices : 3 Failed Devices : 0 Spare Devices : 0

Layout : left-symmetric Chunk Size : 64K

UUID : 692198a5:c4e81632:262558d0:d955e43e Events : 0.36

Number Major Minor RaidDevice State 0 8 17 0 active sync /dev/sdb1 1 8 33 1 active sync /dev/sdc1 2 8 49 2 active sync /dev/sdd1

Note que uma área equivalente a uma partição foi consumida pela paridade no RAID.

Durante a criação do RAID-5 podemos definir o tamanho o bloco de dados em cada faixa do RAID através do parâmetro chunk, o padrão é 64KB. Outro parâmetro interessante é o layout que determina o algoritmo usado para calcular a paridade. Por padrão, mdadm usa left-symmetric, identificado pelo número 2 em /proc/mdstat, e é considerado o melhor dos algoritmos disponíveis em Linux para RAID-5.

Vamos recriar o RAID-5 para vermos o uso destes parâmetros.

# mdadm --stop /dev/md0

# mdadm --create /dev/md0 --level=5 --chunk=128 --layout=right-symmetric --raid-devices=3 /dev/sd{b,c,d}1

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid5 sdd1[2] sdc1[1] sdb1[0] 9600 blocks level 5, 128k chunk, algorithm 3 [3/3] [UUU]

Para aumentar o número de discos em um RAID-5, acrescente o disco como spare (sobressalente) e depois mude o atributo raid-devices para ativar o disco.

Remova o RAID para usarmos os discos em outros tipos de RAID.



35

Criando um RAID-0

Um RAID-0 permite que os dados sejam gravados e lidos de forma distribuída nos discos que o compõe. Nenhum mecanismo de proteção é oferecido em caso de quebra de um dos discos.

Para criar um RAID-0, use a seguinte sintaxe.

# mdadm --create /dev/md0 --level=0 --raid-devices=3 /dev/sd{b,c,d}1 mdadm: /dev/md0 stared

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid0 sdd1[2] sdc1[1] sdb1[0] 144192 blocks 64k chunks unused devices: <none>

# mdadm --detail /dev/md0/dev/md0: Version : 0.90 Creation Time : Wed Oct 14 00:26:57 2009 Raid Level : raid0 Array Size : 144192 (140.84 MiB 147.65 MB) Raid Devices : 3 Total Devices : 3 Preferred Minor : 0 Persistence : Superblock is persistent

Update Time : Wed Oct 14 00:26:57 2009 State : clean Active Devices : 3 Working Devices : 3 Failed Devices : 0 Spare Devices : 0


36

Chunk Size : 64K

UUID : b125725b:434e8b2f:f9619050:6fb58867 Events : 0.1


Note que o RAID-0 disponibiliza toda área das partições para uso.

mdadm não oferece mecanismos de aumentar ou diminuir partições ao RAID-0.




37

Criando um RAID Linear

Um RAID Linear permite que uma partição possa ser usada como extensão de outra quando esta estiver com toda sua capacidade ocupada. disco seja adicionado os dados sejam gravados e lidos de forma distribuída nos discos que o compõe. Nenhum mecanismo de proteção é oferecido em caso de quebra de um dos discos.

Para criar um RAID Linear, use a seguinte sintaxe.

# mdadm --create /dev/md0 --level=linear --raid-devices=2 /dev/sd{b,c}1 mdadm: /dev/md0 stared

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active linear sdc1[1] sdb1[0] 96128 blocks 64k rounding unused devices: <none>

# mdadm --detail /dev/md0/dev/md0: Version : 0.90 Creation Time : Sat Oct 17 19:11:26 2009 Raid Level : linear Array Size : 96128 (93.89 MiB 98.44 MB) Raid Devices : 2 Total Devices : 2 Preferred Minor : 0 Persistence : Superblock is persistent

Update Time : Sat Oct 17 19:14:56 2009 State : clean Active Devices : 2 Working Devices : 2 Failed Devices : 0


CBA

ED

Linear md0

sdb1 sdc1

38

Spare Devices : 0

Rounding : 64K

UUID : ba495196:daf2d405:5ab75c03:da11bb99 Events : 0.3


Note que o RAID Linear disponibiliza toda área das partições para uso.

mdadm não oferece mecanismos de aumentar ou diminuir partições ao RAID Linear.




39

Criando um RAID-6

RAID-6 é um esquema onde duas paridades são calculadas a cada faixa de dados e distribuídas em todos os discos. Tal mecanismo permite que o RAID esteja operacional, mesmo em caso de quebra de dois dos discos.

Para usarmos um RAID-6, é preciso quatro discos. Configure sua máquina para ter os quatro discos conforme a configuração abaixo.

Como este disco rd2.vdi era membro de um RAID-1 anteriormente criado, o Kernel o reconheceu e montou o RAID. Vamos remover o RAID-1 antes de criarmos o RAID-6.

# umount /dev/md0# mdadm --stop /dev/md0


40

Depois crie o RAID-6 usando a sintaxe abaixo.

# mdadm --create /dev/md0 --level=6 --raid-devices=4 /dev/sd{b,c,d,e}1mdadm: /dev/md0 stared

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid6 sde1[3] sdd1[2] sdc1[1] sdb1[0] 96128 blocks level 6, 64k chunk, algorithm 2 [4/4] [UUUU] unused devices: <none>



Chunk Size : 64K

UUID : f125bd55:5d228c48:32cfd09c:6533f995 Events : 0.34

Number Major Minor RaidDevice State 0 8 17 0 active sync /dev/sdb1 1 8 33 1 active sync /dev/sdc1 2 8 49 2 active sync /dev/sdd1 3 8 65 3 active sync /dev/sde1

Note que uma área equivalente a duas partições foram consumidas pelas paridades.




41

Criando um RAID-10

RAID-10 possuem o mesmos níveis de tolerância que um RAID-1, porém com mais tolerância a falhas de disco e melhor desempenho.

Crie o RAID-10 usando a sintaxe abaixo.

# mdadm --create /dev/md0 --level=10 --raid-devices=4 /dev/sd{b,c,d,e}1mdadm: /dev/md0 stared

# cat/proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid10 sde1[3] sdd1[2] sdc1[1] sdb1[0] 96128 blocks 64K chunks 2 near-copies [4/4] [UUUU] unused devices: <none>

# mdadm --detail /dev/md0/dev/md0: Version : 0.90 Creation Time : Sat Oct 17 19:38:43 2009 Raid Level : raid10 Array Size : 96128 (93.89 MiB 98.44 MB) Used Dev Size : 48064 (46.95 MiB 49.22 MB) Raid Devices : 4 Total Devices : 4 Preferred Minor : 0 Persistence : Superblock is persistent

Update Time : Sat Oct 17 19:45:52 2009


42

State : clean Active Devices : 4 Working Devices : 4 Failed Devices : 0 Spare Devices : 0

Layout : near=2 Chunk Size : 64K

UUID : 8d7e2fd8:f5868747:95df6126:a3d857e3 Events : 0.34

Number Major Minor RaidDevice State 0 8 17 0 active sync /dev/sdb1 1 8 33 1 active sync /dev/sdc1 2 8 49 2 active sync /dev/sdd1 3 8 65 3 active sync /dev/sde1

Note que apenas metade da área total está disponível para uso.

Outra forma de criar um RAID-10, é combinando dois RAID-1, md0 e md1, em um RAID-0 md2. Isto pode ser feito usando a sintaxe abaixo e pode ser a única saída em kernels sem o suporte à personalidade RAID-10.

# mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sd{b,c}1# mdadm --create /dev/md1 --level=1 --raid-devices=2 /dev/sd{d,e}1# mdadm --create /dev/md2 --level=0 --raid-devices=2 --chuck=64 /dev/md{0,1}

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md2 : active raid0 md1[1] md0[0] 96000 blocks 64k chunks md1 : active raid1 sde1[1] sdd1[0] 48064 blocks [2/2] [UU] md0 : active raid1 sdc1[1] sdb1[0] 48064 blocks [2/2] [UU] unused devices: <none>

# mdadm --detail /dev/md0/dev/md0: Version : 0.90 Creation Time : Wed Oct 14 00:54:00 2009 Raid Level : raid1 Array Size : 48064 (46.95 MiB 49.22 MB) Used Dev Size : 48064 (46.95 MiB 49.22 MB)


43

Raid Devices : 2 Total Devices : 2 Preferred Minor : 0 Persistence : Superblock is persistent


UUID : ad16b267:96f65b67:c352fde5:1f60f65b Events : 0.34




UUID : a07463e1:ad57a6b2:349dd039:80505610 Events : 0.34

Number Major Minor RaidDevice State 0 8 49 0 active sync /dev/sdd1 1 8 65 1 active sync /dev/sde1

# mdadm --detail /dev/md2/dev/md2: Version : 0.90


44

Creation Time : Wed Oct 14 00:55:59 2009 Raid Level : raid0 Array Size : 96000 (93.77 MiB 98.30 MB) Raid Devices : 2 Total Devices : 2 Preferred Minor : 2 Persistence : Superblock is persistent


Chunk Size : 64K

UUID : 63c732af:ad34a350:050578fa:beb23aea Events : 0.1

Number Major Minor RaidDevice State 0 9 0 0 active sync /dev/block/9:0 1 9 1 1 active sync /dev/block/9:1

Note que apenas metade da área total está disponível para uso e que os dispositivos que compõe o RAID md2 são identificados pelo MAJOR e MINOR number.

Para usá-lo, formate o RAID-10 /dev/md2 e o monte.


# mdadm --stop /dev/md2# mdadm --stop /dev/md1# mdadm --stop /dev/md0


45

Criando um RAID-0+1

RAID-0+1 permite a mesma tolerância que um RAID-5, porém com maior desempenho para escrita e gravação. Como não possuem uma personalidade nativa no kernel, para criá-los é preciso combinar dois RAID-0, md0 e md1, em um RAID-1 md2.

Isto pode ser feito usando a seguinte sintaxe.

# mdadm --create /dev/md0 --level=0 --chunk=64 --raid-devices=2 /dev/sd{b,c}1# mdadm --create /dev/md1 --level=0 --chuck=64 --raid-devices=2 /dev/sd{d,e}1# mdadm --create /dev/md2 --level=1 --raid-devices=2 --chuck=64 /dev/md{0,1}

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md2 : active raid1 md1[1] md0[0] 96064 blocks [2/2] [UU] md1 : active raid0 sde1[1] sdd1[0] 96128 blocks 64k chunks md0 : active raid0 sdc1[1] sdb1[0] 96128 blocks 64k chunks unused devices: <none>

# mdadm --detail /dev/md0/dev/md0: Version : 0.90 Creation Time : Wed Oct 14 01:12:32 2009 Raid Level : raid0


46

Array Size : 96128 (93.89 MiB 98.44 MB) Raid Devices : 2 Total Devices : 2 Preferred Minor : 0 Persistence : Superblock is persistent


Chunk Size : 64K

UUID : 95af0260:ae4f8603:6efc85b2:4e2b3d82 Events : 0.1


# mdadm --detail /dev/md1/dev/md1: Version : 0.90 Creation Time : Wed Oct 14 01:12:45 2009 Raid Level : raid0 Array Size : 96128 (93.89 MiB 98.44 MB) Raid Devices : 2 Total Devices : 2 Preferred Minor : 1 Persistence : Superblock is persistent


Chunk Size : 64K

UUID : 6b0bf77b:bacdf592:49435fba:01164f30 Events : 0.1

Number Major Minor RaidDevice State 0 8 49 0 active sync /dev/sdd1 1 8 65 1 active sync /dev/sde1


47



UUID : 2968b9cf:3d91a33c:c3221658:f736a513 Events : 0.34


Note que toda a área é disponibilizada e que os dispositivos que compõe o RAID md2 são identificados pelo MAJOR e MINOR number.




48

Criando um RAID-50

RAID-50 permitem uma tolerância maior que RAID-5 e permitem maiores taxas de leitura. Para criar um RAID-50, é preciso combinar dois RAID-5, md0 e md1, em um RAID-0 md2.

Utilizaremos sies partições para construir o RAID-50. Crie três partições nos discos sdb, sdc e sdd.

# fdisk/dev/sdbnp2ENTERENTERt2fdw

# fdisk/dev/sdcnp2ENTERENTERt2fdw

# fdisk/dev/sddn


49

p2ENTERENTERt2fdw

Depois crie o RAID-50 usando a seguinte sintaxe.

# mdadm --create /dev/md0 --level=5 --raid-devices=3 /dev/sd{b,c,d}1# mdadm --create /dev/md1 --level=5 --raid-devices=3 /dev/sd{b,c,d}2# mdadm --create /dev/md2 --level=0 --raid-devices=2 --chuck=64 /dev/md{0,1}

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md2 : active raid0 md1[1] md0[0] 192256 blocks 64k chunks md1 : active raid5 sdd2[2] sdc2[1] sdb2[0] 96256 blocks level 5, 64k chunk, algorithm 2 [3/3] [UUU] md0 : active raid5 sdd1[2] sdc1[1] sdb1[0] 96128 blocks level 5, 64k chunk, algorithm 2 [3/3] [UUU] unused devices: <none>


Update Time : Sat Oct 17 20:01:22 2009 State : clean Active Devices : 3 Working Devices : 3 Failed Devices : 0 Spare Devices : 0

Layout : left-symmetric


50

Chunk Size : 64K

UUID : fd67ccb0:31a2fe08:7624063d:25f9d40e Events : 0.34




Layout : left-symmetric Chunk Size : 64K

UUID : 37ffe562:332222ef:16c128d0:8a0b97ca Events : 0.34


# mdadm --detail /dev/md2/dev/md2: Version : 0.90 Creation Time : Sat Oct 17 20:01:21 2009 Raid Level : raid0 Array Size : 192256 (187.78 MiB 196.87 MB) Raid Devices : 2 Total Devices : 2


51

Preferred Minor : 2 Persistence : Superblock is persistent


Chunk Size : 64K

UUID : ff481116:238a0534:3f85d5c0:a5fb097e Events : 0.1


Note que uma área equivalente a duas partições foi gasta com a paridade.

Para usá-lo, formate o RAID-50 /dev/md2 e o monte.



Removendo as partições para reutilizarmos os discos nos módulos seguintes

Vamos remover as partições existentes nos discos usados no curso de RAID para não nos confundirmos com as mensagens gerados pelo driver MD nos módulos seguintes do curso.

# mdadm --zero-superblock /dev/sdb1# mdadm --zero-superblock /dev/sdb2# mdadm --zero-superblock /dev/sdc1# mdadm --zero-superblock /dev/sdc2# mdadm --zero-superblock /dev/sdd1# mdadm --zero-superblock /dev/sdd2# mdadm --zero-superblock /dev/sde1# mdadm --zero-superblock /dev/sde2

Apague todas as partições dos discos usando fdisk.


52

Device Mapper

Device Mapper é uma parte do kernel Linux 2.6 que permite administrador criar volumes virtuais que referenciam dispositivos de blocos reais da máquina. Esta virtualização permite aos administradores, por exemplo, isolar discos físicos da máquina dos sistemas de arquivos, dando-lhes uma série de flexibilidades.

Uma destas flexibilidades permite inserir ou remover novos discos, redimensionar os volumes virtuais e consequentemente alterar a área disponível para os sistemas de arquivos. Dependendo do sistema de arquivos utilizado, o redimensionamento pode ser feito on-line e sem interrupção dos serviços nele instalados ou nos arquivos usados pelos programas em execução.

Device Mapper é composto pela biblioteca /usr/lib/libdevmapper.so que expõe o recurso para as aplicações em modo usuário e por algumas ferramentas. Contudo, o uso destas ferramentas é tão pouco amigável para explorar toda sua capacidade que uma camada de abstração das próprias ferramentas foi criada em modo usuário para facilitar estas operações. Exemplos disto são LVM2 e DM_CRYPT.

Esta complexidade é tanta que neste curso só veremos o recurso de snapshot, que é um recurso de tirar um cópia de uma volume sem degradar o sistema, com LVM2.


53

Identificando o suporte ao Device Mapper no kernel Linux

Para ter suporte ao Device Mapper, é preciso que o kernel esteja compilado com este suporte. Isto pode ser verificado avaliando o arquivo /proc/config.gz, que contém a configuração do kernel em execução. Procure por CONFIG_BLK_DEV_DM. Se o recurso foi compilado como módulo, haverá um valor m no lugar de y.

# zcat /proc/config.gz | grep CONFIG_BLK_DEV_DMCONFIG_BLK_DEV_DM=y

Se seu kernel não expõe o arquivo /proc/config.gz, você pode identificar o suporte através das informações exibidas durante sua carga.

# dmesg | grep ^device-mapperdevice-mapper: ioctl: 4.14.0-ioctl (2008-04-23) initialised: [email protected]

Habilitando Device Mapper no kernel Linux

Caso seu kernel não esteja com o device mapper habilitado, é preciso compilá-lo. Carregue o menu de configuração.

# cd /usr/src/linux

# make menuconfig



<*> Device mapper support<*> Crypt target support<*> Snapshot support<*> Mirror target

Saia do menu, salve a configuração e compile o novo kernel

# make bzImage

# make modules

Faça a instalação do kernel e seus módulos para que possamos usá-lo e depois configure o GRUB para tê-lo como padrão. Neste curso o menu do GRUB já está configurado para carregar um kernel de nome kernel-2.6.30-raid-lvm2, cujo title é Gentoo Kernel 2.6.30-r6 (with RAID and LVM2).


54

# make modules_install

# cp arch/x86/boot/bzImage /boot/kernel-2.6.30-r6-raid-lvm2

# vi /boot/grub/menu.lstggI(mude a linha default 1 para default 2)ESC:wq

# cat /boot/grub/menu.lstdefault 2 timeout 30 color black/white

splashimage=(hd0,0)/grub/robin.xpm.gz

title Gentoo Kernel 2.6.30-r6 root (hd0,0) kernel /kernel-2.6.30-r6 root=/dev/sda3 video=vesafb:ywrap,mtrr:3 vga=0x303

title Gentoo Kernel 2.6.30-r6 (with RAID) root (hd0,0) kernel /kernel-2.6.30-r6-raid root=/dev/sda3 video=vesafb:ywrap,mtrr:3 vga=0x303

title Gentoo Kernel 2.6.30-r6 (with RAID and LVM2) root (hd0,0) kernel /kernel-2.6.30-r6-raid-lvm2 root=/dev/sda3 video=vesafb:ywrap,mtrr:3 vga=0x303

Reinicialize a máquina e de carga no sistema através da opção Gentoo Kernel 2.6.30-r6 (with RAID and LVM2).


55

Instalando a biblioteca e ferramentas Device Mapper

Use seu gerenciador de pacotes de sua distribuição para obter a biblioteca e ferramentas usa pelo device mapper em modo usuário.

Em Gentoo :

# emerge sys-fs/device-mapper

Criando um volume lógico de bloco usando Device Mapper

Com device mapper podemos criar um dispositivo de bloco que abstraem o disco ou partição física na visão do administrador, dando a ele mais flexibilidade de gerenciar suas áreas de armazenamento.

Suponhamos que temos uma partição ou disco em nossa máquina e não queremos alocá-lo inteiramente para um único sistema de arquivos. Usando a ferramenta dmsetup create, podemos criar um volume lógico que ocuparia parte desta partição, deixando uma área livre no disco para futuro crescimento ou alocação de novos volumes.

Vamos criar um volume lógico chamado public ocupando 50 MB do disco /dev/sdb. Para saber quanto é metade do disco, precisamos saber quantos setores de 512 bytes tem este disco. Isto pode ser obtido com o comando blockdev.

# blockdev --getsz /dev/sdb204800

Nosso disco tem então 512 bytes * 204800 setores = 104857600 bytes = 100 MB. Logo, 50 MB são 102400 setores. De posse deste tamanho, vamos escrever no disco em uma notação device mapper que queremos alocar apenas metade para nosso volume lógico.

# echo 0 102400 linear /dev/sdb 0 | dmsetup create publico

Onde o primeiro número indica onde começa o volume lógico, o segundo onde termina e o último o primeiro setor deste disco. Linear é uma das formas como os blocos serão escritos no volume, neste caso, sequencialmente.

Isto criará um volume chamado publico no diretório /dev/mapper/publico.

Para usar o volume lógico, formate-o com o sistema de arquivos que desejar.

# mkfs -t ext4 /dev/mapper/publico


56

Depois monte-o em algum diretório e use-o normalmente.

# mkdir /mnt/publico

# mount /dev/mapper/publico /mnt/publico

# df -h /mnt/publicoFilesystem Size Used Avail Use% Mounted on /dev/mapper/publico 49M 4.8M 42M 11% /mnt/publico

# cp /var/log/messages /mnt/publico

Criando um segundo volume em um mesmo disco

Para criar um segundo volume no mesmo disco já usado pelo device mapper, usamos o mesmo procedimento, apenas precisamos tomar o cuidado de não sobrepormos os setores.

Nosso volume publico ocupa os primeiros 102400 setores de um disco de 204800 setores. Para criarmos um outro volume de 50 MB, usaremos o seguinte endereçamento na sintaxe.

# echo 0 102400 linear /dev/sdb 102400 | dmsetup create restrito

Para usá-lo, faça os mesmos procedimentos.

# mkfs -t ext3 /dev/mapper/restrito

Depois monte-o em algum diretório e use-o normalmente.

# mkdir /mnt/restrito

# mount /dev/mapper/restrito /mnt/restrito

# df -h /mnt/restritoFilesystem Size Used Avail Use% Mounted on /dev/mapper/restrito 49M 4.9M 42M 11% /mnt/restrito


57

Obtendo informações sobre os volumes

Podemos obter informações sobre a configuração de cada volume dmsetup status.

# dmsetup statuspublico: 0 102400 linear restrito: 0 102400 linear

Ou obter informações um pouco mais detalhadas com dmsetup info.

# dmsetup infoName: publico State: ACTIVE Read Ahead: 256 Tables present: LIVE Open count: 1 Event number: 0 Major, minor: 254, 0 Number of targets: 1

Name: restrito State: ACTIVE Read Ahead: 256 Tables present: LIVE Open count: 1 Event number: 0 Major, minor: 254, 1 Number of targets: 1

Ativando o volume após a inicialização da máquina

Após a inicialização da máquina, os volumes não estão disponíveis por padrão. É preciso carregá-los ou recriá-los. Para evitar de repetir todo o processo e correndo o grave risco de perder dados no processo, podemos guardar as informações com o comando dmsetup table no arquivo /etc/dmtab, que será usado por algum script na inicialização de sua máquina para disponibilizá-los.

# dmsetup tablerestrito: 0 102400 linear 7:0 102400 publico: 0 102400 linear 7:0 0

# dmsetup table >> /etc/dmtab

Reinicie a máquina para testarmos o uso do recurso e logue novamente como root.

# reboot


58

Veja que os volumes estão disponíveis. Isto ocorreu porque um script foi executado para ativar os volumes durante a inicialização da máquina.

Em Gentoo/sbin/rc/etc/init.d/device-mapper (baselayout-2)/lib/rcscripts/addons/dm-start.shhttp://www.gentoo.org/doc/en/handbook/handbook-x86.xml?part=2&chap=4

Removendo um volume

Para remover um volume, usamos o comando dmsetup remove. Os volumes não podem estar em uso.

# umount /mnt/publico

# umount /mnt/restrito

# dmsetup remove /dev/mapper/publico

Podemos remover todos de uma vez com dmsetup remove_all.

# dmsetup remove_all


59

LVM2

LVM2 é um conjunto de ferramentas em modo usuários que simplificam o uso de Device Mapper. Mesmo em estações de trabalho com grandes discos, administradores podem utilizar LVM2. Por exemplo, há um tempo adquiri um disco de 500GB para usar vários sistema operacionais instalados não virtualizados para estudo e meu Linux no dia a dia. Dividi o disco em 10 partições de 50 GB e usei uma delas para instalar Gentoo.

Com o uso do LVM2, pude controlar o crescimento de menu Gentoo. Quando os 50 GB iniciais foram consumidos, acrescentei outros 50 GB com o LVM2 e ampliei a partição /. Isto permitiu que eu não precisasse mover dados de um grande diretório para a nova partição e tivesse que lidar com pontos de montagem, correndo o risco de no futuro, faltar espaço em uma partição enquanto sobrava na outra.

Na nomenclatura LVM2, discos físicos ou partições são agrupados em Physical Volumes (PV). Nos PV são alocados os Volume Groups (VG). VG podem ser divididos em Logical Volumes (LV) onde são instalados os sistemas de arquivos.

Discos ou partições podem ser inseridos ou retirados dos PV, permitindo redimensionar os VG e, em seguida, os LV e os sistemas de arquivos. O uso de discos deve ser evitado, pois, se o administrador utilizar outros sistema operacionais, eles poderão erroneamente indicar para ele que o disco não contém dados e causar a falsa impressão de que estão disponíveis para uso.

Quando discos ou partições são usados pelo LVM2, eles são divididos unidades mínimas de alocação que são chamados Physical Extents (PE) e Logical Extents (LE). Por padrão, o tamanho é de 4 MB e a relação PE/LE é de um para um. Ao aumentar ou diminuir o tamanho de LV em X LE, implica em alocar o liberar X PE nos discos que os contém. LVM2 não aloca PE continuamente nos discos, ou seja, LE podem estar mapeados para discos diferentes mesmo que um deles tenha área suficiente para acomodar todos os LE.


60

Preparando os discos para usarmos com LVM2 neste curso

Vamos criar duas partições no disco sdc.

# fdisk /dev/sdcnp1ENTER6np2ENTERENTERw

Instalando as ferramentas LVM2

Utilize o gerenciador de pacotes de sua distribuição para instalar o pacote de ferramentas LVM2.

Em Gentoo :

# emerge sys-fs/lvm2

Criando Physical Volumes (PV)

Antes de usarmos discos ou partições em LVM2 é preciso inicializá-las como PV através do comando pvcreate. Vamos habilitar o disco sdb e a partição /dev/sdc1

# pvcreate /dev/sdb /dev/sdc1 Physical volume "/dev/sdb" successfully created Physical volume "/dev/sdc1" successfully created

Uma prática comum e muito mais robusta é usar dispositivos RAID como Physical Volumes.


61

Visualizando informações sobre os PV

Podemos visualizar informações mais detalhadas sobre os PV existentes com o comando pvdisplay.

# pvdisplay "/dev/sdb" is a new physical volume of "100.00 MB" --- NEW Physical volume --- PV Name /dev/sdb VG Name PV Size 100.00 MB Allocatable NO PE Size (KByte) 0 Total PE 0 Free PE 0 Allocated PE 0 PV UUID 7MXvkN-JTgf-1ARF-xWHP-96XS-fdbT-E9hGbW "/dev/sdc1" is a new physical volume of "47.03 MB" --- NEW Physical volume --- PV Name /dev/sdc1 VG Name PV Size 47.03 MB Allocatable NO PE Size (KByte) 0 Total PE 0 Free PE 0 Allocated PE 0 PV UUID JL3qmK-KOcO-u2H9-0eST-9F1g-QhuH-480X0X

Note que não há nenhum Physical Extent (PE) criado, pois nenhum Volume Group (VG) os estão utilizando.

Você pode ver as informações de cada PV individualmente se fornecer o PV como parâmetro.

# pvdisplay /dev/sdb# pvdisplay /dev/sdc1


62

Removendo um PV não alocado

Para retirar um PV que não possui nenhum PE alocado, usamos o comando pvremove.

# pvcreate /dev/sdd Physical volume "/dev/sdb" successfully created

# pvremove /dev/sdd Labels on physical volume "/dev/sdd" successfully wiped

Criando Volume Group (VG)

Em LVM2, PV não podem ser usados diretamente por file systems (sistemas de arquivos). Eles precisam ser associados a Volume Groups (VG) e depois a Logical Volumes (LV). VG não existem fisicamente como dispositivos de bloco na máquina, apenas existe com uma entidade abstrata para o LVM2 e que são registradas como diretórios em /dev.

Um VG pode ser criado utilizando qualquer combinação de PV disponíveis. Vamos criar um VG0 que utilizará o disco /dev/sdb apenas. Em um ambiente real, procure usar nomes mais significativos para seus volumes, como disco-RH e storage-financeiro.

# vgcreate VG0 /dev/sdb Volume group "VG0" successfully created

Podemos ver que o PV /dev/sdb agora está sustentando o VG VG0.

# pvdisplay /dev/sdb --- Physical volume --- PV Name /dev/sdb VG Name VG0 PV Size 100.00 MB / not usable 4.00 MB Allocatable yes PE Size (KByte) 4096 Total PE 24 Free PE 24 Allocated PE 0 PV UUID 7MXvkN-JTgf-1ARF-xWHP-96XS-fdbT-E9hGbW

Note que foram criados nos 100.00 MB disponíveis, 24 Physical Extents de 4096 KB, valor padrão. Como não temos nenhum LV neste VG, nenhum PE ainda foi alocado. O tamanho o PE pode ser determinado ao criar o VG pelo parâmetro -s ou --physycalextentsize, o menor valor é 1KB e deve ser sempre igual a uma potência de 2.


63

Se observarmos o PV /dev/sdc1, ele se mantém disponível.

# pvdisplay /dev/sdc1 "/dev/sdc1" is a new physical volume of "47.03 MB" --- NEW Physical volume --- PV Name /dev/sdc1 VG Name PV Size 47.03 MB Allocatable NO PE Size (KByte) 0 Total PE 0 Free PE 0 Allocated PE 0 PV UUID JL3qmK-KOcO-u2H9-0eST-9F1g-QhuH-480X0X

Visualizando informações sobre os VG

Podemos visualizar informações sobre os VG com o comando vgdisplay. Se nenhum for passado como parâmetro, todos existentes serão exibidos.

# vgdisplay --- Volume group --- VG Name VG0 System ID Format lvm2 Metadata Areas 2 Metadata Sequence No 1 VG Access read/write VG Status resizable MAX LV 0 Cur LV 0 Open LV 0 Max PV 0 Cur PV 1 Act PV 1 VG Size 96.00 MB PE Size 4.00 MB Total PE 24 Alloc PE / Size 0 / 0 Free PE / Size 24 / 96.00 MB VG UUID eF3FAp-kIKn-V4IS-WQT3-yUO3-L6eQ-1yJjWL

Note que ele permite escrita e leitura, redimensionamento e não possui nenhum LV associado, tendo todos seu tamanho para uso.


64

Removendo um VG que não contém Logical Volumes (LV)

Para remover um VG que não contém nenhum LV nele, ou seja, nenhum PE alocado, basta usar o comando vgremove.

# vgremove VG0 Volume group "VG0" successfully removed

Vamos retomar o VG0 para usá-lo no resto do curso.

# vgcreate VG0 /dev/sdb

Criando um segundo VG

O processo de criar outros VG é idêntico ao da criação do primeiro VG na máquina. Basta termos PV disponíveis para criá-los. Vamos criar um VG1 com PE de 8 MB usando a partição /dev/sdc1.

# vgcreate VG1 -s 8MB /dev/sdc1 Volume group "VG1" successfully created

Note o PE de 8MB refletindo na alocação do VG VG1 e do PV /dev/sdc1.

# vgdisplay VG1 --- Volume group --- VG Name VG1 System ID Format lvm2 Metadata Areas 2 Metadata Sequence No 1 VG Access read/write VG Status resizable MAX LV 0 Cur LV 0 Open LV 0 Max PV 0 Cur PV 1 Act PV 1 VG Size 40.00 MB PE Size 8.00 MB Total PE 5 Alloc PE / Size 0 / 0 Free PE / Size 5 / 40.00 MB VG UUID l3O21K-QUiZ-2nCw-Zu1Y-O9oS-yDbr-hd1WHu

# pvdisplay /dev/sdc1


65

--- Physical volume --- PV Name /dev/sdc1 VG Name VG1 PV Size 47.03 MB / not usable 7.03 MB Allocatable yes PE Size (KByte) 8192 Total PE 5 Free PE 5 Allocated PE 0 PV UUID JL3qmK-KOcO-u2H9-0eST-9F1g-QhuH-480X0X

Criando um Logical Volume (LV)

Logical Volumes (LV) são abstrações dos PV e que podem ser usados pelos administradores para armazenar os sistemas de arquivos. LV são criados em um VG e podem ter qualquer tamanho múltiplo do PE deste VG até o tamanho máximo do próprio VG.

Podemos alocar o tamanho do LV desejado informando seu tamanho de KB a Exabytes, MB é o padrão, ou pela a quantidade de Logical Extents (LE) desejados, que são equivalentes em tamanho ao PE do VG que o contém. Para usarmos LE, devemos descobrir o tamanho do PE no VG desejado e dividir o tamanho desejado por ele para sabermos quantos LE precisaremos.

Vamos criar um LV LV0 80 MB que usaremos para receber os documentos da empresa através do comando lvcreate. Como temos dois VG, mas apenas o VG0 comporta este tamanho, o LV0 será criado nele. O parâmetro -n ou --name indica o nome do LV, -L ou --size o tamanho e -l (ele) ou -- extents o tamanho em LE.

# lvcreate -L 80 -n LV0 VG0 Logical group "LV0" created

Podemos ver a alocação do LV no VG0 e perceber que foram necessários 20 PE de 4MB para comportar o LV0 e que ainda temos 4 PE, 16 MB, disponíveis neste VG.

# vgdisplay VG0 --- Volume group --- VG Name VG0 System ID Format lvm2 Metadata Areas 2 Metadata Sequence No 2 VG Access read/write VG Status resizable MAX LV 0 Cur LV 1 Open LV 0 Max PV 0


66

Cur PV 1 Act PV 1 VG Size 96.00 MB PE Size 4.00 MB Total PE 24 Alloc PE / Size 20 / 80.00 MB Free PE / Size 4 / 16.00 MB VG UUID eF3FAp-kIKn-V4IS-WQT3-yUO3-L6eQ-1yJjWL

O mesmo pode ser notado no PV /dev/sdb que sustenta o VG0.

# pvdisplay /dev/sdb --- Physical volume --- PV Name /dev/sdb VG Name VG0 PV Size 100.00 MB / not usable 4.00 MB Allocatable yes PE Size (KByte) 4096 Total PE 24 Free PE 4 Allocated PE 20 PV UUID 7MXvkN-JTgf-1ARF-xWHP-96XS-fdbT-E9hGbW

LV são arquivos de blocos do tipo device mapper, MAJOR number 253, criados pelo LVM2 e estão armazenados no /dev/mapper.

# ls -l /dev/mappertotal 0 lrwxrwxrwx 1 root root 16 2009-10-25 18:15 control -> ../device-mapper brw-rw---- 1 root disk 253, 0 2009-10-25 23:23 VG0-LV0

Há também um link simbólico para cada LV criado em um diretório com o nome do VG em /dev.

# ls -ld /dev/VG?drwx------ 2 root root 19 2009-10-25 23:36 VG0

# ls -l /dev/VG0total 0 lrwxrwxrwx 1 root root 19 2009-10-25 23:36 LV0 -> /dev/mapper/VG0-LV0


67

Visualizando informações sobre um LV

Para visualizarmos as informações sobre um LV, usamos o comando lvdisplay. Se nenhum parâmetro for passado, todos os LV serão exibidos.

# lvdisplay --- Logical volume --- LV Name /dev/VG0/LV0 VG Name VG0 LV UUID kgtsld-nGVq-whCH-H26y-TbCt-V8jq-jxo1R1 LV Write Access read/write LV Status available # open 1 LV Size 80.00 MB Current LE 20 Segments 1 Allocation inherit Read ahead sectors auto - currently set to 256 Block device 253:0

Para vermos informações de um LV específico, passe o arquivo de bloco que o representa como parâmetro.

# lvdisplay /dev/VG0/LV0

Utilizando um LV

Após a criação do LV, podemos usá-lo, bastando formatá-lo com um sistema de arquivos.Vamos formatar o LV0 com ext4 e montá-lo no em /mnt/docs.

# mkfs -t ext4 /dev/VG0/LV0

Crie o diretório /mnt/docs em sua máquina se não houver um e monte o LV nele. Ele foi criado nos exercícios de RAID

# mkdir /mnt/docs

# mount /dev/VG0/LV0 /mnt/docs

Temos agora um LV LV0 montado em /mnt/docs com quase 80 MB disponível para uso, parte foi usada para o controle do sistema de arquivos.

# df -h


68

Filesystem Size Used Avail Use% Mounted on /dev/sda3 4.3G 2.0G 2.1G 49% / udev 10M 96K 10M 1% /dev /dev/sda1 98M 11M 83M 11% /boot shm 125M 0 125M 0% /dev/shm /dev/mapper/VG0-LV0 78M 5.6M 68M 8% /mnt/docs

Aumentando o LV usando área disponível no VG

Se observarmos o VG que contém LV0, podemos perceber que ainda existem 4 PE disponíveis para alocação, perfazendo um total de 16 MB.

# vgdisplay VG0 --- Volume group --- VG Name VG0 System ID Format lvm2 Metadata Areas 2 Metadata Sequence No 2 VG Access read/write VG Status resizable MAX LV 0 Cur LV 1 Open LV 0 Max PV 0 Cur PV 1 Act PV 1 VG Size 96.00 MB PE Size 4.00 MB Total PE 24 Alloc PE / Size 20 / 80.00 MB Free PE / Size 4 / 16.00 MB VG UUID eF3FAp-kIKn-V4IS-WQT3-yUO3-L6eQ-1yJjWL

Podemos ampliar um LV de duas formas com o comando lvextend, dizendo seu novo tamanho ou o acréscimo desejado. Em ambos os casos, podemos dizer a área em KB a Exabytes ou em extents. As duas sintaxes abaixo são equivalentes. Vamos ampliar o LV0 em 16 MB, é preciso passar o arquivo LV para referência-lo.

# lvextend -L+16 /dev/VG0/LV0 Extending logical volume LV0 to 96.00 MB Logical volume LV0 successfully resized

# lvextend -L96 /dev/VG0/LV0 Extending logical volume LV0 to 96.00 MB Logical volume LV0 successfully resized


69

Note que o LV0 teve seu tamanho ampliado, mas o sistema de arquivos ainda enxerga o tamanho antigo.

# lvdisplay /dev/VG0/LV0 --- Logical volume --- LV Name /dev/VG0/LV0 VG Name VG0 LV UUID kgtsld-nGVq-whCH-H26y-TbCt-V8jq-jxo1R1 LV Write Access read/write LV Status available # open 1 LV Size 96.00 MB Current LE 24 Segments 1 Allocation inherit Read ahead sectors auto - currently set to 256 Block device 253:0

# df -h Filesystem Size Used Avail Use% Mounted on (listagem parcial)/dev/mapper/VG0-LV0 78M 5.6M 68M 8% /mnt/docs

Redimensionar o sistema de arquivo é um processo que vária de acordo com o ipo utilizado. Alguns possuem o suporte on-line, outros precisam que o volume esteja desmontado. Outros ainda, não oferecem o suporte, sendo necessário uma operação de backup e restore com uma nova formatação.Para ampliar um sistema de arquivos ext4 usamos o comando volume resize2fs. Se nenhum tamanho for informado, a ampliação ocupará toda a área disponível no LV.

# resize2fs /dev/VG0/LV0resize2fs 1.41.3 (12-Oct-2008)Filesystem at /dev/VG0/LV0 is mounted on /mnt/docs; on-line resizing required old desc_blocks = 1, new_desc_blocks = 1 Performing an on-line resize of /dev/VG0/LV0 to 98304 (1k) blocks. The filesystem on /dev/VG0/LV0 is now 98304 blocks long.

O que pode ser notado ao rever novamente a área disponível.



70

Ampliando um VG e um LV usando um novo PV

Quando a quantidade de PE livres em um VG não for suficiente para atender a necessidade de crescimento, é preciso adicionar um novo PV ao VG. Vamos adicionar a partição /dev/sdc2 ao VG0.Primeiro é preciso habilitar a partição para uso do LVM2.

# pvcreate /dev/sdc2 Physical volume "/dev/sdc2" successfully created

Depois a adicionamos ao VG0 estendendo o VG com o comando vgextend.

# vgextend VG0 /dev/sdc2 Volume group "VG0" successfully extended

Temos agora mais PE para alocar nos LV neste VG. O que pode ser observado em VG0 e /dev/sdc2.

# vgdisplay VG0 --- Volume group --- VG Name VG0 System ID Format lvm2 Metadata Areas 4 Metadata Sequence No 13 VG Access read/write VG Status resizable MAX LV 0 Cur LV 1 Open LV 1 Max PV 0 Cur PV 2 Act PV 2 VG Size 140.00 MB PE Size 4.00 MB Total PE 35 Alloc PE / Size 24 / 96.00 MB Free PE / Size 11 / 44.00 MB VG UUID eF3FAp-kIKn-V4IS-WQT3-yUO3-L6eQ-1yJjWL

# pvdisplay /dev/sdc2 --- Physical volume --- PV Name /dev/sdc2 VG Name VG0 PV Size 47.07 MB / not usable 3.07 MB Allocatable yes PE Size (KByte) 4096 Total PE 11 Free PE 11


71

Allocated PE 0 PV UUID SGTwFu-s3dW-H9XG-aJgY-pVqQ-6hsr-PAW0mQ

Finalmente podemos estender o LV para usar os PE disponíveis. Vamos ampliar LV1 em 12 MB, que equivale a 3 LE. As sintaxes abaixo são equivalentes.

# lvextend -l+3 /dev/VG0/LV0 Extending logical volume LV0 to 108.00 MB Logical volume LV0 successfully resized

# lvextend -l27 /dev/VG0/LV0 Extending logical volume LV0 to 108.00 MB Logical volume LV0 successfully resized

Nosso LV1 agora possui 108MB e 27 LE alocados no VG0 e nos PV que os compõe.

# lvdisplay /dev/VG0/LV0 --- Logical volume --- LV Name /dev/VG0/LV0 VG Name VG0 LV UUID kgtsld-nGVq-whCH-H26y-TbCt-V8jq-jxo1R1 LV Write Access read/write LV Status available # open 1 LV Size 108.00 MB Current LE 27 Segments 2 Allocation inherit Read ahead sectors auto - currently set to 256 Block device 253:0

# vgdisplay VG0 --- Volume group --- VG Name VG0 System ID Format lvm2 Metadata Areas 4 Metadata Sequence No 16 VG Access read/write VG Status resizable MAX LV 0 Cur LV 1 Open LV 1 Max PV 0 Cur PV 2 Act PV 2 VG Size 140.00 MB


72

PE Size 4.00 MB Total PE 35 Alloc PE / Size 27 / 108.00 MB Free PE / Size 8 / 32.00 MB VG UUID eF3FAp-kIKn-V4IS-WQT3-yUO3-L6eQ-1yJjWL

# pvdisplay /dev/sdb --- Physical volume --- PV Name /dev/sdb VG Name VG0 PV Size 100.00 MB / not usable 4.00 MB Allocatable yes (but full) PE Size (KByte) 4096 Total PE 24 Free PE 0 Allocated PE 24 PV UUID TF9FRe-V0Aq-N9B5-5wN6-2NNl-zRvm-3zOSZn # pvdisplay /dev/sdc2 --- Physical volume --- PV Name /dev/sdc2 VG Name VG0 PV Size 47.07 MB / not usable 3.07 MB Allocatable yes PE Size (KByte) 4096 Total PE 11 Free PE 8 Allocated PE 3 PV UUID wH0nuu-Qfvd-ARYm-uT1q-PEw0-TXEq-8KRGFw

Novamente é necessário redimensionar o sistema de arquivos para refletir a expansão.

# resize2fs /dev/VG0/LV0resize2fs 1.41.3 (12-Oct-2008)Filesystem at /dev/VG0/LV0 is mounted on /mnt/docs; on-line resizing required old desc_blocks = 1, new_desc_blocks = 1 Performing an on-line resize of /dev/VG0/LV0 to 110592 (1k) blocks. The filesystem on /dev/VG0/LV0 is now 110592 blocks long.



73

Criando um novo LV em um mesmo VG

Um VG pode comportar vários LV. Em nosso Volume Group VG0, temos 8 PE livres para receber outro LV. Vamos criar um LV2 com os PE livres existentes, totalizando uma área de 32 MB.

# lvcreate -l8 -n LV1 VG0 Logical volume "LV1" created

Reduzindo o tamanho de um LV

Podemos reduzir o tamanho de um LV em um processo semelhante ao ao realizado para expandi-lo, porém, é preciso antes reduzir o tamanho do sistema de arquivos para não perdermos dados.

Em ext4, redução do tamanho não é uma operação que possa ser feita on-line. Para reduzir seu tamanho, desmonte-o, cheque sua integridade, faça um backup e depois reduza-o.

# umount /dev/VG0/LV0

# e2fsck -f /dev/VG0/LV0

(faça um backup)

# resize2fs /dev/VG0/LV0 96Mresize2fs 1.41.3 (12-Oct-2008)Resizing filesystem Performing an on-line resize of /dev/VG0/LV0 to 98304 (1k) blocks. The filesystem on /dev/VG0/LV0 is now 98304 blocks long.

Uma vez ajustado o sistema de arquivos, reduza o LV usando o comando lvreduce. A sintaxe é a mesma para o lvextend.

# lvreduce -L 96 /dev/VG0/LV0 WARNING: Reducing active logical volume to 96.00 MB THIS MAY DESTROY YOUR DATA (filesystem etc.)Do you really want to reduce LV0 [y/n] ? y Reducing logical volume LV0 to 96.00 MB Logical volume LV0 successfully resized

Depois repita a checagem de integridade para garantir que o sistema de arquivos está íntegro. Cruze os dedos e já vá se lembrando onde pôs a fita de backup.

# e2fsck -f /dev/VG0/LV0

Ao final monte novamente o volume e o ponha em uso.

# mount /dev/VG0/LV0 /mnt/docs


74

Removendo um PV sem alocação

Para remover um PV membro de VG, mas que não tem nenhum PE alocado, ou seja, nenhum LV o esta utilizando, usamos o comando vgreduce.

Vamos simular a entrada de um novo PV no VG0 para depois retirá-lo.

# pvcreate /dev/sdd

# vgextend VG0 /dev/sdd

# vgreduce VG0 /dev/sdb Removed '/dev/sdd' form volume group VG0

Ao final, podemos remover o PV liberado.

# pvremove /dev/sdd Labels on physical volume "/dev/sdd" successfully wiped

Retirando um PV com dados alocados

Podemos retirar um PV com PE alocados se houver outro PV no mesmo volume group com PE livres suficientes para substituí-los. Para fazermos a movimentação, usamos o comando pvmove.

Vamos retirar do VG0 o PV /dev/sdc2. Note que ele possui 8 PE alocados.

# pvdisplay /dev/sdc2 --- Physical volume --- PV Name /dev/sdc2 VG Name VG0 PV Size 47.07 MB / not usable 3.07 MB Allocatable yes PE Size (KByte) 4096 Total PE 11 Free PE 3 Allocated PE 8 PV UUID wH0nuu-Qfvd-ARYm-uT1q-PEw0-TXEq-8KRGFw

Incluiremos o PV /dev/sdd no VG0 para termos PE disponíveis para receber este 8 extents.

# pvcreate /dev/sdd

# vgextend VG0 /dev/sdd


75

# vgdisplay VG0 --- Volume group --- VG Name VG0 System ID Format lvm2 Metadata Areas 6 Metadata Sequence No 14 VG Access read/write VG Status resizable MAX LV 0 Cur LV 2 Open LV 0 Max PV 0 Cur PV 3 Act PV 3 VG Size 236.00 MB PE Size 4.00 MB Total PE 59 Alloc PE / Size 32 / 128.00 MB Free PE / Size 27 / 108.00 MB VG UUID i30A6I-FAHd-ItVO-hQQQ-GHud-QXRW-xfFK9n

Execute o pvmove para movimentar os PE alocados em /dev/sdc2. Como apenas /dev/sdd tem PE livres, eles serão movidos para ele.

# pvmove /dev/sdc2 /dev/sdc2: Moved : 100.0%

# pvdisplay /dev/sdc2 --- Physical volume --- PV Name /dev/sdc2 VG Name VG0 PV Size 47.07 MB / not usable 3.07 MB Allocatable yes PE Size (KByte) 4096 Total PE 11 Free PE 11 Allocated PE 0 PV UUID wH0nuu-Qfvd-ARYm-uT1q-PEw0-TXEq-8KRGFw


76

# pvdisplay /dev/sdd --- Physical volume --- PV Name /dev/sdd VG Name VG0 PV Size 100.00 MB / not usable 4.00 MB Allocatable yes PE Size (KByte) 4096 Total PE 24 Free PE 16 Allocated PE 8 PV UUID R1cxFD-vXXM-pC8J-RPHd-aMiB-9XfE-2uWe0v

Note que /dev/sdc2 ainda é parte do volume group VG0. Para retirá-lo, precisamos reduzir VG0, para depois remover o PV.

# vgreduce VG0 /dev/sdc2 Removed "/dev/sdc2" from volume group "VG0"

# pvremove /dev/sdc2 Labels on physical volume "/dev/sdd" successfully wiped

Se você possui mais de um PV no volume group com capacidade de receber os PE alocados em PV e quer determinar qual deles o pvmove irá usar para deslocar, informe os dois PV como parâmetros.

# pvmove PVorigem PVdestino

Realizando Snapshots

Snapshot é um recurso existente em que permite que uma cópia de um LV seja feita sem que uma alocação física de dados seja feita, isto é, você possui dois LV que compartilham o mesmo bloco de dados. Administradores podem se valer deste recurso para gerar uma imagem no tempo do volume para que backups ou outras rotinas possam ser executadas sem ter que congelar a escrita no volume de origem.

Outro característica interessante dos snapshots em LVM2 é que eles suportam escrita tanto na origem quanto na cópia. Se uma alteração ocorre na origem, o bloco é copiado antes da alteração para o snapshot. Se o bloco é alterado no snapshot, ele é copiado da origem primeiro para registrar a alteração no snapshot, mantendo o bloco de origem intacto. Este processo é conhecido como Copy On Write (COW) e é mantido pelo programa /sbin/dmeventd deve estar em sempre em execução deste a criação do snapshot.

Em Gentoo, existe um script para iniciar o /sbin/dmeventd e deixá-lo em execução. # /etc/init.d/dmeventd startPara carregá-lo automaticamente a cada inicialização da máquina, inclua-o no runlevel boot.# rc-update add dmeventd boot


77

Vamos alocar algum dado no logical volume LV0 para percebermos a alocação dos blocos no snapshot.

(garanta que o /dev/VG0/LV0 está montado em /mnt/docs)# cp /var/log/messages /mnt/docs

Vamos alocar PV no volume group VG0 para termos espaço suficiente para alocar as alterações realizadas no snapshot.

# pvcreate /dev/sdc2 /dev/sde

# vgextend /dev/sdc2 /dev/sde

Vamos criar o snapshot para o logical volume LV0LV0 chamado LV0snap. O tamanho do snapshot não precisa ser equivalente ao do LV de origem, mas se for menor, nem todas as alterações realizadas poderão ser registradas. A sintaxe de criação usa o programa lvcreate, com o parâmetro -s para indicar que estamos criando um snapshot e o nome do LV de origem ao final.

# lvcreate -s -L 96M -n LV0snap /dev/VG0/LV0 Logical volume “LV0snap” created

Monte o snapshot em um diretório para podermos usá-lo.

# mkdir /mnt/snap

# mount /dev/VG0/LV0snap /mnt/LV0snap

# ls /mnt/snap /mnt/docs/mnt/docs:lost+found messages

/mnt/snap:lost+found messages


78

Note que a alocação LV0snap conhecido com o snapshot de LV0 e que o número o tamanho da área alocada em blocos nele é de 0.01%

# lvdisplay /dev/VG0/LV0snap --- Logical volume --- LV Name /dev/VG0/LV0snap VG Name VG0 LV UUID 4NmEtV-HnVe-M351-psad-dG04-KU2N-HLh2T0 LV Write Access read/write LV snapshot status active destination for /dev/VG0/LV0 LV Status available # open 1 LV Size 96.00 MB Current LE 24 COW-table size 96.00 MB COW-table LE 24 Allocated to snapshot 0.01% Snapshot chunk size 4.00 KB Segments 1 Allocation inherit Read ahead sectors auto - currently set to 256 Block device 253:2

Também podemos ver que LV0 reconhece que possui um snapshot.

# lvdisplay /dev/VG0/LV0 --- Logical volume --- LV Name /dev/VG0/LV0 VG Name VG0 LV UUID MLQeNg-zatW-rvET-6XrM-U8Pd-yo01-kgXPtS LV Write Access read/write LV snapshot status source of /dev/VG0/LV0snap [active] LV Status available # open 1 LV Size 96.00 MB Current LE 24 Segments 1 Allocation inherit Read ahead sectors auto - currently set to 256 Block device 253:0


79

Vamos realizar uma alteração no volume de origem para ver que o número de blocos alocados no snapshot aumenta.

# cp /mnt/docs/messages /mnt/docs/messages1(aguarde alguns poucos segundos)

# lvdisplay /dev/VG0/LV0snap --- Logical volume --- LV Name /dev/VG0/LV0snap VG Name VG0 LV UUID 4NmEtV-HnVe-M351-psad-dG04-KU2N-HLh2T0 LV Write Access read/write LV snapshot status active destination for /dev/VG0/LV0 LV Status available # open 1 LV Size 96.00 MB Current LE 24 COW-table size 96.00 MB COW-table LE 24 Allocated to snapshot 0.03% Snapshot chunk size 4.00 KB Segments 1 Allocation inherit Read ahead sectors auto - currently set to 256 Block device 253:2

Note que a alocação subiu para 0.03%. Façamos uma alteração no snapshot para vermos o resultado.

# cp /mnt/snap/messages /mnt/snap/messages2(aguarde alguns poucos segundos)

# lvdisplay /dev/VG0/LV0snap --- Logical volume --- LV Name /dev/VG0/LV0snap VG Name VG0 LV UUID 4NmEtV-HnVe-M351-psad-dG04-KU2N-HLh2T0 LV Write Access read/write LV snapshot status active destination for /dev/VG0/LV0 LV Status available # open 1 LV Size 96.00 MB Current LE 24 COW-table size 96.00 MB COW-table LE 24 Allocated to snapshot 0.44% Snapshot chunk size 4.00 KB


80

Segments 1 Allocation inherit Read ahead sectors auto - currently set to 256 Block device 253:2

Removendo um Snapshot ou um Logical Volume (LV)

Para remover um snapshot ou um logical volume LV, usamos o comando lvremove. Se houver um snapshot para um LV, remova o snapshot primeiro. Tanto o snapshot quando o LV não podem estar montados ao serem removidos.

# umount /mnt/docs /mnt/snap

# lvremove /dev/VG0/LV0snapDo you really want to remove active logical volume “LV0snap” ? [y/n] : y Logical volume “LV0snap” successfully removed

# lvremove /dev/VG0/LV0Do you really want to remove active logical volume “LV0” ? [y/n] : y Logical volume “LV0” successfully removed


81

Loop Devices

Loop devices é um recurso do kernel Linux que permite que arquivos possam ser acessados como dispositivos de blocos. Uma vez criados, eles podem ser usados para qualquer operação comum realizada em um dispositivo de bloco, como suportar sistemas de arquivos.

Imagine que você não possua mais partições disponíveis em sua máquina, mas possui espaço livre gostaria de usar um diferente tipo de sistema de arquivos para suportar uma determinada aplicação que tem melhor funcionamento usando outro sistema de arquivos que o instalado em sua máquina. Neste caso, uma alternativa seria usar um Loop Device, formatá-lo com o novo sistema de arquivos e montá-lo para uso em seu computador.


82

Identificando o suporte a Loop Device no kernel Linux

Para ter suporte a Loop Device é preciso que o kernel esteja compilado com o suporte habilitado.. Isto pode ser verificado avaliando o arquivo /proc/config.gz, que contém a configuração do kernel em execução. Procure por CONFIG_BLK_DEV_LOOP. Se o recurso foi compilado como módulo, haverá um valor m no lugar de y.

# zgrep CONFIG_BLK_DEV_LOOP /proc/config.gz CONFIG_BLK_DEV_LOOP=y

Se seu kernel não expõe o arquivo /proc/config.gz, você pode identificar o suporte através das informações exibidas durante sua carga.

# dmesg | grep loop:loop:module load

Habilitando Loop Device no kernel Linux

Caso seu kernel não esteja com o suporte habilitado, é preciso compilá-lo. Carregue o menu de configuração do kernel.

# cd /usr/src/linux

# make menuconfig


Device Drivers --->[*] Block devices -->

<*> Loopback device support

Saia do menu, salve a configuração, compile e instale o novo kernel. Felizmente em nosso curso, este recurso já está habilitado.


83

Localizando e criando Loop Devices

A interação com o suporte a Loop Devices no kernel é feita através de arquivos no diretório /dev/loop.

# ls -l /dev/looptotal 0 lrwxrwxrwx 1 root root 8 2009-11-01 08:23 0 -> ../loop0 lrwxrwxrwx 1 root root 8 2009-11-01 08:23 1 -> ../loop1 lrwxrwxrwx 1 root root 8 2009-11-01 08:23 2 -> ../loop2 lrwxrwxrwx 1 root root 8 2009-11-01 08:23 3 -> ../loop3 lrwxrwxrwx 1 root root 8 2009-11-01 08:23 4 -> ../loop4 lrwxrwxrwx 1 root root 8 2009-11-01 08:23 5 -> ../loop5 lrwxrwxrwx 1 root root 8 2009-11-01 08:23 6 -> ../loop6 lrwxrwxrwx 1 root root 8 2009-11-01 08:23 7 -> ../loop7

Estes arquivos são link simbólicos cujo o nome é um número equivalente ao MINOR number de um arquivo /dev/loop no dirtório /dev/, cujo MAJOR number é 7.

# ls -l /dev/loop?brw-rw---- 1 root disk 7, 0 2009-10-31 21:15 /dev/loop0 brw-rw---- 1 root disk 7, 1 2009-10-31 21:15 /dev/loop1 brw-rw---- 1 root disk 7, 2 2009-10-31 21:15 /dev/loop2 brw-rw---- 1 root disk 7, 3 2009-10-31 21:15 /dev/loop3 brw-rw---- 1 root disk 7, 4 2009-10-31 21:15 /dev/loop4 brw-rw---- 1 root disk 7, 5 2009-10-31 21:15 /dev/loop5 brw-rw---- 1 root disk 7, 6 2009-10-31 21:15 /dev/loop6 brw-rw---- 1 root disk 7, 7 2009-10-31 21:15 /dev/loop7

Caso precise de mais Loop Devices, é possível adicioná-los. A forma de fazê-lo varia se o recurso estiver embutido no kernel, CONFIG_BLK_DEV_LOOP=y, ou como módulo, CONFIG_BLK_DEV_LOOP=m. Para ter dez Loop devices, proceda da seguinte forma.

Para Loop Device embutido no kernel, adicione o parâmetro max_loop=10 na linha de carga do kernel no arquivo /boot/grub/menu.lst.

# grep kernel /boot/grub/menu.lst(listagem parcial)kernel /kernel-2.6.30-r6 root=/dev/sda3 video=vesafb:ywrap,mtrr:3 vga=0x303 max_loop=10

Para Loop Device habilitados como módulos, adicione a linha abaixo ao arquivo /etc/modprobe.conf.

options loop max_loop=10

Garanta que o módulo loop seja carregado na inicialização da máquina.


84

Em Gentoo, recomenda-se que não o arquivo /etc/modprobe.conf não seja editado diretamente. O procedimento correto sugerido é o apresentado abaixo.

Crie o arquivo /etc/modprobe.d/loop com as opções do módulo.# echo options loop max_loop=10 > /etc/modprobe.d/loop

Execute o script update-modules para atualizar o /etc/modprobe.conf# update-modules

Para carregar o módulo loop na inicialização da máquina

echo loop >> /etc/modules.autoload.d/kernel-2.6

Preparando um Loop Device para uso

Para se utilizar um Loop Device precisamos criar um arquivo para servir de repositório para o sistema de arquivos e depois apontar o Loop Device para ele. O tamanho da área disponível no Loop Device é equivalente ao tamanho deste arquivo.

Podemos criar estes arquivos usando um editor de texto ou outro aplicativo qualquer. Mas é muito mais simples criar arquivos maiores usando o comando dd, que lê dados (bs) de uma origem (if) e os copia em outra (of) uma determinada quantidade de vezes (count).

Os comandos abaixo criam os arquivos disco0 e disco1 com 50MB, 51200 vezes 1024 bytes, usando um dispositivo virtual /dev/zero que sempre retorna zeros quando lido.

# dd if=/dev/zero of=disco0 bs=1024 count-51200

# dd if=/dev/zero of=disco1 bs=1024 count-51200

# ls -l disco?-rw-r--r-- 1 root root 50M 2009-10-30 01:38 disco0 -rw-r--r-- 1 root root 50M 2009-10-30 01:38 disco1

Uma vez criados os repositórios, devemos apontar Loop Devices para eles. Isto é feito pelo comando losetup.

# losetup /dev/loop0 disco0# losetup /dev/loop1 disco1

Use o gerenciado de pacotes de sua distribuição para instalar o comando losetup, normalmente membro do pacote util-linux. Em gentoo :

# emerge sys-apps/util-linux


85

Identificando que Loop Device estão associados

Para identificarmos que Loop Devices estão em uso, podemos usar o comando mesmo comando losetup.

# losetup -a/dev/loop/0: [0803]:56 (/root/disco0) /dev/loop/1: [0803]:78 (/root/disco1)

# losetup /dev/loop0/dev/loop/0: [0803]:56 (/root/disco0)

Utilizando um Loop Device

Uma vez criada a associação, formate o Loop Device e monte-o para utilizar.

# mkfs -t ext3 /dev/loop0

# mount /dev/loop0 /mnt/publico

# df -h /mnt/publicoFilesystem Size Used Avail Use% Mounted on /dev/loop0 49M 4.9M 42M 11% /mnt/publico

Associando os Loop Devices na inicialização da máquina

A cada inicialização da máquina, as associações dos Loop Devices são perdidas. É preciso recriá-las para que possamos manter seu uso constante. Isto pode ser facilmente feito através do arquivo /etc/fstab.

Insira a linha abaixo no arquivo para que a montagem seja feita a cada carga da máquina.

# echo '/root/disco0 /mnt/publico ext3 loop=/dev/loop0 0 0' >> /etc/fstab

Reinicie a máquina e veja que o volume está montado.

# mount | grep loop0/dev/loop0 on /mnt/publico type ext3 (rw)

# losetup /dev/loop0/dev/loop/0: [0803]:56 (/root/disco0)


86

Para executar a montagem manualmente, use a sintaxe equivalente abaixo.

# mount -t ext3 -o loop=/dev/loop0 /root/disco0 /mnt/puplico

Desfazendo a associação com um Loop Device

Para desfazer a associação de um Loop Device com um arquivo, usamos o comando losetup -d.

# losetup -d /dev/loop0

Se ele estiver montado, use o comando umount primeiro.

# umount /dev/loop0

Se a associação foi feita pelo comando losetup e não pelo mount, ao desmontar o volume, ela permanecerá. Caso queira umount remova também a associação estabelecida por losetup, use o parâmetro -d, note que uma mensagem será gerada indicando que o Loop Device não existe mais.

# losetup /dev/loop disco0

# losetup -a/dev/loop/0: [0803]:56 (/root/disco0)


# umount /dev/loop0



# mount -t ext3 -o loop=/dev/loop0 /root/disco0 /mnt/puplico


# umount /dev/loop0ioctl: LOOP_CLR_FD: No such device or address

# losetup -a

# losetup /dev/loop disco0



87


# umount -d /dev/loop0

# losetup -a

Criando um RAID com Loop Devices

Se tivermos mais de um disco na máquina, podemos considerar o uso de RAID usando Loop Devices. Para fazer um, use a sequencia de comandos abaixo.

# losetup /dev/loop0 disco0


# mdadm --create /dev/md0 --level=0 --raid-devices=2 /dev/loop{0,1}

# cat /proc/mdstatPersonalities : [linear] [raid0] [raid1] [raid10] [raid6] [raid5] [raid4] md0 : active raid0 loop1[1] loop0[0] 102272 blocks 64k chunks unused devices: <none>

Desfaça o RAID e os Loop Devices para podermos avançar no curso.





88

DM_CRYPT

DM_CRYPT é a parte do device mapper responsável por criptografar os volumes criados por ele usando as rotinas rotinas de criptografia do kernel. Na prática, ele funciona como uma camada de transformação das operações de entrada e saída nos dispositivos do device mapper, codificando e decodificando os dados que passam por ela.

O kernel Linux oferece vários algoritmos de criptografia e tamanho de chaves. Como não sou um especialista neste assunto, recomendo a leitura sobre estes métodos para identificar quais as vantagens, desvantagens e cenários de uso de cada um. Um bom começo está em disk encryption theory (http://en.wikipedia.org/wiki/Disk_encryption_theory).

A ferramenta para fazer uso do DM_CRYPT em modo usuário é a cryptsetup. Inicialmente, esta ferramenta só armazenava as informações sobre a criptografia fora do volume protegido, o que tornava difícil a portabilidade entre distribuições Linux e praticamente impossível para outros sistemas operacionais. Percebendo esta limitação, os mantenedores desta ferramenta adicionaram a ela um recurso chamado Linux Unified Key Support (LUKS), que salva todas as informações necessárias para se acessar um volume criptografado na tabela de partição deste volume.

Com LUKS, a portabilidade entre distribuições Linux é garantida desde que a distribuição forneça uma versão do cryptsetup com suporte a LUKS. E através do projeto FreeOTFE (http://freeotfe.org) existe suporte LUKS ao Windows 2000 em diante, Windows 7 incluso, e Windows Mobile 2003/2005 e 6. Contudo, fique atento aos sistemas de arquivos e alrotitmos comuns entre os dois ambientes.

Outro benefício de LUKS é a capacidade de gerir até oito senhas diferentes para habilitar os volumes criptografados. Desta forma, vários grupos de usuários e administradores podem ter acesso sem comprometer suas senhas.

Neste curso, usaremos DM_CRYTP com LUKS para proteger partições. Loop Devices podem ser opções muito úteis se desejarmos ter o recurso de criptografia sem ter que nos valor de um esquema de particionamento.


89

Identificando o suporte ao DM_CRYPT e aos algoritmos de criptografia no kernel Linux

Para ter suporte ao DM_CRYTP, é preciso que o kernel esteja compilado com este suporte. Isto pode ser verificado avaliando o arquivo /proc/config.gz, que contém a configuração do kernel em execução. Procure por CONFIG_DM_CRYPT. Se o recurso foi compilado como módulo, haverá um valor m no lugar de y.

# zgrep CONFIG_DM_CRYPT /proc/config.gzCONFIG_BLK_DM_CRYPT=y

Os algoritmos de criptografia habilitados podem ser vistos com o comando :

# zgrep CONFIG_CRYPTO /proc/config.gz(listagem parcial)CONFIG_CRYPTO=y CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD2=y CONFIG_CRYPTO_BLKCIPHER=y CONFIG_CRYPTO_BLKCIPHER2=y CONFIG_CRYPTO_HASH2=y CONFIG_CRYPTO_RNG2=y CONFIG_CRYPTO_PCOMP=y CONFIG_CRYPTO_MANAGER=y CONFIG_CRYPTO_MANAGER2=y CONFIG_CRYPTO_WORKQUEUE=y CONFIG_CRYPTO_CBC=y CONFIG_CRYPTO_ECB=y CONFIG_CRYPTO_AES=y CONFIG_CRYPTO_ARC4=y CONFIG_CRYPTO_DEFLATE=y CONFIG_CRYPTO_ZLIB=y CONFIG_CRYPTO_LZO=y CONFIG_CRYPTO_HW=y

Habilitando DM_CRYPT no kernel Linux

Caso seu kernel não esteja com o DM_CRYPT habilitado ou com os algoritmos que deseja, é preciso compilá-lo. Carregue o menu de configuração.

# cd /usr/src/linux

# make menuconfig


90



<*> Device mapper support<*> Crypt target support

Cryptographic API --->(selecione os algoritmos desejados)

(neste curso, marque todas as opções)

Saia do menu, salve a configuração, compile e instale o novo kernel.

Verificando os algoritmos de criptografia disponíveis em um kernel em execução

Você pode verificar que algoritmos de criptografia estão disponíveis em um kernel em execução exibindo o conteúdo do arquivo /proc/crypto.

# cat /proc/crypto(listagem parcial)name : cbc(aes) driver : cbc(aes-asm) module : kernel priority : 200 refcnt : 1 selftest : passed type : blkcipher blocksize : 16 min keysize : 16 max keysize : 32 ivsize : 16 geniv : <default>

name : sha256 driver : sha256-generic module : kernel priority : 0 refcnt : 1 selftest : passed type : shash blocksize : 64 digestsize : 32 descsize : 168


91

Criptografando com LUKS

Vamos criptografar a partição /dev/sde1 usando o comando cryptsetup luksFormat usando suporte LUKS .

# cryptsetup luksFormat /dev/sde1

WARNING!=========This will overwrite data on /dev/sde1 irrevocably.

Are you sure? (Type uppercase yes): YESEnter LUKS passphrase: totonickVerify passphrase: totonickCommand Succesful.

O mesmo procedimento pode ser aplicado a um Loop Device. Associe o Loop Device a um arquivo e depois criptografe-o.


# cryptsetup luksFormat /dev/loop0

Caso queria determinar o algoritmo a ser usado, use o parâmetro -c.

# cryptsetup luksFormat -c blowfish /dev/loop0

Obtendo informações com LUKS

Para obter informações sobre como uma partição ou Loop Device foi criptografado, usamos o comando cryptsetup luksDump.

# cryptsetup luksDump /dev/sde1LUKS header information for /dev/sde1

Version: 1 Cipher name: aes Cipher mode: cbc-essiv:sha256 Hash spec: sha1 Payload offset: 1032 MK bits: 128 MK digest: 89 4c b7 53 5f a8 9a 27 6e ba 65 03 d3 3c f3 e8 a3 90 4f 37 MK salt: 0a fc e9 cb 4c 80 c1 c4 dc 96 17 34 d5 f7 a3 79 81 62 ba 0f 33 b6 c3 f1 cb 07 6d a2 34 16 60 13 MK iterations: 10


92

UUID: 573eab94-882d-4b6a-967a-a219f82393c8

Key Slot 0: ENABLED Iterations: 243672 Salt: c6 86 8d c9 d6 26 e4 d7 39 c7 b8 e9 f4 1c e9 ce 7a 75 e5 3b d5 de 35 f0 ae 0a 39 98 9a c1 1f 2e Key material offset: 8 AF stripes: 4000

Key Slot 1: DISABLED Key Slot 2: DISABLED Key Slot 3: DISABLED Key Slot 4: DISABLED Key Slot 5: DISABLED Key Slot 6: DISABLED Key Slot 7: DISABLED

Note os algoritmos usados, Cipher e HASH, e que apenas uma senha está ativada, key Slot 0.

# cryptsetup luksDump /dev/loop/0

Usando uma partição ou Device Loop criptografado

Uma vez que preparamos a tabela de partição com as informações criptografadas, devemos associá-la a um volume no Device Manager. isto é feito com o comando cryptsetup luksOpen.

# cryptsetup luksOpen /dev/sde1 protegidoEnter LUKS passphrase: totonickKey slot 0 unlocked.Command successful.

Pronto, temos um volume chamado protegido no device manager.

# dmsetup protegidoName: protegido State: ACTIVE Read Ahead: 256 Tables present: LIVE Open count: 0 Event number: 0 Major, minor: 254, 0 Number of targets: 1


93

Formate o volume com o sistema de arquivos desejado e depois monte-o para uso.

#mkfs -t ext3 /dev/mapper/protegido

# mkdir /mnt/protegido

# df -h /mnt/protegidoFilesystem Size Used Avail Use% Mounted on /dev/mapper/protegido 91M 5.6M 81M 7% /mnt/protegido

Encerrando o uso

Para interromper o uso é preciso desassociar-se do Device Mapper. Isto é feito com o comando cryptsetup luksClose. Desmonte o volume antes.

# umount /mnt/protegido

# cryptsetup luksClose protegido

Ao encerrar o uso, os dados permanecem salvos e criptografados. Para retomar o uso, basta usar luksOpen novamente.

Adicionando senhas

A adição de novas senhas pode ser feita com o comando cryptsetup luksAddKey. Uma das senhas atuais será solicitada para que uma nova seja incluída. O volume pode estar em uso.

# cryptsetup luksAddKey /dev/sde1Enter any LUKS passphrase: totonickkey slot 0 unlocked.Enter new passphrase for key slot: pipocaVerify passphrase: pipocaCommand successful.


94

Removendo senhas

Remover senhas é um processo semelhante ao da adição, A única diferença é que devemos informar qual key slot queremos remover e uma senha remanescente. O comando é o cryptsetup luksKillSlot.

# cryptsetup luksKillSlot 1Enter any remaining LUKS passphrase: totonickkey slot 1 verified.Command successful.

Usando um arquivo arquivo para armazenar as senhas

Ao criptografar um volume, podemos armazenar a senha em um arquivo, que deverá ser passado como parâmetro a fim de evitar a digitação de senhas. Este arquivo pode estar em uma mídia removível, garantindo uma segurança maior das informações armazenadas. Caso o arquivo se perca, todos os dados se perdem.

Crie o arquivo de senha. Para maior segurança, vamos fazê-lo usando o comando dd e preenchendo-o com valores aleatórios. O tamanho do arquivo varia de acordo com o tamanho da chave usada no algoritmo de criptografia, veja max keysize em /proc/crypto, e afeta o valor do parâmetro count. Para criar uma chave de 256 bytes, use a sintaxe abaixo.

# dd if=/dev/urandom of=minhasenha bs=1 count 256

A seguir, formate o dispositivo com luksFormat, caso queira forçar o tamanho da senha, use o parâmetro -s ou --key-size.

# cryptsetup luksFormat -s 256 /dev/loop0 minhasenha

WARNING!=========This will overwrite data on /dev/loop0 irrevocably.

Are you sure? (Type uppercase yes): YESCommand Succesful.

Para usar, use luksOpen e informe o arquivo de senha através do parâmetro -d ou --key-file.

# cryptsetup luksOpen /dev/sde1 confidencial --key-file=./minhasenhaKey 0 unlocked.Command successful.

A partir deste ponto o uso é normal. Formate o volume e monte-o.


95

Usando os volumes após reiniciar a máquina

Quando reiniciamos a máquina,a associação entre a partição e o Device Mapper é perdida. desta forma é preciso luksOpen para recriá-la. Se usou Loop Devices, lembre-se de usar losetup para associar o arquivo de loop ao arquivo repositório.

# cryptsetup luksOpen /dev/sde1 protegido


# cryptsetup luksOpen /dev/loop0 confidencial --key-file=./minhasenha

Em Gentoo, podemos automatizar o processo.

Insira as linhas abaixo em /etc/conf.d/dmcrypt para montar os volumes protegido e confidencial.

target=protegido source='/dev/sde1'

target=confidencial source='/dev/loop0' loop_file='/root/disco0' key='/root/minhasenha'

E estas no /etc/fstabb.

/dev/mapper/protegido /mnt/protegido ext3 defaults 0 0 /dev/mapper/confidencial /mnt/confidencial ext3 defaults 0 0

Atenção, como o volume protegido não usa um arquivo de senha, a inicialização da máquina será interrompida até uma senha ser fornecida pelo teclado.


Documents

RAID e LVM2