[lwp] syscall signature

components/lwp/lwp_syscall.c

@@ -31,15 +31,17 @@
 #if (defined(RT_USING_SAL) && defined(SAL_USING_POSIX))
 #include <sys/socket.h>
 
-#define SYSCALL_NET(f)      ((void *)(f))
+#include "syscall_data.h"
+
+#define SYSCALL_NET(f)      f
 #else
-#define SYSCALL_NET(f)      ((void *)sys_notimpl)
+#define SYSCALL_NET(f)      SYSCALL_SIGN(sys_notimpl)
 #endif
 
 #if defined(RT_USING_DFS) && defined(RT_USING_USERSPACE)
-#define SYSCALL_USPACE(f)   ((void *)(f))
+#define SYSCALL_USPACE(f)   f
 #else
-#define SYSCALL_USPACE(f)   ((void *)sys_notimpl)
+#define SYSCALL_USPACE(f)   SYSCALL_SIGN(sys_notimpl)
 #endif
 
 #define DBG_TAG    "SYSCALL"
@@ -52,6 +54,7 @@
 
 #include <sal_netdb.h>
 #include <sal.h>
+#include <sys/socket.h>
 #endif /* RT_USING_SAL */
 
 #include <tty.h>
@@ -4115,200 +4118,200 @@ int sys_fsync(int fd)
 
 const static void* func_table[] =
 {
-    (void *)sys_exit,            /* 01 */
-    (void *)sys_read,
-    (void *)sys_write,
-    (void *)sys_lseek,
-    (void *)sys_open,            /* 05 */
-    (void *)sys_close,
-    (void *)sys_ioctl,
-    (void *)sys_fstat,
-    (void *)sys_poll,
-    (void *)sys_nanosleep,       /* 10 */
-    (void *)sys_gettimeofday,
-    (void *)sys_settimeofday,
-    (void *)sys_exec,
-    (void *)sys_kill,
-    (void *)sys_getpid,          /* 15 */
-    (void *)sys_getpriority,
-    (void *)sys_setpriority,
-    (void *)sys_sem_create,
-    (void *)sys_sem_delete,
-    (void *)sys_sem_take,        /* 20 */
-    (void *)sys_sem_release,
-    (void *)sys_mutex_create,
-    (void *)sys_mutex_delete,
-    (void *)sys_mutex_take,
-    (void *)sys_mutex_release,   /* 25 */
-    (void *)sys_event_create,
-    (void *)sys_event_delete,
-    (void *)sys_event_send,
-    (void *)sys_event_recv,
-    (void *)sys_mb_create,       /* 30 */
-    (void *)sys_mb_delete,
-    (void *)sys_mb_send,
-    (void *)sys_mb_send_wait,
-    (void *)sys_mb_recv,
-    (void *)sys_mq_create,       /* 35 */
-    (void *)sys_mq_delete,
-    (void *)sys_mq_send,
-    (void *)sys_mq_urgent,
-    (void *)sys_mq_recv,
-    (void *)sys_thread_create,   /* 40 */
-    (void *)sys_thread_delete,
-    (void *)sys_thread_startup,
-    (void *)sys_thread_self,
-    (void *)sys_channel_open,
-    (void *)sys_channel_close,   /* 45 */
-    (void *)sys_channel_send,
-    (void *)sys_channel_send_recv_timeout,
-    (void *)sys_channel_reply,
-    (void *)sys_channel_recv_timeout,
-    (void *)sys_enter_critical,  /* 50 */
-    (void *)sys_exit_critical,
-
-    SYSCALL_USPACE(sys_brk),
-    SYSCALL_USPACE(sys_mmap2),
-    SYSCALL_USPACE(sys_munmap),
+    SYSCALL_SIGN(sys_exit),            /* 01 */
+    SYSCALL_SIGN(sys_read),
+    SYSCALL_SIGN(sys_write),
+    SYSCALL_SIGN(sys_lseek),
+    SYSCALL_SIGN(sys_open),            /* 05 */
+    SYSCALL_SIGN(sys_close),
+    SYSCALL_SIGN(sys_ioctl),
+    SYSCALL_SIGN(sys_fstat),
+    SYSCALL_SIGN(sys_poll),
+    SYSCALL_SIGN(sys_nanosleep),       /* 10 */
+    SYSCALL_SIGN(sys_gettimeofday),
+    SYSCALL_SIGN(sys_settimeofday),
+    SYSCALL_SIGN(sys_exec),
+    SYSCALL_SIGN(sys_kill),
+    SYSCALL_SIGN(sys_getpid),          /* 15 */
+    SYSCALL_SIGN(sys_getpriority),
+    SYSCALL_SIGN(sys_setpriority),
+    SYSCALL_SIGN(sys_sem_create),
+    SYSCALL_SIGN(sys_sem_delete),
+    SYSCALL_SIGN(sys_sem_take),        /* 20 */
+    SYSCALL_SIGN(sys_sem_release),
+    SYSCALL_SIGN(sys_mutex_create),
+    SYSCALL_SIGN(sys_mutex_delete),
+    SYSCALL_SIGN(sys_mutex_take),
+    SYSCALL_SIGN(sys_mutex_release),   /* 25 */
+    SYSCALL_SIGN(sys_event_create),
+    SYSCALL_SIGN(sys_event_delete),
+    SYSCALL_SIGN(sys_event_send),
+    SYSCALL_SIGN(sys_event_recv),
+    SYSCALL_SIGN(sys_mb_create),       /* 30 */
+    SYSCALL_SIGN(sys_mb_delete),
+    SYSCALL_SIGN(sys_mb_send),
+    SYSCALL_SIGN(sys_mb_send_wait),
+    SYSCALL_SIGN(sys_mb_recv),
+    SYSCALL_SIGN(sys_mq_create),       /* 35 */
+    SYSCALL_SIGN(sys_mq_delete),
+    SYSCALL_SIGN(sys_mq_send),
+    SYSCALL_SIGN(sys_mq_urgent),
+    SYSCALL_SIGN(sys_mq_recv),
+    SYSCALL_SIGN(sys_thread_create),   /* 40 */
+    SYSCALL_SIGN(sys_thread_delete),
+    SYSCALL_SIGN(sys_thread_startup),
+    SYSCALL_SIGN(sys_thread_self),
+    SYSCALL_SIGN(sys_channel_open),
+    SYSCALL_SIGN(sys_channel_close),   /* 45 */
+    SYSCALL_SIGN(sys_channel_send),
+    SYSCALL_SIGN(sys_channel_send_recv_timeout),
+    SYSCALL_SIGN(sys_channel_reply),
+    SYSCALL_SIGN(sys_channel_recv_timeout),
+    SYSCALL_SIGN(sys_enter_critical),  /* 50 */
+    SYSCALL_SIGN(sys_exit_critical),
+
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_brk)),
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_mmap2)),
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_munmap)),
 #ifdef ARCH_MM_MMU
