CARGAR MÓDULOS

1.     Compilar el núcleo con los parámetros de configuración que permiten trabajar con módulos.

*

* Loadable module support

*

Enable loadable module support (CONFIG_MODULES) [Y/n/?] Y

2.     Diseñar e implementar un manejador como módulo cargable.

2.1 Definir número mayor y menor para el dispositivo

#define manejador_MAYOR nn

#define manejador_MINOR  xx

2.2 Definir operaciones de entrada salida para el dispositivo

static   int   manejador_fs_read (struct  inode  *inode, struct  file  *file,

                                                                 char *buf, int  nbytes );

2.4 Definir la estructura  file_operations

static struct  file_operations  manejador_fops =

{

          NULL,

          manejador_fs_read,

          NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL,

NULL

};

2.5 Diseñar la función de inicialización del modulo y descarga

int  manejador_init (void)

{

.....

}

#ifdef MODULE

/* función de inicio del modulo */

int init_module (void)

{

          return manejador_init ();

}

/* Función de descarga del módulo */

void cleanup_module (void)

{

unregister_chardev (mayor device, “manejador”);

printk (“manejador modulo no se puede descargar \n”);

}

#endif

2.6 Diseñar la función de lectura del manejador

static int manejador_fs_read (struct inode *inode, struct file *file, char *buf, int nbytes)

{

...

}

3.     Compilar el modulo con las directivas D__KERNEL__  y DMODULE

4.     Crear el archivo especial para este manejador.

#mknod /dev/manejador    c   mayor_device   menor_device

5.     Insertarlo en el núcleo.

#insmod  manejador

6.     Ver lista de módulos cargados.

#lsmod

7.     Utilizarlo

8.     Quitarlo del núcleo.

#rmmod  manejador

MÓDULOS DEL NÚCLEO

Hay componentes del núcleo que siempre tienen que estar en memoria como el planificador de la CPU.

Sin embargo otros componentes solo tienen que estar en memoria cuando se  necesitan, como el manejador de un CDWriter; un sistema de ficheros Minix, NFS; un manejador de protocolo PPP.

Estas partes del núcleo que pueden cargarse o descargarse dinámicamente en memoria, mientras el núcleo se esta ejecutando se llaman MÓDULOS.

Ventajas de los módulos

La incorporación de nuevos manejadores al núcleo es mas fácil, se pueden compilar, cargar, probar, o quitar como módulos antes de integrarlos en le núcleo.

Si el manejador está integrado en el núcleo, cada vez que hagamos modificaciones en el manejador hay que recompilar todo el núcleo y reiniciar.

El núcleo no ocupa tanta memoria principal, quedando libre para las aplicaciones.

Desventajas

Cada vez que se requiere o ya no se necesita un módulo hay que pagar el coste de leer o escribir en disco.

El código del núcleo se incrementa con el sistema de manejo de módulos.

La opción que activa que el núcleo maneje los módulos es:

Enable loadable module suport (CONFIG_MODULES) [Y/n/?]

Si se desea instalar un componente como módulo, hay que declararlo en la configuración del núcleo, ejemplo instalar el sistema de ficheros MSDOS.

DOS FAT fs support (CONFIG_FAT_FS) [M/n/y/?]  M

MSDOS fs support (CONFIG_MSDOS_FS) [M/n/y/?] M

VFAT (Windows-98) fs support (CONFIG_VFAT_FS) [m/n/y/?] M

Una vez compilado el núcleo se compilan los módulos, la secuencia puede ser:

make config

make dep

make clean

make zImage

make modules

make modules_install

finalizado este proceso, los módulos se encuentran el /lib/modules.

Los módulos se compilan como cualquier programa pero son enlazados como imágenes recargables, esto es no están asociadas a ninguna dirección.

Podemos ver los símbolos exportados por el núcleo en /proc/ksyms o utilizando el comando ksyms.

Cada módulo debe contener unos procedimientos que los manejan, incluyendo uno de inicialización cuando se carga el módulo y otro de borrado cuando se quita del núcleo.

Los comandos del super usuario para manejar manualmente los módulos son:

• insmod – instalar un módulo

• lsmod – lee el contenido de /proc/modules y muestra los módulos cargados en memoria, (nombre, número de páginas del módulo y procesos que los utilizan).

ejemplo de listado al ejecutar lsmod

Module:                  #pages:                 Used by:

msdos                              2                            1 (autoclean)

vfat                                  4                            1 (autoclean)

fat                                   6        [vfat msdos] 2 (autoclean)

• rmmod – quitar un módulo

Carga automática de módulos por demanda del núcleo

Cuando se monta un sistema de ficheros que no está integrado en el núcleo, el núcleo solicita al programa kerneld que cargue los módulos necesarios para este sistema de ficheros montado.

La carga dinámica y automática de módulos precisa que se compile el núcleo con la opción CONFIG_KERNELD y los IPC System V.

Se precisa al arrancar el sistema lanzar el programa demonio kerneld, que lee las peticiones del núcleo y realiza la carga o descarga de los módulos necesarios. Se ejecuta como un proceso de usuario y establece un canal de comunicación basado en mensajes  (IPC) con el núcleo, por el cual el núcleo solicita mediante mensajes un modulo al programa modprobe.

se utilizan los programas depmod y modprobe.

DEPMOD, genera un archivo de dependencias de los símbolos encontrados en los módulos.

MODPROBE,  es el programa para manejo de módulos, requiere privilegios de root.

Los procedimientos del núcleo que interaccionan con modprobe y la estructura de datos principal, (se encuentran en include/linux/module.h y kernel/module.c) son:

• request_module

Es la función llamada por el núcleo cuando este percibe, por la solicitud de un proceso, la necesidad de cargar un módulo.

• exec_modprobe

Es el programa que añade el módulo solicitado al núcleo, es llamado por kerneld.

• struct module

Los ficheros que tratan con los módulos son:

incluye/linux/module.h

kernel/module.c

contienen la estructura struc module

 y las llamadas al sistema utilizadas por modprobe y los comandos insmod, lsmod y rmmod son:

sys_create_module

sys_init_module

sys_delete_module

sys_get_kernel_syms