1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2012 Milan Jurik. All rights reserved. 24 */ 25 26 #include <libscf.h> 27 #include <stdio.h> 28 #include <stdlib.h> 29 #include <errno.h> 30 #include <assert.h> 31 #include <strings.h> 32 #include <libstmf.h> 33 #include <store.h> 34 #include <syslog.h> 35 #include <signal.h> 36 #include <pthread.h> 37 #include <libnvpair.h> 38 #include <limits.h> 39 #include <unistd.h> 40 41 /* 42 * This file's functions are responsible for all store and retrieve operations 43 * against the STMF smf(5) database. The following shows the currently defined 44 * schema for the STMF database: 45 * 46 * Description of property groups for service: svc:/system/stmf 47 * 48 * Stability: Volatile 49 * 50 * 1. Property Group: host_groups 51 * Properties: group_name-<N> where <N> is an unsigned integer 52 * type: ustring 53 * contains: group name 54 * group_name-<N>-member_list where <N> is an unsigned 55 * integer matching a group_name-<N> property. 56 * type: ustring 57 * contains: list of members 58 * 59 * Description: 60 * Contains the host group names as well as the host group members 61 * for each host group. 62 * 63 * 2. Property Group: target_groups 64 * Properties: group_name-<N> where <N> is an unsigned integer 65 * type: ustring 66 * contains: group name 67 * group_name-<N>-member_list where <N> is an unsigned 68 * integer matching a group_name-<N> property. 69 * type: ustring 70 * contains: list of members 71 * 72 * Description: 73 * Contains the target group names as well as the target group 74 * members for each target group. 75 * 76 * 3. Property Group: lu-<GUID> 77 * where <GUID> is a 32 character hexadecimal string. 78 * Properties: ve_cnt 79 * type: count 80 * contains: the number of current view entries 81 * view-entry-<N>-<GUID> where <N> is an unsigned integer 82 * type: ustring 83 * contains: nothing. Used as reference to the view 84 * entry property group 85 * 86 * Description: 87 * Contains the references to each view entry. One lu-<GUID> 88 * property group will exist for each logical unit with 1 or more 89 * view entries. 90 * Potentially can hold any other data that can be managed on a per 91 * logical unit basis. 92 * 93 * 4. Property Group: view_entry-<N>-<GUID> (matches property in lu-<GUID> 94 * property group) 95 * Properties: all_hosts 96 * type: boolean 97 * contains: when true, the value of host_group is 98 * ignored 99 * all_targets 100 * type: boolean 101 * contains: when true, the value of target_group is 102 * ignored 103 * host_group 104 * type: ustring 105 * contains: host group for logical unit mapping and 106 * masking purposes 107 * target_group 108 * type: ustring 109 * contains: target group for logical unit mapping and 110 * masking purposes 111 * lu_nbr 112 * type: opaque 113 * contains: the 8-byte SCSI logical unit number for 114 * mapping and masking purposes 115 * Description: 116 * One "view_entry-<N>-<GUID>" property group will exist for each 117 * view entry in the system. This property group name maps 118 * directly to the "lu-<GUID>" property group with a matching 119 * <GUID>. 120 * 121 * 5. Property Group: provider_data_pg_<provider-name> 122 * where <provider-name> is the name of the provider 123 * registered with stmf. 124 * Properties: provider_data_prop-<N> 125 * where <N> is a sequential identifier for the data 126 * chunk. 127 * type: opaque 128 * contains: up to STMF_PROVIDER_DATA_PROP_SIZE bytes 129 * of nvlist packed data. 130 * provider_data_count 131 * type: count 132 * contains: the number of provider data chunks 133 * provider_data_type 134 * type: integer 135 * contains: STMF_PORT_PROVIDER_TYPE or 136 * STMF_LU_PROVIDER_TYPE 137 * 138 * Description: 139 * Holds the nvlist packed provider data set via 140 * stmfSetProviderData and retrieved via stmfGetProviderData. Data 141 * is stored in STMF_PROVIDER_DATA_PROP_SIZE chunks. On retrieve, 142 * these chunks are reassembled and unpacked. 143 * 144 */ 145 146 static int iPsInit(scf_handle_t **, scf_service_t **); 147 static int iPsCreateDeleteGroup(char *, char *, int); 148 static int iPsAddRemoveGroupMember(char *, char *, char *, int); 149 static int iPsGetGroupList(char *, stmfGroupList **); 150 static int iPsGetGroupMemberList(char *, char *, stmfGroupProperties **); 151 static int iPsAddViewEntry(char *, char *, stmfViewEntry *); 152 static int iPsAddRemoveLuViewEntry(char *, char *, int); 153 static int iPsGetViewEntry(char *, stmfViewEntry *); 154 static int iPsGetActualGroupName(char *, char *, char *); 155 static int iPsGetServiceVersion(uint64_t *, scf_handle_t *, scf_service_t *); 156 static int iPsGetSetPersistType(uint8_t *, scf_handle_t *, scf_service_t *, 157 int); 158 static int iPsGetSetStmfProp(int, char *, int); 159 static int viewEntryCompare(const void *, const void *); 160 static int holdSignal(sigset_t *); 161 static int releaseSignal(sigset_t *); 162 static void sigHandler(); 163 164 static pthread_mutex_t sigSetLock = PTHREAD_MUTEX_INITIALIZER; 165 166 sigset_t sigSet; 167 sigset_t signalsCaught; 168 169 struct sigaction currentActionQuit; 170 struct sigaction currentActionTerm; 171 struct sigaction currentActionInt; 172 173 boolean_t actionSet = B_FALSE; 174 175 /* 176 * Version info for the SMF schema 177 */ 178 #define STMF_SMF_VERSION 1 179 180 /* 181 * Note: Do not change these property names and size values. 182 * They represent fields in the persistent config and once modified 183 * will have a nasty side effect of invalidating the existing store. 184 * If you do need to change them, you'll need to use the versioning above 185 * to retain backward compatiblity with the previous configuration schema. 186 */ 187 188 /* BEGIN STORE PROPERTY DEFINITIONS */ 189 /* 190 * Property Group Names and prefixes 191 */ 192 #define STMF_HOST_GROUPS "host_groups" 193 #define STMF_TARGET_GROUPS "target_groups" 194 #define STMF_VE_PREFIX "view_entry" 195 #define STMF_LU_PREFIX "lu" 196 #define STMF_DATA_GROUP "stmf_data" 197 198 /* 199 * Property names and prefix for logical unit property group 200 */ 201 #define STMF_VE_CNT "ve_cnt" 202 #define STMF_GROUP_PREFIX "group_name" 203 #define STMF_MEMBER_LIST_SUFFIX "member_list" 204 #define STMF_VERSION_NAME "version_name" 205 #define STMF_PERSIST_TYPE "persist_method" 206 207 /* Property names for stmf properties */ 208 209 #define DEFAULT_LU_STATE "default_lu_state" 210 #define DEFAULT_TARGET_PORT_STATE "default_target_state" 211 212 /* 213 * Property names for view entry 214 */ 215 #define STMF_VE_ALLHOSTS "all_hosts" 216 #define STMF_VE_HOSTGROUP "host_group" 217 #define STMF_VE_ALLTARGETS "all_targets" 218 #define STMF_VE_TARGETGROUP "target_group" 219 #define STMF_VE_LUNBR "lu_nbr" 220 221 /* Property group suffix for provider data */ 222 #define STMF_PROVIDER_DATA_PREFIX "provider_data_pg_" 223 #define STMF_PROVIDER_DATA_PROP_PREFIX "provider_data_prop" 224 #define STMF_PROVIDER_DATA_PROP_NAME_SIZE 256 225 #define STMF_PROVIDER_DATA_PROP_TYPE "provider_type" 226 #define STMF_PROVIDER_DATA_PROP_SET_COUNT "provider_data_set_cnt" 227 #define STMF_PROVIDER_DATA_PROP_COUNT "provider_data_cnt" 228 229 230 #define STMF_SMF_READ_ATTR "solaris.smf.read.stmf" 231 232 #define STMF_PS_PERSIST_NONE "none" 233 #define STMF_PS_PERSIST_SMF "smf" 234 #define STMF_PROVIDER_DATA_PROP_SIZE 4000 235 236 #define STMF_PS_LU_ONLINE "default_lu_online" 237 #define STMF_PS_LU_OFFLINE "default_lu_offline" 238 #define STMF_PS_TARGET_PORT_ONLINE "default_target_online" 239 #define STMF_PS_TARGET_PORT_OFFLINE "default_target_offline" 240 241 /* END STORE PROPERTY DEFINITIONS */ 242 243 /* service name */ 244 #define STMF_SERVICE "system/stmf" 245 246 /* limits and flag values */ 247 #define GROUP_MEMBER_ALLOC 100 248 #define VIEW_ENTRY_STRUCT_CNT 6 249 #define VIEW_ENTRY_PG_SIZE 256 250 #define LOGICAL_UNIT_PG_SIZE 256 251 #define VIEW_ENTRY_MAX UINT32_MAX 252 #define GROUP_MAX UINT64_MAX 253 #define ADD 0 254 #define REMOVE 1 255 #define GET 0 256 #define SET 1 257 258 /* 259 * sigHandler 260 * 261 * Catch the signal and set the global signalsCaught to the signal received 262 * 263 * signalsCaught will be used by releaseSignal to raise this signal when 264 * we're done processing our critical code. 265 * 266 */ 267 static void 268 sigHandler(int sig) 269 { 270 (void) sigaddset(&signalsCaught, sig); 271 } 272 273 /* 274 * iPsAddRemoveGroupMember 275 * 276 * Add or remove a member for a given group 277 * 278 * pgName - Property group name 279 * groupName - group name to which the member is added/removed 280 * memberName - member to be added/removed 281 * addRemoveFlag - ADD/REMOVE 282 * 283 * returns: 284 * STMF_PS_SUCCESS on success 285 * STMF_PS_ERROR_* on failure 286 */ 287 static int 288 iPsAddRemoveGroupMember(char *pgName, char *groupName, char *memberName, 289 int addRemoveFlag) 290 { 291 scf_handle_t *handle = NULL; 292 scf_service_t *svc = NULL; 293 scf_propertygroup_t *pg = NULL; 294 scf_property_t *prop = NULL; 295 scf_value_t *valueLookup = NULL; 296 scf_value_t **valueSet = NULL; 297 scf_iter_t *valueIter = NULL; 298 scf_transaction_t *tran = NULL; 299 scf_transaction_entry_t *entry = NULL; 300 int i = 0; 301 int lastAlloc; 302 int valueArraySize = 0; 303 int ret = STMF_PS_SUCCESS; 304 char buf[STMF_IDENT_LENGTH]; 305 int commitRet; 306 boolean_t found = B_FALSE; 307 308 assert(pgName != NULL && groupName != NULL && memberName != NULL); 309 310 /* 311 * Init the service handle 312 */ 313 ret = iPsInit(&handle, &svc); 314 if (ret != STMF_PS_SUCCESS) { 315 goto out; 316 } 317 318 /* 319 * Allocate scf resources 320 */ 321 if (((pg = scf_pg_create(handle)) == NULL) || 322 ((tran = scf_transaction_create(handle)) == NULL) || 323 ((entry = scf_entry_create(handle)) == NULL) || 324 ((prop = scf_property_create(handle)) == NULL) || 325 ((valueIter = scf_iter_create(handle)) == NULL)) { 326 syslog(LOG_ERR, "scf alloc resource failed - %s", 327 scf_strerror(scf_error())); 328 ret = STMF_PS_ERROR; 329 goto out; 330 } 331 332 /* 333 * Get the service property group handle 334 */ 335 if (scf_service_get_pg(svc, pgName, pg) == -1) { 336 if (scf_error() == SCF_ERROR_NOT_FOUND) { 337 ret = STMF_PS_ERROR_NOT_FOUND; 338 } else { 339 ret = STMF_PS_ERROR; 340 } 341 syslog(LOG_ERR, "get pg %s failed - %s", 342 pgName, scf_strerror(scf_error())); 343 344 goto out; 345 } 346 347 /* 348 * Begin the transaction 349 */ 350 if (scf_transaction_start(tran, pg) == -1) { 351 syslog(LOG_ERR, "start transaction for %s failed - %s", 352 pgName, scf_strerror(scf_error())); 353 ret = STMF_PS_ERROR; 354 goto out; 355 } 356 357 /* 358 * We're changing an existing property by adding a propval 359 * There are no add semantics in libscf for a property value. We'll 360 * need to read in the current properties and apply them all to the 361 * set and then add the one we were asked to add or omit the one 362 * we were asked to remove. 363 */ 364 if (scf_transaction_property_change(tran, entry, groupName, 365 SCF_TYPE_USTRING) == -1) { 366 if (scf_error() == SCF_ERROR_NOT_FOUND) { 367 ret = STMF_PS_ERROR_GROUP_NOT_FOUND; 368 } else { 369 ret = STMF_PS_ERROR; 370 syslog(LOG_ERR, "tran property change %s/%s " 371 "failed - %s", pgName, groupName, 372 scf_strerror(scf_error())); 373 } 374 goto out; 375 } 376 377 /* 378 * Get the property handle 379 */ 380 if (scf_pg_get_property(pg, groupName, prop) == -1) { 381 syslog(LOG_ERR, "get property %s/%s failed - %s", 382 pgName, groupName, scf_strerror(scf_error())); 383 ret = STMF_PS_ERROR; 384 goto out; 385 } 386 387 /* 388 * Value lookup is used to lookup the existing values 389 */ 390 valueLookup = scf_value_create(handle); 391 if (valueLookup == NULL) { 392 syslog(LOG_ERR, "scf value alloc for %s failed - %s", 393 pgName, scf_strerror(scf_error())); 394 ret = STMF_PS_ERROR; 395 goto out; 396 } 397 398 /* 399 * valueIter is the iterator handle, create the resource 400 */ 401 if (scf_iter_property_values(valueIter, prop) == -1) { 402 syslog(LOG_ERR, "iter values for %s/%s failed - %s", 403 pgName, groupName, scf_strerror(scf_error())); 404 ret = STMF_PS_ERROR; 405 goto out; 406 } 407 408 /* 409 * Allocate value resource pointers. 410 * We need a value resource for each value as value pointers passed 411 * to libscf cannot be destroyed until the commit or destroy on the 412 * transaction is done. 413 * 414 * We're using GROUP_MEMBER_ALLOC initially. If it's not large 415 * enough, we'll realloc on the fly 416 */ 417 valueSet = (scf_value_t **)calloc(1, sizeof (*valueSet) 418 * (lastAlloc = GROUP_MEMBER_ALLOC)); 419 if (valueSet == NULL) { 420 ret = STMF_PS_ERROR_NOMEM; 421 goto out; 422 } 423 424 /* 425 * Iterate through the existing values 426 */ 427 while (scf_iter_next_value(valueIter, valueLookup) == 1) { 428 bzero(buf, sizeof (buf)); 429 if (scf_value_get_ustring(valueLookup, buf, MAXNAMELEN) == -1) { 430 syslog(LOG_ERR, "iter %s/%s value failed - %s", 431 pgName, groupName, scf_strerror(scf_error())); 432 ret = STMF_PS_ERROR; 433 break; 434 } 435 436 /* 437 * Check for existing 438 * If we're adding, it's an error 439 * If we're removing, we skip it and simply not 440 * add it to the set. Subtraction by omission. 441 */ 442 if ((strlen(buf) == strlen(memberName)) && 443 bcmp(buf, memberName, strlen(buf)) == 0) { 444 if (addRemoveFlag == ADD) { 445 ret = STMF_PS_ERROR_EXISTS; 446 break; 447 } else { 448 found = B_TRUE; 449 continue; 450 } 451 } 452 453 /* 454 * Create the value resource for this iteration 455 */ 456 valueSet[i] = scf_value_create(handle); 457 if (valueSet[i] == NULL) { 458 syslog(LOG_ERR, "scf value alloc for %s failed - %s", 459 pgName, scf_strerror(scf_error())); 460 ret = STMF_PS_ERROR; 461 break; 462 } 463 464 /* 465 * Set the value 466 */ 467 if (scf_value_set_ustring(valueSet[i], buf) == -1) { 468 syslog(LOG_ERR, "set value for %s/%s failed - %s", 469 pgName, groupName, scf_strerror(scf_error())); 470 ret = STMF_PS_ERROR; 471 break; 472 } 473 474 /* 475 * Now add the value 476 */ 477 if (scf_entry_add_value(entry, valueSet[i]) == -1) { 478 syslog(LOG_ERR, "add value for %s/%s failed - %s", 479 pgName, groupName, scf_strerror(scf_error())); 480 ret = STMF_PS_ERROR; 481 break; 482 } 483 484 i++; 485 486 /* 487 * realloc if we've hit the previous alloc size 488 */ 489 if (i >= lastAlloc) { 490 lastAlloc += GROUP_MEMBER_ALLOC; 491 valueSet = realloc(valueSet, 492 sizeof (*valueSet) * lastAlloc); 493 if (valueSet == NULL) { 494 ret = STMF_PS_ERROR; 495 break; 496 } 497 } 498 } 499 500 /* 501 * set valueArraySize to final allocated length 502 * so we can use it to destroy the resources correctly 503 */ 504 valueArraySize = i; 505 506 if (!found && (addRemoveFlag == REMOVE)) { 507 ret = STMF_PS_ERROR_MEMBER_NOT_FOUND; 508 } 509 510 if (ret != STMF_PS_SUCCESS) { 511 goto out; 512 } 513 514 /* 515 * If we're adding, we have one more step. Add the member to the 516 * propval list 517 */ 518 if (addRemoveFlag == ADD) { 519 /* 520 * Now create the new entry 521 */ 522 valueSet[i] = scf_value_create(handle); 523 if (valueSet[i] == NULL) { 524 syslog(LOG_ERR, "scf value alloc for %s/%s failed - %s", 525 pgName, groupName, scf_strerror(scf_error())); 526 ret = STMF_PS_ERROR; 527 goto out; 528 } else { 529 valueArraySize++; 530 } 531 532 /* 533 * Set the new member name 534 */ 535 if (scf_value_set_ustring(valueSet[i], memberName) == -1) { 536 syslog(LOG_ERR, "set value for %s/%s failed - %s", 537 pgName, groupName, scf_strerror(scf_error())); 538 ret = STMF_PS_ERROR; 539 goto out; 540 } 541 542 /* 543 * Add the new member 544 */ 545 if (scf_entry_add_value(entry, valueSet[i]) == -1) { 546 syslog(LOG_ERR, "add value for %s/%s failed - %s", 547 pgName, groupName, scf_strerror(scf_error())); 548 ret = STMF_PS_ERROR; 549 goto out; 550 } 551 } 552 553 /* 554 * Yes, we're finally done. We actually added or removed one entry 555 * from the list. 556 * Woohoo! 557 */ 558 if ((commitRet = scf_transaction_commit(tran)) != 1) { 559 syslog(LOG_ERR, "transaction commit for %s failed - %s", 560 pgName, scf_strerror(scf_error())); 561 if (commitRet == 0) { 562 ret = STMF_PS_ERROR_BUSY; 563 } else { 564 ret = STMF_PS_ERROR; 565 } 566 goto out; 567 } 568 569 out: 570 /* 571 * Free resources 572 */ 573 if (handle != NULL) { 574 scf_handle_destroy(handle); 575 } 576 if (svc != NULL) { 577 scf_service_destroy(svc); 578 } 579 if (pg != NULL) { 580 scf_pg_destroy(pg); 581 } 582 if (tran != NULL) { 583 scf_transaction_destroy(tran); 584 } 585 if (entry != NULL) { 586 scf_entry_destroy(entry); 587 } 588 if (prop != NULL) { 589 scf_property_destroy(prop); 590 } 591 if (valueLookup != NULL) { 592 scf_value_destroy(valueLookup); 593 } 594 if (valueIter != NULL) { 595 scf_iter_destroy(valueIter); 596 } 597 598 /* 599 * Free valueSet scf resources 600 */ 601 if (valueArraySize > 0) { 602 for (i = 0; i < valueArraySize; i++) { 603 scf_value_destroy(valueSet[i]); 604 } 605 } 606 /* 607 * Now free the pointer array to the resources 608 */ 609 if (valueSet != NULL) { 610 free(valueSet); 611 } 612 613 return (ret); 614 } 615 616 /* 617 * iPsAddRemoveLuViewEntry 618 * 619 * Adds or removes a view entry name property for a given logical unit 620 * property group. There is one logical unit property group for every logical 621 * unit that has one or more associated view entries. 622 * 623 * luPgName - Property group name of logical unit 624 * viewEntryPgName - Property group name of view entry 625 * addRemoveFlag - ADD_VE/REMOVE_VE 626 * 627 * returns: 628 * STMF_PS_SUCCESS on success 629 * STMF_PS_ERROR_* on failure 630 */ 631 static int 632 iPsAddRemoveLuViewEntry(char *luPgName, char *viewEntryPgName, 633 int addRemoveFlag) 634 { 635 scf_handle_t *handle = NULL; 636 scf_service_t *svc = NULL; 637 scf_propertygroup_t *pg = NULL; 638 scf_property_t *prop = NULL; 639 scf_value_t *value = NULL; 640 scf_transaction_t *tran = NULL; 641 scf_transaction_entry_t *entry = NULL; 642 scf_transaction_entry_t *entryVeName = NULL; 643 boolean_t createVeCnt = B_FALSE; 644 uint64_t veCnt = 0; 645 int ret = STMF_PS_SUCCESS; 646 int commitRet; 647 648 assert(luPgName != NULL || viewEntryPgName != NULL); 649 assert(!(addRemoveFlag != ADD && addRemoveFlag != REMOVE)); 650 651 /* 652 * Init the service handle 653 */ 654 ret = iPsInit(&handle, &svc); 655 if (ret != STMF_PS_SUCCESS) { 656 goto out; 657 } 658 659 /* 660 * Allocate scf resources 661 */ 662 if (((pg = scf_pg_create(handle)) == NULL) || 663 ((tran = scf_transaction_create(handle)) == NULL) || 664 ((entry = scf_entry_create(handle)) == NULL) || 665 ((prop = scf_property_create(handle)) == NULL) || 666 ((value = scf_value_create(handle)) == NULL)) { 667 syslog(LOG_ERR, "scf alloc resource failed - %s", 668 scf_strerror(scf_error())); 669 ret = STMF_PS_ERROR; 670 goto out; 671 } 672 673 /* get the LU property group */ 674 if (scf_service_get_pg(svc, luPgName, pg) == -1) { 675 if (scf_error() == SCF_ERROR_NOT_FOUND && 676 addRemoveFlag == ADD) { 677 /* if it doesn't exist, create it */ 678 if (scf_service_add_pg(svc, luPgName, 679 SCF_GROUP_APPLICATION, 0, pg) == -1) { 680 syslog(LOG_ERR, "add pg %s failed - %s", 681 luPgName, scf_strerror(scf_error())); 682 ret = STMF_PS_ERROR; 683 } else { 684 /* we need to create the VE_CNT property */ 685 createVeCnt = B_TRUE; 686 ret = STMF_PS_SUCCESS; 687 } 688 } else if (scf_error() == SCF_ERROR_NOT_FOUND) { 689 ret = STMF_PS_ERROR_NOT_FOUND; 690 } else { 691 syslog(LOG_ERR, "get lu pg %s failed - %s", 692 luPgName, scf_strerror(scf_error())); 693 ret = STMF_PS_ERROR; 694 } 695 if (ret != STMF_PS_SUCCESS) { 696 goto out; 697 } 698 } 699 700 701 /* 702 * Begin the transaction 703 */ 704 if (scf_transaction_start(tran, pg) == -1) { 705 syslog(LOG_ERR, "start transaction for %s failed - %s", 706 luPgName, scf_strerror(scf_error())); 707 ret = STMF_PS_ERROR; 708 goto out; 709 } 710 711 712 if (createVeCnt) { 713 /* 714 * Create the STMF_VE_CNT property. This will keep the current 715 * total view entries for this logical unit. 716 */ 717 if (scf_transaction_property_new(tran, entry, STMF_VE_CNT, 718 SCF_TYPE_COUNT) == -1) { 719 if (scf_error() == SCF_ERROR_EXISTS) { 720 ret = STMF_PS_ERROR_EXISTS; 721 } else { 722 syslog(LOG_ERR, 723 "transaction property new %s/%s " 724 "failed - %s", luPgName, STMF_VE_CNT, 725 scf_strerror(scf_error())); 726 ret = STMF_PS_ERROR; 727 } 728 goto out; 729 } 730 } else { 731 /* 732 * The STMF_VE_CNT property already exists. Just update 733 * it. 734 */ 735 if (scf_transaction_property_change(tran, entry, 736 STMF_VE_CNT, SCF_TYPE_COUNT) == -1) { 737 syslog(LOG_ERR, "transaction property %s/%s change " 738 "failed - %s", luPgName, STMF_VE_CNT, 739 scf_strerror(scf_error())); 740 ret = STMF_PS_ERROR; 741 goto out; 742 } 743 744 /* 745 * Get the STMF_VE_CNT property 746 */ 747 if (scf_pg_get_property(pg, STMF_VE_CNT, prop) == -1) { 748 syslog(LOG_ERR, "get property %s/%s failed - %s", 749 luPgName, STMF_VE_CNT, scf_strerror(scf_error())); 750 ret = STMF_PS_ERROR; 751 goto out; 752 } 753 754 /* 755 * Get the STMF_VE_CNT value 756 */ 757 if (scf_property_get_value(prop, value) == -1) { 758 syslog(LOG_ERR, "get property %s/%s value failed - %s", 759 luPgName, STMF_VE_CNT, scf_strerror(scf_error())); 760 ret = STMF_PS_ERROR; 761 goto out; 762 } 763 764 /* 765 * Now get the actual value from the value handle 766 */ 767 if (scf_value_get_count(value, &veCnt) == -1) { 768 syslog(LOG_ERR, "get count value %s/%s failed - %s", 769 luPgName, STMF_VE_CNT, scf_strerror(scf_error())); 770 ret = STMF_PS_ERROR; 771 goto out; 772 } 773 774 /* 775 * Reset the value resource as it is used below 776 */ 777 scf_value_reset(value); 778 } 779 780 if (addRemoveFlag == ADD) { 781 veCnt++; 782 } else { 783 /* Check if this is the last one being removed */ 784 if (veCnt == 1) { 785 /* 786 * Delete the pg and get out if this is the last 787 * view entry 788 */ 789 if (scf_pg_delete(pg) == -1) { 790 syslog(LOG_ERR, "delete pg %s failed - %s", 791 luPgName, scf_strerror(scf_error())); 792 793 ret = STMF_PS_ERROR; 794 } 795 goto out; 796 } else { 797 veCnt--; 798 } 799 } 800 801 802 /* 803 * Set the view entry count 804 */ 805 scf_value_set_count(value, veCnt); 806 807 /* 808 * Add the value to the transaction entry 809 */ 810 if (scf_entry_add_value(entry, value) == -1) { 811 syslog(LOG_ERR, "add value %s/%s failed - %s", 812 luPgName, STMF_VE_CNT, scf_strerror(scf_error())); 813 ret = STMF_PS_ERROR; 814 goto out; 815 } 816 817 /* 818 * Create a transaction entry resource for the view entry name 819 */ 820 entryVeName = scf_entry_create(handle); 821 if (entryVeName == NULL) { 822 syslog(LOG_ERR, "scf transaction entry alloc %s/%s failed - %s", 823 luPgName, viewEntryPgName, scf_strerror(scf_error())); 824 ret = STMF_PS_ERROR; 825 goto out; 826 } 827 828 if (addRemoveFlag == ADD) { 829 /* 830 * If adding, create a property with the view entry name 831 */ 832 if (scf_transaction_property_new(tran, entryVeName, 833 viewEntryPgName, SCF_TYPE_USTRING) == -1) { 834 if (scf_error() == SCF_ERROR_EXISTS) { 835 ret = STMF_PS_ERROR_EXISTS; 836 } else { 837 syslog(LOG_ERR, 838 "transaction property new %s/%s " 839 "failed - %s", luPgName, viewEntryPgName, 840 scf_strerror(scf_error())); 841 ret = STMF_PS_ERROR; 842 } 843 goto out; 844 } 845 } else { 846 /* 847 * If removing, delete the existing property with the view 848 * entry name 849 */ 850 if (scf_transaction_property_delete(tran, entryVeName, 851 viewEntryPgName) == -1) { 852 if (scf_error() == SCF_ERROR_NOT_FOUND) { 853 ret = STMF_PS_ERROR_NOT_FOUND; 854 } else { 855 syslog(LOG_ERR, 856 "transaction property delete %s/%s " 857 "failed - %s", luPgName, viewEntryPgName, 858 scf_strerror(scf_error())); 859 ret = STMF_PS_ERROR; 860 } 861 goto out; 862 } 863 } 864 865 /* 866 * Commit property transaction 867 */ 868 if ((commitRet = scf_transaction_commit(tran)) != 1) { 869 syslog(LOG_ERR, "transaction commit for %s failed - %s", 870 luPgName, scf_strerror(scf_error())); 871 if (commitRet == 0) { 872 ret = STMF_PS_ERROR_BUSY; 873 } else { 874 ret = STMF_PS_ERROR; 875 } 876 goto out; 877 } 878 879 out: 880 /* 881 * Free resources 882 */ 883 if (handle != NULL) { 884 scf_handle_destroy(handle); 885 } 886 if (svc != NULL) { 887 scf_service_destroy(svc); 888 } 889 if (pg != NULL) { 890 scf_pg_destroy(pg); 891 } 892 if (tran != NULL) { 893 scf_transaction_destroy(tran); 894 } 895 if (entry != NULL) { 896 scf_entry_destroy(entry); 897 } 898 if (entryVeName != NULL) { 899 scf_entry_destroy(entryVeName); 900 } 901 if (prop != NULL) { 902 scf_property_destroy(prop); 903 } 904 if (value != NULL) { 905 scf_value_destroy(value); 906 } 907 908 return (ret); 909 } 910 911 /* 912 * iPsAddViewEntry 913 * 914 * Add a view entry property group and optionally, a logical unit property 915 * group if it does not exist. 916 * 917 * luName - ascii hexadecimal logical unit identifier 918 * viewEntryName - name of view entry (VIEW_ENTRY_nn) 919 * viewEntry - pointer to stmfViewEntry structure 920 */ 921 static int 922 iPsAddViewEntry(char *luPgName, char *viewEntryPgName, stmfViewEntry *viewEntry) 923 { 924 scf_handle_t *handle = NULL; 925 scf_service_t *svc = NULL; 926 scf_propertygroup_t *pg = NULL; 927 scf_value_t *value[VIEW_ENTRY_STRUCT_CNT]; 928 scf_transaction_t *tran = NULL; 929 scf_transaction_entry_t *entry[VIEW_ENTRY_STRUCT_CNT]; 930 int i = 0; 931 int j = 0; 932 int ret; 933 uint8_t scfBool; 934 boolean_t createdVePg = B_FALSE; 935 int backoutRet; 936 int commitRet; 937 938 assert(luPgName != NULL || viewEntryPgName != NULL || 939 viewEntry == NULL); 940 941 bzero(value, sizeof (value)); 942 bzero(entry, sizeof (entry)); 943 944 /* 945 * Init the service handle 946 */ 947 ret = iPsInit(&handle, &svc); 948 if (ret != STMF_PS_SUCCESS) { 949 goto out; 950 } 951 952 /* 953 * Allocate scf resources 954 */ 955 if (((pg = scf_pg_create(handle)) == NULL) || 956 ((tran = scf_transaction_create(handle)) == NULL)) { 957 syslog(LOG_ERR, "scf alloc resource failed - %s", 958 scf_strerror(scf_error())); 959 ret = STMF_PS_ERROR; 960 goto out; 961 } 962 963 /* 964 * allocate value and entry resources for scf 965 */ 966 for (i = 0; i < VIEW_ENTRY_STRUCT_CNT; i++) { 967 if (((value[i] = scf_value_create(handle)) == NULL) || 968 ((entry[i] = scf_entry_create(handle)) == NULL)) { 969 syslog(LOG_ERR, "scf alloc resource failed - %s", 970 scf_strerror(scf_error())); 971 ret = STMF_PS_ERROR; 972 goto out; 973 } 974 } 975 976 i = 0; 977 978 /* 979 * Create the View Entry property group 980 */ 981 if (scf_service_add_pg(svc, viewEntryPgName, SCF_GROUP_APPLICATION, 982 0, pg) == -1) { 983 if (scf_error() == SCF_ERROR_EXISTS) { 984 ret = STMF_PS_ERROR_EXISTS; 985 } else { 986 syslog(LOG_ERR, "add pg %s failed - %s", 987 viewEntryPgName, scf_strerror(scf_error())); 988 ret = STMF_PS_ERROR; 989 } 990 goto out; 991 } 992 993 createdVePg = B_TRUE; 994 995 /* 996 * Add the view entry as properties on the view entry group 997 */ 998 999 /* 1000 * Begin property update transaction 1001 */ 1002 if (scf_transaction_start(tran, pg) == -1) { 1003 syslog(LOG_ERR, "start transaction for add %s failed - %s", 1004 viewEntryPgName, scf_strerror(scf_error())); 1005 ret = STMF_PS_ERROR; 1006 goto out; 1007 } 1008 1009 /* 1010 * Add allHosts property 1011 */ 1012 if (scf_transaction_property_new(tran, entry[i], 1013 STMF_VE_ALLHOSTS, SCF_TYPE_BOOLEAN) == -1) { 1014 if (scf_error() == SCF_ERROR_EXISTS) { 1015 ret = STMF_PS_ERROR_EXISTS; 1016 } else { 1017 syslog(LOG_ERR, "transaction property new %s/%s " 1018 "failed - %s", viewEntryPgName, STMF_VE_ALLHOSTS, 1019 scf_strerror(scf_error())); 1020 ret = STMF_PS_ERROR; 1021 } 1022 goto out; 1023 } 1024 1025 /* Set the allHosts value */ 1026 scfBool = viewEntry->allHosts; 1027 scf_value_set_boolean(value[i], scfBool); 1028 1029 /* 1030 * Add the allHosts value to the transaction 1031 */ 1032 if (scf_entry_add_value(entry[i], value[i]) == -1) { 1033 syslog(LOG_ERR, "add value %s/%s failed - %s", 1034 viewEntryPgName, STMF_VE_ALLHOSTS, 1035 scf_strerror(scf_error())); 1036 ret = STMF_PS_ERROR; 1037 goto out; 1038 } 1039 1040 i++; 1041 1042 /* 1043 * Create hostGroup property 1044 */ 1045 if (scf_transaction_property_new(tran, entry[i], 1046 STMF_VE_HOSTGROUP, SCF_TYPE_USTRING) == -1) { 1047 if (scf_error() == SCF_ERROR_EXISTS) { 1048 ret = STMF_PS_ERROR_EXISTS; 1049 } else { 1050 syslog(LOG_ERR, "transaction property new %s/%s " 1051 "failed - %s", viewEntryPgName, STMF_VE_HOSTGROUP, 1052 scf_strerror(scf_error())); 1053 ret = STMF_PS_ERROR; 1054 } 1055 goto out; 1056 } 1057 1058 /* 1059 * Set the value for hostGroup 1060 */ 1061 if (scf_value_set_ustring(value[i], viewEntry->hostGroup) == -1) { 1062 syslog(LOG_ERR, "set value %s/%s failed - %s", 1063 viewEntryPgName, STMF_VE_HOSTGROUP, 1064 scf_strerror(scf_error())); 1065 ret = STMF_PS_ERROR; 1066 goto out; 1067 } 1068 1069 /* 1070 * Add the hostGroup value to the transaction entry 1071 */ 1072 if (scf_entry_add_value(entry[i], value[i]) == -1) { 1073 syslog(LOG_ERR, "add value %s/%s failed - %s", 1074 viewEntryPgName, STMF_VE_HOSTGROUP, 1075 scf_strerror(scf_error())); 1076 ret = STMF_PS_ERROR; 1077 goto out; 1078 } 1079 1080 i++; 1081 1082 /* 1083 * Create the allTargets property 1084 */ 1085 if (scf_transaction_property_new(tran, entry[i], 1086 STMF_VE_ALLTARGETS, SCF_TYPE_BOOLEAN) == -1) { 1087 if (scf_error() == SCF_ERROR_EXISTS) { 1088 ret = STMF_PS_ERROR_EXISTS; 1089 } else { 1090 syslog(LOG_ERR, "transaction property new %s/%s " 1091 "failed - %s", viewEntryPgName, STMF_VE_ALLTARGETS, 1092 scf_strerror(scf_error())); 1093 ret = STMF_PS_ERROR; 1094 } 1095 goto out; 1096 } 1097 1098 /* 1099 * Set the allTargets value 1100 */ 1101 scfBool = viewEntry->allTargets; 1102 scf_value_set_boolean(value[i], scfBool); 1103 1104 /* 1105 * Add the allTargets value to the transaction 1106 */ 1107 if (scf_entry_add_value(entry[i], value[i]) == -1) { 1108 syslog(LOG_ERR, "add value %s/%s failed - %s", 1109 viewEntryPgName, STMF_VE_ALLTARGETS, 1110 scf_strerror(scf_error())); 1111 ret = STMF_PS_ERROR; 1112 goto out; 1113 } 1114 1115 i++; 1116 1117 /* 1118 * Create targetGroup property 1119 */ 1120 if (scf_transaction_property_new(tran, entry[i], 1121 STMF_VE_TARGETGROUP, SCF_TYPE_USTRING) == -1) { 1122 if (scf_error() == SCF_ERROR_EXISTS) { 1123 ret = STMF_PS_ERROR_EXISTS; 1124 } else { 1125 syslog(LOG_ERR, "transaction property new %s/%s " 1126 "failed - %s", viewEntryPgName, 1127 STMF_VE_TARGETGROUP, scf_strerror(scf_error())); 1128 ret = STMF_PS_ERROR; 1129 } 1130 goto out; 1131 } 1132 1133 /* 1134 * Set the value for targetGroup 1135 */ 1136 if (scf_value_set_ustring(value[i], viewEntry->targetGroup) == -1) { 1137 syslog(LOG_ERR, "set value %s/%s failed - %s", 1138 viewEntryPgName, STMF_VE_TARGETGROUP, 1139 scf_strerror(scf_error())); 1140 ret = STMF_PS_ERROR; 1141 goto out; 1142 } 1143 1144 /* 1145 * Add targetGroup value to the transaction 1146 */ 1147 if (scf_entry_add_value(entry[i], value[i]) == -1) { 1148 syslog(LOG_ERR, "add value %s/%s failed - %s", 1149 viewEntryPgName, STMF_VE_TARGETGROUP, 1150 scf_strerror(scf_error())); 1151 ret = STMF_PS_ERROR; 1152 goto out; 1153 } 1154 1155 i++; 1156 1157 /* 1158 * Create the luNbr property 1159 */ 1160 if (scf_transaction_property_new(tran, entry[i], STMF_VE_LUNBR, 1161 SCF_TYPE_OPAQUE) == -1) { 1162 if (scf_error() == SCF_ERROR_EXISTS) { 1163 ret = STMF_PS_ERROR_EXISTS; 1164 } else { 1165 syslog(LOG_ERR, "transaction property new %s/%s " 1166 "failed - %s", viewEntryPgName, STMF_VE_LUNBR, 1167 scf_strerror(scf_error())); 1168 ret = STMF_PS_ERROR; 1169 } 1170 goto out; 1171 } 1172 1173 /* 1174 * Set the luNbr 1175 */ 1176 if (scf_value_set_opaque(value[i], (char *)viewEntry->luNbr, 1177 sizeof (viewEntry->luNbr)) == -1) { 1178 syslog(LOG_ERR, "set value %s/%s failed - %s", 1179 viewEntryPgName, STMF_VE_LUNBR, scf_strerror(scf_error())); 1180 ret = STMF_PS_ERROR; 1181 goto out; 1182 } 1183 1184 /* 1185 * Add luNbr to the transaction entry 1186 */ 1187 if (scf_entry_add_value(entry[i], value[i]) == -1) { 1188 syslog(LOG_ERR, "add value %s/%s failed - %s", 1189 viewEntryPgName, STMF_VE_LUNBR, scf_strerror(scf_error())); 1190 ret = STMF_PS_ERROR; 1191 goto out; 1192 } 1193 1194 /* 1195 * Now that we've successfully added the view entry, 1196 * update the logical unit property group or create 1197 * it if it does not exist 1198 */ 1199 ret = iPsAddRemoveLuViewEntry(luPgName, viewEntryPgName, ADD); 1200 1201 /* 1202 * If we did not add the view entry name to the logical unit, 1203 * make sure we do not commit the transaction 1204 */ 1205 if (ret != STMF_PS_SUCCESS) { 1206 goto out; 1207 } 1208 1209 /* 1210 * Commit property transaction 1211 */ 1212 if ((commitRet = scf_transaction_commit(tran)) != 1) { 1213 syslog(LOG_ERR, "transaction commit for add %s failed - %s", 1214 viewEntryPgName, scf_strerror(scf_error())); 1215 if (commitRet == 0) { 1216 ret = STMF_PS_ERROR_BUSY; 1217 } else { 1218 ret = STMF_PS_ERROR; 1219 } 1220 } 1221 1222 if (ret != STMF_PS_SUCCESS) { 1223 /* 1224 * If we did not commit, try to remove the view entry name 1225 * from the logical unit. 1226 * If that fails, we're now inconsistent. 1227 */ 1228 backoutRet = iPsAddRemoveLuViewEntry(luPgName, viewEntryPgName, 1229 REMOVE); 1230 1231 if (backoutRet != STMF_PS_SUCCESS) { 1232 syslog(LOG_ERR, "remove lu view entry %s failed" 1233 "possible inconsistency - %s", luPgName, 1234 scf_strerror(scf_error())); 1235 } 1236 /* 1237 * We are still in an error scenario even though the remove 1238 * lu view entry succeeded. 1239 */ 1240 goto out; 1241 } 1242 1243 out: 1244 /* 1245 * Free resources 1246 */ 1247 if (handle != NULL) { 1248 scf_handle_destroy(handle); 1249 } 1250 if (svc != NULL) { 1251 scf_service_destroy(svc); 1252 } 1253 /* if there was an error, delete the created pg if one was created */ 1254 if ((ret != STMF_PS_SUCCESS) && createdVePg) { 1255 if (scf_pg_delete(pg) == -1) { 1256 syslog(LOG_ERR, "delete VE pg %s failed - %s", 1257 viewEntryPgName, scf_strerror(scf_error())); 1258 } 1259 } 1260 if (pg != NULL) { 1261 scf_pg_destroy(pg); 1262 } 1263 if (tran != NULL) { 1264 scf_transaction_destroy(tran); 1265 } 1266 /* 1267 * Free value and entry scf resources 1268 */ 1269 if (i > 0) { 1270 for (j = 0; j < VIEW_ENTRY_STRUCT_CNT; j++) { 1271 if (value[j] != NULL) 1272 scf_value_destroy(value[j]); 1273 if (entry[j] != NULL) 1274 scf_entry_destroy(entry[j]); 1275 } 1276 } 1277 1278 return (ret); 1279 } 1280 /* 1281 * psClearProviderData 1282 * 1283 * providerName - name of provider data to clear 1284 */ 1285 int 1286 psClearProviderData(char *providerName, int providerType) 1287 { 1288 scf_handle_t *handle = NULL; 1289 scf_service_t *svc = NULL; 1290 scf_propertygroup_t *pg = NULL; 1291 char pgName[MAXPATHLEN]; 1292 int ret = STMF_PS_SUCCESS; 1293 boolean_t pgNotFound = B_FALSE; 1294 1295 if (providerName == NULL || (providerType != STMF_LU_PROVIDER_TYPE && 1296 providerType != STMF_PORT_PROVIDER_TYPE)) { 1297 ret = STMF_PS_ERROR_INVALID_ARG; 1298 goto out; 1299 } 1300 1301 ret = iPsInit(&handle, &svc); 1302 if (ret != STMF_PS_SUCCESS) { 1303 goto out; 1304 } 1305 1306 /* 1307 * Allocate scf resources 1308 */ 1309 if ((pg = scf_pg_create(handle)) == NULL) { 1310 syslog(LOG_ERR, "scf alloc resource failed - %s", 1311 scf_strerror(scf_error())); 1312 ret = STMF_PS_ERROR; 1313 goto out; 1314 } 1315 1316 /* 1317 * create the property group name 1318 */ 1319 (void) snprintf(pgName, sizeof (pgName), "%s%s", 1320 STMF_PROVIDER_DATA_PREFIX, providerName); 1321 1322 /* 1323 * delete provider property group 1324 */ 1325 if (scf_service_get_pg(svc, pgName, pg) == -1) { 1326 if (scf_error() != SCF_ERROR_NOT_FOUND) { 1327 syslog(LOG_ERR, "get pg %s failed - %s", 1328 pgName, scf_strerror(scf_error())); 1329 ret = STMF_PS_ERROR; 1330 goto out; 1331 } else { 1332 pgNotFound = B_TRUE; 1333 } 1334 } 1335 1336 if (!pgNotFound && (scf_pg_delete(pg) == -1)) { 1337 syslog(LOG_ERR, "delete pg %s failed - %s", 1338 pgName, scf_strerror(scf_error())); 1339 ret = STMF_PS_ERROR; 1340 goto out; 1341 } 1342 1343 if (pgNotFound) { 1344 ret = STMF_PS_ERROR_NOT_FOUND; 1345 } 1346 1347 out: 1348 /* 1349 * Free resources 1350 */ 1351 if (handle != NULL) { 1352 scf_handle_destroy(handle); 1353 } 1354 if (svc != NULL) { 1355 scf_service_destroy(svc); 1356 } 1357 if (pg != NULL) { 1358 scf_pg_destroy(pg); 1359 } 1360 1361 return (ret); 1362 } 1363 1364 /* 1365 * iPsCreateDeleteGroup 1366 * 1367 * Creates or deletes a group (target or host) 1368 * 1369 * When creating a group, two properties are created. One to hold the group 1370 * name and the other to hold the group members. 1371 * 1372 * pgName - Property group name 1373 * groupName - group name to create 1374 * addRemoveFlag - ADD_GROUP/REMOVE_GROUP 1375 * 1376 * returns: 1377 * STMF_PS_SUCCESS on success 1378 * STMF_PS_ERROR_* on failure 1379 */ 1380 static int 1381 iPsCreateDeleteGroup(char *pgRefName, char *groupName, int addRemoveFlag) 1382 { 1383 scf_handle_t *handle = NULL; 1384 scf_service_t *svc = NULL; 1385 scf_propertygroup_t *pg = NULL; 1386 scf_property_t *prop = NULL; 1387 scf_iter_t *propIter = NULL; 1388 scf_transaction_t *tran = NULL; 1389 scf_transaction_entry_t *entry1 = NULL; 1390 scf_transaction_entry_t *entry2 = NULL; 1391 scf_value_t *value = NULL; 1392 uint64_t groupIdx; 1393 char buf1[MAXNAMELEN]; 1394 char buf2[MAXNAMELEN]; 1395 char tmpbuf[MAXNAMELEN]; 1396 boolean_t found = B_FALSE; 1397 int ret = STMF_PS_SUCCESS; 1398 int commitRet; 1399 1400 assert(groupName != NULL); 1401 1402 ret = iPsInit(&handle, &svc); 1403 if (ret != STMF_PS_SUCCESS) { 1404 goto out; 1405 } 1406 1407 /* 1408 * Allocate scf resources 1409 */ 1410 if (((pg = scf_pg_create(handle)) == NULL) || 1411 ((tran = scf_transaction_create(handle)) == NULL) || 1412 ((entry1 = scf_entry_create(handle)) == NULL) || 1413 ((entry2 = scf_entry_create(handle)) == NULL) || 1414 ((prop = scf_property_create(handle)) == NULL) || 1415 ((propIter = scf_iter_create(handle)) == NULL) || 1416 ((value = scf_value_create(handle)) == NULL)) { 1417 syslog(LOG_ERR, "scf alloc resource failed - %s", 1418 scf_strerror(scf_error())); 1419 ret = STMF_PS_ERROR; 1420 goto out; 1421 } 1422 1423 /* 1424 * Get the property group being modified 1425 */ 1426 if (scf_service_get_pg(svc, pgRefName, pg) == -1) { 1427 if (scf_error() == SCF_ERROR_NOT_FOUND && 1428 addRemoveFlag == ADD) { 1429 if (scf_service_add_pg(svc, pgRefName, 1430 SCF_GROUP_APPLICATION, 0, pg) == -1) { 1431 syslog(LOG_ERR, "add pg %s failed - %s", 1432 pgRefName, scf_strerror(scf_error())); 1433 ret = STMF_PS_ERROR; 1434 } 1435 } else if (scf_error() == SCF_ERROR_NOT_FOUND) { 1436 syslog(LOG_ERR, "get pg %s failed - %s", 1437 pgRefName, scf_strerror(scf_error())); 1438 ret = STMF_PS_ERROR_NOT_FOUND; 1439 } else { 1440 syslog(LOG_ERR, "get pg %s failed - %s", 1441 pgRefName, scf_strerror(scf_error())); 1442 ret = STMF_PS_ERROR; 1443 } 1444 if (ret != STMF_PS_SUCCESS) { 1445 goto out; 1446 } 1447 } 1448 1449 /* 1450 * propIter is the iterator handle 1451 */ 1452 if (scf_iter_pg_properties(propIter, pg) == -1) { 1453 syslog(LOG_ERR, "iter properties for %s failed - %s", 1454 pgRefName, scf_strerror(scf_error())); 1455 ret = STMF_PS_ERROR; 1456 goto out; 1457 } 1458 1459 /* 1460 * Iterate through the group names. 1461 * If we find it in the list, it's an error when addRemoveFlag == ADD. 1462 */ 1463 while (scf_iter_next_property(propIter, prop) == 1) { 1464 if (scf_property_get_name(prop, buf1, sizeof (buf1)) == -1) { 1465 syslog(LOG_ERR, "get name from %s iter failed - %s", 1466 pgRefName, scf_strerror(scf_error())); 1467 ret = STMF_PS_ERROR; 1468 break; 1469 } 1470 /* 1471 * Skip over member list properties 1472 */ 1473 if (strstr(buf1, STMF_MEMBER_LIST_SUFFIX)) { 1474 continue; 1475 } 1476 if (scf_property_get_value(prop, value) == -1) { 1477 syslog(LOG_ERR, "get property value %s/%s failed - %s", 1478 pgRefName, buf1, scf_strerror(scf_error())); 1479 ret = STMF_PS_ERROR; 1480 break; 1481 } 1482 if (scf_value_get_ustring(value, tmpbuf, 1483 sizeof (tmpbuf)) == -1) { 1484 syslog(LOG_ERR, "get ustring %s/%s failed - %s", 1485 pgRefName, buf1, scf_strerror(scf_error())); 1486 ret = STMF_PS_ERROR; 1487 break; 1488 } 1489 1490 if ((strlen(tmpbuf) == strlen(groupName)) && 1491 bcmp(tmpbuf, groupName, strlen(tmpbuf)) == 0) { 1492 if (addRemoveFlag == ADD) { 1493 ret = STMF_PS_ERROR_EXISTS; 1494 } 1495 found = B_TRUE; 1496 /* 1497 * buf1 contains the name for REMOVE 1498 */ 1499 break; 1500 } 1501 } 1502 1503 if (ret != STMF_PS_SUCCESS) { 1504 goto out; 1505 } 1506 1507 scf_value_reset(value); 1508 1509 if (!found && addRemoveFlag == REMOVE) { 1510 ret = STMF_PS_ERROR_NOT_FOUND; 1511 goto out; 1512 } 1513 1514 /* 1515 * If we're adding, we need to create a new property name for the 1516 * new group 1517 */ 1518 if (addRemoveFlag == ADD) { 1519 for (groupIdx = 0; groupIdx < GROUP_MAX; groupIdx++) { 1520 if (snprintf(buf1, sizeof (buf1), "%s-%lld", 1521 STMF_GROUP_PREFIX, groupIdx) > sizeof (buf1)) { 1522 syslog(LOG_ERR, 1523 "buffer overflow on property name %s", 1524 buf1); 1525 ret = STMF_PS_ERROR; 1526 break; 1527 } 1528 if (scf_pg_get_property(pg, buf1, prop) == -1) { 1529 if (scf_error() != SCF_ERROR_NOT_FOUND) { 1530 syslog(LOG_ERR, "get property %s/%s " 1531 "failed - %s", pgRefName, buf1, 1532 scf_strerror(scf_error())); 1533 ret = STMF_PS_ERROR; 1534 } 1535 break; 1536 } 1537 } 1538 } 1539 1540 /* 1541 * Now create the new member list property for the new group 1542 */ 1543 if (snprintf(buf2, sizeof (buf2), "%s-%s", buf1, 1544 STMF_MEMBER_LIST_SUFFIX) > sizeof (buf2)) { 1545 syslog(LOG_ERR, "buffer overflow on property name %s", 1546 buf1); 1547 ret = STMF_PS_ERROR; 1548 goto out; 1549 } 1550 1551 /* 1552 * buf1 now contains the name of the property if it was found in the 1553 * list in the case of delete or the next available property name 1554 * in the case of create 1555 * 1556 * buf2 now contains the member list property name 1557 */ 1558 if (scf_transaction_start(tran, pg) == -1) { 1559 syslog(LOG_ERR, "start transaction for %s failed - %s", 1560 pgRefName, scf_strerror(scf_error())); 1561 ret = STMF_PS_ERROR; 1562 goto out; 1563 } 1564 1565 if (addRemoveFlag == ADD) { 1566 /* 1567 * Create the property 'group name' 1568 * This is the container for the group name 1569 */ 1570 if (scf_transaction_property_new(tran, entry1, buf1, 1571 SCF_TYPE_USTRING) == -1) { 1572 syslog(LOG_ERR, "transaction property new %s/%s " 1573 "failed - %s", pgRefName, buf1, 1574 scf_strerror(scf_error())); 1575 ret = STMF_PS_ERROR; 1576 goto out; 1577 } 1578 if (scf_value_set_ustring(value, groupName) == -1) { 1579 syslog(LOG_ERR, "set ustring %s/%s failed - %s", 1580 pgRefName, buf1, scf_strerror(scf_error())); 1581 ret = STMF_PS_ERROR; 1582 goto out; 1583 } 1584 if (scf_entry_add_value(entry1, value) == -1) { 1585 syslog(LOG_ERR, "add value %s/%s failed - %s", 1586 pgRefName, buf1, scf_strerror(scf_error())); 1587 ret = STMF_PS_ERROR; 1588 goto out; 1589 } 1590 /* 1591 * Create the property 'group list' 1592 * This is the container for the group members 1593 */ 1594 if (scf_transaction_property_new(tran, entry2, buf2, 1595 SCF_TYPE_USTRING) == -1) { 1596 syslog(LOG_ERR, "transaction property new %s/%s " 1597 "failed - %s", pgRefName, buf2, 1598 scf_strerror(scf_error())); 1599 ret = STMF_PS_ERROR; 1600 goto out; 1601 } 1602 } else { 1603 /* 1604 * Delete the property 'group name' 1605 */ 1606 if (scf_transaction_property_delete(tran, entry1, buf1) 1607 == -1) { 1608 syslog(LOG_ERR, 1609 "transaction property delete %s/%s failed - %s", 1610 pgRefName, buf1, scf_strerror(scf_error())); 1611 ret = STMF_PS_ERROR; 1612 goto out; 1613 } 1614 /* 1615 * Delete the property 'group list' 1616 */ 1617 if (scf_transaction_property_delete(tran, entry2, buf2) 1618 == -1) { 1619 syslog(LOG_ERR, "transaction property delete %s/%s " 1620 "failed - %s", pgRefName, buf2, 1621 scf_strerror(scf_error())); 1622 ret = STMF_PS_ERROR; 1623 goto out; 1624 } 1625 } 1626 1627 if (ret != STMF_PS_SUCCESS) { 1628 goto out; 1629 } 1630 1631 if ((commitRet = scf_transaction_commit(tran)) != 1) { 1632 syslog(LOG_ERR, "transaction commit for %s failed - %s", 1633 pgRefName, scf_strerror(scf_error())); 1634 if (commitRet == 0) { 1635 ret = STMF_PS_ERROR_BUSY; 1636 } else { 1637 ret = STMF_PS_ERROR; 1638 } 1639 } 1640 1641 out: 1642 /* 1643 * Free resources 1644 */ 1645 if (handle != NULL) { 1646 scf_handle_destroy(handle); 1647 } 1648 if (svc != NULL) { 1649 scf_service_destroy(svc); 1650 } 1651 if (pg != NULL) { 1652 scf_pg_destroy(pg); 1653 } 1654 if (tran != NULL) { 1655 scf_transaction_destroy(tran); 1656 } 1657 if (entry1 != NULL) { 1658 scf_entry_destroy(entry1); 1659 } 1660 if (entry2 != NULL) { 1661 scf_entry_destroy(entry2); 1662 } 1663 if (prop != NULL) { 1664 scf_property_destroy(prop); 1665 } 1666 if (propIter != NULL) { 1667 scf_iter_destroy(propIter); 1668 } 1669 if (value != NULL) { 1670 scf_value_destroy(value); 1671 } 1672 1673 return (ret); 1674 } 1675 1676 /* 1677 * iPsGetGroupList 1678 * 1679 * pgName - Property group name 1680 * groupList - pointer to pointer to stmfGroupList structure. On success, 1681 * contains the list of groups 1682 * 1683 * returns: 1684 * STMF_PS_SUCCESS on success 1685 * STMF_PS_ERROR_* on failure 1686 */ 1687 static int 1688 iPsGetGroupList(char *pgName, stmfGroupList **groupList) 1689 { 1690 scf_handle_t *handle = NULL; 1691 scf_service_t *svc = NULL; 1692 scf_propertygroup_t *pg = NULL; 1693 scf_property_t *prop = NULL; 1694 scf_iter_t *propIter = NULL; 1695 scf_value_t *value = NULL; 1696 char buf[MAXNAMELEN]; 1697 int memberCnt = 0; 1698 int i = 0; 1699 int ret = STMF_PS_SUCCESS; 1700 1701 assert(groupList != NULL); 1702 1703 ret = iPsInit(&handle, &svc); 1704 if (ret != STMF_PS_SUCCESS) { 1705 goto out; 1706 } 1707 1708 /* 1709 * Allocate scf resources 1710 */ 1711 if (((pg = scf_pg_create(handle)) == NULL) || 1712 ((prop = scf_property_create(handle)) == NULL) || 1713 ((propIter = scf_iter_create(handle)) == NULL) || 1714 ((value = scf_value_create(handle)) == NULL)) { 1715 syslog(LOG_ERR, "scf alloc resource failed - %s", 1716 scf_strerror(scf_error())); 1717 ret = STMF_PS_ERROR; 1718 goto out; 1719 } 1720 1721 if (scf_service_get_pg(svc, pgName, pg) == -1) { 1722 if (scf_error() == SCF_ERROR_NOT_FOUND) { 1723 syslog(LOG_ERR, "get pg %s failed - %s", 1724 pgName, scf_strerror(scf_error())); 1725 ret = STMF_PS_ERROR_NOT_FOUND; 1726 } else { 1727 syslog(LOG_ERR, "get pg %s failed - %s", 1728 pgName, scf_strerror(scf_error())); 1729 ret = STMF_PS_ERROR; 1730 } 1731 goto out; 1732 } 1733 1734 /* 1735 * propIter is the iterator handle 1736 */ 1737 if (scf_iter_pg_properties(propIter, pg) == -1) { 1738 syslog(LOG_ERR, "iter properties for %s failed - %s", 1739 pgName, scf_strerror(scf_error())); 1740 ret = STMF_PS_ERROR; 1741 goto out; 1742 } 1743 1744 while (scf_iter_next_property(propIter, prop) == 1) { 1745 if (scf_property_get_name(prop, buf, sizeof (buf)) == -1) { 1746 syslog(LOG_ERR, "get name from %s iter failed - %s", 1747 pgName, scf_strerror(scf_error())); 1748 ret = STMF_PS_ERROR; 1749 break; 1750 } 1751 /* 1752 * Skip over member list properties 1753 */ 1754 if (strstr(buf, STMF_MEMBER_LIST_SUFFIX)) { 1755 continue; 1756 } 1757 memberCnt++; 1758 } 1759 1760 /* 1761 * propIter is the iterator handle 1762 */ 1763 if (scf_iter_pg_properties(propIter, pg) == -1) { 1764 syslog(LOG_ERR, "iter properties for %s failed - %s", 1765 pgName, scf_strerror(scf_error())); 1766 ret = STMF_PS_ERROR; 1767 goto out; 1768 } 1769 1770 *groupList = (stmfGroupList *)calloc(1, sizeof (stmfGroupList) + 1771 memberCnt * sizeof (stmfGroupName)); 1772 1773 if (*groupList == NULL) { 1774 ret = STMF_PS_ERROR_NOMEM; 1775 goto out; 1776 } 1777 1778 /* 1779 * In order to get a list of groups, simply get all of the 1780 * properties that are not member list properties, i.e. the group 1781 * name properties. 1782 * It's possible for this list to grow beyond what was originally 1783 * read so just ensure we're not writing beyond our allocated buffer 1784 * by ensuring i < memberCnt 1785 */ 1786 while ((scf_iter_next_property(propIter, prop) == 1) && 1787 (i < memberCnt)) { 1788 if (scf_property_get_name(prop, buf, sizeof (buf)) == -1) { 1789 syslog(LOG_ERR, "get name from %s iter failed - %s", 1790 pgName, scf_strerror(scf_error())); 1791 ret = STMF_PS_ERROR; 1792 break; 1793 } 1794 /* 1795 * Skip over member list properties 1796 */ 1797 if (strstr(buf, STMF_MEMBER_LIST_SUFFIX)) { 1798 continue; 1799 } 1800 if (scf_property_get_value(prop, value) == -1) { 1801 syslog(LOG_ERR, "get property value %s/%s failed - %s", 1802 pgName, buf, scf_strerror(scf_error())); 1803 ret = STMF_PS_ERROR; 1804 break; 1805 } 1806 if (scf_value_get_ustring(value, buf, sizeof (buf)) == -1) { 1807 syslog(LOG_ERR, "get ustring %s/%s failed - %s", 1808 pgName, buf, scf_strerror(scf_error())); 1809 ret = STMF_PS_ERROR; 1810 break; 1811 } 1812 bcopy(buf, (*groupList)->name[i++], strlen(buf)); 1813 (*groupList)->cnt++; 1814 } 1815 1816 if (ret != STMF_PS_SUCCESS) { 1817 free(*groupList); 1818 goto out; 1819 } 1820 1821 out: 1822 /* 1823 * Free resources 1824 */ 1825 if (handle != NULL) { 1826 scf_handle_destroy(handle); 1827 } 1828 if (svc != NULL) { 1829 scf_service_destroy(svc); 1830 } 1831 if (pg != NULL) { 1832 scf_pg_destroy(pg); 1833 } 1834 if (propIter != NULL) { 1835 scf_iter_destroy(propIter); 1836 } 1837 if (prop != NULL) { 1838 scf_property_destroy(prop); 1839 } 1840 if (value != NULL) { 1841 scf_value_destroy(value); 1842 } 1843 1844 return (ret); 1845 } 1846 1847 /* 1848 * iPsGetGroupMemberList 1849 * 1850 * pgName - Property group name 1851 * groupName - group name (host group or target group) 1852 * groupMemberList - pointer to pointer to stmfGroupProperties structure. On 1853 * success, contains the list of group members 1854 * 1855 * returns: 1856 * STMF_PS_SUCCESS on success 1857 * STMF_PS_ERROR_* on failure 1858 */ 1859 static int 1860 iPsGetGroupMemberList(char *pgName, char *groupName, 1861 stmfGroupProperties **groupMemberList) 1862 { 1863 scf_handle_t *handle = NULL; 1864 scf_service_t *svc = NULL; 1865 scf_propertygroup_t *pg = NULL; 1866 scf_property_t *prop = NULL; 1867 scf_value_t *valueLookup = NULL; 1868 scf_iter_t *valueIter = NULL; 1869 int i = 0; 1870 int memberCnt; 1871 int len; 1872 int ret = STMF_PS_SUCCESS; 1873 char buf[MAXNAMELEN]; 1874 1875 assert(pgName != NULL && groupName != NULL); 1876 1877 /* 1878 * init the service handle 1879 */ 1880 ret = iPsInit(&handle, &svc); 1881 if (ret != STMF_PS_SUCCESS) { 1882 goto out; 1883 } 1884 1885 /* 1886 * Allocate scf resources 1887 */ 1888 if (((pg = scf_pg_create(handle)) == NULL) || 1889 ((prop = scf_property_create(handle)) == NULL) || 1890 ((valueIter = scf_iter_create(handle)) == NULL) || 1891 ((valueLookup = scf_value_create(handle)) == NULL)) { 1892 syslog(LOG_ERR, "scf alloc resource failed - %s", 1893 scf_strerror(scf_error())); 1894 ret = STMF_PS_ERROR; 1895 goto out; 1896 } 1897 1898 /* 1899 * get the service property group handle 1900 */ 1901 if (scf_service_get_pg(svc, pgName, pg) == -1) { 1902 if (scf_error() == SCF_ERROR_NOT_FOUND) { 1903 ret = STMF_PS_ERROR_NOT_FOUND; 1904 } else { 1905 ret = STMF_PS_ERROR; 1906 } 1907 syslog(LOG_ERR, "get pg %s failed - %s", 1908 pgName, scf_strerror(scf_error())); 1909 goto out; 1910 } 1911 1912 /* 1913 * Get the property handle 1914 * based on the target or host group name 1915 */ 1916 if (scf_pg_get_property(pg, groupName, prop) == -1) { 1917 syslog(LOG_ERR, "get property %s/%s failed - %s", 1918 pgName, groupName, scf_strerror(scf_error())); 1919 ret = STMF_PS_ERROR; 1920 goto out; 1921 } 1922 1923 /* 1924 * valueIter is the iterator handle 1925 */ 1926 if (scf_iter_property_values(valueIter, prop) == -1) { 1927 syslog(LOG_ERR, "iter value %s/%s failed - %s", 1928 pgName, groupName, scf_strerror(scf_error())); 1929 ret = STMF_PS_ERROR; 1930 goto out; 1931 } 1932 1933 while (scf_iter_next_value(valueIter, valueLookup) == 1) { 1934 if (scf_value_get_ustring(valueLookup, buf, MAXNAMELEN) == -1) { 1935 syslog(LOG_ERR, "iter value %s/%s failed - %s", 1936 pgName, groupName, scf_strerror(scf_error())); 1937 ret = STMF_PS_ERROR; 1938 break; 1939 } 1940 i++; 1941 } 1942 1943 /* 1944 * valueIter is the iterator handle 1945 */ 1946 if (scf_iter_property_values(valueIter, prop) == -1) { 1947 syslog(LOG_ERR, "iter value %s/%s failed - %s", 1948 pgName, groupName, scf_strerror(scf_error())); 1949 ret = STMF_PS_ERROR; 1950 goto out; 1951 } 1952 1953 memberCnt = i; 1954 1955 *groupMemberList = (stmfGroupProperties *)calloc(1, 1956 sizeof (stmfGroupProperties) + memberCnt * sizeof (stmfDevid)); 1957 if (*groupMemberList == NULL) { 1958 ret = STMF_PS_ERROR_NOMEM; 1959 goto out; 1960 } 1961 1962 i = 0; 1963 while ((scf_iter_next_value(valueIter, valueLookup) == 1) && 1964 (i < memberCnt)) { 1965 if ((len = scf_value_get_ustring(valueLookup, buf, MAXNAMELEN)) 1966 == -1) { 1967 syslog(LOG_ERR, "iter value %s/%s failed - %s", 1968 pgName, groupName, scf_strerror(scf_error())); 1969 ret = STMF_PS_ERROR; 1970 break; 1971 } 1972 if (len < sizeof (stmfDevid) - 1) { 1973 (*groupMemberList)->name[i].identLength = len; 1974 bcopy(buf, 1975 (*groupMemberList)->name[i++].ident, len); 1976 (*groupMemberList)->cnt++; 1977 } else { 1978 ret = STMF_PS_ERROR; 1979 break; 1980 } 1981 } 1982 1983 if (ret != STMF_PS_SUCCESS) { 1984 free(*groupMemberList); 1985 goto out; 1986 } 1987 1988 out: 1989 /* 1990 * Free resources 1991 */ 1992 if (handle != NULL) { 1993 scf_handle_destroy(handle); 1994 } 1995 if (svc != NULL) { 1996 scf_service_destroy(svc); 1997 } 1998 if (pg != NULL) { 1999 scf_pg_destroy(pg); 2000 } 2001 if (prop != NULL) { 2002 scf_property_destroy(prop); 2003 } 2004 if (valueLookup != NULL) { 2005 scf_value_destroy(valueLookup); 2006 } 2007 if (valueIter != NULL) { 2008 scf_iter_destroy(valueIter); 2009 } 2010 2011 return (ret); 2012 } 2013 2014 int 2015 psGetServicePersist(uint8_t *persistType) 2016 { 2017 scf_handle_t *handle = NULL; 2018 scf_service_t *svc = NULL; 2019 int ret; 2020 2021 2022 ret = iPsInit(&handle, &svc); 2023 if (ret != STMF_PS_SUCCESS) { 2024 return (STMF_PS_ERROR); 2025 } 2026 2027 ret = iPsGetSetPersistType(persistType, handle, svc, GET); 2028 2029 /* 2030 * Free resources 2031 */ 2032 if (handle != NULL) { 2033 scf_handle_destroy(handle); 2034 } 2035 if (svc != NULL) { 2036 scf_service_destroy(svc); 2037 } 2038 return (ret); 2039 } 2040 2041 int 2042 psSetServicePersist(uint8_t persistType) 2043 { 2044 scf_handle_t *handle = NULL; 2045 scf_service_t *svc = NULL; 2046 int ret; 2047 2048 2049 ret = iPsInit(&handle, &svc); 2050 if (ret != STMF_PS_SUCCESS) { 2051 return (STMF_PS_ERROR); 2052 } 2053 2054 ret = iPsGetSetPersistType(&persistType, handle, svc, SET); 2055 2056 /* 2057 * Free resources 2058 */ 2059 if (handle != NULL) { 2060 scf_handle_destroy(handle); 2061 } 2062 if (svc != NULL) { 2063 scf_service_destroy(svc); 2064 } 2065 return (ret); 2066 } 2067 2068 static int 2069 iPsGetSetPersistType(uint8_t *persistType, scf_handle_t *handle, 2070 scf_service_t *svc, int getSet) 2071 { 2072 scf_propertygroup_t *pg = NULL; 2073 scf_property_t *prop = NULL; 2074 scf_value_t *value = NULL; 2075 scf_transaction_t *tran = NULL; 2076 scf_transaction_entry_t *entry = NULL; 2077 char iPersistTypeGet[MAXNAMELEN] = {0}; 2078 char *iPersistType; 2079 int ret = STMF_PS_SUCCESS; 2080 int commitRet; 2081 2082 if (((pg = scf_pg_create(handle)) == NULL) || 2083 ((prop = scf_property_create(handle)) == NULL) || 2084 ((entry = scf_entry_create(handle)) == NULL) || 2085 ((tran = scf_transaction_create(handle)) == NULL) || 2086 ((value = scf_value_create(handle)) == NULL)) { 2087 syslog(LOG_ERR, "scf alloc resource failed - %s", 2088 scf_strerror(scf_error())); 2089 ret = STMF_PS_ERROR; 2090 goto out; 2091 } 2092 2093 if (getSet == GET) { 2094 /* set to default */ 2095 *persistType = STMF_PERSIST_SMF; 2096 iPersistType = STMF_PS_PERSIST_SMF; 2097 } 2098 2099 if (getSet == SET) { 2100 if (*persistType == STMF_PERSIST_SMF) { 2101 iPersistType = STMF_PS_PERSIST_SMF; 2102 } else if (*persistType == STMF_PERSIST_NONE) { 2103 iPersistType = STMF_PS_PERSIST_NONE; 2104 } else { 2105 ret = STMF_PS_ERROR; 2106 goto out; 2107 } 2108 } 2109 2110 /* 2111 * get stmf data property group 2112 */ 2113 if (scf_service_get_pg(svc, STMF_DATA_GROUP, pg) == -1) { 2114 if (scf_error() == SCF_ERROR_NOT_FOUND) { 2115 ret = STMF_PS_ERROR_NOT_FOUND; 2116 } else { 2117 ret = STMF_PS_ERROR; 2118 } 2119 syslog(LOG_ERR, "get pg %s failed - %s", 2120 STMF_DATA_GROUP, scf_strerror(scf_error())); 2121 2122 goto out; 2123 } 2124 2125 /* find persistence property */ 2126 /* 2127 * Get the persistence property 2128 */ 2129 if (scf_pg_get_property(pg, STMF_PERSIST_TYPE, prop) == -1) { 2130 if (scf_error() == SCF_ERROR_NOT_FOUND) { 2131 ret = STMF_PS_ERROR_NOT_FOUND; 2132 } else { 2133 syslog(LOG_ERR, "get property %s/%s failed - %s", 2134 STMF_DATA_GROUP, STMF_PERSIST_TYPE, 2135 scf_strerror(scf_error())); 2136 ret = STMF_PS_ERROR; 2137 goto out; 2138 } 2139 } 2140 2141 /* no persist property found */ 2142 if (ret == STMF_PS_ERROR_NOT_FOUND || getSet == SET) { 2143 /* 2144 * If we have no persistType property, go ahead 2145 * and create it with the user specified value or 2146 * the default value. 2147 */ 2148 /* 2149 * Begin the transaction 2150 */ 2151 if (scf_transaction_start(tran, pg) == -1) { 2152 syslog(LOG_ERR, "start transaction for %s failed - %s", 2153 STMF_DATA_GROUP, scf_strerror(scf_error())); 2154 ret = STMF_PS_ERROR; 2155 goto out; 2156 } 2157 2158 /* is this a SET or GET w/error? */ 2159 if (ret) { 2160 if (scf_transaction_property_new(tran, entry, 2161 STMF_PERSIST_TYPE, SCF_TYPE_ASTRING) == -1) { 2162 syslog(LOG_ERR, "transaction property new " 2163 "%s/%s failed - %s", STMF_DATA_GROUP, 2164 STMF_PERSIST_TYPE, 2165 scf_strerror(scf_error())); 2166 ret = STMF_PS_ERROR; 2167 goto out; 2168 } 2169 } else { 2170 if (scf_transaction_property_change(tran, entry, 2171 STMF_PERSIST_TYPE, SCF_TYPE_ASTRING) == -1) { 2172 syslog(LOG_ERR, "transaction property change " 2173 "%s/%s failed - %s", STMF_DATA_GROUP, 2174 STMF_PERSIST_TYPE, 2175 scf_strerror(scf_error())); 2176 ret = STMF_PS_ERROR; 2177 goto out; 2178 } 2179 } 2180 2181 /* 2182 * set the persist type 2183 */ 2184 if (scf_value_set_astring(value, iPersistType) == -1) { 2185 syslog(LOG_ERR, "set value %s/%s failed - %s", 2186 STMF_DATA_GROUP, STMF_PERSIST_TYPE, 2187 scf_strerror(scf_error())); 2188 ret = STMF_PS_ERROR; 2189 goto out; 2190 } 2191 2192 /* 2193 * add the value to the transaction 2194 */ 2195 if (scf_entry_add_value(entry, value) == -1) { 2196 syslog(LOG_ERR, "add value %s/%s failed - %s", 2197 STMF_DATA_GROUP, STMF_PERSIST_TYPE, 2198 scf_strerror(scf_error())); 2199 ret = STMF_PS_ERROR; 2200 goto out; 2201 } 2202 if ((commitRet = scf_transaction_commit(tran)) != 1) { 2203 syslog(LOG_ERR, "transaction commit for %s failed - %s", 2204 STMF_DATA_GROUP, scf_strerror(scf_error())); 2205 if (commitRet == 0) { 2206 ret = STMF_PS_ERROR_BUSY; 2207 } else { 2208 ret = STMF_PS_ERROR; 2209 } 2210 goto out; 2211 } 2212 /* reset return value */ 2213 ret = STMF_PS_SUCCESS; 2214 } else if (getSet == GET) { 2215 /* get the persist property */ 2216 if (scf_property_get_value(prop, value) == -1) { 2217 syslog(LOG_ERR, "get property value %s/%s failed - %s", 2218 STMF_DATA_GROUP, STMF_PERSIST_TYPE, 2219 scf_strerror(scf_error())); 2220 ret = STMF_PS_ERROR; 2221 goto out; 2222 } 2223 2224 /* 2225 * Get the value of the persist property 2226 */ 2227 if (scf_value_get_astring(value, iPersistTypeGet, MAXNAMELEN) 2228 == -1) { 2229 syslog(LOG_ERR, "get string value %s/%s failed - %s", 2230 STMF_DATA_GROUP, STMF_PERSIST_TYPE, 2231 scf_strerror(scf_error())); 2232 ret = STMF_PS_ERROR; 2233 goto out; 2234 } 2235 } 2236 2237 if (getSet == GET) { 2238 if (strcmp(iPersistTypeGet, STMF_PS_PERSIST_NONE) == 0) { 2239 *persistType = STMF_PERSIST_NONE; 2240 } else if (strcmp(iPersistTypeGet, STMF_PS_PERSIST_SMF) == 0) { 2241 *persistType = STMF_PERSIST_SMF; 2242 } else { 2243 ret = STMF_PS_ERROR; 2244 goto out; 2245 } 2246 } 2247 out: 2248 /* 2249 * Free resources. 2250 * handle and svc should not be free'd here. They're 2251 * free'd elsewhere 2252 */ 2253 if (pg != NULL) { 2254 scf_pg_destroy(pg); 2255 } 2256 if (prop != NULL) { 2257 scf_property_destroy(prop); 2258 } 2259 if (entry != NULL) { 2260 scf_entry_destroy(entry); 2261 } 2262 if (tran != NULL) { 2263 scf_transaction_destroy(tran); 2264 } 2265 if (value != NULL) { 2266 scf_value_destroy(value); 2267 } 2268 return (ret); 2269 } 2270 2271 int 2272 psSetStmfProp(int propType, char *propVal) 2273 { 2274 return (iPsGetSetStmfProp(propType, propVal, SET)); 2275 } 2276 2277 int 2278 psGetStmfProp(int propType, char *propVal) 2279 { 2280 return (iPsGetSetStmfProp(propType, propVal, GET)); 2281 } 2282 2283 static int 2284 iPsGetSetStmfProp(int propType, char *propVal, int getSet) 2285 { 2286 scf_handle_t *handle = NULL; 2287 scf_service_t *svc = NULL; 2288 scf_property_t *prop = NULL; 2289 scf_propertygroup_t *pg = NULL; 2290 scf_transaction_t *tran = NULL; 2291 scf_transaction_entry_t *entry = NULL; 2292 scf_value_t *value = NULL; 2293 char *psStmfPropVal; 2294 char *psStmfProp; 2295 char stmfPropGet[MAXNAMELEN] = {0}; 2296 int ret = STMF_PS_SUCCESS; 2297 int commitRet; 2298 2299 if (propVal == NULL || (getSet != GET && getSet != SET)) { 2300 ret = STMF_PS_ERROR; 2301 goto out; 2302 } 2303 2304 /* 2305 * Init the service handle 2306 */ 2307 2308 ret = iPsInit(&handle, &svc); 2309 if (ret != STMF_PS_SUCCESS) { 2310 goto out; 2311 } 2312 2313 /* 2314 * Allocate scf resources 2315 */ 2316 2317 if (((pg = scf_pg_create(handle)) == NULL) || 2318 ((prop = scf_property_create(handle)) == NULL) || 2319 ((entry = scf_entry_create(handle)) == NULL) || 2320 ((tran = scf_transaction_create(handle)) == NULL) || 2321 ((value = scf_value_create(handle)) == NULL)) { 2322 syslog(LOG_ERR, "scf alloc resource failed - %s", 2323 scf_strerror(scf_error())); 2324 ret = STMF_PS_ERROR; 2325 goto out; 2326 } 2327 if (getSet == GET) { 2328 switch (propType) { 2329 case STMF_DEFAULT_LU_STATE : 2330 psStmfProp = DEFAULT_LU_STATE; 2331 psStmfPropVal = STMF_PS_LU_ONLINE; 2332 (void) strcpy(stmfPropGet, psStmfPropVal); 2333 break; 2334 case STMF_DEFAULT_TARGET_PORT_STATE : 2335 psStmfProp = DEFAULT_TARGET_PORT_STATE; 2336 psStmfPropVal = STMF_PS_TARGET_PORT_ONLINE; 2337 (void) strcpy(stmfPropGet, psStmfPropVal); 2338 break; 2339 default : 2340 ret = STMF_PS_ERROR; 2341 goto out; 2342 } 2343 } 2344 if (getSet == SET) { 2345 switch (propType) { 2346 case STMF_DEFAULT_LU_STATE : 2347 psStmfProp = DEFAULT_LU_STATE; 2348 if (strcasecmp(propVal, "online") == 0) { 2349 psStmfPropVal = STMF_PS_LU_ONLINE; 2350 } else if (strcasecmp(propVal, 2351 "offline") == 0) { 2352 psStmfPropVal = STMF_PS_LU_OFFLINE; 2353 } else { 2354 ret = STMF_PS_ERROR; 2355 goto out; 2356 } 2357 break; 2358 case STMF_DEFAULT_TARGET_PORT_STATE : 2359 psStmfProp = DEFAULT_TARGET_PORT_STATE; 2360 if (strcasecmp(propVal, "online") == 0) { 2361 psStmfPropVal = 2362 STMF_PS_TARGET_PORT_ONLINE; 2363 } else if (strcasecmp(propVal, 2364 "offline") == 0) { 2365 psStmfPropVal = 2366 STMF_PS_TARGET_PORT_OFFLINE; 2367 } else { 2368 ret = STMF_PS_ERROR; 2369 goto out; 2370 } 2371 break; 2372 default : 2373 ret = STMF_PS_ERROR; 2374 goto out; 2375 } 2376 } 2377 2378 /* 2379 * get stmf data property group 2380 */ 2381 2382 if (scf_service_get_pg(svc, STMF_DATA_GROUP, pg) == -1) { 2383 if (scf_error() == SCF_ERROR_NOT_FOUND) { 2384 ret = STMF_PS_ERROR_NOT_FOUND; 2385 } else { 2386 ret = STMF_PS_ERROR; 2387 } 2388 syslog(LOG_ERR, "get pg %s failed - %s", 2389 STMF_DATA_GROUP, scf_strerror(scf_error())); 2390 goto out; 2391 } 2392 2393 /* 2394 * get the stmf props property, if exists 2395 */ 2396 2397 if (scf_pg_get_property(pg, psStmfProp, prop) == -1) { 2398 if (scf_error() == SCF_ERROR_NOT_FOUND) { 2399 ret = STMF_PS_ERROR_NOT_FOUND; 2400 } else { 2401 syslog(LOG_ERR, "start transaction for %s/%s " 2402 "failed - %s", STMF_DATA_GROUP, psStmfProp, 2403 scf_strerror(scf_error())); 2404 ret = STMF_PS_ERROR; 2405 goto out; 2406 } 2407 } 2408 2409 /* if stmf prop is not found or while setting the prop */ 2410 2411 if (ret == STMF_PS_ERROR_NOT_FOUND || getSet == SET) { 2412 /* 2413 * Begin the transaction 2414 */ 2415 if (scf_transaction_start(tran, pg) == -1) { 2416 syslog(LOG_ERR, "start transaction for %s failed - %s", 2417 STMF_DATA_GROUP, scf_strerror(scf_error())); 2418 ret = STMF_PS_ERROR; 2419 goto out; 2420 } 2421 if (ret) { 2422 if (scf_transaction_property_new(tran, entry, 2423 psStmfProp, SCF_TYPE_ASTRING) == -1) { 2424 syslog(LOG_ERR, "transaction property new " 2425 "%s/%s failed - %s", STMF_DATA_GROUP, 2426 psStmfProp, scf_strerror(scf_error())); 2427 ret = STMF_PS_ERROR; 2428 goto out; 2429 } 2430 } else { 2431 if (scf_transaction_property_change(tran, entry, 2432 psStmfProp, SCF_TYPE_ASTRING) == -1) { 2433 syslog(LOG_ERR, 2434 "transaction property change " 2435 "%s/%s failed - %s", 2436 STMF_DATA_GROUP, psStmfProp, 2437 scf_strerror(scf_error())); 2438 ret = STMF_PS_ERROR; 2439 goto out; 2440 } 2441 } 2442 2443 /* 2444 * set stmf prop value 2445 */ 2446 2447 if (scf_value_set_astring(value, psStmfPropVal) == -1) { 2448 syslog(LOG_ERR, "set value %s/%s failed - %s", 2449 STMF_DATA_GROUP, psStmfProp, 2450 scf_strerror(scf_error())); 2451 ret = STMF_PS_ERROR; 2452 goto out; 2453 } 2454 2455 /* 2456 * add the value to the transaction 2457 */ 2458 2459 if (scf_entry_add_value(entry, value) == -1) { 2460 syslog(LOG_ERR, "add value %s/%s failed - %s", 2461 STMF_DATA_GROUP, psStmfProp, 2462 scf_strerror(scf_error())); 2463 ret = STMF_PS_ERROR; 2464 goto out; 2465 } 2466 if ((commitRet = scf_transaction_commit(tran)) != 1) { 2467 syslog(LOG_ERR, "transaction commit for %s" 2468 "failed - %s", STMF_DATA_GROUP, 2469 scf_strerror(scf_error())); 2470 if (commitRet == 0) { 2471 ret = STMF_PS_ERROR_BUSY; 2472 } else { 2473 ret = STMF_PS_ERROR; 2474 } 2475 goto out; 2476 } 2477 ret = STMF_PS_SUCCESS; 2478 } else if (getSet == GET) { 2479 if (scf_property_get_value(prop, value) == -1) { 2480 syslog(LOG_ERR, "get property value " 2481 "%s/%s failed - %s", 2482 STMF_DATA_GROUP, psStmfProp, 2483 scf_strerror(scf_error())); 2484 ret = STMF_PS_ERROR; 2485 goto out; 2486 } 2487 2488 /* get stmfProp */ 2489 2490 if (scf_value_get_astring(value, stmfPropGet, MAXNAMELEN) 2491 == -1) { 2492 syslog(LOG_ERR, "get string value %s/%s failed - %s", 2493 STMF_DATA_GROUP, psStmfProp, 2494 scf_strerror(scf_error())); 2495 ret = STMF_PS_ERROR; 2496 goto out; 2497 } 2498 } 2499 if (getSet == GET) { 2500 if (strcmp(stmfPropGet, STMF_PS_LU_ONLINE) == 0) { 2501 (void) strcpy(propVal, "online"); 2502 } else if (strcmp(stmfPropGet, STMF_PS_LU_OFFLINE) == 0) { 2503 (void) strcpy(propVal, "offline"); 2504 } else if (strcmp(stmfPropGet, STMF_PS_TARGET_PORT_ONLINE) 2505 == 0) { 2506 (void) strcpy(propVal, "online"); 2507 } else if (strcmp(stmfPropGet, STMF_PS_TARGET_PORT_OFFLINE) 2508 == 0) { 2509 (void) strcpy(propVal, "offline"); 2510 } else { 2511 ret = STMF_PS_ERROR; 2512 goto out; 2513 } 2514 } 2515 out: 2516 /* 2517 * Free resources. 2518 */ 2519 2520 if (handle != NULL) { 2521 scf_handle_destroy(handle); 2522 } 2523 if (svc != NULL) { 2524 scf_service_destroy(svc); 2525 } 2526 if (pg != NULL) { 2527 scf_pg_destroy(pg); 2528 } 2529 if (prop != NULL) { 2530 scf_property_destroy(prop); 2531 } 2532 if (entry != NULL) { 2533 scf_entry_destroy(entry); 2534 } 2535 if (tran != NULL) { 2536 scf_transaction_destroy(tran); 2537 } 2538 if (value != NULL) { 2539 scf_value_destroy(value); 2540 } 2541 return (ret); 2542 } 2543 2544 /* 2545 * Initialize scf stmf service access 2546 * handle - returned handle 2547 * service - returned service handle 2548 * 2549 * Both handle and service must be destroyed by the caller 2550 */ 2551 static int 2552 iPsInit(scf_handle_t **handle, scf_service_t **service) 2553 { 2554 scf_scope_t *scope = NULL; 2555 uint64_t version; 2556 int ret; 2557 2558 assert(handle != NULL && service != NULL); 2559 2560 if ((*handle = scf_handle_create(SCF_VERSION)) == NULL) { 2561 syslog(LOG_ERR, "scf_handle_create failed - %s", 2562 scf_strerror(scf_error())); 2563 ret = STMF_PS_ERROR; 2564 goto err; 2565 } 2566 2567 if (scf_handle_bind(*handle) == -1) { 2568 syslog(LOG_ERR, "scf_handle_bind failed - %s", 2569 scf_strerror(scf_error())); 2570 ret = STMF_PS_ERROR; 2571 goto err; 2572 } 2573 2574 if ((*service = scf_service_create(*handle)) == NULL) { 2575 syslog(LOG_ERR, "scf_service_create failed - %s", 2576 scf_strerror(scf_error())); 2577 ret = STMF_PS_ERROR; 2578 goto err; 2579 } 2580 2581 if ((scope = scf_scope_create(*handle)) == NULL) { 2582 syslog(LOG_ERR, "scf_scope_create failed - %s", 2583 scf_strerror(scf_error())); 2584 ret = STMF_PS_ERROR; 2585 goto err; 2586 } 2587 2588 if (scf_handle_get_scope(*handle, SCF_SCOPE_LOCAL, scope) == -1) { 2589 syslog(LOG_ERR, "scf_handle_get_scope failed - %s", 2590 scf_strerror(scf_error())); 2591 ret = STMF_PS_ERROR; 2592 goto err; 2593 } 2594 2595 if (scf_scope_get_service(scope, STMF_SERVICE, *service) == -1) { 2596 syslog(LOG_ERR, "scf_scope_get_service failed - %s", 2597 scf_strerror(scf_error())); 2598 ret = STMF_PS_ERROR_SERVICE_NOT_FOUND; 2599 goto err; 2600 } 2601 2602 2603 /* 2604 * Get and check the version number 2605 */ 2606 ret = iPsGetServiceVersion(&version, *handle, *service); 2607 if (ret != STMF_PS_SUCCESS) { 2608 goto err; 2609 } 2610 2611 if (version != STMF_SMF_VERSION) { 2612 ret = STMF_PS_ERROR_VERSION_MISMATCH; 2613 goto err; 2614 } 2615 2616 /* we only need destroy the scope here */ 2617 scf_scope_destroy(scope); 2618 2619 return (STMF_PS_SUCCESS); 2620 2621 err: 2622 if (*handle != NULL) { 2623 scf_handle_destroy(*handle); 2624 } 2625 if (*service != NULL) { 2626 scf_service_destroy(*service); 2627 *service = NULL; 2628 } 2629 if (scope != NULL) { 2630 scf_scope_destroy(scope); 2631 } 2632 return (ret); 2633 } 2634 2635 2636 /* 2637 * called by iPsInit only 2638 * iPsGetServiceVersion 2639 */ 2640 static int 2641 iPsGetServiceVersion(uint64_t *version, scf_handle_t *handle, 2642 scf_service_t *svc) 2643 { 2644 scf_propertygroup_t *pg = NULL; 2645 scf_property_t *prop = NULL; 2646 scf_value_t *value = NULL; 2647 scf_transaction_t *tran = NULL; 2648 scf_transaction_entry_t *entry = NULL; 2649 int ret = STMF_PS_SUCCESS; 2650 int commitRet; 2651 2652 if (((pg = scf_pg_create(handle)) == NULL) || 2653 ((prop = scf_property_create(handle)) == NULL) || 2654 ((entry = scf_entry_create(handle)) == NULL) || 2655 ((tran = scf_transaction_create(handle)) == NULL) || 2656 ((value = scf_value_create(handle)) == NULL)) { 2657 syslog(LOG_ERR, "scf alloc resource failed - %s", 2658 scf_strerror(scf_error())); 2659 ret = STMF_PS_ERROR; 2660 goto out; 2661 } 2662 2663 *version = STMF_SMF_VERSION; 2664 2665 /* 2666 * get stmf data property group 2667 */ 2668 if (scf_service_get_pg(svc, STMF_DATA_GROUP, pg) == -1) { 2669 if (scf_error() == SCF_ERROR_NOT_FOUND) { 2670 ret = STMF_PS_ERROR_NOT_FOUND; 2671 } else { 2672 syslog(LOG_ERR, "get pg %s failed - %s", 2673 STMF_DATA_GROUP, scf_strerror(scf_error())); 2674 ret = STMF_PS_ERROR; 2675 goto out; 2676 } 2677 } 2678 2679 /* create the group */ 2680 if (ret == STMF_PS_ERROR_NOT_FOUND) { 2681 /* 2682 * create the property group. 2683 */ 2684 if (scf_service_add_pg(svc, STMF_DATA_GROUP, 2685 SCF_GROUP_APPLICATION, 0, pg) == -1) { 2686 syslog(LOG_ERR, "add pg %s failed - %s", 2687 STMF_DATA_GROUP, scf_strerror(scf_error())); 2688 ret = STMF_PS_ERROR; 2689 goto out; 2690 } 2691 /* reset return value */ 2692 ret = STMF_PS_SUCCESS; 2693 } 2694 2695 /* find version property */ 2696 /* 2697 * Get the version property 2698 */ 2699 if (scf_pg_get_property(pg, STMF_VERSION_NAME, prop) == -1) { 2700 if (scf_error() == SCF_ERROR_NOT_FOUND) { 2701 ret = STMF_PS_ERROR_NOT_FOUND; 2702 } else { 2703 syslog(LOG_ERR, "get property %s/%s failed - %s", 2704 STMF_DATA_GROUP, STMF_VERSION_NAME, 2705 scf_strerror(scf_error())); 2706 ret = STMF_PS_ERROR; 2707 goto out; 2708 } 2709 } 2710 2711 /* no version property found */ 2712 if (ret == STMF_PS_ERROR_NOT_FOUND) { 2713 /* 2714 * If we have no version property, go ahead 2715 * and create it. We're obviously making an assumption 2716 * here that someone did not delete the existing property 2717 * and that this is the initial set and the initial call 2718 * to iPsInit. 2719 * If they did delete it, this will simply plant this 2720 * library's version on this service. That may or may not be 2721 * correct and we have no way of determining that. 2722 */ 2723 /* 2724 * Begin the transaction 2725 */ 2726 if (scf_transaction_start(tran, pg) == -1) { 2727 syslog(LOG_ERR, "start transaction for %s failed - %s", 2728 STMF_DATA_GROUP, scf_strerror(scf_error())); 2729 ret = STMF_PS_ERROR; 2730 goto out; 2731 } 2732 2733 if (scf_transaction_property_new(tran, entry, 2734 STMF_VERSION_NAME, SCF_TYPE_COUNT) == -1) { 2735 syslog(LOG_ERR, 2736 "transaction property new %s/%s failed - %s", 2737 STMF_DATA_GROUP, STMF_VERSION_NAME, 2738 scf_strerror(scf_error())); 2739 ret = STMF_PS_ERROR; 2740 goto out; 2741 } 2742 2743 /* 2744 * set the version number 2745 */ 2746 scf_value_set_count(value, *version); 2747 2748 /* 2749 * add the value to the transaction 2750 */ 2751 if (scf_entry_add_value(entry, value) == -1) { 2752 syslog(LOG_ERR, "add value %s/%s failed - %s", 2753 STMF_DATA_GROUP, STMF_VERSION_NAME, 2754 scf_strerror(scf_error())); 2755 ret = STMF_PS_ERROR; 2756 goto out; 2757 } 2758 if ((commitRet = scf_transaction_commit(tran)) != 1) { 2759 syslog(LOG_ERR, "transaction commit for %s failed - %s", 2760 STMF_DATA_GROUP, scf_strerror(scf_error())); 2761 if (commitRet == 0) { 2762 ret = STMF_PS_ERROR_BUSY; 2763 } else { 2764 ret = STMF_PS_ERROR; 2765 } 2766 goto out; 2767 } 2768 /* reset return value */ 2769 ret = STMF_PS_SUCCESS; 2770 } else { 2771 /* get the version property */ 2772 if (scf_pg_get_property(pg, STMF_VERSION_NAME, prop) == -1) { 2773 syslog(LOG_ERR, "get property %s/%s failed - %s", 2774 STMF_DATA_GROUP, STMF_VERSION_NAME, 2775 scf_strerror(scf_error())); 2776 ret = STMF_PS_ERROR; 2777 goto out; 2778 } 2779 2780 if (scf_property_get_value(prop, value) == -1) { 2781 syslog(LOG_ERR, "get property value %s/%s failed - %s", 2782 STMF_DATA_GROUP, STMF_VERSION_NAME, 2783 scf_strerror(scf_error())); 2784 ret = STMF_PS_ERROR; 2785 goto out; 2786 } 2787 2788 /* 2789 * Get the actual value of the view entry count property 2790 */ 2791 if (scf_value_get_count(value, version) == -1) { 2792 syslog(LOG_ERR, "get count value %s/%s failed - %s", 2793 STMF_DATA_GROUP, STMF_VERSION_NAME, 2794 scf_strerror(scf_error())); 2795 ret = STMF_PS_ERROR; 2796 goto out; 2797 } 2798 } 2799 2800 out: 2801 /* 2802 * Free resources. 2803 * handle and svc should not be free'd here. They're 2804 * free'd elsewhere 2805 */ 2806 if (pg != NULL) { 2807 scf_pg_destroy(pg); 2808 } 2809 if (prop != NULL) { 2810 scf_property_destroy(prop); 2811 } 2812 if (entry != NULL) { 2813 scf_entry_destroy(entry); 2814 } 2815 if (tran != NULL) { 2816 scf_transaction_destroy(tran); 2817 } 2818 if (value != NULL) { 2819 scf_value_destroy(value); 2820 } 2821 return (ret); 2822 } 2823 2824 2825 2826 /* 2827 * iPsGetActualGroupName 2828 * 2829 * pgName - Property group name 2830 * groupName - requested group name 2831 * actualName - actual group name to reference (len must be >= MAXNAMELEN) 2832 * 2833 * returns: 2834 * STMF_PS_SUCCESS on success 2835 * STMF_PS_ERROR_* on failure 2836 */ 2837 static int 2838 iPsGetActualGroupName(char *pgName, char *groupName, char *actualName) 2839 { 2840 scf_handle_t *handle = NULL; 2841 scf_service_t *svc = NULL; 2842 scf_propertygroup_t *pg = NULL; 2843 scf_property_t *prop = NULL; 2844 scf_iter_t *propIter = NULL; 2845 scf_value_t *value = NULL; 2846 char buf[MAXNAMELEN]; 2847 int ret; 2848 2849 ret = iPsInit(&handle, &svc); 2850 if (ret != STMF_PS_SUCCESS) { 2851 goto out; 2852 } 2853 2854 /* 2855 * Allocate scf resources 2856 */ 2857 if (((pg = scf_pg_create(handle)) == NULL) || 2858 ((prop = scf_property_create(handle)) == NULL) || 2859 ((propIter = scf_iter_create(handle)) == NULL) || 2860 ((value = scf_value_create(handle)) == NULL)) { 2861 syslog(LOG_ERR, "scf alloc resource failed - %s", 2862 scf_strerror(scf_error())); 2863 ret = STMF_PS_ERROR; 2864 goto out; 2865 } 2866 2867 /* 2868 * get group list property group 2869 */ 2870 if (scf_service_get_pg(svc, pgName, pg) == -1) { 2871 if (scf_error() == SCF_ERROR_NOT_FOUND) { 2872 ret = STMF_PS_ERROR_GROUP_NOT_FOUND; 2873 } else { 2874 syslog(LOG_ERR, "get pg %s failed - %s", 2875 pgName, scf_strerror(scf_error())); 2876 ret = STMF_PS_ERROR; 2877 } 2878 goto out; 2879 } 2880 2881 /* 2882 * propIter is the iterator handle 2883 */ 2884 if (scf_iter_pg_properties(propIter, pg) == -1) { 2885 syslog(LOG_ERR, "iter properties for %s failed - %s", 2886 pgName, scf_strerror(scf_error())); 2887 ret = STMF_PS_ERROR; 2888 goto out; 2889 } 2890 2891 /* 2892 * Iterate through group properties searching for the requested 2893 * group name. When we find it, we need to get the property name 2894 * since it refers to the actual group name. 2895 */ 2896 2897 /* initialize to not found */ 2898 ret = STMF_PS_ERROR_GROUP_NOT_FOUND; 2899 while (scf_iter_next_property(propIter, prop) == 1) { 2900 if (scf_property_get_name(prop, actualName, MAXNAMELEN) == -1) { 2901 syslog(LOG_ERR, "get name from %s iter failed - %s", 2902 pgName, scf_strerror(scf_error())); 2903 ret = STMF_PS_ERROR; 2904 break; 2905 } 2906 /* 2907 * Skip over non-member list properties 2908 */ 2909 if (strstr(actualName, STMF_MEMBER_LIST_SUFFIX)) { 2910 continue; 2911 } 2912 if (scf_property_get_value(prop, value) == -1) { 2913 syslog(LOG_ERR, "get property value %s/%s failed - %s", 2914 pgName, actualName, scf_strerror(scf_error())); 2915 ret = STMF_PS_ERROR; 2916 break; 2917 } 2918 if (scf_value_get_ustring(value, buf, sizeof (buf)) == -1) { 2919 syslog(LOG_ERR, "get ustring %s/%s failed - %s", 2920 pgName, actualName, scf_strerror(scf_error())); 2921 ret = STMF_PS_ERROR; 2922 break; 2923 } 2924 2925 /* 2926 * When we find a match, set success and break 2927 */ 2928 if ((strlen(buf) == strlen(groupName)) && 2929 bcmp(buf, groupName, strlen(buf)) == 0) { 2930 ret = STMF_PS_SUCCESS; 2931 break; 2932 } 2933 } 2934 2935 /* 2936 * if we didn't find it, ret is set to STMF_PS_ERROR_GROUP_NOT_FOUND 2937 */ 2938 2939 out: 2940 /* 2941 * Free resources 2942 */ 2943 if (handle != NULL) { 2944 scf_handle_destroy(handle); 2945 } 2946 if (svc != NULL) { 2947 scf_service_destroy(svc); 2948 } 2949 if (pg != NULL) { 2950 scf_pg_destroy(pg); 2951 } 2952 if (propIter != NULL) { 2953 scf_iter_destroy(propIter); 2954 } 2955 if (prop != NULL) { 2956 scf_property_destroy(prop); 2957 } 2958 if (value != NULL) { 2959 scf_value_destroy(value); 2960 } 2961 2962 return (ret); 2963 } 2964 2965 /* 2966 * psAddHostGroupMember 2967 * 2968 * Add a host group member to a host group, 2969 * 2970 * Input: groupName - name of group to which the member is added 2971 * memberName - name of group member to add 2972 */ 2973 int 2974 psAddHostGroupMember(char *groupName, char *memberName) 2975 { 2976 int ret; 2977 char groupPropListName[MAXNAMELEN]; 2978 char groupPropName[MAXNAMELEN]; 2979 2980 ret = iPsGetActualGroupName(STMF_HOST_GROUPS, groupName, 2981 groupPropName); 2982 if (ret != STMF_PS_SUCCESS) { 2983 return (ret); 2984 } 2985 2986 if (snprintf(groupPropListName, sizeof (groupPropListName), 2987 "%s-%s", groupPropName, STMF_MEMBER_LIST_SUFFIX) > 2988 sizeof (groupPropListName)) { 2989 syslog(LOG_ERR, "buffer overflow on property name %s", 2990 groupPropName); 2991 return (STMF_PS_ERROR); 2992 } 2993 2994 return (iPsAddRemoveGroupMember(STMF_HOST_GROUPS, groupPropListName, 2995 memberName, ADD)); 2996 } 2997 2998 /* 2999 * psAddTargetGroupMember 3000 * 3001 * Add a target port group member to a target group 3002 * 3003 * Input: groupName - name of group to which the member is added 3004 * memberName - name of group member to add. Must be nul terminated. 3005 */ 3006 int 3007 psAddTargetGroupMember(char *groupName, char *memberName) 3008 { 3009 int ret; 3010 char groupPropListName[MAXNAMELEN]; 3011 char groupPropName[MAXNAMELEN]; 3012 3013 ret = iPsGetActualGroupName(STMF_TARGET_GROUPS, groupName, 3014 groupPropName); 3015 if (ret != STMF_PS_SUCCESS) { 3016 return (ret); 3017 } 3018 3019 if (snprintf(groupPropListName, sizeof (groupPropListName), 3020 "%s-%s", groupPropName, STMF_MEMBER_LIST_SUFFIX) > 3021 sizeof (groupPropListName)) { 3022 syslog(LOG_ERR, "buffer overflow on property name %s", 3023 groupPropName); 3024 return (STMF_PS_ERROR); 3025 } 3026 3027 return (iPsAddRemoveGroupMember(STMF_TARGET_GROUPS, groupPropListName, 3028 memberName, ADD)); 3029 } 3030 3031 3032 /* 3033 * psAddViewEntry 3034 * 3035 * luGuid - logical unit identifier 3036 * viewEntry - pointer to viewEntry allocated by the caller that contains 3037 * the values to set for this view entry 3038 * 3039 * returns: 3040 * STMF_PS_SUCCESS on success 3041 * STMF_PS_ERROR_* on failure 3042 */ 3043 int 3044 psAddViewEntry(stmfGuid *lu, stmfViewEntry *viewEntry) 3045 { 3046 scf_handle_t *handle = NULL; 3047 scf_service_t *svc = NULL; 3048 scf_propertygroup_t *pg = NULL; 3049 char guidAsciiBuf[33]; /* size of ascii hex 16 byte guid with NULL */ 3050 char viewEntryPgName[VIEW_ENTRY_PG_SIZE]; 3051 char scfLuPgName[LOGICAL_UNIT_PG_SIZE]; 3052 int ret = STMF_PS_SUCCESS; 3053 sigset_t sigmaskRestore; 3054 3055 /* grab the signal hold lock */ 3056 (void) pthread_mutex_lock(&sigSetLock); 3057 3058 /* 3059 * hold signals until we're done 3060 */ 3061 if (holdSignal(&sigmaskRestore) != 0) { 3062 (void) pthread_mutex_unlock(&sigSetLock); 3063 return (STMF_PS_ERROR); 3064 } 3065 3066 ret = iPsInit(&handle, &svc); 3067 if (ret != STMF_PS_SUCCESS) { 3068 goto out; 3069 } 3070 3071 pg = scf_pg_create(handle); 3072 if (pg == NULL) { 3073 syslog(LOG_ERR, "scf pg alloc failed - %s", 3074 scf_strerror(scf_error())); 3075 ret = STMF_PS_ERROR; 3076 goto out; 3077 } 3078 3079 /* Convert to ASCII uppercase hexadecimal string */ 3080 (void) snprintf(guidAsciiBuf, sizeof (guidAsciiBuf), 3081 "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", 3082 lu->guid[0], lu->guid[1], lu->guid[2], lu->guid[3], lu->guid[4], 3083 lu->guid[5], lu->guid[6], lu->guid[7], lu->guid[8], lu->guid[9], 3084 lu->guid[10], lu->guid[11], lu->guid[12], lu->guid[13], 3085 lu->guid[14], lu->guid[15]); 3086 3087 (void) snprintf(scfLuPgName, sizeof (scfLuPgName), "%s-%s", 3088 STMF_LU_PREFIX, guidAsciiBuf); 3089 3090 bzero(viewEntryPgName, sizeof (viewEntryPgName)); 3091 /* 3092 * Format of view entry property group name: 3093 * VE-<view_entry_name>-<lu_name> 3094 */ 3095 (void) snprintf(viewEntryPgName, sizeof (viewEntryPgName), 3096 "%s-%d-%s", STMF_VE_PREFIX, viewEntry->veIndex, guidAsciiBuf); 3097 3098 ret = iPsAddViewEntry(scfLuPgName, viewEntryPgName, viewEntry); 3099 3100 out: 3101 /* 3102 * Okay, we're done. Release the signals 3103 */ 3104 if (releaseSignal(&sigmaskRestore) != 0) { 3105 /* 3106 * Don't set this as an STMF_PS_ERROR_*. We succeeded 3107 * the requested operation. But we do need to log it. 3108 */ 3109 syslog(LOG_ERR, "Unable to release one or more signals - %s", 3110 strerror(errno)); 3111 } 3112 3113 /* 3114 * Free resources 3115 */ 3116 if (handle != NULL) { 3117 scf_handle_destroy(handle); 3118 } 3119 if (svc != NULL) { 3120 scf_service_destroy(svc); 3121 } 3122 if (pg != NULL) { 3123 scf_pg_destroy(pg); 3124 } 3125 3126 /* release the signal hold lock */ 3127 (void) pthread_mutex_unlock(&sigSetLock); 3128 3129 return (ret); 3130 } 3131 3132 /* 3133 * psCheckService 3134 * 3135 * Purpose: Checks whether service exists 3136 * 3137 */ 3138 int 3139 psCheckService() 3140 { 3141 int ret; 3142 scf_handle_t *handle = NULL; 3143 scf_service_t *svc = NULL; 3144 3145 ret = iPsInit(&handle, &svc); 3146 3147 /* 3148 * Free resources 3149 */ 3150 if (handle != NULL) { 3151 scf_handle_destroy(handle); 3152 } 3153 if (svc != NULL) { 3154 scf_service_destroy(svc); 3155 } 3156 3157 return (ret); 3158 } 3159 3160 /* 3161 * psCreateHostGroup 3162 * 3163 * groupName - name of group to create 3164 * 3165 * returns: 3166 * STMF_PS_SUCCESS on success 3167 * STMF_PS_ERROR_* on failure 3168 */ 3169 int 3170 psCreateHostGroup(char *groupName) 3171 { 3172 return (iPsCreateDeleteGroup(STMF_HOST_GROUPS, groupName, ADD)); 3173 } 3174 3175 /* 3176 * psCreateTargetGroup 3177 * 3178 * groupName - name of group to create 3179 * 3180 * returns: 3181 * STMF_PS_SUCCESS on success 3182 * STMF_PS_ERROR_* on failure 3183 */ 3184 int 3185 psCreateTargetGroup(char *groupName) 3186 { 3187 return (iPsCreateDeleteGroup(STMF_TARGET_GROUPS, groupName, ADD)); 3188 } 3189 3190 /* 3191 * psDeleteHostGroup 3192 * 3193 * groupName - name of group to delete 3194 * 3195 * returns: 3196 * STMF_PS_SUCCESS on success 3197 * STMF_PS_ERROR_* on failure 3198 */ 3199 int 3200 psDeleteHostGroup(char *groupName) 3201 { 3202 return (iPsCreateDeleteGroup(STMF_HOST_GROUPS, groupName, REMOVE)); 3203 } 3204 3205 /* 3206 * psDeleteTargetGroup 3207 * 3208 * groupName - name of group to delete 3209 * 3210 * returns: 3211 * STMF_PS_SUCCESS on success 3212 * STMF_PS_ERROR_* on failure 3213 */ 3214 int 3215 psDeleteTargetGroup(char *groupName) 3216 { 3217 return (iPsCreateDeleteGroup(STMF_TARGET_GROUPS, groupName, 3218 REMOVE)); 3219 } 3220 3221 /* 3222 * psGetHostGroupList 3223 * 3224 * groupList - pointer to pointer to stmfGroupList. Contains the list 3225 * of host groups on successful return. 3226 * 3227 * returns: 3228 * STMF_PS_SUCCESS on success 3229 * STMF_PS_ERROR_* on failure 3230 */ 3231 int 3232 psGetHostGroupList(stmfGroupList **groupList) 3233 { 3234 return (iPsGetGroupList(STMF_HOST_GROUPS, groupList)); 3235 } 3236 3237 /* 3238 * psGetLogicalUnitList 3239 * 3240 * 3241 */ 3242 int 3243 psGetLogicalUnitList(stmfGuidList **guidList) 3244 { 3245 scf_handle_t *handle = NULL; 3246 scf_service_t *svc = NULL; 3247 scf_propertygroup_t *pg = NULL; 3248 scf_iter_t *pgIter = NULL; 3249 char buf[MAXNAMELEN]; 3250 int guidCnt = 0; 3251 int i = 0, j; 3252 int ret = STMF_PS_SUCCESS; 3253 unsigned int guid[sizeof (stmfGuid)]; 3254 stmfGuid outGuid; 3255 3256 assert(guidList != NULL); 3257 3258 ret = iPsInit(&handle, &svc); 3259 if (ret != STMF_PS_SUCCESS) { 3260 goto out; 3261 } 3262 3263 /* 3264 * Allocate scf resources 3265 */ 3266 if (((pg = scf_pg_create(handle)) == NULL) || 3267 ((pgIter = scf_iter_create(handle)) == NULL)) { 3268 syslog(LOG_ERR, "scf alloc resource failed - %s", 3269 scf_strerror(scf_error())); 3270 ret = STMF_PS_ERROR; 3271 goto out; 3272 } 3273 3274 /* 3275 * pgIter is the iterator handle 3276 */ 3277 if (scf_iter_service_pgs(pgIter, svc) == -1) { 3278 syslog(LOG_ERR, "iter property groups failed - %s", 3279 scf_strerror(scf_error())); 3280 ret = STMF_PS_ERROR; 3281 goto out; 3282 } 3283 3284 while (scf_iter_next_pg(pgIter, pg) == 1) { 3285 if (scf_pg_get_name(pg, buf, sizeof (buf)) == -1) { 3286 syslog(LOG_ERR, "get pg name failed - %s", 3287 scf_strerror(scf_error())); 3288 ret = STMF_PS_ERROR; 3289 break; 3290 } 3291 /* 3292 * Only count LU property groups 3293 */ 3294 if (strncmp(buf, STMF_LU_PREFIX, strlen(STMF_LU_PREFIX)) == 0) { 3295 guidCnt++; 3296 } 3297 } 3298 3299 /* 3300 * pgIter is the iterator handle 3301 */ 3302 if (scf_iter_service_pgs(pgIter, svc) == -1) { 3303 syslog(LOG_ERR, "iter property groups failed - %s", 3304 scf_strerror(scf_error())); 3305 ret = STMF_PS_ERROR; 3306 goto out; 3307 } 3308 3309 *guidList = (stmfGuidList *)calloc(1, sizeof (stmfGuidList) + 3310 guidCnt * sizeof (stmfGuid)); 3311 if (*guidList == NULL) { 3312 ret = STMF_PS_ERROR_NOMEM; 3313 goto out; 3314 } 3315 3316 /* 3317 * it's possible for entries to be added/removed while we're retrieving 3318 * the property groups. Just make sure we don't write beyond our 3319 * allocated buffer by checking to ensure i < guidCnt. 3320 */ 3321 while ((scf_iter_next_pg(pgIter, pg) == 1) && (i < guidCnt)) { 3322 if (scf_pg_get_name(pg, buf, sizeof (buf)) == -1) { 3323 syslog(LOG_ERR, "get pg name failed - %s", 3324 scf_strerror(scf_error())); 3325 ret = STMF_PS_ERROR; 3326 break; 3327 } 3328 /* 3329 * Only use LU property groups 3330 */ 3331 if (strncmp(buf, STMF_LU_PREFIX, strlen(STMF_LU_PREFIX)) != 0) { 3332 continue; 3333 } 3334 3335 j = strlen(STMF_LU_PREFIX) + strlen("-"); 3336 3337 (void) sscanf(buf + j, 3338 "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x", 3339 &guid[0], &guid[1], &guid[2], &guid[3], &guid[4], &guid[5], 3340 &guid[6], &guid[7], &guid[8], &guid[9], &guid[10], 3341 &guid[11], &guid[12], &guid[13], &guid[14], &guid[15]); 3342 3343 for (j = 0; j < sizeof (stmfGuid); j++) { 3344 outGuid.guid[j] = guid[j]; 3345 } 3346 3347 bcopy(&outGuid, (*guidList)->guid[i++].guid, sizeof (stmfGuid)); 3348 (*guidList)->cnt++; 3349 } 3350 3351 if (ret != STMF_PS_SUCCESS) { 3352 free(*guidList); 3353 goto out; 3354 } 3355 3356 out: 3357 /* 3358 * Free resources 3359 */ 3360 if (handle != NULL) { 3361 scf_handle_destroy(handle); 3362 } 3363 if (svc != NULL) { 3364 scf_service_destroy(svc); 3365 } 3366 if (pg != NULL) { 3367 scf_pg_destroy(pg); 3368 } 3369 if (pgIter != NULL) { 3370 scf_iter_destroy(pgIter); 3371 } 3372 3373 return (ret); 3374 } 3375 3376 /* 3377 * psGetTargetGroupList 3378 * 3379 * groupList - pointer to pointer to stmfGroupList. Contains the list 3380 * of target groups on successful return. 3381 * 3382 * returns: 3383 * STMF_PS_SUCCESS on success 3384 * STMF_PS_ERROR_* on failure 3385 */ 3386 int 3387 psGetTargetGroupList(stmfGroupList **groupList) 3388 { 3389 return (iPsGetGroupList(STMF_TARGET_GROUPS, groupList)); 3390 } 3391 3392 /* 3393 * psGetHostGroupMemberList 3394 * 3395 * groupName - group name for which to retrieve a member list 3396 * groupMemberList - pointer to pointer to stmfGroupProperties list 3397 * 3398 * returns: 3399 * STMF_PS_SUCCESS on success 3400 * STMF_PS_ERROR_* on failure 3401 */ 3402 int 3403 psGetHostGroupMemberList(char *groupName, stmfGroupProperties **groupMemberList) 3404 { 3405 int ret; 3406 char groupPropListName[MAXNAMELEN]; 3407 char groupPropName[MAXNAMELEN]; 3408 3409 ret = iPsGetActualGroupName(STMF_HOST_GROUPS, groupName, 3410 groupPropName); 3411 if (ret != STMF_PS_SUCCESS) { 3412 return (ret); 3413 } 3414 3415 if (snprintf(groupPropListName, sizeof (groupPropListName), 3416 "%s-%s", groupPropName, STMF_MEMBER_LIST_SUFFIX) > 3417 sizeof (groupPropListName)) { 3418 syslog(LOG_ERR, "buffer overflow on property name %s", 3419 groupPropName); 3420 return (STMF_PS_ERROR); 3421 } 3422 3423 return (iPsGetGroupMemberList(STMF_HOST_GROUPS, groupPropListName, 3424 groupMemberList)); 3425 } 3426 3427 /* 3428 * psGetTargetGroupMemberList 3429 * 3430 * groupName - group name for which to retrieve a member list 3431 * groupMemberList - pointer to pointer to stmfGroupProperties list 3432 * 3433 * returns: 3434 * STMF_PS_SUCCESS on success 3435 * STMF_PS_ERROR_* on failure 3436 */ 3437 int 3438 psGetTargetGroupMemberList(char *groupName, 3439 stmfGroupProperties **groupMemberList) 3440 { 3441 int ret; 3442 char groupPropListName[MAXNAMELEN]; 3443 char groupPropName[MAXNAMELEN]; 3444 3445 ret = iPsGetActualGroupName(STMF_TARGET_GROUPS, groupName, 3446 groupPropName); 3447 if (ret != STMF_PS_SUCCESS) { 3448 return (ret); 3449 } 3450 3451 if (snprintf(groupPropListName, sizeof (groupPropListName), 3452 "%s-%s", groupPropName, STMF_MEMBER_LIST_SUFFIX) > 3453 sizeof (groupPropListName)) { 3454 syslog(LOG_ERR, "buffer overflow on property name %s", 3455 groupPropName); 3456 return (STMF_PS_ERROR); 3457 } 3458 3459 return (iPsGetGroupMemberList(STMF_TARGET_GROUPS, 3460 groupPropListName, groupMemberList)); 3461 } 3462 3463 /* 3464 * qsort function 3465 * sort on veIndex 3466 */ 3467 static int 3468 viewEntryCompare(const void *p1, const void *p2) 3469 { 3470 3471 stmfViewEntry *v1 = (stmfViewEntry *)p1, *v2 = (stmfViewEntry *)p2; 3472 if (v1->veIndex > v2->veIndex) 3473 return (1); 3474 if (v1->veIndex < v2->veIndex) 3475 return (-1); 3476 return (0); 3477 } 3478 3479 /* 3480 * psGetViewEntryList 3481 * 3482 * luGuid - identifier of logical unit for which to retrieve a view entry list 3483 * viewEntryList - pointer to pointer to stmfViewEntryList. It will be allocated 3484 * on successful return. 3485 * 3486 * returns: 3487 * STMF_PS_SUCCESS on success 3488 * STMF_PS_ERROR_* on failure 3489 */ 3490 int 3491 psGetViewEntryList(stmfGuid *lu, stmfViewEntryList **viewEntryList) 3492 { 3493 scf_handle_t *handle = NULL; 3494 scf_service_t *svc = NULL; 3495 scf_propertygroup_t *pg = NULL; 3496 scf_property_t *prop = NULL; 3497 scf_value_t *value = NULL; 3498 scf_iter_t *propIter = NULL; 3499 char guidAsciiBuf[33]; /* size of ascii hex 16 byte guid with NULL */ 3500 char viewEntryPgName[VIEW_ENTRY_PG_SIZE]; 3501 char luPgName[LOGICAL_UNIT_PG_SIZE]; 3502 int ret = STMF_PS_SUCCESS; 3503 uint64_t i = 0; 3504 uint64_t veCnt; 3505 3506 3507 ret = iPsInit(&handle, &svc); 3508 if (ret != STMF_PS_SUCCESS) { 3509 goto out; 3510 } 3511 3512 /* 3513 * Allocate scf resources 3514 */ 3515 if (((pg = scf_pg_create(handle)) == NULL) || 3516 ((prop = scf_property_create(handle)) == NULL) || 3517 ((propIter = scf_iter_create(handle)) == NULL) || 3518 ((value = scf_value_create(handle)) == NULL)) { 3519 syslog(LOG_ERR, "scf alloc resource failed - %s", 3520 scf_strerror(scf_error())); 3521 ret = STMF_PS_ERROR; 3522 goto out; 3523 } 3524 3525 /* Convert to ASCII uppercase hexadecimal string */ 3526 (void) snprintf(guidAsciiBuf, sizeof (guidAsciiBuf), 3527 "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", 3528 lu->guid[0], lu->guid[1], lu->guid[2], lu->guid[3], lu->guid[4], 3529 lu->guid[5], lu->guid[6], lu->guid[7], lu->guid[8], lu->guid[9], 3530 lu->guid[10], lu->guid[11], lu->guid[12], lu->guid[13], 3531 lu->guid[14], lu->guid[15]); 3532 3533 /* form the LU property group name (LU-<guid>) */ 3534 (void) snprintf(luPgName, sizeof (luPgName), "%s-%s", 3535 STMF_LU_PREFIX, guidAsciiBuf); 3536 3537 /* get the property group associated with this LU */ 3538 if (scf_service_get_pg(svc, luPgName, pg) == -1) { 3539 if (scf_error() == SCF_ERROR_NOT_FOUND) { 3540 ret = STMF_PS_ERROR_NOT_FOUND; 3541 } else { 3542 syslog(LOG_ERR, "get pg %s failed - %s", 3543 luPgName, scf_strerror(scf_error())); 3544 ret = STMF_PS_ERROR; 3545 } 3546 goto out; 3547 } 3548 3549 /* get the view entry count property */ 3550 if (scf_pg_get_property(pg, STMF_VE_CNT, prop) == -1) { 3551 syslog(LOG_ERR, "get property %s/%s failed - %s", 3552 luPgName, STMF_VE_CNT, scf_strerror(scf_error())); 3553 ret = STMF_PS_ERROR; 3554 goto out; 3555 } 3556 3557 if (scf_property_get_value(prop, value) == -1) { 3558 syslog(LOG_ERR, "get property value %s/%s failed - %s", 3559 luPgName, STMF_VE_CNT, scf_strerror(scf_error())); 3560 ret = STMF_PS_ERROR; 3561 goto out; 3562 } 3563 3564 /* 3565 * Get the actual value of the view entry count property 3566 */ 3567 if (scf_value_get_count(value, &veCnt) == -1) { 3568 syslog(LOG_ERR, "get integer value %s/%s failed - %s", 3569 luPgName, STMF_VE_CNT, scf_strerror(scf_error())); 3570 ret = STMF_PS_ERROR; 3571 goto out; 3572 } 3573 3574 /* 3575 * propIter is the iterator handle 3576 */ 3577 if (scf_iter_pg_properties(propIter, pg) == -1) { 3578 syslog(LOG_ERR, "iter properties for %s failed - %s", 3579 luPgName, scf_strerror(scf_error())); 3580 ret = STMF_PS_ERROR; 3581 goto out; 3582 } 3583 3584 /* 3585 * alloc the list based on the view entry count 3586 */ 3587 *viewEntryList = (stmfViewEntryList *)calloc(1, 3588 sizeof (stmfViewEntryList) + veCnt * sizeof (stmfViewEntry)); 3589 if (*viewEntryList == NULL) { 3590 ret = STMF_PS_ERROR_NOMEM; 3591 goto out; 3592 } 3593 3594 i = 0; 3595 /* 3596 * iterate through the view entry properties to find the 3597 * view entries 3598 */ 3599 while (scf_iter_next_property(propIter, prop) == 1) { 3600 /* find match for view entry property */ 3601 if (scf_property_get_name(prop, viewEntryPgName, 3602 sizeof (viewEntryPgName)) != -1) { 3603 if (strncmp(viewEntryPgName, STMF_VE_PREFIX, 3604 strlen(STMF_VE_PREFIX)) != 0) { 3605 continue; 3606 } 3607 /* 3608 * We've exceeded our alloc limit 3609 * break with error 3610 */ 3611 if (i == veCnt) { 3612 ret = STMF_PS_ERROR; 3613 break; 3614 } 3615 3616 if ((ret = iPsGetViewEntry(viewEntryPgName, 3617 &((*viewEntryList)->ve[i]))) != STMF_PS_SUCCESS) { 3618 break; 3619 } 3620 3621 i++; 3622 3623 /* set the list count */ 3624 (*viewEntryList)->cnt++; 3625 } else { 3626 syslog(LOG_ERR, "scf iter %s properties failed - %s", 3627 luPgName, scf_strerror(scf_error())); 3628 ret = STMF_PS_ERROR; 3629 break; 3630 } 3631 3632 } 3633 3634 if (ret != STMF_PS_SUCCESS) { 3635 free(*viewEntryList); 3636 goto out; 3637 } 3638 3639 /* 3640 * We're sorting the final list here based on the veIndex 3641 * If we don't, the caller is going to have to do it to reap 3642 * some intelligent output. 3643 */ 3644 qsort((void *)&((*viewEntryList)->ve[0]), (*viewEntryList)->cnt, 3645 sizeof (stmfViewEntry), viewEntryCompare); 3646 3647 out: 3648 /* 3649 * Free resources 3650 */ 3651 if (handle != NULL) { 3652 scf_handle_destroy(handle); 3653 } 3654 if (svc != NULL) { 3655 scf_service_destroy(svc); 3656 } 3657 if (pg != NULL) { 3658 scf_pg_destroy(pg); 3659 } 3660 if (prop != NULL) { 3661 scf_property_destroy(prop); 3662 } 3663 if (value != NULL) { 3664 scf_value_destroy(value); 3665 } 3666 if (propIter != NULL) { 3667 scf_iter_destroy(propIter); 3668 } 3669 3670 return (ret); 3671 } 3672 3673 /* 3674 * iPsGetViewEntry 3675 * 3676 * viewEntryPgName - view entry property group name to retrieve 3677 * viewEntry - pointer to stmfViewEntry structure allocated by the caller 3678 * 3679 * returns: 3680 * STMF_PS_SUCCESS on success 3681 * STMF_PS_ERROR_* on failure 3682 */ 3683 static int 3684 iPsGetViewEntry(char *viewEntryPgName, stmfViewEntry *viewEntry) 3685 { 3686 scf_handle_t *handle = NULL; 3687 scf_service_t *svc = NULL; 3688 scf_propertygroup_t *pg = NULL; 3689 scf_property_t *prop = NULL; 3690 scf_value_t *value = NULL; 3691 uint8_t scfBool; 3692 char *indexPtr; 3693 char groupName[sizeof (stmfGroupName)]; 3694 int ret = STMF_PS_SUCCESS; 3695 3696 3697 ret = iPsInit(&handle, &svc); 3698 if (ret != STMF_PS_SUCCESS) { 3699 goto out; 3700 } 3701 3702 /* 3703 * Allocate scf resources 3704 */ 3705 if (((pg = scf_pg_create(handle)) == NULL) || 3706 ((prop = scf_property_create(handle)) == NULL) || 3707 ((value = scf_value_create(handle)) == NULL)) { 3708 syslog(LOG_ERR, "scf alloc resource failed - %s", 3709 scf_strerror(scf_error())); 3710 ret = STMF_PS_ERROR; 3711 goto out; 3712 } 3713 3714 bzero(viewEntry, sizeof (stmfViewEntry)); 3715 3716 /* 3717 * get the service property group view entry handle 3718 */ 3719 if (scf_service_get_pg(svc, viewEntryPgName, pg) == -1) { 3720 if (scf_error() == SCF_ERROR_NOT_FOUND) { 3721 ret = STMF_PS_ERROR_NOT_FOUND; 3722 } else { 3723 syslog(LOG_ERR, "get pg %s failed - %s", 3724 viewEntryPgName, scf_strerror(scf_error())); 3725 ret = STMF_PS_ERROR; 3726 } 3727 goto out; 3728 } 3729 3730 3731 /* 3732 * get index 3733 * format is: VE-<veIndex>-GUID 3734 */ 3735 indexPtr = strchr(viewEntryPgName, '-'); 3736 if (!indexPtr) { 3737 ret = STMF_PS_ERROR; 3738 goto out; 3739 } 3740 3741 /* Set the index */ 3742 viewEntry->veIndex = atoi(strtok(++indexPtr, "-")); 3743 3744 viewEntry->veIndexValid = B_TRUE; 3745 3746 /* get allHosts property */ 3747 if (scf_pg_get_property(pg, STMF_VE_ALLHOSTS, 3748 prop) == -1) { 3749 syslog(LOG_ERR, "get property %s/%s failed - %s", 3750 viewEntryPgName, STMF_VE_ALLHOSTS, 3751 scf_strerror(scf_error())); 3752 ret = STMF_PS_ERROR; 3753 goto out; 3754 } 3755 3756 if (scf_property_get_value(prop, value) == -1) { 3757 syslog(LOG_ERR, "get property %s/%s failed - %s", 3758 viewEntryPgName, STMF_VE_ALLHOSTS, 3759 scf_strerror(scf_error())); 3760 ret = STMF_PS_ERROR; 3761 goto out; 3762 } 3763 3764 /* set allHosts */ 3765 if (scf_value_get_boolean(value, (uint8_t *)&scfBool) == -1) { 3766 syslog(LOG_ERR, "get property %s/%s failed - %s", 3767 viewEntryPgName, STMF_VE_ALLHOSTS, 3768 scf_strerror(scf_error())); 3769 ret = STMF_PS_ERROR; 3770 goto out; 3771 } 3772 viewEntry->allHosts = scfBool; 3773 3774 /* get hostGroup property */ 3775 if (scf_pg_get_property(pg, STMF_VE_HOSTGROUP, 3776 prop) == -1) { 3777 syslog(LOG_ERR, "get property %s/%s failed - %s", 3778 viewEntryPgName, STMF_VE_HOSTGROUP, 3779 scf_strerror(scf_error())); 3780 ret = STMF_PS_ERROR; 3781 goto out; 3782 } 3783 3784 if (scf_property_get_value(prop, value) == -1) { 3785 syslog(LOG_ERR, "get property %s/%s failed - %s", 3786 viewEntryPgName, STMF_VE_HOSTGROUP, 3787 scf_strerror(scf_error())); 3788 ret = STMF_PS_ERROR; 3789 goto out; 3790 } 3791 3792 if (scf_value_get_ustring(value, groupName, 3793 sizeof (groupName)) == -1) { 3794 syslog(LOG_ERR, "get value %s/%s failed - %s", 3795 viewEntryPgName, STMF_VE_HOSTGROUP, 3796 scf_strerror(scf_error())); 3797 ret = STMF_PS_ERROR; 3798 goto out; 3799 } 3800 /* set hostGroup */ 3801 bcopy(groupName, viewEntry->hostGroup, strlen(groupName)); 3802 3803 /* get allTargets property */ 3804 if (scf_pg_get_property(pg, STMF_VE_ALLTARGETS, 3805 prop) == -1) { 3806 syslog(LOG_ERR, "get property %s/%s failed - %s", 3807 viewEntryPgName, STMF_VE_ALLTARGETS, 3808 scf_strerror(scf_error())); 3809 ret = STMF_PS_ERROR; 3810 goto out; 3811 } 3812 3813 if (scf_property_get_value(prop, value) == -1) { 3814 syslog(LOG_ERR, "get property value %s/%s failed - %s", 3815 viewEntryPgName, STMF_VE_ALLTARGETS, 3816 scf_strerror(scf_error())); 3817 ret = STMF_PS_ERROR; 3818 goto out; 3819 } 3820 3821 /* set allTargets */ 3822 if (scf_value_get_boolean(value, (uint8_t *)&scfBool) == -1) { 3823 syslog(LOG_ERR, "get value %s/%s failed - %s", 3824 viewEntryPgName, STMF_VE_ALLTARGETS, 3825 scf_strerror(scf_error())); 3826 ret = STMF_PS_ERROR; 3827 goto out; 3828 } 3829 viewEntry->allTargets = scfBool; 3830 3831 /* get targetGroup property */ 3832 if (scf_pg_get_property(pg, STMF_VE_TARGETGROUP, prop) == -1) { 3833 syslog(LOG_ERR, "get property %s/%s failed - %s", 3834 viewEntryPgName, STMF_VE_TARGETGROUP, 3835 scf_strerror(scf_error())); 3836 ret = STMF_PS_ERROR; 3837 goto out; 3838 } 3839 3840 if (scf_property_get_value(prop, value) == -1) { 3841 syslog(LOG_ERR, "get property value %s/%s failed - %s", 3842 viewEntryPgName, STMF_VE_TARGETGROUP, 3843 scf_strerror(scf_error())); 3844 ret = STMF_PS_ERROR; 3845 goto out; 3846 } 3847 3848 if (scf_value_get_ustring(value, groupName, 3849 sizeof (groupName)) == -1) { 3850 syslog(LOG_ERR, "get value %s/%s failed - %s", 3851 viewEntryPgName, STMF_VE_TARGETGROUP, 3852 scf_strerror(scf_error())); 3853 ret = STMF_PS_ERROR; 3854 goto out; 3855 } 3856 /* set targetGroup */ 3857 bcopy(groupName, viewEntry->targetGroup, strlen(groupName)); 3858 3859 /* get luNbr property */ 3860 if (scf_pg_get_property(pg, STMF_VE_LUNBR, 3861 prop) == -1) { 3862 syslog(LOG_ERR, "get property %s/%s failed - %s", 3863 viewEntryPgName, STMF_VE_LUNBR, 3864 scf_strerror(scf_error())); 3865 ret = STMF_PS_ERROR; 3866 goto out; 3867 } 3868 3869 if (scf_property_get_value(prop, value) == -1) { 3870 syslog(LOG_ERR, "get property value %s/%s failed - %s", 3871 viewEntryPgName, STMF_VE_LUNBR, 3872 scf_strerror(scf_error())); 3873 ret = STMF_PS_ERROR; 3874 goto out; 3875 } 3876 3877 /* set luNbr */ 3878 if (scf_value_get_opaque(value, (char *)viewEntry->luNbr, 3879 sizeof (viewEntry->luNbr)) == -1) { 3880 syslog(LOG_ERR, "get opaque value %s/%s failed - %s", 3881 viewEntryPgName, STMF_VE_LUNBR, 3882 scf_strerror(scf_error())); 3883 ret = STMF_PS_ERROR; 3884 goto out; 3885 } 3886 /* set luNbrValid to true since we just got it */ 3887 viewEntry->luNbrValid = B_TRUE; 3888 3889 out: 3890 /* 3891 * Free resources 3892 */ 3893 if (handle != NULL) { 3894 scf_handle_destroy(handle); 3895 } 3896 if (svc != NULL) { 3897 scf_service_destroy(svc); 3898 } 3899 if (pg != NULL) { 3900 scf_pg_destroy(pg); 3901 } 3902 if (value != NULL) { 3903 scf_value_destroy(value); 3904 } 3905 if (prop != NULL) { 3906 scf_property_destroy(prop); 3907 } 3908 3909 return (ret); 3910 } 3911 3912 3913 /* 3914 * psRemoveHostGroupMember 3915 * 3916 * Remove a host group member from a host group, 3917 * 3918 * groupName - name of group from which the member is removed 3919 * memberName - name of group member to remove 3920 * 3921 * returns: 3922 * STMF_PS_SUCCESS on success 3923 * STMF_PS_ERROR_* on failure 3924 */ 3925 int 3926 psRemoveHostGroupMember(char *groupName, char *memberName) 3927 { 3928 int ret; 3929 char groupPropListName[MAXNAMELEN]; 3930 char groupPropName[MAXNAMELEN]; 3931 3932 ret = iPsGetActualGroupName(STMF_HOST_GROUPS, groupName, 3933 groupPropName); 3934 if (ret != STMF_PS_SUCCESS) { 3935 return (ret); 3936 } 3937 3938 if (snprintf(groupPropListName, sizeof (groupPropListName), 3939 "%s-%s", groupPropName, STMF_MEMBER_LIST_SUFFIX) > 3940 sizeof (groupPropListName)) { 3941 syslog(LOG_ERR, "buffer overflow on property name %s", 3942 groupPropName); 3943 return (STMF_PS_ERROR); 3944 } 3945 3946 return (iPsAddRemoveGroupMember(STMF_HOST_GROUPS, groupPropListName, 3947 memberName, REMOVE)); 3948 } 3949 3950 /* 3951 * psRemoveTargetGroupMember 3952 * 3953 * Remove a target port group member from an target port group, 3954 * 3955 * groupName - name of group from which the member is removed 3956 * memberName - name of group member to remove 3957 * 3958 * returns: 3959 * STMF_PS_SUCCESS on success 3960 * STMF_PS_ERROR_* on failure 3961 */ 3962 int 3963 psRemoveTargetGroupMember(char *groupName, char *memberName) 3964 { 3965 int ret; 3966 char groupPropListName[MAXNAMELEN]; 3967 char groupPropName[MAXNAMELEN]; 3968 3969 ret = iPsGetActualGroupName(STMF_TARGET_GROUPS, groupName, 3970 groupPropName); 3971 if (ret != STMF_PS_SUCCESS) { 3972 return (ret); 3973 } 3974 3975 if (snprintf(groupPropListName, sizeof (groupPropListName), 3976 "%s-%s", groupPropName, STMF_MEMBER_LIST_SUFFIX) > 3977 sizeof (groupPropListName)) { 3978 syslog(LOG_ERR, "buffer overflow on property name %s", 3979 groupPropName); 3980 return (STMF_PS_ERROR); 3981 } 3982 3983 return (iPsAddRemoveGroupMember(STMF_TARGET_GROUPS, groupPropListName, 3984 memberName, REMOVE)); 3985 } 3986 3987 /* 3988 * psGetProviderData 3989 * 3990 * Retrieves an nvlist on a per provider basis 3991 * 3992 * providerName - property group name to use 3993 * nvl - nvlist to retrieve 3994 * 3995 */ 3996 int 3997 psGetProviderData(char *providerName, nvlist_t **nvl, int providerType, 3998 uint64_t *setToken) 3999 { 4000 scf_handle_t *handle = NULL; 4001 scf_service_t *svc = NULL; 4002 scf_propertygroup_t *pg = NULL; 4003 scf_property_t *prop = NULL; 4004 scf_value_t *value = NULL; 4005 uint64_t blockCnt = 0; 4006 ssize_t blockOffset = 0; 4007 ssize_t actualBlockSize = 0; 4008 char pgName[MAXPATHLEN]; 4009 char dataPropertyName[STMF_PROVIDER_DATA_PROP_NAME_SIZE]; 4010 char *nvlistEncoded = NULL; 4011 ssize_t nvlistEncodedSize = 0; 4012 boolean_t foundSetCnt = B_TRUE; 4013 int i; 4014 int ret = STMF_PS_SUCCESS; 4015 4016 if (providerName == NULL || (providerType != STMF_LU_PROVIDER_TYPE && 4017 providerType != STMF_PORT_PROVIDER_TYPE)) { 4018 ret = STMF_PS_ERROR_INVALID_ARG; 4019 goto out; 4020 } 4021 4022 ret = iPsInit(&handle, &svc); 4023 if (ret != STMF_PS_SUCCESS) { 4024 goto out; 4025 } 4026 4027 /* 4028 * create the property group name 4029 */ 4030 (void) snprintf(pgName, sizeof (pgName), "%s%s", 4031 STMF_PROVIDER_DATA_PREFIX, providerName); 4032 4033 /* 4034 * Allocate scf resources 4035 */ 4036 if (((pg = scf_pg_create(handle)) == NULL) || 4037 ((value = scf_value_create(handle)) == NULL) || 4038 ((prop = scf_property_create(handle)) == NULL)) { 4039 syslog(LOG_ERR, "scf alloc resource failed - %s", 4040 scf_strerror(scf_error())); 4041 ret = STMF_PS_ERROR; 4042 goto out; 4043 } 4044 4045 /* 4046 * Retrieve the existing property group. 4047 */ 4048 if (scf_service_get_pg(svc, pgName, pg) == -1) { 4049 if (scf_error() != SCF_ERROR_NOT_FOUND) { 4050 syslog(LOG_ERR, "get pg %s failed - %s", pgName, 4051 scf_strerror(scf_error())); 4052 ret = STMF_PS_ERROR; 4053 goto out; 4054 } else { 4055 ret = STMF_PS_ERROR_NOT_FOUND; 4056 goto out; 4057 } 4058 } 4059 4060 /* 4061 * Get the STMF_PROVIDER_DATA_PROP_COUNT property 4062 */ 4063 if (scf_pg_get_property(pg, STMF_PROVIDER_DATA_PROP_COUNT, 4064 prop) == -1) { 4065 syslog(LOG_ERR, "get property %s/%s failed - %s", 4066 pgName, STMF_PROVIDER_DATA_PROP_COUNT, 4067 scf_strerror(scf_error())); 4068 ret = STMF_PS_ERROR; 4069 goto out; 4070 } 4071 4072 /* 4073 * Get the STMF_PROVIDER_DATA_PROP_COUNT value 4074 */ 4075 if (scf_property_get_value(prop, value) == -1) { 4076 syslog(LOG_ERR, "get property value %s/%s failed - %s", 4077 pgName, STMF_PROVIDER_DATA_PROP_COUNT, 4078 scf_strerror(scf_error())); 4079 ret = STMF_PS_ERROR; 4080 goto out; 4081 } 4082 4083 /* 4084 * Now get the actual value from the value handle 4085 */ 4086 if (scf_value_get_count(value, &blockCnt) == -1) { 4087 syslog(LOG_ERR, "get integer value %s/%s failed - %s", 4088 pgName, STMF_PROVIDER_DATA_PROP_COUNT, 4089 scf_strerror(scf_error())); 4090 ret = STMF_PS_ERROR; 4091 goto out; 4092 } 4093 4094 /* Has the caller requested the token to be set? */ 4095 if (setToken) { 4096 /* 4097 * Get the STMF_PROVIDER_DATA_PROP_SET_COUNT property 4098 * If it doesn't exist, we assume it to be zero. 4099 */ 4100 *setToken = 0; 4101 if (scf_pg_get_property(pg, STMF_PROVIDER_DATA_PROP_SET_COUNT, 4102 prop) == -1) { 4103 if (scf_error() == SCF_ERROR_NOT_FOUND) { 4104 foundSetCnt = B_FALSE; 4105 } else { 4106 syslog(LOG_ERR, "get property %s/%s " 4107 "failed - %s", pgName, 4108 STMF_PROVIDER_DATA_PROP_SET_COUNT, 4109 scf_strerror(scf_error())); 4110 ret = STMF_PS_ERROR; 4111 goto out; 4112 } 4113 } 4114 4115 if (foundSetCnt) { 4116 /* 4117 * Get the STMF_PROVIDER_DATA_PROP_SET_COUNT value 4118 */ 4119 if (scf_property_get_value(prop, value) == -1) { 4120 syslog(LOG_ERR, 4121 "get property value %s/%s failed - %s", 4122 pgName, STMF_PROVIDER_DATA_PROP_SET_COUNT, 4123 scf_strerror(scf_error())); 4124 ret = STMF_PS_ERROR; 4125 goto out; 4126 } 4127 4128 /* 4129 * Now get the actual value from the value handle 4130 * and set the caller's token 4131 */ 4132 if (scf_value_get_count(value, setToken) == -1) { 4133 syslog(LOG_ERR, 4134 "get integer value %s/%s failed - %s", 4135 pgName, STMF_PROVIDER_DATA_PROP_SET_COUNT, 4136 scf_strerror(scf_error())); 4137 ret = STMF_PS_ERROR; 4138 goto out; 4139 } 4140 } 4141 } 4142 4143 nvlistEncoded = (char *)calloc(1, 4144 blockCnt * STMF_PROVIDER_DATA_PROP_SIZE); 4145 if (nvlistEncoded == NULL) { 4146 syslog(LOG_ERR, "nvlistEncoded alloc failed"); 4147 ret = STMF_PS_ERROR_NOMEM; 4148 goto out; 4149 } 4150 4151 for (i = 0; i < blockCnt; i++) { 4152 bzero(dataPropertyName, sizeof (dataPropertyName)); 4153 /* 4154 * create the name to use for the property 4155 */ 4156 (void) snprintf(dataPropertyName, sizeof (dataPropertyName), 4157 "%s-%d", STMF_PROVIDER_DATA_PROP_PREFIX, i); 4158 4159 if (scf_pg_get_property(pg, dataPropertyName, prop) == -1) { 4160 syslog(LOG_ERR, "get property %s/%s failed - %s", 4161 pgName, dataPropertyName, 4162 scf_strerror(scf_error())); 4163 ret = STMF_PS_ERROR; 4164 goto out; 4165 } 4166 4167 if (scf_property_get_value(prop, value) == -1) { 4168 syslog(LOG_ERR, "get property value %s/%s failed - %s", 4169 pgName, dataPropertyName, 4170 scf_strerror(scf_error())); 4171 ret = STMF_PS_ERROR; 4172 goto out; 4173 } 4174 4175 /* 4176 * Set the data block offset 4177 */ 4178 blockOffset = STMF_PROVIDER_DATA_PROP_SIZE * i; 4179 actualBlockSize = scf_value_get_opaque(value, 4180 &nvlistEncoded[blockOffset], STMF_PROVIDER_DATA_PROP_SIZE); 4181 if (actualBlockSize == -1) { 4182 syslog(LOG_ERR, "get opaque property value %s/%s " 4183 "failed - %s", pgName, dataPropertyName, 4184 scf_strerror(scf_error())); 4185 ret = STMF_PS_ERROR; 4186 goto out; 4187 } 4188 nvlistEncodedSize += actualBlockSize; 4189 } 4190 4191 if (nvlist_unpack(nvlistEncoded, nvlistEncodedSize, nvl, 0) != 0) { 4192 syslog(LOG_ERR, "unable to unpack nvlist"); 4193 ret = STMF_PS_ERROR; 4194 goto out; 4195 } 4196 4197 4198 out: 4199 /* 4200 * Free resources 4201 */ 4202 if (handle != NULL) { 4203 scf_handle_destroy(handle); 4204 } 4205 if (svc != NULL) { 4206 scf_service_destroy(svc); 4207 } 4208 if (pg != NULL) { 4209 scf_pg_destroy(pg); 4210 } 4211 if (prop != NULL) { 4212 scf_property_destroy(prop); 4213 } 4214 if (value != NULL) { 4215 scf_value_destroy(value); 4216 } 4217 if (nvlistEncoded != NULL) { 4218 free(nvlistEncoded); 4219 } 4220 4221 return (ret); 4222 4223 } 4224 /* 4225 * psGetProviderDataList 4226 * 4227 * Retrieves the list of providers that currently store persistent data 4228 * 4229 * providerList - pointer to a pointer to an stmfProviderList structure 4230 * On success, this will contain the list of providers 4231 * currently storing persistent data. 4232 */ 4233 int 4234 psGetProviderDataList(stmfProviderList **providerList) 4235 { 4236 scf_handle_t *handle = NULL; 4237 scf_service_t *svc = NULL; 4238 scf_propertygroup_t *pg = NULL; 4239 scf_property_t *prop = NULL; 4240 scf_value_t *value = NULL; 4241 scf_iter_t *pgIter = NULL; 4242 char buf[MAXNAMELEN]; 4243 int providerCnt = 0; 4244 int64_t providerType; 4245 int i = 0, j; 4246 int ret = STMF_PS_SUCCESS; 4247 4248 ret = iPsInit(&handle, &svc); 4249 if (ret != STMF_PS_SUCCESS) { 4250 goto out; 4251 } 4252 4253 *providerList = NULL; 4254 4255 /* 4256 * Allocate scf resources 4257 */ 4258 if (((pg = scf_pg_create(handle)) == NULL) || 4259 ((value = scf_value_create(handle)) == NULL) || 4260 ((prop = scf_property_create(handle)) == NULL) || 4261 ((pgIter = scf_iter_create(handle)) == NULL)) { 4262 syslog(LOG_ERR, "scf alloc resource failed - %s", 4263 scf_strerror(scf_error())); 4264 ret = STMF_PS_ERROR; 4265 goto out; 4266 } 4267 4268 /* 4269 * pgIter is the iterator handle 4270 */ 4271 if (scf_iter_service_pgs(pgIter, svc) == -1) { 4272 syslog(LOG_ERR, "iter property groups failed - %s", 4273 scf_strerror(scf_error())); 4274 ret = STMF_PS_ERROR; 4275 goto out; 4276 } 4277 4278 while (scf_iter_next_pg(pgIter, pg) == 1) { 4279 if (scf_pg_get_name(pg, buf, sizeof (buf)) == -1) { 4280 syslog(LOG_ERR, "get name failed - %s", 4281 scf_strerror(scf_error())); 4282 ret = STMF_PS_ERROR; 4283 break; 4284 } 4285 /* 4286 * Only count LU property groups 4287 */ 4288 if (strncmp(buf, STMF_PROVIDER_DATA_PREFIX, 4289 strlen(STMF_PROVIDER_DATA_PREFIX)) == 0) { 4290 providerCnt++; 4291 } 4292 } 4293 4294 /* 4295 * pgIter is the iterator handle 4296 */ 4297 if (scf_iter_service_pgs(pgIter, svc) == -1) { 4298 syslog(LOG_ERR, "iter property groups failed - %s", 4299 scf_strerror(scf_error())); 4300 ret = STMF_PS_ERROR; 4301 goto out; 4302 } 4303 4304 *providerList = (stmfProviderList *)calloc(1, 4305 sizeof (stmfProviderList) + providerCnt * sizeof (stmfProvider)); 4306 if (*providerList == NULL) { 4307 ret = STMF_PS_ERROR_NOMEM; 4308 goto out; 4309 } 4310 4311 /* 4312 * it's possible for entries to be added/removed while we're retrieving 4313 * the property groups. Just make sure we don't write beyond our 4314 * allocated buffer by checking to ensure i < providerCnt. 4315 */ 4316 while ((scf_iter_next_pg(pgIter, pg) == 1) && (i < providerCnt)) { 4317 if (scf_pg_get_name(pg, buf, sizeof (buf)) == -1) { 4318 syslog(LOG_ERR, "get name failed - %s", 4319 scf_strerror(scf_error())); 4320 ret = STMF_PS_ERROR; 4321 break; 4322 } 4323 /* 4324 * Only use provider data property groups 4325 */ 4326 if (strncmp(buf, STMF_PROVIDER_DATA_PREFIX, 4327 strlen(STMF_PROVIDER_DATA_PREFIX)) != 0) { 4328 continue; 4329 } 4330 4331 /* 4332 * Get the STMF_PROVIDER_DATA_PROP_TYPE property 4333 */ 4334 if (scf_pg_get_property(pg, STMF_PROVIDER_DATA_PROP_TYPE, 4335 prop) == -1) { 4336 syslog(LOG_ERR, "get property %s/%s failed - %s", 4337 buf, STMF_PROVIDER_DATA_PROP_TYPE, 4338 scf_strerror(scf_error())); 4339 ret = STMF_PS_ERROR; 4340 break; 4341 } 4342 4343 /* 4344 * Get the STMF_PROVIDER_DATA_PROP_TYPE value 4345 */ 4346 if (scf_property_get_value(prop, value) == -1) { 4347 syslog(LOG_ERR, "get property value %s/%s failed - %s", 4348 buf, STMF_PROVIDER_DATA_PROP_TYPE, 4349 scf_strerror(scf_error())); 4350 ret = STMF_PS_ERROR; 4351 break; 4352 } 4353 4354 /* 4355 * Now get the actual value from the value handle 4356 */ 4357 if (scf_value_get_integer(value, &providerType) == -1) { 4358 syslog(LOG_ERR, "get integer value %s/%s failed - %s", 4359 buf, STMF_PROVIDER_DATA_PROP_TYPE, 4360 scf_strerror(scf_error())); 4361 ret = STMF_PS_ERROR; 4362 break; 4363 } 4364 4365 (*providerList)->provider[i].providerType = providerType; 4366 4367 /* determine offset for copy of provider name */ 4368 j = strlen(STMF_PROVIDER_DATA_PREFIX); 4369 4370 /* copy provider name to caller's list */ 4371 (void) strncpy((*providerList)->provider[i].name, buf + j, 4372 sizeof ((*providerList)->provider[i].name)); 4373 i++; 4374 (*providerList)->cnt++; 4375 } 4376 4377 if (ret != STMF_PS_SUCCESS) { 4378 free(*providerList); 4379 goto out; 4380 } 4381 4382 out: 4383 /* 4384 * Free resources 4385 */ 4386 if (handle != NULL) { 4387 scf_handle_destroy(handle); 4388 } 4389 if (svc != NULL) { 4390 scf_service_destroy(svc); 4391 } 4392 if (pg != NULL) { 4393 scf_pg_destroy(pg); 4394 } 4395 if (value != NULL) { 4396 scf_value_destroy(value); 4397 } 4398 if (prop != NULL) { 4399 scf_property_destroy(prop); 4400 } 4401 if (pgIter != NULL) { 4402 scf_iter_destroy(pgIter); 4403 } 4404 4405 return (ret); 4406 } 4407 4408 4409 /* 4410 * psSetProviderData 4411 * 4412 * Stores a packed nvlist on a per provider basis 4413 * 4414 * providerName - property group name to use 4415 * nvl - nvlist to store 4416 * providerType - type of provider (logical unit or port) 4417 * 4418 */ 4419 int 4420 psSetProviderData(char *providerName, nvlist_t *nvl, int providerType, 4421 uint64_t *setToken) 4422 { 4423 scf_handle_t *handle = NULL; 4424 scf_service_t *svc = NULL; 4425 scf_propertygroup_t *pg = NULL; 4426 scf_property_t *prop = NULL; 4427 scf_transaction_t *tran = NULL; 4428 /* represents arrays of entry and value pointers for scf */ 4429 scf_transaction_entry_t **addEntry = NULL; 4430 scf_transaction_entry_t **deleteEntry = NULL; 4431 scf_value_t **addValue = NULL; 4432 4433 /* 4434 * These declarations are for known entry and value set/get 4435 * operations 4436 */ 4437 scf_transaction_entry_t *entry1 = NULL; 4438 scf_transaction_entry_t *entry2 = NULL; 4439 scf_transaction_entry_t *entry3 = NULL; 4440 scf_transaction_entry_t *entry5 = NULL; 4441 scf_value_t *value1 = NULL; 4442 scf_value_t *value2 = NULL; 4443 scf_value_t *value3 = NULL; 4444 scf_value_t *value4 = NULL; 4445 scf_value_t *value5 = NULL; 4446 4447 boolean_t newPg = B_FALSE; 4448 char pgName[MAXPATHLEN]; 4449 char dataPropertyName[STMF_PROVIDER_DATA_PROP_NAME_SIZE]; 4450 char *nvlistEncoded = NULL; 4451 size_t nvlistEncodedSize; 4452 size_t blockSize; 4453 int i, j = 0; 4454 int addEntryAlloc = 0, deleteEntryAlloc = 0, addValueAlloc = 0; 4455 int blockOffset; 4456 uint64_t oldBlockCnt = 0; 4457 uint64_t blockCnt = 0; 4458 uint64_t setCnt = 0; 4459 boolean_t foundSetCnt = B_TRUE; 4460 int ret = STMF_PS_SUCCESS; 4461 int commitRet; 4462 4463 if (providerName == NULL || (providerType != STMF_LU_PROVIDER_TYPE && 4464 providerType != STMF_PORT_PROVIDER_TYPE)) { 4465 ret = STMF_PS_ERROR_INVALID_ARG; 4466 goto out; 4467 } 4468 4469 ret = iPsInit(&handle, &svc); 4470 if (ret != STMF_PS_SUCCESS) { 4471 goto out; 4472 } 4473 4474 bzero(pgName, sizeof (pgName)); 4475 /* 4476 * create the property group name 4477 */ 4478 (void) snprintf(pgName, sizeof (pgName), "%s%s", 4479 STMF_PROVIDER_DATA_PREFIX, providerName); 4480 4481 /* 4482 * Allocate scf resources 4483 */ 4484 if (((pg = scf_pg_create(handle)) == NULL) || 4485 ((entry1 = scf_entry_create(handle)) == NULL) || 4486 ((entry2 = scf_entry_create(handle)) == NULL) || 4487 ((entry3 = scf_entry_create(handle)) == NULL) || 4488 ((entry5 = scf_entry_create(handle)) == NULL) || 4489 ((value1 = scf_value_create(handle)) == NULL) || 4490 ((value2 = scf_value_create(handle)) == NULL) || 4491 ((value3 = scf_value_create(handle)) == NULL) || 4492 ((value4 = scf_value_create(handle)) == NULL) || 4493 ((value5 = scf_value_create(handle)) == NULL) || 4494 ((prop = scf_property_create(handle)) == NULL) || 4495 ((tran = scf_transaction_create(handle)) == NULL)) { 4496 syslog(LOG_ERR, "scf alloc resource failed - %s", 4497 scf_strerror(scf_error())); 4498 ret = STMF_PS_ERROR; 4499 goto out; 4500 } 4501 4502 /* 4503 * Get the existing property group 4504 */ 4505 if (scf_service_get_pg(svc, pgName, pg) == -1) { 4506 if (scf_error() != SCF_ERROR_NOT_FOUND) { 4507 syslog(LOG_ERR, "get pg %s failed - %s", 4508 pgName, scf_strerror(scf_error())); 4509 ret = STMF_PS_ERROR; 4510 goto out; 4511 } else { 4512 /* 4513 * create the property group. 4514 */ 4515 if (scf_service_add_pg(svc, pgName, 4516 SCF_GROUP_APPLICATION, 0, pg) == -1) { 4517 syslog(LOG_ERR, "add pg %s failed - %s", 4518 pgName, scf_strerror(scf_error())); 4519 ret = STMF_PS_ERROR; 4520 goto out; 4521 } 4522 newPg = B_TRUE; 4523 } 4524 } 4525 4526 /* 4527 * Begin the transaction 4528 */ 4529 if (scf_transaction_start(tran, pg) == -1) { 4530 syslog(LOG_ERR, "start transaction for %s failed - %s", 4531 pgName, scf_strerror(scf_error())); 4532 ret = STMF_PS_ERROR; 4533 goto out; 4534 } 4535 4536 if (!newPg) { 4537 /* 4538 * Get the STMF_PROVIDER_DATA_PROP_COUNT property 4539 */ 4540 if (scf_pg_get_property(pg, STMF_PROVIDER_DATA_PROP_COUNT, 4541 prop) == -1) { 4542 syslog(LOG_ERR, "get property %s/%s failed - %s", 4543 pgName, STMF_PROVIDER_DATA_PROP_COUNT, 4544 scf_strerror(scf_error())); 4545 ret = STMF_PS_ERROR; 4546 goto out; 4547 } 4548 4549 /* 4550 * Get the STMF_PROVIDER_DATA_PROP_COUNT value 4551 */ 4552 if (scf_property_get_value(prop, value4) == -1) { 4553 syslog(LOG_ERR, "get property value %s/%s failed - %s", 4554 pgName, STMF_PROVIDER_DATA_PROP_COUNT, 4555 scf_strerror(scf_error())); 4556 ret = STMF_PS_ERROR; 4557 goto out; 4558 } 4559 4560 /* 4561 * Now get the actual value from the value handle 4562 */ 4563 if (scf_value_get_count(value4, &oldBlockCnt) == -1) { 4564 syslog(LOG_ERR, "get integer value %s/%s failed - %s", 4565 pgName, STMF_PROVIDER_DATA_PROP_COUNT, 4566 scf_strerror(scf_error())); 4567 ret = STMF_PS_ERROR; 4568 goto out; 4569 } 4570 } 4571 4572 /* 4573 * Get the STMF_PROVIDER_DATA_PROP_SET_COUNT property 4574 * If it doesn't exist, we'll create it later after successfully 4575 * setting the data. 4576 */ 4577 if (scf_pg_get_property(pg, STMF_PROVIDER_DATA_PROP_SET_COUNT, 4578 prop) == -1) { 4579 if (scf_error() == SCF_ERROR_NOT_FOUND) { 4580 foundSetCnt = B_FALSE; 4581 } else { 4582 syslog(LOG_ERR, "get property %s/%s failed - %s", 4583 pgName, STMF_PROVIDER_DATA_PROP_SET_COUNT, 4584 scf_strerror(scf_error())); 4585 ret = STMF_PS_ERROR; 4586 goto out; 4587 } 4588 } 4589 4590 if (foundSetCnt) { 4591 /* 4592 * Get the STMF_PROVIDER_DATA_PROP_SET_COUNT value 4593 */ 4594 if (scf_property_get_value(prop, value5) == -1) { 4595 syslog(LOG_ERR, "get property value %s/%s failed - %s", 4596 pgName, STMF_PROVIDER_DATA_PROP_SET_COUNT, 4597 scf_strerror(scf_error())); 4598 ret = STMF_PS_ERROR; 4599 goto out; 4600 } 4601 4602 /* 4603 * Now get the actual value from the value handle 4604 */ 4605 if (scf_value_get_count(value5, &setCnt) == -1) { 4606 syslog(LOG_ERR, "get integer value %s/%s failed - %s", 4607 pgName, STMF_PROVIDER_DATA_PROP_SET_COUNT, 4608 scf_strerror(scf_error())); 4609 ret = STMF_PS_ERROR; 4610 goto out; 4611 } 4612 4613 /* 4614 * Compare the setCnt prop to the caller's. 4615 */ 4616 if (setToken && (*setToken != setCnt)) { 4617 ret = STMF_PS_ERROR_PROV_DATA_STALE; 4618 goto out; 4619 } 4620 } 4621 4622 setCnt++; 4623 4624 /* 4625 * prepare the list for writing 4626 */ 4627 if (nvlist_pack(nvl, &nvlistEncoded, &nvlistEncodedSize, 4628 NV_ENCODE_XDR, 0) != 0) { 4629 syslog(LOG_ERR, "nvlist_pack for %s failed", 4630 pgName); 4631 ret = STMF_PS_ERROR_NOMEM; 4632 goto out; 4633 } 4634 4635 /* Determine how many chunks we need to write */ 4636 blockCnt = nvlistEncodedSize/STMF_PROVIDER_DATA_PROP_SIZE; 4637 if (nvlistEncodedSize % STMF_PROVIDER_DATA_PROP_SIZE) 4638 blockCnt++; 4639 4640 /* allocate entry and value resources for writing those chunks */ 4641 addEntry = (scf_transaction_entry_t **)calloc(1, sizeof (*addEntry) 4642 * blockCnt); 4643 if (addEntry == NULL) { 4644 syslog(LOG_ERR, "addEntry alloc for %s failed", pgName); 4645 ret = STMF_PS_ERROR_NOMEM; 4646 goto out; 4647 } 4648 4649 addValue = (scf_value_t **)calloc(1, sizeof (*addValue) 4650 * blockCnt); 4651 if (addValue == NULL) { 4652 syslog(LOG_ERR, "value alloc for %s failed", pgName); 4653 ret = STMF_PS_ERROR_NOMEM; 4654 goto out; 4655 } 4656 4657 /* 4658 * allocate entry delete resources for deleting anything existing 4659 * that is more than the new block count. We could leave them around 4660 * without suffering any ill effects but it will be cleaner to look at 4661 * in smf tools if they are deleted. 4662 */ 4663 if (oldBlockCnt > blockCnt) { 4664 deleteEntry = (scf_transaction_entry_t **)calloc(1, 4665 sizeof (*deleteEntry) * (oldBlockCnt - blockCnt)); 4666 if (deleteEntry == NULL) { 4667 syslog(LOG_ERR, "deleteEntry alloc for %s failed", 4668 pgName); 4669 ret = STMF_PS_ERROR_NOMEM; 4670 goto out; 4671 } 4672 deleteEntryAlloc = oldBlockCnt - blockCnt; 4673 } 4674 4675 4676 for (i = 0; i < blockCnt; i++) { 4677 /* 4678 * Create the entry resource for the prop 4679 */ 4680 addEntry[i] = scf_entry_create(handle); 4681 if (addEntry[i] == NULL) { 4682 syslog(LOG_ERR, "scf value alloc for %s failed - %s", 4683 pgName, scf_strerror(scf_error())); 4684 ret = STMF_PS_ERROR; 4685 goto out; 4686 } 4687 4688 /* bump alloc count for addEntry allocation */ 4689 addEntryAlloc++; 4690 4691 /* 4692 * create the name to use for the property 4693 */ 4694 (void) snprintf(dataPropertyName, sizeof (dataPropertyName), 4695 "%s-%d", STMF_PROVIDER_DATA_PROP_PREFIX, i); 4696 4697 /* 4698 * Create the new property 4699 */ 4700 if (scf_transaction_property_new(tran, addEntry[i], 4701 dataPropertyName, SCF_TYPE_OPAQUE) == -1) { 4702 if (scf_error() == SCF_ERROR_EXISTS) { 4703 if (scf_transaction_property_change(tran, 4704 addEntry[i], dataPropertyName, 4705 SCF_TYPE_OPAQUE) == -1) { 4706 syslog(LOG_ERR, "transaction property " 4707 "change %s/%s failed - %s", 4708 pgName, dataPropertyName, 4709 scf_strerror(scf_error())); 4710 ret = STMF_PS_ERROR; 4711 goto out; 4712 } 4713 } else { 4714 syslog(LOG_ERR, 4715 "transaction property new %s/%s " 4716 "failed - %s", pgName, dataPropertyName, 4717 scf_strerror(scf_error())); 4718 ret = STMF_PS_ERROR; 4719 goto out; 4720 } 4721 } 4722 /* 4723 * Create the value resource for the prop 4724 */ 4725 addValue[i] = scf_value_create(handle); 4726 if (addValue[i] == NULL) { 4727 syslog(LOG_ERR, "scf value alloc for %s failed - %s", 4728 pgName, scf_strerror(scf_error())); 4729 ret = STMF_PS_ERROR; 4730 goto out; 4731 } 4732 4733 /* bump alloc count for addValue allocation */ 4734 addValueAlloc++; 4735 4736 /* 4737 * Set the data block offset and size 4738 */ 4739 if ((STMF_PROVIDER_DATA_PROP_SIZE * (i + 1)) 4740 > nvlistEncodedSize) { 4741 blockSize = nvlistEncodedSize 4742 - STMF_PROVIDER_DATA_PROP_SIZE * i; 4743 } else { 4744 blockSize = STMF_PROVIDER_DATA_PROP_SIZE; 4745 } 4746 4747 blockOffset = STMF_PROVIDER_DATA_PROP_SIZE * i; 4748 if (scf_value_set_opaque(addValue[i], 4749 &nvlistEncoded[blockOffset], blockSize) == -1) { 4750 syslog(LOG_ERR, "set value for %s failed - %s", 4751 pgName, scf_strerror(scf_error())); 4752 ret = STMF_PS_ERROR; 4753 goto out; 4754 } 4755 4756 /* 4757 * Add the data block to the transaction entry 4758 */ 4759 if (scf_entry_add_value(addEntry[i], addValue[i]) == -1) { 4760 syslog(LOG_ERR, "add value for %s failed - %s", 4761 pgName, scf_strerror(scf_error())); 4762 ret = STMF_PS_ERROR; 4763 goto out; 4764 } 4765 } 4766 4767 /* 4768 * Now we need to delete any chunks (properties) that are no longer 4769 * needed. Iterate through the rest of the chunks deleting each. 4770 */ 4771 for (i = blockCnt; i < oldBlockCnt; i++) { 4772 /* 4773 * Create the entry resource for the prop 4774 */ 4775 deleteEntry[j] = scf_entry_create(handle); 4776 if (deleteEntry[j] == NULL) { 4777 syslog(LOG_ERR, "scf value alloc for %s failed - %s", 4778 pgName, scf_strerror(scf_error())); 4779 ret = STMF_PS_ERROR; 4780 goto out; 4781 } 4782 4783 /* 4784 * create the name to use for the property 4785 */ 4786 (void) snprintf(dataPropertyName, sizeof (dataPropertyName), 4787 "%s-%d", STMF_PROVIDER_DATA_PROP_PREFIX, i); 4788 4789 /* 4790 * Delete the existing property 4791 */ 4792 if (scf_transaction_property_delete(tran, deleteEntry[j++], 4793 dataPropertyName) == -1) { 4794 syslog(LOG_ERR, "delete property %s/%s failed - %s", 4795 pgName, dataPropertyName, 4796 scf_strerror(scf_error())); 4797 ret = STMF_PS_ERROR; 4798 goto out; 4799 } 4800 } 4801 4802 if (newPg) { 4803 /* 4804 * Ensure the read_authorization property is set 4805 * for the group 4806 */ 4807 if (scf_transaction_property_new(tran, entry1, 4808 "read_authorization", SCF_TYPE_ASTRING) == -1) { 4809 syslog(LOG_ERR, "transaction property %s/%s new " 4810 "failed - %s", pgName, "read_authorization", 4811 scf_strerror(scf_error())); 4812 ret = STMF_PS_ERROR; 4813 goto out; 4814 } 4815 4816 if (scf_value_set_astring(value1, STMF_SMF_READ_ATTR) == -1) { 4817 syslog(LOG_ERR, "set value %s/%s failed - %s", 4818 pgName, "read_authorization", 4819 scf_strerror(scf_error())); 4820 ret = STMF_PS_ERROR; 4821 goto out; 4822 } 4823 4824 if (scf_entry_add_value(entry1, value1) == -1) { 4825 syslog(LOG_ERR, "add value %s/%s failed - %s", 4826 pgName, "read_authorization", 4827 scf_strerror(scf_error())); 4828 ret = STMF_PS_ERROR; 4829 goto out; 4830 } 4831 } 4832 4833 /* create or change the count property */ 4834 if (scf_transaction_property_new(tran, entry2, 4835 STMF_PROVIDER_DATA_PROP_COUNT, SCF_TYPE_COUNT) == -1) { 4836 if (scf_error() == SCF_ERROR_EXISTS) { 4837 if (scf_transaction_property_change(tran, entry2, 4838 STMF_PROVIDER_DATA_PROP_COUNT, 4839 SCF_TYPE_COUNT) == -1) { 4840 syslog(LOG_ERR, "transaction property change " 4841 "%s/%s failed - %s", pgName, 4842 STMF_PROVIDER_DATA_PROP_COUNT, 4843 scf_strerror(scf_error())); 4844 ret = STMF_PS_ERROR; 4845 goto out; 4846 } 4847 } else { 4848 syslog(LOG_ERR, "transaction property %s/%s new " 4849 "failed - %s", pgName, 4850 STMF_PROVIDER_DATA_PROP_COUNT, 4851 scf_strerror(scf_error())); 4852 ret = STMF_PS_ERROR; 4853 goto out; 4854 } 4855 } 4856 4857 scf_value_set_count(value2, blockCnt); 4858 4859 if (scf_entry_add_value(entry2, value2) == -1) { 4860 syslog(LOG_ERR, "add value %s/%s failed - %s", 4861 pgName, STMF_PROVIDER_DATA_PROP_COUNT, 4862 scf_strerror(scf_error())); 4863 ret = STMF_PS_ERROR; 4864 goto out; 4865 } 4866 4867 /* create or change the set count property */ 4868 if (scf_transaction_property_new(tran, entry5, 4869 STMF_PROVIDER_DATA_PROP_SET_COUNT, SCF_TYPE_COUNT) == -1) { 4870 if (scf_error() == SCF_ERROR_EXISTS) { 4871 if (scf_transaction_property_change(tran, entry5, 4872 STMF_PROVIDER_DATA_PROP_SET_COUNT, 4873 SCF_TYPE_COUNT) == -1) { 4874 syslog(LOG_ERR, 4875 "transaction property change %s/%s " 4876 "failed - %s", pgName, 4877 STMF_PROVIDER_DATA_PROP_SET_COUNT, 4878 scf_strerror(scf_error())); 4879 ret = STMF_PS_ERROR; 4880 goto out; 4881 } 4882 } else { 4883 syslog(LOG_ERR, "transaction property new %s/%s " 4884 "failed - %s", pgName, 4885 STMF_PROVIDER_DATA_PROP_SET_COUNT, 4886 scf_strerror(scf_error())); 4887 ret = STMF_PS_ERROR; 4888 goto out; 4889 } 4890 } 4891 4892 4893 4894 scf_value_set_count(value5, setCnt); 4895 4896 if (scf_entry_add_value(entry5, value5) == -1) { 4897 syslog(LOG_ERR, "add value %s/%s failed - %s", 4898 pgName, STMF_PROVIDER_DATA_PROP_SET_COUNT, 4899 scf_strerror(scf_error())); 4900 ret = STMF_PS_ERROR; 4901 goto out; 4902 } 4903 4904 /* create or change the provider type property */ 4905 if (scf_transaction_property_new(tran, entry3, 4906 STMF_PROVIDER_DATA_PROP_TYPE, SCF_TYPE_INTEGER) == -1) { 4907 if (scf_error() == SCF_ERROR_EXISTS) { 4908 if (scf_transaction_property_change(tran, entry3, 4909 STMF_PROVIDER_DATA_PROP_TYPE, 4910 SCF_TYPE_INTEGER) == -1) { 4911 syslog(LOG_ERR, 4912 "transaction property change %s/%s " 4913 "failed - %s", pgName, 4914 STMF_PROVIDER_DATA_PROP_TYPE, 4915 scf_strerror(scf_error())); 4916 ret = STMF_PS_ERROR; 4917 goto out; 4918 } 4919 } else { 4920 syslog(LOG_ERR, "transaction property new %s/%s " 4921 "failed - %s", pgName, STMF_PROVIDER_DATA_PROP_TYPE, 4922 scf_strerror(scf_error())); 4923 ret = STMF_PS_ERROR; 4924 goto out; 4925 } 4926 } 4927 4928 switch (providerType) { 4929 case STMF_PORT_PROVIDER_TYPE: 4930 case STMF_LU_PROVIDER_TYPE: 4931 scf_value_set_integer(value3, providerType); 4932 break; 4933 default: 4934 ret = STMF_PS_ERROR; 4935 goto out; 4936 } 4937 4938 if (scf_entry_add_value(entry3, value3) == -1) { 4939 syslog(LOG_ERR, "add value %s/%s failed - %s", pgName, 4940 STMF_PROVIDER_DATA_PROP_TYPE, scf_strerror(scf_error())); 4941 ret = STMF_PS_ERROR; 4942 goto out; 4943 } 4944 4945 4946 if ((commitRet = scf_transaction_commit(tran)) != 1) { 4947 syslog(LOG_ERR, "transaction commit for %s failed - %s", 4948 pgName, scf_strerror(scf_error())); 4949 if (commitRet == 0) { 4950 ret = STMF_PS_ERROR_BUSY; 4951 } else { 4952 ret = STMF_PS_ERROR; 4953 } 4954 goto out; 4955 } 4956 4957 /* pass the new token back to the caller if requested */ 4958 if (ret == STMF_PS_SUCCESS && setToken) { 4959 *setToken = setCnt; 4960 } 4961 4962 out: 4963 /* 4964 * Free resources 4965 */ 4966 if (handle != NULL) { 4967 scf_handle_destroy(handle); 4968 } 4969 if (svc != NULL) { 4970 scf_service_destroy(svc); 4971 } 4972 if (pg != NULL) { 4973 scf_pg_destroy(pg); 4974 } 4975 if (prop != NULL) { 4976 scf_property_destroy(prop); 4977 } 4978 if (tran != NULL) { 4979 scf_transaction_destroy(tran); 4980 } 4981 for (i = 0; i < addEntryAlloc; i++) { 4982 scf_entry_destroy(addEntry[i]); 4983 } 4984 for (i = 0; i < addValueAlloc; i++) { 4985 scf_value_destroy(addValue[i]); 4986 } 4987 free(addValue); 4988 free(addEntry); 4989 for (i = 0; i < deleteEntryAlloc; i++) { 4990 scf_entry_destroy(deleteEntry[i]); 4991 } 4992 free(deleteEntry); 4993 if (entry1 != NULL) { 4994 scf_entry_destroy(entry1); 4995 } 4996 if (entry2 != NULL) { 4997 scf_entry_destroy(entry2); 4998 } 4999 if (entry3 != NULL) { 5000 scf_entry_destroy(entry3); 5001 } 5002 if (entry5 != NULL) { 5003 scf_entry_destroy(entry5); 5004 } 5005 if (value1 != NULL) { 5006 scf_value_destroy(value1); 5007 } 5008 if (value2 != NULL) { 5009 scf_value_destroy(value2); 5010 } 5011 if (value3 != NULL) { 5012 scf_value_destroy(value3); 5013 } 5014 if (value4 != NULL) { 5015 scf_value_destroy(value4); 5016 } 5017 if (value5 != NULL) { 5018 scf_value_destroy(value5); 5019 } 5020 if (nvlistEncoded != NULL) { 5021 free(nvlistEncoded); 5022 } 5023 5024 return (ret); 5025 } 5026 5027 /* 5028 * psGetViewEntry 5029 * 5030 * Purpose: Get a single view entry based on the logical unit identifier and 5031 * view entry index 5032 * 5033 * lu - logical unit identifier 5034 * viewEntryIndex - index of view entry 5035 * ve - caller allocated stmfViewEntry structure. On success, this will 5036 * contain the retrieved view entry 5037 */ 5038 int 5039 psGetViewEntry(stmfGuid *lu, uint32_t viewEntryIndex, stmfViewEntry *ve) 5040 { 5041 scf_handle_t *handle = NULL; 5042 scf_service_t *svc = NULL; 5043 scf_propertygroup_t *pg = NULL; 5044 char guidAsciiBuf[33]; /* size of ascii hex 16 byte guid with NULL */ 5045 char viewEntryPgName[VIEW_ENTRY_PG_SIZE]; 5046 char luPgName[LOGICAL_UNIT_PG_SIZE]; 5047 int ret = STMF_PS_SUCCESS; 5048 5049 ret = iPsInit(&handle, &svc); 5050 if (ret != STMF_PS_SUCCESS) { 5051 goto out; 5052 } 5053 5054 pg = scf_pg_create(handle); 5055 if (pg == NULL) { 5056 syslog(LOG_ERR, "scf pg alloc failed - %s", 5057 scf_strerror(scf_error())); 5058 ret = STMF_PS_ERROR; 5059 goto out; 5060 } 5061 5062 /* Convert to ASCII uppercase hexadecimal string */ 5063 (void) snprintf(guidAsciiBuf, sizeof (guidAsciiBuf), 5064 "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", 5065 lu->guid[0], lu->guid[1], lu->guid[2], lu->guid[3], lu->guid[4], 5066 lu->guid[5], lu->guid[6], lu->guid[7], lu->guid[8], lu->guid[9], 5067 lu->guid[10], lu->guid[11], lu->guid[12], lu->guid[13], 5068 lu->guid[14], lu->guid[15]); 5069 5070 (void) snprintf(luPgName, sizeof (luPgName), "%s-%s", 5071 STMF_LU_PREFIX, guidAsciiBuf); 5072 5073 /* 5074 * Format of view entry property group name: 5075 * VE-<view_entry_index>-<lu_name> 5076 */ 5077 (void) snprintf(viewEntryPgName, sizeof (viewEntryPgName), 5078 "%s-%d-%s", STMF_VE_PREFIX, viewEntryIndex, guidAsciiBuf); 5079 5080 if (scf_service_get_pg(svc, viewEntryPgName, pg) == -1) { 5081 if (scf_error() == SCF_ERROR_NOT_FOUND) { 5082 ret = STMF_PS_ERROR_NOT_FOUND; 5083 } else { 5084 syslog(LOG_ERR, "get pg %s failed - %s", 5085 viewEntryPgName, scf_strerror(scf_error())); 5086 ret = STMF_PS_ERROR; 5087 } 5088 goto out; 5089 } 5090 5091 5092 if ((ret = iPsGetViewEntry(viewEntryPgName, ve)) != STMF_PS_SUCCESS) { 5093 ret = STMF_PS_ERROR; 5094 goto out; 5095 } 5096 5097 out: 5098 /* 5099 * Free resources 5100 */ 5101 if (handle != NULL) { 5102 scf_handle_destroy(handle); 5103 } 5104 if (svc != NULL) { 5105 scf_service_destroy(svc); 5106 } 5107 if (pg != NULL) { 5108 scf_pg_destroy(pg); 5109 } 5110 5111 return (ret); 5112 } 5113 5114 /* 5115 * psRemoveViewEntry 5116 * 5117 * Remove a view entry 5118 * 5119 * luGuid - identifier of logical unit from which to remove view entry 5120 * viewEntryIndex - view entry name to remove 5121 * 5122 * returns: 5123 * STMF_PS_SUCCESS on success 5124 * STMF_PS_ERROR_* on failure 5125 */ 5126 int 5127 psRemoveViewEntry(stmfGuid *lu, uint32_t viewEntryIndex) 5128 { 5129 scf_handle_t *handle = NULL; 5130 scf_service_t *svc = NULL; 5131 scf_propertygroup_t *pg = NULL; 5132 char guidAsciiBuf[33]; /* size of ascii hex 16 byte guid with NULL */ 5133 char viewEntryPgName[VIEW_ENTRY_PG_SIZE]; 5134 char luPgName[LOGICAL_UNIT_PG_SIZE]; 5135 int ret = STMF_PS_SUCCESS; 5136 sigset_t sigmaskRestore; 5137 5138 /* grab the signal hold lock */ 5139 (void) pthread_mutex_lock(&sigSetLock); 5140 5141 /* 5142 * hold signals until we're done 5143 */ 5144 if (holdSignal(&sigmaskRestore) != 0) { 5145 (void) pthread_mutex_unlock(&sigSetLock); 5146 return (STMF_PS_ERROR); 5147 } 5148 5149 ret = iPsInit(&handle, &svc); 5150 if (ret != STMF_PS_SUCCESS) { 5151 goto out; 5152 } 5153 5154 pg = scf_pg_create(handle); 5155 if (pg == NULL) { 5156 syslog(LOG_ERR, "scf pg alloc failed - %s", 5157 scf_strerror(scf_error())); 5158 ret = STMF_PS_ERROR; 5159 goto out; 5160 } 5161 5162 /* Convert to ASCII uppercase hexadecimal string */ 5163 (void) snprintf(guidAsciiBuf, sizeof (guidAsciiBuf), 5164 "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", 5165 lu->guid[0], lu->guid[1], lu->guid[2], lu->guid[3], lu->guid[4], 5166 lu->guid[5], lu->guid[6], lu->guid[7], lu->guid[8], lu->guid[9], 5167 lu->guid[10], lu->guid[11], lu->guid[12], lu->guid[13], 5168 lu->guid[14], lu->guid[15]); 5169 5170 (void) snprintf(luPgName, sizeof (luPgName), "%s-%s", 5171 STMF_LU_PREFIX, guidAsciiBuf); 5172 5173 /* 5174 * Format of view entry property group name: 5175 * VE-<view_entry_index>-<lu_name> 5176 */ 5177 (void) snprintf(viewEntryPgName, sizeof (viewEntryPgName), 5178 "%s-%d-%s", STMF_VE_PREFIX, viewEntryIndex, guidAsciiBuf); 5179 5180 if (scf_service_get_pg(svc, viewEntryPgName, pg) == -1) { 5181 if (scf_error() == SCF_ERROR_NOT_FOUND) { 5182 ret = STMF_PS_ERROR_NOT_FOUND; 5183 } else { 5184 syslog(LOG_ERR, "get pg %s failed - %s", 5185 viewEntryPgName, scf_strerror(scf_error())); 5186 ret = STMF_PS_ERROR; 5187 } 5188 goto out; 5189 } 5190 5191 /* 5192 * update the logical unit property group to remove 5193 * the view entry and update the view entry count 5194 * If it fails, we won't delete the property group so that 5195 * we maintain consistency. 5196 */ 5197 if ((ret = iPsAddRemoveLuViewEntry(luPgName, viewEntryPgName, 5198 REMOVE)) != STMF_PS_SUCCESS) { 5199 goto out; 5200 } 5201 5202 /* 5203 * Delete the view entry. If this fails, we should try to add 5204 * the logical unit view entry property group back otherwise 5205 * we're inconsistent. 5206 */ 5207 if (scf_pg_delete(pg) == -1) { 5208 syslog(LOG_ERR, "delete pg %s failed - %s", viewEntryPgName, 5209 scf_strerror(scf_error())); 5210 if ((ret = iPsAddRemoveLuViewEntry(luPgName, viewEntryPgName, 5211 ADD)) != STMF_PS_SUCCESS) { 5212 syslog(LOG_ERR, "add of view entry %s failed, possible" 5213 "inconsistency - %s", viewEntryPgName, 5214 scf_strerror(scf_error())); 5215 } 5216 ret = STMF_PS_ERROR; 5217 goto out; 5218 } 5219 5220 out: 5221 /* 5222 * Okay, we're done. Release the signals 5223 */ 5224 if (releaseSignal(&sigmaskRestore) != 0) { 5225 /* 5226 * Don't set this as an STMF_PS_ERROR_*. We succeeded 5227 * the requested operation. But we do need to log it. 5228 */ 5229 syslog(LOG_ERR, "Unable to release one or more signals - %s", 5230 strerror(errno)); 5231 } 5232 5233 /* 5234 * Free resources 5235 */ 5236 if (handle != NULL) { 5237 scf_handle_destroy(handle); 5238 } 5239 if (svc != NULL) { 5240 scf_service_destroy(svc); 5241 } 5242 if (pg != NULL) { 5243 scf_pg_destroy(pg); 5244 } 5245 5246 /* release the signal hold lock */ 5247 (void) pthread_mutex_unlock(&sigSetLock); 5248 5249 return (ret); 5250 } 5251 5252 5253 5254 /* 5255 * holdSignal 5256 * 5257 * Hold SIGINT, SIGTERM, SIGQUIT until further notice. 5258 * 5259 * Saves old signal mask on a per thread basis 5260 * and saves action for the process. 5261 * 5262 * Installs action for above signals. 5263 * 5264 * locks held: sigSetLock 5265 * 5266 * returns: 5267 * 0 on success 5268 * non-zero otherwise 5269 */ 5270 static int 5271 holdSignal(sigset_t *sigmaskRestore) 5272 { 5273 struct sigaction act; 5274 sigset_t sigmask; 5275 5276 /* 5277 * Return existing signal mask for this thread 5278 */ 5279 if (pthread_sigmask(0, NULL, sigmaskRestore) != 0) { 5280 return (1); 5281 } 5282 5283 (void) sigemptyset(&act.sa_mask); 5284 act.sa_handler = sigHandler; 5285 act.sa_flags = 0; 5286 5287 /* 5288 * Have we set the actions for the signals we want to catch? 5289 */ 5290 if (!actionSet) { 5291 if (sigaction(SIGQUIT, &act, ¤tActionQuit) != 0) { 5292 return (1); 5293 } 5294 5295 if (sigaction(SIGINT, &act, ¤tActionInt) != 0) { 5296 return (1); 5297 } 5298 5299 if (sigaction(SIGTERM, &act, ¤tActionTerm) != 0) { 5300 return (1); 5301 } 5302 5303 actionSet = B_TRUE; 5304 } 5305 5306 /* 5307 * We still need to change the mask for the current thread 5308 */ 5309 if (sigfillset(&sigmask) != 0) { 5310 return (1); 5311 } 5312 5313 (void) sigdelset(&sigmask, SIGQUIT); 5314 5315 (void) sigdelset(&sigmask, SIGINT); 5316 5317 (void) sigdelset(&sigmask, SIGTERM); 5318 5319 if (pthread_sigmask(SIG_SETMASK, &sigmask, NULL) != 0) { 5320 return (1); 5321 } 5322 5323 return (0); 5324 } 5325 5326 /* 5327 * releaseSignal 5328 * 5329 * Re-install the original signal mask and signal actions 5330 * 5331 * Also, raise any signals that were caught during the hold period and clear 5332 * the signal from the caught set (signalsCaught). 5333 * 5334 * locks held: sigSetLock 5335 * 5336 * Returns 5337 * 0 on success 5338 * non-zero otherwise 5339 */ 5340 static int 5341 releaseSignal(sigset_t *sigmaskRestore) 5342 { 5343 int ret = 0; 5344 5345 if (sigaction(SIGQUIT, ¤tActionQuit, NULL) != 0) { 5346 ret = 1; 5347 } 5348 5349 if (sigaction(SIGINT, ¤tActionInt, NULL) != 0) { 5350 ret = 1; 5351 } 5352 5353 if (sigaction(SIGTERM, ¤tActionTerm, NULL) != 0) { 5354 ret = 1; 5355 } 5356 5357 actionSet = B_FALSE; 5358 5359 /* 5360 * Restore previous signal mask for this thread 5361 */ 5362 if (pthread_sigmask(SIG_SETMASK, sigmaskRestore, NULL) != 0) { 5363 syslog(LOG_ERR, "Unable to restore sigmask"); 5364 } 5365 5366 /* 5367 * Now raise signals that were raised while we were held 5368 */ 5369 if (sigismember(&signalsCaught, SIGTERM)) { 5370 (void) sigdelset(&signalsCaught, SIGTERM); 5371 (void) raise(SIGTERM); 5372 } 5373 5374 if (sigismember(&signalsCaught, SIGINT)) { 5375 (void) sigdelset(&signalsCaught, SIGINT); 5376 (void) raise(SIGINT); 5377 } 5378 5379 if (sigismember(&signalsCaught, SIGQUIT)) { 5380 (void) sigdelset(&signalsCaught, SIGQUIT); 5381 (void) raise(SIGQUIT); 5382 } 5383 5384 return (ret); 5385 } 5386