service: Extensions for new RS.

Change-Id: Ifb72c7e8c912709edce0fb9ba9efb570901be5fb

minix/commands/service/service.c

@@ -23,6 +23,7 @@
 #include <minix/ipc.h>
 #include <minix/rs.h>
 #include <minix/syslib.h>
+#include <minix/sysinfo.h>
 #include <minix/bitmap.h>
 #include <minix/paths.h>
 #include <minix/sef.h>
@@ -47,9 +48,24 @@ static char *known_requests[] = {
   "shutdown", 
   "update",
   "clone",
+  "unclone",
   "edit",
+  "sysctl",
   "catch for illegal requests"
 };
+static int known_request_types[] = {
+  RS_UP,
+  RS_DOWN,
+  RS_REFRESH, 
+  RS_RESTART,
+  RS_SHUTDOWN, 
+  RS_UPDATE,
+  RS_CLONE,
+  RS_UNCLONE,
+  RS_EDIT,
+  RS_SYSCTL,
+  0
+};
 #define ILLEGAL_REQUEST  sizeof(known_requests)/sizeof(char *)
 
 /* Global error number set for failed system calls. */
@@ -68,6 +84,19 @@ static char *known_requests[] = {
 #define OPT_REUSE	"-r"		/* reuse executable image */
 #define OPT_NOBLOCK	"-n"		/* unblock caller immediately */
 #define OPT_REPLICA	"-p"		/* create replica for the service */
+#define OPT_BATCH	"-b"		/* batch mode */
+#define OPT_ASR_LU	"-a"		/* asr update */
+#define OPT_PREPARE_ONLY_LU    "-o"	/* prepare-only update */
+#define OPT_FORCE_SELF_LU      "-s"	/* force self update */
+#define OPT_FORCE_INIT_CRASH   "-x"	/* force init crash (for debugging) */
+#define OPT_FORCE_INIT_FAIL    "-y"	/* force init failure (for debugging) */
+#define OPT_FORCE_INIT_TIMEOUT "-z"	/* force init timeout (for debugging) */
+#define OPT_FORCE_INIT_DEFCB   "-d"	/* force init default callback */
+#define OPT_UNSAFE_LU          "-u"     /* allow unsafe update */
+#define OPT_NOMMAP_LU          "-m"     /* don't inherit mmaped regions */
+#define OPT_DETACH             "-e"     /* detach on update/restart */
+#define OPT_NORESTART          "-f"     /* don't restart */
+#define OPT_FORCE_INIT_ST      "-t"	/* force init state transfer */
 
 /* Define names for arguments provided to this utility. The first few 
  * arguments are required and have a known index. Thereafter, some optional
@@ -79,6 +108,8 @@ static char *known_requests[] = {
 #define ARG_REQUEST	0		/* request to perform */
 #define ARG_PATH	1		/* system service */
 #define ARG_LABEL	1		/* name of system service */
+#define ARG_SYSCTL_TYPE	1		/* sysctl action type */
+
 
 #define MIN_ARG_COUNT	1		/* require an action */
 
@@ -98,6 +129,11 @@ static char *known_requests[] = {
 #define ARG_LU_MAXTIME	"-maxtime"      /* max time to prepare for the update */
 #define ARG_DEVMANID	"-devid"    /* the id of the devman device this
                                        driver should be able to access  */
+#define ARG_HEAP_PREALLOC "-heap-prealloc" /* preallocate heap regions */
+#define ARG_MAP_PREALLOC  "-map-prealloc"  /* preallocate mmapped regions */
+#define ARG_TRG_LABELNAME "-trg-label"	/* target label name */
+#define ARG_LU_IPC_BL	"-ipc_bl"       /* IPC blacklist filter */
+#define ARG_LU_IPC_WL	"-ipc_wl"       /* IPC whitelist filter */
 
 /* The function parse_arguments() verifies and parses the command line 
  * parameters passed to this utility. Request parameters that are needed
@@ -106,6 +142,7 @@ static char *known_requests[] = {
 static int req_type;
 static int do_run= 0;		/* 'run' command instead of 'up' */
 static char *req_label = NULL;
+static char *req_trg_label = NULL;
 static char *req_path = NULL;
 static char *req_path_self = SELF_REQ_PATH;
 static char *req_args = "";
@@ -117,6 +154,12 @@ static char *req_config = PATH_CONFIG;
 static int custom_config_file = 0;
 static int req_lu_state = DEFAULT_LU_STATE;
 static int req_lu_maxtime = DEFAULT_LU_MAXTIME;
+static long req_heap_prealloc = 0;
+static long req_map_prealloc = 0;
+static int req_sysctl_type = 0;
+static struct rs_ipc_filter_el rs_ipc_filter_els[RS_MAX_IPC_FILTERS][IPCF_MAX_ELEMENTS];
+static int num_ipc_filters = 0;
+static char *req_state_eval = NULL;
 
 /* Buffer to build "/command arg1 arg2 ..." string to pass to RS server. */
 static char command[4096];	
@@ -128,15 +171,41 @@ static void print_usage(char *app_name, char *problem)
   fprintf(stderr, "Warning, %s\n", problem);
   fprintf(stderr, "Usage:\n");
   fprintf(stderr,
-  "    %s [%s %s %s %s] (up|run|edit|update) <binary|%s> [%s <args>] [%s <special>] [%s <major_nr>] [%s <dev_id>] [%s <ticks>] [%s <path>] [%s <name>] [%s <path>] [%s <state>] [%s <time>]\n", 
+      "    %s [%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s] (up|run|edit|update) <binary|%s> [%s <args>] [%s <special>] [%s <major_nr>] [%s <dev_id>] [%s <ticks>] [%s <path>] [%s <name>] [%s <path>] [%s <state value|eval_expression>] [%s <time>] [%s <bytes>] [%s <bytes>] [%s <name>] [(%s|%s <src_label1,src_type1:src_label2,:,src_type3:...>)*]\n", 
-	app_name, OPT_COPY, OPT_REUSE, OPT_NOBLOCK, OPT_REPLICA, SELF_BINARY,
+	app_name, OPT_COPY, OPT_REUSE, OPT_NOBLOCK, OPT_REPLICA, 
-	ARG_ARGS, ARG_DEV, ARG_MAJOR, ARG_DEVMANID, ARG_PERIOD, ARG_SCRIPT,
+	OPT_BATCH, OPT_ASR_LU, OPT_PREPARE_ONLY_LU, OPT_FORCE_SELF_LU,
-	ARG_LABELNAME, ARG_CONFIG, ARG_LU_STATE, ARG_LU_MAXTIME);
+	OPT_FORCE_INIT_CRASH, OPT_FORCE_INIT_FAIL, OPT_FORCE_INIT_TIMEOUT,
+	OPT_FORCE_INIT_DEFCB, OPT_UNSAFE_LU, OPT_NOMMAP_LU, OPT_DETACH,
+	OPT_NORESTART, OPT_FORCE_INIT_ST, SELF_BINARY,
+	ARG_ARGS, ARG_DEV, ARG_MAJOR, ARG_DEVMANID, ARG_PERIOD,
+	ARG_SCRIPT, ARG_LABELNAME, ARG_CONFIG, ARG_LU_STATE, ARG_LU_MAXTIME,
+	ARG_HEAP_PREALLOC, ARG_MAP_PREALLOC, ARG_TRG_LABELNAME, ARG_LU_IPC_BL, ARG_LU_IPC_WL);
   fprintf(stderr, "    %s down <label>\n", app_name);
   fprintf(stderr, "    %s refresh <label>\n", app_name);
   fprintf(stderr, "    %s restart <label>\n", app_name);
   fprintf(stderr, "    %s clone <label>\n", app_name);
+  fprintf(stderr, "    %s unclone <label>\n", app_name);
+  fprintf(stderr, "    %s sysctl <srv_status|upd_start|upd_run|upd_stop|upd_status>\n", app_name);
   fprintf(stderr, "    %s shutdown\n", app_name);
+  fprintf(stderr, "    Options:\n");
+  fprintf(stderr, "      %s: copy executable image             \n", OPT_COPY);
+  fprintf(stderr, "      %s: reuse executable image            \n", OPT_REUSE);
+  fprintf(stderr, "      %s: unblock caller immediately        \n", OPT_NOBLOCK);
+  fprintf(stderr, "      %s: create replica for the service    \n", OPT_REPLICA);
+  fprintf(stderr, "      %s: batch mode                        \n", OPT_BATCH);
+  fprintf(stderr, "      %s: asr update                        \n", OPT_ASR_LU);
+  fprintf(stderr, "      %s: prepare-only update               \n", OPT_PREPARE_ONLY_LU);
+  fprintf(stderr, "      %s: force self update                 \n", OPT_FORCE_SELF_LU);
+  fprintf(stderr, "      %s: force init crash (for debugging)  \n", OPT_FORCE_INIT_CRASH);
+  fprintf(stderr, "      %s: force init failure (for debugging)\n", OPT_FORCE_INIT_FAIL);
+  fprintf(stderr, "      %s: force init timeout (for debugging)\n", OPT_FORCE_INIT_TIMEOUT);
+  fprintf(stderr, "      %s: force init default callback       \n", OPT_FORCE_INIT_DEFCB);
+  fprintf(stderr, "      %s: allow unsafe update               \n", OPT_UNSAFE_LU);
+  fprintf(stderr, "      %s: don't inherit mmaped regions      \n", OPT_NOMMAP_LU);
+  fprintf(stderr, "      %s: detach on update/restart          \n", OPT_DETACH);
+  fprintf(stderr, "      %s: don't restart                     \n", OPT_NORESTART);
+  fprintf(stderr, "      %s: force init state transfer         \n", OPT_FORCE_INIT_ST);
+
   fprintf(stderr, "\n");
 }
 
