Apenas para esclarecer, Nested Paging é um recurso disponível apenas para processadores AMD da linha Phenom ou superior. Maiores detalhes, consulte este documento.

Pesquisei por referências de como habilitar a opção ‘-enable-nesting’ do qemu-kvm no libvirt, mas não encontrei. Depois de pelo menos 2 dezenas de cliques, eis que encontro na lista de e-mails dos desenvolvedores do libvirt referências já antigas (novembro de 2009), de como usar o nesting. Pois bem, meu trabalho se resumiu em ler certinho as mensagens e montar um patch. Mesmo que a versão que estou usando (0.8.3) seja muito mais nova que esse post, testei as alterações, e que maravilha, funcionou!!!

Depois de compilado e instalado, só precisei acrescentar na definição do domínio dentro da tag <features> uma tag <nesting/>. Depois disso é só iniciar a VM e ver que na linha de comando da sua máquina virtual tem o -enable-nesting.

Agradeço demais a equipe de desenvolvimento de qemu-kvm e libvirt!

Abaixo segue o meu patch para libvirt-0.8.3:

diff -Naur ../libvirt-0.8.3//docs/schemas/domain.rng ./docs/schemas/domain.rng
--- ../libvirt-0.8.3//docs/schemas/domain.rng   2010-07-29 06:48:30.000000000 -0300
+++ ./docs/schemas/domain.rng   2010-09-01 16:51:57.710851479 -0300
@@ -1595,6 +1595,11 @@
               <empty/>
             </element>
           </optional>
+          <optional>
+           <element name="nesting">
+             <empty/>
+           </element>
+         </optional>
         </interleave>
       </element>
     </optional>
diff -Naur ../libvirt-0.8.3//src/conf/domain_conf.c ./src/conf/domain_conf.c
--- ../libvirt-0.8.3//src/conf/domain_conf.c    2010-08-02 16:16:42.000000000 -0300
+++ ./src/conf/domain_conf.c    2010-09-01 16:51:57.710851479 -0300
@@ -75,7 +75,8 @@
 VIR_ENUM_IMPL(virDomainFeature, VIR_DOMAIN_FEATURE_LAST,
               "acpi",
               "apic",
-              "pae")
+              "pae",
+             "nesting")

 VIR_ENUM_IMPL(virDomainLifecycle, VIR_DOMAIN_LIFECYCLE_LAST,
               "destroy",
diff -Naur ../libvirt-0.8.3//src/conf/domain_conf.h ./src/conf/domain_conf.h
--- ../libvirt-0.8.3//src/conf/domain_conf.h    2010-07-29 06:48:30.000000000 -0300
+++ ./src/conf/domain_conf.h    2010-09-01 16:51:57.710851479 -0300
@@ -649,6 +649,7 @@
     VIR_DOMAIN_FEATURE_ACPI,
     VIR_DOMAIN_FEATURE_APIC,
     VIR_DOMAIN_FEATURE_PAE,
+    VIR_DOMAIN_FEATURE_NESTING,

     VIR_DOMAIN_FEATURE_LAST
 };
diff -Naur ../libvirt-0.8.3//src/qemu/qemu_conf.c ./src/qemu/qemu_conf.c
--- ../libvirt-0.8.3//src/qemu/qemu_conf.c      2010-08-04 09:21:27.000000000 -0300
+++ ./src/qemu/qemu_conf.c      2010-09-01 16:57:47.485469640 -0300
@@ -1190,6 +1190,8 @@
         flags |= QEMUD_CMD_FLAG_MEM_PATH;
     if (strstr(help, "-chardev"))
         flags |= QEMUD_CMD_FLAG_CHARDEV;
+    if (strstr(help, "-enable-nesting"))
+        flags |= QEMUD_CMD_FLAG_NESTING;
     if (strstr(help, "-balloon"))
         flags |= QEMUD_CMD_FLAG_BALLOON;
     if (strstr(help, "-device"))
@@ -3907,6 +3909,9 @@
             goto error;
         }
     }
