libbarrelfish: started merging proc_mgmt_client and spawn_client
authorRoni Häcki <roni.haecki@inf.ethz.ch>
Thu, 5 Oct 2017 14:25:22 +0000 (16:25 +0200)
committerRoni Häcki <roni.haecki@inf.ethz.ch>
Thu, 5 Oct 2017 14:25:22 +0000 (16:25 +0200)
The arugments for spawn_* calls change from domainid_t to
a cap to do any kind of referencing a process.

Signed-off-by: Roni Häcki <roni.haecki@inf.ethz.ch>

include/barrelfish/spawn_client.h
lib/barrelfish/spawn_client.c
lib/bomp/backends/xomp_master.c
lib/posixcompat/wait.c
usr/fish/fish_common.c
usr/kaluga/boot_modules.c
usr/kaluga/boot_modules.h
usr/startd/spawn.c
usr/tests/net-test/net-test.c
usr/tests/proc_mgmt_test/main.c
usr/tests/testdesc/testdesc.c

index 4a7e4db..073b9dc 100644 (file)
@@ -30,29 +30,29 @@ errval_t spawn_program_with_caps(coreid_t coreid, const char *path,
                                  char *const argv[], char *const envp[],
                                  struct capref inheritcn_cap,
                                  struct capref argcn_cap, spawn_flags_t flags,
-                                 domainid_t *ret_domainid);
+                                 struct capref *ret_domain_cap);
 errval_t spawn_arrakis_program(coreid_t coreid, const char *path,
                                  char *const argv[], char *const envp[],
                                  struct capref inheritcn_cap,
                                  struct capref argcn_cap, spawn_flags_t flags,
-                                 domainid_t *ret_domainid);
+                                 domainid_t* domainid);
 errval_t spawn_program(coreid_t coreid, const char *path,
                        char *const argv[], char *const envp[],
-                       spawn_flags_t flags, domainid_t *ret_domainid);
+                       spawn_flags_t flags, struct capref *ret_domain_cap);
 errval_t spawn_program_on_all_cores(bool same_core, const char *path,
                                     char *const argv[], char *const envp[],
-                                    spawn_flags_t flags, domainid_t *ret_domainid,
+                                    spawn_flags_t flags, struct capref *ret_domain_cap,
                                     coreid_t* spawn_count);
-errval_t spawn_kill(domainid_t domainid);
+errval_t spawn_kill(struct capref domain_cap);
 errval_t spawn_exit(uint8_t exitcode);
