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

 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.
+ *
     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();
             LOG("Cleanup of task %" PRIu64" completed.", TASK->taskid);
+        }
+    }
 /** 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/network/kernel/generic/src/proc/thread.c – Rev 3386 → 4153