Add spawn, spawn_with_caps and span calls to the Process Manager API.
[barrelfish] / usr / proc_mgmt / service.c
1 /**
2  * \file
3  * \brief Process management service.
4  */
5
6 /*
7  * Copyright (c) 2017, ETH Zurich.
8  * All rights reserved.
9  *
10  * This file is distributed under the terms in the attached LICENSE file.
11  * If you do not find this file, copies can be found by writing to:
12  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
13  */
14
15 #include <barrelfish/barrelfish.h>
16 #include <barrelfish/nameservice_client.h>
17 #include <barrelfish/proc_mgmt_client.h>
18 #include <barrelfish/spawn_client.h>
19 #include <if/monitor_defs.h>
20 #include <if/proc_mgmt_defs.h>
21 #include <if/spawn_defs.h>
22
23 #include "domain.h"
24 #include "internal.h"
25 #include "pending_clients.h"
26 #include "spawnd_state.h"
27
28 static void add_spawnd_handler(struct proc_mgmt_binding *b, coreid_t core_id,
29                                iref_t iref)
30 {
31     if (spawnd_state_exists(core_id)) {
32         DEBUG_ERR(PROC_MGMT_ERR_SPAWND_EXISTS, "spawnd_state_exists");
33         return;
34     }
35
36     // Bind with the spawnd.
37     struct spawn_binding *spawnb;
38     errval_t err = spawn_bind_iref(iref, &spawnb);
39     if (err_is_fail(err)) {
40         DEBUG_ERR(err, "spawn_bind_iref");
41         return;
42     }
43
44     err = spawnd_state_alloc(core_id, spawnb);
45     if (err_is_fail(err)) {
46         DEBUG_ERR(err, "spawnd_state_alloc");
47     }
48
49     debug_printf("Process manager bound with spawnd.%u on iref %u\n", core_id,
50             iref);
51 }
52
53 static void add_spawnd_handler_non_monitor(struct proc_mgmt_binding *b,
54                                            coreid_t core_id, iref_t iref)
55 {
56     debug_printf("Ignoring add_spawnd call: %s\n",
57                  err_getstring(PROC_MGMT_ERR_NOT_MONITOR));
58 }
59
60 static void spawn_reply_handler(struct spawn_binding *b,
61                                 struct capref domain_cap, errval_t spawn_err)
62 {
63     struct pending_client cl;
64     errval_t err = pending_clients_release(domain_cap, &cl);
65     if (err_is_fail(err)) {
66         // This might be a kill request issued after a successful spawn/span
67         // followed by a local error in the process manager (see below). If that
68         // is the case, then we won't have a client, as it has already been
69         // released.
70         debug_printf("Unable to retrieve pending client based on domain cap "
71                      "returned by spawnd");
72         return;
73     }
74
75     errval_t resp_err;
76     switch (cl.type) {
77         case ClientType_Spawn:
78             err = spawn_err;
79             if (err_is_ok(spawn_err)) {
80                 err = domain_spawn(domain_cap, cl.core_id);
81             }
82             resp_err = cl.b->tx_vtbl.spawn_response(cl.b, NOP_CONT, err,
83                                                      domain_cap);
84             break;
85
86         case ClientType_SpawnWithCaps:
87             err = spawn_err;
88             if (err_is_ok(spawn_err)) {
89                 err = domain_spawn(domain_cap, cl.core_id);
90             }
91             resp_err = cl.b->tx_vtbl.spawn_with_caps_response(cl.b, NOP_CONT,
92                                                                err, domain_cap);
93             break;
94
95         case ClientType_Span:
96             err = spawn_err;
97             if (err_is_ok(spawn_err)) {
98                 err = domain_span(domain_cap, cl.core_id);
99             }
100             resp_err = cl.b->tx_vtbl.span_response(cl.b, NOP_CONT, err);
101             break;
102
103         default:
104             // TODO(razvan): Handle the other cases, e.g. kill.
105             debug_printf("Unknown client type %u\n", cl.type);
106             return;
107     }
108
109     if (err_is_ok(spawn_err) && err_is_fail(err)) {
110         // Spawnd has successfully completed its end of the operation, but
111         // there's been an error in the process manager's book-keeping
112         // of domains. Therefore, if the request was a spawn or span one, spawnd
113         // needs to be asked to stop the dispatcher which it has just enqueued.
114         if (cl.type == ClientType_Spawn ||
115             cl.type == ClientType_SpawnWithCaps ||
116             cl.type == ClientType_Span) {
117             struct spawnd_state *state = spawnd_state_get(cl.core_id);
118             assert(state != NULL);
119             struct spawn_binding *spb = state->b;
120             assert(spb != NULL);
121
122             err = spb->tx_vtbl.kill_request(spb, NOP_CONT, domain_cap);
123             if (err_is_fail(err)) {
124                 // XXX: How severe is this? Maybe we want something more
125                 // assertive than logging an error message.
126                 DEBUG_ERR(err, "failed to send kill request for dangling "
127                           "dispatcher");
128             }
129         }
130     }
131
132     if (err_is_fail(resp_err)) {
133         DEBUG_ERR(resp_err, "failed to send response to client");
134     }
135 }
136
137 static errval_t spawn_handler_common(struct proc_mgmt_binding *b,
138                                      enum ClientType type,
139                                      coreid_t core_id, const char *path,
140                                      const char *argvbuf, size_t argvbytes,
141                                      const char *envbuf, size_t envbytes,
142                                      struct capref inheritcn_cap,
143                                      struct capref argcn_cap, uint8_t flags,
144                                      struct capref *ret_domain_cap)
145 {
146     assert(ret_domain_cap != NULL);
147
148     if (!spawnd_state_exists(core_id)) {
149         return PROC_MGMT_ERR_INVALID_SPAWND;
150     }
151
152     struct spawnd_state *state = spawnd_state_get(core_id);
153     assert(state != NULL);
154     struct spawn_binding *cl = state->b;
155     assert(cl != NULL);
156
157     struct capref domain_cap;
158     errval_t err = slot_alloc(&domain_cap);
159     if (err_is_fail(err)) {
160         DEBUG_ERR(err, "slot_alloc domain_cap");
161         return err_push(err, PROC_MGMT_ERR_CREATE_DOMAIN_CAP);
162     }
163     err = cap_retype(domain_cap, cap_procmng, 0, ObjType_Domain, 0, 1);
164     if (err_is_fail(err)) {
165         DEBUG_ERR(err, "cap_retype domain_cap");
166         return err_push(err, PROC_MGMT_ERR_CREATE_DOMAIN_CAP);
167     }
168
169     err = pending_clients_add(domain_cap, b, type, core_id);
170     if (err_is_fail(err)) {
171         DEBUG_ERR(err, "pending_clients_add");
172         return err;
173     }
174
175     cl->rx_vtbl.spawn_reply = spawn_reply_handler;
176     if (capref_is_null(inheritcn_cap) && capref_is_null(argcn_cap)) {
177         err = cl->tx_vtbl.spawn_request(cl, NOP_CONT, domain_cap, path, argvbuf,
178                                         argvbytes, envbuf, envbytes, flags);
179     } else {
180         err = cl->tx_vtbl.spawn_with_caps_request(cl, NOP_CONT, domain_cap,
181                                                   path, argvbuf, argvbytes,
182                                                   envbuf, envbytes,
183                                                   inheritcn_cap, argcn_cap,
184                                                   flags);
185     }
186     if (err_is_fail(err)) {
187         DEBUG_ERR(err, "sending spawn request");
188         pending_clients_release(domain_cap, NULL);
189         return err_push(err, PROC_MGMT_ERR_SPAWND_REQUEST);
190     }
191
192     return SYS_ERR_OK;
193 }
194
195 static void spawn_handler(struct proc_mgmt_binding *b, coreid_t core_id,
196                           const char *path, const char *argvbuf,
197                           size_t argvbytes, const char *envbuf, size_t envbytes,
198                           uint8_t flags)
199 {
200     errval_t err, resp_err;
201     struct capref domain_cap;
202     err = spawn_handler_common(b, ClientType_Spawn, core_id, path, argvbuf,
203                                argvbytes, envbuf, envbytes, NULL_CAP, NULL_CAP,
204                                flags, &domain_cap);
205     if (err_is_ok(err)) {
206         // Will respond to client when we get the reply from spawnd.
207         return;
208     }
209
210     resp_err = b->tx_vtbl.spawn_response(b, NOP_CONT, err, NULL_CAP);
211     if (err_is_fail(resp_err)) {
212         DEBUG_ERR(resp_err, "failed to send spawn_response");
213     }
214 }
215
216 static void spawn_with_caps_handler(struct proc_mgmt_binding *b,
217                                     coreid_t core_id, const char *path,
218                                     const char *argvbuf, size_t argvbytes,
219                                     const char *envbuf, size_t envbytes,
220                                     struct capref inheritcn_cap,
221                                     struct capref argcn_cap, uint8_t flags)
222 {
223     errval_t err, resp_err;
224     struct capref domain_cap;
225     err = spawn_handler_common(b, ClientType_SpawnWithCaps, core_id, path,
226                                argvbuf, argvbytes, envbuf, envbytes,
227                                inheritcn_cap, argcn_cap, flags, &domain_cap);
228     if (err_is_ok(err)) {
229         // Will respond to client when we get the reply from spawnd.
230         return;
231     }
232
233     resp_err = b->tx_vtbl.spawn_with_caps_response(b, NOP_CONT, err,
234                                                             NULL_CAP);
235     if (err_is_fail(resp_err)) {
236         DEBUG_ERR(resp_err, "failed to send spawn_with_caps_response");
237     }
238 }
239
240 static void span_handler(struct proc_mgmt_binding *b, struct capref domain_cap,
241                          coreid_t core_id, struct capref vroot,
242                          struct capref dispframe)
243 {
244     errval_t err, resp_err;
245     err = domain_can_span(domain_cap, core_id);
246     if (err_is_fail(err)) {
247         goto respond_with_err;
248     }
249
250     if (!spawnd_state_exists(core_id)) {
251         err = PROC_MGMT_ERR_INVALID_SPAWND;
252         goto respond_with_err;
253     }
254
255     struct spawnd_state *state = spawnd_state_get(core_id);
256     assert(state != NULL);
257     struct spawn_binding *cl = state->b;
258     assert(cl != NULL);
259
260     err = pending_clients_add(domain_cap, b, ClientType_Span, core_id);
261     if (err_is_fail(err)) {
262         goto respond_with_err;
263     }
264
265     cl->rx_vtbl.spawn_reply = spawn_reply_handler;
266     err = cl->tx_vtbl.span_request(cl, NOP_CONT, domain_cap, vroot, dispframe);
267     if (err_is_ok(err)) {
268         // Will respond to client when we get the reply from spawnd.
269         return;
270     } else {
271         DEBUG_ERR(err, "sending span request");
272         pending_clients_release(domain_cap, NULL);
273         err = err_push(err, PROC_MGMT_ERR_SPAWND_REQUEST);
274     }
275
276 respond_with_err:
277     resp_err = b->tx_vtbl.span_response(b, NOP_CONT, err);
278     if (err_is_fail(resp_err)) {
279         DEBUG_ERR(resp_err, "failed to send span_response");
280     }
281 }
282
283 static void kill_handler(struct proc_mgmt_binding *b, struct capref domain_cap)
284 {
285     struct domain_entry *entry;
286     errval_t err = domain_get_by_cap(domain_cap, &entry);
287     if (err_is_ok(err)) {
288         domain_send_stop(entry);
289     }
290 }
291
292 static struct proc_mgmt_rx_vtbl monitor_vtbl = {
293     .add_spawnd           = add_spawnd_handler,
294     .spawn_call           = spawn_handler,
295     .spawn_with_caps_call = spawn_with_caps_handler,
296     .span_call            = span_handler,
297     .kill_call            = kill_handler
298 };
299
300 static struct proc_mgmt_rx_vtbl non_monitor_vtbl = {
301     .add_spawnd           = add_spawnd_handler_non_monitor,
302     .spawn_call           = spawn_handler,
303     .spawn_with_caps_call = spawn_with_caps_handler,
304     .span_call            = span_handler,
305     .kill_call            = kill_handler
306 };
307
308 static errval_t alloc_ep_for_monitor(struct capref *ep)
309 {
310     struct proc_mgmt_lmp_binding *lmpb =
311         malloc(sizeof(struct proc_mgmt_lmp_binding));
312     assert(lmpb != NULL);
313
314     // setup our end of the binding
315     errval_t err = proc_mgmt_client_lmp_accept(lmpb, get_default_waitset(),
316                                                DEFAULT_LMP_BUF_WORDS);
317     if (err_is_fail(err)) {
318         free(lmpb);
319         return err_push(err, LIB_ERR_PROC_MGMT_CLIENT_ACCEPT);
320     }
321
322     *ep = lmpb->chan.local_cap;
323     lmpb->b.rx_vtbl = monitor_vtbl;
324
325     return SYS_ERR_OK;
326 }
327
328 static void export_cb(void *st, errval_t err, iref_t iref)
329 {
330     if (err_is_fail(err)) {
331         USER_PANIC_ERR(err, "export failed");
332     }
333
334     // Allocate an endpoint for the local monitor, who will use it to inform
335     // us about new spawnd irefs on behalf of other monitors.
336     struct capref ep;
337     err = alloc_ep_for_monitor(&ep);
338     if (err_is_fail(err)) {
339         USER_PANIC_ERR(err, "failed to allocate LMP EP for local monitor");
340     }
341
342     // Send the endpoint to the monitor, so it can finish the handshake.
343     struct monitor_binding *mb = get_monitor_binding();
344     err = mb->tx_vtbl.set_proc_mgmt_ep_request(mb, NOP_CONT, ep);
345     if (err_is_fail(err)) {
346         USER_PANIC_ERR(err, "failed to send set_proc_mgmt_ep_request to "
347                        "monitor");
348     }
349
350     // Also register this iref with the name service, for arbitrary client
351     // domains to use for spawn-related ops.
352     err = nameservice_register(SERVICE_BASENAME, iref);
353     if (err_is_fail(err)) {
354         USER_PANIC_ERR(err, "nameservice_register failed");
355     }
356 }
357
358 static errval_t connect_cb(void *st, struct proc_mgmt_binding *b)
359 {
360     b->rx_vtbl = non_monitor_vtbl;
361     return SYS_ERR_OK;
362 }
363
364 errval_t start_service(void)
365 {
366     return proc_mgmt_export(NULL, export_cb, connect_cb, get_default_waitset(),
367             IDC_EXPORT_FLAGS_DEFAULT);
368 }