Vamos começar com os pré-requisitos básicos para que tudo funcione a contento.

1) Em primeiro lugar será necessário verificar se a placa-mãe de seu micro suporta o pendrive, e de quais módulos irá necessitar.

• Em primeiro lugar, consulte a documentação da placa-mãe para verificar se a interface USB da mesma é 1.1 ou 2.0;
• Verifique se seu pendrive é USB 1.1 ou 2.0; ou compatível com ambos.

A princípio, o USB 2.0 é para ser compatível com o USB 1.1; entretanto, já vi situações onde a interface USB 1.1 de uma placa mãe antiga nem toma conhecimento de um pendrive USB 2.0, e isto somente podemos explicar como um problema de compatibilidade; talvez se você utilizar um pendrive 1.1 ou 2.0 em uma placa USB 2.0 tenha mais chances de sucesso do que ao contrário, isto é uma placa USB 1.1 com um dispositivo USB 2.0; neste caso procure utilizar um pendrive USB 1.1 ou compatível.

Havendo compatibilidade, conecte então o pendrive em uma das portas USB do micro.

2) Carregue os módulos de suporte ao USB:

Carregue o módulo usb-storage:

# modprobe usb-storage

Carregue o módulo usb-uhci ou usb-ohci, dependendo do chipset de sua placa-mãe:

• PLACAS COM CHIPSET VIA, INTEL: usb-uhci;
• PLACAS COM CHIPSET Compaq, OPTi, SiS, ALi: usb-ohci.

O comando lspci pode dar uma pista:

# lspci
00:00.0 Host bridge: ALi Corporation M1541 (rev 04)
00:01.0 PCI bridge: ALi Corporation M1541 PCI to AGP Controller (rev 04)
00:02.0 USB Controller: ALi Corporation USB 1.1 Controller (rev 03)
00:03.0 Bridge: ALi Corporation M7101 Power Management Controller [PMU]
00:07.0 ISA bridge: ALi Corporation M1533 PCI to ISA Bridge [Aladdin IV] (rev c3)
00:09.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL-8139/8139C/8139C+ (rev 10)
00:0b.0 VGA compatible controller: Trident Microsystems Blade 3D PCI/AGP (rev 3a)
00:0f.0 IDE interface: ALi Corporation M5229 IDE (rev c1)

Na saída acima podemos verificar que o chipset é ALi.

Agora carregue o módulo:

# modprobe usb-uhci
ou
# modprobe usb-ohci

DICA: Se você tentar carregar o módulo errado irá aparecer uma mensagem como a seguinte:

/lib/modules/2.4.22/kernel/drivers/usb/host/usb-uhci.o: init_module: No such device
/lib/modules/2.4.22/kernel/drivers/usb/host/usb-uhci.o: Hint: insmod errors can be caused by incorrect module parameters, including invalid IO or IRQ parameters.
You may find more information in syslog or the output from dmesg
/lib/modules/2.4.22/kernel/drivers/usb/host/usb-uhci.o: insmod /lib/modules/2.4.22/kernel/drivers/usb/host/usb-uhci.o failed
/lib/modules/2.4.22/kernel/drivers/usb/host/usb-uhci.o: insmod usb-uhci failed

Se isto acontecer, tente carregar o outro módulo (uhci ou ohci).

Monte o sistema de arquivos USB:

# mount -t usbdevfs usb /proc/bus/usb
(este comando poderá variar dependendo da versão do kernel)

Verifique se o pendrive está sendo detectado pelo sub-sistema USB:

