Como Formatar em NTFS no Linux (HD Externo, Partições, Pen Drive, etc.)?

Se você tem um pen drive, HD externo, um segundo HD, ou qualquer dispositivo que queira formatar, então esta dica é pra você!! Porém, cuidado: antes de usar estas técnicas abaixo, faça backup dos seus dados!!

• Verificando as Partições de um Dispositivo

Uma maneira simples de verificar quais são as partições de um dispositivo (ex.: um HD externo) é usando o comando mount, conforme mostrado em nossa dica Como Copiar Arquivos Grandes no Linux?. Porém, outras maneiras são:

1- usando o programa GParted

Esta é uma forma gráfica de ver como estão particionados e quais as partições de todos os seus dispositivos de dados. Para instalar o gparted no Ubuntu, por exemplo, basta digitar, como root:

apt-get install gparted

Pelo GParted é possível se formatar uma partição. Basta se clicar com o botão direito sobre ela e se escolher a opção Format to, seguida do sistema de arquivos desejado. Evidentemente, a partição deve estar desmontada para que seja formatada.

2- Com o comando fdisk

O comando fdisk é um programa antigo e bem versátil para operações com partições e discos. Funciona em modo texto. Suponhamos que seu dispositivo externo esteja em /dev/sdb. Para analisá-lo, chame o fdisk com o comando no terminal:

fdisk /dev/sdb

Comando (m para ajuda):

A partir daqui você está na linha de comando do fdisk. Uma lista geral de todos os comandos pode ser obtida pela letra m. Para ver as partições deste dispositivo, pressione p.

Comando (m para ajuda): p

Disco /dev/sdb: 1000.2 GB, 1000204886016 bytes
255 heads, 63 sectors/track, 121601 cylinders
Unidades = cilindros de 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Identificador do disco: 0x796bfcfc

Dispositivo Boot Início Fim Blocos Id Sistema
/dev/sdb1   *           1      121601   976760000+   c  W95 FAT32 (LBA)

Comando (m para ajuda):

Observe que este comando mostra dois blocos: o primeiro, com detalhes do dispositivo. O segundo, com detalhes das partições. No caso acima, temos uma partição única de quase 1TB em sistema de arquivos FAT32, começando no cilindro 1 e terminando no cilindro 121.601.

Se é só isso que você quer, pode sair do programa fdisk, pressionando a letra q.

• Apagando uma Partição e Reformatando-a

Suponho que, a partir daqui, a partição que você quer manipular está desmontada. Caso não esteja, vá para o terminal, como root, e use o comando:

umount /dev/sdb1

Troque o /dev/sdb1 pela partição desejada.

1- Com o GParted

Não é preciso apagar a partição diretamente, ele já fará isso quando a reformatação for solicitada. Basta seguir o procedimento indicado lá em cima: clicar com o botão direito sobre a partição desejada e se escolher a opção Format to, seguida do sistema de arquivos desejado. Cuidado: esta operação pode demorar, de acordo com o tamanho da partição.

2- Com o comando fdisk

Por este meio é mais manual, mas é bem fácil. Primeiramente, vamos apagar a partição desejada, usando a letra d:

Comando (m para ajuda): d
Partição selecionada 1

Comando (m para ajuda):

Agora o disco está sem partições. Vamos criar uma nova partição, usando o comando n. Como é a primeira e única partição do disco, ela será a partição primária (use, na pergunta, a letra p); de outro modo, deverá ser uma partição estendida (use, na pergunta, a letra e). Indique o primeiro e último cilindros da partição. Se você quer o disco todo, pode usar os valores padrões (apenas tecle ENTER); de outra forma, digite o primeiro e último cilindros nas perguntas correspondentes. Faça o cálculo de quanto espaço cada partição terá baseado nos valores de bytes contidos em cada faixa de cilindros (o comando p, acima, diz quantos bytes tem em 1 cilindro):

Comando (m para ajuda): n
Comando - ação
   e   estendida
   p   partição primária (1-4)
p
Número da partição (1-4): 1
Primeiro cilindro (1-121601, padrão 1):
Usando valor padrão 1
Last cilindro, +cilindros or +size{K,M,G} (1-121601, padrão 121601):
Usando valor padrão 121601

Comando (m para ajuda):

Agora sua partição está quase pronta!! Falta dizer qual o tipo de partição. Para tanto, use a letra t. Existem dezenas de tipos de sistemas de arquivos diferentes suportados pelo fdisk (na verdade, pelos drivers do kernel e pelas ferramentas de utilitários destes drivers que estão instaladas no momento). Para ver a lista completa e escolher qual deles você quer, digite L maiúsculo na pergunta e verifique qual o seu código numérico. Para adiantar, posso informar que o tipo NTFS é código 7.

Comando (m para ajuda): t
Partição selecionada 1
Código hexadecimal (digite L para listar os códigos): 7

O tipo da partição 1 foi alterado para 7 (HPFS ou NTFS)

Comando (m para ajuda):

Agora basta efetivar todas estas alterações e sair do fdisk, usando a opção w, que escreve todas as alterações no dispositivo.

Comando (m para ajuda): w
A tabela de partições foi alterada!

Finalmente, precisamos agora formatar a partição. Cuidado: dependendo do tamanho da partição e do dispositivo, esta operação pode demorar bastante tempo!!

Para formatar a partição, use a ferramenta de formatação própria do sistema de arquivos escolhido, seguida pelo caminho da partição. Para o caso do NTFS, use:

mkntfs /dev/sdb1

(cuidado, não é mkntfs /dev/sdb! Indique a partição correta!)

Para outros sistemas de arquivos, existem formatadores equivalentes, como: mkfs.ext2, mkfs.ext3, mkfs.ext4, mkfs.minix, mkfs.msdos, mkfs.vfat, etc.
Quando tudo terminar, o comando irá mostrar uma linda mensagem de sucesso:
 

Initializing device with zeroes: 100% - Done.
Creating NTFS volume structures.
mkntfs completed successfully. Have a nice day.

• Renomeando uma Partição NTFS

Agora que você acabou de criar uma partição NTFS nova, ela precisa de um nome. Inicialmente, ela é batizada com um número feio. Pode até ficar assim, mas convém mudá-lo. Para renomear uma partição NTFS usando Linux, ela precisa estar desmontada. Certamente estará, se acabou de ser criada. Agora basta digitar, ainda como root:

ntfslabel /dev/sdb1 NovoNome

Onde /dev/sdb1 é a partição (não é /dev/sdb, cuidado!!) e NovoNome é o nome válido que você escolheu para ela.

• Conclusão

Este breve artigo procura ensinar duas técnicas diferentes de formatação de partições, que podem ser utilizadas em diferentes situações, desde pen drives até discos rígidos externos ou secundários. Tenha cuidado ao reformatar uma partição, pois seus dados serão perdidos, além do que ela pode demorar bastante tempo, o que requer planejamento. Lembre-se de que a reformatação não conserta defeitos físicos no disco, mas na verdade pode vir a escondê-los!! Para aprender como solucionar este tipo de problema, visite nosso outro artigo: Como recuperar partição Reiserfs com bad blocks?.

Boa sorte!! Espero ter ajudado!! Qualquer coisa, COMENTEM!!

Como Copiar Arquivos Grandes no Linux?

Imagine que você precisa copiar um arquivo bem grande (ou de tamanho que consideramos bem grande para os dias de hoje, quando escrevo), algo em torno de vários gigas. Pode ser um dump geral de seu banco de dados, um arquivo de log gigantesco, um arquivo temporário ou um filme em Blue Ray. Pode ser que a cópia de backup deste arquivo falhe ou a escrita para ele comece a falhar a partir de certo ponto... o que fazer??

Calma, o Pajé tem a solução!!

• Cópia em Ambiente Linux

Se você usa um sistema de arquivos moderno, como o ext4, então você poderá escrever vários gigas num mesmo arquivo. Se sua cópia ou escrita falhar, tente verificar se existe algum limite pré-definido de escrita, usando o comando:

$ ulimit
unlimited

Se a resposta for a que mostro aí em cima (unlimited), então não há limite para a sua cópia. De outra forma, pode haver limite. Daí, para redefinir o limite, basta usar este mesmo comando, passando o novo valor após o argumento -f:

$ ulimit -f [valor]

Para um tutorial completo sobre limites de escrita, uso e cotas de usuários, visite este endereço.

• Cópia pela Rede, para Pen-Drives, HDs Externos ou Outros Dispositivos

Agora realmente a coisa muda de figura!! Você está tentando copiar um arquivo que está em um sistema de arquivos Linux para um dispositivo que provavelmente tem seu próprio sistema de arquivos, não necessariamente aquele que você usa na máquina de origem do arquivo. Lembre-se de que um sistema de arquivos é um banco de dados, e que cada tipo tem seus próprios limites.

Se você está copiando para outro dispositivo, verifique qual o sistema de arquivos que ele usa com este comando (claro, presumindo que o dispositivo esteja montado e acessível!!):

$ mount

(....)

/dev/sdb1 on /media/HDExterno type vfat

O comando acima vai mostrar tudo que está montado em seu sistema (a maioria não interessa neste momento, então coloquei estas saídas no formato de "(...)", para ficar mais fácil de entender). Porém, uma das linhas da saída vai se reportar ao dispositivo externo. No caso acima, é um HD Externo, que é acessível em /dev/sdb1 e está montado em /media/HDExterno. Observe que o tipo de sistemas de arquivos é vfat, ou seja, possivelmente um FAT32.

O sistema de arquivos FAT32 (vfat) é o pior que tem: um sistema antigo, limitado e muito simples. Porém, exatamente dada a sua simplicidade, ele é facilmente acessível e montável em ambientes os mais diferentes, desde Linux e MAC até Rádios (CD Players), TVs, DVD Players, CD Players de carros e aparelhos de som.

