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