Manual de Gentoo: MIPS/Instalación/Núcleo

From Gentoo Wiki
Jump to:navigation Jump to:search
This page is a translated version of the page Handbook:MIPS/Installation/Kernel and the translation is 100% complete.
Other languages:
Deutsch • ‎English • ‎español • ‎français • ‎italiano • ‎polski • ‎português do Brasil • ‎русский • ‎தமிழ் • ‎中文(中国大陆)‎ • ‎日本語 • ‎한국어
Manual MIPS
Instalación
Acerca de la instalación
Elegir los medios
Configurar la red
Preparar los discos
Instalar el stage3
Instalar el sistema base
Configurar el núcleo
Configurar el sistema
Instalar las herramientas
Configurar el cargador de arranque
Terminar
Trabajar con Gentoo
Introducción a Portage
Ajustes USE
Características de Portage
Sistema de guiones de inicio
Variables de entorno
Trabajar con Portage
Ficheros y directorios
Variables
Mezclar ramas de software
Herramientas adicionales
Repositorios personalizados de paquetes
Características avanzadas
Configuración de la red
Comenzar
Configuración avanzada
Configuración de red modular
Conexión inalámbrica
Añadir funcionalidad
Gestión dinámica


Opcional: Instalar firmware y/o microcódigo

Antes de comenzar a configurar las secciones del núcleo, es conveniente tener en cuenta que algunos dispositivos requieren la instalación de firmware adicional en el sistema para que funcionen correctamente. Suele ser el caso de las tarjetas de red, especialmente las tarjetas de red inalámbricas que se usan habitualmente tanto en ordenadores de escritorio como portátiles. Las tarjetas de vídeo modernas de marcas como AMD, Nvidia e Intel, a menudo necesitan archivos con firmware externos para ser completamente funcionales. La mayoría del firmware para hardware moderno está disponible en el paquete sys-kernel/linux-firmware. En los sistemas que utilizan tarjetas gráficas de estos proveedores, es aconsejable instalar ese paquete de firmware para tenerlo disponible antes de configurar y compilar el núcleo.

root #emerge --ask sys-kernel/linux-firmware

Además del específico para el hardware de gráficos y las interfaces de red, las CPUs también pueden requerir actualizaciones de firmware. Normalmente, este tipo de firmware se conoce como microcódigo. A veces se necesitan revisiones más recientes del microcódigo para parchear la inestabilidad, los problemas de seguridad u otros errores en el hardware de la CPU.

Las actualizaciones de microcódigo para las CPUs de AMD se distribuyen normalmente con el paquete linux-firmware mencionado anteriormente. El microcódigo para CPUs Intel se puede encontrar en el paquete sys-firmware/intel-microcode, que deberá instalarse por separado. Consulte el artículo sobre microcódigo para obtener más información sobre cómo aplicar actualizaciones de microcódigo.

Configuración y compilación del núcleo

Es el momento de configurar y compilar las fuentes del núcleo. Hay tres maneras de hacer esto:

  1. Se configura y construye el núcleo manualmente.
  2. Se utiliza una herramienta llamada genkernel para construir e instalar automáticamente el núcleo Linux.
  3. Usar un núcleo de la Distro para compilar e instalar automáticamente el núcleo Linux como cualquier otro paquete.

La configuración manual se explica como la opción predeterminada, ya que es la mejor manera de optimizar un entorno.

El eje alrededor del cual se construyen todas las distribuciones es el núcleo Linux. Es la capa entre los programas de usuario y el hardware del sistema. Gentoo proporciona a sus usuarios varias fuentes de núcleo. Una lista completa está disponible en la página resumen del Núcleo.

Instalar las fuentes

Al instalar y compilar manualmente el núcleo para sistemas basados en mips, Gentoo recomienda el paquete sys-kernel/mips-sources.

Elija sus fuentes del núcleo e instálelas usando emerge.

root #emerge --ask sys-kernel/mips-sources

Esto instalará las fuentes del núcleo Linux en /usr/src/ usando la versión específica del kernel en el nombre de la ruta. No creará un enlace simbólico de forma automática a no ser que la USE=symlink esté habilitada en el paquete de fuentes del núcleo elegido.

Es una convencion que se mantenga el enlace simbólico /usr/src/linux, de modo que se refiera a las fuentes que correspondan con el núcleo que se está ejecutando actualmente. Sin embargo, este enlace simbólico no se creará por defecto. Una manera fácil de crear el enlace simbólico es utilizar el módulo kernel de eselect.

Para obtener más información sobre la finalidad del enlace simbólico y cómo administrarlo, consulte Kernel/Upgrade.

