1.  Instalar las fuentes del núcleo

Elegir un núcleo

El corazón alrededor del cual se construyen todas las distribuciones es el núcleo (kernel) de Linux. Es la capa entre los programas de usuario y el hardware del sistema. Gentoo proporciona a sus usuarios varias fuentes posibles para el núcleo. Una lista completa está disponible en la Guía Gentoo del Kernel.

Para los sistemas basados en ${arch} tenemos gentoo-sources (fuentes del núcleo parcheadas para características extra).

Escoja sus fuentes del núcleo e instálelas con emerge.

# emerge gentoo-sources

Al mirar en /usr/src debería ver un enlace simbólico llamado linux apuntando a las fuentes del núcleo actual. En este caso, el enlace a las fuentes instaladas apunta a gentoo-sources-${kernel-version}. Tenga en cuenta que su versión puede ser diferente.

# ls -l /usr/src/linux
 lrwxrwxrwx    1 root   root    12 Oct 13 11:04 /usr/src/linux -> linux-${kernel-version}

Ahora vamos a configurar y compilar las fuentes del núcleo. Puede usar genkernel, que construirá un núcleo genérico como el usado por el CD de instalación. Explicaremos la configuración "manual", puesto que es la mejor forma de optimizar el entorno.

Para configurar manualmente el núcleo, podemos seguir en Predeterminado: Configuración manual. En cambio,para usar genkernel podemos leer Alternativa: Usar genkernel.

1.  Predeterminado: Configuración manual

Introducción

Configurar manualmente un núcleo es visto frecuentemente como el procedimiento más difícil al que tiene que enfrentarse un usuario de Linux. Nada más lejos de la realidad: después de configurar algunos núcleos no recordaremos si era algo difícil ;)

Sin embargo, una cosa sí es cierta: debemos conocer nuestro sistema para configurar el núcleo manualmente. Mucha información se puede recolectar instalando pciutils (emerge pciutils) que contiene lscpi. Ahora podremos utilizar lscpi en el entorno chroot. Podemos ignorar cualquier advertencia pcilib (tales como "pcilib: cannot open /sys/bus/pci/devices") que produzca lspci. Si ejecutamos lscpi desde un entorno no chroot, los resultados serán los mismos. También podemos ejecutar lsmod para ver que módulos del núcleo usa el CD de instalación (podría proporcionar consejos sobre qué activar).

Ahora hay que ir al directorio de las fuentes para configurar el núcleo. Empiece configurando un núcleo que pueda arrancar en la mayoría de máquinas PowerPC de 32 bits, ejecutando make pmac32_defconfig. Una vez que la configuración predeterminada haya sido generada, ejecutemos make menuconfig que presentará un menú de configuración basado en ncurses.

# cd /usr/src/linux
# make pmac32_defconfig
# make menuconfig

Se presentarán varias secciones de configuración. Listaremos primero algunas opciones que se deben activar (de otro modo Gentoo no funcionará, o no funcionará adecuadamente sin configuración adicional).

Activar opciones requeridas

Primero vayamos a File Systems y seleccionemos el soporte de los sistemas de archivo a usar. No los compile como módulos, ya que entonces su sistema Gentoo no podrá montar las particiones. También seleccione el sistema de archivos /proc y Virtual memory. Asegúrese de activar soporte para particiones Amiga si está usando un equipo Pegasos, o particiones Macintosh si está usando un equipo Apple.

File systems ---->
  Pseudo Filesystems ---->
(/proc puede estar ya forzado por su configuración, si es así,
verá --- en su lugar)
    [*] /proc file system support
    [*] Virtual memory file system support (former shm fs)
  Partition Types --->
    [*] Advanced partition support
    [*] Amiga partition table support
    [*] Macintosh partition map support

(Deben seleccionarse una o más de las siguientes opciones según se necesite)
   <*> Reiserfs support
   <*> Ext3 journalling file system support
   <*> Second extended fs support
   <*> XFS filesystem support