@@ -148,6 +217,65 @@ static void failure(int request)
   exit(errno);
 }
 
+static int parse_ipc_filter(char* str, int type_flag)
+{
+  char *el_str, *label_str, *type_str;
+  char el_strings[IPCF_MAX_ELEMENTS][RS_MAX_IPCF_STR_LEN];
+  int i, num_els, label_len, type_len;
+  struct rs_ipc_filter_el *ipcf_el;
+  if(num_ipc_filters+1 > RS_MAX_IPC_FILTERS) {
+	return E2BIG;
+  }
+  el_str = (char*) strsep(&str,":");
+  num_els = 0;
+  while (el_str != NULL)
+  {
+	if(num_els >= IPCF_MAX_ELEMENTS) {
+		return E2BIG;
+	}
+	if(strlen(el_str)>=RS_MAX_IPCF_STR_LEN) {
+		return ENOMEM;
+	}
+	strcpy(el_strings[num_els], el_str);
+	el_str = (char*) strsep(&str, ":");
+	num_els++;
+  }
+  memset(rs_ipc_filter_els[num_ipc_filters],0,IPCF_MAX_ELEMENTS);
+  for(i=0;i<num_els;i++) {
+	el_str = el_strings[i];
+	ipcf_el = &rs_ipc_filter_els[num_ipc_filters][i];
+	label_str = (char*) strsep(&el_str,",");
+	type_str = (char*) strsep(&el_str,",");
+	if(!label_str || !type_str || strsep(&el_str,",")) {
+		return EINVAL;
+	}
+	label_len = strlen(label_str);
+	type_len = strlen(type_str);
+	ipcf_el->flags = 0;
+	if(label_len>0) {
+		if(label_len >= RS_MAX_LABEL_LEN) {
+			return ENOMEM;
+		}
+		strcpy(ipcf_el->m_label, label_str);
+		ipcf_el->flags |= IPCF_MATCH_M_SOURCE;
+	}
+	if(type_len>0) {
+	        char *buff;
+		errno=0;
+		ipcf_el->m_type = strtol(type_str, &buff, 10);
+		if(errno || strcmp(buff, "")) {
+			return EINVAL;
+		}
+		ipcf_el->flags |= IPCF_MATCH_M_TYPE;
+	}
+	if(ipcf_el->flags == 0) {
+		return EINVAL;
+	}
+	ipcf_el->flags |= type_flag;
+  }
+  num_ipc_filters++;
+  return OK;
+}
 
 /* Parse and verify correctness of arguments. Report problem and exit if an 
  * error is found. Store needed parameters in global variables.
@@ -157,8 +285,11 @@ static int parse_arguments(int argc, char **argv, u32_t *rss_flags)
   struct stat stat_buf;
   char *hz, *buff;
   int req_nr;
-  int c, i, j;
+  int c, i, j, r;
-  int b_flag, c_flag, r_flag, n_flag, p_flag;
+  int b_flag, c_flag, r_flag, n_flag, p_flag, q_flag,
+      a_flag, o_flag, s_flag, x_flag, y_flag,
+      z_flag, d_flag, u_flag, m_flag, e_flag,
+      f_flag, t_flag;
   int label_required;
 
   b_flag = 0;
@@ -166,7 +297,20 @@ static int parse_arguments(int argc, char **argv, u32_t *rss_flags)
   r_flag = 0;
   n_flag = 0;
   p_flag = 0;
-  while (c= getopt(argc, argv, "rbcnp?"), c != -1)
+  q_flag = 0;
+  a_flag = 0;
+  o_flag = 0;
+  s_flag = 0;
+  x_flag = 0;
+  y_flag = 0;
+  z_flag = 0;
+  d_flag = 0;
+  u_flag = 0;
+  m_flag = 0;
+  e_flag = 0;
+  f_flag = 0;
+  t_flag = 0;
+  while (c= getopt(argc, argv, "rbcnpqaosxyzdumeft?"), c != -1)
   {
 	switch(c)
 	{
@@ -189,6 +333,45 @@ static int parse_arguments(int argc, char **argv, u32_t *rss_flags)
 	case 'p':
 		p_flag = 1;
 		break;
+	case 'q':
+		q_flag = 1;
+		break;
+	case 'a':
+		a_flag = 1;
+		break;
+	case 'o':
+		o_flag = 1;
+		break;
+	case 's':
+		s_flag = 1;
+		break;
+	case 'x':
+		x_flag = 1;
+		break;
+	case 'y':
+		y_flag = 1;
+		break;
+	case 'z':
+		z_flag = 1;
+		break;
+	case 'd':
+		d_flag = 1;
+		break;
+	case 'u':
+		u_flag = 1;
+		break;
+	case 'm':
+		m_flag = 1;
+		break;
+	case 'e':
+		e_flag = 1;
+		break;
+	case 'f':
+		f_flag = 1;
+		break;
+	case 't':
+		t_flag = 1;
+		break;
 	default:
 		fprintf(stderr, "%s: getopt failed: %c\n",
 			argv[ARG_NAME], c);
@@ -218,7 +401,7 @@ static int parse_arguments(int argc, char **argv, u32_t *rss_flags)
 	    print_usage(argv[ARG_NAME], "illegal request type");
 	    exit(ENOSYS);
 	}
-	req_nr = RS_RQ_BASE + req_type;
+	req_nr = known_request_types[req_type];
   }
 
   *rss_flags = 0;
@@ -240,6 +423,56 @@ static int parse_arguments(int argc, char **argv, u32_t *rss_flags)
       if(b_flag)
 	*rss_flags |= RSS_NO_BIN_EXP;
 
+      if(q_flag)
+          *rss_flags |= RSS_BATCH;
+
+      if(a_flag)
+          *rss_flags |= RSS_ASR_LU;
+
+      if(s_flag)
+          *rss_flags |= RSS_FORCE_SELF_LU;
+
+      if(o_flag)
+          *rss_flags |= RSS_PREPARE_ONLY_LU;
+
+      if(x_flag)
+          *rss_flags |= RSS_FORCE_INIT_CRASH;
+
+      if(y_flag)
+          *rss_flags |= RSS_FORCE_INIT_FAIL;
+
+      if(z_flag)
+          *rss_flags |= RSS_FORCE_INIT_TIMEOUT;
+
+      if(d_flag)
+          *rss_flags |= RSS_FORCE_INIT_DEFCB;
+
+      if(u_flag)
+          *rss_flags |= RSS_UNSAFE_LU;
+
+      if(m_flag)
+          *rss_flags |= RSS_NOMMAP_LU;
+
+      if(e_flag)
+          *rss_flags |= RSS_DETACH;
+
+      if(f_flag)
+          *rss_flags |= RSS_NORESTART;
+
+      if(t_flag)
+          *rss_flags |= RSS_FORCE_INIT_ST;
+
+      /* Verify argument count. */ 
+      if (argc - 1 < optind+ARG_PATH) {
+          print_usage(argv[ARG_NAME], "action requires a binary to start");
+          exit(EINVAL);
+      }
+
+      if(req_nr != RS_UPDATE && q_flag) {
+	    print_usage(argv[ARG_NAME], "action does not support batch mode");
+	    exit(EINVAL);
+      }
+
       req_path = argv[optind+ARG_PATH];
       if(req_nr == RS_UPDATE && !strcmp(req_path, SELF_BINARY)) {
           /* Self update needs no real path or configuration file. */
@@ -254,12 +487,6 @@ static int parse_arguments(int argc, char **argv, u32_t *rss_flags)
         req_script = RUN_SCRIPT;
       }
 
