| /branches/tracing/kernel/generic/src/proc/scheduler.c |
|---|
| 451,7 → 451,7 |
| /* |
| * Entering state is unexpected. |
| */ |
| panic("tid%" PRIu64 ": unexpected state %s\n", |
| panic("tid%" PRIu64 ": unexpected state %s.", |
| THREAD->tid, thread_states[THREAD->state]); |
| break; |
| } |
| /branches/tracing/kernel/generic/src/proc/task.c |
|---|
| 52,6 → 52,7 |
| #include <print.h> |
| #include <errno.h> |
| #include <func.h> |
| #include <string.h> |
| #include <syscall/copy.h> |
| /** Spinlock protecting the tasks_tree AVL tree. */ |
| 150,7 → 151,7 |
| ta->as = as; |
| memcpy(ta->name, name, TASK_NAME_BUFLEN); |
| ta->name[TASK_NAME_BUFLEN - 1] = '\0'; |
| ta->name[TASK_NAME_BUFLEN - 1] = 0; |
| atomic_set(&ta->refcount, 0); |
| atomic_set(&ta->lifecount, 0); |
| 249,6 → 250,35 |
| sizeof(TASK->taskid)); |
| } |
| /** Syscall for setting the task name. |
| * |
| * The name simplifies identifying the task in the task list. |
| * |
| * @param name The new name for the task. (typically the same |
| * as the command used to execute it). |
| * |
| * @return 0 on success or an error code from @ref errno.h. |
| */ |
| unative_t sys_task_set_name(const char *uspace_name, size_t name_len) |
| { |
| int rc; |
| char namebuf[TASK_NAME_BUFLEN]; |
| /* Cap length of name and copy it from userspace. */ |
| if (name_len > TASK_NAME_BUFLEN - 1) |
| name_len = TASK_NAME_BUFLEN - 1; |
| rc = copy_from_uspace(namebuf, uspace_name, name_len); |
| if (rc != 0) |
| return (unative_t) rc; |
| namebuf[name_len] = '\0'; |
| str_cpy(TASK->name, TASK_NAME_BUFLEN, namebuf); |
| return EOK; |
| } |
| /** Find task structure corresponding to task ID. |
| * |
| * The tasks_lock must be already held by the caller of this function and |
| 339,7 → 369,7 |
| bool sleeping = false; |
| thr = list_get_instance(cur, thread_t, th_link); |
| spinlock_lock(&thr->lock); |
| thr->interrupted = true; |
| if (thr->state == Sleeping) |
| 367,13 → 397,13 |
| order(task_get_accounting(t), &cycles, &suffix); |
| #ifdef __32_BITS__ |
| printf("%-6" PRIu64 " %-10s %-3" PRIu32 " %10p %10p %9" PRIu64 |
| printf("%-6" PRIu64 " %-12s %-3" PRIu32 " %10p %10p %9" PRIu64 |
| "%c %7ld %6ld", t->taskid, t->name, t->context, t, t->as, cycles, |
| suffix, atomic_get(&t->refcount), atomic_get(&t->active_calls)); |
| #endif |
| #ifdef __64_BITS__ |
| printf("%-6" PRIu64 " %-10s %-3" PRIu32 " %18p %18p %9" PRIu64 |
| printf("%-6" PRIu64 " %-12s %-3" PRIu32 " %18p %18p %9" PRIu64 |
| "%c %7ld %6ld", t->taskid, t->name, t->context, t, t->as, cycles, |
| suffix, atomic_get(&t->refcount), atomic_get(&t->active_calls)); |
| #endif |
| 398,16 → 428,16 |
| spinlock_lock(&tasks_lock); |
| #ifdef __32_BITS__ |
| printf("taskid name ctx address as " |
| printf("taskid name ctx address as " |
| "cycles threads calls callee\n"); |
| printf("------ ---------- --- ---------- ---------- " |
| printf("------ ------------ --- ---------- ---------- " |
| "---------- ------- ------ ------>\n"); |
| #endif |
| #ifdef __64_BITS__ |
| printf("taskid name ctx address as " |
| printf("taskid name ctx address as " |
| "cycles threads calls callee\n"); |
| printf("------ ---------- --- ------------------ ------------------ " |
| printf("------ ------------ --- ------------------ ------------------ " |
| "---------- ------- ------ ------>\n"); |
| #endif |
| /branches/tracing/kernel/generic/src/proc/program.c |
|---|
| 133,7 → 133,7 |
| /* Register image as the program loader */ |
| ASSERT(program_loader == NULL); |
| program_loader = image_addr; |
| printf("Registered program loader at 0x%" PRIp "\n", |
| LOG("Registered program loader at 0x%" PRIp "\n", |
| image_addr); |
| return EOK; |
| } |
| 190,49 → 190,31 |
| /** Syscall for creating a new loader instance from userspace. |
| * |
| * Creates a new task from the program loader image, connects a phone |
| * to it and stores the phone id into the provided buffer. |
| * Creates a new task from the program loader image and sets |
| * the task name. |
| * |
| * @param uspace_phone_id Userspace address where to store the phone id. |
| * @param name Name to set on the new task (typically the same |
| * as the command used to execute it). |
| * |
| * @return 0 on success or an error code from @ref errno.h. |
| */ |
| unative_t sys_program_spawn_loader(int *uspace_phone_id, char *uspace_name, |
| size_t name_len) |
| unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len) |
| { |
| program_t p; |
| int fake_id; |
| int rc; |
| int phone_id; |
| char namebuf[TASK_NAME_BUFLEN]; |
| fake_id = 0; |
| /* Before we even try creating the task, see if we can write the id */ |
| rc = (unative_t) copy_to_uspace(uspace_phone_id, &fake_id, |
| sizeof(fake_id)); |
| if (rc != 0) |
| return rc; |
| /* Cap length of name and copy it from userspace. */ |
| if (name_len > THREAD_NAME_BUFLEN - 1) |
| name_len = THREAD_NAME_BUFLEN - 1; |
| if (name_len > TASK_NAME_BUFLEN - 1) |
| name_len = TASK_NAME_BUFLEN - 1; |
| rc = copy_from_uspace(namebuf, uspace_name, name_len); |
| if (rc != 0) |
| return (unative_t) rc; |
| namebuf[name_len] = '\0'; |
| namebuf[name_len] = 0; |
| /* Allocate the phone for communicating with the new task. */ |
| phone_id = phone_alloc(); |
| if (phone_id < 0) |
| return ELIMIT; |
| /* Spawn the new task. */ |
| rc = program_create_loader(&p, namebuf); |
| 239,18 → 221,6 |
| if (rc != 0) |
| return rc; |
| phone_connect(phone_id, &p.task->answerbox); |
| /* No need to aquire lock before task_ready() */ |
| rc = (unative_t) copy_to_uspace(uspace_phone_id, &phone_id, |
| sizeof(phone_id)); |
| if (rc != 0) { |
| /* Ooops */ |
| ipc_phone_hangup(&TASK->phones[phone_id]); |
| task_kill(p.task->taskid); |
| return rc; |
| } |
| // FIXME: control the capabilities |
| cap_set(p.task, cap_get(TASK)); |
| /branches/tracing/kernel/generic/src/proc/tasklet.c |
|---|
| 51,7 → 51,7 |
| tasklet_list = malloc(sizeof(tasklet_descriptor_t *) * config.cpu_count, 0); |
| if (!tasklet_list) |
| panic("Error initializing tasklets"); |
| panic("Error initializing tasklets."); |
| for (i = 0; i < config.cpu_count; i++) |
| tasklet_list[i] = NULL; |
| /branches/tracing/kernel/generic/src/proc/thread.c |
|---|
| 102,7 → 102,7 |
| thread_id_t last_tid = 0; |
| static slab_cache_t *thread_slab; |
| #ifdef ARCH_HAS_FPU |
| #ifdef CONFIG_FPU |
| slab_cache_t *fpu_context_slab; |
| #endif |
| 161,7 → 161,7 |
| /* call the architecture-specific part of the constructor */ |
| thr_constructor_arch(t); |
| #ifdef ARCH_HAS_FPU |
| #ifdef CONFIG_FPU |
| #ifdef CONFIG_FPU_LAZY |
| t->saved_fpu_context = NULL; |
| #else |
| 169,11 → 169,11 |
| if (!t->saved_fpu_context) |
| return -1; |
| #endif |
| #endif |
| #endif |
| t->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags); |
| if (!t->kstack) { |
| #ifdef ARCH_HAS_FPU |
| #ifdef CONFIG_FPU |
| if (t->saved_fpu_context) |
| slab_free(fpu_context_slab, t->saved_fpu_context); |
| #endif |
| 196,7 → 196,7 |
| thr_destructor_arch(t); |
| frame_free(KA2PA(t->kstack)); |
| #ifdef ARCH_HAS_FPU |
| #ifdef CONFIG_FPU |
| if (t->saved_fpu_context) |
| slab_free(fpu_context_slab, t->saved_fpu_context); |
| #endif |
| 211,11 → 211,11 |
| void thread_init(void) |
| { |
| THREAD = NULL; |
| atomic_set(&nrdy,0); |
| atomic_set(&nrdy, 0); |
| thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0, |
| thr_constructor, thr_destructor, 0); |
| #ifdef ARCH_HAS_FPU |
| #ifdef CONFIG_FPU |
| fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t), |
| FPU_CONTEXT_ALIGN, NULL, NULL, 0); |
| #endif |
| 316,7 → 316,7 |
| interrupts_restore(ipl); |
| memcpy(t->name, name, THREAD_NAME_BUFLEN); |
| t->name[THREAD_NAME_BUFLEN - 1] = '\0'; |
| t->name[THREAD_NAME_BUFLEN - 1] = 0; |
| t->thread_code = func; |
| t->thread_arg = arg; |
| 723,7 → 723,7 |
| if (rc != 0) |
| return (unative_t) rc; |
| namebuf[name_len] = '\0'; |
| namebuf[name_len] = 0; |
| /* |
| * In case of failure, kernel_uarg will be deallocated in this function. |