Prex Home / Browse Source - Prex Version: 0.9.0

root/sys/kern/thread.c

DEFINITIONS

1. thread_create
2. thread_terminate
3. thread_destroy
4. thread_load
5. thread_self
6. thread_valid
7. thread_yield
8. thread_suspend
9. thread_resume
10. thread_schedparam
11. thread_idle
12. thread_allocate
13. thread_deallocate
14. thread_info
15. kthread_create
16. kthread_terminate
17. thread_init

   1 /*-
   2  * Copyright (c) 2005-2009, Kohsuke Ohtani
   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  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the author nor the names of any co-contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  30 /*
  31  * thread.c - thread management routines.
  32  */
  34 #include <kernel.h>
  35 #include <kmem.h>
  36 #include <task.h>
  37 #include <thread.h>
  38 #include <ipc.h>
  39 #include <sched.h>
  40 #include <sync.h>
  41 #include <hal.h>
  43 /* forward declarations */
  44 static thread_t thread_allocate(task_t);
  45 static void     thread_deallocate(thread_t);
  47 static struct thread    idle_thread;    /* idle thread */
  48 static thread_t         zombie;         /* zombie thread */
  49 static struct list      thread_list;    /* list of all threads */
  51 /* global variable */
thread_t curthread = &idle_thread;      /* current thread */
  54 /*
  55  * Create a new thread.
  56  *
  57  * The new thread will start from the return address of
  58  * thread_create() in user mode.  Since a new thread shares
  59  * the user mode stack of the caller thread, the caller is
  60  * responsible to allocate and set new stack for it. The new
  61  * thread is initially set to suspend state, and so,
  62  * thread_resume() must be called to start it.
  63  */
  64 int
thread_create(task_t task, thread_t *tp)
  66 {
thread_t t;
vaddr_t sp;
sched_lock();
  72         if (!task_valid(task)) {
sched_unlock();
  74                 return ESRCH;
  75         }
  76         if (!task_access(task)) {
sched_unlock();
  78                 return EPERM;
  79         }
  80         if (task->nthreads >= MAXTHREADS) {
sched_unlock();
  82                 return EAGAIN;
  83         }
  84         /*
  85          * We check the pointer to the return value here.
  86          * This will simplify the error recoveries of the
  87          * subsequent code.
  88          */
  89         if ((curtask->flags & TF_SYSTEM) == 0) {
t = NULL;
  91                 if (copyout(&t, tp, sizeof(t))) {
sched_unlock();
  93                         return EFAULT;
  94                 }
  95         }
  96         /*
  97          * Make thread entry for new thread.
  98          */
  99         if ((t = thread_allocate(task)) == NULL) {
DPRINTF(("Out of text\n"));
sched_unlock();
 102                 return ENOMEM;
 103         }
memcpy(t->kstack, curthread->kstack, KSTACKSZ);
sp = (vaddr_t)t->kstack + KSTACKSZ;
context_set(&t->ctx, CTX_KSTACK, (register_t)sp);
context_set(&t->ctx, CTX_KENTRY, (register_t)&syscall_ret);
sched_start(t, curthread->basepri, SCHED_RR);
t->suscnt = task->suscnt + 1;
 111         /*
 112          * No page fault here:
 113          */
 114         if (curtask->flags & TF_SYSTEM)
 115                 *tp = t;
 116         else
copyout(&t, tp, sizeof(t));
sched_unlock();
 120         return 0;
 121 }
 123 /*
 124  * Permanently stop execution of the specified thread.
 125  * If given thread is a current thread, this routine
 126  * never returns.
 127  */
 128 int
thread_terminate(thread_t t)
 130 {
sched_lock();
 133         if (!thread_valid(t)) {
sched_unlock();
 135                 return ESRCH;
 136         }
 137         if (!task_access(t->task)) {
sched_unlock();
 139                 return EPERM;
 140         }
thread_destroy(t);
sched_unlock();
 143         return 0;
 144 }
 146 /*
 147  * thread_destroy-- the internal version of thread_terminate.
 148  */
 149 void
