Compilação do kernel modprobe rmmod Utilização do kernel uname -r.

Transcrição

1 Compilação do kernel O kernel do Linux é o núcleo do sistema operacional, ou seja é o próprio sistema operacional em si, onde faz gerenciamento entre o hardware e os programas utilizados pelo usuário através de linguagens de programação como C, C++, Shell Script e Java. Porém quando você instala o Linux através do CD ou DVD da sua distribuição Linux, o kernel que vem na instalação nem sempre vem incorporado com todos os recursos que o kernel pode oferecer, sendo necessário a sua recompilação para adicionar estes recursos tais como: suporte a novas tecnologias e dispositivos de hardware, melhor performance e personalização do kernel. Através do Kernel do Linux é possível também carregar e descarregar módulos de hardware e software na memória através dos comandos modprobe e rmmod, conforme a necessidade ou arquitetura de hardware utilizada em seu computador. Utilização do kernel Quando o Linux é instalado através do CD ou DVD da sua distribuição Linux (Debian, Ubuntu, Kurumin, Fedora, Red Hat, Mandriva, OpenSuse e etc), ele vem com um kernel pré-compilado onde ele não conhece a arquitetura de hardware do computador que será instalado, então o kernel é compilado de forma padrão e genérica para qualquer arquitetura de hardware. O kernel instalado pelas distribuições Linux às vezes não reconhecendo novos hardwares e novas tecnologias e obtendo a performance e desempenho que deveria ter, sendo necessário assim a recompilação do kernel. O kernel do Linux é atualizado constantemente, sendo às vezes esse o motivo de sua recompilação, seja para corrigir erros (bugs) onde são aplicados patchs de correção ou para incorporar novos recursos.você pode baixar a última versão no site atualmente a última versão disponível é no formato.tar.gz e tar.bz2 para download. Para ver a versão do seu kernel atual em seu computador execute o comando uname -r. 1

2 $ uname -r

3 Para compilar o kernel primeiramente será mostrado os dois tipos de compilação do kernel: kernel monolítico e kernel modular. kernel monolítico (incluídos no kernel) É quando é adicionado todos os drivers de hardware e de softwares dentro do kernel deixando o tamanho do kernel maior. kernel modular (módulos carregados na memória) É quando os drivers de hardware e softwares são gerados como módulos, onde são carregados em memória conforme a necessidade de utiliza-los Um módulo é um programa que o kernel carrega em memória para ser utilizado por algum dispositivo de hardware ou para adicionar um novo recurso no kernel. A vantagem de carregar um módulo é que ele só consume memória RAM e CPU do sistema quando é carregado, e também ele adiciona novos recursos no kernel ou a funcionalidade de um dispositivo sem precisar recompilar o kernel toda vez que for adicionado um novo dispositivo de hardware no sistema. Por exemplo, uma nova placa de rede wireless, uma nova placa de vídeo 3D e etc. Na verdade não é necessário compilar um kernel totalmente monolítico ou modular, o mais comum é gerar um kernel incluindo algum suporte a recursos direto no kernel, e gerar os módulos dos dispositivos de hardware separados para serem carregados quando forem utilizados. O kernel que vem nas distribuições Linux é um kernel padrão que vem com vários módulos para dar suporte a qualquer tipo de hardware, onde na instalação do Linux o kernel é configurado de tal forma a carregar somente os módulos necessários para p hardware do computador. Melhoria do kernel série 2.6 em relação série 2.4 A série atual do kernel 2.6 além de ser mais rápido, trouxe muitas melhorias em relação a sua versão anterior 2.4, dentre elas destacamos melhor suporte a dispositivos USB, suporte a dispositivos wireless, sistema de arquivos (NTFS), novo gerenciador de I/O (Input / Output), suporte a reserva de energia para notebok. Antes da compilação do kernel Para compilar um novo kernel é necessário ter alguns pacotes instalados em seu computador além de estar logado como root e ter em torno de 100 MB de espaço em disco. 3

