Pilote de périphérique - Device driver

Cet article concerne les pilotes de périphérique pour le matériel. Pour les autres pilotes logiciels, voir Pilote (logiciel) .

En informatique , un pilote de périphérique est un programme informatique qui exploite ou contrôle un type particulier de périphérique connecté à un ordinateur ou à un automate . Un pilote fournit une interface logicielle aux périphériques matériels , permettant aux systèmes d'exploitation et autres programmes informatiques d'accéder aux fonctions matérielles sans avoir besoin de connaître des détails précis sur le matériel utilisé.

Un pilote communique avec le périphérique via le bus informatique ou le sous-système de communication auquel le matériel se connecte. Lorsqu'un programme appelant invoque une routine dans le pilote, le pilote envoie des commandes au périphérique. Une fois que le périphérique renvoie les données au pilote, celui-ci peut invoquer des routines dans le programme appelant d'origine.

Les pilotes dépendent du matériel et du système d'exploitation. Ils fournissent généralement la gestion des interruptions requise pour toute interface matérielle asynchrone dépendante du temps.

But

L'objectif principal des pilotes de périphérique est de fournir une abstraction en agissant comme un traducteur entre un périphérique matériel et les applications ou les systèmes d'exploitation qui l'utilisent. Les programmeurs peuvent écrire du code d'application de niveau supérieur indépendamment du matériel spécifique utilisé par l'utilisateur final. Par exemple, une application de haut niveau pour interagir avec un port série peut simplement avoir deux fonctions pour "envoyer des données" et "recevoir des données". À un niveau inférieur, un pilote de périphérique mettant en œuvre ces fonctions communiquerait avec le contrôleur de port série particulier installé sur l'ordinateur d'un utilisateur. Les commandes nécessaires pour contrôler un UART 16550 sont très différentes des commandes nécessaires pour contrôler un convertisseur de port série FTDI , mais chaque pilote de périphérique spécifique au matériel fait abstraction de ces détails dans la même interface logicielle (ou similaire).

Développement

L'écriture d'un pilote de périphérique nécessite une compréhension approfondie du fonctionnement du matériel et du logiciel pour une fonction de plate-forme donnée . Étant donné que les pilotes nécessitent un accès de bas niveau aux fonctions matérielles pour fonctionner, les pilotes fonctionnent généralement dans un environnement hautement privilégié et peuvent entraîner des problèmes de fonctionnement du système en cas de problème. En revanche, la plupart des logiciels de niveau utilisateur sur les systèmes d'exploitation modernes peuvent être arrêtés sans affecter considérablement le reste du système. Même les pilotes s'exécutant en mode utilisateur peuvent faire planter un système si le périphérique est programmé par erreur . Ces facteurs rendent plus difficile et dangereux le diagnostic des problèmes.

La tâche d'écrire des pilotes incombe donc généralement aux ingénieurs logiciels ou aux ingénieurs informaticiens qui travaillent pour des sociétés de développement de matériel. C'est parce qu'ils ont de meilleures informations que la plupart des étrangers sur la conception de leur matériel. De plus, il était traditionnellement considéré dans l' intérêt du fabricant de matériel de garantir que ses clients puissent utiliser leur matériel de manière optimale. En règle générale, le pilote de périphérique logique (LDD) est écrit par le fournisseur du système d'exploitation, tandis que le pilote de périphérique physique (PDD) est implémenté par le fournisseur du périphérique. Cependant, ces dernières années, des non-fournisseurs ont écrit de nombreux pilotes de périphériques pour des périphériques propriétaires, principalement destinés à être utilisés avec des systèmes d'exploitation libres et open source . Dans de tels cas, il est important que le fabricant du matériel fournisse des informations sur la façon dont l'appareil communique. Bien que ces informations puissent être apprises par ingénierie inverse , cela est beaucoup plus difficile avec le matériel qu'avec le logiciel.

Microsoft a tenté de réduire l'instabilité du système due à des pilotes de périphériques mal écrits en créant un nouveau cadre pour le développement de pilotes, appelé Windows Driver Framework (WDF). Cela inclut User-Mode Driver Framework (UMDF) qui encourage le développement de certains types de pilotes, principalement ceux qui implémentent un protocole basé sur des messages pour communiquer avec leurs appareils, en tant que pilotes en mode utilisateur. Si de tels pilotes fonctionnent mal, ils ne provoquent pas d'instabilité du système. Le modèle Kernel-Mode Driver Framework (KMDF) continue de permettre le développement de pilotes de périphériques en mode noyau, mais tente de fournir des implémentations standard de fonctions connues pour causer des problèmes, y compris l'annulation des opérations d'E/S, la gestion de l'alimentation et le branchement et prise en charge de l'appareil de lecture.

Apple dispose d'un framework open source pour développer des pilotes sur macOS , appelé I/O Kit.

Dans les environnements Linux , les programmeurs peuvent créer des pilotes de périphérique en tant que parties du noyau , séparément en tant que modules chargeables , ou en tant que pilotes en mode utilisateur (pour certains types de périphériques où des interfaces de noyau existent, comme pour les périphériques USB). Makedev inclut une liste des périphériques sous Linux, y compris ttyS (terminal), lp ( port parallèle ), hd (disque), boucle et son (ceux-ci incluent mixer , séquenceur , dsp et audio).

