Logiciels Libres et Systèmes Embarqués

• Site :
  • Accueil
  • News
  • Contact et CV
• Rapports :
  • Linux/Xilinx
  • Linux/DC
  • Pilote Linux
  • LwIP/Xilinx
• Projets :
  • Js2Mouse
  • R3KCompiler
• Articles :
  • FreePlayer
• Recherche :

---

dummy.c

Aller à la documentation de ce fichier.

/*
  Copyright (C) 2005 MARTIN Loïc & VINCENT Cedric
  
  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License
  as published by the Free Software Foundation; either version 2
  of the License, or (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#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"

static int dummy_open (struct inode *inode, struct file *file)
{
        int minor_lu = -1;
        int index = 0;

        // recupere le numero de mineur du fichier special
        minor_lu = MINOR(inode->i_rdev);

        // verifie qu'il est valide
        if (minor_lu > (DeviceCount*2 - 1)) {
                DEBUG && printk (KERN_ALERT "peripherique non supporte !\n");
                return -ENODEV;
        }

        // debut de section critique (prise de semaphore)
        if( down_interruptible(&open_critique[minor_lu]) ) {
                DEBUG && printk (KERN_ALERT "impossible de prendre le semaphore\n");
                return -ERESTARTSYS;
        }

        // verifie que quelqu'un n'est pas en train d'utiliser le fichier special
        if(1 == already_opened[minor_lu]) {
                DEBUG && printk (KERN_ALERT "deja ouvert !\n");
                up(&open_critique[minor_lu]);
                return -EBUSY; //errno : Resource busy
        }       
        already_opened[minor_lu] = 1;

        // verifie que sur le fichier special ecriture on ne demande pas de lecture
        if (0 == minor_lu % 2 && file->f_mode & FMODE_READ) {
                DEBUG && printk (KERN_ALERT "ouverture non autorisee en lecture !\n");
                up(&open_critique[minor_lu]);
                return -EACCES;
        }

        // verifie que sur le fichier special de lecture on ne demande pas d'ecriture  
        if (1 == minor_lu % 2 && file->f_mode & FMODE_WRITE) {
                DEBUG && printk (KERN_ALERT "ouverture non autorisee en ecriture !\n");
                up(&open_critique[minor_lu]);
                return -EACCES;
        }

        // incremente le compteur d'usage du module (premiere chose a faire)
        //MOD_INC_USE_COUNT;
        if(try_module_get(THIS_MODULE) < 0) {
                DEBUG && printk (KERN_ALERT "erreur d'incrementation du compteur d'usage\n");
                up(&open_critique[minor_lu]);
                return -ERESTARTSYS;
        }

        // positionne le pointeur de pile sur le bon peripherique
        index = (int)minor_lu/2;
        file->private_data = &device_fifo[index];       

        // fin de section critique (relachement du semaphore)
        up(&open_critique[minor_lu]);

        DEBUG && printk (KERN_ALERT "ouverture autorisee !\n");
        DEBUG && printk (KERN_ALERT "utilisation de la file %d\n", index);
        
        return 0;
}

static int dummy_release (struct inode *inode, struct file *file)
{
        int minor_lu = -1;
        int index = 0;

        // recupere le numero de mineur du fichier special
        minor_lu = MINOR(inode->i_rdev);
        index = (int)minor_lu/2;

        DEBUG && printk (KERN_ALERT "fichier special ferme !\n");       

        if( down_interruptible(&open_critique[minor_lu]) ) {
                DEBUG && printk (KERN_ALERT "impossible de prendre le semaphore\n");
                return -ERESTARTSYS;
        }
        already_opened[minor_lu] = 0;

        module_put(THIS_MODULE); // (derniere chose a faire)
        //MOD_DEC_USE_COUNT;
        up(&open_critique[minor_lu]);

        return 0;
}

static ssize_t dummy_write (struct file *file, const char *buffer, size_t size, loff_t *offset)
{       
        struct private_dummy *private_data = file->private_data;
        struct element_fifo *last_element = NULL;
        struct element_fifo *new_element = NULL;
        struct element_fifo *current_element = NULL;
        struct element_fifo *head_element = private_data->head;
        size_t count = 0; // donnees ecrites par element
        size_t total_length = 0; // total des donnees ecrites
        unsigned long ret_code = 0;
        size_t origin_size = size; // total des donnees a ecrire
        size_t retvalue = 0; // code de retour

        if( down_interruptible(&private_data->in_use_critique) ) {
                DEBUG && printk (KERN_ALERT "impossible de prendre le semaphore\n");
                return -ERESTARTSYS;
        }

        // gestion de l'ecriture non bloquante
        if (1 == private_data->in_use && O_NONBLOCK & file->f_flags) {
                up(&private_data->in_use_critique);
                return -EAGAIN;
        } 
        private_data->in_use = 1;
        up(&private_data->in_use_critique);

        // debut de section critique (prise de semaphore)
        if( down_interruptible(&private_data->rw_critique) ) {
                DEBUG && printk (KERN_ALERT "impossible de prendre le semaphore\n");
                return -ERESTARTSYS;
        }

        // s'il n'y pas de tete , il faut la creer et l'initialiser (elle pointe (next et prev)
        // sur elle-meme)
        if(NULL == head_element) {
                head_element = kmalloc (sizeof(struct element_fifo), GFP_KERNEL);
                if(NULL == head_element) {
                        DEBUG && printk (KERN_ALERT "allocation ratee");
                        return -ERESTARTSYS;
                }

                DEBUG && printk(KERN_ALERT "allocation de l'element de tete\n");
        
                head_element->used_bytes = 0;
                head_element->position = 0;
                head_element->prev = head_element;
                head_element->next = head_element;

                private_data->head = head_element;
        }

        // tant que les donnees ne sont pas toutes ecrites
        while(total_length < origin_size) {
                // se positionner sur le dernier element.
                current_element = head_element->prev;           
        
                // verifie que le buffer a ecrire rentre dans la place restante du bloc
                if (size < BUF_SIZE - current_element->used_bytes) {
                        count = size;
                } else {
                        //sinon completer l'element avant d'en creer un autre
                        count = BUF_SIZE - current_element->used_bytes;
                }

                // ecriture de 'count' caracteres du buffer dans l'element en cours
                ret_code = copy_from_user(current_element->buffer + current_element->used_bytes,
                                          buffer, count);

                if (0 != ret_code) {
                        DEBUG && printk(KERN_ALERT "erreur d'ecriture\n");
                        retvalue = -EFAULT;
                        goto ret_write;
                } 

                DEBUG && printk(KERN_ALERT "ecriture de %d octets sur %d\n", (int)count, 
                                (int)size);

                // deplacement du pointeur sur le buffer du nombre de caracteres deja ecrits
                buffer = buffer + count;
                // mettre a jour le compteur de ce qu'il reste a ecrire
                size = size - count;
                // mettre a jour des compteurs de ce qui est ecrit
                total_length = total_length + count;
                current_element->used_bytes = count + current_element->used_bytes;

                DEBUG && printk(KERN_ALERT
                                "occupation du noeud %d octets sur %d dans la file %d\n",
                                current_element->used_bytes, BUF_SIZE, private_data->index);

                if (BUF_SIZE == current_element->used_bytes) { 
                        // allocation d'un nouvel element 
                        new_element = kmalloc (sizeof(struct element_fifo), GFP_KERNEL); 
                        if (new_element == NULL)  { 
                                DEBUG && printk (KERN_ALERT "allocation ratee");
                                retvalue = -ERESTARTSYS;
                                goto ret_write;
                        } 

                        // creation des liens entre le nouvel element et le reste de la pile
                        last_element = head_element->prev; 
                        last_element->next = new_element; 
                        head_element->prev = new_element; 

                        // initialisation du nouvel element
                        new_element->used_bytes = 0; 
                        new_element->position = 0; 
                        new_element->prev = last_element; 
                        new_element->next = head_element; 

                        DEBUG && printk(KERN_ALERT "allocation d'un nouveau element\n"); 
                } 
                
                // reordonnancement du processus, afin de liberer le systeme.
                schedule();
        }       
        retvalue = total_length;

ret_write:
        // fin de section critique (relachement du semaphore)
        up(&private_data->rw_critique);

        if( down_interruptible(&private_data->in_use_critique) ) {
                DEBUG && printk (KERN_ALERT "impossible de prendre le semaphore\n");
                return -ERESTARTSYS;
        }
        private_data->in_use = 0;
        up(&private_data->in_use_critique);

        return retvalue;
}

static ssize_t dummy_read (struct file *file, char *buffer, size_t size, loff_t *offset)
{
        struct private_dummy *private_data = file->private_data;
        struct element_fifo *head_element = private_data->head;
        struct element_fifo *current_element = NULL;
        struct element_fifo *next_element = NULL;
        struct element_fifo *prev_element = NULL;
        size_t count = 0; // donnees lues par elements
        size_t total_length = 0; // total des donnees lues
        unsigned long ret_code = 0;
        size_t origin_size = size; // total des donnees a lire
        size_t retvalue = 0; // code de retour

        if( down_interruptible(&private_data->in_use_critique) ) {
                DEBUG && printk (KERN_ALERT "impossible de prendre le semaphore\n");
                return -ERESTARTSYS;
        }

        // gestion de la lecture non bloquante
        if (1 == private_data->in_use && O_NONBLOCK & file->f_flags) {
                up(&private_data->in_use_critique);
                return -EAGAIN;
        } 

        private_data->in_use = 1;

        up(&private_data->in_use_critique);

        // debut de section critique (prise de semaphore)       
        if( down_interruptible(&private_data->rw_critique) ) {
                DEBUG && printk (KERN_ALERT "impossible de prendre le semaphore\n");
                return -ERESTARTSYS;
        }

        //tant que le message n'est pas lu en entier ou qu'il n'y a plus rien a lire 
        while(total_length < origin_size && NULL != head_element) { 
                current_element = head_element; 

                // verifie que le buffer a lire est plus petit qu'un bloc
                if (size < current_element->used_bytes) { 
                        count = size; 
                } else { // sinon lire la taille du bloc
                        count = current_element->used_bytes; 
                } 

                // lecture de 'count' caracteres de l'element en cours a partir de 'position'
                ret_code = copy_to_user(buffer,
                                        current_element->buffer+current_element->position,
                                        count); 

                if (0 != ret_code) { 
                        DEBUG && printk(KERN_ALERT "erreur de lecture\n");
                        retvalue = -EFAULT; 
                        goto ret_read;
                }  

                DEBUG && printk(KERN_ALERT "lecture de %d octets sur %d\n", (int)count,
                                (int)size); 

                // mise a jour des pointeurs de buffer et du nombre de caracteres lus
                buffer = buffer + count; 
                size = size - count; 
                total_length = total_length + count; 
                current_element->used_bytes = current_element->used_bytes - count;
                current_element->position = current_element->position + count;
                DEBUG && printk(KERN_ALERT
                                "occupation du noeud %d octets sur %d dans la file %d\n",
                                current_element->used_bytes, BUF_SIZE, private_data->index);

                //si element vide , desallouer la memoire sauf si c'est le dernier element  
                if(0 == current_element->used_bytes) {
                        prev_element = current_element->prev;
                        next_element = current_element->next;

                        prev_element->next = next_element;
                        next_element->prev = prev_element;

                        if(current_element != current_element->next) {
                                head_element = next_element;
                        } else {
                                head_element = NULL;
                        }
                        
                        private_data->head = head_element;
 
                        kfree(current_element);                 
                        current_element = NULL;
                }
                
                // force le reordonnacement du processus
                schedule();
        } 
        retvalue = total_length;

ret_read:
        // fin de section critique (relachement du semaphore)
        up(&private_data->rw_critique);

        if( down_interruptible(&private_data->in_use_critique) ) {
                DEBUG && printk (KERN_ALERT "impossible de prendre le semaphore\n");
                return -ERESTARTSYS;
        }
        private_data->in_use = 0;
        up(&private_data->in_use_critique);

        return retvalue;
} 

static int dummy_init(void)
{
        int result;
        int i;

        // allocation dynamique d'un majeur pour le pilote dummy
        result = register_chrdev(DUMMY_MAJOR, DeviceName, &dummy_fops);
        if (result < 0) {
                DEBUG && printk(KERN_ALERT "majeur %d indisponible\n", result);
                return -ERESTARTSYS;
        }
        // recuperation du numero de majeur pour la creation des peripheriques
        if (0 == dummy_major) {
                dummy_major = result;
        }

        // creation des peripheriques
        for (i = 0; i < DeviceCount; i++) {
                // mineur pair => ecriture
                devfs_mk_cdev(MKDEV(dummy_major, 2*i), S_IFCHR|S_IRUGO|S_IWUGO, "%s_W%d",
                              DeviceName, i);
                DEBUG && printk(KERN_ALERT "%s_R%d cree\n", DeviceName, i);

                // mineur impair => lecture
                devfs_mk_cdev(MKDEV(dummy_major, 2*i+1), S_IFCHR|S_IRUGO|S_IWUGO, "%s_R%d",
                              DeviceName, i);
                DEBUG && printk(KERN_ALERT "%s_W%d cree\n", DeviceName, i);
        }

        // allocation memoire du tableau d'etat des fichiers speciaux ouverts
        already_opened = kmalloc (DeviceCount*2*sizeof(int), GFP_KERNEL);
        if (already_opened == NULL)  {
                DEBUG && printk (KERN_ALERT "allocation ratee");
                return -ERESTARTSYS; 
        }

        // allocation memoire du semaphore de protection du tableau d'etat des fichier speciaux ouverts
        open_critique = kmalloc (DeviceCount*2*sizeof(struct semaphore), GFP_KERNEL);
        if (open_critique == NULL)  {
                DEBUG && printk (KERN_ALERT "allocation ratee");
                kfree(already_opened);
                return -ERESTARTSYS; 
        }

        // inutile d'utiliser le semaphore (de protection) pour cette operation car il ne peut pas y avoir d'acces concurrent
        // initialisation du tableau d'etat des fichier speciaux ouvrerts et des sempahores de protection
        for(i = 0; i < DeviceCount*2 ; i++) {
                already_opened[i] = 0;
                sema_init(&open_critique[i], 1);
        }

        // allocation et initialisation des pointeurs sur la structure de pile (un par peripherique)
        device_fifo = kmalloc (DeviceCount*sizeof(struct private_dummy), GFP_KERNEL);
        if(NULL == device_fifo) {
                DEBUG && printk (KERN_ALERT "allocation ratee");
                kfree(already_opened);
                kfree(open_critique);
                return -ERESTARTSYS; 
        }

        for(i = 0; i < DeviceCount; i++) {
                device_fifo[i].index = i;
                device_fifo[i].head  = NULL;
                device_fifo[i].in_use = 0;
                sema_init(&device_fifo[i].in_use_critique, 1);
                sema_init(&device_fifo[i].rw_critique, 1);
        }

        DEBUG && printk(KERN_ALERT "module %s charge gerant 2x%d peripheriques\n", DeviceName,
                        DeviceCount);

        // Une valeur de retour differente de 0 signifie un echec de init_module et donc du
        // chargement du module !
        return 0;
}

static void dummy_cleanup(void)
{
        int i = 0;      
        int result;
        struct element_fifo *tmp_element = NULL;
        struct element_fifo *current_element = NULL;

        // liberation de la memoire du semaphore de protection du tableau d'etat des fichier speciaux ouverts
        kfree(open_critique);
        open_critique = NULL;

        kfree(already_opened);
        already_opened = NULL;
        
        // liberation de la memoire des piles de donnees
        for (i = 0; i < DeviceCount; i++) {
                // recuperation de la tete de la pile
                current_element = device_fifo[i].head;
                
                if(NULL != current_element) { //si la tete existe
                        // tant qu'il y a au moins une boite en plus de la tete
                        while(current_element != current_element->next) { 
                                // positionnement sur l'element suivant
                                tmp_element = current_element->next; 

                                // suppression de liens de l'element courant
                                tmp_element->prev =  current_element->prev;
                                current_element->prev->next = tmp_element;
                                
                                // suppression de l'element courant
                                kfree(current_element); 
                                current_element = NULL; 

                                // l'element courant devient l'ancien element suivant
                                current_element = tmp_element; 
                                DEBUG && printk (KERN_ALERT "supression d'un noeud !\n"); 
                        }
                
                        // suppression du dernier element
                        kfree(current_element); 
                        current_element = NULL;

                        DEBUG && printk (KERN_ALERT "supression d'un noeud !\n"); 
                }
        }

        // liberation de la memoire des pointeurs sur la structure de pile (un par peripherique)
        kfree(device_fifo);
        device_fifo = NULL;
        
        // suppression des peripheriques
        for (i = 0; i < DeviceCount; i++) {
                devfs_remove("%s_R%d", DeviceName, i);
                DEBUG && printk(KERN_ALERT "%s_R%d supprime\n", DeviceName, i);
        
                devfs_remove("%s_W%d", DeviceName, i);
                DEBUG && printk(KERN_ALERT "%s_W%d supprime\n", DeviceName, i);
        }

        // desenregistrement du pilote au niveau du noyau
        result = unregister_chrdev(dummy_major, "dummy"); 
        if (result < 0) {
                DEBUG && printk (KERN_ALERT "desenregistrement %d rate\n", dummy_major); 
                return; 
        } 

        DEBUG && printk(KERN_ALERT "dummy decharge\n");
}

module_init(dummy_init);
module_exit(dummy_cleanup);

MODULE_PARM (DeviceCount, "i");
MODULE_PARM (DeviceName, "s");

---