Primero, enumere todos los núcleos instalados:

root #eselect kernel list
Available kernel symlink targets:
  [1]   linux-3.16.5-gentoo

Para crear un enlace simbólico llamado linux, use:

root #eselect kernel set 1
root #ls -l /usr/src/linux
lrwxrwxrwx    1 root   root    12 Oct 13 11:04 /usr/src/linux -> linux-3.16.5-gentoo

Configuración manual

Introducción

La configuración manual de un núcleo a menudo se considera el procedimiento más difícil que un usuario de Linux debe realizar. Nada mas falso - ¡después de configurar un par de núcleos, nadie recuerda que fuera difícil!

Sin embargo, una cosa sí es cierta: es vital conocer el sistema para configurar manualmente un núcleo. La mayor cantidad de información se puede obtener instalando sys-apps/pciutils que contiene la orden lspci:

root #emerge --ask sys-apps/pciutils
Nota
Dentro de la jaula chroot, se pueden ignorar con tranquilidad las advertencias sobre pcilib (como pcilib: cannot open /sys/bus/pci/devices) que pudiera mostrar lspci.

Otra fuente de información sobre nuestro sistema consiste en ejecutar lsmod para ver los módulos del nucleo que ha usado el CD de instalación y tener así buenas indicaciones sobre qué habilitar.

Ahora vaya al directorio de las fuentes del núcleo y ejecute make menuconfig. Esto generará una pantalla de configuración basada en menús.

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

La configuración del núcleo Linux tiene muchas, muchas secciones. Veamos primero una lista con algunas opciones que deben ser activadas (en caso contrario Gentoo no funcionará o no funcionará adecuadamente sin ajustes adicionales). También tenemos la Guía de configuración del núcleo Gentoo en la wiki de Gentoo que también podría ayudar.

Activar opciones necesarias

Al usar sys-kernel/gentoo-sources, se recomienda encarecidamente que se habiliten las opciones de configuración específicas de Gentoo. Ésto asegura que estén disponibles un mínimo de características del núcleo requeridas para el funcionamiento adecuado:

KERNEL Habilitando opciones específicas para Gentoo
Gentoo Linux --->
  Generic Driver Options --->
    [*] Gentoo Linux support
    [*]   Linux dynamic and persistent device naming (userspace devfs) support
    [*]   Select options required by Portage features
        Support for init systems, system and service managers  --->
          [*] OpenRC, runit and other script based systems and managers
          [*] systemd

Naturalmente, la elección en las últimas dos líneas depende del sistema de inicio seleccionado (OpenRC vs. systemd). No está de más tener habilitado el soporte para ambos sistemas de inicio.

Al usar sys-kernel/vanilla-sources, las selecciones adicionales para los sistemas de inicio no estarán disponibles. Es posible habilitar el soporte, pero va más allá del alcance del manual.

Asegúrese que todos los controladores vitales para el arranque del sistema (como pueden ser los de SCSI, etc.) están compilados dentro del núcleo y no como módulos o, de lo contrario, su sistema no será capaz de arrancar correctamente.

A continuación seleccione con exactitud el tipo de procesador. Se recomienda habilitar las funcionalidades MCE (si están disponibles) de manera que los usuarios puedan ser informados de cualquier problema en este hardware. En algunas arquitecturas (como x86_64) estos errores no son presentados a través de dmesg sino de /dev/mcelog. Para ello se requiere el paquete app-admin/mcelog.

A continuación seleccione Maintain a devtmpfs file system to mount at /dev de modo que los archivos de dispositivo críticos estén disponibles cuanto antes en el proceso de inicio (CONFIG_DEVTMPFS y CONFIG_DEVTMPFS_MOUNT):

KERNEL Habilitar soporte devtmpfst
Device Drivers --->
  Generic Driver Options --->
    [*] Maintain a devtmpfs filesystem to mount at /dev
    [*]   Automount devtmpfs at /dev, after the kernel mounted the rootfs

Verificar que se ha activado el soporte de disco SCSI (CONFIG_BLK_DEV_SD):

KERNEL Habilitar el soporte de disco SCSI
Device Drivers --->
   SCSI device support  --->
      <*> SCSI disk support

Vaya ahora a File Systems y seleccione el soporte para los sistemas de archivos que se vayan a usar en el sistema. No compile como módulo el sistema de archivos que vaya a utilizar para el sistema de archivos raíz, de lo contrario su sistema Gentoo podría no conseguir montar la partición raíz. También deberá seleccionar Virtual memory y /proc file system. Selecionar una o más de las siguientes opciones según las necesidades del sistema (CONFIG_EXT2_FS, CONFIG_EXT3_FS, CONFIG_EXT4_FS, CONFIG_MSDOS_FS, CONFIG_VFAT_FS, CONFIG_PROC_FS y CONFIG_TMPFS):