Les fichiers Microsoft Windows .sys et Linux .ko peuvent contenir des pilotes de périphérique chargeables. L'avantage des pilotes de périphériques chargeables est qu'ils ne peuvent être chargés que lorsque cela est nécessaire, puis déchargés, économisant ainsi la mémoire du noyau.

Mode noyau vs mode utilisateur

Les pilotes de périphérique, en particulier sur les plates- formes Microsoft Windows modernes , peuvent s'exécuter en mode noyau ( Ring 0 sur les processeurs x86 ) ou en mode utilisateur (Ring 3 sur les processeurs x86). Le principal avantage de l'exécution d'un pilote en mode utilisateur est une stabilité améliorée, car un pilote de périphérique en mode utilisateur mal écrit ne peut pas planter le système en écrasant la mémoire du noyau. D'un autre côté, les transitions utilisateur/mode noyau imposent généralement une surcharge de performances considérable, ce qui rend les pilotes en mode noyau préférés pour les réseaux à faible latence.

L'espace du noyau est accessible par le module utilisateur uniquement via l'utilisation d'appels système. Les programmes de l'utilisateur final comme le shell UNIX ou d'autres applications basées sur l'interface graphique font partie de l'espace utilisateur. Ces applications interagissent avec le matériel via des fonctions prises en charge par le noyau.

Applications

En raison de la diversité du matériel et des systèmes d'exploitation modernes, les pilotes fonctionnent dans de nombreux environnements différents. Les pilotes peuvent s'interfacer avec :

Les niveaux d'abstraction courants pour les pilotes de périphériques incluent :

  • Pour le matériel :
    • Interfaçage direct
    • Écriture ou lecture à partir d'un registre de contrôle de périphérique
    • Utilisation d'une interface de niveau supérieur (par exemple, BIOS vidéo )
    • Utilisation d'un autre pilote de périphérique de niveau inférieur (par exemple, des pilotes de système de fichiers utilisant des pilotes de disque)
    • Simuler le travail avec du matériel, tout en faisant quelque chose de complètement différent
  • Pour le logiciel :
    • Autoriser le système d'exploitation à accéder directement aux ressources matérielles
    • Implémenter uniquement des primitives
    • Implémentation d'une interface pour les logiciels non pilotes (par exemple TWAIN )
    • Implémentation d'un langage, parfois assez haut niveau (par exemple PostScript )

Ainsi, le choix et l'installation des pilotes de périphérique appropriés pour un matériel donné sont souvent un élément clé de la configuration du système informatique.

Pilotes de périphériques virtuels

Les pilotes de périphériques virtuels représentent une variante particulière des pilotes de périphériques. Ils sont utilisés pour émuler un périphérique matériel, en particulier dans des environnements de virtualisation , par exemple lorsqu'un programme DOS est exécuté sur un ordinateur Microsoft Windows ou lorsqu'un système d'exploitation invité est exécuté sur, par exemple, un hôte Xen . Au lieu de permettre au système d'exploitation invité de dialoguer avec le matériel, les pilotes de périphériques virtuels jouent le rôle inverse et émulent un élément matériel, de sorte que le système d'exploitation invité et ses pilotes exécutés dans une machine virtuelle puissent avoir l'illusion d'accéder au matériel réel. Les tentatives du système d'exploitation invité pour accéder au matériel sont acheminées vers le pilote de périphérique virtuel dans le système d'exploitation hôte comme, par exemple,  les appels de fonction . Le pilote de périphérique virtuel peut également envoyer des événements simulés au niveau du processeur, tels que des interruptions, dans la machine virtuelle.

Les périphériques virtuels peuvent également fonctionner dans un environnement non virtualisé. Par exemple, une carte réseau virtuelle est utilisée avec un réseau privé virtuel , tandis qu'un périphérique de disque virtuel est utilisé avec iSCSI . Un bon exemple de pilotes de périphériques virtuels peut être Daemon Tools .

Il existe plusieurs variantes de pilotes de périphériques virtuels, tels que les VxD , les VLM et les VDD.

Pilotes open source

Descriptions Solaris des pilotes de périphériques couramment utilisés :

  • fas : contrôleur SCSI rapide/large
  • hme : Ethernet rapide (10/100 Mbit/s)
  • isp : contrôleurs SCSI différentiels et la carte SunSwift
  • glm : (Gigabaud Link Module) contrôleurs UltraSCSI
  • scsi : périphériques SCSI (Small Computer Serial Interface)
  • sf : soc+ ou socal Fibre Channel Arbitrated Loop (FCAL)
  • soc : contrôleurs SPARC Storage Array (SSA) et périphérique de contrôle
  • socal : Contrôleurs optiques série pour FCAL (soc+)

Apis

Identifiants

Un périphérique sur le bus PCI ou USB est identifié par deux ID composés de 4 nombres hexadécimaux chacun. L'ID du fournisseur identifie le fournisseur de l'appareil. L'ID d'appareil identifie un appareil spécifique de ce fabricant/fournisseur.

Un périphérique PCI a souvent une paire d'ID pour la puce principale du périphérique, ainsi qu'une paire d'ID de sous-système qui identifie le fournisseur, qui peut être différent du fabricant de la puce.

Voir également

Les références

Liens externes