Made errval_t a flounder builtin.
[barrelfish] / if / monitor.if
1 /*
2  * Copyright (c) 2007, 2008, 2009, 2010, 2011, 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 monitor "The monitor to client Interface" {
11     alias vci uint64;
12     alias capid uint32;
13
14     call alloc_iref_request(
15         uintptr service_id);
16
17     response alloc_iref_reply(
18         uintptr service_id,
19         iref iref,
20         errval err);
21
22     /* TODO: move to monitor_blocking as RPC? */
23     call boot_core_request(uint8 id, cap frame);
24     response boot_core_reply(errval err);
25
26     call new_monitor_binding_request(
27         uintptr st);
28
29     response new_monitor_binding_reply(
30         errval err,
31         cap ep,
32         uintptr st);
33
34     // a client sends this to the monitor to initiate a bind
35     message bind_lmp_client_request(
36         iref iref,
37         uintptr conn_id,
38         size buflen,
39         cap ep);
40
41     // Request multiboot caps from the monitor.
42     // I imagine only a file system doing this.
43     /* TODO: move to monitor_blocking as RPC? */
44     message multiboot_cap_request(uint32 slot);
45     message multiboot_cap_reply(cap cap, errval err);
46
47     // the monitor sends this to a service to pass on a bind request
48     message bind_lmp_service_request(
49         uintptr service_id,
50         uintptr mon_id,
51         size buflen,
52         cap ep);
53
54
55     message bind_lmp_reply_monitor(
56         errval err,
57         uintptr mon_id,
58         uintptr conn_id,
59         cap ep);
60
61     message bind_lmp_reply_client(
62         errval err,
63         uintptr mon_id,
64         uintptr conn_id,
65         cap ep);
66
67     // a client sends this to the monitor to initiate a bind
68     message bind_ump_client_request(
69         iref iref,
70         uintptr conn_id,
71         cap frame,
72         size channel_length_in,
73         size channel_length_out,
74         cap notify);
75
76     // the monitor sends this to a service to pass on a bind request
77     message bind_ump_service_request(
78         uintptr service_id,
79         uintptr mon_id,
80         cap frame,
81         size channel_length_in,
82         size channel_length_out,
83         cap notify);
84
85     call bind_ump_reply_monitor(
86         uintptr mon_id,
87         uintptr conn_id,
88         errval err,
89         cap notify);
90
91     response bind_ump_reply_client(
92         uintptr mon_id,
93         uintptr conn_id,
94         errval err,
95         cap notify);
96
97     call ipi_alloc_notify_request(cap ep, uintptr state);
98     response ipi_alloc_notify_reply(uintptr state, cap notify, errval err);
99
100     call get_mem_iref_request();
101     response get_mem_iref_reply(iref iref);
102
103     call get_name_iref_request(uintptr st);
104     response get_name_iref_reply(iref iref, uintptr st);
105
106     call get_ramfs_iref_request(uintptr st);
107     response get_ramfs_iref_reply(iref iref, uintptr st);
108     call set_ramfs_iref_request(iref iref);
109
110     call set_mem_iref_request(iref iref);
111
112     call set_name_iref_request(iref iref);
113     response set_name_iref_reply(errval err);
114
115     call get_monitor_rpc_iref_request(uintptr st);
116     response get_monitor_rpc_iref_reply(iref iref, uintptr st);
117
118     /* for UMP/BMP cap tx */
119     call cap_send_request(
120         uintptr mon_id,
121         cap cap,
122         capid capid);
123     call cap_move_request(
124         uintptr mon_id,
125         give_away_cap cap,
126         capid capid);
127     response cap_receive_request(
128         uintptr conn_id,
129         errval err,
130         give_away_cap cap,
131         capid capid);
132
133     call span_domain_request(
134         uintptr domain_id,
135         uint8 core_id,
136         cap vroot,
137         cap disp);
138     response span_domain_reply(
139         errval err,
140         uintptr domain_id);
141
142     /**
143      * \brief Migrates a dispatcher to a distant core
144      *
145      * \note Currently in a proof concept stage. We just migrate
146      * and hope for the best, no reply that talks about the success.
147      *
148      * \param core_id Destination core id
149      * \param vroot Address space capability
150      * \param disp Dispatcher Capability
151      */
152     message migrate_dispatcher_request(
153         uint8 core_id,
154         cap vroot,
155         cap disp);
156
157     /* Multi-hop interconnect driver */
158
159     // Send routing table
160     // First message, which describes the set of valid core IDs
161     call multihop_routing_table_new(coreid max_coreid, coreid nentries);
162     // Subsequent messages (repeated) which each contain
163     // a portion of the routing table from a single core
164     call multihop_routing_table_set(coreid from, coreid to[len]);
165
166     // Connection set-up between monitor and client
167     call multihop_bind_client_request(iref iref, vci sender_vci);
168     response multihop_bind_client_reply(vci receiver_vci, vci sender_vci,
169                                         errval err);
170
171     // Connection set-up between monitor and service
172     call multihop_bind_service_request(uintptr service_id, vci sender_vci);
173     response multihop_bind_service_reply(vci receiver_vci , vci sender_vci,
174                                          errval err);
175
176     // user message
177     message multihop_message(vci vci, uint8 direction, uint8 flags, uint32 ack,
178                              uint8 payload[size]);
179
180     // cap transfer
181     call multihop_cap_send(vci vci, uint8 direction, errval err, cap cap,
182                            capid capid);
183
184     /* Tracing Framework */
185
186     // Notify a core that it should prepare the tracing state. The origin core
187     // is the one who initiated the preparation request.
188     message trace_prepare(coreid origin_core);
189
190     // Notify the core who initiated the preparation that it is finished.
191     message trace_prepare_finished();
192
193     /* bfscope - the tracing server */
194
195     // Send a message to bfscope, to notify that it should flush
196     call bfscope_flush_send(iref iref);
197
198     // Notify the initiatior of the flush request that it has been completed.
199     response bfscope_flush_ack();
200
201     message migrate_dispatcher(uintptr domain_id);
202
203     // Capability debugging
204     message debug_print_capabilities();
205 };