KERNEL Seleccionar los sistemas de archivos necesarios
File systems --->
  <*> Second extended fs support
  <*> The Extended 3 (ext3) filesystem
  <*> The Extended 4 (ext4) filesystem
  <*> Reiserfs support
  <*> JFS filesystem support
  <*> XFS filesystem support
  <*> Btrfs filesystem support
  DOS/FAT/NT Filesystems  --->
    <*> MSDOS fs support
    <*> VFAT (Windows-95) fs support
 
  Pseudo Filesystems --->
    [*] /proc file system support
    [*] Tmpfs virtual memory file system support (former shm fs)

Si está usando PPPoE para conectarse a Internet, o está usando un módem telefónico, habilite las siguientes opciones (CONFIG_PPP, CONFIG_PPP_ASYNC y CONFIG_PPP_SYNC_TTY):

KERNEL Seleccionar los controladores PPPoE necesarios
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 están de más aunque no son necesarias, como tampoco lo es la opción PPP sobre Ethernet, que sólo podría utilizarse cuando se configure un núcleo en modo PPPoE.

No olvide incluir el soporte en el núcleo para su tarjeta de red (Ethernet o inalámbrica).

Muchos sistemas también tienen varios núcleos a su disposición, así que es importánte activar Symmetric multi-processing support (CONFIG_SMP):

KERNEL Activar el soporte SMP
Processor type and features  --->
  [*] Symmetric multi-processing support
Nota
En sistemas multi-núcleo, cada núcleo cuenta como un procesador.

Si utiliza dispositivos de entrada USB (como un teclado o un ratón) u otros, no olvide activarlos también (CONFIG_HID_GENERIC y CONFIG_USB_HID, CONFIG_USB_SUPPORT, CONFIG_USB_XHCI_HCD, CONFIG_USB_EHCI_HCD, CONFIG_USB_OHCI_HCD):

KERNEL Activar soporte para dispositivos de entrada USB
Device Drivers --->
  HID support  --->
    -*- HID bus support
    <*>   Generic HID driver
    [*]   Battery level reporting for HID devices
      USB HID support  --->
        <*> USB HID transport layer
  [*] USB support  --->
    <*>     xHCI HCD (USB 3.0) support
    <*>     EHCI HCD (USB 2.0) support
    <*>     OHCI HCD (USB 1.1) support


Preparar la configuración

Importante
En las máquinas Origin 200/2000, Indigo2 Impact (R10000), Octane/Octane2 y O2, se necesita un núcleo de 64 bits para arrancar el sistema. En estas máquinas, hacer emerge de sys-devel/kgcc64 para crear un compilador cruzado con el que construir núcleos de 64 bits.

En muchos de los sistemas soportados se dispone de .configs ocultos entre los fuentes del núcleo. No todos los sistemas tienen estas configuraciones distribuidas así. Aquéllos que los tienen se pueden configurar mediante las órdenes descritas en la tabla de abajo.

Sistema Orden de configuración
Servidores Cobalt make cobalt_defconfig
Indy, Indigo2 (R4k), Challenge S make ip22_defconfig
Origin 200/2000 make ip27_defconfig
Indigo2 Impact (R10k) make ip28_defconfig
O2 make ip32_defconfig

Todas las imágenes de instalación de Gentoo ofrecen una opción de configuración del núcleo que es parte de la propia imagen y accesible a través de /proc/config.gz. Esto se puede utilizar en muchos casos. Es mejor si se consulta la misma que la del núcleo que está corriendo en ese momento. Para extraerla, simplemente lanzarla a través de zcat como se muestra abajo.

root #zcat /proc/config.gz > .config
Importante
Esta configuración del núcleo está preparada para una imagen de arranque por red. Esto es, espera encontrar una imagen de sistema de archivos raíz en algún lugar cercano como un directorio para initramfs o un dispositivo de bucle para initrd. Cuando se lance make menuconfig, no se debe olvidar entrar en la configuración general (General Setup) y deshabilitar las opciones para initramfs.

Personalizar la configuración

Una vez se encuentra una configuración, descargarla en el directorio de fuentes del núcleo y renombrarla a .config. Una vez hecho esto, lanzar make oldconfig para poner todo al día conforme a las instrucciones de arriba y personalizar la configuración antes de compilar.

