Les exceptions sont des interruptions qui sont générées par le CPU quand certaines conditions sont detectées pendant l'éxecution d'un programme. Les exemples de ces conditions sont: utilisation d'un sélecteur invalide,utilisation d'un sélecteur pour lequel le programme a des privilèges insuffisants,utilisation d'un offset en dehors des limites d'un segment, éxecution d'un opcode illegal ,ou division par zéro. L'hôte DPMI distingue les exceptions et les interruptions externes matérielles ou logicielles.

Les gestionnaires d'exceptions peuvent seulement être installés avec l'Int 31H Fonctions 0203H, 0212H, ou 0213H. Si le client n'installe pas de gestionnaire pour une exception particulière, ou en installe un chainé à celui par défaut de l'hôte, l'hôte reflète l'exception comme une interruption en mode réel pour les exceptions 0,1,2,3,4,5, et 7. Le comportement par défaut des exceptions 6 et 8-1FH est de terminer le client (certains hôtes peuvent decider de fermer la VM car la faute vient du code en mode réel ou que l'état ne permet pas de terminer).

Fonction 0203Ha été definie dans DPMI version 0.9 et continue a être supportée dans DPMI version 1.0 pour des raisons de compatibilité. Les gestionnaires d'exceptions installés avec Fonction 0203H sont seulement appelés pour les exceptionsqui se produisent en mode protégé . Toutes exceptions sont examinées par l'hôte DPMI. L'hôte traite toute exception dont il est responsable ,comme les fautes de page dans la gestion de la mémoire virtuelle . Ces exceptions transparentes ne sont jamais transmises aux gestionnaires du client . Toutes les autres deviennent des exceptions visibles par le client et sont transmises au gestionnaire du client (s'il y en a un) par l'hôte DPMI. Le gestionnaire d'exception du client doit finir avec unFAR RETURN, les interruptions désactivées sur un pile verouillée, et avec SS, (E)SP, CS, et (E)IP poussés sur la pile au point d'exception . Tous les autres registres sont inchangés. Le cadre de pile pour les gestionnaires 16 bit installés avec la Fonction 0203H ont le format suivant:

	15		0
	+---------------+
	|	SS	|
	|---------------|  0EH
	|	SP	|
	|---------------|  0CH
	|     Flags	|
	|---------------|  0AH
	|	CS	|
	|---------------|  08H
	|	IP	|
	|---------------|  06H
        | Code d'erreur |
	|---------------|  04H
        |   Retour CS   |
	|---------------|  02H
        |   Retour IP   |
	|---------------|  00H <-- SS:SP
Le cadre de pile pour les gestionnaires 32 bit installé avec Fonction 0203H a le format suivant:
	31		15		0
	+---------------+---------------|
        |    Reservé    |       SS      |
	+---------------+---------------| 1CH
	|	       ESP		|
	|-------------------------------| 18H
	|	     EFLAGS		|
	|---------------+---------------| 14H
        |    Reservé    |       CS      |
	|---------------+---------------| 10H
	|	       EIP		|
	|-------------------------------| 0CH
        |          Code d'erreur        |
	|---------------+---------------| 08H
        |               |   Retour CS   |
	|---------------+---------------| 04H
        |          Retour EIP           |
	|-------------------------------| 00H <-- SS:ESP
Le code d'erreur dans le cadre de pile est valide seulement pour les exceptions suivantes:
08HDouble faute
0AHTSS Invalide
0BHSegment non présent
0CHFaute de pile
0DHFaute Generale de Protection
0EHFaute de Page
Dans le cas d'autres fautes et exceptions , la valeur du code d'erreur est indéfinie. Les champs Retour CS, Retour (E)IP, et Reservé dans le cadre de pile ne doivent pas être modifiés, tout le reste peut être modifié par le client avant la fin de l'éxecution du gestionnaire d'exception.

