source: mainline/kernel/generic/src/proc/thread.c@ df58e44

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since df58e44 was df58e44, checked in by Martin Decky <martin@…>, 14 years ago
  • 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
  • Property mode set to 100644
File size: 21.9 KB
RevLine 
[f761f1eb]1/*
[7ed8530]2 * Copyright (c) 2010 Jakub Jermar
[f761f1eb]3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
[cc73a8a1]29/** @addtogroup genericproc
[b45c443]30 * @{
31 */
32
[9179d0a]33/**
[b45c443]34 * @file
[da1bafb]35 * @brief Thread management functions.
[9179d0a]36 */
37
[f761f1eb]38#include <proc/scheduler.h>
39#include <proc/thread.h>
40#include <proc/task.h>
[0f250f9]41#include <proc/uarg.h>
[f761f1eb]42#include <mm/frame.h>
43#include <mm/page.h>
44#include <arch/asm.h>
[cce6acf]45#include <arch/cycle.h>
[f761f1eb]46#include <arch.h>
47#include <synch/synch.h>
48#include <synch/spinlock.h>
49#include <synch/waitq.h>
50#include <cpu.h>
[e535eeb]51#include <str.h>
[f761f1eb]52#include <context.h>
[5dcee525]53#include <adt/avl.h>
[5c9a08b]54#include <adt/list.h>
[f761f1eb]55#include <time/clock.h>
[b3f8fb7]56#include <time/timeout.h>
[4ffa9e0]57#include <config.h>
58#include <arch/interrupt.h>
[26a8604f]59#include <smp/ipi.h>
[f2ffad4]60#include <arch/faddr.h>
[23684b7]61#include <atomic.h>
[9c0a9b3]62#include <memstr.h>
[55ab0f1]63#include <print.h>
[266294a9]64#include <mm/slab.h>
65#include <debug.h>
[9f52563]66#include <main/uinit.h>
[e3c762cd]67#include <syscall/copy.h>
68#include <errno.h>
[52755f1]69
70
71#ifndef LOADED_PROG_STACK_PAGES_NO
72#define LOADED_PROG_STACK_PAGES_NO 1
73#endif
[f761f1eb]74
[fe19611]75
76/** Thread states */
[a000878c]77const char *thread_states[] = {
[fe19611]78 "Invalid",
79 "Running",
80 "Sleeping",
81 "Ready",
82 "Entering",
83 "Exiting",
[48d14222]84 "Lingering"
[e1b6742]85};
86
87typedef struct {
88 thread_id_t thread_id;
89 thread_t *thread;
90} thread_iterator_t;
[f761f1eb]91
[5dcee525]92/** Lock protecting the threads_tree AVL tree.
[4e33b6b]93 *
94 * For locking rules, see declaration thereof.
[da1bafb]95 *
[4e33b6b]96 */
[da1bafb]97IRQ_SPINLOCK_INITIALIZE(threads_lock);
[88169d9]98
[81c0171e]99/** AVL tree of all threads.
[88169d9]100 *
[5dcee525]101 * When a thread is found in the threads_tree AVL tree, it is guaranteed to
[4e33b6b]102 * exist as long as the threads_lock is held.
[da1bafb]103 *
[88169d9]104 */
[da1bafb]105avltree_t threads_tree;
[f761f1eb]106
[da1bafb]107IRQ_SPINLOCK_STATIC_INITIALIZE(tidlock);
108static thread_id_t last_tid = 0;
[f761f1eb]109
[266294a9]110static slab_cache_t *thread_slab;
[da1bafb]111
[0f81ceb7]112#ifdef CONFIG_FPU
[f76fed4]113slab_cache_t *fpu_context_slab;
114#endif
[266294a9]115
[4e33b6b]116/** Thread wrapper.
[70527f1]117 *
[4e33b6b]118 * This wrapper is provided to ensure that every thread makes a call to
119 * thread_exit() when its implementing function returns.
[f761f1eb]120 *
[22f7769]121 * interrupts_disable() is assumed.
[70527f1]122 *
[f761f1eb]123 */
[e16e036a]124static void cushion(void)
[f761f1eb]125{
[43114c5]126 void (*f)(void *) = THREAD->thread_code;
127 void *arg = THREAD->thread_arg;
[449dc1ed]128 THREAD->last_cycle = get_cycle();
[da1bafb]129
[0313ff0]130 /* This is where each thread wakes up after its creation */
[da1bafb]131 irq_spinlock_unlock(&THREAD->lock, false);
[22f7769]132 interrupts_enable();
[da1bafb]133
[f761f1eb]134 f(arg);
[0313ff0]135
136 /* Accumulate accounting to the task */
[da1bafb]137 irq_spinlock_lock(&THREAD->lock, true);
[62b6d17]138 if (!THREAD->uncounted) {
[a2a00e8]139 thread_update_accounting(true);
140 uint64_t ucycles = THREAD->ucycles;
141 THREAD->ucycles = 0;
142 uint64_t kcycles = THREAD->kcycles;
143 THREAD->kcycles = 0;
[62b6d17]144
[da1bafb]145 irq_spinlock_pass(&THREAD->lock, &TASK->lock);
[a2a00e8]146 TASK->ucycles += ucycles;
147 TASK->kcycles += kcycles;
[da1bafb]148 irq_spinlock_unlock(&TASK->lock, true);
[62b6d17]149 } else
[da1bafb]150 irq_spinlock_unlock(&THREAD->lock, true);
[0313ff0]151
[f761f1eb]152 thread_exit();
[da1bafb]153
154 /* Not reached */
[f761f1eb]155}
156
[da1bafb]157/** Initialization and allocation for thread_t structure
158 *
159 */
160static int thr_constructor(void *obj, unsigned int kmflags)
[266294a9]161{
[da1bafb]162 thread_t *thread = (thread_t *) obj;
163
164 irq_spinlock_initialize(&thread->lock, "thread_t_lock");
165 link_initialize(&thread->rq_link);
166 link_initialize(&thread->wq_link);
167 link_initialize(&thread->th_link);
168
[32fffef0]169 /* call the architecture-specific part of the constructor */
[da1bafb]170 thr_constructor_arch(thread);
[266294a9]171
[0f81ceb7]172#ifdef CONFIG_FPU
[d8431986]173#ifdef CONFIG_FPU_LAZY
[da1bafb]174 thread->saved_fpu_context = NULL;
175#else /* CONFIG_FPU_LAZY */
176 thread->saved_fpu_context = slab_alloc(fpu_context_slab, kmflags);
177 if (!thread->saved_fpu_context)
[f76fed4]178 return -1;
[da1bafb]179#endif /* CONFIG_FPU_LAZY */
180#endif /* CONFIG_FPU */
181
182 thread->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
183 if (!thread->kstack) {
[0f81ceb7]184#ifdef CONFIG_FPU
[da1bafb]185 if (thread->saved_fpu_context)
186 slab_free(fpu_context_slab, thread->saved_fpu_context);
[f76fed4]187#endif
[266294a9]188 return -1;
[f76fed4]189 }
[da1bafb]190
[9a1b20c]191#ifdef CONFIG_UDEBUG
[da1bafb]192 mutex_initialize(&thread->udebug.lock, MUTEX_PASSIVE);
[9a1b20c]193#endif
[da1bafb]194
[266294a9]195 return 0;
196}
197
198/** Destruction of thread_t object */
[da1bafb]199static size_t thr_destructor(void *obj)
[266294a9]200{
[da1bafb]201 thread_t *thread = (thread_t *) obj;
202
[32fffef0]203 /* call the architecture-specific part of the destructor */
[da1bafb]204 thr_destructor_arch(thread);
205
206 frame_free(KA2PA(thread->kstack));
207
[0f81ceb7]208#ifdef CONFIG_FPU
[da1bafb]209 if (thread->saved_fpu_context)
210 slab_free(fpu_context_slab, thread->saved_fpu_context);
[f76fed4]211#endif
[da1bafb]212
213 return 1; /* One page freed */
[266294a9]214}
[70527f1]215
216/** Initialize threads
217 *
218 * Initialize kernel threads support.
219 *
220 */
[f761f1eb]221void thread_init(void)
222{
[43114c5]223 THREAD = NULL;
[da1bafb]224
[7217199]225 atomic_set(&nrdy, 0);
[4e33b6b]226 thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0,
[6f4495f5]227 thr_constructor, thr_destructor, 0);
[da1bafb]228
[0f81ceb7]229#ifdef CONFIG_FPU
[4e33b6b]230 fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t),
[6f4495f5]231 FPU_CONTEXT_ALIGN, NULL, NULL, 0);
[f76fed4]232#endif
[da1bafb]233
[5dcee525]234 avltree_create(&threads_tree);
[016acbe]235}
[70527f1]236
237/** Make thread ready
238 *
[da1bafb]239 * Switch thread to the ready state.
[70527f1]240 *
[df58e44]241 * @param thread Thread to make ready.
[70527f1]242 *
243 */
[da1bafb]244void thread_ready(thread_t *thread)
[f761f1eb]245{
[da1bafb]246 irq_spinlock_lock(&thread->lock, true);
[f761f1eb]247
[df58e44]248 ASSERT(thread->state != Ready);
[da1bafb]249
250 int i = (thread->priority < RQ_COUNT - 1)
251 ? ++thread->priority : thread->priority;
252
253 cpu_t *cpu = CPU;
254 if (thread->flags & THREAD_FLAG_WIRED) {
255 ASSERT(thread->cpu != NULL);
256 cpu = thread->cpu;
[f761f1eb]257 }
[da1bafb]258 thread->state = Ready;
259
260 irq_spinlock_pass(&thread->lock, &(cpu->rq[i].lock));
[f761f1eb]261
[70527f1]262 /*
[da1bafb]263 * Append thread to respective ready queue
264 * on respective processor.
[f761f1eb]265 */
[da1bafb]266
267 list_append(&thread->rq_link, &cpu->rq[i].rq_head);
268 cpu->rq[i].n++;
269 irq_spinlock_unlock(&(cpu->rq[i].lock), true);
270
[59e07c91]271 atomic_inc(&nrdy);
[da1bafb]272 // FIXME: Why is the avg value not used
273 // avg = atomic_get(&nrdy) / config.cpu_active;
[248fc1a]274 atomic_inc(&cpu->nrdy);
[f761f1eb]275}
276
[70527f1]277/** Create new thread
278 *
279 * Create a new thread.
280 *
[da1bafb]281 * @param func Thread's implementing function.
282 * @param arg Thread's implementing function argument.
283 * @param task Task to which the thread belongs. The caller must
284 * guarantee that the task won't cease to exist during the
285 * call. The task's lock may not be held.
286 * @param flags Thread flags.
287 * @param name Symbolic name (a copy is made).
288 * @param uncounted Thread's accounting doesn't affect accumulated task
289 * accounting.
[70527f1]290 *
[da1bafb]291 * @return New thread's structure on success, NULL on failure.
[70527f1]292 *
293 */
[4e33b6b]294thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
[da1bafb]295 unsigned int flags, const char *name, bool uncounted)
[f761f1eb]296{
[da1bafb]297 thread_t *thread = (thread_t *) slab_alloc(thread_slab, 0);
298 if (!thread)
[2a46e10]299 return NULL;
[aa8d0f7]300
[bb68433]301 /* Not needed, but good for debugging */
[da1bafb]302 memsetb(thread->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES, 0);
[bb68433]303
[da1bafb]304 irq_spinlock_lock(&tidlock, true);
305 thread->tid = ++last_tid;
306 irq_spinlock_unlock(&tidlock, true);
[bb68433]307
[da1bafb]308 context_save(&thread->saved_context);
309 context_set(&thread->saved_context, FADDR(cushion),
310 (uintptr_t) thread->kstack, THREAD_STACK_SIZE);
[bb68433]311
[da1bafb]312 the_initialize((the_t *) thread->kstack);
[bb68433]313
[da1bafb]314 ipl_t ipl = interrupts_disable();
315 thread->saved_context.ipl = interrupts_read();
[bb68433]316 interrupts_restore(ipl);
317
[da1bafb]318 str_cpy(thread->name, THREAD_NAME_BUFLEN, name);
319
320 thread->thread_code = func;
321 thread->thread_arg = arg;
322 thread->ticks = -1;
323 thread->ucycles = 0;
324 thread->kcycles = 0;
325 thread->uncounted = uncounted;
326 thread->priority = -1; /* Start in rq[0] */
327 thread->cpu = NULL;
328 thread->flags = flags;
329 thread->state = Entering;
330
331 timeout_initialize(&thread->sleep_timeout);
332 thread->sleep_interruptible = false;
333 thread->sleep_queue = NULL;
334 thread->timeout_pending = false;
335
336 thread->in_copy_from_uspace = false;
337 thread->in_copy_to_uspace = false;
338
339 thread->interrupted = false;
[df58e44]340 thread->btrace = false;
[da1bafb]341 thread->detached = false;
342 waitq_initialize(&thread->join_wq);
343
344 thread->task = task;
345
346 thread->fpu_context_exists = 0;
347 thread->fpu_context_engaged = 0;
348
349 avltree_node_initialize(&thread->threads_tree_node);
350 thread->threads_tree_node.key = (uintptr_t) thread;
[bb68433]351
[9a1b20c]352#ifdef CONFIG_UDEBUG
353 /* Init debugging stuff */
[da1bafb]354 udebug_thread_initialize(&thread->udebug);
[9a1b20c]355#endif
[da1bafb]356
357 /* Might depend on previous initialization */
358 thread_create_arch(thread);
359
[d8431986]360 if (!(flags & THREAD_FLAG_NOATTACH))
[da1bafb]361 thread_attach(thread, task);
362
363 return thread;
[d8431986]364}
365
366/** Destroy thread memory structure
367 *
368 * Detach thread from all queues, cpus etc. and destroy it.
[da1bafb]369 *
370 * @param thread Thread to be destroyed.
371 * @param irq_res Indicate whether it should unlock thread->lock
372 * in interrupts-restore mode.
[d8431986]373 *
374 */
[da1bafb]375void thread_destroy(thread_t *thread, bool irq_res)
[d8431986]376{
[2d3ddad]377 ASSERT(irq_spinlock_locked(&thread->lock));
[da1bafb]378 ASSERT((thread->state == Exiting) || (thread->state == Lingering));
379 ASSERT(thread->task);
380 ASSERT(thread->cpu);
381
382 irq_spinlock_lock(&thread->cpu->lock, false);
383 if (thread->cpu->fpu_owner == thread)
384 thread->cpu->fpu_owner = NULL;
385 irq_spinlock_unlock(&thread->cpu->lock, false);
386
387 irq_spinlock_pass(&thread->lock, &threads_lock);
388
389 avltree_delete(&threads_tree, &thread->threads_tree_node);
390
391 irq_spinlock_pass(&threads_lock, &thread->task->lock);
392
[d8431986]393 /*
394 * Detach from the containing task.
395 */
[da1bafb]396 list_remove(&thread->th_link);
397 irq_spinlock_unlock(&thread->task->lock, irq_res);
398
[ea7890e7]399 /*
[7ed8530]400 * Drop the reference to the containing task.
[ea7890e7]401 */
[da1bafb]402 task_release(thread->task);
403 slab_free(thread_slab, thread);
[d8431986]404}
405
406/** Make the thread visible to the system.
407 *
408 * Attach the thread structure to the current task and make it visible in the
[5dcee525]409 * threads_tree.
[d8431986]410 *
[da1bafb]411 * @param t Thread to be attached to the task.
412 * @param task Task to which the thread is to be attached.
413 *
[d8431986]414 */
[da1bafb]415void thread_attach(thread_t *thread, task_t *task)
[d8431986]416{
417 /*
[9a1b20c]418 * Attach to the specified task.
[d8431986]419 */
[da1bafb]420 irq_spinlock_lock(&task->lock, true);
421
[7ed8530]422 /* Hold a reference to the task. */
423 task_hold(task);
[da1bafb]424
[9a1b20c]425 /* Must not count kbox thread into lifecount */
[da1bafb]426 if (thread->flags & THREAD_FLAG_USPACE)
[9a1b20c]427 atomic_inc(&task->lifecount);
[da1bafb]428
429 list_append(&thread->th_link, &task->th_head);
430
431 irq_spinlock_pass(&task->lock, &threads_lock);
432
[bb68433]433 /*
434 * Register this thread in the system-wide list.
435 */
[da1bafb]436 avltree_insert(&threads_tree, &thread->threads_tree_node);
437 irq_spinlock_unlock(&threads_lock, true);
[f761f1eb]438}
439
[0182a665]440/** Terminate thread.
[70527f1]441 *
[da1bafb]442 * End current thread execution and switch it to the exiting state.
443 * All pending timeouts are executed.
444 *
[70527f1]445 */
[f761f1eb]446void thread_exit(void)
447{
[9a1b20c]448 if (THREAD->flags & THREAD_FLAG_USPACE) {
449#ifdef CONFIG_UDEBUG
450 /* Generate udebug THREAD_E event */
451 udebug_thread_e_event();
[0ac99db]452
453 /*
454 * This thread will not execute any code or system calls from
455 * now on.
456 */
457 udebug_stoppable_begin();
[9a1b20c]458#endif
459 if (atomic_predec(&TASK->lifecount) == 0) {
460 /*
461 * We are the last userspace thread in the task that
462 * still has not exited. With the exception of the
463 * moment the task was created, new userspace threads
464 * can only be created by threads of the same task.
465 * We are safe to perform cleanup.
[da1bafb]466 *
[9a1b20c]467 */
[ea7890e7]468 ipc_cleanup();
[52755f1]469 futex_cleanup();
470 LOG("Cleanup of task %" PRIu64" completed.", TASK->taskid);
[ea7890e7]471 }
472 }
[da1bafb]473
[f761f1eb]474restart:
[da1bafb]475 irq_spinlock_lock(&THREAD->lock, true);
476 if (THREAD->timeout_pending) {
477 /* Busy waiting for timeouts in progress */
478 irq_spinlock_unlock(&THREAD->lock, true);
[f761f1eb]479 goto restart;
480 }
[ea7890e7]481
[43114c5]482 THREAD->state = Exiting;
[da1bafb]483 irq_spinlock_unlock(&THREAD->lock, true);
484
[f761f1eb]485 scheduler();
[da1bafb]486
[874621f]487 /* Not reached */
[da1bafb]488 while (true);
[f761f1eb]489}
490
[70527f1]491/** Thread sleep
492 *
493 * Suspend execution of the current thread.
494 *
495 * @param sec Number of seconds to sleep.
496 *
497 */
[7f1c620]498void thread_sleep(uint32_t sec)
[f761f1eb]499{
[22e6802]500 /* Sleep in 1000 second steps to support
501 full argument range */
502 while (sec > 0) {
503 uint32_t period = (sec > 1000) ? 1000 : sec;
[da1bafb]504
[22e6802]505 thread_usleep(period * 1000000);
506 sec -= period;
507 }
[f761f1eb]508}
[70527f1]509
[fe19611]510/** Wait for another thread to exit.
511 *
[da1bafb]512 * @param thread Thread to join on exit.
513 * @param usec Timeout in microseconds.
514 * @param flags Mode of operation.
[fe19611]515 *
516 * @return An error code from errno.h or an error code from synch.h.
[da1bafb]517 *
[fe19611]518 */
[da1bafb]519int thread_join_timeout(thread_t *thread, uint32_t usec, unsigned int flags)
[fe19611]520{
[da1bafb]521 if (thread == THREAD)
[fe19611]522 return EINVAL;
[da1bafb]523
[fe19611]524 /*
525 * Since thread join can only be called once on an undetached thread,
526 * the thread pointer is guaranteed to be still valid.
527 */
528
[da1bafb]529 irq_spinlock_lock(&thread->lock, true);
530 ASSERT(!thread->detached);
531 irq_spinlock_unlock(&thread->lock, true);
[0182a665]532
[da1bafb]533 return waitq_sleep_timeout(&thread->join_wq, usec, flags);
[fe19611]534}
535
536/** Detach thread.
537 *
[df58e44]538 * Mark the thread as detached. If the thread is already
539 * in the Lingering state, deallocate its resources.
[fe19611]540 *
[da1bafb]541 * @param thread Thread to be detached.
542 *
[fe19611]543 */
[da1bafb]544void thread_detach(thread_t *thread)
[fe19611]545{
546 /*
[31d8e10]547 * Since the thread is expected not to be already detached,
[fe19611]548 * pointer to it must be still valid.
549 */
[da1bafb]550 irq_spinlock_lock(&thread->lock, true);
551 ASSERT(!thread->detached);
552
553 if (thread->state == Lingering) {
554 /*
555 * Unlock &thread->lock and restore
556 * interrupts in thread_destroy().
557 */
558 thread_destroy(thread, true);
[fe19611]559 return;
560 } else {
[da1bafb]561 thread->detached = true;
[fe19611]562 }
[da1bafb]563
564 irq_spinlock_unlock(&thread->lock, true);
[fe19611]565}
566
[70527f1]567/** Thread usleep
568 *
569 * Suspend execution of the current thread.
570 *
571 * @param usec Number of microseconds to sleep.
572 *
573 */
[7f1c620]574void thread_usleep(uint32_t usec)
[f761f1eb]575{
576 waitq_t wq;
[22e6802]577
[f761f1eb]578 waitq_initialize(&wq);
[22e6802]579
[116d1ef4]580 (void) waitq_sleep_timeout(&wq, usec, SYNCH_FLAGS_NON_BLOCKING);
[f761f1eb]581}
582
[b76a2217]583static bool thread_walker(avltree_node_t *node, void *arg)
[5dcee525]584{
[48dcc69]585 bool *additional = (bool *) arg;
[da1bafb]586 thread_t *thread = avltree_get_instance(node, thread_t, threads_tree_node);
[52755f1]587
[1ba37fa]588 uint64_t ucycles, kcycles;
589 char usuffix, ksuffix;
[da1bafb]590 order_suffix(thread->ucycles, &ucycles, &usuffix);
591 order_suffix(thread->kcycles, &kcycles, &ksuffix);
592
[52755f1]593#ifdef __32_BITS__
[48dcc69]594 if (*additional)
595 printf("%-8" PRIu64" %10p %9" PRIu64 "%c %9" PRIu64 "%c ",
596 thread->tid, thread->kstack, ucycles, usuffix,
597 kcycles, ksuffix);
598 else
599 printf("%-8" PRIu64" %-14s %10p %-8s %10p %-5" PRIu32 " %10p\n",
600 thread->tid, thread->name, thread, thread_states[thread->state],
601 thread->task, thread->task->context, thread->thread_code);
[52755f1]602#endif
[da1bafb]603
[52755f1]604#ifdef __64_BITS__
[48dcc69]605 if (*additional)
606 printf("%-8" PRIu64" %18p %18p\n"
607 " %9" PRIu64 "%c %9" PRIu64 "%c ",
608 thread->tid, thread->thread_code, thread->kstack,
609 ucycles, usuffix, kcycles, ksuffix);
[5dcee525]610 else
[48dcc69]611 printf("%-8" PRIu64" %-14s %18p %-8s %18p %-5" PRIu32 "\n",
612 thread->tid, thread->name, thread, thread_states[thread->state],
613 thread->task, thread->task->context);
614#endif
[da1bafb]615
[48dcc69]616 if (*additional) {
617 if (thread->cpu)
618 printf("%-5u", thread->cpu->id);
619 else
620 printf("none ");
621
622 if (thread->state == Sleeping) {
[52755f1]623#ifdef __32_BITS__
[48dcc69]624 printf(" %10p", thread->sleep_queue);
[52755f1]625#endif
[48dcc69]626
[52755f1]627#ifdef __64_BITS__
[48dcc69]628 printf(" %18p", thread->sleep_queue);
[52755f1]629#endif
[48dcc69]630 }
631
632 printf("\n");
[43b1e86]633 }
[da1bafb]634
[b76a2217]635 return true;
[5dcee525]636}
637
[da1bafb]638/** Print list of threads debug info
[48dcc69]639 *
640 * @param additional Print additional information.
[da1bafb]641 *
642 */
[48dcc69]643void thread_print_list(bool additional)
[55ab0f1]644{
645 /* Messing with thread structures, avoid deadlock */
[da1bafb]646 irq_spinlock_lock(&threads_lock, true);
647
648#ifdef __32_BITS__
[48dcc69]649 if (additional)
650 printf("[id ] [stack ] [ucycles ] [kcycles ] [cpu]"
651 " [waitqueue]\n");
652 else
653 printf("[id ] [name ] [address ] [state ] [task ]"
654 " [ctx] [code ]\n");
[52755f1]655#endif
[da1bafb]656
[52755f1]657#ifdef __64_BITS__
[48dcc69]658 if (additional) {
659 printf("[id ] [code ] [stack ]\n"
660 " [ucycles ] [kcycles ] [cpu] [waitqueue ]\n");
661 } else
662 printf("[id ] [name ] [address ] [state ]"
663 " [task ] [ctx]\n");
[52755f1]664#endif
[da1bafb]665
[48dcc69]666 avltree_walk(&threads_tree, thread_walker, &additional);
[da1bafb]667
668 irq_spinlock_unlock(&threads_lock, true);
[55ab0f1]669}
[9f52563]670
[016acbe]671/** Check whether thread exists.
672 *
673 * Note that threads_lock must be already held and
674 * interrupts must be already disabled.
675 *
[da1bafb]676 * @param thread Pointer to thread.
[016acbe]677 *
678 * @return True if thread t is known to the system, false otherwise.
[da1bafb]679 *
[016acbe]680 */
[da1bafb]681bool thread_exists(thread_t *thread)
[016acbe]682{
[1d432f9]683 ASSERT(interrupts_disabled());
684 ASSERT(irq_spinlock_locked(&threads_lock));
685
[da1bafb]686 avltree_node_t *node =
687 avltree_search(&threads_tree, (avltree_key_t) ((uintptr_t) thread));
[016acbe]688
[5dcee525]689 return node != NULL;
[016acbe]690}
691
[cce6acf]692/** Update accounting of current thread.
693 *
694 * Note that thread_lock on THREAD must be already held and
695 * interrupts must be already disabled.
696 *
[da1bafb]697 * @param user True to update user accounting, false for kernel.
698 *
[cce6acf]699 */
[a2a00e8]700void thread_update_accounting(bool user)
[cce6acf]701{
702 uint64_t time = get_cycle();
[1d432f9]703
704 ASSERT(interrupts_disabled());
705 ASSERT(irq_spinlock_locked(&THREAD->lock));
[da1bafb]706
707 if (user)
[a2a00e8]708 THREAD->ucycles += time - THREAD->last_cycle;
[da1bafb]709 else
[a2a00e8]710 THREAD->kcycles += time - THREAD->last_cycle;
[da1bafb]711
[cce6acf]712 THREAD->last_cycle = time;
713}
714
[e1b6742]715static bool thread_search_walker(avltree_node_t *node, void *arg)
716{
717 thread_t *thread =
718 (thread_t *) avltree_get_instance(node, thread_t, threads_tree_node);
719 thread_iterator_t *iterator = (thread_iterator_t *) arg;
720
721 if (thread->tid == iterator->thread_id) {
722 iterator->thread = thread;
723 return false;
724 }
725
726 return true;
727}
728
729/** Find thread structure corresponding to thread ID.
730 *
731 * The threads_lock must be already held by the caller of this function and
732 * interrupts must be disabled.
733 *
734 * @param id Thread ID.
735 *
736 * @return Thread structure address or NULL if there is no such thread ID.
737 *
738 */
739thread_t *thread_find_by_id(thread_id_t thread_id)
740{
[1d432f9]741 ASSERT(interrupts_disabled());
742 ASSERT(irq_spinlock_locked(&threads_lock));
[df58e44]743
[e1b6742]744 thread_iterator_t iterator;
745
746 iterator.thread_id = thread_id;
747 iterator.thread = NULL;
748
749 avltree_walk(&threads_tree, thread_search_walker, (void *) &iterator);
750
751 return iterator.thread;
752}
753
[df58e44]754void thread_stack_trace(thread_id_t thread_id)
755{
756 irq_spinlock_lock(&threads_lock, true);
757
758 thread_t *thread = thread_find_by_id(thread_id);
759 if (thread == NULL) {
760 printf("No such thread.\n");
761 irq_spinlock_unlock(&threads_lock, true);
762 return;
763 }
764
765 irq_spinlock_lock(&thread->lock, false);
766
767 /*
768 * Schedule a stack trace to be printed
769 * just before the thread is scheduled next.
770 *
771 * If the thread is sleeping then try to interrupt
772 * the sleep. Any request for printing an uspace stack
773 * trace from within the kernel should be always
774 * considered a last resort debugging means, therefore
775 * forcing the thread's sleep to be interrupted
776 * is probably justifiable.
777 */
778
779 bool sleeping = false;
780 istate_t *istate = thread->udebug.uspace_state;
781 if (istate != NULL) {
782 printf("Scheduling thread stack trace.\n");
783 thread->btrace = true;
784 if (thread->state == Sleeping)
785 sleeping = true;
786 } else
787 printf("Thread interrupt state not available.\n");
788
789 irq_spinlock_unlock(&thread->lock, false);
790
791 if (sleeping)
792 waitq_interrupt_sleep(thread);
793
794 irq_spinlock_unlock(&threads_lock, true);
795}
[e1b6742]796
[9f52563]797/** Process syscall to create new thread.
798 *
799 */
[96b02eb9]800sysarg_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
[7faabb7]801 size_t name_len, thread_id_t *uspace_thread_id)
[9f52563]802{
[24345a5]803 if (name_len > THREAD_NAME_BUFLEN - 1)
[7faabb7]804 name_len = THREAD_NAME_BUFLEN - 1;
[da1bafb]805
806 char namebuf[THREAD_NAME_BUFLEN];
807 int rc = copy_from_uspace(namebuf, uspace_name, name_len);
[e3c762cd]808 if (rc != 0)
[96b02eb9]809 return (sysarg_t) rc;
[da1bafb]810
[b60c582]811 namebuf[name_len] = 0;
[da1bafb]812
[4680ef5]813 /*
814 * In case of failure, kernel_uarg will be deallocated in this function.
815 * In case of success, kernel_uarg will be freed in uinit().
[da1bafb]816 *
[4680ef5]817 */
[da1bafb]818 uspace_arg_t *kernel_uarg =
819 (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
[4680ef5]820
[e3c762cd]821 rc = copy_from_uspace(kernel_uarg, uspace_uarg, sizeof(uspace_arg_t));
822 if (rc != 0) {
823 free(kernel_uarg);
[96b02eb9]824 return (sysarg_t) rc;
[e3c762cd]825 }
[da1bafb]826
827 thread_t *thread = thread_create(uinit, kernel_uarg, TASK,
[d8431986]828 THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf, false);
[da1bafb]829 if (thread) {
[d8431986]830 if (uspace_thread_id != NULL) {
[da1bafb]831 rc = copy_to_uspace(uspace_thread_id, &thread->tid,
832 sizeof(thread->tid));
[d8431986]833 if (rc != 0) {
834 /*
835 * We have encountered a failure, but the thread
836 * has already been created. We need to undo its
837 * creation now.
838 */
[da1bafb]839
[d8431986]840 /*
[ea7890e7]841 * The new thread structure is initialized, but
842 * is still not visible to the system.
[d8431986]843 * We can safely deallocate it.
844 */
[da1bafb]845 slab_free(thread_slab, thread);
846 free(kernel_uarg);
847
[96b02eb9]848 return (sysarg_t) rc;
[d8431986]849 }
850 }
[da1bafb]851
[9a1b20c]852#ifdef CONFIG_UDEBUG
[13964ef]853 /*
854 * Generate udebug THREAD_B event and attach the thread.
855 * This must be done atomically (with the debug locks held),
856 * otherwise we would either miss some thread or receive
857 * THREAD_B events for threads that already existed
858 * and could be detected with THREAD_READ before.
859 */
[da1bafb]860 udebug_thread_b_event_attach(thread, TASK);
[13964ef]861#else
[da1bafb]862 thread_attach(thread, TASK);
[9a1b20c]863#endif
[da1bafb]864 thread_ready(thread);
865
[d8431986]866 return 0;
[201abde]867 } else
[0f250f9]868 free(kernel_uarg);
[da1bafb]869
[96b02eb9]870 return (sysarg_t) ENOMEM;
[9f52563]871}
872
873/** Process syscall to terminate thread.
874 *
875 */
[96b02eb9]876sysarg_t sys_thread_exit(int uspace_status)
[9f52563]877{
[68091bd]878 thread_exit();
[da1bafb]879
[68091bd]880 /* Unreachable */
881 return 0;
[9f52563]882}
[b45c443]883
[3ce7f082]884/** Syscall for getting TID.
885 *
[201abde]886 * @param uspace_thread_id Userspace address of 8-byte buffer where to store
887 * current thread ID.
888 *
889 * @return 0 on success or an error code from @ref errno.h.
[da1bafb]890 *
[b45c443]891 */
[96b02eb9]892sysarg_t sys_thread_get_id(thread_id_t *uspace_thread_id)
[3ce7f082]893{
894 /*
895 * No need to acquire lock on THREAD because tid
896 * remains constant for the lifespan of the thread.
[da1bafb]897 *
[3ce7f082]898 */
[96b02eb9]899 return (sysarg_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
[201abde]900 sizeof(THREAD->tid));
[3ce7f082]901}
[6f4495f5]902
[d9ece1cb]903/** Syscall wrapper for sleeping. */
[96b02eb9]904sysarg_t sys_thread_usleep(uint32_t usec)
[d9ece1cb]905{
[22e6802]906 thread_usleep(usec);
[d9ece1cb]907 return 0;
908}
909
[3ce7f082]910/** @}
911 */
Note: See TracBrowser for help on using the repository browser.