17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
55b6c5443Srm * Common Development and Distribution License (the "License").
65b6c5443Srm * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
213eae19d9Swesolows
227c478bd9Sstevel@tonic-gate /*
23f6e214c7SGavin Maltby * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
24a9cdd230SMilan Jurik * Copyright 2012 Milan Jurik. All rights reserved.
25*8fff7887SJohn Levon * Copyright 2020 Joyent, Inc.
267c478bd9Sstevel@tonic-gate */
277c478bd9Sstevel@tonic-gate
287c478bd9Sstevel@tonic-gate
297c478bd9Sstevel@tonic-gate #include <sys/contract/process.h>
307c478bd9Sstevel@tonic-gate #include <assert.h>
317c478bd9Sstevel@tonic-gate #include <errno.h>
327c478bd9Sstevel@tonic-gate #include <libscf.h>
337c478bd9Sstevel@tonic-gate #include <libscf_priv.h>
347c478bd9Sstevel@tonic-gate #include <poll.h>
357c478bd9Sstevel@tonic-gate #include <stdlib.h>
367c478bd9Sstevel@tonic-gate #include <string.h>
377c478bd9Sstevel@tonic-gate #include <unistd.h>
387c478bd9Sstevel@tonic-gate
397c478bd9Sstevel@tonic-gate #include "startd.h"
407c478bd9Sstevel@tonic-gate
417c478bd9Sstevel@tonic-gate #define SMF_SNAPSHOT_RUNNING "running"
427c478bd9Sstevel@tonic-gate
43f6e214c7SGavin Maltby #define INFO_EVENTS_ALL "info_events_all"
44f6e214c7SGavin Maltby
457c478bd9Sstevel@tonic-gate char *
inst_fmri_to_svc_fmri(const char * fmri)467c478bd9Sstevel@tonic-gate inst_fmri_to_svc_fmri(const char *fmri)
477c478bd9Sstevel@tonic-gate {
487c478bd9Sstevel@tonic-gate char *buf, *sfmri;
497c478bd9Sstevel@tonic-gate const char *scope, *svc;
507c478bd9Sstevel@tonic-gate int r;
517c478bd9Sstevel@tonic-gate boolean_t local;
527c478bd9Sstevel@tonic-gate
537c478bd9Sstevel@tonic-gate buf = startd_alloc(max_scf_fmri_size);
547c478bd9Sstevel@tonic-gate sfmri = startd_alloc(max_scf_fmri_size);
557c478bd9Sstevel@tonic-gate
567c478bd9Sstevel@tonic-gate (void) strcpy(buf, fmri);
577c478bd9Sstevel@tonic-gate
587c478bd9Sstevel@tonic-gate r = scf_parse_svc_fmri(buf, &scope, &svc, NULL, NULL, NULL);
597c478bd9Sstevel@tonic-gate assert(r == 0);
607c478bd9Sstevel@tonic-gate
617c478bd9Sstevel@tonic-gate local = strcmp(scope, SCF_SCOPE_LOCAL) == 0;
627c478bd9Sstevel@tonic-gate
637c478bd9Sstevel@tonic-gate (void) snprintf(sfmri, max_scf_fmri_size, "svc:%s%s/%s",
647c478bd9Sstevel@tonic-gate local ? "" : "//", local ? "" : scope, svc);
657c478bd9Sstevel@tonic-gate
667c478bd9Sstevel@tonic-gate startd_free(buf, max_scf_fmri_size);
677c478bd9Sstevel@tonic-gate
687c478bd9Sstevel@tonic-gate return (sfmri);
697c478bd9Sstevel@tonic-gate }
707c478bd9Sstevel@tonic-gate
717c478bd9Sstevel@tonic-gate /*
727c478bd9Sstevel@tonic-gate * Wrapper for the scf_*_create() functions. On SCF_ERROR_NO_MEMORY and
737c478bd9Sstevel@tonic-gate * SCF_ERROR_NO_RESOURCES, retries or dies. So this can only fail with
747c478bd9Sstevel@tonic-gate * SCF_ERROR_INVALID_ARGUMENT, if h is NULL.
757c478bd9Sstevel@tonic-gate */
767c478bd9Sstevel@tonic-gate void *
libscf_object_create(void * f (scf_handle_t *),scf_handle_t * h)777c478bd9Sstevel@tonic-gate libscf_object_create(void *f(scf_handle_t *), scf_handle_t *h)
787c478bd9Sstevel@tonic-gate {
797c478bd9Sstevel@tonic-gate void *o;
807c478bd9Sstevel@tonic-gate uint_t try, msecs;
817c478bd9Sstevel@tonic-gate scf_error_t err;
827c478bd9Sstevel@tonic-gate
837c478bd9Sstevel@tonic-gate o = f(h);
847c478bd9Sstevel@tonic-gate if (o != NULL)
857c478bd9Sstevel@tonic-gate return (o);
867c478bd9Sstevel@tonic-gate err = scf_error();
877c478bd9Sstevel@tonic-gate if (err != SCF_ERROR_NO_MEMORY && err != SCF_ERROR_NO_RESOURCES)
887c478bd9Sstevel@tonic-gate return (NULL);
897c478bd9Sstevel@tonic-gate
907c478bd9Sstevel@tonic-gate msecs = ALLOC_DELAY;
917c478bd9Sstevel@tonic-gate
927c478bd9Sstevel@tonic-gate for (try = 0; try < ALLOC_RETRY; ++try) {
937c478bd9Sstevel@tonic-gate (void) poll(NULL, 0, msecs);
947c478bd9Sstevel@tonic-gate msecs *= ALLOC_DELAY_MULT;
957c478bd9Sstevel@tonic-gate o = f(h);
967c478bd9Sstevel@tonic-gate if (o != NULL)
977c478bd9Sstevel@tonic-gate return (o);
987c478bd9Sstevel@tonic-gate err = scf_error();
997c478bd9Sstevel@tonic-gate if (err != SCF_ERROR_NO_MEMORY && err != SCF_ERROR_NO_RESOURCES)
1007c478bd9Sstevel@tonic-gate return (NULL);
1017c478bd9Sstevel@tonic-gate }
1027c478bd9Sstevel@tonic-gate
1037c478bd9Sstevel@tonic-gate uu_die("Insufficient memory.\n");
1047c478bd9Sstevel@tonic-gate /* NOTREACHED */
1057c478bd9Sstevel@tonic-gate }
1067c478bd9Sstevel@tonic-gate
1077c478bd9Sstevel@tonic-gate scf_snapshot_t *
libscf_get_running_snapshot(scf_instance_t * inst)1087c478bd9Sstevel@tonic-gate libscf_get_running_snapshot(scf_instance_t *inst)
1097c478bd9Sstevel@tonic-gate {
1107c478bd9Sstevel@tonic-gate scf_handle_t *h;
1117c478bd9Sstevel@tonic-gate scf_snapshot_t *snap;
1127c478bd9Sstevel@tonic-gate
1137c478bd9Sstevel@tonic-gate h = scf_instance_handle(inst);
1147c478bd9Sstevel@tonic-gate if (h == NULL)
1157c478bd9Sstevel@tonic-gate return (NULL);
1167c478bd9Sstevel@tonic-gate
1177c478bd9Sstevel@tonic-gate snap = scf_snapshot_create(h);
1187c478bd9Sstevel@tonic-gate if (snap == NULL)
1197c478bd9Sstevel@tonic-gate return (NULL);
1207c478bd9Sstevel@tonic-gate
1217c478bd9Sstevel@tonic-gate if (scf_instance_get_snapshot(inst, SMF_SNAPSHOT_RUNNING, snap) == 0)
1227c478bd9Sstevel@tonic-gate return (snap);
1237c478bd9Sstevel@tonic-gate
1247c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap);
1257c478bd9Sstevel@tonic-gate return (NULL);
1267c478bd9Sstevel@tonic-gate }
1277c478bd9Sstevel@tonic-gate
1287c478bd9Sstevel@tonic-gate /*
1297c478bd9Sstevel@tonic-gate * Make sure a service has a "running" snapshot. If it doesn't, make one from
1307c478bd9Sstevel@tonic-gate * the editing configuration.
1317c478bd9Sstevel@tonic-gate */
1327c478bd9Sstevel@tonic-gate scf_snapshot_t *
libscf_get_or_make_running_snapshot(scf_instance_t * inst,const char * fmri,boolean_t retake)1337c478bd9Sstevel@tonic-gate libscf_get_or_make_running_snapshot(scf_instance_t *inst, const char *fmri,
1347c478bd9Sstevel@tonic-gate boolean_t retake)
1357c478bd9Sstevel@tonic-gate {
1367c478bd9Sstevel@tonic-gate scf_handle_t *h;
1377c478bd9Sstevel@tonic-gate scf_snapshot_t *snap;
1387c478bd9Sstevel@tonic-gate
1397c478bd9Sstevel@tonic-gate h = scf_instance_handle(inst);
1407c478bd9Sstevel@tonic-gate
1417c478bd9Sstevel@tonic-gate snap = scf_snapshot_create(h);
1427c478bd9Sstevel@tonic-gate if (snap == NULL)
1437c478bd9Sstevel@tonic-gate goto err;
1447c478bd9Sstevel@tonic-gate
1457c478bd9Sstevel@tonic-gate if (scf_instance_get_snapshot(inst, SMF_SNAPSHOT_RUNNING, snap) == 0)
1467c478bd9Sstevel@tonic-gate return (snap);
1477c478bd9Sstevel@tonic-gate
1487c478bd9Sstevel@tonic-gate switch (scf_error()) {
1497c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
1507c478bd9Sstevel@tonic-gate break;
1517c478bd9Sstevel@tonic-gate
1527c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
1537c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap);
1547c478bd9Sstevel@tonic-gate return (NULL);
1557c478bd9Sstevel@tonic-gate
1567c478bd9Sstevel@tonic-gate default:
1577c478bd9Sstevel@tonic-gate err:
1587c478bd9Sstevel@tonic-gate log_error(LOG_NOTICE,
1597c478bd9Sstevel@tonic-gate "Could not check for running snapshot of %s (%s).\n", fmri,
1607c478bd9Sstevel@tonic-gate scf_strerror(scf_error()));
1617c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap);
1627c478bd9Sstevel@tonic-gate return (NULL);
1637c478bd9Sstevel@tonic-gate }
1647c478bd9Sstevel@tonic-gate
1657c478bd9Sstevel@tonic-gate if (_scf_snapshot_take_new(inst, SMF_SNAPSHOT_RUNNING, snap) == 0) {
1667c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "Took running snapshot for %s.\n",
1677c478bd9Sstevel@tonic-gate fmri);
1687c478bd9Sstevel@tonic-gate } else {
1697c478bd9Sstevel@tonic-gate if (retake && scf_error() == SCF_ERROR_BACKEND_READONLY)
1707c478bd9Sstevel@tonic-gate restarter_mark_pending_snapshot(fmri,
1717c478bd9Sstevel@tonic-gate RINST_RETAKE_RUNNING);
1727c478bd9Sstevel@tonic-gate else
1737c478bd9Sstevel@tonic-gate log_error(LOG_DEBUG,
1747c478bd9Sstevel@tonic-gate "Could not create running snapshot for %s "
1757c478bd9Sstevel@tonic-gate "(%s).\n", fmri, scf_strerror(scf_error()));
1767c478bd9Sstevel@tonic-gate
1777c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap);
1787c478bd9Sstevel@tonic-gate snap = NULL;
1797c478bd9Sstevel@tonic-gate }
1807c478bd9Sstevel@tonic-gate
1817c478bd9Sstevel@tonic-gate return (snap);
1827c478bd9Sstevel@tonic-gate }
1837c478bd9Sstevel@tonic-gate
1847c478bd9Sstevel@tonic-gate /*
1857c478bd9Sstevel@tonic-gate * When a service comes up, point the "start" snapshot at the "running"
1867c478bd9Sstevel@tonic-gate * snapshot. Returns 0 on success, ENOTSUP if fmri designates something other
1877c478bd9Sstevel@tonic-gate * than an instance, ECONNABORTED, ENOENT if the instance does not exist, or
1887c478bd9Sstevel@tonic-gate * EACCES.
1897c478bd9Sstevel@tonic-gate */
1907c478bd9Sstevel@tonic-gate int
libscf_snapshots_poststart(scf_handle_t * h,const char * fmri,boolean_t retake)1917c478bd9Sstevel@tonic-gate libscf_snapshots_poststart(scf_handle_t *h, const char *fmri, boolean_t retake)
1927c478bd9Sstevel@tonic-gate {
1937c478bd9Sstevel@tonic-gate scf_instance_t *inst = NULL;
1947c478bd9Sstevel@tonic-gate scf_snapshot_t *running, *start = NULL;
1957c478bd9Sstevel@tonic-gate int ret = 0, r;
1967c478bd9Sstevel@tonic-gate
1977c478bd9Sstevel@tonic-gate r = libscf_fmri_get_instance(h, fmri, &inst);
1987c478bd9Sstevel@tonic-gate switch (r) {
1997c478bd9Sstevel@tonic-gate case 0:
2007c478bd9Sstevel@tonic-gate break;
2017c478bd9Sstevel@tonic-gate
2027c478bd9Sstevel@tonic-gate case ENOTSUP:
2037c478bd9Sstevel@tonic-gate case ECONNABORTED:
2047c478bd9Sstevel@tonic-gate case ENOENT:
2057c478bd9Sstevel@tonic-gate return (r);
2067c478bd9Sstevel@tonic-gate
2077c478bd9Sstevel@tonic-gate case EINVAL:
2087c478bd9Sstevel@tonic-gate default:
2097c478bd9Sstevel@tonic-gate assert(0);
2107c478bd9Sstevel@tonic-gate abort();
2117c478bd9Sstevel@tonic-gate }
2127c478bd9Sstevel@tonic-gate
2137c478bd9Sstevel@tonic-gate start = safe_scf_snapshot_create(h);
2147c478bd9Sstevel@tonic-gate
2157c478bd9Sstevel@tonic-gate again:
2167c478bd9Sstevel@tonic-gate running = libscf_get_or_make_running_snapshot(inst, fmri, retake);
2177c478bd9Sstevel@tonic-gate if (running == NULL) {
2187c478bd9Sstevel@tonic-gate ret = 0;
2197c478bd9Sstevel@tonic-gate goto out;
2207c478bd9Sstevel@tonic-gate }
2217c478bd9Sstevel@tonic-gate
2227c478bd9Sstevel@tonic-gate lookup:
2237c478bd9Sstevel@tonic-gate if (scf_instance_get_snapshot(inst, "start", start) != 0) {
2247c478bd9Sstevel@tonic-gate switch (scf_error()) {
2257c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
2267c478bd9Sstevel@tonic-gate default:
2277c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
2287c478bd9Sstevel@tonic-gate goto out;
2297c478bd9Sstevel@tonic-gate
2307c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
2317c478bd9Sstevel@tonic-gate if (_scf_snapshot_take_new(inst, "start", start) != 0) {
2327c478bd9Sstevel@tonic-gate switch (scf_error()) {
2337c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
2347c478bd9Sstevel@tonic-gate default:
2357c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
2367c478bd9Sstevel@tonic-gate goto out;
2377c478bd9Sstevel@tonic-gate
2387c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
2397c478bd9Sstevel@tonic-gate ret = ENOENT;
2407c478bd9Sstevel@tonic-gate goto out;
2417c478bd9Sstevel@tonic-gate
2427c478bd9Sstevel@tonic-gate case SCF_ERROR_EXISTS:
2437c478bd9Sstevel@tonic-gate goto lookup;
2447c478bd9Sstevel@tonic-gate
2457c478bd9Sstevel@tonic-gate case SCF_ERROR_NO_RESOURCES:
2467c478bd9Sstevel@tonic-gate uu_die("Repository server out of "
2477c478bd9Sstevel@tonic-gate "resources.\n");
2487c478bd9Sstevel@tonic-gate /* NOTREACHED */
2497c478bd9Sstevel@tonic-gate
2507c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
2517c478bd9Sstevel@tonic-gate goto readonly;
2527c478bd9Sstevel@tonic-gate
2537c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
2547c478bd9Sstevel@tonic-gate uu_die("Insufficient privileges.\n");
2557c478bd9Sstevel@tonic-gate /* NOTREACHED */
2567c478bd9Sstevel@tonic-gate
2577c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
2587c478bd9Sstevel@tonic-gate ret = EACCES;
2597c478bd9Sstevel@tonic-gate goto out;
2607c478bd9Sstevel@tonic-gate
2617c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
2625b7f77adStw case SCF_ERROR_INTERNAL:
2637c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
2647c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
2657c478bd9Sstevel@tonic-gate bad_error("_scf_snapshot_take_new",
2667c478bd9Sstevel@tonic-gate scf_error());
2677c478bd9Sstevel@tonic-gate }
2687c478bd9Sstevel@tonic-gate }
2697c478bd9Sstevel@tonic-gate break;
2707c478bd9Sstevel@tonic-gate
2717c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
2727c478bd9Sstevel@tonic-gate ret = ENOENT;
2737c478bd9Sstevel@tonic-gate goto out;
2747c478bd9Sstevel@tonic-gate
2757c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
2767c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
2777c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
2787c478bd9Sstevel@tonic-gate bad_error("scf_instance_get_snapshot", scf_error());
2797c478bd9Sstevel@tonic-gate }
2807c478bd9Sstevel@tonic-gate }
2817c478bd9Sstevel@tonic-gate
2827c478bd9Sstevel@tonic-gate if (_scf_snapshot_attach(running, start) == 0) {
2837c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG, "Updated \"start\" snapshot for %s.\n",
2847c478bd9Sstevel@tonic-gate fmri);
2857c478bd9Sstevel@tonic-gate } else {
2867c478bd9Sstevel@tonic-gate switch (scf_error()) {
2877c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
2887c478bd9Sstevel@tonic-gate default:
2897c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
2907c478bd9Sstevel@tonic-gate goto out;
2917c478bd9Sstevel@tonic-gate
2927c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
2937c478bd9Sstevel@tonic-gate scf_snapshot_destroy(running);
2947c478bd9Sstevel@tonic-gate goto again;
2957c478bd9Sstevel@tonic-gate
2967c478bd9Sstevel@tonic-gate case SCF_ERROR_NO_RESOURCES:
2977c478bd9Sstevel@tonic-gate uu_die("Repository server out of resources.\n");
2987c478bd9Sstevel@tonic-gate /* NOTREACHED */
2997c478bd9Sstevel@tonic-gate
3007c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
3017c478bd9Sstevel@tonic-gate uu_die("Insufficient privileges.\n");
3027c478bd9Sstevel@tonic-gate /* NOTREACHED */
3037c478bd9Sstevel@tonic-gate
3047c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
3057c478bd9Sstevel@tonic-gate ret = EACCES;
3067c478bd9Sstevel@tonic-gate goto out;
3077c478bd9Sstevel@tonic-gate
3087c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
3097c478bd9Sstevel@tonic-gate readonly:
3107c478bd9Sstevel@tonic-gate if (retake)
3117c478bd9Sstevel@tonic-gate restarter_mark_pending_snapshot(fmri,
3127c478bd9Sstevel@tonic-gate RINST_RETAKE_START);
3137c478bd9Sstevel@tonic-gate break;
3147c478bd9Sstevel@tonic-gate
3157c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
3167c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
3177c478bd9Sstevel@tonic-gate bad_error("_scf_snapshot_attach", scf_error());
3187c478bd9Sstevel@tonic-gate }
3197c478bd9Sstevel@tonic-gate }
3207c478bd9Sstevel@tonic-gate
3217c478bd9Sstevel@tonic-gate out:
3227c478bd9Sstevel@tonic-gate scf_snapshot_destroy(start);
3237c478bd9Sstevel@tonic-gate scf_snapshot_destroy(running);
3247c478bd9Sstevel@tonic-gate scf_instance_destroy(inst);
3257c478bd9Sstevel@tonic-gate
3267c478bd9Sstevel@tonic-gate return (ret);
3277c478bd9Sstevel@tonic-gate }
3287c478bd9Sstevel@tonic-gate
3297c478bd9Sstevel@tonic-gate /*
3307c478bd9Sstevel@tonic-gate * Before a refresh, update the "running" snapshot from the editing
3317c478bd9Sstevel@tonic-gate * configuration.
3327c478bd9Sstevel@tonic-gate *
3337c478bd9Sstevel@tonic-gate * Returns 0 on success and -1 on failure.
3347c478bd9Sstevel@tonic-gate */
3357c478bd9Sstevel@tonic-gate int
libscf_snapshots_refresh(scf_instance_t * inst,const char * fmri)3367c478bd9Sstevel@tonic-gate libscf_snapshots_refresh(scf_instance_t *inst, const char *fmri)
3377c478bd9Sstevel@tonic-gate {
3387c478bd9Sstevel@tonic-gate scf_handle_t *h;
3397c478bd9Sstevel@tonic-gate scf_snapshot_t *snap;
3407c478bd9Sstevel@tonic-gate boolean_t err = 1;
3417c478bd9Sstevel@tonic-gate
3427c478bd9Sstevel@tonic-gate h = scf_instance_handle(inst);
3437c478bd9Sstevel@tonic-gate if (h == NULL)
3447c478bd9Sstevel@tonic-gate goto out;
3457c478bd9Sstevel@tonic-gate
3467c478bd9Sstevel@tonic-gate snap = scf_snapshot_create(h);
3477c478bd9Sstevel@tonic-gate if (snap == NULL)
3487c478bd9Sstevel@tonic-gate goto out;
3497c478bd9Sstevel@tonic-gate
3507c478bd9Sstevel@tonic-gate if (scf_instance_get_snapshot(inst, SMF_SNAPSHOT_RUNNING, snap) == 0) {
3517c478bd9Sstevel@tonic-gate if (_scf_snapshot_take_attach(inst, snap) == 0)
3527c478bd9Sstevel@tonic-gate err = 0;
3537c478bd9Sstevel@tonic-gate } else {
3547c478bd9Sstevel@tonic-gate switch (scf_error()) {
3557c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
3567c478bd9Sstevel@tonic-gate err = 0;
3577c478bd9Sstevel@tonic-gate goto out;
3587c478bd9Sstevel@tonic-gate
3597c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
3607c478bd9Sstevel@tonic-gate break;
3617c478bd9Sstevel@tonic-gate
3627c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
3637c478bd9Sstevel@tonic-gate assert(0);
3647c478bd9Sstevel@tonic-gate abort();
3657c478bd9Sstevel@tonic-gate /* NOTREACHED */
3667c478bd9Sstevel@tonic-gate
3677c478bd9Sstevel@tonic-gate default:
3687c478bd9Sstevel@tonic-gate goto out;
3697c478bd9Sstevel@tonic-gate }
3707c478bd9Sstevel@tonic-gate
3717c478bd9Sstevel@tonic-gate log_error(LOG_DEBUG,
3727c478bd9Sstevel@tonic-gate "Service %s has no %s snapshot; creating one.\n", fmri,
3737c478bd9Sstevel@tonic-gate SMF_SNAPSHOT_RUNNING);
3747c478bd9Sstevel@tonic-gate
3757c478bd9Sstevel@tonic-gate if (_scf_snapshot_take_new(inst, SMF_SNAPSHOT_RUNNING,
3767c478bd9Sstevel@tonic-gate snap) == 0)
3777c478bd9Sstevel@tonic-gate err = 0;
3787c478bd9Sstevel@tonic-gate }
3797c478bd9Sstevel@tonic-gate
3807c478bd9Sstevel@tonic-gate out:
3817c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap);
3827c478bd9Sstevel@tonic-gate
3837c478bd9Sstevel@tonic-gate if (!err)
3847c478bd9Sstevel@tonic-gate return (0);
3857c478bd9Sstevel@tonic-gate
3867c478bd9Sstevel@tonic-gate log_error(LOG_WARNING,
3877c478bd9Sstevel@tonic-gate "Could not update \"running\" snapshot for refresh of %s.\n", fmri);
3887c478bd9Sstevel@tonic-gate return (-1);
3897c478bd9Sstevel@tonic-gate }
3907c478bd9Sstevel@tonic-gate
3917c478bd9Sstevel@tonic-gate /*
3927c478bd9Sstevel@tonic-gate * int libscf_read_single_astring()
3937c478bd9Sstevel@tonic-gate * Reads a single astring value of the requested property into the
3947c478bd9Sstevel@tonic-gate * pre-allocated buffer (conventionally of size max_scf_value_size).
3957c478bd9Sstevel@tonic-gate * Multiple values constitute an error.
3967c478bd9Sstevel@tonic-gate *
3977c478bd9Sstevel@tonic-gate * Returns 0 on success or LIBSCF_PROPERTY_ABSENT or LIBSCF_PROPERTY_ERROR.
3987c478bd9Sstevel@tonic-gate */
3997c478bd9Sstevel@tonic-gate static int
libscf_read_single_astring(scf_handle_t * h,scf_property_t * prop,char ** ret)4007c478bd9Sstevel@tonic-gate libscf_read_single_astring(scf_handle_t *h, scf_property_t *prop, char **ret)
4017c478bd9Sstevel@tonic-gate {
4027c478bd9Sstevel@tonic-gate scf_value_t *val = safe_scf_value_create(h);
4037c478bd9Sstevel@tonic-gate int r = 0;
4047c478bd9Sstevel@tonic-gate
4057c478bd9Sstevel@tonic-gate if (scf_property_get_value(prop, val) == -1) {
4067c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_NOT_FOUND)
4077c478bd9Sstevel@tonic-gate r = LIBSCF_PROPERTY_ABSENT;
4087c478bd9Sstevel@tonic-gate else
4097c478bd9Sstevel@tonic-gate r = LIBSCF_PROPERTY_ERROR;
4107c478bd9Sstevel@tonic-gate goto read_single_astring_fail;
4117c478bd9Sstevel@tonic-gate }
4127c478bd9Sstevel@tonic-gate
4137c478bd9Sstevel@tonic-gate if (scf_value_get_astring(val, *ret, max_scf_value_size) <= 0) {
4147c478bd9Sstevel@tonic-gate r = LIBSCF_PROPERTY_ERROR;
4157c478bd9Sstevel@tonic-gate goto read_single_astring_fail;
4167c478bd9Sstevel@tonic-gate }
4177c478bd9Sstevel@tonic-gate
4187c478bd9Sstevel@tonic-gate read_single_astring_fail:
4197c478bd9Sstevel@tonic-gate scf_value_destroy(val);
4207c478bd9Sstevel@tonic-gate return (r);
4217c478bd9Sstevel@tonic-gate }
4227c478bd9Sstevel@tonic-gate
423f6e214c7SGavin Maltby /*
424f6e214c7SGavin Maltby * libscf_get_stn_tset
425f6e214c7SGavin Maltby */
426f6e214c7SGavin Maltby int32_t
libscf_get_stn_tset(scf_instance_t * inst)427f6e214c7SGavin Maltby libscf_get_stn_tset(scf_instance_t *inst)
428f6e214c7SGavin Maltby {
429f6e214c7SGavin Maltby scf_handle_t *h = scf_instance_handle(inst);
430f6e214c7SGavin Maltby scf_propertygroup_t *pg = scf_pg_create(h);
431f6e214c7SGavin Maltby char *pgname = NULL;
432f6e214c7SGavin Maltby int32_t t, f, tset;
433f6e214c7SGavin Maltby
434f6e214c7SGavin Maltby assert(inst != NULL);
435f6e214c7SGavin Maltby
436f6e214c7SGavin Maltby pgname = startd_alloc(max_scf_fmri_size);
437f6e214c7SGavin Maltby if (h == NULL || pg == NULL) {
438f6e214c7SGavin Maltby tset = -1;
439f6e214c7SGavin Maltby goto cleanup;
440f6e214c7SGavin Maltby }
441f6e214c7SGavin Maltby
442f6e214c7SGavin Maltby for (tset = 0, t = 1; t < SCF_STATE_ALL; t <<= 1) {
443f6e214c7SGavin Maltby f = t << 16;
444f6e214c7SGavin Maltby
445f6e214c7SGavin Maltby (void) strcpy(pgname, SCF_STN_PREFIX_TO);
446f6e214c7SGavin Maltby (void) strlcat(pgname, smf_state_to_string(t),
447f6e214c7SGavin Maltby max_scf_fmri_size);
448f6e214c7SGavin Maltby
449f6e214c7SGavin Maltby if (scf_instance_get_pg_composed(inst, NULL, pgname, pg) ==
450f6e214c7SGavin Maltby SCF_SUCCESS) {
451f6e214c7SGavin Maltby tset |= t;
452f6e214c7SGavin Maltby } else if (scf_error() != SCF_ERROR_NOT_FOUND && scf_error() !=
453f6e214c7SGavin Maltby SCF_ERROR_DELETED) {
454f6e214c7SGavin Maltby tset = -1;
455f6e214c7SGavin Maltby goto cleanup;
456f6e214c7SGavin Maltby }
457f6e214c7SGavin Maltby
458f6e214c7SGavin Maltby (void) strcpy(pgname, SCF_STN_PREFIX_FROM);
459f6e214c7SGavin Maltby (void) strlcat(pgname, smf_state_to_string(t),
460f6e214c7SGavin Maltby max_scf_fmri_size);
461f6e214c7SGavin Maltby
462f6e214c7SGavin Maltby if (scf_instance_get_pg_composed(inst, NULL, pgname, pg) ==
463f6e214c7SGavin Maltby SCF_SUCCESS) {
464f6e214c7SGavin Maltby tset |= f;
465f6e214c7SGavin Maltby } else if (scf_error() != SCF_ERROR_NOT_FOUND && scf_error() !=
466f6e214c7SGavin Maltby SCF_ERROR_DELETED) {
467f6e214c7SGavin Maltby tset = -1;
468f6e214c7SGavin Maltby goto cleanup;
469f6e214c7SGavin Maltby }
470f6e214c7SGavin Maltby }
471f6e214c7SGavin Maltby
472f6e214c7SGavin Maltby cleanup:
473f6e214c7SGavin Maltby scf_pg_destroy(pg);
474f6e214c7SGavin Maltby startd_free(pgname, max_scf_fmri_size);
475f6e214c7SGavin Maltby
476f6e214c7SGavin Maltby return (tset);
477f6e214c7SGavin Maltby }
478f6e214c7SGavin Maltby
479f6e214c7SGavin Maltby static int32_t
libscf_get_global_stn_tset(scf_handle_t * h)480f6e214c7SGavin Maltby libscf_get_global_stn_tset(scf_handle_t *h)
481f6e214c7SGavin Maltby {
482f6e214c7SGavin Maltby scf_instance_t *inst = scf_instance_create(h);
483f6e214c7SGavin Maltby int32_t tset = -1;
484f6e214c7SGavin Maltby
485f6e214c7SGavin Maltby if (inst == NULL) {
486f6e214c7SGavin Maltby goto cleanup;
487f6e214c7SGavin Maltby }
488f6e214c7SGavin Maltby
489f6e214c7SGavin Maltby if (scf_handle_decode_fmri(h, SCF_INSTANCE_GLOBAL, NULL, NULL, inst,
490f6e214c7SGavin Maltby NULL, NULL, SCF_DECODE_FMRI_REQUIRE_INSTANCE) != 0) {
491f6e214c7SGavin Maltby goto cleanup;
492f6e214c7SGavin Maltby }
493f6e214c7SGavin Maltby
494f6e214c7SGavin Maltby tset = libscf_get_stn_tset(inst);
495f6e214c7SGavin Maltby
496f6e214c7SGavin Maltby cleanup:
497f6e214c7SGavin Maltby scf_instance_destroy(inst);
498f6e214c7SGavin Maltby
499f6e214c7SGavin Maltby if (tset == -1)
500f6e214c7SGavin Maltby log_framework(LOG_WARNING,
501f6e214c7SGavin Maltby "Failed to get system wide notification parameters: %s\n",
502f6e214c7SGavin Maltby scf_strerror(scf_error()));
503f6e214c7SGavin Maltby
504f6e214c7SGavin Maltby return (tset);
505f6e214c7SGavin Maltby }
506f6e214c7SGavin Maltby
5077c478bd9Sstevel@tonic-gate static int
libscf_read_state(const scf_propertygroup_t * pg,const char * prop_name,restarter_instance_state_t * state)5087c478bd9Sstevel@tonic-gate libscf_read_state(const scf_propertygroup_t *pg, const char *prop_name,
5097c478bd9Sstevel@tonic-gate restarter_instance_state_t *state)
5107c478bd9Sstevel@tonic-gate {
5117c478bd9Sstevel@tonic-gate scf_handle_t *h;
5127c478bd9Sstevel@tonic-gate scf_property_t *prop;
5137c478bd9Sstevel@tonic-gate char *char_state = startd_alloc(max_scf_value_size);
5147c478bd9Sstevel@tonic-gate int ret = 0;
5157c478bd9Sstevel@tonic-gate
5167c478bd9Sstevel@tonic-gate h = scf_pg_handle(pg);
5177c478bd9Sstevel@tonic-gate prop = safe_scf_property_create(h);
5187c478bd9Sstevel@tonic-gate
5197c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, prop_name, prop) == -1) {
5207c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_NOT_FOUND)
5217c478bd9Sstevel@tonic-gate ret = LIBSCF_PROPERTY_ABSENT;
5227c478bd9Sstevel@tonic-gate else
5237c478bd9Sstevel@tonic-gate ret = LIBSCF_PROPERTY_ERROR;
5247c478bd9Sstevel@tonic-gate } else {
5257c478bd9Sstevel@tonic-gate ret = libscf_read_single_astring(h, prop, &char_state);
5267c478bd9Sstevel@tonic-gate if (ret != 0) {
5277c478bd9Sstevel@tonic-gate if (ret != LIBSCF_PROPERTY_ABSENT)
5287c478bd9Sstevel@tonic-gate ret = LIBSCF_PROPERTY_ERROR;
5297c478bd9Sstevel@tonic-gate } else {
5307c478bd9Sstevel@tonic-gate *state = restarter_string_to_state(char_state);
5317c478bd9Sstevel@tonic-gate ret = 0;
5327c478bd9Sstevel@tonic-gate }
5337c478bd9Sstevel@tonic-gate }
5347c478bd9Sstevel@tonic-gate
5357c478bd9Sstevel@tonic-gate startd_free(char_state, max_scf_value_size);
5367c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
5377c478bd9Sstevel@tonic-gate return (ret);
5387c478bd9Sstevel@tonic-gate }
5397c478bd9Sstevel@tonic-gate
5407c478bd9Sstevel@tonic-gate /*
5417c478bd9Sstevel@tonic-gate * int libscf_read_states(const scf_propertygroup_t *,
5427c478bd9Sstevel@tonic-gate * restarter_instance_state_t *, restarter_instance_state_t *)
5437c478bd9Sstevel@tonic-gate *
5447c478bd9Sstevel@tonic-gate * Set the current state and next_state values for the given service instance.
5457c478bd9Sstevel@tonic-gate * Returns 0 on success, or a libscf error code on failure.
5467c478bd9Sstevel@tonic-gate */
5477c478bd9Sstevel@tonic-gate int
libscf_read_states(const scf_propertygroup_t * pg,restarter_instance_state_t * state,restarter_instance_state_t * next_state)5487c478bd9Sstevel@tonic-gate libscf_read_states(const scf_propertygroup_t *pg,
5497c478bd9Sstevel@tonic-gate restarter_instance_state_t *state, restarter_instance_state_t *next_state)
5507c478bd9Sstevel@tonic-gate {
5517c478bd9Sstevel@tonic-gate int state_ret, next_state_ret, ret;
5527c478bd9Sstevel@tonic-gate
5537c478bd9Sstevel@tonic-gate state_ret = libscf_read_state(pg, SCF_PROPERTY_STATE, state);
5547c478bd9Sstevel@tonic-gate next_state_ret = libscf_read_state(pg, SCF_PROPERTY_NEXT_STATE,
5557c478bd9Sstevel@tonic-gate next_state);
5567c478bd9Sstevel@tonic-gate
5577c478bd9Sstevel@tonic-gate if (state_ret == LIBSCF_PROPERTY_ERROR ||
5587c478bd9Sstevel@tonic-gate next_state_ret == LIBSCF_PROPERTY_ERROR) {
5597c478bd9Sstevel@tonic-gate ret = LIBSCF_PROPERTY_ERROR;
5607c478bd9Sstevel@tonic-gate } else if (state_ret == 0 && next_state_ret == 0) {
5617c478bd9Sstevel@tonic-gate ret = 0;
5627c478bd9Sstevel@tonic-gate } else if (state_ret == LIBSCF_PROPERTY_ABSENT &&
5637c478bd9Sstevel@tonic-gate next_state_ret == LIBSCF_PROPERTY_ABSENT) {
5647c478bd9Sstevel@tonic-gate *state = RESTARTER_STATE_UNINIT;
5657c478bd9Sstevel@tonic-gate *next_state = RESTARTER_STATE_NONE;
5667c478bd9Sstevel@tonic-gate ret = 0;
5677c478bd9Sstevel@tonic-gate } else if (state_ret == LIBSCF_PROPERTY_ABSENT ||
5687c478bd9Sstevel@tonic-gate next_state_ret == LIBSCF_PROPERTY_ABSENT) {
5697c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG,
5707c478bd9Sstevel@tonic-gate "Only one repository state exists, setting "
5717c478bd9Sstevel@tonic-gate "restarter states to MAINTENANCE and NONE\n");
5727c478bd9Sstevel@tonic-gate *state = RESTARTER_STATE_MAINT;
5737c478bd9Sstevel@tonic-gate *next_state = RESTARTER_STATE_NONE;
5747c478bd9Sstevel@tonic-gate ret = 0;
5757c478bd9Sstevel@tonic-gate } else {
5767c478bd9Sstevel@tonic-gate ret = LIBSCF_PROPERTY_ERROR;
5777c478bd9Sstevel@tonic-gate }
5787c478bd9Sstevel@tonic-gate
5797c478bd9Sstevel@tonic-gate read_states_out:
5807c478bd9Sstevel@tonic-gate return (ret);
5817c478bd9Sstevel@tonic-gate }
5827c478bd9Sstevel@tonic-gate
5837c478bd9Sstevel@tonic-gate /*
5847c478bd9Sstevel@tonic-gate * depgroup_empty()
5857c478bd9Sstevel@tonic-gate *
5867c478bd9Sstevel@tonic-gate * Returns 0 if not empty.
5877c478bd9Sstevel@tonic-gate * Returns 1 if empty.
5887c478bd9Sstevel@tonic-gate * Returns -1 on error (check scf_error()).
5897c478bd9Sstevel@tonic-gate */
5907c478bd9Sstevel@tonic-gate int
depgroup_empty(scf_handle_t * h,scf_propertygroup_t * pg)5917c478bd9Sstevel@tonic-gate depgroup_empty(scf_handle_t *h, scf_propertygroup_t *pg)
5927c478bd9Sstevel@tonic-gate {
5937c478bd9Sstevel@tonic-gate int empty = 1;
5947c478bd9Sstevel@tonic-gate scf_iter_t *iter;
5957c478bd9Sstevel@tonic-gate scf_property_t *prop;
5967c478bd9Sstevel@tonic-gate int ret;
5977c478bd9Sstevel@tonic-gate
5987c478bd9Sstevel@tonic-gate iter = safe_scf_iter_create(h);
5997c478bd9Sstevel@tonic-gate prop = safe_scf_property_create(h);
6007c478bd9Sstevel@tonic-gate
6015b6c5443Srm if (scf_iter_pg_properties(iter, pg) != SCF_SUCCESS) {
6025b6c5443Srm scf_property_destroy(prop);
6035b6c5443Srm scf_iter_destroy(iter);
6047c478bd9Sstevel@tonic-gate return (-1);
6055b6c5443Srm }
6067c478bd9Sstevel@tonic-gate
6077c478bd9Sstevel@tonic-gate ret = scf_iter_next_property(iter, prop);
6085b6c5443Srm if (ret < 0) {
6095b6c5443Srm scf_property_destroy(prop);
6105b6c5443Srm scf_iter_destroy(iter);
6117c478bd9Sstevel@tonic-gate return (-1);
6125b6c5443Srm }
6137c478bd9Sstevel@tonic-gate
6147c478bd9Sstevel@tonic-gate if (ret == 1)
6157c478bd9Sstevel@tonic-gate empty = 0;
6167c478bd9Sstevel@tonic-gate
6177c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
6187c478bd9Sstevel@tonic-gate scf_iter_destroy(iter);
6197c478bd9Sstevel@tonic-gate
6207c478bd9Sstevel@tonic-gate return (empty);
6217c478bd9Sstevel@tonic-gate }
6227c478bd9Sstevel@tonic-gate
6237c478bd9Sstevel@tonic-gate gv_type_t
depgroup_read_scheme(scf_handle_t * h,scf_propertygroup_t * pg)6247c478bd9Sstevel@tonic-gate depgroup_read_scheme(scf_handle_t *h, scf_propertygroup_t *pg)
6257c478bd9Sstevel@tonic-gate {
6267c478bd9Sstevel@tonic-gate scf_property_t *prop;
6277c478bd9Sstevel@tonic-gate char *scheme = startd_alloc(max_scf_value_size);
6287c478bd9Sstevel@tonic-gate gv_type_t ret;
6297c478bd9Sstevel@tonic-gate
6307c478bd9Sstevel@tonic-gate prop = safe_scf_property_create(h);
6317c478bd9Sstevel@tonic-gate
6327c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, SCF_PROPERTY_TYPE, prop) == -1 ||
6337c478bd9Sstevel@tonic-gate libscf_read_single_astring(h, prop, &scheme) != 0) {
6347c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
6357c478bd9Sstevel@tonic-gate startd_free(scheme, max_scf_value_size);
6367c478bd9Sstevel@tonic-gate return (GVT_UNSUPPORTED);
6377c478bd9Sstevel@tonic-gate }
6387c478bd9Sstevel@tonic-gate
6397c478bd9Sstevel@tonic-gate if (strcmp(scheme, "service") == 0)
6407c478bd9Sstevel@tonic-gate ret = GVT_INST;
6417c478bd9Sstevel@tonic-gate else if (strcmp(scheme, "path") == 0)
6427c478bd9Sstevel@tonic-gate ret = GVT_FILE;
6437c478bd9Sstevel@tonic-gate else
6447c478bd9Sstevel@tonic-gate ret = GVT_UNSUPPORTED;
6457c478bd9Sstevel@tonic-gate
6467c478bd9Sstevel@tonic-gate startd_free(scheme, max_scf_value_size);
6477c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
6487c478bd9Sstevel@tonic-gate return (ret);
6497c478bd9Sstevel@tonic-gate }
6507c478bd9Sstevel@tonic-gate
6517c478bd9Sstevel@tonic-gate depgroup_type_t
depgroup_read_grouping(scf_handle_t * h,scf_propertygroup_t * pg)6527c478bd9Sstevel@tonic-gate depgroup_read_grouping(scf_handle_t *h, scf_propertygroup_t *pg)
6537c478bd9Sstevel@tonic-gate {
6547c478bd9Sstevel@tonic-gate char *grouping = startd_alloc(max_scf_value_size);
6557c478bd9Sstevel@tonic-gate depgroup_type_t ret;
6567c478bd9Sstevel@tonic-gate scf_property_t *prop = safe_scf_property_create(h);
6577c478bd9Sstevel@tonic-gate
6587c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, SCF_PROPERTY_GROUPING, prop) == -1 ||
6597c478bd9Sstevel@tonic-gate libscf_read_single_astring(h, prop, &grouping) != 0) {
6607c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
6617c478bd9Sstevel@tonic-gate startd_free(grouping, max_scf_value_size);
6627c478bd9Sstevel@tonic-gate return (DEPGRP_UNSUPPORTED);
6637c478bd9Sstevel@tonic-gate }
6647c478bd9Sstevel@tonic-gate
6657c478bd9Sstevel@tonic-gate if (strcmp(grouping, SCF_DEP_REQUIRE_ANY) == 0)
6667c478bd9Sstevel@tonic-gate ret = DEPGRP_REQUIRE_ANY;
6677c478bd9Sstevel@tonic-gate else if (strcmp(grouping, SCF_DEP_REQUIRE_ALL) == 0)
6687c478bd9Sstevel@tonic-gate ret = DEPGRP_REQUIRE_ALL;
6697c478bd9Sstevel@tonic-gate else if (strcmp(grouping, SCF_DEP_OPTIONAL_ALL) == 0)
6707c478bd9Sstevel@tonic-gate ret = DEPGRP_OPTIONAL_ALL;
6717c478bd9Sstevel@tonic-gate else if (strcmp(grouping, SCF_DEP_EXCLUDE_ALL) == 0)
6727c478bd9Sstevel@tonic-gate ret = DEPGRP_EXCLUDE_ALL;
6737c478bd9Sstevel@tonic-gate else {
6747c478bd9Sstevel@tonic-gate ret = DEPGRP_UNSUPPORTED;
6757c478bd9Sstevel@tonic-gate }
6767c478bd9Sstevel@tonic-gate startd_free(grouping, max_scf_value_size);
6777c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
6787c478bd9Sstevel@tonic-gate return (ret);
6797c478bd9Sstevel@tonic-gate }
6807c478bd9Sstevel@tonic-gate
6817c478bd9Sstevel@tonic-gate restarter_error_t
depgroup_read_restart(scf_handle_t * h,scf_propertygroup_t * pg)6827c478bd9Sstevel@tonic-gate depgroup_read_restart(scf_handle_t *h, scf_propertygroup_t *pg)
6837c478bd9Sstevel@tonic-gate {
6847c478bd9Sstevel@tonic-gate scf_property_t *prop = safe_scf_property_create(h);
6857c478bd9Sstevel@tonic-gate char *restart_on = startd_alloc(max_scf_value_size);
6867c478bd9Sstevel@tonic-gate restarter_error_t ret;
6877c478bd9Sstevel@tonic-gate
6887c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, SCF_PROPERTY_RESTART_ON, prop) == -1 ||
6897c478bd9Sstevel@tonic-gate libscf_read_single_astring(h, prop, &restart_on) != 0) {
6907c478bd9Sstevel@tonic-gate startd_free(restart_on, max_scf_value_size);
6917c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
6927c478bd9Sstevel@tonic-gate return (RERR_UNSUPPORTED);
6937c478bd9Sstevel@tonic-gate }
6947c478bd9Sstevel@tonic-gate
6957c478bd9Sstevel@tonic-gate if (strcmp(restart_on, SCF_DEP_RESET_ON_ERROR) == 0)
6967c478bd9Sstevel@tonic-gate ret = RERR_FAULT;
6977c478bd9Sstevel@tonic-gate else if (strcmp(restart_on, SCF_DEP_RESET_ON_RESTART) == 0)
6987c478bd9Sstevel@tonic-gate ret = RERR_RESTART;
6997c478bd9Sstevel@tonic-gate else if (strcmp(restart_on, SCF_DEP_RESET_ON_REFRESH) == 0)
7007c478bd9Sstevel@tonic-gate ret = RERR_REFRESH;
7017c478bd9Sstevel@tonic-gate else if (strcmp(restart_on, SCF_DEP_RESET_ON_NONE) == 0)
7027c478bd9Sstevel@tonic-gate ret = RERR_NONE;
7037c478bd9Sstevel@tonic-gate else
7047c478bd9Sstevel@tonic-gate ret = RERR_UNSUPPORTED;
7057c478bd9Sstevel@tonic-gate
7067c478bd9Sstevel@tonic-gate startd_free(restart_on, max_scf_value_size);
7077c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
7087c478bd9Sstevel@tonic-gate return (ret);
7097c478bd9Sstevel@tonic-gate }
7107c478bd9Sstevel@tonic-gate
7117c478bd9Sstevel@tonic-gate /*
7127c478bd9Sstevel@tonic-gate * int get_boolean()
7137c478bd9Sstevel@tonic-gate * Fetches the value of a boolean property of the given property group.
7147c478bd9Sstevel@tonic-gate * Returns
7157c478bd9Sstevel@tonic-gate * 0 - success
7167c478bd9Sstevel@tonic-gate * ECONNABORTED - repository connection broken
7177c478bd9Sstevel@tonic-gate * ECANCELED - pg was deleted
7187c478bd9Sstevel@tonic-gate * ENOENT - the property doesn't exist or has no values
7197c478bd9Sstevel@tonic-gate * EINVAL - the property has the wrong type
7207c478bd9Sstevel@tonic-gate * the property is not single-valued
7213eae19d9Swesolows * EACCES - the current user does not have permission to read the value
7227c478bd9Sstevel@tonic-gate */
7237c478bd9Sstevel@tonic-gate static int
get_boolean(scf_propertygroup_t * pg,const char * propname,uint8_t * valuep)7247c478bd9Sstevel@tonic-gate get_boolean(scf_propertygroup_t *pg, const char *propname, uint8_t *valuep)
7257c478bd9Sstevel@tonic-gate {
7267c478bd9Sstevel@tonic-gate scf_handle_t *h;
7277c478bd9Sstevel@tonic-gate scf_property_t *prop;
7287c478bd9Sstevel@tonic-gate scf_value_t *val;
7297c478bd9Sstevel@tonic-gate int ret = 0, r;
7307c478bd9Sstevel@tonic-gate scf_type_t type;
7317c478bd9Sstevel@tonic-gate
7327c478bd9Sstevel@tonic-gate h = scf_pg_handle(pg);
7337c478bd9Sstevel@tonic-gate prop = safe_scf_property_create(h);
7347c478bd9Sstevel@tonic-gate val = safe_scf_value_create(h);
7357c478bd9Sstevel@tonic-gate
7367c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, propname, prop) != 0) {
7377c478bd9Sstevel@tonic-gate switch (scf_error()) {
7387c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
7397c478bd9Sstevel@tonic-gate default:
7407c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
7417c478bd9Sstevel@tonic-gate goto out;
7427c478bd9Sstevel@tonic-gate
7437c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
7447c478bd9Sstevel@tonic-gate ret = ECANCELED;
7457c478bd9Sstevel@tonic-gate goto out;
7467c478bd9Sstevel@tonic-gate
7477c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
7487c478bd9Sstevel@tonic-gate ret = ENOENT;
7497c478bd9Sstevel@tonic-gate goto out;
7507c478bd9Sstevel@tonic-gate
7517c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
7527c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
7537c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
7547c478bd9Sstevel@tonic-gate bad_error("scf_pg_get_property", scf_error());
7557c478bd9Sstevel@tonic-gate }
7567c478bd9Sstevel@tonic-gate }
7577c478bd9Sstevel@tonic-gate
7587c478bd9Sstevel@tonic-gate if (scf_property_type(prop, &type) != 0) {
7597c478bd9Sstevel@tonic-gate switch (scf_error()) {
7607c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
7617c478bd9Sstevel@tonic-gate default:
7627c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
7637c478bd9Sstevel@tonic-gate goto out;
7647c478bd9Sstevel@tonic-gate
7657c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
7667c478bd9Sstevel@tonic-gate ret = ENOENT;
7677c478bd9Sstevel@tonic-gate goto out;
7687c478bd9Sstevel@tonic-gate
7697c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
7707c478bd9Sstevel@tonic-gate bad_error("scf_property_type", scf_error());
7717c478bd9Sstevel@tonic-gate }
7727c478bd9Sstevel@tonic-gate }
7737c478bd9Sstevel@tonic-gate
7747c478bd9Sstevel@tonic-gate if (type != SCF_TYPE_BOOLEAN) {
7757c478bd9Sstevel@tonic-gate ret = EINVAL;
7767c478bd9Sstevel@tonic-gate goto out;
7777c478bd9Sstevel@tonic-gate }
7787c478bd9Sstevel@tonic-gate
7797c478bd9Sstevel@tonic-gate if (scf_property_get_value(prop, val) != 0) {
7807c478bd9Sstevel@tonic-gate switch (scf_error()) {
7817c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
7827c478bd9Sstevel@tonic-gate default:
7837c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
7847c478bd9Sstevel@tonic-gate goto out;
7857c478bd9Sstevel@tonic-gate
7867c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
7877c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
7887c478bd9Sstevel@tonic-gate ret = ENOENT;
7897c478bd9Sstevel@tonic-gate goto out;
7907c478bd9Sstevel@tonic-gate
7917c478bd9Sstevel@tonic-gate case SCF_ERROR_CONSTRAINT_VIOLATED:
7927c478bd9Sstevel@tonic-gate ret = EINVAL;
7937c478bd9Sstevel@tonic-gate goto out;
7947c478bd9Sstevel@tonic-gate
7953eae19d9Swesolows case SCF_ERROR_PERMISSION_DENIED:
7963eae19d9Swesolows ret = EACCES;
7973eae19d9Swesolows goto out;
7983eae19d9Swesolows
7997c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
8007c478bd9Sstevel@tonic-gate bad_error("scf_property_get_value", scf_error());
8017c478bd9Sstevel@tonic-gate }
8027c478bd9Sstevel@tonic-gate }
8037c478bd9Sstevel@tonic-gate
8047c478bd9Sstevel@tonic-gate r = scf_value_get_boolean(val, valuep);
8057c478bd9Sstevel@tonic-gate assert(r == 0);
8067c478bd9Sstevel@tonic-gate
8077c478bd9Sstevel@tonic-gate out:
8087c478bd9Sstevel@tonic-gate scf_value_destroy(val);
8097c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
8107c478bd9Sstevel@tonic-gate return (ret);
8117c478bd9Sstevel@tonic-gate }
8127c478bd9Sstevel@tonic-gate
813f6e214c7SGavin Maltby /*
814f6e214c7SGavin Maltby * get info event property from restarter:default
815f6e214c7SGavin Maltby */
816f6e214c7SGavin Maltby int
libscf_get_info_events_all(scf_propertygroup_t * pg)817f6e214c7SGavin Maltby libscf_get_info_events_all(scf_propertygroup_t *pg)
818f6e214c7SGavin Maltby {
819f6e214c7SGavin Maltby uint8_t v;
820f6e214c7SGavin Maltby int r = 0;
821f6e214c7SGavin Maltby
822f6e214c7SGavin Maltby if (get_boolean(pg, INFO_EVENTS_ALL, &v) == 0) {
823f6e214c7SGavin Maltby r = v;
824f6e214c7SGavin Maltby } else if (scf_error() != SCF_ERROR_NOT_FOUND) {
825f6e214c7SGavin Maltby uu_warn("Failed get_boolean %s/%s: %s\n",
826f6e214c7SGavin Maltby SCF_PG_OPTIONS, INFO_EVENTS_ALL,
827f6e214c7SGavin Maltby scf_strerror(scf_error()));
828f6e214c7SGavin Maltby }
829f6e214c7SGavin Maltby
830f6e214c7SGavin Maltby return (r);
831f6e214c7SGavin Maltby }
832f6e214c7SGavin Maltby
8337c478bd9Sstevel@tonic-gate /*
8347c478bd9Sstevel@tonic-gate * int get_count()
8357c478bd9Sstevel@tonic-gate * Fetches the value of a count property of the given property group.
8367c478bd9Sstevel@tonic-gate * Returns
8377c478bd9Sstevel@tonic-gate * 0 - success
8387c478bd9Sstevel@tonic-gate * ECONNABORTED - repository connection broken
8397c478bd9Sstevel@tonic-gate * unknown libscf error
8407c478bd9Sstevel@tonic-gate * ECANCELED - pg was deleted
8417c478bd9Sstevel@tonic-gate * ENOENT - the property doesn't exist or has no values
8427c478bd9Sstevel@tonic-gate * EINVAL - the property has the wrong type
8437c478bd9Sstevel@tonic-gate * the property is not single-valued
8443eae19d9Swesolows * EACCES - the current user does not have permission to read the value
8457c478bd9Sstevel@tonic-gate */
8467c478bd9Sstevel@tonic-gate static int
get_count(scf_propertygroup_t * pg,const char * propname,uint64_t * valuep)8477c478bd9Sstevel@tonic-gate get_count(scf_propertygroup_t *pg, const char *propname, uint64_t *valuep)
8487c478bd9Sstevel@tonic-gate {
8497c478bd9Sstevel@tonic-gate scf_handle_t *h;
8507c478bd9Sstevel@tonic-gate scf_property_t *prop;
8517c478bd9Sstevel@tonic-gate scf_value_t *val;
8527c478bd9Sstevel@tonic-gate int ret = 0, r;
8537c478bd9Sstevel@tonic-gate
8547c478bd9Sstevel@tonic-gate h = scf_pg_handle(pg);
8557c478bd9Sstevel@tonic-gate prop = safe_scf_property_create(h);
8567c478bd9Sstevel@tonic-gate val = safe_scf_value_create(h);
8577c478bd9Sstevel@tonic-gate
8587c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, propname, prop) != 0) {
8597c478bd9Sstevel@tonic-gate switch (scf_error()) {
8607c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
8617c478bd9Sstevel@tonic-gate default:
8627c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
8637c478bd9Sstevel@tonic-gate goto out;
8647c478bd9Sstevel@tonic-gate
8657c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
8667c478bd9Sstevel@tonic-gate ret = ECANCELED;
8677c478bd9Sstevel@tonic-gate goto out;
8687c478bd9Sstevel@tonic-gate
8697c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
8707c478bd9Sstevel@tonic-gate ret = ENOENT;
8717c478bd9Sstevel@tonic-gate goto out;
8727c478bd9Sstevel@tonic-gate
8737c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
8747c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
8757c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
8767c478bd9Sstevel@tonic-gate bad_error("scf_pg_get_property", scf_error());
8777c478bd9Sstevel@tonic-gate }
8787c478bd9Sstevel@tonic-gate }
8797c478bd9Sstevel@tonic-gate
8807c478bd9Sstevel@tonic-gate if (scf_property_is_type(prop, SCF_TYPE_COUNT) != 0) {
8817c478bd9Sstevel@tonic-gate switch (scf_error()) {
8827c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
8837c478bd9Sstevel@tonic-gate default:
8847c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
8857c478bd9Sstevel@tonic-gate goto out;
8867c478bd9Sstevel@tonic-gate
8877c478bd9Sstevel@tonic-gate case SCF_ERROR_TYPE_MISMATCH:
8887c478bd9Sstevel@tonic-gate ret = EINVAL;
8897c478bd9Sstevel@tonic-gate goto out;
8907c478bd9Sstevel@tonic-gate
8917c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
8927c478bd9Sstevel@tonic-gate ret = ECANCELED;
8937c478bd9Sstevel@tonic-gate goto out;
8947c478bd9Sstevel@tonic-gate
8957c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
8967c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_BOUND:
8977c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
8987c478bd9Sstevel@tonic-gate bad_error("scf_property_is_type", scf_error());
8997c478bd9Sstevel@tonic-gate }
9007c478bd9Sstevel@tonic-gate }
9017c478bd9Sstevel@tonic-gate
9027c478bd9Sstevel@tonic-gate if (scf_property_get_value(prop, val) != 0) {
9037c478bd9Sstevel@tonic-gate switch (scf_error()) {
9047c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
9057c478bd9Sstevel@tonic-gate default:
9067c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
9077c478bd9Sstevel@tonic-gate goto out;
9087c478bd9Sstevel@tonic-gate
9097c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
9107c478bd9Sstevel@tonic-gate ret = ECANCELED;
9117c478bd9Sstevel@tonic-gate goto out;
9127c478bd9Sstevel@tonic-gate
9137c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
9147c478bd9Sstevel@tonic-gate ret = ENOENT;
9157c478bd9Sstevel@tonic-gate goto out;
9167c478bd9Sstevel@tonic-gate
9177c478bd9Sstevel@tonic-gate case SCF_ERROR_CONSTRAINT_VIOLATED:
9187c478bd9Sstevel@tonic-gate ret = EINVAL;
9197c478bd9Sstevel@tonic-gate goto out;
9207c478bd9Sstevel@tonic-gate
9213eae19d9Swesolows case SCF_ERROR_PERMISSION_DENIED:
9223eae19d9Swesolows ret = EACCES;
9233eae19d9Swesolows goto out;
9243eae19d9Swesolows
9257c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
9267c478bd9Sstevel@tonic-gate bad_error("scf_property_get_value", scf_error());
9277c478bd9Sstevel@tonic-gate }
9287c478bd9Sstevel@tonic-gate }
9297c478bd9Sstevel@tonic-gate
9307c478bd9Sstevel@tonic-gate r = scf_value_get_count(val, valuep);
9317c478bd9Sstevel@tonic-gate assert(r == 0);
9327c478bd9Sstevel@tonic-gate
9337c478bd9Sstevel@tonic-gate out:
9347c478bd9Sstevel@tonic-gate scf_value_destroy(val);
9357c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
9367c478bd9Sstevel@tonic-gate return (ret);
9377c478bd9Sstevel@tonic-gate }
9387c478bd9Sstevel@tonic-gate
9397c478bd9Sstevel@tonic-gate
9407c478bd9Sstevel@tonic-gate static void
get_restarter(scf_handle_t * h,scf_propertygroup_t * pg,char ** restarter)9417c478bd9Sstevel@tonic-gate get_restarter(scf_handle_t *h, scf_propertygroup_t *pg, char **restarter)
9427c478bd9Sstevel@tonic-gate {
9437c478bd9Sstevel@tonic-gate scf_property_t *prop = safe_scf_property_create(h);
9447c478bd9Sstevel@tonic-gate
9457c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, SCF_PROPERTY_RESTARTER, prop) == -1 ||
9467c478bd9Sstevel@tonic-gate libscf_read_single_astring(h, prop, restarter) != 0)
9477c478bd9Sstevel@tonic-gate *restarter[0] = '\0';
9487c478bd9Sstevel@tonic-gate
9497c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
9507c478bd9Sstevel@tonic-gate }
9517c478bd9Sstevel@tonic-gate
9527c478bd9Sstevel@tonic-gate /*
9537c478bd9Sstevel@tonic-gate * int libscf_instance_get_fmri(scf_instance_t *, char **)
9547c478bd9Sstevel@tonic-gate * Give a valid SCF instance, return its FMRI. Returns 0 on success,
9557c478bd9Sstevel@tonic-gate * ECONNABORTED, or ECANCELED if inst is deleted.
9567c478bd9Sstevel@tonic-gate */
9577c478bd9Sstevel@tonic-gate int
libscf_instance_get_fmri(scf_instance_t * inst,char ** retp)9587c478bd9Sstevel@tonic-gate libscf_instance_get_fmri(scf_instance_t *inst, char **retp)
9597c478bd9Sstevel@tonic-gate {
9607c478bd9Sstevel@tonic-gate char *inst_fmri = startd_alloc(max_scf_fmri_size);
9617c478bd9Sstevel@tonic-gate
9627c478bd9Sstevel@tonic-gate inst_fmri[0] = 0;
9637c478bd9Sstevel@tonic-gate if (scf_instance_to_fmri(inst, inst_fmri, max_scf_fmri_size) <= 0) {
9647c478bd9Sstevel@tonic-gate startd_free(inst_fmri, max_scf_fmri_size);
9657c478bd9Sstevel@tonic-gate switch (scf_error()) {
9667c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
9677c478bd9Sstevel@tonic-gate default:
9687c478bd9Sstevel@tonic-gate return (ECONNABORTED);
9697c478bd9Sstevel@tonic-gate
9707c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
9717c478bd9Sstevel@tonic-gate return (ECANCELED);
9727c478bd9Sstevel@tonic-gate
9737c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
9747c478bd9Sstevel@tonic-gate assert(0);
9757c478bd9Sstevel@tonic-gate abort();
9767c478bd9Sstevel@tonic-gate }
9777c478bd9Sstevel@tonic-gate }
9787c478bd9Sstevel@tonic-gate
9797c478bd9Sstevel@tonic-gate *retp = inst_fmri;
9807c478bd9Sstevel@tonic-gate return (0);
9817c478bd9Sstevel@tonic-gate }
9827c478bd9Sstevel@tonic-gate
9837c478bd9Sstevel@tonic-gate /*
9847c478bd9Sstevel@tonic-gate * int libscf_fmri_get_instance(scf_handle_t *, const char *,
9857c478bd9Sstevel@tonic-gate * scf_instance_t **)
9867c478bd9Sstevel@tonic-gate * Given a valid SCF handle and an FMRI, return the SCF instance that matches
9877c478bd9Sstevel@tonic-gate * exactly. The instance must be released using scf_instance_destroy().
9887c478bd9Sstevel@tonic-gate * Returns 0 on success, EINVAL if the FMRI is invalid, ENOTSUP if the FMRI
9897c478bd9Sstevel@tonic-gate * is valid but designates something other than an instance, ECONNABORTED if
9907c478bd9Sstevel@tonic-gate * the repository connection is broken, or ENOENT if the instance does not
9917c478bd9Sstevel@tonic-gate * exist.
9927c478bd9Sstevel@tonic-gate */
9937c478bd9Sstevel@tonic-gate int
libscf_fmri_get_instance(scf_handle_t * h,const char * fmri,scf_instance_t ** instp)9947c478bd9Sstevel@tonic-gate libscf_fmri_get_instance(scf_handle_t *h, const char *fmri,
9957c478bd9Sstevel@tonic-gate scf_instance_t **instp)
9967c478bd9Sstevel@tonic-gate {
9977c478bd9Sstevel@tonic-gate scf_instance_t *inst;
9987c478bd9Sstevel@tonic-gate int r;
9997c478bd9Sstevel@tonic-gate
10007c478bd9Sstevel@tonic-gate inst = safe_scf_instance_create(h);
10017c478bd9Sstevel@tonic-gate
10027c478bd9Sstevel@tonic-gate r = libscf_lookup_instance(fmri, inst);
10037c478bd9Sstevel@tonic-gate
10047c478bd9Sstevel@tonic-gate if (r == 0)
10057c478bd9Sstevel@tonic-gate *instp = inst;
10067c478bd9Sstevel@tonic-gate else
10077c478bd9Sstevel@tonic-gate scf_instance_destroy(inst);
10087c478bd9Sstevel@tonic-gate
10097c478bd9Sstevel@tonic-gate return (r);
10107c478bd9Sstevel@tonic-gate }
10117c478bd9Sstevel@tonic-gate
10127c478bd9Sstevel@tonic-gate int
libscf_lookup_instance(const char * fmri,scf_instance_t * inst)10137c478bd9Sstevel@tonic-gate libscf_lookup_instance(const char *fmri, scf_instance_t *inst)
10147c478bd9Sstevel@tonic-gate {
10157c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(scf_instance_handle(inst), fmri, NULL, NULL,
10167c478bd9Sstevel@tonic-gate inst, NULL, NULL, SCF_DECODE_FMRI_EXACT) != SCF_SUCCESS) {
10177c478bd9Sstevel@tonic-gate switch (scf_error()) {
10187c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
10197c478bd9Sstevel@tonic-gate return (EINVAL);
10207c478bd9Sstevel@tonic-gate
10217c478bd9Sstevel@tonic-gate case SCF_ERROR_CONSTRAINT_VIOLATED:
10227c478bd9Sstevel@tonic-gate return (ENOTSUP);
10237c478bd9Sstevel@tonic-gate
10247c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
10257c478bd9Sstevel@tonic-gate return (ECONNABORTED);
10267c478bd9Sstevel@tonic-gate
10277c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
10287c478bd9Sstevel@tonic-gate return (ENOENT);
10297c478bd9Sstevel@tonic-gate
10307c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
10317c478bd9Sstevel@tonic-gate default:
10327c478bd9Sstevel@tonic-gate bad_error("scf_handle_decode_fmri", scf_error());
10337c478bd9Sstevel@tonic-gate }
10347c478bd9Sstevel@tonic-gate }
10357c478bd9Sstevel@tonic-gate
10367c478bd9Sstevel@tonic-gate return (0);
10377c478bd9Sstevel@tonic-gate }
10387c478bd9Sstevel@tonic-gate
103970cbfe41SPhilippe Jung /*
104070cbfe41SPhilippe Jung * int libscf_get_deathrow()
104170cbfe41SPhilippe Jung * Read deathrow for inst. Returns 0, ECONNABORTED if the connection to the
104270cbfe41SPhilippe Jung * repository is broken, ECANCELED if inst is deleted, or ENOENT if inst
104370cbfe41SPhilippe Jung * has no deathrow property group.
104470cbfe41SPhilippe Jung *
104570cbfe41SPhilippe Jung * If deathrow/deathrow was missing or invalid, *deathrow will be -1 and a
104670cbfe41SPhilippe Jung * debug message is logged.
104770cbfe41SPhilippe Jung */
104870cbfe41SPhilippe Jung int
libscf_get_deathrow(scf_handle_t * h,scf_instance_t * inst,int * deathrow)104970cbfe41SPhilippe Jung libscf_get_deathrow(scf_handle_t *h, scf_instance_t *inst, int *deathrow)
105070cbfe41SPhilippe Jung {
105170cbfe41SPhilippe Jung scf_propertygroup_t *pg;
105270cbfe41SPhilippe Jung int r;
105370cbfe41SPhilippe Jung uint8_t deathrow_8;
105470cbfe41SPhilippe Jung
105570cbfe41SPhilippe Jung pg = safe_scf_pg_create(h);
105670cbfe41SPhilippe Jung
105770cbfe41SPhilippe Jung if (scf_instance_get_pg_composed(inst, NULL, SCF_PG_DEATHROW, pg) !=
105870cbfe41SPhilippe Jung 0) {
105970cbfe41SPhilippe Jung switch (scf_error()) {
106070cbfe41SPhilippe Jung case SCF_ERROR_CONNECTION_BROKEN:
106170cbfe41SPhilippe Jung default:
106270cbfe41SPhilippe Jung scf_pg_destroy(pg);
106370cbfe41SPhilippe Jung return (ECONNABORTED);
106470cbfe41SPhilippe Jung
106570cbfe41SPhilippe Jung case SCF_ERROR_DELETED:
106670cbfe41SPhilippe Jung scf_pg_destroy(pg);
106770cbfe41SPhilippe Jung return (ECANCELED);
106870cbfe41SPhilippe Jung
106970cbfe41SPhilippe Jung case SCF_ERROR_NOT_FOUND:
107070cbfe41SPhilippe Jung *deathrow = -1;
107170cbfe41SPhilippe Jung break;
107270cbfe41SPhilippe Jung
107370cbfe41SPhilippe Jung case SCF_ERROR_HANDLE_MISMATCH:
107470cbfe41SPhilippe Jung case SCF_ERROR_INVALID_ARGUMENT:
107570cbfe41SPhilippe Jung case SCF_ERROR_NOT_SET:
107670cbfe41SPhilippe Jung bad_error("libscf_get_deathrow", scf_error());
107770cbfe41SPhilippe Jung }
107870cbfe41SPhilippe Jung } else {
107970cbfe41SPhilippe Jung switch (r = get_boolean(pg,
108070cbfe41SPhilippe Jung SCF_PROPERTY_DEATHROW, &deathrow_8)) {
108170cbfe41SPhilippe Jung case 0:
108270cbfe41SPhilippe Jung *deathrow = deathrow_8;
108370cbfe41SPhilippe Jung break;
108470cbfe41SPhilippe Jung
108570cbfe41SPhilippe Jung case ECONNABORTED:
108670cbfe41SPhilippe Jung case ECANCELED:
108770cbfe41SPhilippe Jung scf_pg_destroy(pg);
108870cbfe41SPhilippe Jung return (r);
108970cbfe41SPhilippe Jung
109070cbfe41SPhilippe Jung case ENOENT:
109170cbfe41SPhilippe Jung case EINVAL:
109270cbfe41SPhilippe Jung *deathrow = -1;
109370cbfe41SPhilippe Jung break;
109470cbfe41SPhilippe Jung
109570cbfe41SPhilippe Jung default:
109670cbfe41SPhilippe Jung bad_error("get_boolean", r);
109770cbfe41SPhilippe Jung }
109870cbfe41SPhilippe Jung }
109970cbfe41SPhilippe Jung
110070cbfe41SPhilippe Jung scf_pg_destroy(pg);
110170cbfe41SPhilippe Jung
110270cbfe41SPhilippe Jung return (0);
110370cbfe41SPhilippe Jung }
110470cbfe41SPhilippe Jung
11057c478bd9Sstevel@tonic-gate /*
11067c478bd9Sstevel@tonic-gate * void libscf_get_basic_instance_data()
11077c478bd9Sstevel@tonic-gate * Read enabled, enabled_ovr, and restarter_fmri (into an allocated
11087c478bd9Sstevel@tonic-gate * buffer) for inst. Returns 0, ECONNABORTED if the connection to the
11097c478bd9Sstevel@tonic-gate * repository is broken, ECANCELED if inst is deleted, or ENOENT if inst
11107c478bd9Sstevel@tonic-gate * has no general property group.
11117c478bd9Sstevel@tonic-gate *
11127c478bd9Sstevel@tonic-gate * On success, restarter_fmri may be NULL. If general/enabled was missing
11137c478bd9Sstevel@tonic-gate * or invalid, *enabledp will be -1 and a debug message is logged.
11147c478bd9Sstevel@tonic-gate */
11157c478bd9Sstevel@tonic-gate int
libscf_get_basic_instance_data(scf_handle_t * h,scf_instance_t * inst,const char * fmri,int * enabledp,int * enabled_ovrp,char ** restarter_fmri)11167c478bd9Sstevel@tonic-gate libscf_get_basic_instance_data(scf_handle_t *h, scf_instance_t *inst,
11177c478bd9Sstevel@tonic-gate const char *fmri, int *enabledp, int *enabled_ovrp, char **restarter_fmri)
11187c478bd9Sstevel@tonic-gate {
11197c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg;
11207c478bd9Sstevel@tonic-gate int r;
11217c478bd9Sstevel@tonic-gate uint8_t enabled_8;
11227c478bd9Sstevel@tonic-gate
11237c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h);
11247c478bd9Sstevel@tonic-gate
11257c478bd9Sstevel@tonic-gate if (enabled_ovrp == NULL)
11267c478bd9Sstevel@tonic-gate goto enabled;
11277c478bd9Sstevel@tonic-gate
11287c478bd9Sstevel@tonic-gate if (scf_instance_get_pg_composed(inst, NULL, SCF_PG_GENERAL_OVR, pg) !=
11297c478bd9Sstevel@tonic-gate 0) {
11307c478bd9Sstevel@tonic-gate switch (scf_error()) {
11317c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
11327c478bd9Sstevel@tonic-gate default:
11337c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
11347c478bd9Sstevel@tonic-gate return (ECONNABORTED);
11357c478bd9Sstevel@tonic-gate
11367c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
11377c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
11387c478bd9Sstevel@tonic-gate return (ECANCELED);
11397c478bd9Sstevel@tonic-gate
11407c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
11417c478bd9Sstevel@tonic-gate *enabled_ovrp = -1;
11427c478bd9Sstevel@tonic-gate break;
11437c478bd9Sstevel@tonic-gate
11447c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
11457c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
11467c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
11477c478bd9Sstevel@tonic-gate bad_error("scf_instance_get_pg_composed", scf_error());
11487c478bd9Sstevel@tonic-gate }
11497c478bd9Sstevel@tonic-gate } else {
11507c478bd9Sstevel@tonic-gate switch (r = get_boolean(pg, SCF_PROPERTY_ENABLED, &enabled_8)) {
11517c478bd9Sstevel@tonic-gate case 0:
11527c478bd9Sstevel@tonic-gate *enabled_ovrp = enabled_8;
11537c478bd9Sstevel@tonic-gate break;
11547c478bd9Sstevel@tonic-gate
11557c478bd9Sstevel@tonic-gate case ECONNABORTED:
11567c478bd9Sstevel@tonic-gate case ECANCELED:
11577c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
11587c478bd9Sstevel@tonic-gate return (r);
11597c478bd9Sstevel@tonic-gate
11607c478bd9Sstevel@tonic-gate case ENOENT:
11617c478bd9Sstevel@tonic-gate case EINVAL:
11627c478bd9Sstevel@tonic-gate *enabled_ovrp = -1;
11637c478bd9Sstevel@tonic-gate break;
11647c478bd9Sstevel@tonic-gate
11653eae19d9Swesolows case EACCES:
11667c478bd9Sstevel@tonic-gate default:
11677c478bd9Sstevel@tonic-gate bad_error("get_boolean", r);
11687c478bd9Sstevel@tonic-gate }
11697c478bd9Sstevel@tonic-gate }
11707c478bd9Sstevel@tonic-gate
11717c478bd9Sstevel@tonic-gate enabled:
11727c478bd9Sstevel@tonic-gate /*
11737c478bd9Sstevel@tonic-gate * Since general/restarter can be at the service level, we must do
11747c478bd9Sstevel@tonic-gate * a composed lookup. These properties are immediate, though, so we
11757c478bd9Sstevel@tonic-gate * must use the "editing" snapshot. Technically enabled shouldn't be
11767c478bd9Sstevel@tonic-gate * at the service level, but looking it up composed, too, doesn't
11777c478bd9Sstevel@tonic-gate * hurt.
11787c478bd9Sstevel@tonic-gate */
11797c478bd9Sstevel@tonic-gate if (scf_instance_get_pg_composed(inst, NULL, SCF_PG_GENERAL, pg) != 0) {
11807c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
11817c478bd9Sstevel@tonic-gate switch (scf_error()) {
11827c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
11837c478bd9Sstevel@tonic-gate default:
11847c478bd9Sstevel@tonic-gate return (ECONNABORTED);
11857c478bd9Sstevel@tonic-gate
11867c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
11877c478bd9Sstevel@tonic-gate return (ECANCELED);
11887c478bd9Sstevel@tonic-gate
11897c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
11907c478bd9Sstevel@tonic-gate return (ENOENT);
11917c478bd9Sstevel@tonic-gate
11927c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
11937c478bd9Sstevel@tonic-gate bad_error("scf_instance_get_pg_composed", scf_error());
11947c478bd9Sstevel@tonic-gate }
11957c478bd9Sstevel@tonic-gate }
11967c478bd9Sstevel@tonic-gate
11977c478bd9Sstevel@tonic-gate switch (r = get_boolean(pg, SCF_PROPERTY_ENABLED, &enabled_8)) {
11987c478bd9Sstevel@tonic-gate case 0:
11997c478bd9Sstevel@tonic-gate *enabledp = enabled_8;
12007c478bd9Sstevel@tonic-gate break;
12017c478bd9Sstevel@tonic-gate
12027c478bd9Sstevel@tonic-gate case ECONNABORTED:
12037c478bd9Sstevel@tonic-gate case ECANCELED:
12047c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
12057c478bd9Sstevel@tonic-gate return (r);
12067c478bd9Sstevel@tonic-gate
12077c478bd9Sstevel@tonic-gate case ENOENT:
12087c478bd9Sstevel@tonic-gate /*
12097c478bd9Sstevel@tonic-gate * DEBUG because this happens when svccfg import creates
12107c478bd9Sstevel@tonic-gate * a temporary service.
12117c478bd9Sstevel@tonic-gate */
12127c478bd9Sstevel@tonic-gate log_framework(LOG_DEBUG,
12137c478bd9Sstevel@tonic-gate "general/enabled property of %s is missing.\n", fmri);
12147c478bd9Sstevel@tonic-gate *enabledp = -1;
12157c478bd9Sstevel@tonic-gate break;
12167c478bd9Sstevel@tonic-gate
12177c478bd9Sstevel@tonic-gate case EINVAL:
12187c478bd9Sstevel@tonic-gate log_framework(LOG_ERR,
12197c478bd9Sstevel@tonic-gate "general/enabled property of %s is invalid.\n", fmri);
12207c478bd9Sstevel@tonic-gate *enabledp = -1;
12217c478bd9Sstevel@tonic-gate break;
12227c478bd9Sstevel@tonic-gate
12233eae19d9Swesolows case EACCES:
12247c478bd9Sstevel@tonic-gate default:
12257c478bd9Sstevel@tonic-gate bad_error("get_boolean", r);
12267c478bd9Sstevel@tonic-gate }
12277c478bd9Sstevel@tonic-gate
12287c478bd9Sstevel@tonic-gate if (restarter_fmri != NULL)
12297c478bd9Sstevel@tonic-gate get_restarter(h, pg, restarter_fmri);
12307c478bd9Sstevel@tonic-gate
12317c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
12327c478bd9Sstevel@tonic-gate
12337c478bd9Sstevel@tonic-gate return (0);
12347c478bd9Sstevel@tonic-gate }
12357c478bd9Sstevel@tonic-gate
12367c478bd9Sstevel@tonic-gate /*
12377c478bd9Sstevel@tonic-gate * Sets pg to the name property group of s_inst. If it doesn't exist, it is
12387c478bd9Sstevel@tonic-gate * added.
12397c478bd9Sstevel@tonic-gate *
12407c478bd9Sstevel@tonic-gate * Fails with
12417c478bd9Sstevel@tonic-gate * ECONNABORTED - repository disconnection or unknown libscf error
12427c478bd9Sstevel@tonic-gate * ECANCELED - inst is deleted
12437c478bd9Sstevel@tonic-gate * EPERM - permission is denied
12447c478bd9Sstevel@tonic-gate * EACCES - backend denied access
12457c478bd9Sstevel@tonic-gate * EROFS - backend readonly
12467c478bd9Sstevel@tonic-gate */
12477c478bd9Sstevel@tonic-gate int
libscf_inst_get_or_add_pg(scf_instance_t * inst,const char * name,const char * type,uint32_t flags,scf_propertygroup_t * pg)12487c478bd9Sstevel@tonic-gate libscf_inst_get_or_add_pg(scf_instance_t *inst, const char *name,
12497c478bd9Sstevel@tonic-gate const char *type, uint32_t flags, scf_propertygroup_t *pg)
12507c478bd9Sstevel@tonic-gate {
12517c478bd9Sstevel@tonic-gate uint32_t f;
12527c478bd9Sstevel@tonic-gate
12537c478bd9Sstevel@tonic-gate again:
12547c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(inst, name, pg) == 0) {
12557c478bd9Sstevel@tonic-gate if (scf_pg_get_flags(pg, &f) != 0) {
12567c478bd9Sstevel@tonic-gate switch (scf_error()) {
12577c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
12587c478bd9Sstevel@tonic-gate default:
12597c478bd9Sstevel@tonic-gate return (ECONNABORTED);
12607c478bd9Sstevel@tonic-gate
12617c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
12627c478bd9Sstevel@tonic-gate goto add;
12637c478bd9Sstevel@tonic-gate
12647c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
12657c478bd9Sstevel@tonic-gate bad_error("scf_pg_get_flags", scf_error());
12667c478bd9Sstevel@tonic-gate }
12677c478bd9Sstevel@tonic-gate }
12687c478bd9Sstevel@tonic-gate
12697c478bd9Sstevel@tonic-gate if (f == flags)
12707c478bd9Sstevel@tonic-gate return (0);
12717c478bd9Sstevel@tonic-gate
12727c478bd9Sstevel@tonic-gate if (scf_pg_delete(pg) != 0) {
12737c478bd9Sstevel@tonic-gate switch (scf_error()) {
12747c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
12757c478bd9Sstevel@tonic-gate default:
12767c478bd9Sstevel@tonic-gate return (ECONNABORTED);
12777c478bd9Sstevel@tonic-gate
12787c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
12797c478bd9Sstevel@tonic-gate break;
12807c478bd9Sstevel@tonic-gate
12817c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
12827c478bd9Sstevel@tonic-gate return (EPERM);
12837c478bd9Sstevel@tonic-gate
12847c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
12857c478bd9Sstevel@tonic-gate return (EACCES);
12867c478bd9Sstevel@tonic-gate
12877c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
12887c478bd9Sstevel@tonic-gate return (EROFS);
12897c478bd9Sstevel@tonic-gate
12907c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
12917c478bd9Sstevel@tonic-gate bad_error("scf_pg_delete", scf_error());
12927c478bd9Sstevel@tonic-gate }
12937c478bd9Sstevel@tonic-gate }
12947c478bd9Sstevel@tonic-gate } else {
12957c478bd9Sstevel@tonic-gate switch (scf_error()) {
12967c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
12977c478bd9Sstevel@tonic-gate default:
12987c478bd9Sstevel@tonic-gate return (ECONNABORTED);
12997c478bd9Sstevel@tonic-gate
13007c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
13017c478bd9Sstevel@tonic-gate return (ECANCELED);
13027c478bd9Sstevel@tonic-gate
13037c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
13047c478bd9Sstevel@tonic-gate break;
13057c478bd9Sstevel@tonic-gate
13067c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
13077c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
13087c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
13097c478bd9Sstevel@tonic-gate bad_error("scf_instance_get_pg", scf_error());
13107c478bd9Sstevel@tonic-gate }
13117c478bd9Sstevel@tonic-gate }
13127c478bd9Sstevel@tonic-gate
13137c478bd9Sstevel@tonic-gate add:
13147c478bd9Sstevel@tonic-gate if (scf_instance_add_pg(inst, name, type, flags, pg) == 0)
13157c478bd9Sstevel@tonic-gate return (0);
13167c478bd9Sstevel@tonic-gate
13177c478bd9Sstevel@tonic-gate switch (scf_error()) {
13187c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
13197c478bd9Sstevel@tonic-gate default:
13207c478bd9Sstevel@tonic-gate return (ECONNABORTED);
13217c478bd9Sstevel@tonic-gate
13227c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
13237c478bd9Sstevel@tonic-gate return (ECANCELED);
13247c478bd9Sstevel@tonic-gate
13257c478bd9Sstevel@tonic-gate case SCF_ERROR_EXISTS:
13267c478bd9Sstevel@tonic-gate goto again;
13277c478bd9Sstevel@tonic-gate
13287c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
13297c478bd9Sstevel@tonic-gate return (EPERM);
13307c478bd9Sstevel@tonic-gate
13317c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
13327c478bd9Sstevel@tonic-gate return (EACCES);
13337c478bd9Sstevel@tonic-gate
13347c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
13357c478bd9Sstevel@tonic-gate return (EROFS);
13367c478bd9Sstevel@tonic-gate
13377c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
13387c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
13397c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
13407c478bd9Sstevel@tonic-gate bad_error("scf_instance_add_pg", scf_error());
13417c478bd9Sstevel@tonic-gate /* NOTREACHED */
13427c478bd9Sstevel@tonic-gate }
13437c478bd9Sstevel@tonic-gate }
13447c478bd9Sstevel@tonic-gate
13457c478bd9Sstevel@tonic-gate /*
13467c478bd9Sstevel@tonic-gate * Returns
13477c478bd9Sstevel@tonic-gate * 0 - success
13487c478bd9Sstevel@tonic-gate * ECONNABORTED - repository connection broken
13497c478bd9Sstevel@tonic-gate * - unknown libscf error
13507c478bd9Sstevel@tonic-gate * ECANCELED
13517c478bd9Sstevel@tonic-gate */
13527c478bd9Sstevel@tonic-gate static scf_error_t
transaction_add_set(scf_transaction_t * tx,scf_transaction_entry_t * ent,const char * pname,scf_type_t ty)13537c478bd9Sstevel@tonic-gate transaction_add_set(scf_transaction_t *tx, scf_transaction_entry_t *ent,
13547c478bd9Sstevel@tonic-gate const char *pname, scf_type_t ty)
13557c478bd9Sstevel@tonic-gate {
13567c478bd9Sstevel@tonic-gate for (;;) {
13577c478bd9Sstevel@tonic-gate if (scf_transaction_property_change_type(tx, ent, pname,
13587c478bd9Sstevel@tonic-gate ty) == 0)
13597c478bd9Sstevel@tonic-gate return (0);
13607c478bd9Sstevel@tonic-gate
13617c478bd9Sstevel@tonic-gate switch (scf_error()) {
13627c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
13637c478bd9Sstevel@tonic-gate default:
13647c478bd9Sstevel@tonic-gate return (ECONNABORTED);
13657c478bd9Sstevel@tonic-gate
13667c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
13677c478bd9Sstevel@tonic-gate return (ECANCELED);
13687c478bd9Sstevel@tonic-gate
13697c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
13707c478bd9Sstevel@tonic-gate break;
13717c478bd9Sstevel@tonic-gate
13727c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
13737c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
13747c478bd9Sstevel@tonic-gate case SCF_ERROR_IN_USE:
13757c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
13767c478bd9Sstevel@tonic-gate bad_error("scf_transaction_property_change_type",
13777c478bd9Sstevel@tonic-gate scf_error());
13787c478bd9Sstevel@tonic-gate }
13797c478bd9Sstevel@tonic-gate
13807c478bd9Sstevel@tonic-gate if (scf_transaction_property_new(tx, ent, pname, ty) == 0)
13817c478bd9Sstevel@tonic-gate return (0);
13827c478bd9Sstevel@tonic-gate
13837c478bd9Sstevel@tonic-gate switch (scf_error()) {
13847c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
13857c478bd9Sstevel@tonic-gate default:
13867c478bd9Sstevel@tonic-gate return (ECONNABORTED);
13877c478bd9Sstevel@tonic-gate
13887c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
13897c478bd9Sstevel@tonic-gate return (ECANCELED);
13907c478bd9Sstevel@tonic-gate
13917c478bd9Sstevel@tonic-gate case SCF_ERROR_EXISTS:
13927c478bd9Sstevel@tonic-gate break;
13937c478bd9Sstevel@tonic-gate
13947c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
13957c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
13967c478bd9Sstevel@tonic-gate case SCF_ERROR_IN_USE:
13977c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
13987c478bd9Sstevel@tonic-gate bad_error("scf_transaction_property_new", scf_error());
13997c478bd9Sstevel@tonic-gate /* NOTREACHED */
14007c478bd9Sstevel@tonic-gate }
14017c478bd9Sstevel@tonic-gate }
14027c478bd9Sstevel@tonic-gate }
14037c478bd9Sstevel@tonic-gate
14047c478bd9Sstevel@tonic-gate /*
14057c478bd9Sstevel@tonic-gate * Returns
14067c478bd9Sstevel@tonic-gate * 0 - success
14077c478bd9Sstevel@tonic-gate * ECONNABORTED - repository connection broken
14087c478bd9Sstevel@tonic-gate * - unknown libscf error
14097c478bd9Sstevel@tonic-gate * ECANCELED - pg was deleted
14107c478bd9Sstevel@tonic-gate * EPERM
14117c478bd9Sstevel@tonic-gate * EACCES
14127c478bd9Sstevel@tonic-gate * EROFS
14137c478bd9Sstevel@tonic-gate */
14147c478bd9Sstevel@tonic-gate static int
pg_set_prop_value(scf_propertygroup_t * pg,const char * pname,scf_value_t * v)14157c478bd9Sstevel@tonic-gate pg_set_prop_value(scf_propertygroup_t *pg, const char *pname, scf_value_t *v)
14167c478bd9Sstevel@tonic-gate {
14177c478bd9Sstevel@tonic-gate scf_handle_t *h;
14187c478bd9Sstevel@tonic-gate scf_transaction_t *tx;
14197c478bd9Sstevel@tonic-gate scf_transaction_entry_t *e;
14207c478bd9Sstevel@tonic-gate scf_type_t ty;
14217c478bd9Sstevel@tonic-gate scf_error_t scfe;
14227c478bd9Sstevel@tonic-gate int ret, r;
14237c478bd9Sstevel@tonic-gate
14247c478bd9Sstevel@tonic-gate h = scf_pg_handle(pg);
14257c478bd9Sstevel@tonic-gate tx = safe_scf_transaction_create(h);
14267c478bd9Sstevel@tonic-gate e = safe_scf_entry_create(h);
14277c478bd9Sstevel@tonic-gate
14287c478bd9Sstevel@tonic-gate ty = scf_value_type(v);
14297c478bd9Sstevel@tonic-gate assert(ty != SCF_TYPE_INVALID);
14307c478bd9Sstevel@tonic-gate
14317c478bd9Sstevel@tonic-gate for (;;) {
14327c478bd9Sstevel@tonic-gate if (scf_transaction_start(tx, pg) != 0) {
14337c478bd9Sstevel@tonic-gate switch (scf_error()) {
14347c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
14357c478bd9Sstevel@tonic-gate default:
14367c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
14377c478bd9Sstevel@tonic-gate goto out;
14387c478bd9Sstevel@tonic-gate
14397c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
14407c478bd9Sstevel@tonic-gate ret = ECANCELED;
14417c478bd9Sstevel@tonic-gate goto out;
14427c478bd9Sstevel@tonic-gate
14437c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
14447c478bd9Sstevel@tonic-gate ret = EPERM;
14457c478bd9Sstevel@tonic-gate goto out;
14467c478bd9Sstevel@tonic-gate
14477c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
14487c478bd9Sstevel@tonic-gate ret = EACCES;
14497c478bd9Sstevel@tonic-gate goto out;
14507c478bd9Sstevel@tonic-gate
14517c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
14527c478bd9Sstevel@tonic-gate ret = EROFS;
14537c478bd9Sstevel@tonic-gate goto out;
14547c478bd9Sstevel@tonic-gate
14557c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
14567c478bd9Sstevel@tonic-gate bad_error("scf_transaction_start", ret);
14577c478bd9Sstevel@tonic-gate }
14587c478bd9Sstevel@tonic-gate }
14597c478bd9Sstevel@tonic-gate
14607c478bd9Sstevel@tonic-gate ret = transaction_add_set(tx, e, pname, ty);
14617c478bd9Sstevel@tonic-gate switch (ret) {
14627c478bd9Sstevel@tonic-gate case 0:
14637c478bd9Sstevel@tonic-gate break;
14647c478bd9Sstevel@tonic-gate
14657c478bd9Sstevel@tonic-gate case ECONNABORTED:
14667c478bd9Sstevel@tonic-gate case ECANCELED:
14677c478bd9Sstevel@tonic-gate goto out;
14687c478bd9Sstevel@tonic-gate
14697c478bd9Sstevel@tonic-gate default:
14707c478bd9Sstevel@tonic-gate bad_error("transaction_add_set", ret);
14717c478bd9Sstevel@tonic-gate }
14727c478bd9Sstevel@tonic-gate
14737c478bd9Sstevel@tonic-gate r = scf_entry_add_value(e, v);
14747c478bd9Sstevel@tonic-gate assert(r == 0);
14757c478bd9Sstevel@tonic-gate
14767c478bd9Sstevel@tonic-gate r = scf_transaction_commit(tx);
14777c478bd9Sstevel@tonic-gate if (r == 1)
14787c478bd9Sstevel@tonic-gate break;
14797c478bd9Sstevel@tonic-gate if (r != 0) {
14807c478bd9Sstevel@tonic-gate scfe = scf_error();
14817c478bd9Sstevel@tonic-gate scf_transaction_reset(tx);
14827c478bd9Sstevel@tonic-gate switch (scfe) {
14837c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
14847c478bd9Sstevel@tonic-gate default:
14857c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
14867c478bd9Sstevel@tonic-gate goto out;
14877c478bd9Sstevel@tonic-gate
14887c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
14897c478bd9Sstevel@tonic-gate ret = ECANCELED;
14907c478bd9Sstevel@tonic-gate goto out;
14917c478bd9Sstevel@tonic-gate
14927c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
14937c478bd9Sstevel@tonic-gate ret = EPERM;
14947c478bd9Sstevel@tonic-gate goto out;
14957c478bd9Sstevel@tonic-gate
14967c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
14977c478bd9Sstevel@tonic-gate ret = EACCES;
14987c478bd9Sstevel@tonic-gate goto out;
14997c478bd9Sstevel@tonic-gate
15007c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
15017c478bd9Sstevel@tonic-gate ret = EROFS;
15027c478bd9Sstevel@tonic-gate goto out;
15037c478bd9Sstevel@tonic-gate
15047c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
15057c478bd9Sstevel@tonic-gate bad_error("scf_transaction_commit", scfe);
15067c478bd9Sstevel@tonic-gate }
15077c478bd9Sstevel@tonic-gate }
15087c478bd9Sstevel@tonic-gate
15097c478bd9Sstevel@tonic-gate scf_transaction_reset(tx);
15107c478bd9Sstevel@tonic-gate
15117c478bd9Sstevel@tonic-gate if (scf_pg_update(pg) == -1) {
15127c478bd9Sstevel@tonic-gate switch (scf_error()) {
15137c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
15147c478bd9Sstevel@tonic-gate default:
15157c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
15167c478bd9Sstevel@tonic-gate goto out;
15177c478bd9Sstevel@tonic-gate
15187c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
15197c478bd9Sstevel@tonic-gate ret = ECANCELED;
15207c478bd9Sstevel@tonic-gate goto out;
15217c478bd9Sstevel@tonic-gate
15227c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
15237c478bd9Sstevel@tonic-gate bad_error("scf_pg_update", scf_error());
15247c478bd9Sstevel@tonic-gate }
15257c478bd9Sstevel@tonic-gate }
15267c478bd9Sstevel@tonic-gate }
15277c478bd9Sstevel@tonic-gate
15287c478bd9Sstevel@tonic-gate ret = 0;
15297c478bd9Sstevel@tonic-gate
15307c478bd9Sstevel@tonic-gate out:
15317c478bd9Sstevel@tonic-gate scf_transaction_destroy(tx);
15327c478bd9Sstevel@tonic-gate scf_entry_destroy(e);
15337c478bd9Sstevel@tonic-gate return (ret);
15347c478bd9Sstevel@tonic-gate }
15357c478bd9Sstevel@tonic-gate
15367c478bd9Sstevel@tonic-gate /*
15377c478bd9Sstevel@tonic-gate * Returns
15387c478bd9Sstevel@tonic-gate * 0 - success
15397c478bd9Sstevel@tonic-gate * ECONNABORTED - repository connection broken
15407c478bd9Sstevel@tonic-gate * - unknown libscf error
15417c478bd9Sstevel@tonic-gate * ECANCELED - inst was deleted
15427c478bd9Sstevel@tonic-gate * EPERM
15437c478bd9Sstevel@tonic-gate * EACCES
15447c478bd9Sstevel@tonic-gate * EROFS
15457c478bd9Sstevel@tonic-gate */
15467c478bd9Sstevel@tonic-gate int
libscf_inst_set_boolean_prop(scf_instance_t * inst,const char * pgname,const char * pgtype,uint32_t pgflags,const char * pname,int val)15477c478bd9Sstevel@tonic-gate libscf_inst_set_boolean_prop(scf_instance_t *inst, const char *pgname,
15487c478bd9Sstevel@tonic-gate const char *pgtype, uint32_t pgflags, const char *pname, int val)
15497c478bd9Sstevel@tonic-gate {
15507c478bd9Sstevel@tonic-gate scf_handle_t *h;
15517c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg = NULL;
15527c478bd9Sstevel@tonic-gate scf_value_t *v;
15537c478bd9Sstevel@tonic-gate int ret = 0;
15547c478bd9Sstevel@tonic-gate
15557c478bd9Sstevel@tonic-gate h = scf_instance_handle(inst);
15567c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h);
15577c478bd9Sstevel@tonic-gate v = safe_scf_value_create(h);
15587c478bd9Sstevel@tonic-gate
15597c478bd9Sstevel@tonic-gate ret = libscf_inst_get_or_add_pg(inst, pgname, pgtype, pgflags, pg);
15607c478bd9Sstevel@tonic-gate switch (ret) {
15617c478bd9Sstevel@tonic-gate case 0:
15627c478bd9Sstevel@tonic-gate break;
15637c478bd9Sstevel@tonic-gate
15647c478bd9Sstevel@tonic-gate case ECONNABORTED:
15657c478bd9Sstevel@tonic-gate case ECANCELED:
15667c478bd9Sstevel@tonic-gate case EPERM:
15677c478bd9Sstevel@tonic-gate case EACCES:
15687c478bd9Sstevel@tonic-gate case EROFS:
15697c478bd9Sstevel@tonic-gate goto out;
15707c478bd9Sstevel@tonic-gate
15717c478bd9Sstevel@tonic-gate default:
15727c478bd9Sstevel@tonic-gate bad_error("libscf_inst_get_or_add_pg", ret);
15737c478bd9Sstevel@tonic-gate }
15747c478bd9Sstevel@tonic-gate
15757c478bd9Sstevel@tonic-gate scf_value_set_boolean(v, val);
15767c478bd9Sstevel@tonic-gate
15777c478bd9Sstevel@tonic-gate ret = pg_set_prop_value(pg, pname, v);
15787c478bd9Sstevel@tonic-gate switch (ret) {
15797c478bd9Sstevel@tonic-gate case 0:
15807c478bd9Sstevel@tonic-gate case ECONNABORTED:
15817c478bd9Sstevel@tonic-gate case ECANCELED:
15827c478bd9Sstevel@tonic-gate case EPERM:
15837c478bd9Sstevel@tonic-gate case EACCES:
15847c478bd9Sstevel@tonic-gate case EROFS:
15857c478bd9Sstevel@tonic-gate break;
15867c478bd9Sstevel@tonic-gate
15877c478bd9Sstevel@tonic-gate default:
15887c478bd9Sstevel@tonic-gate bad_error("pg_set_prop_value", ret);
15897c478bd9Sstevel@tonic-gate }
15907c478bd9Sstevel@tonic-gate
15917c478bd9Sstevel@tonic-gate out:
15927c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
15937c478bd9Sstevel@tonic-gate scf_value_destroy(v);
15947c478bd9Sstevel@tonic-gate return (ret);
15957c478bd9Sstevel@tonic-gate }
15967c478bd9Sstevel@tonic-gate
15977c478bd9Sstevel@tonic-gate /*
15987c478bd9Sstevel@tonic-gate * Returns
15997c478bd9Sstevel@tonic-gate * 0 - success
16007c478bd9Sstevel@tonic-gate * ECONNABORTED - repository connection broken
16017c478bd9Sstevel@tonic-gate * - unknown libscf error
16027c478bd9Sstevel@tonic-gate * ECANCELED - inst was deleted
16037c478bd9Sstevel@tonic-gate * EPERM
16047c478bd9Sstevel@tonic-gate * EACCES
16057c478bd9Sstevel@tonic-gate * EROFS
16067c478bd9Sstevel@tonic-gate */
16077c478bd9Sstevel@tonic-gate int
libscf_inst_set_count_prop(scf_instance_t * inst,const char * pgname,const char * pgtype,uint32_t pgflags,const char * pname,uint64_t count)16087c478bd9Sstevel@tonic-gate libscf_inst_set_count_prop(scf_instance_t *inst, const char *pgname,
16097c478bd9Sstevel@tonic-gate const char *pgtype, uint32_t pgflags, const char *pname, uint64_t count)
16107c478bd9Sstevel@tonic-gate {
16117c478bd9Sstevel@tonic-gate scf_handle_t *h;
16127c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg = NULL;
16137c478bd9Sstevel@tonic-gate scf_value_t *v;
16147c478bd9Sstevel@tonic-gate int ret = 0;
16157c478bd9Sstevel@tonic-gate
16167c478bd9Sstevel@tonic-gate h = scf_instance_handle(inst);
16177c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h);
16187c478bd9Sstevel@tonic-gate v = safe_scf_value_create(h);
16197c478bd9Sstevel@tonic-gate
16207c478bd9Sstevel@tonic-gate ret = libscf_inst_get_or_add_pg(inst, pgname, pgtype, pgflags, pg);
16217c478bd9Sstevel@tonic-gate switch (ret) {
16227c478bd9Sstevel@tonic-gate case 0:
16237c478bd9Sstevel@tonic-gate break;
16247c478bd9Sstevel@tonic-gate
16257c478bd9Sstevel@tonic-gate case ECONNABORTED:
16267c478bd9Sstevel@tonic-gate case ECANCELED:
16277c478bd9Sstevel@tonic-gate case EPERM:
16287c478bd9Sstevel@tonic-gate case EACCES:
16297c478bd9Sstevel@tonic-gate case EROFS:
16307c478bd9Sstevel@tonic-gate goto out;
16317c478bd9Sstevel@tonic-gate
16327c478bd9Sstevel@tonic-gate default:
16337c478bd9Sstevel@tonic-gate bad_error("libscf_inst_get_or_add_pg", ret);
16347c478bd9Sstevel@tonic-gate }
16357c478bd9Sstevel@tonic-gate
16367c478bd9Sstevel@tonic-gate scf_value_set_count(v, count);
16377c478bd9Sstevel@tonic-gate
16387c478bd9Sstevel@tonic-gate ret = pg_set_prop_value(pg, pname, v);
16397c478bd9Sstevel@tonic-gate switch (ret) {
16407c478bd9Sstevel@tonic-gate case 0:
16417c478bd9Sstevel@tonic-gate case ECONNABORTED:
16427c478bd9Sstevel@tonic-gate case ECANCELED:
16437c478bd9Sstevel@tonic-gate case EPERM:
16447c478bd9Sstevel@tonic-gate case EACCES:
16457c478bd9Sstevel@tonic-gate case EROFS:
16467c478bd9Sstevel@tonic-gate break;
16477c478bd9Sstevel@tonic-gate
16487c478bd9Sstevel@tonic-gate default:
16497c478bd9Sstevel@tonic-gate bad_error("pg_set_prop_value", ret);
16507c478bd9Sstevel@tonic-gate }
16517c478bd9Sstevel@tonic-gate
16527c478bd9Sstevel@tonic-gate out:
16537c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
16547c478bd9Sstevel@tonic-gate scf_value_destroy(v);
16557c478bd9Sstevel@tonic-gate return (ret);
16567c478bd9Sstevel@tonic-gate }
16577c478bd9Sstevel@tonic-gate
16587c478bd9Sstevel@tonic-gate /*
16597c478bd9Sstevel@tonic-gate * Returns 0 on success, ECONNABORTED if the repository connection is broken,
16607c478bd9Sstevel@tonic-gate * ECANCELED if inst is deleted, EROFS if the backend is readonly, or EPERM if
16617c478bd9Sstevel@tonic-gate * permission was denied.
16627c478bd9Sstevel@tonic-gate */
16637c478bd9Sstevel@tonic-gate int
libscf_set_enable_ovr(scf_instance_t * inst,int enable)16647c478bd9Sstevel@tonic-gate libscf_set_enable_ovr(scf_instance_t *inst, int enable)
16657c478bd9Sstevel@tonic-gate {
16667c478bd9Sstevel@tonic-gate return (libscf_inst_set_boolean_prop(inst, SCF_PG_GENERAL_OVR,
16677c478bd9Sstevel@tonic-gate SCF_PG_GENERAL_OVR_TYPE, SCF_PG_GENERAL_OVR_FLAGS,
16687c478bd9Sstevel@tonic-gate SCF_PROPERTY_ENABLED, enable));
16697c478bd9Sstevel@tonic-gate }
16707c478bd9Sstevel@tonic-gate
167170cbfe41SPhilippe Jung /*
167270cbfe41SPhilippe Jung * Returns 0 on success, ECONNABORTED if the repository connection is broken,
167370cbfe41SPhilippe Jung * ECANCELED if inst is deleted, EROFS if the backend is readonly, or EPERM if
167470cbfe41SPhilippe Jung * permission was denied.
167570cbfe41SPhilippe Jung */
167670cbfe41SPhilippe Jung int
libscf_set_deathrow(scf_instance_t * inst,int deathrow)167770cbfe41SPhilippe Jung libscf_set_deathrow(scf_instance_t *inst, int deathrow)
167870cbfe41SPhilippe Jung {
167970cbfe41SPhilippe Jung return (libscf_inst_set_boolean_prop(inst, SCF_PG_DEATHROW,
168070cbfe41SPhilippe Jung SCF_PG_DEATHROW_TYPE, SCF_PG_DEATHROW_FLAGS,
168170cbfe41SPhilippe Jung SCF_PROPERTY_DEATHROW, deathrow));
168270cbfe41SPhilippe Jung }
168370cbfe41SPhilippe Jung
16847c478bd9Sstevel@tonic-gate /*
1685*8fff7887SJohn Levon * Since we're clearing the over-ridden enabled state for the service, we'll
1686*8fff7887SJohn Levon * also take the opportunity to remove any comment.
1687*8fff7887SJohn Levon *
16887c478bd9Sstevel@tonic-gate * Returns 0, ECONNABORTED, ECANCELED, or EPERM.
16897c478bd9Sstevel@tonic-gate */
16907c478bd9Sstevel@tonic-gate int
libscf_delete_enable_ovr(scf_instance_t * inst)16917c478bd9Sstevel@tonic-gate libscf_delete_enable_ovr(scf_instance_t *inst)
16927c478bd9Sstevel@tonic-gate {
1693*8fff7887SJohn Levon int r = scf_instance_delete_prop(inst, SCF_PG_GENERAL_OVR,
1694*8fff7887SJohn Levon SCF_PROPERTY_ENABLED);
1695*8fff7887SJohn Levon if (r != 0)
1696*8fff7887SJohn Levon return (r);
1697eb1a3463STruong Nguyen return (scf_instance_delete_prop(inst, SCF_PG_GENERAL_OVR,
1698*8fff7887SJohn Levon SCF_PROPERTY_COMMENT));
16997c478bd9Sstevel@tonic-gate }
17007c478bd9Sstevel@tonic-gate
17017c478bd9Sstevel@tonic-gate /*
17027c478bd9Sstevel@tonic-gate * Fails with
17037c478bd9Sstevel@tonic-gate * ECONNABORTED - repository connection was broken
17047c478bd9Sstevel@tonic-gate * ECANCELED - pg was deleted
17057c478bd9Sstevel@tonic-gate * ENOENT - pg has no milestone property
17067c478bd9Sstevel@tonic-gate * EINVAL - the milestone property is misconfigured
17077c478bd9Sstevel@tonic-gate */
17087c478bd9Sstevel@tonic-gate static int
pg_get_milestone(scf_propertygroup_t * pg,scf_property_t * prop,scf_value_t * val,char * buf,size_t buf_sz)17097c478bd9Sstevel@tonic-gate pg_get_milestone(scf_propertygroup_t *pg, scf_property_t *prop,
17107c478bd9Sstevel@tonic-gate scf_value_t *val, char *buf, size_t buf_sz)
17117c478bd9Sstevel@tonic-gate {
17127c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, SCF_PROPERTY_MILESTONE, prop) != 0) {
17137c478bd9Sstevel@tonic-gate switch (scf_error()) {
17147c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
17157c478bd9Sstevel@tonic-gate default:
17167c478bd9Sstevel@tonic-gate return (ECONNABORTED);
17177c478bd9Sstevel@tonic-gate
17187c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
17197c478bd9Sstevel@tonic-gate return (ECANCELED);
17207c478bd9Sstevel@tonic-gate
17217c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
17227c478bd9Sstevel@tonic-gate return (ENOENT);
17237c478bd9Sstevel@tonic-gate
17247c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
17257c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
17267c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
17277c478bd9Sstevel@tonic-gate bad_error("scf_pg_get_property", scf_error());
17287c478bd9Sstevel@tonic-gate }
17297c478bd9Sstevel@tonic-gate }
17307c478bd9Sstevel@tonic-gate
17317c478bd9Sstevel@tonic-gate if (scf_property_get_value(prop, val) != 0) {
17327c478bd9Sstevel@tonic-gate switch (scf_error()) {
17337c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
17347c478bd9Sstevel@tonic-gate default:
17357c478bd9Sstevel@tonic-gate return (ECONNABORTED);
17367c478bd9Sstevel@tonic-gate
17377c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
17387c478bd9Sstevel@tonic-gate case SCF_ERROR_CONSTRAINT_VIOLATED:
17397c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
17407c478bd9Sstevel@tonic-gate return (EINVAL);
17417c478bd9Sstevel@tonic-gate
17427c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
17433eae19d9Swesolows case SCF_ERROR_PERMISSION_DENIED:
17447c478bd9Sstevel@tonic-gate bad_error("scf_property_get_value", scf_error());
17457c478bd9Sstevel@tonic-gate }
17467c478bd9Sstevel@tonic-gate }
17477c478bd9Sstevel@tonic-gate
17487c478bd9Sstevel@tonic-gate if (scf_value_get_astring(val, buf, buf_sz) < 0) {
17497c478bd9Sstevel@tonic-gate switch (scf_error()) {
17507c478bd9Sstevel@tonic-gate case SCF_ERROR_TYPE_MISMATCH:
17517c478bd9Sstevel@tonic-gate return (EINVAL);
17527c478bd9Sstevel@tonic-gate
17537c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
17547c478bd9Sstevel@tonic-gate default:
17557c478bd9Sstevel@tonic-gate bad_error("scf_value_get_astring", scf_error());
17567c478bd9Sstevel@tonic-gate }
17577c478bd9Sstevel@tonic-gate }
17587c478bd9Sstevel@tonic-gate
17597c478bd9Sstevel@tonic-gate return (0);
17607c478bd9Sstevel@tonic-gate }
17617c478bd9Sstevel@tonic-gate
17627c478bd9Sstevel@tonic-gate /*
17637c478bd9Sstevel@tonic-gate * Fails with
17647c478bd9Sstevel@tonic-gate * ECONNABORTED - repository connection was broken
17657c478bd9Sstevel@tonic-gate * ECANCELED - inst was deleted
17667c478bd9Sstevel@tonic-gate * ENOENT - inst has no milestone property
17677c478bd9Sstevel@tonic-gate * EINVAL - the milestone property is misconfigured
17687c478bd9Sstevel@tonic-gate */
17697c478bd9Sstevel@tonic-gate int
libscf_get_milestone(scf_instance_t * inst,scf_property_t * prop,scf_value_t * val,char * buf,size_t buf_sz)17707c478bd9Sstevel@tonic-gate libscf_get_milestone(scf_instance_t *inst, scf_property_t *prop,
17717c478bd9Sstevel@tonic-gate scf_value_t *val, char *buf, size_t buf_sz)
17727c478bd9Sstevel@tonic-gate {
17737c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg;
17747c478bd9Sstevel@tonic-gate int r;
17757c478bd9Sstevel@tonic-gate
17767c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(scf_instance_handle(inst));
17777c478bd9Sstevel@tonic-gate
17787c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(inst, SCF_PG_OPTIONS_OVR, pg) == 0) {
17797c478bd9Sstevel@tonic-gate switch (r = pg_get_milestone(pg, prop, val, buf, buf_sz)) {
17807c478bd9Sstevel@tonic-gate case 0:
17817c478bd9Sstevel@tonic-gate case ECONNABORTED:
17827c478bd9Sstevel@tonic-gate case EINVAL:
17837c478bd9Sstevel@tonic-gate goto out;
17847c478bd9Sstevel@tonic-gate
17857c478bd9Sstevel@tonic-gate case ECANCELED:
17867c478bd9Sstevel@tonic-gate case ENOENT:
17877c478bd9Sstevel@tonic-gate break;
17887c478bd9Sstevel@tonic-gate
17897c478bd9Sstevel@tonic-gate default:
17907c478bd9Sstevel@tonic-gate bad_error("pg_get_milestone", r);
17917c478bd9Sstevel@tonic-gate }
17927c478bd9Sstevel@tonic-gate } else {
17937c478bd9Sstevel@tonic-gate switch (scf_error()) {
17947c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
17957c478bd9Sstevel@tonic-gate default:
17967c478bd9Sstevel@tonic-gate r = ECONNABORTED;
17977c478bd9Sstevel@tonic-gate goto out;
17987c478bd9Sstevel@tonic-gate
17997c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
18007c478bd9Sstevel@tonic-gate r = ECANCELED;
18017c478bd9Sstevel@tonic-gate goto out;
18027c478bd9Sstevel@tonic-gate
18037c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
18047c478bd9Sstevel@tonic-gate break;
18057c478bd9Sstevel@tonic-gate
18067c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
18077c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
18087c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
18097c478bd9Sstevel@tonic-gate bad_error("scf_instance_get_pg", scf_error());
18107c478bd9Sstevel@tonic-gate }
18117c478bd9Sstevel@tonic-gate }
18127c478bd9Sstevel@tonic-gate
18137c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(inst, SCF_PG_OPTIONS, pg) == 0) {
18147c478bd9Sstevel@tonic-gate r = pg_get_milestone(pg, prop, val, buf, buf_sz);
18157c478bd9Sstevel@tonic-gate } else {
18167c478bd9Sstevel@tonic-gate switch (scf_error()) {
18177c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
18187c478bd9Sstevel@tonic-gate default:
18197c478bd9Sstevel@tonic-gate r = ECONNABORTED;
18207c478bd9Sstevel@tonic-gate goto out;
18217c478bd9Sstevel@tonic-gate
18227c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
18237c478bd9Sstevel@tonic-gate r = ECANCELED;
18247c478bd9Sstevel@tonic-gate goto out;
18257c478bd9Sstevel@tonic-gate
18267c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
18277c478bd9Sstevel@tonic-gate r = ENOENT;
18287c478bd9Sstevel@tonic-gate break;
18297c478bd9Sstevel@tonic-gate
18307c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
18317c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
18327c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
18337c478bd9Sstevel@tonic-gate bad_error("scf_instance_get_pg", scf_error());
18347c478bd9Sstevel@tonic-gate }
18357c478bd9Sstevel@tonic-gate }
18367c478bd9Sstevel@tonic-gate
18377c478bd9Sstevel@tonic-gate out:
18387c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
18397c478bd9Sstevel@tonic-gate
18407c478bd9Sstevel@tonic-gate return (r);
18417c478bd9Sstevel@tonic-gate }
18427c478bd9Sstevel@tonic-gate
18437c478bd9Sstevel@tonic-gate /*
18447c478bd9Sstevel@tonic-gate * Get the runlevel character from the runlevel property of the given property
18457c478bd9Sstevel@tonic-gate * group. Fails with
18467c478bd9Sstevel@tonic-gate * ECONNABORTED - repository connection was broken
18477c478bd9Sstevel@tonic-gate * ECANCELED - prop's property group was deleted
18487c478bd9Sstevel@tonic-gate * ENOENT - the property has no values
18497c478bd9Sstevel@tonic-gate * EINVAL - the property has more than one value
18507c478bd9Sstevel@tonic-gate * the property is of the wrong type
18517c478bd9Sstevel@tonic-gate * the property value is malformed
18527c478bd9Sstevel@tonic-gate */
18537c478bd9Sstevel@tonic-gate int
libscf_extract_runlevel(scf_property_t * prop,char * rlp)18547c478bd9Sstevel@tonic-gate libscf_extract_runlevel(scf_property_t *prop, char *rlp)
18557c478bd9Sstevel@tonic-gate {
18567c478bd9Sstevel@tonic-gate scf_value_t *val;
18577c478bd9Sstevel@tonic-gate char buf[2];
18587c478bd9Sstevel@tonic-gate
18597c478bd9Sstevel@tonic-gate val = safe_scf_value_create(scf_property_handle(prop));
18607c478bd9Sstevel@tonic-gate
18617c478bd9Sstevel@tonic-gate if (scf_property_get_value(prop, val) != 0) {
1862a9cdd230SMilan Jurik scf_value_destroy(val);
18637c478bd9Sstevel@tonic-gate switch (scf_error()) {
18647c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
18657c478bd9Sstevel@tonic-gate return (ECONNABORTED);
18667c478bd9Sstevel@tonic-gate
18677c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
18687c478bd9Sstevel@tonic-gate return (ENOENT);
18697c478bd9Sstevel@tonic-gate
18707c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
18717c478bd9Sstevel@tonic-gate return (ECANCELED);
18727c478bd9Sstevel@tonic-gate
18737c478bd9Sstevel@tonic-gate case SCF_ERROR_CONSTRAINT_VIOLATED:
18747c478bd9Sstevel@tonic-gate return (EINVAL);
18757c478bd9Sstevel@tonic-gate
18767c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
18777c478bd9Sstevel@tonic-gate return (ENOENT);
18787c478bd9Sstevel@tonic-gate
18797c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
18807c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_BOUND:
18813eae19d9Swesolows case SCF_ERROR_PERMISSION_DENIED:
18827c478bd9Sstevel@tonic-gate default:
18837c478bd9Sstevel@tonic-gate bad_error("scf_property_get_value", scf_error());
18847c478bd9Sstevel@tonic-gate }
18857c478bd9Sstevel@tonic-gate }
18867c478bd9Sstevel@tonic-gate
18877c478bd9Sstevel@tonic-gate if (scf_value_get_astring(val, buf, sizeof (buf)) < 0) {
1888a9cdd230SMilan Jurik scf_value_destroy(val);
18897c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_TYPE_MISMATCH)
18907c478bd9Sstevel@tonic-gate bad_error("scf_value_get_astring", scf_error());
18917c478bd9Sstevel@tonic-gate
18927c478bd9Sstevel@tonic-gate return (EINVAL);
18937c478bd9Sstevel@tonic-gate }
18947c478bd9Sstevel@tonic-gate
1895a9cdd230SMilan Jurik scf_value_destroy(val);
1896a9cdd230SMilan Jurik
18977c478bd9Sstevel@tonic-gate if (buf[0] == '\0' || buf[1] != '\0')
18987c478bd9Sstevel@tonic-gate return (EINVAL);
18997c478bd9Sstevel@tonic-gate
19007c478bd9Sstevel@tonic-gate *rlp = buf[0];
19017c478bd9Sstevel@tonic-gate
19027c478bd9Sstevel@tonic-gate return (0);
19037c478bd9Sstevel@tonic-gate }
19047c478bd9Sstevel@tonic-gate
19057c478bd9Sstevel@tonic-gate /*
19067c478bd9Sstevel@tonic-gate * Delete the "runlevel" property from the given property group. Also set the
19077c478bd9Sstevel@tonic-gate * "milestone" property to the given string. Fails with ECONNABORTED,
19087c478bd9Sstevel@tonic-gate * ECANCELED, EPERM, EACCES, or EROFS.
19097c478bd9Sstevel@tonic-gate */
19107c478bd9Sstevel@tonic-gate int
libscf_clear_runlevel(scf_propertygroup_t * pg,const char * milestone)19117c478bd9Sstevel@tonic-gate libscf_clear_runlevel(scf_propertygroup_t *pg, const char *milestone)
19127c478bd9Sstevel@tonic-gate {
19137c478bd9Sstevel@tonic-gate scf_handle_t *h;
19147c478bd9Sstevel@tonic-gate scf_transaction_t *tx;
19157c478bd9Sstevel@tonic-gate scf_transaction_entry_t *e_rl, *e_ms;
19167c478bd9Sstevel@tonic-gate scf_value_t *val;
19177c478bd9Sstevel@tonic-gate scf_error_t serr;
19187c478bd9Sstevel@tonic-gate boolean_t isempty = B_TRUE;
19197c478bd9Sstevel@tonic-gate int ret = 0, r;
19207c478bd9Sstevel@tonic-gate
19217c478bd9Sstevel@tonic-gate h = scf_pg_handle(pg);
19227c478bd9Sstevel@tonic-gate tx = safe_scf_transaction_create(h);
19237c478bd9Sstevel@tonic-gate e_rl = safe_scf_entry_create(h);
19247c478bd9Sstevel@tonic-gate e_ms = safe_scf_entry_create(h);
19257c478bd9Sstevel@tonic-gate val = safe_scf_value_create(h);
19267c478bd9Sstevel@tonic-gate
19277c478bd9Sstevel@tonic-gate if (milestone) {
19287c478bd9Sstevel@tonic-gate r = scf_value_set_astring(val, milestone);
19297c478bd9Sstevel@tonic-gate assert(r == 0);
19307c478bd9Sstevel@tonic-gate }
19317c478bd9Sstevel@tonic-gate
19327c478bd9Sstevel@tonic-gate for (;;) {
19337c478bd9Sstevel@tonic-gate if (scf_transaction_start(tx, pg) != 0) {
19347c478bd9Sstevel@tonic-gate switch (scf_error()) {
19357c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
19367c478bd9Sstevel@tonic-gate default:
19377c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
19387c478bd9Sstevel@tonic-gate goto out;
19397c478bd9Sstevel@tonic-gate
19407c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
19417c478bd9Sstevel@tonic-gate ret = ECANCELED;
19427c478bd9Sstevel@tonic-gate goto out;
19437c478bd9Sstevel@tonic-gate
19447c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
19457c478bd9Sstevel@tonic-gate ret = EPERM;
19467c478bd9Sstevel@tonic-gate goto out;
19477c478bd9Sstevel@tonic-gate
19487c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
19497c478bd9Sstevel@tonic-gate ret = EACCES;
19507c478bd9Sstevel@tonic-gate goto out;
19517c478bd9Sstevel@tonic-gate
19527c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
19537c478bd9Sstevel@tonic-gate ret = EROFS;
19547c478bd9Sstevel@tonic-gate goto out;
19557c478bd9Sstevel@tonic-gate
19567c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
19577c478bd9Sstevel@tonic-gate bad_error("scf_transaction_start", scf_error());
19587c478bd9Sstevel@tonic-gate }
19597c478bd9Sstevel@tonic-gate }
19607c478bd9Sstevel@tonic-gate
19617c478bd9Sstevel@tonic-gate if (scf_transaction_property_delete(tx, e_rl,
19627c478bd9Sstevel@tonic-gate "runlevel") == 0) {
19637c478bd9Sstevel@tonic-gate isempty = B_FALSE;
19647c478bd9Sstevel@tonic-gate } else {
19657c478bd9Sstevel@tonic-gate switch (scf_error()) {
19667c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
19677c478bd9Sstevel@tonic-gate default:
19687c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
19697c478bd9Sstevel@tonic-gate goto out;
19707c478bd9Sstevel@tonic-gate
19717c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
19727c478bd9Sstevel@tonic-gate ret = ECANCELED;
19737c478bd9Sstevel@tonic-gate goto out;
19747c478bd9Sstevel@tonic-gate
19757c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
19767c478bd9Sstevel@tonic-gate break;
19777c478bd9Sstevel@tonic-gate
19787c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
19797c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_BOUND:
19807c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
19817c478bd9Sstevel@tonic-gate bad_error("scf_transaction_property_delete",
19827c478bd9Sstevel@tonic-gate scf_error());
19837c478bd9Sstevel@tonic-gate }
19847c478bd9Sstevel@tonic-gate }
19857c478bd9Sstevel@tonic-gate
19867c478bd9Sstevel@tonic-gate if (milestone) {
19877c478bd9Sstevel@tonic-gate ret = transaction_add_set(tx, e_ms,
19887c478bd9Sstevel@tonic-gate SCF_PROPERTY_MILESTONE, SCF_TYPE_ASTRING);
19897c478bd9Sstevel@tonic-gate switch (ret) {
19907c478bd9Sstevel@tonic-gate case 0:
19917c478bd9Sstevel@tonic-gate break;
19927c478bd9Sstevel@tonic-gate
19937c478bd9Sstevel@tonic-gate case ECONNABORTED:
19947c478bd9Sstevel@tonic-gate case ECANCELED:
19957c478bd9Sstevel@tonic-gate goto out;
19967c478bd9Sstevel@tonic-gate
19977c478bd9Sstevel@tonic-gate default:
19987c478bd9Sstevel@tonic-gate bad_error("transaction_add_set", ret);
19997c478bd9Sstevel@tonic-gate }
20007c478bd9Sstevel@tonic-gate
20017c478bd9Sstevel@tonic-gate isempty = B_FALSE;
20027c478bd9Sstevel@tonic-gate
20037c478bd9Sstevel@tonic-gate r = scf_entry_add_value(e_ms, val);
20047c478bd9Sstevel@tonic-gate assert(r == 0);
20057c478bd9Sstevel@tonic-gate }
20067c478bd9Sstevel@tonic-gate
20077c478bd9Sstevel@tonic-gate if (isempty)
20087c478bd9Sstevel@tonic-gate goto out;
20097c478bd9Sstevel@tonic-gate
20107c478bd9Sstevel@tonic-gate r = scf_transaction_commit(tx);
20117c478bd9Sstevel@tonic-gate if (r == 1)
20127c478bd9Sstevel@tonic-gate break;
20137c478bd9Sstevel@tonic-gate if (r != 0) {
20147c478bd9Sstevel@tonic-gate serr = scf_error();
20157c478bd9Sstevel@tonic-gate scf_transaction_reset(tx);
20167c478bd9Sstevel@tonic-gate switch (serr) {
20177c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
20187c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
20197c478bd9Sstevel@tonic-gate goto out;
20207c478bd9Sstevel@tonic-gate
20217c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
20227c478bd9Sstevel@tonic-gate ret = EPERM;
20237c478bd9Sstevel@tonic-gate goto out;
20247c478bd9Sstevel@tonic-gate
20257c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
20267c478bd9Sstevel@tonic-gate ret = EACCES;
20277c478bd9Sstevel@tonic-gate goto out;
20287c478bd9Sstevel@tonic-gate
20297c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
20307c478bd9Sstevel@tonic-gate ret = EROFS;
20317c478bd9Sstevel@tonic-gate goto out;
20327c478bd9Sstevel@tonic-gate
20337c478bd9Sstevel@tonic-gate default:
20347c478bd9Sstevel@tonic-gate bad_error("scf_transaction_commit", serr);
20357c478bd9Sstevel@tonic-gate }
20367c478bd9Sstevel@tonic-gate }
20377c478bd9Sstevel@tonic-gate
20387c478bd9Sstevel@tonic-gate scf_transaction_reset(tx);
20397c478bd9Sstevel@tonic-gate
20407c478bd9Sstevel@tonic-gate if (scf_pg_update(pg) == -1) {
20417c478bd9Sstevel@tonic-gate switch (scf_error()) {
20427c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
20437c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
20447c478bd9Sstevel@tonic-gate goto out;
20457c478bd9Sstevel@tonic-gate
20467c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
20477c478bd9Sstevel@tonic-gate ret = ECANCELED;
20487c478bd9Sstevel@tonic-gate goto out;
20497c478bd9Sstevel@tonic-gate
20507c478bd9Sstevel@tonic-gate default:
20517c478bd9Sstevel@tonic-gate assert(0);
20527c478bd9Sstevel@tonic-gate abort();
20537c478bd9Sstevel@tonic-gate }
20547c478bd9Sstevel@tonic-gate }
20557c478bd9Sstevel@tonic-gate }
20567c478bd9Sstevel@tonic-gate
20577c478bd9Sstevel@tonic-gate out:
20587c478bd9Sstevel@tonic-gate scf_transaction_destroy(tx);
20597c478bd9Sstevel@tonic-gate scf_entry_destroy(e_rl);
20607c478bd9Sstevel@tonic-gate scf_entry_destroy(e_ms);
20617c478bd9Sstevel@tonic-gate scf_value_destroy(val);
20627c478bd9Sstevel@tonic-gate return (ret);
20637c478bd9Sstevel@tonic-gate }
20647c478bd9Sstevel@tonic-gate
20657c478bd9Sstevel@tonic-gate /*
20667c478bd9Sstevel@tonic-gate * int libscf_get_template_values(scf_instance_t *, scf_snapshot_t *,
20677c478bd9Sstevel@tonic-gate * char **)
20687c478bd9Sstevel@tonic-gate *
20697c478bd9Sstevel@tonic-gate * Return template values for inst in *common_name suitable for use in
20707c478bd9Sstevel@tonic-gate * restarter_inst_t->ri_common_name. Called by restarter_insert_inst().
20717c478bd9Sstevel@tonic-gate *
20727c478bd9Sstevel@tonic-gate * Returns 0 on success, ECANCELED if the instance is deleted, ECHILD if
20737c478bd9Sstevel@tonic-gate * a value fetch failed for a property, ENOENT if the instance has no
20747c478bd9Sstevel@tonic-gate * tm_common_name property group or the property group is deleted, and
20757c478bd9Sstevel@tonic-gate * ECONNABORTED if the repository connection is broken.
20767c478bd9Sstevel@tonic-gate */
20777c478bd9Sstevel@tonic-gate int
libscf_get_template_values(scf_instance_t * inst,scf_snapshot_t * snap,char ** common_name,char ** c_common_name)20787c478bd9Sstevel@tonic-gate libscf_get_template_values(scf_instance_t *inst, scf_snapshot_t *snap,
20797c478bd9Sstevel@tonic-gate char **common_name, char **c_common_name)
20807c478bd9Sstevel@tonic-gate {
20817c478bd9Sstevel@tonic-gate scf_handle_t *h;
20827c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg = NULL;
20837c478bd9Sstevel@tonic-gate scf_property_t *prop = NULL;
20847c478bd9Sstevel@tonic-gate int ret = 0, r;
20857c478bd9Sstevel@tonic-gate char *cname = startd_alloc(max_scf_value_size);
20867c478bd9Sstevel@tonic-gate char *c_cname = startd_alloc(max_scf_value_size);
208792175b8eSrm int common_name_initialized = B_FALSE;
208892175b8eSrm int c_common_name_initialized = B_FALSE;
20897c478bd9Sstevel@tonic-gate
20907c478bd9Sstevel@tonic-gate h = scf_instance_handle(inst);
20917c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h);
20927c478bd9Sstevel@tonic-gate prop = safe_scf_property_create(h);
20937c478bd9Sstevel@tonic-gate
20947c478bd9Sstevel@tonic-gate /*
20957c478bd9Sstevel@tonic-gate * The tm_common_name property group, as with all template property
20967c478bd9Sstevel@tonic-gate * groups, is optional.
20977c478bd9Sstevel@tonic-gate */
20987c478bd9Sstevel@tonic-gate if (scf_instance_get_pg_composed(inst, snap, SCF_PG_TM_COMMON_NAME, pg)
20997c478bd9Sstevel@tonic-gate == -1) {
21007c478bd9Sstevel@tonic-gate switch (scf_error()) {
21017c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
21027c478bd9Sstevel@tonic-gate ret = ECANCELED;
21037c478bd9Sstevel@tonic-gate goto template_values_out;
21047c478bd9Sstevel@tonic-gate
21057c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
21067c478bd9Sstevel@tonic-gate goto template_values_out;
21077c478bd9Sstevel@tonic-gate
21087c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
21097c478bd9Sstevel@tonic-gate default:
21107c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
21117c478bd9Sstevel@tonic-gate goto template_values_out;
21127c478bd9Sstevel@tonic-gate
21137c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
21147c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
21157c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
21167c478bd9Sstevel@tonic-gate bad_error("scf_instance_get_pg_composed", scf_error());
21177c478bd9Sstevel@tonic-gate }
21187c478bd9Sstevel@tonic-gate }
21197c478bd9Sstevel@tonic-gate
21207c478bd9Sstevel@tonic-gate /*
21217c478bd9Sstevel@tonic-gate * The name we wish uses the current locale name as the property name.
21227c478bd9Sstevel@tonic-gate */
21237c478bd9Sstevel@tonic-gate if (st->st_locale != NULL) {
21247c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, st->st_locale, prop) == -1) {
21257c478bd9Sstevel@tonic-gate switch (scf_error()) {
21267c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
21277c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
21287c478bd9Sstevel@tonic-gate break;
21297c478bd9Sstevel@tonic-gate
21307c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
21317c478bd9Sstevel@tonic-gate default:
21327c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
21337c478bd9Sstevel@tonic-gate goto template_values_out;
21347c478bd9Sstevel@tonic-gate
21357c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
21367c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
21377c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
21387c478bd9Sstevel@tonic-gate bad_error("scf_pg_get_property", scf_error());
21397c478bd9Sstevel@tonic-gate }
21407c478bd9Sstevel@tonic-gate } else {
21417c478bd9Sstevel@tonic-gate if ((r = libscf_read_single_astring(h, prop, &cname)) !=
21427c478bd9Sstevel@tonic-gate 0) {
21437c478bd9Sstevel@tonic-gate if (r != LIBSCF_PROPERTY_ABSENT)
21447c478bd9Sstevel@tonic-gate ret = ECHILD;
21457c478bd9Sstevel@tonic-gate goto template_values_out;
21467c478bd9Sstevel@tonic-gate }
21477c478bd9Sstevel@tonic-gate
21487c478bd9Sstevel@tonic-gate *common_name = cname;
214992175b8eSrm common_name_initialized = B_TRUE;
21507c478bd9Sstevel@tonic-gate }
21517c478bd9Sstevel@tonic-gate }
21527c478bd9Sstevel@tonic-gate
21537c478bd9Sstevel@tonic-gate /*
21547c478bd9Sstevel@tonic-gate * Also pull out the C locale name, as a fallback for the case where
21557c478bd9Sstevel@tonic-gate * service offers no localized name.
21567c478bd9Sstevel@tonic-gate */
21577c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, "C", prop) == -1) {
21587c478bd9Sstevel@tonic-gate switch (scf_error()) {
21597c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
21607c478bd9Sstevel@tonic-gate ret = ENOENT;
21617c478bd9Sstevel@tonic-gate goto template_values_out;
21627c478bd9Sstevel@tonic-gate
21637c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
21647c478bd9Sstevel@tonic-gate break;
21657c478bd9Sstevel@tonic-gate
21667c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
21677c478bd9Sstevel@tonic-gate default:
21687c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
21697c478bd9Sstevel@tonic-gate goto template_values_out;
21707c478bd9Sstevel@tonic-gate
21717c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
21727c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
21737c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
21747c478bd9Sstevel@tonic-gate bad_error("scf_pg_get_property", scf_error());
21757c478bd9Sstevel@tonic-gate }
21767c478bd9Sstevel@tonic-gate } else {
21777c478bd9Sstevel@tonic-gate if ((r = libscf_read_single_astring(h, prop, &c_cname)) != 0) {
21787c478bd9Sstevel@tonic-gate if (r != LIBSCF_PROPERTY_ABSENT)
21797c478bd9Sstevel@tonic-gate ret = ECHILD;
21807c478bd9Sstevel@tonic-gate goto template_values_out;
21817c478bd9Sstevel@tonic-gate }
21827c478bd9Sstevel@tonic-gate
21837c478bd9Sstevel@tonic-gate *c_common_name = c_cname;
218492175b8eSrm c_common_name_initialized = B_TRUE;
21857c478bd9Sstevel@tonic-gate }
21867c478bd9Sstevel@tonic-gate
21877c478bd9Sstevel@tonic-gate
21887c478bd9Sstevel@tonic-gate template_values_out:
218992175b8eSrm if (common_name_initialized == B_FALSE)
219092175b8eSrm startd_free(cname, max_scf_value_size);
219192175b8eSrm if (c_common_name_initialized == B_FALSE)
219292175b8eSrm startd_free(c_cname, max_scf_value_size);
21937c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
21947c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
21957c478bd9Sstevel@tonic-gate
21967c478bd9Sstevel@tonic-gate return (ret);
21977c478bd9Sstevel@tonic-gate }
21987c478bd9Sstevel@tonic-gate
21997c478bd9Sstevel@tonic-gate /*
22007c478bd9Sstevel@tonic-gate * int libscf_get_startd_properties(scf_handle_t *, scf_instance_t *,
22017c478bd9Sstevel@tonic-gate * scf_snapshot_t *, uint_t *, char **)
22027c478bd9Sstevel@tonic-gate *
22037c478bd9Sstevel@tonic-gate * Return startd settings for inst in *flags suitable for use in
22047c478bd9Sstevel@tonic-gate * restarter_inst_t->ri_flags. Called by restarter_insert_inst().
22057c478bd9Sstevel@tonic-gate *
22067c478bd9Sstevel@tonic-gate * Returns 0 on success, ECANCELED if the instance is deleted, ECHILD if
22077c478bd9Sstevel@tonic-gate * a value fetch failed for a property, ENOENT if the instance has no
22087c478bd9Sstevel@tonic-gate * general property group or the property group is deleted, and
22097c478bd9Sstevel@tonic-gate * ECONNABORTED if the repository connection is broken.
22107c478bd9Sstevel@tonic-gate */
22117c478bd9Sstevel@tonic-gate int
libscf_get_startd_properties(scf_instance_t * inst,scf_snapshot_t * snap,uint_t * flags,char ** prefixp)22127c478bd9Sstevel@tonic-gate libscf_get_startd_properties(scf_instance_t *inst,
22137c478bd9Sstevel@tonic-gate scf_snapshot_t *snap, uint_t *flags, char **prefixp)
22147c478bd9Sstevel@tonic-gate {
22157c478bd9Sstevel@tonic-gate scf_handle_t *h;
22167c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg = NULL;
22177c478bd9Sstevel@tonic-gate scf_property_t *prop = NULL;
22187c478bd9Sstevel@tonic-gate int style = RINST_CONTRACT;
22197c478bd9Sstevel@tonic-gate char *style_str = startd_alloc(max_scf_value_size);
22207c478bd9Sstevel@tonic-gate int ret = 0, r;
22217c478bd9Sstevel@tonic-gate
22227c478bd9Sstevel@tonic-gate h = scf_instance_handle(inst);
22237c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h);
22247c478bd9Sstevel@tonic-gate prop = safe_scf_property_create(h);
22257c478bd9Sstevel@tonic-gate
22267c478bd9Sstevel@tonic-gate /*
22277c478bd9Sstevel@tonic-gate * The startd property group is optional.
22287c478bd9Sstevel@tonic-gate */
22297c478bd9Sstevel@tonic-gate if (scf_instance_get_pg_composed(inst, snap, SCF_PG_STARTD, pg) == -1) {
22307c478bd9Sstevel@tonic-gate switch (scf_error()) {
22317c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
22327c478bd9Sstevel@tonic-gate ret = ECANCELED;
22337c478bd9Sstevel@tonic-gate goto instance_flags_out;
22347c478bd9Sstevel@tonic-gate
22357c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
22367c478bd9Sstevel@tonic-gate ret = ENOENT;
22377c478bd9Sstevel@tonic-gate goto instance_flags_out;
22387c478bd9Sstevel@tonic-gate
22397c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
22407c478bd9Sstevel@tonic-gate default:
22417c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
22427c478bd9Sstevel@tonic-gate goto instance_flags_out;
22437c478bd9Sstevel@tonic-gate
22447c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
22457c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
22467c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
22477c478bd9Sstevel@tonic-gate bad_error("scf_instance_get_pg_composed", scf_error());
22487c478bd9Sstevel@tonic-gate }
22497c478bd9Sstevel@tonic-gate }
22507c478bd9Sstevel@tonic-gate
22517c478bd9Sstevel@tonic-gate /*
22527c478bd9Sstevel@tonic-gate * 1. Duration property.
22537c478bd9Sstevel@tonic-gate */
22547c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, SCF_PROPERTY_DURATION, prop) == -1) {
22557c478bd9Sstevel@tonic-gate switch (scf_error()) {
22567c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
22577c478bd9Sstevel@tonic-gate ret = ENOENT;
22587c478bd9Sstevel@tonic-gate goto instance_flags_out;
22597c478bd9Sstevel@tonic-gate
22607c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
22617c478bd9Sstevel@tonic-gate break;
22627c478bd9Sstevel@tonic-gate
22637c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
22647c478bd9Sstevel@tonic-gate default:
22657c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
22667c478bd9Sstevel@tonic-gate goto instance_flags_out;
22677c478bd9Sstevel@tonic-gate
22687c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
22697c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
22707c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
22717c478bd9Sstevel@tonic-gate bad_error("scf_pg_get_property", scf_error());
22727c478bd9Sstevel@tonic-gate }
22737c478bd9Sstevel@tonic-gate } else {
22747c478bd9Sstevel@tonic-gate errno = 0;
22757c478bd9Sstevel@tonic-gate if ((r = libscf_read_single_astring(h, prop, &style_str))
22767c478bd9Sstevel@tonic-gate != 0) {
22777c478bd9Sstevel@tonic-gate if (r != LIBSCF_PROPERTY_ABSENT)
22787c478bd9Sstevel@tonic-gate ret = ECHILD;
22797c478bd9Sstevel@tonic-gate goto instance_flags_out;
22807c478bd9Sstevel@tonic-gate }
22817c478bd9Sstevel@tonic-gate
22827c478bd9Sstevel@tonic-gate if (strcmp(style_str, "child") == 0)
22837c478bd9Sstevel@tonic-gate style = RINST_WAIT;
22847c478bd9Sstevel@tonic-gate else if (strcmp(style_str, "transient") == 0)
22857c478bd9Sstevel@tonic-gate style = RINST_TRANSIENT;
22867c478bd9Sstevel@tonic-gate }
22877c478bd9Sstevel@tonic-gate
22887c478bd9Sstevel@tonic-gate /*
22897c478bd9Sstevel@tonic-gate * 2. utmpx prefix property.
22907c478bd9Sstevel@tonic-gate */
22917c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, SCF_PROPERTY_UTMPX_PREFIX, prop) == 0) {
22927c478bd9Sstevel@tonic-gate errno = 0;
22937c478bd9Sstevel@tonic-gate if ((r = libscf_read_single_astring(h, prop, prefixp)) != 0) {
22947c478bd9Sstevel@tonic-gate if (r != LIBSCF_PROPERTY_ABSENT)
22957c478bd9Sstevel@tonic-gate ret = ECHILD;
22967c478bd9Sstevel@tonic-gate goto instance_flags_out;
22977c478bd9Sstevel@tonic-gate }
22987c478bd9Sstevel@tonic-gate } else {
22997c478bd9Sstevel@tonic-gate switch (scf_error()) {
23007c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
23017c478bd9Sstevel@tonic-gate ret = ENOENT;
23027c478bd9Sstevel@tonic-gate goto instance_flags_out;
23037c478bd9Sstevel@tonic-gate
23047c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
23057c478bd9Sstevel@tonic-gate goto instance_flags_out;
23067c478bd9Sstevel@tonic-gate
23077c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
23087c478bd9Sstevel@tonic-gate default:
23097c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
23107c478bd9Sstevel@tonic-gate goto instance_flags_out;
23117c478bd9Sstevel@tonic-gate
23127c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
23137c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
23147c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
23157c478bd9Sstevel@tonic-gate bad_error("scf_pg_get_property", scf_error());
23167c478bd9Sstevel@tonic-gate }
23177c478bd9Sstevel@tonic-gate }
23187c478bd9Sstevel@tonic-gate
23197c478bd9Sstevel@tonic-gate instance_flags_out:
23207c478bd9Sstevel@tonic-gate startd_free(style_str, max_scf_value_size);
23217c478bd9Sstevel@tonic-gate *flags = (*flags & ~RINST_STYLE_MASK) | style;
23227c478bd9Sstevel@tonic-gate
23237c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
23247c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
23257c478bd9Sstevel@tonic-gate
23267c478bd9Sstevel@tonic-gate return (ret);
23277c478bd9Sstevel@tonic-gate }
23287c478bd9Sstevel@tonic-gate
23297c478bd9Sstevel@tonic-gate /*
23307c478bd9Sstevel@tonic-gate * int libscf_read_method_ids(scf_handle_t *, scf_instance_t *, ctid_t *,
23317c478bd9Sstevel@tonic-gate * ctid_t *, pid_t *)
23327c478bd9Sstevel@tonic-gate *
23337c478bd9Sstevel@tonic-gate * Sets given id_t variables to primary and transient contract IDs and start
23347c478bd9Sstevel@tonic-gate * PID. Returns 0, ECONNABORTED, and ECANCELED.
23357c478bd9Sstevel@tonic-gate */
23367c478bd9Sstevel@tonic-gate int
libscf_read_method_ids(scf_handle_t * h,scf_instance_t * inst,const char * fmri,ctid_t * primary,ctid_t * transient,pid_t * start_pid)23377c478bd9Sstevel@tonic-gate libscf_read_method_ids(scf_handle_t *h, scf_instance_t *inst, const char *fmri,
23387c478bd9Sstevel@tonic-gate ctid_t *primary, ctid_t *transient, pid_t *start_pid)
23397c478bd9Sstevel@tonic-gate {
23407c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg = NULL;
23417c478bd9Sstevel@tonic-gate scf_property_t *prop = NULL;
23427c478bd9Sstevel@tonic-gate scf_value_t *val = NULL;
23437c478bd9Sstevel@tonic-gate uint64_t p, t;
23447c478bd9Sstevel@tonic-gate int ret = 0;
23457c478bd9Sstevel@tonic-gate
23467c478bd9Sstevel@tonic-gate *primary = 0;
23477c478bd9Sstevel@tonic-gate *transient = 0;
23487c478bd9Sstevel@tonic-gate *start_pid = -1;
23497c478bd9Sstevel@tonic-gate
23507c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h);
23517c478bd9Sstevel@tonic-gate prop = safe_scf_property_create(h);
23527c478bd9Sstevel@tonic-gate val = safe_scf_value_create(h);
23537c478bd9Sstevel@tonic-gate
23547c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, pg) == -1) {
23557c478bd9Sstevel@tonic-gate switch (scf_error()) {
23567c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
23577c478bd9Sstevel@tonic-gate default:
23587c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
23597c478bd9Sstevel@tonic-gate goto read_id_err;
23607c478bd9Sstevel@tonic-gate
23617c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
23627c478bd9Sstevel@tonic-gate ret = ECANCELED;
23637c478bd9Sstevel@tonic-gate goto read_id_err;
23647c478bd9Sstevel@tonic-gate
23657c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
23667c478bd9Sstevel@tonic-gate goto read_id_err;
23677c478bd9Sstevel@tonic-gate
23687c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
23697c478bd9Sstevel@tonic-gate bad_error("scf_instance_get_pg", scf_error());
23707c478bd9Sstevel@tonic-gate }
23717c478bd9Sstevel@tonic-gate }
23727c478bd9Sstevel@tonic-gate
23737c478bd9Sstevel@tonic-gate ret = get_count(pg, SCF_PROPERTY_CONTRACT, &p);
23747c478bd9Sstevel@tonic-gate switch (ret) {
23757c478bd9Sstevel@tonic-gate case 0:
23767c478bd9Sstevel@tonic-gate break;
23777c478bd9Sstevel@tonic-gate
23787c478bd9Sstevel@tonic-gate case EINVAL:
23797c478bd9Sstevel@tonic-gate log_error(LOG_NOTICE,
23807c478bd9Sstevel@tonic-gate "%s: Ignoring %s/%s: multivalued or not of type count\n",
23817c478bd9Sstevel@tonic-gate fmri, SCF_PG_RESTARTER, SCF_PROPERTY_CONTRACT);
23827c478bd9Sstevel@tonic-gate /* FALLTHROUGH */
23837c478bd9Sstevel@tonic-gate case ENOENT:
23847c478bd9Sstevel@tonic-gate ret = 0;
23857c478bd9Sstevel@tonic-gate goto read_trans;
23867c478bd9Sstevel@tonic-gate
23877c478bd9Sstevel@tonic-gate case ECONNABORTED:
23887c478bd9Sstevel@tonic-gate case ECANCELED:
23897c478bd9Sstevel@tonic-gate goto read_id_err;
23907c478bd9Sstevel@tonic-gate
23913eae19d9Swesolows case EACCES:
23927c478bd9Sstevel@tonic-gate default:
23937c478bd9Sstevel@tonic-gate bad_error("get_count", ret);
23947c478bd9Sstevel@tonic-gate }
23957c478bd9Sstevel@tonic-gate
23967c478bd9Sstevel@tonic-gate *primary = p;
23977c478bd9Sstevel@tonic-gate
23987c478bd9Sstevel@tonic-gate read_trans:
23997c478bd9Sstevel@tonic-gate ret = get_count(pg, SCF_PROPERTY_TRANSIENT_CONTRACT, &t);
24007c478bd9Sstevel@tonic-gate switch (ret) {
24017c478bd9Sstevel@tonic-gate case 0:
24027c478bd9Sstevel@tonic-gate break;
24037c478bd9Sstevel@tonic-gate
24047c478bd9Sstevel@tonic-gate case EINVAL:
24057c478bd9Sstevel@tonic-gate log_error(LOG_NOTICE,
24067c478bd9Sstevel@tonic-gate "%s: Ignoring %s/%s: multivalued or not of type count\n",
24077c478bd9Sstevel@tonic-gate fmri, SCF_PG_RESTARTER, SCF_PROPERTY_TRANSIENT_CONTRACT);
24087c478bd9Sstevel@tonic-gate /* FALLTHROUGH */
24097c478bd9Sstevel@tonic-gate
24107c478bd9Sstevel@tonic-gate case ENOENT:
24117c478bd9Sstevel@tonic-gate ret = 0;
24127c478bd9Sstevel@tonic-gate goto read_pid_only;
24137c478bd9Sstevel@tonic-gate
24147c478bd9Sstevel@tonic-gate case ECONNABORTED:
24157c478bd9Sstevel@tonic-gate case ECANCELED:
24167c478bd9Sstevel@tonic-gate goto read_id_err;
24177c478bd9Sstevel@tonic-gate
24183eae19d9Swesolows case EACCES:
24197c478bd9Sstevel@tonic-gate default:
24207c478bd9Sstevel@tonic-gate bad_error("get_count", ret);
24217c478bd9Sstevel@tonic-gate }
24227c478bd9Sstevel@tonic-gate
24237c478bd9Sstevel@tonic-gate *transient = t;
24247c478bd9Sstevel@tonic-gate
24257c478bd9Sstevel@tonic-gate read_pid_only:
24267c478bd9Sstevel@tonic-gate ret = get_count(pg, SCF_PROPERTY_START_PID, &p);
24277c478bd9Sstevel@tonic-gate switch (ret) {
24287c478bd9Sstevel@tonic-gate case 0:
24297c478bd9Sstevel@tonic-gate break;
24307c478bd9Sstevel@tonic-gate
24317c478bd9Sstevel@tonic-gate case EINVAL:
24327c478bd9Sstevel@tonic-gate log_error(LOG_NOTICE,
24337c478bd9Sstevel@tonic-gate "%s: Ignoring %s/%s: multivalued or not of type count\n",
24347c478bd9Sstevel@tonic-gate fmri, SCF_PG_RESTARTER, SCF_PROPERTY_START_PID);
24357c478bd9Sstevel@tonic-gate /* FALLTHROUGH */
24367c478bd9Sstevel@tonic-gate case ENOENT:
24377c478bd9Sstevel@tonic-gate ret = 0;
24387c478bd9Sstevel@tonic-gate goto read_id_err;
24397c478bd9Sstevel@tonic-gate
24407c478bd9Sstevel@tonic-gate case ECONNABORTED:
24417c478bd9Sstevel@tonic-gate case ECANCELED:
24427c478bd9Sstevel@tonic-gate goto read_id_err;
24437c478bd9Sstevel@tonic-gate
24443eae19d9Swesolows case EACCES:
24457c478bd9Sstevel@tonic-gate default:
24467c478bd9Sstevel@tonic-gate bad_error("get_count", ret);
24477c478bd9Sstevel@tonic-gate }
24487c478bd9Sstevel@tonic-gate
24497c478bd9Sstevel@tonic-gate *start_pid = p;
24507c478bd9Sstevel@tonic-gate
24517c478bd9Sstevel@tonic-gate read_id_err:
24527c478bd9Sstevel@tonic-gate scf_value_destroy(val);
24537c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
24547c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
24557c478bd9Sstevel@tonic-gate return (ret);
24567c478bd9Sstevel@tonic-gate }
24577c478bd9Sstevel@tonic-gate
24587c478bd9Sstevel@tonic-gate /*
24597c478bd9Sstevel@tonic-gate * Returns with
24607c478bd9Sstevel@tonic-gate * 0 - success
24617c478bd9Sstevel@tonic-gate * ECONNABORTED - repository connection broken
24627c478bd9Sstevel@tonic-gate * - unknown libscf error
24637c478bd9Sstevel@tonic-gate * ECANCELED - s_inst was deleted
24647c478bd9Sstevel@tonic-gate * EPERM
24657c478bd9Sstevel@tonic-gate * EACCES
24667c478bd9Sstevel@tonic-gate * EROFS
24677c478bd9Sstevel@tonic-gate */
24687c478bd9Sstevel@tonic-gate int
libscf_write_start_pid(scf_instance_t * s_inst,pid_t pid)24697c478bd9Sstevel@tonic-gate libscf_write_start_pid(scf_instance_t *s_inst, pid_t pid)
24707c478bd9Sstevel@tonic-gate {
24717c478bd9Sstevel@tonic-gate scf_handle_t *h;
24727c478bd9Sstevel@tonic-gate scf_transaction_entry_t *t_pid;
24737c478bd9Sstevel@tonic-gate scf_value_t *v_pid;
24747c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg;
24757c478bd9Sstevel@tonic-gate int ret = 0;
24767c478bd9Sstevel@tonic-gate
24777c478bd9Sstevel@tonic-gate h = scf_instance_handle(s_inst);
24787c478bd9Sstevel@tonic-gate
24797c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h);
24807c478bd9Sstevel@tonic-gate t_pid = safe_scf_entry_create(h);
24817c478bd9Sstevel@tonic-gate v_pid = safe_scf_value_create(h);
24827c478bd9Sstevel@tonic-gate
24837c478bd9Sstevel@tonic-gate get_pg:
24847c478bd9Sstevel@tonic-gate ret = libscf_inst_get_or_add_pg(s_inst, SCF_PG_RESTARTER,
24857c478bd9Sstevel@tonic-gate SCF_PG_RESTARTER_TYPE, SCF_PG_RESTARTER_FLAGS, pg);
24867c478bd9Sstevel@tonic-gate switch (ret) {
24877c478bd9Sstevel@tonic-gate case 0:
24887c478bd9Sstevel@tonic-gate break;
24897c478bd9Sstevel@tonic-gate
24907c478bd9Sstevel@tonic-gate case ECONNABORTED:
24917c478bd9Sstevel@tonic-gate case ECANCELED:
24927c478bd9Sstevel@tonic-gate case EPERM:
24937c478bd9Sstevel@tonic-gate case EACCES:
24947c478bd9Sstevel@tonic-gate case EROFS:
24957c478bd9Sstevel@tonic-gate goto write_start_err;
24967c478bd9Sstevel@tonic-gate
24977c478bd9Sstevel@tonic-gate default:
24987c478bd9Sstevel@tonic-gate bad_error("libscf_inst_get_or_add_pg", ret);
24997c478bd9Sstevel@tonic-gate }
25007c478bd9Sstevel@tonic-gate
25017c478bd9Sstevel@tonic-gate scf_value_set_count(v_pid, pid);
25027c478bd9Sstevel@tonic-gate
25037c478bd9Sstevel@tonic-gate ret = pg_set_prop_value(pg, SCF_PROPERTY_START_PID, v_pid);
25047c478bd9Sstevel@tonic-gate switch (ret) {
25057c478bd9Sstevel@tonic-gate case 0:
25067c478bd9Sstevel@tonic-gate case ECONNABORTED:
25077c478bd9Sstevel@tonic-gate case EPERM:
25087c478bd9Sstevel@tonic-gate case EACCES:
25097c478bd9Sstevel@tonic-gate case EROFS:
25107c478bd9Sstevel@tonic-gate break;
25117c478bd9Sstevel@tonic-gate
25127c478bd9Sstevel@tonic-gate case ECANCELED:
25137c478bd9Sstevel@tonic-gate goto get_pg;
25147c478bd9Sstevel@tonic-gate
25157c478bd9Sstevel@tonic-gate default:
25167c478bd9Sstevel@tonic-gate bad_error("pg_set_prop_value", ret);
25177c478bd9Sstevel@tonic-gate }
25187c478bd9Sstevel@tonic-gate
25197c478bd9Sstevel@tonic-gate write_start_err:
25207c478bd9Sstevel@tonic-gate scf_entry_destroy(t_pid);
25217c478bd9Sstevel@tonic-gate scf_value_destroy(v_pid);
25227c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
25237c478bd9Sstevel@tonic-gate
25247c478bd9Sstevel@tonic-gate return (ret);
25257c478bd9Sstevel@tonic-gate }
25267c478bd9Sstevel@tonic-gate
25277c478bd9Sstevel@tonic-gate /*
25287c478bd9Sstevel@tonic-gate * Add a property indicating the instance log file. If the dir is
25297c478bd9Sstevel@tonic-gate * equal to LOG_PREFIX_EARLY, then the property restarter/alt_logfile
25307c478bd9Sstevel@tonic-gate * of the instance is used; otherwise, restarter/logfile is used.
25317c478bd9Sstevel@tonic-gate *
25327c478bd9Sstevel@tonic-gate * Returns
25337c478bd9Sstevel@tonic-gate * 0 - success
25347c478bd9Sstevel@tonic-gate * ECONNABORTED
25357c478bd9Sstevel@tonic-gate * ECANCELED
25367c478bd9Sstevel@tonic-gate * EPERM
25377c478bd9Sstevel@tonic-gate * EACCES
25387c478bd9Sstevel@tonic-gate * EROFS
25397c478bd9Sstevel@tonic-gate * EAGAIN
25407c478bd9Sstevel@tonic-gate */
25417c478bd9Sstevel@tonic-gate int
libscf_note_method_log(scf_instance_t * inst,const char * dir,const char * file)25427c478bd9Sstevel@tonic-gate libscf_note_method_log(scf_instance_t *inst, const char *dir, const char *file)
25437c478bd9Sstevel@tonic-gate {
25447c478bd9Sstevel@tonic-gate scf_handle_t *h;
25457c478bd9Sstevel@tonic-gate scf_value_t *v;
25467c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg;
25477c478bd9Sstevel@tonic-gate int ret = 0;
25487c478bd9Sstevel@tonic-gate char *logname;
25497c478bd9Sstevel@tonic-gate const char *propname;
25507c478bd9Sstevel@tonic-gate
25517c478bd9Sstevel@tonic-gate h = scf_instance_handle(inst);
25527c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h);
25537c478bd9Sstevel@tonic-gate v = safe_scf_value_create(h);
25547c478bd9Sstevel@tonic-gate
25557c478bd9Sstevel@tonic-gate logname = uu_msprintf("%s%s", dir, file);
25567c478bd9Sstevel@tonic-gate
25577c478bd9Sstevel@tonic-gate if (logname == NULL) {
25587c478bd9Sstevel@tonic-gate ret = errno;
25597c478bd9Sstevel@tonic-gate goto out;
25607c478bd9Sstevel@tonic-gate }
25617c478bd9Sstevel@tonic-gate
25627c478bd9Sstevel@tonic-gate ret = libscf_inst_get_or_add_pg(inst, SCF_PG_RESTARTER,
25637c478bd9Sstevel@tonic-gate SCF_PG_RESTARTER_TYPE, SCF_PG_RESTARTER_FLAGS, pg);
25647c478bd9Sstevel@tonic-gate switch (ret) {
25657c478bd9Sstevel@tonic-gate case 0:
25667c478bd9Sstevel@tonic-gate break;
25677c478bd9Sstevel@tonic-gate
25687c478bd9Sstevel@tonic-gate case ECONNABORTED:
25697c478bd9Sstevel@tonic-gate case ECANCELED:
25707c478bd9Sstevel@tonic-gate case EPERM:
25717c478bd9Sstevel@tonic-gate case EACCES:
25727c478bd9Sstevel@tonic-gate case EROFS:
25737c478bd9Sstevel@tonic-gate goto out;
25747c478bd9Sstevel@tonic-gate
25757c478bd9Sstevel@tonic-gate default:
25767c478bd9Sstevel@tonic-gate bad_error("libscf_inst_get_or_add_pg", ret);
25777c478bd9Sstevel@tonic-gate }
25787c478bd9Sstevel@tonic-gate
25797c478bd9Sstevel@tonic-gate (void) scf_value_set_astring(v, logname);
25807c478bd9Sstevel@tonic-gate
25817c478bd9Sstevel@tonic-gate if (strcmp(LOG_PREFIX_EARLY, dir) == 0)
25827c478bd9Sstevel@tonic-gate propname = SCF_PROPERTY_ALT_LOGFILE;
25837c478bd9Sstevel@tonic-gate else
25847c478bd9Sstevel@tonic-gate propname = SCF_PROPERTY_LOGFILE;
25857c478bd9Sstevel@tonic-gate
25867c478bd9Sstevel@tonic-gate ret = pg_set_prop_value(pg, propname, v);
25877c478bd9Sstevel@tonic-gate switch (ret) {
25887c478bd9Sstevel@tonic-gate case 0:
25897c478bd9Sstevel@tonic-gate case ECONNABORTED:
25907c478bd9Sstevel@tonic-gate case ECANCELED:
25917c478bd9Sstevel@tonic-gate case EPERM:
25927c478bd9Sstevel@tonic-gate case EACCES:
25937c478bd9Sstevel@tonic-gate case EROFS:
25947c478bd9Sstevel@tonic-gate break;
25957c478bd9Sstevel@tonic-gate
25967c478bd9Sstevel@tonic-gate default:
25977c478bd9Sstevel@tonic-gate bad_error("pg_set_prop_value", ret);
25987c478bd9Sstevel@tonic-gate }
25997c478bd9Sstevel@tonic-gate
26007c478bd9Sstevel@tonic-gate out:
26017c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
26027c478bd9Sstevel@tonic-gate scf_value_destroy(v);
26037c478bd9Sstevel@tonic-gate uu_free(logname);
26047c478bd9Sstevel@tonic-gate return (ret);
26057c478bd9Sstevel@tonic-gate }
26067c478bd9Sstevel@tonic-gate
26077c478bd9Sstevel@tonic-gate /*
26087c478bd9Sstevel@tonic-gate * Returns
26097c478bd9Sstevel@tonic-gate * 0 - success
26107c478bd9Sstevel@tonic-gate * ENAMETOOLONG - name is too long
26117c478bd9Sstevel@tonic-gate * ECONNABORTED
26127c478bd9Sstevel@tonic-gate * ECANCELED
26137c478bd9Sstevel@tonic-gate * EPERM
26147c478bd9Sstevel@tonic-gate * EACCES
26157c478bd9Sstevel@tonic-gate * EROFS
26167c478bd9Sstevel@tonic-gate */
26177c478bd9Sstevel@tonic-gate int
libscf_write_method_status(scf_instance_t * s_inst,const char * name,int status)26187c478bd9Sstevel@tonic-gate libscf_write_method_status(scf_instance_t *s_inst, const char *name,
26197c478bd9Sstevel@tonic-gate int status)
26207c478bd9Sstevel@tonic-gate {
26217c478bd9Sstevel@tonic-gate scf_handle_t *h;
26227c478bd9Sstevel@tonic-gate scf_transaction_t *tx;
26237c478bd9Sstevel@tonic-gate scf_transaction_entry_t *e_time, *e_stat;
26247c478bd9Sstevel@tonic-gate scf_value_t *v_time, *v_stat;
26257c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg;
26267c478bd9Sstevel@tonic-gate int ret = 0, r;
26277c478bd9Sstevel@tonic-gate char pname[30];
26287c478bd9Sstevel@tonic-gate struct timeval tv;
26297c478bd9Sstevel@tonic-gate scf_error_t scfe;
26307c478bd9Sstevel@tonic-gate
26317c478bd9Sstevel@tonic-gate if (strlen(name) + sizeof ("_method_waitstatus") > sizeof (pname))
26327c478bd9Sstevel@tonic-gate return (ENAMETOOLONG);
26337c478bd9Sstevel@tonic-gate
26347c478bd9Sstevel@tonic-gate h = scf_instance_handle(s_inst);
26357c478bd9Sstevel@tonic-gate
26367c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h);
26377c478bd9Sstevel@tonic-gate tx = safe_scf_transaction_create(h);
26387c478bd9Sstevel@tonic-gate e_time = safe_scf_entry_create(h);
26397c478bd9Sstevel@tonic-gate v_time = safe_scf_value_create(h);
26407c478bd9Sstevel@tonic-gate e_stat = safe_scf_entry_create(h);
26417c478bd9Sstevel@tonic-gate v_stat = safe_scf_value_create(h);
26427c478bd9Sstevel@tonic-gate
26437c478bd9Sstevel@tonic-gate get_pg:
26447c478bd9Sstevel@tonic-gate ret = libscf_inst_get_or_add_pg(s_inst, SCF_PG_RESTARTER,
26457c478bd9Sstevel@tonic-gate SCF_PG_RESTARTER_TYPE, SCF_PG_RESTARTER_FLAGS, pg);
26467c478bd9Sstevel@tonic-gate switch (ret) {
26477c478bd9Sstevel@tonic-gate case 0:
26487c478bd9Sstevel@tonic-gate break;
26497c478bd9Sstevel@tonic-gate
26507c478bd9Sstevel@tonic-gate case ECONNABORTED:
26517c478bd9Sstevel@tonic-gate case ECANCELED:
26527c478bd9Sstevel@tonic-gate case EPERM:
26537c478bd9Sstevel@tonic-gate case EACCES:
26547c478bd9Sstevel@tonic-gate case EROFS:
26557c478bd9Sstevel@tonic-gate goto out;
26567c478bd9Sstevel@tonic-gate
26577c478bd9Sstevel@tonic-gate default:
26587c478bd9Sstevel@tonic-gate bad_error("libscf_inst_get_or_add_pg", ret);
26597c478bd9Sstevel@tonic-gate }
26607c478bd9Sstevel@tonic-gate
26617c478bd9Sstevel@tonic-gate (void) gettimeofday(&tv, NULL);
26627c478bd9Sstevel@tonic-gate
26637c478bd9Sstevel@tonic-gate r = scf_value_set_time(v_time, tv.tv_sec, tv.tv_usec * 1000);
26647c478bd9Sstevel@tonic-gate assert(r == 0);
26657c478bd9Sstevel@tonic-gate
26667c478bd9Sstevel@tonic-gate scf_value_set_integer(v_stat, status);
26677c478bd9Sstevel@tonic-gate
26687c478bd9Sstevel@tonic-gate for (;;) {
26697c478bd9Sstevel@tonic-gate if (scf_transaction_start(tx, pg) != 0) {
26707c478bd9Sstevel@tonic-gate switch (scf_error()) {
26717c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
26727c478bd9Sstevel@tonic-gate default:
26737c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
26747c478bd9Sstevel@tonic-gate goto out;
26757c478bd9Sstevel@tonic-gate
26767c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
26777c478bd9Sstevel@tonic-gate ret = ECANCELED;
26787c478bd9Sstevel@tonic-gate goto out;
26797c478bd9Sstevel@tonic-gate
26807c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
26817c478bd9Sstevel@tonic-gate ret = EPERM;
26827c478bd9Sstevel@tonic-gate goto out;
26837c478bd9Sstevel@tonic-gate
26847c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
26857c478bd9Sstevel@tonic-gate ret = EACCES;
26867c478bd9Sstevel@tonic-gate goto out;
26877c478bd9Sstevel@tonic-gate
26887c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
26897c478bd9Sstevel@tonic-gate ret = EROFS;
26907c478bd9Sstevel@tonic-gate goto out;
26917c478bd9Sstevel@tonic-gate
26927c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
26937c478bd9Sstevel@tonic-gate bad_error("scf_transaction_start", ret);
26947c478bd9Sstevel@tonic-gate }
26957c478bd9Sstevel@tonic-gate }
26967c478bd9Sstevel@tonic-gate
26977c478bd9Sstevel@tonic-gate (void) snprintf(pname, sizeof (pname), "%s_method_timestamp",
26987c478bd9Sstevel@tonic-gate name);
26997c478bd9Sstevel@tonic-gate ret = transaction_add_set(tx, e_time, pname, SCF_TYPE_TIME);
27007c478bd9Sstevel@tonic-gate switch (ret) {
27017c478bd9Sstevel@tonic-gate case 0:
27027c478bd9Sstevel@tonic-gate break;
27037c478bd9Sstevel@tonic-gate
27047c478bd9Sstevel@tonic-gate case ECONNABORTED:
27057c478bd9Sstevel@tonic-gate case ECANCELED:
27067c478bd9Sstevel@tonic-gate goto out;
27077c478bd9Sstevel@tonic-gate
27087c478bd9Sstevel@tonic-gate default:
27097c478bd9Sstevel@tonic-gate bad_error("transaction_add_set", ret);
27107c478bd9Sstevel@tonic-gate }
27117c478bd9Sstevel@tonic-gate
27127c478bd9Sstevel@tonic-gate r = scf_entry_add_value(e_time, v_time);
27137c478bd9Sstevel@tonic-gate assert(r == 0);
27147c478bd9Sstevel@tonic-gate
27157c478bd9Sstevel@tonic-gate (void) snprintf(pname, sizeof (pname), "%s_method_waitstatus",
27167c478bd9Sstevel@tonic-gate name);
27177c478bd9Sstevel@tonic-gate ret = transaction_add_set(tx, e_stat, pname, SCF_TYPE_INTEGER);
27187c478bd9Sstevel@tonic-gate switch (ret) {
27197c478bd9Sstevel@tonic-gate case 0:
27207c478bd9Sstevel@tonic-gate break;
27217c478bd9Sstevel@tonic-gate
27227c478bd9Sstevel@tonic-gate case ECONNABORTED:
27237c478bd9Sstevel@tonic-gate case ECANCELED:
27247c478bd9Sstevel@tonic-gate goto out;
27257c478bd9Sstevel@tonic-gate
27267c478bd9Sstevel@tonic-gate default:
27277c478bd9Sstevel@tonic-gate bad_error("transaction_add_set", ret);
27287c478bd9Sstevel@tonic-gate }
27297c478bd9Sstevel@tonic-gate
27307c478bd9Sstevel@tonic-gate r = scf_entry_add_value(e_stat, v_stat);
27317c478bd9Sstevel@tonic-gate if (r != 0)
27327c478bd9Sstevel@tonic-gate bad_error("scf_entry_add_value", scf_error());
27337c478bd9Sstevel@tonic-gate
27347c478bd9Sstevel@tonic-gate r = scf_transaction_commit(tx);
27357c478bd9Sstevel@tonic-gate if (r == 1)
27367c478bd9Sstevel@tonic-gate break;
27377c478bd9Sstevel@tonic-gate if (r != 0) {
27387c478bd9Sstevel@tonic-gate scfe = scf_error();
27397c478bd9Sstevel@tonic-gate scf_transaction_reset_all(tx);
27407c478bd9Sstevel@tonic-gate switch (scfe) {
27417c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
27427c478bd9Sstevel@tonic-gate default:
27437c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
27447c478bd9Sstevel@tonic-gate goto out;
27457c478bd9Sstevel@tonic-gate
27467c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
27477c478bd9Sstevel@tonic-gate ret = ECANCELED;
27487c478bd9Sstevel@tonic-gate goto out;
27497c478bd9Sstevel@tonic-gate
27507c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
27517c478bd9Sstevel@tonic-gate ret = EPERM;
27527c478bd9Sstevel@tonic-gate goto out;
27537c478bd9Sstevel@tonic-gate
27547c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
27557c478bd9Sstevel@tonic-gate ret = EACCES;
27567c478bd9Sstevel@tonic-gate goto out;
27577c478bd9Sstevel@tonic-gate
27587c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
27597c478bd9Sstevel@tonic-gate ret = EROFS;
27607c478bd9Sstevel@tonic-gate goto out;
27617c478bd9Sstevel@tonic-gate
27627c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
27637c478bd9Sstevel@tonic-gate bad_error("scf_transaction_commit", scfe);
27647c478bd9Sstevel@tonic-gate }
27657c478bd9Sstevel@tonic-gate }
27667c478bd9Sstevel@tonic-gate
27677c478bd9Sstevel@tonic-gate scf_transaction_reset_all(tx);
27687c478bd9Sstevel@tonic-gate
27697c478bd9Sstevel@tonic-gate if (scf_pg_update(pg) == -1) {
27707c478bd9Sstevel@tonic-gate switch (scf_error()) {
27717c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
27727c478bd9Sstevel@tonic-gate default:
27737c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
27747c478bd9Sstevel@tonic-gate goto out;
27757c478bd9Sstevel@tonic-gate
27767c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
27777c478bd9Sstevel@tonic-gate ret = ECANCELED;
27787c478bd9Sstevel@tonic-gate goto out;
27797c478bd9Sstevel@tonic-gate
27807c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
27817c478bd9Sstevel@tonic-gate bad_error("scf_pg_update", scf_error());
27827c478bd9Sstevel@tonic-gate }
27837c478bd9Sstevel@tonic-gate }
27847c478bd9Sstevel@tonic-gate }
27857c478bd9Sstevel@tonic-gate
27867c478bd9Sstevel@tonic-gate out:
27877c478bd9Sstevel@tonic-gate scf_transaction_destroy(tx);
27887c478bd9Sstevel@tonic-gate scf_entry_destroy(e_time);
27897c478bd9Sstevel@tonic-gate scf_value_destroy(v_time);
27907c478bd9Sstevel@tonic-gate scf_entry_destroy(e_stat);
27917c478bd9Sstevel@tonic-gate scf_value_destroy(v_stat);
27927c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
27937c478bd9Sstevel@tonic-gate
27947c478bd9Sstevel@tonic-gate return (ret);
27957c478bd9Sstevel@tonic-gate }
27967c478bd9Sstevel@tonic-gate
2797f6e214c7SGavin Maltby extern int32_t stn_global;
27987c478bd9Sstevel@tonic-gate /*
27997c478bd9Sstevel@tonic-gate * Call dgraph_add_instance() for each instance in the repository.
28007c478bd9Sstevel@tonic-gate */
28017c478bd9Sstevel@tonic-gate void
libscf_populate_graph(scf_handle_t * h)28027c478bd9Sstevel@tonic-gate libscf_populate_graph(scf_handle_t *h)
28037c478bd9Sstevel@tonic-gate {
28047c478bd9Sstevel@tonic-gate scf_scope_t *scope;
28057c478bd9Sstevel@tonic-gate scf_service_t *svc;
28067c478bd9Sstevel@tonic-gate scf_instance_t *inst;
28077c478bd9Sstevel@tonic-gate scf_iter_t *svc_iter;
28087c478bd9Sstevel@tonic-gate scf_iter_t *inst_iter;
28097c478bd9Sstevel@tonic-gate
28107c478bd9Sstevel@tonic-gate scope = safe_scf_scope_create(h);
28117c478bd9Sstevel@tonic-gate svc = safe_scf_service_create(h);
28127c478bd9Sstevel@tonic-gate inst = safe_scf_instance_create(h);
28137c478bd9Sstevel@tonic-gate svc_iter = safe_scf_iter_create(h);
28147c478bd9Sstevel@tonic-gate inst_iter = safe_scf_iter_create(h);
28157c478bd9Sstevel@tonic-gate
281670cbfe41SPhilippe Jung deathrow_init();
281770cbfe41SPhilippe Jung
2818f6e214c7SGavin Maltby stn_global = libscf_get_global_stn_tset(h);
2819f6e214c7SGavin Maltby
2820f6e214c7SGavin Maltby if (scf_handle_get_local_scope(h, scope) !=
28217c478bd9Sstevel@tonic-gate SCF_SUCCESS)
2822f6e214c7SGavin Maltby uu_die("retrieving local scope failed: %s\n",
2823f6e214c7SGavin Maltby scf_strerror(scf_error()));
28247c478bd9Sstevel@tonic-gate
28257c478bd9Sstevel@tonic-gate if (scf_iter_scope_services(svc_iter, scope) == -1)
28267c478bd9Sstevel@tonic-gate uu_die("walking local scope's services failed\n");
28277c478bd9Sstevel@tonic-gate
28287c478bd9Sstevel@tonic-gate while (scf_iter_next_service(svc_iter, svc) > 0) {
28297c478bd9Sstevel@tonic-gate if (scf_iter_service_instances(inst_iter, svc) == -1)
28307c478bd9Sstevel@tonic-gate uu_die("unable to walk service's instances");
28317c478bd9Sstevel@tonic-gate
28327c478bd9Sstevel@tonic-gate while (scf_iter_next_instance(inst_iter, inst) > 0) {
28337c478bd9Sstevel@tonic-gate char *fmri;
28347c478bd9Sstevel@tonic-gate
28357c478bd9Sstevel@tonic-gate if (libscf_instance_get_fmri(inst, &fmri) == 0) {
28367c478bd9Sstevel@tonic-gate int err;
28377c478bd9Sstevel@tonic-gate
28387c478bd9Sstevel@tonic-gate err = dgraph_add_instance(fmri, inst, B_TRUE);
28397c478bd9Sstevel@tonic-gate if (err != 0 && err != EEXIST)
28407c478bd9Sstevel@tonic-gate log_error(LOG_WARNING,
28417c478bd9Sstevel@tonic-gate "Failed to add %s (%s).\n", fmri,
28427c478bd9Sstevel@tonic-gate strerror(err));
28437c478bd9Sstevel@tonic-gate startd_free(fmri, max_scf_fmri_size);
28447c478bd9Sstevel@tonic-gate }
28457c478bd9Sstevel@tonic-gate }
28467c478bd9Sstevel@tonic-gate }
28477c478bd9Sstevel@tonic-gate
284870cbfe41SPhilippe Jung deathrow_fini();
284970cbfe41SPhilippe Jung
28507c478bd9Sstevel@tonic-gate scf_iter_destroy(inst_iter);
28517c478bd9Sstevel@tonic-gate scf_iter_destroy(svc_iter);
28527c478bd9Sstevel@tonic-gate scf_instance_destroy(inst);
28537c478bd9Sstevel@tonic-gate scf_service_destroy(svc);
28547c478bd9Sstevel@tonic-gate scf_scope_destroy(scope);
28557c478bd9Sstevel@tonic-gate }
28567c478bd9Sstevel@tonic-gate
28577c478bd9Sstevel@tonic-gate /*
28587c478bd9Sstevel@tonic-gate * Monitors get handled differently since there can be multiple of them.
28597c478bd9Sstevel@tonic-gate *
28607c478bd9Sstevel@tonic-gate * Returns exec string on success. If method not defined, returns
28617c478bd9Sstevel@tonic-gate * LIBSCF_PGROUP_ABSENT; if exec property missing, returns
28627c478bd9Sstevel@tonic-gate * LIBSCF_PROPERTY_ABSENT. Returns LIBSCF_PROPERTY_ERROR on other failures.
28637c478bd9Sstevel@tonic-gate */
28647c478bd9Sstevel@tonic-gate char *
libscf_get_method(scf_handle_t * h,int type,restarter_inst_t * inst,scf_snapshot_t * snap,method_restart_t * restart_on,uint_t * cte_mask,uint8_t * need_sessionp,uint64_t * timeout,uint8_t * timeout_retry)28657c478bd9Sstevel@tonic-gate libscf_get_method(scf_handle_t *h, int type, restarter_inst_t *inst,
28667c478bd9Sstevel@tonic-gate scf_snapshot_t *snap, method_restart_t *restart_on, uint_t *cte_mask,
28677c478bd9Sstevel@tonic-gate uint8_t *need_sessionp, uint64_t *timeout, uint8_t *timeout_retry)
28687c478bd9Sstevel@tonic-gate {
28697c478bd9Sstevel@tonic-gate scf_instance_t *scf_inst = NULL;
28707c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg = NULL, *pg_startd = NULL;
28717c478bd9Sstevel@tonic-gate scf_property_t *prop = NULL;
28727c478bd9Sstevel@tonic-gate const char *name;
28737c478bd9Sstevel@tonic-gate char *method = startd_alloc(max_scf_value_size);
28747c478bd9Sstevel@tonic-gate char *ig = startd_alloc(max_scf_value_size);
28757c478bd9Sstevel@tonic-gate char *restart = startd_alloc(max_scf_value_size);
28767c478bd9Sstevel@tonic-gate char *ret;
28777c478bd9Sstevel@tonic-gate int error = 0, r;
28787c478bd9Sstevel@tonic-gate
28797c478bd9Sstevel@tonic-gate scf_inst = safe_scf_instance_create(h);
28807c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h);
28817c478bd9Sstevel@tonic-gate pg_startd = safe_scf_pg_create(h);
28827c478bd9Sstevel@tonic-gate prop = safe_scf_property_create(h);
28837c478bd9Sstevel@tonic-gate
28847c478bd9Sstevel@tonic-gate ret = NULL;
28857c478bd9Sstevel@tonic-gate
28867c478bd9Sstevel@tonic-gate *restart_on = METHOD_RESTART_UNKNOWN;
28877c478bd9Sstevel@tonic-gate
28887c478bd9Sstevel@tonic-gate switch (type) {
28897c478bd9Sstevel@tonic-gate case METHOD_START:
28907c478bd9Sstevel@tonic-gate name = "start";
28917c478bd9Sstevel@tonic-gate break;
28927c478bd9Sstevel@tonic-gate case METHOD_STOP:
28937c478bd9Sstevel@tonic-gate name = "stop";
28947c478bd9Sstevel@tonic-gate break;
28957c478bd9Sstevel@tonic-gate case METHOD_REFRESH:
28967c478bd9Sstevel@tonic-gate name = "refresh";
28977c478bd9Sstevel@tonic-gate break;
28987c478bd9Sstevel@tonic-gate default:
28997c478bd9Sstevel@tonic-gate error = LIBSCF_PROPERTY_ERROR;
29007c478bd9Sstevel@tonic-gate goto get_method_cleanup;
29017c478bd9Sstevel@tonic-gate }
29027c478bd9Sstevel@tonic-gate
29037c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, inst->ri_i.i_fmri, NULL, NULL, scf_inst,
29047c478bd9Sstevel@tonic-gate NULL, NULL, SCF_DECODE_FMRI_EXACT) == -1) {
29057c478bd9Sstevel@tonic-gate log_error(LOG_WARNING,
29067c478bd9Sstevel@tonic-gate "%s: get_method decode instance FMRI failed: %s\n",
29077c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri, scf_strerror(scf_error()));
29087c478bd9Sstevel@tonic-gate error = LIBSCF_PROPERTY_ERROR;
29097c478bd9Sstevel@tonic-gate goto get_method_cleanup;
29107c478bd9Sstevel@tonic-gate }
29117c478bd9Sstevel@tonic-gate
29127c478bd9Sstevel@tonic-gate if (scf_instance_get_pg_composed(scf_inst, snap, name, pg) == -1) {
29137c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_NOT_FOUND)
29147c478bd9Sstevel@tonic-gate error = LIBSCF_PGROUP_ABSENT;
29157c478bd9Sstevel@tonic-gate else
29167c478bd9Sstevel@tonic-gate error = LIBSCF_PROPERTY_ERROR;
29177c478bd9Sstevel@tonic-gate goto get_method_cleanup;
29187c478bd9Sstevel@tonic-gate }
29197c478bd9Sstevel@tonic-gate
29207c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, SCF_PROPERTY_EXEC, prop) == -1) {
29217c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_NOT_FOUND)
29227c478bd9Sstevel@tonic-gate error = LIBSCF_PROPERTY_ABSENT;
29237c478bd9Sstevel@tonic-gate else
29247c478bd9Sstevel@tonic-gate error = LIBSCF_PROPERTY_ERROR;
29257c478bd9Sstevel@tonic-gate goto get_method_cleanup;
29267c478bd9Sstevel@tonic-gate }
29277c478bd9Sstevel@tonic-gate
29287c478bd9Sstevel@tonic-gate error = libscf_read_single_astring(h, prop, &method);
29297c478bd9Sstevel@tonic-gate if (error != 0) {
29307c478bd9Sstevel@tonic-gate log_error(LOG_WARNING,
29317c478bd9Sstevel@tonic-gate "%s: get_method failed: can't get a single astring "
29327c478bd9Sstevel@tonic-gate "from %s/%s\n", inst->ri_i.i_fmri, name, SCF_PROPERTY_EXEC);
29337c478bd9Sstevel@tonic-gate goto get_method_cleanup;
29347c478bd9Sstevel@tonic-gate }
29357c478bd9Sstevel@tonic-gate
29367c478bd9Sstevel@tonic-gate error = expand_method_tokens(method, scf_inst, snap, type, &ret);
29377c478bd9Sstevel@tonic-gate if (error != 0) {
29387c478bd9Sstevel@tonic-gate log_instance(inst, B_TRUE, "Could not expand method tokens "
29395ca87c7fSlianep "in \"%s\": %s.", method, ret);
29407c478bd9Sstevel@tonic-gate error = LIBSCF_PROPERTY_ERROR;
29417c478bd9Sstevel@tonic-gate goto get_method_cleanup;
29427c478bd9Sstevel@tonic-gate }
29437c478bd9Sstevel@tonic-gate
29447c478bd9Sstevel@tonic-gate r = get_count(pg, SCF_PROPERTY_TIMEOUT, timeout);
29457c478bd9Sstevel@tonic-gate switch (r) {
29467c478bd9Sstevel@tonic-gate case 0:
29477c478bd9Sstevel@tonic-gate break;
29487c478bd9Sstevel@tonic-gate
29497c478bd9Sstevel@tonic-gate case ECONNABORTED:
29507c478bd9Sstevel@tonic-gate error = LIBSCF_PROPERTY_ERROR;
29517c478bd9Sstevel@tonic-gate goto get_method_cleanup;
29527c478bd9Sstevel@tonic-gate
29537c478bd9Sstevel@tonic-gate case EINVAL:
29547c478bd9Sstevel@tonic-gate log_instance(inst, B_TRUE, "%s/%s is multi-valued or not of "
29557c478bd9Sstevel@tonic-gate "type count. Using infinite timeout.", name,
29567c478bd9Sstevel@tonic-gate SCF_PROPERTY_TIMEOUT);
29577c478bd9Sstevel@tonic-gate /* FALLTHROUGH */
29587c478bd9Sstevel@tonic-gate case ECANCELED:
29597c478bd9Sstevel@tonic-gate case ENOENT:
29607c478bd9Sstevel@tonic-gate *timeout = METHOD_TIMEOUT_INFINITE;
29617c478bd9Sstevel@tonic-gate break;
29627c478bd9Sstevel@tonic-gate
29633eae19d9Swesolows case EACCES:
29647c478bd9Sstevel@tonic-gate default:
29657c478bd9Sstevel@tonic-gate bad_error("get_count", r);
29667c478bd9Sstevel@tonic-gate }
29677c478bd9Sstevel@tonic-gate
29687c478bd9Sstevel@tonic-gate /* Both 0 and -1 (ugh) are considered infinite timeouts. */
29697c478bd9Sstevel@tonic-gate if (*timeout == -1 || *timeout == 0)
29707c478bd9Sstevel@tonic-gate *timeout = METHOD_TIMEOUT_INFINITE;
29717c478bd9Sstevel@tonic-gate
29727c478bd9Sstevel@tonic-gate if (scf_instance_get_pg_composed(scf_inst, snap, SCF_PG_STARTD,
29737c478bd9Sstevel@tonic-gate pg_startd) == -1) {
29747c478bd9Sstevel@tonic-gate switch (scf_error()) {
29757c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
29767c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
29777c478bd9Sstevel@tonic-gate error = LIBSCF_PROPERTY_ERROR;
29787c478bd9Sstevel@tonic-gate goto get_method_cleanup;
29797c478bd9Sstevel@tonic-gate
29807c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
29817c478bd9Sstevel@tonic-gate *cte_mask = 0;
29827c478bd9Sstevel@tonic-gate break;
29837c478bd9Sstevel@tonic-gate
29847c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
29857c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
29867c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_BOUND:
29877c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
29887c478bd9Sstevel@tonic-gate bad_error("scf_instance_get_pg_composed", scf_error());
29897c478bd9Sstevel@tonic-gate }
29907c478bd9Sstevel@tonic-gate } else {
29917c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg_startd, SCF_PROPERTY_IGNORE,
29927c478bd9Sstevel@tonic-gate prop) == -1) {
29937c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_NOT_FOUND)
29947c478bd9Sstevel@tonic-gate *cte_mask = 0;
29957c478bd9Sstevel@tonic-gate else {
29967c478bd9Sstevel@tonic-gate error = LIBSCF_PROPERTY_ERROR;
29977c478bd9Sstevel@tonic-gate goto get_method_cleanup;
29987c478bd9Sstevel@tonic-gate }
29997c478bd9Sstevel@tonic-gate } else {
30007c478bd9Sstevel@tonic-gate error = libscf_read_single_astring(h, prop, &ig);
30017c478bd9Sstevel@tonic-gate if (error != 0) {
30027c478bd9Sstevel@tonic-gate log_error(LOG_WARNING,
30037c478bd9Sstevel@tonic-gate "%s: get_method failed: can't get a single "
30047c478bd9Sstevel@tonic-gate "astring from %s/%s\n", inst->ri_i.i_fmri,
30057c478bd9Sstevel@tonic-gate name, SCF_PROPERTY_IGNORE);
30067c478bd9Sstevel@tonic-gate goto get_method_cleanup;
30077c478bd9Sstevel@tonic-gate }
30087c478bd9Sstevel@tonic-gate
30097c478bd9Sstevel@tonic-gate if (strcmp(ig, "core") == 0)
30107c478bd9Sstevel@tonic-gate *cte_mask = CT_PR_EV_CORE;
30117c478bd9Sstevel@tonic-gate else if (strcmp(ig, "signal") == 0)
30127c478bd9Sstevel@tonic-gate *cte_mask = CT_PR_EV_SIGNAL;
30137c478bd9Sstevel@tonic-gate else if (strcmp(ig, "core,signal") == 0 ||
30147c478bd9Sstevel@tonic-gate strcmp(ig, "signal,core") == 0)
30157c478bd9Sstevel@tonic-gate *cte_mask = CT_PR_EV_CORE | CT_PR_EV_SIGNAL;
30167c478bd9Sstevel@tonic-gate else
30177c478bd9Sstevel@tonic-gate *cte_mask = 0;
30187c478bd9Sstevel@tonic-gate }
30197c478bd9Sstevel@tonic-gate
30207c478bd9Sstevel@tonic-gate r = get_boolean(pg_startd, SCF_PROPERTY_NEED_SESSION,
30217c478bd9Sstevel@tonic-gate need_sessionp);
30227c478bd9Sstevel@tonic-gate switch (r) {
30237c478bd9Sstevel@tonic-gate case 0:
30247c478bd9Sstevel@tonic-gate break;
30257c478bd9Sstevel@tonic-gate
30267c478bd9Sstevel@tonic-gate case ECONNABORTED:
30277c478bd9Sstevel@tonic-gate error = LIBSCF_PROPERTY_ERROR;
30287c478bd9Sstevel@tonic-gate goto get_method_cleanup;
30297c478bd9Sstevel@tonic-gate
30307c478bd9Sstevel@tonic-gate case ECANCELED:
30317c478bd9Sstevel@tonic-gate case ENOENT:
30327c478bd9Sstevel@tonic-gate case EINVAL:
30337c478bd9Sstevel@tonic-gate *need_sessionp = 0;
30347c478bd9Sstevel@tonic-gate break;
30357c478bd9Sstevel@tonic-gate
30363eae19d9Swesolows case EACCES:
30377c478bd9Sstevel@tonic-gate default:
30387c478bd9Sstevel@tonic-gate bad_error("get_boolean", r);
30397c478bd9Sstevel@tonic-gate }
30407c478bd9Sstevel@tonic-gate
30417c478bd9Sstevel@tonic-gate /*
30427c478bd9Sstevel@tonic-gate * Determine whether service has overriden retry after
30437c478bd9Sstevel@tonic-gate * method timeout. Default to retry if no value is
30447c478bd9Sstevel@tonic-gate * specified.
30457c478bd9Sstevel@tonic-gate */
30467c478bd9Sstevel@tonic-gate r = get_boolean(pg_startd, SCF_PROPERTY_TIMEOUT_RETRY,
30477c478bd9Sstevel@tonic-gate timeout_retry);
30487c478bd9Sstevel@tonic-gate switch (r) {
30497c478bd9Sstevel@tonic-gate case 0:
30507c478bd9Sstevel@tonic-gate break;
30517c478bd9Sstevel@tonic-gate
30527c478bd9Sstevel@tonic-gate case ECONNABORTED:
30537c478bd9Sstevel@tonic-gate error = LIBSCF_PROPERTY_ERROR;
30547c478bd9Sstevel@tonic-gate goto get_method_cleanup;
30557c478bd9Sstevel@tonic-gate
30567c478bd9Sstevel@tonic-gate case ECANCELED:
30577c478bd9Sstevel@tonic-gate case ENOENT:
30587c478bd9Sstevel@tonic-gate case EINVAL:
30597c478bd9Sstevel@tonic-gate *timeout_retry = 1;
30607c478bd9Sstevel@tonic-gate break;
30617c478bd9Sstevel@tonic-gate
30623eae19d9Swesolows case EACCES:
30637c478bd9Sstevel@tonic-gate default:
30647c478bd9Sstevel@tonic-gate bad_error("get_boolean", r);
30657c478bd9Sstevel@tonic-gate }
30667c478bd9Sstevel@tonic-gate }
30677c478bd9Sstevel@tonic-gate
30687c478bd9Sstevel@tonic-gate if (type != METHOD_START)
30697c478bd9Sstevel@tonic-gate goto get_method_cleanup;
30707c478bd9Sstevel@tonic-gate
30717c478bd9Sstevel@tonic-gate /* Only start methods need to honor the restart_on property. */
30727c478bd9Sstevel@tonic-gate
30737c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, SCF_PROPERTY_RESTART_ON, prop) == -1) {
30747c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_NOT_FOUND)
30757c478bd9Sstevel@tonic-gate *restart_on = METHOD_RESTART_ALL;
30767c478bd9Sstevel@tonic-gate else
30777c478bd9Sstevel@tonic-gate error = LIBSCF_PROPERTY_ERROR;
30787c478bd9Sstevel@tonic-gate goto get_method_cleanup;
30797c478bd9Sstevel@tonic-gate }
30807c478bd9Sstevel@tonic-gate
30817c478bd9Sstevel@tonic-gate error = libscf_read_single_astring(h, prop, &restart);
30827c478bd9Sstevel@tonic-gate if (error != 0) {
30837c478bd9Sstevel@tonic-gate log_error(LOG_WARNING,
30847c478bd9Sstevel@tonic-gate "%s: get_method failed: can't get a single astring "
30857c478bd9Sstevel@tonic-gate "from %s/%s\n", inst->ri_i.i_fmri, name,
30867c478bd9Sstevel@tonic-gate SCF_PROPERTY_RESTART_ON);
30877c478bd9Sstevel@tonic-gate goto get_method_cleanup;
30887c478bd9Sstevel@tonic-gate }
30897c478bd9Sstevel@tonic-gate
30907c478bd9Sstevel@tonic-gate if (strcmp(restart, "all") == 0)
30917c478bd9Sstevel@tonic-gate *restart_on = METHOD_RESTART_ALL;
30927c478bd9Sstevel@tonic-gate else if (strcmp(restart, "external_fault") == 0)
30937c478bd9Sstevel@tonic-gate *restart_on = METHOD_RESTART_EXTERNAL_FAULT;
30947c478bd9Sstevel@tonic-gate else if (strcmp(restart, "any_fault") == 0)
30957c478bd9Sstevel@tonic-gate *restart_on = METHOD_RESTART_ANY_FAULT;
30967c478bd9Sstevel@tonic-gate
30977c478bd9Sstevel@tonic-gate get_method_cleanup:
30987c478bd9Sstevel@tonic-gate startd_free(ig, max_scf_value_size);
30997c478bd9Sstevel@tonic-gate startd_free(method, max_scf_value_size);
31007c478bd9Sstevel@tonic-gate startd_free(restart, max_scf_value_size);
31017c478bd9Sstevel@tonic-gate
31027c478bd9Sstevel@tonic-gate scf_instance_destroy(scf_inst);
31037c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
31047c478bd9Sstevel@tonic-gate scf_pg_destroy(pg_startd);
31057c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
31067c478bd9Sstevel@tonic-gate
31077c478bd9Sstevel@tonic-gate if (error != 0 && ret != NULL) {
31087c478bd9Sstevel@tonic-gate free(ret);
31097c478bd9Sstevel@tonic-gate ret = NULL;
31107c478bd9Sstevel@tonic-gate }
31117c478bd9Sstevel@tonic-gate
31127c478bd9Sstevel@tonic-gate errno = error;
31137c478bd9Sstevel@tonic-gate return (ret);
31147c478bd9Sstevel@tonic-gate }
31157c478bd9Sstevel@tonic-gate
31167c478bd9Sstevel@tonic-gate /*
31177c478bd9Sstevel@tonic-gate * Returns 1 if we've reached the fault threshold
31187c478bd9Sstevel@tonic-gate */
31197c478bd9Sstevel@tonic-gate int
update_fault_count(restarter_inst_t * inst,int type)31207c478bd9Sstevel@tonic-gate update_fault_count(restarter_inst_t *inst, int type)
31217c478bd9Sstevel@tonic-gate {
31227c478bd9Sstevel@tonic-gate assert(type == FAULT_COUNT_INCR || type == FAULT_COUNT_RESET);
31237c478bd9Sstevel@tonic-gate
31247c478bd9Sstevel@tonic-gate if (type == FAULT_COUNT_INCR) {
31257c478bd9Sstevel@tonic-gate inst->ri_i.i_fault_count++;
31267c478bd9Sstevel@tonic-gate log_framework(LOG_INFO, "%s: Increasing fault count to %d\n",
31277c478bd9Sstevel@tonic-gate inst->ri_i.i_fmri, inst->ri_i.i_fault_count);
31287c478bd9Sstevel@tonic-gate }
31297c478bd9Sstevel@tonic-gate if (type == FAULT_COUNT_RESET)
31307c478bd9Sstevel@tonic-gate inst->ri_i.i_fault_count = 0;
31317c478bd9Sstevel@tonic-gate
31327c478bd9Sstevel@tonic-gate if (inst->ri_i.i_fault_count >= FAULT_THRESHOLD)
31337c478bd9Sstevel@tonic-gate return (1);
31347c478bd9Sstevel@tonic-gate
31357c478bd9Sstevel@tonic-gate return (0);
31367c478bd9Sstevel@tonic-gate }
31377c478bd9Sstevel@tonic-gate
31387c478bd9Sstevel@tonic-gate /*
31397c478bd9Sstevel@tonic-gate * int libscf_unset_action()
31407c478bd9Sstevel@tonic-gate * Delete any pending timestamps for the specified action which is
31417c478bd9Sstevel@tonic-gate * older than the supplied ts.
31427c478bd9Sstevel@tonic-gate *
31437c478bd9Sstevel@tonic-gate * Returns 0 on success, ECONNABORTED, EACCES, or EPERM on failure.
31447c478bd9Sstevel@tonic-gate */
31457c478bd9Sstevel@tonic-gate int
libscf_unset_action(scf_handle_t * h,scf_propertygroup_t * pg,admin_action_t a,hrtime_t ts)31467c478bd9Sstevel@tonic-gate libscf_unset_action(scf_handle_t *h, scf_propertygroup_t *pg,
31477c478bd9Sstevel@tonic-gate admin_action_t a, hrtime_t ts)
31487c478bd9Sstevel@tonic-gate {
31497c478bd9Sstevel@tonic-gate scf_transaction_t *t;
31507c478bd9Sstevel@tonic-gate scf_transaction_entry_t *e;
31517c478bd9Sstevel@tonic-gate scf_property_t *prop;
31527c478bd9Sstevel@tonic-gate scf_value_t *val;
31537c478bd9Sstevel@tonic-gate hrtime_t rep_ts;
31547c478bd9Sstevel@tonic-gate int ret = 0, r;
31557c478bd9Sstevel@tonic-gate
31567c478bd9Sstevel@tonic-gate t = safe_scf_transaction_create(h);
31577c478bd9Sstevel@tonic-gate e = safe_scf_entry_create(h);
31587c478bd9Sstevel@tonic-gate prop = safe_scf_property_create(h);
31597c478bd9Sstevel@tonic-gate val = safe_scf_value_create(h);
31607c478bd9Sstevel@tonic-gate
31617c478bd9Sstevel@tonic-gate for (;;) {
31627c478bd9Sstevel@tonic-gate if (scf_pg_update(pg) == -1) {
31637c478bd9Sstevel@tonic-gate switch (scf_error()) {
31647c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
31657c478bd9Sstevel@tonic-gate default:
31667c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
31677c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
31687c478bd9Sstevel@tonic-gate
31697c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
31707c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
31717c478bd9Sstevel@tonic-gate
31727c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
31737c478bd9Sstevel@tonic-gate assert(0);
31747c478bd9Sstevel@tonic-gate abort();
31757c478bd9Sstevel@tonic-gate }
31767c478bd9Sstevel@tonic-gate }
31777c478bd9Sstevel@tonic-gate
31787c478bd9Sstevel@tonic-gate if (scf_transaction_start(t, pg) == -1) {
31797c478bd9Sstevel@tonic-gate switch (scf_error()) {
31807c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
31817c478bd9Sstevel@tonic-gate default:
31827c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
31837c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
31847c478bd9Sstevel@tonic-gate
31857c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
31867c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
31877c478bd9Sstevel@tonic-gate
31887c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
31897c478bd9Sstevel@tonic-gate ret = EPERM;
31907c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
31917c478bd9Sstevel@tonic-gate
31927c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
31937c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
31947c478bd9Sstevel@tonic-gate ret = EACCES;
31957c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
31967c478bd9Sstevel@tonic-gate
31977c478bd9Sstevel@tonic-gate case SCF_ERROR_IN_USE:
31987c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
31997c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
32007c478bd9Sstevel@tonic-gate assert(0);
32017c478bd9Sstevel@tonic-gate abort();
32027c478bd9Sstevel@tonic-gate }
32037c478bd9Sstevel@tonic-gate }
32047c478bd9Sstevel@tonic-gate
32057c478bd9Sstevel@tonic-gate /* Return failure only if the property hasn't been deleted. */
32067c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, admin_actions[a], prop) == -1) {
32077c478bd9Sstevel@tonic-gate switch (scf_error()) {
32087c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
32097c478bd9Sstevel@tonic-gate default:
32107c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
32117c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
32127c478bd9Sstevel@tonic-gate
32137c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
32147c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
32157c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
32167c478bd9Sstevel@tonic-gate
32177c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
32187c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
32197c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
32207c478bd9Sstevel@tonic-gate assert(0);
32217c478bd9Sstevel@tonic-gate abort();
32227c478bd9Sstevel@tonic-gate }
32237c478bd9Sstevel@tonic-gate }
32247c478bd9Sstevel@tonic-gate
32257c478bd9Sstevel@tonic-gate if (scf_property_get_value(prop, val) == -1) {
32267c478bd9Sstevel@tonic-gate switch (scf_error()) {
32277c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
32287c478bd9Sstevel@tonic-gate default:
32297c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
32307c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
32317c478bd9Sstevel@tonic-gate
32327c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
32337c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
32347c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
32357c478bd9Sstevel@tonic-gate
32367c478bd9Sstevel@tonic-gate case SCF_ERROR_CONSTRAINT_VIOLATED:
32377c478bd9Sstevel@tonic-gate /*
32387c478bd9Sstevel@tonic-gate * More than one value was associated with
32397c478bd9Sstevel@tonic-gate * this property -- this is incorrect. Take
32407c478bd9Sstevel@tonic-gate * the opportunity to clean up and clear the
32417c478bd9Sstevel@tonic-gate * entire property.
32427c478bd9Sstevel@tonic-gate */
32437c478bd9Sstevel@tonic-gate rep_ts = ts;
32447c478bd9Sstevel@tonic-gate break;
32457c478bd9Sstevel@tonic-gate
32463eae19d9Swesolows case SCF_ERROR_PERMISSION_DENIED:
32477c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
32487c478bd9Sstevel@tonic-gate assert(0);
32497c478bd9Sstevel@tonic-gate abort();
32507c478bd9Sstevel@tonic-gate }
32517c478bd9Sstevel@tonic-gate } else if (scf_value_get_integer(val, &rep_ts) == -1) {
32527c478bd9Sstevel@tonic-gate assert(scf_error() == SCF_ERROR_TYPE_MISMATCH);
32537c478bd9Sstevel@tonic-gate rep_ts = 0;
32547c478bd9Sstevel@tonic-gate }
32557c478bd9Sstevel@tonic-gate
32567c478bd9Sstevel@tonic-gate /* Repository ts is more current. Don't clear the action. */
32577c478bd9Sstevel@tonic-gate if (rep_ts > ts)
32587c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
32597c478bd9Sstevel@tonic-gate
32607c478bd9Sstevel@tonic-gate r = scf_transaction_property_change_type(t, e,
32617c478bd9Sstevel@tonic-gate admin_actions[a], SCF_TYPE_INTEGER);
32627c478bd9Sstevel@tonic-gate assert(r == 0);
32637c478bd9Sstevel@tonic-gate
32647c478bd9Sstevel@tonic-gate r = scf_transaction_commit(t);
32657c478bd9Sstevel@tonic-gate if (r == 1)
32667c478bd9Sstevel@tonic-gate break;
32677c478bd9Sstevel@tonic-gate
32687c478bd9Sstevel@tonic-gate if (r != 0) {
32697c478bd9Sstevel@tonic-gate switch (scf_error()) {
32707c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
32717c478bd9Sstevel@tonic-gate default:
32727c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
32737c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
32747c478bd9Sstevel@tonic-gate
32757c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
32767c478bd9Sstevel@tonic-gate break;
32777c478bd9Sstevel@tonic-gate
32787c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
32797c478bd9Sstevel@tonic-gate ret = EPERM;
32807c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
32817c478bd9Sstevel@tonic-gate
32827c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
32837c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
32847c478bd9Sstevel@tonic-gate ret = EACCES;
32857c478bd9Sstevel@tonic-gate goto unset_action_cleanup;
32867c478bd9Sstevel@tonic-gate
32877c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
32887c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
32897c478bd9Sstevel@tonic-gate assert(0);
32907c478bd9Sstevel@tonic-gate abort();
32917c478bd9Sstevel@tonic-gate }
32927c478bd9Sstevel@tonic-gate }
32937c478bd9Sstevel@tonic-gate
32947c478bd9Sstevel@tonic-gate scf_transaction_reset(t);
32957c478bd9Sstevel@tonic-gate }
32967c478bd9Sstevel@tonic-gate
32977c478bd9Sstevel@tonic-gate unset_action_cleanup:
32987c478bd9Sstevel@tonic-gate scf_transaction_destroy(t);
32997c478bd9Sstevel@tonic-gate scf_entry_destroy(e);
33007c478bd9Sstevel@tonic-gate scf_property_destroy(prop);
33017c478bd9Sstevel@tonic-gate scf_value_destroy(val);
33027c478bd9Sstevel@tonic-gate
33037c478bd9Sstevel@tonic-gate return (ret);
33047c478bd9Sstevel@tonic-gate }
33057c478bd9Sstevel@tonic-gate
33067c478bd9Sstevel@tonic-gate /*
33077c478bd9Sstevel@tonic-gate * Decorates & binds hndl. hndl must be unbound. Returns
33087c478bd9Sstevel@tonic-gate * 0 - success
33097c478bd9Sstevel@tonic-gate * -1 - repository server is not running
33107c478bd9Sstevel@tonic-gate * -1 - repository server is out of resources
33117c478bd9Sstevel@tonic-gate */
33127c478bd9Sstevel@tonic-gate static int
handle_decorate_and_bind(scf_handle_t * hndl)33137c478bd9Sstevel@tonic-gate handle_decorate_and_bind(scf_handle_t *hndl)
33147c478bd9Sstevel@tonic-gate {
33157c478bd9Sstevel@tonic-gate scf_value_t *door_dec_value;
33167c478bd9Sstevel@tonic-gate
33177c478bd9Sstevel@tonic-gate door_dec_value = safe_scf_value_create(hndl);
33187c478bd9Sstevel@tonic-gate
33197c478bd9Sstevel@tonic-gate /*
33207c478bd9Sstevel@tonic-gate * Decorate if alternate door path set.
33217c478bd9Sstevel@tonic-gate */
33227c478bd9Sstevel@tonic-gate if (st->st_door_path) {
33237c478bd9Sstevel@tonic-gate if (scf_value_set_astring(door_dec_value, st->st_door_path) !=
33247c478bd9Sstevel@tonic-gate 0)
33257c478bd9Sstevel@tonic-gate uu_die("$STARTD_ALT_DOOR is too long.\n");
33267c478bd9Sstevel@tonic-gate
33277c478bd9Sstevel@tonic-gate if (scf_handle_decorate(hndl, "door_path", door_dec_value) != 0)
33287c478bd9Sstevel@tonic-gate bad_error("scf_handle_decorate", scf_error());
33297c478bd9Sstevel@tonic-gate }
33307c478bd9Sstevel@tonic-gate
33317c478bd9Sstevel@tonic-gate scf_value_destroy(door_dec_value);
33327c478bd9Sstevel@tonic-gate
33337c478bd9Sstevel@tonic-gate if (scf_handle_bind(hndl) == 0)
33347c478bd9Sstevel@tonic-gate return (0);
33357c478bd9Sstevel@tonic-gate
33367c478bd9Sstevel@tonic-gate switch (scf_error()) {
33377c478bd9Sstevel@tonic-gate case SCF_ERROR_NO_SERVER:
33387c478bd9Sstevel@tonic-gate case SCF_ERROR_NO_RESOURCES:
33397c478bd9Sstevel@tonic-gate return (-1);
33407c478bd9Sstevel@tonic-gate
33417c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
33427c478bd9Sstevel@tonic-gate case SCF_ERROR_IN_USE:
33437c478bd9Sstevel@tonic-gate default:
33447c478bd9Sstevel@tonic-gate bad_error("scf_handle_bind", scf_error());
33457c478bd9Sstevel@tonic-gate /* NOTREACHED */
33467c478bd9Sstevel@tonic-gate }
33477c478bd9Sstevel@tonic-gate }
33487c478bd9Sstevel@tonic-gate
33497c478bd9Sstevel@tonic-gate scf_handle_t *
libscf_handle_create_bound(scf_version_t v)33507c478bd9Sstevel@tonic-gate libscf_handle_create_bound(scf_version_t v)
33517c478bd9Sstevel@tonic-gate {
33527c478bd9Sstevel@tonic-gate scf_handle_t *hndl = scf_handle_create(v);
33537c478bd9Sstevel@tonic-gate
33547c478bd9Sstevel@tonic-gate if (hndl == NULL)
33557c478bd9Sstevel@tonic-gate return (hndl);
33567c478bd9Sstevel@tonic-gate
33577c478bd9Sstevel@tonic-gate if (handle_decorate_and_bind(hndl) == 0)
33587c478bd9Sstevel@tonic-gate return (hndl);
33597c478bd9Sstevel@tonic-gate
33607c478bd9Sstevel@tonic-gate scf_handle_destroy(hndl);
33617c478bd9Sstevel@tonic-gate return (NULL);
33627c478bd9Sstevel@tonic-gate }
33637c478bd9Sstevel@tonic-gate
33647c478bd9Sstevel@tonic-gate void
libscf_handle_rebind(scf_handle_t * h)33657c478bd9Sstevel@tonic-gate libscf_handle_rebind(scf_handle_t *h)
33667c478bd9Sstevel@tonic-gate {
33677c478bd9Sstevel@tonic-gate (void) scf_handle_unbind(h);
33687c478bd9Sstevel@tonic-gate
33697c478bd9Sstevel@tonic-gate MUTEX_LOCK(&st->st_configd_live_lock);
33707c478bd9Sstevel@tonic-gate
33717c478bd9Sstevel@tonic-gate /*
33727c478bd9Sstevel@tonic-gate * Try to rebind the handle before sleeping in case the server isn't
33737c478bd9Sstevel@tonic-gate * really dead.
33747c478bd9Sstevel@tonic-gate */
33757c478bd9Sstevel@tonic-gate while (handle_decorate_and_bind(h) != 0)
33767c478bd9Sstevel@tonic-gate (void) pthread_cond_wait(&st->st_configd_live_cv,
33777c478bd9Sstevel@tonic-gate &st->st_configd_live_lock);
33787c478bd9Sstevel@tonic-gate
33797c478bd9Sstevel@tonic-gate MUTEX_UNLOCK(&st->st_configd_live_lock);
33807c478bd9Sstevel@tonic-gate }
33817c478bd9Sstevel@tonic-gate
33827c478bd9Sstevel@tonic-gate /*
33837c478bd9Sstevel@tonic-gate * Create a handle and try to bind it until it succeeds. Always returns
33847c478bd9Sstevel@tonic-gate * a bound handle.
33857c478bd9Sstevel@tonic-gate */
33867c478bd9Sstevel@tonic-gate scf_handle_t *
libscf_handle_create_bound_loop()33877c478bd9Sstevel@tonic-gate libscf_handle_create_bound_loop()
33887c478bd9Sstevel@tonic-gate {
33897c478bd9Sstevel@tonic-gate scf_handle_t *h;
33907c478bd9Sstevel@tonic-gate
33917c478bd9Sstevel@tonic-gate while ((h = scf_handle_create(SCF_VERSION)) == NULL) {
33927c478bd9Sstevel@tonic-gate /* This should have been caught earlier. */
33937c478bd9Sstevel@tonic-gate assert(scf_error() != SCF_ERROR_VERSION_MISMATCH);
33947c478bd9Sstevel@tonic-gate (void) sleep(2);
33957c478bd9Sstevel@tonic-gate }
33967c478bd9Sstevel@tonic-gate
33977c478bd9Sstevel@tonic-gate if (handle_decorate_and_bind(h) != 0)
33987c478bd9Sstevel@tonic-gate libscf_handle_rebind(h);
33997c478bd9Sstevel@tonic-gate
34007c478bd9Sstevel@tonic-gate return (h);
34017c478bd9Sstevel@tonic-gate }
34027c478bd9Sstevel@tonic-gate
34037c478bd9Sstevel@tonic-gate /*
34047c478bd9Sstevel@tonic-gate * Call cb for each dependency property group of inst. cb is invoked with
34057c478bd9Sstevel@tonic-gate * a pointer to the scf_propertygroup_t and arg. If the repository connection
34067c478bd9Sstevel@tonic-gate * is broken, returns ECONNABORTED. If inst is deleted, returns ECANCELED.
34077c478bd9Sstevel@tonic-gate * If cb returns non-zero, the walk is stopped and EINTR is returned.
34087c478bd9Sstevel@tonic-gate * Otherwise returns 0.
34097c478bd9Sstevel@tonic-gate */
34107c478bd9Sstevel@tonic-gate int
walk_dependency_pgs(scf_instance_t * inst,callback_t cb,void * arg)34117c478bd9Sstevel@tonic-gate walk_dependency_pgs(scf_instance_t *inst, callback_t cb, void *arg)
34127c478bd9Sstevel@tonic-gate {
34137c478bd9Sstevel@tonic-gate scf_handle_t *h;
34147c478bd9Sstevel@tonic-gate scf_snapshot_t *snap;
34157c478bd9Sstevel@tonic-gate scf_iter_t *iter;
34167c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg;
34177c478bd9Sstevel@tonic-gate int r;
34187c478bd9Sstevel@tonic-gate
34197c478bd9Sstevel@tonic-gate h = scf_instance_handle(inst);
34207c478bd9Sstevel@tonic-gate
34217c478bd9Sstevel@tonic-gate iter = safe_scf_iter_create(h);
34227c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h);
34237c478bd9Sstevel@tonic-gate
34247c478bd9Sstevel@tonic-gate snap = libscf_get_running_snapshot(inst);
34257c478bd9Sstevel@tonic-gate
34267c478bd9Sstevel@tonic-gate if (scf_iter_instance_pgs_typed_composed(iter, inst, snap,
34277c478bd9Sstevel@tonic-gate SCF_GROUP_DEPENDENCY) != 0) {
34287c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap);
34297c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
34307c478bd9Sstevel@tonic-gate scf_iter_destroy(iter);
34317c478bd9Sstevel@tonic-gate switch (scf_error()) {
34327c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
34337c478bd9Sstevel@tonic-gate default:
34347c478bd9Sstevel@tonic-gate return (ECONNABORTED);
34357c478bd9Sstevel@tonic-gate
34367c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
34377c478bd9Sstevel@tonic-gate return (ECANCELED);
34387c478bd9Sstevel@tonic-gate
34397c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
34407c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
34417c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
34427c478bd9Sstevel@tonic-gate assert(0);
34437c478bd9Sstevel@tonic-gate abort();
34447c478bd9Sstevel@tonic-gate }
34457c478bd9Sstevel@tonic-gate }
34467c478bd9Sstevel@tonic-gate
34477c478bd9Sstevel@tonic-gate for (;;) {
34487c478bd9Sstevel@tonic-gate r = scf_iter_next_pg(iter, pg);
34497c478bd9Sstevel@tonic-gate if (r == 0)
34507c478bd9Sstevel@tonic-gate break;
34517c478bd9Sstevel@tonic-gate if (r == -1) {
34527c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap);
34537c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
34547c478bd9Sstevel@tonic-gate scf_iter_destroy(iter);
345558276701Shg
345658276701Shg switch (scf_error()) {
345758276701Shg case SCF_ERROR_CONNECTION_BROKEN:
345858276701Shg return (ECONNABORTED);
345958276701Shg
346058276701Shg case SCF_ERROR_DELETED:
346158276701Shg return (ECANCELED);
346258276701Shg
346358276701Shg case SCF_ERROR_NOT_SET:
346458276701Shg case SCF_ERROR_INVALID_ARGUMENT:
346558276701Shg case SCF_ERROR_NOT_BOUND:
346658276701Shg case SCF_ERROR_HANDLE_MISMATCH:
346758276701Shg default:
346858276701Shg bad_error("scf_iter_next_pg", scf_error());
346958276701Shg }
34707c478bd9Sstevel@tonic-gate }
34717c478bd9Sstevel@tonic-gate
34727c478bd9Sstevel@tonic-gate r = cb(pg, arg);
34737c478bd9Sstevel@tonic-gate
34747c478bd9Sstevel@tonic-gate if (r != 0)
34757c478bd9Sstevel@tonic-gate break;
34767c478bd9Sstevel@tonic-gate }
34777c478bd9Sstevel@tonic-gate
34787c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap);
34797c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
34807c478bd9Sstevel@tonic-gate scf_iter_destroy(iter);
34817c478bd9Sstevel@tonic-gate
34827c478bd9Sstevel@tonic-gate return (r == 0 ? 0 : EINTR);
34837c478bd9Sstevel@tonic-gate }
34847c478bd9Sstevel@tonic-gate
34857c478bd9Sstevel@tonic-gate /*
34867c478bd9Sstevel@tonic-gate * Call cb for each of the string values of prop. cb is invoked with
34877c478bd9Sstevel@tonic-gate * a pointer to the string and arg. If the connection to the repository is
34887c478bd9Sstevel@tonic-gate * broken, ECONNABORTED is returned. If the property is deleted, ECANCELED is
34897c478bd9Sstevel@tonic-gate * returned. If the property does not have astring type, EINVAL is returned.
34907c478bd9Sstevel@tonic-gate * If cb returns non-zero, the walk is stopped and EINTR is returned.
34917c478bd9Sstevel@tonic-gate * Otherwise 0 is returned.
34927c478bd9Sstevel@tonic-gate */
34937c478bd9Sstevel@tonic-gate int
walk_property_astrings(scf_property_t * prop,callback_t cb,void * arg)34947c478bd9Sstevel@tonic-gate walk_property_astrings(scf_property_t *prop, callback_t cb, void *arg)
34957c478bd9Sstevel@tonic-gate {
34967c478bd9Sstevel@tonic-gate scf_handle_t *h;
34977c478bd9Sstevel@tonic-gate scf_value_t *val;
34987c478bd9Sstevel@tonic-gate scf_iter_t *iter;
34997c478bd9Sstevel@tonic-gate char *buf;
35007c478bd9Sstevel@tonic-gate int r;
35017c478bd9Sstevel@tonic-gate ssize_t sz;
35027c478bd9Sstevel@tonic-gate
35037c478bd9Sstevel@tonic-gate if (scf_property_is_type(prop, SCF_TYPE_ASTRING) != 0) {
35047c478bd9Sstevel@tonic-gate switch (scf_error()) {
35057c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
35067c478bd9Sstevel@tonic-gate default:
35077c478bd9Sstevel@tonic-gate return (ECONNABORTED);
35087c478bd9Sstevel@tonic-gate
35097c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
35107c478bd9Sstevel@tonic-gate return (ECANCELED);
35117c478bd9Sstevel@tonic-gate
35127c478bd9Sstevel@tonic-gate case SCF_ERROR_TYPE_MISMATCH:
35137c478bd9Sstevel@tonic-gate return (EINVAL);
35147c478bd9Sstevel@tonic-gate
35157c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
35167c478bd9Sstevel@tonic-gate assert(0);
35177c478bd9Sstevel@tonic-gate abort();
35187c478bd9Sstevel@tonic-gate }
35197c478bd9Sstevel@tonic-gate }
35207c478bd9Sstevel@tonic-gate
35217c478bd9Sstevel@tonic-gate h = scf_property_handle(prop);
35227c478bd9Sstevel@tonic-gate
35237c478bd9Sstevel@tonic-gate val = safe_scf_value_create(h);
35247c478bd9Sstevel@tonic-gate iter = safe_scf_iter_create(h);
35257c478bd9Sstevel@tonic-gate
35267c478bd9Sstevel@tonic-gate if (scf_iter_property_values(iter, prop) != 0) {
35277c478bd9Sstevel@tonic-gate scf_iter_destroy(iter);
35287c478bd9Sstevel@tonic-gate scf_value_destroy(val);
35297c478bd9Sstevel@tonic-gate switch (scf_error()) {
35307c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
35317c478bd9Sstevel@tonic-gate default:
35327c478bd9Sstevel@tonic-gate return (ECONNABORTED);
35337c478bd9Sstevel@tonic-gate
35347c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
35357c478bd9Sstevel@tonic-gate return (ECANCELED);
35367c478bd9Sstevel@tonic-gate
35377c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
35387c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
35397c478bd9Sstevel@tonic-gate assert(0);
35407c478bd9Sstevel@tonic-gate abort();
35417c478bd9Sstevel@tonic-gate }
35427c478bd9Sstevel@tonic-gate }
35437c478bd9Sstevel@tonic-gate
35447c478bd9Sstevel@tonic-gate buf = startd_alloc(max_scf_value_size);
35457c478bd9Sstevel@tonic-gate
35467c478bd9Sstevel@tonic-gate for (;;) {
35477c478bd9Sstevel@tonic-gate r = scf_iter_next_value(iter, val);
35487c478bd9Sstevel@tonic-gate if (r < 0) {
35497c478bd9Sstevel@tonic-gate startd_free(buf, max_scf_value_size);
35507c478bd9Sstevel@tonic-gate scf_iter_destroy(iter);
35517c478bd9Sstevel@tonic-gate scf_value_destroy(val);
355258276701Shg
355358276701Shg switch (scf_error()) {
355458276701Shg case SCF_ERROR_CONNECTION_BROKEN:
355558276701Shg return (ECONNABORTED);
355658276701Shg
355758276701Shg case SCF_ERROR_DELETED:
355858276701Shg return (ECANCELED);
355958276701Shg
356058276701Shg case SCF_ERROR_NOT_SET:
356158276701Shg case SCF_ERROR_INVALID_ARGUMENT:
356258276701Shg case SCF_ERROR_NOT_BOUND:
356358276701Shg case SCF_ERROR_HANDLE_MISMATCH:
35643eae19d9Swesolows case SCF_ERROR_PERMISSION_DENIED:
356558276701Shg default:
356658276701Shg bad_error("scf_iter_next_value", scf_error());
356758276701Shg }
35687c478bd9Sstevel@tonic-gate }
35697c478bd9Sstevel@tonic-gate if (r == 0)
35707c478bd9Sstevel@tonic-gate break;
35717c478bd9Sstevel@tonic-gate
35727c478bd9Sstevel@tonic-gate sz = scf_value_get_astring(val, buf, max_scf_value_size);
35737c478bd9Sstevel@tonic-gate assert(sz >= 0);
35747c478bd9Sstevel@tonic-gate
35757c478bd9Sstevel@tonic-gate r = cb(buf, arg);
35767c478bd9Sstevel@tonic-gate
35777c478bd9Sstevel@tonic-gate if (r != 0)
35787c478bd9Sstevel@tonic-gate break;
35797c478bd9Sstevel@tonic-gate }
35807c478bd9Sstevel@tonic-gate
35817c478bd9Sstevel@tonic-gate startd_free(buf, max_scf_value_size);
35827c478bd9Sstevel@tonic-gate scf_value_destroy(val);
35837c478bd9Sstevel@tonic-gate scf_iter_destroy(iter);
35847c478bd9Sstevel@tonic-gate
35857c478bd9Sstevel@tonic-gate return (r == 0 ? 0 : EINTR);
35867c478bd9Sstevel@tonic-gate }
35877c478bd9Sstevel@tonic-gate
35887c478bd9Sstevel@tonic-gate /*
35897c478bd9Sstevel@tonic-gate * Returns 0 or ECONNABORTED.
35907c478bd9Sstevel@tonic-gate */
35917c478bd9Sstevel@tonic-gate int
libscf_create_self(scf_handle_t * h)35927c478bd9Sstevel@tonic-gate libscf_create_self(scf_handle_t *h)
35937c478bd9Sstevel@tonic-gate {
35947c478bd9Sstevel@tonic-gate scf_scope_t *scope;
35957c478bd9Sstevel@tonic-gate scf_service_t *svc;
35967c478bd9Sstevel@tonic-gate scf_instance_t *inst;
35977c478bd9Sstevel@tonic-gate instance_data_t idata;
35987c478bd9Sstevel@tonic-gate int ret = 0, r;
35997c478bd9Sstevel@tonic-gate ctid_t ctid;
36007c478bd9Sstevel@tonic-gate uint64_t uint64;
36017c478bd9Sstevel@tonic-gate uint_t count = 0, msecs = ALLOC_DELAY;
36027c478bd9Sstevel@tonic-gate
36037c478bd9Sstevel@tonic-gate const char * const startd_svc = "system/svc/restarter";
36047c478bd9Sstevel@tonic-gate const char * const startd_inst = "default";
36057c478bd9Sstevel@tonic-gate
36067c478bd9Sstevel@tonic-gate /* If SCF_SERVICE_STARTD changes, our strings must change, too. */
36077c478bd9Sstevel@tonic-gate assert(strcmp(SCF_SERVICE_STARTD,
36087c478bd9Sstevel@tonic-gate "svc:/system/svc/restarter:default") == 0);
36097c478bd9Sstevel@tonic-gate
36107c478bd9Sstevel@tonic-gate scope = safe_scf_scope_create(h);
36117c478bd9Sstevel@tonic-gate svc = safe_scf_service_create(h);
36127c478bd9Sstevel@tonic-gate inst = safe_scf_instance_create(h);
36137c478bd9Sstevel@tonic-gate
36147c478bd9Sstevel@tonic-gate if (scf_handle_get_scope(h, SCF_SCOPE_LOCAL, scope) != 0) {
36157c478bd9Sstevel@tonic-gate assert(scf_error() == SCF_ERROR_CONNECTION_BROKEN);
36167c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
36177c478bd9Sstevel@tonic-gate goto out;
36187c478bd9Sstevel@tonic-gate }
36197c478bd9Sstevel@tonic-gate
36207c478bd9Sstevel@tonic-gate get_svc:
36217c478bd9Sstevel@tonic-gate if (scf_scope_get_service(scope, startd_svc, svc) != 0) {
36227c478bd9Sstevel@tonic-gate switch (scf_error()) {
36237c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
36247c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
36257c478bd9Sstevel@tonic-gate default:
36267c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
36277c478bd9Sstevel@tonic-gate goto out;
36287c478bd9Sstevel@tonic-gate
36297c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
36307c478bd9Sstevel@tonic-gate break;
36317c478bd9Sstevel@tonic-gate
36327c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
36337c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
36347c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
36357c478bd9Sstevel@tonic-gate bad_error("scf_scope_get_service", scf_error());
36367c478bd9Sstevel@tonic-gate }
36377c478bd9Sstevel@tonic-gate
36387c478bd9Sstevel@tonic-gate add_svc:
36397c478bd9Sstevel@tonic-gate if (scf_scope_add_service(scope, startd_svc, svc) != 0) {
36407c478bd9Sstevel@tonic-gate switch (scf_error()) {
36417c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
36427c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
36437c478bd9Sstevel@tonic-gate default:
36447c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
36457c478bd9Sstevel@tonic-gate goto out;
36467c478bd9Sstevel@tonic-gate
36477c478bd9Sstevel@tonic-gate case SCF_ERROR_EXISTS:
36487c478bd9Sstevel@tonic-gate goto get_svc;
36497c478bd9Sstevel@tonic-gate
36507c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
36517c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
36527c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
36537c478bd9Sstevel@tonic-gate uu_warn("Could not create %s: %s\n",
36547c478bd9Sstevel@tonic-gate SCF_SERVICE_STARTD,
36557c478bd9Sstevel@tonic-gate scf_strerror(scf_error()));
36567c478bd9Sstevel@tonic-gate goto out;
36577c478bd9Sstevel@tonic-gate
36587c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
36597c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
36607c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
36617c478bd9Sstevel@tonic-gate bad_error("scf_scope_add_service", scf_error());
36627c478bd9Sstevel@tonic-gate }
36637c478bd9Sstevel@tonic-gate }
36647c478bd9Sstevel@tonic-gate }
36657c478bd9Sstevel@tonic-gate
36667c478bd9Sstevel@tonic-gate if (scf_service_get_instance(svc, startd_inst, NULL) == 0)
36677c478bd9Sstevel@tonic-gate goto out;
36687c478bd9Sstevel@tonic-gate
36697c478bd9Sstevel@tonic-gate switch (scf_error()) {
36707c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
36717c478bd9Sstevel@tonic-gate default:
36727c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
36737c478bd9Sstevel@tonic-gate goto out;
36747c478bd9Sstevel@tonic-gate
36757c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
36767c478bd9Sstevel@tonic-gate break;
36777c478bd9Sstevel@tonic-gate
36787c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
36797c478bd9Sstevel@tonic-gate goto add_svc;
36807c478bd9Sstevel@tonic-gate
36817c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
36827c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
36837c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
36847c478bd9Sstevel@tonic-gate bad_error("scf_service_get_instance", scf_error());
36857c478bd9Sstevel@tonic-gate }
36867c478bd9Sstevel@tonic-gate
36877c478bd9Sstevel@tonic-gate add_inst:
36887c478bd9Sstevel@tonic-gate if (scf_service_add_instance(svc, startd_inst, inst) != 0) {
36897c478bd9Sstevel@tonic-gate switch (scf_error()) {
36907c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
36917c478bd9Sstevel@tonic-gate default:
36927c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
36937c478bd9Sstevel@tonic-gate goto out;
36947c478bd9Sstevel@tonic-gate
36957c478bd9Sstevel@tonic-gate case SCF_ERROR_EXISTS:
36967c478bd9Sstevel@tonic-gate break;
36977c478bd9Sstevel@tonic-gate
36987c478bd9Sstevel@tonic-gate case SCF_ERROR_PERMISSION_DENIED:
36997c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_ACCESS:
37007c478bd9Sstevel@tonic-gate uu_die("Could not create %s: %s\n", SCF_SERVICE_STARTD,
37017c478bd9Sstevel@tonic-gate scf_strerror(scf_error()));
37027c478bd9Sstevel@tonic-gate /* NOTREACHED */
37037c478bd9Sstevel@tonic-gate
37047c478bd9Sstevel@tonic-gate case SCF_ERROR_BACKEND_READONLY:
37057c478bd9Sstevel@tonic-gate log_error(LOG_NOTICE,
37067c478bd9Sstevel@tonic-gate "Could not create %s: backend readonly.\n",
37077c478bd9Sstevel@tonic-gate SCF_SERVICE_STARTD);
37087c478bd9Sstevel@tonic-gate goto out;
37097c478bd9Sstevel@tonic-gate
37107c478bd9Sstevel@tonic-gate case SCF_ERROR_DELETED:
37117c478bd9Sstevel@tonic-gate goto add_svc;
37127c478bd9Sstevel@tonic-gate
37137c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
37147c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
37157c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_SET:
37167c478bd9Sstevel@tonic-gate bad_error("scf_service_add_instance", scf_error());
37177c478bd9Sstevel@tonic-gate }
37187c478bd9Sstevel@tonic-gate }
37197c478bd9Sstevel@tonic-gate
37207c478bd9Sstevel@tonic-gate /* Set start time. */
37217c478bd9Sstevel@tonic-gate idata.i_fmri = SCF_SERVICE_STARTD;
37227c478bd9Sstevel@tonic-gate idata.i_state = RESTARTER_STATE_NONE;
37237c478bd9Sstevel@tonic-gate idata.i_next_state = RESTARTER_STATE_NONE;
37247c478bd9Sstevel@tonic-gate set_state:
3725f6e214c7SGavin Maltby switch (r = _restarter_commit_states(h, &idata,
3726f6e214c7SGavin Maltby RESTARTER_STATE_ONLINE, RESTARTER_STATE_NONE,
3727f6e214c7SGavin Maltby restarter_get_str_short(restarter_str_insert_in_graph))) {
37287c478bd9Sstevel@tonic-gate case 0:
37297c478bd9Sstevel@tonic-gate break;
37307c478bd9Sstevel@tonic-gate
37317c478bd9Sstevel@tonic-gate case ENOMEM:
37327c478bd9Sstevel@tonic-gate ++count;
37337c478bd9Sstevel@tonic-gate if (count < ALLOC_RETRY) {
37347c478bd9Sstevel@tonic-gate (void) poll(NULL, 0, msecs);
37357c478bd9Sstevel@tonic-gate msecs *= ALLOC_DELAY_MULT;
37367c478bd9Sstevel@tonic-gate goto set_state;
37377c478bd9Sstevel@tonic-gate }
37387c478bd9Sstevel@tonic-gate
37397c478bd9Sstevel@tonic-gate uu_die("Insufficient memory.\n");
37407c478bd9Sstevel@tonic-gate /* NOTREACHED */
37417c478bd9Sstevel@tonic-gate
37427c478bd9Sstevel@tonic-gate case ECONNABORTED:
37437c478bd9Sstevel@tonic-gate ret = ECONNABORTED;
37447c478bd9Sstevel@tonic-gate goto out;
37457c478bd9Sstevel@tonic-gate
37467c478bd9Sstevel@tonic-gate case ENOENT:
37477c478bd9Sstevel@tonic-gate goto add_inst;
37487c478bd9Sstevel@tonic-gate
37497c478bd9Sstevel@tonic-gate case EPERM:
37507c478bd9Sstevel@tonic-gate case EACCES:
37517c478bd9Sstevel@tonic-gate case EROFS:
37527c478bd9Sstevel@tonic-gate uu_warn("Could not timestamp %s: %s\n", idata.i_fmri,
37537c478bd9Sstevel@tonic-gate strerror(r));
37547c478bd9Sstevel@tonic-gate break;
37557c478bd9Sstevel@tonic-gate
37567c478bd9Sstevel@tonic-gate case EINVAL:
37577c478bd9Sstevel@tonic-gate default:
37587c478bd9Sstevel@tonic-gate bad_error("_restarter_commit_states", r);
37597c478bd9Sstevel@tonic-gate }
37607c478bd9Sstevel@tonic-gate
37617c478bd9Sstevel@tonic-gate /* Set general/enabled. */
37627c478bd9Sstevel@tonic-gate ret = libscf_inst_set_boolean_prop(inst, SCF_PG_GENERAL,
37637c478bd9Sstevel@tonic-gate SCF_PG_GENERAL_TYPE, SCF_PG_GENERAL_FLAGS, SCF_PROPERTY_ENABLED, 1);
37647c478bd9Sstevel@tonic-gate switch (ret) {
37657c478bd9Sstevel@tonic-gate case 0:
37667c478bd9Sstevel@tonic-gate case ECONNABORTED:
37677c478bd9Sstevel@tonic-gate case EPERM:
37687c478bd9Sstevel@tonic-gate case EACCES:
37697c478bd9Sstevel@tonic-gate case EROFS:
37707c478bd9Sstevel@tonic-gate break;
37717c478bd9Sstevel@tonic-gate
37727c478bd9Sstevel@tonic-gate case ECANCELED:
37737c478bd9Sstevel@tonic-gate goto add_inst;
37747c478bd9Sstevel@tonic-gate
37757c478bd9Sstevel@tonic-gate default:
37767c478bd9Sstevel@tonic-gate bad_error("libscf_inst_set_boolean_prop", ret);
37777c478bd9Sstevel@tonic-gate }
37787c478bd9Sstevel@tonic-gate
37797c478bd9Sstevel@tonic-gate ret = libscf_write_start_pid(inst, getpid());
37807c478bd9Sstevel@tonic-gate switch (ret) {
37817c478bd9Sstevel@tonic-gate case 0:
37827c478bd9Sstevel@tonic-gate case ECONNABORTED:
37837c478bd9Sstevel@tonic-gate case EPERM:
37847c478bd9Sstevel@tonic-gate case EACCES:
37857c478bd9Sstevel@tonic-gate case EROFS:
37867c478bd9Sstevel@tonic-gate break;
37877c478bd9Sstevel@tonic-gate
37887c478bd9Sstevel@tonic-gate case ECANCELED:
37897c478bd9Sstevel@tonic-gate goto add_inst;
37907c478bd9Sstevel@tonic-gate
37917c478bd9Sstevel@tonic-gate default:
37927c478bd9Sstevel@tonic-gate bad_error("libscf_write_start_pid", ret);
37937c478bd9Sstevel@tonic-gate }
37947c478bd9Sstevel@tonic-gate
37957c478bd9Sstevel@tonic-gate ctid = proc_get_ctid();
37967c478bd9Sstevel@tonic-gate if (ctid > 0) {
37977c478bd9Sstevel@tonic-gate
37987c478bd9Sstevel@tonic-gate uint64 = (uint64_t)ctid;
37997c478bd9Sstevel@tonic-gate ret = libscf_inst_set_count_prop(inst,
38007c478bd9Sstevel@tonic-gate SCF_PG_RESTARTER, SCF_PG_RESTARTER_TYPE,
38017c478bd9Sstevel@tonic-gate SCF_PG_RESTARTER_FLAGS, SCF_PROPERTY_CONTRACT, uint64);
38027c478bd9Sstevel@tonic-gate
38037c478bd9Sstevel@tonic-gate switch (ret) {
38047c478bd9Sstevel@tonic-gate case 0:
38057c478bd9Sstevel@tonic-gate case ECONNABORTED:
38067c478bd9Sstevel@tonic-gate case EPERM:
38077c478bd9Sstevel@tonic-gate case EACCES:
38087c478bd9Sstevel@tonic-gate case EROFS:
38097c478bd9Sstevel@tonic-gate break;
38107c478bd9Sstevel@tonic-gate
38117c478bd9Sstevel@tonic-gate case ECANCELED:
38127c478bd9Sstevel@tonic-gate goto add_inst;
38137c478bd9Sstevel@tonic-gate
38147c478bd9Sstevel@tonic-gate default:
38157c478bd9Sstevel@tonic-gate bad_error("libscf_inst_set_count_prop", ret);
38167c478bd9Sstevel@tonic-gate }
38177c478bd9Sstevel@tonic-gate }
38187c478bd9Sstevel@tonic-gate
38197c478bd9Sstevel@tonic-gate ret = libscf_note_method_log(inst, LOG_PREFIX_EARLY,
38207c478bd9Sstevel@tonic-gate STARTD_DEFAULT_LOG);
38217c478bd9Sstevel@tonic-gate if (ret == 0) {
38227c478bd9Sstevel@tonic-gate ret = libscf_note_method_log(inst, LOG_PREFIX_NORMAL,
38237c478bd9Sstevel@tonic-gate STARTD_DEFAULT_LOG);
38247c478bd9Sstevel@tonic-gate }
38257c478bd9Sstevel@tonic-gate
38267c478bd9Sstevel@tonic-gate switch (ret) {
38273924b44bSSean Wilcox case 0:
38287c478bd9Sstevel@tonic-gate case ECONNABORTED:
38297c478bd9Sstevel@tonic-gate case EPERM:
38307c478bd9Sstevel@tonic-gate case EACCES:
38317c478bd9Sstevel@tonic-gate case EROFS:
38327c478bd9Sstevel@tonic-gate case EAGAIN:
38337c478bd9Sstevel@tonic-gate break;
38347c478bd9Sstevel@tonic-gate
38357c478bd9Sstevel@tonic-gate case ECANCELED:
38367c478bd9Sstevel@tonic-gate goto add_inst;
38377c478bd9Sstevel@tonic-gate
38387c478bd9Sstevel@tonic-gate default:
38397c478bd9Sstevel@tonic-gate bad_error("libscf_note_method_log", ret);
38407c478bd9Sstevel@tonic-gate }
38417c478bd9Sstevel@tonic-gate
38427c478bd9Sstevel@tonic-gate out:
38437c478bd9Sstevel@tonic-gate scf_instance_destroy(inst);
38447c478bd9Sstevel@tonic-gate scf_service_destroy(svc);
38457c478bd9Sstevel@tonic-gate scf_scope_destroy(scope);
38467c478bd9Sstevel@tonic-gate return (ret);
38477c478bd9Sstevel@tonic-gate }
38487c478bd9Sstevel@tonic-gate
38497c478bd9Sstevel@tonic-gate /*
38507c478bd9Sstevel@tonic-gate * Returns
38517c478bd9Sstevel@tonic-gate * 0 - success
38527c478bd9Sstevel@tonic-gate * ENOENT - SCF_SERVICE_STARTD does not exist in repository
38537c478bd9Sstevel@tonic-gate * EPERM
38547c478bd9Sstevel@tonic-gate * EACCES
38557c478bd9Sstevel@tonic-gate * EROFS
38567c478bd9Sstevel@tonic-gate */
38577c478bd9Sstevel@tonic-gate int
libscf_set_reconfig(int set)38587c478bd9Sstevel@tonic-gate libscf_set_reconfig(int set)
38597c478bd9Sstevel@tonic-gate {
38607c478bd9Sstevel@tonic-gate scf_handle_t *h;
38617c478bd9Sstevel@tonic-gate scf_instance_t *inst;
38627c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg;
38637c478bd9Sstevel@tonic-gate int ret = 0;
38647c478bd9Sstevel@tonic-gate
38657c478bd9Sstevel@tonic-gate h = libscf_handle_create_bound_loop();
38667c478bd9Sstevel@tonic-gate inst = safe_scf_instance_create(h);
38677c478bd9Sstevel@tonic-gate pg = safe_scf_pg_create(h);
38687c478bd9Sstevel@tonic-gate
38697c478bd9Sstevel@tonic-gate again:
38707c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, SCF_SERVICE_STARTD, NULL, NULL,
38717c478bd9Sstevel@tonic-gate inst, NULL, NULL, SCF_DECODE_FMRI_EXACT) == -1) {
38727c478bd9Sstevel@tonic-gate switch (scf_error()) {
38737c478bd9Sstevel@tonic-gate case SCF_ERROR_CONNECTION_BROKEN:
38747c478bd9Sstevel@tonic-gate default:
38757c478bd9Sstevel@tonic-gate libscf_handle_rebind(h);
38767c478bd9Sstevel@tonic-gate goto again;
38777c478bd9Sstevel@tonic-gate
38787c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND:
38797c478bd9Sstevel@tonic-gate ret = ENOENT;
38807c478bd9Sstevel@tonic-gate goto reconfig_out;
38817c478bd9Sstevel@tonic-gate
38827c478bd9Sstevel@tonic-gate case SCF_ERROR_HANDLE_MISMATCH:
38837c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT:
38847c478bd9Sstevel@tonic-gate case SCF_ERROR_CONSTRAINT_VIOLATED:
38857c478bd9Sstevel@tonic-gate bad_error("scf_handle_decode_fmri", scf_error());
38867c478bd9Sstevel@tonic-gate }
38877c478bd9Sstevel@tonic-gate }
38887c478bd9Sstevel@tonic-gate
38897c478bd9Sstevel@tonic-gate ret = libscf_inst_set_boolean_prop(inst, "system", SCF_GROUP_FRAMEWORK,
38907c478bd9Sstevel@tonic-gate SCF_PG_FLAG_NONPERSISTENT, "reconfigure", set);
38917c478bd9Sstevel@tonic-gate switch (ret) {
38927c478bd9Sstevel@tonic-gate case 0:
38937c478bd9Sstevel@tonic-gate case EPERM:
38947c478bd9Sstevel@tonic-gate case EACCES:
38957c478bd9Sstevel@tonic-gate case EROFS:
38967c478bd9Sstevel@tonic-gate break;
38977c478bd9Sstevel@tonic-gate
38987c478bd9Sstevel@tonic-gate case ECONNABORTED:
38997c478bd9Sstevel@tonic-gate libscf_handle_rebind(h);
39007c478bd9Sstevel@tonic-gate goto again;
39017c478bd9Sstevel@tonic-gate
39027c478bd9Sstevel@tonic-gate case ECANCELED:
39037c478bd9Sstevel@tonic-gate ret = ENOENT;
39047c478bd9Sstevel@tonic-gate break;
39057c478bd9Sstevel@tonic-gate
39067c478bd9Sstevel@tonic-gate default:
39077c478bd9Sstevel@tonic-gate bad_error("libscf_inst_set_boolean_prop", ret);
39087c478bd9Sstevel@tonic-gate }
39097c478bd9Sstevel@tonic-gate
39107c478bd9Sstevel@tonic-gate reconfig_out:
39117c478bd9Sstevel@tonic-gate scf_pg_destroy(pg);
39127c478bd9Sstevel@tonic-gate scf_instance_destroy(inst);
39137c478bd9Sstevel@tonic-gate scf_handle_destroy(h);
39147c478bd9Sstevel@tonic-gate return (ret);
39157c478bd9Sstevel@tonic-gate }
39167c478bd9Sstevel@tonic-gate
39177c478bd9Sstevel@tonic-gate /*
39187c478bd9Sstevel@tonic-gate * Set inst->ri_m_inst to the scf instance for inst. If it has been deleted,
39197c478bd9Sstevel@tonic-gate * set inst->ri_mi_deleted to true. If the repository connection is broken, it
39207c478bd9Sstevel@tonic-gate * is rebound with libscf_handle_rebound().
39217c478bd9Sstevel@tonic-gate */
39227c478bd9Sstevel@tonic-gate void
libscf_reget_instance(restarter_inst_t * inst)39237c478bd9Sstevel@tonic-gate libscf_reget_instance(restarter_inst_t *inst)
39247c478bd9Sstevel@tonic-gate {
39257c478bd9Sstevel@tonic-gate scf_handle_t *h;
39267c478bd9Sstevel@tonic-gate int r;
39277c478bd9Sstevel@tonic-gate
39287c478bd9Sstevel@tonic-gate h = scf_instance_handle(inst->ri_m_inst);
39297c478bd9Sstevel@tonic-gate
39307c478bd9Sstevel@tonic-gate again:
39317c478bd9Sstevel@tonic-gate r = libscf_lookup_instance(inst->ri_i.i_fmri, inst->ri_m_inst);
39327c478bd9Sstevel@tonic-gate switch (r) {
39337c478bd9Sstevel@tonic-gate case 0:
39347c478bd9Sstevel@tonic-gate case ENOENT:
39357c478bd9Sstevel@tonic-gate inst->ri_mi_deleted = (r == ENOENT);
39367c478bd9Sstevel@tonic-gate return;
39377c478bd9Sstevel@tonic-gate
39387c478bd9Sstevel@tonic-gate case ECONNABORTED:
39397c478bd9Sstevel@tonic-gate libscf_handle_rebind(h);
39407c478bd9Sstevel@tonic-gate goto again;
39417c478bd9Sstevel@tonic-gate
39427c478bd9Sstevel@tonic-gate case EINVAL:
39437c478bd9Sstevel@tonic-gate case ENOTSUP:
39447c478bd9Sstevel@tonic-gate default:
39457c478bd9Sstevel@tonic-gate bad_error("libscf_lookup_instance", r);
39467c478bd9Sstevel@tonic-gate }
39477c478bd9Sstevel@tonic-gate }
3948