<chapt id="kern">Kernel e Módulos
 <p>
Este capítulo descreve em detalhes o que é o kernel, módulos, 
sua configuração e programas relacionados. 


<sect id="kern-kernel">O Kernel
 <p>
É a peça central do sistema operacional (o <prgn>Linux</prgn>), é ele 
que controla os dispositivos e demais periféricos do sistema (como memória, 
placas de som, vídeo, discos rígidos, disquetes, sistemas de arquivos, 
redes e outros recursos disponíveis). Muitos confundem isto e 
chamam a distribuição de sistema operacional. Isto é errado!  
<![ %DESCRICAOD [ 
 <p>
O <em>kernel</em> faz o controle dos periféricos do sistema e 
para isto ele deve ter o seu suporte incluído. Para fazer uma placa de 
som <em>Sound Blaster</em> funcionar, por exemplo, é necessário que o 
kernel ofereça suporte a este placa e você deve configurar seus 
parâmetros (como interrupção, I/O e DMA) com comandos específicos 
para ativar a placa e faze-la funcionar corretamente. 
Existe um documento que contém quais são os periféricos suportados/
não suportados pelo <prgn>GNU/Linux</prgn>, ele se chama <tt>Hardware-HOWTO</tt>. 
 <p>
Suas versões são identificadas por números como 2.2.30, 2.4.33, 2.6.23.6, 
as versões que contém um número par entre o primeiro e segundo 
ponto são versões estáveis e que contém números ímpares neste mesmo 
local são versões instáveis (em desenvolvimento). Usar versões instáveis 
não quer dizer que ocorrerá travamentos ou coisas do tipo, mas algumas 
partes do kernel podem não estar testadas o suficiente ou alguns 
controladores podem ainda estar incompletos para obter pleno funcionamento. 
Se opera sua máquina em um ambiente crítico, prefira pegar versões estáveis 
do kernel. ]]> 
 <p>
Após inicializar o sistema, o kernel e seus arquivos podem ser acessados ou 
modificados através do ponto de montagem <file>/proc</file>. Para detalhes 
veja <ref id="disc-proc">. 
 <p>
Caso você tenha um dispositivo (como uma placa de som) que tem suporte no 
<prgn>GNU/Linux</prgn> mas não funciona veja <ref id="kern-suporte">. 


<sect id="kern-modulos">Módulos
 <p>
