Controlador de dispositivo Linux Tutorial Para principiantes

El sistema operativo Linux contiene 3 secciones principales: sistema de archivos raíz, kernel y cargador de arranque.

Sistema de archivos raíz:

Esta parte del sistema operativo contiene binarios de la aplicación, bibliotecas, scripts, archivos de configuración y archivos de módulo cargables del kernel, etc

Núcleo:

Esta parte es el corazón del sistema operativo, el kernel es responsable de manejar todas las operaciones necesarias para ejecutar el sistema operativo, como la gestión de la memoria, la gestión de procesos y las operaciones de hardware de entrada / salida, etc

Cargador de arranque:

Esta es la primera parte que ejecuta la CPU al arrancar. El cargador de arranque contiene el código fuente para inicializar el sistema y comenzar a ejecutar el kernel y contiene comandos para depurar y modificar el entorno del kernel, también contiene los comandos para descargar y actualizar el kernel y las imágenes del sistema en la memoria flash.

Los controladores actúan como un puente entre el hardware y una aplicación de usuario, el núcleo proporciona un mecanismo llamado llamadas al sistema para comunicarse con el núcleo.  En Linux, los controladores se pueden implementar de dos maneras, una es que los controladores se pueden compilar como parte del kernel y otra es que los controladores se pueden compilar como módulos y cargar en tiempo de ejecución.

Comencemos con un módulo de kernel simple hello world. Aquí está el código fuente de un módulo de kernel simple hello world.

Hola.C

#incluir // necesario para module_init y module_exit #include // necesario para KERN_INFO #include // necesario para las macros int __init hw_init (void) printk (KERN_INFO "Hola mundo \ n"); return 0;  void __exit hw_exit (void) printk (KERN_INFO "Bye World \ n");  MODULE_LICENSE ("GPL"); module_init (hw_init); module_exit (hw_exit); 

Makefile

obj-m: = hola.o todos: make -C / lib / modules / $ (shell uname -r) / build M = $ (PWD) módulos limpios: make -C / lib / modules / $ (shell uname -r) / build M = $ ( PWD) limpio 

Crea una carpeta llamada Hola y luego coloque el Hola.C y Makefile dentro de eso. Abre el Terminal aplicación y cambie el directorio a hola. Ahora ejecuta el comando fabricar y si tiene éxito, debería generar un archivo de módulo de kernel cargable llamado Hola.ko.

Cuando ejecutas make si obtienes salida hacer: No hay nada que hacer para 'todos'.  Luego, asegúrese de que en el Makefile haya ingresado la pestaña (sin espacios) antes de hacer -C. Si la creación tiene éxito, debería obtener el resultado como se muestra a continuación.

make [1]: Ingresando al directorio '/ usr / src / linux-headers-3.13.0-128-genérico 'CC [M] / home / John / Desktop / hello / hello.o Módulos de construcción, etapa 2. Módulos MODPOST 1 CC / inicio / John / Escritorio / hola / hola.modificación.o LD [M] / home / John / Desktop / mvs / pers / kern / hello / hello.ko make [1]: Saliendo del directorio '/ usr / src / linux-headers-3.13.0-128-genérico ' 

Ahora probemos el módulo cargándolo en el kernel. Para cargar y descargar módulos del kernel, necesitamos tener permiso de superusuario. Utilice el siguiente comando para cargar el módulo del kernel en el kernel.

sudo insmod hola.ko

Para ver el mensaje de printk, debe verificar el registro del kernel, para verificar el registro del kernel use el siguiente comando.

dmesg

Este comando generará los mensajes de registro del kernel, al final debería ver que nuestro mensaje Hola Mundo impreso.

Para descargar el módulo use el siguiente comando.

sudo rmmod hola

Para ver el mensaje de printk, use el comando dmesg nuevamente y en el registro del kernel puede ver nuestro mensaje Adiós mundo.

Ahora entendamos el código fuente.

Hola.C

Para comenzar a escribir el controlador del kernel, puede usar cualquier editor o ide de su elección, pero lo más común es que los desarrolladores del kernel prefieran usar vi editor.

Cada módulo del kernel debe incluir el archivo de encabezado linux / módulo.h esto tiene las declaraciones y macros para funciones del kernel como module_init y module_exit etc.  Las dos funciones más necesarias para un controlador de kernel son las funciones module_init y module_exit. La función cuyo puntero se pasa a module_init se ejecutará cuando carguemos el módulo en el kernel, y la función cuyo puntero se pasa a module_exit se llamará cuando descarguemos o eliminemos el módulo del kernel.

Dentro del kernel para depurar e imprimir el registro, usamos printk función que es similar a la función printf que usamos en la aplicación. Puede utilizar macros como KERN_INFO, KERN_ERR, etc ... para especificar un nivel de registro.

Si estamos escribiendo un controlador para hablar con un hardware específico, entonces la función init debe tener el código para inicializar el hardware antes de comenzar a usarlo y la función de salida debe tener un código para limpiar los recursos (memoria dinámica, etc.) que usamos en el controlador. antes de salir del kernel.

Aquí, en este ejemplo, solo estamos imprimiendo mensajes de depuración en las funciones init y exit.

Makefile

Para construir el módulo del kernel, necesitamos escribir un Makefile que guiará fabricar  utilidad cómo compilar el módulo. La sintaxis obj-m se usa para decirle al archivo make del kernel que el controlador debe compilarse como módulo usando el archivo de objeto especificado. Cuando solo ejecutas el comando fabricar entonces el control llega al todas: sección del Makefile y si ejecuta el comando hacer limpia luego el control va a la limpio: sección de Makefile. Desde este Makefile estamos ejecutando make dentro del directorio fuente del kernel usando la opción -C. Asegúrese de tener el directorio fuente del kernel instalado en su sistema. Aquí en este ejemplo usamos el comando uname -r  para encontrar la versión actual del kernel de linux de su sistema.

Hemos utilizado la opción M = $ (PWD) para indicar en el archivo make del kernel que la fuente del controlador está en el directorio de trabajo actual y estamos especificando la palabra módulos para decirle a kernel makefile que solo compile módulos y no compile el código fuente completo del kernel. En limpio: sección de Makefile le estamos diciendo al kernel makefile que limpie los archivos objeto generados para construir este módulo.

Esto debería comenzar a compilar y ejecutar su primer módulo del kernel.