thread_destroy(thread_t th)
 151 {
msg_cancel(th);
mutex_cancel(th);
timer_cancel(th);
sched_stop(th);
thread_deallocate(th);
 158 }
 160 /*
 161  * Load entry/stack address of the user mode context.
 162  *
 163  * If the entry or stack address is NULL, we keep the
 164  * old value for it.
 165  */
 166 int
thread_load(thread_t t, void (*entry)(void), void *stack)
 168 {
 169         int s;
 171         if (entry != NULL && !user_area(entry))
 172                 return EINVAL;
 173         if (stack != NULL && !user_area(stack))
 174                 return EINVAL;
sched_lock();
 178         if (!thread_valid(t)) {
sched_unlock();
 180                 return ESRCH;
 181         }
 182         if (!task_access(t->task)) {
sched_unlock();
 184                 return EPERM;
 185         }
s = splhigh();
 187         if (entry != NULL)
context_set(&t->ctx, CTX_UENTRY, (register_t)entry);
 189         if (stack != NULL)
context_set(&t->ctx, CTX_USTACK, (register_t)stack);
splx(s);
sched_unlock();
 194         return 0;
 195 }
 197 /*
 198  * Return the current thread.
 199  */
thread_t
thread_self(void)
 202 {
 204         return curthread;
 205 }
 207 /*
 208  * Return true if specified thread is valid.
 209  */
 210 int
thread_valid(thread_t t)
 212 {
list_t head, n;
thread_t tmp;
head = &thread_list;
 217         for (n = list_first(head); n != head; n = list_next(n)) {
tmp = list_entry(n, struct thread, link);
 219                 if (tmp == t)
 220                         return 1;
 221         }
 222         return 0;
 223 }
 225 /*
 226  * Release a current thread for other thread.
 227  */
 228 void
thread_yield(void)
 230 {
sched_yield();
 233 }
 235 /*
 236  * Suspend thread.
 237  *
 238  * A thread can be suspended any number of times.
 239  * And, it does not start to run again unless the thread
 240  * is resumed by the same count of suspend request.
 241  */
 242 int
thread_suspend(thread_t t)
 244 {
sched_lock();
 247         if (!thread_valid(t)) {
sched_unlock();
 249                 return ESRCH;
 250         }
 251         if (!task_access(t->task)) {
sched_unlock();
 253                 return EPERM;
 254         }
 255         if (++t->suscnt == 1)
sched_suspend(t);
sched_unlock();
 259         return 0;
 260 }
 262 /*
 263  * Resume thread.
 264  *
 265  * A thread does not begin to run, unless both thread
 266  * suspend count and task suspend count are set to 0.
 267  */
 268 int
thread_resume(thread_t t)
 270 {
ASSERT(t != curthread);
sched_lock();
 275         if (!thread_valid(t)) {
sched_unlock();
 277                 return ESRCH;
 278         }
 279         if (!task_access(t->task)) {
sched_unlock();
 281                 return EPERM;
 282         }
 283         if (t->suscnt == 0) {
sched_unlock();
 285                 return EINVAL;
 286         }
t->suscnt--;
 288         if (t->suscnt == 0 && t->task->suscnt == 0)
sched_resume(t);
sched_unlock();
 292         return 0;
 293 }
 295 /*
 296  * thread_schedparam - get/set scheduling parameter.
 297  */
 298 int
