Merge pull request #419 from ldierksheide/mpk_fwp

Initial Checkpoint

Author: gparmer

composition_scripts/chkpt.toml

@@ -0,0 +1,16 @@
+[system]
+description = "Create and execute a checkpoint for the test_component"
+
+[[components]]
+name = "booter"
+img  = "no_interface.llbooter"
+implements = [{interface = "init"}]
+deps = [{srv = "kernel", interface = "init", variant = "kernel"}]
+constructor = "kernel"
+
+[[components]]
+name = "test_component"
+img  = "tests.chkpt"
+deps = [{srv = "booter", interface = "init"}]
+baseaddr = "0x1600000"
+constructor = "booter"

src/components/implementation/no_interface/llbooter/doc.md

@@ -8,6 +8,8 @@ Creates a set of components as provided by the `composer`.
 Takes a tarball of these components (accessed through `initargs`), and an `initargs` specification of those components to be booted.
 This will FIFO schedule initialization through the components that depend on it for `init`.
 
+First draft of checkpointing, such that a component can create a checkpoint of itself once initialized (in `init_done`). Then a new component can be created and executed from the checkpoint. 
+
 ### Usage and Assumptions
 
 - Strongly assumes that the `composer` is used to provide all necessary metadata to construct the rest of the system.

src/components/implementation/no_interface/llbooter/llbooter.c

@@ -33,14 +33,24 @@
 #ifndef BOOTER_CAPMGR_MB
 #define BOOTER_CAPMGR_MB 64
 #endif
+#ifndef BOOTER_MAX_CHKPT
+#define BOOTER_MAX_CHKPT 64
+#endif
+
+/* UNCOMMENT HERE FOR CHECKPOINT FUNCTIONALITY */
+/* #ifndef ENABLE_CHKPT
+ * #define ENABLE_CHKPT 1
+ * #endif
+ */
 
 static struct crt_comp boot_comps[MAX_NUM_COMPS];
 static const  compid_t sched_root_id  = 2;
 static        long     boot_id_offset = -1;
 
-SS_STATIC_SLAB(sinv, struct crt_sinv, BOOTER_MAX_SINV);
-SS_STATIC_SLAB(thd,  struct crt_thd,  BOOTER_MAX_INITTHD);
-SS_STATIC_SLAB(rcv,  struct crt_rcv,  BOOTER_MAX_SCHED);
+SS_STATIC_SLAB(sinv,   struct crt_sinv,   BOOTER_MAX_SINV);
+SS_STATIC_SLAB(thd,    struct crt_thd,    BOOTER_MAX_INITTHD);
+SS_STATIC_SLAB(rcv,    struct crt_rcv,    BOOTER_MAX_SCHED);
+SS_STATIC_SLAB(chkpt,  struct crt_chkpt,  BOOTER_MAX_CHKPT);
 
 /*
  * Assumptions: the component with the lowest id *must* be the one
@@ -136,7 +146,7 @@ comps_init(void)
 			if (crt_comp_create(comp, name, id, elf_hdr, info)) {
 				printc("Error constructing the resource tables and image of component %s.\n", comp->name);
 				BUG();
-			}
+			}	
 		}
 		assert(comp->refcnt != 0);
 	}
@@ -261,6 +271,8 @@ comps_init(void)
 		struct crt_sinv *sinv;
 		int serv_id = atoi(args_get_from("server", &curr));
 		int cli_id  = atoi(args_get_from("client", &curr));
+		struct crt_comp *serv = boot_comp_get(serv_id);
+		struct crt_comp *cli = boot_comp_get(cli_id);
 
 		sinv = ss_sinv_alloc();
 		assert(sinv);
@@ -270,8 +282,16 @@ comps_init(void)
 		ss_sinv_activate(sinv);
 		printc("\t%s (%lu->%lu):\tclient_fn @ 0x%lx, client_ucap @ 0x%lx, server_fn @ 0x%lx\n",
 		       sinv->name, sinv->client->id, sinv->server->id, sinv->c_fn_addr, sinv->c_ucap_addr, sinv->s_fn_addr);
+	#ifdef ENABLE_CHKPT
+		assert(serv->n_sinvs < CRT_COMP_SINVS_LEN);
+		serv->sinvs[serv->n_sinvs] = *sinv;
+		serv->n_sinvs++;
+		assert(cli->n_sinvs < CRT_COMP_SINVS_LEN);
+		cli->sinvs[cli->n_sinvs] = *sinv;
+		cli->n_sinvs++;
+	#endif /* ENABLE_CHKPT */
 	}