# cat /proc/bus/usb/devices
T: Bus=01 Lev=00 Prnt=00 Port=00 Cnt=00 Dev#= 1 Spd=12 MxCh= 2
B: Alloc= 0/900 us ( 0%), #Int= 0, #Iso= 0
D: Ver= 1.00 Cls=09(hub ) Sub=00 Prot=00 MxPS= 8 #Cfgs= 1
P: Vendor=0000 ProdID=0000 Rev= 0.00
S: Product=USB UHCI Root Hub
S: SerialNumber=d400
C:* #Ifs= 1 Cfg#= 1 Atr=40 MxPwr= 0mA
I: If#= 0 Alt= 0 #EPs= 1 Cls=09(hub ) Sub=00 Prot=00 Driver=hub
E: Ad=81(I) Atr=03(Int.) MxPS= 8 Ivl=255ms
T: Bus=01 Lev=01 Prnt=01 Port=01 Cnt=01 Dev#= 2 Spd=12 MxCh= 0
D: Ver= 2.00 Cls=00(>ifc ) Sub=00 Prot=00 MxPS=64 #Cfgs= 1
P: Vendor=0951 ProdID=1603 Rev= 2.00
S: Manufacturer=Kingston
S: Product=DataTraveler 2.0
S: SerialNumber=000000000000000000000020
C:* #Ifs= 1 Cfg#= 1 Atr=80 MxPwr=100mA
I: If#= 0 Alt= 0 #EPs= 2 Cls=08(stor.) Sub=06 Prot=50 Driver=usb-storage
E: Ad=81(I) Atr=02(Bulk) MxPS= 64 Ivl=0ms
E: Ad=02(O) Atr=02(Bulk) MxPS= 64 Ivl=0ms

Observe que o pendrive foi detectado acima nas linhas 13 e 14 (fabricante Kingston, produto DataTraveler 2.0).

Isso feito podemos passar à próxima etapa.

3) Particionando e formatando o pendrive.

A rigor este passo talvez não fosse necessário, entretanto ele tornará as coisas mais claras e definidas para o sistema operacional, durante a instalação do mesmo no pendrive e posteriormente durante o boot do mesmo.

Atenção: Para todos os efeitos, estarei considerando que o sistema operacional (no caso em questão trata-se do Slackware/Linux 10.2 com Kernel 2.4.31) atribuirá o arquivo de dispositivo /dev/sda para o pendrive; este comportamento talvez possa variar, conforme a distribuição Linux ou versão do Kernel; portanto, se você utilizar uma distribuição ou Kernel diferentes, consulte antes a documentação para saber como são manipulados os arquivos de dispositivos USB pelo S.O., e faça as devidas adaptações nos comandos aqui ilustrados.

# fdisk /dev/sda

A seguir crie uma partição tipo Linux (tipo 83) no pendrive, normalmente como se fosse em um HD (disco rígido).

Se você não sabe utilizar o fdisk, poderá utilizar um outro particionador qualquer para Linux (por exemplo, cfdisk), que possivelmente dará o mesmo resultado. Ou então consulte alguma documentação ou tutorial sobre fdisk. Neste caso aconselho você treinar antes em um HD secundário velho, que não será utilizado. É possível também treinar o particionamento em arquivos, assim você não corre o risco de danificar o HD - apesar de não estar diretamente relacionado ao escopo deste artigo, se você quiser se aprofundar no assunto, há um excelente artigo em (Devin - página do Eitch (Hugo Cisneiros)) - vale a pena dar uma olhada!

De qualquer forma, após o particionamento do pendrive a saída do fdisk deverá ser a seguinte:

# fdisk -l /dev/sda
Disk /dev/sda: 1017 MB, 1017118720 bytes
78 heads, 32 sectors/track, 795 cylinders
Units = cylinders of 2496 * 512 = 1277952 bytes

   Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1         795      992144   83  Linux

A seguir crie um sistema de arquivos (no caso utilizei ext3) no pendrive:

# mke2fs -b 1024 -j /dev/sda1

A opção -b 1024 faz com que utilizemos um bloco de 1024 bytes e a opção -j cria um sistema com "journal" ext3.

Você poderá montá-lo para verificar se está tudo certo:

# mkdir /mnt/pendrive
# mount -t ext3 -o defaults /dev/sda1 /mnt/pendrive

Se tudo estiver correto você verá uma saída similar à seguinte com o comando mount sem opções (observe a linha onde encontra-se o dispositivo /dev/sda1, neste caso a última):

# mount
/dev/hdd5 on / type ext3 (rw)
proc on /proc type proc (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
/dev/sda1 on /mnt/pendrive ext3 (rw) =============> (Esta é a partição do pendrive montada)

Isso feito o pendrive estará pronto para receber o sistema operacional.

4) Instalação do sistema operacional no pen-drive.

Muito embora talvez esta etapa já seja plenamente conhecida pelos mais experientes, vamos lá:

Conecte o pendrive na porta USB, se já não estiver conectado.

Ligue (ou reinicie) o computador e entre no SETUP (DEL, F10 etc), selecionando a opção de boot pelo CD-ROM.

Coloque o CD-ROM da distribuição Linux na gaveta do drive de CD (no caso em questão utilizei Slackware-10.2).

