Posts tagged ‘curiosidade’

  • CPU flags 2

    Data:2011.10.19 | Categoriacuriosidade | Resposta:0

    Em busca de maior detalhamento sobre o arquivo /proc/cpuinfo, encontrei mais algumas informações interessantes, como, checar se há o recurso de Turbo Boost no seu processador ou páginas aninhadas. Veja:

    • ida – Intel Dynamic Acceleration (Turbo boost);
    • ept – Intel Extended Page Table;
    • npt – AMD Nested Page Table;
    • ht – HyperThreading;
    • hypervisior – É uma máquina virtual sobre um hypervisior.

    Mais informações podem ser encontradas no arquivo cpufeature.h do código-fonte do Linux. Sua localização pode variar de acordo com a versão do kernel. Em 3.0.0 para uma máquina x86, está em arch/x86/include/asm.

  • Youtube URL offset

    Data:2011.02.11 | Categoriacuriosidade, Dicas, vídeos | Resposta:2

    YoutubeHoje, por acaso, acabei descobrindo uma coisa muito interessante no Youtube. É possível abrir um vídeo não só pelo início, mas por qualquer parte dele.

    Não sei se ficou claro, mas segue a dica:

    http://www.youtube.com/watch?v=[video id]#at=[tempo de offset em segundos]

    Exemplo:

    http://www.youtube.com/watch?v=EShea9vWFtI#at=30

    Vai começar o vídeo METNAL – Perfect Strangers (Deep Purple Cover) – Curitiba a partir de 30 segundos do início.

  • Dicas rápidas

    Data:2010.07.28 | CategoriaDicas | Resposta:0

    Nessa ultima semana, descobri dois comandos que me foram bastante úteis. Esses são at e ionice. Abaixo segue um brief sobre ambos.

    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.

  • swapfile

    Data:2010.07.21 | Categoriacuriosidade, linux, utilidades | Resposta:0

    Para usuários GNU/Linux, é muito comum o termo swap, ou partição swap. Em poucas palavras, ele diz respeito à técnica de extender a memória física, que as vezes não é suficiente, para o disco rígido. No Linux, o subsistema de memória usa um mapeamento virtual da memória, que permite um programa da userspace gravar na memória sem se preocupar onde está fisicamente. Mas este já é assunto para outro post.

    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.

  • LVM2 Snapshot

    Data:2010.07.06 | Categoriabackup, linux, utilidades, virtualização | Resposta:0

    Nessas ultimas semanas andei procurando por uma solução eficiente para backups de discos, se possível, usando imagens. Eis que conheço o recurso de snapshot do LVM2. Ele é bastante fácil de usar, mas, é lógico, você precisa de uma partição no seu disco do tipo LVM, tipo 8e.

    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

  • diff binário

    Data:2010.06.28 | Categoriacuriosidade, linux, utilidades | Resposta:0

    Estava eu procurando por uma solução de patch binário para compor uma parte do meu sistema de backups. Pois bem, embora não seja o cerne de tudo, vou explicar meu cenário para que seja melhor entendido.

    Eu estou trabalhando com máquinas virtuais com imagens de discos em volumes lógicos (LVM). Usando o recurso de snapshot do LVM, que é assunto para outro post, eu estava copiando inteiramente a imagem para um backup, através do comando dd. O problema é ter que fazer uma cópia full da  imagem a cada backup. Minha máquina de teste tem 10GB, mas imagina um servidor em produção, que pode ter várias dezenas de GBs… Fica inviável o backup deste jeito. Assim começou a busca por uma solução de calcular a diferença entre os dois binários, imagem de produção e a backup, para assim gerar um patch com somente o necessário para transferir ao servidor de backup. Após, eu precisaria aplicar este patch e assim atualizar a iamgem.

    Pesquisando no oráculo Google, encontrei este site. Lá pude baixar dois fontes, bsdiff e bspatch. Esses são versões ‘binárias’ do GNU diff e patch. Depois de baixar, compilei usando o Makefile do próprio pacote. Como ele foi feito para os *BSD, o formato do Makefile é um pouco diferente. Para compilar direitinho, crie um arquivo chamado Makefile.patch no mesmo diretório do fonte. Dentro dele, coloque o seguinte conteúdo:

    --- Makefile    2010-06-28 14:52:42.351369894 -0300
