Changes in kernel/generic/src/proc/task.c [41df2827:7e752b2] in mainline

File:

• kernel/generic/src/proc/task.c (modified) (13 diffs)

kernel/generic/src/proc/task.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2001-2004 Jakub Jermar
+ * Copyright (c) 2010 Jakub Jermar
  * All rights reserved.
  *
@@ -33 +33 @@
 /**
  * @file
- * @brief       Task management.
+ * @brief Task management.
  */
 
@@ -53 +53 @@
 #include <errno.h>
 #include <func.h>
-#include <string.h>
+#include <str.h>
 #include <memstr.h>
 #include <syscall/copy.h>
@@ -60 +60 @@
 
 /** Spinlock protecting the tasks_tree AVL tree. */
-SPINLOCK_INITIALIZE(tasks_lock);
+IRQ_SPINLOCK_INITIALIZE(tasks_lock);
 
 /** AVL tree of active tasks.
@@ -66 +66 @@
  * The task is guaranteed to exist after it was found in the tasks_tree as
  * long as:
+ *
  * @li the tasks_lock is held,
  * @li the task's lock is held when task's lock is acquired before releasing
@@ -80 +81 @@
 /* Forward declarations. */
 static void task_kill_internal(task_t *);
-static int tsk_constructor(void *, int);
-
-/** Initialize kernel tasks support. */
+static int tsk_constructor(void *, unsigned int);
+
+/** Initialize kernel tasks support.
+ *
+ */
 void task_init(void)
 {
@@ -91 +94 @@
 }
 
-/*
+/** Task finish walker.
+ *
  * The idea behind this walker is to kill and count all tasks different from
  * TASK.
+ *
  */
 static bool task_done_walker(avltree_node_t *node, void *arg)
 {
-        task_t *t = avltree_get_instance(node, task_t, tasks_tree_node);
-        unsigned *cnt = (unsigned *) arg;
-
-        if (t != TASK) {
+        task_t *task = avltree_get_instance(node, task_t, tasks_tree_node);
+        size_t *cnt = (size_t *) arg;
+        
+        if (task != TASK) {
                 (*cnt)++;
+                
 #ifdef CONFIG_DEBUG
-                printf("[%"PRIu64"] ", t->taskid);
-#endif
-                task_kill_internal(t);
+                printf("[%"PRIu64"] ", task->taskid);
+#endif
+                
+                task_kill_internal(task);
         }
-
-        return true;    /* continue the walk */
-}
-
-/** Kill all tasks except the current task. */
+        
+        /* Continue the walk */
+        return true;
+}
+
+/** Kill all tasks except the current task.
+ *
+ */
 void task_done(void)
 {
-        unsigned tasks_left;
-
-        do { /* Repeat until there are any tasks except TASK */
-                /* Messing with task structures, avoid deadlock */
+        size_t tasks_left;
+        
+        /* Repeat until there are any tasks except TASK */
+        do {
 #ifdef CONFIG_DEBUG
                 printf("Killing tasks... ");
 #endif
-                ipl_t ipl = interrupts_disable();
-                spinlock_lock(&tasks_lock);
+                
+                irq_spinlock_lock(&tasks_lock, true);
                 tasks_left = 0;
                 avltree_walk(&tasks_tree, task_done_walker, &tasks_left);
-                spinlock_unlock(&tasks_lock);
-                interrupts_restore(ipl);
+                irq_spinlock_unlock(&tasks_lock, true);
+                
                 thread_sleep(1);
+                
 #ifdef CONFIG_DEBUG
                 printf("\n");
 #endif
-        } while (tasks_left);
-}
-
-int tsk_constructor(void *obj, int kmflags)
-{
-        task_t *ta = obj;
-        int i;
-
-        atomic_set(&ta->refcount, 0);
-        atomic_set(&ta->lifecount, 0);
-        atomic_set(&ta->active_calls, 0);
-
-        spinlock_initialize(&ta->lock, "task_ta_lock");
-        mutex_initialize(&ta->futexes_lock, MUTEX_PASSIVE);
-
-        list_initialize(&ta->th_head);
-        list_initialize(&ta->sync_box_head);
-
-        ipc_answerbox_init(&ta->answerbox, ta);
+        } while (tasks_left > 0);
+}
+
+int tsk_constructor(void *obj, unsigned int kmflags)
+{
+        task_t *task = (task_t *) obj;
+        
+        atomic_set(&task->refcount, 0);
+        atomic_set(&task->lifecount, 0);
+        atomic_set(&task->active_calls, 0);
+        
+        irq_spinlock_initialize(&task->lock, "task_t_lock");
+        mutex_initialize(&task->futexes_lock, MUTEX_PASSIVE);
+        
+        list_initialize(&task->th_head);
+        list_initialize(&task->sync_box_head);
+        
+        ipc_answerbox_init(&task->answerbox, task);
+        
+        size_t i;
         for (i = 0; i < IPC_MAX_PHONES; i++)
-                ipc_phone_init(&ta->phones[i]);
-
+                ipc_phone_init(&task->phones[i]);
+        
 #ifdef CONFIG_UDEBUG
         /* Init kbox stuff */
-        ta->kb.thread = NULL;
-        ipc_answerbox_init(&ta->kb.box, ta);
-        mutex_initialize(&ta->kb.cleanup_lock, MUTEX_PASSIVE);
-#endif
-
+        task->kb.thread = NULL;
+        ipc_answerbox_init(&task->kb.box, task);
+        mutex_initialize(&task->kb.cleanup_lock, MUTEX_PASSIVE);
+#endif
+        
         return 0;
 }