Saia do SETUP salvando as alterações (normalmente opção F10); o sistema deverá dar o boot pelo CD-ROM.

Ao ser carregado o programa de instalação da distribuição, prossiga normalmente, prestando atenção particularmente nas seguintes etapas:

1. Procure selecionar instalação em modo texto, ou se não for possível, um modo gráfico de baixa resolução com poucas cores, para economizar memória.

2. Selecione uma instalação básica, contendo apenas os conjuntos de pacotes fundamentais para o primeiro boot do sistema, tais como sistema básico, aplicativos e ferramentas básicos em modo texto, suporte básico de rede, e se desejar, suporte básico ao sistema gráfico (pacote base do Xserver e fontes); evite os conjuntos de pacotes pesados nesta fase, tais como desenvolvimento, linguagens e ferramentas de programação, fontes do Kernel, aplicações gráficas, documentação, gerenciadores de janelas, jogos etc.; você poderá instalá-los posteriormente via rede ou CD-ROM quando der o boot pelo pendrive; uma instalação mais leve será mais rápida e menos propensa a erros, além do que possivelmente ocupará menos memória após o boot.

Procure sempre selecionar as opções de instalação manuais, evitando sempre que possível as automáticas; sempre que possível escolha configurar os componentes de hardware após a instalação.

Carregamento de módulos de suporte no Kernel: Se o Kernel de sua distribuição suportar automaticamente dispositivos USB e o sistema de arquivos a ser utilizado na instalação (no caso ext3), não será necessário nenhum procedimento para tanto (é o caso por exemplo do Slackware 10.2).

Entretanto, algumas distribuições como Debian possuem uma etapa específica para o carregamento de módulos de suporte ao hardware utilizado na instalação; se for este o caso, você deverá procurar e selecionar os módulos usbcore, usb-storage e usb-uhci (ou usb-ohci como explicado acima), além dos módulos relativos ao sistema de arquivos a ser utilizado (no caso do ext3, seriam os módulos jbd e ext3); pode ser que estes módulos já sejam selecionados por padrão pela distribuição, mas em qualquer caso você deverá verificar.

Quando chegar o momento de particionar, formatar e definir a partição root ( / ), se tudo estiver de acordo com o tópico acima, o dispositivo /dev/sda e a partição /dev/sda1 deverão ser apresentados pelo programa de instalação, como opções a serem selecionadas; selecione então a partição /dev/sda1, especificando que deverá ser montada como root ( / ); e de preferência, evite utilizar as opções ou etapas de particionamento e formatação oferecidas pelo programa de instalação, desmarcando-as, não selecionando-as, ignorando-as ou pulando-as, conforme o caso; pois você já realizou estas etapas no tópico 3 acima e isto evitará qualquer problema imprevisto durante a instalação.

Evite ou ignore também as opções ou etapas relativos à memória virtual ou swap, conforme explicado no tópico "Configurações utilizadas e pré-requisitos" deste artigo. De qualquer forma, posteriormente explicaremos como criar um arquivo de memória virtual no pendrive, para quando for executado o sistema operacional nele instalado, bem como seus programas e aplicativos.

Evite eventuais opções de auto-detecção de hardware, pois o hardware a ser utilizado não será necessariamente o da máquina que você está utilizando para instalar o sistema no pendrive; além do que como se trata de uma instalação atípica, podem haver problemas que paralisem a instalação; você deverá configurar a carga dos módulos manualmente após a instalação, quando der o boot pelo pendrive, para isso utilizando os arquivos ou utilitários específicos de cada distribuição.

A instalação do gerenciador de inicialização (LILO ou GRUB) deverá ser ignorada (você estará inicializando a máquina através do disquete), ou se não for possível, feita no dispositivo root (no caso /dev/sda1) NUNCA no MBR.

Ignore ou desmarque também aquelas opções de tornarem outras partições visíveis para o Linux, incluindo-as no fstab para montagem automática, uma vez que a máquina que você utilizará provavelmente não será a mesma da instalação, nem possuirá HD.

5) Compilação do kernel para o disquete.

Não entraremos em maiores detalhes sobre a compilação do Kernel, pois é um assunto que foge ao escopo deste artigo, e deve ser de domínio da maioria dos usuários Linux não-iniciantes; entretanto, há amplo e farto material sobre o assunto na Internet, revistas e livros, não oferecendo maiores dificuldades.

