WebSVN – HelenOS – Diff – //branches/dd/kernel/generic/src/proc/thread.c

 #include <mm/slab.h>
 #include <debug.h>
 #include <main/uinit.h>
 #include <syscall/copy.h>
 #include <errno.h>
-#include <console/klog.h>
+#ifndef LOADED_PROG_STACK_PAGES_NO
+#define LOADED_PROG_STACK_PAGES_NO 1
+#endif
 /** Thread states */
 char *thread_states[] = {
     "Invalid",
 SPINLOCK_INITIALIZE(tidlock);
 thread_id_t last_tid = 0;
 static slab_cache_t *thread_slab;
-#ifdef ARCH_HAS_FPU
+#ifdef CONFIG_FPU
 slab_cache_t *fpu_context_slab;
 #endif
 /** Thread wrapper.
+ *
     link_initialize(&t->th_link);
     /* call the architecture-specific part of the constructor */
     thr_constructor_arch(t);
-#ifdef ARCH_HAS_FPU
+#ifdef CONFIG_FPU
 #ifdef CONFIG_FPU_LAZY
     t->saved_fpu_context = NULL;
 #else
     t->saved_fpu_context = slab_alloc(fpu_context_slab, kmflags);
     if (!t->saved_fpu_context)
         return -1;
 #endif
 #endif
     t->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
     if (!t->kstack) {
-#ifdef ARCH_HAS_FPU
+#ifdef CONFIG_FPU
         if (t->saved_fpu_context)
             slab_free(fpu_context_slab, t->saved_fpu_context);
 #endif
         return -1;
+    }
+#ifdef CONFIG_UDEBUG
+    mutex_initialize(&t->udebug.lock, MUTEX_PASSIVE);
+#endif
     return 0;
+}
 /** Destruction of thread_t object */
 static int thr_destructor(void *obj)
     /* call the architecture-specific part of the destructor */
     thr_destructor_arch(t);
     frame_free(KA2PA(t->kstack));
-#ifdef ARCH_HAS_FPU
+#ifdef CONFIG_FPU
     if (t->saved_fpu_context)
         slab_free(fpu_context_slab, t->saved_fpu_context);
 #endif
     return 1; /* One page freed */
+}
+ *
  */
 void thread_init(void)
+{
     THREAD = NULL;
-    atomic_set(&nrdy,0);
+    atomic_set(&nrdy, 0);
     thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0,
         thr_constructor, thr_destructor, 0);
-#ifdef ARCH_HAS_FPU
+#ifdef CONFIG_FPU
     fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t),
         FPU_CONTEXT_ALIGN, NULL, NULL, 0);
 #endif
     avltree_create(&threads_tree);
  * @param arg       Thread's implementing function argument.
  * @param task      Task to which the thread belongs. The caller must
  *          guarantee that the task won't cease to exist during the
  *          call. The task's lock may not be held.
  * @param flags     Thread flags.
- * @param name      Symbolic name.
+ * @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.
+ *
     t = (thread_t *) slab_alloc(thread_slab, 0);
     if (!t)
         return NULL;
     /* Not needed, but good for debugging */
-    memsetb((uintptr_t) t->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES,
+    memsetb(t->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES, 0);
-);
     ipl = interrupts_disable();
     spinlock_lock(&tidlock);
     t->tid = ++last_tid;
     spinlock_unlock(&tidlock);
     ipl = interrupts_disable();
     t->saved_context.ipl = interrupts_read();
     interrupts_restore(ipl);
     memcpy(t->name, name, THREAD_NAME_BUFLEN);
+    t->name[THREAD_NAME_BUFLEN - 1] = '\0';
     t->thread_code = func;
     t->thread_arg = arg;
     t->ticks = -1;
     t->cycles = 0;
     t->fpu_context_engaged = 0;
     avltree_node_initialize(&t->threads_tree_node);
     t->threads_tree_node.key = (uintptr_t) t;
+#ifdef CONFIG_UDEBUG
+    /* Init debugging stuff */
+    udebug_thread_initialize(&t->udebug);
+#endif
     /* might depend on previous initialization */
     thread_create_arch(t);
     if (!(flags & THREAD_FLAG_NOATTACH))
         thread_attach(t, task);
 void thread_attach(thread_t *t, task_t *task)