thread_schedparam(thread_t t, int op, int *param)
 300 {
 301         int pri, policy;
 302         int error = 0;
sched_lock();
 305         if (!thread_valid(t)) {
sched_unlock();
 307                 return ESRCH;
 308         }
 309         if (t->task->flags & TF_SYSTEM) {
sched_unlock();
 311                 return EINVAL;
 312         }
 313         /*
 314          * A thread can change the scheduling parameters of the
 315          * threads in the same task or threads in the child task.
 316          */
 317         if (!(t->task == curtask || t->task->parent == curtask) &&
 318             !task_capable(CAP_NICE)) {
sched_unlock();
 320                 return EPERM;
 321         }
 323         switch (op) {
 324         case SOP_GETPRI:
pri = sched_getpri(t);
 326                 if (copyout(&pri, param, sizeof(pri)))
error = EINVAL;
 328                 break;
 330         case SOP_SETPRI:
 331                 if (copyin(param, &pri, sizeof(pri))) {
error = EINVAL;
 333                         break;
 334                 }
 335                 /*
 336                  * Validate the priority range.
 337                  */
 338                 if (pri < 0)
pri = 0;
 340                 else if (pri >= PRI_IDLE)
pri = PRI_IDLE - 1;
 343                 /*
 344                  * If the caller has CAP_NICE capability, it can
 345                  * change the thread priority to any level.
 346                  * Otherwise, the caller can not set the priority
 347                  * to higher above realtime priority.
 348                  */
 349                 if (pri <= PRI_REALTIME && !task_capable(CAP_NICE)) {
error = EPERM;
 351                         break;
 352                 }
 353                 /*
 354                  * If a current priority is inherited for mutex,
 355                  * we can not change the priority to lower value.
 356                  * In this case, only the base priority is changed,
 357                  * and a current priority will be adjusted to
 358                  * correct value, later.
 359                  */
 360                 if (t->priority != t->basepri && pri > t->priority)
pri = t->priority;
mutex_setpri(t, pri);
sched_setpri(t, pri, pri);
 365                 break;
 367         case SOP_GETPOLICY:
policy = sched_getpolicy(t);
 369                 if (copyout(&policy, param, sizeof(policy)))
error = EINVAL;
 371                 break;
 373         case SOP_SETPOLICY:
 374                 if (copyin(param, &policy, sizeof(policy))) {
error = EINVAL;
 376                         break;
 377                 }
error = sched_setpolicy(t, policy);
 379                 break;
 381         default:
error = EINVAL;
 383                 break;
 384         }
sched_unlock();
 386         return error;
 387 }
 389 /*
 390  * Idle thread.
 391  *
 392  * Put the system into low power mode until we get an
 393  * interrupt.  Then, we try to release the current thread to
 394  * run the thread who was woken by ISR.  This routine is
 395  * called only once after kernel initialization is completed.
 396  */
 397 void
thread_idle(void)
 399 {
 401         for (;;) {
machine_idle();
sched_yield();
 404         }
 405 }
 407 /*
 408  * Allocate a thread.
 409  */
 410 static thread_t
thread_allocate(task_t task)
 412 {
 413         struct thread *t;
 414         void *stack;
 416         if ((t = kmem_alloc(sizeof(*t))) == NULL)
 417                 return NULL;
 419         if ((stack = kmem_alloc(KSTACKSZ)) == NULL) {
kmem_free(t);
 421                 return NULL;
 422         }
memset(t, 0, sizeof(*t));
t->kstack = stack;
t->task = task;
list_init(&t->mutexes);
list_insert(&thread_list, &t->link);
list_insert(&task->threads, &t->task_link);
task->nthreads++;
 432         return t;
 433 }
 435 /*
 436  * Deallocate a thread.
 437  *
 438  * We can not release the context of the "current" thread
 439  * because our thread switching always requires the current
 440  * context. So, the resource deallocation is deferred until
 441  * another thread calls thread_deallocate() later.
 442  */
 443 static void
thread_deallocate(thread_t t)
 445 {
list_remove(&t->task_link);
list_remove(&t->link);
t->excbits = 0;
t->task->nthreads--;
 452         if (zombie != NULL) {
 453                 /*
 454                  * Deallocate a zombie thread which
 455                  * was killed in previous request.
 456                  */
ASSERT(zombie != curthread);
kmem_free(zombie->kstack);
zombie->kstack = NULL;
kmem_free(zombie);
zombie = NULL;
 462         }
 463         if (t == curthread) {
 464                 /*
 465                  * Enter zombie state and wait for
 466                  * somebody to be killed us.
 467                  */
zombie = t;
 469                 return;
 470         }
kmem_free(t->kstack);
t->kstack = NULL;
kmem_free(t);
 475 }
 477 /*
 478  * Return thread information.
 479  */
 480 int
