Improve documentation and output

Author: kohler

kernels1/kernel.cc

@@ -311,8 +311,7 @@ uintptr_t syscall(regstate* regs) {
 
     // It can be useful to log events using `log_printf`.
     // Events logged this way are stored in the host's `log.txt` file.
-    /* log_printf("proc %d: syscall %d at rip %p\n",
-                  current->pid, regs->reg_rax, regs->reg_rip); */
+    // log_printf("p%d: %s\n", current->pid, syscall_name(regs->reg_rax));
 
     // Show the current cursor location and memory state.
     console_show_cursor(cursorpos);
@@ -394,17 +393,14 @@ pid_t syscall_spawn(const char* command) {
 char pipebuf[1];
 size_t pipebuf_len = 0;
 
-// syscall_pipewrite(buf, sz)
-//    Handles the SYSCALL_PIPEWRITE system call; see `sys_pipewrite`
-//    in `u-lib.hh`.
-
 ssize_t syscall_pipewrite(const char* buf, size_t sz) {
+    // See `sys_pipewrite` in `u-lib.cc` for specification.
     if (sz == 0) {
         // nothing to write
         return 0;
     } else if (pipebuf_len == 1) {
-        // kernel buffer full, try again
-        return -1;
+        // kernel buffer full, process should try again
+        return E_AGAIN;
     } else {
         // write one character
         pipebuf[0] = buf[0];
@@ -413,17 +409,14 @@ ssize_t syscall_pipewrite(const char* buf, size_t sz) {
     }
 }
 
-// syscall_piperead(buf, sz)
-//    Handles the SYSCALL_PIPEREAD system call; see `sys_piperead`
-//    in `u-lib.hh`.
-
 ssize_t syscall_piperead(char* buf, size_t sz) {
+    // See `sys_piperead` in `u-lib.cc` for specification.
     if (sz == 0) {
         // no room to read
         return 0;
     } else if (pipebuf_len == 0) {
-        // kernel buffer empty, try again
-        return -1;
+        // kernel buffer empty, process should try again
+        return E_AGAIN;
     } else {
         // read one character
         buf[0] = pipebuf[0];

kernels1/lib.cc

@@ -787,6 +787,32 @@ void assert_memeq_fail(const char* file, int line, const char* msg,
 }
 
 
+// system call debugging
+
+const char* syscall_name(int syscall) {
+    switch (syscall) {
+    case SYSCALL_GETPID:
+        return "getpid";
+    case SYSCALL_YIELD:
+        return "yield";
+    case SYSCALL_PANIC:
+        return "panic";
+    case SYSCALL_PAGE_ALLOC:
+        return "page_alloc";
+    case SYSCALL_GETSYSNAME:
+        return "getsysname";
+    case SYSCALL_SPAWN:
+        return "spawn";
+    case SYSCALL_PIPEWRITE:
+        return "pipewrite";
+    case SYSCALL_PIPEREAD:
+        return "piperead";
+    default:
+        return "(unknown)";
+    }
+}
+
+
 // Some static tests of our arithmetic functions
 
 static_assert(msb(0) == 0, "msb failure");

kernels1/lib.hh

@@ -225,9 +225,12 @@ inline uint32_t crc32c(const void* buf, size_t sz) {
 #define SYSCALL_PIPEWRITE       7
 #define SYSCALL_PIPEREAD        8
 
+const char* syscall_name(int syscall);
+
 
 // System call error return values
 
+#define E_AGAIN         -11        // Try again
 #define E_INVAL         -22        // Invalid argument
 #define E_RANGE         -34        // Out of range
 

kernels1/p-pipereader.cc

@@ -3,10 +3,10 @@
 void process_main() {
     char buf[200];
     size_t buflen = 0;
-    size_t nreads = 0;
 
     while (true) {
         // Read a message
+        size_t nreads = 0;
         while (memchr(buf, '\n', buflen) == NULL) {
             ++nreads;
             ssize_t r = sys_piperead(&buf[buflen], sizeof(buf) - buflen);
@@ -19,9 +19,9 @@ void process_main() {
 
         // Print the message that was read
         char* newline = (char*) memchr(buf, '\n', buflen);
-        size_t messagelen = (newline + 1) - buf;
-        console_printf(0x0E00, "%zu sys_piperead calls: read %.*s",
-                       nreads, messagelen, buf);
+        size_t messagelen = newline - buf + 1;
+        console_printf(0x0E00, "%zu sys_piperead calls for %zuB: read %.*s",
+                       nreads, messagelen, messagelen, buf);
 
         // Shift down rest of buffer
         memmove(buf, &buf[messagelen], buflen - messagelen);

kernels1/p-pipewriter.cc

@@ -7,13 +7,12 @@ const char* messages[] = {
 };
 
 void process_main() {
-    size_t nwrites = 0;
-
     while (true) {
         // First, write a message.
         const char* message = messages[rand(0, arraysize(messages) - 1)];
         size_t pos = 0;
         size_t len = strlen(message);
+        size_t nwrites = 0;
         while (pos < len) {
             ++nwrites;
             ssize_t w = sys_pipewrite(&message[pos], len - pos);
@@ -25,8 +24,8 @@ void process_main() {
         }
 
         // Print that message was written.
-        console_printf(0x0F00, "%zu sys_pipewrite calls: wrote %s",
-                       nwrites, message);
+        console_printf(0x0F00, "%zu sys_pipewrite calls for %zuB: wrote %.*s",
+                       nwrites, len, len, message);
 
         // Wait 1-3 seconds.
         unsigned long wait_until = ticks + rand(HZ, 3 * HZ - 1);

kernels1/u-lib.cc

@@ -43,16 +43,19 @@ pid_t sys_spawn(const char* command) {
 }
 
 // sys_pipewrite(buf, sz)
-//    Write data to pipe from `buf`. Writes at most `sz` bytes.
-//    Returns number of bytes written or -1 on error.
+//    Copy up to `sz` bytes of data from `buf` into the system pipe.
+//    Returns number of bytes written or a negative error code (if, for
+//    instance, the system pipe’s data transfer buffer is full).
 [[gnu::noinline]]
 ssize_t sys_pipewrite(const void* buf, size_t sz) {
     return make_syscall(SYSCALL_PIPEWRITE, (uintptr_t) buf, sz);
 }
 
 // sys_piperead(buf, sz)
-//    Read data from pipe into `buf`. Reads at most `sz` bytes.
-//    Returns number of bytes read or -1 on error.
+//    Read up to `sz` bytes of data from the system pipe into `buf`.
+//    Bytes read are removed from the system pipe.
+//    Returns number of bytes read or a negative error code (if, for
+//    instance, the system pipe’s data transfer buffer is empty).
 [[gnu::noinline]]
 ssize_t sys_piperead(void* buf, size_t sz) {
     return make_syscall(SYSCALL_PIPEREAD, (uintptr_t) buf, sz);