Changeset 52755f1 in mainline for kernel/generic/src/proc/task.c


Ignore:
Timestamp:
2008-06-03T14:53:31Z (17 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
aa48a9d
Parents:
5b86d10
Message:

support for SYS_SPAWN syscall
proper printf formatting
change the way init tasks are created

File:
1 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/proc/task.c

    r5b86d10 r52755f1  
    129129                       
    130130#ifdef CONFIG_DEBUG
    131                         printf("Killing task %llu\n", id);
     131                        printf("Killing task %" PRIu64 "\n", id);
    132132#endif                 
    133133                        task_kill(id);
     
    234234}
    235235
    236 /** Create new task with 1 thread and run it
    237  *
    238  * @param program_addr Address of program executable image.
    239  * @param name Program name.
    240  *
    241  * @return Task of the running program or NULL on error.
    242  */
    243 task_t *task_run_program(void *program_addr, char *name)
    244 {
    245         as_t *as;
    246         as_area_t *a;
    247         unsigned int rc;
    248         thread_t *t;
    249         task_t *task;
    250         uspace_arg_t *kernel_uarg;
    251 
    252         as = as_create(0);
    253         ASSERT(as);
    254 
    255         rc = elf_load((elf_header_t *) program_addr, as);
    256         if (rc != EE_OK) {
    257                 as_destroy(as);
    258                 return NULL;
    259         }
    260        
    261         kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
     236/** Syscall for reading task ID from userspace.
     237 *
     238 * @param uspace_task_id Userspace address of 8-byte buffer where to store
     239 * current task ID.
     240 *
     241 * @return 0 on success or an error code from @ref errno.h.
     242 */
     243unative_t sys_task_get_id(task_id_t *uspace_task_id)
     244{
     245        /*
     246         * No need to acquire lock on TASK because taskid
     247         * remains constant for the lifespan of the task.
     248         */
     249        return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid,
     250            sizeof(TASK->taskid));
     251}
     252
     253unative_t sys_task_spawn(void *image, size_t size)
     254{
     255        void *kimage = malloc(size, 0);
     256        if (kimage == NULL)
     257                return ENOMEM;
     258       
     259        int rc = copy_from_uspace(kimage, image, size);
     260        if (rc != EOK)
     261                return rc;
     262       
     263        uspace_arg_t *kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
     264        if (kernel_uarg == NULL) {
     265                free(kimage);
     266                return ENOMEM;
     267        }
     268       
    262269        kernel_uarg->uspace_entry =
    263             (void *) ((elf_header_t *) program_addr)->e_entry;
     270            (void *) ((elf_header_t *) kimage)->e_entry;
    264271        kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
    265272        kernel_uarg->uspace_thread_function = NULL;
     
    267274        kernel_uarg->uspace_uarg = NULL;
    268275       
    269         task = task_create(as, name);
    270         ASSERT(task);
    271 
    272         /*
    273          * Create the data as_area.
    274          */
    275         a = as_area_create(as, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
    276             LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
    277             AS_AREA_ATTR_NONE, &anon_backend, NULL);
    278 
    279         /*
    280          * Create the main thread.
    281          */
    282         t = thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE,
    283             "uinit", false);
    284         ASSERT(t);
    285        
    286         thread_ready(t);
    287 
    288         return task;
    289 }
    290 
    291 /** Syscall for reading task ID from userspace.
    292  *
    293  * @param uspace_task_id Userspace address of 8-byte buffer where to store
    294  * current task ID.
    295  *
    296  * @return 0 on success or an error code from @ref errno.h.
    297  */
    298 unative_t sys_task_get_id(task_id_t *uspace_task_id)
    299 {
    300         /*
    301          * No need to acquire lock on TASK because taskid
    302          * remains constant for the lifespan of the task.
    303          */
    304         return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid,
    305             sizeof(TASK->taskid));
     276        as_t *as = as_create(0);
     277        if (as == NULL) {
     278                free(kernel_uarg);
     279                free(kimage);
     280                return ENOMEM;
     281        }
     282       
     283        unsigned int erc = elf_load((elf_header_t *) kimage, as);
     284        if (erc != EE_OK) {
     285                as_destroy(as);
     286                free(kernel_uarg);
     287                free(kimage);
     288                return ENOENT;
     289        }
     290       
     291        as_area_t *area = as_area_create(as,
     292                AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
     293                LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
     294                AS_AREA_ATTR_NONE, &anon_backend, NULL);
     295        if (area == NULL) {
     296                as_destroy(as);
     297                free(kernel_uarg);
     298                free(kimage);
     299                return ENOMEM;
     300        }
     301       
     302        task_t *task = task_create(as, "app");
     303        if (task == NULL) {
     304                as_destroy(as);
     305                free(kernel_uarg);
     306                free(kimage);
     307                return ENOENT;
     308        }
     309       
     310        // FIXME: control the capabilities
     311        cap_set(task, cap_get(TASK));
     312       
     313        thread_t *thread = thread_create(uinit, kernel_uarg, task,
     314                THREAD_FLAG_USPACE, "user", false);
     315        if (thread == NULL) {
     316                task_destroy(task);
     317                as_destroy(as);
     318                free(kernel_uarg);
     319                free(kimage);
     320                return ENOENT;
     321        }
     322       
     323        thread_ready(thread);
     324       
     325        return EOK;
    306326}
    307327
     
    421441        char suffix;
    422442        order(task_get_accounting(t), &cycles, &suffix);
    423        
    424         if (sizeof(void *) == 4)
    425                 printf("%-6llu %-10s %-3ld %#10zx %#10zx %9llu%c %7zd %6zd",
    426                 t->taskid, t->name, t->context, t, t->as, cycles, suffix,
    427                     t->refcount, atomic_get(&t->active_calls));
    428         else
    429                 printf("%-6llu %-10s %-3ld %#18zx %#18zx %9llu%c %7zd %6zd",
    430                     t->taskid, t->name, t->context, t, t->as, cycles, suffix,
    431                 t->refcount, atomic_get(&t->active_calls));
     443
     444#ifdef __32_BITS__     
     445        printf("%-6" PRIu64 " %-10s %-3" PRIu32 " %10p %10p %9" PRIu64 "%c %7ld %6ld",
     446                t->taskid, t->name, t->context, t, t->as, cycles, suffix,
     447                atomic_get(&t->refcount), atomic_get(&t->active_calls));
     448#endif
     449
     450#ifdef __64_BITS__
     451        printf("%-6" PRIu64 " %-10s %-3" PRIu32 " %18p %18p %9" PRIu64 "%c %7ld %6ld",
     452                t->taskid, t->name, t->context, t, t->as, cycles, suffix,
     453                atomic_get(&t->refcount), atomic_get(&t->active_calls));
     454#endif
     455
    432456        for (j = 0; j < IPC_MAX_PHONES; j++) {
    433457                if (t->phones[j].callee)
    434                         printf(" %zd:%#zx", j, t->phones[j].callee);
     458                        printf(" %d:%p", j, t->phones[j].callee);
    435459        }
    436460        printf("\n");
     
    448472        ipl = interrupts_disable();
    449473        spinlock_lock(&tasks_lock);
    450        
    451         if (sizeof(void *) == 4) {
    452                 printf("taskid name       ctx address    as         "
    453                         "cycles     threads calls  callee\n");
    454                 printf("------ ---------- --- ---------- ---------- "
    455                         "---------- ------- ------ ------>\n");
    456         } else {
    457                 printf("taskid name       ctx address            as                 "
    458                         "cycles     threads calls  callee\n");
    459                 printf("------ ---------- --- ------------------ ------------------ "
    460                         "---------- ------- ------ ------>\n");
    461         }
     474
     475#ifdef __32_BITS__     
     476        printf("taskid name       ctx address    as         "
     477                "cycles     threads calls  callee\n");
     478        printf("------ ---------- --- ---------- ---------- "
     479                "---------- ------- ------ ------>\n");
     480#endif
     481
     482#ifdef __64_BITS__
     483        printf("taskid name       ctx address            as                 "
     484                "cycles     threads calls  callee\n");
     485        printf("------ ---------- --- ------------------ ------------------ "
     486                "---------- ------- ------ ------>\n");
     487#endif
    462488
    463489        avltree_walk(&tasks_tree, task_print_walker, NULL);
Note: See TracChangeset for help on using the changeset viewer.