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