Uma vez que o Kernel deverá ser o mais compacto possível, para caber no disquete de boot, juntamente com outros arquivos necessários (principalmente o initrd, que no caso ilustrado ficou com 430 KB), até 800 KB deverá ser um tamanho viável.

Para obter este Kernel compacto, faça uma seleção criteriosa das opções a serem marcadas para compilação, no programa de configuração do Kernel (menuconfig, xconfig etc.). Selecione apenas as opções rigorosamente necessárias, dando preferência sempre a compilar as opções como módulos ( < M > ) ao invés de embutidas no Kernel ( [ * ] ou < * > ). Preste atenção particularmente aos seguintes itens:

• Suporte a drive de disquete padrão (Seção "Block devices" - "Normal floppy disk support") - configure embutido no Kernel ( < * > );
• Suporte a ramdisk e initrd (logo abaixo do suporte ao floppy) - configure embutidos no Kernel;
• Suporte a USB (usbcore, usb-storage, usb-uhci ou usb-ohci ou ambos): configurar como módulos ( < M > );
• Suporte ao sistema de arquivos do pendrive (jbd, ext3 etc...): configurar como módulos.
• Suporte aos demais componentes de hardware das máquinas que irão dar boot com o pendrive: placas de rede, interfaces IDE genéricas ou específicas, drives de CD-ROM ou similares, teclados, mouses, porta paralela, serial, outros dispositivos USB etc. (mais detalhes no tópico 2 abaixo) - configure como módulos sempre que possível..

Observações:

Para que você possa utilizar o disquete e o pendrive no maior número possível de máquinas diferentes observe as recomendações abaixo:

• Configure e compile um Kernel genérico para i386 (opção 386);
• Uma vez que o Kernel carregado do disquete após o boot rodará como o Kernel do sistema operacional instalado no pendrive, é altamente recomendável, senão fundamental, que você compile todos os módulos dos quais possivelmente irá necessitar, para suportar o hardware da(s) máquina(s) na(s) qual(is) irá utilizar o pendrive; como exemplos mais comuns estão os módulos "genéricos" e de interfaces IDE mais conhecidas, módulos de placas de redes mais conhecidas (p. ex. PCI e ISA), módulos referentes a sistemas de arquivos mais utilizados (p. ex. Linux ext2, VFAT e NTFS para acessar HDs formatados com o MS-Windows, etc.), módulos de placas de som mais conhecidas se for o caso etc. Se houver hardware específico, tal como interfaces SCSI, selecione-o também.

Desta forma você terá um conjunto disquete + pendrive "genérico", que poderá ser utilizado em um número muito grande de máquinas de configurações diferentes, sem a necessidade de criar novos conjuntos disquete + pendrive para cada máquina diferente com a qual se deparar.
Uma vez selecionadas todas as opções, salve o arquivo .config e inicie a compilação:

(assumiremos daqui por diante que você está no diretório dos fontes do Kernel, p.ex. /usr/src/linux ou /usr/src/linux-X.Y.Z, onde X.Y.Z é a versão do Kernel, p.ex. 2.4.31)

# make dep clean bzImage
(aguarde a compilação do Kernel terminar)
# make modules

ATENÇÃO: Se o Kernel que está carregado, na máquina que você está utilizando para a compilação, é da mesma versão do Kernel que está sendo compilado (p. ex. ambos são 2.4.31), antes de instalar os módulos (make modules_install), renomeie o diretório contendo os módulos de seu atual Kernel no diretório /lib:

# mv /lib/modules/X.Y.Z /lib/modules/X.Y.Z.bkp
# make modules_install

O comando make modules_install criará um novo diretório /lib/modules/X.Y.Z . Renomeie-o como por exemplo:

# mv /lib/modules/X.Y.Z /lib/modules/X.Y.Z.pendrive

ATENÇÃO: Este diretório deverá ser posteriormente copiado para o diretório /lib/modules do pendrive, como mostraremos adiante.

A seguir renomeie novamente o diretório dos módulos anterior para seu nome original:

# mv /lib/modules/X.Y.Z.bkp /lib/modules/X.Y.Z

Este procedimento é necessário para evitar conflitos entre o Kernel do sistema hospedeiro e os módulos compilados para o pendrive, da próxima vez que você der o boot com sua máquina.