+    if ((qemuCmdFlags & QEMUD_CMD_FLAG_NESTING) &&
+        (def->features & (1 << VIR_DOMAIN_FEATURE_NESTING)))
+        ADD_ARG_LIT("-enable-nesting");

     /*
      * NB, -nographic *MUST* come before any serial, or monitor
@@ -6265,6 +6270,8 @@
             fullscreen = 1;
         } else if (STREQ(arg, "-localtime")) {
             def->clock.offset = VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME;
+        } else if (STREQ(arg, "-enable-nesting")) {
+            def->features |= (1 << VIR_DOMAIN_FEATURE_NESTING);
         } else if (STREQ(arg, "-kernel")) {
             WANT_VALUE();
             if (!(def->os.kernel = strdup(val)))
diff -Naur ../libvirt-0.8.3//src/qemu/qemu_conf.h ./src/qemu/qemu_conf.h
--- ../libvirt-0.8.3//src/qemu/qemu_conf.h      2010-07-28 11:18:15.000000000 -0300
+++ ./src/qemu/qemu_conf.h      2010-09-01 16:58:29.900876561 -0300
@@ -92,6 +92,7 @@
     QEMUD_CMD_FLAG_PCI_CONFIGFD  = (1LL << 36), /* pci-assign.configfd */
     QEMUD_CMD_FLAG_NODEFCONFIG   = (1LL << 37), /* -nodefconfig */
     QEMUD_CMD_FLAG_BOOT_MENU     = (1LL << 38), /* -boot menu=on support */
+    QEMUD_CMD_FLAG_NESTING       = (1LL << 39), /* Is the -enable-nesting flag available */
 };

 /* Main driver state */

Noutro dia, enquanto dirigia pra casa, fiquei pensando sobre o tempo e a importância dele para nós. Sem perceber usamos a referência do tic-tac. Ao observar minha namorada dançar em uma aula de ginástica, percebi como é impressionante a sincronia entre os bailarinos. Na aula, o professor colocava uma música, na maioria um axé, e ia dando instruções de passos. O que me impressionou foi a rapidez com que as meninas (sim, eram todas meninas) encontravam o pulso da música e entravam em sincronia.

A mesma coisa acontece com músicos de uma sinfonia. Dezenas de músicos com cada grupo responsável por um timbre, por momentos de notas e silêncios, trabalhando em consonância na reprodução de uma música em compassos certos.

Na engenharia este respeito pelo relógio está presente, e um exemplo são os motores, que têm seus pistões e válvulas rigorosamente alinhados e postos para agir em sincronia com outros. No trânsito nas ruas e avenidas também vemos todos os dias um maestro, que alternando suas luzes vermelha, amarela e verde, coordena em função do tempo, o fluxo dos automóveis.

Isso sem olhar par a necessidade de dividir esta linha, que dizem ser infinita, em períodos cíclicos, como dias, semanas, meses, anos…

Seguindo essa linha, percebo que Albert Einstein estava certíssimo ao relacionar intimamente o espaço e o tempo. Além de estarmos conectados ao Universo através das distâncias escalares, nossa participação na existência não pode ser posteriormente negada nem por Deus, pois está gravada de maneira única num período em que nunca mais voltará.

usermod -a -G plugdev eduardo

Agora basta uma alteração no fstab. Acrescente a seguinte linha:

usbfs            /proc/bus/usb    usbfs       devgid=83,devmode=660 0 0

Isso fará com que o sistema no início monte o usbfs sendo do grupo do plugdev também, e dando permissão de leitura e escrita para seus membros.

Para resolver isso rapidamente sem reinicializar o sistema, use o seguinte:

mount -o remount,devgid=83,devmode=660 /proc/bus/usb

At

Esse comando é um agendador de tarefas. Semelhante ao cron, porém este não é cíclico. Agendar uma tarefa é fácil, basta informar ao at o arquivo que contém os comandos que serão executados e a hora e data. Talvez assim tenha ficado um pouco vago. Vou dar um exemplo. Crie um arquivo contendo o seguinte:

