Logiciels Libres et Systèmes Embarqués

Référence du fichier dummy.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/stat.h>
#include <linux/kdev_t.h>
#include <linux/devfs_fs_kernel.h>
#include <linux/slab.h>
#include "dummy.h"

Aller au code source de ce fichier.


Fonctions

static int dummy_open (struct inode *inode, struct file *file)
 Fonction d'ouverture des fichiers speciaux.
static int dummy_release (struct inode *inode, struct file *file)
 Fonction de fermeture des fichiers speciaux.
static ssize_t dummy_write (struct file *file, const char *buffer, size_t size, loff_t *offset)
 Fonction d'ecriture sur les peripheriques.
static ssize_t dummy_read (struct file *file, char *buffer, size_t size, loff_t *offset)
 Fonction de lecture sur les peripheriques.
static int dummy_init (void)
 Fonction de création et d'initialisation des péripheriques.
static void dummy_cleanup (void)
 Fonction de fermeture des périphériques.
 module_init (dummy_init)
 module_exit (dummy_cleanup)
 MODULE_PARM (DeviceCount,"i")
 MODULE_PARM (DeviceName,"s")

Documentation des fonctions

static void dummy_cleanup ( void   )  [static]

Fonction de fermeture des périphériques.

Dans un premier temps, nous libérons la mémoire utilisée par les tableaux alloués et initialisés dans dummy_init. Puis nous supprimons tous les éléments sotckés dans les listes. Enfin nous supprimons les fichiers spéciaux de /dev et nous désenregistrons notre pilote auprès du noyau.

Définition à la ligne 680 du fichier dummy.c.

Références already_opened, DEBUG, device_fifo, DeviceCount, element_fifo::next, open_critique, et element_fifo::prev.

static int dummy_init ( void   )  [static]

Fonction de création et d'initialisation des péripheriques.

Dans un premier temps, nous enregistrons notre pilote auprès du noyau et nous lui demandons de nous affilier un numéro de majeur. Puis nous créons (grâce au système DevFS) les fichiers spéciaux dans /dev. Enfin, nous alloueons et initialisons les différents tableaux nécessaires au pilote.

Renvoie:
0 en cas de succès, -errno sinon.

Définition à la ligne 598 du fichier dummy.c.

Références already_opened, DEBUG, device_fifo, DeviceCount, DeviceName, dummy_fops, dummy_major, DUMMY_MAJOR, private_dummy::head, private_dummy::in_use, et open_critique.

static int dummy_open ( struct inode *  inode,
struct file *  file 
) [static]

Fonction d'ouverture des fichiers speciaux.

Nous vérifions dans un premier temps si le mineur du fichier spécial est valide, c'est à dire qu'il appartient bien à ceux géré par notre pilote. Ensuite, nous prenons soin de vérifier que le fichier spécial n'est pas déjà ouvert (par un autre processus par exemple), auquel cas nous indiquons que la ressource est occupée. Dans un troisième temps nous empèchons qu'un fichier spécial de lecture ne soit ouvert en écriture, et vice-versa. Puis nous déclarons au noyau que le périphérique est utilisé (en incrémentant le compteur d'usage), et enfin nous associons le private_data du fichier spécial avec son private_dummy correspondant.

Renvoie:
0 en cas de succès, -errno sinon.

Définition à la ligne 239 du fichier dummy.c.

Références already_opened, DEBUG, device_fifo, DeviceCount, et open_critique.

static ssize_t dummy_read ( struct file *  file,
char *  buffer,
size_t  size,
loff_t *  offset 
) [static]

Fonction de lecture sur les peripheriques.

Tout d'abord, nous regardons si le périphérique est déjà occupé, si c'est le cas et que l'utilisateur a demandé un accès non bloquant, nous quittons la fonction en précisant que la resource est momentanément inaccéssible, sinon nous bloquons le processus. Dans la lecture, nous réordonnançons le processus afin de libérer le système.

Renvoie:
0 en cas de succès, -errno sinon.

Définition à la ligne 482 du fichier dummy.c.

Références BUF_SIZE, element_fifo::buffer, DEBUG, private_dummy::head, private_dummy::in_use, private_dummy::in_use_critique, private_dummy::index, element_fifo::next, element_fifo::position, element_fifo::prev, private_dummy::rw_critique, et element_fifo::used_bytes.

static int dummy_release ( struct inode *  inode,
struct file *  file 
) [static]

Fonction de fermeture des fichiers speciaux.

On indique simplement que le fichier special est à nouveau accessible et nous décrémentons le compteur d'usage.

Renvoie:
0 en cas de succès, -errno sinon.

Définition à la ligne 308 du fichier dummy.c.

Références already_opened, DEBUG, et open_critique.

static ssize_t dummy_write ( struct file *  file,
const char *  buffer,
size_t  size,
loff_t *  offset 
) [static]

Fonction d'ecriture sur les peripheriques.

Tout d'abord, nous regardons si le périphérique est déjà occupé, si c'est le cas et que l'utilisateur a demandé un accès non bloquant, nous quittons la fonction en précisant que la resource est momentanément inaccéssible, sinon nous bloquons le processus. En ce qui concerne le remplissage de la liste des données, nous vérifions dans un premier temps que la liste n'est pas vide, si tel n'est pas le cas, nous alloueons un premier élément puis nous rentrons dans la boucle de remplissage. Dans cette dernière, nous réordonnançons le processus afin de libérer le système.

Renvoie:
0 en cas de succès, -errno sinon.

Définition à la ligne 343 du fichier dummy.c.

Références BUF_SIZE, element_fifo::buffer, DEBUG, private_dummy::head, private_dummy::in_use, private_dummy::in_use_critique, private_dummy::index, element_fifo::next, element_fifo::position, element_fifo::prev, private_dummy::rw_critique, et element_fifo::used_bytes.

module_exit ( dummy_cleanup   ) 

module_init ( dummy_init   ) 

MODULE_PARM ( DeviceName  ,
"s"   
)

MODULE_PARM ( DeviceCount  ,
"i"   
)