A grande diferença ente software livre e de código aberto e softwares proprietários é que no caso dos softares livres e abertos podemos obter o código fonte do programa e compilá-lo da maneira que acharmos melhor.

A princípio pensamos que nunca vamos precisar compilar programas e que sempre vamos instalá-los a partir de pacotes binários mas, acredite, muitas vezes é mais interessante e até mesmo necessário compilar o programa, seja pela falta de um pacote binário, para ter a chance de otimizar o programa para necessidades específicas ou simplesmente por curiosidade.

Compilar programas no linux não é trivial mas também não chega a ser difícil. Vou tentar mostrar de maneira simples e explicativa as maneiras mais comuns de compilar programas no linux.

O primeiro passo é obter o código fonte do programa. Geralmente ele é encontrado no site do desenvolvedor, mas muitos projetos são hospedados em sites como o freshmeat.net e sourceforge.net. Uma busca no Google Linux também pode ajudar bastante.

A maioria dos programas para linux são escritos na linguagem C ou C++ e consistem de vários arquivos dispostos em diversos diretórios, por isso eles são encontrados comumente na forma de arquivos empacotados e compactados. As extensões mais comuns são .tar.gz e .tar.bz2, que significa empacotado com o tar e compactados com o gzip ou bzip2 respectivamente. O bzip2 tem se tornado mais comum a cada dia, pois resulta em arquivos muito menores.

Vamos usar para efeito de exemplificação um programa fictício chamado ‘meu programa 1.0′. Baixamos este programa nas duas formas de compactação, ou seja, ‘meuprograma-1.0.tar.gz’ e ‘meuprograma-1.0.tar.bz2′.

Vamos agora descompactá-lo:

A forma mais simples de fazer a descompactação é usando o tar com a opção de descompressão -x e indicando o formato gzip (-z) ou bzip2 (j).

[user@host] $ tar zxvf meuprograma-1.0.tar.gz

ou então

[user@host] $ tar jxvf meuprograma-1.0.tar.bz2

Note que não é necessário usar o hífem (-) antes das opções para o tar, use-o se quiser.

A partir daqui não fará nenhuma diferença se você baixou o arquivo .gz ou .bz2.

Descompactado o arquivo é criado um diretório, usualmente com o mesmo nome do arquivo (claro, sem a extensão). No nosso caso ‘meuprograma-1.0′.

Entre nesse diretório

[user@host] $ cd meuprograma-1.0

examine o conteúdo do diretório

[root@host] # ls -la

Provavelmente existem dois arquivos – README e INSTALL – que trazem informações genéricas sobre o pacote e informações sobre a instalação. É altamente recomendada a leitura desses arquivos, mas prepare-se para ler em inglês. Qualquer informação específica do programa que o torne diferente na maneira de instalar vai estar contida nestes arquivos, portanto leia-os

[user@host] $ less README

[user@host] $ less INSTALL

Terminando de ler, vamos agora para a parte interessante: a compilação.

Para compilar programas no linux você vai precisar do compilador C e C++ GCC (geralmente encontrado nas distribuições linux dividido em três pacotes: gcc, cpp e g++), do GNU Make e, algumas vezes do autoconf e automake.

O primeiro passo da compilação geralmente é rodar um script chamado configure. Este script, que é gerado pelo desenvolvedor do programa com o autoconf, examina o seu sistema na busca por bibliotecas e arquivos de configuração e executáveis necessários para a compilação do programa. Se tudo estiver OK ele gera um arquivo chamado Makefile, que será usado posteriormente pelo make. Se alguma dependência não for encontrada ele pára e mostra uma pequena mensagem de erro, indicando o que ocorreu ou qual arquivo estava faltando. Na maioria das vezes o configure executa sem problemas. Para executá-lo faça

[user@host] $ ./configure

O próximo passo é a compilação propriamente dita. Como você pode imaginar, não é necessário compilar um a um os arquivo de código fonte. A compilação é coordenada pelo make, que segue um roteiro definido no Makefile, compilando e gerando os arquivos binários pra você com o uso do gcc.

Para compilar, use

[user@host] $ make

Dependendo do tamanho do programa que você está compilando esse processo pode demorar bastante. Você vai ver muita saída de texto e provavelmente não vai entender nada do que está escrito. Não se preocupe.

Terminada a compila̤̣o Рsem nenhum erro, ̩ claro Р̩ hora de instalar o programa.

Note que até agora usamos um usuário comum (não-root) para executar os comandos. É recomendável que se faça assim. Mas a instalação deve ser feita como root pois ele tem acesso de escrita em qualquer diretório. A não ser que você saiba o que está fazendo, mude para root antes de instalar o programa. Essa mudança de usuário é feita com o comando

[user@host] $ su

