Changeset 3fcea34 in mainline for uspace/lib/c/generic

Timestamp:

2024-09-20T12:16:28Z (10 months ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

master

Children:

d3109ff

Parents:

2cf8f994

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2024-09-20 11:42:13)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2024-09-20 12:16:28)

Message:

Simplify the SYS_THREAD_CREATE syscall interface

Removed the beefy uarg structure. Instead, the syscall gets two
parameters: %pc (program counter) and %sp (stack pointer). It starts
a thread with those values in corresponding registers, with no other
fuss whatsoever.

libc initializes threads by storing any other needed arguments on
the stack and retrieving them in thread_entry. Importantly, this
includes the address of the thread_main function which is now
called indirectly to fix dynamic linking issues on some archs.

There's a bit of weirdness on SPARC and IA-64, because of their
stacked register handling. The current solution is that we require
some space *above* the stack pointer to be available for those
architectures. I think for SPARC, it can be made more normal.

For the remaining ones, we can (probably) just set the initial
%sp to the top edge of the stack. There's some lingering offsets
on some archs just because I didn't want to accidentally break
anything. The initial thread bringup should be functionally
unchanged from the previous state, and no binaries are currently
multithreaded except thread1 test, so there should be minimal
risk of breakage. Naturally, I tested all available emulator
builds, save for msim.

Location:

uspace/lib/c/generic

Files:

• private/fibril.h (modified) (2 diffs)
• private/thread.h (modified) (1 diff)
• thread/fibril.c (modified) (2 diffs)
• thread/thread.c (modified) (6 diffs)

uspace/lib/c/generic/private/fibril.h

@@ -33 +33 @@
 #include <context.h>
 #include <tls.h>
-#include <abi/proc/uarg.h>
 #include <fibril.h>
 #include <ipc/common.h>
@@ -50 +49 @@
         context_t ctx;
 
-        uspace_arg_t uarg;
         link_t link;
         void *stack;

uspace/lib/c/generic/private/thread.h

@@ -37 +37 @@
 
 #include <time.h>
-#include <abi/proc/uarg.h>
 #include <libarch/thread.h>
 #include <abi/proc/thread.h>
 
 extern void __thread_entry(void);
-extern void __thread_main(uspace_arg_t *);
 
-extern errno_t thread_create(void (*)(void *), void *, const char *,
-    thread_id_t *);
+extern errno_t thread_create(errno_t (*)(void *), void *, const char *);
 extern void thread_exit(int) __attribute__((noreturn));
-extern void thread_detach(thread_id_t);
 extern thread_id_t thread_get_id(void);
 extern void thread_usleep(usec_t);

uspace/lib/c/generic/thread/fibril.c

@@ -781 +781 @@
 }
 
-static void _runner_fn(void *arg)
+static errno_t _runner_fn(void *arg)
 {
         _helper_fibril_fn(arg);
+        return EOK;
 }
 
@@ -808 +809 @@
 
         for (int i = 0; i < n; i++) {
-                thread_id_t tid;
-                rc = thread_create(_runner_fn, NULL, "fibril runner", &tid);
+                rc = thread_create(_runner_fn, NULL, "fibril runner");
                 if (rc != EOK)
                         return i;
-                thread_detach(tid);
         }
 

uspace/lib/c/generic/thread/thread.c

@@ -37 +37 @@
 #include <stdlib.h>
 #include <libarch/faddr.h>
-#include <abi/proc/uarg.h>
 #include <fibril.h>
 #include <stack.h>
@@ -54 +53 @@
  * and exit when thread returns back.
  *
- * @param uarg Pointer to userspace argument structure.
+ * @param arg Fibril pointer.
  *
  */
-void __thread_main(uspace_arg_t *uarg)
+static void __thread_main(void *arg)
 {
+        fibril_t *fibril = arg;
+
         assert(!__tcb_is_set());
-
-        fibril_t *fibril = uarg->uspace_thread_arg;
         assert(fibril);
 
         __tcb_set(fibril->tcb);
 
-        uarg->uspace_thread_function(fibril->arg);
+        fibril->func(fibril->arg);
         /*
          * XXX: we cannot free the userspace stack while running on it
@@ -90 +89 @@
  * @return Zero on success or a code from @ref errno.h on failure.
  */
-errno_t thread_create(void (*function)(void *), void *arg, const char *name,
-    thread_id_t *tid)
+errno_t thread_create(errno_t (*func)(void *), void *arg, const char *name)
 {
-        uspace_arg_t *uarg = calloc(1, sizeof(uspace_arg_t));
-        if (!uarg)
+        fibril_t *fibril = fibril_alloc();
+        if (!fibril)
                 return ENOMEM;
 
-        fibril_t *fibril = fibril_alloc();
-        if (!fibril) {
-                free(uarg);
-                return ENOMEM;
-        }
+        fibril->func = func;
+        fibril->arg = arg;
 
         size_t stack_size = stack_size_get();
@@ -109 +104 @@
         if (stack == AS_MAP_FAILED) {
                 fibril_teardown(fibril);
-                free(uarg);
                 return ENOMEM;
         }
 
-        fibril->arg = arg;
-        uarg->uspace_entry = (void *) FADDR(__thread_entry);
-        uarg->uspace_stack = stack;
-        uarg->uspace_stack_size = stack_size;
-        uarg->uspace_thread_function = function;
-        uarg->uspace_thread_arg = fibril;
-        uarg->uspace_uarg = uarg;
+        uintptr_t sp = arch_thread_prepare(stack, stack_size, __thread_main,
+            fibril);
 
-        errno_t rc = (errno_t) __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg,
-            (sysarg_t) name, (sysarg_t) str_size(name), (sysarg_t) tid);
+        errno_t rc = (errno_t) __SYSCALL4(SYS_THREAD_CREATE,
+            (sysarg_t) FADDR(__thread_entry), sp,
+            (sysarg_t) name, (sysarg_t) str_size(name));
 
         if (rc != EOK) {
@@ -130 +120 @@
                  */
                 as_area_destroy(stack);
-                free(uarg);
         }
 
@@ -148 +137 @@
         while (true)
                 ;
-}
-
-/** Detach thread.
- *
- * Currently not implemented.
- *
- * @param thread TID.
- */
-void thread_detach(thread_id_t thread)
-{
 }