Rev 2803 | Rev 2825 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1 | jermar | 1 | /* |
2071 | jermar | 2 | * Copyright (c) 2001-2004 Jakub Jermar |
1 | 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 | |||
1757 | jermar | 29 | /** @addtogroup genericproc |
1702 | cejka | 30 | * @{ |
31 | */ |
||
32 | |||
1248 | jermar | 33 | /** |
1702 | cejka | 34 | * @file |
1248 | jermar | 35 | * @brief Task management. |
36 | */ |
||
37 | |||
973 | palkovsky | 38 | #include <main/uinit.h> |
1 | jermar | 39 | #include <proc/thread.h> |
40 | #include <proc/task.h> |
||
1078 | jermar | 41 | #include <proc/uarg.h> |
703 | jermar | 42 | #include <mm/as.h> |
814 | palkovsky | 43 | #include <mm/slab.h> |
2183 | jermar | 44 | #include <atomic.h> |
1 | jermar | 45 | #include <synch/spinlock.h> |
2109 | jermar | 46 | #include <synch/waitq.h> |
1 | jermar | 47 | #include <arch.h> |
48 | #include <panic.h> |
||
2504 | jermar | 49 | #include <adt/avl.h> |
1159 | jermar | 50 | #include <adt/btree.h> |
788 | jermar | 51 | #include <adt/list.h> |
955 | palkovsky | 52 | #include <ipc/ipc.h> |
1174 | jermar | 53 | #include <security/cap.h> |
955 | palkovsky | 54 | #include <memstr.h> |
1060 | palkovsky | 55 | #include <print.h> |
2000 | decky | 56 | #include <lib/elf.h> |
1579 | jermar | 57 | #include <errno.h> |
2050 | decky | 58 | #include <func.h> |
1288 | jermar | 59 | #include <syscall/copy.h> |
973 | palkovsky | 60 | |
1170 | vana | 61 | #ifndef LOADED_PROG_STACK_PAGES_NO |
62 | #define LOADED_PROG_STACK_PAGES_NO 1 |
||
63 | #endif |
||
1168 | vana | 64 | |
2504 | jermar | 65 | /** Spinlock protecting the tasks_tree AVL tree. */ |
623 | jermar | 66 | SPINLOCK_INITIALIZE(tasks_lock); |
1636 | jermar | 67 | |
2504 | jermar | 68 | /** AVL tree of active tasks. |
1636 | jermar | 69 | * |
2504 | jermar | 70 | * The task is guaranteed to exist after it was found in the tasks_tree as |
2087 | jermar | 71 | * long as: |
1636 | jermar | 72 | * @li the tasks_lock is held, |
2087 | jermar | 73 | * @li the task's lock is held when task's lock is acquired before releasing |
74 | * tasks_lock or |
||
1880 | jermar | 75 | * @li the task's refcount is greater than 0 |
1636 | jermar | 76 | * |
77 | */ |
||
2504 | jermar | 78 | avltree_t tasks_tree; |
1636 | jermar | 79 | |
1005 | palkovsky | 80 | static task_id_t task_counter = 0; |
1 | jermar | 81 | |
107 | decky | 82 | /** Initialize tasks |
83 | * |
||
84 | * Initialize kernel tasks support. |
||
85 | * |
||
86 | */ |
||
1 | jermar | 87 | void task_init(void) |
88 | { |
||
15 | jermar | 89 | TASK = NULL; |
2504 | jermar | 90 | avltree_create(&tasks_tree); |
1 | jermar | 91 | } |
92 | |||
2504 | jermar | 93 | /* |
94 | * The idea behind this walker is to remember a single task different from TASK. |
||
95 | */ |
||
96 | static bool task_done_walker(avltree_node_t *node, void *arg) |
||
97 | { |
||
98 | task_t *t = avltree_get_instance(node, task_t, tasks_tree_node); |
||
99 | task_t **tp = (task_t **) arg; |
||
100 | |||
101 | if (t != TASK) { |
||
102 | *tp = t; |
||
103 | return false; /* stop walking */ |
||
104 | } |
||
105 | |||
106 | return true; /* continue the walk */ |
||
107 | } |
||
108 | |||
2227 | decky | 109 | /** Kill all tasks except the current task. |
110 | * |
||
111 | */ |
||
112 | void task_done(void) |
||
113 | { |
||
114 | task_t *t; |
||
115 | do { /* Repeat until there are any tasks except TASK */ |
||
116 | |||
117 | /* Messing with task structures, avoid deadlock */ |
||
118 | ipl_t ipl = interrupts_disable(); |
||
119 | spinlock_lock(&tasks_lock); |
||
120 | |||
121 | t = NULL; |
||
2504 | jermar | 122 | avltree_walk(&tasks_tree, task_done_walker, &t); |
2227 | decky | 123 | |
124 | if (t != NULL) { |
||
125 | task_id_t id = t->taskid; |
||
126 | |||
127 | spinlock_unlock(&tasks_lock); |
||
128 | interrupts_restore(ipl); |
||
129 | |||
130 | #ifdef CONFIG_DEBUG |
||
131 | printf("Killing task %llu\n", id); |
||
132 | #endif |
||
133 | task_kill(id); |
||
2632 | decky | 134 | thread_usleep(10000); |
2227 | decky | 135 | } else { |
136 | spinlock_unlock(&tasks_lock); |
||
137 | interrupts_restore(ipl); |
||
138 | } |
||
139 | |||
140 | } while (t != NULL); |
||
141 | } |
||
107 | decky | 142 | |
143 | /** Create new task |
||
144 | * |
||
145 | * Create new task with no threads. |
||
146 | * |
||
703 | jermar | 147 | * @param as Task's address space. |
1062 | jermar | 148 | * @param name Symbolic name. |
107 | decky | 149 | * |
973 | palkovsky | 150 | * @return New task's structure |
107 | decky | 151 | * |
152 | */ |
||
1062 | jermar | 153 | task_t *task_create(as_t *as, char *name) |
1 | jermar | 154 | { |
413 | jermar | 155 | ipl_t ipl; |
1 | jermar | 156 | task_t *ta; |
1040 | palkovsky | 157 | int i; |
1 | jermar | 158 | |
822 | palkovsky | 159 | ta = (task_t *) malloc(sizeof(task_t), 0); |
160 | |||
1185 | jermar | 161 | task_create_arch(ta); |
162 | |||
822 | palkovsky | 163 | spinlock_initialize(&ta->lock, "task_ta_lock"); |
164 | list_initialize(&ta->th_head); |
||
165 | ta->as = as; |
||
1062 | jermar | 166 | ta->name = name; |
2446 | jermar | 167 | atomic_set(&ta->refcount, 0); |
168 | atomic_set(&ta->lifecount, 0); |
||
1839 | decky | 169 | ta->context = CONTEXT; |
1579 | jermar | 170 | |
1174 | jermar | 171 | ta->capabilities = 0; |
2039 | decky | 172 | ta->cycles = 0; |
2803 | svoboda | 173 | |
174 | ta->being_debugged = false; |
||
175 | ta->stop_request = false; |
||
176 | ta->debug_begin_call = NULL; |
||
177 | ta->debug_go_call = NULL; |
||
2804 | svoboda | 178 | ta->not_stoppable_count = 0; |
2799 | svoboda | 179 | |
2800 | svoboda | 180 | ipc_answerbox_init(&ta->answerbox, ta); |
1839 | decky | 181 | for (i = 0; i < IPC_MAX_PHONES; i++) |
1040 | palkovsky | 182 | ipc_phone_init(&ta->phones[i]); |
2087 | jermar | 183 | if ((ipc_phone_0) && (context_check(ipc_phone_0->task->context, |
184 | ta->context))) |
||
1040 | palkovsky | 185 | ipc_phone_connect(&ta->phones[0], ipc_phone_0); |
998 | palkovsky | 186 | atomic_set(&ta->active_calls, 0); |
1460 | jermar | 187 | |
188 | mutex_initialize(&ta->futexes_lock); |
||
189 | btree_create(&ta->futexes); |
||
822 | palkovsky | 190 | |
191 | ipl = interrupts_disable(); |
||
1468 | jermar | 192 | |
193 | /* |
||
194 | * Increment address space reference count. |
||
195 | */ |
||
2183 | jermar | 196 | atomic_inc(&as->refcount); |
1468 | jermar | 197 | |
822 | palkovsky | 198 | spinlock_lock(&tasks_lock); |
1005 | palkovsky | 199 | ta->taskid = ++task_counter; |
2504 | jermar | 200 | avltree_node_initialize(&ta->tasks_tree_node); |
201 | ta->tasks_tree_node.key = ta->taskid; |
||
202 | avltree_insert(&tasks_tree, &ta->tasks_tree_node); |
||
822 | palkovsky | 203 | spinlock_unlock(&tasks_lock); |
204 | interrupts_restore(ipl); |
||
205 | |||
1 | jermar | 206 | return ta; |
207 | } |
||
208 | |||
1579 | jermar | 209 | /** Destroy task. |
210 | * |
||
211 | * @param t Task to be destroyed. |
||
212 | */ |
||
213 | void task_destroy(task_t *t) |
||
214 | { |
||
2446 | jermar | 215 | /* |
216 | * Remove the task from the task B+tree. |
||
217 | */ |
||
218 | spinlock_lock(&tasks_lock); |
||
2504 | jermar | 219 | avltree_delete(&tasks_tree, &t->tasks_tree_node); |
2446 | jermar | 220 | spinlock_unlock(&tasks_lock); |
221 | |||
222 | /* |
||
223 | * Perform architecture specific task destruction. |
||
224 | */ |
||
1587 | jermar | 225 | task_destroy_arch(t); |
2446 | jermar | 226 | |
227 | /* |
||
228 | * Free up dynamically allocated state. |
||
229 | */ |
||
1587 | jermar | 230 | btree_destroy(&t->futexes); |
231 | |||
2446 | jermar | 232 | /* |
233 | * Drop our reference to the address space. |
||
234 | */ |
||
2183 | jermar | 235 | if (atomic_predec(&t->as->refcount) == 0) |
1587 | jermar | 236 | as_destroy(t->as); |
237 | |||
238 | free(t); |
||
239 | TASK = NULL; |
||
1579 | jermar | 240 | } |
241 | |||
973 | palkovsky | 242 | /** Create new task with 1 thread and run it |
243 | * |
||
1248 | jermar | 244 | * @param program_addr Address of program executable image. |
1062 | jermar | 245 | * @param name Program name. |
246 | * |
||
1229 | jermar | 247 | * @return Task of the running program or NULL on error. |
973 | palkovsky | 248 | */ |
2436 | jermar | 249 | task_t *task_run_program(void *program_addr, char *name) |
973 | palkovsky | 250 | { |
251 | as_t *as; |
||
252 | as_area_t *a; |
||
2745 | decky | 253 | unsigned int rc; |
2446 | jermar | 254 | thread_t *t; |
973 | palkovsky | 255 | task_t *task; |
1078 | jermar | 256 | uspace_arg_t *kernel_uarg; |
973 | palkovsky | 257 | |
258 | as = as_create(0); |
||
1115 | jermar | 259 | ASSERT(as); |
973 | palkovsky | 260 | |
1025 | palkovsky | 261 | rc = elf_load((elf_header_t *) program_addr, as); |
973 | palkovsky | 262 | if (rc != EE_OK) { |
1468 | jermar | 263 | as_destroy(as); |
973 | palkovsky | 264 | return NULL; |
265 | } |
||
266 | |||
1078 | jermar | 267 | kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0); |
2087 | jermar | 268 | kernel_uarg->uspace_entry = |
269 | (void *) ((elf_header_t *) program_addr)->e_entry; |
||
1078 | jermar | 270 | kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS; |
271 | kernel_uarg->uspace_thread_function = NULL; |
||
272 | kernel_uarg->uspace_thread_arg = NULL; |
||
273 | kernel_uarg->uspace_uarg = NULL; |
||
1066 | jermar | 274 | |
1062 | jermar | 275 | task = task_create(as, name); |
1115 | jermar | 276 | ASSERT(task); |
277 | |||
973 | palkovsky | 278 | /* |
279 | * Create the data as_area. |
||
280 | */ |
||
2087 | jermar | 281 | a = as_area_create(as, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE, |
282 | LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS, |
||
283 | AS_AREA_ATTR_NONE, &anon_backend, NULL); |
||
1115 | jermar | 284 | |
1585 | jermar | 285 | /* |
286 | * Create the main thread. |
||
287 | */ |
||
2446 | jermar | 288 | t = thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE, |
2087 | jermar | 289 | "uinit", false); |
2446 | jermar | 290 | ASSERT(t); |
973 | palkovsky | 291 | |
2446 | jermar | 292 | thread_ready(t); |
1585 | jermar | 293 | |
973 | palkovsky | 294 | return task; |
295 | } |
||
1060 | palkovsky | 296 | |
1176 | jermar | 297 | /** Syscall for reading task ID from userspace. |
298 | * |
||
2087 | jermar | 299 | * @param uspace_task_id Userspace address of 8-byte buffer where to store |
300 | * current task ID. |
||
1176 | jermar | 301 | * |
1288 | jermar | 302 | * @return 0 on success or an error code from @ref errno.h. |
1176 | jermar | 303 | */ |
1780 | jermar | 304 | unative_t sys_task_get_id(task_id_t *uspace_task_id) |
1176 | jermar | 305 | { |
306 | /* |
||
307 | * No need to acquire lock on TASK because taskid |
||
308 | * remains constant for the lifespan of the task. |
||
309 | */ |
||
2087 | jermar | 310 | return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid, |
311 | sizeof(TASK->taskid)); |
||
1176 | jermar | 312 | } |
313 | |||
1178 | jermar | 314 | /** Find task structure corresponding to task ID. |
315 | * |
||
316 | * The tasks_lock must be already held by the caller of this function |
||
317 | * and interrupts must be disabled. |
||
318 | * |
||
319 | * @param id Task ID. |
||
320 | * |
||
321 | * @return Task structure address or NULL if there is no such task ID. |
||
322 | */ |
||
323 | task_t *task_find_by_id(task_id_t id) |
||
324 | { |
||
2504 | jermar | 325 | avltree_node_t *node; |
1178 | jermar | 326 | |
2504 | jermar | 327 | node = avltree_search(&tasks_tree, (avltree_key_t) id); |
328 | |||
329 | if (node) |
||
330 | return avltree_get_instance(node, task_t, tasks_tree_node); |
||
331 | return NULL; |
||
1178 | jermar | 332 | } |
333 | |||
2039 | decky | 334 | /** Get accounting data of given task. |
335 | * |
||
2048 | jermar | 336 | * Note that task lock of 't' must be already held and |
2039 | decky | 337 | * interrupts must be already disabled. |
338 | * |
||
339 | * @param t Pointer to thread. |
||
340 | * |
||
341 | */ |
||
342 | uint64_t task_get_accounting(task_t *t) |
||
343 | { |
||
344 | /* Accumulated value of task */ |
||
345 | uint64_t ret = t->cycles; |
||
346 | |||
347 | /* Current values of threads */ |
||
348 | link_t *cur; |
||
349 | for (cur = t->th_head.next; cur != &t->th_head; cur = cur->next) { |
||
350 | thread_t *thr = list_get_instance(cur, thread_t, th_link); |
||
351 | |||
352 | spinlock_lock(&thr->lock); |
||
2042 | decky | 353 | /* Process only counted threads */ |
354 | if (!thr->uncounted) { |
||
2087 | jermar | 355 | if (thr == THREAD) { |
356 | /* Update accounting of current thread */ |
||
357 | thread_update_accounting(); |
||
358 | } |
||
2042 | decky | 359 | ret += thr->cycles; |
360 | } |
||
2039 | decky | 361 | spinlock_unlock(&thr->lock); |
362 | } |
||
363 | |||
364 | return ret; |
||
365 | } |
||
366 | |||
1579 | jermar | 367 | /** Kill task. |
368 | * |
||
2446 | jermar | 369 | * This function is idempotent. |
370 | * It signals all the task's threads to bail it out. |
||
371 | * |
||
1579 | jermar | 372 | * @param id ID of the task to be killed. |
373 | * |
||
374 | * @return 0 on success or an error code from errno.h |
||
375 | */ |
||
376 | int task_kill(task_id_t id) |
||
377 | { |
||
378 | ipl_t ipl; |
||
379 | task_t *ta; |
||
380 | link_t *cur; |
||
1600 | jermar | 381 | |
382 | if (id == 1) |
||
383 | return EPERM; |
||
1579 | jermar | 384 | |
385 | ipl = interrupts_disable(); |
||
386 | spinlock_lock(&tasks_lock); |
||
387 | if (!(ta = task_find_by_id(id))) { |
||
388 | spinlock_unlock(&tasks_lock); |
||
389 | interrupts_restore(ipl); |
||
390 | return ENOENT; |
||
391 | } |
||
1587 | jermar | 392 | spinlock_unlock(&tasks_lock); |
1579 | jermar | 393 | |
1585 | jermar | 394 | /* |
1687 | jermar | 395 | * Interrupt all threads except ktaskclnp. |
2446 | jermar | 396 | */ |
397 | spinlock_lock(&ta->lock); |
||
1579 | jermar | 398 | for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) { |
399 | thread_t *thr; |
||
2446 | jermar | 400 | bool sleeping = false; |
1579 | jermar | 401 | |
402 | thr = list_get_instance(cur, thread_t, th_link); |
||
403 | |||
404 | spinlock_lock(&thr->lock); |
||
405 | thr->interrupted = true; |
||
406 | if (thr->state == Sleeping) |
||
407 | sleeping = true; |
||
408 | spinlock_unlock(&thr->lock); |
||
409 | |||
410 | if (sleeping) |
||
2109 | jermar | 411 | waitq_interrupt_sleep(thr); |
1579 | jermar | 412 | } |
1580 | jermar | 413 | spinlock_unlock(&ta->lock); |
414 | interrupts_restore(ipl); |
||
1579 | jermar | 415 | |
416 | return 0; |
||
417 | } |
||
418 | |||
2504 | jermar | 419 | static bool task_print_walker(avltree_node_t *node, void *arg) |
420 | { |
||
421 | task_t *t = avltree_get_instance(node, task_t, tasks_tree_node); |
||
422 | int j; |
||
423 | |||
424 | spinlock_lock(&t->lock); |
||
425 | |||
426 | uint64_t cycles; |
||
427 | char suffix; |
||
428 | order(task_get_accounting(t), &cycles, &suffix); |
||
2712 | decky | 429 | |
430 | if (sizeof(void *) == 4) |
||
431 | printf("%-6llu %-10s %-3ld %#10zx %#10zx %9llu%c %7zd %6zd", |
||
432 | t->taskid, t->name, t->context, t, t->as, cycles, suffix, |
||
433 | t->refcount, atomic_get(&t->active_calls)); |
||
434 | else |
||
435 | printf("%-6llu %-10s %-3ld %#18zx %#18zx %9llu%c %7zd %6zd", |
||
436 | t->taskid, t->name, t->context, t, t->as, cycles, suffix, |
||
437 | t->refcount, atomic_get(&t->active_calls)); |
||
2504 | jermar | 438 | for (j = 0; j < IPC_MAX_PHONES; j++) { |
439 | if (t->phones[j].callee) |
||
440 | printf(" %zd:%#zx", j, t->phones[j].callee); |
||
441 | } |
||
442 | printf("\n"); |
||
443 | |||
444 | spinlock_unlock(&t->lock); |
||
445 | return true; |
||
446 | } |
||
447 | |||
1060 | palkovsky | 448 | /** Print task list */ |
449 | void task_print_list(void) |
||
450 | { |
||
451 | ipl_t ipl; |
||
452 | |||
2227 | decky | 453 | /* Messing with task structures, avoid deadlock */ |
1060 | palkovsky | 454 | ipl = interrupts_disable(); |
455 | spinlock_lock(&tasks_lock); |
||
2035 | decky | 456 | |
2712 | decky | 457 | if (sizeof(void *) == 4) { |
458 | printf("taskid name ctx address as " |
||
459 | "cycles threads calls callee\n"); |
||
460 | printf("------ ---------- --- ---------- ---------- " |
||
461 | "---------- ------- ------ ------>\n"); |
||
462 | } else { |
||
463 | printf("taskid name ctx address as " |
||
464 | "cycles threads calls callee\n"); |
||
465 | printf("------ ---------- --- ------------------ ------------------ " |
||
466 | "---------- ------- ------ ------>\n"); |
||
467 | } |
||
1060 | palkovsky | 468 | |
2504 | jermar | 469 | avltree_walk(&tasks_tree, task_print_walker, NULL); |
1159 | jermar | 470 | |
1060 | palkovsky | 471 | spinlock_unlock(&tasks_lock); |
472 | interrupts_restore(ipl); |
||
473 | } |
||
1579 | jermar | 474 | |
1757 | jermar | 475 | /** @} |
1702 | cejka | 476 | */ |