Digite a senha de root e o prompt será mudado para

[root@host] #

Agora use

[root@host] # make install

para instalar o programa. Note que a instalação também é feita através do make. O make não serve apenas para compilar programas, serve para otimizar tarefas que seguem passos bem definidos. A instalação, por exemplo, consiste em copiar os arquivos certos nos lugares certos com as permissões adequadas. O roteiro da instalação também é definido no Makefile.

Este roteiro simples, de 3 comandos

[user@host] $ ./configure

[user@host] $ make

[root@host] # make install

é praticamente um padrão e é usado na grande maioria dos programas. Mas pode ser que o seu programa tenha opções e comandos específicos. Para saber esses comandos o jeito é ler os arquivos README e INSTALL ou procurar ajuda em listas de discussão ou canais IRC.

Existem algumas opções comuns que podem ser usadas, principalmente no script ‘configure’. Geralmente é possível listá-las com

[user@host] $ ./configure --help

A mai usadas é –prefix, que diz onde o programa será instalado. Se você quiser que seu programa seja instalado em /usr por exemplo, use

[user@host] $ ./configure --prefix=/usr

Assim os arquivos serão divididos entre diversos diretórios logo abaixo de /usr (por exemplo: binários em /usr/bin).

Alguns programas, na verdade a maioria deles, incluem um atalho para a desinstalação, geralmente

[user@host] $ make uninstall

e um para limpar os arquivos gerados pela compilação anterior

[user@host] $ make clean

Você pode também optar por gerar um pacote binário a partir da sua compilação. Um programa útil para isso é o checkinstall. Falar sobre o checkinstall está fora do escopo deste artigo mas pode ser que em um artigo futuro eu aborde esse tema. Só devo dizer que sua utilização é simples e trivial.

Compilar o kernel do linux é uma tarefa que se aprende com o tempo, depois de várias tentativas. Mas os problemas geralmente se resumem à configuração e nao à compilação. Vou tentar dar umas dicas referentes ? configuração, mas lembre-se que cada maquina usa uma configuração diferente por isso tenha em mãos toda a configuração do seu computador e não desista na primeira tentativa.

Para compilar você vai precisar do gcc (A documentação do kernel recomenda a versão 2.95 do gcc, mas eu tenho compilado com sucesso o kernel com as versões 3.2 e 3.3 e muitas distros fazem isso também, a dica é tentar compilar com a versão mais atual do gcc, se der algum problema compile com a 2.95), do Ncurses (geralmente um pacote chamado libncurses-dev ou Ncurses-devel), do make e do module-init-tools.

Qualquer dúvida sobre os pacotes necessários para compilar o kernel, leia o arquivo /usr/src/linux/Documentation/Changes.

Vou usar como referência o kernel da versão 2.6.4 baixado do kernel.org.

Baixe o source do kernel (clique no ‘F’ ao lado da versão do kernel que você deseja baixar. O ‘F’ significa ‘Full source’). Copie o arquivo baixado para /usr/src:

[root@host] # cp linux-2.6.4.tar.bz2 /usr/src

e decompacte-o:

[root@host] # cd /usr/src

[root@host] # tar jxvf linux-2.6.4.tar.bz2

Para facilitar, crie um link simbólico para o diretório que foi criado chamado ‘linux’. Se já existir, remova e crie novamente:

[root@host] # rm /usr/src/linux

[root@host] # ln -s /usr/src/linux-2.6.4 /usr/src/linux

Como a maioria de nós vai compilar o kernel em desktop, vou usar o patch do Con Kolivas, que otimiza o kernel para operações comuns de desktop. Não é obrigatório, mas eu recomendo que use este patch, pois ele melhora bastante o desempenho.

Baixe o arquivo patch-2.6.4-ck1.bz2 e copie-o também para /usr/src

[root@host] # cp patch-2.6.4-ck1 /usr/src

descompacte-o

[root@host] # bunzip2 patch-2.6.4-ck1.bz2

e aplique o patch no source do seu kernel

[root@host] # cd /usr/src/linux

[root@host] # patch -p1 < ../patch-2.6.4-ck1

Agora vamos ? configuração. Estando em /usr/src/linux, digite

[root@host] # make mrproper

para limpar as configurações e depois

[root@host] # make menuconfig

Existem outras maneiras de configurar o kernel, inclusive em modo gráfico, mas aqui vou me referir apenas ao menuconfig.

Como disse anteriormente, esta parte depende muito da máquina em questão. É necessário que você selecione todas as opções referentes ao seu hardware e os sistemas de arquivo que você usa. No menuconfig um ‘*’ significa que a opção será compilada dentro da imagem do kernel, um ‘M’ significa que será compilado como um módulo externo.