Notem que o HD Externo acima está formatado em FAT32. Pelas características deste sistema de arquivos, não é possível gravar nenhum arquivo maior que 4GB (na verdade, um byte antes de 4GB de tamanho). Não adianta, quantas vezes você tentar, vai falhar...

• Achando a Solução para o Caso Acima

Se o seu caso é este acima, então tente fazer uma destas soluções:

1- Reformatar o HD com outro sistema de arquivos, como o NTFS (para ter compatibilidade com Windows) ou mesmo os sistemas do Linux, como ext4, ReiserFS, etc. Claro, isto implica em fazer backup de tudo que tem nele, apagar o HD Externo totalmente e reformatar. Porém, se você precisa muito gravar um arquivão de mais de 4GB, que pode ser seu precioso banco de dados ou o Log de seu sistema, então vale a pena o esforço!!

2- Uma alternativa, é usar o comando split, que quebra o arquivo em vários pedaços definidos por você. Depois desta quebra, o original pode ser apagado e os pedaços, em menor tamanho, podem ser gravados sem problemas. Fique tranqüilo, pois eles podem ser remontados sempre que necessário, usando o comando cat. Excede o escopo deste tutorial explicar detalhadamente como eles funcionam, mas a documentação dos mesmos é bem clara e certamente você conseguirá usá-los bem (digite "man split" e "man cat" para ver a página do manual de cada um)!!

3- Existem compactadores muito bons que conseguem reduzir em grande parte o tamanho dos arquivos. Muitos deles, como o rar, suportam não só a compactação como também a quebra do arquivo compactado em arquivos menores e de mesmo tamanho. Muitas vezes, você pode usar mais de um compactador, como a combinação do tar com o gzip ou bzip2. Se você pretende fazer backup, recomendo sempre compactar os dados e, claro, você pode fazer um script para te ajudar nesta tarefa um tanto quanto enfadonha.

Bom, pessoal, por hoje é isso... espero ter ajudado!!

Faxina no Linux: Limpando as Imagens Antigas do Kernel

Você pode não ter notado, mas algumas distribuições, como o Ubuntu, no momento de fazer uma grande atualização, podem baixar novas versões do Kernel, compilá-las automaticamente (ou ao menos instalar imagens pré-compiladas), gerando as chamadas "Imagens do Kernel" e aplicá-las nas opções do boot. Este procedimento não tem problema nenhum, salvo o fato de que as imagens são sempre acompanhadas pelo código-fonte, o que ocupa bastante espaço no seu disco. Além disso, polui a tela de boot do LILO ou GRUB com opções diferentes para cada imagem de kernel, desde a mais antiga, que veio com a instalação do sistema, até as mais recentes baixadas e instaladas.

Como limpar estas imagens de Kernel seguramente, remover as centenas de megas em fontes ocupando seu disco rígido e limpar as entradas das opções de boot do GRUB? Este artigo trata exatamente desta dica, e creio que possa ser de grande valia para muitos usuários Linux, especialmente aqueles que costumam fazer atualizações constantes.

Em sistemas baseados em Debian, como o Ubuntu, para rodar uma atualização completa, basta que se digite, como root:

apt-get dist-upgrade

A atualização do sistema pode reportar, muitas vezes, uma atualização das imagens do Kernel no meio do monte de pacotes sendo atualizados. Isto pode ser verificado nas linhas em negrito do exemplo abaixo:

apt-get dist-upgrade

Lendo listas de pacotes... Pronto
Construindo árvore de dependências      
Lendo informação de estado... Pronto
Calculando atualização... Pronto
Os NOVOS pacotes a seguir serão instalados:
  linux-headers-2.6.32-32 linux-headers-2.6.32-32-server linux-image-2.6.32-32-server
Os pacotes a seguir serão atualizados:
  apparmor apparmor-utils apt apt-transport-https apt-utils at base-files bind9-host binutils bsdutils dhcp3-client dhcp3-common dnsutils fuse-utils grub-common grub-pc initscripts landscape-common libapache2-mod-php5 libapache2-svn libapparmor-perl libapparmor1 libapr1 libbind9-60 libblkid1 libc-bin libc-dev-bin libc6 libc6-dev libcurl3-gnutls libdbus-1-3 libdbus-glib-1-2 libdns64 libfuse2 libgssapi-krb5-2 libisc60 libisccc60 libisccfg60 libk5crypto3 libkrb5-3 libkrb5support0 libldap-2.4-2 liblwres60 libpam-modules libpam-runtime libpam0g libpcsclite1 libplymouth2 libssl0.9.8 libsvn1 libuuid1 libxml2 linux-firmware linux-headers-server linux-image-server linux-libc-dev linux-server login logrotate mount ntpdate openssh-client openssh-server openssl passwd perl perl-base perl-modules php5 php5-common plymouth plymouth-theme-ubuntu-text python-smartpm rsync subversion sysv-rc sysvinit-utils tzdata upstart util-linux uuid-runtime w3m xkb-data
83 pacotes atualizados, 3 pacotes novos instalados, 0 a serem removidos e 0 não atualizados.
É preciso baixar 96,8MB de arquivos.
Depois desta operação, 216MB adicionais de espaço em disco serão usados.
Você quer continuar [S/n]?

O novo Kernel é empacotado em pacotes com outros nomes, então, para o gerenciador de pacotes, não é considerado uma atualização, e sim uma gama de pacotes novos a serem instalados. Observe que existem muitos pacotes sendo de fato atualizados, o que não vai consumir espaço excedente quase nenhum, mas tem uma nova versão do Kernel a ser baixada, o que vai consumir 216MB de espaço, já que é preciso que se baixem todos os fontes. Naturalmente, a versão antiga, que está em pacotes de outros nomes, será mantida por padrão.

Depois de selecionar "S" para a pergunta e a atualização acabar, você já terá ocupado mais de 300MB deste sistema aí em cima sendo atualizado. Então, vamos limpar os arquivos de backup dos pacotes que foram baixados e atualizados. Se a atualização funcionou, não precisamos mais deles. Para tanto, digite:

apt-get clean

TESTE: Agora, dê um boot e certifique-se de que o sistema esteja funcionando perfeitamente, ou seja, a nova imagem do Kernel funciona e está estável (para fazer isto em modo texto, digite: "shutdown -r now"). Em avassaladora massa de vezes tudo estará perfeitamente estável, mas não custa fazer o teste, especialmente em servidores. Como o Pajezinho sempre diz, "um homem prevenido vale por cinco"!!

Estando tudo perfeito, vamos apagar os Kernels antigos do sistema:

apt-get autoremove

Respondendo "S" à pergunta gerada com o comando acima, será possível eliminar os pacotes referentes a Kernels antigos, aliviando centenas de megas de seu disco rígido. Contudo, isto ainda não limpa as imagens que estão associadas ao boot e à tela inicial do GRUB. Para limpá-las, é preciso que se vá ao diretório "/boot" e se apague os arquivos certos.

cd /boot

ls -1

abi-2.6.32-26-generic
abi-2.6.32-27-generic
abi-2.6.32-28-generic
abi-2.6.32-29-generic
abi-2.6.32-30-generic
abi-2.6.32-31-generic
abi-2.6.32-32-generic
config-2.6.32-26-generic
config-2.6.32-27-generic
config-2.6.32-28-generic
config-2.6.32-29-generic
config-2.6.32-30-generic
config-2.6.32-31-generic
config-2.6.32-32-generic
grub
initrd.img-2.6.32-26-generic
initrd.img-2.6.32-27-generic
initrd.img-2.6.32-28-generic
initrd.img-2.6.32-29-generic
initrd.img-2.6.32-30-generic
initrd.img-2.6.32-31-generic
initrd.img-2.6.32-32-generic
memtest86+.bin
System.map-2.6.32-26-generic
System.map-2.6.32-27-generic
System.map-2.6.32-28-generic
System.map-2.6.32-29-generic
System.map-2.6.32-30-generic
System.map-2.6.32-31-generic
System.map-2.6.32-32-generic
vmcoreinfo-2.6.32-26-generic
vmcoreinfo-2.6.32-27-generic
vmcoreinfo-2.6.32-28-generic
vmcoreinfo-2.6.32-29-generic
vmcoreinfo-2.6.32-30-generic
vmcoreinfo-2.6.32-31-generic
vmcoreinfo-2.6.32-32-generic
vmlinuz-2.6.32-26-generic
vmlinuz-2.6.32-27-generic
vmlinuz-2.6.32-28-generic
vmlinuz-2.6.32-29-generic
vmlinuz-2.6.32-30-generic
vmlinuz-2.6.32-31-generic
vmlinuz-2.6.32-32-generic

O comando "ls -1" lista os arquivos e diretórios todos em uma única coluna. Usei este comando para ficar mais fácil a leitura da saída dele aqui no blog. Obverse que temos aí uma verdadeira confusão: uma sopa de kernels e imagens que foram instalados, desde o 2.6.32-26 até o 2.6.32-32. O mais recente é aquele que instalamos lá em cima, o 2.6.32-32. Se ele está rodando e funcionando perfeitamente (conforme nosso teste acima), então podemos seguramente apagar todos os outros:

rm *-26* *-27* *-28* *-29* *-30* *-31*

Cuidado com o comando acima!!! Um dígito errado e você poderá estar prejudicando permanentemente seu sistema!! Apague apenas os arquivos cujos nomes apontam para as versões ANTIGAS do Kernel, nunca os que apontam para a mais recente!!

