17c478bdstevel@tonic-gate/*
27c478bdstevel@tonic-gate * CDDL HEADER START
37c478bdstevel@tonic-gate *
47c478bdstevel@tonic-gate * The contents of this file are subject to the terms of the
53eae19dwesolows * Common Development and Distribution License (the "License").
63eae19dwesolows * You may not use this file except in compliance with the License.
77c478bdstevel@tonic-gate *
87c478bdstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bdstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bdstevel@tonic-gate * See the License for the specific language governing permissions
117c478bdstevel@tonic-gate * and limitations under the License.
127c478bdstevel@tonic-gate *
137c478bdstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bdstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bdstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bdstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bdstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bdstevel@tonic-gate *
197c478bdstevel@tonic-gate * CDDL HEADER END
207c478bdstevel@tonic-gate */
213eae19dwesolows
227c478bdstevel@tonic-gate/*
23eb1a346Truong Nguyen * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
247c478bdstevel@tonic-gate * Use is subject to license terms.
258fff788John Levon * Copyright 2020 Joyent, Inc.
267c478bdstevel@tonic-gate */
277c478bdstevel@tonic-gate
287c478bdstevel@tonic-gate/*
297c478bdstevel@tonic-gate * Service state explanation.  For select services, display a description, the
307c478bdstevel@tonic-gate * state, and possibly why the service is in that state, what's causing it to
317c478bdstevel@tonic-gate * be in that state, and what other services it is keeping offline (impact).
327c478bdstevel@tonic-gate *
337c478bdstevel@tonic-gate * Explaining states other than offline is easy.  For maintenance and
347c478bdstevel@tonic-gate * degraded, we just use the auxiliary state.  For offline, we must determine
357c478bdstevel@tonic-gate * which dependencies are unsatisfied and recurse.  If a causal service is not
367c478bdstevel@tonic-gate * offline, then a svcptr to it is added to the offline service's causes list.
377c478bdstevel@tonic-gate * If a causal service is offline, then we recurse to determine its causes and
387c478bdstevel@tonic-gate * merge them into the causes list of the service in question (see
397c478bdstevel@tonic-gate * add_causes()).  Note that by adding a self-pointing svcptr to the causes
407c478bdstevel@tonic-gate * lists of services which are not offline or are offline for unknown reasons,
417c478bdstevel@tonic-gate * we can always merge the unsatisfied dependency's causes into the
427c478bdstevel@tonic-gate * dependent's list.
437c478bdstevel@tonic-gate *
447c478bdstevel@tonic-gate * Computing an impact list is more involved because the dependencies in the
457c478bdstevel@tonic-gate * repository are unidirectional; it requires determining the causes of all
467c478bdstevel@tonic-gate * offline services.  For each unsatisfied dependency of an offline service,
477c478bdstevel@tonic-gate * a svcptr to the dependent is added to the dependency's impact_dependents
487c478bdstevel@tonic-gate * list (see add_causes()).  determine_impact() uses the lists to build an
497c478bdstevel@tonic-gate * impact list.  The direct dependency is used so that a path from the
507c478bdstevel@tonic-gate * affected service to the causal service can be constructed (see
517c478bdstevel@tonic-gate * print_dependency_reasons()).
527c478bdstevel@tonic-gate *
537c478bdstevel@tonic-gate * Because we always need at least impact counts, we always run
547c478bdstevel@tonic-gate * determine_causes() on all services.
557c478bdstevel@tonic-gate *
567c478bdstevel@tonic-gate * If no arguments are given, we must select the services which are causing
577c478bdstevel@tonic-gate * other services to be offline.  We do so by adding services which are not
587c478bdstevel@tonic-gate * running for any reason other than another service to the g_causes list in
597c478bdstevel@tonic-gate * determine_causes().
607c478bdstevel@tonic-gate *
617c478bdstevel@tonic-gate * Since all services must be examined, and their states may be consulted
627c478bdstevel@tonic-gate * a lot, it is important that we only read volatile data (like states) from
637c478bdstevel@tonic-gate * the repository once.  add_instance() reads data for an instance from the
647c478bdstevel@tonic-gate * repository into an inst_t and puts it into the "services" cache, which is
657c478bdstevel@tonic-gate * organized as a hash table of svc_t's, each of which has a list of inst_t's.
667c478bdstevel@tonic-gate */
677c478bdstevel@tonic-gate
687c478bdstevel@tonic-gate#include "svcs.h"
697c478bdstevel@tonic-gate
707c478bdstevel@tonic-gate#include <sys/stat.h>
717c478bdstevel@tonic-gate#include <sys/wait.h>
727c478bdstevel@tonic-gate
737c478bdstevel@tonic-gate#include <assert.h>
747c478bdstevel@tonic-gate#include <errno.h>
757c478bdstevel@tonic-gate#include <libintl.h>
767c478bdstevel@tonic-gate#include <libuutil.h>
777c478bdstevel@tonic-gate#include <libscf.h>
787c478bdstevel@tonic-gate#include <libscf_priv.h>
797c478bdstevel@tonic-gate#include <string.h>
807c478bdstevel@tonic-gate#include <stdio.h>
817c478bdstevel@tonic-gate#include <stdlib.h>
827c478bdstevel@tonic-gate#include <time.h>
837c478bdstevel@tonic-gate
847c478bdstevel@tonic-gate
857c478bdstevel@tonic-gate#define	DC_DISABLED	"SMF-8000-05"
867c478bdstevel@tonic-gate#define	DC_TEMPDISABLED	"SMF-8000-1S"
877c478bdstevel@tonic-gate#define	DC_RSTRINVALID	"SMF-8000-2A"
887c478bdstevel@tonic-gate#define	DC_RSTRABSENT	"SMF-8000-3P"
897c478bdstevel@tonic-gate#define	DC_UNINIT	"SMF-8000-4D"
907c478bdstevel@tonic-gate#define	DC_RSTRDEAD	"SMF-8000-5H"
917c478bdstevel@tonic-gate#define	DC_ADMINMAINT	"SMF-8000-63"
92eb1a346Truong Nguyen#define	DC_SVCREQMAINT	"SMF-8000-R4"
937c478bdstevel@tonic-gate#define	DC_REPTFAIL	"SMF-8000-7Y"
947c478bdstevel@tonic-gate#define	DC_METHFAIL	"SMF-8000-8Q"
957c478bdstevel@tonic-gate#define	DC_NONE		"SMF-8000-9C"
967c478bdstevel@tonic-gate#define	DC_UNKNOWN	"SMF-8000-AR"
977c478bdstevel@tonic-gate#define	DC_STARTING	"SMF-8000-C4"
987c478bdstevel@tonic-gate#define	DC_ADMINDEGR	"SMF-8000-DX"
997c478bdstevel@tonic-gate#define	DC_DEPABSENT	"SMF-8000-E2"
1007c478bdstevel@tonic-gate#define	DC_DEPRUNNING	"SMF-8000-FJ"
1017c478bdstevel@tonic-gate#define	DC_DEPOTHER	"SMF-8000-GE"
1027c478bdstevel@tonic-gate#define	DC_DEPCYCLE	"SMF-8000-HP"
1037c478bdstevel@tonic-gate#define	DC_INVALIDDEP	"SMF-8000-JA"
1047c478bdstevel@tonic-gate#define	DC_STARTFAIL	"SMF-8000-KS"
1057c478bdstevel@tonic-gate#define	DC_TOOQUICKLY	"SMF-8000-L5"
1067c478bdstevel@tonic-gate#define	DC_INVALIDSTATE	"SMF-8000-N3"
1077c478bdstevel@tonic-gate#define	DC_TRANSITION	"SMF-8000-PH"
1087c478bdstevel@tonic-gate
1097c478bdstevel@tonic-gate#define	DEFAULT_MAN_PATH	"/usr/share/man"
1107c478bdstevel@tonic-gate
111eb1a346Truong Nguyen#define	AUX_STATE_INVALID	"invalid_aux_state"
1127c478bdstevel@tonic-gate
1137c478bdstevel@tonic-gate#define	uu_list_append(lst, e)	uu_list_insert_before(lst, NULL, e)
1147c478bdstevel@tonic-gate
1157c478bdstevel@tonic-gate#define	bad_error(func, err)						\
11654d0224Bryan Cantrill	uu_panic("%s:%d: %s() failed with unknown error %d.\n",		\
11754d0224Bryan Cantrill	    __FILE__, __LINE__, func, err);
1187c478bdstevel@tonic-gate
1197c478bdstevel@tonic-gatetypedef struct {
1207c478bdstevel@tonic-gate	const char *svcname;
1217c478bdstevel@tonic-gate	const char *instname;
1227c478bdstevel@tonic-gate
1237c478bdstevel@tonic-gate	/* restarter pg properties */
1247c478bdstevel@tonic-gate	char state[MAX_SCF_STATE_STRING_SZ];
1257c478bdstevel@tonic-gate	char next_state[MAX_SCF_STATE_STRING_SZ];
1267c478bdstevel@tonic-gate	struct timeval stime;
1277c478bdstevel@tonic-gate	const char *aux_state;
128eb1a346Truong Nguyen	const char *aux_fmri;
1297c478bdstevel@tonic-gate	int64_t start_method_waitstatus;
1307c478bdstevel@tonic-gate
1312e1a947Liane Praza	uint8_t enabled;
1327c478bdstevel@tonic-gate	int temporary;
1337c478bdstevel@tonic-gate	const char *restarter;
1347c478bdstevel@tonic-gate	uu_list_t *dependencies;	/* list of dependency_group's */
1357c478bdstevel@tonic-gate
1368fff788John Levon	char comment[SCF_COMMENT_MAX_LENGTH];
1378fff788John Levon
1387c478bdstevel@tonic-gate	int active;			/* In use?  (cycle detection) */
1397c478bdstevel@tonic-gate	int restarter_bad;
1407c478bdstevel@tonic-gate	const char *summary;
1417c478bdstevel@tonic-gate	uu_list_t *baddeps;		/* list of dependency's */
1427c478bdstevel@tonic-gate	uu_list_t *causes;		/* list of svcptrs */
1437c478bdstevel@tonic-gate	uu_list_t *impact_dependents;	/* list of svcptrs */
1447c478bdstevel@tonic-gate	uu_list_t *impact;		/* list of svcptrs */
1457c478bdstevel@tonic-gate
1467c478bdstevel@tonic-gate	uu_list_node_t node;
1477c478bdstevel@tonic-gate} inst_t;
1487c478bdstevel@tonic-gate
1497c478bdstevel@tonic-gatetypedef struct service {
1507c478bdstevel@tonic-gate	const char *svcname;
1517c478bdstevel@tonic-gate	uu_list_t *instances;
1527c478bdstevel@tonic-gate	struct service *next;
1537c478bdstevel@tonic-gate} svc_t;
1547c478bdstevel@tonic-gate
1557c478bdstevel@tonic-gatestruct svcptr {
1567c478bdstevel@tonic-gate	inst_t *svcp;
1577c478bdstevel@tonic-gate	inst_t *next_hop;
1587c478bdstevel@tonic-gate	uu_list_node_t node;
1597c478bdstevel@tonic-gate};
1607c478bdstevel@tonic-gate
1617c478bdstevel@tonic-gatestruct dependency_group {
1627c478bdstevel@tonic-gate	enum { DGG_REQALL, DGG_REQANY, DGG_OPTALL, DGG_EXCALL } grouping;
1637c478bdstevel@tonic-gate	const char *type;
1647c478bdstevel@tonic-gate	uu_list_t *entities;		/* List of struct dependency's */
1657c478bdstevel@tonic-gate	uu_list_node_t node;
1667c478bdstevel@tonic-gate};
1677c478bdstevel@tonic-gate
1687c478bdstevel@tonic-gatestruct dependency {
1697c478bdstevel@tonic-gate	const char *fmri;
1707c478bdstevel@tonic-gate	uu_list_node_t node;
1717c478bdstevel@tonic-gate};
1727c478bdstevel@tonic-gate
1737c478bdstevel@tonic-gate/* Hash table of service names -> svc_t's */
1747c478bdstevel@tonic-gate#define	SVC_HASH_NBUCKETS	256
1757c478bdstevel@tonic-gate#define	SVC_HASH_MASK		(SVC_HASH_NBUCKETS - 1)
1767c478bdstevel@tonic-gate
1777c478bdstevel@tonic-gatestatic svc_t **services;
1787c478bdstevel@tonic-gate
1797c478bdstevel@tonic-gatestatic uu_list_pool_t *insts, *svcptrs, *depgroups, *deps;
1807c478bdstevel@tonic-gatestatic uu_list_t *g_causes;		/* list of svcptrs */
1817c478bdstevel@tonic-gate
1827c478bdstevel@tonic-gatestatic scf_scope_t *g_local_scope;
1837c478bdstevel@tonic-gatestatic scf_service_t *g_svc;
1847c478bdstevel@tonic-gatestatic scf_instance_t *g_inst;
1857c478bdstevel@tonic-gatestatic scf_snapshot_t *g_snap;
1867c478bdstevel@tonic-gatestatic scf_propertygroup_t *g_pg;
1877c478bdstevel@tonic-gatestatic scf_property_t *g_prop;
1887c478bdstevel@tonic-gatestatic scf_value_t *g_val;
1897c478bdstevel@tonic-gatestatic scf_iter_t *g_iter, *g_viter;
1907c478bdstevel@tonic-gatestatic char *g_fmri, *g_value;
1917c478bdstevel@tonic-gatestatic size_t g_fmri_sz, g_value_sz;
192654b400Joshua M. Clulowstatic const char *g_msgbase = "http://illumos.org/msg/";
1937c478bdstevel@tonic-gate
1947c478bdstevel@tonic-gatestatic char *emsg_nomem;
1957c478bdstevel@tonic-gatestatic char *emsg_invalid_dep;
1967c478bdstevel@tonic-gate
1977c478bdstevel@tonic-gateextern scf_handle_t *h;
198048b027Bryan Cantrillextern char *g_zonename;
1997c478bdstevel@tonic-gate
2007c478bdstevel@tonic-gate/* ARGSUSED */
2017c478bdstevel@tonic-gatestatic int
2027c478bdstevel@tonic-gatesvcptr_compare(struct svcptr *a, struct svcptr *b, void *data)
2037c478bdstevel@tonic-gate{
2047c478bdstevel@tonic-gate	return (b->svcp - a->svcp);
2057c478bdstevel@tonic-gate}
2067c478bdstevel@tonic-gate
2077c478bdstevel@tonic-gatestatic uint32_t
2087c478bdstevel@tonic-gatehash_name(const char *name)
2097c478bdstevel@tonic-gate{
2107c478bdstevel@tonic-gate	uint32_t h = 0, g;
2117c478bdstevel@tonic-gate	const char *p;
2127c478bdstevel@tonic-gate
2137c478bdstevel@tonic-gate	for (p = name; *p != '\0'; ++p) {
2147c478bdstevel@tonic-gate		h = (h << 4) + *p;
2157c478bdstevel@tonic-gate		if ((g = (h & 0xf0000000)) != 0) {
2167c478bdstevel@tonic-gate			h ^= (g >> 24);
2177c478bdstevel@tonic-gate			h ^= g;
2187c478bdstevel@tonic-gate		}
2197c478bdstevel@tonic-gate	}
2207c478bdstevel@tonic-gate
2217c478bdstevel@tonic-gate	return (h);
2227c478bdstevel@tonic-gate}
2237c478bdstevel@tonic-gate
2247c478bdstevel@tonic-gatestatic void
2257c478bdstevel@tonic-gatex_init(void)
2267c478bdstevel@tonic-gate{
2277c478bdstevel@tonic-gate	emsg_nomem = gettext("Out of memory.\n");
2287c478bdstevel@tonic-gate	emsg_invalid_dep =
2297c478bdstevel@tonic-gate	    gettext("svc:/%s:%s has invalid dependency \"%s\".\n");
2307c478bdstevel@tonic-gate
2317c478bdstevel@tonic-gate	services = calloc(SVC_HASH_NBUCKETS, sizeof (*services));
2327c478bdstevel@tonic-gate	if (services == NULL)
2337c478bdstevel@tonic-gate		uu_die(emsg_nomem);
2347c478bdstevel@tonic-gate
2357c478bdstevel@tonic-gate	insts = uu_list_pool_create("insts", sizeof (inst_t),
2367c478bdstevel@tonic-gate	    offsetof(inst_t, node), NULL, UU_LIST_POOL_DEBUG);
2377c478bdstevel@tonic-gate	svcptrs = uu_list_pool_create("svcptrs", sizeof (struct svcptr),
2387c478bdstevel@tonic-gate	    offsetof(struct svcptr, node), (uu_compare_fn_t *)svcptr_compare,
2397c478bdstevel@tonic-gate	    UU_LIST_POOL_DEBUG);
2407c478bdstevel@tonic-gate	depgroups = uu_list_pool_create("depgroups",
2417c478bdstevel@tonic-gate	    sizeof (struct dependency_group),
2427c478bdstevel@tonic-gate	    offsetof(struct dependency_group, node), NULL, UU_LIST_POOL_DEBUG);
2437c478bdstevel@tonic-gate	deps = uu_list_pool_create("deps", sizeof (struct dependency),
2447c478bdstevel@tonic-gate	    offsetof(struct dependency, node), NULL, UU_LIST_POOL_DEBUG);
2457c478bdstevel@tonic-gate	g_causes = uu_list_create(svcptrs, NULL, UU_LIST_DEBUG);
2467c478bdstevel@tonic-gate	if (insts == NULL || svcptrs == NULL || depgroups == NULL ||
2477c478bdstevel@tonic-gate	    deps == NULL || g_causes == NULL)
2487c478bdstevel@tonic-gate		uu_die(emsg_nomem);
2497c478bdstevel@tonic-gate
2507c478bdstevel@tonic-gate	if ((g_local_scope = scf_scope_create(h)) == NULL ||
2517c478bdstevel@tonic-gate	    (g_svc = scf_service_create(h)) == NULL ||
2527c478bdstevel@tonic-gate	    (g_inst = scf_instance_create(h)) == NULL ||
2537c478bdstevel@tonic-gate	    (g_snap = scf_snapshot_create(h)) == NULL ||
2547c478bdstevel@tonic-gate	    (g_pg = scf_pg_create(h)) == NULL ||
2557c478bdstevel@tonic-gate	    (g_prop = scf_property_create(h)) == NULL ||
2567c478bdstevel@tonic-gate	    (g_val = scf_value_create(h)) == NULL ||
2577c478bdstevel@tonic-gate	    (g_iter = scf_iter_create(h)) == NULL ||
2587c478bdstevel@tonic-gate	    (g_viter = scf_iter_create(h)) == NULL)
2597c478bdstevel@tonic-gate		scfdie();
2607c478bdstevel@tonic-gate
2617c478bdstevel@tonic-gate	if (scf_handle_get_scope(h, SCF_SCOPE_LOCAL, g_local_scope) != 0)
2627c478bdstevel@tonic-gate		scfdie();
2637c478bdstevel@tonic-gate
2647c478bdstevel@tonic-gate	g_fmri_sz = max_scf_fmri_length + 1;
2657c478bdstevel@tonic-gate	g_fmri = safe_malloc(g_fmri_sz);
2667c478bdstevel@tonic-gate
2677c478bdstevel@tonic-gate	g_value_sz = max_scf_value_length + 1;
2687c478bdstevel@tonic-gate	g_value = safe_malloc(g_value_sz);
2697c478bdstevel@tonic-gate}
2707c478bdstevel@tonic-gate
2717c478bdstevel@tonic-gate/*
2727c478bdstevel@tonic-gate * Repository loading routines.
2737c478bdstevel@tonic-gate */
2747c478bdstevel@tonic-gate
2757c478bdstevel@tonic-gate/*
2767c478bdstevel@tonic-gate * Returns
2777c478bdstevel@tonic-gate *   0 - success
2787c478bdstevel@tonic-gate *   ECANCELED - inst was deleted
2797c478bdstevel@tonic-gate *   EINVAL - inst is invalid
2807c478bdstevel@tonic-gate */
2817c478bdstevel@tonic-gatestatic int
2827c478bdstevel@tonic-gateload_dependencies(inst_t *svcp, scf_instance_t *inst)
2837c478bdstevel@tonic-gate{
2847c478bdstevel@tonic-gate	scf_snapshot_t *snap;
2857c478bdstevel@tonic-gate	struct dependency_group *dg;
2867c478bdstevel@tonic-gate	struct dependency *d;
2877c478bdstevel@tonic-gate	int r;
2887c478bdstevel@tonic-gate
2897c478bdstevel@tonic-gate	assert(svcp->dependencies == NULL);
2907c478bdstevel@tonic-gate	svcp->dependencies = uu_list_create(depgroups, svcp, UU_LIST_DEBUG);
2917c478bdstevel@tonic-gate	if (svcp->dependencies == NULL)
2927c478bdstevel@tonic-gate		uu_die(emsg_nomem);
2937c478bdstevel@tonic-gate
2947c478bdstevel@tonic-gate	if (scf_instance_get_snapshot(inst, "running", g_snap) == 0) {
2957c478bdstevel@tonic-gate		snap = g_snap;
2967c478bdstevel@tonic-gate	} else {
2977c478bdstevel@tonic-gate		if (scf_error() != SCF_ERROR_NOT_FOUND)
2987c478bdstevel@tonic-gate			scfdie();
2997c478bdstevel@tonic-gate
3007c478bdstevel@tonic-gate		snap = NULL;
3017c478bdstevel@tonic-gate	}
3027c478bdstevel@tonic-gate
3037c478bdstevel@tonic-gate	if (scf_iter_instance_pgs_typed_composed(g_iter, inst, snap,
3047c478bdstevel@tonic-gate	    SCF_GROUP_DEPENDENCY) != 0) {
3057c478bdstevel@tonic-gate		if (scf_error() != SCF_ERROR_DELETED)
3067c478bdstevel@tonic-gate			scfdie();
3077c478bdstevel@tonic-gate		return (ECANCELED);
3087c478bdstevel@tonic-gate	}
3097c478bdstevel@tonic-gate
3107c478bdstevel@tonic-gate	for (;;) {
3117c478bdstevel@tonic-gate		r = scf_iter_next_pg(g_iter, g_pg);
3127c478bdstevel@tonic-gate		if (r == 0)
3137c478bdstevel@tonic-gate			break;
3147c478bdstevel@tonic-gate		if (r != 1) {
3157c478bdstevel@tonic-gate			if (scf_error() != SCF_ERROR_DELETED)
3167c478bdstevel@tonic-gate				scfdie();
3177c478bdstevel@tonic-gate			return (ECANCELED);
3187c478bdstevel@tonic-gate		}
3197c478bdstevel@tonic-gate
3207c478bdstevel@tonic-gate		dg = safe_malloc(sizeof (*dg));
3217c478bdstevel@tonic-gate		(void) memset(dg, 0, sizeof (*dg));
3227c478bdstevel@tonic-gate		dg->entities = uu_list_create(deps, dg, UU_LIST_DEBUG);
3237c478bdstevel@tonic-gate		if (dg->entities == NULL)
3247c478bdstevel@tonic-gate			uu_die(emsg_nomem);
3257c478bdstevel@tonic-gate
3267c478bdstevel@tonic-gate		if (pg_get_single_val(g_pg, SCF_PROPERTY_GROUPING,
3277c478bdstevel@tonic-gate		    SCF_TYPE_ASTRING, g_value, g_value_sz, 0) != 0)
3287c478bdstevel@tonic-gate			return (EINVAL);
3297c478bdstevel@tonic-gate
3307c478bdstevel@tonic-gate		if (strcmp(g_value, "require_all") == 0)
3317c478bdstevel@tonic-gate			dg->grouping = DGG_REQALL;
3327c478bdstevel@tonic-gate		else if (strcmp(g_value, "require_any") == 0)
3337c478bdstevel@tonic-gate			dg->grouping = DGG_REQANY;
3347c478bdstevel@tonic-gate		else if (strcmp(g_value, "optional_all") == 0)
3357c478bdstevel@tonic-gate			dg->grouping = DGG_OPTALL;
3367c478bdstevel@tonic-gate		else if (strcmp(g_value, "exclude_all") == 0)
3377c478bdstevel@tonic-gate			dg->grouping = DGG_EXCALL;
3387c478bdstevel@tonic-gate		else {
3397c478bdstevel@tonic-gate			(void) fprintf(stderr, gettext("svc:/%s:%s has "
3407c478bdstevel@tonic-gate			    "dependency with unknown type \"%s\".\n"),
3417c478bdstevel@tonic-gate			    svcp->svcname, svcp->instname, g_value);
3427c478bdstevel@tonic-gate			return (EINVAL);
3437c478bdstevel@tonic-gate		}
3447c478bdstevel@tonic-gate
3457c478bdstevel@tonic-gate		if (pg_get_single_val(g_pg, SCF_PROPERTY_TYPE, SCF_TYPE_ASTRING,
3467c478bdstevel@tonic-gate		    g_value, g_value_sz, 0) != 0)
3477c478bdstevel@tonic-gate			return (EINVAL);
3487c478bdstevel@tonic-gate		dg->type = safe_strdup(g_value);
3497c478bdstevel@tonic-gate
3507c478bdstevel@tonic-gate		if (scf_pg_get_property(g_pg, SCF_PROPERTY_ENTITIES, g_prop) !=
3517c478bdstevel@tonic-gate		    0) {
3527c478bdstevel@tonic-gate			switch (scf_error()) {
3537c478bdstevel@tonic-gate			case SCF_ERROR_NOT_FOUND:
3547c478bdstevel@tonic-gate				(void) fprintf(stderr, gettext("svc:/%s:%s has "
3557c478bdstevel@tonic-gate				    "dependency without an entities "
3567c478bdstevel@tonic-gate				    "property.\n"), svcp->svcname,
3577c478bdstevel@tonic-gate				    svcp->instname);
3587c478bdstevel@tonic-gate				return (EINVAL);
3597c478bdstevel@tonic-gate
3607c478bdstevel@tonic-gate			case SCF_ERROR_DELETED:
3617c478bdstevel@tonic-gate				return (ECANCELED);
3627c478bdstevel@tonic-gate
3637c478bdstevel@tonic-gate			default:
3647c478bdstevel@tonic-gate				scfdie();
3657c478bdstevel@tonic-gate			}
3667c478bdstevel@tonic-gate		}
3677c478bdstevel@tonic-gate
3687c478bdstevel@tonic-gate		if (scf_iter_property_values(g_viter, g_prop) != 0) {
3697c478bdstevel@tonic-gate			if (scf_error() != SCF_ERROR_DELETED)
3707c478bdstevel@tonic-gate				scfdie();
3717c478bdstevel@tonic-gate			return (ECANCELED);
3727c478bdstevel@tonic-gate		}
3737c478bdstevel@tonic-gate
3747c478bdstevel@tonic-gate		for (;;) {
3757c478bdstevel@tonic-gate			r = scf_iter_next_value(g_viter, g_val);
3767c478bdstevel@tonic-gate			if (r == 0)
3777c478bdstevel@tonic-gate				break;
3787c478bdstevel@tonic-gate			if (r != 1) {
3797c478bdstevel@tonic-gate				if (scf_error() != SCF_ERROR_DELETED)
3807c478bdstevel@tonic-gate					scfdie();
3817c478bdstevel@tonic-gate				return (ECANCELED);
3827c478bdstevel@tonic-gate			}
3837c478bdstevel@tonic-gate
3847c478bdstevel@tonic-gate			d = safe_malloc(sizeof (*d));
3857c478bdstevel@tonic-gate			d->fmri = safe_malloc(max_scf_fmri_length + 1);
3867c478bdstevel@tonic-gate
3877c478bdstevel@tonic-gate			if (scf_value_get_astring(g_val, (char *)d->fmri,
3887c478bdstevel@tonic-gate			    max_scf_fmri_length + 1) < 0)
3897c478bdstevel@tonic-gate				scfdie();
3907c478bdstevel@tonic-gate
3917c478bdstevel@tonic-gate			uu_list_node_init(d, &d->node, deps);
3927c478bdstevel@tonic-gate			(void) uu_list_append(dg->entities, d);
3937c478bdstevel@tonic-gate		}
3947c478bdstevel@tonic-gate
3957c478bdstevel@tonic-gate		uu_list_node_init(dg, &dg->node, depgroups);
3967c478bdstevel@tonic-gate		r = uu_list_append(svcp->dependencies, dg);
3977c478bdstevel@tonic-gate		assert(r == 0);
3987c478bdstevel@tonic-gate	}
3997c478bdstevel@tonic-gate
4007c478bdstevel@tonic-gate	return (0);
4017c478bdstevel@tonic-gate}
4027c478bdstevel@tonic-gate
4037c478bdstevel@tonic-gatestatic void
4047c478bdstevel@tonic-gateadd_instance(const char *svcname, const char *instname, scf_instance_t *inst)
4057c478bdstevel@tonic-gate{
4067c478bdstevel@tonic-gate	inst_t *instp;
4077c478bdstevel@tonic-gate	svc_t *svcp;
4088fff788John Levon	int ovr_set = 0;
4092e1a947Liane Praza	uint8_t i;
4107c478bdstevel@tonic-gate	uint32_t h;
4112e1a947Liane Praza	int r;
4127c478bdstevel@tonic-gate
4137c478bdstevel@tonic-gate	h = hash_name(svcname) & SVC_HASH_MASK;
4147c478bdstevel@tonic-gate	for (svcp = services[h]; svcp != NULL; svcp = svcp->next) {
4157c478bdstevel@tonic-gate		if (strcmp(svcp->svcname, svcname) == 0)
4167c478bdstevel@tonic-gate			break;
4177c478bdstevel@tonic-gate	}
4187c478bdstevel@tonic-gate
4197c478bdstevel@tonic-gate	if (svcp == NULL) {
4207c478bdstevel@tonic-gate		svcp = safe_malloc(sizeof (*svcp));
4217c478bdstevel@tonic-gate		svcp->svcname = safe_strdup(svcname);
4227c478bdstevel@tonic-gate		svcp->instances = uu_list_create(insts, svcp, UU_LIST_DEBUG);
4237c478bdstevel@tonic-gate		if (svcp->instances == NULL)
4247c478bdstevel@tonic-gate			uu_die(emsg_nomem);
4257c478bdstevel@tonic-gate		svcp->next = services[h];
4267c478bdstevel@tonic-gate		services[h] = svcp;
4277c478bdstevel@tonic-gate	}
4287c478bdstevel@tonic-gate
4297c478bdstevel@tonic-gate	instp = safe_malloc(sizeof (*instp));
4307c478bdstevel@tonic-gate	(void) memset(instp, 0, sizeof (*instp));
4317c478bdstevel@tonic-gate	instp->svcname = svcp->svcname;
4327c478bdstevel@tonic-gate	instp->instname = safe_strdup(instname);
4337c478bdstevel@tonic-gate	instp->impact_dependents =
4347c478bdstevel@tonic-gate	    uu_list_create(svcptrs, instp, UU_LIST_DEBUG);
4357c478bdstevel@tonic-gate	if (instp->impact_dependents == NULL)
4367c478bdstevel@tonic-gate		uu_die(emsg_nomem);
4377c478bdstevel@tonic-gate
4387c478bdstevel@tonic-gate	if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, g_pg) != 0) {
4397c478bdstevel@tonic-gate		switch (scf_error()) {
4407c478bdstevel@tonic-gate		case SCF_ERROR_DELETED:
4417c478bdstevel@tonic-gate			return;
4427c478bdstevel@tonic-gate
4437c478bdstevel@tonic-gate		case SCF_ERROR_NOT_FOUND:
4447c478bdstevel@tonic-gate			(void) fprintf(stderr, gettext("svc:/%s:%s has no "
4457c478bdstevel@tonic-gate			    "\"%s\" property group; ignoring.\n"),
4467c478bdstevel@tonic-gate			    instp->svcname, instp->instname, SCF_PG_RESTARTER);
4477c478bdstevel@tonic-gate			return;
4487c478bdstevel@tonic-gate
4497c478bdstevel@tonic-gate		default:
4507c478bdstevel@tonic-gate			scfdie();
4517c478bdstevel@tonic-gate		}
4527c478bdstevel@tonic-gate	}
4537c478bdstevel@tonic-gate
4547c478bdstevel@tonic-gate	if (pg_get_single_val(g_pg, SCF_PROPERTY_STATE, SCF_TYPE_ASTRING,
4557c478bdstevel@tonic-gate	    (void *)instp->state, sizeof (instp->state), 0) != 0)
4567c478bdstevel@tonic-gate		return;
4577c478bdstevel@tonic-gate
4587c478bdstevel@tonic-gate	if (pg_get_single_val(g_pg, SCF_PROPERTY_NEXT_STATE, SCF_TYPE_ASTRING,
4597c478bdstevel@tonic-gate	    (void *)instp->next_state, sizeof (instp->next_state), 0) != 0)
4607c478bdstevel@tonic-gate		return;
4617c478bdstevel@tonic-gate
4627c478bdstevel@tonic-gate	if (pg_get_single_val(g_pg, SCF_PROPERTY_STATE_TIMESTAMP,
4637c478bdstevel@tonic-gate	    SCF_TYPE_TIME, &instp->stime, 0, 0) != 0)
4647c478bdstevel@tonic-gate		return;
4657c478bdstevel@tonic-gate
466eb1a346Truong Nguyen	/* restarter may not set aux_state, allow to continue in that case */
4677c478bdstevel@tonic-gate	if (pg_get_single_val(g_pg, SCF_PROPERTY_AUX_STATE, SCF_TYPE_ASTRING,
468eb1a346Truong Nguyen	    g_fmri, g_fmri_sz, 0) == 0)
469eb1a346Truong Nguyen		instp->aux_state = safe_strdup(g_fmri);
470eb1a346Truong Nguyen	else
471eb1a346Truong Nguyen		instp->aux_state = safe_strdup(AUX_STATE_INVALID);
4727c478bdstevel@tonic-gate
4737c478bdstevel@tonic-gate	(void) pg_get_single_val(g_pg, SCF_PROPERTY_START_METHOD_WAITSTATUS,
4747c478bdstevel@tonic-gate	    SCF_TYPE_INTEGER, &instp->start_method_waitstatus, 0, 0);
4757c478bdstevel@tonic-gate
476eb1a346Truong Nguyen	/* Get the optional auxiliary_fmri */
477eb1a346Truong Nguyen	if (pg_get_single_val(g_pg, SCF_PROPERTY_AUX_FMRI, SCF_TYPE_ASTRING,
478eb1a346Truong Nguyen	    g_fmri, g_fmri_sz, 0) == 0)
479eb1a346Truong Nguyen		instp->aux_fmri = safe_strdup(g_fmri);
480eb1a346Truong Nguyen
4817c478bdstevel@tonic-gate	if (scf_instance_get_pg(inst, SCF_PG_GENERAL_OVR, g_pg) == 0) {
4827c478bdstevel@tonic-gate		if (pg_get_single_val(g_pg, SCF_PROPERTY_ENABLED,
4837c478bdstevel@tonic-gate		    SCF_TYPE_BOOLEAN, &instp->enabled, 0, 0) == 0)
4848fff788John Levon			ovr_set = 1;
4858fff788John Levon		(void) pg_get_single_val(g_pg, SCF_PROPERTY_COMMENT,
4868fff788John Levon		    SCF_TYPE_ASTRING, instp->comment,
4878fff788John Levon		    sizeof (instp->comment), EMPTY_OK);
4887c478bdstevel@tonic-gate	} else {
4897c478bdstevel@tonic-gate		switch (scf_error()) {
4907c478bdstevel@tonic-gate		case SCF_ERROR_NOT_FOUND:
4917c478bdstevel@tonic-gate			break;
4927c478bdstevel@tonic-gate
4937c478bdstevel@tonic-gate		case SCF_ERROR_DELETED:
4947c478bdstevel@tonic-gate			return;
4957c478bdstevel@tonic-gate
4967c478bdstevel@tonic-gate		default:
4977c478bdstevel@tonic-gate			scfdie();
4987c478bdstevel@tonic-gate		}
4997c478bdstevel@tonic-gate	}
5007c478bdstevel@tonic-gate
5017c478bdstevel@tonic-gate	if (scf_instance_get_pg_composed(inst, NULL, SCF_PG_GENERAL, g_pg) !=
5027c478bdstevel@tonic-gate	    0) {
5037c478bdstevel@tonic-gate		switch (scf_error()) {
5047c478bdstevel@tonic-gate		case SCF_ERROR_DELETED:
5057c478bdstevel@tonic-gate		case SCF_ERROR_NOT_FOUND:
5067c478bdstevel@tonic-gate			return;
5077c478bdstevel@tonic-gate
5087c478bdstevel@tonic-gate		default:
5097c478bdstevel@tonic-gate			scfdie();
5107c478bdstevel@tonic-gate		}
5117c478bdstevel@tonic-gate	}
5127c478bdstevel@tonic-gate
5137c478bdstevel@tonic-gate	if (pg_get_single_val(g_pg, SCF_PROPERTY_ENABLED, SCF_TYPE_BOOLEAN,
5147c478bdstevel@tonic-gate	    &i, 0, 0) != 0)
5157c478bdstevel@tonic-gate		return;
5168fff788John Levon
5178fff788John Levon	if (ovr_set) {
5188fff788John Levon		instp->temporary = (instp->enabled != i);
5198fff788John Levon	} else {
5207c478bdstevel@tonic-gate		instp->enabled = i;
5217c478bdstevel@tonic-gate		instp->temporary = 0;
5228fff788John Levon	}
5238fff788John Levon
5248fff788John Levon	if (!instp->temporary) {
5258fff788John Levon		(void) pg_get_single_val(g_pg, SCF_PROPERTY_COMMENT,
5268fff788John Levon		    SCF_TYPE_ASTRING, instp->comment,
5278fff788John Levon		    sizeof (instp->comment), EMPTY_OK);
5287c478bdstevel@tonic-gate	}
5297c478bdstevel@tonic-gate
5307c478bdstevel@tonic-gate	if (pg_get_single_val(g_pg, SCF_PROPERTY_RESTARTER, SCF_TYPE_ASTRING,
5317c478bdstevel@tonic-gate	    g_fmri, g_fmri_sz, 0) == 0)
5327c478bdstevel@tonic-gate		instp->restarter = safe_strdup(g_fmri);
5337c478bdstevel@tonic-gate	else
5347c478bdstevel@tonic-gate		instp->restarter = SCF_SERVICE_STARTD;
5357c478bdstevel@tonic-gate
5367c478bdstevel@tonic-gate	if (strcmp(instp->state, SCF_STATE_STRING_OFFLINE) == 0 &&
5377c478bdstevel@tonic-gate	    load_dependencies(instp, inst) != 0)
5387c478bdstevel@tonic-gate		return;
5397c478bdstevel@tonic-gate
5407c478bdstevel@tonic-gate	uu_list_node_init(instp, &instp->node, insts);
5412e1a947Liane Praza	r = uu_list_append(svcp->instances, instp);
5422e1a947Liane Praza	assert(r == 0);
5437c478bdstevel@tonic-gate}
5447c478bdstevel@tonic-gate
5457c478bdstevel@tonic-gatestatic void
5467c478bdstevel@tonic-gateload_services(void)
5477c478bdstevel@tonic-gate{
5487c478bdstevel@tonic-gate	scf_iter_t *siter, *iiter;
5497c478bdstevel@tonic-gate	int r;
5507c478bdstevel@tonic-gate	char *svcname, *instname;
5517c478bdstevel@tonic-gate
5527c478bdstevel@tonic-gate	if ((siter = scf_iter_create(h)) == NULL ||
5537c478bdstevel@tonic-gate	    (iiter = scf_iter_create(h)) == NULL)
5547c478bdstevel@tonic-gate		scfdie();
5557c478bdstevel@tonic-gate
5567c478bdstevel@tonic-gate	svcname = safe_malloc(max_scf_name_length + 1);
5577c478bdstevel@tonic-gate	instname = safe_malloc(max_scf_name_length + 1);
5587c478bdstevel@tonic-gate
5597c478bdstevel@tonic-gate	if (scf_iter_scope_services(siter, g_local_scope) != 0)
5607c478bdstevel@tonic-gate		scfdie();
5617c478bdstevel@tonic-gate
5627c478bdstevel@tonic-gate	for (;;) {
5637c478bdstevel@tonic-gate		r = scf_iter_next_service(siter, g_svc);
5647c478bdstevel@tonic-gate		if (r == 0)
5657c478bdstevel@tonic-gate			break;
5667c478bdstevel@tonic-gate		if (r != 1)
5677c478bdstevel@tonic-gate			scfdie();
5687c478bdstevel@tonic-gate
5697c478bdstevel@tonic-gate		if (scf_service_get_name(g_svc, svcname,
5707c478bdstevel@tonic-gate		    max_scf_name_length + 1) < 0) {
5717c478bdstevel@tonic-gate			if (scf_error() != SCF_ERROR_DELETED)
5727c478bdstevel@tonic-gate				scfdie();
5737c478bdstevel@tonic-gate			continue;
5747c478bdstevel@tonic-gate		}
5757c478bdstevel@tonic-gate
5767c478bdstevel@tonic-gate		if (scf_iter_service_instances(iiter, g_svc) != 0) {
5777c478bdstevel@tonic-gate			if (scf_error() != SCF_ERROR_DELETED)
5787c478bdstevel@tonic-gate				scfdie();
5797c478bdstevel@tonic-gate			continue;
5807c478bdstevel@tonic-gate		}
5817c478bdstevel@tonic-gate
5827c478bdstevel@tonic-gate		for (;;) {
5837c478bdstevel@tonic-gate			r = scf_iter_next_instance(iiter, g_inst);
5847c478bdstevel@tonic-gate			if (r == 0)
5857c478bdstevel@tonic-gate				break;
5867c478bdstevel@tonic-gate			if (r != 1) {
5877c478bdstevel@tonic-gate				if (scf_error() != SCF_ERROR_DELETED)
5887c478bdstevel@tonic-gate					scfdie();
5897c478bdstevel@tonic-gate				break;
5907c478bdstevel@tonic-gate			}
5917c478bdstevel@tonic-gate
5927c478bdstevel@tonic-gate			if (scf_instance_get_name(g_inst, instname,
5937c478bdstevel@tonic-gate			    max_scf_name_length + 1) < 0) {
5947c478bdstevel@tonic-gate				if (scf_error() != SCF_ERROR_DELETED)
5957c478bdstevel@tonic-gate					scfdie();
5967c478bdstevel@tonic-gate				continue;
5977c478bdstevel@tonic-gate			}
5987c478bdstevel@tonic-gate
5997c478bdstevel@tonic-gate			add_instance(svcname, instname, g_inst);
6007c478bdstevel@tonic-gate		}
6017c478bdstevel@tonic-gate	}
6027c478bdstevel@tonic-gate
6037c478bdstevel@tonic-gate	free(svcname);
6047c478bdstevel@tonic-gate	free(instname);
6057c478bdstevel@tonic-gate	scf_iter_destroy(siter);
6067c478bdstevel@tonic-gate	scf_iter_destroy(iiter);
6077c478bdstevel@tonic-gate}
6087c478bdstevel@tonic-gate
6097c478bdstevel@tonic-gate/*
6107c478bdstevel@tonic-gate * Dependency analysis routines.
6117c478bdstevel@tonic-gate */
6127c478bdstevel@tonic-gate
6137c478bdstevel@tonic-gatestatic void
6147c478bdstevel@tonic-gateadd_svcptr(uu_list_t *lst, inst_t *svcp)
6157c478bdstevel@tonic-gate{
6167c478bdstevel@tonic-gate	struct svcptr *spp;
6177c478bdstevel@tonic-gate	uu_list_index_t idx;
6187c478bdstevel@tonic-gate	int r;
6197c478bdstevel@tonic-gate
6207c478bdstevel@tonic-gate	spp = safe_malloc(sizeof (*spp));
6217c478bdstevel@tonic-gate	spp->svcp = svcp;
6227c478bdstevel@tonic-gate	spp->next_hop = NULL;
6237c478bdstevel@tonic-gate
6247c478bdstevel@tonic-gate	if (uu_list_find(lst, spp, NULL, &idx) != NULL) {
6257c478bdstevel@tonic-gate		free(spp);
6267c478bdstevel@tonic-gate		return;
6277c478bdstevel@tonic-gate	}
6287c478bdstevel@tonic-gate
6297c478bdstevel@tonic-gate	uu_list_node_init(spp, &spp->node, svcptrs);
6307c478bdstevel@tonic-gate	r = uu_list_append(lst, spp);
6317c478bdstevel@tonic-gate	assert(r == 0);
6327c478bdstevel@tonic-gate}
6337c478bdstevel@tonic-gate
6347c478bdstevel@tonic-gatestatic int determine_causes(inst_t *, void *);
6357c478bdstevel@tonic-gate
6367c478bdstevel@tonic-gate/*
6377c478bdstevel@tonic-gate * Determine the causes of src and add them to the causes list of dst.
6387c478bdstevel@tonic-gate * Returns ELOOP if src is active, and 0 otherwise.
6397c478bdstevel@tonic-gate */
6407c478bdstevel@tonic-gatestatic int
6417c478bdstevel@tonic-gateadd_causes(inst_t *dst, inst_t *src)
6427c478bdstevel@tonic-gate{
6437c478bdstevel@tonic-gate	struct svcptr *spp, *copy;
6447c478bdstevel@tonic-gate	uu_list_index_t idx;
6457c478bdstevel@tonic-gate
6467c478bdstevel@tonic-gate	if (determine_causes(src, (void *)1) != UU_WALK_NEXT) {
6477c478bdstevel@tonic-gate		/* Dependency cycle. */
6487c478bdstevel@tonic-gate		(void) fprintf(stderr, "  svc:/%s:%s\n", dst->svcname,
6497c478bdstevel@tonic-gate		    dst->instname);
6507c478bdstevel@tonic-gate		return (ELOOP);
6517c478bdstevel@tonic-gate	}
6527c478bdstevel@tonic-gate
6537c478bdstevel@tonic-gate	add_svcptr(src->impact_dependents, dst);
6547c478bdstevel@tonic-gate
6557c478bdstevel@tonic-gate	for (spp = uu_list_first(src->causes);
6567c478bdstevel@tonic-gate	    spp != NULL;
6577c478bdstevel@tonic-gate	    spp = uu_list_next(src->causes, spp)) {
6587c478bdstevel@tonic-gate		if (uu_list_find(dst->causes, spp, NULL, &idx) != NULL)
6597c478bdstevel@tonic-gate			continue;
6607c478bdstevel@tonic-gate
6617c478bdstevel@tonic-gate		copy = safe_malloc(sizeof (*copy));
6627c478bdstevel@tonic-gate		copy->svcp = spp->svcp;
6637c478bdstevel@tonic-gate		copy->next_hop = src;
6647c478bdstevel@tonic-gate		uu_list_node_init(copy, &copy->node, svcptrs);
6657c478bdstevel@tonic-gate		uu_list_insert(dst->causes, copy, idx);
6667c478bdstevel@tonic-gate
6677c478bdstevel@tonic-gate		add_svcptr(g_causes, spp->svcp);
6687c478bdstevel@tonic-gate	}
6697c478bdstevel@tonic-gate
6707c478bdstevel@tonic-gate	return (0);
6717c478bdstevel@tonic-gate}
6727c478bdstevel@tonic-gate
6737c478bdstevel@tonic-gatestatic int
6747c478bdstevel@tonic-gateinst_running(inst_t *ip)
6757c478bdstevel@tonic-gate{
6767c478bdstevel@tonic-gate	return (strcmp(ip->state, SCF_STATE_STRING_ONLINE) == 0 ||
6777c478bdstevel@tonic-gate	    strcmp(ip->state, SCF_STATE_STRING_DEGRADED) == 0);
6787c478bdstevel@tonic-gate}
6797c478bdstevel@tonic-gate
6807c478bdstevel@tonic-gatestatic int
6817c478bdstevel@tonic-gateinst_running_or_maint(inst_t *ip)
6827c478bdstevel@tonic-gate{
6837c478bdstevel@tonic-gate	return (inst_running(ip) ||
6847c478bdstevel@tonic-gate	    strcmp(ip->state, SCF_STATE_STRING_MAINT) == 0);
6857c478bdstevel@tonic-gate}
6867c478bdstevel@tonic-gate
6877c478bdstevel@tonic-gatestatic svc_t *
6887c478bdstevel@tonic-gateget_svc(const char *sn)
6897c478bdstevel@tonic-gate{
6907c478bdstevel@tonic-gate	uint32_t h;
6917c478bdstevel@tonic-gate	svc_t *svcp;
6927c478bdstevel@tonic-gate
6937c478bdstevel@tonic-gate	h = hash_name(sn) & SVC_HASH_MASK;
6947c478bdstevel@tonic-gate
6957c478bdstevel@tonic-gate	for (svcp = services[h]; svcp != NULL; svcp = svcp->next) {
6967c478bdstevel@tonic-gate		if (strcmp(svcp->svcname, sn) == 0)
6977c478bdstevel@tonic-gate			break;
6987c478bdstevel@tonic-gate	}
6997c478bdstevel@tonic-gate
7007c478bdstevel@tonic-gate	return (svcp);
7017c478bdstevel@tonic-gate}
7027c478bdstevel@tonic-gate
7037c478bdstevel@tonic-gate/* ARGSUSED */
7047c478bdstevel@tonic-gatestatic inst_t *
7057c478bdstevel@tonic-gateget_inst(svc_t *svcp, const char *in)
7067c478bdstevel@tonic-gate{
7077c478bdstevel@tonic-gate	inst_t *instp;
7087c478bdstevel@tonic-gate
7097c478bdstevel@tonic-gate	for (instp = uu_list_first(svcp->instances);
7107c478bdstevel@tonic-gate	    instp != NULL;
7117c478bdstevel@tonic-gate	    instp = uu_list_next(svcp->instances, instp)) {
7127c478bdstevel@tonic-gate		if (strcmp(instp->instname, in) == 0)
7137c478bdstevel@tonic-gate			return (instp);
7147c478bdstevel@tonic-gate	}
7157c478bdstevel@tonic-gate
7167c478bdstevel@tonic-gate	return (NULL);
7177c478bdstevel@tonic-gate}
7187c478bdstevel@tonic-gate
7197c478bdstevel@tonic-gatestatic int
7207c478bdstevel@tonic-gateget_fmri(const char *fmri, svc_t **spp, inst_t **ipp)
7217c478bdstevel@tonic-gate{
7227c478bdstevel@tonic-gate	const char *sn, *in;
7237c478bdstevel@tonic-gate	svc_t *sp;
7247c478bdstevel@tonic-gate	inst_t *ip;
7257c478bdstevel@tonic-gate
7267c478bdstevel@tonic-gate	if (strlcpy(g_fmri, fmri, g_fmri_sz) >= g_fmri_sz)
7277c478bdstevel@tonic-gate		return (EINVAL);
7287c478bdstevel@tonic-gate
7297c478bdstevel@tonic-gate	if (scf_parse_svc_fmri(g_fmri, NULL, &sn, &in, NULL, NULL) != 0)
7307c478bdstevel@tonic-gate		return (EINVAL);
7317c478bdstevel@tonic-gate
7327c478bdstevel@tonic-gate	if (sn == NULL)
7337c478bdstevel@tonic-gate		return (EINVAL);
7347c478bdstevel@tonic-gate
7357c478bdstevel@tonic-gate	sp = get_svc(sn);
7367c478bdstevel@tonic-gate	if (sp == NULL)
7377c478bdstevel@tonic-gate		return (ENOENT);
7387c478bdstevel@tonic-gate
7397c478bdstevel@tonic-gate	if (in != NULL) {
7407c478bdstevel@tonic-gate		ip = get_inst(sp, in);
7417c478bdstevel@tonic-gate		if (ip == NULL)
7427c478bdstevel@tonic-gate			return (ENOENT);
7437c478bdstevel@tonic-gate	}
7447c478bdstevel@tonic-gate
7457c478bdstevel@tonic-gate	if (spp != NULL)
7467c478bdstevel@tonic-gate		*spp = sp;
7477c478bdstevel@tonic-gate	if (ipp != NULL)
7487c478bdstevel@tonic-gate		*ipp = ((in == NULL) ? NULL : ip);
7497c478bdstevel@tonic-gate
7507c478bdstevel@tonic-gate	return (0);
7517c478bdstevel@tonic-gate}
7527c478bdstevel@tonic-gate
7537c478bdstevel@tonic-gatestatic int
7547c478bdstevel@tonic-gateprocess_reqall(inst_t *svcp, struct dependency_group *dg)
7557c478bdstevel@tonic-gate{
7567c478bdstevel@tonic-gate	uu_list_walk_t *walk;
7577c478bdstevel@tonic-gate	struct dependency *d;
7587c478bdstevel@tonic-gate	int r, svcrunning;
7597c478bdstevel@tonic-gate	svc_t *sp;
7607c478bdstevel@tonic-gate	inst_t *ip;
7617c478bdstevel@tonic-gate
7627c478bdstevel@tonic-gate	walk = uu_list_walk_start(dg->entities, UU_WALK_ROBUST);
7637c478bdstevel@tonic-gate	if (walk == NULL)
7647c478bdstevel@tonic-gate		uu_die(emsg_nomem);
7657c478bdstevel@tonic-gate
7667c478bdstevel@tonic-gate	while ((d = uu_list_walk_next(walk)) != NULL) {
7677c478bdstevel@tonic-gate		r = get_fmri(d->fmri, &sp, &ip);
7687c478bdstevel@tonic-gate		switch (r) {
7697c478bdstevel@tonic-gate		case EINVAL:
7707c478bdstevel@tonic-gate			/* LINTED */
7717c478bdstevel@tonic-gate			(void) fprintf(stderr, emsg_invalid_dep, svcp->svcname,
7727c478bdstevel@tonic-gate			    svcp->instname, d->fmri);
7737c478bdstevel@tonic-gate			continue;
7747c478bdstevel@tonic-gate
7757c478bdstevel@tonic-gate		case ENOENT:
7767c478bdstevel@tonic-gate			uu_list_remove(dg->entities, d);
7777c478bdstevel@tonic-gate			r = uu_list_append(svcp->baddeps, d);
7787c478bdstevel@tonic-gate			assert(r == 0);
7797c478bdstevel@tonic-gate			continue;
7807c478bdstevel@tonic-gate
7817c478bdstevel@tonic-gate		case 0:
7827c478bdstevel@tonic-gate			break;
7837c478bdstevel@tonic-gate
7847c478bdstevel@tonic-gate		default:
7857c478bdstevel@tonic-gate			bad_error("get_fmri", r);
7867c478bdstevel@tonic-gate		}
7877c478bdstevel@tonic-gate
7887c478bdstevel@tonic-gate		if (ip != NULL) {
7897c478bdstevel@tonic-gate			if (inst_running(ip))
7907c478bdstevel@tonic-gate				continue;
7917c478bdstevel@tonic-gate			r = add_causes(svcp, ip);
7927c478bdstevel@tonic-gate			if (r != 0) {
7937c478bdstevel@tonic-gate				assert(r == ELOOP);
7947c478bdstevel@tonic-gate				return (r);
7957c478bdstevel@tonic-gate			}
7967c478bdstevel@tonic-gate			continue;
7977c478bdstevel@tonic-gate		}
7987c478bdstevel@tonic-gate
7997c478bdstevel@tonic-gate		svcrunning = 0;
8007c478bdstevel@tonic-gate
8017c478bdstevel@tonic-gate		for (ip = uu_list_first(sp->instances);
8027c478bdstevel@tonic-gate		    ip != NULL;
8037c478bdstevel@tonic-gate		    ip = uu_list_next(sp->instances, ip)) {
8047c478bdstevel@tonic-gate			if (inst_running(ip))
8057c478bdstevel@tonic-gate				svcrunning = 1;
8067c478bdstevel@tonic-gate		}
8077c478bdstevel@tonic-gate
8087c478bdstevel@tonic-gate		if (!svcrunning) {
8097c478bdstevel@tonic-gate			for (ip = uu_list_first(sp->instances);
8107c478bdstevel@tonic-gate			    ip != NULL;
8117c478bdstevel@tonic-gate			    ip = uu_list_next(sp->instances, ip)) {
8127c478bdstevel@tonic-gate				r = add_causes(svcp, ip);
8137c478bdstevel@tonic-gate				if (r != 0) {
8147c478bdstevel@tonic-gate					assert(r == ELOOP);
8157c478bdstevel@tonic-gate					uu_list_walk_end(walk);
8167c478bdstevel@tonic-gate					return (r);
8177c478bdstevel@tonic-gate				}
8187c478bdstevel@tonic-gate			}
8197c478bdstevel@tonic-gate		}
8207c478bdstevel@tonic-gate	}
8217c478bdstevel@tonic-gate
8227c478bdstevel@tonic-gate	uu_list_walk_end(walk);
8237c478bdstevel@tonic-gate	return (0);
8247c478bdstevel@tonic-gate}
8257c478bdstevel@tonic-gate
8267c478bdstevel@tonic-gatestatic int
8277c478bdstevel@tonic-gateprocess_reqany(inst_t *svcp, struct dependency_group *dg)
8287c478bdstevel@tonic-gate{
8297c478bdstevel@tonic-gate	svc_t *sp;
8307c478bdstevel@tonic-gate	inst_t *ip;
8317c478bdstevel@tonic-gate	struct dependency *d;
8327c478bdstevel@tonic-gate	int r;
8337c478bdstevel@tonic-gate	uu_list_walk_t *walk;
8347c478bdstevel@tonic-gate
8357c478bdstevel@tonic-gate	for (d = uu_list_first(dg->entities);
8367c478bdstevel@tonic-gate	    d != NULL;
8377c478bdstevel@tonic-gate	    d = uu_list_next(dg->entities, d)) {
8387c478bdstevel@tonic-gate		r = get_fmri(d->fmri, &sp, &ip);
8397c478bdstevel@tonic-gate		switch (r) {
8407c478bdstevel@tonic-gate		case 0:
8417c478bdstevel@tonic-gate			break;
8427c478bdstevel@tonic-gate
8437c478bdstevel@tonic-gate		case EINVAL:
8447c478bdstevel@tonic-gate			/* LINTED */
8457c478bdstevel@tonic-gate			(void) fprintf(stderr, emsg_invalid_dep, svcp->svcname,
8467c478bdstevel@tonic-gate			    svcp->instname, d->fmri);
8477c478bdstevel@tonic-gate			continue;
8487c478bdstevel@tonic-gate
8497c478bdstevel@tonic-gate		case ENOENT:
8507c478bdstevel@tonic-gate			continue;
8517c478bdstevel@tonic-gate
8527c478bdstevel@tonic-gate		default:
8537c478bdstevel@tonic-gate			bad_error("eval_svc_dep", r);
8547c478bdstevel@tonic-gate		}
8557c478bdstevel@tonic-gate
8567c478bdstevel@tonic-gate		if (ip != NULL) {
8577c478bdstevel@tonic-gate			if (inst_running(ip))
8587c478bdstevel@tonic-gate				return (0);
8597c478bdstevel@tonic-gate			continue;
8607c478bdstevel@tonic-gate		}
8617c478bdstevel@tonic-gate
8627c478bdstevel@tonic-gate		for (ip = uu_list_first(sp->instances);
8637c478bdstevel@tonic-gate		    ip != NULL;
8647c478bdstevel@tonic-gate		    ip = uu_list_next(sp->instances, ip)) {
8657c478bdstevel@tonic-gate			if (inst_running(ip))
8667c478bdstevel@tonic-gate				return (0);
8677c478bdstevel@tonic-gate		}
8687c478bdstevel@tonic-gate	}
8697c478bdstevel@tonic-gate
8707c478bdstevel@tonic-gate	/*
8717c478bdstevel@tonic-gate	 * The dependency group is not satisfied.  Add all unsatisfied members
8727c478bdstevel@tonic-gate	 * to the cause list.
8737c478bdstevel@tonic-gate	 */
8747c478bdstevel@tonic-gate
8757c478bdstevel@tonic-gate	walk = uu_list_walk_start(dg->entities, UU_WALK_ROBUST);
8767c478bdstevel@tonic-gate	if (walk == NULL)
8777c478bdstevel@tonic-gate		uu_die(emsg_nomem);
8787c478bdstevel@tonic-gate
8797c478bdstevel@tonic-gate	while ((d = uu_list_walk_next(walk)) != NULL) {
8807c478bdstevel@tonic-gate		r = get_fmri(d->fmri, &sp, &ip);
8817c478bdstevel@tonic-gate		switch (r) {
8827c478bdstevel@tonic-gate		case 0:
8837c478bdstevel@tonic-gate			break;
8847c478bdstevel@tonic-gate
8857c478bdstevel@tonic-gate		case ENOENT:
8867c478bdstevel@tonic-gate			uu_list_remove(dg->entities, d);
8877c478bdstevel@tonic-gate			r = uu_list_append(svcp->baddeps, d);
8887c478bdstevel@tonic-gate			assert(r == 0);
8897c478bdstevel@tonic-gate			continue;
8907c478bdstevel@tonic-gate
8917c478bdstevel@tonic-gate		case EINVAL:
8927c478bdstevel@tonic-gate			/* Should have caught above. */
8937c478bdstevel@tonic-gate		default:
8947c478bdstevel@tonic-gate			bad_error("eval_svc_dep", r);
8957c478bdstevel@tonic-gate		}
8967c478bdstevel@tonic-gate
8977c478bdstevel@tonic-gate		if (ip != NULL) {
8987c478bdstevel@tonic-gate			if (inst_running(ip))
8997c478bdstevel@tonic-gate				continue;
9007c478bdstevel@tonic-gate			r = add_causes(svcp, ip);
9017c478bdstevel@tonic-gate			if (r != 0) {
9027c478bdstevel@tonic-gate				assert(r == ELOOP);
9037c478bdstevel@tonic-gate				return (r);
9047c478bdstevel@tonic-gate			}
9057c478bdstevel@tonic-gate			continue;
9067c478bdstevel@tonic-gate		}
9077c478bdstevel@tonic-gate
9087c478bdstevel@tonic-gate		for (ip = uu_list_first(sp->instances);
9097c478bdstevel@tonic-gate		    ip != NULL;
9107c478bdstevel@tonic-gate		    ip = uu_list_next(sp->instances, ip)) {
9117c478bdstevel@tonic-gate			if (inst_running(ip))
9127c478bdstevel@tonic-gate				continue;
9137c478bdstevel@tonic-gate			r = add_causes(svcp, ip);
9147c478bdstevel@tonic-gate			if (r != 0) {
9157c478bdstevel@tonic-gate				assert(r == ELOOP);
9167c478bdstevel@tonic-gate				return (r);
9177c478bdstevel@tonic-gate			}
9187c478bdstevel@tonic-gate		}
9197c478bdstevel@tonic-gate	}
9207c478bdstevel@tonic-gate
9217c478bdstevel@tonic-gate	return (0);
9227c478bdstevel@tonic-gate}
9237c478bdstevel@tonic-gate
9247c478bdstevel@tonic-gatestatic int
9257c478bdstevel@tonic-gateprocess_optall(inst_t *svcp, struct dependency_group *dg)
9267c478bdstevel@tonic-gate{
9277c478bdstevel@tonic-gate	uu_list_walk_t *walk;
9287c478bdstevel@tonic-gate	struct dependency *d;
9297c478bdstevel@tonic-gate	int r;
9307c478bdstevel@tonic-gate	inst_t *ip;
9317c478bdstevel@tonic-gate	svc_t *sp;
9327c478bdstevel@tonic-gate
9337c478bdstevel@tonic-gate	walk = uu_list_walk_start(dg->entities, UU_WALK_ROBUST);
9347c478bdstevel@tonic-gate	if (walk == NULL)
9357c478bdstevel@tonic-gate		uu_die(emsg_nomem);
9367c478bdstevel@tonic-gate
9377c478bdstevel@tonic-gate	while ((d = uu_list_walk_next(walk)) != NULL) {
9387c478bdstevel@tonic-gate		r = get_fmri(d->fmri, &sp, &ip);
9397c478bdstevel@tonic-gate
9407c478bdstevel@tonic-gate		switch (r) {
9417c478bdstevel@tonic-gate		case 0:
9427c478bdstevel@tonic-gate			break;
9437c478bdstevel@tonic-gate
9447c478bdstevel@tonic-gate		case EINVAL:
9457c478bdstevel@tonic-gate			/* LINTED */
9467c478bdstevel@tonic-gate			(void) fprintf(stderr, emsg_invalid_dep, svcp->svcname,
9477c478bdstevel@tonic-gate			    svcp->instname, d->fmri);
9487c478bdstevel@tonic-gate			continue;
9497c478bdstevel@tonic-gate
9507c478bdstevel@tonic-gate		case ENOENT:
9517c478bdstevel@tonic-gate			continue;
9527c478bdstevel@tonic-gate
9537c478bdstevel@tonic-gate		default:
9547c478bdstevel@tonic-gate			bad_error("get_fmri", r);
9557c478bdstevel@tonic-gate		}
9567c478bdstevel@tonic-gate
9577c478bdstevel@tonic-gate		if (ip != NULL) {
9582e1a947Liane Praza			if ((ip->enabled != 0) && !inst_running_or_maint(ip)) {
9597c478bdstevel@tonic-gate				r = add_causes(svcp, ip);
9607c478bdstevel@tonic-gate				if (r != 0) {
9617c478bdstevel@tonic-gate					assert(r == ELOOP);
9627c478bdstevel@tonic-gate					uu_list_walk_end(walk);
9637c478bdstevel@tonic-gate					return (r);
9647c478bdstevel@tonic-gate				}
9657c478bdstevel@tonic-gate			}
9667c478bdstevel@tonic-gate			continue;
9677c478bdstevel@tonic-gate		}
9687c478bdstevel@tonic-gate
9697c478bdstevel@tonic-gate		for (ip = uu_list_first(sp->instances);
9707c478bdstevel@tonic-gate		    ip != NULL;
9717c478bdstevel@tonic-gate		    ip = uu_list_next(sp->instances, ip)) {
9722e1a947Liane Praza			if ((ip->enabled != 0) && !inst_running_or_maint(ip)) {
9737c478bdstevel@tonic-gate				r = add_causes(svcp, ip);
9747c478bdstevel@tonic-gate				if (r != 0) {
9757c478bdstevel@tonic-gate					assert(r == ELOOP);
9767c478bdstevel@tonic-gate					uu_list_walk_end(walk);
9777c478bdstevel@tonic-gate					return (r);
9787c478bdstevel@tonic-gate				}
9797c478bdstevel@tonic-gate			}
9807c478bdstevel@tonic-gate		}
9817c478bdstevel@tonic-gate	}
9827c478bdstevel@tonic-gate
9837c478bdstevel@tonic-gate	uu_list_walk_end(walk);
9847c478bdstevel@tonic-gate	return (0);
9857c478bdstevel@tonic-gate}
9867c478bdstevel@tonic-gate
9877c478bdstevel@tonic-gatestatic int
9887c478bdstevel@tonic-gateprocess_excall(inst_t *svcp, struct dependency_group *dg)
9897c478bdstevel@tonic-gate{
9907c478bdstevel@tonic-gate	struct dependency *d;
9917c478bdstevel@tonic-gate	int r;
9927c478bdstevel@tonic-gate	svc_t *sp;
9937c478bdstevel@tonic-gate	inst_t *ip;
9947c478bdstevel@tonic-gate
9957c478bdstevel@tonic-gate	for (d = uu_list_first(dg->entities);
9967c478bdstevel@tonic-gate	    d != NULL;
9977c478bdstevel@tonic-gate	    d = uu_list_next(dg->entities, d)) {
9987c478bdstevel@tonic-gate		r = get_fmri(d->fmri, &sp, &ip);
9997c478bdstevel@tonic-gate
10007c478bdstevel@tonic-gate		switch (r) {
10017c478bdstevel@tonic-gate		case 0:
10027c478bdstevel@tonic-gate			break;
10037c478bdstevel@tonic-gate
10047c478bdstevel@tonic-gate		case EINVAL:
10057c478bdstevel@tonic-gate			/* LINTED */
10067c478bdstevel@tonic-gate			(void) fprintf(stderr, emsg_invalid_dep, svcp->svcname,
10077c478bdstevel@tonic-gate			    svcp->instname, d->fmri);
10087c478bdstevel@tonic-gate			continue;
10097c478bdstevel@tonic-gate
10107c478bdstevel@tonic-gate		case ENOENT:
10117c478bdstevel@tonic-gate			continue;
10127c478bdstevel@tonic-gate
10137c478bdstevel@tonic-gate		default:
10147c478bdstevel@tonic-gate			bad_error("eval_svc_dep", r);
10157c478bdstevel@tonic-gate		}
10167c478bdstevel@tonic-gate
10177c478bdstevel@tonic-gate		if (ip != NULL) {
10187c478bdstevel@tonic-gate			if (inst_running(ip)) {
10197c478bdstevel@tonic-gate				r = add_causes(svcp, ip);
10207c478bdstevel@tonic-gate				if (r != 0) {
10217c478bdstevel@tonic-gate					assert(r == ELOOP);
10227c478bdstevel@tonic-gate					return (r);
10237c478bdstevel@tonic-gate				}
10247c478bdstevel@tonic-gate			}
10257c478bdstevel@tonic-gate			continue;
10267c478bdstevel@tonic-gate		}
10277c478bdstevel@tonic-gate
10287c478bdstevel@tonic-gate		for (ip = uu_list_first(sp->instances);
10297c478bdstevel@tonic-gate		    ip != NULL;
10307c478bdstevel@tonic-gate		    ip = uu_list_next(sp->instances, ip)) {
10317c478bdstevel@tonic-gate			if (inst_running(ip)) {
10327c478bdstevel@tonic-gate				r = add_causes(svcp, ip);
10337c478bdstevel@tonic-gate				if (r != 0) {
10347c478bdstevel@tonic-gate					assert(r == ELOOP);
10357c478bdstevel@tonic-gate					return (r);
10367c478bdstevel@tonic-gate				}
10377c478bdstevel@tonic-gate			}
10387c478bdstevel@tonic-gate		}
10397c478bdstevel@tonic-gate	}
10407c478bdstevel@tonic-gate
10417c478bdstevel@tonic-gate	return (0);
10427c478bdstevel@tonic-gate}
10437c478bdstevel@tonic-gate
10447c478bdstevel@tonic-gatestatic int
10457c478bdstevel@tonic-gateprocess_svc_dg(inst_t *svcp, struct dependency_group *dg)
10467c478bdstevel@tonic-gate{
10477c478bdstevel@tonic-gate	switch (dg->grouping) {
10487c478bdstevel@tonic-gate	case DGG_REQALL:
10497c478bdstevel@tonic-gate		return (process_reqall(svcp, dg));
10507c478bdstevel@tonic-gate
10517c478bdstevel@tonic-gate	case DGG_REQANY:
10527c478bdstevel@tonic-gate		return (process_reqany(svcp, dg));
10537c478bdstevel@tonic-gate
10547c478bdstevel@tonic-gate	case DGG_OPTALL:
10557c478bdstevel@tonic-gate		return (process_optall(svcp, dg));
10567c478bdstevel@tonic-gate
10577c478bdstevel@tonic-gate	case DGG_EXCALL:
10587c478bdstevel@tonic-gate		return (process_excall(svcp, dg));
10597c478bdstevel@tonic-gate
10607c478bdstevel@tonic-gate	default:
10617c478bdstevel@tonic-gate#ifndef NDEBUG
10627c478bdstevel@tonic-gate		(void) fprintf(stderr,
10637c478bdstevel@tonic-gate		    "%s:%d: Unknown dependency grouping %d.\n", __FILE__,
10647c478bdstevel@tonic-gate		    __LINE__, dg->grouping);
10657c478bdstevel@tonic-gate#endif
10667c478bdstevel@tonic-gate		abort();
10677c478bdstevel@tonic-gate		/* NOTREACHED */
10687c478bdstevel@tonic-gate	}
10697c478bdstevel@tonic-gate}
10707c478bdstevel@tonic-gate
10717c478bdstevel@tonic-gate/*
10727c478bdstevel@tonic-gate * Returns
10737c478bdstevel@tonic-gate *   EINVAL - fmri is not a valid FMRI
10747c478bdstevel@tonic-gate *   0 - the file indicated by fmri is missing
10757c478bdstevel@tonic-gate *   1 - the file indicated by fmri is present
10767c478bdstevel@tonic-gate */
10777c478bdstevel@tonic-gatestatic int
10787c478bdstevel@tonic-gateeval_file_dep(const char *fmri)
10797c478bdstevel@tonic-gate{
10807c478bdstevel@tonic-gate	const char *path;
10817c478bdstevel@tonic-gate	struct stat st;
10827c478bdstevel@tonic-gate
10837c478bdstevel@tonic-gate	if (strncmp(fmri, "file:", sizeof ("file:") - 1) != 0)
10847c478bdstevel@tonic-gate		return (EINVAL);
10857c478bdstevel@tonic-gate
10867c478bdstevel@tonic-gate	path = fmri + (sizeof ("file:") - 1);
10877c478bdstevel@tonic-gate
10887c478bdstevel@tonic-gate	if (path[0] != '/')
10897c478bdstevel@tonic-gate		return (EINVAL);
10907c478bdstevel@tonic-gate
10917c478bdstevel@tonic-gate	if (path[1] == '/') {
10927c478bdstevel@tonic-gate		path += 2;
10937c478bdstevel@tonic-gate		if (strncmp(path, "localhost/", sizeof ("localhost/") - 1) == 0)
10947c478bdstevel@tonic-gate			path += sizeof ("localhost") - 1;
10957c478bdstevel@tonic-gate		else if (path[0] != '/')
10967c478bdstevel@tonic-gate			return (EINVAL);
10977c478bdstevel@tonic-gate	}
10987c478bdstevel@tonic-gate
10997c478bdstevel@tonic-gate	return (stat(path, &st) == 0 ? 1 : 0);
11007c478bdstevel@tonic-gate}
11017c478bdstevel@tonic-gate
11027c478bdstevel@tonic-gatestatic void
11037c478bdstevel@tonic-gateprocess_file_dg(inst_t *svcp, struct dependency_group *dg)
11047c478bdstevel@tonic-gate{
11057c478bdstevel@tonic-gate	uu_list_walk_t *walk;
11067c478bdstevel@tonic-gate	struct dependency *d, **deps;
11077c478bdstevel@tonic-gate	int r, i = 0, any_satisfied = 0;
11087c478bdstevel@tonic-gate
11097c478bdstevel@tonic-gate	if (dg->grouping == DGG_REQANY) {
11107c478bdstevel@tonic-gate		deps = calloc(uu_list_numnodes(dg->entities), sizeof (*deps));
11117c478bdstevel@tonic-gate		if (deps == NULL)
11127c478bdstevel@tonic-gate			uu_die(emsg_nomem);
11137c478bdstevel@tonic-gate	}
11147c478bdstevel@tonic-gate
11157c478bdstevel@tonic-gate	walk = uu_list_walk_start(dg->entities, UU_WALK_ROBUST);
11167c478bdstevel@tonic-gate	if (walk == NULL)
11177c478bdstevel@tonic-gate		uu_die(emsg_nomem);
11187c478bdstevel@tonic-gate
11197c478bdstevel@tonic-gate	while ((d = uu_list_walk_next(walk)) != NULL) {
11207c478bdstevel@tonic-gate		r = eval_file_dep(d->fmri);
11217c478bdstevel@tonic-gate		if (r == EINVAL) {
11227c478bdstevel@tonic-gate			/* LINTED */
11237c478bdstevel@tonic-gate			(void) fprintf(stderr, emsg_invalid_dep, svcp->svcname,
11247c478bdstevel@tonic-gate			    svcp->instname, d->fmri);
11257c478bdstevel@tonic-gate			continue;
11267c478bdstevel@tonic-gate		}
11277c478bdstevel@tonic-gate
11287c478bdstevel@tonic-gate		assert(r == 0 || r == 1);
11297c478bdstevel@tonic-gate
11307c478bdstevel@tonic-gate		switch (dg->grouping) {
11317c478bdstevel@tonic-gate		case DGG_REQALL:
11327c478bdstevel@tonic-gate		case DGG_OPTALL:
11337c478bdstevel@tonic-gate			if (r == 0) {
11347c478bdstevel@tonic-gate				uu_list_remove(dg->entities, d);
11357c478bdstevel@tonic-gate				r = uu_list_append(svcp->baddeps, d);
11367c478bdstevel@tonic-gate				assert(r == 0);
11377c478bdstevel@tonic-gate			}
11387c478bdstevel@tonic-gate			break;
11397c478bdstevel@tonic-gate
11407c478bdstevel@tonic-gate		case DGG_REQANY:
11417c478bdstevel@tonic-gate			if (r == 1)
11427c478bdstevel@tonic-gate				any_satisfied = 1;
11437c478bdstevel@tonic-gate			else
11447c478bdstevel@tonic-gate				deps[i++] = d;
11457c478bdstevel@tonic-gate			break;
11467c478bdstevel@tonic-gate
11477c478bdstevel@tonic-gate		case DGG_EXCALL:
11487c478bdstevel@tonic-gate			if (r == 1) {
11497c478bdstevel@tonic-gate				uu_list_remove(dg->entities, d);
11507c478bdstevel@tonic-gate				r = uu_list_append(svcp->baddeps, d);
11517c478bdstevel@tonic-gate				assert(r == 0);
11527c478bdstevel@tonic-gate			}
11537c478bdstevel@tonic-gate			break;
11547c478bdstevel@tonic-gate
11557c478bdstevel@tonic-gate		default:
11567c478bdstevel@tonic-gate#ifndef NDEBUG
11577c478bdstevel@tonic-gate			(void) fprintf(stderr, "%s:%d: Unknown grouping %d.\n",
11587c478bdstevel@tonic-gate			    __FILE__, __LINE__, dg->grouping);
11597c478bdstevel@tonic-gate#endif
11607c478bdstevel@tonic-gate			abort();
11617c478bdstevel@tonic-gate		}
11627c478bdstevel@tonic-gate	}
11637c478bdstevel@tonic-gate
11647c478bdstevel@tonic-gate	uu_list_walk_end(walk);
11657c478bdstevel@tonic-gate
11667c478bdstevel@tonic-gate	if (dg->grouping != DGG_REQANY)
11677c478bdstevel@tonic-gate		return;
11687c478bdstevel@tonic-gate
11697c478bdstevel@tonic-gate	if (!any_satisfied) {
1170d87bb7drm		while (--i >= 0) {
11717c478bdstevel@tonic-gate			uu_list_remove(dg->entities, deps[i]);
11727c478bdstevel@tonic-gate			r = uu_list_append(svcp->baddeps, deps[i]);
11737c478bdstevel@tonic-gate			assert(r == 0);
11747c478bdstevel@tonic-gate		}
11757c478bdstevel@tonic-gate	}
11767c478bdstevel@tonic-gate
11777c478bdstevel@tonic-gate	free(deps);
11787c478bdstevel@tonic-gate}
11797c478bdstevel@tonic-gate
11807c478bdstevel@tonic-gate/*
11817c478bdstevel@tonic-gate * Populate the causes list of svcp.  This function should not return with
11827c478bdstevel@tonic-gate * causes empty.
11837c478bdstevel@tonic-gate */
11847c478bdstevel@tonic-gatestatic int
11857c478bdstevel@tonic-gatedetermine_causes(inst_t *svcp, void *canfailp)
11867c478bdstevel@tonic-gate{
11877c478bdstevel@tonic-gate	struct dependency_group *dg;
11887c478bdstevel@tonic-gate	int r;
11897c478bdstevel@tonic-gate
11907c478bdstevel@tonic-gate	if (svcp->active) {
11917c478bdstevel@tonic-gate		(void) fprintf(stderr, gettext("Dependency cycle detected:\n"
11927c478bdstevel@tonic-gate		    "  svc:/%s:%s\n"), svcp->svcname, svcp->instname);
11937c478bdstevel@tonic-gate		return ((int)canfailp != 0 ? UU_WALK_ERROR : UU_WALK_NEXT);
11947c478bdstevel@tonic-gate	}
11957c478bdstevel@tonic-gate
11967c478bdstevel@tonic-gate	if (svcp->causes != NULL)
11977c478bdstevel@tonic-gate		return (UU_WALK_NEXT);
11987c478bdstevel@tonic-gate
11997c478bdstevel@tonic-gate	svcp->causes = uu_list_create(svcptrs, svcp, UU_LIST_DEBUG);
12007c478bdstevel@tonic-gate	svcp->baddeps = uu_list_create(deps, svcp, UU_LIST_DEBUG);
12017c478bdstevel@tonic-gate	if (svcp->causes == NULL || svcp->baddeps == NULL)
12027c478bdstevel@tonic-gate		uu_die(emsg_nomem);
12037c478bdstevel@tonic-gate
12047c478bdstevel@tonic-gate	if (inst_running(svcp) ||
12057c478bdstevel@tonic-gate	    strcmp(svcp->state, SCF_STATE_STRING_UNINIT) == 0) {
12067c478bdstevel@tonic-gate		/*
12077c478bdstevel@tonic-gate		 * If we're running, add a self-pointer in case we're
12087c478bdstevel@tonic-gate		 * excluding another service.
12097c478bdstevel@tonic-gate		 */
12107c478bdstevel@tonic-gate		add_svcptr(svcp->causes, svcp);
12117c478bdstevel@tonic-gate		return (UU_WALK_NEXT);
12127c478bdstevel@tonic-gate	}
12137c478bdstevel@tonic-gate
12147c478bdstevel@tonic-gate	if (strcmp(svcp->state, SCF_STATE_STRING_MAINT) == 0) {
12157c478bdstevel@tonic-gate		add_svcptr(svcp->causes, svcp);
12167c478bdstevel@tonic-gate		add_svcptr(g_causes, svcp);
12177c478bdstevel@tonic-gate		return (UU_WALK_NEXT);
12187c478bdstevel@tonic-gate	}
12197c478bdstevel@tonic-gate
12207c478bdstevel@tonic-gate	if (strcmp(svcp->state, SCF_STATE_STRING_DISABLED) == 0) {
12217c478bdstevel@tonic-gate		add_svcptr(svcp->causes, svcp);
12222e1a947Liane Praza		if (svcp->enabled != 0)
12237c478bdstevel@tonic-gate			add_svcptr(g_causes, svcp);
12247c478bdstevel@tonic-gate
12257c478bdstevel@tonic-gate		return (UU_WALK_NEXT);
12267c478bdstevel@tonic-gate	}
12277c478bdstevel@tonic-gate
12287c478bdstevel@tonic-gate	if (strcmp(svcp->state, SCF_STATE_STRING_OFFLINE) != 0) {
12297c478bdstevel@tonic-gate		(void) fprintf(stderr,
12307c478bdstevel@tonic-gate		    gettext("svc:/%s:%s has invalid state \"%s\".\n"),
12317c478bdstevel@tonic-gate		    svcp->svcname, svcp->instname, svcp->state);
12327c478bdstevel@tonic-gate		add_svcptr(svcp->causes, svcp);
12337c478bdstevel@tonic-gate		add_svcptr(g_causes, svcp);
12347c478bdstevel@tonic-gate		return (UU_WALK_NEXT);
12357c478bdstevel@tonic-gate	}
12367c478bdstevel@tonic-gate
12377c478bdstevel@tonic-gate	if (strcmp(svcp->next_state, SCF_STATE_STRING_NONE) != 0) {
12387c478bdstevel@tonic-gate		add_svcptr(svcp->causes, svcp);
12397c478bdstevel@tonic-gate		add_svcptr(g_causes, svcp);
12407c478bdstevel@tonic-gate		return (UU_WALK_NEXT);
12417c478bdstevel@tonic-gate	}
12427c478bdstevel@tonic-gate
12437c478bdstevel@tonic-gate	svcp->active = 1;
12447c478bdstevel@tonic-gate
12457c478bdstevel@tonic-gate	/*
12467c478bdstevel@tonic-gate	 * Dependency analysis can add elements to our baddeps list (absent
12477c478bdstevel@tonic-gate	 * dependency, unsatisfied file dependency), or to our cause list
12487c478bdstevel@tonic-gate	 * (unsatisfied dependency).
12497c478bdstevel@tonic-gate	 */
12507c478bdstevel@tonic-gate	for (dg = uu_list_first(svcp->dependencies);
12517c478bdstevel@tonic-gate	    dg != NULL;
12527c478bdstevel@tonic-gate	    dg = uu_list_next(svcp->dependencies, dg)) {
12537c478bdstevel@tonic-gate		if (strcmp(dg->type, "path") == 0) {
12547c478bdstevel@tonic-gate			process_file_dg(svcp, dg);
12557c478bdstevel@tonic-gate		} else if (strcmp(dg->type, "service") == 0) {
12567c478bdstevel@tonic-gate			int r;
12577c478bdstevel@tonic-gate
12587c478bdstevel@tonic-gate			r = process_svc_dg(svcp, dg);
12597c478bdstevel@tonic-gate			if (r != 0) {
12607c478bdstevel@tonic-gate				assert(r == ELOOP);
12617c478bdstevel@tonic-gate				svcp->active = 0;
12627c478bdstevel@tonic-gate				return ((int)canfailp != 0 ?
12637c478bdstevel@tonic-gate				    UU_WALK_ERROR : UU_WALK_NEXT);
12647c478bdstevel@tonic-gate			}
12657c478bdstevel@tonic-gate		} else {
12667c478bdstevel@tonic-gate			(void) fprintf(stderr, gettext("svc:/%s:%s has "
12677c478bdstevel@tonic-gate			    "dependency group with invalid type \"%s\".\n"),
12687c478bdstevel@tonic-gate			    svcp->svcname, svcp->instname, dg->type);
12697c478bdstevel@tonic-gate		}
12707c478bdstevel@tonic-gate	}
12717c478bdstevel@tonic-gate
12727c478bdstevel@tonic-gate	if (uu_list_numnodes(svcp->causes) == 0) {
12737c478bdstevel@tonic-gate		if (uu_list_numnodes(svcp->baddeps) > 0) {
12747c478bdstevel@tonic-gate			add_svcptr(g_causes, svcp);
12757c478bdstevel@tonic-gate			add_svcptr(svcp->causes, svcp);
12767c478bdstevel@tonic-gate		} else {
12777c478bdstevel@tonic-gate			inst_t *restarter;
12787c478bdstevel@tonic-gate
12797c478bdstevel@tonic-gate			r = get_fmri(svcp->restarter, NULL, &restarter);
12807c478bdstevel@tonic-gate			if (r == 0 && !inst_running(restarter)) {
12817c478bdstevel@tonic-gate				r = add_causes(svcp, restarter);
12827c478bdstevel@tonic-gate				if (r != 0) {
12837c478bdstevel@tonic-gate					assert(r == ELOOP);
12847c478bdstevel@tonic-gate					svcp->active = 0;
12857c478bdstevel@tonic-gate					return ((int)canfailp != 0 ?
12867c478bdstevel@tonic-gate					    UU_WALK_ERROR : UU_WALK_NEXT);
12877c478bdstevel@tonic-gate				}
12887c478bdstevel@tonic-gate			} else {
12897c478bdstevel@tonic-gate				svcp->restarter_bad = r;
12907c478bdstevel@tonic-gate				add_svcptr(svcp->causes, svcp);
12917c478bdstevel@tonic-gate				add_svcptr(g_causes, svcp);
12927c478bdstevel@tonic-gate			}
12937c478bdstevel@tonic-gate		}
12947c478bdstevel@tonic-gate	}
12957c478bdstevel@tonic-gate
12967c478bdstevel@tonic-gate	assert(uu_list_numnodes(svcp->causes) > 0);
12977c478bdstevel@tonic-gate
12987c478bdstevel@tonic-gate	svcp->active = 0;
12997c478bdstevel@tonic-gate	return (UU_WALK_NEXT);
13007c478bdstevel@tonic-gate}
13017c478bdstevel@tonic-gate
13027c478bdstevel@tonic-gatestatic void
13037c478bdstevel@tonic-gatedetermine_all_causes(void)
13047c478bdstevel@tonic-gate{
13057c478bdstevel@tonic-gate	svc_t *svcp;
13067c478bdstevel@tonic-gate	int i;
13077c478bdstevel@tonic-gate
13087c478bdstevel@tonic-gate	for (i = 0; i < SVC_HASH_NBUCKETS; ++i) {
13097c478bdstevel@tonic-gate		for (svcp = services[i]; svcp != NULL; svcp = svcp->next)
13107c478bdstevel@tonic-gate			(void) uu_list_walk(svcp->instances,
13117c478bdstevel@tonic-gate			    (uu_walk_fn_t *)determine_causes, 0, 0);
13127c478bdstevel@tonic-gate	}
13137c478bdstevel@tonic-gate}
13147c478bdstevel@tonic-gate
13157c478bdstevel@tonic-gate/*
13167c478bdstevel@tonic-gate * Returns
13177c478bdstevel@tonic-gate *   0 - success
13187c478bdstevel@tonic-gate *   ELOOP - dependency cycle detected
13197c478bdstevel@tonic-gate */
13207c478bdstevel@tonic-gatestatic int
13217c478bdstevel@tonic-gatedetermine_impact(inst_t *ip)
13227c478bdstevel@tonic-gate{
13237c478bdstevel@tonic-gate	struct svcptr *idsp, *spp, *copy;
13247c478bdstevel@tonic-gate	uu_list_index_t idx;
13257c478bdstevel@tonic-gate
13267c478bdstevel@tonic-gate	if (ip->active) {
13277c478bdstevel@tonic-gate		(void) fprintf(stderr, gettext("Dependency cycle detected:\n"
13287c478bdstevel@tonic-gate		    "  svc:/%s:%s\n"), ip->svcname, ip->instname);
13297c478bdstevel@tonic-gate		return (ELOOP);
13307c478bdstevel@tonic-gate	}
13317c478bdstevel@tonic-gate
13327c478bdstevel@tonic-gate	if (ip->impact != NULL)
13337c478bdstevel@tonic-gate		return (0);
13347c478bdstevel@tonic-gate
13357c478bdstevel@tonic-gate	ip->impact = uu_list_create(svcptrs, ip, UU_LIST_DEBUG);
13367c478bdstevel@tonic-gate	if (ip->impact == NULL)
13377c478bdstevel@tonic-gate		uu_die(emsg_nomem);
13387c478bdstevel@tonic-gate	ip->active = 1;
13397c478bdstevel@tonic-gate
13407c478bdstevel@tonic-gate	for (idsp = uu_list_first(ip->impact_dependents);
13417c478bdstevel@tonic-gate	    idsp != NULL;
13427c478bdstevel@tonic-gate	    idsp = uu_list_next(ip->impact_dependents, idsp)) {
13437c478bdstevel@tonic-gate		if (determine_impact(idsp->svcp) != 0) {
13447c478bdstevel@tonic-gate			(void) fprintf(stderr, "  svc:/%s:%s\n",
13457c478bdstevel@tonic-gate			    ip->svcname, ip->instname);
13467c478bdstevel@tonic-gate			return (ELOOP);
13477c478bdstevel@tonic-gate		}
13487c478bdstevel@tonic-gate
13497c478bdstevel@tonic-gate		add_svcptr(ip->impact, idsp->svcp);
13507c478bdstevel@tonic-gate
13517c478bdstevel@tonic-gate		for (spp = uu_list_first(idsp->svcp->impact);
13527c478bdstevel@tonic-gate		    spp != NULL;
13537c478bdstevel@tonic-gate		    spp = uu_list_next(idsp->svcp->impact, spp)) {
13547c478bdstevel@tonic-gate			if (uu_list_find(ip->impact, spp, NULL, &idx) != NULL)
13557c478bdstevel@tonic-gate				continue;
13567c478bdstevel@tonic-gate
13577c478bdstevel@tonic-gate			copy = safe_malloc(sizeof (*copy));
13587c478bdstevel@tonic-gate			copy->svcp = spp->svcp;
13597c478bdstevel@tonic-gate			copy->next_hop = NULL;
13607c478bdstevel@tonic-gate			uu_list_node_init(copy, &copy->node, svcptrs);
13617c478bdstevel@tonic-gate			uu_list_insert(ip->impact, copy, idx);
13627c478bdstevel@tonic-gate		}
13637c478bdstevel@tonic-gate	}
13647c478bdstevel@tonic-gate
13657c478bdstevel@tonic-gate	ip->active = 0;
13667c478bdstevel@tonic-gate	return (0);
13677c478bdstevel@tonic-gate}
13687c478bdstevel@tonic-gate
13697c478bdstevel@tonic-gate/*
13707c478bdstevel@tonic-gate * Printing routines.
13717c478bdstevel@tonic-gate */
13727c478bdstevel@tonic-gate
13737c478bdstevel@tonic-gatestatic void
13747c478bdstevel@tonic-gatecheck_msgbase(void)
13757c478bdstevel@tonic-gate{
13767c478bdstevel@tonic-gate	if (scf_handle_decode_fmri(h, SCF_SERVICE_STARTD, NULL, NULL, g_inst,
13777c478bdstevel@tonic-gate	    NULL, NULL, SCF_DECODE_FMRI_EXACT) != 0) {
13787c478bdstevel@tonic-gate		if (scf_error() != SCF_ERROR_NOT_FOUND)
13797c478bdstevel@tonic-gate			scfdie();
13807c478bdstevel@tonic-gate
13817c478bdstevel@tonic-gate		return;
13827c478bdstevel@tonic-gate	}
13837c478bdstevel@tonic-gate
13847c478bdstevel@tonic-gate	if (scf_instance_get_pg_composed(g_inst, NULL, "msg", g_pg) != 0) {
13857c478bdstevel@tonic-gate		switch (scf_error()) {
13867c478bdstevel@tonic-gate		case SCF_ERROR_NOT_FOUND:
13877c478bdstevel@tonic-gate		case SCF_ERROR_DELETED:
13887c478bdstevel@tonic-gate			return;
13897c478bdstevel@tonic-gate
13907c478bdstevel@tonic-gate		default:
13917c478bdstevel@tonic-gate			scfdie();
13927c478bdstevel@tonic-gate		}
13937c478bdstevel@tonic-gate	}
13947c478bdstevel@tonic-gate
13957c478bdstevel@tonic-gate	if (scf_pg_get_property(g_pg, "base", g_prop) != 0) {
13967c478bdstevel@tonic-gate		switch (scf_error()) {
13977c478bdstevel@tonic-gate		case SCF_ERROR_NOT_FOUND:
13987c478bdstevel@tonic-gate		case SCF_ERROR_DELETED:
13997c478bdstevel@tonic-gate			return;
14007c478bdstevel@tonic-gate
14017c478bdstevel@tonic-gate		default:
14027c478bdstevel@tonic-gate			scfdie();
14037c478bdstevel@tonic-gate		}
14047c478bdstevel@tonic-gate	}
14057c478bdstevel@tonic-gate
14067c478bdstevel@tonic-gate	if (scf_property_get_value(g_prop, g_val) != 0) {
14077c478bdstevel@tonic-gate		switch (scf_error()) {
14087c478bdstevel@tonic-gate		case SCF_ERROR_NOT_FOUND:
14097c478bdstevel@tonic-gate		case SCF_ERROR_CONSTRAINT_VIOLATED:
14103eae19dwesolows		case SCF_ERROR_PERMISSION_DENIED:
14117c478bdstevel@tonic-gate			g_msgbase = NULL;
14127c478bdstevel@tonic-gate			return;
14137c478bdstevel@tonic-gate
14147c478bdstevel@tonic-gate		case SCF_ERROR_DELETED:
14157c478bdstevel@tonic-gate			return;
14167c478bdstevel@tonic-gate
14177c478bdstevel@tonic-gate		default:
14187c478bdstevel@tonic-gate			scfdie();
14197c478bdstevel@tonic-gate		}
14207c478bdstevel@tonic-gate	}
14217c478bdstevel@tonic-gate
14227c478bdstevel@tonic-gate	if (scf_value_get_astring(g_val, g_value, g_value_sz) < 0) {
14237c478bdstevel@tonic-gate		if (scf_error() != SCF_ERROR_TYPE_MISMATCH)
14247c478bdstevel@tonic-gate			scfdie();
14257c478bdstevel@tonic-gate		return;
14267c478bdstevel@tonic-gate	}
14277c478bdstevel@tonic-gate
14287c478bdstevel@tonic-gate	g_msgbase = safe_strdup(g_value);
14297c478bdstevel@tonic-gate}
14307c478bdstevel@tonic-gate
14317c478bdstevel@tonic-gatestatic void
14327c478bdstevel@tonic-gatedetermine_summary(inst_t *ip)
14337c478bdstevel@tonic-gate{
14347c478bdstevel@tonic-gate	if (ip->summary != NULL)
14357c478bdstevel@tonic-gate		return;
14367c478bdstevel@tonic-gate
14377c478bdstevel@tonic-gate	if (inst_running(ip)) {
14387c478bdstevel@tonic-gate		ip->summary = gettext("is running.");
14397c478bdstevel@tonic-gate		return;
14407c478bdstevel@tonic-gate	}
14417c478bdstevel@tonic-gate
14427c478bdstevel@tonic-gate	if (strcmp(ip->state, SCF_STATE_STRING_UNINIT) == 0) {
14437c478bdstevel@tonic-gate		ip->summary = gettext("is uninitialized.");
14447c478bdstevel@tonic-gate	} else if (strcmp(ip->state, SCF_STATE_STRING_DISABLED) == 0) {
14457c478bdstevel@tonic-gate		if (!ip->temporary)
14467c478bdstevel@tonic-gate			ip->summary = gettext("is disabled.");
14477c478bdstevel@tonic-gate		else
14487c478bdstevel@tonic-gate			ip->summary = gettext("is temporarily disabled.");
14497c478bdstevel@tonic-gate	} else if (strcmp(ip->state, SCF_STATE_STRING_OFFLINE) == 0) {
14507c478bdstevel@tonic-gate		if (uu_list_numnodes(ip->baddeps) != 0)
14517c478bdstevel@tonic-gate			ip->summary = gettext("has missing dependencies.");
14527c478bdstevel@tonic-gate		else if (strcmp(ip->next_state, SCF_STATE_STRING_ONLINE) == 0)
14537c478bdstevel@tonic-gate			ip->summary = gettext("is starting.");
14547c478bdstevel@tonic-gate		else
14557c478bdstevel@tonic-gate			ip->summary = gettext("is offline.");
14567c478bdstevel@tonic-gate	} else if (strcmp(ip->state, SCF_STATE_STRING_MAINT) == 0) {
14577c478bdstevel@tonic-gate		if (strcmp(ip->aux_state, "administrative_request") == 0) {
14587c478bdstevel@tonic-gate			ip->summary = gettext("was taken down for maintenace "
14597c478bdstevel@tonic-gate			    "by an administrator.");
14607c478bdstevel@tonic-gate		} else if (strcmp(ip->aux_state, "dependency_cycle") == 0) {
14617c478bdstevel@tonic-gate			ip->summary = gettext("completed a dependency cycle.");
14627c478bdstevel@tonic-gate		} else if (strcmp(ip->aux_state, "fault_threshold_reached") ==
14637c478bdstevel@tonic-gate		    0) {
14647c478bdstevel@tonic-gate			ip->summary = gettext("is not running because "
14657c478bdstevel@tonic-gate			    "a method failed repeatedly.");
14667c478bdstevel@tonic-gate		} else if (strcmp(ip->aux_state, "invalid_dependency") == 0) {
14677c478bdstevel@tonic-gate			ip->summary = gettext("has an invalid dependency.");
14687c478bdstevel@tonic-gate		} else if (strcmp(ip->aux_state, "invalid_restarter") == 0) {
14697c478bdstevel@tonic-gate			ip->summary = gettext("has an invalid restarter.");
14707c478bdstevel@tonic-gate		} else if (strcmp(ip->aux_state, "method_failed") == 0) {
14717c478bdstevel@tonic-gate			ip->summary = gettext("is not running because "
14727c478bdstevel@tonic-gate			    "a method failed.");
14737c478bdstevel@tonic-gate		} else if (strcmp(ip->aux_state, "none") == 0) {
14747c478bdstevel@tonic-gate			ip->summary =
14757c478bdstevel@tonic-gate			    gettext("is not running for an unknown reason.");
14767c478bdstevel@tonic-gate		} else if (strcmp(ip->aux_state, "restarting_too_quickly") ==
14777c478bdstevel@tonic-gate		    0) {
14787c478bdstevel@tonic-gate			ip->summary = gettext("was restarting too quickly.");
14797c478bdstevel@tonic-gate		} else {
14807c478bdstevel@tonic-gate			ip->summary = gettext("requires maintenance.");
14817c478bdstevel@tonic-gate		}
14827c478bdstevel@tonic-gate	} else {
14837c478bdstevel@tonic-gate		ip->summary = gettext("is in an invalid state.");
14847c478bdstevel@tonic-gate	}
14857c478bdstevel@tonic-gate}
14867c478bdstevel@tonic-gate
14877c478bdstevel@tonic-gatestatic void
14887c478bdstevel@tonic-gateprint_method_failure(const inst_t *ip, const char **dcp)
14897c478bdstevel@tonic-gate{
14907c478bdstevel@tonic-gate	char buf[50];
14917c478bdstevel@tonic-gate	int stat = ip->start_method_waitstatus;
14927c478bdstevel@tonic-gate
14937c478bdstevel@tonic-gate	if (stat != 0) {
14947c478bdstevel@tonic-gate		if (WIFEXITED(stat)) {
14957c478bdstevel@tonic-gate			if (WEXITSTATUS(stat) == SMF_EXIT_ERR_CONFIG) {
14967c478bdstevel@tonic-gate				(void) strlcpy(buf, gettext(
14977c478bdstevel@tonic-gate				    "exited with $SMF_EXIT_ERR_CONFIG"),
14987c478bdstevel@tonic-gate				    sizeof (buf));
14997c478bdstevel@tonic-gate			} else if (WEXITSTATUS(stat) == SMF_EXIT_ERR_FATAL) {
15007c478bdstevel@tonic-gate				(void) strlcpy(buf, gettext(
15017c478bdstevel@tonic-gate				    "exited with $SMF_EXIT_ERR_FATAL"),
15027c478bdstevel@tonic-gate				    sizeof (buf));
15037c478bdstevel@tonic-gate			} else {
15047c478bdstevel@tonic-gate				(void) snprintf(buf, sizeof (buf),
15057c478bdstevel@tonic-gate				    gettext("exited with status %d"),
15067c478bdstevel@tonic-gate				    WEXITSTATUS(stat));
15077c478bdstevel@tonic-gate			}
15087c478bdstevel@tonic-gate		} else if (WIFSIGNALED(stat)) {
15097c478bdstevel@tonic-gate			if (WCOREDUMP(stat)) {
15107c478bdstevel@tonic-gate				if (strsignal(WTERMSIG(stat)) != NULL)
15117c478bdstevel@tonic-gate					(void) snprintf(buf, sizeof (buf),
15127c478bdstevel@tonic-gate					    gettext("dumped core on %s (%d)"),
15137c478bdstevel@tonic-gate					    strsignal(WTERMSIG(stat)),
15147c478bdstevel@tonic-gate					    WTERMSIG(stat));
15157c478bdstevel@tonic-gate				else
15167c478bdstevel@tonic-gate					(void) snprintf(buf, sizeof (buf),
15177c478bdstevel@tonic-gate					    gettext("dumped core signal %d"),
15187c478bdstevel@tonic-gate					    WTERMSIG(stat));
15197c478bdstevel@tonic-gate			} else {
15207c478bdstevel@tonic-gate				if (strsignal(WTERMSIG(stat)) != NULL) {
15217c478bdstevel@tonic-gate					(void) snprintf(buf, sizeof (buf),
15227c478bdstevel@tonic-gate					    gettext("died on %s (%d)"),
15237c478bdstevel@tonic-gate					    strsignal(WTERMSIG(stat)),
15247c478bdstevel@tonic-gate					    WTERMSIG(stat));
15257c478bdstevel@tonic-gate				} else {
15267c478bdstevel@tonic-gate					(void) snprintf(buf, sizeof (buf),
15277c478bdstevel@tonic-gate					    gettext("died on signal %d"),
15287c478bdstevel@tonic-gate					    WTERMSIG(stat));
15297c478bdstevel@tonic-gate				}
15307c478bdstevel@tonic-gate			}
15317c478bdstevel@tonic-gate		} else {
15327c478bdstevel@tonic-gate			goto fail;
15337c478bdstevel@tonic-gate		}
15347c478bdstevel@tonic-gate
15357c478bdstevel@tonic-gate		if (strcmp(ip->aux_state, "fault_threshold_reached") != 0)
15367c478bdstevel@tonic-gate			(void) printf(gettext("Reason: Start method %s.\n"),
15377c478bdstevel@tonic-gate			    buf);
15387c478bdstevel@tonic-gate		else
15397c478bdstevel@tonic-gate			(void) printf(gettext("Reason: "
15407c478bdstevel@tonic-gate			    "Start method failed repeatedly, last %s.\n"), buf);
15417c478bdstevel@tonic-gate		*dcp = DC_STARTFAIL;
15427c478bdstevel@tonic-gate	} else {
15437c478bdstevel@tonic-gatefail:
15447c478bdstevel@tonic-gate		if (strcmp(ip->aux_state, "fault_threshold_reached") == 0)
15457c478bdstevel@tonic-gate			(void) puts(gettext(
15467c478bdstevel@tonic-gate			    "Reason: Method failed repeatedly."));
15477c478bdstevel@tonic-gate		else
15487c478bdstevel@tonic-gate			(void) puts(gettext("Reason: Method failed."));
15497c478bdstevel@tonic-gate		*dcp = DC_METHFAIL;
15507c478bdstevel@tonic-gate	}
15517c478bdstevel@tonic-gate}
15527c478bdstevel@tonic-gate
15537c478bdstevel@tonic-gatestatic void
15547c478bdstevel@tonic-gateprint_dependency_reasons(const inst_t *svcp, int verbose)
15557c478bdstevel@tonic-gate{
15567c478bdstevel@tonic-gate	struct dependency *d;
15577c478bdstevel@tonic-gate	struct svcptr *spp;
15587c478bdstevel@tonic-gate	const char *dc;
15597c478bdstevel@tonic-gate
15607c478bdstevel@tonic-gate	/*
15617c478bdstevel@tonic-gate	 * If we couldn't determine why the service is offline, then baddeps
15627c478bdstevel@tonic-gate	 * will be empty and causes will have a pointer to self.
15637c478bdstevel@tonic-gate	 */
15647c478bdstevel@tonic-gate	if (uu_list_numnodes(svcp->baddeps) == 0 &&
15657c478bdstevel@tonic-gate	    uu_list_numnodes(svcp->causes) == 1) {
15667c478bdstevel@tonic-gate		spp = uu_list_first(svcp->causes);
15677c478bdstevel@tonic-gate		if (spp->svcp == svcp) {
15687c478bdstevel@tonic-gate			switch (svcp->restarter_bad) {
15697c478bdstevel@tonic-gate			case 0:
15707c478bdstevel@tonic-gate				(void) puts(gettext("Reason: Unknown."));
15717c478bdstevel@tonic-gate				dc = DC_UNKNOWN;
15727c478bdstevel@tonic-gate				break;
15737c478bdstevel@tonic-gate
15747c478bdstevel@tonic-gate			case EINVAL:
15757c478bdstevel@tonic-gate				(void) printf(gettext("Reason: "
15767c478bdstevel@tonic-gate				    "Restarter \"%s\" is invalid.\n"),
15777c478bdstevel@tonic-gate				    svcp->restarter);
15787c478bdstevel@tonic-gate				dc = DC_RSTRINVALID;
15797c478bdstevel@tonic-gate				break;
15807c478bdstevel@tonic-gate
15817c478bdstevel@tonic-gate			case ENOENT:
15827c478bdstevel@tonic-gate				(void) printf(gettext("Reason: "
15837c478bdstevel@tonic-gate				    "Restarter \"%s\" does not exist.\n"),
15847c478bdstevel@tonic-gate				    svcp->restarter);
15857c478bdstevel@tonic-gate				dc = DC_RSTRABSENT;
15867c478bdstevel@tonic-gate				break;
15877c478bdstevel@tonic-gate
15887c478bdstevel@tonic-gate			default:
15897c478bdstevel@tonic-gate#ifndef NDEBUG
15907c478bdstevel@tonic-gate				(void) fprintf(stderr, "%s:%d: Bad "
15917c478bdstevel@tonic-gate				    "restarter_bad value %d.  Aborting.\n",
15927c478bdstevel@tonic-gate				    __FILE__, __LINE__, svcp->restarter_bad);
15937c478bdstevel@tonic-gate#endif
15947c478bdstevel@tonic-gate				abort();
15957c478bdstevel@tonic-gate			}
15967c478bdstevel@tonic-gate
15977c478bdstevel@tonic-gate			if (g_msgbase)
15987c478bdstevel@tonic-gate				(void) printf(gettext("   See: %s%s\n"),
15997c478bdstevel@tonic-gate				    g_msgbase, dc);
16007c478bdstevel@tonic-gate			return;
16017c478bdstevel@tonic-gate		}
16027c478bdstevel@tonic-gate	}
16037c478bdstevel@tonic-gate
16047c478bdstevel@tonic-gate	for (d = uu_list_first(svcp->baddeps);
16057c478bdstevel@tonic-gate	    d != NULL;
16067c478bdstevel@tonic-gate	    d = uu_list_next(svcp->baddeps, d)) {
16077c478bdstevel@tonic-gate		(void) printf(gettext("Reason: Dependency %s is absent.\n"),
16087c478bdstevel@tonic-gate		    d->fmri);
16097c478bdstevel@tonic-gate		if (g_msgbase)
16107c478bdstevel@tonic-gate			(void) printf(gettext("   See: %s%s\n"), g_msgbase,
16117c478bdstevel@tonic-gate			    DC_DEPABSENT);
16127c478bdstevel@tonic-gate	}
16137c478bdstevel@tonic-gate
16147c478bdstevel@tonic-gate	for (spp = uu_list_first(svcp->causes);
16157c478bdstevel@tonic-gate	    spp != NULL && spp->svcp != svcp;
16167c478bdstevel@tonic-gate	    spp = uu_list_next(svcp->causes, spp)) {
16177c478bdstevel@tonic-gate		determine_summary(spp->svcp);
16187c478bdstevel@tonic-gate
16197c478bdstevel@tonic-gate		if (inst_running(spp->svcp)) {
16207c478bdstevel@tonic-gate			(void) printf(gettext("Reason: "
16217c478bdstevel@tonic-gate			    "Service svc:/%s:%s is running.\n"),
16227c478bdstevel@tonic-gate			    spp->svcp->svcname, spp->svcp->instname);
16237c478bdstevel@tonic-gate			dc = DC_DEPRUNNING;
16247c478bdstevel@tonic-gate		} else {
16257c478bdstevel@tonic-gate			if (snprintf(NULL, 0,
16267c478bdstevel@tonic-gate			    gettext("Reason: Service svc:/%s:%s %s"),
16277c478bdstevel@tonic-gate			    spp->svcp->svcname, spp->svcp->instname,
16287c478bdstevel@tonic-gate			    spp->svcp->summary) <= 80) {
16297c478bdstevel@tonic-gate				(void) printf(gettext(
16307c478bdstevel@tonic-gate				    "Reason: Service svc:/%s:%s %s\n"),
16317c478bdstevel@tonic-gate				    spp->svcp->svcname, spp->svcp->instname,
16327c478bdstevel@tonic-gate				    spp->svcp->summary);
16337c478bdstevel@tonic-gate			} else {
16347c478bdstevel@tonic-gate				(void) printf(gettext(
16357c478bdstevel@tonic-gate				    "Reason: Service svc:/%s:%s\n"
16367c478bdstevel@tonic-gate				    "        %s\n"), spp->svcp->svcname,
16377c478bdstevel@tonic-gate				    spp->svcp->instname, spp->svcp->summary);
16387c478bdstevel@tonic-gate			}
16397c478bdstevel@tonic-gate
16407c478bdstevel@tonic-gate			dc = DC_DEPOTHER;
16417c478bdstevel@tonic-gate		}
16427c478bdstevel@tonic-gate
16437c478bdstevel@tonic-gate		if (g_msgbase != NULL)
16447c478bdstevel@tonic-gate			(void) printf(gettext("   See: %s%s\n"), g_msgbase, dc);
16457c478bdstevel@tonic-gate
16467c478bdstevel@tonic-gate		if (verbose) {
16477c478bdstevel@tonic-gate			inst_t *pp;
16487c478bdstevel@tonic-gate			int indent;
16497c478bdstevel@tonic-gate
16507c478bdstevel@tonic-gate			(void) printf(gettext("  Path: svc:/%s:%s\n"),
16517c478bdstevel@tonic-gate			    svcp->svcname, svcp->instname);
16527c478bdstevel@tonic-gate
16537c478bdstevel@tonic-gate			indent = 1;
16547c478bdstevel@tonic-gate			for (pp = spp->next_hop; ; ) {
16557c478bdstevel@tonic-gate				struct svcptr *tmp;
16567c478bdstevel@tonic-gate
16577c478bdstevel@tonic-gate				(void) printf(gettext("%6s  %*ssvc:/%s:%s\n"),
16587c478bdstevel@tonic-gate				    "", indent++ * 2, "", pp->svcname,
16597c478bdstevel@tonic-gate				    pp->instname);
16607c478bdstevel@tonic-gate
16617c478bdstevel@tonic-gate				if (pp == spp->svcp)
16627c478bdstevel@tonic-gate					break;
16637c478bdstevel@tonic-gate
16647c478bdstevel@tonic-gate				/* set pp to next_hop of cause with same svcp */
16657c478bdstevel@tonic-gate				tmp = uu_list_find(pp->causes, spp, NULL, NULL);
16667c478bdstevel@tonic-gate				pp = tmp->next_hop;
16677c478bdstevel@tonic-gate			}
16687c478bdstevel@tonic-gate		}
16697c478bdstevel@tonic-gate	}
16707c478bdstevel@tonic-gate}
16717c478bdstevel@tonic-gate
16727c478bdstevel@tonic-gatestatic void
1673eb1a346Truong Nguyenprint_logs(scf_instance_t *inst)
1674eb1a346Truong Nguyen{
1675eb1a346Truong Nguyen	if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, g_pg) != 0)
1676eb1a346Truong Nguyen		return;
1677eb1a346Truong Nguyen
1678eb1a346Truong Nguyen	if (pg_get_single_val(g_pg, SCF_PROPERTY_ALT_LOGFILE,
1679eb1a346Truong Nguyen	    SCF_TYPE_ASTRING, (void *)g_value, g_value_sz, 0) == 0)
1680eb1a346Truong Nguyen		(void) printf(gettext("   See: %s\n"), g_value);
1681eb1a346Truong Nguyen
1682eb1a346Truong Nguyen	if (pg_get_single_val(g_pg, SCF_PROPERTY_LOGFILE,
1683eb1a346Truong Nguyen	    SCF_TYPE_ASTRING, (void *)g_value, g_value_sz, 0) == 0)
1684eb1a346Truong Nguyen		(void) printf(gettext("   See: %s\n"), g_value);
1685eb1a346Truong Nguyen}
1686eb1a346Truong Nguyen
1687eb1a346Truong Nguyenstatic void
1688eb1a346Truong Nguyenprint_aux_fmri_logs(const char *fmri)
1689eb1a346Truong Nguyen{
1690eb1a346Truong Nguyen	scf_instance_t *scf_inst = scf_instance_create(h);
1691eb1a346Truong Nguyen	if (scf_inst == NULL)
1692eb1a346Truong Nguyen		return;
1693eb1a346Truong Nguyen
1694eb1a346Truong Nguyen	if (scf_handle_decode_fmri(h, fmri, NULL, NULL, scf_inst,
1695eb1a346Truong Nguyen	    NULL, NULL, SCF_DECODE_FMRI_EXACT) == 0)
1696eb1a346Truong Nguyen		print_logs(scf_inst);
1697eb1a346Truong Nguyen
1698eb1a346Truong Nguyen	scf_instance_destroy(scf_inst);
1699eb1a346Truong Nguyen}
1700eb1a346Truong Nguyen
1701eb1a346Truong Nguyenstatic void
17027c478bdstevel@tonic-gateprint_reasons(const inst_t *svcp, int verbose)
17037c478bdstevel@tonic-gate{
17047c478bdstevel@tonic-gate	int r;
17057c478bdstevel@tonic-gate	const char *dc = NULL;
17067c478bdstevel@tonic-gate
17077c478bdstevel@tonic-gate	if (strcmp(svcp->state, SCF_STATE_STRING_ONLINE) == 0)
17087c478bdstevel@tonic-gate		return;
17097c478bdstevel@tonic-gate
17107c478bdstevel@tonic-gate	if (strcmp(svcp->state, SCF_STATE_STRING_UNINIT) == 0) {
17117c478bdstevel@tonic-gate		inst_t *rsp;
17127c478bdstevel@tonic-gate
17137c478bdstevel@tonic-gate		r = get_fmri(svcp->restarter, NULL, &rsp);
17147c478bdstevel@tonic-gate		switch (r) {
17157c478bdstevel@tonic-gate		case 0:
17167c478bdstevel@tonic-gate			if (rsp != NULL)
17177c478bdstevel@tonic-gate				break;
17187c478bdstevel@tonic-gate			/* FALLTHROUGH */
17197c478bdstevel@tonic-gate
17207c478bdstevel@tonic-gate		case EINVAL:
17217c478bdstevel@tonic-gate			(void) printf(gettext("Reason: "
17227c478bdstevel@tonic-gate			    "Restarter \"%s\" is invalid.\n"), svcp->restarter);
17237c478bdstevel@tonic-gate			dc = DC_RSTRINVALID;
17247c478bdstevel@tonic-gate			goto diagcode;
17257c478bdstevel@tonic-gate
17267c478bdstevel@tonic-gate		case ENOENT:
17277c478bdstevel@tonic-gate			(void) printf(gettext("Reason: "
17287c478bdstevel@tonic-gate			    "Restarter \"%s\" does not exist.\n"),
17297c478bdstevel@tonic-gate			    svcp->restarter);
17307c478bdstevel@tonic-gate			dc = DC_RSTRABSENT;
17317c478bdstevel@tonic-gate			goto diagcode;
17327c478bdstevel@tonic-gate
17337c478bdstevel@tonic-gate		default:
17347c478bdstevel@tonic-gate			bad_error("get_fmri", r);
17357c478bdstevel@tonic-gate		}
17367c478bdstevel@tonic-gate
17377c478bdstevel@tonic-gate		if (inst_running(rsp)) {
17387c478bdstevel@tonic-gate			(void) printf(gettext("Reason: Restarter %s "
17397c478bdstevel@tonic-gate			    "has not initialized service state.\n"),
17407c478bdstevel@tonic-gate			    svcp->restarter);
17417c478bdstevel@tonic-gate			dc = DC_UNINIT;
17427c478bdstevel@tonic-gate		} else {
17437c478bdstevel@tonic-gate			(void) printf(gettext(
17447c478bdstevel@tonic-gate			    "Reason: Restarter %s is not running.\n"),
17457c478bdstevel@tonic-gate			    svcp->restarter);
17467c478bdstevel@tonic-gate			dc = DC_RSTRDEAD;
17477c478bdstevel@tonic-gate		}
17487c478bdstevel@tonic-gate
17497c478bdstevel@tonic-gate	} else if (strcmp(svcp->state, SCF_STATE_STRING_DISABLED) == 0) {
17507c478bdstevel@tonic-gate		if (!svcp->temporary) {
17518fff788John Levon			if (svcp->comment[0] != '\0') {
17528fff788John Levon				(void) printf(gettext("Reason: Disabled by "
17538fff788John Levon				    "an administrator: %s\n"), svcp->comment);
17548fff788John Levon			} else {
17558fff788John Levon				(void) printf(gettext("Reason: Disabled by "
17568fff788John Levon				    "an administrator.\n"));
17578fff788John Levon			}
17587c478bdstevel@tonic-gate			dc = DC_DISABLED;
17597c478bdstevel@tonic-gate		} else {
17608fff788John Levon			if (svcp->comment[0] != '\0') {
17618fff788John Levon				(void) printf(gettext("Reason: Temporarily "
17628fff788John Levon				    "disabled by an administrator: %s\n"),
17638fff788John Levon				    svcp->comment);
17648fff788John Levon			} else {
17658fff788John Levon				(void) printf(gettext("Reason: Temporarily "
17668fff788John Levon				    "disabled by an administrator.\n"));
17678fff788John Levon			}
17687c478bdstevel@tonic-gate			dc = DC_TEMPDISABLED;
17697c478bdstevel@tonic-gate		}
17707c478bdstevel@tonic-gate
17717c478bdstevel@tonic-gate	} else if (strcmp(svcp->state, SCF_STATE_STRING_MAINT) == 0) {
17727c478bdstevel@tonic-gate		if (strcmp(svcp->aux_state, "administrative_request") == 0) {
17737c478bdstevel@tonic-gate			(void) puts(gettext("Reason: "
17747c478bdstevel@tonic-gate			    "Maintenance requested by an administrator."));
17757c478bdstevel@tonic-gate			dc = DC_ADMINMAINT;
17767c478bdstevel@tonic-gate		} else if (strcmp(svcp->aux_state, "dependency_cycle") == 0) {
17777c478bdstevel@tonic-gate			(void) puts(gettext(
17787c478bdstevel@tonic-gate			    "Reason: Completes a dependency cycle."));
17797c478bdstevel@tonic-gate			dc = DC_DEPCYCLE;
17807c478bdstevel@tonic-gate		} else if (strcmp(svcp->aux_state, "fault_threshold_reached") ==
17817c478bdstevel@tonic-gate		    0) {
17827c478bdstevel@tonic-gate			print_method_failure(svcp, &dc);
1783eb1a346Truong Nguyen		} else if (strcmp(svcp->aux_state, "service_request") == 0) {
1784eb1a346Truong Nguyen			if (svcp->aux_fmri) {
1785eb1a346Truong Nguyen				(void) printf(gettext("Reason: Maintenance "
1786eb1a346Truong Nguyen				    "requested by \"%s\"\n"), svcp->aux_fmri);
1787eb1a346Truong Nguyen				print_aux_fmri_logs(svcp->aux_fmri);
1788eb1a346Truong Nguyen			} else {
1789eb1a346Truong Nguyen				(void) puts(gettext("Reason: Maintenance "
1790eb1a346Truong Nguyen				    "requested by another service."));
1791eb1a346Truong Nguyen			}
1792eb1a346Truong Nguyen			dc = DC_SVCREQMAINT;
17937c478bdstevel@tonic-gate		} else if (strcmp(svcp->aux_state, "invalid_dependency") == 0) {
17947c478bdstevel@tonic-gate			(void) puts(gettext("Reason: Has invalid dependency."));
17957c478bdstevel@tonic-gate			dc = DC_INVALIDDEP;
17967c478bdstevel@tonic-gate		} else if (strcmp(svcp->aux_state, "invalid_restarter") == 0) {
17977c478bdstevel@tonic-gate			(void) printf(gettext("Reason: Restarter \"%s\" is "
17987c478bdstevel@tonic-gate			    "invalid.\n"), svcp->restarter);
17997c478bdstevel@tonic-gate			dc = DC_RSTRINVALID;
18007c478bdstevel@tonic-gate		} else if (strcmp(svcp->aux_state, "method_failed") == 0) {
18017c478bdstevel@tonic-gate			print_method_failure(svcp, &dc);
18027c478bdstevel@tonic-gate		} else if (strcmp(svcp->aux_state, "restarting_too_quickly") ==
18037c478bdstevel@tonic-gate		    0) {
18047c478bdstevel@tonic-gate			(void) puts(gettext("Reason: Restarting too quickly."));
18057c478bdstevel@tonic-gate			dc = DC_TOOQUICKLY;
18067c478bdstevel@tonic-gate		} else if (strcmp(svcp->aux_state, "none") == 0) {
18077c478bdstevel@tonic-gate			(void) printf(gettext(
18087c478bdstevel@tonic-gate			    "Reason: Restarter %s gave no explanation.\n"),
18097c478bdstevel@tonic-gate			    svcp->restarter);
18107c478bdstevel@tonic-gate			dc = DC_NONE;
18117c478bdstevel@tonic-gate		} else {
18127c478bdstevel@tonic-gate			(void) puts(gettext("Reason: Unknown."));
18137c478bdstevel@tonic-gate			dc = DC_UNKNOWN;
18147c478bdstevel@tonic-gate		}
18157c478bdstevel@tonic-gate
18167c478bdstevel@tonic-gate	} else if (strcmp(svcp->state, SCF_STATE_STRING_OFFLINE) == 0) {
18177c478bdstevel@tonic-gate		if (strcmp(svcp->next_state, SCF_STATE_STRING_ONLINE) == 0) {
18187c478bdstevel@tonic-gate			(void) puts(gettext(
18197c478bdstevel@tonic-gate			    "Reason: Start method is running."));
18207c478bdstevel@tonic-gate			dc = DC_STARTING;
18217c478bdstevel@tonic-gate		} else if (strcmp(svcp->next_state, SCF_STATE_STRING_NONE) ==
18227c478bdstevel@tonic-gate		    0) {
18237c478bdstevel@tonic-gate			print_dependency_reasons(svcp, verbose);
18247c478bdstevel@tonic-gate			/* Function prints diagcodes. */
18257c478bdstevel@tonic-gate			return;
18267c478bdstevel@tonic-gate		} else {
18277c478bdstevel@tonic-gate			(void) printf(gettext(
18287c478bdstevel@tonic-gate			    "Reason: Transitioning to state %s.\n"),
18297c478bdstevel@tonic-gate			    svcp->next_state);
18307c478bdstevel@tonic-gate			dc = DC_TRANSITION;
18317c478bdstevel@tonic-gate		}
18327c478bdstevel@tonic-gate
18337c478bdstevel@tonic-gate	} else if (strcmp(svcp->state, SCF_STATE_STRING_DEGRADED) == 0) {
18347c478bdstevel@tonic-gate		(void) puts(gettext("Reason: Degraded by an administrator."));
18357c478bdstevel@tonic-gate		dc = DC_ADMINDEGR;
18367c478bdstevel@tonic-gate
18377c478bdstevel@tonic-gate	} else {
18387c478bdstevel@tonic-gate		(void) printf(gettext("Reason: Not in valid state (%s).\n"),
18397c478bdstevel@tonic-gate		    svcp->state);
18407c478bdstevel@tonic-gate		dc = DC_INVALIDSTATE;
18417c478bdstevel@tonic-gate	}
18427c478bdstevel@tonic-gate
18437c478bdstevel@tonic-gatediagcode:
18447c478bdstevel@tonic-gate	if (g_msgbase != NULL)
18457c478bdstevel@tonic-gate		(void) printf(gettext("   See: %s%s\n"), g_msgbase, dc);
18467c478bdstevel@tonic-gate}
18477c478bdstevel@tonic-gate
18487c478bdstevel@tonic-gatestatic void
18497c478bdstevel@tonic-gateprint_manpage(int verbose)
18507c478bdstevel@tonic-gate{
18517c478bdstevel@tonic-gate	static char *title = NULL;
18527c478bdstevel@tonic-gate	static char *section = NULL;
18537c478bdstevel@tonic-gate
18547c478bdstevel@tonic-gate	if (title == NULL) {
18557c478bdstevel@tonic-gate		title = safe_malloc(g_value_sz);
18567c478bdstevel@tonic-gate		section = safe_malloc(g_value_sz);
18577c478bdstevel@tonic-gate	}
18587c478bdstevel@tonic-gate
18597c478bdstevel@tonic-gate	if (pg_get_single_val(g_pg, SCF_PROPERTY_TM_TITLE, SCF_TYPE_ASTRING,
18607c478bdstevel@tonic-gate	    (void *)title, g_value_sz, 0) != 0)
18617c478bdstevel@tonic-gate		return;
18627c478bdstevel@tonic-gate
18637c478bdstevel@tonic-gate	if (pg_get_single_val(g_pg, SCF_PROPERTY_TM_SECTION,
18647c478bdstevel@tonic-gate	    SCF_TYPE_ASTRING, (void *)section, g_value_sz, 0) != 0)
18657c478bdstevel@tonic-gate		return;
18667c478bdstevel@tonic-gate
18677c478bdstevel@tonic-gate	if (!verbose) {
18687c478bdstevel@tonic-gate		(void) printf(gettext("   See: %s(%s)\n"), title, section);
18697c478bdstevel@tonic-gate		return;
18707c478bdstevel@tonic-gate	}
18717c478bdstevel@tonic-gate
18727c478bdstevel@tonic-gate	if (pg_get_single_val(g_pg, SCF_PROPERTY_TM_MANPATH, SCF_TYPE_ASTRING,
18737c478bdstevel@tonic-gate	    (void *)g_value, g_value_sz, 0) != 0)
18747c478bdstevel@tonic-gate		return;
18757c478bdstevel@tonic-gate
18767c478bdstevel@tonic-gate	if (strcmp(g_value, ":default") == 0) {
18777c478bdstevel@tonic-gate		assert(sizeof (DEFAULT_MAN_PATH) < g_value_sz);
18787c478bdstevel@tonic-gate		(void) strcpy(g_value, DEFAULT_MAN_PATH);
18797c478bdstevel@tonic-gate	}
18807c478bdstevel@tonic-gate
18817c478bdstevel@tonic-gate	(void) printf(gettext("   See: man -M %s -s %s %s\n"), g_value,
18827c478bdstevel@tonic-gate	    section, title);
18837c478bdstevel@tonic-gate}
18847c478bdstevel@tonic-gate
18857c478bdstevel@tonic-gatestatic void
18867c478bdstevel@tonic-gateprint_doclink()
18877c478bdstevel@tonic-gate{
18887c478bdstevel@tonic-gate	static char *uri = NULL;
18897c478bdstevel@tonic-gate
18907c478bdstevel@tonic-gate	if (uri == NULL) {
18917c478bdstevel@tonic-gate		uri = safe_malloc(g_value_sz);
18927c478bdstevel@tonic-gate	}
18937c478bdstevel@tonic-gate
18947c478bdstevel@tonic-gate	if (pg_get_single_val(g_pg, SCF_PROPERTY_TM_URI, SCF_TYPE_ASTRING,
18957c478bdstevel@tonic-gate	    (void *)uri, g_value_sz, 0) != 0)
18967c478bdstevel@tonic-gate		return;
18977c478bdstevel@tonic-gate
18987c478bdstevel@tonic-gate	(void) printf(gettext("   See: %s\n"), uri);
18997c478bdstevel@tonic-gate}
19007c478bdstevel@tonic-gate
19017c478bdstevel@tonic-gate
19027c478bdstevel@tonic-gate/*
19037c478bdstevel@tonic-gate * Returns
19047c478bdstevel@tonic-gate *   0 - success
19057c478bdstevel@tonic-gate *   1 - inst was deleted
19067c478bdstevel@tonic-gate */
19077c478bdstevel@tonic-gatestatic int
19087c478bdstevel@tonic-gateprint_docs(scf_instance_t *inst, int verbose)
19097c478bdstevel@tonic-gate{
19107c478bdstevel@tonic-gate	scf_snapshot_t *snap;
19117c478bdstevel@tonic-gate	int r;
19127c478bdstevel@tonic-gate
19137c478bdstevel@tonic-gate	if (scf_instance_get_snapshot(inst, "running", g_snap) != 0) {
19147c478bdstevel@tonic-gate		switch (scf_error()) {
19157c478bdstevel@tonic-gate		case SCF_ERROR_NOT_FOUND:
19167c478bdstevel@tonic-gate			break;
19177c478bdstevel@tonic-gate
19187c478bdstevel@tonic-gate		case SCF_ERROR_DELETED:
19197c478bdstevel@tonic-gate			return (1);
19207c478bdstevel@tonic-gate
19217c478bdstevel@tonic-gate		default:
19227c478bdstevel@tonic-gate			scfdie();
19237c478bdstevel@tonic-gate		}
19247c478bdstevel@tonic-gate
19257c478bdstevel@tonic-gate		snap = NULL;
19267c478bdstevel@tonic-gate	} else {
19277c478bdstevel@tonic-gate		snap = g_snap;
19287c478bdstevel@tonic-gate	}
19297c478bdstevel@tonic-gate
19307c478bdstevel@tonic-gate	if (scf_iter_instance_pgs_typed_composed(g_iter, inst, snap,
19317c478bdstevel@tonic-gate	    SCF_GROUP_TEMPLATE) != 0) {
19327c478bdstevel@tonic-gate		if (scf_error() != SCF_ERROR_DELETED)
19337c478bdstevel@tonic-gate			scfdie();
19347c478bdstevel@tonic-gate
19357c478bdstevel@tonic-gate		return (1);
19367c478bdstevel@tonic-gate	}
19377c478bdstevel@tonic-gate
19387c478bdstevel@tonic-gate	for (;;) {
19397c478bdstevel@tonic-gate		r = scf_iter_next_pg(g_iter, g_pg);
19407c478bdstevel@tonic-gate		if (r == 0)
19417c478bdstevel@tonic-gate			break;
19427c478bdstevel@tonic-gate		if (r != 1) {
19437c478bdstevel@tonic-gate			if (scf_error() != SCF_ERROR_DELETED)
19447c478bdstevel@tonic-gate				scfdie();
19457c478bdstevel@tonic-gate
19467c478bdstevel@tonic-gate			return (1);
19477c478bdstevel@tonic-gate		}
19487c478bdstevel@tonic-gate
19497c478bdstevel@tonic-gate		if (scf_pg_get_name(g_pg, g_fmri, g_fmri_sz) < 0) {
19507c478bdstevel@tonic-gate			if (scf_error() != SCF_ERROR_DELETED)
19517c478bdstevel@tonic-gate				scfdie();
19527c478bdstevel@tonic-gate
19537c478bdstevel@tonic-gate			continue;
19547c478bdstevel@tonic-gate		}
19557c478bdstevel@tonic-gate
19567c478bdstevel@tonic-gate		if (strncmp(g_fmri, SCF_PG_TM_MAN_PREFIX,
19577c478bdstevel@tonic-gate		    strlen(SCF_PG_TM_MAN_PREFIX)) == 0) {
19587c478bdstevel@tonic-gate			print_manpage(verbose);
19597c478bdstevel@tonic-gate			continue;
19607c478bdstevel@tonic-gate		}
19617c478bdstevel@tonic-gate
19627c478bdstevel@tonic-gate		if (strncmp(g_fmri, SCF_PG_TM_DOC_PREFIX,
19637c478bdstevel@tonic-gate		    strlen(SCF_PG_TM_DOC_PREFIX)) == 0) {
19647c478bdstevel@tonic-gate			print_doclink();
19657c478bdstevel@tonic-gate			continue;
19667c478bdstevel@tonic-gate		}
19677c478bdstevel@tonic-gate	}
19687c478bdstevel@tonic-gate	return (0);
19697c478bdstevel@tonic-gate}
19707c478bdstevel@tonic-gate
19717c478bdstevel@tonic-gatestatic int first = 1;
19727c478bdstevel@tonic-gate
19737c478bdstevel@tonic-gate/*
19747c478bdstevel@tonic-gate * Explain why the given service is in the state it's in.
19757c478bdstevel@tonic-gate */
19767c478bdstevel@tonic-gatestatic void
19777c478bdstevel@tonic-gateprint_service(inst_t *svcp, int verbose)
19787c478bdstevel@tonic-gate{
19797c478bdstevel@tonic-gate	struct svcptr *spp;
19807c478bdstevel@tonic-gate	time_t stime;
19817c478bdstevel@tonic-gate	char *timebuf;
19827c478bdstevel@tonic-gate	size_t tbsz;
19837c478bdstevel@tonic-gate	struct tm *tmp;
19847c478bdstevel@tonic-gate	int deleted = 0;
19857c478bdstevel@tonic-gate
19867c478bdstevel@tonic-gate	if (first)
19877c478bdstevel@tonic-gate		first = 0;
19887c478bdstevel@tonic-gate	else
19897c478bdstevel@tonic-gate		(void) putchar('\n');
19907c478bdstevel@tonic-gate
19917c478bdstevel@tonic-gate	(void) printf(gettext("svc:/%s:%s"), svcp->svcname, svcp->instname);
19927c478bdstevel@tonic-gate
19937c478bdstevel@tonic-gate	if (scf_scope_get_service(g_local_scope, svcp->svcname, g_svc) != 0) {
19947c478bdstevel@tonic-gate		if (scf_error() != SCF_ERROR_NOT_FOUND)
19957c478bdstevel@tonic-gate			scfdie();
19967c478bdstevel@tonic-gate		deleted = 1;
19977c478bdstevel@tonic-gate	} else if (scf_service_get_instance(g_svc, svcp->instname, g_inst) !=
19987c478bdstevel@tonic-gate	    0) {
19997c478bdstevel@tonic-gate		if (scf_error() != SCF_ERROR_NOT_FOUND)
20007c478bdstevel@tonic-gate			scfdie();
20017c478bdstevel@tonic-gate		deleted = 1;
20027c478bdstevel@tonic-gate	}
20037c478bdstevel@tonic-gate
20047c478bdstevel@tonic-gate	if (!deleted) {
20057c478bdstevel@tonic-gate		if (inst_get_single_val(g_inst, SCF_PG_TM_COMMON_NAME, locale,
20067c478bdstevel@tonic-gate		    SCF_TYPE_USTRING, g_value, g_value_sz, 0, 0, 1) == 0)
20077c478bdstevel@tonic-gate			/* EMPTY */;
20087c478bdstevel@tonic-gate		else if (inst_get_single_val(g_inst, SCF_PG_TM_COMMON_NAME, "C",
20097c478bdstevel@tonic-gate		    SCF_TYPE_USTRING, g_value, g_value_sz, 0, 0, 1) != 0)
20107c478bdstevel@tonic-gate			(void) strcpy(g_value, "?");
20117c478bdstevel@tonic-gate
20127c478bdstevel@tonic-gate		(void) printf(gettext(" (%s)\n"), g_value);
20137c478bdstevel@tonic-gate	} else {
20147c478bdstevel@tonic-gate		(void) putchar('\n');
20157c478bdstevel@tonic-gate	}
20167c478bdstevel@tonic-gate
2017048b027Bryan Cantrill	if (g_zonename != NULL)
2018048b027Bryan Cantrill		(void) printf(gettext("  Zone: %s\n"), g_zonename);
2019048b027Bryan Cantrill
20207c478bdstevel@tonic-gate	stime = svcp->stime.tv_sec;
20217c478bdstevel@tonic-gate	tmp = localtime(&stime);
20227c478bdstevel@tonic-gate
20237c478bdstevel@tonic-gate	for (tbsz = 50; ; tbsz *= 2) {
20247c478bdstevel@tonic-gate		timebuf = safe_malloc(tbsz);
20257c478bdstevel@tonic-gate		if (strftime(timebuf, tbsz, NULL, tmp) != 0)
20263eae19dwesolows			break;
20277c478bdstevel@tonic-gate		free(timebuf);
20287c478bdstevel@tonic-gate	}
20297c478bdstevel@tonic-gate
20307c478bdstevel@tonic-gate	(void) printf(gettext(" State: %s since %s\n"), svcp->state, timebuf);
20317c478bdstevel@tonic-gate
20327c478bdstevel@tonic-gate	free(timebuf);
20337c478bdstevel@tonic-gate
20347c478bdstevel@tonic-gate	/* Reasons */
20357c478bdstevel@tonic-gate	print_reasons(svcp, verbose);
20367c478bdstevel@tonic-gate
20377c478bdstevel@tonic-gate	if (!deleted)
20387c478bdstevel@tonic-gate		deleted = print_docs(g_inst, verbose);
20397c478bdstevel@tonic-gate	if (!deleted)
20407c478bdstevel@tonic-gate		print_logs(g_inst);
20417c478bdstevel@tonic-gate
20427c478bdstevel@tonic-gate	(void) determine_impact(svcp);
20437c478bdstevel@tonic-gate
20447c478bdstevel@tonic-gate	switch (uu_list_numnodes(svcp->impact)) {
20457c478bdstevel@tonic-gate	case 0:
20467c478bdstevel@tonic-gate		if (inst_running(svcp))
20477c478bdstevel@tonic-gate			(void) puts(gettext("Impact: None."));
20487c478bdstevel@tonic-gate		else
20497c478bdstevel@tonic-gate			(void) puts(gettext(
20507c478bdstevel@tonic-gate			    "Impact: This service is not running."));
20517c478bdstevel@tonic-gate		break;
20527c478bdstevel@tonic-gate
20537c478bdstevel@tonic-gate	case 1:
20547c478bdstevel@tonic-gate		if (!verbose)
20557c478bdstevel@tonic-gate			(void) puts(gettext("Impact: 1 dependent service "
20567c478bdstevel@tonic-gate			    "is not running.  (Use -v for list.)"));
20577c478bdstevel@tonic-gate		else
20587c478bdstevel@tonic-gate			(void) puts(gettext(
20597c478bdstevel@tonic-gate			    "Impact: 1 dependent service is not running:"));
20607c478bdstevel@tonic-gate		break;
20617c478bdstevel@tonic-gate
20627c478bdstevel@tonic-gate	default:
20637c478bdstevel@tonic-gate		if (!verbose)
20647c478bdstevel@tonic-gate			(void) printf(gettext("Impact: %d dependent services "
20657c478bdstevel@tonic-gate			    "are not running.  (Use -v for list.)\n"),
20667c478bdstevel@tonic-gate			    uu_list_numnodes(svcp->impact));
20677c478bdstevel@tonic-gate		else
20687c478bdstevel@tonic-gate			(void) printf(gettext(
20697c478bdstevel@tonic-gate			    "Impact: %d dependent services are not running:\n"),
20707c478bdstevel@tonic-gate			    uu_list_numnodes(svcp->impact));
20717c478bdstevel@tonic-gate	}
20727c478bdstevel@tonic-gate
20737c478bdstevel@tonic-gate	if (verbose) {
20747c478bdstevel@tonic-gate		for (spp = uu_list_first(svcp->impact);
20757c478bdstevel@tonic-gate		    spp != NULL;
20767c478bdstevel@tonic-gate		    spp = uu_list_next(svcp->impact, spp))
20777c478bdstevel@tonic-gate			(void) printf(gettext("        svc:/%s:%s\n"),
20787c478bdstevel@tonic-gate			    spp->svcp->svcname, spp->svcp->instname);
20797c478bdstevel@tonic-gate	}
20807c478bdstevel@tonic-gate}
20817c478bdstevel@tonic-gate
20827c478bdstevel@tonic-gate/*
20837c478bdstevel@tonic-gate * Top level routine.
20847c478bdstevel@tonic-gate */
20857c478bdstevel@tonic-gate
20867c478bdstevel@tonic-gatestatic int
20877c478bdstevel@tonic-gateimpact_compar(const void *a, const void *b)
20887c478bdstevel@tonic-gate{
20897c478bdstevel@tonic-gate	int n, m;
20907c478bdstevel@tonic-gate
20917c478bdstevel@tonic-gate	n = uu_list_numnodes((*(inst_t **)a)->impact);
20927c478bdstevel@tonic-gate	m = uu_list_numnodes((*(inst_t **)b)->impact);
20937c478bdstevel@tonic-gate
20947c478bdstevel@tonic-gate	return (m - n);
20957c478bdstevel@tonic-gate}
20967c478bdstevel@tonic-gate
20977c478bdstevel@tonic-gatestatic int
20987c478bdstevel@tonic-gateprint_service_cb(void *verbose, scf_walkinfo_t *wip)
20997c478bdstevel@tonic-gate{
21007c478bdstevel@tonic-gate	int r;
21017c478bdstevel@tonic-gate	inst_t *ip;
21027c478bdstevel@tonic-gate
21037c478bdstevel@tonic-gate	assert(wip->pg == NULL);
21047c478bdstevel@tonic-gate
21057c478bdstevel@tonic-gate	r = get_fmri(wip->fmri, NULL, &ip);
21067c478bdstevel@tonic-gate	assert(r != EINVAL);
21077c478bdstevel@tonic-gate	if (r == ENOENT)
21087c478bdstevel@tonic-gate		return (0);
21097c478bdstevel@tonic-gate
21107c478bdstevel@tonic-gate	assert(r == 0);
21117c478bdstevel@tonic-gate	assert(ip != NULL);
21127c478bdstevel@tonic-gate
21137c478bdstevel@tonic-gate	print_service(ip, (int)verbose);
21147c478bdstevel@tonic-gate
21157c478bdstevel@tonic-gate	return (0);
21167c478bdstevel@tonic-gate}
21177c478bdstevel@tonic-gate
21187c478bdstevel@tonic-gatevoid
21197c478bdstevel@tonic-gateexplain(int verbose, int argc, char **argv)
21207c478bdstevel@tonic-gate{
2121048b027Bryan Cantrill	/*
2122048b027Bryan Cantrill	 * Initialize globals.  If we have been called before (e.g., for a
2123048b027Bryan Cantrill	 * different zone), this will clobber the previous globals -- keeping
2124048b027Bryan Cantrill	 * with the proud svcs(1) tradition of not bothering to ever clean
2125048b027Bryan Cantrill	 * anything up.
2126048b027Bryan Cantrill	 */
21277c478bdstevel@tonic-gate	x_init();
21287c478bdstevel@tonic-gate
21297c478bdstevel@tonic-gate	/* Walk the graph and populate services with inst_t's */
21307c478bdstevel@tonic-gate	load_services();
21317c478bdstevel@tonic-gate
21327c478bdstevel@tonic-gate	/* Populate causes for services. */
21337c478bdstevel@tonic-gate	determine_all_causes();
21347c478bdstevel@tonic-gate
21357c478bdstevel@tonic-gate	if (argc > 0) {
21367c478bdstevel@tonic-gate		scf_error_t err;
21377c478bdstevel@tonic-gate
21387c478bdstevel@tonic-gate		check_msgbase();
21397c478bdstevel@tonic-gate
21407c478bdstevel@tonic-gate		/* Call print_service() for each operand. */
21417c478bdstevel@tonic-gate
21427c478bdstevel@tonic-gate		err = scf_walk_fmri(h, argc, argv, SCF_WALK_MULTIPLE,
21437c478bdstevel@tonic-gate		    print_service_cb, (void *)verbose, &exit_status, uu_warn);
21447c478bdstevel@tonic-gate		if (err != 0) {
21457c478bdstevel@tonic-gate			uu_warn(gettext(
21467c478bdstevel@tonic-gate			    "failed to iterate over instances: %s\n"),
21477c478bdstevel@tonic-gate			    scf_strerror(err));
21487c478bdstevel@tonic-gate			exit_status = UU_EXIT_FATAL;
21497c478bdstevel@tonic-gate		}
21507c478bdstevel@tonic-gate	} else {
21517c478bdstevel@tonic-gate		struct svcptr *spp;
21527c478bdstevel@tonic-gate		int n, i;
21537c478bdstevel@tonic-gate		inst_t **ary;
21547c478bdstevel@tonic-gate
21557c478bdstevel@tonic-gate		/* Sort g_causes. */
21567c478bdstevel@tonic-gate
21577c478bdstevel@tonic-gate		n = uu_list_numnodes(g_causes);
21587c478bdstevel@tonic-gate		if (n == 0)
21597c478bdstevel@tonic-gate			return;
21607c478bdstevel@tonic-gate
21617c478bdstevel@tonic-gate		check_msgbase();
21627c478bdstevel@tonic-gate
21637c478bdstevel@tonic-gate		ary = calloc(n, sizeof (*ary));
21647c478bdstevel@tonic-gate		if (ary == NULL)
21657c478bdstevel@tonic-gate			uu_die(emsg_nomem);
21667c478bdstevel@tonic-gate
21677c478bdstevel@tonic-gate		i = 0;
21687c478bdstevel@tonic-gate		for (spp = uu_list_first(g_causes);
21697c478bdstevel@tonic-gate		    spp != NULL;
21707c478bdstevel@tonic-gate		    spp = uu_list_next(g_causes, spp)) {
21717c478bdstevel@tonic-gate			(void) determine_impact(spp->svcp);
21727c478bdstevel@tonic-gate			ary[i++] = spp->svcp;
21737c478bdstevel@tonic-gate		}
21747c478bdstevel@tonic-gate
21757c478bdstevel@tonic-gate		qsort(ary, n, sizeof (*ary), impact_compar);
21767c478bdstevel@tonic-gate
21777c478bdstevel@tonic-gate		/* Call print_service() for each service. */
21787c478bdstevel@tonic-gate
21797c478bdstevel@tonic-gate		for (i = 0; i < n; ++i)
21807c478bdstevel@tonic-gate			print_service(ary[i], verbose);
21817c478bdstevel@tonic-gate	}
21827c478bdstevel@tonic-gate}
2183