Creación de lista enlazada en liinux Kernel utilizando la lista

Las listas enlazadas son una estructura de datos que se utiliza con mucha frecuencia en el kernel de Linux y hacer la programación más fácil el kernel de Linux proporciona un fácil de crear las listas enlazadas. Utilizando el método incorporado disponible en el núcleo podemos crear listas doblemente enlazadas circulares fácilmente y usarlos en el que cada vez se requiere en el código.

Para poder utilizar esta función disponible en el kernel que necesitamos agregar el archivo de cabecera linux / list.h. La estructura que se utiliza para la creación de la lista «list_head» definido en types.h />
struct list_head {struct list_head * siguiente * anterior ;};

Para utilizar esta estructura para la creación de una lista enlazada es necesario incluir la estructura como un miembro de la estructura principal de la que queremos crear la lista. Por ejemplo, para crear una lista enlazada llamada k_list en el que vamos a crear una lista de números que tendremos que crear la estructura como />
struct k_list {test_list struct list_head; int temp;};

En la estructura anterior «temp» es el dato real que queremos almacenar y test_list, que es una estructura del tipo «list_head «será utilizado para la creación de la lista de enlace.

A continuación, vamos a necesitar para crear una cabeza de la lista enlazada que se utilizará iniciar la creación de la lista. Para crear una cabeza que podemos hacer uso de th INIT_LIST_HEAD macro, que se declaró e inicializar la lista en tiempo de ejecución, o podemos usar el LIST_HEAD función para inicializar la lista en tiempo de compilación.

Una vez que la lista ha sido creada podemos añadir nodos a la lista enlazada usando la función

list_add (struct list_head * nueva estructura list_head * cabeza);

Digamos que queremos añadir a crear una lista enlazada de tres nodos de la estructura tipo k_list se muestra arriba. primero vamos a crear tres estructuras y rellenarla con los datos que queremos almacenar en él.

struct k_list * one *, dos, tres *, * entrada, uno = kmalloc (sizeof (struct k_list *), GFP_KERNEL); dos = kmalloc (sizeof (struct k_list *), GFP_KERNEL); tres = kmalloc (sizeof (struct k_list *), GFP_KERNEL), uno-> temp = 10; dos> temp = 20; tres> temp = 30;

Así, hemos creado tres estructuras «uno», «dos» y «tres» de tipo k_list en el que hemos almacenado los datos «10», «20» y «30», respectivamente .

Ahora, para formar una lista enlazada de estas tres estructuras utilizando

lines_add list_add (y uno-> test_list, y test_head ); list_add (y de dos> test_list, y test_head); list_add (y de tres> test_list, y test_head);

El primer argumento para list_add es la punta para la estructura de tipo list_head que es un miembro de k_list y el segundo argumento es un puntero al nodo cabeza inicializado usando INIT_LIST_HEAD.

Para recorrer a través de la lista enlazada podemos hacer uso de otra función disponible en el núcleo

list_for_each (struct list_head * cursor, struct list_head * lista) * cursor: Es el puntero a la posición actual en la lista de la lista *: Puntero a la cabeza de la lista.

En nuestro ejemplo, puede utilizar esta función como

list_for_each (ptr, y test_head) {

Donde ptr es />
struct list_head * ptr;

Ahora a medida que atravesamos por la lista que tenemos que ser capaces de acceder a los datos que hemos almacenado en la estructura k_list. Para ser capaz de ge un puntero a la estructura k_list través del puntero a los nodos que podemos hacer uso de la función

list_entry (struct list_head * ptr, type_of_struct, field_name); ptr: puntero al nodo actual de la lista type_of_struct vinculado: El tipo de la estructura principal de la que el puntero se va a devolver field_name: Nombre del campo en «type_of_struct» del tipo ptr.

Nota: Esta estructura funciona de forma similar a la función «container_of»

Así, en el ejemplo anterior para obtener un puntero de tipo k_list con el puntero «ptr» Tenemos que utilizar la función como />
entrada = list_entry (ptr, struct k_list, test_list);

Si la penetración es

struct k_list * entrada;

Poner todas las piezas anteriores de código en un módulo podemos probar las funciones relacionadas con la creación de lista enlazada en kernel.
/> create_list.c />

#include#include#include#include struct k_list {test_list struct list_head; int temp;}; int create_list_init () {struct k_list * one *, dos, tres *, * entrada; struct list_head test_head; struct list_head * ptr; uno = kmalloc (sizeof (struct k_list *) , GFP_KERNEL); dos = kmalloc (sizeof (struct k_list *), GFP_KERNEL); tres = kmalloc (sizeof (struct k_list *), GFP_KERNEL), uno-> temp = 10; dos> temp = 20; tres> temp = 30; INIT_LIST_HEAD (& test_head); list_add (y uno-> test_list, y test_head); list_add (y de dos> test_list, y test_head); list_add (y de tres> test_list, y test_head); list_for_each (ptr, y test_head) {entrada = list_entry (ptr , estructura k_list, test_list); printk (KERN_INFO » n Hola% d n», la entrada-> temp);} return 0;} int create_list_exit () {return 0;} module_init (create_list_init); module_exit (create_list_exit);

Makefile necesario para compilar el módulo />
ifneq ($ (KERNELRELEASE),) obj- m: = create_list.o demás KERNELDIR = / lib / modules / $ (shell uname-r) / build PWD: = $ (pwd cáscara) por defecto: $ (MAKE)-C $ (KERNELDIR) M = $ (PWD) módulos endif

Para ver la salida del primero compilar el módulo con

$ make

insertarlo en el kernel

$ insmod create_list.ko

Para ver la salida />
$ dmesg [7822.769538] Hola 30 [7822.769538] [7822.769547] [7822.769547] Hola 20 [7822.769547] [7822.769550] [7822.769550] Hola 10 [7822.769550]

Podemos ver en la salida de dmesg que hemos sido capaces de recorrer la lista mediante list_for_each éxito.