O sistema de arquivos que a sua partição linux usa deve ser marcado como ‘*’, bem como suporte a IDE (ou SCSI se for o caso). O restante das opções podem ser escolhidas como módulo, você escolhe.

Lembre-se que se você selecionar alguma opção como módulo, deve marcar a opção

Loadable Module Support -> Enable loadable module support,

Loadable Module Support -> Module unloading

e

Loadable Module Support -> Automatic kernel module unloading.

Depois publicarei um artigo mostrando com mais detalhes a configuração.

Salve a configuração. Agora vamos compilar.

A compilação dos kernels da versão 2.6 é um pouco diferente da 2.4. Não existe mais o comando make dep e tem alguns outros alvos (make help exibe as opções disponíveis).

Vamos por partes:

A primeira coisa a fazer é criar a imagem ‘bootável’ do kernel:

[root@host] # make bzImage

Este comando pode demorar bastante tempo dependendo da máquina usada. Se a sua máquina for antiga arrume algo pra fazer pois é tedioso ficar assistindo ? compilação.

Após terminado esse comando a imagem do kernel gerada é gravada em /usr/src/linux/arch/i386/boot/bzImage

O próximo passo é compilar os módulos (aquelas opções selecionadas como ‘M’ na configuração). Se você nao selecionou nada como ‘M’ (o que não é comum), pode pular essa parte.

[root@host] # make modules

E agora instale os módulos criados:

[root@host] # make modules_install

Se você não tiver instalado o pacote module-init-tools, vai receber uma mensagem de erro ao final do make modules_install. Se isso acontecer, instale o module-init-tools pois sem ele o kernel 2.6 nao vai funcionar.

Tudo certo até aqui? Parabéns, o seu kernel está compilado. Vamos agora configurar o nosso sistema para poder ‘bootar’ este novo kernel.

Copie os arquivos de imagem, configuração e o System.map para /boot

[root@host] # cp /usr/src/linux/arch/i386/boot/bzImage
/boot/vmlinuz-2.6.4

[root@host] # cp /usr/src/linux/.config /boot/config-2.6.4

[root@host] # cp /usr/src/linux/System.map /boot/System.map-2.6.4

Vamos configurar agora o gerenciador de boot para usar esse novo kernel. É importante que você mantenha a versão antiga do kernel intocada para poder inicializar o linux em caso de erros no kernel novo.

Se você usa o LILO, edite o arquivo /etc/lilo.conf com o seu editor de textos preferido.

Saiba qual a partição onde seu linux está instalado. É algo como /dev/hdax, onde x é um número. Olhe no lilo.conf na parte referente ao outro kernel e use a mesma partição na nova configuração. Vou usar /dev/hda2 como referência:

A configuração ficará assim:

image /boot/vmlinuz-2.6.4
    root=/dev/hda2
    label=Linux-2.6.4
    read-only

Salve o arquivo e execute o comando /sbin/lilo para gravar a nova configuração

[root@host] # /sbin/lilo

Se o seu gerenciador de boot é o GRUB, edite o arquivo /boot/grub/grub.conf ou /boot/grub/menu.lst. Veja qual a partição onde seu linux está instalado. O GRUB usa uma configuração um pouco diferente, do tipo (hdx,y), onde x é a interface IDE e o y é o numero da partição. Neste caso /dev/hda2 = (hd0,1). Vou usar /dev/hda2 como exemplo mas lembre-se de trocar para a partição que você usa.

A entrada no arquivo ficará assim:

title Linux-2.6.4

root (hd0,1)

kernel /boot/vmlinuz-2.6.4 root=/dev/hda2 ro

Salve o arquivo e pronto. O GRUB nao necessita que seja rodado nenhum comando apos a alteração.

Para quem deseja usar o gcc-2.95 para compilar o kernel:

Se vc usa normalmente o gcc versão 3.2 ou 3.3 mas deseja compilar o kernel com o 2.95 seguindo as recomendações da documentação, faça o seguinte:

Instale o gcc-2.95. Vamos assumir que ele seja instalado em /usr/bin/gcc-2.95, substitua pelo local correto da sua instalação.

Para usá-lo para compilar o kernel, basta passar o parametro ‘CC’ para o make, assim:

[root@host] # make CC=/usr/bin/gcc-2.95 bzImage

[root@host] # make CC=/usr/bin/gcc-2.95 modules

[root@host] # make CC=/usr/bin/gcc-2.95 modules_install

Espero ter sido claro na minha explicação.

O artigo vale apenas para as versões 2.4 do kernel do linux, mas como ainda é bastante comum usar essa versão, vale a pena dar uma conferida.
Em breve publicarei um artigo atualizado para a versão 2.6.
Por enquanto confira este artigo e boa compilação!