Linux Avanzado Tema 1: Kernel: Configuración, Compilación y Actualización. Virtualización aplicación

de

plataforma

vs.

virtualización

de

Las máquinas virtuales (VMs), en su primera encarnación, fueron creadas por IBM hace 60 años como una forma para compartir sistemas principales grandes y costosos. Y aunque el concepto todavía se aplica en los sistemas IBM actuales, el concepto popular de una VM se ha ampliado y se ha aplicado a numerosas áreas que están por fuera de la virtualización.

Origen de la máquina virtual El primer sistema operativo en soportar virtualización completa para VMs fue el Conversational Monitor System (CMS). El CMS soportaba tanto virtualización como para-virtualización. A comienzos de los años 1970, IBM introdujo la familia VM de sistemas, que ejecutaba múltiples sistemas operativos de usuario individual, sobre su VM Control Program—un hipervisor temprano tipo-1. El área de la virtualización que IBM popularizó en los años 1960 se conoce como virtualización de plataforma (o sistema) . En esta forma de virtualización, la plataforma de hardware subyacente es virtualizada para ser compartida con cierto número de sistemas operativos y usuarios diferentes. Otra aplicación de la VM es ofrecer la propiedad de independencia de máquina. Esta forma, llamada virtualización de aplicación (oproceso) , crea un entorno abstracto (para una aplicación), haciéndolo independiente del entorno físico.

Aspectos de las máquinas virtuales de aplicaciones En el espacio de virtualización de aplicaciones, las VMs se utilizan para proporcionar un entorno independiente del hardware para la ejecución de aplicaciones. Por ejemplo, considere la Figura 1. En la parte superior está el lenguaje de alto nivel, que los desarrolladores usan para construir aplicaciones. Mediante un proceso de compilación, este código de alto nivel se compila en una representación intermedia llamada código objeto. En un entorno no virtualizado, este código objeto (que es independiente de la máquina) se compila en el código de la máquina nativa para ser ejecutado en la plataforma física. Pero en un entorno de virtualización de aplicación, el código objeto se interpreta dentro de una máquina abstracta para proporcionar la ejecución. La ventaja clave aquí es que el mismo código objeto puede ejecutarse en cualquier plataforma de hardware que soporte la máquina abstracta (el intérprete)). Figura 1. VM de aplicación para independencia de plataforma

Además de crear un entorno portátil en el cual ejecutar el código objeto, la virtualización de aplicación proporciona un entorno en el cual aislar la VM de otras aplicaciones que se estén ejecutando en el host. Esta configuración tiene numerosas ventajas, como una administración detallada de recursos y seguridad.

1

El código objeto de una VM también es llamado bytecode , definiendo específicamente un conjunto de instrucciones que ejecuta un intérprete. El término bytecode evolucionó desde implementaciones que implementaban eficientemente sus conjuntos de instrucciones virtuales como bytes individuales para simplicidad y desempeño. Ahora, vamos a ver algunos de los usos históricos de la virtualización de aplicación y a explorar algunos de sus usos modernos.

Historia de la máquina virtual Uno de los primeros usos de la virtualización de aplicación ocurrió en los años 1960, para el Basic Combined Programming Language (BCPL). El BCPL era un lenguaje imperativo desarrollado por Martin Richards en la Universidad de Cambridge y fue un precursor del lenguaje B que luego evolucionó hasta el lenguaje C que usamos hoy.

El BCPL, antes y ahora Aunque el BCPL se originó en 1966, todavía está bajo un activo desarrollo actualmente por su creador, Martin Richards. El primer compilador del BCPL se escribió para el sistema IBM 7094 bajo el Compatible Time Sharing System, uno de los primeros sistemas operativos desarrollados de tiempo compartido. Actualmente, usted puede usar el BCPL en una variedad de sistemas, incluyendo Linux. Aunque el BCPL tiene un lenguaje de alto nivel (similar a C), el código intermedio que generaba el compilador se llamó O-code(código objeto). El O-code podía ser interpretado en una máquina física (como una VM) o compilado a partir de O-code para el lenguaje de máquina nativa del host. Esta funcionalidad proporcionó numerosas ventajas en el contexto de independencia de máquina. Primero, al abstraer el O-code de la máquina física, este podía ser fácilmente interpretado por una variedad de hosts. Y segundo, el O-code podía ser compilado para la máquina nativa, lo cual permitía el desarrollo de un compilador y múltiples compiladores que traducen el O-code a instrucciones de máquina nativa (una tarea más simple). Esta independencia de máquina hizo que el lenguaje fuera portátil entre máquinas y por lo tanto popular debido a su disponibilidad. A comienzos de los años 1970, la Universidad de California en San Diego, implementó el enfoque de VM para la ejecución de Pascal compilado. Llamaron a la representación intermedia p-code, el cual buscó la independencia del hardware subyacente para simplificar el desarrollo del compilador Pascal (en lugar de depender de una arquitectura abstracta de pseudo-máquina). El lenguaje Forth también aplicó VMs, concretamente, a arquitecturas de dirección-cero o basadas en apilamientos. En 1972, Xerox PARC introdujo el lenguaje Smalltalkque dependía de una VM para ejecutarse. Smalltalk fue uno de los primeros lenguajes construidos alrededor del concepto de objetos. Tanto Smalltalk como p-code influenciaron fuertemente uno de los lenguajes basa dos en VM más prominentes que existe actualmente: el lenguaje Java. Java apareció por primera vez en 1995, desarrollado por Sun Microsystems, y desarrolló la idea de una programación independiente de la plataforma, mediante la Java Virtual Machine. Desde entonces, la tecnología Java se ha convertido en un bloque de construcción de las aplicaciones Web. Desde los scripts del lado del servidor hasta los applets del lado del cliente, la tecnología Java incrementó el conocimiento sobre las tecnologías de VM e introdujo tecnologías más nuevas que conectaron la interpretación y la ejecución nativa, usando técnicas de compilación justo-a-tiempo (JIT). Muchos otros lenguajes introdujeron el concepto de VMs. El lenguaje Erlang (desarrollado por Ericsson) usa una VM para ejecutar códigos de bytes Erlang y también para interpretar Erlang del árbol abstracto de sintaxis de la fuente. El lenguaje liviano Lua (desarrollado por la Pontificia Universidad Católica de Río de Janeiro, en Brasil) incluye una VM basada en el registro. Cuando se ejecuta un programa Lua, este se traduce en códigos de bytes y luego se ejecuta en la VM. Más adelante, este artículo observa un código de bytes estándar que puede utilizarse para cualquier lenguaje.

Las máquinas virtuales hoy El uso de las VMs para proporcionar una abstracción al host físico es un método común históricamente y hoy evoluciona y encuentra aplicación. Observemos algunas de las soluciones de fuente abierta más recientes que presionan el concepto de VMs hacia el futuro.

2

Dalvik VM Dalvik es una tecnología de VM de fuente abierta desarrollada por Google para el sistema operativo Android. Android es un kernel Linux modificado que incorpora una pila de software para dispositivos móviles (Figura 2). A diferencia de muchas tecnologías de VM que dependen de arquitecturas basadas en apilamientos, la Dalvik VM es una arquitectura virtual basada en registro (vea Recursos para más información sobre la arquitectura y el conjunto de instrucciones). Aunque las arquitecturas basadas en apilamientos son conceptualmente simples y eficientes, pueden introducir nuevas ineficiencias, como tamaños de programa más grandes (debido al mantenimiento del apilamiento). Figura 2. Arquitectura simple de un apilamiento de software Dalvik

Como Dalvik es la arquitectura de VM, descansa en un lenguaje de alto nivel compilado en códigos de bytes que la VM entiende. En lugar de reinventar la rueda, Dalvik depende del lenguaje Java como el lenguaje de alto nivel para el desarrollo de aplicaciones. Dalvik también depende de una herramienta especial llamada dx para convertir archivos de clase Java en ejecutables de VM Dalvik. Para desempeño, la VM puede también modificar el ejecutable Dalvik (dex) para optimizaciones adicionales, incluyendo compilación JIT, que traduce las instrucciones dex en instrucciones nativas para desempeño nativo. Este proceso también es conocido como traducción dinámica y es una técnica popular para aumentar el desempeño de las tecnologías de VM. Como se muestra en la Figura 2, un ejecutable Dalvik (junto con una instancia de la VM) es aislado como un proceso individual en el espacio de usuario Linux. La VM Dalvik ha sido diseñada para soportar la ejecución de múltiples VMs (en procesos independientes) simultáneamente. La VM Dalvik no está implementada en el tiempo de ejecución del estándar Java y por lo tanto, no hereda las licencias sobre este. En lugar de ello, Dalvik es una implementación limpia publicada bajo licencia de Apache 2.0.

Parrot Otro interesante proyecto de VM de fuente abierta es Parrot. Parrot es otra tecnología de VM basada en registro diseñada para ejecutar eficientemente lenguajes dinámicos (lenguajes que realizan ciertas operaciones en el momento de ejecución, que normalmente se ejecutan en el momento de la compilación, como alterar el sistema de tipo). Parrot fue diseñada originalmente como un tiempo de ejecución para Perl6, pero es un entorno flexible para la ejecución de códigos de bytes para muchos lenguajes (vea la Figura 3). Parrot soporta varios formularios de ingreso de información, como Parrot Abstract Syntax Tree (PAST), que es útil para los escritores de compilador; el Parrot Intermediate Representation (PIR), que es una representación de alto nivel que puede ser escrita por personas o automáticamente por compiladores; y el Parrot Assembly (PASM), que está por debajo de la representación intermedia pero que es útil tanto para personas como para compiladores. Cada formulario se traduce y ejecuta en código de byte Parrot en la VM Parrot.

3

Figura 3. Arquitectura simple de la VM Parrot

Parrot soporta un gran número de lenguajes, pero un aspecto que la hace tan interesante es su soporte tanto de lenguaje dinámico como de lenguaje estático, incluyendo soporte específico para lenguajes funcionales. El Listado 1 muestra un uso simple de PASM. Para instalar Parrot con Ubuntu, simplemente use apt-get: sudo apt-get install parrot La siguiente sesión ilustra un programa simple de manipulación de cadena de caracteres en Parrot. Note que aunque Parrot implementa este código como un conjunto, es mucho más rico en atributos que el conjunto al que usted puede estar acostumbrado(a). Las instrucciones en Parrot usan la sintaxis dest,src , de manera que el Listado 1 muestra una cadena de caracteres siendo cargada con texto. La instrucción length determina la longitud de la cadena de caracteres y la carga en un registro entero. La instrucción print emite el argumento para una salida estándar (stdout), y concat implementa la concatenación de cadena de caracteres. Listado 1. Ejemplo PASM

$ more test.pasm set S1, "Parrot" set S2, "VM" length I1, S1 print I1 print "\n" concat print print

S3, S1, S2 S3 "\n"

end $ parrot test.pasm 6 ParrotVM $

4

