Changeset aab5e46 in mainline

Timestamp:

2018-11-03T23:32:39Z (5 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

790f3a3

Parents:

ef1eab7

Message:

Thread and task iterator functions.

Location:

kernel

Files:

• generic/include/proc/task.h (modified) (1 diff)
• generic/include/proc/thread.h (modified) (1 diff)
• generic/src/proc/task.c (modified) (5 diffs)
• generic/src/proc/thread.c (modified) (4 diffs)
• generic/src/sysinfo/stats.c (modified) (6 diffs)
• test/mm/falloc2.c (modified) (4 diffs)

kernel/generic/include/proc/task.h

@@ -158 +158 @@
 extern void task_release(task_t *);
 extern task_t *task_find_by_id(task_id_t);
+extern size_t task_count(void);
+extern task_t *task_first(void);
+extern task_t *task_next(task_t *);
 extern errno_t task_kill(task_id_t);
 extern void task_kill_self(bool) __attribute__((noreturn));

kernel/generic/include/proc/thread.h

@@ -261 +261 @@
 extern void thread_destroy(thread_t *, bool);
 extern thread_t *thread_find_by_id(thread_id_t);
+extern size_t thread_count(void);
+extern thread_t *thread_first(void);
+extern thread_t *thread_next(thread_t *);
 extern void thread_update_accounting(bool);
 extern bool thread_exists(thread_t *);

kernel/generic/src/proc/task.c

@@ -107 +107 @@
 {
         size_t tasks_left;
-        odlink_t *odlink;
         task_t *task;
 
@@ -128 +127 @@
                 tasks_left = 0;
 
-                odlink = odict_first(&tasks);
-                while (odlink != NULL) {
-                        task = odict_get_instance(odlink, task_t, ltasks);
-
+                task = task_first();
+                while (task != NULL) {
                         if (task != TASK) {
                                 tasks_left++;
@@ -140 +137 @@
                         }
 
-                        odlink = odict_next(odlink, &tasks);
+                        task = task_next(task);
                 }
 
@@ -452 +449 @@
 }
 
+/** Get count of tasks.
+ *
+ * @return Number of tasks in the system
+ */
+size_t task_count(void)
+{
+        assert(interrupts_disabled());
+        assert(irq_spinlock_locked(&tasks_lock));
+
+        return odict_count(&tasks);
+}
+
+/** Get first task (task with lowest ID).
+ *
+ * @return Pointer to first task or @c NULL if there are none.
+ */
+task_t *task_first(void)
+{
+        odlink_t *odlink;
+
+        assert(interrupts_disabled());
+        assert(irq_spinlock_locked(&tasks_lock));
+
+        odlink = odict_first(&tasks);
+        if (odlink == NULL)
+                return NULL;
+
+        return odict_get_instance(odlink, task_t, ltasks);
+}
+
+/** Get next task (with higher task ID).
+ *
+ * @param cur Current task
+ * @return Pointer to next task or @c NULL if there are no more tasks.
+ */
+task_t *task_next(task_t *cur)
+{
+        odlink_t *odlink;
+
+        assert(interrupts_disabled());
+        assert(irq_spinlock_locked(&tasks_lock));
+
+        odlink = odict_next(&cur->ltasks, &tasks);
+        if (odlink == NULL)
+                return NULL;
+
+        return odict_get_instance(odlink, task_t, ltasks);
+}
+
 /** Get accounting data of given task.
  *
@@ -658 +704 @@
 #endif
 
-        odlink_t *odlink;
         task_t *task;
 
-        odlink = odict_first(&tasks);
-        while (odlink != NULL) {
-                task = odict_get_instance(odlink, task_t, ltasks);
+        task = task_first();
+        while (task != NULL) {
                 task_print(task, additional);
-                odlink = odict_next(odlink, &tasks);
+                task = task_next(task);
         }
 

kernel/generic/src/proc/thread.c

@@ -772 +772 @@
 void thread_print_list(bool additional)
 {
-        odlink_t *odlink;
         thread_t *thread;
 
@@ -796 +795 @@
 #endif
 
-        odlink = odict_first(&threads);
-        while (odlink != NULL) {
-                thread = odict_get_instance(odlink, thread_t, lthreads);
+        thread = thread_first();
+        while (thread != NULL) {
                 thread_print(thread, additional);
-                odlink = odict_next(odlink, &threads);
+                thread = thread_next(thread);
         }
 
@@ -860 +858 @@
 thread_t *thread_find_by_id(thread_id_t thread_id)
 {
-        odlink_t *odlink;
         thread_t *thread;
 
@@ -866 +863 @@
         assert(irq_spinlock_locked(&threads_lock));
 
-        odlink = odict_first(&threads);
-        while (odlink != NULL) {
-                thread = odict_get_instance(odlink, thread_t, lthreads);
+        thread = thread_first();
+        while (thread != NULL) {
                 if (thread->tid == thread_id)
                         return thread;
 
-                odlink = odict_next(odlink, &threads);
+                thread = thread_next(thread);
         }
 
         return NULL;
+}
+
+/** Get count of threads.
+ *
+ * @return Number of threads in the system
+ */
+size_t thread_count(void)
+{
+        assert(interrupts_disabled());
+        assert(irq_spinlock_locked(&threads_lock));
+
+        return odict_count(&threads);
+}
+
+/** Get first thread.
+ *
+ * @return Pointer to first thread or @c NULL if there are none.
+ */
+thread_t *thread_first(void)
+{
+        odlink_t *odlink;
+
+        assert(interrupts_disabled());
+        assert(irq_spinlock_locked(&threads_lock));
+
+        odlink = odict_first(&threads);
+        if (odlink == NULL)
+                return NULL;
+
+        return odict_get_instance(odlink, thread_t, lthreads);
+}
+
+/** Get next thread.
+ *
+ * @param cur Current thread
+ * @return Pointer to next thread or @c NULL if there are no more threads.
+ */
+thread_t *thread_next(thread_t *cur)
+{
+        odlink_t *odlink;
+
+        assert(interrupts_disabled());
+        assert(irq_spinlock_locked(&threads_lock));
+
+        odlink = odict_next(&cur->lthreads, &threads);
+        if (odlink == NULL)
+                return NULL;
+
+        return odict_get_instance(odlink, thread_t, lthreads);
 }
 

kernel/generic/src/sysinfo/stats.c

@@ -246 +246 @@
 
         /* Count the tasks */
-        size_t count = odict_count(&tasks);
+        size_t count = task_count();
 
         if (count == 0) {
@@ -271 +271 @@
         /* Gather the statistics for each task */
         size_t i = 0;
-        odlink_t *odlink = odict_first(&tasks);
-        while (odlink != NULL) {
-                task_t *task = odict_get_instance(odlink, task_t, ltasks);
-
+        task_t *task = task_first();
+        while (task != NULL) {
                 /* Interrupts are already disabled */
                 irq_spinlock_lock(&(task->lock), false);
@@ -283 +281 @@
 
                 irq_spinlock_unlock(&(task->lock), false);
-                odlink = odict_next(odlink, &tasks);
+                task = task_next(task);
         }
 
@@ -336 +334 @@
 
         /* Count the threads */
-        size_t count = odict_count(&threads);
+        size_t count = thread_count();
 
         if (count == 0) {
@@ -362 +360 @@
         size_t i = 0;
 
-        odlink_t *odlink = odict_first(&threads);
-        while (odlink != NULL) {
-                thread_t *thread = odict_get_instance(odlink, thread_t,
-                    lthreads);
-
+        thread_t *thread = thread_first();
+        while (thread != NULL) {
                 /* Interrupts are already disabled */
                 irq_spinlock_lock(&thread->lock, false);
@@ -376 +371 @@
                 irq_spinlock_unlock(&thread->lock, false);
 
-                odlink = odict_next(odlink, &threads);
+                thread = thread_next(thread);
         }
 

kernel/test/mm/falloc2.c

@@ -43 +43 @@
 #define THREADS      8
 
-static atomic_t thread_count;
+static atomic_t thread_cnt;
 static atomic_t thread_fail;
 
@@ -56 +56 @@
                     "Unable to allocate frames\n", THREAD->tid, CPU->id);
                 atomic_inc(&thread_fail);
-                atomic_dec(&thread_count);
+                atomic_dec(&thread_cnt);
                 return;
         }
@@ -110 +110 @@
         TPRINTF("Thread #%" PRIu64 " (cpu%u): Exiting\n",
             THREAD->tid, CPU->id);
-        atomic_dec(&thread_count);
+        atomic_dec(&thread_cnt);
 }
 
 const char *test_falloc2(void)
 {
-        atomic_store(&thread_count, THREADS);
+        atomic_store(&thread_cnt, THREADS);
         atomic_store(&thread_fail, 0);
 
@@ -128 +128 @@
         }
 
-        while (atomic_load(&thread_count) > 0) {
+        while (atomic_load(&thread_cnt) > 0) {
                 TPRINTF("Threads left: %zu\n",
-                    atomic_load(&thread_count));
+                    atomic_load(&thread_cnt));
                 thread_sleep(1);
         }