Changes between Version 38 and Version 39 of AS6-TME-B5

Timestamp:

Feb 22, 2022, 3:02:06 PM (4 years ago)

Author:

franck

Comment:

--

AS6-TME-B5

@@ -388 +388 @@
 
 **kernel/harch.c**
+
+  *
 {{{#!c
 int tty_read (int tty, char *buf, unsigned count)
@@ -409 +411 @@
 Le schéma ci-dessous illustre le problème.
  [[Image(htdocs:img/IRQTTY_1.png,nolink,height=200)]]
+Le thread **`T0`** demande des lectures, `T1` prend le temps qui lui est donné jusqu'à l'IRQ du TIMER, je vous propose de lire le code en détail.
+
+**uapp/main.c**
+
+ * Le code ci-dessous contient l'application. Nous avons 3 threads : `main`, `t0` et `t1`.
+ * `main` et `t1` se contente d'afficher des messages sur le TTY0 et d'attendre (une attente active pour ralentir l'affichage des messages).
+ * `t0` lit le clavier de TTY1
+
+{{{#!c
+/*--------------------------------------------------------------------------------*\
+   _     ___    __
+  | |__ /'v'\  / /      \date        2022-02-22
+  | / /(     )/ _ \     \copyright   2021-2022 Sorbonne University
+  |_\_\ x___x \___/                  https://opensource.org/licenses/MIT
+
+\*--------------------------------------------------------------------------------*/
+
+#include <libc.h>
+#include <thread.h>
+
+#define DELAY(n) for(int i=n;i--;) __asm__("nop");
+
+thread_t t0, t1;
+
+void * t0_fun (void * arg)
+{
+    char buf[64];
+    for (int i = 0;; i++) {
+        fprintf (1, "entrez un truc : ");
+        fgets (buf, sizeof(buf), 1);
+        fprintf (1, "%s\n", buf);
+    }
+    return NULL;
+}
+
+void * t1_fun (void * arg)
+{
+    for (int i = 0;; i++) {
+        fprintf (0, "[%d] t1 is alive (%d) : %s\n", clock(), i, (char *)arg);
+        DELAY(1000000);
+    }
+    return NULL;
+}
+
+int main (void)
+{
+    thread_create (&t1, t1_fun, "bonjour");
+    thread_create (&t2, t2_fun, NULL);
+    for (int i = 0;; i++) {
+        fprintf (0, "[%d] app is alive (%d)\n", clock(), i);
+        DELAY(1000000);
+    }
+    return 0;
+}
+}}}
+
+**ulib/libc.c**
+
+ * La fonction `fgets()` est dans la **libc**, c'est une fonction bloquante du point de vue de l'utilisateur. Il l'appelle pour lire `count` caractères sur le TTY n°`tty` et les enregistre dans `buf`. 
+ * `fgets()` demande 1 caractère à la fois et elle le revoit sur l'écran (c'est un ''loopback'') pour que l'utilisateur sache que son caractère a été pris en compte.
+ * Il y a quelques subtilités dues au fait que lorsque vous taper sur ''**enter''**, le clavier envoie deux caractères '\r' (`13` = ''carriage return'') et '\n' (`10` = ''line feed''), on jette `\r`. En outre, on gère le `back sapce` et le `delete` (à qui on donne le même comportement pour simplifier). Je vous laisse essayer de comprendre pour le plaisir.
+ * Quand `fgets()` appelle `read()`, cela fait l'appel système `SYSCALL_READ`.
+
+{{{#!c
+int read(int fd, void *buf, int count)
+{   
+    return syscall_fct( fd, (int)buf, count, 0, SYSCALL_READ);
+}   
+    
+int write(int fd, void *buf, int count)
+{   
+    return syscall_fct( fd, (int)buf, count, 0, SYSCALL_WRITE);
+}
+
+int fgets (char *buf, int count, int tty)
+{
+    // to make the backspace, we use ANSI codes : https://www.wikiwand.com/en/ANSI_escape_code
+    char *DEL = "\033[D \033[D";                // move left, then write ' ' and move left
+    int res = 0; 
+    count--;                                    // we need to add a NUL (0) char at the end
+    char c=0;
+    
+    while ((count != 0) && (c != '\n')) {       // as long as we can or need to get a char
+
+        read (tty, &c, 1);                      // read only 1 char
+        if (c == '\r')                          // if c is the carriage return (13)
+            read (tty, &c, 1);                  // get the next that is line feed (10)
+    
+        if ((c == 8)||(c == 127)) {             // 8 = backspace, 127 = delete
+            if (res) {                          // go back in the buffer if possible
+                write (tty, DEL, 7);            // erase current char
+                count++;                        // count is the remaining place
+                buf--;                          // but is the next address in buffer
+                res--;
+            }
+            continue;                           // ask for another key
+        } else
+            write (tty, &c, 1);                 // loop back to the tty
+
+        *buf = c;                               // write the char into the buffer
+        buf++;                                  // increments the writing pointer
+        count--;                                // decrements the remaining space
+        res++;                                  // increments the read char
+    }
+    *buf = 0;                                   // add a last 0 to end the string
+
+    return res;                                 // returns the number of char read
+}
+}}}
+
+**kernel/ksyscall.c**
+
+ * Je ne met pas toutes les étapes de l'appel du gestionnaire de syscall, vous avez ici le vecteur de syscall qui montre bien que l'on appelle la fonction du noyau `tty_read()` dont vous avez le code un peu plus haut.
+
+{{{#!c
+void *syscall_vector[] = {
+    [0 ... SYSCALL_NR - 1 ] = unknown_syscall,   /* default function */
+    [SYSCALL_EXIT         ] = exit,
+    [SYSCALL_READ         ] = tty_read,
+    [SYSCALL_WRITE        ] = tty_write,
+    [SYSCALL_CLOCK        ] = clock,
+    [SYSCALL_THREAD_CREATE] = thread_create_kernel,
+    [SYSCALL_THREAD_YIELD ] = thread_yield,
+    [SYSCALL_THREAD_EXIT  ] = thread_exit,
+    [SYSCALL_SCHED_DUMP   ] = sched_dump,
+};
+}}}
+