Fix CPU load balancer bugs, scheduling points support for remote CPUs

kernel/proc/mutex.c

@@ -37,14 +37,15 @@ void proc_mutexes_cleanup (struct proc* proc) {
     if (resource->u.mutex.owner == proc && resource->u.mutex.locked) {
       spin_unlock (&resource->lock, &ctxrs);
 
-      proc_mutex_unlock (proc, &resource->u.mutex);
+      struct cpu* reschedule_cpu;
+      proc_mutex_unlock (proc, &resource->u.mutex, &reschedule_cpu);
     }
   }
 
   spin_unlock (&proc->procgroup->lock, &ctxpg);
 }
 
-bool proc_cleanup_resource_mutex (struct proc_resource* resource) {
+bool proc_cleanup_resource_mutex (struct proc_resource* resource, struct cpu** reschedule_cpu) {
   struct proc_mutex* mutex = &resource->u.mutex;
   spin_lock_ctx_t ctxmt, ctxsq;
 
@@ -62,7 +63,7 @@ bool proc_cleanup_resource_mutex (struct proc_resource* resource) {
     spin_unlock (&mutex->suspension_q.lock, &ctxsq);
     spin_unlock (&mutex->resource->lock, &ctxmt);
 
-    reschedule = reschedule || proc_sq_resume (suspended_proc, sq_entry);
+    reschedule = reschedule || proc_sq_resume (suspended_proc, sq_entry, reschedule_cpu);
 
     /* reacquire */
     spin_lock (&mutex->resource->lock, &ctxmt);
@@ -78,7 +79,7 @@ bool proc_cleanup_resource_mutex (struct proc_resource* resource) {
   return reschedule;
 }
 
-bool proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex) {
+bool proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex, struct cpu** reschedule_cpu) {
   spin_lock_ctx_t ctxmt;
 
   spin_lock (&mutex->resource->lock, &ctxmt);
@@ -90,10 +91,11 @@ bool proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex) {
     return PROC_NO_RESCHEDULE;
   }
 
-  return proc_sq_suspend (proc, &mutex->suspension_q, &mutex->resource->lock, &ctxmt);
+  return proc_sq_suspend (proc, &mutex->suspension_q, &mutex->resource->lock, &ctxmt,
+                          reschedule_cpu);
 }
 
-bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex) {
+bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex, struct cpu** reschedule_cpu) {
   spin_lock_ctx_t ctxmt, ctxsq;
 
   spin_lock (&mutex->resource->lock, &ctxmt);
@@ -117,7 +119,7 @@ bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex) {
     spin_unlock (&mutex->suspension_q.lock, &ctxsq);
     spin_unlock (&mutex->resource->lock, &ctxmt);
 
-    return proc_sq_resume (resumed_proc, sq_entry);
+    return proc_sq_resume (resumed_proc, sq_entry, reschedule_cpu);
   }
 
   mutex->locked = false;
@@ -126,5 +128,5 @@ bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex) {
   spin_unlock (&mutex->suspension_q.lock, &ctxsq);
   spin_unlock (&mutex->resource->lock, &ctxmt);
 
-  return PROC_NEED_RESCHEDULE;
+  return PROC_NO_RESCHEDULE;
 }

kernel/proc/mutex.h

@@ -6,6 +6,7 @@
 
 struct proc;
 struct proc_resource;
+struct cpu;
 
 struct proc_mutex {
   struct proc_resource* resource;
@@ -15,9 +16,9 @@ struct proc_mutex {
   struct proc* owner;
 };
 
-bool proc_cleanup_resource_mutex (struct proc_resource* resource);
-bool proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex);
-bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex);
+bool proc_cleanup_resource_mutex (struct proc_resource* resource, struct cpu** reschedule_cpu);
+bool proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex, struct cpu** reschedule_cpu);
+bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex, struct cpu** reschedule_cpu);
 void proc_mutexes_cleanup (struct proc* proc);
 
 #endif // _KERNEL_PROC_MUTEX_H

kernel/proc/proc.c

@@ -122,15 +122,16 @@ struct proc* proc_find_pid (int pid) {
   return proc;
 }
 
