Print this page
7387 SMF is fast and loose with require_any/service dependencies
Reviewed by: Dan McDonald <danmcd@omniti.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/svc/startd/graph.c
+++ new/usr/src/cmd/svc/startd/graph.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
24 24 * Copyright (c) 2015, Syneto S.R.L. All rights reserved.
25 + * Copyright 2016 RackTop Systems.
25 26 */
26 27
27 28 /*
28 29 * graph.c - master restarter graph engine
29 30 *
30 31 * The graph engine keeps a dependency graph of all service instances on the
31 32 * system, as recorded in the repository. It decides when services should
32 33 * be brought up or down based on service states and dependencies and sends
33 34 * commands to restarters to effect any changes. It also executes
34 35 * administrator commands sent by svcadm via the repository.
35 36 *
36 37 * The graph is stored in uu_list_t *dgraph and its vertices are
37 38 * graph_vertex_t's, each of which has a name and an integer id unique to
38 39 * its name (see dict.c). A vertex's type attribute designates the type
39 40 * of object it represents: GVT_INST for service instances, GVT_SVC for
40 41 * service objects (since service instances may depend on another service,
41 42 * rather than service instance), GVT_FILE for files (which services may
42 43 * depend on), and GVT_GROUP for dependencies on multiple objects. GVT_GROUP
43 44 * vertices are necessary because dependency lists may have particular
44 45 * grouping types (require any, require all, optional, or exclude) and
45 46 * event-propagation characteristics.
46 47 *
47 48 * The initial graph is built by libscf_populate_graph() invoking
48 49 * dgraph_add_instance() for each instance in the repository. The function
49 50 * adds a GVT_SVC vertex for the service if one does not already exist, adds
50 51 * a GVT_INST vertex named by the FMRI of the instance, and sets up the edges.
51 52 * The resulting web of vertices & edges associated with an instance's vertex
52 53 * includes
53 54 *
54 55 * - an edge from the GVT_SVC vertex for the instance's service
55 56 *
56 57 * - an edge to the GVT_INST vertex of the instance's resarter, if its
57 58 * restarter is not svc.startd
58 59 *
59 60 * - edges from other GVT_INST vertices if the instance is a restarter
60 61 *
61 62 * - for each dependency property group in the instance's "running"
62 63 * snapshot, an edge to a GVT_GROUP vertex named by the FMRI of the
63 64 * instance and the name of the property group
64 65 *
65 66 * - for each value of the "entities" property in each dependency property
66 67 * group, an edge from the corresponding GVT_GROUP vertex to a
67 68 * GVT_INST, GVT_SVC, or GVT_FILE vertex
68 69 *
69 70 * - edges from GVT_GROUP vertices for each dependent instance
70 71 *
71 72 * After the edges are set up the vertex's GV_CONFIGURED flag is set. If
72 73 * there are problems, or if a service is mentioned in a dependency but does
73 74 * not exist in the repository, the GV_CONFIGURED flag will be clear.
74 75 *
75 76 * The graph and all of its vertices are protected by the dgraph_lock mutex.
76 77 * See restarter.c for more information.
77 78 *
78 79 * The properties of an instance fall into two classes: immediate and
79 80 * snapshotted. Immediate properties should have an immediate effect when
80 81 * changed. Snapshotted properties should be read from a snapshot, so they
81 82 * only change when the snapshot changes. The immediate properties used by
82 83 * the graph engine are general/enabled, general/restarter, and the properties
83 84 * in the restarter_actions property group. Since they are immediate, they
84 85 * are not read out of a snapshot. The snapshotted properties used by the
85 86 * graph engine are those in the property groups with type "dependency" and
86 87 * are read out of the "running" snapshot. The "running" snapshot is created
87 88 * by the the graph engine as soon as possible, and it is updated, along with
88 89 * in-core copies of the data (dependency information for the graph engine) on
89 90 * receipt of the refresh command from svcadm. In addition, the graph engine
90 91 * updates the "start" snapshot from the "running" snapshot whenever a service
91 92 * comes online.
92 93 *
93 94 * When a DISABLE event is requested by the administrator, svc.startd shutdown
94 95 * the dependents first before shutting down the requested service.
95 96 * In graph_enable_by_vertex, we create a subtree that contains the dependent
96 97 * vertices by marking those vertices with the GV_TOOFFLINE flag. And we mark
97 98 * the vertex to disable with the GV_TODISABLE flag. Once the tree is created,
98 99 * we send the _ADMIN_DISABLE event to the leaves. The leaves will then
99 100 * transition from STATE_ONLINE/STATE_DEGRADED to STATE_OFFLINE/STATE_MAINT.
100 101 * In gt_enter_offline and gt_enter_maint if the vertex was in a subtree then
101 102 * we clear the GV_TOOFFLINE flag and walk the dependencies to offline the new
102 103 * exposed leaves. We do the same until we reach the last leaf (the one with
103 104 * the GV_TODISABLE flag). If the vertex to disable is also part of a larger
104 105 * subtree (eg. multiple DISABLE events on vertices in the same subtree) then
105 106 * once the first vertex is disabled (GV_TODISABLE flag is removed), we
106 107 * continue to propagate the offline event to the vertex's dependencies.
107 108 *
108 109 *
109 110 * SMF state transition notifications
110 111 *
111 112 * When an instance of a service managed by SMF changes state, svc.startd may
112 113 * publish a GPEC sysevent. All transitions to or from maintenance, a
113 114 * transition cause by a hardware error will generate an event.
114 115 * Other transitions will generate an event if there exist notification
115 116 * parameter for that transition. Notification parameters are stored in the
116 117 * SMF repository for the service/instance they refer to. System-wide
117 118 * notification parameters are stored in the global instance.
118 119 * svc.startd can be told to send events for all SMF state transitions despite
119 120 * of notification parameters by setting options/info_events_all to true in
120 121 * restarter:default
121 122 *
122 123 * The set of transitions that generate events is cached in the
123 124 * dgraph_vertex_t gv_stn_tset for service/instance and in the global
124 125 * stn_global for the system-wide set. They are re-read when instances are
125 126 * refreshed.
126 127 *
127 128 * The GPEC events published by svc.startd are consumed by fmd(1M). After
128 129 * processing these events, fmd(1M) publishes the processed events to
129 130 * notification agents. The notification agents read the notification
130 131 * parameters from the SMF repository through libscf(3LIB) interfaces and send
131 132 * the notification, or not, based on those parameters.
132 133 *
133 134 * Subscription and publishing to the GPEC channels is done with the
134 135 * libfmevent(3LIB) wrappers fmev_[r]publish_*() and
135 136 * fmev_shdl_(un)subscribe().
136 137 *
137 138 */
138 139
139 140 #include <sys/uadmin.h>
140 141 #include <sys/wait.h>
141 142
142 143 #include <assert.h>
143 144 #include <errno.h>
144 145 #include <fcntl.h>
145 146 #include <fm/libfmevent.h>
146 147 #include <libscf.h>
147 148 #include <libscf_priv.h>
148 149 #include <librestart.h>
149 150 #include <libuutil.h>
150 151 #include <locale.h>
151 152 #include <poll.h>
152 153 #include <pthread.h>
153 154 #include <signal.h>
154 155 #include <stddef.h>
155 156 #include <stdio.h>
156 157 #include <stdlib.h>
157 158 #include <string.h>
158 159 #include <strings.h>
159 160 #include <sys/statvfs.h>
160 161 #include <sys/uadmin.h>
161 162 #include <zone.h>
162 163 #if defined(__i386)
163 164 #include <libgrubmgmt.h>
164 165 #endif /* __i386 */
165 166
166 167 #include "startd.h"
167 168 #include "protocol.h"
168 169
169 170
170 171 #define MILESTONE_NONE ((graph_vertex_t *)1)
171 172
172 173 #define CONSOLE_LOGIN_FMRI "svc:/system/console-login:default"
173 174 #define FS_MINIMAL_FMRI "svc:/system/filesystem/minimal:default"
174 175
175 176 #define VERTEX_REMOVED 0 /* vertex has been freed */
176 177 #define VERTEX_INUSE 1 /* vertex is still in use */
177 178
178 179 #define IS_ENABLED(v) ((v)->gv_flags & (GV_ENABLED | GV_ENBLD_NOOVR))
179 180
180 181 /*
181 182 * stn_global holds the tset for the system wide notification parameters.
182 183 * It is updated on refresh of svc:/system/svc/global:default
183 184 *
184 185 * There are two assumptions that relax the need for a mutex:
185 186 * 1. 32-bit value assignments are atomic
186 187 * 2. Its value is consumed only in one point at
187 188 * dgraph_state_transition_notify(). There are no test and set races.
188 189 *
189 190 * If either assumption is broken, we'll need a mutex to synchronize
190 191 * access to stn_global
191 192 */
192 193 int32_t stn_global;
193 194 /*
194 195 * info_events_all holds a flag to override notification parameters and send
195 196 * Information events for all state transitions.
196 197 * same about the need of a mutex here.
197 198 */
198 199 int info_events_all;
199 200
200 201 /*
201 202 * Services in these states are not considered 'down' by the
202 203 * milestone/shutdown code.
203 204 */
204 205 #define up_state(state) ((state) == RESTARTER_STATE_ONLINE || \
205 206 (state) == RESTARTER_STATE_DEGRADED || \
206 207 (state) == RESTARTER_STATE_OFFLINE)
207 208
208 209 #define is_depgrp_bypassed(v) ((v->gv_type == GVT_GROUP) && \
209 210 ((v->gv_depgroup == DEPGRP_EXCLUDE_ALL) || \
210 211 (v->gv_depgroup == DEPGRP_OPTIONAL_ALL) || \
211 212 (v->gv_restart < RERR_RESTART)))
212 213
213 214 static uu_list_pool_t *graph_edge_pool, *graph_vertex_pool;
214 215 static uu_list_t *dgraph;
215 216 static pthread_mutex_t dgraph_lock;
216 217
217 218 /*
218 219 * milestone indicates the current subgraph. When NULL, it is the entire
219 220 * graph. When MILESTONE_NONE, it is the empty graph. Otherwise, it is all
220 221 * services on which the target vertex depends.
221 222 */
222 223 static graph_vertex_t *milestone = NULL;
223 224 static boolean_t initial_milestone_set = B_FALSE;
224 225 static pthread_cond_t initial_milestone_cv = PTHREAD_COND_INITIALIZER;
225 226
226 227 /* protected by dgraph_lock */
227 228 static boolean_t sulogin_thread_running = B_FALSE;
228 229 static boolean_t sulogin_running = B_FALSE;
229 230 static boolean_t console_login_ready = B_FALSE;
230 231
231 232 /* Number of services to come down to complete milestone transition. */
232 233 static uint_t non_subgraph_svcs;
233 234
234 235 /*
235 236 * These variables indicate what should be done when we reach the milestone
236 237 * target milestone, i.e., when non_subgraph_svcs == 0. They are acted upon in
237 238 * dgraph_set_instance_state().
238 239 */
239 240 static int halting = -1;
240 241 static boolean_t go_single_user_mode = B_FALSE;
241 242 static boolean_t go_to_level1 = B_FALSE;
242 243
243 244 /*
244 245 * Tracks when we started halting.
245 246 */
246 247 static time_t halting_time = 0;
247 248
248 249 /*
249 250 * This tracks the legacy runlevel to ensure we signal init and manage
250 251 * utmpx entries correctly.
251 252 */
252 253 static char current_runlevel = '\0';
253 254
254 255 /* Number of single user threads currently running */
255 256 static pthread_mutex_t single_user_thread_lock;
256 257 static int single_user_thread_count = 0;
257 258
258 259 /* Statistics for dependency cycle-checking */
259 260 static u_longlong_t dep_inserts = 0;
260 261 static u_longlong_t dep_cycle_ns = 0;
261 262 static u_longlong_t dep_insert_ns = 0;
262 263
263 264
264 265 static const char * const emsg_invalid_restarter =
265 266 "Transitioning %s to maintenance, restarter FMRI %s is invalid "
266 267 "(see 'svcs -xv' for details).\n";
267 268 static const char * const console_login_fmri = CONSOLE_LOGIN_FMRI;
268 269 static const char * const single_user_fmri = SCF_MILESTONE_SINGLE_USER;
269 270 static const char * const multi_user_fmri = SCF_MILESTONE_MULTI_USER;
270 271 static const char * const multi_user_svr_fmri = SCF_MILESTONE_MULTI_USER_SERVER;
271 272
272 273
273 274 /*
274 275 * These services define the system being "up". If none of them can come
275 276 * online, then we will run sulogin on the console. Note that the install ones
276 277 * are for the miniroot and when installing CDs after the first. can_come_up()
277 278 * does the decision making, and an sulogin_thread() runs sulogin, which can be
278 279 * started by dgraph_set_instance_state() or single_user_thread().
279 280 *
280 281 * NOTE: can_come_up() relies on SCF_MILESTONE_SINGLE_USER being the first
281 282 * entry, which is only used when booting_to_single_user (boot -s) is set.
282 283 * This is because when doing a "boot -s", sulogin is started from specials.c
283 284 * after milestone/single-user comes online, for backwards compatibility.
284 285 * In this case, SCF_MILESTONE_SINGLE_USER needs to be part of up_svcs
285 286 * to ensure sulogin will be spawned if milestone/single-user cannot be reached.
286 287 */
287 288 static const char * const up_svcs[] = {
288 289 SCF_MILESTONE_SINGLE_USER,
289 290 CONSOLE_LOGIN_FMRI,
290 291 "svc:/system/install-setup:default",
291 292 "svc:/system/install:default",
292 293 NULL
293 294 };
294 295
295 296 /* This array must have an element for each non-NULL element of up_svcs[]. */
296 297 static graph_vertex_t *up_svcs_p[] = { NULL, NULL, NULL, NULL };
297 298
298 299 /* These are for seed repository magic. See can_come_up(). */
299 300 static const char * const manifest_import = SCF_INSTANCE_MI;
300 301 static graph_vertex_t *manifest_import_p = NULL;
301 302
302 303
303 304 static char target_milestone_as_runlevel(void);
304 305 static void graph_runlevel_changed(char rl, int online);
305 306 static int dgraph_set_milestone(const char *, scf_handle_t *, boolean_t);
306 307 static boolean_t should_be_in_subgraph(graph_vertex_t *v);
307 308 static int mark_subtree(graph_edge_t *, void *);
308 309 static boolean_t insubtree_dependents_down(graph_vertex_t *);
309 310
310 311 /*
311 312 * graph_vertex_compare()
312 313 * This function can compare either int *id or * graph_vertex_t *gv
313 314 * values, as the vertex id is always the first element of a
314 315 * graph_vertex structure.
315 316 */
316 317 /* ARGSUSED */
317 318 static int
318 319 graph_vertex_compare(const void *lc_arg, const void *rc_arg, void *private)
319 320 {
320 321 int lc_id = ((const graph_vertex_t *)lc_arg)->gv_id;
321 322 int rc_id = *(int *)rc_arg;
322 323
323 324 if (lc_id > rc_id)
324 325 return (1);
325 326 if (lc_id < rc_id)
326 327 return (-1);
327 328 return (0);
328 329 }
329 330
330 331 void
331 332 graph_init()
332 333 {
333 334 graph_edge_pool = startd_list_pool_create("graph_edges",
334 335 sizeof (graph_edge_t), offsetof(graph_edge_t, ge_link), NULL,
335 336 UU_LIST_POOL_DEBUG);
336 337 assert(graph_edge_pool != NULL);
337 338
338 339 graph_vertex_pool = startd_list_pool_create("graph_vertices",
339 340 sizeof (graph_vertex_t), offsetof(graph_vertex_t, gv_link),
340 341 graph_vertex_compare, UU_LIST_POOL_DEBUG);
341 342 assert(graph_vertex_pool != NULL);
342 343
343 344 (void) pthread_mutex_init(&dgraph_lock, &mutex_attrs);
344 345 (void) pthread_mutex_init(&single_user_thread_lock, &mutex_attrs);
345 346 dgraph = startd_list_create(graph_vertex_pool, NULL, UU_LIST_SORTED);
346 347 assert(dgraph != NULL);
347 348
348 349 if (!st->st_initial)
349 350 current_runlevel = utmpx_get_runlevel();
350 351
351 352 log_framework(LOG_DEBUG, "Initialized graph\n");
352 353 }
353 354
354 355 static graph_vertex_t *
355 356 vertex_get_by_name(const char *name)
356 357 {
357 358 int id;
358 359
359 360 assert(MUTEX_HELD(&dgraph_lock));
360 361
361 362 id = dict_lookup_byname(name);
362 363 if (id == -1)
363 364 return (NULL);
364 365
365 366 return (uu_list_find(dgraph, &id, NULL, NULL));
366 367 }
367 368
368 369 static graph_vertex_t *
369 370 vertex_get_by_id(int id)
370 371 {
371 372 assert(MUTEX_HELD(&dgraph_lock));
372 373
373 374 if (id == -1)
374 375 return (NULL);
375 376
376 377 return (uu_list_find(dgraph, &id, NULL, NULL));
377 378 }
378 379
379 380 /*
380 381 * Creates a new vertex with the given name, adds it to the graph, and returns
381 382 * a pointer to it. The graph lock must be held by this thread on entry.
382 383 */
383 384 static graph_vertex_t *
384 385 graph_add_vertex(const char *name)
385 386 {
386 387 int id;
387 388 graph_vertex_t *v;
388 389 void *p;
389 390 uu_list_index_t idx;
390 391
391 392 assert(MUTEX_HELD(&dgraph_lock));
392 393
393 394 id = dict_insert(name);
394 395
395 396 v = startd_zalloc(sizeof (*v));
396 397
397 398 v->gv_id = id;
398 399
399 400 v->gv_name = startd_alloc(strlen(name) + 1);
400 401 (void) strcpy(v->gv_name, name);
401 402
402 403 v->gv_dependencies = startd_list_create(graph_edge_pool, v, 0);
403 404 v->gv_dependents = startd_list_create(graph_edge_pool, v, 0);
404 405
405 406 p = uu_list_find(dgraph, &id, NULL, &idx);
406 407 assert(p == NULL);
407 408
408 409 uu_list_node_init(v, &v->gv_link, graph_vertex_pool);
409 410 uu_list_insert(dgraph, v, idx);
410 411
411 412 return (v);
412 413 }
413 414
414 415 /*
415 416 * Removes v from the graph and frees it. The graph should be locked by this
416 417 * thread, and v should have no edges associated with it.
417 418 */
418 419 static void
419 420 graph_remove_vertex(graph_vertex_t *v)
420 421 {
421 422 assert(MUTEX_HELD(&dgraph_lock));
422 423
423 424 assert(uu_list_numnodes(v->gv_dependencies) == 0);
424 425 assert(uu_list_numnodes(v->gv_dependents) == 0);
425 426 assert(v->gv_refs == 0);
426 427
427 428 startd_free(v->gv_name, strlen(v->gv_name) + 1);
428 429 uu_list_destroy(v->gv_dependencies);
429 430 uu_list_destroy(v->gv_dependents);
430 431 uu_list_remove(dgraph, v);
431 432
432 433 startd_free(v, sizeof (graph_vertex_t));
433 434 }
434 435
435 436 static void
436 437 graph_add_edge(graph_vertex_t *fv, graph_vertex_t *tv)
437 438 {
438 439 graph_edge_t *e, *re;
439 440 int r;
440 441
441 442 assert(MUTEX_HELD(&dgraph_lock));
442 443
443 444 e = startd_alloc(sizeof (graph_edge_t));
444 445 re = startd_alloc(sizeof (graph_edge_t));
445 446
446 447 e->ge_parent = fv;
447 448 e->ge_vertex = tv;
448 449
449 450 re->ge_parent = tv;
450 451 re->ge_vertex = fv;
451 452
452 453 uu_list_node_init(e, &e->ge_link, graph_edge_pool);
453 454 r = uu_list_insert_before(fv->gv_dependencies, NULL, e);
454 455 assert(r == 0);
455 456
456 457 uu_list_node_init(re, &re->ge_link, graph_edge_pool);
457 458 r = uu_list_insert_before(tv->gv_dependents, NULL, re);
458 459 assert(r == 0);
459 460 }
460 461
461 462 static void
462 463 graph_remove_edge(graph_vertex_t *v, graph_vertex_t *dv)
463 464 {
464 465 graph_edge_t *e;
465 466
466 467 for (e = uu_list_first(v->gv_dependencies);
467 468 e != NULL;
468 469 e = uu_list_next(v->gv_dependencies, e)) {
469 470 if (e->ge_vertex == dv) {
470 471 uu_list_remove(v->gv_dependencies, e);
471 472 startd_free(e, sizeof (graph_edge_t));
472 473 break;
473 474 }
474 475 }
475 476
476 477 for (e = uu_list_first(dv->gv_dependents);
477 478 e != NULL;
478 479 e = uu_list_next(dv->gv_dependents, e)) {
479 480 if (e->ge_vertex == v) {
480 481 uu_list_remove(dv->gv_dependents, e);
481 482 startd_free(e, sizeof (graph_edge_t));
482 483 break;
483 484 }
484 485 }
485 486 }
486 487
487 488 static void
488 489 remove_inst_vertex(graph_vertex_t *v)
489 490 {
490 491 graph_edge_t *e;
491 492 graph_vertex_t *sv;
492 493 int i;
493 494
494 495 assert(MUTEX_HELD(&dgraph_lock));
495 496 assert(uu_list_numnodes(v->gv_dependents) == 1);
496 497 assert(uu_list_numnodes(v->gv_dependencies) == 0);
497 498 assert(v->gv_refs == 0);
498 499 assert((v->gv_flags & GV_CONFIGURED) == 0);
499 500
500 501 e = uu_list_first(v->gv_dependents);
501 502 sv = e->ge_vertex;
502 503 graph_remove_edge(sv, v);
503 504
504 505 for (i = 0; up_svcs[i] != NULL; ++i) {
505 506 if (up_svcs_p[i] == v)
506 507 up_svcs_p[i] = NULL;
507 508 }
508 509
509 510 if (manifest_import_p == v)
510 511 manifest_import_p = NULL;
511 512
512 513 graph_remove_vertex(v);
513 514
514 515 if (uu_list_numnodes(sv->gv_dependencies) == 0 &&
515 516 uu_list_numnodes(sv->gv_dependents) == 0 &&
516 517 sv->gv_refs == 0)
517 518 graph_remove_vertex(sv);
518 519 }
519 520
520 521 static void
521 522 graph_walk_dependents(graph_vertex_t *v, void (*func)(graph_vertex_t *, void *),
522 523 void *arg)
523 524 {
524 525 graph_edge_t *e;
525 526
526 527 for (e = uu_list_first(v->gv_dependents);
527 528 e != NULL;
528 529 e = uu_list_next(v->gv_dependents, e))
529 530 func(e->ge_vertex, arg);
530 531 }
531 532
532 533 static void
533 534 graph_walk_dependencies(graph_vertex_t *v, void (*func)(graph_vertex_t *,
534 535 void *), void *arg)
535 536 {
536 537 graph_edge_t *e;
537 538
538 539 assert(MUTEX_HELD(&dgraph_lock));
539 540
540 541 for (e = uu_list_first(v->gv_dependencies);
541 542 e != NULL;
542 543 e = uu_list_next(v->gv_dependencies, e)) {
543 544
544 545 func(e->ge_vertex, arg);
545 546 }
546 547 }
547 548
548 549 /*
549 550 * Generic graph walking function.
550 551 *
551 552 * Given a vertex, this function will walk either dependencies
552 553 * (WALK_DEPENDENCIES) or dependents (WALK_DEPENDENTS) of a vertex recursively
553 554 * for the entire graph. It will avoid cycles and never visit the same vertex
554 555 * twice.
555 556 *
556 557 * We avoid traversing exclusion dependencies, because they are allowed to
557 558 * create cycles in the graph. When propagating satisfiability, there is no
558 559 * need to walk exclusion dependencies because exclude_all_satisfied() doesn't
559 560 * test for satisfiability.
560 561 *
561 562 * The walker takes two callbacks. The first is called before examining the
562 563 * dependents of each vertex. The second is called on each vertex after
563 564 * examining its dependents. This allows is_path_to() to construct a path only
564 565 * after the target vertex has been found.
565 566 */
566 567 typedef enum {
567 568 WALK_DEPENDENTS,
568 569 WALK_DEPENDENCIES
569 570 } graph_walk_dir_t;
570 571
571 572 typedef int (*graph_walk_cb_t)(graph_vertex_t *, void *);
572 573
573 574 typedef struct graph_walk_info {
574 575 graph_walk_dir_t gi_dir;
575 576 uchar_t *gi_visited; /* vertex bitmap */
576 577 int (*gi_pre)(graph_vertex_t *, void *);
577 578 void (*gi_post)(graph_vertex_t *, void *);
578 579 void *gi_arg; /* callback arg */
579 580 int gi_ret; /* return value */
580 581 } graph_walk_info_t;
581 582
582 583 static int
583 584 graph_walk_recurse(graph_edge_t *e, graph_walk_info_t *gip)
584 585 {
585 586 uu_list_t *list;
586 587 int r;
587 588 graph_vertex_t *v = e->ge_vertex;
588 589 int i;
589 590 uint_t b;
590 591
591 592 i = v->gv_id / 8;
592 593 b = 1 << (v->gv_id % 8);
593 594
594 595 /*
595 596 * Check to see if we've visited this vertex already.
596 597 */
597 598 if (gip->gi_visited[i] & b)
598 599 return (UU_WALK_NEXT);
599 600
600 601 gip->gi_visited[i] |= b;
601 602
602 603 /*
603 604 * Don't follow exclusions.
604 605 */
605 606 if (v->gv_type == GVT_GROUP && v->gv_depgroup == DEPGRP_EXCLUDE_ALL)
606 607 return (UU_WALK_NEXT);
607 608
608 609 /*
609 610 * Call pre-visit callback. If this doesn't terminate the walk,
610 611 * continue search.
611 612 */
612 613 if ((gip->gi_ret = gip->gi_pre(v, gip->gi_arg)) == UU_WALK_NEXT) {
613 614 /*
614 615 * Recurse using appropriate list.
615 616 */
616 617 if (gip->gi_dir == WALK_DEPENDENTS)
617 618 list = v->gv_dependents;
618 619 else
619 620 list = v->gv_dependencies;
620 621
621 622 r = uu_list_walk(list, (uu_walk_fn_t *)graph_walk_recurse,
622 623 gip, 0);
623 624 assert(r == 0);
624 625 }
625 626
626 627 /*
627 628 * Callbacks must return either UU_WALK_NEXT or UU_WALK_DONE.
628 629 */
629 630 assert(gip->gi_ret == UU_WALK_NEXT || gip->gi_ret == UU_WALK_DONE);
630 631
631 632 /*
632 633 * If given a post-callback, call the function for every vertex.
633 634 */
634 635 if (gip->gi_post != NULL)
635 636 (void) gip->gi_post(v, gip->gi_arg);
636 637
637 638 /*
638 639 * Preserve the callback's return value. If the callback returns
639 640 * UU_WALK_DONE, then we propagate that to the caller in order to
640 641 * terminate the walk.
641 642 */
642 643 return (gip->gi_ret);
643 644 }
644 645
645 646 static void
646 647 graph_walk(graph_vertex_t *v, graph_walk_dir_t dir,
647 648 int (*pre)(graph_vertex_t *, void *),
648 649 void (*post)(graph_vertex_t *, void *), void *arg)
649 650 {
650 651 graph_walk_info_t gi;
651 652 graph_edge_t fake;
652 653 size_t sz = dictionary->dict_new_id / 8 + 1;
653 654
654 655 gi.gi_visited = startd_zalloc(sz);
655 656 gi.gi_pre = pre;
656 657 gi.gi_post = post;
657 658 gi.gi_arg = arg;
658 659 gi.gi_dir = dir;
659 660 gi.gi_ret = 0;
660 661
661 662 /*
662 663 * Fake up an edge for the first iteration
663 664 */
664 665 fake.ge_vertex = v;
665 666 (void) graph_walk_recurse(&fake, &gi);
666 667
667 668 startd_free(gi.gi_visited, sz);
668 669 }
669 670
670 671 typedef struct child_search {
671 672 int id; /* id of vertex to look for */
672 673 uint_t depth; /* recursion depth */
673 674 /*
674 675 * While the vertex is not found, path is NULL. After the search, if
675 676 * the vertex was found then path should point to a -1-terminated
676 677 * array of vertex id's which constitute the path to the vertex.
677 678 */
678 679 int *path;
679 680 } child_search_t;
680 681
681 682 static int
682 683 child_pre(graph_vertex_t *v, void *arg)
683 684 {
684 685 child_search_t *cs = arg;
685 686
686 687 cs->depth++;
687 688
688 689 if (v->gv_id == cs->id) {
689 690 cs->path = startd_alloc((cs->depth + 1) * sizeof (int));
690 691 cs->path[cs->depth] = -1;
691 692 return (UU_WALK_DONE);
692 693 }
693 694
694 695 return (UU_WALK_NEXT);
695 696 }
696 697
697 698 static void
698 699 child_post(graph_vertex_t *v, void *arg)
699 700 {
700 701 child_search_t *cs = arg;
701 702
702 703 cs->depth--;
703 704
704 705 if (cs->path != NULL)
705 706 cs->path[cs->depth] = v->gv_id;
706 707 }
707 708
708 709 /*
709 710 * Look for a path from from to to. If one exists, returns a pointer to
710 711 * a NULL-terminated array of pointers to the vertices along the path. If
711 712 * there is no path, returns NULL.
712 713 */
713 714 static int *
714 715 is_path_to(graph_vertex_t *from, graph_vertex_t *to)
715 716 {
716 717 child_search_t cs;
717 718
718 719 cs.id = to->gv_id;
719 720 cs.depth = 0;
720 721 cs.path = NULL;
721 722
722 723 graph_walk(from, WALK_DEPENDENCIES, child_pre, child_post, &cs);
723 724
724 725 return (cs.path);
725 726 }
726 727
727 728 /*
728 729 * Given an array of int's as returned by is_path_to, allocates a string of
729 730 * their names joined by newlines. Returns the size of the allocated buffer
730 731 * in *sz and frees path.
731 732 */
732 733 static void
733 734 path_to_str(int *path, char **cpp, size_t *sz)
734 735 {
735 736 int i;
736 737 graph_vertex_t *v;
737 738 size_t allocd, new_allocd;
738 739 char *new, *name;
739 740
740 741 assert(MUTEX_HELD(&dgraph_lock));
741 742 assert(path[0] != -1);
742 743
743 744 allocd = 1;
744 745 *cpp = startd_alloc(1);
745 746 (*cpp)[0] = '\0';
746 747
747 748 for (i = 0; path[i] != -1; ++i) {
748 749 name = NULL;
749 750
750 751 v = vertex_get_by_id(path[i]);
751 752
752 753 if (v == NULL)
753 754 name = "<deleted>";
754 755 else if (v->gv_type == GVT_INST || v->gv_type == GVT_SVC)
755 756 name = v->gv_name;
756 757
757 758 if (name != NULL) {
758 759 new_allocd = allocd + strlen(name) + 1;
759 760 new = startd_alloc(new_allocd);
760 761 (void) strcpy(new, *cpp);
761 762 (void) strcat(new, name);
762 763 (void) strcat(new, "\n");
763 764
764 765 startd_free(*cpp, allocd);
765 766
766 767 *cpp = new;
767 768 allocd = new_allocd;
768 769 }
769 770 }
770 771
771 772 startd_free(path, sizeof (int) * (i + 1));
772 773
773 774 *sz = allocd;
774 775 }
775 776
776 777
777 778 /*
778 779 * This function along with run_sulogin() implements an exclusion relationship
779 780 * between system/console-login and sulogin. run_sulogin() will fail if
780 781 * system/console-login is online, and the graph engine should call
781 782 * graph_clogin_start() to bring system/console-login online, which defers the
782 783 * start if sulogin is running.
783 784 */
784 785 static void
785 786 graph_clogin_start(graph_vertex_t *v)
786 787 {
787 788 assert(MUTEX_HELD(&dgraph_lock));
788 789
789 790 if (sulogin_running)
790 791 console_login_ready = B_TRUE;
791 792 else
792 793 vertex_send_event(v, RESTARTER_EVENT_TYPE_START);
793 794 }
794 795
795 796 static void
796 797 graph_su_start(graph_vertex_t *v)
797 798 {
798 799 /*
799 800 * /etc/inittab used to have the initial /sbin/rcS as a 'sysinit'
800 801 * entry with a runlevel of 'S', before jumping to the final
801 802 * target runlevel (as set in initdefault). We mimic that legacy
802 803 * behavior here.
803 804 */
804 805 utmpx_set_runlevel('S', '0', B_FALSE);
805 806 vertex_send_event(v, RESTARTER_EVENT_TYPE_START);
806 807 }
807 808
808 809 static void
809 810 graph_post_su_online(void)
810 811 {
811 812 graph_runlevel_changed('S', 1);
812 813 }
813 814
814 815 static void
815 816 graph_post_su_disable(void)
816 817 {
817 818 graph_runlevel_changed('S', 0);
818 819 }
819 820
820 821 static void
821 822 graph_post_mu_online(void)
822 823 {
823 824 graph_runlevel_changed('2', 1);
824 825 }
825 826
826 827 static void
827 828 graph_post_mu_disable(void)
828 829 {
829 830 graph_runlevel_changed('2', 0);
830 831 }
831 832
832 833 static void
833 834 graph_post_mus_online(void)
834 835 {
835 836 graph_runlevel_changed('3', 1);
836 837 }
837 838
838 839 static void
839 840 graph_post_mus_disable(void)
840 841 {
841 842 graph_runlevel_changed('3', 0);
842 843 }
843 844
844 845 static struct special_vertex_info {
845 846 const char *name;
846 847 void (*start_f)(graph_vertex_t *);
847 848 void (*post_online_f)(void);
848 849 void (*post_disable_f)(void);
849 850 } special_vertices[] = {
850 851 { CONSOLE_LOGIN_FMRI, graph_clogin_start, NULL, NULL },
851 852 { SCF_MILESTONE_SINGLE_USER, graph_su_start,
852 853 graph_post_su_online, graph_post_su_disable },
853 854 { SCF_MILESTONE_MULTI_USER, NULL,
854 855 graph_post_mu_online, graph_post_mu_disable },
855 856 { SCF_MILESTONE_MULTI_USER_SERVER, NULL,
856 857 graph_post_mus_online, graph_post_mus_disable },
857 858 { NULL },
858 859 };
859 860
860 861
861 862 void
862 863 vertex_send_event(graph_vertex_t *v, restarter_event_type_t e)
863 864 {
864 865 switch (e) {
865 866 case RESTARTER_EVENT_TYPE_ADD_INSTANCE:
866 867 assert(v->gv_state == RESTARTER_STATE_UNINIT);
867 868
868 869 MUTEX_LOCK(&st->st_load_lock);
869 870 st->st_load_instances++;
870 871 MUTEX_UNLOCK(&st->st_load_lock);
871 872 break;
872 873
873 874 case RESTARTER_EVENT_TYPE_ENABLE:
874 875 log_framework(LOG_DEBUG, "Enabling %s.\n", v->gv_name);
875 876 assert(v->gv_state == RESTARTER_STATE_UNINIT ||
876 877 v->gv_state == RESTARTER_STATE_DISABLED ||
877 878 v->gv_state == RESTARTER_STATE_MAINT);
878 879 break;
879 880
880 881 case RESTARTER_EVENT_TYPE_DISABLE:
881 882 case RESTARTER_EVENT_TYPE_ADMIN_DISABLE:
882 883 log_framework(LOG_DEBUG, "Disabling %s.\n", v->gv_name);
883 884 assert(v->gv_state != RESTARTER_STATE_DISABLED);
884 885 break;
885 886
886 887 case RESTARTER_EVENT_TYPE_STOP_RESET:
887 888 case RESTARTER_EVENT_TYPE_STOP:
888 889 log_framework(LOG_DEBUG, "Stopping %s.\n", v->gv_name);
889 890 assert(v->gv_state == RESTARTER_STATE_DEGRADED ||
890 891 v->gv_state == RESTARTER_STATE_ONLINE);
891 892 break;
892 893
893 894 case RESTARTER_EVENT_TYPE_START:
894 895 log_framework(LOG_DEBUG, "Starting %s.\n", v->gv_name);
895 896 assert(v->gv_state == RESTARTER_STATE_OFFLINE);
896 897 break;
897 898
898 899 case RESTARTER_EVENT_TYPE_REMOVE_INSTANCE:
899 900 case RESTARTER_EVENT_TYPE_ADMIN_DEGRADED:
900 901 case RESTARTER_EVENT_TYPE_ADMIN_REFRESH:
901 902 case RESTARTER_EVENT_TYPE_ADMIN_RESTART:
902 903 case RESTARTER_EVENT_TYPE_ADMIN_MAINT_OFF:
903 904 case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON:
904 905 case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON_IMMEDIATE:
905 906 case RESTARTER_EVENT_TYPE_DEPENDENCY_CYCLE:
906 907 case RESTARTER_EVENT_TYPE_INVALID_DEPENDENCY:
907 908 break;
908 909
909 910 default:
910 911 #ifndef NDEBUG
911 912 uu_warn("%s:%d: Bad event %d.\n", __FILE__, __LINE__, e);
912 913 #endif
913 914 abort();
914 915 }
915 916
916 917 restarter_protocol_send_event(v->gv_name, v->gv_restarter_channel, e,
917 918 v->gv_reason);
918 919 }
919 920
920 921 static void
921 922 graph_unset_restarter(graph_vertex_t *v)
922 923 {
923 924 assert(MUTEX_HELD(&dgraph_lock));
924 925 assert(v->gv_flags & GV_CONFIGURED);
925 926
926 927 vertex_send_event(v, RESTARTER_EVENT_TYPE_REMOVE_INSTANCE);
927 928
928 929 if (v->gv_restarter_id != -1) {
929 930 graph_vertex_t *rv;
930 931
931 932 rv = vertex_get_by_id(v->gv_restarter_id);
932 933 graph_remove_edge(v, rv);
933 934 }
934 935
935 936 v->gv_restarter_id = -1;
936 937 v->gv_restarter_channel = NULL;
937 938 }
938 939
939 940 /*
940 941 * Return VERTEX_REMOVED when the vertex passed in argument is deleted from the
941 942 * dgraph otherwise return VERTEX_INUSE.
942 943 */
943 944 static int
944 945 free_if_unrefed(graph_vertex_t *v)
945 946 {
946 947 assert(MUTEX_HELD(&dgraph_lock));
947 948
948 949 if (v->gv_refs > 0)
949 950 return (VERTEX_INUSE);
950 951
951 952 if (v->gv_type == GVT_SVC &&
952 953 uu_list_numnodes(v->gv_dependents) == 0 &&
953 954 uu_list_numnodes(v->gv_dependencies) == 0) {
954 955 graph_remove_vertex(v);
955 956 return (VERTEX_REMOVED);
956 957 } else if (v->gv_type == GVT_INST &&
957 958 (v->gv_flags & GV_CONFIGURED) == 0 &&
958 959 uu_list_numnodes(v->gv_dependents) == 1 &&
959 960 uu_list_numnodes(v->gv_dependencies) == 0) {
960 961 remove_inst_vertex(v);
961 962 return (VERTEX_REMOVED);
962 963 }
963 964
964 965 return (VERTEX_INUSE);
965 966 }
966 967
967 968 static void
968 969 delete_depgroup(graph_vertex_t *v)
969 970 {
970 971 graph_edge_t *e;
971 972 graph_vertex_t *dv;
972 973
973 974 assert(MUTEX_HELD(&dgraph_lock));
974 975 assert(v->gv_type == GVT_GROUP);
975 976 assert(uu_list_numnodes(v->gv_dependents) == 0);
976 977
977 978 while ((e = uu_list_first(v->gv_dependencies)) != NULL) {
978 979 dv = e->ge_vertex;
979 980
980 981 graph_remove_edge(v, dv);
981 982
982 983 switch (dv->gv_type) {
983 984 case GVT_INST: /* instance dependency */
984 985 case GVT_SVC: /* service dependency */
985 986 (void) free_if_unrefed(dv);
986 987 break;
987 988
988 989 case GVT_FILE: /* file dependency */
989 990 assert(uu_list_numnodes(dv->gv_dependencies) == 0);
990 991 if (uu_list_numnodes(dv->gv_dependents) == 0)
991 992 graph_remove_vertex(dv);
992 993 break;
993 994
994 995 default:
995 996 #ifndef NDEBUG
996 997 uu_warn("%s:%d: Unexpected node type %d", __FILE__,
997 998 __LINE__, dv->gv_type);
998 999 #endif
999 1000 abort();
1000 1001 }
1001 1002 }
1002 1003
1003 1004 graph_remove_vertex(v);
1004 1005 }
1005 1006
1006 1007 static int
1007 1008 delete_instance_deps_cb(graph_edge_t *e, void **ptrs)
1008 1009 {
1009 1010 graph_vertex_t *v = ptrs[0];
1010 1011 boolean_t delete_restarter_dep = (boolean_t)ptrs[1];
1011 1012 graph_vertex_t *dv;
1012 1013
1013 1014 dv = e->ge_vertex;
1014 1015
1015 1016 /*
1016 1017 * We have four possibilities here:
1017 1018 * - GVT_INST: restarter
1018 1019 * - GVT_GROUP - GVT_INST: instance dependency
1019 1020 * - GVT_GROUP - GVT_SVC - GV_INST: service dependency
1020 1021 * - GVT_GROUP - GVT_FILE: file dependency
1021 1022 */
1022 1023 switch (dv->gv_type) {
1023 1024 case GVT_INST: /* restarter */
1024 1025 assert(dv->gv_id == v->gv_restarter_id);
1025 1026 if (delete_restarter_dep)
1026 1027 graph_remove_edge(v, dv);
1027 1028 break;
1028 1029
1029 1030 case GVT_GROUP: /* pg dependency */
1030 1031 graph_remove_edge(v, dv);
1031 1032 delete_depgroup(dv);
1032 1033 break;
1033 1034
1034 1035 case GVT_FILE:
1035 1036 /* These are currently not direct dependencies */
1036 1037
1037 1038 default:
1038 1039 #ifndef NDEBUG
1039 1040 uu_warn("%s:%d: Bad vertex type %d.\n", __FILE__, __LINE__,
1040 1041 dv->gv_type);
1041 1042 #endif
1042 1043 abort();
1043 1044 }
1044 1045
1045 1046 return (UU_WALK_NEXT);
1046 1047 }
1047 1048
1048 1049 static void
1049 1050 delete_instance_dependencies(graph_vertex_t *v, boolean_t delete_restarter_dep)
1050 1051 {
1051 1052 void *ptrs[2];
1052 1053 int r;
1053 1054
1054 1055 assert(MUTEX_HELD(&dgraph_lock));
1055 1056 assert(v->gv_type == GVT_INST);
1056 1057
1057 1058 ptrs[0] = v;
1058 1059 ptrs[1] = (void *)delete_restarter_dep;
1059 1060
1060 1061 r = uu_list_walk(v->gv_dependencies,
1061 1062 (uu_walk_fn_t *)delete_instance_deps_cb, &ptrs, UU_WALK_ROBUST);
1062 1063 assert(r == 0);
1063 1064 }
1064 1065
1065 1066 /*
1066 1067 * int graph_insert_vertex_unconfigured()
1067 1068 * Insert a vertex without sending any restarter events. If the vertex
1068 1069 * already exists or creation is successful, return a pointer to it in *vp.
1069 1070 *
1070 1071 * If type is not GVT_GROUP, dt can remain unset.
1071 1072 *
1072 1073 * Returns 0, EEXIST, or EINVAL if the arguments are invalid (i.e., fmri
1073 1074 * doesn't agree with type, or type doesn't agree with dt).
1074 1075 */
1075 1076 static int
1076 1077 graph_insert_vertex_unconfigured(const char *fmri, gv_type_t type,
1077 1078 depgroup_type_t dt, restarter_error_t rt, graph_vertex_t **vp)
1078 1079 {
1079 1080 int r;
1080 1081 int i;
1081 1082
1082 1083 assert(MUTEX_HELD(&dgraph_lock));
1083 1084
1084 1085 switch (type) {
1085 1086 case GVT_SVC:
1086 1087 case GVT_INST:
1087 1088 if (strncmp(fmri, "svc:", sizeof ("svc:") - 1) != 0)
1088 1089 return (EINVAL);
1089 1090 break;
1090 1091
1091 1092 case GVT_FILE:
1092 1093 if (strncmp(fmri, "file:", sizeof ("file:") - 1) != 0)
1093 1094 return (EINVAL);
1094 1095 break;
1095 1096
1096 1097 case GVT_GROUP:
1097 1098 if (dt <= 0 || rt < 0)
1098 1099 return (EINVAL);
1099 1100 break;
1100 1101
1101 1102 default:
1102 1103 #ifndef NDEBUG
1103 1104 uu_warn("%s:%d: Unknown type %d.\n", __FILE__, __LINE__, type);
1104 1105 #endif
1105 1106 abort();
1106 1107 }
1107 1108
1108 1109 *vp = vertex_get_by_name(fmri);
1109 1110 if (*vp != NULL)
1110 1111 return (EEXIST);
1111 1112
1112 1113 *vp = graph_add_vertex(fmri);
1113 1114
1114 1115 (*vp)->gv_type = type;
1115 1116 (*vp)->gv_depgroup = dt;
1116 1117 (*vp)->gv_restart = rt;
1117 1118
1118 1119 (*vp)->gv_flags = 0;
1119 1120 (*vp)->gv_state = RESTARTER_STATE_NONE;
1120 1121
1121 1122 for (i = 0; special_vertices[i].name != NULL; ++i) {
1122 1123 if (strcmp(fmri, special_vertices[i].name) == 0) {
1123 1124 (*vp)->gv_start_f = special_vertices[i].start_f;
1124 1125 (*vp)->gv_post_online_f =
1125 1126 special_vertices[i].post_online_f;
1126 1127 (*vp)->gv_post_disable_f =
1127 1128 special_vertices[i].post_disable_f;
1128 1129 break;
1129 1130 }
1130 1131 }
1131 1132
1132 1133 (*vp)->gv_restarter_id = -1;
1133 1134 (*vp)->gv_restarter_channel = 0;
1134 1135
1135 1136 if (type == GVT_INST) {
1136 1137 char *sfmri;
1137 1138 graph_vertex_t *sv;
1138 1139
1139 1140 sfmri = inst_fmri_to_svc_fmri(fmri);
1140 1141 sv = vertex_get_by_name(sfmri);
1141 1142 if (sv == NULL) {
1142 1143 r = graph_insert_vertex_unconfigured(sfmri, GVT_SVC, 0,
1143 1144 0, &sv);
1144 1145 assert(r == 0);
1145 1146 }
1146 1147 startd_free(sfmri, max_scf_fmri_size);
1147 1148
1148 1149 graph_add_edge(sv, *vp);
1149 1150 }
1150 1151
1151 1152 /*
1152 1153 * If this vertex is in the subgraph, mark it as so, for both
1153 1154 * GVT_INST and GVT_SERVICE verteces.
1154 1155 * A GVT_SERVICE vertex can only be in the subgraph if another instance
1155 1156 * depends on it, in which case it's already been added to the graph
1156 1157 * and marked as in the subgraph (by refresh_vertex()). If a
1157 1158 * GVT_SERVICE vertex was freshly added (by the code above), it means
1158 1159 * that it has no dependents, and cannot be in the subgraph.
1159 1160 * Regardless of this, we still check that gv_flags includes
1160 1161 * GV_INSUBGRAPH in the event that future behavior causes the above
1161 1162 * code to add a GVT_SERVICE vertex which should be in the subgraph.
1162 1163 */
1163 1164
1164 1165 (*vp)->gv_flags |= (should_be_in_subgraph(*vp)? GV_INSUBGRAPH : 0);
1165 1166
1166 1167 return (0);
1167 1168 }
1168 1169
1169 1170 /*
1170 1171 * Returns 0 on success or ELOOP if the dependency would create a cycle.
1171 1172 */
1172 1173 static int
1173 1174 graph_insert_dependency(graph_vertex_t *fv, graph_vertex_t *tv, int **pathp)
1174 1175 {
1175 1176 hrtime_t now;
1176 1177
1177 1178 assert(MUTEX_HELD(&dgraph_lock));
1178 1179
1179 1180 /* cycle detection */
1180 1181 now = gethrtime();
1181 1182
1182 1183 /* Don't follow exclusions. */
1183 1184 if (!(fv->gv_type == GVT_GROUP &&
1184 1185 fv->gv_depgroup == DEPGRP_EXCLUDE_ALL)) {
1185 1186 *pathp = is_path_to(tv, fv);
1186 1187 if (*pathp)
1187 1188 return (ELOOP);
1188 1189 }
1189 1190
1190 1191 dep_cycle_ns += gethrtime() - now;
1191 1192 ++dep_inserts;
1192 1193 now = gethrtime();
1193 1194
1194 1195 graph_add_edge(fv, tv);
1195 1196
1196 1197 dep_insert_ns += gethrtime() - now;
1197 1198
1198 1199 /* Check if the dependency adds the "to" vertex to the subgraph */
1199 1200 tv->gv_flags |= (should_be_in_subgraph(tv) ? GV_INSUBGRAPH : 0);
1200 1201
1201 1202 return (0);
1202 1203 }
1203 1204
1204 1205 static int
1205 1206 inst_running(graph_vertex_t *v)
1206 1207 {
1207 1208 assert(v->gv_type == GVT_INST);
1208 1209
1209 1210 if (v->gv_state == RESTARTER_STATE_ONLINE ||
1210 1211 v->gv_state == RESTARTER_STATE_DEGRADED)
1211 1212 return (1);
1212 1213
1213 1214 return (0);
1214 1215 }
1215 1216
1216 1217 /*
1217 1218 * The dependency evaluation functions return
1218 1219 * 1 - dependency satisfied
1219 1220 * 0 - dependency unsatisfied
1220 1221 * -1 - dependency unsatisfiable (without administrator intervention)
1221 1222 *
1222 1223 * The functions also take a boolean satbility argument. When true, the
1223 1224 * functions may recurse in order to determine satisfiability.
1224 1225 */
1225 1226 static int require_any_satisfied(graph_vertex_t *, boolean_t);
1226 1227 static int dependency_satisfied(graph_vertex_t *, boolean_t);
1227 1228
1228 1229 /*
1229 1230 * A require_all dependency is unsatisfied if any elements are unsatisfied. It
1230 1231 * is unsatisfiable if any elements are unsatisfiable.
1231 1232 */
1232 1233 static int
1233 1234 require_all_satisfied(graph_vertex_t *groupv, boolean_t satbility)
1234 1235 {
1235 1236 graph_edge_t *edge;
1236 1237 int i;
1237 1238 boolean_t any_unsatisfied;
1238 1239
1239 1240 if (uu_list_numnodes(groupv->gv_dependencies) == 0)
1240 1241 return (1);
1241 1242
1242 1243 any_unsatisfied = B_FALSE;
1243 1244
1244 1245 for (edge = uu_list_first(groupv->gv_dependencies);
1245 1246 edge != NULL;
1246 1247 edge = uu_list_next(groupv->gv_dependencies, edge)) {
1247 1248 i = dependency_satisfied(edge->ge_vertex, satbility);
1248 1249 if (i == 1)
1249 1250 continue;
1250 1251
1251 1252 log_framework2(LOG_DEBUG, DEBUG_DEPENDENCIES,
1252 1253 "require_all(%s): %s is unsatisfi%s.\n", groupv->gv_name,
1253 1254 edge->ge_vertex->gv_name, i == 0 ? "ed" : "able");
1254 1255
1255 1256 if (!satbility)
1256 1257 return (0);
1257 1258
1258 1259 if (i == -1)
1259 1260 return (-1);
1260 1261
1261 1262 any_unsatisfied = B_TRUE;
1262 1263 }
1263 1264
1264 1265 return (any_unsatisfied ? 0 : 1);
1265 1266 }
1266 1267
1267 1268 /*
1268 1269 * A require_any dependency is satisfied if any element is satisfied. It is
1269 1270 * satisfiable if any element is satisfiable.
1270 1271 */
1271 1272 static int
1272 1273 require_any_satisfied(graph_vertex_t *groupv, boolean_t satbility)
1273 1274 {
1274 1275 graph_edge_t *edge;
1275 1276 int s;
1276 1277 boolean_t satisfiable;
1277 1278
1278 1279 if (uu_list_numnodes(groupv->gv_dependencies) == 0)
1279 1280 return (1);
1280 1281
1281 1282 satisfiable = B_FALSE;
1282 1283
1283 1284 for (edge = uu_list_first(groupv->gv_dependencies);
1284 1285 edge != NULL;
1285 1286 edge = uu_list_next(groupv->gv_dependencies, edge)) {
1286 1287 s = dependency_satisfied(edge->ge_vertex, satbility);
1287 1288
1288 1289 if (s == 1)
1289 1290 return (1);
|
↓ open down ↓ |
1255 lines elided |
↑ open up ↑ |
1290 1291
1291 1292 log_framework2(LOG_DEBUG, DEBUG_DEPENDENCIES,
1292 1293 "require_any(%s): %s is unsatisfi%s.\n",
1293 1294 groupv->gv_name, edge->ge_vertex->gv_name,
1294 1295 s == 0 ? "ed" : "able");
1295 1296
1296 1297 if (satbility && s == 0)
1297 1298 satisfiable = B_TRUE;
1298 1299 }
1299 1300
1300 - return (!satbility || satisfiable ? 0 : -1);
1301 + if (!satbility)
1302 + return (0);
1303 +
1304 + return (satisfiable ? 0 : -1);
1301 1305 }
1302 1306
1303 1307 /*
1304 1308 * An optional_all dependency only considers elements which are configured,
1305 1309 * enabled, and not in maintenance. If any are unsatisfied, then the dependency
1306 1310 * is unsatisfied.
1307 1311 *
1308 1312 * Offline dependencies which are waiting for a dependency to come online are
1309 1313 * unsatisfied. Offline dependences which cannot possibly come online
1310 1314 * (unsatisfiable) are always considered satisfied.
1311 1315 */
1312 1316 static int
1313 1317 optional_all_satisfied(graph_vertex_t *groupv, boolean_t satbility)
1314 1318 {
1315 1319 graph_edge_t *edge;
1316 1320 graph_vertex_t *v;
1317 1321 boolean_t any_qualified;
1318 1322 boolean_t any_unsatisfied;
1319 1323 int i;
1320 1324
1321 1325 any_qualified = B_FALSE;
1322 1326 any_unsatisfied = B_FALSE;
1323 1327
1324 1328 for (edge = uu_list_first(groupv->gv_dependencies);
1325 1329 edge != NULL;
1326 1330 edge = uu_list_next(groupv->gv_dependencies, edge)) {
1327 1331 v = edge->ge_vertex;
1328 1332
1329 1333 switch (v->gv_type) {
1330 1334 case GVT_INST:
1331 1335 /* Skip missing or disabled instances */
1332 1336 if ((v->gv_flags & (GV_CONFIGURED | GV_ENABLED)) !=
1333 1337 (GV_CONFIGURED | GV_ENABLED))
1334 1338 continue;
1335 1339
1336 1340 if (v->gv_state == RESTARTER_STATE_MAINT)
1337 1341 continue;
1338 1342
1339 1343 if (v->gv_flags & GV_TOOFFLINE)
1340 1344 continue;
1341 1345
1342 1346 any_qualified = B_TRUE;
1343 1347 if (v->gv_state == RESTARTER_STATE_OFFLINE) {
1344 1348 /*
1345 1349 * For offline dependencies, treat unsatisfiable
1346 1350 * as satisfied.
1347 1351 */
1348 1352 i = dependency_satisfied(v, B_TRUE);
1349 1353 if (i == -1)
1350 1354 i = 1;
1351 1355 } else if (v->gv_state == RESTARTER_STATE_DISABLED) {
1352 1356 /*
1353 1357 * The service is enabled, but hasn't
1354 1358 * transitioned out of disabled yet. Treat it
1355 1359 * as unsatisfied (not unsatisfiable).
1356 1360 */
1357 1361 i = 0;
1358 1362 } else {
1359 1363 i = dependency_satisfied(v, satbility);
1360 1364 }
1361 1365 break;
1362 1366
1363 1367 case GVT_FILE:
1364 1368 any_qualified = B_TRUE;
1365 1369 i = dependency_satisfied(v, satbility);
1366 1370
1367 1371 break;
1368 1372
1369 1373 case GVT_SVC: {
1370 1374 boolean_t svc_any_qualified;
1371 1375 boolean_t svc_satisfied;
1372 1376 boolean_t svc_satisfiable;
1373 1377 graph_vertex_t *v2;
1374 1378 graph_edge_t *e2;
1375 1379
1376 1380 svc_any_qualified = B_FALSE;
1377 1381 svc_satisfied = B_FALSE;
1378 1382 svc_satisfiable = B_FALSE;
1379 1383
1380 1384 for (e2 = uu_list_first(v->gv_dependencies);
1381 1385 e2 != NULL;
1382 1386 e2 = uu_list_next(v->gv_dependencies, e2)) {
1383 1387 v2 = e2->ge_vertex;
1384 1388 assert(v2->gv_type == GVT_INST);
1385 1389
1386 1390 if ((v2->gv_flags &
1387 1391 (GV_CONFIGURED | GV_ENABLED)) !=
1388 1392 (GV_CONFIGURED | GV_ENABLED))
1389 1393 continue;
1390 1394
1391 1395 if (v2->gv_state == RESTARTER_STATE_MAINT)
1392 1396 continue;
1393 1397
1394 1398 if (v2->gv_flags & GV_TOOFFLINE)
1395 1399 continue;
1396 1400
1397 1401 svc_any_qualified = B_TRUE;
1398 1402
1399 1403 if (v2->gv_state == RESTARTER_STATE_OFFLINE) {
1400 1404 /*
1401 1405 * For offline dependencies, treat
1402 1406 * unsatisfiable as satisfied.
1403 1407 */
1404 1408 i = dependency_satisfied(v2, B_TRUE);
1405 1409 if (i == -1)
1406 1410 i = 1;
1407 1411 } else if (v2->gv_state ==
1408 1412 RESTARTER_STATE_DISABLED) {
1409 1413 i = 0;
1410 1414 } else {
1411 1415 i = dependency_satisfied(v2, satbility);
1412 1416 }
1413 1417
1414 1418 if (i == 1) {
1415 1419 svc_satisfied = B_TRUE;
1416 1420 break;
1417 1421 }
1418 1422 if (i == 0)
1419 1423 svc_satisfiable = B_TRUE;
1420 1424 }
1421 1425
1422 1426 if (!svc_any_qualified)
1423 1427 continue;
1424 1428 any_qualified = B_TRUE;
1425 1429 if (svc_satisfied) {
1426 1430 i = 1;
1427 1431 } else if (svc_satisfiable) {
1428 1432 i = 0;
1429 1433 } else {
1430 1434 i = -1;
1431 1435 }
1432 1436 break;
1433 1437 }
1434 1438
1435 1439 case GVT_GROUP:
1436 1440 default:
1437 1441 #ifndef NDEBUG
1438 1442 uu_warn("%s:%d: Unexpected vertex type %d.\n", __FILE__,
1439 1443 __LINE__, v->gv_type);
1440 1444 #endif
1441 1445 abort();
1442 1446 }
1443 1447
1444 1448 if (i == 1)
1445 1449 continue;
1446 1450
1447 1451 log_framework2(LOG_DEBUG, DEBUG_DEPENDENCIES,
1448 1452 "optional_all(%s): %s is unsatisfi%s.\n", groupv->gv_name,
1449 1453 v->gv_name, i == 0 ? "ed" : "able");
1450 1454
1451 1455 if (!satbility)
1452 1456 return (0);
1453 1457 if (i == -1)
1454 1458 return (-1);
1455 1459 any_unsatisfied = B_TRUE;
1456 1460 }
1457 1461
1458 1462 if (!any_qualified)
1459 1463 return (1);
1460 1464
1461 1465 return (any_unsatisfied ? 0 : 1);
1462 1466 }
1463 1467
1464 1468 /*
1465 1469 * An exclude_all dependency is unsatisfied if any non-service element is
1466 1470 * satisfied or any service instance which is configured, enabled, and not in
1467 1471 * maintenance is satisfied. Usually when unsatisfied, it is also
1468 1472 * unsatisfiable.
1469 1473 */
1470 1474 #define LOG_EXCLUDE(u, v) \
1471 1475 log_framework2(LOG_DEBUG, DEBUG_DEPENDENCIES, \
1472 1476 "exclude_all(%s): %s is satisfied.\n", \
1473 1477 (u)->gv_name, (v)->gv_name)
1474 1478
1475 1479 /* ARGSUSED */
1476 1480 static int
1477 1481 exclude_all_satisfied(graph_vertex_t *groupv, boolean_t satbility)
1478 1482 {
1479 1483 graph_edge_t *edge, *e2;
1480 1484 graph_vertex_t *v, *v2;
1481 1485
1482 1486 for (edge = uu_list_first(groupv->gv_dependencies);
1483 1487 edge != NULL;
1484 1488 edge = uu_list_next(groupv->gv_dependencies, edge)) {
1485 1489 v = edge->ge_vertex;
1486 1490
1487 1491 switch (v->gv_type) {
1488 1492 case GVT_INST:
1489 1493 if ((v->gv_flags & GV_CONFIGURED) == 0)
1490 1494 continue;
1491 1495
1492 1496 switch (v->gv_state) {
1493 1497 case RESTARTER_STATE_ONLINE:
1494 1498 case RESTARTER_STATE_DEGRADED:
1495 1499 LOG_EXCLUDE(groupv, v);
1496 1500 return (v->gv_flags & GV_ENABLED ? -1 : 0);
1497 1501
1498 1502 case RESTARTER_STATE_OFFLINE:
1499 1503 case RESTARTER_STATE_UNINIT:
1500 1504 LOG_EXCLUDE(groupv, v);
1501 1505 return (0);
1502 1506
1503 1507 case RESTARTER_STATE_DISABLED:
1504 1508 case RESTARTER_STATE_MAINT:
1505 1509 continue;
1506 1510
1507 1511 default:
1508 1512 #ifndef NDEBUG
1509 1513 uu_warn("%s:%d: Unexpected vertex state %d.\n",
1510 1514 __FILE__, __LINE__, v->gv_state);
1511 1515 #endif
1512 1516 abort();
1513 1517 }
1514 1518 /* NOTREACHED */
1515 1519
1516 1520 case GVT_SVC:
1517 1521 break;
1518 1522
1519 1523 case GVT_FILE:
1520 1524 if (!file_ready(v))
1521 1525 continue;
1522 1526 LOG_EXCLUDE(groupv, v);
1523 1527 return (-1);
1524 1528
1525 1529 case GVT_GROUP:
1526 1530 default:
1527 1531 #ifndef NDEBUG
1528 1532 uu_warn("%s:%d: Unexpected vertex type %d.\n", __FILE__,
1529 1533 __LINE__, v->gv_type);
1530 1534 #endif
1531 1535 abort();
1532 1536 }
1533 1537
1534 1538 /* v represents a service */
1535 1539 if (uu_list_numnodes(v->gv_dependencies) == 0)
1536 1540 continue;
1537 1541
1538 1542 for (e2 = uu_list_first(v->gv_dependencies);
1539 1543 e2 != NULL;
1540 1544 e2 = uu_list_next(v->gv_dependencies, e2)) {
1541 1545 v2 = e2->ge_vertex;
1542 1546 assert(v2->gv_type == GVT_INST);
1543 1547
1544 1548 if ((v2->gv_flags & GV_CONFIGURED) == 0)
1545 1549 continue;
1546 1550
1547 1551 switch (v2->gv_state) {
1548 1552 case RESTARTER_STATE_ONLINE:
1549 1553 case RESTARTER_STATE_DEGRADED:
1550 1554 LOG_EXCLUDE(groupv, v2);
1551 1555 return (v2->gv_flags & GV_ENABLED ? -1 : 0);
1552 1556
1553 1557 case RESTARTER_STATE_OFFLINE:
1554 1558 case RESTARTER_STATE_UNINIT:
1555 1559 LOG_EXCLUDE(groupv, v2);
1556 1560 return (0);
1557 1561
1558 1562 case RESTARTER_STATE_DISABLED:
1559 1563 case RESTARTER_STATE_MAINT:
1560 1564 continue;
1561 1565
1562 1566 default:
1563 1567 #ifndef NDEBUG
1564 1568 uu_warn("%s:%d: Unexpected vertex type %d.\n",
1565 1569 __FILE__, __LINE__, v2->gv_type);
1566 1570 #endif
1567 1571 abort();
1568 1572 }
1569 1573 }
1570 1574 }
1571 1575
1572 1576 return (1);
1573 1577 }
1574 1578
1575 1579 /*
1576 1580 * int instance_satisfied()
1577 1581 * Determine if all the dependencies are satisfied for the supplied instance
1578 1582 * vertex. Return 1 if they are, 0 if they aren't, and -1 if they won't be
1579 1583 * without administrator intervention.
1580 1584 */
1581 1585 static int
1582 1586 instance_satisfied(graph_vertex_t *v, boolean_t satbility)
1583 1587 {
1584 1588 assert(v->gv_type == GVT_INST);
1585 1589 assert(!inst_running(v));
1586 1590
1587 1591 return (require_all_satisfied(v, satbility));
1588 1592 }
1589 1593
1590 1594 /*
1591 1595 * Decide whether v can satisfy a dependency. v can either be a child of
1592 1596 * a group vertex, or of an instance vertex.
1593 1597 */
1594 1598 static int
1595 1599 dependency_satisfied(graph_vertex_t *v, boolean_t satbility)
1596 1600 {
1597 1601 switch (v->gv_type) {
1598 1602 case GVT_INST:
1599 1603 if ((v->gv_flags & GV_CONFIGURED) == 0) {
1600 1604 if (v->gv_flags & GV_DEATHROW) {
1601 1605 /*
1602 1606 * A dependency on an instance with GV_DEATHROW
1603 1607 * flag is always considered as satisfied.
1604 1608 */
1605 1609 return (1);
1606 1610 }
1607 1611 return (-1);
1608 1612 }
1609 1613
1610 1614 /*
1611 1615 * Any vertex with the GV_TOOFFLINE flag set is guaranteed
1612 1616 * to have its dependencies unsatisfiable.
1613 1617 */
1614 1618 if (v->gv_flags & GV_TOOFFLINE)
1615 1619 return (-1);
1616 1620
1617 1621 switch (v->gv_state) {
1618 1622 case RESTARTER_STATE_ONLINE:
1619 1623 case RESTARTER_STATE_DEGRADED:
1620 1624 return (1);
1621 1625
1622 1626 case RESTARTER_STATE_OFFLINE:
1623 1627 if (!satbility)
1624 1628 return (0);
1625 1629 return (instance_satisfied(v, satbility) != -1 ?
1626 1630 0 : -1);
1627 1631
1628 1632 case RESTARTER_STATE_DISABLED:
1629 1633 case RESTARTER_STATE_MAINT:
1630 1634 return (-1);
1631 1635
1632 1636 case RESTARTER_STATE_UNINIT:
1633 1637 return (0);
1634 1638
1635 1639 default:
1636 1640 #ifndef NDEBUG
1637 1641 uu_warn("%s:%d: Unexpected vertex state %d.\n",
1638 1642 __FILE__, __LINE__, v->gv_state);
1639 1643 #endif
1640 1644 abort();
1641 1645 /* NOTREACHED */
1642 1646 }
1643 1647
1644 1648 case GVT_SVC:
1645 1649 if (uu_list_numnodes(v->gv_dependencies) == 0)
1646 1650 return (-1);
1647 1651 return (require_any_satisfied(v, satbility));
1648 1652
1649 1653 case GVT_FILE:
1650 1654 /* i.e., we assume files will not be automatically generated */
1651 1655 return (file_ready(v) ? 1 : -1);
1652 1656
1653 1657 case GVT_GROUP:
1654 1658 break;
1655 1659
1656 1660 default:
1657 1661 #ifndef NDEBUG
1658 1662 uu_warn("%s:%d: Unexpected node type %d.\n", __FILE__, __LINE__,
1659 1663 v->gv_type);
1660 1664 #endif
1661 1665 abort();
1662 1666 /* NOTREACHED */
1663 1667 }
1664 1668
1665 1669 switch (v->gv_depgroup) {
1666 1670 case DEPGRP_REQUIRE_ANY:
1667 1671 return (require_any_satisfied(v, satbility));
1668 1672
1669 1673 case DEPGRP_REQUIRE_ALL:
1670 1674 return (require_all_satisfied(v, satbility));
1671 1675
1672 1676 case DEPGRP_OPTIONAL_ALL:
1673 1677 return (optional_all_satisfied(v, satbility));
1674 1678
1675 1679 case DEPGRP_EXCLUDE_ALL:
1676 1680 return (exclude_all_satisfied(v, satbility));
1677 1681
1678 1682 default:
1679 1683 #ifndef NDEBUG
1680 1684 uu_warn("%s:%d: Unknown dependency grouping %d.\n", __FILE__,
1681 1685 __LINE__, v->gv_depgroup);
1682 1686 #endif
1683 1687 abort();
1684 1688 }
1685 1689 }
1686 1690
1687 1691 void
1688 1692 graph_start_if_satisfied(graph_vertex_t *v)
1689 1693 {
1690 1694 if (v->gv_state == RESTARTER_STATE_OFFLINE &&
1691 1695 instance_satisfied(v, B_FALSE) == 1) {
1692 1696 if (v->gv_start_f == NULL)
1693 1697 vertex_send_event(v, RESTARTER_EVENT_TYPE_START);
1694 1698 else
1695 1699 v->gv_start_f(v);
1696 1700 }
1697 1701 }
1698 1702
1699 1703 /*
1700 1704 * propagate_satbility()
1701 1705 *
1702 1706 * This function is used when the given vertex changes state in such a way that
1703 1707 * one of its dependents may become unsatisfiable. This happens when an
1704 1708 * instance transitions between offline -> online, or from !running ->
1705 1709 * maintenance, as well as when an instance is removed from the graph.
1706 1710 *
1707 1711 * We have to walk all the dependents, since optional_all dependencies several
1708 1712 * levels up could become (un)satisfied, instead of unsatisfiable. For example,
1709 1713 *
1710 1714 * +-----+ optional_all +-----+ require_all +-----+
1711 1715 * | A |--------------->| B |-------------->| C |
1712 1716 * +-----+ +-----+ +-----+
1713 1717 *
1714 1718 * offline -> maintenance
1715 1719 *
1716 1720 * If C goes into maintenance, it's not enough simply to check B. Because A has
1717 1721 * an optional dependency, what was previously an unsatisfiable situation is now
1718 1722 * satisfied (B will never come online, even though its state hasn't changed).
1719 1723 *
1720 1724 * Note that it's not necessary to continue examining dependents after reaching
1721 1725 * an optional_all dependency. It's not possible for an optional_all dependency
1722 1726 * to change satisfiability without also coming online, in which case we get a
1723 1727 * start event and propagation continues naturally. However, it does no harm to
1724 1728 * continue propagating satisfiability (as it is a relatively rare event), and
1725 1729 * keeps the walker code simple and generic.
1726 1730 */
1727 1731 /*ARGSUSED*/
1728 1732 static int
1729 1733 satbility_cb(graph_vertex_t *v, void *arg)
1730 1734 {
1731 1735 if (v->gv_type == GVT_INST)
1732 1736 graph_start_if_satisfied(v);
1733 1737
1734 1738 return (UU_WALK_NEXT);
1735 1739 }
1736 1740
1737 1741 static void
1738 1742 propagate_satbility(graph_vertex_t *v)
1739 1743 {
1740 1744 graph_walk(v, WALK_DEPENDENTS, satbility_cb, NULL, NULL);
1741 1745 }
1742 1746
1743 1747 static void propagate_stop(graph_vertex_t *, void *);
1744 1748
1745 1749 /* ARGSUSED */
1746 1750 static void
1747 1751 propagate_start(graph_vertex_t *v, void *arg)
1748 1752 {
1749 1753 switch (v->gv_type) {
1750 1754 case GVT_INST:
1751 1755 graph_start_if_satisfied(v);
1752 1756 break;
1753 1757
1754 1758 case GVT_GROUP:
1755 1759 if (v->gv_depgroup == DEPGRP_EXCLUDE_ALL) {
1756 1760 graph_walk_dependents(v, propagate_stop,
1757 1761 (void *)RERR_RESTART);
1758 1762 break;
1759 1763 }
1760 1764 /* FALLTHROUGH */
1761 1765
1762 1766 case GVT_SVC:
1763 1767 graph_walk_dependents(v, propagate_start, NULL);
1764 1768 break;
1765 1769
1766 1770 case GVT_FILE:
1767 1771 #ifndef NDEBUG
1768 1772 uu_warn("%s:%d: propagate_start() encountered GVT_FILE.\n",
1769 1773 __FILE__, __LINE__);
1770 1774 #endif
1771 1775 abort();
1772 1776 /* NOTREACHED */
1773 1777
1774 1778 default:
1775 1779 #ifndef NDEBUG
1776 1780 uu_warn("%s:%d: Unknown vertex type %d.\n", __FILE__, __LINE__,
1777 1781 v->gv_type);
1778 1782 #endif
1779 1783 abort();
1780 1784 }
1781 1785 }
1782 1786
1783 1787 static void
1784 1788 propagate_stop(graph_vertex_t *v, void *arg)
1785 1789 {
1786 1790 graph_edge_t *e;
1787 1791 graph_vertex_t *svc;
1788 1792 restarter_error_t err = (restarter_error_t)arg;
1789 1793
1790 1794 switch (v->gv_type) {
1791 1795 case GVT_INST:
1792 1796 /* Restarter */
1793 1797 if (err > RERR_NONE && inst_running(v)) {
1794 1798 if (err == RERR_RESTART || err == RERR_REFRESH) {
1795 1799 vertex_send_event(v,
1796 1800 RESTARTER_EVENT_TYPE_STOP_RESET);
1797 1801 } else {
1798 1802 vertex_send_event(v, RESTARTER_EVENT_TYPE_STOP);
1799 1803 }
1800 1804 }
1801 1805 break;
1802 1806
1803 1807 case GVT_SVC:
1804 1808 graph_walk_dependents(v, propagate_stop, arg);
1805 1809 break;
1806 1810
1807 1811 case GVT_FILE:
1808 1812 #ifndef NDEBUG
1809 1813 uu_warn("%s:%d: propagate_stop() encountered GVT_FILE.\n",
1810 1814 __FILE__, __LINE__);
1811 1815 #endif
1812 1816 abort();
1813 1817 /* NOTREACHED */
1814 1818
1815 1819 case GVT_GROUP:
1816 1820 if (v->gv_depgroup == DEPGRP_EXCLUDE_ALL) {
1817 1821 graph_walk_dependents(v, propagate_start, NULL);
1818 1822 break;
1819 1823 }
1820 1824
1821 1825 if (err == RERR_NONE || err > v->gv_restart)
1822 1826 break;
1823 1827
1824 1828 assert(uu_list_numnodes(v->gv_dependents) == 1);
1825 1829 e = uu_list_first(v->gv_dependents);
1826 1830 svc = e->ge_vertex;
1827 1831
1828 1832 if (inst_running(svc)) {
1829 1833 if (err == RERR_RESTART || err == RERR_REFRESH) {
1830 1834 vertex_send_event(svc,
1831 1835 RESTARTER_EVENT_TYPE_STOP_RESET);
1832 1836 } else {
1833 1837 vertex_send_event(svc,
1834 1838 RESTARTER_EVENT_TYPE_STOP);
1835 1839 }
1836 1840 }
1837 1841 break;
1838 1842
1839 1843 default:
1840 1844 #ifndef NDEBUG
1841 1845 uu_warn("%s:%d: Unknown vertex type %d.\n", __FILE__, __LINE__,
1842 1846 v->gv_type);
1843 1847 #endif
1844 1848 abort();
1845 1849 }
1846 1850 }
1847 1851
1848 1852 void
1849 1853 offline_vertex(graph_vertex_t *v)
1850 1854 {
1851 1855 scf_handle_t *h = libscf_handle_create_bound_loop();
1852 1856 scf_instance_t *scf_inst = safe_scf_instance_create(h);
1853 1857 scf_propertygroup_t *pg = safe_scf_pg_create(h);
1854 1858 restarter_instance_state_t state, next_state;
1855 1859 int r;
1856 1860
1857 1861 assert(v->gv_type == GVT_INST);
1858 1862
1859 1863 if (scf_inst == NULL)
1860 1864 bad_error("safe_scf_instance_create", scf_error());
1861 1865 if (pg == NULL)
1862 1866 bad_error("safe_scf_pg_create", scf_error());
1863 1867
1864 1868 /* if the vertex is already going offline, return */
1865 1869 rep_retry:
1866 1870 if (scf_handle_decode_fmri(h, v->gv_name, NULL, NULL, scf_inst, NULL,
1867 1871 NULL, SCF_DECODE_FMRI_EXACT) != 0) {
1868 1872 switch (scf_error()) {
1869 1873 case SCF_ERROR_CONNECTION_BROKEN:
1870 1874 libscf_handle_rebind(h);
1871 1875 goto rep_retry;
1872 1876
1873 1877 case SCF_ERROR_NOT_FOUND:
1874 1878 scf_pg_destroy(pg);
1875 1879 scf_instance_destroy(scf_inst);
1876 1880 (void) scf_handle_unbind(h);
1877 1881 scf_handle_destroy(h);
1878 1882 return;
1879 1883 }
1880 1884 uu_die("Can't decode FMRI %s: %s\n", v->gv_name,
1881 1885 scf_strerror(scf_error()));
1882 1886 }
1883 1887
1884 1888 r = scf_instance_get_pg(scf_inst, SCF_PG_RESTARTER, pg);
1885 1889 if (r != 0) {
1886 1890 switch (scf_error()) {
1887 1891 case SCF_ERROR_CONNECTION_BROKEN:
1888 1892 libscf_handle_rebind(h);
1889 1893 goto rep_retry;
1890 1894
1891 1895 case SCF_ERROR_NOT_SET:
1892 1896 case SCF_ERROR_NOT_FOUND:
1893 1897 scf_pg_destroy(pg);
1894 1898 scf_instance_destroy(scf_inst);
1895 1899 (void) scf_handle_unbind(h);
1896 1900 scf_handle_destroy(h);
1897 1901 return;
1898 1902
1899 1903 default:
1900 1904 bad_error("scf_instance_get_pg", scf_error());
1901 1905 }
1902 1906 } else {
1903 1907 r = libscf_read_states(pg, &state, &next_state);
1904 1908 if (r == 0 && (next_state == RESTARTER_STATE_OFFLINE ||
1905 1909 next_state == RESTARTER_STATE_DISABLED)) {
1906 1910 log_framework(LOG_DEBUG,
1907 1911 "%s: instance is already going down.\n",
1908 1912 v->gv_name);
1909 1913 scf_pg_destroy(pg);
1910 1914 scf_instance_destroy(scf_inst);
1911 1915 (void) scf_handle_unbind(h);
1912 1916 scf_handle_destroy(h);
1913 1917 return;
1914 1918 }
1915 1919 }
1916 1920
1917 1921 scf_pg_destroy(pg);
1918 1922 scf_instance_destroy(scf_inst);
1919 1923 (void) scf_handle_unbind(h);
1920 1924 scf_handle_destroy(h);
1921 1925
1922 1926 vertex_send_event(v, RESTARTER_EVENT_TYPE_STOP_RESET);
1923 1927 }
1924 1928
1925 1929 /*
1926 1930 * void graph_enable_by_vertex()
1927 1931 * If admin is non-zero, this is an administrative request for change
1928 1932 * of the enabled property. Thus, send the ADMIN_DISABLE rather than
1929 1933 * a plain DISABLE restarter event.
1930 1934 */
1931 1935 void
1932 1936 graph_enable_by_vertex(graph_vertex_t *vertex, int enable, int admin)
1933 1937 {
1934 1938 graph_vertex_t *v;
1935 1939 int r;
1936 1940
1937 1941 assert(MUTEX_HELD(&dgraph_lock));
1938 1942 assert((vertex->gv_flags & GV_CONFIGURED));
1939 1943
1940 1944 vertex->gv_flags = (vertex->gv_flags & ~GV_ENABLED) |
1941 1945 (enable ? GV_ENABLED : 0);
1942 1946
1943 1947 if (enable) {
1944 1948 if (vertex->gv_state != RESTARTER_STATE_OFFLINE &&
1945 1949 vertex->gv_state != RESTARTER_STATE_DEGRADED &&
1946 1950 vertex->gv_state != RESTARTER_STATE_ONLINE) {
1947 1951 /*
1948 1952 * In case the vertex was notified to go down,
1949 1953 * but now can return online, clear the _TOOFFLINE
1950 1954 * and _TODISABLE flags.
1951 1955 */
1952 1956 vertex->gv_flags &= ~GV_TOOFFLINE;
1953 1957 vertex->gv_flags &= ~GV_TODISABLE;
1954 1958
1955 1959 vertex_send_event(vertex, RESTARTER_EVENT_TYPE_ENABLE);
1956 1960 }
1957 1961
1958 1962 /*
1959 1963 * Wait for state update from restarter before sending _START or
1960 1964 * _STOP.
1961 1965 */
1962 1966
1963 1967 return;
1964 1968 }
1965 1969
1966 1970 if (vertex->gv_state == RESTARTER_STATE_DISABLED)
1967 1971 return;
1968 1972
1969 1973 if (!admin) {
1970 1974 vertex_send_event(vertex, RESTARTER_EVENT_TYPE_DISABLE);
1971 1975
1972 1976 /*
1973 1977 * Wait for state update from restarter before sending _START or
1974 1978 * _STOP.
1975 1979 */
1976 1980
1977 1981 return;
1978 1982 }
1979 1983
1980 1984 /*
1981 1985 * If it is a DISABLE event requested by the administrator then we are
1982 1986 * offlining the dependents first.
1983 1987 */
1984 1988
1985 1989 /*
1986 1990 * Set GV_TOOFFLINE for the services we are offlining. We cannot
1987 1991 * clear the GV_TOOFFLINE bits from all the services because
1988 1992 * other DISABLE events might be handled at the same time.
1989 1993 */
1990 1994 vertex->gv_flags |= GV_TOOFFLINE;
1991 1995
1992 1996 /* remember which vertex to disable... */
1993 1997 vertex->gv_flags |= GV_TODISABLE;
1994 1998
1995 1999 log_framework(LOG_DEBUG, "Marking in-subtree vertices before "
1996 2000 "disabling %s.\n", vertex->gv_name);
1997 2001
1998 2002 /* set GV_TOOFFLINE for its dependents */
1999 2003 r = uu_list_walk(vertex->gv_dependents, (uu_walk_fn_t *)mark_subtree,
2000 2004 NULL, 0);
2001 2005 assert(r == 0);
2002 2006
2003 2007 /* disable the instance now if there is nothing else to offline */
2004 2008 if (insubtree_dependents_down(vertex) == B_TRUE) {
2005 2009 vertex_send_event(vertex, RESTARTER_EVENT_TYPE_ADMIN_DISABLE);
2006 2010 return;
2007 2011 }
2008 2012
2009 2013 /*
2010 2014 * This loop is similar to the one used for the graph reversal shutdown
2011 2015 * and could be improved in term of performance for the subtree reversal
2012 2016 * disable case.
2013 2017 */
2014 2018 for (v = uu_list_first(dgraph); v != NULL;
2015 2019 v = uu_list_next(dgraph, v)) {
2016 2020 /* skip the vertex we are disabling for now */
2017 2021 if (v == vertex)
2018 2022 continue;
2019 2023
2020 2024 if (v->gv_type != GVT_INST ||
2021 2025 (v->gv_flags & GV_CONFIGURED) == 0 ||
2022 2026 (v->gv_flags & GV_ENABLED) == 0 ||
2023 2027 (v->gv_flags & GV_TOOFFLINE) == 0)
2024 2028 continue;
2025 2029
2026 2030 if ((v->gv_state != RESTARTER_STATE_ONLINE) &&
2027 2031 (v->gv_state != RESTARTER_STATE_DEGRADED)) {
2028 2032 /* continue if there is nothing to offline */
2029 2033 continue;
2030 2034 }
2031 2035
2032 2036 /*
2033 2037 * Instances which are up need to come down before we're
2034 2038 * done, but we can only offline the leaves here. An
2035 2039 * instance is a leaf when all its dependents are down.
2036 2040 */
2037 2041 if (insubtree_dependents_down(v) == B_TRUE) {
2038 2042 log_framework(LOG_DEBUG, "Offlining in-subtree "
2039 2043 "instance %s for %s.\n",
2040 2044 v->gv_name, vertex->gv_name);
2041 2045 offline_vertex(v);
2042 2046 }
2043 2047 }
2044 2048 }
2045 2049
2046 2050 static int configure_vertex(graph_vertex_t *, scf_instance_t *);
2047 2051
2048 2052 /*
2049 2053 * Set the restarter for v to fmri_arg. That is, make sure a vertex for
2050 2054 * fmri_arg exists, make v depend on it, and send _ADD_INSTANCE for v. If
2051 2055 * v is already configured and fmri_arg indicates the current restarter, do
2052 2056 * nothing. If v is configured and fmri_arg is a new restarter, delete v's
2053 2057 * dependency on the restarter, send _REMOVE_INSTANCE for v, and set the new
2054 2058 * restarter. Returns 0 on success, EINVAL if the FMRI is invalid,
2055 2059 * ECONNABORTED if the repository connection is broken, and ELOOP
2056 2060 * if the dependency would create a cycle. In the last case, *pathp will
2057 2061 * point to a -1-terminated array of ids which compose the path from v to
2058 2062 * restarter_fmri.
2059 2063 */
2060 2064 int
2061 2065 graph_change_restarter(graph_vertex_t *v, const char *fmri_arg, scf_handle_t *h,
2062 2066 int **pathp)
2063 2067 {
2064 2068 char *restarter_fmri = NULL;
2065 2069 graph_vertex_t *rv;
2066 2070 int err;
2067 2071 int id;
2068 2072
2069 2073 assert(MUTEX_HELD(&dgraph_lock));
2070 2074
2071 2075 if (fmri_arg[0] != '\0') {
2072 2076 err = fmri_canonify(fmri_arg, &restarter_fmri, B_TRUE);
2073 2077 if (err != 0) {
2074 2078 assert(err == EINVAL);
2075 2079 return (err);
2076 2080 }
2077 2081 }
2078 2082
2079 2083 if (restarter_fmri == NULL ||
2080 2084 strcmp(restarter_fmri, SCF_SERVICE_STARTD) == 0) {
2081 2085 if (v->gv_flags & GV_CONFIGURED) {
2082 2086 if (v->gv_restarter_id == -1) {
2083 2087 if (restarter_fmri != NULL)
2084 2088 startd_free(restarter_fmri,
2085 2089 max_scf_fmri_size);
2086 2090 return (0);
2087 2091 }
2088 2092
2089 2093 graph_unset_restarter(v);
2090 2094 }
2091 2095
2092 2096 /* Master restarter, nothing to do. */
2093 2097 v->gv_restarter_id = -1;
2094 2098 v->gv_restarter_channel = NULL;
2095 2099 vertex_send_event(v, RESTARTER_EVENT_TYPE_ADD_INSTANCE);
2096 2100 return (0);
2097 2101 }
2098 2102
2099 2103 if (v->gv_flags & GV_CONFIGURED) {
2100 2104 id = dict_lookup_byname(restarter_fmri);
2101 2105 if (id != -1 && v->gv_restarter_id == id) {
2102 2106 startd_free(restarter_fmri, max_scf_fmri_size);
2103 2107 return (0);
2104 2108 }
2105 2109
2106 2110 graph_unset_restarter(v);
2107 2111 }
2108 2112
2109 2113 err = graph_insert_vertex_unconfigured(restarter_fmri, GVT_INST, 0,
2110 2114 RERR_NONE, &rv);
2111 2115 startd_free(restarter_fmri, max_scf_fmri_size);
2112 2116 assert(err == 0 || err == EEXIST);
2113 2117
2114 2118 if (rv->gv_delegate_initialized == 0) {
2115 2119 if ((rv->gv_delegate_channel = restarter_protocol_init_delegate(
2116 2120 rv->gv_name)) == NULL)
2117 2121 return (EINVAL);
2118 2122 rv->gv_delegate_initialized = 1;
2119 2123 }
2120 2124 v->gv_restarter_id = rv->gv_id;
2121 2125 v->gv_restarter_channel = rv->gv_delegate_channel;
2122 2126
2123 2127 err = graph_insert_dependency(v, rv, pathp);
2124 2128 if (err != 0) {
2125 2129 assert(err == ELOOP);
2126 2130 return (ELOOP);
2127 2131 }
2128 2132
2129 2133 vertex_send_event(v, RESTARTER_EVENT_TYPE_ADD_INSTANCE);
2130 2134
2131 2135 if (!(rv->gv_flags & GV_CONFIGURED)) {
2132 2136 scf_instance_t *inst;
2133 2137
2134 2138 err = libscf_fmri_get_instance(h, rv->gv_name, &inst);
2135 2139 switch (err) {
2136 2140 case 0:
2137 2141 err = configure_vertex(rv, inst);
2138 2142 scf_instance_destroy(inst);
2139 2143 switch (err) {
2140 2144 case 0:
2141 2145 case ECANCELED:
2142 2146 break;
2143 2147
2144 2148 case ECONNABORTED:
2145 2149 return (ECONNABORTED);
2146 2150
2147 2151 default:
2148 2152 bad_error("configure_vertex", err);
2149 2153 }
2150 2154 break;
2151 2155
2152 2156 case ECONNABORTED:
2153 2157 return (ECONNABORTED);
2154 2158
2155 2159 case ENOENT:
2156 2160 break;
2157 2161
2158 2162 case ENOTSUP:
2159 2163 /*
2160 2164 * The fmri doesn't specify an instance - translate
2161 2165 * to EINVAL.
2162 2166 */
2163 2167 return (EINVAL);
2164 2168
2165 2169 case EINVAL:
2166 2170 default:
2167 2171 bad_error("libscf_fmri_get_instance", err);
2168 2172 }
2169 2173 }
2170 2174
2171 2175 return (0);
2172 2176 }
2173 2177
2174 2178
2175 2179 /*
2176 2180 * Add all of the instances of the service named by fmri to the graph.
2177 2181 * Returns
2178 2182 * 0 - success
2179 2183 * ENOENT - service indicated by fmri does not exist
2180 2184 *
2181 2185 * In both cases *reboundp will be B_TRUE if the handle was rebound, or B_FALSE
2182 2186 * otherwise.
2183 2187 */
2184 2188 static int
2185 2189 add_service(const char *fmri, scf_handle_t *h, boolean_t *reboundp)
2186 2190 {
2187 2191 scf_service_t *svc;
2188 2192 scf_instance_t *inst;
2189 2193 scf_iter_t *iter;
2190 2194 char *inst_fmri;
2191 2195 int ret, r;
2192 2196
2193 2197 *reboundp = B_FALSE;
2194 2198
2195 2199 svc = safe_scf_service_create(h);
2196 2200 inst = safe_scf_instance_create(h);
2197 2201 iter = safe_scf_iter_create(h);
2198 2202 inst_fmri = startd_alloc(max_scf_fmri_size);
2199 2203
2200 2204 rebound:
2201 2205 if (scf_handle_decode_fmri(h, fmri, NULL, svc, NULL, NULL, NULL,
2202 2206 SCF_DECODE_FMRI_EXACT) != 0) {
2203 2207 switch (scf_error()) {
2204 2208 case SCF_ERROR_CONNECTION_BROKEN:
2205 2209 default:
2206 2210 libscf_handle_rebind(h);
2207 2211 *reboundp = B_TRUE;
2208 2212 goto rebound;
2209 2213
2210 2214 case SCF_ERROR_NOT_FOUND:
2211 2215 ret = ENOENT;
2212 2216 goto out;
2213 2217
2214 2218 case SCF_ERROR_INVALID_ARGUMENT:
2215 2219 case SCF_ERROR_CONSTRAINT_VIOLATED:
2216 2220 case SCF_ERROR_NOT_BOUND:
2217 2221 case SCF_ERROR_HANDLE_MISMATCH:
2218 2222 bad_error("scf_handle_decode_fmri", scf_error());
2219 2223 }
2220 2224 }
2221 2225
2222 2226 if (scf_iter_service_instances(iter, svc) != 0) {
2223 2227 switch (scf_error()) {
2224 2228 case SCF_ERROR_CONNECTION_BROKEN:
2225 2229 default:
2226 2230 libscf_handle_rebind(h);
2227 2231 *reboundp = B_TRUE;
2228 2232 goto rebound;
2229 2233
2230 2234 case SCF_ERROR_DELETED:
2231 2235 ret = ENOENT;
2232 2236 goto out;
2233 2237
2234 2238 case SCF_ERROR_HANDLE_MISMATCH:
2235 2239 case SCF_ERROR_NOT_BOUND:
2236 2240 case SCF_ERROR_NOT_SET:
2237 2241 bad_error("scf_iter_service_instances", scf_error());
2238 2242 }
2239 2243 }
2240 2244
2241 2245 for (;;) {
2242 2246 r = scf_iter_next_instance(iter, inst);
2243 2247 if (r == 0)
2244 2248 break;
2245 2249 if (r != 1) {
2246 2250 switch (scf_error()) {
2247 2251 case SCF_ERROR_CONNECTION_BROKEN:
2248 2252 default:
2249 2253 libscf_handle_rebind(h);
2250 2254 *reboundp = B_TRUE;
2251 2255 goto rebound;
2252 2256
2253 2257 case SCF_ERROR_DELETED:
2254 2258 ret = ENOENT;
2255 2259 goto out;
2256 2260
2257 2261 case SCF_ERROR_HANDLE_MISMATCH:
2258 2262 case SCF_ERROR_NOT_BOUND:
2259 2263 case SCF_ERROR_NOT_SET:
2260 2264 case SCF_ERROR_INVALID_ARGUMENT:
2261 2265 bad_error("scf_iter_next_instance",
2262 2266 scf_error());
2263 2267 }
2264 2268 }
2265 2269
2266 2270 if (scf_instance_to_fmri(inst, inst_fmri, max_scf_fmri_size) <
2267 2271 0) {
2268 2272 switch (scf_error()) {
2269 2273 case SCF_ERROR_CONNECTION_BROKEN:
2270 2274 libscf_handle_rebind(h);
2271 2275 *reboundp = B_TRUE;
2272 2276 goto rebound;
2273 2277
2274 2278 case SCF_ERROR_DELETED:
2275 2279 continue;
2276 2280
2277 2281 case SCF_ERROR_NOT_BOUND:
2278 2282 case SCF_ERROR_NOT_SET:
2279 2283 bad_error("scf_instance_to_fmri", scf_error());
2280 2284 }
2281 2285 }
2282 2286
2283 2287 r = dgraph_add_instance(inst_fmri, inst, B_FALSE);
2284 2288 switch (r) {
2285 2289 case 0:
2286 2290 case ECANCELED:
2287 2291 break;
2288 2292
2289 2293 case EEXIST:
2290 2294 continue;
2291 2295
2292 2296 case ECONNABORTED:
2293 2297 libscf_handle_rebind(h);
2294 2298 *reboundp = B_TRUE;
2295 2299 goto rebound;
2296 2300
2297 2301 case EINVAL:
2298 2302 default:
2299 2303 bad_error("dgraph_add_instance", r);
2300 2304 }
2301 2305 }
2302 2306
2303 2307 ret = 0;
2304 2308
2305 2309 out:
2306 2310 startd_free(inst_fmri, max_scf_fmri_size);
2307 2311 scf_iter_destroy(iter);
2308 2312 scf_instance_destroy(inst);
2309 2313 scf_service_destroy(svc);
2310 2314 return (ret);
2311 2315 }
2312 2316
2313 2317 struct depfmri_info {
2314 2318 graph_vertex_t *v; /* GVT_GROUP vertex */
2315 2319 gv_type_t type; /* type of dependency */
2316 2320 const char *inst_fmri; /* FMRI of parental GVT_INST vert. */
2317 2321 const char *pg_name; /* Name of dependency pg */
2318 2322 scf_handle_t *h;
2319 2323 int err; /* return error code */
2320 2324 int **pathp; /* return circular dependency path */
2321 2325 };
2322 2326
2323 2327 /*
2324 2328 * Find or create a vertex for fmri and make info->v depend on it.
2325 2329 * Returns
2326 2330 * 0 - success
2327 2331 * nonzero - failure
2328 2332 *
2329 2333 * On failure, sets info->err to
2330 2334 * EINVAL - fmri is invalid
2331 2335 * fmri does not match info->type
2332 2336 * ELOOP - Adding the dependency creates a circular dependency. *info->pathp
2333 2337 * will point to an array of the ids of the members of the cycle.
2334 2338 * ECONNABORTED - repository connection was broken
2335 2339 * ECONNRESET - succeeded, but repository connection was reset
2336 2340 */
2337 2341 static int
2338 2342 process_dependency_fmri(const char *fmri, struct depfmri_info *info)
2339 2343 {
2340 2344 int err;
2341 2345 graph_vertex_t *depgroup_v, *v;
2342 2346 char *fmri_copy, *cfmri;
2343 2347 size_t fmri_copy_sz;
2344 2348 const char *scope, *service, *instance, *pg;
2345 2349 scf_instance_t *inst;
2346 2350 boolean_t rebound;
2347 2351
2348 2352 assert(MUTEX_HELD(&dgraph_lock));
2349 2353
2350 2354 /* Get or create vertex for FMRI */
2351 2355 depgroup_v = info->v;
2352 2356
2353 2357 if (strncmp(fmri, "file:", sizeof ("file:") - 1) == 0) {
2354 2358 if (info->type != GVT_FILE) {
2355 2359 log_framework(LOG_NOTICE,
2356 2360 "FMRI \"%s\" is not allowed for the \"%s\" "
2357 2361 "dependency's type of instance %s.\n", fmri,
2358 2362 info->pg_name, info->inst_fmri);
2359 2363 return (info->err = EINVAL);
2360 2364 }
2361 2365
2362 2366 err = graph_insert_vertex_unconfigured(fmri, info->type, 0,
2363 2367 RERR_NONE, &v);
2364 2368 switch (err) {
2365 2369 case 0:
2366 2370 break;
2367 2371
2368 2372 case EEXIST:
2369 2373 assert(v->gv_type == GVT_FILE);
2370 2374 break;
2371 2375
2372 2376 case EINVAL: /* prevented above */
2373 2377 default:
2374 2378 bad_error("graph_insert_vertex_unconfigured", err);
2375 2379 }
2376 2380 } else {
2377 2381 if (info->type != GVT_INST) {
2378 2382 log_framework(LOG_NOTICE,
2379 2383 "FMRI \"%s\" is not allowed for the \"%s\" "
2380 2384 "dependency's type of instance %s.\n", fmri,
2381 2385 info->pg_name, info->inst_fmri);
2382 2386 return (info->err = EINVAL);
2383 2387 }
2384 2388
2385 2389 /*
2386 2390 * We must canonify fmri & add a vertex for it.
2387 2391 */
2388 2392 fmri_copy_sz = strlen(fmri) + 1;
2389 2393 fmri_copy = startd_alloc(fmri_copy_sz);
2390 2394 (void) strcpy(fmri_copy, fmri);
2391 2395
2392 2396 /* Determine if the FMRI is a property group or instance */
2393 2397 if (scf_parse_svc_fmri(fmri_copy, &scope, &service,
2394 2398 &instance, &pg, NULL) != 0) {
2395 2399 startd_free(fmri_copy, fmri_copy_sz);
2396 2400 log_framework(LOG_NOTICE,
2397 2401 "Dependency \"%s\" of %s has invalid FMRI "
2398 2402 "\"%s\".\n", info->pg_name, info->inst_fmri,
2399 2403 fmri);
2400 2404 return (info->err = EINVAL);
2401 2405 }
2402 2406
2403 2407 if (service == NULL || pg != NULL) {
2404 2408 startd_free(fmri_copy, fmri_copy_sz);
2405 2409 log_framework(LOG_NOTICE,
2406 2410 "Dependency \"%s\" of %s does not designate a "
2407 2411 "service or instance.\n", info->pg_name,
2408 2412 info->inst_fmri);
2409 2413 return (info->err = EINVAL);
2410 2414 }
2411 2415
2412 2416 if (scope == NULL || strcmp(scope, SCF_SCOPE_LOCAL) == 0) {
2413 2417 cfmri = uu_msprintf("svc:/%s%s%s",
2414 2418 service, instance ? ":" : "", instance ? instance :
2415 2419 "");
2416 2420 } else {
2417 2421 cfmri = uu_msprintf("svc://%s/%s%s%s",
2418 2422 scope, service, instance ? ":" : "", instance ?
2419 2423 instance : "");
2420 2424 }
2421 2425
2422 2426 startd_free(fmri_copy, fmri_copy_sz);
2423 2427
2424 2428 err = graph_insert_vertex_unconfigured(cfmri, instance ?
2425 2429 GVT_INST : GVT_SVC, instance ? 0 : DEPGRP_REQUIRE_ANY,
2426 2430 RERR_NONE, &v);
2427 2431 uu_free(cfmri);
2428 2432 switch (err) {
2429 2433 case 0:
2430 2434 break;
2431 2435
2432 2436 case EEXIST:
2433 2437 /* Verify v. */
2434 2438 if (instance != NULL)
2435 2439 assert(v->gv_type == GVT_INST);
2436 2440 else
2437 2441 assert(v->gv_type == GVT_SVC);
2438 2442 break;
2439 2443
2440 2444 default:
2441 2445 bad_error("graph_insert_vertex_unconfigured", err);
2442 2446 }
2443 2447 }
2444 2448
2445 2449 /* Add dependency from depgroup_v to new vertex */
2446 2450 info->err = graph_insert_dependency(depgroup_v, v, info->pathp);
2447 2451 switch (info->err) {
2448 2452 case 0:
2449 2453 break;
2450 2454
2451 2455 case ELOOP:
2452 2456 return (ELOOP);
2453 2457
2454 2458 default:
2455 2459 bad_error("graph_insert_dependency", info->err);
2456 2460 }
2457 2461
2458 2462 /* This must be after we insert the dependency, to avoid looping. */
2459 2463 switch (v->gv_type) {
2460 2464 case GVT_INST:
2461 2465 if ((v->gv_flags & GV_CONFIGURED) != 0)
2462 2466 break;
2463 2467
2464 2468 inst = safe_scf_instance_create(info->h);
2465 2469
2466 2470 rebound = B_FALSE;
2467 2471
2468 2472 rebound:
2469 2473 err = libscf_lookup_instance(v->gv_name, inst);
2470 2474 switch (err) {
2471 2475 case 0:
2472 2476 err = configure_vertex(v, inst);
2473 2477 switch (err) {
2474 2478 case 0:
2475 2479 case ECANCELED:
2476 2480 break;
2477 2481
2478 2482 case ECONNABORTED:
2479 2483 libscf_handle_rebind(info->h);
2480 2484 rebound = B_TRUE;
2481 2485 goto rebound;
2482 2486
2483 2487 default:
2484 2488 bad_error("configure_vertex", err);
2485 2489 }
2486 2490 break;
2487 2491
2488 2492 case ENOENT:
2489 2493 break;
2490 2494
2491 2495 case ECONNABORTED:
2492 2496 libscf_handle_rebind(info->h);
2493 2497 rebound = B_TRUE;
2494 2498 goto rebound;
2495 2499
2496 2500 case EINVAL:
2497 2501 case ENOTSUP:
2498 2502 default:
2499 2503 bad_error("libscf_fmri_get_instance", err);
2500 2504 }
2501 2505
2502 2506 scf_instance_destroy(inst);
2503 2507
2504 2508 if (rebound)
2505 2509 return (info->err = ECONNRESET);
2506 2510 break;
2507 2511
2508 2512 case GVT_SVC:
2509 2513 (void) add_service(v->gv_name, info->h, &rebound);
2510 2514 if (rebound)
2511 2515 return (info->err = ECONNRESET);
2512 2516 }
2513 2517
2514 2518 return (0);
2515 2519 }
2516 2520
2517 2521 struct deppg_info {
2518 2522 graph_vertex_t *v; /* GVT_INST vertex */
2519 2523 int err; /* return error */
2520 2524 int **pathp; /* return circular dependency path */
2521 2525 };
2522 2526
2523 2527 /*
2524 2528 * Make info->v depend on a new GVT_GROUP node for this property group,
2525 2529 * and then call process_dependency_fmri() for the values of the entity
2526 2530 * property. Return 0 on success, or if something goes wrong return nonzero
2527 2531 * and set info->err to ECONNABORTED, EINVAL, or the error code returned by
2528 2532 * process_dependency_fmri().
2529 2533 */
2530 2534 static int
2531 2535 process_dependency_pg(scf_propertygroup_t *pg, struct deppg_info *info)
2532 2536 {
2533 2537 scf_handle_t *h;
2534 2538 depgroup_type_t deptype;
2535 2539 restarter_error_t rerr;
2536 2540 struct depfmri_info linfo;
2537 2541 char *fmri, *pg_name;
2538 2542 size_t fmri_sz;
2539 2543 graph_vertex_t *depgrp;
2540 2544 scf_property_t *prop;
2541 2545 int err;
2542 2546 int empty;
2543 2547 scf_error_t scferr;
2544 2548 ssize_t len;
2545 2549
2546 2550 assert(MUTEX_HELD(&dgraph_lock));
2547 2551
2548 2552 h = scf_pg_handle(pg);
2549 2553
2550 2554 pg_name = startd_alloc(max_scf_name_size);
2551 2555
2552 2556 len = scf_pg_get_name(pg, pg_name, max_scf_name_size);
2553 2557 if (len < 0) {
2554 2558 startd_free(pg_name, max_scf_name_size);
2555 2559 switch (scf_error()) {
2556 2560 case SCF_ERROR_CONNECTION_BROKEN:
2557 2561 default:
2558 2562 return (info->err = ECONNABORTED);
2559 2563
2560 2564 case SCF_ERROR_DELETED:
2561 2565 return (info->err = 0);
2562 2566
2563 2567 case SCF_ERROR_NOT_SET:
2564 2568 bad_error("scf_pg_get_name", scf_error());
2565 2569 }
2566 2570 }
2567 2571
2568 2572 /*
2569 2573 * Skip over empty dependency groups. Since dependency property
2570 2574 * groups are updated atomically, they are either empty or
2571 2575 * fully populated.
2572 2576 */
2573 2577 empty = depgroup_empty(h, pg);
2574 2578 if (empty < 0) {
2575 2579 log_error(LOG_INFO,
2576 2580 "Error reading dependency group \"%s\" of %s: %s\n",
2577 2581 pg_name, info->v->gv_name, scf_strerror(scf_error()));
2578 2582 startd_free(pg_name, max_scf_name_size);
2579 2583 return (info->err = EINVAL);
2580 2584
2581 2585 } else if (empty == 1) {
2582 2586 log_framework(LOG_DEBUG,
2583 2587 "Ignoring empty dependency group \"%s\" of %s\n",
2584 2588 pg_name, info->v->gv_name);
2585 2589 startd_free(pg_name, max_scf_name_size);
2586 2590 return (info->err = 0);
2587 2591 }
2588 2592
2589 2593 fmri_sz = strlen(info->v->gv_name) + 1 + len + 1;
2590 2594 fmri = startd_alloc(fmri_sz);
2591 2595
2592 2596 (void) snprintf(fmri, fmri_sz, "%s>%s", info->v->gv_name,
2593 2597 pg_name);
2594 2598
2595 2599 /* Validate the pg before modifying the graph */
2596 2600 deptype = depgroup_read_grouping(h, pg);
2597 2601 if (deptype == DEPGRP_UNSUPPORTED) {
2598 2602 log_error(LOG_INFO,
2599 2603 "Dependency \"%s\" of %s has an unknown grouping value.\n",
2600 2604 pg_name, info->v->gv_name);
2601 2605 startd_free(fmri, fmri_sz);
2602 2606 startd_free(pg_name, max_scf_name_size);
2603 2607 return (info->err = EINVAL);
2604 2608 }
2605 2609
2606 2610 rerr = depgroup_read_restart(h, pg);
2607 2611 if (rerr == RERR_UNSUPPORTED) {
2608 2612 log_error(LOG_INFO,
2609 2613 "Dependency \"%s\" of %s has an unknown restart_on value."
2610 2614 "\n", pg_name, info->v->gv_name);
2611 2615 startd_free(fmri, fmri_sz);
2612 2616 startd_free(pg_name, max_scf_name_size);
2613 2617 return (info->err = EINVAL);
2614 2618 }
2615 2619
2616 2620 prop = safe_scf_property_create(h);
2617 2621
2618 2622 if (scf_pg_get_property(pg, SCF_PROPERTY_ENTITIES, prop) != 0) {
2619 2623 scferr = scf_error();
2620 2624 scf_property_destroy(prop);
2621 2625 if (scferr == SCF_ERROR_DELETED) {
2622 2626 startd_free(fmri, fmri_sz);
2623 2627 startd_free(pg_name, max_scf_name_size);
2624 2628 return (info->err = 0);
2625 2629 } else if (scferr != SCF_ERROR_NOT_FOUND) {
2626 2630 startd_free(fmri, fmri_sz);
2627 2631 startd_free(pg_name, max_scf_name_size);
2628 2632 return (info->err = ECONNABORTED);
2629 2633 }
2630 2634
2631 2635 log_error(LOG_INFO,
2632 2636 "Dependency \"%s\" of %s is missing a \"%s\" property.\n",
2633 2637 pg_name, info->v->gv_name, SCF_PROPERTY_ENTITIES);
2634 2638
2635 2639 startd_free(fmri, fmri_sz);
2636 2640 startd_free(pg_name, max_scf_name_size);
2637 2641
2638 2642 return (info->err = EINVAL);
2639 2643 }
2640 2644
2641 2645 /* Create depgroup vertex for pg */
2642 2646 err = graph_insert_vertex_unconfigured(fmri, GVT_GROUP, deptype,
2643 2647 rerr, &depgrp);
2644 2648 assert(err == 0);
2645 2649 startd_free(fmri, fmri_sz);
2646 2650
2647 2651 /* Add dependency from inst vertex to new vertex */
2648 2652 err = graph_insert_dependency(info->v, depgrp, info->pathp);
2649 2653 /* ELOOP can't happen because this should be a new vertex */
2650 2654 assert(err == 0);
2651 2655
2652 2656 linfo.v = depgrp;
2653 2657 linfo.type = depgroup_read_scheme(h, pg);
2654 2658 linfo.inst_fmri = info->v->gv_name;
2655 2659 linfo.pg_name = pg_name;
2656 2660 linfo.h = h;
2657 2661 linfo.err = 0;
2658 2662 linfo.pathp = info->pathp;
2659 2663 err = walk_property_astrings(prop, (callback_t)process_dependency_fmri,
2660 2664 &linfo);
2661 2665
2662 2666 scf_property_destroy(prop);
2663 2667 startd_free(pg_name, max_scf_name_size);
2664 2668
2665 2669 switch (err) {
2666 2670 case 0:
2667 2671 case EINTR:
2668 2672 return (info->err = linfo.err);
2669 2673
2670 2674 case ECONNABORTED:
2671 2675 case EINVAL:
2672 2676 return (info->err = err);
2673 2677
2674 2678 case ECANCELED:
2675 2679 return (info->err = 0);
2676 2680
2677 2681 case ECONNRESET:
2678 2682 return (info->err = ECONNABORTED);
2679 2683
2680 2684 default:
2681 2685 bad_error("walk_property_astrings", err);
2682 2686 /* NOTREACHED */
2683 2687 }
2684 2688 }
2685 2689
2686 2690 /*
2687 2691 * Build the dependency info for v from the repository. Returns 0 on success,
2688 2692 * ECONNABORTED on repository disconnection, EINVAL if the repository
2689 2693 * configuration is invalid, and ELOOP if a dependency would cause a cycle.
2690 2694 * In the last case, *pathp will point to a -1-terminated array of ids which
2691 2695 * constitute the rest of the dependency cycle.
2692 2696 */
2693 2697 static int
2694 2698 set_dependencies(graph_vertex_t *v, scf_instance_t *inst, int **pathp)
2695 2699 {
2696 2700 struct deppg_info info;
2697 2701 int err;
2698 2702 uint_t old_configured;
2699 2703
2700 2704 assert(MUTEX_HELD(&dgraph_lock));
2701 2705
2702 2706 /*
2703 2707 * Mark the vertex as configured during dependency insertion to avoid
2704 2708 * dependency cycles (which can appear in the graph if one of the
2705 2709 * vertices is an exclusion-group).
2706 2710 */
2707 2711 old_configured = v->gv_flags & GV_CONFIGURED;
2708 2712 v->gv_flags |= GV_CONFIGURED;
2709 2713
2710 2714 info.err = 0;
2711 2715 info.v = v;
2712 2716 info.pathp = pathp;
2713 2717
2714 2718 err = walk_dependency_pgs(inst, (callback_t)process_dependency_pg,
2715 2719 &info);
2716 2720
2717 2721 if (!old_configured)
2718 2722 v->gv_flags &= ~GV_CONFIGURED;
2719 2723
2720 2724 switch (err) {
2721 2725 case 0:
2722 2726 case EINTR:
2723 2727 return (info.err);
2724 2728
2725 2729 case ECONNABORTED:
2726 2730 return (ECONNABORTED);
2727 2731
2728 2732 case ECANCELED:
2729 2733 /* Should get delete event, so return 0. */
2730 2734 return (0);
2731 2735
2732 2736 default:
2733 2737 bad_error("walk_dependency_pgs", err);
2734 2738 /* NOTREACHED */
2735 2739 }
2736 2740 }
2737 2741
2738 2742
2739 2743 static void
2740 2744 handle_cycle(const char *fmri, int *path)
2741 2745 {
2742 2746 const char *cp;
2743 2747 size_t sz;
2744 2748
2745 2749 assert(MUTEX_HELD(&dgraph_lock));
2746 2750
2747 2751 path_to_str(path, (char **)&cp, &sz);
2748 2752
2749 2753 log_error(LOG_ERR, "Transitioning %s to maintenance "
2750 2754 "because it completes a dependency cycle (see svcs -xv for "
2751 2755 "details):\n%s", fmri ? fmri : "?", cp);
2752 2756
2753 2757 startd_free((void *)cp, sz);
2754 2758 }
2755 2759
2756 2760 /*
2757 2761 * Increment the vertex's reference count to prevent the vertex removal
2758 2762 * from the dgraph.
2759 2763 */
2760 2764 static void
2761 2765 vertex_ref(graph_vertex_t *v)
2762 2766 {
2763 2767 assert(MUTEX_HELD(&dgraph_lock));
2764 2768
2765 2769 v->gv_refs++;
2766 2770 }
2767 2771
2768 2772 /*
2769 2773 * Decrement the vertex's reference count and remove the vertex from
2770 2774 * the dgraph when possible.
2771 2775 *
2772 2776 * Return VERTEX_REMOVED when the vertex has been removed otherwise
2773 2777 * return VERTEX_INUSE.
2774 2778 */
2775 2779 static int
2776 2780 vertex_unref(graph_vertex_t *v)
2777 2781 {
2778 2782 assert(MUTEX_HELD(&dgraph_lock));
2779 2783 assert(v->gv_refs > 0);
2780 2784
2781 2785 v->gv_refs--;
2782 2786
2783 2787 return (free_if_unrefed(v));
2784 2788 }
2785 2789
2786 2790 /*
2787 2791 * When run on the dependencies of a vertex, populates list with
2788 2792 * graph_edge_t's which point to the service vertices or the instance
2789 2793 * vertices (no GVT_GROUP nodes) on which the vertex depends.
2790 2794 *
2791 2795 * Increment the vertex's reference count once the vertex is inserted
2792 2796 * in the list. The vertex won't be able to be deleted from the dgraph
2793 2797 * while it is referenced.
2794 2798 */
2795 2799 static int
2796 2800 append_svcs_or_insts(graph_edge_t *e, uu_list_t *list)
2797 2801 {
2798 2802 graph_vertex_t *v = e->ge_vertex;
2799 2803 graph_edge_t *new;
2800 2804 int r;
2801 2805
2802 2806 switch (v->gv_type) {
2803 2807 case GVT_INST:
2804 2808 case GVT_SVC:
2805 2809 break;
2806 2810
2807 2811 case GVT_GROUP:
2808 2812 r = uu_list_walk(v->gv_dependencies,
2809 2813 (uu_walk_fn_t *)append_svcs_or_insts, list, 0);
2810 2814 assert(r == 0);
2811 2815 return (UU_WALK_NEXT);
2812 2816
2813 2817 case GVT_FILE:
2814 2818 return (UU_WALK_NEXT);
2815 2819
2816 2820 default:
2817 2821 #ifndef NDEBUG
2818 2822 uu_warn("%s:%d: Unexpected vertex type %d.\n", __FILE__,
2819 2823 __LINE__, v->gv_type);
2820 2824 #endif
2821 2825 abort();
2822 2826 }
2823 2827
2824 2828 new = startd_alloc(sizeof (*new));
2825 2829 new->ge_vertex = v;
2826 2830 uu_list_node_init(new, &new->ge_link, graph_edge_pool);
2827 2831 r = uu_list_insert_before(list, NULL, new);
2828 2832 assert(r == 0);
2829 2833
2830 2834 /*
2831 2835 * Because we are inserting the vertex in a list, we don't want
2832 2836 * the vertex to be freed while the list is in use. In order to
2833 2837 * achieve that, increment the vertex's reference count.
2834 2838 */
2835 2839 vertex_ref(v);
2836 2840
2837 2841 return (UU_WALK_NEXT);
2838 2842 }
2839 2843
2840 2844 static boolean_t
2841 2845 should_be_in_subgraph(graph_vertex_t *v)
2842 2846 {
2843 2847 graph_edge_t *e;
2844 2848
2845 2849 if (v == milestone)
2846 2850 return (B_TRUE);
2847 2851
2848 2852 /*
2849 2853 * v is in the subgraph if any of its dependents are in the subgraph.
2850 2854 * Except for EXCLUDE_ALL dependents. And OPTIONAL dependents only
2851 2855 * count if we're enabled.
2852 2856 */
2853 2857 for (e = uu_list_first(v->gv_dependents);
2854 2858 e != NULL;
2855 2859 e = uu_list_next(v->gv_dependents, e)) {
2856 2860 graph_vertex_t *dv = e->ge_vertex;
2857 2861
2858 2862 if (!(dv->gv_flags & GV_INSUBGRAPH))
2859 2863 continue;
2860 2864
2861 2865 /*
2862 2866 * Don't include instances that are optional and disabled.
2863 2867 */
2864 2868 if (v->gv_type == GVT_INST && dv->gv_type == GVT_SVC) {
2865 2869
2866 2870 int in = 0;
2867 2871 graph_edge_t *ee;
2868 2872
2869 2873 for (ee = uu_list_first(dv->gv_dependents);
2870 2874 ee != NULL;
2871 2875 ee = uu_list_next(dv->gv_dependents, ee)) {
2872 2876
2873 2877 graph_vertex_t *ddv = e->ge_vertex;
2874 2878
2875 2879 if (ddv->gv_type == GVT_GROUP &&
2876 2880 ddv->gv_depgroup == DEPGRP_EXCLUDE_ALL)
2877 2881 continue;
2878 2882
2879 2883 if (ddv->gv_type == GVT_GROUP &&
2880 2884 ddv->gv_depgroup == DEPGRP_OPTIONAL_ALL &&
2881 2885 !(v->gv_flags & GV_ENBLD_NOOVR))
2882 2886 continue;
2883 2887
2884 2888 in = 1;
2885 2889 }
2886 2890 if (!in)
2887 2891 continue;
2888 2892 }
2889 2893 if (v->gv_type == GVT_INST &&
2890 2894 dv->gv_type == GVT_GROUP &&
2891 2895 dv->gv_depgroup == DEPGRP_OPTIONAL_ALL &&
2892 2896 !(v->gv_flags & GV_ENBLD_NOOVR))
2893 2897 continue;
2894 2898
2895 2899 /* Don't include excluded services and instances */
2896 2900 if (dv->gv_type == GVT_GROUP &&
2897 2901 dv->gv_depgroup == DEPGRP_EXCLUDE_ALL)
2898 2902 continue;
2899 2903
2900 2904 return (B_TRUE);
2901 2905 }
2902 2906
2903 2907 return (B_FALSE);
2904 2908 }
2905 2909
2906 2910 /*
2907 2911 * Ensures that GV_INSUBGRAPH is set properly for v and its descendents. If
2908 2912 * any bits change, manipulate the repository appropriately. Returns 0 or
2909 2913 * ECONNABORTED.
2910 2914 */
2911 2915 static int
2912 2916 eval_subgraph(graph_vertex_t *v, scf_handle_t *h)
2913 2917 {
2914 2918 boolean_t old = (v->gv_flags & GV_INSUBGRAPH) != 0;
2915 2919 boolean_t new;
2916 2920 graph_edge_t *e;
2917 2921 scf_instance_t *inst;
2918 2922 int ret = 0, r;
2919 2923
2920 2924 assert(milestone != NULL && milestone != MILESTONE_NONE);
2921 2925
2922 2926 new = should_be_in_subgraph(v);
2923 2927
2924 2928 if (new == old)
2925 2929 return (0);
2926 2930
2927 2931 log_framework(LOG_DEBUG, new ? "Adding %s to the subgraph.\n" :
2928 2932 "Removing %s from the subgraph.\n", v->gv_name);
2929 2933
2930 2934 v->gv_flags = (v->gv_flags & ~GV_INSUBGRAPH) |
2931 2935 (new ? GV_INSUBGRAPH : 0);
2932 2936
2933 2937 if (v->gv_type == GVT_INST && (v->gv_flags & GV_CONFIGURED)) {
2934 2938 int err;
2935 2939
2936 2940 get_inst:
2937 2941 err = libscf_fmri_get_instance(h, v->gv_name, &inst);
2938 2942 if (err != 0) {
2939 2943 switch (err) {
2940 2944 case ECONNABORTED:
2941 2945 libscf_handle_rebind(h);
2942 2946 ret = ECONNABORTED;
2943 2947 goto get_inst;
2944 2948
2945 2949 case ENOENT:
2946 2950 break;
2947 2951
2948 2952 case EINVAL:
2949 2953 case ENOTSUP:
2950 2954 default:
2951 2955 bad_error("libscf_fmri_get_instance", err);
2952 2956 }
2953 2957 } else {
2954 2958 const char *f;
2955 2959
2956 2960 if (new) {
2957 2961 err = libscf_delete_enable_ovr(inst);
2958 2962 f = "libscf_delete_enable_ovr";
2959 2963 } else {
2960 2964 err = libscf_set_enable_ovr(inst, 0);
2961 2965 f = "libscf_set_enable_ovr";
2962 2966 }
2963 2967 scf_instance_destroy(inst);
2964 2968 switch (err) {
2965 2969 case 0:
2966 2970 case ECANCELED:
2967 2971 break;
2968 2972
2969 2973 case ECONNABORTED:
2970 2974 libscf_handle_rebind(h);
2971 2975 /*
2972 2976 * We must continue so the graph is updated,
2973 2977 * but we must return ECONNABORTED so any
2974 2978 * libscf state held by any callers is reset.
2975 2979 */
2976 2980 ret = ECONNABORTED;
2977 2981 goto get_inst;
2978 2982
2979 2983 case EROFS:
2980 2984 case EPERM:
2981 2985 log_error(LOG_WARNING,
2982 2986 "Could not set %s/%s for %s: %s.\n",
2983 2987 SCF_PG_GENERAL_OVR, SCF_PROPERTY_ENABLED,
2984 2988 v->gv_name, strerror(err));
2985 2989 break;
2986 2990
2987 2991 default:
2988 2992 bad_error(f, err);
2989 2993 }
2990 2994 }
2991 2995 }
2992 2996
2993 2997 for (e = uu_list_first(v->gv_dependencies);
2994 2998 e != NULL;
2995 2999 e = uu_list_next(v->gv_dependencies, e)) {
2996 3000 r = eval_subgraph(e->ge_vertex, h);
2997 3001 if (r != 0) {
2998 3002 assert(r == ECONNABORTED);
2999 3003 ret = ECONNABORTED;
3000 3004 }
3001 3005 }
3002 3006
3003 3007 return (ret);
3004 3008 }
3005 3009
3006 3010 /*
3007 3011 * Delete the (property group) dependencies of v & create new ones based on
3008 3012 * inst. If doing so would create a cycle, log a message and put the instance
3009 3013 * into maintenance. Update GV_INSUBGRAPH flags as necessary. Returns 0 or
3010 3014 * ECONNABORTED.
3011 3015 */
3012 3016 int
3013 3017 refresh_vertex(graph_vertex_t *v, scf_instance_t *inst)
3014 3018 {
3015 3019 int err;
3016 3020 int *path;
3017 3021 char *fmri;
3018 3022 int r;
3019 3023 scf_handle_t *h = scf_instance_handle(inst);
3020 3024 uu_list_t *old_deps;
3021 3025 int ret = 0;
3022 3026 graph_edge_t *e;
3023 3027 graph_vertex_t *vv;
3024 3028
3025 3029 assert(MUTEX_HELD(&dgraph_lock));
3026 3030 assert(v->gv_type == GVT_INST);
3027 3031
3028 3032 log_framework(LOG_DEBUG, "Graph engine: Refreshing %s.\n", v->gv_name);
3029 3033
3030 3034 if (milestone > MILESTONE_NONE) {
3031 3035 /*
3032 3036 * In case some of v's dependencies are being deleted we must
3033 3037 * make a list of them now for GV_INSUBGRAPH-flag evaluation
3034 3038 * after the new dependencies are in place.
3035 3039 */
3036 3040 old_deps = startd_list_create(graph_edge_pool, NULL, 0);
3037 3041
3038 3042 err = uu_list_walk(v->gv_dependencies,
3039 3043 (uu_walk_fn_t *)append_svcs_or_insts, old_deps, 0);
3040 3044 assert(err == 0);
3041 3045 }
3042 3046
3043 3047 delete_instance_dependencies(v, B_FALSE);
3044 3048
3045 3049 err = set_dependencies(v, inst, &path);
3046 3050 switch (err) {
3047 3051 case 0:
3048 3052 break;
3049 3053
3050 3054 case ECONNABORTED:
3051 3055 ret = err;
3052 3056 goto out;
3053 3057
3054 3058 case EINVAL:
3055 3059 case ELOOP:
3056 3060 r = libscf_instance_get_fmri(inst, &fmri);
3057 3061 switch (r) {
3058 3062 case 0:
3059 3063 break;
3060 3064
3061 3065 case ECONNABORTED:
3062 3066 ret = ECONNABORTED;
3063 3067 goto out;
3064 3068
3065 3069 case ECANCELED:
3066 3070 ret = 0;
3067 3071 goto out;
3068 3072
3069 3073 default:
3070 3074 bad_error("libscf_instance_get_fmri", r);
3071 3075 }
3072 3076
3073 3077 if (err == EINVAL) {
3074 3078 log_error(LOG_ERR, "Transitioning %s "
3075 3079 "to maintenance due to misconfiguration.\n",
3076 3080 fmri ? fmri : "?");
3077 3081 vertex_send_event(v,
3078 3082 RESTARTER_EVENT_TYPE_INVALID_DEPENDENCY);
3079 3083 } else {
3080 3084 handle_cycle(fmri, path);
3081 3085 vertex_send_event(v,
3082 3086 RESTARTER_EVENT_TYPE_DEPENDENCY_CYCLE);
3083 3087 }
3084 3088 startd_free(fmri, max_scf_fmri_size);
3085 3089 ret = 0;
3086 3090 goto out;
3087 3091
3088 3092 default:
3089 3093 bad_error("set_dependencies", err);
3090 3094 }
3091 3095
3092 3096 if (milestone > MILESTONE_NONE) {
3093 3097 boolean_t aborted = B_FALSE;
3094 3098
3095 3099 for (e = uu_list_first(old_deps);
3096 3100 e != NULL;
3097 3101 e = uu_list_next(old_deps, e)) {
3098 3102 vv = e->ge_vertex;
3099 3103
3100 3104 if (vertex_unref(vv) == VERTEX_INUSE &&
3101 3105 eval_subgraph(vv, h) == ECONNABORTED)
3102 3106 aborted = B_TRUE;
3103 3107 }
3104 3108
3105 3109 for (e = uu_list_first(v->gv_dependencies);
3106 3110 e != NULL;
3107 3111 e = uu_list_next(v->gv_dependencies, e)) {
3108 3112 if (eval_subgraph(e->ge_vertex, h) ==
3109 3113 ECONNABORTED)
3110 3114 aborted = B_TRUE;
3111 3115 }
3112 3116
3113 3117 if (aborted) {
3114 3118 ret = ECONNABORTED;
3115 3119 goto out;
3116 3120 }
3117 3121 }
3118 3122
3119 3123 graph_start_if_satisfied(v);
3120 3124
3121 3125 ret = 0;
3122 3126
3123 3127 out:
3124 3128 if (milestone > MILESTONE_NONE) {
3125 3129 void *cookie = NULL;
3126 3130
3127 3131 while ((e = uu_list_teardown(old_deps, &cookie)) != NULL)
3128 3132 startd_free(e, sizeof (*e));
3129 3133
3130 3134 uu_list_destroy(old_deps);
3131 3135 }
3132 3136
3133 3137 return (ret);
3134 3138 }
3135 3139
3136 3140 /*
3137 3141 * Set up v according to inst. That is, make sure it depends on its
3138 3142 * restarter and set up its dependencies. Send the ADD_INSTANCE command to
3139 3143 * the restarter, and send ENABLE or DISABLE as appropriate.
3140 3144 *
3141 3145 * Returns 0 on success, ECONNABORTED on repository disconnection, or
3142 3146 * ECANCELED if inst is deleted.
3143 3147 */
3144 3148 static int
3145 3149 configure_vertex(graph_vertex_t *v, scf_instance_t *inst)
3146 3150 {
3147 3151 scf_handle_t *h;
3148 3152 scf_propertygroup_t *pg;
3149 3153 scf_snapshot_t *snap;
3150 3154 char *restarter_fmri = startd_alloc(max_scf_value_size);
3151 3155 int enabled, enabled_ovr;
3152 3156 int err;
3153 3157 int *path;
3154 3158 int deathrow;
3155 3159 int32_t tset;
3156 3160
3157 3161 restarter_fmri[0] = '\0';
3158 3162
3159 3163 assert(MUTEX_HELD(&dgraph_lock));
3160 3164 assert(v->gv_type == GVT_INST);
3161 3165 assert((v->gv_flags & GV_CONFIGURED) == 0);
3162 3166
3163 3167 /* GV_INSUBGRAPH should already be set properly. */
3164 3168 assert(should_be_in_subgraph(v) ==
3165 3169 ((v->gv_flags & GV_INSUBGRAPH) != 0));
3166 3170
3167 3171 /*
3168 3172 * If the instance fmri is in the deathrow list then set the
3169 3173 * GV_DEATHROW flag on the vertex and create and set to true the
3170 3174 * SCF_PROPERTY_DEATHROW boolean property in the non-persistent
3171 3175 * repository for this instance fmri.
3172 3176 */
3173 3177 if ((v->gv_flags & GV_DEATHROW) ||
3174 3178 (is_fmri_in_deathrow(v->gv_name) == B_TRUE)) {
3175 3179 if ((v->gv_flags & GV_DEATHROW) == 0) {
3176 3180 /*
3177 3181 * Set flag GV_DEATHROW, create and set to true
3178 3182 * the SCF_PROPERTY_DEATHROW property in the
3179 3183 * non-persistent repository for this instance fmri.
3180 3184 */
3181 3185 v->gv_flags |= GV_DEATHROW;
3182 3186
3183 3187 switch (err = libscf_set_deathrow(inst, 1)) {
3184 3188 case 0:
3185 3189 break;
3186 3190
3187 3191 case ECONNABORTED:
3188 3192 case ECANCELED:
3189 3193 startd_free(restarter_fmri, max_scf_value_size);
3190 3194 return (err);
3191 3195
3192 3196 case EROFS:
3193 3197 log_error(LOG_WARNING, "Could not set %s/%s "
3194 3198 "for deathrow %s: %s.\n",
3195 3199 SCF_PG_DEATHROW, SCF_PROPERTY_DEATHROW,
3196 3200 v->gv_name, strerror(err));
3197 3201 break;
3198 3202
3199 3203 case EPERM:
3200 3204 uu_die("Permission denied.\n");
3201 3205 /* NOTREACHED */
3202 3206
3203 3207 default:
3204 3208 bad_error("libscf_set_deathrow", err);
3205 3209 }
3206 3210 log_framework(LOG_DEBUG, "Deathrow, graph set %s.\n",
3207 3211 v->gv_name);
3208 3212 }
3209 3213 startd_free(restarter_fmri, max_scf_value_size);
3210 3214 return (0);
3211 3215 }
3212 3216
3213 3217 h = scf_instance_handle(inst);
3214 3218
3215 3219 /*
3216 3220 * Using a temporary deathrow boolean property, set through
3217 3221 * libscf_set_deathrow(), only for fmris on deathrow, is necessary
3218 3222 * because deathrow_fini() may already have been called, and in case
3219 3223 * of a refresh, GV_DEATHROW may need to be set again.
3220 3224 * libscf_get_deathrow() sets deathrow to 1 only if this instance
3221 3225 * has a temporary boolean property named 'deathrow' valued true
3222 3226 * in a property group 'deathrow', -1 or 0 in all other cases.
3223 3227 */
3224 3228 err = libscf_get_deathrow(h, inst, &deathrow);
3225 3229 switch (err) {
3226 3230 case 0:
3227 3231 break;
3228 3232
3229 3233 case ECONNABORTED:
3230 3234 case ECANCELED:
3231 3235 startd_free(restarter_fmri, max_scf_value_size);
3232 3236 return (err);
3233 3237
3234 3238 default:
3235 3239 bad_error("libscf_get_deathrow", err);
3236 3240 }
3237 3241
3238 3242 if (deathrow == 1) {
3239 3243 v->gv_flags |= GV_DEATHROW;
3240 3244 startd_free(restarter_fmri, max_scf_value_size);
3241 3245 return (0);
3242 3246 }
3243 3247
3244 3248 log_framework(LOG_DEBUG, "Graph adding %s.\n", v->gv_name);
3245 3249
3246 3250 /*
3247 3251 * If the instance does not have a restarter property group,
3248 3252 * initialize its state to uninitialized/none, in case the restarter
3249 3253 * is not enabled.
3250 3254 */
3251 3255 pg = safe_scf_pg_create(h);
3252 3256
3253 3257 if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, pg) != 0) {
3254 3258 instance_data_t idata;
3255 3259 uint_t count = 0, msecs = ALLOC_DELAY;
3256 3260
3257 3261 switch (scf_error()) {
3258 3262 case SCF_ERROR_NOT_FOUND:
3259 3263 break;
3260 3264
3261 3265 case SCF_ERROR_CONNECTION_BROKEN:
3262 3266 default:
3263 3267 scf_pg_destroy(pg);
3264 3268 startd_free(restarter_fmri, max_scf_value_size);
3265 3269 return (ECONNABORTED);
3266 3270
3267 3271 case SCF_ERROR_DELETED:
3268 3272 scf_pg_destroy(pg);
3269 3273 startd_free(restarter_fmri, max_scf_value_size);
3270 3274 return (ECANCELED);
3271 3275
3272 3276 case SCF_ERROR_NOT_SET:
3273 3277 bad_error("scf_instance_get_pg", scf_error());
3274 3278 }
3275 3279
3276 3280 switch (err = libscf_instance_get_fmri(inst,
3277 3281 (char **)&idata.i_fmri)) {
3278 3282 case 0:
3279 3283 break;
3280 3284
3281 3285 case ECONNABORTED:
3282 3286 case ECANCELED:
3283 3287 scf_pg_destroy(pg);
3284 3288 startd_free(restarter_fmri, max_scf_value_size);
3285 3289 return (err);
3286 3290
3287 3291 default:
3288 3292 bad_error("libscf_instance_get_fmri", err);
3289 3293 }
3290 3294
3291 3295 idata.i_state = RESTARTER_STATE_NONE;
3292 3296 idata.i_next_state = RESTARTER_STATE_NONE;
3293 3297
3294 3298 init_state:
3295 3299 switch (err = _restarter_commit_states(h, &idata,
3296 3300 RESTARTER_STATE_UNINIT, RESTARTER_STATE_NONE,
3297 3301 restarter_get_str_short(restarter_str_insert_in_graph))) {
3298 3302 case 0:
3299 3303 break;
3300 3304
3301 3305 case ENOMEM:
3302 3306 ++count;
3303 3307 if (count < ALLOC_RETRY) {
3304 3308 (void) poll(NULL, 0, msecs);
3305 3309 msecs *= ALLOC_DELAY_MULT;
3306 3310 goto init_state;
3307 3311 }
3308 3312
3309 3313 uu_die("Insufficient memory.\n");
3310 3314 /* NOTREACHED */
3311 3315
3312 3316 case ECONNABORTED:
3313 3317 startd_free((void *)idata.i_fmri, max_scf_fmri_size);
3314 3318 scf_pg_destroy(pg);
3315 3319 startd_free(restarter_fmri, max_scf_value_size);
3316 3320 return (ECONNABORTED);
3317 3321
3318 3322 case ENOENT:
3319 3323 startd_free((void *)idata.i_fmri, max_scf_fmri_size);
3320 3324 scf_pg_destroy(pg);
3321 3325 startd_free(restarter_fmri, max_scf_value_size);
3322 3326 return (ECANCELED);
3323 3327
3324 3328 case EPERM:
3325 3329 case EACCES:
3326 3330 case EROFS:
3327 3331 log_error(LOG_NOTICE, "Could not initialize state for "
3328 3332 "%s: %s.\n", idata.i_fmri, strerror(err));
3329 3333 break;
3330 3334
3331 3335 case EINVAL:
3332 3336 default:
3333 3337 bad_error("_restarter_commit_states", err);
3334 3338 }
3335 3339
3336 3340 startd_free((void *)idata.i_fmri, max_scf_fmri_size);
3337 3341 }
3338 3342
3339 3343 scf_pg_destroy(pg);
3340 3344
3341 3345 if (milestone != NULL) {
3342 3346 /*
3343 3347 * Make sure the enable-override is set properly before we
3344 3348 * read whether we should be enabled.
3345 3349 */
3346 3350 if (milestone == MILESTONE_NONE ||
3347 3351 !(v->gv_flags & GV_INSUBGRAPH)) {
3348 3352 /*
3349 3353 * This might seem unjustified after the milestone
3350 3354 * transition has completed (non_subgraph_svcs == 0),
3351 3355 * but it's important because when we boot to
3352 3356 * a milestone, we set the milestone before populating
3353 3357 * the graph, and all of the new non-subgraph services
3354 3358 * need to be disabled here.
3355 3359 */
3356 3360 switch (err = libscf_set_enable_ovr(inst, 0)) {
3357 3361 case 0:
3358 3362 break;
3359 3363
3360 3364 case ECONNABORTED:
3361 3365 case ECANCELED:
3362 3366 startd_free(restarter_fmri, max_scf_value_size);
3363 3367 return (err);
3364 3368
3365 3369 case EROFS:
3366 3370 log_error(LOG_WARNING,
3367 3371 "Could not set %s/%s for %s: %s.\n",
3368 3372 SCF_PG_GENERAL_OVR, SCF_PROPERTY_ENABLED,
3369 3373 v->gv_name, strerror(err));
3370 3374 break;
3371 3375
3372 3376 case EPERM:
3373 3377 uu_die("Permission denied.\n");
3374 3378 /* NOTREACHED */
3375 3379
3376 3380 default:
3377 3381 bad_error("libscf_set_enable_ovr", err);
3378 3382 }
3379 3383 } else {
3380 3384 assert(v->gv_flags & GV_INSUBGRAPH);
3381 3385 switch (err = libscf_delete_enable_ovr(inst)) {
3382 3386 case 0:
3383 3387 break;
3384 3388
3385 3389 case ECONNABORTED:
3386 3390 case ECANCELED:
3387 3391 startd_free(restarter_fmri, max_scf_value_size);
3388 3392 return (err);
3389 3393
3390 3394 case EPERM:
3391 3395 uu_die("Permission denied.\n");
3392 3396 /* NOTREACHED */
3393 3397
3394 3398 default:
3395 3399 bad_error("libscf_delete_enable_ovr", err);
3396 3400 }
3397 3401 }
3398 3402 }
3399 3403
3400 3404 err = libscf_get_basic_instance_data(h, inst, v->gv_name, &enabled,
3401 3405 &enabled_ovr, &restarter_fmri);
3402 3406 switch (err) {
3403 3407 case 0:
3404 3408 break;
3405 3409
3406 3410 case ECONNABORTED:
3407 3411 case ECANCELED:
3408 3412 startd_free(restarter_fmri, max_scf_value_size);
3409 3413 return (err);
3410 3414
3411 3415 case ENOENT:
3412 3416 log_framework(LOG_DEBUG,
3413 3417 "Ignoring %s because it has no general property group.\n",
3414 3418 v->gv_name);
3415 3419 startd_free(restarter_fmri, max_scf_value_size);
3416 3420 return (0);
3417 3421
3418 3422 default:
3419 3423 bad_error("libscf_get_basic_instance_data", err);
3420 3424 }
3421 3425
3422 3426 if ((tset = libscf_get_stn_tset(inst)) == -1) {
3423 3427 log_framework(LOG_WARNING,
3424 3428 "Failed to get notification parameters for %s: %s\n",
3425 3429 v->gv_name, scf_strerror(scf_error()));
3426 3430 v->gv_stn_tset = 0;
3427 3431 } else {
3428 3432 v->gv_stn_tset = tset;
3429 3433 }
3430 3434 if (strcmp(v->gv_name, SCF_INSTANCE_GLOBAL) == 0)
3431 3435 stn_global = v->gv_stn_tset;
3432 3436
3433 3437 if (enabled == -1) {
3434 3438 startd_free(restarter_fmri, max_scf_value_size);
3435 3439 return (0);
3436 3440 }
3437 3441
3438 3442 v->gv_flags = (v->gv_flags & ~GV_ENBLD_NOOVR) |
3439 3443 (enabled ? GV_ENBLD_NOOVR : 0);
3440 3444
3441 3445 if (enabled_ovr != -1)
3442 3446 enabled = enabled_ovr;
3443 3447
3444 3448 v->gv_state = RESTARTER_STATE_UNINIT;
3445 3449
3446 3450 snap = libscf_get_or_make_running_snapshot(inst, v->gv_name, B_TRUE);
3447 3451 scf_snapshot_destroy(snap);
3448 3452
3449 3453 /* Set up the restarter. (Sends _ADD_INSTANCE on success.) */
3450 3454 err = graph_change_restarter(v, restarter_fmri, h, &path);
3451 3455 if (err != 0) {
3452 3456 instance_data_t idata;
3453 3457 uint_t count = 0, msecs = ALLOC_DELAY;
3454 3458 restarter_str_t reason;
3455 3459
3456 3460 if (err == ECONNABORTED) {
3457 3461 startd_free(restarter_fmri, max_scf_value_size);
3458 3462 return (err);
3459 3463 }
3460 3464
3461 3465 assert(err == EINVAL || err == ELOOP);
3462 3466
3463 3467 if (err == EINVAL) {
3464 3468 log_framework(LOG_ERR, emsg_invalid_restarter,
3465 3469 v->gv_name, restarter_fmri);
3466 3470 reason = restarter_str_invalid_restarter;
3467 3471 } else {
3468 3472 handle_cycle(v->gv_name, path);
3469 3473 reason = restarter_str_dependency_cycle;
3470 3474 }
3471 3475
3472 3476 startd_free(restarter_fmri, max_scf_value_size);
3473 3477
3474 3478 /*
3475 3479 * We didn't register the instance with the restarter, so we
3476 3480 * must set maintenance mode ourselves.
3477 3481 */
3478 3482 err = libscf_instance_get_fmri(inst, (char **)&idata.i_fmri);
3479 3483 if (err != 0) {
3480 3484 assert(err == ECONNABORTED || err == ECANCELED);
3481 3485 return (err);
3482 3486 }
3483 3487
3484 3488 idata.i_state = RESTARTER_STATE_NONE;
3485 3489 idata.i_next_state = RESTARTER_STATE_NONE;
3486 3490
3487 3491 set_maint:
3488 3492 switch (err = _restarter_commit_states(h, &idata,
3489 3493 RESTARTER_STATE_MAINT, RESTARTER_STATE_NONE,
3490 3494 restarter_get_str_short(reason))) {
3491 3495 case 0:
3492 3496 break;
3493 3497
3494 3498 case ENOMEM:
3495 3499 ++count;
3496 3500 if (count < ALLOC_RETRY) {
3497 3501 (void) poll(NULL, 0, msecs);
3498 3502 msecs *= ALLOC_DELAY_MULT;
3499 3503 goto set_maint;
3500 3504 }
3501 3505
3502 3506 uu_die("Insufficient memory.\n");
3503 3507 /* NOTREACHED */
3504 3508
3505 3509 case ECONNABORTED:
3506 3510 startd_free((void *)idata.i_fmri, max_scf_fmri_size);
3507 3511 return (ECONNABORTED);
3508 3512
3509 3513 case ENOENT:
3510 3514 startd_free((void *)idata.i_fmri, max_scf_fmri_size);
3511 3515 return (ECANCELED);
3512 3516
3513 3517 case EPERM:
3514 3518 case EACCES:
3515 3519 case EROFS:
3516 3520 log_error(LOG_NOTICE, "Could not initialize state for "
3517 3521 "%s: %s.\n", idata.i_fmri, strerror(err));
3518 3522 break;
3519 3523
3520 3524 case EINVAL:
3521 3525 default:
3522 3526 bad_error("_restarter_commit_states", err);
3523 3527 }
3524 3528
3525 3529 startd_free((void *)idata.i_fmri, max_scf_fmri_size);
3526 3530
3527 3531 v->gv_state = RESTARTER_STATE_MAINT;
3528 3532
3529 3533 goto out;
3530 3534 }
3531 3535 startd_free(restarter_fmri, max_scf_value_size);
3532 3536
3533 3537 /* Add all the other dependencies. */
3534 3538 err = refresh_vertex(v, inst);
3535 3539 if (err != 0) {
3536 3540 assert(err == ECONNABORTED);
3537 3541 return (err);
3538 3542 }
3539 3543
3540 3544 out:
3541 3545 v->gv_flags |= GV_CONFIGURED;
3542 3546
3543 3547 graph_enable_by_vertex(v, enabled, 0);
3544 3548
3545 3549 return (0);
3546 3550 }
3547 3551
3548 3552
3549 3553 static void
3550 3554 kill_user_procs(void)
3551 3555 {
3552 3556 (void) fputs("svc.startd: Killing user processes.\n", stdout);
3553 3557
3554 3558 /*
3555 3559 * Despite its name, killall's role is to get select user processes--
3556 3560 * basically those representing terminal-based logins-- to die. Victims
3557 3561 * are located by killall in the utmp database. Since these are most
3558 3562 * often shell based logins, and many shells mask SIGTERM (but are
3559 3563 * responsive to SIGHUP) we first HUP and then shortly thereafter
3560 3564 * kill -9.
3561 3565 */
3562 3566 (void) fork_with_timeout("/usr/sbin/killall HUP", 1, 5);
3563 3567 (void) fork_with_timeout("/usr/sbin/killall KILL", 1, 5);
3564 3568
3565 3569 /*
3566 3570 * Note the selection of user id's 0, 1 and 15, subsequently
3567 3571 * inverted by -v. 15 is reserved for dladmd. Yes, this is a
3568 3572 * kludge-- a better policy is needed.
3569 3573 *
3570 3574 * Note that fork_with_timeout will only wait out the 1 second
3571 3575 * "grace time" if pkill actually returns 0. So if there are
3572 3576 * no matches, this will run to completion much more quickly.
3573 3577 */
3574 3578 (void) fork_with_timeout("/usr/bin/pkill -TERM -v -u 0,1,15", 1, 5);
3575 3579 (void) fork_with_timeout("/usr/bin/pkill -KILL -v -u 0,1,15", 1, 5);
3576 3580 }
3577 3581
3578 3582 static void
3579 3583 do_uadmin(void)
3580 3584 {
3581 3585 const char * const resetting = "/etc/svc/volatile/resetting";
3582 3586 int fd;
3583 3587 struct statvfs vfs;
3584 3588 time_t now;
3585 3589 struct tm nowtm;
3586 3590 char down_buf[256], time_buf[256];
3587 3591 uintptr_t mdep;
3588 3592 #if defined(__i386)
3589 3593 grub_boot_args_t fbarg;
3590 3594 #endif /* __i386 */
3591 3595
3592 3596 mdep = NULL;
3593 3597 fd = creat(resetting, 0777);
3594 3598 if (fd >= 0)
3595 3599 startd_close(fd);
3596 3600 else
3597 3601 uu_warn("Could not create \"%s\"", resetting);
3598 3602
3599 3603 /* Kill dhcpagent if we're not using nfs for root */
3600 3604 if ((statvfs("/", &vfs) == 0) &&
3601 3605 (strncmp(vfs.f_basetype, "nfs", sizeof ("nfs") - 1) != 0))
3602 3606 fork_with_timeout("/usr/bin/pkill -x -u 0 dhcpagent", 0, 5);
3603 3607
3604 3608 /*
3605 3609 * Call sync(2) now, before we kill off user processes. This takes
3606 3610 * advantage of the several seconds of pause we have before the
3607 3611 * killalls are done. Time we can make good use of to get pages
3608 3612 * moving out to disk.
3609 3613 *
3610 3614 * Inside non-global zones, we don't bother, and it's better not to
3611 3615 * anyway, since sync(2) can have system-wide impact.
3612 3616 */
3613 3617 if (getzoneid() == 0)
3614 3618 sync();
3615 3619
3616 3620 kill_user_procs();
3617 3621
3618 3622 /*
3619 3623 * Note that this must come after the killing of user procs, since
3620 3624 * killall relies on utmpx, and this command affects the contents of
3621 3625 * said file.
3622 3626 */
3623 3627 if (access("/usr/lib/acct/closewtmp", X_OK) == 0)
3624 3628 fork_with_timeout("/usr/lib/acct/closewtmp", 0, 5);
3625 3629
3626 3630 /*
3627 3631 * For patches which may be installed as the system is shutting
3628 3632 * down, we need to ensure, one more time, that the boot archive
3629 3633 * really is up to date.
3630 3634 */
3631 3635 if (getzoneid() == 0 && access("/usr/sbin/bootadm", X_OK) == 0)
3632 3636 fork_with_timeout("/usr/sbin/bootadm -ea update_all", 0, 3600);
3633 3637
3634 3638 /*
3635 3639 * Right now, fast reboot is supported only on i386.
3636 3640 * scf_is_fastboot_default() should take care of it.
3637 3641 * If somehow we got there on unsupported platform -
3638 3642 * print warning and fall back to regular reboot.
3639 3643 */
3640 3644 if (halting == AD_FASTREBOOT) {
3641 3645 #if defined(__i386)
3642 3646 int rc;
3643 3647
3644 3648 if ((rc = grub_get_boot_args(&fbarg, NULL,
3645 3649 GRUB_ENTRY_DEFAULT)) == 0) {
3646 3650 mdep = (uintptr_t)&fbarg.gba_bootargs;
3647 3651 } else {
3648 3652 /*
3649 3653 * Failed to read GRUB menu, fall back to normal reboot
3650 3654 */
3651 3655 halting = AD_BOOT;
3652 3656 uu_warn("Failed to process GRUB menu entry "
3653 3657 "for fast reboot.\n\t%s\n"
3654 3658 "Falling back to regular reboot.\n",
3655 3659 grub_strerror(rc));
3656 3660 }
3657 3661 #else /* __i386 */
3658 3662 halting = AD_BOOT;
3659 3663 uu_warn("Fast reboot configured, but not supported by "
3660 3664 "this ISA\n");
3661 3665 #endif /* __i386 */
3662 3666 }
3663 3667
3664 3668 fork_with_timeout("/sbin/umountall -l", 0, 5);
3665 3669 fork_with_timeout("/sbin/umount /tmp /var/adm /var/run /var "
3666 3670 ">/dev/null 2>&1", 0, 5);
3667 3671
3668 3672 /*
3669 3673 * Try to get to consistency for whatever UFS filesystems are left.
3670 3674 * This is pretty expensive, so we save it for the end in the hopes of
3671 3675 * minimizing what it must do. The other option would be to start in
3672 3676 * parallel with the killall's, but lockfs tends to throw out much more
3673 3677 * than is needed, and so subsequent commands (like umountall) take a
3674 3678 * long time to get going again.
3675 3679 *
3676 3680 * Inside of zones, we don't bother, since we're not about to terminate
3677 3681 * the whole OS instance.
3678 3682 *
3679 3683 * On systems using only ZFS, this call to lockfs -fa is a no-op.
3680 3684 */
3681 3685 if (getzoneid() == 0) {
3682 3686 if (access("/usr/sbin/lockfs", X_OK) == 0)
3683 3687 fork_with_timeout("/usr/sbin/lockfs -fa", 0, 30);
3684 3688
3685 3689 sync(); /* once more, with feeling */
3686 3690 }
3687 3691
3688 3692 fork_with_timeout("/sbin/umount /usr >/dev/null 2>&1", 0, 5);
3689 3693
3690 3694 /*
3691 3695 * Construct and emit the last words from userland:
3692 3696 * "<timestamp> The system is down. Shutdown took <N> seconds."
3693 3697 *
3694 3698 * Normally we'd use syslog, but with /var and other things
3695 3699 * potentially gone, try to minimize the external dependencies.
3696 3700 */
3697 3701 now = time(NULL);
3698 3702 (void) localtime_r(&now, &nowtm);
3699 3703
3700 3704 if (strftime(down_buf, sizeof (down_buf),
3701 3705 "%b %e %T The system is down.", &nowtm) == 0) {
3702 3706 (void) strlcpy(down_buf, "The system is down.",
3703 3707 sizeof (down_buf));
3704 3708 }
3705 3709
3706 3710 if (halting_time != 0 && halting_time <= now) {
3707 3711 (void) snprintf(time_buf, sizeof (time_buf),
3708 3712 " Shutdown took %lu seconds.", now - halting_time);
3709 3713 } else {
3710 3714 time_buf[0] = '\0';
3711 3715 }
3712 3716 (void) printf("%s%s\n", down_buf, time_buf);
3713 3717
3714 3718 (void) uadmin(A_SHUTDOWN, halting, mdep);
3715 3719 uu_warn("uadmin() failed");
3716 3720
3717 3721 #if defined(__i386)
3718 3722 /* uadmin fail, cleanup grub_boot_args */
3719 3723 if (halting == AD_FASTREBOOT)
3720 3724 grub_cleanup_boot_args(&fbarg);
3721 3725 #endif /* __i386 */
3722 3726
3723 3727 if (remove(resetting) != 0 && errno != ENOENT)
3724 3728 uu_warn("Could not remove \"%s\"", resetting);
3725 3729 }
3726 3730
3727 3731 /*
3728 3732 * If any of the up_svcs[] are online or satisfiable, return true. If they are
3729 3733 * all missing, disabled, in maintenance, or unsatisfiable, return false.
3730 3734 */
3731 3735 boolean_t
3732 3736 can_come_up(void)
3733 3737 {
3734 3738 int i;
3735 3739
3736 3740 assert(MUTEX_HELD(&dgraph_lock));
3737 3741
3738 3742 /*
3739 3743 * If we are booting to single user (boot -s),
3740 3744 * SCF_MILESTONE_SINGLE_USER is needed to come up because startd
3741 3745 * spawns sulogin after single-user is online (see specials.c).
3742 3746 */
3743 3747 i = (booting_to_single_user ? 0 : 1);
3744 3748
3745 3749 for (; up_svcs[i] != NULL; ++i) {
3746 3750 if (up_svcs_p[i] == NULL) {
3747 3751 up_svcs_p[i] = vertex_get_by_name(up_svcs[i]);
3748 3752
3749 3753 if (up_svcs_p[i] == NULL)
3750 3754 continue;
3751 3755 }
3752 3756
3753 3757 /*
3754 3758 * Ignore unconfigured services (the ones that have been
3755 3759 * mentioned in a dependency from other services, but do
3756 3760 * not exist in the repository). Services which exist
3757 3761 * in the repository but don't have general/enabled
3758 3762 * property will be also ignored.
3759 3763 */
3760 3764 if (!(up_svcs_p[i]->gv_flags & GV_CONFIGURED))
3761 3765 continue;
3762 3766
3763 3767 switch (up_svcs_p[i]->gv_state) {
3764 3768 case RESTARTER_STATE_ONLINE:
3765 3769 case RESTARTER_STATE_DEGRADED:
3766 3770 /*
3767 3771 * Deactivate verbose boot once a login service has been
3768 3772 * reached.
3769 3773 */
3770 3774 st->st_log_login_reached = 1;
3771 3775 /*FALLTHROUGH*/
3772 3776 case RESTARTER_STATE_UNINIT:
3773 3777 return (B_TRUE);
3774 3778
3775 3779 case RESTARTER_STATE_OFFLINE:
3776 3780 if (instance_satisfied(up_svcs_p[i], B_TRUE) != -1)
3777 3781 return (B_TRUE);
3778 3782 log_framework(LOG_DEBUG,
3779 3783 "can_come_up(): %s is unsatisfiable.\n",
3780 3784 up_svcs_p[i]->gv_name);
3781 3785 continue;
3782 3786
3783 3787 case RESTARTER_STATE_DISABLED:
3784 3788 case RESTARTER_STATE_MAINT:
3785 3789 log_framework(LOG_DEBUG,
3786 3790 "can_come_up(): %s is in state %s.\n",
3787 3791 up_svcs_p[i]->gv_name,
3788 3792 instance_state_str[up_svcs_p[i]->gv_state]);
3789 3793 continue;
3790 3794
3791 3795 default:
3792 3796 #ifndef NDEBUG
3793 3797 uu_warn("%s:%d: Unexpected vertex state %d.\n",
3794 3798 __FILE__, __LINE__, up_svcs_p[i]->gv_state);
3795 3799 #endif
3796 3800 abort();
3797 3801 }
3798 3802 }
3799 3803
3800 3804 /*
3801 3805 * In the seed repository, console-login is unsatisfiable because
3802 3806 * services are missing. To behave correctly in that case we don't want
3803 3807 * to return false until manifest-import is online.
3804 3808 */
3805 3809
3806 3810 if (manifest_import_p == NULL) {
3807 3811 manifest_import_p = vertex_get_by_name(manifest_import);
3808 3812
3809 3813 if (manifest_import_p == NULL)
3810 3814 return (B_FALSE);
3811 3815 }
3812 3816
3813 3817 switch (manifest_import_p->gv_state) {
3814 3818 case RESTARTER_STATE_ONLINE:
3815 3819 case RESTARTER_STATE_DEGRADED:
3816 3820 case RESTARTER_STATE_DISABLED:
3817 3821 case RESTARTER_STATE_MAINT:
3818 3822 break;
3819 3823
3820 3824 case RESTARTER_STATE_OFFLINE:
3821 3825 if (instance_satisfied(manifest_import_p, B_TRUE) == -1)
3822 3826 break;
3823 3827 /* FALLTHROUGH */
3824 3828
3825 3829 case RESTARTER_STATE_UNINIT:
3826 3830 return (B_TRUE);
3827 3831 }
3828 3832
3829 3833 return (B_FALSE);
3830 3834 }
3831 3835
3832 3836 /*
3833 3837 * Runs sulogin. Returns
3834 3838 * 0 - success
3835 3839 * EALREADY - sulogin is already running
3836 3840 * EBUSY - console-login is running
3837 3841 */
3838 3842 static int
3839 3843 run_sulogin(const char *msg)
3840 3844 {
3841 3845 graph_vertex_t *v;
3842 3846
3843 3847 assert(MUTEX_HELD(&dgraph_lock));
3844 3848
3845 3849 if (sulogin_running)
3846 3850 return (EALREADY);
3847 3851
3848 3852 v = vertex_get_by_name(console_login_fmri);
3849 3853 if (v != NULL && inst_running(v))
3850 3854 return (EBUSY);
3851 3855
3852 3856 sulogin_running = B_TRUE;
3853 3857
3854 3858 MUTEX_UNLOCK(&dgraph_lock);
3855 3859
3856 3860 fork_sulogin(B_FALSE, msg);
3857 3861
3858 3862 MUTEX_LOCK(&dgraph_lock);
3859 3863
3860 3864 sulogin_running = B_FALSE;
3861 3865
3862 3866 if (console_login_ready) {
3863 3867 v = vertex_get_by_name(console_login_fmri);
3864 3868
3865 3869 if (v != NULL && v->gv_state == RESTARTER_STATE_OFFLINE) {
3866 3870 if (v->gv_start_f == NULL)
3867 3871 vertex_send_event(v,
3868 3872 RESTARTER_EVENT_TYPE_START);
3869 3873 else
3870 3874 v->gv_start_f(v);
3871 3875 }
3872 3876
3873 3877 console_login_ready = B_FALSE;
3874 3878 }
3875 3879
3876 3880 return (0);
3877 3881 }
3878 3882
3879 3883 /*
3880 3884 * The sulogin thread runs sulogin while can_come_up() is false. run_sulogin()
3881 3885 * keeps sulogin from stepping on console-login's toes.
3882 3886 */
3883 3887 /* ARGSUSED */
3884 3888 static void *
3885 3889 sulogin_thread(void *unused)
3886 3890 {
3887 3891 MUTEX_LOCK(&dgraph_lock);
3888 3892
3889 3893 assert(sulogin_thread_running);
3890 3894
3891 3895 do {
3892 3896 (void) run_sulogin("Console login service(s) cannot run\n");
3893 3897 } while (!can_come_up());
3894 3898
3895 3899 sulogin_thread_running = B_FALSE;
3896 3900 MUTEX_UNLOCK(&dgraph_lock);
3897 3901
3898 3902 return (NULL);
3899 3903 }
3900 3904
3901 3905 /* ARGSUSED */
3902 3906 void *
3903 3907 single_user_thread(void *unused)
3904 3908 {
3905 3909 uint_t left;
3906 3910 scf_handle_t *h;
3907 3911 scf_instance_t *inst;
3908 3912 scf_property_t *prop;
3909 3913 scf_value_t *val;
3910 3914 const char *msg;
3911 3915 char *buf;
3912 3916 int r;
3913 3917
3914 3918 MUTEX_LOCK(&single_user_thread_lock);
3915 3919 single_user_thread_count++;
3916 3920
3917 3921 if (!booting_to_single_user)
3918 3922 kill_user_procs();
3919 3923
3920 3924 if (go_single_user_mode || booting_to_single_user) {
3921 3925 msg = "SINGLE USER MODE\n";
3922 3926 } else {
3923 3927 assert(go_to_level1);
3924 3928
3925 3929 fork_rc_script('1', "start", B_TRUE);
3926 3930
3927 3931 uu_warn("The system is ready for administration.\n");
3928 3932
3929 3933 msg = "";
3930 3934 }
3931 3935
3932 3936 MUTEX_UNLOCK(&single_user_thread_lock);
3933 3937
3934 3938 for (;;) {
3935 3939 MUTEX_LOCK(&dgraph_lock);
3936 3940 r = run_sulogin(msg);
3937 3941 MUTEX_UNLOCK(&dgraph_lock);
3938 3942 if (r == 0)
3939 3943 break;
3940 3944
3941 3945 assert(r == EALREADY || r == EBUSY);
3942 3946
3943 3947 left = 3;
3944 3948 while (left > 0)
3945 3949 left = sleep(left);
3946 3950 }
3947 3951
3948 3952 MUTEX_LOCK(&single_user_thread_lock);
3949 3953
3950 3954 /*
3951 3955 * If another single user thread has started, let it finish changing
3952 3956 * the run level.
3953 3957 */
3954 3958 if (single_user_thread_count > 1) {
3955 3959 single_user_thread_count--;
3956 3960 MUTEX_UNLOCK(&single_user_thread_lock);
3957 3961 return (NULL);
3958 3962 }
3959 3963
3960 3964 h = libscf_handle_create_bound_loop();
3961 3965 inst = scf_instance_create(h);
3962 3966 prop = safe_scf_property_create(h);
3963 3967 val = safe_scf_value_create(h);
3964 3968 buf = startd_alloc(max_scf_fmri_size);
3965 3969
3966 3970 lookup:
3967 3971 if (scf_handle_decode_fmri(h, SCF_SERVICE_STARTD, NULL, NULL, inst,
3968 3972 NULL, NULL, SCF_DECODE_FMRI_EXACT) != 0) {
3969 3973 switch (scf_error()) {
3970 3974 case SCF_ERROR_NOT_FOUND:
3971 3975 r = libscf_create_self(h);
3972 3976 if (r == 0)
3973 3977 goto lookup;
3974 3978 assert(r == ECONNABORTED);
3975 3979 /* FALLTHROUGH */
3976 3980
3977 3981 case SCF_ERROR_CONNECTION_BROKEN:
3978 3982 libscf_handle_rebind(h);
3979 3983 goto lookup;
3980 3984
3981 3985 case SCF_ERROR_INVALID_ARGUMENT:
3982 3986 case SCF_ERROR_CONSTRAINT_VIOLATED:
3983 3987 case SCF_ERROR_NOT_BOUND:
3984 3988 case SCF_ERROR_HANDLE_MISMATCH:
3985 3989 default:
3986 3990 bad_error("scf_handle_decode_fmri", scf_error());
3987 3991 }
3988 3992 }
3989 3993
3990 3994 MUTEX_LOCK(&dgraph_lock);
3991 3995
3992 3996 r = scf_instance_delete_prop(inst, SCF_PG_OPTIONS_OVR,
3993 3997 SCF_PROPERTY_MILESTONE);
3994 3998 switch (r) {
3995 3999 case 0:
3996 4000 case ECANCELED:
3997 4001 break;
3998 4002
3999 4003 case ECONNABORTED:
4000 4004 MUTEX_UNLOCK(&dgraph_lock);
4001 4005 libscf_handle_rebind(h);
4002 4006 goto lookup;
4003 4007
4004 4008 case EPERM:
4005 4009 case EACCES:
4006 4010 case EROFS:
4007 4011 log_error(LOG_WARNING, "Could not clear temporary milestone: "
4008 4012 "%s.\n", strerror(r));
4009 4013 break;
4010 4014
4011 4015 default:
4012 4016 bad_error("scf_instance_delete_prop", r);
4013 4017 }
4014 4018
4015 4019 MUTEX_UNLOCK(&dgraph_lock);
4016 4020
4017 4021 r = libscf_get_milestone(inst, prop, val, buf, max_scf_fmri_size);
4018 4022 switch (r) {
4019 4023 case ECANCELED:
4020 4024 case ENOENT:
4021 4025 case EINVAL:
4022 4026 (void) strcpy(buf, "all");
4023 4027 /* FALLTHROUGH */
4024 4028
4025 4029 case 0:
4026 4030 uu_warn("Returning to milestone %s.\n", buf);
4027 4031 break;
4028 4032
4029 4033 case ECONNABORTED:
4030 4034 libscf_handle_rebind(h);
4031 4035 goto lookup;
4032 4036
4033 4037 default:
4034 4038 bad_error("libscf_get_milestone", r);
4035 4039 }
4036 4040
4037 4041 r = dgraph_set_milestone(buf, h, B_FALSE);
4038 4042 switch (r) {
4039 4043 case 0:
4040 4044 case ECONNRESET:
4041 4045 case EALREADY:
4042 4046 case EINVAL:
4043 4047 case ENOENT:
4044 4048 break;
4045 4049
4046 4050 default:
4047 4051 bad_error("dgraph_set_milestone", r);
4048 4052 }
4049 4053
4050 4054 /*
4051 4055 * See graph_runlevel_changed().
4052 4056 */
4053 4057 MUTEX_LOCK(&dgraph_lock);
4054 4058 utmpx_set_runlevel(target_milestone_as_runlevel(), 'S', B_TRUE);
4055 4059 MUTEX_UNLOCK(&dgraph_lock);
4056 4060
4057 4061 startd_free(buf, max_scf_fmri_size);
4058 4062 scf_value_destroy(val);
4059 4063 scf_property_destroy(prop);
4060 4064 scf_instance_destroy(inst);
4061 4065 scf_handle_destroy(h);
4062 4066
4063 4067 /*
4064 4068 * We'll give ourselves 3 seconds to respond to all of the enablings
4065 4069 * that setting the milestone should have created before checking
4066 4070 * whether to run sulogin.
4067 4071 */
4068 4072 left = 3;
4069 4073 while (left > 0)
4070 4074 left = sleep(left);
4071 4075
4072 4076 MUTEX_LOCK(&dgraph_lock);
4073 4077 /*
4074 4078 * Clearing these variables will allow the sulogin thread to run. We
4075 4079 * check here in case there aren't any more state updates anytime soon.
4076 4080 */
4077 4081 go_to_level1 = go_single_user_mode = booting_to_single_user = B_FALSE;
4078 4082 if (!sulogin_thread_running && !can_come_up()) {
4079 4083 (void) startd_thread_create(sulogin_thread, NULL);
4080 4084 sulogin_thread_running = B_TRUE;
4081 4085 }
4082 4086 MUTEX_UNLOCK(&dgraph_lock);
4083 4087 single_user_thread_count--;
4084 4088 MUTEX_UNLOCK(&single_user_thread_lock);
4085 4089 return (NULL);
4086 4090 }
4087 4091
4088 4092
4089 4093 /*
4090 4094 * Dependency graph operations API. These are handle-independent thread-safe
4091 4095 * graph manipulation functions which are the entry points for the event
4092 4096 * threads below.
4093 4097 */
4094 4098
4095 4099 /*
4096 4100 * If a configured vertex exists for inst_fmri, return EEXIST. If no vertex
4097 4101 * exists for inst_fmri, add one. Then fetch the restarter from inst, make
4098 4102 * this vertex dependent on it, and send _ADD_INSTANCE to the restarter.
4099 4103 * Fetch whether the instance should be enabled from inst and send _ENABLE or
4100 4104 * _DISABLE as appropriate. Finally rummage through inst's dependency
4101 4105 * property groups and add vertices and edges as appropriate. If anything
4102 4106 * goes wrong after sending _ADD_INSTANCE, send _ADMIN_MAINT_ON to put the
4103 4107 * instance in maintenance. Don't send _START or _STOP until we get a state
4104 4108 * update in case we're being restarted and the service is already running.
4105 4109 *
4106 4110 * To support booting to a milestone, we must also make sure all dependencies
4107 4111 * encountered are configured, if they exist in the repository.
4108 4112 *
4109 4113 * Returns 0 on success, ECONNABORTED on repository disconnection, EINVAL if
4110 4114 * inst_fmri is an invalid (or not canonical) FMRI, ECANCELED if inst is
4111 4115 * deleted, or EEXIST if a configured vertex for inst_fmri already exists.
4112 4116 */
4113 4117 int
4114 4118 dgraph_add_instance(const char *inst_fmri, scf_instance_t *inst,
4115 4119 boolean_t lock_graph)
4116 4120 {
4117 4121 graph_vertex_t *v;
4118 4122 int err;
4119 4123
4120 4124 if (strcmp(inst_fmri, SCF_SERVICE_STARTD) == 0)
4121 4125 return (0);
4122 4126
4123 4127 /* Check for a vertex for inst_fmri. */
4124 4128 if (lock_graph) {
4125 4129 MUTEX_LOCK(&dgraph_lock);
4126 4130 } else {
4127 4131 assert(MUTEX_HELD(&dgraph_lock));
4128 4132 }
4129 4133
4130 4134 v = vertex_get_by_name(inst_fmri);
4131 4135
4132 4136 if (v != NULL) {
4133 4137 assert(v->gv_type == GVT_INST);
4134 4138
4135 4139 if (v->gv_flags & GV_CONFIGURED) {
4136 4140 if (lock_graph)
4137 4141 MUTEX_UNLOCK(&dgraph_lock);
4138 4142 return (EEXIST);
4139 4143 }
4140 4144 } else {
4141 4145 /* Add the vertex. */
4142 4146 err = graph_insert_vertex_unconfigured(inst_fmri, GVT_INST, 0,
4143 4147 RERR_NONE, &v);
4144 4148 if (err != 0) {
4145 4149 assert(err == EINVAL);
4146 4150 if (lock_graph)
4147 4151 MUTEX_UNLOCK(&dgraph_lock);
4148 4152 return (EINVAL);
4149 4153 }
4150 4154 }
4151 4155
4152 4156 err = configure_vertex(v, inst);
4153 4157
4154 4158 if (lock_graph)
4155 4159 MUTEX_UNLOCK(&dgraph_lock);
4156 4160
4157 4161 return (err);
4158 4162 }
4159 4163
4160 4164 /*
4161 4165 * Locate the vertex for this property group's instance. If it doesn't exist
4162 4166 * or is unconfigured, call dgraph_add_instance() & return. Otherwise fetch
4163 4167 * the restarter for the instance, and if it has changed, send
4164 4168 * _REMOVE_INSTANCE to the old restarter, remove the dependency, make sure the
4165 4169 * new restarter has a vertex, add a new dependency, and send _ADD_INSTANCE to
4166 4170 * the new restarter. Then fetch whether the instance should be enabled, and
4167 4171 * if it is different from what we had, or if we changed the restarter, send
4168 4172 * the appropriate _ENABLE or _DISABLE command.
4169 4173 *
4170 4174 * Returns 0 on success, ENOTSUP if the pg's parent is not an instance,
4171 4175 * ECONNABORTED on repository disconnection, ECANCELED if the instance is
4172 4176 * deleted, or -1 if the instance's general property group is deleted or if
4173 4177 * its enabled property is misconfigured.
4174 4178 */
4175 4179 static int
4176 4180 dgraph_update_general(scf_propertygroup_t *pg)
4177 4181 {
4178 4182 scf_handle_t *h;
4179 4183 scf_instance_t *inst;
4180 4184 char *fmri;
4181 4185 char *restarter_fmri;
4182 4186 graph_vertex_t *v;
4183 4187 int err;
4184 4188 int enabled, enabled_ovr;
4185 4189 int oldflags;
4186 4190
4187 4191 /* Find the vertex for this service */
4188 4192 h = scf_pg_handle(pg);
4189 4193
4190 4194 inst = safe_scf_instance_create(h);
4191 4195
4192 4196 if (scf_pg_get_parent_instance(pg, inst) != 0) {
4193 4197 switch (scf_error()) {
4194 4198 case SCF_ERROR_CONSTRAINT_VIOLATED:
4195 4199 return (ENOTSUP);
4196 4200
4197 4201 case SCF_ERROR_CONNECTION_BROKEN:
4198 4202 default:
4199 4203 return (ECONNABORTED);
4200 4204
4201 4205 case SCF_ERROR_DELETED:
4202 4206 return (0);
4203 4207
4204 4208 case SCF_ERROR_NOT_SET:
4205 4209 bad_error("scf_pg_get_parent_instance", scf_error());
4206 4210 }
4207 4211 }
4208 4212
4209 4213 err = libscf_instance_get_fmri(inst, &fmri);
4210 4214 switch (err) {
4211 4215 case 0:
4212 4216 break;
4213 4217
4214 4218 case ECONNABORTED:
4215 4219 scf_instance_destroy(inst);
4216 4220 return (ECONNABORTED);
4217 4221
4218 4222 case ECANCELED:
4219 4223 scf_instance_destroy(inst);
4220 4224 return (0);
4221 4225
4222 4226 default:
4223 4227 bad_error("libscf_instance_get_fmri", err);
4224 4228 }
4225 4229
4226 4230 log_framework(LOG_DEBUG,
4227 4231 "Graph engine: Reloading general properties for %s.\n", fmri);
4228 4232
4229 4233 MUTEX_LOCK(&dgraph_lock);
4230 4234
4231 4235 v = vertex_get_by_name(fmri);
4232 4236 if (v == NULL || !(v->gv_flags & GV_CONFIGURED)) {
4233 4237 /* Will get the up-to-date properties. */
4234 4238 MUTEX_UNLOCK(&dgraph_lock);
4235 4239 err = dgraph_add_instance(fmri, inst, B_TRUE);
4236 4240 startd_free(fmri, max_scf_fmri_size);
4237 4241 scf_instance_destroy(inst);
4238 4242 return (err == ECANCELED ? 0 : err);
4239 4243 }
4240 4244
4241 4245 /* Read enabled & restarter from repository. */
4242 4246 restarter_fmri = startd_alloc(max_scf_value_size);
4243 4247 err = libscf_get_basic_instance_data(h, inst, v->gv_name, &enabled,
4244 4248 &enabled_ovr, &restarter_fmri);
4245 4249 if (err != 0 || enabled == -1) {
4246 4250 MUTEX_UNLOCK(&dgraph_lock);
4247 4251 scf_instance_destroy(inst);
4248 4252 startd_free(fmri, max_scf_fmri_size);
4249 4253
4250 4254 switch (err) {
4251 4255 case ENOENT:
4252 4256 case 0:
4253 4257 startd_free(restarter_fmri, max_scf_value_size);
4254 4258 return (-1);
4255 4259
4256 4260 case ECONNABORTED:
4257 4261 case ECANCELED:
4258 4262 startd_free(restarter_fmri, max_scf_value_size);
4259 4263 return (err);
4260 4264
4261 4265 default:
4262 4266 bad_error("libscf_get_basic_instance_data", err);
4263 4267 }
4264 4268 }
4265 4269
4266 4270 oldflags = v->gv_flags;
4267 4271 v->gv_flags = (v->gv_flags & ~GV_ENBLD_NOOVR) |
4268 4272 (enabled ? GV_ENBLD_NOOVR : 0);
4269 4273
4270 4274 if (enabled_ovr != -1)
4271 4275 enabled = enabled_ovr;
4272 4276
4273 4277 /*
4274 4278 * If GV_ENBLD_NOOVR has changed, then we need to re-evaluate the
4275 4279 * subgraph.
4276 4280 */
4277 4281 if (milestone > MILESTONE_NONE && v->gv_flags != oldflags)
4278 4282 (void) eval_subgraph(v, h);
4279 4283
4280 4284 scf_instance_destroy(inst);
4281 4285
4282 4286 /* Ignore restarter change for now. */
4283 4287
4284 4288 startd_free(restarter_fmri, max_scf_value_size);
4285 4289 startd_free(fmri, max_scf_fmri_size);
4286 4290
4287 4291 /*
4288 4292 * Always send _ENABLE or _DISABLE. We could avoid this if the
4289 4293 * restarter didn't change and the enabled value didn't change, but
4290 4294 * that's not easy to check and improbable anyway, so we'll just do
4291 4295 * this.
4292 4296 */
4293 4297 graph_enable_by_vertex(v, enabled, 1);
4294 4298
4295 4299 MUTEX_UNLOCK(&dgraph_lock);
4296 4300
4297 4301 return (0);
4298 4302 }
4299 4303
4300 4304 /*
4301 4305 * Delete all of the property group dependencies of v, update inst's running
4302 4306 * snapshot, and add the dependencies in the new snapshot. If any of the new
4303 4307 * dependencies would create a cycle, send _ADMIN_MAINT_ON. Otherwise
4304 4308 * reevaluate v's dependencies, send _START or _STOP as appropriate, and do
4305 4309 * the same for v's dependents.
4306 4310 *
4307 4311 * Returns
4308 4312 * 0 - success
4309 4313 * ECONNABORTED - repository connection broken
4310 4314 * ECANCELED - inst was deleted
4311 4315 * EINVAL - inst is invalid (e.g., missing general/enabled)
4312 4316 * -1 - libscf_snapshots_refresh() failed
4313 4317 */
4314 4318 static int
4315 4319 dgraph_refresh_instance(graph_vertex_t *v, scf_instance_t *inst)
4316 4320 {
4317 4321 int r;
4318 4322 int enabled;
4319 4323 int32_t tset;
4320 4324
4321 4325 assert(MUTEX_HELD(&dgraph_lock));
4322 4326 assert(v->gv_type == GVT_INST);
4323 4327
4324 4328 /* Only refresh services with valid general/enabled properties. */
4325 4329 r = libscf_get_basic_instance_data(scf_instance_handle(inst), inst,
4326 4330 v->gv_name, &enabled, NULL, NULL);
4327 4331 switch (r) {
4328 4332 case 0:
4329 4333 break;
4330 4334
4331 4335 case ECONNABORTED:
4332 4336 case ECANCELED:
4333 4337 return (r);
4334 4338
4335 4339 case ENOENT:
4336 4340 log_framework(LOG_DEBUG,
4337 4341 "Ignoring %s because it has no general property group.\n",
4338 4342 v->gv_name);
4339 4343 return (EINVAL);
4340 4344
4341 4345 default:
4342 4346 bad_error("libscf_get_basic_instance_data", r);
4343 4347 }
4344 4348
4345 4349 if ((tset = libscf_get_stn_tset(inst)) == -1) {
4346 4350 log_framework(LOG_WARNING,
4347 4351 "Failed to get notification parameters for %s: %s\n",
4348 4352 v->gv_name, scf_strerror(scf_error()));
4349 4353 tset = 0;
4350 4354 }
4351 4355 v->gv_stn_tset = tset;
4352 4356 if (strcmp(v->gv_name, SCF_INSTANCE_GLOBAL) == 0)
4353 4357 stn_global = tset;
4354 4358
4355 4359 if (enabled == -1)
4356 4360 return (EINVAL);
4357 4361
4358 4362 r = libscf_snapshots_refresh(inst, v->gv_name);
4359 4363 if (r != 0) {
4360 4364 if (r != -1)
4361 4365 bad_error("libscf_snapshots_refresh", r);
4362 4366
4363 4367 /* error logged */
4364 4368 return (r);
4365 4369 }
4366 4370
4367 4371 r = refresh_vertex(v, inst);
4368 4372 if (r != 0 && r != ECONNABORTED)
4369 4373 bad_error("refresh_vertex", r);
4370 4374 return (r);
4371 4375 }
4372 4376
4373 4377 /*
4374 4378 * Returns true only if none of this service's dependents are 'up' -- online
4375 4379 * or degraded (offline is considered down in this situation). This function
4376 4380 * is somehow similar to is_nonsubgraph_leaf() but works on subtrees.
4377 4381 */
4378 4382 static boolean_t
4379 4383 insubtree_dependents_down(graph_vertex_t *v)
4380 4384 {
4381 4385 graph_vertex_t *vv;
4382 4386 graph_edge_t *e;
4383 4387
4384 4388 assert(MUTEX_HELD(&dgraph_lock));
4385 4389
4386 4390 for (e = uu_list_first(v->gv_dependents); e != NULL;
4387 4391 e = uu_list_next(v->gv_dependents, e)) {
4388 4392 vv = e->ge_vertex;
4389 4393 if (vv->gv_type == GVT_INST) {
4390 4394 if ((vv->gv_flags & GV_CONFIGURED) == 0)
4391 4395 continue;
4392 4396
4393 4397 if ((vv->gv_flags & GV_TOOFFLINE) == 0)
4394 4398 continue;
4395 4399
4396 4400 if ((vv->gv_state == RESTARTER_STATE_ONLINE) ||
4397 4401 (vv->gv_state == RESTARTER_STATE_DEGRADED))
4398 4402 return (B_FALSE);
4399 4403 } else {
4400 4404 /*
4401 4405 * Skip all excluded and optional_all dependencies
4402 4406 * and decide whether to offline the service based
4403 4407 * on restart_on attribute.
4404 4408 */
4405 4409 if (is_depgrp_bypassed(vv))
4406 4410 continue;
4407 4411
4408 4412 /*
4409 4413 * For dependency groups or service vertices, keep
4410 4414 * traversing to see if instances are running.
4411 4415 */
4412 4416 if (insubtree_dependents_down(vv) == B_FALSE)
4413 4417 return (B_FALSE);
4414 4418 }
4415 4419 }
4416 4420
4417 4421 return (B_TRUE);
4418 4422 }
4419 4423
4420 4424 /*
4421 4425 * Returns true only if none of this service's dependents are 'up' -- online,
4422 4426 * degraded, or offline.
4423 4427 */
4424 4428 static int
4425 4429 is_nonsubgraph_leaf(graph_vertex_t *v)
4426 4430 {
4427 4431 graph_vertex_t *vv;
4428 4432 graph_edge_t *e;
4429 4433
4430 4434 assert(MUTEX_HELD(&dgraph_lock));
4431 4435
4432 4436 for (e = uu_list_first(v->gv_dependents);
4433 4437 e != NULL;
4434 4438 e = uu_list_next(v->gv_dependents, e)) {
4435 4439
4436 4440 vv = e->ge_vertex;
4437 4441 if (vv->gv_type == GVT_INST) {
4438 4442 if ((vv->gv_flags & GV_CONFIGURED) == 0)
4439 4443 continue;
4440 4444
4441 4445 if (vv->gv_flags & GV_INSUBGRAPH)
4442 4446 continue;
4443 4447
4444 4448 if (up_state(vv->gv_state))
4445 4449 return (0);
4446 4450 } else {
4447 4451 /*
4448 4452 * For dependency group or service vertices, keep
4449 4453 * traversing to see if instances are running.
4450 4454 *
4451 4455 * We should skip exclude_all dependencies otherwise
4452 4456 * the vertex will never be considered as a leaf
4453 4457 * if the dependent is offline. The main reason for
4454 4458 * this is that disable_nonsubgraph_leaves() skips
4455 4459 * exclusion dependencies.
4456 4460 */
4457 4461 if (vv->gv_type == GVT_GROUP &&
4458 4462 vv->gv_depgroup == DEPGRP_EXCLUDE_ALL)
4459 4463 continue;
4460 4464
4461 4465 if (!is_nonsubgraph_leaf(vv))
4462 4466 return (0);
4463 4467 }
4464 4468 }
4465 4469
4466 4470 return (1);
4467 4471 }
4468 4472
4469 4473 /*
4470 4474 * Disable v temporarily. Attempt to do this by setting its enabled override
4471 4475 * property in the repository. If that fails, send a _DISABLE command.
4472 4476 * Returns 0 on success and ECONNABORTED if the repository connection is
4473 4477 * broken.
4474 4478 */
4475 4479 static int
4476 4480 disable_service_temporarily(graph_vertex_t *v, scf_handle_t *h)
4477 4481 {
4478 4482 const char * const emsg = "Could not temporarily disable %s because "
4479 4483 "%s. Will stop service anyways. Repository status for the "
4480 4484 "service may be inaccurate.\n";
4481 4485 const char * const emsg_cbroken =
4482 4486 "the repository connection was broken";
4483 4487
4484 4488 scf_instance_t *inst;
4485 4489 int r;
4486 4490
4487 4491 inst = scf_instance_create(h);
4488 4492 if (inst == NULL) {
4489 4493 char buf[100];
4490 4494
4491 4495 (void) snprintf(buf, sizeof (buf),
4492 4496 "scf_instance_create() failed (%s)",
4493 4497 scf_strerror(scf_error()));
4494 4498 log_error(LOG_WARNING, emsg, v->gv_name, buf);
4495 4499
4496 4500 graph_enable_by_vertex(v, 0, 0);
4497 4501 return (0);
4498 4502 }
4499 4503
4500 4504 r = scf_handle_decode_fmri(h, v->gv_name, NULL, NULL, inst,
4501 4505 NULL, NULL, SCF_DECODE_FMRI_EXACT);
4502 4506 if (r != 0) {
4503 4507 switch (scf_error()) {
4504 4508 case SCF_ERROR_CONNECTION_BROKEN:
4505 4509 log_error(LOG_WARNING, emsg, v->gv_name, emsg_cbroken);
4506 4510 graph_enable_by_vertex(v, 0, 0);
4507 4511 return (ECONNABORTED);
4508 4512
4509 4513 case SCF_ERROR_NOT_FOUND:
4510 4514 return (0);
4511 4515
4512 4516 case SCF_ERROR_HANDLE_MISMATCH:
4513 4517 case SCF_ERROR_INVALID_ARGUMENT:
4514 4518 case SCF_ERROR_CONSTRAINT_VIOLATED:
4515 4519 case SCF_ERROR_NOT_BOUND:
4516 4520 default:
4517 4521 bad_error("scf_handle_decode_fmri",
4518 4522 scf_error());
4519 4523 }
4520 4524 }
4521 4525
4522 4526 r = libscf_set_enable_ovr(inst, 0);
4523 4527 switch (r) {
4524 4528 case 0:
4525 4529 scf_instance_destroy(inst);
4526 4530 return (0);
4527 4531
4528 4532 case ECANCELED:
4529 4533 scf_instance_destroy(inst);
4530 4534 return (0);
4531 4535
4532 4536 case ECONNABORTED:
4533 4537 log_error(LOG_WARNING, emsg, v->gv_name, emsg_cbroken);
4534 4538 graph_enable_by_vertex(v, 0, 0);
4535 4539 return (ECONNABORTED);
4536 4540
4537 4541 case EPERM:
4538 4542 log_error(LOG_WARNING, emsg, v->gv_name,
4539 4543 "the repository denied permission");
4540 4544 graph_enable_by_vertex(v, 0, 0);
4541 4545 return (0);
4542 4546
4543 4547 case EROFS:
4544 4548 log_error(LOG_WARNING, emsg, v->gv_name,
4545 4549 "the repository is read-only");
4546 4550 graph_enable_by_vertex(v, 0, 0);
4547 4551 return (0);
4548 4552
4549 4553 default:
4550 4554 bad_error("libscf_set_enable_ovr", r);
4551 4555 /* NOTREACHED */
4552 4556 }
4553 4557 }
4554 4558
4555 4559 /*
4556 4560 * Of the transitive instance dependencies of v, offline those which are
4557 4561 * in the subtree and which are leaves (i.e., have no dependents which are
4558 4562 * "up").
4559 4563 */
4560 4564 void
4561 4565 offline_subtree_leaves(graph_vertex_t *v, void *arg)
4562 4566 {
4563 4567 assert(MUTEX_HELD(&dgraph_lock));
4564 4568
4565 4569 /* If v isn't an instance, recurse on its dependencies. */
4566 4570 if (v->gv_type != GVT_INST) {
4567 4571 graph_walk_dependencies(v, offline_subtree_leaves, arg);
4568 4572 return;
4569 4573 }
4570 4574
4571 4575 /*
4572 4576 * If v is not in the subtree, so should all of its dependencies,
4573 4577 * so do nothing.
4574 4578 */
4575 4579 if ((v->gv_flags & GV_TOOFFLINE) == 0)
4576 4580 return;
4577 4581
4578 4582 /* If v isn't a leaf because it's already down, recurse. */
4579 4583 if (!up_state(v->gv_state)) {
4580 4584 graph_walk_dependencies(v, offline_subtree_leaves, arg);
4581 4585 return;
4582 4586 }
4583 4587
4584 4588 /* if v is a leaf, offline it or disable it if it's the last one */
4585 4589 if (insubtree_dependents_down(v) == B_TRUE) {
4586 4590 if (v->gv_flags & GV_TODISABLE)
4587 4591 vertex_send_event(v,
4588 4592 RESTARTER_EVENT_TYPE_ADMIN_DISABLE);
4589 4593 else
4590 4594 offline_vertex(v);
4591 4595 }
4592 4596 }
4593 4597
4594 4598 void
4595 4599 graph_offline_subtree_leaves(graph_vertex_t *v, void *h)
4596 4600 {
4597 4601 graph_walk_dependencies(v, offline_subtree_leaves, (void *)h);
4598 4602 }
4599 4603
4600 4604
4601 4605 /*
4602 4606 * Of the transitive instance dependencies of v, disable those which are not
4603 4607 * in the subgraph and which are leaves (i.e., have no dependents which are
4604 4608 * "up").
4605 4609 */
4606 4610 static void
4607 4611 disable_nonsubgraph_leaves(graph_vertex_t *v, void *arg)
4608 4612 {
4609 4613 assert(MUTEX_HELD(&dgraph_lock));
4610 4614
4611 4615 /*
4612 4616 * We must skip exclusion dependencies because they are allowed to
4613 4617 * complete dependency cycles. This is correct because A's exclusion
4614 4618 * dependency on B doesn't bear on the order in which they should be
4615 4619 * stopped. Indeed, the exclusion dependency should guarantee that
4616 4620 * they are never online at the same time.
4617 4621 */
4618 4622 if (v->gv_type == GVT_GROUP && v->gv_depgroup == DEPGRP_EXCLUDE_ALL)
4619 4623 return;
4620 4624
4621 4625 /* If v isn't an instance, recurse on its dependencies. */
4622 4626 if (v->gv_type != GVT_INST)
4623 4627 goto recurse;
4624 4628
4625 4629 if ((v->gv_flags & GV_CONFIGURED) == 0)
4626 4630 /*
4627 4631 * Unconfigured instances should have no dependencies, but in
4628 4632 * case they ever get them,
4629 4633 */
4630 4634 goto recurse;
4631 4635
4632 4636 /*
4633 4637 * If v is in the subgraph, so should all of its dependencies, so do
4634 4638 * nothing.
4635 4639 */
4636 4640 if (v->gv_flags & GV_INSUBGRAPH)
4637 4641 return;
4638 4642
4639 4643 /* If v isn't a leaf because it's already down, recurse. */
4640 4644 if (!up_state(v->gv_state))
4641 4645 goto recurse;
4642 4646
4643 4647 /* If v is disabled but not down yet, be patient. */
4644 4648 if ((v->gv_flags & GV_ENABLED) == 0)
4645 4649 return;
4646 4650
4647 4651 /* If v is a leaf, disable it. */
4648 4652 if (is_nonsubgraph_leaf(v))
4649 4653 (void) disable_service_temporarily(v, (scf_handle_t *)arg);
4650 4654
4651 4655 return;
4652 4656
4653 4657 recurse:
4654 4658 graph_walk_dependencies(v, disable_nonsubgraph_leaves, arg);
4655 4659 }
4656 4660
4657 4661 static int
4658 4662 stn_restarter_state(restarter_instance_state_t rstate)
4659 4663 {
4660 4664 static const struct statemap {
4661 4665 restarter_instance_state_t restarter_state;
4662 4666 int scf_state;
4663 4667 } map[] = {
4664 4668 { RESTARTER_STATE_UNINIT, SCF_STATE_UNINIT },
4665 4669 { RESTARTER_STATE_MAINT, SCF_STATE_MAINT },
4666 4670 { RESTARTER_STATE_OFFLINE, SCF_STATE_OFFLINE },
4667 4671 { RESTARTER_STATE_DISABLED, SCF_STATE_DISABLED },
4668 4672 { RESTARTER_STATE_ONLINE, SCF_STATE_ONLINE },
4669 4673 { RESTARTER_STATE_DEGRADED, SCF_STATE_DEGRADED }
4670 4674 };
4671 4675
4672 4676 int i;
4673 4677
4674 4678 for (i = 0; i < sizeof (map) / sizeof (map[0]); i++) {
4675 4679 if (rstate == map[i].restarter_state)
4676 4680 return (map[i].scf_state);
4677 4681 }
4678 4682
4679 4683 return (-1);
4680 4684 }
4681 4685
4682 4686 /*
4683 4687 * State transition counters
4684 4688 * Not incremented atomically - indicative only
4685 4689 */
4686 4690 static uint64_t stev_ct_maint;
4687 4691 static uint64_t stev_ct_hwerr;
4688 4692 static uint64_t stev_ct_service;
4689 4693 static uint64_t stev_ct_global;
4690 4694 static uint64_t stev_ct_noprefs;
4691 4695 static uint64_t stev_ct_from_uninit;
4692 4696 static uint64_t stev_ct_bad_state;
4693 4697 static uint64_t stev_ct_ovr_prefs;
4694 4698
4695 4699 static void
4696 4700 dgraph_state_transition_notify(graph_vertex_t *v,
4697 4701 restarter_instance_state_t old_state, restarter_str_t reason)
4698 4702 {
4699 4703 restarter_instance_state_t new_state = v->gv_state;
4700 4704 int stn_transition, maint;
4701 4705 int from, to;
4702 4706 nvlist_t *attr;
4703 4707 fmev_pri_t pri = FMEV_LOPRI;
4704 4708 int raise = 0;
4705 4709
4706 4710 if ((from = stn_restarter_state(old_state)) == -1 ||
4707 4711 (to = stn_restarter_state(new_state)) == -1) {
4708 4712 stev_ct_bad_state++;
4709 4713 return;
4710 4714 }
4711 4715
4712 4716 stn_transition = from << 16 | to;
4713 4717
4714 4718 maint = (to == SCF_STATE_MAINT || from == SCF_STATE_MAINT);
4715 4719
4716 4720 if (maint) {
4717 4721 /*
4718 4722 * All transitions to/from maintenance state must raise
4719 4723 * an event.
4720 4724 */
4721 4725 raise++;
4722 4726 pri = FMEV_HIPRI;
4723 4727 stev_ct_maint++;
4724 4728 } else if (reason == restarter_str_ct_ev_hwerr) {
4725 4729 /*
4726 4730 * All transitions caused by hardware fault must raise
4727 4731 * an event
4728 4732 */
4729 4733 raise++;
4730 4734 pri = FMEV_HIPRI;
4731 4735 stev_ct_hwerr++;
4732 4736 } else if (stn_transition & v->gv_stn_tset) {
4733 4737 /*
4734 4738 * Specifically enabled event.
4735 4739 */
4736 4740 raise++;
4737 4741 stev_ct_service++;
4738 4742 } else if (from == SCF_STATE_UNINIT) {
4739 4743 /*
4740 4744 * Only raise these if specifically selected above.
4741 4745 */
4742 4746 stev_ct_from_uninit++;
4743 4747 } else if (stn_transition & stn_global &&
4744 4748 (IS_ENABLED(v) == 1 || to == SCF_STATE_DISABLED)) {
4745 4749 raise++;
4746 4750 stev_ct_global++;
4747 4751 } else {
4748 4752 stev_ct_noprefs++;
4749 4753 }
4750 4754
4751 4755 if (info_events_all) {
4752 4756 stev_ct_ovr_prefs++;
4753 4757 raise++;
4754 4758 }
4755 4759 if (!raise)
4756 4760 return;
4757 4761
4758 4762 if (nvlist_alloc(&attr, NV_UNIQUE_NAME, 0) != 0 ||
4759 4763 nvlist_add_string(attr, "fmri", v->gv_name) != 0 ||
4760 4764 nvlist_add_uint32(attr, "reason-version",
4761 4765 restarter_str_version()) || nvlist_add_string(attr, "reason-short",
4762 4766 restarter_get_str_short(reason)) != 0 ||
4763 4767 nvlist_add_string(attr, "reason-long",
4764 4768 restarter_get_str_long(reason)) != 0 ||
4765 4769 nvlist_add_int32(attr, "transition", stn_transition) != 0) {
4766 4770 log_framework(LOG_WARNING,
4767 4771 "FMEV: %s could not create nvlist for transition "
4768 4772 "event: %s\n", v->gv_name, strerror(errno));
4769 4773 nvlist_free(attr);
4770 4774 return;
4771 4775 }
4772 4776
4773 4777 if (fmev_rspublish_nvl(FMEV_RULESET_SMF, "state-transition",
4774 4778 instance_state_str[new_state], pri, attr) != FMEV_SUCCESS) {
4775 4779 log_framework(LOG_DEBUG,
4776 4780 "FMEV: %s failed to publish transition event: %s\n",
4777 4781 v->gv_name, fmev_strerror(fmev_errno));
4778 4782 nvlist_free(attr);
4779 4783 }
4780 4784 }
4781 4785
4782 4786 /*
4783 4787 * Find the vertex for inst_name. If it doesn't exist, return ENOENT.
4784 4788 * Otherwise set its state to state. If the instance has entered a state
4785 4789 * which requires automatic action, take it (Uninitialized: do
4786 4790 * dgraph_refresh_instance() without the snapshot update. Disabled: if the
4787 4791 * instance should be enabled, send _ENABLE. Offline: if the instance should
4788 4792 * be disabled, send _DISABLE, and if its dependencies are satisfied, send
4789 4793 * _START. Online, Degraded: if the instance wasn't running, update its start
4790 4794 * snapshot. Maintenance: no action.)
4791 4795 *
4792 4796 * Also fails with ECONNABORTED, or EINVAL if state is invalid.
4793 4797 */
4794 4798 static int
4795 4799 dgraph_set_instance_state(scf_handle_t *h, const char *inst_name,
4796 4800 protocol_states_t *states)
4797 4801 {
4798 4802 graph_vertex_t *v;
4799 4803 int err = 0;
4800 4804 restarter_instance_state_t old_state;
4801 4805 restarter_instance_state_t state = states->ps_state;
4802 4806 restarter_error_t serr = states->ps_err;
4803 4807
4804 4808 MUTEX_LOCK(&dgraph_lock);
4805 4809
4806 4810 v = vertex_get_by_name(inst_name);
4807 4811 if (v == NULL) {
4808 4812 MUTEX_UNLOCK(&dgraph_lock);
4809 4813 return (ENOENT);
4810 4814 }
4811 4815
4812 4816 assert(v->gv_type == GVT_INST);
4813 4817
4814 4818 switch (state) {
4815 4819 case RESTARTER_STATE_UNINIT:
4816 4820 case RESTARTER_STATE_DISABLED:
4817 4821 case RESTARTER_STATE_OFFLINE:
4818 4822 case RESTARTER_STATE_ONLINE:
4819 4823 case RESTARTER_STATE_DEGRADED:
4820 4824 case RESTARTER_STATE_MAINT:
4821 4825 break;
4822 4826
4823 4827 default:
4824 4828 MUTEX_UNLOCK(&dgraph_lock);
4825 4829 return (EINVAL);
4826 4830 }
4827 4831
4828 4832 log_framework(LOG_DEBUG, "Graph noting %s %s -> %s.\n", v->gv_name,
4829 4833 instance_state_str[v->gv_state], instance_state_str[state]);
4830 4834
4831 4835 old_state = v->gv_state;
4832 4836 v->gv_state = state;
4833 4837
4834 4838 v->gv_reason = states->ps_reason;
4835 4839 err = gt_transition(h, v, serr, old_state);
4836 4840 if (err == 0 && v->gv_state != old_state) {
4837 4841 dgraph_state_transition_notify(v, old_state, states->ps_reason);
4838 4842 }
4839 4843
4840 4844 MUTEX_UNLOCK(&dgraph_lock);
4841 4845 return (err);
4842 4846 }
4843 4847
4844 4848 /*
4845 4849 * Handle state changes during milestone shutdown. See
4846 4850 * dgraph_set_milestone(). If the repository connection is broken,
4847 4851 * ECONNABORTED will be returned, though a _DISABLE command will be sent for
4848 4852 * the vertex anyway.
4849 4853 */
4850 4854 int
4851 4855 vertex_subgraph_dependencies_shutdown(scf_handle_t *h, graph_vertex_t *v,
4852 4856 restarter_instance_state_t old_state)
4853 4857 {
4854 4858 int was_up, now_up;
4855 4859 int ret = 0;
4856 4860
4857 4861 assert(v->gv_type == GVT_INST);
4858 4862
4859 4863 /* Don't care if we're not going to a milestone. */
4860 4864 if (milestone == NULL)
4861 4865 return (0);
4862 4866
4863 4867 /* Don't care if we already finished coming down. */
4864 4868 if (non_subgraph_svcs == 0)
4865 4869 return (0);
4866 4870
4867 4871 /* Don't care if the service is in the subgraph. */
4868 4872 if (v->gv_flags & GV_INSUBGRAPH)
4869 4873 return (0);
4870 4874
4871 4875 /*
4872 4876 * Update non_subgraph_svcs. It is the number of non-subgraph
4873 4877 * services which are in online, degraded, or offline.
4874 4878 */
4875 4879
4876 4880 was_up = up_state(old_state);
4877 4881 now_up = up_state(v->gv_state);
4878 4882
4879 4883 if (!was_up && now_up) {
4880 4884 ++non_subgraph_svcs;
4881 4885 } else if (was_up && !now_up) {
4882 4886 --non_subgraph_svcs;
4883 4887
4884 4888 if (non_subgraph_svcs == 0) {
4885 4889 if (halting != -1) {
4886 4890 do_uadmin();
4887 4891 } else if (go_single_user_mode || go_to_level1) {
4888 4892 (void) startd_thread_create(single_user_thread,
4889 4893 NULL);
4890 4894 }
4891 4895 return (0);
4892 4896 }
4893 4897 }
4894 4898
4895 4899 /* If this service is a leaf, it should be disabled. */
4896 4900 if ((v->gv_flags & GV_ENABLED) && is_nonsubgraph_leaf(v)) {
4897 4901 int r;
4898 4902
4899 4903 r = disable_service_temporarily(v, h);
4900 4904 switch (r) {
4901 4905 case 0:
4902 4906 break;
4903 4907
4904 4908 case ECONNABORTED:
4905 4909 ret = ECONNABORTED;
4906 4910 break;
4907 4911
4908 4912 default:
4909 4913 bad_error("disable_service_temporarily", r);
4910 4914 }
4911 4915 }
4912 4916
4913 4917 /*
4914 4918 * If the service just came down, propagate the disable to the newly
4915 4919 * exposed leaves.
4916 4920 */
4917 4921 if (was_up && !now_up)
4918 4922 graph_walk_dependencies(v, disable_nonsubgraph_leaves,
4919 4923 (void *)h);
4920 4924
4921 4925 return (ret);
4922 4926 }
4923 4927
4924 4928 /*
4925 4929 * Decide whether to start up an sulogin thread after a service is
4926 4930 * finished changing state. Only need to do the full can_come_up()
4927 4931 * evaluation if an instance is changing state, we're not halfway through
4928 4932 * loading the thread, and we aren't shutting down or going to the single
4929 4933 * user milestone.
4930 4934 */
4931 4935 void
4932 4936 graph_transition_sulogin(restarter_instance_state_t state,
4933 4937 restarter_instance_state_t old_state)
4934 4938 {
4935 4939 assert(MUTEX_HELD(&dgraph_lock));
4936 4940
4937 4941 if (state != old_state && st->st_load_complete &&
4938 4942 !go_single_user_mode && !go_to_level1 &&
4939 4943 halting == -1) {
4940 4944 if (!sulogin_thread_running && !can_come_up()) {
4941 4945 (void) startd_thread_create(sulogin_thread, NULL);
4942 4946 sulogin_thread_running = B_TRUE;
4943 4947 }
4944 4948 }
4945 4949 }
4946 4950
4947 4951 /*
4948 4952 * Propagate a start, stop event, or a satisfiability event.
4949 4953 *
4950 4954 * PROPAGATE_START and PROPAGATE_STOP simply propagate the transition event
4951 4955 * to direct dependents. PROPAGATE_SAT propagates a start then walks the
4952 4956 * full dependent graph to check for newly satisfied nodes. This is
4953 4957 * necessary for cases when non-direct dependents may be effected but direct
4954 4958 * dependents may not (e.g. for optional_all evaluations, see the
4955 4959 * propagate_satbility() comments).
4956 4960 *
4957 4961 * PROPAGATE_SAT should be used whenever a non-running service moves into
4958 4962 * a state which can satisfy optional dependencies, like disabled or
4959 4963 * maintenance.
4960 4964 */
4961 4965 void
4962 4966 graph_transition_propagate(graph_vertex_t *v, propagate_event_t type,
4963 4967 restarter_error_t rerr)
4964 4968 {
4965 4969 if (type == PROPAGATE_STOP) {
4966 4970 graph_walk_dependents(v, propagate_stop, (void *)rerr);
4967 4971 } else if (type == PROPAGATE_START || type == PROPAGATE_SAT) {
4968 4972 graph_walk_dependents(v, propagate_start, NULL);
4969 4973
4970 4974 if (type == PROPAGATE_SAT)
4971 4975 propagate_satbility(v);
4972 4976 } else {
4973 4977 #ifndef NDEBUG
4974 4978 uu_warn("%s:%d: Unexpected type value %d.\n", __FILE__,
4975 4979 __LINE__, type);
4976 4980 #endif
4977 4981 abort();
4978 4982 }
4979 4983 }
4980 4984
4981 4985 /*
4982 4986 * If a vertex for fmri exists and it is enabled, send _DISABLE to the
4983 4987 * restarter. If it is running, send _STOP. Send _REMOVE_INSTANCE. Delete
4984 4988 * all property group dependencies, and the dependency on the restarter,
4985 4989 * disposing of vertices as appropriate. If other vertices depend on this
4986 4990 * one, mark it unconfigured and return. Otherwise remove the vertex. Always
4987 4991 * returns 0.
4988 4992 */
4989 4993 static int
4990 4994 dgraph_remove_instance(const char *fmri, scf_handle_t *h)
4991 4995 {
4992 4996 graph_vertex_t *v;
4993 4997 graph_edge_t *e;
4994 4998 uu_list_t *old_deps;
4995 4999 int err;
4996 5000
4997 5001 log_framework(LOG_DEBUG, "Graph engine: Removing %s.\n", fmri);
4998 5002
4999 5003 MUTEX_LOCK(&dgraph_lock);
5000 5004
5001 5005 v = vertex_get_by_name(fmri);
5002 5006 if (v == NULL) {
5003 5007 MUTEX_UNLOCK(&dgraph_lock);
5004 5008 return (0);
5005 5009 }
5006 5010
5007 5011 /* Send restarter delete event. */
5008 5012 if (v->gv_flags & GV_CONFIGURED)
5009 5013 graph_unset_restarter(v);
5010 5014
5011 5015 if (milestone > MILESTONE_NONE) {
5012 5016 /*
5013 5017 * Make a list of v's current dependencies so we can
5014 5018 * reevaluate their GV_INSUBGRAPH flags after the dependencies
5015 5019 * are removed.
5016 5020 */
5017 5021 old_deps = startd_list_create(graph_edge_pool, NULL, 0);
5018 5022
5019 5023 err = uu_list_walk(v->gv_dependencies,
5020 5024 (uu_walk_fn_t *)append_svcs_or_insts, old_deps, 0);
5021 5025 assert(err == 0);
5022 5026 }
5023 5027
5024 5028 delete_instance_dependencies(v, B_TRUE);
5025 5029
5026 5030 /*
5027 5031 * Deleting an instance can both satisfy and unsatisfy dependencies,
5028 5032 * depending on their type. First propagate the stop as a RERR_RESTART
5029 5033 * event -- deletion isn't a fault, just a normal stop. This gives
5030 5034 * dependent services the chance to do a clean shutdown. Then, mark
5031 5035 * the service as unconfigured and propagate the start event for the
5032 5036 * optional_all dependencies that might have become satisfied.
5033 5037 */
5034 5038 graph_walk_dependents(v, propagate_stop, (void *)RERR_RESTART);
5035 5039
5036 5040 v->gv_flags &= ~GV_CONFIGURED;
5037 5041 v->gv_flags &= ~GV_DEATHROW;
5038 5042
5039 5043 graph_walk_dependents(v, propagate_start, NULL);
5040 5044 propagate_satbility(v);
5041 5045
5042 5046 /*
5043 5047 * If there are no (non-service) dependents, the vertex can be
5044 5048 * completely removed.
5045 5049 */
5046 5050 if (v != milestone && v->gv_refs == 0 &&
5047 5051 uu_list_numnodes(v->gv_dependents) == 1)
5048 5052 remove_inst_vertex(v);
5049 5053
5050 5054 if (milestone > MILESTONE_NONE) {
5051 5055 void *cookie = NULL;
5052 5056
5053 5057 while ((e = uu_list_teardown(old_deps, &cookie)) != NULL) {
5054 5058 v = e->ge_vertex;
5055 5059
5056 5060 if (vertex_unref(v) == VERTEX_INUSE)
5057 5061 while (eval_subgraph(v, h) == ECONNABORTED)
5058 5062 libscf_handle_rebind(h);
5059 5063
5060 5064 startd_free(e, sizeof (*e));
5061 5065 }
5062 5066
5063 5067 uu_list_destroy(old_deps);
5064 5068 }
5065 5069
5066 5070 MUTEX_UNLOCK(&dgraph_lock);
5067 5071
5068 5072 return (0);
5069 5073 }
5070 5074
5071 5075 /*
5072 5076 * Return the eventual (maybe current) milestone in the form of a
5073 5077 * legacy runlevel.
5074 5078 */
5075 5079 static char
5076 5080 target_milestone_as_runlevel()
5077 5081 {
5078 5082 assert(MUTEX_HELD(&dgraph_lock));
5079 5083
5080 5084 if (milestone == NULL)
5081 5085 return ('3');
5082 5086 else if (milestone == MILESTONE_NONE)
5083 5087 return ('0');
5084 5088
5085 5089 if (strcmp(milestone->gv_name, multi_user_fmri) == 0)
5086 5090 return ('2');
5087 5091 else if (strcmp(milestone->gv_name, single_user_fmri) == 0)
5088 5092 return ('S');
5089 5093 else if (strcmp(milestone->gv_name, multi_user_svr_fmri) == 0)
5090 5094 return ('3');
5091 5095
5092 5096 #ifndef NDEBUG
5093 5097 (void) fprintf(stderr, "%s:%d: Unknown milestone name \"%s\".\n",
5094 5098 __FILE__, __LINE__, milestone->gv_name);
5095 5099 #endif
5096 5100 abort();
5097 5101 /* NOTREACHED */
5098 5102 }
5099 5103
5100 5104 static struct {
5101 5105 char rl;
5102 5106 int sig;
5103 5107 } init_sigs[] = {
5104 5108 { 'S', SIGBUS },
5105 5109 { '0', SIGINT },
5106 5110 { '1', SIGQUIT },
5107 5111 { '2', SIGILL },
5108 5112 { '3', SIGTRAP },
5109 5113 { '4', SIGIOT },
5110 5114 { '5', SIGEMT },
5111 5115 { '6', SIGFPE },
5112 5116 { 0, 0 }
5113 5117 };
5114 5118
5115 5119 static void
5116 5120 signal_init(char rl)
5117 5121 {
5118 5122 pid_t init_pid;
5119 5123 int i;
5120 5124
5121 5125 assert(MUTEX_HELD(&dgraph_lock));
5122 5126
5123 5127 if (zone_getattr(getzoneid(), ZONE_ATTR_INITPID, &init_pid,
5124 5128 sizeof (init_pid)) != sizeof (init_pid)) {
5125 5129 log_error(LOG_NOTICE, "Could not get pid to signal init.\n");
5126 5130 return;
5127 5131 }
5128 5132
5129 5133 for (i = 0; init_sigs[i].rl != 0; ++i)
5130 5134 if (init_sigs[i].rl == rl)
5131 5135 break;
5132 5136
5133 5137 if (init_sigs[i].rl != 0) {
5134 5138 if (kill(init_pid, init_sigs[i].sig) != 0) {
5135 5139 switch (errno) {
5136 5140 case EPERM:
5137 5141 case ESRCH:
5138 5142 log_error(LOG_NOTICE, "Could not signal init: "
5139 5143 "%s.\n", strerror(errno));
5140 5144 break;
5141 5145
5142 5146 case EINVAL:
5143 5147 default:
5144 5148 bad_error("kill", errno);
5145 5149 }
5146 5150 }
5147 5151 }
5148 5152 }
5149 5153
5150 5154 /*
5151 5155 * This is called when one of the major milestones changes state, or when
5152 5156 * init is signalled and tells us it was told to change runlevel. We wait
5153 5157 * to reach the milestone because this allows /etc/inittab entries to retain
5154 5158 * some boot ordering: historically, entries could place themselves before/after
5155 5159 * the running of /sbin/rcX scripts but we can no longer make the
5156 5160 * distinction because the /sbin/rcX scripts no longer exist as punctuation
5157 5161 * marks in /etc/inittab.
5158 5162 *
5159 5163 * Also, we only trigger an update when we reach the eventual target
5160 5164 * milestone: without this, an /etc/inittab entry marked only for
5161 5165 * runlevel 2 would be executed for runlevel 3, which is not how
5162 5166 * /etc/inittab entries work.
5163 5167 *
5164 5168 * If we're single user coming online, then we set utmpx to the target
5165 5169 * runlevel so that legacy scripts can work as expected.
5166 5170 */
5167 5171 static void
5168 5172 graph_runlevel_changed(char rl, int online)
5169 5173 {
5170 5174 char trl;
5171 5175
5172 5176 assert(MUTEX_HELD(&dgraph_lock));
5173 5177
5174 5178 trl = target_milestone_as_runlevel();
5175 5179
5176 5180 if (online) {
5177 5181 if (rl == trl) {
5178 5182 current_runlevel = trl;
5179 5183 signal_init(trl);
5180 5184 } else if (rl == 'S') {
5181 5185 /*
5182 5186 * At boot, set the entry early for the benefit of the
5183 5187 * legacy init scripts.
5184 5188 */
5185 5189 utmpx_set_runlevel(trl, 'S', B_FALSE);
5186 5190 }
5187 5191 } else {
5188 5192 if (rl == '3' && trl == '2') {
5189 5193 current_runlevel = trl;
5190 5194 signal_init(trl);
5191 5195 } else if (rl == '2' && trl == 'S') {
5192 5196 current_runlevel = trl;
5193 5197 signal_init(trl);
5194 5198 }
5195 5199 }
5196 5200 }
5197 5201
5198 5202 /*
5199 5203 * Move to a backwards-compatible runlevel by executing the appropriate
5200 5204 * /etc/rc?.d/K* scripts and/or setting the milestone.
5201 5205 *
5202 5206 * Returns
5203 5207 * 0 - success
5204 5208 * ECONNRESET - success, but handle was reset
5205 5209 * ECONNABORTED - repository connection broken
5206 5210 * ECANCELED - pg was deleted
5207 5211 */
5208 5212 static int
5209 5213 dgraph_set_runlevel(scf_propertygroup_t *pg, scf_property_t *prop)
5210 5214 {
5211 5215 char rl;
5212 5216 scf_handle_t *h;
5213 5217 int r;
5214 5218 const char *ms = NULL; /* what to commit as options/milestone */
5215 5219 boolean_t rebound = B_FALSE;
5216 5220 int mark_rl = 0;
5217 5221
5218 5222 const char * const stop = "stop";
5219 5223
5220 5224 r = libscf_extract_runlevel(prop, &rl);
5221 5225 switch (r) {
5222 5226 case 0:
5223 5227 break;
5224 5228
5225 5229 case ECONNABORTED:
5226 5230 case ECANCELED:
5227 5231 return (r);
5228 5232
5229 5233 case EINVAL:
5230 5234 case ENOENT:
5231 5235 log_error(LOG_WARNING, "runlevel property is misconfigured; "
5232 5236 "ignoring.\n");
5233 5237 /* delete the bad property */
5234 5238 goto nolock_out;
5235 5239
5236 5240 default:
5237 5241 bad_error("libscf_extract_runlevel", r);
5238 5242 }
5239 5243
5240 5244 switch (rl) {
5241 5245 case 's':
5242 5246 rl = 'S';
5243 5247 /* FALLTHROUGH */
5244 5248
5245 5249 case 'S':
5246 5250 case '2':
5247 5251 case '3':
5248 5252 /*
5249 5253 * These cases cause a milestone change, so
5250 5254 * graph_runlevel_changed() will eventually deal with
5251 5255 * signalling init.
5252 5256 */
5253 5257 break;
5254 5258
5255 5259 case '0':
5256 5260 case '1':
5257 5261 case '4':
5258 5262 case '5':
5259 5263 case '6':
5260 5264 mark_rl = 1;
5261 5265 break;
5262 5266
5263 5267 default:
5264 5268 log_framework(LOG_NOTICE, "Unknown runlevel '%c'.\n", rl);
5265 5269 ms = NULL;
5266 5270 goto nolock_out;
5267 5271 }
5268 5272
5269 5273 h = scf_pg_handle(pg);
5270 5274
5271 5275 MUTEX_LOCK(&dgraph_lock);
5272 5276
5273 5277 /*
5274 5278 * Since this triggers no milestone changes, force it by hand.
5275 5279 */
5276 5280 if (current_runlevel == '4' && rl == '3')
5277 5281 mark_rl = 1;
5278 5282
5279 5283 /*
5280 5284 * 1. If we are here after an "init X":
5281 5285 *
5282 5286 * init X
5283 5287 * init/lscf_set_runlevel()
5284 5288 * process_pg_event()
5285 5289 * dgraph_set_runlevel()
5286 5290 *
5287 5291 * then we haven't passed through graph_runlevel_changed() yet,
5288 5292 * therefore 'current_runlevel' has not changed for sure but 'rl' has.
5289 5293 * In consequence, if 'rl' is lower than 'current_runlevel', we change
5290 5294 * the system runlevel and execute the appropriate /etc/rc?.d/K* scripts
5291 5295 * past this test.
5292 5296 *
5293 5297 * 2. On the other hand, if we are here after a "svcadm milestone":
5294 5298 *
5295 5299 * svcadm milestone X
5296 5300 * dgraph_set_milestone()
5297 5301 * handle_graph_update_event()
5298 5302 * dgraph_set_instance_state()
5299 5303 * graph_post_X_[online|offline]()
5300 5304 * graph_runlevel_changed()
5301 5305 * signal_init()
5302 5306 * init/lscf_set_runlevel()
5303 5307 * process_pg_event()
5304 5308 * dgraph_set_runlevel()
5305 5309 *
5306 5310 * then we already passed through graph_runlevel_changed() (by the way
5307 5311 * of dgraph_set_milestone()) and 'current_runlevel' may have changed
5308 5312 * and already be equal to 'rl' so we are going to return immediately
5309 5313 * from dgraph_set_runlevel() without changing the system runlevel and
5310 5314 * without executing the /etc/rc?.d/K* scripts.
5311 5315 */
5312 5316 if (rl == current_runlevel) {
5313 5317 ms = NULL;
5314 5318 goto out;
5315 5319 }
5316 5320
5317 5321 log_framework(LOG_DEBUG, "Changing to runlevel '%c'.\n", rl);
5318 5322
5319 5323 /*
5320 5324 * Make sure stop rc scripts see the new settings via who -r.
5321 5325 */
5322 5326 utmpx_set_runlevel(rl, current_runlevel, B_TRUE);
5323 5327
5324 5328 /*
5325 5329 * Some run levels don't have a direct correspondence to any
5326 5330 * milestones, so we have to signal init directly.
5327 5331 */
5328 5332 if (mark_rl) {
5329 5333 current_runlevel = rl;
5330 5334 signal_init(rl);
5331 5335 }
5332 5336
5333 5337 switch (rl) {
5334 5338 case 'S':
5335 5339 uu_warn("The system is coming down for administration. "
5336 5340 "Please wait.\n");
5337 5341 fork_rc_script(rl, stop, B_FALSE);
5338 5342 ms = single_user_fmri;
5339 5343 go_single_user_mode = B_TRUE;
5340 5344 break;
5341 5345
5342 5346 case '0':
5343 5347 halting_time = time(NULL);
5344 5348 fork_rc_script(rl, stop, B_TRUE);
5345 5349 halting = AD_HALT;
5346 5350 goto uadmin;
5347 5351
5348 5352 case '5':
5349 5353 halting_time = time(NULL);
5350 5354 fork_rc_script(rl, stop, B_TRUE);
5351 5355 halting = AD_POWEROFF;
5352 5356 goto uadmin;
5353 5357
5354 5358 case '6':
5355 5359 halting_time = time(NULL);
5356 5360 fork_rc_script(rl, stop, B_TRUE);
5357 5361 if (scf_is_fastboot_default() && getzoneid() == GLOBAL_ZONEID)
5358 5362 halting = AD_FASTREBOOT;
5359 5363 else
5360 5364 halting = AD_BOOT;
5361 5365
5362 5366 uadmin:
5363 5367 uu_warn("The system is coming down. Please wait.\n");
5364 5368 ms = "none";
5365 5369
5366 5370 /*
5367 5371 * We can't wait until all services are offline since this
5368 5372 * thread is responsible for taking them offline. Instead we
5369 5373 * set halting to the second argument for uadmin() and call
5370 5374 * do_uadmin() from dgraph_set_instance_state() when
5371 5375 * appropriate.
5372 5376 */
5373 5377 break;
5374 5378
5375 5379 case '1':
5376 5380 if (current_runlevel != 'S') {
5377 5381 uu_warn("Changing to state 1.\n");
5378 5382 fork_rc_script(rl, stop, B_FALSE);
5379 5383 } else {
5380 5384 uu_warn("The system is coming up for administration. "
5381 5385 "Please wait.\n");
5382 5386 }
5383 5387 ms = single_user_fmri;
5384 5388 go_to_level1 = B_TRUE;
5385 5389 break;
5386 5390
5387 5391 case '2':
5388 5392 if (current_runlevel == '3' || current_runlevel == '4')
5389 5393 fork_rc_script(rl, stop, B_FALSE);
5390 5394 ms = multi_user_fmri;
5391 5395 break;
5392 5396
5393 5397 case '3':
5394 5398 case '4':
5395 5399 ms = "all";
5396 5400 break;
5397 5401
5398 5402 default:
5399 5403 #ifndef NDEBUG
5400 5404 (void) fprintf(stderr, "%s:%d: Uncaught case %d ('%c').\n",
5401 5405 __FILE__, __LINE__, rl, rl);
5402 5406 #endif
5403 5407 abort();
5404 5408 }
5405 5409
5406 5410 out:
5407 5411 MUTEX_UNLOCK(&dgraph_lock);
5408 5412
5409 5413 nolock_out:
5410 5414 switch (r = libscf_clear_runlevel(pg, ms)) {
5411 5415 case 0:
5412 5416 break;
5413 5417
5414 5418 case ECONNABORTED:
5415 5419 libscf_handle_rebind(h);
5416 5420 rebound = B_TRUE;
5417 5421 goto nolock_out;
5418 5422
5419 5423 case ECANCELED:
5420 5424 break;
5421 5425
5422 5426 case EPERM:
5423 5427 case EACCES:
5424 5428 case EROFS:
5425 5429 log_error(LOG_NOTICE, "Could not delete \"%s/%s\" property: "
5426 5430 "%s.\n", SCF_PG_OPTIONS, "runlevel", strerror(r));
5427 5431 break;
5428 5432
5429 5433 default:
5430 5434 bad_error("libscf_clear_runlevel", r);
5431 5435 }
5432 5436
5433 5437 return (rebound ? ECONNRESET : 0);
5434 5438 }
5435 5439
5436 5440 /*
5437 5441 * mark_subtree walks the dependents and add the GV_TOOFFLINE flag
5438 5442 * to the instances that are supposed to go offline during an
5439 5443 * administrative disable operation.
5440 5444 */
5441 5445 static int
5442 5446 mark_subtree(graph_edge_t *e, void *arg)
5443 5447 {
5444 5448 graph_vertex_t *v;
5445 5449 int r;
5446 5450
5447 5451 v = e->ge_vertex;
5448 5452
5449 5453 /* If it's already in the subgraph, skip. */
5450 5454 if (v->gv_flags & GV_TOOFFLINE)
5451 5455 return (UU_WALK_NEXT);
5452 5456
5453 5457 switch (v->gv_type) {
5454 5458 case GVT_INST:
5455 5459 /* If the instance is already disabled, skip it. */
5456 5460 if (!(v->gv_flags & GV_ENABLED))
5457 5461 return (UU_WALK_NEXT);
5458 5462
5459 5463 v->gv_flags |= GV_TOOFFLINE;
5460 5464 log_framework(LOG_DEBUG, "%s added to subtree\n", v->gv_name);
5461 5465 break;
5462 5466 case GVT_GROUP:
5463 5467 /*
5464 5468 * Skip all excluded and optional_all dependencies and decide
5465 5469 * whether to offline the service based on restart_on attribute.
5466 5470 */
5467 5471 if (is_depgrp_bypassed(v))
5468 5472 return (UU_WALK_NEXT);
5469 5473 break;
5470 5474 }
5471 5475
5472 5476 r = uu_list_walk(v->gv_dependents, (uu_walk_fn_t *)mark_subtree, arg,
5473 5477 0);
5474 5478 assert(r == 0);
5475 5479 return (UU_WALK_NEXT);
5476 5480 }
5477 5481
5478 5482 static int
5479 5483 mark_subgraph(graph_edge_t *e, void *arg)
5480 5484 {
5481 5485 graph_vertex_t *v;
5482 5486 int r;
5483 5487 int optional = (int)arg;
5484 5488
5485 5489 v = e->ge_vertex;
5486 5490
5487 5491 /* If it's already in the subgraph, skip. */
5488 5492 if (v->gv_flags & GV_INSUBGRAPH)
5489 5493 return (UU_WALK_NEXT);
5490 5494
5491 5495 /*
5492 5496 * Keep track if walk has entered an optional dependency group
5493 5497 */
5494 5498 if (v->gv_type == GVT_GROUP && v->gv_depgroup == DEPGRP_OPTIONAL_ALL) {
5495 5499 optional = 1;
5496 5500 }
5497 5501 /*
5498 5502 * Quit if we are in an optional dependency group and the instance
5499 5503 * is disabled
5500 5504 */
5501 5505 if (optional && (v->gv_type == GVT_INST) &&
5502 5506 (!(v->gv_flags & GV_ENBLD_NOOVR)))
5503 5507 return (UU_WALK_NEXT);
5504 5508
5505 5509 v->gv_flags |= GV_INSUBGRAPH;
5506 5510
5507 5511 /* Skip all excluded dependencies. */
5508 5512 if (v->gv_type == GVT_GROUP && v->gv_depgroup == DEPGRP_EXCLUDE_ALL)
5509 5513 return (UU_WALK_NEXT);
5510 5514
5511 5515 r = uu_list_walk(v->gv_dependencies, (uu_walk_fn_t *)mark_subgraph,
5512 5516 (void *)optional, 0);
5513 5517 assert(r == 0);
5514 5518 return (UU_WALK_NEXT);
5515 5519 }
5516 5520
5517 5521 /*
5518 5522 * Bring down all services which are not dependencies of fmri. The
5519 5523 * dependencies of fmri (direct & indirect) will constitute the "subgraph",
5520 5524 * and will have the GV_INSUBGRAPH flag set. The rest must be brought down,
5521 5525 * which means the state is "disabled", "maintenance", or "uninitialized". We
5522 5526 * could consider "offline" to be down, and refrain from sending start
5523 5527 * commands for such services, but that's not strictly necessary, so we'll
5524 5528 * decline to intrude on the state machine. It would probably confuse users
5525 5529 * anyway.
5526 5530 *
5527 5531 * The services should be brought down in reverse-dependency order, so we
5528 5532 * can't do it all at once here. We initiate by override-disabling the leaves
5529 5533 * of the dependency tree -- those services which are up but have no
5530 5534 * dependents which are up. When they come down,
5531 5535 * vertex_subgraph_dependencies_shutdown() will override-disable the newly
5532 5536 * exposed leaves. Perseverance will ensure completion.
5533 5537 *
5534 5538 * Sometimes we need to take action when the transition is complete, like
5535 5539 * start sulogin or halt the system. To tell when we're done, we initialize
5536 5540 * non_subgraph_svcs here to be the number of services which need to come
5537 5541 * down. As each does, we decrement the counter. When it hits zero, we take
5538 5542 * the appropriate action. See vertex_subgraph_dependencies_shutdown().
5539 5543 *
5540 5544 * In case we're coming up, we also remove any enable-overrides for the
5541 5545 * services which are dependencies of fmri.
5542 5546 *
5543 5547 * If norepository is true, the function will not change the repository.
5544 5548 *
5545 5549 * The decision to change the system run level in accordance with the milestone
5546 5550 * is taken in dgraph_set_runlevel().
5547 5551 *
5548 5552 * Returns
5549 5553 * 0 - success
5550 5554 * ECONNRESET - success, but handle was rebound
5551 5555 * EINVAL - fmri is invalid (error is logged)
5552 5556 * EALREADY - the milestone is already set to fmri
5553 5557 * ENOENT - a configured vertex does not exist for fmri (an error is logged)
5554 5558 */
5555 5559 static int
5556 5560 dgraph_set_milestone(const char *fmri, scf_handle_t *h, boolean_t norepository)
5557 5561 {
5558 5562 const char *cfmri, *fs;
5559 5563 graph_vertex_t *nm, *v;
5560 5564 int ret = 0, r;
5561 5565 scf_instance_t *inst;
5562 5566 boolean_t isall, isnone, rebound = B_FALSE;
5563 5567
5564 5568 /* Validate fmri */
5565 5569 isall = (strcmp(fmri, "all") == 0);
5566 5570 isnone = (strcmp(fmri, "none") == 0);
5567 5571
5568 5572 if (!isall && !isnone) {
5569 5573 if (fmri_canonify(fmri, (char **)&cfmri, B_FALSE) == EINVAL)
5570 5574 goto reject;
5571 5575
5572 5576 if (strcmp(cfmri, single_user_fmri) != 0 &&
5573 5577 strcmp(cfmri, multi_user_fmri) != 0 &&
5574 5578 strcmp(cfmri, multi_user_svr_fmri) != 0) {
5575 5579 startd_free((void *)cfmri, max_scf_fmri_size);
5576 5580 reject:
5577 5581 log_framework(LOG_WARNING,
5578 5582 "Rejecting request for invalid milestone \"%s\".\n",
5579 5583 fmri);
5580 5584 return (EINVAL);
5581 5585 }
5582 5586 }
5583 5587
5584 5588 inst = safe_scf_instance_create(h);
5585 5589
5586 5590 MUTEX_LOCK(&dgraph_lock);
5587 5591
5588 5592 if (milestone == NULL) {
5589 5593 if (isall) {
5590 5594 log_framework(LOG_DEBUG,
5591 5595 "Milestone already set to all.\n");
5592 5596 ret = EALREADY;
5593 5597 goto out;
5594 5598 }
5595 5599 } else if (milestone == MILESTONE_NONE) {
5596 5600 if (isnone) {
5597 5601 log_framework(LOG_DEBUG,
5598 5602 "Milestone already set to none.\n");
5599 5603 ret = EALREADY;
5600 5604 goto out;
5601 5605 }
5602 5606 } else {
5603 5607 if (!isall && !isnone &&
5604 5608 strcmp(cfmri, milestone->gv_name) == 0) {
5605 5609 log_framework(LOG_DEBUG,
5606 5610 "Milestone already set to %s.\n", cfmri);
5607 5611 ret = EALREADY;
5608 5612 goto out;
5609 5613 }
5610 5614 }
5611 5615
5612 5616 if (!isall && !isnone) {
5613 5617 nm = vertex_get_by_name(cfmri);
5614 5618 if (nm == NULL || !(nm->gv_flags & GV_CONFIGURED)) {
5615 5619 log_framework(LOG_WARNING, "Cannot set milestone to %s "
5616 5620 "because no such service exists.\n", cfmri);
5617 5621 ret = ENOENT;
5618 5622 goto out;
5619 5623 }
5620 5624 }
5621 5625
5622 5626 log_framework(LOG_DEBUG, "Changing milestone to %s.\n", fmri);
5623 5627
5624 5628 /*
5625 5629 * Set milestone, removing the old one if this was the last reference.
5626 5630 */
5627 5631 if (milestone > MILESTONE_NONE)
5628 5632 (void) vertex_unref(milestone);
5629 5633
5630 5634 if (isall)
5631 5635 milestone = NULL;
5632 5636 else if (isnone)
5633 5637 milestone = MILESTONE_NONE;
5634 5638 else {
5635 5639 milestone = nm;
5636 5640 /* milestone should count as a reference */
5637 5641 vertex_ref(milestone);
5638 5642 }
5639 5643
5640 5644 /* Clear all GV_INSUBGRAPH bits. */
5641 5645 for (v = uu_list_first(dgraph); v != NULL; v = uu_list_next(dgraph, v))
5642 5646 v->gv_flags &= ~GV_INSUBGRAPH;
5643 5647
5644 5648 if (!isall && !isnone) {
5645 5649 /* Set GV_INSUBGRAPH for milestone & descendents. */
5646 5650 milestone->gv_flags |= GV_INSUBGRAPH;
5647 5651
5648 5652 r = uu_list_walk(milestone->gv_dependencies,
5649 5653 (uu_walk_fn_t *)mark_subgraph, NULL, 0);
5650 5654 assert(r == 0);
5651 5655 }
5652 5656
5653 5657 /* Un-override services in the subgraph & override-disable the rest. */
5654 5658 if (norepository)
5655 5659 goto out;
5656 5660
5657 5661 non_subgraph_svcs = 0;
5658 5662 for (v = uu_list_first(dgraph);
5659 5663 v != NULL;
5660 5664 v = uu_list_next(dgraph, v)) {
5661 5665 if (v->gv_type != GVT_INST ||
5662 5666 (v->gv_flags & GV_CONFIGURED) == 0)
5663 5667 continue;
5664 5668
5665 5669 again:
5666 5670 r = scf_handle_decode_fmri(h, v->gv_name, NULL, NULL, inst,
5667 5671 NULL, NULL, SCF_DECODE_FMRI_EXACT);
5668 5672 if (r != 0) {
5669 5673 switch (scf_error()) {
5670 5674 case SCF_ERROR_CONNECTION_BROKEN:
5671 5675 default:
5672 5676 libscf_handle_rebind(h);
5673 5677 rebound = B_TRUE;
5674 5678 goto again;
5675 5679
5676 5680 case SCF_ERROR_NOT_FOUND:
5677 5681 continue;
5678 5682
5679 5683 case SCF_ERROR_HANDLE_MISMATCH:
5680 5684 case SCF_ERROR_INVALID_ARGUMENT:
5681 5685 case SCF_ERROR_CONSTRAINT_VIOLATED:
5682 5686 case SCF_ERROR_NOT_BOUND:
5683 5687 bad_error("scf_handle_decode_fmri",
5684 5688 scf_error());
5685 5689 }
5686 5690 }
5687 5691
5688 5692 if (isall || (v->gv_flags & GV_INSUBGRAPH)) {
5689 5693 r = libscf_delete_enable_ovr(inst);
5690 5694 fs = "libscf_delete_enable_ovr";
5691 5695 } else {
5692 5696 assert(isnone || (v->gv_flags & GV_INSUBGRAPH) == 0);
5693 5697
5694 5698 /*
5695 5699 * Services which are up need to come down before
5696 5700 * we're done, but we can only disable the leaves
5697 5701 * here.
5698 5702 */
5699 5703
5700 5704 if (up_state(v->gv_state))
5701 5705 ++non_subgraph_svcs;
5702 5706
5703 5707 /* If it's already disabled, don't bother. */
5704 5708 if ((v->gv_flags & GV_ENABLED) == 0)
5705 5709 continue;
5706 5710
5707 5711 if (!is_nonsubgraph_leaf(v))
5708 5712 continue;
5709 5713
5710 5714 r = libscf_set_enable_ovr(inst, 0);
5711 5715 fs = "libscf_set_enable_ovr";
5712 5716 }
5713 5717 switch (r) {
5714 5718 case 0:
5715 5719 case ECANCELED:
5716 5720 break;
5717 5721
5718 5722 case ECONNABORTED:
5719 5723 libscf_handle_rebind(h);
5720 5724 rebound = B_TRUE;
5721 5725 goto again;
5722 5726
5723 5727 case EPERM:
5724 5728 case EROFS:
5725 5729 log_error(LOG_WARNING,
5726 5730 "Could not set %s/%s for %s: %s.\n",
5727 5731 SCF_PG_GENERAL_OVR, SCF_PROPERTY_ENABLED,
5728 5732 v->gv_name, strerror(r));
5729 5733 break;
5730 5734
5731 5735 default:
5732 5736 bad_error(fs, r);
5733 5737 }
5734 5738 }
5735 5739
5736 5740 if (halting != -1) {
5737 5741 if (non_subgraph_svcs > 1)
5738 5742 uu_warn("%d system services are now being stopped.\n",
5739 5743 non_subgraph_svcs);
5740 5744 else if (non_subgraph_svcs == 1)
5741 5745 uu_warn("One system service is now being stopped.\n");
5742 5746 else if (non_subgraph_svcs == 0)
5743 5747 do_uadmin();
5744 5748 }
5745 5749
5746 5750 ret = rebound ? ECONNRESET : 0;
5747 5751
5748 5752 out:
5749 5753 MUTEX_UNLOCK(&dgraph_lock);
5750 5754 if (!isall && !isnone)
5751 5755 startd_free((void *)cfmri, max_scf_fmri_size);
5752 5756 scf_instance_destroy(inst);
5753 5757 return (ret);
5754 5758 }
5755 5759
5756 5760
5757 5761 /*
5758 5762 * Returns 0, ECONNABORTED, or EINVAL.
5759 5763 */
5760 5764 static int
5761 5765 handle_graph_update_event(scf_handle_t *h, graph_protocol_event_t *e)
5762 5766 {
5763 5767 int r;
5764 5768
5765 5769 switch (e->gpe_type) {
5766 5770 case GRAPH_UPDATE_RELOAD_GRAPH:
5767 5771 log_error(LOG_WARNING,
5768 5772 "graph_event: reload graph unimplemented\n");
5769 5773 break;
5770 5774
5771 5775 case GRAPH_UPDATE_STATE_CHANGE: {
5772 5776 protocol_states_t *states = e->gpe_data;
5773 5777
5774 5778 switch (r = dgraph_set_instance_state(h, e->gpe_inst, states)) {
5775 5779 case 0:
5776 5780 case ENOENT:
5777 5781 break;
5778 5782
5779 5783 case ECONNABORTED:
5780 5784 return (ECONNABORTED);
5781 5785
5782 5786 case EINVAL:
5783 5787 default:
5784 5788 #ifndef NDEBUG
5785 5789 (void) fprintf(stderr, "dgraph_set_instance_state() "
5786 5790 "failed with unexpected error %d at %s:%d.\n", r,
5787 5791 __FILE__, __LINE__);
5788 5792 #endif
5789 5793 abort();
5790 5794 }
5791 5795
5792 5796 startd_free(states, sizeof (protocol_states_t));
5793 5797 break;
5794 5798 }
5795 5799
5796 5800 default:
5797 5801 log_error(LOG_WARNING,
5798 5802 "graph_event_loop received an unknown event: %d\n",
5799 5803 e->gpe_type);
5800 5804 break;
5801 5805 }
5802 5806
5803 5807 return (0);
5804 5808 }
5805 5809
5806 5810 /*
5807 5811 * graph_event_thread()
5808 5812 * Wait for state changes from the restarters.
5809 5813 */
5810 5814 /*ARGSUSED*/
5811 5815 void *
5812 5816 graph_event_thread(void *unused)
5813 5817 {
5814 5818 scf_handle_t *h;
5815 5819 int err;
5816 5820
5817 5821 h = libscf_handle_create_bound_loop();
5818 5822
5819 5823 /*CONSTCOND*/
5820 5824 while (1) {
5821 5825 graph_protocol_event_t *e;
5822 5826
5823 5827 MUTEX_LOCK(&gu->gu_lock);
5824 5828
5825 5829 while (gu->gu_wakeup == 0)
5826 5830 (void) pthread_cond_wait(&gu->gu_cv, &gu->gu_lock);
5827 5831
5828 5832 gu->gu_wakeup = 0;
5829 5833
5830 5834 while ((e = graph_event_dequeue()) != NULL) {
5831 5835 MUTEX_LOCK(&e->gpe_lock);
5832 5836 MUTEX_UNLOCK(&gu->gu_lock);
5833 5837
5834 5838 while ((err = handle_graph_update_event(h, e)) ==
5835 5839 ECONNABORTED)
5836 5840 libscf_handle_rebind(h);
5837 5841
5838 5842 if (err == 0)
5839 5843 graph_event_release(e);
5840 5844 else
5841 5845 graph_event_requeue(e);
5842 5846
5843 5847 MUTEX_LOCK(&gu->gu_lock);
5844 5848 }
5845 5849
5846 5850 MUTEX_UNLOCK(&gu->gu_lock);
5847 5851 }
5848 5852
5849 5853 /*
5850 5854 * Unreachable for now -- there's currently no graceful cleanup
5851 5855 * called on exit().
5852 5856 */
5853 5857 MUTEX_UNLOCK(&gu->gu_lock);
5854 5858 scf_handle_destroy(h);
5855 5859 return (NULL);
5856 5860 }
5857 5861
5858 5862 static void
5859 5863 set_initial_milestone(scf_handle_t *h)
5860 5864 {
5861 5865 scf_instance_t *inst;
5862 5866 char *fmri, *cfmri;
5863 5867 size_t sz;
5864 5868 int r;
5865 5869
5866 5870 inst = safe_scf_instance_create(h);
5867 5871 fmri = startd_alloc(max_scf_fmri_size);
5868 5872
5869 5873 /*
5870 5874 * If -m milestone= was specified, we want to set options_ovr/milestone
5871 5875 * to it. Otherwise we want to read what the milestone should be set
5872 5876 * to. Either way we need our inst.
5873 5877 */
5874 5878 get_self:
5875 5879 if (scf_handle_decode_fmri(h, SCF_SERVICE_STARTD, NULL, NULL, inst,
5876 5880 NULL, NULL, SCF_DECODE_FMRI_EXACT) != 0) {
5877 5881 switch (scf_error()) {
5878 5882 case SCF_ERROR_CONNECTION_BROKEN:
5879 5883 libscf_handle_rebind(h);
5880 5884 goto get_self;
5881 5885
5882 5886 case SCF_ERROR_NOT_FOUND:
5883 5887 if (st->st_subgraph != NULL &&
5884 5888 st->st_subgraph[0] != '\0') {
5885 5889 sz = strlcpy(fmri, st->st_subgraph,
5886 5890 max_scf_fmri_size);
5887 5891 assert(sz < max_scf_fmri_size);
5888 5892 } else {
5889 5893 fmri[0] = '\0';
5890 5894 }
5891 5895 break;
5892 5896
5893 5897 case SCF_ERROR_INVALID_ARGUMENT:
5894 5898 case SCF_ERROR_CONSTRAINT_VIOLATED:
5895 5899 case SCF_ERROR_HANDLE_MISMATCH:
5896 5900 default:
5897 5901 bad_error("scf_handle_decode_fmri", scf_error());
5898 5902 }
5899 5903 } else {
5900 5904 if (st->st_subgraph != NULL && st->st_subgraph[0] != '\0') {
5901 5905 scf_propertygroup_t *pg;
5902 5906
5903 5907 pg = safe_scf_pg_create(h);
5904 5908
5905 5909 sz = strlcpy(fmri, st->st_subgraph, max_scf_fmri_size);
5906 5910 assert(sz < max_scf_fmri_size);
5907 5911
5908 5912 r = libscf_inst_get_or_add_pg(inst, SCF_PG_OPTIONS_OVR,
5909 5913 SCF_PG_OPTIONS_OVR_TYPE, SCF_PG_OPTIONS_OVR_FLAGS,
5910 5914 pg);
5911 5915 switch (r) {
5912 5916 case 0:
5913 5917 break;
5914 5918
5915 5919 case ECONNABORTED:
5916 5920 libscf_handle_rebind(h);
5917 5921 goto get_self;
5918 5922
5919 5923 case EPERM:
5920 5924 case EACCES:
5921 5925 case EROFS:
5922 5926 log_error(LOG_WARNING, "Could not set %s/%s: "
5923 5927 "%s.\n", SCF_PG_OPTIONS_OVR,
5924 5928 SCF_PROPERTY_MILESTONE, strerror(r));
5925 5929 /* FALLTHROUGH */
5926 5930
5927 5931 case ECANCELED:
5928 5932 sz = strlcpy(fmri, st->st_subgraph,
5929 5933 max_scf_fmri_size);
5930 5934 assert(sz < max_scf_fmri_size);
5931 5935 break;
5932 5936
5933 5937 default:
5934 5938 bad_error("libscf_inst_get_or_add_pg", r);
5935 5939 }
5936 5940
5937 5941 r = libscf_clear_runlevel(pg, fmri);
5938 5942 switch (r) {
5939 5943 case 0:
5940 5944 break;
5941 5945
5942 5946 case ECONNABORTED:
5943 5947 libscf_handle_rebind(h);
5944 5948 goto get_self;
5945 5949
5946 5950 case EPERM:
5947 5951 case EACCES:
5948 5952 case EROFS:
5949 5953 log_error(LOG_WARNING, "Could not set %s/%s: "
5950 5954 "%s.\n", SCF_PG_OPTIONS_OVR,
5951 5955 SCF_PROPERTY_MILESTONE, strerror(r));
5952 5956 /* FALLTHROUGH */
5953 5957
5954 5958 case ECANCELED:
5955 5959 sz = strlcpy(fmri, st->st_subgraph,
5956 5960 max_scf_fmri_size);
5957 5961 assert(sz < max_scf_fmri_size);
5958 5962 break;
5959 5963
5960 5964 default:
5961 5965 bad_error("libscf_clear_runlevel", r);
5962 5966 }
5963 5967
5964 5968 scf_pg_destroy(pg);
5965 5969 } else {
5966 5970 scf_property_t *prop;
5967 5971 scf_value_t *val;
5968 5972
5969 5973 prop = safe_scf_property_create(h);
5970 5974 val = safe_scf_value_create(h);
5971 5975
5972 5976 r = libscf_get_milestone(inst, prop, val, fmri,
5973 5977 max_scf_fmri_size);
5974 5978 switch (r) {
5975 5979 case 0:
5976 5980 break;
5977 5981
5978 5982 case ECONNABORTED:
5979 5983 libscf_handle_rebind(h);
5980 5984 goto get_self;
5981 5985
5982 5986 case EINVAL:
5983 5987 log_error(LOG_WARNING, "Milestone property is "
5984 5988 "misconfigured. Defaulting to \"all\".\n");
5985 5989 /* FALLTHROUGH */
5986 5990
5987 5991 case ECANCELED:
5988 5992 case ENOENT:
5989 5993 fmri[0] = '\0';
5990 5994 break;
5991 5995
5992 5996 default:
5993 5997 bad_error("libscf_get_milestone", r);
5994 5998 }
5995 5999
5996 6000 scf_value_destroy(val);
5997 6001 scf_property_destroy(prop);
5998 6002 }
5999 6003 }
6000 6004
6001 6005 if (fmri[0] == '\0' || strcmp(fmri, "all") == 0)
6002 6006 goto out;
6003 6007
6004 6008 if (strcmp(fmri, "none") != 0) {
6005 6009 retry:
6006 6010 if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL,
6007 6011 NULL, SCF_DECODE_FMRI_EXACT) != 0) {
6008 6012 switch (scf_error()) {
6009 6013 case SCF_ERROR_INVALID_ARGUMENT:
6010 6014 log_error(LOG_WARNING,
6011 6015 "Requested milestone \"%s\" is invalid. "
6012 6016 "Reverting to \"all\".\n", fmri);
6013 6017 goto out;
6014 6018
6015 6019 case SCF_ERROR_CONSTRAINT_VIOLATED:
6016 6020 log_error(LOG_WARNING, "Requested milestone "
6017 6021 "\"%s\" does not specify an instance. "
6018 6022 "Reverting to \"all\".\n", fmri);
6019 6023 goto out;
6020 6024
6021 6025 case SCF_ERROR_CONNECTION_BROKEN:
6022 6026 libscf_handle_rebind(h);
6023 6027 goto retry;
6024 6028
6025 6029 case SCF_ERROR_NOT_FOUND:
6026 6030 log_error(LOG_WARNING, "Requested milestone "
6027 6031 "\"%s\" not in repository. Reverting to "
6028 6032 "\"all\".\n", fmri);
6029 6033 goto out;
6030 6034
6031 6035 case SCF_ERROR_HANDLE_MISMATCH:
6032 6036 default:
6033 6037 bad_error("scf_handle_decode_fmri",
6034 6038 scf_error());
6035 6039 }
6036 6040 }
6037 6041
6038 6042 r = fmri_canonify(fmri, &cfmri, B_FALSE);
6039 6043 assert(r == 0);
6040 6044
6041 6045 r = dgraph_add_instance(cfmri, inst, B_TRUE);
6042 6046 startd_free(cfmri, max_scf_fmri_size);
6043 6047 switch (r) {
6044 6048 case 0:
6045 6049 break;
6046 6050
6047 6051 case ECONNABORTED:
6048 6052 goto retry;
6049 6053
6050 6054 case EINVAL:
6051 6055 log_error(LOG_WARNING,
6052 6056 "Requested milestone \"%s\" is invalid. "
6053 6057 "Reverting to \"all\".\n", fmri);
6054 6058 goto out;
6055 6059
6056 6060 case ECANCELED:
6057 6061 log_error(LOG_WARNING,
6058 6062 "Requested milestone \"%s\" not "
6059 6063 "in repository. Reverting to \"all\".\n",
6060 6064 fmri);
6061 6065 goto out;
6062 6066
6063 6067 case EEXIST:
6064 6068 default:
6065 6069 bad_error("dgraph_add_instance", r);
6066 6070 }
6067 6071 }
6068 6072
6069 6073 log_console(LOG_INFO, "Booting to milestone \"%s\".\n", fmri);
6070 6074
6071 6075 r = dgraph_set_milestone(fmri, h, B_FALSE);
6072 6076 switch (r) {
6073 6077 case 0:
6074 6078 case ECONNRESET:
6075 6079 case EALREADY:
6076 6080 break;
6077 6081
6078 6082 case EINVAL:
6079 6083 case ENOENT:
6080 6084 default:
6081 6085 bad_error("dgraph_set_milestone", r);
6082 6086 }
6083 6087
6084 6088 out:
6085 6089 startd_free(fmri, max_scf_fmri_size);
6086 6090 scf_instance_destroy(inst);
6087 6091 }
6088 6092
6089 6093 void
6090 6094 set_restart_milestone(scf_handle_t *h)
6091 6095 {
6092 6096 scf_instance_t *inst;
6093 6097 scf_property_t *prop;
6094 6098 scf_value_t *val;
6095 6099 char *fmri;
6096 6100 int r;
6097 6101
6098 6102 inst = safe_scf_instance_create(h);
6099 6103
6100 6104 get_self:
6101 6105 if (scf_handle_decode_fmri(h, SCF_SERVICE_STARTD, NULL, NULL,
6102 6106 inst, NULL, NULL, SCF_DECODE_FMRI_EXACT) != 0) {
6103 6107 switch (scf_error()) {
6104 6108 case SCF_ERROR_CONNECTION_BROKEN:
6105 6109 libscf_handle_rebind(h);
6106 6110 goto get_self;
6107 6111
6108 6112 case SCF_ERROR_NOT_FOUND:
6109 6113 break;
6110 6114
6111 6115 case SCF_ERROR_INVALID_ARGUMENT:
6112 6116 case SCF_ERROR_CONSTRAINT_VIOLATED:
6113 6117 case SCF_ERROR_HANDLE_MISMATCH:
6114 6118 default:
6115 6119 bad_error("scf_handle_decode_fmri", scf_error());
6116 6120 }
6117 6121
6118 6122 scf_instance_destroy(inst);
6119 6123 return;
6120 6124 }
6121 6125
6122 6126 prop = safe_scf_property_create(h);
6123 6127 val = safe_scf_value_create(h);
6124 6128 fmri = startd_alloc(max_scf_fmri_size);
6125 6129
6126 6130 r = libscf_get_milestone(inst, prop, val, fmri, max_scf_fmri_size);
6127 6131 switch (r) {
6128 6132 case 0:
6129 6133 break;
6130 6134
6131 6135 case ECONNABORTED:
6132 6136 libscf_handle_rebind(h);
6133 6137 goto get_self;
6134 6138
6135 6139 case ECANCELED:
6136 6140 case ENOENT:
6137 6141 case EINVAL:
6138 6142 goto out;
6139 6143
6140 6144 default:
6141 6145 bad_error("libscf_get_milestone", r);
6142 6146 }
6143 6147
6144 6148 r = dgraph_set_milestone(fmri, h, B_TRUE);
6145 6149 switch (r) {
6146 6150 case 0:
6147 6151 case ECONNRESET:
6148 6152 case EALREADY:
6149 6153 case EINVAL:
6150 6154 case ENOENT:
6151 6155 break;
6152 6156
6153 6157 default:
6154 6158 bad_error("dgraph_set_milestone", r);
6155 6159 }
6156 6160
6157 6161 out:
6158 6162 startd_free(fmri, max_scf_fmri_size);
6159 6163 scf_value_destroy(val);
6160 6164 scf_property_destroy(prop);
6161 6165 scf_instance_destroy(inst);
6162 6166 }
6163 6167
6164 6168 /*
6165 6169 * void *graph_thread(void *)
6166 6170 *
6167 6171 * Graph management thread.
6168 6172 */
6169 6173 /*ARGSUSED*/
6170 6174 void *
6171 6175 graph_thread(void *arg)
6172 6176 {
6173 6177 scf_handle_t *h;
6174 6178 int err;
6175 6179
6176 6180 h = libscf_handle_create_bound_loop();
6177 6181
6178 6182 if (st->st_initial)
6179 6183 set_initial_milestone(h);
6180 6184
6181 6185 MUTEX_LOCK(&dgraph_lock);
6182 6186 initial_milestone_set = B_TRUE;
6183 6187 err = pthread_cond_broadcast(&initial_milestone_cv);
6184 6188 assert(err == 0);
6185 6189 MUTEX_UNLOCK(&dgraph_lock);
6186 6190
6187 6191 libscf_populate_graph(h);
6188 6192
6189 6193 if (!st->st_initial)
6190 6194 set_restart_milestone(h);
6191 6195
6192 6196 MUTEX_LOCK(&st->st_load_lock);
6193 6197 st->st_load_complete = 1;
6194 6198 (void) pthread_cond_broadcast(&st->st_load_cv);
6195 6199 MUTEX_UNLOCK(&st->st_load_lock);
6196 6200
6197 6201 MUTEX_LOCK(&dgraph_lock);
6198 6202 /*
6199 6203 * Now that we've set st_load_complete we need to check can_come_up()
6200 6204 * since if we booted to a milestone, then there won't be any more
6201 6205 * state updates.
6202 6206 */
6203 6207 if (!go_single_user_mode && !go_to_level1 &&
6204 6208 halting == -1) {
6205 6209 if (!sulogin_thread_running && !can_come_up()) {
6206 6210 (void) startd_thread_create(sulogin_thread, NULL);
6207 6211 sulogin_thread_running = B_TRUE;
6208 6212 }
6209 6213 }
6210 6214 MUTEX_UNLOCK(&dgraph_lock);
6211 6215
6212 6216 (void) pthread_mutex_lock(&gu->gu_freeze_lock);
6213 6217
6214 6218 /*CONSTCOND*/
6215 6219 while (1) {
6216 6220 (void) pthread_cond_wait(&gu->gu_freeze_cv,
6217 6221 &gu->gu_freeze_lock);
6218 6222 }
6219 6223
6220 6224 /*
6221 6225 * Unreachable for now -- there's currently no graceful cleanup
6222 6226 * called on exit().
6223 6227 */
6224 6228 (void) pthread_mutex_unlock(&gu->gu_freeze_lock);
6225 6229 scf_handle_destroy(h);
6226 6230
6227 6231 return (NULL);
6228 6232 }
6229 6233
6230 6234
6231 6235 /*
6232 6236 * int next_action()
6233 6237 * Given an array of timestamps 'a' with 'num' elements, find the
6234 6238 * lowest non-zero timestamp and return its index. If there are no
6235 6239 * non-zero elements, return -1.
6236 6240 */
6237 6241 static int
6238 6242 next_action(hrtime_t *a, int num)
6239 6243 {
6240 6244 hrtime_t t = 0;
6241 6245 int i = 0, smallest = -1;
6242 6246
6243 6247 for (i = 0; i < num; i++) {
6244 6248 if (t == 0) {
6245 6249 t = a[i];
6246 6250 smallest = i;
6247 6251 } else if (a[i] != 0 && a[i] < t) {
6248 6252 t = a[i];
6249 6253 smallest = i;
6250 6254 }
6251 6255 }
6252 6256
6253 6257 if (t == 0)
6254 6258 return (-1);
6255 6259 else
6256 6260 return (smallest);
6257 6261 }
6258 6262
6259 6263 /*
6260 6264 * void process_actions()
6261 6265 * Process actions requested by the administrator. Possibilities include:
6262 6266 * refresh, restart, maintenance mode off, maintenance mode on,
6263 6267 * maintenance mode immediate, and degraded.
6264 6268 *
6265 6269 * The set of pending actions is represented in the repository as a
6266 6270 * per-instance property group, with each action being a single property
6267 6271 * in that group. This property group is converted to an array, with each
6268 6272 * action type having an array slot. The actions in the array at the
6269 6273 * time process_actions() is called are acted on in the order of the
6270 6274 * timestamp (which is the value stored in the slot). A value of zero
6271 6275 * indicates that there is no pending action of the type associated with
6272 6276 * a particular slot.
6273 6277 *
6274 6278 * Sending an action event multiple times before the restarter has a
6275 6279 * chance to process that action will force it to be run at the last
6276 6280 * timestamp where it appears in the ordering.
6277 6281 *
6278 6282 * Turning maintenance mode on trumps all other actions.
6279 6283 *
6280 6284 * Returns 0 or ECONNABORTED.
6281 6285 */
6282 6286 static int
6283 6287 process_actions(scf_handle_t *h, scf_propertygroup_t *pg, scf_instance_t *inst)
6284 6288 {
6285 6289 scf_property_t *prop = NULL;
6286 6290 scf_value_t *val = NULL;
6287 6291 scf_type_t type;
6288 6292 graph_vertex_t *vertex;
6289 6293 admin_action_t a;
6290 6294 int i, ret = 0, r;
6291 6295 hrtime_t action_ts[NACTIONS];
6292 6296 char *inst_name;
6293 6297
6294 6298 r = libscf_instance_get_fmri(inst, &inst_name);
6295 6299 switch (r) {
6296 6300 case 0:
6297 6301 break;
6298 6302
6299 6303 case ECONNABORTED:
6300 6304 return (ECONNABORTED);
6301 6305
6302 6306 case ECANCELED:
6303 6307 return (0);
6304 6308
6305 6309 default:
6306 6310 bad_error("libscf_instance_get_fmri", r);
6307 6311 }
6308 6312
6309 6313 MUTEX_LOCK(&dgraph_lock);
6310 6314
6311 6315 vertex = vertex_get_by_name(inst_name);
6312 6316 if (vertex == NULL) {
6313 6317 MUTEX_UNLOCK(&dgraph_lock);
6314 6318 log_framework(LOG_DEBUG, "%s: Can't find graph vertex. "
6315 6319 "The instance must have been removed.\n", inst_name);
6316 6320 startd_free(inst_name, max_scf_fmri_size);
6317 6321 return (0);
6318 6322 }
6319 6323
6320 6324 prop = safe_scf_property_create(h);
6321 6325 val = safe_scf_value_create(h);
6322 6326
6323 6327 for (i = 0; i < NACTIONS; i++) {
6324 6328 if (scf_pg_get_property(pg, admin_actions[i], prop) != 0) {
6325 6329 switch (scf_error()) {
6326 6330 case SCF_ERROR_CONNECTION_BROKEN:
6327 6331 default:
6328 6332 ret = ECONNABORTED;
6329 6333 goto out;
6330 6334
6331 6335 case SCF_ERROR_DELETED:
6332 6336 goto out;
6333 6337
6334 6338 case SCF_ERROR_NOT_FOUND:
6335 6339 action_ts[i] = 0;
6336 6340 continue;
6337 6341
6338 6342 case SCF_ERROR_HANDLE_MISMATCH:
6339 6343 case SCF_ERROR_INVALID_ARGUMENT:
6340 6344 case SCF_ERROR_NOT_SET:
6341 6345 bad_error("scf_pg_get_property", scf_error());
6342 6346 }
6343 6347 }
6344 6348
6345 6349 if (scf_property_type(prop, &type) != 0) {
6346 6350 switch (scf_error()) {
6347 6351 case SCF_ERROR_CONNECTION_BROKEN:
6348 6352 default:
6349 6353 ret = ECONNABORTED;
6350 6354 goto out;
6351 6355
6352 6356 case SCF_ERROR_DELETED:
6353 6357 action_ts[i] = 0;
6354 6358 continue;
6355 6359
6356 6360 case SCF_ERROR_NOT_SET:
6357 6361 bad_error("scf_property_type", scf_error());
6358 6362 }
6359 6363 }
6360 6364
6361 6365 if (type != SCF_TYPE_INTEGER) {
6362 6366 action_ts[i] = 0;
6363 6367 continue;
6364 6368 }
6365 6369
6366 6370 if (scf_property_get_value(prop, val) != 0) {
6367 6371 switch (scf_error()) {
6368 6372 case SCF_ERROR_CONNECTION_BROKEN:
6369 6373 default:
6370 6374 ret = ECONNABORTED;
6371 6375 goto out;
6372 6376
6373 6377 case SCF_ERROR_DELETED:
6374 6378 goto out;
6375 6379
6376 6380 case SCF_ERROR_NOT_FOUND:
6377 6381 case SCF_ERROR_CONSTRAINT_VIOLATED:
6378 6382 action_ts[i] = 0;
6379 6383 continue;
6380 6384
6381 6385 case SCF_ERROR_NOT_SET:
6382 6386 case SCF_ERROR_PERMISSION_DENIED:
6383 6387 bad_error("scf_property_get_value",
6384 6388 scf_error());
6385 6389 }
6386 6390 }
6387 6391
6388 6392 r = scf_value_get_integer(val, &action_ts[i]);
6389 6393 assert(r == 0);
6390 6394 }
6391 6395
6392 6396 a = ADMIN_EVENT_MAINT_ON_IMMEDIATE;
6393 6397 if (action_ts[ADMIN_EVENT_MAINT_ON_IMMEDIATE] ||
6394 6398 action_ts[ADMIN_EVENT_MAINT_ON]) {
6395 6399 a = action_ts[ADMIN_EVENT_MAINT_ON_IMMEDIATE] ?
6396 6400 ADMIN_EVENT_MAINT_ON_IMMEDIATE : ADMIN_EVENT_MAINT_ON;
6397 6401
6398 6402 vertex_send_event(vertex, admin_events[a]);
6399 6403 r = libscf_unset_action(h, pg, a, action_ts[a]);
6400 6404 switch (r) {
6401 6405 case 0:
6402 6406 case EACCES:
6403 6407 break;
6404 6408
6405 6409 case ECONNABORTED:
6406 6410 ret = ECONNABORTED;
6407 6411 goto out;
6408 6412
6409 6413 case EPERM:
6410 6414 uu_die("Insufficient privilege.\n");
6411 6415 /* NOTREACHED */
6412 6416
6413 6417 default:
6414 6418 bad_error("libscf_unset_action", r);
6415 6419 }
6416 6420 }
6417 6421
6418 6422 while ((a = next_action(action_ts, NACTIONS)) != -1) {
6419 6423 log_framework(LOG_DEBUG,
6420 6424 "Graph: processing %s action for %s.\n", admin_actions[a],
6421 6425 inst_name);
6422 6426
6423 6427 if (a == ADMIN_EVENT_REFRESH) {
6424 6428 r = dgraph_refresh_instance(vertex, inst);
6425 6429 switch (r) {
6426 6430 case 0:
6427 6431 case ECANCELED:
6428 6432 case EINVAL:
6429 6433 case -1:
6430 6434 break;
6431 6435
6432 6436 case ECONNABORTED:
6433 6437 /* pg & inst are reset now, so just return. */
6434 6438 ret = ECONNABORTED;
6435 6439 goto out;
6436 6440
6437 6441 default:
6438 6442 bad_error("dgraph_refresh_instance", r);
6439 6443 }
6440 6444 }
6441 6445
6442 6446 vertex_send_event(vertex, admin_events[a]);
6443 6447
6444 6448 r = libscf_unset_action(h, pg, a, action_ts[a]);
6445 6449 switch (r) {
6446 6450 case 0:
6447 6451 case EACCES:
6448 6452 break;
6449 6453
6450 6454 case ECONNABORTED:
6451 6455 ret = ECONNABORTED;
6452 6456 goto out;
6453 6457
6454 6458 case EPERM:
6455 6459 uu_die("Insufficient privilege.\n");
6456 6460 /* NOTREACHED */
6457 6461
6458 6462 default:
6459 6463 bad_error("libscf_unset_action", r);
6460 6464 }
6461 6465
6462 6466 action_ts[a] = 0;
6463 6467 }
6464 6468
6465 6469 out:
6466 6470 MUTEX_UNLOCK(&dgraph_lock);
6467 6471
6468 6472 scf_property_destroy(prop);
6469 6473 scf_value_destroy(val);
6470 6474 startd_free(inst_name, max_scf_fmri_size);
6471 6475 return (ret);
6472 6476 }
6473 6477
6474 6478 /*
6475 6479 * inst and pg_name are scratch space, and are unset on entry.
6476 6480 * Returns
6477 6481 * 0 - success
6478 6482 * ECONNRESET - success, but repository handle rebound
6479 6483 * ECONNABORTED - repository connection broken
6480 6484 */
6481 6485 static int
6482 6486 process_pg_event(scf_handle_t *h, scf_propertygroup_t *pg, scf_instance_t *inst,
6483 6487 char *pg_name)
6484 6488 {
6485 6489 int r;
6486 6490 scf_property_t *prop;
6487 6491 scf_value_t *val;
6488 6492 char *fmri;
6489 6493 boolean_t rebound = B_FALSE, rebind_inst = B_FALSE;
6490 6494
6491 6495 if (scf_pg_get_name(pg, pg_name, max_scf_value_size) < 0) {
6492 6496 switch (scf_error()) {
6493 6497 case SCF_ERROR_CONNECTION_BROKEN:
6494 6498 default:
6495 6499 return (ECONNABORTED);
6496 6500
6497 6501 case SCF_ERROR_DELETED:
6498 6502 return (0);
6499 6503
6500 6504 case SCF_ERROR_NOT_SET:
6501 6505 bad_error("scf_pg_get_name", scf_error());
6502 6506 }
6503 6507 }
6504 6508
6505 6509 if (strcmp(pg_name, SCF_PG_GENERAL) == 0 ||
6506 6510 strcmp(pg_name, SCF_PG_GENERAL_OVR) == 0) {
6507 6511 r = dgraph_update_general(pg);
6508 6512 switch (r) {
6509 6513 case 0:
6510 6514 case ENOTSUP:
6511 6515 case ECANCELED:
6512 6516 return (0);
6513 6517
6514 6518 case ECONNABORTED:
6515 6519 return (ECONNABORTED);
6516 6520
6517 6521 case -1:
6518 6522 /* Error should have been logged. */
6519 6523 return (0);
6520 6524
6521 6525 default:
6522 6526 bad_error("dgraph_update_general", r);
6523 6527 }
6524 6528 } else if (strcmp(pg_name, SCF_PG_RESTARTER_ACTIONS) == 0) {
6525 6529 if (scf_pg_get_parent_instance(pg, inst) != 0) {
6526 6530 switch (scf_error()) {
6527 6531 case SCF_ERROR_CONNECTION_BROKEN:
6528 6532 return (ECONNABORTED);
6529 6533
6530 6534 case SCF_ERROR_DELETED:
6531 6535 case SCF_ERROR_CONSTRAINT_VIOLATED:
6532 6536 /* Ignore commands on services. */
6533 6537 return (0);
6534 6538
6535 6539 case SCF_ERROR_NOT_BOUND:
6536 6540 case SCF_ERROR_HANDLE_MISMATCH:
6537 6541 case SCF_ERROR_NOT_SET:
6538 6542 default:
6539 6543 bad_error("scf_pg_get_parent_instance",
6540 6544 scf_error());
6541 6545 }
6542 6546 }
6543 6547
6544 6548 return (process_actions(h, pg, inst));
6545 6549 }
6546 6550
6547 6551 if (strcmp(pg_name, SCF_PG_OPTIONS) != 0 &&
6548 6552 strcmp(pg_name, SCF_PG_OPTIONS_OVR) != 0)
6549 6553 return (0);
6550 6554
6551 6555 /*
6552 6556 * We only care about the options[_ovr] property groups of our own
6553 6557 * instance, so get the fmri and compare. Plus, once we know it's
6554 6558 * correct, if the repository connection is broken we know exactly what
6555 6559 * property group we were operating on, and can look it up again.
6556 6560 */
6557 6561 if (scf_pg_get_parent_instance(pg, inst) != 0) {
6558 6562 switch (scf_error()) {
6559 6563 case SCF_ERROR_CONNECTION_BROKEN:
6560 6564 return (ECONNABORTED);
6561 6565
6562 6566 case SCF_ERROR_DELETED:
6563 6567 case SCF_ERROR_CONSTRAINT_VIOLATED:
6564 6568 return (0);
6565 6569
6566 6570 case SCF_ERROR_HANDLE_MISMATCH:
6567 6571 case SCF_ERROR_NOT_BOUND:
6568 6572 case SCF_ERROR_NOT_SET:
6569 6573 default:
6570 6574 bad_error("scf_pg_get_parent_instance",
6571 6575 scf_error());
6572 6576 }
6573 6577 }
6574 6578
6575 6579 switch (r = libscf_instance_get_fmri(inst, &fmri)) {
6576 6580 case 0:
6577 6581 break;
6578 6582
6579 6583 case ECONNABORTED:
6580 6584 return (ECONNABORTED);
6581 6585
6582 6586 case ECANCELED:
6583 6587 return (0);
6584 6588
6585 6589 default:
6586 6590 bad_error("libscf_instance_get_fmri", r);
6587 6591 }
6588 6592
6589 6593 if (strcmp(fmri, SCF_SERVICE_STARTD) != 0) {
6590 6594 startd_free(fmri, max_scf_fmri_size);
6591 6595 return (0);
6592 6596 }
6593 6597
6594 6598 /*
6595 6599 * update the information events flag
6596 6600 */
6597 6601 if (strcmp(pg_name, SCF_PG_OPTIONS) == 0)
6598 6602 info_events_all = libscf_get_info_events_all(pg);
6599 6603
6600 6604 prop = safe_scf_property_create(h);
6601 6605 val = safe_scf_value_create(h);
6602 6606
6603 6607 if (strcmp(pg_name, SCF_PG_OPTIONS_OVR) == 0) {
6604 6608 /* See if we need to set the runlevel. */
6605 6609 /* CONSTCOND */
6606 6610 if (0) {
6607 6611 rebind_pg:
6608 6612 libscf_handle_rebind(h);
6609 6613 rebound = B_TRUE;
6610 6614
6611 6615 r = libscf_lookup_instance(SCF_SERVICE_STARTD, inst);
6612 6616 switch (r) {
6613 6617 case 0:
6614 6618 break;
6615 6619
6616 6620 case ECONNABORTED:
6617 6621 goto rebind_pg;
6618 6622
6619 6623 case ENOENT:
6620 6624 goto out;
6621 6625
6622 6626 case EINVAL:
6623 6627 case ENOTSUP:
6624 6628 bad_error("libscf_lookup_instance", r);
6625 6629 }
6626 6630
6627 6631 if (scf_instance_get_pg(inst, pg_name, pg) != 0) {
6628 6632 switch (scf_error()) {
6629 6633 case SCF_ERROR_DELETED:
6630 6634 case SCF_ERROR_NOT_FOUND:
6631 6635 goto out;
6632 6636
6633 6637 case SCF_ERROR_CONNECTION_BROKEN:
6634 6638 goto rebind_pg;
6635 6639
6636 6640 case SCF_ERROR_HANDLE_MISMATCH:
6637 6641 case SCF_ERROR_NOT_BOUND:
6638 6642 case SCF_ERROR_NOT_SET:
6639 6643 case SCF_ERROR_INVALID_ARGUMENT:
6640 6644 default:
6641 6645 bad_error("scf_instance_get_pg",
6642 6646 scf_error());
6643 6647 }
6644 6648 }
6645 6649 }
6646 6650
6647 6651 if (scf_pg_get_property(pg, "runlevel", prop) == 0) {
6648 6652 r = dgraph_set_runlevel(pg, prop);
6649 6653 switch (r) {
6650 6654 case ECONNRESET:
6651 6655 rebound = B_TRUE;
6652 6656 rebind_inst = B_TRUE;
6653 6657 /* FALLTHROUGH */
6654 6658
6655 6659 case 0:
6656 6660 break;
6657 6661
6658 6662 case ECONNABORTED:
6659 6663 goto rebind_pg;
6660 6664
6661 6665 case ECANCELED:
6662 6666 goto out;
6663 6667
6664 6668 default:
6665 6669 bad_error("dgraph_set_runlevel", r);
6666 6670 }
6667 6671 } else {
6668 6672 switch (scf_error()) {
6669 6673 case SCF_ERROR_CONNECTION_BROKEN:
6670 6674 default:
6671 6675 goto rebind_pg;
6672 6676
6673 6677 case SCF_ERROR_DELETED:
6674 6678 goto out;
6675 6679
6676 6680 case SCF_ERROR_NOT_FOUND:
6677 6681 break;
6678 6682
6679 6683 case SCF_ERROR_INVALID_ARGUMENT:
6680 6684 case SCF_ERROR_HANDLE_MISMATCH:
6681 6685 case SCF_ERROR_NOT_BOUND:
6682 6686 case SCF_ERROR_NOT_SET:
6683 6687 bad_error("scf_pg_get_property", scf_error());
6684 6688 }
6685 6689 }
6686 6690 }
6687 6691
6688 6692 if (rebind_inst) {
6689 6693 lookup_inst:
6690 6694 r = libscf_lookup_instance(SCF_SERVICE_STARTD, inst);
6691 6695 switch (r) {
6692 6696 case 0:
6693 6697 break;
6694 6698
6695 6699 case ECONNABORTED:
6696 6700 libscf_handle_rebind(h);
6697 6701 rebound = B_TRUE;
6698 6702 goto lookup_inst;
6699 6703
6700 6704 case ENOENT:
6701 6705 goto out;
6702 6706
6703 6707 case EINVAL:
6704 6708 case ENOTSUP:
6705 6709 bad_error("libscf_lookup_instance", r);
6706 6710 }
6707 6711 }
6708 6712
6709 6713 r = libscf_get_milestone(inst, prop, val, fmri, max_scf_fmri_size);
6710 6714 switch (r) {
6711 6715 case 0:
6712 6716 break;
6713 6717
6714 6718 case ECONNABORTED:
6715 6719 libscf_handle_rebind(h);
6716 6720 rebound = B_TRUE;
6717 6721 goto lookup_inst;
6718 6722
6719 6723 case EINVAL:
6720 6724 log_error(LOG_NOTICE,
6721 6725 "%s/%s property of %s is misconfigured.\n", pg_name,
6722 6726 SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD);
6723 6727 /* FALLTHROUGH */
6724 6728
6725 6729 case ECANCELED:
6726 6730 case ENOENT:
6727 6731 (void) strcpy(fmri, "all");
6728 6732 break;
6729 6733
6730 6734 default:
6731 6735 bad_error("libscf_get_milestone", r);
6732 6736 }
6733 6737
6734 6738 r = dgraph_set_milestone(fmri, h, B_FALSE);
6735 6739 switch (r) {
6736 6740 case 0:
6737 6741 case ECONNRESET:
6738 6742 case EALREADY:
6739 6743 break;
6740 6744
6741 6745 case EINVAL:
6742 6746 log_error(LOG_WARNING, "Milestone %s is invalid.\n", fmri);
6743 6747 break;
6744 6748
6745 6749 case ENOENT:
6746 6750 log_error(LOG_WARNING, "Milestone %s does not exist.\n", fmri);
6747 6751 break;
6748 6752
6749 6753 default:
6750 6754 bad_error("dgraph_set_milestone", r);
6751 6755 }
6752 6756
6753 6757 out:
6754 6758 startd_free(fmri, max_scf_fmri_size);
6755 6759 scf_value_destroy(val);
6756 6760 scf_property_destroy(prop);
6757 6761
6758 6762 return (rebound ? ECONNRESET : 0);
6759 6763 }
6760 6764
6761 6765 /*
6762 6766 * process_delete() deletes an instance from the dgraph if 'fmri' is an
6763 6767 * instance fmri or if 'fmri' matches the 'general' property group of an
6764 6768 * instance (or the 'general/enabled' property).
6765 6769 *
6766 6770 * 'fmri' may be overwritten and cannot be trusted on return by the caller.
6767 6771 */
6768 6772 static void
6769 6773 process_delete(char *fmri, scf_handle_t *h)
6770 6774 {
6771 6775 char *lfmri, *end_inst_fmri;
6772 6776 const char *inst_name = NULL;
6773 6777 const char *pg_name = NULL;
6774 6778 const char *prop_name = NULL;
6775 6779
6776 6780 lfmri = safe_strdup(fmri);
6777 6781
6778 6782 /* Determine if the FMRI is a property group or instance */
6779 6783 if (scf_parse_svc_fmri(lfmri, NULL, NULL, &inst_name, &pg_name,
6780 6784 &prop_name) != SCF_SUCCESS) {
6781 6785 log_error(LOG_WARNING,
6782 6786 "Received invalid FMRI \"%s\" from repository server.\n",
6783 6787 fmri);
6784 6788 } else if (inst_name != NULL && pg_name == NULL) {
6785 6789 (void) dgraph_remove_instance(fmri, h);
6786 6790 } else if (inst_name != NULL && pg_name != NULL) {
6787 6791 /*
6788 6792 * If we're deleting the 'general' property group or
6789 6793 * 'general/enabled' property then the whole instance
6790 6794 * must be removed from the dgraph.
6791 6795 */
6792 6796 if (strcmp(pg_name, SCF_PG_GENERAL) != 0) {
6793 6797 free(lfmri);
6794 6798 return;
6795 6799 }
6796 6800
6797 6801 if (prop_name != NULL &&
6798 6802 strcmp(prop_name, SCF_PROPERTY_ENABLED) != 0) {
6799 6803 free(lfmri);
6800 6804 return;
6801 6805 }
6802 6806
6803 6807 /*
6804 6808 * Because the instance has already been deleted from the
6805 6809 * repository, we cannot use any scf_ functions to retrieve
6806 6810 * the instance FMRI however we can easily reconstruct it
6807 6811 * manually.
6808 6812 */
6809 6813 end_inst_fmri = strstr(fmri, SCF_FMRI_PROPERTYGRP_PREFIX);
6810 6814 if (end_inst_fmri == NULL)
6811 6815 bad_error("process_delete", 0);
6812 6816
6813 6817 end_inst_fmri[0] = '\0';
6814 6818
6815 6819 (void) dgraph_remove_instance(fmri, h);
6816 6820 }
6817 6821
6818 6822 free(lfmri);
6819 6823 }
6820 6824
6821 6825 /*ARGSUSED*/
6822 6826 void *
6823 6827 repository_event_thread(void *unused)
6824 6828 {
6825 6829 scf_handle_t *h;
6826 6830 scf_propertygroup_t *pg;
6827 6831 scf_instance_t *inst;
6828 6832 char *fmri = startd_alloc(max_scf_fmri_size);
6829 6833 char *pg_name = startd_alloc(max_scf_value_size);
6830 6834 int r;
6831 6835
6832 6836 h = libscf_handle_create_bound_loop();
6833 6837
6834 6838 pg = safe_scf_pg_create(h);
6835 6839 inst = safe_scf_instance_create(h);
6836 6840
6837 6841 retry:
6838 6842 if (_scf_notify_add_pgtype(h, SCF_GROUP_FRAMEWORK) != SCF_SUCCESS) {
6839 6843 if (scf_error() == SCF_ERROR_CONNECTION_BROKEN) {
6840 6844 libscf_handle_rebind(h);
6841 6845 } else {
6842 6846 log_error(LOG_WARNING,
6843 6847 "Couldn't set up repository notification "
6844 6848 "for property group type %s: %s\n",
6845 6849 SCF_GROUP_FRAMEWORK, scf_strerror(scf_error()));
6846 6850
6847 6851 (void) sleep(1);
6848 6852 }
6849 6853
6850 6854 goto retry;
6851 6855 }
6852 6856
6853 6857 /*CONSTCOND*/
6854 6858 while (1) {
6855 6859 ssize_t res;
6856 6860
6857 6861 /* Note: fmri is only set on delete events. */
6858 6862 res = _scf_notify_wait(pg, fmri, max_scf_fmri_size);
6859 6863 if (res < 0) {
6860 6864 libscf_handle_rebind(h);
6861 6865 goto retry;
6862 6866 } else if (res == 0) {
6863 6867 /*
6864 6868 * property group modified. inst and pg_name are
6865 6869 * pre-allocated scratch space.
6866 6870 */
6867 6871 if (scf_pg_update(pg) < 0) {
6868 6872 switch (scf_error()) {
6869 6873 case SCF_ERROR_DELETED:
6870 6874 continue;
6871 6875
6872 6876 case SCF_ERROR_CONNECTION_BROKEN:
6873 6877 log_error(LOG_WARNING,
6874 6878 "Lost repository event due to "
6875 6879 "disconnection.\n");
6876 6880 libscf_handle_rebind(h);
6877 6881 goto retry;
6878 6882
6879 6883 case SCF_ERROR_NOT_BOUND:
6880 6884 case SCF_ERROR_NOT_SET:
6881 6885 default:
6882 6886 bad_error("scf_pg_update", scf_error());
6883 6887 }
6884 6888 }
6885 6889
6886 6890 r = process_pg_event(h, pg, inst, pg_name);
6887 6891 switch (r) {
6888 6892 case 0:
6889 6893 break;
6890 6894
6891 6895 case ECONNABORTED:
6892 6896 log_error(LOG_WARNING, "Lost repository event "
6893 6897 "due to disconnection.\n");
6894 6898 libscf_handle_rebind(h);
6895 6899 /* FALLTHROUGH */
6896 6900
6897 6901 case ECONNRESET:
6898 6902 goto retry;
6899 6903
6900 6904 default:
6901 6905 bad_error("process_pg_event", r);
6902 6906 }
6903 6907 } else {
6904 6908 /*
6905 6909 * Service, instance, or pg deleted.
6906 6910 * Don't trust fmri on return.
6907 6911 */
6908 6912 process_delete(fmri, h);
6909 6913 }
6910 6914 }
6911 6915
6912 6916 /*NOTREACHED*/
6913 6917 return (NULL);
6914 6918 }
6915 6919
6916 6920 void
6917 6921 graph_engine_start()
6918 6922 {
6919 6923 int err;
6920 6924
6921 6925 (void) startd_thread_create(graph_thread, NULL);
6922 6926
6923 6927 MUTEX_LOCK(&dgraph_lock);
6924 6928 while (!initial_milestone_set) {
6925 6929 err = pthread_cond_wait(&initial_milestone_cv, &dgraph_lock);
6926 6930 assert(err == 0);
6927 6931 }
6928 6932 MUTEX_UNLOCK(&dgraph_lock);
6929 6933
6930 6934 (void) startd_thread_create(repository_event_thread, NULL);
6931 6935 (void) startd_thread_create(graph_event_thread, NULL);
6932 6936 }
|
↓ open down ↓ |
5622 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX