Changeset df58e44 in mainline for kernel/generic/src/proc

Timestamp:

2011-01-27T16:36:35Z (15 years ago)

Author:

Martin Decky <martin@…>

Branches:

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

Children:

5b7a107

Parents:

0843f02

Message:

• add support for printing uspace stack traces from kernel console (as a last resort debugging means)
• change the semantics of waitq_interrupt_sleep() (require threads_lock to be held even before it is called)
• minor cstyle

Location:

kernel/generic/src/proc

Files:

• scheduler.c (modified) (5 diffs)
• task.c (modified) (2 diffs)
• thread.c (modified) (8 diffs)

kernel/generic/src/proc/scheduler.c

@@ -62 +62 @@
 #include <print.h>
 #include <debug.h>
+#include <stacktrace.h>
 
 static void scheduler_separated_stack(void);
@@ -77 +78 @@
  * Perform actions that need to be
  * taken before the newly selected
- * tread is passed control.
+ * thread is passed control.
  *
  * THREAD->lock is locked on entry
@@ -87 +88 @@
         
 #ifdef CONFIG_FPU_LAZY
-        if(THREAD == CPU->fpu_owner)
+        if (THREAD == CPU->fpu_owner)
                 fpu_enable();
         else
@@ -100 +101 @@
         }
 #endif
+        
+        if (THREAD->btrace) {
+                istate_t *istate = THREAD->udebug.uspace_state;
+                if (istate != NULL) {
+                        printf("Thread %" PRIu64 " stack trace:\n", THREAD->tid);
+                        stack_trace_istate(istate);
+                }
+                
+                THREAD->btrace = false;
+        }
 }
 
@@ -645 +656 @@
                                 /*
                                  * Ready thread on local CPU
-                                 *
                                  */
                                 

kernel/generic/src/proc/task.c

@@ -449 +449 @@
 static void task_kill_internal(task_t *task)
 {
+        irq_spinlock_lock(&task->lock, false);
+        irq_spinlock_lock(&threads_lock, false);
+        
+        /*
+         * Interrupt all threads.
+         */
+        
         link_t *cur;
-        
-        /*
-         * Interrupt all threads.
-         */
-        irq_spinlock_lock(&task->lock, false);
         for (cur = task->th_head.next; cur != &task->th_head; cur = cur->next) {
                 thread_t *thread = list_get_instance(cur, thread_t, th_link);
@@ -471 +473 @@
         }
         
+        irq_spinlock_unlock(&threads_lock, false);
         irq_spinlock_unlock(&task->lock, false);
 }

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)
@@ -338 +338 @@
         
         thread->interrupted = false;
+        thread->btrace = false;
         thread->detached = false;
         waitq_initialize(&thread->join_wq);
@@ -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.
@@ -740 +741 @@
         ASSERT(interrupts_disabled());
         ASSERT(irq_spinlock_locked(&threads_lock));
-
+        
         thread_iterator_t iterator;
         
@@ -751 +752 @@
 }
 
+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);
+}
 
 /** Process syscall to create new thread.
@@ -793 +836 @@
                                  * has already been created. We need to undo its
                                  * creation now.
-                                 *
                                  */
                                 
@@ -815 +857 @@
                  * THREAD_B events for threads that already existed
                  * and could be detected with THREAD_READ before.
-                 *
                  */
                 udebug_thread_b_event_attach(thread, TASK);