flounder: merging rpc client with a binding layer
authorAdam Turowski <adam.turowski@inf.ethz.ch>
Tue, 28 Feb 2017 11:49:22 +0000 (12:49 +0100)
committerAdam Turowski <adam.turowski@inf.ethz.ch>
Tue, 28 Feb 2017 15:38:57 +0000 (16:38 +0100)
Signed-off-by: Adam Turowski <adam.turowski@inf.ethz.ch>

101 files changed:
if/dma.if
if/interphi.if
if/xeon_phi_driver.if
include/acpi_client/acpi_client.h
include/barrelfish/core_state.h
include/barrelfish/domain.h
include/barrelfish/spawn_client.h
include/usb/usb_driver.h
lib/acpi_client/acpi_client.c
lib/ahci/storage_vsic.c
lib/angler/angler.c
lib/barrelfish/capabilities.c
lib/barrelfish/debug.c
lib/barrelfish/domain.c
lib/barrelfish/inthandler.c
lib/barrelfish/monitor_client.c
lib/barrelfish/nameservice_client.c
lib/barrelfish/ram_alloc.c
lib/barrelfish/resource_ctrl.c
lib/barrelfish/spawn_client.c
lib/bulk_transfer/backends/net/bulk_net_e10k.c
lib/devif/backends/idc/desc_queue.c
lib/devif/backends/net/solarflare/devif_backend_solarflare.c
lib/dma/client/dma_client_channel.c
lib/dma/dma_mgr_client.c
lib/dma/dma_service.c
lib/int_route/client/client.c
lib/lwip/src/barrelfish/ARP_lookup_client.c
lib/lwip/src/barrelfish/idc_barrelfish.c
lib/lwip/src/barrelfish/idc_net_control.c
lib/net_device_manager/soft_filt_cl_impl.c
lib/net_queue_manager/net_soft_filters_srv_impl.c
lib/pci/pci_client.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_device.c
lib/usb/usb_manager_client.c
lib/usb/usb_manager_client.h
lib/usb/usb_request.c
lib/usb/usb_transfer.c
lib/vfs/cache.c
lib/vfs/vfs_blockdevfs_ahci.c
lib/vfs/vfs_blockdevfs_ata.c
lib/vfs/vfs_fat.c
lib/vfs/vfs_ramfs.c
lib/virtio/guest/channel_flounder.c
lib/virtio/host/channel_flounder.c
lib/xeon_phi/xeon_phi_domain.c
lib/xeon_phi/xeon_phi_manager_client.c
tools/flounder/BackendCommon.hs
tools/flounder/GCBackend.hs
tools/flounder/GHBackend.hs
tools/flounder/Loopback.hs
tools/flounder/RPCClient.hs
usr/acpi/acpi_allocators.c
usr/acpi/acpi_main.c
usr/acpi/arch/x86/acpi_allocators_arch.c
usr/arrakismon/vmkitmon.c
usr/bench/freemem_bench/freemem.c
usr/drivers/cpuboot/common.c
usr/drivers/cpuboot/coreboot.h
usr/drivers/cpuboot/main.c
usr/drivers/cpuboot/x86boot.c
usr/drivers/e10k/e10k_vf.c
usr/drivers/solarflare/sfn5122f_cdriver.c
usr/drivers/usb/usb_manager/include/usb_transfer.h
usr/drivers/usb/usb_manager/usb_driver.c
usr/drivers/usb/usb_manager/usb_manager.c
usr/drivers/usb/usb_manager/usb_request.c
usr/drivers/xeon_phi/domain.c
usr/drivers/xeon_phi/service.c
usr/examples/xmpl-rpc/rpc_rpc.c
usr/fbdemo/main.c
usr/fish/fish_common.c
usr/kaluga/armv7.c
usr/kaluga/armv7_startup.c
usr/kaluga/armv8.c
usr/kaluga/device_caps.c
usr/kaluga/driver_startup.c
usr/mem_serv/mem_serv.c
usr/mem_serv_dist/hybrid_support.c
usr/mem_serv_dist/mem_serv.c
usr/mem_serv_dist/steal.c
usr/mem_serv_dist/thc_support.c
usr/monitor/capops/delete.c
usr/monitor/domain.c
usr/monitor/octopus_client.c
usr/monitor/ram_alloc.c
usr/pci/pci.c
usr/pci/pci_service.c
usr/pci/pcie.c
usr/pci/pcimain.c
usr/ramfsd/main.c
usr/slideshow/main.c
usr/spawnd/service.c
usr/tests/ata_rw28_test/ata_rw28_test.c
usr/tests/mt_waitset/main.c
usr/tests/rpc_cap_test/rpc_cap_test.c

