ELE-784 Ordinateurs et programmation système Cours #3 Introduction aux pilotes d interfaces Bruno De Kelper Site internet : http://www.ele.etsmtl.ca/academique/ele784/ Cours # 3 ELE784 - Ordinateurs et programmation système 1 Plan d aujourd hui 1. Introduction Pilote d unité-matériel (chap. 1) 1. Rôle d un pilote d unité-matériel 2. Division du Noyau 3. Classes d unités-matériel et de modules 2. Bâtir et exécuter des modules (chap. 2) 1. Module-Noyau versus Application-usager 1. Application-usager et Module-Noyau : Hello World 2. Concurrence dans le Noyau 3. Le processus courant 4. Quelques autres détails 2. Compiler et charger un module 3. La table des symboles du Noyau et le passage de paramètres 3. (chap. 3) 1. Un exemple simple : scull 2. Nombres majeur et mineur 3. Quelques structures de données importantes 4. Inscription d un pilote-caractère 5. Opérations d ouverture et de libération 6. Opérations de lecture et d écriture Réf. : Linux Device Drivers, 3 ième éd., J. Corbet, A. Rubin, G. Kroah-Hartman, O Reilly Media, chap.1-3. Cours # 3 ELE784 - Ordinateurs et programmation système 2 Cours # 3 ELE784 - Ordinateurs et programmation système 1
Introduction Pilote d unité-matériel - Le Noyau de Linux est un morceau de code complexe et imposant en taille. - Les pilotes d unités-matériel (device driver) fournissent une excellente entrée en matière à cette complexité pour les développeurs novices. - Vu de l extérieur du Noyau, ce sont des boites noires qui permettent d utiliser correctement des pièces d équipement, au travers d un interface de programmation bien défini. Espace-Usager Application usager Interface Appels-système standardisés Espace-Noyau Pilote d unité-matériel Ne connait pas Connait parfaitement Opérations spécifiques Pièce d équipement - Pour une application-usager, l interface de programmation fait voir le matériel comme si c était un fichier (ouvrir, lire, écrire, fermer, ). Cours # 3 ELE784 - Ordinateurs et programmation système 3 Introduction Pilote d unité-matériel 1.1 - Rôle d un pilote d unité-matériel - Un pilote doit être flexible en fournissant des mécanismes d utilisation plutôt que des politiques d utilisation. Ce qu on peut faire Ex. : - Ouvrir Comment on peut faire - Lire Ex. : - Ouvrir en lecture - Écrire - Lire un tableau - - Écrire des données formatées - - Ainsi, un pilote doit pouvoir supporter : Tout en n ayant pas de couches de code pour simplifier les choses ou pour fournir des opérations qui imposent des politiques d utilisation. - des opérations synchrones. - des opérations asynchrones - de multiples instances - les pleines capacités du matériel - Plusieurs pilotes peuvent donner accès à différentes fonctionnalités pour un même matériel. - Par contre, plusieurs pilotes sont accompagnés de librairies de fonctions, qui, elles, instaurent des politiques d utilisation. Cours # 3 ELE784 - Ordinateurs et programmation système 4 Cours # 3 ELE784 - Ordinateurs et programmation système 2
1.2 - Division du Noyau Introduction Pilote d unité-matériel - Même si la division n est pas toujours très claire, les tâches du Noyau de Linux peuvent être divisées dans les différents rôles suivants : Gestion de processus - créer / détruire les processus. - connexion entre les processus et le monde extérieur. - communication entre les processus. - Ordonnancement des processus. Système de fichiers - crée un système de fichiers structuré par-dessus un matériel non-structuré. - supporte différents types de systèmes de fichiers. Gestion de la mémoire - créer et gérer un espace d adressage virtuel pour tous et chacun. Contrôle d unités-matériel - fait le lien entre les opérations du système et les unités-matériel physiques. - exception faite du processeur, de la mémoire et quelles races autres. Réseautique - les opérations de réseau ne sont pas spécifiques à un processus. - en charge de livrer les paquets au travers des programmes et des interfaces de réseau. Cours # 3 ELE784 - Ordinateurs et programmation système 5 Vue plus détaillée du noyau Pour réaliser son rôle, le Noyau est composé d une série de modules chargeables dynamiquement. Réf. : Linux Device Drivers, 3 ième éd., J. Corbet, A. Rubin, G. Kroah-Hartman, O Reilly Media, page 6, fig. 1.1 Cours # 3 ELE784 - Ordinateurs et programmation système 6 Cours # 3 ELE784 - Ordinateurs et programmation système 3
Introduction Pilote d unité-matériel 1.3 - Classes d unités-matériel et de modules - Bien pas rigidement imposé, Linux distingue trois catégories fondamentales d unités-matériel et donc de modules : Unités-caractère : Le Char Driver - Unité qui peut traiter un flux de données. - Sont perçus comme des fichiers. - Le pilote implémente minimalement : - l ouverture (open) - la fermeture (close) - la lecture (read) - l écriture (write) - Par contre, l accès aux données est strictement séquentiel. Unités-bloc : Le Block Driver - Unité qui peut traiter des blocs de données. - Sont aussi perçus comme des fichiers. - Le pilote implémente minimalement : - l ouverture (open) - la fermeture (close) - la lecture (read) - l écriture (write) - L accès aux données est aussi strictement séquentiel. - Peut être l hôte d un système de fichiers. Unités-réseau : Le Network Interface - Unité / logiciel qui peut échanger des données avec d autres hôtes. - S occupe de transmettre et de recevoir des paquets de données. - Sont de type flux de données mais conçus autour de la notion de paquets. - Ne sont pas facilement associés à un système de fichiers. Cours # 3 ELE784 - Ordinateurs et programmation système 7 Introduction Pilote d unité-matériel 1.3 - Classes d unités-matériel et de modules - Cette classification est une vue simplifiée des modules du Noyau. - Plusieurs pilotes utilisent plus qu une couche de fonction-noyau de support et peuvent faire appel à plus qu un type d unité-matériel et/ou module. - Par exemple, l unité-matériel USB est géré par les modules USB qui fonctionnent avec un sous-système USB. - Mais l unité-matériel USB est vue par le système comme : - une unité-caractère (ex. : un port série USB) - une unité-bloc (ex. : un lecteur USB de carte mémoire) - une unité-réseau (ex. : un interface réseau USB) - Ainsi, les développeurs du Noyau ont mit à la disposition des développeurs de pilotes des ressources logiciels pour certaines classes d unités-matériel afin de simplifier et de renforcer la création de ces pilotes. - C est entre autre le cas pour les pilotes USB qui sont souvent perçus comme œuvrant sur plusieurs unités-matériel différentes. Cours # 3 ELE784 - Ordinateurs et programmation système 8 Cours # 3 ELE784 - Ordinateurs et programmation système 4
Bâtir et exécuter des modules 2.1 - Module-Noyau versus Application-usager Application-Usager - commence son exécution immédiatement. - peut des fois être pilotée par événements. - peut être paresseuse à restaurer le système. - est enchainée à des librairies contenants une large variété de fonctions. - inclus des fichiers d entête habituels du langage C. - les fautes sont sans conséquences et les outils de déverminage peuvent en faire la trace. Module-Noyau - s inscrit et attend des requêtes futurs. - est toujours piloté par événements. - lorsqu il se termine, il doit replacer le système comme il était avant. - est enchainé au Noyau et n utilise que des fonctions disponibles dans le Noyau. - ne peut pas inclure les fichiers d entêtes habituels. - les fautes tuent le processus courant et peuvent même tuer le système. Cours # 3 ELE784 - Ordinateurs et programmation système 9 2.1.1 - Application-usager et Module-Noyau : Hello World Librairies standards du C Fonction standardisée Bâtir et exécuter des modules Application-Usager : Hello World #include <stdlib.h> #include <stdio.h> int hello_init(void) { printf("hello, world\n"); return 0; peut dormir void hello_exit(void) { printf("goodbye, cruel world\n"); peut dormir Point d entrée Point de sortie int main(void) { hello_init (); hello_exit (); return 0; S exécute en une fois, mais peut dormir en cours de route. Cours # 3 ELE784 - Ordinateurs et programmation système 10 Cours # 3 ELE784 - Ordinateurs et programmation système 5
2.1.1 - Application-usager et Module-Noyau : Hello World Librairies spécifiques à Linux Bâtir et exécuter des modules Module-Noyau: Hello World #include <linux/init.h> #include <linux/module.h> MODULE_LICENSE("Dual BSD/GPL"); licence du module Fonction spécifique static int init hello_init(void) { printk(kern_warning "Hello, world\n"); return 0; peut dormir s exécute à l installation s exécute à la désinstallation Point d entrée static void exit hello_exit(void) { printk(kern_alert "Goodbye, cruel world\n"); ne dors pas module_init(hello_init); Point de sortie module_exit(hello_exit); Cours # 3 ELE784 - Ordinateurs et programmation système 11 Bâtir et exécuter des modules 2.1.2 - Concurrence dans le Noyau - Tandis que les applications-usager n ont pas habituellement à s inquiéter de la concurrence, les modules-noyau doivent en tenir compte et être capable de la gérer. - Les modules-noyau doivent être réentrants. 2.1.3 - Le processus courant - La plupart des actions du Noyau sont effectuées pour et au nom d un processus. - Le Noyau peut référer au processus courant par le pointeur global : current. - Lors de l exécution d un appel-système, current réfère au processus qui l a déclenché. 2.1.4 - Quelques autres détails - Les modules-noyau ont accès à une très petite pile (peut être aussi petite que 4 kbytes) qui est partagée par tout le Noyau. - Les fonctions du Noyau dont le nom commence par (double souligné) sont des composantes de bas niveau et doivent être utilisées avec précaution. - Le code-noyau ne peut pas faire d arithmétique à point flottant. Cours # 3 ELE784 - Ordinateurs et programmation système 12 Cours # 3 ELE784 - Ordinateurs et programmation système 6
Bâtir et exécuter des modules 2.2 - Compiler et charger un module Compilation : - D abord s assurer d avoir une version suffisamment récente du compilateur, des utilitaires de module et des autres outils requis. - Ensuite, il convient de créer un fichier Makefile pour le projet : archi-simple archi-simple pour plusieurs fichiers ou obj-m := hello.o suivit de la commande : obj-m := hello.o module-objs := file1.o file2.o ifneq ($(KERNELRELEASE),) obj-m := hello.o else KERNELDIR?= /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) default: $(MAKE) -C $(KERNELDIR) M=$(PWD) modules endif voir Documentation/Changes make -C ~/kernel-2.6 M=`pwd` modules suffisant pour compiler à partir de l arbre du Noyau. pour compiler dans ou à l extérieur de l arbre du Noyau. Cours # 3 ELE784 - Ordinateurs et programmation système 13 Bâtir et exécuter des modules 2.2 - Compiler et charger un module Charger le module : - Le chargement du module dans le Noyau est fait par la commande insmod tandis que sont déchargement est fait par rmmod. Par exemple : /sbin/insmod./hello.ko $* exit 1 charge le module Hello /sbin/rmmod hello $* exit 1 décharge le module Hello déclenche l exécution de : module_exit(hello_exit); déclenche l exécution de : module_init(hello_exit); - De plus, la commande modprobe permet aussi de charger le module dans le noyau, comme insmod. - Par contre, en plus modprobe vérifie si le module fait référence à des symboles qui ne sont pas définis dans le Noyau. - Si oui, alors la commande modprobe charge les autres modules qui déclarent ces symboles. Cours # 3 ELE784 - Ordinateurs et programmation système 14 Cours # 3 ELE784 - Ordinateurs et programmation système 7
Bâtir et exécuter des modules 2.3 - La table des symboles du Noyau et le passage de paramètres Table des symboles : - Puisque tout les modules-noyau font partie du même espace-noyau (partage le même espace-mémoire), un module-noyau peut rendre ses variables globales visible aux autres modules-noyau : EXPORT_SYMBOL(ma_var); rend la variable visible aux autres modules EXPORT_SYMBOL_GPL(ma_var); rend la variable visible aux autres Par exemple : modules qui satisfont la licence GPL #include <linux/init.h> GNU General Public License #include <linux/module.h> int ma_var; MODULE_LICENSE("Dual BSD/GPL"); EXPORT_SYMBOL_GPL(ma_var); static int init hello_init(void) { printk(kern_warning "Hello, world\n"); return 0; static void exit hello_exit(void) { printk(kern_alert "Goodbye, cruel world\n"); module_init(hello_init); module_exit(hello_exit); Cours # 3 ELE784 - Ordinateurs et programmation système 15 Bâtir et exécuter des modules 2.3 - La table des symboles du Noyau et le passage de paramètres Passage de paramètres : - Les modules ont souvent besoin de s adapter à des situations changeantes d un système à l autre. Ainsi, le Noyau permet de fournir des paramètres au module, lors de son chargement, en déclarant ces paramètres dans le module avec : MODULE_PARAM(nom, type, permission); voir les valeurs permises dans linux/stat.h bool short invbool uint charp ulong int ushort long variable interne du module qui sert pour recevoir le paramètre (doit avoir une valeur par défaut) #include <linux/init.h> #include <linux/module.h> #include <linux/moduleparam.h> int ma_var = 3; MODULE_LICENSE("Dual BSD/GPL"); EXPORT_SYMBOL_GPL(ma_var); MODULE_PARAM(ma_var, int, S_IRUGO); static int init hello_init(void) { printk(kern_warning "Hello, world\n"); return 0; static void exit hello_exit(void) { printk(kern_alert "Goodbye, cruel world\n"); module_init(hello_init); module_exit(hello_exit); Cours # 3 ELE784 - Ordinateurs et programmation système 16 Cours # 3 ELE784 - Ordinateurs et programmation système 8
À la base, un pilote est un module-noyau qui s attache à une unité-matériel et qui implémente certaines méthodes d accès à cette unité-matériel. 3.1 - Un exemple simple : scull - Nous allons développer un pilote-caractère, appelé scull, qui servira de base aux démonstrations. - Ce pilote n utilise pas une vrai unitématériel, mais utilise plutôt des blocs de mémoire comme si c était une unité-matériel. #include <linux/init.h> #include <linux/module.h> MODULE_AUTHOR("A. Rubini, J. Corbet"); MODULE_LICENSE("Dual BSD/GPL"); static exit void scull_cleanup_module(void) { printk(kern_warning "Scull cleanup\n"); static init int scull_init_module(void) { printk(kern_warning "Scull init\n"); module_init(scull_init_module); module_exit(scull_cleanup_module); Cours # 3 ELE784 - Ordinateurs et programmation système 17 3.2 - Nombres majeur et mineur - La 1 ière chose qu un pilote doit faire est d obtenir un numéro d unité-matériel : Majeur (12 bits) Mineur (20 bits) dev_t dev = 16 0 définit dans linux/types.h identifie le pilote identifie l unité-matériel - Ce numéro sert au Noyau pour identifier sans ambigüité le pilote et l unitématériel à laquelle il est rattaché. - Le Noyau fournit des macros qui permettent de gérer ce numéro : définit dans linux/kdev_t.h MAJOR (dev_t dev); MINOR (dev_t dev); MKDEV (int major, int minor); Permet d obtenir le MAJOR et le MINOR à partir du numéro. Permet de créer le numéro à partir d un MAJOR et d un MINOR connus. Cours # 3 ELE784 - Ordinateurs et programmation système 18 Cours # 3 ELE784 - Ordinateurs et programmation système 9
3.2 - Nombres majeur et mineur - La commande ls -l permet entre autre de voir le numéro attribué aux pilotes : ex. : ls l Major Minor crw-rw-rw- 1 root root 1, 3 Apr 11 2002 null crw------- 1 root root 10, 1 Apr 11 2002 psaux crw------- 1 root root 4, 1 Oct 28 03:04 tty1 crw-rw-rw- 1 root tty 4, 64 Apr 11 2002 ttys0 Allocation et désallocation d un numéro d unité-matériel : Allocation static : int register_chrdev_region (dev_t first, unsigned int count, char *name); définit dans linux/fs.h 1 er numéro Les deux ensembles forment une série de numéros consécutifs qui seront attribués au pilote lorsqu on connaît le numéro combien d unité-matériel Cours # 3 ELE784 - Ordinateurs et programmation système 19 nom du Pilote nom du pilote 3.2 - Nombres majeur et mineur Allocation et désallocation d un numéro d unité-matériel : Allocation dynamique : le 1 er numéro qui sera attribué lorsqu on ne connaît pas le numéro Méthode préférée le 1 er numéro d unitématériel désiré int alloc_chrdev_region (dev_t *dev, unsigned int firstminor, unsigned int count, char *name); combien d unité-matériel nom du pilote Désallocation : void unregister_chrdev_region (dev_t first, unsigned int count); 1 er numéro a désallouer combien d unité-matériel a désallouer Cours # 3 ELE784 - Ordinateurs et programmation système 20 Cours # 3 ELE784 - Ordinateurs et programmation système 10
3.2 - Nombres majeur et mineur Allocation et désallocation d un numéro d unité-matériel : - L allocation du numéro d unité-matériel se fait lors de l initialisation du pilote. - Et la désallocation est faite lors de la libération du pilote. Par exemple : #include <linux/init.h> #include <linux/module.h> #include <linux/fs.h> dans Scull MODULE_AUTHOR("A. Rubini, J. Corbet"); MODULE_LICENSE("Dual BSD/GPL"); int scull_major; int scull_minor = 0; int scull_nr_devs = SCULL_NR_DEVS; static exit void scull_cleanup_module(void) { dev_t devno = MKDEV(scull_major, scull_minor); unregister_chrdev_region(devno, scull_nr_devs); static init int scull_init_module(void) { int result; result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull"); scull_major = MAJOR(dev); if (result < 0) { printk(kern_warning "scull: can't get major %d\n", scull_major); return result; module_init(scull_init_module); module_exit(scull_cleanup_module); Cours # 3 ELE784 - Ordinateurs et programmation système 21 3.2 - Nombres majeur et mineur Allocation et désallocation d un numéro d unité-matériel : - Finalement, les nœuds des unités-matériel doivent être créés au chargement du pilote et détruit lors de son déchargement. - Par exemple, les scripts suivants charge le pilote et crée le nœud de l unité-matériel et décharge le pilote en détruisant le nœud pour Scull : #!/bin/sh module="scull" device="scull" mode="664" group="staff" /sbin/insmod./$module.ko $* exit 1 major=$(awk "\$2==\"$module\" {print \$1" /proc/devices) rm -f /dev/${device0 mknod /dev/${device0 c $major 0 chgrp $group /dev/${device0 chmod $mode /dev/${device0 #!/bin/sh Chargement Déchargement module="scull" device="scull" /sbin/rmmod $module $* exit 1 rm -f /dev/${device /dev/${device0 Cours # 3 ELE784 - Ordinateurs et programmation système 22 Cours # 3 ELE784 - Ordinateurs et programmation système 11
3.3 - Quelques structures de données importantes - L attribution d un unité-matériel n est que la toute 1 ière action d un pilote. - Le pilote a aussi besoin de se connecter à certaines structures de données du Noyau afin de devenir fonctionnel : Noyau struct file { struct file_operations *f_op; void *private_data; (linux/fs.h) struct scull_dev { struct cdev *cdev; (scull.h) Noyau struct cdev { struct module *owner; struct file_operations *ops; (linux/cdev.h) struct inode { struct file_operations *i_fop; struct inode_operations *i_op; struct cdev *i_cdev; dev_t i_rdev; struct file_operations { struct module *owner; (Pointeurs de fonctions) (linux/fs.h) struct inode_operations { (Pointeurs de fonctions) (linux/fs.h) Cours # 3 ELE784 - Ordinateurs et programmation (linux/fs.h) système 23 3.3 - Quelques structures de données importantes - N a rien à voir avec la structure FILE du langage C. - Représente un fichier ouvert pour le Noyau. - Créée par le Noyau à l ouverture (open) et détruit à la dernière fermeture (close). - Fournit en paramètre à toutes les fonctions (voir struct file_operations). - Connecte les opérations du pilote au numéro d unité-matériel. - C est une série de pointeurs de fonction. - Ces opérations sont principalement des appels-système. Ex. : - read ( ) - write ( ) - open ( ) - flush ( ) - Les fonctions inutilisées sont NULL. Noyau struct scull_dev { struct cdev *cdev; (scull.h) struct file { struct file_operations *f_op; void *private_data; (linux/fs.h) struct file_operations { struct module *owner; (Pointeurs de fonctions) (linux/fs.h) Cours # 3 ELE784 - Ordinateurs et programmation système 24 Cours # 3 ELE784 - Ordinateurs et programmation système 12
struct scull_dev { 3.3 - Quelques structures de données importantes struct cdev *cdev; (scull.h) Noyau Pointeur vers la structure de l unité-matériel Numéro d unité-matériel struct cdev { struct module *owner; struct file_operations *ops; (linux/cdev.h) struct inode { struct file_operations *i_fop; struct inode_operations *i_op; struct cdev *i_cdev; dev_t i_rdev; (linux/fs.h) - Utilisée par le Noyau pour représenter des fichiers en général. - Plusieurs (struct file) peuvent pointer vers un même fichier, mais une seul (struct inode) identifie ce fichier. struct file_operations { struct module *owner; (Pointeurs de fonctions) (linux/fs.h) struct inode_operations { (Pointeurs de fonctions) (linux/fs.h) - Contient des pointeurs de fonction vers des opérations générales sur les fichiers. Ex. : - create ( ) - mkdir ( ) - rename ( ) - permission ( ) - setattr ( ) Cours # 3 ELE784 - Ordinateurs et programmation système 25 3.4 - Inscription d un pilote-caractère - Le Noyau utilise la (struct cdev) pour représenter un pilote-caractère. - Pour que le Noyau puisse faire appel aux opérations du pilote, au moins une (struct cdev) doit être créée et inscrite dans le Noyau. - Créer une (struct cdev) signifie aussi d y attacher une (struct file_operations) qui fournit les pointeurs vers les fonctions du pilote pour cette unité-matériel. Déclaration d une (struct file_operations) : Exemple pour Scull Champs de la structure qui sont peuplés, les autres resterons à NULL. struct file_operations scull_fops = {.owner = THIS_MODULE,.llseek = scull_llseek,.read = scull_read,.write = scull_write,.ioctl = scull_ioctl,.open = scull_open,.release = scull_release, ; Représente le module auquel cette struct file_operations appartient. Fonctions qui font partie du module et qui fournissent les fonctionnalités du pilote. Cours # 3 ELE784 - Ordinateurs et programmation système 26 Cours # 3 ELE784 - Ordinateurs et programmation système 13
3.4 - Inscription d un pilote-caractère Allocation d une (struct cdev) : Méthode simple Déclare la struct cdev et l initialise. ou Autre Méthode Déclare la struct cdev à l intérieure d une structure "personnelle" et l initialise. struct cdev *my_cdev = cdev_alloc ( ); my_cdev->ops = &my_fops; struct scull_dev { struct scull_qset *data; int quantum; int qset; unsigned long size; unsigned int access_key; struct semaphore sem; struct cdev cdev; ; Déclaration et allocation Connecte les opérations du pilote. Ex. : Structure personnelle de Scull. Déclaration de la struct cdev Initialisation de la struct cdev void cdev_init (struct cdev *cdev, struct file_operations *fops); Cours # 3 ELE784 - Ordinateurs et programmation système 27 3.4 - Inscription d un pilote-caractère Inscription du Pilote : - Lorsque la (struct cdev) est créée et initialisée, il faut ensuite l inscrire dans le Noyau avec : int cdev_add (struct cdev *cdev, dev_t num, unsigned int count); La (struct cdev) Le nombre d unité-matériel Le numéro d unité-matériel ATTENTION : Dés que l inscription est faite, le pilote est ACTIF. Élimination du Pilote : - Lorsque le module est retiré du système (module_exit), le Pilote doit être retiré du Noyau : void cdev_del (struct cdev *cdev); La (struct cdev) Cours # 3 ELE784 - Ordinateurs et programmation système 28 Cours # 3 ELE784 - Ordinateurs et programmation système 14
3.4 - Inscription d un pilote-caractère int scull_init_module(void) { dev_t devno = MKDEV(scull_major, scull_minor); int err; if (scull_major) { devno = MKDEV(scull_major, scull_minor); result = register_chrdev_region(devno, 1, "scull"); else { result = alloc_chrdev_region(&devno, scull_minor, 1, "scull"); scull_major = MAJOR(devno); if (result < 0) { Exemple pour Scull printk(kern_warning "scull: can't get major %d\n", scull_major); return result; cdev_init(&dev->cdev, &scull_fops); Initialisation dev->cdev.owner = THIS_MODULE; du Pilote dev->cdev.ops = &scull_fops; err = cdev_add (&dev->cdev, devno, 1); if (err) du Pilote printk(kern_notice "Error %d adding scull%d", err, index); Inscription et démarrage Attribution du numéro d unitématériel Cours # 3 ELE784 - Ordinateurs et programmation système 29 3.5 - Opérations d ouverture et de libération Opération d ouverture : OPEN - L opération d ouverture sert à : - Vérifier les erreurs spécifiques de l unité-matériel. - Initialiser l unité-matériel lorsqu elle est ouverte pour la 1 ière fois. - Mettre à jour le pointeur vers la structure des fonctions (flip-> f_op). - Allouer et initialiser les données personnelles (flip->private_data). - Mais la 1 ière chose à faire est d identifier quelle unité-matériel est en train d être ouverte. Toutes les fonctions Certaines reçoivent ça aussi. Exemple Scull : reçoivent ça. Identifie l unité-matériel Initialisation personnelle" int scull_open (struct inode *inode, struct file *filp) { struct scull_dev *dev; dev = container_of (inode->i_cdev, struct scull_dev, cdev); filp->private_data = dev; if ( (filp->f_flags & O_ACCMODE) = = O_WRONLY) { scull_trim (dev); return 0; /* success */ Cours # 3 ELE784 - Ordinateurs et programmation système 30 voir struct file Cours # 3 ELE784 - Ordinateurs et programmation système 15
3.5 - Opérations d ouverture et de libération Opération de libération : RELEASE - L opération de libération sert à : - Libérer les données personnelles (flip->private_data). Toutes les fonctions - Arrêter le matériel à la dernière libération. reçoivent ça. Certaines reçoivent ça aussi. Exemple Scull-pipe : Capture sémaphore Crée une région critique Libère sémaphore static int scull_release (struct inode *inode, struct file *filp) { struct scull_pipe *dev = filp->private_data; scull_p_fasync(-1, filp, 0); down(&dev->sem); if (filp->f_mode & FMODE_READ) dev->nreaders--; if (filp->f_mode & FMODE_WRITE) dev->nwriters--; if (dev->nreaders + dev->nwriters == 0) { kfree(dev->buffer); dev->buffer = NULL; up(&dev->sem); return 0; Cours # 3 ELE784 - Ordinateurs et programmation système 31 3.6 - Opérations de lecture et d écriture - Les opérations de lecture et d écriture ont tous les deux pour but d échanger des données avec l espace-usager. - Tous les deux reçoivent : - Tous les deux retournent : - le pointeur de fichier flip (voir struct file). - un pointeur vers le tampon de l espace-usager avec lequel l échange sera fait. - le nombre de données à échanger. - un pointeur vers un décalage (offset) donnant la position des données à échanger. - un chiffre négatif si une erreur s est produite. - le nombre de bytes échangées avec succès, sinon. - Puisque l échange se fait avec l espace-usager, le pointeur vers cet espace doit toujours être considéré "suspect" : - peut ne pas être valide, directement accessible ou en mémoire-paginée. - puisque fournit par un programme-usager, peut être erroné ou malicieux. Cours # 3 ELE784 - Ordinateurs et programmation système 32 Cours # 3 ELE784 - Ordinateurs et programmation système 16
3.6 - Opérations de lecture et d écriture - Les échanges avec l espace-usager doivent absolument être fait de façon sécuritaire à l aide de fonctions spéciales fournies par le Noyau : Espace-Usager unsigned long copy_to_user (void user *to, const void *from, unsigned long count); Forme général : (destination, source, compte) unsigned long copy_from_user (void *to, const void user *from, unsigned long count); Version non-sécurisées : (ex. : à déjà été vérifié) copy_to_user copy_from_user DANGER Espace-Noyau - Les deux fonctions retournent le nombre de bytes n ayant pas été échangés. - Puisque le tampon de l espace-usager peut ne pas être disponible au moment de l échange, ces deux fonctions peuvent DORMIR. Cours # 3 ELE784 - Ordinateurs et programmation système 33 3.6 - Opérations de lecture et d écriture Opération de lecture : READ - Exemple simplifié de Scull Capture sémaphore Crée une région critique Libère sémaphore ssize_t scull_read(struct file *filp, char user *buf, size_t count, loff_t *f_pos) { struct scull_dev *dev = filp->private_data; Étiquette spéciale qui int *dptr = dev->quantum; identifie un espace-usager ssize_t retval = 0; if (down_interruptible(&dev->sem)) return -ERESTARTSYS; if (*f_pos >= dev->size) goto OUT; if (*f_pos + count > dev->size) count = dev->size - *f_pos; if (copy_to_user(buf, ((char *) dptr) + f_pos, count)) { retval = -EFAULT; goto OUT; *f_pos += count; retval = count; OUT: up(&dev->sem); return retval; Cours # 3 ELE784 - Ordinateurs et programmation système 34 Cours # 3 ELE784 - Ordinateurs et programmation système 17
Capture sémaphore Crée une région critique Libère sémaphore 3.6 - Opérations de lecture et d écriture Opération de écriture : WRITE - Exemple simplifié de Scull ssize_t scull_write(struct file *filp, const char user *buf, size_t count, loff_t *f_pos) { struct scull_dev *dev = filp->private_data; int *dptr = dev->quantum; ssize_t retval = -ENOMEM; if (down_interruptible(&dev->sem)) return -ERESTARTSYS; if (copy_from_user(((char *)dptr)+q_pos, buf, count)) { retval = -EFAULT; goto OUT; *f_pos += count; retval = count; if (dev->size < *f_pos) dev->size = *f_pos; OUT: up(&dev->sem); return retval; Étiquette spéciale qui identifie un espace-usager Cours # 3 ELE784 - Ordinateurs et programmation système 35 Cours # 3 ELE784 - Ordinateurs et programmation système 18