Changeset ebb1489 in mainline for kernel/generic/src

Timestamp:

2024-10-13T08:23:40Z (19 months ago)

Author:

GitHub <noreply@…>

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

Location:

kernel/generic/src

Files:

• lib/ubsan.c (modified) (2 diffs)
• main/kinit.c (modified) (1 diff)
• main/uinit.c (modified) (1 diff)
• mm/malloc.c (modified) (1 diff)
• proc/program.c (modified) (3 diffs)
• proc/thread.c (modified) (2 diffs)

kernel/generic/src/lib/ubsan.c

@@ -13 +13 @@
 
 #define PRINTF(...) printf(__VA_ARGS__)
-#define ubsan_panic() panic("... aborting ...")
 
 struct source_location {
@@ -115 +114 @@
 void __ubsan_handle_builtin_unreachable(struct unreachable_data *data);
 
+/* A real function for potential breakpoint location. */
+__attribute__((noinline))
+    static void ubsan_panic(void)
+{
+        panic("... aborting ...");
+}
+
 static void print_loc(const char *func, struct source_location *loc)
 {

kernel/generic/src/main/kinit.c

@@ -296 +296 @@
                         }
 
-                } else if (i == init.cnt - 1) {
-                        /*
-                         * Assume the last task is the RAM disk.
-                         */
+                } else if (str_cmp(name, "initrd.img") == 0) {
                         init_rd((void *) init.tasks[i].paddr, init.tasks[i].size);
                 } else {

kernel/generic/src/main/uinit.c

@@ -60 +60 @@
 #endif
 
-        uspace_arg_t *uarg = arg;
-        uspace_arg_t local_uarg;
-
-        local_uarg.uspace_entry = uarg->uspace_entry;
-        local_uarg.uspace_stack = uarg->uspace_stack;
-        local_uarg.uspace_stack_size = uarg->uspace_stack_size;
-        local_uarg.uspace_uarg = uarg->uspace_uarg;
-        local_uarg.uspace_thread_function = USPACE_NULL;
-        local_uarg.uspace_thread_arg = USPACE_NULL;
-
+        uinit_arg_t *uarg = arg;
+        sysarg_t pc = uarg->pc;
+        sysarg_t sp = uarg->sp;
         free(uarg);
 
-        userspace(&local_uarg);
+        userspace(pc, sp);
 }
 

kernel/generic/src/mm/malloc.c

@@ -211 +211 @@
 void *realloc(void *old_obj, size_t new_size)
 {
+        if (new_size == 0)
+                new_size = 1;
+
         if (!old_obj)
                 return malloc(new_size);

kernel/generic/src/proc/program.c

@@ -53 +53 @@
 #include <syscall/copy.h>
 #include <proc/program.h>
+#include <userspace.h>
 
 /**
@@ -72 +73 @@
 errno_t program_create(as_t *as, uspace_addr_t entry_addr, char *name, program_t *prg)
 {
-        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 ENOMEM;
@@ -104 +104 @@
         }
 
-        kernel_uarg->uspace_entry = entry_addr;
-        kernel_uarg->uspace_stack = virt;
-        kernel_uarg->uspace_stack_size = STACK_SIZE_USER;
-        kernel_uarg->uspace_thread_function = USPACE_NULL;
-        kernel_uarg->uspace_thread_arg = USPACE_NULL;
-        kernel_uarg->uspace_uarg = USPACE_NULL;
+        kernel_uarg->pc = entry_addr;
+        kernel_uarg->sp = arch_get_initial_sp(virt, STACK_SIZE_USER);
 
         /*

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;
 }