Preparación para el examen 201 de LPI: Kernel de Linux

Tema 201 de Intermediate Level Administration (LPIC-2)

En este tutorial, David Mertz continúa preparándolo para dar el®examen 201 de Intermediate Level Administration (LPIC-2) del Linux Professional Institute. En éste, el primero de ocho tutoriales, usted aprenderá a comprender, compilar y personalizar un kernel de ™Linux.

David Mertz, Developer, Gnosis Software

David MertzDavid 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 libro Text Processing in Python [Procesamiento de texto en Python].



31-03-2014 (Primera publicación 28-07-2010)

Antes de comenzar

Conozca qué es lo que esta serie de tutoriales puede enseñarle y cómo aprovecharla al máximo.

Acerca de esta serie

El Linux Professional Institute (LPI) certifica a administradores de sistemas Linux en los niveles junior e intermedio. Para obtener cada uno de los niveles de certificación, usted deberá aprobar dos exámenes de LPI.

Cada examen abarca diversos temas, y casa uno de los temas tiene un valor. Los valores indican la importancia relativa de cada tema. A grandes rasgos, usted deberá esperar más preguntas sobre los temas con valor más altos en cada examen. Los temas y sus valores para el examen 201 de LPI son:

Tema 201
Kernel de Linux (valor 5). El foco de este tutorial.
Tema 202
Arranque del sistema (valor 5).
Tema 203
Sistema de archivos (valor 10).
Tema 204
Hardware (valor 8).
Tema 209
Uso compartido de archivos y servicios (valor 8).
Tema 211
Mantenimiento del sistema (valor 4).
Tema 213
Personalización y automatización del sistema (valor 3).
Tema 214
Resolución de problemas (valor 6).

El Linux Professional Institute no avala ningún material o técnica de preparación de exámenes en particular. Para más detalles, por favor comuníquese con info@lpi.org.

Acerca de este tutorial

Bienvenido a "Linux kernel," el primero de ocho tutoriales diseñados para prepararlo para el examen 201 de LPI. En este tutorial, usted aprenderá a compilar y personalizar un kernel de Linux.

El tutorial está organizado según los objetivos de LPI para este Tema, de la siguiente manera:

2.201.1 Componentes del kernel (valor 1)
Usted aprenderá a usar los componentes del kernel que son necesarios para cierto hardware, ciertos recursos del sistema y los requerimientos. Aprenderá a implementar diferentes tipos de imágenes del kernel, identificar los kernels estables y de desarrollo y los parches, así como a usar los módulos del kernel.
2.201.2 Recopilación de un kernel (valor 1)
Usted aprenderá a compilar adecuadamente un kernel para incluir o desactivar características específicas del kernel de Linux según resulte necesario. Aprenderá a compilar y recopilar el kernel de Linux según sus necesidades, y a observar los cambios en el nuevo kernel, a crear una imagen initrd del sistema y a instalar nuevos kernels.
2.201.3 Cómo emparchar un kernel (valor 2)
Usted aprenderá a emparchar correctamente un kernel para diversos propósitos, incluyendo cómo implementar las actualizaciones del kernel, cómo implementar los arreglos de errores, y cómo agregar soporte para nuevo hardware. Además, aprenderá a eliminar correctamente los parches de un kernel en los kernel de producción existentes.
2.201.4 Cómo personalizar un kernel (valor 1)
Usted aprenderá a personalizar un kernel según requerimientos de un sistema específico emparchando, compilando y editando los archivos de configuración según resulte necesario. Aprenderá a evaluar los requerimientos para un compilado de kernel versus un parche de kernel así como a construir y configurar módulos del kernel.

Este tutorial es uno de los pocos de la serie que se ocupa de Linux, en el sentido estricto de la palabra. Es decir, existe una variedad de herramientas para el trabajo de redes, el mantenimiento de sistema, la manipulación de archivos y datos, etc., que son importantes para el funcionamiento de una instalación Linux y forman parte de casi todas las distribuciones de Linux. Pero el kernel de base –ese trozo de software que media entre programas rivales y tiene acceso al hardware– es el software gestionado por Linus Torvalds, que se denomina correctamente "el verdadero Linux."

Una de las mejores ventajas del kernel de Linux es que es un Software Gratuito. No sólo el kernel de Linux ha recibido el aporte de muchísimas personas brillantes para su mejora, sino que usted, como administrador de sistemas, tiene acceso al código fuente del mismo. Esto le da el poder de configurar y personalizar el kernel para adecuarlo a sus requerimientos.

Requisitos previos

Para aprovechar al máximo este tutorial, usted deberá contar con un conocimiento básico de Linux y con un sistema Linux en funcionamiento donde practicar los comandos que se tratan en este tutorial.


Componentes del kernel

Esta sección abarca el material del Tema 2.201.1 del examen 201 de la Intermediate Level Administration (LPIC-2). El Tema tiene un valor de1.

¿De qué está compuesto un kernel?

Un kernel de Linux está compuesto por el kernel de base más un número cualquiera de módulos del kernel. En la mayoría o muchos de los casos, el kernel de base y una gran colección de módulos del kernel se compilan al mismo tiempo y se instalan o distribuyen todos juntos, en base al código creado por Linus Torvalds o personalizado por los distribuidores de Linux. En el arranque del sistema siempre se carga un kernel de base kernel que permanece cargado durante todo el tiempo de actividad; los módulos del kernel pueden o no cargarse en el inicio (aunque por lo general algunos se cargan), y pueden cargarse o descargarse durante el tiempo de ejecución

