Les interruptions et leurs gestionnaires

Il existe en standard 16 interruptions matérielles : les IRQ, ou Interruption Request.

Les IRQ sont assignées au matériel : le processeur, la mémoire, les cartes d'extension, les périphériques, etc... Elle lui donne la possibilité d'interrompre le processeur lorsqu'il requiert un traitement immédiat. Par exemple, l'horloge système peut demander au processeur de mettre à jour l'heure, ou le clavier peut signifier l'appui sur une touche.

Etant en quantité limitée, les IRQ ont longtemps été la cause de conflits matériels, car une IRQ ne peut être partagée que sous des conditions très strictes, et la plupart du temps, un tel partage résulte en un plantage du système.

Les utilisateurs de Windows peuvent se faire une idée du l'utilisation de leurs IRQ en allant dans les Propriétés systèmes, puis en ouvrant le Gestionnaire de périphériques. Recherchez par exemple votre clavier dans la liste, puis choisissez Propriétés et regardez l'onglet Ressources.

Il est à noter que chaque interruption matérielle est associée à une interruption logicielle.

Il existe en tout 256 interruptions logicielles, dont 16 liées à une IRQ (voir tableau). Tout comme les interruptions matérielles, les interruptions logicielles permettent d'interrompre le processeur à tout moment pour requérir son attention.

Toutefois, les interruptions logicielles sont souvent utilisées pour les API (Application Programming Interface). Elles offrent un accès à un panel de routines effectuant diverses actions. On peut ainsi prendre l'exemple de l'API Dos, interruption 21h, ou bien de l'API Vidéo, interruption 10h.

Pour plus d'information sur les interruptions existantes, je vous renvoie à l'excellente librairie de Ralph Brown, la Ralph Brown's Interrupt List.

Tableau récapitulatif IRQ/Interruptions logicielles

Chaque interruption est liée à un gestionnaire d'interruption (ou vecteur d'interruption), un petit programme qui est exécuté à chaque fois qu'une interruption est déclenchée. De fait, on confond souvent l'interruption en elle-même et son gestionnaire associé. Toutes les adresses des gestionnaires d'interruption sont stockées au tout début de la mémoire de l'ordinateur, en 0000:0000 : c'est la table des vecteurs d'interruption.