-    SYSCALL_USPACE(sys_shmget), /* 55 */
-    SYSCALL_USPACE(sys_shmrm),
-    SYSCALL_USPACE(sys_shmat),
-    SYSCALL_USPACE(sys_shmdt),
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_shmget)), /* 55 */
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_shmrm)),
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_shmat)),
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_shmdt)),
 #else
 #ifdef RT_LWP_USING_SHM
-    (void *)sys_shm_alloc,      /* 55 */
-    (void *)sys_shm_free,
-    (void *)sys_shm_retain,
-    (void *)sys_notimpl,
+    SYSCALL_SIGN(sys_shm_alloc),      /* 55 */
+    SYSCALL_SIGN(sys_shm_free),
+    SYSCALL_SIGN(sys_shm_retain),
+    SYSCALL_SIGN(sys_notimpl),
 #else
-    (void *)sys_notimpl,      /* 55 */
-    (void *)sys_notimpl,
-    (void *)sys_notimpl,
-    (void *)sys_notimpl,
+    SYSCALL_SIGN(sys_notimpl),      /* 55 */
+    SYSCALL_SIGN(sys_notimpl),
+    SYSCALL_SIGN(sys_notimpl),
+    SYSCALL_SIGN(sys_notimpl),
 #endif /* RT_LWP_USING_SHM */
 #endif /* ARCH_MM_MMU */
