Nuestro primer driver de bloques.

Veamos como quedaría un sencillo driver para un dispositivo de bloques, por ejemplo un disco duro. En esta primera aproximación solo vamos a implementar las funciones init_module() y cleanup_module(), para probarlo crearemos un /dev dos dispositivos de bloque, /dev/mi_dsico0 y mi_disco1.

/*  mpdisco.h */
/*  el comportamiento por defecto es la asignación dinámica */
#define MPDISCO_MAYOR 0



/*  mpdisco.c */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include "mpdisco.h"

unsigned int mpdisco_mayor=MPDISCO_MAYOR;
struct file_operations mpdisco_fops = {
        NULL,       /* lseek */
        block_read,       /* read */
        block_write,       /* write */
        NULL,       /* readdir */
        NULL,       /* poll */
        NULL,       /* ioctl */
        NULL,       /* mmap */
        NULL,       /* open */
        NULL,       /* flush */
        NULL,       /* release */
        NULL,       /* fsync */
        NULL,       /* fasync */
        NULL,       /* check_media_change */
        NULL,       /* revalidate */
        NULL,       /* lock */
};              

int init_module(void) {
        int result;
        EXPORT_NO_SYMBOLS;

        /*  reserva dinamica del número mayor del módulo */
        result=register_blkdev(mpdisco_mayor, "mpdisco", &mpdisco_fops);
        if (result < 0) {
                printk(KERN_WARNING "mpdisco> (init_module) no se pudo 
                                   obtener el mayor %d\n",mpdisco_mayor);
                return result;
        }
        if (mpdisco_mayor == 0) mpdisco_mayor = result;

        /* mensaje y salimos */
        printk( KERN_INFO "mpdisco> (init_module) cargado satisfactoriamente\n");
        return 0;
}

void cleanup_module(void) {
        int result;
        result = unregister_blkdev(mpdisco_mayor, "mpdisco");
        printk( KERN_INFO "mpdisco> (cleanup_module) descargado sin problemas\n");
}

Como vemos el código es prácticamente idéntico al del driver de caracteres, si bien cambiamos la función register_chrdev() por register_blkdev() y unregister_chrdev() por unregister_blkdev() . Los argumentos que reciben estas dos nuevas funciones son los mismos que para el caso de los drivers de caracter y su finalidad es la misma.

También es importante volver a hacer hincapié en el hecho de que nuestro driver no va a implementar ni read ni write, si no que usaremos las funciones predefinidas en el kernel para ello: block_read y block_write .

Es necesario informar al kernel de las características que va a tener nuestros dispositivos, como ya hemos mencionado antes, tenemos que rellenar unos cuantos arrays del kernel:

/*  mpdisco.h */
/*  el comportamiento por defecto es la asignación dinámica */
#define MPDISCO_MAYOR 0
/*  numero máximo de dispositivos que vamos a tener */
#define MPDISCO_MAX_NUM_DEV 2
/*  tamaño en kilobytes de los discos */
#define MPDISCO_SIZE 512
/*  tamaño de los bloques en bytes */
#define MPDISCO_BLKSIZE 1024
/*  Tamaño del sector de los discos en bytes*/
#define MPDISCO_HARDSECT_SIZE 512
/*  ReadAHead que vamos a utilizar para nuestros discos */
#define MPDISCO_RAHEAD 3


/*  mpdisco.c */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/blkdev.h>
#include "mpdisco.h"

unsigned int mpdisco_mayor=MPDISCO_MAYOR;
int mpdisco_blk_sizes[MPDISCO_MAX_NUM_DEV];
int mpdisco_blksize_size[MPDISCO_MAX_NUM_DEV];
int mpdisco_hardsect_size[MPDISCO_MAX_NUM_DEV];

struct file_operations mpdisco_fops = {
        NULL,       /* lseek */
        block_read,       /* read */
        block_write,       /* write */
        NULL,       /* readdir */
        NULL,       /* poll */
        NULL,       /* ioctl */
        NULL,       /* mmap */
        NULL,       /* open */
        NULL,       /* flush */
        NULL,       /* release */
        NULL,       /* fsync */
        NULL,       /* fasync */
        NULL,       /* check_media_change */
        NULL,       /* revalidate */
        NULL,       /* lock */
};                

int init_module(void) {
        int result,i;
        EXPORT_NO_SYMBOLS;
        
        /*  reserva dinamica del número mayor del módulo */
        result=register_blkdev(mpdisco_mayor, "mpdisco", &mpdisco_fops);
        if (result < 0) {
                printk(KERN_WARNING "mpdisco> (init_module) no se pudo 
                                 obtener el mayor %d\n",mpdisco_mayor);
                return result;
        }
        if (mpdisco_mayor == 0) mpdisco_mayor = result;
        
        /*  fijamos el tamaño de los discos */
        for (i=0; i<MPDISCO_MAX_NUM_DEV; i++) {
                mpdisco_blk_sizes[i]=MPDISCO_SIZE;
        }
        blk_size[mpdisco_mayor]=mpdisco_blk_sizes;
        /*  fijamos el tamaño de bloque de los discos */
        for (i=0; i<MPDISCO_MAX_NUM_DEV; i++) {
                mpdisco_blksize_size[i]=MPDISCO_BLKSIZE;
        }
               blksize_size[mpdisco_mayor]=mpdisco_blksize_size;
        /*  fijamos el tamaño de los sectores de disco */
        for (i=0; i<MPDISCO_MAX_NUM_DEV; i++) {
                mpdisco_hardsect_size[i]=MPDISCO_HARDSECT_SIZE;
        }
        hardsect_size[mpdisco_mayor]=mpdisco_hardsect_size;
        /*  fijamos el readahead */
        read_ahead[mpdisco_mayor]=MPDISCO_RAHEAD;
        
        /* mensaje y salimos */
        printk( KERN_INFO "mpdisco> (init_module) cargado satisfactoriamente\n");
        return 0;
}

void cleanup_module(void) {
        int result;
        
        blk_size[mpdisco_mayor]=NULL;
        blksize_size[mpdisco_mayor]=NULL;
        hardsect_size[mpdisco_mayor]=NULL;
        read_ahead[mpdisco_mayor]=0;

        result = unregister_blkdev(mpdisco_mayor, "mpdisco");
        printk( KERN_INFO "mpdisco> (cleanup_module) descargado sin problemas\n");
}

Si intentamos un dd if=un_fichero of=/dev/mi_disco0 comprobaremos como no se ha podido escribir en el dispositivo, esto es por que como es la primera vez que accedemos al dispositivo, no tenemos ninguno de sus bloque en la cache, por lo que la función block_write() mete en la cola de peticiones una petición de escritura, pero como no hemos implementado todavía ninguna función que procese dichas peticiones, esta se queda pendiente.

Vamos a implementar una función muy simple que, aunque procesará las peticiones no llegará a escribir ningún dato en ningún sitio, además vamos a publicarla utilizando la estructura blk_dev, como ya se ha explicado.

La estructura general de la función que atiende a las peticiones ha de ser la siguiente:

• La función en si misma consiste en un bucle infinito, que estará continuamente mirando la cola de peticiones en busca de alguna para procesar.
• La manera de averiguar si una hay una petición pendiente válida es a través de la macro INIT_REQUEST , definida en linux/blk.h . Si leemos cuidadosamente dicho fichero de cabeceras veremos que está preparado para actuar de una forma u otra según sea el valor de MAJOR_NR , es decir si MAJOR_NR tiene alguno de los valores predefinidos para ciertos dispositivos (ram disks, sanyo cdrom...) se configuraran ciertas etiquetas de la manera apropiada. Nuestro dispositivo ficticio no es ninguno de los casos contemplados, y así lo demuestra nuestro número mayor. Todo esto pone de manifiesto que previamente a la inclusión de linux/blk.h tendremos que asociar MAJOR_NR al valor de nuestro número mayor. El orden en que se defina esta macro y se incluya el fichero linux/blk.h es muy importante, más abajo presentamos un ejemplo de como hacerlo, compare las diferencias entre las 43 primeras lineas de código del ejemplo anterior y del nuevo.
• Una vez hemos comprobado la validez de la petición podemos procesarla de la manera que más nos apetezca, o incluso ignorarla. Para ello disponemos de la macro CURRENT , que almacena información sobre la petición a procesar. El tipo de CURRENT es struct request y tiene los siguientes campos de interés:
  • kdev_t rq_dev : El dispositivo sobre el que se quiere acceder.
  • int cmd : contiene READ si se quiere leer o WRITE si se quiere escribir.
  • unsigned long sector : El primer sector al que se quiere acceder (aquí se pone de manifiesto la importancia de informar al kernel sobre las características de nuestro dispositivo, ver sección 4.3.2, pág ).
  • unsigned long current_nr_sectors : La cantidad de sectores que se quieren leer-escribir.
  • char *buffer : El buffer donde serán almacenados los datos leídos (cmd=READ) o donde están los datos que se quieren escribir (cmd=WRITE).
• Una vez procesada la petición no nos queda más que informar al kernel de que todo a salido bien, para que el se ocupe de eliminar la petición procesada de la cola de peticiones. Para ello ejecutamos la función end_request() , definida en linux/blk.h. Es importante hacer notar que dicha función hace uso de una macro llamada DEVICE_OFF , dicha macro no ha sido definida para el dispositivo genérico, por lo que tendremos que definirla nosotros mismos antes de la inclusión de linux/blk.h.
• Unas últimas advertencias sobre linux/blk.h:
  • DEVICE_REQUEST : Al estar declarada como estática en linux/blk.h hemos de definirla en nuestro driver, si no queremos que el compilador nos lance un WARNING.
  • Como nuestro dispositivo es genérico (linea 413 del fichero linux/blk.h) muchas de las macros tendrán un valor por defecto, no obstante si queremos podemos predefinirlas con nuestras preferencias.

Finalmente, podemos implementar un sencillo ejemplo de nuestra función de atención a peticiones (mpdisco_request())de la siguiente manera:

/*  mpdisco.c */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/blkdev.h>


#define MAJOR_NR mpdisco_mayor
unsigned int mpdisco_mayor;
#define DEVICE_OFF(dispositivo) /* nuestro dispositivo no apaga su motor, pues
                                   no tiene */
#define DEVICE_REQUEST mpdisco_request
#include <linux/blk.h>

#include "mpdisco.h"

int mpdisco_blk_sizes[MPDISCO_MAX_NUM_DEV];
int mpdisco_blksize_size[MPDISCO_MAX_NUM_DEV];
int mpdisco_hardsect_size[MPDISCO_MAX_NUM_DEV];

struct file_operations mpdisco_fops = {
        NULL,       /* lseek */
        block_read,       /* read */
        block_write,       /* write */
        NULL,       /* readdir */
        NULL,       /* poll */
        NULL,       /* ioctl */
        NULL,       /* mmap */
        NULL,       /* open */
        NULL,       /* flush */
        NULL,       /* release */
        NULL,       /* fsync */
        NULL,       /* fasync */
        NULL,       /* check_media_change */
        NULL,       /* revalidate */
        NULL,       /* lock */
};                

int init_module(void) {
        int result,i;
        EXPORT_NO_SYMBOLS;

        mpdisco_mayor=MPDISCO_MAYOR;
        /*  reserva dinamica del número mayor del módulo */
        result=register_blkdev(mpdisco_mayor, "mpdisco", &mpdisco_fops);
        if (result < 0) {
                printk(KERN_WARNING "mpdisco> (init_module) no se pudo 
                                 obtener el mayor %d\n",mpdisco_mayor);
                return result;
        }
        if (mpdisco_mayor == 0) mpdisco_mayor = result;
        
        /*  fijamos el tamaño de los discos */
        for (i=0; i<MPDISCO_MAX_NUM_DEV; i++) {
                mpdisco_blk_sizes[i]=MPDISCO_SIZE;
        }
        blk_size[mpdisco_mayor]=mpdisco_blk_sizes;
        /*  fijamos el tamaño de bloque de los discos */
        for (i=0; i<MPDISCO_MAX_NUM_DEV; i++) {
                mpdisco_blksize_size[i]=MPDISCO_BLKSIZE;
        }
               blksize_size[mpdisco_mayor]=mpdisco_blksize_size;
        /*  fijamos el tamaño de los sectores de disco */
        for (i=0; i<MPDISCO_MAX_NUM_DEV; i++) {
                mpdisco_hardsect_size[i]=MPDISCO_HARDSECT_SIZE;
        }
        hardsect_size[mpdisco_mayor]=mpdisco_hardsect_size;
        /*  fijamos el readahead */
        read_ahead[mpdisco_mayor]=MPDISCO_RAHEAD;
        /*  avisamos al kernel de donde está nuestra función para atender peticiones */
        blk_dev[mpdisco_mayor].request_fn = mpdisco_request;
        
        /* mensaje y salimos */
        printk( KERN_INFO "mpdisco> (init_module) cargado satisfactoriamente\n");
        return 0;
}

void cleanup_module(void) {
        int result;
        
        blk_size[mpdisco_mayor]=NULL;
        blksize_size[mpdisco_mayor]=NULL;
        hardsect_size[mpdisco_mayor]=NULL;
        read_ahead[mpdisco_mayor]=0;

        result = unregister_blkdev(mpdisco_mayor, "mpdisco");
        printk( KERN_INFO "mpdisco> (cleanup_module) descargado sin problemas\n");
}


void mpdisco_request(void) {
        for (;;) {
                INIT_REQUEST;
                printk(KERN_INFO "mpdisco> request cmd: %i, sec %li, num_sec:
 %li\n", CURRENT->cmd, CURRENT->sector, CURRENT->current_nr_sectors);
                end_request(1);
        }
}

Para probar este ejemplo hemos de tener en cuenta que el kernel siempre intentará trabajar con los datos en cache. Por ello si ejecutamos un:

 $ dd if=mpdisco.c of=/dev/mi_disco0

Veremos que los primeros mensajes que aparecen en /var/log/messages no son de escritura, si no de lectura, el kernel está leyendo los bloques que cree oportunos, los mete en la cache, y allí escribe los datos. Pasado un determinado tiempo, el kernel decide que ya no se va a trabajar más con esos bloques y le dice al dispositivo que los escriba, por lo que es entonces cuando vemos que aparecen los mensajes de escritura.

Si con los datos cargados en cache intentamos una nueva escritura, el driver tampoco se dará cuenta de ello, pues los datos están siendo modificados en la cache, evitando continuos accesos al dispositivo. Esto es lo que se llama trabajar con la cache ``caliente''. A la hora de hacer pruebas, tenemos que considerar el caso de la cache en frío y la cache en caliente .

Siempre podemos actualizar los datos del dispositivo con los de la cache, por medio del comando sync , veremos que ante la ejecución de ese comando se hacen efectivos en el dispositivo todas las escrituras que se hayan quedado en cache.

Una buena manera de limpiar la cache, para poder hacer pruebas en frío es cargar en ella un fichero de gran tamaño, eliminando así todos los posibles bloques de nuestro dispositivo que estuviesen almacenados en ella. Para ello podemos ejecutar el siguiente comando:

 $ dd if=/dev/zero of=/tmp/fichero_con_ceros count=100000

Que nos crea un fichero en /tmp relleno de ceros de unos 49M aproximadamente ( $100000*512 \ bytes$). De esta manera, la cache a tenido que vaciarse para dar cabida a ese gran fichero.

Para asegurarnos de que hemos entendido perfectamente el funcionamiento de los drivers de bloques, y su relación con la cache, conviene practicar un poco con estos comandos, observando en cada momento las respuestas de nuestro driver ante tales estímulos. Por ejemplo, escribir datos al dispositivo /dev/mi_disco0 con la cache en frío y en caliente ¿qué diferencias se aprecian?, leer datos del dispositivo con la cache en frío y en caliente ¿qué diferencias se aprecian?, aumentar el readahead de nuestro módulo y repetir las mismas operaciones, ¿Se aprecia alguna diferencia?. ¿Qué diferencias hay entre hacer un sync y ``enfriar'' la cache?. ¿Qué pasaría si apagásemos el ordenador (cortando la alimentación) cuando parte de nuestras operaciones están aún en la cache?, ¿como puede ayudarnos sync en este caso?.