Programmation système IFT-17584 Semaine 07 Programmation système @Pierre Marchand, 2001

Plan de la présentation Présentation du corrigé du travail pratique 1 Retour sur la semaine précédente Présentation du travail pratique 2 Codage des instructions Interruptions Exceptions Matière pour le premier examen @Pierre Marchand, 2001

Présentation du corrigé du TP 1 @Pierre Marchand, 2001

La semaine dernière Programmation SIMD Extension SIMD 2 Mode de fonctionnement du processeur Mémoire virtuelle Segmentation Pagination @Pierre Marchand, 2001

Présentation du TP 2 @Pierre Marchand, 2001

Format des instructions Mod R/M SIB = Scale-Index-Base Préfixes 0 à 4 Opcode 1 ou 2 Mode d’adressage SIB 0 ou 1 Déplacement 0, 1, 2 ou 4 Immédiat 0, 1, 2 ou 4 7 6 5 3 2 7 6 5 3 2 Mod Reg/ Opcode R/M Scale Index Base @Pierre Marchand, 2001

Préfixes Lock and repeat F0 = préfixe LOCK F2 = préfixe REPNE/REPNZ F3 = préfixe REPE/REPZ 0F = préfixe des nouvelles instructions (depuis le 386) telles que rdtsc, cmpxchg, cpuid, lmsw, lgdt, etc. @Pierre Marchand, 2001

Préfixes Préfixes Segment override 2E = préfixe CS segment override 36 = préfixe SS segment override 3E = préfixe DS segment override 64 = préfixe FS segment override 65 = préfixe GS segment override Normalement, une adresse mémoire a un segment par défaut : [BX], [DI], [SI] ont comme défaut DS [BP], [SP] ont comme défaut SS [IP] a comme défaut CS @Pierre Marchand, 2001

Préfixes Préfixes 67 = préfixe Address-size override 66 = préfixe Operand-size override 67 = préfixe Address-size override En mode protégé, le bit D du descripteur d’un segment exécutable détermine l’attribut par défaut pour la taille de l’adresse et la taille des opérandes : 0 = 16 bits, 1 = 32 bits. Les préfixes 66 et 67 permettent de déroger à cette valeur par défaut pour l’instruction qui les suit. @Pierre Marchand, 2001

Codage des instructions Opcode 1 ou 2 octets + 3 bits dans le champ Mod R/M ModR/M et SIB Le champ Mod se combine avec le champ R/M pour former 32 combinaisons possibles : 8 registres et 24 modes d’adressage. Le champ Reg/Opcode indique soit un numéro de registre soit trois bits supplémentaires de l’opcode. En mode 32 bits, on a pour le champ Reg : eax = 000 ecx = 001 edx = 010 ebx = 011 esp = 100 ebp = 101 esi = 110 edi = 111 @Pierre Marchand, 2001

Codage des instructions R/M Le champ R/M peut, soit spécifier un registre comme opérande, soit être combiné avec le champ Mod pour encoder un mode d’adressage. Pour coder une instruction, on utilise les tables de l’appendice B du volume 2 d’Intel. @Pierre Marchand, 2001

Codage des instructions Exemple mov eax, edx Selon la page B11 de l’appendice, il y a deux possibilités : Mov - Move Data register1 to register2 : 1000 100w : 11 reg1 reg2 32 bits : w = 1, reg1 = edx, reg2 = eax -> 11010000 Ce qui donne 89 D0. On a aussi : register2 to register 1: 1000 101w : 11 reg1 reg2 32 bits ; w = 1, reg1 = eax, reg2 = edx -> 11000010 Ce qui donne 8B C2. @Pierre Marchand, 2001

Codage des instructions Exemple mov eax, edx -> 89 D0 opcode = 89 (MOV r/m32, r32, p. 3-432) ModR/M = D0 (Mod 11: R/M = Reg, Reg = EDX, R/M = EAX, p. 2-5) 7 6 5 3 2 1 1 010 000 Mod Reg EDX R/M EAX @Pierre Marchand, 2001

Codage des instructions Exemple mov edx, eax -> 89 C2 opcode = 89 (MOV r/m32, r32, p. 3-432) ModR/M = C2 (Mod = 11: R/M = Reg, Reg = EAX, R/M = EDX, p. 2-6) 7 6 5 3 2 1 1 000 010 Mod Reg EAX R/M EDX @Pierre Marchand, 2001