+++ Makefile.gnu        2010-06-28 14:53:29.883369968 -0300
@@ -1,4 +1,5 @@
 CFLAGS         +=      -O3 -lbz2
+INSTALL                ?=      /bin/install

 PREFIX         ?=      /usr/local
 INSTALL_PROGRAM        ?=      ${INSTALL} -c -s -m 555
@@ -10,6 +11,6 @@

 install:
        ${INSTALL_PROGRAM} bsdiff bspatch ${PREFIX}/bin
-.ifndef WITHOUT_MAN
+ifndef WITHOUT_MAN
        ${INSTALL_MAN} bsdiff.1 bspatch.1 ${PREFIX}/man/man1
-.endif
+endif

    Salve o arquivo e aplique o patch da seguinte forma:

    patch -p0 < Makefile.patch

    Depois disso, é só instalar:

    make install

    Para testar, fiz o seguinte: copiei para uma pasta os binários /bin/ls e /bin/bash. Lá, calculei a diferença usando o bsdiff:

    /usr/local/bin/bsdiff ls bash teste

    Assim, foi criado o arquivo binário teste, que é a diferença entre ls e bash, ou seja, um patch. Depois, eu resolvi aplicar este patch no próprio ls. Assim, eu faria este ls se transformar no bash.

    /usr/local/bin/bspatch ls ls_patched teste

    Realmente, aconteceu como eu esperava. O comand bspatch gerou um binário ls_patched, que é o resultado do ls + teste. E adivinha, ele é exatamente o bash. Executa  direitinho.

  • Liberar espaço

    Data:2010.06.21 | Categoriacuriosidade, linux, utilidades | Resposta:1

    De vez em quando, a partição root, ou / (barra), fica perto de usar sua capacidade máxima, e para que o sistema não pare, é preciso liberar um pouco de espaço. De cara, eu sempre penso no diretório /tmp. Claro, se ele fizer parte da mesma partição do /. Para solucionar temporariamente o problema de espaço, eu excluo os arquivos temporários que não foram usados desde uma certa data. Para isto, o comando find é bastante útil. Como exemplo, no meu laptop, eu rodo a seguinte sentença:

    $ sudo find /tmp -atime +1 -exec rm -rfv{} \;

    Isto faz com que ele busque no diretório /tmp todos os arquivos que tem a data de acesso maior que 1 dia no passado e submete-o ao comando rm, para removê-lo. A data pode ser modificada alterando o parâmetro +1 do atime. Caso coloque +2, serão buscados os arquivos com mais de 2 dias de acesso. Para mais informações, sempre existe o man.

    $ man find

    Outro utilitário bom para ajudar na busca por maior espaço livre é o du (disk usage). Ele faz uma somatória do uso de cada diretório e subdiretório. Dois parâmetros que sempre uso são: -h, para traduzir o espaço usado para unidades mais legíveis (GB, MB…); –max-depth=n, que diz ao du para correr até o nível n. Exemplo de uso:

    $ sudo du -h --max-depth=1 /tmp

    Ou seja, some o uso de todos os diretórios e subdiretórios de /tmp, porém só me exiba até o primeiro nível, de maneira legível.

  • CPU flags

    Data:2010.06.02 | Categoriacuriosidade, hardware, linux | Resposta:0

    Pelo tanto que venho lendo sobre virtualização e propriedades dos processadores, resolvi ir um pouco mais a fundo para saber o que significam aqueles nomes estranhos de instruções. No Linux pode-se verificar o conteúdo do arquivo /proc/cpuinfo:

    
$ grep flags /proc/cpuinfo
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt rdtscp lm 3dnowext 3dnow rep_good extd_apicid pni cx16 lahf_lm cmp_legacy svm extapic cr8_legacy 3dnowprefetch lbrv

    As mais comuns que vi referências foram: PAE (Physical Address Extensions) que permite endereçamento de memória acima de 4GB; HT (Hyper Threading) que permite um núcleo de processador possuir duas filhas de processamento, simulando assim processamento paralelo; LM (Long Mode) que indica presença de instruções x86_64; entre outros que podem ser encontrados neste endereço.