Prex Home / Browse Source - Prex Version: 0.9.0

root/sys/kern/task.c

DEFINITIONS

1. task_create
2. task_terminate
3. task_self
4. task_suspend
5. task_resume
6. task_setname
7. task_setcap
8. task_chkcap
9. task_capable
10. task_valid
11. task_access
12. task_info
13. task_bootstrap
14. task_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  * task.c - task management routines.
  32  */
  34 #include <kernel.h>
  35 #include <kmem.h>
  36 #include <sched.h>
  37 #include <thread.h>
  38 #include <ipc.h>
  39 #include <sync.h>
  40 #include <vm.h>
  41 #include <exception.h>
  42 #include <task.h>
  43 #include <hal.h>
  44 #include <sys/bootinfo.h>
  46 struct task             kernel_task;    /* kernel task */
  47 static struct list      task_list;      /* list for all tasks */
  48 static int              ntasks;         /* number of tasks in system */
  50 /**
  51  * task_create - create a new task.
  52  *
  53  * vm_option:
  54  *   VM_NEW:   The child task will have fresh memory image.
  55  *   VM_SHARE: The child task will share whole memory image with parent.
  56  *   VM_COPY:  The parent's memory image is copied to the child's one.
  57  *             VM_COPY is supported only with MMU system.
  58  *
  59  * Note: The child task initially contains no threads.
  60  */
  61 int
task_create(task_t parent, int vm_option, task_t *childp)
  63 {
  64         struct task *task;
vm_map_t map = NULL;
ASSERT(parent != NULL);
  69         switch (vm_option) {
  70         case VM_NEW:
  71         case VM_SHARE:
  72 #ifdef CONFIG_MMU
  73         case VM_COPY:
  74 #endif
  75                 break;
  76         default:
  77                 return EINVAL;
  78         }
  79         if (ntasks >= MAXTASKS)
  80                 return EAGAIN;
sched_lock();
  83         if (!task_valid(parent)) {
sched_unlock();
  85                 return ESRCH;
  86         }
  87         if ((curtask->flags & TF_SYSTEM) == 0) {
  88                 if (!task_access(parent)) {
sched_unlock();
  90                         return EPERM;
  91                 }
  92                 /*
  93                  * It's important to set zero as task id before
  94                  * copying parent's memory space. Otherwise, we
  95                  * have to switch VM space to copy it.
  96                  */
task = 0;
  98                 if (copyout(&task, childp, sizeof(task))) {
sched_unlock();
 100                         return EFAULT;
 101                 }
 102         }
 104         if ((task = kmem_alloc(sizeof(*task))) == NULL) {
sched_unlock();
 106                 return ENOMEM;
 107         }
memset(task, 0, sizeof(*task));
 110         /*
 111          * Setup VM mapping.
 112          */
 113         switch (vm_option) {
 114         case VM_NEW:
map = vm_create();
 116                 break;
 117         case VM_SHARE:
vm_reference(parent->map);
map = parent->map;
 120                 break;
 121         case VM_COPY:
map = vm_dup(parent->map);
 123                 break;
 124         }
 125         if (map == NULL) {
kmem_free(task);
sched_unlock();
 128                 return ENOMEM;
 129         }
 131         /*
 132          * Fill initial task data.
 133          */
task->map = map;
task->handler = parent->handler;
task->capability = parent->capability;
task->parent = parent;
task->flags = TF_DEFAULT;
strlcpy(task->name, "*noname", MAXTASKNAME);
list_init(&task->threads);
list_init(&task->objects);
list_init(&task->mutexes);
list_init(&task->conds);
list_init(&task->sems);
list_insert(&task_list, &task->link);
ntasks++;
 148         if (curtask->flags & TF_SYSTEM)
 149                 *childp = task;
 150         else {
 151                 /*
 152                  * No page fault here because we have already
 153                  * checked it.
 154                  */
copyout(&task, childp, sizeof(task));
 156         }
sched_unlock();
 159         return 0;
 160 }
 162 /*
 163  * Terminate the specified task.
 164  */
 165 int