Codage des instructions Exemple mov al, dl Selon la page B11 de l’appendice, il y a deux possibilités : Mov - Move Data register1 to register2 : 1000 100w : 11 reg1 reg2 8 bits : w = 0, reg1 = dl, reg2 = al -> 11010000 Ce qui donne 88 D0. On a aussi : register2 to register 1: 1000 101w : 11 reg1 reg2 8 bits ; w = 0, reg1 = al, reg2 = dl -> 11000010 Ce qui donne 8A C2. @Pierre Marchand, 2001

Codage des instructions Exemple mov ax, dx Comme nous sommes en mode 32 bits, il faut un préfixe de dérogation de taille d’opérande, 66h. Ensuite, selon la page B11 de l’appendice, il y a deux possibilités : Mov - Move Data register1 to register2 : 1000 100w : 11 reg1 reg2 16 bits : w = 1, reg1 = dx, reg2 = ax -> 11010000 Ce qui donne 66 89 D0. On a aussi : register2 to register 1: 1000 101w : 11 reg1 reg2 16 bits ; w = 1, reg1 = ax, reg2 = dx -> 11000010 Ce qui donne 66 8B C2. @Pierre Marchand, 2001

Codage des instructions Exemple mov eax, 0 -> B8 00 00 00 00 opcode = B8 (MOV r32, imm32, p. 3-432 ou B11) déplacement = 00 00 00 00 xor eax, eax -> 31 C0 opcode = 31 (XOR r/m32, r32, p. 3-790 ou B18) ModR/M = C0 (Mod = 11: R/M = Reg, Reg = EAX, R/M = EAX) 7 6 5 3 2 1 1 000 000 Mod Reg EAX R/M EAX @Pierre Marchand, 2001

Codage des instructions Exemple mov eax, [edi] -> 8B 07 opcode 8B (MOV r32, r/m32, p. 3-432). ModR/M = 07 (Mod = 00 : R/M = [Reg] ou [...][...], Reg = EAX, R/M = [EDI], p. 2-6) mov [edi], eax -> 89 07 opcode 89 (MOV r/m32, r32, p. 3-432) ModR/M = 07 comme ci-haut. 7 6 5 3 2 00 000 111 Mod Reg EAX R/M [EDI] @Pierre Marchand, 2001

Codage des instructions Exemple mov ax, [edi] -> 66 8B 07 mov al, [edi] -> 8A 07 @Pierre Marchand, 2001

Codage des instructions Exemple mov eax, [edx+ecx*4] -> 8B 04 8A opcode = 8B (MOV r32, r/m32, p. 3-432) ModR/M = 04 (Mod = 00: R/M = [Reg] ou [...][...], Reg = EAX, R/M = [...][...], p. 2-6) SIB = 8A (Scale = 4, Index = ECX, Base = EDX, p. 2-6) 7 6 5 3 2 00 000 100 Mod Reg EAX R/M [...][…] 7 6 5 3 2 10 001 010 Scale 4 Index ECX Base EDX @Pierre Marchand, 2001

Codage des instructions Exemple add al, [esi+ebx*4+8] -> 02 44 9E 08 opcode = 02 (ADD r8, r/m8, p. 3-21) ModR/M = 44 (Mod=01:[…]+d8, Reg = AL, R/M = [...][...] , p. 2-6) SIB = 9E (Scale = 4, Index = ECX, Base = esi) déplacement = 08 7 6 5 3 2 7 6 5 3 2 01 000 100 10 011 110 Mod Reg AL R/M [...][…] Scale 4 Index EBX Base ESI @Pierre Marchand, 2001

Codage des instructions Exemple mov eax, [edx+ecx*4] -> 8B 04 8A opcode = 8B (MOV r32,r/m32, p. 3-432) ModR/M = 04 (Mod = 00: R/M = [Reg] ou [...][...], Reg = EAX, R/M = [...][...], p. 2-6) SIB = 8A (Scale = 4, Index = ECX, Base = EDX, p. 2-6) 7 6 5 3 2 00 000 100 Mod Reg EAX R/M [...][…] 7 6 5 3 2 10 001 010 Scale 4 Index ECX Base EDX @Pierre Marchand, 2001