4 Para compilar o kernel em qualquer distribuição Linux é necessário ter o compilador e as bibliotecas de desenvolvimento instaladas que geralmente são : gcc libc-dev libncurses-dev make automake binutils kernel-headers initrd-tools Pacotes necessários para uma compilação baseada no Debian ou Ubuntu. gcc libc6-dev autoconf libncurses5-dev make automake1.9 binutils linux-kernel-headers initrd-tools module-init-tools kernel-package dpkg-dev Baixando os fontes do kernel Se você quiser obter o apenas personalizar seu kernel, então você pode utilizar o próprio kernel atual que está incluído na sua distribuição Linux que é representado pelo pacote linux-source (Debian e Ubuntu), kernel-devel (Fedora) e kernel-source (outras distribuições Linux) No Debian existe várias versões do pacote kernel-source, portanto você deverá instalar o pacote correspondente ao seu kernel atual, que pode exibi-lo pelo comando uname -r. 4

5 $ uname -r

6 Agora procure pela versão correta correspondente ao seu kernel com o comando apt-cache search # apt-cache search linux-source linux-source Linux kernel source for version with Debian patches Agora instale o pacote linux-source que corresponde ao meu kernel , que na verdade será baixado o arquivo do kernel do linux no formato.tar.bz2 no diretório /usr/src para ser descompactado com o comando tar. 6

7 # apt-get install linux-source

8 Agora se você quer baixar a última versão do kernel no diretório /usr/src, então acesse o site usando seu navegador escolhendo HTTP ou FTP e acesse a última versão da série 2.6 (no meu caso atualmente é ) no formato tar.gz ou tar.bz2 e depois baixe com o comando wget como mostra abaixo. 8

9 # cd /usr/src # wget -cv 9

10 Descompactando os fontes do kernel Após ter baixado os fontes do kernel no diretório /usr/src, descompacte-o com o comando abaixo. 10

11 # cd /usr/src # tar -xvjf linux tar.bz2 11

12 Caso tenha um link simbólico (linux) apontando para o kernel atual ou um kernel antigo, remova-o ou renomei-o e crie um novo link apontando para o novo kernel. # mv linux linux-antigo # ln -s linux linux Configurando o kernel Na configuração do kernel você pode incluir novos recursos a novos dispositivos de hardware e novas tecnologias, suporte a sistema de arquivos, recursos de rede e firewall, personalizar a arquitetura do processador utilizado melhorando muito a performance no sistema e etc. Existem três comandos que podem ser utilizados para configurar o kernel: make config (não recomendado) é uma interface em modo texto, onde é configurado as opções uma por uma tornando o seu uso mais difícil. make menuconfig (recomendado) - é uma interface em modo texto, onde é mais simples e rápido a configuração do que make config. Para seu funcionamento é necessário ter instalado o compilador gcc e a biblioteca de desenvolvimento (gcc, libc6-dev, e libncurses5-dev). 12

13 # apt-get install gcc libc6-dev libncurses5-dev 13

14 make xconfig (recomendado) - é uma interface em modo gráfico baseada em menus, onde sua configuração é mais fácil do que make menuconfig, mas para seu funcionamento é necessário ter instalado o compilador g++ e pacote QT no kernel série 2.6 (g++ qt3-apps-dev qt3-designer qt3-dev-tools qt3-qtconfig libqt3-mt-dev e pkg-config). 14

15 # apt-get install g++ qt3-apps-dev qt3-designer qt3-dev-tools qt3-qtconfig libqt3-mt-dev pkg-config 15

16 make gconfig (recomendado) - é uma interface em modo gráfico baseada em menus mas que usa a biblioteca GTK É recomendado make menuconfig, pois é fácil sua configuração e funciona em modo texto e gráfico e só depende de um pacote para seu funcionamento (libncurses5-dev). No momento de configuração de compilação do kernel com make menuconfig, será necessário você responder algumas opções de compilação para cada módulo dentro da configuração do kernel onde são mostradas abaixo o seu significado. make menuconfig Para navegar pelo menuconfig use as setas direcionais para cima, baixo, direita e esquerda do seu teclado para navegar pelos menus e as opções Select para selecionar opções ou Exit ou ESC para sair. [ * ] (asterístico) diz para compilar dentro do kernel [ m ] diz para compilar como módulo [ ] desativado (diz para não compilar) make xconfig No make xconfig as opções de compilação para cada módulo são as mesmas do make menuconfig onde pode ser OK (compilar dentro do kernel), M (compilar como módulo) e desativado. 16

