Changes in kernel/generic/src/sysinfo/stats.c [fe7bcf1:07d4271] in mainline

File:

• kernel/generic/src/sysinfo/stats.c (modified) (11 diffs)

kernel/generic/src/sysinfo/stats.c

@@ -119 +119 @@
         size_t i;
         for (i = 0; i < config.cpu_count; i++) {
-                irq_spinlock_lock(&cpus[i].lock, true);
-
                 stats_cpus[i].id = cpus[i].id;
                 stats_cpus[i].active = cpus[i].active;
                 stats_cpus[i].frequency_mhz = cpus[i].frequency_mhz;
-                stats_cpus[i].busy_cycles = cpus[i].busy_cycles;
-                stats_cpus[i].idle_cycles = cpus[i].idle_cycles;
-
-                irq_spinlock_unlock(&cpus[i].lock, true);
+
+                stats_cpus[i].busy_cycles = atomic_time_read(&cpus[i].busy_cycles);
+                stats_cpus[i].idle_cycles = atomic_time_read(&cpus[i].idle_cycles);
         }
 
@@ -224 +221 @@
         stats_task->virtmem = get_task_virtmem(task->as);
         stats_task->resmem = get_task_resmem(task->as);
-        stats_task->threads = atomic_load(&task->refcount);
+        stats_task->threads = atomic_load(&task->lifecount);
         task_get_accounting(task, &(stats_task->ucycles),
             &(stats_task->kcycles));
@@ -302 +299 @@
 {
         assert(interrupts_disabled());
-        assert(irq_spinlock_locked(&thread->lock));
 
         stats_thread->thread_id = thread->tid;
         stats_thread->task_id = thread->task->taskid;
-        stats_thread->state = thread->state;
-        stats_thread->priority = thread->priority;
-        stats_thread->ucycles = thread->ucycles;
-        stats_thread->kcycles = thread->kcycles;
-
-        if (thread->cpu != NULL) {
+        stats_thread->state = atomic_get_unordered(&thread->state);
+        stats_thread->priority = atomic_get_unordered(&thread->priority);
+        stats_thread->ucycles = atomic_time_read(&thread->ucycles);
+        stats_thread->kcycles = atomic_time_read(&thread->kcycles);
+
+        cpu_t *cpu = atomic_get_unordered(&thread->cpu);
+
+        if (cpu != NULL) {
                 stats_thread->on_cpu = true;
-                stats_thread->cpu = thread->cpu->id;
+                stats_thread->cpu = cpu->id;
         } else
                 stats_thread->on_cpu = false;
@@ -332 +330 @@
     bool dry_run, void *data)
 {
-        /* Messing with threads structures, avoid deadlock */
+        /* Messing with threads structures */
         irq_spinlock_lock(&threads_lock, true);
 
@@ -364 +362 @@
         thread_t *thread = thread_first();
         while (thread != NULL) {
-                /* Interrupts are already disabled */
-                irq_spinlock_lock(&thread->lock, false);
-
                 /* Record the statistics and increment the index */
                 produce_stats_thread(thread, &stats_threads[i]);
                 i++;
-
-                irq_spinlock_unlock(&thread->lock, false);
 
                 thread = thread_next(thread);
@@ -518 +511 @@
 {
         /* Initially no return value */
-        sysinfo_return_t ret;
-        ret.tag = SYSINFO_VAL_UNDEFINED;
+        sysinfo_return_t ret = {
+                .tag = SYSINFO_VAL_UNDEFINED,
+        };
 
         /* Parse the task ID */
@@ -526 +520 @@
                 return ret;
 
-        /* Messing with task structures, avoid deadlock */
-        irq_spinlock_lock(&tasks_lock, true);
-
         task_t *task = task_find_by_id(task_id);
-        if (task == NULL) {
-                /* No task with this ID */
-                irq_spinlock_unlock(&tasks_lock, true);
+        if (!task)
                 return ret;
-        }
 
         if (dry_run) {
@@ -540 +528 @@
                 ret.data.data = NULL;
                 ret.data.size = sizeof(stats_task_t);
-
-                irq_spinlock_unlock(&tasks_lock, true);
         } else {
                 /* Allocate stats_task_t structure */
-                stats_task_t *stats_task =
-                    (stats_task_t *) malloc(sizeof(stats_task_t));
-                if (stats_task == NULL) {
-                        irq_spinlock_unlock(&tasks_lock, true);
-                        return ret;
+                stats_task_t *stats_task = malloc(sizeof(stats_task_t));
+
+                if (stats_task != NULL) {
+                        /* Correct return value */
+                        ret.tag = SYSINFO_VAL_FUNCTION_DATA;
+                        ret.data.data = stats_task;
+                        ret.data.size = sizeof(stats_task_t);
+
+                        irq_spinlock_lock(&task->lock, true);
+                        produce_stats_task(task, stats_task);
+                        irq_spinlock_unlock(&task->lock, true);
                 }
-
-                /* Correct return value */
-                ret.tag = SYSINFO_VAL_FUNCTION_DATA;
-                ret.data.data = (void *) stats_task;
-                ret.data.size = sizeof(stats_task_t);
-
-                /* Hand-over-hand locking */
-                irq_spinlock_exchange(&tasks_lock, &task->lock);
-
-                produce_stats_task(task, stats_task);
-
-                irq_spinlock_unlock(&task->lock, true);
-        }
-
+        }
+
+        task_release(task);
         return ret;
 }
@@ -597 +578 @@
                 return ret;
 
-        /* Messing with threads structures, avoid deadlock */
+        /* Messing with threads structures */
         irq_spinlock_lock(&threads_lock, true);
 
@@ -627 +608 @@
                 ret.data.size = sizeof(stats_thread_t);
 
-                /* Hand-over-hand locking */
-                irq_spinlock_exchange(&threads_lock, &thread->lock);
-
                 produce_stats_thread(thread, stats_thread);
 
-                irq_spinlock_unlock(&thread->lock, true);
+                irq_spinlock_unlock(&threads_lock, true);
         }
 
@@ -847 +825 @@
 void kload(void *arg)
 {
-        thread_detach(THREAD);
-
         while (true) {
                 size_t ready = atomic_load(&nrdy);