Changeset ebb1489 in mainline for kernel/generic/src/proc/thread.c

Timestamp:

2024-10-13T08:23:40Z (8 weeks ago)

Author:

GitHub <noreply@…>

Children:

0472cf17

Parents:

2a0c827c (diff), b3b79981 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

boba-buba <120932204+boba-buba@…> (2024-10-13 08:23:40)

git-committer:

GitHub <noreply@…> (2024-10-13 08:23:40)

Message:

Merge branch 'HelenOS:master' into topic/packet-capture

File:

• kernel/generic/src/proc/thread.c (modified) (2 diffs)

kernel/generic/src/proc/thread.c

@@ -944 +944 @@
 
 /** Process syscall to create new thread.
- *
- */
-sys_errno_t sys_thread_create(uspace_ptr_uspace_arg_t uspace_uarg, uspace_ptr_char uspace_name,
-    size_t name_len, uspace_ptr_thread_id_t uspace_thread_id)
+ * The started thread will have initial pc and sp set to the exact values passed
+ * to the syscall. The kernel will not touch any stack data below the stack
+ * pointer, but some architectures may require some space to be available
+ * for use above it. See userspace() in kernel, and <libarch/thread.h> in libc.
+ *
+ */
+sys_errno_t sys_thread_create(sysarg_t pc, sysarg_t sp,
+    uspace_ptr_char uspace_name, size_t name_len)
 {
         if (name_len > THREAD_NAME_BUFLEN - 1)
@@ -963 +967 @@
          * In case of success, kernel_uarg will be freed in uinit().
          */
-        uspace_arg_t *kernel_uarg =
-            (uspace_arg_t *) malloc(sizeof(uspace_arg_t));
+        uinit_arg_t *kernel_uarg = malloc(sizeof(uinit_arg_t));
         if (!kernel_uarg)
                 return (sys_errno_t) ENOMEM;
 
-        rc = copy_from_uspace(kernel_uarg, uspace_uarg, sizeof(uspace_arg_t));
-        if (rc != EOK) {
-                free(kernel_uarg);
-                return (sys_errno_t) rc;
-        }
+        kernel_uarg->pc = pc;
+        kernel_uarg->sp = sp;
+
+        // TODO: fix some unnecessary inconsistencies between architectures
 
         thread_t *thread = thread_create(uinit, kernel_uarg, TASK,
             THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf);
-        if (thread) {
-                if (uspace_thread_id) {
-                        rc = copy_to_uspace(uspace_thread_id, &thread->tid,
-                            sizeof(thread->tid));
-                        if (rc != EOK) {
-                                /*
-                                 * We have encountered a failure, but the thread
-                                 * has already been created. We need to undo its
-                                 * creation now.
-                                 */
-
-                                /*
-                                 * The new thread structure is initialized, but
-                                 * is still not visible to the system.
-                                 * We can safely deallocate it.
-                                 */
-                                slab_free(thread_cache, thread);
-                                free(kernel_uarg);
-
-                                return (sys_errno_t) rc;
-                        }
-                }
+        if (!thread) {
+                free(kernel_uarg);
+                return (sys_errno_t) ENOMEM;
+        }
 
 #ifdef CONFIG_UDEBUG
-                /*
-                 * Generate udebug THREAD_B event and attach the thread.
-                 * This must be done atomically (with the debug locks held),
-                 * otherwise we would either miss some thread or receive
-                 * THREAD_B events for threads that already existed
-                 * and could be detected with THREAD_READ before.
-                 */
-                udebug_thread_b_event_attach(thread, TASK);
+        /*
+         * Generate udebug THREAD_B event and attach the thread.
+         * This must be done atomically (with the debug locks held),
+         * otherwise we would either miss some thread or receive
+         * THREAD_B events for threads that already existed
+         * and could be detected with THREAD_READ before.
+         */
+        udebug_thread_b_event_attach(thread, TASK);
 #else
-                thread_attach(thread, TASK);
+        thread_attach(thread, TASK);
 #endif
-                thread_start(thread);
-                thread_put(thread);
-
-                return 0;
-        } else
-                free(kernel_uarg);
-
-        return (sys_errno_t) ENOMEM;
+        thread_start(thread);
+        thread_put(thread);
+
+        return (sys_errno_t) EOK;
 }