-
+	
 	/*
 	 * Delegate the untyped memory to the capmgr. This should go
 	 * *after* all allocations that use untyped memory, so that we
@@ -299,6 +319,70 @@ comps_init(void)
 	return;
 }
 
+/*
+ * We only support a single checkpoint directly above the existing components.
+ * At this point we assume capability managers and schedulers will not be checkpointed
+ */
+void 
+chkpt_comp_init(struct crt_comp *comp, struct crt_chkpt *chkpt, char *name)
+{
+#ifdef ENABLE_CHKPT
+	/* create the component */
+	void *elf_hdr;
+	int   keylen;
+	compid_t id;
+	const char *root = "binaries/";
+	int   len  = strlen(root);
+	char  path[INITARGS_MAX_PATHNAME];
+	struct crt_comp_exec_context ctxt = { 0 };
+	struct crt_thd *t;
+
+	id = crt_ncomp() + 1;
+	assert(id < MAX_NUM_COMPS && id > 0 && name);
+
+	assert(len < INITARGS_MAX_PATHNAME);
+	memset(path, 0, INITARGS_MAX_PATHNAME);
+	strncat(path, root, len);
+	assert(path[len] == '\0');
+	strncat(path, name, INITARGS_MAX_PATHNAME - len);
+	assert(path[INITARGS_MAX_PATHNAME - 1] == '\0'); /* no truncation allowed */
+
+	if (id == cos_compid()) {
+		/* this should never happen */
+		assert(0);
+	} else {
+		if (crt_comp_create_from(comp, name, id, chkpt)) {
+			printc("Error constructing the resource tables and image of component %s.\n", comp->name);
+			BUG();
+		}
+	}
+	assert(comp->refcnt != 0);
+
+	t = ss_thd_alloc();
+	assert(t);
+
+	if (crt_comp_exec(comp, crt_comp_exec_thd_init(&ctxt, t))) BUG();
+	ss_thd_activate(t);
+	comp->init_state = CRT_COMP_INIT_COS_INIT;
+
+	/* create the sinvs */
+	for (u32_t i = 0 ; i < comp->n_sinvs ; i++) {
+		struct crt_sinv *sinv;
+		int serv_id = comp->sinvs[i].server->id;
+		int cli_id  = comp->sinvs[i].client->id;
+
+		sinv = ss_sinv_alloc();
+		assert(sinv);
+		crt_sinv_create(sinv, comp->sinvs[i].name, comp->sinvs[i].server, comp->sinvs[i].client,
+			comp->sinvs[i].c_fn_addr, comp->sinvs[i].c_ucap_addr, comp->sinvs[i].s_fn_addr);
+		ss_sinv_activate(sinv);
+		printc("\t(chkpt) sinv: %s (%lu->%lu):\tclient_fn @ 0x%lx, client_ucap @ 0x%lx, server_fn @ 0x%lx\n",
+			sinv->name, sinv->client->id, sinv->server->id, sinv->c_fn_addr, sinv->c_ucap_addr, sinv->s_fn_addr);	
+	}
+#endif /* ENABLE_CHKPT */
+
+}
+
 unsigned long
 addr_get(compid_t id, addr_t type)
 {
@@ -344,18 +428,67 @@ execute(void)
 	crt_compinit_execute(boot_comp_get);
 }
 
