Changeset c680333 in mainline

Timestamp:

2023-04-07T18:23:19Z (19 months ago)

Author:

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

Branches:

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

Children:

2a230b6, dd218ea

Parents:

3118355

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2023-03-04 18:17:37)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2023-04-07 18:23:19)

Message:

Move task switch handling into a separate function

Location:

kernel/generic/src

Files:

• mm/as.c (modified) (1 diff)
• proc/scheduler.c (modified) (4 diffs)

kernel/generic/src/mm/as.c

@@ -1688 +1688 @@
         spinlock_unlock(&asidlock);
 
+        if (AS)
+                as_release(AS);
+
         AS = new_as;
+
+        as_hold(AS);
 }
 

kernel/generic/src/proc/scheduler.c

@@ -70 +70 @@
 atomic_size_t nrdy;  /**< Number of ready threads in the system. */
 
-/** Carry out actions before new task runs. */
-static void before_task_runs(void)
-{
-        before_task_runs_arch();
-}
-
 /** Take actions before new thread runs.
  *
@@ -255 +249 @@
 
         goto loop;
+}
+
+static void switch_task(task_t *task)
+{
+        /* If the task stays the same, a lot of work is avoided. */
+        if (TASK == task)
+                return;
+
+        as_t *old_as = AS;
+        as_t *new_as = task->as;
+
+        /* It is possible for two tasks to share one address space. */
+        if (old_as != new_as)
+                as_switch(old_as, new_as);
+
+        if (TASK)
+                task_release(TASK);
+
+        TASK = task;
+
+        task_hold(TASK);
+
+        before_task_runs_arch();
 }
 
@@ -403 +420 @@
 void scheduler_separated_stack(void)
 {
-        task_t *old_task = TASK;
-        as_t *old_as = AS;
-
         assert((!THREAD) || (irq_spinlock_locked(&THREAD->lock)));
         assert(CPU != NULL);
         assert(interrupts_disabled());
-
-        /*
-         * Hold the current task and the address space to prevent their
-         * possible destruction should thread_destroy() be called on this or any
-         * other processor while the scheduler is still using them.
-         */
-        if (old_task)
-                task_hold(old_task);
-
-        if (old_as)
-                as_hold(old_as);
 
         if (THREAD) {
@@ -471 +474 @@
         relink_rq(priority);
 
-        /*
-         * If both the old and the new task are the same,
-         * lots of work is avoided.
-         */
-        if (TASK != THREAD->task) {
-                as_t *new_as = THREAD->task->as;
-
-                /*
-                 * Note that it is possible for two tasks
-                 * to share one address space.
-                 */
-                if (old_as != new_as) {
-                        /*
-                         * Both tasks and address spaces are different.
-                         * Replace the old one with the new one.
-                         */
-                        as_switch(old_as, new_as);
-                }
-
-                TASK = THREAD->task;
-                before_task_runs();
-        }
-
-        if (old_task)
-                task_release(old_task);
-
-        if (old_as)
-                as_release(old_as);
+        switch_task(THREAD->task);
 
         irq_spinlock_lock(&THREAD->lock, false);