WebSVN – HelenOS – Diff – //trunk/kernel/generic/src/proc/task.c

 /** Spinlock protecting the tasks_btree B+tree. */
 SPINLOCK_INITIALIZE(tasks_lock);
 /** B+tree of active tasks.
+ *
- * The task is guaranteed to exist after it was found in the tasks_btree as long as:
+ * The task is guaranteed to exist after it was found in the tasks_btree as
+ * long as:
  * @li the tasks_lock is held,
- * @li the task's lock is held when task's lock is acquired before releasing tasks_lock or
+ * @li the task's lock is held when task's lock is acquired before releasing
+ *     tasks_lock or
  * @li the task's refcount is greater than 0
+ *
  */
 btree_t tasks_btree;
     ta->cycles = 0;
     ipc_answerbox_init(&ta->answerbox);
     for (i = 0; i < IPC_MAX_PHONES; i++)
         ipc_phone_init(&ta->phones[i]);
-    if ((ipc_phone_0) && (context_check(ipc_phone_0->task->context, ta->context)))
+    if ((ipc_phone_0) && (context_check(ipc_phone_0->task->context,
+        ta->context)))
         ipc_phone_connect(&ta->phones[0], ipc_phone_0);
     atomic_set(&ta->active_calls, 0);
     mutex_initialize(&ta->futexes_lock);
     btree_create(&ta->futexes);
         as_destroy(as);
         return NULL;
+    }
     kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
+    kernel_uarg->uspace_entry =
-    kernel_uarg->uspace_entry = (void *) ((elf_header_t *) program_addr)->e_entry;
+        (void *) ((elf_header_t *) program_addr)->e_entry;
     kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
     kernel_uarg->uspace_thread_function = NULL;
     kernel_uarg->uspace_thread_arg = NULL;
     kernel_uarg->uspace_uarg = NULL;
     ASSERT(task);
     /*
      * Create the data as_area.
      */
     a = as_area_create(as, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
-        LOADED_PROG_STACK_PAGES_NO*PAGE_SIZE,
+        LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
-        USTACK_ADDRESS, AS_AREA_ATTR_NONE, &anon_backend, NULL);
+        AS_AREA_ATTR_NONE, &anon_backend, NULL);
     /*
      * Create the main thread.
      */
-    t1 = thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE, "uinit", false);
+    t1 = thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE,
+        "uinit", false);
     ASSERT(t1);
     /*
      * Create killer thread for the new task.
      */
     return task;
+}
 /** Syscall for reading task ID from userspace.
+ *
- * @param uspace_task_id Userspace address of 8-byte buffer where to store current task ID.
+ * @param uspace_task_id Userspace address of 8-byte buffer where to store
+ * current task ID.
+ *
  * @return 0 on success or an error code from @ref errno.h.
  */
 unative_t sys_task_get_id(task_id_t *uspace_task_id)
+{
     /*
      * No need to acquire lock on TASK because taskid
      * remains constant for the lifespan of the task.
      */
-    return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid, sizeof(TASK->taskid));
+    return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid,
+        sizeof(TASK->taskid));
+}
 /** Find task structure corresponding to task ID.
+ *
  * The tasks_lock must be already held by the caller of this function
         thread_t *thr = list_get_instance(cur, thread_t, th_link);
         spinlock_lock(&thr->lock);
         /* Process only counted threads */
         if (!thr->uncounted) {
+            if (thr == THREAD) {
-            if (thr == THREAD) /* Update accounting of current thread */
+                /* Update accounting of current thread */
                 thread_update_accounting();
+            }
             ret += thr->cycles;
+        }
         spinlock_unlock(&thr->lock);
+    }
     /* Messing with thread structures, avoid deadlock */
     ipl = interrupts_disable();
     spinlock_lock(&tasks_lock);
-    printf("taskid name       ctx address    as         cycles     threads calls  callee\n");
+    printf("taskid name       ctx address    as         cycles     threads "
+        "calls  callee\n");
-    printf("------ ---------- --- ---------- ---------- ---------- ------- ------ ------>\n");
+    printf("------ ---------- --- ---------- ---------- ---------- ------- "        "------ ------>\n");
-    for (cur = tasks_btree.leaf_head.next; cur != &tasks_btree.leaf_head; cur = cur->next) {
+    for (cur = tasks_btree.leaf_head.next; cur != &tasks_btree.leaf_head;
+        cur = cur->next) {
         btree_node_t *node;
         int i;
         node = list_get_instance(cur, btree_node_t, leaf_link);
         for (i = 0; i < node->keys; i++) {
             uint64_t cycles;
             char suffix;
             order(task_get_accounting(t), &cycles, &suffix);
-            printf("%-6lld %-10s %-3ld %#10zx %#10zx %9llu%c %7zd %6zd", t->taskid, t->name, t->context, t, t->as, cycles, suffix, t->refcount, atomic_get(&t->active_calls));
+            printf("%-6lld %-10s %-3ld %#10zx %#10zx %9llu%c %7zd "
+                "%6zd", t->taskid, t->name, t->context, t, t->as,
+                cycles, suffix, t->refcount,
+                atomic_get(&t->active_calls));
             for (j = 0; j < IPC_MAX_PHONES; j++) {
                 if (t->phones[j].callee)
+                    printf(" %zd:%#zx", j,
-                    printf(" %zd:%#zx", j, t->phones[j].callee);
+                        t->phones[j].callee);
+            }
             printf("\n");
             spinlock_unlock(&t->lock);
+        }
         scheduler();
         goto loop;
+    }
     if (t != THREAD) {
-        ASSERT(t != main_thread);   /* uninit is joined and detached in ktaskgc */
+        ASSERT(t != main_thread);   /* uninit is joined and detached
+                         * in ktaskgc */
         thread_join(t);
         thread_detach(t);
-        goto loop;  /* go for another thread */
+        goto loop;          /* go for another thread */
+    }
     /*
      * Now there are no other threads in this task
      * and no new threads can be created.
 loop:
     /*
      * Userspace threads cannot detach themselves,
      * therefore the thread pointer is guaranteed to be valid.
      */
-    if (thread_join_timeout(t, 1000000, SYNCH_FLAGS_NONE) == ESYNCH_TIMEOUT) {  /* sleep uninterruptibly here! */
+    if (thread_join_timeout(t, 1000000, SYNCH_FLAGS_NONE) ==
+        ESYNCH_TIMEOUT) {   /* sleep uninterruptibly here! */
         ipl_t ipl;
         link_t *cur;
         thread_t *thr = NULL;
         /*
-         * The join timed out. Try to do some garbage collection of Undead threads.
+         * The join timed out. Try to do some garbage collection of
+         * Undead threads.
          */
 more_gc:
         ipl = interrupts_disable();
         spinlock_lock(&TASK->lock);
-        for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
+        for (cur = TASK->th_head.next; cur != &TASK->th_head;
+            cur = cur->next) {
             thr = list_get_instance(cur, thread_t, th_link);
             spinlock_lock(&thr->lock);
-            if (thr != t && thr->state == Undead && thr->join_type == None) {
+            if (thr != t && thr->state == Undead &&
+                thr->join_type == None) {
                 thr->join_type = TaskGC;
                 spinlock_unlock(&thr->lock);
                 break;
+            }
             spinlock_unlock(&thr->lock);

Subversion Repositories HelenOS

(root)//trunk/kernel/generic/src/proc/task.c – Rev 2071 → 2087