Changes between Version 12 and Version 13 of AS6-TME-B1

Timestamp:

Feb 9, 2022, 9:29:40 AM (3 years ago)

Author:

franck

Comment:

--

AS6-TME-B1

@@ -659 +659 @@
 '''''''''''''''
 }}}
-1. Vous avez appris à écrire des programmes assembleur, mais parfois il est plus simple, voire nécessaire, de mélanger le code C et le code assembleur. Dans l'exemple ci-dessous, nous voyons comment la fonction `kinit()` procède pour entrer dans la fonction placée à l'adresse `__crt0` définie dans le fichier `kernel.ld`.\\Remarquez la syntaxe, ici `volatile` permet de dire au compilateur d'insérer le code tel que sans le modifier. Notez aussi l'absence de `,` entre les chaînes de caractères. Le premier argument de `__asm__` est une chaîne de caractères **unique** dans laquelle les instructions sont séparées par de `\n`. Il peut y avoir d'autres arguments, nous n'en aurons pas besoin.\\ \\Dans quelle section se trouve l'adresse `__crt0`? Combien vaut-elle? Est-ce que cette valeur est imposée par le processeur MIPS comme l'adresse de boot ou d'entrée dans le kernel? Quelle fonction est à cette adresse? Pourquoi doit-on écrire ce code en assembleur?
-{{{#!c
-  9 void kinit (void)
- 10 {
- 11     kprintf (0, banner);
+1. Vous avez appris à écrire des programmes assembleur, mais parfois il est plus simple, voire nécessaire, de mélanger le code C et le code assembleur. Dans l'exemple ci-dessous, nous voyons comment la fonction `syscall()` est écrite. Cette fonction utilise l'instruction `syscall`.\\Deux exemples d'usage de la fonction `syscall()` pris dans le fichier `tp2/4_libc/ulib/libc.c`
+{{{#!c
+  1 int fprintf (int tty, char *fmt, ...)
+  2 {
+  3     int res;
+  4     char buffer[PRINTF_MAX];
+  5     va_list ap;
+  6     va_start (ap, fmt);
+  7     res = vsnprintf(buffer, sizeof(buffer), fmt, ap);
+  8     res = syscall (tty, (int)buffer, 0, 0, SYSCALL_TTY_PUTS);
+  9     va_end(ap);
+ 10     return res;
+ 11 }
  12 
- 13     // put bss sections to zero. bss contains uninitialised global variables
- 14     extern int __bss_origin;    // first int of bss section
- 15     extern int __bss_end;       // first int of above bss section
- 16     for (int *a = &__bss_origin; a != &__bss_end; *a++ = 0);
- 17 
- 18     // this code allows to exit the kernel to go to user code
- 19     __asm__ volatile (   "la     $26,    __text_origin  \n"     // get first address of user code
- 20                          "mtc0   $26,    $14            \n"     // put it in c0_EPC
- 21                          "li     $26,    0b00010010     \n"     // next status [UM,0,ERL,EXL,IE] 
- 22                          "mtc0   $26,    $12            \n"     // UM <- 1, IE <- 0, EXL <- 1
- 23                          "la     $29,    __data_end     \n"     // define new user stack pointer
- 24                          "eret                          \n");   // j EPC and EXL <- 0
- 25 }
-}}}
-{{{#!protected ------------------------------------------------------------------------------------
-'''''''''''''''
-- L'adresse `__crt0` est la première adresse de la section `text` dans laquelle se trouve le code de l'application.
-- Elle vaut `0X7F400000`.
-- Cette adresse n'est pas imposée par le MIPS. C'est le choix des architectes du SoC. La seule condition est que cette adresse soit 
-  dans la partie accessible en mode user.
-- A cette adresse, on place la fonction `__start()`.
-- On est obligé d'écrire ce code en assembleur parce que la manière de changer de mode (de `kernel` à `user`) est propre à chaque processeur. Il n'y a aucun moyen de le faire en C.
-'''''''''''''''
-}}}
-1. Dans le code C de la question précédente, à quoi servent les lignes 14 à 16? Pourquoi faire des déclarations `extern`?
-{{{#!protected ------------------------------------------------------------------------------------
-'''''''''''''''
-- Ces lignes servent à mettre à 0 la zone des variables globales non initialisées explicitement par le programme.
-- Les déclarations `extern` permettent d'informer le compilateur que les adresses `__bss_orgin` et `__bss_end` 
-  existent ailleurs. De fait, elles sont définies dans le fichier `kernel.ld`.
-'''''''''''''''
+ 13 void exit (int status)
+ 14 {
+ 15     syscall( status, 0, 0, 0, SYSCALL_EXIT);        // never returns
+ 16 }
+}}}
+ Le code de cette fonction est dans le fichier `04_libc/ulib/crt0.c`
+{{{#!c
+  1 //int syscall (int a0, int a1, int a2, int a3, int syscall_code)
+  2 __asm__ (
+  3 ".globl syscall     \n"         
+  4 "syscall:           \n"         
+  5 "   lw  $2,16($29)  \n"         
+  6 "   syscall         \n"         
+  7 "   jr  $31         \n"         
+  8 );
+}}}
+ Combien d'arguments a la fonction `syscall()`?
+ Comment la fonction `syscall()` reçoit-elle ses arguments ?
+ A quoi sert la ligne 3 de la fonction `syscall()` et que se passe-t-il si on la retire ?
+ Expliquer la ligne 5 de la fonction `syscall()`.
+ Aurait-il été possible de mettre le code de la fonction `syscall()` dans un fichier `.S` ? 
+{{{#!protected ------------------------------------------------------------------------------------
+''
+- La fonction `syscall()` a 5 a arguments
+- Elle reçoit ses 4 premiers arguments dans les registres $4 à $7 et le 5e (le numéro de service) dans la pile.
+- La ligne 3 sert à dire que syscall est une étiquette utilisée dans un autre fichier. `.globl` signifie **glob**al **l**abel. Si on la retire, il y aura un problème lors de l'édition de lien. `syscall()` ne sera pas trouvé par l'éditeur de liens.
+- Le noyau attend le numéro de service dans `$2`. Or le numéro du service est le 5e argument de la fonction `syscall()`. La ligne 5 permet d'aller le chercher dans la pile.
+- oui, ce code de la fonction `syscall()` qui fait appel à l'instruction `syscall` aurait pu être mis dans un fichier en assembleur, mais cela aurait demandé d'avoir un fichier de plus, pour une seule fonction. Dans une version plus évoluée du système, il y aura un d'autres fonctions assembleur, alors on créera un fichier assembleur pour les réunir.
+''
 }}}