Module

Les devices sont gérés par différents modules. Lorsqu'on tape ls, on peut voir des numéros séparés par une virgule. Le premier indique le numéro majeur, le module qui gère le device. Le second indique le numéro mineur, un numéro identifiant le device pour le module.

ls -l --time-style=+"" /dev/input/mouse* /dev/sda

crw-rw---- 1 root input 13, 32  /dev/input/mouse0
crw-rw---- 1 root input 13, 33  /dev/input/mouse1
crw-rw---- 1 root input 13, 34  /dev/input/mouse2
brw-rw---- 1 root disk   8,  0  /dev/sda

Un numéro majeur peut être partagé entre plusieurs modules.

Il est possible de lister tous les devices et leur numéro majeur dans le fichier /proc/devices.

Pour créer un numéro, il faut utiliser la macro MKDEV() qui prend un numéro majeur et mineur. Elle génère un type dev_t. Il est possible de récupérer ces numéros avec les macros MAJOR() et MINOR().

void test_mkdev(void)
{
  dev_t dev = MKDEV(245, 0);
  pr_info("Major: %d\nMinor: %d\n", MAJOR(dev), MINOR(dev));
}

Il est possible de les créer avec la commande mknod. Il suffit de mettre le numéro majeur réservé par le module ainsi qu'un numéro mineur compris dans la plage réservée. Il faut le supprimer avec la commande rm après avoir déchargé le module.

Pour pouvoir interagir avec un fichier device, il faut mettre en place une structure file_operations avec des méthodes de lecture et d'écriture. Cette structure possède beaucoup de champs, chacun avec comportement différent si on le met à NULL. Un exemple ci-dessous montre juste les champs de lecture et d'écriture mais pas d'ouverture ou de verouillage.

Pour pouvoir interagir avec le userspace, la fonction put_user permet d'envoyer un caractère à l'utilisateur et copy_from_user un tampon (cf. fichier source indiqué dans le lien). Les fonctions copy_ retournent le nombre de bytes restant à transférer. Il s'agit là d'une erreur, 0 indique le succès de l'opération.

static ssize_t my_read(struct file *, char __user *buffer, size_t count,
                       loff_t *offset)
{
  /* lecture du fichier par l'utilisateur */
}

static ssize_t my_write(struct file *, char __user *buffer, size_t count,
                       loff_t *offset)
{
  /* écriture dans le fichier */
}

static const struct file_operations fops = {
  .owner = THIS_MODULE,
  .read = my_read,
  .write = my_write,
};

static struct cdev *my_cdev;

static int __init my_init(void)
{
  my_cdev = cdev_alloc();
  my_cdev->ops = &fops;
  my_cdev->owner = THIS_MODULE;
}

Ces fonctions peuvent être appelées en boucle ! Selon la valeur de retour, le programme essayant de lire ou d'écrire peut réessayer l'opération. Il est possible de jouer avec count et offset pour vérifier si on essaie de lire/écrire plus qu'il ne faut et retourner 0 dans ce cas.

Les erreurs les plus communes à retourner sont :

-EINVAL

-EFAULT

mauvaise adresse, à utiliser quand une fonction copy_ échoue

Les pages 63 à 69 du Linux Device Drivers (chapitre 3) sont très intéressantes sur le fonctionnement de ces fonctions.

• Linux Device Drivers; chap. 3: Char Drivers
• Linux Kernel Labs - Character device drivers
• The Linux Kernel Module Programming Guide; 5.6 et 6
• Linux Device Driver Tutorials (4, 5, 32)
• Misc char devices (Nihaal)

Les kobject sont des obets noyaux génériques. Ils sont derrière beaucoup de choses dans le noyau, comme le /sys ou les devices par exemple. Ils ont un nom, des attributs et parfois un parent.

Les kset sont des ensembles de kobject tout en étant eux-même un kobject.

Il est possible de mettre les kobject dans le dossier /sys, un dossier sera alors créé.

Le kobject enregistre le nombre d'utilisation, un peu comme un sémaphore. Il faut qu'il ne soit plus du tout utilisé pour pouvoir le supprimer.

Conseil : il faut bien lire la documentation et les exemples pour comprendre comment développer les kobject. Ce n'est pas écrit explicitement dans le livre et les articles LWN comment faire.