Los usuarios de las máquinas NewWorld y OldWorld querrán soporte para HFS también. Los usuarios de OldWorld lo necesitan para copiar en la partición MacOS los núcleos compilados. Los usuarios de NewWorld lo necesitan para configurar la partición especial Apple_Bootstrap:

File Systems --->
  Miscellaneous filesystems --->
    <M> Apple Macintosh file system support
    <M> Apple Extended HFS file system support

Si usamos PPPoE o un módem para conectar a Internet, necesitaremos las siguientes opciones del núcleo:

Device Drivers --->
   Network device support --->
    <*> PPP (point-to-point protocol) support
    <*>   PPP support for async serial ports
    <*>   PPP support for sync tty ports

Las dos opciones de compresión no molestan pero no son siempre necesarias. La opción PPP over Ethernet solo podría ser usada por ppp cuando se configure para realizar PPPoE en modo núcleo.

¡No olvide incluir soporte en el núcleo para su tarjeta ethernet! Muchos de los nuevos computadores Apple usan el controlador ethernet SunGEM. Lo viejos iMac usan el controlador BMAC.

Device Drivers --->
   Network device support --->
    Ethernet (10 or 100Mbit) --->
      [*] Ethernet (10 or 100Mbit)
      <*>   Generic Media Independent Interface device support
      <*>   MACE (Power Mac ethernet) support
      <*>   BMAC (G3 ethernet) support
      <*> Sun GEM support

Si estamos arrancando desde FireWire, necesitaremos activar estas opciones. Si no queremos compilar el soporte embebido, necesitaremos incluir estos módulos y sus dependencias en un initrd.

  Device Drivers --->
    IEEE 1394 (FireWire) support --->
      <*> IEEE 1394 (FireWire) support
      <*>   OHCI-1394 support
      <*>   SBP-2 support (Harddisks etc.)

Si estamos arrancando desde USB, necesitaremos habilitar estas opciones, si no queremos compilar el soporte embebido, necesitaremos incluir estos módulos y sus dependencias en un initrd.

  Device Drivers --->
    USB support --->
      <*> Support for Host-side USB
      <*>   OHCI HCD support
      <*>   USB Mass Storage support

No desactive el soporte en el núcleo para el framebuffer porque se necesita para un arranque exitoso. Si utilizamos un chipset basado en NVIDIA debemos utilizar el framebuffer de Open Firmware. Si utilizamos un chipset basado en ATI, debemos utilizar el controlador según el chipset (Mach64, Rage128 o Radeon).

  Device Drivers --->
  Graphics support --->
    <*> Support for frame buffer devices
    [*] Open Firmware frame buffer device support
    <*> ATI Radeon display support
    <*> ATI Rage128 display support
    <*> ATI Mach64 display support
    Console display driver support --->
    <*> Framebuffer Console support

Continuaremos con Compilar e instalar al acabar de configurar el núcleo.

Compilar e instalar

Ahora que ya está configurado el núcleo, es el momento para compilarlo e instalarlo. Saldremos del menú de configuración y ejecutaremos las siguientes órdenes:

# make && make modules_install

Cuando el núcleo haya terminado de compilar, copiemos la imagen a /boot tal como se muestra a continuación. Si tiene una partición boot separada, como en los ordenadores Pegasos, asegúrese que esté montada correctamente. Si estamos utilizando BootX para arrancar, copiaremos el núcleo después.

Yaboot y BootX usan un núcleo sin comprimir a diferencia de otros gestores de arranque. El núcleo sin comprimir se llama vmlinux y se encontrará en /usr/src/linux una vez que el núcleo haya terminado de compilarse. Si está utilizando una máquina Pegasos, el microcódigo del Pegasos necesita un núcleo comprimido llamado zImage que puede encontrarse en /usr/src/linux/arch/powerpc/boot/images.

# cd /usr/src/linux
Note que su versión del núcleo puede ser diferente
(Apple/IBM)
# cp vmlinux /boot/${kernel-name}
(Pegasos)
# cp arch/powerpc/boot/images/zImage /boot/${kernel-name}

Ahora continuemos con Instalar módulos del núcleo separadamente.