São partes do kernel que são carregadas somente quando são solicitadas 
por algum aplicativo ou dispositivo e descarregadas da memória quando 
não são mais usadas. Este recurso é útil por 2 motivos: Evita a construção 
de um kernel grande (estático) que ocupe grande parte da memória com 
todos os drivers compilados e permite que partes do kernel ocupem a 
memória somente quando forem necessários. 
<![ %DESCRICAOD [ 
 <p>
Os módulos do kernel estão localizados no diretório 
<file>/lib/modules/versão_do_kernel/*</file> (onde <tt>versão_do_kernel</tt> 
é a versão atual do kernel em seu sistema, caso seja <tt>2.6.23.6</tt> o 
diretório que contém seus módulos será <file>/lib/modules/2.6.23.6</file>. ]]>
 <p>
Os módulos são carregados automaticamente quando solicitados através do 
programa <prgn>kmod</prgn> ou manualmente através do arquivo 
<![ %DEBIAN [ <file>/etc/modules</file> ]]>, <prgn>insmod</prgn> ou 
<prgn>modprobe</prgn>. 
<![ %OBS [
Atenção: Não compile o suporte ao seu sistema de arquivos raíz como módulo, 
isto o tornará inacessível, a não ser que esteja usando initrd. ]]>


<sect id="kern-suporte">Como adicionar suporte a Hardwares e outros 
dispositivos no kernel
 <p>
Quando seu hardware não funciona mas você tem certeza que é 
suportado pelo <prgn>GNU/Linux</prgn>, é preciso seguir alguns passos 
para faze-lo funcionar corretamente: 
<list>
 <item>
Verifique se o kernel atual foi compilado com suporte ao seu dispositivo. 
Também é possível que o suporte ao dispositivo esteja compilado como módulo. 
Dê o comando <tt>dmesg</tt> para ver as mensagens do kernel durante a 
inicialização e verifique se aparece alguma coisa referente ao 
dispositivo que deseja instalar (alguma mensagem de erro, etc). Caso 
não aparecer nada é possível que o driver esteja compilado como módulo, 
para verificar isto entre no diretório 
<file>/lib/modules/versao_do_kernel</file> e veja se encontra o módulo 
correspondente ao seu dispositivo (o módulo da placa <em>NE 2000</em> 
tem o nome de <file>ne.ko</file> e o da placa <em>Sound Blaster</em> 
de <file>sb.ko</file>, por exemplo).  
<![ %OBS [
 <p>
<em>OBS:</em> Nos kernel 2.4 e anteriores, a extensão dos módulos era
<file>.o</file>.
]]>
<p>
Caso o kernel não tiver o suporte ao seu dispositivo, você precisará 
recompilar seu kernel ativando seu suporte. Veja 
<ref id="kern-recompilando">. 

 <item>
Caso seu hardware esteja compilado no kernel, verifique se o módulo 
correspondente está carregado (com o comando <prgn>lsmod</prgn>). 
Caso não estiver, carregue-o com o <prgn>modprobe</prgn>
(por exemplo, <tt>modprobe sb io=0x220 irq=5 dma=1 dma16=5 
mpuio=0x330</tt>), para detalhes veja <ref id="kern-modprobe">. 
 <p>
O uso deste comando deverá ativar seu hardware imediatamente, neste 
caso configure o módulo para ser carregado automaticamente 
através do programa <![ %DEBIAN [ <prgn>modconf</prgn> ]]> 
ou edite os arquivos relacionados com os módulos 
(veja <ref id="kern-arquivos">). 
Caso não tenha sucesso, será retornada uma mensagem de erro. 
</list>


<sect id="kern-kmod">kmod
 <p>
Este é o programa usado para carregar os módulos automaticamente quando 
são requeridos pelo sistema. Ele é um daemon que funciona constantemente 
fazendo a monitoração, quando verifica que algum dispositivo ou programa 
está solicitando o suporte a algum dispositivo, ele carrega o módulo 
correspondente. 
 <p>
Ele pode ser desativado através da recompilação do kernel, 
dando um <prgn>kill</prgn> no processo ou através do 
arquivo <file>/etc/modules</file> (veja <ref id="kern-arquivos-modules">. 
Caso seja desativado, é preciso carregar manualmente os módulos através do 
<prgn>modprobe</prgn> ou <prgn>insmod</prgn>. 


<sect id="kern-lsmod">lsmod
 <p>
Lista quais módulos estão carregados atualmente pelo kernel. O nome 
<tt>lsmod</tt> é uma contração de <tt>ls</tt>+<tt>módulos</tt> - 
Listar Módulos. A listagem feita pelo <prgn>lsmod</prgn> é uma 
alternativa ao uso do comando <tt>cat /proc/modules</tt>. 
 <p>
A saída deste comando tem a seguinte forma:
<example>
Module            Size  Pages    Used by
nls_iso8859_1     8000      1          1 (autoclean)
nls_cp437         3744      1          1 (autoclean)
ne                6156      2          1
8390              8390      2     [ne] 0
</example>
A coluna <em>Module</em> indica o nome do módulo que está carregado, a 
coluna <em>Used</em> mostra qual módulos está usando aquele recurso. O 
parâmetro <em>(autoclean)</em> no final da coluna indica que o módulo 
foi carregado manualmente (pelo <prgn>insmod</prgn> ou <prgn>modprobe</prgn>) 
ou através do <prgn>kmod</prgn> e será automaticamente removido da memória 
quando não for mais usado. 
 <p>
No exemplo acima os módulos <em>ne</em> e <em>8390</em> não tem 
o parâmetro <em>(autoclean)</em> porque foram carregados pelo 
arquivo <file>/etc/modules</file> (veja <ref id="kern-arquivos-modules">). 
Isto significa que não serão removidos da memória caso estiverem sem uso. 
 <p>
Qualquer módulo carregado pode ser removido manualmente através do 
comandos <prgn>rmmod</prgn>. 


<sect id="kern-insmod">insmod
 <p>
Carrega um módulo manualmente. Para carregar módulos que dependem de outros 
módulos para que funcionem, você duas opções: Carregar os módulos manualmente 
ou usar o <prgn>modprobe</prgn> que verifica e carrega as dependências 
correspondentes. 
 <p>
A sintaxe do comando é: <tt>insmod [<em>módulo</em>] [<em>opções_módulo</em>]
</tt>
 <p>
Onde:
<taglist compact>
 <tag>módulo</tag>
 <item>
É o nome do módulo que será carregado.
 
 <tag>opções_módulo</tag>
 <item>
Opções que serão usadas pelo módulo. Variam de módulo para módulo, alguns 
precisam de opções outros não, tente primeiro carregar sem opções, caso seja 
mostrada uma mensagem de erro verifique as opções usadas por ele. Para 
detalhes sobre que opções são suportadas por cada módulo, veja a sua 
documentação no código fonte do kernel em <file>/usr/src/linux/Documentation
</file> 
</taglist>
<![ %EXEMPLO [
 <p>
Exemplo: <tt>insmod ne io=0x300 irq=10</tt> ]]>


<sect id="kern-rmmod">rmmod
 <p>
Remove módulos carregados no kernel. Para ver os nomes dos módulos 
atualmente carregados no kernel digite <tt>lsmod</tt> e verifique 
na primeira coluna o nome do módulo. Caso um módulo tenha dependências 
e você tentar remover suas dependências, uma mensagem de erro será 
mostrada alertando que o módulo está em uso. 
<![ %EXEMPLO [ 
 <p>
Exemplo: <tt>rmmod ne</tt> ]]>


<sect id="kern-modprobe">modprobe
 <p>
Carrega um módulo e suas dependências manualmente. Este comando permite 
carregar diversos módulos e dependências de uma só vez. O comportamento 
do <prgn>modprobe</prgn> é modificado pelo arquivo 
<![ %DEBIAN [ <file>/etc/modules.conf</file> ]]>. 
 <p>
A sintaxe deste comando é: <tt>modprobe [<em>módulo</em>] 
[<em>opções_módulo</em>]
</tt>
 <p>
Onde:
<taglist compact>
 <tag>módulo</tag>
 <item>
É o nome do módulo que será carregado.
 
 <tag>opções_módulo</tag>
 <item>
Opções que serão usadas pelo módulo. Variam de módulo para módulo, alguns 
precisam de opções outros não, tente primeiro carregar sem opções, caso seja 
mostrada uma mensagem de erro verifique as opções usadas por ele. Para 
detalhes sobre que opções são suportadas por cada módulo, veja a sua 
documentação no código fonte do kernel em <file>/usr/src/linux/Documentation
</file> 
</taglist>
<![ %OBS [
 <p>
Nem todos os módulos são carregados corretamente pelo <prgn>modprobe</prgn>, o 
<file>plip</file>, por exemplo, mostra uma mensagem sobre porta I/O inválida 
mas não caso seja carregado pelo <prgn>insmod</prgn>. 
]]>
<![ %EXEMPLO [
 <p>
Exemplo: <tt>modprobe ne io=0x300 irq=10</tt>, 
<tt>modprobe sb io=0x220 irq=5 dma=1 dma16=5 mpuio=0x330</tt> ]]>


<sect id="kern-depmod">depmod
 <p>
Verifica a dependência de módulos. As dependências dos módulos são 
verificadas pelos scripts em <file>/etc/init.d</file> usando o 
comando <tt>depmod -a</tt> e o resultado gravado no arquivo 
<file>/lib/modules/versao_do_kernel/modules.dep</file>. Esta checagem 
serve para que todas as dependências de módulos estejam corretamente 
disponíveis na inicialização do sistema. O comportamento do 
<prgn>depmod</prgn> pode ser modificado através do arquivo 
<![ %DEBIAN [ <file>/etc/modules.conf</file> ]]>. 
É possível criar a dependência de módulos imediatamente após a 
compilação do kernel digitando 
<tt>depmod -a [<em>versão_do_kernel</em>]</tt>. 
<![ %EXEMPLO [
 <p>
Exemplo: <tt>depmod -a</tt> ]]>


    <![ %DEBIAN [
<sect id="kern-modconf">modconf
 <p>
Este programa permite um meio mais fácil de configurar a ativação de 
módulos e opções através de uma interface através de menus. Selecione 
a categoria de módulos através das setas acima e abaixo e pressione 
enter para selecionar os módulos existentes. Serão pedidas as opções 
do módulo (como DMA, IRQ, I/O) para que sua inicialização seja possível, 
estes parâmetros são específicos de cada módulo e devem ser vistos na 
documentação do código fonte do kernel no diretório 
<file>/usr/src/linux/Documentation</file>. Note que também existem 
módulos com auto-detecção mas isto deixa o sistema um pouco mais lento, 
porque ele fará uma varredura na faixa de endereços especificados pelo 
módulo para achar o dispositivo. As opções são desnecessárias em 
alguns tipos de módulos. 
 <p>
As modificações feitas por este programa são gravadas no diretório 
<file>/etc/modutils</file> em arquivos separados como 
<file>/etc/modutils/alias</file> - alias de módulos, 
<file>/etc/modutils/modconf</file> - opções usadas por módulos, 
<file>/etc/modutils/paths</file> - Caminho onde os módulos do sistema 
são encontrados. 
Dentro de <file>/etc/modutils</file> é ainda encontrado um sub-diretório 
chamado <file>arch</file> que contém opções específicas por arquiteturas. 
 <p>
A sincronização dos arquivos gerados pelo <prgn>modconf</prgn> com o 
<file>/etc/modules.conf</file> é feita através do utilitário 
<prgn>update-modules</prgn>. Ele é normalmente executado após modificações 
nos módulos feitas pelo <prgn>modconf</prgn>. 

    ]]>


<sect id="kern-recompilando">Recompilando o Kernel
 <p>
Será que vou precisar recompilar o meu kernel? você deve estar se 
perguntando agora. Abaixo alguns motivos para esclarecer suas 
dúvidas: 
<list>
 <item>
Melhora o desempenho do kernel. O kernel padrão que acompanha as distribuições 
<prgn>GNU/Linux</prgn> foi feito para funcionar em qualquer tipo de sistema e 
garantir seu funcionamento e inclui suporte a praticamente tudo. Isto pode 
gerar desde instabilidade até uma grade pausa do kernel na inicialização 
quando estiver procurando pelos dispositivos que simplesmente não existem 
em seu computador! 
 <p>
A compilação permite escolher somente o suporte aos dispositivos existentes em 
seu computador e assim diminuir o tamanho do kernel, desocupar a memória 
RAM com dispositivos que nunca usará e assim você terá um desempenho bem 
melhor do que teria com um kernel pesado. 
 
 <item>
Incluir suporte a alguns hardwares que estão desativados no kernel padrão 
(SMP, APM, ACPI, Virtualização, Firewall, Bridge, memory cards, 
drivers experimentais, etc).

 <item>
Se aventurar em compilar um kernel (sistema operacional) personalizado em 
seu sistema. 

 <item>
Tornar seu sistema mais seguro

 <item>
Impressionar os seus amigos, tentando coisas novas. 
</list>
Serão necessários uns 300Mb de espaço em disco disponível para copiar 
e descompactar o código fonte do kernel e alguns pacotes de 
desenvolvimento como o <prgn>gcc</prgn>, <prgn>cpp</prgn>, 
<prgn>binutils</prgn>, <prgn>gcc-i386-gnu</prgn>, <prgn>bin86</prgn>, 
<prgn>make</prgn>, <prgn>dpkg-dev</prgn>, <prgn>perl</prgn>, 
<prgn>kernel-package</prgn> (os três últimos somente para a distribuição 
<prgn>Debian</prgn>). 
<![ %DEBIAN [
 <p>
Na distribuição <prgn>Debian</prgn>, o melhor método é através 
do <prgn>kernel-package</prgn> que faz tudo para você 
(menos escolher o que terá o não o suporte no kernel) e gera um 
pacote <prgn>.deb</prgn> que poderá ser usado para instalar o kernel 
em seu sistema ou em qualquer outro que execute a <prgn>Debian</prgn> 
ou distribuições baseadas (<prgn>Ubuntu</prgn>, etc). Devido a sua 
facilidade, a compilação do kernel através do <file>kernel-package</file> 
é muito recomendado para usuários iniciantes e para aqueles que usam 
somente um kernel no sistema (é possível usar mais de dois ao mesmo tempo, 
veja o processo de compilação manual adiante neste capítulo). Siga este 
passos para recompilar seu kernel através do <file>kernel-package</file>: 
<enumlist>
 <item>
Descompacte o código fonte do kernel (através do arquivo linux-2.6.XX.XX.tar.bz2) 
para o diretório <file>/usr/src</file>. Caso use os pacotes da 
<prgn>Debian</prgn> eles terão o nome de <file>kernel-source-2.6.XX.XX</file>, 
para detalhes de como instalar um pacote, veja <ref id="dpkg-instalar">. 
 <item>
Após isto, entre no diretório onde o código fonte do kernel foi instalado 
com <tt>cd /usr/src/linux</tt> (este será assumido o lugar onde o código 
fonte do kernel se encontra). 
 <item>
Como usuário <tt>root</tt>, digite <tt>make config</tt>. Você também pode 
usar <tt>make menuconfig</tt> (configuração através de menus) ou 
<tt>make xconfig</tt> (configuração em modo gráfico) mas precisará de 
pacotes adicionais para que estes dois funcionem corretamente. 
 <p>
Serão feitas perguntas sobre se deseja suporte a tal dispositivo, etc. 
Pressione <tt>Y</tt> para incluir o suporte diretamente no kernel, 
<tt>M</tt> para incluir o suporte como módulo ou <tt>N</tt> para não 
incluir o suporte. Note que nem todos os drivers podem ser compilados 
como módulos. 
 <p>
Escolha as opções que se encaixam em seu sistema. se estiver em dúvida 
sobre a pergunta digite <tt>?</tt> e tecle Enter para ter uma explicação 
sobre o que aquela opção faz. Se não souber do que se trata, recomendo 
incluir a opção (pressionando <tt>Y</tt> ou <tt>M</tt>. Este passo pode 
levar entre 5 minutos e 1 Hora (usuários que estão fazendo isto pela 
primeira vez tendem a levar mais tempo lendo e conhecendo os recursos 
que o <prgn>GNU/Linux</prgn> possui, antes de tomar qualquer decisão). Não 
se preocupe se esquecer de incluir o suporte a alguma coisa, você pode 
repetir o passo <tt>make config</tt> (todas as suas escolhas são gravadas 
no arquivo <file>.config</file>), recompilar o kernel e instalar em 
cima do antigo a qualquer hora que quiser. 
 <item>
Após o <tt>make config</tt> chegar ao final, digite <tt>make-kpkg clean</tt> 
para limpar construções anteriores do kernel. 
 <item>
Agora compile o kernel digitando <tt>make-kpkg --revision=teste.1.0 
kernel-image</tt>. A palavra <tt>teste</tt> pode ser substituída por qualquer 
outra que você quiser e número da versão <tt>1.0</tt> serve apenas como 
controle de suas compilações (pode ser qualquer número). 
<![ %OBS [
 <p>
Observação: Não inclua hífens (<tt>-</tt>) no parâmetro --revision, use 
somente pontos. ]]>
 <item>
Agora após compilar, o kernel será gravado no diretório superior (..) com 
um nome do tipo <tt>linux-image-2.6.23.6-i386_teste.1.0.deb</tt>. 
Basta você digitar <tt>dpkg -i kernel-image-2.6.23.6-i386_teste.1.0.deb
</tt> e o <prgn>dpkg</prgn> fará o resto da instalação do kernel para você 
e perguntará se deseja criar um disquete de inicialização (recomendável). 
 <item>
Reinicie seu computador, seu novo kernel iniciará e você já 
perceberá a primeira diferença pela velocidade que o <prgn>GNU/Linux</prgn> 
é iniciado (você inclui somente suporte a dispositivos em seu sistema). 
O desempenho dos programas também melhorará pois cortou o suporte a 
dispositivos/funções que seu computador não precisa. 
 <p>
Caso alguma coisa sair errada, coloque o disquete que gravou no passo 
anterior e reinicie o computador para fazer as correções. 
</enumlist> 
]]>

 <p>
Para recompilar o kernel usando o método manual, siga os seguintes 
passos:
<enumlist compact>
 <item>
Descompacte o código fonte do kernel (através do arquivo linux-2.6.XX.XX.tar.bz2) 
para o diretório <file>/usr/src</file>. O código fonte do kernel 
pode ser encontrado em <url id="&url-kernel-ftp;">. 
 <item>
Após isto, entre no diretório onde o código fonte do kernel foi instalado 
com <tt>cd /usr/src/linux</tt> (este será assumido o lugar onde o código 
fonte do kernel se encontra). 
 <item>
Como usuário <tt>root</tt>, digite <tt>make config</tt>. Você também pode 
usar <tt>make menuconfig</tt> (configuração através de menus) ou 
<tt>make xconfig</tt> (configuração em modo gráfico) mas precisará de 
pacotes adicionais. 
 <p>
Serão feitas perguntas sobre se deseja suporte a tal dispositivo, etc. 
Pressione <tt>Y</tt> para incluir o suporte diretamente no kernel, 
<tt>M</tt> para incluir o suporte como módulo ou <tt>N</tt> para não 
incluir o suporte. Note que nem todos os drivers podem ser compilados 
como módulos. 
 <p>
Escolha as opções que se encaixam em seu sistema. se estiver em dúvida 
sobre a pergunta digite <tt>?</tt> e tecle Enter para ter uma explicação 
sobre o que aquela opção faz. Se não souber do que se trata, recomendo 
incluir a opção (pressionando <tt>Y</tt> ou <tt>M</tt>. Este passo pode 
levar entre 5 minutos e 1 Hora (usuários que estão fazendo isto pela 
primeira vez tendem a levar mais tempo lendo e conhecendo os recursos 
que o <prgn>GNU/Linux</prgn> possui antes de tomar qualquer decisão). Não 
se preocupe se esquecer de incluir o suporte a alguma coisa, você pode 
repetir o passo <tt>make config</tt>, recompilar o kernel e instalar em 
cima do antigo a qualquer hora que quiser. 
 <item>
Caso esteja compilando um kernel 2.4 ou inferior, Digite o comando <tt>make dep</tt> 
para verificar as dependências dos módulos. Se estiver compilando um kernel 2.6 ou 
superior, pule esse comando.
 <item>
Digite o comando <tt>make clean</tt> para limpar construções anteriores 
do kernel. 
 <item>
Digite o comando <tt>make</tt> para iniciar a compilação do 
kernel e seus módulos. Aguarde a compilação, o tempo pode variar 
dependendo da quantidade de recursos que adicionou ao kernel, a velocidade 
de seu computador e a quantidade de memória RAM disponível. 
 <p>
Caso tenha acrescentado muitos ítens no Kernel, é possível que o comando 
<tt>make zImage</tt> falhe no final (especialmente se o tamanho do kernel 
estático for maior que 505Kb). Neste caso use <tt>make bzImage</tt>. A 
diferença entre <em>zImage</em> e <em>bzImage</em> é que o primeiro 
possui um limite de tamanho porque é descompactado na memória básica 
(recomendado para alguns Notebooks), já a <em>bzImage</em>, é descompactada 
na memória estendida e não possui as limitações da <em>zImage</em>. 
 <item>
A compilação neste ponto está completa, você agora tem duas opções para 
instalar o kernel: Substituir o kernel anterior pelo recém compilado ou 
usar os dois. A segunda questão é recomendável se você não tem certeza 
se o kernel funcionará corretamente e deseja iniciar pelo antigo no 
caso de alguma coisa dar errado.
 <p>
Se você optar por substituir o kernel anterior:
<enumlist compact> 
 <item>
É recomendável renomear o diretório <file>/lib/modules/versão_do_kernel</file> 
para <file>/lib/modules/versão_do_kernel.old</file>, isto será útil para 
restauração completa dos módulos antigos caso alguma coisa der errado.
 <item>
Execute o comando <tt>make modules_install</tt> para instalar os módulos 
do kernel recém compilado em <file>/lib/modules/versão_do_kernel</file>. 
 <item>
Copie o arquivo <file>zImage</file> que contém o kernel de 
<file>/usr/src/linux/arch/i386/boot/zImage</file> para 
<file>/boot/vmlinuz-2.XX.XX</file> (<em>2.XX.XX</em> é a versão do kernel
anterior) 
 <item>
Verifique se o link simbólico <file>/vmlinuz</file> aponta para a versão 
do kernel que compilou atualmente (com <tt>ls -la /</tt>). Caso contrário, 
apague o arquivo <file>/vmlinuz</file> do diretório raíz e crie um novo 
link com <tt>ln -s /boot/vmlinuz-2.XX.Xx /vmlinuz</tt> apontando para o 
kernel correto. 
 <item>
Execute o comando <tt>lilo</tt> para gerar um novo setor de partida no 
disco rígido. Para detalhes veja <ref id="boot-lilo">. 
 <item>
Reinicie o sistema (<tt>shutdown -r now</tt>). 
 <item>
Caso tudo esteja funcionando normalmente, apague o diretório antigo 
de módulos que salvou e o kernel antigo de <file>/boot</file>. Caso 
algo tenha dado errado e seu sistema não inicializa, inicie a partir de 
um disquete, apague o novo kernel, apague os novos módulos, renomeie o 
diretório de módulos antigos para o nome original, ajuste o link 
simbólico <file>/vmlinuz</file> para apontar para o antigo kernel e 
execute o <tt>lilo</tt>. Após reiniciar seu computador voltará como 
estava antes. 
</enumlist>
 <p>
Se você optar por manter o kernel anterior e selecionar qual será usado 
na partida do sistema (útil para um kernel em testes): 
<enumlist>
 <item>
Execute o comando <tt>make modules_install</tt> para instalar os módulos 
recém compilados do kernel em <file>/lib/modules/versao_do_kernel</file>. 
 <item>
Copie o arquivo <file>zImage</file> que contém o kernel de 
<file>/usr/src/linux/arch/i386/boot/zImage</file> para 
<file>/boot/vmlinuz-2.XX.XX</file> (<em>2.XX.XX</em> é a versão do 
kernel anterior) 
 <item>
Crie um link simbólico no diretório raíz (<file>/</file>) apontando para o 
novo kernel. Como exemplos será usado <file>/vmlinuz-novo</file>.
 <item>
Modifique o arquivo <![ %DEBIAN [ <file>/etc/lilo.conf</file> ]]> para 
incluir a nova imagem de kernel. Por exemplo:
<example>
Antes da modificação:

boot=/dev/hda
prompt
timeout=200
delay=200
map=/boot/map
install=menu

image = /vmlinuz
  root = /dev/hda1
  label = 1
  read-only

Depois da modificação:

boot=/dev/hda
prompt
timeout=200
delay=200
map=/boot/map
install=menu

image = /vmlinuz
  root = /dev/hda1
  label = 1
  read-only

image = /vmlinuz-new
  root = /dev/hda1
  label = 2
  read-only
</example> 
Se você digitar <tt>1</tt> no aviso de <tt>boot:</tt> do <prgn>Lilo</prgn>, o 
kernel antigo será carregado, caso digitar <tt>2</tt> o novo kernel será 
carregado. Para detalhes veja <ref id="boot-lilo-cfg"> e 
<ref id="boot-lilo-exemplo">. 
 <item>
Execute o comando <tt>lilo</tt> para gravar o novo setor de boot para o 
disco rígido. 
 <item>
Reinicie o computador
 <item>
Carregue o novo kernel escolhendo a opção <tt>2</tt> no aviso 
de <tt>boot:</tt> do <prgn>Lilo</prgn>. Caso tiver problemas, 
escolha a opção <tt>1</tt> para iniciar com o kernel antigo e verifique 
os passos de configuração (o arquivo <![ %DEBIAN [ <file>lilo.conf</file> ]]> 
foi modificado corretamente?. 
</enumlist>

</enumlist>

Em alguns casos (como nos kernels empacotados em distribuições 
<prgn>GNU/Linux</prgn>) o código fonte do kernel é gravado em 
um diretório chamado <file>kernel-source-xx.xx.xx</file>. É 
recomendável fazer um link com um diretório <file>GNU/Linux</file>, 
pois é o padrão usado pelas atualização do código fonte através 
de patches (veja <ref id="kern-patches">). 
 <p>
Para criar o link simbólico, entre em <file>/usr/src</file> e digite: 
<tt>ln -s kernel-source-xx.xx.xx linux</tt>. 
 <p>
Se quiser mais detalhes sobre a compilação do kernel, consulte o 
documento <em>kernel-howto</em>. 


<sect id="kern-arquivos">Arquivos relacionados com o Kernel e Módulos
 <p>
Esta seção descreve os arquivos usados pelo kernel e módulos, a 
função de cada um no sistema, a sintaxe, etc.


<sect1 id="kern-arquivos-modules">/etc/modules
 <p>
A função deste arquivo é carregar módulos especificados na inicialização 
do sistema e mantê-los carregado todo o tempo. É útil para módulos de 
placas de rede que precisam ser carregados antes da configuração de rede 
feita pela distribuição e não podem ser removidos quando a placa de rede 
estiver sem uso (isto retiraria seu computador da rede). 
 <p>
Seu conteúdo é uma lista de módulos (um por linha) que serão carregados 
na inicialização do sistema. Os módulos carregados pelo arquivo 
<file>/etc/modules</file> pode ser listados usando o comando 
<prgn>lsmod</prgn> (veja <ref id="kern-lsmod">. 
 <p>
Se o parâmetro <tt>auto</tt> estiver especificado como um módulo, o 
<prgn>kmod</prgn> será ativado e carregará os módulos somente em demanda, 
caso seja especificado <tt>noauto</tt> o programa <prgn>kmod</prgn> será 
desativado. O <prgn>kmod</prgn> é ativado por padrão nos níveis de 
execução 2 ao 5. 
 <p>
Ele pode ser editado em qualquer editor de textos comum ou modificado 
automaticamente através do utilitário 
<![ %DEBIAN [ <prgn>modconf</prgn>. ]]> 


<sect1 id="kern-arquivos-modulesconf">modules.conf
 <p>
O arquivo <![ %DEBIAN [ <file>/etc/modules.conf</file> ]]> permite 
controlar as opções de todos os módulos do sistema. Ele é consultado 
pelos programas <prgn>modprobe</prgn> e <prgn>depmod</prgn>. As 
opções especificadas neste arquivo facilita o gerenciamento de 
módulos, evitando a digitação de opções através da linha de comando. 
<![ %DEBIAN [
 <![ %OBS [  
 <p>
Note que é recomendado o uso do utilitário <prgn>modconf</prgn> para 
configurar quaisquer módulos em seu sistema e o utilitário 
<prgn>update-modules</prgn> para sincronização dos arquivos 
gerados pelo <prgn>modconf</prgn> em <file>/etc/modutils</file> com 
o <file>/etc/modules.conf</file> (geralmente isto é feito automaticamente 
após o uso do <prgn>modconf</prgn>). Por este motivo não é recomendável 
modifica-lo manualmente, a não ser que seja um usuário experiente e 
saiba o que está fazendo. Veja <ref id="kern-modconf"> ]]> ]]>
<![ %EXEMPLO [ 
 <p>
Por exemplo: adicionando as linhas:
<example>
alias sound sb 
options sb io=0x220 irq=5 dma=1 dma16=5 mpuio=0x330 
</example>
permitirá que seja usado somente o comando <tt>modprobe sb</tt> para 
ativar a placa de som. 
]]> 


<sect id="kern-patches">Aplicando Patches no kernel
 <p>
<em>Patches</em> são modificações geradas pelo programa <prgn>diff</prgn> 
em que servem para atualizar um programa ou texto. 
<![ %DESCRICAOD [ Este recurso é muito útil para os desenvolvedores, 
pois podem gerar um arquivo contendo as diferenças entre um programa 
antigo e um novo (usando o comando <prgn>diff</prgn>) e enviar o arquivo 
contendo as diferenças para outras pessoas. 
 <p>
As pessoas interessadas em atualizar o programa antigo, podem 
simplesmente pegar o arquivo contendo as diferenças e atualizar 
o programa usando o <prgn>patch</prgn>. ]]>
 <p>
Isto é muito usado no desenvolvimento do kernel do <prgn>GNU/Linux</prgn> 
em que novas versões são lançadas freqüentemente e o tamanho kernel 
completo compactado ocupa cerca de 18MB. Você pode atualizar seu kernel 
pegando um patch seguinte a versão que possui em 
<url id="&url-kernel-ftp;">. 
 <p>
Para aplicar um patch que atualizará seu kernel 2.6.23 para a versão 
2.6.24 você deve proceder da seguinte forma:
<list compact>
 <item>
Descompacte o código fonte do kernel 2.6.23 em <file>/usr/src/linux</file> 
ou certifique-se que existe um link simbólico do código fonte do 
kernel para <file>/usr/src/linux</file>. 
 <item>
Copie o arquivo <file>patch-2.6.24.gz</file> de <url id="&url-kernel-ftp;"> 
para <file>/usr/src</file>.
 <item>
Use o comando <tt>gzip -dc patch-2.6.24|patch -p0 -N -E</tt> para 
atualizar o código fonte em <file>/usr/src/linux</file> para a 
versão 2.6.24.
 <p>
Alternativamente você pode primeiro descompactar o arquivo 
<file>patch-2.6.24.gz</file> com o <prgn>gzip</prgn> e usar o 
comando <tt>patch -p0 -N -E &lt;patch-2.6.24</tt> para atualizar o 
código fonte do kernel. O <prgn>GNU/Linux</prgn> permite que você 
obtenha o mesmo resultado através de diferentes métodos, a 
escolha é somente sua. 
</list>
<![ %OBS [
 <p>
Caso deseja atualizar o kernel 2.6.20 para 2.6.24, como no 
exemplo acima, você deverá aplicar os patches em seqüência 
(do patch 2.6.20 ao 2.6.24). Vale a pena observar se o 
tamanho total dos patches ultrapassa ou chega perto o 
tamanho do kernel completo, pois dependendo da quantidade de 
alterações pode ser mais viável baixar diretamente a nova 
versão. ]]>

 