Annotation of prex-old/sys/kern/thread.c, Revision 1.1
1.1 ! nbrk 1: /*-
! 2: * Copyright (c) 2005-2007, 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: */
! 29:
! 30: /*
! 31: * thread.c - thread management routines.
! 32: */
! 33:
! 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 <system.h>
! 42:
! 43: struct thread idle_thread;
! 44: thread_t cur_thread = &idle_thread;
! 45: static thread_t zombie;
! 46:
! 47: /*
! 48: * Allocate a new thread and attach kernel stack for it.
! 49: * Returns thread pointer on success, or NULL on failure.
! 50: */
! 51: static thread_t
! 52: thread_alloc(void)
! 53: {
! 54: thread_t th;
! 55: void *stack;
! 56:
! 57: if ((th = kmem_alloc(sizeof(struct thread))) == NULL)
! 58: return NULL;
! 59: memset(th, 0, sizeof(struct thread));
! 60:
! 61: if ((stack = kmem_alloc(KSTACK_SIZE)) == NULL) {
! 62: kmem_free(th);
! 63: return NULL;
! 64: }
! 65: th->kstack = stack;
! 66: th->magic = THREAD_MAGIC;
! 67: list_init(&th->mutexes);
! 68: return th;
! 69: }
! 70:
! 71: static void
! 72: thread_free(thread_t th)
! 73: {
! 74:
! 75: kmem_free(th->kstack);
! 76: kmem_free(th);
! 77: }
! 78:
! 79: /*
! 80: * Create a new thread within the specified task.
! 81: *
! 82: * The context of a current thread will be copied to the new thread.
! 83: * The new thread will start from the return address of thread_create()
! 84: * call in user mode code. Since a new thread will share the user
! 85: * mode stack with a current thread, user mode applications are
! 86: * responsible to allocate stack for it. The new thread is initially
! 87: * set to suspend state, and so, thread_resume() must be called to
! 88: * start it.
! 89: *
! 90: * The following scheduling parameters are reset to default values
! 91: * in the created thread.
! 92: * - Thread State
! 93: * - Scheduling Policy
! 94: * - Scheduling Priority
! 95: */
! 96: int
! 97: thread_create(task_t task, thread_t *thp)
! 98: {
! 99: thread_t th;
! 100: int err = 0;
! 101:
! 102: sched_lock();
! 103: if (!task_valid(task)) {
! 104: err = ESRCH;
! 105: goto out;
! 106: }
! 107: if (!task_access(task)) {
! 108: err = EPERM;
! 109: goto out;
! 110: }
! 111: if ((th = thread_alloc()) == NULL) {
! 112: err = ENOMEM;
! 113: goto out;
! 114: }
! 115: /*
! 116: * At first, we copy a new thread id as return value.
! 117: * This is done here to simplify all error recoveries
! 118: * of the subsequent code.
! 119: */
! 120: if (cur_task() == &kern_task)
! 121: *thp = th;
! 122: else {
! 123: if (umem_copyout(&th, thp, sizeof(thread_t))) {
! 124: thread_free(th);
! 125: err = EFAULT;
! 126: goto out;
! 127: }
! 128: }
! 129: /*
! 130: * Initialize thread state.
! 131: */
! 132: th->task = task;
! 133: th->suspend_count = task->suspend_count + 1;
! 134: memcpy(th->kstack, cur_thread->kstack, KSTACK_SIZE);
! 135: context_init(&th->context, (u_long)th->kstack + KSTACK_SIZE);
! 136: list_insert(&task->threads, &th->task_link);
! 137: sched_start(th);
! 138: out:
! 139: sched_unlock();
! 140: return err;
! 141: }
! 142:
! 143: /*
! 144: * Permanently stop execution of the specified thread.
! 145: * If given thread is a current thread, this routine never returns.
! 146: */
! 147: int
! 148: thread_terminate(thread_t th)
! 149: {
! 150: int err;
! 151:
! 152: sched_lock();
! 153: if (!thread_valid(th)) {
! 154: err = ESRCH;
! 155: } else if (!task_access(th->task)) {
! 156: err = EPERM;
! 157: } else {
! 158: err = thread_kill(th);
! 159: }
! 160: sched_unlock();
! 161: return err;
! 162: }
! 163:
! 164: /*
! 165: * Kill a thread regardless of the current task state.
! 166: *
! 167: * This may be used to terminate a kernel thread under the non-context
! 168: * condition. For example, a device driver may terminate its interrupt
! 169: * thread even if a current task does not have the capability to
! 170: * terminate it.
! 171: */
! 172: int
! 173: thread_kill(thread_t th)
! 174: {
! 175: /*
! 176: * Clean up thread state.
! 177: */
! 178: msg_cleanup(th);
! 179: timer_cleanup(th);
! 180: mutex_cleanup(th);
! 181: list_remove(&th->task_link);
! 182: sched_stop(th);
! 183: th->exc_bitmap = 0;
! 184: th->magic = 0;
! 185:
! 186: /*
! 187: * We can not release the context of the "current" thread
! 188: * because our thread switching always requires the current
! 189: * context. So, the resource deallocation is deferred until
! 190: * another thread calls thread_kill().
! 191: */
! 192: if (zombie != NULL) {
! 193: /*
! 194: * Deallocate a zombie thread which was killed
! 195: * in previous request.
! 196: */
! 197: ASSERT(zombie != cur_thread);
! 198: thread_free(zombie);
! 199: zombie = NULL;
! 200: }
! 201: if (th == cur_thread) {
! 202: /*
! 203: * If the current thread is being terminated,
! 204: * enter zombie state and wait for sombody
! 205: * to be killed us.
! 206: */
! 207: zombie = th;
! 208: } else
! 209: thread_free(th);
! 210: return 0;
! 211: }
! 212:
! 213: /*
! 214: * Load entry/stack address of the user mode context.
! 215: *
! 216: * The entry and stack address can be set to NULL.
! 217: * If it is NULL, old state is just kept.
! 218: */
! 219: int
! 220: thread_load(thread_t th, void (*entry)(void), void *stack)
! 221: {
! 222: int err = 0;
! 223:
! 224: if ((entry != NULL && !user_area(entry)) ||
! 225: (stack != NULL && !user_area(stack)))
! 226: return EINVAL;
! 227:
! 228: sched_lock();
! 229: if (!thread_valid(th)) {
! 230: err = ESRCH;
! 231: } else if (!task_access(th->task)) {
! 232: err = EPERM;
! 233: } else {
! 234: if (entry != NULL)
! 235: context_set(&th->context, CTX_UENTRY, (u_long)entry);
! 236: if (stack != NULL)
! 237: context_set(&th->context, CTX_USTACK, (u_long)stack);
! 238: }
! 239: sched_unlock();
! 240: return 0;
! 241: }
! 242:
! 243: thread_t
! 244: thread_self(void)
! 245: {
! 246:
! 247: return cur_thread;
! 248: }
! 249:
! 250: /*
! 251: * Release current thread for other thread.
! 252: */
! 253: void
! 254: thread_yield(void)
! 255: {
! 256:
! 257: sched_yield();
! 258: }
! 259:
! 260: /*
! 261: * Suspend thread.
! 262: *
! 263: * A thread can be suspended any number of times. And, it does
! 264: * not start to run again unless the thread is resumed by the
! 265: * same count of suspend request.
! 266: */
! 267: int
! 268: thread_suspend(thread_t th)
! 269: {
! 270: int err = 0;
! 271:
! 272: sched_lock();
! 273: if (!thread_valid(th)) {
! 274: err = ESRCH;
! 275: } else if (!task_access(th->task)) {
! 276: err = EPERM;
! 277: } else {
! 278: if (++th->suspend_count == 1)
! 279: sched_suspend(th);
! 280: }
! 281: sched_unlock();
! 282: return 0;
! 283: }
! 284:
! 285: /*
! 286: * Resume thread.
! 287: *
! 288: * A thread does not begin to run, unless both thread
! 289: * suspend count and task suspend count are set to 0.
! 290: */
! 291: int
! 292: thread_resume(thread_t th)
! 293: {
! 294: int err = 0;
! 295:
! 296: ASSERT(th != cur_thread);
! 297:
! 298: sched_lock();
! 299: if (!thread_valid(th)) {
! 300: err = ESRCH;
! 301: } else if (!task_access(th->task)) {
! 302: err= EPERM;
! 303: } else if (th->suspend_count == 0) {
! 304: err = EINVAL;
! 305: } else {
! 306: th->suspend_count--;
! 307: if (th->suspend_count == 0 && th->task->suspend_count == 0)
! 308: sched_resume(th);
! 309: }
! 310: sched_unlock();
! 311: return err;
! 312: }
! 313:
! 314: /*
! 315: * thread_schedparam - get/set scheduling parameter.
! 316: * @th: target thread
! 317: * @op: operation ID
! 318: * @param: pointer to parameter
! 319: *
! 320: * If the caller has CAP_NICE capability, all operations are allowed.
! 321: * Otherwise, the caller can change the parameter for the threads in
! 322: * the same task, and it can not set the priority to higher value.
! 323: */
! 324: int
! 325: thread_schedparam(thread_t th, int op, int *param)
! 326: {
! 327: int prio, policy, err = 0;
! 328: int capable = 0;
! 329:
! 330: sched_lock();
! 331: if (!thread_valid(th)) {
! 332: sched_unlock();
! 333: return ESRCH;
! 334: }
! 335: if (task_capable(CAP_NICE))
! 336: capable = 1;
! 337:
! 338: if (th->task != cur_task() && !capable) {
! 339: sched_unlock();
! 340: return EPERM;
! 341: }
! 342: if ((th->task == &kern_task) &&
! 343: (op == OP_SETPRIO || op == OP_SETPOLICY)) {
! 344: sched_unlock();
! 345: return EPERM;
! 346: }
! 347: switch (op) {
! 348: case OP_GETPRIO:
! 349: prio = sched_getprio(th);
! 350: err = umem_copyout(&prio, param, sizeof(int));
! 351: break;
! 352: case OP_SETPRIO:
! 353: if ((err = umem_copyin(param, &prio, sizeof(int))))
! 354: break;
! 355: if (prio < 0)
! 356: prio = 0;
! 357: else if (prio >= PRIO_IDLE)
! 358: prio = PRIO_IDLE - 1;
! 359:
! 360: if (prio < th->prio && !capable) {
! 361: err = EPERM;
! 362: break;
! 363: }
! 364: /*
! 365: * If a current priority is inherited for mutex,
! 366: * we can not change the priority to lower value.
! 367: * In this case, only the base priority is changed,
! 368: * and a current priority will be adjusted to correct
! 369: * value, later.
! 370: */
! 371: if (th->prio != th->base_prio && prio > th->prio)
! 372: prio = th->prio;
! 373:
! 374: mutex_setprio(th, prio);
! 375: sched_setprio(th, prio, prio);
! 376: break;
! 377: case OP_GETPOLICY:
! 378: policy = sched_getpolicy(th);
! 379: err = umem_copyout(&policy, param, sizeof(int));
! 380: break;
! 381: case OP_SETPOLICY:
! 382: if ((err = umem_copyin(param, &policy, sizeof(int))))
! 383: break;
! 384: if (sched_setpolicy(th, policy))
! 385: err = EINVAL;
! 386: break;
! 387: default:
! 388: err = EINVAL;
! 389: break;
! 390: }
! 391: sched_unlock();
! 392: return err;
! 393: }
! 394:
! 395: /*
! 396: * Idle thread.
! 397: *
! 398: * This routine is called only once after kernel initialization
! 399: * is completed. An idle thread has the role of cutting down the power
! 400: * consumption of a system. An idle thread has FIFO scheduling policy
! 401: * because it does not have time quantum.
! 402: */
! 403: void
! 404: thread_idle(void)
! 405: {
! 406:
! 407: for (;;) {
! 408: machine_idle();
! 409: sched_yield();
! 410: }
! 411: /* NOTREACHED */
! 412: }
! 413:
! 414: /*
! 415: * Create a thread running in the kernel address space.
! 416: *
! 417: * A kernel thread does not have user mode context, and its
! 418: * scheduling policy is set to SCHED_FIFO. kernel_thread() returns
! 419: * thread ID on success, or NULL on failure. We assume scheduler
! 420: * is already locked.
! 421: *
! 422: * Important: Since sched_switch() will disable interrupts in CPU,
! 423: * the interrupt is always disabled at the entry point of the kernel
! 424: * thread. So, the kernel thread must enable the interrupt first when
! 425: * it gets control.
! 426: */
! 427: thread_t
! 428: kernel_thread(int prio, void (*entry)(u_long), u_long arg)
! 429: {
! 430: thread_t th;
! 431:
! 432: if ((th = thread_alloc()) == NULL)
! 433: return NULL;
! 434:
! 435: th->task = &kern_task;
! 436: memset(th->kstack, 0, KSTACK_SIZE);
! 437: context_init(&th->context, (u_long)th->kstack + KSTACK_SIZE);
! 438: context_set(&th->context, CTX_KENTRY, (u_long)entry);
! 439: context_set(&th->context, CTX_KARG, arg);
! 440: list_insert(&kern_task.threads, &th->task_link);
! 441:
! 442: sched_start(th);
! 443: sched_setpolicy(th, SCHED_FIFO);
! 444: sched_setprio(th, prio, prio);
! 445: sched_resume(th);
! 446: return th;
! 447: }
! 448:
! 449: /*
! 450: * Return thread information for ps command.
! 451: */
! 452: int
! 453: thread_info(struct info_thread *info)
! 454: {
! 455: u_long index, target = info->cookie;
! 456: list_t i, j;
! 457: thread_t th;
! 458: task_t task;
! 459:
! 460: sched_lock();
! 461: index = 0;
! 462: i = &kern_task.link;
! 463: do {
! 464: task = list_entry(i, struct task, link);
! 465: j = &task->threads;
! 466: j = list_first(j);
! 467: do {
! 468: th = list_entry(j, struct thread, task_link);
! 469: if (index++ == target)
! 470: goto found;
! 471: j = list_next(j);
! 472: } while (j != &task->threads);
! 473: i = list_next(i);
! 474: } while (i != &kern_task.link);
! 475:
! 476: sched_unlock();
! 477: return ESRCH;
! 478: found:
! 479: info->state = th->state;
! 480: info->policy = th->policy;
! 481: info->prio = th->prio;
! 482: info->base_prio = th->base_prio;
! 483: info->suspend_count = th->suspend_count;
! 484: info->total_ticks = th->total_ticks;
! 485: info->id = th;
! 486: info->task = th->task;
! 487: strlcpy(info->task_name, task->name, MAXTASKNAME);
! 488: strlcpy(info->sleep_event,
! 489: th->sleep_event ? th->sleep_event->name : "-", 12);
! 490:
! 491: sched_unlock();
! 492: return 0;
! 493: }
! 494:
! 495: #if defined(DEBUG) && defined(CONFIG_KDUMP)
! 496: void
! 497: thread_dump(void)
! 498: {
! 499: static const char state[][4] = \
! 500: { "RUN", "SLP", "SUS", "S&S", "EXT" };
! 501: static const char pol[][5] = { "FIFO", "RR " };
! 502: list_t i, j;
! 503: thread_t th;
! 504: task_t task;
! 505:
! 506: printk("Thread dump:\n");
! 507: printk(" mod thread task stat pol prio base ticks "
! 508: "susp sleep event\n");
! 509: printk(" --- -------- -------- ---- ---- ---- ---- -------- "
! 510: "---- ------------\n");
! 511:
! 512: i = &kern_task.link;
! 513: do {
! 514: task = list_entry(i, struct task, link);
! 515: j = &task->threads;
! 516: j = list_first(j);
! 517: do {
! 518: th = list_entry(j, struct thread, task_link);
! 519: printk(" %s %08x %8s %s%c %s %3d %3d %8d %4d %s\n",
! 520: (task == &kern_task) ? "Knl" : "Usr", th,
! 521: task->name, state[th->state],
! 522: (th == cur_thread) ? '*' : ' ',
! 523: pol[th->policy], th->prio, th->base_prio,
! 524: th->total_ticks, th->suspend_count,
! 525: th->sleep_event ? th->sleep_event->name : "-");
! 526: j = list_next(j);
! 527: } while (j != &task->threads);
! 528: i = list_next(i);
! 529: } while (i != &kern_task.link);
! 530: }
! 531: #endif
! 532:
! 533: /*
! 534: * The first thread in system is created here by hand. This thread
! 535: * will become an idle thread when thread_idle() is called later.
! 536: */
! 537: void
! 538: thread_init(void)
! 539: {
! 540: void *stack;
! 541:
! 542: if ((stack = kmem_alloc(KSTACK_SIZE)) == NULL)
! 543: panic("thread_init");
! 544:
! 545: memset(stack, 0, KSTACK_SIZE);
! 546: idle_thread.kstack = stack;
! 547: idle_thread.magic = THREAD_MAGIC;
! 548: idle_thread.task = &kern_task;
! 549: idle_thread.state = TH_RUN;
! 550: idle_thread.policy = SCHED_FIFO;
! 551: idle_thread.prio = PRIO_IDLE;
! 552: idle_thread.base_prio = PRIO_IDLE;
! 553: idle_thread.lock_count = 1;
! 554:
! 555: context_init(&idle_thread.context, (u_long)stack + KSTACK_SIZE);
! 556: list_insert(&kern_task.threads, &idle_thread.task_link);
! 557: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to thread.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / sys / kern