Depois disso, basta atualizar o GRUB ou o LILO (dependendo de qual você use) para que ele não aponte mais para as imagens antigas (até porque, elas foram apagadas). Para atualizar o LILO, é preciso que se edite manualmente o seu arquivo de configurações, removendo as linhas correspondentes às imagens apagadas. Para atualizar o GRUB (que é bem mais fácil!!), basta que se rode o seguinte comando:

update-grub2

Generating grub.cfg ...
Found linux image: /boot/vmlinuz-2.6.32-32-generic
Found initrd image: /boot/initrd.img-2.6.32-32-generic
Found memtest86+ image: /boot/memtest86+.bin
done

Prontinho!!!! O GRUB encontrou apenas uma versão do Kernel, que é a mais recente!! Você já pode reiniciar o sistema e ver a tela limpinha do GRUB funcionando. Pode verificar seu disco para notar o quanto de espaço foi recuperado graças ao comando "apt-get autoremove" (para verificar o disco, use o comando "df -h").

Observações Importantes:

1- Evite colocar esta operação em scripts. São operações delicadas e muito pouco rotineiras. Faça-as com carinho e cuidado, manualmente;

2- Em servidores, assegure-se do momento mais propício para reiniciar a máquina;

3- Caso você tenha compilado manualmente uma versão do Kernel, assegure-se de deixá-la intacta. Tudo que não for removido será automaticamente detectado pelo GRUB e permanecerá válido;
4- Se você tiver medo na hora de apagar os arquivos do /boot, faça um backup deles. Caso necessário, apague os arquivos um a um, sem usar o "*", de forma a que você não se engane nem apague um arquivo errado;
5- Se você fez tudo isso e usa o indexador padrão do Linux, este é um bom momento para rodar o comando "updatedb". Não vai lhe render muito mais espaço em disco, mas vai remover uma série de entradas dos índices e vai deixar a busca mais leve;

6- Evidentemente, faça absolutamente todas estas operações como superusuário (root). De outro modo, nenhuma delas funcionará.

Bom, espero ter ajudado!! Boa sorte e, lembrem-se: COMENTEM!!!

Instalando o Ambiente de Programação Qt

O Qt é um arcabouço de desenvolvimento em C++ para ambientes gráficos (vide verbete da Wikipedia). Além de ser bem antigo, o Qt é muito poderoso e dá sustentação a uma série de grandes e complexas aplicações, como o KDE. Este artigo mostra como instalar o ambiente de desenvolvimento Qt em sua máquina Linux.

• Instalação do Qt

Primeiramente, você precisará instalar os pacotes de desenvolvimento que são necessários para o Qt existir na sua máquina:

apt-get install libqt4-dev

Isto instalará os seguintes pacotes:

libdrm-dev libgl1-mesa-dev libglu1-mesa-dev libpthread-stubs0 libpthread-stubs0-dev libqt4-dev libqt4-multimedia libqt4-opengl-dev libx11-dev libxau-dev libxcb1-dev libxdmcp-dev mesa-common-dev x11proto-core-dev x11proto-input-dev x11proto-kb-dev xtrans-dev.

São em torno de 10MB para download e 43MB instalados.

É preciso também se instalar o compilador de C e C++, obviamente, uma vez que o Qt é um arcabouço para a linguagem C++:

apt-get install g++

Por fim, é preciso se instalar a ferramenta qmake, que gera automaticamente o seu projeto e o MakeFile do mesmo:

apt-get install qt4-qmake

• Testando o Ambiente

Feitos os passos acima, seu ambiente deverá estar pronto para o desenvolvimento. Vamos fazer um pequeno teste. Crie um diretório para um programa no estilo "Hello World" do Qt:

mkdir Qt

cd Qt

Agora crie o arquivo de seu programa (inspirado neste tutorial):

vi main.cpp

e digite o código dentro dele:

#include
#include

 int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);

     QPushButton hello("Hello world!");
     hello.resize(100, 30);

     hello.show();
     return app.exec();
 }

Como estamos preocupados apenas em instalar o ambiente, não vou esmiuçar o que o código faz, mas os detalhes para tanto podem ser encontrados na referência do tutorial citado acima.

Terminada de codificar sua classe C++, você deve criar o arquivo do projeto da mesma (arquivo .pro):

qmake -project

E, agora, gerar o arquivo MakeFile:

qmake

Beleza, estamos quase no fim!! Para finalmente compilar seu programa, vamos fazer o MakeFile rodar:

make

Provavelmente isto chamará o g++, que compilará o programa e gerará um arquivo executável chamado "Qt". Para executá-lo, basta digitar:

./Qt

E surgirá o nosso programinha de Hello World na tela!!

É claro que existem ambientes de desenvolvimento próprios para o Qt, de forma que você poderá automatizar em grande parte os passos acima. Contudo, é sempre bom saber o que ocorre internamente, em especial quando se busca a solução de algum problema ou a identificação de uma biblioteca omissa em seu ambiente.

Como Remover um Commit Errado no SVN? Ou: Como Desfazer um Commit no Subversion?

Este artigo é dedicado a todos aqueles que já enviaram um commit equivocado para o SVN e quebraram ou estragaram alguma coisa no sistema onde trabalham. Quem nunca fez isso antes, que atire a primeira pedra!!
Bom, mas vamos lá.... A reposta para a pergunta acima é bem simples: não há como. Meu Deus, então agora estou perdido?? Calma, não se preocupe!! Existe uma técnica que lhe permite reverter o seu repositório para um estado anterior, se for realmente preciso. Acompanhe nosso artigo.

• Por Que não há uma Forma Direta de Desfazer Commits??

Se desejar, você pode ir imediatamente para a solução do problema, lá embaixo. Entretanto, eu resolvi incluir esta seção aqui para lhe ajudar a pensar mais sobre como funciona o SVN e quais as suas premissas, aumentando seu conhecimento sobre o mesmo.
O SVN armazena seus dados em um banco de dados interno (ou em BDB - Berkeley Data Base, ou em FSFS). Evidentemente, seria possível fazer operações comuns a bancos de dados, como delete ou roll back. Contudo, o Subversion não permite qualquer tipo de remoção de entradas (inserts) de dados que foram efetivadas, sob risco de comprometer a segurança do repositório. Observe o risco a que os desenvolvedores estariam sujeitos e a falta de confiança que se geraria sobre os repositórios se isso fosse possível, considerando cenários como:

1. Um desenvolvedor ou administrador de sistemas é demitido. Num acesso de raiva e considerando-se injustiçado, ele remove grande parte dos commits dos repositórios da empresa, deixando-os em estados muito primitivos e perdendo grande parte dos códigos gerados durante anos.
2. Um desenvolvedor mal intencionado pratica sabotagem industrial: elimina ou deturpa parte do código do sistema antes do mesmo ser compilado e o envia para produção. Após a implantação do sistema danificado, o desenvolvedor remove o trecho defeituoso que criou, eliminando a única prova concreta de sua ação.
3. Imagine que ninguém será demitido e não há qualquer pessoa mal intencionada. Ao contrário: todos trabalham felizes e freneticamente. Contudo, a equipe tem o hábito de, vez por outra, remover um commit mal feito. A uma certa altura, descobre-se um erro grave no sistema que está há mais de 1 mês em produção. A correção parece simples e poderia ser feita em cerca de um dia. Contudo, a quantidade de commits removidos impede que se consiga restaurar o código exato da versão que está em produção. Resultado: o erro vai persistir lá até que a versão seguinte seja totalmente finalizada e implantada...

Por motivos como estes, a remoção direta de commits não é possível. No entanto, existe a solução paliativa, um pouco mais agressiva, porém que funciona e é razoavelmente fácil e segura. Acompanhe-a na próxima seção!!

• Removendo um Commit Indesejado

Se é realmente necessário remover um ou mais commits do SVN, e espero que tenham sido os últimos, então a única solução é fazem um dump do repositório filtrado pelo número de revisão, eliminá-lo, recriá-lo e restaurar o dump com um load, de forma a carregar no repositório recém-criado todas as revisões até a última antes das indesejadas. Todas estas ações devem ser feitas como root!! Vamos fazer isso passo a passo...