Codage des instructions Exemple add al, [esi+ebx*4+8] -> 02 44 9E 08 opcode = 02 (ADD r8, r/m8, p. 3-21 ou B6) ModR/M = 44 (Mod=01:[]+d8, Reg = AL, R/M = [...][...] , p. 2-5) SIB = 9E (Scale = 4, Index = ECX, Base = esi) déplacement = 08 7 6 5 3 2 7 6 5 3 2 01 000 100 10 011 110 Mod Reg AL R/M [...][…] Scale 4 Index EBX Base ESI @Pierre Marchand, 2001

Codage des instructions Exemple add [esi+ebx*4+0x12345678],0x100000000 opcode = 81 (ADD r/m32, imm32, p. 3-21 ou B6) ModR/M = 84 (Mod = 10: disp32[...][...]) SIB = 9E (Scale = 4, Base = ESI, Index = EBX) déplacement = 0x12345678 imm = 0x10000000 -> 81 84 9E 78 56 34 12 00 00 00 10 7 6 5 3 2 7 6 5 3 2 10 000 100 10 011 110 Mod Reg AL R/M [...][…] Scale 4 Index EBX Base ESI @Pierre Marchand, 2001

Codage des instructions Exemple rep movsb préfixe = F2 opcode = A4 jmp etiquette opcode = EB + offset signé de 8 bits par rapport à l’instruction suivante (EIP) opcode = E9 + offset signé de 32 bits par rapport à EIP @Pierre Marchand, 2001

Codage des instructions Virgule flottante Les instructions de virgule flottante commencent toutes par 11011 et sont toujours d’au moins 2 octets. Il y a 5 formats différents (Intel vol. 2, p. B-46). @Pierre Marchand, 2001

Décodage des instructions • Éliminer les préfixes • Est-ce l'opcode commence par 11011? Si oui, c'est de la virgule flottante. • Décoder opcode • Décoder ModR/M. Si c’est 100, il y aura un SIB. • Décoder le SIB s'il y a lieu. • Lire offset, puis opérande immédiat s'il y a lieu. @Pierre Marchand, 2001

Interruptions et exceptions Sortes d’interruptions Il y a deux types d’interruption. Les interruptions logicielles et les interruptions matérielles. Les interruptions matérielles sont provoquées par des signaux électriques appliqués sur des broches du processeur destinées à cet effet, par exemple IRQ ou RESET. Les interruptions logicielles peuvent être le résultat d’instructions spécifiques telles que int ou into, ou le résultat d’erreurs décelées par le processeur, par exemple la division par 0, une lecture dans une adresse où il n’y a pas de mémoire, une exception de virgule flottante. @Pierre Marchand, 2001

Interruptions et exceptions Sortes d’interruptions Le mot interruption est un terme qui définit une variété de transferts de contrôle dans le Pentium. Les items spécifiques impliquées par ce terme sont les véritables interruptions, et les exceptions, qu’on peut subdiviser en trappes, fautes et arrêts. Interruptions matérielles Les interruptions sont causées par le matériel extérieur au processeur. Des signaux sur les broches NMI et INTR du Pentium provoquent le déclenchement d’un traitement d’interruption. @Pierre Marchand, 2001

Interruptions et exceptions La ligne NMI provoque une interruption non masquable, qui ne peut être empêchée par logiciel. La ligne INTR provoque une interruption seulement si le bit IF du registre EFLAGS est 1. Si ce bit est 0, on dit que l’interruption est masquée. Lorsque le processeur répond à une telle interruption, il déclenche un cycle de reconnaissance d’interruption (interrupt acknowledge) et le périphérique interrupteur doit répondre par un numéro d’interruption compris entre 32 et 255. @Pierre Marchand, 2001

Interruptions et exceptions Le processeur réagit aux interruptions et aux exceptions essentiellement de la même façon. Quand une interruption ou une exception est signalée, le processeur arrête l’exécution du programme ou de la tâche en cours et passe à une procédure de traitement (ISR ou Interrupt Service Routine) spécifique pour l’interruption ou l’exception en cause. Le processeur accède à cette procédure de traitement via une entrée dans la table de descripteurs d’interruption (IDT). Quand la procédure de traitement a terminé son travail, le processeur retourne à l’exécution du programme interrompu. @Pierre Marchand, 2001

