ba3bd5c4259993a477106db6949cbeb0ef4ae7d6
[barrelfish] / 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, coreid owner);
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 };