17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 57646ae23Slianep * Common Development and Distribution License (the "License"). 67646ae23Slianep * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22eb1a3463STruong Nguyen * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 26647f8444SBryan Cantrill /* 27*54d02241SBryan Cantrill * Copyright 2015, Joyent, Inc. All rights reserved. 28647f8444SBryan Cantrill */ 29647f8444SBryan Cantrill 307c478bd9Sstevel@tonic-gate /* 317c478bd9Sstevel@tonic-gate * svcadm - request adminstrative actions for service instances 327c478bd9Sstevel@tonic-gate */ 337c478bd9Sstevel@tonic-gate 347c478bd9Sstevel@tonic-gate #include <locale.h> 357c478bd9Sstevel@tonic-gate #include <libintl.h> 367c478bd9Sstevel@tonic-gate #include <libscf.h> 377c478bd9Sstevel@tonic-gate #include <libscf_priv.h> 38eb1a3463STruong Nguyen #include <libcontract.h> 39eb1a3463STruong Nguyen #include <libcontract_priv.h> 40eb1a3463STruong Nguyen #include <sys/contract/process.h> 417c478bd9Sstevel@tonic-gate #include <libuutil.h> 427c478bd9Sstevel@tonic-gate #include <stddef.h> 437c478bd9Sstevel@tonic-gate #include <stdio.h> 447c478bd9Sstevel@tonic-gate #include <stdlib.h> 457c478bd9Sstevel@tonic-gate #include <string.h> 467c478bd9Sstevel@tonic-gate #include <unistd.h> 47eb1a3463STruong Nguyen #include <fcntl.h> 48eb1a3463STruong Nguyen #include <procfs.h> 497c478bd9Sstevel@tonic-gate #include <assert.h> 507c478bd9Sstevel@tonic-gate #include <errno.h> 51647f8444SBryan Cantrill #include <zone.h> 527c478bd9Sstevel@tonic-gate 537c478bd9Sstevel@tonic-gate #ifndef TEXT_DOMAIN 547c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SUNW_OST_OSCMD" 557c478bd9Sstevel@tonic-gate #endif /* TEXT_DOMAIN */ 567c478bd9Sstevel@tonic-gate 577c478bd9Sstevel@tonic-gate /* Must be a power of two */ 587c478bd9Sstevel@tonic-gate #define HT_BUCKETS 64 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate /* 617c478bd9Sstevel@tonic-gate * Exit codes for enable and disable -s. 627c478bd9Sstevel@tonic-gate */ 637c478bd9Sstevel@tonic-gate #define EXIT_SVC_FAILURE 3 647c478bd9Sstevel@tonic-gate #define EXIT_DEP_FAILURE 4 657c478bd9Sstevel@tonic-gate 666c7c876cSJerry Jelinek #define WALK_FLAGS (SCF_WALK_UNIPARTIAL | SCF_WALK_MULTIPLE) 676c7c876cSJerry Jelinek 687c478bd9Sstevel@tonic-gate /* 697c478bd9Sstevel@tonic-gate * How long we will wait (in seconds) for a service to change state 707c478bd9Sstevel@tonic-gate * before re-checking its dependencies. 717c478bd9Sstevel@tonic-gate */ 727c478bd9Sstevel@tonic-gate #define WAIT_INTERVAL 3 737c478bd9Sstevel@tonic-gate 74*54d02241SBryan Cantrill #define bad_error(func, err) \ 75*54d02241SBryan Cantrill uu_panic("%s:%d: %s() failed with unexpected error %d.\n", \ 76*54d02241SBryan Cantrill __FILE__, __LINE__, (func), (err)); 777c478bd9Sstevel@tonic-gate 787c478bd9Sstevel@tonic-gate struct ht_elt { 797c478bd9Sstevel@tonic-gate struct ht_elt *next; 807c478bd9Sstevel@tonic-gate boolean_t active; 817c478bd9Sstevel@tonic-gate char str[1]; 827c478bd9Sstevel@tonic-gate }; 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate 857c478bd9Sstevel@tonic-gate scf_handle_t *h; 867c478bd9Sstevel@tonic-gate ssize_t max_scf_fmri_sz; 877c478bd9Sstevel@tonic-gate static const char *emsg_permission_denied; 887c478bd9Sstevel@tonic-gate static const char *emsg_nomem; 897c478bd9Sstevel@tonic-gate static const char *emsg_create_pg_perm_denied; 907c478bd9Sstevel@tonic-gate static const char *emsg_pg_perm_denied; 917c478bd9Sstevel@tonic-gate static const char *emsg_prop_perm_denied; 927c478bd9Sstevel@tonic-gate static const char *emsg_no_service; 937c478bd9Sstevel@tonic-gate 947c478bd9Sstevel@tonic-gate static int exit_status = 0; 957c478bd9Sstevel@tonic-gate static int verbose = 0; 967c478bd9Sstevel@tonic-gate static char *scratch_fmri; 97702a871aSJerry Jelinek static char *g_zonename = NULL; 9837b40227SJerry Jelinek static char svcstate[80]; 9937b40227SJerry Jelinek static boolean_t svcsearch = B_FALSE; 1007c478bd9Sstevel@tonic-gate 1017c478bd9Sstevel@tonic-gate static struct ht_elt **visited; 1027c478bd9Sstevel@tonic-gate 1030b5c9250Shg void do_scfdie(int lineno) __NORETURN; 1040b5c9250Shg static void usage_milestone(void) __NORETURN; 105eb1a3463STruong Nguyen static void set_astring_prop(const char *, const char *, const char *, 106eb1a3463STruong Nguyen uint32_t, const char *, const char *); 107702a871aSJerry Jelinek static void pr_warn(const char *format, ...); 1080b5c9250Shg 1097c478bd9Sstevel@tonic-gate /* 1107c478bd9Sstevel@tonic-gate * Visitors from synch.c, needed for enable -s and disable -s. 1117c478bd9Sstevel@tonic-gate */ 1127c478bd9Sstevel@tonic-gate extern int is_enabled(scf_instance_t *); 1137c478bd9Sstevel@tonic-gate extern int has_potential(scf_instance_t *, int); 1147c478bd9Sstevel@tonic-gate 1157c478bd9Sstevel@tonic-gate void 1167c478bd9Sstevel@tonic-gate do_scfdie(int lineno) 1177c478bd9Sstevel@tonic-gate { 1187c478bd9Sstevel@tonic-gate scf_error_t err; 1197c478bd9Sstevel@tonic-gate 1207c478bd9Sstevel@tonic-gate switch (err = scf_error()) { 1217c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN: 1227c478bd9Sstevel@tonic-gate uu_die(gettext("Connection to repository server broken. " 1237c478bd9Sstevel@tonic-gate "Exiting.\n")); 1247c478bd9Sstevel@tonic-gate /* NOTREACHED */ 1257c478bd9Sstevel@tonic-gate 1267c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY: 1277c478bd9Sstevel@tonic-gate uu_die(gettext("Repository is read-only. Exiting.\n")); 1287c478bd9Sstevel@tonic-gate /* NOTREACHED */ 1297c478bd9Sstevel@tonic-gate 1307c478bd9Sstevel@tonic-gate default: 1317c478bd9Sstevel@tonic-gate #ifdef NDEBUG 1327c478bd9Sstevel@tonic-gate uu_die(gettext("Unexpected libscf error: %s. Exiting.\n"), 1337c478bd9Sstevel@tonic-gate scf_strerror(err)); 1347c478bd9Sstevel@tonic-gate #else 1357c478bd9Sstevel@tonic-gate uu_die("Unexpected libscf error on line %d: %s.\n", lineno, 1367c478bd9Sstevel@tonic-gate scf_strerror(err)); 1377c478bd9Sstevel@tonic-gate #endif 1387c478bd9Sstevel@tonic-gate } 1397c478bd9Sstevel@tonic-gate } 1407c478bd9Sstevel@tonic-gate 1417c478bd9Sstevel@tonic-gate #define scfdie() do_scfdie(__LINE__) 1427c478bd9Sstevel@tonic-gate 1437c478bd9Sstevel@tonic-gate static void 1447c478bd9Sstevel@tonic-gate usage() 1457c478bd9Sstevel@tonic-gate { 1467c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 14737b40227SJerry Jelinek "Usage: %1$s [-S <state>] [-v] [-Z | -z zone] [cmd [args ... ]]\n\n" 14837b40227SJerry Jelinek "\t%1$s enable [-rst] [<service> ...]\t- enable and online service(s)\n" 14937b40227SJerry Jelinek "\t%1$s disable [-st] [<service> ...]\t- disable and offline " 15037b40227SJerry Jelinek "service(s)\n" 151ac0324d2SJerry Jelinek "\t%1$s restart [-d] [<service> ...]\t- restart specified service(s)\n" 15237b40227SJerry Jelinek "\t%1$s refresh [<service> ...]\t\t- re-read service configuration\n" 15337b40227SJerry Jelinek "\t%1$s mark [-It] <state> [<service> ...] - set maintenance state\n" 15437b40227SJerry Jelinek "\t%1$s clear [<service> ...]\t\t- clear maintenance state\n" 1557c478bd9Sstevel@tonic-gate "\t%1$s milestone [-d] <milestone>\t- advance to a service milestone\n" 1567c478bd9Sstevel@tonic-gate "\n\t" 1577c478bd9Sstevel@tonic-gate "Services can be specified using an FMRI, abbreviation, or fnmatch(5)\n" 1587c478bd9Sstevel@tonic-gate "\tpattern, as shown in these examples for svc:/network/smtp:sendmail\n" 1597c478bd9Sstevel@tonic-gate "\n" 1607c478bd9Sstevel@tonic-gate "\t%1$s <cmd> svc:/network/smtp:sendmail\n" 1617c478bd9Sstevel@tonic-gate "\t%1$s <cmd> network/smtp:sendmail\n" 1627c478bd9Sstevel@tonic-gate "\t%1$s <cmd> network/*mail\n" 1637c478bd9Sstevel@tonic-gate "\t%1$s <cmd> network/smtp\n" 1647c478bd9Sstevel@tonic-gate "\t%1$s <cmd> smtp:sendmail\n" 1657c478bd9Sstevel@tonic-gate "\t%1$s <cmd> smtp\n" 1667c478bd9Sstevel@tonic-gate "\t%1$s <cmd> sendmail\n"), uu_getpname()); 1677c478bd9Sstevel@tonic-gate 1687c478bd9Sstevel@tonic-gate exit(UU_EXIT_USAGE); 1697c478bd9Sstevel@tonic-gate } 1707c478bd9Sstevel@tonic-gate 1717c478bd9Sstevel@tonic-gate 1727c478bd9Sstevel@tonic-gate /* 1737c478bd9Sstevel@tonic-gate * FMRI hash table for recursive enable. 1747c478bd9Sstevel@tonic-gate */ 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate static uint32_t 1777c478bd9Sstevel@tonic-gate hash_fmri(const char *str) 1787c478bd9Sstevel@tonic-gate { 1797c478bd9Sstevel@tonic-gate uint32_t h = 0, g; 1807c478bd9Sstevel@tonic-gate const char *p; 1817c478bd9Sstevel@tonic-gate 1827c478bd9Sstevel@tonic-gate /* Generic hash function from uts/common/os/modhash.c . */ 1837c478bd9Sstevel@tonic-gate for (p = str; *p != '\0'; ++p) { 1847c478bd9Sstevel@tonic-gate h = (h << 4) + *p; 1857c478bd9Sstevel@tonic-gate if ((g = (h & 0xf0000000)) != 0) { 1867c478bd9Sstevel@tonic-gate h ^= (g >> 24); 1877c478bd9Sstevel@tonic-gate h ^= g; 1887c478bd9Sstevel@tonic-gate } 1897c478bd9Sstevel@tonic-gate } 1907c478bd9Sstevel@tonic-gate 1917c478bd9Sstevel@tonic-gate return (h); 1927c478bd9Sstevel@tonic-gate } 1937c478bd9Sstevel@tonic-gate 1947c478bd9Sstevel@tonic-gate /* 1957c478bd9Sstevel@tonic-gate * Return 1 if str has been visited, 0 if it has not, and -1 if memory could not 1967c478bd9Sstevel@tonic-gate * be allocated. 1977c478bd9Sstevel@tonic-gate */ 1987c478bd9Sstevel@tonic-gate static int 1997c478bd9Sstevel@tonic-gate visited_find_or_add(const char *str, struct ht_elt **hep) 2007c478bd9Sstevel@tonic-gate { 2017c478bd9Sstevel@tonic-gate uint32_t h; 2027c478bd9Sstevel@tonic-gate uint_t i; 2037c478bd9Sstevel@tonic-gate struct ht_elt *he; 2047c478bd9Sstevel@tonic-gate 2057c478bd9Sstevel@tonic-gate h = hash_fmri(str); 2067c478bd9Sstevel@tonic-gate i = h & (HT_BUCKETS - 1); 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate for (he = visited[i]; he != NULL; he = he->next) { 2097c478bd9Sstevel@tonic-gate if (strcmp(he->str, str) == 0) { 2107c478bd9Sstevel@tonic-gate if (hep) 2117c478bd9Sstevel@tonic-gate *hep = he; 2127c478bd9Sstevel@tonic-gate return (1); 2137c478bd9Sstevel@tonic-gate } 2147c478bd9Sstevel@tonic-gate } 2157c478bd9Sstevel@tonic-gate 2167c478bd9Sstevel@tonic-gate he = malloc(offsetof(struct ht_elt, str) + strlen(str) + 1); 2177c478bd9Sstevel@tonic-gate if (he == NULL) 2187c478bd9Sstevel@tonic-gate return (-1); 2197c478bd9Sstevel@tonic-gate 2207c478bd9Sstevel@tonic-gate (void) strcpy(he->str, str); 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate he->next = visited[i]; 2237c478bd9Sstevel@tonic-gate visited[i] = he; 2247c478bd9Sstevel@tonic-gate 2257c478bd9Sstevel@tonic-gate if (hep) 2267c478bd9Sstevel@tonic-gate *hep = he; 2277c478bd9Sstevel@tonic-gate return (0); 2287c478bd9Sstevel@tonic-gate } 2297c478bd9Sstevel@tonic-gate 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate /* 2327c478bd9Sstevel@tonic-gate * Returns 0, ECANCELED if pg is deleted, ENOENT if propname doesn't exist, 2337c478bd9Sstevel@tonic-gate * EINVAL if the property is not of boolean type or has no values, and E2BIG 2347c478bd9Sstevel@tonic-gate * if it has more than one value. *bp is set if 0 or E2BIG is returned. 2357c478bd9Sstevel@tonic-gate */ 2367c478bd9Sstevel@tonic-gate int 2377c478bd9Sstevel@tonic-gate get_bool_prop(scf_propertygroup_t *pg, const char *propname, uint8_t *bp) 2387c478bd9Sstevel@tonic-gate { 2397c478bd9Sstevel@tonic-gate scf_property_t *prop; 2407c478bd9Sstevel@tonic-gate scf_value_t *val; 2417c478bd9Sstevel@tonic-gate int ret; 2427c478bd9Sstevel@tonic-gate 2437c478bd9Sstevel@tonic-gate if ((prop = scf_property_create(h)) == NULL || 2447c478bd9Sstevel@tonic-gate (val = scf_value_create(h)) == NULL) 2457c478bd9Sstevel@tonic-gate scfdie(); 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, propname, prop) != 0) { 2487c478bd9Sstevel@tonic-gate switch (scf_error()) { 2497c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED: 2507c478bd9Sstevel@tonic-gate ret = ECANCELED; 2517c478bd9Sstevel@tonic-gate goto out; 2527c478bd9Sstevel@tonic-gate 2537c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 2547c478bd9Sstevel@tonic-gate ret = ENOENT; 2557c478bd9Sstevel@tonic-gate goto out; 2567c478bd9Sstevel@tonic-gate 2577c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET: 2587c478bd9Sstevel@tonic-gate assert(0); 2597c478bd9Sstevel@tonic-gate abort(); 2607c478bd9Sstevel@tonic-gate /* NOTREACHED */ 2617c478bd9Sstevel@tonic-gate 2627c478bd9Sstevel@tonic-gate default: 2637c478bd9Sstevel@tonic-gate scfdie(); 2647c478bd9Sstevel@tonic-gate } 2657c478bd9Sstevel@tonic-gate } 2667c478bd9Sstevel@tonic-gate 2677c478bd9Sstevel@tonic-gate if (scf_property_get_value(prop, val) == 0) { 2687c478bd9Sstevel@tonic-gate ret = 0; 2697c478bd9Sstevel@tonic-gate } else { 2707c478bd9Sstevel@tonic-gate switch (scf_error()) { 2717c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED: 2727c478bd9Sstevel@tonic-gate ret = ENOENT; 2737c478bd9Sstevel@tonic-gate goto out; 2747c478bd9Sstevel@tonic-gate 2757c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 2767c478bd9Sstevel@tonic-gate ret = EINVAL; 2777c478bd9Sstevel@tonic-gate goto out; 2787c478bd9Sstevel@tonic-gate 2797c478bd9Sstevel@tonic-gate case SCF_ERROR_CONSTRAINT_VIOLATED: 2807c478bd9Sstevel@tonic-gate ret = E2BIG; 2817c478bd9Sstevel@tonic-gate break; 2827c478bd9Sstevel@tonic-gate 2837c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET: 2847c478bd9Sstevel@tonic-gate assert(0); 2857c478bd9Sstevel@tonic-gate abort(); 2867c478bd9Sstevel@tonic-gate /* NOTREACHED */ 2877c478bd9Sstevel@tonic-gate 2887c478bd9Sstevel@tonic-gate default: 2897c478bd9Sstevel@tonic-gate scfdie(); 2907c478bd9Sstevel@tonic-gate } 2917c478bd9Sstevel@tonic-gate } 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate if (scf_value_get_boolean(val, bp) != 0) { 2947c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_TYPE_MISMATCH) 2957c478bd9Sstevel@tonic-gate scfdie(); 2967c478bd9Sstevel@tonic-gate 2977c478bd9Sstevel@tonic-gate ret = EINVAL; 2987c478bd9Sstevel@tonic-gate goto out; 2997c478bd9Sstevel@tonic-gate } 3007c478bd9Sstevel@tonic-gate 3017c478bd9Sstevel@tonic-gate out: 3027c478bd9Sstevel@tonic-gate scf_value_destroy(val); 3037c478bd9Sstevel@tonic-gate scf_property_destroy(prop); 3047c478bd9Sstevel@tonic-gate return (ret); 3057c478bd9Sstevel@tonic-gate } 3067c478bd9Sstevel@tonic-gate 3077c478bd9Sstevel@tonic-gate /* 3087c478bd9Sstevel@tonic-gate * Returns 0, EPERM, or EROFS. 3097c478bd9Sstevel@tonic-gate */ 3107c478bd9Sstevel@tonic-gate static int 3117c478bd9Sstevel@tonic-gate set_bool_prop(scf_propertygroup_t *pg, const char *propname, boolean_t b) 3127c478bd9Sstevel@tonic-gate { 3137c478bd9Sstevel@tonic-gate scf_value_t *v; 3147c478bd9Sstevel@tonic-gate scf_transaction_t *tx; 3157c478bd9Sstevel@tonic-gate scf_transaction_entry_t *ent; 3167c478bd9Sstevel@tonic-gate int ret = 0, r; 3177c478bd9Sstevel@tonic-gate 3187c478bd9Sstevel@tonic-gate if ((tx = scf_transaction_create(h)) == NULL || 3197c478bd9Sstevel@tonic-gate (ent = scf_entry_create(h)) == NULL || 3207c478bd9Sstevel@tonic-gate (v = scf_value_create(h)) == NULL) 3217c478bd9Sstevel@tonic-gate scfdie(); 3227c478bd9Sstevel@tonic-gate 3237c478bd9Sstevel@tonic-gate scf_value_set_boolean(v, b); 3247c478bd9Sstevel@tonic-gate 3257c478bd9Sstevel@tonic-gate for (;;) { 3267c478bd9Sstevel@tonic-gate if (scf_transaction_start(tx, pg) == -1) { 3277c478bd9Sstevel@tonic-gate switch (scf_error()) { 3287c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED: 3297c478bd9Sstevel@tonic-gate ret = EPERM; 3307c478bd9Sstevel@tonic-gate goto out; 3317c478bd9Sstevel@tonic-gate 3327c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY: 3337c478bd9Sstevel@tonic-gate ret = EROFS; 3347c478bd9Sstevel@tonic-gate goto out; 3357c478bd9Sstevel@tonic-gate 3367c478bd9Sstevel@tonic-gate default: 3377c478bd9Sstevel@tonic-gate scfdie(); 3387c478bd9Sstevel@tonic-gate } 3397c478bd9Sstevel@tonic-gate } 3407c478bd9Sstevel@tonic-gate 3417c478bd9Sstevel@tonic-gate if (scf_transaction_property_change_type(tx, ent, propname, 3427c478bd9Sstevel@tonic-gate SCF_TYPE_BOOLEAN) != 0) { 3437c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 3447c478bd9Sstevel@tonic-gate scfdie(); 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate if (scf_transaction_property_new(tx, ent, propname, 3477c478bd9Sstevel@tonic-gate SCF_TYPE_BOOLEAN) != 0) 3487c478bd9Sstevel@tonic-gate scfdie(); 3497c478bd9Sstevel@tonic-gate } 3507c478bd9Sstevel@tonic-gate 3517c478bd9Sstevel@tonic-gate r = scf_entry_add_value(ent, v); 3527c478bd9Sstevel@tonic-gate assert(r == 0); 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate r = scf_transaction_commit(tx); 3557c478bd9Sstevel@tonic-gate if (r == 1) 3567c478bd9Sstevel@tonic-gate break; 3577c478bd9Sstevel@tonic-gate 3587c478bd9Sstevel@tonic-gate scf_transaction_reset(tx); 3597c478bd9Sstevel@tonic-gate 3607c478bd9Sstevel@tonic-gate if (r != 0) { 3617c478bd9Sstevel@tonic-gate switch (scf_error()) { 3627c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED: 3637c478bd9Sstevel@tonic-gate ret = EPERM; 3647c478bd9Sstevel@tonic-gate goto out; 3657c478bd9Sstevel@tonic-gate 3667c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY: 3677c478bd9Sstevel@tonic-gate ret = EROFS; 3687c478bd9Sstevel@tonic-gate goto out; 3697c478bd9Sstevel@tonic-gate 3707c478bd9Sstevel@tonic-gate default: 3717c478bd9Sstevel@tonic-gate scfdie(); 3727c478bd9Sstevel@tonic-gate } 3737c478bd9Sstevel@tonic-gate } 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate if (scf_pg_update(pg) == -1) 3767c478bd9Sstevel@tonic-gate scfdie(); 3777c478bd9Sstevel@tonic-gate } 3787c478bd9Sstevel@tonic-gate 3797c478bd9Sstevel@tonic-gate out: 3807c478bd9Sstevel@tonic-gate scf_transaction_destroy(tx); 3817c478bd9Sstevel@tonic-gate scf_entry_destroy(ent); 3827c478bd9Sstevel@tonic-gate scf_value_destroy(v); 3837c478bd9Sstevel@tonic-gate return (ret); 3847c478bd9Sstevel@tonic-gate } 3857c478bd9Sstevel@tonic-gate 3867c478bd9Sstevel@tonic-gate /* 3877c478bd9Sstevel@tonic-gate * Gets the single astring value of the propname property of pg. prop & v are 3887c478bd9Sstevel@tonic-gate * scratch space. Returns the length of the string on success or 3897c478bd9Sstevel@tonic-gate * -ENOENT - pg has no property named propname 3907c478bd9Sstevel@tonic-gate * -E2BIG - property has no values or multiple values 3917c478bd9Sstevel@tonic-gate * -EINVAL - property type is not compatible with astring 3927c478bd9Sstevel@tonic-gate */ 3937c478bd9Sstevel@tonic-gate ssize_t 3947c478bd9Sstevel@tonic-gate get_astring_prop(const scf_propertygroup_t *pg, const char *propname, 3957c478bd9Sstevel@tonic-gate scf_property_t *prop, scf_value_t *v, char *buf, size_t bufsz) 3967c478bd9Sstevel@tonic-gate { 3977c478bd9Sstevel@tonic-gate ssize_t sz; 3987c478bd9Sstevel@tonic-gate 3997c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, propname, prop) != 0) { 4007c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 4017c478bd9Sstevel@tonic-gate scfdie(); 4027c478bd9Sstevel@tonic-gate 4037c478bd9Sstevel@tonic-gate return (-ENOENT); 4047c478bd9Sstevel@tonic-gate } 4057c478bd9Sstevel@tonic-gate 4067c478bd9Sstevel@tonic-gate if (scf_property_get_value(prop, v) != 0) { 4077c478bd9Sstevel@tonic-gate switch (scf_error()) { 4087c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 4097c478bd9Sstevel@tonic-gate case SCF_ERROR_CONSTRAINT_VIOLATED: 4107c478bd9Sstevel@tonic-gate return (-E2BIG); 4117c478bd9Sstevel@tonic-gate 4127c478bd9Sstevel@tonic-gate default: 4137c478bd9Sstevel@tonic-gate scfdie(); 4147c478bd9Sstevel@tonic-gate } 4157c478bd9Sstevel@tonic-gate } 4167c478bd9Sstevel@tonic-gate 4177c478bd9Sstevel@tonic-gate sz = scf_value_get_astring(v, buf, bufsz); 4187c478bd9Sstevel@tonic-gate if (sz < 0) { 4197c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_TYPE_MISMATCH) 4207c478bd9Sstevel@tonic-gate scfdie(); 4217c478bd9Sstevel@tonic-gate 4227c478bd9Sstevel@tonic-gate return (-EINVAL); 4237c478bd9Sstevel@tonic-gate } 4247c478bd9Sstevel@tonic-gate 4257c478bd9Sstevel@tonic-gate return (sz); 4267c478bd9Sstevel@tonic-gate } 4277c478bd9Sstevel@tonic-gate 4287c478bd9Sstevel@tonic-gate /* 429eb1a3463STruong Nguyen * Returns 0 or EPERM. 4307c478bd9Sstevel@tonic-gate */ 4317c478bd9Sstevel@tonic-gate static int 432eb1a3463STruong Nguyen pg_get_or_add(const scf_instance_t *inst, const char *pgname, 433eb1a3463STruong Nguyen const char *pgtype, uint32_t pgflags, scf_propertygroup_t *pg) 4347c478bd9Sstevel@tonic-gate { 435eb1a3463STruong Nguyen again: 436eb1a3463STruong Nguyen if (scf_instance_get_pg(inst, pgname, pg) == 0) 437eb1a3463STruong Nguyen return (0); 4387c478bd9Sstevel@tonic-gate 439eb1a3463STruong Nguyen if (scf_error() != SCF_ERROR_NOT_FOUND) 4407c478bd9Sstevel@tonic-gate scfdie(); 4417c478bd9Sstevel@tonic-gate 442eb1a3463STruong Nguyen if (scf_instance_add_pg(inst, pgname, pgtype, pgflags, pg) == 0) 443eb1a3463STruong Nguyen return (0); 4447c478bd9Sstevel@tonic-gate 445eb1a3463STruong Nguyen switch (scf_error()) { 446eb1a3463STruong Nguyen case SCF_ERROR_EXISTS: 447eb1a3463STruong Nguyen goto again; 4487c478bd9Sstevel@tonic-gate 449eb1a3463STruong Nguyen case SCF_ERROR_PERMISSION_DENIED: 450eb1a3463STruong Nguyen return (EPERM); 4517c478bd9Sstevel@tonic-gate 452eb1a3463STruong Nguyen default: 453eb1a3463STruong Nguyen scfdie(); 454eb1a3463STruong Nguyen /* NOTREACHED */ 455eb1a3463STruong Nguyen } 456eb1a3463STruong Nguyen } 4577c478bd9Sstevel@tonic-gate 458eb1a3463STruong Nguyen static int 459eb1a3463STruong Nguyen my_ct_name(char *out, size_t len) 460eb1a3463STruong Nguyen { 461eb1a3463STruong Nguyen ct_stathdl_t st; 462eb1a3463STruong Nguyen char *ct_fmri; 463eb1a3463STruong Nguyen ctid_t ct; 464eb1a3463STruong Nguyen int fd, errno, ret; 4657c478bd9Sstevel@tonic-gate 466eb1a3463STruong Nguyen if ((ct = getctid()) == -1) 467eb1a3463STruong Nguyen uu_die(gettext("Could not get contract id for process")); 4687c478bd9Sstevel@tonic-gate 469eb1a3463STruong Nguyen fd = contract_open(ct, "process", "status", O_RDONLY); 4707c478bd9Sstevel@tonic-gate 471eb1a3463STruong Nguyen if ((errno = ct_status_read(fd, CTD_ALL, &st)) != 0) 472eb1a3463STruong Nguyen uu_warn(gettext("Could not read status of contract " 473eb1a3463STruong Nguyen "%ld: %s.\n"), ct, strerror(errno)); 4747c478bd9Sstevel@tonic-gate 475eb1a3463STruong Nguyen if ((errno = ct_pr_status_get_svc_fmri(st, &ct_fmri)) != 0) 476eb1a3463STruong Nguyen uu_warn(gettext("Could not get svc_fmri for contract " 477eb1a3463STruong Nguyen "%ld: %s.\n"), ct, strerror(errno)); 4787c478bd9Sstevel@tonic-gate 479eb1a3463STruong Nguyen ret = strlcpy(out, ct_fmri, len); 4807c478bd9Sstevel@tonic-gate 481eb1a3463STruong Nguyen ct_status_free(st); 482eb1a3463STruong Nguyen (void) close(fd); 4837c478bd9Sstevel@tonic-gate 4847c478bd9Sstevel@tonic-gate return (ret); 4857c478bd9Sstevel@tonic-gate } 4867c478bd9Sstevel@tonic-gate 4877c478bd9Sstevel@tonic-gate /* 488eb1a3463STruong Nguyen * Set auxiliary_tty and auxiliary_fmri properties in restarter_actions pg to 489eb1a3463STruong Nguyen * communicate whether the action is requested from a tty and the fmri of the 490eb1a3463STruong Nguyen * responsible process. 491e8f5b3f5STruong Nguyen * 492e8f5b3f5STruong Nguyen * Returns 0, EPERM, or EROFS 4937c478bd9Sstevel@tonic-gate */ 4947c478bd9Sstevel@tonic-gate static int 495eb1a3463STruong Nguyen restarter_setup(const char *fmri, const scf_instance_t *inst) 4967c478bd9Sstevel@tonic-gate { 497eb1a3463STruong Nguyen boolean_t b = B_FALSE; 498eb1a3463STruong Nguyen scf_propertygroup_t *pg = NULL; 499e8f5b3f5STruong Nguyen int ret = 0; 5007c478bd9Sstevel@tonic-gate 501eb1a3463STruong Nguyen if ((pg = scf_pg_create(h)) == NULL) 5027c478bd9Sstevel@tonic-gate scfdie(); 5037c478bd9Sstevel@tonic-gate 504eb1a3463STruong Nguyen if (pg_get_or_add(inst, SCF_PG_RESTARTER_ACTIONS, 505eb1a3463STruong Nguyen SCF_PG_RESTARTER_ACTIONS_TYPE, SCF_PG_RESTARTER_ACTIONS_FLAGS, 506e8f5b3f5STruong Nguyen pg) == EPERM) { 507e8f5b3f5STruong Nguyen if (!verbose) 508e8f5b3f5STruong Nguyen uu_warn(emsg_permission_denied, fmri); 509e8f5b3f5STruong Nguyen else 510e8f5b3f5STruong Nguyen uu_warn(emsg_create_pg_perm_denied, fmri, 511e8f5b3f5STruong Nguyen SCF_PG_RESTARTER_ACTIONS); 512e8f5b3f5STruong Nguyen 513e8f5b3f5STruong Nguyen ret = EPERM; 514e8f5b3f5STruong Nguyen goto out; 515e8f5b3f5STruong Nguyen } 5167c478bd9Sstevel@tonic-gate 517eb1a3463STruong Nguyen /* Set auxiliary_tty property */ 518eb1a3463STruong Nguyen if (isatty(STDIN_FILENO)) 519eb1a3463STruong Nguyen b = B_TRUE; 5207c478bd9Sstevel@tonic-gate 521eb1a3463STruong Nguyen /* Create and set state to disabled */ 522eb1a3463STruong Nguyen switch (set_bool_prop(pg, SCF_PROPERTY_AUX_TTY, b) != 0) { 523eb1a3463STruong Nguyen case 0: 524eb1a3463STruong Nguyen break; 525eb1a3463STruong Nguyen 526eb1a3463STruong Nguyen case EPERM: 527e8f5b3f5STruong Nguyen if (!verbose) 528e8f5b3f5STruong Nguyen uu_warn(emsg_permission_denied, fmri); 529e8f5b3f5STruong Nguyen else 530e8f5b3f5STruong Nguyen uu_warn(emsg_prop_perm_denied, fmri, 531e8f5b3f5STruong Nguyen SCF_PG_RESTARTER_ACTIONS, SCF_PROPERTY_AUX_TTY); 532e8f5b3f5STruong Nguyen 533e8f5b3f5STruong Nguyen ret = EPERM; 534e8f5b3f5STruong Nguyen goto out; 535e8f5b3f5STruong Nguyen /* NOTREACHED */ 536eb1a3463STruong Nguyen 537eb1a3463STruong Nguyen case EROFS: 538e8f5b3f5STruong Nguyen /* Shouldn't happen, but it can. */ 539e8f5b3f5STruong Nguyen if (!verbose) 540e8f5b3f5STruong Nguyen uu_warn(gettext("%s: Repository read-only.\n"), fmri); 541e8f5b3f5STruong Nguyen else 542e8f5b3f5STruong Nguyen uu_warn(gettext("%s: Could not set %s/%s " 543e8f5b3f5STruong Nguyen "(repository read-only).\n"), fmri, 544e8f5b3f5STruong Nguyen SCF_PG_RESTARTER_ACTIONS, SCF_PROPERTY_AUX_TTY); 545e8f5b3f5STruong Nguyen 546e8f5b3f5STruong Nguyen ret = EROFS; 547e8f5b3f5STruong Nguyen goto out; 548e8f5b3f5STruong Nguyen /* NOTREACHED */ 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate default: 5517c478bd9Sstevel@tonic-gate scfdie(); 5527c478bd9Sstevel@tonic-gate } 553eb1a3463STruong Nguyen 554eb1a3463STruong Nguyen if (my_ct_name(scratch_fmri, max_scf_fmri_sz) > 0) { 555eb1a3463STruong Nguyen set_astring_prop(fmri, SCF_PG_RESTARTER_ACTIONS, 556eb1a3463STruong Nguyen SCF_PG_RESTARTER_ACTIONS_TYPE, 557eb1a3463STruong Nguyen SCF_PG_RESTARTER_ACTIONS_FLAGS, 558eb1a3463STruong Nguyen SCF_PROPERTY_AUX_FMRI, scratch_fmri); 559eb1a3463STruong Nguyen } else { 560eb1a3463STruong Nguyen uu_warn(gettext("%s: Could not set %s/%s: " 561eb1a3463STruong Nguyen "my_ct_name failed.\n"), fmri, 562eb1a3463STruong Nguyen SCF_PG_RESTARTER_ACTIONS, SCF_PROPERTY_AUX_FMRI); 563eb1a3463STruong Nguyen } 564eb1a3463STruong Nguyen 565e8f5b3f5STruong Nguyen out: 566eb1a3463STruong Nguyen scf_pg_destroy(pg); 567e8f5b3f5STruong Nguyen return (ret); 5687c478bd9Sstevel@tonic-gate } 5697c478bd9Sstevel@tonic-gate 5707c478bd9Sstevel@tonic-gate /* 5717c478bd9Sstevel@tonic-gate * Enable or disable inst, per enable. If temp is true, set 5727c478bd9Sstevel@tonic-gate * general_ovr/enabled. Otherwise set general/enabled and delete 5737c478bd9Sstevel@tonic-gate * general_ovr/enabled if it exists (order is important here: we don't want the 5747c478bd9Sstevel@tonic-gate * enabled status to glitch). 5757c478bd9Sstevel@tonic-gate */ 5767c478bd9Sstevel@tonic-gate static void 5777c478bd9Sstevel@tonic-gate set_inst_enabled(const char *fmri, scf_instance_t *inst, boolean_t temp, 5787c478bd9Sstevel@tonic-gate boolean_t enable) 5797c478bd9Sstevel@tonic-gate { 5807c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg; 5817c478bd9Sstevel@tonic-gate uint8_t b; 5827c478bd9Sstevel@tonic-gate const char *pgname = NULL; /* For emsg_pg_perm_denied */ 5837c478bd9Sstevel@tonic-gate int r; 5847c478bd9Sstevel@tonic-gate 5857c478bd9Sstevel@tonic-gate pg = scf_pg_create(h); 5867c478bd9Sstevel@tonic-gate if (pg == NULL) 5877c478bd9Sstevel@tonic-gate scfdie(); 5887c478bd9Sstevel@tonic-gate 589eb1a3463STruong Nguyen if (restarter_setup(fmri, inst)) 590e8f5b3f5STruong Nguyen goto out; 591eb1a3463STruong Nguyen 592fee38f6fStn /* 593fee38f6fStn * An instance's configuration is incomplete if general/enabled 594fee38f6fStn * doesn't exist. Create both the property group and property 595fee38f6fStn * here if they don't exist. 596fee38f6fStn */ 597fee38f6fStn pgname = SCF_PG_GENERAL; 598fee38f6fStn if (pg_get_or_add(inst, pgname, SCF_PG_GENERAL_TYPE, 599fee38f6fStn SCF_PG_GENERAL_FLAGS, pg) != 0) 600fee38f6fStn goto eperm; 601fee38f6fStn 602fee38f6fStn if (get_bool_prop(pg, SCF_PROPERTY_ENABLED, &b) != 0) { 603fee38f6fStn /* Create and set state to disabled */ 604fee38f6fStn switch (set_bool_prop(pg, SCF_PROPERTY_ENABLED, B_FALSE) != 0) { 605fee38f6fStn case 0: 606fee38f6fStn break; 607fee38f6fStn 608fee38f6fStn case EPERM: 609fee38f6fStn goto eperm; 610fee38f6fStn 611fee38f6fStn case EROFS: 612fee38f6fStn /* Shouldn't happen, but it can. */ 613fee38f6fStn if (!verbose) 614fee38f6fStn uu_warn(gettext("%s: Repository read-only.\n"), 615fee38f6fStn fmri); 616fee38f6fStn else 617fee38f6fStn uu_warn(gettext("%s: Could not set %s/%s " 618fee38f6fStn "(repository read-only).\n"), fmri, 619fee38f6fStn SCF_PG_GENERAL, SCF_PROPERTY_ENABLED); 620fee38f6fStn goto out; 621fee38f6fStn 622fee38f6fStn default: 623fee38f6fStn assert(0); 624fee38f6fStn abort(); 625fee38f6fStn } 626fee38f6fStn } 627fee38f6fStn 6287c478bd9Sstevel@tonic-gate if (temp) { 6297c478bd9Sstevel@tonic-gate /* Set general_ovr/enabled */ 6307c478bd9Sstevel@tonic-gate pgname = SCF_PG_GENERAL_OVR; 6317c478bd9Sstevel@tonic-gate if (pg_get_or_add(inst, pgname, SCF_PG_GENERAL_OVR_TYPE, 6327c478bd9Sstevel@tonic-gate SCF_PG_GENERAL_OVR_FLAGS, pg) != 0) 6337c478bd9Sstevel@tonic-gate goto eperm; 6347c478bd9Sstevel@tonic-gate 6357c478bd9Sstevel@tonic-gate switch (set_bool_prop(pg, SCF_PROPERTY_ENABLED, enable) != 0) { 6367c478bd9Sstevel@tonic-gate case 0: 6377c478bd9Sstevel@tonic-gate break; 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate case EPERM: 6407c478bd9Sstevel@tonic-gate goto eperm; 6417c478bd9Sstevel@tonic-gate 6427c478bd9Sstevel@tonic-gate case EROFS: 6437c478bd9Sstevel@tonic-gate /* Shouldn't happen, but it can. */ 6447c478bd9Sstevel@tonic-gate if (!verbose) 6457c478bd9Sstevel@tonic-gate uu_warn(gettext("%s: Repository read-only.\n"), 6467c478bd9Sstevel@tonic-gate fmri); 6477c478bd9Sstevel@tonic-gate else 6487c478bd9Sstevel@tonic-gate uu_warn(gettext("%s: Could not set %s/%s " 6497c478bd9Sstevel@tonic-gate "(repository read-only).\n"), fmri, 6507c478bd9Sstevel@tonic-gate SCF_PG_GENERAL_OVR, SCF_PROPERTY_ENABLED); 6517c478bd9Sstevel@tonic-gate goto out; 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate default: 6547c478bd9Sstevel@tonic-gate assert(0); 6557c478bd9Sstevel@tonic-gate abort(); 6567c478bd9Sstevel@tonic-gate } 6577c478bd9Sstevel@tonic-gate 6587c478bd9Sstevel@tonic-gate if (verbose) 6597c478bd9Sstevel@tonic-gate (void) printf(enable ? 6607c478bd9Sstevel@tonic-gate gettext("%s temporarily enabled.\n") : 6617c478bd9Sstevel@tonic-gate gettext("%s temporarily disabled.\n"), fmri); 6627c478bd9Sstevel@tonic-gate } else { 6637c478bd9Sstevel@tonic-gate again: 664fee38f6fStn /* 665fee38f6fStn * Both pg and property should exist since we created 666fee38f6fStn * them earlier. However, there's still a chance that 667fee38f6fStn * someone may have deleted the property out from under 668fee38f6fStn * us. 669fee38f6fStn */ 6707c478bd9Sstevel@tonic-gate if (pg_get_or_add(inst, pgname, SCF_PG_GENERAL_TYPE, 6717c478bd9Sstevel@tonic-gate SCF_PG_GENERAL_FLAGS, pg) != 0) 6727c478bd9Sstevel@tonic-gate goto eperm; 6737c478bd9Sstevel@tonic-gate 6747c478bd9Sstevel@tonic-gate switch (set_bool_prop(pg, SCF_PROPERTY_ENABLED, enable)) { 6757c478bd9Sstevel@tonic-gate case 0: 6767c478bd9Sstevel@tonic-gate break; 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate case EPERM: 6797c478bd9Sstevel@tonic-gate goto eperm; 6807c478bd9Sstevel@tonic-gate 6817c478bd9Sstevel@tonic-gate case EROFS: 6827c478bd9Sstevel@tonic-gate /* 6837c478bd9Sstevel@tonic-gate * If general/enabled is already set the way we want, 6847c478bd9Sstevel@tonic-gate * proceed. 6857c478bd9Sstevel@tonic-gate */ 6867c478bd9Sstevel@tonic-gate switch (get_bool_prop(pg, SCF_PROPERTY_ENABLED, &b)) { 6877c478bd9Sstevel@tonic-gate case 0: 6887c478bd9Sstevel@tonic-gate if ((b != 0) == (enable != B_FALSE)) 6897c478bd9Sstevel@tonic-gate break; 6907c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 6917c478bd9Sstevel@tonic-gate 6927c478bd9Sstevel@tonic-gate case ENOENT: 6937c478bd9Sstevel@tonic-gate case EINVAL: 6947c478bd9Sstevel@tonic-gate case E2BIG: 6957c478bd9Sstevel@tonic-gate if (!verbose) 6967c478bd9Sstevel@tonic-gate uu_warn(gettext("%s: Repository " 6977c478bd9Sstevel@tonic-gate "read-only.\n"), fmri); 6987c478bd9Sstevel@tonic-gate else 6997c478bd9Sstevel@tonic-gate uu_warn(gettext("%s: Could not set " 7007c478bd9Sstevel@tonic-gate "%s/%s (repository read-only).\n"), 7017c478bd9Sstevel@tonic-gate fmri, SCF_PG_GENERAL, 7027c478bd9Sstevel@tonic-gate SCF_PROPERTY_ENABLED); 7037c478bd9Sstevel@tonic-gate goto out; 7047c478bd9Sstevel@tonic-gate 7057c478bd9Sstevel@tonic-gate case ECANCELED: 7067c478bd9Sstevel@tonic-gate goto again; 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate default: 7097c478bd9Sstevel@tonic-gate assert(0); 7107c478bd9Sstevel@tonic-gate abort(); 7117c478bd9Sstevel@tonic-gate } 7127c478bd9Sstevel@tonic-gate break; 7137c478bd9Sstevel@tonic-gate 7147c478bd9Sstevel@tonic-gate default: 7157c478bd9Sstevel@tonic-gate assert(0); 7167c478bd9Sstevel@tonic-gate abort(); 7177c478bd9Sstevel@tonic-gate } 7187c478bd9Sstevel@tonic-gate 7197c478bd9Sstevel@tonic-gate pgname = SCF_PG_GENERAL_OVR; 720eb1a3463STruong Nguyen r = scf_instance_delete_prop(inst, pgname, 721eb1a3463STruong Nguyen SCF_PROPERTY_ENABLED); 722eb1a3463STruong Nguyen switch (r) { 723eb1a3463STruong Nguyen case 0: 724eb1a3463STruong Nguyen break; 7257c478bd9Sstevel@tonic-gate 726eb1a3463STruong Nguyen case ECANCELED: 727eb1a3463STruong Nguyen uu_warn(emsg_no_service, fmri); 728eb1a3463STruong Nguyen goto out; 7297c478bd9Sstevel@tonic-gate 730eb1a3463STruong Nguyen case EPERM: 731eb1a3463STruong Nguyen goto eperm; 7327c478bd9Sstevel@tonic-gate 733eb1a3463STruong Nguyen case EACCES: 734eb1a3463STruong Nguyen uu_warn(gettext("Could not delete %s/%s " 735eb1a3463STruong Nguyen "property of %s: backend access denied.\n"), 736eb1a3463STruong Nguyen pgname, SCF_PROPERTY_ENABLED, fmri); 737eb1a3463STruong Nguyen goto out; 7387c478bd9Sstevel@tonic-gate 739eb1a3463STruong Nguyen case EROFS: 740eb1a3463STruong Nguyen uu_warn(gettext("Could not delete %s/%s " 741eb1a3463STruong Nguyen "property of %s: backend is read-only.\n"), 742eb1a3463STruong Nguyen pgname, SCF_PROPERTY_ENABLED, fmri); 743eb1a3463STruong Nguyen goto out; 7447c478bd9Sstevel@tonic-gate 745eb1a3463STruong Nguyen default: 746eb1a3463STruong Nguyen bad_error("scf_instance_delete_prop", r); 7477c478bd9Sstevel@tonic-gate } 7487c478bd9Sstevel@tonic-gate 7497c478bd9Sstevel@tonic-gate if (verbose) 7507c478bd9Sstevel@tonic-gate (void) printf(enable ? gettext("%s enabled.\n") : 7517c478bd9Sstevel@tonic-gate gettext("%s disabled.\n"), fmri); 7527c478bd9Sstevel@tonic-gate } 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 7557c478bd9Sstevel@tonic-gate return; 7567c478bd9Sstevel@tonic-gate 7577c478bd9Sstevel@tonic-gate eperm: 7587c478bd9Sstevel@tonic-gate assert(pgname != NULL); 7597c478bd9Sstevel@tonic-gate if (!verbose) 7607c478bd9Sstevel@tonic-gate uu_warn(emsg_permission_denied, fmri); 7617c478bd9Sstevel@tonic-gate else 7627c478bd9Sstevel@tonic-gate uu_warn(emsg_pg_perm_denied, fmri, pgname); 7637c478bd9Sstevel@tonic-gate 7647c478bd9Sstevel@tonic-gate out: 7657c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 7667c478bd9Sstevel@tonic-gate exit_status = 1; 7677c478bd9Sstevel@tonic-gate } 7687c478bd9Sstevel@tonic-gate 7697c478bd9Sstevel@tonic-gate /* 7707c478bd9Sstevel@tonic-gate * Set inst to the instance which corresponds to fmri. If fmri identifies 7717c478bd9Sstevel@tonic-gate * a service with a single instance, get that instance. 7727c478bd9Sstevel@tonic-gate * 7737c478bd9Sstevel@tonic-gate * Fails with 7747c478bd9Sstevel@tonic-gate * ENOTSUP - fmri has an unsupported scheme 7757c478bd9Sstevel@tonic-gate * EINVAL - fmri is invalid 7767c478bd9Sstevel@tonic-gate * ENOTDIR - fmri does not identify a service or instance 7777c478bd9Sstevel@tonic-gate * ENOENT - could not locate instance 7787c478bd9Sstevel@tonic-gate * E2BIG - fmri is a service with multiple instances (warning not printed) 7797c478bd9Sstevel@tonic-gate */ 7807c478bd9Sstevel@tonic-gate static int 7817c478bd9Sstevel@tonic-gate get_inst_mult(const char *fmri, scf_instance_t *inst) 7827c478bd9Sstevel@tonic-gate { 7837c478bd9Sstevel@tonic-gate char *cfmri; 7847c478bd9Sstevel@tonic-gate const char *svc_name, *inst_name, *pg_name; 7857c478bd9Sstevel@tonic-gate scf_service_t *svc; 7867c478bd9Sstevel@tonic-gate scf_instance_t *inst2; 7877c478bd9Sstevel@tonic-gate scf_iter_t *iter; 7887c478bd9Sstevel@tonic-gate int ret; 7897c478bd9Sstevel@tonic-gate 7907c478bd9Sstevel@tonic-gate if (strncmp(fmri, "lrc:", sizeof ("lrc:") - 1) == 0) { 7917c478bd9Sstevel@tonic-gate uu_warn(gettext("FMRI \"%s\" is a legacy service.\n"), fmri); 7927c478bd9Sstevel@tonic-gate exit_status = 1; 7937c478bd9Sstevel@tonic-gate return (ENOTSUP); 7947c478bd9Sstevel@tonic-gate } 7957c478bd9Sstevel@tonic-gate 7967c478bd9Sstevel@tonic-gate cfmri = strdup(fmri); 7977c478bd9Sstevel@tonic-gate if (cfmri == NULL) 7987c478bd9Sstevel@tonic-gate uu_die(emsg_nomem); 7997c478bd9Sstevel@tonic-gate 8007c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(cfmri, NULL, &svc_name, &inst_name, &pg_name, 8017c478bd9Sstevel@tonic-gate NULL) != SCF_SUCCESS) { 8027c478bd9Sstevel@tonic-gate free(cfmri); 8037c478bd9Sstevel@tonic-gate uu_warn(gettext("FMRI \"%s\" is invalid.\n"), fmri); 8047c478bd9Sstevel@tonic-gate exit_status = 1; 8057c478bd9Sstevel@tonic-gate return (EINVAL); 8067c478bd9Sstevel@tonic-gate } 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate free(cfmri); 8097c478bd9Sstevel@tonic-gate 8107c478bd9Sstevel@tonic-gate if (svc_name == NULL || pg_name != NULL) { 8117c478bd9Sstevel@tonic-gate uu_warn(gettext( 8127c478bd9Sstevel@tonic-gate "FMRI \"%s\" does not designate a service or instance.\n"), 8137c478bd9Sstevel@tonic-gate fmri); 8147c478bd9Sstevel@tonic-gate exit_status = 1; 8157c478bd9Sstevel@tonic-gate return (ENOTDIR); 8167c478bd9Sstevel@tonic-gate } 8177c478bd9Sstevel@tonic-gate 8187c478bd9Sstevel@tonic-gate if (inst_name != NULL) { 8197c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL, 8207c478bd9Sstevel@tonic-gate NULL, SCF_DECODE_FMRI_EXACT) == 0) 8217c478bd9Sstevel@tonic-gate return (0); 8227c478bd9Sstevel@tonic-gate 8237c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 8247c478bd9Sstevel@tonic-gate scfdie(); 8257c478bd9Sstevel@tonic-gate 8267c478bd9Sstevel@tonic-gate uu_warn(gettext("No such instance \"%s\".\n"), fmri); 8277c478bd9Sstevel@tonic-gate exit_status = 1; 8287c478bd9Sstevel@tonic-gate 8297c478bd9Sstevel@tonic-gate return (ENOENT); 8307c478bd9Sstevel@tonic-gate } 8317c478bd9Sstevel@tonic-gate 8327c478bd9Sstevel@tonic-gate if ((svc = scf_service_create(h)) == NULL || 8337c478bd9Sstevel@tonic-gate (inst2 = scf_instance_create(h)) == NULL || 8347c478bd9Sstevel@tonic-gate (iter = scf_iter_create(h)) == NULL) 8357c478bd9Sstevel@tonic-gate scfdie(); 8367c478bd9Sstevel@tonic-gate 8377c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, fmri, NULL, svc, NULL, NULL, NULL, 8387c478bd9Sstevel@tonic-gate SCF_DECODE_FMRI_EXACT) != SCF_SUCCESS) { 8397c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 8407c478bd9Sstevel@tonic-gate scfdie(); 8417c478bd9Sstevel@tonic-gate 8427c478bd9Sstevel@tonic-gate uu_warn(emsg_no_service, fmri); 8437c478bd9Sstevel@tonic-gate exit_status = 1; 8447c478bd9Sstevel@tonic-gate 8457c478bd9Sstevel@tonic-gate ret = ENOENT; 8467c478bd9Sstevel@tonic-gate goto out; 8477c478bd9Sstevel@tonic-gate } 8487c478bd9Sstevel@tonic-gate 8497c478bd9Sstevel@tonic-gate /* If the service has only one child, use it. */ 8507c478bd9Sstevel@tonic-gate if (scf_iter_service_instances(iter, svc) != SCF_SUCCESS) 8517c478bd9Sstevel@tonic-gate scfdie(); 8527c478bd9Sstevel@tonic-gate 8537c478bd9Sstevel@tonic-gate ret = scf_iter_next_instance(iter, inst); 8547c478bd9Sstevel@tonic-gate if (ret < 0) 8557c478bd9Sstevel@tonic-gate scfdie(); 8567c478bd9Sstevel@tonic-gate if (ret != 1) { 8577c478bd9Sstevel@tonic-gate uu_warn(gettext("Service \"%s\" has no instances.\n"), 8587c478bd9Sstevel@tonic-gate fmri); 8597c478bd9Sstevel@tonic-gate exit_status = 1; 8607c478bd9Sstevel@tonic-gate ret = ENOENT; 8617c478bd9Sstevel@tonic-gate goto out; 8627c478bd9Sstevel@tonic-gate } 8637c478bd9Sstevel@tonic-gate 8647c478bd9Sstevel@tonic-gate ret = scf_iter_next_instance(iter, inst2); 8657c478bd9Sstevel@tonic-gate if (ret < 0) 8667c478bd9Sstevel@tonic-gate scfdie(); 8677c478bd9Sstevel@tonic-gate 8687c478bd9Sstevel@tonic-gate if (ret != 0) { 8697c478bd9Sstevel@tonic-gate ret = E2BIG; 8707c478bd9Sstevel@tonic-gate goto out; 8717c478bd9Sstevel@tonic-gate } 8727c478bd9Sstevel@tonic-gate 8737c478bd9Sstevel@tonic-gate ret = 0; 8747c478bd9Sstevel@tonic-gate 8757c478bd9Sstevel@tonic-gate out: 8767c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 8777c478bd9Sstevel@tonic-gate scf_instance_destroy(inst2); 8787c478bd9Sstevel@tonic-gate scf_service_destroy(svc); 8797c478bd9Sstevel@tonic-gate return (ret); 8807c478bd9Sstevel@tonic-gate } 8817c478bd9Sstevel@tonic-gate 8827c478bd9Sstevel@tonic-gate /* 8837c478bd9Sstevel@tonic-gate * Same as get_inst_mult(), but on E2BIG prints a warning and returns ENOENT. 8847c478bd9Sstevel@tonic-gate */ 8857c478bd9Sstevel@tonic-gate static int 8867c478bd9Sstevel@tonic-gate get_inst(const char *fmri, scf_instance_t *inst) 8877c478bd9Sstevel@tonic-gate { 8887c478bd9Sstevel@tonic-gate int r; 8897c478bd9Sstevel@tonic-gate 8907c478bd9Sstevel@tonic-gate r = get_inst_mult(fmri, inst); 8917c478bd9Sstevel@tonic-gate if (r != E2BIG) 8927c478bd9Sstevel@tonic-gate return (r); 8937c478bd9Sstevel@tonic-gate 8947c478bd9Sstevel@tonic-gate uu_warn(gettext("operation on service %s is ambiguous; " 8957c478bd9Sstevel@tonic-gate "instance specification needed.\n"), fmri); 8967c478bd9Sstevel@tonic-gate return (ENOENT); 8977c478bd9Sstevel@tonic-gate } 8987c478bd9Sstevel@tonic-gate 8997c478bd9Sstevel@tonic-gate static char * 9007c478bd9Sstevel@tonic-gate inst_get_fmri(const scf_instance_t *inst) 9017c478bd9Sstevel@tonic-gate { 9027c478bd9Sstevel@tonic-gate ssize_t sz; 9037c478bd9Sstevel@tonic-gate 9047c478bd9Sstevel@tonic-gate sz = scf_instance_to_fmri(inst, scratch_fmri, max_scf_fmri_sz); 9057c478bd9Sstevel@tonic-gate if (sz < 0) 9067c478bd9Sstevel@tonic-gate scfdie(); 9077c478bd9Sstevel@tonic-gate if (sz >= max_scf_fmri_sz) 9087c478bd9Sstevel@tonic-gate uu_die(gettext("scf_instance_to_fmri() returned unexpectedly " 9097c478bd9Sstevel@tonic-gate "long value.\n")); 9107c478bd9Sstevel@tonic-gate 9117c478bd9Sstevel@tonic-gate return (scratch_fmri); 9127c478bd9Sstevel@tonic-gate } 9137c478bd9Sstevel@tonic-gate 9147c478bd9Sstevel@tonic-gate static ssize_t 9157c478bd9Sstevel@tonic-gate dep_get_astring(const char *fmri, const char *pgname, 9167c478bd9Sstevel@tonic-gate const scf_propertygroup_t *pg, const char *propname, scf_property_t *prop, 9177c478bd9Sstevel@tonic-gate scf_value_t *v, char *buf, size_t bufsz) 9187c478bd9Sstevel@tonic-gate { 9197c478bd9Sstevel@tonic-gate ssize_t sz; 9207c478bd9Sstevel@tonic-gate 9217c478bd9Sstevel@tonic-gate sz = get_astring_prop(pg, propname, prop, v, buf, bufsz); 9227c478bd9Sstevel@tonic-gate if (sz >= 0) 9237c478bd9Sstevel@tonic-gate return (sz); 9247c478bd9Sstevel@tonic-gate 9257c478bd9Sstevel@tonic-gate switch (-sz) { 9267c478bd9Sstevel@tonic-gate case ENOENT: 9277c478bd9Sstevel@tonic-gate uu_warn(gettext("\"%s\" is misconfigured (\"%s\" dependency " 9287c478bd9Sstevel@tonic-gate "lacks \"%s\" property.)\n"), fmri, pgname, propname); 9297c478bd9Sstevel@tonic-gate return (-1); 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate case E2BIG: 9327c478bd9Sstevel@tonic-gate uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" property " 9337c478bd9Sstevel@tonic-gate "is not single-valued.)\n"), fmri, pgname, propname); 9347c478bd9Sstevel@tonic-gate return (-1); 9357c478bd9Sstevel@tonic-gate 9367c478bd9Sstevel@tonic-gate case EINVAL: 9377c478bd9Sstevel@tonic-gate uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" property " 9387c478bd9Sstevel@tonic-gate "is not of astring type.)\n"), fmri, pgname, propname); 9397c478bd9Sstevel@tonic-gate return (-1); 9407c478bd9Sstevel@tonic-gate 9417c478bd9Sstevel@tonic-gate default: 9427c478bd9Sstevel@tonic-gate assert(0); 9437c478bd9Sstevel@tonic-gate abort(); 9447c478bd9Sstevel@tonic-gate /* NOTREACHED */ 9457c478bd9Sstevel@tonic-gate } 9467c478bd9Sstevel@tonic-gate } 9477c478bd9Sstevel@tonic-gate 9487c478bd9Sstevel@tonic-gate static boolean_t 9497c478bd9Sstevel@tonic-gate multiple_instances(scf_iter_t *iter, scf_value_t *v, char *buf) 9507c478bd9Sstevel@tonic-gate { 9517c478bd9Sstevel@tonic-gate int count = 0, r; 9527c478bd9Sstevel@tonic-gate boolean_t ret; 9537c478bd9Sstevel@tonic-gate scf_instance_t *inst; 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate inst = scf_instance_create(h); 9567c478bd9Sstevel@tonic-gate if (inst == NULL) 9577c478bd9Sstevel@tonic-gate scfdie(); 9587c478bd9Sstevel@tonic-gate 9597c478bd9Sstevel@tonic-gate for (;;) { 9607c478bd9Sstevel@tonic-gate r = scf_iter_next_value(iter, v); 9617c478bd9Sstevel@tonic-gate if (r == 0) { 9627c478bd9Sstevel@tonic-gate ret = B_FALSE; 9637c478bd9Sstevel@tonic-gate goto out; 9647c478bd9Sstevel@tonic-gate } 9657c478bd9Sstevel@tonic-gate if (r != 1) 9667c478bd9Sstevel@tonic-gate scfdie(); 9677c478bd9Sstevel@tonic-gate 9687c478bd9Sstevel@tonic-gate if (scf_value_get_astring(v, buf, max_scf_fmri_sz) < 0) 9697c478bd9Sstevel@tonic-gate scfdie(); 9707c478bd9Sstevel@tonic-gate 9717c478bd9Sstevel@tonic-gate switch (get_inst_mult(buf, inst)) { 9727c478bd9Sstevel@tonic-gate case 0: 9737c478bd9Sstevel@tonic-gate ++count; 9747c478bd9Sstevel@tonic-gate if (count > 1) { 9757c478bd9Sstevel@tonic-gate ret = B_TRUE; 9767c478bd9Sstevel@tonic-gate goto out; 9777c478bd9Sstevel@tonic-gate } 9787c478bd9Sstevel@tonic-gate break; 9797c478bd9Sstevel@tonic-gate 9807c478bd9Sstevel@tonic-gate case ENOTSUP: 9817c478bd9Sstevel@tonic-gate case EINVAL: 9827c478bd9Sstevel@tonic-gate case ENOTDIR: 9837c478bd9Sstevel@tonic-gate case ENOENT: 9847c478bd9Sstevel@tonic-gate continue; 9857c478bd9Sstevel@tonic-gate 9867c478bd9Sstevel@tonic-gate case E2BIG: 9877c478bd9Sstevel@tonic-gate ret = B_TRUE; 9887c478bd9Sstevel@tonic-gate goto out; 9897c478bd9Sstevel@tonic-gate 9907c478bd9Sstevel@tonic-gate default: 9917c478bd9Sstevel@tonic-gate assert(0); 9927c478bd9Sstevel@tonic-gate abort(); 9937c478bd9Sstevel@tonic-gate } 9947c478bd9Sstevel@tonic-gate } 9957c478bd9Sstevel@tonic-gate 9967c478bd9Sstevel@tonic-gate out: 9977c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 9987c478bd9Sstevel@tonic-gate return (ret); 9997c478bd9Sstevel@tonic-gate } 10007c478bd9Sstevel@tonic-gate 10017c478bd9Sstevel@tonic-gate /* 10027c478bd9Sstevel@tonic-gate * Enable the service or instance identified by fmri and its dependencies, 10037c478bd9Sstevel@tonic-gate * recursively. Specifically, call get_inst(fmri), enable the result, and 10047c478bd9Sstevel@tonic-gate * recurse on its restarter and the dependencies. To avoid duplication of 10057c478bd9Sstevel@tonic-gate * effort or looping around a dependency cycle, each FMRI is entered into the 10067c478bd9Sstevel@tonic-gate * "visited" hash table. While recursing, the hash table entry is marked 10077c478bd9Sstevel@tonic-gate * "active", so that if we come upon it again, we know we've hit a cycle. 10087c478bd9Sstevel@tonic-gate * exclude_all and optional_all dependencies are ignored. require_any 10097c478bd9Sstevel@tonic-gate * dependencies are followed only if they comprise a single service; otherwise 10107c478bd9Sstevel@tonic-gate * the user is warned. 10117c478bd9Sstevel@tonic-gate * 10127c478bd9Sstevel@tonic-gate * fmri must point to a writable max_scf_fmri_sz buffer. Returns EINVAL if fmri 10137c478bd9Sstevel@tonic-gate * is invalid, E2BIG if fmri identifies a service with multiple instances, ELOOP 10147c478bd9Sstevel@tonic-gate * on cycle detection, or 0 on success. 10157c478bd9Sstevel@tonic-gate */ 10167c478bd9Sstevel@tonic-gate static int 10177c478bd9Sstevel@tonic-gate enable_fmri_rec(char *fmri, boolean_t temp) 10187c478bd9Sstevel@tonic-gate { 10197c478bd9Sstevel@tonic-gate scf_instance_t *inst; 10207c478bd9Sstevel@tonic-gate scf_snapshot_t *snap; 10217c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg; 10227c478bd9Sstevel@tonic-gate scf_property_t *prop; 10237c478bd9Sstevel@tonic-gate scf_value_t *v; 10247c478bd9Sstevel@tonic-gate scf_iter_t *pg_iter, *val_iter; 10257c478bd9Sstevel@tonic-gate scf_type_t ty; 10267c478bd9Sstevel@tonic-gate char *buf, *pgname; 10277c478bd9Sstevel@tonic-gate ssize_t name_sz, len, sz; 10287c478bd9Sstevel@tonic-gate int ret; 10297c478bd9Sstevel@tonic-gate struct ht_elt *he; 10307c478bd9Sstevel@tonic-gate 10317c478bd9Sstevel@tonic-gate len = scf_canonify_fmri(fmri, fmri, max_scf_fmri_sz); 10327c478bd9Sstevel@tonic-gate if (len < 0) { 10337c478bd9Sstevel@tonic-gate assert(scf_error() == SCF_ERROR_INVALID_ARGUMENT); 10347c478bd9Sstevel@tonic-gate return (EINVAL); 10357c478bd9Sstevel@tonic-gate } 10367c478bd9Sstevel@tonic-gate assert(len < max_scf_fmri_sz); 10377c478bd9Sstevel@tonic-gate 10387c478bd9Sstevel@tonic-gate switch (visited_find_or_add(fmri, &he)) { 10397c478bd9Sstevel@tonic-gate case 0: 10407c478bd9Sstevel@tonic-gate he->active = B_TRUE; 10417c478bd9Sstevel@tonic-gate break; 10427c478bd9Sstevel@tonic-gate 10437c478bd9Sstevel@tonic-gate case 1: 10447c478bd9Sstevel@tonic-gate return (he->active ? ELOOP : 0); 10457c478bd9Sstevel@tonic-gate 10467c478bd9Sstevel@tonic-gate case -1: 10477c478bd9Sstevel@tonic-gate uu_die(emsg_nomem); 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate default: 10507c478bd9Sstevel@tonic-gate assert(0); 10517c478bd9Sstevel@tonic-gate abort(); 10527c478bd9Sstevel@tonic-gate } 10537c478bd9Sstevel@tonic-gate 10547c478bd9Sstevel@tonic-gate inst = scf_instance_create(h); 10557c478bd9Sstevel@tonic-gate if (inst == NULL) 10567c478bd9Sstevel@tonic-gate scfdie(); 10577c478bd9Sstevel@tonic-gate 10587c478bd9Sstevel@tonic-gate switch (get_inst_mult(fmri, inst)) { 10597c478bd9Sstevel@tonic-gate case 0: 10607c478bd9Sstevel@tonic-gate break; 10617c478bd9Sstevel@tonic-gate 10627c478bd9Sstevel@tonic-gate case E2BIG: 10637c478bd9Sstevel@tonic-gate he->active = B_FALSE; 10647c478bd9Sstevel@tonic-gate return (E2BIG); 10657c478bd9Sstevel@tonic-gate 10667c478bd9Sstevel@tonic-gate default: 10677c478bd9Sstevel@tonic-gate he->active = B_FALSE; 10687c478bd9Sstevel@tonic-gate return (0); 10697c478bd9Sstevel@tonic-gate } 10707c478bd9Sstevel@tonic-gate 10717c478bd9Sstevel@tonic-gate set_inst_enabled(fmri, inst, temp, B_TRUE); 10727c478bd9Sstevel@tonic-gate 10737c478bd9Sstevel@tonic-gate if ((snap = scf_snapshot_create(h)) == NULL || 10747c478bd9Sstevel@tonic-gate (pg = scf_pg_create(h)) == NULL || 10757c478bd9Sstevel@tonic-gate (prop = scf_property_create(h)) == NULL || 10767c478bd9Sstevel@tonic-gate (v = scf_value_create(h)) == NULL || 10777c478bd9Sstevel@tonic-gate (pg_iter = scf_iter_create(h)) == NULL || 10787c478bd9Sstevel@tonic-gate (val_iter = scf_iter_create(h)) == NULL) 10797c478bd9Sstevel@tonic-gate scfdie(); 10807c478bd9Sstevel@tonic-gate 10817c478bd9Sstevel@tonic-gate buf = malloc(max_scf_fmri_sz); 10827c478bd9Sstevel@tonic-gate if (buf == NULL) 10837c478bd9Sstevel@tonic-gate uu_die(emsg_nomem); 10847c478bd9Sstevel@tonic-gate 10857c478bd9Sstevel@tonic-gate name_sz = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH); 10867c478bd9Sstevel@tonic-gate if (name_sz < 0) 10877c478bd9Sstevel@tonic-gate scfdie(); 10887c478bd9Sstevel@tonic-gate ++name_sz; 10897c478bd9Sstevel@tonic-gate pgname = malloc(name_sz); 10907c478bd9Sstevel@tonic-gate if (pgname == NULL) 10917c478bd9Sstevel@tonic-gate uu_die(emsg_nomem); 10927c478bd9Sstevel@tonic-gate 10937c478bd9Sstevel@tonic-gate if (scf_instance_get_snapshot(inst, "running", snap) != 0) { 10947c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 10957c478bd9Sstevel@tonic-gate scfdie(); 10967c478bd9Sstevel@tonic-gate 10977c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 10987c478bd9Sstevel@tonic-gate snap = NULL; 10997c478bd9Sstevel@tonic-gate } 11007c478bd9Sstevel@tonic-gate 11017c478bd9Sstevel@tonic-gate /* Enable restarter */ 11027c478bd9Sstevel@tonic-gate if (scf_instance_get_pg_composed(inst, snap, SCF_PG_GENERAL, pg) != 0) { 11037c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 11047c478bd9Sstevel@tonic-gate scfdie(); 11057c478bd9Sstevel@tonic-gate 11067c478bd9Sstevel@tonic-gate uu_warn(gettext("\"%s\" is misconfigured (lacks \"%s\" " 11077c478bd9Sstevel@tonic-gate "property group).\n"), fmri, SCF_PG_GENERAL); 11087c478bd9Sstevel@tonic-gate ret = 0; 11097c478bd9Sstevel@tonic-gate goto out; 11107c478bd9Sstevel@tonic-gate } 11117c478bd9Sstevel@tonic-gate 11127c478bd9Sstevel@tonic-gate sz = get_astring_prop(pg, SCF_PROPERTY_RESTARTER, prop, v, buf, 11137c478bd9Sstevel@tonic-gate max_scf_fmri_sz); 11147c478bd9Sstevel@tonic-gate if (sz > max_scf_fmri_sz) { 11157c478bd9Sstevel@tonic-gate uu_warn(gettext("\"%s\" is misconfigured (the value of " 11167c478bd9Sstevel@tonic-gate "\"%s/%s\" is too long).\n"), fmri, SCF_PG_GENERAL, 11177c478bd9Sstevel@tonic-gate SCF_PROPERTY_RESTARTER); 11187c478bd9Sstevel@tonic-gate ret = 0; 11197c478bd9Sstevel@tonic-gate goto out; 11207c478bd9Sstevel@tonic-gate } else if (sz >= 0) { 11217c478bd9Sstevel@tonic-gate switch (enable_fmri_rec(buf, temp)) { 11227c478bd9Sstevel@tonic-gate case 0: 11237c478bd9Sstevel@tonic-gate break; 11247c478bd9Sstevel@tonic-gate 11257c478bd9Sstevel@tonic-gate case EINVAL: 11267c478bd9Sstevel@tonic-gate uu_warn(gettext("Restarter FMRI for \"%s\" is " 11277c478bd9Sstevel@tonic-gate "invalid.\n"), fmri); 11287c478bd9Sstevel@tonic-gate break; 11297c478bd9Sstevel@tonic-gate 11307c478bd9Sstevel@tonic-gate case E2BIG: 11317c478bd9Sstevel@tonic-gate uu_warn(gettext("Restarter FMRI for \"%s\" identifies " 11327c478bd9Sstevel@tonic-gate "a service with multiple instances.\n"), fmri); 11337c478bd9Sstevel@tonic-gate break; 11347c478bd9Sstevel@tonic-gate 11357c478bd9Sstevel@tonic-gate case ELOOP: 11367c478bd9Sstevel@tonic-gate ret = ELOOP; 11377c478bd9Sstevel@tonic-gate goto out; 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate default: 11407c478bd9Sstevel@tonic-gate assert(0); 11417c478bd9Sstevel@tonic-gate abort(); 11427c478bd9Sstevel@tonic-gate } 11437c478bd9Sstevel@tonic-gate } else if (sz < 0) { 11447c478bd9Sstevel@tonic-gate switch (-sz) { 11457c478bd9Sstevel@tonic-gate case ENOENT: 11467c478bd9Sstevel@tonic-gate break; 11477c478bd9Sstevel@tonic-gate 11487c478bd9Sstevel@tonic-gate case E2BIG: 11497c478bd9Sstevel@tonic-gate uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" " 11507c478bd9Sstevel@tonic-gate "property is not single-valued).\n"), fmri, 11517c478bd9Sstevel@tonic-gate SCF_PG_GENERAL, SCF_PROPERTY_RESTARTER); 11527c478bd9Sstevel@tonic-gate ret = 0; 11537c478bd9Sstevel@tonic-gate goto out; 11547c478bd9Sstevel@tonic-gate 11557c478bd9Sstevel@tonic-gate case EINVAL: 11567c478bd9Sstevel@tonic-gate uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" " 11577c478bd9Sstevel@tonic-gate "property is not of astring type).\n"), fmri, 11587c478bd9Sstevel@tonic-gate SCF_PG_GENERAL, SCF_PROPERTY_RESTARTER); 11597c478bd9Sstevel@tonic-gate ret = 0; 11607c478bd9Sstevel@tonic-gate goto out; 11617c478bd9Sstevel@tonic-gate 11627c478bd9Sstevel@tonic-gate default: 11637c478bd9Sstevel@tonic-gate assert(0); 11647c478bd9Sstevel@tonic-gate abort(); 11657c478bd9Sstevel@tonic-gate } 11667c478bd9Sstevel@tonic-gate } 11677c478bd9Sstevel@tonic-gate 11687c478bd9Sstevel@tonic-gate if (scf_iter_instance_pgs_typed_composed(pg_iter, inst, snap, 11697c478bd9Sstevel@tonic-gate SCF_GROUP_DEPENDENCY) == -1) 11707c478bd9Sstevel@tonic-gate scfdie(); 11717c478bd9Sstevel@tonic-gate 11727c478bd9Sstevel@tonic-gate while (scf_iter_next_pg(pg_iter, pg) > 0) { 11737c478bd9Sstevel@tonic-gate len = scf_pg_get_name(pg, pgname, name_sz); 11747c478bd9Sstevel@tonic-gate if (len < 0) 11757c478bd9Sstevel@tonic-gate scfdie(); 11767c478bd9Sstevel@tonic-gate assert(len < name_sz); 11777c478bd9Sstevel@tonic-gate 11787c478bd9Sstevel@tonic-gate if (dep_get_astring(fmri, pgname, pg, SCF_PROPERTY_TYPE, prop, 11797c478bd9Sstevel@tonic-gate v, buf, max_scf_fmri_sz) < 0) 11807c478bd9Sstevel@tonic-gate continue; 11817c478bd9Sstevel@tonic-gate 11827c478bd9Sstevel@tonic-gate if (strcmp(buf, "service") != 0) 11837c478bd9Sstevel@tonic-gate continue; 11847c478bd9Sstevel@tonic-gate 11857c478bd9Sstevel@tonic-gate if (dep_get_astring(fmri, pgname, pg, SCF_PROPERTY_GROUPING, 11867c478bd9Sstevel@tonic-gate prop, v, buf, max_scf_fmri_sz) < 0) 11877c478bd9Sstevel@tonic-gate continue; 11887c478bd9Sstevel@tonic-gate 11897c478bd9Sstevel@tonic-gate if (strcmp(buf, SCF_DEP_EXCLUDE_ALL) == 0 || 11907c478bd9Sstevel@tonic-gate strcmp(buf, SCF_DEP_OPTIONAL_ALL) == 0) 11917c478bd9Sstevel@tonic-gate continue; 11927c478bd9Sstevel@tonic-gate 11937c478bd9Sstevel@tonic-gate if (strcmp(buf, SCF_DEP_REQUIRE_ALL) != 0 && 11947c478bd9Sstevel@tonic-gate strcmp(buf, SCF_DEP_REQUIRE_ANY) != 0) { 11957c478bd9Sstevel@tonic-gate uu_warn(gettext("Dependency \"%s\" of \"%s\" has " 11967c478bd9Sstevel@tonic-gate "unknown type \"%s\".\n"), pgname, fmri, buf); 11977c478bd9Sstevel@tonic-gate continue; 11987c478bd9Sstevel@tonic-gate } 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, SCF_PROPERTY_ENTITIES, prop) == 12017c478bd9Sstevel@tonic-gate -1) { 12027c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 12037c478bd9Sstevel@tonic-gate scfdie(); 12047c478bd9Sstevel@tonic-gate 12057c478bd9Sstevel@tonic-gate uu_warn(gettext("\"%s\" is misconfigured (\"%s\" " 12067c478bd9Sstevel@tonic-gate "dependency lacks \"%s\" property.)\n"), fmri, 12077c478bd9Sstevel@tonic-gate pgname, SCF_PROPERTY_ENTITIES); 12087c478bd9Sstevel@tonic-gate continue; 12097c478bd9Sstevel@tonic-gate } 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate if (scf_property_type(prop, &ty) != SCF_SUCCESS) 12127c478bd9Sstevel@tonic-gate scfdie(); 12137c478bd9Sstevel@tonic-gate 12147c478bd9Sstevel@tonic-gate if (ty != SCF_TYPE_FMRI) { 12157c478bd9Sstevel@tonic-gate uu_warn(gettext("\"%s\" is misconfigured (property " 12167c478bd9Sstevel@tonic-gate "\"%s/%s\" is not of fmri type).\n"), fmri, pgname, 12177c478bd9Sstevel@tonic-gate SCF_PROPERTY_ENTITIES); 12187c478bd9Sstevel@tonic-gate continue; 12197c478bd9Sstevel@tonic-gate } 12207c478bd9Sstevel@tonic-gate 12217c478bd9Sstevel@tonic-gate if (scf_iter_property_values(val_iter, prop) == -1) 12227c478bd9Sstevel@tonic-gate scfdie(); 12237c478bd9Sstevel@tonic-gate 12247c478bd9Sstevel@tonic-gate if (strcmp(buf, SCF_DEP_REQUIRE_ANY) == 0) { 12257c478bd9Sstevel@tonic-gate if (multiple_instances(val_iter, v, buf)) { 12267c478bd9Sstevel@tonic-gate (void) printf(gettext("%s requires one of:\n"), 12277c478bd9Sstevel@tonic-gate fmri); 12287c478bd9Sstevel@tonic-gate 12297c478bd9Sstevel@tonic-gate if (scf_iter_property_values(val_iter, prop) != 12307c478bd9Sstevel@tonic-gate 0) 12317c478bd9Sstevel@tonic-gate scfdie(); 12327c478bd9Sstevel@tonic-gate 12337c478bd9Sstevel@tonic-gate for (;;) { 12347c478bd9Sstevel@tonic-gate int r; 12357c478bd9Sstevel@tonic-gate 12367c478bd9Sstevel@tonic-gate r = scf_iter_next_value(val_iter, v); 12377c478bd9Sstevel@tonic-gate if (r == 0) 12387c478bd9Sstevel@tonic-gate break; 12397c478bd9Sstevel@tonic-gate if (r != 1) 12407c478bd9Sstevel@tonic-gate scfdie(); 12417c478bd9Sstevel@tonic-gate 12427c478bd9Sstevel@tonic-gate if (scf_value_get_astring(v, buf, 12437c478bd9Sstevel@tonic-gate max_scf_fmri_sz) < 0) 12447c478bd9Sstevel@tonic-gate scfdie(); 12457c478bd9Sstevel@tonic-gate 12467c478bd9Sstevel@tonic-gate (void) fputs(" ", stdout); 12477c478bd9Sstevel@tonic-gate (void) puts(buf); 12487c478bd9Sstevel@tonic-gate } 12497c478bd9Sstevel@tonic-gate 12507c478bd9Sstevel@tonic-gate continue; 12517c478bd9Sstevel@tonic-gate } 12527c478bd9Sstevel@tonic-gate 12537c478bd9Sstevel@tonic-gate /* 12547c478bd9Sstevel@tonic-gate * Since there's only one instance, we can enable it. 12557c478bd9Sstevel@tonic-gate * Reset val_iter and continue. 12567c478bd9Sstevel@tonic-gate */ 12577c478bd9Sstevel@tonic-gate if (scf_iter_property_values(val_iter, prop) != 0) 12587c478bd9Sstevel@tonic-gate scfdie(); 12597c478bd9Sstevel@tonic-gate } 12607c478bd9Sstevel@tonic-gate 12617c478bd9Sstevel@tonic-gate for (;;) { 12627c478bd9Sstevel@tonic-gate ret = scf_iter_next_value(val_iter, v); 12637c478bd9Sstevel@tonic-gate if (ret == 0) 12647c478bd9Sstevel@tonic-gate break; 12657c478bd9Sstevel@tonic-gate if (ret != 1) 12667c478bd9Sstevel@tonic-gate scfdie(); 12677c478bd9Sstevel@tonic-gate 12687c478bd9Sstevel@tonic-gate if (scf_value_get_astring(v, buf, max_scf_fmri_sz) == 12697c478bd9Sstevel@tonic-gate -1) 12707c478bd9Sstevel@tonic-gate scfdie(); 12717c478bd9Sstevel@tonic-gate 12727c478bd9Sstevel@tonic-gate switch (enable_fmri_rec(buf, temp)) { 12737c478bd9Sstevel@tonic-gate case 0: 12747c478bd9Sstevel@tonic-gate break; 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate case EINVAL: 12777c478bd9Sstevel@tonic-gate uu_warn(gettext("\"%s\" dependency of \"%s\" " 12787c478bd9Sstevel@tonic-gate "has invalid FMRI \"%s\".\n"), pgname, 12797c478bd9Sstevel@tonic-gate fmri, buf); 12807c478bd9Sstevel@tonic-gate break; 12817c478bd9Sstevel@tonic-gate 12827c478bd9Sstevel@tonic-gate case E2BIG: 12837c478bd9Sstevel@tonic-gate uu_warn(gettext("%s depends on %s, which has " 12847c478bd9Sstevel@tonic-gate "multiple instances.\n"), fmri, buf); 12857c478bd9Sstevel@tonic-gate break; 12867c478bd9Sstevel@tonic-gate 12877c478bd9Sstevel@tonic-gate case ELOOP: 12887c478bd9Sstevel@tonic-gate ret = ELOOP; 12897c478bd9Sstevel@tonic-gate goto out; 12907c478bd9Sstevel@tonic-gate 12917c478bd9Sstevel@tonic-gate default: 12927c478bd9Sstevel@tonic-gate assert(0); 12937c478bd9Sstevel@tonic-gate abort(); 12947c478bd9Sstevel@tonic-gate } 12957c478bd9Sstevel@tonic-gate } 12967c478bd9Sstevel@tonic-gate } 12977c478bd9Sstevel@tonic-gate 12987c478bd9Sstevel@tonic-gate ret = 0; 12997c478bd9Sstevel@tonic-gate 13007c478bd9Sstevel@tonic-gate out: 13017c478bd9Sstevel@tonic-gate he->active = B_FALSE; 13027c478bd9Sstevel@tonic-gate 13037c478bd9Sstevel@tonic-gate free(buf); 13047c478bd9Sstevel@tonic-gate free(pgname); 13057c478bd9Sstevel@tonic-gate 13067c478bd9Sstevel@tonic-gate (void) scf_value_destroy(v); 13077c478bd9Sstevel@tonic-gate scf_property_destroy(prop); 13087c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 13097c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 13107c478bd9Sstevel@tonic-gate scf_iter_destroy(pg_iter); 13117c478bd9Sstevel@tonic-gate scf_iter_destroy(val_iter); 13127c478bd9Sstevel@tonic-gate 13137c478bd9Sstevel@tonic-gate return (ret); 13147c478bd9Sstevel@tonic-gate } 13157c478bd9Sstevel@tonic-gate 13167c478bd9Sstevel@tonic-gate /* 13177c478bd9Sstevel@tonic-gate * fmri here is only used for verbose messages. 13187c478bd9Sstevel@tonic-gate */ 13197c478bd9Sstevel@tonic-gate static void 13207c478bd9Sstevel@tonic-gate set_inst_action(const char *fmri, const scf_instance_t *inst, 13217c478bd9Sstevel@tonic-gate const char *action) 13227c478bd9Sstevel@tonic-gate { 13237c478bd9Sstevel@tonic-gate scf_transaction_t *tx; 13247c478bd9Sstevel@tonic-gate scf_transaction_entry_t *ent; 13257c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg; 13267c478bd9Sstevel@tonic-gate scf_property_t *prop; 13277c478bd9Sstevel@tonic-gate scf_value_t *v; 13287c478bd9Sstevel@tonic-gate int ret; 13297c478bd9Sstevel@tonic-gate int64_t t; 13307c478bd9Sstevel@tonic-gate hrtime_t timestamp; 13317c478bd9Sstevel@tonic-gate 13327c478bd9Sstevel@tonic-gate const char * const scf_pg_restarter_actions = SCF_PG_RESTARTER_ACTIONS; 13337c478bd9Sstevel@tonic-gate 13347c478bd9Sstevel@tonic-gate if ((pg = scf_pg_create(h)) == NULL || 13357c478bd9Sstevel@tonic-gate (prop = scf_property_create(h)) == NULL || 13367c478bd9Sstevel@tonic-gate (v = scf_value_create(h)) == NULL || 13377c478bd9Sstevel@tonic-gate (tx = scf_transaction_create(h)) == NULL || 13387c478bd9Sstevel@tonic-gate (ent = scf_entry_create(h)) == NULL) 13397c478bd9Sstevel@tonic-gate scfdie(); 13407c478bd9Sstevel@tonic-gate 1341a97d4a16SDave Eddy if (restarter_setup(fmri, inst)) { 1342a97d4a16SDave Eddy exit_status = 1; 1343e8f5b3f5STruong Nguyen goto out; 1344a97d4a16SDave Eddy } 1345eb1a3463STruong Nguyen 13467c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(inst, scf_pg_restarter_actions, pg) == -1) { 13477c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 13487c478bd9Sstevel@tonic-gate scfdie(); 13497c478bd9Sstevel@tonic-gate 13507c478bd9Sstevel@tonic-gate /* Try creating the restarter_actions property group. */ 13517c478bd9Sstevel@tonic-gate if (scf_instance_add_pg(inst, scf_pg_restarter_actions, 13527c478bd9Sstevel@tonic-gate SCF_PG_RESTARTER_ACTIONS_TYPE, 13537c478bd9Sstevel@tonic-gate SCF_PG_RESTARTER_ACTIONS_FLAGS, pg) == -1) { 13547c478bd9Sstevel@tonic-gate switch (scf_error()) { 13557c478bd9Sstevel@tonic-gate case SCF_ERROR_EXISTS: 13567c478bd9Sstevel@tonic-gate /* Someone must have added it. */ 13577c478bd9Sstevel@tonic-gate break; 13587c478bd9Sstevel@tonic-gate 13597c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED: 13607c478bd9Sstevel@tonic-gate if (!verbose) 13617c478bd9Sstevel@tonic-gate uu_warn(emsg_permission_denied, fmri); 13627c478bd9Sstevel@tonic-gate else 13637c478bd9Sstevel@tonic-gate uu_warn(emsg_create_pg_perm_denied, 13647c478bd9Sstevel@tonic-gate fmri, scf_pg_restarter_actions); 13657c478bd9Sstevel@tonic-gate goto out; 13667c478bd9Sstevel@tonic-gate 13677c478bd9Sstevel@tonic-gate default: 13687c478bd9Sstevel@tonic-gate scfdie(); 13697c478bd9Sstevel@tonic-gate } 13707c478bd9Sstevel@tonic-gate } 13717c478bd9Sstevel@tonic-gate } 13727c478bd9Sstevel@tonic-gate 13737c478bd9Sstevel@tonic-gate /* 13747c478bd9Sstevel@tonic-gate * If we lose the transaction race and need to retry, there are 2 13757c478bd9Sstevel@tonic-gate * potential other winners: 13767c478bd9Sstevel@tonic-gate * - another process setting actions 13777c478bd9Sstevel@tonic-gate * - the restarter marking the action complete 13787c478bd9Sstevel@tonic-gate * Therefore, re-read the property every time through the loop before 13797c478bd9Sstevel@tonic-gate * making any decisions based on their values. 13807c478bd9Sstevel@tonic-gate */ 13817c478bd9Sstevel@tonic-gate do { 13827c478bd9Sstevel@tonic-gate timestamp = gethrtime(); 13837c478bd9Sstevel@tonic-gate 13847c478bd9Sstevel@tonic-gate if (scf_transaction_start(tx, pg) == -1) { 13857c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_PERMISSION_DENIED) 13867c478bd9Sstevel@tonic-gate scfdie(); 13877c478bd9Sstevel@tonic-gate 13887c478bd9Sstevel@tonic-gate if (!verbose) 13897c478bd9Sstevel@tonic-gate uu_warn(emsg_permission_denied, fmri); 13907c478bd9Sstevel@tonic-gate else 13917c478bd9Sstevel@tonic-gate uu_warn(emsg_pg_perm_denied, fmri, 13927c478bd9Sstevel@tonic-gate scf_pg_restarter_actions); 13937c478bd9Sstevel@tonic-gate goto out; 13947c478bd9Sstevel@tonic-gate } 13957c478bd9Sstevel@tonic-gate 13967c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, action, prop) == -1) { 13977c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 13987c478bd9Sstevel@tonic-gate scfdie(); 13997c478bd9Sstevel@tonic-gate if (scf_transaction_property_new(tx, ent, 14007c478bd9Sstevel@tonic-gate action, SCF_TYPE_INTEGER) == -1) 14017c478bd9Sstevel@tonic-gate scfdie(); 14027c478bd9Sstevel@tonic-gate goto action_set; 14037c478bd9Sstevel@tonic-gate } else { 14047c478bd9Sstevel@tonic-gate if (scf_transaction_property_change_type(tx, ent, 14057c478bd9Sstevel@tonic-gate action, SCF_TYPE_INTEGER) == -1) 14067c478bd9Sstevel@tonic-gate scfdie(); 14077c478bd9Sstevel@tonic-gate } 14087c478bd9Sstevel@tonic-gate 14097c478bd9Sstevel@tonic-gate if (scf_property_get_value(prop, v) == -1) { 14107c478bd9Sstevel@tonic-gate switch (scf_error()) { 14117c478bd9Sstevel@tonic-gate case SCF_ERROR_CONSTRAINT_VIOLATED: 14127c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 14137c478bd9Sstevel@tonic-gate /* Misconfigured, so set anyway. */ 14147c478bd9Sstevel@tonic-gate goto action_set; 14157c478bd9Sstevel@tonic-gate 14167c478bd9Sstevel@tonic-gate default: 14177c478bd9Sstevel@tonic-gate scfdie(); 14187c478bd9Sstevel@tonic-gate } 14197c478bd9Sstevel@tonic-gate } else { 14207c478bd9Sstevel@tonic-gate if (scf_value_get_integer(v, &t) == -1) { 14217c478bd9Sstevel@tonic-gate assert(scf_error() == SCF_ERROR_TYPE_MISMATCH); 14227c478bd9Sstevel@tonic-gate goto action_set; 14237c478bd9Sstevel@tonic-gate } 14247c478bd9Sstevel@tonic-gate if (t > timestamp) 14257c478bd9Sstevel@tonic-gate break; 14267c478bd9Sstevel@tonic-gate } 14277c478bd9Sstevel@tonic-gate 14287c478bd9Sstevel@tonic-gate action_set: 14297c478bd9Sstevel@tonic-gate scf_value_set_integer(v, timestamp); 14307c478bd9Sstevel@tonic-gate if (scf_entry_add_value(ent, v) == -1) 14317c478bd9Sstevel@tonic-gate scfdie(); 14327c478bd9Sstevel@tonic-gate 14337c478bd9Sstevel@tonic-gate ret = scf_transaction_commit(tx); 14347c478bd9Sstevel@tonic-gate if (ret == -1) { 14357c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_PERMISSION_DENIED) 14367c478bd9Sstevel@tonic-gate scfdie(); 14377c478bd9Sstevel@tonic-gate 14387c478bd9Sstevel@tonic-gate if (!verbose) 14397c478bd9Sstevel@tonic-gate uu_warn(emsg_permission_denied, fmri); 14407c478bd9Sstevel@tonic-gate else 14417c478bd9Sstevel@tonic-gate uu_warn(emsg_prop_perm_denied, fmri, 14427c478bd9Sstevel@tonic-gate scf_pg_restarter_actions, action); 14437c478bd9Sstevel@tonic-gate scf_transaction_reset(tx); 14447c478bd9Sstevel@tonic-gate goto out; 14457c478bd9Sstevel@tonic-gate } 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate scf_transaction_reset(tx); 14487c478bd9Sstevel@tonic-gate 14497c478bd9Sstevel@tonic-gate if (ret == 0) { 14507c478bd9Sstevel@tonic-gate if (scf_pg_update(pg) == -1) 14517c478bd9Sstevel@tonic-gate scfdie(); 14527c478bd9Sstevel@tonic-gate } 14537c478bd9Sstevel@tonic-gate } while (ret == 0); 14547c478bd9Sstevel@tonic-gate 14557c478bd9Sstevel@tonic-gate if (verbose) 14567c478bd9Sstevel@tonic-gate (void) printf(gettext("Action %s set for %s.\n"), action, fmri); 14577c478bd9Sstevel@tonic-gate 14587c478bd9Sstevel@tonic-gate out: 14597c478bd9Sstevel@tonic-gate scf_value_destroy(v); 14607c478bd9Sstevel@tonic-gate scf_entry_destroy(ent); 14617c478bd9Sstevel@tonic-gate scf_transaction_destroy(tx); 14627c478bd9Sstevel@tonic-gate scf_property_destroy(prop); 14637c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 14647c478bd9Sstevel@tonic-gate } 14657c478bd9Sstevel@tonic-gate 14667c478bd9Sstevel@tonic-gate /* 14677c478bd9Sstevel@tonic-gate * Get the state of inst. state should point to a buffer of 14687c478bd9Sstevel@tonic-gate * MAX_SCF_STATE_STRING_SZ bytes. Returns 0 on success or -1 if 14697c478bd9Sstevel@tonic-gate * no restarter property group 14707c478bd9Sstevel@tonic-gate * no state property 14717c478bd9Sstevel@tonic-gate * state property is misconfigured (wrong type, not single-valued) 14727c478bd9Sstevel@tonic-gate * state value is too long 14737c478bd9Sstevel@tonic-gate * In these cases, fmri is used to print a warning. 14747c478bd9Sstevel@tonic-gate * 14757c478bd9Sstevel@tonic-gate * If pgp is non-NULL, a successful call to inst_get_state will store 14767c478bd9Sstevel@tonic-gate * the SCF_PG_RESTARTER property group in *pgp, and the caller will be 14777c478bd9Sstevel@tonic-gate * responsible for calling scf_pg_destroy on the property group. 14787c478bd9Sstevel@tonic-gate */ 14797c478bd9Sstevel@tonic-gate int 14807c478bd9Sstevel@tonic-gate inst_get_state(scf_instance_t *inst, char *state, const char *fmri, 14817c478bd9Sstevel@tonic-gate scf_propertygroup_t **pgp) 14827c478bd9Sstevel@tonic-gate { 14837c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg; 14847c478bd9Sstevel@tonic-gate scf_property_t *prop; 14857c478bd9Sstevel@tonic-gate scf_value_t *val; 14867c478bd9Sstevel@tonic-gate int ret = -1; 14877c478bd9Sstevel@tonic-gate ssize_t szret; 14887c478bd9Sstevel@tonic-gate 14897c478bd9Sstevel@tonic-gate if ((pg = scf_pg_create(h)) == NULL || 14907c478bd9Sstevel@tonic-gate (prop = scf_property_create(h)) == NULL || 14917c478bd9Sstevel@tonic-gate (val = scf_value_create(h)) == NULL) 14927c478bd9Sstevel@tonic-gate scfdie(); 14937c478bd9Sstevel@tonic-gate 14947c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, pg) != SCF_SUCCESS) { 14957c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 14967c478bd9Sstevel@tonic-gate scfdie(); 14977c478bd9Sstevel@tonic-gate 14987c478bd9Sstevel@tonic-gate uu_warn(gettext("%s is misconfigured (lacks \"%s\" property " 14997c478bd9Sstevel@tonic-gate "group).\n"), fmri ? fmri : inst_get_fmri(inst), 15007c478bd9Sstevel@tonic-gate SCF_PG_RESTARTER); 15017c478bd9Sstevel@tonic-gate goto out; 15027c478bd9Sstevel@tonic-gate } 15037c478bd9Sstevel@tonic-gate 15047c478bd9Sstevel@tonic-gate szret = get_astring_prop(pg, SCF_PROPERTY_STATE, prop, val, state, 15057c478bd9Sstevel@tonic-gate MAX_SCF_STATE_STRING_SZ); 15067c478bd9Sstevel@tonic-gate if (szret < 0) { 15077c478bd9Sstevel@tonic-gate switch (-szret) { 15087c478bd9Sstevel@tonic-gate case ENOENT: 15097c478bd9Sstevel@tonic-gate uu_warn(gettext("%s is misconfigured (\"%s\" property " 15107c478bd9Sstevel@tonic-gate "group lacks \"%s\" property).\n"), 15117c478bd9Sstevel@tonic-gate fmri ? fmri : inst_get_fmri(inst), SCF_PG_RESTARTER, 15127c478bd9Sstevel@tonic-gate SCF_PROPERTY_STATE); 15137c478bd9Sstevel@tonic-gate goto out; 15147c478bd9Sstevel@tonic-gate 15157c478bd9Sstevel@tonic-gate case E2BIG: 15167c478bd9Sstevel@tonic-gate uu_warn(gettext("%s is misconfigured (\"%s/%s\" " 15177c478bd9Sstevel@tonic-gate "property is not single-valued).\n"), 15187c478bd9Sstevel@tonic-gate fmri ? fmri : inst_get_fmri(inst), SCF_PG_RESTARTER, 15197c478bd9Sstevel@tonic-gate SCF_PROPERTY_STATE); 15207c478bd9Sstevel@tonic-gate goto out; 15217c478bd9Sstevel@tonic-gate 15227c478bd9Sstevel@tonic-gate case EINVAL: 15237c478bd9Sstevel@tonic-gate uu_warn(gettext("%s is misconfigured (\"%s/%s\" " 15247c478bd9Sstevel@tonic-gate "property is not of type astring).\n"), 15257c478bd9Sstevel@tonic-gate fmri ? fmri : inst_get_fmri(inst), SCF_PG_RESTARTER, 15267c478bd9Sstevel@tonic-gate SCF_PROPERTY_STATE); 15277c478bd9Sstevel@tonic-gate goto out; 15287c478bd9Sstevel@tonic-gate 15297c478bd9Sstevel@tonic-gate default: 15307c478bd9Sstevel@tonic-gate assert(0); 15317c478bd9Sstevel@tonic-gate abort(); 15327c478bd9Sstevel@tonic-gate } 15337c478bd9Sstevel@tonic-gate } 15347c478bd9Sstevel@tonic-gate if (szret >= MAX_SCF_STATE_STRING_SZ) { 15357c478bd9Sstevel@tonic-gate uu_warn(gettext("%s is misconfigured (\"%s/%s\" property value " 15367c478bd9Sstevel@tonic-gate "is too long).\n"), fmri ? fmri : inst_get_fmri(inst), 15377c478bd9Sstevel@tonic-gate SCF_PG_RESTARTER, SCF_PROPERTY_STATE); 15387c478bd9Sstevel@tonic-gate goto out; 15397c478bd9Sstevel@tonic-gate } 15407c478bd9Sstevel@tonic-gate 15417c478bd9Sstevel@tonic-gate ret = 0; 15427c478bd9Sstevel@tonic-gate if (pgp) 15437c478bd9Sstevel@tonic-gate *pgp = pg; 15447c478bd9Sstevel@tonic-gate 15457c478bd9Sstevel@tonic-gate out: 15467c478bd9Sstevel@tonic-gate (void) scf_value_destroy(val); 15477c478bd9Sstevel@tonic-gate scf_property_destroy(prop); 15487c478bd9Sstevel@tonic-gate if (ret || pgp == NULL) 15497c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 15507c478bd9Sstevel@tonic-gate return (ret); 15517c478bd9Sstevel@tonic-gate } 15527c478bd9Sstevel@tonic-gate 15537c478bd9Sstevel@tonic-gate static void 15547c478bd9Sstevel@tonic-gate set_astring_prop(const char *fmri, const char *pgname, const char *pgtype, 15557c478bd9Sstevel@tonic-gate uint32_t pgflags, const char *propname, const char *str) 15567c478bd9Sstevel@tonic-gate { 15577c478bd9Sstevel@tonic-gate scf_instance_t *inst; 15587c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg; 15597c478bd9Sstevel@tonic-gate scf_property_t *prop; 15607c478bd9Sstevel@tonic-gate scf_value_t *val; 15617c478bd9Sstevel@tonic-gate scf_transaction_t *tx; 15627c478bd9Sstevel@tonic-gate scf_transaction_entry_t *txent; 15637c478bd9Sstevel@tonic-gate int ret; 15647c478bd9Sstevel@tonic-gate 15657c478bd9Sstevel@tonic-gate inst = scf_instance_create(h); 15667c478bd9Sstevel@tonic-gate if (inst == NULL) 15677c478bd9Sstevel@tonic-gate scfdie(); 15687c478bd9Sstevel@tonic-gate 15697c478bd9Sstevel@tonic-gate if (get_inst(fmri, inst) != 0) 15707c478bd9Sstevel@tonic-gate return; 15717c478bd9Sstevel@tonic-gate 15727c478bd9Sstevel@tonic-gate if ((pg = scf_pg_create(h)) == NULL || 15737c478bd9Sstevel@tonic-gate (prop = scf_property_create(h)) == NULL || 15747c478bd9Sstevel@tonic-gate (val = scf_value_create(h)) == NULL || 15757c478bd9Sstevel@tonic-gate (tx = scf_transaction_create(h)) == NULL || 15767c478bd9Sstevel@tonic-gate (txent = scf_entry_create(h)) == NULL) 15777c478bd9Sstevel@tonic-gate scfdie(); 15787c478bd9Sstevel@tonic-gate 15797c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(inst, pgname, pg) != SCF_SUCCESS) { 15807c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 15817c478bd9Sstevel@tonic-gate scfdie(); 15827c478bd9Sstevel@tonic-gate 15837c478bd9Sstevel@tonic-gate if (scf_instance_add_pg(inst, pgname, pgtype, pgflags, pg) != 15847c478bd9Sstevel@tonic-gate SCF_SUCCESS) { 15857c478bd9Sstevel@tonic-gate switch (scf_error()) { 15867c478bd9Sstevel@tonic-gate case SCF_ERROR_EXISTS: 15877c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(inst, pgname, pg) != 15887c478bd9Sstevel@tonic-gate SCF_SUCCESS) { 15897c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 15907c478bd9Sstevel@tonic-gate scfdie(); 15917c478bd9Sstevel@tonic-gate 15927c478bd9Sstevel@tonic-gate uu_warn(gettext("Repository write " 15937c478bd9Sstevel@tonic-gate "contention.\n")); 15947c478bd9Sstevel@tonic-gate goto out; 15957c478bd9Sstevel@tonic-gate } 15967c478bd9Sstevel@tonic-gate break; 15977c478bd9Sstevel@tonic-gate 15987c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED: 15997c478bd9Sstevel@tonic-gate if (!verbose) 16007c478bd9Sstevel@tonic-gate uu_warn(emsg_permission_denied, fmri); 16017c478bd9Sstevel@tonic-gate else 16027c478bd9Sstevel@tonic-gate uu_warn(emsg_create_pg_perm_denied, 16037c478bd9Sstevel@tonic-gate fmri, pgname); 16047c478bd9Sstevel@tonic-gate goto out; 16057c478bd9Sstevel@tonic-gate 16067c478bd9Sstevel@tonic-gate default: 16077c478bd9Sstevel@tonic-gate scfdie(); 16087c478bd9Sstevel@tonic-gate } 16097c478bd9Sstevel@tonic-gate } 16107c478bd9Sstevel@tonic-gate } 16117c478bd9Sstevel@tonic-gate 16127c478bd9Sstevel@tonic-gate do { 16137c478bd9Sstevel@tonic-gate if (scf_transaction_start(tx, pg) != SCF_SUCCESS) { 16147c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_PERMISSION_DENIED) 16157c478bd9Sstevel@tonic-gate scfdie(); 16167c478bd9Sstevel@tonic-gate 16177c478bd9Sstevel@tonic-gate if (!verbose) 16187c478bd9Sstevel@tonic-gate uu_warn(emsg_permission_denied, fmri); 16197c478bd9Sstevel@tonic-gate else 16207c478bd9Sstevel@tonic-gate uu_warn(emsg_pg_perm_denied, fmri, pgname); 16217c478bd9Sstevel@tonic-gate goto out; 16227c478bd9Sstevel@tonic-gate } 16237c478bd9Sstevel@tonic-gate 16247c478bd9Sstevel@tonic-gate if (scf_transaction_property_change_type(tx, txent, propname, 16257c478bd9Sstevel@tonic-gate SCF_TYPE_ASTRING) != 0) { 16267c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 16277c478bd9Sstevel@tonic-gate scfdie(); 16287c478bd9Sstevel@tonic-gate 16297c478bd9Sstevel@tonic-gate if (scf_transaction_property_new(tx, txent, propname, 16307c478bd9Sstevel@tonic-gate SCF_TYPE_ASTRING) != 0) 16317c478bd9Sstevel@tonic-gate scfdie(); 16327c478bd9Sstevel@tonic-gate } 16337c478bd9Sstevel@tonic-gate 16347c478bd9Sstevel@tonic-gate if (scf_value_set_astring(val, str) != SCF_SUCCESS) 16357c478bd9Sstevel@tonic-gate scfdie(); 16367c478bd9Sstevel@tonic-gate 16377c478bd9Sstevel@tonic-gate if (scf_entry_add_value(txent, val) != SCF_SUCCESS) 16387c478bd9Sstevel@tonic-gate scfdie(); 16397c478bd9Sstevel@tonic-gate 16407c478bd9Sstevel@tonic-gate ret = scf_transaction_commit(tx); 16417c478bd9Sstevel@tonic-gate if (ret == -1) { 16427c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_PERMISSION_DENIED) 16437c478bd9Sstevel@tonic-gate scfdie(); 16447c478bd9Sstevel@tonic-gate 16457c478bd9Sstevel@tonic-gate if (!verbose) 16467c478bd9Sstevel@tonic-gate uu_warn(emsg_permission_denied, fmri); 16477c478bd9Sstevel@tonic-gate else 16487c478bd9Sstevel@tonic-gate uu_warn(emsg_prop_perm_denied, fmri, pgname, 16497c478bd9Sstevel@tonic-gate propname); 16507c478bd9Sstevel@tonic-gate goto out; 16517c478bd9Sstevel@tonic-gate } 16527c478bd9Sstevel@tonic-gate 16537c478bd9Sstevel@tonic-gate if (ret == 0) { 16547c478bd9Sstevel@tonic-gate scf_transaction_reset(tx); 16557c478bd9Sstevel@tonic-gate 1656bc9767f9Stn if (scf_pg_update(pg) == -1) 16577c478bd9Sstevel@tonic-gate scfdie(); 16587c478bd9Sstevel@tonic-gate } 16597c478bd9Sstevel@tonic-gate } while (ret == 0); 16607c478bd9Sstevel@tonic-gate 16617c478bd9Sstevel@tonic-gate out: 16627c478bd9Sstevel@tonic-gate scf_transaction_destroy(tx); 16637c478bd9Sstevel@tonic-gate scf_entry_destroy(txent); 16647c478bd9Sstevel@tonic-gate scf_value_destroy(val); 16657c478bd9Sstevel@tonic-gate scf_property_destroy(prop); 16667c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 16677c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 16687c478bd9Sstevel@tonic-gate } 16697c478bd9Sstevel@tonic-gate 16707c478bd9Sstevel@tonic-gate 16717c478bd9Sstevel@tonic-gate /* 16727c478bd9Sstevel@tonic-gate * Flags to control enable and disable actions. 16737c478bd9Sstevel@tonic-gate */ 16747c478bd9Sstevel@tonic-gate #define SET_ENABLED 0x1 16757c478bd9Sstevel@tonic-gate #define SET_TEMPORARY 0x2 16767c478bd9Sstevel@tonic-gate #define SET_RECURSIVE 0x4 16777c478bd9Sstevel@tonic-gate 16787c478bd9Sstevel@tonic-gate static int 16797c478bd9Sstevel@tonic-gate set_fmri_enabled(void *data, scf_walkinfo_t *wip) 16807c478bd9Sstevel@tonic-gate { 16817c478bd9Sstevel@tonic-gate int flags = (int)data; 16827c478bd9Sstevel@tonic-gate 16837c478bd9Sstevel@tonic-gate assert(wip->inst != NULL); 16847c478bd9Sstevel@tonic-gate assert(wip->pg == NULL); 16857c478bd9Sstevel@tonic-gate 168637b40227SJerry Jelinek if (svcsearch) { 168737b40227SJerry Jelinek char state[MAX_SCF_STATE_STRING_SZ]; 168837b40227SJerry Jelinek 168937b40227SJerry Jelinek if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0) 169037b40227SJerry Jelinek return (0); 169137b40227SJerry Jelinek if (strcmp(state, svcstate) != 0) 169237b40227SJerry Jelinek return (0); 169337b40227SJerry Jelinek } 169437b40227SJerry Jelinek 16957c478bd9Sstevel@tonic-gate if (flags & SET_RECURSIVE) { 16967c478bd9Sstevel@tonic-gate char *fmri_buf = malloc(max_scf_fmri_sz); 16977c478bd9Sstevel@tonic-gate if (fmri_buf == NULL) 16987c478bd9Sstevel@tonic-gate uu_die(emsg_nomem); 16997c478bd9Sstevel@tonic-gate 17007c478bd9Sstevel@tonic-gate visited = calloc(HT_BUCKETS, sizeof (*visited)); 17017c478bd9Sstevel@tonic-gate if (visited == NULL) 17027c478bd9Sstevel@tonic-gate uu_die(emsg_nomem); 17037c478bd9Sstevel@tonic-gate 17047c478bd9Sstevel@tonic-gate /* scf_walk_fmri() guarantees that fmri isn't too long */ 17057c478bd9Sstevel@tonic-gate assert(strlen(wip->fmri) <= max_scf_fmri_sz); 17067c478bd9Sstevel@tonic-gate (void) strlcpy(fmri_buf, wip->fmri, max_scf_fmri_sz); 17077c478bd9Sstevel@tonic-gate 17087c478bd9Sstevel@tonic-gate switch (enable_fmri_rec(fmri_buf, (flags & SET_TEMPORARY))) { 17097c478bd9Sstevel@tonic-gate case E2BIG: 17107c478bd9Sstevel@tonic-gate uu_warn(gettext("operation on service %s is ambiguous; " 17117c478bd9Sstevel@tonic-gate "instance specification needed.\n"), fmri_buf); 17127c478bd9Sstevel@tonic-gate break; 17137c478bd9Sstevel@tonic-gate 17147c478bd9Sstevel@tonic-gate case ELOOP: 17157c478bd9Sstevel@tonic-gate uu_warn(gettext("%s: Dependency cycle detected.\n"), 17167c478bd9Sstevel@tonic-gate fmri_buf); 17177c478bd9Sstevel@tonic-gate } 17187c478bd9Sstevel@tonic-gate 17197c478bd9Sstevel@tonic-gate free(visited); 17207c478bd9Sstevel@tonic-gate free(fmri_buf); 17217c478bd9Sstevel@tonic-gate 17227c478bd9Sstevel@tonic-gate } else { 17237c478bd9Sstevel@tonic-gate set_inst_enabled(wip->fmri, wip->inst, 17247c478bd9Sstevel@tonic-gate (flags & SET_TEMPORARY) != 0, (flags & SET_ENABLED) != 0); 17257c478bd9Sstevel@tonic-gate } 17267c478bd9Sstevel@tonic-gate 17277c478bd9Sstevel@tonic-gate return (0); 17287c478bd9Sstevel@tonic-gate } 17297c478bd9Sstevel@tonic-gate 17307c478bd9Sstevel@tonic-gate /* ARGSUSED */ 17317c478bd9Sstevel@tonic-gate static int 17327c478bd9Sstevel@tonic-gate wait_fmri_enabled(void *data, scf_walkinfo_t *wip) 17337c478bd9Sstevel@tonic-gate { 17347c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg = NULL; 17357c478bd9Sstevel@tonic-gate char state[MAX_SCF_STATE_STRING_SZ]; 17367c478bd9Sstevel@tonic-gate 17377c478bd9Sstevel@tonic-gate assert(wip->inst != NULL); 17387c478bd9Sstevel@tonic-gate assert(wip->pg == NULL); 17397c478bd9Sstevel@tonic-gate 17407c478bd9Sstevel@tonic-gate do { 17417c478bd9Sstevel@tonic-gate if (pg) 17427c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 17437c478bd9Sstevel@tonic-gate if (inst_get_state(wip->inst, state, wip->fmri, &pg) != 0) { 17447c478bd9Sstevel@tonic-gate exit_status = EXIT_SVC_FAILURE; 17457c478bd9Sstevel@tonic-gate return (0); 17467c478bd9Sstevel@tonic-gate } 17477c478bd9Sstevel@tonic-gate 17487c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0 || 17497c478bd9Sstevel@tonic-gate strcmp(state, SCF_STATE_STRING_DEGRADED) == 0) { 17507c478bd9Sstevel@tonic-gate /* 17517c478bd9Sstevel@tonic-gate * We're done. 17527c478bd9Sstevel@tonic-gate */ 17537c478bd9Sstevel@tonic-gate goto out; 17547c478bd9Sstevel@tonic-gate } 17557c478bd9Sstevel@tonic-gate 17567c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) { 17577c478bd9Sstevel@tonic-gate /* 17587c478bd9Sstevel@tonic-gate * The service is ill. 17597c478bd9Sstevel@tonic-gate */ 17607c478bd9Sstevel@tonic-gate uu_warn(gettext("Instance \"%s\" is in maintenance" 17617c478bd9Sstevel@tonic-gate " state.\n"), wip->fmri); 17627c478bd9Sstevel@tonic-gate exit_status = EXIT_SVC_FAILURE; 17637c478bd9Sstevel@tonic-gate goto out; 17647c478bd9Sstevel@tonic-gate } 17657c478bd9Sstevel@tonic-gate 17667c478bd9Sstevel@tonic-gate if (!is_enabled(wip->inst)) { 17677c478bd9Sstevel@tonic-gate /* 17687c478bd9Sstevel@tonic-gate * Someone stepped in and disabled the service. 17697c478bd9Sstevel@tonic-gate */ 17707c478bd9Sstevel@tonic-gate uu_warn(gettext("Instance \"%s\" has been disabled" 17717c478bd9Sstevel@tonic-gate " by another entity.\n"), wip->fmri); 17727c478bd9Sstevel@tonic-gate exit_status = EXIT_SVC_FAILURE; 17737c478bd9Sstevel@tonic-gate goto out; 17747c478bd9Sstevel@tonic-gate } 17757c478bd9Sstevel@tonic-gate 17767c478bd9Sstevel@tonic-gate if (!has_potential(wip->inst, B_FALSE)) { 17777c478bd9Sstevel@tonic-gate /* 17787c478bd9Sstevel@tonic-gate * Our dependencies aren't met. We'll never 17797c478bd9Sstevel@tonic-gate * amount to anything. 17807c478bd9Sstevel@tonic-gate */ 17817c478bd9Sstevel@tonic-gate uu_warn(gettext("Instance \"%s\" has unsatisfied" 17827c478bd9Sstevel@tonic-gate " dependencies.\n"), wip->fmri); 17837c478bd9Sstevel@tonic-gate /* 17847c478bd9Sstevel@tonic-gate * EXIT_SVC_FAILURE takes precedence over 17857c478bd9Sstevel@tonic-gate * EXIT_DEP_FAILURE 17867c478bd9Sstevel@tonic-gate */ 17877c478bd9Sstevel@tonic-gate if (exit_status == 0) 17887c478bd9Sstevel@tonic-gate exit_status = EXIT_DEP_FAILURE; 17897c478bd9Sstevel@tonic-gate goto out; 17907c478bd9Sstevel@tonic-gate } 17917c478bd9Sstevel@tonic-gate } while (_scf_pg_wait(pg, WAIT_INTERVAL) >= 0); 17927c478bd9Sstevel@tonic-gate scfdie(); 17937c478bd9Sstevel@tonic-gate /* NOTREACHED */ 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate out: 17967c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 17977c478bd9Sstevel@tonic-gate return (0); 17987c478bd9Sstevel@tonic-gate } 17997c478bd9Sstevel@tonic-gate 18007c478bd9Sstevel@tonic-gate /* ARGSUSED */ 18017c478bd9Sstevel@tonic-gate static int 18027c478bd9Sstevel@tonic-gate wait_fmri_disabled(void *data, scf_walkinfo_t *wip) 18037c478bd9Sstevel@tonic-gate { 18047c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg = NULL; 18057c478bd9Sstevel@tonic-gate char state[MAX_SCF_STATE_STRING_SZ]; 18067c478bd9Sstevel@tonic-gate 18077c478bd9Sstevel@tonic-gate assert(wip->inst != NULL); 18087c478bd9Sstevel@tonic-gate assert(wip->pg == NULL); 18097c478bd9Sstevel@tonic-gate 18107c478bd9Sstevel@tonic-gate do { 18117c478bd9Sstevel@tonic-gate if (pg) 18127c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 18137c478bd9Sstevel@tonic-gate if (inst_get_state(wip->inst, state, wip->fmri, &pg) != 0) { 18147c478bd9Sstevel@tonic-gate exit_status = EXIT_SVC_FAILURE; 18157c478bd9Sstevel@tonic-gate return (0); 18167c478bd9Sstevel@tonic-gate } 18177c478bd9Sstevel@tonic-gate 18187c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0) { 18197c478bd9Sstevel@tonic-gate /* 18207c478bd9Sstevel@tonic-gate * We're done. 18217c478bd9Sstevel@tonic-gate */ 18227c478bd9Sstevel@tonic-gate goto out; 18237c478bd9Sstevel@tonic-gate } 18247c478bd9Sstevel@tonic-gate 18257c478bd9Sstevel@tonic-gate if (is_enabled(wip->inst)) { 18267c478bd9Sstevel@tonic-gate /* 18277c478bd9Sstevel@tonic-gate * Someone stepped in and enabled the service. 18287c478bd9Sstevel@tonic-gate */ 18297c478bd9Sstevel@tonic-gate uu_warn(gettext("Instance \"%s\" has been enabled" 18307c478bd9Sstevel@tonic-gate " by another entity.\n"), wip->fmri); 18317c478bd9Sstevel@tonic-gate exit_status = EXIT_SVC_FAILURE; 18327c478bd9Sstevel@tonic-gate goto out; 18337c478bd9Sstevel@tonic-gate } 18347c478bd9Sstevel@tonic-gate 18357c478bd9Sstevel@tonic-gate if (!has_potential(wip->inst, B_TRUE)) { 18367c478bd9Sstevel@tonic-gate /* 18377c478bd9Sstevel@tonic-gate * Our restarter is hopeless. 18387c478bd9Sstevel@tonic-gate */ 18397c478bd9Sstevel@tonic-gate uu_warn(gettext("Restarter for instance \"%s\" is" 18407c478bd9Sstevel@tonic-gate " unavailable.\n"), wip->fmri); 18417c478bd9Sstevel@tonic-gate /* 18427c478bd9Sstevel@tonic-gate * EXIT_SVC_FAILURE takes precedence over 18437c478bd9Sstevel@tonic-gate * EXIT_DEP_FAILURE 18447c478bd9Sstevel@tonic-gate */ 18457c478bd9Sstevel@tonic-gate if (exit_status == 0) 18467c478bd9Sstevel@tonic-gate exit_status = EXIT_DEP_FAILURE; 18477c478bd9Sstevel@tonic-gate goto out; 18487c478bd9Sstevel@tonic-gate } 18497c478bd9Sstevel@tonic-gate 18507c478bd9Sstevel@tonic-gate } while (_scf_pg_wait(pg, WAIT_INTERVAL) >= 0); 18517c478bd9Sstevel@tonic-gate scfdie(); 18527c478bd9Sstevel@tonic-gate /* NOTREACHED */ 18537c478bd9Sstevel@tonic-gate 18547c478bd9Sstevel@tonic-gate out: 18557c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 18567c478bd9Sstevel@tonic-gate return (0); 18577c478bd9Sstevel@tonic-gate } 18587c478bd9Sstevel@tonic-gate 18597c478bd9Sstevel@tonic-gate /* ARGSUSED */ 18607c478bd9Sstevel@tonic-gate static int 18617c478bd9Sstevel@tonic-gate clear_instance(void *data, scf_walkinfo_t *wip) 18627c478bd9Sstevel@tonic-gate { 18637c478bd9Sstevel@tonic-gate char state[MAX_SCF_STATE_STRING_SZ]; 18647c478bd9Sstevel@tonic-gate 18657c478bd9Sstevel@tonic-gate assert(wip->inst != NULL); 18667c478bd9Sstevel@tonic-gate assert(wip->pg == NULL); 18677c478bd9Sstevel@tonic-gate 18687c478bd9Sstevel@tonic-gate if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0) 18697c478bd9Sstevel@tonic-gate return (0); 18707c478bd9Sstevel@tonic-gate 187137b40227SJerry Jelinek if (svcsearch && strcmp(state, svcstate) != 0) 187237b40227SJerry Jelinek return (0); 187337b40227SJerry Jelinek 18747c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) { 18757c478bd9Sstevel@tonic-gate set_inst_action(wip->fmri, wip->inst, SCF_PROPERTY_MAINT_OFF); 18767c478bd9Sstevel@tonic-gate } else if (strcmp(state, SCF_STATE_STRING_DEGRADED) == 18777c478bd9Sstevel@tonic-gate 0) { 18787c478bd9Sstevel@tonic-gate set_inst_action(wip->fmri, wip->inst, SCF_PROPERTY_RESTORE); 18797c478bd9Sstevel@tonic-gate } else { 18807c478bd9Sstevel@tonic-gate uu_warn(gettext("Instance \"%s\" is not in a " 18817c478bd9Sstevel@tonic-gate "maintenance or degraded state.\n"), wip->fmri); 18827c478bd9Sstevel@tonic-gate 18837c478bd9Sstevel@tonic-gate exit_status = 1; 18847c478bd9Sstevel@tonic-gate } 18857c478bd9Sstevel@tonic-gate 18867c478bd9Sstevel@tonic-gate return (0); 18877c478bd9Sstevel@tonic-gate } 18887c478bd9Sstevel@tonic-gate 18897c478bd9Sstevel@tonic-gate static int 18907c478bd9Sstevel@tonic-gate set_fmri_action(void *action, scf_walkinfo_t *wip) 18917c478bd9Sstevel@tonic-gate { 18927c478bd9Sstevel@tonic-gate assert(wip->inst != NULL && wip->pg == NULL); 18937c478bd9Sstevel@tonic-gate 189437b40227SJerry Jelinek if (svcsearch) { 189537b40227SJerry Jelinek char state[MAX_SCF_STATE_STRING_SZ]; 189637b40227SJerry Jelinek 189737b40227SJerry Jelinek if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0) 189837b40227SJerry Jelinek return (0); 189937b40227SJerry Jelinek if (strcmp(state, svcstate) != 0) 190037b40227SJerry Jelinek return (0); 190137b40227SJerry Jelinek } 190237b40227SJerry Jelinek 19037c478bd9Sstevel@tonic-gate set_inst_action(wip->fmri, wip->inst, action); 19047c478bd9Sstevel@tonic-gate 19057c478bd9Sstevel@tonic-gate return (0); 19067c478bd9Sstevel@tonic-gate } 19077c478bd9Sstevel@tonic-gate 19087c478bd9Sstevel@tonic-gate /* 19097c478bd9Sstevel@tonic-gate * Flags to control 'mark' action. 19107c478bd9Sstevel@tonic-gate */ 19117c478bd9Sstevel@tonic-gate #define MARK_IMMEDIATE 0x1 19127c478bd9Sstevel@tonic-gate #define MARK_TEMPORARY 0x2 19137c478bd9Sstevel@tonic-gate 19147c478bd9Sstevel@tonic-gate static int 19157c478bd9Sstevel@tonic-gate force_degraded(void *data, scf_walkinfo_t *wip) 19167c478bd9Sstevel@tonic-gate { 19177c478bd9Sstevel@tonic-gate int flags = (int)data; 19187c478bd9Sstevel@tonic-gate char state[MAX_SCF_STATE_STRING_SZ]; 19197c478bd9Sstevel@tonic-gate 19207c478bd9Sstevel@tonic-gate if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0) { 19217c478bd9Sstevel@tonic-gate exit_status = 1; 19227c478bd9Sstevel@tonic-gate return (0); 19237c478bd9Sstevel@tonic-gate } 19247c478bd9Sstevel@tonic-gate 192537b40227SJerry Jelinek if (svcsearch && strcmp(state, svcstate) != 0) 192637b40227SJerry Jelinek return (0); 192737b40227SJerry Jelinek 19287c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_ONLINE) != 0) { 19297c478bd9Sstevel@tonic-gate uu_warn(gettext("Instance \"%s\" is not online.\n"), wip->fmri); 19307c478bd9Sstevel@tonic-gate exit_status = 1; 19317c478bd9Sstevel@tonic-gate return (0); 19327c478bd9Sstevel@tonic-gate } 19337c478bd9Sstevel@tonic-gate 19347c478bd9Sstevel@tonic-gate set_inst_action(wip->fmri, wip->inst, (flags & MARK_IMMEDIATE) ? 19357c478bd9Sstevel@tonic-gate SCF_PROPERTY_DEGRADE_IMMEDIATE : SCF_PROPERTY_DEGRADED); 19367c478bd9Sstevel@tonic-gate 19377c478bd9Sstevel@tonic-gate return (0); 19387c478bd9Sstevel@tonic-gate } 19397c478bd9Sstevel@tonic-gate 19407c478bd9Sstevel@tonic-gate static int 19417c478bd9Sstevel@tonic-gate force_maintenance(void *data, scf_walkinfo_t *wip) 19427c478bd9Sstevel@tonic-gate { 19437c478bd9Sstevel@tonic-gate int flags = (int)data; 19447c478bd9Sstevel@tonic-gate const char *prop; 19457c478bd9Sstevel@tonic-gate 194637b40227SJerry Jelinek if (svcsearch) { 194737b40227SJerry Jelinek char state[MAX_SCF_STATE_STRING_SZ]; 194837b40227SJerry Jelinek 194937b40227SJerry Jelinek if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0) 195037b40227SJerry Jelinek return (0); 195137b40227SJerry Jelinek if (strcmp(state, svcstate) != 0) 195237b40227SJerry Jelinek return (0); 195337b40227SJerry Jelinek } 195437b40227SJerry Jelinek 19557c478bd9Sstevel@tonic-gate if (flags & MARK_IMMEDIATE) { 19567c478bd9Sstevel@tonic-gate prop = (flags & MARK_TEMPORARY) ? 19577c478bd9Sstevel@tonic-gate SCF_PROPERTY_MAINT_ON_IMMTEMP : 19587c478bd9Sstevel@tonic-gate SCF_PROPERTY_MAINT_ON_IMMEDIATE; 19597c478bd9Sstevel@tonic-gate } else { 19607c478bd9Sstevel@tonic-gate prop = (flags & MARK_TEMPORARY) ? 19617c478bd9Sstevel@tonic-gate SCF_PROPERTY_MAINT_ON_TEMPORARY : 19627c478bd9Sstevel@tonic-gate SCF_PROPERTY_MAINT_ON; 19637c478bd9Sstevel@tonic-gate } 19647c478bd9Sstevel@tonic-gate 19657c478bd9Sstevel@tonic-gate set_inst_action(wip->fmri, wip->inst, prop); 19667c478bd9Sstevel@tonic-gate 19677c478bd9Sstevel@tonic-gate return (0); 19687c478bd9Sstevel@tonic-gate } 19697c478bd9Sstevel@tonic-gate 19707c478bd9Sstevel@tonic-gate static void 19717c478bd9Sstevel@tonic-gate set_milestone(const char *fmri, boolean_t temporary) 19727c478bd9Sstevel@tonic-gate { 19737c478bd9Sstevel@tonic-gate scf_instance_t *inst; 19747c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg; 19757c478bd9Sstevel@tonic-gate int r; 19767c478bd9Sstevel@tonic-gate 19777c478bd9Sstevel@tonic-gate if (temporary) { 19787c478bd9Sstevel@tonic-gate set_astring_prop(SCF_SERVICE_STARTD, SCF_PG_OPTIONS_OVR, 19797c478bd9Sstevel@tonic-gate SCF_PG_OPTIONS_OVR_TYPE, SCF_PG_OPTIONS_OVR_FLAGS, 19807c478bd9Sstevel@tonic-gate SCF_PROPERTY_MILESTONE, fmri); 19817c478bd9Sstevel@tonic-gate return; 19827c478bd9Sstevel@tonic-gate } 19837c478bd9Sstevel@tonic-gate 19847c478bd9Sstevel@tonic-gate if ((inst = scf_instance_create(h)) == NULL || 19857c478bd9Sstevel@tonic-gate (pg = scf_pg_create(h)) == NULL) 19867c478bd9Sstevel@tonic-gate scfdie(); 19877c478bd9Sstevel@tonic-gate 19887c478bd9Sstevel@tonic-gate if (get_inst(SCF_SERVICE_STARTD, inst) != 0) { 19897c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 19907c478bd9Sstevel@tonic-gate return; 19917c478bd9Sstevel@tonic-gate } 19927c478bd9Sstevel@tonic-gate 19937c478bd9Sstevel@tonic-gate /* 19947c478bd9Sstevel@tonic-gate * Set the persistent milestone before deleting the override so we don't 19957c478bd9Sstevel@tonic-gate * glitch. 19967c478bd9Sstevel@tonic-gate */ 19977c478bd9Sstevel@tonic-gate set_astring_prop(SCF_SERVICE_STARTD, SCF_PG_OPTIONS, 19987c478bd9Sstevel@tonic-gate SCF_PG_OPTIONS_TYPE, SCF_PG_OPTIONS_FLAGS, SCF_PROPERTY_MILESTONE, 19997c478bd9Sstevel@tonic-gate fmri); 20007c478bd9Sstevel@tonic-gate 2001eb1a3463STruong Nguyen r = scf_instance_delete_prop(inst, SCF_PG_OPTIONS_OVR, 2002eb1a3463STruong Nguyen SCF_PROPERTY_MILESTONE); 2003eb1a3463STruong Nguyen switch (r) { 2004eb1a3463STruong Nguyen case 0: 2005eb1a3463STruong Nguyen break; 20067c478bd9Sstevel@tonic-gate 2007eb1a3463STruong Nguyen case ECANCELED: 2008eb1a3463STruong Nguyen uu_warn(emsg_no_service, fmri); 2009eb1a3463STruong Nguyen exit_status = 1; 2010eb1a3463STruong Nguyen goto out; 20117c478bd9Sstevel@tonic-gate 2012eb1a3463STruong Nguyen case EPERM: 2013eb1a3463STruong Nguyen uu_warn(gettext("Could not delete %s/%s property of " 2014eb1a3463STruong Nguyen "%s: permission denied.\n"), SCF_PG_OPTIONS_OVR, 2015eb1a3463STruong Nguyen SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD); 2016eb1a3463STruong Nguyen exit_status = 1; 2017eb1a3463STruong Nguyen goto out; 20187c478bd9Sstevel@tonic-gate 2019eb1a3463STruong Nguyen case EACCES: 2020eb1a3463STruong Nguyen uu_warn(gettext("Could not delete %s/%s property of " 2021eb1a3463STruong Nguyen "%s: access denied.\n"), SCF_PG_OPTIONS_OVR, 2022eb1a3463STruong Nguyen SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD); 2023eb1a3463STruong Nguyen exit_status = 1; 2024eb1a3463STruong Nguyen goto out; 20257c478bd9Sstevel@tonic-gate 2026eb1a3463STruong Nguyen case EROFS: 2027eb1a3463STruong Nguyen uu_warn(gettext("Could not delete %s/%s property of " 2028eb1a3463STruong Nguyen "%s: backend read-only.\n"), SCF_PG_OPTIONS_OVR, 2029eb1a3463STruong Nguyen SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD); 2030eb1a3463STruong Nguyen exit_status = 1; 2031eb1a3463STruong Nguyen goto out; 20327c478bd9Sstevel@tonic-gate 2033eb1a3463STruong Nguyen default: 2034eb1a3463STruong Nguyen bad_error("scf_instance_delete_prop", r); 20357c478bd9Sstevel@tonic-gate } 20367c478bd9Sstevel@tonic-gate 20377c478bd9Sstevel@tonic-gate out: 20387c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 20397c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 20407c478bd9Sstevel@tonic-gate } 20417c478bd9Sstevel@tonic-gate 20427c478bd9Sstevel@tonic-gate static char const *milestones[] = { 20437c478bd9Sstevel@tonic-gate SCF_MILESTONE_SINGLE_USER, 20447c478bd9Sstevel@tonic-gate SCF_MILESTONE_MULTI_USER, 20457c478bd9Sstevel@tonic-gate SCF_MILESTONE_MULTI_USER_SERVER, 20467c478bd9Sstevel@tonic-gate NULL 20477c478bd9Sstevel@tonic-gate }; 20487c478bd9Sstevel@tonic-gate 20497c478bd9Sstevel@tonic-gate static void 20500b5c9250Shg usage_milestone(void) 20517c478bd9Sstevel@tonic-gate { 20527c478bd9Sstevel@tonic-gate const char **ms; 20537c478bd9Sstevel@tonic-gate 20547c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 20557c478bd9Sstevel@tonic-gate "Usage: svcadm milestone [-d] <milestone>\n\n" 20567c478bd9Sstevel@tonic-gate "\t-d\tmake the specified milestone the default for system boot\n\n" 20577c478bd9Sstevel@tonic-gate "\tMilestones can be specified using an FMRI or abbreviation.\n" 20587c478bd9Sstevel@tonic-gate "\tThe major milestones are as follows:\n\n" 20597c478bd9Sstevel@tonic-gate "\tall\n" 20607c478bd9Sstevel@tonic-gate "\tnone\n")); 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate for (ms = milestones; *ms != NULL; ms++) 20637c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\t%s\n", *ms); 20647c478bd9Sstevel@tonic-gate 20657c478bd9Sstevel@tonic-gate exit(UU_EXIT_USAGE); 20667c478bd9Sstevel@tonic-gate } 20677c478bd9Sstevel@tonic-gate 20687c478bd9Sstevel@tonic-gate static const char * 20697c478bd9Sstevel@tonic-gate validate_milestone(const char *milestone) 20707c478bd9Sstevel@tonic-gate { 20717c478bd9Sstevel@tonic-gate const char **ms; 20727c478bd9Sstevel@tonic-gate const char *tmp; 20737c478bd9Sstevel@tonic-gate size_t len; 20747c478bd9Sstevel@tonic-gate 20757c478bd9Sstevel@tonic-gate if (strcmp(milestone, "all") == 0) 20767c478bd9Sstevel@tonic-gate return (milestone); 20777c478bd9Sstevel@tonic-gate 20787c478bd9Sstevel@tonic-gate if (strcmp(milestone, "none") == 0) 20797c478bd9Sstevel@tonic-gate return (milestone); 20807c478bd9Sstevel@tonic-gate 20817c478bd9Sstevel@tonic-gate /* 20827c478bd9Sstevel@tonic-gate * Determine if this is a full or partial milestone 20837c478bd9Sstevel@tonic-gate */ 20847c478bd9Sstevel@tonic-gate for (ms = milestones; *ms != NULL; ms++) { 20857c478bd9Sstevel@tonic-gate if ((tmp = strstr(*ms, milestone)) != NULL) { 20867c478bd9Sstevel@tonic-gate len = strlen(milestone); 20877c478bd9Sstevel@tonic-gate 20887c478bd9Sstevel@tonic-gate /* 20897c478bd9Sstevel@tonic-gate * The beginning of the string must align with the start 20907c478bd9Sstevel@tonic-gate * of a milestone fmri, or on the boundary between 20917c478bd9Sstevel@tonic-gate * elements. The end of the string must align with the 20927c478bd9Sstevel@tonic-gate * end of the milestone, or at the instance boundary. 20937c478bd9Sstevel@tonic-gate */ 20947c478bd9Sstevel@tonic-gate if ((tmp == *ms || tmp[-1] == '/') && 20957c478bd9Sstevel@tonic-gate (tmp[len] == '\0' || tmp[len] == ':')) 20967c478bd9Sstevel@tonic-gate return (*ms); 20977c478bd9Sstevel@tonic-gate } 20987c478bd9Sstevel@tonic-gate } 20997c478bd9Sstevel@tonic-gate 21007c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 21017c478bd9Sstevel@tonic-gate gettext("\"%s\" is not a valid major milestone.\n"), milestone); 21027c478bd9Sstevel@tonic-gate 21037c478bd9Sstevel@tonic-gate usage_milestone(); 21047c478bd9Sstevel@tonic-gate /* NOTREACHED */ 21057c478bd9Sstevel@tonic-gate } 21067c478bd9Sstevel@tonic-gate 2107702a871aSJerry Jelinek /*PRINTFLIKE1*/ 2108702a871aSJerry Jelinek static void 2109702a871aSJerry Jelinek pr_warn(const char *format, ...) 2110702a871aSJerry Jelinek { 2111702a871aSJerry Jelinek const char *pname = uu_getpname(); 2112702a871aSJerry Jelinek va_list alist; 2113702a871aSJerry Jelinek 2114702a871aSJerry Jelinek va_start(alist, format); 2115702a871aSJerry Jelinek 2116702a871aSJerry Jelinek if (pname != NULL) 2117702a871aSJerry Jelinek (void) fprintf(stderr, "%s", pname); 2118702a871aSJerry Jelinek 2119702a871aSJerry Jelinek if (g_zonename != NULL) 2120702a871aSJerry Jelinek (void) fprintf(stderr, " (%s)", g_zonename); 2121702a871aSJerry Jelinek 2122702a871aSJerry Jelinek (void) fprintf(stderr, ": "); 2123702a871aSJerry Jelinek 2124702a871aSJerry Jelinek (void) vfprintf(stderr, format, alist); 2125702a871aSJerry Jelinek 2126702a871aSJerry Jelinek if (strrchr(format, '\n') == NULL) 2127702a871aSJerry Jelinek (void) fprintf(stderr, ": %s\n", strerror(errno)); 2128702a871aSJerry Jelinek 2129702a871aSJerry Jelinek va_end(alist); 2130702a871aSJerry Jelinek } 2131702a871aSJerry Jelinek 21327c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 21337c478bd9Sstevel@tonic-gate static void 21347c478bd9Sstevel@tonic-gate quiet(const char *fmt, ...) 21357c478bd9Sstevel@tonic-gate { 21367c478bd9Sstevel@tonic-gate /* Do nothing */ 21377c478bd9Sstevel@tonic-gate } 21387c478bd9Sstevel@tonic-gate 21397c478bd9Sstevel@tonic-gate int 21407c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 21417c478bd9Sstevel@tonic-gate { 21427c478bd9Sstevel@tonic-gate int o; 21437c478bd9Sstevel@tonic-gate int err; 2144c0889d7aSstevep int sw_back; 2145702a871aSJerry Jelinek boolean_t do_zones = B_FALSE; 2146702a871aSJerry Jelinek boolean_t do_a_zone = B_FALSE; 2147702a871aSJerry Jelinek char zonename[ZONENAME_MAX]; 2148702a871aSJerry Jelinek uint_t nzents = 0, zent = 0; 2149702a871aSJerry Jelinek zoneid_t *zids = NULL; 2150702a871aSJerry Jelinek int orig_optind, orig_argc; 2151702a871aSJerry Jelinek char **orig_argv; 21527c478bd9Sstevel@tonic-gate 21537c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 21547c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 21557c478bd9Sstevel@tonic-gate 21567c478bd9Sstevel@tonic-gate (void) uu_setpname(argv[0]); 21577c478bd9Sstevel@tonic-gate 21587c478bd9Sstevel@tonic-gate if (argc < 2) 21597c478bd9Sstevel@tonic-gate usage(); 21607c478bd9Sstevel@tonic-gate 21617c478bd9Sstevel@tonic-gate max_scf_fmri_sz = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH); 21627c478bd9Sstevel@tonic-gate if (max_scf_fmri_sz < 0) 21637c478bd9Sstevel@tonic-gate scfdie(); 21647c478bd9Sstevel@tonic-gate ++max_scf_fmri_sz; 21657c478bd9Sstevel@tonic-gate 21667c478bd9Sstevel@tonic-gate scratch_fmri = malloc(max_scf_fmri_sz); 21677c478bd9Sstevel@tonic-gate if (scratch_fmri == NULL) 21687c478bd9Sstevel@tonic-gate uu_die(emsg_nomem); 21697c478bd9Sstevel@tonic-gate 217037b40227SJerry Jelinek while ((o = getopt(argc, argv, "S:vZz:")) != -1) { 2171647f8444SBryan Cantrill switch (o) { 217237b40227SJerry Jelinek case 'S': 217337b40227SJerry Jelinek (void) strlcpy(svcstate, optarg, sizeof (svcstate)); 217437b40227SJerry Jelinek svcsearch = B_TRUE; 217537b40227SJerry Jelinek break; 217637b40227SJerry Jelinek 2177647f8444SBryan Cantrill case 'v': 21787c478bd9Sstevel@tonic-gate verbose = 1; 2179647f8444SBryan Cantrill break; 2180647f8444SBryan Cantrill 2181702a871aSJerry Jelinek case 'z': 2182647f8444SBryan Cantrill if (getzoneid() != GLOBAL_ZONEID) 2183647f8444SBryan Cantrill uu_die(gettext("svcadm -z may only be used " 2184647f8444SBryan Cantrill "from the global zone\n")); 2185702a871aSJerry Jelinek if (do_zones) 2186702a871aSJerry Jelinek usage(); 2187647f8444SBryan Cantrill 2188702a871aSJerry Jelinek (void) strlcpy(zonename, optarg, sizeof (zonename)); 2189702a871aSJerry Jelinek do_a_zone = B_TRUE; 2190702a871aSJerry Jelinek break; 2191647f8444SBryan Cantrill 2192702a871aSJerry Jelinek case 'Z': 2193702a871aSJerry Jelinek if (getzoneid() != GLOBAL_ZONEID) 2194702a871aSJerry Jelinek uu_die(gettext("svcadm -Z may only be used " 2195702a871aSJerry Jelinek "from the global zone\n")); 2196702a871aSJerry Jelinek if (do_a_zone) 2197702a871aSJerry Jelinek usage(); 2198647f8444SBryan Cantrill 2199702a871aSJerry Jelinek do_zones = B_TRUE; 2200647f8444SBryan Cantrill break; 2201647f8444SBryan Cantrill 2202647f8444SBryan Cantrill default: 22037c478bd9Sstevel@tonic-gate usage(); 2204647f8444SBryan Cantrill } 22057c478bd9Sstevel@tonic-gate } 22067c478bd9Sstevel@tonic-gate 2207702a871aSJerry Jelinek while (do_zones) { 2208702a871aSJerry Jelinek uint_t found; 2209647f8444SBryan Cantrill 2210702a871aSJerry Jelinek if (zone_list(NULL, &nzents) != 0) 2211702a871aSJerry Jelinek uu_die(gettext("could not get number of zones")); 2212702a871aSJerry Jelinek 2213702a871aSJerry Jelinek if ((zids = malloc(nzents * sizeof (zoneid_t))) == NULL) { 2214702a871aSJerry Jelinek uu_die(gettext("could not allocate array for " 2215702a871aSJerry Jelinek "%d zone IDs"), nzents); 2216702a871aSJerry Jelinek } 2217702a871aSJerry Jelinek 2218702a871aSJerry Jelinek found = nzents; 2219702a871aSJerry Jelinek 2220702a871aSJerry Jelinek if (zone_list(zids, &found) != 0) 2221702a871aSJerry Jelinek uu_die(gettext("could not get zone list")); 2222702a871aSJerry Jelinek 2223702a871aSJerry Jelinek /* 2224702a871aSJerry Jelinek * If the number of zones has not changed between our calls to 2225702a871aSJerry Jelinek * zone_list(), we're done -- otherwise, we must free our array 2226702a871aSJerry Jelinek * of zone IDs and take another lap. 2227702a871aSJerry Jelinek */ 2228702a871aSJerry Jelinek if (found == nzents) 2229702a871aSJerry Jelinek break; 2230702a871aSJerry Jelinek 2231702a871aSJerry Jelinek free(zids); 2232702a871aSJerry Jelinek } 22337c478bd9Sstevel@tonic-gate 22347c478bd9Sstevel@tonic-gate emsg_permission_denied = gettext("%s: Permission denied.\n"); 22357c478bd9Sstevel@tonic-gate emsg_nomem = gettext("Out of memory.\n"); 22367c478bd9Sstevel@tonic-gate emsg_create_pg_perm_denied = gettext("%s: Couldn't create \"%s\" " 22377c478bd9Sstevel@tonic-gate "property group (permission denied).\n"); 22387c478bd9Sstevel@tonic-gate emsg_pg_perm_denied = gettext("%s: Couldn't modify \"%s\" property " 22397c478bd9Sstevel@tonic-gate "group (permission denied).\n"); 22407c478bd9Sstevel@tonic-gate emsg_prop_perm_denied = gettext("%s: Couldn't modify \"%s/%s\" " 22417c478bd9Sstevel@tonic-gate "property (permission denied).\n"); 22427c478bd9Sstevel@tonic-gate emsg_no_service = gettext("No such service \"%s\".\n"); 22437c478bd9Sstevel@tonic-gate 2244702a871aSJerry Jelinek orig_optind = optind; 2245702a871aSJerry Jelinek orig_argc = argc; 2246702a871aSJerry Jelinek orig_argv = argv; 2247702a871aSJerry Jelinek 2248702a871aSJerry Jelinek again: 2249702a871aSJerry Jelinek h = scf_handle_create(SCF_VERSION); 2250702a871aSJerry Jelinek if (h == NULL) 2251702a871aSJerry Jelinek scfdie(); 2252702a871aSJerry Jelinek 2253702a871aSJerry Jelinek if (do_zones) { 2254702a871aSJerry Jelinek zone_status_t status; 2255702a871aSJerry Jelinek 2256702a871aSJerry Jelinek if (zone_getattr(zids[zent], ZONE_ATTR_STATUS, &status, 2257702a871aSJerry Jelinek sizeof (status)) < 0 || status != ZONE_IS_RUNNING) { 2258702a871aSJerry Jelinek /* 2259702a871aSJerry Jelinek * If this zone is not running or we cannot 2260702a871aSJerry Jelinek * get its status, we do not want to attempt 2261702a871aSJerry Jelinek * to bind an SCF handle to it, lest we 2262702a871aSJerry Jelinek * accidentally interfere with a zone that 2263702a871aSJerry Jelinek * is not yet running by looking up a door 2264702a871aSJerry Jelinek * to its svc.configd (which could potentially 2265702a871aSJerry Jelinek * block a mount with an EBUSY). 2266702a871aSJerry Jelinek */ 2267702a871aSJerry Jelinek zent++; 2268702a871aSJerry Jelinek goto nextzone; 2269702a871aSJerry Jelinek } 2270702a871aSJerry Jelinek 2271702a871aSJerry Jelinek if (getzonenamebyid(zids[zent++], zonename, 2272702a871aSJerry Jelinek sizeof (zonename)) < 0) { 2273702a871aSJerry Jelinek uu_warn(gettext("could not get name for " 2274702a871aSJerry Jelinek "zone %d; ignoring"), zids[zent - 1]); 2275702a871aSJerry Jelinek goto nextzone; 2276702a871aSJerry Jelinek } 2277702a871aSJerry Jelinek 2278702a871aSJerry Jelinek g_zonename = zonename; 2279702a871aSJerry Jelinek } 2280702a871aSJerry Jelinek 2281702a871aSJerry Jelinek if (do_a_zone || do_zones) { 2282702a871aSJerry Jelinek scf_value_t *zone; 2283702a871aSJerry Jelinek 2284702a871aSJerry Jelinek if ((zone = scf_value_create(h)) == NULL) 2285702a871aSJerry Jelinek scfdie(); 2286702a871aSJerry Jelinek 2287702a871aSJerry Jelinek if (scf_value_set_astring(zone, zonename) != SCF_SUCCESS) 2288702a871aSJerry Jelinek scfdie(); 2289702a871aSJerry Jelinek 2290702a871aSJerry Jelinek if (scf_handle_decorate(h, "zone", zone) != SCF_SUCCESS) { 2291702a871aSJerry Jelinek if (do_a_zone) { 2292702a871aSJerry Jelinek uu_die(gettext("invalid zone '%s'\n"), optarg); 2293702a871aSJerry Jelinek } else { 2294702a871aSJerry Jelinek scf_value_destroy(zone); 2295702a871aSJerry Jelinek goto nextzone; 2296702a871aSJerry Jelinek } 2297702a871aSJerry Jelinek } 2298702a871aSJerry Jelinek 2299702a871aSJerry Jelinek scf_value_destroy(zone); 2300702a871aSJerry Jelinek } 2301702a871aSJerry Jelinek 2302702a871aSJerry Jelinek if (scf_handle_bind(h) == -1) { 2303702a871aSJerry Jelinek if (do_zones) 2304702a871aSJerry Jelinek goto nextzone; 2305702a871aSJerry Jelinek 2306702a871aSJerry Jelinek uu_die(gettext("Couldn't bind to configuration repository: " 2307702a871aSJerry Jelinek "%s.\n"), scf_strerror(scf_error())); 2308702a871aSJerry Jelinek } 2309702a871aSJerry Jelinek 2310702a871aSJerry Jelinek optind = orig_optind; 2311702a871aSJerry Jelinek argc = orig_argc; 2312702a871aSJerry Jelinek argv = orig_argv; 2313702a871aSJerry Jelinek 2314702a871aSJerry Jelinek if (optind >= argc) 2315702a871aSJerry Jelinek usage(); 2316702a871aSJerry Jelinek 23177c478bd9Sstevel@tonic-gate if (strcmp(argv[optind], "enable") == 0) { 23187c478bd9Sstevel@tonic-gate int flags = SET_ENABLED; 23197c478bd9Sstevel@tonic-gate int wait = 0; 23207c478bd9Sstevel@tonic-gate int error = 0; 23217c478bd9Sstevel@tonic-gate 23227c478bd9Sstevel@tonic-gate ++optind; 23237c478bd9Sstevel@tonic-gate 23247c478bd9Sstevel@tonic-gate while ((o = getopt(argc, argv, "rst")) != -1) { 23257c478bd9Sstevel@tonic-gate if (o == 'r') 23267c478bd9Sstevel@tonic-gate flags |= SET_RECURSIVE; 23277c478bd9Sstevel@tonic-gate else if (o == 't') 23287c478bd9Sstevel@tonic-gate flags |= SET_TEMPORARY; 23297c478bd9Sstevel@tonic-gate else if (o == 's') 23307c478bd9Sstevel@tonic-gate wait = 1; 23317c478bd9Sstevel@tonic-gate else if (o == '?') 23327c478bd9Sstevel@tonic-gate usage(); 23337c478bd9Sstevel@tonic-gate else { 23347c478bd9Sstevel@tonic-gate assert(0); 23357c478bd9Sstevel@tonic-gate abort(); 23367c478bd9Sstevel@tonic-gate } 23377c478bd9Sstevel@tonic-gate } 23387c478bd9Sstevel@tonic-gate argc -= optind; 23397c478bd9Sstevel@tonic-gate argv += optind; 23407c478bd9Sstevel@tonic-gate 234137b40227SJerry Jelinek if (argc == 0 && !svcsearch) 234237b40227SJerry Jelinek usage(); 234337b40227SJerry Jelinek 234437b40227SJerry Jelinek if (argc > 0 && svcsearch) 23457c478bd9Sstevel@tonic-gate usage(); 23467c478bd9Sstevel@tonic-gate 23477c478bd9Sstevel@tonic-gate /* 23487c478bd9Sstevel@tonic-gate * We want to continue with -s processing if we had 23497c478bd9Sstevel@tonic-gate * invalid options, but not if an enable failed. We 23507c478bd9Sstevel@tonic-gate * squelch output the second time we walk fmris; we saw 23517c478bd9Sstevel@tonic-gate * the errors the first time. 23527c478bd9Sstevel@tonic-gate */ 23536c7c876cSJerry Jelinek if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS, 2354702a871aSJerry Jelinek set_fmri_enabled, (void *)flags, &error, pr_warn)) != 0) { 23557c478bd9Sstevel@tonic-gate 2356702a871aSJerry Jelinek pr_warn(gettext("failed to iterate over " 23577c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 23587c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 23597c478bd9Sstevel@tonic-gate 23607c478bd9Sstevel@tonic-gate } else if (wait && exit_status == 0 && 23616c7c876cSJerry Jelinek (err = scf_walk_fmri(h, argc, argv, WALK_FLAGS, 23626c7c876cSJerry Jelinek wait_fmri_enabled, (void *)flags, &error, quiet)) != 0) { 23637c478bd9Sstevel@tonic-gate 2364702a871aSJerry Jelinek pr_warn(gettext("failed to iterate over " 23657c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 23667c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 23677c478bd9Sstevel@tonic-gate } 23687c478bd9Sstevel@tonic-gate 23697c478bd9Sstevel@tonic-gate if (error > 0) 23707c478bd9Sstevel@tonic-gate exit_status = error; 23717c478bd9Sstevel@tonic-gate 23727c478bd9Sstevel@tonic-gate } else if (strcmp(argv[optind], "disable") == 0) { 23737c478bd9Sstevel@tonic-gate int flags = 0; 23747c478bd9Sstevel@tonic-gate int wait = 0; 23757c478bd9Sstevel@tonic-gate int error = 0; 23767c478bd9Sstevel@tonic-gate 23777c478bd9Sstevel@tonic-gate ++optind; 23787c478bd9Sstevel@tonic-gate 23797c478bd9Sstevel@tonic-gate while ((o = getopt(argc, argv, "st")) != -1) { 23807c478bd9Sstevel@tonic-gate if (o == 't') 23817c478bd9Sstevel@tonic-gate flags |= SET_TEMPORARY; 23827c478bd9Sstevel@tonic-gate else if (o == 's') 23837c478bd9Sstevel@tonic-gate wait = 1; 23847c478bd9Sstevel@tonic-gate else if (o == '?') 23857c478bd9Sstevel@tonic-gate usage(); 23867c478bd9Sstevel@tonic-gate else { 23877c478bd9Sstevel@tonic-gate assert(0); 23887c478bd9Sstevel@tonic-gate abort(); 23897c478bd9Sstevel@tonic-gate } 23907c478bd9Sstevel@tonic-gate } 23917c478bd9Sstevel@tonic-gate argc -= optind; 23927c478bd9Sstevel@tonic-gate argv += optind; 23937c478bd9Sstevel@tonic-gate 239437b40227SJerry Jelinek if (argc == 0 && !svcsearch) 239537b40227SJerry Jelinek usage(); 239637b40227SJerry Jelinek 239737b40227SJerry Jelinek if (argc > 0 && svcsearch) 23987c478bd9Sstevel@tonic-gate usage(); 23997c478bd9Sstevel@tonic-gate 24007c478bd9Sstevel@tonic-gate /* 24017c478bd9Sstevel@tonic-gate * We want to continue with -s processing if we had 24027c478bd9Sstevel@tonic-gate * invalid options, but not if a disable failed. We 24037c478bd9Sstevel@tonic-gate * squelch output the second time we walk fmris; we saw 24047c478bd9Sstevel@tonic-gate * the errors the first time. 24057c478bd9Sstevel@tonic-gate */ 24066c7c876cSJerry Jelinek if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS, 24076c7c876cSJerry Jelinek set_fmri_enabled, (void *)flags, &exit_status, 2408702a871aSJerry Jelinek pr_warn)) != 0) { 24097c478bd9Sstevel@tonic-gate 2410702a871aSJerry Jelinek pr_warn(gettext("failed to iterate over " 24117c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 24127c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 24137c478bd9Sstevel@tonic-gate 24147c478bd9Sstevel@tonic-gate } else if (wait && exit_status == 0 && 24156c7c876cSJerry Jelinek (err = scf_walk_fmri(h, argc, argv, WALK_FLAGS, 24166c7c876cSJerry Jelinek wait_fmri_disabled, (void *)flags, &error, quiet)) != 0) { 24177c478bd9Sstevel@tonic-gate 2418702a871aSJerry Jelinek pr_warn(gettext("failed to iterate over " 24197c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 24207c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 24217c478bd9Sstevel@tonic-gate } 24227c478bd9Sstevel@tonic-gate 24237c478bd9Sstevel@tonic-gate if (error > 0) 24247c478bd9Sstevel@tonic-gate exit_status = error; 24257c478bd9Sstevel@tonic-gate 24267c478bd9Sstevel@tonic-gate } else if (strcmp(argv[optind], "restart") == 0) { 2427ac0324d2SJerry Jelinek boolean_t do_dump = B_FALSE; 2428ac0324d2SJerry Jelinek 24297c478bd9Sstevel@tonic-gate ++optind; 2430ac0324d2SJerry Jelinek 2431ac0324d2SJerry Jelinek while ((o = getopt(argc, argv, "d")) != -1) { 2432ac0324d2SJerry Jelinek if (o == 'd') 2433ac0324d2SJerry Jelinek do_dump = B_TRUE; 2434ac0324d2SJerry Jelinek else if (o == '?') 2435ac0324d2SJerry Jelinek usage(); 2436ac0324d2SJerry Jelinek else { 2437ac0324d2SJerry Jelinek assert(0); 2438ac0324d2SJerry Jelinek abort(); 2439ac0324d2SJerry Jelinek } 2440ac0324d2SJerry Jelinek } 244137b40227SJerry Jelinek argc -= optind; 244237b40227SJerry Jelinek argv += optind; 24437c478bd9Sstevel@tonic-gate 244437b40227SJerry Jelinek if (argc == 0 && !svcsearch) 244537b40227SJerry Jelinek usage(); 244637b40227SJerry Jelinek 244737b40227SJerry Jelinek if (argc > 0 && svcsearch) 24487c478bd9Sstevel@tonic-gate usage(); 24497c478bd9Sstevel@tonic-gate 2450ac0324d2SJerry Jelinek if (do_dump) { 2451ac0324d2SJerry Jelinek if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS, 2452ac0324d2SJerry Jelinek set_fmri_action, (void *)SCF_PROPERTY_DODUMP, 2453ac0324d2SJerry Jelinek &exit_status, pr_warn)) != 0) { 2454ac0324d2SJerry Jelinek pr_warn(gettext("failed to iterate over " 2455ac0324d2SJerry Jelinek "instances: %s\n"), scf_strerror(err)); 2456ac0324d2SJerry Jelinek exit_status = UU_EXIT_FATAL; 2457ac0324d2SJerry Jelinek } 2458ac0324d2SJerry Jelinek } 2459ac0324d2SJerry Jelinek 246037b40227SJerry Jelinek if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS, 246137b40227SJerry Jelinek set_fmri_action, (void *)SCF_PROPERTY_RESTART, &exit_status, 2462702a871aSJerry Jelinek pr_warn)) != 0) { 2463702a871aSJerry Jelinek pr_warn(gettext("failed to iterate over " 24647c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 24657c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 24667c478bd9Sstevel@tonic-gate } 24677c478bd9Sstevel@tonic-gate 24687c478bd9Sstevel@tonic-gate } else if (strcmp(argv[optind], "refresh") == 0) { 24697c478bd9Sstevel@tonic-gate ++optind; 247037b40227SJerry Jelinek argc -= optind; 247137b40227SJerry Jelinek argv += optind; 24727c478bd9Sstevel@tonic-gate 247337b40227SJerry Jelinek if (argc == 0 && !svcsearch) 247437b40227SJerry Jelinek usage(); 247537b40227SJerry Jelinek 247637b40227SJerry Jelinek if (argc > 0 && svcsearch) 24777c478bd9Sstevel@tonic-gate usage(); 24787c478bd9Sstevel@tonic-gate 247937b40227SJerry Jelinek if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS, 248037b40227SJerry Jelinek set_fmri_action, (void *)SCF_PROPERTY_REFRESH, &exit_status, 2481702a871aSJerry Jelinek pr_warn)) != 0) { 2482702a871aSJerry Jelinek pr_warn(gettext("failed to iterate over " 24837c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(scf_error())); 24847c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 24857c478bd9Sstevel@tonic-gate } 24867c478bd9Sstevel@tonic-gate 24877c478bd9Sstevel@tonic-gate } else if (strcmp(argv[optind], "mark") == 0) { 24887c478bd9Sstevel@tonic-gate int flags = 0; 24897c478bd9Sstevel@tonic-gate scf_walk_callback callback; 24907c478bd9Sstevel@tonic-gate 24917c478bd9Sstevel@tonic-gate ++optind; 24927c478bd9Sstevel@tonic-gate 24937c478bd9Sstevel@tonic-gate while ((o = getopt(argc, argv, "It")) != -1) { 24947c478bd9Sstevel@tonic-gate if (o == 'I') 24957c478bd9Sstevel@tonic-gate flags |= MARK_IMMEDIATE; 24967c478bd9Sstevel@tonic-gate else if (o == 't') 24977c478bd9Sstevel@tonic-gate flags |= MARK_TEMPORARY; 24987c478bd9Sstevel@tonic-gate else if (o == '?') 24997c478bd9Sstevel@tonic-gate usage(); 25007c478bd9Sstevel@tonic-gate else { 25017c478bd9Sstevel@tonic-gate assert(0); 25027c478bd9Sstevel@tonic-gate abort(); 25037c478bd9Sstevel@tonic-gate } 25047c478bd9Sstevel@tonic-gate } 25057c478bd9Sstevel@tonic-gate 25067c478bd9Sstevel@tonic-gate if (argc - optind < 2) 25077c478bd9Sstevel@tonic-gate usage(); 25087c478bd9Sstevel@tonic-gate 25097c478bd9Sstevel@tonic-gate if (strcmp(argv[optind], "degraded") == 0) { 25107c478bd9Sstevel@tonic-gate if (flags & MARK_TEMPORARY) 25117c478bd9Sstevel@tonic-gate uu_xdie(UU_EXIT_USAGE, gettext("-t may not be " 25127c478bd9Sstevel@tonic-gate "used with degraded.\n")); 25137c478bd9Sstevel@tonic-gate callback = force_degraded; 25147c478bd9Sstevel@tonic-gate 25157c478bd9Sstevel@tonic-gate } else if (strcmp(argv[optind], "maintenance") == 0) { 25167c478bd9Sstevel@tonic-gate callback = force_maintenance; 25177c478bd9Sstevel@tonic-gate } else { 25187c478bd9Sstevel@tonic-gate usage(); 25197c478bd9Sstevel@tonic-gate } 25207c478bd9Sstevel@tonic-gate 252137b40227SJerry Jelinek optind++; 252237b40227SJerry Jelinek argc -= optind; 252337b40227SJerry Jelinek argv += optind; 252437b40227SJerry Jelinek 252537b40227SJerry Jelinek if (argc == 0 && !svcsearch) 252637b40227SJerry Jelinek usage(); 252737b40227SJerry Jelinek 252837b40227SJerry Jelinek if (argc > 0 && svcsearch) 252937b40227SJerry Jelinek usage(); 253037b40227SJerry Jelinek 253137b40227SJerry Jelinek if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS, callback, 253237b40227SJerry Jelinek NULL, &exit_status, pr_warn)) != 0) { 2533702a871aSJerry Jelinek pr_warn(gettext("failed to iterate over " 25347c478bd9Sstevel@tonic-gate "instances: %s\n"), 25357c478bd9Sstevel@tonic-gate scf_strerror(err)); 25367c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 25377c478bd9Sstevel@tonic-gate } 25387c478bd9Sstevel@tonic-gate 25397c478bd9Sstevel@tonic-gate } else if (strcmp(argv[optind], "clear") == 0) { 25407c478bd9Sstevel@tonic-gate ++optind; 254137b40227SJerry Jelinek argc -= optind; 254237b40227SJerry Jelinek argv += optind; 25437c478bd9Sstevel@tonic-gate 254437b40227SJerry Jelinek if (argc == 0 && !svcsearch) 25457c478bd9Sstevel@tonic-gate usage(); 25467c478bd9Sstevel@tonic-gate 254737b40227SJerry Jelinek if (svcsearch) { 254837b40227SJerry Jelinek if (argc > 0) 254937b40227SJerry Jelinek usage(); 255037b40227SJerry Jelinek if (strcmp(svcstate, SCF_STATE_STRING_MAINT) != 0 && 255137b40227SJerry Jelinek strcmp(svcstate, SCF_STATE_STRING_DEGRADED) != 0) 255237b40227SJerry Jelinek uu_die(gettext("State must be '%s' or '%s'\n"), 255337b40227SJerry Jelinek SCF_STATE_STRING_MAINT, 255437b40227SJerry Jelinek SCF_STATE_STRING_DEGRADED); 255537b40227SJerry Jelinek } 255637b40227SJerry Jelinek 255737b40227SJerry Jelinek if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS, 255837b40227SJerry Jelinek clear_instance, NULL, &exit_status, pr_warn)) != 0) { 2559702a871aSJerry Jelinek pr_warn(gettext("failed to iterate over " 25607c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 25617c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 25627c478bd9Sstevel@tonic-gate } 25637c478bd9Sstevel@tonic-gate 25647c478bd9Sstevel@tonic-gate } else if (strcmp(argv[optind], "milestone") == 0) { 25657c478bd9Sstevel@tonic-gate boolean_t temporary = B_TRUE; 25667c478bd9Sstevel@tonic-gate const char *milestone; 25677c478bd9Sstevel@tonic-gate 25687c478bd9Sstevel@tonic-gate ++optind; 25697c478bd9Sstevel@tonic-gate 25707c478bd9Sstevel@tonic-gate while ((o = getopt(argc, argv, "d")) != -1) { 25717c478bd9Sstevel@tonic-gate if (o == 'd') 25727c478bd9Sstevel@tonic-gate temporary = B_FALSE; 25737c478bd9Sstevel@tonic-gate else if (o == '?') 25747c478bd9Sstevel@tonic-gate usage_milestone(); 25757c478bd9Sstevel@tonic-gate else { 25767c478bd9Sstevel@tonic-gate assert(0); 25777c478bd9Sstevel@tonic-gate abort(); 25787c478bd9Sstevel@tonic-gate } 25797c478bd9Sstevel@tonic-gate } 25807c478bd9Sstevel@tonic-gate 25817c478bd9Sstevel@tonic-gate if (optind >= argc) 25827c478bd9Sstevel@tonic-gate usage_milestone(); 25837c478bd9Sstevel@tonic-gate 25847c478bd9Sstevel@tonic-gate milestone = validate_milestone(argv[optind]); 25857c478bd9Sstevel@tonic-gate 25867c478bd9Sstevel@tonic-gate set_milestone(milestone, temporary); 25877c478bd9Sstevel@tonic-gate } else if (strcmp(argv[optind], "_smf_backup") == 0) { 25887c478bd9Sstevel@tonic-gate const char *reason = NULL; 25897c478bd9Sstevel@tonic-gate 25907c478bd9Sstevel@tonic-gate ++optind; 25917c478bd9Sstevel@tonic-gate 25927c478bd9Sstevel@tonic-gate if (optind != argc - 1) 25937c478bd9Sstevel@tonic-gate usage(); 25947c478bd9Sstevel@tonic-gate 25957c478bd9Sstevel@tonic-gate if ((err = _scf_request_backup(h, argv[optind])) != 25967c478bd9Sstevel@tonic-gate SCF_SUCCESS) { 25977c478bd9Sstevel@tonic-gate switch (scf_error()) { 25987c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_BOUND: 25997c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN: 26007c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY: 26017c478bd9Sstevel@tonic-gate scfdie(); 26027c478bd9Sstevel@tonic-gate break; 26037c478bd9Sstevel@tonic-gate 26047c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED: 26057c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT: 26067c478bd9Sstevel@tonic-gate reason = scf_strerror(scf_error()); 26077c478bd9Sstevel@tonic-gate break; 26087c478bd9Sstevel@tonic-gate 26097c478bd9Sstevel@tonic-gate case SCF_ERROR_INTERNAL: 26107c478bd9Sstevel@tonic-gate reason = 26117c478bd9Sstevel@tonic-gate "unknown error (see console for details)"; 26127c478bd9Sstevel@tonic-gate break; 26137c478bd9Sstevel@tonic-gate } 2614c0889d7aSstevep 2615702a871aSJerry Jelinek pr_warn("failed to backup repository: %s\n", reason); 26167c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 26177c478bd9Sstevel@tonic-gate } 2618c0889d7aSstevep } else if (strcmp(argv[optind], "_smf_repository_switch") == 0) { 2619c0889d7aSstevep const char *reason = NULL; 2620c0889d7aSstevep 2621c0889d7aSstevep ++optind; 2622c0889d7aSstevep 2623c0889d7aSstevep /* 2624c0889d7aSstevep * Check argument and setup scf_switch structure 2625c0889d7aSstevep */ 2626c0889d7aSstevep if (optind != argc - 1) 2627c0889d7aSstevep exit(1); 2628c0889d7aSstevep 2629c0889d7aSstevep if (strcmp(argv[optind], "fast") == 0) { 2630c0889d7aSstevep sw_back = 0; 2631c0889d7aSstevep } else if (strcmp(argv[optind], "perm") == 0) { 2632c0889d7aSstevep sw_back = 1; 2633c0889d7aSstevep } else { 2634c0889d7aSstevep exit(UU_EXIT_USAGE); 2635c0889d7aSstevep } 2636c0889d7aSstevep 2637c0889d7aSstevep /* 2638c0889d7aSstevep * Call into switch primitive 2639c0889d7aSstevep */ 2640c0889d7aSstevep if ((err = _scf_repository_switch(h, sw_back)) != 2641c0889d7aSstevep SCF_SUCCESS) { 2642c0889d7aSstevep /* 2643c0889d7aSstevep * Retrieve per thread SCF error code 2644c0889d7aSstevep */ 2645c0889d7aSstevep switch (scf_error()) { 2646c0889d7aSstevep case SCF_ERROR_NOT_BOUND: 2647c0889d7aSstevep abort(); 2648c0889d7aSstevep /* NOTREACHED */ 2649c0889d7aSstevep 2650c0889d7aSstevep case SCF_ERROR_CONNECTION_BROKEN: 2651c0889d7aSstevep case SCF_ERROR_BACKEND_READONLY: 2652c0889d7aSstevep scfdie(); 2653c0889d7aSstevep /* NOTREACHED */ 2654c0889d7aSstevep 2655c0889d7aSstevep case SCF_ERROR_PERMISSION_DENIED: 2656c0889d7aSstevep case SCF_ERROR_INVALID_ARGUMENT: 2657c0889d7aSstevep reason = scf_strerror(scf_error()); 2658c0889d7aSstevep break; 2659c0889d7aSstevep 2660c0889d7aSstevep case SCF_ERROR_INTERNAL: 2661c0889d7aSstevep reason = "File operation error: (see console)"; 2662c0889d7aSstevep break; 2663c0889d7aSstevep 2664c0889d7aSstevep default: 2665c0889d7aSstevep abort(); 2666c0889d7aSstevep /* NOTREACHED */ 2667c0889d7aSstevep } 2668c0889d7aSstevep 2669702a871aSJerry Jelinek pr_warn("failed to switch repository: %s\n", reason); 2670c0889d7aSstevep exit_status = UU_EXIT_FATAL; 2671c0889d7aSstevep } 26727c478bd9Sstevel@tonic-gate } else { 26737c478bd9Sstevel@tonic-gate usage(); 26747c478bd9Sstevel@tonic-gate } 26757c478bd9Sstevel@tonic-gate 26767c478bd9Sstevel@tonic-gate if (scf_handle_unbind(h) == -1) 26777c478bd9Sstevel@tonic-gate scfdie(); 2678702a871aSJerry Jelinek nextzone: 26797c478bd9Sstevel@tonic-gate scf_handle_destroy(h); 2680702a871aSJerry Jelinek if (do_zones && zent < nzents) 2681702a871aSJerry Jelinek goto again; 26827c478bd9Sstevel@tonic-gate 26837c478bd9Sstevel@tonic-gate return (exit_status); 26847c478bd9Sstevel@tonic-gate } 2685