#/bin/sh
touch /tmp/teste-at

Assumindo que o arquivo criado seja o ~/job.txt, vamos agendar a execução desse programa:

at -f ~/job.txt 3pm tomorrow

Se tudo ocorrer bem, aparecerá uma mensagem semelhante à essa:

job 1 at Thu Jul 29 15:00:00 2010

A notação de hora e data do at é um tanto flexível. Neste exemplo, poderíamos definir como 15:00 Jul 29 2010, ou então15:00 07/29/10. O resultado seria o mesmo. Para melhor detalhamento, consulte o manual do comando: man at. Para consultar os jobs que já foram agendados, use o comando primo atq, e para remover/cancelar um job, use o atrm fornecendo o id do job como primeiro argumento.

ionice

Assim como o comando nice, ele estabelece prioridades para os processos, mas este, se limita às operações de disco (I/O). Sua sintaxe é semelhante do seu primo nice. Dois argumentos eu enfatizo: -c e -p. O primeiro define o número da classe de prioridade e o segundo o número do PID que sofrerá a modificação.

As classes podem ser:

Idle: O processo só usará o processador para I/O se nenhum outro processo estiver usando.

Best effort: O processo concorrerá o processador em níveis de prioridade que podem ser definidas entre 0 e 7, sendo 0 (zero) a maior prioridade. Para definir esse valor, use a opção -n. Vale lembrar que qualquer que seja o nível de prioridadem ele sempre passará na frente de processos da classe Idle.

Real-time: Esse é para processos que realmente necessitem de atenção de I/O. Assim como a classe Best effort, esse é dividido em 8 níveis de prioridades e sua definição é idêntica. Vale lembrar que qualquer processo dessa classe, mesmo que seja prioridade 7, passará na frente de processos Best effort e Idle.

O número das classes Idle, Best effort e Real-time são respectivamente 3, 2 e 1. 0 (zero) significa que não pertence a classe alguma. Caso queira já iniciar o processo com ionice definido, troque o argumento -p pelo comando em si, como por exemplo:

ionice -c 3 cp ~/hugefile.img /tmp

Ou seja, defina classe Idle para o processo que executará a cópia do arquivo hugefile.img.

Para maior detalhamento, consulte o manual do comando, man ioince.

Como de costume, logo na instalação de uma distribuição já particionamos o disco de uma tal maneira que uma parte fica reservada para a área de troca, que é a tradução de swap. Alguns usam partições primárias para isto, outros lógicas… Alguns seguem uma regra que diz que “a capacidade do swap deve ser o dobro da memória física”… mas no final, isso fica mesmo é a critério do administrador do sistema.

O problema da partição é que complica no caso de precisar aumentar seu espaço. Para isto, poderia criar outra partição e ativá-la no sistema, mas seria necessário espaço em disco não particionado.

Uma solução rápida para isto seria criar um arquivo de swap, ou swapfile. Para criá-lo é quase igual à uma partição, já que para o Linux, os dispositivos de block são representados como arquivos e, cá entre nós, uma partição nada mais é que um conteiner grande de dados (um arquivão!). Na prática, sua criação ficaria assim:

Gerar um arquivo do tamanho de 512 * 100.000 bytes (100.000 blocos de 512 bytes) contendo apenas zeros:

dd if=/dev/zero of=/tmp/swapfile bs=512 count=100000

Definir o arquivo criado como swap:

mkswap /tmp/swapfile

Ativar o novo arquivo no pool de swap do sistema com prioridade 0 (zero):

swapon -p 0 /tmp/swapfile

Verificar o pool swap do sistema:

swapon -s

Desativar um dispositivo/arquivo swap do sistema:

swapoff /tmp/swapfile

Quanto à performance e aplicabilidade em ambiente de produção, prefiro não opinar, mas acredito ser uma alternativa mais rápida e simples para o aumento da área de troca, swap.

