Software">
Sebenta de Estudo UFCD 0838
Sebenta de Estudo UFCD 0838
Sebenta de Estudo UFCD 0838
O código que permite executar essas funções recebe a designação de kernel, e encontra-
se rodeado de um conjunto de códigos de suporte — entre eles, as livrarias ou
bibliotecas (libraries) - que servem duas estruturas de funções. São, por um lado, o
suporte para a execução das tarefas fundamentais do SO, “chamadas” sempre que
necessárias, e, por outro, a ligação com o utilizador. Este código de suporte é, para todos
os efeitos, a shell.
Monolítico simples
Nesta primeira subcategoria, de que existem inúmeros exemplos sobretudo no final do
século XX, como é o caso do UNIX, do MS-DOS, das versões do Windows até ao NT e das
da Apple até ao MAC OS (v9), podemos considerar que se trata de uma estrutura de SO
que:
• Não oferece portabilidade
• É de difícil manutenção (“pesada” no sentido de trabalhosa e complexa)
• Tem falta de fiabilidade (passível de muitos crashs e de erros não esperados)
• Todas as componentes de serviço estão no kernel
• Pode conseguir uma alta eficácia enquanto sistema (daí a sua durabilidade)
Em esquema:
Monolítico modular
Uma primeira solução para tentar resolver alguns destes problemas foi estruturar o
sistema operativo em módulos, com algum grau de autonomia entre eles que permita
resolver, de facto, alguns dos inconvenientes anteriores.
Repare-se que, em termos globais, parece não diferir muito do anterior, mas os módulos
permitem uma melhor organização e “atribuição de responsabilidades” dentro do
sistema permitindo, a partir daí, ações mais direcionadas e mais precisas, com todas as
vantagens daí decorrentes.
Uma última solução mais aperfeiçoada é:
Naturalmente que este modelo possui, apesar de tudo, alguns inconvenientes difíceis
de ultrapassar pelo facto de o kernel ser o “pai de tudo” no Sistema Operativo.
Na estrutura modular, por exemplo, apesar de cada módulo executar operações
separadamente do conjunto do todo do SO, a integração do código no processo global
é condicionado por não existirem praticamente margens de erro, e serem de difícil
correção, caso aconteçam. Acresce a isto o facto de todos os módulos que concorrem
para um dado problema acabam por funcionar para um mesmo espaço endereçável e
um erro num deles aca- baria por provocar o crash de todo o sistema.
Apesar deste facto, quando a implementação do Sistema Operativo está bem feita e é
fiável a “fina” integração dos componentes permite articular com facilidade o software
designado de baixo nível (Low-Level software — ver imagem de página 27) subjacente à
shell, construindo uma solução altamente eficiente.
Os defensores deste modelo explicam muitas vezes que, se um código é defeituoso, não
pertence em princípio ao kernel e, caso isso aconteça, existem vantagens no modelo
modular para ultrapassar essa situação. De facto, a solução encontra-se no microkernel,
muitas vezes designado como ukernel.
O arranque: LILO/GRUB
Num sistema onde estão instalados vários sistemas operativos temos de ter um gestor
para que o utilizador, no arranque do computador, possa selecionar qual o sistema
operativo que vai arrancar. Existem diversos programas que realizam a tarefa anterior,
dentro dos quais destacamos o LILO e o GRUB.
O GRUB é o gestor de arranque que é instalado, por defeito, durante a fase de instalação
do Fedora e do Red Hat.
Após o arranque do computador e, antes de o sistema operativo ser carregado para a
memória, o GRUB disponibiliza aos utilizadores, durante uns segundos, um menu onde
podemos selecionar o sistema operativo que será carregado pelo computador.
• /var/www — diretoria que contém várias subdiretorias, das quais destacamos a que aloja
os manuais, as CGI, os defeitos e as páginas HTML do site:
• /var/www/html — diretoria, por defeito, do Apache, onde devemos alojar as pági- nas do
site;
• /usr/share/man — diretoria com manuais do Apache. O acesso a estes manuais pode ser
efetuado usando o comando man httpd;
• /usr/bin — alguns dos utilitários do Apache são colocados aqui, por exemplo, o programa
hipasswa, que é usado para gerar ficheiros de autenticação de palavras-passe;
Vamos analisar alguns dos principais módulos disponíveis. Alguns deles podem ser
encontrados na Internet, por exemplo, no endereço http://modules.apache.org.
• mod_cgi — este módulo permite a execução de scripts CGI. Apesar da grande varie-
dade de scripts disponíveis na Internet e da facilidade em criá-las, a utilização de
CGI tem tendência a diminuir, dado que, para além de serem mais lentos, relativa-
mente a scripts escritas noutras linguagens, nomeadamente em Perl ou PHP, elas
podem sempre representar uma ameaça na segurança do servidor, pois estas
scripts são programas executáveis. Por esta razão, muitos administradores hesitam
em ativar este módulo de suporte a CGI;
• mod_perl — o Perl é uma linguagem de programação muito poderosa. A par do
PHP, o Perl é uma das linguagens mais usadas no desenvolvimento de sites
dinâmicos, fóruns e outras aplicações que envolvam processamento de
informação. O endereço do módulo mod_perl é http://perl.apache.org;
• mod_php — o PHP é muito utilizado em manipular base de dados e pode ser
integrado com várias bases de dados, entre elas o MySQL, PostgreSQL e dBase. A
página oficial do PHP é http://www.php.net;
• mod_asp — como o nome sugere, este é um módulo que oferece suporte parcial a
páginas ASP. É uma boa solução para migrar sites que estão escritos em ASP e a
funcionar em IIS para o Apache, sem haver necessidade de se converter tudo para
PHP. O mod_asp trabalha convertendo os comandos ASP para comandos Perl e,
por esta razão, é necessário instalar o mod_perl. O endereço oficial do módulo
mod_asp é: http://www.apache-asp.org;
• mod_gzip – O gzip ou GNU Zip é um formato de compressão desenvolvido pela Free
Software Fundation e é muito utilizado em sistema Linux. O mod_gzip pode ser
usado em conjunto com o Apache para compactar as páginas enviadas aos clientes.
Isto permite diminuir até 80% o tempo de transferência das páginas, melhorando
muito a capacidade do servidor. Atualmente, quase todos os browsers são capazes
de descompactar automaticamente as páginas; assim, não existem grandes
desvantagens em utilizar este módulo, a não ser um pequeno aumento na
utilização do processa- dor. O endereço do módulo mod_gzip é
http://freshmeat.net/projects/mod. gzip;
• mod_speling — este módulo corrige erros nos endereços digitados pelos utilizadores;
mesmo que estes introduzam, num browser, um endereço errado, este módulo pode
corrigir o erro e atingir a página desejada. Outro recurso permitido por este módulo é a
desativação da diferenciação entre letras maiúsculas e minúsculas. O endereço do módulo
mod_speling é http: //httpd.apache.org/docs/mod/mod speling.html;
• mod_ssl — este módulo permite ligações seguras, com encriptação forte. Este módulo
deve ser utilizado em sites de bancos e em outras páginas que trabalhem com números de
cartão de crédito e com outros dados confidenciais. O endereço do módulo mod_ssl é
http://www.modssl.org;
• jakarta — este é o projeto que oferece uma implementação do Java para o servidor
Apache. Os pacotes podem ser descarregados a partir do endereço http: //jakarta.apa-
che.org.
Versões do kernel
O kernel do Linux encontra-se num constante estado de desenvolvimento. Quando se
adicionam novas características, ou se resolvem defeitos ou, ainda, se uma nova
tecnologia é incorporada no código-base, torna-se necessário fornecer lançamentos
estáveis do kernel para serem usados. É importante ter lançamentos separados que
contenham o código mais recente para que os colaboradores, que desenvolvem o
kernel, o possam testar.
Para nos mantermos a par das várias versões do kernel, são-lhes atribuídos números das
versões.
Os programadores usam números de versões sequenciais que tenham um significado
abstrato. Por exemplo, será que a versão 6 é duas vezes mais avançada que a versão 3
da mesma aplicação? Será que a versão 2 de uma aplicação é menos desenvolvida que
a versão 5 de uma outra aplicação? Os números das versões não podem ser usa- dos
para este tipo de comparação quantitativa e qualitativa. É perfeitamente possível que
números mais elevados possam ter menos características e mais defeitos que versões
mais antigas. Os números apenas existem para diferenciar e organizar as versões
sequenciais da revisão do software.
Imaginemos a versão mais recentemente desenvolvida do kernel, que, no momento em
que este texto é escrito, é, a versão número 2.6.16-11.
A versão do kernel pode ser dividida em quatro secções:
• versão principal — este é o número da versão principal, que agora está em 2;
• número de subnível — este número indica a iteração atual do kernel; aqui é o número 16;
• nível extraversão — este é o número que representa uma coleção de pacotes e adições
feitas ao kernel. Neste exemplo é 11.
A visualização da versão atual do kernel, isto é, saber qual a versão do kernel que o
sistema carregou durante o arranque do sistema, pode ser realizada executando, numa
linha de comandos de uma shell, o comando:
uname -r
Neste exemplo o resultado seria:
2.6.16-11
As versões menores numeradas com números pares são kerneis estáveis, enquanto que
versões menores, numeradas com números ímpares, são lançamentos de
desenvolvimento. A versão 2.6.x é o kernel de produção estável, enquanto que a versão
2.5.x é o kernel de desenvolvimento do Linux. Quando se iniciar uma nova versão de
desenvolvi- mento do kernel, será numerada com 2.7.x.
Para computadores de produção, devem-se sempre usar kernels com números pares
menores. Os números ímpares menores introduzem novas características, por isso,
podemos usar um kernel com números ímpares menores numa máquina de testes se
necessitarmos de usufruir das novas características disponibilizadas pela versão de
desenvolvimento.
Compilar o kernel
Antes de iniciar o processo de compilação é necessário instalar o compilador de gcc.
Para isso, no ambiente de trabalho, vamos a Área de Trabalho e, em Configuração do
Sistema, selecionamos Adicionar/Remover Aplicações, ou podemos, simplesmente,
numa shell, executar system-config-packages.
Na janela Gestão de Pacotes selecionamos as Ferramentas de Desenvolvimento e
clicamos em Atualizar para prosseguir com a instalação do compilador.
Se quisermos fazer uma atualização — update — do kernel, a partir do novo código-
fonte que descarregamos, ou se pretendermos aplicar um acrescento para adicionar
novas funcionalidades ou apoio
de hardware, necessitamos de
compilar e instalar um novo
kernel para que o sistema,
realmente, possa usar essa nova
funcionalidade. Compilar o
kernel envolve traduzir os
conteúdos do kernel do código-
fonte para a forma binária.
Instalar o kernel compreende
colocar todos os ficheiros
compilados onde pertencem em
/boot e /lib e fazer alterações ao
gestor de arranque (bootloader).
O processo de compilação do
kernel é quase completamente
automatizado pelo utilitário Adicionar compilador gcc.
make, como o é o processo de
instalação.
Eis uma lista de verificação dos passos para compilar e configurar o kernel:
1. Encontrar o disco de arranque que funcione com o kernel antigo, para ser capaz
de reiniciar o sistema, no caso de algo correr mal com o novo kernel.
Nota: Antes de efetuarmos qualquer alteração ao kernel atual, devemos ter a certeza
de termos feito uma cópia de segurança numa disquete ou pen. Isto irá permitir fazer o
arranque ao nosso sistema com um Kernel que sabemos que funciona, no caso de algo
correr mal durante a configuração. O comando para tal é o seguinte:
mkpootdisk --device /dev/fd0 uname -r
2. Aplicar todos os aumentos ao kernel, se existirem, para que tenhamos as
características que desejamos. Se estamos a instalar um novo kernel a partir do
código-fonte completo, esta tarefa não se efetua.
3. Fazer cópia de segurança ao .config, se existir, para que se possa recuperar, caso
haja algum erro. Se estamos a instalar um novo kernel a partir do código-fonte
completo, não é necessário efetuar esta tarefa.
Módulos
Como já foi visto, os módulos são pacotes de software que podem ser adicionados e
removidos do kernel durante o funcionamento do sistema operativo, sem que este
tenha de parar, nem mesmo por um instante.
Pelo facto de funcionarem dentro do kernel, esses pacotes de software têm acesso
directo ao hardware e às estruturas de dados internas do próprio kernel.
Os módulos são a plataforma ideal para implementar os controladores de dispositivos
(drivers), que necessitam de aceder directamente ao hardware.
Contudo, a utilidade dos módulos é muito mais vasta do que esta, pois também são
usados para implementar muitos subsistemas e pacotes opcionais do próprio kernel. Por
exemplo, existem módulos que implementam protocolos de comunicação, suporte para
novos sistemas de ficheiros, extensões para criar compatibilidade com outros sistemas
operativos, novos algoritmos de cifragem de dados, etc.
As duas grandes vantagens dos módulos são a optimização da quantidade de memória
ocupada pelo próprio kernel e o uptime. Ao contrário do que acontece com outros
sistemas operativos, não temos de mandar o sistema abaixo apenas para instalar um
novo driver ou alterar um protocolo de comunicação.
O kernel inicial com que o sistema arranca possui apenas um conjunto de
funcionalidades mínimo, necessário para fazer o sistema arrancar, assim como todos os
serviços genéricos que são usados em todas as situações. Desta forma, a quantidade de
memória ocupada pelo kernel é mínima.
Os componentes opcionais, que variam de sistema para sistema e que não são essenciais
para o seu funcionamento, são carregados sob a forma de módulos, durante a fase final
do arranque do sistema.
Por exemplo, os controladores das placas de som, das placas de rede, das placas RDIS,
alguns protocolos de rede e o software de suporte a alguns sistemas de ficheiros, estão
dentro de módulos opcionais.
Para conhecer os módulos que estão instalados no kernel, vamos novamente utilizar o
file-system proc (ou executar o comando «/sbin/lsmod»):
# cat /proc/modules
Ao executar este comando, vamos obter uma listagem de todos os módulos instalados,
em conjunto com as suas interdependências. As interdependências devem-se ao facto
de existirem módulos que utilizam o software implementado noutros módulos.
Exemplo:
Neste exemplo, estão instalados 12 módulos no kernel, que dizem respeito a uma placa
de rede RTL8139, ao sistema de ficheiros FAT/VFAT do DOS, uma placa de som AWE32
e um controlador SCSI NCR/Symbios 53c875.
Os módulos «rtl8139too» e «ncr53c8xx» são os controladores da placa de rede e do
adaptador SCSI. Estes dois módulos funcionam isoladamente e não possuem
dependências com nenhuns outros.
Os módulos «soundcore», «soundlow», «sound», «uart401», «awe wave» e «sb» fazem
parte do subsistema de áudio. Por esse motivo, estão interligados e dependem uns dos
outros.
Os primeiros três módulos são genéricos para todas as placas de áudio, enquanto os
últimos três são os controladores da porta MIDI externa da placa, do sintetizador MIDI
interno e do módulo PCM da Sound Blaster AWE 32.
Os módulos «fat», «vfat», «nls iso8859-1» e «nsl cp437» também dependem uns dos
outros, pois são necessários para dar suporte ao filesystem FAT, incluindo as extensões
do Windows para nomes compridos, VFAT e FAT32. Neste file-system, são suportados
os códigos de página 427 e is0o8859-1.
A indicação autoclean que aparece em alguns destes módulos indica que estes foram
carregados de forma automática. Por esse motivo, assim que deixarem de ser utilizados,
são automaticamente descarregados.
O programa «kmod» («kerneld» nas versões antigas) verifica periodicamente quais são
os módulos que deixaram de ser necessários, descarregando-os de imediato. Como
consequência, a memória que estes estavam a ocupar fica livre para outras aplicações.
Os comandos usados para carregar e descarregar módulos manualmente são o
«insmod» e «rmmod». Em ambos os casos, temos de indicar o nome do módulo que
desejamos carregar ou descarregar ou, então, o nome do respectivo ficheiro.
A directoria «/lib/modules» é o local onde estão localizados os módulos que foram
fornecidos com o kemel. Ao inspeccionar esta directoria, vamos encontrar várias
subdirectorias contendo módulos, ordenados de acordo com a sua utilidade e com a
versão do kernel para que foram criados.
O nome de alguns destes módulos pode não ser auto-explicativo, pelo que é
recomendável uma consulta à documentação do próprio kernel, que se encontra na
directoria «/usr/src/linux*/Documentation».
Para além dos módulos que são fornecidos com o kernel, também é possível instalar
novos módulos fornecidos por terceiras pessoas ou desenvolvidos pelo próprio
utilizador.
Uma das situações mais frequentes em que isto costuma acontecer é quando instalamos
drivers para hardware novo, pois já existem alguns fabricantes de hardware que
começaram a fornecer módulos com drivers para os periféricos que fabricam.
Por exemplo, se desejássemos instalar suporte no kernel para o protocolo de rede IPX
(conectividade com redes Novell), seria necessário inserir o seguinte módulo no kernel:
# /sbin/insmod ipx
Para voltar a remover este módulo, bastaria usar:
# /sbin/rmmod ipx
Durante a inserção e a remoção de módulos, é normal que o kernel escreva algumas
mensagens para os logs que registam os acontecimentos do sistema. Para consultar
estes logs, podemos utilizar o comando «dmesg» ou então ler o texto que está no fim
do ficheiro «/var/log/messages».
Existe um comando muito útil, chamado «modprobe», que serve para manipular
módulos e pode ser utilizado de várias formas. Pode servir para detectar o hardware
presente no sistema, listar os módulos disponíveis no sistema e até para instalar grupos
de módulos interdependentes, de uma única vez.
Por exemplo, o comando:
# /sbin/modprobe ppp
Serve para activar o suporte para PPP (protocolo IP sobre linhas série e modems) no
kernel. Contudo, se verificarmos o conteúdo do ficheiro «/proc/modules», vamos
descobrir que para além do módulo ppp, foi também carregado o módulo slhc, pois o
ppp depende deste último para funcionar.
Da mesma forma, podemos remover os dois módulos anteriores de uma só vez, usando
o comando:
# /sbin/modprobe -r ppp
O funcionamento do «modprobe» pode ser configurado através do ficheiro
«/etc/modules.conf» (nas distribuições antigas chama-se «/etc/conf.modules»).
No sistema do exemplo anterior, o ficheiro «modules.conf» tem a seguinte
configuração:
As linhas que começam pela palavra alias identificam o módulo que deve ser utilizado
em cada classe de dispositivos. Por exemplo, na classe dos controladores SCSI é usado o
módulo «ncr53c8xx», na classe das placas de rede (1º placa) é usado o módulo «rtl8139»
e, na classe das placas de som, o módulo «sb».
As linhas que começam pelas palavras pre-install e post-install definem as dependências
que existem entre módulos, pois permitem especificar comandos que são executados
sempre que um módulo é carregado.
As linhas que começam pela palavra options definem diversos parâmetros de
funcionamento de cada módulo. Por exemplo, no caso dos controladores de
dispositivos, definem os recursos de hardware utilizados (IRQ, DMA, IOPorts).
Os parâmetros de configuração de módulos podem parecer algo complexos à primeira
vista. Contudo, não existe qualquer razão para preocupações, uma vez que existem
vários utilitários que fazem a gestão de módulos de forma automática.
Em primeiro lugar, quando o sistema operativo é instalado, a maioria do hardware é
detectado de forma automática e o software de instalação encarrega-se de criar uma
versão inicial do ficheiro «/etc/modules.conf» perfeitamente funcional.
No caso das placas de som, existem os programas «/usr/sbin/sndconfig» e «redhat-
config-soundcard» do painel de controlo, que se encarregam de detectar
automaticamente o tipo de placa de som presente no sistema e actualizam o ficheiro
«/etc/modules.conf».
Quando desejamos instalar novo hardware, após o computador ter sido instalado,
também existe software que nos pode auxiliar. No caso dos modems, controladores SCSI
e placas de rede, existem vários utilitários gráficos, como o próprio painel de controlo
do Linux Red Hat, que simplificam esta tarefa.
Recompilação do kernel
Nos primeiros tempos, a única forma de adicionar ou remover controladores de
dispositivos ao kernel de Linux consistia em reconstruir um novo kernel e seleccionar
apenas os componentes desejados.
Actualmente, esta tarefa já raramente é utilizada, pois os módulos oferecem muito mais
flexibilidade. Contudo, existem casos em que ainda temos de modificar o kernel. Por
exemplo, isso é o que acontece quando desejamos instalar uma nova versão.
Desde os primeiros tempos que o kernel de Linux tem sido distribuído aos utilizadores
sob a forma de código-fonte. O código-fonte está maioritariamente escrito em
linguagem C, existindo apenas algumas pequenas partes em linguagem Assembly,
porque dependem do hardware.
A maioria das distribuições de Linux costuma incluir um conjunto de utilitários, que
servem para instalar e desenvolver novas aplicações. Esse utilitários incluem os
compiladores e os assembladores, que traduzem programas em linguagens C e
Assembly para o formato binário dos microprocessadores (linguagem máquina).
Utilizando esses utilitários, é possível reconstruir um kernel novo a partir do seu código-
fonte. Como esta tarefa é relativamente complicada, existe outro utilitário chamando
«make», que faz tudo de forma automática. O «make» vai ler um ficheiro, chamado
Makefile, que contém a lista das tarefas a realizar e executa-as sequencialmente.
O «make» permite aos utilizadores compilar kernels novos, mesmo sem possuir
quaisquer conhecimentos sobre programação em linguagem C, nem sobre as restantes
ferramentas de desenvolvimento do Linux.
Para reconstruir o kernel, apenas temos de executar a seguinte sequência de operações:
# cd /usr/src/linux-2.4
# make menuconfig
# make dep
# make
# make modules
# make install
# make modules install
O comando «cd» serve apenas para mudar a directoria actual, para o local onde o
código-fonte do kernel de Linux se encontra. Caso tenha sido feito download para outro
local ou esteja a ser usada uma versão diferente da 2.4, deverá ser escolhida a directoria
correcta.
A linha «make menuconfig» serve para aceder a um sistema de menus, que nos permite
escolher todos os serviços e controladores que desejamos instalar.
Caso estejamos a usar o sistema de janelas X, podemos usar «make xconfig» em vez do
«make menuconfig». O «xconfig» funciona em modo gráfico, pelo que ainda é mais fácil
de usar.
Para cada componente do kernel, podemos escolher as opções «y», «n», ou «m».
Quando escolhemos «y», esse componente é automaticamente instalado na versão
base do kernel. Quando escolhemos «m», é criado um módulo que pode ser carregado
dinamicamente durante o funcionamento do sistema. Quanto escolhemos «n», estamos
simplesmente a desactivar esse componente.
A linha seguinte, «make dep», vai analisar as dependências entre cada um dos pacotes
de software que fazem parte de kernel. Pode acontecer que a configuração escolhida
no passo anterior esteja inconsistente. Isso acontece quando activamos um
componente que necessita de outro, mas este outro foi desactivado.
A linha «make» é que vai realmente reconstruir o novo kernel. Quando este comando é
executado, o utilitário «make» vai mandar traduzir algumas centenas de ficheiros em
linguagem C para código-binário. Por esse motivo, o compilador de C «gec» vai ser
chamado centenas de vezes, até todos os ficheiros terem sido convertidos. Esta
operação pode demorar entre 10 minutos a mais de meia hora, dependendo da
velocidade do computador.
Após todos os ficheiros terem sido compilados, o seu resultado é agrupado num único
ficheiro (linking), que é depois comprimido utilizando o programa «gzip». Quando o
Linux está a ser usado num PC, o ficheiro final fica guardado na directoria
«./arch/i386/boot». É exactamente este ficheiro que contém o novo kernel,
devidamente comprimido.
A linha «make modules» gera todos os módulos que serão utilizados em conjunto com
o novo kernel.
As linhas «make install» e «make modules install» copiam o kernel propriamente dito,
juntamente com os ficheiros auxiliares e os módulos que acabaram de ser compilados
para as directorias definitivas do sistema: «/boot» e «/lib/modules».
Por fim, falta apenas configurar o sistema para passar a arrancar a partir do novo kernel:
este é o tema que vai ser tratado em seguida...
O arranque do sistema
O conhecimento da sequência de passos que um sistema Linux executa durante o
arranque é essencial para qualquer administrador.
Entre muitas outras coisas, é durante o arranque que são lançados os vários serviços do
sistema, as interfaces de rede são configuradas e os periféricos são activados.
GRUB/LILO ou «loadlin»
A primeira fase do arranque de um sistema Linux consiste no carregamento do kernel
do sistema operativo para a memória. Nos PC, os programas utilizados para carregar o
kernel são o GRUB (Grand Unified Boot Loader) ou alternativamente o LILO (Linux
Loader).
Tanto o GRUB como o LILO podem ser instalados no início do disco rígido (MBR - master
boot record) ou no início da partição principal de Linux (ou seja, a que possui a directoria
raiz e a «/boot»).
Quando um PC arranca, a BIOS do sistema executa o boot-loader que estiver instalado,
GRUB ou LILO, que em seguida lê o kernel de Linux do disco, descomprime-o e carrega-
o em memória. Depois de carregado, o kernel começa a ser executado e só então é que
podemos dizer que o computador está efectivamente a correr Linux.
Outro programa que também pode ser utilizado para correr Linux é o «loadlin». O
«loadlin» é um programa que corre a partir do DOS e faz a mesma coisa que o LILO.
Utilizando o «loadlin»
O «loadlin» é uma ferramenta muito útil para as pessoas que utilizam o Linux, mas por
uma razão ou por outra ainda têm de continuar a usar outros sistemas operativos no
mesmo computador.
A grande vantagem do «loadlin» é que pode ser executado manualmente, permitindo
entrar em Linux a partir da linha de comandos do DOS, sem necessidade de reiniciar o
sistema.
Para arrancar o Linux a partir do DOS, podemos usar o «loadlin» de acordo com os
seguintes exemplos:
C:> loadlin vmlinuz.bin root=/dev/hda5
C:> loadlin vmlinuz.bin initrd=image. img
No primeiro exemplo, estamos a carregar um kernel a partir do ficheiro «vmlinuz.bin>.
À partição principal por onde o Linux deve arrancar é a «/dev/hda5».
No segundo exemplo, estamos a carregar novamente o kernel do ficheiro «vmlinuz.bin»,
mas também estamos a carregar um ramdisk inicial contendo um file-system de
arranque, que está no ficheiro «image.img».
Em qualquer dos dois casos, o ficheiro «vmlinuz.bin» tem de estar acessível a partir do
DOS, pois é ele que contém o kernel que vamos carregar em memória.
Num sistema com várias partições e mais do que um sistema operativo, temos um
problema adicional: é normal ter de reinstalar os outros sistemas operativos de tempos
em tempos, quer seja para fazer actualizações, quer seja para recuperar de situações de
instabilidade e crashes.
Acontece que os outros sistemas operativos têm o mau hábito de apagar o sector de
arranque, que é substituído pelo seu próprio. Nessas situações, o GRUB/LILO deixam de
ser executados e o Linux deixa de arrancar.
Esse problema pode ser facilmente resolvido, utilizando o primeiro dos dois exemplos
anteriores: usamos o «loadlin» para arrancar o Linux a partir do DOS e usamos o
parâmetro root para indicar o nome da partição por onde o Linux costumava arrancar.
Após o Linux arrancar, podemos voltar a configurar o GRUB/LILO, para repor o sector de
arranque do Linux.
Configurando o GRUB
O GRUB é um programa muito versátil, que permite ao utilizador escolher diversos
sistemas operativos por onde fazer o arranque.
Antes de carregar qualquer sistema operativo em memória, o GRUB apresenta um menu
ao utilizador e faz uma pausa de vários segundos. Nessa altura, os utilizadores podem
seleccionar o sistema operativo que desejam usar.
Para além disso, os utilizadores podem inserir uma password e aceder a um conjunto de
opções extra, que permitem editar os parâmetros de arranque do kernel e aceder a uma
shell simplificada que permite realizar algumas operações para tentar recuperar
sistemas danificados, seleccionar kernels contidos em ficheiros diferentes, etc.
A configuração do GRUB é feita no ficheiro «/etc/grub.conf», que contém a lista com
todos os sistemas operativos instalados:
A nova seção que acrescentámos define um sistema que será conhecido por new-linux
e usa a partição «/dev/hda2» como directoria raiz, pois esta é a partição onde está
instalado o início da árvore de directorias do Linux.
Se desejamos que o novo kernel passe a ser o sistema preferido, que arranca por
omissão, basta alterar a linha «default=», que aparece na primeira secção do
«grub.conf» e escolher a posição em que aparece o novo kernel.
Finalmente, resta lembrar que quando o novo kernel é instalado a partir de um pacote
RPM, não é habitual ser necessário fazer absolutamente nada, dado que os RPM
costumam acrescentar automaticamente uma secção ao «grub.conf».
Esta linha define o nível de execução do sistema, que costuma ser conhecido por
runlevel. No exemplo anterior, foi escolhido o nível de execução número 5, cujo
significado será analisado em seguida.
Um sistema Linux pode trabalhar em sete níveis de execução diferentes:
A tabela inittab
A tabela inittab contém a lista de tarefas que o processo «init» tem de realizar:
Cada linha deste ficheiro é composta por 4 campos separados por caracteres «:» e
corresponde a um programa que deve ser executado pelo «init».
O primeiro campo atribui uma identificação a cada linha e o segundo campo tem a lista
de runlevels em que o comando deve ser executado. O terceiro campo define opções
sobre a forma como os comandos são executados e o último campo tem o nome do
programa a executar.
A linha inicial é diferente de todas as outras, porque serve apenas para identificar o
runlevel com que o sistema arranca:
A primeira linha que realmente contém comandos para serem executados pelo «init» é
a que vem a seguir:
Esta linha é executada imediatamente assim que o sistema arranca, pelo que não tem
nenhum runlevel definido. A instrução «/etc/rc.d/rc.sysinit» executa um script de shell,
que faz toda a inicialização do hardware do sistema.
Em seguida, temos uma sequência de 7 linhas praticamente iguais, que executam o
script de inicialização «/etc/re.d/rc» (runtime configuration), de acordo com cada nível
de execução:
Este script é responsável por lançar todos os serviços do sistema, como a gestão de
impressoras, serviços de rede, etc. Como iremos ver adiante, o seu funcionamento varia
de acordo com o runlevel em que o sistema arrancou.
Nas linhas que se seguem, definem-se as acções a tomar sempre que alguns eventos
acontecem. Por exemplo, quando o utilizador carrega em CTRL-ALT-DEL ou quando uma
UPS avisa que a energia está prestes a faltar, é executado um shutdown automático.
Depois disto, temos um conjunto de 6 linhas muito importantes, que executam o
programa «mingetty» em cada consola virtual de tty1 a tty6:
O «mingetty» é o programa que o sistema utiliza para fazer o pedido de login aos
utilizadores. Este programa faz a validação do nome dos utilizadores e da respectiva
senha, lançando em seguida o interpretador de comandos”.
São estas 6 linhas do «inittab» que mandam lançar 6 cópias do programa «mingetty»,
para cada uma das primeiras 6 consolas virtuais do sistema. E apenas por esse motivo
que nos aparece a prompt «login:» em cada uma dessas consolas virtuais.