thread_info(struct threadinfo *info)
 482 {
u_long target = info->cookie;
u_long i = 0;
thread_t t;
list_t n;
sched_lock();
n = list_last(&thread_list);
 490         do {
 491                 if (i++ == target) {
t = list_entry(n, struct thread, link);
info->cookie = i;
info->id = t;
info->state = t->state;
info->policy = t->policy;
info->priority = t->priority;
info->basepri = t->basepri;
info->time = t->time;
info->suscnt = t->suscnt;
info->task = t->task;
info->active = (t == curthread) ? 1 : 0;
strlcpy(info->taskname, t->task->name, MAXTASKNAME);
strlcpy(info->slpevt, t->slpevt ?
t->slpevt->name : "-", MAXEVTNAME);
sched_unlock();
 507                         return 0;
 508                 }
n = list_prev(n);
 510         } while (n != &thread_list);
sched_unlock();
 512         return ESRCH;
 513 }
 515 /*
 516  * Create a thread running in the kernel address space.
 517  *
 518  * Since we disable an interrupt during thread switching, the
 519  * interrupt is still disabled at the entry of the kernel
 520  * thread.  So, the kernel thread must enable interrupts
 521  * immediately when it gets control.
 522  * This routine assumes the scheduler is already locked.
 523  */
thread_t
kthread_create(void (*entry)(void *), void *arg, int pri)
 526 {
thread_t t;
vaddr_t sp;
ASSERT(curthread->locks > 0);
 532         /*
 533          * If there is not enough core for the new thread,
 534          * the caller should just drop to panic().
 535          */
 536         if ((t = thread_allocate(&kernel_task)) == NULL)
 537                 return NULL;
memset(t->kstack, 0, KSTACKSZ);
sp = (vaddr_t)t->kstack + KSTACKSZ;
context_set(&t->ctx, CTX_KSTACK, (register_t)sp);
context_set(&t->ctx, CTX_KENTRY, (register_t)entry);
context_set(&t->ctx, CTX_KARG, (register_t)arg);
sched_start(t, pri, SCHED_FIFO);
t->suscnt = 1;
sched_resume(t);
 548         return t;
 549 }
 551 /*
 552  * Terminate a kernel thread.
 553  */
 554 void
kthread_terminate(thread_t t)
 556 {
ASSERT(t != NULL);
ASSERT(t->task->flags & TF_SYSTEM);
sched_lock();
mutex_cancel(t);
timer_cancel(t);
sched_stop(t);
thread_deallocate(t);
sched_unlock();
 568 }
 570 /*
 571  * The first thread in the system is created here by hand.
 572  * This thread will become an idle thread when thread_idle()
 573  * is called later in main().
 574  */
 575 void
thread_init(void)
 577 {
 578         void *stack;
vaddr_t sp;
list_init(&thread_list);
 583         if ((stack = kmem_alloc(KSTACKSZ)) == NULL)
panic("thread_init");
memset(stack, 0, KSTACKSZ);
sp = (vaddr_t)stack + KSTACKSZ;
context_set(&idle_thread.ctx, CTX_KSTACK, (register_t)sp);
sched_start(&idle_thread, PRI_IDLE, SCHED_FIFO);
idle_thread.kstack = stack;
idle_thread.task = &kernel_task;
idle_thread.state = TS_RUN;
idle_thread.locks = 1;
list_init(&idle_thread.mutexes);
list_insert(&thread_list, &idle_thread.link);
list_insert(&kernel_task.threads, &idle_thread.task_link);
kernel_task.nthreads = 1;
 599 }