17 Atenção! Caso você tenha escolhido compilar o kernel incluído na sua distribuição Linux e não a última versão do kernel baixada através do site primeiramente é necessário carregar o arquivo de configuração do kernel atual disponível no diretório /boot que tem como nome a versão do kernel atual (Por exemplo /boot/config ). Carregando o arquivo evitar alguns problemas e erros, pois a configuração será iniciada a partir das configurações atuais do seu kernel em uso e será incluídas apenas as suas alterações. Antes de carregar o arquivo, execute o comando uname -r para ver a versão do seu kernel Para carregar o arquivo de configuração do kernel atual da pasta /boot acesse o menu Load an Alternate Configuration File no make menuconfig ou File > Load no make xconfig e informe o caminho para o arquivo no diretório /boot. Por exemplo no menuconfig será necessário você digitar ou copiar e colar o caminho para o arquivo /boot/config e no xconfig apenas acesse o diretório /boot/ e escolha o arquivo config Dentro da configuração do kernel com make menuconfig ou make xconfig terá varias seções menus de configuração onde você pode personalizar a compilação, onde serão mostradas na tabela abaixo: 17

18 Menu de configuração Code maturity level options General setup Loadable module support Block layer Processor type and features Power management options (ACPI, APM) Bus options (PCI, PCMCIA, EISA, MCA, ISA) Executable file formats Descrição Desenvolvimento e código de drivers incompletos Configurações gerais Suporte a módulos carregaveis Camada de blocos (relacionados a arquivos) Tipos e características de processadores Gerenciamento opções de energia Opções sobre barramentos PCI, ISA, PCMCIA... Suporte a formato de arquivos binários Networking Suporte a rede (BlueTooth, Wifi, IPV6, Qos, IPsec, NetFilter...) Device Drivers File systems Suporte a drivers de dispositivos (porta paralela, USB, rede, som, scsi...) Suporte a sistema de arquivos (ext3, reiserfs,ntfs...) 18

19 Instrumentation Support Kernel hacking Security options Cryptographic options Library routines Load an Alternate Configuration File Save Configuration to an Alternate File Suporte de instrumentação Opções de ferramentas de desenvolvimento do kernel Opções de segurança Opções de criptografia Rotinas de bibliotecas Carrega as configurações de um arquivo de alternativo Salvar configurações em um arquivo alternativo Após selecionar todas as opções de configuração correspondente a seu hardware, selecione as opções Exit e Yes (make menuconfig) ou Save and Exit (make xconfig) no menu principal para salvar. Após as configurações feitas pelos comandos make menuconfig ou manke xconfig, será gerado o arquivo.config usado durante a compilação no diretório /usr/src/linux Compilando o kernel Compilação no Debian O Debian possui um pacote chamado kernel-package que facilita o processo de compilação do kernel, onde não é necessário digitar os comandos de compilação (make clean, make, make modules, make modules_install e make install). O comando make-kpkg do pacote kernel-package gera um arquivo.deb no diretório /usr/src/ que pode ser instalado com o comando dpkg -i e também ser instalado em outros computadores. O processo de é simplificado por dois comandos: make-kpkg clean make-kpkg -initrd kernel_image (este processo demora várias horas dependendo da memória e processador do seu computador) Para executar os comandos abaixo é necessário acessar o diretório dos fontes do kernel em /usr/src/linux onde foi descompactado e criado o link simbólico linux e no final será gerado um arquivo kernel_image com o novo kernel dentro da pasta /usr/src/ que pode ser instalado com o comando dpkg -i kernel_image deb (onde é a versão do kernel). 19