1. Fazendo o dump:
Considere que seu repositórios se chame "repo" e você está no diretório onde ele se encontra. Primeiramente, pare todos os acessos ao repositório, para congelá-lo (ou seja, pare o Apache, se você usa o WebDAV, ou impeça o login via SSH de usuários comuns, se você usa o protocolo svn+ssh://). Descubra o número da última revisão boa (desejada), a partir da qual todas serão eliminadas (suponhamos: revisão 200), para que façamos o dump de tudo até ela. Agora, considerando esta revisão, faça o dump:

svnadmin dump repo --revision 0:200 > repo.dump

É criado o arquivo repo.dump, que contém todas as revisões deste o tenro início de seu repositório até a revisão informada, de número 200.

2. Remova o repositório e crie outro idêntico:
Se você quiser, por segurança, pode mover o repositório para outro nome ao invés de apagá-lo, de forma a manter uma cópia de segurança do mesmo, caso alguma operação falhe. Você pode também fazer um backup do diretório completo do repositório ou armazená-lo em um arquivo .tar.gz, para economizar espaço, caso o repositório seja muito grande.

rm -rf repo
svnadmin create --fs-type bdb repo

Isto recria o repositório com mesmo nome, só que agora completamente vazio.

3. Agora sim, subindo tudo!!
Rode o comando, considerando o arquivo de dump gerado e o repositório novo recém-criado. Observe que, evidentemente, convém utilizar o mesmo nome do repositório antigo, para que outras configurações de seu sistema permaneçam válidas:

svnadmin load repo < repo.dump

Se tudo deu certo até aqui, você terá seu repositório recuperado até a revisão que você informou no dump, de forma que as posteriores foram ignoradas e serão perdidas.

4. Para finalizar, não esqueça deste procedimento!! Atribua as mesmas permissões de arquivos, dono e grupo originais às pastas do repositório, especialmente ao diretório "db" e seus arquivos. Se você usa o WebDAV, por exemplo, terá de tornar os arquivos pertencentes ao usuário "www-data" (ou o nome que tem seu usuário do Apache), e não "root", como é inicialmente criado. Não esqueça de verificar se os diretórios estão marcados como executáveis, se for o caso, para permitir a criação de novos arquivos de log no diretório "db".

5. Teste tudo bem detidamente, para evitar surpresas. Em tudo funcionando, finalmente, faça a faxina: elimine ou faça backup do repositório antigo e dos arquivos de dump que ainda estão no disco.

Bom, pessoal, testei realmente todos estes comandos, embora eu mesmo já tenha me visto em situações de utilizar este mecanismo para eliminar commits errados. Torço que tudo dê certo com vocês!!

Mais detalhes sobre administração de repositórios, consultem o manual do SVN (SVN Red Book), Capítulo 5. Veja também nosso artigo completo sobre Como Fazer Backup de Repositórios SVN. E, claro, COMENTEM!!!

Aplicando Comandos a vários Arquivos Recursivamente

Este artigo ensina como tirar proveito de uma famosa dupla: os comando find e xargs. Juntos, eles podem capturar arquivos que se encaixam em determinadas características e aplicar, de uma vez só, um comando específico para todos eles. É muito útil se você quiser apagar ou copiar determinados arquivos que existem em vários níveis diferentes da árvore de diretórios, contar linhas de um código que tem arquivos de fontes em vários diretórios dentro de uma pasta de fontes, além de milhares de outras coisas... Vejamos as possibilidades!!

• O comando find

O segredo de tudo é o comando find. Basicamente, este comando é capaz de varrer o diretório especificado como parâmetro e todos os seus subdiretórios para achar e listar na tela arquivos que se conformem às características especificadas. Ele suporta duas ordens de parâmetros:

[1]- Configuração da busca (nível de profundidade, se deve ou não seguir links simbólicos, se deve ou não penetrar em outros filesystems montados na árvore pesquisada, se deve ser sensível à caixa ou não, etc...).
[2]- Configuração do filtro: quais as características dos arquivos que devem ser encontrados (nome ou trecho do nome do arquivo, data de modificação do arquivo maior ou menor que alguma data indicada, etc...).

Os parâmetros de [1] são sempre maiúsculos, e os parâmetros de [2] são sempre minúsculos. A documentação de todos os parâmetros pode ser fácil e detalhadamente encontrada na página de manual do comando (ou, opcionalmente, uma versão reduzida pode ser encontrada aqui). Para tanto, basta digitar:

man find

Assim, para não ficar muito teórico, vamos aprender a usar este comando a partir de exemplos, vendo como ele pode ser poderoso...

• Encontrando Todos os .directory do Dolphin

O Dolphin, que vem por padrão com o KDE 4, é um excelente gerenciado de arquivos e realmente foi um bom substituto para quem subutilizava o Konqueror, no KDE 3, apenas como gerenciador de arquivos e pastas. O (grande?) problema dele e que, de fato, muito me incomoda, é que ele cria em diversos diretórios um arquivo oculto chamado ".directory". São arquivos de texto pequenos, contendo informações como a data do último acesso e o modo de visualização de arquivos. Um exemplo de arquivo ".directory":

cat .directory
[Dolphin]
Timestamp=2010,12,4,13,44,38
ViewMode=1

Se você é paranóico como eu e não gosta de deixar registros de onde você passou, ou simplesmente quer apagar estes arquivos para poupar espaço, vamos então primeiro encontrar a todos com o comando find, e depois apagá-los (quanto a apagá-los, continue conosco no item adiante...):

# Voltando para a pasta padrão do usuário
cd

# Encontrando recursivamente todos os arquivos ".directory"
find . -iname .directory

O que significa isso tudo no comando find?

".": diretório atual, a partir de onde a busca deve começar.
"-iname": indica que o filtro será por nome.
".directory": o nome do arquivo. Aqui podemos utilizar os mesmos caracteres curingas que usamos com todos os demais comandos de navegação e manipulação de arquivos.
O resultado será a listagem na tela do caminho a partir do diretório informado, linha a linha, de todos os arquivos encontrados.

• Removendo Todos os .directory do Dolphin

Agora vamos finalmente apagá-los!! Para tanto, precisamos utilizar o comando xargs. Este comando simplesmente toma a saída de outro comando (como o find) e aplica seqüencialmente um terceiro comando, passado para ele por parâmetro, a cada linha que receber. O comando que apaga arquivos, como sabemos, é o "rm -f" (o parâmetro "-f" apenas assegura que o apagamento será silencioso, ou seja, o comando não vai te perguntar, item a item, se quer mesmo apagar o arquivo). É claro que o xargs tem várias opções e elas estão detalhadas na sua página de manual (digite "man xargs"). Para nós, o que interessa é que ele recebe como parâmetro o comando que deve ser executado para as benditas linhas do resultado.
Importante: para pegar a saída para a tela que o comando find gera e redirecioná-la para o comando xargs, utilize o caracter pipe ("|").
Assim, o comando mágico ficará:

find . -iname .directory | xargs rm -f

Outra opção, dispensando o comando xargs, é:

rm -f 'find . -iname .directory'

A única restrição é que os diretórios não podem ter nomes com caracteres inválidos (possível em alguns filesystems) ou com espaços, senão o comando rm falhará. Lembre-se de que o xargs passa para o comando que lhe foi informado a linha de resultado exatamente como ele a recebe!!

• Apagando Todas as Pastas .svn
  

Cuidado com este comando, ele pode ser drasticamente perigoso, embora, em algumas situações, você possa querer isto mesmo....
Quem utiliza projetos versionados já deve ter notado que o cliente de versionamento adiciona geralmente uma pasta oculta com dados da versão local, dados temporários e, algumas vezes, algum cache de arquivos. Exemplos deste comportamento são o Subversion, que cria a pasta ".svn". Para remover estas pastas, use o comando:

find . -iname .svn | xargs rm -rf

A opção "-r" do comando rm apaga a pasta inteira mesmo que ela não esteja vazia, que certamente é o caso de uma pasta deste tipo acima.

• Buscando Apenas Diretórios

find . -type d -name .sv*

A opção "-type d" indica que só estamos interessados em diretórios. Existem outros tipos que podem ser informados com o parâmetro "-type", a saber "f", para arquivo, "s", para soquete, "l", para link simbólico, etc.

• Contando as Linhas de Vários Arquivos Fontes Automaticamente

Este é outro momento de glória do comando find!! Para contar as linhas de um arquivo, utilizamos o comando wc -l. O parâmetro "-l" indica que serão contadas apenas linhas.

find ./src -iname *.java | xargs wc -l

Note que, aqui, mostramos que os caracteres como "*" e "?" podem ser utilizados no comando find. Evidentemente, no comando acima, supomos que os arquivos fontes estão no diretório ./src.

• Contando Todos os Arquivos de um Diretório

Se você quiser contar rapidamente todos os arquivos de um diretório, saiba que existem várias maneiras de se fazer isso, das quais podemos sugerir, com o comando find, uma maneira bem simples:

find . > arquivos && wc -l arquivos && rm arquivos

Dissecando o comando acima:

"find .": simplesmente lista todos os arquivos, já que nenhum filtro foi especificado.
"> arquivos": copia os resultados para um arquivo chamado "arquivos".
"&&": significa que outro comando deverá ser executado em seguida.
"wc -l arquivos": conta todas as linhas do arquivo "arquivos", ou seja, se a cada linha eu tenho, na verdade, um arquivo encontrado pelo comando find, então esta contagem corresponderá ao total de arquivos encontrados.
"&&": outro comando que deverá ser executado na seqüência...
"rm arquivos": claro, vamos apagar o arquivo "arquivos", já que ele foi criado apenas temporariamente para que o comando "wc -l" pudesse contar as suas linhas.

Assegure-se de ter permissão de escrita no local onde o arquivo será criado, para que o comando funcione!!
Este trecho é interessante porque pode dar margem a várias outras idéias (criando pesquisas específicas com os recursos que já vimos acima), como guardar em arquivos diferentes listagens específicas que poderão ser utilizadas em um script mais complexo, evitando repetir o comando find desnecessariamente.


Bom, pessoal, creio que vimos vários exemplos interessantes e muito úteis sobre como tirar proveito dos comandos find e xargs, uma verdadeira dupla dinâmica, usados em conjunto com os comandos wc, rm, dentre outros. Existem muitas outras situações interessantes derivadas destas e muitas outras novas, que podem ser formuladas de acordo com as suas criatividade e necessidade. O céu é o limite!! Espero que tenham gostado!! E não esqueçam que o Pajé adora quando os leitores COMENTAM!!!

Como Listar os Usuários e Grupos Existentes no Linux?

Os usuários existentes em uma instalação do sistema Linux podem ser listados facilmente se conseguimos listar o arquivo de dados onde eles são catalogados pelo sistema, ao lado de várias outras informações pessoais importantes, como a sua senha (criptografada, naturalmente), seu nome, grupo primário, etc. Este fantástico arquivo é o /etc/passwd. Ver o seu conteúdo pode ser feito pelo comando abaixo (não precisa ser root):

cat /etc/passwd

Em geral, isto lista uma série de informações. Os grupos, analogamente, encontram-se no arquivo /etc/group, associados a algumas informações pertinentes, e podem ser listados da seguinte maneira (não precisa ser root):

cat /etc/group

Dependendo de como o sistema esteja configurado, as senhas dos usuários podem ficar em local específico, no arquivo /etc/shadow, que só pode ser lido ou modificado pelo root:

cat /etc/shadow

• Entendendo o /etc/passwd

Como este arquivo é usado durante o login, ele é acessível a todos os usuário (para leitura), mas só pode ser modificado pelo administrador do sistema. Cada linha representa um usuário e contém seus dados específicos. Cada campo é separado do outro pelo caracter ":" (dois pontos). Observe a seqüência de dados presentes em cada linha, conforme mostra o trecho do arquivo abaixo:

gdm:x:105:112:Gnome Display Manager:/var/lib/gdm:/bin/false
paje:x:1001:1001:O Paje,,,:/home/gabriel:/bin/bash
1 :2: 3 : 4 : 5 :6 :7

1- nome do usuário: contém o nome da conta do usuário, que pode ter entre 1 e 32 caracteres. Em nosso caso, um usuário se chama "gdm" e o outro "paje";

2- É o local da senha. Se, ao invés disso, houver o caracter "x", então o arquivo indica que as senhas estão encriptadas no arquivo /etc/shadow, que só pode ser lido pelo root.

3- UID (User ID). Número identificador do usuário. Nunca existirão dois usuários com o mesmo número. O UID segue as seguintes regras: 0=root; 1-99=contas pré-definidas (ex: bin, sys, mail, games, irc); 100-999=reservados pelo sistema para contas administrativas e de gerenciamento interno; a partir de 1000=usuários convencionais. No caso acima, "gdm" é um usuário administrativo, mas "paje" é um usuário normal.

4- GID (Group ID). Número identificado do grupo primário do usuário. Um usuário pode estar associado a vários grupos, mas tem apenas um grupo denominado "primário". Quando o usuário cria um arquivo novo, por exemplo, este arquivo fica registrado como pertencente a este usuário seu criador e ao grupo ao qual ele está associado como grupo primário no momento de criação do arquivo.

5- Uma série de informações separadas por vírgulas (que nem sempre são cadastradas!), como o nome real do usuário, telefone, número da sala, etc.

6- O caminho completo (absoluto) do diretório do usuário.

7- O shell que será executado cada vez que este usuário fizer login. Em geral é /bin/bash (para usuários comuns), mas pode ser outro shell ou mesmo /bin/false, caso o usuário não seja autorizado a fazer login.

Não foi tão difĩcil entender estes campos, foi??

• Várias Maneiras de Listar Usuários

Verificando se um usuário existe mesmo, e sabendo suas informações:

grep gdm /etc/passwd
gdm:x:105:112:Gnome Display Manager:/var/lib/gdm:/bin/false

Verificando todos os usuários convencionais (que, supostamente, possuem um diretório no /home):

grep /home/ /etc/passwd

Mostrando uma listagem simples, contendo somente o nome dos usuários, sem as demais informações da linha:

grep /home/ /etc/passwd | cut -d: -f1

O comando "cut" usado no filtro "|" recorta o resultado do comando grep. Os parâmetros significam: "-d:"=delimitador (indica que será fornecida uma informação para delimitar o resultado), "-f1"=indica que deverá ser mostrado apenas o primeiro campo (field 1).

É claro que este comando todo pode ser armazenado em um shell script ou em uma aliases. Adicionalmente, gostaria de encorajá-lo a modificar o comando acima e personalizá-lo conforme deseje!! Sinta-se à vontade!!

• Entendendo o /etc/group

Analogamente ao /etc/passwd, o /etc/group contém uma linha para cada grupo, onde as informações específicas do grupo são separadas pelo caracter ":" (dois pontos). Exemplo de trecho do arquivo:

video:x:44:paje,fulano,beltrano
1 :2: 3 :4

1- Nome do grupo;

2- Senha do grupo. Analogamente ao /etc/passwd, a senha é substituída pelo caracter "x" para ser armazenada em local seguro. Em muitos sistemas, a administração de grupos é feita exclusiva e diretamente pelo root, sem necessidades de senhas para os grupos.

3- GID (Group ID);

4- Lista de usuários que estão associados a este grupo, separados por vírgulas. Esta lista pode estar vazia, indicando que não há usuários associados ao grupo.


Bom, pessoal, espero que este artigo tenha ajudado... lembrem-se de que, aconteça o que acontecer, o mais importante é que COMENTEM!!

Verificando as Dependências (Bibliotecas) de um Programa

Quando instalamos um programa no Linux através de repositórios (usando o apt-get, yum, ou outro gerenciador qualquer), não nos damos conta da gama de operações que estes gerenciadores fazem para garantir a integridade do programa, ou seja, garantir que seja instalado o programa correto, com a compilação para a sua arquitetura, que seja a versão mais nova apontada e que faça instalar, concomitantemente, todas as dependências deste programa. É simplesmente uma maravilha não nos preocuparmos com isto!
Contudo, algumas vezes somos forçados a baixar aplicativos que não estão no repositório... daí toda esta magestosa praticidade cai por terra... como verificar se o programa que você acabou de baixar vai rodar?? Como saber se você realmente tem instaladas, em sua máquina, todas as bibliotecas, nas versões corretas, de que ele precisa?? Como achar e instalar as bibliotecas que estão faltando?? Se você se encontra perdido entre estas cruéis indagações, então neste artigo lhe apresentaremos duas soluções interessantes que vão dar uma luz a sua vida!!

• Usando o comando ldd

É possível que em sua máquina já exista instalado este comando. Ele é muito simples: basta que se digite "ldd [arquivo]", e você terá a lista de todas as dependências do arquivo informado. Lembre-se de que o arquivo deve ser um binário executável, e não um script de texto, como muitos programas em Shell Script ou Python (caso seu programa seja em Python, a própria máquina virtual vai informar o trace do programa, mostrando as bibliotecas de import que não foram encontradas). Exemplo do ldd:

ldd /opt/eclipse/eclipse
linux-gate.so.1 => (0x00310000)
libpthread.so.0 => /lib/tls/i686/cmov/libpthread.so.0 (0x0061e000)
libdl.so.2 => /lib/tls/i686/cmov/libdl.so.2 (0x0020c000)
libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0x00311000)
/lib/ld-linux.so.2 (0x00a99000)

