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, Universitaetstrasse 6, CH-8092 Zurich. Attn: Systems Group.
8 */
9
10interface intermon "The Interface between monitors" {
11
12    /* XXX Aliases for base system types */
13    alias coreid uint8;
14    alias chanid 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 uint64;
19    alias mon_id uint64;
20    alias state_id uint64;
21    alias vci uint64;
22
23    alias capid uint32;
24    alias capaddr uint32;
25    alias caplevel uint8;
26    alias capslot 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 cnptr;
42        caplevel cnlevel;
43        capslot 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 core_id);
76    message bind_monitor_proxy(coreid dst_core_id, caprep cap);
77    message bind_monitor_request(coreid core_id, caprep cap);
78    message bind_monitor_reply(errval err);
79
80    message bind_ump_request(iref iref,
81                             mon_id mon_id,
82                             uint32 channel_length_in,
83                             uint32 channel_length_out,
84                             genpaddr framebase,
85                             uint8 framebits,
86                             caprep notify);
87    message bind_ump_reply(con_id con_id,
88                           mon_id mon_id,
89                           errval err,
90                           caprep notify);
91
92    message ump_route_setup_request(con_id conid, mon_id state, coreid core, genpaddr ep, uint16 type);
93    message ump_route_setup_reply(con_id yourconid, con_id myconid, mon_id state, errval err);
94
95
96    message cap_send_request(con_id con_id,
97                             capid capid,
98                             captx cap);
99
100    message span_domain_request(state_id state_id,
101                                genpaddr vnodebase,
102                                genpaddr framebase,
103                                uint64 framebytes);
104    message span_domain_reply(state_id state_id, errval err);
105
106    // Inform the monitor connected to the process manager about the spawnd
107    // that the caller just spawned.
108    message add_spawnd(iref iref);
109
110    // Resource control
111    message rsrc_join(rsrcid id, coreid coreid);
112    message rsrc_join_complete(rsrcid id);
113    message rsrc_phase_data(rsrcid id, uint32 phase, uint8 data[len, 2048]);
114    message rsrc_timer_sync(uint64 timestamp);
115    message rsrc_timer_sync_reply(errval err);
116
117    // Change to given resource phase.
118    // timestamp is the time (as the scheduler counts it) when the
119    // message was sent, so other cores know what to relate
120    // relative timestamps to.
121    message rsrc_phase(rsrcid id, uint32 phase, uint64 timestamp);
122
123    /* Multi-hop interconnect driver */
124
125    // request portion of routing table from another monitor
126    message multihop_routing_table_request(coreid source_coreid);
127    message multihop_routing_table_response(errval err,
128            coreid source_coreid,
129            coreid max_coreid,
130            coreid to[len, 2048]);
131
132    // grow the routing table to a set of desination cores, via a given forwarder
133    message multihop_routing_table_grow(coreid forwarder, coreid destinations[len, 2048]);
134
135    // set up a new multihop virtual circuit
136    message bind_multihop_intermon_request(iref iref, vci sender_vci,
137                                           coreid core_id);
138    message bind_multihop_intermon_reply(vci receiver_vci, vci sender_vci,
139                                         errval err);
140
141    message multihop_message(vci vci, uint8 direction, uint8 flags, uint32 ack,
142                             uint8 payload[size, 2048]);
143    message multihop_cap_send(vci vci, uint8 direction, capid capid, errval err,
144                              caprep cap, bool null_cap, coreid owner);
145
146    // cap operation messages
147    message capops_request_copy(coreid dest, caprep cap, capop_st st);
148    message capops_recv_copy(caprep cap, uint8 owner_relations, capop_st st);
149    message capops_recv_copy_result(errval status, capaddr cap, caplevel level, capslot slot, capop_st st);
150
151    message capops_move_request(caprep cap, uint8 relations, capop_st st);
152    message capops_move_result(errval status, capop_st st);
153    message capops_retrieve_request(caprep cap, capop_st st);
154    message capops_retrieve_result(errval status, uint8 relations, capop_st st);
155
156    message capops_delete_remote(caprep cap, capop_st st);
157    message capops_delete_remote_result(errval status, capop_st st);
158
159    message capops_revoke_mark(caprep cap, capop_st st);
160    message capops_revoke_ready(capop_st st);
161    message capops_revoke_commit(capop_st st);
162    message capops_revoke_done(capop_st st);
163
164    // XXX: uint32 for bits? -MN
165    message capops_request_retype(caprep src, uint64 offset,
166                                  uint32 desttype, uint64 destsize, uint64 count,
167                                  capop_st st);
168    message capops_retype_response(errval status, capop_st st);
169
170    // ownership / relation messages
171    message capops_update_owner(caprep cap, capop_st st);
172    message capops_owner_updated(capop_st st);
173
174    message capops_find_cap(caprep cap, capop_st st);
175    message capops_find_cap_result(errval status, capop_st st);
176
177    message capops_find_descendants(caprep cap, capop_st st);
178    message capops_find_descendants_result(errval status, capop_st st);
179
180    // Retypeability check
181    message capops_check_retypeable(caprep cap, capop_st st, uint64 offset,
182                                    uint64 objsize, uint64 count);
183    message capops_check_retypeable_result(errval status, capop_st st);
184
185    /* Tracing Framework */
186
187    // Notify a core that it should prepare the tracing state. The origin core
188    // is the one who initiated the preparation request.
189    message trace_prepare(coreid origin_core);
190
191    // Notify the core who initiated the preparation that it is finished.
192    message trace_prepare_finished();
193
194    // Notify core 0 that you want to make a time measurement (Network Time
195    // Protocol). The origin core is the one who initiated the trace preparation.
196    message trace_measure(coreid origin_core, uint64 t0);
197
198    // The response to a measurement call from a core.
199    message trace_measure_ack(coreid origin_core, uint64 t0, uint64 t1, uint64 t2);
200
201    /* bfscope - the tracing server */
202
203    // Forward a trace-flush command to the monitor on the core on which bfscope
204    // is running.
205    message bfscope_flush_send_forward(iref iref);
206
207    // This message is sent, once bfscope has finished flushing.
208    message bfscope_flush_ack_forward();
209
210    message give_kcb_request(caprep kcb);
211    message give_kcb_response(errval err);
212
213    message forward_kcb_rm_request(uint64 kcb_base);
214    message forward_kcb_rm_response(errval err);
215};
216
217