Require `g_lock` in g_finish_switch()

While Linux will probably never run g_finish_switch() while we're
in edfsc_gschedule() on the same core, g_finish_switch() may run
simultaneously to an edfsc_gschedule() on a remote core. This may
not be safe, as requeue() modifies global data structures and is
currently called in g_finish_switch().

Make certain this is safe by obtaining `g_lock` for the whole
function. If future refactors remove the requeue() call from this
function, it is likely safe to revert this commit.

1 files changed, 7 insertions, 0 deletions

diff --git a/litmus/sched_edfsc.c b/litmus/sched_edfsc.c
index ada8ff936422..91c3d40529d3 100644
--- a/litmus/sched_edfsc.c
+++ b/litmus/sched_edfsc.c
@@ -557,8 +557,14 @@ static void g_finish_switch(struct task_struct *prev)
 {
         cpu_entry_t* entry = this_cpu_ptr(&edfsc_cpu_entries);
         struct task_struct* container = &container_tasks[entry->cpu];
+        unsigned long flags;
         BUG_ON(is_realtime(current) && tsk_rt(current)->domain == NULL);
 
+        // FIXME: It's really expensive to put a lock in here, but since we touch
+        //        members of entry multiple times, we have to lock. Otherwise we
+        //        may make an if branch based off entry->linked, and then have it
+        //        change before we can set entry->scheduled.
+        raw_spin_lock_irqsave(&g_lock, flags);
         entry->scheduled = is_realtime(current) ? current : NULL;
         // If we're scheduling a task in a container, set entry->scheduled to the container
         if (entry->scheduled) {
@@ -578,6 +584,7 @@ static void g_finish_switch(struct task_struct *prev)
                 requeue(tsk_rt(container)->edfsc_params.domain->scheduled);
                 tsk_rt(container)->edfsc_params.domain->scheduled = NULL;
         }
+        raw_spin_unlock_irqrestore(&g_lock, flags);
 #ifdef WANT_ALL_SCHED_EVENTS
         TRACE_TASK(prev, "switched away from\n");
 #endif