Veja que são informadas as bibliotecas e o caminho onde elas devem estar!! Se você quiser obter ainda mais detalhes, utilize o parâmetro "-v". Desta forma, você poderá descobrir não só as dependências do arquivo, como também as dependências das dependências, tornando bem fácil a instalação e resolução de grande parte dos problemas. Exemplo:

ldd -v /opt/eclipse/eclipse
linux-gate.so.1 => (0x0069d000)
libpthread.so.0 => /lib/tls/i686/cmov/libpthread.so.0 (0x009e7000)
libdl.so.2 => /lib/tls/i686/cmov/libdl.so.2 (0x00f0c000)
libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0x00a50000)
/lib/ld-linux.so.2 (0x00f31000)

Version information:
/opt/eclipse/eclipse:
libpthread.so.0 (GLIBC_2.0) => /lib/tls/i686/cmov/libpthread.so.0
libdl.so.2 (GLIBC_2.1) => /lib/tls/i686/cmov/libdl.so.2
libdl.so.2 (GLIBC_2.0) => /lib/tls/i686/cmov/libdl.so.2
libc.so.6 (GLIBC_2.3) => /lib/tls/i686/cmov/libc.so.6
libc.so.6 (GLIBC_2.1) => /lib/tls/i686/cmov/libc.so.6
libc.so.6 (GLIBC_2.0) => /lib/tls/i686/cmov/libc.so.6
/lib/tls/i686/cmov/libpthread.so.0:
ld-linux.so.2 (GLIBC_2.3) => /lib/ld-linux.so.2
ld-linux.so.2 (GLIBC_2.1) => /lib/ld-linux.so.2
ld-linux.so.2 (GLIBC_PRIVATE) => /lib/ld-linux.so.2
libc.so.6 (GLIBC_2.1.3) => /lib/tls/i686/cmov/libc.so.6
libc.so.6 (GLIBC_2.1) => /lib/tls/i686/cmov/libc.so.6
libc.so.6 (GLIBC_2.3.2) => /lib/tls/i686/cmov/libc.so.6
libc.so.6 (GLIBC_2.2) => /lib/tls/i686/cmov/libc.so.6
libc.so.6 (GLIBC_PRIVATE) => /lib/tls/i686/cmov/libc.so.6
libc.so.6 (GLIBC_2.0) => /lib/tls/i686/cmov/libc.so.6
/lib/tls/i686/cmov/libdl.so.2:
ld-linux.so.2 (GLIBC_PRIVATE) => /lib/ld-linux.so.2
libc.so.6 (GLIBC_2.1.3) => /lib/tls/i686/cmov/libc.so.6
libc.so.6 (GLIBC_2.1) => /lib/tls/i686/cmov/libc.so.6
libc.so.6 (GLIBC_2.0) => /lib/tls/i686/cmov/libc.so.6
libc.so.6 (GLIBC_PRIVATE) => /lib/tls/i686/cmov/libc.so.6
/lib/tls/i686/cmov/libc.so.6:
ld-linux.so.2 (GLIBC_PRIVATE) => /lib/ld-linux.so.2
ld-linux.so.2 (GLIBC_2.3) => /lib/ld-linux.so.2
ld-linux.so.2 (GLIBC_2.1) => /lib/ld-linux.so.2

Mais opções e alguma ajuda podem ser obtidas com o help:

man ldd
ou: ldd --help

• Usando o comando getlibs