-    (void *)sys_device_init,
-    (void *)sys_device_register, /* 60 */
-    (void *)sys_device_control,
-    (void *)sys_device_find,
-    (void *)sys_device_open,
-    (void *)sys_device_close,
-    (void *)sys_device_read,    /* 65 */
-    (void *)sys_device_write,
-
-    (void *)sys_stat,
-    (void *)sys_thread_find,
-
-    SYSCALL_NET(sys_accept),
-    SYSCALL_NET(sys_bind),      /* 70 */
-    SYSCALL_NET(sys_shutdown),
-    SYSCALL_NET(sys_getpeername),
-    SYSCALL_NET(sys_getsockname),
-    SYSCALL_NET(sys_getsockopt),
-    SYSCALL_NET(sys_setsockopt), /* 75 */
-    SYSCALL_NET(sys_connect),
-    SYSCALL_NET(sys_listen),
-    SYSCALL_NET(sys_recv),
-    SYSCALL_NET(sys_recvfrom),
-    SYSCALL_NET(sys_send),      /* 80 */
-    SYSCALL_NET(sys_sendto),
-    SYSCALL_NET(sys_socket),
-
-    SYSCALL_NET(sys_closesocket),
-    SYSCALL_NET(sys_getaddrinfo),
-    SYSCALL_NET(sys_gethostbyname2_r), /* 85 */
-
-    (void *)sys_notimpl,    //(void *)network,
-    (void *)sys_notimpl,    //(void *)network,
-    (void *)sys_notimpl,    //(void *)network,
-    (void *)sys_notimpl,    //(void *)network,
-    (void *)sys_notimpl,    //(void *)network, /* 90 */
-    (void *)sys_notimpl,    //(void *)network,
-    (void *)sys_notimpl,    //(void *)network,
-    (void *)sys_notimpl,    //(void *)network,
+    SYSCALL_SIGN(sys_device_init),
+    SYSCALL_SIGN(sys_device_register), /* 60 */
+    SYSCALL_SIGN(sys_device_control),
+    SYSCALL_SIGN(sys_device_find),
+    SYSCALL_SIGN(sys_device_open),
+    SYSCALL_SIGN(sys_device_close),
+    SYSCALL_SIGN(sys_device_read),    /* 65 */
+    SYSCALL_SIGN(sys_device_write),
+
+    SYSCALL_SIGN(sys_stat),
+    SYSCALL_SIGN(sys_thread_find),
+
+    SYSCALL_NET(SYSCALL_SIGN(sys_accept)),
+    SYSCALL_NET(SYSCALL_SIGN(sys_bind)),      /* 70 */
+    SYSCALL_NET(SYSCALL_SIGN(sys_shutdown)),
+    SYSCALL_NET(SYSCALL_SIGN(sys_getpeername)),
+    SYSCALL_NET(SYSCALL_SIGN(sys_getsockname)),
+    SYSCALL_NET(SYSCALL_SIGN(sys_getsockopt)),
+    SYSCALL_NET(SYSCALL_SIGN(sys_setsockopt)), /* 75 */
+    SYSCALL_NET(SYSCALL_SIGN(sys_connect)),
+    SYSCALL_NET(SYSCALL_SIGN(sys_listen)),
+    SYSCALL_NET(SYSCALL_SIGN(sys_recv)),
+    SYSCALL_NET(SYSCALL_SIGN(sys_recvfrom)),
+    SYSCALL_NET(SYSCALL_SIGN(sys_send)),      /* 80 */
+    SYSCALL_NET(SYSCALL_SIGN(sys_sendto)),
+    SYSCALL_NET(SYSCALL_SIGN(sys_socket)),
+
+    SYSCALL_NET(SYSCALL_SIGN(sys_closesocket)),
+    SYSCALL_NET(SYSCALL_SIGN(sys_getaddrinfo)),
+    SYSCALL_NET(SYSCALL_SIGN(sys_gethostbyname2_r)), /* 85 */
+
+    SYSCALL_SIGN(sys_notimpl),    //network,
+    SYSCALL_SIGN(sys_notimpl),    //network,
+    SYSCALL_SIGN(sys_notimpl),    //network,
+    SYSCALL_SIGN(sys_notimpl),    //network,
+    SYSCALL_SIGN(sys_notimpl),    //network, /* 90 */
+    SYSCALL_SIGN(sys_notimpl),    //network,
+    SYSCALL_SIGN(sys_notimpl),    //network,
+    SYSCALL_SIGN(sys_notimpl),    //network,
 
 #ifdef RT_USING_DFS