-errval_t spawn_wait_coreid(coreid_t coreid, domainid_t domainid, uint8_t *exitcode, bool nohang);
-errval_t spawn_wait(domainid_t domainid, uint8_t *exitcode, bool nohang);
-errval_t spawn_wait_core(coreid_t coreid, domainid_t domainid,
+errval_t spawn_wait_coreid(coreid_t coreid, struct capref domain_cap, uint8_t *exitcode, bool nohang);
+errval_t spawn_wait(struct capref domain_cap, uint8_t *exitcode, bool nohang);
+errval_t spawn_wait_core(coreid_t coreid, struct capref domainid,
                          uint8_t *exitcode, bool nohang);
 errval_t spawn_binding(coreid_t coreid, struct spawn_binding **ret_client);
 errval_t spawn_bind_iref(iref_t iref, struct spawn_binding **ret_client);
 errval_t spawn_get_domain_list(uint8_t **domains, size_t *len);
-errval_t spawn_get_status(uint8_t domain, struct spawn_ps_entry *pse,
+errval_t spawn_get_status(uint8_t domainid, struct spawn_ps_entry *pse,
                           char **argbuf, size_t *arglen, errval_t *reterr);
 
 errval_t alloc_inheritcn_with_caps(struct capref *inheritcn_capp,
@@ -60,7 +60,9 @@ errval_t alloc_inheritcn_with_caps(struct capref *inheritcn_capp,
                                    struct capref sidcap,
                                    struct capref kernelcap);
 
-errval_t spawn_dump_capabilities(domainid_t domainid);
+// definitions for compatibility reasons (_poxsixcompat and unimplemented in proc_mgmt)
+errval_t spawn_wait_compat(uint8_t domaind, uint8_t *exitcode, bool nohang);
+errval_t spawn_dump_capabilities_compat(domainid_t domainid);
 __END_DECLS
 
 #endif // BARRELFISH_SPAWN_CLIENT_H
index bb439c7..91c62af 100644 (file)
@@ -20,6 +20,7 @@
 #include <barrelfish/nameservice_client.h>
 #include <barrelfish/spawn_client.h>
 #include <barrelfish/cpu_arch.h>
+#include <barrelfish/proc_mgmt_client.h>
 #include <if/spawn_defs.h>
 #include <if/arrakis_defs.h>
 #include <if/monitor_defs.h>
@@ -156,7 +157,7 @@ errval_t spawn_bind_iref(iref_t iref, struct spawn_binding **ret_client)
  * \param argcn_cap     Cap to a CNode containing capabilities passed as
  *                      arguments
  * \param flags         Flags to spawn
- * \param ret_domainid  If non-NULL, filled in with domain ID of program
+ * \param domain_Cap  If non-NULL, filled in with domain cap of program
  *
  * \bug flags are currently ignored
  */
@@ -164,94 +165,10 @@ errval_t spawn_program_with_caps(coreid_t coreid, const char *path,
                                  char *const argv[], char *const envp[],
                                  struct capref inheritcn_cap,
                                  struct capref argcn_cap, spawn_flags_t flags,
-                                 domainid_t *ret_domainid)
+                                 struct capref *domain_cap)
 {
-    errval_t err, msgerr;
-
-    // default to copying our environment
-    if (envp == NULL) {
-        envp = environ;
-    }
-
-    err = bind_client(coreid);
-    if (err_is_fail(err)) {
-        return err;
-    }
-
-    struct spawn_binding *cl = get_spawn_binding(coreid);
-    assert(cl != NULL);
-
-    // construct argument "string"
-    // \0-separated strings in contiguous character buffer
-    // this is needed, as flounder can't send variable-length arrays of strings
-    size_t argstrlen = 0;
-    for (int i = 0; argv[i] != NULL; i++) {
-        argstrlen += strlen(argv[i]) + 1;
-    }
-
-    char argstr[argstrlen];
-    size_t argstrpos = 0;
-    for (int i = 0; argv[i] != NULL; i++) {
-        strcpy(&argstr[argstrpos], argv[i]);
-        argstrpos += strlen(argv[i]);
-        argstr[argstrpos++] = '\0';
-    }
-    assert(argstrpos == argstrlen);
-
-    // repeat for environment
-    size_t envstrlen = 0;
-    for (int i = 0; envp[i] != NULL; i++) {
-        envstrlen += strlen(envp[i]) + 1;
-    }
-
-    char envstr[envstrlen];
-    size_t envstrpos = 0;
-    for (int i = 0; envp[i] != NULL; i++) {
-        strcpy(&envstr[envstrpos], envp[i]);
-        envstrpos += strlen(envp[i]);
-        envstr[envstrpos++] = '\0';
-    }
-    assert(envstrpos == envstrlen);
-
-
-    domainid_t domain_id;
-
-    // make an unqualified path absolute using the $PATH variable
-    // TODO: implement search (currently assumes PATH is a single directory)
-    char *searchpath = getenv("PATH");
-    if (searchpath == NULL) {
-        searchpath = VFS_PATH_SEP_STR; // XXX: just put it in the root
-    }
-    size_t buflen = strlen(path) + strlen(searchpath) + 2;
-    char pathbuf[buflen];
-    if (path[0] != VFS_PATH_SEP) {
-        snprintf(pathbuf, buflen, "%s%c%s", searchpath, VFS_PATH_SEP, path);
-        pathbuf[buflen - 1] = '\0';
-        //vfs_path_normalise(pathbuf);
-        path = pathbuf;
-    }
-
-    if (capref_is_null(inheritcn_cap) && capref_is_null(argcn_cap)) {
-        err = cl->rpc_tx_vtbl.spawn_domain(cl, path, argstr, argstrlen,
-                                    envstr, envstrlen, flags,
-                                    &msgerr, &domain_id);
-    } else {
-        err = cl->rpc_tx_vtbl.spawn_domain_with_caps(cl, path, argstr, argstrlen,
-                                              envstr, envstrlen, inheritcn_cap,
-                                              argcn_cap, flags, &msgerr, &domain_id);
-    }
-    if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "error sending spawn request");
-    } else if (err_is_fail(msgerr)) {
-        goto out;
-    }
-
-    if (ret_domainid != NULL) {
-        *ret_domainid = domain_id;
-    }
-
-out:
-    return msgerr;
+    return proc_mgmt_spawn_program_with_caps(coreid, path, argv, envp, inheritcn_cap, 
+                                             argcn_cap, flags, domain_cap);
 }
 
 errval_t spawn_arrakis_program(coreid_t coreid, const char *path,
@@ -380,16 +297,16 @@ errval_t spawn_arrakis_program(coreid_t coreid, const char *path,
  * \param argv   Command-line arguments, NULL-terminated
  * \param envp   Optional environment, NULL-terminated (pass NULL to inherit)
  * \param flags  Flags to spawn
- * \param ret_domainid If non-NULL, filled in with domain ID of program
+ * \param ret_domain_cap If non-NULL, filled in with domain cap of program
  *
  * \bug flags are currently ignored
  */
 errval_t spawn_program(coreid_t coreid, const char *path,
                        char *const argv[], char *const envp[],
-                       spawn_flags_t flags, domainid_t *ret_domainid)
+                       spawn_flags_t flags, struct capref* ret_domain_cap)
 {
     return spawn_program_with_caps(coreid, path, argv, envp, NULL_CAP,
-                                   NULL_CAP, flags, ret_domainid);
+                                   NULL_CAP, flags, ret_domain_cap);
 }
 
 