20 # cd /usr/src/linux 20

21 Execute o comando make menuconfig e carregue o arquivo de configuração do kernel atual da pasta /boot acesse o menu Load an Alternate Configuration File no make menuconfig e digite ou copie e cole o caminho para o arquivo /boot/config (que corresponde ao meu kernel atual). 21

22 # make menuconfig 22

23 O arquivo gerado com o comando make-kpkg -initrd kernel_image contém a imagem completa do kernel incluindo os arquivos vmlinuz e initrd, com imagem de pré-carregamento em memória do kernel pelos gerenciadores de boot (Grub e Lilo) localizados no diretório /boot. 23

24 # make-kpkg clean # make-kpkg -initrd kernel_image 24

25 Agora instale o pacote /usr/src/linux-image _ custom_i386.deb 25

26 # dpkg -i /usr/src/linux-image _ custom_i386.deb 26

27 Repare que foram criados os arquivos de configuração e carregamento do sistema config , initrd.img , System.map e vmlinuz no diretório /boot. Além de adicionar as entradas de configuração do novo kernel no gerenciador de boot Grub no arquivo /boot/grub/menu.lst title Debian GNU/Linux, kernel root (hd0,2) kernel /boot/vmlinuz root=/dev/hda3 ro initrd /boot/initrd.img savedefault Pronto agora é só reiniciar o computador e escolher o novo kernel, que neste caso é o kernel e após entrar no sistema execute o comando uname -r e verá a nova versão do kernel com as alterações que você fez. $ uname -r Compilação em qualquer distribuição Linux Para compilar o kernel não se esqueça que é necessário o compilador gcc e os pacotes das bibliotecas de desenvolvimento (libc-dev e libncurses-dev) e depois de configurar as opções do kernel é necessário os seguintes comandos para compilar um kernel série 2.6. make clean (opcional) make make modules make modules_install make install Para executar os comandos abaixo é necessário acessar o diretório dos fontes do kernel em /usr/src/linux, onde foi descompactado e criado o link simbólico linux. 27

28 # cd /usr/src/linux 28

29 Agora execute o comando make menuconfig para fazer as suas alterações e depois 29

30 # make menuconfig 30

31 O comando make clean é opcional, ele limpa configurações de compilações anteriores e removendo módulos desnecessários, em versões anteriores a série 2.6, era necessário digite make dep para verificar dependências do kernel. # make clean O comando make verifica dependências do novo kernel e inicia a compilação # make O comando make modules compila todos os módulos do novo kernel marcados com módulo na configuração do kernel. (este processo demora várias horas dependendo da memória e processador do seu computador). Atenção! Se por acaso ao executar o comando make modules aparecer alguma mensagem de erro como é mostrado abaixo: WARNING: modpost: Found 10 section mismatch(es). To see full details build your kernel with: 'make CONFIG_DEBUG_SECTION_MISMATCH=y' Execute o comando make novamente com a opção que ele mesmo sugere make CONFIG_DEBUG_SECTION_MISMATCH=y e depois execute o comando make modules. # make CONFIG_DEBUG_SECTION_MISMATCH=y # make modules O comando make modules_install finaliza a compilação copiando os módulos compilados marcados com módulo na configuração do kernel para seus respectivos diretórios em /lib/modules/novo-kernel. (onde novo-kernel é a novo kernel instalado) 31

32 # make modules_install Agora instale o kernel com o comando make install onde serão criados os arquivos de configuração e carregamento do sistema config , System.map e vmlinuz no diretório /boot e agora edite o grub editando o arquivo /boot/grub/menu.lst que deverá ser editado posteriormente. # make install Para configurar o Grub é necessário criar um arquivo de imagem initrd usado para fazer o pré-carregamento em memória do kernel e para a criação deste arquivo não esqueça de instalar o pacote initrd-tools. # apt-get install initrd-tools Agora é necessário criar o arquivo initd usado pelo Grub com o comando mkinitrd # cd /boot # mkinitrd -o /boot/initrd.img O comando acima criará o arquivo /boot/initrd.img usando o como referência o novo kernel , onde este arquivo será utilizado pelo gerenciador de boot Grub que veremos agora sua configuração abaixo. A opção root (hd0,2) corresponde ao meu primeiro disco rígido IDE (hda) e 2 corresponde a minha terceira partição /dev/hda3 onde veremos a explicação abaixo sobre o Grub. A opção initrd /boot/initrd.img corresponde ao arquivo de imagem de pré-carregamento do kernel criado acima com comando mkinitrd. title Debian GNU/Linux, kernel root (hd0,2) kernel /boot/vmlinuz root=/dev/hda3 ro initrd /boot/initrd.img savedefault 32

