Chapter 6.
Drivers
Introduction to drivers
Un controlador es un tipo de programa que extiende la funcionalidad del núcleo de alguna manera.
Hay muchos controladores diferentes en el núcleo para proporcionar soporte a dispositivos de
hardware, tipos de sistemas de archivos, formatos de ejecutables binarios, protocolos de red y una gran
variedad de otras cosas imaginables.
La mayor parte del binario del núcleo, que existe tanto como un archivo en disco (/boot/vmlinuz o
/boot/vmlinux) como en memoria durante el tiempo de ejecución, está compuesto por controladores.
Tipos de Controladores
Existen dos tipos de controladores:
1. **Controladores internos**, que son parte del binario del núcleo y, por lo tanto, forman parte de la
memoria del núcleo cuando el sistema está en funcionamiento.
2. **Controladores externos**, que no son parte del binario del núcleo y se cargan en la memoria de
usuario cuando se necesitan.
Estos controladores externos también se conocen como **módulos de núcleo cargables**.
Los módulos cargables existen como archivos en disco, almacenados en **/lib/modules**. Estos pueden
cargarse en la memoria de usuario según sea necesario. También pueden descargarse de la memoria de
usuario cuando ya no se necesitan.
Driver Implementations
Originalmente, Unix, hasta e incluyendo SVR3, solo podía incorporar controladores internos que eran
directamente parte del binario del núcleo. El proveedor distribuía todos los controladores y otros
componentes del núcleo como archivos binarios precompilados ubicados en el sistema de archivos
instalado.
Si agregabas un nuevo dispositivo de hardware al sistema, como un controlador SCSI, tenías que
construir un nuevo binario del núcleo que incorporara el controlador adecuado para ese dispositivo.
Este controlador podía ser proporcionado por el proveedor de Unix o por el proveedor del hardware del
dispositivo que estabas instalando.
El script de instalación suministrado por el proveedor del hardware o por el proveedor de Unix (cuando
se instalaban controladores genéricos) normalmente también creaba un archivo de dispositivo
adecuado en el directorio **/dev**, permitiendo a los programas acceder al hardware mediante
llamadas al sistema de acceso a archivos normales como **open()**, **close()**, **read()**, y
**write()**.
Una vez completada esta operación, era necesario reiniciar el sistema para que el nuevo núcleo, que
ahora incluía el controlador adecuado, pudiera ejecutarse y comunicarse con el dispositivo
correspondiente.
**SVR4** introdujo el concepto de módulos cargables. BSD y Linux también siguen este modelo de
diseño, aunque cada sistema Unix utiliza diferentes comandos para administrarlos.
### Gestión de Controladores
Existen varios comandos disponibles para administrar módulos cargables en Linux.
**Listar los módulos cargados actualmente**
Puedes ejecutar **lsmod(8)** para mostrar la lista de módulos actualmente cargados en la memoria de
usuario.
### **Carga de Módulos**
Puedes usar los comandos **insmod(8)** o **modprobe(8)** para cargar un módulo desde la
estructura de directorios **/lib/modules** en la memoria de usuario para su uso por el núcleo.
**Ventaja de modprobe sobre insmod:**
- **modprobe** consulta un archivo de dependencias en **/lib/modules** para determinar qué otros
controladores deben cargarse antes del módulo solicitado, mientras que **insmod** no maneja
dependencias automáticamente.
### **Descarga de Módulos**
Para descargar un módulo de la memoria de usuario, puedes usar los comandos **rmmod(8)** o
**modprobe -r**. Sin embargo, el módulo no debe estar en uso por el núcleo; de lo contrario, el intento
de eliminación fallará.
### **Otros Comandos de Gestión de Módulos**
- **modinfo(8):** Muestra información importante sobre un módulo, incluidos sus parámetros de
configuración.
- **depmod(8):** Analiza todos los binarios de módulos en **/lib/modules** y crea un archivo de
dependencias en esa misma estructura de directorios.
### **Controladores de Dispositivos**
**Figura 6.3. Controladores de Dispositivos de Bloque y de Carácter**
- **Controladores de Bloque:** Manejan dispositivos que almacenan datos en bloques, como discos
duros y unidades SSD.
- **Controladores de Carácter:** Manejan dispositivos que transmiten datos en flujos de caracteres,
como teclados y puertos serie.
**Acceso a Dispositivos**
El acceso a los dispositivos implica que el núcleo interactúe con los dispositivos de E/S a través de un
controlador de dispositivos.
Los controladores de dispositivos pueden:
- **Estar vinculados a la imagen del núcleo**, estando disponibles según sea necesario.
- **Ser añadidos como módulos separados**, permitiendo su carga sin reiniciar el núcleo.
Esto permite que el núcleo mantenga una imagen ligera y eficiente, cargando módulos solo cuando se
necesita un dispositivo específico.
**Niveles de Soporte para Controladores de Dispositivos**
Aunque no todos los tipos de soporte están implementados actualmente en Linux, el desarrollo apunta
en esa dirección. Sin embargo, existen límites en la cantidad de controladores que el núcleo puede
manejar. A continuación, se mencionan los niveles de soporte:
1. **Sin Soporte:**
- La aplicación contiene código ensamblador para acceder directamente a los puertos de E/S del
dispositivo.
- Ejemplo: X-Windows maneja pantallas gráficas.
- Funciones relevantes: **iopl()** y **ioperm()**, que otorgan permisos de acceso directo a los
puertos de E/S.
- **Nota:** El proceso debe ejecutarse con permisos de **root**.
2. **Soporte Mínimo:**
- El núcleo detecta y posiblemente reconoce el dispositivo de hardware, pero no puede gestionar su
interfaz de E/S.
- Las aplicaciones de usuario acceden al dispositivo leyendo o escribiendo secuencias de caracteres.
- **Ejemplo:** Puertos serie y paralelo.
3. **Soporte Extendido:**
- El núcleo reconoce el dispositivo de hardware y puede manejar directamente su interfaz de E/S.
- Es posible que ni siquiera sea necesario un archivo de dispositivo para interactuar con el hardware.
Pag 88.