O comando getlibs dá um passo a frente do ldd! Com ele, não só você conseguirá verificar se existem bibliotecas faltando para seu programa rodar, como também poderá baixar e instalar automaticamente as bibliotecas omissas. De fato, um programinha de ouro para qualquer usuário, desde um administrador de sistemas até o usuário doméstico!!
Provavelmente o getlibs não estará instalado em seu sistema, e talvez não exista no repositório. No entanto, ele poderá ser baixado gratuitamente do site:

http://frozenfox.freehostia.com/cappy/

Se seu sistema é baseado em Debian, baixe o arquivo .deb e instale com o seguinte comando (como superusuário!!):

dpkg -i getlibs-all.deb

Agora é só verificar as dependências:

getlibs /opt/eclipse/eclipse
This application isn't missing any dependencies

A mensagem acima indica que não há dependências faltando. Caso haja, o getlibs vai indicar quais sejam elas e tentar baixá-las e instalá-las para você.
Mais detalhes sobre as opções e parâmetros do getlibs podem ser encontradas neste link.
Aí está: outro programa extremamente útil, que pode lhe salvar dos últimos desesperos da alta madrugada, quando nada mais parecer ter vida...

Bom, claro, muito mais importante do que tudo isso: COMENTEM!!!!

Testando a Placa de Vídeo no Linux com mesa-utils

Então imagine: você acabou de instalar a sua nova distribuição Linux, ou a nova versão dela, e quer saber se o driver de vídeo está rodando, ou seja, se a sua placa aceleradora de vídeo funciona perfeitamente. Ou então: você acaba de trocar ou comprar uma placa de vídeo nova e quer saber se o driver está rodando direitinho... mais ainda: você acabou de instalar o driver da placa de vídeo e quer confirmar se ele está funcionando. Outro cenário: instalei o Kubuntu, mas os efeitos gráficos não estão funcionando; quero testar a placa de vídeo.
Tudo te leva a uma mesma pergunta: como testar, de forma rápida, a performance do vídeo no Linux??

• Usando o glxgears

Existe um programa simples e rápido para tanto!! Ele é denominado glxgears e nem sempre vem com a sua distribuição. Não se preocupe: ele pode ser instalado com o conjunto de aplicativos gráficos do pacote mesa-utils. Se sua distribuição é baseada em Debian, instale, como root:

apt-get update
apt-get install mesa-utils

Agora simplesmente abra um terminal (Terminal ou Konsole) e digite:

glxgears

Se tudo estiver certinho com sua placa de vídeo, driver e configurações do X, então deve aparecer uma janela do X com três simpáticas engrenagens rodando ativamente. Deixe o terminal aberto. A cada 5 segundos, haverá uma saída de texto no terminal indicando o desempenho gráfico de sua placa (quantidade de frames per second - fps - ou: quadros por segundo).
Veja o exemplo na imagem abaixo...

• Obtendo Informações sobre a Placa de Vídeo

Se o seu caso é obter informações mais detalhadas (bem mais avançadas!) e técnicas sobre a placa de vídeo e todos os módulos e bibliotecas que o driver de vídeo está rodando, pormenorizadamente, então este pacote acima vai te ajudar com outro programa simples e útil. Digite no terminal, após instalar o pacote mesa-utils:

glxinfo

Surgirá uma saída de texto enorme, contendo diversas informações sobre seu dispositivo de vídeo, o driver que está rodando e todos os detalhes concernentes. Apenas um pequeno trecho do mesmo (clique para ampliar):

• Testando Eventos de Janela

Outra ferramenta presente neste pacote e que pode ser particularmente útil para programadores, como desenvolvedores de jogos, é o programa glxdemo. Ele abre uma pequena janela com um quadrado amarelo centralizado, ocupando grande parte da janela. A cada pixel que o usuário mova ou redimensione as bordas da janela, é gerado um evento que o glxdemo captura e acusa numa saída de texto. Para usá-lo, abra-o no terminal e tente mover ou redimensionar a janela:

glxdemo

Vide o exemplo:

• O Teste Final: Testando Múltiplas Conexões com GLX

Similar ao glxgears, existe o glxheads, porém este testa múltiplas conexões com o GLX. O resultado é uma janela com um triângulo rodando, sendo recalculado e redesenhado, com uma simpática saída de texto indicando lindamente o nome de sua placa de vídeo e algumas informações básicas sobre a mesma. Basta digitar, no terminal:

glxheads

Vide o exemplo (clique para aumentar, como todos os outros):




Bom, pessoal... espero ter ajudado em alguma coisa!! O objetivo deste artigo foi contribuir tanto para usuários com problemas de configuração de placas de vídeo quanto para programadores interessados em explorar o máximo delas. Conforme todos os outros artigos, se você gostou, detestou, salvou sua vida ou acabou de vez com ela: COMENTE!!!
E até a próxima!!

Várias Maneiras de Matar uma Aplicação

A verdade é a seguinte: embora o Kernel do Linux seja a coisa mais estável do mundo (impressionantemente estável como poucas coisas na vida!!), as aplicações que nós rodamos muitas vezes não têm esta mesma propriedade (nem tempo de desenvolvimento, já que o Kernel é de fato bem velhinho...). Assim, acontece o inesperado: as aplicações travam!! E a gente tem que pedir ao Kernel que as "mate", ou seja, interrompa os seus processos, nem que seja bruscamente, e recupere (às vezes chamado "reivindique") a memória usada por elas. Não preciso nem dizer que, o que quer que estes programas estejam fazendo, vai para o espaço, e, uma vez tendo a memória que ocupam ao rodarem reivindicada, eles viram meras vagas lembranças...
Bom, este é o cenário deste artigo: como matar um programa no Linux?? As instruções servem tanto para programas rodando normalmente quanto para aqueles que travaram e não respondem. Qualquer programa pode ser matado porque quem mata é o Kernel, e com o Kernel ninguém pode (lembrem-se de que estamos falando de sistemas de verdade, e não de sistemas com falhas de proteção entre as camadas básicas, como o Windows e alguns sistemas embarcados muito simples...)

• Matando Bruscamente

Matar bruscamente um programa é a última coisa que fazemos, recurso somente utilizado quando nada mais é possível e o programa não responde mais. A maneira mais simples é digitar o comando kill. Este comando precisa do argumento referente ao PID (identificador do processo) do programa e do tipo de sinal a ser enviado. Para achar o PID de seu programa, veja o número da primeira coluna deste comando:

ps -e

(a opção "-e" exige que se mostrem todos os processos).
Em geral isto exibe uma lista enorme. Então, se você sabe qual programa matar, resuma a saída com o comando grep (exemplo, vamos matar o kedit):

ps -e | grep kedit
20128 pts/0 00:00:00 kedit

Viu?? Apenas uma linha, que informa que o PID do kedit é 20128. Felizmente, só temos uma instância do kedit rodando. Agora vamos matar esse camarada (coitado, aqui ele tava rodando direitinho, mas foi eleito como bode expiatório deste tutorial... a vida nem sempre é justa...):

kill -9 20128

Isto mata exatamente aquela instância. Se houver mais de uma instância do kedit, elas terão identificadores diferentes (PIDs diferentes) e você conseguirá matar apenas a instância que você quer. Não se esqueça de usar o "-9", pois esta opção indica ao Kernel que realmente mate o programa, ou seja, que envie o sinal denominado "SIGKILL" para o processo.
Peraí!! O que é esse negócio de sinal?? É a maneira como o Kernel elenca os estados dos processos, e sabe o que fazer com cada um. Existem diversos estados, apesar de quase nunca precisarmos pensar nisso... mas o Kernel precisa controlar os sinais para que seus componentes saibam como tratar o processo. Por isso, o comando kill, apesar do nome, nunca mata realmente o processo, mas apenas solicita ao Kernel que troque o estado daquele programa, ou seja, que envie um determinado sinal para ele, o referente à sua morte, seu letal fim...
Quer saber quantos sinais existem?? Digite:

kill -l
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL
5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE
9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2
13) SIGPIPE 14) SIGALRM 15) SIGTERM 16) SIGSTKFLT
17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU
25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH
29) SIGIO 30) SIGPWR 31) SIGSYS 34) SIGRTMIN
35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3 38) SIGRTMIN+4
39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12
47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14
51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10
55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-6
59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX

Sua lista de sinais vai ser parecida com esta acima... Ainda bem que o Kernel gerencia isto tudo sozinho...

• Matando Graficamente

ProcessTable: o gerenciador de processos do KDE.

Se você usa o KDE, então existe uma maneira de matar graficamente um aplicativo!! Aperte CTRL + ESC. Isto abrirá o ProcessTable, o gerenciador de processos gráfico do KDE. Identifique o nosso bode expiatório (kedit) na tabela, clique nele e aperte o botão "matar".
O ProcessTable faz o mesmo que o comando kill, porém de forma gráfica. Se essa for a sua preferência e se houver interface gráfica rodando, o procedimento pode ser feito tranqüilamente desta maneira sem nenhuma perda de eficiência.

• Quem Pode Matar??

Todos os usuário podem matar seus processos, ou seja, não precisa ser root para matar um processo. No entanto, um usuário sem preferências de administrador não pode matar o processo do outro. Apenas o root (ou alguém com privilégios como tal) pode matar qualquer processo da máquina, porque, afinal de contas, o root é o root...

• Matando Suavemente Um Serviço

