Adjustments of IPC to match new convention (static buffers).
authorAdam Turowski <adam.turowski@inf.ethz.ch>
Tue, 26 Jul 2016 11:36:51 +0000 (13:36 +0200)
committerAdam Turowski <adam.turowski@inf.ethz.ch>
Tue, 26 Jul 2016 11:36:51 +0000 (13:36 +0200)
(Flounder) Fixing a token passing in 32-bit architectures.

Signed-off-by: Adam Turowski <adam.turowski@inf.ethz.ch>

61 files changed:
include/skb/skb.h
lib/angler/angler.c
lib/barrelfish/morecore.c
lib/barrelfish/nameservice_client.c
lib/barrelfish/spawn_client.c
lib/octopus/client/barriers.c
lib/octopus/client/getset.c
lib/octopus/client/locking.c
lib/octopus/client/pubsub.c
lib/octopus/client/semaphores.c
lib/octopus/client/trigger.c
lib/octopus/server/capstorage.c
lib/octopus/server/service.c
lib/pci/pci_client.c
lib/posixcompat/dirent.c
lib/posixcompat/pty.c
lib/skb/skb.c
lib/skb/skb_functions.c
lib/spawndomain/spawn_omp.c
lib/term/client/client_blocking.c
lib/usb/usb_manager_client.c
lib/usb/usb_request.c
lib/vfs/vfs_blockdevfs_ahci.c
lib/vfs/vfs_blockdevfs_ata.c
lib/vfs/vfs_fat.c
lib/vfs/vfs_ramfs.c
lib/xeon_phi/xeon_phi_domain.c
tools/flounder/LMP.hs
tools/flounder/MsgFragments.hs
tools/flounder/Multihop.hs
tools/flounder/Syntax.lhs
usr/acpi/acpi_service.c
usr/drivers/cpuboot/main.c
usr/drivers/cpuboot/x86boot.c
usr/drivers/serial/basic_service.c
usr/drivers/serial/terminal_service.c
usr/drivers/xeon_phi/domain.c
usr/examples/xmpl-msg/msg.c
usr/examples/xmpl-rpc/rpc_msg.c
usr/examples/xmpl-thc-binding/thc-binding.c
usr/fish/fish_common.c
usr/kaluga/start_cpu.c
usr/kaluga/start_pci.c
usr/monitor/arch/aarch64/monitor_server.c
usr/monitor/arch/armv7/monitor_server.c
usr/monitor/arch/x86/monitor_server.c
usr/monitor/capops/internal.c
usr/monitor/inter.c
usr/monitor/monitor_server.c
usr/monitor/multihop_support.c
usr/monitor/ram_alloc.c
usr/monitor/resource_ctrl.c
usr/monitor/ump_support.c
usr/pci/pci.c
usr/pci/pci_service.c
usr/ramfsd/service.c
usr/skb/include/skb_server.h
usr/skb/skb_main.c
usr/skb/skb_service.c
usr/spawnd/service.c
usr/tests/ata_rw28_test/ata_rw28_test.c

index b35b84f..a97f91d 100644 (file)
@@ -21,7 +21,6 @@ errval_t skb_add_fact(char *fmt, ...) __attribute__((format(printf, 1, 2)));
 errval_t skb_set_memory_affinity(void);
 
 #define ELEMENT_NAME_BUF_SIZE 80
-#define SKB_REPLY_BUF_SIZE (128*1024)
 
 struct list_parser_status {
     char *s;
index 32fe54f..c502000 100644 (file)
@@ -177,7 +177,6 @@ static errval_t store_session_state(struct capref *session_id,
     struct octopus_rpc_client *rpc_client = NULL;
     char *attributes = NULL;
     size_t attributes_len = 0;
-    char *record = NULL;
     octopus_trigger_id_t tid;
 
     rpc_client = get_octopus_rpc_client();
@@ -195,7 +194,7 @@ static errval_t store_session_state(struct capref *session_id,
     /* Store record at octopus. */
     err = rpc_client->vtbl.set_with_idcap(rpc_client, *session_id, attributes,
                                            SET_DEFAULT, NOP_TRIGGER, false,
-                                           &record, &tid, &error);
+                                           NULL, &tid, &error);
     if (err_is_fail(err)) {
         goto out;
     }
index b7eb34a..2504c51 100644 (file)
@@ -44,6 +44,15 @@ static void *morecore_alloc(size_t bytes, size_t *retbytes)
     errval_t err;
     struct morecore_state *state = get_morecore_state();
 
+    struct ram_alloc_state *ram_alloc_state = get_ram_alloc_state();
+    if(ram_alloc_state->ram_alloc_func != ram_alloc_fixed) {
+        if (bytes < LARGE_PAGE_SIZE) {
+            bytes = LARGE_PAGE_SIZE;
+        }
+
+        bytes = ROUND_UP(bytes, LARGE_PAGE_SIZE);
+    }
+
     void *buf = NULL;
     size_t mapped = 0;
     size_t step = bytes;
index eb66ffe..0818cf0 100644 (file)
@@ -38,14 +38,14 @@ errval_t nameservice_lookup(const char *iface, iref_t *retiref)
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
 
-    char* record = NULL;
-    octopus_trigger_id_t tid;
-    errval_t error_code;
-    err = r->vtbl.get(r, iface, NOP_TRIGGER, &record, &tid, &error_code);
+
+    struct octopus_get_names_response__rx_args reply;
+    err = r->vtbl.get(r, iface, NOP_TRIGGER, reply.output, &reply.tid,
+                      &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
     }
-    err = error_code;
+    err = reply.error_code;
     if (err_is_fail(err)) {
         if (err_no(err) == OCT_ERR_NO_RECORD) {
             err = err_push(err, LIB_ERR_NAMESERVICE_UNKNOWN_NAME);
@@ -54,7 +54,7 @@ errval_t nameservice_lookup(const char *iface, iref_t *retiref)
     }
 
     uint64_t iref_number = 0;
-    err = oct_read(record, "_ { iref: %d }", &iref_number);
+    err = oct_read(reply.output, "_ { iref: %d }", &iref_number);
     if (err_is_fail(err) || iref_number == 0) {
         err = err_push(err, LIB_ERR_NAMESERVICE_INVALID_NAME);
         goto out;
@@ -64,7 +64,6 @@ errval_t nameservice_lookup(const char *iface, iref_t *retiref)
     }
 
 out:
-    free(record);
     return err;
 }
 
@@ -83,13 +82,12 @@ errval_t nameservice_blocking_lookup(const char *iface, iref_t *retiref)
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
 
-    char* record = NULL;
-    errval_t error_code;
-    err = r->vtbl.wait_for(r, iface, &record, &error_code);
+    struct octopus_wait_for_response__rx_args reply;
+    err = r->vtbl.wait_for(r, iface, reply.record, &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
     }
-    err = error_code;
+    err = reply.error_code;
     if (err_is_fail(err)) {
         if (err_no(err) == OCT_ERR_NO_RECORD) {
             err = err_push(err, LIB_ERR_NAMESERVICE_UNKNOWN_NAME);
@@ -98,7 +96,7 @@ errval_t nameservice_blocking_lookup(const char *iface, iref_t *retiref)
     }
 
     uint64_t iref_number = 0;
-    err = oct_read(record, "_ { iref: %d }", &iref_number);
+    err = oct_read(reply.record, "_ { iref: %d }", &iref_number);
     if (err_is_fail(err)) {
         err = err_push(err, LIB_ERR_NAMESERVICE_INVALID_NAME);
         goto out;
@@ -108,7 +106,6 @@ errval_t nameservice_blocking_lookup(const char *iface, iref_t *retiref)
     }
 
 out:
-    free(record);
     return err;
 }
 
@@ -136,10 +133,9 @@ errval_t nameservice_register(const char *iface, iref_t iref)
     }
     snprintf(record, len+1, format, iface, iref);
 
-    char* ret = NULL;
     octopus_trigger_id_t tid;
     errval_t error_code;
-    err = r->vtbl.set(r, record, 0, NOP_TRIGGER, 0, &ret, &tid, &error_code);
+    err = r->vtbl.set(r, record, 0, NOP_TRIGGER, 0, NULL, &tid, &error_code);
     if (err_is_fail(err)) {
         goto out;
     }
index 904549d..bcec47e 100644 (file)
@@ -421,22 +421,19 @@ errval_t spawn_program_on_all_cores(bool same_core, const char *path,
     }
 
     // FIXME: world's most (kinda less now) broken implementation...
-    
-    char* buffer = NULL;
-    errval_t error_code;
-    octopus_trigger_id_t tid;
-    
     char** names = NULL;
     size_t count = 0;
-    
+
     static char* spawnds = "r'spawn.[0-9]+' { iref: _ }";
-        err = r->vtbl.get_names(r, spawnds, NOP_TRIGGER, &buffer, &tid, &error_code);
-    if (err_is_fail(err) || err_is_fail(error_code)) {
+    struct octopus_get_names_response__rx_args reply;
+    err = r->vtbl.get_names(r, spawnds, NOP_TRIGGER, reply.output, &reply.tid,
+                            &reply.error_code);
+    if (err_is_fail(err) || err_is_fail(reply.error_code)) {
         err = err_push(err, SPAWN_ERR_FIND_SPAWNDS);
         goto out;
     }
 
-    err = oct_parse_names(buffer, &names, &count);
+    err = oct_parse_names(reply.output, &names, &count);
     if (err_is_fail(err)) {
         goto out;
     }
@@ -464,7 +461,6 @@ errval_t spawn_program_on_all_cores(bool same_core, const char *path,
     }
 
 out:
-    free(buffer);
     oct_free_names(names, count);
     return err;
 }
@@ -578,11 +574,13 @@ errval_t spawn_get_domain_list(uint8_t **domains, size_t *len)
     }
     assert(cl != NULL);
 
-    err = cl->vtbl.get_domainlist(cl, domains, len);
+    struct spawn_get_domainlist_response__rx_args reply;
+    err = cl->vtbl.get_domainlist(cl, reply.domains, len);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "get_domainlist");
     }
 
+    *domains = memdup(reply.domains, *len);
     return SYS_ERR_OK;
 }
 
@@ -601,12 +599,14 @@ errval_t spawn_get_status(uint8_t domain, struct spawn_ps_entry *pse,
     }
     assert(cl != NULL);
 
-    err = cl->vtbl.status(cl, domain, (spawn_ps_entry_t *)pse, argbuf, arglen,
-                          reterr);
+    struct spawn_status_response__rx_args reply;
+    err = cl->vtbl.status(cl, domain, (spawn_ps_entry_t *)pse, reply.argv,
+                          arglen, reterr);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "status");
     }
 
+    *argbuf = memdup(reply.argv, *arglen);
     return SYS_ERR_OK;
 }
 