Un kobject représente un dossier. Un attribute représente un fichier.

Pour pouvoir créer un dossier, il faut en premier créer et initialisier un kobject puis l'ajouter dans le système de fichiers. Il faut ensuite le retirer lorsqu'on souhaite le supprimer du dossier. Il existe plusieurs façons de faire ça :

• tout faire à la main (kobject_add())
• l'initialiser et l'ajouter en même temps (kobject_init_and_add())
• utiliser directement une fonction pour tout faire à notre place (kobject_create_and_add())

Pour créer un fichier, il faut ajouter un attribut. Il est lié à un kobject, le dossier où il se trouve. On peut ajouter ensuite le fichier dans le système de fichiers sys avec sysfs_create_file(), elle retourne 0 si l'opération s'est bien déroulée. sysfs_remove_file() permet de retirer le fichier.

Pour pouvoir gérer les opérations de lecture et d'écriture, il faut ajouter des fonctions dans une structure sysfs_ops :

• ssize_t show(struct kobject *kobj, struct attribute *attr, char *buffer)
• ssize_t store(struct kobject *kobj, struct attribute *attr, const char *buffer, size_t len)

Si on a plusieurs attribute, il est possible de vérifier leur nom avec attr->name et faire un appel à la bonne fonction.

Il faut utiliser la fonction sysfs_emit() pour pouvoir copier des informations dans le tampon de l'espace utilisateur, dans la partie show().

Exemple :

static struct kobject foo;

static struct attribute bar = {
  .name = "bar",
  .mode = 0666
};

ssize_t show(struct kobject *kobj, struct attribute *attr, char *buffer)
{
  return sysfs_emit(buffer, "foo bar");
}

ssize_t store(struct kobject *kobj, struct attribute *attr, const char *buffer,
              size_t len)
{
  ssize_t ret = 0;

  if (!strcmp(buffer, "foo"))
    ret = size;

  return ret;
}

static const struct sysfs_ops my_ops = {
  .show = &show,
  .store = &store,
};

static const struct kobj_type my_type = {
  .sysfs_ops = &my_ops,
};

static int __init my_init(void)
{
  if (!memset(&foo, 0, sizeof(struct kobject)))
    return -ENOMEM;

  kobject_init(&foo, NULL);
  if (kobject_init_and_add(&foo, &my_type, NULL, "foo")) {
    kobject_put(&foo);
    return -EINVAL;
  }

  if (sysfs_create_file(&foo, &bar) {
      kobject_put(&foo);
      return -ENOMEM;
   }

  return 0;
}

static void __exit my_exit(void)
{
  kobject_put(&foo);
  sysfs_remove_file(&foo, &bar);
}

file:///usr/src/linux/Documentation/output/filesystems/sysfs.html

Quelques articles de LWN qui sont très intéressants mais pas à jour, par exemple pour la fonction kobject_set_name.

• The zen of kobjects (LWN)
• kobjects and sysfs (LWN)
• Everything you never wanted to know about kobjects, ksets, and ktypes (Documentation noyau)
• Exemples pour kobject et kset (noyau)
• Linux Device Drivers; chap. 14: The Linux Device Model, Kobjects, Ksets, and Subsystems et Low-Level Sysfs Operations

Documentation noyau et Chapitre 5 de Linux Device Drivers.

Linked Lists du chapitre 11 de Linux Device Drivers (Data Types in the Kernel) explique très bien comment utiliser les listes chaînées du noyau.

Pour faire une liste chaînée d'une structure, il faut lui ajouter un attribut de type struct list_head. On peut le nommer comme l'on veut. Il faut aussi créer la tête de la liste, en déclarant une structure list_head que l'on initialise avec INIT_LIST_HEAD() et un pointeur vers la structure.

Cette structure contient un pointeur vers l'élement suivant (next) et l'élément précédent (pred).

Il existe plusieurs fonctions pour rajouter un élément (en tête, à la fin), en supprimer un, le déplacer (cf. la doc.)… Il faut toujours donner la structure list_head se trouvant dans la structure. Il est possible de récupérer un élément de la liste avec la macro list_entry. Elle prend en paramètre la tête, la structure qui la contient et le nom du champ contenant la list_head de cette structure : list_entry(my_head, my_struct, list).