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