Interrupt Descriptor Table Registres d’adresses système Interrupt Descriptor Table Register IDTR (48 bits) 47 IDTR @Pierre Marchand, 2001

IDTR • La partie accessible de IDTR comporte 48 bits : • Le champ limit donne la taille de la table, tandis que le champ base donne son adresse. 47 15 base limit @Pierre Marchand, 2001

Interrupt Descriptor Table Interrupt Descriptor Table (IDT) La table de descripteurs d’interruptions contient les descripteurs qui pointent sur l’adresse de 32 à 256 routines de traitement d’interruption. Cette table ne peut contenir que des trap gates, des task gates et des interrupt gates. Elle doit avoir au moins 256 octets, pour pouvoir contenir des descripteurs pour les 32 interruptions réservées par Intel. Toute interruption utilisée par le système doit avoir une entrée dans la IDT. @Pierre Marchand, 2001

« Interrupt Gate » et « Trap Gate » 16 bits 1 2 5 3 5 Offset 31..16 P DPL 0D11? 000 Reserved Segment selector Offset 15..0 16 bits 16 bits @Pierre Marchand, 2001

Interruptions et exceptions 2. Lecture du vecteur (descripteur) IDT 3. Exécution de la Routine de traitement ISR 1.Interruption CODE 4. Retour au programme interrompu @Pierre Marchand, 2001

Interruptions et exceptions • Trappes Une trappe, aussi appelée interruption logicielle ou déroute-ment, est causée par une instruction spéciale telle que INT ou INTO. La procédure qui veut utiliser ces instructions doit avoir un niveau de privilège lui permettant d’accéder au descripteur d’interruption de la table IDT pour le numéro de trappe en question. Ainsi, si une application de niveau 3 veut exécuter INT 47, il faut que le descripteur à IDT(47) ait DPL=3. @Pierre Marchand, 2001

Interruptions et exceptions Fautes Une faute se produit quand le processeur détecte une erreur durant le traitement d’une instruction. Par exemple, division par 0, opcode invalide, etc. @Pierre Marchand, 2001

Interruptions et exceptions INT Interrupt Génère une interruption logicielle. Une constante de 8 bits (0-255) spécifie la procédure d’interruption à appeler. Ce nombre est un index dans la table IVT qui débute à l’offset 0 du segment 0. En mode réel, la IVT contient des pointeurs de 32 bits vers les procédures d’interruption. En mode privilégié, le processeur accède à la procédure au moyen d’un descripteur de 8 octets appelé Trap Gate dans la table des descripteurs d’interruption IDT. Les indicateurs IF et TF sont mis à 0, ce qui interdit les interruptions pendant l’exécution de la ISR. Exemple: INT 21h @Pierre Marchand, 2001

Interruption et appels système Nous verrons, après le premier examen, comment les systèmes d’exploitation utilisent cette instruction pour permettre aux application d’appeler des fonctions du noyau de manière sécuritaire. @Pierre Marchand, 2001

Interruptions et exceptions INTO Interrupt on Overflow Génère l’interruption logicielle no. 4 si l’indicateur OF est 1. En mode réel, l’entrée 4 de la IVT contient un pointeur de 32 bits vers la procédure de traitement de l’interruption INTO En mode privilégié, le processeur accède à la procédure au moyen d’un descripteur de 8 octets appelé Trap Gate dans la table des descripteurs d’interruption IDT. Exemple: INTO @Pierre Marchand, 2001

Interruptions et exceptions Sortes d’interruptions Normalement, les interruptions ne peuvent être traitées qu’au niveau du noyau (niveau de privilège 0). Il y a toutefois quelques mécanismes permettant de traiter les interruptions logicielles ou exceptions dans les langages de haut niveau au niveau application (niveau de privilège 3). @Pierre Marchand, 2001

Exceptions Macros standard pour Signal sous Windows SIGINT Signal d’interruption interactif (par exemple CTRL-C). SIGFPE Signal d’exception de virgule flottante. SIGILL Signal d’exception d’instruction illégale. SIGTERM Signal de terminaison. Termine le programme appelant en appelant la fonction exit( ). SIGABRT Signal d’arrêt. Appelé par la fonction abort( ). SIGSEGV Violation de segment. @Pierre Marchand, 2001

