From d95de5f45ea35bbdea408436c944749184b35570 Mon Sep 17 00:00:00 2001 From: Denis Monnerat Date: Thu, 24 Sep 2026 13:21:22 +0200 Subject: [PATCH] tp4 --- tp/tp4/README.md | 6 ++ tp/tp4/illegal.c | 16 ++++ tp/tp4/interruptions.md | 207 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 229 insertions(+) create mode 100644 tp/tp4/README.md create mode 100644 tp/tp4/illegal.c create mode 100644 tp/tp4/interruptions.md diff --git a/tp/tp4/README.md b/tp/tp4/README.md new file mode 100644 index 0000000..73dfc25 --- /dev/null +++ b/tp/tp4/README.md @@ -0,0 +1,6 @@ +# Interruptions - Ordonnancement + +- partie 1 : [interruptions](interruptions.md) +- partie 2 : [Ordonnamcement](ordonnancement.md) + + diff --git a/tp/tp4/illegal.c b/tp/tp4/illegal.c new file mode 100644 index 0000000..378c5f6 --- /dev/null +++ b/tp/tp4/illegal.c @@ -0,0 +1,16 @@ +#include + +void (fonction) (void) +{ + asm volatile (".byte 255, 255, 255, 255"); +// asm volatile ("ud2"); +} + +int main(int argc, char * argv[]) +{ + fprintf(stderr, "J'execute la fonction avec le code invalide...\n"); + fonction(); + fprintf(stderr, "Et me voici de retour\n"); + return 0; +} + diff --git a/tp/tp4/interruptions.md b/tp/tp4/interruptions.md new file mode 100644 index 0000000..31c0b15 --- /dev/null +++ b/tp/tp4/interruptions.md @@ -0,0 +1,207 @@ +# Interruptions - Ordonnancement + +- partie 1 : [interruptions](interruptions.md) +- partie 2 : [Ordonnamcement](ordonnancement.md) + +#### Ex1 : +Linux fournit les compteurs d'interruptions dans : + +```bash +cat /proc/interrupts +``` + +Exécutez : + +```bash +cat /proc/interrupts +``` + +Vous devriez obtenir un tableau comportant notamment une colonne par CPU. + +Pour connaître le nombre de processeurs logiques : + +```bash +nproc +``` + +Vous pouvez également utiliser : + +```bash +lscpu +``` + +1. Combien de processeurs logiques possède votre machine ? +2. Combien de colonnes correspondant aux CPU observez-vous dans `/proc/interrupts` ? +3. À quoi correspond chaque ligne du tableau ? +4. Pourquoi les compteurs sont-ils différents selon les CPU ? + +#### Ex2 +Une interruption matérielle peut être générée lorsqu'un périphérique demande l'attention du processeur. +Sur un PC traditionnel, le clavier est associé à l'IRQ 1. +Recherchez les informations relatives au clavier : + +```bash +grep -i keyboard /proc/interrupts +``` + +Vous pouvez également rechercher le contrôleur `i8042` : + +```bash +grep i8042 /proc/interrupts +``` + +Sur de nombreuses machines, vous observerez une ligne semblable à : + +```text +1: ... IR-IO-APIC 1-edge i8042 +``` + +Le numéro `1` est le numéro d'IRQ. + +Le suffixe : + +```text +1-edge +``` + +indique que cette interruption est configurée en mode déclenché sur front (*edge-triggered*). + + +Dans un terminal, lancez : + +```bash +watch -n 1 'grep "^ *1:" /proc/interrupts' +``` + +Puis appuyez plusieurs fois sur des touches. + +1. Le compteur de l'IRQ 1 augmente-t-il lorsque vous utilisez le clavier ? +2. Sur quel CPU le compteur augmente-t-il ? +3. Pourquoi le clavier n'a-t-il pas besoin d'être interrogé en permanence par le processeur ? +4. Quelle différence faites-vous entre : + - une interruption ; + - une interrogation périodique (*polling*) ? + +#### Ex3 + +Linux permet de contrôler les processeurs auxquels une IRQ peut être distribuée. + +Pour l'IRQ 1 : + +```bash +cat /proc/irq/1/smp_affinity +``` + +Vous pouvez également utiliser : + +```bash +cat /proc/irq/1/effective_affinity +``` + +et : + +```bash +cat /proc/irq/1/effective_affinity_list +``` + +1. Quel est le masque d'affinité pour l'IRQ 1 sur votre machine ? +2. Quel(s) CPU(s) est(sont) séléctionné(s) pour la gérer ? +3. Y-a-t-il un interêt à la gérer toujours sur le même cpu ? + +#### Ex4 +Sur une machine multicœur, un processeur peut avoir besoin de demander une action à un autre processeur. + +Linux utilise alors des **IPI** (*Inter-Processor Interrupts*). + +Examinez : + +```bash +cat /proc/interrupts +``` + +Recherchez notamment les lignes : + +```text +LOC +RES +CAL +TLB +``` + +Les significations importantes sont : + +- `LOC` : interruptions du timer local ; +- `RES` : demandes de réordonnancement ; +- `CAL` : appels de fonctions entre CPU ; +- `TLB` : invalidations de TLB entre CPU. + + +##### `LOC` : timer local + +`LOC` correspond aux interruptions du timer local de chaque CPU. + +Elles permettent notamment au noyau d'effectuer certaines opérations liées : + +- à la gestion du temps ; +- à la comptabilisation du temps CPU ; +- à l'ordonnancement. + + +1. Pourquoi chaque CPU possède-t-il son propre compteur `LOC` ? + +--- + +##### `RES` : rescheduling + +Une ligne `RES` correspond à des demandes de réordonnancement transmises entre CPU. + +Par exemple, un CPU peut devoir signaler à un autre CPU qu'il doit réévaluer le processus actuellement exécuté. + + +1. Pourquoi un CPU peut-il avoir besoin de demander à un autre CPU de réévaluer son ordonnancement ? + + +##### `TLB` — TLB shootdown + +Le TLB (*Translation Lookaside Buffer*) contient des traductions récentes : + +```text +adresse virtuelle → adresse physique +``` + +Supposons qu'un CPU modifie les tables de pages d'un processus. + +Un autre CPU peut encore posséder dans son TLB une ancienne traduction. + +Linux doit alors demander à ce CPU d'invalider l'entrée correspondante. + +Il peut utiliser une IPI. + +Le mécanisme est souvent appelé : + +> **TLB shootdown** + + +1. Pourquoi une modification des tables de pages peut-elle nécessiter une action sur un autre CPU ? +2. Pourquoi le TLB doit-il être invalidé ? +3. Une IPI TLB provient-elle d'un périphérique matériel externe ? + +#### Ex4 + +Pour déclencher l’exception `Illegal instruction` , il faut exécuter du code +invalide pour le processeur employé. C’est difficile avec les architectures +actuelles car les pages de code sont verrouillées en lecture seule (donc +impossible de modifier des fonctions existantes) et les pages de données ne sont +pas exécutables (donc impossible d’y dérouter l’exécution). + +La solution consiste à générer un code assembleur invalide et à l’insérer +manuellement dans un programme C, comme c’est fait dans le fichier +illegal.c (les instructions sont invalides pour un processeur x86, il +faudra peut-être changer les valeurs si on le teste sur une autre architecture). + +1. Observez l'effet avec + ``bash + strace ./illegal + ``` + Comment l'exception s'est traduite au niveau du processus fautif ? +