DPD Kernel
De Gleducar, http://www.gleducar.org.ar
|
|
Contenido |
Conceptos del núcleo
Los dos diferentes tipos de Kernel son:
- A. Monolitico
- Los núcleos monolíticos son aquellos que soportan todo el hardware, el sistema de red, el sistema de archivos compilado dentro de un solo archivo.
- B. Modular
- Los núcleo modulares son aquellos en que los controladores (módulos) se encuentran compilados como objetos, los cuales el núcleo puede cargar o descargar según sea necesario. Los módulos se encuentran en /lib/modules
La ventaja de un núcleo modular es que no siempre es necesario recompilarlo cuando nuevo hardware es agregado o reemplazado en el sistema. Los núcleos monolíticos inician un poco más rápido que los núcleos modulares, pero no superan en rendimiento a un núcleo modular.
El núcleo modular
Muchos componentes del núcleo Linux deben ser compilados como módulo que el núcleo pueda dinamicamente cargar o remover.
- Los módulos para un núcleo en particular son guardados en
/lib/modules/<kernel-version>. - Los mejores componentes para modularizar son aquellos que no se requieron en el momento de carga, por ejemplo dispositivos perisféricos y sistema de archivos suplementarios.
- Los módulos del núcleo son controlado por las herramientas proporcionadas por el paquete modutils
- lsmod lista los modulos cargados
- rmmod remueve el módulo especificado
- insmod inserta el módulo especificado
- modprobe inserta el módulo especificado con sus dependncias listada en modules.dep
- modinfo muestra información sobre un módulo: autor, tipo de licencia y parámetros
Muchos módulos dependen de la presencia de otros módulos. Una base de datos de la dependencia de módulos (en texto plano) es almacenada en /lib/modules/<kernel-version>/modules.dep. El programa que genera esta base de datos es depmod, el cual se inicia en el arranque (por ejemplo dentro de el script rc.sysinit).
modprobe puede cargar cualquier módulo y las dependencias de modulos listados en modules.dep (o conf.modules)
Busca por ejemplo los modulos que seran cargados en el momento de carga de tvaudio.
grep tvaudio /lib/modules/kernel-version/modules.dep /lib/modules/kernel-version/kernel/drivers/media/video/tvaudio.o: \ /lib/modules/kernel-version/kernel/drivers/i2c/i2c-core.o
Esto significa que el modulo i2c-core.o sera tambien cargado cuando usamos modprobe. Esta dependencia tambien aparece cuando listamos los modulos con lsmod:
lsmod Module Size Used by Not tainted tvaudio 16796 0 (unused) i2c-core 19236 0 [tvaudio]
/etc/modules.conf es consultado para determinar los parametros de cada modulo(IRQ y E/S) pero es mas comun que contenga una lista de alias. Un alias refiere a un dispositivo usando un nombre comun. Por ejemplo el primer dispositivo ethernet siempre esta referido como eth0 y no con el nombre particular del modulo.
Ejemplo del archivo /etc/modules.conf:
alias eth0 e100 alias usb-core usb-uhc alias sound-slot-0 i810_audio alias char-major-108 ppp_generic alias ppp-compress-18 ppp_mppe # 100Mbps full duplex options eth0 e100_speed_duplex=4
modinfo dará informacion sobre los modulos.
modinfo tvaudio filename: /lib/modules/kernel-version/kernel/drivers/media/video/tvaudio.o description: "device driver for various i2c TV sound decoder / audiomux chips" author: "Eric Sandeen, Steve VanDeBogart, Greg Alexander, Gerd Knorr" license: "GPL" parm: debug int parm: probe short array (min = 1, max = 48), description "List of adapter,address pairs to scan additionally" parm: probe_range short array (min = 1, max = 48), description "List of adapter,start-addr,end-addr triples to scan additionally" parm: ignore short array (min = 1, max = 48), description "List of adapter,address pairs not to scan" parm: ignore_range short array (min = 1, max = 48), description "List of adapter,start-addr,end-addr triples not to scan" parm: force short array (min = 1, max = 48), description "List of adapter,address pairs to boldly assume to be present" parm: tda9874a_SIF int parm: tda9874a_AMSEL int parm: tda9874a_STD int parm: tda8425 int parm: tda9840 int
Para obtener informacion sobre las opciones de parametro usamos modinfo -p, paraobtener informacion sobre el tipo de licencia usamos modinfo -l, etc.
kmod es un mecanismo que permite al nucleo cargar los modulos automaticamente (rara vez necesitamos cargar los modulos manualmente). Esto es en realidad u modulo compilado estaticamente que necesita ser configurado previo a la compilacion del nucleo. El comando usado por el nucleo para cargar los modulos es /proc/sys/kernel/modprobe.
Recompilación rutinaria del núcleo
Extracción del código fuente
El codigo fuente del nucleo esta guardado en /usr/src/linux, que es un enlace simbólico al directorio /usr/src/(kernel-version). Cuendo se extrae un nuevo archivo con el codigo fuente del nucleo se recomienda:
- quitar el enlace simbolico al viejo codigo fuente del nucleo...
rm linux
El código fuente que ha sido empaquetado como un RPM frecuentemente crea un enlace llamado linux-2-4
- extraer el nuevo código fuente (ej linux-2.4.20.tar.bz2)
tar xjf linux-2.4.29.tar.bz2
NOTA: Los núcleo Linux de la serie 2.2 crean un directorio llamado linux en vez de linux-version. Por esta razón el primer paso es importante, de otra forma podriamos sobrescribir una versión vieja de las fuentes con la versión nueva. Desde la serie 2.4 el nombre del directorio es linux-version.
- crea un enlace simbólico llamado linux desde el directorio nuevotory
ln -s linux-2.4.20 linux
El núcleo ya está casi configurado, pero primero necesitamos asegurarnos que los viejos archivos binarios no están presentes en el árbol de directorio de las fuentes, esto es realizado con el comando mrproper.
Advertencia: este comando también eleminará el archivo de configuración del núcleo .config, al cual nos referiremos más adelante.
cd /usr/src/linux make mrproper
Nota: mrproper es una marca escandinava de limpiador que se promociona como "Limpia más que limpio", es un paso más allá de "make clean".
Configuración del núcleo
Primero edita el archivo Makefile y asegurate que la variable "EXTRAVERSION" es diferente a la de la versión existente:
- VERSION = 2
- PATCHLEVEL = 4
- SUBLEVEL = 20
- EXTRAVERSION = -test
El núcleo está ahora listo para ser configurado. Esto se hace creando el archivo de configuración llamado .config. Esto se realiza desde el directorio del núcleo /usr/src/linux usando cualquier de los siguiente comandos:
make menuconfig make xconfig make config
Todos estos métodos guardarán la configuración en el archivo /usr/src/linux/.config
Es comunmente más facil configurar un nuevo núcleo usando uno viejo, esto se realiza usando el comando oldconfig. Este solo mostrará al usuario las nuevas opciones o caracteristicas en el código fuente del núcleo (si el núcleo es nuevo o ha siso parcheado).
Nota: Algunas distribuciones como RedHat tienen un subdirectorio que contiene los archivos .config con una serie de configuracion predefinidas.
Para habilitar las funciones del núcleo (con make menuconfig) es necesario entrar a una categoria de mayor nivel moviendose on las flechas y presionando enter para acceder sobre la categoria deseada. Una vez dentro de la categoria escojida, el presionar la barra espaciadora cambiará el estado de alguna opción (una función del núcleo o un controlador).
Las posibles opciones son:
- soportado (compilado estaticamente) [*]
- modular (compilado modularmente) [M]
- no soportado [ ]
La misma elección s posible con las otras aplicaciones de configuración de nucleos y xconfig.
Problema: Para que menuconfig funcione es necesario contar con las cabeceras de las librerias ncurses. Estas son provistas por el paquete ncurses-devel y deben ser instaladas previamente.
Compilación del núcleo
make clean
El comando make toma las intrucciones que figuran dentro del Makefile y compila lo que es necesario. Si algunos archivos estan presentes, make los usará. En particular archivos con la extensión ".o". Para asegurarse que todas las opciones de configuracion dentro de .config son usadas para reconstruir los archivos ncesario es necesario ejecutar make clean (elimina los archivos ".o")
Nota: no es necesario usar make clean en esta etapa si usamos previamente el ya mencionado make mrproper.
make dep
Una vez que la configuración del núcleo está completa, es necesario transferir todas esas opciones a los subdirecotrio que código fuente del núcleo. Esto se realiza con el comando dep. Los archivos llamdos .depend que contienen rutas hacia los archivos de cabecera (*.h) presentes en /usr/src/linux/include, son generados de esta forma.
El núcleo en si mismo es compilado con alguno de estos comandos:
make zImage make bzImage
Cuando el comando termina sin ningún error, existirá un archivo llamado vmlinux dentro de /usr/src/linux/. Este es el núcleo descomprimido.
Los otros dos comandos crearan un archivo adicional en /usr/src/linux/arch/i386/boot/ llamados zImage y bzImage respectivamente. Estas son versiones del núcleos comprimidas con gzip y bzip2. A continuación se explica como usar estos archivos.
make modules
Los módulos son compilados mediante make modules.
make modules_install
Una vez que los módulos son compilados necesitan ser copiados al subdirecorio llamado /lib/modules. El comando make modules_install hará precisamente eso.
Comandos de la compilación del núcleo:
make dep make clean make bzImage make modules make modules_install
Instalando un nuevo núcleo
El nuevo núcleo puede ser encontrado en /usr/src/linux/arch/i386/boot/bzImage, dependiendo de la arquitectura de su sistema. Este archivo debe ser copiado al directorio /boot y renombrado a vmlinuz-<full-kernel-version>
cp /usr/src/linux/arch/i386/boot/bzImage /boot/vmlinuz-<full-kernel-version>
Luego es necesario editar el archivo de conffiguración de nuestro gestor de arranque: para LILO /etc/lilo.conf o para GRUB /boot/grub/grub.conf. Copia el núcleo compilado a la seccion "iamge" dentro de tu núcleo y agrega una nueva sección dentro del archivo de configuración de nuestro gestor de arranque:
Editando el archivo /etc/lilo.conf
prompt
timeout=50
message=/boot/message
image=/boot/vmlinuz
label=linux
root=/dev/hda6 Sección existente
read-only
image=/boot/vmlinuz-<full-kernel-version>
label=linux-new Sección añadida
root=/dev/hda6
read-only
La tabla de simbolos para los procedimiento del núcleo puede ser copiada en el directorio /boot:
cp /usr/src/linux/System.map /boot/System.map-<full-kernel-version>
La versión completa del núcleo
En un sistema, la versión del núcleo en ejecución puede ser obtenida mediante
uname -r
La versión del núcleo puede ser tambien mostrada en las terminales virtuales usando la opcion \k dentro del archivo /etc/issue.
Ramdisks iniciales
Si cualquier módulo compilado dinámicamente es necesario en el momento de arranque (ej: un driver scsi, o el moculo l istema de archivos de la partición principal) seran cargado usando el ramdisk inicial.
El ramdisk inicial es creado con el comando mkinitrd el cual recibe solo dos parámetros el nombre del archivos y la versión de núcleo.
Si se usa un ramdisk inicial es necesario añadir la línea initrd= dentro de /etc/lilo.conf
mkinitrd /boot/initrd-full-version.img full-version
Optional
Es recomandable copiar el arhchivo /usr/src/linux/.config a /boot/config-<full-kernel-version>, solo para mantener un registro de las caracteristicas de los distintos núcleos que han sido compilados.
Re-instalando LILO
Finalmente LILO necesita ser ejecutado para actualizar el menu de arranque. Primero es recomendable ejecutarlo en modo de prueba para detectar cualquier error en el archivo de configuración:
NOTA: el comando lilo debe ser ejecutado luego de cualquier cambio efecutado sobre /etc/lilo.conf
3.8 Proceder con GRUB
Para actualizar el cargaor de arranque de GRUB tan solo ejecutamos grub <dispositivo>:
grub /dev/hda
Esto cargará las opciones almacenadas en el archivo de configuración en el cargador de arranque de nuestra PC.