Interface definitions: Changing calls/responses into messages.
authorAdam Turowski <adam.turowski@inf.ethz.ch>
Fri, 1 Jul 2016 07:20:06 +0000 (09:20 +0200)
committerAdam Turowski <adam.turowski@inf.ethz.ch>
Fri, 1 Jul 2016 07:20:06 +0000 (09:20 +0200)
Signed-off-by: Adam Turowski <adam.turowski@inf.ethz.ch>

16 files changed:
if/bfs.if
if/e10k.if
if/intermon.if
if/keyboard.if
if/lpc_kbd.if
if/monitor.if
if/mouse.if
if/net_queue_manager.if
if/net_soft_filters.if
if/ping_pong.if
if/serial.if
if/timer.if
if/xcorecap.if
if/xcorecapbench.if
if/xmplcr.if
if/xmplthc.if

index b959a73..491caf4 100644 (file)
--- a/if/bfs.if
+++ b/if/bfs.if
-/*\r
- * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.\r
- * All rights reserved.\r
- *\r
- * This file is distributed under the terms in the attached LICENSE file.\r
- * If you do not find this file, copies can be found by writing to:\r
- * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.\r
- */\r
-\r
-\r
-interface bfs "BFS interface" {\r
-\r
-/* -----------------------------------------------\r
- * Typedefs and structs\r
- */\r
-\r
-typedef uint64 object_key;\r
-typedef uint64 chunk_id;\r
-\r
-/* From BFS.h */\r
-typedef enum\r
-{\r
-       INVALID_OBJ,\r
-       BFS_FILE,\r
-       BFS_DIR\r
-}  OBJECT_TYPE;\r
-\r
-/* From servers.h */\r
-typedef enum {\r
-       INVALID_SERVER,\r
-       DIR_SERVER,\r
-       STORAGE_SERVER,\r
-       CLIENT,\r
-       NAME_SERVER\r
-} SERVER_TYPE;\r
-\r
-/* From DS.h */\r
-/*\r
- * Object open permissions.\r
- */\r
-typedef enum {\r
-       READ_ONLY,\r
-       WRITE_ONLY,\r
-       READ_WRITE\r
-} OBJECT_ACCESS_PERM;\r
-\r
-/* -----------------------------------------------\r
- * Storage Server\r
- * -----------------------------------------------\r
- *\r
- * Overview\r
- * --------\r
- * The storage server implements a log-structured data store,\r
- * from which data can be read or written in terms of chunks.\r
- * A chunk is a block of data of a specific size with a \r
- * unique ID.  A client or directory server can read or \r
- * write chunks from the storage by passing the ID of the chunk.\r
- */\r
-\r
-/* XXX For now we pass the frame cap every time.\r
-   Not efficient but simple. */\r
-rpc ss_read_chunk(\r
-    in chunk_id cid,\r
-    in uint32   coffset,\r
-    in uint32   size,\r
-    in cap      frame,\r
-    in uint32   foffset);\r
-\r
-rpc ss_write_chunk(\r
-    in chunk_id cid,\r
-    in uint32   coffset,\r
-    in uint32   size,\r
-    in cap      frame,\r
-    in uint32   foffset);\r
-\r
-rpc ss_delete_chunk(\r
-    in chunk_id cid\r
-);\r
-\r
-message ss_shutdown();\r
-\r
-/* -----------------------------------------------\r
- * Name Server\r
- * -----------------------------------------------\r
- *\r
- * Overview\r
- * --------\r
- * The name server implements both a name service and a distributed\r
- * lock service.  It keeps track of all the other servers running\r
- * in the system, and manages the locking of common state for all\r
- * instances the directory server.\r
- */\r
-\r
-/* Dir and storage servers must register */\r
-message ns_register_server(uint32 server_type, uint64 server_guid);\r
-\r
-/* Servers can request list of currently registered servers */\r
-/* nb generation increments when the list changes. */\r
-rpc ns_query_registered_servers(in uint32 server_ordinal,\r
-    out uint32 generation,\r
-    out SERVER_TYPE server_type,\r
-    out uint64 server_guid);\r
-\r
-/* Lock/unlock invocations would be more naturally expressed\r
- * as call/response with separate failure/success response\r
- * messages.  Use RPC here just to simplify the async version.\r
- */\r
-rpc ns_lock(/*in object_key objects*/\r
-    in object_key object\r
-    , out errval err);\r
-\r
-rpc ns_unlock(in object_key object, out errval err);\r
-\r
-/* -----------------------------------------------\r
- * Directory Server\r
- * -----------------------------------------------\r
- *\r
- * Overview\r
- * --------\r
- * The directory server manages the metadata of the file\r
- * system on the storage servers and implements the file\r
- * system interface for the clients.  It also maintains\r
- * a simple data cache of file chunks.\r
- *\r
- * Multiple directory servers running at the same time\r
- * will share common metadata structures and invoke\r
- * locking operations on the name server as required.\r
- */\r
-\r
-/* Create a file or directory.\r
- * Returns the key of the object that was created.\r
- */\r
-rpc ds_create(\r
-    in  OBJECT_TYPE         ob_type,\r
-    in  OBJECT_ACCESS_PERM  ob_perm,\r
-    in  string              ob_name,\r
-    in  uint64              client_id,\r
-    out object_key          object);\r
-\r
-rpc ds_open(        \r
-    in  OBJECT_TYPE         ob_type,\r
-    in  OBJECT_ACCESS_PERM  ob_perm,\r
-    in  string              ob_name,\r
-    in  uint64             client_id,\r
-    out object_key          object);\r
-\r
-message ds_shutdown();\r
-\r
-/* From name server. */\r
-message ds_invalidate_cache(object_key object);\r
-\r
-/* -----------------------------------------------\r
- * State Maintenance\r
- * -----------------------------------------------\r
- * XXX TO DO: make the maintenance of replicated state\r
- * be implicit via a consensus protocol.\r
- * \r
- * Name server can broadcast current list of servers\r
- * to all SS and DS servers in the system.  This is a\r
- * one-way notification.\r
- */\r
-message ss_notify_registered_servers(\r
-       uint64   server);\r
-message ds_notify_registered_servers(\r
-       uint64   server);\r
-\r
-};\r
+/*
+ * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
+ * All rights reserved.
+ *
+ * This file is distributed under the terms in the attached LICENSE file.
+ * If you do not find this file, copies can be found by writing to:
+ * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
+ */
+
+
+interface bfs "BFS interface" {
+
+/* -----------------------------------------------
+ * Typedefs and structs
+ */
+
+typedef uint64 object_key;
+typedef uint64 chunk_id;
+
+/* From BFS.h */
+typedef enum
+{
+       INVALID_OBJ,
+       BFS_FILE,
+       BFS_DIR
+}  OBJECT_TYPE;
+
+/* From servers.h */
+typedef enum {
+       INVALID_SERVER,
+       DIR_SERVER,
+       STORAGE_SERVER,
+       CLIENT,
+       NAME_SERVER
+} SERVER_TYPE;
+
+/* From DS.h */
+/*
+ * Object open permissions.
+ */
+typedef enum {
+       READ_ONLY,
+       WRITE_ONLY,
+       READ_WRITE
+} OBJECT_ACCESS_PERM;
+
+/* -----------------------------------------------
+ * Storage Server
+ * -----------------------------------------------
+ *
+ * Overview
+ * --------
+ * The storage server implements a log-structured data store,
+ * from which data can be read or written in terms of chunks.
+ * A chunk is a block of data of a specific size with a 
+ * unique ID.  A client or directory server can read or 
+ * write chunks from the storage by passing the ID of the chunk.
+ */
+
+/* XXX For now we pass the frame cap every time.
+   Not efficient but simple. */
+rpc ss_read_chunk(
+    in chunk_id cid,
+    in uint32   coffset,
+    in uint32   size,
+    in cap      frame,
+    in uint32   foffset);
+
+rpc ss_write_chunk(
+    in chunk_id cid,
+    in uint32   coffset,
+    in uint32   size,
+    in cap      frame,
+    in uint32   foffset);
+
+rpc ss_delete_chunk(
+    in chunk_id cid
+);
+
+message ss_shutdown();
+
+/* -----------------------------------------------
+ * Name Server
+ * -----------------------------------------------
+ *
+ * Overview
+ * --------
+ * The name server implements both a name service and a distributed
+ * lock service.  It keeps track of all the other servers running
+ * in the system, and manages the locking of common state for all
+ * instances the directory server.
+ */
+
+/* Dir and storage servers must register */
+message ns_register_server(uint32 server_type, uint64 server_guid);
+
+/* Servers can request list of currently registered servers */
+/* nb generation increments when the list changes. */
+rpc ns_query_registered_servers(in uint32 server_ordinal,
+    out uint32 generation,
+    out SERVER_TYPE server_type,
+    out uint64 server_guid);
+
+/* Lock/unlock invocations would be more naturally expressed
+ * as call/response with separate failure/success response
+ * messages.  Use RPC here just to simplify the async version.
+ */
+rpc ns_lock(/*in object_key objects*/
+    in object_key object
+    , out errval err);
+
+rpc ns_unlock(in object_key object, out errval err);
+
+/* -----------------------------------------------
+ * Directory Server
+ * -----------------------------------------------
+ *
+ * Overview
+ * --------
+ * The directory server manages the metadata of the file
+ * system on the storage servers and implements the file
+ * system interface for the clients.  It also maintains
+ * a simple data cache of file chunks.
+ *
+ * Multiple directory servers running at the same time
+ * will share common metadata structures and invoke
+ * locking operations on the name server as required.
+ */
+
+/* Create a file or directory.
+ * Returns the key of the object that was created.
+ */
+rpc ds_create(
+    in  OBJECT_TYPE         ob_type,
+    in  OBJECT_ACCESS_PERM  ob_perm,
+    in  string              ob_name,
+    in  uint64              client_id,
+    out object_key          object);
+
+rpc ds_open(        
+    in  OBJECT_TYPE         ob_type,
+    in  OBJECT_ACCESS_PERM  ob_perm,
+    in  string              ob_name,
+    in  uint64             client_id,
+    out object_key          object);
+
+message ds_shutdown();
+
+/* From name server. */
+message ds_invalidate_cache(object_key object);
+
+/* -----------------------------------------------
+ * State Maintenance
+ * -----------------------------------------------
+ * XXX TO DO: make the maintenance of replicated state
+ * be implicit via a consensus protocol.
+ * 
+ * Name server can broadcast current list of servers
+ * to all SS and DS servers in the system.  This is a
+ * one-way notification.
+ */
+message ss_notify_registered_servers(
+       uint64   server);
+message ds_notify_registered_servers(
+       uint64   server);
+
+};
index e767c76..0be8352 100644 (file)
@@ -16,12 +16,12 @@ interface e10k "e10k queue management interface" {
     typedef enum {PORT_TCP, PORT_UDP} port_type;
     alias qid uint8;
 
-    call request_device_info();
-    response queue_init_data(cap registers, uint64 macaddr);
+    message request_device_info();
+    message queue_init_data(cap registers, uint64 macaddr);
 
     /* Upon initialization the queue driver registers its memory with
        the device manager. */
-    call register_queue_memory(qid    id,
+    message register_queue_memory(qid    id,
                                cap    tx,
                                cap    txhwb,
                                cap    rx,
@@ -34,37 +34,37 @@ interface e10k "e10k queue management interface" {
                               uint64 tx_va,
                               uint64 rx_va,
                               uint64 txhwb_va);
-    response queue_memory_registered();
+    message queue_memory_registered();
 
     /* Modify interrupt rate for a particular queue */
-    call set_interrupt_rate(qid id, uint16 rate);
+    message set_interrupt_rate(qid id, uint16 rate);
 
     /* FIXME: this is not technically a response, but a request by the server,
               hope this works anyway... I'd like the dev mgr to be server. */
     /* Tells queue driver to write the tail pointers for the rx and
        tx queues after initialization or reset */
-    response write_queue_tails();
+    message write_queue_tails();
 
     /* Called by queue manager if it is done, and is going to terminate. */
-    call terminate_queue(qid id);
-    response queue_terminated();
+    message terminate_queue(qid id);
+    message queue_terminated();
 
     /*****************************************************
      * Filter management (used by device  manager library)
      *****************************************************/
 
-    call register_port_filter(uint64    buf_id_rx,
+    message register_port_filter(uint64    buf_id_rx,
                               uint64    buf_id_tx,
                               qid       queue,
                               port_type type,
                               uint16    port);
-    response filter_registered(uint64    buf_id_rx,
+    message filter_registered(uint64    buf_id_rx,
                                uint64    buf_id_tx,
                                errval err,
                                uint64 filter);
 
-    call unregister_filter(uint64 filter);
-    response filter_unregistered(uint64 filter, errval err);
+    message unregister_filter(uint64 filter);
+    message filter_unregistered(uint64 filter, errval err);
 
                             
 };
index c57bbad..26f7a5f 100644 (file)
@@ -74,8 +74,8 @@ interface intermon "The Interface between monitors" {
     message monitor_initialized();
     message new_monitor_notify(coreid core_id);
     message bind_monitor_proxy(coreid dst_core_id, caprep cap);
-    call bind_monitor_request(coreid core_id, caprep cap);
-    response bind_monitor_reply(errval err);
+    message bind_monitor_request(coreid core_id, caprep cap);
+    message bind_monitor_reply(errval err);
 
     message bind_ump_request(iref iref,
                              mon_id mon_id,
@@ -115,8 +115,8 @@ interface intermon "The Interface between monitors" {
     /* Multi-hop interconnect driver */
 
     // request portion of routing table from another monitor
-    call multihop_routing_table_request(coreid source_coreid);
-    response multihop_routing_table_response(errval err,
+    message multihop_routing_table_request(coreid source_coreid);
+    message multihop_routing_table_response(errval err,
             coreid source_coreid,
             coreid max_coreid,
             coreid to[len]);
@@ -180,23 +180,23 @@ interface intermon "The Interface between monitors" {
 
     // Notify core 0 that you want to make a time measurement (Network Time
     // Protocol). The origin core is the one who initiated the trace preparation.
-    call trace_measure(coreid origin_core, uint64 t0);
+    message trace_measure(coreid origin_core, uint64 t0);
 
     // The response to a measurement call from a core.
-    response trace_measure_ack(coreid origin_core, uint64 t0, uint64 t1, uint64 t2);
+    message trace_measure_ack(coreid origin_core, uint64 t0, uint64 t1, uint64 t2);
 
     /* bfscope - the tracing server */
 
     // Forward a trace-flush command to the monitor on the core on which bfscope
     // is running.
-    call bfscope_flush_send_forward(iref iref);
+    message bfscope_flush_send_forward(iref iref);
 
     // This message is sent, once bfscope has finished flushing.
-    response bfscope_flush_ack_forward();
+    message bfscope_flush_ack_forward();
 
-    call give_kcb_request(caprep kcb);
-    response give_kcb_response(errval err);
+    message give_kcb_request(caprep kcb);
+    message give_kcb_response(errval err);
 
-    call forward_kcb_rm_request(uint64 kcb_base);
-    call forward_kcb_rm_response(errval err);
+    message forward_kcb_rm_request(uint64 kcb_base);
+    message forward_kcb_rm_response(errval err);
 };
index 9c23a99..1df3a39 100644 (file)
@@ -8,5 +8,5 @@
  */
 
 interface keyboard "Keyboard events" {
-    response key_event(uint8 scancode, bool extended);
+    message key_event(uint8 scancode, bool extended);
 };
index f741a10..24fdf43 100644 (file)
@@ -8,7 +8,7 @@
  */
 
 interface keyboard "Keyboard server" {
-    response key_event(uint8 scancode);
+    message key_event(uint8 scancode);
     // dummy call to prevent flounder generating uncompilable stubs
-    call dummy();
+    message dummy();
 };
index 3fbe686..9701902 100644 (file)
@@ -11,22 +11,22 @@ interface monitor "The monitor to client Interface" {
     alias vci uint64;
     alias capid uint32;
 
-    call alloc_iref_request(
+    message alloc_iref_request(
         uintptr service_id);
 
-    response alloc_iref_reply(
+    message alloc_iref_reply(
         uintptr service_id,
         iref iref,
         errval err);
 
     /* TODO: move to monitor_blocking as RPC? */
-    call boot_core_request(uint8 id, cap frame);
-    response boot_core_reply(errval err);
+    message boot_core_request(uint8 id, cap frame);
+    message boot_core_reply(errval err);
 
-    call new_monitor_binding_request(
+    message new_monitor_binding_request(
         uintptr st);
 
-    response new_monitor_binding_reply(
+    message new_monitor_binding_reply(
         errval err,
         cap ep,
         uintptr st);
@@ -82,60 +82,60 @@ interface monitor "The monitor to client Interface" {
         size channel_length_out,
         cap notify);
 
-    call bind_ump_reply_monitor(
+    message bind_ump_reply_monitor(
         uintptr mon_id,
         uintptr conn_id,
         errval err,
         cap notify);
 
-    response bind_ump_reply_client(
+    message bind_ump_reply_client(
         uintptr mon_id,
         uintptr conn_id,
         errval err,
         cap notify);
 
-    call ipi_alloc_notify_request(cap ep, uintptr state);
-    response ipi_alloc_notify_reply(uintptr state, cap notify, errval err);
+    message ipi_alloc_notify_request(cap ep, uintptr state);
+    message ipi_alloc_notify_reply(uintptr state, cap notify, errval err);
 
-    call get_mem_iref_request();
-    response get_mem_iref_reply(iref iref);
+    message get_mem_iref_request();
+    message get_mem_iref_reply(iref iref);
 
-    call get_name_iref_request(uintptr st);
-    response get_name_iref_reply(iref iref, uintptr st);
+    message get_name_iref_request(uintptr st);
+    message get_name_iref_reply(iref iref, uintptr st);
 
-    call get_ramfs_iref_request(uintptr st);
-    response get_ramfs_iref_reply(iref iref, uintptr st);
-    call set_ramfs_iref_request(iref iref);
+    message get_ramfs_iref_request(uintptr st);
+    message get_ramfs_iref_reply(iref iref, uintptr st);
+    message set_ramfs_iref_request(iref iref);
 
-    call set_mem_iref_request(iref iref);
+    message set_mem_iref_request(iref iref);
 
-    call set_name_iref_request(iref iref);
-    response set_name_iref_reply(errval err);
+    message set_name_iref_request(iref iref);
+    message set_name_iref_reply(errval err);
 
-    call get_monitor_rpc_iref_request(uintptr st);
-    response get_monitor_rpc_iref_reply(iref iref, uintptr st);
+    message get_monitor_rpc_iref_request(uintptr st);
+    message get_monitor_rpc_iref_reply(iref iref, uintptr st);
 
     /* for UMP/BMP cap tx */
-    call cap_send_request(
+    message cap_send_request(
         uintptr mon_id,
         cap cap,
         capid capid);
-    call cap_move_request(
+    message cap_move_request(
         uintptr mon_id,
         give_away_cap cap,
         capid capid);
-    response cap_receive_request(
+    message cap_receive_request(
         uintptr conn_id,
         errval err,
         give_away_cap cap,
         capid capid);
 
-    call span_domain_request(
+    message span_domain_request(
         uintptr domain_id,
         uint8 core_id,
         cap vroot,
         cap disp);
-    response span_domain_reply(
+    message span_domain_reply(
         errval err,
         uintptr domain_id);
 
@@ -158,19 +158,19 @@ interface monitor "The monitor to client Interface" {
 
     // Send routing table
     // First message, which describes the set of valid core IDs
-    call multihop_routing_table_new(coreid max_coreid, coreid nentries);
+    message multihop_routing_table_new(coreid max_coreid, coreid nentries);
     // Subsequent messages (repeated) which each contain
     // a portion of the routing table from a single core
-    call multihop_routing_table_set(coreid from, coreid to[len]);
+    message multihop_routing_table_set(coreid from, coreid to[len]);
 
     // Connection set-up between monitor and client
-    call multihop_bind_client_request(iref iref, vci sender_vci);
-    response multihop_bind_client_reply(vci receiver_vci, vci sender_vci,
+    message multihop_bind_client_request(iref iref, vci sender_vci);
+    message multihop_bind_client_reply(vci receiver_vci, vci sender_vci,
                                         errval err);
 
     // Connection set-up between monitor and service
-    call multihop_bind_service_request(uintptr service_id, vci sender_vci);
-    response multihop_bind_service_reply(vci receiver_vci , vci sender_vci,
+    message multihop_bind_service_request(uintptr service_id, vci sender_vci);
+    message multihop_bind_service_reply(vci receiver_vci , vci sender_vci,
                                          errval err);
 
     // user message
@@ -178,7 +178,7 @@ interface monitor "The monitor to client Interface" {
                              uint8 payload[size]);
 
     // cap transfer
-    call multihop_cap_send(vci vci, uint8 direction, errval err, cap cap,
+    message multihop_cap_send(vci vci, uint8 direction, errval err, cap cap,
                            capid capid);
 
     /* Tracing Framework */
@@ -193,10 +193,10 @@ interface monitor "The monitor to client Interface" {
     /* bfscope - the tracing server */
 
     // Send a message to bfscope, to notify that it should flush
-    call bfscope_flush_send(iref iref);
+    message bfscope_flush_send(iref iref);
 
     // Notify the initiatior of the flush request that it has been completed.
-    response bfscope_flush_ack();
+    message bfscope_flush_ack();
 
     message migrate_dispatcher(uintptr domain_id);
 
index 38a9fa2..6019509 100644 (file)
@@ -8,6 +8,6 @@
  */
 
 interface mouse "Mouse events" {
-    response mouse_event(int32 xdelta, int32 ydelta,
+    message mouse_event(int32 xdelta, int32 ydelta,
                          bool left, bool middle, bool right);
 };
index 41d1e62..33e2210 100644 (file)
 interface net_queue_manager "Ethernet hardware RX/TX queue manager" {
     /* antoinek: I think most of the queue id arguments are not needed here */
 
-    call register_buffer(cap buf,
+    message register_buffer(cap buf,
                          cap sp,
                          uint64 queueid,
                          uint64 slots,
                          uint8 role);
-    response new_buffer_id(errval err,
+    message new_buffer_id(errval err,
                          uint64 queueid,
                          uint64 idx);
 
-    call get_mac_address(uint64 queueid);
-    response get_mac_address_response(uint64 queueid, uint64 hwaddr);
+    message get_mac_address(uint64 queueid);
+    message get_mac_address_response(uint64 queueid, uint64 hwaddr);
 
-    call sp_notification_from_app(uint64 queueid, uint64 type,
+    message sp_notification_from_app(uint64 queueid, uint64 type,
                          uint64 ts);
-    response sp_notification_from_driver(uint64 queueid, uint64 type,
+    message sp_notification_from_driver(uint64 queueid, uint64 type,
                          uint64 ts);
 
-    call raw_add_buffer(uint64 offset, uint64 length, uint64 more,
+    message raw_add_buffer(uint64 offset, uint64 length, uint64 more,
                         uint64 flags);
-    response raw_xmit_done(uint64 offset, uint64 length, uint64 more,
+    message raw_xmit_done(uint64 offset, uint64 length, uint64 more,
                            uint64 flags);
 
 
-    call print_statistics(uint64 queueid);
-    call print_cardinfo();
-    call benchmark_control_request(uint64 queueid, uint8 state,
+    message print_statistics(uint64 queueid);
+    message print_cardinfo();
+    message benchmark_control_request(uint64 queueid, uint8 state,
                             uint64 trigger, uint64 cl);
-    response benchmark_control_response(uint64 queueid, uint8 state,
+    message benchmark_control_response(uint64 queueid, uint8 state,
                             uint64 delta, uint64 cl);
 
-    call terminate_queue();
+    message terminate_queue();
 };
 
index 3620235..3a15a35 100644 (file)
@@ -9,49 +9,49 @@
 
 interface net_soft_filters "Software based filter Interface" {
 
-    call register_filter_memory_request(cap mem);
-    response register_filter_memory_response(errval err);
+    message register_filter_memory_request(cap mem);
+    message register_filter_memory_response(errval err);
 
-    call register_filter_request(uint64 id,
+    message register_filter_request(uint64 id,
             uint64 len_rx,
             uint64 len_tx,
             uint64 buffer_id_rx,
             uint64 buffer_id_tx,
             uint64 filter_type,
             uint64 paused);
-    response register_filter_response(uint64 id,
+    message register_filter_response(uint64 id,
             errval err,
             uint64 filter_id,
             uint64 buffer_id_rx,
             uint64 buffer_id_tx,
             uint64 filter_type);
 
-    call re_register_filter_request(uint64 filter_id,
+    message re_register_filter_request(uint64 filter_id,
             uint64 buffer_id_rx,
             uint64 buffer_id_tx);
-    response re_register_filter_response(errval err,
+    message re_register_filter_response(errval err,
             uint64 filter_id,
             uint64 buffer_id_rx,
             uint64 buffer_id_tx);
 
-    call deregister_filter_request(uint64 filter_id);
-    response deregister_filter_response(errval err,
+    message deregister_filter_request(uint64 filter_id);
+    message deregister_filter_response(errval err,
             uint64 filter_id);
 
-    call register_arp_filter_request(uint64 id,
+    message register_arp_filter_request(uint64 id,
             uint64 len_rx,
             uint64 len_tx);
-    response register_arp_filter_response(uint64 id,
+    message register_arp_filter_response(uint64 id,
             errval err);
 
-    call pause(uint64 filter_id, uint64 buffer_id_rx, uint64 buffer_id_tx);
-    response pause_response(uint64 filter_id, errval err);
-    call unpause(uint64 filter_id);
-    response unpause_response(uint64 filter_id, errval err);
+    message pause(uint64 filter_id, uint64 buffer_id_rx, uint64 buffer_id_tx);
+    message pause_response(uint64 filter_id, errval err);
+    message unpause(uint64 filter_id);
+    message unpause_response(uint64 filter_id, errval err);
 
     /* Hack to pass the mac addr info to */
-    call mac_address_request();
-    response mac_address_response(errval err, uint64 macaddr);
+    message mac_address_request();
+    message mac_address_response(errval err, uint64 macaddr);
 };
 
 
index 780defd..4db04fd 100644 (file)
@@ -15,13 +15,13 @@ interface ping_pong "Ping-Pong async example Interface" {
        message rsrc_join_request(uint32 id);
        message rsrc_join_reply();
        message init();
-       call ping(uint64 val);
-       response pong(uint64 val);
+       message ping(uint64 val);
+       message pong(uint64 val);
 
-       call slow_op(uint64 val);
-       response slow_reply(uint64 val);
+       message slow_op(uint64 val);
+       message slow_reply(uint64 val);
 
-        call stop();
+        message stop();
 
         rpc testrpc(in uint64 testin, out uint64 testout);
         rpc testrpc2(in uint64 testin, out uint64 testout);
@@ -35,8 +35,8 @@ interface ping_pong "Ping-Pong async example Interface" {
         // exercise the THC Flounder back-end
 
         message str0(uint32 arg1, string s);
-        call str1(uint32 arg1, string s);
-        response str2(uint32 arg1, string s);
+        message str1(uint32 arg1, string s);
+        message str2(uint32 arg1, string s);
         rpc str3(in uint32 arg1, in string s);
         rpc str4(out uint32 arg1, out string s);
         rpc str5(in uint64 seq_in,
@@ -47,6 +47,6 @@ interface ping_pong "Ping-Pong async example Interface" {
                  out uint32 arg1, out string s);
 
         message arr0(uint32 arg1, char a[l]);
-        call arr1(uint32 arg1, char a[l]);
-        response arr2(uint32 arg1, char a[l]);
+        message arr1(uint32 arg1, char a[l]);
+        message arr2(uint32 arg1, char a[l]);
 };
index 0c70c55..b7aeda6 100644 (file)
@@ -8,7 +8,7 @@
  */
 
 interface serial "Serial characters" {
-    call output(char data[len]);
-    response input(char data[len]);
-    call associate_stdin();
+    message output(char data[len]);
+    message input(char data[len]);
+    message associate_stdin();
 };
index 2be9169..8b21455 100644 (file)
@@ -9,20 +9,20 @@
 
 interface timer "Timer service" {
     // set the one (and only) timeout value (in us) for this client
-    call set_timeout(uint64 timeout);
+    message set_timeout(uint64 timeout);
 
     // add the given increment (in us) to the running timer for this client
-    call add_to_timeout(uint64 increment);
+    message add_to_timeout(uint64 increment);
 
     // cancel the outstanding timeout
-    call cancel_timeout();
+    message cancel_timeout();
 
     // wakeup response when the timer is triggered
-    response wakeup();
+    message wakeup();
 
     // request for the remaining time of the currently-running timer
-    call get_remaining();
+    message get_remaining();
 
     // response containing remaining time of running timer
-    response remaining(uint64 time);
+    message remaining(uint64 time);
 };
index a59c2a8..d33e51e 100644 (file)
@@ -9,10 +9,10 @@
 
 interface xcorecap "Cross core capability test interface" {
 
-    call send_cap(cap cap);
-    call retype_cap();
-    call delete_cap();
-    call revoke_cap();
+    message send_cap(cap cap);
+    message retype_cap();
+    message delete_cap();
+    message revoke_cap();
 
-    response send_done();
-};
\ No newline at end of file
+    message send_done();
+};
index ef15fb4..aa6810b 100644 (file)
@@ -8,9 +8,9 @@
  */
 
 interface xcorecapbench "Cross core capability benchmark interface" {
-    call connect();
-    call start_sending();
-    call start_retyping();
-    call send_cap(cap cap);
-    call barrier_done(uint64 cycles);
-};
\ No newline at end of file
+    message connect();
+    message start_sending();
+    message start_retyping();
+    message send_cap(cap cap);
+    message barrier_done(uint64 cycles);
+};
index 5402691..c016aca 100644 (file)
@@ -12,6 +12,6 @@
  */
 
 interface xmplcr "Example call reply interface" {
-         call mycall(int i);
-         response myresponse(string s);
+    message mycall(int i);
+    message myresponse(string s);
 };
\ No newline at end of file
index 8665f8a..4f6c628 100644 (file)
@@ -12,8 +12,8 @@
  */
 
 interface xmplthc "Example thc interface" {
-         message mymsg(int i);
-         call mycall(int i);
-         response myresponse(string s);
-         rpc myrpc(in int i, out string s);
-};
\ No newline at end of file
+    message mymsg(int i);
+    message mycall(int i);
+    message myresponse(string s);
+    rpc myrpc(in int i, out string s);
+};