-    (void *)sys_select,
+    SYSCALL_SIGN(sys_select),
 #else
-    (void *)sys_notimpl,
+    SYSCALL_SIGN(sys_notimpl),
 #endif
 
-    (void *)sys_notimpl,    //(void *)sys_hw_interrupt_disable, /* 95 */
-    (void *)sys_notimpl,    //(void *)sys_hw_interrupt_enable,
+    SYSCALL_SIGN(sys_notimpl),    //SYSCALL_SIGN(sys_hw_interrupt_disable), /* 95 */
+    SYSCALL_SIGN(sys_notimpl),    //SYSCALL_SIGN(sys_hw_interrupt_enable),
 
-    (void *)sys_tick_get,
-    (void *)sys_exit_group,
+    SYSCALL_SIGN(sys_tick_get),
+    SYSCALL_SIGN(sys_exit_group),
 
-    (void *)sys_notimpl,    //(void *)rt_delayed_work_init,
-    (void *)sys_notimpl,    //(void *)rt_work_submit,           /* 100 */
-    (void *)sys_notimpl,    //(void *)rt_wqueue_wakeup,
-    (void *)sys_thread_mdelay,
-    (void *)sys_sigaction,
-    (void *)sys_sigprocmask,
-    (void *)sys_tkill,             /* 105 */
-    (void *)sys_thread_sigprocmask,
+    SYSCALL_SIGN(sys_notimpl),    //rt_delayed_work_init,
+    SYSCALL_SIGN(sys_notimpl),    //rt_work_submit,           /* 100 */
+    SYSCALL_SIGN(sys_notimpl),    //rt_wqueue_wakeup,
+    SYSCALL_SIGN(sys_thread_mdelay),
+    SYSCALL_SIGN(sys_sigaction),
+    SYSCALL_SIGN(sys_sigprocmask),
+    SYSCALL_SIGN(sys_tkill),             /* 105 */
+    SYSCALL_SIGN(sys_thread_sigprocmask),
 #ifdef ARCH_MM_MMU
-    (void *)sys_cacheflush,
-    (void *)sys_notimpl,
-    (void *)sys_notimpl,
+    SYSCALL_SIGN(sys_cacheflush),
+    SYSCALL_SIGN(sys_notimpl),
+    SYSCALL_SIGN(sys_notimpl),
 #else
-    (void *)sys_notimpl,
-    (void *)sys_lwp_sighandler_set,
-    (void *)sys_thread_sighandler_set,
+    SYSCALL_SIGN(sys_notimpl),
+    SYSCALL_SIGN(sys_lwp_sighandler_set),
+    SYSCALL_SIGN(sys_thread_sighandler_set),
 #endif
-    (void *)sys_waitpid,          /* 110 */
-
-    (void *)sys_timer_create,
-    (void *)sys_timer_delete,
-    (void *)sys_timer_start,
-    (void *)sys_timer_stop,
-    (void *)sys_timer_control,  /* 115 */
-    (void *)sys_getcwd,
-    (void *)sys_chdir,
-    (void *)sys_unlink,
-    (void *)sys_mkdir,
-    (void *)sys_rmdir,          /* 120 */
-    (void *)sys_getdents,
-    (void *)sys_get_errno,
+    SYSCALL_SIGN(sys_waitpid),          /* 110 */
+
+    SYSCALL_SIGN(sys_timer_create),
+    SYSCALL_SIGN(sys_timer_delete),
+    SYSCALL_SIGN(sys_timer_start),
+    SYSCALL_SIGN(sys_timer_stop),
+    SYSCALL_SIGN(sys_timer_control),  /* 115 */
+    SYSCALL_SIGN(sys_getcwd),
+    SYSCALL_SIGN(sys_chdir),
+    SYSCALL_SIGN(sys_unlink),
+    SYSCALL_SIGN(sys_mkdir),
+    SYSCALL_SIGN(sys_rmdir),          /* 120 */
+    SYSCALL_SIGN(sys_getdents),
+    SYSCALL_SIGN(sys_get_errno),
 #ifdef ARCH_MM_MMU
