Changes between Version 4 and Version 5 of AS6-TME-B1

Timestamp:

Feb 8, 2022, 12:32:04 PM (2 years ago)

Author:

franck

Comment:

--

AS6-TME-B1

@@ -651 +651 @@
  - placer cette adresse dans un registre, par exemple `$2`;
  - exécuter l'instruction `jal` (ici, `jal $2`) pour appeler la fonction.
-
  Que doivent contenir les registres `$4` à `$7` et comment doit-être la pile?
 {{{#!protected ------------------------------------------------------------------------------------
@@ -721 +720 @@
 ''''''''''''''' 
 }}}
-1. Dans la question **A2.5**, nous avons vu comment la fonction `kinit()` appelle la fonction `__start()` grâce à un bout de code en assembleur placé au début de la section `.text`. Nous allons voir maintenant quelles sont les conditions de cet appel. Dans le code de la question **A2.5**, `$26` est un registre de travail pour le kernel. Quels sont les autres registres modifiés? Expliquez pour chacun la valeur affectée.
+1. Dans la question **A6.5**, nous avons vu comment la fonction `kinit()` appelle la fonction `__start()` grâce à un bout de code en assembleur placé au début de la section `.text`. Nous allons voir maintenant quelles sont les conditions de cet appel. Dans le code de la question **A6.5**, `$26` est un registre de travail pour le kernel. Quels sont les autres registres modifiés? Expliquez pour chacun la valeur affectée.
 {{{#!protected ------------------------------------------------------------------------------------
 '''''''''''''''
@@ -771 +770 @@
 '''''''''''''''
 }}}
-1. Le gestionnaire de `syscall` est la partie du code qui gère le comportement du noyau lors de l'exécution de l'instruction `syscall`. C'est un code en assembleur présent dans le fichier `kernel/hcpu.S` que nous allons observer. Pour vous aider dans la compréhension de ce code, vous devez imaginer que l'instruction `syscall` est un peu comme un appel de fonction. Ce code utilise un tableau de pointeurs de fonctions nommé `syscall_vector` définit dans le fichier `kernel/ksyscalls.c`. Les lignes `36` à `43` sont chargées d'allouer de la place dans la pile.\\Dessinez l'état de la pile après l'exécution de ces instructions. Que fait l'instruction ligne `44` et quelle conséquence cela a-t-il? Que font les lignes `46` à `51`? Et enfin que font les lignes `53` à `59` sans détailler ligne à ligne.\\ \\**`common/syscalls.h`**
-{{{#!c
-  1 #define SYSCALL_EXIT        0
-  2 #define SYSCALL_TTY_WRITE   1
-  3 #define SYSCALL_TTY_READ    2
-  4 #define SYSCALL_CLOCK       3
-  5 #define SYSCALL_NR          32
+1. Le gestionnaire de `syscall` est la partie du code qui gère le comportement du noyau lors de l'exécution de l'instruction `syscall`. C'est un code en assembleur présent dans le fichier `kernel/hcpu.S` que nous allons observer. Pour vous aider dans la compréhension de ce code, vous devez imaginer que l'instruction `syscall` est un peu comme un appel de fonction. Ce code utilise un tableau de pointeurs de fonctions nommé `syscall_vector` définit dans le fichier `kernel/ksyscalls.c`. Les lignes `47` à `54` sont chargées d'allouer de la place dans la pile.\\- Dessinez l'état de la pile après l'exécution de ces instructions.\\- Que fait l'instruction ligne `55` et quelle conséquence cela a-t-il?\\- Que font les lignes `57` à `62`?\\- Et enfin que font les lignes `64` à `70` ?\\Les commentaires ont été laissés, vous devez juste mettre à quoi ça sert, sans détailler ligne à ligne.\\ \\**`common/syscalls.h`**
+{{{#!c
+#define SYSCALL_EXIT        0       /* see exit()   in ulib/libc.c */
+#define SYSCALL_READ        1       /* see read()   in ulib/libc.c */
+#define SYSCALL_WRITE       2       /* see write()  in ulib/libc.c */
+#define SYSCALL_CLOCK       3       /* see clock()  in ulib/libc.c */
+#define SYSCALL_NR          32
 }}}
   **`kernel/ksyscalls.c`**
 {{{#!c
 void *syscall_vector[] = {
-    [0 ... SYSCALL_NR - 1] = unknown_syscall,
-    [SYSCALL_EXIT]      = exit,
-    [SYSCALL_TTY_READ]  = tty_read,
-    [SYSCALL_TTY_WRITE] = tty_write,
-    [SYSCALL_CLOCK]     = clock,
+    [0 ... SYSCALL_NR - 1] = unknown_syscall,   /* default function */
+    [SYSCALL_EXIT        ] = exit,
+    [SYSCALL_READ        ] = tty_read,
+    [SYSCALL_WRITE       ] = tty_write,
+    [SYSCALL_CLOCK       ] = clock,
 };
 }}}
   **`kernel/hcpu.S`**
-{{{#!xml
- 34 ksyscall:
- 35 
- 36     addiu   $29,    $29,    -8*4            
- 37     mfc0    $27,    $14                     
- 38     mfc0    $26,    $12                     
- 39     addiu   $27,    $27,    4               
- 40     sw      $31,    7*4($29)                
- 41     sw      $27,    6*4($29)                
- 42     sw      $26,    5*4($29)                
- 43     sw      $2,     4*4($29)                
- 44     mtc0    $0,     $12                     
- 45 
- 46     la      $26,    syscall_vector          
- 47     andi    $2,     $2,     SYSCALL_NR-1    
- 48     sll     $2,     $2,     2               
- 49     addu    $2,     $26,    $2              
- 50     lw      $2,     0($2)                    
- 51     jalr    $2                              
- 52 
- 53     lw      $26,    5*4($29)                
- 54     lw      $27,    6*4($29)                
- 55     lw      $31,    7*4($29)                
- 56     mtc0    $26,    $12                     
- 57     mtc0    $27,    $14                     
- 58     addiu   $29,    $29,    8*4             
- 59     eret                       
+{{{#!asm
+ 45 syscall_handler:
+ 46 
+ 47     addiu   $29,    $29,    -8*4        // context for $31 + EPC + SR + syscall_code + 4 args
+ 48     mfc0    $27,    $14                 // $27 <- EPC (addr of syscall instruction)
+ 49     mfc0    $26,    $12                 // $26 <- SR (status register)
+ 50     addiu   $27,    $27,    4           // $27 <- EPC+4 (return address)
+ 51     sw      $31,    7*4($29)            // save $31 because it will be erased
+ 52     sw      $27,    6*4($29)            // save EPC+4 (return address of syscall)
+ 53     sw      $26,    5*4($29)            // save SR (status register)
+ 54     sw      $2,     4*4($29)            // save syscall code (useful for debug message)
+ 55     mtc0    $0,     $12                 // SR <- kernel-mode without INT (UM=0 ERL=0 EXL=0 IE=0)
+ 56 
+ 57     la      $26,    syscall_vector      // $26 <- table of syscall functions
+ 58     andi    $2,     $2,     SYSCALL_NR-1// apply syscall mask
+ 59     sll     $2,     $2,     2           // compute syscall index (mutiply by 4)
+ 60     addu    $2,     $26,    $2          // $2 <- & syscall_vector[$2]
+ 61     lw      $2,     ($2)                // at the end: $2 <- syscall_vector[$2]
+ 62     jalr    $2                          // call service function
+ 63 
+ 64     lw      $26,    5*4($29)            // get old SR
+ 65     lw      $27,    6*4($29)            // get return address of syscall
+ 66     lw      $31,    7*4($29)            // restore $31 (return address of syscall function)
+ 67     mtc0    $26,    $12                 // restore SR
+ 68     mtc0    $27,    $14                 // restore EPC
+ 69     addiu   $29,    $29,    8*4         // restore stack pointer
+ 70     eret                                // return : jr EPC with EXL <- 0
 }}}
 {{{#!protected ------------------------------------------------------------------------------------