tp4

tp/tp4/README.md

@@ -0,0 +1,6 @@
+# Interruptions - Ordonnancement
+
+- partie 1 : [interruptions](interruptions.md)
+- partie 2 : [Ordonnamcement](ordonnancement.md)
+
+

tp/tp4/illegal.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+
+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;
+}
+

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 ?
+