  COMO FAZER um Disco de Inicialização Linux
  Tom Fawcett (fawcett@croftj.net


  v3.2, Junho de 1998

  Este documento descreve como definir e construir o seu próprio
  disquete de inicialização e do sistema de arquivos raiz para o Linux.
  Estes discos podem ser usados como disquetes de emergência ou no teste
  de novos componentes do sistema. Caso não se tenha lido o FAQ do Linux
  e outros relacionados, como o Tutorial de Instalação Linux e o Guia de
  Instalação Linux, não é indicada a construção de discos de
  inicialização. Caso se deseje somente criar discos de emergência, veja
  o Anexo ``Discos de inicialização pré-configurados ''.
  ______________________________________________________________________

  Índice geral


  1. Prefácio

     1.1 Notas
     1.2 Opiniões e Créditos
     1.3 Política de Distribuição

  2. Introdução

  3. Discos de Inicialização e o Processo de Inicialização do Sistema

     3.1 O Processo de Inicialização
     3.2 Tipos de Discos

  4. Construíndo um Sistema de Arquivos Raiz

     4.1 Visão Geral
     4.2 Criando o Sistema de Arquivos
     4.3 Ocupando o Sistema de Arquivos
     4.4 Módulos
     4.5 Alguns detalhes finais
     4.6 Empacotando

  5. Escolhendo um kernel

  6. Colocando tudo junto: Construindo o(s) disco(s)

     6.1 Transferindo o kernel com o  LILO
     6.2 Transferindo o kernel sem o LILO
     6.3 Configurando o disco em memória
     6.4 Transferindo o sistema de arquivos raiz

  7. Problemas

  8. Diversos

     8.1 Reduzindo o tamanho do sistema de arquivos raiz
     8.2 Sistemas de arquivos raiz não residentes em discos na memória
     8.3 Construindo um disquete de utilitários

  9. Como os profissionais fazem isso

  10. Lista das Perguntas Mais Frequentes (FAQ)

  11. Recursos e Endereços

     11.1 Discos de Inicialização Pré-Configurados
     11.2 Discos de Emergência
     11.3 Programas de Lote de Graham Chapman
     11.4 LILO --- O carregador Linux
     11.5 Perguntas Mais Freqüentes e Como Fazer
     11.6 Uso do Disco em Memória
     11.7 O processo de inicialização do Linux

  12. Códigos de Erros de Inicialização do LILO

  13. Listas de exemplo do conteúdo do disco de inicialização

  14. Listas de exemplo do conteúdo do disco de utilitários


  ______________________________________________________________________


  11..  PPrreeffáácciioo


  NNoottaa:: eessttee ddooccuummeennttoo ppooddee nnããoo eessttaarr aattuuaalliizzaaddoo.. Verifique na página do
  Projeto de Documentação Linux  <http://sunsite.unc.edu/LDP/> se há
  alguma versão mais recente deste documento.

  Apesar  deste  documento  estar  em  formato texto, ele pode ser
  visualizado de maneira muito _m_a_i_s agradável em formato Postscript
  (.ps) ou HTML, em virtude dos comandos de notação tipográfica
  utilizados. Nós sugerimos a utilização de um destes formatos.


  11..11..  NNoottaass


  Graham Chapman (grahamc@zeta.org.au) escreveu a versão original e a
  suportou até a versão 3.1. Tom Fawcett (fawcett@croftj.net) adicionou
  uma grande quantidade de informações do kernel 2.0 e é o mantenedor
  atual da versão 3.2, porém muito da versão original ainda permanece.

  Este documento está voltado para usuários da versão  22..00 ddoo KKeerrnneell ddoo
  LLiinnuuxx oouu ppoosstteerriioorr. Caso se esteja utilizando uma versão anterior
  (1.2.xx ou mais antiga), é aconselhável utilizar versões do COMOFAZER-
  Bootisk arquivadas na Página Pessoal de Graham Chapman
  <http://www.zeta.org.au/~grahamc/linux.html>.

  As informações aqui apresentadas estão voltadas para os usuários da
  plataforma IInntteell, porém muito do aqui descrito aplica-se ainda a
  outros processadores, porém não podemos ser conclusivos a respeito
  disso. Caso alguém tenha essa experiência, por favor nos contacte.


  11..22..  OOppiinniiõõeess ee CCrrééddiittooss

  Quaisquer comentários ou sugestões, positivas ou negativas, sobre o
  conteúdo deste documento são bem-vindas. Fizemos o melhor possível
  para garantir que as informações aqui contidas sejam confiáveis e
  acuradas. Por favor avise-nos caso sejam encontrados erros ou
  omissões.

  Agradecemos às inúmeras pessoas que enviaram as suas sugestões e
  correções. A sua contribuição certamente tornou este documento muito
  melhor, do que se   tivéssemos feito tudo sozinhos.

  Por favor envie comentários, correções e dúvidas ao autor  no
  endereço-eletrônico apresentado mais acima. Não me incomodo em
  responder dúvidas, porém por favor leia primeiramente a seção
  ``Problemas''.


  11..33..  PPoollííttiiccaa ddee DDiissttrriibbuuiiççããoo


  Copyright © 1995,1996,1997,1998 de Tom Fawcett and Graham Chapman.
  Este documento pode ser distribuído sob os termos da Licença do
  Projeto de Documentação Linux  disponível em
  <http://sunsite.unc.edu/LDP/COPYRIGHT.html>.  Por favor contacte os
  autores caso não seja possível obter uma licença.

  Esta é uma documentação livre. É distribuída na expectativa de ser
  útil, porém sem qquuaallqquueerr ggaarraannttiiaa;  mesmo as garantias inerentes de
  ccoommeerrcciiaalliizzaaççããoo ou aaddeeqquuaaççããoo aa uumm pprrooppóóssiittoo ppaarrttiiccuullaarr.


  22..  IInnttrroodduuççããoo


  Discos de inicialização do Linux são úteis em diversas situações, tais
  como:

  ·  Testes de um novo kernel.

  ·  Recuperação de falhas de disco -- qualquer coisa que pode variar
     desde um setor de inicialização à uma quebra de cabeça de disco.

  ·  Consertando um sistema defeituoso. Um pequeno erro como
     superusuário pode tornar o sistema  sem condições de uso, e pode
     ser necessário inicializar o sistema a partir um disquete, para
     consertá-lo.

  ·  Atualizar arquivos críticos do sistema, tais como o libc.so.

  Há várias formas de se obter discos de inicialização (boot):


  ·  Usar um de uma distribuição como Slackware, Red Hat, Conectiva
     Linux, o qual permitirá que ao menos o sistema seja inicializado.

  ·  Usar um pacote  desenvolvido para a criação de discos de
     emergência.

  ·  Aprender o que é necessário para cada tipo de disco operar e
     construir um por conta própria.

  Algumas pessoas escolhem a última opção, construindo os seus próprios
  discos de emergência. Desta forma, na ocorrência de algum problema,
  eles podem saber o que deve ser corrigido. Mais ainda, é uma grande
  maneira de aprender como o Linux funciona.

  Este documento assume alguma familiaridade com os conceitos básicos de
  administração de sistemas Linux. Por exemplo, deve-se  conhecer os
  conceitos de diretórios, sistemas de arquivos e disquetes. Deve-se
  saber ainda utilizar os comandos  mount e tt/df/, bem como o
  significado dos arquivos /etc/passwd efstab e como eles estão
  constituídos, assim como saber que a maioria dos comandos deste COMO
  FAZER devem ser executados como superusuário (root).

  A construção de um disco de inicialização do nada pode ser bem
  complexa. Caso não se tenha lido os conteúdos do FAQ do Linux e
  documentos relacionados, como por exemplo, o  COMO FAZER Instalação
  Linux e o Guia de Instalação Linux, não é aconselhável tentar-se a
  construção dos discos desta forma. Caso se necessite somente de um
  disco de emergência  que funcione, será _m_u_i_t_o  mais simples utilizar
  um pré-existente. Veja o Apêndice ``Discos de Inicialização
  Pré-Configurados'', abaixo, a fim de verificar onde encontrá-los .


  33..  DDiissccooss ddee IInniicciiaalliizzaaççããoo ee oo PPrroocceessssoo ddee IInniicciiaalliizzaaççããoo ddoo SSiisstteemmaa


  Um disco de inicialização é basicamente uma miniatura de um sistema
  completo, ou seja é um sistema Linux contido em um disquete. Ele deve
  executar muitas das funções que o sistema completo permite. Antes de
  tentar construir um, deve-se conhecer os conceitos básicos do processo
  de inicialização do sistema, apresentados a seguir, os quais são
  suficientes para o entendimento do restante deste documento. Alguns
  detalhes e opções foram omitidos por não serem significativos para o
  conteúdo deste documento.


  33..11..  OO PPrroocceessssoo ddee IInniicciiaalliizzaaççããoo

  Todos os sistemas em microcomputadores começam o processo de
  inicialização executando o código existente na ROM  (especificamente
  no BIOS O BIOS tenta então executar este setor. Em muitos discos
  inicializáveis, o setor 0, cilindro 0, pode conter ainda:

  ·  código de um carregador de sistemas, como o LILO, o qual localiza o
     kernel do sistema escolhido, carrega e  executa, de acordo com a
     opção definida.

  ·  o início de um kernel de um sistema operacional, como por exemplo o
     Linux.

  Caso o kernel do Linux  tenha sido copiado fisicamente para um
  disquete, o primeiro setor do disco será o primeiro setor do kernel do
  Linux. O primeiro setor continuará o processo de inicialização,
  carregando o restante do kernel contido no dispositivo.

  Uma vez que o  kernel tenha sido completamente carregado, ele executa
  alguma inicialização básica de dispositivos. Ele tenta carregar e
  montar o ssiisstteemmaa ddee aarrqquuiivvooss rraaiizz

  Em algumas situações de início do sistema, freqüentemente na
  inicialização a partir de disquetes, o sistema de arquivos é montado
  em um ddiissccoo eemm mmeemmóórriiaa ssiisstteemmaa ddee aarrqquuiivvooss ccoommppaaccttaaddooss

  Uma vez que o sistema de arquivos raiz é montado, pode-se visualizar
  uma mensagem similar a:


          VFS:  Raiz montado (sistema de arquivos ext2) somente para leitura.


  ·  Execução do comando  fsck em todos os discos

  ·  Carga dos módulos

  ·  Inicialização da área de troca

  ·  Inicialização da rede

  ·  Montagem dos discos descritos em fstab.

  Este programa normalmente aciona diversos outros, tornando o processo
  de inicialização modular. Por exemplo, na estrutura comum do SysVinit,
  o diretório /etc/rc.d/ contém uma estrutura complexa de subdiretórios,
  cujos arquivos definem como iniciar e desligar a maior parte dos
  serviços do sistema. De qualquer forma, um programa sysinit em um
  disco de inicialização é normalmente muito simples.

  Quando o programa sysinit termina, o controle retorna ao  init,  o
  qual entrará no  _n_í_v_e_l _d_e _e_x_e_c_u_ç_ã_o _p_a_d_r_ã_o, especificado em  inittab,
  através da palavra chave initdefault.  A linha de nível de execução
  normalmente especifica um programa como getty,  o qual é responsável
  pelo gerenciamento das comunicações através do console e dos ttys. É o
  programa  getty que apresenta a expressão familiar ``login:''. O
  programa getty por sua vez, chama o programa login  para administrar o
  processo de validação e iniciar  as sessões dos usuários.


  33..22..  TTiippooss ddee DDiissccooss

  Após a revisão do processo básico de inicialização, podemos agora
  definir diversos tipos de discos envolvidos. Podemos classificar os
  discos em quatro tipos. A discussão aqui contida e através de todo o
  documento do uso do termo disco refere-se a disquetes, a menos que
  seja especificado o contrário, observando-se que na verdade, o
  conceito pode ser aplicado sem distinção a discos rígidos.


     iinniicciiaalliizzaaççããoo
        Um disco contendo um kernel do sistema que pode ser
        inicializado. O disco pode ser usado  para iniciar o kernel do
        sistema, o qual pode carregar o sistema de arquivos raiz a
        partir de outro disco. O kernel em um disco de inicialização
        pode receber informações sobre a localização do sistema de
        arquivos raiz.

        Freqüentemente um disco de inicialização carrega o sistema de
        arquivos raiz a partir de outro disquete, porém é possível
        configurar a carga a partir de um sistema de arquivos raiz
        residente em um disco rígido, por exemplo. Isso é comumente
        feito quando se está testando um novo kernel (na verdade ``make
        zdisk'' criará um disco de inicialização automaticamente a
        partir dos fontes do kernel).


     rraaiizz
        Um disco com um sistema de arquivos raiz contém os arquivos
        necessários para a execução de um sistema Linux. Tal disco pode
        não conter necessariamente nem o kernel e tão pouco o carregador
        de sistemas disco raiz

        Um disco raiz pode ser usado para executar o sistema
        independentemente de outros discos, uma vez que o kernel do
        sistema tenha sido inicializado. Normalmente o disco raiz é
        automaticamente copiado para um disco em memória, o que torna o
        acesso às suas informações muito mais rápido e libera a unidade
        de disquetes para outras atividades.


     iinniicciiaalliizzaaççããoo//rraaiizz
        Um disco pode conter  tanto o kernel


     uuttiilliittáárriioo
        É um disco que contém um sistema de arquivos, mas que não será
        montado como um sistema raiz. É um disco de dados adicionais, e
        pode ser utilizado para a disponibilização de utilitários, caso
        o disco raiz não tenha mais espaço disponível.


  Em geral, quando falamos de "construir um disco de inicialização"
  significa a criação das funções de carga do kernel e do sistema de
  arquivos raiz. Elas podem estar juntas (em um único disco de
  inicialização e raiz) ou separados (disco de inicialização e disco
  raiz). A abordagem mais flexível para discos de emergência é
  provavelmente usar disquetes separados, e um ou mais disquetes de
  utilitários para gerenciar o que não foi possível colocar nos
  primeiros.
  44..  CCoonnssttrruuíínnddoo uumm SSiisstteemmaa ddee AArrqquuiivvooss RRaaiizz


  Criar um sistema de arquivos raiz envolve a seleção dos arquivos
  necessários para que o sistema possa ser executado. Nesta seção
  descreveremos como construir um _s_i_s_t_e_m_a _d_e _a_r_q_u_i_v_o_s _r_a_i_z _c_o_m_p_a_c_t_a_d_o


  44..11..  VViissããoo GGeerraall

  Um sistema de arquivos raiz deve conter todo o necessário para
  suportar um sistema Linux completo. Para tanto, o disco deve incluir
  os requisitos mínimos de um sistema Linux:


  ·  A estrutura básica do sistema de arquivos

  ·  Conjunto mínimo de diretórios: /dev, /proc, /bin, /etc, /lib, /usr,
     /tmp

  ·  Conjunto básico de utilitários: sh, ls, cp, mv, etc.

  ·  Conjunto mínimo de arquivos de configuração: rc, inittab, fstab,
     etc...

  ·  Dispositivos: /dev/hd*, /dev/tty*, /dev/fd0, etc...

  ·  Biblioteca que disponibilize as funções básicas necessárias aos
     utilitário

  Evidentemente, qualquer sistema somente torna-se útil quando permite a
  execução de algum programa, e um disquete raiz somente é útil quando
  permite que sejam executadas funções como:


  ·  Verificar um sistema de arquivos em outro dispositivo, por exemplo
     para checar o sistema de arquivos raiz em um disco rígido será
     necessário carregar o sistema operacional a partir de outro
     dispositivo, o que pode ser feito com um sistema de arquivos raiz
     em disquete. Pode-se então executar fsck no dispositivo original
     que contém o sistema raiz enquanto ele não estiver montado.

  ·  Restauração total ou parcial do dispositivo raiz original a partir
     de uma cópia de segurança usando arquivamento ou utilitários de
     compactação, tais como  cpio, tar, gzip e ftape.

  Descreveremos como construir um sistema de arquivos  _c_o_m_p_a_c_t_a_d_o, assim
  chamado  porque é arquivado compactado no disco e é descompactado do
  disco para memória.  Um sistema de arquivos compactado pode conter
  diversos arquivos (aproximadamente 2 megabytes) em um disquete padrão
  1.440 Kb. Como o arquivo é muito maior que o disquete, não se pode
  construí-lo diretamente no dispositivo. Deve-se construí-lo em outro
  local qualquer, compactá-lo, e então copiá-lo para o disquete.


  44..22..  CCrriiaannddoo oo SSiisstteemmaa ddee AArrqquuiivvooss


  Para construir-se um sistema de arquivos raiz, deve-se ter um
  dispositivo extra, grande o suficiente para conter todos os arquivos
  antes da compactação. Deve-se ter à mão um dispositivo capaz de conter
  pelo menos 4 Mb. Há diversas opções:


  ·  Usar um ddiissccoo eemm mmeemmóórriiaa


             RAMDISK_SIZE = nnn


  Verifique a existência de um dispositivo como por exemplo /dev/ram0,
  /dev/ram ou /dev/ramdisk. Caso não exista, crie  /dev/ram0 com  mknod
  (maior numero 1, menor 0).

  ·  Caso se tenha uma partição de disco rígido grande o suficiente
     (diversos megabytes) disponível, esta certamente será uma boa
     solução. Caso se tenha memória RAM disponível, pode-se desligar as
     funções de troca e utilizar a partição de troca (swap).

  ·  Usar uma ssiimmuullaaccaaoo ddee ddiissppoossiittiivvoo

     PPaarraa ffaazzeerr uussoo ddaa ssiimmuullaaççããoo ddee ddiissppoossiittiivvooss,, ddeevvee--ssee uuttiilliizzaarr ooss
     pprrooggrraammaass mount e unmount especialmente alterados para isso. Eles
     podem ser encontrados no diretório:
     ftp://ftp.win.tue.nl/pub/linux/util/mount/


     Caso não se tenha uma simulação de dispositivos  (/dev/loop0,
     /dev/loop1, etc...) no sistema, pode-se criar uma através do
     comando ``mknod /dev/loop0 b 7 0''.  Uma vez instalados os binários
     especiais de mount e umount , deve-se criar um arquivo temporário
     em um disco rígido com capacidade suficiente (por exemplo,
     /tmp/fsfile). Pode-se, por exemplo, utilizar o comando:


       dd if=/dev/zero of=/tmp/fsfile bs=1k count=_n_n_n


  para criar um arquivo com  _n_n_n blocos.

  Deve-se utilizar então o nome do arquivo no lugar do DISPOSITIVO a
  seguir. Ao utilizar o comando mount deve-se incluir a opção``-o loop''
  para definir uma simulação de dispositivo.

          mount -o loop -t ext2 /tmp/fsfile /mnt


  irá montar  /tmp/fsfile (através de uma simulação de dispositivo) no
  ponto de montagem  /mnt.  Através do comando df pode-se obter a
  confirmação disso.


  Após a escolha de alguma dessas opções, deve-se preparar o DISPOSITIVO
  com o seguinte comando:


          dd if=/dev/zero of=DISPOSITIVO bs=1k count=3000


  Este comando inicializa com zeros o DISPOSITIVO. Este passo é
  importante pois o sistema de arquivos será compactado posteriormente e
  as partes não utilizadas e preenchidas com zeros, atingirão o máximo
  de compactação.


  O comando necessário será algo similar a:

       mke2fs -m 0 -i 2000 DISPOSITIVO


  (Caso se esteja usando uma simulação de dispositivos, o arquivo em
  disco que se esteja utilizando deve ser informado no lugar do
  DISPOSITIVO.

  O comando mke2fs  automaticamente detectará o espaço disponível e fará
  a configuração automaticamente. O parâmetro -m 0  evita a alocação de
  espaço para o raiz, e adicionalmente provê mais espaço útil em disco.

  A seguir deve-se montar o dispositivo:


          mount -t ext2 DISPOSITIVO /mnt


  (Deve-se criar um ponto de montagem mnt caso ele ainda não exista).
  Nas próximas seções, todos os nomes de diretórios são assumidos como
  relativos a  /mnt.


  44..33..  OOccuuppaannddoo oo SSiisstteemmaa ddee AArrqquuiivvooss


  Segue um razoável número mínimo de diretórios no sistema de arquivos
  raiz:


  ·  /dev  Dispositivos, necessários para as operações de
     Leitura/Gravação

  ·  /proc Diretório temporário requerido pelo sistema de arquivos proc

  ·  /etc  Arquivos de configuração do sistema

  ·  /sbin Binários fundamentais do sistema

  ·  /bin  Binários básicos e considerados parte do sistema

  ·  /lib  Bibliotecas compartilhadas que provêem suporte à execução dos
     binários

  ·  /mnt  Um ponto de montagem para manutenção em outros discos

  ·  /usr  Utilitários adicionais e aplicações

  (A estrutura de diretórios aqui apresentada é somente para uso no
  disquete raiz. Sistemas Linux têm uma política mais complexa e
  disciplinada, chamada Padrões de Sistemas de Arquivos, para determinar
  quais arquivos devem estar presentes e aonde.)


  Três destes diretórios devem estar vazios no sistema de arquivos raiz,
  devendo somente serem criados com o comando  mkdir.  O diretório /proc
  é basicamente um ponto de referência onde o sistema de arquivos proc
  está localizado. Os diretórios  /mnt e /usr são somente pontos de
  montagem para uso após a inicialização do sistema e a carga do sistema
  de arquivos raiz. Mais uma vez, estes diretórios somente precisam ser
  criados.

  Os quatro diretórios remanescentes estão descritos nas seções a
  seguir:
  /dev


  Um diretório /dev  contendo um arquivo especial com todos os
  dispositivos a serem utilizados pelo sistema é fundamental para o
  Linux. O diretório em si é um diretório comum e pode ser criado com o
  comando  mkdir  da forma usual. Os arquivos especiais de dispositivos
  devem ser criados de uma forma especial, utilizando-se o comando
  mknod.

  Há um atalho, podendo-se copiar o conteúdo do diretório /dev e
  apagando-se o que for desnecessário. A única exigência é que a cópia
  seja efetuada com a utilização do parâmetro -R. Isso copiará o
  diretório sem copiar o conteúdo dos arquivos.  _E_s_t_e_j_a _s_e_g_u_r_o _d_e
  _u_t_i_l_i_z_a_r _u_m _R _m_a_i_ú_s_c_u_l_o. Caso seja utilizado  r em formato minúsculo,
  provavelmente será copiado o conteúdo completo de todo o disco rígido
  -- ou no mínimo, o que couber no disquete! De qualquer forma, é
  importante estar atento ao comando:


          cp -dpR /dev /mnt


  Assumindo-se que o disquete esteja montado em /mnt.  A opção dp
  garante que ligações simbólicas serão copiadas como ligações, ao invés
  de usar um arquivo de destino, e que os atributos originais do arquivo
  serão preservados, assim como as informações sobre os donos.

  Alternativamente, pode-se usar o programa cpio  com a opção -p, uma
  vez que o cpio  lida com arquivos especiais corretamente, e não
  tentará copiar o seu conteúdo. Pode-se por exemplo, utilizar o
  seguinte comando:


       cd /dev
       find . -print | cpio -pmd /mnt/dev


  o qual irá copiar todos os arquivos especiais de  /dev para /mnt/dev.
  Na verdade, irá copiar todos os arquivos da árvore de diretórios
  iniciada em /dev,  e criará todos os subdiretórios necessários na
  árvore de diretórios de destino.

  Caso se deseje fazer da forma mais difícil, deve-se usar  ls -l  para
  mostrar os números maior e menor dos dispositivos desejados, e
  criá-los  no disquete através do comando  mknod.


  Uma vez que os dispositivos estejam copiados, é aconselhável verificar
  se todos os arquivos de dispositivos necessários foram copiados no
  disco de emergência. Por exemplo, o ftape  é utilizado por unidades de
  fitas, sendo necessário copiar todos eles, caso se pretenda acessar um
  dispositivo desse tipo a partir do disco de inicialização.

  Note que um inode é necessário para cada tipo de arquivo especial de
  dispositivo, e

  _D_e_v_e_-_s_e _n_e_c_e_s_s_a_r_i_a_m_e_n_t_e _t_e_r _o_s _s_e_g_u_i_n_t_e_s _a_r_q_u_i_v_o_s _n_e_s_t_e _d_i_r_e_t_ó_r_i_o_:
  console, kmem, mem, null, ram, tty1.

  /etc


  Este diretório deve conter uma série de arquivos de configuração. Na
  maioria dos sistemas este pode estar dividido em três grupos:


  1. Sempre requeridos, _p_o_r _e_x_e_m_p_l_o rc, fstab, passwd

  2. Podem ser requeridos, mas não há como assegurar

  3. Arquivos desnecessários

  Arquivos que não são essenciais podem ser identificados através do
  comando:


               ls -ltru


  Este comando gera uma lista em ordem inversa de último acesso,
  dependendo de que arquivos não são acessados ou utilizados e que,
  podem não estar presentes no disquete raiz.

  Nos nossos disquetes raiz, temos um número de arquivos de configuração
  inferior a 15. Isso reduz o trabalho de lidar com um conjunto de três
  tipos de arquivos.


  1. Os arquivos que devem ser configurados para um  sistema:


     a. rc.d/* início do sistema e definição dos programas de cada nível
        de execução

     b. fstab lista dos sistemas de arquivos que devem ser montados

     c. inittab parâmetros para o processo init , o primeiro que é
        executado em tempo de inicialização do sistema.


  2. Estes devem ser customizados para a inicialização de um sistema:

     a. passwd lista de usuários, diretórios pessoais, etc...

     b. group grupos de usuários

     c. shadow senha dos usuários. Eventualmente pode não existir.


     Caso a segurança seja um item importante do sistema específico,
     passwd  e shadow  devem ser  suprimidos, a fim de evitar a cópia de
     senhas de usuários para fora do sistema, e quando o sistema for
     inicializado através de disquetes, acessos indesejados serão
     rejeitados. De qualquer forma, há uma razão para  _n_ã_o suprimir
     passwd e  group. O tar (e provavelmente outros programas de
     arquivamento) armazenam o usuário e o grupo junto com os dados dos
     arquivos. Caso estes arquivos sejam restaurados no disco rígido a
     partir de uma fita, os arquivos serão restaurados com seus nomes
     originais. Caso os nomes dos donos e grupos não existam em
     passwd/group  durante a restauração,  as identificações de usuários
     e grupos (UID e GID) não estarão corretas.
     Esteja certo de que o arquivo passwd contém ao menos o superusuário
     (root).  Caso se pretenda utilizar outros usuários para acessar o
     sistema, deve-se estar seguro da existência de seus diretórios
     pessoais e interpretadores de comando (shell).


  3. Os demais: verificaremos mais adiante as informações sobre este
     tópico.

  Além disso, deve-se somente configurar dois arquivos, e o que eles
  devem conter é surpreendentemente pequeno.

  ·  rc deve conter

             #!/bin/sh
             /bin/mount -av
             /bin/hostname Conectiva


  Deve-se estar seguro de que os diretórios estão corretos. A execução
  de hostname  não é obrigatória, somente dá um melhor acabamento ao
  trabalho.

  ·  fstab deve conter, no mínimo:


             /dev/ram0       /               ext2    defaults
             /dev/fd0        /               ext2    defaults
             /proc           /proc           proc    defaults


  Pode-se copiar as entradas de um arquivo  fstab, já existente, mas não
  se deve montar automaticamente qualquer partição do disco rígido;
  usando-se então o parâmetro noauto, pois o disco rígido pode estar
  danificado ou sem condições de uso no momento da inicialização do
  sistema.


  O inittab deve ser alterado, de outra forma a linha  sysinit executará
  o  rc ou qualquer outro programa básico de inicialização que seja
  indicado. Ainda para assegurar-se de que usuários em portas seriais
  não poderão acessar o sistema, pode-se comentar todas as entradas em
  getty que incluam  dispositivos ttys ou ttyS  ao final da linha. Deve-
  se deixar as portas tty para poder-se acessar o sistema a partir do
  console.

  Um arquivo inittab mínimo contém:

          id:2:initdefault:
          si::sysinit:/etc/rc
          1:2345:respawn:/sbin/getty 9600 tty1
          2:23:respawn:/sbin/getty 9600 tty2


  O arquivo inittab define o que o sistema executará nos vários estados,
  inclusive no seu início, em modo multiusuário, etc... Um ponto no qual
  deve-se ter muito cuidado é o de verificar se todos os comandos
  informados em inittab referem-se a programas presentes e se o
  diretório está corretamente indicado. Caso se coloque no disco de
  emergência os arquivos de comandos apresentados  na Seção ``Listas de
  exemplo do conteúdo do disco de inicialização''  como um guia, e após
  se copie o  inittab  para o disco sem uma verificação cuidadosa,
  provavelmente ele falhará, e o problema terá origem na ausência de
  arquivos ou indicações erradas de diretórios.

  Note que alguns comandos não podem ser movidos para qualquer outro
  lugar, porque têm a sua localização dentro de seu código. Por exemplo
  em nosso sistema, o /etc/shutdown tem a sua localização definida no
  fonte do comando /etc/reboot. Caso reboot seja movido para
  /bin/reboot, e após seja executado o comando shutdown, ele falhará,
  porque o arquivo reboot não pode ser localizado.


  Para todo o restante, deve-se simplesmente copiar os arquivos texto no
  diretório /etc, mais os executáveis do mesmo diretório que não possam
  ser definidos como desnecessários. Como um guia, pode-se consultar os
  exemplos na Seção ``Listas de exemplo do conteúdo do disco de
  inicialização''. Provavelmente será suficiente copiar somente aqueles
  arquivos, porém sistemas podem ser muito diferentes, então não se pode
  estar seguro de que a lista apresentada seja suficiente. O único
  método de estar seguro é iniciar o sistema com inittab e verificar o
  que é solicitado.

  Muitos sistemas utilizam um diretório /etc/rc.d/ contendo roteiros do
  interpretador de comandos de diferentes níveis de execução. O mínimo é
  um simples programa rc, mas pode ser mais simples copiar o inittab e o
  diretório /etc/rc.d de um sistema já existente, e suprimir os roteiros
  no diretório rc.d para remover os processamentos não relevantes do
  ambiente de sistema em disquete.

  /bin e /sbin


  O diretório /bin  é um lugar adequado para utilitários extras
  necessários à execução de atividades básicas. Utilitários como ls, mv,
  cat e dd.Veja o Apêndice ``Listagem de exemplo de conteúdo do disco de
  inicialização'' para um exemplo da lista de arquivos que podem estar
  presentes nos diretórios /bin e /sbin. Ela não inclui nenhum
  utilitário requerido para restaurar cópias de segurança, tais como
  cpio, tar e gzip. Isso porque estes programas foram colocados em um
  disquete de utilitários em separado, visando economizar espaço no
  disquete de inicialização e raiz. Uma vez que o disquete de
  inicialização tenha sido carregado, ele é copiado para o disco em
  memória, deixando a unidade de disquetes livre para montar outro
  disquete, o disquete de utilitários. Normalmente montamos esse
  disquete como /usr.

  A criação de um disquete de utilitários

  _E_s_t_e_j_a _s_e_g_u_r_o _d_e _i_n_c_l_u_i_r _o_s _s_e_g_u_i_n_t_e_s _p_r_o_g_r_a_m_a_s_: init, getty ou
  equivalente, login, mount, algum interpretador que possa executar os
  programas rc, e uma ligação de sh para o interpretador de comandos.


  /lib


  No diretório /lib deve-se colocar as bibliotecas compartilhadas e seus
  carregadores. Caso as bibliotecas necessárias não sejam encontradas no
  diretório /lib, o sistema não poderá ser iniciado. Com um pouco de
  sorte pode-se receber uma mensagem de erro dizendo a razão.

  Praticamente todos os programas requerem no mínimo a biblioteca libc,
  libc.so._N, onde _N é o número da versão corrente. Ao verificar o
  diretório /lib, libc.so.5 é normalmente uma ligação simbólica para um
  arquivo com o número completo da versão.


  % ls -l /lib/libc.so*
  lrwxrwxrwx  1 root root      14 Nov  1 20:34 /lib/libc.so.5 -> libc.so.5.4.33*
  -rwxr-xr-x  1 root root  573176 Jun 12 02:05 /lib/libc.so.5.4.33*


  Neste caso, tem-se disponível o arquivo libc.so.5.4.33. Para encontrar
  outras bibliotecas deve-se verificar todos os binários necessários e
  verficar as suas dependências com o comando ldd . Por exemplo:


          % ldd /sbin/mke2fs
                  libext2fs.so.2 => /lib/libext2fs.so.2
                  libcom_err.so.2 => /lib/libcom_err.so.2
                  libuuid.so.1 => /lib/libuuid.so.1
                  libc.so.5 => /lib/libc.so.5


  O arquivo apresentado na coluna da direita é necessário, tendo-se em
  mente que as bibliotecas listadas podem ser ligações simbólicas.

  Em  /lib deve-se ainda incluir um carregador de bibliotecas.  ou ld-
  linux.so (para bibliotecas ELF).


  % file /lib/libc.so.5.4.33 /lib/libc.so.4.7.2
    /lib/libc.so.4.7.2: Linux/i386 demand-paged executable (QMAGIC), stripped
    /lib/libc.so.5.4.33: ELF 32-bit LSB shared object, Intel 386, version 1, stripped


  QMAGIC indica que 4.7.2 é para bibliotecas a.out, e ELF indica que
  5.4.33 é para ELF.

  Deve-se então copiar o(s) carregador(es) necessário(s) para o sistema
  de arquivos raiz em construção. Bibliotecas e carregadores devem ser
  checados _c_u_i_d_a_d_o_s_a_m_e_n_t_e com o binários incluídos. Caso o kernel não
  possa carregar a biblioteca necessária, normalmente haverá um
  travamento sem mensagens de erro.


  44..44..  MMóódduullooss

  Caso se tenha um kernel modular, deve-se considerar quais módulos
  devem ser carregados a partir do disco de inicialização após o início
  do sistema. Pode-se incluir os módulos ftape e zftape caso cópias de
  segurança tenham sido feitas em um fita, módulos para dispositivos
  SCSI caso eles estejam presentes, e módulos para suporte a PPP ou SLIP
  caso se queira acesso a rede em uma emergência.

  Estes módulos podem ser colocados em /lib/modules. Deve-se ainda
  incluir  insmod, rmmod e lsmod.

  Caso se deseje carregar os módulos automaticamente, pode-se incluir
  ainda modprobe, depmod e swapout.  E caso se use o kerneld, deve-se
  incluir ainda o  /etc/conf.modules.

  A principal vantagem de utilizar módulos reside no fato de poder mover
  módulos não essenciais para um disco de utilitários e carregá-los
  quando necessário, usando menos espaço no disco raiz. Porém, caso seja
  necessário lidar com muitos dispositivos diferentes, uma abordagem
  mais adequada pode  residir em construir um único kernel com diversos
  módulos integrados.

  _N_o_t_e _q_u_e _p_a_r_a _s_e _t_e_r _u_m _s_i_s_t_e_m_a _d_e _a_r_q_u_i_v_o_s _e_x_t_2 _c_o_m_p_a_c_t_a_d_o_, _é
  _o_b_r_i_g_a_t_ó_r_i_a _a _e_x_i_s_t_ê_n_c_i_a _d_e _s_u_p_o_r_t_e _a _d_i_s_c_o _e_m _m_e_m_ó_r_i_a _e  _s_i_s_t_e_m_a_s _d_e
  _a_r_q_u_i_v_o_s _e_x_t_2. Estes não podem ser disponibilizados como módulos.


  44..55..  AAllgguunnss ddeettaallhheess ffiinnaaiiss


  Alguns programas de sistema, como o  login, apresentam mensagem de
  advertência caso o arquivo /var/run/utmp e o diretório  /var/log não
  existam.


          mkdir -p /mnt/var/{log,run}
          touch /mnt/var/run/utmp


  Finalmente, após ter-se configurado todas as bibliotecas necessárias,
  deve-se executar o ldconfig  para gerar novamente o  /etc/ld.so.cache
  no sistema de arquivos raiz. O cache diz ao carregador onde encontrar
  as bibliotecas. Para reconstruir  o ld.so.cache, execute os seguintes
  comandos:


          chdir /mnt; chroot /mnt /sbin/ldconfig


  O comando chroot  é necessário porque  ldconfig  sempre gera o cache
  para o sistema de arquivos raiz.


  44..66..  EEmmppaaccoottaannddoo


  Uma vez concluída a construção do sistema de arquivos raiz, ele deve
  ser desmontado, copiado para um arquivo e compactado:


          umount /mnt
          dd if=DISPOSITIVO bs=1k | gzip -v9 > saraiz.gz


  Isso pode levar diversos minutos. Ao finalizar estará disponível um
  arquivo saraiz.gz  que é o sistema de arquivos raiz compactado. Deve-
  se verificar se o arquivo cabe em um disquete. Caso não caiba, deve-se
  retornar aos passos anteriores e eliminar alguns arquivos. A Seção
  ``Reduzindo o tamanho de um sistema de arquivos raiz'' fornece algumas
  dicas sobre a redução de tamanho do sistema de arquivos raiz.


  55..  EEssccoollhheennddoo uumm kkeerrnneell


  Neste ponto tem-se disponível um sistema de arquivos raiz compactado.
  O próximo passo é construir um kernel ou selecionar um kernel. Em
  muitos casos é possível copiar o kernel atual e inicializar o sistema
  a partir do disquete. Porém em muitos casos poderá ser necessário
  construir um em separado.

  Uma das razões é o tamanho. Caso se esteja construindo um único
  disquete de inicialização e raiz, o kernel será um dos maiores
  arquivos no disquete e será necessário reduzí-lo o máximo possível.
  Caso se esteja construindo dois discos (um de inicialização e um
  raiz), isso não será problema pois o kernel irá em um disquete
  separado.

  Para reduzir seu tamanho, deve-se construir um kernel com o mínimo de
  facilidades necessárias ao suporte do sistema desejado. Isso
  significa, deixar de lado tudo que não seja absolutamente necessário.
  Suporte a rede é um dos prováveis candidatos, assim como suporte a
  unidades de disco e outros dispositivos desnecessários durante o
  início do sistema. Conforme descrito anteriormente, o kernel  _d_e_v_e ter
  suporte a disco em memória e ext2 .

  Após incluir somente o mínimo necessário de facilidades no kernel,
  deve-se verificar o que deve retornar. Provavelmente um dos usos mais
  comuns a um disquete de inicialização e raiz é a restauração de
  sistemas de arquivos raiz com problemas, e para que isso seja possível
  é necessário suporte no kernel do sistema. Por exemplo, caso as cópias
  de segurança tenham sido efetuadas em fita, utilizando Ftape para
  acessar uma unidade de fita,  então será obrigatória a presença de
  suporte a dispositivos de fitas para efetuar uma restauração. Caso não
  esteja presente, poderá ser necessário reinstalar o Linux, copiar e
  reinstalar ftape, e então tentar  ler as cópias de segurança.

  O ponto aqui é, qualquer suporte a leitura e gravação que seja
  adicionado ao kernel para suportar cópias de segurança, deve também
  ser adicionado ao kernel de inicialização do sistema em disquete de
  emergência.


  O procedimento para construir um kernel é descrito na documentação que
  o acompanha. É relativamente simples, podendo-se verificar o conteúdo
  de  /usr/src/linux.  Note que caso se tenha problemas construindo um
  novo kernel, então provavelmente não se deve tentar construir um disco
  de inicialização. Deve-se lembrar de compactar o kernel  através do
  comando ``make zImage''.


  66..  CCoollooccaannddoo ttuuddoo jjuunnttoo:: CCoonnssttrruuiinnddoo oo((ss)) ddiissccoo((ss))


  Neste ponto, tem-se um kernel e um sistema de arquivos raiz. Caso se
  esteja construindo um único disco de inicialização e raiz, deve-se
  verificar o seu tamanho e estar seguro de que eles caberão em um único
  disco. Caso se esteja construindo dois discos, deve-se verificar se o
  sistema de arquivos cabe em um único disquete.

  Deve-se decidir pelo uso ou não do LILO no disquete de inicialização
  do kernel. A alternativa será copiar o kernel diretamente no disquete
  e iniciar o sistema sem o LILO.  A vantagem de utilizar o LILO reside
  na possibilidade de passagens de parâmetros para o kernel, o que pode
  ser necessário para inicializar algum equipamento (deve-se verificar o
  conteúdo do arquivo /etc/lilo.conf.  Caso exista alguma linha do tipo
  ``append=...'', provavelmente esta facilidade será necessária). A
  desvantagem de usar o LILO é que a construção do disco de
  inicialização torna-se mais complexa e  mais espaço é necessário.
  Deve-se construir um pequeno sistema de arquivos em separado, o qual
  nós denominamos ssiisstteemmaa ddee aarrqquuiivvooss ddoo kkeerrnneell, para onde se pode
  transferir o kernel e algumas outras coisas necessárias para o LILO.


  Caso se vá utilizar o LILO, siga adiante, caso contrário pode-se ir
  diretamente para a seção  ``Transferindo o kernel sem o LILO''.


  66..11..  TTrraannssffeerriinnddoo oo kkeerrnneell ccoomm oo  LLIILLOO


  O primeiro item que deve ser criado é um pequeno arquivo de
  configuração do LILO. Ele deve ser similar ao seguinte:


  ______________________________________________________________________
          boot      =/dev/fd0
          install   =/boot/boot.b
          map       =/boot/map
          read-write
          backup    =/dev/null
          compact
          image     = KERNEL
          label     = Disquete_Inic
          root      =/dev/fd0
  ______________________________________________________________________


  Para obter detalhes destes parâmetros, por favor verifique a
  documentação de usuário do LILO. Pode ser desejável ainda adicionar a
  linha append=...  copiada do arquivo /etc/lilo.conf existente em
  disco.

  Deve-se salvar o arquivo como  bdlilo.conf e a seguir criar um pequeno
  sistema de arquivos, o qual será denominado


  Inicialmente, deve-se verificar o tamanho que o sistema de arquivos
  terá. Verifique o tamanho do kernel em blocos (o tamanho é mostrado
  através do comando ``ls -l KERNEL''  dividido por 1024 e arredondado
  para cima) e acrescido de 50, referentes ao espaço necessário aos
  inodes e outros arquivos. Pode-se calcular o número exato ou
  simplesmente utilizar 50. Caso se esteja criando um conjunto com dois
  disquetes, pode-se superestimar o espaço usado pelo kernel.
  Denominaremos este número de NÚCLEO_BLOCOS.

  Deve-se colocar um disquete no dispositivo (para simplificar
  assumiremos que será em  /dev/fd0) e após criar um sistema de arquivos
  tipo ext2 para o kernel:


          mke2fs -i 8192 -m 0 /dev/fd0 NÚCLEO_BLOCOS


  O parâmetro ``-i 8192'' especifica que desejamos um inode para cada
  8192 bytes. Após, deve-se montar o sistema de arquivos, remover o
  diretório lost+found e criar os diretórios dev e boot para o  LILO:


          mount /dev/fd0 /mnt
          rm -rf /mnt/lost+found
          mkdir /mnt/{boot,dev}


  Após, deve-se criar os dispositivos /dev/null e /dev/fd0. Ao invés de
  procurar pelos números dos dispositivos, pode-se simplesmente copiá-lo
  do disco rígido utilizando-se -R:


          cp -R /dev/{null,fd0} /mnt/dev


  O LILO necessita de uma cópia de seu  carregador de inicialização,
  boot.b,  o qual pode ser encontrado no disco rígido, normalmente no
  diretório  /boot .


          cp /boot/boot.b /mnt/boot


  Finalmente, deve-se copiar os arquivos de configuração do LILO criado
  conforme a seção anterior, assim como o kernel. Ambos devem estar
  presentes no diretório raiz:


          cp bdlilo.conf KERNEL /mnt


  Todo o necessário para que o LILO possa ser executado está presente no
  sistema de arquivos do kernel. Deve-se então executar o   LILO com o
  parâmetro -r  para instalar o carregador de inicialização :


          lilo -v -C bdlilo.conf -r /mnt


  O LILO deverá ser executado sem erros, após o qual o sistema de
  arquivos do kernel deve ter a seguinte aparência:


  ______________________________________________________________________
  total 361
    1 -rw-r--r--   1 root     root          176 Jan 10 07:22 bdlilo.conf
    1 drwxr-xr-x   2 root     root         1024 Jan 10 07:23 boot/
    1 drwxr-xr-x   2 root     root         1024 Jan 10 07:22 dev/
  358 -rw-r--r--   1 root     root       362707 Jan 10 07:23 vmlinuz
  boot:
  total 8
    4 -rw-r--r--   1 root     root         3708 Jan 10 07:22 boot.b
    4 -rw-------   1 root     root         3584 Jan 10 07:23 map
  dev:
  total 0
    0 brw-r-----   1 root     root       2,   0 Jan 10 07:22 fd0
    0 crw-r--r--   1 root     root       1,   3 Jan 10 07:22 null
  ______________________________________________________________________


  Não há motivos para preocupação caso os tamanhos de arquivos sejam um
  pouco diferentes.

  Pode-se ir agora para a seção ``Configurando o disco em memória''.


  66..22..  TTrraannssffeerriinnddoo oo kkeerrnneell sseemm oo LLIILLOO


  Caso  _n_ã_o  se esteja utilizando o LILO, o kernel pode ser transferido
  para o disco de inicialização com o comando dd :


          % dd if=KERNEL of=/dev/fd0 bs=1k
          353+1 records in
          353+1 records out


  Neste exemplo, dd  gravou 353 registros completos e 1 parcialmente,
  concluindo-se que o kernel ocupou 354 blocos do disquete.
  Denominaremos este número como NÚCLEO_BLOCOS , o qual será utilizado
  na próxima seção.

  Finalmente, deve-se configurar o disquete como o dispositivo raiz e
  dar-lhe permissões de leitura e gravação:


          rdev /dev/fd0 /dev/fd0
          rdev -R /dev/fd0 0


  Deve-se ter o máximo cuidado ao usar o -R maiúsculo no comando  rdev .


  66..33..  CCoonnffiigguurraannddoo oo ddiissccoo eemm mmeemmóórriiaa


  Dentro da imagem do kernel está a  ppaallaavvrraa ((ddooiiss oouu mmaaiiss bbyytteess)) ddee
  ccoonnffiigguurraaççããoo ddoo ddiissccoo eemm mmeemmóórriiaa que especifica onde o sistema de
  arquivos raiz deve ser encontrado, em conjunto com as suas opções. A
  palavra  é definida em  /usr/src/linux/arch/i386/kernel/setup.c e é
  interpretada da seguinte forma:


  bits  0-10:     deslocamento para início da memória, em blocos de 1024 bytes
  bits 11-13:     sem utilização
  bit     14:     Indicador se o disco em memória deve ser carregado
  bit     15:     Indicador de prompt antes da carga do sistema de arquivos raiz


  Caso o bit 15 esteja configurado, no processo de inicialização será
  solicitada a inserção de um novo disquete na unidade. Isso é
  necessário no caso de conjuntos de dois disquetes de inicialização.

  Há dois casos, dependendo da construção de um único disquete ou de um
  conjunto de dois disquetes (inicialização e raiz).


  1. Caso se esteja construindo um único disco, o sistema de arquivos
     raiz será colocado exatamente após o kernel, sendo o deslocamento
     então igual ao primeiro bloco livre (o que deve ser igual a
     NÚCLEO_BLOCOS).  O bit 14 será configurado com 1 e o bit 15 com
     zero.

  2. Caso se esteja construindo um conjunto de dois disquetes, o sistema
     de arquivos raiz começará no bloco zero e o deslocamento será igual
     a zero. Bit 14 será igual a 1 e o bit 15 também será igual a 1.

     Após calcular cuidadosamente o valor da palavra de disco em
     memória, deve-se configurá-la com  rdev -r.


          rdev -r NÚCLEO_OU_UNIDADE_DE_DISQUETE

  Caso se esteja utilizando o LILO, a unidade de disquetes deve ser
  desmontada agora.


  66..44..  TTrraannssffeerriinnddoo oo ssiisstteemmaa ddee aarrqquuiivvooss rraaiizz


  O último passo é a transferência do sistema de arquivos raiz.


  ·  Caso o sistema de arquivos raiz seja colocado no  _m_e_s_m_o disco que o
     kernel, a transferência deve ser efetuada utilizando-se o comando
     dd com a opção seek,  a qual especifica quantos blocos devem ser
     ignorados até que a gravação tenha início:


             dd if=rootfs.gz of=/dev/fd0 bs=1k seek=BLOCOS_NÚCLEO


  ·  Caso o sistema de arquivos raiz seja colocado em um  _s_e_g_u_n_d_o disco,
     deve-se remover o primeiro disquete e colocar o segundo na unidade,
     transferindo-se o sistema de arquivos raiz:


             dd if=rootfs.gz of=/dev/fd0 bs=1k


  Parabéns, serviço concluído!

  DDEEVVEE--SSEE SSEEMMPPRREE TTEESSTTAARR UUMM DDIISSCCOO DDEE IINNIICCIIAALLIIZZAAÇÇÃÃOO AANNTTEESS DDEE GGUUAARRDDÁÁ--LLOO,,
  PPAARRAA UUSSOO EEMM UUMMAA EEMMEERRGGÊÊNNCCIIAA


  77..  PPrroobblleemmaass


  Na construção de discos de inicialização, as primeiras tentativas
  normalmente gerarão discos com problemas. A abordagem de construção de
  um disco raiz é montar seus componentes a partir de um sistema já
  existente e tentar construir um disquete baseado nele  que viabilize a
  carga do sistema até o momento em que mensagens possam ser
  apresentadas na console. Após esse passo, cabe verificar as mensagens
  e os erros apresentados, e ir corrigindo um a  um, de acordo com o
  apresentado no console. Caso o sistema simplesmente trave, sem maiores
  explicações, encontrar a causa será um pouco mais difícil. Para ter-se
  um sistema que possa chegar ao estágio de enviar mensagens para o
  console, são requeridos diversos componentes, que devem estar
  presentes e corretamente configurados. O procedimento recomendado na
  investigação de um problema onde o sistema não apresente a sua causa é
  o seguinte:

  ·  Verificar se o disco raiz contém realmente os diretórios
     necessários. É comum copiar de níveis errados e ter algo como
     /discoraiz/bin ao invés de  /bin no disquete.

  ·  Verificar se existe /lib/libc.so com a mesma ligação que aparece no
     diretório /lib do disco rígido.

  ·  Verificar se todas as  ligações simbólicas no diretório  /dev
     existem  no sistema de arquivos raiz do disquete, onde aquelas
     ligações devem ser para dispositivos que estão inclusos no disco
     raiz. Em particular, ligações para /dev/console são fundamentais em
     diversos casos.
  ·  Verificar se os arquivos /dev/tty1, /dev/null, /dev/zero, /dev/mem,
     /dev/ram e /dev/kmem foram incluídos.

  ·  Verificar se a configuração do kernel suporta todos os recursos
     requeridos até o momento de acesso ao sistema e se estão
     adicionados ao kernel de forma residente e não como módulos.
     _S_u_p_o_r_t_e _a _d_i_s_c_o_s _e_m _m_e_m_ó_r_i_a _e _e_x_t_2 _d_e_v_e_m _e_s_t_a_r _r_e_s_i_d_e_n_t_e_s.

  ·  Verificar se as configurações do dispositivo  raiz e do kernel e o
     disco em memória estão corretas.

  Alguns deste aspectos gerais são melhor detalhados a seguir:


  1. Esteja certo de que  init foi incluído como  /sbin/init ou
     /bin/init e  que tem permissão de execução.

  2. Execute  ldd init para checar as bibliotecas necessárias à execução
     do init. Normalmente é necessária somente libc.so. Esteja certo de
     que todas as bibliotecas e carregadores foram incluídos.

  3. Esteja certo de utilizar o carregador correto para as bibliotecas
     --- ld.so para a.out ou ld-linux.so para ELF.

  4. Verificar se o arquivo /etc/inittab no sistema de arquivos do
     disquete de inicialização, aponta para o programa getty (ou algum
     programa similar a  getty, como por exemplo agetty, mgetty ou
     getty_ps).

  5. Assim como realizado com  init, execute ldd em getty para verificar
     as dependências, esteja certo de que as bibliotecas necessárias e
     carregadores estão presentes no sistema de arquivos raiz.

  6. Esteja seguro de ter incluído um shell script (por exemplo, bash ou
     ash), capaz de executar todos os programas rc .

  7. Caso se tenha um arquivo  /etc/ld.so.cache no disco de emergência,
     refaça-o.


  Caso init comece, mas seja obtida a seguinte mensagem:

          Id xxx respawning too fast: disabled for 5 minutes


  ela é oriunda do init, normalmente indicando que  os programas getty
  ou login estão sendo encerrados imediatamente após o seu início.

  Caso ao se tentar executar algum programa, tal como  df,  presente no
  disco de emergência, e obtêm-se mensagens como: df: não encontrado,
  deve-se verificar: (1) o diretório que contém o comando está
  configurado na variável de ambiente PATH, e (2) todas as bibliotecas e
  carregadores necessários ao programa estão presentes.


  88..  DDiivveerrssooss


  88..11..  RReedduuzziinnddoo oo ttaammaannhhoo ddoo ssiisstteemmaa ddee aarrqquuiivvooss rraaiizz


  Algumas vezes o sistema de arquivos raiz é muito grande para caber em
  um disquete, mesmo após a sua compactação. Seguem algumas formas de
  reduzir seu tamanho, listadas em ordem decrescente de efetividade:


     AAuummeennttaarr aa ddeennssiiddaaddee ddoo ddiissccoo
        Por padrão, disquetes são formatados em 1400K, mas  formatos de
        maior densidade estão disponíveis. fdformat poderá formatar nos
        seguintes tamanhos: 1600, 1680, 1722, 1743, 1760, 1840, e 1920.
        Muitos dispositivos de 1440K suportarão  1722K, e é este que
        sempre usamos para disquetes de inicialização. A página de
        manual fdformat e  o arquivo
        /usr/src/linux/Documentation/devices.txt fornecem maiores
        informações sobre o tema.


     AAlltteerraarr oo iinntteerrpprreettaaddoorr ddee ccoommaannddooss
        Alguns dos mais populares interpretadores de comando para Linux,
        como  bash e tcsh, são grandes e requerem diversas bibliotecas.


     DDiimmiinnuuiirr aass bbiibblliiootteeccaass ee ooss bbiinnáárriiooss


                objcopy --strip-all FROM TO


     Ao copiar bibliotecas deve ser usado:


             objcopy --strip-debug FROM TO


     MMoovveerr aarrqquuiivvooss nnããoo ccrrííttiiccooss ppaarraa uumm ddiissccoo ddee uuttiilliittáárriiooss
        Caso alguns binários não sejam necessários durante a
        inicialização ou no acesso ao sistema, eles podem ser movidos
        para um disquete adicional. Veja a Seção ``Construindo um
        disquete de utilitários'' para maiores detalhes. Deve-se ainda
        considerar também a movimentação de módulos.


  88..22..  SSiisstteemmaass ddee aarrqquuiivvooss rraaiizz nnããoo rreessiiddeenntteess eemm ddiissccooss nnaa mmeemmóórriiaa


  A Seção ``Construindo um sistema de arquivos raiz'' apresenta
  instruções sobre como construir um sistema de arquivos raiz compactado
  o qual é carregado em um disco em memória quando o sistema é iniciado.
  Este método tem diversas vantagens e é o mais comumente utilizado. De
  qualquer forma, alguns sistemas com pouca memória podem não suportar
  toda a RAM necessária para isso; e nestes casos o sistema de arquivos
  raiz é montado diretamente ao invés de ser copiado para um disco em
  memória.

  Tais sistemas de arquivos são na verdade mais simples de serem
  construídos do que sistemas compactados, uma vez que eles podem ser
  construídos tanto em disquetes como em qualquer outro dispositivo, e
  não têm que ser compactados. Apresentaremos os procedimentos
  necessários e as suas diferenças em relação ao descrito até aqui. Caso
  seja esta a sua opção, deve-se ter em mente que se terá  _m_u_i_t_o _m_e_n_o_s
  _e_s_p_a_ç_o  disponível.


  1. Calcular o espaço disponível para os arquivos do sistema de
     arquivos raiz.

     Caso se esteja construindo um único disco de inicialização e raiz,
     todos os blocos do kernel mais os do sistema de arquivos raiz devem
     caber em um disquete.

  2. Utilizar o programa  mke2fs, para criar um sistema de arquivos raiz
     em um disquete com o tamanho apropriado.

  3. Incluir os arquivos do sistema de arquivos conforme descrito acima.

  4. Ao finalizar, desmontar o sistema de arquivos e transferi-lo para
     um arquivo de disco, _s_e_m _c_o_m_p_a_c_t_a_ç_ã_o.

  5. Transferir o kernel para um disquete, conforme descrito
     anteriormente. Ao calcular a palavra do disco em memória,
     ccoonnffiigguurraarr oo bbiitt 1144 ppaarraa zzeerroo, para indicar que o sistema de
     arquivos raiz não será carregado para um disco em memória. Executar
     o comando  rdev conforme descrito.

  6. Transferir o sistema de arquivos raiz conforme descrito
     anteriormente.

     Há diversos atalhos que podem ser executados. Caso se esteja
     construindo um conjunto de dois disquetes, pode-se construir o
     sistema de arquivos raiz diretamente no segundo disquete, não sendo
     necessário transferi-lo para o disco rígido e após para o disquete
     novamente. Ainda, caso se esteja construindo um único disquete de
     raiz e inicialização utilizando-se o LILO, pode-se construir  um
     _ú_n_i_c_o sistema de arquivos no disco inteiro, contendo o kernel,
     arquivos do LILO e do raiz, e simplesmente executar o LILO como o
     último passo.


  88..33..  CCoonnssttrruuiinnddoo uumm ddiissqquueettee ddee uuttiilliittáárriiooss


  Construir um disquete de utilitários é bastante simples, basta
  simplesmente criar um sistema de arquivos em um disquete formatado e
  copiar os arquivos para ele. Para usá-lo com o disco de inicialização,
  deve-se montá-lo manualmente após o sistema ser carregado.

  Conforme descrito anteriormente, o disquete de utilitários  pode ser
  montado como /usr.  Neste caso, os binários podem ser colocados no
  diretório /bin no disquete de utilitários, sendo que uma indicação a
  /usr/bin na variável de ambiente de caminho permitirá o acesso direto
  a eles. Bibliotecas adicionais podem ser colocadas no diretório  /lib
  no disquete de utilitários.

  Há vários pontos importantes  para atentar-se ao se construir um disco
  de utilitários, a saber:


  1. _N_ã_o colocar binários ou bibliotecas que sejam críticos para o
     início do sistema, uma vez que o disquete não será montado antes da
     inicialização do sistema.

  2. Não é possível acessar uma unidade de disquete e uma unidade de
     fita simultaneamente. Isso significa que caso se tenha uma unidade
     de fita, não será possível acessá-la enquanto o disco de
     utilitários estiver montado.


  3. O acesso aos arquivos no disco de utilitários será lento.


  Apêndice ``Listas de exemplo do conteúdo do disco de utilitários''
  mostra um lista de exemplo de arquivos em um disquete de utilitários.
  Aqui estão colocadas algumas idéias que podem ser úteis: programas
  para examinar e manipular discos ( (format, fdisk) e sistemas de
  arquivos (mke2fs, fsck, isofs.o), um editor de textos leve (elvis,
  jove), utilitários de compactação e arquivamento (gzip, tar, cpio,
  afio), utilitários para fitas (mt, tob, taper), comunicação (ppp.o,
  slip.o, minicom) e dispositivos (setserial, mknod).


  99..  CCoommoo ooss pprrooffiissssiioonnaaiiss ffaazzeemm iissssoo


  É possível perceber que os discos de inicialização das maiores
  distribuições, tais como Conectiva Linux, Red Hat, Slackware ou
  Debian, parecem ser mais sofisticados do que o descrito neste
  documento. Discos de inicialização de distribuições profissionais são
  baseados nos mesmos princípios aqui descritos, mas empregam alguns
  detalhes adicionais, uma vez que devem atender a um número maior de
  sistemas e situações. Inicialmente, eles devem ser capazes de
  funcionar com uma grande variedade de hardwares, sendo necessário
  então interagir com o usuário e carregar diversos arquivos de
  dispositivos. Segundo, eles devem ser preparados para trabalhar com
  diversas opções de instalação, com diferentes níveis de automação.
  Finalmente, distribuições normalmente combinam  funcionalidades de
  instalação e emergências.

  Alguns discos de inicialização contém uma funcionalidade chamada
  iinniittrrdd (ddiissccoo eemm mmeemmóórriiaa iinniicciiaall).
  <ftp://elserv.ffm.fgan.de/pub/linux/loadlin-1.6/initrd-example.tgz>.

  As informações a seguir são um resumo dos discos de instalação de cada
  uma das distribuições, baseado na inspeção de seus sistemas de
  arquivos e dos códigos fontes. Não podemos garantir a exata acuidade
  das informações aqui descritas, ou se elas forem alteradas em novas
  versões.


  Slackware (v.3.1) usa uma inicialização similar a um LILO descrito na
  seção ``Transferindo o kernel com o  LILO''.  O disco de inicialização
  do Slackware apresenta uma mensagem (``Bem-vindo ao disco de
  inicialização do kernel do Slackware Linux!'') usando o parâmetro
  message do LILO. Após, o usuário é instruído a entrar com os
  parâmetros de inicialização, se necessários. Após a inicialização, um
  sistema de arquivos raiz é carregado de um segundo disco. O usuário
  executa o programa setup  que inicia a instalação. Ao invés de usar um
  kernel modular, Slackware provê uma série de diferentes kernels e
  depende do usuário a escolha do mais adequado aos seus requisitos de
  hardware.

  RedHat (v.4.0)  também utiliza a inicialização do LILO. Ele carrega um
  disco em memória compactado a partir do primeiro disco, o qual executa
  um programa  init customizado. Este programa solicita os arquivos de
  controle de dispositivos e carrega-os de um disco suplementar quando
  necessário.

  Debian (v.1.3) é provavelmente o mais sofisticado disco de instalação.
  Ele utiliza o carregador SYSLINUX para permitir várias opções de
  inicialização, usando então uma imagem do  initrd para guiar o usuário
  pelo processo de instalação. Aparenta usar tanto um  init quanto um
  interpretador customizados.


  1100..  LLiissttaa ddaass PPeerrgguunnttaass MMaaiiss FFrreeqquueenntteess ((FFAAQQ))


  QQ.. EEuu ccaarrrreeggoo mmeeuuss ddiissccooss ddee iinniicciiaalliizzaaççããoo ee rraaiizz ee nnaaddaa aaccoonntteeccee.. OO
  qquuee ppoossssoo ffaazzeerr??

  Veja a Seção ``Problemas''.

  QQ.. CCoommoo oo ddiissccoo ddee iinniicciiaalliizzaaççããoo ddaa CCoonneeccttiivvaa//RReedd HHaatt//SSllaacckkwwaarree//DDeebbiiaann
  ffuunncciioonnaamm??

  Veja a Seção ``Como os profisisonais fazem isso''.

  QQ.. CCoommoo eeuu ppoossssoo ccoonnssttrruuiirr uumm ddiissqquueettee ddee iinniicciiaalliizzaaççããoo ccoomm oo aarrqquuiivvoo
  ddee ccoonnttrroollee ddee ddiissppoossiittiivvooss XXYYZZ??

  A forma mais simples é obter um kernel do Slackware em um site espelho
  mais próximo. Os kernels do Slackware são genéricos e tentam incluir
  arquivos de controle para o maior número de dispositivos possível.
  Então caso se tenha uma controladora IDE ou SCSI, as chances são
  grandes de se ter um arquivo de controle para elas em um kernel do
  Slackware.  Vá para o diretório  a1  e selecione IDE ou SCSI
  dependendo do tipo de controladora que se tenha. Verifique o arquivo
  xxxxkern.cfg do kernel  selecionado para ver os arquivos de controle
  que foram incluídos neste kernel. Caso o dispositivo que se deseje
  instalar esteja incluído na lista, então o kernel correspondente deve
  inicializar o seu computador. Transfira o arquivo  xxxxkern.tgz e
  copie para o seu disquete de inicialização conforme descrito acima, na
  seção de construção de discos de inicialização.

  Deve-se checar o dispositivo raiz no kernel usando-se o comando rdev:

          rdev zImage


  rdev mostrará o dispositivo raiz atual do kernel. Caso este não seja o
  mesmo desejado, deve-se usar o  rdev para alterá-lo.  Por exemplo, um
  kernel testado apontava para /dev/sda2, porém a partição raiz SCSI era
  /dev/sda8. Para usar um disquete raiz, deve-se utilizar o comando:


          rdev zImage /dev/fd0


  Caso se queira saber como configurar um disquete de inicialização do
  Slackware, sugere-se verificar o Guia de Instalação Linux ou obter uma
  distribuição Slackware. Veja a seção denominada "Referências".

  QQ.. CCoommoo aattuuaalliizzaarr uumm ddiissccoo ddee iinniicciiaalliizzaaççããoo ccoomm uumm nnoovvoo kkeerrnneell??


  Simplesmente copie o novo kernel em um disquete de inicialização
  utilizando o comando dd para um disquete sem sistema de arquivos, ou
  através do comando cp para um disco de inicialização e raiz. Verifique
  a seção denominada "inicialização" para detalhes sobre a criação de um
  disquete de inicialização.  A descrição aplica-se perfeitamente à
  atualização do kernel em um disquete de inicialização.

  QQ.. CCoommoo aattuuaalliizzaarr oo ddiissqquueettee rraaiizz ccoomm nnoovvooss aarrqquuiivvooss??


  A maneira mais simples é copiar o sistema de arquivos do disco raiz de
  volta ao DISPOSITIVO utilizado, seção ``Criando um sistema de
  arquivos''. Após monte o sistema de arquivos e faça as alterações
  necessárias. Deve-se lembrar sempre onde o sistema de arquivos começa
  e quantos blocos ele ocupa:


  dd if=/dev/fd0 bs=1k skip=INÍCIO_RAIZ  count=BLOCOS | gunzip > DISPOSITIVO
  mount -t ext2 DISPOSITIVO /mnt


  Após as alterações serem concluídas, proceda de acordo com a Seção
  ``Empacotando'' e transfira o sistema de arquivos raiz de volta para o
  disco. Não se deve retransferir o kernel ou recalcular a palavra do
  disco em memória caso não tenha havido alterações do ponto de início
  do novo sistema de arquivos raiz.

  QQ.. CCoommoo rreemmoovveerr oo LLIILLOO ppaarraa sseerr ppoossssíívveell uuttiilliizzaarr aa iinniicciiaalliizzaaççããoo DDOOSS
  nnoovvaammeennttee??


  No Linux pode-se executar:


               /sbin/lilo -u


  Pode-se ainda usar o comando   dd para utilizar a cópia de segurança
  salva pelo LILO do setor de inicialização. Veja na documentação do
  LILO maiores informações.

  No DOS ou Windows pode-se executar o seguinte comando DOS:


               FDISK /MBR


  MBR significa Registro Mestre de Inicialização (Master Boot Record), e
  após o comando acima o setor de inicialização recebe registros DOS sem
  alterar a tabela de partições. Alguns puristas não concordam com essa
  abordagem, mas mesmo o autor do  LILO, Werner Almesberger, sugere
  isso, além de ser simples e funcional.

  QQ.. CCoommoo iinniicciiaalliizzaarr oo ssiisstteemmaa ssee oo kkeerrnneell _e oo ddiissccoo ddee iinniicciiaalliizzaaççããoo
  ffoorraamm ppeerrddiiddooss??

  Caso não se tenha um disco de inicialização extra, provavelmente o
  método mais simples será obter um kernel do Slackware para a sua
  controladora de discos ((IDE ou SCSI) conforme descrito anteriormente
  em "Como construir um disco de inicialização com o arquivo de controle
  de dispositivos XYZ?". Pode-se iniciar o sistema com esse kernel e
  procurar reparar o que estiver danificado.

  O kernel obtido pode não conter o tipo de disco e a partição que se
  deseje. Por exemplo, kernel genérico do Slackware para controladoras
  SCSI tem o dispositivo raiz configurado para /dev/sda2,  e
  eventualmente a partição raiz pode estar em  /dev/sda8. Neste caso o
  dispositivo raiz do kernel deve ser alterado.

  Pode-se mudar os parâmetros de dispositivo raiz e disco em memória no
  kernel, mesmo que tudo o que tenha seja um kernel ou mesmo a partir de
  outro sistema operacional, como por exemplo DOS.

  rdev altera o kernel através de alterações de valores de deslocamentos
  fixos do arquivo do kernel, então pode-se utilizar um editor em
  hexadecimal  em qualquer sistema disponível, como por exemplo o Editor
  de Disco de Utilitários Norton sob DOS. Deve-se checar se é necessário
  mudar os valores do kernel nos seguintes deslocamentos:


       HEX     DEC  DESCRIPTION
       0x01F8  504  Byte inferior da palavra do disco em memória
       0x01F9  505  Byte superior da palavra do disco em memória
       0x01FC  508  Número menor do dispositivo raiz - vide abaixo
       0X01FD  509  Número maior do dispositivo raiz - vide abaixo


  A interpretação da palavra do disco em memória está descrita na seção
  ``Configurando o disco em memória''.

  O número maior e menor do dispositivo devem ser configurados caso se
  deseje montar o sistema de arquivos raiz nele. Alguns valores
  importantes são:


       DISPOSITIVO      MAIOR MENOR
       /dev/fd0             2     0       primeira unidade de disquetes
       /dev/hda1            3     1       partição 1 no primeiro disco IDE
       /dev/sda1            8     1       partição 1 no primeiro disco SCSI
       /dev/sda8            8     8       partição 8 no primeiro disco SCSI


  Uma vez que estes valores estejam configurados, pode-se gravar o
  arquivo utilizando tanto o editor Norton, quanto um programa chamado
  rawrite.exe. Este programa é incluído em todas as distribuições, e é
  executado em ambientes DOS, sendo capaz de gravar os dados de forma
  direta, ao invés de gravar através do sistema de arquivos. Caso se
  utilize o Norton deve-se gravar o arquivo em um disco físico com
  início igual ao do disco de inicialização.

  QQ.. CCoommoo ffaazzeerr ccóóppiiaass aaddiicciioonnaaiiss ddooss ddiissqquueetteess ddee iinniicciiaalliizzaaççããoo ee rraaiizz??

  Como a mídia magnética pode deteriorar-se com o tempo, deve-se manter
  diversas cópias dos discos de emergência, para as situações em que o
  original não funcione.

  A forma mais simples de fazer cópias de qualquer disquete, inclusive
  disquetes que podem ser inicializados e disquetes de utilitários, é
  através da utilização do comando dd  para cópia do disquete original
  em um disco rígido e após o mesmo comando para copiar do disco rígido
  para os diversos disquetes.  Note que não se deve montar os disquetes,
  porque o comando  dd  utiliza o acesso direto ao dispositivo.

  Para copiar o disquete original, execute o comando:


               dd if=NOME_DISPOSITIVO of=NOME_ARQUIVO
               onde NOME_DISPOSITIVO é o nome da unidade de disquetes
               e NOME_ARQUIVO é o nome do arquivo de saída (no disco rígido)


  Omitindo-se o parâmetro  count  faz com que o comando copie todo o
  disquete (2880 blocos de alta densidade).

  Para copiar o arquivo resultante para um novo disquete, deve-se
  inserir o disquete na unidade e executar o comando:


               dd if=NOME_ARQUIVO of=NOME_DISPOSITIVO


  Note que o exemplo acima assume que se tenha somente uma unidade de
  gravação de disquetes. Caso se tenha duas de mesmo tipo, pode-se
  copiar o disquete usando-se o comando:


               dd if=/dev/fd0 of=/dev/fd1


  QQ.. CCoommoo iinniicciiaalliizzaarr oo ssiisstteemmaa sseemm tteerr qquuee ddiiggiittaarr ""aahhaaxxxxxxxx==nnnn,,nnnn,,nnnn""
  ttooddaa vveezz??


  Quando um dispositivo não pode ser detectado automáticamente, é
  necessário fornecer ao kernel os parâmetros através do comando de
  dispositivos, como por exemplo:


               aha152x=0x340,11,3,1


  Este parâmetro pode ser fornecido pelo LILO de diversas formas:


  ·  Informando o comando toda a vez que o sistema for inicializado via
     LILO. A opção  menos aconselhável.

  ·  Usando o parâmetro  ``lock'' para armazenar a linha de comando como
     a linha padrão de comando, fazendo com que o LILO use estas opções
     toda a vez que o sistema for carregado.

  ·  Utilizando o parâmetro  append= no arquivo de configuração do LILO.
     Note que o parâmetro deve estar entre aspas.

  Por exemplo, uma linha de comando usando os parâmetros acima poderia
  ser:


               zImage  aha152x=0x340,11,3,1 root=/dev/sda1 lock


  Este comando passa os parâmetros do dispositivo,  configura o
  dispositivo raiz em /dev/sda1 e salva todo o comando para reutilização
  futura.

  Um exemplo de comando append:

          \{append} = "aha152x=0x340,11,3,1"


  Note que o parâmetro não deve estar entre aspas na linha de comando,
  mas é obrigatório que assim esteja no comando append.

  Note ainda que  para que o parâmetro seja ativado, o kernel deve
  conter o módulo para o dispositivo assinalado. Caso contrário,  o
  comando não surtirá efeito algum e o kernel deverá ser reconstruído
  para incluir o módulo requerido. Para maiores detalhes sobre a
  reconstrução do kernel, mude o diretório  para /usr/src/linux e veja o
  arquivo README, e leia o FAQ e o tutorial de instalação.
  Alternativamente pode-se obter um kernel genérico e instalá-lo.

  É extremamente indicado a leitura da documentação LILO antes de se
  tentar instalá-lo. Usos indevidos do comando  BOOT podem causar danos
  às partições.

  QQ.. DDuurraannttee aa iinniicciiaalliizzaaççããoo  ooccoorrrreeuu oo eerrrroo  ""A: não pode executar B".
  Por quê?


  Há diversos casos em que nomes de programas encontram-se dentro do
  código de vários utilitários. Este casos não ocorrem em toda parte,
  mas pode ser uma explicação de porquê um executável aparentemente pode
  não ser encontrado, apesar de estar presente no sistema. Pode-se
  descobrir se um determinado programa tem o nome de outro dentro de seu
  código usando-se o comando strings e conectando sua saída com o
  comando grep.

  Exemplos conhecidos de localizações pré-definidas:

  ·  Shutdown em algumas versões tem o programa  /etc/reboot
     pré-definido, sendo que reboot deverá estar no diretório  /etc .

  ·  init pode causar alguns problemas, caso o kernel não consiga
     encontrá-lo em init.

  Para corrigir estes problemas, deve-se ou mover os programas para o
  diretório correto, ou mudar os arquivos de configuração (por exemplo
  inittab) para apontarem para o diretório correto. Em caso de dúvidas,
  ponha os programas no mesmo diretório em que eles estavam no disco
  rígido, e utilize os mesmos  inittab e  /etc/rc.d da forma como eles
  estão presentes.

  QQ.. MMeeuu kkeerrnneell tteemm ssuuppoorrttee aa ddiissccoo eemm mmeemmóórriiaa,, mmaass aappaarreeccee ccoomm 00 KKbb ddee
  eessppaaççoo..


  Quando isso ocorre, uma mensagem do kernel aparecerá durante a
  inicialização:


  Dispositivo de disco em memória inicializado:
  16 discos em memória com tamanho de 0K.


  Isso se deve provavelmente à definição do tamanho em zero através dos
  parâmetros de kernel em tempo de inicialização. Algo como:


       ramdisk=0

  Isso foi incluído como exemplo de configuração do LILO em algumas
  distribuições antigas, e foi colocado para sobrepor-se a parâmetros
  anteriores de configuração do kernel. Caso essa linha esteja presente,
  deve ser retirada.

  Note que ao se tentar utilizar um disco em memória com tamanho igual a
  zero, o comportamento do sistema é imprevisível, e pode resultar em
  travamentos do kernel.


  KK..  RReeccuurrssooss ee EEnnddeerreeççooss

  Nesta seção, _v_v_v é usado no lugar de versões dos nomes dos pacotes, a
  fim de evitar a referência a uma versão específica. Ao recuperar um
  pacote, deve-se procurar usar sempre a versão mais recente, a menos
  que haja alguma boa razão para fazer o contrário.


  KK..11..  DDiissccooss ddee IInniicciiaalliizzaaççããoo PPrréé--CCoonnffiigguurraaddooss


  Há diversas fontes de discos de distribuições.   _P_o_r _f_a_v_o_r _u_s_e _u_m _d_o_s
  _s_i_t_e_s _e_s_p_e_l_h_o_s _p_a_r_a _r_e_d_u_z_i_r _o _t_r_á_f_e_g_o _n_e_s_t_a_s _m_á_q_u_i_n_a_s_.

  ·  Discos de inicialização Slackware
     <http://sunsite.unc.edu/pub/Linux/distributions/slackware/bootdsks.144/>
     e Sites espelho Slackware
     <http://sunsite.unc.edu/pub/Linux/distributions/slackware/MIRRORS.TXT>

  ·  Discos de inicialização Red Hat
     <http://sunsite.unc.edu/pub/Linux/distributions/redhat/current/i386/images/>
     e Sites espelho Red Hat <http://www.redhat.com/ftp.html>

  ·  Discos de inicialização Debian
     <ftp://ftp.debian.org/pub/debian/stable/disks-i386> e Sites espelho
     Debian <ftp://ftp.debian.org/debian/README.mirrors>

  Em adição aos discos das distribuições, as seguintes imagens de discos
  de emergência estão disponíveis:


  ·  tomsrtbt, de Tom Oehser, é um único disco de inicialização e raiz,
     baseado no kernel 2.0.33, com uma grande lista de funcionalidades e
     programas de suporte. Suporta IDE, SCSI, fita, placas de rede,
     PCMCIA e mais. Mais de 100 utilitários e ferramentas estão inclusas
     para correção e restauração de discos. O pacote ainda inclui
     programas para desmontagem e reconstrução de imagens, permitindo
     que novos itens possam ser incluídos.

     <http://www.toms.net/~toehser/rb/tomsrtbt-current.tar.gz>

     <http://sunsite.unc.edu/pub/Linux/system/recovery/>


  ·  rescue02, de John Comyns, é um disco de emergência baseado no
     kernel 1.3.84, com suporte a IDE e  Adaptec 1542 e NCR53C7,8xx. Usa
     binários ELF, porém contém comandos suficientes para ser utilizado
     em qualquer sistema. Há módulos que podem ser carregados após a
     inicialização do sistema para todas as placas SCSI. Provavelmente
     não funcionará em sistemas com 4 Mb de RAM, uma vez que utiliza um
     disco de 3 Mb.

     <http://sunsite.unc.edu/pub/Linux/system/recovery/rescue02.zip>


  ·  resque_disk-2.0.22, de Sergei Viznyuk,  é um disco de inicialização
     e raiz baseado no kernel 2.0.22 com suporte a IDE, muitas
     controladoras SCSI e ELF/OUT. Inclui ainda diversos módulos e
     utilitários para reparar e restaurar discos rígidos.

     <http://sunsite.unc.edu/pub/Linux/system/recovery/resque_disk-
     vvv.tar.gz>


  ·  Imagens cramdisk baseado no kernel 2.0.33, disponível para máquinas
     com 4 e 8 Mb. Incluem emulador matemático e suporte à comunicação
     (PPP e programas de discagem, NE2000, 3C509), ou suporte a
     dispositivos ZIP paralelos. Estas imagens serão capazes de
     inicializar um 386 com 4 Mb de RAM. Suporte a MSDOS está incluso,
     podendo-se assim transmitir da Internet para uma partição DOS.

     <http://sunsite.unc.edu/pub/Linux/system/recovery/images/>


  KK..22..  DDiissccooss ddee EEmmeerrggêênncciiaa

  Diversos pacotes de criação de discos de emergência estão disponíveis
  em sunsite.unc.edu. Com estes pacotes pode-se especificar um conjunto
  de arquivos para inclusão e o software automatiza (em vários níveis) a
  criação do disco de inicialização. Veja
  <http://sunsite.unc.edu/pub/Linux/system/recovery/!INDEX.html> para
  maiores informações. VVeerriiffiiqquuee aass ddaattaass ddooss aarrqquuiivvooss ccuuiiddaaddoossaammeennttee
  --- alguns destes pacotes podem estar desatualizados há vários anos e
  podem não suportar a criação de sistemas de arquivos raiz compactados
  carregados em discos em memória. Até onde conhecemos Yard é o único
  pacote que poderá fazer isso.


  KK..33..  PPrrooggrraammaass ddee LLoottee ddee GGrraahhaamm CChhaappmmaann


  Graham Chapman  escreveu um conjunto de programas que podem ser
  bastante úteis como exemplos de criação de discos de inicialização. Em
  versões anteriores deste tutorial os programas apareciam como um
  apêndice, mas foram apagados deste documento e colocados em uma página
  web: <http://www.zeta.org.au/~grahamc/linux.html>

  Pode ser conveniente o uso destes programas, mas deve-se ler
  cuidadosamente as instruções -- por exemplo ao especificar uma área de
  troca incorreta, pode-se apagar o sistema de arquivos raiz
  definitivamente. Esteja seguro de que esteja bem configurado antes de
  usar os programas.


  KK..44..  LLIILLOO ------ OO ccaarrrreeggaaddoorr LLiinnuuxx


  Escrito por  Werner Almesberger.  Excelente carregador da
  inicialização do sistema, e a documentação inclui informações sobre o
  setor de inicialização e os estágios anteriores do processo de carga
  de um sistema.

  Ftp em
  <ftp://tsx-11.mit.edu/pub/linux/packages/lilo/lilo.vvv.tar.gz>.  Está
  também disponível no Sunsite e seus diversos sites espelhos.


  KK..55..  PPeerrgguunnttaass MMaaiiss FFrreeqqüüeenntteess ee CCoommoo FFaazzeerr

  Estão disponíveis em diversos locais. Pode-se verificar os grupos de
  notícias da Usenet em  news.answers e comp.os.linux.announce.

  Perguntas mais freqüentes em
  <http://sunsite.unc.edu/pub/Linux/docs/faqs/linux-faq> e Como Fazer em
  <http://sunsite.unc.edu/pub/Linux/docs/HOWTO>.

  Mais documentação sobre o Linux pode ser encontrada em  Página do
  Projeto de Documentação Linux <http://sunsite.unc.edu/LDP/>.

  Caso o problema seja seríssimo pode-se enviar uma mensagem em inglês
  para mail-server@rtfm.mit.edu com a palavra ``help'' na mensagem.


  KK..66..  UUssoo ddoo DDiissccoo eemm MMeemmóórriiaa

  Uma excelente descrição de como funciona o novo código de disco em
  memória pode ser encontrada com a documentação do kernel do Linux.
  Veja em  /usr/src/linux/Documentation/ramdisk.txt. Foi escrito por
  Paul Gortmaker e inclui uma seção sobre a criação de discos em memória
  compactados.


  KK..77..  OO pprroocceessssoo ddee iinniicciiaalliizzaaççããoo ddoo LLiinnuuxx


  Para maiores detalhes sobre o processo de inicialização do Linux,
  seguem algumas indicações:


  ·  O Guia de Administração do Sistema Linux contém uma seção sobre o
     processo. Veja em
     <http://sunsite.unc.edu/LDP/LDP/sag-0.5/node68.html>

  ·  Visão Geral do  LILO
     <http://sunsite.unc.edu/pub/Linux/system/boot/lilo/lilo-t-20.ps.gz>
     tem uma visão tecnicamente detalhada e definitiva sobre o processo
     de inicialização e como o kernel é carregado.

  ·  O código fonte é o último guia. Abaixo seguem alguns arquivos do
     kernel relacionados com o processo de inicialização. Caso se tenha
     à disposição os fontes do Linux, que podem ser encontrados em
     /usr/src/linux em sistemas Linux; ou alternativamente  Shigio
     Yamaguchi (shigio@wafu.netgate.net) tem um kernel em hipertexto em
     <http://wafu.netgate.net/linux/>.


     aarrcchh//ii338866//bboooott//bboooottsseecctt..SS,,sseettuupp..SS
        Contém o código Assembler para o setor de inicialização.


     aarrcchh//ii338866//bboooott//ccoommpprreesssseedd//mmiisscc..cc
        Contém o código para descompactar o kernel.


     aarrcchh//ii338866//kkeerrnneell//
        Diretório contendo o código de inicialização do kernel. setup.c
        contém a palavra de configuração do disco em memória.


     ddrriivveerrss//bblloocckk//rrdd..cc
        Contém o arquivo de controle do disco em memória. Os
        procedimentos rd_load e   rd_load_image carregam os blocos de um
        dispositivo em um disco em memória. O procedimento
        identify_ramdisk_image determina o tipo do sistema de arquivos
        encontrado e se ele é compactado.


  LL..  CCóóddiiggooss ddee EErrrrooss ddee IInniicciiaalliizzaaççããoo ddoo LLIILLOO

  Questões sobre esses códigos de erros, tem sido freqüentes na Usenet,
  sendo que incluímos aqui como um serviço público. Este sumário foi
  desenvolvido a partir da Documentação do Usuário LILO de Werner
  Almsberger, disponível em
  <ftp://lrcftp.epfl.ch:/pub/linux/local/lilo/lilo.u.19.ps.gz>.

  Quando o LILO carrega a si próprio, ele apresenta a palavra ``LILO''.
  Cada letra é apresentada antes da execução de algum processo, assim
  sendo as letras podem ser um indicador do estágio atingido e da origem
  do problema.


        Nenhuma parte do LILO foi carregada. LILO pode não estar
        instalado ou a partição no qual o setor de inicialização está
        localizado não está ativa.


     LL  O primeiro estágio do carregador foi iniciado e executado, mas
        não foi possível carregar o segundo estágio. Os códigos de erro
        com dois dígitos indicam o tipo de problema (Veja ainda "Códigos
        de Erros de Discos"). Esta condição indica normalmente a falha
        na mídia ou erro de geometria (por exemplo parâmetros de disco
        incorretos).


     LLII O primeiro estágio foi capaz de carregar o segundo, mas falhou
        na sua execução. Isso pode ser causado por erro de geometria ou
        pela movimentação do /boot/boot.b  sem a execução do instalador.


     LLIILL
        O segundo estágio conseguiu ser iniciado, mas não pode carregar
        a tabela de descritores do arquivo map. Isso normalmente é
        causado por falha na mídia ou erro de geometria.


     LLIILL??
        O segundo estágio do LILO foi carregado para um endereço
        incorreto. Isso é tipicamente causado por erros de geometria ou
        pela movimentação do arquivo /boot/boot.b sem a execução do
        instalador.


     LLIILL--
        A tabela de descritores está corrompida. Isso pode ser causado
        por erros de geometria ou pela movimentação do arquivo
        /boot/boot.b sem a execução do instalador.


     LLIILLOO
        Todas as partes do LILO foram carregadas.


  Caso o BIOS apresente algum erro quando o LILO estiver tentando
  carregar uma imagem de inicialização, o respectivo código de erro é
  apresentado. Estes códigos variam de 0x00 até 0xbb. Veja o Guia do
  Usuário LILO para uma maior explicação sobre este tema.


  MM..  LLiissttaass ddee eexxeemmpplloo ddoo ccoonntteeúúddoo ddoo ddiissccoo ddee iinniicciiaalliizzaaççããoo


  Aqui está o conteúdo dos disquetes raiz e utilitários de Graham. Estas
  listas são apresentadas como um exemplo dos arquivos incluídos em um
  sistema funcional. Graham adicionou algumas notas explicativas que
  parecem muito úteis.


  total 18
  drwxr-xr-x   2 root     root         1024 Jul 29 21:16 bin/
  drwxr-xr-x   2 root     root         9216 Jul 28 16:21 dev/
  drwxr-xr-x   3 root     root         1024 Jul 29 20:25 etc/
  drwxr-xr-x   2 root     root         1024 Jul 28 19:53 lib/
  drwxr-xr-x   2 root     root         1024 Jul 24 22:47 mnt/
  drwxr-xr-x   2 root     root         1024 Jul 24 22:47 proc/
  drwxr-xr-x   2 root     root         1024 Jul 28 19:07 sbin/
  drwxr-xr-x   2 root     root         1024 Jul 29 20:57 tmp/
  drwxr-xr-x   4 root     root         1024 Jul 29 21:35 usr/
  drwxr-xr-x   3 root     root         1024 Jul 28 19:52 var/

  /bin:
  total 713
  -rwxr-xr-x   1 root     bin          7737 Jul 24 22:16 cat*
  -rwxr-xr-x   1 root     bin          9232 Jul 24 22:48 chmod*
  -rwxr-xr-x   1 root     bin          8156 Jul 24 22:48 chown*
  -rwxr-xr-x   1 root     bin         19652 Jul 24 22:48 cp*
  -rwxr-xr-x   1 root     root         8313 Jul 29 21:16 cut*
  -rwxr-xr-x   1 root     bin         12136 Jul 24 22:48 dd*
  -rwxr-xr-x   1 root     bin          9308 Jul 24 22:48 df*
  -rwxr-xr-x   1 root     root         9036 Jul 29 20:24 dircolors*
  -rwxr-xr-x   1 root     bin          9064 Jul 24 22:48 du*
  -rwxr-x---   1 root     bin         69252 Jul 24 22:51 e2fsck*
  -rwxr-xr-x   1 root     bin          5361 Jul 24 22:48 echo*
  -rwxr-xr-x   1 root     bin          5696 Jul 24 22:16 hostname*
  -rwxr-xr-x   1 root     bin          6596 Jul 24 22:49 kill*
  -rwxr-xr-x   1 root     bin         10644 Jul 24 22:17 ln*
  -rwxr-xr-x   1 root     bin         13508 Jul 24 22:17 login*
  -rwxr-xr-x   1 root     bin         26976 Jul 24 22:17 ls*
  -rwxr-xr-x   1 root     bin          7416 Jul 24 22:49 mkdir*
  -rwxr-x---   1 root     bin         34596 Jul 24 22:51 mke2fs*
  -rwxr-xr-x   1 root     bin          6712 Jul 24 22:49 mknod*
  -rwxr-xr-x   1 root     bin         20304 Jul 24 22:17 more*
  -rwxr-xr-x   1 root     bin         24704 Jul 24 22:17 mount*
  -rwxr-xr-x   1 root     bin         12464 Jul 24 22:17 mv*
  -rwxr-xr-x   1 root     bin         20829 Jul 24 22:50 ps*
  -rwxr-xr-x   1 root     bin          9424 Jul 24 22:50 rm*
  -rwxr-xr-x   1 root     bin          4344 Jul 24 22:50 rmdir*
  -rwxr-xr-x   1 root     root       299649 Jul 27 14:12 sh*
  -rwxr-xr-x   1 root     bin          9853 Jul 24 22:17 su*
  -rwxr-xr-x   1 root     bin           380 Jul 27 14:12 sync*
  -rwxr-xr-x   1 root     bin         13620 Jul 24 22:17 umount*
  -rwxr-xr-x   1 root     root         5013 Jul 29 20:03 uname*

  /dev:
  total 0
  lrwxrwxrwx   1 root     root           10 Jul 24 22:34 cdrom -> /dev/sbpcd
  crw--w--w-   1 root     tty        4,   0 Jul 24 21:49 console
  brw-rw----   1 root     floppy     2,   0 Apr 28  1995 fd0
  lrwxrwxrwx   1 root     root            4 Jul 24 22:34 ftape -> rft0
  crw-rw-rw-   1 root     sys       10,   2 Jul 18  1994 inportbm
  crw-rw----   1 root     kmem       1,   2 Jul 28 16:21 kmem
  crw-rw----   1 root     kmem       1,   1 Jul 18  1994 mem
  lrwxrwxrwx   1 root     root            4 Jul 24 22:34 modem -> cua0
  lrwxrwxrwx   1 root     root            4 Jul 24 22:34 mouse -> cua1
  crw-rw-rw-   1 root     sys        1,   3 Jul 18  1994 null
  brw-rw----   1 root     disk       1,   1 Jul 18  1994 ram
  crw-rw----   1 root     disk      27,   0 Jul 18  1994 rft0
  brw-rw----   1 root     disk      25,   0 Jul 19  1994 sbpcd
  ***  Foram incluídos arquivos de dispositivos para as partições SCSI em uso
  ***  Caso sejam utilizados discos IDE, deve-se usar /dev/hdxx .
  brw-rw----   1 root     disk       8,   0 Apr 29  1995 sda
  brw-rw----   1 root     disk       8,   6 Apr 29  1995 sda6
  brw-rw----   1 root     disk       8,   7 Apr 29  1995 sda7
  brw-rw----   1 root     disk       8,   8 Apr 29  1995 sda8
  lrwxrwxrwx   1 root     root            7 Jul 28 12:56 systty -> console
  *** esta ligação de systty para a console é obrigatória
  crw-rw-rw-   1 root     tty        5,   0 Jul 18  1994 tty
  crw--w--w-   1 root     tty        4,   0 Jul 18  1994 tty0
  crw--w----   1 root     tty        4,   1 Jul 24 22:33 tty1
  crw--w----   1 root     tty        4,   2 Jul 24 22:34 tty2
  crw--w--w-   1 root     root       4,   3 Jul 24 21:49 tty3
  crw--w--w-   1 root     root       4,   4 Jul 24 21:49 tty4
  crw--w--w-   1 root     root       4,   5 Jul 24 21:49 tty5
  crw--w--w-   1 root     root       4,   6 Jul 24 21:49 tty6
  crw-rw-rw-   1 root     tty        4,   7 Jul 18  1994 tty7
  crw-rw-rw-   1 root     tty        4,   8 Jul 18  1994 tty8
  crw-rw-rw-   1 root     tty        4,   9 Jul 19  1994 tty9
  crw-rw-rw-   1 root     sys        1,   5 Jul 18  1994 zero

  /etc:
  total 20
  -rw-r--r--   1 root     root         2167 Jul 29 20:25 DIR_COLORS
  -rw-r--r--   1 root     root           20 Jul 28 12:37 HOSTNAME
  -rw-r--r--   1 root     root          109 Jul 24 22:57 fstab
  -rw-r--r--   1 root     root          271 Jul 24 22:21 group
  -rw-r--r--   1 root     root         2353 Jul 24 22:27 inittab
  -rw-r--r--   1 root     root            0 Jul 29 21:02 issue
  -rw-r--r--   1 root     root         2881 Jul 28 19:38 ld.so.cache
  *** Diversos erros ocorrem na inicialização se ld.so.cache não está presente,mas
  *** esteja seguro que  ldconfig está incluído e pode ser executado em rc.x para
  *** atualizá-lo.
  -rw-r--r--   1 root     root           12 Jul 24 22:22 motd
  -rw-r--r--   1 root     root          606 Jul 28 19:25 passwd
  -rw-r--r--   1 root     root         1065 Jul 24 22:21 profile
  drwxr-xr-x   2 root     root         1024 Jul 29 21:01 rc.d/
  -rw-r--r--   1 root     root           18 Jul 24 22:21 shells
  -rw-r--r--   1 root     root          774 Jul 28 13:43 termcap
  -rw-r--r--   1 root     root          126 Jul 28 13:44 ttys
  -rw-r--r--   1 root     root            0 Jul 24 22:47 utmp

  /etc/rc.d:
  total 5
  *** Não me importo muito com programas de encerramento do sistema -
  *** tudo é executado em um disco em memória, não havendo muitas coisas
  *** para finalizar.
  -rwxr-xr-x   1 root     root         1158 Jul 24 22:23 rc.K*
  -rwxr-xr-x   1 root     root         1151 Jul 28 19:08 rc.M*
  -rwxr-xr-x   1 root     root          507 Jul 29 20:25 rc.S*

  /lib:
  total 588
  *** Tenho um sistema ELF, tendo sido incluído o carregador loader ld-linux.so.
  ***  Caso se esteja ainda utilizando o  a.out, então deve-se incluir ld.so.
  *** Deve-se usar o comando file para verificar quais  bibliotecas devem ser incluídas.
  lrwxrwxrwx   1 root     root           17 Jul 24 23:36 ld-linux.so.1 -> ld-linux.so.1.7.3*
  -rwxr-xr-x   1 root     root        20722 Aug 15  1995 ld-linux.so.1.7.3*
  lrwxrwxrwx   1 root     root           13 Jul 24 23:36 libc.so.5 -> libc.so.5.0.9*
  -rwxr-xr-x   1 root     root       562683 May 19  1995 libc.so.5.0.9*
  ***  Deve-se incluir   libtermcap
  lrwxrwxrwx   1 root     root           19 Jul 28 19:53 libtermcap.so.2 -> libtermcap.so.2.0.0*
  -rwxr-xr-x   1 root     root        11360 May 19  1995 libtermcap.so.2.0.0*

  /mnt:
  total 0

  /proc:
  total 0

  /sbin:
  total 191
  ***  Utilizo Slackware, o qual usa  agetty. Muitos sistemas usam  getty.
  ***  Verifique em /etc/inittab para ver qual o necessário. Note que  (a)getty e login
  ***  são necessários para que se possa fazer algo no sistema.
  -rwxr-xr-x   1 root     bin         11309 Jul 24 22:54 agetty*
  -rwxr-xr-x   1 root     bin          5204 Jul 24 22:19 halt*
  ***  Obrigatório na inicialização do sistema
  -rwxr-xr-x   1 root     bin         20592 Jul 24 22:19 init*
  -rwxr-xr-x   1 root     root        86020 Jul 28 19:07 ldconfig*
  -rwxr-xr-x   1 root     bin          5329 Jul 27 14:10 mkswap*
  -rwxr-xr-x   1 root     root         5204 Jul 24 22:20 reboot*
  -rwxr-xr-x   1 root     root         6024 Jul 24 22:20 rdev*
  -rwxr-xr-x   1 root     bin         12340 Jul 24 22:20 shutdown*
  -rwxr-xr-x   1 root     root         5029 Jul 24 22:20 swapoff*
  -rwxr-xr-x   1 root     bin          5029 Jul 24 22:20 swapon*
  -rwxr-xr-x   1 root     root        20592 Jul 27 18:18 telinit*
  -rwxr-xr-x   1 root     root         7077 Jul 24 22:20 update*

  /tmp:
  total 0

  /usr:
  total 2
  drwxr-xr-x   2 root     root         1024 Jul 29 21:00 adm/
  drwxr-xr-x   2 root     root         1024 Jul 29 21:16 lib/

  /usr/adm:
  total 0

  /usr/lib:
  total 0

  /var:
  total 1
  ***  Muitos problemas ocorreram antes da inclusão do  /etc/rc.S
  ***  para inicializar o /var/run/utmp, mas talvez  isso não seja necessário
  *** em outros sistemas
  drwxr-xr-x   2 root     root         1024 Jul 28 19:52 run/

  /var/run:
  total 0


  NN..  LLiissttaass ddee eexxeemmpplloo ddoo ccoonntteeúúddoo ddoo ddiissccoo ddee uuttiilliittáárriiooss


  total 579
  -rwxr-xr-x   1 root     root        42333 Jul 28 19:05 cpio*
  -rwxr-xr-x   1 root     root       103560 Jul 29 21:31 elvis*
  -rwxr-xr-x   1 root     root        56401 Jul 28 19:06 find*
  -rwxr-xr-x   1 root     root        29536 Jul 28 19:04 fdisk*
  -rw-r--r--   1 root     root       128254 Jul 28 19:03 ftape.o
  -rwxr-xr-x   1 root     root        17564 Jul 25 03:21 ftmt*
  -rwxr-xr-x   1 root     root        64161 Jul 29 20:47 grep*
  -rwxr-xr-x   1 root     root        45309 Jul 29 20:48 gzip*
  -rwxr-xr-x   1 root     root        23560 Jul 28 19:04 insmod*
  -rwxr-xr-x   1 root     root          118 Jul 28 19:04 lsmod*
  lrwxrwxrwx   1 root     root            5 Jul 28 19:04 mt -> mt-st*
  -rwxr-xr-x   1 root     root         9573 Jul 28 19:03 mt-st*
  lrwxrwxrwx   1 root     root            6 Jul 28 19:05 rmmod -> insmod*
  -rwxr-xr-x   1 root     root       104085 Jul 28 19:05 tar*
  lrwxrwxrwx   1 root     root            5 Jul 29 21:35 vi -> elvis*