Changeset a5b5f17 in mainline for kernel/generic/src/udebug/udebug_ops.c

Timestamp:

2024-01-21T16:36:15Z (4 months ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

master

Children:

1a1e124

Parents:

ed7e057 (diff), d23712e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge scheduler refactoring to remove the need for thread structure lock

All necessary synchronization is already a product of other operations
that enforce ordering (that is, runqueue manipulation and thread_sleep()
/thread_wakeup()). Some fields formally become atomic, which is only
needed because they are read from other threads to print out statistics.
These atomic operations are limited to relaxed individual reads/writes
to native-sized fields, which should at least in theory be compiled
identically to regular volatile variable accesses, the only difference
being that concurrent accesses from different threads are not undefined
behavior by definition.

Additionally, it is now made possible to switch directly to new thread
context instead of going through a separate scheduler stack. A separate
context is only needed and used when no runnable threads is immediately
available, which means we optimize switching in the limiting case where
many threads are waiting for execution. Switching is also avoided
altogether when there's only one runnable thread and it is being
preempted. Originally, the scheduler would switch to a separate stack,
requeue the thread that was running, retrieve that same thread from
queue, and switch to it again, all that work is now avoided.

File:

• kernel/generic/src/udebug/udebug_ops.c (modified) (3 diffs)

kernel/generic/src/udebug/udebug_ops.c

@@ -90 +90 @@
         }
 
-        irq_spinlock_lock(&thread->lock, true);
-
         /* Verify that 'thread' is a userspace thread. */
         if (!thread->uspace) {
-                /* It's not, deny its existence */
-                irq_spinlock_unlock(&thread->lock, true);
                 mutex_unlock(&TASK->udebug.lock);
                 return ENOENT;
         }
-
-        /* Verify debugging state. */
-        if (thread->udebug.active != true) {
-                /* Not in debugging session or undesired GO state */
-                irq_spinlock_unlock(&thread->lock, true);
-                mutex_unlock(&TASK->udebug.lock);
-                return ENOENT;
-        }
-
-        /* Now verify that the thread belongs to the current task. */
-        if (thread->task != TASK) {
-                /* No such thread belonging this task */
-                irq_spinlock_unlock(&thread->lock, true);
-                mutex_unlock(&TASK->udebug.lock);
-                return ENOENT;
-        }
-
-        irq_spinlock_unlock(&thread->lock, true);
-
-        /* Only mutex TASK->udebug.lock left. */
 
         /*
@@ -126 +102 @@
          */
         mutex_lock(&thread->udebug.lock);
+
+        /* Verify debugging state. */
+        if (thread->udebug.active != true) {
+                /* Not in debugging session or undesired GO state */
+                mutex_unlock(&thread->udebug.lock);
+                mutex_unlock(&TASK->udebug.lock);
+                return ENOENT;
+        }
+
+        /* Now verify that the thread belongs to the current task. */
+        if (thread->task != TASK) {
+                /* No such thread belonging this task */
+                mutex_unlock(&thread->udebug.lock);
+                mutex_unlock(&TASK->udebug.lock);
+                return ENOENT;
+        }
 
         /* The big task mutex is no longer needed. */
@@ -388 +380 @@
         /* FIXME: make sure the thread isn't past debug shutdown... */
         list_foreach(TASK->threads, th_link, thread_t, thread) {
-                irq_spinlock_lock(&thread->lock, false);
                 bool uspace = thread->uspace;
-                irq_spinlock_unlock(&thread->lock, false);
 
                 /* Not interested in kernel threads. */