Du fait de la capacité d'une interruption à interrompre le processeur à n'importe quel moment (on peut se rendre compte de la nécessité d'un tel comportement pour une défaillance matérielle, par exemple), un gestionnaire se doit de conserver le système dans le même état avant et après une interruption, et notamment de sauver le contenu des registres systèmes.

Autre nécessité pour un gestionnaire d'interruption : la capacité à appeler le gestionnaire précédent qu'il aurait remplacé. En effet, on ne peut savoir ce qui est "branché" sur une interruption, et de fait, il convient de conserver la chaîne des gestionnaires sans quoi on pourrait mettre en danger la stabilité du système. Ainsi, à moins de vouloir créer un nouveau gestionnaire, il faudra toujours conserver la liaison avec le gestionnaire remplacé.

Il faut enfin savoir que certaines interruptions peuvent être masquées, autrement dit désactivées si besoin est, en utilisant les ports 21h et A1h (voir la Ralph Brown's Interrupt List).

Veillez à ne toucher à aucun port que vous ne connaîtriez pas. Les ports sont en communication directe avec le système. Une mauvaise manipulation peut conduire à une défaillance matérielle.

Le Pascal, s'il ne permet d'accéder de manière directe à tous les éléments de votre PC, vous offre néanmoins la possibilité de le faire vous-même, en mettant quelques outils à votre disposition.

La plupart des compilateurs Pascal disposent de deux procédures pour faire appel à une interruption. Toutefois, la deuxième n'est qu'un cas particulier de la première, et nous verrons un peu plus loin comment la remplacer rapidement.

2-1-1. L'interruption Dos 21h▲

type
  Registers = record
    case Integer of
    0: (AX, BX, CX, DX, BP, SI, DI, DS, ES, Flags: Word);
    1: (AL, AH, BL, BH, CL, CH, DL, DH: Byte);
  end;

uses		
  Dos;

procedure MyGetDate(var Year, Month, Day, DayOfWeek: Word);
var
  Regs: Registers;
begin
  Regs.AH := $2A;   { On indique le numéro de la fonction }
  MsDos(Regs);      { On appelle l'interruption 21h }
  { Pour la fonction 2Ah, les résultats sont répartis comme suit : }
  {  CX: année (de 1980 à 2099)                                    }
  {  DH: mois                                                      }
  {  DL: jour                                                      }
  {  AL: jour de la semaine (0 correspond à Dimanche)              }
  with Regs do
  begin
    Year := CX;
    Month := DH;
    Day := DL;
    DayOfWeek := AL;
  end;
end;

2-1-2. Accéder à toutes les interruptions▲

uses
  Dos;

var 
  Regs: Registers;

begin			
  Regs.AH := $00;
  Regs.AL := $13;
  Intr($10, Regs);
  
  WriteLn('Test du mode 13h... Appuyer sur Entree');
  ReadLn;
  
  Regs.AH := $00;
  Regs.AL := $03;
  Intr($10, Regs);
end;

2-1-3. Remplacer la procédure MsDos▲

procedure MsDos(var Regs: Registers);
begin
  Intr($21, Regs);
end;

2-1-4. Les interruptions qui nécessitent une zone mémoire▲

DS:DX  Buffer

var
  Regs: Registers;
  Buffer: array[0..9] of Char;
  ...
begin
  ...
  Regs.DS := Seg(Buffer);
  Regs.DX := Ofs(Buffer);
  ...

var
  Buffer: record
    MaxCh: Byte;
    LastCh: Byte;
    ReadCh: array[1..255] of Char;
  end;

var
  Regs: Registers;
  P: Pointer;
  ...
begin
  ...
  GetMem(P, 1024);    { On alloue par exemple 1 Ko à P }
  ...
  Regs.DS := Seg(P^); { ATTENTION ! Il faut déréférencer le pointeur ! }
  Regs.DX := Ofs(P^);
  ...

Il est très courant d'avoir recourt à l'assembleur pour l'appel des interruptions. Il n'est pas prévu ici de faire un cours sur l'assembleur. Nous n'aborderons donc que les points les plus importants, principalement concernant la mise en place des registres.

Pour faire appel à une interruption, on se servira de l'opcode int suivie du numéro de l'interruption désirée :

asm
  ...
  int IntNo
  ...
end;

Certains éléments importants sont à prendre en compte lors de la modification des registres. Nous allons les voir point par point.

2-2-1. Les registres à sauver▲

asm
  ...
  push  bp
  mov   bp, ax
  ...
  pop   bp
  ...
end;

2-2-2. L'utilisation des buffers▲

var
  Buffer: array[0..9] of Byte;
  ...
 
begin
  ...
  asm
    ...
    mov  ax, ds
    mov  es, ax
    lea  di, Buffer
    ...
  end;
  ...
end.

procedure Exemple;
var
  Buffer: array[0..9] of Byte;
  ...
begin
  ...
  asm
    ...
    les  di, Buffer
    ...
  end;
  ...
end;

var
  Buffer: Pointer;
  ...
begin
  GetMem(Buffer, 1024);
  ...
  asm
    ...
    les  di, Buffer
    ...
  end;
  ...
  FreeMem(Buffer, 1024);
end;

type
  PtrRec = record
    Offset, Segment: Word;
  end;

asm
  ...
  mov  es, word ptr Buffer+2
  mov  di, word ptr Buffer
  ...
end;

2-2-3. Les opérateurs segment et ofs▲

var
  Buffer: array[0..9] of Byte;
  ...
begin
  ...
  asm
    ...
    mov  es, segment Buffer
    mov  di, ofs Buffer
    ...
  end;
  ...
end;

Pour une procédure, deux modes d'appel existent : le mode d'appel near, et le mode d'appel far. Si l'on se réfère à la FAQ, Appels far, appels near, qu'est-ce que cela signifie ?, il convient d'utiliser le mode d'appel far pour notre gestionnaire d'interruption, car il sera susceptible d'être appelé depuis n'importe quelle position de la mémoire.

De fait, notre procédure devra être placée entre les directives de compilation {$F+} et {$F-}.

Comme il a été dit plus haut, un gestionnaire d'interruption se doit de sauvegarder tous les registres systèmes pour les restaurer à la sortie. S'il est tout à fait possible de réaliser ceci par soit-même, autant laisser le Pascal le faire pour nous. Pour cela, il suffit d'ajouter la directive interrupt à notre procédure :

{$F+}
procedure IntVector; interrupt;
begin
				
end;
{$F-}

Néanmoins, comme on l'a vu, les gestionnaires d'interruption sont souvent utilisés pour gérer une API. Dès lors, il devient nécessaire de savoir à quelle fonction l'utilisateur souhaite faire appel, et quels sont les paramètres de cette fonction.

Pour cela, on se sert plus facilement des registres que de la pile. Il est donc nécessaire de pouvoir accéder aux registres systèmes sauvés lors de l'entrée dans le gestionnaire, et de pouvoir les modifier si le besoin s'en fait sentir, pour retourner un code d'erreur par exemple.

En fait, la syntaxe vue plus haut utilisant la directive interrupt est incomplète. En effet, le Pascal nous offre un accès direct aux registres en utilisant cette directive. Les registres devront alors être déclarés comme de simples paramètres de type Word, mais en respectant un ordre précis, et en prenant garde au fait que ceux-ci se comportent comme des paramètres passés par adresse, alors que leur déclaration ne le laisse pas apparaître. Ainsi, la moindre modification d'un paramètre registre entraînera une répercution sur sa valeur réelle.

L'ordre de déclaration est : Flags, CS, IP, AX, BX, CX, DX, SI, DI, DS, ES, BP. On obtient donc un gestionnaire qui a la forme suivante :

{$F+}
procedure IntVector(Flags, CS, IP, AX, BX, CX, DX, SI, DI, DS, ES, BP: Word); interrupt;
begin

end;
{$F-}

Les registres pourront être omis, mais devront tous figurer sitôt que vous désirez accéder à au moins un d'entre eux.

Les interruptions matérielles et logicielles ne se comportent pas de la même manière. En effet, les interruptions matérielles se doivent de signifier au système lorsqu'elles ont terminé leur traitement, et utilisent le registre Flags sur la pile.

3-3-1. La notification de fin de traitement▲

Port[$20] := $20;

ou

Port[$A0] := $20;
Port[$20] := $20;

3-3-2. Le registre Flags▲

if Assigned(AncienIRQ) then
begin
  asm
    pushf
  end;
  AncienIRQ;					
end;

3-3-3. Résumé▲

if Assigned(AncienIRQ) then
begin
  asm
    pushf
  end;
  AncienIRQ;					
end
else
begin
  {Port[$A0] := $20; si IRQ >= 8 }
  Port[$20] := $20;
end;

Les procédures nécessaires à la récupération ou la modification d'un vecteur d'interruption se situent dans l'unité Dos. On l'ajoutera donc dans notre clause uses.

program Test;

uses
  Dos;

...

4-1-1. Retrouver l'adresse d'un vecteur d'interruption▲

var
  IntVec: procedure;
  
begin
  GetIntVec($09, @IntVec); 
  ...

4-1-2. Remplacer un vecteur d'interruption▲

{$F+}
procedure IntVector; interrupt;
begin
  ...
end;					
{$F-}

begin
  SetIntVec($09, @IntVector);
  ...

Nous avons à présent réuni tous les éléments nécessaires pour la rédaction de notre gestionnaire d'interruption.

L'exemple suivant est totalement fonctionnel : il concerne la surcharge du gestionnaire d'interruption du clavier, interruption 9, correspondant à l'IRQ 1. Il s'agit donc d'une interruption matérielle, dont le PIC est situé sur le port $20.

program TestIntClavier;

uses
  Dos;
  
{ Pour sauver l'ancien gestionnaire }
var
  OldKbdInt: procedure;   
  
  
  
{$F+}
procedure KbdInt; interrupt;
begin
  { En rapport avec le clavier, hors de propos ici }
  WriteLn('Touche : ', Port[$60]);
  
  { Si un ancien gestionnaire existait... }
  if Assigned(OldKbdInt) then       
  begin
    { On place le registre de Flags sur la pile (int matérielle) }
    asm
      pushf
    end;
    { On appelle l'ancien gestionnaire }
    OldKbdInt;  
  end
  else
    { Sinon, on notifie la fin de l'interruption (int matérielle) }
    Port[$20] := $20;  
end;
{$F-}


begin
  { On récupère l'ancien gestionnaire pour l'int 9 }
  GetIntVec($09, @OldKbdInt);
  { On définit le nouveau gestionnaire }
  SetIntVec($09, @KbdInt);

  ReadLn;
  
  { On rétablit l'ancien gestionnaire à la fin du programme }
  SetIntVec($09, @OldKbdInt);
end.

Télécharger l'exemple

Remarque :

• On n'oubliera pas de restaurer l'ancien gestionnaire à la fin du programme, car sinon, l'interruption serait reliée à une procédure qui ne serait plus en mémoire : plantage assuré !