El sistema de módulos del kernel permite la inclusión de módulos adicionales que son compilados después, o de manera independiente del kernel de base. Se pueden crear módulos adicionales cuando usted agrega dispositivos de hardware a un sistema Linux en ejecución o cuando los mismos son distribuidos por terceros. A veces, hay módulos del kernel distribuidos por terceros en forma binaria, a pesar de que eso le quita a usted, como administrador, la capacidad de personalizar un módulo del kernel. En cualquier caso, una vez que se carga un módulo del kernel, se transforma en parte del kernel en funcionamiento todo el tiempo que permanezca cargado. Contrariamente a lo que a veces se piensa, un módulo del kernel no es simplemente una API para hablar con el kernel de base, sino que se incorpora como parte del kernel mismo.

Convenciones de denominación para los kernels

Los kernels de Linux siguen una convención de denominación/numeración que rápidamente le brinda información significativa acerca del kernel que usted está ejecutando. La convención utilizada indica un número mayor, un número menor, una revisión y, en algunos casos, la cadena de proveedor/customización. La misma convención se aplica a diversos tipos de archivos, incluyendo el archivo fuente del kernel, los parches y quizás múltiples kernels de base (si usted ejecuta muchos).

Además de la secuencia básica separada por puntos, los kernels de Linux siguen una convención para distinguir las ramificaciones estables de las experimentales. Las ramificaciones estables usan un número menor aún, mientras que las experimentales usan un número menor impar. Las revisiones son simplemente números secuenciales que representan arreglos de errores y mejoras compatibles con versiones anteriores. Las cadenas de customización a menudo describen una característica específica o un proveedor. Por ejemplo:

  • linux-2.4.37-foo.tar.gz: Indica un archivo fuente de kernel estable 2.4 del proveedor "Foo Industries"
  • /boot/bzImage-2.7.5-smp: Indica un kernel de base experimental compilado 2.7 con soporte a SMP activado
  • patch-2.6.21.bz2: Indica un parche para actualizar un kernel estable 2.6 anterior a la revisión 21

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

Esta sección se ocupa del material del Tema 2.201.2 para el examen 201 de la Intermediate Level Administration (LPIC-2). El Tema tiene un valor de 1.

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 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 son config, 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:

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. El siguiente tutorial de esta serie brinda información sobre la configuración de lilo y grub.

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 Recursos.


Cómo emparchar un kernel

Esta sección se ocupa del material del Tema 2.201.3 del examen 201 de la Intermediate Level Administration (LPIC-2). El Tema tiene un valor de 2.

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 clean eliminará los archivos de objetos adicionales que no reflejen los nuevos cambios.


Cómo personalizar un kernel

Esta sección se ocupa del material del Tema 2.201.4 para el examen 201 de Intermediate Level Administration (LPIC-2). El Tema tiene un valor de 1.

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
   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                  Size  Used by    Not tainted
   lp                      8096   0
   parport_pc             25096   1
   parport                34176   1  [lp parport_pc]
   sg                     34636   0  (autoclean) (unused)
   st                     29488   0  (autoclean) (unused)
   sr_mod                 16920   0  (autoclean) (unused)
   sd_mod                 13100   0  (autoclean) (unused)
   scsi_mod              103284   4  (autoclean) [sg st sr_mod sd_mod]
   ide-cd                 33856   0  (autoclean)
   cdrom                  31648   0  (autoclean) [sr_mod ide-cd]
   nfsd                   74256   8  (autoclean)
   af_packet              14952   1  (autoclean)
   ip_vs                  83192   0  (autoclean)
   floppy                 55132   0
   8139too                17160   1  (autoclean)
   mii                     3832   0  (autoclean) [8139too]
   supermount             15296   2  (autoclean)
   usb-uhci               24652   0  (unused)
   usbcore                72992   1  [usb-uhci]
   rtc                     8060   0  (autoclean)
   ext3                   59916   2
   jbd                    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 por modprobe 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/
      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 con rmmod. 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

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

Obtener los productos y tecnologías

Comentar

Comentarios

developerWorks: Ingrese

Los campos obligatorios están marcados con un asterisco (*).


¿Necesita un IBM ID?
¿Olvidó su IBM ID?


¿Olvidó su Password?
Cambie su Password

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


La primera vez que inicie sesión en developerWorks, se creará un perfil para usted. La información en su propio perfil (nombre, país/región y nombre de la empresa) se muestra al público y acompañará a cualquier contenido que publique, a menos que opte por la opción de ocultar el nombre de su empresa. Puede actualizar su cuenta de IBM en cualquier momento.

Toda la información enviada es segura.

Elija su nombre para mostrar



La primera vez que inicia sesión en developerWorks se crea un perfil para usted, teniendo que elegir un nombre para mostrar en el mismo. Este nombre acompañará el contenido que usted publique en developerWorks.

Por favor elija un nombre de 3 - 31 caracteres. Su nombre de usuario debe ser único en la comunidad developerWorks y debe ser distinto a su dirección de email por motivos de privacidad.

Los campos obligatorios están marcados con un asterisco (*).

(Por favor elija un nombre de 3 - 31 caracteres.)

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


Toda la información enviada es segura.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=90
Zone=Linux
ArticleID=475706
ArticleTitle=Preparación para el examen 201 de LPI: Kernel de Linux
publish-date=03312014