Le gestionnaire d'exception doit preserver et restaurer tous les registres, et doit aussi se brancher sur le gestionnaire suivant dans la chaine ou terminer avec une instructionRETF . Dans ce dernier cas, les SS:(E)SP, CS:(E)IP et les flags originaux sur la pile, inclus le flag d'interruption, seront restaurés.Le gestionnaire d'exception peut transférer le contrôle à une routine de gestion d'erreur plus générale à l'interieur de l'application en modifiant CS:(E)IP rangé dans la pile au dessus de (l'adresse de) Retour CS:(E)IP.

DPMI version 1.0 supporte un cadre de pile étendu pour les gestionnaires d'exception, et la capacité d'installer des gestionnaires séparés pour les exceptions qui se produisent en mode réel et protégé avecFonctions 0212H et 0213H. Le cadre étendu est defini sur la pile au dessus du cadre precédemment décrit pour les gestionnaires installés avec Fonction 0203H. Ceci permet au gestionnaires compatibles DPMI 0.9 et DPMI 1.0 de coexister dans la même chaine; les anciens gestionnaires ignoreront l'information additionnelle disponible au-dela de l'ancien cadre de pile,pendant que les nouveaux ignoreront l'ancien cadre et utiliseront le cadre étendu.

Le format du cadre de pile étendu pour les gestionnaires 16 et 32-bit installés avecFonctions 0212H et0213H est le suivant:

31				15				0
+---------------------------------------------------------------+ 58H
|				PTE				|
|---------------------------------------------------------------| 54H
|				CR2				|
|---------------------------------------------------------------| 50H
|       Reservé                 |               GS              |
|---------------------------------------------------------------| 4CH
|       Reservé                 |               FS              |
|---------------------------------------------------------------| 48H
|       Reservé                 |               DS              |
|---------------------------------------------------------------| 44H
|       Reservé                 |               ES              |
|---------------------------------------------------------------| 40H
|       Reservé                 |               SS              |
|---------------------------------------------------------------| 3CH
|				ESP				|
|---------------------------------------------------------------| 38H
|			      EFLAGS				|
|-------------------------------+-------------------------------| 34H
|bits d'information d'exception |               CS              |
|-------------------------------+-------------------------------| 30H
|				EIP				|
|-------------------------------+-------------------------------| 2CH
|                          Code d'Erreur                        |
|-------------------------------+-------------------------------| 28H
|       Reservé                 |    Retour CS (32-bit) or 0    |
|-------------------------------+-------------------------------| 24H
|       Retour EIP (32-bit) or CS:IP (16-bit)                   |
|-------------------------------+-------------------------------| 20H+SS:(E)SP
Une image de cadre de pile 32-bit est toujours presentée,même pour les gestionnaires 16-bit,et l'offset de SS:(E)SP pour le cadre étendu est toujours 20H (32) quelque soit le type du gestionnaire. Les registres DS,ES,FS, et GS sont préservés pour les modes réel et protégé. Le client peut inspecter les bits VM dans EFLAGS pour determiner le mode au point d'exception. Le champ CS à SS:(E)SP+24H est à zéro si le gestionnaire s'exécute en mode protégé 16-bit.

Les bits d'information d'exception à SS:(E)SP+32H ont le sens suivant:

Bit Signification
0 0 l'exception s'est produite dans le client
1 l'exception s'est produite dans l'hôte (principalement due à un faute de page ou selecteur invalide transmis à l'hôte pedant un appel à Int 31H)
1 0 l'exception peut être retentée
1 l'exception ne peut pas être retentée, le gestionnaire doit s'executer bien qu'un nettoyage soit possible
2 0 l'exception de l'hôte doit être retentée (selecteur invalide ou causant la faute de page corrigé par le gestionnaire)
1 l'exception de l'hôte est redirigée ailleurs que sur une adresse de réessai
3reservé

Les bits 0 à 2 des bits d'information d'exception relèvent des hôtes qui supportent la possibilité de Redémarrage des Exceptions (voir Int 31H Fonction 0401H). Les bits 0 et 1 sont fournis au client par l'hôte. L'état par défaut du bit 2 est mis à zero par l'hôte, et le client doit le mettre à 1 avant de clore le gestionnaire d'exception.

Les bits 0-14 du code d'erreur à SS:(E)SP+28H sont le DR6 "virtuel" pour l'exception de déboggage (Int 1), et corresponds aux points d'arrêt 0-14. En d'autres mots, si les bits 0 et 2 sont posés dans le champs du code d'erreur après une Int 1, alors les points d'arrêt 0 et 2 ont disparu. Le gestionnaire retourné par Définir un Point d'Inspection (Fonction 0B00H) corresponds au nombre de bits dans le DR6 "virtuel" . Le bit 15 du DR6 "virtuel" est posé (=1) si l'Int 1 est due au flag trap. Les points d'arrêt doivent être virtualisés et il n'y a pas de guarantie de correspondance avec le matériel actuel. La provision de 15 points d'arrêt est là pour les futurs CPUs ou des extensions matérielles (les 80386 et 80486 supportent seulement quatre points d'arrêt).

Les champs PTE et CR2 cadre de pile étendu à SS:(E)SP+50H et 54H respectivement sont seulement valides pour les fautes de page (Int 0EH). Les bits 0-7 de la PTE (page table entry=Table d'Entrée des Pages)proviennent de la PTE courante et doivent être virtualisés par l'hôte; les bits restants de la PTE sont indéfinis. Le champ CR2 contient l'addresse linéaire qui a provoqué la faute de page.

Les gestionnaires d'exception installésavec Fonctions 0212H et 0213H doivent se terminer d'une de ces trois façons:

Les champs de l'offset 2CH à 4FH dans le cadre de pile étendu peuvent être modifiés par un gestionnaire d'exception. Notez qu'il doit seulement modifier les valeurs dan le cadre particulier (SS:(E)SP)+0 ou SS:(E)SP+20H) qu'il utilisera pour le RETF. Les valeurs modifiées dans l'autre cadre sont ignoréesz par l'hôte DPMI . Les exceptions en mode réel n'ont pas de données valides dans l'ancien cadre. Un gestionnaire d'exception en mode réel doit abandonner l'ancien cadre de pile s'il retourne.

Exemple: Le code suivant illustre comment un client pourrait installer son propre gestionnaire d'exception pour les fautes generales de protection (GPF). Le gestionnaire courant ne fait rien de plus qu'atteindre le cadre de pile et modifier l'addresse de retour, donc le contrôle dans l'application redémarre à un point différent après la fin du gestionnaire.

prevgp  dd      0                       ; addresse du gestionnaire
                                        ; précédent

	.
        .                               ; ce code est executé pendant 
        .                               ; l'initialisation de l'application ...
        mov     ax,0210h                ; obtient l' addresse du precédent
        mov     bl,13                   ; propriétaire du vecteur  "GPF" 
	int	31h
        mov     word ptr prevgp,dx      ; sauve comme un pointeur far
	mov	word ptr prevgp+2,cx

        mov     ax,0212h                ; installe notre gestionnaire
	mov	bl,13
        mov     cx,cs                   ; CX:DX =  addresse du gestionnaire
	mov	dx,offset _TEXT:gpfisr
	int	31h
        jc      init9                   ; branchement, on ne peut s'installer
        .                               ; continue avec l'initialisation
	.
	.

gpfisr proc far                         ; c'est le gestionnaire actuel
                                        ; pour les GPF 
        add     sp,20h                  ; abandonne "l'ancien" cadre de pile
        push    bp                      ; pointe CS:IP dans le cadre de pile sur
        mov     bp,sp                   ; la routine de message d'erreur GPF  
	mov	word ptr [bp+0eh],offset _TEXT:	gpferr
	mov	word ptr [bp+12h],cs
	pop	bp
        ret                             ;  retour de l'exception
gpfisr endp

gpferr proc near                        ; cette routine s'executes après le
                                        ; retour de GPFISR à l'hôte DPMI 
	
        mov     ax,4c01h                ; termine le client DPMI avec
        int     21h                     ; code de retour =1

gpferr endp