Muitos programas, como deamons e serviços, têm toda uma rotina de clean-up (descarrego e limpeza) que é executada ao ser descarregado. Normalmente estas rotinas ficam em scripts e mesmo os scripts de shutdown do sistema (desligamento) estão encadeados em ordem, de forma que um só pode ser executado ao final da conclusão de outro. Para permitir uma morte mais limpa a estes programas especiais e evitar que, por algum motivo (e isto já vi várias vezes!!), o desligamento da máquina páre bruscamente no meio do procedimento, caindo num terminal em modo texto, esperando a conclusão de um processo que pendurou e nunca vai terminar, é possível fazer uma morte suave, mais tranqüila, que não interrompe o descarrego do serviço (e do sistema, conseqüentemente).
Vamos supor que o KDM tenha travado durante o desligamento do sistema. Assim, precisamos matá-lo. Porém, o seu processo implica em scripts que, se forem interrompidos bruscamente, como o foram, paralizam o desligamento, caindo num terminal em modo texto. Então, matamos o KDM desta maneira:

ps -e | grep kdm
2882 ? 00:00:00 kdm
kill -HUP 2882

A opção "-HUP" concede ao KDM uma morte suave, talvez até com opção de realizar o último desejo...

• Matando de uma vez Todas as Instâncias de uma Aplicação

Se você tem várias instâncias de uma aplicação e quer matar todas elas, ou mesmo se só tem uma instância, mas não quer se preocupar em buscar o PID da mesma, basta usar o comando killall. Vamos ao exemplo, matando nosso pobre kedit:

killall kedit

Dessa, nenhum kedit que o referido usuário esteja rodando escapa...
CUIDADO: se você digitar um comando como este usando privilégios de root, você vai matar todas as instâncias de todos os usuários do referido programa, o que pode causar problemas sérios, especialmente se estiver no contexto de um servidor...

• Resumindo...

Existem várias maneiras de se matar aplicativos no Linux. A notícia boa é que, por mais que as aplicações travem, o sistema é estável, permitindo-se recuperar o controle. Usar um método ou outro depende de sua situação: um usuário doméstico, rodando sobre interface gráfica, tenderá a considerar cômodo o ProcessTable. Um administrador de sistemas, logado remotamente e preocupado com os serviços que precisa manter no ar, vai mergulhar nas opções dos comandos kill e ps. Em suma: a gama de opções nos dá ferramentas para o uso mais apropriado em diversas situações.

Gostou deste tutorial?? Ajudou em alguma coisa?? Detestou completamente???? Então: COMENTE!!!!!!

Sincronizando Pen-Drive com o Comando diff

A invenção do pen-drive é fabulosa: portátil, fácil, leve! Porém, é também um perigo para quem pretende usá-lo como backup e não tem muita organização para manter seus dados sincronizados. Uma má sincronia entre os dados que você tem no pen-drive e os dados dos HDs das máquinas que você acessa pode facilmente te levar ao descuido de sobrescerver uma versão nova de um ou mais arquivos por uma versão antiga do mesmo.
Pensando neste problema, este artigo mostra como a sincronia pode ser facilmente verificada com um único comando: o comando diff.

• Verificando a Sincronia dos Dados

Primeiramente, é preciso montar o pen-drive. Isto pode ser feito com o comando mount, embora, hoje em dia, qualquer um que use uma distro do Linux minimamente atualizada e com interface gráfica pode montar facilmente o pen-drive com poucos cliques.
Supondo que a pasta cuja sincronia deva ser verificada se chame "dados", basta digitar, no terminal:

diff -r /media/KINGSTON/dados /home/usuario/dados

Note que:
/media/KINGSTON - deve ser substituído pelo caminho que corresponde ao seu pen-drive montado.
/home/usuario - deve ser substituído pelo caminho onde se localiza a versão da pasta no HD (ou em outro local).
-r - instrui o comando diff a verificar recursivamente, ou seja, em todos os diretórios e subdiretórios que ele encontrar.

• Trocando em Miúdos

O comando diff faz dois tipos de comparação: binária e textual. Quando arquivos em modo texto puro (ou no máximo Unicode) existem, ele compara todo o conteúdo reportando, na tela, todos os conflitos entre um e outro. Quando se trata de arquivos binários, o diff faz uma leitura binária de cada arquivo e, havendo um bit diferente, ele reporta (embora, neste caso, não possa indicar em que lugar do arquivo houve o conflito).
Somente são reportados problemas (conflitos) entre as pastas. Assim, tudo que é idêntico não será indicado (quer dizer que, se não há saída, é porque as pastas têm exatamente o mesmo conteúdo). Note que o comando diff também acusa se algum arquivo existir somente em uma das pastas.
Havendo colhido o relatório do comando diff, agora entre em seu gerenciador de arquivos favorito (Koqueror, etc...) e copie os arquivos conforme desejar, atentando apenas aos que foram reportados no relatório.

Bom, essa dica foi rápida... qualquer coisa: COMENTEM!!! E vamos parar de perder arquivos no pen-drive por descuido!!

Aprimorando o Auto-Completar do Terminal (Tecla TAB do Linux)

Como sabemos, no Linux, UNIX, BSD (e qualquer sistema decente), o terminal em modo texto não é bobo: ele é capaz de auto-completar os comandos (geralmente digitando-se o início dos comandos e teclando-se a tecla TAB para que apareçam as sugestões e para que elas sejam utilizadas). Assim, o uso do terminal fica realmente fácil, rápido e prático: você digita apenas o início do nome de todos os comandos, pastas e arquivos, aperta TAB e pronto!! Tá lá o comando todinho magicamente!!
Acontece que (e talvez você não saiba disso!!) o teminal pode muito mais!! Ele pode aprender a auto-completar inclusive os parâmetros de comandos conhecidos, como o apt-get, por exemplo. Normalmente, em muitas distribuições estas opções vêem desligadas por padrão. Aqui aprenderemos a religá-las de maneira fácil e indolor.

• Habilitando o Auto-Completar Interativo do Terminal
  

Antes de mais nada: é preciso ser root (Administrador) para executar os passos a seguir. Localize e edite o arquivo /etc/bash.bashrc:

vi /etc/bash.bashrc

Localize as linhas responsáveis pelo auto-complemento dos comandos e retire os sinais de comentários (as tralhas ou "joguinhos-da-velha" - "#"), para que elas possam ser executadas:

Está assim:
# enable bash completion in interactive shells
#if [ -f /etc/bash_completion ]; then
# . /etc/bash_completion
#fi

Fica assim:
# enable bash completion in interactive shells
if [ -f /etc/bash_completion ]; then
. /etc/bash_completion
fi

(Somente a primeira linha permanecerá comentada, porque é realmente um comentário e não um trecho válido de programa)

É preciso que o arquivo /etc/bash_completion exista e não esteja vazio (não se preocupe, dificilmente ele não existirá, a menos que tenha sido retirado pelo administrador).

• O Que Isso Faz??

Em poucas palavras: Quando você executa o Terminal ("Terminal", no Gnome; "Konsole", no KDE; ou mesmo o terminal em modo texto), o shell (/etc/bash) roda e abre uma seção para você. Este programinha é simples e eficiente, e faz várias coisas no curtíssimo espaço de tempo em que carrega, como: carregar as variáveis de ambiente, aliases, além de diversas personalizações que você pode ter a nível de usuário. Uma destas tarefas é ler e executar o script /etc/bash.bashrc. Nas linhas que modificamos, nós estamos indicando que o script deve executar um segundo script, encontrado em /etc/bash_completion. Este script é um programa enorme, com vários scripts próprios, e carrega todos os principais casos de auto-complemento interativo (inteligente).
Felizmente, está tudo pronto, basta você habitilitá-lo com o procedimento simples acima. Claro, se você é um programador de Shell Script que adora desafios, sinta-se livre para modificar estes scripts e torná-los ainda melhores!! Neste caso, não se esqueça de voltar aqui e nos avisar as maravilhas que fez!!!

Boa sorte, pessoal!!

Gerenciando Grupos e Usuários Linux

No Linux, como em todo o sistema UNIX-like, os usuário são registrados em grupos. Cada usuário tem pelo menos um grupo ao qual está associado. Se só estiver associado a um grupo, este será seu grupo principal (geralmente é um grupo com o mesmo nome do usuário), denominado Primary Group (grupo primário). Porém, um usuário pode estar associado a vários grupos (embora apenas um deles seja o seu grupo principal). Vejamos como manipulá-los...

• Verificando os Grupos do Usuário

Basta digitar o comando "groups", ou "groups usuario". No primeiro caso, será mostrada a lista de grupos do usuário que digitou o comando. No segundo, a lista referente ao usuário especificado. Qualquer usuário do sistema pode inspecionar os grupos de qualquer outro, mesmo os do root!! Experimente!!

• Adicionando um Grupo Linux
  

Em algumas situações, desejamos criar um grupo novo e adicionar usuários a este grupo. Para criar um grupo novo, digite (somente como root):

addgroup nomegrupo

Isto criará um grupo novo com o nome especificado, porém sem usuários vinculados a este grupo.

• Adicionando um Grupo a um Usuário Existente

Se você acabou de criar seu grupo novo e quer colocar usuários associados a ele, mas os usuários já existem, basta digitar:

usermod -a -G nomegrupoexistente nomeusuarioexistente

Isto vincula um usuário existente a um grupo existente ao qual ainda não pertença. Claro que não remove os vínculos do referido usuário a outros grupos a que porventura ele esteja associado.

• Adicionando um Novo Usuário a um Grupo Já Existente

Beleza, agora vamos fazer o contrário: criar um novo usuário, porém definindo seu grupo primário (principal) como um grupo que já exista:

useradd -g grupoexistente usuarionovo

Note que o grupo especificado (grupoexistente) já deve existir previamente!! O novo usuário (usuarionovo) terá vínculo a apenas um grupo, o referido no comando, que será seu grupo primário.

• Simplesmente Criando um Usuário Novo

Bem semelhante ao comando acima, se o comando digitado fosse:

useradd usuarionovo

