Changes in kernel/generic/src/proc/task.c [be06914:5bcf1f9] in mainline

File:

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

kernel/generic/src/proc/task.c

@@ -151 +151 @@
         atomic_set(&task->refcount, 0);
         atomic_set(&task->lifecount, 0);
-        atomic_set(&task->active_calls, 0);
         
         irq_spinlock_initialize(&task->lock, "task_t_lock");
@@ -291 +290 @@
 }
 
-/** Syscall for reading task ID from userspace.
- *
- * @param uspace_task_id Userspace address of 8-byte buffer
- *                       where to store current task ID.
+#ifdef __32_BITS__
+
+/** Syscall for reading task ID from userspace (32 bits)
+ *
+ * @param uspace_taskid Pointer to user-space 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)
+sysarg_t sys_task_get_id(sysarg64_t *uspace_taskid)
 {
         /*
@@ -305 +306 @@
          * the lifespan of the task.
          */
-        return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid,
+        return (sysarg_t) copy_to_uspace(uspace_taskid, &TASK->taskid,
             sizeof(TASK->taskid));
 }
+
+#endif  /* __32_BITS__ */
+
+#ifdef __64_BITS__
+
+/** Syscall for reading task ID from userspace (64 bits)
+ *
+ * @return Current task ID.
+ *
+ */
+sysarg_t sys_task_get_id(void)
+{
+        /*
+         * No need to acquire lock on TASK because taskid remains constant for
+         * the lifespan of the task.
+         */
+        return TASK->taskid;
+}
+
+#endif  /* __64_BITS__ */
 
 /** Syscall for setting the task name.
@@ -319 +340 @@
  *
  */
-unative_t sys_task_set_name(const char *uspace_name, size_t name_len)
-{
-        int rc;
+sysarg_t sys_task_set_name(const char *uspace_name, size_t name_len)
+{
         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);
+        int rc = copy_from_uspace(namebuf, uspace_name, name_len);
         if (rc != 0)
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         
         namebuf[name_len] = '\0';
+        
+        /*
+         * As the task name is referenced also from the
+         * threads, lock the threads' lock for the course
+         * of the update.
+         */
+        
+        irq_spinlock_lock(&tasks_lock, true);
+        irq_spinlock_lock(&TASK->lock, false);
+        irq_spinlock_lock(&threads_lock, false);
+        
+        /* Set task name */
         str_cpy(TASK->name, TASK_NAME_BUFLEN, namebuf);
         
+        irq_spinlock_unlock(&threads_lock, false);
+        irq_spinlock_unlock(&TASK->lock, false);
+        irq_spinlock_unlock(&tasks_lock, true);
+        
         return EOK;
+}
+
+/** Syscall to forcefully terminate a task
+ *
+ * @param uspace_taskid Pointer to task ID in user space.
+ *
+ * @return 0 on success or an error code from @ref errno.h.
+ *
+ */
+sysarg_t sys_task_kill(task_id_t *uspace_taskid)
+{
+        task_id_t taskid;
+        int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(taskid));
+        if (rc != 0)
+                return (sysarg_t) rc;
+        
+        return (sysarg_t) task_kill(taskid);
 }
 
@@ -409 +461 @@
 static void task_kill_internal(task_t *task)
 {
+        irq_spinlock_lock(&task->lock, false);
+        irq_spinlock_lock(&threads_lock, false);
+        
+        /*
+         * Interrupt all threads.
+         */
+        
         link_t *cur;
-        
-        /*
-         * Interrupt all threads.
-         */
-        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);
@@ -431 +485 @@
         }
         
+        irq_spinlock_unlock(&threads_lock, false);
         irq_spinlock_unlock(&task->lock, false);
 }
@@ -460 +515 @@
         irq_spinlock_unlock(&tasks_lock, true);
         
+        return EOK;
+}
+
+/** Kill the currently running task.
+ *
+ * @param notify Send out fault notifications.
+ *
+ * @return Zero on success or an error code from errno.h.
+ *
+ */
+void task_kill_self(bool notify)
+{
+        /*
+         * User space can subscribe for FAULT events to take action
+         * whenever a task faults (to take a dump, run a debugger, etc.).
+         * The notification is always available, but unless udebug is enabled,
+         * that's all you get.
+        */
+        if (notify) {
+                if (event_is_subscribed(EVENT_FAULT)) {
+                        /* Notify the subscriber that a fault occurred. */
+                        event_notify_3(EVENT_FAULT, LOWER32(TASK->taskid),
+                            UPPER32(TASK->taskid), (sysarg_t) THREAD);
+                
+#ifdef CONFIG_UDEBUG
+                        /* Wait for a debugging session. */
+                        udebug_thread_fault();
+#endif
+                }
+        }
+        
+        irq_spinlock_lock(&tasks_lock, true);
+        task_kill_internal(TASK);
+        irq_spinlock_unlock(&tasks_lock, true);
+        
+        thread_exit();
+}
+
+/** Process syscall to terminate the current task.
+ *
+ * @param notify Send out fault notifications.
+ *
+ */
+sysarg_t sys_task_exit(sysarg_t notify)
+{
+        task_kill_self(notify);
+        
+        /* Unreachable */
         return EOK;
 }
@@ -478 +581 @@
 #ifdef __32_BITS__
         if (*additional)
-                printf("%-8" PRIu64 " %9lu %7lu", task->taskid,
-                    atomic_get(&task->refcount), atomic_get(&task->active_calls));
+                printf("%-8" PRIu64 " %9" PRIua, task->taskid,
+                    atomic_get(&task->refcount));
         else
                 printf("%-8" PRIu64 " %-14s %-5" PRIu32 " %10p %10p"
@@ -489 +592 @@
 #ifdef __64_BITS__
         if (*additional)
-                printf("%-8" PRIu64 " %9" PRIu64 "%c %9" PRIu64 "%c %9lu %7lu",
-                    task->taskid, ucycles, usuffix, kcycles, ksuffix,
-                    atomic_get(&task->refcount), atomic_get(&task->active_calls));
+                printf("%-8" PRIu64 " %9" PRIu64 "%c %9" PRIu64 "%c "
+                    "%9" PRIua, task->taskid, ucycles, usuffix, kcycles,
+                    ksuffix, atomic_get(&task->refcount));
         else
                 printf("%-8" PRIu64 " %-14s %-5" PRIu32 " %18p %18p\n",
@@ -501 +604 @@
                 for (i = 0; i < IPC_MAX_PHONES; i++) {
                         if (task->phones[i].callee)
-                                printf(" %" PRIs ":%p", i, task->phones[i].callee);
+                                printf(" %zu:%p", i, task->phones[i].callee);
                 }
                 printf("\n");