Lines Matching defs:v

179 #define	IS_ENABLED(v) ((v)->gv_flags & (GV_ENABLED | GV_ENBLD_NOOVR))
209 #define is_depgrp_bypassed(v) ((v->gv_type == GVT_GROUP) && \
210 ((v->gv_depgroup == DEPGRP_EXCLUDE_ALL) || \
211 (v->gv_depgroup == DEPGRP_OPTIONAL_ALL) || \
212 (v->gv_restart < RERR_RESTART)))
307 static boolean_t should_be_in_subgraph(graph_vertex_t *v);
388 graph_vertex_t *v;
396 v = startd_zalloc(sizeof (*v));
398 v->gv_id = id;
400 v->gv_name = startd_alloc(strlen(name) + 1);
401 (void) strcpy(v->gv_name, name);
403 v->gv_dependencies = startd_list_create(graph_edge_pool, v, 0);
404 v->gv_dependents = startd_list_create(graph_edge_pool, v, 0);
409 uu_list_node_init(v, &v->gv_link, graph_vertex_pool);
410 uu_list_insert(dgraph, v, idx);
412 return (v);
416 * Removes v from the graph and frees it. The graph should be locked by this
417 * thread, and v should have no edges associated with it.
420 graph_remove_vertex(graph_vertex_t *v)
424 assert(uu_list_numnodes(v->gv_dependencies) == 0);
425 assert(uu_list_numnodes(v->gv_dependents) == 0);
426 assert(v->gv_refs == 0);
428 startd_free(v->gv_name, strlen(v->gv_name) + 1);
429 uu_list_destroy(v->gv_dependencies);
430 uu_list_destroy(v->gv_dependents);
431 uu_list_remove(dgraph, v);
433 startd_free(v, sizeof (graph_vertex_t));
463 graph_remove_edge(graph_vertex_t *v, graph_vertex_t *dv)
467 for (e = uu_list_first(v->gv_dependencies);
469 e = uu_list_next(v->gv_dependencies, e)) {
471 uu_list_remove(v->gv_dependencies, e);
480 if (e->ge_vertex == v) {
489 remove_inst_vertex(graph_vertex_t *v)
496 assert(uu_list_numnodes(v->gv_dependents) == 1);
497 assert(uu_list_numnodes(v->gv_dependencies) == 0);
498 assert(v->gv_refs == 0);
499 assert((v->gv_flags & GV_CONFIGURED) == 0);
501 e = uu_list_first(v->gv_dependents);
503 graph_remove_edge(sv, v);
506 if (up_svcs_p[i] == v)
510 if (manifest_import_p == v)
513 graph_remove_vertex(v);
522 graph_walk_dependents(graph_vertex_t *v, void (*func)(graph_vertex_t *, void *),
527 for (e = uu_list_first(v->gv_dependents);
529 e = uu_list_next(v->gv_dependents, e))
534 graph_walk_dependencies(graph_vertex_t *v,
541 for (e = uu_list_first(v->gv_dependencies);
543 e = uu_list_next(v->gv_dependencies, e)) {
588 graph_vertex_t *v = e->ge_vertex;
592 i = v->gv_id / 8;
593 b = 1 << (v->gv_id % 8);
606 if (v->gv_type == GVT_GROUP && v->gv_depgroup == DEPGRP_EXCLUDE_ALL)
613 if ((gip->gi_ret = gip->gi_pre(v, gip->gi_arg)) == UU_WALK_NEXT) {
618 list = v->gv_dependents;
620 list = v->gv_dependencies;
636 (void) gip->gi_post(v, gip->gi_arg);
647 graph_walk(graph_vertex_t *v, graph_walk_dir_t dir,
665 fake.ge_vertex = v;
683 child_pre(graph_vertex_t *v, void *arg)
689 if (v->gv_id == cs->id) {
699 child_post(graph_vertex_t *v, void *arg)
706 cs->path[cs->depth] = v->gv_id;
737 graph_vertex_t *v;
751 v = vertex_get_by_id(path[i]);
753 if (v == NULL)
755 else if (v->gv_type == GVT_INST || v->gv_type == GVT_SVC)
756 name = v->gv_name;
786 graph_clogin_start(graph_vertex_t *v)
793 vertex_send_event(v, RESTARTER_EVENT_TYPE_START);
797 graph_su_start(graph_vertex_t *v)
806 vertex_send_event(v, RESTARTER_EVENT_TYPE_START);
863 vertex_send_event(graph_vertex_t *v, restarter_event_type_t e)
867 assert(v->gv_state == RESTARTER_STATE_UNINIT);
875 log_framework(LOG_DEBUG, "Enabling %s.\n", v->gv_name);
876 assert(v->gv_state == RESTARTER_STATE_UNINIT ||
877 v->gv_state == RESTARTER_STATE_DISABLED ||
878 v->gv_state == RESTARTER_STATE_MAINT);
883 log_framework(LOG_DEBUG, "Disabling %s.\n", v->gv_name);
884 assert(v->gv_state != RESTARTER_STATE_DISABLED);
889 log_framework(LOG_DEBUG, "Stopping %s.\n", v->gv_name);
890 assert(v->gv_state == RESTARTER_STATE_DEGRADED ||
891 v->gv_state == RESTARTER_STATE_ONLINE);
895 log_framework(LOG_DEBUG, "Starting %s.\n", v->gv_name);
896 assert(v->gv_state == RESTARTER_STATE_OFFLINE);
917 restarter_protocol_send_event(v->gv_name, v->gv_restarter_channel, e,
918 v->gv_reason);
922 graph_unset_restarter(graph_vertex_t *v)
925 assert(v->gv_flags & GV_CONFIGURED);
927 vertex_send_event(v, RESTARTER_EVENT_TYPE_REMOVE_INSTANCE);
929 if (v->gv_restarter_id != -1) {
932 rv = vertex_get_by_id(v->gv_restarter_id);
933 graph_remove_edge(v, rv);
936 v->gv_restarter_id = -1;
937 v->gv_restarter_channel = NULL;
945 free_if_unrefed(graph_vertex_t *v)
949 if (v->gv_refs > 0)
952 if (v->gv_type == GVT_SVC &&
953 uu_list_numnodes(v->gv_dependents) == 0 &&
954 uu_list_numnodes(v->gv_dependencies) == 0) {
955 graph_remove_vertex(v);
957 } else if (v->gv_type == GVT_INST &&
958 (v->gv_flags & GV_CONFIGURED) == 0 &&
959 uu_list_numnodes(v->gv_dependents) == 1 &&
960 uu_list_numnodes(v->gv_dependencies) == 0) {
961 remove_inst_vertex(v);
969 delete_depgroup(graph_vertex_t *v)
975 assert(v->gv_type == GVT_GROUP);
976 assert(uu_list_numnodes(v->gv_dependents) == 0);
978 while ((e = uu_list_first(v->gv_dependencies)) != NULL) {
981 graph_remove_edge(v, dv);
1004 graph_remove_vertex(v);
1010 graph_vertex_t *v = ptrs[0];
1025 assert(dv->gv_id == v->gv_restarter_id);
1027 graph_remove_edge(v, dv);
1031 graph_remove_edge(v, dv);
1050 delete_instance_dependencies(graph_vertex_t *v, boolean_t delete_restarter_dep)
1056 assert(v->gv_type == GVT_INST);
1058 ptrs[0] = v;
1061 r = uu_list_walk(v->gv_dependencies,
1206 inst_running(graph_vertex_t *v)
1208 assert(v->gv_type == GVT_INST);
1210 if (v->gv_state == RESTARTER_STATE_ONLINE ||
1211 v->gv_state == RESTARTER_STATE_DEGRADED)
1317 graph_vertex_t *v;
1328 v = edge->ge_vertex;
1330 switch (v->gv_type) {
1333 if ((v->gv_flags & (GV_CONFIGURED | GV_ENABLED)) !=
1337 if (v->gv_state == RESTARTER_STATE_MAINT)
1340 if (v->gv_flags & GV_TOOFFLINE)
1344 if (v->gv_state == RESTARTER_STATE_OFFLINE) {
1349 i = dependency_satisfied(v, B_TRUE);
1352 } else if (v->gv_state == RESTARTER_STATE_DISABLED) {
1360 i = dependency_satisfied(v, satbility);
1366 i = dependency_satisfied(v, satbility);
1381 for (e2 = uu_list_first(v->gv_dependencies);
1383 e2 = uu_list_next(v->gv_dependencies, e2)) {
1440 __LINE__, v->gv_type);
1450 v->gv_name, i == 0 ? "ed" : "able");
1471 #define LOG_EXCLUDE(u, v) \
1474 (u)->gv_name, (v)->gv_name)
1481 graph_vertex_t *v, *v2;
1486 v = edge->ge_vertex;
1488 switch (v->gv_type) {
1490 if ((v->gv_flags & GV_CONFIGURED) == 0)
1493 switch (v->gv_state) {
1496 LOG_EXCLUDE(groupv, v);
1497 return (v->gv_flags & GV_ENABLED ? -1 : 0);
1501 LOG_EXCLUDE(groupv, v);
1511 __FILE__, __LINE__, v->gv_state);
1521 if (!file_ready(v))
1523 LOG_EXCLUDE(groupv, v);
1530 __LINE__, v->gv_type);
1535 /* v represents a service */
1536 if (uu_list_numnodes(v->gv_dependencies) == 0)
1539 for (e2 = uu_list_first(v->gv_dependencies);
1541 e2 = uu_list_next(v->gv_dependencies, e2)) {
1583 instance_satisfied(graph_vertex_t *v, boolean_t satbility)
1585 assert(v->gv_type == GVT_INST);
1586 assert(!inst_running(v));
1588 return (require_all_satisfied(v, satbility));
1592 * Decide whether v can satisfy a dependency. v can either be a child of
1596 dependency_satisfied(graph_vertex_t *v, boolean_t satbility)
1598 switch (v->gv_type) {
1600 if ((v->gv_flags & GV_CONFIGURED) == 0) {
1601 if (v->gv_flags & GV_DEATHROW) {
1615 if (v->gv_flags & GV_TOOFFLINE)
1618 switch (v->gv_state) {
1626 return (instance_satisfied(v, satbility) != -1 ?
1639 __FILE__, __LINE__, v->gv_state);
1646 if (uu_list_numnodes(v->gv_dependencies) == 0)
1648 return (require_any_satisfied(v, satbility));
1652 return (file_ready(v) ? 1 : -1);
1660 v->gv_type);
1666 switch (v->gv_depgroup) {
1668 return (require_any_satisfied(v, satbility));
1671 return (require_all_satisfied(v, satbility));
1674 return (optional_all_satisfied(v, satbility));
1677 return (exclude_all_satisfied(v, satbility));
1682 __LINE__, v->gv_depgroup);
1689 graph_start_if_satisfied(graph_vertex_t *v)
1691 if (v->gv_state == RESTARTER_STATE_OFFLINE &&
1692 instance_satisfied(v, B_FALSE) == 1) {
1693 if (v->gv_start_f == NULL)
1694 vertex_send_event(v, RESTARTER_EVENT_TYPE_START);
1696 v->gv_start_f(v);
1730 satbility_cb(graph_vertex_t *v, void *arg)
1732 if (v->gv_type == GVT_INST)
1733 graph_start_if_satisfied(v);
1739 propagate_satbility(graph_vertex_t *v)
1741 graph_walk(v, WALK_DEPENDENTS, satbility_cb, NULL, NULL);
1748 propagate_start(graph_vertex_t *v, void *arg)
1750 switch (v->gv_type) {
1752 graph_start_if_satisfied(v);
1756 if (v->gv_depgroup == DEPGRP_EXCLUDE_ALL) {
1757 graph_walk_dependents(v, propagate_stop,
1764 graph_walk_dependents(v, propagate_start, NULL);
1778 v->gv_type);
1785 propagate_stop(graph_vertex_t *v, void *arg)
1791 switch (v->gv_type) {
1794 if (err > RERR_NONE && inst_running(v)) {
1796 vertex_send_event(v,
1799 vertex_send_event(v, RESTARTER_EVENT_TYPE_STOP);
1805 graph_walk_dependents(v, propagate_stop, arg);
1817 if (v->gv_depgroup == DEPGRP_EXCLUDE_ALL) {
1818 graph_walk_dependents(v, propagate_start, NULL);
1822 if (err == RERR_NONE || err > v->gv_restart)
1825 assert(uu_list_numnodes(v->gv_dependents) == 1);
1826 e = uu_list_first(v->gv_dependents);
1843 v->gv_type);
1850 offline_vertex(graph_vertex_t *v)
1858 assert(v->gv_type == GVT_INST);
1867 if (scf_handle_decode_fmri(h, v->gv_name, NULL, NULL, scf_inst, NULL,
1881 uu_die("Can't decode FMRI %s: %s\n", v->gv_name,
1909 v->gv_name);
1923 vertex_send_event(v, RESTARTER_EVENT_TYPE_STOP_RESET);
1935 graph_vertex_t *v;
2015 for (v = uu_list_first(dgraph); v != NULL;
2016 v = uu_list_next(dgraph, v)) {
2018 if (v == vertex)
2021 if (v->gv_type != GVT_INST ||
2022 (v->gv_flags & GV_CONFIGURED) == 0 ||
2023 (v->gv_flags & GV_ENABLED) == 0 ||
2024 (v->gv_flags & GV_TOOFFLINE) == 0)
2027 if ((v->gv_state != RESTARTER_STATE_ONLINE) &&
2028 (v->gv_state != RESTARTER_STATE_DEGRADED)) {
2038 if (insubtree_dependents_down(v) == B_TRUE) {
2041 v->gv_name, vertex->gv_name);
2042 offline_vertex(v);
2050 * Set the restarter for v to fmri_arg. That is, make sure a vertex for
2051 * fmri_arg exists, make v depend on it, and send _ADD_INSTANCE for v. If
2052 * v is already configured and fmri_arg indicates the current restarter, do
2053 * nothing. If v is configured and fmri_arg is a new restarter, delete v's
2054 * dependency on the restarter, send _REMOVE_INSTANCE for v, and set the new
2058 * point to a -1-terminated array of ids which compose the path from v to
2062 graph_change_restarter(graph_vertex_t *v, const char *fmri_arg, scf_handle_t *h,
2082 if (v->gv_flags & GV_CONFIGURED) {
2083 if (v->gv_restarter_id == -1) {
2090 graph_unset_restarter(v);
2094 v->gv_restarter_id = -1;
2095 v->gv_restarter_channel = NULL;
2096 vertex_send_event(v, RESTARTER_EVENT_TYPE_ADD_INSTANCE);
2100 if (v->gv_flags & GV_CONFIGURED) {
2102 if (id != -1 && v->gv_restarter_id == id) {
2107 graph_unset_restarter(v);
2121 v->gv_restarter_id = rv->gv_id;
2122 v->gv_restarter_channel = rv->gv_delegate_channel;
2124 err = graph_insert_dependency(v, rv, pathp);
2130 vertex_send_event(v, RESTARTER_EVENT_TYPE_ADD_INSTANCE);
2315 graph_vertex_t *v; /* GVT_GROUP vertex */
2325 * Find or create a vertex for fmri and make info->v depend on it.
2342 graph_vertex_t *depgroup_v, *v;
2352 depgroup_v = info->v;
2364 RERR_NONE, &v);
2370 assert(v->gv_type == GVT_FILE);
2427 RERR_NONE, &v);
2434 /* Verify v. */
2436 assert(v->gv_type == GVT_INST);
2438 assert(v->gv_type == GVT_SVC);
2447 info->err = graph_insert_dependency(depgroup_v, v, info->pathp);
2460 switch (v->gv_type) {
2462 if ((v->gv_flags & GV_CONFIGURED) != 0)
2470 err = libscf_lookup_instance(v->gv_name, inst);
2473 err = configure_vertex(v, inst);
2510 (void) add_service(v->gv_name, info->h, &rebound);
2519 graph_vertex_t *v; /* GVT_INST vertex */
2525 * Make info->v depend on a new GVT_GROUP node for this property group,
2578 pg_name, info->v->gv_name, scf_strerror(scf_error()));
2585 pg_name, info->v->gv_name);
2590 fmri_sz = strlen(info->v->gv_name) + 1 + len + 1;
2593 (void) snprintf(fmri, fmri_sz, "%s>%s", info->v->gv_name,
2601 pg_name, info->v->gv_name);
2611 "\n", pg_name, info->v->gv_name);
2634 pg_name, info->v->gv_name, SCF_PROPERTY_ENTITIES);
2649 err = graph_insert_dependency(info->v, depgrp, info->pathp);
2653 linfo.v = depgrp;
2655 linfo.inst_fmri = info->v->gv_name;
2688 * Build the dependency info for v from the repository. Returns 0 on success,
2695 set_dependencies(graph_vertex_t *v, scf_instance_t *inst, int **pathp)
2708 old_configured = v->gv_flags & GV_CONFIGURED;
2709 v->gv_flags |= GV_CONFIGURED;
2712 info.v = v;
2719 v->gv_flags &= ~GV_CONFIGURED;
2762 vertex_ref(graph_vertex_t *v)
2766 v->gv_refs++;
2777 vertex_unref(graph_vertex_t *v)
2780 assert(v->gv_refs > 0);
2782 v->gv_refs--;
2784 return (free_if_unrefed(v));
2799 graph_vertex_t *v = e->ge_vertex;
2803 switch (v->gv_type) {
2809 r = uu_list_walk(v->gv_dependencies,
2820 __LINE__, v->gv_type);
2826 new->ge_vertex = v;
2836 vertex_ref(v);
2842 should_be_in_subgraph(graph_vertex_t *v)
2846 if (v == milestone)
2850 * v is in the subgraph if any of its dependents are in the subgraph.
2854 for (e = uu_list_first(v->gv_dependents);
2856 e = uu_list_next(v->gv_dependents, e)) {
2865 if (v->gv_type == GVT_INST && dv->gv_type == GVT_SVC) {
2882 !(v->gv_flags & GV_ENBLD_NOOVR))
2890 if (v->gv_type == GVT_INST &&
2893 !(v->gv_flags & GV_ENBLD_NOOVR))
2908 * Ensures that GV_INSUBGRAPH is set properly for v and its descendents. If
2913 eval_subgraph(graph_vertex_t *v, scf_handle_t *h)
2915 boolean_t old = (v->gv_flags & GV_INSUBGRAPH) != 0;
2923 new = should_be_in_subgraph(v);
2929 "Removing %s from the subgraph.\n", v->gv_name);
2931 v->gv_flags = (v->gv_flags & ~GV_INSUBGRAPH) |
2934 if (v->gv_type == GVT_INST && (v->gv_flags & GV_CONFIGURED)) {
2938 err = libscf_fmri_get_instance(h, v->gv_name, &inst);
2985 v->gv_name, strerror(err));
2994 for (e = uu_list_first(v->gv_dependencies);
2996 e = uu_list_next(v->gv_dependencies, e)) {
3008 * Delete the (property group) dependencies of v & create new ones based on
3014 refresh_vertex(graph_vertex_t *v, scf_instance_t *inst)
3027 assert(v->gv_type == GVT_INST);
3029 log_framework(LOG_DEBUG, "Graph engine: Refreshing %s.\n", v->gv_name);
3033 * In case some of v's dependencies are being deleted we must
3039 err = uu_list_walk(v->gv_dependencies,
3044 delete_instance_dependencies(v, B_FALSE);
3046 err = set_dependencies(v, inst, &path);
3078 vertex_send_event(v,
3082 vertex_send_event(v,
3106 for (e = uu_list_first(v->gv_dependencies);
3108 e = uu_list_next(v->gv_dependencies, e)) {
3120 graph_start_if_satisfied(v);
3138 * Set up v according to inst. That is, make sure it depends on its
3146 configure_vertex(graph_vertex_t *v, scf_instance_t *inst)
3161 assert(v->gv_type == GVT_INST);
3162 assert((v->gv_flags & GV_CONFIGURED) == 0);
3165 assert(should_be_in_subgraph(v) ==
3166 ((v->gv_flags & GV_INSUBGRAPH) != 0));
3174 if ((v->gv_flags & GV_DEATHROW) ||
3175 (is_fmri_in_deathrow(v->gv_name) == B_TRUE)) {
3176 if ((v->gv_flags & GV_DEATHROW) == 0) {
3182 v->gv_flags |= GV_DEATHROW;
3197 v->gv_name, strerror(err));
3208 v->gv_name);
3240 v->gv_flags |= GV_DEATHROW;
3245 log_framework(LOG_DEBUG, "Graph adding %s.\n", v->gv_name);
3348 !(v->gv_flags & GV_INSUBGRAPH)) {
3370 v->gv_name, strerror(err));
3381 assert(v->gv_flags & GV_INSUBGRAPH);
3401 err = libscf_get_basic_instance_data(h, inst, v->gv_name, &enabled,
3415 v->gv_name);
3426 v->gv_name, scf_strerror(scf_error()));
3427 v->gv_stn_tset = 0;
3429 v->gv_stn_tset = tset;
3431 if (strcmp(v->gv_name, SCF_INSTANCE_GLOBAL) == 0)
3432 stn_global = v->gv_stn_tset;
3439 v->gv_flags = (v->gv_flags & ~GV_ENBLD_NOOVR) |
3445 v->gv_state = RESTARTER_STATE_UNINIT;
3447 snap = libscf_get_or_make_running_snapshot(inst, v->gv_name, B_TRUE);
3451 err = graph_change_restarter(v, restarter_fmri, h, &path);
3466 v->gv_name, restarter_fmri);
3469 handle_cycle(v->gv_name, path);
3528 v->gv_state = RESTARTER_STATE_MAINT;
3535 err = refresh_vertex(v, inst);
3542 v->gv_flags |= GV_CONFIGURED;
3544 graph_enable_by_vertex(v, enabled, 0);
3568 * inverted by -v. 15 is reserved for dladmd. Yes, this is a
3575 (void) fork_with_timeout("/usr/bin/pkill -TERM -v -u 0,1,15", 1, 5);
3576 (void) fork_with_timeout("/usr/bin/pkill -KILL -v -u 0,1,15", 1, 5);
3836 graph_vertex_t *v;
3843 v = vertex_get_by_name(console_login_fmri);
3844 if (v != NULL && inst_running(v))
3858 v = vertex_get_by_name(console_login_fmri);
3860 if (v != NULL && v->gv_state == RESTARTER_STATE_OFFLINE) {
3861 if (v->gv_start_f == NULL)
3862 vertex_send_event(v,
3865 v->gv_start_f(v);
4112 graph_vertex_t *v;
4125 v = vertex_get_by_name(inst_fmri);
4127 if (v != NULL) {
4128 assert(v->gv_type == GVT_INST);
4130 if (v->gv_flags & GV_CONFIGURED) {
4138 RERR_NONE, &v);
4147 err = configure_vertex(v, inst);
4177 graph_vertex_t *v;
4226 v = vertex_get_by_name(fmri);
4227 if (v == NULL || !(v->gv_flags & GV_CONFIGURED)) {
4238 err = libscf_get_basic_instance_data(h, inst, v->gv_name, &enabled,
4261 oldflags = v->gv_flags;
4262 v->gv_flags = (v->gv_flags & ~GV_ENBLD_NOOVR) |
4272 if (milestone > MILESTONE_NONE && v->gv_flags != oldflags)
4273 (void) eval_subgraph(v, h);
4288 graph_enable_by_vertex(v, enabled, 1);
4296 * Delete all of the property group dependencies of v, update inst's running
4299 * reevaluate v's dependencies, send _START or _STOP as appropriate, and do
4300 * the same for v's dependents.
4310 dgraph_refresh_instance(graph_vertex_t *v, scf_instance_t *inst)
4317 assert(v->gv_type == GVT_INST);
4321 v->gv_name, &enabled, NULL, NULL);
4333 v->gv_name);
4343 v->gv_name, scf_strerror(scf_error()));
4346 v->gv_stn_tset = tset;
4347 if (strcmp(v->gv_name, SCF_INSTANCE_GLOBAL) == 0)
4353 r = libscf_snapshots_refresh(inst, v->gv_name);
4362 r = refresh_vertex(v, inst);
4374 insubtree_dependents_down(graph_vertex_t *v)
4381 for (e = uu_list_first(v->gv_dependents); e != NULL;
4382 e = uu_list_next(v->gv_dependents, e)) {
4420 is_nonsubgraph_leaf(graph_vertex_t *v)
4427 for (e = uu_list_first(v->gv_dependents);
4429 e = uu_list_next(v->gv_dependents, e)) {
4465 * Disable v temporarily. Attempt to do this by setting its enabled override
4471 disable_service_temporarily(graph_vertex_t *v, scf_handle_t *h)
4489 log_error(LOG_WARNING, emsg, v->gv_name, buf);
4491 graph_enable_by_vertex(v, 0, 0);
4495 r = scf_handle_decode_fmri(h, v->gv_name, NULL, NULL, inst,
4500 log_error(LOG_WARNING, emsg, v->gv_name, emsg_cbroken);
4501 graph_enable_by_vertex(v, 0, 0);
4528 log_error(LOG_WARNING, emsg, v->gv_name, emsg_cbroken);
4529 graph_enable_by_vertex(v, 0, 0);
4533 log_error(LOG_WARNING, emsg, v->gv_name,
4535 graph_enable_by_vertex(v, 0, 0);
4539 log_error(LOG_WARNING, emsg, v->gv_name,
4541 graph_enable_by_vertex(v, 0, 0);
4551 * Of the transitive instance dependencies of v, offline those which are
4556 offline_subtree_leaves(graph_vertex_t *v, void *arg)
4560 /* If v isn't an instance, recurse on its dependencies. */
4561 if (v->gv_type != GVT_INST) {
4562 graph_walk_dependencies(v, offline_subtree_leaves, arg);
4567 * If v is not in the subtree, so should all of its dependencies,
4570 if ((v->gv_flags & GV_TOOFFLINE) == 0)
4573 /* If v isn't a leaf because it's already down, recurse. */
4574 if (!up_state(v->gv_state)) {
4575 graph_walk_dependencies(v, offline_subtree_leaves, arg);
4579 /* if v is a leaf, offline it or disable it if it's the last one */
4580 if (insubtree_dependents_down(v) == B_TRUE) {
4581 if (v->gv_flags & GV_TODISABLE)
4582 vertex_send_event(v,
4585 offline_vertex(v);
4590 graph_offline_subtree_leaves(graph_vertex_t *v, void *h)
4592 graph_walk_dependencies(v, offline_subtree_leaves, (void *)h);
4597 * Of the transitive instance dependencies of v, disable those which are not
4602 disable_nonsubgraph_leaves(graph_vertex_t *v, void *arg)
4613 if (v->gv_type == GVT_GROUP && v->gv_depgroup == DEPGRP_EXCLUDE_ALL)
4616 /* If v isn't an instance, recurse on its dependencies. */
4617 if (v->gv_type != GVT_INST)
4620 if ((v->gv_flags & GV_CONFIGURED) == 0)
4628 * If v is in the subgraph, so should all of its dependencies, so do
4631 if (v->gv_flags & GV_INSUBGRAPH)
4634 /* If v isn't a leaf because it's already down, recurse. */
4635 if (!up_state(v->gv_state))
4638 /* If v is disabled but not down yet, be patient. */
4639 if ((v->gv_flags & GV_ENABLED) == 0)
4642 /* If v is a leaf, disable it. */
4643 if (is_nonsubgraph_leaf(v))
4644 (void) disable_service_temporarily(v, (scf_handle_t *)arg);
4649 graph_walk_dependencies(v, disable_nonsubgraph_leaves, arg);
4691 dgraph_state_transition_notify(graph_vertex_t *v,
4694 restarter_instance_state_t new_state = v->gv_state;
4727 } else if (stn_transition & v->gv_stn_tset) {
4739 (IS_ENABLED(v) == 1 || to == SCF_STATE_DISABLED)) {
4754 nvlist_add_string(attr, "fmri", v->gv_name) != 0 ||
4763 "event: %s\n", v->gv_name, strerror(errno));
4772 v->gv_name, fmev_strerror(fmev_errno));
4793 graph_vertex_t *v;
4801 v = vertex_get_by_name(inst_name);
4802 if (v == NULL) {
4807 assert(v->gv_type == GVT_INST);
4823 log_framework(LOG_DEBUG, "Graph noting %s %s -> %s.\n", v->gv_name,
4824 instance_state_str[v->gv_state], instance_state_str[state]);
4826 old_state = v->gv_state;
4827 v->gv_state = state;
4829 v->gv_reason = states->ps_reason;
4830 err = gt_transition(h, v, serr, old_state);
4831 if (err == 0 && v->gv_state != old_state) {
4832 dgraph_state_transition_notify(v, old_state, states->ps_reason);
4846 vertex_subgraph_dependencies_shutdown(scf_handle_t *h, graph_vertex_t *v,
4852 assert(v->gv_type == GVT_INST);
4863 if (v->gv_flags & GV_INSUBGRAPH)
4872 now_up = up_state(v->gv_state);
4891 if ((v->gv_flags & GV_ENABLED) && is_nonsubgraph_leaf(v)) {
4894 r = disable_service_temporarily(v, h);
4913 graph_walk_dependencies(v, disable_nonsubgraph_leaves,
4957 graph_transition_propagate(graph_vertex_t *v, propagate_event_t type,
4961 graph_walk_dependents(v, propagate_stop, (void *)rerr);
4963 graph_walk_dependents(v, propagate_start, NULL);
4966 propagate_satbility(v);
4987 graph_vertex_t *v;
4996 v = vertex_get_by_name(fmri);
4997 if (v == NULL) {
5003 if (v->gv_flags & GV_CONFIGURED)
5004 graph_unset_restarter(v);
5008 * Make a list of v's current dependencies so we can
5014 err = uu_list_walk(v->gv_dependencies,
5019 delete_instance_dependencies(v, B_TRUE);
5029 graph_walk_dependents(v, propagate_stop, (void *)RERR_RESTART);
5031 v->gv_flags &= ~GV_CONFIGURED;
5032 v->gv_flags &= ~GV_DEATHROW;
5034 graph_walk_dependents(v, propagate_start, NULL);
5035 propagate_satbility(v);
5041 if (v != milestone && v->gv_refs == 0 &&
5042 uu_list_numnodes(v->gv_dependents) == 1)
5043 remove_inst_vertex(v);
5049 v = e->ge_vertex;
5051 if (vertex_unref(v) == VERTEX_INUSE)
5052 while (eval_subgraph(v, h) == ECONNABORTED)
5439 graph_vertex_t *v;
5442 v = e->ge_vertex;
5445 if (v->gv_flags & GV_TOOFFLINE)
5448 switch (v->gv_type) {
5451 if (!(v->gv_flags & GV_ENABLED))
5454 v->gv_flags |= GV_TOOFFLINE;
5455 log_framework(LOG_DEBUG, "%s added to subtree\n", v->gv_name);
5462 if (is_depgrp_bypassed(v))
5467 r = uu_list_walk(v->gv_dependents, (uu_walk_fn_t *)mark_subtree, arg,
5476 graph_vertex_t *v;
5480 v = e->ge_vertex;
5483 if (v->gv_flags & GV_INSUBGRAPH)
5489 if (v->gv_type == GVT_GROUP && v->gv_depgroup == DEPGRP_OPTIONAL_ALL) {
5496 if (optional && (v->gv_type == GVT_INST) &&
5497 (!(v->gv_flags & GV_ENBLD_NOOVR)))
5500 v->gv_flags |= GV_INSUBGRAPH;
5503 if (v->gv_type == GVT_GROUP && v->gv_depgroup == DEPGRP_EXCLUDE_ALL)
5506 r = uu_list_walk(v->gv_dependencies, (uu_walk_fn_t *)mark_subgraph,
5554 graph_vertex_t *nm, *v;
5636 for (v = uu_list_first(dgraph); v != NULL; v = uu_list_next(dgraph, v))
5637 v->gv_flags &= ~GV_INSUBGRAPH;
5653 for (v = uu_list_first(dgraph);
5654 v != NULL;
5655 v = uu_list_next(dgraph, v)) {
5656 if (v->gv_type != GVT_INST ||
5657 (v->gv_flags & GV_CONFIGURED) == 0)
5661 r = scf_handle_decode_fmri(h, v->gv_name, NULL, NULL, inst,
5683 if (isall || (v->gv_flags & GV_INSUBGRAPH)) {
5687 assert(isnone || (v->gv_flags & GV_INSUBGRAPH) == 0);
5695 if (up_state(v->gv_state))
5699 if ((v->gv_flags & GV_ENABLED) == 0)
5702 if (!is_nonsubgraph_leaf(v))
5723 v->gv_name, strerror(r));