root #cd /usr/src/linux
root #cp /ruta/a/config-ejemplo .config
root #make oldconfig

Por ahora, sólo aprete la tecla ENTER (o Return) en cada pregunta para aceptar las opciones predeterminadas...

root #make menuconfig
Importante
En la sección de hacking del núcleo existe una opción titulada "Are You Using A Cross Compiler?". Esto le indica a los ficheros Makefile del núcleo que antepongan "mips-linux-" (o mipsel-linux ... etc) a las órdenes gcc y as cuando se construya el núcleo. Esta opción se debería deshabilitar incluso si se está realizando una compilación cruzada. En lugar de esto, si se necesita realizar una compilación cruzada, especificar el prefijo utilizando la variable CROSS_COMPILE tal y como se muestra en la siguiente sección.
Importante
Existe un problema conocido con JFS y ALSA en sistemas Octane systems en los que ALSA no funciona. Dada la naturaleza experimental de JFS en MIPS, se recomienda no utilizar JFS en este momento.

Compilar e instalar

Ahora que el núcleo está configurado, es hora de compilarlo e instalarlo. Salga de la configuración e inicie el proceso de compilación:

Nota
En las máquinas de 64 bits, especificar CROSS_COMPILE=mips64-unknown-linux-gnu- (o mips64el-... si se trata de un sistema little-endian) para utilizar el compilador de 64 bits.

Para compilar de forma nativa:

root #make vmlinux modules modules_install

Para compilar de forma cruzada en la máquina destino, ajustar mips64-unknown-linux-gnu- de la forma adecuada:

root #make vmlinux modules modules_install CROSS_COMPILE=mips64-unknown-linux-gnu-

Cuando se compile en otra máquina como una x86, utilizar las siguientes órdenes para compilar el núcleo e instalar los módulos en un directorio específica que se va a transferir a la máquina destino.

root #make vmlinux modules CROSS_COMPILE=mips64-unknown-linux-gnu-
root #make modules_install INSTALL_MOD_PATH=/algúnlugar
Importante
Cuando se compile un núcleo de 64 bits para el Indy, Indigo2 (R4k), Challenge S u O2, utilizar el objetivo vmlinux.32 en lugar de vmlinux, de lo contrario, la máquina no arrancará. Esto se hace para saltarse la PROM que no reconoce el formato ELF64.
root #make vmlinux.32
Nota
Es posible habilitar compilaciones en paralelo usando make -jX, siendo X el número de compilaciones paralelas que se permite que lance el proceso. Es similar a las instrucciones anteriores sobre /etc/portage/make.conf con la variable MAKEOPTS.

Lo de arriba creará vmlinux.32, que es el núcleo final.

Cuando se ha terminado de compilar el núcleo, copiar la imagen a /boot/.

Nota
En los servidores Cobalt, el cargador de arranque espera ver una imagen de núcleo comprimida. Recuerde hacer gzip -9 al fichero una vez está en /boot/.
root #cp vmlinux /boot/kernel-3.16.5-gentoo

Para lo servidores Cobalt, comprimir la imagen del núcleo:

root #gzip -9v /boot/kernel-3.16.5-gentoo


(Opcional) Construir un sistema de archivos de inicio en memoria -Initramfs-

En ciertos casos es necesario construir un initramfs - un sistema de archivos inicial basado en memoria (initial ram-based file system). El caso mas común se da cuando partes importantes del sistema de archivos (como /usr/ o /var/) están en particiones separadas. Con un initramfs, estas particiones pueden ser montadas utilizando las herramientas disponibles dentro del initramfs.

Sin un initramfs, hay riesgo de que el sistema no se inicie de forma correcta ya que las herramientas responsables de montar los sistemas de archivos requieren información que se encuentra en sistemas de archivos que aún no están montados. Un initramfs obtendrá los archivos necesarios y los pondrá en otro archivo que se utiliza una vez se inicie el núcleo, pero antes de que el control se ceda a la herramienta init. Los guiones en el initramfs se asegurarán de que las particiones se han montado correctamente antes de que el sistema continúe con su inicio.

Importante
Si usa genkernel, debe usarse tanto para compilar el núcleo como el initramfs. Cuando se usa genkernel solo para generar un initramfs, es crucial pasar --kernel-config=/path/to/kernel.config a genkernel o los initramfs generados pueden no funcionar con un núcleo creado manualmente. Tenga en cuenta que los núcleos construidos manualmente van más allá del alcance del manual. Consulte el artículo configuración del núcleo para obtener más información.