-      /* Verify argument count. */ 
-      if (argc - 1 < optind+ARG_PATH) {
-          print_usage(argv[ARG_NAME], "action requires a binary to start");
-          exit(EINVAL);
-      }
-
       /* Verify the name of the binary of the system service. */
       if(!(*rss_flags & RSS_SELF_LU)) {
           if (req_path[0] != '/') {
@@ -330,6 +557,9 @@ static int parse_arguments(int argc, char **argv, u32_t *rss_flags)
           else if (strcmp(argv[i], ARG_LABELNAME)==0) {
               req_label = argv[i+1];
           }
+          else if (strcmp(argv[i], ARG_TRG_LABELNAME)==0) {
+              req_trg_label = argv[i+1];
+          }
           else if (strcmp(argv[i], ARG_CONFIG)==0) {
               req_config = argv[i+1];
  	      custom_config_file = 1;
@@ -338,10 +568,11 @@ static int parse_arguments(int argc, char **argv, u32_t *rss_flags)
               errno=0;
               req_lu_state = strtol(argv[i+1], &buff, 10);
               if(errno || strcmp(buff, "")) {
-                  print_usage(argv[ARG_NAME], "bad live update state");
+                  /* State is not a number, assume it's an eval expression. */
-                  exit(EINVAL);
+                  req_lu_state = SEF_LU_STATE_EVAL;
+                  req_state_eval = argv[i+1];
               }
-              if(req_lu_state == SEF_LU_STATE_NULL) {
+              else if(req_lu_state == SEF_LU_STATE_NULL) {
                   print_usage(argv[ARG_NAME], "null live update state");
                   exit(EINVAL);
               }
@@ -355,21 +586,55 @@ static int parse_arguments(int argc, char **argv, u32_t *rss_flags)
                       "bad live update max time");
                   exit(EINVAL);
               }
-              if (strcmp(hz,"HZ")==0) req_lu_maxtime *= system_hz;
+              if(req_lu_maxtime == 0) {
-          } else if (strcmp(argv[i], ARG_DEVMANID) == 0) {
+                  /* no timeout requested. */
-			 if (i+1 < argc) { 
+                  req_lu_maxtime = -1;
-				 devman_id = atoi(argv[i+1]);
+              }
-			 } else {
+              else if (strcmp(hz,"HZ")==0) req_lu_maxtime *= system_hz;
-				 exit(EINVAL);
+          }
-			 }
+          else if (strcmp(argv[i], ARG_DEVMANID) == 0) {
-		  } else {
+              if (i+1 < argc) {
+                  devman_id = atoi(argv[i+1]);
+              } else {
+                  exit(EINVAL);
+              }
+          }
+          else if (strcmp(argv[i], ARG_HEAP_PREALLOC)==0) {
+              errno=0;
+              req_heap_prealloc = strtol(argv[i+1], &buff, 10);
+              if(errno || strcmp(buff, "") || req_heap_prealloc <= 0) {
+                  print_usage(argv[ARG_NAME], "bad heap prealloc bytes");
+                  exit(EINVAL);
+              }
+          }
+          else if (strcmp(argv[i], ARG_MAP_PREALLOC)==0) {
+              errno=0;
+              req_map_prealloc = strtol(argv[i+1], &buff, 10);
+              if(errno || strcmp(buff, "") || req_map_prealloc <= 0) {
+                  print_usage(argv[ARG_NAME], "bad heap prealloc bytes");
+                  exit(EINVAL);
+              }
+          }
+          else if (strcmp(argv[i], ARG_LU_IPC_BL)==0) {
+              if((r=parse_ipc_filter(argv[i+1], IPCF_EL_BLACKLIST)) != OK) {
+                  print_usage(argv[ARG_NAME], "bad IPC blacklist filter");
+                  exit(r);
+              }
+          }
+          else if (strcmp(argv[i], ARG_LU_IPC_WL)==0) {
+              if((r=parse_ipc_filter(argv[i+1], IPCF_EL_WHITELIST)) != OK) {
+                  print_usage(argv[ARG_NAME], "bad IPC whitelist filter");
+                  exit(r);
+              }
+          }
+          else {
               print_usage(argv[ARG_NAME], "unknown optional argument given");
               exit(EINVAL);
           }
       }
   }
   else if (req_nr == RS_DOWN || req_nr == RS_REFRESH || req_nr == RS_RESTART
-      || req_nr == RS_CLONE) {
+      || req_nr == RS_CLONE || req_nr == RS_UNCLONE) {
 
       /* Verify argument count. */ 
       if (argc - 1 < optind+ARG_LABEL) {
@@ -377,9 +642,34 @@ static int parse_arguments(int argc, char **argv, u32_t *rss_flags)
           exit(EINVAL);
       }
       req_label= argv[optind+ARG_LABEL];
-  } 
+  }
+  else if (req_nr == RS_SYSCTL) {
+      char* sysctl_types[] = { "srv_status", "upd_start", "upd_run", "upd_stop",
+          "upd_status", NULL };
+      char* sysctl_type;
+      int sysctl_type_values[] = { RS_SYSCTL_SRV_STATUS, RS_SYSCTL_UPD_START,
+          RS_SYSCTL_UPD_RUN, RS_SYSCTL_UPD_STOP, RS_SYSCTL_UPD_STATUS };
+
+      /* Verify argument count. */ 
+      if (argc - 1 < optind+ARG_SYSCTL_TYPE) {
+          print_usage(argv[ARG_NAME], "sysctl requires an action type");
+          exit(EINVAL);
+      }
+
+      sysctl_type = argv[optind+ARG_SYSCTL_TYPE];
+      for(i=0;sysctl_types[i]!=NULL;i++) {
+          if(!strcmp(sysctl_types[i], sysctl_type)) {
+              break;
+          }
+      }
+      if(sysctl_types[i] == NULL) {
+          print_usage(argv[ARG_NAME], "bad sysctl type");
+          exit(EINVAL);
+      }
+      req_sysctl_type = sysctl_type_values[i];
+  }
   else if (req_nr == RS_SHUTDOWN) {
-        /* no extra arguments required */
+      /* no extra arguments required */
   }
 
   label_required = (*rss_flags & RSS_SELF_LU) || (req_nr == RS_EDIT);