index f6af00d..09b2eb4 100644 (file)
--- a/if/dma.if
+++ b/if/dma.if
@@ -19,7 +19,7 @@ interface dma "Generic DMA service interface" {
         * 
         * Note: either local or remote memory must be registered
         */
-    rpc register(in cap memory, out errval msgerr);
+    rpc register_(in cap memory, out errval msgerr);
     
 
     /**
index 33fb889..edeafa3 100644 (file)
@@ -76,7 +76,7 @@ interface interphi "Interface between host and card side driver" {
      */
 
 
-    rpc register(in uint8 id,
+    rpc register_(in uint8 id,
                  in uint64 local_apt_base,
                  in uint64 local_apt_size,
                  out errval msgerr,
index 44faa8f..b4fb832 100644 (file)
@@ -13,7 +13,7 @@
 
 interface xeon_phi_driver "Xeon Phi Service Interface" {
 
-    rpc register(in uint8 id, 
+    rpc register_(in uint8 id, 
                  in uint64 local_apt_base,
                  in uint64 local_apt_size, 
                  out errval msgerr, 
index b7ad66c..a5b0e04 100644 (file)
 #include <errors/errno.h>
 
 /* forward declaration */
-struct acpi_rpc_client;
+struct acpi_binding;
 
 typedef uint64_t acpi_device_handle_t;
 
 
-struct acpi_rpc_client* get_acpi_rpc_client(void);
+struct acpi_binding* get_acpi_binding(void);
 errval_t connect_to_acpi(void);
 
 errval_t acpi_client_get_device_handle(const char *dev_id,
index e49954b..2b4e32a 100644 (file)
@@ -54,7 +54,7 @@ struct ram_alloc_state {
 
 struct skb_state {
     bool request_done;
-    struct skb_rpc_client *skb;
+    struct skb_binding *skb;
 };
 
 struct slot_alloc_state {
@@ -74,24 +74,25 @@ struct slot_alloc_state {
 };
 
 struct terminal_state;
-struct octopus_rpc_client;
+struct octopus_binding;
 struct domain_state;
 struct spawn_state;
 struct monitor_binding;
-struct mem_rpc_client;
-struct spawn_rpc_client;
-struct arrakis_rpc_client;
+struct monitor_blocking_binding;
+struct mem_binding;
+struct spawn_binding;
+struct arrakis_binding;
 
 struct core_state_generic {
     struct waitset default_waitset;
     struct monitor_binding *monitor_binding;
-    struct monitor_blocking_rpc_client *monitor_blocking_rpc_client;
-    struct mem_rpc_client *mem_st;
+    struct monitor_blocking_binding *monitor_blocking_binding;
+    struct mem_binding *mem_st;
     struct morecore_state morecore_state;
     struct ram_alloc_state ram_alloc_state;
-    struct octopus_rpc_client *octopus_rpc_client;
-    struct spawn_rpc_client *spawn_rpc_clients[MAX_CPUS];
-    struct arrakis_rpc_client *arrakis_rpc_clients[MAX_CPUS];
+    struct octopus_binding *octopus_binding;
+    struct spawn_binding *spawn_bindings[MAX_CPUS];
+    struct arrakis_binding *arrakis_bindings[MAX_CPUS];
     struct terminal_state *terminal_state;
     struct domain_state *domain_state;
     struct spawn_state *spawn_state;
index ab185f7..6910996 100644 (file)
@@ -23,13 +23,13 @@ __BEGIN_DECLS
 
 typedef void (*domain_spanned_callback_t)(void *arg, errval_t err);
 
-struct mem_rpc_client;
-struct octopus_rpc_client;
+struct mem_binding;
+struct octopus_binding;
 struct monitor_binding;
-struct monitor_blocking_rpc_client;
+struct monitor_blocking_binding;
 struct waitset;
-struct spawn_rpc_client;
-struct arrakis_rpc_client;
+struct spawn_binding;
+struct arrakis_binding;
 
 struct waitset *get_default_waitset(void);
 void disp_set_core_id(coreid_t core_id);
@@ -41,21 +41,21 @@ domainid_t disp_get_domain_id(void);
 coreid_t disp_handle_get_core_id(dispatcher_handle_t handle);
 void set_monitor_binding(struct monitor_binding *b);
 struct monitor_binding *get_monitor_binding(void);
-void set_monitor_blocking_rpc_client(struct monitor_blocking_rpc_client *st);
-struct monitor_blocking_rpc_client *get_monitor_blocking_rpc_client(void);
-void set_mem_client(struct mem_rpc_client *st);
-struct mem_rpc_client *get_mem_client(void);
+void set_monitor_blocking_binding(struct monitor_blocking_binding *st);
+struct monitor_blocking_binding *get_monitor_blocking_binding(void);
+void set_mem_client(struct mem_binding *st);
+struct mem_binding *get_mem_client(void);
 struct pinned_state *get_current_pinned_state(void);
 struct vspace *get_current_vspace(void);
 struct pmap *get_current_pmap(void);
 struct morecore_state *get_morecore_state(void);
 struct ram_alloc_state *get_ram_alloc_state(void);
-void set_octopus_rpc_client(struct octopus_rpc_client *st);
-struct octopus_rpc_client *get_octopus_rpc_client(void);
-void set_spawn_rpc_client(coreid_t core, struct spawn_rpc_client *st);
-void set_arrakis_rpc_client(coreid_t core, struct arrakis_rpc_client *st);
-struct spawn_rpc_client *get_spawn_rpc_client(coreid_t core);
-struct arrakis_rpc_client *get_arrakis_rpc_client(coreid_t core);
+void set_octopus_binding(struct octopus_binding *st);
+struct octopus_binding *get_octopus_binding(void);
+void set_spawn_binding(coreid_t core, struct spawn_binding *st);
+void set_arrakis_binding(coreid_t core, struct arrakis_binding *st);
+struct spawn_binding *get_spawn_binding(coreid_t core);
+struct arrakis_binding *get_arrakis_binding(coreid_t core);
 struct terminal_state *get_terminal_state(void);
 void set_terminal_state(struct terminal_state *st);
 struct domain_state *get_domain_state(void);
index 3a83a09..9bb1d8f 100644 (file)
@@ -49,7 +49,7 @@ errval_t spawn_wait_coreid(coreid_t coreid, domainid_t domainid, uint8_t *exitco
 errval_t spawn_wait(domainid_t domainid, uint8_t *exitcode, bool nohang);
 errval_t spawn_wait_core(coreid_t coreid, domainid_t domainid,
                          uint8_t *exitcode, bool nohang);
-errval_t spawn_rpc_client(coreid_t coreid, struct spawn_rpc_client **ret_client);
+errval_t spawn_binding(coreid_t coreid, struct spawn_binding **ret_client);
 errval_t spawn_get_domain_list(uint8_t **domains, size_t *len);
 errval_t spawn_get_status(uint8_t domain, struct spawn_ps_entry *pse,
                           char **argbuf, size_t *arglen, errval_t *reterr);
index 25ae3fe..12526af 100644 (file)
@@ -15,6 +15,6 @@
 #include <usb/usb_request.h>
 
 #include <if/usb_manager_defs.h>
-#include <if/usb_manager_rpcclient_defs.h>
+#include <if/usb_manager_defs.h>
 
 #endif /* LIB_USB_DRIVER_H_ */
index 6ea5c63..40a6943 100644 (file)
@@ -17,7 +17,7 @@
 #include <barrelfish/nameservice_client.h>
 
 #include <if/acpi_defs.h>
-#include <if/acpi_rpcclient_defs.h>
+#include <if/acpi_defs.h>
 
 #include <acpi_client/acpi_client.h>
 
@@ -26,47 +26,47 @@ static struct acpi_connection {
     errval_t err;
 } state;
 
-static struct acpi_rpc_client* rpc_client;
+static struct acpi_binding* binding;
 
 errval_t acpi_client_get_device_handle(const char *dev_id,
                                        acpi_device_handle_t *ret_handle)
 {
-    assert(rpc_client != NULL);
+    assert(binding != NULL);
     errval_t err, msgerr;
-    err = rpc_client->vtbl.get_handle(rpc_client, dev_id, ret_handle, &msgerr);
+    err = binding->rpc_tx_vtbl.get_handle(binding, dev_id, ret_handle, &msgerr);
     return err_is_fail(err) ? err : msgerr;
 }
 
 errval_t acpi_client_eval_integer(acpi_device_handle_t handle,
                                   const char *path, uint64_t *data)
 {
-    assert(rpc_client != NULL);
+    assert(binding != NULL);
     errval_t err, msgerr;
-    err = rpc_client->vtbl.eval_integer(rpc_client, handle, path, data, &msgerr);
+    err = binding->rpc_tx_vtbl.eval_integer(binding, handle, path, data, &msgerr);
     return err_is_fail(err) ? err : msgerr;
 }
 
 
 errval_t acpi_reset(void)
 {
-    assert(rpc_client != NULL);
+    assert(binding != NULL);
     errval_t err, msgerr;
-    err = rpc_client->vtbl.reset(rpc_client, &msgerr);
+    err = binding->rpc_tx_vtbl.reset(binding, &msgerr);
     return err_is_fail(err) ? err : msgerr;
 }
 
 errval_t acpi_sleep(int st)
 {
-    assert(rpc_client != NULL);
+    assert(binding != NULL);
     errval_t err, msgerr;
-    err = rpc_client->vtbl.sleep(rpc_client, st, &msgerr);
+    err = binding->rpc_tx_vtbl.sleep(binding, st, &msgerr);
     return err_is_fail(err) ? err : msgerr;
 }
 
 // Kludge for VBE driver
 errval_t acpi_get_vbe_bios_cap(struct capref *retcap, size_t *retsize)
 {
-    assert(rpc_client != NULL);
+    assert(binding != NULL);
     errval_t err, msgerr;
     assert(retcap != NULL);
     assert(retsize != NULL);
@@ -75,67 +75,62 @@ errval_t acpi_get_vbe_bios_cap(struct capref *retcap, size_t *retsize)
     if (err_is_fail(err)) {
         return err;
     }
-    err = rpc_client->vtbl.get_vbe_bios_cap(rpc_client, &msgerr, retcap, &s);
+    err = binding->rpc_tx_vtbl.get_vbe_bios_cap(binding, &msgerr, retcap, &s);
     *retsize = s;
     return err_is_fail(err) ? err : msgerr;
 }
 
 errval_t vtd_create_domain(struct capref pml4)
 {
-    assert(rpc_client != NULL);
+    assert(binding != NULL);
     errval_t err, msgerr;
-    err = rpc_client->vtbl.create_domain(rpc_client, pml4, &msgerr);
+    err = binding->rpc_tx_vtbl.create_domain(binding, pml4, &msgerr);
     return err_is_fail(err) ? err : msgerr;
 }
 
 errval_t vtd_delete_domain(struct capref pml4)
 {
-    assert(rpc_client != NULL);
+    assert(binding != NULL);
     errval_t err, msgerr;
-    err = rpc_client->vtbl.delete_domain(rpc_client, pml4, &msgerr);
+    err = binding->rpc_tx_vtbl.delete_domain(binding, pml4, &msgerr);
     return err_is_fail(err) ? err : msgerr;
 }
 
-errval_t vtd_domain_add_device(int seg, int bus, int dev, int func, struct capref pml4) 
+errval_t vtd_domain_add_device(int seg, int bus, int dev, int func, struct capref pml4)
 {
-    assert(rpc_client != NULL);
+    assert(binding != NULL);
     errval_t err, msgerr;
-    err = rpc_client->vtbl.vtd_add_device(rpc_client, seg, bus, dev, func, pml4, &msgerr);
+    err = binding->rpc_tx_vtbl.vtd_add_device(binding, seg, bus, dev, func, pml4, &msgerr);
     return err_is_fail(err) ? err : msgerr;
 }
 
-errval_t vtd_domain_remove_device(int seg, int bus, int dev, int func, struct capref pml4) 
+errval_t vtd_domain_remove_device(int seg, int bus, int dev, int func, struct capref pml4)
 {
-    assert(rpc_client != NULL);
+    assert(binding != NULL);
     errval_t err, msgerr;
-    err = rpc_client->vtbl.vtd_remove_device(rpc_client, seg, bus, dev, func, pml4, &msgerr);
+    err = binding->rpc_tx_vtbl.vtd_remove_device(binding, seg, bus, dev, func, pml4, &msgerr);
     return err_is_fail(err) ? err : msgerr;
 }
 
 errval_t vtd_add_devices(void)
 {
-    assert(rpc_client != NULL);
+    assert(binding != NULL);
     errval_t err, msgerr;
-    err = rpc_client->vtbl.vtd_id_dom_add_devices(rpc_client, &msgerr);
+    err = binding->rpc_tx_vtbl.vtd_id_dom_add_devices(binding, &msgerr);
     return err_is_fail(err) ? err : msgerr;
 }
 
-struct acpi_rpc_client* get_acpi_rpc_client(void)
+struct acpi_binding* get_acpi_binding(void)
 {
-    assert(rpc_client != NULL);
-    return rpc_client;
+    assert(binding != NULL);
+    return binding;
 }
 
 static void rpc_bind_cb(void *st, errval_t err, struct acpi_binding* b)
 {
     if (err_is_ok(err)) {
-        rpc_client = malloc(sizeof(struct acpi_rpc_client));
-        assert(rpc_client != NULL);
-
-        err = acpi_rpc_client_init(rpc_client, b);
-        if (err_is_fail(err)) {
-            free(rpc_client);
-        }
+        binding = b;
+        acpi_rpc_client_init(binding);
     } // else: Do nothing
 
     assert(!state.is_done);
index 1107d9e..0ee3463 100644 (file)
 #include <barrelfish/waitset.h>
 #include <if/ata_rw28_defs.h>
 #include <if/ata_rw28_ahci_defs.h>
-#include <if/ata_rw28_rpcclient_defs.h>
+#include <if/ata_rw28_defs.h>
 #include <storage/vsic.h>
 
 struct ahci_vsic {
     struct ahci_ata_rw28_binding ahci_ata_rw28_binding;
-    struct ata_rw28_rpc_client ata_rw28_rpc;
+    struct ata_rw28_binding ata_rw28_rpc;
     struct ata_rw28_binding *ata_rw28_binding;
     struct ahci_binding *ahci_binding;
     errval_t bind_err;
@@ -31,7 +31,7 @@ static errval_t vsic_write(struct storage_vsic *vsic, struct storage_vsa *vsa,
     struct ahci_vsic *mydata = vsic->data;
     errval_t status;
 
-    errval_t err = mydata->ata_rw28_rpc.vtbl.
+    errval_t err = mydata->ata_rw28_rpc->rpc_tx_vtbl.
       write_dma(&mydata->ata_rw28_rpc, buffer, STORAGE_VSIC_ROUND(vsic, size),
                offset, &status);
     if (err_is_fail(err)) {
@@ -54,7 +54,7 @@ static errval_t vsic_read(struct storage_vsic *vsic, struct storage_vsa *vsa,
     uint8_t *buf = NULL;
     size_t bytes_read, toread = STORAGE_VSIC_ROUND(vsic, size);
 
-    errval_t err = mydata->ata_rw28_rpc.vtbl.
+    errval_t err = mydata->ata_rw28_rpc->rpc_tx_vtbl.
       read_dma(&mydata->ata_rw28_rpc, toread, offset, &buf, &bytes_read);
     if (err_is_fail(err))
         USER_PANIC_ERR(err, "read_dma rpc");
@@ -77,7 +77,7 @@ static errval_t vsic_flush(struct storage_vsic *vsic, struct storage_vsa *vsa)
   struct ahci_vsic *mydata = vsic->data;
   errval_t outerr;
 
-  errval_t err = mydata->ata_rw28_rpc.vtbl.
+  errval_t err = mydata->ata_rw28_rpc->rpc_tx_vtbl.
     flush_cache(&mydata->ata_rw28_rpc, &outerr);
   assert(err_is_ok(err));
 
@@ -132,10 +132,10 @@ static errval_t ahci_vsic_alloc(struct storage_vsic *vsic, uint8_t port)
         (struct ata_rw28_binding*)&mydata->ahci_ata_rw28_binding;
 
     // init RPC client
-    err = ata_rw28_rpc_client_init(&mydata->ata_rw28_rpc,
+    err = ata_rw28_binding_init(&mydata->ata_rw28_rpc,
                                    mydata->ata_rw28_binding);
     if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "ata_rw28_rpc_client_init");
+        USER_PANIC_ERR(err, "ata_rw28_binding_init");
     }
 
     // Init VSIC data structure
index c502000..b08d178 100644 (file)
@@ -19,8 +19,8 @@
 #include <barrelfish/waitset.h>
 #include <if/monitor_defs.h>
 #include <if/terminal_session_defs.h>
-#include <if/terminal_session_rpcclient_defs.h>
-#include <if/octopus_rpcclient_defs.h>
+#include <if/terminal_session_defs.h>
+#include <if/octopus_defs.h>
 #include <octopus/getset.h> /* For SET_DEFAULT */
 #include <octopus/trigger.h> /* For NOP_TRIGGER */
 
@@ -81,7 +81,6 @@ errval_t angler_new_session_with_iref(iref_t session_iref,
     errval_t err = SYS_ERR_OK;
     errval_t error = SYS_ERR_OK;
     struct _angler_state *state = NULL;
-    struct terminal_session_rpc_client rpc_client;
     struct waitset ws;
     iref_t in_iref;
     iref_t out_iref;
@@ -122,15 +121,11 @@ errval_t angler_new_session_with_iref(iref_t session_iref,
     }
 
     /* Initialize rpc client. */
-    err = terminal_session_rpc_client_init(&rpc_client, state->binding);
-    if (err_is_fail(err)) {
-        err = err_push(err, ANGLER_ERR_INIT_RPCCLIENT);
-        goto out;
-    }
+    terminal_session_rpc_client_init(state->binding);
 
     /* Associate session with terminal. */
-    err = rpc_client.vtbl.session_associate_with_terminal
-            (&rpc_client, *session_id, &in_iref, &out_iref, &conf_iref, &error);
+    err = state->binding->rpc_tx_vtbl.session_associate_with_terminal
+            (state->binding, *session_id, &in_iref, &out_iref, &conf_iref, &error);
     if (err_is_fail(err)) {
         err = err_push(err, ANGLER_ERR_ASSOCIATE_WITH_TERMINAL);
         goto out;
@@ -174,12 +169,12 @@ static errval_t store_session_state(struct capref *session_id,
 {
     errval_t err = SYS_ERR_OK;
     errval_t error;
-    struct octopus_rpc_client *rpc_client = NULL;
+    struct octopus_binding *rpc_client = NULL;
     char *attributes = NULL;
     size_t attributes_len = 0;
     octopus_trigger_id_t tid;
 
-    rpc_client = get_octopus_rpc_client();
+    rpc_client = get_octopus_binding();
     assert(rpc_client != NULL);
 
     /* Build attributes. */
@@ -192,7 +187,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,
+    err = rpc_client->rpc_tx_vtbl.set_with_idcap(rpc_client, *session_id, attributes,
                                            SET_DEFAULT, NOP_TRIGGER, false,
                                            NULL, &tid, &error);
     if (err_is_fail(err)) {
index c651225..89034f0 100644 (file)
@@ -19,7 +19,7 @@
 #include <barrelfish/caddr.h>
 #include <barrelfish/lmp_endpoints.h>
 #include <if/monitor_defs.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 #include <barrelfish/monitor_client.h>
 #include <trace/trace.h>
 #include <stdio.h>
@@ -173,7 +173,7 @@ static errval_t cap_retype_remote(struct capref src_root, struct capref dest_roo
                                   gensize_t objsize, size_t count, capaddr_t to,
                                   capaddr_t slot, int to_level)
 {
-    struct monitor_blocking_rpc_client *mrc = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *mrc = get_monitor_blocking_binding();
     if (!mrc) {
         return LIB_ERR_MONITOR_RPC_NULL;
     }
@@ -181,7 +181,7 @@ static errval_t cap_retype_remote(struct capref src_root, struct capref dest_roo
     errval_t err, remote_cap_err;
     int send_count = 0;
     do {
-        err = mrc->vtbl.remote_cap_retype(mrc, src_root, dest_root, src,
+        err = mrc->rpc_tx_vtbl.remote_cap_retype(mrc, src_root, dest_root, src,
                                           offset, (uint64_t)new_type, objsize,
                                           count, to, slot, to_level, &remote_cap_err);
         if (err_is_fail(err)){
@@ -206,7 +206,7 @@ static errval_t cap_retype_remote(struct capref src_root, struct capref dest_roo
  */
 static errval_t cap_delete_remote(struct capref root, capaddr_t src, uint8_t level)
 {
-    struct monitor_blocking_rpc_client *mrc = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *mrc = get_monitor_blocking_binding();
     if (!mrc) {
         return LIB_ERR_MONITOR_RPC_NULL;
     }
@@ -214,7 +214,7 @@ static errval_t cap_delete_remote(struct capref root, capaddr_t src, uint8_t lev
     errval_t err, remote_cap_err;
     int count = 0;
     do {
-        err = mrc->vtbl.remote_cap_delete(mrc, root, src, level,
+        err = mrc->rpc_tx_vtbl.remote_cap_delete(mrc, root, src, level,
                                           &remote_cap_err);
         if (err_is_fail(err)){
             DEBUG_ERR(err, "remote cap delete\n");
@@ -237,7 +237,7 @@ static errval_t cap_delete_remote(struct capref root, capaddr_t src, uint8_t lev
  */
 static errval_t cap_revoke_remote(struct capref root, capaddr_t src, uint8_t level)
 {
-    struct monitor_blocking_rpc_client *mrc = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *mrc = get_monitor_blocking_binding();
     if (!mrc) {
         return LIB_ERR_MONITOR_RPC_NULL;
     }
@@ -245,7 +245,7 @@ static errval_t cap_revoke_remote(struct capref root, capaddr_t src, uint8_t lev
     errval_t err, remote_cap_err;
     int count = 0;
     do {
-        err = mrc->vtbl.remote_cap_revoke(mrc, root, src, level,
+        err = mrc->rpc_tx_vtbl.remote_cap_revoke(mrc, root, src, level,
                                           &remote_cap_err);
         if (err_is_fail(err)){
             DEBUG_ERR(err, "remote cap delete\n");
index d48c09f..1dfd66c 100644 (file)
@@ -19,7 +19,7 @@
 #include <barrelfish/debug.h>
 #include <barrelfish/sys_debug.h>
 #include <barrelfish/dispatch.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
@@ -88,11 +88,11 @@ errval_t debug_cap_identify(struct capref cap, struct capability *ret)
         struct capability capability;
     } u;
 
-    struct monitor_blocking_rpc_client *r = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *r = get_monitor_blocking_binding();
     if (!r) {
         return LIB_ERR_MONITOR_RPC_NULL;
     }
-    err = r->vtbl.cap_identify(r, cap, &msgerr, &u.caprep);
+    err = r->rpc_tx_vtbl.cap_identify(r, cap, &msgerr, &u.caprep);
     if (err_is_fail(err)){
         return err;
     } else if (err_is_fail(msgerr)) {
index e88e512..a882446 100644 (file)
@@ -1156,28 +1156,28 @@ struct monitor_binding *get_monitor_binding(void)
 /**
  * \brief set the  blocking rpc monitor client binding on the dispatcher priv
  */
-void set_monitor_blocking_rpc_client(struct monitor_blocking_rpc_client *st)
+void set_monitor_blocking_binding(struct monitor_blocking_binding *st)
 {
     dispatcher_handle_t handle = curdispatcher();
     struct dispatcher_generic* disp = get_dispatcher_generic(handle);
-    disp->core_state.c.monitor_blocking_rpc_client = st;
+    disp->core_state.c.monitor_blocking_binding = st;
 }
 
 /**
  * \brief Returns the blocking rpc monitor client binding on the
  * dispatcher priv
  */
-struct monitor_blocking_rpc_client *get_monitor_blocking_rpc_client(void)
+struct monitor_blocking_binding *get_monitor_blocking_binding(void)
 {
     dispatcher_handle_t handle = curdispatcher();
     struct dispatcher_generic* disp = get_dispatcher_generic(handle);
-    return disp->core_state.c.monitor_blocking_rpc_client;
+    return disp->core_state.c.monitor_blocking_binding;
 }
 
 /**
  * \brief set the mem client on the dispatcher priv
  */
-void set_mem_client(struct mem_rpc_client *st)
+void set_mem_client(struct mem_binding *st)
 {
     dispatcher_handle_t handle = curdispatcher();
     struct dispatcher_generic* disp = get_dispatcher_generic(handle);
@@ -1187,7 +1187,7 @@ void set_mem_client(struct mem_rpc_client *st)
 /**
  * \brief Returns the mem client on the dispatcher priv
  */
-struct mem_rpc_client *get_mem_client(void)
+struct mem_binding *get_mem_client(void)
 {
     dispatcher_handle_t handle = curdispatcher();
     struct dispatcher_generic* disp = get_dispatcher_generic(handle);
@@ -1257,62 +1257,62 @@ struct skb_state *get_skb_state(void)
 /**
  * \brief Returns a pointer to the octopus rpc client on the dispatcher priv
  */
-struct octopus_rpc_client *get_octopus_rpc_client(void)
+struct octopus_binding *get_octopus_binding(void)
 {
     dispatcher_handle_t handle = curdispatcher();
     struct dispatcher_generic* disp = get_dispatcher_generic(handle);
-    return disp->core_state.c.octopus_rpc_client;
+    return disp->core_state.c.octopus_binding;
 }
 
 /**
  * \brief Sets the octopus rpc client on the dispatcher priv
  */
-void set_octopus_rpc_client(struct octopus_rpc_client *c)
+void set_octopus_binding(struct octopus_binding *c)
 {
     dispatcher_handle_t handle = curdispatcher();
     struct dispatcher_generic* disp = get_dispatcher_generic(handle);
-    disp->core_state.c.octopus_rpc_client = c;
+    disp->core_state.c.octopus_binding = c;
 }
 
 /**
  * \brief Returns a pointer to the chips_context state on the dispatcher priv
  */
-struct spawn_rpc_client *get_spawn_rpc_client(coreid_t core)
+struct spawn_binding *get_spawn_binding(coreid_t core)
 {
     dispatcher_handle_t handle = curdispatcher();
     struct dispatcher_generic* disp = get_dispatcher_generic(handle);
     assert(core < MAX_CPUS);
-    return disp->core_state.c.spawn_rpc_clients[core];
+    return disp->core_state.c.spawn_bindings[core];
 }
 
 /**
  * \brief set the chips_context state on the dispatcher priv
  */
-void set_spawn_rpc_client(coreid_t core, struct spawn_rpc_client *c)
+void set_spawn_binding(coreid_t core, struct spawn_binding *c)
 {
     dispatcher_handle_t handle = curdispatcher();
     struct dispatcher_generic* disp = get_dispatcher_generic(handle);
     assert(core < MAX_CPUS);
-    disp->core_state.c.spawn_rpc_clients[core] = c;
+    disp->core_state.c.spawn_bindings[core] = c;
 }
 
-struct arrakis_rpc_client *get_arrakis_rpc_client(coreid_t core)
+struct arrakis_binding *get_arrakis_binding(coreid_t core)
 {
     dispatcher_handle_t handle = curdispatcher();
     struct dispatcher_generic* disp = get_dispatcher_generic(handle);
     assert(core < MAX_CPUS);
-    return disp->core_state.c.arrakis_rpc_clients[core];
+    return disp->core_state.c.arrakis_bindings[core];
 }
 
 /**
  * \brief set the chips_context state on the dispatcher priv
  */
-void set_arrakis_rpc_client(coreid_t core, struct arrakis_rpc_client *c)
+void set_arrakis_binding(coreid_t core, struct arrakis_binding *c)
 {
     dispatcher_handle_t handle = curdispatcher();
     struct dispatcher_generic* disp = get_dispatcher_generic(handle);
     assert(core < MAX_CPUS);
-    disp->core_state.c.arrakis_rpc_clients[core] = c;
+    disp->core_state.c.arrakis_bindings[core] = c;
 }
 
 /**
index 6391533..9c102fb 100644 (file)
@@ -14,7 +14,7 @@
 
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/inthandler.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 
 struct waitset *barrelfish_interrupt_waitset = NULL;
 
@@ -23,8 +23,8 @@ static errval_t arm_allocirq(struct capref ep, uint32_t irq)
 {
     errval_t err, msgerr;
 
-    struct monitor_blocking_rpc_client *r = get_monitor_blocking_rpc_client();
-    err = r->vtbl.arm_irq_handle(r, ep, irq, &msgerr);
+    struct monitor_blocking_binding *r = get_monitor_blocking_binding();
+    err = r->rpc_tx_vtbl.arm_irq_handle(r, ep, irq, &msgerr);
     if (err_is_fail(err)){
         return err;
     } else {
@@ -40,12 +40,12 @@ errval_t alloc_dest_irq_cap(struct capref *retcap)
 {
     errval_t err, msgerr;
 
-    struct monitor_blocking_rpc_client *r = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *r = get_monitor_blocking_binding();
     err = slot_alloc(retcap);
     if (err_is_fail(err)) {
         return err;
     }
-    err = r->vtbl.get_irq_dest_cap(r, retcap, &msgerr);
+    err = r->rpc_tx_vtbl.get_irq_dest_cap(r, retcap, &msgerr);
     if (err_is_fail(err)){
         return err;
     } else {
index d16ecbf..eb68424 100644 (file)
@@ -16,7 +16,7 @@
 #include <barrelfish/dispatcher_arch.h>
 #include <if/monitor_defs.h>
 #include <barrelfish/monitor_client.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 #include <string.h>
 #include <inttypes.h>
 
@@ -313,11 +313,11 @@ errval_t monitor_cap_set_remote(struct capref cap, bool remote)
 {
     return ERR_NOTIMP;
 #if 0
-    struct monitor_blocking_rpc_client *mc = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *mc = get_monitor_blocking_binding();
     assert(mc != NULL);
     errval_t err, reterr;
 
-    err = mc->vtbl.cap_set_remote(mc, cap, remote, &reterr);
+    err = mc->rpc_tx_vtbl.cap_set_remote(mc, cap, remote, &reterr);
     if(err_is_fail(err)) {
         return err;
     } else {
@@ -337,16 +337,8 @@ static void monitor_rpc_bind_continuation(void *st_arg, errval_t err,
     struct bind_state *st = st_arg;
 
     if (err_is_ok(err)) {
-        struct monitor_blocking_rpc_client *r =
-            malloc(sizeof(struct monitor_blocking_rpc_client));
-        assert(r != NULL);
-        err = monitor_blocking_rpc_client_init(r, b);
-        if (err_is_fail(err)) {
-            free(r);
-            USER_PANIC_ERR(err, "error in mem_rpc_client_init");
-        } else {
-            set_monitor_blocking_rpc_client(r);
-        }
+        monitor_blocking_rpc_client_init(b);
+        set_monitor_blocking_binding(b);
     }
 
     st->err  = err;
index 0818cf0..ac69858 100644 (file)
@@ -18,7 +18,6 @@
 #include <barrelfish/nameservice_client.h>
 
 #include <if/octopus_defs.h>
-#include <if/octopus_rpcclient_defs.h>
 #include <if/monitor_defs.h>
 #include <octopus/getset.h> // for oct_read TODO
 #include <octopus/trigger.h> // for NOP_TRIGGER
@@ -33,14 +32,14 @@ errval_t nameservice_lookup(const char *iface, iref_t *retiref)
 {
     errval_t err;
 
-    struct octopus_rpc_client *r = get_octopus_rpc_client();
+    struct octopus_binding *r = get_octopus_binding();
     if (r == NULL) {
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
 
 
     struct octopus_get_names_response__rx_args reply;
-    err = r->vtbl.get(r, iface, NOP_TRIGGER, reply.output, &reply.tid,
+    err = r->rpc_tx_vtbl.get(r, iface, NOP_TRIGGER, reply.output, &reply.tid,
                       &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
@@ -77,13 +76,13 @@ errval_t nameservice_blocking_lookup(const char *iface, iref_t *retiref)
 {
     errval_t err;
 
-    struct octopus_rpc_client *r = get_octopus_rpc_client();
+    struct octopus_binding *r = get_octopus_binding();
     if (r == NULL) {
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
 
     struct octopus_wait_for_response__rx_args reply;
-    err = r->vtbl.wait_for(r, iface, reply.record, &reply.error_code);
+    err = r->rpc_tx_vtbl.wait_for(r, iface, reply.record, &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
     }
@@ -119,7 +118,7 @@ errval_t nameservice_register(const char *iface, iref_t iref)
 {
     errval_t err = SYS_ERR_OK;
 
-    struct octopus_rpc_client *r = get_octopus_rpc_client();
+    struct octopus_binding *r = get_octopus_binding();
     if (r == NULL) {
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
@@ -135,7 +134,7 @@ errval_t nameservice_register(const char *iface, iref_t iref)
 
     octopus_trigger_id_t tid;
     errval_t error_code;
-    err = r->vtbl.set(r, record, 0, NOP_TRIGGER, 0, NULL, &tid, &error_code);
+    err = r->rpc_tx_vtbl.set(r, record, 0, NOP_TRIGGER, 0, NULL, &tid, &error_code);
     if (err_is_fail(err)) {
         goto out;
     }
@@ -167,16 +166,8 @@ static void bind_continuation(void *st_arg, errval_t err,
     if (err_is_ok(err)) {
         b->error_handler = error_handler;
 
-        struct octopus_rpc_client *r;
-        r = malloc(sizeof(struct octopus_rpc_client));
-        assert(r != NULL);
-        err = octopus_rpc_client_init(r, b);
-        if (err_is_fail(err)) {
-            free(r);
-            USER_PANIC_ERR(err, "error in nameservice_rpc_client_init");
-        } else {
-            set_octopus_rpc_client(r);
-        }
+        octopus_rpc_client_init(b);
+        set_octopus_binding(b);
     }
 
     st->err = err;
@@ -232,4 +223,3 @@ errval_t nameservice_client_blocking_bind(void)
 
     return st.err;
 }
-
index a21ddb4..1cfdcf8 100644 (file)
@@ -16,7 +16,7 @@
 #include <barrelfish/core_state.h>
 
 #include <if/monitor_defs.h>
-#include <if/mem_rpcclient_defs.h>
+#include <if/mem_defs.h>
 
 /* remote (indirect through a channel) version of ram_alloc, for most domains */
 static errval_t ram_alloc_remote(struct capref *ret, uint8_t size_bits,
@@ -60,8 +60,8 @@ static errval_t ram_alloc_remote(struct capref *ret, uint8_t size_bits,
 
     thread_mutex_lock(&ram_alloc_state->ram_alloc_lock);
 
-    struct mem_rpc_client *b = get_mem_client();
-    err = b->vtbl.allocate(b, size_bits, minbase, maxlimit, &result, ret);
+    struct mem_binding *b = get_mem_client();
+    err = b->rpc_tx_vtbl.allocate(b, size_bits, minbase, maxlimit, &result, ret);
 
     thread_mutex_unlock(&ram_alloc_state->ram_alloc_lock);
 
@@ -140,9 +140,9 @@ errval_t ram_available(genpaddr_t *available, genpaddr_t *total)
 {
     errval_t err;
 
-    struct mem_rpc_client *mc = get_mem_client();
+    struct mem_binding *mc = get_mem_client();
 
-    err = mc->vtbl.available(mc, available, total);
+    err = mc->rpc_tx_vtbl.available(mc, available, total);
     if(err_is_fail(err)) {
         USER_PANIC_ERR(err, "available");
     }
@@ -156,15 +156,8 @@ static void bind_continuation(void *st, errval_t err, struct mem_binding *b)
     assert(st == get_ram_alloc_state());
 
     if (err_is_ok(err)) {
-        struct mem_rpc_client *r = malloc(sizeof(struct mem_rpc_client));
-        assert(r != NULL);
-        err = mem_rpc_client_init(r, b);
-        if (err_is_fail(err)) {
-            free(r);
-            USER_PANIC_ERR(err, "error in mem_rpc_client_init");
-        } else {
-            set_mem_client(r);
-        }
+        mem_rpc_client_init(b);
+        set_mem_client(b);
     }
 
     ram_alloc_state->mem_connect_err = err;
index 0b0475a..c61680c 100644 (file)
 #include <barrelfish/resource_ctrl.h>
 #include <barrelfish/curdispatcher_arch.h>
 #include <barrelfish/dispatcher_arch.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 
 errval_t rsrc_manifest(const char *manifest, rsrcid_t *id)
 {
-    struct monitor_blocking_rpc_client *b = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *b = get_monitor_blocking_binding();
     struct dispatcher_generic *d = get_dispatcher_generic(curdispatcher());
     errval_t err, msgerr;
 
-    err = b->vtbl.rsrc_manifest(b, d->dcb_cap, manifest, id, &msgerr);
+    err = b->rpc_tx_vtbl.rsrc_manifest(b, d->dcb_cap, manifest, id, &msgerr);
     assert(err_is_ok(err));
 
     return msgerr;
@@ -32,11 +32,11 @@ errval_t rsrc_manifest(const char *manifest, rsrcid_t *id)
 
 errval_t rsrc_join(rsrcid_t id)
 {
-    struct monitor_blocking_rpc_client *b = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *b = get_monitor_blocking_binding();
     struct dispatcher_generic *d = get_dispatcher_generic(curdispatcher());
     errval_t err, msgerr;
 
-    err = b->vtbl.rsrc_join(b, id, d->dcb_cap, &msgerr);
+    err = b->rpc_tx_vtbl.rsrc_join(b, id, d->dcb_cap, &msgerr);
     assert(err_is_ok(err));
 
     return msgerr;
@@ -44,6 +44,6 @@ errval_t rsrc_join(rsrcid_t id)
 
 errval_t rsrc_phase(rsrcid_t id, uint32_t phase)
 {
-    struct monitor_blocking_rpc_client *b = get_monitor_blocking_rpc_client();
-    return b->vtbl.rsrc_phase(b, id, phase);
+    struct monitor_blocking_binding *b = get_monitor_blocking_binding();
+    return b->rpc_tx_vtbl.rsrc_phase(b, id, phase);
 }
index ea26708..594d208 100644 (file)
 #include <barrelfish/nameservice_client.h>
 #include <barrelfish/spawn_client.h>
 #include <barrelfish/cpu_arch.h>
-#include <if/spawn_rpcclient_defs.h>
-#include <if/arrakis_rpcclient_defs.h>
+#include <if/spawn_defs.h>
+#include <if/arrakis_defs.h>
 #include <if/monitor_defs.h>
 #include <vfs/vfs_path.h>
 
 // For spawn_program_on_all_cores
 #include <octopus/getset.h> // for oct_read TODO
 #include <octopus/trigger.h> // for NOP_TRIGGER
-#include <if/octopus_rpcclient_defs.h>
+#include <if/octopus_defs.h>
 
 
 extern char **environ;
@@ -69,12 +69,12 @@ static struct spawn_binding *spawn_b = NULL;
 
 static errval_t bind_client(coreid_t coreid)
 {
-    struct spawn_rpc_client *cl;
+    struct spawn_binding *cl;
     errval_t err = SYS_ERR_OK;
 
     // do we have a spawn client connection for this core?
     assert(coreid < MAX_CPUS);
-    cl = get_spawn_rpc_client(coreid);
+    cl = get_spawn_binding(coreid);
     if (cl == NULL) {
         char namebuf[16];
         snprintf(namebuf, sizeof(namebuf), "spawn.%u", coreid);
@@ -107,18 +107,8 @@ static errval_t bind_client(coreid_t coreid)
 
         spawn_b = bindst.b;
 
-        cl = malloc(sizeof(struct spawn_rpc_client));
-        if (cl == NULL) {
-            return err_push(err, LIB_ERR_MALLOC_FAIL);
-        }
-
-        err = spawn_rpc_client_init(cl, bindst.b);
-        if (err_is_fail(err)) {
-            DEBUG_ERR(err, "spawn_rpc_client_init failed");
-            return err;
-        }
-
-        set_spawn_rpc_client(coreid, cl);
+        spawn_rpc_client_init(bindst.b);
+        set_spawn_binding(coreid, bindst.b);
     }
 
     return err;
@@ -160,7 +150,7 @@ errval_t spawn_program_with_caps(coreid_t coreid, const char *path,
         return err;
     }
 
-    struct spawn_rpc_client *cl = get_spawn_rpc_client(coreid);
+    struct spawn_binding *cl = get_spawn_binding(coreid);
     assert(cl != NULL);
 
     // construct argument "string"
@@ -214,11 +204,11 @@ errval_t spawn_program_with_caps(coreid_t coreid, const char *path,
     }
 
     if (capref_is_null(inheritcn_cap) && capref_is_null(argcn_cap)) {
-        err = cl->vtbl.spawn_domain(cl, path, argstr, argstrlen,
+        err = cl->rpc_tx_vtbl.spawn_domain(cl, path, argstr, argstrlen,
                                     envstr, envstrlen, flags,
                                     &msgerr, &domain_id);
     } else {
-        err = cl->vtbl.spawn_domain_with_caps(cl, path, argstr, argstrlen,
+        err = cl->rpc_tx_vtbl.spawn_domain_with_caps(cl, path, argstr, argstrlen,
                                               envstr, envstrlen, inheritcn_cap,
                                               argcn_cap, flags, &msgerr, &domain_id);
     }
@@ -242,7 +232,7 @@ errval_t spawn_arrakis_program(coreid_t coreid, const char *path,
                                struct capref argcn_cap, spawn_flags_t flags,
                                domainid_t *ret_domainid)
 {
-    struct arrakis_rpc_client *cl;
+    struct arrakis_binding *cl;
     errval_t err, msgerr;
 
     // default to copying our environment
@@ -252,7 +242,7 @@ errval_t spawn_arrakis_program(coreid_t coreid, const char *path,
 
     // do we have a arrakis client connection for this core?
     assert(coreid < MAX_CPUS);
-    cl = get_arrakis_rpc_client(coreid);
+    cl = get_arrakis_binding(coreid);
     if (cl == NULL) {
         char namebuf[16];
         snprintf(namebuf, sizeof(namebuf), "arrakis.%u", coreid);
@@ -283,15 +273,8 @@ errval_t spawn_arrakis_program(coreid_t coreid, const char *path,
         }
         assert(bindst.b != NULL);
 
-        cl = malloc(sizeof(struct arrakis_rpc_client));
-        assert(cl != NULL);
-
-        err = arrakis_rpc_client_init(cl, bindst.b);
-        if (err_is_fail(err)) {
-            USER_PANIC_ERR(err, "arrakis_rpc_client_init failed");
-        }
-
-        set_arrakis_rpc_client(coreid, cl);
+        arrakis_rpc_client_init(bindst.b);
+        set_arrakis_binding(coreid, bindst.b);
     }
 
     // construct argument "string"
@@ -344,7 +327,7 @@ errval_t spawn_arrakis_program(coreid_t coreid, const char *path,
         path = pathbuf;
     }
 
-    err = cl->vtbl.spawn_arrakis_domain(cl, path, argstr, argstrlen,
+    err = cl->rpc_tx_vtbl.spawn_arrakis_domain(cl, path, argstr, argstrlen,
                                         envstr, envstrlen, &msgerr, &domain_id);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "error sending arrakis request");
@@ -408,7 +391,7 @@ errval_t spawn_program_on_all_cores(bool same_core, const char *path,
     // TODO: handle flags, domain ID
     errval_t err = SYS_ERR_OK;
 
-    struct octopus_rpc_client *r = get_octopus_rpc_client();
+    struct octopus_binding *r = get_octopus_binding();
     if (r == NULL) {
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
@@ -419,7 +402,7 @@ errval_t spawn_program_on_all_cores(bool same_core, const char *path,
 
     static char* spawnds = "r'spawn.[0-9]+' { iref: _ }";
     struct octopus_get_names_response__rx_args reply;
-    err = r->vtbl.get_names(r, spawnds, NOP_TRIGGER, reply.output, &reply.tid,
+    err = r->rpc_tx_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);
@@ -458,14 +441,14 @@ out:
     return err;
 }
 
-errval_t spawn_rpc_client(coreid_t coreid, struct spawn_rpc_client **ret_client)
+errval_t spawn_binding(coreid_t coreid, struct spawn_binding **ret_client)
 {
     errval_t err = bind_client(coreid);
     if (err_is_fail(err)) {
         return err;
     }
 
-    *ret_client = get_spawn_rpc_client(coreid);
+    *ret_client = get_spawn_binding(coreid);
     return SYS_ERR_OK;
 }
 
@@ -480,10 +463,10 @@ errval_t spawn_kill(domainid_t domainid)
     if (err_is_fail(err)) {
         return err;
     }
-    struct spawn_rpc_client *cl = get_spawn_rpc_client(disp_get_core_id());
+    struct spawn_binding *cl = get_spawn_binding(disp_get_core_id());
     assert(cl != NULL);
 
-    err = cl->vtbl.kill(cl, domainid, &reterr);
+    err = cl->rpc_tx_vtbl.kill(cl, domainid, &reterr);
     if (err_is_fail(err)) {
         return err;
     }
@@ -502,10 +485,10 @@ errval_t spawn_exit(uint8_t exitcode)
     if (err_is_fail(err)) {
         return err;
     }
-    struct spawn_rpc_client *cl = get_spawn_rpc_client(disp_get_core_id());
+    struct spawn_binding *cl = get_spawn_binding(disp_get_core_id());
     assert(cl != NULL);
 
-    err = cl->vtbl.exit(cl, disp_get_domain_id(), exitcode);
+    err = cl->rpc_tx_vtbl.exit(cl, disp_get_domain_id(), exitcode);
     if (err_is_fail(err)) {
         return err;
     }
@@ -534,10 +517,10 @@ errval_t spawn_wait_core(coreid_t coreid, domainid_t domainid,
     if (err_is_fail(err)) {
         return err;
     }
-    struct spawn_rpc_client *cl = get_spawn_rpc_client(coreid);
+    struct spawn_binding *cl = get_spawn_binding(coreid);
     assert(cl != NULL);
 
-    err = cl->vtbl.wait(cl, domainid, nohang, exitcode, &reterr);
+    err = cl->rpc_tx_vtbl.wait(cl, domainid, nohang, exitcode, &reterr);
     if (err_is_fail(err)) {
         return err;
     }
@@ -560,15 +543,15 @@ errval_t spawn_get_domain_list(uint8_t **domains, size_t *len)
 {
     errval_t err;
 
-    struct spawn_rpc_client *cl;
-    err = spawn_rpc_client(disp_get_core_id(), &cl);
+    struct spawn_binding *cl;
+    err = spawn_binding(disp_get_core_id(), &cl);
     if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "spawn_rpc_client");
+        USER_PANIC_ERR(err, "spawn_binding");
     }
     assert(cl != NULL);
 
     struct spawn_get_domainlist_response__rx_args reply;
-    err = cl->vtbl.get_domainlist(cl, reply.domains, len);
+    err = cl->rpc_tx_vtbl.get_domainlist(cl, reply.domains, len);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "get_domainlist");
     }
@@ -585,15 +568,15 @@ errval_t spawn_get_status(uint8_t domain, struct spawn_ps_entry *pse,
 {
     errval_t err;
 
-    struct spawn_rpc_client *cl;
-    err = spawn_rpc_client(disp_get_core_id(), &cl);
+    struct spawn_binding *cl;
+    err = spawn_binding(disp_get_core_id(), &cl);
     if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "spawn_rpc_client");
+        USER_PANIC_ERR(err, "spawn_binding");
     }
     assert(cl != NULL);
 
     struct spawn_status_response__rx_args reply;
-    err = cl->vtbl.status(cl, domain, (spawn_ps_entry_t *)pse, reply.argv,
+    err = cl->rpc_tx_vtbl.status(cl, domain, (spawn_ps_entry_t *)pse, reply.argv,
                           arglen, reterr);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "status");
@@ -614,10 +597,10 @@ errval_t spawn_dump_capabilities(domainid_t domainid)
     if (err_is_fail(err)) {
         return err;
     }
-    struct spawn_rpc_client *cl = get_spawn_rpc_client(disp_get_core_id());
+    struct spawn_binding *cl = get_spawn_binding(disp_get_core_id());
     assert(cl != NULL);
 
-    err = cl->vtbl.dump_capabilities(cl, domainid, &reterr);
+    err = cl->rpc_tx_vtbl.dump_capabilities(cl, domainid, &reterr);
     if (err_is_fail(err)) {
         return err;
     }
index dfd11f7..0227702 100644 (file)
@@ -19,9 +19,9 @@
 #include <pci/pci.h>
 
 #include <if/net_ports_defs.h>
-#include <if/net_ports_rpcclient_defs.h>
+#include <if/net_ports_defs.h>
+#include <if/net_ARP_defs.h>
 #include <if/net_ARP_defs.h>
-#include <if/net_ARP_rpcclient_defs.h>
 #include <if/e10k_defs.h>
 
 #include <dev/e10k_dev.h>
@@ -62,10 +62,10 @@ struct e10k_tx_event {
 };
 
 
-static struct net_ports_rpc_client net_ports_rpc;
+static struct net_ports_binding *net_ports_rpc;
 static bool net_ports_connected = false;
 
-static struct net_ARP_rpc_client net_arp_rpc;
+static struct net_ARP_binding *net_arp_rpc;
 static bool net_arp_connected = false;
 
 static errval_t update_rxtail(void *opaque, size_t tail);
@@ -101,7 +101,7 @@ static errval_t port_bind(uint64_t b_rx, uint64_t b_tx, uint64_t q,
 {
     errval_t err, msgerr;
 
-    err = net_ports_rpc.vtbl.bind_port(&net_ports_rpc, net_ports_PORT_UDP, port,
+    err = net_ports_rpc->rpc_tx_vtbl.bind_port(net_ports_rpc, net_ports_PORT_UDP, port,
             b_rx, b_tx, 0, q, &msgerr);
     if (err_is_fail(err)) {
         return err;
@@ -116,7 +116,7 @@ static errval_t port_get(uint64_t b_rx, uint64_t b_tx, uint64_t q,
 {
     errval_t err, msgerr;
 
-    err = net_ports_rpc.vtbl.get_port(&net_ports_rpc, net_ports_PORT_UDP,
+    err = net_ports_rpc->rpc_tx_vtbl.get_port(net_ports_rpc, net_ports_PORT_UDP,
             b_rx, b_tx, 0, q, &msgerr, port);
     if (err_is_fail(err)) {
         return err;
@@ -128,8 +128,8 @@ static errval_t port_get(uint64_t b_rx, uint64_t b_tx, uint64_t q,
 static void p_bind_cb(void *st, errval_t err, struct net_ports_binding *b)
 {
     assert(err_is_ok(err));
-    err = net_ports_rpc_client_init(&net_ports_rpc, b);
-    assert(err_is_ok(err));
+    net_ports_rpc = b;
+    net_ports_rpc_client_init(net_ports_rpc);
     net_ports_connected = true;
 }
 
@@ -164,7 +164,7 @@ static errval_t arp_ip_info(uint32_t *ip, uint32_t *gw, uint32_t *mask)
 {
     errval_t err, msgerr;
 
-    err = net_arp_rpc.vtbl.ip_info(&net_arp_rpc, 0, &msgerr, ip, gw, mask);
+    err = net_arp_rpc->rpc_tx_vtbl.ip_info(net_arp_rpc, 0, &msgerr, ip, gw, mask);
     if (err_is_fail(err)) {
         return err;
     }
@@ -176,7 +176,7 @@ static errval_t arp_lookup(uint32_t ip, uint64_t *mac)
 {
     errval_t err, msgerr;
 
-    err = net_arp_rpc.vtbl.ARP_lookup(&net_arp_rpc, ip, 0, true, &msgerr, mac);
+    err = net_arp_rpc->rpc_tx_vtbl.ARP_lookup(net_arp_rpc, ip, 0, true, &msgerr, mac);
     if (err_is_fail(err)) {
         return err;
     }
@@ -186,8 +186,8 @@ static errval_t arp_lookup(uint32_t ip, uint64_t *mac)
 static void a_bind_cb(void *st, errval_t err, struct net_ARP_binding *b)
 {
     assert(err_is_ok(err));
-    err = net_ARP_rpc_client_init(&net_arp_rpc, b);
-    assert(err_is_ok(err));
+    net_arp_rpc = b;
+    net_ARP_rpc_client_init(net_arp_rpc);
     net_arp_connected = true;
 }
 
@@ -725,4 +725,3 @@ errval_t bulk_e10k_arp_lookup(struct bulk_e10k *bu, uint32_t ip, uint64_t *mac)
 {
     return arp_lookup(htonl(ip), mac);
 }
-
index 8a14aa9..9748e78 100644 (file)
@@ -13,7 +13,7 @@
 #include <devif/backends/descq.h>
 #include <if/descq_data_defs.h>
 #include <if/descq_ctrl_defs.h>
-#include <if/descq_ctrl_rpcclient_defs.h>
+#include <if/descq_ctrl_defs.h>
 #include "../../queue_interface_internal.h"
 #include "descq_debug.h"
 
@@ -56,7 +56,7 @@ struct descq {
     // Flounder
     struct descq_data_binding* data;
     struct descq_ctrl_binding* ctrl;
-    struct descq_ctrl_rpc_client* rpc;
+    struct descq_ctrl_binding* rpc;
 
     // linked list
     struct descq* next;
@@ -171,7 +171,7 @@ static errval_t descq_notify(struct devq* q)
     struct descq* queue = (struct descq*) q;
     /*
     DESCQ_DEBUG("start \n");
-    err = queue->rpc->vtbl.notify(queue->rpc, &err2);
+    err = queue->rpc->rpc_tx_vtbl.notify(queue->rpc, &err2);
     err = err_is_fail(err) ? err : err2;
     DESCQ_DEBUG("end\n");
     */
@@ -195,7 +195,7 @@ static errval_t descq_control(struct devq* q, uint64_t cmd,
     struct descq* queue = (struct descq*) q;
 
     DESCQ_DEBUG("start \n");
-    err = queue->rpc->vtbl.control(queue->rpc, cmd, value, &err2);
+    err = queue->rpc->rpc_tx_vtbl.control(queue->rpc, cmd, value, &err2);
     err = err_is_fail(err) ? err : err2;
     DESCQ_DEBUG("end\n");
     return err;
@@ -208,7 +208,7 @@ static errval_t descq_register(struct devq* q, struct capref cap,
     struct descq* queue = (struct descq*) q;
 
     DESCQ_DEBUG("start %p\n", queue);
-    err = queue->rpc->vtbl.register_region(queue->rpc, cap, rid, &err2);
+    err = queue->rpc->rpc_tx_vtbl.register_region(queue->rpc, cap, rid, &err2);
     err = err_is_fail(err) ? err : err2;
     DESCQ_DEBUG("end\n");
     return err;
@@ -219,7 +219,7 @@ static errval_t descq_deregister(struct devq* q, regionid_t rid)
     errval_t err, err2;
     struct descq* queue = (struct descq*) q;
 
-    err = queue->rpc->vtbl.deregister_region(queue->rpc, rid, &err2);
+    err = queue->rpc->rpc_tx_vtbl.deregister_region(queue->rpc, rid, &err2);
     err = err_is_fail(err) ? err : err2;
     return err;
 }
@@ -451,10 +451,10 @@ static void ctrl_bind_cb(void *st, errval_t err, struct descq_ctrl_binding* b)
     struct descq* q = (struct descq*) st;
     DESCQ_DEBUG("Control interface bound \n");
     q->ctrl = b;
-    q->rpc = malloc(sizeof(struct descq_ctrl_rpc_client));
+    q->rpc = malloc(sizeof(struct descq_ctrl_binding));
     assert(q->rpc != NULL); 
 
-    err = descq_ctrl_rpc_client_init(q->rpc, b);
+    err = descq_ctrl_binding_init(q->rpc, b);
     assert(err_is_ok(err));
 
     b->rx_vtbl = ctrl_rx_vtbl;
@@ -603,7 +603,7 @@ errval_t descq_create(struct descq** q,
         }
 
         errval_t err2;
-        err = tmp->rpc->vtbl.create_queue(tmp->rpc, slots, rx, tx, &err2);
+        err = tmp->rpc->rpc_tx_vtbl.create_queue(tmp->rpc, slots, rx, tx, &err2);
         if (err_is_fail(err) || err_is_fail(err2)) {
             err = err_is_fail(err) ? err: err2;
             goto cleanup5;
index f60dab0..fbd5718 100644 (file)
@@ -16,7 +16,7 @@
 #include <devif/queue_interface.h>
 #include <pci/pci.h>
 #include <if/sfn5122f_devif_defs.h>
-#include <if/sfn5122f_devif_rpcclient_defs.h>
+#include <if/sfn5122f_devif_defs.h>
 #include <devif/backends/net/sfn5122f_devif.h>
 #include "../../../queue_interface_internal.h"
 #include "hw_queue.h"
@@ -90,20 +90,14 @@ static void bind_cb(void *st, errval_t err, struct sfn5122f_devif_binding *b)
     // Initi RPC client
     
     queue->b = b;
-    queue->rpc = malloc(sizeof(struct sfn5122f_devif_rpc_client));
-    assert(queue->rpc != NULL);
 
-    err = sfn5122f_devif_rpc_client_init(queue->rpc, b);
-    if (err_is_fail(err)) {
-       free(queue->rpc);
-    }   
-    queue->bound = true;   
+    sfn5122f_devif_binding_init(queue->b);
+    queue->bound = true;
 }
 
 
 static errval_t sfn5122f_register(struct devq* q, struct capref cap,
-                                  regionid_t rid) 
+                                  regionid_t rid)
 {
     uint64_t buftbl_idx = 0;
     errval_t err, err2;
@@ -112,7 +106,7 @@ static errval_t sfn5122f_register(struct devq* q, struct capref cap,
     struct sfn5122f_queue* queue = (struct sfn5122f_queue*) q;
 
     if (queue->userspace) {
-        err = queue->rpc->vtbl.register_region(queue->rpc, queue->id, cap, 
+        err = queue->b->b_tx_vtbl.register_region(queue->b, queue->id, cap,
                                                &buftbl_idx, &err2);
         if (err_is_fail(err) || err_is_fail(err2)) {
             err = err_is_fail(err) ? err: err2;
@@ -144,20 +138,20 @@ static errval_t sfn5122f_register(struct devq* q, struct capref cap,
 
     while (cur->next != NULL) {
         cur = cur->next;
-    }  
+    }
     
     cur->next = entry;
     
     return SYS_ERR_OK;
 }
 
-static errval_t sfn5122f_deregister(struct devq* q, regionid_t rid) 
+static errval_t sfn5122f_deregister(struct devq* q, regionid_t rid)
 {
     errval_t err, err2;
     
     struct sfn5122f_queue* queue = (struct sfn5122f_queue*) q;
 
-    // find region and translate to buftlb entry 
+    // find region and translate to buftlb entry
     struct region_entry* cur = queue->regions;
 
     if (cur == NULL) {
@@ -166,11 +160,11 @@ static errval_t sfn5122f_deregister(struct devq* q, regionid_t rid)
 
     while (cur->next != NULL && cur->rid != rid) {
         cur = cur->next;
-    }  
+    }
    
     // do rpc do inform carddriver to remove buftbl entries
     if (queue->userspace) {
-        err = queue->rpc->vtbl.deregister_region(queue->rpc, cur->buftbl_idx, cur->size,
+        err = queue->b->b_tx_vtbl.deregister_region(queue->b, cur->buftbl_idx, cur->size,
                                                  &err2);
         if (err_is_fail(err) || err_is_fail(err2)) {
             err = err_is_fail(err) ? err: err2;
@@ -197,14 +191,14 @@ static errval_t sfn5122f_notify(struct devq* q)
 }
 
 static errval_t enqueue_rx_buf(struct sfn5122f_queue* q, regionid_t rid,
-                               bufferid_t bid, lpaddr_t base, size_t len, 
+                               bufferid_t bid, lpaddr_t base, size_t len,
                                uint64_t flags)
 {
 
     DEBUG_QUEUE("Enqueueing RX buf \n");
     // check if there is space
     if (sfn5122f_queue_free_rxslots(q) == 0) {
-        printf("SFN5122F_%d: Not enough space in RX ring, not adding buffer\n", 
+        printf("SFN5122F_%d: Not enough space in RX ring, not adding buffer\n",
                 q->id);
         return SFN_ERR_ENQUEUE;
     }
@@ -222,19 +216,19 @@ static errval_t enqueue_rx_buf(struct sfn5122f_queue* q, regionid_t rid,
     
     // compute buffer table entry of the rx buffer and the within it offset
     uint64_t buftbl_idx = entry->buftbl_idx + (bid/BUF_SIZE);
-    uint16_t offset = bid & 0x00000FFF;    
+    uint16_t offset = bid & 0x00000FFF;
 
     // still in the same buffer table entry
     assert(buftbl_idx == (entry->buftbl_idx + ((bid+len-1)/BUF_SIZE)));
 
    
-    DEBUG_QUEUE("RX_BUF tbl_idx=%lu offset=%d flags=%lu \n", 
+    DEBUG_QUEUE("RX_BUF tbl_idx=%lu offset=%d flags=%lu \n",
                 buftbl_idx, offset, flags);
     if (q->userspace) {
         sfn5122f_queue_add_user_rxbuf_devif(q, buftbl_idx, offset,
                                             rid, bid, base, len, flags);
     } else {
-        sfn5122f_queue_add_rxbuf_devif(q, rid, bid, base, 
+        sfn5122f_queue_add_rxbuf_devif(q, rid, bid, base,
                                        len, flags);
     }
     sfn5122f_queue_bump_rxtail(q);
@@ -243,13 +237,13 @@ static errval_t enqueue_rx_buf(struct sfn5122f_queue* q, regionid_t rid,
 
 
 static errval_t enqueue_tx_buf(struct sfn5122f_queue* q, regionid_t rid,
-                               bufferid_t bid, lpaddr_t base, size_t len, 
+                               bufferid_t bid, lpaddr_t base, size_t len,
                                uint64_t flags)
 {
     DEBUG_QUEUE("Enqueueing TX buf \n");
     // check if there is space
     if (sfn5122f_queue_free_txslots(q) == 0) {
-        printf("SFN5122F_%d: Not enough space in TX ring, not adding buffer\n", 
+        printf("SFN5122F_%d: Not enough space in TX ring, not adding buffer\n",
                 q->id);
         return SFN_ERR_ENQUEUE;
     }
@@ -267,7 +261,7 @@ static errval_t enqueue_tx_buf(struct sfn5122f_queue* q, regionid_t rid,
     
     // compute buffer table entry of the rx buffer and the within it offset
     uint64_t buftbl_idx = entry->buftbl_idx + (bid/BUF_SIZE);
-    uint16_t offset = bid & 0x00000FFF;    
+    uint16_t offset = bid & 0x00000FFF;
 
 
     // still in the same buffer table entry
@@ -284,14 +278,14 @@ static errval_t enqueue_tx_buf(struct sfn5122f_queue* q, regionid_t rid,
     } else {
 
         DEBUG_QUEUE("TX_BUF flags=%lu \n", flags);
-        sfn5122f_queue_add_txbuf_devif(q, rid, bid, base, 
+        sfn5122f_queue_add_txbuf_devif(q, rid, bid, base,
                                        len, flags);
     }
     sfn5122f_queue_bump_txtail(q);
     return SYS_ERR_OK;
 }
 
-static errval_t sfn5122f_enqueue(struct devq* q, regionid_t rid, bufferid_t bid, 
+static errval_t sfn5122f_enqueue(struct devq* q, regionid_t rid, bufferid_t bid,
                                  lpaddr_t base, size_t len, uint64_t flags)
 {
     errval_t err;
@@ -305,24 +299,24 @@ static errval_t sfn5122f_enqueue(struct devq* q, regionid_t rid, bufferid_t bid,
         err = enqueue_rx_buf(queue, rid, bid, base, len, flags);
         if (err_is_fail(err)) {
             return err;
-        }      
+        }
     } else if (flags & NETIF_TXFLAG) {
         assert(len <= BASE_PAGE_SIZE);
 
         err = enqueue_tx_buf(queue, rid, bid, base, len, flags);
         if (err_is_fail(err)) {
             return err;
-        } 
+        }
     }
 
     return SYS_ERR_OK;
 }
 
-static errval_t sfn5122f_dequeue(struct devq* q, regionid_t* rid, bufferid_t* bid, 
+static errval_t sfn5122f_dequeue(struct devq* q, regionid_t* rid, bufferid_t* bid,
                                  lpaddr_t* base, size_t* len, uint64_t* flags)
 {
     uint8_t ev_code;
-    errval_t err = DEVQ_ERR_RX_EMPTY;    
+    errval_t err = DEVQ_ERR_RX_EMPTY;
     
     struct sfn5122f_queue* queue = (struct sfn5122f_queue*) q;
 
@@ -337,8 +331,8 @@ static errval_t sfn5122f_dequeue(struct devq* q, regionid_t* rid, bufferid_t* bi
         *len = queue->bufs[queue->last_deq].len;
         queue->num_left--;
         queue->last_deq++;
-        return SYS_ERR_OK;   
-    }    
+        return SYS_ERR_OK;
+    }
 
     while(true) {
         ev_code = sfn5122f_get_event_code(queue);
@@ -346,17 +340,17 @@ static errval_t sfn5122f_dequeue(struct devq* q, regionid_t* rid, bufferid_t* bi
         case EV_CODE_RX:
             // TODO multiple packets
             err = sfn5122f_queue_handle_rx_ev_devif(queue, rid, bid, base,
-                                                    len, flags);  
+                                                    len, flags);
             if (err_is_ok(err)) {
                 DEBUG_QUEUE(" RX_EV Q_ID: %d len %ld \n", queue->id, *len);
             }
             sfn5122f_queue_bump_evhead(queue);
             return SYS_ERR_OK;
         case EV_CODE_TX:
-            err = sfn5122f_queue_handle_tx_ev_devif(queue, rid, bid, base, 
+            err = sfn5122f_queue_handle_tx_ev_devif(queue, rid, bid, base,
                                                     len, flags);
             if (err_is_ok(err)) {
-                DEBUG_QUEUE("TX EVENT OK %d \n", queue->id);               
+                DEBUG_QUEUE("TX EVENT OK %d \n", queue->id);
             } else {
                 DEBUG_QUEUE("TX EVENT ERR %d \n", queue->id);
             }
@@ -386,7 +380,7 @@ static errval_t sfn5122f_dequeue(struct devq* q, regionid_t* rid, bufferid_t* bi
             sfn5122f_queue_bump_evhead(queue);
             break;
         case EV_CODE_NONE:
-            sfn5122f_evq_rptr_reg_wr(queue->device, queue->id, 
+            sfn5122f_evq_rptr_reg_wr(queue->device, queue->id,
                                      queue->ev_head);
             return err;
         }
@@ -409,7 +403,7 @@ static void interrupt_handler(void* arg)
  *
  */
 
-errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb, 
+errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb,
                                bool userlevel, bool interrupts)
 {
     DEBUG_QUEUE("create called \n");
@@ -428,7 +422,7 @@ errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb
         .update_rxtail = update_rxtail
      };
    
-    /* Allocate memory for descriptor rings  
+    /* Allocate memory for descriptor rings
        No difference for userspace networking*/
     // TODO too large ...
     total_size = sizeof(uint64_t)*(TX_ENTRIES + RX_ENTRIES + EV_ENTRIES);
@@ -484,7 +478,7 @@ errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb
 
     if (!interrupts) {
         printf("Solarflare queue used in polling mode \n");
-        err = queue->rpc->vtbl.create_queue(queue->rpc, frame, userlevel, interrupts, 
+        err = queue->b->b_tx_vtbl.create_queue(queue->b, frame, userlevel, interrupts, 
                                             0, 0, &queue->id, &regs, &err2);
         if (err_is_fail(err) || err_is_fail(err2)) {
             err = err_is_fail(err) ? err: err2;
@@ -497,9 +491,9 @@ errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb
 
         queue->core = disp_get_core_id();
         
-        err = queue->rpc->vtbl.create_queue(queue->rpc, frame, userlevel, 
+        err = queue->b->b_tx_vtbl.create_queue(queue->b, frame, userlevel,
                                             interrupts, queue->core,
-                                            queue->vector, &queue->id, 
+                                            queue->vector, &queue->id,
                                             &regs, &err2);
         if (err_is_fail(err) || err_is_fail(err2)) {
             err = err_is_fail(err) ? err: err2;
@@ -514,7 +508,7 @@ errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb
         return err;
     }
 
-    err = vspace_map_one_frame_attr(&queue->device_va, id.bytes, regs, 
+    err = vspace_map_one_frame_attr(&queue->device_va, id.bytes, regs,
                                     VREGION_FLAGS_READ_WRITE, NULL, NULL);
     if (err_is_fail(err)) {
         return err;
@@ -545,7 +539,7 @@ errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb
 errval_t sfn5122f_queue_destroy(struct sfn5122f_queue* q)
 {
     errval_t err, err2;
-    err = q->rpc->vtbl.destroy_queue(q->rpc, q->id, &err2);
+    err = q->b->b_tx_vtbl.destroy_queue(q->b, q->id, &err2);
     if (err_is_fail(err) || err_is_fail(err2)) {
         err = err_is_fail(err) ? err: err2;
         return err;
@@ -557,7 +551,7 @@ errval_t sfn5122f_queue_destroy(struct sfn5122f_queue* q)
     }
 
     free(q->device);
-    free(q->rpc);
+    free(q->b);
 
     err = devq_destroy(&(q->q));
     if (err_is_fail(err)){
@@ -571,4 +565,3 @@ errval_t sfn5122f_queue_destroy(struct sfn5122f_queue* q)
 
     return SYS_ERR_OK;
 }
-
index 965ae0c..c3bf9de 100644 (file)
@@ -193,7 +193,7 @@ static void memcpy_response_rx(struct dma_binding *_binding,
 }
 
 static struct dma_rx_vtbl dma_rxvtbl = {
-    .register_response = register_response_rx,
+    .register__response = register_response_rx,
     .deregister_response = deregister_response_rx,
     .memcpy_response = memcpy_response_rx,
     .done = done_msg_rx
@@ -209,7 +209,7 @@ static errval_t dma_client_channel_register_call_tx(struct txq_msg_st *msg_st)
 {
     struct svc_msg_st *st = (struct svc_msg_st *) msg_st;
 
-    return dma_register_call__tx(msg_st->queue->binding, TXQCONT(msg_st),
+    return dma_register__call__tx(msg_st->queue->binding, TXQCONT(msg_st),
                                  st->args.cap);
 }
 
index e203fb7..c8bbb6b 100644 (file)
 #include <debug.h>
 
 #include <if/dma_mgr_defs.h>
-#include <if/dma_mgr_rpcclient_defs.h>
+#include <if/dma_mgr_defs.h>
 
 /// DMA manager RPC client
-static struct dma_mgr_rpc_client dma_mgr_client;
+static struct dma_mgr_binding *dma_mgr_client;
 
 /// connected flag
 uint8_t dma_mgr_connected = 0x0;
@@ -53,12 +53,8 @@ static void bind_cb(void *st,
     }
 
     DMAMGR_DEBUG("connect: connection to {%s} established.\n", DMA_MGR_SVC_NAME);
-
-    bindst->err = dma_mgr_rpc_client_init(&dma_mgr_client, b);
-
-    if (err_is_fail(bindst->err)) {
-        DMAMGR_DEBUG("connect: RPC client init failed.\n");
-    }
+    dma_mgr_client = b;
+    dma_mgr_rpc_client_init(dma_mgr_client);
 
     bindst->bound = 0x1;
 }
@@ -162,7 +158,7 @@ errval_t dma_manager_register_driver(lpaddr_t mem_low,
     //XXX need to figure this out otherwise
     uint8_t numa_node = (disp_get_core_id() >= 20);
 
-    err = dma_mgr_client.vtbl.register_driver(&dma_mgr_client, mem_low, mem_high,
+    err = dma_mgr_client->rpc_tx_vtbl.register_driver(dma_mgr_client, mem_low, mem_high,
                     numa_node, type, iref, &msgerr);
     if (err_is_fail(err)) {
         DMAMGR_DEBUG("register driver: RPC failed %s\n", err_getstring(err));
@@ -223,7 +219,7 @@ errval_t dma_manager_lookup_driver(lpaddr_t addr,
 
     uint8_t numa_node = (disp_get_core_id() >= 20);
 
-    err = dma_mgr_client.vtbl.lookup_driver(&dma_mgr_client, addr, size,
+    err = dma_mgr_client->rpc_tx_vtbl.lookup_driver(dma_mgr_client, addr, size,
                     numa_node, &msgerr, &info->mem_low,
                     &info->mem_high, &info->numa_node,
                     (uint8_t*) &info->type, &info->iref);
@@ -267,7 +263,7 @@ errval_t dma_manager_lookup_by_iref(iref_t iref,
 
     DMAMGR_DEBUG("lookup driver by iref:%"PRIxIREF"\n", iref);
 
-    err = dma_mgr_client.vtbl.lookup_driver_by_iref(&dma_mgr_client, iref,
+    err = dma_mgr_client->rpc_tx_vtbl.lookup_driver_by_iref(dma_mgr_client, iref,
                                                     &msgerr, &info->mem_low,
                                                     &info->mem_high,
                                                     &info->numa_node,
@@ -304,4 +300,3 @@ errval_t dma_manager_wait_for_driver(dma_dev_type_t device,
     iref_t dummy_iref;
     return nameservice_blocking_lookup(buf, &dummy_iref);
 }
-
index 1354e51..734ada8 100644 (file)
@@ -84,7 +84,7 @@ static errval_t dma_register_response_tx(struct txq_msg_st *msg_st)
 {
     struct dma_binding *b = msg_st->queue->binding;
 
-    return dma_register_response__tx(b, TXQCONT(msg_st), msg_st->err);
+    return dma_register__response__tx(b, TXQCONT(msg_st), msg_st->err);
 }
 
 static void dma_register_call_rx(struct dma_binding *_binding,
@@ -188,7 +188,7 @@ static void dma_memcpy_call_rx(struct dma_binding *_binding,
 }
 
 struct dma_rx_vtbl dma_rx_vtbl = {
-    .register_call = dma_register_call_rx,
+    .register__call = dma_register_call_rx,
     .deregister_call = dma_deregister_call_rx,
     .memcpy_call = dma_memcpy_call_rx,
 };
index 5670c05..ef36817 100644 (file)
 #include <int_route/int_route_debug.h>
 
 #include <if/int_route_service_defs.h>
-#include <if/int_route_service_rpcclient_defs.h>
+#include <if/int_route_service_defs.h>
 
 static struct int_route_state {
     bool request_done;
-    struct int_route_rpc_client * client;
+    struct int_route_binding * client;
     struct int_route_service_binding * binding;
-    struct int_route_service_rpc_client rpc_client;
 
 } int_route_state_st;
 
@@ -38,12 +37,10 @@ static struct int_route_state * get_int_route_state(void){
 
 static void bind_cb(void *st, errval_t binderr, struct int_route_service_binding *b) {
     assert(err_is_ok(binderr));
-    errval_t err;
     int_route_state_st.binding = b;
     int_route_state_st.request_done = true;
 
-    err = int_route_service_rpc_client_init(&(int_route_state_st.rpc_client), b);
-    assert(err_is_ok(err));
+    int_route_service_rpc_client_init(b);
 }
 
 //errval_t int_route_add_controller(int bus, int dev, int fun,
@@ -65,9 +62,9 @@ static void bind_cb(void *st, errval_t binderr, struct int_route_service_binding
 
 errval_t int_route_client_route(struct capref intsrc, struct capref intdest){
     assert(int_route_state_st.request_done);
-    struct int_route_service_rpc_client * cl = &int_route_state_st.rpc_client;
+    struct int_route_service_binding * cl = int_route_state_st.binding;
     errval_t msgerr, err;
-    msgerr = cl->vtbl.route(cl, intsrc, intdest, &err);
+    msgerr = cl->rpc_tx_vtbl.route(cl, intsrc, intdest, &err);
     if(err_is_fail(msgerr)){
         return msgerr;
     }
index 2bfe1fd..c564aa2 100644 (file)
@@ -15,7 +15,7 @@
 #include <barrelfish/net_constants.h>
 
 #include <if/net_ARP_defs.h>
-#include <if/net_ARP_rpcclient_defs.h>
+#include <if/net_ARP_defs.h>
 
 // standard include files
 #include <stdio.h>
@@ -31,7 +31,7 @@
 // *****************************************************************
 //     local states
 // *****************************************************************
-static struct net_ARP_rpc_client net_ARP_rpc;
+static struct net_ARP_binding *net_ARP_binding;
 static bool net_ARP_service_connected = false;
 static struct netif netif;
 
@@ -50,13 +50,8 @@ static void net_ARP_bind_cb(void *st, errval_t err, struct net_ARP_binding *b)
         abort();
     }
     LWIPBF_DEBUG("net_ARP_bind_cb: called\n");
-
-    err = net_ARP_rpc_client_init(&net_ARP_rpc, b);
-    if (!err_is_ok(err)) {
-        printf("net_ARP_bind_cb failed in init\n");
-        abort();
-    }
-
+    net_ARP_binding = b;
+    net_ARP_rpc_client_init(b);
     net_ARP_service_connected = true;
     LWIPBF_DEBUG("net_ARP_bind_cb: net_ARP bind successful!\n");
 }
@@ -137,7 +132,7 @@ void idc_get_ip_from_ARP_lookup(void)
     struct ip_addr ip, gw, nm;
     uint32_t iface = 0;
 
-    err = net_ARP_rpc.vtbl.ip_info(&net_ARP_rpc, iface, &remote_err,
+    err = net_ARP_binding->rpc_tx_vtbl.ip_info(net_ARP_binding, iface, &remote_err,
             &ip.addr, &gw.addr, &nm.addr);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "error in making ip_info call");
@@ -173,7 +168,7 @@ uint64_t idc_ARP_lookup(uint32_t ip)
     bool force = false;
     uint64_t mac = 0;
 
-    err = net_ARP_rpc.vtbl.ARP_lookup(&net_ARP_rpc, ip, iface, force,
+    err = net_ARP_binding->rpc_tx_vtbl.ARP_lookup(net_ARP_binding, ip, iface, force,
             &remote_err, &mac);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "error in making ARP_lookup call");
@@ -187,5 +182,3 @@ uint64_t idc_ARP_lookup(uint32_t ip)
     LWIPBF_DEBUG("idc_ARP_lookup: got answer\n");
     return mac;
 } // end function: idc_ARP_lookup
-
-
index 5f066b9..72891a1 100644 (file)
@@ -30,7 +30,7 @@
 #include "idc_barrelfish.h"
 #include <if/net_queue_manager_defs.h>
 //#include <if/net_ports_defs.h>
-//#include <if/net_ports_rpcclient_defs.h>
+//#include <if/net_ports_defs.h>
 #include <barrelfish/bulk_transfer_arch.h>
 #include <net_interfaces/net_interfaces.h>
 
index feff3fe..171e6e0 100644 (file)
@@ -24,7 +24,7 @@
 #include "lwip/init.h"
 #include <netbench/netbench.h>
 #include <if/net_ports_defs.h>
-#include <if/net_ports_rpcclient_defs.h>
+#include <if/net_ports_defs.h>
 #include <stdio.h>
 #include <assert.h>
 #include "lwip/barrelfish.h"
@@ -52,7 +52,7 @@ static void (*close_port) (uint16_t port, net_ports_port_type_t type) = NULL;
  * @{
  *
  ****************************************************************/
-static struct net_ports_rpc_client net_ports_rpc;
+static struct net_ports_binding *net_ports_binding;
 static bool net_ports_service_connected = false;
 
 static net_ports_appid_t appid_delete = 0;
@@ -152,12 +152,8 @@ static void net_ports_bind_cb(void *st, errval_t err, struct net_ports_binding *
     }
     LWIPBF_DEBUG("net_ports_bind_cb: called\n");
 
-    err = net_ports_rpc_client_init(&net_ports_rpc, b);
-    if (!err_is_ok(err)) {
-        printf("net_ports_bind_cb failed in init\n");
-        abort();
-    }
-
+    net_ports_binding = b;
+    net_ports_rpc_client_init(net_ports_binding);
     net_ports_service_connected = true;
     LWIPBF_DEBUG("net_ports_bind_cb: net_ports bind successful!\n");
 }
@@ -235,7 +231,7 @@ void idc_get_ip(void)
     errval_t err;
     struct ip_addr ip, gw, nm;
 
-    err = net_ports_rpc.vtbl.get_ip_info(&net_ports_rpc, &ip.addr, &gw.addr,
+    err = net_ports_binding->rpc_tx_vtbl.get_ip_info(net_ports_binding, &ip.addr, &gw.addr,
             &nm.addr);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "error sending get_ip_info");
@@ -268,7 +264,7 @@ static err_t idc_close_port(uint16_t port, int port_type)
 
     errval_t err, msgerr;
 
-    err = net_ports_rpc.vtbl.close_port(&net_ports_rpc, port_type, port,
+    err = net_ports_binding->rpc_tx_vtbl.close_port(net_ports_binding, port_type, port,
                                   appid_delete, lwip_queue_id,
                                   &msgerr);
     if (err_is_fail(err)) {
@@ -307,7 +303,7 @@ static err_t idc_bind_port(uint16_t port, net_ports_port_type_t port_type)
     errval_t err, msgerr;
 
     /* getting the proper buffer id's here */
-    err = net_ports_rpc.vtbl.bind_port(&net_ports_rpc, port_type, port,
+    err = net_ports_binding->rpc_tx_vtbl.bind_port(net_ports_binding, port_type, port,
                                   /* buffer for RX */
                                    get_rx_bufferid(),
                                   /* buffer for TX */
@@ -352,7 +348,7 @@ static err_t idc_new_port(uint16_t * port_no, net_ports_port_type_t port_type)
     //assert(!"NYI");
 
     /* getting the proper buffer id's here */
-    err = net_ports_rpc.vtbl.get_port(&net_ports_rpc, port_type,
+    err = net_ports_binding->rpc_tx_vtbl.get_port(net_ports_binding, port_type,
                                  /* buffer for RX */
                                  get_rx_bufferid(),
                                  /* buffer for TX */
@@ -410,7 +406,7 @@ static err_t idc_redirect(struct ip_addr *local_ip, u16_t local_port,
 #if 0
     /* getting the proper buffer id's here */
     err =
-      net_ports_rpc.vtbl.redirect(&net_ports_rpc, port_type, local_ip->addr, local_port,
+      net_ports_binding->rpc_tx_vtbl.redirect(net_ports_binding, port_type, local_ip->addr, local_port,
                              remote_ip->addr, remote_port,
                              /* buffer for RX */
                              get_rx_bufferid(),
@@ -448,7 +444,7 @@ static err_t idc_pause(struct ip_addr *local_ip, u16_t local_port,
 #if 0
     /* getting the proper buffer id's here */
     err =
-      net_ports_rpc.vtbl.redirect_pause(&net_ports_rpc, port_type, local_ip->addr,
+      net_ports_binding->rpc_tx_vtbl.redirect_pause(net_ports_binding, port_type, local_ip->addr,
                                    local_port, remote_ip->addr, remote_port,
                                    /* buffer for RX */
                                    ((struct client_closure_NC *)
@@ -508,4 +504,3 @@ void perform_ownership_housekeeping(uint16_t(*alloc_tcp_ptr) (void),
     bind_port = bind_port_ptr;
     close_port = close_port_ptr;
 }
-
index cd00f92..af44afb 100755 (executable)
@@ -15,7 +15,7 @@
 #include <barrelfish/bulk_transfer.h>
 //#include <net_device_manager/net_ports_service.h>
 #include <if/net_soft_filters_defs.h>
-#include <if/net_soft_filters_rpcclient_defs.h>
+#include <if/net_soft_filters_defs.h>
 //#include <if/net_ports_defs.h>
 
 // For filter generation
@@ -151,9 +151,7 @@ static void soft_filters_bind_cb(void *st, errval_t err,
     }
     NDM_DEBUG("soft_filters_bind_cb: started\n");
 
-    struct net_soft_filters_rpc_client *rpc_client = malloc(sizeof(struct net_soft_filters_rpc_client));
-    net_soft_filters_rpc_client_init(rpc_client, enb);
-    enb->st = rpc_client;
+    net_soft_filters_rpc_client_init(enb);
 
     soft_filters_connection = enb;
     NDM_DEBUG(" soft_filters_bind_cb: connection made,"
@@ -228,10 +226,9 @@ static void connect_soft_filters_service(char *dev_name, qid_t qid)
 static void register_filter_memory(struct capref cap)
 {
     struct net_soft_filters_binding *b = soft_filters_connection;
-    struct net_soft_filters_rpc_client *rpc = b->st;
 
     errval_t err, rerr;
-    err = rpc->vtbl.register_filter_memory(rpc, cap, &rerr);
+    err = b->rpc_tx_vtbl.register_filter_memory(b, cap, &rerr);
     assert(err_is_ok(err));
     assert(err_is_ok(rerr));
     soft_filters_ready = true;
@@ -288,11 +285,10 @@ static struct eth_addr my_convert_uint64_to_eth_addr(uint64_t given_mac)
 static void sf_mac_lookup(void)
 {
     struct net_soft_filters_binding *b = soft_filters_connection;
-    struct net_soft_filters_rpc_client *rpc = b->st;
 
     uint64_t mac_addr;
     errval_t err, rerr;
-    err = rpc->vtbl.mac_address(rpc, &rerr, &mac_addr);
+    err = b->rpc_tx_vtbl.mac_address(b, &rerr, &mac_addr);
     assert(err_is_ok(err));
     assert(err_is_ok(rerr));
     mac = my_convert_uint64_to_eth_addr(mac_addr);
@@ -312,11 +308,10 @@ static void send_soft_filter(uint64_t id, uint64_t len_rx,
                " and type %x, paused = %d\n", id, ftype, paused);
 
     struct net_soft_filters_binding *b = soft_filters_connection;
-    struct net_soft_filters_rpc_client *rpc = b->st;
 
     errval_t err, rerr;
     uint64_t filter_id;
-    err = rpc->vtbl.register_filter(rpc, id, len_rx, len_tx, buffer_id_rx, buffer_id_tx, ftype, paused, &rerr, &filter_id);
+    err = b->rpc_tx_vtbl.register_filter(b, id, len_rx, len_tx, buffer_id_rx, buffer_id_tx, ftype, paused, &rerr, &filter_id);
     assert(err_is_ok(err));
     assert(err_is_ok(rerr));
     NDM_DEBUG("filter at id [%" PRIu64 "] type[%" PRIu64
@@ -340,10 +335,9 @@ static void send_soft_filter(uint64_t id, uint64_t len_rx,
 static void unregister_soft_filter(uint64_t filter_id, qid_t qid)
 {
     struct net_soft_filters_binding *b = soft_filters_connection;
-    struct net_soft_filters_rpc_client *rpc = b->st;
 
     errval_t err, rerr;
-    err = rpc->vtbl.deregister_filter(rpc, filter_id, &rerr);
+    err = b->rpc_tx_vtbl.deregister_filter(b, filter_id, &rerr);
     assert(err_is_ok(err));
     assert(err_is_ok(rerr));
 } // end function: unregister_soft_filter
@@ -357,10 +351,9 @@ static void register_arp_soft_filter(uint64_t id, uint64_t len_rx,
 {
     NDM_DEBUG("register_arp_soft_filter: called\n");
     struct net_soft_filters_binding *b = soft_filters_connection;
-    struct net_soft_filters_rpc_client *rpc = b->st;
 
     errval_t err, rerr;
-    err = rpc->vtbl.register_arp_filter(rpc, id, len_rx, len_tx, &rerr);
+    err = b->rpc_tx_vtbl.register_arp_filter(b, id, len_rx, len_tx, &rerr);
     assert(err_is_ok(err));
     assert(err_is_ok(rerr));
 
@@ -437,4 +430,3 @@ static uint64_t populate_rx_tx_filter_mem(uint16_t port, net_ports_port_type_t t
 
     return id;
 }
-
index 61a8064..7ef3559 100644 (file)
@@ -29,7 +29,7 @@
 #include <net_queue_manager/net_queue_manager.h>
 #include <bfdmuxvm/vm.h>
 #include <if/net_soft_filters_defs.h>
-#include <if/net_soft_filters_rpcclient_defs.h>
+#include <if/net_soft_filters_defs.h>
 #include <if/net_queue_manager_defs.h>
 #include "queue_manager_local.h"
 #include "queue_manager_debug.h"
index a60aa75..be52710 100644 (file)
@@ -21,8 +21,7 @@
 #include <pci/pci.h>
 #include <pci/pci_client_debug.h>
 #include <if/pci_defs.h>
-#include <if/pci_rpcclient_defs.h>
-#include <if/acpi_rpcclient_defs.h>
+#include <if/acpi_defs.h>
 #include <acpi_client/acpi_client.h>
 #include <int_route/int_model.h>
 #include <int_route/int_route_client.h>
@@ -30,7 +29,7 @@
 #define INVALID_VECTOR ((uint64_t)-1)
 #define INVALID_VECTOR_32 ((uint32_t)-1)
 
-static struct pci_rpc_client *pci_client = NULL;
+static struct pci_binding *pci_client = NULL;
 
 
 /*
@@ -81,7 +80,7 @@ errval_t pci_reregister_irq_for_device(uint32_t class, uint32_t subclass, uint32
         assert(vector != INVALID_VECTOR);
     }
 
-    err = pci_client->vtbl.
+    err = pci_client->rpc_tx_vtbl.
         reregister_interrupt(pci_client, class, subclass, prog_if, vendor,
                 device, bus, dev, fun, disp_get_current_core_id(),
                 vector, &msgerr);
@@ -178,7 +177,7 @@ static errval_t setup_int_routing(int irq_idx, interrupt_handler_fn handler,
     }
 
     // Activate PCI interrupt
-    err = pci_client->vtbl.irq_enable(pci_client, &msgerr);
+    err = pci_client->rpc_tx_vtbl.irq_enable(pci_client, &msgerr);
     assert(err_is_ok(err));
     if(err_is_fail(msgerr)){
         DEBUG_ERR(msgerr, "irq_enable");
@@ -200,7 +199,7 @@ errval_t pci_register_driver_movable_irq(pci_driver_init_fn init_func, uint32_t
     uint8_t nbars;
     errval_t err, msgerr;
 
-    err = pci_client->vtbl.
+    err = pci_client->rpc_tx_vtbl.
         init_pci_device(pci_client, class, subclass, prog_if, vendor,
                         device, bus, dev, fun, &msgerr,
                         &nbars, caps_per_bar, caps_per_bar + 1, caps_per_bar + 2,
@@ -245,7 +244,7 @@ errval_t pci_register_driver_movable_irq(pci_driver_init_fn init_func, uint32_t
 
             err = slot_alloc(&cap);
             assert(err_is_ok(err));
-            err = pci_client->vtbl.get_bar_cap(pci_client, nb, nc, &msgerr, &cap,
+            err = pci_client->rpc_tx_vtbl.get_bar_cap(pci_client, nb, nc, &msgerr, &cap,
                                            &type, &bar->bar_nr);
             if (err_is_fail(err) || err_is_fail(msgerr)) {
                 if (err_is_ok(err)) {
@@ -319,7 +318,7 @@ errval_t pci_register_legacy_driver_irq_cap(legacy_driver_init_fn init_func,
     // Connect to PCI without interrupts
     err = slot_alloc(&iocap);
     assert(err_is_ok(err));
-    err = pci_client->vtbl.init_legacy_device(pci_client, iomin, iomax, 0,
+    err = pci_client->rpc_tx_vtbl.init_legacy_device(pci_client, iomin, iomax, 0,
                                               disp_get_core_id(), INVALID_VECTOR_32,
                                               &msgerr, &iocap);
     if (err_is_fail(err)) {
@@ -375,7 +374,7 @@ errval_t pci_register_legacy_driver_irq(legacy_driver_init_fn init_func,
 
     err = slot_alloc(&iocap);
     assert(err_is_ok(err));
-    err = pci_client->vtbl.init_legacy_device(pci_client, iomin, iomax, irq,
+    err = pci_client->rpc_tx_vtbl.init_legacy_device(pci_client, iomin, iomax, irq,
                                               disp_get_core_id(), vector,
                                               &msgerr, &iocap);
     if (err_is_fail(err)) {
@@ -417,14 +416,14 @@ errval_t pci_setup_inthandler(interrupt_handler_fn handler, void *handler_arg,
 errval_t pci_read_conf_header(uint32_t dword, uint32_t *val)
 {
     errval_t err, msgerr;
-    err = pci_client->vtbl.read_conf_header(pci_client, dword, &msgerr, val);
+    err = pci_client->rpc_tx_vtbl.read_conf_header(pci_client, dword, &msgerr, val);
     return err_is_fail(err) ? err : msgerr;
 }
 
 errval_t pci_write_conf_header(uint32_t dword, uint32_t val)
 {
     errval_t err, msgerr;
-    err = pci_client->vtbl.write_conf_header(pci_client, dword, val, &msgerr);
+    err = pci_client->rpc_tx_vtbl.write_conf_header(pci_client, dword, val, &msgerr);
     return err_is_fail(err) ? err : msgerr;
 }
 
@@ -432,9 +431,9 @@ errval_t pci_msix_enable_addr(struct pci_address *addr, uint16_t *count)
 {
     errval_t err, msgerr;
     if (addr == NULL) {
-        err = pci_client->vtbl.msix_enable(pci_client, &msgerr, count);
+        err = pci_client->rpc_tx_vtbl.msix_enable(pci_client, &msgerr, count);
     } else {
-        err = pci_client->vtbl.msix_enable_addr(pci_client, addr->bus, addr->device,
+        err = pci_client->rpc_tx_vtbl.msix_enable_addr(pci_client, addr->bus, addr->device,
                                                 addr->function, &msgerr, count);
     }
     return err_is_fail(err) ? err : msgerr;
@@ -450,10 +449,10 @@ errval_t pci_msix_vector_init_addr(struct pci_address *addr, uint16_t idx,
 {
     errval_t err, msgerr;
     if (addr == NULL) {
-        err = pci_client->vtbl.msix_vector_init(pci_client, idx, destination,
+        err = pci_client->rpc_tx_vtbl.msix_vector_init(pci_client, idx, destination,
                                                     vector, &msgerr);
     } else {
-        err = pci_client->vtbl.msix_vector_init_addr(pci_client, addr->bus,
+        err = pci_client->rpc_tx_vtbl.msix_vector_init_addr(pci_client, addr->bus,
                                                      addr->device, addr->function,
                                                      idx, destination,
                                                      vector, &msgerr);
@@ -472,14 +471,8 @@ static void bind_cont(void *st, errval_t err, struct pci_binding *b)
 {
     errval_t *reterr = st;
     if (err_is_ok(err)) {
-        struct pci_rpc_client *r = malloc(sizeof(*r));
-        assert(r != NULL);
-        err = pci_rpc_client_init(r, b);
-        if (err_is_ok(err)) {
-            pci_client = r;
-        } else {
-            free(r);
-        }
+        pci_rpc_client_init(b);
+        pci_client = b;
     }
     *reterr = err;
 }
index 6d42f60..71f64cd 100644 (file)
@@ -25,7 +25,7 @@
 #include <barrelfish/waitset.h>
 #include <collections/list.h>
 #include <if/octopus_defs.h>
-#include <if/octopus_rpcclient_defs.h>
+#include <if/octopus_defs.h>
 #include <octopus/octopus.h>
 #include <posixcompat.h>
 #include <term/server/server.h>
@@ -465,13 +465,13 @@ static errval_t allocate_unique_number(uint32_t *np)
 {
     errval_t err;
 
-    struct octopus_rpc_client *oc = get_octopus_rpc_client();
+    struct octopus_binding *oc = get_octopus_binding();
 
     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, reply.record,
+    oc->rpc_tx_vtbl.set(oc, query, SET_SEQUENTIAL, NOP_TRIGGER, true, reply.record,
                  &reply.tid, &err);
     if (err_is_fail(err)) {
         goto finish;
index 852f0dd..3c22a05 100644 (file)
@@ -16,7 +16,7 @@
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/nameservice_client.h>
 #include <skb/skb.h>
-#include <if/skb_rpcclient_defs.h>
+#include <if/skb_defs.h>
 #include <barrelfish/core_state_arch.h>
 
 /* ------------------------- Connecting to skb ------------------------------ */
@@ -30,15 +30,8 @@ static void bind_cb(void *st, errval_t err, struct skb_binding *b)
         abort();
     }
 
-    skb_state->skb = malloc(sizeof(struct skb_rpc_client));
-    assert(skb_state->skb != NULL);
-    err = skb_rpc_client_init(skb_state->skb, b);
-    if (err_is_fail(err)) {
-        free(skb_state->skb);
-        DEBUG_ERR(err, "error in skb_rpc_client_init");
-        abort();
-    }
-
+    skb_state->skb = b;
+    skb_rpc_client_init(skb_state->skb);
     assert(!skb_state->request_done);
     skb_state->request_done = true;
 }
@@ -98,7 +91,7 @@ errval_t skb_evaluate(char *query, char **ret_result, char **ret_str_error, int3
             return LIB_ERR_MALLOC_FAIL;
         }
     }
-    err = skb_state->skb->vtbl.run(skb_state->skb, query, result,
+    err = skb_state->skb->rpc_tx_vtbl.run(skb_state->skb, query, result,
                                    str_error, int_error);
     if (err_is_fail(err)) {
         if (result) {
index 5a20674..18a7dc5 100644 (file)
@@ -16,7 +16,7 @@
 #include <string.h>
 #include <barrelfish/barrelfish.h>
 #include <skb/skb.h>
-#include <if/skb_rpcclient_defs.h>
+#include <if/skb_defs.h>
 #include <barrelfish/core_state_arch.h>
 #include "skb_debug.h"
 
@@ -58,7 +58,7 @@ errval_t skb_execute(char *goal)
     struct skb_state *skb_state = get_skb_state();
 
     last_goal = goal;
-    err = skb_state->skb->vtbl.run(skb_state->skb, goal, output,
+    err = skb_state->skb->rpc_tx_vtbl.run(skb_state->skb, goal, output,
             error_output, &error_code);
     if (err_is_fail(err)) {
         return err_push(err, SKB_ERR_RUN);
index 31cd742..be4eb60 100644 (file)
@@ -20,7 +20,7 @@
 #include <spawndomain/spawndomain.h>
 
 #include <if/octopus_defs.h>
-#include <if/octopus_rpcclient_defs.h>
+#include <if/octopus_defs.h>
 #include <if/monitor_defs.h>
 #include <octopus/getset.h> // for oct_read TODO
 #include <octopus/trigger.h> // for NOP_TRIGGER
@@ -247,7 +247,7 @@ errval_t spawn_symval_lookup(const char *binary,
     }
     snprintf(omp_entry, len+1, "%s.omp.%"PRIu32, binary, idx);
 
-    struct octopus_rpc_client *r = get_octopus_rpc_client();
+    struct octopus_binding *r = get_octopus_binding();
     if (r == NULL) {
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
@@ -260,7 +260,7 @@ errval_t spawn_symval_lookup(const char *binary,
     }
 
     struct octopus_get_response__rx_args reply;
-    err = r->vtbl.get(r, omp_entry, NOP_TRIGGER,
+    err = r->rpc_tx_vtbl.get(r, omp_entry, NOP_TRIGGER,
                       reply.output, &reply.tid, &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
@@ -311,7 +311,7 @@ errval_t spawn_symval_register(const char *binary,
 
     errval_t err = SYS_ERR_OK;
 
-    struct octopus_rpc_client *r = get_octopus_rpc_client();
+    struct octopus_binding *r = get_octopus_binding();
     if (r == NULL) {
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
@@ -336,7 +336,7 @@ errval_t spawn_symval_register(const char *binary,
 
     octopus_trigger_id_t tid;
     errval_t error_code;
-    err = r->vtbl.set(r, record, 0, NOP_TRIGGER,
+    err = r->rpc_tx_vtbl.set(r, record, 0, NOP_TRIGGER,
                       0, NULL, &tid, &error_code);
     if (err_is_fail(err)) {
         goto out;
index 7c8dccd..04bd4e3 100644 (file)
@@ -19,7 +19,7 @@
 #include <collections/list.h>
 #include <if/monitor_defs.h>
 #include <if/octopus_defs.h>
-#include <if/octopus_rpcclient_defs.h>
+#include <if/octopus_defs.h>
 #include <if/terminal_defs.h>
 #include <if/terminal_config_defs.h>
 #include <octopus/getset.h>
@@ -467,12 +467,12 @@ static errval_t get_irefs(struct capref session_id, iref_t *in_iref,
 {
     errval_t err;
 
-    struct octopus_rpc_client *r = get_octopus_rpc_client();
+    struct octopus_binding *r = get_octopus_binding();
     assert(r != NULL);
 
     struct octopus_get_with_idcap_response__rx_args reply;
 
-    err = r->vtbl.get_with_idcap(r, session_id, NOP_TRIGGER, reply.output, &reply.tid,
+    err = r->rpc_tx_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);
index 87ed58a..b9da0d6 100644 (file)
@@ -17,7 +17,7 @@
 #include <barrelfish/barrelfish.h>
 
 #include <if/usb_manager_defs.h>
-#include <if/usb_manager_rpcclient_defs.h>
+#include <if/usb_manager_defs.h>
 
 #include <usb/usb.h>
 #include <usb/usb_device.h>
index 476dfa0..d76c56d 100644 (file)
@@ -21,7 +21,7 @@
 
 
 /// the usb manager RPC client structure
-struct usb_manager_rpc_client usb_manager;
+struct usb_manager_binding *usb_manager;
 
 /*
  * -------------------------------------------------------------------------
@@ -111,12 +111,10 @@ static void usb_bind_cb(void *st, errval_t err, struct usb_manager_binding *b)
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "USB manager binding failed");
     }
-
-    err = usb_manager_rpc_client_init(&usb_manager, b);
-    if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "rpc client initialization failed\n");
-    }
-    debug_printf("vtbl.connect=%p\n", usb_manager.vtbl.connect);
+    
+    usb_manager = b;
+    usb_manager_rpc_client_init(usb_manager);
+    debug_printf("vtbl.connect=%p\n", usb_manager->rpc_tx_vtbl.connect);
 
     uint32_t ret_status;
 
@@ -124,7 +122,7 @@ static void usb_bind_cb(void *st, errval_t err, struct usb_manager_binding *b)
     uint8_t tmp[2048];
 
     /* connect with the USB Manager */
-    err = usb_manager.vtbl.connect(&usb_manager, client_st->usb_driver_iref, client_st->init_config,
+    err = usb_manager->rpc_tx_vtbl.connect(usb_manager, client_st->usb_driver_iref, client_st->init_config,
             &ret_status, tmp, &length);
 
     if (((usb_error_t) ret_status) != USB_ERR_OK) {
index f8e631e..0d97dda 100644 (file)
 #define USB_MANAGER_CLIENT_H_
 
 #include <if/usb_manager_defs.h>
-#include <if/usb_manager_rpcclient_defs.h>
 #include <if/usb_driver_defs.h>
 
-extern struct usb_manager_rpc_client usb_manager;
+extern struct usb_manager_binding *usb_manager;
 
 void usb_driver_rx_detach_notify(struct usb_driver_binding *b);
 void usb_driver_rx_done_notify(struct usb_driver_binding *b,
index 0df5afc..5af1872 100644 (file)
@@ -598,7 +598,7 @@ usb_error_t usb_do_request(struct usb_device_request *req)
 \r
     USB_DEBUG_IDC("libusb: usb_do_request()\n");\r
 \r
-    err = usb_manager.vtbl.request(&usb_manager, (uint8_t*) req, sizeof(*req),\r
+    err = usb_manager->rpc_tx_vtbl.request(usb_manager, (uint8_t*) req, sizeof(*req),\r
             &ret_status);\r
 \r
     if (err_is_fail(err)) {\r
@@ -624,7 +624,7 @@ usb_error_t usb_do_request_write(struct usb_device_request *req,
 \r
     USB_DEBUG_IDC("libusb: usb_do_request_write()\n");\r
 \r
-    err = usb_manager.vtbl.request_write(&usb_manager, (uint8_t*) req,\r
+    err = usb_manager->rpc_tx_vtbl.request_write(usb_manager, (uint8_t*) req,\r
             sizeof(*req), (uint8_t *) data, length, &ret_status);\r
 \r
     if (err_is_fail(err)) {\r
@@ -653,7 +653,7 @@ usb_error_t usb_do_request_read(struct usb_device_request *req,
 \r
     USB_DEBUG_IDC("libusb: usb_do_request_read()\n");\r
 \r
-    err = usb_manager.vtbl.request_read(&usb_manager, (uint8_t*) req,\r
+    err = usb_manager->rpc_tx_vtbl.request_read(usb_manager, (uint8_t*) req,\r
             sizeof(*req), data, &length, &ret_status);\r
 \r
     *ret_length = length;\r
index 71a8e4d..cfce38d 100644 (file)
@@ -159,7 +159,7 @@ usb_error_t usb_transfer_setup_control(usb_transfer_setup_t *setup,
 \r
     usb_manager_setup_param_t *params = (usb_manager_setup_param_t *) setup;\r
 \r
-    usb_manager.vtbl.transfer_setup(&usb_manager, (uint8_t) USB_TYPE_CTRL,\r
+    usb_manager->rpc_tx_vtbl.transfer_setup(usb_manager, (uint8_t) USB_TYPE_CTRL,\r
             *params, &ret_error, &ret_tid);\r
 \r
     if (((usb_error_t) ret_error) != USB_ERR_OK) {\r
@@ -203,7 +203,7 @@ usb_error_t usb_transfer_setup_isoc(usb_transfer_setup_t *setup,
 \r
     usb_manager_setup_param_t *params = (usb_manager_setup_param_t *) setup;\r
 \r
-    usb_manager.vtbl.transfer_setup(&usb_manager, (uint8_t) USB_TYPE_ISOC,\r
+    usb_manager->rpc_tx_vtbl.transfer_setup(usb_manager, (uint8_t) USB_TYPE_ISOC,\r
             *params, &ret_error, &ret_tid);\r
 \r
     if (((usb_error_t) ret_error) != USB_ERR_OK) {\r
@@ -247,7 +247,7 @@ usb_error_t usb_transfer_setup_bulk(usb_transfer_setup_t *setup,
 \r
     usb_manager_setup_param_t *params = (usb_manager_setup_param_t *) setup;\r
 \r
-    usb_manager.vtbl.transfer_setup(&usb_manager, (uint8_t) USB_TYPE_BULK,\r
+    usb_manager->rpc_tx_vtbl.transfer_setup(usb_manager, (uint8_t) USB_TYPE_BULK,\r
             *params, &ret_error, &ret_tid);\r
 \r
     if (((usb_error_t) ret_error) != USB_ERR_OK) {\r
@@ -291,7 +291,7 @@ usb_error_t usb_transfer_setup_intr(usb_transfer_setup_t *setup,
 \r
     usb_manager_setup_param_t *params = (usb_manager_setup_param_t *) setup;\r
 \r
-    usb_manager.vtbl.transfer_setup(&usb_manager, (uint8_t) USB_TYPE_INTR,\r
+    usb_manager->rpc_tx_vtbl.transfer_setup(usb_manager, (uint8_t) USB_TYPE_INTR,\r
             *params, &ret_error, &ret_tid);\r
 \r
     if (((usb_error_t) ret_error) != USB_ERR_OK) {\r
@@ -333,7 +333,7 @@ usb_error_t usb_transfer_unsetup(usb_xfer_id_t tid)
     }\r
     uint32_t ret_error = 0;\r
 \r
-    usb_manager.vtbl.transfer_unsetup(&usb_manager, tid, &ret_error);\r
+    usb_manager->rpc_tx_vtbl.transfer_unsetup(usb_manager, tid, &ret_error);\r
 \r
     if (((usb_error_t) ret_error) != USB_ERR_OK) {\r
         return ((usb_error_t) ret_error);\r
@@ -372,7 +372,7 @@ usb_error_t usb_transfer_start(usb_xfer_id_t tid)
 \r
     uint32_t ret_error = 0;\r
 \r
-    usb_manager.vtbl.transfer_start(&usb_manager, tid, &ret_error);\r
+    usb_manager->rpc_tx_vtbl.transfer_start(usb_manager, tid, &ret_error);\r
 \r
     if (((usb_error_t) ret_error) != USB_ERR_OK) {\r
         return ((usb_error_t) ret_error);\r
@@ -398,7 +398,7 @@ usb_error_t usb_transfer_stop(usb_xfer_id_t tid)
     }\r
     uint32_t ret_error = 0;\r
 \r
-    usb_manager.vtbl.transfer_stop(&usb_manager, tid, &ret_error);\r
+    usb_manager->rpc_tx_vtbl.transfer_stop(usb_manager, tid, &ret_error);\r
 \r
     if (((usb_error_t) ret_error) != USB_ERR_OK) {\r
         return ((usb_error_t) ret_error);\r
@@ -423,7 +423,7 @@ usb_error_t usb_transfer_clear_stall(usb_xfer_id_t tid)
     }\r
     uint32_t ret_error = 0;\r
 \r
-    usb_manager.vtbl.transfer_clear_stall(&usb_manager, tid, &ret_error);\r
+    usb_manager->rpc_tx_vtbl.transfer_clear_stall(usb_manager, tid, &ret_error);\r
 \r
     if (((usb_error_t) ret_error) != USB_ERR_OK) {\r
         return ((usb_error_t) ret_error);\r
@@ -456,7 +456,7 @@ usb_error_t usb_transfer_get_state(usb_xfer_id_t tid, usb_tstate_t *ret_state)
     uint32_t ret_error = 0;\r
     uint32_t idc_ret_state = 0;\r
 \r
-    usb_manager.vtbl.transfer_state(&usb_manager, tid, &ret_error,\r
+    usb_manager->rpc_tx_vtbl.transfer_state(usb_manager, tid, &ret_error,\r
             &idc_ret_state);\r
 \r
     if (((usb_error_t) ret_error) != USB_ERR_OK) {\r
@@ -493,7 +493,7 @@ usb_error_t usb_transfer_get_status(usb_xfer_id_t tid, uint32_t *ret_actlen,
 \r
     uint32_t ret_error = 0;\r
 \r
-    usb_manager.vtbl.transfer_status(&usb_manager, tid, &ret_error,\r
+    usb_manager->rpc_tx_vtbl.transfer_status(usb_manager, tid, &ret_error,\r
             ret_actlen, ret_length, ret_actframes, ret_numframes);\r
 \r
     if (((usb_error_t) ret_error) != USB_ERR_OK) {\r
index cc28563..cb9a002 100644 (file)
@@ -18,7 +18,7 @@
 #include <barrelfish/bulk_transfer.h>
 #include <barrelfish/nameservice_client.h>
 #include <vfs/vfs.h>
-#include <if/bcache_rpcclient_defs.h>
+#include <if/bcache_defs.h>
 
 #ifdef WITH_BUFFER_CACHE
 
@@ -34,7 +34,7 @@
 #define MAX_CACHES      10
 
 struct bcache_client {
-    struct bcache_rpc_client rpc;
+    struct bcache_binding rpc;
     struct bulk_transfer_slave bulk_slave;
     struct capref cache_memory;
     bool bound;
@@ -374,7 +374,7 @@ static bool cache_op_start(char *key, size_t key_len, void **retblock,
 #ifndef FAKE_SCALABLE_CACHE
     errval_t err;
 
-    err = bcc->rpc.vtbl.get_start(&bcc->rpc, key, key_len, &index, &haveit,
+    err = bcc->rpc->rpc_tx_vtbl.get_start(&bcc->rpc, key, key_len, &index, &haveit,
                                   transid, block_length);
     /* err = bcc->rpc.b->tx_vtbl.get_start_call(bcc->rpc.b, key, key_len); */
     if(err_is_fail(err)) {
@@ -410,7 +410,7 @@ static void cache_op_stop(void *block, uint64_t transid, uintptr_t block_length)
 
 #ifndef FAKE_SCALABLE_CACHE
     errval_t err;
-    err = bcc->rpc.vtbl.get_stop(&bcc->rpc, transid, index, block_length);
+    err = bcc->rpc->rpc_tx_vtbl.get_stop(&bcc->rpc, transid, index, block_length);
     if(err_is_fail(err)) {
         USER_PANIC_ERR(err, "get_stop");
     }
@@ -421,7 +421,7 @@ void cache_print_stats(void);
 void cache_print_stats(void)
 {
     struct bcache_client *bcc = cache[0];
-    errval_t err = bcc->rpc.vtbl.print_stats(&bcc->rpc);
+    errval_t err = bcc->rpc->rpc_tx_vtbl.print_stats(&bcc->rpc);
     assert(err_is_ok(err));
 
     printf("cache[%d] stats\n", disp_get_core_id());
@@ -808,7 +808,7 @@ static void bind_cb(void *st, errval_t err, struct bcache_binding *b)
         USER_PANIC_ERR(err, "bind failed");
     }
 
-    err = bcache_rpc_client_init(&cl->rpc, b);
+    err = bcache_binding_init(&cl->rpc, b);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "RPC init failed");
     }
@@ -862,7 +862,7 @@ static errval_t buffer_cache_connect(const char *bcache_name)
     if(err_is_fail(err)) {
         USER_PANIC_ERR(err, "slot_alloc for new_client");
     }
-    err = client->rpc.vtbl.new_client(&client->rpc, &client->cache_memory);
+    err = client->rpc->rpc_tx_vtbl.new_client(&client->rpc, &client->cache_memory);
     if(err_is_fail(err)) {
         USER_PANIC_ERR(err, "new_client");
     }
index d8683a5..5aae830 100644 (file)
@@ -13,7 +13,7 @@
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/nameservice_client.h>
 #include <if/ahci_mgmt_defs.h>
-#include <if/ahci_mgmt_rpcclient_defs.h>
+#include <if/ahci_mgmt_defs.h>
 #include <dev/ata_identify_dev.h>
 #include <dev/ahci_port_dev.h>
 #include <ahci/ahci.h>
@@ -22,7 +22,6 @@
 
 #include "vfs_blockdevfs.h"
 
-static struct ahci_mgmt_rpc_client ahci_mgmt_rpc;
 static struct ahci_mgmt_binding *ahci_mgmt_binding;
 static bool ahci_mgmt_bound = false;
 
@@ -297,20 +296,17 @@ static void ahci_mgmt_bind_cb(void *st, errval_t err, struct ahci_mgmt_binding *
     }
 
     ahci_mgmt_binding = b;
-    err = ahci_mgmt_rpc_client_init(&ahci_mgmt_rpc, b);
-    if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "ahci_mgmt RPC init failed");
-    }
+    ahci_mgmt_rpc_client_init(ahci_mgmt_binding);
 
     ahci_mgmt_bound = true;
 
     struct ahci_mgmt_list_response__rx_args reply;
-    err = ahci_mgmt_rpc.vtbl.list(&ahci_mgmt_rpc, reply.port_ids, &reply.len);
+    err = ahci_mgmt_binding->rpc_tx_vtbl.list(ahci_mgmt_binding, reply.port_ids, &reply.len);
     assert(err_is_ok(err));
 
     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,
+        err = ahci_mgmt_binding->rpc_tx_vtbl.identify(ahci_mgmt_binding,
                 reply.port_ids[i], identify_reply.identify_data,
                 &identify_reply.data_len);
         assert(err_is_ok(err));
index e62b3f7..5cdcdee 100644 (file)
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/nameservice_client.h>
 #include <if/ahci_mgmt_defs.h>
-#include <if/ahci_mgmt_rpcclient_defs.h>
+#include <if/ahci_mgmt_defs.h>
 #include <if/ahci_mgmt_defs.h>
 #include <if/ata_rw28_defs.h>
 #include <if/ata_rw28_ahci_defs.h>
-#include <if/ata_rw28_rpcclient_defs.h>
+#include <if/ata_rw28_defs.h>
 #include <dev/ata_identify_dev.h>
 #include <dev/ahci_port_dev.h>
 #include <ahci/ahci.h>
@@ -26,7 +26,6 @@
 
 #include "vfs_blockdevfs.h"
 
-static struct ahci_mgmt_rpc_client ahci_mgmt_rpc;
 static struct ahci_mgmt_binding *ahci_mgmt_binding;
 static bool ahci_mgmt_bound = false;
 
@@ -39,7 +38,6 @@ static bool ahci_mgmt_bound = false;
 struct ata_handle {
     struct ahci_binding *ahci_binding;
     struct ata_rw28_binding *ata_rw28_binding;
-    struct ata_rw28_rpc_client ata_rw28_rpc;
     uint8_t port_num;
     bool waiting;
     errval_t wait_status;
@@ -90,12 +88,7 @@ errval_t blockdevfs_ata_open(void *handle)
     ahci_ata_rw28_binding = calloc(1, sizeof(struct ahci_ata_rw28_binding));
     ahci_ata_rw28_init(ahci_ata_rw28_binding, get_default_waitset(), h->ahci_binding);
     h->ata_rw28_binding = (struct ata_rw28_binding*)ahci_ata_rw28_binding;
-    err = ata_rw28_rpc_client_init(&h->ata_rw28_rpc, h->ata_rw28_binding);
-    if (err_is_fail(err)) {
-        // TODO: bindings leak
-        VFS_BLK_DEBUG("blockdevfs_ata_open: failed to init ata_rw28 rpc client\n");
-        return err;
-    }
+    ata_rw28_rpc_client_init(h->ata_rw28_binding);
     VFS_BLK_DEBUG("blockdevfs_ata_open: exiting\n");
     return h->wait_status;
 }
@@ -112,7 +105,7 @@ errval_t blockdevfs_ata_flush(void *handle)
 {
     struct ata_handle *h = handle;
     errval_t err, status;
-    err = h->ata_rw28_rpc.vtbl.flush_cache(&h->ata_rw28_rpc, &status);
+    err = h->ata_rw28_binding->rpc_tx_vtbl.flush_cache(h->ata_rw28_binding, &status);
     if (err_is_fail(err)) {
         printf("failed calling flush_cache\n");
         return err;
@@ -126,7 +119,7 @@ errval_t blockdevfs_ata_close(void *handle)
     struct ata_handle *h = handle;
     errval_t err, status;
 
-    err = h->ata_rw28_rpc.vtbl.flush_cache(&h->ata_rw28_rpc, &status);
+    err = h->ata_rw28_binding->rpc_tx_vtbl.flush_cache(h->ata_rw28_binding, &status);
     if (err_is_fail(err)) {
         printf("failed calling flush_cache\n");
         return err;
@@ -163,7 +156,7 @@ 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);
 
-    err = h->ata_rw28_rpc.vtbl.read_dma(&h->ata_rw28_rpc,
+    err = h->ata_rw28_binding->rpc_tx_vtbl.read_dma(h->ata_rw28_binding,
             aligned_bytes, blockpos, buffer, bytes_read);
 
     return err;
@@ -179,7 +172,7 @@ errval_t blockdevfs_ata_write(void *handle, size_t pos, const void *buffer,
     size_t blockpos = pos / PR_SIZE;
 
     errval_t status;
-    err = h->ata_rw28_rpc.vtbl.write_dma(&h->ata_rw28_rpc,
+    err = h->ata_rw28_binding->rpc_tx_vtbl.write_dma(h->ata_rw28_binding,
             buffer, aligned_bytes, blockpos, &status);
     *bytes_written = aligned_bytes;
     return err;
@@ -192,16 +185,12 @@ static void ahci_mgmt_bind_cb(void *st, errval_t err, struct ahci_mgmt_binding *
     }
 
     ahci_mgmt_binding = b;
-    err = ahci_mgmt_rpc_client_init(&ahci_mgmt_rpc, b);
-    if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "ahci_mgmt RPC init failed");
-    }
-
+    ahci_mgmt_rpc_client_init(ahci_mgmt_binding);
     ahci_mgmt_bound = true;
 
     // populate list
     struct ahci_mgmt_list_response__rx_args reply;
-    err = ahci_mgmt_rpc.vtbl.list(&ahci_mgmt_rpc, reply.port_ids, &reply.len);
+    err = ahci_mgmt_binding->rpc_tx_vtbl.list(ahci_mgmt_binding, reply.port_ids, &reply.len);
     assert(err_is_ok(err));
 
     for (size_t i = 0; i < reply.len; i++) {
@@ -209,7 +198,7 @@ static void ahci_mgmt_bind_cb(void *st, errval_t err, struct ahci_mgmt_binding *
             break;
         }
         struct ahci_mgmt_identify_response__rx_args identify_reply;
-        err = ahci_mgmt_rpc.vtbl.identify(&ahci_mgmt_rpc, reply.port_ids[i],
+        err = ahci_mgmt_binding->rpc_tx_vtbl.identify(ahci_mgmt_binding, reply.port_ids[i],
                                           identify_reply.identify_data,
                                           &identify_reply.data_len);
         assert(err_is_ok(err));
index 20d6dd6..c5d51c6 100644 (file)
@@ -19,7 +19,7 @@
 #include <dev/fat_direntry_dev.h>
 #include <if/ata_rw28_defs.h>
 #include <if/ata_rw28_ahci_defs.h>
-#include <if/ata_rw28_rpcclient_defs.h>
+#include <if/ata_rw28_defs.h>
 #include <ahci/ahci.h>
 #include "vfs_fat_conv.h"
 #include "vfs_backends.h"
@@ -128,7 +128,6 @@ enum {
 
 struct fat_mount {
     struct ata_rw28_binding *ata_rw28_binding;
-    struct ata_rw28_rpc_client ata_rw28_rpc;
     struct ahci_binding *ahci_binding;
     errval_t bind_err;
 
@@ -171,7 +170,7 @@ 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,
+        err = mount->ata_rw28_binding->rpc_tx_vtbl.read_dma(mount->ata_rw28_binding,
                 size, block, data_, &read_size);
         if (err_is_fail(err)) {
             return err;
@@ -1077,11 +1076,7 @@ bind_cb(void *st, errval_t err, struct ata_rw28_binding *b)
 
     struct fat_mount *mount = (struct fat_mount*) st;
 
-    err = ata_rw28_rpc_client_init(&mount->ata_rw28_rpc, b);
-    if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "RPC initialization failed");
-    }
-
+    ata_rw28_binding_init(b);
     mount->ata_rw28_binding = b;
 }
 #endif
@@ -1164,11 +1159,8 @@ vfs_fat_mount(const char *uri, void **retst, struct vfs_ops **retops)
     }
     FAT_DEBUG("ahci_ata_rw28_init completed");
     mount->ata_rw28_binding = (struct ata_rw28_binding*)ahci_ata_rw28_binding;
-    err = ata_rw28_rpc_client_init(&mount->ata_rw28_rpc, mount->ata_rw28_binding);
-    if (err_is_fail(err)) {
-        goto ata_rw28_init_failed;
-    }
-    FAT_DEBUG("ata_rw28_rpc_client_init completed");
+    ata_rw28_rpc_client_init(mount->ata_rw28_binding);
+    FAT_DEBUG("ata_rw28_binding_init completed");
 #elif defined(__pandaboard__)
     FAT_DEBUG("wait for mmchs service\n");
     iref_t iref;
@@ -1194,7 +1186,7 @@ vfs_fat_mount(const char *uri, void **retst, struct vfs_ops **retops)
     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,
+    err = mount->ata_rw28_binding->rpc_tx_vtbl.read_dma_block(mount->ata_rw28_binding,
             mount->startblock, mount->bootsec_data, &size);
     if (err_is_fail(err)) {
         goto bootsec_read_failed;
@@ -1295,7 +1287,7 @@ vfs_fat_mount(const char *uri, void **retst, struct vfs_ops **retops)
             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->ata_rw28_binding->rpc_tx_vtbl.read_dma_block(mount->ata_rw28_binding,
                 mount->startblock + fs_info_sector, reply.buffer ,
                 &reply.buffer_size);
         if (memcmp(reply.buffer+0, "RRaA", 4) != 0 ||
index d4b7a5e..f4cf9b9 100644 (file)
@@ -15,7 +15,7 @@
 #include <barrelfish/bulk_transfer.h>
 #include <vfs/vfs_path.h>
 #include <if/trivfs_defs.h>
-#include <if/trivfs_rpcclient_defs.h>
+#include <if/trivfs_defs.h>
 #include <if/monitor_defs.h>
 
 #include "vfs_backends.h"
@@ -27,7 +27,7 @@ static const bool use_bulk_data = true;
 #define BULK_BLOCK_SIZE     BULK_MEM_SIZE   // (it's RPC)
 
 struct ramfs_client {
-    struct trivfs_rpc_client rpc;
+    struct trivfs_binding *rpc;
     struct bulk_transfer bulk;
     trivfs_fh_t rootfh;
     bool bound;
@@ -73,14 +73,14 @@ restart: ;
 
         // lookup
         trivfs_fh_t nextfh;
-        err = cl->rpc.vtbl.lookup(&cl->rpc, fh, pathbuf, &msgerr, &nextfh, &isdir);
+        err = cl->rpc->rpc_tx_vtbl.lookup(cl->rpc, fh, pathbuf, &msgerr, &nextfh, &isdir);
         if (err_is_fail(err)) {
             DEBUG_ERR(err, "transport error in lookup");
             return err;
         } else if (err_is_fail(msgerr)) {
             if (err_no(msgerr) == FS_ERR_INVALID_FH) {
                 if (fh == cl->rootfh) { // revalidate root
-                    err = cl->rpc.vtbl.getroot(&cl->rpc, &cl->rootfh);
+                    err = cl->rpc->rpc_tx_vtbl.getroot(cl->rpc, &cl->rootfh);
                     if (err_is_fail(err)) {
                         USER_PANIC_ERR(err, "failed to get root fh");
                     }
@@ -176,7 +176,7 @@ static errval_t create(void *st, const char *path, vfs_handle_t *rethandle)
     }
 
     // create the last part of the path
-    err = cl->rpc.vtbl.create(&cl->rpc, fh, &path[pos], &msgerr, &fh);
+    err = cl->rpc->rpc_tx_vtbl.create(cl->rpc, fh, &path[pos], &msgerr, &fh);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "transport error in create");
         return err;
@@ -214,7 +214,7 @@ static errval_t ramfs_remove(void *st, const char *path)
         return FS_ERR_NOTFILE;
     }
 
-    err = cl->rpc.vtbl.delete(&cl->rpc, fh, &msgerr);
+    err = cl->rpc->rpc_tx_vtbl.delete(cl->rpc, fh, &msgerr);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "transport error in delete");
         return err;
@@ -237,7 +237,7 @@ static errval_t read(void *st, vfs_handle_t handle, void *buffer, size_t bytes,
     assert(!h->isdir);
 
 restart:
-    err = cl->rpc.vtbl.read(&cl->rpc, h->fh, h->pos, bytes,
+    err = cl->rpc->rpc_tx_vtbl.read(cl->rpc, h->fh, h->pos, bytes,
                             &msgerr, buffer, bytes_read);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "transport error in read");
@@ -274,7 +274,7 @@ static errval_t write(void *st, vfs_handle_t handle, const void *buffer,
     assert(!h->isdir);
 
 restart:
-    err = cl->rpc.vtbl.write(&cl->rpc, h->fh, h->pos, buffer, bytes, &msgerr);
+    err = cl->rpc->rpc_tx_vtbl.write(cl->rpc, h->fh, h->pos, buffer, bytes, &msgerr);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "transport error in write");
         return err;
@@ -328,7 +328,7 @@ static errval_t read_bulk(void *st, vfs_handle_t handle, void *buffer,
         int restarts = 0;
 
 restart:
-        err = cl->rpc.vtbl.read_bulk(&cl->rpc, h->fh, h->pos, reqlen,
+        err = cl->rpc->rpc_tx_vtbl.read_bulk(cl->rpc, h->fh, h->pos, reqlen,
                                      txbufid, &msgerr, &retlen);
         if (err_is_fail(err)) {
             DEBUG_ERR(err, "transport error in read");
@@ -399,7 +399,7 @@ static errval_t write_bulk(void *st, vfs_handle_t handle, const void *buffer,
         int restarts = 0;
 
 restart:
-        err = cl->rpc.vtbl.write_bulk(&cl->rpc, h->fh, h->pos, reqlen, bufid,
+        err = cl->rpc->rpc_tx_vtbl.write_bulk(cl->rpc, h->fh, h->pos, reqlen, bufid,
                                       &msgerr);
         if (err_is_fail(err)) {
             DEBUG_ERR(err, "transport error in write");
@@ -443,7 +443,7 @@ static errval_t truncate(void *st, vfs_handle_t handle, size_t bytes)
     assert(!h->isdir);
 
 restart:
-    err = cl->rpc.vtbl.truncate(&cl->rpc, h->fh, bytes, &msgerr);
+    err = cl->rpc->rpc_tx_vtbl.truncate(cl->rpc, h->fh, bytes, &msgerr);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "transport error in truncate");
         return err;
@@ -479,7 +479,7 @@ static errval_t stat(void *st, vfs_handle_t inhandle, struct vfs_fileinfo *info)
     int restarts = 0;
 
 restart:
-    err = cl->rpc.vtbl.getattr(&cl->rpc, h->fh, &msgerr, &isdir, &size);
+    err = cl->rpc->rpc_tx_vtbl.getattr(cl->rpc, h->fh, &msgerr, &isdir, &size);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "transport error in getattr");
         return err;
@@ -589,7 +589,7 @@ static errval_t dir_read_next(void *st, vfs_handle_t inhandle, char **retname,
 
     struct trivfs_readdir_response__rx_args reply;
 restart:
-    err = cl->rpc.vtbl.readdir(&cl->rpc, h->fh, h->pos,
+    err = cl->rpc->rpc_tx_vtbl.readdir(cl->rpc, h->fh, h->pos,
                                &reply.err, reply.name, &reply.isdir, &reply.size);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "transport error in readdir");
@@ -598,7 +598,7 @@ restart:
         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);
+                err = cl->rpc->rpc_tx_vtbl.getroot(cl->rpc, &cl->rootfh);
                 if (err_is_fail(err)) {
                     USER_PANIC_ERR(err, "failed to get root fh");
                 }
@@ -673,7 +673,7 @@ static errval_t mkdir(void *st, const char *path)
 
     // create child
     trivfs_fh_t newfh;
-    err = cl->rpc.vtbl.mkdir(&cl->rpc, parent, childname, &msgerr, &newfh);
+    err = cl->rpc->rpc_tx_vtbl.mkdir(cl->rpc, parent, childname, &msgerr, &newfh);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "transport error in mkdir");
         return err;
@@ -696,7 +696,7 @@ static errval_t rmdir(void *st, const char *path)
         return FS_ERR_NOTDIR;
     }
 
-    err = cl->rpc.vtbl.delete(&cl->rpc, fh, &msgerr);
+    err = cl->rpc->rpc_tx_vtbl.delete(cl->rpc, fh, &msgerr);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "transport error in delete");
         return err;
@@ -751,12 +751,9 @@ static void bind_cb(void *st, errval_t err, struct trivfs_binding *b)
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "bind failed");
     }
-
-    err = trivfs_rpc_client_init(&cl->rpc, b);
-    if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "RPC init failed");
-    }
-
+    
+    cl->rpc = b;
+    trivfs_rpc_client_init(cl->rpc);
     cl->bound = true;
 }
 
@@ -840,7 +837,7 @@ errval_t vfs_ramfs_mount(const char *uri, void **retst, struct vfs_ops **retops)
     }
 
     // get root fh
-    err = client->rpc.vtbl.getroot(&client->rpc, &client->rootfh);
+    err = client->rpc->rpc_tx_vtbl.getroot(client->rpc, &client->rootfh);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "failed to get root fh");
     }
@@ -855,7 +852,7 @@ errval_t vfs_ramfs_mount(const char *uri, void **retst, struct vfs_ops **retops)
         }
 
         // Send bulk frame cap to server
-        err = client->rpc.vtbl.bulk_init(&client->rpc, shared_frame, &msgerr);
+        err = client->rpc->rpc_tx_vtbl.bulk_init(client->rpc, shared_frame, &msgerr);
         if (err_is_fail(err)) {
             USER_PANIC_ERR(err, "failed to call bulk_init");
         } else if (err_is_fail(msgerr)) {
index ebd5dc0..8acd085 100644 (file)
 #include <virtio/virtio_guest.h>
 
 #include <if/virtio_defs.h>
-#include <if/virtio_rpcclient_defs.h>
+#include <if/virtio_defs.h>
 
 #include "channel.h"
 #include "debug.h"
 
 
-static struct virtio_rpc_client virtio_rpc_client;
+static struct virtio_binding *virtio_binding;
 
 static iref_t virtio_rpc_svc_iref;
 
-enum virtio_rpc_client_state {
+enum virtio_binding_state {
     RPC_CLIENT_STATE_INVALID,
     RPC_CLIENT_STATE_BINDING,
     RPC_CLIENT_STATE_FAILED,
     RPC_CLIENT_STATE_READY
 };
 
-static enum virtio_rpc_client_state rpc_client_state = RPC_CLIENT_STATE_INVALID;
+static enum virtio_binding_state rpc_client_state = RPC_CLIENT_STATE_INVALID;
 
 
 /**
@@ -49,7 +49,7 @@ static  errval_t open_device(uint8_t backend,
         return -1;
     }
 
-    err = virtio_rpc_client.vtbl.open(&virtio_rpc_client,
+    err = virtio_binding->rpc_tx_vtbl.open(virtio_binding,
                                       backend,
                                       &msg_err,
                                       ret_frame);
@@ -71,7 +71,7 @@ static  errval_t close_device(void)
         return -1;
     }
 
-    err =  virtio_rpc_client.vtbl.close(&virtio_rpc_client);
+    err =  virtio_binding->rpc_tx_vtbl.close(virtio_binding);
     if (err_is_fail(err)) {
         return err;
     }
@@ -99,7 +99,7 @@ static  errval_t add_vring(struct virtqueue *vq)
 
     uint16_t ndesc = virtio_virtqueue_get_num_desc(vq);
 
-    err =  virtio_rpc_client.vtbl.add(&virtio_rpc_client, id, ndesc, buffers, frame, &msg_err);
+    err =  virtio_binding->rpc_tx_vtbl.add(virtio_binding, id, ndesc, buffers, frame, &msg_err);
     if (err_is_fail(err)) {
         return err;
     }
@@ -119,7 +119,7 @@ static  errval_t extend_vring(uint16_t vq_id,
         return -1;
     }
 
-    err =  virtio_rpc_client.vtbl.extend(&virtio_rpc_client, vq_id, vbuf, &msg_err);
+    err =  virtio_binding->rpc_tx_vtbl.extend(virtio_binding, vq_id, vbuf, &msg_err);
     if (err_is_fail(err)) {
         return err;
     }
@@ -139,7 +139,7 @@ static  errval_t request_mem(uint64_t size,
         return -1;
     }
 
-    err =  virtio_rpc_client.vtbl.req(&virtio_rpc_client, size, &msg_err, cap);
+    err =  virtio_binding->rpc_tx_vtbl.req(virtio_binding, size, &msg_err, cap);
     if (err_is_fail(err)) {
         return err;
     }
@@ -163,11 +163,8 @@ static void bind_cb(void *st, errval_t err, struct virtio_binding *b)
     }
 
     VIRTIO_DEBUG_CHAN("Initializing RPC client\n");
-    err = virtio_rpc_client_init(&virtio_rpc_client, b);
-    if (err_is_fail(err)) {
-        rpc_client_state = RPC_CLIENT_STATE_FAILED;
-    }
-
+    virtio_binding = b;
+    virtio_rpc_client_init(virtio_binding);
     vguest_chan_fn = &vguest_fc_fn;
 
     rpc_client_state = RPC_CLIENT_STATE_READY;
index 777f47f..036f52c 100644 (file)
@@ -16,7 +16,7 @@
 #include <virtio/virtio_host.h>
 
 #include <if/virtio_defs.h>
-#include <if/virtio_rpcclient_defs.h>
+#include <if/virtio_defs.h>
 
 #include "channel.h"
 #include "device.h"
index d3f8855..ab91ed9 100644 (file)
@@ -21,7 +21,7 @@
 #include <xeon_phi/xeon_phi_client.h>
 
 #include <if/octopus_defs.h>
-#include <if/octopus_rpcclient_defs.h>
+#include <if/octopus_defs.h>
 //#include <if/monitor_defs.h>
 #include <octopus/getset.h> // for oct_read TODO
 #include <octopus/trigger.h> // for NOP_TRIGGER
@@ -96,13 +96,13 @@ errval_t xeon_phi_domain_lookup(const char *iface,
 #else
     errval_t err;
 
-    struct octopus_rpc_client *r = get_octopus_rpc_client();
+    struct octopus_binding *r = get_octopus_binding();
     if (r == NULL) {
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
 
     struct octopus_get_response__rx_args reply;
-    err = r->vtbl.get(r, iface, NOP_TRIGGER, reply.output, &reply.tid, &reply.error_code);
+    err = r->rpc_tx_vtbl.get(r, iface, NOP_TRIGGER, reply.output, &reply.tid, &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
     }
@@ -144,13 +144,13 @@ errval_t xeon_phi_domain_blocking_lookup(const char *iface,
 #else
     errval_t err;
 
-    struct octopus_rpc_client *r = get_octopus_rpc_client();
+    struct octopus_binding *r = get_octopus_binding();
     if (r == NULL) {
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
 
     struct octopus_wait_for_response__rx_args reply;
-    err = r->vtbl.wait_for(r, iface, reply.record, &reply.error_code);
+    err = r->rpc_tx_vtbl.wait_for(r, iface, reply.record, &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
     }
@@ -191,7 +191,7 @@ errval_t xeon_phi_domain_register(const char *iface,
 #else
     errval_t err = SYS_ERR_OK;
 
-    struct octopus_rpc_client *r = get_octopus_rpc_client();
+    struct octopus_binding *r = get_octopus_binding();
     if (r == NULL) {
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
@@ -207,7 +207,7 @@ errval_t xeon_phi_domain_register(const char *iface,
 
     octopus_trigger_id_t tid;
     errval_t error_code;
-    err = r->vtbl.set(r, record, 0, NOP_TRIGGER, 0, NULL, &tid, &error_code);
+    err = r->rpc_tx_vtbl.set(r, record, 0, NOP_TRIGGER, 0, NULL, &tid, &error_code);
     if (err_is_fail(err)) {
         goto out;
     }
index 26f7e85..440ffdc 100644 (file)
@@ -14,7 +14,7 @@
 #include <xeon_phi/xeon_phi_manager_client.h>
 
 #include <if/xeon_phi_manager_defs.h>
-#include <if/xeon_phi_manager_rpcclient_defs.h>
+#include <if/xeon_phi_manager_defs.h>
 
 /// the name of the Xeon Phi Manager service
 #define XEON_PHI_MANAGER_SERVICE_NAME "xeon_phi_manager"
@@ -49,8 +49,6 @@ static iref_t xpm_iref = 0;
 /// Flounder binind go the Xeon Phi manager
 static struct xeon_phi_manager_binding *xpm_binding = NULL;
 
-static struct xeon_phi_manager_rpc_client xpm_rpc_client;
-
 /// connection state
 static enum xpm_state conn_state = XPM_STATE_INVALID;
 
@@ -99,7 +97,7 @@ static void xpm_bind_cb(void *st,
 
     conn_state = XPM_STATE_BIND_OK;
 
-    xeon_phi_manager_rpc_client_init(&xpm_rpc_client, binding);
+    xeon_phi_manager_rpc_client_init(xpm_binding);
 
     DEBUG_XPMC("binding to "XEON_PHI_MANAGER_SERVICE_NAME" succeeded\n");
 }
@@ -198,7 +196,7 @@ errval_t xeon_phi_manager_client_register(iref_t svc_iref,
 
     xeon_phi_manager_cards_t cards;
 
-    err = xpm_rpc_client.vtbl.register_driver(&xpm_rpc_client, svc_iref, id,
+    err = xpm_binding->rpc_tx_vtbl.register_driver(xpm_binding, svc_iref, id,
                                               &cards, &msgerr);
     if (err_is_fail(err)) {
         return err;
@@ -251,7 +249,7 @@ errval_t xeon_phi_manager_lookup(xphi_id_t xid,
         return err;
     }
 
-    err = xpm_rpc_client.vtbl.lookup(&xpm_rpc_client, xid, svc_iref, &msgerr);
+    err = xpm_binding->rpc_tx_vtbl.lookup(xpm_binding, xid, svc_iref, &msgerr);
     if (err_is_fail(err)) {
         return err;
     }
index a6f9d63..fc5cf76 100644 (file)
@@ -75,13 +75,11 @@ msg_enum_elem_name ifn mn = idscope ifn mn "msgnum"
 
 -- Name of the type of a message function
 msg_sig_type :: String -> MessageDef -> Direction -> String
-msg_sig_type ifn m@(RPC _ _ _) _ = idscope ifn (msg_name m) "rpc_method_fn"
+msg_sig_type ifn m@(RPC _ _ _) TX = idscope ifn (msg_name m) "rpc_tx_method_fn"
+msg_sig_type ifn m@(RPC _ _ _) RX = idscope ifn (msg_name m) "rpc_rx_method_fn"
 msg_sig_type ifn m TX = idscope ifn (msg_name m) "tx_method_fn"
 msg_sig_type ifn m RX =  idscope ifn (msg_name m) "rx_method_fn"
 
-msg_sig_type_rpc_rx :: String -> MessageDef -> String
-msg_sig_type_rpc_rx ifn m@(RPC _ _ _) = idscope ifn (msg_name m) "rpc_rx_method_fn"
-
 -- Name of a given message definition
 msg_name :: MessageDef -> String
 msg_name (Message _ n _ _) = n
index e0a8771..5758fa8 100644 (file)
@@ -16,8 +16,8 @@ module GCBackend where
 import Data.Char
 
 import qualified CAbsSyntax as C
-import Syntax (Interface (Interface), MessageDef(Message, RPC), TypeDef, MessageType(MMessage, MCall, MResponse), RPCArgument(RPCArgIn, RPCArgOut))
-import GHBackend (flounder_backends, export_fn_name, bind_fn_name, accept_fn_name, connect_fn_name, connect_handlers_fn_name, disconnect_handlers_fn_name)
+import Syntax
+import GHBackend (flounder_backends, export_fn_name, bind_fn_name, accept_fn_name, connect_fn_name, connect_handlers_fn_name, disconnect_handlers_fn_name, rpc_tx_vtbl_type, rpc_init_fn_name)
 import qualified Backend
 import BackendCommon
 import LMP (lmp_bind_type, lmp_bind_fn_name)
@@ -26,6 +26,9 @@ import qualified UMP_IPI (bind_type, bind_fn_name)
 import qualified Multihop (m_bind_type, m_bind_fn_name)
 import Local (local_init_fn_name)
 
+
+-- import GHBackend (msg_signature_generic, intf_vtbl_param)
+
 -- name of the bind continuation function
 bind_cont_name :: String -> String
 bind_cont_name ifn = ifscope ifn "bind_continuation_direct"
@@ -34,6 +37,18 @@ bind_cont_name ifn = ifscope ifn "bind_continuation_direct"
 bind_cont_name2 :: String -> String
 bind_cont_name2 ifn = ifscope ifn "bind_contination_multihop"
 
+-- Name of the RPC function
+rpc_fn_name ifn mn = idscope ifn mn "rpc"
+local_rpc_fn_name ifn mn = idscope ifn mn "local_rpc"
+
+-- Name of the RPC vtable
+rpc_vtbl_name ifn = ifscope ifn "rpc_vtbl"
+local_rpc_vtbl_name ifn = ifscope ifn "local_rpc_vtbl"
+
+-- Name of the error handler
+rpc_error_fn_name :: String -> String
+rpc_error_fn_name ifn = ifscope ifn "rpc_client_error"
+
 compile :: String -> String -> Interface -> String
 compile infile outfile interface =
     unlines $ C.pp_unit $ stub_body infile interface
@@ -90,6 +105,20 @@ stub_body_message_handlers infile (Interface ifn descr decls) = C.UnitList [
 
     C.MultiComment [ "Disconnect handlers function" ],
     disconnect_handlers_fn_def ifn messages,
+    C.Blank,
+
+    C.MultiComment [ "RPC wrapper functions" ],
+    C.UnitList [ rpc_fn ifn types m | m <- rpcs ],
+    C.UnitList [ local_rpc_fn ifn types m | m <- rpcs ],
+    C.Blank,
+
+    C.MultiComment [ "RPC Vtable" ],
+    rpc_vtbl ifn rpcs,
+    local_rpc_vtbl ifn rpcs,
+        
+    C.MultiComment [ "RPC init function" ],
+    rpc_init_fn ifn rpcs,
+        
     C.Blank]
 
     where
@@ -413,6 +442,147 @@ bind_fn_def n =
                  C.Param (C.Ptr $ C.Struct "waitset") "waitset",
                  C.Param (C.TypeName "idc_bind_flags_t") "flags" ]
 
+rpc_rx_union_elem :: String -> String -> C.Expr
+rpc_rx_union_elem mn fn =
+   C.FieldOf (C.FieldOf (C.DerefField bindvar "rx_union")
+                    (rpc_resp_name mn)) fn
+
+rpc_fn :: String -> [TypeDef] -> MessageDef -> C.Unit
+rpc_fn ifn typedefs msg@(RPC n args _) =
+    C.FunctionDef C.Static (C.TypeName "errval_t") (rpc_fn_name ifn n) params [
+        localvar (C.TypeName "errval_t") errvar_name (Just $ C.Variable "SYS_ERR_OK"),
+        C.Ex $ C.Call "assert" [C.Unary C.Not rpc_progress_var],
+        C.Ex $ C.Call "assert" [C.Binary C.Equals async_err_var (C.Variable "SYS_ERR_OK")],
+        C.Ex $ C.Call "thread_set_rpc_in_progress" [C.Variable "true"],
+        C.SBlank,
+        C.SComment "set provided caprefs on underlying binding",
+        binding_save_rx_slots,
+        C.SBlank,
+        C.SComment "call send function",
+        C.Ex $ C.Assignment binding_error (C.Variable "SYS_ERR_OK"),
+        C.Ex $ C.Call "thread_set_outgoing_token" [C.Call "thread_set_token" [message_chanstate]],
+        C.Ex $ C.Assignment errvar $ C.CallInd tx_func tx_func_args,
+        C.If (C.Call "err_is_fail" [errvar]) [
+            C.Goto "out"] [],
+        C.SBlank,
+        C.SComment "wait for message to be sent and reply or error to be present",
+        C.Ex $ C.Assignment errvar $ C.Call "wait_for_channel"
+                [waitset_var, message_chanstate, C.AddressOf binding_error],
+        C.SBlank,
+        C.If (C.Call "err_is_fail" [errvar]) [
+            C.Goto "out"] [],
+        C.SBlank,
+
+        C.StmtList [assign typedefs arg | arg <- rxargs],
+        C.Ex $ C.Assignment errvar $ C.CallInd receive_next [bindvar],
+        C.Label "out",
+        C.Ex $ C.Call "thread_set_rpc_in_progress" [C.Variable "false"],
+        C.Ex $ C.Call "thread_clear_token" [receiving_chanstate],
+        C.Return errvar
+    ]
+    where
+        params = [C.Param (C.Ptr $ C.Struct $ intf_bind_type ifn) intf_bind_var]
+                 ++ concat [rpc_argdecl2 TX ifn typedefs a | a <- args]
+        rpc_progress_var = C.Call "thread_get_rpc_in_progress" []
+        async_err_var = C.Call "thread_get_async_error" []
+        waitset_var = C.DerefField bindvar "waitset"
+        tx_func = C.DerefField bindvar "tx_vtbl" `C.FieldOf` (rpc_call_name n)
+        tx_func_args = [bindvar, C.Variable "BLOCKING_CONT"] ++ (map C.Variable $ concat $ map mkargs txargs)
+        mkargs (Arg _ (Name an)) = [an]
+        mkargs (Arg _ (StringArray an _)) = [an]
+        mkargs (Arg _ (DynamicArray an al _)) = [an, al]
+        (txargs, rxargs) = partition_rpc_args args
+        is_cap_arg (Arg (Builtin t) _) = t == Cap || t == GiveAwayCap
+        is_cap_arg (Arg _ _) = False
+        rx_cap_args = filter is_cap_arg rxargs
+        binding_save_rx_slot (Arg tr (Name an)) = C.Ex $
+            C.Call "thread_store_recv_slot" [(C.DerefPtr $ C.Variable an)]
+        binding_save_rx_slots = C.StmtList [ binding_save_rx_slot c | c <- rx_cap_args ]
+        token_name = "token"
+        outgoing_token = bindvar `C.DerefField` "outgoing_token"
+        receiving_chanstate = C.CallInd (bindvar `C.DerefField` "get_receiving_chanstate") [bindvar]
+        binding_error = C.DerefField bindvar "error"
+        message_chanstate = C.Binary C.Plus (C.DerefField bindvar "message_chanstate") (C.Variable $ msg_enum_elem_name ifn (rpc_resp_name n))
+        receive_next = C.DerefField bindvar "receive_next"
+        assign td (Arg tr (Name an)) = case lookup_typeref typedefs tr of
+            TArray t n _ -> C.If (rpc_rx_union_elem n an) [ C.Ex $ C.Call "mem__cpy" [
+                                (rpc_rx_union_elem n an),
+                                (C.Variable an),
+                                C.SizeOfT $ C.TypeName (type_c_name1 ifn n)]][]
+            _ -> C.If (C.Variable an) [
+                    C.Ex $ C.Assignment (C.DerefPtr $ C.Variable an) (rpc_rx_union_elem n an)] []
+        assign _ (Arg _ (StringArray an l)) =  C.If (C.Variable an) [
+                C.Ex $ C.Call "strncpy" [(C.Variable an), (rpc_rx_union_elem n an), C.NumConstant l]
+            ] []
+        assign _ (Arg _ (DynamicArray an al l)) =  C.If (C.Binary C.And (C.Variable an) (C.Variable al)) [
+                C.Ex $ C.Assignment (C.DerefPtr $ C.Variable al) (rpc_rx_union_elem n al),
+                C.Ex $ C.Call "memcpy" [(C.Variable an), (rpc_rx_union_elem n an), C.DerefPtr $ C.Variable al]
+            ] []
+        errvar_name = "_err"
+        errvar = C.Variable errvar_name
+
+
+
+local_rpc_fn :: String -> [TypeDef] -> MessageDef -> C.Unit
+local_rpc_fn ifn typedefs msg@(RPC n args _) =
+    C.FunctionDef C.Static (C.TypeName "errval_t") (local_rpc_fn_name ifn n) params [
+        C.Return $ C.CallInd tx_func (localbindvar:(map C.Variable $ concat $ map mkargs rpc_args))
+    ]
+    where
+        params = [C.Param (C.Ptr $ C.Struct $ intf_bind_type ifn) intf_bind_var]
+                 ++ concat [rpc_argdecl2 TX ifn typedefs a | a <- args]
+        rpc_args = map rpc_arg args
+        tx_func = C.DerefField localbindvar "rpc_rx_vtbl" `C.FieldOf` (rpc_call_name n)
+        localbindvar = C.DerefField bindvar "local_binding"
+        rpc_arg (RPCArgIn t v) = Arg t v
+        rpc_arg (RPCArgOut t v) = Arg t v
+        mkargs (Arg _ (Name an)) = [an]
+        mkargs (Arg _ (StringArray an _)) = [an]
+        mkargs (Arg _ (DynamicArray an al _)) = [an, al]
+        (txargs, rxargs) = partition_rpc_args args
+
+rpc_vtbl :: String -> [MessageDef] -> C.Unit
+rpc_vtbl ifn ml =
+    C.StructDef C.Static (rpc_tx_vtbl_type ifn) (rpc_vtbl_name ifn) fields
+    where
+        fields = [let mn = msg_name m in (mn, rpc_fn_name ifn mn) | m <- ml]
+
+local_rpc_vtbl :: String -> [MessageDef] -> C.Unit
+local_rpc_vtbl ifn ml =
+    C.StructDef C.Static (rpc_tx_vtbl_type ifn) (local_rpc_vtbl_name ifn) fields
+    where
+        fields = [let mn = msg_name m in (mn, local_rpc_fn_name ifn mn) | m <- ml]
+
+
+arg_names :: MessageArgument -> [String]
+arg_names (Arg _ v) = var_names v
+    where
+        var_names (Name n) = [n]
+        var_names (StringArray n _) = [n]
+        var_names (DynamicArray n1 n2 _) = [n1, n2]
+
+rpc_init_fn :: String -> [MessageDef] -> C.Unit
+rpc_init_fn ifn ml = C.FunctionDef C.NoScope (C.Void)
+                            (rpc_init_fn_name ifn) (rpc_init_fn_params ifn) $
+    [
+     C.SBlank,
+     C.SComment "Setup state of RPC client object",
+     C.If (C.DerefField bindvar "local_binding") [
+        C.Ex $ C.Assignment (C.DerefField bindvar "rpc_tx_vtbl") (C.Variable $ local_rpc_vtbl_name ifn)
+     ][
+        C.Ex $ C.Assignment (C.DerefField bindvar "rpc_tx_vtbl") (C.Variable $ rpc_vtbl_name ifn)
+     ],
+     C.SBlank,
+     C.SComment "Set RX handlers on binding object for RPCs",
+     C.StmtList [C.Ex $ C.Assignment (C.FieldOf (C.DerefField bindvar "rx_vtbl")
+                                        (rpc_resp_name mn))
+         (C.Variable "NULL") | RPC mn _ _ <- ml],
+     C.Ex $ C.Assignment (bindvar `C.DerefField` "error_handler") (C.Variable "NULL"),
+     C.SBlank,
+     C.ReturnVoid]
+    where
+        rpc_init_fn_params n = [C.Param (C.Ptr $ C.Struct (intf_bind_type n)) "_binding"]
+
 ----------------------------------------------------------------------------
 -- everything that we need to know about a backend to attempt a generic bind
 ----------------------------------------------------------------------------
@@ -444,7 +614,7 @@ multihop_bind_backends ifn cont_fn_name = map (\i -> i ifn (C.Variable cont_fn_n
 
 bindst = C.Variable "b"
 binding = bindst `C.DerefField` "binding"
-iref = bindst `C.DerefField` "iref"
+bind_iref = bindst `C.DerefField` "iref"
 waitset = bindst `C.DerefField` "waitset"
 flags = bindst `C.DerefField` "flags"
 
@@ -456,7 +626,7 @@ lmp_bind_backend ifn cont =
             C.Call "malloc" [C.SizeOfT $ C.Struct $ lmp_bind_type ifn],
         C.Ex $ C.Call "assert" [C.Binary C.NotEquals binding (C.Variable "NULL")],
         C.Ex $ C.Assignment errvar $
-            C.Call (lmp_bind_fn_name ifn) [binding, iref, cont, C.Variable "b", waitset,
+            C.Call (lmp_bind_fn_name ifn) [binding, bind_iref, cont, C.Variable "b", waitset,
                                            flags,
                                            C.Variable "DEFAULT_LMP_BUF_WORDS"]
     ],
@@ -477,7 +647,7 @@ local_bind_backend ifn (C.Variable cont) =
             C.Ex $ C.Call "assert" [C.Binary C.NotEquals binding (C.Variable "NULL")],
             localvar (C.Ptr $ C.Struct "idc_export") "e" $ Nothing,
             localvar (C.Ptr $ C.Void) "ret_binding" $ Nothing,
-            C.Ex $ C.Assignment errvar $ C.Call "idc_get_service" [iref, C.AddressOf $ C.Variable "e"],
+            C.Ex $ C.Assignment errvar $ C.Call "idc_get_service" [bind_iref, C.AddressOf $ C.Variable "e"],
             C.Ex $ C.CallInd (C.DerefField (C.Variable "e") "local_connect_callback") [C.Variable "e", binding, C.AddressOf $ C.Variable "ret_binding"],
             C.Ex $ C.Call (local_init_fn_name ifn) [binding, waitset, C.Variable "ret_binding"],
             C.Ex $ C.Call cont [C.Variable "b", C.Variable "SYS_ERR_OK", binding]
@@ -499,7 +669,7 @@ ump_bind_backend ifn cont =
             C.Call "malloc" [C.SizeOfT $ C.Struct $ UMP.bind_type ifn],
         C.Ex $ C.Call "assert" [C.Binary C.NotEquals binding (C.Variable "NULL")],
         C.Ex $ C.Assignment errvar $
-            C.Call (UMP.bind_fn_name ifn) [binding, iref, cont, C.Variable "b", waitset,
+            C.Call (UMP.bind_fn_name ifn) [binding, bind_iref, cont, C.Variable "b", waitset,
                                            flags,
                                            C.Variable "DEFAULT_UMP_BUFLEN",
                                            C.Variable "DEFAULT_UMP_BUFLEN"]
@@ -517,7 +687,7 @@ ump_ipi_bind_backend ifn cont =
             C.Call "malloc" [C.SizeOfT $ C.Struct $ UMP_IPI.bind_type ifn],
         C.Ex $ C.Call "assert" [C.Binary C.NotEquals binding (C.Variable "NULL")],
         C.Ex $ C.Assignment errvar $
-            C.Call (UMP_IPI.bind_fn_name ifn) [binding, iref, cont, C.Variable "b", waitset,
+            C.Call (UMP_IPI.bind_fn_name ifn) [binding, bind_iref, cont, C.Variable "b", waitset,
                                            flags,
                                            C.Variable "DEFAULT_UMP_BUFLEN",
                                            C.Variable "DEFAULT_UMP_BUFLEN"]
@@ -534,7 +704,7 @@ multihop_bind_backend ifn cont =
                          C.Call "malloc" [C.SizeOfT $ C.Struct $ Multihop.m_bind_type ifn],
                          C.Ex $ C.Call "assert" [C.Binary C.NotEquals binding (C.Variable "NULL")],
                          C.Ex $ C.Assignment errvar $
-                         C.Call (Multihop.m_bind_fn_name ifn) [binding, iref, cont, C.Variable "b", waitset, flags]],
+                         C.Call (Multihop.m_bind_fn_name ifn) [binding, bind_iref, cont, C.Variable "b", waitset, flags]],
     test_cb_success = C.Call "err_is_ok" [errvar],
     test_cb_try_next = C.Variable "true",
     cleanup_bind = [ C.Ex $ C.Call "free" [binding] ]
index d146e6b..508c6db 100644 (file)
@@ -30,7 +30,13 @@ bind_fn_name n = ifscope n "bind"
 connect_handlers_fn_name n = ifscope n "connect_handlers"
 disconnect_handlers_fn_name n = ifscope n "disconnect_handlers"
 
+-- Name of the init function
+rpc_init_fn_name :: String -> String
+rpc_init_fn_name ifn = ifscope ifn "rpc_client_init"
+
 rpc_rx_vtbl_type ifn = ifscope ifn "rpc_rx_vtbl"
+rpc_tx_vtbl_type ifn = ifscope ifn "rpc_tx_vtbl"
+local_rpc_tx_vtbl_type ifn = ifscope ifn "local_rpc_tx_vtbl"
 
 ------------------------------------------------------------------------
 -- Language mapping: Create the generic header file for the interface
@@ -96,7 +102,12 @@ intf_header_body infile interface@(Interface name descr decls) =
         C.Blank,
 
         C.MultiComment [ "RPC RX function signatures" ],
-        C.UnitList [ msg_signature_rpc_rx name types (binding_param name) m
+        C.UnitList [ msg_signature_generic RX name types (binding_param name) m
+                    | m <- rpcs ],
+        C.Blank,
+
+        C.MultiComment [ "RPC TX Function signatures" ],
+        C.UnitList [ msg_signature_generic TX name types (binding_param name) m
                     | m <- rpcs ],
         C.Blank,
 
@@ -133,6 +144,10 @@ intf_header_body infile interface@(Interface name descr decls) =
         rpc_rx_vtbl_decl name rpcs,
         C.Blank,
 
+        C.MultiComment [ "VTable struct definition for the rpc interface (transmit)" ],
+        rpc_tx_vtbl_decl name rpcs,
+        C.Blank,
+        
         C.MultiComment [ "Incoming connect callback type" ],
         connect_callback_fn name,
         C.Blank,
@@ -172,6 +187,9 @@ intf_header_body infile interface@(Interface name descr decls) =
         C.MultiComment [ "Backend-specific includes" ],
         C.UnitList $ backend_includes name,
 
+        C.MultiComment [ "Function to initialise an RPC client" ],
+        rpc_init_fn_proto name,
+        
         C.MultiComment [ "And we're done" ]
       ]
 
@@ -191,9 +209,8 @@ msg_enums ifname msgs
 -- Generate type definitions for each message signature
 --
 msg_signature_generic :: Direction -> String -> [TypeDef] -> C.Param -> MessageDef -> C.Unit
-msg_signature_generic dirn ifname typedefs firstparam m = case dirn of
-    TX -> C.TypeDef (C.Function C.NoScope (C.TypeName "errval_t") params) name
-    RX -> C.TypeDef (C.Function C.NoScope (C.TypeName "void") params) name
+msg_signature_generic dirn ifname typedefs firstparam m =
+    C.TypeDef (C.Function C.NoScope (return_type dirn m) params) name
   where
     name = msg_sig_type ifname m dirn
     continuation = C.Param (C.Struct "event_closure") intf_cont_var
@@ -206,23 +223,23 @@ msg_signature_generic dirn ifname typedefs firstparam m = case dirn of
     params = [ firstparam ] ++ opt_continuation ++ concat payload
     payload = case m of
         Message _ _ args _ -> [ msg_argdecl dirn ifname a | a <- args ]
-        RPC s args _       -> [ rpc_argdecl2 TX ifname typedefs a | a <- args ]
+        RPC s args _       -> [ rpc_argdecl2 dirn ifname typedefs a | a <- args ]
+    return_type RX m@(Message _ _ _ _) = C.TypeName "void"
+    return_type _ _ = C.TypeName "errval_t"
 
 msg_signature :: Direction -> String -> MessageDef -> C.Unit
 msg_signature dir ifn = msg_signature_generic dir ifn [] (binding_param ifn)
 
-msg_signature_rpc_rx :: String -> [TypeDef] -> C.Param -> MessageDef -> C.Unit
-msg_signature_rpc_rx ifname typedefs firstparam m@(RPC s args _) = C.TypeDef (C.Function C.NoScope (C.TypeName "errval_t") params) name
-  where
-    name = msg_sig_type_rpc_rx ifname m
-    params = [ firstparam ] ++ concat payload
-    payload = [rpc_argdecl2 RX ifname typedefs a | a <- args]
-
 rpc_rx_vtbl_decl :: String -> [MessageDef] -> C.Unit
 rpc_rx_vtbl_decl n ml =
     C.StructDecl (rpc_rx_vtbl_type n) [ param n m | m <- ml ]
     where
-        param ifn m = C.Param (C.Ptr $ C.TypeName $ msg_sig_type_rpc_rx ifn m) ((msg_name m) ++ "_call")
+        param ifn m = C.Param (C.Ptr $ C.TypeName $ msg_sig_type ifn m RX) ((msg_name m) ++ "_call")
+
+rpc_tx_vtbl_decl :: String -> [MessageDef] -> C.Unit
+rpc_tx_vtbl_decl n ml =
+    C.StructDecl (rpc_tx_vtbl_type n) [ intf_vtbl_param n m TX | m <- ml ]
+
 
 --
 -- Get the maximum size of the arguments
@@ -360,6 +377,10 @@ binding_struct n ml = C.StructDecl (intf_bind_type n) fields
         C.Param (C.Struct $ rpc_rx_vtbl_type n) "rpc_rx_vtbl",
         C.ParamBlank,
 
+        C.ParamComment "RPC send functions (filled in by binding)",
+        C.Param (C.Struct $ rpc_tx_vtbl_type n) "rpc_tx_vtbl",
+        C.ParamBlank,
+
         C.ParamComment "Message channels",
         C.Param (C.Array (toInteger ((length ml) + 3)) (C.Struct "waitset_chanstate")) "message_chanstate",
 
@@ -553,6 +574,14 @@ connect_function n =
                  C.Param (C.Ptr $ C.Struct "waitset") "ws",
                  C.Param (C.TypeName "idc_bind_flags_t") "flags" ]
 
+rpc_init_fn_proto :: String -> C.Unit
+rpc_init_fn_proto n =
+    C.GVarDecl C.Extern C.NonConst
+         (C.Function C.NoScope (C.Void) (rpc_init_fn_params n)) name Nothing
+    where
+        name = rpc_init_fn_name n
+        rpc_init_fn_params n = [C.Param (C.Ptr $ C.Struct (intf_bind_type n)) "binding"]
+
 --
 -- Generate send function inline wrappers for each message signature
 --
index 0c0e086..e636d99 100644 (file)
@@ -191,6 +191,7 @@ tx_fn ifn msg@(Message _ mn args _) =
 
         -- string and array arguments need special treatment
         mkvars (Arg (Builtin String) (Name n)) = [C.Call "strdup" [C.Variable n]]
+        mkvars (Arg _ (StringArray n _)) = [C.Variable n]
         mkvars (Arg _ (DynamicArray n l _)) = [C.Variable $ array_copy_name n, C.Variable l]
         mkvars (Arg _ (Name n)) = [C.Variable n]
 
index e90b909..5ae8005 100644 (file)
@@ -67,31 +67,7 @@ header infile outfile intf =
 
 rpc_header_body :: String -> Interface -> [C.Unit]
 rpc_header_body infile interface@(Interface name descr decls) = [
-    intf_preamble infile name descr,
-    C.Blank,
-    C.MultiComment [ "RPC client" ],
-    C.Blank,
-    C.Include C.Standard ("if/" ++ name ++ "_defs.h"),
-    C.Blank,
-    C.MultiComment [ "Forward declaration of binding type" ],
-    C.StructForwardDecl (rpc_bind_type name),
-    C.Blank,
-    C.MultiComment [ "Function signatures" ],
-    C.UnitList [ msg_signature_generic TX name types (rpc_binding_param name) m
-                | m <- rpcs ],
-    C.Blank,
-    C.MultiComment [ "VTable struct definition for the interface" ],
-    rpc_vtbl_decl name rpcs,
-    C.Blank,
-    C.MultiComment [ "The Binding structure" ],
-    rpc_binding_struct name,
-    C.Blank,
-    C.MultiComment [ "Function to initialise an RPC client" ],
-    rpc_init_fn_proto name,
     C.Blank]
-    where
-        (types, messagedecls) = Backend.partitionTypesMessages decls
-        rpcs = [m | m@(RPC _ _ _) <- messagedecls]
 
 rpc_vtbl_decl :: String -> [MessageDef] -> C.Unit
 rpc_vtbl_decl n ml =
@@ -131,21 +107,7 @@ rpc_stub_body infile intf@(Interface ifn descr decls) = C.UnitList [
     C.Include C.Standard "barrelfish/barrelfish.h",
     C.Include C.Standard "flounder/flounder_support.h",
     C.Include C.Standard ("if/" ++ ifn ++ "_rpcclient_defs.h"),
-    C.Blank,
-
-    C.MultiComment [ "RPC wrapper functions" ],
-    C.UnitList [ rpc_fn ifn types m | m <- rpcs ],
-    C.UnitList [ local_rpc_fn ifn types m | m <- rpcs ],
-    C.Blank,
-
-    C.MultiComment [ "RPC Vtable" ],
-    rpc_vtbl ifn rpcs,
-    local_rpc_vtbl ifn rpcs,
-    C.Blank,
-
-
-    C.MultiComment [ "Init function" ],
-    rpc_init_fn ifn rpcs]
+    C.Blank]
     where
         (types, messagedecls) = Backend.partitionTypesMessages decls
         rpcs = [m | m@(RPC _ _ _) <- messagedecls]
@@ -288,11 +250,23 @@ rpc_init_fn ifn ml = C.FunctionDef C.NoScope (C.TypeName "errval_t")
      C.SBlank,
      C.SComment "Setup state of RPC client object",
      C.Ex $ C.Assignment (C.DerefField rpcvar "b") bindvar,
+
+
+
      C.If (C.DerefField bindvar "local_binding") [
         C.Ex $ C.Assignment (C.DerefField rpcvar "vtbl") (C.Variable $ local_rpc_vtbl_name ifn)
      ][
         C.Ex $ C.Assignment (C.DerefField rpcvar "vtbl") (C.Variable $ rpc_vtbl_name ifn)
      ],
+     C.SBlank,
+     C.SComment "Set RX handlers on binding object for RPCs",
+     C.StmtList [C.Ex $ C.Assignment (C.FieldOf (C.DerefField bindvar "rx_vtbl")
+                                        (rpc_resp_name mn))
+         (C.Variable "NULL") | RPC mn _ _ <- ml],
+     
+     
+     
+     
      C.Ex $ C.Assignment (C.DerefField bindvar "st") rpcvar,
      C.SBlank,
      C.SComment "Set RX handlers on binding object for RPCs",
index c338196..04ccf02 100644 (file)
@@ -1,6 +1,6 @@
 /**
  * \file acpi_generic.c
- * \brief 
+ * \brief
  */
 
 
@@ -17,7 +17,7 @@
 
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/capabilities.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 
 #include <mm/mm.h>
 
@@ -43,7 +43,7 @@ errval_t acpi_allocators_init(void)
 
     ACPI_DEBUG("acpi: initializing allocators\n");
 
-    struct monitor_blocking_rpc_client *cl = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *cl = get_monitor_blocking_binding();
     assert(cl != NULL);
 
     ACPI_DEBUG("acpi: obtaining boot info...\n");
@@ -58,7 +58,7 @@ errval_t acpi_allocators_init(void)
         USER_PANIC_ERR(err, "slot_alloc for monitor->get_bootinfo");
     }
 
-    msgerr = cl->vtbl.get_bootinfo(cl, &err, &bootinfo_frame, &bootinfo_size);
+    msgerr = cl->rpc_tx_vtbl.get_bootinfo(cl, &err, &bootinfo_frame, &bootinfo_size);
     if (err_is_fail(msgerr) || err_is_fail(err)) {
         USER_PANIC_ERR(err_is_fail(msgerr) ? msgerr : err, "failed in get_bootinfo");
     }
@@ -121,7 +121,7 @@ errval_t acpi_allocators_init(void)
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "slot_alloc for monitor->get_phyaddr_cap");
     }
-    err = cl->vtbl.get_phyaddr_cap(cl, &requested_caps, &msgerr);
+    err = cl->rpc_tx_vtbl.get_phyaddr_cap(cl, &requested_caps, &msgerr);
     assert(err_is_ok(err) && err_is_ok(msgerr));
     physical_caps = requested_caps;
 
index 2869a00..087ca30 100644 (file)
@@ -18,7 +18,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <mm/mm.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 
 #include <octopus/octopus.h>
 #include <skb/skb.h>
index e02de78..7432350 100644 (file)
@@ -1,6 +1,6 @@
 /**
  * \file acpi_generic.c
- * \brief 
+ * \brief
  */
 
 
@@ -15,7 +15,7 @@
 
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/capabilities.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 
 #include "acpi_debug.h"
 #include "acpi_shared.h"
@@ -25,7 +25,7 @@ errval_t acpi_allocators_init_arch(struct bootinfo *bootinfo)
 {
     errval_t err;
 
-    struct monitor_blocking_rpc_client *cl = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *cl = get_monitor_blocking_binding();
     assert(cl != NULL);
 
     // Request I/O Cap
@@ -35,7 +35,7 @@ errval_t acpi_allocators_init_arch(struct bootinfo *bootinfo)
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "slot_alloc for monitor->get_io_cap");
     }
-    err = cl->vtbl.get_io_cap(cl, &requested_caps, &error_code);
+    err = cl->rpc_tx_vtbl.get_io_cap(cl, &requested_caps, &error_code);
     assert(err_is_ok(err) && err_is_ok(error_code));
     // Copy into correct slot
     struct capref caps_io = {
index 60230f9..4199636 100644 (file)
@@ -24,7 +24,7 @@
 #include <vfs/vfs_path.h>
 #include <spawndomain/spawndomain.h>
 #include <if/arrakis_defs.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 /* #include <timer/timer.h> */
 #include "ps.h"
 
@@ -100,9 +100,9 @@ static errval_t spawn_arrakis(const char *path, char *const argv[], const char *
     free(image);
 
     /* request connection from monitor */
-    struct monitor_blocking_rpc_client *mrpc = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *mrpc = get_monitor_blocking_binding();
     struct capref monep;
-    err = mrpc->vtbl.alloc_monitor_ep(mrpc, &msgerr, &monep);
+    err = mrpc->rpc_tx_vtbl.alloc_monitor_ep(mrpc, &msgerr, &monep);
     if (err_is_fail(err)) {
         return err_push(err, SPAWN_ERR_MONITOR_CLIENT);
     } else if (err_is_fail(msgerr)) {
index fcf2dfe..9156725 100644 (file)
@@ -3,7 +3,7 @@
 
 static int freemem(void)
 {
-       struct mem_rpc_client *mc = get_mem_client();
+       struct mem_binding *mc = get_mem_client();
        assert(mc != NULL);
        errval_t err;
        genpaddr_t available, total;
index 7c41150..1436dac 100644 (file)
@@ -12,6 +12,7 @@
  */
 
 #include "coreboot.h"
+#include <if/monitor_blocking_defs.h>
 
 extern bool done;
 extern coreid_t core_count;
@@ -137,12 +138,12 @@ errval_t create_or_get_kcb_cap(coreid_t coreid, struct capref* the_kcb)
 
 errval_t give_kcb_to_new_core(coreid_t destination_id, struct capref new_kcb)
 {
-    struct monitor_blocking_rpc_client *mc = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *mc = get_monitor_blocking_binding();
     DEBUG("%s:%s:%d: Send KCB to local monitor for forwarding to destination_id = %"PRIuCOREID"\n",
           __FILE__, __FUNCTION__, __LINE__, destination_id);
 
     errval_t ret_err;
-    errval_t err = mc->vtbl.forward_kcb_request(mc, destination_id, new_kcb,
+    errval_t err = mc->rpc_tx_vtbl.forward_kcb_request(mc, destination_id, new_kcb,
                    &ret_err);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "forward_kcb_request failed.");
@@ -159,8 +160,8 @@ errval_t cap_mark_remote(struct capref cap)
 {
     errval_t err, msgerr;
 
-    struct monitor_blocking_rpc_client *mc = get_monitor_blocking_rpc_client();
-    err = mc->vtbl.cap_set_remote(mc, cap, true, &msgerr);
+    struct monitor_blocking_binding *mc = get_monitor_blocking_binding();
+    err = mc->rpc_tx_vtbl.cap_set_remote(mc, cap, true, &msgerr);
     if (err_is_fail(err)) {
         debug_printf("cap_set_remote RPC transmission failed\n");
         return err;
index 23d3ed5..209d415 100644 (file)
 #include <spawndomain/spawndomain.h>
 
 #include <if/monitor_defs.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
 #include <if/intermon_defs.h>
 
 #if defined(__x86__) && !defined(__k1om__)
 #include <acpi_client/acpi_client.h>
-#include <if/acpi_rpcclient_defs.h>
+#include <if/acpi_defs.h>
 #endif
 
 #define DEBUG_CPUBOOT 0
index 79e4119..5bef85e 100644 (file)
@@ -14,6 +14,7 @@
 #include <getopt.h>
 #include "coreboot.h"
 #include <hw_records.h>
+#include <if/monitor_blocking_defs.h>
 
 
 coreid_t my_arch_id;
@@ -38,8 +39,8 @@ char* cmd_kernel_args = "loglevel=2 logmask=0";
 
 static void load_arch_id(void)
 {
-    struct monitor_blocking_rpc_client *mc = get_monitor_blocking_rpc_client();
-    errval_t err = mc->vtbl.get_arch_core_id(mc, (uintptr_t *)&my_arch_id);
+    struct monitor_blocking_binding *mc = get_monitor_blocking_binding();
+    errval_t err = mc->rpc_tx_vtbl.get_arch_core_id(mc, (uintptr_t *)&my_arch_id);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "get_arch_core_id failed.");
     }
@@ -55,12 +56,12 @@ static void setup_monitor_messaging(void)
 static void load_ipi_cap(void)
 {
     errval_t err;
-    struct monitor_blocking_rpc_client *mc = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *mc = get_monitor_blocking_binding();
     err = slot_alloc(&ipi_cap);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "slot_alloc for monitor->get_ipi_cap failed");
     }
-    err = mc->vtbl.get_ipi_cap(mc, &ipi_cap);
+    err = mc->rpc_tx_vtbl.get_ipi_cap(mc, &ipi_cap);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "get_ipi_cap failed.");
     }
@@ -370,12 +371,12 @@ static int remove_kcb(int argc, char** argv)
         USER_PANIC_ERR(err, "Can not get KCB.");
     }
 
-    struct monitor_blocking_rpc_client *mc = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *mc = get_monitor_blocking_binding();
     // send message to monitor to be relocated -> don't switch kcb ->
     // remove kcb from ring -> msg ->
     // (disp_save_rm_kcb -> next/home/... kcb -> enable switching)
     errval_t ret_err;
-    err = mc->vtbl.forward_kcb_rm_request(mc, target_id, kcb, &ret_err);
+    err = mc->rpc_tx_vtbl.forward_kcb_rm_request(mc, target_id, kcb, &ret_err);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "forward_kcb_request failed.");
     }
index bb94d6e..0459741 100644 (file)
@@ -24,6 +24,8 @@
 #include <arch/x86/start_aps.h>
 #include <target/x86_64/offsets_target.h>
 #include <target/x86_32/offsets_target.h>
+#include <if/acpi_defs.h>
+#include <if/monitor_blocking_defs.h>
 
 #define MON_URPC_CHANNEL_LEN  (32 * UMP_MSG_BYTES)
 
@@ -102,11 +104,11 @@ errval_t get_architecture_config(enum cpu_type type,
         *arch_page_size = X86_64_BASE_PAGE_SIZE;
         *monitor_binary = (cmd_monitor_binary == NULL) ?
                         "/" BF_BINARY_PREFIX "x86_64/sbin/monitor" :
-                        get_binary_path("/" BF_BINARY_PREFIX "x86_64/sbin/%s", 
+                        get_binary_path("/" BF_BINARY_PREFIX "x86_64/sbin/%s",
                                         cmd_monitor_binary);
         *cpu_binary = (cmd_kernel_binary == NULL) ?
                         "/" BF_BINARY_PREFIX "x86_64/sbin/cpu" :
-                        get_binary_path("/" BF_BINARY_PREFIX "x86_64/sbin/%s", 
+                        get_binary_path("/" BF_BINARY_PREFIX "x86_64/sbin/%s",
                                         cmd_kernel_binary);
     }
     break;
@@ -116,11 +118,11 @@ errval_t get_architecture_config(enum cpu_type type,
         *arch_page_size = X86_32_BASE_PAGE_SIZE;
         *monitor_binary = (cmd_monitor_binary == NULL) ?
                         "/" BF_BINARY_PREFIX "x86_32/sbin/monitor" :
-                        get_binary_path("/" BF_BINARY_PREFIX "x86_32/sbin/%s", 
+                        get_binary_path("/" BF_BINARY_PREFIX "x86_32/sbin/%s",
                                         cmd_monitor_binary);
         *cpu_binary = (cmd_kernel_binary == NULL) ?
                         "/" BF_BINARY_PREFIX "x86_32/sbin/cpu" :
-                        get_binary_path("/" BF_BINARY_PREFIX "x86_32/sbin/%s", 
+                        get_binary_path("/" BF_BINARY_PREFIX "x86_32/sbin/%s",
                                         cmd_kernel_binary);
     }
     break;
@@ -130,11 +132,11 @@ errval_t get_architecture_config(enum cpu_type type,
         *arch_page_size = X86_64_BASE_PAGE_SIZE;
         *monitor_binary = (cmd_kernel_binary == NULL) ?
                         "/" BF_BINARY_PREFIX "k1om/sbin/monitor" :
-                        get_binary_path("/" BF_BINARY_PREFIX "k1om/sbin/%s", 
+                        get_binary_path("/" BF_BINARY_PREFIX "k1om/sbin/%s",
                                         cmd_monitor_binary);
         *cpu_binary = (cmd_kernel_binary == NULL) ?
                         "/" BF_BINARY_PREFIX "k1om/sbin/cpu" :
-                        get_binary_path("/" BF_BINARY_PREFIX "k1om/sbin/%s", 
+                        get_binary_path("/" BF_BINARY_PREFIX "k1om/sbin/%s",
                                         cmd_kernel_binary);
     }
     break;
@@ -191,13 +193,13 @@ int start_aps_x86_64_start(uint8_t core_id, genvaddr_t entry)
 
 
 #else
-    struct acpi_rpc_client* acl = get_acpi_rpc_client();
+    struct acpi_binding* acl = get_acpi_binding();
     err = slot_alloc(&bootcap);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "slot_alloc for mm_realloc_range_proxy");
     }
     errval_t error_code;
-    err = acl->vtbl.mm_realloc_range_proxy(acl, 16, 0x0,
+    err = acl->rpc_tx_vtbl.mm_realloc_range_proxy(acl, 16, 0x0,
                                            &bootcap, &error_code);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "mm_alloc_range_proxy failed.");
@@ -235,9 +237,9 @@ int start_aps_x86_64_start(uint8_t core_id, genvaddr_t entry)
 
 
     genpaddr_t global;
-    struct monitor_blocking_rpc_client *mc =
-        get_monitor_blocking_rpc_client();
-    err = mc->vtbl.get_global_paddr(mc, &global);
+    struct monitor_blocking_binding *mc =
+        get_monitor_blocking_binding();
+    err = mc->rpc_tx_vtbl.get_global_paddr(mc, &global);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "invoke spawn core");
         return err_push(err, MON_ERR_SPAWN_CORE);
@@ -310,14 +312,14 @@ int start_aps_x86_32_start(uint8_t core_id, genvaddr_t entry)
     uint8_t *real_end = (uint8_t *) &x86_32_start_ap_end;
 
     struct capref bootcap;
-    struct acpi_rpc_client* acl = get_acpi_rpc_client();
+    struct acpi_binding* acl = get_acpi_binding();
     errval_t err, error_code;
 
     err = slot_alloc(&bootcap);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "slot_alloc for mm_alloc_range_proxy");
     }
-    err = acl->vtbl.mm_realloc_range_proxy(acl, 16, 0x0,
+    err = acl->rpc_tx_vtbl.mm_realloc_range_proxy(acl, 16, 0x0,
                                                     &bootcap, &error_code);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "mm_alloc_range_proxy failed.");
@@ -354,9 +356,9 @@ int start_aps_x86_32_start(uint8_t core_id, genvaddr_t entry)
 
 
     genpaddr_t global;
-    struct monitor_blocking_rpc_client *mc =
-        get_monitor_blocking_rpc_client();
-    err = mc->vtbl.get_global_paddr(mc, &global);
+    struct monitor_blocking_binding *mc =
+        get_monitor_blocking_binding();
+    err = mc->rpc_tx_vtbl.get_global_paddr(mc, &global);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "invoke spawn core");
         return err_push(err, MON_ERR_SPAWN_CORE);
index adebfab..3063330 100644 (file)
@@ -22,7 +22,7 @@
 #include <acpi_client/acpi_client.h>
 #ifdef VF
 #    include <if/e10k_vf_defs.h>
-#    include <if/e10k_vf_rpcclient_defs.h>
+#    include <if/e10k_vf_defs.h>
 #    include <dev/e10k_vf_dev.h>
 #endif
 
@@ -157,7 +157,7 @@ static uint32_t pci_bus = PCI_DONT_CARE;
 static uint32_t pci_device = PCI_DONT_CARE;
 static uint32_t pci_function = 0;
 
-static struct e10k_vf_rpc_client *e10k_vf_client = NULL;
+static struct e10k_vf_binding *e10k_vf_client = NULL;
 
 static void setup_interrupt(size_t *msix_index, uint8_t core, uint8_t vector)
 {
@@ -767,7 +767,7 @@ static void pci_init_card(struct device_mem* bar_info, int bar_count)
     assert(initialized);
 
     // Tell PF driver
-    err = e10k_vf_client->vtbl.init_done(e10k_vf_client, vf_num);
+    err = e10k_vf_client->rpc_tx_vtbl.init_done(e10k_vf_client, vf_num);
     assert(err_is_ok(err));
 
 #if 0
@@ -834,9 +834,9 @@ static void vf_bind_cont(void *st, errval_t err, struct e10k_vf_binding *b)
 {
   assert(err_is_ok(err));
 
-  struct e10k_vf_rpc_client *r = malloc(sizeof(*r));
+  struct e10k_vf_binding *r = malloc(sizeof(*r));
   assert(r != NULL);
-  err = e10k_vf_rpc_client_init(r, b);
+  err = e10k_vf_binding_init(r, b);
   if (err_is_ok(err)) {
     e10k_vf_client = r;
   } else {
@@ -872,7 +872,7 @@ static errval_t e10k_vf_client_connect(void)
         messages_wait_and_handle_next();
     }
 
-    err = e10k_vf_client->vtbl.get_mac_address(e10k_vf_client, vf_num, &d_mac);
+    err = e10k_vf_client->rpc_tx_vtbl.get_mac_address(e10k_vf_client, vf_num, &d_mac);
     assert(err_is_ok(err));
 
     return err2;
index 004d5c2..f5de8e3 100644 (file)
@@ -20,8 +20,8 @@
 #include <barrelfish/debug.h>
 #include <if/sfn5122f_defs.h>
 #include <if/sfn5122f_devif_defs.h>
-#include <if/sfn5122f_devif_rpcclient_defs.h>
-#include <if/net_ARP_rpcclient_defs.h>
+#include <if/sfn5122f_devif_defs.h>
+#include <if/net_ARP_defs.h>
 #include <if/net_ARP_defs.h>
 
 
@@ -91,7 +91,7 @@ static uint32_t phy_loopback_mode = 0;
 static uint32_t wol_filter_id = 0;
 
 // ARP rpc client
-static struct net_ARP_rpc_client arp_rpc;
+static struct net_ARP_binding arp_rpc;
 static bool net_arp_connected = false;
 static struct waitset rpc_ws;
 
@@ -1595,7 +1595,7 @@ static errval_t arp_ip_info(void)
 
     uint32_t gw;
     uint32_t mask;
-    err = arp_rpc.vtbl.ip_info(&arp_rpc, 0, &msgerr, &ip, &gw, &mask);
+    err = arp_rpc->rpc_tx_vtbl.ip_info(&arp_rpc, 0, &msgerr, &ip, &gw, &mask);
     if (err_is_fail(err)) {
         return err;
     }
@@ -1605,7 +1605,7 @@ static errval_t arp_ip_info(void)
 static void a_bind_cb(void *st, errval_t err, struct net_ARP_binding *b)
 {
     assert(err_is_ok(err));
-    err = net_ARP_rpc_client_init(&arp_rpc, b);
+    err = net_ARP_binding_init(&arp_rpc, b);
     assert(err_is_ok(err));
     net_arp_connected = true;
 }
index b3aca1c..9f0c57f 100644 (file)
@@ -12,7 +12,7 @@
 #define USB_TRANSFER_H_
 
 #include <if/usb_manager_defs.h>
-#include <if/usb_manager_rpcclient_defs.h>
+#include <if/usb_manager_defs.h>
 
 struct usb_device;
 struct usb_xfer;
index bc2486a..2067732 100644 (file)
@@ -14,7 +14,7 @@
 #include <barrelfish/spawn_client.h>
 
 #include <if/usb_manager_defs.h>
-#include <if/usb_manager_rpcclient_defs.h>
+#include <if/usb_manager_defs.h>
 
 #include <usb/usb.h>
 #include <usb/class/usb_hid.h>
index 89398dc..ebadb43 100644 (file)
@@ -12,8 +12,8 @@
 
 #include <if/usb_driver_defs.h>
 #include <if/usb_manager_defs.h>
-#include <if/usb_manager_rpcclient_defs.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/usb_manager_defs.h>
+#include <if/monitor_blocking_defs.h>
 
 #include <usb_controller.h>
 #include <usb_request.h>
@@ -330,10 +330,10 @@ int main(int argc, char *argv[])
     /* the default tuple size is 2, since on x86 the interrupts can be routed */
     uint8_t arg_tuple_size = 2;
 
-    struct monitor_blocking_rpc_client *cl = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *cl = get_monitor_blocking_binding();
     assert(cl != NULL);
     uint32_t arch, platform;
-    err = cl->vtbl.get_platform(cl, &arch, &platform);
+    err = cl->rpc_tx_vtbl.get_platform(cl, &arch, &platform);
     assert(err_is_ok(err));
 
     if (arch == PI_ARCH_ARMV7A && platform == PI_PLATFORM_OMAP44XX) {
index 2a07dea..60f7f69 100644 (file)
@@ -14,7 +14,7 @@
 #include <barrelfish/barrelfish.h>
 
 #include <if/usb_manager_defs.h>
-#include <if/usb_manager_rpcclient_defs.h>
+#include <if/usb_manager_defs.h>
 
 #include <usb/usb.h>
 #include <usb/usb_request.h>
index 6a6a444..d4cf788 100644 (file)
@@ -18,7 +18,7 @@
 #include <octopus/octopus.h>
 
 #include <if/octopus_defs.h>
-#include <if/octopus_rpcclient_defs.h>
+#include <if/octopus_defs.h>
 #include <if/octopus_thc.h>
 
 #include "xeon_phi_internal.h"
@@ -64,13 +64,13 @@ errval_t domain_lookup(const char *iface,
 {
     errval_t err;
 
-    struct octopus_rpc_client *r = get_octopus_rpc_client();
+    struct octopus_binding *r = get_octopus_binding();
     if (r == NULL) {
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
 
     struct octopus_get_response__rx_args reply;
-    err = r->vtbl.get(r, iface, NOP_TRIGGER, reply.output, &reply.tid,
+    err = r->rpc_tx_vtbl.get(r, iface, NOP_TRIGGER, reply.output, &reply.tid,
                       &reply.error_code);
     if (err_is_fail(err)) {
         goto out;
@@ -170,7 +170,7 @@ errval_t domain_register(const char *iface,
 {
     errval_t err = SYS_ERR_OK;
 
-    struct octopus_rpc_client *r = get_octopus_rpc_client();
+    struct octopus_binding *r = get_octopus_binding();
     if (r == NULL) {
         return LIB_ERR_NAMESERVICE_NOT_BOUND;
     }
@@ -186,7 +186,7 @@ errval_t domain_register(const char *iface,
 
     octopus_trigger_id_t tid;
     errval_t error_code;
-    err = r->vtbl.set(r, record, 0, NOP_TRIGGER, 0, NULL, &tid, &error_code);
+    err = r->rpc_tx_vtbl.set(r, record, 0, NOP_TRIGGER, 0, NULL, &tid, &error_code);
     if (err_is_fail(err)) {
         goto out;
     }
index 1c89268..aa8b323 100644 (file)
@@ -206,7 +206,7 @@ static void register_response_send(void *a)
 
     struct xeon_phi *phi = topology->local;
 
-    err = xeon_phi_driver_register_response__tx(topology->binding, txcont, err,
+    err = xeon_phi_driver_register__response__tx(topology->binding, txcont, err,
                                                 phi->apt.pbase, phi->apt.length);
     if (err_is_fail(err)) {
         if (err_no(err) == FLOUNDER_ERR_TX_BUSY) {
@@ -296,7 +296,7 @@ static void register_call_send(void *a)
 
     topology->state = XNODE_STATE_REGISTERING;
 
-    err = xeon_phi_driver_register_call__tx(topology->binding, txcont, phi->id,
+    err = xeon_phi_driver_register__call__tx(topology->binding, txcont, phi->id,
                                             phi->apt.pbase, phi->apt.length);
     if (err_is_fail(err)) {
         if (err_no(err) == FLOUNDER_ERR_TX_BUSY) {
@@ -312,8 +312,8 @@ static void register_call_send(void *a)
 
 /// Receive handler table
 static struct xeon_phi_driver_rx_vtbl xps_rx_vtbl = {
-    .register_call = register_call_recv,
-    .register_response = register_response_recv,
+    .register__call = register_call_recv,
+    .register__response = register_response_recv,
     .bootstrap_call = bootstrap_call_rx,
     .bootstrap_response = bootstrap_response_rx
 };
@@ -494,4 +494,3 @@ errval_t service_start(struct xeon_phi *phi)
 
     return SYS_ERR_OK;
 }
-
index ec8d18a..b1aaf23 100644 (file)
 #include <barrelfish/nameservice_client.h>
 
 #include <if/xmplrpc_defs.h>
-#include <if/xmplrpc_rpcclient_defs.h>
+#include <if/xmplrpc_defs.h>
 
 const char *service_name = "xmplrpc_rpc_service";
 
 /* --------------------- Client ------------------------------ */
 
-static struct xmplrpc_rpc_client xmplrpc_client;
+static struct xmplrpc_binding xmplrpc_client;
 
 static void send_myrpc(void)
 {
@@ -36,7 +36,7 @@ static void send_myrpc(void)
     debug_printf("client: sending myrpc\n");
 
     in = 42;
-    err = xmplrpc_client.vtbl.myrpc(&xmplrpc_client, in, &s_out);
+    err = xmplrpc_client->rpc_tx_vtbl.myrpc(&xmplrpc_client, in, &s_out);
 
     if (err_is_ok(err)) {
         debug_printf("client: myrpc(in: %u, out: '%s')\n", in, s_out);
@@ -53,8 +53,8 @@ static void bind_cb(void *st, errval_t err, struct xmplrpc_binding *b)
         USER_PANIC_ERR(err, "bind failed");
     }
     
-    xmplrpc_rpc_client_init(&xmplrpc_client, b);
-    printf("client: finished xmlrpc_rpc_client_init\n");
+    xmplrpc_binding_init(&xmplrpc_client, b);
+    printf("client: finished xmlrpc_binding_init\n");
 
     send_myrpc();
 }
index 8407820..61a6e35 100644 (file)
 #include <stdlib.h>
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/nameservice_client.h>
-#include <if/fb_rpcclient_defs.h>
+#include <if/fb_defs.h>
 
 #include "demo.h"
 
-static struct fb_rpc_client fb_client;
+static struct fb_binding *fb_client;
 static bool init = false;
 
 static void fb_bind_cb(void *st, errval_t err, struct fb_binding *b)
 {
     assert(err_is_ok(err));
 
-    err = fb_rpc_client_init(&fb_client, b);
-    if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "error in mem_rpc_client_init");
-    }
-
+    fb_client = b;
+    fb_rpc_client_init(fb_client);
     init = true;
 }
 
@@ -60,7 +57,7 @@ static int fb_client_connect(void)
 
 void wait_for_vsync(void)
 {
-    errval_t err = fb_client.vtbl.vsync(&fb_client);
+    errval_t err = fb_client->rpc_tx_vtbl.vsync(fb_client);
     assert(err_is_ok(err));
 }
 
@@ -81,7 +78,7 @@ int main(int argc, char *argv[])
 
     fb_client_connect();
 
-    err = fb_client.vtbl.set_videomode(&fb_client, xres, yres, bpp, &ret);
+    err = fb_client->rpc_tx_vtbl.set_videomode(fb_client, xres, yres, bpp, &ret);
     assert(err_is_ok(err));
     if(err_is_fail(ret)) {
         fprintf(stderr, "Error: failed to set video mode %dx%d %dbpp\n",
@@ -92,7 +89,7 @@ int main(int argc, char *argv[])
     // Get and map framebuffer
     struct capref fbcap;
     uint32_t fboffset;
-    err = fb_client.vtbl.get_framebuffer(&fb_client, &ret, &fbcap, &fboffset);
+    err = fb_client->rpc_tx_vtbl.get_framebuffer(fb_client, &ret, &fbcap, &fboffset);
     assert(err_is_ok(err));
     assert(err_is_ok(ret));
 
index 4b4e57b..070e37b 100644 (file)
@@ -35,7 +35,7 @@
 #include <vfs/vfs_path.h>
 #include <if/pixels_defs.h>
 
-#include <if/octopus_rpcclient_defs.h>
+#include <if/octopus_defs.h>
 #include <octopus/getset.h> // for oct_read TODO
 #include <octopus/trigger.h> // for NOP_TRIGGER
 #include <octopus/init.h> // oct_init
@@ -1152,7 +1152,7 @@ static int src(int argc, char *argv[])
 
 static int freecmd(int argc, char *argv[])
 {
-    struct mem_rpc_client *mc = get_mem_client();
+    struct mem_binding *mc = get_mem_client();
     assert(mc != NULL);
     errval_t err;
     genpaddr_t available, total;
@@ -1178,8 +1178,8 @@ static int nproc(int argc, char* argv[]) {
     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, reply.output,
+    struct octopus_binding *r = get_octopus_binding();
+    err = r->rpc_tx_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");
index 45e1bb2..0983d9f 100644 (file)
@@ -16,7 +16,7 @@
 #include <hw_records_arch.h>
 #include <barrelfish/barrelfish.h>
 #include <barrelfish_kpi/platform.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 
 #include <skb/skb.h>
 #include <octopus/getset.h>
@@ -137,11 +137,11 @@ errval_t arch_startup(char * add_device_db_file)
         }
     }
 
-    struct monitor_blocking_rpc_client *m = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *m = get_monitor_blocking_binding();
     assert(m != NULL);
 
     uint32_t arch, platform;
-    err = m->vtbl.get_platform(m, &arch, &platform);
+    err = m->rpc_tx_vtbl.get_platform(m, &arch, &platform);
     assert(err_is_ok(err));
     assert(arch == PI_ARCH_ARMV7A);
 
@@ -149,7 +149,7 @@ errval_t arch_startup(char * add_device_db_file)
 
     struct arch_info_armv7 *arch_info= (struct arch_info_armv7 *)buf;
     size_t buflen;
-    err = m->vtbl.get_platform_arch(m, buf, &buflen);
+    err = m->rpc_tx_vtbl.get_platform_arch(m, buf, &buflen);
     assert(buflen == sizeof(struct arch_info_armv7));
 
     /* Query the SKB for the available cores on this platform - we can't
index 60910ff..b1f442a 100644 (file)
@@ -20,7 +20,7 @@
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/spawn_client.h>
 #include <barrelfish_kpi/platform.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 
 #include <arch/arm/omap44xx/device_registers.h>
 #include <omap44xx_map.h>
@@ -166,12 +166,12 @@ default_start_function(coreid_t where, struct module_info* driver,
 
     errval_t err;
 
-    struct monitor_blocking_rpc_client *m=
-        get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *m=
+        get_monitor_blocking_binding();
     assert(m != NULL);
 
     uint32_t arch, platform;
-    err = m->vtbl.get_platform(m, &arch, &platform);
+    err = m->rpc_tx_vtbl.get_platform(m, &arch, &platform);
     assert(err_is_ok(err));
     assert(arch == PI_ARCH_ARMV7A);
 
index 0934f9e..b41bf48 100644 (file)
@@ -16,7 +16,7 @@
 #include <barrelfish/barrelfish.h>
 #include <skb/skb.h>
 #include <barrelfish_kpi/platform.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 #include "kaluga.h"
 
 
@@ -100,11 +100,11 @@ errval_t arch_startup(char * add_device_db_file)
 {
     errval_t err = SYS_ERR_OK;
 
-    struct monitor_blocking_rpc_client *m = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *m = get_monitor_blocking_binding();
     assert(m != NULL);
 
     uint32_t arch, platform;
-    err = m->vtbl.get_platform(m, &arch, &platform);
+    err = m->rpc_tx_vtbl.get_platform(m, &arch, &platform);
     assert(err_is_ok(err));
     assert(arch == PI_ARCH_ARMV8A);
 
index a103af9..dc6daa1 100644 (file)
@@ -5,7 +5,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <mm/mm.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 
 #include "kaluga.h"
 
@@ -81,13 +81,13 @@ errval_t init_cap_manager(void)
     errval_t err, error_code;
 
     // Request I/O Cap
-    struct monitor_blocking_rpc_client *cl = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *cl = get_monitor_blocking_binding();
     assert(cl != NULL);
 
     struct capref requested_cap;
     err = slot_alloc(&requested_cap);
     assert(err_is_ok(err));
-    err = cl->vtbl.get_io_cap(cl, &requested_cap, &error_code);
+    err = cl->rpc_tx_vtbl.get_io_cap(cl, &requested_cap, &error_code);
     assert(err_is_ok(err) && err_is_ok(error_code));
 
     // Initialize the memory allocator to handle PhysAddr caps
index 88287c6..09a7fcf 100644 (file)
 #include <pci/pci.h> // for pci_address
 
 #ifdef __arm__
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 #endif
 
 #ifdef __aarch64__
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 #endif
 
 #include "kaluga.h"
@@ -204,14 +204,14 @@ errval_t start_networking(coreid_t core,
 /*     debug_printf("doing pandaboard related setup...\n"); */
 /*     errval_t err; */
 
-/*     struct monitor_blocking_rpc_client *cl = get_monitor_blocking_rpc_client(); */
+/*     struct monitor_binding *cl = get_monitor_blocking_binding(); */
 /*     assert(cl != NULL); */
 
 /*     // Request I/O Cap */
 /*     struct capref requested_caps; */
 /*     errval_t error_code; */
 
-/*     err = cl->vtbl.get_io_cap(cl, &requested_caps, &error_code); */
+/*     err = cl->rpc_tx_vtbl.get_io_cap(cl, &requested_caps, &error_code); */
 /*     assert(err_is_ok(err) && err_is_ok(error_code)); */
 
 /*     // Copy into correct slot */
index 3c4eb28..0ae6c2b 100644 (file)
@@ -577,7 +577,7 @@ int main(int argc, char ** argv)
 
 #if 0
         static bool in_rpc_init = false;
-        if (do_rpc_init && !in_rpc_init && !get_monitor_blocking_rpc_client()) {
+        if (do_rpc_init && !in_rpc_init && !get_monitor_blocking_binding()) {
             // XXX: this is an ugly hack try and get a monitor rpc client once
             // the monitor is ready
             in_rpc_init = true;
index 006d397..3c97400 100644 (file)
@@ -30,7 +30,7 @@
 #include <dist/barrier.h>
 
 #include <if/mem_defs.h>
-#include <if/mem_rpcclient_defs.h>
+#include <if/mem_defs.h>
 #include <if/monitor_defs.h>
 
 // #include "barrier.h"
index cb2d632..22b276d 100644 (file)
@@ -30,9 +30,8 @@
 #include <dist/barrier.h>
 
 #include <if/mem_defs.h>
-#include <if/mem_rpcclient_defs.h>
 #include <if/monitor_defs.h>
-#include <if/spawn_rpcclient_defs.h>
+#include <if/spawn_defs.h>
 
 #include "skb.h"
 #include "args.h"
@@ -44,7 +43,7 @@
 
 /*
  * TODO:
- * - currently requests too much memory from initial mem_serv and other 
+ * - currently requests too much memory from initial mem_serv and other
  *   (non_dist) mem_serv clients may suffer
  */
 
@@ -57,13 +56,13 @@ memsize_t mem_local = 0;
 
 /// MM per-core allocator instance data: B-tree to manage mem regions
 struct mm mm_percore;
-// static storage for MM allocator to get it started 
+// static storage for MM allocator to get it started
 static char percore_nodebuf[SLAB_STATIC_SIZE(MINSPARENODES,
                                              MM_NODE_SIZE(MAXCHILDBITS))];
 
 /// MM allocator for reserve of emergency memory used within the mem_serv only
 struct mm mm_local;
-// static storage for MM allocator to get it started 
+// static storage for MM allocator to get it started
 static char local_nodebuf[SLAB_STATIC_SIZE(MINSPARENODES,
                                            MM_NODE_SIZE(MAXCHILDBITS))];
 
@@ -107,9 +106,9 @@ errval_t slab_refill(struct slab_allocator *slabs)
 {
     errval_t err;
 
-    // refill slab allocator if needed 
+    // refill slab allocator if needed
     while (slab_freecount(slabs) <= MINSPARENODES) {
-        // debug_printf("running low on free slabs: slabs=%ld\n", 
+        // debug_printf("running low on free slabs: slabs=%ld\n",
         //             slab_freecount(&mm_percore.slabs));
         struct capref frame;
         err = slot_alloc(&frame);
@@ -162,7 +161,7 @@ static errval_t do_free(struct mm *mm, struct capref ramcap,
     return SYS_ERR_OK;
 }
 
-static errval_t percore_free(struct capref ramcap) 
+static errval_t percore_free(struct capref ramcap)
 {
     struct capability info;
     errval_t ret;
@@ -179,7 +178,7 @@ static errval_t percore_free(struct capref ramcap)
 #if 0
     printf("%d: Cap is type %d Ram base 0x%"PRIxGENPADDR
            " (%"PRIuGENPADDR") Bits %d\n", disp_get_core_id(),
-           info.type, info.u.ram.base, info.u.ram.base, 
+           info.type, info.u.ram.base, info.u.ram.base,
            info.u.ram.bits);
 #endif
 
@@ -193,7 +192,7 @@ errval_t percore_free_handler_common(struct capref ramcap, genpaddr_t base,
     return do_free(&mm_percore, ramcap, base, bits, &mem_avail);
 }
 
-memsize_t mem_available_handler_common(void) 
+memsize_t mem_available_handler_common(void)
 {
     return mem_avail;
 }
@@ -248,7 +247,7 @@ static errval_t local_alloc(struct capref *ret, uint8_t bits,
     return err;
 }
 
-static errval_t get_more_ram(uint8_t bits, genpaddr_t minbase, 
+static errval_t get_more_ram(uint8_t bits, genpaddr_t minbase,
                              genpaddr_t maxlimit)
 {
     errval_t err;
@@ -266,7 +265,7 @@ static errval_t get_more_ram(uint8_t bits, genpaddr_t minbase,
     // make the cap available for a subsequent alloc
     percore_free(cap);
 
-    return SYS_ERR_OK;    
+    return SYS_ERR_OK;
 }
 
 static errval_t do_slot_prealloc_refill(struct slot_prealloc *slot_alloc_inst)
@@ -290,7 +289,7 @@ static errval_t do_slot_prealloc_refill(struct slot_prealloc *slot_alloc_inst)
 }
 
 errval_t percore_allocate_handler_common(uint8_t bits,
-                                         genpaddr_t minbase, 
+                                         genpaddr_t minbase,
                                          genpaddr_t maxlimit,
                                          struct capref *retcap)
 {
@@ -301,13 +300,13 @@ errval_t percore_allocate_handler_common(uint8_t bits,
 
     trace_event(TRACE_SUBSYS_MEMSERV, TRACE_EVENT_MEMSERV_PERCORE_ALLOC, bits);
 
-    // refill slot allocator if needed 
+    // refill slot allocator if needed
     err = do_slot_prealloc_refill(mm_slots->slot_alloc_inst);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "Warning: failure in slot_prealloc_refill");
     }
 
-    // refill slab allocators if needed 
+    // refill slab allocators if needed
     err = slab_refill(&mm_percore.slabs);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "Warning: failure when refilling mm_percore slab");
@@ -343,8 +342,8 @@ static memsize_t get_percore_size(int num_cores)
     memsize_t all_mem_avail, mem_percore, tot_mem;
 
     // send message to mem_serv
-    struct mem_rpc_client *b = get_mem_client();
-    err = b->vtbl.available(b, &all_mem_avail, &tot_mem);
+    struct mem_binding *b = get_mem_client();
+    err = b->rpc_tx_vtbl.available(b, &all_mem_avail, &tot_mem);
 
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "Warning: failure in call to mem_serv.available");
@@ -352,19 +351,19 @@ static memsize_t get_percore_size(int num_cores)
         return PERCORE_MEM;
     }
 
-    debug_printf("available memory: %"PRIuMEMSIZE" bytes over %d cores\n", 
+    debug_printf("available memory: %"PRIuMEMSIZE" bytes over %d cores\n",
                   all_mem_avail, num_cores);
 
     mem_percore = all_mem_avail / num_cores;
 
-    debug_printf("available memory per core: %"PRIuMEMSIZE" bytes\n", 
+    debug_printf("available memory per core: %"PRIuMEMSIZE" bytes\n",
                   mem_percore);
 
     return mem_percore;
 #else
     // Use predetermined amount of memory per core
 
-    debug_printf("available memory per core: %"PRIuMEMSIZE" bytes\n", 
+    debug_printf("available memory per core: %"PRIuMEMSIZE" bytes\n",
                  PERCORE_MEM);
 
     return PERCORE_MEM;
@@ -392,7 +391,7 @@ static void set_affinity(coreid_t core)
 #endif
 
 
-static memsize_t fill_mm(struct mm *mm, memsize_t mem_requested, uint8_t bits, 
+static memsize_t fill_mm(struct mm *mm, memsize_t mem_requested, uint8_t bits,
                       memsize_t *mem_tot)
 {
     errval_t err;
@@ -402,12 +401,12 @@ static memsize_t fill_mm(struct mm *mm, memsize_t mem_requested, uint8_t bits,
     struct capref ramcap;
     struct capability info;
 
-    // get as much of the requested memory as we can, requesting ever 
+    // get as much of the requested memory as we can, requesting ever
     // smaller RAM caps until we hit the smallest RAM cap size
 
     while (bits >= MINALLOCBITS) {
 
-        // debug_printf("adding memory %"PRIuMEMSIZE" (%d bits)\n", 
+        // debug_printf("adding memory %"PRIuMEMSIZE" (%d bits)\n",
         //             (memsize_t)1<<bits, bits);
 
         err = ram_alloc(&ramcap, bits);
@@ -415,7 +414,7 @@ static memsize_t fill_mm(struct mm *mm, memsize_t mem_requested, uint8_t bits,
             // skip this size and try the next size down
             bits--;
             continue;
-        } 
+        }
 
         // XXX: Hack until we have cross-core cap management
         // Forget about remote relations of this cap. This will ensure
@@ -435,7 +434,7 @@ static memsize_t fill_mm(struct mm *mm, memsize_t mem_requested, uint8_t bits,
 #if 0
         debug_printf("Cap is type %d Ram base 0x%"PRIxGENPADDR
                      " (%"PRIuGENPADDR") Bits %d\n",
-                     info.type, info.u.ram.base, info.u.ram.base, 
+                     info.type, info.u.ram.base, info.u.ram.base,
                      info.u.ram.bits);
 #endif
         assert(bits == log2ceil(info.u.ram.bytes));
@@ -509,7 +508,7 @@ static errval_t init_mm(struct mm *mm, char nodebuf[], memsize_t nodebuf_size,
         return err_push(err, MM_ERR_MM_ADD);
     }
 
-    // try to refill slot allocator (may fail or do nothing) 
+    // try to refill slot allocator (may fail or do nothing)
     slot_prealloc_refill(mm->slot_alloc_inst);
 
     return SYS_ERR_OK;
@@ -530,7 +529,7 @@ static errval_t init_slot_allocator(struct slot_prealloc *slot_alloc_inst,
         .slot = 0,
     };
 
-    // init slot allocator 
+    // init slot allocator
     err = slot_prealloc_init(slot_alloc_inst, MAXCHILDBITS,
                              cnode_start_cap, L2_CNODE_SLOTS, mm);
     if (err_is_fail(err)) {
@@ -540,7 +539,7 @@ static errval_t init_slot_allocator(struct slot_prealloc *slot_alloc_inst,
     return SYS_ERR_OK;
 }
 
-errval_t initialize_percore_mem_serv(coreid_t core, coreid_t *cores, 
+errval_t initialize_percore_mem_serv(coreid_t core, coreid_t *cores,
                                      int len_cores, memsize_t percore_mem)
 {
     errval_t err;
@@ -593,7 +592,7 @@ errval_t initialize_percore_mem_serv(coreid_t core, coreid_t *cores,
     // TODO: is this necessary?
     slot_prealloc_refill(mm_slots->slot_alloc_inst);
 
-    // refill slab allocator if needed and possible 
+    // refill slab allocator if needed and possible
     if (slab_freecount(&mm_percore.slabs) <= MINSPARENODES
         && mem_avail > (1UL << (CNODE_BITS + OBJBITS_CTE)) * 2
         + 10 * BASE_PAGE_SIZE) {
@@ -638,13 +637,13 @@ errval_t initialize_percore_mem_serv(coreid_t core, coreid_t *cores,
  */
 errval_t set_local_spawnd_memserv(coreid_t coreid)
 {
-    struct spawn_rpc_client *cl;
-    errval_t err = spawn_rpc_client(coreid, &cl);
+    struct spawn_binding *cl;
+    errval_t err = spawn_binding(coreid, &cl);
     if (err_is_fail(err)) {
         return err;
     }
 
-    return cl->vtbl.use_local_memserv(cl);
+    return cl->rpc_tx_vtbl.use_local_memserv(cl);
 }
 
 
@@ -655,7 +654,7 @@ static int run_worker(coreid_t core, struct args *args)
     // debug_printf("Distributed mem_serv. percore server on core %d\n", core);
 
     // this should never return
-    percore_mem_serv(core, args->cores, args->cores_len, args->ram); 
+    percore_mem_serv(core, args->cores, args->cores_len, args->ram);
     return EXIT_FAILURE; // so we should never reach here
 }
 
@@ -672,7 +671,7 @@ static int run_master(coreid_t core, struct args *args)
     if (args->ram > 0) {
         percore_mem = args->ram;
     } else {
-        percore_mem = get_percore_size(args->cores_len); 
+        percore_mem = get_percore_size(args->cores_len);
     }
 
     // debug_printf("spawning on %d cores\n", args->cores_len);
@@ -683,7 +682,7 @@ static int run_master(coreid_t core, struct args *args)
     // -r <percore_mem>
     char *new_argv[7];
     new_argv[0] = args->path;
-    new_argv[1] = "-w"; 
+    new_argv[1] = "-w";
     new_argv[2] = "-c";
     new_argv[3] = list_to_string(args->cores, args->cores_len);
     assert(new_argv[3] != NULL);
@@ -702,7 +701,7 @@ static int run_master(coreid_t core, struct args *args)
     new_argv[6] = NULL;
 
     for (int i = 0; i < args->cores_len; i++) {
-        err = spawn_program(args->cores[i], new_argv[0], new_argv, 
+        err = spawn_program(args->cores[i], new_argv[0], new_argv,
                             NULL, 0, NULL);
         if (err_is_fail(err)) {
             DEBUG_ERR(err, "spawning percore mem_serv on core %d", i);
@@ -732,7 +731,7 @@ int common_main(int argc, char ** argv)
         return run_master(core, &my_args);
     } else {
         return run_worker(core, &my_args);
-    } 
+    }
 
     return EXIT_SUCCESS;
 }
index 48186f4..a9469b5 100644 (file)
 #include <trace_definitions/trace_defs.h>
 #include <mm/mm.h>
 #include <if/mem_defs.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 
 #include <thc/thc.h>
 #include <thc/thcsync.h>
 
 #include <if/mem_defs.h>
-#include <if/mem_rpcclient_defs.h>
+#include <if/mem_defs.h>
 #include <if/mem_thc.h>
 
 // #include "barrier.h"
index 54356fd..4935123 100644 (file)
@@ -29,7 +29,7 @@
 #include <thc/thcsync.h>
 
 #include <if/mem_defs.h>
-#include <if/mem_rpcclient_defs.h>
+#include <if/mem_defs.h>
 #include <if/mem_thc.h>
 #include <if/monitor_defs.h>
 
index 00b64cf..2deba51 100644 (file)
@@ -18,7 +18,7 @@
 #include "delete_int.h"
 #include "internal.h"
 #include "ram_alloc.h"
-#include <if/mem_rpcclient_defs.h>
+#include <if/mem_defs.h>
 
 struct delete_remote_mc_st {
     struct capsend_mc_st mc_st;
@@ -70,7 +70,7 @@ send_new_ram_cap(struct capref cap)
     struct ram_alloc_state *ram_alloc_state = get_ram_alloc_state();
     thread_mutex_lock(&ram_alloc_state->ram_alloc_lock);
 
-    struct mem_rpc_client *b = get_mem_client();
+    struct mem_binding *b = get_mem_client();
     if (!b) {
         DEBUG_CAPOPS("%s: forwarding to monitor.0\n", __FUNCTION__);
         // we're not on core 0, so forward free_monitor msg to monitor.0
@@ -80,7 +80,7 @@ send_new_ram_cap(struct capref cap)
         DEBUG_CAPOPS("%s: we are monitor.0\n", __FUNCTION__);
         // XXX: This should not be an RPC! It could stall the monitor, but
         // we trust mem_serv for the moment.
-        err = b->vtbl.free_monitor(b, cap, ram.base, log2ceil(ram.bytes), &result);
+        err = b->rpc_tx_vtbl.free_monitor(b, cap, ram.base, log2ceil(ram.bytes), &result);
         assert(err_is_ok(err));
         assert(err_is_ok(result));
     }
index ccaf26d..51dc9e8 100644 (file)
@@ -19,7 +19,7 @@
 #include <barrelfish/core_state.h>
 #include <barrelfish/dispatch.h>
 #include "monitor.h"
-#include <if/mem_rpcclient_defs.h>
+#include <if/mem_defs.h>
 
 #if !defined(__arm__) && !defined(__aarch64__)
 static errval_t reclaim_memory(genpaddr_t base, uint8_t bits)
@@ -52,10 +52,10 @@ static errval_t reclaim_memory(genpaddr_t base, uint8_t bits)
     struct ram_alloc_state *ram_alloc_state = get_ram_alloc_state();
     errval_t result;
     thread_mutex_lock(&ram_alloc_state->ram_alloc_lock);
-    struct mem_rpc_client *b = get_mem_client();
+    struct mem_binding *b = get_mem_client();
     // XXX: This should not be an RPC! It could stall the monitor, but
     // we trust mem_serv for the moment.
-    err = b->vtbl.free_monitor(b, ramcap, base, bits, &result);
+    err = b->rpc_tx_vtbl.free_monitor(b, ramcap, base, bits, &result);
     thread_mutex_unlock(&ram_alloc_state->ram_alloc_lock);
     if(err_is_fail(err)) {
         return err;
index 362bcd0..c04e095 100644 (file)
@@ -15,7 +15,7 @@
  * ETH Zurich D-INFK, Universitaetstr. 6, CH-8092 Zurich. Attn: Systems Group.
  */
 
-#include <if/octopus_rpcclient_defs.h>
+#include <if/octopus_defs.h>
 #include <octopus/getset.h> // for oct_read TODO
 #include <octopus/trigger.h> // for NOP_TRIGGER
 #include "monitor.h"
@@ -38,16 +38,8 @@ static void bind_continuation(void *st_arg, errval_t err,
     if (err_is_ok(err)) {
         b->error_handler = error_handler;
 
-        struct octopus_rpc_client *r;
-        r = malloc(sizeof(struct octopus_rpc_client));
-        assert(r != NULL);
-        err = octopus_rpc_client_init(r, b);
-        if (err_is_fail(err)) {
-            free(r);
-            USER_PANIC_ERR(err, "error in nameservice_rpc_client_init");
-        } else {
-            set_octopus_rpc_client(r);
-        }
+        octopus_rpc_client_init(b);
+        set_octopus_binding(b);
     }
 
     st->err = err;
@@ -84,8 +76,8 @@ errval_t octopus_set_bspkcb(void)
     };
 
     debug_printf("%s: storing cap\n", __FUNCTION__);
-    struct octopus_rpc_client *orpc = get_octopus_rpc_client();
-    err = orpc->vtbl.put_cap(orpc, kcb_key, bspkcb, &octerr);
+    struct octopus_binding *orpc = get_octopus_binding();
+    err = orpc->rpc_tx_vtbl.put_cap(orpc, kcb_key, bspkcb, &octerr);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "oct_put_capability(bspkcb)");
         return err;
@@ -95,7 +87,7 @@ errval_t octopus_set_bspkcb(void)
         return err;
     }
     debug_printf("%s: setting mapping\n", __FUNCTION__);
-    err = orpc->vtbl.set(orpc, mapping, SET_DEFAULT, NOP_TRIGGER, false,
+    err = orpc->rpc_tx_vtbl.set(orpc, mapping, SET_DEFAULT, NOP_TRIGGER, false,
                          NULL, NULL, &octerr);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "oct_set(\"kcb.0 { ... }\")");
index 57eab30..e3e4abb 100644 (file)
 #include "monitor.h"
 #include "capops.h"
 #include <if/monitor_mem_defs.h>
-#include <if/monitor_mem_rpcclient_defs.h>
-#include <if/mem_rpcclient_defs.h>
+#include <if/monitor_mem_defs.h>
+#include <if/mem_defs.h>
 
 static uint8_t mem_core_id;
-static struct monitor_mem_rpc_client monitor_mem_client;
+static struct monitor_mem_binding *monitor_mem_client;
 static bool mem_setup_complete = false;
 iref_t monitor_mem_iref = 0;
 
@@ -140,9 +140,9 @@ static errval_t mem_free_handler(struct monitor_mem_binding *b,
     }
     DEBUG_CAPOPS("%s: created local copy, sending to memserv\n", __FUNCTION__);
 
-    struct mem_rpc_client *mb = get_mem_client();
+    struct mem_binding *mb = get_mem_client();
     assert(mb);
-    err = mb->vtbl.free_monitor(mb, cap, base, bits, result);
+    err = mb->rpc_tx_vtbl.free_monitor(mb, cap, base, bits, result);
     if (err_is_fail(err)) {
         *result = err;
     }
@@ -158,7 +158,7 @@ static errval_t mon_ram_alloc(struct capref *ret, uint8_t size_bits,
     intermon_caprep_t caprep;
     errval_t reterr;
 
-    err = monitor_mem_client.vtbl.alloc(&monitor_mem_client, size_bits,
+    err = monitor_mem_client->rpc_tx_vtbl.alloc(monitor_mem_client, size_bits,
                                         minbase, maxlimit, my_core_id, &reterr,
                                         (monitor_mem_caprep_t *) &caprep);
     if (err_is_fail(err)) {
@@ -223,12 +223,9 @@ static void bind_cont(void *st, errval_t err, struct monitor_mem_binding *b)
     }
 
     // setup RPC client above binding
-    err = monitor_mem_rpc_client_init(&monitor_mem_client, b);
-    if(err_is_fail(err)) {
-        DEBUG_ERR(err, "in monitor_mem_rpc_client_init");
-    } else {
-        mem_setup_complete = true;
-    }
+    monitor_mem_client = b;
+    monitor_mem_rpc_client_init(monitor_mem_client);
+    mem_setup_complete = true;
 }
 
 errval_t mon_ram_alloc_init(coreid_t core_id, struct intermon_binding *b)
@@ -276,10 +273,9 @@ errval_t mon_ram_free(struct capability *cap_raw, genpaddr_t base, uint8_t bits)
     STATIC_ASSERT_SIZEOF(caprep, sizeof(caprep2));
     memcpy(&caprep2, &caprep, sizeof(caprep));
 
-    err = monitor_mem_client.vtbl.free(&monitor_mem_client, caprep2, base, bits, &status);
+    err = monitor_mem_client->rpc_tx_vtbl.free(monitor_mem_client, caprep2, base, bits, &status);
     if (err_is_fail(err)) {
         return err;
     }
     return status;
 }
-
index 6eebca9..4453050 100644 (file)
@@ -33,7 +33,7 @@
 #include <dev/ht_config_dev.h>
 #include "pci_debug.h"
 
-#include <if/acpi_rpcclient_defs.h>
+#include <if/acpi_defs.h>
 
 #define BAR_PROBE       0xffffffff
 
@@ -158,7 +158,7 @@ static errval_t alloc_device_bar(uint8_t idx,
                                  pciaddr_t high,
                                  pcisize_t size)
 {
-    struct acpi_rpc_client* acl = get_acpi_rpc_client();
+    struct acpi_binding* acl = get_acpi_binding();
 
     struct device_caps *c = &dev_caps[bus][dev][fun][idx];
     errval_t err;
@@ -184,7 +184,7 @@ static errval_t alloc_device_bar(uint8_t idx,
         errval_t error_code;
         err = slot_alloc(&c->phys_cap[i]);
         assert(err_is_ok(err));
-        err = acl->vtbl.mm_alloc_range_proxy(acl, bits, base + i * framesize,
+        err = acl->rpc_tx_vtbl.mm_alloc_range_proxy(acl, bits, base + i * framesize,
                                              base + (i + 1) * framesize,
                                              &c->phys_cap[i], &error_code);
         assert(err_is_ok(err));
@@ -196,7 +196,7 @@ static errval_t alloc_device_bar(uint8_t idx,
             if (err_no(err) == MM_ERR_MISSING_CAPS && bits > PAGE_BITS) {
                 /* try again with smaller page-sized caps */
                 for (int j = 0; j < i; j++) {
-                    err = acl->vtbl.mm_free_proxy(acl, c->phys_cap[i],
+                    err = acl->rpc_tx_vtbl.mm_free_proxy(acl, c->phys_cap[i],
                                                   base + j * framesize, bits,
                                                   &error_code);
                     assert(err_is_ok(err) && err_is_ok(error_code));
@@ -523,9 +523,9 @@ errval_t device_reregister_interrupt(uint8_t coreid, int vector,
     PCI_DEBUG("pci: init_device_handler_irq: init interrupt.\n");
     PCI_DEBUG("pci: irq = %u, core = %hhu, vector = %u\n",
             irq, coreid, vector);
-    struct acpi_rpc_client* cl = get_acpi_rpc_client();
+    struct acpi_binding* cl = get_acpi_binding();
     errval_t ret_error;
-    err = cl->vtbl.enable_and_route_interrupt(cl, irq, coreid, vector, &ret_error);
+    err = cl->rpc_tx_vtbl.enable_and_route_interrupt(cl, irq, coreid, vector, &ret_error);
     assert(err_is_ok(err));
     assert(err_is_ok(ret_error)); // FIXME
     //        printf("IRQ for this device is %d\n", irq);
@@ -680,14 +680,14 @@ static void assign_bus_numbers(struct pci_address parentaddr,
                 errval_t error_code;
                 PCI_DEBUG("get irq table for (%hhu,%hhu,%hhu)\n", (*busnum) + 2,
                           addr.device, addr.function);
-                struct acpi_rpc_client* cl = get_acpi_rpc_client();
+                struct acpi_binding* cl = get_acpi_binding();
                 // XXX: why do we have two different types for the same thing?
                 acpi_pci_address_t xaddr = {
                     .bus = addr.bus,
                     .device = addr.device,
                     .function = addr.function,
                 };
-                errval_t err = cl->vtbl.read_irq_table(cl, handle, xaddr, (*busnum) + 2,
+                errval_t err = cl->rpc_tx_vtbl.read_irq_table(cl, handle, xaddr, (*busnum) + 2,
                                         &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");
@@ -1703,9 +1703,9 @@ uint32_t pci_setup_interrupt(uint32_t bus,
         return irq;
     }
 
-    struct acpi_rpc_client* cl = get_acpi_rpc_client();
+    struct acpi_binding* cl = get_acpi_binding();
     errval_t error_code;
-    err = cl->vtbl.set_device_irq(cl, ldev, irq, &error_code);
+    err = cl->rpc_tx_vtbl.set_device_irq(cl, ldev, irq, &error_code);
     assert(err_is_ok(err));
     if (err_is_fail(error_code)) {
         //DEBUG_ERR(error_code, "set device irq failed.");
index c6cf859..0671d1e 100644 (file)
@@ -22,7 +22,7 @@
 #include <barrelfish/sys_debug.h>
 
 #include <if/pci_defs.h>
-#include <if/acpi_rpcclient_defs.h>
+#include <if/acpi_defs.h>
 
 #include <acpi_client/acpi_client.h>
 #include <mm/mm.h>
@@ -137,9 +137,9 @@ static void init_legacy_device_handler(struct pci_binding *b,
     /* determine IOAPIC INTI for given GSI and map to core */
     if (vector != (uint32_t)-1) {
 
-        struct acpi_rpc_client* cl = get_acpi_rpc_client();
+        struct acpi_binding* cl = get_acpi_binding();
         errval_t ret_error;
-        e = cl->vtbl.enable_and_route_interrupt(cl, irq, coreid, vector, &ret_error);
+        e = cl->rpc_tx_vtbl.enable_and_route_interrupt(cl, irq, coreid, vector, &ret_error);
         assert(err_is_ok(e));
         if (err_is_fail(ret_error)) {
             DEBUG_ERR(e, "failed to route interrupt %d -> %d\n", irq, vector);
index 737dad0..ab9779d 100644 (file)
@@ -19,7 +19,7 @@
 #include <pci/confspace/pci_confspace.h>
 #include <acpi_client/acpi_client.h>
 #include <skb/skb.h>
-#include <if/acpi_rpcclient_defs.h>
+#include <if/acpi_defs.h>
 
 #include "pci.h"
 #include "pci_debug.h"
@@ -32,8 +32,8 @@ errval_t pcie_setup_confspace(void) {
     uint8_t sbus;
     uint8_t ebus;
 
-    struct acpi_rpc_client* cl = get_acpi_rpc_client();
-    cl->vtbl.get_pcie_confspace(cl, &err, &address, &segment, &sbus, &ebus);
+    struct acpi_binding* cl = get_acpi_binding();
+    cl->rpc_tx_vtbl.get_pcie_confspace(cl, &err, &address, &segment, &sbus, &ebus);
     if (err_is_ok(err)) {
 
         size_t region_pages = (ebus + 1 - sbus) << 8;
@@ -41,13 +41,13 @@ errval_t pcie_setup_confspace(void) {
         uint8_t region_bits = log2ceil(region_bytes);
 
         struct capref pcie_cap;
-        struct acpi_rpc_client* acl = get_acpi_rpc_client();
+        struct acpi_binding* acl = get_acpi_binding();
         errval_t error_code;
         err = slot_alloc(&pcie_cap);
         if (err_is_fail(err)) {
             return err;
         }
-        err = acl->vtbl.mm_alloc_range_proxy(acl, region_bits, address,
+        err = acl->rpc_tx_vtbl.mm_alloc_range_proxy(acl, region_bits, address,
                 address + (1UL << region_bits), &pcie_cap, &error_code);
         if (err_is_fail(err)) {
             return err;
index ce7909f..a540f18 100644 (file)
@@ -19,7 +19,7 @@
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/nameservice_client.h>
 
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 
 #include <mm/mm.h>
 #include <octopus/init.h>
@@ -36,7 +36,7 @@ static errval_t init_io_ports(void)
 {
     errval_t err;
 
-    struct monitor_blocking_rpc_client *cl = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *cl = get_monitor_blocking_binding();
     assert(cl != NULL);
 
     // Request I/O Cap
@@ -44,7 +44,7 @@ static errval_t init_io_ports(void)
     errval_t error_code;
     err = slot_alloc(&requested_caps);
     assert(err_is_ok(err));
-    err = cl->vtbl.get_io_cap(cl, &requested_caps, &error_code);
+    err = cl->rpc_tx_vtbl.get_io_cap(cl, &requested_caps, &error_code);
     assert(err_is_ok(err) && err_is_ok(error_code));
 
     // Copy into correct slot
index a60061b..8565789 100644 (file)
@@ -19,7 +19,7 @@
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/nameservice_client.h>
 #include <if/monitor_defs.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 #include <if/trivfs_defs.h>
 #include <spawndomain/spawndomain.h>
 #include "ramfs.h"
@@ -436,7 +436,7 @@ static errval_t map_bootinfo(struct bootinfo **bootinfo)
 {
     errval_t err, msgerr;
 
-    struct monitor_blocking_rpc_client *cl = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *cl = get_monitor_blocking_binding();
     assert(cl != NULL);
 
     struct capref bootinfo_frame;
@@ -446,7 +446,7 @@ static errval_t map_bootinfo(struct bootinfo **bootinfo)
     if (err_is_fail(err)) {
         return err;
     }
-    msgerr = cl->vtbl.get_bootinfo(cl, &err, &bootinfo_frame, &bootinfo_size);
+    msgerr = cl->rpc_tx_vtbl.get_bootinfo(cl, &err, &bootinfo_frame, &bootinfo_size);
     if (err_is_fail(msgerr)) {
         err = msgerr;
     }
index a345637..7e99f56 100644 (file)
@@ -16,7 +16,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <barrelfish/barrelfish.h>
-#include <if/fb_rpcclient_defs.h>
+#include <if/fb_defs.h>
 #include <if/keyboard_defs.h>
 #include <barrelfish/nameservice_client.h>
 #include <vfs/vfs.h>
@@ -24,7 +24,7 @@
 
 #include "slideshow.h"
 
-static struct fb_rpc_client fb_client;
+static struct fb_binding *fb_client;
 static struct keyboard_binding *kb_client;
 
 static char *vidmem;    /// Pointer to video memory
@@ -36,7 +36,7 @@ static char fontbackup[65536];
 
 void wait_for_vsync(void)
 {
-    errval_t err = fb_client.vtbl.vsync(&fb_client);
+    errval_t err = fb_client->rpc_tx_vtbl.vsync(fb_client);
     assert(err_is_ok(err));
 }
 
@@ -47,7 +47,7 @@ void quit(void)
     // Restore font backup
     memcpy(vidmem, fontbackup, 65536);
 
-    err = fb_client.vtbl.set_vesamode(&fb_client, origmode, origlinear,
+    err = fb_client->rpc_tx_vtbl.set_vesamode(fb_client, origmode, origlinear,
                                       true, &ret);
     assert(err_is_ok(err));
     assert(err_is_ok(ret));
@@ -70,10 +70,8 @@ static void fb_connected_callback(void *st, errval_t err, struct fb_binding *b)
 {
     assert(err_is_ok(err));
 
-    err = fb_rpc_client_init(&fb_client, b);
-    if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "error in mem_rpc_client_init");
-    }
+    fb_client = b;
+    fb_rpc_client_init(fb_client);
 }
 
 static void start_keyboard_client(void)
@@ -240,19 +238,19 @@ int main(int argc, char *argv[])
     load_slides(argv[4]);
 
     // Get current video mode
-    err = fb_client.vtbl.get_vesamode(&fb_client, &origmode, &origlinear, &ret);
+    err = fb_client->rpc_tx_vtbl.get_vesamode(fb_client, &origmode, &origlinear, &ret);
     assert(err_is_ok(err));
     assert(err_is_ok(ret));
 
     // Set videomode
-    err = fb_client.vtbl.set_videomode(&fb_client, xres, yres, bpp, &ret);
+    err = fb_client->rpc_tx_vtbl.set_videomode(fb_client, xres, yres, bpp, &ret);
     assert(err_is_ok(err));
     assert(err_is_ok(ret));
 
     // Get and map framebuffer
     struct capref fbcap;
     uint32_t fboffset;
-    err = fb_client.vtbl.get_framebuffer(&fb_client, &ret, &fbcap, &fboffset);
+    err = fb_client->rpc_tx_vtbl.get_framebuffer(fb_client, &ret, &fbcap, &fboffset);
     assert(err_is_ok(err));
     assert(err_is_ok(ret));
 
index e73ef39..7f1e8dc 100644 (file)
@@ -22,7 +22,7 @@
 #include <vfs/vfs_path.h>
 #include <dist/barrier.h>
 #include <if/spawn_defs.h>
-#include <if/monitor_blocking_rpcclient_defs.h>
+#include <if/monitor_blocking_defs.h>
 #include <barrelfish/dispatcher_arch.h>
 #include <barrelfish/invocations_arch.h>
 
@@ -101,13 +101,13 @@ static errval_t spawn(const char *path, char *const argv[], const char *argbuf,
     free(image);
 
     /* request connection from monitor */
-    struct monitor_blocking_rpc_client *mrpc = get_monitor_blocking_rpc_client();
+    struct monitor_blocking_binding *mrpc = get_monitor_blocking_binding();
     struct capref monep;
     err = slot_alloc(&monep);
     if (err_is_fail(err)) {
         return err_push(err, SPAWN_ERR_MONEP_SLOT_ALLOC);
     }
-    err = mrpc->vtbl.alloc_monitor_ep(mrpc, &msgerr, &monep);
+    err = mrpc->rpc_tx_vtbl.alloc_monitor_ep(mrpc, &msgerr, &monep);
     if (err_is_fail(err)) {
         return err_push(err, SPAWN_ERR_MONITOR_CLIENT);
     } else if (err_is_fail(msgerr)) {
index 97b6a07..7190d83 100644 (file)
 #include <barrelfish/waitset.h>
 #include <if/ata_rw28_defs.h>
 #include <if/ata_rw28_ahci_defs.h>
-#include <if/ata_rw28_rpcclient_defs.h>
+#include <if/ata_rw28_defs.h>
 
 struct ahci_ata_rw28_binding ahci_ata_rw28_binding;
-struct ata_rw28_rpc_client ata_rw28_rpc;
 struct ata_rw28_binding *ata_rw28_binding = NULL;
 struct ahci_binding *ahci_binding = NULL;
 volatile errval_t bind_err = SYS_ERR_OK;
@@ -40,7 +39,7 @@ static void write_and_check_32(uint32_t pat, size_t start_lba, size_t block_size
 
     printf("writing data\n");
     errval_t status;
-    err = ata_rw28_rpc.vtbl.write_dma(&ata_rw28_rpc, buf, bytes, start_lba, &status);
+    err = ata_rw28_binding->rpc_tx_vtbl.write_dma(ata_rw28_binding, buf, bytes, start_lba, &status);
     if (err_is_fail(err))
         USER_PANIC_ERR(err, "write_dma rpc");
     if (err_is_fail(status))
@@ -49,7 +48,7 @@ static void write_and_check_32(uint32_t pat, size_t start_lba, size_t block_size
 
     printf("reading data\n");
     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);
+    err = ata_rw28_binding->rpc_tx_vtbl.read_dma(ata_rw28_binding, bytes, start_lba, reply.buffer, &reply.buffer_size);
     if (err_is_fail(err))
         USER_PANIC_ERR(err, "read_dma rpc");
     if (reply.buffer_size != bytes)
@@ -116,10 +115,7 @@ int main(int argc, char **argv)
     ata_rw28_binding = (struct ata_rw28_binding*)&ahci_ata_rw28_binding;
 
     // init RPC client
-    err = ata_rw28_rpc_client_init(&ata_rw28_rpc, ata_rw28_binding);
-    if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "ata_rw28_rpc_client_init");
-    }
+    ata_rw28_rpc_client_init(ata_rw28_binding);
 
     // run tests
     run_tests();
index fa2d9d2..1c7821d 100644 (file)
@@ -4,7 +4,7 @@
 #include <barrelfish/barrelfish.h>
 #include <barrelfish/nameservice_client.h>
 #include <if/mt_waitset_defs.h>
-#include <if/mt_waitset_rpcclient_defs.h>
+#include <if/mt_waitset_defs.h>
 #include <barrelfish/deferred.h>
 #include <barrelfish/inthandler.h>
 #include <bench/bench.h>
@@ -50,9 +50,9 @@ static void show_client_stats(void)
 
 static int client_thread(void * arg)
 {
-    struct mt_waitset_rpc_client *rpc_client;
+    struct mt_waitset_binding *binding;
     errval_t err;
-    rpc_client = arg;
+    binding = arg;
     int i, j, k, l;
     uint64_t payload[512];
     uint64_t result[512];
@@ -73,7 +73,7 @@ static int client_thread(void * arg)
 
         for (i = 0; i < j; i++)
             payload[i] = i2 + i;
-        err = rpc_client->vtbl.rpc_method(rpc_client, i2, (uint8_t *)payload, 8 * j, i1, &o1, (uint8_t *)result, &result_size, &o2);
+        err = binding->rpc_tx_vtbl.rpc_method(binding, i2, (uint8_t *)payload, 8 * j, i1, &o1, (uint8_t *)result, &result_size, &o2);
 
         assert(err == SYS_ERR_OK);
         l = 0;
@@ -101,7 +101,7 @@ static int client_thread(void * arg)
         disp_enable(handle);
         // all threads have finished, we're done, inform the server
         payload[0] = mmm;
-        err = rpc_client->vtbl.rpc_method(rpc_client, mmm, (uint8_t *)payload, 8, 65536, &o1, (uint8_t *)result, &result_size, &o2);
+        err = binding->rpc_tx_vtbl.rpc_method(binding, mmm, (uint8_t *)payload, 8, 65536, &o1, (uint8_t *)result, &result_size, &o2);
         show_stats();
     } else
         disp_enable(handle);
@@ -110,16 +110,14 @@ static int client_thread(void * arg)
 
 static void bind_cb(void *st, errval_t err, struct mt_waitset_binding *b)
 {
-    struct mt_waitset_rpc_client *rpc_client;
     int i = (long int)st;
 
-    rpc_client = malloc(sizeof(struct mt_waitset_rpc_client));
-    mt_waitset_rpc_client_init(rpc_client, b);
+    mt_waitset_rpc_client_init(b);
 
     client_counter = client_threads;
     for (i = 1; i < client_threads; i++)
-        thread_create(client_thread, rpc_client);
-    client_thread(rpc_client);
+        thread_create(client_thread, b);
+    client_thread(b);
 }
 
 static void start_client(void)
index 27afb96..f756c97 100644 (file)
@@ -17,7 +17,7 @@
 #include <barrelfish/nameservice_client.h>
 
 #include <if/test_rpc_cap_defs.h>
-#include <if/test_rpc_cap_rpcclient_defs.h>
+#include <if/test_rpc_cap_defs.h>
 
 static const char *my_service_name = "rpc_cap_test";
 uint8_t is_server = 0x0;
@@ -112,12 +112,12 @@ static struct test_rpc_cap_rx_vtbl rx_vtbl = {
 
 /* ------------------------------ CLIENT ------------------------------ */
 
-static struct test_rpc_cap_rpc_client rpc_client;
+static struct test_rpc_cap_binding rpc_client;
 
 static void client_call_test_1(void){
     uint32_t res=0;
     errval_t err;
-    err = rpc_client.vtbl.echo(&rpc_client, client_id, &res);
+    err = rpc_client->rpc_tx_vtbl.echo(&rpc_client, client_id, &res);
     if(err_is_fail(err)){
         my_debug_printf("Error in rpc call (1)\n");
     } else if(res != client_id) {
@@ -134,7 +134,7 @@ static void client_call_test_2(void){
     err = frame_alloc(&my_frame, BASE_PAGE_SIZE, NULL);
     assert(err_is_ok(err));
 
-    err = rpc_client.vtbl.send_cap_one(&rpc_client, my_frame, &msg_err);
+    err = rpc_client->rpc_tx_vtbl.send_cap_one(&rpc_client, my_frame, &msg_err);
     if(err_is_fail(err)){
         USER_PANIC_ERR(err, "Error in rpc call (2)\n");
     } else if(err_is_fail(msg_err)) {
@@ -165,7 +165,7 @@ static void client_call_test_3(int i){
 
     my_debug_printf("Calling send_cap_two: %s\n", buf);
 
-    err = rpc_client.vtbl.send_cap_two(&rpc_client, frame1, frame2, &msg_err);
+    err = rpc_client->rpc_tx_vtbl.send_cap_two(&rpc_client, frame1, frame2, &msg_err);
     if(err_is_fail(err)){
         USER_PANIC_ERR(err, "Error in rpc call (3)\n");
     } else if(err_is_fail(msg_err)) {
@@ -185,7 +185,7 @@ static void bind_cb(void *st,
 
     my_debug_printf("client: bound!\n");
 
-    test_rpc_cap_rpc_client_init(&rpc_client, b);
+    test_rpc_cap_binding_init(&rpc_client, b);
 
     client_call_test_1();
     client_call_test_2();