| /branches/tracing/kernel/generic/include/proc/task.h |
|---|
| 100,6 → 100,9 |
| call_t *debug_begin_call; |
| call_t *debug_go_call; |
| int not_stoppable_count; |
| answerbox_t kernel_box; |
| struct thread *kb_thread; |
| /** Architecture specific task data. */ |
| task_arch_t arch; |
| /branches/tracing/kernel/generic/include/syscall/syscall.h |
|---|
| 66,7 → 66,7 |
| SYS_SYSINFO_VALID, |
| SYS_SYSINFO_VALUE, |
| SYS_DEBUG_ENABLE_CONSOLE, |
| SYS_IPC_CONNECT_TASK, |
| SYS_IPC_CONNECT_KBOX, |
| SYSCALL_END |
| } syscall_t; |
| /branches/tracing/kernel/generic/include/ipc/sysipc.h |
|---|
| 57,7 → 57,7 |
| unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method, |
| irq_code_t *ucode); |
| unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno); |
| unative_t sys_ipc_connect_task(sysarg64_t *task_id); |
| unative_t sys_ipc_connect_kbox(sysarg64_t *task_id); |
| #endif |
| /branches/tracing/kernel/generic/include/ipc/ipc.h |
|---|
| 356,7 → 356,7 |
| extern int ipc_phone_hangup(phone_t *phone); |
| extern void ipc_backsend_err(phone_t *phone, call_t *call, unative_t err); |
| extern void ipc_print_task(task_id_t taskid); |
| extern int ipc_connect_task(task_id_t taskid); |
| extern int ipc_connect_kbox(task_id_t taskid); |
| extern answerbox_t *ipc_phone_0; |
| /branches/tracing/kernel/generic/src/proc/task.c |
|---|
| 176,7 → 176,10 |
| ta->debug_begin_call = NULL; |
| ta->debug_go_call = NULL; |
| ta->not_stoppable_count = 0; |
| ipc_answerbox_init(&ta->kernel_box, ta); |
| ta->kb_thread = NULL; |
| ipc_answerbox_init(&ta->answerbox, ta); |
| for (i = 0; i < IPC_MAX_PHONES; i++) |
| ipc_phone_init(&ta->phones[i]); |
| /branches/tracing/kernel/generic/src/proc/thread.c |
|---|
| 412,7 → 412,11 |
| spinlock_lock(&task->lock); |
| atomic_inc(&task->refcount); |
| atomic_inc(&task->lifecount); |
| ++task->not_stoppable_count; |
| /* FIXME: this must be done very carefully.. an unstoppable |
| thread cannot appear just-so, it must be possible to catch it. */ |
| if (t->flags & THREAD_FLAG_USPACE) |
| ++task->not_stoppable_count; |
| list_append(&t->th_link, &task->th_head); |
| spinlock_unlock(&task->lock); |
| /branches/tracing/kernel/generic/src/syscall/syscall.c |
|---|
| 165,7 → 165,7 |
| /* Debug calls */ |
| (syshandler_t) sys_debug_enable_console, |
| (syshandler_t) sys_ipc_connect_task |
| (syshandler_t) sys_ipc_connect_kbox |
| }; |
| /** @} |
| /branches/tracing/kernel/generic/src/ipc/sysipc.c |
|---|
| 438,7 → 438,11 |
| copied = total = 0; |
| for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) { |
| t = list_get_instance(cur, thread_t, th_link); |
| /* Not interested in kernel threads */ |
| if ((t->flags & THREAD_FLAG_USPACE) == 0) |
| continue; |
| //FIXME: id cropped!! |
| tid = (unative_t) t->tid; |
| 1073,7 → 1077,7 |
| * |
| * @return Phone id on success, or negative error code. |
| */ |
| unative_t sys_ipc_connect_task(sysarg64_t *uspace_taskid_arg) |
| unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg) |
| { |
| sysarg64_t taskid_arg; |
| int rc; |
| 1084,7 → 1088,7 |
| klog_printf("sys_ipc_connect_kbox(%lld, %d)", taskid_arg.value); |
| return ipc_connect_task(taskid_arg.value); |
| return ipc_connect_kbox(taskid_arg.value); |
| } |
| /** @} |
| /branches/tracing/kernel/generic/src/ipc/ipc.c |
|---|
| 609,12 → 609,23 |
| #include <ipc/ipcrsc.h> |
| #include <console/klog.h> |
| static void kbox_thread_proc(void *arg) |
| { |
| (void)arg; |
| klog_printf("kbox_thread_proc()"); |
| while (1) { |
| klog_printf("kbox: wait for call"); |
| ipc_wait_for_call(&TASK->kernel_box, SYNCH_NO_TIMEOUT, |
| SYNCH_FLAGS_NONE); |
| } |
| } |
| /** |
| * Connect phone to a task specified by id. |
| * Connect phone to a task kernel-box specified by id. |
| * |
| * @return Phone id on success, or negative error code. |
| */ |
| int ipc_connect_task(task_id_t taskid) |
| int ipc_connect_kbox(task_id_t taskid) |
| { |
| int newphid; |
| task_t *ta; |
| 633,9 → 644,17 |
| spinlock_lock(&ta->lock); |
| spinlock_unlock(&tasks_lock); |
| ipc_phone_connect(&TASK->phones[newphid], &ta->answerbox); |
| ipc_phone_connect(&TASK->phones[newphid], &ta->kernel_box); |
| spinlock_unlock(&ta->lock); |
| /* FIXME: locking! */ |
| ta->kb_thread = thread_create(kbox_thread_proc, |
| NULL, ta, 0, "kbox", false); |
| if (!ta->kb_thread) |
| return ENOMEM; |
| thread_ready(ta->kb_thread); |
| return newphid; |
| } |
| /branches/tracing/uspace/app/tester/debug/debug1.c |
|---|
| 56,7 → 56,7 |
| printf("running debug1 test\n"); |
| taskid = 12; |
| printf("ipc_connect_task(%d)...\n", taskid); |
| rc = ipc_connect_task(taskid); |
| rc = ipc_connect_kbox(taskid); |
| printf("-> %d\n", rc); |
| phoneid = rc; |
| 72,7 → 72,7 |
| printf("thread IDs:"); |
| for (i=0; i<tb_copied / sizeof(unsigned); i++) { |
| printf("%u", threadid_buf[i]); |
| printf(" %u", threadid_buf[i]); |
| } |
| printf("\ntotal of %u threads\n", tb_needed/sizeof(unsigned)); |
| /branches/tracing/uspace/lib/libc/include/ipc/ipc.h |
|---|
| 290,7 → 290,7 |
| #include <task.h> |
| extern int ipc_connect_task(task_id_t id); |
| extern int ipc_connect_kbox(task_id_t id); |
| #endif |
| /branches/tracing/uspace/lib/libc/generic/ipc.c |
|---|
| 913,13 → 913,13 |
| #include <kernel/syscall/sysarg64.h> |
| /** Connect to a task specified by id. |
| */ |
| int ipc_connect_task(task_id_t id) |
| int ipc_connect_kbox(task_id_t id) |
| { |
| sysarg64_t arg; |
| arg.value = (unsigned long long) id; |
| return __SYSCALL1(SYS_IPC_CONNECT_TASK, (sysarg_t) &arg); |
| return __SYSCALL1(SYS_IPC_CONNECT_KBOX, (sysarg_t) &arg); |
| } |
| /** @} |