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

Timestamp:

2011-06-01T08:43:42Z (14 years ago)

Author:

Lubos Slovak <lubos.slovak@…>

Branches:

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

Children:

8d6c1f1

Parents:

9e2e715 (diff), e51a514 (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:

Huuuuuge merge from development - all the work actually

File:

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

kernel/generic/src/proc/thread.c

@@ -239 +239 @@
  * Switch thread to the ready state.
  *
- * @param t Thread to make ready.
+ * @param thread Thread to make ready.
  *
  */
@@ -246 +246 @@
         irq_spinlock_lock(&thread->lock, true);
         
-        ASSERT(!(thread->state == Ready));
+        ASSERT(thread->state != Ready);
         
         int i = (thread->priority < RQ_COUNT - 1)
@@ -350 +350 @@
         
 #ifdef CONFIG_UDEBUG
-        /* Init debugging stuff */
+        /* Initialize debugging stuff */
+        thread->btrace = false;
         udebug_thread_initialize(&thread->udebug);
 #endif
@@ -535 +536 @@
 /** Detach thread.
  *
- * Mark the thread as detached, if the thread is already in the Lingering
- * state, deallocate its resources.
+ * Mark the thread as detached. If the thread is already
+ * in the Lingering state, deallocate its resources.
  *
  * @param thread Thread to be detached.
@@ -590 +591 @@
         order_suffix(thread->kcycles, &kcycles, &ksuffix);
         
+        char *name;
+        if (str_cmp(thread->name, "uinit") == 0)
+                name = thread->task->name;
+        else
+                name = thread->name;
+        
 #ifdef __32_BITS__
         if (*additional)
-                printf("%-8" PRIu64" %10p %9" PRIu64 "%c %9" PRIu64 "%c ",
-                    thread->tid, thread->kstack, ucycles, usuffix,
-                    kcycles, ksuffix);
+                printf("%-8" PRIu64 " %10p %10p %9" PRIu64 "%c %9" PRIu64 "%c ",
+                    thread->tid, thread->thread_code, thread->kstack,
+                    ucycles, usuffix, kcycles, ksuffix);
         else
-                printf("%-8" PRIu64" %-14s %10p %-8s %10p %-5" PRIu32 " %10p\n",
-                    thread->tid, thread->name, thread, thread_states[thread->state],
-                    thread->task, thread->task->context, thread->thread_code);
+                printf("%-8" PRIu64 " %-14s %10p %-8s %10p %-5" PRIu32 "\n",
+                    thread->tid, name, thread, thread_states[thread->state],
+                    thread->task, thread->task->context);
 #endif
         
 #ifdef __64_BITS__
         if (*additional)
-                printf("%-8" PRIu64" %18p %18p\n"
+                printf("%-8" PRIu64 " %18p %18p\n"
                     "         %9" PRIu64 "%c %9" PRIu64 "%c ",
                     thread->tid, thread->thread_code, thread->kstack,
                     ucycles, usuffix, kcycles, ksuffix);
         else
-                printf("%-8" PRIu64" %-14s %18p %-8s %18p %-5" PRIu32 "\n",
-                    thread->tid, thread->name, thread, thread_states[thread->state],
+                printf("%-8" PRIu64 " %-14s %18p %-8s %18p %-5" PRIu32 "\n",
+                    thread->tid, name, thread, thread_states[thread->state],
                     thread->task, thread->task->context);
 #endif
@@ -647 +654 @@
 #ifdef __32_BITS__
         if (additional)
-                printf("[id    ] [stack   ] [ucycles ] [kcycles ] [cpu]"
-                    " [waitqueue]\n");
+                printf("[id    ] [code    ] [stack   ] [ucycles ] [kcycles ]"
+                    " [cpu] [waitqueue]\n");
         else
                 printf("[id    ] [name        ] [address ] [state ] [task    ]"
-                    " [ctx] [code    ]\n");
+                    " [ctx]\n");
 #endif
         
@@ -740 +747 @@
         ASSERT(interrupts_disabled());
         ASSERT(irq_spinlock_locked(&threads_lock));
-
+        
         thread_iterator_t iterator;
         
@@ -751 +758 @@
 }
 
+#ifdef CONFIG_UDEBUG
+
+void thread_stack_trace(thread_id_t thread_id)
+{
+        irq_spinlock_lock(&threads_lock, true);
+        
+        thread_t *thread = thread_find_by_id(thread_id);
+        if (thread == NULL) {
+                printf("No such thread.\n");
+                irq_spinlock_unlock(&threads_lock, true);
+                return;
+        }
+        
+        irq_spinlock_lock(&thread->lock, false);
+        
+        /*
+         * Schedule a stack trace to be printed
+         * just before the thread is scheduled next.
+         *
+         * If the thread is sleeping then try to interrupt
+         * the sleep. Any request for printing an uspace stack
+         * trace from within the kernel should be always
+         * considered a last resort debugging means, therefore
+         * forcing the thread's sleep to be interrupted
+         * is probably justifiable.
+         */
+        
+        bool sleeping = false;
+        istate_t *istate = thread->udebug.uspace_state;
+        if (istate != NULL) {
+                printf("Scheduling thread stack trace.\n");
+                thread->btrace = true;
+                if (thread->state == Sleeping)
+                        sleeping = true;
+        } else
+                printf("Thread interrupt state not available.\n");
+        
+        irq_spinlock_unlock(&thread->lock, false);
+        
+        if (sleeping)
+                waitq_interrupt_sleep(thread);
+        
+        irq_spinlock_unlock(&threads_lock, true);
+}
+
+#endif /* CONFIG_UDEBUG */
 
 /** Process syscall to create new thread.
  *
  */
-unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
+sysarg_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
     size_t name_len, thread_id_t *uspace_thread_id)
 {
@@ -764 +817 @@
         int rc = copy_from_uspace(namebuf, uspace_name, name_len);
         if (rc != 0)
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         
         namebuf[name_len] = 0;
@@ -779 +832 @@
         if (rc != 0) {
                 free(kernel_uarg);
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         }
         
@@ -793 +846 @@
                                  * has already been created. We need to undo its
                                  * creation now.
-                                 *
                                  */
                                 
@@ -804 +856 @@
                                 free(kernel_uarg);
                                 
-                                return (unative_t) rc;
+                                return (sysarg_t) rc;
                          }
                 }
@@ -815 +867 @@
                  * THREAD_B events for threads that already existed
                  * and could be detected with THREAD_READ before.
-                 *
                  */
                 udebug_thread_b_event_attach(thread, TASK);
@@ -827 +878 @@
                 free(kernel_uarg);
         
-        return (unative_t) ENOMEM;
+        return (sysarg_t) ENOMEM;
 }
 
@@ -833 +884 @@
  *
  */
-unative_t sys_thread_exit(int uspace_status)
+sysarg_t sys_thread_exit(int uspace_status)
 {
         thread_exit();
@@ -849 +900 @@
  *
  */
-unative_t sys_thread_get_id(thread_id_t *uspace_thread_id)
+sysarg_t sys_thread_get_id(thread_id_t *uspace_thread_id)
 {
         /*
@@ -856 +907 @@
          *
          */
-        return (unative_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
+        return (sysarg_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
             sizeof(THREAD->tid));
 }
 
 /** Syscall wrapper for sleeping. */
-unative_t sys_thread_usleep(uint32_t usec)
+sysarg_t sys_thread_usleep(uint32_t usec)
 {
         thread_usleep(usec);
@@ -867 +918 @@
 }
 
+sysarg_t sys_thread_udelay(uint32_t usec)
+{
+        asm_delay_loop(usec * CPU->delay_loop_const);
+        return 0;
+}
+
 /** @}
  */