task_terminate(task_t task)
 167 {
list_t head, n;
thread_t t;
sched_lock();
 172         if (!task_valid(task)) {
sched_unlock();
 174                 return ESRCH;
 175         }
 176         if (!task_access(task)) {
sched_unlock();
 178                 return EPERM;
 179         }
list_remove(&task->link);
task->handler = EXC_DFL;
 184         /*
 185          * Clean up all resources owned by the target task.
 186          */
timer_stop(&task->alarm);
object_cleanup(task);
mutex_cleanup(task);
cond_cleanup(task);
sem_cleanup(task);
 193         /*
 194          * Terminate each thread in the task.
 195          */
head = &task->threads;
 197         for (n = list_first(head); n != head; n = list_next(n)) {
t = list_entry(n, struct thread, task_link);
 199                 if (t != curthread)
thread_destroy(t);
 201         }
 202         if (task == curtask)
thread_destroy(curthread);
vm_terminate(task->map);
task->map = NULL;
kmem_free(task);
ntasks--;
sched_unlock();
 210         return 0;
 211 }
 213 /*
 214  * Return the current task.
 215  */
task_t
task_self(void)
 218 {
 220         return curthread->task;
 221 }
 223 /*
 224  * Suspend a task.
 225  */
 226 int
task_suspend(task_t task)
 228 {
list_t head, n;
thread_t t;
sched_lock();
 233         if (!task_valid(task)) {
sched_unlock();
 235                 return ESRCH;
 236         }
 237         if (!task_access(task)) {
sched_unlock();
 239                 return EPERM;
 240         }
 242         if (++task->suscnt == 1) {
 243                 /*
 244                  * Suspend all threads within the task.
 245                  */
head = &task->threads;
 247                 for (n = list_first(head); n != head; n = list_next(n)) {
t = list_entry(n, struct thread, task_link);
thread_suspend(t);
 250                 }
 251         }
sched_unlock();
 253         return 0;
 254 }
 256 /*
 257  * Resume a task.
 258  *
 259  * A thread in the task will begin to run only when both
 260  * thread suspend count and task suspend count become 0.
 261  */
 262 int
task_resume(task_t task)
 264 {
list_t head, n;
thread_t t;
ASSERT(task != curtask);
sched_lock();
 271         if (!task_valid(task)) {
sched_unlock();
 273                 return ESRCH;
 274         }
 275         if (!task_access(task)) {
sched_unlock();
 277                 return EPERM;
 278         }
 279         if (task->suscnt == 0) {
sched_unlock();
 281                 return EINVAL;
 282         }
 284         if (--task->suscnt == 0) {
 285                 /*
 286                  * Resume all threads in the target task.
 287                  */
head = &task->threads;
 289                 for (n = list_first(head); n != head; n = list_next(n)) {
t = list_entry(n, struct thread, task_link);
thread_resume(t);
 292                 }
 293         }
sched_unlock();
 295         return 0;
 296 }
 298 /*
 299  * Set task name.
 300  *
 301  * The naming service is separated from task_create() because
 302  * the task name can be changed at anytime by exec().
 303  */
 304 int
task_setname(task_t task, const char *name)
 306 {
 307         char str[MAXTASKNAME];
 308         int error;
sched_lock();
 311         if (!task_valid(task)) {
sched_unlock();
 313                 return ESRCH;
 314         }
 315         if (!task_access(task)) {
sched_unlock();
 317                 return EPERM;
 318         }
 320         if (curtask->flags & TF_SYSTEM)
strlcpy(task->name, name, MAXTASKNAME);
 322         else {
error = copyinstr(name, str, MAXTASKNAME);
 324                 if (error) {
sched_unlock();
 326                         return error;
 327                 }
strlcpy(task->name, str, MAXTASKNAME);
 329         }
sched_unlock();
 331         return 0;
 332 }
 334 /*
 335  * Set the capability of the specified task.
 336  */
 337 int
task_setcap(task_t task, cap_t cap)
 339 {
 341         if (!task_capable(CAP_SETPCAP))
 342                 return EPERM;
sched_lock();
 345         if (!task_valid(task)) {
sched_unlock();
 347                 return ESRCH;
 348         }
 349         if (!task_access(task)) {
sched_unlock();
 351                 return EPERM;
 352         }
task->capability = cap;
sched_unlock();
 355         return 0;
 356 }
 358 /*
 359  * task_chkcap - system call to check task capability.
 360  */
 361 int
task_chkcap(task_t task, cap_t cap)
 363 {
 364         int error = 0;
sched_lock();
 367         if (!task_valid(task)) {
sched_unlock();
 369                 return ESRCH;
 370         }
 371         if ((task->capability & cap) == 0) {
DPRINTF(("Denying capability by %s: task=%s cap=%08x\n",
curtask->name, task->name, cap));
 374                 if (task->flags & TF_AUDIT)
panic("audit failed");
error = EPERM;
 377         }
sched_unlock();
 379         return error;
 380 }
 382 /*
 383  * Check if the current task has specified capability.
 384  * Returns true on success, or false on error.
 385  */
 386 int