@@ -165 +177 @@
 /** Create new task with no threads.
  *
- * @param as            Task's address space.
- * @param name          Symbolic name (a copy is made).
- *
- * @return              New task's structure.
- *
- */
-task_t *task_create(as_t *as, char *name)
-{
-        ipl_t ipl;
-        task_t *ta;
-        
-        ta = (task_t *) slab_alloc(task_slab, 0);
-        task_create_arch(ta);
-        ta->as = as;
-        memcpy(ta->name, name, TASK_NAME_BUFLEN);
-        ta->name[TASK_NAME_BUFLEN - 1] = 0;
-
-        ta->context = CONTEXT;
-        ta->capabilities = 0;
-        ta->cycles = 0;
-
+ * @param as   Task's address space.
+ * @param name Symbolic name (a copy is made).
+ *
+ * @return New task's structure.
+ *
+ */
+task_t *task_create(as_t *as, const char *name)
+{
+        task_t *task = (task_t *) slab_alloc(task_slab, 0);
+        task_create_arch(task);
+        
+        task->as = as;
+        str_cpy(task->name, TASK_NAME_BUFLEN, name);
+        
+        task->context = CONTEXT;
+        task->capabilities = 0;
+        task->ucycles = 0;
+        task->kcycles = 0;
+        
+        task->ipc_info.call_sent = 0;
+        task->ipc_info.call_received = 0;
+        task->ipc_info.answer_sent = 0;
+        task->ipc_info.answer_received = 0;
+        task->ipc_info.irq_notif_received = 0;
+        task->ipc_info.forwarded = 0;
+        
 #ifdef CONFIG_UDEBUG
         /* Init debugging stuff */
-        udebug_task_init(&ta->udebug);
-
+        udebug_task_init(&task->udebug);
+        
         /* Init kbox stuff */
-        ta->kb.finished = false;
-#endif
-
+        task->kb.finished = false;
+#endif
+        
         if ((ipc_phone_0) &&
-            (context_check(ipc_phone_0->task->context, ta->context)))
-                ipc_phone_connect(&ta->phones[0], ipc_phone_0);
-
-        btree_create(&ta->futexes);
-        
-        ipl = interrupts_disable();
-        atomic_inc(&as->refcount);
-        spinlock_lock(&tasks_lock);
-        ta->taskid = ++task_counter;
-        avltree_node_initialize(&ta->tasks_tree_node);
-        ta->tasks_tree_node.key = ta->taskid; 
-        avltree_insert(&tasks_tree, &ta->tasks_tree_node);
-        spinlock_unlock(&tasks_lock);
-        interrupts_restore(ipl);
-        
-        return ta;
+            (context_check(ipc_phone_0->task->context, task->context)))
+                ipc_phone_connect(&task->phones[0], ipc_phone_0);
+        
+        btree_create(&task->futexes);
+        
+        /*
+         * Get a reference to the address space.
+         */
+        as_hold(task->as);
+        
+        irq_spinlock_lock(&tasks_lock, true);
+        
+        task->taskid = ++task_counter;
+        avltree_node_initialize(&task->tasks_tree_node);
+        task->tasks_tree_node.key = task->taskid;
+        avltree_insert(&tasks_tree, &task->tasks_tree_node);
+        
+        irq_spinlock_unlock(&tasks_lock, true);
+        
+        return task;
 }
 
 /** Destroy task.
  *
- * @param t             Task to be destroyed.
- */
-void task_destroy(task_t *t)
+ * @param task Task to be destroyed.
+ *
+ */
+void task_destroy(task_t *task)
 {
         /*
          * Remove the task from the task B+tree.
          */
-        spinlock_lock(&tasks_lock);
-        avltree_delete(&tasks_tree, &t->tasks_tree_node);
-        spinlock_unlock(&tasks_lock);
-
+        irq_spinlock_lock(&tasks_lock, true);
+        avltree_delete(&tasks_tree, &task->tasks_tree_node);
+        irq_spinlock_unlock(&tasks_lock, true);
+        
         /*
          * Perform architecture specific task destruction.
          */
-        task_destroy_arch(t);
-
+        task_destroy_arch(task);
+        
         /*
          * Free up dynamically allocated state.
          */
-        btree_destroy(&t->futexes);
-
+        btree_destroy(&task->futexes);
+        
         /*
          * Drop our reference to the address space.
          */
-        if (atomic_predec(&t->as->refcount) == 0) 
-                as_destroy(t->as);
-        
-        slab_free(task_slab, t);
-        TASK = NULL;
+        as_release(task->as);
+        
+        slab_free(task_slab, task);
+}
+
+/** Hold a reference to a task.
+ *
+ * Holding a reference to a task prevents destruction of that task.
+ *
+ * @param task Task to be held.
+ *
+ */
+void task_hold(task_t *task)
+{
+        atomic_inc(&task->refcount);
+}
+
+/** Release a reference to a task.
+ *
+ * The last one to release a reference to a task destroys the task.
+ *
+ * @param task Task to be released.
+ *
+ */
+void task_release(task_t *task)
+{
+        if ((atomic_predec(&task->refcount)) == 0)
+                task_destroy(task);
 }
 
 /** Syscall for reading task ID from userspace.
  *
- * @param               uspace_task_id userspace address of 8-byte buffer
- *                      where to store current task ID.
- *
- * @return              Zero on success or an error code from @ref errno.h.
+ * @param uspace_task_id Userspace address of 8-byte buffer
+ *                       where to store current task ID.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
  */
 unative_t sys_task_get_id(task_id_t *uspace_task_id)
