7387 SMF is fast and loose with require_any/service dependencies
Reviewed by: Dan McDonald <danmcd@omniti.com>

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright (c) 2015, Syneto S.R.L. All rights reserved.

  25  */
  26 
  27 /*
  28  * graph.c - master restarter graph engine
  29  *
  30  *   The graph engine keeps a dependency graph of all service instances on the
  31  *   system, as recorded in the repository.  It decides when services should
  32  *   be brought up or down based on service states and dependencies and sends
  33  *   commands to restarters to effect any changes.  It also executes
  34  *   administrator commands sent by svcadm via the repository.
  35  *
  36  *   The graph is stored in uu_list_t *dgraph and its vertices are
  37  *   graph_vertex_t's, each of which has a name and an integer id unique to
  38  *   its name (see dict.c).  A vertex's type attribute designates the type
  39  *   of object it represents: GVT_INST for service instances, GVT_SVC for
  40  *   service objects (since service instances may depend on another service,
  41  *   rather than service instance), GVT_FILE for files (which services may
  42  *   depend on), and GVT_GROUP for dependencies on multiple objects.  GVT_GROUP
  43  *   vertices are necessary because dependency lists may have particular
  44  *   grouping types (require any, require all, optional, or exclude) and
  45  *   event-propagation characteristics.
  46  *
  47  *   The initial graph is built by libscf_populate_graph() invoking
  48  *   dgraph_add_instance() for each instance in the repository.  The function
  49  *   adds a GVT_SVC vertex for the service if one does not already exist, adds
  50  *   a GVT_INST vertex named by the FMRI of the instance, and sets up the edges.
  51  *   The resulting web of vertices & edges associated with an instance's vertex
  52  *   includes
  53  *
  54  *     - an edge from the GVT_SVC vertex for the instance's service
  55  *
  56  *     - an edge to the GVT_INST vertex of the instance's resarter, if its
  57  *       restarter is not svc.startd
  58  *
  59  *     - edges from other GVT_INST vertices if the instance is a restarter
  60  *
  61  *     - for each dependency property group in the instance's "running"
  62  *       snapshot, an edge to a GVT_GROUP vertex named by the FMRI of the
  63  *       instance and the name of the property group
  64  *
  65  *     - for each value of the "entities" property in each dependency property
  66  *       group, an edge from the corresponding GVT_GROUP vertex to a
  67  *       GVT_INST, GVT_SVC, or GVT_FILE vertex
  68  *
  69  *     - edges from GVT_GROUP vertices for each dependent instance
  70  *
  71  *   After the edges are set up the vertex's GV_CONFIGURED flag is set.  If
  72  *   there are problems, or if a service is mentioned in a dependency but does
  73  *   not exist in the repository, the GV_CONFIGURED flag will be clear.
  74  *
  75  *   The graph and all of its vertices are protected by the dgraph_lock mutex.
  76  *   See restarter.c for more information.
  77  *
  78  *   The properties of an instance fall into two classes: immediate and
  79  *   snapshotted.  Immediate properties should have an immediate effect when
  80  *   changed.  Snapshotted properties should be read from a snapshot, so they
  81  *   only change when the snapshot changes.  The immediate properties used by
  82  *   the graph engine are general/enabled, general/restarter, and the properties
  83  *   in the restarter_actions property group.  Since they are immediate, they
  84  *   are not read out of a snapshot.  The snapshotted properties used by the
  85  *   graph engine are those in the property groups with type "dependency" and
  86  *   are read out of the "running" snapshot.  The "running" snapshot is created
  87  *   by the the graph engine as soon as possible, and it is updated, along with
  88  *   in-core copies of the data (dependency information for the graph engine) on
  89  *   receipt of the refresh command from svcadm.  In addition, the graph engine
  90  *   updates the "start" snapshot from the "running" snapshot whenever a service
  91  *   comes online.
  92  *
  93  *   When a DISABLE event is requested by the administrator, svc.startd shutdown
  94  *   the dependents first before shutting down the requested service.
  95  *   In graph_enable_by_vertex, we create a subtree that contains the dependent
  96  *   vertices by marking those vertices with the GV_TOOFFLINE flag. And we mark
  97  *   the vertex to disable with the GV_TODISABLE flag. Once the tree is created,
  98  *   we send the _ADMIN_DISABLE event to the leaves. The leaves will then
  99  *   transition from STATE_ONLINE/STATE_DEGRADED to STATE_OFFLINE/STATE_MAINT.
 100  *   In gt_enter_offline and gt_enter_maint if the vertex was in a subtree then
 101  *   we clear the GV_TOOFFLINE flag and walk the dependencies to offline the new
 102  *   exposed leaves. We do the same until we reach the last leaf (the one with
 103  *   the GV_TODISABLE flag). If the vertex to disable is also part of a larger
 104  *   subtree (eg. multiple DISABLE events on vertices in the same subtree) then
 105  *   once the first vertex is disabled (GV_TODISABLE flag is removed), we
 106  *   continue to propagate the offline event to the vertex's dependencies.
 107  *
 108  *
 109  * SMF state transition notifications
 110  *
 111  *   When an instance of a service managed by SMF changes state, svc.startd may
 112  *   publish a GPEC sysevent. All transitions to or from maintenance, a
 113  *   transition cause by a hardware error will generate an event.
 114  *   Other transitions will generate an event if there exist notification
 115  *   parameter for that transition. Notification parameters are stored in the
 116  *   SMF repository for the service/instance they refer to. System-wide
 117  *   notification parameters are stored in the global instance.
 118  *   svc.startd can be told to send events for all SMF state transitions despite
 119  *   of notification parameters by setting options/info_events_all to true in
 120  *   restarter:default
 121  *
 122  *   The set of transitions that generate events is cached in the
 123  *   dgraph_vertex_t gv_stn_tset for service/instance and in the global
 124  *   stn_global for the system-wide set. They are re-read when instances are
 125  *   refreshed.
 126  *
 127  *   The GPEC events published by svc.startd are consumed by fmd(1M). After
 128  *   processing these events, fmd(1M) publishes the processed events to
 129  *   notification agents. The notification agents read the notification
 130  *   parameters from the SMF repository through libscf(3LIB) interfaces and send
 131  *   the notification, or not, based on those parameters.
 132  *
 133  *   Subscription and publishing to the GPEC channels is done with the
 134  *   libfmevent(3LIB) wrappers fmev_[r]publish_*() and
 135  *   fmev_shdl_(un)subscribe().
 136  *
 137  */
 138 
 139 #include <sys/uadmin.h>
 140 #include <sys/wait.h>
 141 
 142 #include <assert.h>
 143 #include <errno.h>
 144 #include <fcntl.h>
 145 #include <fm/libfmevent.h>
 146 #include <libscf.h>
 147 #include <libscf_priv.h>
 148 #include <librestart.h>
 149 #include <libuutil.h>
 150 #include <locale.h>
 151 #include <poll.h>
 152 #include <pthread.h>
 153 #include <signal.h>
 154 #include <stddef.h>
 155 #include <stdio.h>
 156 #include <stdlib.h>
 157 #include <string.h>
 158 #include <strings.h>
 159 #include <sys/statvfs.h>
 160 #include <sys/uadmin.h>
 161 #include <zone.h>
 162 #if defined(__i386)
 163 #include <libgrubmgmt.h>
 164 #endif  /* __i386 */
 165 
 166 #include "startd.h"
 167 #include "protocol.h"
 168 
 169 
 170 #define MILESTONE_NONE  ((graph_vertex_t *)1)
 171 
 172 #define CONSOLE_LOGIN_FMRI      "svc:/system/console-login:default"
 173 #define FS_MINIMAL_FMRI         "svc:/system/filesystem/minimal:default"
 174 
 175 #define VERTEX_REMOVED  0       /* vertex has been freed  */
 176 #define VERTEX_INUSE    1       /* vertex is still in use */
 177 
 178 #define IS_ENABLED(v) ((v)->gv_flags & (GV_ENABLED | GV_ENBLD_NOOVR))
 179 
 180 /*
 181  * stn_global holds the tset for the system wide notification parameters.
 182  * It is updated on refresh of svc:/system/svc/global:default
 183  *
 184  * There are two assumptions that relax the need for a mutex:
 185  *     1. 32-bit value assignments are atomic
 186  *     2. Its value is consumed only in one point at
 187  *     dgraph_state_transition_notify(). There are no test and set races.
 188  *
 189  *     If either assumption is broken, we'll need a mutex to synchronize
 190  *     access to stn_global
 191  */
 192 int32_t stn_global;
 193 /*
 194  * info_events_all holds a flag to override notification parameters and send
 195  * Information events for all state transitions.
 196  * same about the need of a mutex here.
 197  */
 198 int info_events_all;
 199 
 200 /*
 201  * Services in these states are not considered 'down' by the
 202  * milestone/shutdown code.
 203  */
 204 #define up_state(state) ((state) == RESTARTER_STATE_ONLINE || \
 205         (state) == RESTARTER_STATE_DEGRADED || \
 206         (state) == RESTARTER_STATE_OFFLINE)
 207 
 208 #define is_depgrp_bypassed(v) ((v->gv_type == GVT_GROUP) && \
 209         ((v->gv_depgroup == DEPGRP_EXCLUDE_ALL) || \
 210         (v->gv_depgroup == DEPGRP_OPTIONAL_ALL) || \
 211         (v->gv_restart < RERR_RESTART)))
 212 
 213 static uu_list_pool_t *graph_edge_pool, *graph_vertex_pool;
 214 static uu_list_t *dgraph;
 215 static pthread_mutex_t dgraph_lock;
 216 
 217 /*
 218  * milestone indicates the current subgraph.  When NULL, it is the entire
 219  * graph.  When MILESTONE_NONE, it is the empty graph.  Otherwise, it is all
 220  * services on which the target vertex depends.
 221  */
 222 static graph_vertex_t *milestone = NULL;
 223 static boolean_t initial_milestone_set = B_FALSE;
 224 static pthread_cond_t initial_milestone_cv = PTHREAD_COND_INITIALIZER;
 225 
 226 /* protected by dgraph_lock */
 227 static boolean_t sulogin_thread_running = B_FALSE;
 228 static boolean_t sulogin_running = B_FALSE;
 229 static boolean_t console_login_ready = B_FALSE;
 230 
 231 /* Number of services to come down to complete milestone transition. */
 232 static uint_t non_subgraph_svcs;
 233 
 234 /*
 235  * These variables indicate what should be done when we reach the milestone
 236  * target milestone, i.e., when non_subgraph_svcs == 0.  They are acted upon in
 237  * dgraph_set_instance_state().
 238  */
 239 static int halting = -1;
 240 static boolean_t go_single_user_mode = B_FALSE;
 241 static boolean_t go_to_level1 = B_FALSE;
 242 
 243 /*
 244  * Tracks when we started halting.
 245  */
 246 static time_t halting_time = 0;
 247 
 248 /*
 249  * This tracks the legacy runlevel to ensure we signal init and manage
 250  * utmpx entries correctly.
 251  */
 252 static char current_runlevel = '\0';
 253 
 254 /* Number of single user threads currently running */
 255 static pthread_mutex_t single_user_thread_lock;
 256 static int single_user_thread_count = 0;
 257 
 258 /* Statistics for dependency cycle-checking */
 259 static u_longlong_t dep_inserts = 0;
 260 static u_longlong_t dep_cycle_ns = 0;
 261 static u_longlong_t dep_insert_ns = 0;
 262 
 263 
 264 static const char * const emsg_invalid_restarter =
 265         "Transitioning %s to maintenance, restarter FMRI %s is invalid "
 266         "(see 'svcs -xv' for details).\n";
 267 static const char * const console_login_fmri = CONSOLE_LOGIN_FMRI;
 268 static const char * const single_user_fmri = SCF_MILESTONE_SINGLE_USER;
 269 static const char * const multi_user_fmri = SCF_MILESTONE_MULTI_USER;
 270 static const char * const multi_user_svr_fmri = SCF_MILESTONE_MULTI_USER_SERVER;
 271 
 272 
 273 /*
 274  * These services define the system being "up".  If none of them can come
 275  * online, then we will run sulogin on the console.  Note that the install ones
 276  * are for the miniroot and when installing CDs after the first.  can_come_up()
 277  * does the decision making, and an sulogin_thread() runs sulogin, which can be
 278  * started by dgraph_set_instance_state() or single_user_thread().
 279  *
 280  * NOTE: can_come_up() relies on SCF_MILESTONE_SINGLE_USER being the first
 281  * entry, which is only used when booting_to_single_user (boot -s) is set.
 282  * This is because when doing a "boot -s", sulogin is started from specials.c
 283  * after milestone/single-user comes online, for backwards compatibility.
 284  * In this case, SCF_MILESTONE_SINGLE_USER needs to be part of up_svcs
 285  * to ensure sulogin will be spawned if milestone/single-user cannot be reached.
 286  */
 287 static const char * const up_svcs[] = {
 288         SCF_MILESTONE_SINGLE_USER,
 289         CONSOLE_LOGIN_FMRI,
 290         "svc:/system/install-setup:default",
 291         "svc:/system/install:default",
 292         NULL
 293 };
 294 
 295 /* This array must have an element for each non-NULL element of up_svcs[]. */
 296 static graph_vertex_t *up_svcs_p[] = { NULL, NULL, NULL, NULL };
 297 
 298 /* These are for seed repository magic.  See can_come_up(). */
 299 static const char * const manifest_import = SCF_INSTANCE_MI;
 300 static graph_vertex_t *manifest_import_p = NULL;
 301 
 302 
 303 static char target_milestone_as_runlevel(void);
 304 static void graph_runlevel_changed(char rl, int online);
 305 static int dgraph_set_milestone(const char *, scf_handle_t *, boolean_t);
 306 static boolean_t should_be_in_subgraph(graph_vertex_t *v);
 307 static int mark_subtree(graph_edge_t *, void *);
 308 static boolean_t insubtree_dependents_down(graph_vertex_t *);
 309 
 310 /*
 311  * graph_vertex_compare()
 312  *      This function can compare either int *id or * graph_vertex_t *gv
 313  *      values, as the vertex id is always the first element of a
 314  *      graph_vertex structure.
 315  */
 316 /* ARGSUSED */
 317 static int
 318 graph_vertex_compare(const void *lc_arg, const void *rc_arg, void *private)
 319 {
 320         int lc_id = ((const graph_vertex_t *)lc_arg)->gv_id;
 321         int rc_id = *(int *)rc_arg;
 322 
 323         if (lc_id > rc_id)
 324                 return (1);
 325         if (lc_id < rc_id)
 326                 return (-1);
 327         return (0);
 328 }
 329 
 330 void
 331 graph_init()
 332 {
 333         graph_edge_pool = startd_list_pool_create("graph_edges",
 334             sizeof (graph_edge_t), offsetof(graph_edge_t, ge_link), NULL,
 335             UU_LIST_POOL_DEBUG);
 336         assert(graph_edge_pool != NULL);
 337 
 338         graph_vertex_pool = startd_list_pool_create("graph_vertices",
 339             sizeof (graph_vertex_t), offsetof(graph_vertex_t, gv_link),
 340             graph_vertex_compare, UU_LIST_POOL_DEBUG);
 341         assert(graph_vertex_pool != NULL);
 342 
 343         (void) pthread_mutex_init(&dgraph_lock, &mutex_attrs);
 344         (void) pthread_mutex_init(&single_user_thread_lock, &mutex_attrs);
 345         dgraph = startd_list_create(graph_vertex_pool, NULL, UU_LIST_SORTED);
 346         assert(dgraph != NULL);
 347 
 348         if (!st->st_initial)
 349                 current_runlevel = utmpx_get_runlevel();
 350 
 351         log_framework(LOG_DEBUG, "Initialized graph\n");
 352 }
 353 
 354 static graph_vertex_t *
 355 vertex_get_by_name(const char *name)
 356 {
 357         int id;
 358 
 359         assert(MUTEX_HELD(&dgraph_lock));
 360 
 361         id = dict_lookup_byname(name);
 362         if (id == -1)
 363                 return (NULL);
 364 
 365         return (uu_list_find(dgraph, &id, NULL, NULL));
 366 }
 367 
 368 static graph_vertex_t *
 369 vertex_get_by_id(int id)
 370 {
 371         assert(MUTEX_HELD(&dgraph_lock));
 372 
 373         if (id == -1)
 374                 return (NULL);
 375 
 376         return (uu_list_find(dgraph, &id, NULL, NULL));
 377 }
 378 
 379 /*
 380  * Creates a new vertex with the given name, adds it to the graph, and returns
 381  * a pointer to it.  The graph lock must be held by this thread on entry.
 382  */
 383 static graph_vertex_t *
 384 graph_add_vertex(const char *name)
 385 {
 386         int id;
 387         graph_vertex_t *v;
 388         void *p;
 389         uu_list_index_t idx;
 390 
 391         assert(MUTEX_HELD(&dgraph_lock));
 392 
 393         id = dict_insert(name);
 394 
 395         v = startd_zalloc(sizeof (*v));
 396 
 397         v->gv_id = id;
 398 
 399         v->gv_name = startd_alloc(strlen(name) + 1);
 400         (void) strcpy(v->gv_name, name);
 401 
 402         v->gv_dependencies = startd_list_create(graph_edge_pool, v, 0);
 403         v->gv_dependents = startd_list_create(graph_edge_pool, v, 0);
 404 
 405         p = uu_list_find(dgraph, &id, NULL, &idx);
 406         assert(p == NULL);
 407 
 408         uu_list_node_init(v, &v->gv_link, graph_vertex_pool);
 409         uu_list_insert(dgraph, v, idx);
 410 
 411         return (v);
 412 }
 413 
 414 /*
 415  * Removes v from the graph and frees it.  The graph should be locked by this
 416  * thread, and v should have no edges associated with it.
 417  */
 418 static void
 419 graph_remove_vertex(graph_vertex_t *v)
 420 {
 421         assert(MUTEX_HELD(&dgraph_lock));
 422 
 423         assert(uu_list_numnodes(v->gv_dependencies) == 0);
 424         assert(uu_list_numnodes(v->gv_dependents) == 0);
 425         assert(v->gv_refs == 0);
 426 
 427         startd_free(v->gv_name, strlen(v->gv_name) + 1);
 428         uu_list_destroy(v->gv_dependencies);
 429         uu_list_destroy(v->gv_dependents);
 430         uu_list_remove(dgraph, v);
 431 
 432         startd_free(v, sizeof (graph_vertex_t));
 433 }
 434 
 435 static void
 436 graph_add_edge(graph_vertex_t *fv, graph_vertex_t *tv)
 437 {
 438         graph_edge_t *e, *re;
 439         int r;
 440 
 441         assert(MUTEX_HELD(&dgraph_lock));
 442 
 443         e = startd_alloc(sizeof (graph_edge_t));
 444         re = startd_alloc(sizeof (graph_edge_t));
 445 
 446         e->ge_parent = fv;
 447         e->ge_vertex = tv;
 448 
 449         re->ge_parent = tv;
 450         re->ge_vertex = fv;
 451 
 452         uu_list_node_init(e, &e->ge_link, graph_edge_pool);
 453         r = uu_list_insert_before(fv->gv_dependencies, NULL, e);
 454         assert(r == 0);
 455 
 456         uu_list_node_init(re, &re->ge_link, graph_edge_pool);
 457         r = uu_list_insert_before(tv->gv_dependents, NULL, re);
 458         assert(r == 0);
 459 }
 460 
 461 static void
 462 graph_remove_edge(graph_vertex_t *v, graph_vertex_t *dv)
 463 {
 464         graph_edge_t *e;
 465 
 466         for (e = uu_list_first(v->gv_dependencies);
 467             e != NULL;
 468             e = uu_list_next(v->gv_dependencies, e)) {
 469                 if (e->ge_vertex == dv) {
 470                         uu_list_remove(v->gv_dependencies, e);
 471                         startd_free(e, sizeof (graph_edge_t));
 472                         break;
 473                 }
 474         }
 475 
 476         for (e = uu_list_first(dv->gv_dependents);
 477             e != NULL;
 478             e = uu_list_next(dv->gv_dependents, e)) {
 479                 if (e->ge_vertex == v) {
 480                         uu_list_remove(dv->gv_dependents, e);
 481                         startd_free(e, sizeof (graph_edge_t));
 482                         break;
 483                 }
 484         }
 485 }
 486 
 487 static void
 488 remove_inst_vertex(graph_vertex_t *v)
 489 {
 490         graph_edge_t *e;
 491         graph_vertex_t *sv;
 492         int i;
 493 
 494         assert(MUTEX_HELD(&dgraph_lock));
 495         assert(uu_list_numnodes(v->gv_dependents) == 1);
 496         assert(uu_list_numnodes(v->gv_dependencies) == 0);
 497         assert(v->gv_refs == 0);
 498         assert((v->gv_flags & GV_CONFIGURED) == 0);
 499 
 500         e = uu_list_first(v->gv_dependents);
 501         sv = e->ge_vertex;
 502         graph_remove_edge(sv, v);
 503 
 504         for (i = 0; up_svcs[i] != NULL; ++i) {
 505                 if (up_svcs_p[i] == v)
 506                         up_svcs_p[i] = NULL;
 507         }
 508 
 509         if (manifest_import_p == v)
 510                 manifest_import_p = NULL;
 511 
 512         graph_remove_vertex(v);
 513 
 514         if (uu_list_numnodes(sv->gv_dependencies) == 0 &&
 515             uu_list_numnodes(sv->gv_dependents) == 0 &&
 516             sv->gv_refs == 0)
 517                 graph_remove_vertex(sv);
 518 }
 519 
 520 static void
 521 graph_walk_dependents(graph_vertex_t *v, void (*func)(graph_vertex_t *, void *),
 522     void *arg)
 523 {
 524         graph_edge_t *e;
 525 
 526         for (e = uu_list_first(v->gv_dependents);
 527             e != NULL;
 528             e = uu_list_next(v->gv_dependents, e))
 529                 func(e->ge_vertex, arg);
 530 }
 531 
 532 static void
 533 graph_walk_dependencies(graph_vertex_t *v, void (*func)(graph_vertex_t *,
 534         void *), void *arg)
 535 {
 536         graph_edge_t *e;
 537 
 538         assert(MUTEX_HELD(&dgraph_lock));
 539 
 540         for (e = uu_list_first(v->gv_dependencies);
 541             e != NULL;
 542             e = uu_list_next(v->gv_dependencies, e)) {
 543 
 544                 func(e->ge_vertex, arg);
 545         }
 546 }
 547 
 548 /*
 549  * Generic graph walking function.
 550  *
 551  * Given a vertex, this function will walk either dependencies
 552  * (WALK_DEPENDENCIES) or dependents (WALK_DEPENDENTS) of a vertex recursively
 553  * for the entire graph.  It will avoid cycles and never visit the same vertex
 554  * twice.
 555  *
 556  * We avoid traversing exclusion dependencies, because they are allowed to
 557  * create cycles in the graph.  When propagating satisfiability, there is no
 558  * need to walk exclusion dependencies because exclude_all_satisfied() doesn't
 559  * test for satisfiability.
 560  *
 561  * The walker takes two callbacks.  The first is called before examining the
 562  * dependents of each vertex.  The second is called on each vertex after
 563  * examining its dependents.  This allows is_path_to() to construct a path only
 564  * after the target vertex has been found.
 565  */
 566 typedef enum {
 567         WALK_DEPENDENTS,
 568         WALK_DEPENDENCIES
 569 } graph_walk_dir_t;
 570 
 571 typedef int (*graph_walk_cb_t)(graph_vertex_t *, void *);
 572 
 573 typedef struct graph_walk_info {
 574         graph_walk_dir_t        gi_dir;
 575         uchar_t                 *gi_visited;    /* vertex bitmap */
 576         int                     (*gi_pre)(graph_vertex_t *, void *);
 577         void                    (*gi_post)(graph_vertex_t *, void *);
 578         void                    *gi_arg;        /* callback arg */
 579         int                     gi_ret;         /* return value */
 580 } graph_walk_info_t;
 581 
 582 static int
 583 graph_walk_recurse(graph_edge_t *e, graph_walk_info_t *gip)
 584 {
 585         uu_list_t *list;
 586         int r;
 587         graph_vertex_t *v = e->ge_vertex;
 588         int i;
 589         uint_t b;
 590 
 591         i = v->gv_id / 8;
 592         b = 1 << (v->gv_id % 8);
 593 
 594         /*
 595          * Check to see if we've visited this vertex already.
 596          */
 597         if (gip->gi_visited[i] & b)
 598                 return (UU_WALK_NEXT);
 599 
 600         gip->gi_visited[i] |= b;
 601 
 602         /*
 603          * Don't follow exclusions.
 604          */
 605         if (v->gv_type == GVT_GROUP && v->gv_depgroup == DEPGRP_EXCLUDE_ALL)
 606                 return (UU_WALK_NEXT);
 607 
 608         /*
 609          * Call pre-visit callback.  If this doesn't terminate the walk,
 610          * continue search.
 611          */
 612         if ((gip->gi_ret = gip->gi_pre(v, gip->gi_arg)) == UU_WALK_NEXT) {
 613                 /*
 614                  * Recurse using appropriate list.
 615                  */
 616                 if (gip->gi_dir == WALK_DEPENDENTS)
 617                         list = v->gv_dependents;
 618                 else
 619                         list = v->gv_dependencies;
 620 
 621                 r = uu_list_walk(list, (uu_walk_fn_t *)graph_walk_recurse,
 622                     gip, 0);
 623                 assert(r == 0);
 624         }
 625 
 626         /*
 627          * Callbacks must return either UU_WALK_NEXT or UU_WALK_DONE.
 628          */
 629         assert(gip->gi_ret == UU_WALK_NEXT || gip->gi_ret == UU_WALK_DONE);
 630 
 631         /*
 632          * If given a post-callback, call the function for every vertex.
 633          */
 634         if (gip->gi_post != NULL)
 635                 (void) gip->gi_post(v, gip->gi_arg);
 636 
 637         /*
 638          * Preserve the callback's return value.  If the callback returns
 639          * UU_WALK_DONE, then we propagate that to the caller in order to
 640          * terminate the walk.
 641          */
 642         return (gip->gi_ret);
 643 }
 644 
 645 static void
 646 graph_walk(graph_vertex_t *v, graph_walk_dir_t dir,
 647     int (*pre)(graph_vertex_t *, void *),
 648     void (*post)(graph_vertex_t *, void *), void *arg)
 649 {
 650         graph_walk_info_t gi;
 651         graph_edge_t fake;
 652         size_t sz = dictionary->dict_new_id / 8 + 1;
 653 
 654         gi.gi_visited = startd_zalloc(sz);
 655         gi.gi_pre = pre;
 656         gi.gi_post = post;
 657         gi.gi_arg = arg;
 658         gi.gi_dir = dir;
 659         gi.gi_ret = 0;
 660 
 661         /*
 662          * Fake up an edge for the first iteration
 663          */
 664         fake.ge_vertex = v;
 665         (void) graph_walk_recurse(&fake, &gi);
 666 
 667         startd_free(gi.gi_visited, sz);
 668 }
 669 
 670 typedef struct child_search {
 671         int     id;             /* id of vertex to look for */
 672         uint_t  depth;          /* recursion depth */
 673         /*
 674          * While the vertex is not found, path is NULL.  After the search, if
 675          * the vertex was found then path should point to a -1-terminated
 676          * array of vertex id's which constitute the path to the vertex.
 677          */
 678         int     *path;
 679 } child_search_t;
 680 
 681 static int
 682 child_pre(graph_vertex_t *v, void *arg)
 683 {
 684         child_search_t *cs = arg;
 685 
 686         cs->depth++;
 687 
 688         if (v->gv_id == cs->id) {
 689                 cs->path = startd_alloc((cs->depth + 1) * sizeof (int));
 690                 cs->path[cs->depth] = -1;
 691                 return (UU_WALK_DONE);
 692         }
 693 
 694         return (UU_WALK_NEXT);
 695 }
 696 
 697 static void
 698 child_post(graph_vertex_t *v, void *arg)
 699 {
 700         child_search_t *cs = arg;
 701 
 702         cs->depth--;
 703 
 704         if (cs->path != NULL)
 705                 cs->path[cs->depth] = v->gv_id;
 706 }
 707 
 708 /*
 709  * Look for a path from from to to.  If one exists, returns a pointer to
 710  * a NULL-terminated array of pointers to the vertices along the path.  If
 711  * there is no path, returns NULL.
 712  */
 713 static int *
 714 is_path_to(graph_vertex_t *from, graph_vertex_t *to)
 715 {
 716         child_search_t cs;
 717 
 718         cs.id = to->gv_id;
 719         cs.depth = 0;
 720         cs.path = NULL;
 721 
 722         graph_walk(from, WALK_DEPENDENCIES, child_pre, child_post, &cs);
 723 
 724         return (cs.path);
 725 }
 726 
 727 /*
 728  * Given an array of int's as returned by is_path_to, allocates a string of
 729  * their names joined by newlines.  Returns the size of the allocated buffer
 730  * in *sz and frees path.
 731  */
 732 static void
 733 path_to_str(int *path, char **cpp, size_t *sz)
 734 {
 735         int i;
 736         graph_vertex_t *v;
 737         size_t allocd, new_allocd;
 738         char *new, *name;
 739 
 740         assert(MUTEX_HELD(&dgraph_lock));
 741         assert(path[0] != -1);
 742 
 743         allocd = 1;
 744         *cpp = startd_alloc(1);
 745         (*cpp)[0] = '\0';
 746 
 747         for (i = 0; path[i] != -1; ++i) {
 748                 name = NULL;
 749 
 750                 v = vertex_get_by_id(path[i]);
 751 
 752                 if (v == NULL)
 753                         name = "<deleted>";
 754                 else if (v->gv_type == GVT_INST || v->gv_type == GVT_SVC)
 755                         name = v->gv_name;
 756 
 757                 if (name != NULL) {
 758                         new_allocd = allocd + strlen(name) + 1;
 759                         new = startd_alloc(new_allocd);
 760                         (void) strcpy(new, *cpp);
 761                         (void) strcat(new, name);
 762                         (void) strcat(new, "\n");
 763 
 764                         startd_free(*cpp, allocd);
 765 
 766                         *cpp = new;
 767                         allocd = new_allocd;
 768                 }
 769         }
 770 
 771         startd_free(path, sizeof (int) * (i + 1));
 772 
 773         *sz = allocd;
 774 }
 775 
 776 
 777 /*
 778  * This function along with run_sulogin() implements an exclusion relationship
 779  * between system/console-login and sulogin.  run_sulogin() will fail if
 780  * system/console-login is online, and the graph engine should call
 781  * graph_clogin_start() to bring system/console-login online, which defers the
 782  * start if sulogin is running.
 783  */
 784 static void
 785 graph_clogin_start(graph_vertex_t *v)
 786 {
 787         assert(MUTEX_HELD(&dgraph_lock));
 788 
 789         if (sulogin_running)
 790                 console_login_ready = B_TRUE;
 791         else
 792                 vertex_send_event(v, RESTARTER_EVENT_TYPE_START);
 793 }
 794 
 795 static void
 796 graph_su_start(graph_vertex_t *v)
 797 {
 798         /*
 799          * /etc/inittab used to have the initial /sbin/rcS as a 'sysinit'
 800          * entry with a runlevel of 'S', before jumping to the final
 801          * target runlevel (as set in initdefault).  We mimic that legacy
 802          * behavior here.
 803          */
 804         utmpx_set_runlevel('S', '0', B_FALSE);
 805         vertex_send_event(v, RESTARTER_EVENT_TYPE_START);
 806 }
 807 
 808 static void
 809 graph_post_su_online(void)
 810 {
 811         graph_runlevel_changed('S', 1);
 812 }
 813 
 814 static void
 815 graph_post_su_disable(void)
 816 {
 817         graph_runlevel_changed('S', 0);
 818 }
 819 
 820 static void
 821 graph_post_mu_online(void)
 822 {
 823         graph_runlevel_changed('2', 1);
 824 }
 825 
 826 static void
 827 graph_post_mu_disable(void)
 828 {
 829         graph_runlevel_changed('2', 0);
 830 }
 831 
 832 static void
 833 graph_post_mus_online(void)
 834 {
 835         graph_runlevel_changed('3', 1);
 836 }
 837 
 838 static void
 839 graph_post_mus_disable(void)
 840 {
 841         graph_runlevel_changed('3', 0);
 842 }
 843 
 844 static struct special_vertex_info {
 845         const char      *name;
 846         void            (*start_f)(graph_vertex_t *);
 847         void            (*post_online_f)(void);
 848         void            (*post_disable_f)(void);
 849 } special_vertices[] = {
 850         { CONSOLE_LOGIN_FMRI, graph_clogin_start, NULL, NULL },
 851         { SCF_MILESTONE_SINGLE_USER, graph_su_start,
 852             graph_post_su_online, graph_post_su_disable },
 853         { SCF_MILESTONE_MULTI_USER, NULL,
 854             graph_post_mu_online, graph_post_mu_disable },
 855         { SCF_MILESTONE_MULTI_USER_SERVER, NULL,
 856             graph_post_mus_online, graph_post_mus_disable },
 857         { NULL },
 858 };
 859 
 860 
 861 void
 862 vertex_send_event(graph_vertex_t *v, restarter_event_type_t e)
 863 {
 864         switch (e) {
 865         case RESTARTER_EVENT_TYPE_ADD_INSTANCE:
 866                 assert(v->gv_state == RESTARTER_STATE_UNINIT);
 867 
 868                 MUTEX_LOCK(&st->st_load_lock);
 869                 st->st_load_instances++;
 870                 MUTEX_UNLOCK(&st->st_load_lock);
 871                 break;
 872 
 873         case RESTARTER_EVENT_TYPE_ENABLE:
 874                 log_framework(LOG_DEBUG, "Enabling %s.\n", v->gv_name);
 875                 assert(v->gv_state == RESTARTER_STATE_UNINIT ||
 876                     v->gv_state == RESTARTER_STATE_DISABLED ||
 877                     v->gv_state == RESTARTER_STATE_MAINT);
 878                 break;
 879 
 880         case RESTARTER_EVENT_TYPE_DISABLE:
 881         case RESTARTER_EVENT_TYPE_ADMIN_DISABLE:
 882                 log_framework(LOG_DEBUG, "Disabling %s.\n", v->gv_name);
 883                 assert(v->gv_state != RESTARTER_STATE_DISABLED);
 884                 break;
 885 
 886         case RESTARTER_EVENT_TYPE_STOP_RESET:
 887         case RESTARTER_EVENT_TYPE_STOP:
 888                 log_framework(LOG_DEBUG, "Stopping %s.\n", v->gv_name);
 889                 assert(v->gv_state == RESTARTER_STATE_DEGRADED ||
 890                     v->gv_state == RESTARTER_STATE_ONLINE);
 891                 break;
 892 
 893         case RESTARTER_EVENT_TYPE_START:
 894                 log_framework(LOG_DEBUG, "Starting %s.\n", v->gv_name);
 895                 assert(v->gv_state == RESTARTER_STATE_OFFLINE);
 896                 break;
 897 
 898         case RESTARTER_EVENT_TYPE_REMOVE_INSTANCE:
 899         case RESTARTER_EVENT_TYPE_ADMIN_DEGRADED:
 900         case RESTARTER_EVENT_TYPE_ADMIN_REFRESH:
 901         case RESTARTER_EVENT_TYPE_ADMIN_RESTART:
 902         case RESTARTER_EVENT_TYPE_ADMIN_MAINT_OFF:
 903         case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON:
 904         case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON_IMMEDIATE:
 905         case RESTARTER_EVENT_TYPE_DEPENDENCY_CYCLE:
 906         case RESTARTER_EVENT_TYPE_INVALID_DEPENDENCY:
 907                 break;
 908 
 909         default:
 910 #ifndef NDEBUG
 911                 uu_warn("%s:%d: Bad event %d.\n", __FILE__, __LINE__, e);
 912 #endif
 913                 abort();
 914         }
 915 
 916         restarter_protocol_send_event(v->gv_name, v->gv_restarter_channel, e,
 917             v->gv_reason);
 918 }
 919 
 920 static void
 921 graph_unset_restarter(graph_vertex_t *v)
 922 {
 923         assert(MUTEX_HELD(&dgraph_lock));
 924         assert(v->gv_flags & GV_CONFIGURED);
 925 
 926         vertex_send_event(v, RESTARTER_EVENT_TYPE_REMOVE_INSTANCE);
 927 
 928         if (v->gv_restarter_id != -1) {
 929                 graph_vertex_t *rv;
 930 
 931                 rv = vertex_get_by_id(v->gv_restarter_id);
 932                 graph_remove_edge(v, rv);
 933         }
 934 
 935         v->gv_restarter_id = -1;
 936         v->gv_restarter_channel = NULL;
 937 }
 938 
 939 /*
 940  * Return VERTEX_REMOVED when the vertex passed in argument is deleted from the
 941  * dgraph otherwise return VERTEX_INUSE.
 942  */
 943 static int
 944 free_if_unrefed(graph_vertex_t *v)
 945 {
 946         assert(MUTEX_HELD(&dgraph_lock));
 947 
 948         if (v->gv_refs > 0)
 949                 return (VERTEX_INUSE);
 950 
 951         if (v->gv_type == GVT_SVC &&
 952             uu_list_numnodes(v->gv_dependents) == 0 &&
 953             uu_list_numnodes(v->gv_dependencies) == 0) {
 954                 graph_remove_vertex(v);
 955                 return (VERTEX_REMOVED);
 956         } else if (v->gv_type == GVT_INST &&
 957             (v->gv_flags & GV_CONFIGURED) == 0 &&
 958             uu_list_numnodes(v->gv_dependents) == 1 &&
 959             uu_list_numnodes(v->gv_dependencies) == 0) {
 960                 remove_inst_vertex(v);
 961                 return (VERTEX_REMOVED);
 962         }
 963 
 964         return (VERTEX_INUSE);
 965 }
 966 
 967 static void
 968 delete_depgroup(graph_vertex_t *v)
 969 {
 970         graph_edge_t *e;
 971         graph_vertex_t *dv;
 972 
 973         assert(MUTEX_HELD(&dgraph_lock));
 974         assert(v->gv_type == GVT_GROUP);
 975         assert(uu_list_numnodes(v->gv_dependents) == 0);
 976 
 977         while ((e = uu_list_first(v->gv_dependencies)) != NULL) {
 978                 dv = e->ge_vertex;
 979 
 980                 graph_remove_edge(v, dv);
 981 
 982                 switch (dv->gv_type) {
 983                 case GVT_INST:          /* instance dependency */
 984                 case GVT_SVC:           /* service dependency */
 985                         (void) free_if_unrefed(dv);
 986                         break;
 987 
 988                 case GVT_FILE:          /* file dependency */
 989                         assert(uu_list_numnodes(dv->gv_dependencies) == 0);
 990                         if (uu_list_numnodes(dv->gv_dependents) == 0)
 991                                 graph_remove_vertex(dv);
 992                         break;
 993 
 994                 default:
 995 #ifndef NDEBUG
 996                         uu_warn("%s:%d: Unexpected node type %d", __FILE__,
 997                             __LINE__, dv->gv_type);
 998 #endif
 999                         abort();
1000                 }
1001         }
1002 
1003         graph_remove_vertex(v);
1004 }
1005 
1006 static int
1007 delete_instance_deps_cb(graph_edge_t *e, void **ptrs)
1008 {
1009         graph_vertex_t *v = ptrs[0];
1010         boolean_t delete_restarter_dep = (boolean_t)ptrs[1];
1011         graph_vertex_t *dv;
1012 
1013         dv = e->ge_vertex;
1014 
1015         /*
1016          * We have four possibilities here:
1017          *   - GVT_INST: restarter
1018          *   - GVT_GROUP - GVT_INST: instance dependency
1019          *   - GVT_GROUP - GVT_SVC - GV_INST: service dependency
1020          *   - GVT_GROUP - GVT_FILE: file dependency
1021          */
1022         switch (dv->gv_type) {
1023         case GVT_INST:  /* restarter */
1024                 assert(dv->gv_id == v->gv_restarter_id);
1025                 if (delete_restarter_dep)
1026                         graph_remove_edge(v, dv);
1027                 break;
1028 
1029         case GVT_GROUP: /* pg dependency */
1030                 graph_remove_edge(v, dv);
1031                 delete_depgroup(dv);
1032                 break;
1033 
1034         case GVT_FILE:
1035                 /* These are currently not direct dependencies */
1036 
1037         default:
1038 #ifndef NDEBUG
1039                 uu_warn("%s:%d: Bad vertex type %d.\n", __FILE__, __LINE__,
1040                     dv->gv_type);
1041 #endif
1042                 abort();
1043         }
1044 
1045         return (UU_WALK_NEXT);
1046 }
1047 
1048 static void
1049 delete_instance_dependencies(graph_vertex_t *v, boolean_t delete_restarter_dep)
1050 {
1051         void *ptrs[2];
1052         int r;
1053 
1054         assert(MUTEX_HELD(&dgraph_lock));
1055         assert(v->gv_type == GVT_INST);
1056 
1057         ptrs[0] = v;
1058         ptrs[1] = (void *)delete_restarter_dep;
1059 
1060         r = uu_list_walk(v->gv_dependencies,
1061             (uu_walk_fn_t *)delete_instance_deps_cb, &ptrs, UU_WALK_ROBUST);
1062         assert(r == 0);
1063 }
1064 
1065 /*
1066  * int graph_insert_vertex_unconfigured()
1067  *   Insert a vertex without sending any restarter events. If the vertex
1068  *   already exists or creation is successful, return a pointer to it in *vp.
1069  *
1070  *   If type is not GVT_GROUP, dt can remain unset.
1071  *
1072  *   Returns 0, EEXIST, or EINVAL if the arguments are invalid (i.e., fmri
1073  *   doesn't agree with type, or type doesn't agree with dt).
1074  */
1075 static int
1076 graph_insert_vertex_unconfigured(const char *fmri, gv_type_t type,
1077     depgroup_type_t dt, restarter_error_t rt, graph_vertex_t **vp)
1078 {
1079         int r;
1080         int i;
1081 
1082         assert(MUTEX_HELD(&dgraph_lock));
1083 
1084         switch (type) {
1085         case GVT_SVC:
1086         case GVT_INST:
1087                 if (strncmp(fmri, "svc:", sizeof ("svc:") - 1) != 0)
1088                         return (EINVAL);
1089                 break;
1090 
1091         case GVT_FILE:
1092                 if (strncmp(fmri, "file:", sizeof ("file:") - 1) != 0)
1093                         return (EINVAL);
1094                 break;
1095 
1096         case GVT_GROUP:
1097                 if (dt <= 0 || rt < 0)
1098                         return (EINVAL);
1099                 break;
1100 
1101         default:
1102 #ifndef NDEBUG
1103                 uu_warn("%s:%d: Unknown type %d.\n", __FILE__, __LINE__, type);
1104 #endif
1105                 abort();
1106         }
1107 
1108         *vp = vertex_get_by_name(fmri);
1109         if (*vp != NULL)
1110                 return (EEXIST);
1111 
1112         *vp = graph_add_vertex(fmri);
1113 
1114         (*vp)->gv_type = type;
1115         (*vp)->gv_depgroup = dt;
1116         (*vp)->gv_restart = rt;
1117 
1118         (*vp)->gv_flags = 0;
1119         (*vp)->gv_state = RESTARTER_STATE_NONE;
1120 
1121         for (i = 0; special_vertices[i].name != NULL; ++i) {
1122                 if (strcmp(fmri, special_vertices[i].name) == 0) {
1123                         (*vp)->gv_start_f = special_vertices[i].start_f;
1124                         (*vp)->gv_post_online_f =
1125                             special_vertices[i].post_online_f;
1126                         (*vp)->gv_post_disable_f =
1127                             special_vertices[i].post_disable_f;
1128                         break;
1129                 }
1130         }
1131 
1132         (*vp)->gv_restarter_id = -1;
1133         (*vp)->gv_restarter_channel = 0;
1134 
1135         if (type == GVT_INST) {
1136                 char *sfmri;
1137                 graph_vertex_t *sv;
1138 
1139                 sfmri = inst_fmri_to_svc_fmri(fmri);
1140                 sv = vertex_get_by_name(sfmri);
1141                 if (sv == NULL) {
1142                         r = graph_insert_vertex_unconfigured(sfmri, GVT_SVC, 0,
1143                             0, &sv);
1144                         assert(r == 0);
1145                 }
1146                 startd_free(sfmri, max_scf_fmri_size);
1147 
1148                 graph_add_edge(sv, *vp);
1149         }
1150 
1151         /*
1152          * If this vertex is in the subgraph, mark it as so, for both
1153          * GVT_INST and GVT_SERVICE verteces.
1154          * A GVT_SERVICE vertex can only be in the subgraph if another instance
1155          * depends on it, in which case it's already been added to the graph
1156          * and marked as in the subgraph (by refresh_vertex()).  If a
1157          * GVT_SERVICE vertex was freshly added (by the code above), it means
1158          * that it has no dependents, and cannot be in the subgraph.
1159          * Regardless of this, we still check that gv_flags includes
1160          * GV_INSUBGRAPH in the event that future behavior causes the above
1161          * code to add a GVT_SERVICE vertex which should be in the subgraph.
1162          */
1163 
1164         (*vp)->gv_flags |= (should_be_in_subgraph(*vp)? GV_INSUBGRAPH : 0);
1165 
1166         return (0);
1167 }
1168 
1169 /*
1170  * Returns 0 on success or ELOOP if the dependency would create a cycle.
1171  */
1172 static int
1173 graph_insert_dependency(graph_vertex_t *fv, graph_vertex_t *tv, int **pathp)
1174 {
1175         hrtime_t now;
1176 
1177         assert(MUTEX_HELD(&dgraph_lock));
1178 
1179         /* cycle detection */
1180         now = gethrtime();
1181 
1182         /* Don't follow exclusions. */
1183         if (!(fv->gv_type == GVT_GROUP &&
1184             fv->gv_depgroup == DEPGRP_EXCLUDE_ALL)) {
1185                 *pathp = is_path_to(tv, fv);
1186                 if (*pathp)
1187                         return (ELOOP);
1188         }
1189 
1190         dep_cycle_ns += gethrtime() - now;
1191         ++dep_inserts;
1192         now = gethrtime();
1193 
1194         graph_add_edge(fv, tv);
1195 
1196         dep_insert_ns += gethrtime() - now;
1197 
1198         /* Check if the dependency adds the "to" vertex to the subgraph */
1199         tv->gv_flags |= (should_be_in_subgraph(tv) ? GV_INSUBGRAPH : 0);
1200 
1201         return (0);
1202 }
1203 
1204 static int
1205 inst_running(graph_vertex_t *v)
1206 {
1207         assert(v->gv_type == GVT_INST);
1208 
1209         if (v->gv_state == RESTARTER_STATE_ONLINE ||
1210             v->gv_state == RESTARTER_STATE_DEGRADED)
1211                 return (1);
1212 
1213         return (0);
1214 }
1215 
1216 /*
1217  * The dependency evaluation functions return
1218  *   1 - dependency satisfied
1219  *   0 - dependency unsatisfied
1220  *   -1 - dependency unsatisfiable (without administrator intervention)
1221  *
1222  * The functions also take a boolean satbility argument.  When true, the
1223  * functions may recurse in order to determine satisfiability.
1224  */
1225 static int require_any_satisfied(graph_vertex_t *, boolean_t);
1226 static int dependency_satisfied(graph_vertex_t *, boolean_t);
1227 
1228 /*
1229  * A require_all dependency is unsatisfied if any elements are unsatisfied.  It
1230  * is unsatisfiable if any elements are unsatisfiable.
1231  */
1232 static int
1233 require_all_satisfied(graph_vertex_t *groupv, boolean_t satbility)
1234 {
1235         graph_edge_t *edge;
1236         int i;
1237         boolean_t any_unsatisfied;
1238 
1239         if (uu_list_numnodes(groupv->gv_dependencies) == 0)
1240                 return (1);
1241 
1242         any_unsatisfied = B_FALSE;
1243 
1244         for (edge = uu_list_first(groupv->gv_dependencies);
1245             edge != NULL;
1246             edge = uu_list_next(groupv->gv_dependencies, edge)) {
1247                 i = dependency_satisfied(edge->ge_vertex, satbility);
1248                 if (i == 1)
1249                         continue;
1250 
1251                 log_framework2(LOG_DEBUG, DEBUG_DEPENDENCIES,
1252                     "require_all(%s): %s is unsatisfi%s.\n", groupv->gv_name,
1253                     edge->ge_vertex->gv_name, i == 0 ? "ed" : "able");
1254 
1255                 if (!satbility)
1256                         return (0);
1257 
1258                 if (i == -1)
1259                         return (-1);
1260 
1261                 any_unsatisfied = B_TRUE;
1262         }
1263 
1264         return (any_unsatisfied ? 0 : 1);
1265 }
1266 
1267 /*
1268  * A require_any dependency is satisfied if any element is satisfied.  It is
1269  * satisfiable if any element is satisfiable.
1270  */
1271 static int
1272 require_any_satisfied(graph_vertex_t *groupv, boolean_t satbility)
1273 {
1274         graph_edge_t *edge;
1275         int s;
1276         boolean_t satisfiable;
1277 
1278         if (uu_list_numnodes(groupv->gv_dependencies) == 0)
1279                 return (1);
1280 
1281         satisfiable = B_FALSE;
1282 
1283         for (edge = uu_list_first(groupv->gv_dependencies);
1284             edge != NULL;
1285             edge = uu_list_next(groupv->gv_dependencies, edge)) {
1286                 s = dependency_satisfied(edge->ge_vertex, satbility);
1287 
1288                 if (s == 1)
1289                         return (1);
1290 
1291                 log_framework2(LOG_DEBUG, DEBUG_DEPENDENCIES,
1292                     "require_any(%s): %s is unsatisfi%s.\n",
1293                     groupv->gv_name, edge->ge_vertex->gv_name,
1294                     s == 0 ? "ed" : "able");
1295 
1296                 if (satbility && s == 0)
1297                         satisfiable = B_TRUE;
1298         }
1299 
1300         return (!satbility || satisfiable ? 0 : -1);



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