git.barrelfish.org Git - barrelfish/blob - if/intermon.if

   1 /*
   2  * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
   3  * All rights reserved.
   4  *
   5  * This file is distributed under the terms in the attached LICENSE file.
   6  * If you do not find this file, copies can be found by writing to:
   7  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
   8  */
   9
  10 interface intermon "The Interface between monitors" {
  11
  12     /* XXX Aliases for base system types */
  13     alias coreid_t uint8;
  14     alias chanid_t uint32;
  15
  16     /* Types which we may need to change at some point, especially
  17        on a heterogeneous platform, or 32-bit only platform */
  18     alias con_id_t uint64;
  19     alias mon_id_t uint64;
  20     alias state_id_t uint64;
  21     alias vci_t uint64;
  22
  23     alias capid_t uint32;
  24     alias capaddr_t uint32;
  25     alias capbits_t uint8;
  26     alias capslot_t uint32;
  27     alias capop_st uint64;
  28
  29     /* XXX depends on MAX_COREID and definition of coremask_t in types.h */
  30     typedef uint64 coremask[4];
  31
  32     /* Struct to marshal caps between cores */
  33     typedef struct {
  34         uint64 w0;
  35         uint64 w1;
  36         uint64 w2;
  37         uint64 w3;
  38     } caprep;
  39
  40     typedef struct {
  41         capaddr_t cnptr;
  42         capbits_t cnbits;
  43         capslot_t slot;
  44     } captx;
  45
  46     message spawnd_image_request();
  47     message spawnd_image_reply(genpaddr base, uint32 bytes);
  48
  49     message trace_caps_request();
  50     message trace_caps_reply(caprep cap);
  51
  52     message mem_serv_iref_request();
  53     message mem_serv_iref_reply(iref iref);
  54
  55     message ramfs_serv_iref_request();
  56     message ramfs_serv_iref_reply(iref iref);
  57
  58     message name_serv_iref_request();
  59     message name_serv_iref_reply(iref iref);
  60
  61     message monitor_mem_iref_request();
  62     message monitor_mem_iref_reply(iref iref);
  63
  64     /**
  65      * New monitor communication set-up.
  66      *  1. capops_ready (new monitor -> bsp)
  67      *  2. monitor_initialized (new monitor -> bsp)
  68      *  3. new_monitor_nofity (monitor.0 -> <all available monitors>)
  69      *  4. bind_monitor_proxy (<all available monitors> -> monitor.0)
  70      *  5. bind_monitor_request (monitor.0 -> new monitor)
  71      *  6. bind_monitor_reply (new monitor -> monitor.0)
  72      */
  73     message capops_ready();
  74     message monitor_initialized();
  75     message new_monitor_notify(coreid_t core_id);
  76     message bind_monitor_proxy(coreid_t dst_core_id, caprep cap);
  77     call bind_monitor_request(coreid_t core_id, caprep cap);
  78     response bind_monitor_reply(errval err);
  79
  80     message bind_monitor_request_scc(coreid_t core_id,
  81                                      caprep cap,
  82                                      chanid_t chan_id,
  83                                      coreid_t from_core_id);
  84     message bind_monitor_reply_scc(errval err,
  85                                    chanid_t chan_id,
  86                                    coreid_t core_id);
  87     message bind_monitor_proxy_scc(coreid_t dst_core_id,
  88                                    caprep cap,
  89                                    chanid_t chan_id,
  90                                    coreid_t core_id);
  91     message bind_ump_request(iref iref,
  92                              mon_id_t mon_id,
  93                              uint32 channel_length_in,
  94                              uint32 channel_length_out,
  95                              genpaddr framebase,
  96                              uint8 framebits,
  97                              caprep notify);
  98     message bind_ump_reply(con_id_t con_id,
  99                            mon_id_t mon_id,
 100                            errval err,
 101                            caprep notify);
 102
 103     message cap_send_request(con_id_t con_id,
 104                              capid_t capid,
 105                              captx cap);
 106
 107     message span_domain_request(state_id_t state_id,
 108                                 genpaddr vnodebase,
 109                                 genpaddr framebase,
 110                                 uint8      framebits);
 111     message span_domain_reply(state_id_t state_id, errval err);
 112
 113     // Resource control
 114     message rsrc_join(rsrcid id, coreid_t coreid);
 115     message rsrc_join_complete(rsrcid id);
 116     message rsrc_phase_data(rsrcid id, uint32 phase, uint8 data[len]);
 117     message rsrc_timer_sync(uint64 timestamp);
 118     message rsrc_timer_sync_reply(errval err);
 119
 120     // Change to given resource phase.
 121     // timestamp is the time (as the scheduler counts it) when the
 122     // message was sent, so other cores know what to relate
 123     // relative timestamps to.
 124     message rsrc_phase(rsrcid id, uint32 phase, uint64 timestamp);
 125
 126     /* Multi-hop interconnect driver */
 127
 128     // request portion of routing table from another monitor
 129     call multihop_routing_table_request(coreid source_coreid);
 130     response multihop_routing_table_response(errval err,
 131             coreid source_coreid,
 132             coreid max_coreid,
 133             coreid to[len]);
 134
 135     // grow the routing table to a set of desination cores, via a given forwarder
 136     message multihop_routing_table_grow(coreid forwarder, coreid destinations[len]);
 137
 138     // set up a new multihop virtual circuit
 139     message bind_multihop_intermon_request(iref iref, vci_t sender_vci,
 140                                            coreid core_id);
 141     message bind_multihop_intermon_reply(vci_t receiver_vci, vci_t sender_vci,
 142                                          errval err);
 143
 144     message multihop_message(vci_t vci, uint8 direction, uint8 flags, uint32 ack,
 145                              uint8 payload[size]);
 146     message multihop_cap_send(vci_t vci, uint8 direction, capid_t capid, errval err,
 147                               caprep cap, bool null_cap);
 148
 149     // cap operation messages
 150     message capops_request_copy(coreid dest, caprep cap, capop_st st);
 151     message capops_recv_copy(caprep cap, uint8 owner_relations, capop_st st);
 152     message capops_recv_copy_result(errval status, capaddr_t cap, capbits_t bits, capslot_t slot, capop_st st);
 153
 154     message capops_move_request(caprep cap, uint8 relations, capop_st st);
 155     message capops_move_result(errval status, capop_st st);
 156     message capops_retrieve_request(caprep cap, capop_st st);
 157     message capops_retrieve_result(errval status, uint8 relations, capop_st st);
 158
 159     message capops_delete_remote(caprep cap, capop_st st);
 160     message capops_delete_remote_result(errval status, capop_st st);
 161
 162     message capops_revoke_mark(caprep cap, capop_st st);
 163     message capops_revoke_ready(capop_st st);
 164     message capops_revoke_commit(capop_st st);
 165     message capops_revoke_done(capop_st st);
 166
 167     // XXX: uint32 for bits? -MN
 168     message capops_request_retype(caprep src, uint32 desttype, uint32 destbits, capop_st st);
 169     message capops_retype_response(errval status, capop_st st);
 170
 171     // ownership / relation messages
 172     message capops_update_owner(caprep cap, capop_st st);
 173     message capops_owner_updated(capop_st st);
 174
 175     message capops_find_cap(caprep cap, capop_st st);
 176     message capops_find_cap_result(errval status, capop_st st);
 177
 178     message capops_find_descendants(caprep cap, capop_st st);
 179     message capops_find_descendants_result(errval status, capop_st st);
 180
 181     /* Tracing Framework */
 182
 183     // Notify a core that it should prepare the tracing state. The origin core
 184     // is the one who initiated the preparation request.
 185     message trace_prepare(coreid origin_core);
 186
 187     // Notify the core who initiated the preparation that it is finished.
 188     message trace_prepare_finished();
 189
 190     // Notify core 0 that you want to make a time measurement (Network Time
 191     // Protocol). The origin core is the one who initiated the trace preparation.
 192     call trace_measure(coreid_t origin_core, uint64 t0);
 193
 194     // The response to a measurement call from a core.
 195     response trace_measure_ack(coreid origin_core, uint64 t0, uint64 t1, uint64 t2);
 196
 197     /* bfscope - the tracing server */
 198
 199     // Forward a trace-flush command to the monitor on the core on which bfscope
 200     // is running.
 201     call bfscope_flush_send_forward(iref iref);
 202
 203     // This message is sent, once bfscope has finished flushing.
 204     response bfscope_flush_ack_forward();
 205
 206     call give_kcb_request(caprep kcb);
 207     response give_kcb_response(errval err);
 208
 209     call forward_kcb_rm_request(uint64 kcb_base);
 210     call forward_kcb_rm_response(errval err);
 211 };