+void
+init_done_chkpt(struct crt_comp *c)
+{
+	struct crt_comp  *new_comp = boot_comp_get(crt_ncomp() + 1);
+	struct crt_chkpt *chkpt;
+	thdcap_t          thdcap;
+	int               ret;
+	char              name[INITARGS_MAX_PATHNAME];
+	char             *prefix = "chkpt_";
+	int               prefix_sz = strlen("chkpt_");
+
+	if (c->id == cos_compid()) {
+	 	/* don't allow chkpnts of the booter */
+	 	BUG();
+	}
+
+	assert(INITARGS_MAX_PATHNAME > prefix_sz + strlen(c->name));
+	memcpy(name, prefix, prefix_sz + 1);
+	strncat(name, c->name, INITARGS_MAX_PATHNAME - prefix_sz - 1); 
+	c->name[INITARGS_MAX_PATHNAME - 1] = '\0';
+	
+	/* completed all initialization */
+	if (c->init_state >= CRT_COMP_INIT_MAIN) {
+		if (crt_nchkpt() > BOOTER_MAX_CHKPT) {
+			BUG();
+		}
+
+		chkpt = ss_chkpt_alloc();
+		if (crt_chkpt_create(chkpt, c) != 0) {
+			BUG();
+		}
+
+		ss_chkpt_activate(chkpt);
+		chkpt_comp_init(new_comp, chkpt, name);
+		thdcap = crt_comp_thdcap_get(new_comp);
+		assert(thdcap);
+		if ((ret = cos_defswitch(thdcap, TCAP_PRIO_MAX, TCAP_RES_INF, cos_sched_sync()))) {
+			printc("Switch failure on thdcap %ld, with ret %d\n", thdcap, ret);
+			BUG();
+		}
+	}
+
+	return;
+}
+
 void
 init_done(int parallel_init, init_main_t main_type)
 {
 	compid_t client = (compid_t)cos_inv_token();
-	struct crt_comp *c;
+	struct crt_comp    *c;
 
 	assert(client > 0 && client <= MAX_NUM_COMPS);
 	c = boot_comp_get(client);
 
 	crt_compinit_done(c, parallel_init, main_type);
 
+#ifdef ENABLE_CHKPT
+	init_done_chkpt(c);
+#endif /* ENABLE_CHKPT */
 	return;
+
 }
 
 
@@ -371,6 +504,8 @@ init_exit(int retval)
 
 	crt_compinit_exit(c, retval);
 
+	/* TODO: recycle back to a chkpt via chkpt_restore() */
+
 	while (1) ;
 }
 

src/components/implementation/tests/chkpt/Makefile

@@ -0,0 +1,18 @@
+# Required variables used to drive the compilation process. It is OK
+# for many of these to be empty.
+#
+# The set of interfaces that this component exports for use by other
+# components. This is a list of the interface names.
+INTERFACE_EXPORTS = 
+# The interfaces this component is dependent on for compilation (this
+# is a list of directory names in interface/)
+INTERFACE_DEPENDENCIES =
+# The library dependencies this component is reliant on for
+# compilation/linking (this is a list of directory names in lib/)
+LIBRARY_DEPENDENCIES = component
+# Note: Both the interface and library dependencies should be
+# *minimal*. That is to say that removing a dependency should cause
+# the build to fail. The build system does not validate this
+# minimality; that's on you!
+
+include Makefile.subsubdir

src/components/implementation/tests/chkpt/chkpt.c

