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
sigHandler(int sig)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
iPsAddRemoveGroupMember(char * pgName,char * groupName,char * memberName,int addRemoveFlag)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
iPsAddRemoveLuViewEntry(char * luPgName,char * viewEntryPgName,int addRemoveFlag)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
iPsAddViewEntry(char * luPgName,char * viewEntryPgName,stmfViewEntry * viewEntry)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
psClearProviderData(char * providerName,int providerType)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
iPsCreateDeleteGroup(char * pgRefName,char * groupName,int addRemoveFlag)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
iPsGetGroupList(char * pgName,stmfGroupList ** groupList)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
iPsGetGroupMemberList(char * pgName,char * groupName,stmfGroupProperties ** groupMemberList)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
psGetServicePersist(uint8_t * persistType)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
psSetServicePersist(uint8_t persistType)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
iPsGetSetPersistType(uint8_t * persistType,scf_handle_t * handle,scf_service_t * svc,int getSet)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
psSetStmfProp(int propType,char * propVal)2272 psSetStmfProp(int propType, char *propVal)
2273 {
2274 return (iPsGetSetStmfProp(propType, propVal, SET));
2275 }
2276
2277 int
psGetStmfProp(int propType,char * propVal)2278 psGetStmfProp(int propType, char *propVal)
2279 {
2280 return (iPsGetSetStmfProp(propType, propVal, GET));
2281 }
2282
2283 static int
iPsGetSetStmfProp(int propType,char * propVal,int getSet)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 = NULL;
2294 char *psStmfProp = NULL;
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
iPsInit(scf_handle_t ** handle,scf_service_t ** service)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
iPsGetServiceVersion(uint64_t * version,scf_handle_t * handle,scf_service_t * svc)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
iPsGetActualGroupName(char * pgName,char * groupName,char * actualName)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
psAddHostGroupMember(char * groupName,char * memberName)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
psAddTargetGroupMember(char * groupName,char * memberName)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
psAddViewEntry(stmfGuid * lu,stmfViewEntry * viewEntry)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
psCheckService()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
psCreateHostGroup(char * groupName)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
psCreateTargetGroup(char * groupName)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
psDeleteHostGroup(char * groupName)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
psDeleteTargetGroup(char * groupName)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
psGetHostGroupList(stmfGroupList ** groupList)3232 psGetHostGroupList(stmfGroupList **groupList)
3233 {
3234 return (iPsGetGroupList(STMF_HOST_GROUPS, groupList));
3235 }
3236
3237 /*
3238 * psGetLogicalUnitList
3239 *
3240 *
3241 */
3242 int
psGetLogicalUnitList(stmfGuidList ** guidList)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
psGetTargetGroupList(stmfGroupList ** groupList)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
psGetHostGroupMemberList(char * groupName,stmfGroupProperties ** groupMemberList)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
psGetTargetGroupMemberList(char * groupName,stmfGroupProperties ** groupMemberList)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
viewEntryCompare(const void * p1,const void * p2)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
psGetViewEntryList(stmfGuid * lu,stmfViewEntryList ** viewEntryList)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
iPsGetViewEntry(char * viewEntryPgName,stmfViewEntry * viewEntry)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;
<