Exceptions Macros standard pour Signal sous Linux Il y en a au moins 26. Voici les principales : SIGINT Signal d’interruption interactif (par exemple CTRL-C). SIGFPE Signal d’exception de virgule flottante. SIGILL Signal d’exception d’instruction illégale. SIGTERM Signal de terminaison. Termine le programme appelant en appelant la fonction exit( ). Peut être capturé ou ignoré. SIGABRT Signal d’arrêt. Appelé par la fonction abort( ). SIGALRM Généré par l’appel système alarm() à l’expiration du délai programmé. SIGSEGV Violation de segment. SIGBUS Référence à une adresse mémoire invalide. SIGCHLD Avertit un processus qu’un fils vient de se terminer ou d’être stoppé. @Pierre Marchand, 2001

Exceptions Macros standard pour Signal sous Linux SIGIO SIGKILL Tue un processus. Ne peut être ni capturé ni ignoré. SIGPIPE Émis par le noyau quand un processus tente d’écrire dans un tube (pipe) qui n’a pas de lecteur. SIGQUIT Émis par le pilote de terminal lors de la réception de la touche CTRL-\. SIGSTOP (19) Ne peut être ni capturé ni ignoré. Le processus passe au mode stoppé. SIGCONT Redémarre un processus stoppé. SIGTRAP Émis par le noyau lorsque le processus a atteint un point d’arrêt. @Pierre Marchand, 2001

Exceptions Mécanisme sigaction Le gestionnaire reçoit plus d’information qu’avec le mécanisme signal. Il peut être de la forme : void gestionnaire (int numero, struct siginfo * info, void * inutile); Ce mécanisme offre une plus grande flexibilité de paramétrage grâce à l’utilisation de la structure sigaction lors de la mise en place de sigaction: int sigaction( int numero, const struct sigaction * nouvelle, struct sigaction * ancienne); @Pierre Marchand, 2001

Exceptions Mécanisme sigaction struct sigaction { void ( *sa_handler )( int ); // adresse du gestionnaire sigset_t sa_mask; // liste des signaux bloqués pendant // l’exécution du gestionnaire int sa_flags; // constantes permettant de configurer // le comportement du gestionnaire void ( *sa_restorer )( void ); // } ; @Pierre Marchand, 2001

Exceptions Mécanisme sigaction La structure siginfo : typedef struct siginfo { int si_signo; int si_errno int si_code union { int _pad[ SI_PAD_SIZE ]; struct { pid_t _pid; uid_t _uid } _kill; @Pierre Marchand, 2001

Exceptions Mécanisme sigaction La structure siginfo : struct { unsigned int _timer1; unsigned int _timer2; } _timer; pid_t _pid; // sender’s pid uid_t _uid; // sender’s uid sigval_t _sigval; } _rt; @Pierre Marchand, 2001

Exceptions Mécanisme sigaction La structure siginfo : struct { pid_t _pid; // which child uid_t _uid; // sender’s uid int _status; clock_t _utime; clock_t _stime; } _sigchld; @Pierre Marchand, 2001

Exceptions Mécanisme sigaction La structure siginfo : struct { void * _addr; } _sigfault; int _band; int _fd; } _sigpoll; } _sigfields; } siginfo_t; @Pierre Marchand, 2001

Matière pour le premier examen Semaine 01 Histoire de l’architecture IA-32 Architecture générale du Pentium 4 @Pierre Marchand, 2001

Matière pour le premier examen Semaine 02 Assembleur « inline » Masm32 Directives Programme mixte assembleur et C Directives spécifiques @Pierre Marchand, 2001

Matière pour le premier examen Semaine 03 Types de données Placement des données en mémoire Mode d’adressage Gestion de la piles Passage des arguments Variables locales « Stack frame » @Pierre Marchand, 2001

Matière pour le premier examen Semaine 04 Comparaisons Branchements Non conditionnel Conditionnel Structures de contrôles If For While Switch Instructions logiques Instructions arithmétiques @Pierre Marchand, 2001

Matière pour le premier examen Semaine 05 Programmation virgule flottante Programmation MMX @Pierre Marchand, 2001

Matière pour le premier examen Semaine 06 Programmation SIMD Extension SIMD2 Mémoire virtuelle Segmentation Pagination @Pierre Marchand, 2001

Matière pour le premier examen Semaine 07 Interruptions Exceptions @Pierre Marchand, 2001