-    (void *)sys_set_thread_area,
-    (void *)sys_set_tid_address,
+    SYSCALL_SIGN(sys_set_thread_area),
+    SYSCALL_SIGN(sys_set_tid_address),
 #else
-    (void *)sys_notimpl,
-    (void *)sys_notimpl,
+    SYSCALL_SIGN(sys_notimpl),
+    SYSCALL_SIGN(sys_notimpl),
 #endif
-    (void *)sys_access,         /* 125 */
-    (void *)sys_pipe,
-    (void *)sys_clock_settime,
-    (void *)sys_clock_gettime,
-    (void *)sys_clock_getres,
-    SYSCALL_USPACE(sys_clone),           /* 130 */
-    SYSCALL_USPACE(sys_futex),
-    SYSCALL_USPACE(sys_pmutex),
-    (void *)sys_dup,
-    (void *)sys_dup2,
-    (void *)sys_rename,         /* 135 */
-    SYSCALL_USPACE(sys_fork),
-    SYSCALL_USPACE(sys_execve),
-    SYSCALL_USPACE(sys_vfork),
-    (void *)sys_gettid,
-    (void *)sys_prlimit64,      /* 140 */
-    (void *)sys_getrlimit,
-    (void *)sys_setrlimit,
-    (void *)sys_setsid,
-    (void *)sys_getrandom,
-    (void *)sys_notimpl,    // (void *)sys_readlink     /* 145 */
-    SYSCALL_USPACE(sys_mremap),
-    SYSCALL_USPACE(sys_madvise),
-    (void *)sys_sched_setparam,
-    (void *)sys_sched_getparam,
-    (void *)sys_sched_get_priority_max,
-    (void *)sys_sched_get_priority_min,
-    (void *)sys_sched_setscheduler,
-    (void *)sys_sched_getscheduler,
-    (void *)sys_setaffinity,
-    (void *)sys_fsync
+    SYSCALL_SIGN(sys_access),         /* 125 */
+    SYSCALL_SIGN(sys_pipe),
+    SYSCALL_SIGN(sys_clock_settime),
+    SYSCALL_SIGN(sys_clock_gettime),
+    SYSCALL_SIGN(sys_clock_getres),
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_clone)),           /* 130 */
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_futex)),
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_pmutex)),
+    SYSCALL_SIGN(sys_dup),
+    SYSCALL_SIGN(sys_dup2),
+    SYSCALL_SIGN(sys_rename),         /* 135 */
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_fork)),
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_execve)),
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_vfork)),
+    SYSCALL_SIGN(sys_gettid),
+    SYSCALL_SIGN(sys_prlimit64),      /* 140 */
+    SYSCALL_SIGN(sys_getrlimit),
+    SYSCALL_SIGN(sys_setrlimit),
+    SYSCALL_SIGN(sys_setsid),
+    SYSCALL_SIGN(sys_getrandom),
+    SYSCALL_SIGN(sys_notimpl),    // SYSCALL_SIGN(sys_readlink)     /* 145 */
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_mremap)),
+    SYSCALL_USPACE(SYSCALL_SIGN(sys_madvise)),
+    SYSCALL_SIGN(sys_sched_setparam),
+    SYSCALL_SIGN(sys_sched_getparam),
+    SYSCALL_SIGN(sys_sched_get_priority_max),
+    SYSCALL_SIGN(sys_sched_get_priority_min),
+    SYSCALL_SIGN(sys_sched_setscheduler),
+    SYSCALL_SIGN(sys_sched_getscheduler),
+    SYSCALL_SIGN(sys_setaffinity),
+    SYSCALL_SIGN(sys_fsync)
 };
 
 const void *lwp_get_sys_api(rt_uint32_t number)
@@ -4322,11 +4325,32 @@ const void *lwp_get_sys_api(rt_uint32_t number)
     else
     {
         number -= 1;
-        if (number < sizeof(func_table) / sizeof(func_table[0]))
+        if (number < sizeof(func_table) / sizeof(func_table[0]) / 2)
         {
-            func = func_table[number];
+            func = func_table[number << 1];
         }
     }
 
     return func;
 }