@@ -445,6 +735,8 @@ int main(int argc, char **argv)
       config.rs_start.rss_period= req_period;
       config.rs_start.rss_script= req_script;
       config.rs_start.devman_id= devman_id;
+      config.rs_start.rss_heap_prealloc_bytes= req_heap_prealloc;
+      config.rs_start.rss_map_prealloc_bytes= req_map_prealloc;
       config.rs_start.rss_flags |= rss_flags;
       if(req_label) {
         config.rs_start.rss_label.l_addr = req_label;
@@ -453,6 +745,13 @@ int main(int argc, char **argv)
         config.rs_start.rss_label.l_addr = progname;
         config.rs_start.rss_label.l_len = strlen(progname);
       }
+      if(req_trg_label) {
+        config.rs_start.rss_trg_label.l_addr = req_trg_label;
+        config.rs_start.rss_trg_label.l_len = strlen(req_trg_label);
+      } else {
+        config.rs_start.rss_trg_label.l_addr = 0;
+        config.rs_start.rss_trg_label.l_len = 0;
+      }
       if (req_script)
 	      config.rs_start.rss_scriptlen= strlen(req_script);
       else
@@ -461,15 +760,40 @@ int main(int argc, char **argv)
       assert(config.rs_start.rss_priority < NR_SCHED_QUEUES);
       assert(config.rs_start.rss_quantum > 0);
 
