source: mainline/kernel/generic/src/proc/task.c@ 55cc9bc

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 55cc9bc was 55cc9bc, checked in by Martin Decky <martin@…>, 19 years ago

revert 2040
  • Property mode set to 100644
File size: 12.6 KB
Line 
1/*
2 * Copyright (C) 2001-2004 Jakub Jermar
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
29/** @addtogroup genericproc
30 * @{
31 */
32
33/**
34 * @file
35 * @brief Task management.
36 */
37
38#include <main/uinit.h>
39#include <proc/thread.h>
40#include <proc/task.h>
41#include <proc/uarg.h>
42#include <mm/as.h>
43#include <mm/slab.h>
44#include <synch/spinlock.h>
45#include <arch.h>
46#include <panic.h>
47#include <adt/btree.h>
48#include <adt/list.h>
49#include <ipc/ipc.h>
50#include <security/cap.h>
51#include <memstr.h>
52#include <print.h>
53#include <lib/elf.h>
54#include <errno.h>
55#include <syscall/copy.h>
56#include <console/klog.h>
57
58#ifndef LOADED_PROG_STACK_PAGES_NO
59#define LOADED_PROG_STACK_PAGES_NO 1
60#endif
61
62/** Spinlock protecting the tasks_btree B+tree. */
63SPINLOCK_INITIALIZE(tasks_lock);
64
65/** B+tree of active tasks.
66 *
67 * The task is guaranteed to exist after it was found in the tasks_btree as long as:
68 * @li the tasks_lock is held,
69 * @li the task's lock is held when task's lock is acquired before releasing tasks_lock or
70 * @li the task's refcount is greater than 0
71 *
72 */
73btree_t tasks_btree;
74
75static task_id_t task_counter = 0;
76
77static void ktaskclnp(void *arg);
78static void ktaskgc(void *arg);
79
80/** Initialize tasks
81 *
82 * Initialize kernel tasks support.
83 *
84 */
85void task_init(void)
86{
87 TASK = NULL;
88 btree_create(&tasks_btree);
89}
90
91
92/** Create new task
93 *
94 * Create new task with no threads.
95 *
96 * @param as Task's address space.
97 * @param name Symbolic name.
98 *
99 * @return New task's structure
100 *
101 */
102task_t *task_create(as_t *as, char *name)
103{
104 ipl_t ipl;
105 task_t *ta;
106 int i;
107
108 ta = (task_t *) malloc(sizeof(task_t), 0);
109
110 task_create_arch(ta);
111
112 spinlock_initialize(&ta->lock, "task_ta_lock");
113 list_initialize(&ta->th_head);
114 ta->as = as;
115 ta->name = name;
116 ta->main_thread = NULL;
117 ta->refcount = 0;
118 ta->context = CONTEXT;
119
120 ta->capabilities = 0;
121 ta->accept_new_threads = true;
122 ta->cycles = 0;
123
124 ipc_answerbox_init(&ta->answerbox);
125 for (i = 0; i < IPC_MAX_PHONES; i++)
126 ipc_phone_init(&ta->phones[i]);
127 if ((ipc_phone_0) && (context_check(ipc_phone_0->task->context, ta->context)))
128 ipc_phone_connect(&ta->phones[0], ipc_phone_0);
129 atomic_set(&ta->active_calls, 0);
130
131 mutex_initialize(&ta->futexes_lock);
132 btree_create(&ta->futexes);
133
134 ipl = interrupts_disable();
135
136 /*
137 * Increment address space reference count.
138 * TODO: Reconsider the locking scheme.
139 */
140 mutex_lock(&as->lock);
141 as->refcount++;
142 mutex_unlock(&as->lock);
143
144 spinlock_lock(&tasks_lock);
145
146 ta->taskid = ++task_counter;
147 btree_insert(&tasks_btree, (btree_key_t) ta->taskid, (void *) ta, NULL);
148
149 spinlock_unlock(&tasks_lock);
150 interrupts_restore(ipl);
151
152 return ta;
153}
154
155/** Destroy task.
156 *
157 * @param t Task to be destroyed.
158 */
159void task_destroy(task_t *t)
160{
161 task_destroy_arch(t);
162 btree_destroy(&t->futexes);
163
164 mutex_lock_active(&t->as->lock);
165 if (--t->as->refcount == 0) {
166 mutex_unlock(&t->as->lock);
167 as_destroy(t->as);
168 /*
169 * t->as is destroyed.
170 */
171 } else
172 mutex_unlock(&t->as->lock);
173
174 free(t);
175 TASK = NULL;
176}
177
178/** Create new task with 1 thread and run it
179 *
180 * @param program_addr Address of program executable image.
181 * @param name Program name.
182 *
183 * @return Task of the running program or NULL on error.
184 */
185task_t * task_run_program(void *program_addr, char *name)
186{
187 as_t *as;
188 as_area_t *a;
189 int rc;
190 thread_t *t1, *t2;
191 task_t *task;
192 uspace_arg_t *kernel_uarg;
193
194 as = as_create(0);
195 ASSERT(as);
196
197 rc = elf_load((elf_header_t *) program_addr, as);
198 if (rc != EE_OK) {
199 as_destroy(as);
200 return NULL;
201 }
202
203 kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
204 kernel_uarg->uspace_entry = (void *) ((elf_header_t *) program_addr)->e_entry;
205 kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
206 kernel_uarg->uspace_thread_function = NULL;
207 kernel_uarg->uspace_thread_arg = NULL;
208 kernel_uarg->uspace_uarg = NULL;
209
210 task = task_create(as, name);
211 ASSERT(task);
212
213 /*
214 * Create the data as_area.
215 */
216 a = as_area_create(as, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
217 LOADED_PROG_STACK_PAGES_NO*PAGE_SIZE,
218 USTACK_ADDRESS, AS_AREA_ATTR_NONE, &anon_backend, NULL);
219
220 /*
221 * Create the main thread.
222 */
223 t1 = thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE, "uinit");
224 ASSERT(t1);
225
226 /*
227 * Create killer thread for the new task.
228 */
229 t2 = thread_create(ktaskgc, t1, task, 0, "ktaskgc");
230 ASSERT(t2);
231 thread_ready(t2);
232
233 thread_ready(t1);
234
235 return task;
236}
237
238/** Syscall for reading task ID from userspace.
239 *
240 * @param uspace_task_id Userspace address of 8-byte buffer where to store current task ID.
241 *
242 * @return 0 on success or an error code from @ref errno.h.
243 */
244unative_t sys_task_get_id(task_id_t *uspace_task_id)
245{
246 /*
247 * No need to acquire lock on TASK because taskid
248 * remains constant for the lifespan of the task.
249 */
250 return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid, sizeof(TASK->taskid));
251}
252
253/** Find task structure corresponding to task ID.
254 *
255 * The tasks_lock must be already held by the caller of this function
256 * and interrupts must be disabled.
257 *
258 * @param id Task ID.
259 *
260 * @return Task structure address or NULL if there is no such task ID.
261 */
262task_t *task_find_by_id(task_id_t id)
263{
264 btree_node_t *leaf;
265
266 return (task_t *) btree_search(&tasks_btree, (btree_key_t) id, &leaf);
267}
268
269/** Get accounting data of given task.
270 *
271 * Note that task_lock on @t must be already held and
272 * interrupts must be already disabled.
273 *
274 * @param t Pointer to thread.
275 *
276 */
277uint64_t task_get_accounting(task_t *t)
278{
279 /* Accumulated value of task */
280 uint64_t ret = t->cycles;
281
282 /* Current values of threads */
283 link_t *cur;
284 for (cur = t->th_head.next; cur != &t->th_head; cur = cur->next) {
285 thread_t *thr = list_get_instance(cur, thread_t, th_link);
286
287 spinlock_lock(&thr->lock);
288
289 if (thr == THREAD) /* Update accounting of current thread */
290 thread_update_accounting();
291 ret += thr->cycles;
292
293 spinlock_unlock(&thr->lock);
294 }
295
296 return ret;
297}
298
299/** Kill task.
300 *
301 * @param id ID of the task to be killed.
302 *
303 * @return 0 on success or an error code from errno.h
304 */
305int task_kill(task_id_t id)
306{
307 ipl_t ipl;
308 task_t *ta;
309 thread_t *t;
310 link_t *cur;
311
312 if (id == 1)
313 return EPERM;
314
315 ipl = interrupts_disable();
316 spinlock_lock(&tasks_lock);
317
318 if (!(ta = task_find_by_id(id))) {
319 spinlock_unlock(&tasks_lock);
320 interrupts_restore(ipl);
321 return ENOENT;
322 }
323
324 spinlock_lock(&ta->lock);
325 ta->refcount++;
326 spinlock_unlock(&ta->lock);
327
328 btree_remove(&tasks_btree, ta->taskid, NULL);
329 spinlock_unlock(&tasks_lock);
330
331 t = thread_create(ktaskclnp, NULL, ta, 0, "ktaskclnp");
332
333 spinlock_lock(&ta->lock);
334 ta->accept_new_threads = false;
335 ta->refcount--;
336
337 /*
338 * Interrupt all threads except ktaskclnp.
339 */
340 for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
341 thread_t *thr;
342 bool sleeping = false;
343
344 thr = list_get_instance(cur, thread_t, th_link);
345 if (thr == t)
346 continue;
347
348 spinlock_lock(&thr->lock);
349 thr->interrupted = true;
350 if (thr->state == Sleeping)
351 sleeping = true;
352 spinlock_unlock(&thr->lock);
353
354 if (sleeping)
355 waitq_interrupt_sleep(thr);
356 }
357
358 spinlock_unlock(&ta->lock);
359 interrupts_restore(ipl);
360
361 if (t)
362 thread_ready(t);
363
364 return 0;
365}
366
367/** Print task list */
368void task_print_list(void)
369{
370 link_t *cur;
371 ipl_t ipl;
372
373 /* Messing with thread structures, avoid deadlock */
374 ipl = interrupts_disable();
375 spinlock_lock(&tasks_lock);
376
377 printf("taskid name ctx address as cycles threads calls callee\n");
378 printf("------ ---------- --- ---------- ---------- ---------- ------- ------ ------>\n");
379
380 for (cur = tasks_btree.leaf_head.next; cur != &tasks_btree.leaf_head; cur = cur->next) {
381 btree_node_t *node;
382 int i;
383
384 node = list_get_instance(cur, btree_node_t, leaf_link);
385 for (i = 0; i < node->keys; i++) {
386 task_t *t;
387 int j;
388
389 t = (task_t *) node->value[i];
390
391 spinlock_lock(&t->lock);
392
393 uint64_t cycles = task_get_accounting(t);
394 char suffix;
395
396 if (cycles > 1000000000000000000LL) {
397 cycles = cycles / 1000000000000000000LL;
398 suffix = 'E';
399 } else if (cycles > 1000000000000LL) {
400 cycles = cycles / 1000000000000LL;
401 suffix = 'T';
402 } else if (cycles > 1000000LL) {
403 cycles = cycles / 1000000LL;
404 suffix = 'M';
405 } else
406 suffix = ' ';
407
408 printf("%-6lld %-10s %-3ld %#10zx %#10zx %9llu%c %7zd %6zd", t->taskid, t->name, t->context, t, t->as, cycles, suffix, t->refcount, atomic_get(&t->active_calls));
409 for (j = 0; j < IPC_MAX_PHONES; j++) {
410 if (t->phones[j].callee)
411 printf(" %zd:%#zx", j, t->phones[j].callee);
412 }
413 printf("\n");
414
415 spinlock_unlock(&t->lock);
416 }
417 }
418
419 spinlock_unlock(&tasks_lock);
420 interrupts_restore(ipl);
421}
422
423/** Kernel thread used to cleanup the task after it is killed. */
424void ktaskclnp(void *arg)
425{
426 ipl_t ipl;
427 thread_t *t = NULL, *main_thread;
428 link_t *cur;
429 bool again;
430
431 thread_detach(THREAD);
432
433loop:
434 ipl = interrupts_disable();
435 spinlock_lock(&TASK->lock);
436
437 main_thread = TASK->main_thread;
438
439 /*
440 * Find a thread to join.
441 */
442 again = false;
443 for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
444 t = list_get_instance(cur, thread_t, th_link);
445
446 spinlock_lock(&t->lock);
447 if (t == THREAD) {
448 spinlock_unlock(&t->lock);
449 continue;
450 } else if (t == main_thread) {
451 spinlock_unlock(&t->lock);
452 continue;
453 } else if (t->join_type != None) {
454 spinlock_unlock(&t->lock);
455 again = true;
456 continue;
457 } else {
458 t->join_type = TaskClnp;
459 spinlock_unlock(&t->lock);
460 again = false;
461 break;
462 }
463 }
464
465 spinlock_unlock(&TASK->lock);
466 interrupts_restore(ipl);
467
468 if (again) {
469 /*
470 * Other cleanup (e.g. ktaskgc) is in progress.
471 */
472 scheduler();
473 goto loop;
474 }
475
476 if (t != THREAD) {
477 ASSERT(t != main_thread); /* uninit is joined and detached in ktaskgc */
478 thread_join(t);
479 thread_detach(t);
480 goto loop; /* go for another thread */
481 }
482
483 /*
484 * Now there are no other threads in this task
485 * and no new threads can be created.
486 */
487
488 ipc_cleanup();
489 futex_cleanup();
490 klog_printf("Cleanup of task %lld completed.", TASK->taskid);
491}
492
493/** Kernel thread used to kill the userspace task when its main thread exits.
494 *
495 * This thread waits until the main userspace thread (i.e. uninit) exits.
496 * When this happens, the task is killed. In the meantime, exited threads
497 * are garbage collected.
498 *
499 * @param arg Pointer to the thread structure of the task's main thread.
500 */
501void ktaskgc(void *arg)
502{
503 thread_t *t = (thread_t *) arg;
504loop:
505 /*
506 * Userspace threads cannot detach themselves,
507 * therefore the thread pointer is guaranteed to be valid.
508 */
509 if (thread_join_timeout(t, 1000000, SYNCH_FLAGS_NONE) == ESYNCH_TIMEOUT) { /* sleep uninterruptibly here! */
510 ipl_t ipl;
511 link_t *cur;
512 thread_t *thr = NULL;
513
514 /*
515 * The join timed out. Try to do some garbage collection of Undead threads.
516 */
517more_gc:
518 ipl = interrupts_disable();
519 spinlock_lock(&TASK->lock);
520
521 for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
522 thr = list_get_instance(cur, thread_t, th_link);
523 spinlock_lock(&thr->lock);
524 if (thr != t && thr->state == Undead && thr->join_type == None) {
525 thr->join_type = TaskGC;
526 spinlock_unlock(&thr->lock);
527 break;
528 }
529 spinlock_unlock(&thr->lock);
530 thr = NULL;
531 }
532 spinlock_unlock(&TASK->lock);
533 interrupts_restore(ipl);
534
535 if (thr) {
536 thread_join(thr);
537 thread_detach(thr);
538 scheduler();
539 goto more_gc;
540 }
541
542 goto loop;
543 }
544 thread_detach(t);
545 task_kill(TASK->taskid);
546}
547
548/** @}
549 */
Note: See TracBrowser for help on using the repository browser.