1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * Copyright 2015, Joyent, Inc. All rights reserved.
28 */
29
30 /*
31 * svcadm - request adminstrative actions for service instances
32 */
33
34 #include <locale.h>
35 #include <libintl.h>
36 #include <libscf.h>
37 #include <libscf_priv.h>
38 #include <libcontract.h>
39 #include <libcontract_priv.h>
40 #include <sys/contract/process.h>
41 #include <libuutil.h>
42 #include <stddef.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <unistd.h>
47 #include <fcntl.h>
48 #include <procfs.h>
49 #include <assert.h>
50 #include <errno.h>
51 #include <zone.h>
52
53 #ifndef TEXT_DOMAIN
54 #define TEXT_DOMAIN "SUNW_OST_OSCMD"
55 #endif /* TEXT_DOMAIN */
56
57 /* Must be a power of two */
58 #define HT_BUCKETS 64
59
60 /*
61 * Exit codes for enable and disable -s.
62 */
63 #define EXIT_SVC_FAILURE 3
64 #define EXIT_DEP_FAILURE 4
65
66 #define WALK_FLAGS (SCF_WALK_UNIPARTIAL | SCF_WALK_MULTIPLE)
67
68 /*
69 * How long we will wait (in seconds) for a service to change state
70 * before re-checking its dependencies.
71 */
72 #define WAIT_INTERVAL 3
73
74 #define bad_error(func, err) \
75 uu_panic("%s:%d: %s() failed with unexpected error %d.\n", \
76 __FILE__, __LINE__, (func), (err));
77
78 struct ht_elt {
79 struct ht_elt *next;
80 boolean_t active;
81 char str[1];
82 };
83
84
85 scf_handle_t *h;
86 ssize_t max_scf_fmri_sz;
87 static const char *emsg_permission_denied;
88 static const char *emsg_nomem;
89 static const char *emsg_create_pg_perm_denied;
90 static const char *emsg_pg_perm_denied;
91 static const char *emsg_prop_perm_denied;
92 static const char *emsg_no_service;
93
94 static int exit_status = 0;
95 static int verbose = 0;
96 static char *scratch_fmri;
97 static char *g_zonename = NULL;
98 static char svcstate[80];
99 static boolean_t svcsearch = B_FALSE;
100
101 static struct ht_elt **visited;
102
103 void do_scfdie(int lineno) __NORETURN;
104 static void usage_milestone(void) __NORETURN;
105 static void set_astring_prop(const char *, const char *, const char *,
106 uint32_t, const char *, const char *);
107 static void pr_warn(const char *format, ...);
108
109 /*
110 * Visitors from synch.c, needed for enable -s and disable -s.
111 */
112 extern int is_enabled(scf_instance_t *);
113 extern int has_potential(scf_instance_t *, int);
114
115 void
116 do_scfdie(int lineno)
117 {
118 scf_error_t err;
119
120 switch (err = scf_error()) {
121 case SCF_ERROR_CONNECTION_BROKEN:
122 uu_die(gettext("Connection to repository server broken. "
123 "Exiting.\n"));
124 /* NOTREACHED */
125
126 case SCF_ERROR_BACKEND_READONLY:
127 uu_die(gettext("Repository is read-only. Exiting.\n"));
128 /* NOTREACHED */
129
130 default:
131 #ifdef NDEBUG
132 uu_die(gettext("Unexpected libscf error: %s. Exiting.\n"),
133 scf_strerror(err));
134 #else
135 uu_die("Unexpected libscf error on line %d: %s.\n", lineno,
136 scf_strerror(err));
137 #endif
138 }
139 }
140
141 #define scfdie() do_scfdie(__LINE__)
142
143 static void
144 usage()
145 {
146 (void) fprintf(stderr, gettext(
147 "Usage: %1$s [-S <state>] [-v] [-Z | -z zone] [cmd [args ... ]]\n\n"
148 "\t%1$s enable [-rst] [<service> ...]\t- enable and online service(s)\n"
149 "\t%1$s disable [-st] [<service> ...]\t- disable and offline "
150 "service(s)\n"
151 "\t%1$s restart [-d] [<service> ...]\t- restart specified service(s)\n"
152 "\t%1$s refresh [<service> ...]\t\t- re-read service configuration\n"
153 "\t%1$s mark [-It] <state> [<service> ...] - set maintenance state\n"
154 "\t%1$s clear [<service> ...]\t\t- clear maintenance state\n"
155 "\t%1$s milestone [-d] <milestone>\t- advance to a service milestone\n"
156 "\n\t"
157 "Services can be specified using an FMRI, abbreviation, or fnmatch(5)\n"
158 "\tpattern, as shown in these examples for svc:/network/smtp:sendmail\n"
159 "\n"
160 "\t%1$s <cmd> svc:/network/smtp:sendmail\n"
161 "\t%1$s <cmd> network/smtp:sendmail\n"
162 "\t%1$s <cmd> network/*mail\n"
163 "\t%1$s <cmd> network/smtp\n"
164 "\t%1$s <cmd> smtp:sendmail\n"
165 "\t%1$s <cmd> smtp\n"
166 "\t%1$s <cmd> sendmail\n"), uu_getpname());
167
168 exit(UU_EXIT_USAGE);
169 }
170
171
172 /*
173 * FMRI hash table for recursive enable.
174 */
175
176 static uint32_t
177 hash_fmri(const char *str)
178 {
179 uint32_t h = 0, g;
180 const char *p;
181
182 /* Generic hash function from uts/common/os/modhash.c . */
183 for (p = str; *p != '\0'; ++p) {
184 h = (h << 4) + *p;
185 if ((g = (h & 0xf0000000)) != 0) {
186 h ^= (g >> 24);
187 h ^= g;
188 }
189 }
190
191 return (h);
192 }
193
194 /*
195 * Return 1 if str has been visited, 0 if it has not, and -1 if memory could not
196 * be allocated.
197 */
198 static int
199 visited_find_or_add(const char *str, struct ht_elt **hep)
200 {
201 uint32_t h;
202 uint_t i;
203 struct ht_elt *he;
204
205 h = hash_fmri(str);
206 i = h & (HT_BUCKETS - 1);
207
208 for (he = visited[i]; he != NULL; he = he->next) {
209 if (strcmp(he->str, str) == 0) {
210 if (hep)
211 *hep = he;
212 return (1);
213 }
214 }
215
216 he = malloc(offsetof(struct ht_elt, str) + strlen(str) + 1);
217 if (he == NULL)
218 return (-1);
219
220 (void) strcpy(he->str, str);
221
222 he->next = visited[i];
223 visited[i] = he;
224
225 if (hep)
226 *hep = he;
227 return (0);
228 }
229
230
231 /*
232 * Returns 0, ECANCELED if pg is deleted, ENOENT if propname doesn't exist,
233 * EINVAL if the property is not of boolean type or has no values, and E2BIG
234 * if it has more than one value. *bp is set if 0 or E2BIG is returned.
235 */
236 int
237 get_bool_prop(scf_propertygroup_t *pg, const char *propname, uint8_t *bp)
238 {
239 scf_property_t *prop;
240 scf_value_t *val;
241 int ret;
242
243 if ((prop = scf_property_create(h)) == NULL ||
244 (val = scf_value_create(h)) == NULL)
245 scfdie();
246
247 if (scf_pg_get_property(pg, propname, prop) != 0) {
248 switch (scf_error()) {
249 case SCF_ERROR_DELETED:
250 ret = ECANCELED;
251 goto out;
252
253 case SCF_ERROR_NOT_FOUND:
254 ret = ENOENT;
255 goto out;
256
257 case SCF_ERROR_NOT_SET:
258 assert(0);
259 abort();
260 /* NOTREACHED */
261
262 default:
263 scfdie();
264 }
265 }
266
267 if (scf_property_get_value(prop, val) == 0) {
268 ret = 0;
269 } else {
270 switch (scf_error()) {
271 case SCF_ERROR_DELETED:
272 ret = ENOENT;
273 goto out;
274
275 case SCF_ERROR_NOT_FOUND:
276 ret = EINVAL;
277 goto out;
278
279 case SCF_ERROR_CONSTRAINT_VIOLATED:
280 ret = E2BIG;
281 break;
282
283 case SCF_ERROR_NOT_SET:
284 assert(0);
285 abort();
286 /* NOTREACHED */
287
288 default:
289 scfdie();
290 }
291 }
292
293 if (scf_value_get_boolean(val, bp) != 0) {
294 if (scf_error() != SCF_ERROR_TYPE_MISMATCH)
295 scfdie();
296
297 ret = EINVAL;
298 goto out;
299 }
300
301 out:
302 scf_value_destroy(val);
303 scf_property_destroy(prop);
304 return (ret);
305 }
306
307 /*
308 * Returns 0, EPERM, or EROFS.
309 */
310 static int
311 set_bool_prop(scf_propertygroup_t *pg, const char *propname, boolean_t b)
312 {
313 scf_value_t *v;
314 scf_transaction_t *tx;
315 scf_transaction_entry_t *ent;
316 int ret = 0, r;
317
318 if ((tx = scf_transaction_create(h)) == NULL ||
319 (ent = scf_entry_create(h)) == NULL ||
320 (v = scf_value_create(h)) == NULL)
321 scfdie();
322
323 scf_value_set_boolean(v, b);
324
325 for (;;) {
326 if (scf_transaction_start(tx, pg) == -1) {
327 switch (scf_error()) {
328 case SCF_ERROR_PERMISSION_DENIED:
329 ret = EPERM;
330 goto out;
331
332 case SCF_ERROR_BACKEND_READONLY:
333 ret = EROFS;
334 goto out;
335
336 default:
337 scfdie();
338 }
339 }
340
341 if (scf_transaction_property_change_type(tx, ent, propname,
342 SCF_TYPE_BOOLEAN) != 0) {
343 if (scf_error() != SCF_ERROR_NOT_FOUND)
344 scfdie();
345
346 if (scf_transaction_property_new(tx, ent, propname,
347 SCF_TYPE_BOOLEAN) != 0)
348 scfdie();
349 }
350
351 r = scf_entry_add_value(ent, v);
352 assert(r == 0);
353
354 r = scf_transaction_commit(tx);
355 if (r == 1)
356 break;
357
358 scf_transaction_reset(tx);
359
360 if (r != 0) {
361 switch (scf_error()) {
362 case SCF_ERROR_PERMISSION_DENIED:
363 ret = EPERM;
364 goto out;
365
366 case SCF_ERROR_BACKEND_READONLY:
367 ret = EROFS;
368 goto out;
369
370 default:
371 scfdie();
372 }
373 }
374
375 if (scf_pg_update(pg) == -1)
376 scfdie();
377 }
378
379 out:
380 scf_transaction_destroy(tx);
381 scf_entry_destroy(ent);
382 scf_value_destroy(v);
383 return (ret);
384 }
385
386 /*
387 * Gets the single astring value of the propname property of pg. prop & v are
388 * scratch space. Returns the length of the string on success or
389 * -ENOENT - pg has no property named propname
390 * -E2BIG - property has no values or multiple values
391 * -EINVAL - property type is not compatible with astring
392 */
393 ssize_t
394 get_astring_prop(const scf_propertygroup_t *pg, const char *propname,
395 scf_property_t *prop, scf_value_t *v, char *buf, size_t bufsz)
396 {
397 ssize_t sz;
398
399 if (scf_pg_get_property(pg, propname, prop) != 0) {
400 if (scf_error() != SCF_ERROR_NOT_FOUND)
401 scfdie();
402
403 return (-ENOENT);
404 }
405
406 if (scf_property_get_value(prop, v) != 0) {
407 switch (scf_error()) {
408 case SCF_ERROR_NOT_FOUND:
409 case SCF_ERROR_CONSTRAINT_VIOLATED:
410 return (-E2BIG);
411
412 default:
413 scfdie();
414 }
415 }
416
417 sz = scf_value_get_astring(v, buf, bufsz);
418 if (sz < 0) {
419 if (scf_error() != SCF_ERROR_TYPE_MISMATCH)
420 scfdie();
421
422 return (-EINVAL);
423 }
424
425 return (sz);
426 }
427
428 /*
429 * Returns 0 or EPERM.
430 */
431 static int
432 pg_get_or_add(const scf_instance_t *inst, const char *pgname,
433 const char *pgtype, uint32_t pgflags, scf_propertygroup_t *pg)
434 {
435 again:
436 if (scf_instance_get_pg(inst, pgname, pg) == 0)
437 return (0);
438
439 if (scf_error() != SCF_ERROR_NOT_FOUND)
440 scfdie();
441
442 if (scf_instance_add_pg(inst, pgname, pgtype, pgflags, pg) == 0)
443 return (0);
444
445 switch (scf_error()) {
446 case SCF_ERROR_EXISTS:
447 goto again;
448
449 case SCF_ERROR_PERMISSION_DENIED:
450 return (EPERM);
451
452 default:
453 scfdie();
454 /* NOTREACHED */
455 }
456 }
457
458 static int
459 my_ct_name(char *out, size_t len)
460 {
461 ct_stathdl_t st;
462 char *ct_fmri;
463 ctid_t ct;
464 int fd, errno, ret;
465
466 if ((ct = getctid()) == -1)
467 uu_die(gettext("Could not get contract id for process"));
468
469 fd = contract_open(ct, "process", "status", O_RDONLY);
470
471 if ((errno = ct_status_read(fd, CTD_ALL, &st)) != 0)
472 uu_warn(gettext("Could not read status of contract "
473 "%ld: %s.\n"), ct, strerror(errno));
474
475 if ((errno = ct_pr_status_get_svc_fmri(st, &ct_fmri)) != 0)
476 uu_warn(gettext("Could not get svc_fmri for contract "
477 "%ld: %s.\n"), ct, strerror(errno));
478
479 ret = strlcpy(out, ct_fmri, len);
480
481 ct_status_free(st);
482 (void) close(fd);
483
484 return (ret);
485 }
486
487 /*
488 * Set auxiliary_tty and auxiliary_fmri properties in restarter_actions pg to
489 * communicate whether the action is requested from a tty and the fmri of the
490 * responsible process.
491 *
492 * Returns 0, EPERM, or EROFS
493 */
494 static int
495 restarter_setup(const char *fmri, const scf_instance_t *inst)
496 {
497 boolean_t b = B_FALSE;
498 scf_propertygroup_t *pg = NULL;
499 int ret = 0;
500
501 if ((pg = scf_pg_create(h)) == NULL)
502 scfdie();
503
504 if (pg_get_or_add(inst, SCF_PG_RESTARTER_ACTIONS,
505 SCF_PG_RESTARTER_ACTIONS_TYPE, SCF_PG_RESTARTER_ACTIONS_FLAGS,
506 pg) == EPERM) {
507 if (!verbose)
508 uu_warn(emsg_permission_denied, fmri);
509 else
510 uu_warn(emsg_create_pg_perm_denied, fmri,
511 SCF_PG_RESTARTER_ACTIONS);
512
513 ret = EPERM;
514 goto out;
515 }
516
517 /* Set auxiliary_tty property */
518 if (isatty(STDIN_FILENO))
519 b = B_TRUE;
520
521 /* Create and set state to disabled */
522 switch (set_bool_prop(pg, SCF_PROPERTY_AUX_TTY, b)) {
523 case 0:
524 break;
525
526 case EPERM:
527 if (!verbose)
528 uu_warn(emsg_permission_denied, fmri);
529 else
530 uu_warn(emsg_prop_perm_denied, fmri,
531 SCF_PG_RESTARTER_ACTIONS, SCF_PROPERTY_AUX_TTY);
532
533 ret = EPERM;
534 goto out;
535 /* NOTREACHED */
536
537 case EROFS:
538 /* Shouldn't happen, but it can. */
539 if (!verbose)
540 uu_warn(gettext("%s: Repository read-only.\n"), fmri);
541 else
542 uu_warn(gettext("%s: Could not set %s/%s "
543 "(repository read-only).\n"), fmri,
544 SCF_PG_RESTARTER_ACTIONS, SCF_PROPERTY_AUX_TTY);
545
546 ret = EROFS;
547 goto out;
548 /* NOTREACHED */
549
550 default:
551 scfdie();
552 }
553
554 if (my_ct_name(scratch_fmri, max_scf_fmri_sz) > 0) {
555 set_astring_prop(fmri, SCF_PG_RESTARTER_ACTIONS,
556 SCF_PG_RESTARTER_ACTIONS_TYPE,
557 SCF_PG_RESTARTER_ACTIONS_FLAGS,
558 SCF_PROPERTY_AUX_FMRI, scratch_fmri);
559 } else {
560 uu_warn(gettext("%s: Could not set %s/%s: "
561 "my_ct_name failed.\n"), fmri,
562 SCF_PG_RESTARTER_ACTIONS, SCF_PROPERTY_AUX_FMRI);
563 }
564
565 out:
566 scf_pg_destroy(pg);
567 return (ret);
568 }
569
570 /*
571 * Enable or disable inst, per enable. If temp is true, set
572 * general_ovr/enabled. Otherwise set general/enabled and delete
573 * general_ovr/enabled if it exists (order is important here: we don't want the
574 * enabled status to glitch).
575 */
576 static void
577 set_inst_enabled(const char *fmri, scf_instance_t *inst, boolean_t temp,
578 boolean_t enable)
579 {
580 scf_propertygroup_t *pg;
581 uint8_t b;
582 const char *pgname = NULL; /* For emsg_pg_perm_denied */
583 int r;
584
585 pg = scf_pg_create(h);
586 if (pg == NULL)
587 scfdie();
588
589 if (restarter_setup(fmri, inst))
590 goto out;
591
592 /*
593 * An instance's configuration is incomplete if general/enabled
594 * doesn't exist. Create both the property group and property
595 * here if they don't exist.
596 */
597 pgname = SCF_PG_GENERAL;
598 if (pg_get_or_add(inst, pgname, SCF_PG_GENERAL_TYPE,
599 SCF_PG_GENERAL_FLAGS, pg) != 0)
600 goto eperm;
601
602 if (get_bool_prop(pg, SCF_PROPERTY_ENABLED, &b) != 0) {
603 /* Create and set state to disabled */
604 switch (set_bool_prop(pg, SCF_PROPERTY_ENABLED, B_FALSE)) {
605 case 0:
606 break;
607
608 case EPERM:
609 goto eperm;
610
611 case EROFS:
612 /* Shouldn't happen, but it can. */
613 if (!verbose)
614 uu_warn(gettext("%s: Repository read-only.\n"),
615 fmri);
616 else
617 uu_warn(gettext("%s: Could not set %s/%s "
618 "(repository read-only).\n"), fmri,
619 SCF_PG_GENERAL, SCF_PROPERTY_ENABLED);
620 goto out;
621
622 default:
623 assert(0);
624 abort();
625 }
626 }
627
628 if (temp) {
629 /* Set general_ovr/enabled */
630 pgname = SCF_PG_GENERAL_OVR;
631 if (pg_get_or_add(inst, pgname, SCF_PG_GENERAL_OVR_TYPE,
632 SCF_PG_GENERAL_OVR_FLAGS, pg) != 0)
633 goto eperm;
634
635 switch (set_bool_prop(pg, SCF_PROPERTY_ENABLED, enable)) {
636 case 0:
637 break;
638
639 case EPERM:
640 goto eperm;
641
642 case EROFS:
643 /* Shouldn't happen, but it can. */
644 if (!verbose)
645 uu_warn(gettext("%s: Repository read-only.\n"),
646 fmri);
647 else
648 uu_warn(gettext("%s: Could not set %s/%s "
649 "(repository read-only).\n"), fmri,
650 SCF_PG_GENERAL_OVR, SCF_PROPERTY_ENABLED);
651 goto out;
652
653 default:
654 assert(0);
655 abort();
656 }
657
658 if (verbose)
659 (void) printf(enable ?
660 gettext("%s temporarily enabled.\n") :
661 gettext("%s temporarily disabled.\n"), fmri);
662 } else {
663 again:
664 /*
665 * Both pg and property should exist since we created
666 * them earlier. However, there's still a chance that
667 * someone may have deleted the property out from under
668 * us.
669 */
670 if (pg_get_or_add(inst, pgname, SCF_PG_GENERAL_TYPE,
671 SCF_PG_GENERAL_FLAGS, pg) != 0)
672 goto eperm;
673
674 switch (set_bool_prop(pg, SCF_PROPERTY_ENABLED, enable)) {
675 case 0:
676 break;
677
678 case EPERM:
679 goto eperm;
680
681 case EROFS:
682 /*
683 * If general/enabled is already set the way we want,
684 * proceed.
685 */
686 switch (get_bool_prop(pg, SCF_PROPERTY_ENABLED, &b)) {
687 case 0:
688 if ((b != 0) == (enable != B_FALSE))
689 break;
690 /* FALLTHROUGH */
691
692 case ENOENT:
693 case EINVAL:
694 case E2BIG:
695 if (!verbose)
696 uu_warn(gettext("%s: Repository "
697 "read-only.\n"), fmri);
698 else
699 uu_warn(gettext("%s: Could not set "
700 "%s/%s (repository read-only).\n"),
701 fmri, SCF_PG_GENERAL,
702 SCF_PROPERTY_ENABLED);
703 goto out;
704
705 case ECANCELED:
706 goto again;
707
708 default:
709 assert(0);
710 abort();
711 }
712 break;
713
714 default:
715 assert(0);
716 abort();
717 }
718
719 pgname = SCF_PG_GENERAL_OVR;
720 r = scf_instance_delete_prop(inst, pgname,
721 SCF_PROPERTY_ENABLED);
722 switch (r) {
723 case 0:
724 break;
725
726 case ECANCELED:
727 uu_warn(emsg_no_service, fmri);
728 goto out;
729
730 case EPERM:
731 goto eperm;
732
733 case EACCES:
734 uu_warn(gettext("Could not delete %s/%s "
735 "property of %s: backend access denied.\n"),
736 pgname, SCF_PROPERTY_ENABLED, fmri);
737 goto out;
738
739 case EROFS:
740 uu_warn(gettext("Could not delete %s/%s "
741 "property of %s: backend is read-only.\n"),
742 pgname, SCF_PROPERTY_ENABLED, fmri);
743 goto out;
744
745 default:
746 bad_error("scf_instance_delete_prop", r);
747 }
748
749 if (verbose)
750 (void) printf(enable ? gettext("%s enabled.\n") :
751 gettext("%s disabled.\n"), fmri);
752 }
753
754 scf_pg_destroy(pg);
755 return;
756
757 eperm:
758 assert(pgname != NULL);
759 if (!verbose)
760 uu_warn(emsg_permission_denied, fmri);
761 else
762 uu_warn(emsg_pg_perm_denied, fmri, pgname);
763
764 out:
765 scf_pg_destroy(pg);
766 exit_status = 1;
767 }
768
769 /*
770 * Set inst to the instance which corresponds to fmri. If fmri identifies
771 * a service with a single instance, get that instance.
772 *
773 * Fails with
774 * ENOTSUP - fmri has an unsupported scheme
775 * EINVAL - fmri is invalid
776 * ENOTDIR - fmri does not identify a service or instance
777 * ENOENT - could not locate instance
778 * E2BIG - fmri is a service with multiple instances (warning not printed)
779 */
780 static int
781 get_inst_mult(const char *fmri, scf_instance_t *inst)
782 {
783 char *cfmri;
784 const char *svc_name, *inst_name, *pg_name;
785 scf_service_t *svc;
786 scf_instance_t *inst2;
787 scf_iter_t *iter;
788 int ret;
789
790 if (strncmp(fmri, "lrc:", sizeof ("lrc:") - 1) == 0) {
791 uu_warn(gettext("FMRI \"%s\" is a legacy service.\n"), fmri);
792 exit_status = 1;
793 return (ENOTSUP);
794 }
795
796 cfmri = strdup(fmri);
797 if (cfmri == NULL)
798 uu_die(emsg_nomem);
799
800 if (scf_parse_svc_fmri(cfmri, NULL, &svc_name, &inst_name, &pg_name,
801 NULL) != SCF_SUCCESS) {
802 free(cfmri);
803 uu_warn(gettext("FMRI \"%s\" is invalid.\n"), fmri);
804 exit_status = 1;
805 return (EINVAL);
806 }
807
808 free(cfmri);
809
810 if (svc_name == NULL || pg_name != NULL) {
811 uu_warn(gettext(
812 "FMRI \"%s\" does not designate a service or instance.\n"),
813 fmri);
814 exit_status = 1;
815 return (ENOTDIR);
816 }
817
818 if (inst_name != NULL) {
819 if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL,
820 NULL, SCF_DECODE_FMRI_EXACT) == 0)
821 return (0);
822
823 if (scf_error() != SCF_ERROR_NOT_FOUND)
824 scfdie();
825
826 uu_warn(gettext("No such instance \"%s\".\n"), fmri);
827 exit_status = 1;
828
829 return (ENOENT);
830 }
831
832 if ((svc = scf_service_create(h)) == NULL ||
833 (inst2 = scf_instance_create(h)) == NULL ||
834 (iter = scf_iter_create(h)) == NULL)
835 scfdie();
836
837 if (scf_handle_decode_fmri(h, fmri, NULL, svc, NULL, NULL, NULL,
838 SCF_DECODE_FMRI_EXACT) != SCF_SUCCESS) {
839 if (scf_error() != SCF_ERROR_NOT_FOUND)
840 scfdie();
841
842 uu_warn(emsg_no_service, fmri);
843 exit_status = 1;
844
845 ret = ENOENT;
846 goto out;
847 }
848
849 /* If the service has only one child, use it. */
850 if (scf_iter_service_instances(iter, svc) != SCF_SUCCESS)
851 scfdie();
852
853 ret = scf_iter_next_instance(iter, inst);
854 if (ret < 0)
855 scfdie();
856 if (ret != 1) {
857 uu_warn(gettext("Service \"%s\" has no instances.\n"),
858 fmri);
859 exit_status = 1;
860 ret = ENOENT;
861 goto out;
862 }
863
864 ret = scf_iter_next_instance(iter, inst2);
865 if (ret < 0)
866 scfdie();
867
868 if (ret != 0) {
869 ret = E2BIG;
870 goto out;
871 }
872
873 ret = 0;
874
875 out:
876 scf_iter_destroy(iter);
877 scf_instance_destroy(inst2);
878 scf_service_destroy(svc);
879 return (ret);
880 }
881
882 /*
883 * Same as get_inst_mult(), but on E2BIG prints a warning and returns ENOENT.
884 */
885 static int
886 get_inst(const char *fmri, scf_instance_t *inst)
887 {
888 int r;
889
890 r = get_inst_mult(fmri, inst);
891 if (r != E2BIG)
892 return (r);
893
894 uu_warn(gettext("operation on service %s is ambiguous; "
895 "instance specification needed.\n"), fmri);
896 return (ENOENT);
897 }
898
899 static char *
900 inst_get_fmri(const scf_instance_t *inst)
901 {
902 ssize_t sz;
903
904 sz = scf_instance_to_fmri(inst, scratch_fmri, max_scf_fmri_sz);
905 if (sz < 0)
906 scfdie();
907 if (sz >= max_scf_fmri_sz)
908 uu_die(gettext("scf_instance_to_fmri() returned unexpectedly "
909 "long value.\n"));
910
911 return (scratch_fmri);
912 }
913
914 static ssize_t
915 dep_get_astring(const char *fmri, const char *pgname,
916 const scf_propertygroup_t *pg, const char *propname, scf_property_t *prop,
917 scf_value_t *v, char *buf, size_t bufsz)
918 {
919 ssize_t sz;
920
921 sz = get_astring_prop(pg, propname, prop, v, buf, bufsz);
922 if (sz >= 0)
923 return (sz);
924
925 switch (-sz) {
926 case ENOENT:
927 uu_warn(gettext("\"%s\" is misconfigured (\"%s\" dependency "
928 "lacks \"%s\" property.)\n"), fmri, pgname, propname);
929 return (-1);
930
931 case E2BIG:
932 uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" property "
933 "is not single-valued.)\n"), fmri, pgname, propname);
934 return (-1);
935
936 case EINVAL:
937 uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" property "
938 "is not of astring type.)\n"), fmri, pgname, propname);
939 return (-1);
940
941 default:
942 assert(0);
943 abort();
944 /* NOTREACHED */
945 }
946 }
947
948 static boolean_t
949 multiple_instances(scf_iter_t *iter, scf_value_t *v, char *buf)
950 {
951 int count = 0, r;
952 boolean_t ret;
953 scf_instance_t *inst;
954
955 inst = scf_instance_create(h);
956 if (inst == NULL)
957 scfdie();
958
959 for (;;) {
960 r = scf_iter_next_value(iter, v);
961 if (r == 0) {
962 ret = B_FALSE;
963 goto out;
964 }
965 if (r != 1)
966 scfdie();
967
968 if (scf_value_get_astring(v, buf, max_scf_fmri_sz) < 0)
969 scfdie();
970
971 switch (get_inst_mult(buf, inst)) {
972 case 0:
973 ++count;
974 if (count > 1) {
975 ret = B_TRUE;
976 goto out;
977 }
978 break;
979
980 case ENOTSUP:
981 case EINVAL:
982 case ENOTDIR:
983 case ENOENT:
984 continue;
985
986 case E2BIG:
987 ret = B_TRUE;
988 goto out;
989
990 default:
991 assert(0);
992 abort();
993 }
994 }
995
996 out:
997 scf_instance_destroy(inst);
998 return (ret);
999 }
1000
1001 /*
1002 * Enable the service or instance identified by fmri and its dependencies,
1003 * recursively. Specifically, call get_inst(fmri), enable the result, and
1004 * recurse on its restarter and the dependencies. To avoid duplication of
1005 * effort or looping around a dependency cycle, each FMRI is entered into the
1006 * "visited" hash table. While recursing, the hash table entry is marked
1007 * "active", so that if we come upon it again, we know we've hit a cycle.
1008 * exclude_all and optional_all dependencies are ignored. require_any
1009 * dependencies are followed only if they comprise a single service; otherwise
1010 * the user is warned.
1011 *
1012 * fmri must point to a writable max_scf_fmri_sz buffer. Returns EINVAL if fmri
1013 * is invalid, E2BIG if fmri identifies a service with multiple instances, ELOOP
1014 * on cycle detection, or 0 on success.
1015 */
1016 static int
1017 enable_fmri_rec(char *fmri, boolean_t temp)
1018 {
1019 scf_instance_t *inst;
1020 scf_snapshot_t *snap;
1021 scf_propertygroup_t *pg;
1022 scf_property_t *prop;
1023 scf_value_t *v;
1024 scf_iter_t *pg_iter, *val_iter;
1025 scf_type_t ty;
1026 char *buf, *pgname;
1027 ssize_t name_sz, len, sz;
1028 int ret;
1029 struct ht_elt *he;
1030
1031 len = scf_canonify_fmri(fmri, fmri, max_scf_fmri_sz);
1032 if (len < 0) {
1033 assert(scf_error() == SCF_ERROR_INVALID_ARGUMENT);
1034 return (EINVAL);
1035 }
1036 assert(len < max_scf_fmri_sz);
1037
1038 switch (visited_find_or_add(fmri, &he)) {
1039 case 0:
1040 he->active = B_TRUE;
1041 break;
1042
1043 case 1:
1044 return (he->active ? ELOOP : 0);
1045
1046 case -1:
1047 uu_die(emsg_nomem);
1048
1049 default:
1050 assert(0);
1051 abort();
1052 }
1053
1054 inst = scf_instance_create(h);
1055 if (inst == NULL)
1056 scfdie();
1057
1058 switch (get_inst_mult(fmri, inst)) {
1059 case 0:
1060 break;
1061
1062 case E2BIG:
1063 he->active = B_FALSE;
1064 return (E2BIG);
1065
1066 default:
1067 he->active = B_FALSE;
1068 return (0);
1069 }
1070
1071 set_inst_enabled(fmri, inst, temp, B_TRUE);
1072
1073 if ((snap = scf_snapshot_create(h)) == NULL ||
1074 (pg = scf_pg_create(h)) == NULL ||
1075 (prop = scf_property_create(h)) == NULL ||
1076 (v = scf_value_create(h)) == NULL ||
1077 (pg_iter = scf_iter_create(h)) == NULL ||
1078 (val_iter = scf_iter_create(h)) == NULL)
1079 scfdie();
1080
1081 buf = malloc(max_scf_fmri_sz);
1082 if (buf == NULL)
1083 uu_die(emsg_nomem);
1084
1085 name_sz = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH);
1086 if (name_sz < 0)
1087 scfdie();
1088 ++name_sz;
1089 pgname = malloc(name_sz);
1090 if (pgname == NULL)
1091 uu_die(emsg_nomem);
1092
1093 if (scf_instance_get_snapshot(inst, "running", snap) != 0) {
1094 if (scf_error() != SCF_ERROR_NOT_FOUND)
1095 scfdie();
1096
1097 scf_snapshot_destroy(snap);
1098 snap = NULL;
1099 }
1100
1101 /* Enable restarter */
1102 if (scf_instance_get_pg_composed(inst, snap, SCF_PG_GENERAL, pg) != 0) {
1103 if (scf_error() != SCF_ERROR_NOT_FOUND)
1104 scfdie();
1105
1106 uu_warn(gettext("\"%s\" is misconfigured (lacks \"%s\" "
1107 "property group).\n"), fmri, SCF_PG_GENERAL);
1108 ret = 0;
1109 goto out;
1110 }
1111
1112 sz = get_astring_prop(pg, SCF_PROPERTY_RESTARTER, prop, v, buf,
1113 max_scf_fmri_sz);
1114 if (sz > max_scf_fmri_sz) {
1115 uu_warn(gettext("\"%s\" is misconfigured (the value of "
1116 "\"%s/%s\" is too long).\n"), fmri, SCF_PG_GENERAL,
1117 SCF_PROPERTY_RESTARTER);
1118 ret = 0;
1119 goto out;
1120 } else if (sz >= 0) {
1121 switch (enable_fmri_rec(buf, temp)) {
1122 case 0:
1123 break;
1124
1125 case EINVAL:
1126 uu_warn(gettext("Restarter FMRI for \"%s\" is "
1127 "invalid.\n"), fmri);
1128 break;
1129
1130 case E2BIG:
1131 uu_warn(gettext("Restarter FMRI for \"%s\" identifies "
1132 "a service with multiple instances.\n"), fmri);
1133 break;
1134
1135 case ELOOP:
1136 ret = ELOOP;
1137 goto out;
1138
1139 default:
1140 assert(0);
1141 abort();
1142 }
1143 } else if (sz < 0) {
1144 switch (-sz) {
1145 case ENOENT:
1146 break;
1147
1148 case E2BIG:
1149 uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" "
1150 "property is not single-valued).\n"), fmri,
1151 SCF_PG_GENERAL, SCF_PROPERTY_RESTARTER);
1152 ret = 0;
1153 goto out;
1154
1155 case EINVAL:
1156 uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" "
1157 "property is not of astring type).\n"), fmri,
1158 SCF_PG_GENERAL, SCF_PROPERTY_RESTARTER);
1159 ret = 0;
1160 goto out;
1161
1162 default:
1163 assert(0);
1164 abort();
1165 }
1166 }
1167
1168 if (scf_iter_instance_pgs_typed_composed(pg_iter, inst, snap,
1169 SCF_GROUP_DEPENDENCY) == -1)
1170 scfdie();
1171
1172 while (scf_iter_next_pg(pg_iter, pg) > 0) {
1173 len = scf_pg_get_name(pg, pgname, name_sz);
1174 if (len < 0)
1175 scfdie();
1176 assert(len < name_sz);
1177
1178 if (dep_get_astring(fmri, pgname, pg, SCF_PROPERTY_TYPE, prop,
1179 v, buf, max_scf_fmri_sz) < 0)
1180 continue;
1181
1182 if (strcmp(buf, "service") != 0)
1183 continue;
1184
1185 if (dep_get_astring(fmri, pgname, pg, SCF_PROPERTY_GROUPING,
1186 prop, v, buf, max_scf_fmri_sz) < 0)
1187 continue;
1188
1189 if (strcmp(buf, SCF_DEP_EXCLUDE_ALL) == 0 ||
1190 strcmp(buf, SCF_DEP_OPTIONAL_ALL) == 0)
1191 continue;
1192
1193 if (strcmp(buf, SCF_DEP_REQUIRE_ALL) != 0 &&
1194 strcmp(buf, SCF_DEP_REQUIRE_ANY) != 0) {
1195 uu_warn(gettext("Dependency \"%s\" of \"%s\" has "
1196 "unknown type \"%s\".\n"), pgname, fmri, buf);
1197 continue;
1198 }
1199
1200 if (scf_pg_get_property(pg, SCF_PROPERTY_ENTITIES, prop) ==
1201 -1) {
1202 if (scf_error() != SCF_ERROR_NOT_FOUND)
1203 scfdie();
1204
1205 uu_warn(gettext("\"%s\" is misconfigured (\"%s\" "
1206 "dependency lacks \"%s\" property.)\n"), fmri,
1207 pgname, SCF_PROPERTY_ENTITIES);
1208 continue;
1209 }
1210
1211 if (scf_property_type(prop, &ty) != SCF_SUCCESS)
1212 scfdie();
1213
1214 if (ty != SCF_TYPE_FMRI) {
1215 uu_warn(gettext("\"%s\" is misconfigured (property "
1216 "\"%s/%s\" is not of fmri type).\n"), fmri, pgname,
1217 SCF_PROPERTY_ENTITIES);
1218 continue;
1219 }
1220
1221 if (scf_iter_property_values(val_iter, prop) == -1)
1222 scfdie();
1223
1224 if (strcmp(buf, SCF_DEP_REQUIRE_ANY) == 0) {
1225 if (multiple_instances(val_iter, v, buf)) {
1226 (void) printf(gettext("%s requires one of:\n"),
1227 fmri);
1228
1229 if (scf_iter_property_values(val_iter, prop) !=
1230 0)
1231 scfdie();
1232
1233 for (;;) {
1234 int r;
1235
1236 r = scf_iter_next_value(val_iter, v);
1237 if (r == 0)
1238 break;
1239 if (r != 1)
1240 scfdie();
1241
1242 if (scf_value_get_astring(v, buf,
1243 max_scf_fmri_sz) < 0)
1244 scfdie();
1245
1246 (void) fputs(" ", stdout);
1247 (void) puts(buf);
1248 }
1249
1250 continue;
1251 }
1252
1253 /*
1254 * Since there's only one instance, we can enable it.
1255 * Reset val_iter and continue.
1256 */
1257 if (scf_iter_property_values(val_iter, prop) != 0)
1258 scfdie();
1259 }
1260
1261 for (;;) {
1262 ret = scf_iter_next_value(val_iter, v);
1263 if (ret == 0)
1264 break;
1265 if (ret != 1)
1266 scfdie();
1267
1268 if (scf_value_get_astring(v, buf, max_scf_fmri_sz) ==
1269 -1)
1270 scfdie();
1271
1272 switch (enable_fmri_rec(buf, temp)) {
1273 case 0:
1274 break;
1275
1276 case EINVAL:
1277 uu_warn(gettext("\"%s\" dependency of \"%s\" "
1278 "has invalid FMRI \"%s\".\n"), pgname,
1279 fmri, buf);
1280 break;
1281
1282 case E2BIG:
1283 uu_warn(gettext("%s depends on %s, which has "
1284 "multiple instances.\n"), fmri, buf);
1285 break;
1286
1287 case ELOOP:
1288 ret = ELOOP;
1289 goto out;
1290
1291 default:
1292 assert(0);
1293 abort();
1294 }
1295 }
1296 }
1297
1298 ret = 0;
1299
1300 out:
1301 he->active = B_FALSE;
1302
1303 free(buf);
1304 free(pgname);
1305
1306 (void) scf_value_destroy(v);
1307 scf_property_destroy(prop);
1308 scf_pg_destroy(pg);
1309 scf_snapshot_destroy(snap);
1310 scf_iter_destroy(pg_iter);
1311 scf_iter_destroy(val_iter);
1312
1313 return (ret);
1314 }
1315
1316 /*
1317 * fmri here is only used for verbose messages.
1318 */
1319 static void
1320 set_inst_action(const char *fmri, const scf_instance_t *inst,
1321 const char *action)
1322 {
1323 scf_transaction_t *tx;
1324 scf_transaction_entry_t *ent;
1325 scf_propertygroup_t *pg;
1326 scf_property_t *prop;
1327 scf_value_t *v;
1328 int ret;
1329 int64_t t;
1330 hrtime_t timestamp;
1331
1332 const char * const scf_pg_restarter_actions = SCF_PG_RESTARTER_ACTIONS;
1333
1334 if ((pg = scf_pg_create(h)) == NULL ||
1335 (prop = scf_property_create(h)) == NULL ||
1336 (v = scf_value_create(h)) == NULL ||
1337 (tx = scf_transaction_create(h)) == NULL ||
1338 (ent = scf_entry_create(h)) == NULL)
1339 scfdie();
1340
1341 if (restarter_setup(fmri, inst)) {
1342 exit_status = 1;
1343 goto out;
1344 }
1345
1346 if (scf_instance_get_pg(inst, scf_pg_restarter_actions, pg) == -1) {
1347 if (scf_error() != SCF_ERROR_NOT_FOUND)
1348 scfdie();
1349
1350 /* Try creating the restarter_actions property group. */
1351 if (scf_instance_add_pg(inst, scf_pg_restarter_actions,
1352 SCF_PG_RESTARTER_ACTIONS_TYPE,
1353 SCF_PG_RESTARTER_ACTIONS_FLAGS, pg) == -1) {
1354 switch (scf_error()) {
1355 case SCF_ERROR_EXISTS:
1356 /* Someone must have added it. */
1357 break;
1358
1359 case SCF_ERROR_PERMISSION_DENIED:
1360 if (!verbose)
1361 uu_warn(emsg_permission_denied, fmri);
1362 else
1363 uu_warn(emsg_create_pg_perm_denied,
1364 fmri, scf_pg_restarter_actions);
1365 goto out;
1366
1367 default:
1368 scfdie();
1369 }
1370 }
1371 }
1372
1373 /*
1374 * If we lose the transaction race and need to retry, there are 2
1375 * potential other winners:
1376 * - another process setting actions
1377 * - the restarter marking the action complete
1378 * Therefore, re-read the property every time through the loop before
1379 * making any decisions based on their values.
1380 */
1381 do {
1382 timestamp = gethrtime();
1383
1384 if (scf_transaction_start(tx, pg) == -1) {
1385 if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
1386 scfdie();
1387
1388 if (!verbose)
1389 uu_warn(emsg_permission_denied, fmri);
1390 else
1391 uu_warn(emsg_pg_perm_denied, fmri,
1392 scf_pg_restarter_actions);
1393 goto out;
1394 }
1395
1396 if (scf_pg_get_property(pg, action, prop) == -1) {
1397 if (scf_error() != SCF_ERROR_NOT_FOUND)
1398 scfdie();
1399 if (scf_transaction_property_new(tx, ent,
1400 action, SCF_TYPE_INTEGER) == -1)
1401 scfdie();
1402 goto action_set;
1403 } else {
1404 if (scf_transaction_property_change_type(tx, ent,
1405 action, SCF_TYPE_INTEGER) == -1)
1406 scfdie();
1407 }
1408
1409 if (scf_property_get_value(prop, v) == -1) {
1410 switch (scf_error()) {
1411 case SCF_ERROR_CONSTRAINT_VIOLATED:
1412 case SCF_ERROR_NOT_FOUND:
1413 /* Misconfigured, so set anyway. */
1414 goto action_set;
1415
1416 default:
1417 scfdie();
1418 }
1419 } else {
1420 if (scf_value_get_integer(v, &t) == -1) {
1421 assert(scf_error() == SCF_ERROR_TYPE_MISMATCH);
1422 goto action_set;
1423 }
1424 if (t > timestamp)
1425 break;
1426 }
1427
1428 action_set:
1429 scf_value_set_integer(v, timestamp);
1430 if (scf_entry_add_value(ent, v) == -1)
1431 scfdie();
1432
1433 ret = scf_transaction_commit(tx);
1434 if (ret == -1) {
1435 if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
1436 scfdie();
1437
1438 if (!verbose)
1439 uu_warn(emsg_permission_denied, fmri);
1440 else
1441 uu_warn(emsg_prop_perm_denied, fmri,
1442 scf_pg_restarter_actions, action);
1443 scf_transaction_reset(tx);
1444 goto out;
1445 }
1446
1447 scf_transaction_reset(tx);
1448
1449 if (ret == 0) {
1450 if (scf_pg_update(pg) == -1)
1451 scfdie();
1452 }
1453 } while (ret == 0);
1454
1455 if (verbose)
1456 (void) printf(gettext("Action %s set for %s.\n"), action, fmri);
1457
1458 out:
1459 scf_value_destroy(v);
1460 scf_entry_destroy(ent);
1461 scf_transaction_destroy(tx);
1462 scf_property_destroy(prop);
1463 scf_pg_destroy(pg);
1464 }
1465
1466 /*
1467 * Get the state of inst. state should point to a buffer of
1468 * MAX_SCF_STATE_STRING_SZ bytes. Returns 0 on success or -1 if
1469 * no restarter property group
1470 * no state property
1471 * state property is misconfigured (wrong type, not single-valued)
1472 * state value is too long
1473 * In these cases, fmri is used to print a warning.
1474 *
1475 * If pgp is non-NULL, a successful call to inst_get_state will store
1476 * the SCF_PG_RESTARTER property group in *pgp, and the caller will be
1477 * responsible for calling scf_pg_destroy on the property group.
1478 */
1479 int
1480 inst_get_state(scf_instance_t *inst, char *state, const char *fmri,
1481 scf_propertygroup_t **pgp)
1482 {
1483 scf_propertygroup_t *pg;
1484 scf_property_t *prop;
1485 scf_value_t *val;
1486 int ret = -1;
1487 ssize_t szret;
1488
1489 if ((pg = scf_pg_create(h)) == NULL ||
1490 (prop = scf_property_create(h)) == NULL ||
1491 (val = scf_value_create(h)) == NULL)
1492 scfdie();
1493
1494 if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, pg) != SCF_SUCCESS) {
1495 if (scf_error() != SCF_ERROR_NOT_FOUND)
1496 scfdie();
1497
1498 uu_warn(gettext("%s is misconfigured (lacks \"%s\" property "
1499 "group).\n"), fmri ? fmri : inst_get_fmri(inst),
1500 SCF_PG_RESTARTER);
1501 goto out;
1502 }
1503
1504 szret = get_astring_prop(pg, SCF_PROPERTY_STATE, prop, val, state,
1505 MAX_SCF_STATE_STRING_SZ);
1506 if (szret < 0) {
1507 switch (-szret) {
1508 case ENOENT:
1509 uu_warn(gettext("%s is misconfigured (\"%s\" property "
1510 "group lacks \"%s\" property).\n"),
1511 fmri ? fmri : inst_get_fmri(inst), SCF_PG_RESTARTER,
1512 SCF_PROPERTY_STATE);
1513 goto out;
1514
1515 case E2BIG:
1516 uu_warn(gettext("%s is misconfigured (\"%s/%s\" "
1517 "property is not single-valued).\n"),
1518 fmri ? fmri : inst_get_fmri(inst), SCF_PG_RESTARTER,
1519 SCF_PROPERTY_STATE);
1520 goto out;
1521
1522 case EINVAL:
1523 uu_warn(gettext("%s is misconfigured (\"%s/%s\" "
1524 "property is not of type astring).\n"),
1525 fmri ? fmri : inst_get_fmri(inst), SCF_PG_RESTARTER,
1526 SCF_PROPERTY_STATE);
1527 goto out;
1528
1529 default:
1530 assert(0);
1531 abort();
1532 }
1533 }
1534 if (szret >= MAX_SCF_STATE_STRING_SZ) {
1535 uu_warn(gettext("%s is misconfigured (\"%s/%s\" property value "
1536 "is too long).\n"), fmri ? fmri : inst_get_fmri(inst),
1537 SCF_PG_RESTARTER, SCF_PROPERTY_STATE);
1538 goto out;
1539 }
1540
1541 ret = 0;
1542 if (pgp)
1543 *pgp = pg;
1544
1545 out:
1546 (void) scf_value_destroy(val);
1547 scf_property_destroy(prop);
1548 if (ret || pgp == NULL)
1549 scf_pg_destroy(pg);
1550 return (ret);
1551 }
1552
1553 static void
1554 set_astring_prop(const char *fmri, const char *pgname, const char *pgtype,
1555 uint32_t pgflags, const char *propname, const char *str)
1556 {
1557 scf_instance_t *inst;
1558 scf_propertygroup_t *pg;
1559 scf_property_t *prop;
1560 scf_value_t *val;
1561 scf_transaction_t *tx;
1562 scf_transaction_entry_t *txent;
1563 int ret;
1564
1565 inst = scf_instance_create(h);
1566 if (inst == NULL)
1567 scfdie();
1568
1569 if (get_inst(fmri, inst) != 0)
1570 return;
1571
1572 if ((pg = scf_pg_create(h)) == NULL ||
1573 (prop = scf_property_create(h)) == NULL ||
1574 (val = scf_value_create(h)) == NULL ||
1575 (tx = scf_transaction_create(h)) == NULL ||
1576 (txent = scf_entry_create(h)) == NULL)
1577 scfdie();
1578
1579 if (scf_instance_get_pg(inst, pgname, pg) != SCF_SUCCESS) {
1580 if (scf_error() != SCF_ERROR_NOT_FOUND)
1581 scfdie();
1582
1583 if (scf_instance_add_pg(inst, pgname, pgtype, pgflags, pg) !=
1584 SCF_SUCCESS) {
1585 switch (scf_error()) {
1586 case SCF_ERROR_EXISTS:
1587 if (scf_instance_get_pg(inst, pgname, pg) !=
1588 SCF_SUCCESS) {
1589 if (scf_error() != SCF_ERROR_NOT_FOUND)
1590 scfdie();
1591
1592 uu_warn(gettext("Repository write "
1593 "contention.\n"));
1594 goto out;
1595 }
1596 break;
1597
1598 case SCF_ERROR_PERMISSION_DENIED:
1599 if (!verbose)
1600 uu_warn(emsg_permission_denied, fmri);
1601 else
1602 uu_warn(emsg_create_pg_perm_denied,
1603 fmri, pgname);
1604 goto out;
1605
1606 default:
1607 scfdie();
1608 }
1609 }
1610 }
1611
1612 do {
1613 if (scf_transaction_start(tx, pg) != SCF_SUCCESS) {
1614 if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
1615 scfdie();
1616
1617 if (!verbose)
1618 uu_warn(emsg_permission_denied, fmri);
1619 else
1620 uu_warn(emsg_pg_perm_denied, fmri, pgname);
1621 goto out;
1622 }
1623
1624 if (scf_transaction_property_change_type(tx, txent, propname,
1625 SCF_TYPE_ASTRING) != 0) {
1626 if (scf_error() != SCF_ERROR_NOT_FOUND)
1627 scfdie();
1628
1629 if (scf_transaction_property_new(tx, txent, propname,
1630 SCF_TYPE_ASTRING) != 0)
1631 scfdie();
1632 }
1633
1634 if (scf_value_set_astring(val, str) != SCF_SUCCESS)
1635 scfdie();
1636
1637 if (scf_entry_add_value(txent, val) != SCF_SUCCESS)
1638 scfdie();
1639
1640 ret = scf_transaction_commit(tx);
1641 if (ret == -1) {
1642 if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
1643 scfdie();
1644
1645 if (!verbose)
1646 uu_warn(emsg_permission_denied, fmri);
1647 else
1648 uu_warn(emsg_prop_perm_denied, fmri, pgname,
1649 propname);
1650 goto out;
1651 }
1652
1653 if (ret == 0) {
1654 scf_transaction_reset(tx);
1655
1656 if (scf_pg_update(pg) == -1)
1657 scfdie();
1658 }
1659 } while (ret == 0);
1660
1661 out:
1662 scf_transaction_destroy(tx);
1663 scf_entry_destroy(txent);
1664 scf_value_destroy(val);
1665 scf_property_destroy(prop);
1666 scf_pg_destroy(pg);
1667 scf_instance_destroy(inst);
1668 }
1669
1670
1671 /*
1672 * Flags to control enable and disable actions.
1673 */
1674 #define SET_ENABLED 0x1
1675 #define SET_TEMPORARY 0x2
1676 #define SET_RECURSIVE 0x4
1677
1678 static int
1679 set_fmri_enabled(void *data, scf_walkinfo_t *wip)
1680 {
1681 int flags = (int)data;
1682
1683 assert(wip->inst != NULL);
1684 assert(wip->pg == NULL);
1685
1686 if (svcsearch) {
1687 char state[MAX_SCF_STATE_STRING_SZ];
1688
1689 if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0)
1690 return (0);
1691 if (strcmp(state, svcstate) != 0)
1692 return (0);
1693 }
1694
1695 if (flags & SET_RECURSIVE) {
1696 char *fmri_buf = malloc(max_scf_fmri_sz);
1697 if (fmri_buf == NULL)
1698 uu_die(emsg_nomem);
1699
1700 visited = calloc(HT_BUCKETS, sizeof (*visited));
1701 if (visited == NULL)
1702 uu_die(emsg_nomem);
1703
1704 /* scf_walk_fmri() guarantees that fmri isn't too long */
1705 assert(strlen(wip->fmri) <= max_scf_fmri_sz);
1706 (void) strlcpy(fmri_buf, wip->fmri, max_scf_fmri_sz);
1707
1708 switch (enable_fmri_rec(fmri_buf, (flags & SET_TEMPORARY))) {
1709 case E2BIG:
1710 uu_warn(gettext("operation on service %s is ambiguous; "
1711 "instance specification needed.\n"), fmri_buf);
1712 break;
1713
1714 case ELOOP:
1715 uu_warn(gettext("%s: Dependency cycle detected.\n"),
1716 fmri_buf);
1717 }
1718
1719 free(visited);
1720 free(fmri_buf);
1721
1722 } else {
1723 set_inst_enabled(wip->fmri, wip->inst,
1724 (flags & SET_TEMPORARY) != 0, (flags & SET_ENABLED) != 0);
1725 }
1726
1727 return (0);
1728 }
1729
1730 /* ARGSUSED */
1731 static int
1732 wait_fmri_enabled(void *data, scf_walkinfo_t *wip)
1733 {
1734 scf_propertygroup_t *pg = NULL;
1735 char state[MAX_SCF_STATE_STRING_SZ];
1736
1737 assert(wip->inst != NULL);
1738 assert(wip->pg == NULL);
1739
1740 do {
1741 if (pg)
1742 scf_pg_destroy(pg);
1743 if (inst_get_state(wip->inst, state, wip->fmri, &pg) != 0) {
1744 exit_status = EXIT_SVC_FAILURE;
1745 return (0);
1746 }
1747
1748 if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0 ||
1749 strcmp(state, SCF_STATE_STRING_DEGRADED) == 0) {
1750 /*
1751 * We're done.
1752 */
1753 goto out;
1754 }
1755
1756 if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) {
1757 /*
1758 * The service is ill.
1759 */
1760 uu_warn(gettext("Instance \"%s\" is in maintenance"
1761 " state.\n"), wip->fmri);
1762 exit_status = EXIT_SVC_FAILURE;
1763 goto out;
1764 }
1765
1766 if (!is_enabled(wip->inst)) {
1767 /*
1768 * Someone stepped in and disabled the service.
1769 */
1770 uu_warn(gettext("Instance \"%s\" has been disabled"
1771 " by another entity.\n"), wip->fmri);
1772 exit_status = EXIT_SVC_FAILURE;
1773 goto out;
1774 }
1775
1776 if (!has_potential(wip->inst, B_FALSE)) {
1777 /*
1778 * Our dependencies aren't met. We'll never
1779 * amount to anything.
1780 */
1781 uu_warn(gettext("Instance \"%s\" has unsatisfied"
1782 " dependencies.\n"), wip->fmri);
1783 /*
1784 * EXIT_SVC_FAILURE takes precedence over
1785 * EXIT_DEP_FAILURE
1786 */
1787 if (exit_status == 0)
1788 exit_status = EXIT_DEP_FAILURE;
1789 goto out;
1790 }
1791 } while (_scf_pg_wait(pg, WAIT_INTERVAL) >= 0);
1792 scfdie();
1793 /* NOTREACHED */
1794
1795 out:
1796 scf_pg_destroy(pg);
1797 return (0);
1798 }
1799
1800 /* ARGSUSED */
1801 static int
1802 wait_fmri_disabled(void *data, scf_walkinfo_t *wip)
1803 {
1804 scf_propertygroup_t *pg = NULL;
1805 char state[MAX_SCF_STATE_STRING_SZ];
1806
1807 assert(wip->inst != NULL);
1808 assert(wip->pg == NULL);
1809
1810 do {
1811 if (pg)
1812 scf_pg_destroy(pg);
1813 if (inst_get_state(wip->inst, state, wip->fmri, &pg) != 0) {
1814 exit_status = EXIT_SVC_FAILURE;
1815 return (0);
1816 }
1817
1818 if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0) {
1819 /*
1820 * We're done.
1821 */
1822 goto out;
1823 }
1824
1825 if (is_enabled(wip->inst)) {
1826 /*
1827 * Someone stepped in and enabled the service.
1828 */
1829 uu_warn(gettext("Instance \"%s\" has been enabled"
1830 " by another entity.\n"), wip->fmri);
1831 exit_status = EXIT_SVC_FAILURE;
1832 goto out;
1833 }
1834
1835 if (!has_potential(wip->inst, B_TRUE)) {
1836 /*
1837 * Our restarter is hopeless.
1838 */
1839 uu_warn(gettext("Restarter for instance \"%s\" is"
1840 " unavailable.\n"), wip->fmri);
1841 /*
1842 * EXIT_SVC_FAILURE takes precedence over
1843 * EXIT_DEP_FAILURE
1844 */
1845 if (exit_status == 0)
1846 exit_status = EXIT_DEP_FAILURE;
1847 goto out;
1848 }
1849
1850 } while (_scf_pg_wait(pg, WAIT_INTERVAL) >= 0);
1851 scfdie();
1852 /* NOTREACHED */
1853
1854 out:
1855 scf_pg_destroy(pg);
1856 return (0);
1857 }
1858
1859 /* ARGSUSED */
1860 static int
1861 clear_instance(void *data, scf_walkinfo_t *wip)
1862 {
1863 char state[MAX_SCF_STATE_STRING_SZ];
1864
1865 assert(wip->inst != NULL);
1866 assert(wip->pg == NULL);
1867
1868 if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0)
1869 return (0);
1870
1871 if (svcsearch && strcmp(state, svcstate) != 0)
1872 return (0);
1873
1874 if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) {
1875 set_inst_action(wip->fmri, wip->inst, SCF_PROPERTY_MAINT_OFF);
1876 } else if (strcmp(state, SCF_STATE_STRING_DEGRADED) ==
1877 0) {
1878 set_inst_action(wip->fmri, wip->inst, SCF_PROPERTY_RESTORE);
1879 } else {
1880 uu_warn(gettext("Instance \"%s\" is not in a "
1881 "maintenance or degraded state.\n"), wip->fmri);
1882
1883 exit_status = 1;
1884 }
1885
1886 return (0);
1887 }
1888
1889 static int
1890 set_fmri_action(void *action, scf_walkinfo_t *wip)
1891 {
1892 assert(wip->inst != NULL && wip->pg == NULL);
1893
1894 if (svcsearch) {
1895 char state[MAX_SCF_STATE_STRING_SZ];
1896
1897 if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0)
1898 return (0);
1899 if (strcmp(state, svcstate) != 0)
1900 return (0);
1901 }
1902
1903 set_inst_action(wip->fmri, wip->inst, action);
1904
1905 return (0);
1906 }
1907
1908 /*
1909 * Flags to control 'mark' action.
1910 */
1911 #define MARK_IMMEDIATE 0x1
1912 #define MARK_TEMPORARY 0x2
1913
1914 static int
1915 force_degraded(void *data, scf_walkinfo_t *wip)
1916 {
1917 int flags = (int)data;
1918 char state[MAX_SCF_STATE_STRING_SZ];
1919
1920 if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0) {
1921 exit_status = 1;
1922 return (0);
1923 }
1924
1925 if (svcsearch && strcmp(state, svcstate) != 0)
1926 return (0);
1927
1928 if (strcmp(state, SCF_STATE_STRING_ONLINE) != 0) {
1929 uu_warn(gettext("Instance \"%s\" is not online.\n"), wip->fmri);
1930 exit_status = 1;
1931 return (0);
1932 }
1933
1934 set_inst_action(wip->fmri, wip->inst, (flags & MARK_IMMEDIATE) ?
1935 SCF_PROPERTY_DEGRADE_IMMEDIATE : SCF_PROPERTY_DEGRADED);
1936
1937 return (0);
1938 }
1939
1940 static int
1941 force_maintenance(void *data, scf_walkinfo_t *wip)
1942 {
1943 int flags = (int)data;
1944 const char *prop;
1945
1946 if (svcsearch) {
1947 char state[MAX_SCF_STATE_STRING_SZ];
1948
1949 if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0)
1950 return (0);
1951 if (strcmp(state, svcstate) != 0)
1952 return (0);
1953 }
1954
1955 if (flags & MARK_IMMEDIATE) {
1956 prop = (flags & MARK_TEMPORARY) ?
1957 SCF_PROPERTY_MAINT_ON_IMMTEMP :
1958 SCF_PROPERTY_MAINT_ON_IMMEDIATE;
1959 } else {
1960 prop = (flags & MARK_TEMPORARY) ?
1961 SCF_PROPERTY_MAINT_ON_TEMPORARY :
1962 SCF_PROPERTY_MAINT_ON;
1963 }
1964
1965 set_inst_action(wip->fmri, wip->inst, prop);
1966
1967 return (0);
1968 }
1969
1970 static void
1971 set_milestone(const char *fmri, boolean_t temporary)
1972 {
1973 scf_instance_t *inst;
1974 scf_propertygroup_t *pg;
1975 int r;
1976
1977 if (temporary) {
1978 set_astring_prop(SCF_SERVICE_STARTD, SCF_PG_OPTIONS_OVR,
1979 SCF_PG_OPTIONS_OVR_TYPE, SCF_PG_OPTIONS_OVR_FLAGS,
1980 SCF_PROPERTY_MILESTONE, fmri);
1981 return;
1982 }
1983
1984 if ((inst = scf_instance_create(h)) == NULL ||
1985 (pg = scf_pg_create(h)) == NULL)
1986 scfdie();
1987
1988 if (get_inst(SCF_SERVICE_STARTD, inst) != 0) {
1989 scf_instance_destroy(inst);
1990 return;
1991 }
1992
1993 /*
1994 * Set the persistent milestone before deleting the override so we don't
1995 * glitch.
1996 */
1997 set_astring_prop(SCF_SERVICE_STARTD, SCF_PG_OPTIONS,
1998 SCF_PG_OPTIONS_TYPE, SCF_PG_OPTIONS_FLAGS, SCF_PROPERTY_MILESTONE,
1999 fmri);
2000
2001 r = scf_instance_delete_prop(inst, SCF_PG_OPTIONS_OVR,
2002 SCF_PROPERTY_MILESTONE);
2003 switch (r) {
2004 case 0:
2005 break;
2006
2007 case ECANCELED:
2008 uu_warn(emsg_no_service, fmri);
2009 exit_status = 1;
2010 goto out;
2011
2012 case EPERM:
2013 uu_warn(gettext("Could not delete %s/%s property of "
2014 "%s: permission denied.\n"), SCF_PG_OPTIONS_OVR,
2015 SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD);
2016 exit_status = 1;
2017 goto out;
2018
2019 case EACCES:
2020 uu_warn(gettext("Could not delete %s/%s property of "
2021 "%s: access denied.\n"), SCF_PG_OPTIONS_OVR,
2022 SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD);
2023 exit_status = 1;
2024 goto out;
2025
2026 case EROFS:
2027 uu_warn(gettext("Could not delete %s/%s property of "
2028 "%s: backend read-only.\n"), SCF_PG_OPTIONS_OVR,
2029 SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD);
2030 exit_status = 1;
2031 goto out;
2032
2033 default:
2034 bad_error("scf_instance_delete_prop", r);
2035 }
2036
2037 out:
2038 scf_pg_destroy(pg);
2039 scf_instance_destroy(inst);
2040 }
2041
2042 static char const *milestones[] = {
2043 SCF_MILESTONE_SINGLE_USER,
2044 SCF_MILESTONE_MULTI_USER,
2045 SCF_MILESTONE_MULTI_USER_SERVER,
2046 NULL
2047 };
2048
2049 static void
2050 usage_milestone(void)
2051 {
2052 const char **ms;
2053
2054 (void) fprintf(stderr, gettext(
2055 "Usage: svcadm milestone [-d] <milestone>\n\n"
2056 "\t-d\tmake the specified milestone the default for system boot\n\n"
2057 "\tMilestones can be specified using an FMRI or abbreviation.\n"
2058 "\tThe major milestones are as follows:\n\n"
2059 "\tall\n"
2060 "\tnone\n"));
2061
2062 for (ms = milestones; *ms != NULL; ms++)
2063 (void) fprintf(stderr, "\t%s\n", *ms);
2064
2065 exit(UU_EXIT_USAGE);
2066 }
2067
2068 static const char *
2069 validate_milestone(const char *milestone)
2070 {
2071 const char **ms;
2072 const char *tmp;
2073 size_t len;
2074
2075 if (strcmp(milestone, "all") == 0)
2076 return (milestone);
2077
2078 if (strcmp(milestone, "none") == 0)
2079 return (milestone);
2080
2081 /*
2082 * Determine if this is a full or partial milestone
2083 */
2084 for (ms = milestones; *ms != NULL; ms++) {
2085 if ((tmp = strstr(*ms, milestone)) != NULL) {
2086 len = strlen(milestone);
2087
2088 /*
2089 * The beginning of the string must align with the start
2090 * of a milestone fmri, or on the boundary between
2091 * elements. The end of the string must align with the
2092 * end of the milestone, or at the instance boundary.
2093 */
2094 if ((tmp == *ms || tmp[-1] == '/') &&
2095 (tmp[len] == '\0' || tmp[len] == ':'))
2096 return (*ms);
2097 }
2098 }
2099
2100 (void) fprintf(stderr,
2101 gettext("\"%s\" is not a valid major milestone.\n"), milestone);
2102
2103 usage_milestone();
2104 /* NOTREACHED */
2105 }
2106
2107 /*PRINTFLIKE1*/
2108 static void
2109 pr_warn(const char *format, ...)
2110 {
2111 const char *pname = uu_getpname();
2112 va_list alist;
2113
2114 va_start(alist, format);
2115
2116 if (pname != NULL)
2117 (void) fprintf(stderr, "%s", pname);
2118
2119 if (g_zonename != NULL)
2120 (void) fprintf(stderr, " (%s)", g_zonename);
2121
2122 (void) fprintf(stderr, ": ");
2123
2124 (void) vfprintf(stderr, format, alist);
2125
2126 if (strrchr(format, '\n') == NULL)
2127 (void) fprintf(stderr, ": %s\n", strerror(errno));
2128
2129 va_end(alist);
2130 }
2131
2132 /*ARGSUSED*/
2133 static void
2134 quiet(const char *fmt, ...)
2135 {
2136 /* Do nothing */
2137 }
2138
2139 int
2140 main(int argc, char *argv[])
2141 {
2142 int o;
2143 int err;
2144 int sw_back;
2145 boolean_t do_zones = B_FALSE;
2146 boolean_t do_a_zone = B_FALSE;
2147 char zonename[ZONENAME_MAX];
2148 uint_t nzents = 0, zent = 0;
2149 zoneid_t *zids = NULL;
2150 int orig_optind, orig_argc;
2151 char **orig_argv;
2152
2153 (void) setlocale(LC_ALL, "");
2154 (void) textdomain(TEXT_DOMAIN);
2155
2156 (void) uu_setpname(argv[0]);
2157
2158 if (argc < 2)
2159 usage();
2160
2161 max_scf_fmri_sz = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH);
2162 if (max_scf_fmri_sz < 0)
2163 scfdie();
2164 ++max_scf_fmri_sz;
2165
2166 scratch_fmri = malloc(max_scf_fmri_sz);
2167 if (scratch_fmri == NULL)
2168 uu_die(emsg_nomem);
2169
2170 while ((o = getopt(argc, argv, "S:vZz:")) != -1) {
2171 switch (o) {
2172 case 'S':
2173 (void) strlcpy(svcstate, optarg, sizeof (svcstate));
2174 svcsearch = B_TRUE;
2175 break;
2176
2177 case 'v':
2178 verbose = 1;
2179 break;
2180
2181 case 'z':
2182 if (getzoneid() != GLOBAL_ZONEID)
2183 uu_die(gettext("svcadm -z may only be used "
2184 "from the global zone\n"));
2185 if (do_zones)
2186 usage();
2187
2188 (void) strlcpy(zonename, optarg, sizeof (zonename));
2189 do_a_zone = B_TRUE;
2190 break;
2191
2192 case 'Z':
2193 if (getzoneid() != GLOBAL_ZONEID)
2194 uu_die(gettext("svcadm -Z may only be used "
2195 "from the global zone\n"));
2196 if (do_a_zone)
2197 usage();
2198
2199 do_zones = B_TRUE;
2200 break;
2201
2202 default:
2203 usage();
2204 }
2205 }
2206
2207 while (do_zones) {
2208 uint_t found;
2209
2210 if (zone_list(NULL, &nzents) != 0)
2211 uu_die(gettext("could not get number of zones"));
2212
2213 if ((zids = malloc(nzents * sizeof (zoneid_t))) == NULL) {
2214 uu_die(gettext("could not allocate array for "
2215 "%d zone IDs"), nzents);
2216 }
2217
2218 found = nzents;
2219
2220 if (zone_list(zids, &found) != 0)
2221 uu_die(gettext("could not get zone list"));
2222
2223 /*
2224 * If the number of zones has not changed between our calls to
2225 * zone_list(), we're done -- otherwise, we must free our array
2226 * of zone IDs and take another lap.
2227 */
2228 if (found == nzents)
2229 break;
2230
2231 free(zids);
2232 }
2233
2234 emsg_permission_denied = gettext("%s: Permission denied.\n");
2235 emsg_nomem = gettext("Out of memory.\n");
2236 emsg_create_pg_perm_denied = gettext("%s: Couldn't create \"%s\" "
2237 "property group (permission denied).\n");
2238 emsg_pg_perm_denied = gettext("%s: Couldn't modify \"%s\" property "
2239 "group (permission denied).\n");
2240 emsg_prop_perm_denied = gettext("%s: Couldn't modify \"%s/%s\" "
2241 "property (permission denied).\n");
2242 emsg_no_service = gettext("No such service \"%s\".\n");
2243
2244 orig_optind = optind;
2245 orig_argc = argc;
2246 orig_argv = argv;
2247
2248 again:
2249 h = scf_handle_create(SCF_VERSION);
2250 if (h == NULL)
2251 scfdie();
2252
2253 if (do_zones) {
2254 zone_status_t status;
2255
2256 if (zone_getattr(zids[zent], ZONE_ATTR_STATUS, &status,
2257 sizeof (status)) < 0 || status != ZONE_IS_RUNNING) {
2258 /*
2259 * If this zone is not running or we cannot
2260 * get its status, we do not want to attempt
2261 * to bind an SCF handle to it, lest we
2262 * accidentally interfere with a zone that
2263 * is not yet running by looking up a door
2264 * to its svc.configd (which could potentially
2265 * block a mount with an EBUSY).
2266 */
2267 zent++;
2268 goto nextzone;
2269 }
2270
2271 if (getzonenamebyid(zids[zent++], zonename,
2272 sizeof (zonename)) < 0) {
2273 uu_warn(gettext("could not get name for "
2274 "zone %d; ignoring"), zids[zent - 1]);
2275 goto nextzone;
2276 }
2277
2278 g_zonename = zonename;
2279 }
2280
2281 if (do_a_zone || do_zones) {
2282 scf_value_t *zone;
2283
2284 if ((zone = scf_value_create(h)) == NULL)
2285 scfdie();
2286
2287 if (scf_value_set_astring(zone, zonename) != SCF_SUCCESS)
2288 scfdie();
2289
2290 if (scf_handle_decorate(h, "zone", zone) != SCF_SUCCESS) {
2291 if (do_a_zone) {
2292 uu_die(gettext("invalid zone '%s'\n"), optarg);
2293 } else {
2294 scf_value_destroy(zone);
2295 goto nextzone;
2296 }
2297 }
2298
2299 scf_value_destroy(zone);
2300 }
2301
2302 if (scf_handle_bind(h) == -1) {
2303 if (do_zones)
2304 goto nextzone;
2305
2306 uu_die(gettext("Couldn't bind to configuration repository: "
2307 "%s.\n"), scf_strerror(scf_error()));
2308 }
2309
2310 optind = orig_optind;
2311 argc = orig_argc;
2312 argv = orig_argv;
2313
2314 if (optind >= argc)
2315 usage();
2316
2317 if (strcmp(argv[optind], "enable") == 0) {
2318 int flags = SET_ENABLED;
2319 int wait = 0;
2320 int error = 0;
2321
2322 ++optind;
2323
2324 while ((o = getopt(argc, argv, "rst")) != -1) {
2325 if (o == 'r')
2326 flags |= SET_RECURSIVE;
2327 else if (o == 't')
2328 flags |= SET_TEMPORARY;
2329 else if (o == 's')
2330 wait = 1;
2331 else if (o == '?')
2332 usage();
2333 else {
2334 assert(0);
2335 abort();
2336 }
2337 }
2338 argc -= optind;
2339 argv += optind;
2340
2341 if (argc == 0 && !svcsearch)
2342 usage();
2343
2344 if (argc > 0 && svcsearch)
2345 usage();
2346
2347 /*
2348 * We want to continue with -s processing if we had
2349 * invalid options, but not if an enable failed. We
2350 * squelch output the second time we walk fmris; we saw
2351 * the errors the first time.
2352 */
2353 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2354 set_fmri_enabled, (void *)flags, &error, pr_warn)) != 0) {
2355
2356 pr_warn(gettext("failed to iterate over "
2357 "instances: %s\n"), scf_strerror(err));
2358 exit_status = UU_EXIT_FATAL;
2359
2360 } else if (wait && exit_status == 0 &&
2361 (err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2362 wait_fmri_enabled, (void *)flags, &error, quiet)) != 0) {
2363
2364 pr_warn(gettext("failed to iterate over "
2365 "instances: %s\n"), scf_strerror(err));
2366 exit_status = UU_EXIT_FATAL;
2367 }
2368
2369 if (error > 0)
2370 exit_status = error;
2371
2372 } else if (strcmp(argv[optind], "disable") == 0) {
2373 int flags = 0;
2374 int wait = 0;
2375 int error = 0;
2376
2377 ++optind;
2378
2379 while ((o = getopt(argc, argv, "st")) != -1) {
2380 if (o == 't')
2381 flags |= SET_TEMPORARY;
2382 else if (o == 's')
2383 wait = 1;
2384 else if (o == '?')
2385 usage();
2386 else {
2387 assert(0);
2388 abort();
2389 }
2390 }
2391 argc -= optind;
2392 argv += optind;
2393
2394 if (argc == 0 && !svcsearch)
2395 usage();
2396
2397 if (argc > 0 && svcsearch)
2398 usage();
2399
2400 /*
2401 * We want to continue with -s processing if we had
2402 * invalid options, but not if a disable failed. We
2403 * squelch output the second time we walk fmris; we saw
2404 * the errors the first time.
2405 */
2406 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2407 set_fmri_enabled, (void *)flags, &exit_status,
2408 pr_warn)) != 0) {
2409
2410 pr_warn(gettext("failed to iterate over "
2411 "instances: %s\n"), scf_strerror(err));
2412 exit_status = UU_EXIT_FATAL;
2413
2414 } else if (wait && exit_status == 0 &&
2415 (err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2416 wait_fmri_disabled, (void *)flags, &error, quiet)) != 0) {
2417
2418 pr_warn(gettext("failed to iterate over "
2419 "instances: %s\n"), scf_strerror(err));
2420 exit_status = UU_EXIT_FATAL;
2421 }
2422
2423 if (error > 0)
2424 exit_status = error;
2425
2426 } else if (strcmp(argv[optind], "restart") == 0) {
2427 boolean_t do_dump = B_FALSE;
2428
2429 ++optind;
2430
2431 while ((o = getopt(argc, argv, "d")) != -1) {
2432 if (o == 'd')
2433 do_dump = B_TRUE;
2434 else if (o == '?')
2435 usage();
2436 else {
2437 assert(0);
2438 abort();
2439 }
2440 }
2441 argc -= optind;
2442 argv += optind;
2443
2444 if (argc == 0 && !svcsearch)
2445 usage();
2446
2447 if (argc > 0 && svcsearch)
2448 usage();
2449
2450 if (do_dump) {
2451 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2452 set_fmri_action, (void *)SCF_PROPERTY_DODUMP,
2453 &exit_status, pr_warn)) != 0) {
2454 pr_warn(gettext("failed to iterate over "
2455 "instances: %s\n"), scf_strerror(err));
2456 exit_status = UU_EXIT_FATAL;
2457 }
2458 }
2459
2460 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2461 set_fmri_action, (void *)SCF_PROPERTY_RESTART, &exit_status,
2462 pr_warn)) != 0) {
2463 pr_warn(gettext("failed to iterate over "
2464 "instances: %s\n"), scf_strerror(err));
2465 exit_status = UU_EXIT_FATAL;
2466 }
2467
2468 } else if (strcmp(argv[optind], "refresh") == 0) {
2469 ++optind;
2470 argc -= optind;
2471 argv += optind;
2472
2473 if (argc == 0 && !svcsearch)
2474 usage();
2475
2476 if (argc > 0 && svcsearch)
2477 usage();
2478
2479 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2480 set_fmri_action, (void *)SCF_PROPERTY_REFRESH, &exit_status,
2481 pr_warn)) != 0) {
2482 pr_warn(gettext("failed to iterate over "
2483 "instances: %s\n"), scf_strerror(scf_error()));
2484 exit_status = UU_EXIT_FATAL;
2485 }
2486
2487 } else if (strcmp(argv[optind], "mark") == 0) {
2488 int flags = 0;
2489 scf_walk_callback callback;
2490
2491 ++optind;
2492
2493 while ((o = getopt(argc, argv, "It")) != -1) {
2494 if (o == 'I')
2495 flags |= MARK_IMMEDIATE;
2496 else if (o == 't')
2497 flags |= MARK_TEMPORARY;
2498 else if (o == '?')
2499 usage();
2500 else {
2501 assert(0);
2502 abort();
2503 }
2504 }
2505
2506 if (argc - optind < 2)
2507 usage();
2508
2509 if (strcmp(argv[optind], "degraded") == 0) {
2510 if (flags & MARK_TEMPORARY)
2511 uu_xdie(UU_EXIT_USAGE, gettext("-t may not be "
2512 "used with degraded.\n"));
2513 callback = force_degraded;
2514
2515 } else if (strcmp(argv[optind], "maintenance") == 0) {
2516 callback = force_maintenance;
2517 } else {
2518 usage();
2519 }
2520
2521 optind++;
2522 argc -= optind;
2523 argv += optind;
2524
2525 if (argc == 0 && !svcsearch)
2526 usage();
2527
2528 if (argc > 0 && svcsearch)
2529 usage();
2530
2531 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS, callback,
2532 NULL, &exit_status, pr_warn)) != 0) {
2533 pr_warn(gettext("failed to iterate over "
2534 "instances: %s\n"),
2535 scf_strerror(err));
2536 exit_status = UU_EXIT_FATAL;
2537 }
2538
2539 } else if (strcmp(argv[optind], "clear") == 0) {
2540 ++optind;
2541 argc -= optind;
2542 argv += optind;
2543
2544 if (argc == 0 && !svcsearch)
2545 usage();
2546
2547 if (svcsearch) {
2548 if (argc > 0)
2549 usage();
2550 if (strcmp(svcstate, SCF_STATE_STRING_MAINT) != 0 &&
2551 strcmp(svcstate, SCF_STATE_STRING_DEGRADED) != 0)
2552 uu_die(gettext("State must be '%s' or '%s'\n"),
2553 SCF_STATE_STRING_MAINT,
2554 SCF_STATE_STRING_DEGRADED);
2555 }
2556
2557 if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2558 clear_instance, NULL, &exit_status, pr_warn)) != 0) {
2559 pr_warn(gettext("failed to iterate over "
2560 "instances: %s\n"), scf_strerror(err));
2561 exit_status = UU_EXIT_FATAL;
2562 }
2563
2564 } else if (strcmp(argv[optind], "milestone") == 0) {
2565 boolean_t temporary = B_TRUE;
2566 const char *milestone;
2567
2568 ++optind;
2569
2570 while ((o = getopt(argc, argv, "d")) != -1) {
2571 if (o == 'd')
2572 temporary = B_FALSE;
2573 else if (o == '?')
2574 usage_milestone();
2575 else {
2576 assert(0);
2577 abort();
2578 }
2579 }
2580
2581 if (optind >= argc)
2582 usage_milestone();
2583
2584 milestone = validate_milestone(argv[optind]);
2585
2586 set_milestone(milestone, temporary);
2587 } else if (strcmp(argv[optind], "_smf_backup") == 0) {
2588 const char *reason = NULL;
2589
2590 ++optind;
2591
2592 if (optind != argc - 1)
2593 usage();
2594
2595 if ((err = _scf_request_backup(h, argv[optind])) !=
2596 SCF_SUCCESS) {
2597 switch (scf_error()) {
2598 case SCF_ERROR_NOT_BOUND:
2599 case SCF_ERROR_CONNECTION_BROKEN:
2600 case SCF_ERROR_BACKEND_READONLY:
2601 scfdie();
2602 break;
2603
2604 case SCF_ERROR_PERMISSION_DENIED:
2605 case SCF_ERROR_INVALID_ARGUMENT:
2606 reason = scf_strerror(scf_error());
2607 break;
2608
2609 case SCF_ERROR_INTERNAL:
2610 reason =
2611 "unknown error (see console for details)";
2612 break;
2613 }
2614
2615 pr_warn("failed to backup repository: %s\n", reason);
2616 exit_status = UU_EXIT_FATAL;
2617 }
2618 } else if (strcmp(argv[optind], "_smf_repository_switch") == 0) {
2619 const char *reason = NULL;
2620
2621 ++optind;
2622
2623 /*
2624 * Check argument and setup scf_switch structure
2625 */
2626 if (optind != argc - 1)
2627 exit(1);
2628
2629 if (strcmp(argv[optind], "fast") == 0) {
2630 sw_back = 0;
2631 } else if (strcmp(argv[optind], "perm") == 0) {
2632 sw_back = 1;
2633 } else {
2634 exit(UU_EXIT_USAGE);
2635 }
2636
2637 /*
2638 * Call into switch primitive
2639 */
2640 if ((err = _scf_repository_switch(h, sw_back)) !=
2641 SCF_SUCCESS) {
2642 /*
2643 * Retrieve per thread SCF error code
2644 */
2645 switch (scf_error()) {
2646 case SCF_ERROR_NOT_BOUND:
2647 abort();
2648 /* NOTREACHED */
2649
2650 case SCF_ERROR_CONNECTION_BROKEN:
2651 case SCF_ERROR_BACKEND_READONLY:
2652 scfdie();
2653 /* NOTREACHED */
2654
2655 case SCF_ERROR_PERMISSION_DENIED:
2656 case SCF_ERROR_INVALID_ARGUMENT:
2657 reason = scf_strerror(scf_error());
2658 break;
2659
2660 case SCF_ERROR_INTERNAL:
2661 reason = "File operation error: (see console)";
2662 break;
2663
2664 default:
2665 abort();
2666 /* NOTREACHED */
2667 }
2668
2669 pr_warn("failed to switch repository: %s\n", reason);
2670 exit_status = UU_EXIT_FATAL;
2671 }
2672 } else {
2673 usage();
2674 }
2675
2676 if (scf_handle_unbind(h) == -1)
2677 scfdie();
2678 nextzone:
2679 scf_handle_destroy(h);
2680 if (do_zones && zent < nzents)
2681 goto again;
2682
2683 return (exit_status);
2684 }