Usted encontrará un rico conjunto de instrucciones dentro de Parrot (vea Recursos para más detalles). Los autores optaron por riqueza de recursos sobre minimalismo, facilitando la codificación y construcción de compiladores para Parrot VM. Incluso con el alto nivel de abstracción que proporciona el PASM, el PIR es incluso más confortable para programadores de alto nivel. El Listado 2 proporciona un programa de ejemplo escrito en PIR y ejecutado por la VM Parrot. Este ejemplo declara una sub-rutina llamada square que eleva el número al cuadrado y lo retorna. Este proceso es llamado por la subrutina principal (etiquetada con :main para decirle a Parrot que lo ejecute primero) para imprimir el resultado. Listado 2. Ejemplo de PIR

$ more test.pir .sub square .param int arg arg *= arg .return(arg) .end .sub main :main .local int value value = square(19) print value print "\n" .end $ parrot test.pir 361 $

Parrot proporciona un rico entorno de virtualización de aplicación, para el desarrollo de aplicaciones independientes del tipo de máquina que también busquen alta eficiencia. Usted puede encontrar un gran número de lenguajes que soporten primeros planos de compilador diseñados para Parrot, incluyendo C, Lua, Python, Scheme, Smalltalk, y muchos otros.

Otros usos de las máquinas virtuales de aplicación Hasta ahora, usted ha visto los usos históricos de la virtualización de aplicaciones, incluyendo dos ejemplos presentes. Dalvik está potenciando el desarrollo de aplicaciones con las terminales actuales, y Parrot proporciona una infraestructura eficiente para escritores de compilador, para lenguajes estáticos y dinámicos. Pero el concepto de virtualización de aplicación está siendo implementado en otras numerosas áreas externas al enfoque que hemos explorado hasta ahora. Un uso particularmente interesante es similar probablemente se está ejecutando en la computadora que usted está usando en este momento. Los sistemas que utilizan la interfaz Extensible Firmware Interface (EFI), que es un reemplazo de la BIOS, pueden implementar controladores de firmware en lo que se conoce como el EFI Byte Code (EBC). El firmware de sistemas incluye un intérprete que es invocado cuando se carga una imagen EBC. Este concepto también está implementado en Open Firmware de Sun Microsystems usando Forth (un lenguaje que incluye su propia VM). En el mundo de los juegos, el uso de virtualización de aplicaciones no es nuevo. Muchos juegos modernos incluyen scripting de comportamiento de personajes que no son jugadores y de otros aspectos del juego, usando lenguajes que ejecutan códigos de bytes (como Lua). Pero el concepto de virtualización de aplicaciones en los juegos en realidad va mucho más atrás. Infocom, la compañía que introdujo las aventuras basadas en texto como Zork, vio el valor de la independencia del tipo de máquina en 1979. Infocom creó una VM llamada la Z-

5

machine (nombrada en honor a Zork). La Z-machine fue una VM que permitió llevar un juego de aventura más fácilmente a otras arquitecturas. En lugar de tener que llevar toda la aventura al nuevo sistema, se podía llevar un intérprete que representaba a la Z-machine. Esta funcionalidad simplificó el proceso de transporte hacia otros sistemas que podían tener un soporte de lenguaje diferente y arquitecturas de máquina totalmente diferentes. Aunque la meta de Infocom era facilitar el transporte entre las arquitecturas de su época, su trabajo continúa simplificando el transporte y da como resultado que estos juegos son accesibles a una nueva generación (incluso en plataformas móviles). Otras aplicaciones en juegos de las VM incluyen la ScummVM (que proporciona un entorno de VM para la Script Creation Utility para el lenguaje de scripting Maniac Mansion (SCUMM) (creado en 1987). SCUMM fue desarrollado por LucasArts para simplificar el desarrollo de juegos de aventuras gráficas. ScummVM se utiliza ahora en un gran número de juegos de aventura gráficos y de texto, en una variedad de plataformas.

Avanzando Así como la virtualización de plataforma (o sistema) ha cambiado la forma en la que aprovisionamos y administramos tanto servidores como PCs de escritorio, la virtualización de aplicaciones continúa proporcionando mecanismos eficientes para abstraer una aplicación de su sistema host. Dada la popularidad de este enfoque, será interesante ver una evolución del software y del hardware para hacer aún más flexible y eficiente la virtualización de aplicaciones.

Recursos Aprender •

Navegue más artículos developerWorks.

sobre

virtualización o todos

los

•

Wikipedia ofrece un gran conjunto de recursos para aprender más sobre las VMs (de plataforma y de aplicaciones). Visite la página sobre máquinas virtuales además de la página especialmente dedicada a máquinas p-code.

•

BCPL, el precursor al lenguaje B y a su sucesor C , creado en 1967 por Martin Richards. Usted puede leer el primermanual de referencia BCPL en línea como parte del Proyecto MAC. Usted también puede descargar la última versión del BCPL de su sitio principal.

•

EFI Byte Code, o EBC, especifica una capa interpretativa para controladores de componentes portátiles. Usted puede aprender más sobre EBC y UEFI en Boot Loaders: Small, Fast System Initialization (Dr. Dobb's, septiembre de 2010).

•

Aunque Forth ha estado presente desde los años 1970, continúa encontrando aplicaciones como lenguaje de VM. Usted puede encontrar a Forth aplicado en ciencias espaciales, sistemas incorporados, BIOS y en cualquier otra aplicación que exista con recursos escasos. Aprenda más sobre Forth en el Forth Interest Group.

•

Siga a developerWorks en Twitter, suscríbase a developerWorks, o siga a M. Tim Jones en Twitter.

•

En la zona Linux de developerWorks, encontrará cientos de artículos "cómo hacer" y tutoriales, así como descargas, foros de discusión, y gran cantidad de otros recursos para desarrolladores y administradores Linux.

•

Permanezca actualizado(a) con los Eventos técnicos y webcasts de developerWorks enfocados en una variedad de productos IBM y de temas de la industria TI.

un feed

artículos

de

Tim en

de tweets Linux en

6

•

Asista a presentaciones breves developerWorks ¡en vivo!, para actualizarse rápidamente sobre productos y herramientas IBM y sobre las tendencias de la industria.

•

Vea demostraciones developerWorks on-demand que van desde demostraciones sobre instalación y configuración de productos para principiantes, hasta funcionalidades avanzadas pera desarrolladores experimentados.

•

Las VMs de aplicaciones son populares en el mundo de los desarrolladores de juegos. Uno de los primeros usos lo hizo Infocom en sus juegos de aventura en texto (como Zork). Usted puede aprender más sobre la VM de Infocom llamada Z-machine, así como sobre los intérpretes que existen para diferentes plataformas. Otra aplicación de las VMs fue el SCUMM, usado por LucasArts en aventuras gráficas. SCUMM ha sido implementada como fuente abierta comoScummVM y está reviviendo juegos antiguos sobre nuevo hardware.

Autor:

M. Tim Jones es arquitecto de firmware integrado y el autor de Artificial Intelligence: A Systems Approach GNU/Linux Application Programming (ahora en su segunda edición), AI Application Programming (en su segunda edición) y de BSD Sockets Programming from a Multilanguage Perspective. Su experiencia en ingeniería va desde el desarrollo de kernels para vehículos espaciales geo-sincronizados hasta arquitectura de sistemas incorporados y desarrollo de protocolos de redes. Tim trabaja en Intel y vive en Longmont, Colorado. Compilación y edición: Ing. Sergio Aguilera. Facultad de Tecnología Informática. Universidad de Belgrano. [email protected] Todos los Derechos Reservados a IBM Corp. – Marzo 2012.

7

Archivos del kernel El kernel base de Linux viene en dos versiones: zImage, que está limitada a alrededor de 508 KB, y bzImage para kernels de mayor tamaño (de hasta 2.5 MB). Por lo general, las distribuciones modernas de Linux usan el formato de kernel bzImage para permitir la inclusión de más características. Usted podría esperar que, debido a que la "z" de la zImage indica compresión de gzip, la "bz" de la bzImage podría significar que aquí se usa una compresión bzip2. Sin embargo, la "b" simplemente significa "big" (grande): todavía se usa la compresión gzip. En cualquier caso, como está instalado en el directorio /boot/, el kernel de base a menudo recibe el nombre de vmlinuz. Por lo general el archivo /vmlinuz es un vínculo a un archivo de nombres de versiones como por ejemplo /boot/vmlinuz-2.6.10-5-386. Existen algunos otros archivos en el directorio /boot/ asociado con el kernel de base que usted deberá tomar en (a veces los encontrará, en cambio, en la raíz del sistema de archivos). El Mapa del sistema es una tabla que muestra las direcciones para los símbolos del kernel. initrd.img es usado a veces por el kernel de base para crear un sistema de archivos simple en un ramdisk antes del montajes del sistema de archivos completo.

Módulos del kernel Los módulos del kernel incluyen un código de kernel adicional que se puede cargar después del kernel de base. Los módulos por lo general ofrecen una de las siguientes funciones: • Unidades de dispositivos: Soportan un tipo específico de hardware • Unidades de sistemas de archivos: Brindan la capacidad opcional de leer y/o escribir un sistema de archivos en particular • Llamadas al sistema: La mayoría tiene soporte en el kernel de base, pero los módulos del kernel pueden agregar o modificar los servicios del sistema • Unidades de red: Implementan un protocolo de red particular • Cargadores ejecutables: Analizan y cargan formatos ejecutables adicionales

Cómo compilar un kernel Cómo obtener fuentes de kernel Lo primero que usted debe hacer para compilar un nuevo kernel de Linux es obtener el código fuente para uno. El principal lugar donde buscar fuentes de kernels son los Archivos de almacenamiento de Kernels de Linux (kernel.org; consulte la sección Recursos para ver un vínculo). El proveedor de su distribución podrá también brindarle sus propias fuentes de kernels actualizadas, las cuales reflejan las mejoras específicas del proveedor. Por ejemplo, quizás usted consiga y abra una versión reciente de kernel con comandos similares a los siguientes: Listado 1. Cómo conseguir y abrir un kernel % cd /tmp/src/ % wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.12.tar.bz2 % cd /usr/src/ % tar jxvfy /tmp/src/linux-2.6.12.tar.bz2

Es probable que necesite permisos de raíz para abrir las fuentes de /usr/src/. No obstante, usted podrá abrir o compilar un kernel en un directorio de usuario. Consulte kernel.org para ver otros formatos de archivos de almacenamiento y protocolos de descarga.

Cómo verificar sus fuentes de kernel Si usted ha obtenido y abierto con éxito un archivo de almacenamiento de fuentes de kernels, su sistema deberá incluir un directorio como el que aparece a continuación: /usr/src/linux-2.6.12 (o un directorio de hojas si usted abrió el archivo en otro lugar). Es de particular importancia el hecho de que ese directorio deberá incluir un archivo README que será conveniente leer para buscar

8

información actualizada. Por debajo de este directorio hay numerosos subdirectorios que incluyen archivos fuentes, que son principalmente archivos .c o .h. La principal tarea de ensamble de estos archivos fuente en un kernel que funcione se encuentra encriptada en el archivo Makefile, que es utilizado por la utilidad make.

Cómo configurar el compilado Una vez que usted ha conseguido y abierto sus fuentes de kernel, tundra que configurar su kernel objetivo. Existen tres indicadores al comando make que usted puede usar para configurar las opciones del kernel. Técnicamente, usted puede también editar de manera manual el archivo .config, pero en la práctica, no se recomienda hacerlo (de esta manera usted renuncia al contexto de información adicional y puede crear fácilmente una configuración inválida). Los tres indicadores sonconfig, menuconfig, y xconfig. De estas opciones, make config es casi tan burda como la edición manual del archivo .config; exige que usted configure cada una de las opciones (cientos de ellas) en un orden fijo, sin poder realizar una exploración hacia atrás. Para las terminales de texto, make menuconfig le ofrece una atractiva pantalla de curses (maldiciones) que usted puede navegar para establecer las opciones que desea modificar. El comando make xconfig es similar para las interfaces X11 pero agrega un atractivo visual de gráficos adicional (que es especialmente agradable en Linux 2.6+). Para muchas de las opciones de kernel usted cuenta con tres opciones: (1) incluir la capacidad en el kernel de base; (2) incluirla como un módulo de kernel; (3) omitir totalmente la capacidad. Por lo general, no se producen daños (a excepción de un poco de tiempo de compilación adicional) para la creación de numerosos módulos de kernel, debido a que los mismos no se cargan a menos que sea necesario. Para los medios con espacio restringido, usted podrá omitir completamente ciertas capacidades.

Cómo ejecutar la compilación Para realmente construir un kernel basado en las opciones que usted ha seleccionado, deberá seguir diversos pasos: • make dep: Solamente necesario en 2.4, ya no es necesario en 2.6. • make clean: Limpia los archivos de objetos previos, lo que es una buena idea especialmente si ésta no es su primera compilación de un árbol de kernels determinado. • make bzImage: Construye el kernel de base. En circunstancias especiales, será conveniente usar make zImage para una imagen de kernel pequeña. Además, podrá usar make zlilo para instalar el jernel directamente dentro del cargador de arranque lilo, omake zdiskpara crear un disco flexible de arranque. Por lo general, es preferible crear la imagen del kernel en un directorio como /usr/src/linux/arch/i386/boot/vmlinuz usando make bzImage, y copiar manualmente desde la misma. • make modules: Construye todos los módulos de kernel cargables que usted ha configurado para su construcción. • sudo make modules_install: Instala todos los módulos de construcción en un directorio como por ejemplo/lib/modules/2.6.12/, donde la hoja del directorio recibe el nombre según la versión del kernel.

Cómo crear un ramdisk inicial Si usted construyó unidades de arranque importantes como módulos, un ramdisk inicial será una manera de conseguir por sí mismo las capacidades durante el proceso inicial de arranque. Esto se aplica especialmente a las unidades de sistemas de archivos que se compilan como módulos de kernel. Básicamente, un ramdisk inicial es una seudopartición de raíz mágica que reside solamente en la memoria y luego es chroot “eada” a la partición de disco real (por ejemplo, si su partición de raíz se encuentra en RAID). Los tutoriales posteriores de esta serie se ocuparán de este tema en más detalle. La creación de una imagen de ramdisk inicial se realiza con el comando mkinitrd. Consulte la página man sobre su distribución de Linux específica para las opciones particulares dadas al comando mkinitrd. En el más simple de los casos, usted podrá ejecutar algo como lo que aparece a continuación:

9

Listado 2. Cómo crear un ramdisk % mkinitrd /boot/initrd-2.6.12 2.6.12

Cómo instalar el kernel de Linux compilado Una vez compilado con éxito el kernel de base y sus módulos asociados (lo cual puede llevar algún tiempo, quizás horas en una máquina lenta), usted deberá copiar la imagen del kernel (vmlinuz o bzImage) y el archivo System.map en su directorio/boot/. Una vez copiados los archivos necesarios del kernel en /boot/, e instalados los módulos del kernel usando make modules_install, usted deberá configurar su cargador de arranque – por lo general lilo o grub – para acceder al /a los kernel/s adecuado/s.

Información adicional El sitio kernel.org contiene una cantidad de vínculos útiles para obtener más información sobre las características de los kernels y los requerimientos para la compilación. Un documento detallado de particular importancia es la Kernel Rebuild Guide [Guía para la reconstrucción de kernels] de Kwan Lowe. Usted encontrará vínculos a ambos en la sección

Cómo emparchar un kernel Cómo obtener un parche Las fuentes de kernels de Linux se distribuyen como árboles de fuentes principales combinados con parches mucho más pequeños. Por lo general, hacerlo de esta manera le permite obtener un kernel de súper vanguardia con descargas mucho más veloces. Esta disposición le permite aplicar parches con fines especiales desde fuentes que no sean kernel.org. Si usted desea emparchar varios niveles de cambios, deberá obtener cada parche incremental. Por ejemplo, suponga que para el momento en que usted lee este documento, se encuentra disponible un kernel de Linux 2.6.14, y usted había descargado el kernel 2.6.12 en la sección anterior. Usted podrá ejecutar: Listado 3. Cómo obtener parches incrementales % wget http://www.kernel.org/pub/linux/kernel/v2.6/patch-2.6.13.bz2 % wget http://www.kernel.org/pub/linux/kernel/v2.6/patch-2.6.14.bz2

Cómo abrir y aplicar los parches Para aplicar los parches, primero deberá abrirlos usando bzip2 o gzip, según el formato de archivo de compresión que usted haya descargado; luego aplique cada uno de los parches. Por ejemplo: Listado 4. Cómo descomprimir y aplicar parches % bzip2 -d patch2.6.13.bz2 % bzip2 -d patch2.6.14.bz2 % cd /usr/src/linux-2.6.12 % patch -p1 < /path/to/patch2.6.13 % patch -p1 < /path/to/patch2.6.14 Una vez aplicados los parches, proceda con la compilación de la manera descripta en la sección anterior. make cleaneliminará los archivos de objetos adicionales que no reflejen los nuevos cambios.

10

Cómo personalizar un kernel Acerca de la personalización Gran parte de lo que usted pensaría sobre la personalización de un kernel se discutió en la sección de este tutorial sobre cómo compilar un kernel (específicamente, las opciones make [x|menu]config). Mientras se compilan un kernel de base y los módulos del kernel, usted puede incluir u omitir capacidades para lograr capacidades específicas, ejecutar perfiles, y utilización de memoria. Esta sección analiza maneras de modificar el comportamiento del kernel en tiempo de ejecución.

Cómo buscar información sobre un kernel en ejecución Linux (y otros sistemas operativos similares a UNIX) usa una técnica especial, generalmente consistente y elegante para almacenar información sobre un kernel en ejecución (u otros procesos en ejecución). El directorio especial /proc/ incluye seudoarchivos y subdirectorios con una amplia variedad de información sobre el sistema en ejecución. Cada proceso que se crea durante el tiempo de actividad de un sistema Linux crea su propio subdirectorio numérico con numerosos archivos de estado. Gran parte de esta información se encuentra resumida por comandos del nivel del usuario y herramientas del sistema, pero la información subyacente reside en el sistema de archivos /proc/. De particular interés para comprender el estado del kernel en sí mismo son los contenidos de /proc/sys/kernel.

Más acerca de los procesos actuales Si bien el estado de los procesos, especialmente de los procesos del espacio del usuario, no pertenecen al kernel en sí mismo, es importante comprenderlos si usted intenta retocar un kernel subyacente. la manera más sencilla de obtener un resumen de procesos es con el comando ps (también existen herramientas gráficas y de un nivel superior). Con una ID de proceso en mente, usted podrá explorar el proceso que se ejecuta. Por ejemplo: Listado 5. Cómo explorar el proceso en ejecución % ps PID TTY TIME CMD 16961 pts/2 00:00:00 bash 17239 pts/2 00:00:00 ps % ls /proc/16961 binfmt cwd@ exe@ maps mounts stat status cmdline environ fd/ mem root@ statm

Este tutorial no puede cubrir toda la información incluida en estos seudoarchivos de procesos, pero simplemente a modo de ejemplo, veamos parte de status: Listado 6. Una mirada al seudoarchivo status $ head -12 /proc/17268/status Name: bash State: S (sleeping) Tgid: 17268 Pid: 17268 PPid: 17266 TracerPid: 0 Uid: 0 0 0 0 Gid: 0 0 0 0

11

FDSize: 256 Groups: 0 VmSize: 2640 kB VmLck: 0 kB

El proceso del kernel Al igual que con los procesos de los usuarios, el sistema de archivos /proc/ contiene información útil sobre un kernel en ejecución. El directorio /proc/sys/kernel/ tiene particular importancia: Listado 7. Directorio /proc/sys/kernel/ % ls /proc/sys/kernel/ acct domainname msgmni printk shmall threads-max cad_pid hostname osrelease random/ shmmax version cap-bound hotplug ostype real-root-dev shmmni core_pattern modprobe overflowgid rtsig-max swsusp core_uses_pid msgmax overflowuid rtsig-nr sysrq ctrl-alt-del msgmnb panic sem tainted

Los contenidos de estos seudoarchivos muestran información sobre el kernel en ejecución. Por ejemplo: Listado 8. Una Mirada al seudoarchivo ostype % cat /proc/sys/kernel/ostype Linux % cat /proc/sys/kernel/threads-max 4095

Módulos del kernel ya cargados Al igual que con otros aspectos de un sistema Linux en ejecución, la información sobre los módulos del kernel cargados reside en el sistema de archivos /proc/, específicamente en /proc/modules. Sin embargo, por lo general, usted accederá a esta información usando la utilidad lsmod (que simplemente coloca un encabezado en la visualización de los contenidos en bruto de /proc/modules); cat /proc/modules muestra la misma información. Veamos un ejemplo: Listado 9. Contenidos de /proc/modules % lsmod Module lp parport_pc parport sg st sr_mod sd_mod scsi_mod ide-cd cdrom nfsd af_packet

Size Used by Not tainted 8096 0 25096 1 34176 1 [lp parport_pc] 34636 0 (autoclean) (unused) 29488 0 (autoclean) (unused) 16920 0 (autoclean) (unused) 13100 0 (autoclean) (unused) 103284 4 (autoclean) [sg st sr_mod sd_mod] 33856 0 (autoclean) 31648 0 (autoclean) [sr_mod ide-cd] 74256 8 (autoclean) 14952 1 (autoclean)

12

ip_vs floppy 8139too mii supermount usb-uhci usbcore rtc ext3 jbd

83192 0 (autoclean) 55132 0 17160 1 (autoclean) 3832 0 (autoclean) [8139too] 15296 2 (autoclean) 24652 0 (unused) 72992 1 [usb-uhci] 8060 0 (autoclean) 59916 2 38972 2 [ext3]

Cómo cargar módulos del kernel adicionales Existen dos herramientas para cargar módulos del kernel. El comando modprobe es de un nivel algo superior, y maneja las dependencias de carga – es decir, otros módulos de kernel que puede necesitar un módulo del kernel cargado. En su interior, sin embargo, modprobe es sólo un contenedor para llamar a insmod. Por ejemplo, imagine que usted desea cargar soporte para el sistema de archivos Reiser en el kernel (suponiendo que ya no está compilado en el kernel). Usted podrá usar la opción modprobe nv para ver simplemente qué es lo que haría el comando, pero sin cargar nada en realidad: Listado 10. Cómo verificar las dependencias con modprobe % modprobe -nv reiserfs /sbin/insmod /lib/modules/2.4.21-0.13mdk/kernel/fs/reiserfs/reiserfs.o.gz

En este caso, no hay dependencias. En otros casos, es probable que existan dependencias (que serían manejadas pormodprobe si se ejecutara sin -n). Por ejemplo: Listado 11. Más modprobe % modprobe -nv snd-emux-synth /sbin/insmod /lib/modules/2.4.21-0.13mdk/kernel/drivers/sound/ soundcore.o.gz /sbin/insmod /lib/modules/2.4.21-0.13mdk/kernel/sound/core/ snd.o.gz /sbin/insmod /lib/modules/2.4.21-0.13mdk/kernel/sound/synth/ snd-util-mem.o.gz /sbin/insmod /lib/modules/2.4.21-0.13mdk/kernel/sound/core/seq/ snd-seq-device.o.gz /sbin/insmod /lib/modules/2.4.21-0.13mdk/kernel/sound/core/ snd-timer.o.gz /sbin/insmod /lib/modules/2.4.21-0.13mdk/kernel/sound/core/seq/ snd-seq.o.gz /sbin/insmod /lib/modules/2.4.21-0.13mdk/kernel/sound/core/seq/ snd-seq-midi-event.o.gz /sbin/insmod /lib/modules/2.4.21-0.13mdk/kernel/sound/core/ snd-rawmidi.o.gz /sbin/insmod /lib/modules/2.4.21-0.13mdk/kernel/sound/core/seq/ snd-seq-virmidi.o.gz /sbin/insmod /lib/modules/2.4.21-0.13mdk/kernel/sound/core/seq/ snd-seq-midi-emul.o.gz /sbin/insmod /lib/modules/2.4.21-0.13mdk/kernel/sound/synth/emux/

13

snd-emux-synth.o.gz

Imagine que desea cargar ahora un módulo del kernel. Puede usar modprobe para cargar todas las dependencias mientras tanto, pero para ser explícito, usted deberá usar insmod. A partir de la información presentada anteriormente, quizás usted podría querer ejecutar, por ejemplo, insmod snd-emux-synth. Pero si hace esto sin haber cargado primero las dependencias, recibirá quejas sobre los “símbolos sin solución”. Por lo tanto, tratemos de usar en cambio el sistema de archivos de Reiser, que es independiente: Listado 12. Cómo cargar un módulo de kernel % insmod reiserfs Using /lib/modules/2.4.21-0.13mdk/kernel/fs/reiserfs/reiserfs.o.gz

Por suerte, su kernel soportará ahora un nuevo sistema de archivos. Usted podrá montar una partición, la lectura/escritura del mismo, etc. Para otras capacidades del sistema, el concepto será el mismo.

Cómo quitar los módulos del kernel cargados Al igual que con la carga de módulos, la descarga puede realizarse en un nivel superior con modprobe o a un nivel inferior conrmmod. La herramienta de nivel superior descarga todo en orden de dependencia inverso. rmmod simplemente elimina un único módulo de kernel, pero fallará si los módulos se encuentran en uso (por lo general debido a las dependencias). Por ejemplo: Listado 13. Intento de descarga de módulos con dependencias en uso % modprobe snd-emux-synth % rmmod soundcore soundcore: Device or resource busy % modprobe -rv snd-emux-synth # delete snd-emux-synth # delete snd-seq-midi-emul # delete snd-seq-virmidi # delete snd-rawmidi # delete snd-seq-midi-event # delete snd-seq # delete snd-timer # delete snd-seq-device # delete snd-util-mem # delete snd # delete soundcore

Sin embargo, si un módulo de kernel es candidato para ser quitado, rmmod lo descargará de la memoria, por ejemplo: Listado 14. Cómo descargar módulos sin dependencias % rmmod -v reiserfs Checking reiserfs for persistent data

14

Cómo cargar automáticamente los módulos de kernel Usted puede hacer que se carguen automáticamente los módulos del kernel, si lo desea, usando el cargador de módulos de kernel de las recientes versiones de Linux, o el daemon de kerneld de las versiones más antiguas. Si usa estas técnicas, el kernel detectará el hecho de que no soporta una llamada al sistema en particular, y luego intentará cargar el módulo de kernel adecuado. Sin embargo, a menos que usted ejecute en sistemas con memorias muy restringidas, por lo general no hay motive para no cargar los módulos de kernel necesarios durante el inicio del sistema (consulte el siguiente tutorial de esta serie para ver más información al respecto). Algunas distribuciones vienen con el cargador de módulos de kernel activado.

Cómo efectuar la limpieza automática de los módulos del kernel Al igual que con la carga automática, la limpieza automática de los módulos de kernel es en gran medida un problema sólo de los sistemas con memorias restringidas, como por ejemplo los sistemas Linux incrustados. Sin embargo, usted deberá saber que los módulos de kernel pueden cargarse con el indicador insmod --autoclean, que los marca como descargables si no están en uso actualmente. El más antiguo daemon kerneld haría una llamada a rmmod --all de manera periódica para quitar los módulos de kernel sin uso. En casos especiales (si usted no está usando kerneld, lo cual no haría en los sistemas Linux recientes), podría agregar el comando rmmod --all a su crontab, para que funcionara quizás más o menos una vez por minuto. Pero en su mayoría, esta cuestión es superflua, debido a que los módulos del kernel por lo general usan mucha menos memoria que los procesos de usuarios típicos. Recursos Aprender • Lea la Kernel Rebuild Guide (Guía de reconstrucción de kernel) de Kwan Lowe para ver más detalles sobre cómo construir un kernel. •

Encuentre más recursos para desarrolladores Linux en la zona Linux de developerWorks.

Obtener los productos y tecnologías • Obtenga la fuente del kernel de Linux en kernel.org, los Linux Kernel Archives. •

Ordene el kit de evaluación de software para Linux, un set de dos DVD que incluye el último software de prueba para Linux de DB2®, Lotus®, Rational®, Tivoli® y WebSphere®.

•

Construya su próximo proyecto de desarrollo en Linux con el software de prueba de IBM, disponible para su descarga directa en developerWorks.

Comentar • KernelNewbies.org posee numerosos recursos para las personas nuevas en el ámbito del kernel: una Pregunta Frecuente, un canal de IRC, una lista de correo y un wiki. •

KernelTrap es una comunidad Web dedicada al uso compartido de lo último de las noticias sobre desarrollo de kernels.

•

Involúcrese en developerWorks.

la

comunidad

developerWorks

participando

en

los blogs

de

15

Administración de kernel para tiempo de ejecución En esta sección, aprenda cómo: • Usar los utilitarios de línea de comando para obtener información acerca del kernel y los módulos kernel que se están ejecutando actualmente • Cargar y descargar manualmente módulos kernel • Determinar cuándo se pueden descargar los módulos • Configurar el sistema para cargar módulos por nombres distintos a su nombre de archivo Técnicamente, Linux es el kernel de su sistema. El kernel brinda un marco para que las aplicaciones se ejecuten y usen varios dispositivos de hardware. Es un código de nivel bajo que maneja interfaces de hardware, planificación y administración de memoria, entre otras cosas. Muchos se refieren al sistema completo como GNU/Linux porque gran parte de las herramientas que hacen que la mayoría de las distribuciones se puedan usar provienen del proyecto GNU de la Fundación para el Software Libre (FSF). Sin embargo, a menudo veremos sólo "Linux" en lugar de "GNU/Linux."

uname El comando uname imprime información sobre su sistema y su kernel. El Listado 1 muestra las distintas opciones para unamey la información resultante; cada opción se define en la Tabla 3. Listado 1. El comando uname ian@pinguino:~$ uname Linux ian@pinguino:~$ uname -s Linux ian@pinguino:~$ uname -n pinguino ian@pinguino:~$ uname -r 2.6.12-10-386 ian@pinguino:~$ uname -v #1 Mon Jan 16 17:18:08 UTC 2006 ian@pinguino:~$ uname -m i686 ian@pinguino:~$ uname -o GNU/Linux ian@pinguino:~$ uname -a Linux pinguino 2.6.12-10-386 #1 Mon Jan 16 17:18:08 UTC 2006 i686 GNU/Linux

Tabla 3. Opciones para uname

Opción Descripción

-s

Imprimir el nombre del kernel. Éste es el predeterminado si no se especifica una opción.

16

-n

Imprimir el nodename o hostname.

-r

Imprimir la edición del kernel. Esta opción se usa habitualmente con los comandos de manejo de módulos.

-v

Imprimir la versión del kernel.

-m

Imprimir el nombre (CPU) del equipo.

-o

Imprimir el operativo.

-a

Imprimir toda la información anterior.

nombre

del

del

hardware

sistema

El Listado 1 es de un sistema Ubuntu ejecutado en una CPU Intel®. El comando uname se encuentra disponible en casi todos los sistemas UNIX® y similares a UNIX, como así también en Linux. La información impresa variará según la distribución y versión de Linux, como así también por el tipo de equipo en la cual se está ejecutando. El Listado 2 muestra los datos de salida de un sistema AMD Athlon 64 que ejecuta Fedora Core 4 y, a modo de comparación, un Apple PowerBook. Listado 2. Uso de uname con otro sistema Linux attic4 2.6.14-1.1656_FC4 #1 Thu Jan 5 22:13:55 EST 2006 x86_64 x86_64 x86_64 GNU/Linuxfilesystem Darwin Ian-Shields-Computer.local 7.9.0 Darwin Kernel Version 7.9.0: Wed Mar 30 20:11:17 PST 2005; root:xnu/xnu-517.12.7.obj~1/RELEASE_PPC Power Macintosh powerpc

Módulos kernel El kernel administra muchos de los aspectos de bajo nivel de su sistema, incluyendo hardware e interfaces. Con una gran variedad de hardware posible y varios sistemas de archivos distintos, el kernel que pudiera soportar todo esto sería demasiado grande. Afortunadamente, los módulos kernel le permite cargar software de soporte como drivers de hardware o sistemas de archivos cuando fuera necesario, de manera tal que usted pueda ejecutar su sistema con un pequeño kernel y luego cargar otros módulos a medida que lo necesite. A menudo el proceso de carga es automático, así como cuando se enchufan los dispositivos USB. El resto de esta sección analiza los comandos y la configuración para los módulos kernel. Los comandos para tareas como cargar o descargar módulos requieren autoridad de certificación raíz. Los comandos para visualizar información acerca de los módulos pueden ser ejecutados habitualmente por usuarios generales. Sin embargo, dado que se alojan en /sbin, por lo general no están en la ruta de usuario no root, por ende probablemente usted deba usar los nombres completos de la ruta de acceso si usted es un usuario no root.

17

lsmod Use el comando lsmod para visualizar los módulos que están actualmente cargados en su sistema, como se muestra en el Listado 3. Probablemente sus datos de salida sean diferentes, aunque debería ver algunas entradas comunes. Listado 3. Visualización de los módulos kernel con lsmod [ian@attic4 ~]$ /sbin/lsmod Module Size Used by nvnet 74148 0 nvidia 4092336 12 forcedeth 24129 0 md5 4161 1 ipv6 268737 12 parport_pc 29189 1 lp 13129 0 parport 40969 2 parport_pc,lp autofs4 29637 1 sunrpc 168453 1 ipt_REJECT 5825 1 ipt_state 1985 3 ip_conntrack 42009 1 ipt_state iptable_filter 3137 1 ip_tables 19521 3 ipt_REJECT,ipt_state,iptable_filter dm_mod 58613 0 video 16069 0 button 4161 0 battery 9541 0 ac 4933 0 ohci_hcd 26977 0 ehci_hcd 41165 0 i2c_nforce2 7105 0 i2c_core 21825 1 i2c_nforce2 shpchp 94661 0 snd_intel8x0 34945 1 snd_ac97_codec 76217 1 snd_intel8x0 snd_seq_dummy 3781 0 snd_seq_oss 37569 0 snd_seq_midi_event 9409 1 snd_seq_oss snd_seq 62801 5 snd_seq_dummy,snd_seq_oss,snd_seq_midi_event snd_seq_device 9037 3 snd_seq_dummy,snd_seq_oss,snd_seq snd_pcm_oss 51569 0 snd_mixer_oss 18113 1 snd_pcm_oss snd_pcm 100553 3 snd_intel8x0,snd_ac97_codec,snd_pcm_oss snd_timer 33733 2 snd_seq,snd_pcm snd 57669 11 snd_intel8x0,snd_ac97_codec,snd_seq_oss,snd_seq, snd_seq_device,snd_pcm_oss,snd_mixer_oss,snd_pcm,snd_timer soundcore 11169 1 snd snd_page_alloc 9925 2 snd_intel8x0,snd_pcm floppy 65397 0 ext3 132681 3 jbd 86233 1 ext3 sata_nv 9541 0 libata 47301 1 sata_nv sd_mod 20545 0

18

scsi_mod [ian@attic4 ~]$

147977 2 libata,sd_mod

Como podrá observar, este sistema tiene muchos módulos cargados, la mayoría de los cuales vienen con el kernel. Sin embargo, algunos, como los módulos nvnet, nvidia, y sata_nv de NVIDIA Corporation incluyen código registrado y no se proveen como parte de un kernel estándar. De esta manera, el enfoque modular le permite al código registrado conectarse a una fuente abierta de kernel. Suponiendo que la licencia del proveedor lo permita, un distribuidor Linux puede agregar módulos propios a una distribución, ahorrándole la necesidad de obtenerlo directamente de un proveedor y ayudándolo a garantizar los niveles apropiados que usted necesita. En el Listado 3, usted también puede observar que el soporte modular se extiende a otros dispositivos como video, unidades de disco duro SATA y SCSI, discos flexibles y tarjetas de sonido, como así también funciones de redes como IPV6, soporte para sistema de archivos como ext3, y llamada a procedimiento remoto (Remote Procedure Call o RPC) de Sun. Además del nombre de módulo, lsmod también muestra el tamaño del módulo y la cantidad de usuarios del mimo. Si el módulo es usado por cualquier otro módulo, éstos aparecen listados. Entonces, por ejemplo, el módulo soundcore es usado por el módulo snd, que a su vez es usado por otros módulos de sonido.

modinfo El comando modinfo muestra la información sobre uno o varios módulos. Como se muestra en el Listado 4, la información incluye la ruta de acceso completa al archivo, el autor, la licencia, cualquier parámetro que el módulo pudiera aceptar, versión, dependencias y otra información. Listado 4. Información del módulo básico [ian@attic4 ~]$ /sbin/modinfo floppy filename: /lib/modules/2.6.12-1.1456_FC4/kernel/drivers/block/floppy.ko author: Alain L. Knaff license: GPL alias: block-major-2-* vermagic: 2.6.12-1.1456_FC4 686 REGPARM 4KSTACKS gcc-4.0 depends: srcversion: 2633BC999A0747D8D215F1F parm: FLOPPY_DMA:int parm: FLOPPY_IRQ:int parm: floppy:charp [ian@attic4 ~]$ /sbin/modinfo sata_nv filename: /lib/modules/2.6.12-1.1456_FC4/kernel/drivers/scsi/sata_nv.ko author: NVIDIA description: low-level driver for NVIDIA nForce SATA controller license: GPL version: 0.6 vermagic: 2.6.12-1.1456_FC4 686 REGPARM 4KSTACKS gcc-4.0 depends: libata alias: pci:v000010DEd0000008Esv*sd*bc*sc*i* alias: pci:v000010DEd000000E3sv*sd*bc*sc*i* alias: pci:v000010DEd000000EEsv*sd*bc*sc*i* alias: pci:v000010DEd00000054sv*sd*bc*sc*i* alias: pci:v000010DEd00000055sv*sd*bc*sc*i* alias: pci:v000010DEd00000036sv*sd*bc*sc*i* alias: pci:v000010DEd0000003Esv*sd*bc*sc*i* alias: pci:v000010DEd*sv*sd*bc01sc01i*

19

srcversion:

3094AD48C1B869BCC301E9F

En el Listado 4, observe que en las líneas donde aparecen los nombres de archivo del módulo, estos nombres de archivo terminan con un sufijo .ko. Esto distingue a los módulos para kernels 2.6 de otros archivos de objetos y de los módulos para 2.4 y kernels anteriores que usaban el mismo sufijo .o como otros archivos de objeto. Usted también observará que la ruta de acceso del módulo incluye la versión de kernel. Por ejemplo, /lib/modules/2.6.12-1.1456_FC4/kernel/drivers/block/floppy.ko incluye 2.6.12-1.1456_FC4 como elemento de ruta de acceso. Éste es el mismo valor que el emitido por uname -r. Los módulos kernel son específicos para cada kernel, y esta estructura administra la relación. En los kernels 2.6 también puede usar modinfo para limitar las solicitudes a información específica sobre un módulo. Use la opción -F para extraer un único tipo de información, como por ejemplo parámetro, descripción, licencia, nombre de archivo, o alias. Use el comando muchas veces con diferentes opciones si necesita distintos tipos de información. En los kernels 2.4, parámetros como -p extraen información de parámetros. El comando actual modinfo también soporta los parámetros más antiguos. El Listado 5 muestra algunos ejemplos. Listado 5. Información específica del módulo [ian@attic4 ~]$ /sbin/modinfo -F parm snd cards_limit:Count of auto-loadable soundcards. major:Major # for sound driver. [ian@attic4 ~]$ /sbin/modinfo -F license nvidia floppy NVIDIA GPL [ian@attic4 ~]$ /sbin/modinfo -p snd major:Major # for sound driver. cards_limit:Count of auto-loadable soundcards.

rmmod Si el contador de uso del módulo está en 0, usted puede eliminarlo de manera segura. Por ejemplo, usted podría hacer esto como preparación para cargar una versión actualizada. Esta es una función importante del kernel modular porque no siempre tiene que reiniciar sólo para actualizar el soporte para algún dispositivo en particular. Para eliminar un módulo, use el comandormmod junto con el nombre de módulo, como se muestra en el Listado 7. Listado 7. Eliminar un módulo de un sistema en funcionamiento [root@attic4 ~]# rmmod floppy

Diríjase a las páginas man para consultar otras opciones disponibles conrmmod.

insmod y modprobe Una vez que haya eliminado el módulo, tal vez necesite volver a cargarlo, puede hacer esto usando el comando insmod, que toma el nombre completo de la ruta de acceso del módulo a recargar, junto con cualquier opción de módulos que fuera necesaria. Si usa este comando, probablemente desee usar la sustitución de comandos para generar el nombre de archivo. En el Listado 8 se muestran dos formas de hacer esto.

20

Listado 8. Cargar un módulo usando insmod [root@attic4 ~]# insmod /lib/modules/`uname -r`/kernel/drivers/block/floppy.ko [root@attic4 ~]# rmmod floppy [root@attic4 ~]# insmod $(modinfo -F filename floppy) La segunda forma que se mencionó anteriormente le ahorra la necesidad de recordar en qué subdirectorio (drivers/block en este caso) se encuentra un módulo, pero hay una manera aún mejor de cargar un módulo. El comando modprobe provee una interfaz de más alto nivel que opera con el nombre del módulo, en lugar de hacerlo con la ruta de acceso del archivo. También administra la carga de módulos adicionales de los cuales depende un módulo, y puede eliminar módulos así como también cargarlos. El Listado 9 muestra cómo usar modprobe para eliminar el módulo vfat, junto con el módulo fat que lo usa. Luego muestra qué haría el sistema si se volviera a cargar el módulo, y por último el resultado de recargar el módulo. Observe que se especifica la opción -v para obtener datos de salida detallados; de lo contrario, modprobe (y el comando insmod subyacente) visualizarán sólo mensajes de error del módulo propiamente dicho. Entre cada paso, los datos de salida de lsmod se canalizan a través de grep para mostrar si el módulo vfat o fat está cargado o no. Listado 9. Cargar un módulo usando modprobe [root@lyrebird root]# modprobe -r vfat vfat: Device or resource busy [root@lyrebird root]# lsmod | grep fat vfat 13132 1 fat 38744 0 [vfat] [root@lyrebird root]# umount /windows/D [root@lyrebird root]# modprobe -r vfat [root@lyrebird root]# modprobe -v --show vfat /sbin/insmod /lib/modules/2.4.21-37.0.1.EL/kernel/fs/fat/fat.o /sbin/insmod /lib/modules/2.4.21-37.0.1.EL/kernel/fs/vfat/vfat.o [root@lyrebird root]# lsmod | grep fat [root@lyrebird root]# modprobe -v vfat /sbin/insmod /lib/modules/2.4.21-37.0.1.EL/kernel/fs/fat/fat.o Using /lib/modules/2.4.21-37.0.1.EL/kernel/fs/fat/fat.o Symbol version prefix '' /sbin/insmod /lib/modules/2.4.21-37.0.1.EL/kernel/fs/vfat/vfat.o Using /lib/modules/2.4.21-37.0.1.EL/kernel/fs/vfat/vfat.o [root@lyrebird root]# lsmod | grep fat vfat 13132 0 (unused) fat 38744 0 [vfat]

depmod Recién vio quemodprobepuede manejar la carga automática de múltiples módulos cuando algunos dependen de otros. Las dependencias se conservan en el archivo modules.dep en el subdirectorio /lib/modules para el kernel correcto, según lo determinado por el comando uname -r. Este archivo, junto a varios archivos map, es generado por el comando depmod. La -a(porall [“todo” en inglés]) ahora es opcional. El comando depmod escanea los módulos en los subdirectorios de /lib/modules para buscar el kernel en el que usted está trabajando y actualiza la información sobre dependencia. En el Listado 10 se muestra un ejemplo y los archivos cambiados resultantes.

21

Listado 10. Usar depmod para reconstruir modules.dep [root@lyrebird root]# date Thu Mar 16 10:41:05 EST 2006 [root@lyrebird root]# depmod [root@lyrebird root]# cd /lib/modules/`uname -r` [root@lyrebird 2.4.21-37.0.1.EL]# ls -l mod* -rw-rw-r-- 1 root root 54194 Mar 16 10:41 modules.dep -rw-rw-r-- 1 root root 31 Mar 16 10:41 modules.generic_string -rw-rw-r-- 1 root root 73 Mar 16 10:41 modules.ieee1394map -rw-rw-r-- 1 root root 1614 Mar 16 10:41 modules.isapnpmap -rw-rw-r-- 1 root root 29 Mar 16 10:41 modules.parportmap -rw-rw-r-- 1 root root 65171 Mar 16 10:41 modules.pcimap -rw-rw-r-- 1 root root 24 Mar 16 10:41 modules.pnpbiosmap -rw-rw-r-- 1 root root 122953 Mar 16 10:41 modules.usbmap [root@lyrebird 2.4.21-37.0.1.EL]# cd /root

Usted puede personalizar el comportamiento de modprobe y depmod usando el archivo de configuración /etc/modules.conf. Éste se usa comúnmente para nombres de módulos alias y para especificar comandos que deberán ejecutarse después que un módulo se cargó y antes de volver a cargarlo. No obstante, puede realizarse una amplia gama de otras configuraciones. El Listado 11 muestra un ejemplo de /etc/modules.conf. Consulte la página man para obtener más detalles sobre modules.conf. Listado 11. Ejemplo de archivo /etc/modules [root@lyrebird root]# cat /etc/modules.conf alias eth0 e100 alias usb-controller usb-uhci alias usb-controller1 ehci-hcd alias sound-slot-0 i810_audio post-install sound-slot-0 /bin/aumix-minimal -f /etc/.aumixrc -L >/dev/null 2>&1 || : pre-remove sound-slot-0 /bin/aumix-minimal -f /etc/.aumixrc -S >/dev/null 2>&1 || :

También es importante que sepa que algunos sistemas usan otro archivo de configuración llamado modprobe.conf, en tanto que otros almacenan información de configuración de módulos en el directorio /etc/modules.d directory. También puede encontrar un archivo llamado /etc/modules en algunos sistemas; este archivo contiene los nombres de los módulos kernel que deberán cargarse al momento de inicializar.

Módulos USB Cuando usted conecte un dispositivo USB, mediante hot plug, a su sistema Lynux, el kernel debe determinar qué módulos cargar para manejar el dispositivo. Esto normalmente es realizado por usted mediante un script de hot plug que usa el comando usbmodules para encontrar el módulo adecuado. También puede ejecutar usbmodules (como raíz) para que lo haga por usted. El Listado 12 muestra un ejemplo.

22

Listado 12. Módulos USB root@pinguino:~# lsusb Bus 005 Device 004: ID 1058:0401 Western Digital Technologies, Inc. Bus 005 Device 003: ID 054c:0220 Sony Corp. Bus 005 Device 001: ID 0000:0000 Bus 004 Device 001: ID 0000:0000 Bus 003 Device 001: ID 0000:0000 Bus 002 Device 001: ID 0000:0000 Bus 001 Device 003: ID 04b3:310b IBM Corp. Red Wheel Mouse Bus 001 Device 001: ID 0000:0000 root@pinguino:~# usbmodules --device /proc/bus/usb/005/003 usb-storage root@pinguino:~# usbmodules --device /proc/bus/usb/001/003 usbmouse usbhid La siguiente sección le muestra cómo construir y configurar un kernel personalizado.

Personalizar y construir kernels y módulos kernel En esta sección, aprenderá cómo: • Personalizar la actual configuración de kernel • Construir un kernel nuevo y los módulos kernel adecuados • Instalar un kernel nuevo y cualquier módulo • Asegurarse que el gestor de arranque pueda localizar al kernel nuevo y los archivos asociados Como aprendió en la sección anterior, Administración de kernel para tiempo de ejecución, el kernel le brinda soporte de bajo nivel para el hardware de su sistema y los sistemas de archivo. Una imagen de kernel moderna normalmente contiene sólo funciones esenciales, pero está configurada para soportar las funciones adicionales que usted pueda necesitar, mediante el uso de kernel modules. El soporte adicional se carga sólo cuando se lo necesita, por ejemplo cuando se conecta o desactiva un dispositivo. El código modular pasa a formar parte del kernel, ampliando las funciones de kernel de una manera dinámica. Si las funciones de un módulo kernel cargado no se han usado durante varios minutos, el kernel puede voluntariamente desvincularlo del resto del kernel y descargarlo de la memoria mediante un proceso conocido como autolimpieza. Sin los módulos kernel, su kernel que está ejecutándose, el cual se carga del disco como un archivo binario único, debería contener toda la funcionalidad que probablemente usted necesite para siempre. También necesitaría construir un kernel totalmente nuevo cada vez que desee agregar una funcionalidad a su sistema. Aunque no puede poner todo en un módulo. Como mínimo, la imagen de kernel que esté cargada debe poder montar su sistema de archivo raíz, su cargador de arranque puede cargar un disco RAM inicial (o initrd), que puede contener los módulos necesarios para montar el sistema de archivo raíz. No obstante, la imagen de kernel debe contener por lo menos soporte para el sistema de archivos RAM usado en el disco RAM inicial. Si no lo hace, su sistema no arrancará. Una vez que su sistema ha realizado bootstrap de sí mismo hasta este punto, sigue con el montaje del sistema de archivo raíz y luego comienza con los otros procesos de inicialización. Después de unos pocos segundos, el sistema ya está preparado y listo para usar. Sin embargo, el kernel se mantiene a la espera de las solicitudes para realizar el trabajo de los procesos de usuario y programar los recursos del sistema entre las tareas que los requieran. Los kernels modulares funcionan bien en sistemas de módem con mucho espacio de memoria RAM y en disco. Sin embargo, tal vez usted tenga un dispositivo de hardware como una tarjeta de video o un sistema de almacenamiento que no sea soportado por el kernel que vino con su distribución. Efectivamente, algunos drivers contienen código registrado que interferiríacon un kernel Linux puro, por eso algunos distribuidores no lo incluirán, aún cuando los términos de la

23

licencia del proveedor permitan su distribución al distribuidor que usted ha elegido. En este caso, usted necesitará por lo menos construir nuevos módulos, y posiblemente hasta construir un kernel nuevo. Linux se puede usar en muchos entornos, desde sistemas incrustados como teléfonos celulares, hasta dispositivos de redes como routers, decodificadores y también entornos de computación más tradicionales. Algunos de estos dispositivos usan un kernel que se ha personalizado para soportar sólo aquellas funciones que el sistema se propone soportar. Por ejemplo, un sistema destinado a ser un firewall inalámbrico probablemente no necesite soportar ningún otro sistema de archivos que el sistema de archivos de sólo lectura desde el cual se carga, sin embargo tal vez necesite soporte para hardware de redes avanzado que no forma parte del kernel estándar. Nuevamente, se requerirá un kernel personalizado.

Paquetes fuente El último paquete fuente para kernel Linux es el Linux Kernel Archives (consulte Recursos para acceder a un vínculo). A menos que usted ya sepa qué es lo que está haciendo, debería usar un paquete kernel de su distribución Linux, porque su distribuidor puede haberle agregado parches personalizados. Si usted descarga una fuente de los archivos públicos de kernel, descargará un archivo comprimido, y necesitará descomprimirlo usando gzip o bzip2, según cuál sea la versión de la fuente de kernel que haya descargado (.gz o .bz2). El directorio pub/linux/kernel/ en el servidor de descarga tiene un directorio para cada versión de kernel, por ejemplo 2.4, 2.5, o 2.6. A la fecha de este documento, la última versión bzip2 de kernel 2.6 kernel es linux-2.6.15.tar.bz2. En ese directorio de kernel, usted también verá el respectivo archivo ChangeLog-2.6.15.6 que describe los cambios en esta versión, y un parche patch-2.6.15.bz2, que es un archivo más pequeño que le permite complementar la versión de fuente anterior para equipararla con el nivel de 2.6.15. También observará los archivos de firmas que puede usar para verificar que su archivo de descarga no esté dañado, ya sea accidental o intencionalmente. La fuente comprimida está normalmente descomprimida en /usr/src, y crea un subdirectorio nuevo para la versión de kernel, como linux-2.6.15, que contiene el árbol de archivos necesarios para construir su kernel. Si usted ya tiene ese archivo, tal vez desee hacer una copia de seguridad del mismo o cambiarle el nombre antes de desempaquetar la nueva fuente de kernel. Esto le garantiza que pueda volver atrás si lo necesita, y también que no tendrá archivos cautivos que no deberían estar en su árbol de fuente de kernel. Necesita aproximadamente 40MB de espacio en disco para el tarball y alrededor de 350MB para el código fuente expandido. Algunos distribuidores, especialmente Red Hat, ahora distribuyen los encabezados y fuentes kernel necesarios para construir módulos kernel como un paquete de desarrollo kernel. La documentación puede estar en un paquete de documentación de kernel aparte. Éstos están diseñados para crear módulos y son suficientes para ello, como un módulo para tarjeta de gráficos exclusiva de un proveedor, pero no son suficientes para reconstruir un kernel personalizado. Su distribución deberá contar con información sobre cómo reconstruir un kernel y cómo se puede obtener la fuente. Consulte la documentación, como por ejemplo notas de versiones. Supongamos que usted usa FTP o HTTP para descargar la fuente RPM de kernel-2.6.151.1833_FC4.src.rpm de pub/fedora/linux/core/updates/4/SRPMS/ en download.fedora.redhat.com, y el archivo está en el directorio /root. Observe que los números de versión usados aquí probablemente sean diferentes para su sistema, por lo tanto asegúrese de conseguir la versión de fuente actualizada correspondiente al kernel que tiene instalado. Ahora, para Fedora, usted debe instalar el RPM fuente, luego pasar al directorio /usr/src/redhat/SPECS y por último construir el RPM fuente para crear el árbol fuente de kernel Linux, como se muestra en el Listado 13. Listado 13. Crear el árbol fuente de kernel para Fedora Core [root@attic4 ~]# uname -r 2.6.15-1.1833_FC4 [root@attic4 ~]# rpm -Uvh kernel-2.6.15-1.1833_FC4.src.rpm 1:kernel ########################################### [100%] [root@attic4 ~]# cd /usr/src/redhat/SPECS

24

[root@attic4 SPECS]# rpmbuild -bp --target $(arch) kernel-2.6.spec Building target platforms: x86_64 Building for target x86_64 Executing(%prep): /bin/sh -e /var/tmp/rpm-tmp.23188 + umask 022 + cd /usr/src/redhat/BUILD + LANG=C + export LANG + unset DISPLAY + '[' '!' -d kernel-2.6.15/vanilla ']' + cd /usr/src/redhat/BUILD + rm -rf kernel-2.6.15 + /bin/mkdir -p kernel-2.6.15 + cd kernel-2.6.15 + /usr/bin/bzip2 -dc /usr/src/redhat/SOURCES/linux-2.6.15.tar.bz2 + tar -xf ... + echo '# x86_64' + cat .config + perl -p -i -e 's/^SUBLEVEL.*/SUBLEVEL = 15/' Makefile + perl -p -i -e 's/^EXTRAVERSION.*/EXTRAVERSION = -prep/' Makefile + find . -name '*.orig' -o -name '*~' -exec rm -f '{}' ';' + exit 0

La fuente kernel de Linux para Fedora ahora está ubicada en /usr/src/redhat/BUILD/kernel2.6.15/linux-2.6.15. Por convención, el árbol /linux-2.6.15 habitualmente se mueve a /usr/src y simbólicamente se vincula a /usr/src/linux, como se muestra en el Listado 14. Esto no es estrictamente necesario, pero es más fácil de seguir junto con las referencias que asumen que el árbol fuente de kernel estará en .usr./src/linux. Listado 14. Mover el árbol fuente a ./usr/src [root@attic4 SPECS]# mv ../BUILD/kernel-2.6.15/linux-2.6.15 /usr/src [root@attic4 SPECS]# cd /usr/src [root@attic4 src]# ln -s linux-2.6.15 linux [root@attic4 src]# ls -ld lin* lrwxrwxrwx 1 root root 12 Mar 20 18:23 linux -> linux-2.6.15 drwxr-xr-x 20 root root 4096 Mar 20 18:13 linux-2.6.15

Antes de intentar construir algo, revise el archivo Changes (Cambios) que aparece en el directorio Documentation (Documentación). Entre otras cosas, enumera los niveles mínimos de paquetes de software que usted necesita para construir un kernel. Asegúrese de tener estos paquetes instalados. Usted puede observar Makefile y .config entre los archivos que se muestran en el Listado 13. El archivo make contiene varios objetivos para tareas como configurar las opciones de kernel, construir el kernel y sus módulos, e instalar los módulos y construir RPM o paquetes deb. Las fuentes kernel más recientes le permiten usar make helppara brindar una ayuda rápida en cada objetivo. Para los sistemas más viejos, tal vez necesite consultar la documentación o examinar el archivo make. El Listado 15 muestra los datos de salida parciales paramake help.

25

Listado 15. Ayuda para el archivo make usado para construir kernels [ian@attic4 linux-2.6.15]$ make help Cleaning targets: clean - remove most generated files but keep the config mrproper - remove all generated files + config + various backup files Configuration targets: config - Update current config utilising a line-oriented program menuconfig - Update current config utilising a menu based program xconfig - Update current config utilising a QT based front-end gconfig - Update current config utilising a GTK based front-end oldconfig - Update current config utilising a provided .config as base randconfig - New config with random answer to all options defconfig - New config with default answer to all options allmodconfig - New config selecting modules when possible allyesconfig - New config where all options are accepted with yes allnoconfig - New minimal config Other generic targets: all - Build all targets marked with [*] * vmlinux - Build the bare kernel * modules - Build all modules modules_install - Install all modules dir/ - Build all files in dir and below dir/file.[ois] - Build specified target only ...

Configuración El archivo .config en su directorio de construcción de kernels contiene información de configuración para su kernel, incluyendo el entorno del equipo de destino, las funciones a incluir, y si una función debería compilarse dentro del kernel o construirse como un módulo. Crear el archivo .config es el primer paso para construir o reconstruir un kernel. Usted lo crea usando uno de los destinos de configuración en el archivo make. Las principales opciones de configuración son: config El destino config usa una interfaz de línea de comandos para obtener respuestas a muchas preguntas para construir o actualizar su archivo .config. Con el advenimiento de los destinos de configuración basados en menú, rara vez se usa esta interfaz de línea de comandos. menuconfig El destino menuconfig usa un programa basado en ncurses y en menú para crear o actualizar su archivo .config. Usted sólo necesita responder preguntas para los elementos que desee cambiar. Este enfoque ha desplazado el destino de configuración anterior. Usted lo ejecuta en una ventana de terminal de manera local o remota. xconfig El destino xconfig usa un sistema de menú gráfico basado en QT front-end, como el usado con el escritorio KDE.

26

gconfig El destino gconfig usa un sistema de menú gráfico basado en un GTK front-end, como el usado con el escritorio GNOME. oldconfig El destino oldconfig le permite construir una configuración usando un archivo .config ya existente, como el que podría tener de otra creación previa u otro sistema. Por ejemplo, si usted instaló la fuente kernel para Fedora, como se describió anteriormente, puede copiar el archivo de configuración para su sistema en ejecución de/lib/modules/$(uname r)/build/.config a /usr/src/linux. Una vez que lo construyó, puede usar uno de los objetivos de configuración del menú para modificarlo si fuera necesario. La Figura 1 le muestra qué podría ver si ejecuta make menuconfig para un kernel serie 2.4. Presione Enter para descender a menús de menor nivel, y presione Esc para volver. La mayoría de los elementos cuentan con ayuda disponible. Haga clic en< Help (Ayuda) > y presione Enter, o simplemente escriba h. Presione Esc para volver a la configuración. Figura 1. Ejecutar make menuconfig en un kernel 2.4

La Tabla 4 muestra las diferentes opciones para incluir funciones en el kernel, ya sea incorporado o como módulos. Cuando una opción se resalta, presione la barra espaciadora para seleccionar entre las opciones permitidas para esta función. También puede presionar y para activar una opción, n para desactivarla, o m para compilarla como un módulo si fuera posible. Tabla 4. Opciones para menuconfig

Opción Descripción

[*]

La función se incorporará a kernel.

[]

La función no se incluirá en el kernel.



La función se construirá como un

27

módulo kernel.



La función no se incluirá en el kernel, pero se puede construir como un módulo.

La Figura 2 muestra aquello qué podría ver si ejecuta make gconfig para un kernel serie 2.6. Haga clic en las flechas para maximizar o minimizar los elementos del menú. La Ayuda se visualiza en un panel inferior. Figura 2. Ejecutar make gconfig en un kernel 2.6

A continuación se describen las principales secciones de configuración para un kernel 2.6. Probablemente no las encuentre a todas en kernel 2.4 y versiones anteriores, pero esta lista brinda una orientación general para saber dónde se puede encontrar cada elemento. Opciones para nivel de madurez de códigos Esta sección contiene una opción que determina si las opciones restantes le permiten elegir un código que sea considerado experimental. Si usted no selecciona esta opción, entonces podrá seleccionar sólo aquellas opciones que se consideran estables. Tenga en cuenta que las funciones que elija pueden o no funcionar en el nivel de código actual de su sistema, así que podría tener la opción de ayuda con depuración. Configuración general Esta sección le permite incluir una cadena de identificación con su kernel nuevo, junto con las opciones para varios atributos de kernel que no pertenecen a otro lugar, pero que usted puede especificar.

28

Soporte de módulo que se puede cargar Esta sección contiene una opción que determina si su kernel soportará módulos y si se pueden cargar y descargar automáticamente. Usted debería habilitar el soporte de módulo. Nivel de bloque Esta sección contiene soporte para discos superiores a 2TB, y le permite elegir el tipo planificación de disco que usted desee. Tipo de procesador y funciones Esta sección contiene opciones de configuración específicas para CPU. Aquí usted elige el procesador o la familia de procesadores que soportará su kernel, como así también si habilitar o no el acceso a varias funciones de procesador. Asegúrese de habilitar soporte de multiprocesamiento simétrico si tiene más de una CPU o una CPU con hyperthreading. Generalmente, usted debería habilitar la opción MTRR para permitir un mejor rendimiento gráfico con tarjetas de video AGP o PCI. Opciones para administración de energía Esta sección contiene varias opciones de administración de energía que son particularmente útiles en computadoras portátiles. Además de controlar los estados de la energía, aquí también encontrará opciones para controlar y monitorear elementos como temperatura o estados de ventilador. Opciones de bus (PCI etc.) Esta sección contiene opciones para los buses soportados por su sistema, como buses PCI, PCI Express y PC Card. Aquí usted también puede habilitar el sistema de archivo /proc/pci, aunque en cambio debería usar generalmentelspci. Formatos de archivos ejecutables / Emulaciones Esta sección contiene opciones para soportar varios formatos de archivos binarios. Usted debería habilitar el soporte binario ELF, también puede habilitar el soporte para binarios DOS para ejecutarlos en DOSEMU, como así también binarios accionados por contenedor como Java™, Python, Emacs-Lisp, etc. Por último, para un sistema de 64 bits que soporta emulación de 32 bits, probablemente usted quiera habilitar soporte binario de 32 bits. Redes La sección de redes es grande. Aquí usted puede habilitar sockets básicos y redes TCP/IP, como así también filtros de paquetes, creación de puentes, ruteo y soporte para una variedad de protocolos como IPV6, IPX, Appletalk y X.25. Aquí también puede habilitar soporte de radio inalámbrica, infrarroja y amateur. Drivers de dispositivos Esta sección también es muy extensa. Aquí usted habilita el soporte para la mayoría de sus dispositivos de hardware, incluyendo IDE/ATAPI o unidades de disco duro SCSI y dispositivos de memoria flash. Habilite DMA para sus dispositivos IDE; sino trabajarán en

29

el modo PIO más lento. Si usted desea soporte para varios dispositivos como RAID o LVM, aquí es donde los habilita, también puede configurar soporte de puertos paralelos si desea soporte de impresoras paralelas. Aquí es donde también usted configura una amplia gama de dispositivos de redes para soportar los protocolos de redes que configuró anteriormente. También encontrará soporte para dispositivos de captura de audio y video, USB e IEEE 1384 (Firewire), como así también una variedad de dispositivos para el monitoreo de hardware. En el apartado de dispositivos de carácter, probablemente usted desee habilitar soporte para impresoras paralelas y direccionar el soporte suministrado. Drivers de firmware Esta sección contiene unas pocas opciones relacionadas con la configuración y actualización de BIOS, como el uso de las funciones de Dell System Management en ciertos sistemas Dell. Sistemas de archivos Esta sección es para configurar los sistemas de archivo que desea que soporte su kernel, ya sea compilado o como módulos. Aquí también encontrará sistemas de archivos para medios extraíbles como disquetes, CD o DVD, con soporte para sistemas de archivos en redes como NFS, SMB, o CIFS. Aquí también se puede encontrar soporte para una variedad de particiones y soportes para lenguaje nativo (NLS). Soporte de instrumentación Esta sección le permite habilitar soporte de generación de perfiles experimentales con el fin de crear los perfiles para los movimientos de su sistema. Piratería de Kernel Esta sección le permite habilitar la depuración de kernel y elegir qué funciones serán habilitadas. Opciones de seguridad Esta sección le permite configurar varias operaciones de seguridad y habilitar y configurar SELinux (Security Enhanced Linux). Opciones criptográficas Esta selección le permite configurar varios algoritmos criptográficos, como MD4, DES y SHA256. Rutinas de biblioteca Esta sección le permite decidir si ciertos algoritmos CRC deberían compilarse o construirse como módulos.

Construcción Ahora que ya conoce los aspectos principales de la configuración de un kernel, está listo para construir uno. Si no está seguro del estado de su árbol de construcción, ejecute make clean antes de configurar su kernel nuevo. Para un objetivo de limpieza más completo, ejecute make mrproper;

30

esto eliminará su archivo .config como así también otros archivos usados por el proceso de construcción. Si usted hace esto y luego necesita restaurar un archivo .config file guardado como copia de seguridad, necesitará ejecutar make oldconfig antes de configurar. Mientras esté experimentando, debería darle un nombre personalizado a su kernel nuevo para que pueda identificarlo fácilmente. Haga esto configurando un valor de versión local y activando la opción para agregar automáticamente información de la versión a la cadena de versión en la sección de Configuración general, como se muestra en la Figura 3. Figura 3. Configurar un kernel personalizado

Con la intención de adoptar pequeños pasos, los ejemplos que se presentan en el resto de este tutorial se basan en construir un kernel con sólo los dos cambios que se muestran en la Figura 3. En principio, el kernel no requiere autoridad de certificación raíz para construir, aunque usted la necesitará para instalar su kernel nuevo. Sin embargo, si usted está usando un paquete instalado por su distribución, probablemente deba ejecutar como raíz debido a los permisos de directorio y archivo que se han configurado. Usted puede practicar en el modo usuario mediante la descarga de un tarball de fuente kernel de los archivos kernel de Linux y desempaquetándolo en su directorio principal, o haciendo una copia de su árbol de construcción kernel y cambiando los permisos de su ID de usuario. Para comenzar a construir un kernel 2.6, escriba make. Para comenzar a construir un kernel 2.4, ejecute estos tres comandos: make dep make bzImage make modules El primero crea los archivos de dependencia necesarios. El segundo construye el kernel y el último construye sus módulos. Ejecutar make en mi sistema AMD Athlon 3500+ lleva aproximadamente media hora para completar la construcción desde su comienzo. Los sistemas más lentos pueden tardar un par de horas para completar esta tarea, así que tómese un descanso o haga alguna otra cosa mientras espera. Observará mensajes de avance de las tareas como los que se muestran en el Listado 16 mientras la construcción se está ejecutando.

31

Listado 16. Ejecución de make [root@attic4 linux]# make CHK include/linux/version.h HOSTCC scripts/basic/fixdep HOSTCC scripts/basic/split-include HOSTCC scripts/basic/docproc SPLIT include/linux/autoconf.h -> include/config/* CC arch/x86_64/kernel/asm-offsets.s GEN include/asm-x86_64/asm-offsets.h ... LD [M] sound/usb/snd-usb-lib.ko CC sound/usb/usx2y/snd-usb-usx2y.mod.o LD [M] sound/usb/usx2y/snd-usb-usx2y.ko

Instalación Cuando haya completado la construcción de su kernel, todavía tiene que completar un par de pasos. Primero, necesita ejecutarmake modules_installpara instalar sus módulos kernel en un subdirectorio nuevo ./lib/modules. Si usted necesita módulos de propiedad exclusiva para una tarjeta de video o driver de red, como necesito para mi tarjeta de gráficos nVidia y chipset de placa madre nForce 4, éste es un buen momento para construir módulos usando las herramientas suministradas por el proveedor. Por último, necesita ejecutar make install para instalar el kernel nuevo y el disco de memoria RAM inicial en /boot y actualizar la configuración de su cargador de arranque. Estos pasos se ilustran en el Listado 17. Listado 17. Instalar el kernel y los módulos [root@attic4 linux]# make modules_install INSTALL arch/x86_64/crypto/aes-x86_64.ko INSTALL arch/x86_64/kernel/cpufreq/acpi-cpufreq.ko INSTALL arch/x86_64/kernel/microcode.ko INSTALL arch/x86_64/oprofile/oprofile.ko INSTALL crypto/aes.ko INSTALL crypto/anubis.ko INSTALL crypto/arc4.ko ... [root@attic4 linux]# ls -lrt /lib/modules | tail -n 3 drwxr-xr-x 5 root root 4096 Mar 4 14:48 2.6.15-1.1831_FC4 drwxr-xr-x 5 root root 4096 Mar 20 18:52 2.6.15-1.1833_FC4 drwxr-xr-x 3 root root 4096 Mar 20 21:38 2.6.15-prep-Topic105 [root@attic4 linux]# sh /root/NFORCE-Linux-x86_64-1.0-0310-pkg1.run -a \ > -n -K -k 2.6.15-prep-Topic105 Verifying archive integrity...OK Uncompressing NVIDIA nForce drivers for Linux-x86_64 1.0-0310................... [root@attic4 linux]# sh /root/NVIDIA-Linux-x86_64-1.0-8178-pkg2.run -a \ > -n -K -k 2.6.15-prep-Topic105 Verifying archive integrity... OK Uncompressing NVIDIA Accelerated Graphics Driver for Linux-x86_64 1.0-8178.............. [root@attic4 linux]# make install CHK include/linux/version.h CHK include/linux/compile.h CHK usr/initramfs_list

32

Kernel: arch/x86_64/boot/bzImage is ready (#2) sh /usr/src/linux-2.6.15/arch/x86_64/boot/install.sh 2.6.15-prep-Topic105 arch/x86_64/boot/bzImage System.map "/boot" [root@attic4 linux]# ls -lrt /boot | tail -n 6 -rw-r--r-- 1 root root 1743149 Mar 20 21:45 vmlinuz-2.6.15-prep-Topic105 lrwxrwxrwx 1 root root 28 Mar 20 21:45 vmlinuz -> vmlinuz-2.6.15-prep-Topic105 -rw-r--r-- 1 root root 980796 Mar 20 21:45 System.map-2.6.15-prep-Topic105 lrwxrwxrwx 1 root root 31 Mar 20 21:45 System.map -> System.map-2.6.15-prep-Topic105 -rw-r--r-- 1 root root 1318741 Mar 20 21:45 initrd-2.6.15-prep-Topic105.img drwxr-xr-x 2 root root 4096 Mar 20 21:45 grub

Disco RAM inicial Observe que el proceso de construcción creó automáticamente el disco RAM inicial necesario (initrd) para usted. Siempre que necesite crear uno manualmente, hágalo usando el comando mkinitrd. Consulte las páginas man para obtener más detalles.

Cargadores de arranque Si todo funcionó correctamente, el paso make install también debería haber actualizado la configuración de su cargador de arranque. En el Listado 18 se muestran algunas líneas del mío. Listado 18. Archivo de configuración GRUB actualizado default=1 timeout=10 splashimage=(hd0,5)/boot/grub/splash.xpm.gz password --md5 $1$y.uQRs1W$Sqs30hDB3GtE957PoiDWO. title Fedora Core (2.6.15-prep-Topic105) root (hd0,11) kernel /boot/vmlinuz-2.6.15-prep-Topic105 ro root=LABEL=FC4-64 rhgb quiet initrd /boot/initrd-2.6.15-prep-Topic105.img title Fedora Core -x86-64 (2.6.15-1.1833_FC4)

La entrada para el kernel recientemente creado se colocó en la parte superior, pero se ajustó la entrada predeterminada para que se mantenga como la predeterminada anterior. Si en cambio usted usa LILO, entonces el comando grubby que se usa en el scrip construido debería haber actualizado su configuración LILO. Un comentario final. Usted se preguntará por qué la configuración de muestra agregó -Topic105, aunque todos los archivos creados tenían en cambio -prep-Topic105. Esta es una medida de seguridad de Fedora para evitar que usted inadvertidamente destruya su kernel activo. Esto se controla con la variable EXTRAVERSION configurada cerca de la parte superior del archivo make principal, como se muestra en el Listado 19. Edite el archivo si necesita eliminar esto. Listado 19. Archivo de configuración GRUB actualizado [root@attic4 linux]# head -n 6 Makefile VERSION = 2 PATCHLEVEL = 6 SUBLEVEL = 15 EXTRAVERSION = -prep NAME=Sliding Snow Leopard

33

Reiniciación Si todo funciona bien, ahora usted debería poder arrancar su sistema nuevo. Necesitará seleccionar la entrada de configuración para el kernel nuevo porque no está (todavía) predeterminada. Una vez que esté satisfecho con ella, puede predeterminarla. Cuando reinicie, use el comando uname para verificar el kernel de su sistema, como se muestra en el Listado 20. Listado 20. Verificación del nuevo sistema [ian@attic4 ~]$ uname -rv 2.6.15-prep-Topic105 #2 Mon Mar 20 21:13:20 EST 2006

Recursos Aprender • En "Tareas básicas para nuevos desarrolladores Linux" (developerWorks, marzo 2005), aprenda cómo abrir una ventana de terminal o ejecutar shell prompt y mucho más. •

Los archivos Kernel de Linux es el último recurso para el kernel de Linux. Verifique su espejo más cercano antes de descargar.

•

El proyecto kernelnewbies posee mucha información para aquellos que recién se inician en kernels y cómo crearlos.

•

La Kernel Rebuild Guide le muestra cómo configurar, construir e instalar un nuevo kernel.

•

La Linux Kernel Module Programming Guide de Linuxtopia es un libro online sobre los módulos kernel para Linux.

Autor:

David Mertz es Turing completo, pero probablemente no apruebe la Prueba de Turing. Para conocer más acerca de su vida, consulte su página Web personal. David escribe las columnas developerWorks Charming Python y XML Matters desde el año 2000. Consulte su libroText Processing in Python [Procesamiento de texto en Python]. Compilación y edición: Ing. Sergio Aguilera. Facultad de Tecnología Informática. Universidad de Belgrano. [email protected] Todos los Derechos Reservados a IBM Corp. – Marzo 2012.

34