1.  Alternativa: Usar genkernel

Ahora que el árbol de las fuentes del núcleo está instalado, es hora de compilarlo usando el guión genkernel que automáticamente construirá uno por nosotros. genkernel trabaja configurando un núcleo prácticamente idéntico al núcleo del CD de instalación. Esto significa que cuando se usa genkernel para construir el núcleo, el sistema generalmente detectará todo el hardware durante el arranque, tal como lo hace el CD de instalación. Debido a que genkernel no requiere ninguna configuración manual del núcleo, es una solución ideal para esos usuarios que no se sienten cómodos compilando sus propios núcleos.

Ahora, veamos como usar genkernel. Primero, hay que hacer emerge al ebuild de genkernel:

# emerge genkernel

Si estamos usando firewire o USB para arrancar, necesitaremos añadir los módulos al initrd. Editaremos /usr/share/genkernel/arch/ppc/modules_load y cambiaremos MODULES_FIREWIRE="ieee1394 ohci1394 sbp2" para el soporte de FireWire o MODULES_USB="usbcore ohci-hcd ehci-hcd usb-storage" para el soporte de USB.

Antes de compilar las fuentes, el fichero fstab necesita algunos pequeños ajustes. El resto del fstab se podrá completar en un paso posterior, por lo que no se preocupe ahora por los detalles. Si no quiere crear una partición separada para boot (NO bootstrap, que es algo diferente), quite la línea que se refiere a /boot en /etc/fstab. Esto tendrá que hacerse en muchos ordenadores Apple.

# nano -w /etc/fstab
Quite esta línea
/dev/BOOT  /boot    ext2    noauto,noatime    0 2

Ahora hay que compilar las fuentes del núcleo ejecutando genkernel --genzimage all. Para Pegasos necesitaremos usar una configuración diferente y crear una zImage en lugar del núcleo vmlinux usado en las máquinas Apple. Recordaremos que como genkernel compila un núcleo que soporta casi todo el hardware, esta compilación ¡tardará un rato en terminar!

Observaremos que si la partición de arranque no usa ext2 o ext3 como sistema de archivos, debemos configurar manualmente el núcleo usando genkernel --menuconfig all para agregar soporte para el sistema de archivos correspondiente en el núcleo (no como módulo). Los usuarios de LVM2 probablemente querrán añadir también el argumento --lvm2.

# genkernel all

# genkernel --genzimage all

Una vez que genkernel haya terminado, un núcleo, un conjunto completo de módulos y un disco ram de inicio (initramfs) habrán sido creados. Usaremos el núcleo e initrd para configurar un gestor de arranque más tarde en este documento. Escribiremos los nombres del núcleo y de initrd ya que se necesitarán para el archivo de configuración del gestor de arranque. initrd se iniciará inmediatamente después del arranque para realizar la autodetección de hardware (igual que en el CD de instalación) antes que se inicie el sistema "real". Nos aseguraremos de escribir también los parámetros de arranque necesarios, puesto que se requieren para un arranque correcto con genkernel.

Note que su versión del núcleo puede ser diferente
# ls /boot/${genkernel-name} /boot/initramfs-genkernel-ppc-${genkernel-initrd}

Ahora continuaremos con (Configurar el sistema).

1.  Módulos del núcleo

Configurar los Módulos

Debe listar los módulos que quiera cargar automáticamente en /etc/conf.d/modules. Puede agregar opciones extra a los módulos si así lo desea.

Para ver todos los módulos disponibles, ejecute el comando find. No olvide sustituir "<kernel version>" por la versión del kernel que acaba de compilar:

# find /lib/modules/<kernel version>/ -type f -iname '*.o' -or -iname '*.ko' | less

Por ejemplo, para cargar automáticamente el módulo 3c59x.ko (el driver para una tarjeta de red específica de la familia 3Com), edite el archivo /etc/conf.d/modules y escriba el nombre del módulo.

# nano -w /etc/conf.d/modules
modules_2_6="3c59x"

Continúe la instalación con (Configurar su Sistema).