index 59fcd5e..eafa458 100644 (file)
@@ -41,11 +41,8 @@ errval_t oct_barrier_enter(const char* name, char** barrier_record, size_t wait_
 {
     errval_t err;
     errval_t exist_err;
-    char* record = NULL;
     char** names = NULL;
     uint64_t mode = 0;
-    uint64_t state = 0;
-    uint64_t fn = 0;
     octopus_trigger_id_t tid;
     size_t current_barriers = 0;
     octopus_trigger_t t = oct_mktrigger(OCT_ERR_NO_RECORD, octopus_BINDING_RPC,
@@ -53,6 +50,10 @@ errval_t oct_barrier_enter(const char* name, char** barrier_record, size_t wait_
 
     err = oct_set_get(SET_SEQUENTIAL, barrier_record,
             "%s_ { barrier: '%s' }", name, name);
+    *barrier_record = strdup(*barrier_record);
+    if (*barrier_record == NULL) {
+        return LIB_ERR_MALLOC_FAIL;
+    }
     err = oct_get_names(&names, &current_barriers, "_ { barrier: '%s' }",
             name);
     oct_free_names(names, current_barriers);
@@ -75,8 +76,7 @@ errval_t oct_barrier_enter(const char* name, char** barrier_record, size_t wait_
         }
         if (err_no(err) == OCT_ERR_NO_RECORD) {
             // Wait until barrier record is created
-            err = cl->recv.trigger(cl, &tid, &fn, &mode, &record, &state);
-            free(record);
+            err = cl->recv.trigger(cl, NULL, NULL, &mode, NULL, NULL);
             assert(mode & OCT_REMOVED);
 
             err = SYS_ERR_OK;
@@ -111,12 +111,9 @@ errval_t oct_barrier_leave(const char* barrier_record)
     errval_t err;
     char* rec_name = NULL;
     char* barrier_name = NULL;
-    char* record = NULL;
     char** names = NULL;
     size_t remaining_barriers = 0;
     uint64_t mode = 0;
-    uint64_t state = 0;
-    uint64_t fn = 0;
     octopus_trigger_id_t tid;
     octopus_trigger_t t = oct_mktrigger(SYS_ERR_OK, octopus_BINDING_RPC,
             OCT_ON_DEL, NULL, NULL);
@@ -146,7 +143,7 @@ errval_t oct_barrier_leave(const char* barrier_record)
 
             if (err_is_ok(err)) {
                 // Wait until everyone has left the barrier
-                err = cl->recv.trigger(cl, &tid, &fn, &mode, &record, &state);
+                err = cl->recv.trigger(cl, NULL, NULL, &mode, NULL, NULL);
                 assert(mode & OCT_REMOVED);
             }
             else if (err_no(err) == OCT_ERR_NO_RECORD) {
@@ -165,7 +162,6 @@ errval_t oct_barrier_leave(const char* barrier_record)
     }
 
 out:
-    free(record);
     free(rec_name);
     free(barrier_name);
     return err;
index 5f18792..a4b0e64 100644 (file)
@@ -54,7 +54,6 @@ errval_t oct_get_names(char*** names, size_t* len, const char* query, ...)
     errval_t err = SYS_ERR_OK;
     va_list args;
 
-    char* data = NULL;
     char* buf = NULL;
     *len = 0;
 
@@ -62,21 +61,19 @@ errval_t oct_get_names(char*** names, size_t* len, const char* query, ...)
 
     struct octopus_thc_client_binding_t* cl = oct_get_thc_client();
 
-    errval_t error_code;
-    octopus_trigger_id_t tid;
-    err = cl->call_seq.get_names(cl, buf, NOP_TRIGGER, &data,
-            &tid, &error_code);
+    struct octopus_get_names_response__rx_args reply;
+    err = cl->call_seq.get_names(cl, buf, NOP_TRIGGER, reply.output,
+            &reply.tid, &reply.error_code);
     if (err_is_ok(err)) {
-        err = error_code;
+        err = reply.error_code;
     }
 
     if (err_is_ok(err)) {
-        err = oct_parse_names(data, names, len);
+        err = oct_parse_names(reply.output, names, len);
         //qsort(*names, *len, sizeof(char*), cmpstringp);
     }
 
     free(buf);
-    free(data);
     return err;
 }
 
@@ -96,9 +93,7 @@ errval_t oct_get_names(char*** names, size_t* len, const char* query, ...)
 errval_t oct_get(char** data, const char* query, ...)
 {
     assert(query != NULL);
-    errval_t error_code;
     errval_t err = SYS_ERR_OK;
-    octopus_trigger_id_t tid;
     va_list args;
 
     char* buf = NULL;
@@ -106,14 +101,26 @@ errval_t oct_get(char** data, const char* query, ...)
 
     struct octopus_thc_client_binding_t* cl = oct_get_thc_client();
     assert(cl != NULL);
-    err = cl->call_seq.get(cl, buf, NOP_TRIGGER, data,
-            &tid, &error_code);
+
+    struct octopus_get_response__rx_args reply;
+    err = cl->call_seq.get(cl, buf, NOP_TRIGGER, reply.output,
+            &reply.tid, &reply.error_code);
 
     if (err_is_ok(err)) {
-        err = error_code;
+        err = reply.error_code;
     }
 
     free(buf);
+
+    if (err_is_fail(err)) {
+        return err;
+    }
+
+    if (data) {
+        *data = strdup(reply.output);
+    }
+
+
     return err;
 }
 
@@ -140,12 +147,9 @@ errval_t oct_set(const char* query, ...)
     // Send to Server
     struct octopus_thc_client_binding_t* cl = oct_get_thc_client();
 
-    char* record = NULL;
     errval_t error_code;
-    octopus_trigger_id_t tid;
-    err = cl->call_seq.set(cl, buf, SET_DEFAULT, NOP_TRIGGER, false,
-            &record, &tid, &error_code);
-    assert(record == NULL);
+    err = cl->call_seq.set(cl, buf, SET_DEFAULT, NOP_TRIGGER, false, NULL, NULL,
+                           &error_code);
 
     if (err_is_ok(err)) {
         err = error_code;
@@ -179,12 +183,9 @@ errval_t oct_mset(oct_mode_t mode, const char* query, ...)
     // Send to Server
     struct octopus_thc_client_binding_t* cl = oct_get_thc_client();
 
-    char* record = NULL;
     errval_t error_code;
-    octopus_trigger_id_t tid;
-    err = cl->call_seq.set(cl, buf, mode, NOP_TRIGGER, false,
-            &record, &tid, &error_code);
-    assert(record == NULL);
+    err = cl->call_seq.set(cl, buf, mode, NOP_TRIGGER, false, NULL, NULL,
+                           &error_code);
 
     if (err_is_ok(err)) {
         err = error_code;
@@ -224,15 +225,23 @@ errval_t oct_set_get(oct_mode_t mode, char** record, const char* query, ...)
 
     // Send to Server
     struct octopus_thc_client_binding_t* cl = oct_get_thc_client();
-    errval_t error_code;
-    octopus_trigger_id_t tid;
-    err = cl->call_seq.set(cl, buf, mode, NOP_TRIGGER, true, record,
-            &tid, &error_code);
+    struct octopus_set_response__rx_args reply;
+    err = cl->call_seq.set(cl, buf, mode, NOP_TRIGGER, true, reply.record,
+                           &reply.tid, &reply.error_code);
     if (err_is_ok(err)) {
-        err = error_code;
+        err = reply.error_code;
     }
 
     free(buf);
+
+    if (err_is_fail(err)) {
+        return err;
+    }
+
+    if (record) {
+        *record = strdup(reply.record);
+    }
+
     return err;
 }
 
@@ -250,17 +259,24 @@ errval_t oct_set_get(oct_mode_t mode, char** record, const char* query, ...)
 errval_t oct_get_with_idcap(char **data, struct capref idcap)
 {
     assert(!capref_is_null(idcap));
-    errval_t error_code;
     errval_t err = SYS_ERR_OK;
-    octopus_trigger_id_t tid;
 
     struct octopus_thc_client_binding_t *cl = oct_get_thc_client();
     assert(cl != NULL);
-    err = cl->call_seq.get_with_idcap(cl, idcap, NOP_TRIGGER, data, &tid,
-                                      &error_code);
+    struct octopus_get_with_idcap_response__rx_args reply;
+    err = cl->call_seq.get_with_idcap(cl, idcap, NOP_TRIGGER, reply.output,
+                                      &reply.tid, &reply.error_code);
 
     if (err_is_ok(err)) {
-        err = error_code;
+        err = reply.error_code;
+    }
+
+    if (err_is_fail(err)) {
+        return err;
+    }
+
+    if (data) {
+        *data = strdup(reply.output);
     }
 
     return err;
@@ -292,12 +308,9 @@ errval_t oct_set_with_idcap(struct capref idcap, const char *attributes, ...)
     // Send to Server
     struct octopus_thc_client_binding_t *cl = oct_get_thc_client();
 
-    char *record = NULL;
     errval_t error_code;
-    octopus_trigger_id_t tid;
     err = cl->call_seq.set_with_idcap(cl, idcap, buf, SET_DEFAULT, NOP_TRIGGER,
-                                      false, &record, &tid, &error_code);
-    assert(record == NULL);
+                                      false, NULL, NULL, &error_code);
 
     if (err_is_ok(err)) {
         err = error_code;
@@ -332,8 +345,7 @@ errval_t oct_del(const char* query, ...)
 
     struct octopus_thc_client_binding_t* cl = oct_get_thc_client();
     errval_t error_code;
-    octopus_trigger_id_t tid;
-    err = cl->call_seq.del(cl, buf, NOP_TRIGGER, &tid, &error_code);
+    err = cl->call_seq.del(cl, buf, NOP_TRIGGER, NULL, &error_code);
     if (err_is_ok(err)) {
         err = error_code;
     }
@@ -364,8 +376,7 @@ errval_t oct_exists(const char* query, ...)
 
     struct octopus_thc_client_binding_t* cl = oct_get_thc_client();
     errval_t error_code;
-    octopus_trigger_id_t tid;
-    err = cl->call_seq.exists(cl, buf, NOP_TRIGGER, &tid, &error_code);
+    err = cl->call_seq.exists(cl, buf, NOP_TRIGGER, NULL, &error_code);
     if (err_is_ok(err)) {
         err = error_code;
     }
@@ -396,12 +407,20 @@ errval_t oct_wait_for(char** record, const char *query, ...)
 
     struct octopus_thc_client_binding_t* cl = oct_get_thc_client();
 
-    errval_t error_code;
-    err = cl->call_seq.wait_for(cl, buf, record, &error_code);
+    struct octopus_wait_for_response__rx_args reply;
+    err = cl->call_seq.wait_for(cl, buf, reply.record, &reply.error_code);
+    if (err_is_fail(err)) {
+        goto out;
+    }
+    err = reply.error_code;
+
     if (err_is_fail(err)) {
         goto out;
     }
-    err = error_code;
+
+    if (record) {
+        *record = strdup(reply.record);
+    }
 
 out:
     free(buf);
index 8101a32..fad5e1b 100644 (file)
@@ -47,14 +47,11 @@ errval_t oct_lock(const char* lock_name, char** lock_record)
     errval_t err = SYS_ERR_OK;
     errval_t exist_err;
     char** names = NULL;
-    char* record = NULL;
     char* name = NULL;
     size_t len = 0;
     size_t i = 0;
     bool found = false;
     uint64_t mode = 0;
-    uint64_t state = 0;
-    uint64_t fn = 0;
     octopus_trigger_id_t tid;
     octopus_trigger_t t = oct_mktrigger(SYS_ERR_OK, octopus_BINDING_RPC,
             OCT_ON_DEL, NULL, NULL);
@@ -64,6 +61,8 @@ errval_t oct_lock(const char* lock_name, char** lock_record)
     if (err_is_fail(err)) {
         goto out;
     }
+    /// XXX why is there a strdup ?
+    *lock_record = strdup(*lock_record);
     err = oct_read(*lock_record, "%s", &name);
     if (err_is_fail(err)) {
         goto out;
@@ -101,9 +100,8 @@ errval_t oct_lock(const char* lock_name, char** lock_record)
             }
 
             if (err_is_ok(exist_err)) {
-                err = cl->recv.trigger(cl, &tid, &fn, &mode, &record, &state);
+                err = cl->recv.trigger(cl, &tid, NULL, &mode, NULL, NULL);
                 assert(err_is_ok(err));
-                free(record);
                 assert(mode & OCT_REMOVED);
             }
             else if (err_no(exist_err) != OCT_ERR_NO_RECORD) {
index a76e49d..7269dc6 100644 (file)
@@ -46,7 +46,6 @@ void subscription_handler(struct octopus_binding *b, subscription_t id,
     else {
         fprintf(stderr, "Incoming subscription(%"PRIu64") for %s with unset handler function.",
                 id, record);
-        free(record);
     }
 }
 
index 3548891..10386e2 100644 (file)
@@ -88,8 +88,6 @@ errval_t oct_sem_post(uint32_t id)
 errval_t oct_sem_wait(uint32_t id)
 {
     errval_t err = SYS_ERR_OK;
-    char* result = NULL;
-    octopus_trigger_id_t tid;
     octopus_trigger_t t = oct_mktrigger(OCT_ERR_NO_RECORD,
             octopus_BINDING_RPC, OCT_ON_SET, NULL, NULL);
     struct octopus_thc_client_binding_t* cl = oct_get_thc_client();
@@ -103,12 +101,11 @@ errval_t oct_sem_wait(uint32_t id)
     // XXX: The current implementation suffers from a herd effect,
     // may be worth it to use locks for this critical section
     while (1) {
-        cl->call_seq.get(cl, query, t, &result, &tid, &err);
+        struct octopus_get_response__rx_args reply;
+        cl->call_seq.get(cl, query, t, reply.output, &reply.tid, &err);
 
         if (err_is_ok(err)) {
-            errval_t del_err = oct_del(result);
-            free(result);
-            result = NULL;
+            errval_t del_err = oct_del(reply.output);
 
             if (err_is_ok(del_err)) {
                 break; // Decreased successfully
@@ -123,17 +120,13 @@ errval_t oct_sem_wait(uint32_t id)
         }
         else if (err_no(err) == OCT_ERR_NO_RECORD) {
             // No record found, wait until one is posted
-            char* trigger_result = NULL;
-            uint64_t fn, mode, state;
-            cl->recv.trigger(cl, &tid, &fn, &mode, &trigger_result, &state);
-            free(trigger_result);
+            cl->recv.trigger(cl, NULL, NULL, NULL, NULL, NULL);
         }
         else {
             break; // Unexpected error
         }
     }
 
-    free(result);
     return err;
 }
 
index 86ef222..695837b 100644 (file)
@@ -41,7 +41,6 @@ void trigger_handler(struct octopus_binding* b, octopus_trigger_id_t id,
     else {
         fprintf(stderr, "Incoming trigger(%"PRIu64") for %s with unset handler function.",
                 id, record);
-        free(record);
     }
 }
 
@@ -101,9 +100,7 @@ errval_t oct_trigger_existing_and_watch(const char* query,
         trigger_handler_fn event_handler, void* state,
         octopus_trigger_id_t* tid)
 {
-    errval_t error_code;
     char** names = NULL;
-    char* output = NULL;
     char* record = NULL; // freed by cpu_change_event
     size_t len = 0;
     octopus_trigger_t t = oct_mktrigger(0, octopus_BINDING_EVENT,
@@ -111,16 +108,18 @@ errval_t oct_trigger_existing_and_watch(const char* query,
 
     // Get current cores registered in system
     struct octopus_thc_client_binding_t* rpc = oct_get_thc_client();
+
+    struct octopus_get_names_response__rx_args reply;
     errval_t err = rpc->call_seq.get_names(rpc, query,
-            t, &output, tid, &error_code);
+            t, reply.output, &reply.tid, &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
     }
-    err = error_code;
+    err = reply.error_code;
 
     switch(err_no(err)) {
     case SYS_ERR_OK:
-        err = oct_parse_names(output, &names, &len);
+        err = oct_parse_names(reply.output, &names, &len);
         if (err_is_fail(err)) {
             goto out;
         }
@@ -134,12 +133,10 @@ errval_t oct_trigger_existing_and_watch(const char* query,
                 break;
 
             case OCT_ERR_NO_RECORD:
-                assert(record == NULL);
                 break;
 
             default:
                 DEBUG_ERR(err, "Unable to retrieve core record for %s", names[i]);
-                assert(record == NULL);
                 break;
             }
         }
@@ -155,7 +152,6 @@ errval_t oct_trigger_existing_and_watch(const char* query,
 
 out:
     oct_free_names(names, len);
-    free(output);
 
     return err;
 }
index e12256a..68637f8 100644 (file)
@@ -70,8 +70,6 @@ void get_cap_handler(struct octopus_binding *b, char *key)
     ns->cap = cap;
     ns->error = reterr;
     ns->reply(b, ns);
-
-    free(key);
 }
 
 static void put_cap_reply(struct octopus_binding *b,
@@ -100,8 +98,9 @@ void put_cap_handler(struct octopus_binding *b, char *key,
         reterr = OCT_ERR_CAP_OVERWRITE;
         err = cap_delete(cap);
         assert(err_is_ok(err));
-        free(key);
     } else {
+        /* we need to make our own copy of the key */
+        key = strdup(key);
         int r = capdb->d.put_capability(&capdb->d, key, cap);
         assert(r == 0);
     }
@@ -147,8 +146,6 @@ void remove_cap_handler(struct octopus_binding *b, char *key)
     assert(err_is_ok(err));
     ns->error = reterr;
     ns->reply(b, ns);
-
-    free(key);
 }
 
 errval_t init_capstorage(void)
index 8087a56..8ec6f1b 100644 (file)
@@ -238,7 +238,6 @@ out:
     drs->reply(b, drs);
 
     free_ast(ast);
-    free(query);
 }
 
 static void get_names_reply(struct octopus_binding* b,
@@ -286,7 +285,6 @@ out:
     drs->reply(b, drs);
 
     free_ast(ast);
-    free(query);
 }
 
 static void set_reply(struct octopus_binding* b, struct oct_reply_state* drs)
@@ -344,7 +342,6 @@ out:
     drs->reply(b, drs);
 
     free_ast(ast);
-    free(query);
 }
 
 static errval_t build_query_with_idcap(char **query_p, struct capref idcap,
@@ -494,7 +491,6 @@ out:
     drs->reply(b, drs);
 
     free_ast(ast);
-    free(attributes);
     if (query != NULL) {
         free(query);
     }
@@ -550,7 +546,6 @@ out:
     drs->reply(b, drs);
 
     free_ast(ast);
-    free(query);
 }
 
 static void exists_reply(struct octopus_binding* b, struct oct_reply_state* drs)
@@ -595,7 +590,6 @@ out:
     drs->reply(b, drs);
 
     free_ast(ast);
-    free(query);
 }
 
 static void wait_for_reply(struct octopus_binding* b, struct oct_reply_state* drs)
@@ -634,7 +628,6 @@ void wait_for_handler(struct octopus_binding* b, char* query) {
     if (err_is_ok(err)) {
         err = get_record(ast, &drs->query_state);
         if (err_no(err) == OCT_ERR_NO_RECORD) {
-            debug_printf("waiting for: %s\n", query);
             uint64_t wid;
             set_watch_err = set_watch(b, ast, OCT_ON_SET, drs, &wid);
         }
@@ -651,7 +644,6 @@ out:
     }
 
     free_ast(ast);
-    free(query);
 }
 
 static void subscribe_reply(struct octopus_binding* b,
@@ -697,7 +689,6 @@ out:
     drs->reply(b, drs);
 
     free_ast(ast);
-    free(query);
 }
 
 static void unsubscribe_reply(struct octopus_binding* b,
@@ -862,7 +853,7 @@ void publish_handler(struct octopus_binding *b, char* record)
 out2:
     free_ast(ast);
 out1:
-    free(record);
+    return;
 }
 
 void get_identifier(struct octopus_binding* b)
index bab725f..00ac28c 100644 (file)
@@ -79,18 +79,18 @@ errval_t pci_register_driver_movable_irq(pci_driver_init_fn init_func, uint32_t
                                          interrupt_handler_fn reloc_handler,
                                          void *reloc_handler_arg)
 {
-    pci_caps_per_bar_t *caps_per_bar = NULL;
+    pci_caps_per_bar_t caps_per_bar;
     uint8_t nbars;
     errval_t err, msgerr;
 
     err = pci_client->vtbl.
         init_pci_device(pci_client, class, subclass, prog_if, vendor,
                         device, bus, dev, fun, &msgerr,
-                        &nbars, &caps_per_bar);
+                        &nbars, caps_per_bar, caps_per_bar + 1, caps_per_bar + 2,
+                        caps_per_bar + 3, caps_per_bar + 4, caps_per_bar + 5);
     if (err_is_fail(err)) {
         return err;
     } else if (err_is_fail(msgerr)) {
-        free(caps_per_bar);
         return msgerr;
     }
 
@@ -163,7 +163,7 @@ errval_t pci_register_driver_movable_irq(pci_driver_init_fn init_func, uint32_t
     for (int nb = 0; nb < nbars; nb++) {
         struct device_mem *bar = &bars[nb];
 
-        int ncaps = (*caps_per_bar)[nb];
+        int ncaps = (caps_per_bar)[nb];
         if (ncaps != 0) {
             bar->nr_caps = ncaps;
             bar->frame_cap = malloc(ncaps * sizeof(struct capref)); // FIXME: leak
@@ -210,7 +210,6 @@ errval_t pci_register_driver_movable_irq(pci_driver_init_fn init_func, uint32_t
     err = SYS_ERR_OK;
 
  out:
-    free(caps_per_bar);
     return err;
 }
 
index fb0de68..6e9a04a 100644 (file)
@@ -55,7 +55,6 @@ struct dirent *readdir(DIR* dir)
     }
 
     strncpy(dir->dirent.d_name, name, sizeof(dir->dirent.d_name));
-    free(name);
     dir->dirent.d_name[sizeof(dir->dirent.d_name) - 1] = '\0';
     return &dir->dirent;
 }
index 477a439..6d42f60 100644 (file)
@@ -464,15 +464,15 @@ iref_t posixcompat_pts_get_iref(int fd)
 static errval_t allocate_unique_number(uint32_t *np)
 {
     errval_t err;
-    char *record;
-    octopus_trigger_id_t tid;
 
     struct octopus_rpc_client *oc = get_octopus_rpc_client();
 
+    struct octopus_set_response__rx_args reply;
+
     /* request a system-wide unique number at octopus */
     char *query = PTY_PTS_OCTOPUS_PREFIX;
-    oc->vtbl.set(oc, query, SET_SEQUENTIAL, NOP_TRIGGER, true, &record, &tid,
-                 &err);
+    oc->vtbl.set(oc, query, SET_SEQUENTIAL, NOP_TRIGGER, true, reply.record,
+                 &reply.tid, &err);
     if (err_is_fail(err)) {
         goto finish;
     }
@@ -481,11 +481,10 @@ static errval_t allocate_unique_number(uint32_t *np)
      * Octpus returns the record in the form 'ptypts0 {}'. Extract unique
      * number.
      */
-    int ret = sscanf(record, PTY_PTS_OCTOPUS_PREFIX "%" PRIu32, np);
+    int ret = sscanf(reply.record, PTY_PTS_OCTOPUS_PREFIX "%" PRIu32, np);
     assert(ret == 1);
 
 finish:
-    free(record);
     return err;
 }
 
index 51e875a..852f0dd 100644 (file)
@@ -75,15 +75,47 @@ errval_t skb_client_connect(void)
 }
 
 /* ------------------------- evaluate ------------------------------ */
-errval_t skb_evaluate(char *query, char **result, char **str_error, int32_t *int_error)
+errval_t skb_evaluate(char *query, char **ret_result, char **ret_str_error, int32_t *int_error)
 {
     errval_t err;
     struct skb_state *skb_state = get_skb_state();
 
-    err = skb_state->skb->vtbl.run(skb_state->skb, query, result, str_error,
-                                   int_error);
+    // allocate memory for holding the response data
+    char *result = NULL;
+    if (ret_result) {
+        result = malloc(skb__run_response_output_MAX_ARGUMENT_SIZE);
+        if (result == NULL) {
+            return LIB_ERR_MALLOC_FAIL;
+        }
+    }
+    char *str_error = NULL;
+    if (ret_str_error) {
+        str_error = malloc(skb__run_response_str_error_MAX_ARGUMENT_SIZE);
+        if (str_error == NULL) {
+            if (result) {
+                free(result);
+            }
+            return LIB_ERR_MALLOC_FAIL;
+        }
+    }
+    err = skb_state->skb->vtbl.run(skb_state->skb, query, result,
+                                   str_error, int_error);
     if (err_is_fail(err)) {
+        if (result) {
+            free(result);
+        }
+        if (str_error) {
+            free(str_error);
+        }
         return err_push(err, SKB_ERR_RUN);
     }
+
+    if (ret_result) {
+        *ret_result = result;
+    }
+    if (ret_str_error) {
+        *ret_str_error = str_error;
+    }
+
     return SYS_ERR_OK;
 }
index 323bf8e..f1532df 100644 (file)
 #include <string.h>
 #include <barrelfish/barrelfish.h>
 #include <skb/skb.h>
+#include <if/skb_rpcclient_defs.h>
+#include <barrelfish/core_state_arch.h>
 #include "skb_debug.h"
 
-#define BUFFER_SIZE SKB_REPLY_BUF_SIZE
-#define OUTPUT_SIZE SKB_REPLY_BUF_SIZE
+#define BUFFER_SIZE skb__run_call_input_MAX_ARGUMENT_SIZE
+#define OUTPUT_SIZE skb__run_response_output_MAX_ARGUMENT_SIZE
 
 /* XXX: The following static chars make the skb connection not thread
    safe and we probably don't want to put them in the per dispatcher
    corestate as they are so big. */
-static char buffer[BUFFER_SIZE];
-static char output[OUTPUT_SIZE];
-static char error_output[OUTPUT_SIZE];
+static char buffer[skb__run_call_input_MAX_ARGUMENT_SIZE + 1];
+static char output[skb__run_response_output_MAX_ARGUMENT_SIZE + 1];
+static char error_output[skb__run_response_str_error_MAX_ARGUMENT_SIZE + 1];
 static int error_code;
 
 int skb_read_error_code(void)
@@ -46,20 +48,19 @@ char *skb_get_error_output(void)
 
 errval_t skb_execute(char *goal)
 {
-    int32_t error;
-    char *result, *error_out;
-    errval_t err = skb_evaluate(goal, &result, &error_out, &error);
+    errval_t err;
+    struct skb_state *skb_state = get_skb_state();
+
+    err = skb_state->skb->vtbl.run(skb_state->skb, goal, output,
+            error_output, &error_code);
     if (err_is_fail(err)) {
-        return err_push(err, SKB_ERR_EVALUATE);
+        return err_push(err, SKB_ERR_RUN);
     }
-    error_code = error;
-    strncpy(output, result, OUTPUT_SIZE);
-    strncpy(error_output, error_out, OUTPUT_SIZE);
-    free(result);
-    free(error_out);
-    if (error != 0) {
+
+    if (error_code != 0) {
         return err_push(err, SKB_ERR_EXECUTION);
     }
+
     return err;
 }
 
index 7a21ae4..31cd742 100644 (file)
@@ -259,15 +259,13 @@ errval_t spawn_symval_lookup(const char *binary,
         }
     }
 
-    char* record = NULL;
-    octopus_trigger_id_t tid;
-    errval_t error_code;
+    struct octopus_get_response__rx_args reply;
     err = r->vtbl.get(r, omp_entry, NOP_TRIGGER,
-                      &record, &tid, &error_code);
+                      reply.output, &reply.tid, &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
     }
-    err = error_code;
+    err = reply.error_code;
     if (err_is_fail(err)) {
         if (err_no(err) == OCT_ERR_NO_RECORD) {
             err = err_push(err, LIB_ERR_NAMESERVICE_UNKNOWN_NAME);
@@ -277,7 +275,7 @@ errval_t spawn_symval_lookup(const char *binary,
 
     uint64_t addr = 0;
     char *symname = NULL;
-    err = oct_read(record, "_ { sym: %s, addr: %d }", &symname, &addr);
+    err = oct_read(reply.output, "_ { sym: %s, addr: %d }", &symname, &addr);
     if (err_is_fail(err) || symname == NULL) {
         err = err_push(err, LIB_ERR_NAMESERVICE_INVALID_NAME);
         goto out;
@@ -289,7 +287,7 @@ errval_t spawn_symval_lookup(const char *binary,
         *ret_name = strdup(symname);
     }
 
-    out: free(record);
+    out:
     free(omp_entry);
     return err;
 }
@@ -336,19 +334,17 @@ errval_t spawn_symval_register(const char *binary,
         }
     }
 
-    char* ret = NULL;
     octopus_trigger_id_t tid;
     errval_t error_code;
     err = r->vtbl.set(r, record, 0, NOP_TRIGGER,
-                      0, &ret, &tid, &error_code);
+                      0, NULL, &tid, &error_code);
     if (err_is_fail(err)) {
         goto out;
     }
     err = error_code;
 
 out: 
-       free(record);
-       
+    free(record);
     return err;
 }
 
index 9f4be43..10babde 100644 (file)
@@ -269,9 +269,7 @@ errval_t term_client_blocking_write(struct term_client *client,
     }
 
     /* Make a copy of characters, since the output filters might modify them. */
-    outdata = malloc(length);
-    assert(outdata != NULL);
-    memcpy(outdata, data, length);
+    outdata = memdup(data, length);
 
     /* tell user how much we've written (before applying filters) */
     *written = length;
@@ -340,7 +338,7 @@ errval_t term_client_blocking_config(struct term_client *client,
                 term_filter_id_t id = term_client_add_input_filter(client, term_filter_cr2lf);
                 client->cr2lf_id = id;
             }
-            
+
             return SYS_ERR_OK;
         }
         break;
@@ -370,7 +368,7 @@ errval_t term_client_blocking_config(struct term_client *client,
 
 }
 
-errval_t term_client_blocking_tcgetattr(struct term_client *client, 
+errval_t term_client_blocking_tcgetattr(struct term_client *client,
                                         struct termios* t)
 {
     if (client->cr2lf_id > 0) {
@@ -383,7 +381,7 @@ errval_t term_client_blocking_tcgetattr(struct term_client *client,
     return SYS_ERR_OK;
 }
 
-errval_t term_client_blocking_tcsetattr(struct term_client *client, 
+errval_t term_client_blocking_tcsetattr(struct term_client *client,
                                         const struct termios* t)
 {
     errval_t err = term_client_blocking_config(client, TerminalConfig_ECHO, (t->c_lflag & ECHO) > 0);
@@ -472,16 +470,15 @@ static errval_t get_irefs(struct capref session_id, iref_t *in_iref,
     struct octopus_rpc_client *r = get_octopus_rpc_client();
     assert(r != NULL);
 
-    char *record;
-    errval_t error_code;
-    octopus_trigger_id_t tid;
-    err = r->vtbl.get_with_idcap(r, session_id, NOP_TRIGGER, &record, &tid,
-                                 &error_code);
+    struct octopus_get_with_idcap_response__rx_args reply;
+
+    err = r->vtbl.get_with_idcap(r, session_id, NOP_TRIGGER, reply.output, &reply.tid,
+                                 &reply.error_code);
     if (err_is_fail(err)) {
         err_push(err, TERM_ERR_LOOKUP_SESSION_RECORD);
         goto out;
     }
-    err = error_code;
+    err = reply.error_code;
     if (err_is_fail(err)) {
         err_push(err, TERM_ERR_LOOKUP_SESSION_RECORD);
         goto out;
@@ -495,7 +492,7 @@ static errval_t get_irefs(struct capref session_id, iref_t *in_iref,
     int64_t conf_oct;
     // oct_read can only parse 64-bit values, we need to parse the irefs as 64bit
     // then cast to 32bit
-    err = oct_read(record, "_ { session_iref: %d, in_iref: %d, out_iref: %d, "
+    err = oct_read(reply.output, "_ { session_iref: %d, in_iref: %d, out_iref: %d, "
                    "conf_iref: %d }", &session_oct, &in_oct, &out_oct,
                     &conf_oct);
     //iref_t session_iref = (iref_t)session_oct;
@@ -517,7 +514,6 @@ static errval_t get_irefs(struct capref session_id, iref_t *in_iref,
                "\n", *in_iref, *out_iref, *conf_iref);
 
 out:
-    free(record);
     return err;
 }
 
@@ -554,9 +550,7 @@ static errval_t handle_echo(struct term_client *client, char *data,
      * Make a copy of the data, since the echo filters might modify it and the
      * modification should not be seen by the application.
      */
-    echodata = malloc(length);
-    assert(echodata != NULL);
-    memcpy(echodata, data, length);
+    echodata = memdup(data, length);
 
     /* apply echo filters */
     term_filter_apply(client->echo_filters, &echodata, &length);
@@ -607,22 +601,25 @@ static void in_characters_handler(struct terminal_binding *b, char *data,
 {
     struct term_client *client = b->st;
 
+
+    char *my_data = memdup(data, length);
+
     if (client->non_blocking_read) {
         assert(client->chars_cb != NULL);
 
         /* handle triggers */
-        handle_triggers(client, data, length);
+        handle_triggers(client, my_data, length);
 
         /* filter input */
-        term_filter_apply(client->input_filters, &data, &length);
+        term_filter_apply(client->input_filters, &my_data, &length);
 
         /* call user supplied chars_cb */
-        client->chars_cb(client->st, data, length);
+        client->chars_cb(client->st, my_data, length);
     } else {
         assert(client->readbuf == NULL);
 
-        client->readbuf = data;
-        client->readbuf_pos = data;
+        client->readbuf = my_data;
+        client->readbuf_pos = my_data;
         client->readbuf_len = length;
     }
 }
index 0f10ebb..af687c1 100644 (file)
@@ -154,12 +154,12 @@ usb_error_t usb_lib_init(uint8_t init_config)
 
     uint32_t ret_status;
 
-    uint8_t *tmp;
+    uint8_t tmp[2048];
     size_t length;
 
     /* connect with the USB Manager */
     err = usb_manager.vtbl.connect(&usb_manager, usb_driver_iref, init_config,
-            &ret_status, &tmp, &length);
+            &ret_status, tmp, &length);
 
     if (((usb_error_t) ret_status) != USB_ERR_OK) {
         debug_printf("libusb: ERROR connecting to the USB manager\n");
@@ -180,7 +180,6 @@ usb_error_t usb_lib_init(uint8_t init_config)
 
     /*
      * initialize the devices with the descriptors
-     * Do not free the tmp, since the data is still used by the descriptors
      */
     usb_device_init(tmp);
 
index 9de085d..0df5afc 100644 (file)
@@ -647,14 +647,14 @@ usb_error_t usb_do_request_read(struct usb_device_request *req,
 {\r
     errval_t err;\r
     uint32_t ret_status = 0;\r
-    uint8_t *data = NULL;\r
+    uint8_t data[2048];\r
     size_t length = 0;\r
     usb_error_t ret;\r
 \r
     USB_DEBUG_IDC("libusb: usb_do_request_read()\n");\r
 \r
     err = usb_manager.vtbl.request_read(&usb_manager, (uint8_t*) req,\r
-            sizeof(*req), (uint8_t **) &data, &length, &ret_status);\r
+            sizeof(*req), data, &length, &ret_status);\r
 \r
     *ret_length = length;\r
 \r
@@ -670,7 +670,7 @@ usb_error_t usb_do_request_read(struct usb_device_request *req,
 \r
     USB_DEBUG_IDC("libusb: usb_do_request_read() got data (len=%i)\n", *ret_length);\r
 \r
-    *ret_data = (void *) data;\r
+    *ret_data = memdup(data, sizeof(data));\r
 \r
     return (ret);\r
 }\r
index 03f16b5..d8683a5 100644 (file)
@@ -304,23 +304,20 @@ static void ahci_mgmt_bind_cb(void *st, errval_t err, struct ahci_mgmt_binding *
 
     ahci_mgmt_bound = true;
 
-    // populate list
-    uint8_t *port_ids;
-    size_t len;
-
-    err = ahci_mgmt_rpc.vtbl.list(&ahci_mgmt_rpc, &port_ids, &len);
+    struct ahci_mgmt_list_response__rx_args reply;
+    err = ahci_mgmt_rpc.vtbl.list(&ahci_mgmt_rpc, reply.port_ids, &reply.len);
     assert(err_is_ok(err));
 
-    for (size_t i = 0; i < len; i++) {
-        uint8_t *data;
-        size_t identifylen = 0;
+    for (size_t i = 0; i < reply.len; i++) {
+        struct ahci_mgmt_identify_response__rx_args identify_reply;
         err = ahci_mgmt_rpc.vtbl.identify(&ahci_mgmt_rpc,
-                port_ids[i], &data, &identifylen);
+                reply.port_ids[i], identify_reply.identify_data,
+                &identify_reply.data_len);
         assert(err_is_ok(err));
-        assert(identifylen == 512);
+        assert(identify_reply.data_len == 512);
 
         ata_identify_t identify;
-        ata_identify_initialize(&identify, (void *)data);
+        ata_identify_initialize(&identify, (void *)identify_reply.identify_data );
 
         //char buf[8192];
         //ata_identify_pr(buf, 8192, &identify);
@@ -340,7 +337,7 @@ static void ahci_mgmt_bind_cb(void *st, errval_t err, struct ahci_mgmt_binding *
                 port_ids[i], sectors, sector_size);
 
         struct ahci_handle *handle = calloc(1, sizeof(struct ahci_handle));
-        handle->port_num = port_ids[i];
+        handle->port_num = reply.port_ids[i];
 
         struct blockdev_entry *newentry = calloc(1, sizeof(struct blockdev_entry));
         newentry->open = false;
index c51ca3d..e62b3f7 100644 (file)
@@ -163,11 +163,8 @@ errval_t blockdevfs_ata_read(void *handle, size_t pos, void *buffer,
 
     //VFS_BLK_DEBUG("bdfs_ahci: read begin: %zu -> %zu\n", bytes, aligned_bytes);
 
-    uint8_t *data;
     err = h->ata_rw28_rpc.vtbl.read_dma(&h->ata_rw28_rpc,
-            aligned_bytes, blockpos, &data, bytes_read);
-    memcpy(buffer, data, *bytes_read);
-    free(data);
+            aligned_bytes, blockpos, buffer, bytes_read);
 
     return err;
 }
@@ -203,25 +200,23 @@ static void ahci_mgmt_bind_cb(void *st, errval_t err, struct ahci_mgmt_binding *
     ahci_mgmt_bound = true;
 
     // populate list
-    uint8_t *port_ids;
-    size_t len;
-
-    err = ahci_mgmt_rpc.vtbl.list(&ahci_mgmt_rpc, &port_ids, &len);
+    struct ahci_mgmt_list_response__rx_args reply;
+    err = ahci_mgmt_rpc.vtbl.list(&ahci_mgmt_rpc, reply.port_ids, &reply.len);
     assert(err_is_ok(err));
 
-    for (size_t i = 0; i < len; i++) {
+    for (size_t i = 0; i < reply.len; i++) {
         if (i > 9) {
             break;
         }
-        uint8_t *data;
-        size_t identifylen = 0;
-        err = ahci_mgmt_rpc.vtbl.identify(&ahci_mgmt_rpc,
-                port_ids[i], &data, &identifylen);
+        struct ahci_mgmt_identify_response__rx_args identify_reply;
+        err = ahci_mgmt_rpc.vtbl.identify(&ahci_mgmt_rpc, reply.port_ids[i],
+                                          identify_reply.identify_data,
+                                          &identify_reply.data_len);
         assert(err_is_ok(err));
-        assert(identifylen == 512);
+        assert(identify_reply.data_len == 512);
 
         ata_identify_t identify;
-        ata_identify_initialize(&identify, (void *)data);
+        ata_identify_initialize(&identify, (void *)identify_reply.identify_data);
 
         //char buf[8192];
         //ata_identify_pr(buf, 8192, &identify);
@@ -241,7 +236,7 @@ static void ahci_mgmt_bind_cb(void *st, errval_t err, struct ahci_mgmt_binding *
                 port_ids[i], sectors, sector_size);
 
         struct ata_handle *handle = calloc(1, sizeof(struct ata_handle));
-        handle->port_num = port_ids[i];
+        handle->port_num = reply.port_ids[i];
 
         struct blockdev_entry *newentry = calloc(1, sizeof(struct blockdev_entry));
         newentry->open = false;
index e838d11..20d6dd6 100644 (file)
@@ -170,8 +170,9 @@ acquire_or_read(struct fat_mount *mount, struct fs_cache *cache,
     }
     else if (err == FS_CACHE_NOTPRESENT) {
         size_t read_size;
+        data_ = malloc(size);
         err = mount->ata_rw28_rpc.vtbl.read_dma(&mount->ata_rw28_rpc,
-                size, block, &data_, &read_size);
+                size, block, data_, &read_size);
         if (err_is_fail(err)) {
             return err;
         }
@@ -1190,12 +1191,11 @@ vfs_fat_mount(const char *uri, void **retst, struct vfs_ops **retops)
 
     FAT_DEBUG("ata_rw28 initialized.\n");
 #endif
-
-    // read data from fat boot sector
-    uint8_t *data;
     size_t size;
+    // read data from fat boot sector
+    uint8_t *data = malloc(ata_rw28__read_dma_block_response_buffer_MAX_ARGUMENT_SIZE);
     err = mount->ata_rw28_rpc.vtbl.read_dma_block(&mount->ata_rw28_rpc,
-            mount->startblock, &data, &size);
+            mount->startblock, mount->bootsec_data, &size);
     if (err_is_fail(err)) {
         goto bootsec_read_failed;
     }
@@ -1213,8 +1213,7 @@ vfs_fat_mount(const char *uri, void **retst, struct vfs_ops **retops)
     }
     FAT_DEBUG("end sector 0 dump");
 #endif
-    memcpy(mount->bootsec_data, data, size);
-    free(data);
+
     data = NULL;
 
     if (memcmp(mount->bootsec_data+0x1FE, "\x55\xAA", 2) != 0) {
@@ -1295,28 +1294,29 @@ vfs_fat_mount(const char *uri, void **retst, struct vfs_ops **retops)
                     mount->block_count);
             goto fs_check_failed;
         }
+        struct ata_rw28_read_dma_block_response__rx_args reply;
         mount->ata_rw28_rpc.vtbl.read_dma_block(&mount->ata_rw28_rpc,
-                mount->startblock + fs_info_sector, &data, &size);
-        if (memcmp(data+0, "RRaA", 4) != 0 ||
-            memcmp(data+0x1e4, "rrAa", 4) != 0)
+                mount->startblock + fs_info_sector, reply.buffer ,
+                &reply.buffer_size);
+        if (memcmp(reply.buffer+0, "RRaA", 4) != 0 ||
+            memcmp(reply.buffer+0x1e4, "rrAa", 4) != 0)
         {
             FAT_DEBUG_F("File System Information Sector signatures do not match,"
-                    " %"PRIx32", %"PRIx32, *(uint32_t*)(data+0),
-                    *(uint32_t*)(data+0x1e4));
+                    " %"PRIx32", %"PRIx32, *(uint32_t*)(reply.buffer+0),
+                    *(uint32_t*)(reply.buffer+0x1e4));
             goto fs_check_failed;
         }
-        if (memcmp(data+0x1fe, "\x55\xAA", 2) != 0) {
+        if (memcmp(reply.buffer+0x1fe, "\x55\xAA", 2) != 0) {
             FAT_DEBUG("File System Information Sector check bytes do not match");
             goto fs_check_failed;
         }
 #ifdef FAT_DEBUG_ENABLED
         FAT_DEBUG("dumping FSIS");
-        printf("nr of free clusters: %"PRIu32"\n", *(uint32_t*)(data+0x1e8));
+        printf("nr of free clusters: %"PRIu32"\n", *(uint32_t*)(reply.buffer+0x1e8));
         printf("most recently allocated cluster: %"PRIu32"\n",
-                *(uint32_t*)(data+0x1ec));
+                *(uint32_t*)(reply.buffer+0x1ec));
         printf("----------------\n");
 #endif
-        free(data);
         data = NULL;
     }
 
index 203fac8..d4b7a5e 100644 (file)
@@ -236,16 +236,13 @@ static errval_t read(void *st, vfs_handle_t handle, void *buffer, size_t bytes,
 
     assert(!h->isdir);
 
-    uint8_t *mybuf = NULL;
-
 restart:
     err = cl->rpc.vtbl.read(&cl->rpc, h->fh, h->pos, bytes,
-                            &msgerr, &mybuf, bytes_read);
+                            &msgerr, buffer, bytes_read);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "transport error in read");
         return err;
     } else if (err_is_fail(msgerr)) {
-        assert(mybuf == NULL);
         if (err_no(msgerr) == FS_ERR_INVALID_FH && !restarts++) {
             // revalidate handle and try again
             msgerr = resolve_path(cl, h->path, &h->fh, NULL, NULL);
@@ -258,8 +255,6 @@ restart:
     }
 
     h->pos += *bytes_read;
-    memcpy(buffer, mybuf, *bytes_read);
-    free(mybuf);
 
     if (*bytes_read < bytes) { // XXX: this can only mean EOF for ramfs
         return VFS_ERR_EOF;
@@ -586,23 +581,21 @@ static errval_t dir_read_next(void *st, vfs_handle_t inhandle, char **retname,
 {
     struct ramfs_handle *h = inhandle;
     struct ramfs_client *cl = st;
-    char *name;
-    trivfs_fsize_t size;
-    bool isdir;
-    errval_t err, msgerr;
+
+    errval_t err;
     int restarts = 0;
 
     assert(h->isdir);
 
+    struct trivfs_readdir_response__rx_args reply;
 restart:
     err = cl->rpc.vtbl.readdir(&cl->rpc, h->fh, h->pos,
-                               &msgerr, &name, &isdir, &size);
+                               &reply.err, reply.name, &reply.isdir, &reply.size);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "transport error in readdir");
         return err;
-    } else if (err_is_fail(msgerr)) {
-        assert(name == NULL);
-        if (err_no(msgerr) == FS_ERR_INVALID_FH && !restarts++) {
+    } else if (err_is_fail(reply.err)) {
+        if (err_no(reply.err) == FS_ERR_INVALID_FH && !restarts++) {
             // revalidate handle and try again
             if (h->fh == cl->rootfh) { // XXX: revalidate root
                 err = cl->rpc.vtbl.getroot(&cl->rpc, &cl->rootfh);
@@ -612,27 +605,27 @@ restart:
                 h->fh = cl->rootfh;
                 goto restart;
             } else {
-                msgerr = resolve_path(cl, h->path, &h->fh, NULL, NULL);
-                if (err_is_ok(msgerr)) {
+                reply.err = resolve_path(cl, h->path, &h->fh, NULL, NULL);
+                if (err_is_ok(reply.err)) {
                     goto restart;
                 }
             }
         }
-        if (err_no(msgerr) != FS_ERR_INDEX_BOUNDS) {
-            DEBUG_ERR(msgerr, "server error in readdir");
+        if (err_no(reply.err) != FS_ERR_INDEX_BOUNDS) {
+            DEBUG_ERR(reply.err, "server error in readdir");
         }
-        return msgerr;
+        return reply.err;
     }
 
     h->pos++;
 
     if (retname != NULL) {
-        *retname = name;
+        *retname = strdup(reply.name);
     }
 
     if (info != NULL) {
-        info->type = isdir ? VFS_DIRECTORY : VFS_FILE;
-        info->size = size;
+        info->type = reply.isdir ? VFS_DIRECTORY : VFS_FILE;
+        info->size = reply.size;
     }
 
     return SYS_ERR_OK;
index 8226ef6..d3f8855 100644 (file)
@@ -101,14 +101,12 @@ errval_t xeon_phi_domain_lookup(const char *iface,
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
 
-    char* record = NULL;
-    octopus_trigger_id_t tid;
-    errval_t error_code;
-    err = r->vtbl.get(r, iface, NOP_TRIGGER, &record, &tid, &error_code);
+    struct octopus_get_response__rx_args reply;
+    err = r->vtbl.get(r, iface, NOP_TRIGGER, reply.output, &reply.tid, &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
     }
-    err = error_code;
+    err = reply.error_code;
     if (err_is_fail(err)) {
         if (err_no(err) == OCT_ERR_NO_RECORD) {
             err = err_push(err, XEON_PHI_ERR_CLIENT_DOMAIN_VOID);
@@ -117,7 +115,7 @@ errval_t xeon_phi_domain_lookup(const char *iface,
     }
 
     xphi_dom_id_t domid = 0;
-    err = oct_read(record, "_ { domid: %d }", &domid);
+    err = oct_read(reply.output, "_ { domid: %d }", &domid);
     if (err_is_fail(err) || domid == 0) {
         err = err_push(err, XEON_PHI_ERR_CLIENT_DOMAIN_VOID);
         goto out;
@@ -127,8 +125,7 @@ errval_t xeon_phi_domain_lookup(const char *iface,
         *retdomid = domid;
     }
 
-    out: free(record);
-
+    out:
     return err;
 #endif
 }
@@ -152,13 +149,12 @@ errval_t xeon_phi_domain_blocking_lookup(const char *iface,
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
 
-    char* record = NULL;
-    errval_t error_code;
-    err = r->vtbl.wait_for(r, iface, &record, &error_code);
+    struct octopus_wait_for_response__rx_args reply;
+    err = r->vtbl.wait_for(r, iface, reply.record, &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
     }
-    err = error_code;
+    err = reply.error_code;
     if (err_is_fail(err)) {
         if (err_no(err) == OCT_ERR_NO_RECORD) {
             err = err_push(err, XEON_PHI_ERR_CLIENT_DOMAIN_VOID);
@@ -167,7 +163,7 @@ errval_t xeon_phi_domain_blocking_lookup(const char *iface,
     }
 
     xphi_dom_id_t domid = 0;
-    err = oct_read(record, "_ { domid: %d }", &domid);
+    err = oct_read(reply.record, "_ { domid: %d }", &domid);
     if (err_is_fail(err)) {
         err = err_push(err, XEON_PHI_ERR_CLIENT_DOMAIN_VOID);
         goto out;
@@ -177,7 +173,6 @@ errval_t xeon_phi_domain_blocking_lookup(const char *iface,
     }
 
     out:
-    free(record);
     return err;
 #endif
 }
@@ -210,10 +205,9 @@ errval_t xeon_phi_domain_register(const char *iface,
     }
     snprintf(record, len+1, format, iface, domid);
 
-    char* ret = NULL;
     octopus_trigger_id_t tid;
     errval_t error_code;
-    err = r->vtbl.set(r, record, 0, NOP_TRIGGER, 0, &ret, &tid, &error_code);
+    err = r->vtbl.set(r, record, 0, NOP_TRIGGER, 0, NULL, &tid, &error_code);
     if (err_is_fail(err)) {
         goto out;
     }
index 249c9ce..22818bc 100644 (file)
@@ -685,8 +685,7 @@ rx_handler arch ifn typedefs msgdefs msgs =
             C.SComment "unmarshall message number from first word, set fragment to 0",
             C.Ex $ C.Assignment rx_msgnum_field $
                 C.Binary C.BitwiseAnd (C.SubscriptOf msgwords $ C.NumConstant 0) msgnum_mask,
-            C.Ex $ C.Assignment rx_msgfrag_field (C.NumConstant 0),
-            C.Ex $ C.Assignment binding_incoming_token (C.Binary C.BitwiseAnd (C.Binary C.RightShift (C.SubscriptOf msgwords $ C.NumConstant 0) (C.NumConstant (toInteger msgnum_bits))) (C.HexConstant 0xffffffff))
+            C.Ex $ C.Assignment rx_msgfrag_field (C.NumConstant 0)
         ] [],
         C.SBlank,
 
index 7c7dd6e..f5aca6a 100644 (file)
@@ -56,14 +56,13 @@ type FragmentWord = [ArgFieldFragment]
 -- a (possibly larger) message argument, by type, qualified name and bit offset
 data ArgFieldFragment = ArgFieldFragment TypeBuiltin ArgField Int
                       | MsgCode -- implicit argument, occurs once per message
-                      | Token
                       deriving (Show, Eq)
 
 -- an argument field names the lowest-level field of an argument
 -- each entry in the list is a field name and (optional) array index
 -- eg. foo[3].bar is [NamedField "foo", ArrayField 3, NamedField "bar"]
 type ArgField = [ArgFieldElt]
-data ArgFieldElt = NamedField String | ArrayField Integer
+data ArgFieldElt = NamedField String | ArrayField Integer | TokenField
     deriving (Show, Eq)
 
 -- modes of transfering a cap
@@ -89,8 +88,6 @@ data FieldFragment = FieldFragment ArgFieldFragment
 msg_code_type :: TypeBuiltin
 msg_code_type = UInt16
 
-msg_code_token :: TypeBuiltin
-msg_code_token = UInt32
 
 build_msg_spec :: Arch -> Int -> Bool -> [TypeDef] -> MessageDef -> MsgSpec
 build_msg_spec arch words_per_frag contains_msgcode types (Message _ mn args _)
@@ -107,9 +104,9 @@ build_msg_spec arch words_per_frag contains_msgcode types (Message _ mn args _)
 
 -- build an LMP message spec by merging in the caps from a UMP spec
 build_lmp_msg_spec :: Arch -> [TypeDef] -> MessageDef -> LMPMsgSpec
-build_lmp_msg_spec arch types msgdef = LMPMsgSpec mn (merge_caps frags caps)
+build_lmp_msg_spec arch types (Message msgt msgn args msgm) = LMPMsgSpec mn (merge_caps frags caps)
     where
-        MsgSpec mn frags caps = build_msg_spec arch (lmp_words arch) True types msgdef
+        MsgSpec mn frags caps = build_msg_spec arch (lmp_words arch) True types (Message msgt msgn (Arg (Builtin UInt32) Token:args) msgm)
 
         -- XXX: ensure that we never put a cap together with an overflow fragment
         -- even though this could work at the transport-level, the current
@@ -141,7 +138,7 @@ find_msg_fragments arch words_per_frag contains_msgcode frags
     where
         -- does the first fragment need to contain the message code?
         first_frag
-            | contains_msgcode = MsgFragment [[MsgCode, Token]]
+            | contains_msgcode = MsgFragment [[MsgCode]]
             | otherwise        = MsgFragment []
 
         group_frags :: [FieldFragment] -> MsgFragment -> [MsgFragment]
@@ -182,6 +179,7 @@ build_field_fragments arch types args = concat $ map arg_fragments args
             | t `elem` [UInt8, Int8, Char]
                 = [OverflowField $ BufferFragment t [NamedField n] [NamedField l]]
             | otherwise = error "dynamic arrays of types other than char/int8/uint8 are not yet supported"
+        arg_fragments (Arg (Builtin b) Token) = fragment_builtin [TokenField] b
         arg_fragments (Arg (Builtin b) v) = fragment_builtin [NamedField (varname v)] b
         arg_fragments (Arg (TypeVar t) v) =
             fragment_typedef [NamedField (varname v)] (lookup_type_name types t)
@@ -220,8 +218,6 @@ bitsizeof_argfieldfrag a (ArgFieldFragment t _ _)
     = min (wordsize a) (bitsizeof_builtin a t)
 bitsizeof_argfieldfrag a MsgCode
     = bitsizeof_builtin a msg_code_type
-bitsizeof_argfieldfrag a Token
-    = bitsizeof_builtin a msg_code_token
 
 bitsizeof_builtin :: Arch -> TypeBuiltin -> Int
 bitsizeof_builtin _ UInt8 = 8
@@ -252,6 +248,8 @@ bitsizeof_builtin _ GiveAwayCap = undefined
 argfield_expr :: Direction -> String -> ArgField -> C.Expr
 argfield_expr TX mn [NamedField n] = tx_union_elem mn n
 argfield_expr RX mn [NamedField n] = rx_union_elem mn n
+argfield_expr TX mn [TokenField] = C.DerefField bindvar "outgoing_token"
+argfield_expr RX mn [TokenField] = C.DerefField bindvar "incoming_token"
 argfield_expr _ _ [ArrayField n] = error "invalid; top-level array"
 argfield_expr dir mn ((NamedField n):rest)
     = C.FieldOf (argfield_expr dir mn rest) n
@@ -277,7 +275,6 @@ fragment_word_to_expr arch ifn mn frag = mkwordexpr 0 frag
 
         mkfieldexpr :: ArgFieldFragment -> C.Expr
         mkfieldexpr MsgCode = C.Variable $ msg_enum_elem_name ifn mn
-        mkfieldexpr Token = C.DerefField bindvar "outgoing_token"
         mkfieldexpr (ArgFieldFragment t af 0) = fieldaccessor t af
         mkfieldexpr (ArgFieldFragment t af off) =
             C.Binary C.RightShift (fieldaccessor t af) (C.NumConstant $ toInteger off)
@@ -293,8 +290,6 @@ store_arg_frags :: Arch -> String -> String -> C.Expr -> Int -> Int -> [ArgField
 store_arg_frags _ _ _ _ _ _ [] = []
 store_arg_frags arch ifn mn msgdata_ex word bitoff (MsgCode:rest)
     = store_arg_frags arch ifn mn msgdata_ex word (bitoff + bitsizeof_argfieldfrag arch MsgCode) rest
-store_arg_frags arch ifn mn msgdata_ex word bitoff (Token:rest)
-    = store_arg_frags arch ifn mn msgdata_ex word (bitoff + bitsizeof_argfieldfrag arch Token) rest
 store_arg_frags _ _ _ _ _ _ ((ArgFieldFragment String _ _):_)
     = error "strings are not handled here"
 store_arg_frags arch ifn mn msgdata_ex word bitoff (aff@(ArgFieldFragment t af argoff):rest)
index dd2c03e..d1b6d41 100644 (file)
@@ -235,7 +235,6 @@ m_fragment_word_to_expr arch ifn mn frag = mkwordexpr 0 frag
 
         mkfieldexpr :: ArgFieldFragment -> C.Expr
         mkfieldexpr MsgCode = C.Variable $ msg_enum_elem_name ifn mn
-        mkfieldexpr Token = C.DerefField bindvar "outgoing_token"
         mkfieldexpr (ArgFieldFragment t af 0) = fieldaccessor t af
         mkfieldexpr (ArgFieldFragment t af off) =
             C.Binary C.RightShift (fieldaccessor t af) (C.NumConstant $ toInteger off)
index 4919c5b..1569cf3 100644 (file)
@@ -305,6 +305,7 @@ the @identifier@ of the argument:
 > data Variable = Name String
 >               | StringArray String Integer
 >               | DynamicArray String String Integer
+>               | Token
 >     deriving (Show)
 >
 > arg, (.@.) :: TypeRef -> String -> MessageArgument
index 30b8fc7..8322a30 100644 (file)
@@ -168,8 +168,6 @@ static void read_irq_table(struct acpi_binding* b, char* pathname,
                 ACPI_ERR_INVALID_PATH_NAME, NULL);
         assert(err_is_ok(err));
     }
-
-    free(pathname);
 }
 
 static void set_device_irq(struct acpi_binding *b, char* device, uint32_t irq)
@@ -224,8 +222,6 @@ static void set_device_irq(struct acpi_binding *b, char* device, uint32_t irq)
 reply:
     err = b->tx_vtbl.set_device_irq_response(b, NOP_CONT, err);
     assert(err_is_ok(err));
-
-    free(device);
 }
 
 static void reset_handler(struct acpi_binding *b)
index 6962aa3..a494ab0 100644 (file)
@@ -143,7 +143,6 @@ static int list_kcb(int argc, char **argv) {
                kcb_id, barrelfish_id, cap_key);
 
         free(cap_key);
-        free(record);
     }
     if (len == 0) {
         DEBUG("%s:%s:%d: No KCB found?\n",
@@ -173,8 +172,6 @@ static int list_cpu(int argc, char **argv) {
 
         printf("CPU %"PRIu64": APIC_ID=%"PRIu64" APIC_PROCESSOR_ID=%"PRIu64" ENABLED=%"PRIu64"\n",
                barrelfish_id, apic_id, processor_id, enabled);
-
-        free(record);
     }
     if (len == 0) {
         DEBUG("%s:%s:%d: No cpus found?\n",
index ac47c67..478e820 100644 (file)
@@ -83,7 +83,6 @@ errval_t get_core_info(coreid_t core_id, archid_t* apic_id, enum cpu_type* cpu_t
     *apic_id = (archid_t) apic;
     *cpu_type = (enum cpu_type) type;
 out:
-    free(record);
     return err;
 #endif
 }
index ae6c628..14fee94 100644 (file)
@@ -84,7 +84,6 @@ static void basic_serial_input(char *data, size_t length)
 static void output_handler(struct serial_binding *b, char *c, size_t len)
 {
     serial_write(c, len);
-    free(c);
 }
 
 static void associate_stdin_handler(struct serial_binding *b)
index a1d93a4..1bbf0b9 100644 (file)
@@ -34,7 +34,6 @@ static void terminal_serial_input(char *data, size_t length)
 static void characters_handler(void *st, char *buffer, size_t length)
 {
     serial_write(buffer, length);
-    free(buffer);
 }
 
 static void configuration_handler(void *st, terminal_config_option_t opt,
index a3e4ded..f9186d9 100644 (file)
@@ -51,7 +51,6 @@ static void domain_wait_trigger_handler(octopus_mode_t mode,
     interphi_domain_wait_reply(ws->node, err, ws->usr_state, domid);
 
     free(state);
-    free(record);
 }
 
 /**
@@ -70,14 +69,13 @@ errval_t domain_lookup(const char *iface,
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
 
-    char* record = NULL;
-    octopus_trigger_id_t tid;
-    errval_t error_code;
-    err = r->vtbl.get(r, iface, NOP_TRIGGER, &record, &tid, &error_code);
+    struct octopus_get_response__rx_args reply;
+    err = r->vtbl.get(r, iface, NOP_TRIGGER, reply.output, &reply.tid,
+                      &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
     }
-    err = error_code;
+    err = reply.error_code;
     if (err_is_fail(err)) {
         if (err_no(err) == OCT_ERR_NO_RECORD) {
             err = err_push(err, XEON_PHI_ERR_CLIENT_DOMAIN_VOID);
@@ -86,7 +84,7 @@ errval_t domain_lookup(const char *iface,
     }
 
     xphi_dom_id_t domid = 0;
-    err = oct_read(record, "_ { domid: %d }", &domid);
+    err = oct_read(reply.output, "_ { domid: %d }", &domid);
     if (err_is_fail(err) || domid == 0) {
         err = err_push(err, XEON_PHI_ERR_CLIENT_DOMAIN_VOID);
         goto out;
@@ -96,7 +94,7 @@ errval_t domain_lookup(const char *iface,
         *retdomid = domid;
     }
 
-    out: free(record);
+    out:
     return err;
 }
 
@@ -131,28 +129,26 @@ errval_t domain_wait(const char *iface,
                     OCT_ERR_NO_RECORD, octopus_BINDING_EVENT, m,
                     domain_wait_trigger_handler, ws);
 
-    char* record = NULL;
-    errval_t error_code;
-    err = c->call_seq.get(c, iface, iface_set_trigger, &record, &ws->tid,
-                      &error_code);
+    struct octopus_get_response__rx_args reply;
+
+    assert(!"FIXME");
+    err = c->call_seq.get(c, iface, iface_set_trigger, NULL, &ws->tid,
+                      &reply.error_code);
 
     if (err_is_fail(err)) {
-        free(record);
         return err;
     }
 
-    if (err_is_fail(error_code)) {
-        free(record);
-        return error_code;
+    if (err_is_fail(reply.error_code)) {
+        return reply.error_code;
     }
 
     free(ws);
 
     xphi_dom_id_t domid = 0;
-    err = oct_read(record, "_ { domid: %d }", &domid);
+    err = oct_read(reply.output, "_ { domid: %d }", &domid);
     if (err_is_fail(err) || domid == 0) {
         err = err_push(err, XEON_PHI_ERR_CLIENT_DOMAIN_VOID);
-        free(record);
         return err;
     }
 
@@ -188,10 +184,9 @@ errval_t domain_register(const char *iface,
     }
     snprintf(record, len + 1, format, iface, domid);
 
-    char* ret = NULL;
     octopus_trigger_id_t tid;
     errval_t error_code;
-    err = r->vtbl.set(r, record, 0, NOP_TRIGGER, 0, &ret, &tid, &error_code);
+    err = r->vtbl.set(r, record, 0, NOP_TRIGGER, 0, NULL, &tid, &error_code);
     if (err_is_fail(err)) {
         goto out;
     }
index cb80716..19744d0 100644 (file)
@@ -139,7 +139,7 @@ static void rx_msg_ints(struct xmplmsg_binding *b, int ia, int ib)
 static void rx_msg_string(struct xmplmsg_binding *b, char *str)
 {
     printf("server: received msg_string:\n\t%s\n", str);
-    free(str); 
+    // no need to free the string
 }
 
 static struct xmplmsg_rx_vtbl rx_vtbl = {
index 845e461..881fdc6 100644 (file)
@@ -27,7 +27,7 @@ static void rx_myrpc_response(struct xmplrpc_binding *b, char *s)
 {
     debug_printf("client: rx_myrpc_response called: %s\n", s);
 
-    free(s);
+    // no need to free s
 }
 
 
index fdd740c..014cef0 100644 (file)
@@ -28,7 +28,8 @@ const char *service_name = "xmplthc_binding_service";
 static void run_client(struct xmplthc_thc_client_binding_t *cl)
 {
     int i = 42;
-    char *s = NULL;
+
+    char s[512];
 
     // regular message
     cl->send.mymsg(cl, i);
@@ -37,21 +38,18 @@ static void run_client(struct xmplthc_thc_client_binding_t *cl)
     // call/response
     cl->send.mycall(cl, i);
     debug_printf("client: sent mycall: %d\n", i);
-    cl->recv.myresponse(cl, &s);
+    cl->recv.myresponse(cl, s);
     debug_printf("client: received myresponse: '%s'\n", s);
-    free(s);
 
     // rpc as call/response
     cl->send.myrpc(cl, i);
     debug_printf("client: sent myrpc call msg: %d\n", i);
-    cl->recv.myrpc(cl, &s);
+    cl->recv.myrpc(cl, s);
     debug_printf("client: received myrpc response msg: '%s'\n", s);
-    free(s);
 
     // rpc
-    cl->call_seq.myrpc(cl, i, &s);
+    cl->call_seq.myrpc(cl, i, s);
     debug_printf("client: returned from myrpc(%d, '%s')\n", i, s);
-    free(s);
 
     debug_printf("finished client\n");
 }
index 6758ef0..b7fa35c 100644 (file)
@@ -1175,30 +1175,29 @@ static int freecmd(int argc, char *argv[])
 }
 
 static int nproc(int argc, char* argv[]) {
-    errval_t err, error_code;
-    octopus_trigger_id_t tid;
+    errval_t err;
     size_t count = 0;
     char** names = NULL;
-    char* buffer;
 
     static char* spawnds = "r'spawn.[0-9]+' { iref: _ }";
     oct_init();
 
+    struct octopus_get_names_response__rx_args reply;
     struct octopus_rpc_client *r = get_octopus_rpc_client();
-    err = r->vtbl.get_names(r, spawnds, NOP_TRIGGER, &buffer, &tid, &error_code);
-    if (err_is_fail(err) || err_is_fail(error_code)) {
+    err = r->vtbl.get_names(r, spawnds, NOP_TRIGGER, reply.output,
+                            &reply.tid, &reply.error_code);
+    if (err_is_fail(err) || err_is_fail(reply.error_code)) {
         DEBUG_ERR(err, "get_names failed");
         goto out;
     }
 
-    err = oct_parse_names(buffer, &names, &count);
+    err = oct_parse_names(reply.output, &names, &count);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "parse_names failed.");
         goto out;
     }
 
 out:
-    free(buffer);
     oct_free_names(names, count);
 
     printf("%zx\n", count);
index 121c6ad..755daf9 100644 (file)
@@ -63,7 +63,6 @@ static void cpu_change_event(octopus_mode_t mode, char* record, void* state)
 
 out:
     assert(!(mode & OCT_REMOVED));
-    free(record);
 }
 
 static char* local_apics = "r'hw\\.processor\\.[0-9]+' { processor_id: _, "
@@ -199,7 +198,6 @@ errval_t wait_for_all_spawnds(void)
     KALUGA_DEBUG("Waiting for acpi");
     char* record = NULL;
     errval_t err = oct_wait_for(&record, "acpi { iref: _ }");
-    free(record);
     if (err_is_fail(err)) {
         return err_push(err, KALUGA_ERR_WAITING_FOR_ACPI);
     }
index 93e0bcd..251881b 100644 (file)
@@ -48,8 +48,6 @@ static errval_t wait_for_spawnd(coreid_t core, void* state)
 {
     // Check if the core we're spawning on is already up...
     struct octopus_thc_client_binding_t* cl = oct_get_thc_client();
-    char* iref_record = NULL;
-    octopus_trigger_id_t tid;
     errval_t error_code;
     octopus_trigger_t t = oct_mktrigger(OCT_ERR_NO_RECORD,
             octopus_BINDING_EVENT, OCT_ON_SET, spawnd_up_event, state);
@@ -60,9 +58,8 @@ static errval_t wait_for_spawnd(coreid_t core, void* state)
     char* query = malloc(length+1);
     snprintf(query, length+1, format, core);
 
-    errval_t err = cl->call_seq.get(cl, query, t, &iref_record, &tid, &error_code);
+    errval_t err = cl->call_seq.get(cl, query, t, NULL, NULL, &error_code);
     free(query);
-    free(iref_record);
 
     if (err_is_fail(err)) {
         return err;
@@ -81,6 +78,11 @@ static void pci_change_event(octopus_mode_t mode, char* device_record, void* st)
         if (err_is_fail(err)) {
             USER_PANIC_ERR(err, "Got malformed device record?");
         }
+        
+        /* duplicate device record as we may need it for later */
+        device_record = strdup(device_record);
+        assert(device_record);
+        
 
         // Ask the SKB which binary and where to start it...
         static char* query = "find_pci_driver(pci_card(%"PRIu64", %"PRIu64", _, _, _), Driver),"
@@ -176,7 +178,7 @@ static void bridge_change_event(octopus_mode_t mode, char* bridge_record, void*
         struct module_info* mi = find_module("pci");
         if (mi == NULL) {
             KALUGA_DEBUG("PCI driver not found or not declared as auto.");
-            goto out;
+            return;
         }
 
         // XXX: always spawn on my_core_id; otherwise we need to check that
@@ -201,9 +203,6 @@ static void bridge_change_event(octopus_mode_t mode, char* bridge_record, void*
             break;
         }
     }
-
-out:
-    free(bridge_record);
 }
 
 errval_t watch_for_pci_root_bridge(void)
index 005b4ba..7a6e4a4 100644 (file)
@@ -23,7 +23,7 @@
 
 struct ipi_alloc_notify_reply_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_ipi_alloc_notify_reply__args args;
+    struct monitor_ipi_alloc_notify_reply__tx_args args;
 };
 
 static void
index 005b4ba..7a6e4a4 100644 (file)
@@ -23,7 +23,7 @@
 
 struct ipi_alloc_notify_reply_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_ipi_alloc_notify_reply__args args;
+    struct monitor_ipi_alloc_notify_reply__tx_args args;
 };
 
 static void
index 005b4ba..7a6e4a4 100644 (file)
@@ -23,7 +23,7 @@
 
 struct ipi_alloc_notify_reply_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_ipi_alloc_notify_reply__args args;
+    struct monitor_ipi_alloc_notify_reply__tx_args args;
 };
 
 static void
index 402c6d6..d9c50e0 100644 (file)
@@ -70,27 +70,24 @@ size_t num_monitors_online(void)
     }
     assert(r != NULL);
 
-    char* buffer = NULL;
-    errval_t error_code;
-    octopus_trigger_id_t tid;
-
     char** names = NULL;
     size_t count = 0;
 
     static char* spawnds = "r'spawn.[0-9]+' { iref: _ }";
-        err = r->vtbl.get_names(r, spawnds, NOP_TRIGGER, &buffer, &tid, &error_code);
-    if (err_is_fail(err) || err_is_fail(error_code)) {
+    struct octopus_get_names_response__rx_args reply;
+    err = r->vtbl.get_names(r, spawnds, NOP_TRIGGER, reply.output,
+                            &reply.tid, &reply.error_code);
+    if (err_is_fail(err) || err_is_fail(reply.error_code)) {
         err = err_push(err, SPAWN_ERR_FIND_SPAWNDS);
         goto out;
     }
 
-    err = oct_parse_names(buffer, &names, &count);
+    err = oct_parse_names(reply.output, &names, &count);
     if (err_is_fail(err)) {
         goto out;
     }
 
 out:
-    free(buffer);
     oct_free_names(names, count);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "num_spawnds_online");
index ce05801..94a5e76 100644 (file)
@@ -84,7 +84,7 @@ static void boot_core_reply_handler(struct monitor_binding *b,
 
 struct boot_core_reply_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_boot_core_reply__args args;
+    struct monitor_boot_core_reply__tx_args args;
 };
 
 static void
@@ -172,7 +172,7 @@ static void cap_receive_request_handler(struct monitor_binding *b,
 
 struct cap_receive_request_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_cap_receive_request__args args;
+    struct monitor_cap_receive_request__tx_args args;
     uintptr_t your_mon_id;
     struct intermon_binding *b;
 };
index b17cd05..eefe5cc 100644 (file)
@@ -88,7 +88,7 @@ static void alloc_iref_reply_handler(struct monitor_binding *b,
 
 struct alloc_iref_reply_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_alloc_iref_reply__args args;
+    struct monitor_alloc_iref_reply__tx_args args;
     struct monitor_binding *b;
 };
 
@@ -150,7 +150,7 @@ static void bind_lmp_client_request_error_handler(struct monitor_binding *b,
 
 struct bind_lmp_client_request_error_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_bind_lmp_reply_client__args args;
+    struct monitor_bind_lmp_reply_client__tx_args args;
     struct monitor_binding *serv_binding;
     struct capref ep;
 };
@@ -213,7 +213,7 @@ static void bind_lmp_service_request_handler(struct monitor_binding *b,
 
 struct bind_lmp_service_request_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_bind_lmp_service_request__args args;
+    struct monitor_bind_lmp_service_request__tx_args args;
     struct monitor_binding *b;
     uintptr_t domain_id;
 };
@@ -342,7 +342,7 @@ static void bind_lmp_reply_client_handler(struct monitor_binding *b,
 
 struct bind_lmp_reply_client_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_bind_lmp_reply_client__args args;
+    struct monitor_bind_lmp_reply_client__tx_args args;
     struct monitor_binding *b;
 };
 
@@ -449,7 +449,7 @@ cleanup:
 
 struct new_monitor_binding_reply_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_new_monitor_binding_reply__args args;
+    struct monitor_new_monitor_binding_reply__tx_args args;
 };
 
 static void
index b21c794..b1a2488 100644 (file)
@@ -125,7 +125,7 @@ static void multihop_routing_table_set(struct monitor_binding *b,
     assert(from <= routing_table_max_coreid);
     assert(routing_table[from] == NULL);
     assert(len == routing_table_max_coreid + 1);
-    routing_table[from] = to;
+    routing_table[from] = memdup(to, len * sizeof(coreid_t));
 
     if (--routing_table_nentries == 0) {
         // we have received the complete table!
@@ -197,10 +197,8 @@ static void multihop_handle_routing_table_response(struct intermon_binding *b,
 
         assert(len == max_coreid + 1);
         assert(source_coreid <= max_coreid);
-        routing_table[source_coreid] = to;
+        routing_table[source_coreid] = memdup(to, len * sizeof(coreid_t));
     } else {
-        assert(to == NULL);
-
         if (err_no(err) != MON_ERR_INCOMPLETE_ROUTE) {
             DEBUG_ERR(err, "unexpected error retrieving routing table");
         }
@@ -270,8 +268,6 @@ static void multihop_routing_table_grow(struct intermon_binding *b,
             }
         }
     }
-
-    free(destinations);
 }
 
 // return the next hop (based on the routing table)
@@ -755,7 +751,7 @@ static void multihop_monitor_service_bind_reply_handler(
 
 struct multihop_intermon_bind_reply_state {
     struct intermon_msg_queue_elem elem;
-    struct intermon_bind_multihop_intermon_reply__args args;
+    struct intermon_bind_multihop_intermon_reply__tx_args args;
 };
 
 // called when channel is no longer busy
@@ -856,7 +852,7 @@ static void multihop_intermon_bind_reply_handler(
 
 struct multihop_monitor_bind_reply_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_multihop_bind_client_reply__args args;
+    struct monitor_multihop_bind_client_reply__tx_args args;
 };
 
 // continue function to forward a message to a dispatcher
@@ -953,13 +949,13 @@ static void multihop_message_intermon_forward_cont(struct intermon_binding *b,
 // monitor message forwarding state
 struct monitor_multihop_message_forwarding_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_multihop_message__args args;
+    struct monitor_multihop_message__rx_args args;
 };
 
 // inter-monitor forwarding state
 struct intermon_message_forwarding_state {
     struct intermon_msg_queue_elem elem;
-    struct intermon_multihop_message__args args;
+    struct intermon_multihop_message__rx_args args;
 };
 
 /**
@@ -1007,7 +1003,8 @@ static void multihop_message_handler(struct monitor_binding *mon_binding,
         me->args.direction = direction;
         me->args.flags = flags;
         me->args.ack = ack;
-        me->args.payload = payload;
+        memcpy(me->args.payload, payload, size);
+
         me->args.size = size;
         me->elem.cont = multihop_message_intermon_forward_cont;
 
@@ -1043,7 +1040,7 @@ static inline void multihop_message_intermon_forward(struct intermon_binding *b,
     errval_t err;
 
     // try to forward message
-    err = b->tx_vtbl.multihop_message(b, MKCONT(free, payload), vci, direction,
+    err = b->tx_vtbl.multihop_message(b, NOP_CONT, vci, direction,
             flags, ack, payload, size);
 
     if (err_is_fail(err)) {
@@ -1055,7 +1052,8 @@ static inline void multihop_message_intermon_forward(struct intermon_binding *b,
             me->args.direction = direction;
             me->args.flags = flags;
             me->args.ack = ack;
-            me->args.payload = payload;
+            memcpy(me->args.payload, payload, size);
+
             me->args.size = size;
             me->elem.cont = multihop_message_intermon_forward_cont;
 
@@ -1127,7 +1125,8 @@ static void intermon_multihop_message_handler(struct intermon_binding *binding,
             me->args.direction = direction;
             me->args.flags = flags;
             me->args.ack = ack;
-            me->args.payload = payload;
+            memcpy(me->args.payload, payload, size);
+
             me->args.size = size;
             me->elem.cont = multihop_message_forward_continue;
 
@@ -1153,7 +1152,8 @@ static void intermon_multihop_message_handler(struct intermon_binding *binding,
             me->args.direction = direction;
             me->args.flags = flags;
             me->args.ack = ack;
-            me->args.payload = payload;
+            memcpy(me->args.payload, payload, size);
+
             me->args.size = size;
             me->elem.cont = multihop_message_intermon_forward_cont;
 
@@ -1190,7 +1190,7 @@ static inline void multihop_message_monitor_forward(struct monitor_binding *b,
     errval_t err;
 
     // try to forward message
-    err = b->tx_vtbl.multihop_message(b, MKCONT(free, payload), vci, direction,
+    err = b->tx_vtbl.multihop_message(b, NOP_CONT, vci, direction,
             flags, ack, payload, size);
 
     if (err_is_fail(err)) {
@@ -1203,7 +1203,8 @@ static inline void multihop_message_monitor_forward(struct monitor_binding *b,
             me->args.direction = direction;
             me->args.flags = flags;
             me->args.ack = ack;
-            me->args.payload = payload;
+            memcpy(me->args.payload, payload, size);
+
             me->args.size = size;
             me->elem.cont = multihop_message_forward_continue;
 
@@ -1247,13 +1248,13 @@ inline static void multihop_cap_send_forward(struct monitor_binding *b,
 // intermonitor capability forwarding state
 struct multihop_intermon_capability_forwarding_state {
     struct intermon_msg_queue_elem elem;
-    struct intermon_multihop_cap_send__args args;
+    struct intermon_multihop_cap_send__tx_args args;
 };
 
 // monitor capability forwarding state
 struct multihop_capability_forwarding_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_multihop_cap_send__args args;
+    struct monitor_multihop_cap_send__tx_args args;
 };
 
 /**
index bf5170e..fe27c89 100644 (file)
@@ -44,9 +44,13 @@ static void mem_alloc_delete_result_handler(errval_t status, void *st)
 /**
  * \brief Request for some memory (over the memory allocation channel)
  */
-static void mem_alloc_handler(struct monitor_mem_binding *b,
+// static void mem_alloc_handler(struct monitor_mem_binding *b,
+//                               uint8_t size_bits, genpaddr_t minbase,
+//                               genpaddr_t maxlimit, coreid_t from)
+static errval_t mem_alloc_handler(struct monitor_mem_binding *b,
                               uint8_t size_bits, genpaddr_t minbase,
-                              genpaddr_t maxlimit, coreid_t from)
+                              genpaddr_t maxlimit, coreid_t from,
+                              errval_t *out_err, monitor_mem_caprep_t *out_caprep)
 {
     struct capref *cap = NULL;
     monitor_mem_caprep_t caprep = {0,0,0,0};
@@ -90,21 +94,25 @@ static void mem_alloc_handler(struct monitor_mem_binding *b,
 
 out:
     // RPC protocol, this can never fail with TX_BUSY
-    err = b->tx_vtbl.alloc_response(b, NOP_CONT, reterr, caprep);
-    if (err_is_fail(err)) {
-        DEBUG_ERR(err, "reply failed");
-    }
+    *out_err = reterr;
+    *out_caprep = caprep;
+    // err = b->tx_vtbl.alloc_response(b, NOP_CONT, reterr, caprep);
+    // if (err_is_fail(err)) {
+    //     DEBUG_ERR(err, "reply failed");
+    // }
 
     if (cap) {
         capops_delete(get_cap_domref(*cap), mem_alloc_delete_result_handler, cap);
     }
+    return SYS_ERR_OK;
 }
 
-static void mem_free_handler(struct monitor_mem_binding *b,
+static errval_t mem_free_handler(struct monitor_mem_binding *b,
                              monitor_mem_caprep_t caprep,
-                             genpaddr_t base, uint8_t bits)
+                             genpaddr_t base, uint8_t bits, errval_t *result)
 {
-    errval_t err, result;
+    debug_printf("%s:%d\n", __func__, __LINE__);
+    errval_t err;
     // this should only run on the bsp monitor
     assert(bsp_monitor);
     DEBUG_CAPOPS("%s\n", __FUNCTION__);
@@ -125,27 +133,29 @@ static void mem_free_handler(struct monitor_mem_binding *b,
     struct capref cap;
     err = slot_alloc(&cap);
     if (err_is_fail(err)) {
-        result = err_push(err, LIB_ERR_SLOT_ALLOC);
+        *result = err_push(err, LIB_ERR_SLOT_ALLOC);
         goto out;
     }
 
     err = monitor_cap_create(cap, &cap_raw, my_core_id);
     if (err_is_fail(err)) {
-        result = err_push(err, MON_ERR_CAP_CREATE);
+        *result = err_push(err, MON_ERR_CAP_CREATE);
         goto out;
     }
     DEBUG_CAPOPS("%s: created local copy, sending to memserv\n", __FUNCTION__);
 
     struct mem_rpc_client *mb = get_mem_client();
     assert(mb);
-    err = mb->vtbl.free_monitor(mb, cap, base, bits, &result);
+    err = mb->vtbl.free_monitor(mb, cap, base, bits, result);
     if (err_is_fail(err)) {
-        result = err;
+        *result = err;
     }
 out:
-    DEBUG_CAPOPS("%s: sending reply: %s\n", __FUNCTION__, err_getstring(result));
-    err = b->tx_vtbl.free_response(b, NOP_CONT, result);
-    assert(err_is_ok(err));
+    DEBUG_CAPOPS("%s: sending reply: %s\n", __FUNCTION__, err_getstring(*result));
+    debug_printf("%s:%d response\n", __func__, __LINE__);
+//    err = b->tx_vtbl.free_response(b, NOP_CONT, result);
+//    assert(err_is_ok(err));
+    return SYS_ERR_OK;
 }
 
 static errval_t mon_ram_alloc(struct capref *ret, uint8_t size_bits,
@@ -181,14 +191,14 @@ static errval_t mon_ram_alloc(struct capref *ret, uint8_t size_bits,
     return reterr;
 }
 
-static struct monitor_mem_rx_vtbl the_monitor_mem_vtable = {
+static struct monitor_mem_rpc_rx_vtbl the_monitor_mem_rpc_vtable = {
     .alloc_call = mem_alloc_handler,
     .free_call = mem_free_handler,
 };
 
 static errval_t monitor_mem_connected(void *st, struct monitor_mem_binding *b)
 {
-    b->rx_vtbl = the_monitor_mem_vtable;
+    b->rpc_rx_vtbl = the_monitor_mem_rpc_vtable;
     return SYS_ERR_OK;
 }
 
index 541eb10..a4f2b30 100644 (file)
@@ -76,7 +76,7 @@ static void rsrc_phase_data_done(void *arg)
 
 struct send_phase_data_state {
     struct intermon_msg_queue_elem elem;
-    struct intermon_rsrc_phase_data__args args;
+    struct intermon_rsrc_phase_data__tx_args args;
 };
 
 static void send_phase_data_handler(struct intermon_binding *b,
@@ -327,7 +327,7 @@ static void activate_phase(rsrcid_t id, struct rsrc_domain *d, uintptr_t phase,
 
 struct rsrc_phase_state {
     struct intermon_msg_queue_elem elem;
-    struct intermon_rsrc_phase__args args;
+    struct intermon_rsrc_phase__tx_args args;
 };
 
 static void rsrc_phase_handler(struct intermon_binding *b,
@@ -445,8 +445,5 @@ errval_t rsrc_set_phase_data(rsrcid_t id, uintptr_t active, void *data,
     assert(len == sizeof(d->phase));
     memcpy(&d->phase, data, len);
 
-    // Free copy
-    free(data);
-
     return SYS_ERR_OK;
 }
index 2b080b6..69489c1 100644 (file)
@@ -49,7 +49,7 @@ static void bind_ump_request_handler(struct intermon_binding *b,
 
 struct bind_ump_request_state {
     struct intermon_msg_queue_elem elem;
-    struct intermon_bind_ump_request__args args;
+    struct intermon_bind_ump_request__tx_args args;
     struct frame_identity frameid;
     struct capability capability;
     struct monitor_binding *mb;
@@ -204,7 +204,7 @@ static void bind_ump_reply_handler(struct intermon_binding *b,
 
 struct bind_ump_reply_state {
     struct intermon_msg_queue_elem elem;
-    struct intermon_bind_ump_reply__args args;
+    struct intermon_bind_ump_reply__tx_args args;
     struct capability capability;
 };
 
@@ -306,7 +306,7 @@ static void bind_ump_service_request_handler(struct monitor_binding *b,
 
 struct bind_ump_service_request_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_bind_ump_service_request__args args;
+    struct monitor_bind_ump_service_request__tx_args args;
     struct intermon_binding *binding;
     uintptr_t your_mon_id;
 };
@@ -462,7 +462,7 @@ static void bind_ump_reply_client_handler(struct monitor_binding *b,
 
 struct bind_ump_reply_client_state {
     struct monitor_msg_queue_elem elem;
-    struct monitor_bind_ump_reply_client__args args;
+    struct monitor_bind_ump_reply_client__tx_args args;
 };
 
 static void bind_ump_reply_client_cont(struct monitor_binding *domain_binding,
index 43e488f..521833c 100644 (file)
@@ -672,7 +672,8 @@ static void assign_bus_numbers(struct pci_address parentaddr,
                 pci_hdr1_initialize(&bhdr, addr);
 
                 //ACPI_HANDLE child;
-                char* child = NULL;
+                char* child = malloc(acpi__read_irq_table_response_child_MAX_ARGUMENT_SIZE);
+                assert(child);
                 errval_t error_code;
                 PCI_DEBUG("get irq table for (%hhu,%hhu,%hhu)\n", (*busnum) + 2,
                           addr.device, addr.function);
@@ -684,7 +685,7 @@ static void assign_bus_numbers(struct pci_address parentaddr,
                     .function = addr.function,
                 };
                 errval_t err = cl->vtbl.read_irq_table(cl, handle, xaddr, (*busnum) + 2,
-                                        &error_code, &child);
+                                        &error_code, child);
                 if (err_is_ok(err) && error_code == ACPI_ERR_NO_CHILD_BRIDGE){
                     PCI_DEBUG("No corresponding ACPI entry for bridge found\n");
                 } else if (err_is_fail(err) || err_is_fail(error_code)) {
@@ -755,7 +756,6 @@ static void assign_bus_numbers(struct pci_address parentaddr,
                              pci_hdr0_int_pin_rd(&devhdr) - 1);
 
                 // octopus start
-                char* record = NULL;
                 static char* device_fmt = "hw.pci.device. { "
                                 "bus: %u, device: %u, function: %u, "
                                 "vendor: %u, device_id: %u, class: %u, "
@@ -767,7 +767,6 @@ static void assign_bus_numbers(struct pci_address parentaddr,
                                         classcode.subclss, classcode.prog_if);
 
                 assert(err_is_ok(err));
-                free(record);
                 // end octopus
 
                 query_bars(devhdr, addr, false);
@@ -1084,6 +1083,7 @@ static void assign_bus_numbers(struct pci_address parentaddr,
     }
 
     free(handle);
+    
 }
 
 #if 0
@@ -1184,8 +1184,6 @@ errval_t pci_setup_root_complex(void)
         pcie_enable();
         pci_add_root(addr, maxbus, acpi_node);
         pcie_disable();
-
-        free(record);
     }
 
     out: oct_free_names(names, len);
index c243d63..b0f4aab 100644 (file)
@@ -77,12 +77,23 @@ static void init_pci_device_handler(struct pci_binding *b,
 
     if (err_is_fail(err)) {
         err = b->tx_vtbl.init_pci_device_response(b, NOP_CONT, err, 0,
-                                                  cc->nr_caps_bar);
+                                                  cc->nr_caps_bar[0],
+                                                  cc->nr_caps_bar[1],
+                                                  cc->nr_caps_bar[2],
+                                                  cc->nr_caps_bar[3],
+                                                  cc->nr_caps_bar[4],
+                                                  cc->nr_caps_bar[5]);
 
     } else {
         err = b->tx_vtbl.init_pci_device_response(b, NOP_CONT, err,
                                                   cc->nr_allocated_bars,
-                                                  cc->nr_caps_bar);
+                                                  cc->nr_caps_bar[0],
+                                                  cc->nr_caps_bar[1],
+                                                  cc->nr_caps_bar[2],
+                                                  cc->nr_caps_bar[3],
+                                                  cc->nr_caps_bar[4],
+                                                  cc->nr_caps_bar[5]);
+
     }
     assert(err_is_ok(err));
 }
@@ -161,7 +172,7 @@ static void get_bar_cap_response_cont(struct pci_binding *b, errval_t err,
     if(err_is_fail(e)) {
         if(err_no(e) == FLOUNDER_ERR_TX_BUSY) {
             struct client_state *st = b->st;
-            struct pci_get_bar_cap_response__args *me = malloc(sizeof(*me));
+            struct pci_get_bar_cap_response__tx_args *me = malloc(sizeof(*me));
             assert(me != NULL);
             me->err = err;
             me->cap = cap;
@@ -182,7 +193,7 @@ static void get_bar_cap_response_resend(void *arg)
 {
     struct pci_binding *b = arg;
     struct client_state *st = b->st;
-    struct pci_get_bar_cap_response__args *a = st->cont_st;
+    struct pci_get_bar_cap_response__tx_args *a = st->cont_st;
     get_bar_cap_response_cont(b, a->err, a->cap, a->type, a->bar_nr);
     free(a);
 }
index 54e98c1..b8b6589 100644 (file)
@@ -34,7 +34,7 @@
 
 struct msgq_elem {
     enum trivfs_msg_enum msgnum;
-    union trivfs_arg_union a;
+    union trivfs_rx_arg_union a;
     struct dirent *dirent;
     struct msgq_elem *next;
 };
@@ -424,12 +424,12 @@ reply:
     assert(q != NULL);
     q->msgnum = trivfs_readdir_response__msgnum;
     q->a.readdir_response.err = reterr;
-    q->a.readdir_response.name = (char *)name;
+    strncpy(q->a.readdir_response.name, name, sizeof(q->a.readdir_response.name));
     q->a.readdir_response.isdir = isdir;
     q->a.readdir_response.size = size;
     q->dirent = err_is_ok(reterr) ? e : NULL;
     msg_enqueue(st, b, q);
-   
+
 }
 
 static void lookup(struct trivfs_binding *b, trivfs_fh_t dir, char *name)
@@ -464,7 +464,6 @@ static void lookup(struct trivfs_binding *b, trivfs_fh_t dir, char *name)
     isdir = ramfs_isdir(e);
 
 reply:
-    free(name);
     if (queue_is_empty(st)) {
         err = b->tx_vtbl.lookup_response(b, NOP_CONT, reterr, retfh, isdir);
         if (err_is_ok(err)) {
@@ -572,7 +571,7 @@ reply:
     assert(q != NULL);
     q->msgnum = trivfs_read_response__msgnum;
     q->a.read_response.err = reterr;
-    q->a.read_response.data = buf;
+    memcpy(q->a.read_response.data, buf, len);
     q->a.read_response.retlen = len;
     q->dirent = err_is_ok(reterr) ? f : NULL;
     msg_enqueue(st, b, q);
@@ -601,7 +600,6 @@ static void write(struct trivfs_binding *b, trivfs_fh_t fh,
     memcpy(buf, data, len);
 
 reply:
-    free(data);
     if (queue_is_empty(st)) {
         err = b->tx_vtbl.write_response(b, NOP_CONT, reterr);
         if (err_is_ok(err)) {
@@ -795,9 +793,16 @@ static void create(struct trivfs_binding *b, trivfs_fh_t dir, char *name)
         goto reply;
     }
 
+
+    name = strdup(name);
+    if (name == NULL) {
+        reterr = LIB_ERR_MALLOC_FAIL;
+        goto reply;
+    }
     struct dirent *newf;
     err = ramfs_create(d, name, &newf);
     if (err_is_fail(err)) {
+        free(name);
         reterr = err;
         goto reply;
     }
@@ -805,10 +810,6 @@ static void create(struct trivfs_binding *b, trivfs_fh_t dir, char *name)
     fh = fh_set(st, newf);
 
 reply:
-    if (err_is_fail(reterr)) {
-        free(name);
-    }
-
     if (queue_is_empty(st)) {
         err = b->tx_vtbl.create_response(b, NOP_CONT, reterr, fh);
         if (err_is_ok(err)) {
@@ -846,9 +847,16 @@ static void mkdir(struct trivfs_binding *b, trivfs_fh_t dir, char *name)
         goto reply;
     }
 
+    name = strdup(name);
+    if (name == NULL) {
+        reterr = LIB_ERR_MALLOC_FAIL;
+        goto reply;
+    }
+
     struct dirent *newd;
     err = ramfs_mkdir(d, name, &newd);
     if (err_is_fail(err)) {
+        free(name);
         reterr = err;
         goto reply;
     }
@@ -856,10 +864,6 @@ static void mkdir(struct trivfs_binding *b, trivfs_fh_t dir, char *name)
     fh = fh_set(st, newd);
 
 reply:
-    if (err_is_fail(reterr)) {
-        free(name);
-    }
-
     if (queue_is_empty(st)) {
         err = b->tx_vtbl.mkdir_response(b, NOP_CONT, reterr, fh);
         if (err_is_ok(err)) {
index 557de97..4328462 100644 (file)
@@ -25,12 +25,9 @@ void skb_server_init(void);
 void post_and_execute_string(void);
 
 
-#define BUFFER_SIZE SKB_REPLY_BUF_SIZE
-
-
 struct skb_query_state {
-    char output_buffer[BUFFER_SIZE];
-    char error_buffer[BUFFER_SIZE];
+    char output_buffer[skb__run_response_output_MAX_ARGUMENT_SIZE];
+    char error_buffer[skb__run_response_str_error_MAX_ARGUMENT_SIZE];
     int output_length;
     int error_output_length;
     int exec_res;
index 786f402..5776899 100644 (file)
@@ -57,11 +57,11 @@ int main(int argc, char**argv)
     vfs_mkdir("/tmp");
     chdir(ECLIPSE_DIR);
 
-       // make sure, that dlsym has the right table to the statically compiled-in
-       // shared libraries...
+    // make sure, that dlsym has the right table to the statically compiled-in
+    // shared libraries...
     dlopen_set_params(funcs, sizeof(funcs) / sizeof(*funcs));
 
-       // now set the right values for the eclipse-clp engine
+    // now set the right values for the eclipse-clp engine
     ec_set_option_int(EC_OPTION_IO, MEMORY_IO);
     ec_set_option_ptr(EC_OPTION_ECLIPSEDIR, ECLIPSE_DIR);
     ec_set_option_long(EC_OPTION_GLOBALSIZE, MEMORY_SIZE);
@@ -70,7 +70,7 @@ int main(int argc, char**argv)
 
     struct skb_query_state* sqs = malloc(sizeof(struct skb_query_state));
 
-       // ec_.m.vm_flags |= 8;
+    // ec_.m.vm_flags |= 8;
     SKB_DEBUG("before ec init\n");
     int n = ec_init();
     if (n != 0) {
index e113ae6..ee36f14 100644 (file)
 
 errval_t new_reply_state(struct skb_reply_state** srs, rpc_reply_handler_fn reply_handler)
 {
-       assert(*srs == NULL);
-       *srs = malloc(sizeof(struct skb_reply_state));
-       if(*srs == NULL) {
-               return LIB_ERR_MALLOC_FAIL;
-       }
-       memset(*srs, 0, sizeof(struct skb_reply_state));
+    assert(*srs == NULL);
+    *srs = malloc(sizeof(struct skb_reply_state));
+    if(*srs == NULL) {
+        return LIB_ERR_MALLOC_FAIL;
+    }
+    memset(*srs, 0, sizeof(struct skb_reply_state));
 
-       (*srs)->rpc_reply = reply_handler;
-       (*srs)->next = NULL;
+    (*srs)->rpc_reply = reply_handler;
+    (*srs)->next = NULL;
 
-       return SYS_ERR_OK;
+    return SYS_ERR_OK;
 }
 
 
 void free_reply_state(void* arg) {
-       if(arg != NULL) {
-               struct skb_reply_state* srt = (struct skb_reply_state*) arg;
-               free(srt);
-       }
-       else {
-               assert(!"free_reply_state with NULL argument?");
-       }
+    if(arg != NULL) {
+        struct skb_reply_state* srt = (struct skb_reply_state*) arg;
+        free(srt);
+    }
+    else {
+        assert(!"free_reply_state with NULL argument?");
+    }
 }
 
 
 errval_t execute_query(char* query, struct skb_query_state* st)
 {
     SKB_DEBUG("Executing query: %s\n", query);
-       assert(query != NULL);
+    assert(query != NULL);
     assert(st != NULL);
-       int res;
+    int res;
 
     ec_ref Start = ec_ref_create_newvar();
 
-       st->exec_res = PFLUSHIO;
+    st->exec_res = PFLUSHIO;
     st->output_length = 0;
     st->error_output_length = 0;
 
@@ -89,18 +89,18 @@ errval_t execute_query(char* query, struct skb_query_state* st)
         res = 0;
         do {
             res = ec_queue_read(1, st->output_buffer + st->output_length,
-                                BUFFER_SIZE - res);
+                                sizeof(st->output_buffer) - res);
             st->output_length += res;
-        } while ((res != 0) && (st->output_length < BUFFER_SIZE));
+        } while ((res != 0) && (st->output_length < sizeof(st->output_buffer)));
         st->output_buffer[st->output_length] = 0;
 
         res = 0;
         do {
             res = ec_queue_read(2, st->error_buffer + st->error_output_length,
-                                BUFFER_SIZE - res);
+                                sizeof(st->error_buffer) - res);
             st->error_output_length += res;
         } while ((res != 0) &&
-                    (st->error_output_length < BUFFER_SIZE));
+                    (st->error_output_length < sizeof(st->error_buffer)));
 
         st->error_buffer[st->error_output_length] = 0;
     }
@@ -131,13 +131,13 @@ errval_t execute_query(char* query, struct skb_query_state* st)
 static void run_reply(struct skb_binding* b, struct skb_reply_state* srt) {
     errval_t err;
     err = b->tx_vtbl.run_response(b, MKCONT(free_reply_state, srt),
-                                             srt->skb.output_buffer,
-                                             srt->skb.error_buffer,
-                                             srt->skb.exec_res);
+                                  srt->skb.output_buffer,
+                                  srt->skb.error_buffer,
+                                  srt->skb.exec_res);
     if (err_is_fail(err)) {
         if(err_no(err) == FLOUNDER_ERR_TX_BUSY) {
-               enqueue_reply_state(b, srt);
-               return;
+            enqueue_reply_state(b, srt);
+            return;
         }
         USER_PANIC_ERR(err, "SKB sending %s failed!", __FUNCTION__);
     }
@@ -146,15 +146,14 @@ static void run_reply(struct skb_binding* b, struct skb_reply_state* srt) {
 
 static void run(struct skb_binding *b, char *query)
 {
-       struct skb_reply_state* srt = NULL;
-       errval_t err = new_reply_state(&srt, run_reply);
-       assert(err_is_ok(err)); // TODO
+    struct skb_reply_state* srt = NULL;
+    errval_t err = new_reply_state(&srt, run_reply);
+    assert(err_is_ok(err)); // TODO
 
-       err = execute_query(query, &srt->skb);
-       assert(err_is_ok(err));
+    err = execute_query(query, &srt->skb);
+    assert(err_is_ok(err));
 
     run_reply(b, srt);
-       free(query);
 }
 
 
@@ -187,7 +186,7 @@ static void export_cb(void *st, errval_t err, iref_t iref)
 
 static errval_t connect_cb(void *st, struct skb_binding *b)
 {
-       // Set up continuation queue
+    // Set up continuation queue
     b->st = NULL;
 
     // copy my message receive handler vtable to the binding
index 74bf3e3..f4fa4c9 100644 (file)
@@ -152,7 +152,7 @@ static errval_t spawn(char *path, char *const argv[], char *argbuf,
     assert(pe != NULL);
     memset(pe, 0, sizeof(struct ps_entry));
     memcpy(pe->argv, argv, MAX_CMDLINE_ARGS*sizeof(*argv));
-    pe->argbuf = argbuf;
+    pe->argbuf = memdup(argbuf, argbytes);
     pe->argbytes = argbytes;
     /*
      * NB: It's important to keep a copy of the DCB *and* the root
@@ -235,119 +235,6 @@ struct pending_spawn_response {
     domainid_t domainid;
 };
 
-static void retry_spawn_domain_response(void *a)
-{
-    errval_t err;
-
-    struct pending_spawn_response *r = (struct pending_spawn_response*)a;
-    struct spawn_binding *b = r->b;
-
-    err = b->tx_vtbl.spawn_domain_response(b, NOP_CONT, r->err, r->domainid);
-
-    if (err_no(err) == FLOUNDER_ERR_TX_BUSY) {
-        // try again
-        err = b->register_send(b, get_default_waitset(),
-                               MKCONT(retry_spawn_domain_response,a));
-    }
-    if (err_is_fail(err)) {
-        DEBUG_ERR(err, "error sending spawn_domain reply\n");
-    }
-
-    free(a);
-}
-
-
-static errval_t spawn_reply(struct spawn_binding *b, errval_t rerr,
-                            domainid_t domainid)
-{
-    errval_t err;
-
-    err = b->tx_vtbl.spawn_domain_response(b, NOP_CONT, rerr, domainid);
-
-    if (err_is_fail(err)) {
-        DEBUG_ERR(err, "error sending spawn_domain reply\n");
-
-        if (err_no(err) == FLOUNDER_ERR_TX_BUSY) {
-            // this will be freed in the retry handler
-            struct pending_spawn_response *sr =
-                malloc(sizeof(struct pending_spawn_response));
-            if (sr == NULL) {
-                return LIB_ERR_MALLOC_FAIL;
-            }
-            sr->b = b;
-            sr->err = rerr;
-            sr->domainid = domainid;
-            err = b->register_send(b, get_default_waitset(),
-                                   MKCONT(retry_spawn_domain_response, sr));
-            if (err_is_fail(err)) {
-                // note that only one continuation may be registered at a time
-                free(sr);
-                DEBUG_ERR(err, "register_send failed!");
-                return err;
-            }
-        }
-    }
-
-    return SYS_ERR_OK;
-}
-
-static void retry_spawn_domain_w_caps_response(void *a)
-{
-    errval_t err;
-
-    struct pending_spawn_response *r = (struct pending_spawn_response*)a;
-    struct spawn_binding *b = r->b;
-
-    err = b->tx_vtbl.spawn_domain_with_caps_response(b, NOP_CONT, r->err, r->domainid);
-
-    if (err_no(err) == FLOUNDER_ERR_TX_BUSY) {
-        // try again
-        err = b->register_send(b, get_default_waitset(), 
-                               MKCONT(retry_spawn_domain_response,a));
-    }
-    if (err_is_fail(err)) {
-        DEBUG_ERR(err, "error sending spawn_domain reply\n");
-    }
-
-    free(a);
-}
-
-
-static errval_t spawn_with_caps_reply(struct spawn_binding *b, errval_t rerr,
-                                      domainid_t domainid)
-{
-    errval_t err;
-    err = b->tx_vtbl.spawn_domain_with_caps_response(b, NOP_CONT, rerr, domainid);
-
-    if (err_is_fail(err)) { 
-        DEBUG_ERR(err, "error sending spawn_domain reply\n");
-
-        if (err_no(err) == FLOUNDER_ERR_TX_BUSY) {
-            // this will be freed in the retry handler
-            struct pending_spawn_response *sr =
-                malloc(sizeof(struct pending_spawn_response));
-            if (sr == NULL) {
-                return LIB_ERR_MALLOC_FAIL;
-            }
-            sr->b = b;
-            sr->err = rerr;
-            sr->domainid = domainid;
-            err = b->register_send(b, get_default_waitset(), 
-                                   MKCONT(retry_spawn_domain_w_caps_response, sr));
-            if (err_is_fail(err)) {
-                // note that only one continuation may be registered at a time
-                free(sr);
-                DEBUG_ERR(err, "register_send failed!");
-                return err;
-            }
-        }
-    }
-
-    return SYS_ERR_OK;
-}
-
-
 static errval_t spawn_with_caps_common(char *path, char *argbuf, size_t argbytes,
                                        char *envbuf, size_t envbytes,
                                        struct capref inheritcn_cap,
@@ -410,50 +297,29 @@ static errval_t spawn_with_caps_common(char *path, char *argbuf, size_t argbytes
 
  finish:
     if(err_is_fail(err)) {
-        free(argbuf);
         DEBUG_ERR(err, "spawn");
     }
 
-    free(envbuf);
-    free(path);
-
     return err;
 }
 
-static void spawn_with_caps_handler(struct spawn_binding *b, char *path,
-                                    char *argbuf, size_t argbytes,
-                                    char *envbuf, size_t envbytes,
-                                    struct capref inheritcn_cap,
-                                    struct capref argcn_cap,
-                                    uint8_t flags)
+static errval_t spawn_with_caps_handler(struct spawn_binding *b, char *path,
+    char *argvbuf, size_t argvbytes, char *envbuf, size_t envbytes,
+    struct capref inheritcn_cap, struct capref argcn_cap, uint8_t flags,
+    errval_t *err, spawn_domainid_t *domain_id)
 {
-    errval_t err;
-    domainid_t newdomid;
-    err = spawn_with_caps_common(path, argbuf, argbytes, envbuf, envbytes,
-                                 inheritcn_cap, argcn_cap, flags, &newdomid);
-
-    err = spawn_with_caps_reply(b, err, newdomid);
-
-    if (err_is_fail(err)) {
-        DEBUG_ERR(err, "while sending reply in spawn_with_caps_handler");
-    }
+    *err = spawn_with_caps_common(path, argvbuf, argvbytes, envbuf, envbytes,
+                                 inheritcn_cap, argcn_cap, flags, domain_id);
+    return SYS_ERR_OK;
 }
 
-static void spawn_handler(struct spawn_binding *b, char *path, char *argbuf,
-                          size_t argbytes, char *envbuf, size_t envbytes,
-                          uint8_t flags)
+static errval_t spawn_handler(struct spawn_binding *b, char *path,
+    char *argvbuf, size_t argvbytes, char *envbuf, size_t envbytes,
+    uint8_t flags, errval_t *err, spawn_domainid_t *domain_id)
 {
-    errval_t err;
-    domainid_t newdomid;
-    err = spawn_with_caps_common(path, argbuf, argbytes, envbuf, envbytes,
-                                 NULL_CAP, NULL_CAP, flags, &newdomid);
-
-    err = spawn_reply(b, err, newdomid);
-
-    if (err_is_fail(err)) {
-        // not much we can do about this
-        DEBUG_ERR(err, "while sending reply in spawn_handler");
-    }
+    *err = spawn_with_caps_common(path, argvbuf, argvbytes, envbuf, envbytes,
+                                 NULL_CAP, NULL_CAP, flags, domain_id);
+    return SYS_ERR_OK;
 }
 
 /**
@@ -657,8 +523,8 @@ static void dump_capabilities_handler(struct spawn_binding *b, domainid_t domain
 }
 
 static struct spawn_rx_vtbl rx_vtbl = {
-    .spawn_domain_call = spawn_handler,
-    .spawn_domain_with_caps_call = spawn_with_caps_handler,
+    // .spawn_domain_call = spawn_handler,
+    // .spawn_domain_with_caps_call = spawn_with_caps_handler,
     .use_local_memserv_call = use_local_memserv_handler,
     .kill_call = kill_handler,
     .exit_call = exit_handler,
@@ -668,6 +534,18 @@ static struct spawn_rx_vtbl rx_vtbl = {
     .dump_capabilities_call = dump_capabilities_handler
 };
 
+static struct spawn_rpc_rx_vtbl rpc_rx_vtbl = {
+    .spawn_domain_call = spawn_handler,
+    .spawn_domain_with_caps_call = spawn_with_caps_handler,
+    // .use_local_memserv_call = use_local_memserv_handler,
+    // .kill_call = kill_handler,
+    // .exit_call = exit_handler,
+    // .wait_call = wait_handler,
+    // .get_domainlist_call = get_domainlist_handler,
+    // .status_call = status_handler,
+    // .dump_capabilities_call = dump_capabilities_handler
+};
+
 static void export_cb(void *st, errval_t err, iref_t iref)
 {
     if (err_is_fail(err)) {
@@ -693,6 +571,7 @@ static errval_t connect_cb(void *st, struct spawn_binding *b)
 {
     // copy my message receive handler vtable to the binding
     b->rx_vtbl = rx_vtbl;
+    b->rpc_rx_vtbl = rpc_rx_vtbl;
     return SYS_ERR_OK;
 }
 
index 7174860..97b6a07 100644 (file)
@@ -48,15 +48,14 @@ static void write_and_check_32(uint32_t pat, size_t start_lba, size_t block_size
     free(buf);
 
     printf("reading data\n");
-    size_t bytes_read;
-    err = ata_rw28_rpc.vtbl.read_dma(&ata_rw28_rpc, bytes, start_lba, &buf, &bytes_read);
+    struct ata_rw28_read_dma_response__rx_args reply;
+    err = ata_rw28_rpc.vtbl.read_dma(&ata_rw28_rpc, bytes, start_lba, reply.buffer, &reply.buffer_size);
     if (err_is_fail(err))
         USER_PANIC_ERR(err, "read_dma rpc");
-    if (!buf)
-        USER_PANIC("read_dma -> !buf");
-    if (bytes_read != bytes)
+    if (reply.buffer_size != bytes)
         USER_PANIC("read_dma -> read_size != size");
 
+    buf = reply.buffer;
     printf("checking data\n");
     for (size_t i = 0; i < count; ++i)
     {
@@ -68,7 +67,6 @@ static void write_and_check_32(uint32_t pat, size_t start_lba, size_t block_size
                     i*step, val, pat);
         }
     }
-    free(buf);
 
     printf("write_and_check_32 completed\n");
 }