Outro método de autenticação seria por meio de um par de chaves pública e privada. Nesse método, cada cliente possui uma chave privada que o identifica e deve ser protegida. O servidor recebe a chave pública correspondente de cada cliente para autenticar. Desta forma, não há, à princípio, necessidade de senha. Porém, o próprio certificado pode exigir uma senha para ser acessado, mas assim, ele será único para todos os servidores e não haverá tráfego de senha entre servidor e cliente. Vejamos como fazer isto:

No cliente, é preciso gerar as chaves com o seguinte comando:

ssh-keygen

Ele perguntará por uma senha. Caso queira fornecer, digite-a. Caso queira que o acesso seja direto, deixe em branco. Por padrão, ele gerará dois arquivos: ~/.ssh/id_rsa e ~/.ssh/id_rsa.pub. Respectivamente eles são a chave privada e pública em algorítmo RSA. Copie a chave pública para o servidor (assumindo que o IP dele é 10.0.0.8):

scp ~/.ssh/id_rsa.pub 10.0.0.8:~

No servidor, insira a chave pública recém recebida na lista de chaves autorizadas:

cat ~/id_rsa.pub >> ~/.ssh/authorized_keys

Feito isto, basta alterar o modo de autenticação do servidor. Acesse o arquivo de configuração /etc/ssh/sshd_config e altere, acrescente ou descomente as seguintes opções para que confira com o modelo:

# Define autenticação por chave pública RSA.
RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile     .ssh/authorized_keys

# Desabilita autenticação por senha
PasswordAuthentication no
PermitEmptyPasswords no

Reinicialize o serviço do ssh. No Slackware execute /etc/rc.d/rc.sshd restart. Agora está pronto, basta testar. No cliente, pode-ser conectar usando duas sintaxes:

ssh 10.0.0.8

Use o exemplo acima caso o nome do arquivo e caminho da chave seja o padrão, ~/.ssh/id_rsa. Se for diferente, a seguinte sintaxe será necessária:

ssh -i <caminho completo para chave privada> 10.0.0.8

Para mais informações, o bom e velho man sempre ajuda.

O vídeo original é encontrado aqui.

Antes de tudo, é necessário que já tenha sido criado um grupo virtual. Como isso não está no escopo do post, recomendo navegar por esse howto. Com o grupo criado e ativado, vamos criar a definição do pool para o libvirt. Abra um editor de texto, como o vim, e coloque nele o seguinte texto:

<pool type='logical'>
<name>logical</name>
<source>
<device path='/dev/sdb1'/>
<name>logical</name>
<format type='lvm2'/>
</source>
<target>
<path>/dev/logical</path>
</target></pool>

Nesse exemplo, vamos assumir que a partição que compõe o grupo logico é o /dev/sdb1. Após, salve com um nome sugestivo, como por exemplo logical.xml. Agora só resta registrar no libvirt.

virsh pool-define logical.xml

Mesmo registrado, o sistema ainda não ativou o pool. É recomendado que ele seja marcado como autostart, para que caso o libvirt pare, ele ative automaticamente o pool. Para isto, basta os seguintes comandos:

virsh pool-autostart logical
virsh pool-start logical

Com o pool inicializado, agora só resta criar um volume lógico dentro dele:

virsh vol-create-as logical disco_teste 10GB

Este comando criará um volume lógico de nome disco_teste no grupo logical tendo como capacidade 10GiB

Convertendo arquivos de imagens em volumes lógicos

Caso já tenha uma máquina virtual configurada em um arquivo de imagem nos formatos suportados pelo qemu, basta convertê-lo usando o próprio qemu-img para o formato desejado. Na versão 0.12.4 os formatos suportados são: cow, qcow, vdi, vmdk, cloop, dmg, bochs, qcow2, host_device, raw entre outros.

Antes de começar, é preciso criar um volume lógico com o mesmo tamanho da imagem existente. Para ter o valor correto, use a ferramenta qemu-img para saber o tamanho total da imagem:

qemu-img info disco.img

Ele retornará algo como:

image: disco.img
file format: qcow2
virtual size: 10G (10737418240 bytes)
disk size: 4.0G
cluster_size: 65536