+
+const char *lwp_get_syscall_name(rt_uint32_t number)
+{
+    const char *name = "sys_notimpl";
+
+    if (number == 0xff)
+    {
+        name = "sys_log";
+    }
+    else
+    {
+        number -= 1;
+        if (number < sizeof(func_table) / sizeof(func_table[0]) / 2)
+        {
+            name = (char*)func_table[(number << 1) + 1];
+        }
+    }
+
+    // skip sys_
+    return name + 4;
+}

components/lwp/lwp_syscall.h

@@ -35,6 +35,9 @@ typedef uint32_t id_t;          /* may contain pid, uid or gid */
 #define	PRIO_PGRP	    1
 #define	PRIO_USER	    2
 
+const char *lwp_get_syscall_name(rt_uint32_t number);
+const void *lwp_get_sys_api(rt_uint32_t number);
+
 void sys_exit(int value);
 ssize_t sys_read(int fd, void *buf, size_t nbyte);
 ssize_t sys_write(int fd, const void *buf, size_t nbyte);

components/lwp/syscall_data.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2006-2022, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2022-11-10     RT-Thread    The first version
+ */
+#ifndef __SYSCALL_DATA_H__
+#define __SYSCALL_DATA_H__
+
+#define xstr(x...)	#x
+#define str(x...)	xstr(x)
+
+/**
+ * @brief signature for syscall, used to locate syscall metadata.
+ *
+ * We don't allocate an exclusive section in ELF like Linux do
+ * to avoid initializing necessary data by iterating that section,
+ * which increases system booting time. We signature a pointer
+ * just below each syscall entry in syscall table to make it
+ * easy to locate every syscall's metadata by using syscall id.
+ *
+ * TODO Currently this adds a dummy pointer to syscall name.
+ * After adding metadata of every syscalls in front of their definition,
+ * this should be replaced by a pointer to that structure
+ */
+#define SYSCALL_SIGN(func) \
+    (void *)func,          \
+        str(func)
+
+#endif /* __SYSCALL_DATA_H__ */

libcpu/risc-v/t-head/c906/syscall_c.c

@@ -6,13 +6,14 @@
  * Change Logs:
  * Date           Author       Notes
  * 2021-02-03     lizhirui     first version
+ * 2022-11-10     WangXiaoyao  Add readable syscall tracing
  */
 
 #include <rthw.h>
 #include <rtthread.h>
 
-#define DBG_LEVEL DBG_WARNING
-//#define DBG_LEVEL DBG_INFO
+#define DBG_TAG "syscall"
+#define DBG_LVL DBG_WARNING
 #include <rtdbg.h>
 
 #include <stdint.h>
@@ -21,39 +22,39 @@
 #include <lwp_mm_area.h>
 #include <lwp_user_mm.h>
 
-#include <stdio.h>
-
 #include "riscv_mmu.h"
 #include "stack.h"
 