task_capable(cap_t cap)
 388 {
 389         int capable = 1;
 391         if ((curtask->capability & cap) == 0) {
DPRINTF(("Denying capability by kernel: task=%s cap=%08x\n",
curtask->name, cap));
 394                 if (curtask->flags & TF_AUDIT)
panic("audit failed");
capable = 0;
 397         }
 398         return capable;
 399 }
 401 /*
 402  * Return true if the specified task is valid.
 403  */
 404 int
task_valid(task_t task)
 406 {
task_t tmp;
list_t n;
 410         for (n = list_first(&task_list); n != &task_list; n = list_next(n)) {
tmp = list_entry(n, struct task, link);
 412                 if (tmp == task)
 413                         return 1;
 414         }
 415         return 0;
 416 }
 418 /*
 419  * Check if the current task can access the specified task.
 420  * Return true on success, or false on error.
 421  */
 422 int
task_access(task_t task)
 424 {
 426         if (task->flags & TF_SYSTEM) {
 427                 /* Do not access the kernel task. */
 428                 return 0;
 429         } else {
 430                 if (task == curtask || task->parent == curtask ||
task == curtask->parent ||  /* XXX: fork on nommu */
task_capable(CAP_TASKCTRL))
 433                         return 1;
 434         }
 435         return 0;
 436 }
 438 int
task_info(struct taskinfo *info)
 440 {
u_long target = info->cookie;
u_long i = 0;
task_t task;
list_t n;
sched_lock();
n = list_first(&task_list);
 448         do {
 449                 if (i++ == target) {
task = list_entry(n, struct task, link);
info->cookie = i;
info->id = task;
info->flags = task->flags;
info->suscnt = task->suscnt;
info->capability = task->capability;
info->vmsize = task->map->total;
info->nthreads = task->nthreads;
info->active = (task == curtask) ? 1 : 0;
strlcpy(info->taskname, task->name, MAXTASKNAME);
sched_unlock();
 461                         return 0;
 462                 }
n = list_next(n);
 464         } while (n != &task_list);
sched_unlock();
 466         return ESRCH;
 467 }
 469 /*
 470  * Create and setup boot tasks.
 471  */
 472 void
task_bootstrap(void)
 474 {
 475         struct module *mod;
 476         struct bootinfo *bi;
task_t task;
thread_t t;
 479         void *stack, *sp;
 480         int i, error = 0;
machine_bootinfo(&bi);
mod = &bi->tasks[0];
 485         for (i = 0; i < bi->nr_tasks; i++) {
 486                 /*
 487                  * Create a new task.
 488                  */
 489                 if ((error = task_create(&kernel_task, VM_NEW, &task)) != 0)
 490                         break;
 491                 if ((error = vm_load(task->map, mod, &stack)) != 0)
 492                         break;
task_setname(task, mod->name);
 495                 /*
 496                  * Set the default capability.
 497                  * We give CAP_SETPCAP to the exec server.
 498                  */
task->capability = CAPSET_BOOT;
 500                 if (!strncmp(task->name, "exec", MAXTASKNAME))
task->capability |= CAP_SETPCAP;
 503                 /*
 504                  * Create and start a new thread.
 505                  */
 506                 if ((error = thread_create(task, &t)) != 0)
 507                         break;
sp = (char *)stack + DFLSTKSZ - (sizeof(int) * 3);
error = thread_load(t, (void (*)(void))mod->entry, sp);
 510                 if (error)
 511                         break;
t->priority = PRI_REALTIME;
t->basepri = PRI_REALTIME;
thread_resume(t);
mod++;
 517         }
 518         if (error) {
DPRINTF(("task_bootstrap: error=%d\n", error));
panic("unable to load boot task");
 521         }
 522 }
 524 /*
 525  * Initialize task.
 526  */
 527 void
task_init(void)
 529 {
list_init(&task_list);
 533         /*
 534          * Create a kernel task as first task.
 535          */
strlcpy(kernel_task.name, "kernel", MAXTASKNAME);
kernel_task.flags = TF_SYSTEM;
kernel_task.nthreads = 0;
list_init(&kernel_task.threads);
list_init(&kernel_task.objects);
list_init(&kernel_task.mutexes);
list_init(&kernel_task.conds);
list_init(&kernel_task.sems);
list_insert(&task_list, &kernel_task.link);
ntasks = 1;
 547 }