monitor debug stuff + other debug msgs.
authorSimon Gerber <simon.gerber@inf.ethz.ch>
Mon, 17 Mar 2014 12:32:22 +0000 (13:32 +0100)
committerSimon Gerber <simon.gerber@inf.ethz.ch>
Mon, 17 Mar 2014 12:32:22 +0000 (13:32 +0100)
18 files changed:
errors/errno.fugu
kernel/cap_delete.c
kernel/capabilities.c
lib/barrelfish/spawn_client.c
lib/mdb/mdb_tree.c
lib/spawndomain/spawn.c
usr/fish/fish.c
usr/monitor/boot.c
usr/monitor/capops/caplock.c
usr/monitor/capops/capsend.c
usr/monitor/capops/copy.c
usr/monitor/include/monitor.h
usr/monitor/include/monitor_debug.h [new file with mode: 0644]
usr/monitor/inter.c
usr/monitor/main.c
usr/monitor/monitor_server.c
usr/monitor/send_cap.c
usr/spawnd/service.c

index e55aa3d..c56cfd7 100755 (executable)
@@ -479,6 +479,9 @@ errors monitor MON_ERR_ {
     failure RSRC_MEMBER_LIMIT  "Reached member limit of resource domain",
     failure RSRC_ILL_MANIFEST  "Illegal manifest",
     failure RSRC_NOT_FOUND     "Resource domain not found on this core",
+
+    // capops
+    failure CAPOPS_BUSY         "Other end not ready for operation",
 };
 
 // errors related to the routing library
index e5f3490..3284987 100644 (file)
@@ -104,6 +104,10 @@ errval_t caps_delete_last(struct cte *cte, struct cte *ret_ram_cap)
             caps_mark_revoke_generic(slot);
         }
 
+        if (cte->delete_node.next) {
+            debug(SUBSYS_CAPS, "cte is part of delete list, clearing\n");
+            cte->delete_node.next = NULL;
+        }
         clear_list_append(cte);
 
         return SYS_ERR_OK;
