Changeset bb252ca in mainline for kernel/generic/src

Timestamp:

2010-05-02T20:58:27Z (15 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

4872160

Parents:

4ce914d4 (diff), 1624aae (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 the scheduler fix.

Location:

kernel/generic/src

Files:

• mm/as.c (modified) (5 diffs)
• proc/scheduler.c (modified) (4 diffs)
• proc/task.c (modified) (3 diffs)
• proc/thread.c (modified) (3 diffs)

kernel/generic/src/mm/as.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2001-2006 Jakub Jermar
+ * Copyright (c) 2010 Jakub Jermar
  * All rights reserved.
  *
@@ -152 +152 @@
          * reference count never drops to zero.
          */
-        atomic_set(&AS_KERNEL->refcount, 1);
+        as_hold(AS_KERNEL);
 }
 
@@ -200 +200 @@
         DEADLOCK_PROBE_INIT(p_asidlock);
 
+        ASSERT(as != AS);
         ASSERT(atomic_get(&as->refcount) == 0);
         
         /*
-         * Since there is no reference to this area,
-         * it is safe not to lock its mutex.
+         * Since there is no reference to this address space, it is safe not to
+         * lock its mutex.
          */
 
@@ -225 +226 @@
         preemption_enable();    /* Interrupts disabled, enable preemption */
         if (as->asid != ASID_INVALID && as != AS_KERNEL) {
-                if (as != AS && as->cpu_refcount == 0)
+                if (as->cpu_refcount == 0)
                         list_remove(&as->inactive_as_with_asid_link);
                 asid_put(as->asid);
@@ -258 +259 @@
 
         slab_free(as_slab, as);
+}
+
+/** Hold a reference to an address space.
+ *
+ * Holding a reference to an address space prevents destruction of that address
+ * space.
+ *
+ * @param a             Address space to be held.
+ */
+void as_hold(as_t *as)
+{
+        atomic_inc(&as->refcount);
+}
+
+/** Release a reference to an address space.
+ *
+ * The last one to release a reference to an address space destroys the address
+ * space.
+ *
+ * @param a             Address space to be released.
+ */
+void as_release(as_t *as)
+{
+        if (atomic_predec(&as->refcount) == 0)
+                as_destroy(as);
 }
 

kernel/generic/src/proc/scheduler.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2001-2007 Jakub Jermar
+ * Copyright (c) 2010 Jakub Jermar
  * All rights reserved.
  *
@@ -382 +382 @@
         int priority;
         DEADLOCK_PROBE_INIT(p_joinwq);
+        task_t *old_task = TASK;
+        as_t *old_as = AS;
 
         ASSERT(CPU != NULL);
         
+        /*
+         * 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) {
                 /* must be run after the switch to scheduler stack */
@@ -476 +488 @@
          */
         if (TASK != THREAD->task) {
-                as_t *as1 = NULL;
-                as_t *as2;
-
-                if (TASK) {
-                        spinlock_lock(&TASK->lock);
-                        as1 = TASK->as;
-                        spinlock_unlock(&TASK->lock);
-                }
-
-                spinlock_lock(&THREAD->task->lock);
-                as2 = THREAD->task->as;
-                spinlock_unlock(&THREAD->task->lock);
+                as_t *new_as = THREAD->task->as;
                 
                 /*
@@ -493 +494 @@
                  * space.
                  */
-                if (as1 != as2) {
+                if (old_as != new_as) {
                         /*
                          * Both tasks and address spaces are different.
                          * Replace the old one with the new one.
                          */
-                        as_switch(as1, as2);
+                        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);
+        
         spinlock_lock(&THREAD->lock);   
         THREAD->state = Running;

kernel/generic/src/proc/task.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2001-2004 Jakub Jermar
+ * Copyright (c) 2010 Jakub Jermar
  * All rights reserved.
  *
@@ -210 +210 @@
         btree_create(&ta->futexes);
         
+        /*
+         * Get a reference to the address space.
+         */
+        as_hold(ta->as);
+
         ipl = interrupts_disable();
-        atomic_inc(&as->refcount);
         spinlock_lock(&tasks_lock);
         ta->taskid = ++task_counter;
@@ -250 +254 @@
          * Drop our reference to the address space.
          */
-        if (atomic_predec(&t->as->refcount) == 0) 
-                as_destroy(t->as);
+        as_release(t->as);
         
         slab_free(task_slab, t);
-        TASK = NULL;
+}
+
+/** Hold a reference to a task.
+ *
+ * Holding a reference to a task prevents destruction of that task.
+ *
+ * @param t             Task to be held.
+ */
+void task_hold(task_t *t)
+{
+        atomic_inc(&t->refcount);
+}
+
+/** Release a reference to a task.
+ *
+ * The last one to release a reference to a task destroys the task.
+ *
+ * @param t             Task to be released.
+ */
+void task_release(task_t *t)
+{
+        if ((atomic_predec(&t->refcount)) == 0)
+                task_destroy(t);
 }
 

kernel/generic/src/proc/thread.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2001-2004 Jakub Jermar
+ * Copyright (c) 2010 Jakub Jermar
  * All rights reserved.
  *
@@ -409 +409 @@
 
         /*
-         * t is guaranteed to be the very last thread of its task.
-         * It is safe to destroy the task.
+         * Drop the reference to the containing task.
          */
-        if (atomic_predec(&t->task->refcount) == 0)
-                task_destroy(t->task);
+        task_release(t->task);
         
         slab_free(thread_slab, t);
@@ -436 +434 @@
         spinlock_lock(&task->lock);
 
-        atomic_inc(&task->refcount);
+        /* Hold a reference to the task. */
+        task_hold(task);
 
         /* Must not count kbox thread into lifecount */