-void proc_register (struct proc* proc, struct cpu* cpu1) {
-  spin_lock_ctx_t ctxcpu, ctxprtr;
+bool proc_register (struct proc* proc, struct cpu** reschedule_cpu) {
+  spin_lock_ctx_t ctxcpu, ctxprtr, ctxpr;
 
-  proc->cpu = cpu1 != NULL ? cpu1 : cpu_find_lightest ();
-
-  struct cpu* cpu = proc->cpu;
+  struct cpu* cpu = *reschedule_cpu != NULL ? *reschedule_cpu : cpu_find_lightest ();
 
   spin_lock (&proc_tree_lock, &ctxprtr);
   spin_lock (&cpu->lock, &ctxcpu);
+  spin_lock (&proc->lock, &ctxpr);
+
+  proc->cpu = cpu;
 
   rbtree_insert (struct proc, &proc_tree, &proc->proc_tree_link, proc_tree_link, pid);
 
@@ -139,8 +140,13 @@ void proc_register (struct proc* proc, struct cpu* cpu1) {
   if (cpu->proc_current == NULL)
     cpu->proc_current = proc;
 
-  spin_unlock (&proc_tree_lock, &ctxprtr);
+  spin_unlock (&proc->lock, &ctxpr);
   spin_unlock (&cpu->lock, &ctxcpu);
+  spin_unlock (&proc_tree_lock, &ctxprtr);
+
+  *reschedule_cpu = cpu;
+
+  return PROC_NEED_RESCHEDULE;
 }
 
 /* caller holds cpu->lock */
@@ -237,27 +243,32 @@ void proc_sched (void) {
   }
 }
 
-void proc_kill (struct proc* proc) {
+bool proc_kill (struct proc* proc, struct cpu** reschedule_cpu) {
   spin_lock_ctx_t ctxpr, ctxcpu;
-  struct cpu* cpu = proc->cpu;
 
   spin_lock (&proc->lock, &ctxpr);
-  atomic_store (&proc->state, PROC_DEAD);
-  proc->cpu = NULL;
+  struct cpu* cpu = proc->cpu;
   spin_unlock (&proc->lock, &ctxpr);
 
   spin_lock (&cpu->lock, &ctxcpu);
+  spin_lock (&proc->lock, &ctxpr);
+
+  atomic_store (&proc->state, PROC_DEAD);
+  proc->cpu = NULL;
 
   list_remove (cpu->proc_run_q, &proc->cpu_run_q_link);
   atomic_fetch_sub (&cpu->proc_run_q_count, 1);
   if (cpu->proc_current == proc)
     cpu->proc_current = NULL;
 
+  spin_unlock (&proc->lock, &ctxpr);
   spin_unlock (&cpu->lock, &ctxcpu);
 
   DEBUG ("killed PID %d\n", proc->pid);
 
-  cpu_request_sched (cpu);
+  *reschedule_cpu = cpu;
+
+  return PROC_NEED_RESCHEDULE;
 }
 
 static void proc_irq_sched (void* arg, void* regs) {
@@ -272,10 +283,12 @@ void proc_init (void) {
 #endif
 
   struct proc* spin_proc = proc_spawn_rd ("spin.exe");
-  proc_register (spin_proc, thiscpu);
+  struct cpu* spin_cpu = thiscpu;
+  proc_register (spin_proc, &spin_cpu);
 
   struct proc* init = proc_spawn_rd ("init.exe");
-  proc_register (init, NULL);
+  struct cpu* init_cpu = thiscpu;
+  proc_register (init, &init_cpu);
 
   spin_lock_ctx_t ctxcpu;
   spin_lock (&spin_proc->cpu->lock, &ctxcpu);

kernel/proc/proc.h

@@ -47,9 +47,9 @@ struct proc {
 };
 
 void proc_sched (void);
-void proc_kill (struct proc* proc);
+bool proc_kill (struct proc* proc, struct cpu** reschedule_cpu);
 struct elf_aux proc_load_segments (struct proc* proc, uint8_t* elf);
-void proc_register (struct proc* proc, struct cpu* cpu);
+bool proc_register (struct proc* proc, struct cpu** reschedule_cpu);
 struct proc* proc_find_pid (int pid);
 struct proc* proc_spawn_rd (char* name);
 void proc_init (void);

kernel/proc/procgroup.c

@@ -197,7 +197,8 @@ void procgroup_detach (struct procgroup* procgroup, struct proc* proc) {
 
       rnode = next;
 
-      proc_delete_resource (resource);
+      struct cpu* reschedule_cpu;
+      proc_delete_resource (resource, &reschedule_cpu);
     }
 
     struct list_node_link *mapping_link, *mapping_link_tmp;

kernel/proc/resource.c

@@ -51,8 +51,8 @@ struct proc_resource* proc_create_resource_mutex (struct procgroup* procgroup, i
   return resource;
 }
 
-bool proc_delete_resource (struct proc_resource* resource) {
-  bool reschedule = resource->ops.cleanup (resource);
+bool proc_delete_resource (struct proc_resource* resource, struct cpu** reschedule_cpu) {
+  bool reschedule = resource->ops.cleanup (resource, reschedule_cpu);
   free (resource);
 
   return reschedule;

kernel/proc/resource.h

@@ -11,6 +11,7 @@
 
 struct proc;
 struct procgroup;
+struct cpu;
 
 struct proc_resource {
   int type;
@@ -21,12 +22,12 @@ struct proc_resource {
     struct proc_mutex mutex;
   } u;
   struct {
-    bool (*cleanup) (struct proc_resource* resource);
+    bool (*cleanup) (struct proc_resource* resource, struct cpu** reschedule_cpu);
   } ops;
 };
 
 struct proc_resource* proc_find_resource (struct procgroup* procgroup, int rid);
 struct proc_resource* proc_create_resource_mutex (struct procgroup* procgroup, int rid);
-bool proc_delete_resource (struct proc_resource* resource);
+bool proc_delete_resource (struct proc_resource* resource, struct cpu** reschedule_cpu);
 
 #endif // _KERNEL_PROC_RESOURCE_H

kernel/proc/suspension_q.c

@@ -9,7 +9,7 @@
 #include <sys/spin_lock.h>
 
 bool proc_sq_suspend (struct proc* proc, struct proc_suspension_q* sq, spin_lock_t* resource_lock,
-                      spin_lock_ctx_t* ctxrl) {
+                      spin_lock_ctx_t* ctxrl, struct cpu** reschedule_cpu) {
   spin_lock_ctx_t ctxpr, ctxcpu, ctxsq;
   struct cpu* cpu = proc->cpu;
 
@@ -48,10 +48,13 @@ bool proc_sq_suspend (struct proc* proc, struct proc_suspension_q* sq, spin_lock
   spin_unlock (&proc->lock, &ctxpr);
   spin_unlock (&cpu->lock, &ctxcpu);
 
+  *reschedule_cpu = cpu;
+
   return PROC_NEED_RESCHEDULE;
 }
 
-bool proc_sq_resume (struct proc* proc, struct proc_sq_entry* sq_entry) {
+bool proc_sq_resume (struct proc* proc, struct proc_sq_entry* sq_entry,
+                     struct cpu** reschedule_cpu) {
   spin_lock_ctx_t ctxsq, ctxpr, ctxcpu;
   struct cpu* cpu = cpu_find_lightest ();
   struct proc_suspension_q* sq = sq_entry->sq;
@@ -80,6 +83,8 @@ bool proc_sq_resume (struct proc* proc, struct proc_sq_entry* sq_entry) {
 
   free (sq_entry);
 
+  *reschedule_cpu = cpu;
+
   return PROC_NEED_RESCHEDULE;
 }
 

kernel/proc/suspension_q.h

@@ -5,6 +5,7 @@
 #include <sync/spin_lock.h>
 
 struct proc;
+struct cpu;
 
 struct proc_suspension_q {
   struct list_node_link* proc_list;
@@ -20,7 +21,8 @@ struct proc_sq_entry {
 
 void proc_sqs_cleanup (struct proc* proc);
 bool proc_sq_suspend (struct proc* proc, struct proc_suspension_q* sq, spin_lock_t* resource_lock,
-                      spin_lock_ctx_t* ctxrl);
-bool proc_sq_resume (struct proc* proc, struct proc_sq_entry* sq_entry);
+                      spin_lock_ctx_t* ctxrl, struct cpu** reschedule_cpu);
+bool proc_sq_resume (struct proc* proc, struct proc_sq_entry* sq_entry,
+                     struct cpu** reschedule_cpu);
 
 #endif // _KERNEL_PROC_SUSPENTION_Q_H