Drop memory_read_str function

The memory_read_str function tends to terminate the string with '\0'
character but the string is only terminated with '\0' character if src is
less than max characters long according to "man 3 strncpy". As a result,
there is a chance to make the dst is not terminated with '\0' character,
e.g., the length of filename equals 256 characters long. It can simply
solved by passing "sizeof(name_str) - 1" to memory_read_str function
instead of "sizeof(name_str)" when calling memory_read_str function.
But, to deal with the filename >= 256 characters long, malloc the desired
length of filename during runtime is a better way.

Author: ChinYikMing

src/io.c

@@ -61,16 +61,6 @@ void memory_read(const memory_t *mem,
     memcpy(dst, mem->mem_base + addr, size);
 }
 
-uint32_t memory_read_str(const memory_t *mem,
-                         uint8_t *dst,
-                         uint32_t addr,
-                         uint32_t max)
-{
-    char *d = (char *) dst;
-    char *s = (char *) mem->mem_base + addr;
-    return strlen(strncpy(d, s, max));
-}
-
 uint32_t memory_ifetch(uint32_t addr)
 {
     return *(const uint32_t *) (data_memory_base + addr);

src/io.h

@@ -20,12 +20,6 @@ typedef struct {
 memory_t *memory_new(uint32_t size);
 void memory_delete(memory_t *m);
 
-/* read a C-style string from memory */
-uint32_t memory_read_str(const memory_t *m,
-                         uint8_t *dst,
-                         uint32_t addr,
-                         uint32_t max);
-
 /* read an instruction from memory */
 uint32_t memory_ifetch(uint32_t addr);
 

src/syscall.c

@@ -7,6 +7,7 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/time.h>
 
 #include "riscv.h"
@@ -84,7 +85,7 @@ static void syscall_write(riscv_t *rv)
 {
     vm_attr_t *attr = PRIV(rv);
 
-    /* _write(fde, buffer, count) */
+    /* _write(fd, buffer, count) */
     riscv_word_t fd = rv_get_reg(rv, rv_reg_a0);
     riscv_word_t buffer = rv_get_reg(rv, rv_reg_a1);
     riscv_word_t count = rv_get_reg(rv, rv_reg_a2);
@@ -327,13 +328,11 @@ static void syscall_open(riscv_t *rv)
     uint32_t mode = rv_get_reg(rv, rv_reg_a2);
 
     /* read name from runtime memory */
-    char name_str[256] = {'\0'};
-    uint32_t read = memory_read_str(attr->mem, (uint8_t *) name_str, name,
-                                    sizeof(name_str));
-    if (read > sizeof(name_str)) {
-        rv_set_reg(rv, rv_reg_a0, -1);
-        return;
-    }
+    const size_t name_len = strlen(attr->mem->mem_base + name);
+    char *name_str = malloc(name_len + 1);
+    assert(name_str);
+    name_str[name_len] = '\0';
+    memory_read(attr->mem, (uint8_t *) name_str, name, name_len);
 
     /* open the file */
     const char *mode_str = get_mode_str(flags, mode);
@@ -348,6 +347,8 @@ static void syscall_open(riscv_t *rv)
         return;
     }
 
+    free(name_str);
+
     const int fd = find_free_fd(attr); /* find a free file descriptor */
 
     /* insert into the file descriptor map */