+      /* State-related data. */
+      config.rs_start.rss_state_data.size =
+        sizeof(config.rs_start.rss_state_data);
+      if(num_ipc_filters > 0) {
+        config.rs_start.rss_state_data.ipcf_els = rs_ipc_filter_els;
+        config.rs_start.rss_state_data.ipcf_els_size =
+          num_ipc_filters*sizeof(rs_ipc_filter_els[0]);
+      }
+      else {
+        config.rs_start.rss_state_data.ipcf_els = NULL;
+        config.rs_start.rss_state_data.ipcf_els_size = 0;
+      }
+      if(req_state_eval) {
+        config.rs_start.rss_state_data.eval_addr = req_state_eval;
+        config.rs_start.rss_state_data.eval_len = strlen(req_state_eval);
+      }
+      else {
+        config.rs_start.rss_state_data.eval_addr = NULL;
+        config.rs_start.rss_state_data.eval_len = 0;
+      }
+
       m.m_rs_req.addr = (char *) &config.rs_start;
       break;
   case RS_DOWN:
   case RS_REFRESH:
   case RS_RESTART:
   case RS_CLONE:
+  case RS_UNCLONE:
       m.m_rs_req.addr = req_label;
       m.m_rs_req.len = strlen(req_label);
       break;
+  case RS_SYSCTL:
+      m.m_rs_req.subtype = req_sysctl_type;
+      break;
   case RS_SHUTDOWN:
       break;
   default:

minix/include/minix/com.h

@@ -465,7 +465,7 @@
 #define RS_SHUTDOWN	(RS_RQ_BASE + 4)	/* alert about shutdown */
 #define RS_UPDATE	(RS_RQ_BASE + 5)	/* update system service */
 #define RS_CLONE	(RS_RQ_BASE + 6)	/* clone system service */
-#define RS_UNCLONE	(RS_RQ_BASE + 22)	/* unclone system service */
+#define RS_UNCLONE	(RS_RQ_BASE + 7)	/* unclone system service */
 
 #define RS_LOOKUP	(RS_RQ_BASE + 8)	/* lookup server name */
 
@@ -473,7 +473,7 @@
 
 #define RS_INIT 	(RS_RQ_BASE + 20)	/* service init message */
 #define RS_LU_PREPARE	(RS_RQ_BASE + 21)	/* prepare to update message */
-#define RS_EDIT		(RS_RQ_BASE + 7)	/* edit system service */
+#define RS_EDIT		(RS_RQ_BASE + 22)	/* edit system service */
 #define RS_SYSCTL	(RS_RQ_BASE + 23)	/* perform system ctl action */
 
 /* Subfunctions for RS_SYSCTL. */