+{
     ipl_t ipl;
     /*
-     * Attach to the current task.
+     * Attach to the specified task.
      */
     ipl = interrupts_disable();
     spinlock_lock(&task->lock);
     atomic_inc(&task->refcount);
+    /* Must not count kbox thread into lifecount */
+    if (t->flags & THREAD_FLAG_USPACE)
-    atomic_inc(&task->lifecount);
+        atomic_inc(&task->lifecount);
     list_append(&t->th_link, &task->th_head);
     spinlock_unlock(&task->lock);
     /*
      * Register this thread in the system-wide list.
  */
 void thread_exit(void)
+{
     ipl_t ipl;
+    if (THREAD->flags & THREAD_FLAG_USPACE) {
+#ifdef CONFIG_UDEBUG
+        /* Generate udebug THREAD_E event */
+        udebug_thread_e_event();
+#endif
-    if (atomic_predec(&TASK->lifecount) == 0) {
+        if (atomic_predec(&TASK->lifecount) == 0) {
-        /*
+            /*
-         * We are the last thread in the task that still has not exited.
+             * We are the last userspace thread in the task that
+             * still has not exited. With the exception of the
-         * With the exception of the moment the task was created, new
+             * moment the task was created, new userspace threads
-         * threads can only be created by threads of the same task.
+             * can only be created by threads of the same task.
-         * We are safe to perform cleanup.
+             * We are safe to perform cleanup.
-         */
+             */
-        if (THREAD->flags & THREAD_FLAG_USPACE) {
             ipc_cleanup();
-                futex_cleanup();
+            futex_cleanup();
-            klog_printf("Cleanup of task %llu completed.",
+            LOG("Cleanup of task %" PRIu64" completed.", TASK->taskid);
-                TASK->taskid);
+        }
+    }
 restart:
     ipl = interrupts_disable();
     interrupts_restore(ipl);
+}
 static bool thread_walker(avltree_node_t *node, void *arg)
+{
-    thread_t *t;
-    t = avltree_get_instance(node, thread_t, threads_tree_node);
+    thread_t *t = avltree_get_instance(node, thread_t, threads_tree_node);
     uint64_t cycles;
     char suffix;
     order(t->cycles, &cycles, &suffix);
-    if (sizeof(void *) == 4)
+#ifdef __32_BITS__
-        printf("%-6llu %-10s %#10zx %-8s %#10zx %-3ld %#10zx %#10zx %9llu%c ",
+    printf("%-6" PRIu64" %-10s %10p %-8s %10p %-3" PRIu32 " %10p %10p %9" PRIu64 "%c ",
-            t->tid, t->name, t, thread_states[t->state], t->task,
+        t->tid, t->name, t, thread_states[t->state], t->task,
-            t->task->context, t->thread_code, t->kstack, cycles, suffix);
+        t->task->context, t->thread_code, t->kstack, cycles, suffix);
-    else
+#endif
+#ifdef __64_BITS__
-        printf("%-6llu %-10s %#18zx %-8s %#18zx %-3ld %#18zx %#18zx %9llu%c ",
+    printf("%-6" PRIu64" %-10s %18p %-8s %18p %-3" PRIu32 " %18p %18p %9" PRIu64 "%c ",
-            t->tid, t->name, t, thread_states[t->state], t->task,
+        t->tid, t->name, t, thread_states[t->state], t->task,
-            t->task->context, t->thread_code, t->kstack, cycles, suffix);
+        t->task->context, t->thread_code, t->kstack, cycles, suffix);
+#endif
     if (t->cpu)
-        printf("%-4zd", t->cpu->id);
+        printf("%-4u", t->cpu->id);
     else
         printf("none");
     if (t->state == Sleeping) {
-        if (sizeof(uintptr_t) == 4)
+#ifdef __32_BITS__
-            printf(" %#10zx", t->sleep_queue);
+        printf(" %10p", t->sleep_queue);
-        else
+#endif
+#ifdef __64_BITS__
-            printf(" %#18zx", t->sleep_queue);
+        printf(" %18p", t->sleep_queue);
+#endif
+    }
     printf("\n");
     return true;
     ipl_t ipl;
     /* Messing with thread structures, avoid deadlock */
     ipl = interrupts_disable();
     spinlock_lock(&threads_lock);
-    if (sizeof(uintptr_t) == 4) {
+#ifdef __32_BITS__
-        printf("tid    name       address    state    task       "
+    printf("tid    name       address    state    task       "
-            "ctx code       stack      cycles     cpu  "
+        "ctx code       stack      cycles     cpu  "
-            "waitqueue\n");
+        "waitqueue\n");
-        printf("------ ---------- ---------- -------- ---------- "
+    printf("------ ---------- ---------- -------- ---------- "
-            "--- ---------- ---------- ---------- ---- "
+        "--- ---------- ---------- ---------- ---- "
-            "----------\n");
+        "----------\n");
-    } else {
+#endif
+#ifdef __64_BITS__
-        printf("tid    name       address            state    task               "
+    printf("tid    name       address            state    task               "
-            "ctx code               stack              cycles     cpu  "
+        "ctx code               stack              cycles     cpu  "
-            "waitqueue\n");
+        "waitqueue\n");
-        printf("------ ---------- ------------------ -------- ------------------ "
+    printf("------ ---------- ------------------ -------- ------------------ "
-            "--- ------------------ ------------------ ---------- ---- "
+        "--- ------------------ ------------------ ---------- ---- "
-            "------------------\n");
+        "------------------\n");
-    }
+#endif
     avltree_walk(&threads_tree, thread_walker, NULL);
     spinlock_unlock(&threads_lock);
     interrupts_restore(ipl);
     node = avltree_search(&threads_tree, (avltree_key_t) ((uintptr_t) t));
     return node != NULL;
+}
 /** Update accounting of current thread.
+ *
  * Note that thread_lock on THREAD must be already held and
  * interrupts must be already disabled.
+ *
 /** Process syscall to create new thread.
+ *
  */
 unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
-    thread_id_t *uspace_thread_id)
+    size_t name_len, thread_id_t *uspace_thread_id)
+{
     thread_t *t;
     char namebuf[THREAD_NAME_BUFLEN];
     uspace_arg_t *kernel_uarg;
     int rc;
+    if (name_len > THREAD_NAME_BUFLEN - 1)
+        name_len = THREAD_NAME_BUFLEN - 1;
-    rc = copy_from_uspace(namebuf, uspace_name, THREAD_NAME_BUFLEN);
+    rc = copy_from_uspace(namebuf, uspace_name, name_len);
     if (rc != 0)
         return (unative_t) rc;
+    namebuf[name_len] = '\0';
     /*
      * In case of failure, kernel_uarg will be deallocated in this function.
      * In case of success, kernel_uarg will be freed in uinit().
      */
     kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
                 free(kernel_uarg);
                 return (unative_t) rc;
+             }
+        }
+#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(t, TASK);
+#else
         thread_attach(t, TASK);
+#endif
         thread_ready(t);
         return 0;
     } else
         free(kernel_uarg);

Subversion Repositories HelenOS

(root)//branches/dd/kernel/generic/src/proc/thread.c – Rev 3022 → 4055