Add U-mode safe output syscall

User mode tasks cannot directly use the standard output functions because
the logger system requires privileged operations for synchronization. When
user mode code attempts these operations, the processor triggers illegal
instruction exceptions that prevent normal execution.

To address this limitation, a new system call interface provides safe
output capabilities for user mode tasks. The implementation splits the
work between user and machine modes: formatting occurs in user space
using only unprivileged operations, while the actual output is performed
through a system call that executes in machine mode where privileged
operations are permitted. The kernel handles all synchronization and
hardware access transparently, allowing user mode tasks to produce output
without violating privilege boundaries.

Author: HeatCrab

include/lib/libc.h

@@ -153,3 +153,9 @@ char *getline(char *s);
 int32_t printf(const char *fmt, ...);
 int32_t snprintf(char *str, size_t size, const char *fmt, ...);
 int vsnprintf(char *str, size_t size, const char *fmt, va_list args);
+
+/* User mode safe formatted output.
+ * Similar to printf but safe for U-mode tasks - formats in user space
+ * then uses syscall to output, avoiding privilege violations.
+ */
+int32_t umode_printf(const char *fmt, ...);

include/sys/syscall.h

@@ -48,7 +48,8 @@
     _(twfi, 40, int, (void) )                                \
     _(tcount, 41, int, (void) )                              \
     _(ticks, 42, int, (void) )                               \
-    _(uptime, 43, int, (void) )
+    _(uptime, 43, int, (void) )                              \
+    _(tputs, 44, int, (const char *str))
 
 /* Generate enumeration of system call numbers */
 #define _(name, num, rettype, arglist) SYS_##name = num,

kernel/syscall.c

@@ -382,3 +382,21 @@ int sys_uptime(void)
 {
     return syscall(SYS_uptime, 0, 0, 0);
 }
+
+/* User mode safe output syscall.
+ * Outputs a string from user mode by executing puts() in kernel context.
+ * This avoids privilege violations from printf's logger mutex operations.
+ */
+static int _tputs(const char *str)
+{
+    if (unlikely(!str))
+        return -EINVAL;
+
+    /* Use puts() which will handle logger enqueue or direct output */
+    return puts(str);
+}
+
+int sys_tputs(const char *str)
+{
+    return syscall(SYS_tputs, (void *) str, 0, 0);
+}

lib/stdio.c

@@ -446,3 +446,32 @@ char *getline(char *s)
 
     return s;
 }
+
+/* User mode safe formatted output.
+ * Formats string in user space using vsnprintf, then outputs via syscall.
+ * This avoids privilege violations from printf's logger mutex operations.
+ *
+ * Safe for U-mode tasks because:
+ * 1. vsnprintf runs in user space (no privileged operations)
+ * 2. sys_tputs syscall transitions to M-mode for actual output
+ * 3. Kernel handles logger mutex/direct output decision
+ */
+int32_t umode_printf(const char *fmt, ...)
+{
+    char buf[256]; /* Stack buffer for formatted output */
+    va_list args;
+
+    va_start(args, fmt);
+    int32_t len = vsnprintf(buf, sizeof(buf), fmt, args);
+    va_end(args);
+
+    /* Handle vsnprintf error */
+    if (len < 0)
+        return len;
+
+    /* Output via syscall - safe for U-mode */
+    extern int sys_tputs(const char *str);
+    sys_tputs(buf);
+
+    return len;
+}