-typedef rt_size_t (*syscallfunc_t)(rt_size_t,rt_size_t,rt_size_t,rt_size_t,rt_size_t,rt_size_t,rt_size_t);
-syscallfunc_t lwp_get_sys_api(uint32_t);
+typedef rt_size_t (*syscallfunc_t)(rt_size_t, rt_size_t, rt_size_t, rt_size_t, rt_size_t, rt_size_t, rt_size_t);
 
 void syscall_handler(struct rt_hw_stack_frame *regs)
 {
-    if(regs -> a7 == 0)
-    {
-        rt_kprintf("syscall id = 0!\n");
-        while(1);
-    }
+    const char *syscall_name;
+    int syscallid = regs->a7;
 
-    if(regs -> a7 == 0xdeadbeef)
+    if (syscallid == 0)
     {
-        rt_kprintf("syscall id = 0xdeadbeef\n");
-        while(1);
+        LOG_E("syscall id = 0!\n");
+        while (1)
+            ;
     }
 
-    syscallfunc_t syscallfunc = (syscallfunc_t)lwp_get_sys_api(regs -> a7);
+    syscallfunc_t syscallfunc = (syscallfunc_t)lwp_get_sys_api(syscallid);
 
-    if(syscallfunc == RT_NULL)
+    if (syscallfunc == RT_NULL)
     {
-        rt_kprintf("unsupported syscall!\n");
-        while(1);
+        LOG_E("unsupported syscall!\n");
+        sys_exit(-1);
     }
 
-    LOG_I("\033[36msyscall id = %d,arg0 = 0x%p,arg1 = 0x%p,arg2 = 0x%p,arg3 = 0x%p,arg4 = 0x%p,arg5 = 0x%p,arg6 = 0x%p\n\033[37m",regs -> a7,regs -> a0,regs -> a1,regs -> a2,regs -> a3,regs -> a4,regs -> a5,regs -> a6);
-    regs -> a0 = syscallfunc(regs -> a0,regs -> a1,regs -> a2,regs -> a3,regs -> a4,regs -> a5,regs -> a6);
-    regs -> a7 = 0;
-    regs -> epc += 4;//skip ecall instruction
-    LOG_I("\033[36msyscall deal ok,ret = 0x%p\n\033[37m",regs -> a0);
+#if DBG_LVL >= DBG_INFO
+    syscall_name = lwp_get_syscall_name(syscallid);
+#endif
+
+    LOG_I("[0x%lx] %s(0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx)", rt_thread_self(), syscall_name,
+        regs->a0, regs->a1, regs->a2, regs->a3, regs->a4, regs->a5, regs->a6);
+    regs->a0 = syscallfunc(regs->a0, regs->a1, regs->a2, regs->a3, regs->a4, regs->a5, regs->a6);
+    regs->a7 = 0;
+    regs->epc += 4; // skip ecall instruction
+    LOG_I("[0x%lx] %s ret: 0x%lx", rt_thread_self(), syscall_name, regs->a0);
 }

libcpu/risc-v/virt64/syscall_c.c

@@ -6,6 +6,7 @@
  * Change Logs:
  * Date           Author       Notes
  * 2021-02-03     lizhirui     first version
+ * 2022-11-10     WangXiaoyao  Add readable syscall tracing
  */
 
 #include <rthw.h>
@@ -21,19 +22,16 @@
 #include <lwp_mm_area.h>
 #include <lwp_user_mm.h>
 
-#include <stdio.h>
-
 #include "riscv_mmu.h"
 #include "stack.h"
 
 typedef rt_size_t (*syscallfunc_t)(rt_size_t, rt_size_t, rt_size_t, rt_size_t, rt_size_t, rt_size_t, rt_size_t);
