1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2012 Milan Jurik. All rights reserved.
25 */
26
27
28 #include <sys/contract/process.h>
29 #include <assert.h>
30 #include <errno.h>
31 #include <libscf.h>
32 #include <libscf_priv.h>
33 #include <poll.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <unistd.h>
37
38 #include "startd.h"
39
40 #define SMF_SNAPSHOT_RUNNING "running"
41
42 #define INFO_EVENTS_ALL "info_events_all"
43
44 char *
45 inst_fmri_to_svc_fmri(const char *fmri)
46 {
47 char *buf, *sfmri;
48 const char *scope, *svc;
49 int r;
50 boolean_t local;
51
52 buf = startd_alloc(max_scf_fmri_size);
53 sfmri = startd_alloc(max_scf_fmri_size);
54
55 (void) strcpy(buf, fmri);
56
57 r = scf_parse_svc_fmri(buf, &scope, &svc, NULL, NULL, NULL);
58 assert(r == 0);
59
60 local = strcmp(scope, SCF_SCOPE_LOCAL) == 0;
61
62 (void) snprintf(sfmri, max_scf_fmri_size, "svc:%s%s/%s",
63 local ? "" : "//", local ? "" : scope, svc);
64
65 startd_free(buf, max_scf_fmri_size);
66
67 return (sfmri);
68 }
69
70 /*
71 * Wrapper for the scf_*_create() functions. On SCF_ERROR_NO_MEMORY and
72 * SCF_ERROR_NO_RESOURCES, retries or dies. So this can only fail with
73 * SCF_ERROR_INVALID_ARGUMENT, if h is NULL.
74 */
75 void *
76 libscf_object_create(void *f(scf_handle_t *), scf_handle_t *h)
77 {
78 void *o;
79 uint_t try, msecs;
80 scf_error_t err;
81
82 o = f(h);
83 if (o != NULL)
84 return (o);
85 err = scf_error();
86 if (err != SCF_ERROR_NO_MEMORY && err != SCF_ERROR_NO_RESOURCES)
87 return (NULL);
88
89 msecs = ALLOC_DELAY;
90
91 for (try = 0; try < ALLOC_RETRY; ++try) {
92 (void) poll(NULL, 0, msecs);
93 msecs *= ALLOC_DELAY_MULT;
94 o = f(h);
95 if (o != NULL)
96 return (o);
97 err = scf_error();
98 if (err != SCF_ERROR_NO_MEMORY && err != SCF_ERROR_NO_RESOURCES)
99 return (NULL);
100 }
101
102 uu_die("Insufficient memory.\n");
103 /* NOTREACHED */
104 }
105
106 scf_snapshot_t *
107 libscf_get_running_snapshot(scf_instance_t *inst)
108 {
109 scf_handle_t *h;
110 scf_snapshot_t *snap;
111
112 h = scf_instance_handle(inst);
113 if (h == NULL)
114 return (NULL);
115
116 snap = scf_snapshot_create(h);
117 if (snap == NULL)
118 return (NULL);
119
120 if (scf_instance_get_snapshot(inst, SMF_SNAPSHOT_RUNNING, snap) == 0)
121 return (snap);
122
123 scf_snapshot_destroy(snap);
124 return (NULL);
125 }
126
127 /*
128 * Make sure a service has a "running" snapshot. If it doesn't, make one from
129 * the editing configuration.
130 */
131 scf_snapshot_t *
132 libscf_get_or_make_running_snapshot(scf_instance_t *inst, const char *fmri,
133 boolean_t retake)
134 {
135 scf_handle_t *h;
136 scf_snapshot_t *snap;
137
138 h = scf_instance_handle(inst);
139
140 snap = scf_snapshot_create(h);
141 if (snap == NULL)
142 goto err;
143
144 if (scf_instance_get_snapshot(inst, SMF_SNAPSHOT_RUNNING, snap) == 0)
145 return (snap);
146
147 switch (scf_error()) {
148 case SCF_ERROR_NOT_FOUND:
149 break;
150
151 case SCF_ERROR_DELETED:
152 scf_snapshot_destroy(snap);
153 return (NULL);
154
155 default:
156 err:
157 log_error(LOG_NOTICE,
158 "Could not check for running snapshot of %s (%s).\n", fmri,
159 scf_strerror(scf_error()));
160 scf_snapshot_destroy(snap);
161 return (NULL);
162 }
163
164 if (_scf_snapshot_take_new(inst, SMF_SNAPSHOT_RUNNING, snap) == 0) {
165 log_framework(LOG_DEBUG, "Took running snapshot for %s.\n",
166 fmri);
167 } else {
168 if (retake && scf_error() == SCF_ERROR_BACKEND_READONLY)
169 restarter_mark_pending_snapshot(fmri,
170 RINST_RETAKE_RUNNING);
171 else
172 log_error(LOG_DEBUG,
173 "Could not create running snapshot for %s "
174 "(%s).\n", fmri, scf_strerror(scf_error()));
175
176 scf_snapshot_destroy(snap);
177 snap = NULL;
178 }
179
180 return (snap);
181 }
182
183 /*
184 * When a service comes up, point the "start" snapshot at the "running"
185 * snapshot. Returns 0 on success, ENOTSUP if fmri designates something other
186 * than an instance, ECONNABORTED, ENOENT if the instance does not exist, or
187 * EACCES.
188 */
189 int
190 libscf_snapshots_poststart(scf_handle_t *h, const char *fmri, boolean_t retake)
191 {
192 scf_instance_t *inst = NULL;
193 scf_snapshot_t *running, *start = NULL;
194 int ret = 0, r;
195
196 r = libscf_fmri_get_instance(h, fmri, &inst);
197 switch (r) {
198 case 0:
199 break;
200
201 case ENOTSUP:
202 case ECONNABORTED:
203 case ENOENT:
204 return (r);
205
206 case EINVAL:
207 default:
208 assert(0);
209 abort();
210 }
211
212 start = safe_scf_snapshot_create(h);
213
214 again:
215 running = libscf_get_or_make_running_snapshot(inst, fmri, retake);
216 if (running == NULL) {
217 ret = 0;
218 goto out;
219 }
220
221 lookup:
222 if (scf_instance_get_snapshot(inst, "start", start) != 0) {
223 switch (scf_error()) {
224 case SCF_ERROR_CONNECTION_BROKEN:
225 default:
226 ret = ECONNABORTED;
227 goto out;
228
229 case SCF_ERROR_NOT_FOUND:
230 if (_scf_snapshot_take_new(inst, "start", start) != 0) {
231 switch (scf_error()) {
232 case SCF_ERROR_CONNECTION_BROKEN:
233 default:
234 ret = ECONNABORTED;
235 goto out;
236
237 case SCF_ERROR_DELETED:
238 ret = ENOENT;
239 goto out;
240
241 case SCF_ERROR_EXISTS:
242 goto lookup;
243
244 case SCF_ERROR_NO_RESOURCES:
245 uu_die("Repository server out of "
246 "resources.\n");
247 /* NOTREACHED */
248
249 case SCF_ERROR_BACKEND_READONLY:
250 goto readonly;
251
252 case SCF_ERROR_PERMISSION_DENIED:
253 uu_die("Insufficient privileges.\n");
254 /* NOTREACHED */
255
256 case SCF_ERROR_BACKEND_ACCESS:
257 ret = EACCES;
258 goto out;
259
260 case SCF_ERROR_HANDLE_MISMATCH:
261 case SCF_ERROR_INTERNAL:
262 case SCF_ERROR_INVALID_ARGUMENT:
263 case SCF_ERROR_NOT_SET:
264 bad_error("_scf_snapshot_take_new",
265 scf_error());
266 }
267 }
268 break;
269
270 case SCF_ERROR_DELETED:
271 ret = ENOENT;
272 goto out;
273
274 case SCF_ERROR_HANDLE_MISMATCH:
275 case SCF_ERROR_NOT_SET:
276 case SCF_ERROR_INVALID_ARGUMENT:
277 bad_error("scf_instance_get_snapshot", scf_error());
278 }
279 }
280
281 if (_scf_snapshot_attach(running, start) == 0) {
282 log_framework(LOG_DEBUG, "Updated \"start\" snapshot for %s.\n",
283 fmri);
284 } else {
285 switch (scf_error()) {
286 case SCF_ERROR_CONNECTION_BROKEN:
287 default:
288 ret = ECONNABORTED;
289 goto out;
290
291 case SCF_ERROR_DELETED:
292 scf_snapshot_destroy(running);
293 goto again;
294
295 case SCF_ERROR_NO_RESOURCES:
296 uu_die("Repository server out of resources.\n");
297 /* NOTREACHED */
298
299 case SCF_ERROR_PERMISSION_DENIED:
300 uu_die("Insufficient privileges.\n");
301 /* NOTREACHED */
302
303 case SCF_ERROR_BACKEND_ACCESS:
304 ret = EACCES;
305 goto out;
306
307 case SCF_ERROR_BACKEND_READONLY:
308 readonly:
309 if (retake)
310 restarter_mark_pending_snapshot(fmri,
311 RINST_RETAKE_START);
312 break;
313
314 case SCF_ERROR_HANDLE_MISMATCH:
315 case SCF_ERROR_NOT_SET:
316 bad_error("_scf_snapshot_attach", scf_error());
317 }
318 }
319
320 out:
321 scf_snapshot_destroy(start);
322 scf_snapshot_destroy(running);
323 scf_instance_destroy(inst);
324
325 return (ret);
326 }
327
328 /*
329 * Before a refresh, update the "running" snapshot from the editing
330 * configuration.
331 *
332 * Returns 0 on success and -1 on failure.
333 */
334 int
335 libscf_snapshots_refresh(scf_instance_t *inst, const char *fmri)
336 {
337 scf_handle_t *h;
338 scf_snapshot_t *snap;
339 boolean_t err = 1;
340
341 h = scf_instance_handle(inst);
342 if (h == NULL)
343 goto out;
344
345 snap = scf_snapshot_create(h);
346 if (snap == NULL)
347 goto out;
348
349 if (scf_instance_get_snapshot(inst, SMF_SNAPSHOT_RUNNING, snap) == 0) {
350 if (_scf_snapshot_take_attach(inst, snap) == 0)
351 err = 0;
352 } else {
353 switch (scf_error()) {
354 case SCF_ERROR_DELETED:
355 err = 0;
356 goto out;
357
358 case SCF_ERROR_NOT_FOUND:
359 break;
360
361 case SCF_ERROR_NOT_SET:
362 assert(0);
363 abort();
364 /* NOTREACHED */
365
366 default:
367 goto out;
368 }
369
370 log_error(LOG_DEBUG,
371 "Service %s has no %s snapshot; creating one.\n", fmri,
372 SMF_SNAPSHOT_RUNNING);
373
374 if (_scf_snapshot_take_new(inst, SMF_SNAPSHOT_RUNNING,
375 snap) == 0)
376 err = 0;
377 }
378
379 out:
380 scf_snapshot_destroy(snap);
381
382 if (!err)
383 return (0);
384
385 log_error(LOG_WARNING,
386 "Could not update \"running\" snapshot for refresh of %s.\n", fmri);
387 return (-1);
388 }
389
390 /*
391 * int libscf_read_single_astring()
392 * Reads a single astring value of the requested property into the
393 * pre-allocated buffer (conventionally of size max_scf_value_size).
394 * Multiple values constitute an error.
395 *
396 * Returns 0 on success or LIBSCF_PROPERTY_ABSENT or LIBSCF_PROPERTY_ERROR.
397 */
398 static int
399 libscf_read_single_astring(scf_handle_t *h, scf_property_t *prop, char **ret)
400 {
401 scf_value_t *val = safe_scf_value_create(h);
402 int r = 0;
403
404 if (scf_property_get_value(prop, val) == -1) {
405 if (scf_error() == SCF_ERROR_NOT_FOUND)
406 r = LIBSCF_PROPERTY_ABSENT;
407 else
408 r = LIBSCF_PROPERTY_ERROR;
409 goto read_single_astring_fail;
410 }
411
412 if (scf_value_get_astring(val, *ret, max_scf_value_size) <= 0) {
413 r = LIBSCF_PROPERTY_ERROR;
414 goto read_single_astring_fail;
415 }
416
417 read_single_astring_fail:
418 scf_value_destroy(val);
419 return (r);
420 }
421
422 /*
423 * libscf_get_stn_tset
424 */
425 int32_t
426 libscf_get_stn_tset(scf_instance_t *inst)
427 {
428 scf_handle_t *h = scf_instance_handle(inst);
429 scf_propertygroup_t *pg = scf_pg_create(h);
430 char *pgname = NULL;
431 int32_t t, f, tset;
432
433 assert(inst != NULL);
434
435 pgname = startd_alloc(max_scf_fmri_size);
436 if (h == NULL || pg == NULL) {
437 tset = -1;
438 goto cleanup;
439 }
440
441 for (tset = 0, t = 1; t < SCF_STATE_ALL; t <<= 1) {
442 f = t << 16;
443
444 (void) strcpy(pgname, SCF_STN_PREFIX_TO);
445 (void) strlcat(pgname, smf_state_to_string(t),
446 max_scf_fmri_size);
447
448 if (scf_instance_get_pg_composed(inst, NULL, pgname, pg) ==
449 SCF_SUCCESS) {
450 tset |= t;
451 } else if (scf_error() != SCF_ERROR_NOT_FOUND && scf_error() !=
452 SCF_ERROR_DELETED) {
453 tset = -1;
454 goto cleanup;
455 }
456
457 (void) strcpy(pgname, SCF_STN_PREFIX_FROM);
458 (void) strlcat(pgname, smf_state_to_string(t),
459 max_scf_fmri_size);
460
461 if (scf_instance_get_pg_composed(inst, NULL, pgname, pg) ==
462 SCF_SUCCESS) {
463 tset |= f;
464 } else if (scf_error() != SCF_ERROR_NOT_FOUND && scf_error() !=
465 SCF_ERROR_DELETED) {
466 tset = -1;
467 goto cleanup;
468 }
469 }
470
471 cleanup:
472 scf_pg_destroy(pg);
473 startd_free(pgname, max_scf_fmri_size);
474
475 return (tset);
476 }
477
478 static int32_t
479 libscf_get_global_stn_tset(scf_handle_t *h)
480 {
481 scf_instance_t *inst = scf_instance_create(h);
482 int32_t tset = -1;
483
484 if (inst == NULL) {
485 goto cleanup;
486 }
487
488 if (scf_handle_decode_fmri(h, SCF_INSTANCE_GLOBAL, NULL, NULL, inst,
489 NULL, NULL, SCF_DECODE_FMRI_REQUIRE_INSTANCE) != 0) {
490 goto cleanup;
491 }
492
493 tset = libscf_get_stn_tset(inst);
494
495 cleanup:
496 scf_instance_destroy(inst);
497
498 if (tset == -1)
499 log_framework(LOG_WARNING,
500 "Failed to get system wide notification parameters: %s\n",
501 scf_strerror(scf_error()));
502
503 return (tset);
504 }
505
506 static int
507 libscf_read_state(const scf_propertygroup_t *pg, const char *prop_name,
508 restarter_instance_state_t *state)
509 {
510 scf_handle_t *h;
511 scf_property_t *prop;
512 char *char_state = startd_alloc(max_scf_value_size);
513 int ret = 0;
514
515 h = scf_pg_handle(pg);
516 prop = safe_scf_property_create(h);
517
518 if (scf_pg_get_property(pg, prop_name, prop) == -1) {
519 if (scf_error() == SCF_ERROR_NOT_FOUND)
520 ret = LIBSCF_PROPERTY_ABSENT;
521 else
522 ret = LIBSCF_PROPERTY_ERROR;
523 } else {
524 ret = libscf_read_single_astring(h, prop, &char_state);
525 if (ret != 0) {
526 if (ret != LIBSCF_PROPERTY_ABSENT)
527 ret = LIBSCF_PROPERTY_ERROR;
528 } else {
529 *state = restarter_string_to_state(char_state);
530 ret = 0;
531 }
532 }
533
534 startd_free(char_state, max_scf_value_size);
535 scf_property_destroy(prop);
536 return (ret);
537 }
538
539 /*
540 * int libscf_read_states(const scf_propertygroup_t *,
541 * restarter_instance_state_t *, restarter_instance_state_t *)
542 *
543 * Set the current state and next_state values for the given service instance.
544 * Returns 0 on success, or a libscf error code on failure.
545 */
546 int
547 libscf_read_states(const scf_propertygroup_t *pg,
548 restarter_instance_state_t *state, restarter_instance_state_t *next_state)
549 {
550 int state_ret, next_state_ret, ret;
551
552 state_ret = libscf_read_state(pg, SCF_PROPERTY_STATE, state);
553 next_state_ret = libscf_read_state(pg, SCF_PROPERTY_NEXT_STATE,
554 next_state);
555
556 if (state_ret == LIBSCF_PROPERTY_ERROR ||
557 next_state_ret == LIBSCF_PROPERTY_ERROR) {
558 ret = LIBSCF_PROPERTY_ERROR;
559 } else if (state_ret == 0 && next_state_ret == 0) {
560 ret = 0;
561 } else if (state_ret == LIBSCF_PROPERTY_ABSENT &&
562 next_state_ret == LIBSCF_PROPERTY_ABSENT) {
563 *state = RESTARTER_STATE_UNINIT;
564 *next_state = RESTARTER_STATE_NONE;
565 ret = 0;
566 } else if (state_ret == LIBSCF_PROPERTY_ABSENT ||
567 next_state_ret == LIBSCF_PROPERTY_ABSENT) {
568 log_framework(LOG_DEBUG,
569 "Only one repository state exists, setting "
570 "restarter states to MAINTENANCE and NONE\n");
571 *state = RESTARTER_STATE_MAINT;
572 *next_state = RESTARTER_STATE_NONE;
573 ret = 0;
574 } else {
575 ret = LIBSCF_PROPERTY_ERROR;
576 }
577
578 read_states_out:
579 return (ret);
580 }
581
582 /*
583 * depgroup_empty()
584 *
585 * Returns 0 if not empty.
586 * Returns 1 if empty.
587 * Returns -1 on error (check scf_error()).
588 */
589 int
590 depgroup_empty(scf_handle_t *h, scf_propertygroup_t *pg)
591 {
592 int empty = 1;
593 scf_iter_t *iter;
594 scf_property_t *prop;
595 int ret;
596
597 iter = safe_scf_iter_create(h);
598 prop = safe_scf_property_create(h);
599
600 if (scf_iter_pg_properties(iter, pg) != SCF_SUCCESS) {
601 scf_property_destroy(prop);
602 scf_iter_destroy(iter);
603 return (-1);
604 }
605
606 ret = scf_iter_next_property(iter, prop);
607 if (ret < 0) {
608 scf_property_destroy(prop);
609 scf_iter_destroy(iter);
610 return (-1);
611 }
612
613 if (ret == 1)
614 empty = 0;
615
616 scf_property_destroy(prop);
617 scf_iter_destroy(iter);
618
619 return (empty);
620 }
621
622 gv_type_t
623 depgroup_read_scheme(scf_handle_t *h, scf_propertygroup_t *pg)
624 {
625 scf_property_t *prop;
626 char *scheme = startd_alloc(max_scf_value_size);
627 gv_type_t ret;
628
629 prop = safe_scf_property_create(h);
630
631 if (scf_pg_get_property(pg, SCF_PROPERTY_TYPE, prop) == -1 ||
632 libscf_read_single_astring(h, prop, &scheme) != 0) {
633 scf_property_destroy(prop);
634 startd_free(scheme, max_scf_value_size);
635 return (GVT_UNSUPPORTED);
636 }
637
638 if (strcmp(scheme, "service") == 0)
639 ret = GVT_INST;
640 else if (strcmp(scheme, "path") == 0)
641 ret = GVT_FILE;
642 else
643 ret = GVT_UNSUPPORTED;
644
645 startd_free(scheme, max_scf_value_size);
646 scf_property_destroy(prop);
647 return (ret);
648 }
649
650 depgroup_type_t
651 depgroup_read_grouping(scf_handle_t *h, scf_propertygroup_t *pg)
652 {
653 char *grouping = startd_alloc(max_scf_value_size);
654 depgroup_type_t ret;
655 scf_property_t *prop = safe_scf_property_create(h);
656
657 if (scf_pg_get_property(pg, SCF_PROPERTY_GROUPING, prop) == -1 ||
658 libscf_read_single_astring(h, prop, &grouping) != 0) {
659 scf_property_destroy(prop);
660 startd_free(grouping, max_scf_value_size);
661 return (DEPGRP_UNSUPPORTED);
662 }
663
664 if (strcmp(grouping, SCF_DEP_REQUIRE_ANY) == 0)
665 ret = DEPGRP_REQUIRE_ANY;
666 else if (strcmp(grouping, SCF_DEP_REQUIRE_ALL) == 0)
667 ret = DEPGRP_REQUIRE_ALL;
668 else if (strcmp(grouping, SCF_DEP_OPTIONAL_ALL) == 0)
669 ret = DEPGRP_OPTIONAL_ALL;
670 else if (strcmp(grouping, SCF_DEP_EXCLUDE_ALL) == 0)
671 ret = DEPGRP_EXCLUDE_ALL;
672 else {
673 ret = DEPGRP_UNSUPPORTED;
674 }
675 startd_free(grouping, max_scf_value_size);
676 scf_property_destroy(prop);
677 return (ret);
678 }
679
680 restarter_error_t
681 depgroup_read_restart(scf_handle_t *h, scf_propertygroup_t *pg)
682 {
683 scf_property_t *prop = safe_scf_property_create(h);
684 char *restart_on = startd_alloc(max_scf_value_size);
685 restarter_error_t ret;
686
687 if (scf_pg_get_property(pg, SCF_PROPERTY_RESTART_ON, prop) == -1 ||
688 libscf_read_single_astring(h, prop, &restart_on) != 0) {
689 startd_free(restart_on, max_scf_value_size);
690 scf_property_destroy(prop);
691 return (RERR_UNSUPPORTED);
692 }
693
694 if (strcmp(restart_on, SCF_DEP_RESET_ON_ERROR) == 0)
695 ret = RERR_FAULT;
696 else if (strcmp(restart_on, SCF_DEP_RESET_ON_RESTART) == 0)
697 ret = RERR_RESTART;
698 else if (strcmp(restart_on, SCF_DEP_RESET_ON_REFRESH) == 0)
699 ret = RERR_REFRESH;
700 else if (strcmp(restart_on, SCF_DEP_RESET_ON_NONE) == 0)
701 ret = RERR_NONE;
702 else
703 ret = RERR_UNSUPPORTED;
704
705 startd_free(restart_on, max_scf_value_size);
706 scf_property_destroy(prop);
707 return (ret);
708 }
709
710 /*
711 * int get_boolean()
712 * Fetches the value of a boolean property of the given property group.
713 * Returns
714 * 0 - success
715 * ECONNABORTED - repository connection broken
716 * ECANCELED - pg was deleted
717 * ENOENT - the property doesn't exist or has no values
718 * EINVAL - the property has the wrong type
719 * the property is not single-valued
720 * EACCES - the current user does not have permission to read the value
721 */
722 static int
723 get_boolean(scf_propertygroup_t *pg, const char *propname, uint8_t *valuep)
724 {
725 scf_handle_t *h;
726 scf_property_t *prop;
727 scf_value_t *val;
728 int ret = 0, r;
729 scf_type_t type;
730
731 h = scf_pg_handle(pg);
732 prop = safe_scf_property_create(h);
733 val = safe_scf_value_create(h);
734
735 if (scf_pg_get_property(pg, propname, prop) != 0) {
736 switch (scf_error()) {
737 case SCF_ERROR_CONNECTION_BROKEN:
738 default:
739 ret = ECONNABORTED;
740 goto out;
741
742 case SCF_ERROR_DELETED:
743 ret = ECANCELED;
744 goto out;
745
746 case SCF_ERROR_NOT_FOUND:
747 ret = ENOENT;
748 goto out;
749
750 case SCF_ERROR_HANDLE_MISMATCH:
751 case SCF_ERROR_INVALID_ARGUMENT:
752 case SCF_ERROR_NOT_SET:
753 bad_error("scf_pg_get_property", scf_error());
754 }
755 }
756
757 if (scf_property_type(prop, &type) != 0) {
758 switch (scf_error()) {
759 case SCF_ERROR_CONNECTION_BROKEN:
760 default:
761 ret = ECONNABORTED;
762 goto out;
763
764 case SCF_ERROR_DELETED:
765 ret = ENOENT;
766 goto out;
767
768 case SCF_ERROR_NOT_SET:
769 bad_error("scf_property_type", scf_error());
770 }
771 }
772
773 if (type != SCF_TYPE_BOOLEAN) {
774 ret = EINVAL;
775 goto out;
776 }
777
778 if (scf_property_get_value(prop, val) != 0) {
779 switch (scf_error()) {
780 case SCF_ERROR_CONNECTION_BROKEN:
781 default:
782 ret = ECONNABORTED;
783 goto out;
784
785 case SCF_ERROR_DELETED:
786 case SCF_ERROR_NOT_FOUND:
787 ret = ENOENT;
788 goto out;
789
790 case SCF_ERROR_CONSTRAINT_VIOLATED:
791 ret = EINVAL;
792 goto out;
793
794 case SCF_ERROR_PERMISSION_DENIED:
795 ret = EACCES;
796 goto out;
797
798 case SCF_ERROR_NOT_SET:
799 bad_error("scf_property_get_value", scf_error());
800 }
801 }
802
803 r = scf_value_get_boolean(val, valuep);
804 assert(r == 0);
805
806 out:
807 scf_value_destroy(val);
808 scf_property_destroy(prop);
809 return (ret);
810 }
811
812 /*
813 * get info event property from restarter:default
814 */
815 int
816 libscf_get_info_events_all(scf_propertygroup_t *pg)
817 {
818 uint8_t v;
819 int r = 0;
820
821 if (get_boolean(pg, INFO_EVENTS_ALL, &v) == 0) {
822 r = v;
823 } else if (scf_error() != SCF_ERROR_NOT_FOUND) {
824 uu_warn("Failed get_boolean %s/%s: %s\n",
825 SCF_PG_OPTIONS, INFO_EVENTS_ALL,
826 scf_strerror(scf_error()));
827 }
828
829 return (r);
830 }
831
832 /*
833 * int get_count()
834 * Fetches the value of a count property of the given property group.
835 * Returns
836 * 0 - success
837 * ECONNABORTED - repository connection broken
838 * unknown libscf error
839 * ECANCELED - pg was deleted
840 * ENOENT - the property doesn't exist or has no values
841 * EINVAL - the property has the wrong type
842 * the property is not single-valued
843 * EACCES - the current user does not have permission to read the value
844 */
845 static int
846 get_count(scf_propertygroup_t *pg, const char *propname, uint64_t *valuep)
847 {
848 scf_handle_t *h;
849 scf_property_t *prop;
850 scf_value_t *val;
851 int ret = 0, r;
852
853 h = scf_pg_handle(pg);
854 prop = safe_scf_property_create(h);
855 val = safe_scf_value_create(h);
856
857 if (scf_pg_get_property(pg, propname, prop) != 0) {
858 switch (scf_error()) {
859 case SCF_ERROR_CONNECTION_BROKEN:
860 default:
861 ret = ECONNABORTED;
862 goto out;
863
864 case SCF_ERROR_DELETED:
865 ret = ECANCELED;
866 goto out;
867
868 case SCF_ERROR_NOT_FOUND:
869 ret = ENOENT;
870 goto out;
871
872 case SCF_ERROR_HANDLE_MISMATCH:
873 case SCF_ERROR_INVALID_ARGUMENT:
874 case SCF_ERROR_NOT_SET:
875 bad_error("scf_pg_get_property", scf_error());
876 }
877 }
878
879 if (scf_property_is_type(prop, SCF_TYPE_COUNT) != 0) {
880 switch (scf_error()) {
881 case SCF_ERROR_CONNECTION_BROKEN:
882 default:
883 ret = ECONNABORTED;
884 goto out;
885
886 case SCF_ERROR_TYPE_MISMATCH:
887 ret = EINVAL;
888 goto out;
889
890 case SCF_ERROR_DELETED:
891 ret = ECANCELED;
892 goto out;
893
894 case SCF_ERROR_INVALID_ARGUMENT:
895 case SCF_ERROR_NOT_BOUND:
896 case SCF_ERROR_NOT_SET:
897 bad_error("scf_property_is_type", scf_error());
898 }
899 }
900
901 if (scf_property_get_value(prop, val) != 0) {
902 switch (scf_error()) {
903 case SCF_ERROR_CONNECTION_BROKEN:
904 default:
905 ret = ECONNABORTED;
906 goto out;
907
908 case SCF_ERROR_DELETED:
909 ret = ECANCELED;
910 goto out;
911
912 case SCF_ERROR_NOT_FOUND:
913 ret = ENOENT;
914 goto out;
915
916 case SCF_ERROR_CONSTRAINT_VIOLATED:
917 ret = EINVAL;
918 goto out;
919
920 case SCF_ERROR_PERMISSION_DENIED:
921 ret = EACCES;
922 goto out;
923
924 case SCF_ERROR_NOT_SET:
925 bad_error("scf_property_get_value", scf_error());
926 }
927 }
928
929 r = scf_value_get_count(val, valuep);
930 assert(r == 0);
931
932 out:
933 scf_value_destroy(val);
934 scf_property_destroy(prop);
935 return (ret);
936 }
937
938
939 static void
940 get_restarter(scf_handle_t *h, scf_propertygroup_t *pg, char **restarter)
941 {
942 scf_property_t *prop = safe_scf_property_create(h);
943
944 if (scf_pg_get_property(pg, SCF_PROPERTY_RESTARTER, prop) == -1 ||
945 libscf_read_single_astring(h, prop, restarter) != 0)
946 *restarter[0] = '\0';
947
948 scf_property_destroy(prop);
949 }
950
951 /*
952 * int libscf_instance_get_fmri(scf_instance_t *, char **)
953 * Give a valid SCF instance, return its FMRI. Returns 0 on success,
954 * ECONNABORTED, or ECANCELED if inst is deleted.
955 */
956 int
957 libscf_instance_get_fmri(scf_instance_t *inst, char **retp)
958 {
959 char *inst_fmri = startd_alloc(max_scf_fmri_size);
960
961 inst_fmri[0] = 0;
962 if (scf_instance_to_fmri(inst, inst_fmri, max_scf_fmri_size) <= 0) {
963 startd_free(inst_fmri, max_scf_fmri_size);
964 switch (scf_error()) {
965 case SCF_ERROR_CONNECTION_BROKEN:
966 default:
967 return (ECONNABORTED);
968
969 case SCF_ERROR_DELETED:
970 return (ECANCELED);
971
972 case SCF_ERROR_NOT_SET:
973 assert(0);
974 abort();
975 }
976 }
977
978 *retp = inst_fmri;
979 return (0);
980 }
981
982 /*
983 * int libscf_fmri_get_instance(scf_handle_t *, const char *,
984 * scf_instance_t **)
985 * Given a valid SCF handle and an FMRI, return the SCF instance that matches
986 * exactly. The instance must be released using scf_instance_destroy().
987 * Returns 0 on success, EINVAL if the FMRI is invalid, ENOTSUP if the FMRI
988 * is valid but designates something other than an instance, ECONNABORTED if
989 * the repository connection is broken, or ENOENT if the instance does not
990 * exist.
991 */
992 int
993 libscf_fmri_get_instance(scf_handle_t *h, const char *fmri,
994 scf_instance_t **instp)
995 {
996 scf_instance_t *inst;
997 int r;
998
999 inst = safe_scf_instance_create(h);
1000
1001 r = libscf_lookup_instance(fmri, inst);
1002
1003 if (r == 0)
1004 *instp = inst;
1005 else
1006 scf_instance_destroy(inst);
1007
1008 return (r);
1009 }
1010
1011 int
1012 libscf_lookup_instance(const char *fmri, scf_instance_t *inst)
1013 {
1014 if (scf_handle_decode_fmri(scf_instance_handle(inst), fmri, NULL, NULL,
1015 inst, NULL, NULL, SCF_DECODE_FMRI_EXACT) != SCF_SUCCESS) {
1016 switch (scf_error()) {
1017 case SCF_ERROR_INVALID_ARGUMENT:
1018 return (EINVAL);
1019
1020 case SCF_ERROR_CONSTRAINT_VIOLATED:
1021 return (ENOTSUP);
1022
1023 case SCF_ERROR_CONNECTION_BROKEN:
1024 return (ECONNABORTED);
1025
1026 case SCF_ERROR_NOT_FOUND:
1027 return (ENOENT);
1028
1029 case SCF_ERROR_HANDLE_MISMATCH:
1030 default:
1031 bad_error("scf_handle_decode_fmri", scf_error());
1032 }
1033 }
1034
1035 return (0);
1036 }
1037
1038 /*
1039 * int libscf_get_deathrow()
1040 * Read deathrow for inst. Returns 0, ECONNABORTED if the connection to the
1041 * repository is broken, ECANCELED if inst is deleted, or ENOENT if inst
1042 * has no deathrow property group.
1043 *
1044 * If deathrow/deathrow was missing or invalid, *deathrow will be -1 and a
1045 * debug message is logged.
1046 */
1047 int
1048 libscf_get_deathrow(scf_handle_t *h, scf_instance_t *inst, int *deathrow)
1049 {
1050 scf_propertygroup_t *pg;
1051 int r;
1052 uint8_t deathrow_8;
1053
1054 pg = safe_scf_pg_create(h);
1055
1056 if (scf_instance_get_pg_composed(inst, NULL, SCF_PG_DEATHROW, pg) !=
1057 0) {
1058 switch (scf_error()) {
1059 case SCF_ERROR_CONNECTION_BROKEN:
1060 default:
1061 scf_pg_destroy(pg);
1062 return (ECONNABORTED);
1063
1064 case SCF_ERROR_DELETED:
1065 scf_pg_destroy(pg);
1066 return (ECANCELED);
1067
1068 case SCF_ERROR_NOT_FOUND:
1069 *deathrow = -1;
1070 break;
1071
1072 case SCF_ERROR_HANDLE_MISMATCH:
1073 case SCF_ERROR_INVALID_ARGUMENT:
1074 case SCF_ERROR_NOT_SET:
1075 bad_error("libscf_get_deathrow", scf_error());
1076 }
1077 } else {
1078 switch (r = get_boolean(pg,
1079 SCF_PROPERTY_DEATHROW, &deathrow_8)) {
1080 case 0:
1081 *deathrow = deathrow_8;
1082 break;
1083
1084 case ECONNABORTED:
1085 case ECANCELED:
1086 scf_pg_destroy(pg);
1087 return (r);
1088
1089 case ENOENT:
1090 case EINVAL:
1091 *deathrow = -1;
1092 break;
1093
1094 default:
1095 bad_error("get_boolean", r);
1096 }
1097 }
1098
1099 scf_pg_destroy(pg);
1100
1101 return (0);
1102 }
1103
1104 /*
1105 * void libscf_get_basic_instance_data()
1106 * Read enabled, enabled_ovr, and restarter_fmri (into an allocated
1107 * buffer) for inst. Returns 0, ECONNABORTED if the connection to the
1108 * repository is broken, ECANCELED if inst is deleted, or ENOENT if inst
1109 * has no general property group.
1110 *
1111 * On success, restarter_fmri may be NULL. If general/enabled was missing
1112 * or invalid, *enabledp will be -1 and a debug message is logged.
1113 */
1114 int
1115 libscf_get_basic_instance_data(scf_handle_t *h, scf_instance_t *inst,
1116 const char *fmri, int *enabledp, int *enabled_ovrp, char **restarter_fmri)
1117 {
1118 scf_propertygroup_t *pg;
1119 int r;
1120 uint8_t enabled_8;
1121
1122 pg = safe_scf_pg_create(h);
1123
1124 if (enabled_ovrp == NULL)
1125 goto enabled;
1126
1127 if (scf_instance_get_pg_composed(inst, NULL, SCF_PG_GENERAL_OVR, pg) !=
1128 0) {
1129 switch (scf_error()) {
1130 case SCF_ERROR_CONNECTION_BROKEN:
1131 default:
1132 scf_pg_destroy(pg);
1133 return (ECONNABORTED);
1134
1135 case SCF_ERROR_DELETED:
1136 scf_pg_destroy(pg);
1137 return (ECANCELED);
1138
1139 case SCF_ERROR_NOT_FOUND:
1140 *enabled_ovrp = -1;
1141 break;
1142
1143 case SCF_ERROR_HANDLE_MISMATCH:
1144 case SCF_ERROR_INVALID_ARGUMENT:
1145 case SCF_ERROR_NOT_SET:
1146 bad_error("scf_instance_get_pg_composed", scf_error());
1147 }
1148 } else {
1149 switch (r = get_boolean(pg, SCF_PROPERTY_ENABLED, &enabled_8)) {
1150 case 0:
1151 *enabled_ovrp = enabled_8;
1152 break;
1153
1154 case ECONNABORTED:
1155 case ECANCELED:
1156 scf_pg_destroy(pg);
1157 return (r);
1158
1159 case ENOENT:
1160 case EINVAL:
1161 *enabled_ovrp = -1;
1162 break;
1163
1164 case EACCES:
1165 default:
1166 bad_error("get_boolean", r);
1167 }
1168 }
1169
1170 enabled:
1171 /*
1172 * Since general/restarter can be at the service level, we must do
1173 * a composed lookup. These properties are immediate, though, so we
1174 * must use the "editing" snapshot. Technically enabled shouldn't be
1175 * at the service level, but looking it up composed, too, doesn't
1176 * hurt.
1177 */
1178 if (scf_instance_get_pg_composed(inst, NULL, SCF_PG_GENERAL, pg) != 0) {
1179 scf_pg_destroy(pg);
1180 switch (scf_error()) {
1181 case SCF_ERROR_CONNECTION_BROKEN:
1182 default:
1183 return (ECONNABORTED);
1184
1185 case SCF_ERROR_DELETED:
1186 return (ECANCELED);
1187
1188 case SCF_ERROR_NOT_FOUND:
1189 return (ENOENT);
1190
1191 case SCF_ERROR_NOT_SET:
1192 bad_error("scf_instance_get_pg_composed", scf_error());
1193 }
1194 }
1195
1196 switch (r = get_boolean(pg, SCF_PROPERTY_ENABLED, &enabled_8)) {
1197 case 0:
1198 *enabledp = enabled_8;
1199 break;
1200
1201 case ECONNABORTED:
1202 case ECANCELED:
1203 scf_pg_destroy(pg);
1204 return (r);
1205
1206 case ENOENT:
1207 /*
1208 * DEBUG because this happens when svccfg import creates
1209 * a temporary service.
1210 */
1211 log_framework(LOG_DEBUG,
1212 "general/enabled property of %s is missing.\n", fmri);
1213 *enabledp = -1;
1214 break;
1215
1216 case EINVAL:
1217 log_framework(LOG_ERR,
1218 "general/enabled property of %s is invalid.\n", fmri);
1219 *enabledp = -1;
1220 break;
1221
1222 case EACCES:
1223 default:
1224 bad_error("get_boolean", r);
1225 }
1226
1227 if (restarter_fmri != NULL)
1228 get_restarter(h, pg, restarter_fmri);
1229
1230 scf_pg_destroy(pg);
1231
1232 return (0);
1233 }
1234
1235 /*
1236 * Sets pg to the name property group of s_inst. If it doesn't exist, it is
1237 * added.
1238 *
1239 * Fails with
1240 * ECONNABORTED - repository disconnection or unknown libscf error
1241 * ECANCELED - inst is deleted
1242 * EPERM - permission is denied
1243 * EACCES - backend denied access
1244 * EROFS - backend readonly
1245 */
1246 int
1247 libscf_inst_get_or_add_pg(scf_instance_t *inst, const char *name,
1248 const char *type, uint32_t flags, scf_propertygroup_t *pg)
1249 {
1250 uint32_t f;
1251
1252 again:
1253 if (scf_instance_get_pg(inst, name, pg) == 0) {
1254 if (scf_pg_get_flags(pg, &f) != 0) {
1255 switch (scf_error()) {
1256 case SCF_ERROR_CONNECTION_BROKEN:
1257 default:
1258 return (ECONNABORTED);
1259
1260 case SCF_ERROR_DELETED:
1261 goto add;
1262
1263 case SCF_ERROR_NOT_SET:
1264 bad_error("scf_pg_get_flags", scf_error());
1265 }
1266 }
1267
1268 if (f == flags)
1269 return (0);
1270
1271 if (scf_pg_delete(pg) != 0) {
1272 switch (scf_error()) {
1273 case SCF_ERROR_CONNECTION_BROKEN:
1274 default:
1275 return (ECONNABORTED);
1276
1277 case SCF_ERROR_DELETED:
1278 break;
1279
1280 case SCF_ERROR_PERMISSION_DENIED:
1281 return (EPERM);
1282
1283 case SCF_ERROR_BACKEND_ACCESS:
1284 return (EACCES);
1285
1286 case SCF_ERROR_BACKEND_READONLY:
1287 return (EROFS);
1288
1289 case SCF_ERROR_NOT_SET:
1290 bad_error("scf_pg_delete", scf_error());
1291 }
1292 }
1293 } else {
1294 switch (scf_error()) {
1295 case SCF_ERROR_CONNECTION_BROKEN:
1296 default:
1297 return (ECONNABORTED);
1298
1299 case SCF_ERROR_DELETED:
1300 return (ECANCELED);
1301
1302 case SCF_ERROR_NOT_FOUND:
1303 break;
1304
1305 case SCF_ERROR_HANDLE_MISMATCH:
1306 case SCF_ERROR_INVALID_ARGUMENT:
1307 case SCF_ERROR_NOT_SET:
1308 bad_error("scf_instance_get_pg", scf_error());
1309 }
1310 }
1311
1312 add:
1313 if (scf_instance_add_pg(inst, name, type, flags, pg) == 0)
1314 return (0);
1315
1316 switch (scf_error()) {
1317 case SCF_ERROR_CONNECTION_BROKEN:
1318 default:
1319 return (ECONNABORTED);
1320
1321 case SCF_ERROR_DELETED:
1322 return (ECANCELED);
1323
1324 case SCF_ERROR_EXISTS:
1325 goto again;
1326
1327 case SCF_ERROR_PERMISSION_DENIED:
1328 return (EPERM);
1329
1330 case SCF_ERROR_BACKEND_ACCESS:
1331 return (EACCES);
1332
1333 case SCF_ERROR_BACKEND_READONLY:
1334 return (EROFS);
1335
1336 case SCF_ERROR_HANDLE_MISMATCH:
1337 case SCF_ERROR_INVALID_ARGUMENT:
1338 case SCF_ERROR_NOT_SET:
1339 bad_error("scf_instance_add_pg", scf_error());
1340 /* NOTREACHED */
1341 }
1342 }
1343
1344 /*
1345 * Returns
1346 * 0 - success
1347 * ECONNABORTED - repository connection broken
1348 * - unknown libscf error
1349 * ECANCELED
1350 */
1351 static scf_error_t
1352 transaction_add_set(scf_transaction_t *tx, scf_transaction_entry_t *ent,
1353 const char *pname, scf_type_t ty)
1354 {
1355 for (;;) {
1356 if (scf_transaction_property_change_type(tx, ent, pname,
1357 ty) == 0)
1358 return (0);
1359
1360 switch (scf_error()) {
1361 case SCF_ERROR_CONNECTION_BROKEN:
1362 default:
1363 return (ECONNABORTED);
1364
1365 case SCF_ERROR_DELETED:
1366 return (ECANCELED);
1367
1368 case SCF_ERROR_NOT_FOUND:
1369 break;
1370
1371 case SCF_ERROR_HANDLE_MISMATCH:
1372 case SCF_ERROR_INVALID_ARGUMENT:
1373 case SCF_ERROR_IN_USE:
1374 case SCF_ERROR_NOT_SET:
1375 bad_error("scf_transaction_property_change_type",
1376 scf_error());
1377 }
1378
1379 if (scf_transaction_property_new(tx, ent, pname, ty) == 0)
1380 return (0);
1381
1382 switch (scf_error()) {
1383 case SCF_ERROR_CONNECTION_BROKEN:
1384 default:
1385 return (ECONNABORTED);
1386
1387 case SCF_ERROR_DELETED:
1388 return (ECANCELED);
1389
1390 case SCF_ERROR_EXISTS:
1391 break;
1392
1393 case SCF_ERROR_HANDLE_MISMATCH:
1394 case SCF_ERROR_INVALID_ARGUMENT:
1395 case SCF_ERROR_IN_USE:
1396 case SCF_ERROR_NOT_SET:
1397 bad_error("scf_transaction_property_new", scf_error());
1398 /* NOTREACHED */
1399 }
1400 }
1401 }
1402
1403 /*
1404 * Returns
1405 * 0 - success
1406 * ECONNABORTED - repository connection broken
1407 * - unknown libscf error
1408 * ECANCELED - pg was deleted
1409 * EPERM
1410 * EACCES
1411 * EROFS
1412 */
1413 static int
1414 pg_set_prop_value(scf_propertygroup_t *pg, const char *pname, scf_value_t *v)
1415 {
1416 scf_handle_t *h;
1417 scf_transaction_t *tx;
1418 scf_transaction_entry_t *e;
1419 scf_type_t ty;
1420 scf_error_t scfe;
1421 int ret, r;
1422
1423 h = scf_pg_handle(pg);
1424 tx = safe_scf_transaction_create(h);
1425 e = safe_scf_entry_create(h);
1426
1427 ty = scf_value_type(v);
1428 assert(ty != SCF_TYPE_INVALID);
1429
1430 for (;;) {
1431 if (scf_transaction_start(tx, pg) != 0) {
1432 switch (scf_error()) {
1433 case SCF_ERROR_CONNECTION_BROKEN:
1434 default:
1435 ret = ECONNABORTED;
1436 goto out;
1437
1438 case SCF_ERROR_DELETED:
1439 ret = ECANCELED;
1440 goto out;
1441
1442 case SCF_ERROR_PERMISSION_DENIED:
1443 ret = EPERM;
1444 goto out;
1445
1446 case SCF_ERROR_BACKEND_ACCESS:
1447 ret = EACCES;
1448 goto out;
1449
1450 case SCF_ERROR_BACKEND_READONLY:
1451 ret = EROFS;
1452 goto out;
1453
1454 case SCF_ERROR_NOT_SET:
1455 bad_error("scf_transaction_start", ret);
1456 }
1457 }
1458
1459 ret = transaction_add_set(tx, e, pname, ty);
1460 switch (ret) {
1461 case 0:
1462 break;
1463
1464 case ECONNABORTED:
1465 case ECANCELED:
1466 goto out;
1467
1468 default:
1469 bad_error("transaction_add_set", ret);
1470 }
1471
1472 r = scf_entry_add_value(e, v);
1473 assert(r == 0);
1474
1475 r = scf_transaction_commit(tx);
1476 if (r == 1)
1477 break;
1478 if (r != 0) {
1479 scfe = scf_error();
1480 scf_transaction_reset(tx);
1481 switch (scfe) {
1482 case SCF_ERROR_CONNECTION_BROKEN:
1483 default:
1484 ret = ECONNABORTED;
1485 goto out;
1486
1487 case SCF_ERROR_DELETED:
1488 ret = ECANCELED;
1489 goto out;
1490
1491 case SCF_ERROR_PERMISSION_DENIED:
1492 ret = EPERM;
1493 goto out;
1494
1495 case SCF_ERROR_BACKEND_ACCESS:
1496 ret = EACCES;
1497 goto out;
1498
1499 case SCF_ERROR_BACKEND_READONLY:
1500 ret = EROFS;
1501 goto out;
1502
1503 case SCF_ERROR_NOT_SET:
1504 bad_error("scf_transaction_commit", scfe);
1505 }
1506 }
1507
1508 scf_transaction_reset(tx);
1509
1510 if (scf_pg_update(pg) == -1) {
1511 switch (scf_error()) {
1512 case SCF_ERROR_CONNECTION_BROKEN:
1513 default:
1514 ret = ECONNABORTED;
1515 goto out;
1516
1517 case SCF_ERROR_DELETED:
1518 ret = ECANCELED;
1519 goto out;
1520
1521 case SCF_ERROR_NOT_SET:
1522 bad_error("scf_pg_update", scf_error());
1523 }
1524 }
1525 }
1526
1527 ret = 0;
1528
1529 out:
1530 scf_transaction_destroy(tx);
1531 scf_entry_destroy(e);
1532 return (ret);
1533 }
1534
1535 /*
1536 * Returns
1537 * 0 - success
1538 * ECONNABORTED - repository connection broken
1539 * - unknown libscf error
1540 * ECANCELED - inst was deleted
1541 * EPERM
1542 * EACCES
1543 * EROFS
1544 */
1545 int
1546 libscf_inst_set_boolean_prop(scf_instance_t *inst, const char *pgname,
1547 const char *pgtype, uint32_t pgflags, const char *pname, int val)
1548 {
1549 scf_handle_t *h;
1550 scf_propertygroup_t *pg = NULL;
1551 scf_value_t *v;
1552 int ret = 0;
1553
1554 h = scf_instance_handle(inst);
1555 pg = safe_scf_pg_create(h);
1556 v = safe_scf_value_create(h);
1557
1558 ret = libscf_inst_get_or_add_pg(inst, pgname, pgtype, pgflags, pg);
1559 switch (ret) {
1560 case 0:
1561 break;
1562
1563 case ECONNABORTED:
1564 case ECANCELED:
1565 case EPERM:
1566 case EACCES:
1567 case EROFS:
1568 goto out;
1569
1570 default:
1571 bad_error("libscf_inst_get_or_add_pg", ret);
1572 }
1573
1574 scf_value_set_boolean(v, val);
1575
1576 ret = pg_set_prop_value(pg, pname, v);
1577 switch (ret) {
1578 case 0:
1579 case ECONNABORTED:
1580 case ECANCELED:
1581 case EPERM:
1582 case EACCES:
1583 case EROFS:
1584 break;
1585
1586 default:
1587 bad_error("pg_set_prop_value", ret);
1588 }
1589
1590 out:
1591 scf_pg_destroy(pg);
1592 scf_value_destroy(v);
1593 return (ret);
1594 }
1595
1596 /*
1597 * Returns
1598 * 0 - success
1599 * ECONNABORTED - repository connection broken
1600 * - unknown libscf error
1601 * ECANCELED - inst was deleted
1602 * EPERM
1603 * EACCES
1604 * EROFS
1605 */
1606 int
1607 libscf_inst_set_count_prop(scf_instance_t *inst, const char *pgname,
1608 const char *pgtype, uint32_t pgflags, const char *pname, uint64_t count)
1609 {
1610 scf_handle_t *h;
1611 scf_propertygroup_t *pg = NULL;
1612 scf_value_t *v;
1613 int ret = 0;
1614
1615 h = scf_instance_handle(inst);
1616 pg = safe_scf_pg_create(h);
1617 v = safe_scf_value_create(h);
1618
1619 ret = libscf_inst_get_or_add_pg(inst, pgname, pgtype, pgflags, pg);
1620 switch (ret) {
1621 case 0:
1622 break;
1623
1624 case ECONNABORTED:
1625 case ECANCELED:
1626 case EPERM:
1627 case EACCES:
1628 case EROFS:
1629 goto out;
1630
1631 default:
1632 bad_error("libscf_inst_get_or_add_pg", ret);
1633 }
1634
1635 scf_value_set_count(v, count);
1636
1637 ret = pg_set_prop_value(pg, pname, v);
1638 switch (ret) {
1639 case 0:
1640 case ECONNABORTED:
1641 case ECANCELED:
1642 case EPERM:
1643 case EACCES:
1644 case EROFS:
1645 break;
1646
1647 default:
1648 bad_error("pg_set_prop_value", ret);
1649 }
1650
1651 out:
1652 scf_pg_destroy(pg);
1653 scf_value_destroy(v);
1654 return (ret);
1655 }
1656
1657 /*
1658 * Returns 0 on success, ECONNABORTED if the repository connection is broken,
1659 * ECANCELED if inst is deleted, EROFS if the backend is readonly, or EPERM if
1660 * permission was denied.
1661 */
1662 int
1663 libscf_set_enable_ovr(scf_instance_t *inst, int enable)
1664 {
1665 return (libscf_inst_set_boolean_prop(inst, SCF_PG_GENERAL_OVR,
1666 SCF_PG_GENERAL_OVR_TYPE, SCF_PG_GENERAL_OVR_FLAGS,
1667 SCF_PROPERTY_ENABLED, enable));
1668 }
1669
1670 /*
1671 * Returns 0 on success, ECONNABORTED if the repository connection is broken,
1672 * ECANCELED if inst is deleted, EROFS if the backend is readonly, or EPERM if
1673 * permission was denied.
1674 */
1675 int
1676 libscf_set_deathrow(scf_instance_t *inst, int deathrow)
1677 {
1678 return (libscf_inst_set_boolean_prop(inst, SCF_PG_DEATHROW,
1679 SCF_PG_DEATHROW_TYPE, SCF_PG_DEATHROW_FLAGS,
1680 SCF_PROPERTY_DEATHROW, deathrow));
1681 }
1682
1683 /*
1684 * Returns 0, ECONNABORTED, ECANCELED, or EPERM.
1685 */
1686 int
1687 libscf_delete_enable_ovr(scf_instance_t *inst)
1688 {
1689 return (scf_instance_delete_prop(inst, SCF_PG_GENERAL_OVR,
1690 SCF_PROPERTY_ENABLED));
1691 }
1692
1693 /*
1694 * Fails with
1695 * ECONNABORTED - repository connection was broken
1696 * ECANCELED - pg was deleted
1697 * ENOENT - pg has no milestone property
1698 * EINVAL - the milestone property is misconfigured
1699 */
1700 static int
1701 pg_get_milestone(scf_propertygroup_t *pg, scf_property_t *prop,
1702 scf_value_t *val, char *buf, size_t buf_sz)
1703 {
1704 if (scf_pg_get_property(pg, SCF_PROPERTY_MILESTONE, prop) != 0) {
1705 switch (scf_error()) {
1706 case SCF_ERROR_CONNECTION_BROKEN:
1707 default:
1708 return (ECONNABORTED);
1709
1710 case SCF_ERROR_DELETED:
1711 return (ECANCELED);
1712
1713 case SCF_ERROR_NOT_FOUND:
1714 return (ENOENT);
1715
1716 case SCF_ERROR_HANDLE_MISMATCH:
1717 case SCF_ERROR_INVALID_ARGUMENT:
1718 case SCF_ERROR_NOT_SET:
1719 bad_error("scf_pg_get_property", scf_error());
1720 }
1721 }
1722
1723 if (scf_property_get_value(prop, val) != 0) {
1724 switch (scf_error()) {
1725 case SCF_ERROR_CONNECTION_BROKEN:
1726 default:
1727 return (ECONNABORTED);
1728
1729 case SCF_ERROR_DELETED:
1730 case SCF_ERROR_CONSTRAINT_VIOLATED:
1731 case SCF_ERROR_NOT_FOUND:
1732 return (EINVAL);
1733
1734 case SCF_ERROR_NOT_SET:
1735 case SCF_ERROR_PERMISSION_DENIED:
1736 bad_error("scf_property_get_value", scf_error());
1737 }
1738 }
1739
1740 if (scf_value_get_astring(val, buf, buf_sz) < 0) {
1741 switch (scf_error()) {
1742 case SCF_ERROR_TYPE_MISMATCH:
1743 return (EINVAL);
1744
1745 case SCF_ERROR_NOT_SET:
1746 default:
1747 bad_error("scf_value_get_astring", scf_error());
1748 }
1749 }
1750
1751 return (0);
1752 }
1753
1754 /*
1755 * Fails with
1756 * ECONNABORTED - repository connection was broken
1757 * ECANCELED - inst was deleted
1758 * ENOENT - inst has no milestone property
1759 * EINVAL - the milestone property is misconfigured
1760 */
1761 int
1762 libscf_get_milestone(scf_instance_t *inst, scf_property_t *prop,
1763 scf_value_t *val, char *buf, size_t buf_sz)
1764 {
1765 scf_propertygroup_t *pg;
1766 int r;
1767
1768 pg = safe_scf_pg_create(scf_instance_handle(inst));
1769
1770 if (scf_instance_get_pg(inst, SCF_PG_OPTIONS_OVR, pg) == 0) {
1771 switch (r = pg_get_milestone(pg, prop, val, buf, buf_sz)) {
1772 case 0:
1773 case ECONNABORTED:
1774 case EINVAL:
1775 goto out;
1776
1777 case ECANCELED:
1778 case ENOENT:
1779 break;
1780
1781 default:
1782 bad_error("pg_get_milestone", r);
1783 }
1784 } else {
1785 switch (scf_error()) {
1786 case SCF_ERROR_CONNECTION_BROKEN:
1787 default:
1788 r = ECONNABORTED;
1789 goto out;
1790
1791 case SCF_ERROR_DELETED:
1792 r = ECANCELED;
1793 goto out;
1794
1795 case SCF_ERROR_NOT_FOUND:
1796 break;
1797
1798 case SCF_ERROR_HANDLE_MISMATCH:
1799 case SCF_ERROR_INVALID_ARGUMENT:
1800 case SCF_ERROR_NOT_SET:
1801 bad_error("scf_instance_get_pg", scf_error());
1802 }
1803 }
1804
1805 if (scf_instance_get_pg(inst, SCF_PG_OPTIONS, pg) == 0) {
1806 r = pg_get_milestone(pg, prop, val, buf, buf_sz);
1807 } else {
1808 switch (scf_error()) {
1809 case SCF_ERROR_CONNECTION_BROKEN:
1810 default:
1811 r = ECONNABORTED;
1812 goto out;
1813
1814 case SCF_ERROR_DELETED:
1815 r = ECANCELED;
1816 goto out;
1817
1818 case SCF_ERROR_NOT_FOUND:
1819 r = ENOENT;
1820 break;
1821
1822 case SCF_ERROR_HANDLE_MISMATCH:
1823 case SCF_ERROR_INVALID_ARGUMENT:
1824 case SCF_ERROR_NOT_SET:
1825 bad_error("scf_instance_get_pg", scf_error());
1826 }
1827 }
1828
1829 out:
1830 scf_pg_destroy(pg);
1831
1832 return (r);
1833 }
1834
1835 /*
1836 * Get the runlevel character from the runlevel property of the given property
1837 * group. Fails with
1838 * ECONNABORTED - repository connection was broken
1839 * ECANCELED - prop's property group was deleted
1840 * ENOENT - the property has no values
1841 * EINVAL - the property has more than one value
1842 * the property is of the wrong type
1843 * the property value is malformed
1844 */
1845 int
1846 libscf_extract_runlevel(scf_property_t *prop, char *rlp)
1847 {
1848 scf_value_t *val;
1849 char buf[2];
1850
1851 val = safe_scf_value_create(scf_property_handle(prop));
1852
1853 if (scf_property_get_value(prop, val) != 0) {
1854 scf_value_destroy(val);
1855 switch (scf_error()) {
1856 case SCF_ERROR_CONNECTION_BROKEN:
1857 return (ECONNABORTED);
1858
1859 case SCF_ERROR_NOT_SET:
1860 return (ENOENT);
1861
1862 case SCF_ERROR_DELETED:
1863 return (ECANCELED);
1864
1865 case SCF_ERROR_CONSTRAINT_VIOLATED:
1866 return (EINVAL);
1867
1868 case SCF_ERROR_NOT_FOUND:
1869 return (ENOENT);
1870
1871 case SCF_ERROR_HANDLE_MISMATCH:
1872 case SCF_ERROR_NOT_BOUND:
1873 case SCF_ERROR_PERMISSION_DENIED:
1874 default:
1875 bad_error("scf_property_get_value", scf_error());
1876 }
1877 }
1878
1879 if (scf_value_get_astring(val, buf, sizeof (buf)) < 0) {
1880 scf_value_destroy(val);
1881 if (scf_error() != SCF_ERROR_TYPE_MISMATCH)
1882 bad_error("scf_value_get_astring", scf_error());
1883
1884 return (EINVAL);
1885 }
1886
1887 scf_value_destroy(val);
1888
1889 if (buf[0] == '\0' || buf[1] != '\0')
1890 return (EINVAL);
1891
1892 *rlp = buf[0];
1893
1894 return (0);
1895 }
1896
1897 /*
1898 * Delete the "runlevel" property from the given property group. Also set the
1899 * "milestone" property to the given string. Fails with ECONNABORTED,
1900 * ECANCELED, EPERM, EACCES, or EROFS.
1901 */
1902 int
1903 libscf_clear_runlevel(scf_propertygroup_t *pg, const char *milestone)
1904 {
1905 scf_handle_t *h;
1906 scf_transaction_t *tx;
1907 scf_transaction_entry_t *e_rl, *e_ms;
1908 scf_value_t *val;
1909 scf_error_t serr;
1910 boolean_t isempty = B_TRUE;
1911 int ret = 0, r;
1912
1913 h = scf_pg_handle(pg);
1914 tx = safe_scf_transaction_create(h);
1915 e_rl = safe_scf_entry_create(h);
1916 e_ms = safe_scf_entry_create(h);
1917 val = safe_scf_value_create(h);
1918
1919 if (milestone) {
1920 r = scf_value_set_astring(val, milestone);
1921 assert(r == 0);
1922 }
1923
1924 for (;;) {
1925 if (scf_transaction_start(tx, pg) != 0) {
1926 switch (scf_error()) {
1927 case SCF_ERROR_CONNECTION_BROKEN:
1928 default:
1929 ret = ECONNABORTED;
1930 goto out;
1931
1932 case SCF_ERROR_DELETED:
1933 ret = ECANCELED;
1934 goto out;
1935
1936 case SCF_ERROR_PERMISSION_DENIED:
1937 ret = EPERM;
1938 goto out;
1939
1940 case SCF_ERROR_BACKEND_ACCESS:
1941 ret = EACCES;
1942 goto out;
1943
1944 case SCF_ERROR_BACKEND_READONLY:
1945 ret = EROFS;
1946 goto out;
1947
1948 case SCF_ERROR_NOT_SET:
1949 bad_error("scf_transaction_start", scf_error());
1950 }
1951 }
1952
1953 if (scf_transaction_property_delete(tx, e_rl,
1954 "runlevel") == 0) {
1955 isempty = B_FALSE;
1956 } else {
1957 switch (scf_error()) {
1958 case SCF_ERROR_CONNECTION_BROKEN:
1959 default:
1960 ret = ECONNABORTED;
1961 goto out;
1962
1963 case SCF_ERROR_DELETED:
1964 ret = ECANCELED;
1965 goto out;
1966
1967 case SCF_ERROR_NOT_FOUND:
1968 break;
1969
1970 case SCF_ERROR_HANDLE_MISMATCH:
1971 case SCF_ERROR_NOT_BOUND:
1972 case SCF_ERROR_INVALID_ARGUMENT:
1973 bad_error("scf_transaction_property_delete",
1974 scf_error());
1975 }
1976 }
1977
1978 if (milestone) {
1979 ret = transaction_add_set(tx, e_ms,
1980 SCF_PROPERTY_MILESTONE, SCF_TYPE_ASTRING);
1981 switch (ret) {
1982 case 0:
1983 break;
1984
1985 case ECONNABORTED:
1986 case ECANCELED:
1987 goto out;
1988
1989 default:
1990 bad_error("transaction_add_set", ret);
1991 }
1992
1993 isempty = B_FALSE;
1994
1995 r = scf_entry_add_value(e_ms, val);
1996 assert(r == 0);
1997 }
1998
1999 if (isempty)
2000 goto out;
2001
2002 r = scf_transaction_commit(tx);
2003 if (r == 1)
2004 break;
2005 if (r != 0) {
2006 serr = scf_error();
2007 scf_transaction_reset(tx);
2008 switch (serr) {
2009 case SCF_ERROR_CONNECTION_BROKEN:
2010 ret = ECONNABORTED;
2011 goto out;
2012
2013 case SCF_ERROR_PERMISSION_DENIED:
2014 ret = EPERM;
2015 goto out;
2016
2017 case SCF_ERROR_BACKEND_ACCESS:
2018 ret = EACCES;
2019 goto out;
2020
2021 case SCF_ERROR_BACKEND_READONLY:
2022 ret = EROFS;
2023 goto out;
2024
2025 default:
2026 bad_error("scf_transaction_commit", serr);
2027 }
2028 }
2029
2030 scf_transaction_reset(tx);
2031
2032 if (scf_pg_update(pg) == -1) {
2033 switch (scf_error()) {
2034 case SCF_ERROR_CONNECTION_BROKEN:
2035 ret = ECONNABORTED;
2036 goto out;
2037
2038 case SCF_ERROR_NOT_SET:
2039 ret = ECANCELED;
2040 goto out;
2041
2042 default:
2043 assert(0);
2044 abort();
2045 }
2046 }
2047 }
2048
2049 out:
2050 scf_transaction_destroy(tx);
2051 scf_entry_destroy(e_rl);
2052 scf_entry_destroy(e_ms);
2053 scf_value_destroy(val);
2054 return (ret);
2055 }
2056
2057 /*
2058 * int libscf_get_template_values(scf_instance_t *, scf_snapshot_t *,
2059 * char **)
2060 *
2061 * Return template values for inst in *common_name suitable for use in
2062 * restarter_inst_t->ri_common_name. Called by restarter_insert_inst().
2063 *
2064 * Returns 0 on success, ECANCELED if the instance is deleted, ECHILD if
2065 * a value fetch failed for a property, ENOENT if the instance has no
2066 * tm_common_name property group or the property group is deleted, and
2067 * ECONNABORTED if the repository connection is broken.
2068 */
2069 int
2070 libscf_get_template_values(scf_instance_t *inst, scf_snapshot_t *snap,
2071 char **common_name, char **c_common_name)
2072 {
2073 scf_handle_t *h;
2074 scf_propertygroup_t *pg = NULL;
2075 scf_property_t *prop = NULL;
2076 int ret = 0, r;
2077 char *cname = startd_alloc(max_scf_value_size);
2078 char *c_cname = startd_alloc(max_scf_value_size);
2079 int common_name_initialized = B_FALSE;
2080 int c_common_name_initialized = B_FALSE;
2081
2082 h = scf_instance_handle(inst);
2083 pg = safe_scf_pg_create(h);
2084 prop = safe_scf_property_create(h);
2085
2086 /*
2087 * The tm_common_name property group, as with all template property
2088 * groups, is optional.
2089 */
2090 if (scf_instance_get_pg_composed(inst, snap, SCF_PG_TM_COMMON_NAME, pg)
2091 == -1) {
2092 switch (scf_error()) {
2093 case SCF_ERROR_DELETED:
2094 ret = ECANCELED;
2095 goto template_values_out;
2096
2097 case SCF_ERROR_NOT_FOUND:
2098 goto template_values_out;
2099
2100 case SCF_ERROR_CONNECTION_BROKEN:
2101 default:
2102 ret = ECONNABORTED;
2103 goto template_values_out;
2104
2105 case SCF_ERROR_INVALID_ARGUMENT:
2106 case SCF_ERROR_HANDLE_MISMATCH:
2107 case SCF_ERROR_NOT_SET:
2108 bad_error("scf_instance_get_pg_composed", scf_error());
2109 }
2110 }
2111
2112 /*
2113 * The name we wish uses the current locale name as the property name.
2114 */
2115 if (st->st_locale != NULL) {
2116 if (scf_pg_get_property(pg, st->st_locale, prop) == -1) {
2117 switch (scf_error()) {
2118 case SCF_ERROR_DELETED:
2119 case SCF_ERROR_NOT_FOUND:
2120 break;
2121
2122 case SCF_ERROR_CONNECTION_BROKEN:
2123 default:
2124 ret = ECONNABORTED;
2125 goto template_values_out;
2126
2127 case SCF_ERROR_INVALID_ARGUMENT:
2128 case SCF_ERROR_HANDLE_MISMATCH:
2129 case SCF_ERROR_NOT_SET:
2130 bad_error("scf_pg_get_property", scf_error());
2131 }
2132 } else {
2133 if ((r = libscf_read_single_astring(h, prop, &cname)) !=
2134 0) {
2135 if (r != LIBSCF_PROPERTY_ABSENT)
2136 ret = ECHILD;
2137 goto template_values_out;
2138 }
2139
2140 *common_name = cname;
2141 common_name_initialized = B_TRUE;
2142 }
2143 }
2144
2145 /*
2146 * Also pull out the C locale name, as a fallback for the case where
2147 * service offers no localized name.
2148 */
2149 if (scf_pg_get_property(pg, "C", prop) == -1) {
2150 switch (scf_error()) {
2151 case SCF_ERROR_DELETED:
2152 ret = ENOENT;
2153 goto template_values_out;
2154
2155 case SCF_ERROR_NOT_FOUND:
2156 break;
2157
2158 case SCF_ERROR_CONNECTION_BROKEN:
2159 default:
2160 ret = ECONNABORTED;
2161 goto template_values_out;
2162
2163 case SCF_ERROR_INVALID_ARGUMENT:
2164 case SCF_ERROR_HANDLE_MISMATCH:
2165 case SCF_ERROR_NOT_SET:
2166 bad_error("scf_pg_get_property", scf_error());
2167 }
2168 } else {
2169 if ((r = libscf_read_single_astring(h, prop, &c_cname)) != 0) {
2170 if (r != LIBSCF_PROPERTY_ABSENT)
2171 ret = ECHILD;
2172 goto template_values_out;
2173 }
2174
2175 *c_common_name = c_cname;
2176 c_common_name_initialized = B_TRUE;
2177 }
2178
2179
2180 template_values_out:
2181 if (common_name_initialized == B_FALSE)
2182 startd_free(cname, max_scf_value_size);
2183 if (c_common_name_initialized == B_FALSE)
2184 startd_free(c_cname, max_scf_value_size);
2185 scf_property_destroy(prop);
2186 scf_pg_destroy(pg);
2187
2188 return (ret);
2189 }
2190
2191 /*
2192 * int libscf_get_startd_properties(scf_handle_t *, scf_instance_t *,
2193 * scf_snapshot_t *, uint_t *, char **)
2194 *
2195 * Return startd settings for inst in *flags suitable for use in
2196 * restarter_inst_t->ri_flags. Called by restarter_insert_inst().
2197 *
2198 * Returns 0 on success, ECANCELED if the instance is deleted, ECHILD if
2199 * a value fetch failed for a property, ENOENT if the instance has no
2200 * general property group or the property group is deleted, and
2201 * ECONNABORTED if the repository connection is broken.
2202 */
2203 int
2204 libscf_get_startd_properties(scf_instance_t *inst,
2205 scf_snapshot_t *snap, uint_t *flags, char **prefixp)
2206 {
2207 scf_handle_t *h;
2208 scf_propertygroup_t *pg = NULL;
2209 scf_property_t *prop = NULL;
2210 int style = RINST_CONTRACT;
2211 char *style_str = startd_alloc(max_scf_value_size);
2212 int ret = 0, r;
2213
2214 h = scf_instance_handle(inst);
2215 pg = safe_scf_pg_create(h);
2216 prop = safe_scf_property_create(h);
2217
2218 /*
2219 * The startd property group is optional.
2220 */
2221 if (scf_instance_get_pg_composed(inst, snap, SCF_PG_STARTD, pg) == -1) {
2222 switch (scf_error()) {
2223 case SCF_ERROR_DELETED:
2224 ret = ECANCELED;
2225 goto instance_flags_out;
2226
2227 case SCF_ERROR_NOT_FOUND:
2228 ret = ENOENT;
2229 goto instance_flags_out;
2230
2231 case SCF_ERROR_CONNECTION_BROKEN:
2232 default:
2233 ret = ECONNABORTED;
2234 goto instance_flags_out;
2235
2236 case SCF_ERROR_INVALID_ARGUMENT:
2237 case SCF_ERROR_HANDLE_MISMATCH:
2238 case SCF_ERROR_NOT_SET:
2239 bad_error("scf_instance_get_pg_composed", scf_error());
2240 }
2241 }
2242
2243 /*
2244 * 1. Duration property.
2245 */
2246 if (scf_pg_get_property(pg, SCF_PROPERTY_DURATION, prop) == -1) {
2247 switch (scf_error()) {
2248 case SCF_ERROR_DELETED:
2249 ret = ENOENT;
2250 goto instance_flags_out;
2251
2252 case SCF_ERROR_NOT_FOUND:
2253 break;
2254
2255 case SCF_ERROR_CONNECTION_BROKEN:
2256 default:
2257 ret = ECONNABORTED;
2258 goto instance_flags_out;
2259
2260 case SCF_ERROR_INVALID_ARGUMENT:
2261 case SCF_ERROR_HANDLE_MISMATCH:
2262 case SCF_ERROR_NOT_SET:
2263 bad_error("scf_pg_get_property", scf_error());
2264 }
2265 } else {
2266 errno = 0;
2267 if ((r = libscf_read_single_astring(h, prop, &style_str))
2268 != 0) {
2269 if (r != LIBSCF_PROPERTY_ABSENT)
2270 ret = ECHILD;
2271 goto instance_flags_out;
2272 }
2273
2274 if (strcmp(style_str, "child") == 0)
2275 style = RINST_WAIT;
2276 else if (strcmp(style_str, "transient") == 0)
2277 style = RINST_TRANSIENT;
2278 }
2279
2280 /*
2281 * 2. utmpx prefix property.
2282 */
2283 if (scf_pg_get_property(pg, SCF_PROPERTY_UTMPX_PREFIX, prop) == 0) {
2284 errno = 0;
2285 if ((r = libscf_read_single_astring(h, prop, prefixp)) != 0) {
2286 if (r != LIBSCF_PROPERTY_ABSENT)
2287 ret = ECHILD;
2288 goto instance_flags_out;
2289 }
2290 } else {
2291 switch (scf_error()) {
2292 case SCF_ERROR_DELETED:
2293 ret = ENOENT;
2294 goto instance_flags_out;
2295
2296 case SCF_ERROR_NOT_FOUND:
2297 goto instance_flags_out;
2298
2299 case SCF_ERROR_CONNECTION_BROKEN:
2300 default:
2301 ret = ECONNABORTED;
2302 goto instance_flags_out;
2303
2304 case SCF_ERROR_INVALID_ARGUMENT:
2305 case SCF_ERROR_HANDLE_MISMATCH:
2306 case SCF_ERROR_NOT_SET:
2307 bad_error("scf_pg_get_property", scf_error());
2308 }
2309 }
2310
2311 instance_flags_out:
2312 startd_free(style_str, max_scf_value_size);
2313 *flags = (*flags & ~RINST_STYLE_MASK) | style;
2314
2315 scf_property_destroy(prop);
2316 scf_pg_destroy(pg);
2317
2318 return (ret);
2319 }
2320
2321 /*
2322 * int libscf_read_method_ids(scf_handle_t *, scf_instance_t *, ctid_t *,
2323 * ctid_t *, pid_t *)
2324 *
2325 * Sets given id_t variables to primary and transient contract IDs and start
2326 * PID. Returns 0, ECONNABORTED, and ECANCELED.
2327 */
2328 int
2329 libscf_read_method_ids(scf_handle_t *h, scf_instance_t *inst, const char *fmri,
2330 ctid_t *primary, ctid_t *transient, pid_t *start_pid)
2331 {
2332 scf_propertygroup_t *pg = NULL;
2333 scf_property_t *prop = NULL;
2334 scf_value_t *val = NULL;
2335 uint64_t p, t;
2336 int ret = 0;
2337
2338 *primary = 0;
2339 *transient = 0;
2340 *start_pid = -1;
2341
2342 pg = safe_scf_pg_create(h);
2343 prop = safe_scf_property_create(h);
2344 val = safe_scf_value_create(h);
2345
2346 if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, pg) == -1) {
2347 switch (scf_error()) {
2348 case SCF_ERROR_CONNECTION_BROKEN:
2349 default:
2350 ret = ECONNABORTED;
2351 goto read_id_err;
2352
2353 case SCF_ERROR_DELETED:
2354 ret = ECANCELED;
2355 goto read_id_err;
2356
2357 case SCF_ERROR_NOT_FOUND:
2358 goto read_id_err;
2359
2360 case SCF_ERROR_NOT_SET:
2361 bad_error("scf_instance_get_pg", scf_error());
2362 }
2363 }
2364
2365 ret = get_count(pg, SCF_PROPERTY_CONTRACT, &p);
2366 switch (ret) {
2367 case 0:
2368 break;
2369
2370 case EINVAL:
2371 log_error(LOG_NOTICE,
2372 "%s: Ignoring %s/%s: multivalued or not of type count\n",
2373 fmri, SCF_PG_RESTARTER, SCF_PROPERTY_CONTRACT);
2374 /* FALLTHROUGH */
2375 case ENOENT:
2376 ret = 0;
2377 goto read_trans;
2378
2379 case ECONNABORTED:
2380 case ECANCELED:
2381 goto read_id_err;
2382
2383 case EACCES:
2384 default:
2385 bad_error("get_count", ret);
2386 }
2387
2388 *primary = p;
2389
2390 read_trans:
2391 ret = get_count(pg, SCF_PROPERTY_TRANSIENT_CONTRACT, &t);
2392 switch (ret) {
2393 case 0:
2394 break;
2395
2396 case EINVAL:
2397 log_error(LOG_NOTICE,
2398 "%s: Ignoring %s/%s: multivalued or not of type count\n",
2399 fmri, SCF_PG_RESTARTER, SCF_PROPERTY_TRANSIENT_CONTRACT);
2400 /* FALLTHROUGH */
2401
2402 case ENOENT:
2403 ret = 0;
2404 goto read_pid_only;
2405
2406 case ECONNABORTED:
2407 case ECANCELED:
2408 goto read_id_err;
2409
2410 case EACCES:
2411 default:
2412 bad_error("get_count", ret);
2413 }
2414
2415 *transient = t;
2416
2417 read_pid_only:
2418 ret = get_count(pg, SCF_PROPERTY_START_PID, &p);
2419 switch (ret) {
2420 case 0:
2421 break;
2422
2423 case EINVAL:
2424 log_error(LOG_NOTICE,
2425 "%s: Ignoring %s/%s: multivalued or not of type count\n",
2426 fmri, SCF_PG_RESTARTER, SCF_PROPERTY_START_PID);
2427 /* FALLTHROUGH */
2428 case ENOENT:
2429 ret = 0;
2430 goto read_id_err;
2431
2432 case ECONNABORTED:
2433 case ECANCELED:
2434 goto read_id_err;
2435
2436 case EACCES:
2437 default:
2438 bad_error("get_count", ret);
2439 }
2440
2441 *start_pid = p;
2442
2443 read_id_err:
2444 scf_value_destroy(val);
2445 scf_property_destroy(prop);
2446 scf_pg_destroy(pg);
2447 return (ret);
2448 }
2449
2450 /*
2451 * Returns with
2452 * 0 - success
2453 * ECONNABORTED - repository connection broken
2454 * - unknown libscf error
2455 * ECANCELED - s_inst was deleted
2456 * EPERM
2457 * EACCES
2458 * EROFS
2459 */
2460 int
2461 libscf_write_start_pid(scf_instance_t *s_inst, pid_t pid)
2462 {
2463 scf_handle_t *h;
2464 scf_transaction_entry_t *t_pid;
2465 scf_value_t *v_pid;
2466 scf_propertygroup_t *pg;
2467 int ret = 0;
2468
2469 h = scf_instance_handle(s_inst);
2470
2471 pg = safe_scf_pg_create(h);
2472 t_pid = safe_scf_entry_create(h);
2473 v_pid = safe_scf_value_create(h);
2474
2475 get_pg:
2476 ret = libscf_inst_get_or_add_pg(s_inst, SCF_PG_RESTARTER,
2477 SCF_PG_RESTARTER_TYPE, SCF_PG_RESTARTER_FLAGS, pg);
2478 switch (ret) {
2479 case 0:
2480 break;
2481
2482 case ECONNABORTED:
2483 case ECANCELED:
2484 case EPERM:
2485 case EACCES:
2486 case EROFS:
2487 goto write_start_err;
2488
2489 default:
2490 bad_error("libscf_inst_get_or_add_pg", ret);
2491 }
2492
2493 scf_value_set_count(v_pid, pid);
2494
2495 ret = pg_set_prop_value(pg, SCF_PROPERTY_START_PID, v_pid);
2496 switch (ret) {
2497 case 0:
2498 case ECONNABORTED:
2499 case EPERM:
2500 case EACCES:
2501 case EROFS:
2502 break;
2503
2504 case ECANCELED:
2505 goto get_pg;
2506
2507 default:
2508 bad_error("pg_set_prop_value", ret);
2509 }
2510
2511 write_start_err:
2512 scf_entry_destroy(t_pid);
2513 scf_value_destroy(v_pid);
2514 scf_pg_destroy(pg);
2515
2516 return (ret);
2517 }
2518
2519 /*
2520 * Add a property indicating the instance log file. If the dir is
2521 * equal to LOG_PREFIX_EARLY, then the property restarter/alt_logfile
2522 * of the instance is used; otherwise, restarter/logfile is used.
2523 *
2524 * Returns
2525 * 0 - success
2526 * ECONNABORTED
2527 * ECANCELED
2528 * EPERM
2529 * EACCES
2530 * EROFS
2531 * EAGAIN
2532 */
2533 int
2534 libscf_note_method_log(scf_instance_t *inst, const char *dir, const char *file)
2535 {
2536 scf_handle_t *h;
2537 scf_value_t *v;
2538 scf_propertygroup_t *pg;
2539 int ret = 0;
2540 char *logname;
2541 const char *propname;
2542
2543 h = scf_instance_handle(inst);
2544 pg = safe_scf_pg_create(h);
2545 v = safe_scf_value_create(h);
2546
2547 logname = uu_msprintf("%s%s", dir, file);
2548
2549 if (logname == NULL) {
2550 ret = errno;
2551 goto out;
2552 }
2553
2554 ret = libscf_inst_get_or_add_pg(inst, SCF_PG_RESTARTER,
2555 SCF_PG_RESTARTER_TYPE, SCF_PG_RESTARTER_FLAGS, pg);
2556 switch (ret) {
2557 case 0:
2558 break;
2559
2560 case ECONNABORTED:
2561 case ECANCELED:
2562 case EPERM:
2563 case EACCES:
2564 case EROFS:
2565 goto out;
2566
2567 default:
2568 bad_error("libscf_inst_get_or_add_pg", ret);
2569 }
2570
2571 (void) scf_value_set_astring(v, logname);
2572
2573 if (strcmp(LOG_PREFIX_EARLY, dir) == 0)
2574 propname = SCF_PROPERTY_ALT_LOGFILE;
2575 else
2576 propname = SCF_PROPERTY_LOGFILE;
2577
2578 ret = pg_set_prop_value(pg, propname, v);
2579 switch (ret) {
2580 case 0:
2581 case ECONNABORTED:
2582 case ECANCELED:
2583 case EPERM:
2584 case EACCES:
2585 case EROFS:
2586 break;
2587
2588 default:
2589 bad_error("pg_set_prop_value", ret);
2590 }
2591
2592 out:
2593 scf_pg_destroy(pg);
2594 scf_value_destroy(v);
2595 uu_free(logname);
2596 return (ret);
2597 }
2598
2599 /*
2600 * Returns
2601 * 0 - success
2602 * ENAMETOOLONG - name is too long
2603 * ECONNABORTED
2604 * ECANCELED
2605 * EPERM
2606 * EACCES
2607 * EROFS
2608 */
2609 int
2610 libscf_write_method_status(scf_instance_t *s_inst, const char *name,
2611 int status)
2612 {
2613 scf_handle_t *h;
2614 scf_transaction_t *tx;
2615 scf_transaction_entry_t *e_time, *e_stat;
2616 scf_value_t *v_time, *v_stat;
2617 scf_propertygroup_t *pg;
2618 int ret = 0, r;
2619 char pname[30];
2620 struct timeval tv;
2621 scf_error_t scfe;
2622
2623 if (strlen(name) + sizeof ("_method_waitstatus") > sizeof (pname))
2624 return (ENAMETOOLONG);
2625
2626 h = scf_instance_handle(s_inst);
2627
2628 pg = safe_scf_pg_create(h);
2629 tx = safe_scf_transaction_create(h);
2630 e_time = safe_scf_entry_create(h);
2631 v_time = safe_scf_value_create(h);
2632 e_stat = safe_scf_entry_create(h);
2633 v_stat = safe_scf_value_create(h);
2634
2635 get_pg:
2636 ret = libscf_inst_get_or_add_pg(s_inst, SCF_PG_RESTARTER,
2637 SCF_PG_RESTARTER_TYPE, SCF_PG_RESTARTER_FLAGS, pg);
2638 switch (ret) {
2639 case 0:
2640 break;
2641
2642 case ECONNABORTED:
2643 case ECANCELED:
2644 case EPERM:
2645 case EACCES:
2646 case EROFS:
2647 goto out;
2648
2649 default:
2650 bad_error("libscf_inst_get_or_add_pg", ret);
2651 }
2652
2653 (void) gettimeofday(&tv, NULL);
2654
2655 r = scf_value_set_time(v_time, tv.tv_sec, tv.tv_usec * 1000);
2656 assert(r == 0);
2657
2658 scf_value_set_integer(v_stat, status);
2659
2660 for (;;) {
2661 if (scf_transaction_start(tx, pg) != 0) {
2662 switch (scf_error()) {
2663 case SCF_ERROR_CONNECTION_BROKEN:
2664 default:
2665 ret = ECONNABORTED;
2666 goto out;
2667
2668 case SCF_ERROR_DELETED:
2669 ret = ECANCELED;
2670 goto out;
2671
2672 case SCF_ERROR_PERMISSION_DENIED:
2673 ret = EPERM;
2674 goto out;
2675
2676 case SCF_ERROR_BACKEND_ACCESS:
2677 ret = EACCES;
2678 goto out;
2679
2680 case SCF_ERROR_BACKEND_READONLY:
2681 ret = EROFS;
2682 goto out;
2683
2684 case SCF_ERROR_NOT_SET:
2685 bad_error("scf_transaction_start", ret);
2686 }
2687 }
2688
2689 (void) snprintf(pname, sizeof (pname), "%s_method_timestamp",
2690 name);
2691 ret = transaction_add_set(tx, e_time, pname, SCF_TYPE_TIME);
2692 switch (ret) {
2693 case 0:
2694 break;
2695
2696 case ECONNABORTED:
2697 case ECANCELED:
2698 goto out;
2699
2700 default:
2701 bad_error("transaction_add_set", ret);
2702 }
2703
2704 r = scf_entry_add_value(e_time, v_time);
2705 assert(r == 0);
2706
2707 (void) snprintf(pname, sizeof (pname), "%s_method_waitstatus",
2708 name);
2709 ret = transaction_add_set(tx, e_stat, pname, SCF_TYPE_INTEGER);
2710 switch (ret) {
2711 case 0:
2712 break;
2713
2714 case ECONNABORTED:
2715 case ECANCELED:
2716 goto out;
2717
2718 default:
2719 bad_error("transaction_add_set", ret);
2720 }
2721
2722 r = scf_entry_add_value(e_stat, v_stat);
2723 if (r != 0)
2724 bad_error("scf_entry_add_value", scf_error());
2725
2726 r = scf_transaction_commit(tx);
2727 if (r == 1)
2728 break;
2729 if (r != 0) {
2730 scfe = scf_error();
2731 scf_transaction_reset_all(tx);
2732 switch (scfe) {
2733 case SCF_ERROR_CONNECTION_BROKEN:
2734 default:
2735 ret = ECONNABORTED;
2736 goto out;
2737
2738 case SCF_ERROR_DELETED:
2739 ret = ECANCELED;
2740 goto out;
2741
2742 case SCF_ERROR_PERMISSION_DENIED:
2743 ret = EPERM;
2744 goto out;
2745
2746 case SCF_ERROR_BACKEND_ACCESS:
2747 ret = EACCES;
2748 goto out;
2749
2750 case SCF_ERROR_BACKEND_READONLY:
2751 ret = EROFS;
2752 goto out;
2753
2754 case SCF_ERROR_NOT_SET:
2755 bad_error("scf_transaction_commit", scfe);
2756 }
2757 }
2758
2759 scf_transaction_reset_all(tx);
2760
2761 if (scf_pg_update(pg) == -1) {
2762 switch (scf_error()) {
2763 case SCF_ERROR_CONNECTION_BROKEN:
2764 default:
2765 ret = ECONNABORTED;
2766 goto out;
2767
2768 case SCF_ERROR_DELETED:
2769 ret = ECANCELED;
2770 goto out;
2771
2772 case SCF_ERROR_NOT_SET:
2773 bad_error("scf_pg_update", scf_error());
2774 }
2775 }
2776 }
2777
2778 out:
2779 scf_transaction_destroy(tx);
2780 scf_entry_destroy(e_time);
2781 scf_value_destroy(v_time);
2782 scf_entry_destroy(e_stat);
2783 scf_value_destroy(v_stat);
2784 scf_pg_destroy(pg);
2785
2786 return (ret);
2787 }
2788
2789 extern int32_t stn_global;
2790 /*
2791 * Call dgraph_add_instance() for each instance in the repository.
2792 */
2793 void
2794 libscf_populate_graph(scf_handle_t *h)
2795 {
2796 scf_scope_t *scope;
2797 scf_service_t *svc;
2798 scf_instance_t *inst;
2799 scf_iter_t *svc_iter;
2800 scf_iter_t *inst_iter;
2801
2802 scope = safe_scf_scope_create(h);
2803 svc = safe_scf_service_create(h);
2804 inst = safe_scf_instance_create(h);
2805 svc_iter = safe_scf_iter_create(h);
2806 inst_iter = safe_scf_iter_create(h);
2807
2808 deathrow_init();
2809
2810 stn_global = libscf_get_global_stn_tset(h);
2811
2812 if (scf_handle_get_local_scope(h, scope) !=
2813 SCF_SUCCESS)
2814 uu_die("retrieving local scope failed: %s\n",
2815 scf_strerror(scf_error()));
2816
2817 if (scf_iter_scope_services(svc_iter, scope) == -1)
2818 uu_die("walking local scope's services failed\n");
2819
2820 while (scf_iter_next_service(svc_iter, svc) > 0) {
2821 if (scf_iter_service_instances(inst_iter, svc) == -1)
2822 uu_die("unable to walk service's instances");
2823
2824 while (scf_iter_next_instance(inst_iter, inst) > 0) {
2825 char *fmri;
2826
2827 if (libscf_instance_get_fmri(inst, &fmri) == 0) {
2828 int err;
2829
2830 err = dgraph_add_instance(fmri, inst, B_TRUE);
2831 if (err != 0 && err != EEXIST)
2832 log_error(LOG_WARNING,
2833 "Failed to add %s (%s).\n", fmri,
2834 strerror(err));
2835 startd_free(fmri, max_scf_fmri_size);
2836 }
2837 }
2838 }
2839
2840 deathrow_fini();
2841
2842 scf_iter_destroy(inst_iter);
2843 scf_iter_destroy(svc_iter);
2844 scf_instance_destroy(inst);
2845 scf_service_destroy(svc);
2846 scf_scope_destroy(scope);
2847 }
2848
2849 /*
2850 * Monitors get handled differently since there can be multiple of them.
2851 *
2852 * Returns exec string on success. If method not defined, returns
2853 * LIBSCF_PGROUP_ABSENT; if exec property missing, returns
2854 * LIBSCF_PROPERTY_ABSENT. Returns LIBSCF_PROPERTY_ERROR on other failures.
2855 */
2856 char *
2857 libscf_get_method(scf_handle_t *h, int type, restarter_inst_t *inst,
2858 scf_snapshot_t *snap, method_restart_t *restart_on, uint_t *cte_mask,
2859 uint8_t *need_sessionp, uint64_t *timeout, uint8_t *timeout_retry)
2860 {
2861 scf_instance_t *scf_inst = NULL;
2862 scf_propertygroup_t *pg = NULL, *pg_startd = NULL;
2863 scf_property_t *prop = NULL;
2864 const char *name;
2865 char *method = startd_alloc(max_scf_value_size);
2866 char *ig = startd_alloc(max_scf_value_size);
2867 char *restart = startd_alloc(max_scf_value_size);
2868 char *ret;
2869 int error = 0, r;
2870
2871 scf_inst = safe_scf_instance_create(h);
2872 pg = safe_scf_pg_create(h);
2873 pg_startd = safe_scf_pg_create(h);
2874 prop = safe_scf_property_create(h);
2875
2876 ret = NULL;
2877
2878 *restart_on = METHOD_RESTART_UNKNOWN;
2879
2880 switch (type) {
2881 case METHOD_START:
2882 name = "start";
2883 break;
2884 case METHOD_STOP:
2885 name = "stop";
2886 break;
2887 case METHOD_REFRESH:
2888 name = "refresh";
2889 break;
2890 default:
2891 error = LIBSCF_PROPERTY_ERROR;
2892 goto get_method_cleanup;
2893 }
2894
2895 if (scf_handle_decode_fmri(h, inst->ri_i.i_fmri, NULL, NULL, scf_inst,
2896 NULL, NULL, SCF_DECODE_FMRI_EXACT) == -1) {
2897 log_error(LOG_WARNING,
2898 "%s: get_method decode instance FMRI failed: %s\n",
2899 inst->ri_i.i_fmri, scf_strerror(scf_error()));
2900 error = LIBSCF_PROPERTY_ERROR;
2901 goto get_method_cleanup;
2902 }
2903
2904 if (scf_instance_get_pg_composed(scf_inst, snap, name, pg) == -1) {
2905 if (scf_error() == SCF_ERROR_NOT_FOUND)
2906 error = LIBSCF_PGROUP_ABSENT;
2907 else
2908 error = LIBSCF_PROPERTY_ERROR;
2909 goto get_method_cleanup;
2910 }
2911
2912 if (scf_pg_get_property(pg, SCF_PROPERTY_EXEC, prop) == -1) {
2913 if (scf_error() == SCF_ERROR_NOT_FOUND)
2914 error = LIBSCF_PROPERTY_ABSENT;
2915 else
2916 error = LIBSCF_PROPERTY_ERROR;
2917 goto get_method_cleanup;
2918 }
2919
2920 error = libscf_read_single_astring(h, prop, &method);
2921 if (error != 0) {
2922 log_error(LOG_WARNING,
2923 "%s: get_method failed: can't get a single astring "
2924 "from %s/%s\n", inst->ri_i.i_fmri, name, SCF_PROPERTY_EXEC);
2925 goto get_method_cleanup;
2926 }
2927
2928 error = expand_method_tokens(method, scf_inst, snap, type, &ret);
2929 if (error != 0) {
2930 log_instance(inst, B_TRUE, "Could not expand method tokens "
2931 "in \"%s\": %s.", method, ret);
2932 error = LIBSCF_PROPERTY_ERROR;
2933 goto get_method_cleanup;
2934 }
2935
2936 r = get_count(pg, SCF_PROPERTY_TIMEOUT, timeout);
2937 switch (r) {
2938 case 0:
2939 break;
2940
2941 case ECONNABORTED:
2942 error = LIBSCF_PROPERTY_ERROR;
2943 goto get_method_cleanup;
2944
2945 case EINVAL:
2946 log_instance(inst, B_TRUE, "%s/%s is multi-valued or not of "
2947 "type count. Using infinite timeout.", name,
2948 SCF_PROPERTY_TIMEOUT);
2949 /* FALLTHROUGH */
2950 case ECANCELED:
2951 case ENOENT:
2952 *timeout = METHOD_TIMEOUT_INFINITE;
2953 break;
2954
2955 case EACCES:
2956 default:
2957 bad_error("get_count", r);
2958 }
2959
2960 /* Both 0 and -1 (ugh) are considered infinite timeouts. */
2961 if (*timeout == -1 || *timeout == 0)
2962 *timeout = METHOD_TIMEOUT_INFINITE;
2963
2964 if (scf_instance_get_pg_composed(scf_inst, snap, SCF_PG_STARTD,
2965 pg_startd) == -1) {
2966 switch (scf_error()) {
2967 case SCF_ERROR_CONNECTION_BROKEN:
2968 case SCF_ERROR_DELETED:
2969 error = LIBSCF_PROPERTY_ERROR;
2970 goto get_method_cleanup;
2971
2972 case SCF_ERROR_NOT_FOUND:
2973 *cte_mask = 0;
2974 break;
2975
2976 case SCF_ERROR_INVALID_ARGUMENT:
2977 case SCF_ERROR_HANDLE_MISMATCH:
2978 case SCF_ERROR_NOT_BOUND:
2979 case SCF_ERROR_NOT_SET:
2980 bad_error("scf_instance_get_pg_composed", scf_error());
2981 }
2982 } else {
2983 if (scf_pg_get_property(pg_startd, SCF_PROPERTY_IGNORE,
2984 prop) == -1) {
2985 if (scf_error() == SCF_ERROR_NOT_FOUND)
2986 *cte_mask = 0;
2987 else {
2988 error = LIBSCF_PROPERTY_ERROR;
2989 goto get_method_cleanup;
2990 }
2991 } else {
2992 error = libscf_read_single_astring(h, prop, &ig);
2993 if (error != 0) {
2994 log_error(LOG_WARNING,
2995 "%s: get_method failed: can't get a single "
2996 "astring from %s/%s\n", inst->ri_i.i_fmri,
2997 name, SCF_PROPERTY_IGNORE);
2998 goto get_method_cleanup;
2999 }
3000
3001 if (strcmp(ig, "core") == 0)
3002 *cte_mask = CT_PR_EV_CORE;
3003 else if (strcmp(ig, "signal") == 0)
3004 *cte_mask = CT_PR_EV_SIGNAL;
3005 else if (strcmp(ig, "core,signal") == 0 ||
3006 strcmp(ig, "signal,core") == 0)
3007 *cte_mask = CT_PR_EV_CORE | CT_PR_EV_SIGNAL;
3008 else
3009 *cte_mask = 0;
3010 }
3011
3012 r = get_boolean(pg_startd, SCF_PROPERTY_NEED_SESSION,
3013 need_sessionp);
3014 switch (r) {
3015 case 0:
3016 break;
3017
3018 case ECONNABORTED:
3019 error = LIBSCF_PROPERTY_ERROR;
3020 goto get_method_cleanup;
3021
3022 case ECANCELED:
3023 case ENOENT:
3024 case EINVAL:
3025 *need_sessionp = 0;
3026 break;
3027
3028 case EACCES:
3029 default:
3030 bad_error("get_boolean", r);
3031 }
3032
3033 /*
3034 * Determine whether service has overriden retry after
3035 * method timeout. Default to retry if no value is
3036 * specified.
3037 */
3038 r = get_boolean(pg_startd, SCF_PROPERTY_TIMEOUT_RETRY,
3039 timeout_retry);
3040 switch (r) {
3041 case 0:
3042 break;
3043
3044 case ECONNABORTED:
3045 error = LIBSCF_PROPERTY_ERROR;
3046 goto get_method_cleanup;
3047
3048 case ECANCELED:
3049 case ENOENT:
3050 case EINVAL:
3051 *timeout_retry = 1;
3052 break;
3053
3054 case EACCES:
3055 default:
3056 bad_error("get_boolean", r);
3057 }
3058 }
3059
3060 if (type != METHOD_START)
3061 goto get_method_cleanup;
3062
3063 /* Only start methods need to honor the restart_on property. */
3064
3065 if (scf_pg_get_property(pg, SCF_PROPERTY_RESTART_ON, prop) == -1) {
3066 if (scf_error() == SCF_ERROR_NOT_FOUND)
3067 *restart_on = METHOD_RESTART_ALL;
3068 else
3069 error = LIBSCF_PROPERTY_ERROR;
3070 goto get_method_cleanup;
3071 }
3072
3073 error = libscf_read_single_astring(h, prop, &restart);
3074 if (error != 0) {
3075 log_error(LOG_WARNING,
3076 "%s: get_method failed: can't get a single astring "
3077 "from %s/%s\n", inst->ri_i.i_fmri, name,
3078 SCF_PROPERTY_RESTART_ON);
3079 goto get_method_cleanup;
3080 }
3081
3082 if (strcmp(restart, "all") == 0)
3083 *restart_on = METHOD_RESTART_ALL;
3084 else if (strcmp(restart, "external_fault") == 0)
3085 *restart_on = METHOD_RESTART_EXTERNAL_FAULT;
3086 else if (strcmp(restart, "any_fault") == 0)
3087 *restart_on = METHOD_RESTART_ANY_FAULT;
3088
3089 get_method_cleanup:
3090 startd_free(ig, max_scf_value_size);
3091 startd_free(method, max_scf_value_size);
3092 startd_free(restart, max_scf_value_size);
3093
3094 scf_instance_destroy(scf_inst);
3095 scf_pg_destroy(pg);
3096 scf_pg_destroy(pg_startd);
3097 scf_property_destroy(prop);
3098
3099 if (error != 0 && ret != NULL) {
3100 free(ret);
3101 ret = NULL;
3102 }
3103
3104 errno = error;
3105 return (ret);
3106 }
3107
3108 /*
3109 * Returns 1 if we've reached the fault threshold
3110 */
3111 int
3112 update_fault_count(restarter_inst_t *inst, int type)
3113 {
3114 assert(type == FAULT_COUNT_INCR || type == FAULT_COUNT_RESET);
3115
3116 if (type == FAULT_COUNT_INCR) {
3117 inst->ri_i.i_fault_count++;
3118 log_framework(LOG_INFO, "%s: Increasing fault count to %d\n",
3119 inst->ri_i.i_fmri, inst->ri_i.i_fault_count);
3120 }
3121 if (type == FAULT_COUNT_RESET)
3122 inst->ri_i.i_fault_count = 0;
3123
3124 if (inst->ri_i.i_fault_count >= FAULT_THRESHOLD)
3125 return (1);
3126
3127 return (0);
3128 }
3129
3130 /*
3131 * int libscf_unset_action()
3132 * Delete any pending timestamps for the specified action which is
3133 * older than the supplied ts.
3134 *
3135 * Returns 0 on success, ECONNABORTED, EACCES, or EPERM on failure.
3136 */
3137 int
3138 libscf_unset_action(scf_handle_t *h, scf_propertygroup_t *pg,
3139 admin_action_t a, hrtime_t ts)
3140 {
3141 scf_transaction_t *t;
3142 scf_transaction_entry_t *e;
3143 scf_property_t *prop;
3144 scf_value_t *val;
3145 hrtime_t rep_ts;
3146 int ret = 0, r;
3147
3148 t = safe_scf_transaction_create(h);
3149 e = safe_scf_entry_create(h);
3150 prop = safe_scf_property_create(h);
3151 val = safe_scf_value_create(h);
3152
3153 for (;;) {
3154 if (scf_pg_update(pg) == -1) {
3155 switch (scf_error()) {
3156 case SCF_ERROR_CONNECTION_BROKEN:
3157 default:
3158 ret = ECONNABORTED;
3159 goto unset_action_cleanup;
3160
3161 case SCF_ERROR_DELETED:
3162 goto unset_action_cleanup;
3163
3164 case SCF_ERROR_NOT_SET:
3165 assert(0);
3166 abort();
3167 }
3168 }
3169
3170 if (scf_transaction_start(t, pg) == -1) {
3171 switch (scf_error()) {
3172 case SCF_ERROR_CONNECTION_BROKEN:
3173 default:
3174 ret = ECONNABORTED;
3175 goto unset_action_cleanup;
3176
3177 case SCF_ERROR_DELETED:
3178 goto unset_action_cleanup;
3179
3180 case SCF_ERROR_PERMISSION_DENIED:
3181 ret = EPERM;
3182 goto unset_action_cleanup;
3183
3184 case SCF_ERROR_BACKEND_ACCESS:
3185 case SCF_ERROR_BACKEND_READONLY:
3186 ret = EACCES;
3187 goto unset_action_cleanup;
3188
3189 case SCF_ERROR_IN_USE:
3190 case SCF_ERROR_HANDLE_MISMATCH:
3191 case SCF_ERROR_NOT_SET:
3192 assert(0);
3193 abort();
3194 }
3195 }
3196
3197 /* Return failure only if the property hasn't been deleted. */
3198 if (scf_pg_get_property(pg, admin_actions[a], prop) == -1) {
3199 switch (scf_error()) {
3200 case SCF_ERROR_CONNECTION_BROKEN:
3201 default:
3202 ret = ECONNABORTED;
3203 goto unset_action_cleanup;
3204
3205 case SCF_ERROR_DELETED:
3206 case SCF_ERROR_NOT_FOUND:
3207 goto unset_action_cleanup;
3208
3209 case SCF_ERROR_HANDLE_MISMATCH:
3210 case SCF_ERROR_INVALID_ARGUMENT:
3211 case SCF_ERROR_NOT_SET:
3212 assert(0);
3213 abort();
3214 }
3215 }
3216
3217 if (scf_property_get_value(prop, val) == -1) {
3218 switch (scf_error()) {
3219 case SCF_ERROR_CONNECTION_BROKEN:
3220 default:
3221 ret = ECONNABORTED;
3222 goto unset_action_cleanup;
3223
3224 case SCF_ERROR_DELETED:
3225 case SCF_ERROR_NOT_FOUND:
3226 goto unset_action_cleanup;
3227
3228 case SCF_ERROR_CONSTRAINT_VIOLATED:
3229 /*
3230 * More than one value was associated with
3231 * this property -- this is incorrect. Take
3232 * the opportunity to clean up and clear the
3233 * entire property.
3234 */
3235 rep_ts = ts;
3236 break;
3237
3238 case SCF_ERROR_PERMISSION_DENIED:
3239 case SCF_ERROR_NOT_SET:
3240 assert(0);
3241 abort();
3242 }
3243 } else if (scf_value_get_integer(val, &rep_ts) == -1) {
3244 assert(scf_error() == SCF_ERROR_TYPE_MISMATCH);
3245 rep_ts = 0;
3246 }
3247
3248 /* Repository ts is more current. Don't clear the action. */
3249 if (rep_ts > ts)
3250 goto unset_action_cleanup;
3251
3252 r = scf_transaction_property_change_type(t, e,
3253 admin_actions[a], SCF_TYPE_INTEGER);
3254 assert(r == 0);
3255
3256 r = scf_transaction_commit(t);
3257 if (r == 1)
3258 break;
3259
3260 if (r != 0) {
3261 switch (scf_error()) {
3262 case SCF_ERROR_CONNECTION_BROKEN:
3263 default:
3264 ret = ECONNABORTED;
3265 goto unset_action_cleanup;
3266
3267 case SCF_ERROR_DELETED:
3268 break;
3269
3270 case SCF_ERROR_PERMISSION_DENIED:
3271 ret = EPERM;
3272 goto unset_action_cleanup;
3273
3274 case SCF_ERROR_BACKEND_ACCESS:
3275 case SCF_ERROR_BACKEND_READONLY:
3276 ret = EACCES;
3277 goto unset_action_cleanup;
3278
3279 case SCF_ERROR_INVALID_ARGUMENT:
3280 case SCF_ERROR_NOT_SET:
3281 assert(0);
3282 abort();
3283 }
3284 }
3285
3286 scf_transaction_reset(t);
3287 }
3288
3289 unset_action_cleanup:
3290 scf_transaction_destroy(t);
3291 scf_entry_destroy(e);
3292 scf_property_destroy(prop);
3293 scf_value_destroy(val);
3294
3295 return (ret);
3296 }
3297
3298 /*
3299 * Decorates & binds hndl. hndl must be unbound. Returns
3300 * 0 - success
3301 * -1 - repository server is not running
3302 * -1 - repository server is out of resources
3303 */
3304 static int
3305 handle_decorate_and_bind(scf_handle_t *hndl)
3306 {
3307 scf_value_t *door_dec_value;
3308
3309 door_dec_value = safe_scf_value_create(hndl);
3310
3311 /*
3312 * Decorate if alternate door path set.
3313 */
3314 if (st->st_door_path) {
3315 if (scf_value_set_astring(door_dec_value, st->st_door_path) !=
3316 0)
3317 uu_die("$STARTD_ALT_DOOR is too long.\n");
3318
3319 if (scf_handle_decorate(hndl, "door_path", door_dec_value) != 0)
3320 bad_error("scf_handle_decorate", scf_error());
3321 }
3322
3323 scf_value_destroy(door_dec_value);
3324
3325 if (scf_handle_bind(hndl) == 0)
3326 return (0);
3327
3328 switch (scf_error()) {
3329 case SCF_ERROR_NO_SERVER:
3330 case SCF_ERROR_NO_RESOURCES:
3331 return (-1);
3332
3333 case SCF_ERROR_INVALID_ARGUMENT:
3334 case SCF_ERROR_IN_USE:
3335 default:
3336 bad_error("scf_handle_bind", scf_error());
3337 /* NOTREACHED */
3338 }
3339 }
3340
3341 scf_handle_t *
3342 libscf_handle_create_bound(scf_version_t v)
3343 {
3344 scf_handle_t *hndl = scf_handle_create(v);
3345
3346 if (hndl == NULL)
3347 return (hndl);
3348
3349 if (handle_decorate_and_bind(hndl) == 0)
3350 return (hndl);
3351
3352 scf_handle_destroy(hndl);
3353 return (NULL);
3354 }
3355
3356 void
3357 libscf_handle_rebind(scf_handle_t *h)
3358 {
3359 (void) scf_handle_unbind(h);
3360
3361 MUTEX_LOCK(&st->st_configd_live_lock);
3362
3363 /*
3364 * Try to rebind the handle before sleeping in case the server isn't
3365 * really dead.
3366 */
3367 while (handle_decorate_and_bind(h) != 0)
3368 (void) pthread_cond_wait(&st->st_configd_live_cv,
3369 &st->st_configd_live_lock);
3370
3371 MUTEX_UNLOCK(&st->st_configd_live_lock);
3372 }
3373
3374 /*
3375 * Create a handle and try to bind it until it succeeds. Always returns
3376 * a bound handle.
3377 */
3378 scf_handle_t *
3379 libscf_handle_create_bound_loop()
3380 {
3381 scf_handle_t *h;
3382
3383 while ((h = scf_handle_create(SCF_VERSION)) == NULL) {
3384 /* This should have been caught earlier. */
3385 assert(scf_error() != SCF_ERROR_VERSION_MISMATCH);
3386 (void) sleep(2);
3387 }
3388
3389 if (handle_decorate_and_bind(h) != 0)
3390 libscf_handle_rebind(h);
3391
3392 return (h);
3393 }
3394
3395 /*
3396 * Call cb for each dependency property group of inst. cb is invoked with
3397 * a pointer to the scf_propertygroup_t and arg. If the repository connection
3398 * is broken, returns ECONNABORTED. If inst is deleted, returns ECANCELED.
3399 * If cb returns non-zero, the walk is stopped and EINTR is returned.
3400 * Otherwise returns 0.
3401 */
3402 int
3403 walk_dependency_pgs(scf_instance_t *inst, callback_t cb, void *arg)
3404 {
3405 scf_handle_t *h;
3406 scf_snapshot_t *snap;
3407 scf_iter_t *iter;
3408 scf_propertygroup_t *pg;
3409 int r;
3410
3411 h = scf_instance_handle(inst);
3412
3413 iter = safe_scf_iter_create(h);
3414 pg = safe_scf_pg_create(h);
3415
3416 snap = libscf_get_running_snapshot(inst);
3417
3418 if (scf_iter_instance_pgs_typed_composed(iter, inst, snap,
3419 SCF_GROUP_DEPENDENCY) != 0) {
3420 scf_snapshot_destroy(snap);
3421 scf_pg_destroy(pg);
3422 scf_iter_destroy(iter);
3423 switch (scf_error()) {
3424 case SCF_ERROR_CONNECTION_BROKEN:
3425 default:
3426 return (ECONNABORTED);
3427
3428 case SCF_ERROR_DELETED:
3429 return (ECANCELED);
3430
3431 case SCF_ERROR_HANDLE_MISMATCH:
3432 case SCF_ERROR_INVALID_ARGUMENT:
3433 case SCF_ERROR_NOT_SET:
3434 assert(0);
3435 abort();
3436 }
3437 }
3438
3439 for (;;) {
3440 r = scf_iter_next_pg(iter, pg);
3441 if (r == 0)
3442 break;
3443 if (r == -1) {
3444 scf_snapshot_destroy(snap);
3445 scf_pg_destroy(pg);
3446 scf_iter_destroy(iter);
3447
3448 switch (scf_error()) {
3449 case SCF_ERROR_CONNECTION_BROKEN:
3450 return (ECONNABORTED);
3451
3452 case SCF_ERROR_DELETED:
3453 return (ECANCELED);
3454
3455 case SCF_ERROR_NOT_SET:
3456 case SCF_ERROR_INVALID_ARGUMENT:
3457 case SCF_ERROR_NOT_BOUND:
3458 case SCF_ERROR_HANDLE_MISMATCH:
3459 default:
3460 bad_error("scf_iter_next_pg", scf_error());
3461 }
3462 }
3463
3464 r = cb(pg, arg);
3465
3466 if (r != 0)
3467 break;
3468 }
3469
3470 scf_snapshot_destroy(snap);
3471 scf_pg_destroy(pg);
3472 scf_iter_destroy(iter);
3473
3474 return (r == 0 ? 0 : EINTR);
3475 }
3476
3477 /*
3478 * Call cb for each of the string values of prop. cb is invoked with
3479 * a pointer to the string and arg. If the connection to the repository is
3480 * broken, ECONNABORTED is returned. If the property is deleted, ECANCELED is
3481 * returned. If the property does not have astring type, EINVAL is returned.
3482 * If cb returns non-zero, the walk is stopped and EINTR is returned.
3483 * Otherwise 0 is returned.
3484 */
3485 int
3486 walk_property_astrings(scf_property_t *prop, callback_t cb, void *arg)
3487 {
3488 scf_handle_t *h;
3489 scf_value_t *val;
3490 scf_iter_t *iter;
3491 char *buf;
3492 int r;
3493 ssize_t sz;
3494
3495 if (scf_property_is_type(prop, SCF_TYPE_ASTRING) != 0) {
3496 switch (scf_error()) {
3497 case SCF_ERROR_CONNECTION_BROKEN:
3498 default:
3499 return (ECONNABORTED);
3500
3501 case SCF_ERROR_DELETED:
3502 return (ECANCELED);
3503
3504 case SCF_ERROR_TYPE_MISMATCH:
3505 return (EINVAL);
3506
3507 case SCF_ERROR_NOT_SET:
3508 assert(0);
3509 abort();
3510 }
3511 }
3512
3513 h = scf_property_handle(prop);
3514
3515 val = safe_scf_value_create(h);
3516 iter = safe_scf_iter_create(h);
3517
3518 if (scf_iter_property_values(iter, prop) != 0) {
3519 scf_iter_destroy(iter);
3520 scf_value_destroy(val);
3521 switch (scf_error()) {
3522 case SCF_ERROR_CONNECTION_BROKEN:
3523 default:
3524 return (ECONNABORTED);
3525
3526 case SCF_ERROR_DELETED:
3527 return (ECANCELED);
3528
3529 case SCF_ERROR_HANDLE_MISMATCH:
3530 case SCF_ERROR_NOT_SET:
3531 assert(0);
3532 abort();
3533 }
3534 }
3535
3536 buf = startd_alloc(max_scf_value_size);
3537
3538 for (;;) {
3539 r = scf_iter_next_value(iter, val);
3540 if (r < 0) {
3541 startd_free(buf, max_scf_value_size);
3542 scf_iter_destroy(iter);
3543 scf_value_destroy(val);
3544
3545 switch (scf_error()) {
3546 case SCF_ERROR_CONNECTION_BROKEN:
3547 return (ECONNABORTED);
3548
3549 case SCF_ERROR_DELETED:
3550 return (ECANCELED);
3551
3552 case SCF_ERROR_NOT_SET:
3553 case SCF_ERROR_INVALID_ARGUMENT:
3554 case SCF_ERROR_NOT_BOUND:
3555 case SCF_ERROR_HANDLE_MISMATCH:
3556 case SCF_ERROR_PERMISSION_DENIED:
3557 default:
3558 bad_error("scf_iter_next_value", scf_error());
3559 }
3560 }
3561 if (r == 0)
3562 break;
3563
3564 sz = scf_value_get_astring(val, buf, max_scf_value_size);
3565 assert(sz >= 0);
3566
3567 r = cb(buf, arg);
3568
3569 if (r != 0)
3570 break;
3571 }
3572
3573 startd_free(buf, max_scf_value_size);
3574 scf_value_destroy(val);
3575 scf_iter_destroy(iter);
3576
3577 return (r == 0 ? 0 : EINTR);
3578 }
3579
3580 /*
3581 * Returns 0 or ECONNABORTED.
3582 */
3583 int
3584 libscf_create_self(scf_handle_t *h)
3585 {
3586 scf_scope_t *scope;
3587 scf_service_t *svc;
3588 scf_instance_t *inst;
3589 instance_data_t idata;
3590 int ret = 0, r;
3591 ctid_t ctid;
3592 uint64_t uint64;
3593 uint_t count = 0, msecs = ALLOC_DELAY;
3594
3595 const char * const startd_svc = "system/svc/restarter";
3596 const char * const startd_inst = "default";
3597
3598 /* If SCF_SERVICE_STARTD changes, our strings must change, too. */
3599 assert(strcmp(SCF_SERVICE_STARTD,
3600 "svc:/system/svc/restarter:default") == 0);
3601
3602 scope = safe_scf_scope_create(h);
3603 svc = safe_scf_service_create(h);
3604 inst = safe_scf_instance_create(h);
3605
3606 if (scf_handle_get_scope(h, SCF_SCOPE_LOCAL, scope) != 0) {
3607 assert(scf_error() == SCF_ERROR_CONNECTION_BROKEN);
3608 ret = ECONNABORTED;
3609 goto out;
3610 }
3611
3612 get_svc:
3613 if (scf_scope_get_service(scope, startd_svc, svc) != 0) {
3614 switch (scf_error()) {
3615 case SCF_ERROR_CONNECTION_BROKEN:
3616 case SCF_ERROR_DELETED:
3617 default:
3618 ret = ECONNABORTED;
3619 goto out;
3620
3621 case SCF_ERROR_NOT_FOUND:
3622 break;
3623
3624 case SCF_ERROR_HANDLE_MISMATCH:
3625 case SCF_ERROR_INVALID_ARGUMENT:
3626 case SCF_ERROR_NOT_SET:
3627 bad_error("scf_scope_get_service", scf_error());
3628 }
3629
3630 add_svc:
3631 if (scf_scope_add_service(scope, startd_svc, svc) != 0) {
3632 switch (scf_error()) {
3633 case SCF_ERROR_CONNECTION_BROKEN:
3634 case SCF_ERROR_DELETED:
3635 default:
3636 ret = ECONNABORTED;
3637 goto out;
3638
3639 case SCF_ERROR_EXISTS:
3640 goto get_svc;
3641
3642 case SCF_ERROR_PERMISSION_DENIED:
3643 case SCF_ERROR_BACKEND_ACCESS:
3644 case SCF_ERROR_BACKEND_READONLY:
3645 uu_warn("Could not create %s: %s\n",
3646 SCF_SERVICE_STARTD,
3647 scf_strerror(scf_error()));
3648 goto out;
3649
3650 case SCF_ERROR_HANDLE_MISMATCH:
3651 case SCF_ERROR_INVALID_ARGUMENT:
3652 case SCF_ERROR_NOT_SET:
3653 bad_error("scf_scope_add_service", scf_error());
3654 }
3655 }
3656 }
3657
3658 if (scf_service_get_instance(svc, startd_inst, NULL) == 0)
3659 goto out;
3660
3661 switch (scf_error()) {
3662 case SCF_ERROR_CONNECTION_BROKEN:
3663 default:
3664 ret = ECONNABORTED;
3665 goto out;
3666
3667 case SCF_ERROR_NOT_FOUND:
3668 break;
3669
3670 case SCF_ERROR_DELETED:
3671 goto add_svc;
3672
3673 case SCF_ERROR_HANDLE_MISMATCH:
3674 case SCF_ERROR_INVALID_ARGUMENT:
3675 case SCF_ERROR_NOT_SET:
3676 bad_error("scf_service_get_instance", scf_error());
3677 }
3678
3679 add_inst:
3680 if (scf_service_add_instance(svc, startd_inst, inst) != 0) {
3681 switch (scf_error()) {
3682 case SCF_ERROR_CONNECTION_BROKEN:
3683 default:
3684 ret = ECONNABORTED;
3685 goto out;
3686
3687 case SCF_ERROR_EXISTS:
3688 break;
3689
3690 case SCF_ERROR_PERMISSION_DENIED:
3691 case SCF_ERROR_BACKEND_ACCESS:
3692 uu_die("Could not create %s: %s\n", SCF_SERVICE_STARTD,
3693 scf_strerror(scf_error()));
3694 /* NOTREACHED */
3695
3696 case SCF_ERROR_BACKEND_READONLY:
3697 log_error(LOG_NOTICE,
3698 "Could not create %s: backend readonly.\n",
3699 SCF_SERVICE_STARTD);
3700 goto out;
3701
3702 case SCF_ERROR_DELETED:
3703 goto add_svc;
3704
3705 case SCF_ERROR_HANDLE_MISMATCH:
3706 case SCF_ERROR_INVALID_ARGUMENT:
3707 case SCF_ERROR_NOT_SET:
3708 bad_error("scf_service_add_instance", scf_error());
3709 }
3710 }
3711
3712 /* Set start time. */
3713 idata.i_fmri = SCF_SERVICE_STARTD;
3714 idata.i_state = RESTARTER_STATE_NONE;
3715 idata.i_next_state = RESTARTER_STATE_NONE;
3716 set_state:
3717 switch (r = _restarter_commit_states(h, &idata,
3718 RESTARTER_STATE_ONLINE, RESTARTER_STATE_NONE,
3719 restarter_get_str_short(restarter_str_insert_in_graph))) {
3720 case 0:
3721 break;
3722
3723 case ENOMEM:
3724 ++count;
3725 if (count < ALLOC_RETRY) {
3726 (void) poll(NULL, 0, msecs);
3727 msecs *= ALLOC_DELAY_MULT;
3728 goto set_state;
3729 }
3730
3731 uu_die("Insufficient memory.\n");
3732 /* NOTREACHED */
3733
3734 case ECONNABORTED:
3735 ret = ECONNABORTED;
3736 goto out;
3737
3738 case ENOENT:
3739 goto add_inst;
3740
3741 case EPERM:
3742 case EACCES:
3743 case EROFS:
3744 uu_warn("Could not timestamp %s: %s\n", idata.i_fmri,
3745 strerror(r));
3746 break;
3747
3748 case EINVAL:
3749 default:
3750 bad_error("_restarter_commit_states", r);
3751 }
3752
3753 /* Set general/enabled. */
3754 ret = libscf_inst_set_boolean_prop(inst, SCF_PG_GENERAL,
3755 SCF_PG_GENERAL_TYPE, SCF_PG_GENERAL_FLAGS, SCF_PROPERTY_ENABLED, 1);
3756 switch (ret) {
3757 case 0:
3758 case ECONNABORTED:
3759 case EPERM:
3760 case EACCES:
3761 case EROFS:
3762 break;
3763
3764 case ECANCELED:
3765 goto add_inst;
3766
3767 default:
3768 bad_error("libscf_inst_set_boolean_prop", ret);
3769 }
3770
3771 ret = libscf_write_start_pid(inst, getpid());
3772 switch (ret) {
3773 case 0:
3774 case ECONNABORTED:
3775 case EPERM:
3776 case EACCES:
3777 case EROFS:
3778 break;
3779
3780 case ECANCELED:
3781 goto add_inst;
3782
3783 default:
3784 bad_error("libscf_write_start_pid", ret);
3785 }
3786
3787 ctid = proc_get_ctid();
3788 if (ctid > 0) {
3789
3790 uint64 = (uint64_t)ctid;
3791 ret = libscf_inst_set_count_prop(inst,
3792 SCF_PG_RESTARTER, SCF_PG_RESTARTER_TYPE,
3793 SCF_PG_RESTARTER_FLAGS, SCF_PROPERTY_CONTRACT, uint64);
3794
3795 switch (ret) {
3796 case 0:
3797 case ECONNABORTED:
3798 case EPERM:
3799 case EACCES:
3800 case EROFS:
3801 break;
3802
3803 case ECANCELED:
3804 goto add_inst;
3805
3806 default:
3807 bad_error("libscf_inst_set_count_prop", ret);
3808 }
3809 }
3810
3811 ret = libscf_note_method_log(inst, LOG_PREFIX_EARLY,
3812 STARTD_DEFAULT_LOG);
3813 if (ret == 0) {
3814 ret = libscf_note_method_log(inst, LOG_PREFIX_NORMAL,
3815 STARTD_DEFAULT_LOG);
3816 }
3817
3818 switch (ret) {
3819 case 0:
3820 case ECONNABORTED:
3821 case EPERM:
3822 case EACCES:
3823 case EROFS:
3824 case EAGAIN:
3825 break;
3826
3827 case ECANCELED:
3828 goto add_inst;
3829
3830 default:
3831 bad_error("libscf_note_method_log", ret);
3832 }
3833
3834 out:
3835 scf_instance_destroy(inst);
3836 scf_service_destroy(svc);
3837 scf_scope_destroy(scope);
3838 return (ret);
3839 }
3840
3841 /*
3842 * Returns
3843 * 0 - success
3844 * ENOENT - SCF_SERVICE_STARTD does not exist in repository
3845 * EPERM
3846 * EACCES
3847 * EROFS
3848 */
3849 int
3850 libscf_set_reconfig(int set)
3851 {
3852 scf_handle_t *h;
3853 scf_instance_t *inst;
3854 scf_propertygroup_t *pg;
3855 int ret = 0;
3856
3857 h = libscf_handle_create_bound_loop();
3858 inst = safe_scf_instance_create(h);
3859 pg = safe_scf_pg_create(h);
3860
3861 again:
3862 if (scf_handle_decode_fmri(h, SCF_SERVICE_STARTD, NULL, NULL,
3863 inst, NULL, NULL, SCF_DECODE_FMRI_EXACT) == -1) {
3864 switch (scf_error()) {
3865 case SCF_ERROR_CONNECTION_BROKEN:
3866 default:
3867 libscf_handle_rebind(h);
3868 goto again;
3869
3870 case SCF_ERROR_NOT_FOUND:
3871 ret = ENOENT;
3872 goto reconfig_out;
3873
3874 case SCF_ERROR_HANDLE_MISMATCH:
3875 case SCF_ERROR_INVALID_ARGUMENT:
3876 case SCF_ERROR_CONSTRAINT_VIOLATED:
3877 bad_error("scf_handle_decode_fmri", scf_error());
3878 }
3879 }
3880
3881 ret = libscf_inst_set_boolean_prop(inst, "system", SCF_GROUP_FRAMEWORK,
3882 SCF_PG_FLAG_NONPERSISTENT, "reconfigure", set);
3883 switch (ret) {
3884 case 0:
3885 case EPERM:
3886 case EACCES:
3887 case EROFS:
3888 break;
3889
3890 case ECONNABORTED:
3891 libscf_handle_rebind(h);
3892 goto again;
3893
3894 case ECANCELED:
3895 ret = ENOENT;
3896 break;
3897
3898 default:
3899 bad_error("libscf_inst_set_boolean_prop", ret);
3900 }
3901
3902 reconfig_out:
3903 scf_pg_destroy(pg);
3904 scf_instance_destroy(inst);
3905 scf_handle_destroy(h);
3906 return (ret);
3907 }
3908
3909 /*
3910 * Set inst->ri_m_inst to the scf instance for inst. If it has been deleted,
3911 * set inst->ri_mi_deleted to true. If the repository connection is broken, it
3912 * is rebound with libscf_handle_rebound().
3913 */
3914 void
3915 libscf_reget_instance(restarter_inst_t *inst)
3916 {
3917 scf_handle_t *h;
3918 int r;
3919
3920 h = scf_instance_handle(inst->ri_m_inst);
3921
3922 again:
3923 r = libscf_lookup_instance(inst->ri_i.i_fmri, inst->ri_m_inst);
3924 switch (r) {
3925 case 0:
3926 case ENOENT:
3927 inst->ri_mi_deleted = (r == ENOENT);
3928 return;
3929
3930 case ECONNABORTED:
3931 libscf_handle_rebind(h);
3932 goto again;
3933
3934 case EINVAL:
3935 case ENOTSUP:
3936 default:
3937 bad_error("libscf_lookup_instance", r);
3938 }
3939 }