33 Depois de editar o arquivo /boot/grub/menu.lst, salve as configurações e atualize o grub executando o comando update-grub. # update-grub Ao executar o comando update-grub será adicionado outras entradas referentes ao novo kernel, mas com o nome do kernel errado e sem especificar o nome do arquivo de imagem initrd. title Debian GNU/Linux, kernel Default root (hd0,2) kernel /boot/vmlinuz root=/dev/hda3 ro savedefault title Debian GNU/Linux, kernel Default (single-user mode) root (hd0,2) kernel /boot/vmlinuz root=/dev/hda3 ro single savedefault Portanto você pode apagar as entradas ou corrigir o nome do kernel que vem como /boot/vmlinuz para o nome correto /boot/vmlinuz , e adicione a linha referente ao arquivo de imagem initrd. initrd /boot/initrd.img Pronto agora é só reiniciar o computador e escolher o novo kernel, que neste caso é o kernel e após entrar no sistema execute o comando uname -r e verá a nova versão do kernel com as alterações que você fez. $ uname -r

34 Gerenciadores de boot (Grub e Lilo) Grub (GRand Unified Bootloader) O GRUB é um gerenciador de boot mais recente e que usa interface gráfica mais amigável, ao contrário do Lilo que é mais antigo e usa modo texto. O Grub vem instalado como padrão nas distribuições Linux: Debian, Ubuntu, Kurumin, Fedora, Red Hat, OpenSuse e Mandriva. A única distribuição Linux que utiliza o Lilo é o Slackware. Caso você tenha perdido o gestor de boot, com por exemplo após de uma instalação do Windows sobre o Linux, você pode recuperar o Grub através de um Live CD como Ubuntu ou Kurumin ou acessando de um outro HD com o Linux instalado e montando o HD onde que perdeu o Grub com os comandos abaixo: # mount /dev/hda3 /mnt # chroot /mnt # grub-install /dev/hda pressione CTRL + D para sair ou digite exit Onde /dev/hda3 é a partição Linux e o comando chroot enjaula o diretório /mnt permite executar comandos de forma especial como se estivesse no Linux instalado nessa partição, e o comando grub-install /dev/hda regrava o Grub na MBR. Se o comando grub-install /dev/hda não funcionar execute os comandos abaixo: # mount /dev/hda3 /mnt # chroot /mnt # grub grub> root (hd0,2) # instala a partição raiz /dev/hda3 que corresponde a (hd0,2) grub> setup(hd0) # instala o grub na MBR no primeiro disco IDE (Primary Master) grub> exit O arquivo de configuração do GRUB fica localizado no diretório /boot/grub/menu.lst que veremos algumas opções de configuração na tabela abaixo: 34