index dc3f0cf..499fec5 100644 (file)
@@ -758,7 +758,8 @@ static errval_t caps_create(enum objtype type, lpaddr_t lpaddr, uint8_t bits,
         src_cap.u.id.core_local_id = id_cap_counter++;
 
         // Insert the capability
-        return set_cap(&dest_caps->cap, &src_cap);
+        err = set_cap(&dest_caps->cap, &src_cap);
+        break;
 
     case ObjType_IO:
         src_cap.u.io.start = 0;
index 46bf705..e1ea3bf 100644 (file)
@@ -124,6 +124,7 @@ errval_t spawn_program_with_caps(coreid_t coreid, const char *path,
                                  struct capref argcn_cap, spawn_flags_t flags,
                                  domainid_t *ret_domainid)
 {
+    debug_printf("%s: %s\n", __FUNCTION__, path);
     struct spawn_rpc_client *cl;
     errval_t err, msgerr;
 
@@ -231,6 +232,7 @@ errval_t spawn_program_with_caps(coreid_t coreid, const char *path,
                                     envstr, envstrlen,
                                     &msgerr, &domain_id);
     } else {
+        debug_printf("%s: spawn_domain_with_caps\n", __FUNCTION__);
         err = cl->vtbl.spawn_domain_with_caps(cl, path, argstr, argstrlen,
                                               envstr, envstrlen, inheritcn_cap,
                                               argcn_cap, &msgerr, &domain_id);
index db97cd7..e0300fe 100644 (file)
@@ -37,7 +37,7 @@ mdb_dump_and_fail(struct cte *cte, enum mdb_inv failure)
     printf("failed on cte %p with failure %s (%d)\n", cte,
             mdb_invariants[failure], failure);
     // XXX: what is "proper" way to always terminate?
-    mdb_dump_all_the_things();
+    //mdb_dump_all_the_things();
     assert(false);
 }
 #define MDB_RET_INVARIANT(cte, failure) mdb_dump_and_fail(cte, failure)
@@ -151,6 +151,9 @@ mdb_check_subtree_invariants(struct cte *cte)
     if (!cte) {
         return MDB_INVARIANT_OK;
     }
+    if (C(cte)->type == 0) {
+        mdb_dump_all_the_things();
+    }
     assert(C(cte)->type != 0);
 
     int err;
index e0aa998..e2f92b3 100644 (file)
@@ -685,6 +685,7 @@ errval_t spawn_load_image(struct spawninfo *si, lvaddr_t binary,
 
     si->cpu_type = type;
 
+    debug_printf("init cspace\n");
     /* Initialize cspace */
     err = spawn_setup_cspace(si);
     if (err_is_fail(err)) {
@@ -692,11 +693,13 @@ errval_t spawn_load_image(struct spawninfo *si, lvaddr_t binary,
     }
 
     /* Initialize vspace */
+    debug_printf("init vspace\n");
     err = spawn_setup_vspace(si);
     if (err_is_fail(err)) {
         return err_push(err, SPAWN_ERR_VSPACE_INIT);
     }
 
+    debug_printf("load binary\n");
     genvaddr_t entry;
     void* arch_info;
     /* Load the image */
@@ -705,26 +708,28 @@ errval_t spawn_load_image(struct spawninfo *si, lvaddr_t binary,
         return err_push(err, SPAWN_ERR_LOAD);
     }
 
+    debug_printf("setup disp frame\n");
     /* Setup dispatcher frame */
     err = spawn_setup_dispatcher(si, coreid, name, entry, arch_info);
     if (err_is_fail(err)) {
         return err_push(err, SPAWN_ERR_SETUP_DISPATCHER);
     }
 
-    debug_printf("setup inherited\n");
+    debug_printf("setup inheritcn\n");
     /* Setup inherited caps */
     err = spawn_setup_inherited_caps(si, inheritcn_cap);
     if (err_is_fail(err)) {
         return err_push(err, SPAWN_ERR_SETUP_INHERITED_CAPS);
     }
 
-    debug_printf("setup args\n");
+    debug_printf("setup argcn\n");
     /* Setup argument caps */
     err = spawn_setup_argcn(si, argcn_cap);
     if (err_is_fail(err)) {
         return err_push(err, SPAWN_ERR_SETUP_ARGCN);
     }
  
+    debug_printf("setup cmdline args & env\n");
     /* Setup cmdline args */
     err = spawn_setup_env(si, argv, envp);
     if (err_is_fail(err)) {
index 15d1952..b28ec9b 100644 (file)
@@ -82,6 +82,7 @@ static int execute_program(coreid_t coreid, int argc, char *argv[],
 
     assert(retdomainid != NULL);
 
+    debug_printf("create inheritcn\n");
     // inherit the session capability
     struct capref inheritcn_cap;
     err = alloc_inheritcn_with_sidcap(&inheritcn_cap, cap_sessionid);
@@ -89,6 +90,7 @@ static int execute_program(coreid_t coreid, int argc, char *argv[],
         USER_PANIC_ERR(err, "Error allocating inherit CNode with session cap.");
     }
 
+    debug_printf("spawn program\n");
     argv[argc] = NULL;
     err = spawn_program_with_caps(coreid, prog, argv, NULL, inheritcn_cap,
                                   NULL_CAP, SPAWN_NEW_DOMAIN, retdomainid);
index f56ca2b..f25de03 100644 (file)
@@ -93,7 +93,7 @@ void boot_core_request(struct monitor_binding *b, coreid_t id, int32_t hwid,
     if (err_is_ok(err)) {
         num_monitors++;
     } else {
-        debug_printf("sending boot_core_reply: %s (%"PRIuERRV")\n",
+        DEBUG_CAPOPS("sending boot_core_reply: %s (%"PRIuERRV")\n",
                 err_getstring(err), err);
         errval_t err2 = b->tx_vtbl.boot_core_reply(b, NOP_CONT, err);
         if (err_is_fail(err2)) {
index 18bc743..3afdad6 100644 (file)
@@ -13,7 +13,7 @@
 #include <barrelfish/debug.h>
 #include <monitor_invocations.h>
 #include "capqueue.h"
-#include "magic.h"
+#include "monitor_debug.h"
 
 static struct capqueue_queue global_queue;
 
@@ -21,7 +21,7 @@ void
 caplock_wait(struct domcapref cap,
              struct event_queue_node *qn, struct event_closure cont)
 {
-    debug_printf("caplock_wait\n");
+    DEBUG_CAPOPS("caplock_wait\n");
     capqueue_wait(&global_queue, qn, cont);
 }
 
index 92637b9..cf4b251 100644 (file)
@@ -29,10 +29,11 @@ capsend_target(coreid_t dest, struct msg_queue_elem *queue_elem)
     if (err_is_fail(err)) {
         return err;
     }
+    DEBUG_CAPOPS("capsend_target: ->%d (%p)\n", dest, queue_elem);
     struct intermon_state *inter_st = (struct intermon_state*)dest_b->st;
     if (!inter_st->capops_ready) {
         // XXX: custom error value
-        return MON_ERR_NO_MONITOR_FOR_CORE;
+        return MON_ERR_CAPOPS_BUSY;
     }
 
     // enqueue message
index f456161..2e85204 100644 (file)
@@ -75,6 +75,7 @@ static void
 recv_copy_result_send__rdy(struct intermon_binding *b,
                            struct intermon_msg_queue_elem *e)
 {
+    DEBUG_CAPOPS("recv_copy_result_send__rdy: %p, %p\n", b, e);
     errval_t err;
     struct recv_copy_result_msg_st *msg_st = (struct recv_copy_result_msg_st*)e;
     err = intermon_capops_recv_copy_result__tx(b, NOP_CONT, msg_st->status,
@@ -92,6 +93,7 @@ recv_copy_result__enq(coreid_t dest, errval_t status, capaddr_t capaddr,
                       uint8_t vbits, cslot_t slot, genvaddr_t st)
 {
     errval_t err;
+    DEBUG_CAPOPS("recv_copy_result__enq: ->%d, %s\n", dest, err_getstring(status));
 
     // create send state
     struct recv_copy_result_msg_st *msg_st = calloc(1, sizeof(struct recv_copy_result_msg_st));
@@ -136,6 +138,7 @@ static void
 owner_copy_send__rdy(struct intermon_binding *b,
                      struct intermon_msg_queue_elem *e)
 {
+    DEBUG_CAPOPS("owner_copy_send__rdy: ->%p, %p\n", b, e);
     struct owner_copy_msg_st *msg_st = (struct owner_copy_msg_st*)e;
     struct cap_copy_rpc_st *rpc_st = (struct cap_copy_rpc_st*)(msg_st->st);
     assert(rpc_st);
@@ -161,6 +164,7 @@ owner_copy__enq(struct capref capref, struct capability *cap, coreid_t from,
                 coreid_t dest, bool give_away,
                 copy_result_handler_t result_handler, genvaddr_t st)
 {
+    DEBUG_CAPOPS("owner_copy__enq: %d->%d, give_away=%d\n", from, dest, give_away);
     errval_t err = SYS_ERR_OK, err2;
 
     // create new rpc state to associate return message
@@ -308,6 +312,10 @@ request_copy__enq(struct capref capref, coreid_t dest, bool give_away,
     err = monitor_cap_identify(capref, &cap);
     GOTO_IF_ERR(err, cont);
 
+    char buf[256];
+    debug_print_cap(buf,256,&cap);
+    buf[255]=0;
+    debug_printf("cap: %s\n", buf);
     // cap is foreign so it must be a type that needs "locality" on a particular core
     assert(distcap_needs_locality(cap.type));
 
@@ -379,12 +387,15 @@ static void
 recv_copy_result__src(errval_t status, capaddr_t capaddr, uint8_t vbits,
                       cslot_t slot, struct cap_copy_rpc_st *rpc_st)
 {
+    DEBUG_CAPOPS("recv_copy_result__src: %s\n", err_getstring(status));
     // origin of copy
     errval_t err;
 
     if (err_is_ok(status)) {
         if (rpc_st->delete_after) {
+            DEBUG_CAPOPS("deleting our copy\n");
             if (rpc_st->is_last) {
+                DEBUG_CAPOPS("our copy is last\n");
                 // a give_away was performed, need to unlock and set new owner
                 err = monitor_set_cap_owner(cap_root,
                                             get_cap_addr(rpc_st->cap),
@@ -401,6 +412,7 @@ recv_copy_result__src(errval_t status, capaddr_t capaddr, uint8_t vbits,
         }
     }
     // call result handler
+    DEBUG_CAPOPS("result_handler: %p\n", rpc_st->result_handler);
     if (rpc_st->result_handler) {
         rpc_st->result_handler(status, capaddr, vbits, slot, (void*)rpc_st->st);
     }
@@ -417,6 +429,7 @@ recv_copy_result__rx(struct intermon_binding *b, errval_t status,
                      genvaddr_t st)
 {
     assert(st);
+    DEBUG_CAPOPS("recv_copy_result__rx: %p, %s\n", b, err_getstring(status));
     struct cap_copy_rpc_st *rpc_st = (struct cap_copy_rpc_st*)st;
     rpc_st->recv_handler(status, capaddr, vbits, slot, rpc_st);
 }
@@ -432,6 +445,8 @@ void
 recv_copy__rx(struct intermon_binding *b, intermon_caprep_t caprep,
               uint8_t owner_relations, genvaddr_t st)
 {
+    DEBUG_CAPOPS("recv_copy__rx: %p, %"PRIu8"\n", b, owner_relations);
+    debug_print_caprep(&caprep);
     errval_t err, err2;
     struct intermon_state *inter_st = (struct intermon_state*)b->st;
     coreid_t from = inter_st->core_id;
@@ -568,6 +583,7 @@ void
 capops_copy(struct capref capref, coreid_t dest, bool give_away,
             copy_result_handler_t result_handler, void *st)
 {
+    DEBUG_CAPOPS("capops_copy: dest=%d, give_away=%d\n", dest, give_away);
     errval_t err, err2;
     struct capability cap;
     distcap_state_t state;
@@ -602,10 +618,12 @@ capops_copy(struct capref capref, coreid_t dest, bool give_away,
                        get_cnode_valid_bits(res), res.slot, st);
     }
     else if (distcap_state_is_foreign(state)) {
+        DEBUG_CAPOPS("capops_copy: sending copy from non-owner, forward request to owner\n");
         // sending copy from non-owner, send copy request to owner
         request_copy__enq(capref, dest, give_away, result_handler, st);
     }
     else {
+        DEBUG_CAPOPS("capops_copy: sending copy from owner\n");
         // sending copy from owner
         err = monitor_cap_identify(capref, &cap);
         GOTO_IF_ERR(err, err_cont);
index e562d2f..a5dfb52 100644 (file)
@@ -26,6 +26,7 @@
 #include <monitor_invocations_arch.h>
 #include <queue.h>
 #include <connection.h>
+#include "monitor_debug.h"
 
 // Change #URPC_SIZE if changing this
 #define MON_URPC_CHANNEL_LEN  (32 * UMP_MSG_BYTES)
@@ -92,6 +93,15 @@ static inline void caprep_to_capability(intermon_caprep_t *caprep,
     *cap = u.cap;
 }
 
+static inline void debug_print_caprep(intermon_caprep_t *caprep)
+{
+    union capability_caprep_u u = { .caprep = *caprep };
+    char buf[256];
+    debug_print_cap(buf, 256, &u.cap);
+    buf[255] = 0;
+    DEBUG_CAPOPS("\t%s\n", buf);
+}
+
 #include <ram_alloc.h>
 #include <spawn.h>
 #include <monitor_server.h>
diff --git a/usr/monitor/include/monitor_debug.h b/usr/monitor/include/monitor_debug.h
new file mode 100644 (file)
index 0000000..de4ef13
--- /dev/null
@@ -0,0 +1,27 @@
+/**
+ * \file
+ * \brief
+ */
+
+/*
+ * Copyright (c) 2014, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Universitaetstr 6, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+#ifndef DEBUG_MONITOR_H
+#define DEBUG_MONITOR_H
+
+// XXX: should be done via Config.hs
+#define DEBUG_MONITOR_CAPOPS
+
+#if defined(DEBUG_MONITOR_CAPOPS) || defined(GLOBAL_DEBUG)
+#define DEBUG_CAPOPS(x...) debug_printf(x)
+#else
+#define DEBUG_CAPOPS(x...) ((void)0)
+#endif
+
+#endif // DEBUG_MONITOR_H
index 6873518..3d1c054 100644 (file)
@@ -111,7 +111,7 @@ boot_core_reply_cont(struct monitor_binding *domain_binding,
                      errval_t error_code)
 {
     errval_t err;
-    debug_printf("boot_core_reply_cont: %s (%"PRIuERRV")\n",
+    DEBUG_CAPOPS("boot_core_reply_cont: %s (%"PRIuERRV")\n",
             err_getstring(error_code), error_code);
     err = domain_binding->tx_vtbl.
             boot_core_reply(domain_binding, NOP_CONT, error_code);
@@ -172,6 +172,7 @@ cap_receive_request_enqueue(struct monitor_binding *domain_binding,
                             uintptr_t your_mon_id,
                             struct intermon_binding *b)
 {
+    DEBUG_CAPOPS("%s\n", __FUNCTION__);
     errval_t err;
 
     struct cap_receive_request_state *me =
@@ -200,6 +201,7 @@ cap_receive_request_cont(struct monitor_binding *domain_binding,
                          uint32_t capid, uintptr_t your_mon_id,
                          struct intermon_binding *b)
 {
+    DEBUG_CAPOPS("%s ->%"PRIuPTR", %s\n", __FUNCTION__, domain_id, err_getstring(msgerr));
     errval_t err, err2;
     struct capref *capp = caprefdup(cap);
 
@@ -207,8 +209,10 @@ cap_receive_request_cont(struct monitor_binding *domain_binding,
         cap_receive_request(domain_binding, MKCONT(free, capp), domain_id, msgerr, cap, capid);
 
     if (err_is_fail(err)) {
+        DEBUG_CAPOPS("%s: send failed: %s\n", __FUNCTION__, err_getstring(err));
         free(capp);
         if(err_no(err) == FLOUNDER_ERR_TX_BUSY) {
+            DEBUG_CAPOPS("%s: enqueueing message b/c flounder busy\n", __FUNCTION__);
             cap_receive_request_enqueue(domain_binding, domain_id, msgerr, cap,
                                         capid, your_mon_id, b);
         } else {
@@ -245,6 +249,7 @@ static void
 cap_send_request_caprecv_cont(errval_t err, struct captx_recv_state *captx_st,
                               struct capref cap, void *st_)
 {
+    DEBUG_CAPOPS("%s: %s\n", __FUNCTION__, err_getstring(err));
     struct cap_send_request_st *st = (struct cap_send_request_st*)st_;
 
     uintptr_t my_mon_id = st->my_mon_id;
@@ -259,9 +264,11 @@ cap_send_request_caprecv_cont(errval_t err, struct captx_recv_state *captx_st,
     // Try to send cap to the user domain, but only if the queue is empty
     struct monitor_state *mst = domain_binding->st;
     if (msg_queue_is_empty(&mst->queue)) {
+        DEBUG_CAPOPS("deliver cap to user domain 0x%"PRIxPTR"\n", domain_id);
         cap_receive_request_cont(domain_binding, domain_id, err, cap, st->capid,
                                  your_mon_id, st->b);
     } else {
+        DEBUG_CAPOPS("enqueue cap for delivery to user domain\n");
         // don't allow sends to bypass the queue
         cap_receive_request_enqueue(domain_binding, domain_id, err, cap, st->capid,
                                     your_mon_id, st->b);
@@ -272,6 +279,7 @@ static void
 cap_send_request(struct intermon_binding *b, mon_id_t my_mon_id,
                  uint32_t capid, intermon_captx_t captx)
 {
+    DEBUG_CAPOPS("intermon: %s\n", __FUNCTION__);
     errval_t err;
 
     struct cap_send_request_st *st;
@@ -669,10 +677,10 @@ errval_t intermon_init(struct intermon_binding *b, coreid_t coreid)
 
 #if CONFIG_TRACE
     err = trace_intermon_init(b);
-       if (err_is_fail(err)) {
-               USER_PANIC_ERR(err, "trace_intermon_init failed");
-               return err;
-       }
+    if (err_is_fail(err)) {
+        USER_PANIC_ERR(err, "trace_intermon_init failed");
+        return err;
+    }
 
     err = bfscope_intermon_init(b);
     if (err_is_fail(err)) {
@@ -695,7 +703,7 @@ errval_t intermon_init(struct intermon_binding *b, coreid_t coreid)
 
     err = intermon_binding_set(st);
     if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "intermon_binding_set failed");       
+        USER_PANIC_ERR(err, "intermon_binding_set failed");
         return err;
     }
 
index 424bb86..e0ebdbe 100644 (file)
@@ -157,7 +157,7 @@ static errval_t boot_app_core(int argc, char *argv[])
 #endif
 
     /* with memory alloc running, take part in cap ops */
-    debug_printf("sending capops_ready to %"PRIuCOREID"\n", parent_core_id);
+    DEBUG_CAPOPS("sending capops_ready to %"PRIuCOREID"\n", parent_core_id);
     err = intermon_binding->tx_vtbl.capops_ready(intermon_binding, NOP_CONT);
     if (err_is_fail(err)) {
         return err_push(err, MON_ERR_SEND_REMOTE_MSG);
index a2d3c21..8a0814e 100644 (file)
@@ -633,6 +633,7 @@ static void
 cap_send_tx_cont(struct intermon_binding *b,
                  struct intermon_msg_queue_elem *e)
 {
+    DEBUG_CAPOPS("%s: %p %p\n", __FUNCTION__, b, e);
     errval_t send_err;
     struct send_cap_st *st = (struct send_cap_st*)e;
     struct remote_conn_state *conn = remote_conn_lookup(st->my_mon_id);
@@ -648,6 +649,7 @@ static void
 cap_send_request_tx_cont(errval_t err, struct captx_prepare_state *captx_st,
                          intermon_captx_t *captx, void *st_)
 {
+    DEBUG_CAPOPS("%s: %s\n", __FUNCTION__, err_getstring(err));
     errval_t queue_err;
     struct send_cap_st *send_st = (struct send_cap_st*)st_;
 
@@ -660,6 +662,7 @@ cap_send_request_tx_cont(errval_t err, struct captx_prepare_state *captx_st,
 
     send_st->captx = *captx;
 
+    DEBUG_CAPOPS("%s: enqueueing send\n", __FUNCTION__);
     send_st->qe.cont = cap_send_tx_cont;
     struct remote_conn_state *conn = remote_conn_lookup(send_st->my_mon_id);
     struct intermon_binding *binding = conn->mon_binding;
@@ -677,6 +680,7 @@ static void
 cap_send_request(struct monitor_binding *b, uintptr_t my_mon_id,
                  struct capref cap, uint32_t capid)
 {
+    DEBUG_CAPOPS("cap_send_request\n");
     errval_t err;
     struct remote_conn_state *conn = remote_conn_lookup(my_mon_id);
 
@@ -828,7 +832,7 @@ static void num_cores_request(struct monitor_binding *b)
      * and start from zero, which is a false assumption! Go ask the SKB...
      */
 
-    debug_printf("Application invoked deprecated num_cores_request() API."
+    DEBUG_CAPOPS("Application invoked deprecated num_cores_request() API."
                  " Please fix it!\n");
 
     /* Send reply */
index 8f605a6..4582a82 100644 (file)
@@ -12,6 +12,7 @@
 #include <barrelfish/debug.h>
 #include <monitor_invocations_arch.h>
 #include <string.h>
+#include "monitor_debug.h"
 
 static void
 captx_prepare_copy_result_cont(errval_t status, capaddr_t cnaddr,
@@ -24,6 +25,7 @@ captx_prepare_copy_result_cont(errval_t status, capaddr_t cnaddr,
         st->captx.slot = slot;
     }
     intermon_captx_t *tx = err_is_ok(status) ? &st->captx : NULL;
+    DEBUG_CAPOPS("%s: st->send_cont = %p\n", __FUNCTION__, st->send_cont);
     st->send_cont(status, st, tx, st->st);
 }
 
@@ -72,6 +74,7 @@ void
 captx_handle_recv(intermon_captx_t *captx, struct captx_recv_state *state,
                   captx_recv_cont recv_cont, void *st)
 {
+    DEBUG_CAPOPS("%s\n", __FUNCTION__);
     assert(state);
     assert(recv_cont);
     errval_t err;
index 02ee657..a0b08df 100644 (file)
@@ -34,6 +34,7 @@ static errval_t spawn(char *path, char *const argv[], char *argbuf,
                       struct capref inheritcn_cap, struct capref argcn_cap,
                       domainid_t *domainid)
 {
+    debug_printf("spawn: %s\n", path);
     errval_t err, msgerr;
 
     /* read file into memory */
@@ -296,6 +297,7 @@ static void spawn_with_caps_handler(struct spawn_binding *b, char *path,
                                     struct capref inheritcn_cap,
                                     struct capref argcn_cap)
 {
+    debug_printf("%s: %s\n", __FUNCTION__, path);
     errval_t err;
     domainid_t domainid = 0;