@@ -267 +313 @@
  * 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).
+ * @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)
@@ -276 +323 @@
         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;
 }
@@ -297 +344 @@
  * interrupts must be disabled.
  *
- * @param id            Task ID.
- *
- * @return              Task structure address or NULL if there is no such task
- *                      ID.
- */
-task_t *task_find_by_id(task_id_t id) { avltree_node_t *node;
-        
-        node = avltree_search(&tasks_tree, (avltree_key_t) id);
-
+ * @param id Task ID.
+ *
+ * @return Task structure address or NULL if there is no such task ID.
+ *
+ */
+task_t *task_find_by_id(task_id_t id)
+{
+        ASSERT(interrupts_disabled());
+        ASSERT(irq_spinlock_locked(&tasks_lock));
+
+        avltree_node_t *node =
+            avltree_search(&tasks_tree, (avltree_key_t) id);
+        
         if (node)
-                return avltree_get_instance(node, task_t, tasks_tree_node); 
+                return avltree_get_instance(node, task_t, tasks_tree_node);
+        
         return NULL;
 }
@@ -313 +365 @@
 /** Get accounting data of given task.
  *
- * Note that task lock of 't' must be already held and interrupts must be
+ * Note that task lock of 'task' must be already held and interrupts must be
  * already disabled.
  *
- * @param t             Pointer to thread.
- *
- * @return              Number of cycles used by the task and all its threads
- *                      so far.
- */
-uint64_t task_get_accounting(task_t *t)
-{
-        /* Accumulated value of task */
-        uint64_t ret = t->cycles;
+ * @param task    Pointer to the task.
+ * @param ucycles Out pointer to sum of all user cycles.
+ * @param kcycles Out pointer to sum of all kernel cycles.
+ *
+ */
+void task_get_accounting(task_t *task, uint64_t *ucycles, uint64_t *kcycles)
+{
+        ASSERT(interrupts_disabled());
+        ASSERT(irq_spinlock_locked(&task->lock));
+
+        /* Accumulated values of task */
+        uint64_t uret = task->ucycles;
+        uint64_t kret = task->kcycles;
         
         /* Current values of threads */
         link_t *cur;
-        for (cur = t->th_head.next; cur != &t->th_head; cur = cur->next) {
-                thread_t *thr = list_get_instance(cur, thread_t, th_link);
-                
-                spinlock_lock(&thr->lock);
+        for (cur = task->th_head.next; cur != &task->th_head; cur = cur->next) {
+                thread_t *thread = list_get_instance(cur, thread_t, th_link);
+                
+                irq_spinlock_lock(&thread->lock, false);
+                
                 /* Process only counted threads */
-                if (!thr->uncounted) {
-                        if (thr == THREAD) {
+                if (!thread->uncounted) {
+                        if (thread == THREAD) {
                                 /* Update accounting of current thread */
-                                thread_update_accounting();
-                        } 
-                        ret += thr->cycles;
+                                thread_update_accounting(false);
+                        }
+                        
+                        uret += thread->ucycles;
+                        kret += thread->kcycles;
                 }
-                spinlock_unlock(&thr->lock);
+                
+                irq_spinlock_unlock(&thread->lock, false);
         }
         
-        return ret;
-}
-
-static void task_kill_internal(task_t *ta)
+        *ucycles = uret;
+        *kcycles = kret;
+}
+
+static void task_kill_internal(task_t *task)
 {
         link_t *cur;
-
+        
         /*
          * Interrupt all threads.
          */
-        spinlock_lock(&ta->lock);
-        for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
-                thread_t *thr;
+        irq_spinlock_lock(&task->lock, false);
+        for (cur = task->th_head.next; cur != &task->th_head; cur = cur->next) {
+                thread_t *thread = list_get_instance(cur, thread_t, th_link);
                 bool sleeping = false;
                 
-                thr = list_get_instance(cur, thread_t, th_link);
-                
-                spinlock_lock(&thr->lock);
-                thr->interrupted = true;
-                if (thr->state == Sleeping)
+                irq_spinlock_lock(&thread->lock, false);
+                
+                thread->interrupted = true;
+                if (thread->state == Sleeping)
                         sleeping = true;
-                spinlock_unlock(&thr->lock);
+                
+                irq_spinlock_unlock(&thread->lock, false);
                 
                 if (sleeping)
-                        waitq_interrupt_sleep(thr);
+                        waitq_interrupt_sleep(thread);
         }
-        spinlock_unlock(&ta->lock);
+        
+        irq_spinlock_unlock(&task->lock, false);
 }
 
@@ -377 +439 @@
  * It signals all the task's threads to bail it out.
  *
- * @param id            ID of the task to be killed.
- *
- * @return              Zero on success or an error code from errno.h.
+ * @param id ID of the task to be killed.
+ *
+ * @return Zero on success or an error code from errno.h.
+ *
  */
 int task_kill(task_id_t id)
 {
-        ipl_t ipl;
-        task_t *ta;
-
         if (id == 1)
                 return EPERM;
         
-        ipl = interrupts_disable();
-        spinlock_lock(&tasks_lock);
-        if (!(ta = task_find_by_id(id))) {
-                spinlock_unlock(&tasks_lock);
-                interrupts_restore(ipl);
+        irq_spinlock_lock(&tasks_lock, true);
+        
+        task_t *task = task_find_by_id(id);
+        if (!task) {
+                irq_spinlock_unlock(&tasks_lock, true);
                 return ENOENT;
         }
-        task_kill_internal(ta);
-        spinlock_unlock(&tasks_lock);
-        interrupts_restore(ipl);
-        return 0;
+        
+        task_kill_internal(task);
+        irq_spinlock_unlock(&tasks_lock, true);
+        
+        return EOK;
 }
 
 static bool task_print_walker(avltree_node_t *node, void *arg)
 {
-        task_t *t = avltree_get_instance(node, task_t, tasks_tree_node);
-        int j;
-                
-        spinlock_lock(&t->lock);
-                        
-        uint64_t cycles;
-        char suffix;
-        order(task_get_accounting(t), &cycles, &suffix);
-
-#ifdef __32_BITS__      
-        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
-
+        bool *additional = (bool *) arg;
+        task_t *task = avltree_get_instance(node, task_t, tasks_tree_node);
+        irq_spinlock_lock(&task->lock, false);
+        
+        uint64_t ucycles;
+        uint64_t kcycles;
+        char usuffix, ksuffix;
+        task_get_accounting(task, &ucycles, &kcycles);
+        order_suffix(ucycles, &ucycles, &usuffix);
+        order_suffix(kcycles, &kcycles, &ksuffix);
+        
+#ifdef __32_BITS__
+        if (*additional)
+                printf("%-8" PRIu64 " %9" PRIua " %7" PRIua, task->taskid,
+                    atomic_get(&task->refcount), atomic_get(&task->active_calls));
+        else
+                printf("%-8" PRIu64 " %-14s %-5" PRIu32 " %10p %10p"
+                    " %9" PRIu64 "%c %9" PRIu64 "%c\n", task->taskid,
+                    task->name, task->context, task, task->as,
+                    ucycles, usuffix, kcycles, ksuffix);
+#endif
+        
 #ifdef __64_BITS__
-        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
-
-        for (j = 0; j < IPC_MAX_PHONES; j++) {
-                if (t->phones[j].callee)
-                        printf(" %d:%p", j, t->phones[j].callee);
+        if (*additional)
+                printf("%-8" PRIu64 " %9" PRIu64 "%c %9" PRIu64 "%c "
+                    "%9" PRIua " %7" PRIua,
+                    task->taskid, ucycles, usuffix, kcycles, ksuffix,
+                    atomic_get(&task->refcount), atomic_get(&task->active_calls));
+        else
+                printf("%-8" PRIu64 " %-14s %-5" PRIu32 " %18p %18p\n",
+                    task->taskid, task->name, task->context, task, task->as);
+#endif
+        
+        if (*additional) {
+                size_t i;
+                for (i = 0; i < IPC_MAX_PHONES; i++) {
+                        if (task->phones[i].callee)
+                                printf(" %zu:%p", i, task->phones[i].callee);
+                }
+                printf("\n");
         }
-        printf("\n");
-                        
-        spinlock_unlock(&t->lock);
+        
+        irq_spinlock_unlock(&task->lock, false);
         return true;
 }
 
-/** Print task list */
-void task_print_list(void)
-{
-        ipl_t ipl;
-        
+/** Print task list
+ *
+ * @param additional Print additional information.
+ *
+ */
+void task_print_list(bool additional)
+{
         /* Messing with task structures, avoid deadlock */
-        ipl = interrupts_disable();
-        spinlock_lock(&tasks_lock);
-
-#ifdef __32_BITS__      
-        printf("taskid name         ctx address    as         "
-            "cycles     threads calls  callee\n");
-        printf("------ ------------ --- ---------- ---------- "
-            "---------- ------- ------ ------>\n");
-#endif
-
+        irq_spinlock_lock(&tasks_lock, true);
+        
+#ifdef __32_BITS__
+        if (additional)
+                printf("[id    ] [threads] [calls] [callee\n");
+        else
+                printf("[id    ] [name        ] [ctx] [address ] [as      ]"
+                    " [ucycles ] [kcycles ]\n");
+#endif
+        
 #ifdef __64_BITS__
-        printf("taskid name         ctx address            as                 "
-            "cycles     threads calls  callee\n");
-        printf("------ ------------ --- ------------------ ------------------ "
-            "---------- ------- ------ ------>\n");
-#endif
-
-        avltree_walk(&tasks_tree, task_print_walker, NULL);
-
-        spinlock_unlock(&tasks_lock);
-        interrupts_restore(ipl);
+        if (additional)
+                printf("[id    ] [ucycles ] [kcycles ] [threads] [calls]"
+                    " [callee\n");
+        else
+                printf("[id    ] [name        ] [ctx] [address         ]"
+                    " [as              ]\n");
+#endif
+        
+        avltree_walk(&tasks_tree, task_print_walker, &additional);
+        
+        irq_spinlock_unlock(&tasks_lock, true);
 }