35 Opção timeout = (número) default = (número) color foreground = (cor hexadecimal) background = (cor hexadecimal) splashimage = (arquivo) password = (senha) title = (S.O) kernel = (hddiscorígido, Partição) arquivo initrd = (hddiscorígido, Partição) arquivo hide = (hddiscorígido, Partição) unhide = (hddiscorígido, Partição) chainloader (arquivo) ou +1 Significado Especifica o tempo em segundos de espera até você digitar alguma tecla na tela de inicialização, caso não pressione nada será carregado tempo padrão especificado pelo sistema Número que indica qual sistema operacional será inicializado como padrão Especifica as de cores utilizados no menu do grub Especifica a cor de primeiro plano Especifica a cor de plano plano Especifica o arquivo usado como papel de parede Especifica uma senha na tela de inicialização do Grub Especifica o nome do sistema operacional Especifica o kernel a ser utilizado Especifica o arquivo initrd de pré-carregamento do kernel a ser utilizado Ignora a uma partição especificada Detecta a uma partição especificada Especifica um arquivo a ser carregado ou o primeiro setor da partição (+1) (Apenas para Windows) makeactive Especifica como uma partição ativa antes de ser carregada Para entender as opções kernel, initrd, hide e unhide que especifica o disco rígido e as partições da seguinte forma (hddiscorígido, Partição), abaixo e mostrado o significado na tabela dos discos rígidos e partições. O Grub não faz distinção entre discos rígidos IDE (hda, hdb,...), Sata (sda, sdb...) e SCSI (sda, sdb...), ele apenas conta os números dos drives começando de zero (0) após as inciais hd. Abaixo segue a tabela com os números dos discos que podem ser IDE (hda, hdb, hdc ou hdd) ou SATA ou SCSI (sda, sdb, sdc ou sdd) que correspondem as partições e veja que o 35

36 Grub não faz distinção entre discos IDE, Sata ou SCSI. Disco Rígido Partição Significado hd0, 0 hda1 (hd0, 0) onde o zero 0 após hd corresponde ao primeiro disco IDE (hda) e o segundo zero 0 corresponde a primeira partição hda1. hd0, 1 hda2 (hd0, 1) onde o zero 0 após hd corresponde ao primeiro disco IDE (hda) e o número um 1 corresponde a segunda partição hda2. hd0, 2 sda3 (hd0, 2) onde o zero 0 após hd corresponde ao primeiro disco SATA ou SCSI (sda) e o número dois 2 corresponde a terceira partição sda3.... e etc... e etc... e etc hd1, 0 hdb1 (hd1, 0) onde o um 1 após hd corresponde ao segundo disco IDE (hda) e o número zero 0 corresponde a primeira partição hdb1. hd1, 1 hdb2 (hd1, 1) onde o um 1 após hd corresponde ao segundo disco IDE (hda) e o segundo número um 1 corresponde a segunda partição hdb2. hd1, 2 sdb3 (hd1, 2) onde o um 1 após hd corresponde ao segundo disco SATA ou SCSI (sdb) e o número dois 2 corresponde a terceira partição hdb3.... e etc... e etc... e etc Agora podemos editar o Grub e adicionar uma entrada para o novo kernel compilado na seção anterior, onde devemos manter a entrada do kernel antigo caso ocorra algum erro, onde será possível carregar o kernel antigo. # kernel antigo title Debian GNU/Linux, kernel root (hd0,2) kernel /boot/vmlinuz root=/dev/hda3 ro partição raiz / onde está instalado o LInux # onde root=/dev/hda3 é a initrd /boot/initrd.img savedefault 36

37 # novo kernel title Debian GNU/Linux, kernel root (hd0,2) kernel /boot/vmlinuz root=/dev/hda3 ro partição raiz / onde está instalado o LInux # onde root=/dev/hda3 é a initrd /boot/initrd.img savedefault Após editar o arquivo /boot/grub/menu.lst com as configurações para o novo kenel, é necessário atualizar o Grub na MBR (Master Boot Record) com comando update-grub. Caso defina alguma senha no arquivo /boot/grub/menu.lst, é aconselhável alterar as permissões de leitura e escrita apenas para o usuário root. # chmod 600 /boot/grub/menu.lst # update-grub Pronto agora é só reiniciar o computador e escolher o novo kernel, que neste caso é o kernel e após entrar no sistema execute o comando uname -r e verá a nova versão do kernel com as alterações que você fez. 37

38 # reboot 38