@@ -413,7 +330,7 @@ errval_t spawn_program(coreid_t coreid, const char *path,
  */
 errval_t spawn_program_on_all_cores(bool same_core, const char *path,
                                     char *const argv[], char *const envp[],
-                                    spawn_flags_t flags, domainid_t *ret_domainid,
+                                    spawn_flags_t flags, struct capref *ret_domain_cap,
                                     coreid_t* spawn_count)
 {
     // TODO: handle flags, domain ID
@@ -454,10 +371,11 @@ errval_t spawn_program_on_all_cores(bool same_core, const char *path,
             continue;
         }
 
-        err = spawn_program(c, path, argv, envp, flags, NULL);
+        err = proc_mgmt_spawn_program(c, path, argv, envp, flags, NULL);
         if (err_is_ok(err) && spawn_count != NULL) {
             *spawn_count += 1;
         }
+
         if (err_is_fail(err)) {
             DEBUG_ERR(err, "error spawning %s on core %u\n", path, c);
             goto out;
@@ -483,8 +401,14 @@ errval_t spawn_binding(coreid_t coreid, struct spawn_binding **ret_client)
 /**
  * \brief Kill a domain.
  */
-errval_t spawn_kill(domainid_t domainid)
+errval_t spawn_kill(struct capref domain_cap)
 {
+    return proc_mgmt_kill(domain_cap);
+}
+
+errval_t spawn_wait_compat(uint8_t domainid,
+                           uint8_t *exitcode, bool nohang)
+ {
     errval_t err, reterr;
 
     err = bind_client(disp_get_core_id());
@@ -494,74 +418,46 @@ errval_t spawn_kill(domainid_t domainid)
     struct spawn_binding *cl = get_spawn_binding(disp_get_core_id());
     assert(cl != NULL);
 
-    err = cl->rpc_tx_vtbl.kill(cl, domainid, &reterr);
+    err = cl->rpc_tx_vtbl.wait(cl, domainid, nohang, exitcode, &reterr);
     if (err_is_fail(err)) {
         return err;
     }
 
     return reterr;
-}
+ }
 
 /**
  * \brief Exit this domain.
  */
 errval_t spawn_exit(uint8_t exitcode)
 {
-    errval_t err;
-
-    err = bind_client(disp_get_core_id());
-    if (err_is_fail(err)) {
-        return err;
-    }
-    struct spawn_binding *cl = get_spawn_binding(disp_get_core_id());
-    assert(cl != NULL);
-
-    err = cl->rpc_tx_vtbl.exit(cl, disp_get_domain_id(), exitcode);
-    if (err_is_fail(err)) {
-        return err;
-    }
-
-    return SYS_ERR_OK;
+    return proc_mgmt_exit(exitcode);
 }
 
 /**
  * \brief Wait for spawned proccess to exit on core.
  */
-errval_t spawn_wait_coreid(coreid_t coreid, domainid_t domainid,
+errval_t spawn_wait_coreid(coreid_t coreid, struct capref domain_cap,
                            uint8_t *exitcode, bool nohang)
 {
-    return spawn_wait_core(disp_get_core_id(), domainid, exitcode, nohang);
+    return spawn_wait_core(disp_get_core_id(), domain_cap, exitcode, nohang);
 }
 
 /**
  * \brief Wait for the termination of a domain on a remote core.
  */
-errval_t spawn_wait_core(coreid_t coreid, domainid_t domainid,
+errval_t spawn_wait_core(coreid_t coreid, struct capref domain_cap,
                          uint8_t *exitcode, bool nohang)
 {
-    errval_t err, reterr;
-
-    err = bind_client(coreid);
-    if (err_is_fail(err)) {
-        return err;
-    }
-    struct spawn_binding *cl = get_spawn_binding(coreid);
-    assert(cl != NULL);
-
-    err = cl->rpc_tx_vtbl.wait(cl, domainid, nohang, exitcode, &reterr);
-    if (err_is_fail(err)) {
-        return err;
-    }
-
-    return reterr;
+    return proc_mgmt_wait(domain_cap, exitcode);
 }
 
 /**
  * \brief Wait for spawned proccess to exit on current core.
  */
-errval_t spawn_wait(domainid_t domainid, uint8_t *exitcode, bool nohang)
+errval_t spawn_wait(struct capref domain_cap, uint8_t *exitcode, bool nohang)
 {
-    return spawn_wait_coreid(disp_get_core_id(), domainid, exitcode, nohang);
+    return spawn_wait_coreid(disp_get_core_id(), domain_cap, exitcode, nohang);
 }
 
 /**
@@ -617,7 +513,7 @@ errval_t spawn_get_status(uint8_t domain, struct spawn_ps_entry *pse,
 /**
  * \brief Dump capabilities for a given domain
  */
-errval_t spawn_dump_capabilities(domainid_t domainid)
+errval_t spawn_dump_capabilities_compat(domainid_t domainid)
 {
     errval_t err, reterr;
 
index 86d601c..252549d 100644 (file)
@@ -63,7 +63,8 @@ struct xomp_worker
     xomp_wid_t id;                  ///< worker ID
     xomp_worker_type_t type;        ///< worker type
     xomp_worker_st_t state;         ///< worker state
-    xphi_dom_id_t domainid;         ///< domain ID of the worker
+    struct capref domain;           ///< domain cap of the worker
+    xphi_dom_id_t domainid;         ///< domain ID of the worker  
 
     struct xomp_binding *binding;   ///< Control channel binding
     struct tx_queue txq;            ///< Flounder TX queue
@@ -744,7 +745,7 @@ errval_t xomp_master_spawn_workers(uint32_t nworkers)
             spawn_timer = bench_tsc();
 #endif
 
-            domainid_t did;
+            struct capref did;
             err = spawn_program_with_caps(core, spawn_args_local.path,
                                           spawn_args_local.argv, NULL, NULL_CAP,
                                           worker->msgframe, SPAWN_FLAGS_OMP,
@@ -753,7 +754,7 @@ errval_t xomp_master_spawn_workers(uint32_t nworkers)
             local_spawn_timer += bench_tsc() - spawn_timer;
             spawn_timer = bench_tsc();
 #endif
-            worker->domainid = did;
+            worker->domain = did;
             worker->type = XOMP_WORKER_TYPE_LOCAL;
             if (err_is_fail(err)) {
                 /* TODO: cleanup */
index 54b8585..cbb53ae 100644 (file)
@@ -69,7 +69,7 @@ pid_t waitpid(pid_t pid, int *status, int options)
 
     // We got a child to wait for
     uint8_t exitcode;
-    errval_t err = spawn_wait(children[i], &exitcode, nohang);
+    errval_t err = spawn_wait_compat(children[i], &exitcode, nohang);
     if(err_is_fail(err)) {
         if(err_no(err) == SPAWN_ERR_DOMAIN_RUNNING) {
             return 0;
index 070e37b..c540fa5 100644 (file)
@@ -70,7 +70,7 @@ static struct capref inheritcn_cap;
 static int help(int argc, char *argv[]);
 
 static int execute_program(coreid_t coreid, int argc, char *argv[],
-                           domainid_t *retdomainid)
+                           struct capref *ret_domain_cap)
 {
     vfs_handle_t vh;
     errval_t err;
@@ -90,11 +90,11 @@ static int execute_program(coreid_t coreid, int argc, char *argv[],
         vfs_close(vh);
     }
 
-    assert(retdomainid != NULL);
+    assert(ret_domain_cap != NULL);
 
     argv[argc] = NULL;
     err = spawn_program_with_caps(coreid, prog, argv, NULL, inheritcn_cap,
-                                  NULL_CAP, SPAWN_FLAGS_NEW_DOMAIN, retdomainid);
+                                  NULL_CAP, SPAWN_FLAGS_NEW_DOMAIN, ret_domain_cap);
 
     if (prog != argv[0]) {
         free(prog);
@@ -126,7 +126,7 @@ static int dump_caps(int argc, char *argv[]) {
     errval_t err;
     if (argc > 1) {
         domainid_t domain = strtol(argv[1], NULL, 10);
-        err = spawn_dump_capabilities(domain);
+        err = spawn_dump_capabilities_compat(domain);
     } else {
         dispatcher_handle_t handle = curdispatcher();
         struct capref dcb = get_dispatcher_generic(handle)->dcb_cap;
@@ -344,8 +344,8 @@ static int oncore(int argc, char *argv[])
     argc -= 2;
     argv += 2;
 
-    domainid_t domain_id;
-    int ret = execute_program(core, argc, argv, &domain_id);
+    struct capref domain_cap;
+    int ret = execute_program(core, argc, argv, &domain_cap);
 
     // TODO: do something with domain_id
 
@@ -1312,7 +1312,7 @@ static int makeargs(char *cmdline, char *argv[])
     return argc;
 }
 
-static uint8_t wait_domain_id(domainid_t domainid)
+static uint8_t wait_domain_id(struct capref domainid)
 {
     uint8_t exitcode;
     errval_t err = spawn_wait(domainid, &exitcode, false);
@@ -1407,12 +1407,12 @@ int main(int argc, const char *argv[])
             exitcode = cmd->cmd(cmd_argc, cmd_argv);
         } else {
             // Try loading a program off disk if VFS is initialized
-            domainid_t domain_id;
-            exitcode = execute_program(my_core_id, cmd_argc, cmd_argv, &domain_id);
+            struct capref domain_cap;
+            exitcode = execute_program(my_core_id, cmd_argc, cmd_argv, &domain_cap);
 
             // wait if it succeeds
             if (exitcode == 0 && wait) {
-                exitcode = wait_domain_id(domain_id);
+                exitcode = wait_domain_id(domain_cap);
                 char exitstr[128];
                 snprintf(exitstr, 128, "%u", exitcode);
                 int r = setenv("EXITCODE", exitstr, 1);
index b499da2..312ceeb 100644 (file)
@@ -54,7 +54,7 @@ void set_core_id_offset(struct module_info* mi, coreid_t offset)
     mi->coreoffset = offset;
 }
 
-domainid_t *get_did_ptr(struct module_info *mi)
+struct capref *get_did_ptr(struct module_info *mi)
 {
     return (mi->did + mi->num_started);
 }
index 7597edd..388d925 100644 (file)
@@ -32,7 +32,7 @@ struct module_info {
     uint8_t allow_multi;    ///< allow multiple driver instances
     uint8_t num_started;    ///< keeps track of the number of started domains
     coreid_t coreoffset;     ///< next coreid to start the new instance on
-    domainid_t did[MAX_DRIVER_INSTANCES];
+    struct capref did[MAX_DRIVER_INSTANCES];
 };
 
 
@@ -48,7 +48,7 @@ void set_start_function(char*, module_start_fn);
 void set_started(struct module_info*);
 void set_multi_instance(struct module_info*, uint8_t);
 void set_core_id_offset(struct module_info*, coreid_t);
-domainid_t *get_did_ptr(struct module_info *);
+struct capref *get_did_ptr(struct module_info *);
 coreid_t get_core_id_offset(struct module_info*);
 
 #endif /* BOOT_MODULES_H_ */
index 704c4f9..91b8ee0 100644 (file)
@@ -174,7 +174,7 @@ void spawn_dist_domains(void)
 
             debug_printf("starting dist-serv %s on core %d\n", si.name, coreid);
 
-            domainid_t new_domain;
+            struct capref new_domain;
             err = spawn_program(coreid, si.name, si.argv, environ,
                                 0, &new_domain);
             if (err_is_fail(err)) {
@@ -452,7 +452,7 @@ void spawn_bootscript_domains(void)
                 for(int i = id_from; i <= id_to; i++) {
                     debug_printf("starting app %s on core %d\n", name, i);
 
-                    domainid_t new_domain;
+                    struct capref new_domain;
                     err = spawn_program(i, name, argv, environ,
                                         0, &new_domain);
                     if (err_is_fail(err)) {
@@ -463,7 +463,7 @@ void spawn_bootscript_domains(void)
         } else {
             debug_printf("starting app %s on core %d\n", name, my_coreid);
 
-            domainid_t new_domain;
+            struct capref new_domain;
             err = spawn_program(my_coreid, name, argv, environ,
                                 0, &new_domain);
             if (err_is_fail(err)) {
index fb6ec34..8a3f692 100644 (file)
@@ -46,7 +46,7 @@ static errval_t spawn_child(int rfd)
 {
     errval_t err;
     char *argv[2] = { "net-test", NULL };
-    domainid_t new_domain = -1;
+    struct capref new_domain;
     coreid_t core = 0;
     struct capref fdcap;
 
index 9d33977..46ce106 100644 (file)
@@ -28,9 +28,8 @@ static errval_t test_spawn(coreid_t core_id, char *argv[],
 {
        assert(ret_domain_cap != NULL);
 
-       errval_t err = proc_mgmt_spawn_program(core_id,
-                                                  "/x86_64/sbin/proc_mgmt_test",
-                                                  argv, NULL, 0, ret_domain_cap);
+       errval_t err = spawn_program(core_id, "/x86_64/sbin/proc_mgmt_test",
+                                        argv, NULL, 0, ret_domain_cap);
        if (err_is_fail(err)) {
         return err;
        }
@@ -164,7 +163,7 @@ int main(int argc, char **argv)
     barrelfish_usleep(5*1000*1000);
 
     printf("Killing process \n");
-       err = proc_mgmt_kill(domain_cap);
+       err = spawn_kill(domain_cap);
        if (err_is_fail(err)) {
         USER_PANIC("Failed waiting for domain \n");
        }
@@ -181,7 +180,7 @@ int main(int argc, char **argv)
     barrelfish_usleep(5*1000*1000);
 
     printf("Killing process \n");
-       err = proc_mgmt_kill(domain_cap);
+       err = spawn_kill(domain_cap);
        if (err_is_fail(err)) {
         USER_PANIC("Failed waiting for domain \n");
        }
@@ -211,7 +210,7 @@ int main(int argc, char **argv)
     
        uint8_t code;
     printf("Waiting for process on different core to finish \n");
-       err = proc_mgmt_wait(domain_cap, &code);
+       err = spawn_wait(domain_cap, &code, false);
        if (err_is_fail(err)) {
         USER_PANIC("Failed waiting for domain \n");
        }
@@ -226,7 +225,7 @@ int main(int argc, char **argv)
     barrelfish_usleep(5*1000*1000);
     
     printf("Waiting for process on same core to finish \n");
-       err = proc_mgmt_wait(domain_cap, &code);
+       err = spawn_wait(domain_cap, &code, false);
        if (err_is_fail(err)) {
         USER_PANIC("Failed waiting for domain \n");
        }
index 74f9ef8..a1b008c 100644 (file)
@@ -160,7 +160,7 @@ static errval_t spawn_child(struct capref fdcap)
 
     char *argv[2] = { "testdesc-child", NULL };
 
-    domainid_t new_domain = -1;
+    struct capref new_domain;
 
     coreid_t core = 0;