Seriam criados ambos um usuário novo com o nome especificado e um grupo novo com o mesmo nome, sendo automaticamente o usuário novo vinculado unicamente ao grupo de mesmo nome, que lhe será seu grupo primário.

Bom, espero que estas dicas ajudem!! Resolveu seus problemas?? Atrapalhou tudo?? Então, claro, COMENTEM!!

Como Trocar o Nome do Servidor

Trocar o nome do servidor é uma coisa simples, porém pode ser capciosa de se fazer em modo texto. Basicamente, existem dois caminhos, ambos devendo ser realizados pelo superusuário (root):

hostname novonome

Este comando acima troca o nome do servidor (hostname), porém de forma não permanente, ou seja, esta troca será perdida se o servidor for reiniciado. Serve para testes ou para alguma troca temporária, sem afetar as configurações da máquina. Para verificar a troca de nome, basta usar o mesmo comando (hostname), sem argumentos.
Caso seja requerida a troca permanente do nome do servidor, basta editar os seguintes arquivos:

vi /etc/hostname
vi /etc/hosts

O /etc/hostname é um arquivos que deve conter apenas uma linha, com uma palavra, que é o nome do host. Não use espaços ou nomes que não serão reconhecidos numa rede TCP!! Em muitos casos, basta editar este arquivo, reiniciar a máquina, e estará tudo resolvido!!
O /etc/hosts é um arquivo com diversas informações de roteamentos e redirecionamentos de rede. Geralmente encontramos nele tabelas de nomes e IPs e algumas instruções para o IPv6 resolver tranqüilamente. Caso o /etc/hosts contenha, em algum lugar, o nome antigo, este deve também ser substituído pelo nome novo.

Beleza: dica rápida, fácil e segura!! Boa sorte e, claro, COMENTEM!!!

Abrindo Arquivos 7z e 7za do 7-Zip, ARJ, CAB, CPIO e outros no Linux

Há algum tempo, um projeto open source ganhou muita popularidade: o 7-Zip (sevenzip). Este programa, criado para Windows e com uma interface parecida com a do WinZip e do WinRAR, deu na verdade um passo a frente: não se limitando a ser apenas mais uma interface para compactadores de arquivos, criou o seu próprio formato de compactação, o 7z (e suas variantes). O fato notável é que este formato tem hoje a maior taxa de compactação, maior mesmo que a do formato RAR, e chegando a ser 30% a 50% melhor que o formato ZIP. Seus filtros conseguem até comprimir arquivos JPG, ainda que com uma pequena taxa de compressão!!
Assim, surgiram muitos arquivos com a extensão 7z, valendo-se do benefício da altíssima compactação do 7-Zip. Porém, o programa roda em Windows... e para descompactar estes arquivos no Linux?? Claro que existe uma maneira!! E a solução é a seguinte:

• Instalando o 7-Zip no Linux
  

Existe uma versão do compactador para Linux, que pode ser instalada a partir do repositório padrão. Para sistemas baseados em Debian, como o Ubuntu, basta digitar:

apt-get update
apt-get install p7zip p7zip-full

O novo programa funciona com o comando p7zip, que suporta os formatos 7z, ZIP, CAB, ARJ, GZIP, BZIP2, TAR, CPIO, RPM e DEB.

• Comprimindo e Descomprimindo Arquivos 7z, ARJ, CAB, etc.
  

Uma vez instalado o programa, você não precisa digitar nada na linha de comando para abrir um arquivo 7z!!! Basta abrí-lo utilizando o Ark ou o addon do Ark para o Konqueror (lembrando que o Ark é apenas uma interface, um frontend, e que entende uma série de compactadores diferentes que são acionados por baixo dos panos).

• Compactando e Descompactando com o p7zip
  

Tudo bem: você é chato, ou é um administrador de sistemas atrás de um terminado remoto, e precisa usar a linha de comando... não se preocupe!! Ainda assim, é fácil comprimir e descomprimir arquivos, com os comandos:

p7zip [nome do arquivo]: comprime o arquivo no formato 7z, apagando o arquivo original e ficando com a cópia comprimida de nome [nome do arquivo].7z.

p7zip -d [nome do arquivo].7z: descomprime o arquivo no formato 7z, apagando o arquivo comprimido e retornando o arquivo original, de nome [nome do arquivo].


Bom, espero ter ajudado!! E, claro, COMENTEM!!!!

Limpando Virus de Partições Windows com ClamAV

Imagine os seguintes cenários:

1- Você tem uma máquina com 2 partições, uma Windows e outra Linux. Forçado a usar o horripilante Windows, você pega um virus... e agora, o que fazer??
2- Seu amigo te liga desesperado: a máquina Windows dele pegou um virus e agora está funcionando muito mal... e agora, o que fazer??

Não se desespere!! O linux tem uma solução para isso: um anti-virus eficiente, fácil de usar, gratuito e leve chamado ClamAV. O ClamAV foi desenvolvido para servidores e é capaz de verificar partições inteiras, arquivos de rede, arquivos anexados em e-mail antes de serem entregues, dentre outras funcionalidades. Claro que o Linux não pega virus, mas o Windows pega, e, muitas vezes, o ClamAV pode salvar a sua pátria!! Mas minha máquina não é um servidor!! Calma... o ClamAV é flexível o suficiente para funcionar bem em máquinas simples e até laptops!!

• Solução do Problema
  

Para o cenário 1, você tem que entrar na partição Linux, que vai estar intacta, e instalar o ClamAV. Para o cenário 2, você pode dar um boot com o DVD do Ubuntu (ou qualquer outra distro que inicie pelo CD, DVD ou pendrive), que vai carregar o Linux na memória sem alterar o HD (todo tomado de Windows e viri), e instalar o ClamAV. Note que, mesmo se a máquina não possui Linux, é possível dar um jeito!!

• Instalando o ClamAV

É simples e depende de sua distribuição. Na maioria das vezes, ele existe no repositório e pode ser instalado com seu programa de instalação normal ou um gerenciador de pacotes, como o Synaptic. Em distribuições baseadas em Debian, como o Ubuntu, basta digitar, como root:

apt-get update
apt-get install clamav

Pronto!! Tudo instalado!!

• Atualizando o Banco de Dados

Pode não ser necessário, mas geralmente você tem que buscar os dados mais brilhantemente novos de viri que o pessoal do ClamAV conseguiu identificar e disponibilizar. Quem atualiza estes dados é uma ferramenta chamada freshclam. Para atualizar, basta simplesmente digitar o nome da ferramenta, como root:

freshclam
ClamAV update process started at Wed Jan 27 09:45:08 2010
main.cld is up to date (version: 51, sigs: 545035, f-level: 42, builder: sven)
daily.cld is up to date (version: 10335, sigs: 158617, f-level: 44, builder: guitar)

Note que, como o ClamAV é feito para servidor, provavelmente, ao instalar, ele colocou o freshclam como um serviço. Se isso aconteceu, a atualização será feita automaticamente, sem você sequer perceber. Para verificar se ele entrou como serviço, basta digitar:

ps -e | grep fresh
2573 ? 00:00:00 freshclam

Viu?? Tá ele lá, no PID 2573, rodando!! Mas, como eu sei que ele está mesmo baixando atualizações?? Bom, você não precisa ser chato a este ponto, mas tem como descobrir, lendo o arquivo de configuração do freshclam e procurando a linha que informa quantas verificações ele deve fazer por dia (que deve ser limitada a um número de 1 a 50)... O arquivo pode estar no /etc/freshclam.conf ou no /etc/clamav/freshclam.conf, dependendo de sua distribuição. Vamos fazer isso??

cat /etc/clamav/freshclam.conf | grep Checks
Checks 24

Beleza!! O camarada verifica 24 vezes por dia se há atualizações!! É exatamente uma verificação a cada hora. Para minha máquina, isto está muito bom, mas você pode colocar o valor que quiser. Lembre-se de que, mudando o arquivo de configuração, é preciso reiniciar o serviço (como root!!), para que ele leia a nova configuração:

/etc/init.d/clamav-freshclam restart
Stopping ClamAV virus database updater: freshclam.
Starting ClamAV virus database updater: freshclam.

Claro que tudo isso pode ser feito também com as opções de linha de comando do freshclam... sinta-se à vontade!!

• Finalmente, Limpando o virus!!

É preciso que seu sistema Linux tenha acesso à partição Windows... então, você pode montá-la manualmente, com o comando "mount", ou deixar que o sistema a monte sozinho. Dependendo do seu Kernel e da sua distro, a montagem automática pode acontecer ou não. Suponhamos que sua partição infectada esteja em /mnt/hda1. Para limpar a famigerada, basta digitar, como root:

clamscan -r --remove=yes /mnt/hda1

Bom, o que isso faz??
1- clamscan é o comando do clamav que verifica um arquivo ou diretório contra viri conhecidos.
2- a opção "-r" significa que a verificação deve ser executada recursivamente, ou seja, em todos os diretórios, arquivos, e em cada subdiretório e seus arquivos, até o último nível. Ideal para verificar realmente TUDO da partição!! Vai demorar bastante, mas vale a pena!!
3- --remove=yes instrui que, achando um arquivo infectado, ele deve ser apagado. É preciso digitar isto porque, por padrão, o clamscan gera apenas um relatório mas não mexe em nada. Como a gente quer expurgar mesmo o virus, então vamos mandar apagar logo tudo que está infectado.

Enquanto ele verifica, você pode continuar usando o sistema normalmente. No terminal, o clamscan vai imprimir um por um os arquivos verificados e, ao final, vai gerar um relatório completo sobre o que foi feito.
Bom, espero ter ajudado!! Boa sorte e, claro, use Linux!! Não terá mais problemas com virus novamente!! Ah, e o mais importante de tudo: COMENTE!!! :-)