39 $ uname -r Lilo (Linux Loader) O Lilo foi o primeiro gerenciador de boot do Linux e atualmente é utilizado como padrão na distribuição Linux Slackware. Caso você tenha perdido o gestor de boot, com por exemplo após de uma instalação do Windows sobre o Linux, você pode recuperar o Lilo através de um Live CD como Ubuntu ou Kurumin ou acessando de um outro HD com o Linux instalado e montando o HD onde que perdeu o Lilo com os comandos abaixo: # mount /dev/hda3 /mnt # chroot /mnt # lilo -v pressione CTRL + D para sair ou digite exit Onde /dev/hda3 é a partição Linux e o comando chroot enjaula o diretório /mnt permite executar comandos de forma especial como se estivesse no Linux instalado nessa partição, e o comando lilo -v regrava o Lilo na MBR. O arquivo de configuração do Lilo fica localizado em /etc/lilo.conf. Esse arquivo possui dois tipos de configuração: seção global e seção por imagem. Seção global - uma seção de configuração global onde podemos fazer configurações do sistema tais: inicialização do sistema operacional Linux e de outros sistemas operacionais e parâmetros passados para o kernel. Seção por imagem uma seção por imagem corresponde a um sistema operacional e suas definições sobrepõe a configurado global. Opções de seção global Opção lba32 boot = disco Significado Esta opção permite boot para que seja inicializado o sistema de partições que ultrapassarem o cilindro Especifica um dispositivo de disco rígido (/dev/hda) ou de uma partição do disco(/dev/hda1) 39

40 map = arquivo_mapa install = setor de inicialização default = nome message = arquivo password = senha restricted prompt Especifica o arquivo mapa, caso não seja especifica, é utilizado o arquivo /boot/map. Especifica o arquivo a ser instalado no novo setor de inicialização que pode ser: install bmp (/boot/boot-bmp.b), install text (/boot/boot-text.b) ou install menu que é o padrão (/boot/boot-menu.b ou /boot/boot-boot.b). Especifica a imagem do kernel para ser inicializada como padrão, caso não seja especificado, a primeira imagem exibida no arquivo será utilizada. Especifica um arquivo com uma mensagem a ser exibida na tela de inicialização do Lilo Especifica uma senha na tela de inicialização do Lilo Determina que a senha somente será utilizada, caso seja passado algum comando como parâmetro na tela inicialização do Lilo (Ex: linux single) Determina uma mensagem de acesso ao sistema e aguarda que alguma tecla seja pressionada timeout = número Opções de seção por imagem Especifica o tempo de espera (em décimos de segundos, Ex: 100 corresponde a 10 segundos que é o padrão) para que seja pressionada alguma tecla para inicializar o sistema, caso não seja especificado o tempo padrão que é infinito será utilizado. Opção image = arquivo other = dispositivo label = nome password = senha root = partição Significado Especifica o arquivo de inicialização de imagem do kernel (Ex: /boot/vmlinuz) Especifica uma partição do disco rígido referente ao sistema operacional a ser inicializado. (Ex: /dev/hda1) *(usado para partições Windows) Especifica o nome do sistema operacional (Ex: Linux, Windows) Especifica um senha da imagem do sistema operacional Especifica também uma partição do disco rígido referente ao sistema operacional a ser inicializado. (Ex: /dev/hda2) 40

41 *(usado para partições Windows) table = disco Opções do kernel Especifica um dispositivo de disco rígido a ser inicializado (Ex: /dev/hda) Opção append = string mem = MegaBytesM ramdisk = tamanho root = dispositivo initrd = arquivo_imagem read-only Significado Especifica parâmetros a serem passados para o kernel na inicialização, por exemplo hardwares não detectados ou ativar e desativar suporte para algum recurso ou dispositivo. (Ex: append mem=256m (Faz o Linux reconhecer 256 de memória RAM)) Configura o kernel para utiliza o tamanho em MegaBytesM de memória. (Ex: 128M) Especifica o tamanho do disco de RAM opcional, caso seja configurado com o valor zero 0, nenhum disco em memória deverá ser utilizado. E caso não seja especificado, será utilizado como padrão o valor configurado na imagem de inicialização para o disco de RAM em memória. Especifica o dispositivo do disco rígido a ser montado como partição raiz (Ex: /dev/hda1) Especifica a imagem de pré-carregamento em memória do kernel, sendo opcional seu uso, e em algumas distribuições como o Slackware não é necessário este arquivo Diz que a partição raiz / deverá ser montada com as permissões somente para leitura. read-write Diz que a partição raiz / deverá ser montada com as permissões de leitura e escrita. Abaixo segue um exemplo da seção global do arquivo /etc/lilo.conf # /etc/lilo.conf # seção global lba32 41

