Changeset e6a78b9 in mainline for kernel/generic/src

Timestamp:

2012-06-29T15:31:44Z (13 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

9432f08

Parents:

34ab31c0 (diff), 0bbd13e (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.

Message:

Merge mainline changes.

Location:

kernel/generic/src

Files:

• adt/btree.c (modified) (1 diff)
• console/cmd.c (modified) (1 diff)
• ipc/ipc.c (modified) (1 diff)
• ipc/kbox.c (modified) (1 diff)
• ipc/sysipc.c (modified) (3 diffs)
• lib/ra.c (modified) (1 diff)
• lib/rd.c (modified) (2 diffs)
• main/kinit.c (modified) (6 diffs)
• main/main.c (modified) (1 diff)
• main/uinit.c (modified) (2 diffs)
• mm/as.c (modified) (1 diff)
• mm/slab.c (modified) (2 diffs)
• proc/program.c (modified) (7 diffs)
• proc/scheduler.c (modified) (6 diffs)
• proc/task.c (modified) (1 diff)
• proc/thread.c (modified) (15 diffs)
• synch/mutex.c (modified) (2 diffs)
• synch/spinlock.c (modified) (1 diff)
• sysinfo/sysinfo.c (modified) (1 diff)
• udebug/udebug.c (modified) (1 diff)
• udebug/udebug_ops.c (modified) (3 diffs)

kernel/generic/src/adt/btree.c

@@ -71 +71 @@
 void btree_init(void)
 {
-        btree_node_slab = slab_cache_create("btree_node_slab",
+        btree_node_slab = slab_cache_create("btree_node_t",
             sizeof(btree_node_t), 0, NULL, NULL, SLAB_CACHE_MAGDEFERRED);
 }

kernel/generic/src/console/cmd.c

@@ -724 +724 @@
                 thread_t *thread;
                 if ((thread = thread_create((void (*)(void *)) cmd_call0,
-                    (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
-                        irq_spinlock_lock(&thread->lock, true);
-                        thread->cpu = &cpus[i];
-                        irq_spinlock_unlock(&thread->lock, true);
-                        
+                    (void *) argv, TASK, THREAD_FLAG_NONE, "call0"))) {
                         printf("cpu%u: ", i);
-                        
+                        thread_wire(thread, &cpus[i]);
                         thread_ready(thread);
                         thread_join(thread);

kernel/generic/src/ipc/ipc.c

@@ -670 +670 @@
 void ipc_init(void)
 {
-        ipc_call_slab = slab_cache_create("ipc_call", sizeof(call_t), 0, NULL,
+        ipc_call_slab = slab_cache_create("call_t", sizeof(call_t), 0, NULL,
             NULL, 0);
-        ipc_answerbox_slab = slab_cache_create("ipc_answerbox",
+        ipc_answerbox_slab = slab_cache_create("answerbox_t",
             sizeof(answerbox_t), 0, NULL, NULL, 0);
 }

kernel/generic/src/ipc/kbox.c

@@ -244 +244 @@
         
         /* Create a kbox thread */
-        thread_t *kb_thread = thread_create(kbox_thread_proc, NULL, task, 0,
-            "kbox", false);
+        thread_t *kb_thread = thread_create(kbox_thread_proc, NULL, task,
+            THREAD_FLAG_NONE, "kbox");
         if (!kb_thread) {
                 mutex_unlock(&task->kb.cleanup_lock);

kernel/generic/src/ipc/sysipc.c

@@ -597 +597 @@
         if (IPC_GET_IMETHOD(call->data) == IPC_M_CONNECT_TO_ME) {
                 int phoneid = phone_alloc(TASK);
-                if (phoneid < 0) { /* Failed to allocate phone */
+                if (phoneid < 0) {  /* Failed to allocate phone */
                         IPC_SET_RETVAL(call->data, ELIMIT);
                         ipc_answer(box, call);
@@ -883 +883 @@
         
         /*
-         * Userspace is not allowed to change interface and method of system
+         * User space is not allowed to change interface and method of system
          * methods on forward, allow changing ARG1, ARG2, ARG3 and ARG4 by
-         * means of method, arg1, arg2 and arg3.
+         * means of imethod, arg1, arg2 and arg3.
          * If the interface and method is immutable, don't change anything.
          */
@@ -897 +897 @@
                         IPC_SET_ARG3(call->data, arg2);
                         
-                        if (slow) {
+                        if (slow)
                                 IPC_SET_ARG4(call->data, arg3);
-                                /*
-                                 * For system methods we deliberately don't
-                                 * overwrite ARG5.
-                                 */
-                        }
+                        
+                        /*
+                         * For system methods we deliberately don't
+                         * overwrite ARG5.
+                         */
                 } else {
                         IPC_SET_IMETHOD(call->data, imethod);

kernel/generic/src/lib/ra.c

@@ -424 +424 @@
 void ra_init(void)
 {
-        ra_segment_cache = slab_cache_create("segment_cache",
+        ra_segment_cache = slab_cache_create("ra_segment_t",
             sizeof(ra_segment_t), 0, NULL, NULL, SLAB_CACHE_MAGDEFERRED);
 }

kernel/generic/src/lib/rd.c

@@ -38 +38 @@
  */
 
+#include <print.h>
 #include <lib/rd.h>
 #include <mm/frame.h>
@@ -66 +67 @@
         sysinfo_set_item_val("rd.size", NULL, size);
         sysinfo_set_item_val("rd.address.physical", NULL, (sysarg_t) base);
+        
+        printf("RAM disk at %p (size %zu bytes)\n", (void *) base, size);
 }
 

kernel/generic/src/main/kinit.c

@@ -116 +116 @@
                  * Just a beautification.
                  */
-                thread = thread_create(kmp, NULL, TASK, THREAD_FLAG_WIRED, "kmp", true);
+                thread = thread_create(kmp, NULL, TASK,
+                    THREAD_FLAG_UNCOUNTED, "kmp");
                 if (thread != NULL) {
-                        irq_spinlock_lock(&thread->lock, false);
-                        thread->cpu = &cpus[0];
-                        irq_spinlock_unlock(&thread->lock, false);
+                        thread_wire(thread, &cpus[0]);
                         thread_ready(thread);
                 } else
@@ -134 +133 @@
                 
                 for (i = 0; i < config.cpu_count; i++) {
-                        thread = thread_create(kcpulb, NULL, TASK, THREAD_FLAG_WIRED, "kcpulb", true);
+                        thread = thread_create(kcpulb, NULL, TASK,
+                            THREAD_FLAG_UNCOUNTED, "kcpulb");
                         if (thread != NULL) {
-                                irq_spinlock_lock(&thread->lock, false);
-                                thread->cpu = &cpus[i];
-                                irq_spinlock_unlock(&thread->lock, false);
+                                thread_wire(thread, &cpus[i]);
                                 thread_ready(thread);
                         } else
@@ -152 +150 @@
         
         /* Start thread computing system load */
-        thread = thread_create(kload, NULL, TASK, 0, "kload", false);
+        thread = thread_create(kload, NULL, TASK, THREAD_FLAG_NONE,
+            "kload");
         if (thread != NULL)
                 thread_ready(thread);
@@ -163 +162 @@
                  * Create kernel console.
                  */
-                thread = thread_create(kconsole_thread, NULL, TASK, 0, "kconsole", false);
+                thread = thread_create(kconsole_thread, NULL, TASK,
+                    THREAD_FLAG_NONE, "kconsole");
                 if (thread != NULL)
                         thread_ready(thread);
@@ -201 +201 @@
                 str_cpy(namebuf + INIT_PREFIX_LEN,
                     TASK_NAME_BUFLEN - INIT_PREFIX_LEN, name);
-
+                
                 /*
                  * Create virtual memory mappings for init task images.
@@ -236 +236 @@
                         init_rd((void *) init.tasks[i].paddr, init.tasks[i].size);
                 } else
-                        printf("init[%zu]: Init binary load failed (error %d)\n", i, rc);
+                        printf("init[%zu]: Init binary load failed "
+                            "(error %d, loader status %u)\n", i, rc,
+                            programs[i].loader_status);
         }
         

kernel/generic/src/main/main.c

@@ -276 +276 @@
          * Create the first thread.
          */
-        thread_t *kinit_thread =
-            thread_create(kinit, NULL, kernel, 0, "kinit", true);
+        thread_t *kinit_thread = thread_create(kinit, NULL, kernel,
+            THREAD_FLAG_UNCOUNTED, "kinit");
         if (!kinit_thread)
                 panic("Cannot create kinit thread.");

kernel/generic/src/main/uinit.c

@@ -56 +56 @@
 void uinit(void *arg)
 {
-        uspace_arg_t uarg;
-        
         /*
          * So far, we don't have a use for joining userspace threads so we
@@ -72 +70 @@
 #endif
         
-        uarg.uspace_entry = ((uspace_arg_t *) arg)->uspace_entry;
-        uarg.uspace_stack = ((uspace_arg_t *) arg)->uspace_stack;
-        uarg.uspace_uarg = ((uspace_arg_t *) arg)->uspace_uarg;
-        uarg.uspace_thread_function = NULL;
-        uarg.uspace_thread_arg = NULL;
+        uspace_arg_t *uarg = (uspace_arg_t *) arg;
+        uspace_arg_t local_uarg;
         
-        free((uspace_arg_t *) arg);
+        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 = NULL;
+        local_uarg.uspace_thread_arg = NULL;
         
-        userspace(&uarg);
+        free(uarg);
+        
+        userspace(&local_uarg);
 }
 

kernel/generic/src/mm/as.c

@@ -130 +130 @@
         as_arch_init();
         
-        as_slab = slab_cache_create("as_slab", sizeof(as_t), 0,
+        as_slab = slab_cache_create("as_t", sizeof(as_t), 0,
             as_constructor, as_destructor, SLAB_CACHE_MAGDEFERRED);
         

kernel/generic/src/mm/slab.c

@@ -891 +891 @@
 {
         /* Initialize magazine cache */
-        _slab_cache_create(&mag_cache, "slab_magazine",
+        _slab_cache_create(&mag_cache, "slab_magazine_t",
             sizeof(slab_magazine_t) + SLAB_MAG_SIZE * sizeof(void*),
             sizeof(uintptr_t), NULL, NULL, SLAB_CACHE_NOMAGAZINE |
@@ -897 +897 @@
         
         /* Initialize slab_cache cache */
-        _slab_cache_create(&slab_cache_cache, "slab_cache",
+        _slab_cache_create(&slab_cache_cache, "slab_cache_cache",
             sizeof(slab_cache_cache), sizeof(uintptr_t), NULL, NULL,
             SLAB_CACHE_NOMAGAZINE | SLAB_CACHE_SLINSIDE);
         
         /* Initialize external slab cache */
-        slab_extern_cache = slab_cache_create("slab_extern", sizeof(slab_t), 0,
+        slab_extern_cache = slab_cache_create("slab_t", sizeof(slab_t), 0,
             NULL, NULL, SLAB_CACHE_SLINSIDE | SLAB_CACHE_MAGDEFERRED);
         

kernel/generic/src/proc/program.c

@@ -71 +71 @@
 int program_create(as_t *as, uintptr_t entry_addr, char *name, program_t *prg)
 {
-        uspace_arg_t *kernel_uarg;
-        
-        kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
-        kernel_uarg->uspace_entry = (void *) entry_addr;
-        kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
-        kernel_uarg->uspace_thread_function = NULL;
-        kernel_uarg->uspace_thread_arg = NULL;
-        kernel_uarg->uspace_uarg = NULL;
-        
+        prg->loader_status = EE_OK;
         prg->task = task_create(as, name);
         if (!prg->task)
@@ -91 +83 @@
             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
             STACK_SIZE, AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, 0);
-        if (!area)
+        if (!area) {
+                task_destroy(prg->task);
                 return ENOMEM;
+        }
+        
+        uspace_arg_t *kernel_uarg = (uspace_arg_t *)
+            malloc(sizeof(uspace_arg_t), 0);
+        
+        kernel_uarg->uspace_entry = (void *) entry_addr;
+        kernel_uarg->uspace_stack = (void *) virt;
+        kernel_uarg->uspace_stack_size = STACK_SIZE;
+        kernel_uarg->uspace_thread_function = NULL;
+        kernel_uarg->uspace_thread_arg = NULL;
+        kernel_uarg->uspace_uarg = NULL;
         
         /*
@@ -98 +102 @@
          */
         prg->main_thread = thread_create(uinit, kernel_uarg, prg->task,
-            THREAD_FLAG_USPACE, "uinit", false);
-        if (!prg->main_thread)
+            THREAD_FLAG_USPACE, "uinit");
+        if (!prg->main_thread) {
+                free(kernel_uarg);
+                as_area_destroy(as, virt);
+                task_destroy(prg->task);
                 return ELIMIT;
+        }
         
         return EOK;
@@ -111 +119 @@
  * executable image. The task is returned in *task.
  *
- * @param image_addr Address of an executable program image.
- * @param name       Name to set for the program's task.
- * @param prg        Buffer for storing program info. If image_addr
- *                   points to a loader image, p->task will be set to
- *                   NULL and EOK will be returned.
+ * @param[in]  image_addr Address of an executable program image.
+ * @param[in]  name       Name to set for the program's task.
+ * @param[out] prg        Buffer for storing program info.
+ *                        If image_addr points to a loader image,
+ *                        prg->task will be set to NULL and EOK
+ *                        will be returned.
  *
  * @return EOK on success or negative error code.
@@ -126 +135 @@
                 return ENOMEM;
         
-        unsigned int rc = elf_load((elf_header_t *) image_addr, as, 0);
-        if (rc != EE_OK) {
+        prg->loader_status = elf_load((elf_header_t *) image_addr, as, 0);
+        if (prg->loader_status != EE_OK) {
                 as_destroy(as);
                 prg->task = NULL;
                 prg->main_thread = NULL;
                 
-                if (rc != EE_LOADER)
+                if (prg->loader_status != EE_LOADER)
                         return ENOTSUP;
                 
@@ -140 +149 @@
                 
                 program_loader = image_addr;
-                LOG("Registered program loader at %p",
-                    (void *) image_addr);
+                printf("Program loader at %p\n", (void *) image_addr);
                 
                 return EOK;
@@ -171 +179 @@
         }
         
-        unsigned int rc = elf_load((elf_header_t *) program_loader, as,
+        prg->loader_status = elf_load((elf_header_t *) program_loader, as,
             ELD_F_LOADER);
-        if (rc != EE_OK) {
+        if (prg->loader_status != EE_OK) {
                 as_destroy(as);
-                printf("Cannot spawn loader (%s)\n", elf_error(rc));
+                printf("Cannot spawn loader (%s)\n",
+                    elf_error(prg->loader_status));
                 return ENOENT;
         }

kernel/generic/src/proc/scheduler.c

@@ -98 +98 @@
         else {
                 fpu_init();
-                THREAD->fpu_context_exists = 1;
+                THREAD->fpu_context_exists = true;
         }
 #endif
@@ -142 +142 @@
                 
                 /* Don't prevent migration */
-                CPU->fpu_owner->fpu_context_engaged = 0;
+                CPU->fpu_owner->fpu_context_engaged = false;
                 irq_spinlock_unlock(&CPU->fpu_owner->lock, false);
                 CPU->fpu_owner = NULL;
@@ -163 +163 @@
                 }
                 fpu_init();
-                THREAD->fpu_context_exists = 1;
+                THREAD->fpu_context_exists = true;
         }
         
         CPU->fpu_owner = THREAD;
-        THREAD->fpu_context_engaged = 1;
+        THREAD->fpu_context_engaged = true;
         irq_spinlock_unlock(&THREAD->lock, false);
         
@@ -248 +248 @@
                 
                 /*
-                 * Clear the THREAD_FLAG_STOLEN flag so that t can be migrated
+                 * Clear the stolen flag so that it can be migrated
                  * when load balancing needs emerge.
                  */
-                thread->flags &= ~THREAD_FLAG_STOLEN;
+                thread->stolen = false;
                 irq_spinlock_unlock(&thread->lock, false);
                 
@@ -630 +630 @@
                                 irq_spinlock_lock(&thread->lock, false);
                                 
-                                if (!(thread->flags & THREAD_FLAG_WIRED) &&
-                                    !(thread->flags & THREAD_FLAG_STOLEN) &&
-                                    !thread->nomigrate &&
-                                    !thread->fpu_context_engaged) {
+                                if ((!thread->wired) && (!thread->stolen) &&
+                                    (!thread->nomigrate) &&
+                                    (!thread->fpu_context_engaged)) {
                                         /*
                                          * Remove thread from ready queue.
@@ -670 +669 @@
 #endif
                                 
-                                thread->flags |= THREAD_FLAG_STOLEN;
+                                thread->stolen = true;
                                 thread->state = Entering;
                                 

kernel/generic/src/proc/task.c

@@ -90 +90 @@
         TASK = NULL;
         avltree_create(&tasks_tree);
-        task_slab = slab_cache_create("task_slab", sizeof(task_t), 0,
+        task_slab = slab_cache_create("task_t", sizeof(task_t), 0,
             tsk_constructor, NULL, 0);
 }

kernel/generic/src/proc/thread.c

@@ -191 +191 @@
         kmflags |= FRAME_LOWMEM;
         kmflags &= ~FRAME_HIGHMEM;
-
+        
         thread->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
         if (!thread->kstack) {
@@ -236 +236 @@
         
         atomic_set(&nrdy, 0);
-        thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0,
+        thread_slab = slab_cache_create("thread_t", sizeof(thread_t), 0,
             thr_constructor, thr_destructor, 0);
         
 #ifdef CONFIG_FPU
-        fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t),
-            FPU_CONTEXT_ALIGN, NULL, NULL, 0);
+        fpu_context_slab = slab_cache_create("fpu_context_t",
+            sizeof(fpu_context_t), FPU_CONTEXT_ALIGN, NULL, NULL, 0);
 #endif
         
@@ -247 +247 @@
 }
 
+/** Wire thread to the given CPU
+ *
+ * @param cpu CPU to wire the thread to.
+ *
+ */
+void thread_wire(thread_t *thread, cpu_t *cpu)
+{
+        irq_spinlock_lock(&thread->lock, true);
+        thread->cpu = cpu;
+        thread->wired = true;
+        irq_spinlock_unlock(&thread->lock, true);
+}
+
 /** Make thread ready
  *
@@ -260 +273 @@
         ASSERT(thread->state != Ready);
         
-        int i = (thread->priority < RQ_COUNT - 1)
-            ? ++thread->priority : thread->priority;
-        
-        cpu_t *cpu = CPU;
-        if (thread->flags & THREAD_FLAG_WIRED) {
+        int i = (thread->priority < RQ_COUNT - 1) ?
+            ++thread->priority : thread->priority;
+        
+        cpu_t *cpu;
+        if (thread->wired || thread->nomigrate || thread->fpu_context_engaged) {
                 ASSERT(thread->cpu != NULL);
                 cpu = thread->cpu;
-        }
+        } else
+                cpu = CPU;
+        
         thread->state = Ready;
         
@@ -298 +313 @@
  * @param flags     Thread flags.
  * @param name      Symbolic name (a copy is made).
- * @param uncounted Thread's accounting doesn't affect accumulated task
- *                  accounting.
  *
  * @return New thread's structure on success, NULL on failure.
@@ -305 +318 @@
  */
 thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
-    unsigned int flags, const char *name, bool uncounted)
+    thread_flags_t flags, const char *name)
 {
         thread_t *thread = (thread_t *) slab_alloc(thread_slab, 0);
@@ -335 +348 @@
         thread->ucycles = 0;
         thread->kcycles = 0;
-        thread->uncounted = uncounted;
+        thread->uncounted =
+            ((flags & THREAD_FLAG_UNCOUNTED) == THREAD_FLAG_UNCOUNTED);
         thread->priority = -1;          /* Start in rq[0] */
         thread->cpu = NULL;
-        thread->flags = flags;
+        thread->wired = false;
+        thread->stolen = false;
+        thread->uspace =
+            ((flags & THREAD_FLAG_USPACE) == THREAD_FLAG_USPACE);
+        
         thread->nomigrate = 0;
         thread->state = Entering;
@@ -356 +374 @@
         thread->task = task;
         
-        thread->fpu_context_exists = 0;
-        thread->fpu_context_engaged = 0;
+        thread->fpu_context_exists = false;
+        thread->fpu_context_engaged = false;
         
         avltree_node_initialize(&thread->threads_tree_node);
@@ -371 +389 @@
         thread_create_arch(thread);
         
-        if (!(flags & THREAD_FLAG_NOATTACH))
+        if ((flags & THREAD_FLAG_NOATTACH) != THREAD_FLAG_NOATTACH)
                 thread_attach(thread, task);
         
@@ -437 +455 @@
         
         /* Must not count kbox thread into lifecount */
-        if (thread->flags & THREAD_FLAG_USPACE)
+        if (thread->uspace)
                 atomic_inc(&task->lifecount);
         
@@ -459 +477 @@
 void thread_exit(void)
 {
-        if (THREAD->flags & THREAD_FLAG_USPACE) {
+        if (THREAD->uspace) {
 #ifdef CONFIG_UDEBUG
                 /* Generate udebug THREAD_E event */
                 udebug_thread_e_event();
-
+                
                 /*
                  * This thread will not execute any code or system calls from
@@ -506 +524 @@
 {
         ASSERT(THREAD);
-
+        
         THREAD->nomigrate++;
 }
@@ -515 +533 @@
         ASSERT(THREAD);
         ASSERT(THREAD->nomigrate > 0);
-
-        THREAD->nomigrate--;
+        
+        if (THREAD->nomigrate > 0)
+                THREAD->nomigrate--;
 }
 
@@ -854 +873 @@
          * In case of failure, kernel_uarg will be deallocated in this function.
          * In case of success, kernel_uarg will be freed in uinit().
-         *
          */
         uspace_arg_t *kernel_uarg =
@@ -866 +884 @@
         
         thread_t *thread = thread_create(uinit, kernel_uarg, TASK,
-            THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf, false);
+            THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf);
         if (thread) {
                 if (uspace_thread_id != NULL) {

kernel/generic/src/synch/mutex.c

@@ -63 +63 @@
 }
 
+#define MUTEX_DEADLOCK_THRESHOLD        100000000
+
 /** Acquire mutex.
  *
@@ -91 +93 @@
                 bool deadlock_reported = false;
                 do {
-                        if (cnt++ > DEADLOCK_THRESHOLD) {
+                        if (cnt++ > MUTEX_DEADLOCK_THRESHOLD) {
                                 printf("cpu%u: looping on active mutex %p\n",
                                     CPU->id, mtx);

kernel/generic/src/synch/spinlock.c

@@ -262 +262 @@
         int rc = spinlock_trylock(&(lock->lock));
         
-        ASSERT_IRQ_SPINLOCK(!rc || !lock->guard, lock);
+        ASSERT_IRQ_SPINLOCK((!rc) || (!lock->guard), lock);
         return rc;
 }

kernel/generic/src/sysinfo/sysinfo.c

@@ -97 +97 @@
 void sysinfo_init(void)
 {
-        sysinfo_item_slab = slab_cache_create("sysinfo_item_slab",
+        sysinfo_item_slab = slab_cache_create("sysinfo_item_t",
             sizeof(sysinfo_item_t), 0, sysinfo_item_constructor,
             sysinfo_item_destructor, SLAB_CACHE_MAGDEFERRED);

kernel/generic/src/udebug/udebug.c

@@ -410 +410 @@
                 
                 mutex_lock(&thread->udebug.lock);
-                unsigned int flags = thread->flags;
                 
                 /* Only process userspace threads. */
-                if ((flags & THREAD_FLAG_USPACE) != 0) {
+                if (thread->uspace) {
                         /* Prevent any further debug activity in thread. */
                         thread->udebug.active = false;

kernel/generic/src/udebug/udebug_ops.c

@@ -95 +95 @@
         
         /* Verify that 'thread' is a userspace thread. */
-        if ((thread->flags & THREAD_FLAG_USPACE) == 0) {
+        if (!thread->uspace) {
                 /* It's not, deny its existence */
                 irq_spinlock_unlock(&thread->lock, true);
@@ -200 +200 @@
                 
                 mutex_lock(&thread->udebug.lock);
-                if ((thread->flags & THREAD_FLAG_USPACE) != 0) {
+                if (thread->uspace) {
                         thread->udebug.active = true;
                         mutex_unlock(&thread->udebug.lock);
@@ -393 +393 @@
                 
                 irq_spinlock_lock(&thread->lock, false);
-                int flags = thread->flags;
+                bool uspace = thread->uspace;
                 irq_spinlock_unlock(&thread->lock, false);
                 
                 /* Not interested in kernel threads. */
-                if ((flags & THREAD_FLAG_USPACE) == 0)
+                if (!uspace)
                         continue;