Veja que, embora o arquivo tenha tamanho de 4GB, ele pode crescer até o tamanho virtual, que é de 10GB para esta imagem. Agora, crie um volume lógico com este tamanho seguindo o modelo logo acima.

Eu conheço duas formas de levar o arquivo de imagem para um volume lógico. A primeira é usando o qemu-img para já gravar a imagem no volume:

qemu-img convert -f qcow2 -O host_device disco.img /dev/logical/disco_teste

Ou então, com uma etapa a mais, e portanto mais demorada, transformando a imagem do formato nativo para raw e depois transferindo os dados de forma bruta para o volume com o dd:

qemu-img convert -f qcow2 -O raw disco.img disco.raw
dd if=disco.raw of=/dev/logical/disco_teste

O resultado de ambos é o mesmo. Desde que tenha um domínio registrado com esse disco, agora é só usar o volume lógico recém criado. A definição de um disco em volume lógico segue o modelo:

<devices>
...
<disk type='block' device='disk'>
<source dev='/dev/logical/disco_teste'/>
<target dev='sdc' bus='scsi'/>
</disk>
...
</devices>

Tendo isto em mãos, basta criar um grupo de volumes lógicos do tamanho desejado na nova partição LVM. Isso pode ser feito com o seguinte comando:

vgcreate logical /dev/sdb1

No meu caso, eu não especifiquei o tamanho máximo do grupo, portanto ele pega todo o espaço disponível em sdb1. A grosso modo, o grupo de volumes lógicos está para um disco físico assim como os volumes lógicos estão para as partições. A diferença é que a virtualização do disco permite um ambiente mais flexível e simples.

Com o grupo pronto, basta adicionar os volumes. Meu disco tem 80GB, e para teste vou gerar um volume de 10GB chamado teste no grupo logical:

lvcreate -L10G -n teste logical

Pronto! Agora pode verificar que existe um dispositivo de bloco criado em /dev/logical/teste. Ele representa o volume lógico. Ele se comporta como um dispositivo de bloco comum, e portanto, pode ser tratado como um. Para conseguir usar, esse volume precisa ser formatado. Eu costumo usar o raiserfs, mas pode ser usado ext3, ext4, xfs…

mkreiserfs /dev/logical/teste
mount -t reiserfs /dev/logical/teste /mnt/tmp

O volume agora pode ser usado normalmente. É só acessar o ponto de montagem /mnt/tmp. Com o ambiente todo pronto, agora vamos ao que interessa, o snapshot. Assumindo que o volume está em plena produção, vamos simular uma situação de backup online, que é a aplicação mais óbvia que vejo neste recurso. Para melhor entendimento, vamos analisando os passos seguintes:

lvcreate -L 500M -s -n backup /dev/logical/teste

Isso fará com que seja criado um volume lógico de 500MB, de nome backup e tipo snapshot do volume já existente /dev/logical/teste. O tamanho do snapshot é claramente menor que o volume original, e isso não está errado. No momento em que o snaphot é criado, o sistema ‘congela’ o volume original para que possamos trabalhar com ele sem que haja alterações, e o tamanho do snapshot representa o volume de alterações que ele permitirá que o sistema em produção faça nesse volume sem que seja prejudicado. A grosso modo, é como se fosse um buffer de alterações, que são armazenadas sem serem efetivadas no volume original. Para aqueles que conhecem o sistema de arquivamento e hotbackup de SGBDs, é a mesma coisa.

Muitos dão exemplos de backups usando snapshots montando o volume snapshot e copiando os arquivos com cp, compactando com tar e gz, mas eu normalmente crio uma imagem completa com o dd. De qualquer forma, apresentarei ambos abaixo:

Tar e gz

mount -t reiserfs /dev/logical/backup /mnt/tmp0
tar cf ~/backup.tar.gz /mnt/tmp0

dd

dd if=/dev/logical/backup of=~/backup.img

Depois do backup, basta remover o snapshot que as alterações serão aplicadas.

lvremove -f /dev/logical/backup