Estando ainda no diretório /usr/src/linux ou equivalente, verifique se o Kernel está com o tamanho adequado para caber no disquete:

# du -sh arch/i386/boot/bzImage
773K    arch/i386/boot/bzImage

No exemplo acima, constatamos que o Kernel está com 773 KB, o que é um tamanho adequado.

Para preservar o Kernel para futuras utilizações, você poderá copiar a imagem do Kernel para um novo diretório, como por exemplo:

# mkdir /opt/boot_pen
# cp arch/i386/boot/bzImage /opt/boot_pen/vmlinuz

6) Transferindo o diretório com os módulos para o pen-drive

Atenção a esta etapa, pois ela é muito importante.

Após o boot pelo disquete, o Kernel estará em condições de detectar o pendrive e montá-lo, mas isso não é tudo, pois poderá haver outros componentes de hardware na máquina que você precisará ou desejará que funcione, conforme explicado acima. Para tanto, o Kernel deverá encontrar o diretório com seus módulos (compilados como descrito acima) em /lib/modules do pendrive. O Kernel não poderá utilizar o diretório de módulos original da instalação do sistema operacional no pendrive, pois mesmo que seja da mesma versão (p.ex. 2.4.31), muito possivelmente haverá incompatibilidade, pois o Kernel foi recompilado. Assim sendo, você deverá copiar o diretório de módulos renomeado acima como /lib/modules/X.Y.Z.pendrive para o diretório /lib do pendrive, conforme abaixo:

Carregue os módulos de suporte ao pendrive (se já não estão carregados - veja com lsmod):

# modprobe usb-storage
# modprobe usb-uhci (ou ohci dependendo de sua máquina)

Monte o pendrive:

# mount -t auto -o defaults /dev/sda1 /mnt/pendrive
# cd /mnt/pendrive/lib/modules
# mv X.Y.Z X.Y.Z.bkp (onde X.Y.Z é a versão do Kernel, como p.ex. 2.4.31)
# cp -R /lib/modules/X.Y.Z.pendrive X.Y.Z

7) Criando um arquivo de swap no pen-drive

Como dito anteriormente, uma vez que não criamos uma partição de swap durante a instalação no pendrive, poderemos criar agora um arquivo com a mesma finalidade, visando uma melhor operação do sistema operacional nele instalado, quando for executado. Para tanto verifique inicialmente se há espaço disponível no pendrive.

Para simplificar as coisas, assumindo que conforme acima, o pendrive esteja montado em /mnt/pendrive, vamos "entrar nele" temporariamente como nosso diretório root, através do comando chroot:

# chroot /mnt/pendrive
(A partir deste momento o diretório /mnt/pendrive passa a ser seu diretório-raiz ou root, e todos os comandos que você emitir levarão isto em consideração)

# df -h
Filesystem            Size    Used   Avail Use% Mounted on
/dev/sda1              954M  825M   81M  92%    /

Como verificado acima, existem 81 MB disponíveis no pendrive. Você poderá criar um arquivo de swap com os seguintes comandos:

# dd if=/dev/zero of=/swap bs=1k count=64k
65536+0 records in
65536+0 records out

Isso criará um arquivo vazio de 64 MB na partição root do pendrive chamado /swap. Agora você precisa configurá-lo como swap (a saída do comando pode variar):

# mkswap /swap
Setting up swapspace version 1, size = 67104 kB
no label, UUID=dfad2954-b253-4ec3-a19c-5be0a304cb0c

Finalmente adicione o arquivo de swap ao fstab do pendrive através da seguinte linha, utilizando seu editor favorito, para que o arquivo de swap seja habilitado todas as vezes que o sistema operacional for carregado.

# vi /etc/fstab
/swap        swap             swap        defaults         0   0

Agora "saia" do comando chroot:

# exit

Com isto você retorna ao diretório de trabalho anterior, localizado no sob o diretório root original de sua máquina (por exemplo, o /root ou seu /home).

Atenção: você deve tomar um certo cuidado ao desconectar o pendrive da máquina, pois ele é um dispositivo sensível, e pode ser danificado facilmente; por este motivo, siga as instruções abaixo para poder removê-lo e testá-lo em outra máquina:

Desmonte o pendrive:

# umount /mnt/pendrive

Descarregue o módulo do pendrive do Kernel:

# modprobe -r usb-storage

Ou simplesmente:

# rmmod usb-storage

Poderemos agora passar ao próximo tópico.