Para instalar un initramfs, en primer lugar instale sys-kernel/dracut, a continuación genere el initramfs:

root #emerge --ask sys-kernel/dracut
root #dracut --kver=3.16.5-gentoo

El initramfs se almacenará en /boot/. Puede encontrar este archivo simplemente listando aquéllos ficheros que comienzan por initramfs:

root #ls /boot/initramfs*

Ahora continúe con Módulos del núcleo.

Alternativa: Usar genkernel

Si la configuración manual parece demasiado complicada, considere usar genkernel. La configuración y construcción del núcleo se hará de forma automática.

genkernel funciona configurando un núcleo de forma casi idéntica a la forma en que se configura el núcleo del CD de instalación. Esto significa que cuando se usa genkernel para compilar el núcleo, el sistema normalmente detectará el hardware con el que fue creado para poder usarlo en el momento del arranque, al igual que lo hace el CD de instalación. genkernel puede ser una solución útil para aquellos usuarios que no se sientan cómodos compilando sus propios núcleos. Tenga en cuenta que genkernel no genera automáticamente una configuración del núcleo personalizada para el hardware en el que se ejecuta.

Ahora, veamos como usar genkernel. Primero, haga emerge al ebuild de sys-kernel/genkernel:

root #emerge --ask sys-kernel/genkernel

A continuación, edite el fichero /etc/fstab de modo que la línea que contiene /boot/ en el segundo campo tenga el primer campo apuntando al dispositivo correcto. Si se sigue el ejemplo de particionamiento del manual, entonces este dispositivo es, seguramente /dev/sda1 con un sistema de archivos ext4. Esto haría que la línea en el archivo tuviera el siguiente aspecto:

root #nano -w /etc/fstab
ARCHIVO /etc/fstabConfiguración del punto de montaje /boot
/dev/sda1	/boot	ext4	defaults	0 2
Nota
/etc/fstab será configurado de nuevo mas adelante en la instalación. Es necesario configurar ahora el valor correcto para /boot ya que la aplicación genkernel la tiene en cuenta.

Ahora, compile las fuentes del núcleo ejecutando genkernel all. Tenga en cuenta que, dado que genkernel compila un núcleo que soporta casi todo el hardware, ¡esta compilación tardará un rato en terminar!

Nota
Si su partición/volumen raiz no usa como sistema de archivos ext4 podría ser necesario configurar manualmente su núcleo con genkernel --menuconfig all y agregar soporte para su sistema de archivos dentro del núcleo (es decir, no como módulo). Los usuarios de LVM2 probablemente querrán añadir también el argumento --lvm.
root #genkernel all

Una vez que genkernel haya terminado, un núcleo, un conjunto completo de módulos y un disco de inicio en ram (initramfs) se habrán creado. Usaremos el núcleo e initramfs para configurar un gestor de arranque más tarde en este documento. Anote los nombres del núcleo y de initramfs ya que los necesitará cuando edite el archivo de configuración del gestor de arranque. El initramfs se iniciará inmediatamente después del arranque para realizar la autodetección de hardware (igual que en el CD de instalación) antes del inicio del sistema "real".

root #ls /boot/vmlinu* /boot/initramfs*


Módulos del núcleo

Configurar los módulos

Nota
Opcionalmente se pueden listar los módulos hardware de forma manual. udev normalmente cargará todos los módulos hardware que se han detectado en el momento de ser conectados en la mayoría de los casos. El algunas caos el hardware menos común necesitará ayuda para cargar sus controladores.

Los módulos que necesitan ser cargados automáticamente se listan en los ficheros /etc/modules-load.d/*.conf indicando un módulo en cada línea. Las opciones extra para los módulos, en caso de ser necesarias, se deben definir en los ficheros /etc/modprobe.d/*.conf.

Para ver todos los módulos disponibles, ejecute la siguiente orden find. No olvide sustituir "<versión del núcleo>" por la versión del núcleo que acaba de compilar:

root #find /lib/modules/<versión del núcleo>/ -type f -iname '*.o' -or -iname '*.ko' | less

Por ejemplo, para cargar automáticamente el módulo 3c59x.ko (que es un controlador para una tarjeta de red específica de la familia 3Com), edite el archivo /etc/modules-load.d/network.conf y escriba el nombre del módulo. El nombre real del fichero no es representativo para el cargador.

root #mkdir -p /etc/modules-load.d
root #nano -w /etc/modules-load.d/network.conf
ARCHIVO /etc/modules-load.d/network.confForzar la carga del módulo 3c59x
3c59x

Continúe la instalación con Configurar el sistema.