#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>
"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. */
#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
#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 */
#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
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 = "";
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];
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",
- app_name, OPT_COPY, OPT_REUSE, OPT_NOBLOCK, OPT_REPLICA, SELF_BINARY,
- ARG_ARGS, ARG_DEV, ARG_MAJOR, ARG_DEVMANID, ARG_PERIOD, ARG_SCRIPT,
- ARG_LABELNAME, ARG_CONFIG, ARG_LU_STATE, ARG_LU_MAXTIME);
+ " %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,
+ OPT_BATCH, OPT_ASR_LU, OPT_PREPARE_ONLY_LU, OPT_FORCE_SELF_LU,
+ 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");
}
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.
struct stat stat_buf;
char *hz, *buff;
int req_nr;
- int c, i, j;
- int b_flag, c_flag, r_flag, n_flag, p_flag;
+ int c, i, j, r;
+ 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;
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)
{
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);
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;
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. */
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] != '/') {
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;
errno=0;
req_lu_state = strtol(argv[i+1], &buff, 10);
if(errno || strcmp(buff, "")) {
- print_usage(argv[ARG_NAME], "bad live update state");
- exit(EINVAL);
+ /* State is not a number, assume it's an eval expression. */
+ 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);
}
"bad live update max time");
exit(EINVAL);
}
- if (strcmp(hz,"HZ")==0) req_lu_maxtime *= system_hz;
- } else if (strcmp(argv[i], ARG_DEVMANID) == 0) {
- if (i+1 < argc) {
- devman_id = atoi(argv[i+1]);
- } else {
- exit(EINVAL);
- }
- } else {
+ if(req_lu_maxtime == 0) {
+ /* no timeout requested. */
+ req_lu_maxtime = -1;
+ }
+ else if (strcmp(hz,"HZ")==0) req_lu_maxtime *= system_hz;
+ }
+ else if (strcmp(argv[i], ARG_DEVMANID) == 0) {
+ 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) {
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);
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;
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
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: