Changeset 875c629 in mainline for kernel/generic/src/proc


Ignore:
Timestamp:
2011-01-27T17:19:49Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
577f042a, f579760
Parents:
bf75e3cb (diff), 5b7a107 (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 'btrace' kernel console command (a last resort debugging means for printing uspace stack traces from within kernel console)

Location:
kernel/generic/src/proc
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/proc/scheduler.c

    rbf75e3cb r875c629  
    6262#include <print.h>
    6363#include <debug.h>
    64 
    65 static void before_task_runs(void);
    66 static void before_thread_runs(void);
    67 static void after_thread_ran(void);
     64#include <stacktrace.h>
     65
    6866static void scheduler_separated_stack(void);
    6967
    … …  
    7169
    7270/** Carry out actions before new task runs. */
    73 void before_task_runs(void)
     71static void before_task_runs(void)
    7472{
    7573        before_task_runs_arch();
    … …  
    8078 * Perform actions that need to be
    8179 * taken before the newly selected
    82  * tread is passed control.
     80 * thread is passed control.
    8381 *
    8482 * THREAD->lock is locked on entry
    8583 *
    8684 */
    87 void before_thread_runs(void)
     85static void before_thread_runs(void)
    8886{
    8987        before_thread_runs_arch();
     88       
    9089#ifdef CONFIG_FPU_LAZY
    91         if(THREAD == CPU->fpu_owner)
     90        if (THREAD == CPU->fpu_owner)
    9291                fpu_enable();
    9392        else
    … …  
    102101        }
    103102#endif
     103       
     104#ifdef CONFIG_UDEBUG
     105        if (THREAD->btrace) {
     106                istate_t *istate = THREAD->udebug.uspace_state;
     107                if (istate != NULL) {
     108                        printf("Thread %" PRIu64 " stack trace:\n", THREAD->tid);
     109                        stack_trace_istate(istate);
     110                }
     111               
     112                THREAD->btrace = false;
     113        }
     114#endif
    104115}
    105116
    … …  
    113124 *
    114125 */
    115 void after_thread_ran(void)
     126static void after_thread_ran(void)
    116127{
    117128        after_thread_ran_arch();
    … …  
    391402         * possible destruction should thread_destroy() be called on this or any
    392403         * other processor while the scheduler is still using them.
    393          *
    394404         */
    395405        if (old_task)
    … …  
    417427                                 * The thread structure is kept allocated until
    418428                                 * somebody calls thread_detach() on it.
    419                                  *
    420429                                 */
    421430                                if (!irq_spinlock_trylock(&THREAD->join_wq.lock)) {
    422431                                        /*
    423432                                         * Avoid deadlock.
    424                                          *
    425433                                         */
    426434                                        irq_spinlock_unlock(&THREAD->lock, false);
    … …  
    443451                        /*
    444452                         * Prefer the thread after it's woken up.
    445                          *
    446453                         */
    447454                        THREAD->priority = -1;
    … …  
    451458                         * waitq_sleep(). Address of wq->lock is kept in
    452459                         * THREAD->sleep_queue.
    453                          *
    454460                         */
    455461                        irq_spinlock_unlock(&THREAD->sleep_queue->lock, false);
    … …  
    461467                        /*
    462468                         * Entering state is unexpected.
    463                          *
    464469                         */
    465470                        panic("tid%" PRIu64 ": unexpected state %s.",
    … …  
    480485       
    481486        /*
    482          * If both the old and the new task are the same, lots of work is
    483          * avoided.
    484          *
     487         * If both the old and the new task are the same,
     488         * lots of work is avoided.
    485489         */
    486490        if (TASK != THREAD->task) {
    … …  
    488492               
    489493                /*
    490                  * Note that it is possible for two tasks to share one address
    491                  * space.
    492                  (
     494                 * Note that it is possible for two tasks
     495                 * to share one address space.
    493496                 */
    494497                if (old_as != new_as) {
    … …  
    496499                         * Both tasks and address spaces are different.
    497500                         * Replace the old one with the new one.
    498                          *
    499501                         */
    500502                        as_switch(old_as, new_as);
    … …  
    527529         * necessary, is to be mapped in before_thread_runs(). This
    528530         * function must be executed before the switch to the new stack.
    529          *
    530531         */
    531532        before_thread_runs();
    … …  
    534535         * Copy the knowledge of CPU, TASK, THREAD and preemption counter to
    535536         * thread's stack.
    536          *
    537537         */
    538538        the_copy(THE, (the_t *) THREAD->kstack);
    … …  
    658658                                /*
    659659                                 * Ready thread on local CPU
    660                                  *
    661660                                 */
    662661                               

  • kernel/generic/src/proc/task.c

    rbf75e3cb r875c629  
    449449static void task_kill_internal(task_t *task)
    450450{
     451        irq_spinlock_lock(&task->lock, false);
     452        irq_spinlock_lock(&threads_lock, false);
     453       
     454        /*
     455         * Interrupt all threads.
     456         */
     457       
    451458        link_t *cur;
    452        
    453         /*
    454          * Interrupt all threads.
    455          */
    456         irq_spinlock_lock(&task->lock, false);
    457459        for (cur = task->th_head.next; cur != &task->th_head; cur = cur->next) {
    458460                thread_t *thread = list_get_instance(cur, thread_t, th_link);
    … …  
    471473        }
    472474       
     475        irq_spinlock_unlock(&threads_lock, false);
    473476        irq_spinlock_unlock(&task->lock, false);
    474477}

  • kernel/generic/src/proc/thread.c

    rbf75e3cb r875c629  
    239239 * Switch thread to the ready state.
    240240 *
    241  * @param t Thread to make ready.
     241 * @param thread Thread to make ready.
    242242 *
    243243 */
    … …  
    246246        irq_spinlock_lock(&thread->lock, true);
    247247       
    248         ASSERT(!(thread->state == Ready));
     248        ASSERT(thread->state != Ready);
    249249       
    250250        int i = (thread->priority < RQ_COUNT - 1)
    … …  
    350350       
    351351#ifdef CONFIG_UDEBUG
    352         /* Init debugging stuff */
     352        /* Initialize debugging stuff */
     353        thread->btrace = false;
    353354        udebug_thread_initialize(&thread->udebug);
    354355#endif
    … …  
    535536/** Detach thread.
    536537 *
    537  * Mark the thread as detached, if the thread is already in the Lingering
    538  * state, deallocate its resources.
     538 * Mark the thread as detached. If the thread is already
     539 * in the Lingering state, deallocate its resources.
    539540 *
    540541 * @param thread Thread to be detached.
    … …  
    740741        ASSERT(interrupts_disabled());
    741742        ASSERT(irq_spinlock_locked(&threads_lock));
    742 
     743       
    743744        thread_iterator_t iterator;
    744745       
    … …  
    751752}
    752753
     754#ifdef CONFIG_UDEBUG
     755
     756void thread_stack_trace(thread_id_t thread_id)
     757{
     758        irq_spinlock_lock(&threads_lock, true);
     759       
     760        thread_t *thread = thread_find_by_id(thread_id);
     761        if (thread == NULL) {
     762                printf("No such thread.\n");
     763                irq_spinlock_unlock(&threads_lock, true);
     764                return;
     765        }
     766       
     767        irq_spinlock_lock(&thread->lock, false);
     768       
     769        /*
     770         * Schedule a stack trace to be printed
     771         * just before the thread is scheduled next.
     772         *
     773         * If the thread is sleeping then try to interrupt
     774         * the sleep. Any request for printing an uspace stack
     775         * trace from within the kernel should be always
     776         * considered a last resort debugging means, therefore
     777         * forcing the thread's sleep to be interrupted
     778         * is probably justifiable.
     779         */
     780       
     781        bool sleeping = false;
     782        istate_t *istate = thread->udebug.uspace_state;
     783        if (istate != NULL) {
     784                printf("Scheduling thread stack trace.\n");
     785                thread->btrace = true;
     786                if (thread->state == Sleeping)
     787                        sleeping = true;
     788        } else
     789                printf("Thread interrupt state not available.\n");
     790       
     791        irq_spinlock_unlock(&thread->lock, false);
     792       
     793        if (sleeping)
     794                waitq_interrupt_sleep(thread);
     795       
     796        irq_spinlock_unlock(&threads_lock, true);
     797}
     798
     799#endif /* CONFIG_UDEBUG */
    753800
    754801/** Process syscall to create new thread.
    … …  
    793840                                 * has already been created. We need to undo its
    794841                                 * creation now.
    795                                  *
    796842                                 */
    797843                               
    … …  
    815861                 * THREAD_B events for threads that already existed
    816862                 * and could be detected with THREAD_READ before.
    817                  *
    818863                 */
    819864                udebug_thread_b_event_attach(thread, TASK);
Note: See TracChangeset for help on using the changeset viewer.