42 boot = /dev/hda map = /boot/map install = menu default = linux # aqui pode ser usado outra distribuição Linux como default=debian, default=ubuntu ou Windows default=windows message = /boot/mensagem.txt # define o arquivo com a mensagem # password = senha_secreta # define uma senha e será usada caso seja passado algum parâmetro para o kernel # restricted prompt timeout = 100 append = mem=256m Abaixo segue um exemplo da seção por imagem, onde contém entradas de um kernel antigo e de um novo kernel e uma entrada para o Windows no arquivo /etc/lilo.conf # /etc/lilo.conf # seção da primeira imagem Partição Linux # kernel antigo image = /boot/vmlinuz label = Debian boot = /dev/hda3 # aqui você pode usar a opção root também root = /dev/hda3 read-only # seção da segunda imagem Partição Linux 42

43 # kernel novo image = /boot/vmlinuz label = Debian root = /dev/hda3 read-only # seção da terceira imagem Partição Linux image = /boot/vmlinuz fc8 label = Fedora root = /dev/hda2 read-only # seção da quarta imagem Partição Windows label = Windows other = /dev/hda1 table = /dev/hda Após editar o arquivo /etc/lilo.conf com as configurações para o novo kenel, é necessário atualizar o Lilo na MBR (Master Boot Record) com comando lilo -v. Caso defina alguma senha no arquivo /etc/lilo.conf, é aconselhável alterar as permissões de leitura e escrita apenas para o usuário root. # chmod 600 /etc/lilo.conf Através do comando lilo -D podemos especificar qualquer sistema operacional será padrão na inicialização, por exemplo: 43

44 # lilo -D Windows # lilo -D Debian Gravando o Lilo ba MBR # lilo -v Aplicando patches no kernel Patchs são arquivos de correção de erros (bugs) no kernel do Linux, e por isso as vezes é a razão o qual leva a recompilação do kernel. As correções de erros ou novos recursos demoram para ser lançados na versão mais recente do kernel, e estando assim disponíveis apenas em formas de patches. Algumas vezes você precisa de drivers de hardware que não é suportado pelo novo kernel por padrão, ou você precise de tecnologias de virtualização ou algumas tecnologias muito recentes que ainda não foram feitas para esse kernel, sendo assim nestes casos você deve aplicar patch em seu kernel. Como exemplo de patches temos alguns novos recursos de firewall para o iptables tais como o layer 7 (bloquear MSN) e Patch-O-Match (para bloquear palavras), Freeswan (VPN), OpenMosix (Cluster), Bootsplash (boot gráfico), PPTP Client (Tunelamento de Protocolo Ponto-a-ponto) e etc. Entendendo os patches As atualizações e correções do kernel são distribuídas em patches com extensões de arquivos.bz2 (bzip2) ou.gz (gunzip) através do site no link onde 2.6 é versão atual do kernel. Por exemplo se você tem um kernel e soube que há um patch na versão , isso significa que você pode atualizar sua versão para aplicando o patch bz2 ou gz. Vamos supor que recente foi lançado um novo kernel com a versão e você deseja atualizar sua versão para , então você deveria aplicar cada patch seqüencialmente para cada nova versão (2.6.19, , ), sendo assim neste caso você não deve aplicar patches e sim baixar a última versão do kernel (que atualmente é ) disponível em As versões do Linux estão disponíveis em versões com números pares (2.6.18) chamadas de versões estáveis (releases de produção) e as versões ímpares (2.6.19) chamadas de instáveis (releases de testes). Entendendo os patches 44