-syscallfunc_t lwp_get_sys_api(uint32_t);
-
-static char *syscall_name[256];
 
 void syscall_handler(struct rt_hw_stack_frame *regs)
 {
+    const char *syscall_name;
     int syscallid = regs->a7;
+
     if (syscallid == 0)
     {
         LOG_E("syscall id = 0!\n");
@@ -49,170 +47,14 @@ void syscall_handler(struct rt_hw_stack_frame *regs)
         sys_exit(-1);
     }
 
-    LOG_I("[0x%lx] %s(0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx)", rt_thread_self(), syscall_name[syscallid],
+#if DBG_LVL >= DBG_INFO
+    syscall_name = lwp_get_syscall_name(syscallid);
+#endif
+
+    LOG_I("[0x%lx] %s(0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx)", rt_thread_self(), syscall_name,
         regs->a0, regs->a1, regs->a2, regs->a3, regs->a4, regs->a5, regs->a6);
     regs->a0 = syscallfunc(regs->a0, regs->a1, regs->a2, regs->a3, regs->a4, regs->a5, regs->a6);
     regs->a7 = 0;
     regs->epc += 4; // skip ecall instruction
-    LOG_I("[0x%lx] %s ret: 0x%lx", rt_thread_self(), syscall_name[syscallid], regs->a0);
+    LOG_I("[0x%lx] %s ret: 0x%lx", rt_thread_self(), syscall_name, regs->a0);
 }
-
-static char *syscall_name[] = {
-    "UNDEFINED",
-    "sys_exit",
-    "sys_read",
-    "sys_write",
-    "sys_lseek",
-    "sys_open",
-    "sys_close",
-    "sys_ioctl",
-    "sys_fstat",
-    "sys_poll",
-    "sys_nanosleep",
-    "sys_gettimeofday",
-    "sys_settimeofday",
-    "sys_exec",
-    "sys_kill",
-    "sys_getpid",
-    "sys_getpriority",
-    "sys_setpriority",
-    "sys_sem_create",
-    "sys_sem_delete",
-    "sys_sem_take",
-    "sys_sem_release",
-    "sys_mutex_create",
-    "sys_mutex_delete",
-    "sys_mutex_take",
-    "sys_mutex_release",
-    "sys_event_create",
-    "sys_event_delete",
-    "sys_event_send",
-    "sys_event_recv",
-    "sys_mb_create",
-    "sys_mb_delete",
-    "sys_mb_send",
-    "sys_mb_send_wait",
-    "sys_mb_recv",
-    "sys_mq_create",
-    "sys_mq_delete",
-    "sys_mq_send",
-    "sys_mq_urgent",
-    "sys_mq_recv",
-    "sys_thread_create",
-    "sys_thread_delete",
-    "sys_thread_startup",
-    "sys_thread_self",
-    "sys_channel_open",
-    "sys_channel_close",
-    "sys_channel_send",
-    "sys_channel_send_recv_timeout",
-    "sys_channel_reply",
-    "sys_channel_recv_timeout",
-    "sys_enter_critical",
-    "sys_exit_critical",
-    "sys_brk",
-    "sys_mmap2",
-    "sys_munmap",
-    "sys_shmget",
-    "sys_shmrm",
-    "sys_shmat",
-    "sys_shmdt",
-    "sys_device_init",
-    "sys_device_register",
-    "sys_device_control",
-    "sys_device_find",
-    "sys_device_open",
-    "sys_device_close",
-    "sys_device_read",
-    "sys_device_write",
-    "sys_stat",
-    "sys_thread_find",
-    "sys_accept",
-    "sys_bind",
-    "sys_shutdown",
-    "sys_getpeername",
-    "sys_getsockname",
-    "sys_getsockopt",
-    "sys_setsockopt",
-    "sys_connect",
-    "sys_listen",
-    "sys_recv",
-    "sys_recvfrom",
-    "sys_send",
-    "sys_sendto",
-    "sys_socket",
-    "sys_closesocket",
-    "sys_getaddrinfo",
-    "sys_gethostbyname2_r",
-    "sys_notimpl",
-    "sys_notimpl",
-    "sys_notimpl",
-    "sys_notimpl",
-    "sys_notimpl",
-    "sys_notimpl",
-    "sys_notimpl",
-    "sys_notimpl",
-    "sys_select",
-    "sys_notimpl",
-    "sys_notimpl",
-    "sys_tick_get",
-    "sys_exit_group",
-    "sys_notimpl",
-    "sys_notimpl",
-    "sys_notimpl",
-    "sys_thread_mdelay",
-    "sys_sigaction",
-    "sys_sigprocmask",
-    "sys_tkill",
-    "sys_thread_sigprocmask",
-    "sys_cacheflush",
-    "sys_notimpl",
-    "sys_notimpl",
-    "sys_waitpid",
-    "sys_timer_create",
-    "sys_timer_delete",
-    "sys_timer_start",
-    "sys_timer_stop",
-    "sys_timer_control",
-    "sys_getcwd",
-    "sys_chdir",
-    "sys_unlink",
-    "sys_mkdir",
-    "sys_rmdir",
-    "sys_getdents",
-    "sys_get_errno",
-    "sys_set_thread_area",
-    "sys_set_tid_address",
-    "sys_access",
-    "sys_pipe",
-    "sys_clock_settime",
-    "sys_clock_gettime",
-    "sys_clock_getres",
-    "sys_clone",
-    "sys_futex",
-    "sys_pmutex",
-    "sys_dup",
-    "sys_dup2",
-    "sys_rename",
-    "sys_fork",
-    "sys_execve",
-    "sys_vfork",
-    "sys_gettid",
-    "sys_prlimit64",
-    "sys_getrlimit",
-    "sys_setrlimit",
-    "sys_setsid",
-    "sys_getrandom",
-    "sys_notimpl",
-    "sys_mremap",
-    "sys_madvise",
-    "sys_sched_setparam",
-    "sys_sched_getparam",
-    "sys_sched_get_priority_max",
-    "sys_sched_get_priority_min",
-    "sys_sched_setscheduler",
-    "sys_sched_getscheduler",
-    "sys_setaffinity",
-    "sys_fsync",
-    [255] = "sys_log"
-};