@@ -0,0 +1,40 @@
+#include <cos_component.h>
+#include <llprint.h>
+#include <cos_types.h>
+
+/* 
+ * USE THE chkpt.toml RUNSCRIPT FOR THIS TEST TO PASS
+ * UNCOMMENT THE #DEFINE ENABLE_CHKPT IN llbooter.c FOR THIS TEST TO PASS
+ * Component IDs are hardcoded: 
+ * we must be creating a checkpoint of component with ID 2
+ * and the component created from the checkpoint must have ID 3
+ */
+static compid_t test_compid = 2;
+static compid_t chkpt_compid = 3;
+
+static u32_t test_var = 2;
+
+void
+cos_init(void)
+{
+	assert(cos_compid() == test_compid);
+	assert(test_var == 2);
+	test_var = 5;
+}
+
+void
+cos_parallel_init(coreid_t cid, int init_core, int ncores)
+{
+	if (init_core) {
+		assert(cos_compid() == test_compid);
+	}
+}
+
+void
+parallel_main(coreid_t cid)
+{
+	assert(cos_compid() == chkpt_compid);
+	assert(test_var == 5);
+
+	printc("Success: Checkpoint created and executed\n");
+}

src/components/implementation/tests/chkpt/doc.md

@@ -0,0 +1,9 @@
+## Chkpt
+
+### Description
+This component is a unit test for the baseline checkpoint functionality. This includes creating a checkpoint from a non-booter component (defined in `chkpt.c` in this case), creating a component from that checkpoint, and running it. The checkpoint copies the memory (we do not yet support the copying for dynamic allocations) and synchronous invocations from the initial component and allows the new component to skip initialization steps.
+
+### Usage and Assumptions
+- Assumes that the `chkpt.toml` runscript is used
+- You must uncomment the `#define ENABLE_CHKPT` in `src/components/implementation/no_interface/llbooter/llbooter.c` for this test to work; checkpoint functionality is disabled by default in the system
+

src/components/lib/component/cos_component.c

@@ -202,6 +202,7 @@ start_execution(coreid_t cid, int init_core, int ncores)
 	const int parallel_init = cos_parallel_init != __crt_cos_parallel_init;
 	int ret = 0;
 	int main_time = 0;
+	static volatile int initialization_completed = 0;
 
 	/* are parallel/regular main user-defined? */
 	if (parallel_main != __crt_parallel_main) {
@@ -212,20 +213,23 @@ start_execution(coreid_t cid, int init_core, int ncores)
 	}
 
 	/* single-core initialization */
-	if (init_core) {
-		cos_init();
-		/* continue only if there is no user-defined main, or parallel exec */
-		COS_EXTERN_INV(init_done)(parallel_init, main_type);
-		assert(parallel_init || main_type != INIT_MAIN_NONE);
-	}
+	if (initialization_completed == 0) {
+		if (init_core) {
+			cos_init();
+			/* continue only if there is no user-defined main, or parallel exec */
+			COS_EXTERN_INV(init_done)(parallel_init, main_type);
+			assert(parallel_init || main_type != INIT_MAIN_NONE);
+		}
 
-	/* Parallel initialization */
-	COS_EXTERN_INV(init_parallel_await_init)();
-	if (parallel_init) {
-		cos_parallel_init(cid, init_core, init_parallelism());
+		/* Parallel initialization */
+		COS_EXTERN_INV(init_parallel_await_init)();
+		if (parallel_init) {
+			cos_parallel_init(cid, init_core, init_parallelism());
+		}
+		/* All initialization completed here, go onto main execution */
+		initialization_completed = 1;
+		COS_EXTERN_INV(init_done)(0, main_type);
 	}
-	/* All initialization completed here, go onto main execution */
-	COS_EXTERN_INV(init_done)(0, main_type);
 	/* No main? we shouldn't have continued here... */
 	assert(main_type != INIT_MAIN_NONE);
 	assert(main_type == INIT_MAIN_PARALLEL || (main_type == INIT_MAIN_SINGLE && init_core));
@@ -299,6 +303,7 @@ cos_upcall_fn(upcall_type_t t, void *arg1, void *arg2, void *arg3)
 			static unsigned long first_core = 1;
 
 			start_execution(cos_coreid(), ps_cas(&first_core, 1, 0), init_parallelism());
+
 		} else {
 			u32_t idx = (int)arg1 - 1;
 			if (idx >= COS_THD_INIT_REGION_SIZE) {