From: Tomas Hruby <tom@minix3.org>
Date: Wed, 15 Sep 2010 14:10:42 +0000 (+0000)
Subject: SMP - Changed prototype of sys_schedule()
X-Git-Tag: v3.2.0~851
X-Git-Url: http://zhaoyanbai.com/repos/%22http:/www.isc.org/icons/zlib_tech.html?a=commitdiff_plain;h=06b6e5624a9e702a53767285a311b17e6fda8ce2;p=minix.git

SMP - Changed prototype of sys_schedule()

- sys_schedule can change only selected values, -1 means that the
  current value should be kept unchanged. For instance we mostly want
  to change the scheduling quantum and priority but we want to keep
  the process at the current cpu

- RS can hand off its processes to scheduler

- service can read the destination cpu from system.conf

- RS can pass the information farther
---

diff --git a/include/minix/com.h b/include/minix/com.h
index 04fc74d95..270e6406f 100644
--- a/include/minix/com.h
+++ b/include/minix/com.h
@@ -676,6 +676,7 @@
 #define SCHEDCTL_ENDPOINT	m9_l2	/* endpt of process to be scheduled */
 #define SCHEDCTL_QUANTUM	m9_l3   /* current scheduling quantum */
 #define SCHEDCTL_PRIORITY	m9_s4   /* current scheduling priority */
+#define SCHEDCTL_CPU		m9_l5   /* where to place this process */
 
 /*===========================================================================*
  *                Messages for the Reincarnation Server 		     *
@@ -1141,6 +1142,7 @@
 #	define SCHEDULING_ENDPOINT	m9_l1
 #	define SCHEDULING_QUANTUM	m9_l2
 #	define SCHEDULING_PRIORITY	m9_s1
+#	define SCHEDULING_CPU		m9_l4
 
 /* SCHEDULING_START uses _ENDPOINT, _PRIORITY and _QUANTUM from
  * SCHEDULING_NO_QUANTUM */
diff --git a/include/minix/rs.h b/include/minix/rs.h
index 5d64ff756..f0493dcad 100644
--- a/include/minix/rs.h
+++ b/include/minix/rs.h
@@ -33,6 +33,10 @@ Interface to the reincarnation server
 #define RS_NR_PCI_CLASS		 4
 #define RS_MAX_LABEL_LEN	16
 
+/* CPU special values */
+#define RS_CPU_DEFAULT		-1 /* use the default cpu or do not change the current one */
+#define RS_CPU_BSP		-2 /* use the bootstrap cpu */
+
 /* Labels are copied over separately. */
 struct rss_label
 {
diff --git a/include/minix/sched.h b/include/minix/sched.h
index 6134f8a0c..8a32e30a0 100644
--- a/include/minix/sched.h
+++ b/include/minix/sched.h
@@ -5,7 +5,7 @@
 
 _PROTOTYPE(int sched_stop, (endpoint_t scheduler_e, endpoint_t schedulee_e));
 _PROTOTYPE(int sched_start, (endpoint_t scheduler_e, endpoint_t schedulee_e, 
-	endpoint_t parent_e, unsigned maxprio, unsigned quantum,
+	endpoint_t parent_e, int maxprio, int quantum, int cpu,
 	endpoint_t *newscheduler_e));
 _PROTOTYPE(int sched_inherit, (endpoint_t scheduler_e, 
 	endpoint_t schedulee_e, endpoint_t parent_e, unsigned maxprio, 
diff --git a/include/minix/syslib.h b/include/minix/syslib.h
index 36f4a33df..b1a3db189 100644
--- a/include/minix/syslib.h
+++ b/include/minix/syslib.h
@@ -44,9 +44,10 @@ _PROTOTYPE( int sys_clear, (endpoint_t proc_ep));
 _PROTOTYPE( int sys_exit, (void));
 _PROTOTYPE( int sys_trace, (int req, endpoint_t proc_ep, long addr, long *data_p));
 
-_PROTOTYPE( int sys_schedule, (endpoint_t proc_ep, unsigned priority, unsigned quantum));
+_PROTOTYPE( int sys_schedule, (endpoint_t proc_ep, int priority,
+						int quantum, int cpu));
 _PROTOTYPE( int sys_schedctl, (unsigned flags, endpoint_t proc_ep,
-	unsigned priority, unsigned quantum));
+	int priority, int quantum, int cpu));
 
 /* Shorthands for sys_runctl() system call. */
 #define sys_stop(proc_ep) sys_runctl(proc_ep, RC_STOP, 0)
diff --git a/kernel/proto.h b/kernel/proto.h
index 0ac33a28c..aa2d4413d 100644
--- a/kernel/proto.h
+++ b/kernel/proto.h
@@ -84,7 +84,7 @@ _PROTOTYPE( void clear_ipc_refs, (struct proc *rc, int caller_ret)	);
 _PROTOTYPE( phys_bytes umap_bios, (vir_bytes vir_addr, vir_bytes bytes));
 _PROTOTYPE( void kernel_call_resume, (struct proc *p));
 _PROTOTYPE( int sched_proc, (struct proc *rp,
-	unsigned priority, unsigned quantum));
+	int priority, int quantum, int cpu));
 
 /* system/do_newmap.c */
 _PROTOTYPE( int newmap, (struct proc * caller, struct proc *rp,
diff --git a/kernel/system.c b/kernel/system.c
index 3f18a3187..6e02000da 100644
--- a/kernel/system.c
+++ b/kernel/system.c
@@ -638,29 +638,51 @@ PUBLIC void kernel_call_resume(struct proc *caller)
 /*===========================================================================*
  *                               sched_proc                                  *
  *===========================================================================*/
-PUBLIC int sched_proc(struct proc *rp, unsigned priority, unsigned quantum)
+PUBLIC int sched_proc(struct proc *p,
+			int priority,
+			int quantum,
+			int cpu)
 {
-	/* Make sure the priority number given is within the allowed range.*/
-	if (priority < TASK_Q || priority > NR_SCHED_QUEUES)
-		return EINVAL;
+	/* Make sure the values given are within the allowed range.*/
+	if ((priority < TASK_Q && priority != -1) || priority > NR_SCHED_QUEUES)
+		return(EINVAL);
 
-	/* Make sure the quantum given is within the allowed range.*/
-	if(quantum <= 0)
-		return EINVAL;
+	if (quantum < 1 && quantum != -1)
+		return(EINVAL);
+
+	if ((cpu < 0 && cpu != -1) || (cpu > 0 && (unsigned) cpu >= ncpus))
+		return(EINVAL);
 
 	/* In some cases, we might be rescheduling a runnable process. In such
 	 * a case (i.e. if we are updating the priority) we set the NO_QUANTUM
 	 * flag before the generic unset to dequeue/enqueue the process
 	 */
-	if (proc_is_runnable(rp))
-		RTS_SET(rp, RTS_NO_QUANTUM);
 
-	/* Clear the scheduling bit and enqueue the process */
-	rp->p_priority = priority;
-	rp->p_quantum_size_ms = quantum;
-	rp->p_cpu_time_left = ms_2_cpu_time(quantum);
+	/* FIXME this preempts the process, do we really want to do that ?*/
+
+	/* FIXME this is a problem for SMP if the processes currently runs on a
+	 * different CPU */
+	if (proc_is_runnable(p) && p->p_cpu != cpuid &&
+			(cpu != -1 || cpu != p->p_cpu)) {
+		printf("WARNING : changing cpu of a runnable process %d "
+				"on a different cpu!\n", p->p_endpoint);
+		return(EINVAL);
+	}
 
-	RTS_UNSET(rp, RTS_NO_QUANTUM);
+	if (proc_is_runnable(p))
+		RTS_SET(p, RTS_NO_QUANTUM);
+
+	if (priority != -1)
+		p->p_priority = priority;
+	if (quantum != -1) {
+		p->p_quantum_size_ms = quantum;
+		p->p_cpu_time_left = ms_2_cpu_time(quantum);
+	}
+	if (cpu != -1)
+		p->p_cpu = cpu;
+
+	/* Clear the scheduling bit and enqueue the process */
+	RTS_UNSET(p, RTS_NO_QUANTUM);
 
 	return OK;
 }
diff --git a/kernel/system/do_schedctl.c b/kernel/system/do_schedctl.c
index 8a40e1e09..b2e4563a3 100644
--- a/kernel/system/do_schedctl.c
+++ b/kernel/system/do_schedctl.c
@@ -8,7 +8,7 @@ PUBLIC int do_schedctl(struct proc * caller, message * m_ptr)
 {
 	struct proc *p;
 	unsigned flags;
-	unsigned priority, quantum;
+	int priority, quantum, cpu;
 	int proc_nr;
 	int r;
 
@@ -29,11 +29,12 @@ PUBLIC int do_schedctl(struct proc * caller, message * m_ptr)
 		/* the kernel becomes the scheduler and starts 
 		 * scheduling the process.
 		 */
-		priority = (unsigned) m_ptr->SCHEDCTL_PRIORITY;
-		quantum = (unsigned) m_ptr->SCHEDCTL_QUANTUM;
+		priority = (int) m_ptr->SCHEDCTL_PRIORITY;
+		quantum = (int) m_ptr->SCHEDCTL_QUANTUM;
+		cpu = (int) m_ptr->SCHEDCTL_CPU;
 
 		/* Try to schedule the process. */
-		if((r = sched_proc(p, priority, quantum) != OK))
+		if((r = sched_proc(p, priority, quantum, cpu) != OK))
 			return r;
 		p->p_scheduler = NULL;
 	} else {
diff --git a/kernel/system/do_schedule.c b/kernel/system/do_schedule.c
index d4935c755..436f8147d 100644
--- a/kernel/system/do_schedule.c
+++ b/kernel/system/do_schedule.c
@@ -9,7 +9,7 @@ PUBLIC int do_schedule(struct proc * caller, message * m_ptr)
 {
 	struct proc *p;
 	int proc_nr;
-	unsigned priority, quantum;
+	int priority, quantum, cpu;
 
 	if (!isokendpt(m_ptr->SCHEDULING_ENDPOINT, &proc_nr))
 		return EINVAL;
@@ -21,7 +21,9 @@ PUBLIC int do_schedule(struct proc * caller, message * m_ptr)
 		return(EPERM);
 
 	/* Try to schedule the process. */
-	priority = (unsigned) m_ptr->SCHEDULING_PRIORITY;
-	quantum = (unsigned) m_ptr->SCHEDULING_QUANTUM;
-	return sched_proc(p, priority, quantum);
+	priority = (int) m_ptr->SCHEDULING_PRIORITY;
+	quantum = (int) m_ptr->SCHEDULING_QUANTUM;
+	cpu = (int) m_ptr->SCHEDULING_CPU;
+
+	return sched_proc(p, priority, quantum, cpu);
 }
diff --git a/lib/libsys/sched_start.c b/lib/libsys/sched_start.c
index 4a41b013a..0f8f2402d 100644
--- a/lib/libsys/sched_start.c
+++ b/lib/libsys/sched_start.c
@@ -46,9 +46,13 @@ PUBLIC int sched_inherit(endpoint_t scheduler_e,
 /*===========================================================================*
  *				sched_start				     *
  *===========================================================================*/
-PUBLIC int sched_start(endpoint_t scheduler_e, endpoint_t schedulee_e, 
-	endpoint_t parent_e, unsigned maxprio, unsigned quantum,
-	endpoint_t *newscheduler_e)
+PUBLIC int sched_start(endpoint_t scheduler_e,
+			endpoint_t schedulee_e, 
+			endpoint_t parent_e,
+			int maxprio,
+			int quantum,
+			int cpu,
+			endpoint_t *newscheduler_e)
 {
 	int rv;
 	message m;
@@ -68,7 +72,7 @@ PUBLIC int sched_start(endpoint_t scheduler_e, endpoint_t schedulee_e,
 	/* The KERNEL must schedule this process. */
 	if(scheduler_e == KERNEL) {
 		if ((rv = sys_schedctl(SCHEDCTL_FLAG_KERNEL, 
-			schedulee_e, maxprio, quantum)) != OK) {
+			schedulee_e, maxprio, quantum, cpu)) != OK) {
 			return rv;
 		}
 		*newscheduler_e = scheduler_e;
diff --git a/lib/libsys/sys_schedctl.c b/lib/libsys/sys_schedctl.c
index 46ef5f1bb..b7b975e4c 100644
--- a/lib/libsys/sys_schedctl.c
+++ b/lib/libsys/sys_schedctl.c
@@ -1,7 +1,10 @@
 #include "syslib.h"
 
-PUBLIC int sys_schedctl(unsigned flags, endpoint_t proc_ep, unsigned priority,
-	unsigned quantum)
+PUBLIC int sys_schedctl(unsigned flags,
+			endpoint_t proc_ep,
+			int priority,
+			int quantum,
+			int cpu)
 {
 	message m;
 
@@ -9,5 +12,6 @@ PUBLIC int sys_schedctl(unsigned flags, endpoint_t proc_ep, unsigned priority,
 	m.SCHEDCTL_ENDPOINT = proc_ep;
 	m.SCHEDCTL_PRIORITY = priority;
 	m.SCHEDCTL_QUANTUM = quantum;
+	m.SCHEDCTL_CPU = cpu;
 	return(_kernel_call(SYS_SCHEDCTL, &m));
 }
diff --git a/lib/libsys/sys_schedule.c b/lib/libsys/sys_schedule.c
index 94354ed96..f7664c47c 100644
--- a/lib/libsys/sys_schedule.c
+++ b/lib/libsys/sys_schedule.c
@@ -1,11 +1,15 @@
 #include "syslib.h"
 
-PUBLIC int sys_schedule(endpoint_t proc_ep, unsigned priority, unsigned quantum)
+PUBLIC int sys_schedule(endpoint_t proc_ep,
+			int priority,
+			int quantum,
+			int cpu)
 {
 	message m;
 
 	m.SCHEDULING_ENDPOINT = proc_ep;
 	m.SCHEDULING_PRIORITY = priority;
 	m.SCHEDULING_QUANTUM  = quantum;
+	m.SCHEDULING_CPU = cpu;
 	return(_kernel_call(SYS_SCHEDULE, &m));
 }
diff --git a/servers/pm/schedule.c b/servers/pm/schedule.c
index aa0d0bdf8..e94c20eb2 100644
--- a/servers/pm/schedule.c
+++ b/servers/pm/schedule.c
@@ -39,6 +39,7 @@ PUBLIC void sched_init(void)
 				parent_e,		/* parent_e */
 				USER_Q, 		/* maxprio */
 				USER_QUANTUM, 		/* quantum */
+				-1,			/* don't change cpu */
 				&trmp->mp_scheduler);	/* *newsched_e */
 			if (s != OK) {
 				printf("PM: SCHED denied taking over scheduling of %s: %d\n",
diff --git a/servers/rs/glo.h b/servers/rs/glo.h
index d4db45227..4c883ad21 100644
--- a/servers/rs/glo.h
+++ b/servers/rs/glo.h
@@ -50,5 +50,7 @@ EXTERN int shutting_down;
 
 EXTERN unsigned system_hz;
 
+EXTERN struct machine machine;		/* machine info */
+
 #endif /* RS_GLO_H */
 
diff --git a/servers/rs/main.c b/servers/rs/main.c
index a5293e3fa..21bdedf83 100644
--- a/servers/rs/main.c
+++ b/servers/rs/main.c
@@ -33,6 +33,7 @@ FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
 FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
 FORWARD _PROTOTYPE( int sef_cb_signal_manager, (endpoint_t target, int signo) );
 
+
 /*===========================================================================*
  *				main                                         *
  *===========================================================================*/
@@ -46,9 +47,13 @@ PUBLIC int main(void)
   int ipc_status;				/* status code */
   int call_nr, who_e,who_p;			/* call number and caller */
   int result;                 			/* result to return */
+  int s;
 
   /* SEF local startup. */
   sef_local_startup();
+  
+  if (OK != (s=sys_getmachine(&machine)))
+	  panic("couldn't get machine info: %d", s);
 
   /* Main loop - get work and do it, forever. */         
   while (TRUE) {              
diff --git a/servers/rs/manager.c b/servers/rs/manager.c
index 3e778c0ec..4897e8d1a 100644
--- a/servers/rs/manager.c
+++ b/servers/rs/manager.c
@@ -1361,6 +1361,7 @@ endpoint_t source;
       rp->r_scheduler = rs_start->rss_scheduler;
       rp->r_priority = rs_start->rss_priority;
       rp->r_quantum = rs_start->rss_quantum;
+      rp->r_cpu = rs_start->rss_cpu;
   }
 
   /* Update command and arguments. */
diff --git a/servers/rs/request.c b/servers/rs/request.c
index 0282a3510..eccf60ed5 100755
--- a/servers/rs/request.c
+++ b/servers/rs/request.c
@@ -958,6 +958,18 @@ PRIVATE int check_request(struct rs_start *rs_start)
 	return EINVAL;
   }
 
+  if (rs_start->rss_cpu == RS_CPU_BSP)
+	  rs_start->rss_cpu = machine.bsp_id;
+  else if (rs_start->rss_cpu == RS_CPU_DEFAULT) {
+	  /* keep the default value */
+  } else if (rs_start->rss_cpu < 0)
+	  return EINVAL;
+  else if (rs_start->rss_cpu > machine.processors_count) {
+	  printf("RS: cpu number %d out of range 0-%d, using BSP\n",
+			  rs_start->rss_cpu, machine.processors_count);
+	  rs_start->rss_cpu = machine.bsp_id;
+  }
+
   /* Verify signal manager. */
   if (rs_start->rss_sigmgr != SELF && 
 	(rs_start->rss_sigmgr < 0 || 
diff --git a/servers/rs/type.h b/servers/rs/type.h
index b9eee86d0..8deb541e1 100644
--- a/servers/rs/type.h
+++ b/servers/rs/type.h
@@ -62,8 +62,9 @@ struct rproc {
 				 */
   uid_t r_uid;
   endpoint_t r_scheduler;	/* scheduler */
-  unsigned r_priority;
-  unsigned r_quantum;
+  int r_priority;		/* negative values are reserved for special meanings */
+  int r_quantum;
+  int r_cpu;
 
   char r_ipc_list[MAX_IPC_LIST];
   int r_nr_control;
diff --git a/servers/rs/utility.c b/servers/rs/utility.c
index dbbedc214..c32ecbd22 100644
--- a/servers/rs/utility.c
+++ b/servers/rs/utility.c
@@ -205,7 +205,7 @@ PUBLIC int sched_init_proc(struct rproc *rp)
 
   /* Start scheduling for the given process. */
   if ((s = sched_start(rp->r_scheduler, rp->r_pub->endpoint, 
-      RS_PROC_NR, rp->r_priority, rp->r_quantum, 
+      RS_PROC_NR, rp->r_priority, rp->r_quantum, rp->r_cpu,
       &rp->r_scheduler)) != OK) {
       return s;
   }
diff --git a/servers/sched/schedule.c b/servers/sched/schedule.c
index 142cfad32..97e9674f9 100644
--- a/servers/sched/schedule.c
+++ b/servers/sched/schedule.c
@@ -189,7 +189,7 @@ PUBLIC int do_start_scheduling(message *m_ptr)
 
 	/* Take over scheduling the process. The kernel reply message populates
 	 * the processes current priority and its time slice */
-	if ((rv = sys_schedctl(0, rmp->endpoint, 0, 0)) != OK) {
+	if ((rv = sys_schedctl(0, rmp->endpoint, 0, 0, 0)) != OK) {
 		printf("Sched: Error taking over scheduling for %d, kernel said %d\n",
 			rmp->endpoint, rv);
 		return rv;
@@ -268,7 +268,7 @@ PRIVATE int schedule_process(struct schedproc * rmp)
 	pick_cpu(rmp);
 
 	if ((rv = sys_schedule(rmp->endpoint, rmp->priority,
-			rmp->time_slice)) != OK) {
+			rmp->time_slice, rmp->cpu)) != OK) {
 		printf("SCHED: An error occurred when trying to schedule %d: %d\n",
 		rmp->endpoint, rv);
 	}