?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge commit '00f1a4f432b3d8aad1aa270e91c44c57f03ef407'
[unleashed.git] / usr / src / cmd / stmfadm / stmfadm.c
blob292ce47f19ea77a345d6f4c12007f5e9f714f297
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 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 * Copyright 2012 Milan Jurik. All rights reserved.
25 */
26
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <strings.h>
30 #include <sys/types.h>
31 #include <unistd.h>
32 #include <wchar.h>
33 #include <libintl.h>
34 #include <errno.h>
35 #include <time.h>
36 #include <string.h>
37 #include <assert.h>
38 #include <getopt.h>
39 #include <cmdparse.h>
40 #include <stmfadm.h>
41 #include <libstmf.h>
42 #include <signal.h>
43 #include <pthread.h>
44 #include <locale.h>
45
46 static int addHostGroupMemberFunc(int, char **, cmdOptions_t *, void *);
47 static int addTargetGroupMemberFunc(int, char **, cmdOptions_t *, void *);
48 static int addViewFunc(int, char **, cmdOptions_t *, void *);
49 static int createHostGroupFunc(int, char **, cmdOptions_t *, void *);
50 static int createLuFunc(int, char **, cmdOptions_t *, void *);
51 static int modifyLuFunc(int, char **, cmdOptions_t *, void *);
52 static int importLuFunc(int, char **, cmdOptions_t *, void *);
53 static int deleteLuFunc(int, char **, cmdOptions_t *, void *);
54 static int createTargetGroupFunc(int, char **, cmdOptions_t *, void *);
55 static int deleteHostGroupFunc(int, char **, cmdOptions_t *, void *);
56 static int deleteTargetGroupFunc(int, char **, cmdOptions_t *, void *);
57 static int listLuFunc(int, char **, cmdOptions_t *, void *);
58 static int listTargetFunc(int, char **, cmdOptions_t *, void *);
59 static int listViewFunc(int, char **, cmdOptions_t *, void *);
60 static int listHostGroupFunc(int, char **, cmdOptions_t *, void *);
61 static int listStateFunc(int, char **, cmdOptions_t *, void *);
62 static int listTargetGroupFunc(int, char **, cmdOptions_t *, void *);
63 static int offlineTargetFunc(int, char **, cmdOptions_t *, void *);
64 static int offlineLuFunc(int, char **, cmdOptions_t *, void *);
65 static int onlineTargetFunc(int, char **, cmdOptions_t *, void *);
66 static int onlineLuFunc(int, char **, cmdOptions_t *, void *);
67 static int onlineOfflineTarget(char *, int);
68 static int onlineOfflineLu(char *, int);
69 static int removeHostGroupMemberFunc(int, char **, cmdOptions_t *, void *);
70 static int removeTargetGroupMemberFunc(int, char **, cmdOptions_t *, void *);
71 static int callModify(char *, stmfGuid *, uint32_t, const char *, const char *);
72 static int removeViewFunc(int, char **, cmdOptions_t *, void *);
73 static char *getExecBasename(char *);
74 static int parseDevid(char *input, stmfDevid *devid);
75 static void printGroupProps(stmfGroupProperties *groupProps);
76 static int checkScsiNameString(wchar_t *, stmfDevid *);
77 static int checkHexUpper(char *);
78 static int checkIscsiName(wchar_t *);
79 static void printLuProps(stmfLogicalUnitProperties *luProps);
80 static int printExtLuProps(stmfGuid *guid);
81 static void printGuid(stmfGuid *guid, FILE *printWhere);
82 static void printTargetProps(stmfTargetProperties *);
83 static void printSessionProps(stmfSessionList *);
84 static int setLuPropFromInput(luResource, char *);
85 static int convertCharToPropId(char *, uint32_t *);
86
87
88
89 /*
90 * MAJOR - This should only change when there is an incompatible change made
91 * to the interfaces or the output.
92 *
93 * MINOR - This should change whenever there is a new command or new feature
94 * with no incompatible change.
95 */
96 #define VERSION_STRING_MAJOR "1"
97 #define VERSION_STRING_MINOR "0"
98 #define MAX_DEVID_INPUT 256
99 #define GUID_INPUT 32
100 #define MAX_LU_NBR 16383
101 #define ONLINE_LU 0
102 #define OFFLINE_LU 1
103 #define ONLINE_TARGET 2
104 #define OFFLINE_TARGET 3
105 #define PROPS_FORMAT " %-18s: "
106 #define VIEW_FORMAT " %-13s: "
107 #define LVL3_FORMAT " %s"
108 #define LVL4_FORMAT " %s"
109 #define DELAYED_EXEC_WAIT_INTERVAL 300 * 1000 * 1000 /* in nano sec */
110 #define DELAYED_EXEC_WAIT_MAX 30 /* Maximum number of interval times */
111
112 /* SCSI Name String length definitions */
113 #define SNS_EUI_16 16
114 #define SNS_EUI_24 24
115 #define SNS_EUI_32 32
116 #define SNS_NAA_16 16
117 #define SNS_NAA_32 32
118 #define SNS_WWN_16 16
119 #define SNS_IQN_223 223
120
121 /* LU Property strings */
122 #define GUID "GUID"
123 #define ALIAS "ALIAS"
124 #define VID "VID"
125 #define PID "PID"
126 #define META_FILE "META"
127 #define WRITE_PROTECT "WP"
128 #define WRITEBACK_CACHE_DISABLE "WCD"
129 #define COMPANY_ID "OUI"
130 #define BLOCK_SIZE "BLK"
131 #define SERIAL_NUMBER "SERIAL"
132 #define MGMT_URL "MGMT-URL"
133 #define HOST_ID "HOST-ID"
134
135 #define STMFADM_SUCCESS 0
136 #define STMFADM_FAILURE 1
137
138 #define MODIFY_HELP "\n"\
139 "Description: Modify properties of a logical unit. \n" \
140 "Valid properties for -p, --lu-prop are: \n" \
141 " alias - alias for logical unit (up to 255 chars)\n" \
142 " mgmt-url - Management URL address\n" \
143 " wcd - write cache disabled (true, false)\n" \
144 " wp - write protect (true, false)\n\n" \
145 "-f alters the meaning of the operand to be a file name\n" \
146 "rather than a LU name. This allows for modification\n" \
147 "of a logical unit that is not yet imported into stmf\n"
148
149 #define CREATE_HELP "\n"\
150 "Description: Create a logical unit. \n" \
151 "Valid properties for -p, --lu-prop are: \n" \
152 " alias - alias for logical unit (up to 255 chars)\n" \
153 " blk - block size in bytes in 2^n\n" \
154 " guid - 32 ascii hex characters in NAA format \n" \
155 " host-id - host identifier to be used for GUID generation \n" \
156 " 8 ascii hex characters\n" \
157 " meta - separate meta data file name\n" \
158 " mgmt-url - Management URL address\n" \
159 " oui - organizational unique identifier\n" \
160 " 6 ascii hex characters of valid format\n" \
161 " pid - product identifier (up to 16 chars)\n" \
162 " serial - serial number (up to 252 chars)\n" \
163 " vid - vendor identifier (up to 8 chars)\n" \
164 " wcd - write cache disabled (true, false)\n" \
165 " wp - write protect (true, false)\n"
166 #define ADD_VIEW_HELP "\n"\
167 "Description: Add a view entry to a logical unit. \n" \
168 "A view entry is comprised of three elements; the \n" \
169 "logical unit number, the target group name and the\n" \
170 "host group name. These three elements combine together\n" \
171 "to form a view for a given COMSTAR logical unit.\n" \
172 "This view is realized by a client, a SCSI initiator,\n" \
173 "via a REPORT LUNS command. \n"
174
175
176
177 /* tables set up based on cmdparse instructions */
178
179 /* add new options here */
180 optionTbl_t longOptions[] = {
181 {"all", no_arg, 'a', NULL},
182 {"group-name", required_arg, 'g', "group-name"},
183 {"keep-views", no_arg, 'k', NULL},
184 {"lu-name", required_arg, 'l', "LU-Name"},
185 {"lun", required_arg, 'n', "logical-unit-number"},
186 {"lu-prop", required_arg, 'p', "logical-unit-property=value"},
187 {"file", no_arg, 'f', "filename"},
188 {"size", required_arg, 's', "size K/M/G/T/P"},
189 {"target-group", required_arg, 't', "group-name"},
190 {"host-group", required_arg, 'h', "group-name"},
191 {"verbose", no_arg, 'v', NULL},
192 {NULL, 0, 0, 0}
193 };
194
195 /*
196 * Add new subcommands here
197 */
198 subCommandProps_t subcommands[] = {
199 {"add-hg-member", addHostGroupMemberFunc, "g", "g", NULL,
200 OPERAND_MANDATORY_MULTIPLE, OPERANDSTRING_GROUP_MEMBER, NULL},
201 {"add-tg-member", addTargetGroupMemberFunc, "g", "g", NULL,
202 OPERAND_MANDATORY_MULTIPLE, OPERANDSTRING_GROUP_MEMBER, NULL},
203 {"add-view", addViewFunc, "nth", NULL, NULL,
204 OPERAND_MANDATORY_SINGLE, OPERANDSTRING_LU, ADD_VIEW_HELP},
205 {"create-hg", createHostGroupFunc, NULL, NULL, NULL,
206 OPERAND_MANDATORY_SINGLE, OPERANDSTRING_GROUP_NAME, NULL},
207 {"create-tg", createTargetGroupFunc, NULL, NULL, NULL,
208 OPERAND_MANDATORY_SINGLE, OPERANDSTRING_GROUP_NAME, NULL},
209 {"create-lu", createLuFunc, "ps", NULL, NULL, OPERAND_MANDATORY_SINGLE,
210 "lu file", CREATE_HELP},
211 {"delete-hg", deleteHostGroupFunc, NULL, NULL, NULL,
212 OPERAND_MANDATORY_SINGLE, OPERANDSTRING_GROUP_NAME, NULL},
213 {"modify-lu", modifyLuFunc, "psf", NULL, NULL, OPERAND_MANDATORY_SINGLE,
214 OPERANDSTRING_LU, MODIFY_HELP},
215 {"delete-lu", deleteLuFunc, "k", NULL, NULL,
216 OPERAND_MANDATORY_MULTIPLE, OPERANDSTRING_LU, NULL},
217 {"delete-tg", deleteTargetGroupFunc, NULL, NULL, NULL,
218 OPERAND_MANDATORY_SINGLE, OPERANDSTRING_GROUP_NAME, NULL},
219 {"import-lu", importLuFunc, NULL, NULL, NULL,
220 OPERAND_MANDATORY_SINGLE, "file name", NULL},
221 {"list-hg", listHostGroupFunc, "v", NULL, NULL,
222 OPERAND_OPTIONAL_MULTIPLE, OPERANDSTRING_GROUP_NAME, NULL},
223 {"list-lu", listLuFunc, "v", NULL, NULL, OPERAND_OPTIONAL_MULTIPLE,
224 OPERANDSTRING_LU, NULL},
225 {"list-state", listStateFunc, NULL, NULL, NULL, OPERAND_NONE, NULL},
226 {"list-target", listTargetFunc, "v", NULL, NULL,
227 OPERAND_OPTIONAL_MULTIPLE, OPERANDSTRING_TARGET, NULL},
228 {"list-tg", listTargetGroupFunc, "v", NULL, NULL,
229 OPERAND_OPTIONAL_MULTIPLE, OPERANDSTRING_GROUP_NAME, NULL},
230 {"list-view", listViewFunc, "l", "l", NULL,
231 OPERAND_OPTIONAL_MULTIPLE, OPERANDSTRING_VIEW_ENTRY, NULL},
232 {"online-lu", onlineLuFunc, NULL, NULL, NULL,
233 OPERAND_MANDATORY_SINGLE, OPERANDSTRING_LU, NULL},
234 {"offline-lu", offlineLuFunc, NULL, NULL, NULL,
235 OPERAND_MANDATORY_SINGLE, OPERANDSTRING_LU, NULL},
236 {"online-target", onlineTargetFunc, NULL, NULL, NULL,
237 OPERAND_MANDATORY_SINGLE, OPERANDSTRING_TARGET, NULL},
238 {"offline-target", offlineTargetFunc, NULL, NULL, NULL,
239 OPERAND_MANDATORY_SINGLE, OPERANDSTRING_TARGET, NULL},
240 {"remove-hg-member", removeHostGroupMemberFunc, "g", "g", NULL,
241 OPERAND_MANDATORY_MULTIPLE, OPERANDSTRING_GROUP_MEMBER, NULL},
242 {"remove-tg-member", removeTargetGroupMemberFunc, "g", "g", NULL,
243 OPERAND_MANDATORY_MULTIPLE, OPERANDSTRING_GROUP_MEMBER, NULL},
244 {"remove-view", removeViewFunc, "la", "l", NULL,
245 OPERAND_OPTIONAL_MULTIPLE, OPERANDSTRING_VIEW_ENTRY, NULL},
246 {NULL, NULL, NULL, NULL, NULL, 0, NULL, NULL}
247 };
248
249 /* globals */
250 char *cmdName;
251
252 /*
253 * addHostGroupMemberFunc
254 *
255 * Add members to a host group
256 *
257 */
258 /*ARGSUSED*/
259 static int
260 addHostGroupMemberFunc(int operandLen, char *operands[], cmdOptions_t *options,
261 void *args)
262 {
263 int i;
264 int ret = 0;
265 int stmfRet;
266 stmfGroupName groupName = {0};
267 wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};
268 stmfDevid devid;
269
270 for (; options->optval; options++) {
271 switch (options->optval) {
272 /* host group name */
273 case 'g':
274 (void) mbstowcs(groupNamePrint, options->optarg,
275 sizeof (stmfGroupName) - 1);
276 bcopy(options->optarg, groupName,
277 strlen(options->optarg));
278 break;
279 default:
280 (void) fprintf(stderr, "%s: %c: %s\n",
281 cmdName, options->optval,
282 gettext("unknown option"));
283 return (1);
284 }
285 }
286
287 for (i = 0; i < operandLen; i++) {
288 if (parseDevid(operands[i], &devid) != 0) {
289 (void) fprintf(stderr, "%s: %s: %s\n",
290 cmdName, operands[i],
291 gettext("unrecognized device id"));
292 ret++;
293 continue;
294 }
295 stmfRet = stmfAddToHostGroup(&groupName, &devid);
296 switch (stmfRet) {
297 case STMF_STATUS_SUCCESS:
298 break;
299 case STMF_ERROR_EXISTS:
300 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
301 operands[i], gettext("already exists"));
302 ret++;
303 break;
304 case STMF_ERROR_GROUP_NOT_FOUND:
305 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
306 groupNamePrint, gettext("not found"));
307 ret++;
308 break;
309 case STMF_ERROR_PERM:
310 (void) fprintf(stderr, "%s: %s\n", cmdName,
311 gettext("permission denied"));
312 ret++;
313 break;
314 case STMF_ERROR_BUSY:
315 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
316 operands[i], gettext("resource busy"));
317 ret++;
318 break;
319 case STMF_ERROR_SERVICE_NOT_FOUND:
320 (void) fprintf(stderr, "%s: %s\n", cmdName,
321 gettext("STMF service not found"));
322 ret++;
323 break;
324 case STMF_ERROR_SERVICE_DATA_VERSION:
325 (void) fprintf(stderr, "%s: %s\n", cmdName,
326 gettext("STMF service version incorrect"));
327 ret++;
328 break;
329 default:
330 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
331 operands[i], gettext("unknown error"));
332 ret++;
333 break;
334 }
335 }
336
337 return (ret);
338 }
339
340 /*
341 * addTargetGroupMemberFunc
342 *
343 * Add members to a target group
344 *
345 */
346 /*ARGSUSED*/
347 static int
348 addTargetGroupMemberFunc(int operandLen, char *operands[],
349 cmdOptions_t *options, void *args)
350 {
351 int i;
352 int ret = 0;
353 int stmfRet;
354 stmfGroupName groupName = {0};
355 wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};
356 stmfDevid devid;
357
358 for (; options->optval; options++) {
359 switch (options->optval) {
360 /* target group name */
361 case 'g':
362 (void) mbstowcs(groupNamePrint, options->optarg,
363 sizeof (stmfGroupName) - 1);
364 bcopy(options->optarg, groupName,
365 strlen(options->optarg));
366 break;
367 default:
368 (void) fprintf(stderr, "%s: %c: %s\n",
369 cmdName, options->optval,
370 gettext("unknown option"));
371 return (1);
372 }
373 }
374
375 for (i = 0; i < operandLen; i++) {
376 if (parseDevid(operands[i], &devid) != 0) {
377 (void) fprintf(stderr, "%s: %s: %s\n",
378 cmdName, operands[i],
379 gettext("unrecognized device id"));
380 ret++;
381 continue;
382 }
383 stmfRet = stmfAddToTargetGroup(&groupName, &devid);
384 switch (stmfRet) {
385 case STMF_STATUS_SUCCESS:
386 break;
387 case STMF_ERROR_EXISTS:
388 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
389 operands[i], gettext("already exists"));
390 ret++;
391 break;
392 case STMF_ERROR_GROUP_NOT_FOUND:
393 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
394 groupNamePrint, gettext("not found"));
395 ret++;
396 break;
397 case STMF_ERROR_PERM:
398 (void) fprintf(stderr, "%s: %s\n", cmdName,
399 gettext("permission denied"));
400 ret++;
401 break;
402 case STMF_ERROR_BUSY:
403 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
404 operands[i], gettext("resource busy"));
405 ret++;
406 break;
407 case STMF_ERROR_SERVICE_NOT_FOUND:
408 (void) fprintf(stderr, "%s: %s\n", cmdName,
409 gettext("STMF service not found"));
410 ret++;
411 break;
412 case STMF_ERROR_SERVICE_ONLINE:
413 (void) fprintf(stderr, "%s: %s\n", cmdName,
414 gettext("STMF service must be offline"));
415 ret++;
416 break;
417 case STMF_ERROR_SERVICE_DATA_VERSION:
418 (void) fprintf(stderr, "%s: %s\n", cmdName,
419 gettext("STMF service version incorrect"));
420 ret++;
421 break;
422 case STMF_ERROR_TG_ONLINE:
423 (void) fprintf(stderr, "%s: %s\n", cmdName,
424 gettext("STMF target must be offline"));
425 ret++;
426 break;
427 default:
428 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
429 operands[i], gettext("unknown error"));
430 ret++;
431 break;
432 }
433 }
434
435 return (ret);
436 }
437
438 /*
439 * parseDevid
440 *
441 * Converts char * input to a stmfDevid
442 *
443 * input - this should be in the following format with either a
444 * wwn. iqn. or eui. representation.
445 * A name string of the format:
446 * wwn.<WWN> (FC/SAS address)
447 * iqn.<iSCSI name> (iSCSI iqn)
448 * eui.<WWN> (iSCSI eui name)
449 *
450 * devid - pointer to stmfDevid structure allocated by the caller.
451 *
452 * Returns:
453 * 0 on success
454 * non-zero on failure
455 */
456 static int
457 parseDevid(char *input, stmfDevid *devid)
458 {
459 wchar_t inputWc[MAX_DEVID_INPUT + 1] = {0};
460
461 /* convert to wcs */
462 (void) mbstowcs(inputWc, input, MAX_DEVID_INPUT);
463
464 /*
465 * Check for known scsi name string formats
466 * If one is found, we're done
467 * If not, then it's a failure to parse
468 */
469 if (checkScsiNameString(inputWc, devid) == 0) {
470 return (0);
471 }
472
473 return (-1);
474 }
475
476 /*
477 * checkScsiNameString
478 *
479 * Validates known SCSI name string formats and converts to stmfDevid
480 * format
481 *
482 * input - input SCSI name string
483 * devid - pointer to stmfDevid structure allocated by the caller
484 * on successful return, contains the devid based on input
485 *
486 * returns:
487 * 0 on success
488 * -1 on failure
489 */
490 static int
491 checkScsiNameString(wchar_t *input, stmfDevid *devid)
492 {
493 char *mbString = NULL;
494 int mbStringLen;
495 int len;
496 int i;
497
498 /*
499 * Convert to multi-byte string
500 *
501 * This is used for either eui or naa formats
502 */
503 mbString = calloc(1, (mbStringLen = wcstombs(mbString, input, 0)) + 1);
504 if (mbString == NULL) {
505 (void) fprintf(stderr, "%s: %s\n",
506 cmdName, "Insufficient memory\n");
507 return (-1);
508 }
509 if (wcstombs(mbString, input, mbStringLen) == (size_t)-1) {
510 return (-1);
511 }
512
513 /*
514 * check for iqn format
515 */
516 if (strncmp(mbString, "iqn.", 4) == 0) {
517 if ((len = strlen(mbString)) > (SNS_IQN_223)) {
518 return (-1);
519 }
520 for (i = 0; i < len; i++) {
521 mbString[i] = tolower(mbString[i]);
522 }
523 if (checkIscsiName(input + 4) != 0) {
524 return (-1);
525 }
526 } else if (strncmp(mbString, "wwn.", 4) == 0) {
527 if ((len = strlen(mbString + 4)) != SNS_WWN_16) {
528 return (-1);
529 } else if (checkHexUpper(mbString + 4) != 0) {
530 return (-1);
531 }
532 } else if (strncmp(mbString, "eui.", 4) == 0) {
533 if ((len = strlen(mbString + 4)) != SNS_EUI_16) {
534 return (-1);
535 } else if (checkHexUpper(mbString + 4) != 0) {
536 return (-1);
537 }
538 } else {
539 return (-1);
540 }
541
542 /*
543 * We have a validated name string.
544 * Go ahead and set the length and copy it.
545 */
546 devid->identLength = strlen(mbString);
547 bzero(devid->ident, STMF_IDENT_LENGTH);
548 bcopy(mbString, devid->ident, devid->identLength);
549
550 return (0);
551 }
552
553
554 /*
555 * Checks whether the entire string is in hex and converts to upper
556 */
557 static int
558 checkHexUpper(char *input)
559 {
560 int i;
561
562 for (i = 0; i < strlen(input); i++) {
563 if (isxdigit(input[i])) {
564 input[i] = toupper(input[i]);
565 continue;
566 }
567 return (-1);
568 }
569
570 return (0);
571 }
572
573 /*
574 * checkIscsiName
575 *
576 * Purpose: Basic string checking on name
577 */
578 static int
579 checkIscsiName(wchar_t *input)
580 {
581 int i;
582
583 for (i = 0; input[i] != 0; i++) {
584 if (!iswalnum(input[i]) && input[i] != '-' &&
585 input[i] != '.' && input[i] != ':') {
586 return (-1);
587 }
588 }
589
590 return (0);
591 }
592
593
594 /*
595 * addViewFunc
596 *
597 * Adds a view entry to a logical unit
598 *
599 */
600 /*ARGSUSED*/
601 static int
602 addViewFunc(int operandLen, char *operands[], cmdOptions_t *options,
603 void *args)
604 {
605 stmfViewEntry viewEntry;
606 stmfGuid inGuid;
607 unsigned int guid[sizeof (stmfGuid)];
608 uint16_t inputLuNbr;
609 int ret = 0;
610 int stmfRet;
611 int i;
612 char sGuid[GUID_INPUT + 1];
613
614 bzero(&viewEntry, sizeof (viewEntry));
615 /* init view entry structure */
616 viewEntry.allHosts = B_TRUE;
617 viewEntry.allTargets = B_TRUE;
618 viewEntry.luNbrValid = B_FALSE;
619
620 /* check input length */
621 if (strlen(operands[0]) != GUID_INPUT) {
622 (void) fprintf(stderr, "%s: %s: %s%d%s\n", cmdName, operands[0],
623 gettext("must be "), GUID_INPUT,
624 gettext(" hexadecimal digits"));
625 return (1);
626 }
627
628 for (; options->optval; options++) {
629 switch (options->optval) {
630 /* logical unit number */
631 case 'n':
632 viewEntry.luNbrValid = B_TRUE;
633 inputLuNbr = atoi(options->optarg);
634 if (inputLuNbr > MAX_LU_NBR) {
635 (void) fprintf(stderr, "%s: %d: %s\n",
636 cmdName, inputLuNbr,
637 gettext("Logical unit number"
638 " must be less than 16384"));
639 return (1);
640 }
641 viewEntry.luNbr[0] = inputLuNbr >> 8;
642 viewEntry.luNbr[1] = inputLuNbr & 0xff;
643 break;
644 /* host group */
645 case 'h':
646 viewEntry.allHosts = B_FALSE;
647 bcopy(options->optarg, viewEntry.hostGroup,
648 strlen(options->optarg));
649 break;
650 /* target group */
651 case 't':
652 viewEntry.allTargets = B_FALSE;
653 bcopy(options->optarg, viewEntry.targetGroup,
654 strlen(options->optarg));
655 break;
656 default:
657 (void) fprintf(stderr, "%s: %c: %s\n",
658 cmdName, options->optval,
659 gettext("unknown option"));
660 return (1);
661 }
662 }
663
664 /* convert to lower case for scan */
665 for (i = 0; i < 32; i++)
666 sGuid[i] = tolower(operands[0][i]);
667 sGuid[i] = 0;
668
669 (void) sscanf(sGuid, "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
670 &guid[0], &guid[1], &guid[2], &guid[3], &guid[4], &guid[5],
671 &guid[6], &guid[7], &guid[8], &guid[9], &guid[10], &guid[11],
672 &guid[12], &guid[13], &guid[14], &guid[15]);
673
674 for (i = 0; i < sizeof (stmfGuid); i++) {
675 inGuid.guid[i] = guid[i];
676 }
677
678 /* add the view entry */
679 stmfRet = stmfAddViewEntry(&inGuid, &viewEntry);
680 switch (stmfRet) {
681 case STMF_STATUS_SUCCESS:
682 break;
683 case STMF_ERROR_EXISTS:
684 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
685 operands[0], gettext("already exists"));
686 ret++;
687 break;
688 case STMF_ERROR_BUSY:
689 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
690 operands[0], gettext("resource busy"));
691 ret++;
692 break;
693 case STMF_ERROR_SERVICE_NOT_FOUND:
694 (void) fprintf(stderr, "%s: %s\n", cmdName,
695 gettext("STMF service not found"));
696 ret++;
697 break;
698 case STMF_ERROR_PERM:
699 (void) fprintf(stderr, "%s: %s\n", cmdName,
700 gettext("permission denied"));
701 ret++;
702 break;
703 case STMF_ERROR_LUN_IN_USE:
704 (void) fprintf(stderr, "%s: %s\n", cmdName,
705 gettext("LUN already in use"));
706 ret++;
707 break;
708 case STMF_ERROR_VE_CONFLICT:
709 (void) fprintf(stderr, "%s: %s\n", cmdName,
710 gettext("view entry exists"));
711 ret++;
712 break;
713 case STMF_ERROR_CONFIG_NONE:
714 (void) fprintf(stderr, "%s: %s\n", cmdName,
715 gettext("STMF service is not initialized"));
716 ret++;
717 break;
718 case STMF_ERROR_SERVICE_DATA_VERSION:
719 (void) fprintf(stderr, "%s: %s\n", cmdName,
720 gettext("STMF service version incorrect"));
721 ret++;
722 break;
723 case STMF_ERROR_INVALID_HG:
724 (void) fprintf(stderr, "%s: %s\n", cmdName,
725 gettext("invalid host group"));
726 ret++;
727 break;
728 case STMF_ERROR_INVALID_TG:
729 (void) fprintf(stderr, "%s: %s\n", cmdName,
730 gettext("invalid target group"));
731 ret++;
732 break;
733 default:
734 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
735 operands[0], gettext("unknown error"));
736 ret++;
737 break;
738 }
739
740 return (ret);
741 }
742
743 /*
744 * createHostGroupFunc
745 *
746 * Create a host group
747 *
748 */
749 /*ARGSUSED*/
750 static int
751 createHostGroupFunc(int operandLen, char *operands[],
752 cmdOptions_t *options, void *args)
753 {
754 int ret = 0;
755 int stmfRet;
756 wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};
757 stmfGroupName groupName = {0};
758
759 (void) strlcpy(groupName, operands[0], sizeof (groupName));
760 (void) mbstowcs(groupNamePrint, (char *)groupName,
761 sizeof (stmfGroupName) - 1);
762 /* call create group */
763 stmfRet = stmfCreateHostGroup(&groupName);
764 switch (stmfRet) {
765 case STMF_STATUS_SUCCESS:
766 break;
767 case STMF_ERROR_EXISTS:
768 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
769 operands[0], gettext("already exists"));
770 ret++;
771 break;
772 case STMF_ERROR_BUSY:
773 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
774 operands[0], gettext("resource busy"));
775 ret++;
776 break;
777 case STMF_ERROR_SERVICE_NOT_FOUND:
778 (void) fprintf(stderr, "%s: %s\n", cmdName,
779 gettext("STMF service not found"));
780 ret++;
781 break;
782 case STMF_ERROR_PERM:
783 (void) fprintf(stderr, "%s: %s\n", cmdName,
784 gettext("permission denied"));
785 ret++;
786 break;
787 case STMF_ERROR_SERVICE_DATA_VERSION:
788 (void) fprintf(stderr, "%s: %s\n", cmdName,
789 gettext("STMF service version incorrect"));
790 ret++;
791 break;
792 default:
793 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
794 operands[0], gettext("unknown error"));
795 ret++;
796 break;
797 }
798
799 return (ret);
800 }
801
802 /*
803 * createLuFunc
804 *
805 * Create a logical unit
806 *
807 */
808 /*ARGSUSED*/
809 static int
810 createLuFunc(int operandLen, char *operands[], cmdOptions_t *options,
811 void *args)
812 {
813 luResource hdl = NULL;
814 int ret = 0;
815 int stmfRet = 0;
816 char guidAsciiBuf[33];
817 stmfGuid createdGuid;
818
819 stmfRet = stmfCreateLuResource(STMF_DISK, &hdl);
820
821 if (stmfRet != STMF_STATUS_SUCCESS) {
822 (void) fprintf(stderr, "%s: %s\n",
823 cmdName, gettext("Failure to create lu resource\n"));
824 return (1);
825 }
826
827 for (; options->optval; options++) {
828 switch (options->optval) {
829 case 'p':
830 ret = setLuPropFromInput(hdl, options->optarg);
831 if (ret != 0) {
832 (void) stmfFreeLuResource(hdl);
833 return (1);
834 }
835 break;
836 case 's':
837 stmfRet = stmfSetLuProp(hdl, STMF_LU_PROP_SIZE,
838 options->optarg);
839 if (stmfRet != STMF_STATUS_SUCCESS) {
840 (void) fprintf(stderr, "%s: %c: %s\n",
841 cmdName, options->optval,
842 gettext("size param invalid"));
843 (void) stmfFreeLuResource(hdl);
844 return (1);
845 }
846 break;
847 default:
848 (void) fprintf(stderr, "%s: %c: %s\n",
849 cmdName, options->optval,
850 gettext("unknown option"));
851 return (1);
852 }
853 }
854
855 stmfRet = stmfSetLuProp(hdl, STMF_LU_PROP_FILENAME, operands[0]);
856
857 if (stmfRet != STMF_STATUS_SUCCESS) {
858 (void) fprintf(stderr, "%s: %s\n",
859 cmdName, gettext("could not set filename"));
860 return (1);
861 }
862
863 stmfRet = stmfCreateLu(hdl, &createdGuid);
864 switch (stmfRet) {
865 case STMF_STATUS_SUCCESS:
866 break;
867 case STMF_ERROR_BUSY:
868 case STMF_ERROR_LU_BUSY:
869 (void) fprintf(stderr, "%s: %s\n", cmdName,
870 gettext("resource busy"));
871 ret++;
872 break;
873 case STMF_ERROR_PERM:
874 (void) fprintf(stderr, "%s: %s\n", cmdName,
875 gettext("permission denied"));
876 ret++;
877 break;
878 case STMF_ERROR_FILE_IN_USE:
879 (void) fprintf(stderr, "%s: filename %s: %s\n", cmdName,
880 operands[0], gettext("in use"));
881 ret++;
882 break;
883 case STMF_ERROR_INVALID_BLKSIZE:
884 (void) fprintf(stderr, "%s: %s\n", cmdName,
885 gettext("invalid block size"));
886 ret++;
887 break;
888 case STMF_ERROR_GUID_IN_USE:
889 (void) fprintf(stderr, "%s: %s\n", cmdName,
890 gettext("guid in use"));
891 ret++;
892 break;
893 case STMF_ERROR_META_FILE_NAME:
894 (void) fprintf(stderr, "%s: %s\n", cmdName,
895 gettext("meta file error"));
896 ret++;
897 break;
898 case STMF_ERROR_DATA_FILE_NAME:
899 (void) fprintf(stderr, "%s: %s\n", cmdName,
900 gettext("data file error"));
901 ret++;
902 break;
903 case STMF_ERROR_FILE_SIZE_INVALID:
904 (void) fprintf(stderr, "%s: %s\n", cmdName,
905 gettext("file size invalid"));
906 ret++;
907 break;
908 case STMF_ERROR_SIZE_OUT_OF_RANGE:
909 (void) fprintf(stderr, "%s: %s\n", cmdName,
910 gettext("invalid size"));
911 ret++;
912 break;
913 case STMF_ERROR_META_CREATION:
914 (void) fprintf(stderr, "%s: %s\n", cmdName,
915 gettext("could not create meta file"));
916 ret++;
917 break;
918 case STMF_ERROR_WRITE_CACHE_SET:
919 (void) fprintf(stderr, "%s: %s\n", cmdName,
920 gettext("could not set write cache"));
921 ret++;
922 break;
923 default:
924 (void) fprintf(stderr, "%s: %s\n", cmdName,
925 gettext("unknown error"));
926 ret++;
927 break;
928 }
929
930 if (ret != 0) {
931 goto done;
932 }
933
934 (void) snprintf(guidAsciiBuf, sizeof (guidAsciiBuf),
935 "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"
936 "%02X%02X%02X%02X%02X%02X",
937 createdGuid.guid[0], createdGuid.guid[1], createdGuid.guid[2],
938 createdGuid.guid[3], createdGuid.guid[4], createdGuid.guid[5],
939 createdGuid.guid[6], createdGuid.guid[7], createdGuid.guid[8],
940 createdGuid.guid[9], createdGuid.guid[10], createdGuid.guid[11],
941 createdGuid.guid[12], createdGuid.guid[13], createdGuid.guid[14],
942 createdGuid.guid[15]);
943 (void) printf("Logical unit created: %s\n", guidAsciiBuf);
944
945 done:
946 (void) stmfFreeLuResource(hdl);
947 return (ret);
948 }
949
950 /*
951 * createLuFunc
952 *
953 * Create a logical unit
954 *
955 */
956 /*ARGSUSED*/
957 static int
958 modifyLuFunc(int operandLen, char *operands[], cmdOptions_t *options,
959 void *args)
960 {
961 stmfGuid inGuid;
962 unsigned int guid[sizeof (stmfGuid)];
963 int ret = 0;
964 int i;
965 char *fname = NULL;
966 char *lasts = NULL;
967 char sGuid[GUID_INPUT + 1];
968 char *prop = NULL;
969 char *propVal = NULL;
970 boolean_t fnameUsed = B_FALSE;
971 uint32_t propId;
972 cmdOptions_t *optionStart = options;
973
974
975 for (; options->optval; options++) {
976 switch (options->optval) {
977 case 'f':
978 fnameUsed = B_TRUE;
979 fname = operands[0];
980 break;
981 }
982 }
983 options = optionStart;
984
985 /* check input length */
986 if (!fnameUsed && strlen(operands[0]) != GUID_INPUT) {
987 (void) fprintf(stderr, "%s: %s: %s%d%s\n", cmdName, operands[0],
988 gettext("must be "), GUID_INPUT,
989 gettext(" hexadecimal digits"));
990 return (1);
991 }
992
993 if (!fnameUsed) {
994 /* convert to lower case for scan */
995 for (i = 0; i < 32; i++)
996 sGuid[i] = tolower(operands[0][i]);
997 sGuid[i] = 0;
998 (void) sscanf(sGuid,
999 "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
1000 &guid[0], &guid[1], &guid[2], &guid[3], &guid[4], &guid[5],
1001 &guid[6], &guid[7], &guid[8], &guid[9], &guid[10],
1002 &guid[11], &guid[12], &guid[13], &guid[14], &guid[15]);
1003
1004 for (i = 0; i < sizeof (stmfGuid); i++) {
1005 inGuid.guid[i] = guid[i];
1006 }
1007 }
1008
1009 for (; options->optval; options++) {
1010 switch (options->optval) {
1011 case 'p':
1012 prop = strtok_r(options->optarg, "=", &lasts);
1013 propVal = strtok_r(NULL, "=", &lasts);
1014 ret = convertCharToPropId(prop, &propId);
1015 if (ret != 0) {
1016 (void) fprintf(stderr, "%s: %s: %s\n",
1017 cmdName,
1018 gettext("invalid property specified"),
1019 prop);
1020 return (1);
1021 }
1022 if (propVal == NULL &&
1023 propId != STMF_LU_PROP_MGMT_URL) {
1024 (void) fprintf(stderr, "%s: %s: %s\n",
1025 cmdName, options->optarg,
1026 gettext("invalid property specifier"
1027 "- prop=val\n"));
1028 return (1);
1029 }
1030 if (propVal == NULL) {
1031 ret = callModify(fname, &inGuid, propId,
1032 "", prop);
1033 } else {
1034 ret = callModify(fname, &inGuid, propId,
1035 propVal, prop);
1036 }
1037 if (ret != 0) {
1038 return (1);
1039 }
1040 break;
1041 case 's':
1042 if (callModify(fname, &inGuid,
1043 STMF_LU_PROP_SIZE, options->optarg,
1044 "size") != 0) {
1045 return (1);
1046 }
1047 break;
1048 case 'f':
1049 break;
1050 default:
1051 (void) fprintf(stderr, "%s: %c: %s\n",
1052 cmdName, options->optval,
1053 gettext("unknown option"));
1054 return (1);
1055 }
1056 }
1057 return (ret);
1058 }
1059
1060 static int
1061 callModify(char *fname, stmfGuid *luGuid, uint32_t prop, const char *propVal,
1062 const char *propString)
1063 {
1064 int ret = 0;
1065 int stmfRet = 0;
1066
1067 if (!fname) {
1068 stmfRet = stmfModifyLu(luGuid, prop, propVal);
1069 } else {
1070 stmfRet = stmfModifyLuByFname(STMF_DISK, fname, prop,
1071 propVal);
1072 }
1073 switch (stmfRet) {
1074 case STMF_STATUS_SUCCESS:
1075 break;
1076 case STMF_ERROR_BUSY:
1077 case STMF_ERROR_LU_BUSY:
1078 (void) fprintf(stderr, "%s: %s\n", cmdName,
1079 gettext("resource busy"));
1080 ret++;
1081 break;
1082 case STMF_ERROR_PERM:
1083 (void) fprintf(stderr, "%s: %s\n", cmdName,
1084 gettext("permission denied"));
1085 ret++;
1086 break;
1087 case STMF_ERROR_INVALID_BLKSIZE:
1088 (void) fprintf(stderr, "%s: %s\n", cmdName,
1089 gettext("invalid block size"));
1090 ret++;
1091 break;
1092 case STMF_ERROR_GUID_IN_USE:
1093 (void) fprintf(stderr, "%s: %s\n", cmdName,
1094 gettext("guid in use"));
1095 ret++;
1096 break;
1097 case STMF_ERROR_META_FILE_NAME:
1098 (void) fprintf(stderr, "%s: %s\n", cmdName,
1099 gettext("meta file error"));
1100 ret++;
1101 break;
1102 case STMF_ERROR_DATA_FILE_NAME:
1103 (void) fprintf(stderr, "%s: %s\n", cmdName,
1104 gettext("data file error"));
1105 ret++;
1106 break;
1107 case STMF_ERROR_FILE_SIZE_INVALID:
1108 (void) fprintf(stderr, "%s: %s\n", cmdName,
1109 gettext("file size invalid"));
1110 ret++;
1111 break;
1112 case STMF_ERROR_SIZE_OUT_OF_RANGE:
1113 (void) fprintf(stderr, "%s: %s\n", cmdName,
1114 gettext("invalid size"));
1115 ret++;
1116 break;
1117 case STMF_ERROR_META_CREATION:
1118 (void) fprintf(stderr, "%s: %s\n", cmdName,
1119 gettext("could not create meta file"));
1120 ret++;
1121 break;
1122 case STMF_ERROR_INVALID_PROP:
1123 (void) fprintf(stderr, "%s: %s\n", cmdName,
1124 gettext("invalid property for modify"));
1125 ret++;
1126 break;
1127 case STMF_ERROR_WRITE_CACHE_SET:
1128 (void) fprintf(stderr, "%s: %s\n", cmdName,
1129 gettext("could not set write cache"));
1130 ret++;
1131 break;
1132 case STMF_ERROR_ACCESS_STATE_SET:
1133 (void) fprintf(stderr, "%s: %s\n", cmdName,
1134 gettext("cannot modify while in standby mode"));
1135 ret++;
1136 break;
1137 default:
1138 (void) fprintf(stderr, "%s: %s: %s: %d\n", cmdName,
1139 gettext("could not set property"), propString,
1140 stmfRet);
1141 ret++;
1142 break;
1143 }
1144
1145 return (ret);
1146 }
1147
1148
1149 /*
1150 * importLuFunc
1151 *
1152 * Create a logical unit
1153 *
1154 */
1155 /*ARGSUSED*/
1156 static int
1157 importLuFunc(int operandLen, char *operands[], cmdOptions_t *options,
1158 void *args)
1159 {
1160 int stmfRet = 0;
1161 int ret = 0;
1162 char guidAsciiBuf[33];
1163 stmfGuid createdGuid;
1164
1165 stmfRet = stmfImportLu(STMF_DISK, operands[0], &createdGuid);
1166 switch (stmfRet) {
1167 case STMF_STATUS_SUCCESS:
1168 break;
1169 case STMF_ERROR_BUSY:
1170 case STMF_ERROR_LU_BUSY:
1171 (void) fprintf(stderr, "%s: %s\n", cmdName,
1172 gettext("resource busy"));
1173 ret++;
1174 break;
1175 case STMF_ERROR_PERM:
1176 (void) fprintf(stderr, "%s: %s\n", cmdName,
1177 gettext("permission denied"));
1178 ret++;
1179 break;
1180 case STMF_ERROR_FILE_IN_USE:
1181 (void) fprintf(stderr, "%s: filename %s: %s\n", cmdName,
1182 operands[0], gettext("in use"));
1183 ret++;
1184 break;
1185 case STMF_ERROR_GUID_IN_USE:
1186 (void) fprintf(stderr, "%s: %s\n", cmdName,
1187 gettext("guid in use"));
1188 ret++;
1189 break;
1190 case STMF_ERROR_META_FILE_NAME:
1191 (void) fprintf(stderr, "%s: %s\n", cmdName,
1192 gettext("meta file error"));
1193 ret++;
1194 break;
1195 case STMF_ERROR_DATA_FILE_NAME:
1196 (void) fprintf(stderr, "%s: %s\n", cmdName,
1197 gettext("data file error"));
1198 ret++;
1199 break;
1200 case STMF_ERROR_META_CREATION:
1201 (void) fprintf(stderr, "%s: %s\n", cmdName,
1202 gettext("could not create meta file"));
1203 ret++;
1204 break;
1205 case STMF_ERROR_WRITE_CACHE_SET:
1206 (void) fprintf(stderr, "%s: %s\n", cmdName,
1207 gettext("could not set write cache"));
1208 ret++;
1209 break;
1210 default:
1211 (void) fprintf(stderr, "%s: %s\n", cmdName,
1212 gettext("unknown error"));
1213 ret++;
1214 break;
1215 }
1216
1217 if (ret != STMF_STATUS_SUCCESS) {
1218 goto done;
1219 }
1220
1221 (void) snprintf(guidAsciiBuf, sizeof (guidAsciiBuf),
1222 "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"
1223 "%02X%02X%02X%02X%02X%02X",
1224 createdGuid.guid[0], createdGuid.guid[1], createdGuid.guid[2],
1225 createdGuid.guid[3], createdGuid.guid[4], createdGuid.guid[5],
1226 createdGuid.guid[6], createdGuid.guid[7], createdGuid.guid[8],
1227 createdGuid.guid[9], createdGuid.guid[10], createdGuid.guid[11],
1228 createdGuid.guid[12], createdGuid.guid[13], createdGuid.guid[14],
1229 createdGuid.guid[15]);
1230 (void) printf("Logical unit imported: %s\n", guidAsciiBuf);
1231
1232 done:
1233 return (ret);
1234 }
1235
1236 static int
1237 setLuPropFromInput(luResource hdl, char *optarg)
1238 {
1239 char *prop = NULL;
1240 char *propVal = NULL;
1241 char *lasts = NULL;
1242 uint32_t propId;
1243 int ret = 0;
1244
1245 prop = strtok_r(optarg, "=", &lasts);
1246 if ((propVal = strtok_r(NULL, "=", &lasts)) == NULL) {
1247 (void) fprintf(stderr, "%s: %s: %s\n",
1248 cmdName, optarg,
1249 gettext("invalid property specifier - prop=val\n"));
1250 return (1);
1251 }
1252
1253 ret = convertCharToPropId(prop, &propId);
1254 if (ret != 0) {
1255 (void) fprintf(stderr, "%s: %s: %s\n",
1256 cmdName, gettext("invalid property specified"), prop);
1257 return (1);
1258 }
1259
1260 ret = stmfSetLuProp(hdl, propId, propVal);
1261 if (ret != STMF_STATUS_SUCCESS) {
1262 (void) fprintf(stderr, "%s: %s %s: ",
1263 cmdName, gettext("unable to set"), prop);
1264 switch (ret) {
1265 case STMF_ERROR_INVALID_PROPSIZE:
1266 (void) fprintf(stderr, "invalid length\n");
1267 break;
1268 case STMF_ERROR_INVALID_ARG:
1269 (void) fprintf(stderr, "bad format\n");
1270 break;
1271 default:
1272 (void) fprintf(stderr, "\n");
1273 break;
1274 }
1275 return (1);
1276 }
1277
1278 return (0);
1279 }
1280
1281 static int
1282 convertCharToPropId(char *prop, uint32_t *propId)
1283 {
1284 if (strcasecmp(prop, GUID) == 0) {
1285 *propId = STMF_LU_PROP_GUID;
1286 } else if (strcasecmp(prop, ALIAS) == 0) {
1287 *propId = STMF_LU_PROP_ALIAS;
1288 } else if (strcasecmp(prop, VID) == 0) {
1289 *propId = STMF_LU_PROP_VID;
1290 } else if (strcasecmp(prop, PID) == 0) {
1291 *propId = STMF_LU_PROP_PID;
1292 } else if (strcasecmp(prop, WRITE_PROTECT) == 0) {
1293 *propId = STMF_LU_PROP_WRITE_PROTECT;
1294 } else if (strcasecmp(prop, WRITEBACK_CACHE_DISABLE) == 0) {
1295 *propId = STMF_LU_PROP_WRITE_CACHE_DISABLE;
1296 } else if (strcasecmp(prop, BLOCK_SIZE) == 0) {
1297 *propId = STMF_LU_PROP_BLOCK_SIZE;
1298 } else if (strcasecmp(prop, SERIAL_NUMBER) == 0) {
1299 *propId = STMF_LU_PROP_SERIAL_NUM;
1300 } else if (strcasecmp(prop, COMPANY_ID) == 0) {
1301 *propId = STMF_LU_PROP_COMPANY_ID;
1302 } else if (strcasecmp(prop, META_FILE) == 0) {
1303 *propId = STMF_LU_PROP_META_FILENAME;
1304 } else if (strcasecmp(prop, MGMT_URL) == 0) {
1305 *propId = STMF_LU_PROP_MGMT_URL;
1306 } else if (strcasecmp(prop, HOST_ID) == 0) {
1307 *propId = STMF_LU_PROP_HOST_ID;
1308 } else {
1309 return (1);
1310 }
1311 return (0);
1312 }
1313
1314 /*
1315 * deleteLuFunc
1316 *
1317 * Delete a logical unit
1318 *
1319 */
1320 /*ARGSUSED*/
1321 static int
1322 deleteLuFunc(int operandLen, char *operands[], cmdOptions_t *options,
1323 void *args)
1324 {
1325 int i, j;
1326 int ret = 0;
1327 int stmfRet;
1328 unsigned int inGuid[sizeof (stmfGuid)];
1329 stmfGuid delGuid;
1330 boolean_t keepViews = B_FALSE;
1331 boolean_t viewEntriesRemoved = B_FALSE;
1332 boolean_t noLunFound = B_FALSE;
1333 boolean_t views = B_FALSE;
1334 boolean_t notValidHexNumber = B_FALSE;
1335 char sGuid[GUID_INPUT + 1];
1336 stmfViewEntryList *viewEntryList = NULL;
1337
1338 for (; options->optval; options++) {
1339 switch (options->optval) {
1340 /* Keep views for logical unit */
1341 case 'k':
1342 keepViews = B_TRUE;
1343 break;
1344 default:
1345 (void) fprintf(stderr, "%s: %c: %s\n",
1346 cmdName, options->optval,
1347 gettext("unknown option"));
1348 return (1);
1349 }
1350 }
1351
1352
1353 for (i = 0; i < operandLen; i++) {
1354 for (j = 0; j < GUID_INPUT; j++) {
1355 if (!isxdigit(operands[i][j])) {
1356 notValidHexNumber = B_TRUE;
1357 break;
1358 }
1359 sGuid[j] = tolower(operands[i][j]);
1360 }
1361 if ((notValidHexNumber == B_TRUE) ||
1362 (strlen(operands[i]) != GUID_INPUT)) {
1363 (void) fprintf(stderr, "%s: %s: %s%d%s\n",
1364 cmdName, operands[i], gettext("must be "),
1365 GUID_INPUT,
1366 gettext(" hexadecimal digits long"));
1367 notValidHexNumber = B_FALSE;
1368 ret++;
1369 continue;
1370 }
1371
1372 sGuid[j] = 0;
1373
1374 (void) sscanf(sGuid,
1375 "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
1376 &inGuid[0], &inGuid[1], &inGuid[2], &inGuid[3],
1377 &inGuid[4], &inGuid[5], &inGuid[6], &inGuid[7],
1378 &inGuid[8], &inGuid[9], &inGuid[10], &inGuid[11],
1379 &inGuid[12], &inGuid[13], &inGuid[14], &inGuid[15]);
1380
1381 for (j = 0; j < sizeof (stmfGuid); j++) {
1382 delGuid.guid[j] = inGuid[j];
1383 }
1384
1385 stmfRet = stmfDeleteLu(&delGuid);
1386 switch (stmfRet) {
1387 case STMF_STATUS_SUCCESS:
1388 break;
1389 case STMF_ERROR_NOT_FOUND:
1390 noLunFound = B_TRUE;
1391 break;
1392 case STMF_ERROR_BUSY:
1393 (void) fprintf(stderr, "%s: %s\n", cmdName,
1394 gettext("resource busy"));
1395 ret++;
1396 break;
1397 case STMF_ERROR_PERM:
1398 (void) fprintf(stderr, "%s: %s\n", cmdName,
1399 gettext("permission denied"));
1400 ret++;
1401 break;
1402 default:
1403 (void) fprintf(stderr, "%s: %s\n", cmdName,
1404 gettext("unknown error"));
1405 ret++;
1406 break;
1407 }
1408
1409 if (!keepViews) {
1410 stmfRet = stmfGetViewEntryList(&delGuid,
1411 &viewEntryList);
1412 if (stmfRet == STMF_STATUS_SUCCESS) {
1413 for (j = 0; j < viewEntryList->cnt; j++) {
1414 (void) stmfRemoveViewEntry(&delGuid,
1415 viewEntryList->ve[j].veIndex);
1416 }
1417 /* check if viewEntryList is empty */
1418 if (viewEntryList->cnt != 0)
1419 viewEntriesRemoved = B_TRUE;
1420 stmfFreeMemory(viewEntryList);
1421 } else {
1422 (void) fprintf(stderr, "%s: %s\n", cmdName,
1423 gettext("unable to remove view entries\n"));
1424 ret++;
1425 }
1426
1427 }
1428 if (keepViews) {
1429 stmfRet = stmfGetViewEntryList(&delGuid,
1430 &viewEntryList);
1431 if (stmfRet == STMF_STATUS_SUCCESS) {
1432 views = B_TRUE;
1433 stmfFreeMemory(viewEntryList);
1434 }
1435 }
1436
1437 if ((!viewEntriesRemoved && noLunFound && !views) ||
1438 (!views && keepViews && noLunFound)) {
1439 (void) fprintf(stderr, "%s: %s: %s\n",
1440 cmdName, sGuid,
1441 gettext("not found"));
1442 ret++;
1443 }
1444 noLunFound = viewEntriesRemoved = views = B_FALSE;
1445 }
1446 return (ret);
1447 }
1448
1449
1450 /*
1451 * createTargetGroupFunc
1452 *
1453 * Create a target group
1454 *
1455 */
1456 /*ARGSUSED*/
1457 static int
1458 createTargetGroupFunc(int operandLen, char *operands[], cmdOptions_t *options,
1459 void *args)
1460 {
1461 int ret = 0;
1462 int stmfRet;
1463 wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};
1464 stmfGroupName groupName = {0};
1465
1466 (void) strlcpy(groupName, operands[0], sizeof (groupName));
1467 (void) mbstowcs(groupNamePrint, (char *)groupName,
1468 sizeof (stmfGroupName) - 1);
1469 /* call create group */
1470 stmfRet = stmfCreateTargetGroup(&groupName);
1471 switch (stmfRet) {
1472 case STMF_STATUS_SUCCESS:
1473 break;
1474 case STMF_ERROR_EXISTS:
1475 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
1476 groupNamePrint, gettext("already exists"));
1477 ret++;
1478 break;
1479 case STMF_ERROR_BUSY:
1480 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
1481 groupNamePrint, gettext("resource busy"));
1482 ret++;
1483 break;
1484 case STMF_ERROR_PERM:
1485 (void) fprintf(stderr, "%s: %s\n", cmdName,
1486 gettext("permission denied"));
1487 ret++;
1488 break;
1489 case STMF_ERROR_SERVICE_NOT_FOUND:
1490 (void) fprintf(stderr, "%s: %s\n", cmdName,
1491 gettext("STMF service not found"));
1492 ret++;
1493 break;
1494 case STMF_ERROR_SERVICE_DATA_VERSION:
1495 (void) fprintf(stderr, "%s: %s\n", cmdName,
1496 gettext("STMF service version incorrect"));
1497 ret++;
1498 break;
1499 default:
1500 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
1501 groupNamePrint, gettext("unknown error"));
1502 ret++;
1503 break;
1504 }
1505
1506 return (ret);
1507 }
1508
1509 /*
1510 * deleteHostGroupFunc
1511 *
1512 * Delete a host group
1513 *
1514 */
1515 /*ARGSUSED*/
1516 static int
1517 deleteHostGroupFunc(int operandLen, char *operands[],
1518 cmdOptions_t *options, void *args)
1519 {
1520 int ret = 0;
1521 int stmfRet;
1522 wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};
1523 stmfGroupName groupName = {0};
1524
1525 (void) strlcpy(groupName, operands[0], sizeof (groupName));
1526 (void) mbstowcs(groupNamePrint, (char *)groupName,
1527 sizeof (stmfGroupName) - 1);
1528 /* call delete group */
1529 stmfRet = stmfDeleteHostGroup(&groupName);
1530 switch (stmfRet) {
1531 case STMF_STATUS_SUCCESS:
1532 break;
1533 case STMF_ERROR_NOT_FOUND:
1534 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
1535 groupNamePrint, gettext("not found"));
1536 ret++;
1537 break;
1538 case STMF_ERROR_BUSY:
1539 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
1540 groupNamePrint, gettext("resource busy"));
1541 ret++;
1542 break;
1543 case STMF_ERROR_SERVICE_NOT_FOUND:
1544 (void) fprintf(stderr, "%s: %s\n", cmdName,
1545 gettext("STMF service not found"));
1546 ret++;
1547 break;
1548 case STMF_ERROR_PERM:
1549 (void) fprintf(stderr, "%s: %s\n", cmdName,
1550 gettext("permission denied"));
1551 ret++;
1552 break;
1553 case STMF_ERROR_GROUP_IN_USE:
1554 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
1555 groupNamePrint,
1556 gettext("group is in use by existing view entry"));
1557 ret++;
1558 break;
1559 case STMF_ERROR_SERVICE_DATA_VERSION:
1560 (void) fprintf(stderr, "%s: %s\n", cmdName,
1561 gettext("STMF service version incorrect"));
1562 ret++;
1563 break;
1564 default:
1565 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
1566 groupNamePrint, gettext("unknown error"));
1567 ret++;
1568 break;
1569 }
1570
1571 return (ret);
1572 }
1573
1574 /*
1575 * deleteTargetGroupFunc
1576 *
1577 * Delete a target group
1578 *
1579 */
1580 /*ARGSUSED*/
1581 static int
1582 deleteTargetGroupFunc(int operandLen, char *operands[], cmdOptions_t *options,
1583 void *args)
1584 {
1585 int ret = 0;
1586 int stmfRet;
1587 wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};
1588 stmfGroupName groupName = {0};
1589
1590 (void) strlcpy(groupName, operands[0], sizeof (groupName));
1591 (void) mbstowcs(groupNamePrint, (char *)groupName,
1592 sizeof (stmfGroupName) - 1);
1593 /* call delete group */
1594 stmfRet = stmfDeleteTargetGroup(&groupName);
1595 switch (stmfRet) {
1596 case STMF_STATUS_SUCCESS:
1597 break;
1598 case STMF_ERROR_NOT_FOUND:
1599 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
1600 groupNamePrint, gettext("not found"));
1601 ret++;
1602 break;
1603 case STMF_ERROR_BUSY:
1604 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
1605 groupNamePrint, gettext("resource busy"));
1606 ret++;
1607 break;
1608 case STMF_ERROR_SERVICE_NOT_FOUND:
1609 (void) fprintf(stderr, "%s: %s\n", cmdName,
1610 gettext("STMF service not found"));
1611 ret++;
1612 break;
1613 case STMF_ERROR_PERM:
1614 (void) fprintf(stderr, "%s: %s\n", cmdName,
1615 gettext("permission denied"));
1616 ret++;
1617 break;
1618 case STMF_ERROR_GROUP_IN_USE:
1619 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
1620 groupNamePrint,
1621 gettext("group is in use by existing view entry"));
1622 ret++;
1623 break;
1624 case STMF_ERROR_SERVICE_DATA_VERSION:
1625 (void) fprintf(stderr, "%s: %s\n", cmdName,
1626 gettext("STMF service version incorrect"));
1627 ret++;
1628 break;
1629 default:
1630 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
1631 groupNamePrint, gettext("unknown error"));
1632 ret++;
1633 break;
1634 }
1635
1636 return (ret);
1637 }
1638
1639 /*
1640 * listHostGroupFunc
1641 *
1642 * Lists the specified host groups or all if none are specified
1643 *
1644 */
1645 /*ARGSUSED*/
1646 static int
1647 listHostGroupFunc(int operandLen, char *operands[], cmdOptions_t *options,
1648 void *args)
1649 {
1650 int ret = 0;
1651 int stmfRet;
1652 int i, j, outerLoop;
1653 boolean_t verbose = B_FALSE;
1654 boolean_t found = B_TRUE;
1655 boolean_t operandEntered;
1656 stmfGroupList *groupList;
1657 stmfGroupProperties *groupProps;
1658 wchar_t operandName[sizeof (stmfGroupName)];
1659 wchar_t groupNamePrint[sizeof (stmfGroupName)];
1660
1661 for (; options->optval; options++) {
1662 switch (options->optval) {
1663 case 'v':
1664 verbose = B_TRUE;
1665 break;
1666 default:
1667 (void) fprintf(stderr, "%s: %c: %s\n",
1668 cmdName, options->optval,
1669 gettext("unknown option"));
1670 return (1);
1671 }
1672 }
1673
1674 if (operandLen > 0) {
1675 outerLoop = operandLen;
1676 operandEntered = B_TRUE;
1677 } else {
1678 outerLoop = 1;
1679 operandEntered = B_FALSE;
1680 }
1681
1682 stmfRet = stmfGetHostGroupList(&groupList);
1683 if (stmfRet != STMF_STATUS_SUCCESS) {
1684 switch (stmfRet) {
1685 case STMF_ERROR_BUSY:
1686 (void) fprintf(stderr, "%s: %s\n", cmdName,
1687 gettext("resource busy"));
1688 break;
1689 case STMF_ERROR_SERVICE_NOT_FOUND:
1690 (void) fprintf(stderr, "%s: %s\n", cmdName,
1691 gettext("STMF service not found"));
1692 break;
1693 case STMF_ERROR_PERM:
1694 (void) fprintf(stderr, "%s: %s\n", cmdName,
1695 gettext("permission denied"));
1696 break;
1697 case STMF_ERROR_SERVICE_DATA_VERSION:
1698 (void) fprintf(stderr, "%s: %s\n", cmdName,
1699 gettext("STMF service version incorrect"));
1700 break;
1701 default:
1702 (void) fprintf(stderr, "%s: %s\n", cmdName,
1703 gettext("unknown error"));
1704 break;
1705 }
1706 return (1);
1707 }
1708
1709 for (i = 0; i < outerLoop; i++) {
1710 for (found = B_FALSE, j = 0; j < groupList->cnt; j++) {
1711 (void) mbstowcs(groupNamePrint,
1712 (char *)groupList->name[j],
1713 sizeof (stmfGroupName) - 1);
1714 groupNamePrint[sizeof (stmfGroupName) - 1] = 0;
1715 if (operandEntered) {
1716 (void) mbstowcs(operandName, operands[i],
1717 sizeof (stmfGroupName) - 1);
1718 operandName[sizeof (stmfGroupName) - 1] = 0;
1719 if (wcscmp(operandName, groupNamePrint)
1720 == 0) {
1721 found = B_TRUE;
1722 }
1723 }
1724 if ((found && operandEntered) || !operandEntered) {
1725 (void) printf("Host Group: %ws\n",
1726 groupNamePrint);
1727 if (verbose) {
1728 stmfRet = stmfGetHostGroupMembers(
1729 &(groupList->name[j]), &groupProps);
1730 if (stmfRet != STMF_STATUS_SUCCESS) {
1731 return (1);
1732 }
1733 printGroupProps(groupProps);
1734 }
1735 if (found && operandEntered) {
1736 break;
1737 }
1738 }
1739
1740 }
1741 if (operandEntered && !found) {
1742 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
1743 operands[i], gettext("not found"));
1744 ret = 1;
1745 }
1746 }
1747 return (ret);
1748 }
1749
1750 /*
1751 * printGroupProps
1752 *
1753 * Prints group members for target or host groups
1754 *
1755 */
1756 static void
1757 printGroupProps(stmfGroupProperties *groupProps)
1758 {
1759 int i;
1760 wchar_t memberIdent[sizeof (groupProps->name[0].ident) + 1] = {0};
1761
1762
1763 for (i = 0; i < groupProps->cnt; i++) {
1764 (void) mbstowcs(memberIdent, (char *)groupProps->name[i].ident,
1765 sizeof (groupProps->name[0].ident));
1766 (void) printf("\tMember: %ws\n", memberIdent);
1767 }
1768 }
1769
1770 /*
1771 * listTargetGroupFunc
1772 *
1773 * Lists the specified target groups or all if none are specified
1774 *
1775 */
1776 /*ARGSUSED*/
1777 static int
1778 listTargetGroupFunc(int operandLen, char *operands[], cmdOptions_t *options,
1779 void *args)
1780 {
1781 int ret = 0;
1782 int stmfRet;
1783 int i, j, outerLoop;
1784 boolean_t verbose = B_FALSE;
1785 boolean_t found = B_TRUE;
1786 boolean_t operandEntered;
1787 stmfGroupList *groupList;
1788 stmfGroupProperties *groupProps;
1789 wchar_t operandName[sizeof (stmfGroupName)];
1790 wchar_t groupNamePrint[sizeof (stmfGroupName)];
1791
1792 for (; options->optval; options++) {
1793 switch (options->optval) {
1794 case 'v':
1795 verbose = B_TRUE;
1796 break;
1797 default:
1798 (void) fprintf(stderr, "%s: %c: %s\n",
1799 cmdName, options->optval,
1800 gettext("unknown option"));
1801 return (1);
1802 }
1803 }
1804
1805 if (operandLen > 0) {
1806 outerLoop = operandLen;
1807 operandEntered = B_TRUE;
1808 } else {
1809 outerLoop = 1;
1810 operandEntered = B_FALSE;
1811 }
1812
1813 stmfRet = stmfGetTargetGroupList(&groupList);
1814 if (stmfRet != STMF_STATUS_SUCCESS) {
1815 switch (stmfRet) {
1816 case STMF_ERROR_BUSY:
1817 (void) fprintf(stderr, "%s: %s\n", cmdName,
1818 gettext("resource busy"));
1819 break;
1820 case STMF_ERROR_SERVICE_NOT_FOUND:
1821 (void) fprintf(stderr, "%s: %s\n", cmdName,
1822 gettext("STMF service not found"));
1823 break;
1824 case STMF_ERROR_SERVICE_DATA_VERSION:
1825 (void) fprintf(stderr, "%s: %s\n", cmdName,
1826 gettext("STMF service version incorrect"));
1827 break;
1828 case STMF_ERROR_PERM:
1829 (void) fprintf(stderr, "%s: %s\n", cmdName,
1830 gettext("permission denied"));
1831 break;
1832 default:
1833 (void) fprintf(stderr, "%s: %s\n", cmdName,
1834 gettext("unknown error"));
1835 break;
1836 }
1837 return (1);
1838 }
1839
1840 for (i = 0; i < outerLoop; i++) {
1841 for (found = B_FALSE, j = 0; j < groupList->cnt; j++) {
1842 (void) mbstowcs(groupNamePrint,
1843 (char *)groupList->name[j],
1844 sizeof (stmfGroupName) - 1);
1845 groupNamePrint[sizeof (stmfGroupName) - 1] = 0;
1846 if (operandEntered) {
1847 (void) mbstowcs(operandName, operands[i],
1848 sizeof (stmfGroupName) - 1);
1849 operandName[sizeof (stmfGroupName) - 1] = 0;
1850 if (wcscmp(operandName, groupNamePrint)
1851 == 0) {
1852 found = B_TRUE;
1853 }
1854 }
1855 if ((found && operandEntered) || !operandEntered) {
1856 (void) printf("Target Group: %ws\n",
1857 groupNamePrint);
1858 if (verbose) {
1859 stmfRet = stmfGetTargetGroupMembers(
1860 &(groupList->name[j]), &groupProps);
1861 if (stmfRet != STMF_STATUS_SUCCESS) {
1862 return (1);
1863 }
1864 printGroupProps(groupProps);
1865 }
1866 if (found && operandEntered) {
1867 break;
1868 }
1869 }
1870
1871 }
1872 if (operandEntered && !found) {
1873 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
1874 operands[i], gettext("not found"));
1875 ret = 1;
1876 }
1877 }
1878 return (ret);
1879 }
1880
1881 /*
1882 * listLuFunc
1883 *
1884 * List the logical units and optionally the properties
1885 *
1886 */
1887 /*ARGSUSED*/
1888 static int
1889 listLuFunc(int operandLen, char *operands[], cmdOptions_t *options, void *args)
1890 {
1891 cmdOptions_t *optionList = options;
1892 boolean_t operandEntered;
1893 int i, j;
1894 int ret = 0;
1895 int stmfRet;
1896 int outerLoop;
1897 unsigned int inGuid[sizeof (stmfGuid)];
1898 stmfGuid cmpGuid;
1899 boolean_t verbose = B_FALSE;
1900 boolean_t found;
1901 char sGuid[GUID_INPUT + 1];
1902 stmfGuidList *luList;
1903 stmfLogicalUnitProperties luProps;
1904 boolean_t invalidInput = B_FALSE;
1905 stmfViewEntryList *viewEntryList;
1906
1907 for (; optionList->optval; optionList++) {
1908 switch (optionList->optval) {
1909 case 'v':
1910 verbose = B_TRUE;
1911 break;
1912 }
1913 }
1914
1915 if ((stmfRet = stmfGetLogicalUnitList(&luList))
1916 != STMF_STATUS_SUCCESS) {
1917 switch (stmfRet) {
1918 case STMF_ERROR_SERVICE_NOT_FOUND:
1919 (void) fprintf(stderr, "%s: %s\n", cmdName,
1920 gettext("STMF service not found"));
1921 break;
1922 case STMF_ERROR_BUSY:
1923 (void) fprintf(stderr, "%s: %s\n", cmdName,
1924 gettext("resource busy"));
1925 break;
1926 case STMF_ERROR_PERM:
1927 (void) fprintf(stderr, "%s: %s\n", cmdName,
1928 gettext("permission denied"));
1929 break;
1930 case STMF_ERROR_SERVICE_DATA_VERSION:
1931 (void) fprintf(stderr, "%s: %s\n", cmdName,
1932 gettext("STMF service version incorrect"));
1933 break;
1934 default:
1935 (void) fprintf(stderr, "%s: %s\n", cmdName,
1936 gettext("list failed"));
1937 break;
1938 }
1939 return (1);
1940 }
1941
1942 if (operandLen > 0) {
1943 operandEntered = B_TRUE;
1944 outerLoop = operandLen;
1945 } else {
1946 operandEntered = B_FALSE;
1947 outerLoop = 1;
1948 }
1949
1950
1951 for (invalidInput = B_FALSE, i = 0; i < outerLoop; i++) {
1952 if (operandEntered) {
1953 if (strlen(operands[i]) != GUID_INPUT) {
1954 invalidInput = B_TRUE;
1955 } else {
1956 for (j = 0; j < GUID_INPUT; j++) {
1957 if (!isxdigit(operands[i][j])) {
1958 invalidInput = B_TRUE;
1959 break;
1960 }
1961 }
1962 }
1963 if (invalidInput) {
1964 (void) fprintf(stderr, "%s: %s: %s%d%s\n",
1965 cmdName, operands[i], gettext("must be "),
1966 GUID_INPUT,
1967 gettext(" hexadecimal digits long"));
1968 invalidInput = B_FALSE;
1969 continue;
1970 }
1971
1972 for (j = 0; j < GUID_INPUT; j++) {
1973 sGuid[j] = tolower(operands[i][j]);
1974 }
1975 sGuid[j] = 0;
1976
1977 (void) sscanf(sGuid,
1978 "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
1979 &inGuid[0], &inGuid[1], &inGuid[2], &inGuid[3],
1980 &inGuid[4], &inGuid[5], &inGuid[6], &inGuid[7],
1981 &inGuid[8], &inGuid[9], &inGuid[10], &inGuid[11],
1982 &inGuid[12], &inGuid[13], &inGuid[14], &inGuid[15]);
1983
1984 for (j = 0; j < sizeof (stmfGuid); j++) {
1985 cmpGuid.guid[j] = inGuid[j];
1986 }
1987 }
1988
1989 for (found = B_FALSE, j = 0; j < luList->cnt; j++) {
1990 if (operandEntered) {
1991 if (bcmp(luList->guid[j].guid, cmpGuid.guid,
1992 sizeof (stmfGuid)) == 0) {
1993 found = B_TRUE;
1994 }
1995 }
1996 if ((found && operandEntered) || !operandEntered) {
1997 (void) printf("LU Name: ");
1998 printGuid(&luList->guid[j], stdout);
1999 (void) printf("\n");
2000
2001 if (verbose) {
2002 stmfRet = stmfGetLogicalUnitProperties(
2003 &(luList->guid[j]), &luProps);
2004 if (stmfRet == STMF_STATUS_SUCCESS) {
2005 printLuProps(&luProps);
2006 } else {
2007 (void) fprintf(stderr, "%s:",
2008 cmdName);
2009 printGuid(&luList->guid[j],
2010 stderr);
2011 (void) fprintf(stderr, "%s\n",
2012 gettext(" get properties "
2013 "failed"));
2014 }
2015 stmfRet = stmfGetViewEntryList(
2016 &(luList->guid[j]),
2017 &viewEntryList);
2018 (void) printf(PROPS_FORMAT,
2019 "View Entry Count");
2020 if (stmfRet == STMF_STATUS_SUCCESS) {
2021 (void) printf("%d",
2022 viewEntryList->cnt);
2023 } else {
2024 (void) printf("unknown");
2025 }
2026 (void) printf("\n");
2027 ret = printExtLuProps(
2028 &(luList->guid[j]));
2029 }
2030 if (found && operandEntered) {
2031 break;
2032 }
2033 }
2034
2035 }
2036 if (operandEntered && !found) {
2037 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
2038 operands[i], gettext("not found"));
2039 ret = 1;
2040 }
2041 }
2042
2043 return (ret);
2044 }
2045
2046 static void
2047 printGuid(stmfGuid *guid, FILE *stream)
2048 {
2049 int i;
2050 for (i = 0; i < 16; i++) {
2051 (void) fprintf(stream, "%02X", guid->guid[i]);
2052 }
2053 }
2054
2055 static int
2056 printExtLuProps(stmfGuid *guid)
2057 {
2058 int stmfRet;
2059 luResource hdl = NULL;
2060 int ret = 0;
2061 char propVal[MAXNAMELEN];
2062 size_t propValSize = sizeof (propVal);
2063
2064 if ((stmfRet = stmfGetLuResource(guid, &hdl))
2065 != STMF_STATUS_SUCCESS) {
2066 switch (stmfRet) {
2067 case STMF_ERROR_BUSY:
2068 (void) fprintf(stderr, "%s: %s\n", cmdName,
2069 gettext("resource busy"));
2070 break;
2071 case STMF_ERROR_PERM:
2072 (void) fprintf(stderr, "%s: %s\n", cmdName,
2073 gettext("permission denied"));
2074 break;
2075 case STMF_ERROR_NOT_FOUND:
2076 /* No error here */
2077 return (0);
2078 default:
2079 (void) fprintf(stderr, "%s: %s\n", cmdName,
2080 gettext("get extended properties failed"));
2081 break;
2082 }
2083 return (1);
2084 }
2085
2086 stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_FILENAME, propVal,
2087 &propValSize);
2088 (void) printf(PROPS_FORMAT, "Data File");
2089 if (stmfRet == STMF_STATUS_SUCCESS) {
2090 (void) printf("%s\n", propVal);
2091 } else if (stmfRet == STMF_ERROR_NO_PROP) {
2092 (void) printf("not set\n");
2093 } else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {
2094 (void) printf("prop unavailable in standby\n");
2095 } else {
2096 (void) printf("<error retrieving property>\n");
2097 ret++;
2098 }
2099
2100 stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_META_FILENAME, propVal,
2101 &propValSize);
2102 (void) printf(PROPS_FORMAT, "Meta File");
2103 if (stmfRet == STMF_STATUS_SUCCESS) {
2104 (void) printf("%s\n", propVal);
2105 } else if (stmfRet == STMF_ERROR_NO_PROP) {
2106 (void) printf("not set\n");
2107 } else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {
2108 (void) printf("prop unavailable in standby\n");
2109 } else {
2110 (void) printf("<error retrieving property>\n");
2111 ret++;
2112 }
2113
2114 stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_SIZE, propVal,
2115 &propValSize);
2116 (void) printf(PROPS_FORMAT, "Size");
2117 if (stmfRet == STMF_STATUS_SUCCESS) {
2118 (void) printf("%s\n", propVal);
2119 } else if (stmfRet == STMF_ERROR_NO_PROP) {
2120 (void) printf("not set\n");
2121 } else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {
2122 (void) printf("prop unavailable in standby\n");
2123 } else {
2124 (void) printf("<error retrieving property>\n");
2125 ret++;
2126 }
2127
2128 stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_BLOCK_SIZE, propVal,
2129 &propValSize);
2130 (void) printf(PROPS_FORMAT, "Block Size");
2131 if (stmfRet == STMF_STATUS_SUCCESS) {
2132 (void) printf("%s\n", propVal);
2133 } else if (stmfRet == STMF_ERROR_NO_PROP) {
2134 (void) printf("not set\n");
2135 } else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {
2136 (void) printf("prop unavailable in standby\n");
2137 } else {
2138 (void) printf("<error retrieving property>\n");
2139 ret++;
2140 }
2141
2142 stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_MGMT_URL, propVal,
2143 &propValSize);
2144 (void) printf(PROPS_FORMAT, "Management URL");
2145 if (stmfRet == STMF_STATUS_SUCCESS) {
2146 (void) printf("%s\n", propVal);
2147 } else if (stmfRet == STMF_ERROR_NO_PROP) {
2148 (void) printf("not set\n");
2149 } else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {
2150 (void) printf("prop unavailable in standby\n");
2151 } else {
2152 (void) printf("<error retrieving property>\n");
2153 ret++;
2154 }
2155
2156 stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_VID, propVal,
2157 &propValSize);
2158 (void) printf(PROPS_FORMAT, "Vendor ID");
2159 if (stmfRet == STMF_STATUS_SUCCESS) {
2160 (void) printf("%s\n", propVal);
2161 } else if (stmfRet == STMF_ERROR_NO_PROP) {
2162 (void) printf("not set\n");
2163 } else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {
2164 (void) printf("prop unavailable in standby\n");
2165 } else {
2166 (void) printf("<error retrieving property>\n");
2167 ret++;
2168 }
2169
2170 stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_PID, propVal,
2171 &propValSize);
2172 (void) printf(PROPS_FORMAT, "Product ID");
2173 if (stmfRet == STMF_STATUS_SUCCESS) {
2174 (void) printf("%s\n", propVal);
2175 } else if (stmfRet == STMF_ERROR_NO_PROP) {
2176 (void) printf("not set\n");
2177 } else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {
2178 (void) printf("prop unavailable in standby\n");
2179 } else {
2180 (void) printf("<error retrieving property>\n");
2181 ret++;
2182 }
2183
2184 stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_SERIAL_NUM, propVal,
2185 &propValSize);
2186 (void) printf(PROPS_FORMAT, "Serial Num");
2187 if (stmfRet == STMF_STATUS_SUCCESS) {
2188 (void) printf("%s\n", propVal);
2189 } else if (stmfRet == STMF_ERROR_NO_PROP) {
2190 (void) printf("not set\n");
2191 } else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {
2192 (void) printf("prop unavailable in standby\n");
2193 } else {
2194 (void) printf("<error retrieving property>\n");
2195 ret++;
2196 }
2197
2198 stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_WRITE_PROTECT, propVal,
2199 &propValSize);
2200 (void) printf(PROPS_FORMAT, "Write Protect");
2201 if (stmfRet == STMF_STATUS_SUCCESS) {
2202 (void) printf("%s\n",
2203 strcasecmp(propVal, "true") ? "Disabled" : "Enabled");
2204 } else if (stmfRet == STMF_ERROR_NO_PROP) {
2205 (void) printf("not set\n");
2206 } else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {
2207 (void) printf("prop unavailable in standby\n");
2208 } else {
2209 (void) printf("<error retrieving property>\n");
2210 ret++;
2211 }
2212
2213 stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_WRITE_CACHE_DISABLE, propVal,
2214 &propValSize);
2215 (void) printf(PROPS_FORMAT, "Writeback Cache");
2216 if (stmfRet == STMF_STATUS_SUCCESS) {
2217 (void) printf("%s\n",
2218 strcasecmp(propVal, "true") ? "Enabled" : "Disabled");
2219 } else if (stmfRet == STMF_ERROR_NO_PROP) {
2220 (void) printf("not set\n");
2221 } else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {
2222 (void) printf("prop unavailable in standby\n");
2223 } else {
2224 (void) printf("<error retrieving property>\n");
2225 ret++;
2226 }
2227
2228 stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_ACCESS_STATE, propVal,
2229 &propValSize);
2230 (void) printf(PROPS_FORMAT, "Access State");
2231 if (stmfRet == STMF_STATUS_SUCCESS) {
2232 if (strcmp(propVal, STMF_ACCESS_ACTIVE) == 0) {
2233 (void) printf("%s\n", "Active");
2234 } else if (strcmp(propVal,
2235 STMF_ACCESS_ACTIVE_TO_STANDBY) == 0) {
2236 (void) printf("%s\n", "Active->Standby");
2237 } else if (strcmp(propVal, STMF_ACCESS_STANDBY) == 0) {
2238 (void) printf("%s\n", "Standby");
2239 } else if (strcmp(propVal,
2240 STMF_ACCESS_STANDBY_TO_ACTIVE) == 0) {
2241 (void) printf("%s\n", "Standby->Active");
2242 } else {
2243 (void) printf("%s\n", "Unknown");
2244 }
2245 } else if (stmfRet == STMF_ERROR_NO_PROP) {
2246 (void) printf("not set\n");
2247 } else {
2248 (void) printf("<error retrieving property>\n");
2249 ret++;
2250 }
2251
2252 done:
2253 (void) stmfFreeLuResource(hdl);
2254 return (ret);
2255
2256 }
2257
2258
2259 /*
2260 * printLuProps
2261 *
2262 * Prints the properties for a logical unit
2263 *
2264 */
2265 static void
2266 printLuProps(stmfLogicalUnitProperties *luProps)
2267 {
2268 (void) printf(PROPS_FORMAT, "Operational Status");
2269 switch (luProps->status) {
2270 case STMF_LOGICAL_UNIT_ONLINE:
2271 (void) printf("Online");
2272 break;
2273 case STMF_LOGICAL_UNIT_OFFLINE:
2274 (void) printf("Offline");
2275 break;
2276 case STMF_LOGICAL_UNIT_ONLINING:
2277 (void) printf("Onlining");
2278 break;
2279 case STMF_LOGICAL_UNIT_OFFLINING:
2280 (void) printf("Offlining");
2281 break;
2282 case STMF_LOGICAL_UNIT_UNREGISTERED:
2283 (void) printf("unregistered");
2284 (void) strncpy(luProps->providerName, "unregistered",
2285 sizeof (luProps->providerName));
2286 break;
2287 default:
2288 (void) printf("unknown");
2289 break;
2290 }
2291 (void) printf("\n");
2292 (void) printf(PROPS_FORMAT, "Provider Name");
2293 if (luProps->providerName[0] != 0) {
2294 (void) printf("%s", luProps->providerName);
2295 } else {
2296 (void) printf("unknown");
2297 }
2298 (void) printf("\n");
2299 (void) printf(PROPS_FORMAT, "Alias");
2300 if (luProps->alias[0] != 0) {
2301 (void) printf("%s", luProps->alias);
2302 } else {
2303 (void) printf("-");
2304 }
2305 (void) printf("\n");
2306 }
2307
2308 /*
2309 * printTargetProps
2310 *
2311 * Prints the properties for a target
2312 *
2313 */
2314 static void
2315 printTargetProps(stmfTargetProperties *targetProps)
2316 {
2317 (void) printf(PROPS_FORMAT, "Operational Status");
2318 switch (targetProps->status) {
2319 case STMF_TARGET_PORT_ONLINE:
2320 (void) printf("Online");
2321 break;
2322 case STMF_TARGET_PORT_OFFLINE:
2323 (void) printf("Offline");
2324 break;
2325 case STMF_TARGET_PORT_ONLINING:
2326 (void) printf("Onlining");
2327 break;
2328 case STMF_TARGET_PORT_OFFLINING:
2329 (void) printf("Offlining");
2330 break;
2331 default:
2332 (void) printf("unknown");
2333 break;
2334 }
2335 (void) printf("\n");
2336 (void) printf(PROPS_FORMAT, "Provider Name");
2337 if (targetProps->providerName[0] != 0) {
2338 (void) printf("%s", targetProps->providerName);
2339 }
2340 (void) printf("\n");
2341 (void) printf(PROPS_FORMAT, "Alias");
2342 if (targetProps->alias[0] != 0) {
2343 (void) printf("%s", targetProps->alias);
2344 } else {
2345 (void) printf("-");
2346 }
2347 (void) printf("\n");
2348 (void) printf(PROPS_FORMAT, "Protocol");
2349 switch (targetProps->protocol) {
2350 case STMF_PROTOCOL_FIBRE_CHANNEL:
2351 (void) printf("%s", "Fibre Channel");
2352 break;
2353 case STMF_PROTOCOL_ISCSI:
2354 (void) printf("%s", "iSCSI");
2355 break;
2356 case STMF_PROTOCOL_SRP:
2357 (void) printf("%s", "SRP");
2358 break;
2359 case STMF_PROTOCOL_SAS:
2360 (void) printf("%s", "SAS");
2361 break;
2362 default:
2363 (void) printf("%s", "unknown");
2364 break;
2365 }
2366
2367 (void) printf("\n");
2368 }
2369
2370 /*
2371 * printSessionProps
2372 *
2373 * Prints the session data
2374 *
2375 */
2376 static void
2377 printSessionProps(stmfSessionList *sessionList)
2378 {
2379 int i;
2380 char *cTime;
2381 wchar_t initiator[STMF_IDENT_LENGTH + 1];
2382
2383 (void) printf(PROPS_FORMAT, "Sessions");
2384 (void) printf("%d\n", sessionList->cnt);
2385 for (i = 0; i < sessionList->cnt; i++) {
2386 (void) mbstowcs(initiator,
2387 (char *)sessionList->session[i].initiator.ident,
2388 STMF_IDENT_LENGTH);
2389 initiator[STMF_IDENT_LENGTH] = 0;
2390 (void) printf(LVL3_FORMAT, "Initiator: ");
2391 (void) printf("%ws\n", initiator);
2392 (void) printf(LVL4_FORMAT, "Alias: ");
2393 if (sessionList->session[i].alias[0] != 0) {
2394 (void) printf("%s", sessionList->session[i].alias);
2395 } else {
2396 (void) printf("-");
2397 }
2398 (void) printf("\n");
2399 (void) printf(LVL4_FORMAT, "Logged in since: ");
2400 cTime = ctime(&(sessionList->session[i].creationTime));
2401 if (cTime != NULL) {
2402 (void) printf("%s", cTime);
2403 } else {
2404 (void) printf("unknown\n");
2405 }
2406 }
2407 }
2408
2409 static int
2410 getStmfState(stmfState *state)
2411 {
2412 int ret;
2413
2414 ret = stmfGetState(state);
2415 switch (ret) {
2416 case STMF_STATUS_SUCCESS:
2417 break;
2418 case STMF_ERROR_PERM:
2419 (void) fprintf(stderr, "%s: %s\n", cmdName,
2420 gettext("permission denied"));
2421 break;
2422 case STMF_ERROR_SERVICE_NOT_FOUND:
2423 (void) fprintf(stderr, "%s: %s\n", cmdName,
2424 gettext("STMF service not found"));
2425 break;
2426 case STMF_ERROR_BUSY:
2427 (void) fprintf(stderr, "%s: %s\n", cmdName,
2428 gettext("resource busy"));
2429 break;
2430 case STMF_ERROR_SERVICE_DATA_VERSION:
2431 (void) fprintf(stderr, "%s: %s\n", cmdName,
2432 gettext("STMF service version incorrect"));
2433 break;
2434 default:
2435 (void) fprintf(stderr, "%s: %s: %d\n", cmdName,
2436 gettext("unknown error"), ret);
2437 break;
2438 }
2439 return (ret);
2440 }
2441
2442 /*
2443 * listStateFunc
2444 *
2445 * List the operational and config state of the stmf service
2446 *
2447 */
2448 /*ARGSUSED*/
2449 static int
2450 listStateFunc(int operandLen, char *operands[], cmdOptions_t *options,
2451 void *args)
2452 {
2453 int ret;
2454 stmfState state;
2455 boolean_t aluaEnabled;
2456 uint32_t node;
2457
2458 if ((ret = getStmfState(&state)) != STMF_STATUS_SUCCESS)
2459 return (ret);
2460
2461 (void) printf("%-18s: ", "Operational Status");
2462 switch (state.operationalState) {
2463 case STMF_SERVICE_STATE_ONLINE:
2464 (void) printf("online");
2465 break;
2466 case STMF_SERVICE_STATE_OFFLINE:
2467 (void) printf("offline");
2468 break;
2469 case STMF_SERVICE_STATE_ONLINING:
2470 (void) printf("onlining");
2471 break;
2472 case STMF_SERVICE_STATE_OFFLINING:
2473 (void) printf("offlining");
2474 break;
2475 default:
2476 (void) printf("unknown");
2477 break;
2478 }
2479 (void) printf("\n");
2480 (void) printf("%-18s: ", "Config Status");
2481 switch (state.configState) {
2482 case STMF_CONFIG_STATE_NONE:
2483 (void) printf("uninitialized");
2484 break;
2485 case STMF_CONFIG_STATE_INIT:
2486 (void) printf("initializing");
2487 break;
2488 case STMF_CONFIG_STATE_INIT_DONE:
2489 (void) printf("initialized");
2490 break;
2491 default:
2492 (void) printf("unknown");
2493 break;
2494 }
2495 (void) printf("\n");
2496 ret = stmfGetAluaState(&aluaEnabled, &node);
2497 switch (ret) {
2498 case STMF_STATUS_SUCCESS:
2499 break;
2500 case STMF_ERROR_PERM:
2501 (void) fprintf(stderr, "%s: %s\n", cmdName,
2502 gettext("permission denied"));
2503 break;
2504 case STMF_ERROR_BUSY:
2505 (void) fprintf(stderr, "%s: %s\n", cmdName,
2506 gettext("resource busy"));
2507 break;
2508 default:
2509 (void) fprintf(stderr, "%s: %s: %d\n", cmdName,
2510 gettext("unknown error"), ret);
2511 break;
2512 }
2513 (void) printf("%-18s: ", "ALUA Status");
2514 if (ret == STMF_STATUS_SUCCESS) {
2515 if (aluaEnabled == B_TRUE) {
2516 (void) printf("enabled");
2517 } else {
2518 (void) printf("disabled");
2519 }
2520 } else {
2521 (void) printf("unknown");
2522 }
2523
2524 (void) printf("\n");
2525 (void) printf("%-18s: ", "ALUA Node");
2526 if (ret == STMF_STATUS_SUCCESS) {
2527 (void) printf("%d", node);
2528 } else {
2529 (void) printf("unknown");
2530 }
2531 (void) printf("\n");
2532 return (ret);
2533 }
2534
2535 /*
2536 * listTargetFunc
2537 *
2538 * list the targets and optionally their properties
2539 *
2540 */
2541 /*ARGSUSED*/
2542 static int
2543 listTargetFunc(int operandLen, char *operands[], cmdOptions_t *options,
2544 void *args)
2545 {
2546 cmdOptions_t *optionList = options;
2547 int ret = 0;
2548 int stmfRet;
2549 int i, j;
2550 int outerLoop;
2551 stmfSessionList *sessionList;
2552 stmfDevid devid;
2553 boolean_t operandEntered, found, verbose = B_FALSE;
2554 stmfDevidList *targetList;
2555 wchar_t targetIdent[STMF_IDENT_LENGTH + 1];
2556 stmfTargetProperties targetProps;
2557
2558 if ((stmfRet = stmfGetTargetList(&targetList)) != STMF_STATUS_SUCCESS) {
2559 switch (stmfRet) {
2560 case STMF_ERROR_NOT_FOUND:
2561 ret = 0;
2562 break;
2563 case STMF_ERROR_SERVICE_OFFLINE:
2564 (void) fprintf(stderr, "%s: %s\n", cmdName,
2565 gettext("STMF service offline"));
2566 break;
2567 case STMF_ERROR_BUSY:
2568 (void) fprintf(stderr, "%s: %s\n", cmdName,
2569 gettext("resource busy"));
2570 break;
2571 case STMF_ERROR_SERVICE_DATA_VERSION:
2572 (void) fprintf(stderr, "%s: %s\n", cmdName,
2573 gettext("STMF service version incorrect"));
2574 break;
2575 case STMF_ERROR_PERM:
2576 (void) fprintf(stderr, "%s: %s\n", cmdName,
2577 gettext("permission denied"));
2578 break;
2579 default:
2580 (void) fprintf(stderr, "%s: %s\n", cmdName,
2581 gettext("unknown error"));
2582 break;
2583 }
2584 return (1);
2585 }
2586
2587 for (; optionList->optval; optionList++) {
2588 switch (optionList->optval) {
2589 case 'v':
2590 verbose = B_TRUE;
2591 break;
2592 }
2593 }
2594
2595 if (operandLen > 0) {
2596 outerLoop = operandLen;
2597 operandEntered = B_TRUE;
2598 } else {
2599 outerLoop = 1;
2600 operandEntered = B_FALSE;
2601 }
2602
2603 for (i = 0; i < outerLoop; i++) {
2604 if (operandEntered) {
2605 bzero(&devid, sizeof (devid));
2606 (void) parseDevid(operands[i], &devid);
2607 }
2608 for (found = B_FALSE, j = 0; j < targetList->cnt; j++) {
2609 if (operandEntered) {
2610 if (bcmp(&devid, &(targetList->devid[j]),
2611 sizeof (devid)) == 0) {
2612 found = B_TRUE;
2613 }
2614 }
2615 if ((found && operandEntered) || !operandEntered) {
2616 (void) mbstowcs(targetIdent,
2617 (char *)targetList->devid[j].ident,
2618 STMF_IDENT_LENGTH);
2619 targetIdent[STMF_IDENT_LENGTH] = 0;
2620 (void) printf("Target: %ws\n", targetIdent);
2621 if (verbose) {
2622 stmfRet = stmfGetTargetProperties(
2623 &(targetList->devid[j]),
2624 &targetProps);
2625 if (stmfRet == STMF_STATUS_SUCCESS) {
2626 printTargetProps(&targetProps);
2627 } else {
2628 (void) fprintf(stderr, "%s:",
2629 cmdName);
2630 (void) fprintf(stderr, "%s\n",
2631 gettext(" get properties"
2632 " failed"));
2633 }
2634 stmfRet = stmfGetSessionList(
2635 &(targetList->devid[j]),
2636 &sessionList);
2637 if (stmfRet == STMF_STATUS_SUCCESS) {
2638 printSessionProps(sessionList);
2639 } else {
2640 (void) fprintf(stderr, "%s:",
2641 cmdName);
2642 (void) fprintf(stderr, "%s\n",
2643 gettext(" get session info"
2644 " failed"));
2645 }
2646 }
2647 if (found && operandEntered) {
2648 break;
2649 }
2650 }
2651
2652 }
2653 if (operandEntered && !found) {
2654 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
2655 operands[i], "not found");
2656 ret = 1;
2657 }
2658 }
2659 return (ret);
2660 }
2661
2662 /*
2663 * listViewFunc
2664 *
2665 * list the view entries for the specified logical unit
2666 *
2667 */
2668 /*ARGSUSED*/
2669 static int
2670 listViewFunc(int operandLen, char *operands[], cmdOptions_t *options,
2671 void *args)
2672 {
2673 stmfViewEntryList *viewEntryList;
2674 stmfGuid inGuid;
2675 unsigned int guid[sizeof (stmfGuid)];
2676 int ret = 0;
2677 int stmfRet;
2678 int i, j, outerLoop;
2679 boolean_t found = B_TRUE;
2680 boolean_t operandEntered;
2681 uint16_t outputLuNbr;
2682 wchar_t groupName[sizeof (stmfGroupName)];
2683 char sGuid[GUID_INPUT + 1];
2684
2685
2686 for (; options->optval; options++) {
2687 switch (options->optval) {
2688 case 'l':
2689 if (strlen(options->optarg) != GUID_INPUT) {
2690 (void) fprintf(stderr,
2691 "%s: %s: %s%d%s\n",
2692 cmdName, options->optarg,
2693 gettext("must be "), GUID_INPUT,
2694 gettext(" hexadecimal digits"
2695 " long"));
2696 return (1);
2697 }
2698 bcopy(options->optarg, sGuid, GUID_INPUT);
2699 break;
2700 default:
2701 (void) fprintf(stderr, "%s: %c: %s\n",
2702 cmdName, options->optval,
2703 gettext("unknown option"));
2704 return (1);
2705 }
2706 }
2707
2708 if (operandLen > 0) {
2709 outerLoop = operandLen;
2710 operandEntered = B_TRUE;
2711 } else {
2712 outerLoop = 1;
2713 operandEntered = B_FALSE;
2714 }
2715
2716 for (i = 0; i < 32; i++)
2717 sGuid[i] = tolower(sGuid[i]);
2718 sGuid[i] = 0;
2719
2720 (void) sscanf(sGuid, "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
2721 &guid[0], &guid[1], &guid[2], &guid[3], &guid[4], &guid[5],
2722 &guid[6], &guid[7], &guid[8], &guid[9], &guid[10], &guid[11],
2723 &guid[12], &guid[13], &guid[14], &guid[15]);
2724
2725 for (i = 0; i < sizeof (stmfGuid); i++) {
2726 inGuid.guid[i] = guid[i];
2727 }
2728
2729 if ((stmfRet = stmfGetViewEntryList(&inGuid, &viewEntryList))
2730 != STMF_STATUS_SUCCESS) {
2731
2732 switch (stmfRet) {
2733 case STMF_ERROR_BUSY:
2734 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
2735 sGuid, gettext("resource busy"));
2736 break;
2737 case STMF_ERROR_SERVICE_NOT_FOUND:
2738 (void) fprintf(stderr, "%s: %s\n", cmdName,
2739 gettext("STMF service not found"));
2740 break;
2741 case STMF_ERROR_SERVICE_DATA_VERSION:
2742 (void) fprintf(stderr, "%s: %s\n", cmdName,
2743 gettext("STMF service version incorrect"));
2744 break;
2745 case STMF_ERROR_PERM:
2746 (void) fprintf(stderr, "%s: %s\n", cmdName,
2747 gettext("permission denied"));
2748 break;
2749 default:
2750 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
2751 sGuid, gettext("unknown error"));
2752 break;
2753 }
2754 return (1);
2755 }
2756
2757 if (viewEntryList->cnt == 0) {
2758 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
2759 sGuid, gettext("no views found"));
2760 return (1);
2761 }
2762
2763 for (i = 0; i < outerLoop; i++) {
2764 for (found = B_FALSE, j = 0; j < viewEntryList->cnt; j++) {
2765 if (operandEntered) {
2766 if (atoi(operands[i]) ==
2767 viewEntryList->ve[j].veIndex) {
2768 found = B_TRUE;
2769 }
2770 }
2771 if ((found && operandEntered) || !operandEntered) {
2772 (void) printf("View Entry: %d\n",
2773 viewEntryList->ve[j].veIndex);
2774 (void) printf(VIEW_FORMAT, "Host group");
2775 if (viewEntryList->ve[j].allHosts) {
2776 (void) printf("All\n");
2777 } else {
2778 (void) mbstowcs(groupName,
2779 viewEntryList->ve[j].hostGroup,
2780 sizeof (stmfGroupName) - 1);
2781 groupName[sizeof (stmfGroupName) - 1]
2782 = 0;
2783 (void) printf("%ws\n", groupName);
2784 }
2785 (void) printf(VIEW_FORMAT, "Target group");
2786 if (viewEntryList->ve[j].allTargets) {
2787 (void) printf("All\n");
2788 } else {
2789 (void) mbstowcs(groupName,
2790 viewEntryList->ve[j].targetGroup,
2791 sizeof (stmfGroupName) - 1);
2792 groupName[sizeof (stmfGroupName) - 1]
2793 = 0;
2794 (void) printf("%ws\n", groupName);
2795 }
2796 outputLuNbr = ((viewEntryList->ve[j].luNbr[0] &
2797 0x3F) << 8) | viewEntryList->ve[j].luNbr[1];
2798 (void) printf(VIEW_FORMAT, "LUN");
2799 (void) printf("%d\n", outputLuNbr);
2800 if (found && operandEntered) {
2801 break;
2802 }
2803 }
2804 }
2805 if (operandEntered && !found) {
2806 (void) fprintf(stderr, "%s: %s, %s: %s\n", cmdName,
2807 sGuid, operands[i], gettext("not found"));
2808 ret = 1;
2809 }
2810 }
2811
2812 return (ret);
2813 }
2814
2815
2816 /*
2817 * onlineOfflineLu
2818 *
2819 * Purpose: Online or offline a logical unit
2820 *
2821 * lu - logical unit to online or offline
2822 *
2823 * state - ONLINE_LU
2824 * OFFLINE_LU
2825 */
2826 static int
2827 onlineOfflineLu(char *lu, int state)
2828 {
2829 char sGuid[GUID_INPUT + 1];
2830 stmfGuid inGuid;
2831 unsigned int guid[sizeof (stmfGuid)];
2832 int i;
2833 int ret = 0, stmfRet;
2834 stmfLogicalUnitProperties luProps;
2835
2836 if (strlen(lu) != GUID_INPUT) {
2837 (void) fprintf(stderr, "%s: %s: %s %d %s\n", cmdName, lu,
2838 gettext("must be"), GUID_INPUT,
2839 gettext("hexadecimal digits long"));
2840 return (1);
2841 }
2842
2843 bcopy(lu, sGuid, GUID_INPUT);
2844
2845 for (i = 0; i < 32; i++)
2846 sGuid[i] = tolower(sGuid[i]);
2847 sGuid[i] = 0;
2848
2849 (void) sscanf(sGuid, "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
2850 &guid[0], &guid[1], &guid[2], &guid[3], &guid[4], &guid[5],
2851 &guid[6], &guid[7], &guid[8], &guid[9], &guid[10], &guid[11],
2852 &guid[12], &guid[13], &guid[14], &guid[15]);
2853
2854 for (i = 0; i < sizeof (stmfGuid); i++) {
2855 inGuid.guid[i] = guid[i];
2856 }
2857
2858 if (state == ONLINE_LU) {
2859 ret = stmfOnlineLogicalUnit(&inGuid);
2860 } else if (state == OFFLINE_LU) {
2861 ret = stmfOfflineLogicalUnit(&inGuid);
2862 } else {
2863 return (STMFADM_FAILURE);
2864 }
2865 if (ret != STMF_STATUS_SUCCESS) {
2866 switch (ret) {
2867 case STMF_ERROR_PERM:
2868 (void) fprintf(stderr, "%s: %s\n", cmdName,
2869 gettext("permission denied"));
2870 break;
2871 case STMF_ERROR_SERVICE_NOT_FOUND:
2872 (void) fprintf(stderr, "%s: %s\n", cmdName,
2873 gettext("STMF service not found"));
2874 break;
2875 case STMF_ERROR_BUSY:
2876 (void) fprintf(stderr, "%s: %s\n", cmdName,
2877 gettext("resource busy"));
2878 break;
2879 case STMF_ERROR_NOT_FOUND:
2880 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
2881 lu, gettext("not found"));
2882 break;
2883 case STMF_ERROR_SERVICE_DATA_VERSION:
2884 (void) fprintf(stderr, "%s: %s\n", cmdName,
2885 gettext("STMF service version incorrect"));
2886 break;
2887 default:
2888 (void) fprintf(stderr, "%s: %s\n", cmdName,
2889 gettext("unknown error"));
2890 break;
2891 }
2892 } else {
2893 struct timespec ts = {0};
2894 unsigned int count = 0;
2895 uint32_t ret_state;
2896
2897 ret_state = (state == ONLINE_LU) ?
2898 STMF_LOGICAL_UNIT_ONLINING : STMF_LOGICAL_UNIT_OFFLINING;
2899 ts.tv_nsec = DELAYED_EXEC_WAIT_INTERVAL;
2900
2901 /* CONSTCOND */
2902 while (1) {
2903 stmfRet = stmfGetLogicalUnitProperties(&inGuid,
2904 &luProps);
2905 if (stmfRet == STMF_STATUS_SUCCESS)
2906 ret_state = luProps.status;
2907
2908 if ((state == ONLINE_LU &&
2909 ret_state == STMF_LOGICAL_UNIT_ONLINE) ||
2910 (state == OFFLINE_LU &&
2911 ret_state == STMF_LOGICAL_UNIT_OFFLINE))
2912 return (STMFADM_SUCCESS);
2913
2914 if ((state == ONLINE_LU &&
2915 ret_state == STMF_LOGICAL_UNIT_OFFLINE) ||
2916 (state == OFFLINE_LU &&
2917 ret_state == STMF_LOGICAL_UNIT_ONLINE))
2918 return (STMFADM_FAILURE);
2919
2920 if (++count == DELAYED_EXEC_WAIT_MAX) {
2921 (void) fprintf(stderr, "%s: %s\n", cmdName,
2922 gettext("Logical Unit state change request "
2923 "submitted. Waiting for completion "
2924 "timed out"));
2925 return (STMFADM_FAILURE);
2926 }
2927 (void) nanosleep(&ts, NULL);
2928 }
2929 }
2930 return (STMFADM_FAILURE);
2931 }
2932
2933 /*
2934 * onlineLuFunc
2935 *
2936 * Purpose: Online a logical unit
2937 *
2938 */
2939 /*ARGSUSED*/
2940 static int
2941 onlineLuFunc(int operandLen, char *operands[], cmdOptions_t *options,
2942 void *args)
2943 {
2944 int ret;
2945 stmfState state;
2946
2947 ret = getStmfState(&state);
2948 if (ret != STMF_STATUS_SUCCESS)
2949 return (ret);
2950 if (state.operationalState == STMF_SERVICE_STATE_OFFLINE ||
2951 state.operationalState == STMF_SERVICE_STATE_OFFLINING) {
2952 (void) fprintf(stderr, "%s: %s\n", cmdName,
2953 gettext("STMF service is offline"));
2954 return (1);
2955 }
2956 return (onlineOfflineLu(operands[0], ONLINE_LU));
2957 }
2958
2959 /*
2960 * offlineLuFunc
2961 *
2962 * Purpose: Offline a logical unit
2963 *
2964 */
2965 /*ARGSUSED*/
2966 static int
2967 offlineLuFunc(int operandLen, char *operands[], cmdOptions_t *options,
2968 void *args)
2969 {
2970 return (onlineOfflineLu(operands[0], OFFLINE_LU));
2971 }
2972
2973 /*
2974 * onlineOfflineTarget
2975 *
2976 * Purpose: Online or offline a target
2977 *
2978 * target - target to online or offline
2979 *
2980 * state - ONLINE_TARGET
2981 * OFFLINE_TARGET
2982 */
2983 static int
2984 onlineOfflineTarget(char *target, int state)
2985 {
2986 int ret = 0, stmfRet = 0;
2987 stmfDevid devid;
2988 stmfTargetProperties targetProps;
2989
2990 if (parseDevid(target, &devid) != 0) {
2991 (void) fprintf(stderr, "%s: %s: %s\n",
2992 cmdName, target, gettext("unrecognized device id"));
2993 return (1);
2994 }
2995 if (state == ONLINE_TARGET) {
2996 ret = stmfOnlineTarget(&devid);
2997 } else if (state == OFFLINE_TARGET) {
2998 ret = stmfOfflineTarget(&devid);
2999 } else {
3000 return (STMFADM_FAILURE);
3001 }
3002 if (ret != STMF_STATUS_SUCCESS) {
3003 switch (ret) {
3004 case STMF_ERROR_PERM:
3005 (void) fprintf(stderr, "%s: %s\n", cmdName,
3006 gettext("permission denied"));
3007 break;
3008 case STMF_ERROR_SERVICE_NOT_FOUND:
3009 (void) fprintf(stderr, "%s: %s\n", cmdName,
3010 gettext("STMF service not found"));
3011 break;
3012 case STMF_ERROR_BUSY:
3013 (void) fprintf(stderr, "%s: %s\n", cmdName,
3014 gettext("resource busy"));
3015 break;
3016 case STMF_ERROR_NOT_FOUND:
3017 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
3018 target, gettext("not found"));
3019 break;
3020 case STMF_ERROR_SERVICE_DATA_VERSION:
3021 (void) fprintf(stderr, "%s: %s\n", cmdName,
3022 gettext("STMF service version incorrect"));
3023 break;
3024 default:
3025 (void) fprintf(stderr, "%s: %s\n", cmdName,
3026 gettext("unknown error"));
3027 break;
3028 }
3029 } else {
3030 struct timespec ts = {0};
3031 unsigned int count = 0;
3032 uint32_t ret_state;
3033
3034 ret_state = (state == ONLINE_TARGET) ?
3035 STMF_TARGET_PORT_ONLINING : STMF_TARGET_PORT_OFFLINING;
3036 ts.tv_nsec = DELAYED_EXEC_WAIT_INTERVAL;
3037
3038 /* CONSTCOND */
3039 while (1) {
3040 stmfRet = stmfGetTargetProperties(&devid, &targetProps);
3041 if (stmfRet == STMF_STATUS_SUCCESS)
3042 ret_state = targetProps.status;
3043
3044 if ((state == ONLINE_TARGET &&
3045 ret_state == STMF_TARGET_PORT_ONLINE) ||
3046 (state == OFFLINE_TARGET &&
3047 ret_state == STMF_TARGET_PORT_OFFLINE)) {
3048 return (STMFADM_SUCCESS);
3049 }
3050
3051 if ((state == ONLINE_TARGET &&
3052 ret_state == STMF_TARGET_PORT_OFFLINE) ||
3053 (state == OFFLINE_TARGET &&
3054 ret_state == STMF_TARGET_PORT_ONLINE)) {
3055 return (STMFADM_FAILURE);
3056 }
3057
3058 if (++count == DELAYED_EXEC_WAIT_MAX) {
3059 (void) fprintf(stderr, "%s: %s\n", cmdName,
3060 gettext("Target state change request "
3061 "submitted. Waiting for completion "
3062 "timed out."));
3063 return (STMFADM_FAILURE);
3064 }
3065 (void) nanosleep(&ts, NULL);
3066 }
3067 }
3068 return (STMFADM_FAILURE);
3069 }
3070
3071 /*
3072 * onlineTargetFunc
3073 *
3074 * Purpose: Online a target
3075 *
3076 */
3077 /*ARGSUSED*/
3078 static int
3079 onlineTargetFunc(int operandLen, char *operands[], cmdOptions_t *options,
3080 void *args)
3081 {
3082 int ret;
3083 stmfState state;
3084
3085 ret = getStmfState(&state);
3086 if (ret != STMF_STATUS_SUCCESS)
3087 return (ret);
3088 if (state.operationalState == STMF_SERVICE_STATE_OFFLINE ||
3089 state.operationalState == STMF_SERVICE_STATE_OFFLINING) {
3090 (void) fprintf(stderr, "%s: %s\n", cmdName,
3091 gettext("STMF service is offline"));
3092 return (1);
3093 }
3094 return (onlineOfflineTarget(operands[0], ONLINE_TARGET));
3095 }
3096
3097 /*
3098 * offlineTargetFunc
3099 *
3100 * Purpose: Offline a target
3101 *
3102 */
3103 /*ARGSUSED*/
3104 static int
3105 offlineTargetFunc(int operandLen, char *operands[], cmdOptions_t *options,
3106 void *args)
3107 {
3108 return (onlineOfflineTarget(operands[0], OFFLINE_TARGET));
3109 }
3110
3111
3112 /*ARGSUSED*/
3113 static int
3114 removeHostGroupMemberFunc(int operandLen, char *operands[],
3115 cmdOptions_t *options, void *args)
3116 {
3117 int i;
3118 int ret = 0;
3119 int stmfRet;
3120 stmfGroupName groupName = {0};
3121 stmfDevid devid;
3122 wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};
3123
3124 for (; options->optval; options++) {
3125 switch (options->optval) {
3126 case 'g':
3127 (void) mbstowcs(groupNamePrint, options->optarg,
3128 sizeof (stmfGroupName) - 1);
3129 bcopy(options->optarg, groupName,
3130 strlen(options->optarg));
3131 break;
3132 default:
3133 (void) fprintf(stderr, "%s: %c: %s\n",
3134 cmdName, options->optval,
3135 gettext("unknown option"));
3136 return (1);
3137 }
3138 }
3139
3140 for (i = 0; i < operandLen; i++) {
3141 if (parseDevid(operands[i], &devid) != 0) {
3142 (void) fprintf(stderr, "%s: %s: %s\n",
3143 cmdName, operands[i],
3144 gettext("unrecognized device id"));
3145 ret++;
3146 continue;
3147 }
3148 stmfRet = stmfRemoveFromHostGroup(&groupName, &devid);
3149 switch (stmfRet) {
3150 case STMF_STATUS_SUCCESS:
3151 break;
3152 case STMF_ERROR_MEMBER_NOT_FOUND:
3153 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
3154 operands[i], gettext("not found"));
3155 ret++;
3156 break;
3157 case STMF_ERROR_GROUP_NOT_FOUND:
3158 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
3159 groupNamePrint, gettext("not found"));
3160 ret++;
3161 break;
3162 case STMF_ERROR_BUSY:
3163 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
3164 operands[i], "resource busy");
3165 ret++;
3166 break;
3167 case STMF_ERROR_SERVICE_NOT_FOUND:
3168 (void) fprintf(stderr, "%s: %s\n", cmdName,
3169 gettext("STMF service not found"));
3170 ret++;
3171 break;
3172 case STMF_ERROR_SERVICE_DATA_VERSION:
3173 (void) fprintf(stderr, "%s: %s\n", cmdName,
3174 gettext("STMF service version incorrect"));
3175 ret++;
3176 break;
3177 case STMF_ERROR_PERM:
3178 (void) fprintf(stderr, "%s: %s\n", cmdName,
3179 gettext("permission denied"));
3180 ret++;
3181 break;
3182 default:
3183 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
3184 operands[i], gettext("unknown error"));
3185 ret++;
3186 break;
3187 }
3188 }
3189
3190 return (ret);
3191 }
3192
3193 /*
3194 * removeTargetGroupMemberFunc
3195 *
3196 * Removes one or more members from a target group
3197 *
3198 */
3199 /*ARGSUSED*/
3200 static int
3201 removeTargetGroupMemberFunc(int operandLen, char *operands[],
3202 cmdOptions_t *options, void *args)
3203 {
3204 int i;
3205 int ret = 0;
3206 int stmfRet;
3207 stmfGroupName groupName = {0};
3208 stmfDevid devid;
3209 wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};
3210
3211 for (; options->optval; options++) {
3212 switch (options->optval) {
3213 case 'g':
3214 (void) mbstowcs(groupNamePrint, options->optarg,
3215 sizeof (stmfGroupName) - 1);
3216 bcopy(options->optarg, groupName,
3217 strlen(options->optarg));
3218 break;
3219 default:
3220 (void) fprintf(stderr, "%s: %c: %s\n",
3221 cmdName, options->optval,
3222 gettext("unknown option"));
3223 return (1);
3224 }
3225 }
3226
3227 for (i = 0; i < operandLen; i++) {
3228 if (parseDevid(operands[i], &devid) != 0) {
3229 (void) fprintf(stderr, "%s: %s: %s\n",
3230 cmdName, operands[i],
3231 gettext("unrecognized device id"));
3232 ret++;
3233 continue;
3234 }
3235 stmfRet = stmfRemoveFromTargetGroup(&groupName, &devid);
3236 switch (stmfRet) {
3237 case STMF_STATUS_SUCCESS:
3238 break;
3239 case STMF_ERROR_MEMBER_NOT_FOUND:
3240 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
3241 operands[i], gettext("not found"));
3242 ret++;
3243 break;
3244 case STMF_ERROR_GROUP_NOT_FOUND:
3245 (void) fprintf(stderr, "%s: %ws: %s\n", cmdName,
3246 groupNamePrint, gettext("not found"));
3247 ret++;
3248 break;
3249 case STMF_ERROR_BUSY:
3250 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
3251 operands[i], gettext("resource busy"));
3252 ret++;
3253 break;
3254 case STMF_ERROR_SERVICE_NOT_FOUND:
3255 (void) fprintf(stderr, "%s: %s\n", cmdName,
3256 gettext("STMF service not found"));
3257 ret++;
3258 break;
3259 case STMF_ERROR_PERM:
3260 (void) fprintf(stderr, "%s: %s\n", cmdName,
3261 gettext("permission denied"));
3262 ret++;
3263 break;
3264 case STMF_ERROR_SERVICE_DATA_VERSION:
3265 (void) fprintf(stderr, "%s: %s\n", cmdName,
3266 gettext("STMF service version incorrect"));
3267 ret++;
3268 break;
3269 case STMF_ERROR_TG_ONLINE:
3270 (void) fprintf(stderr, "%s: %s\n", cmdName,
3271 gettext("STMF target must be offline"));
3272 ret++;
3273 break;
3274 default:
3275 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
3276 operands[i], gettext("unknown error"));
3277 ret++;
3278 break;
3279 }
3280 }
3281
3282 return (ret);
3283 }
3284
3285 /*
3286 * removeViewFunc
3287 *
3288 * Removes one or more view entries from a logical unit
3289 *
3290 */
3291 /*ARGSUSED*/
3292 static int
3293 removeViewFunc(int operandLen, char *operands[], cmdOptions_t *options,
3294 void *args)
3295 {
3296 char sGuid[GUID_INPUT + 1];
3297 stmfViewEntryList *viewEntryList;
3298 stmfGuid inGuid;
3299 uint32_t count;
3300 unsigned int guid[sizeof (stmfGuid)];
3301 char *endPtr;
3302 uint32_t veNbr;
3303 int i;
3304 boolean_t all = B_FALSE;
3305 boolean_t luInput = B_FALSE;
3306 int ret = 0;
3307 int stmfRet;
3308
3309 /* Note: 'l' is required */
3310 for (; options->optval; options++) {
3311 switch (options->optval) {
3312 case 'l':
3313 if (strlen(options->optarg) != GUID_INPUT) {
3314 (void) fprintf(stderr,
3315 "%s: %s: %s %d %s\n",
3316 cmdName, options->optarg,
3317 gettext("must be"), GUID_INPUT,
3318 gettext("hexadecimal digits long"));
3319 return (1);
3320 }
3321 bcopy(options->optarg, sGuid, GUID_INPUT);
3322 luInput = B_TRUE;
3323 break;
3324 case 'a':
3325 /* removing all view entries for this GUID */
3326 all = B_TRUE;
3327 break;
3328 default:
3329 (void) fprintf(stderr, "%s: %c: %s\n",
3330 cmdName, options->optval,
3331 "unknown option");
3332 return (1);
3333 }
3334 }
3335
3336 if (!all && operandLen == 0) {
3337 (void) fprintf(stderr, "%s: %s\n", cmdName,
3338 gettext("no view entries specified"));
3339 return (1);
3340 }
3341
3342 if (!luInput) {
3343 (void) fprintf(stderr, "%s: %s\n", cmdName,
3344 gettext("logical unit (-l) not specified"));
3345 return (1);
3346 }
3347
3348 for (i = 0; i < 32; i++)
3349 sGuid[i] = tolower(sGuid[i]);
3350 sGuid[i] = 0;
3351
3352 (void) sscanf(sGuid, "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
3353 &guid[0], &guid[1], &guid[2], &guid[3], &guid[4], &guid[5],
3354 &guid[6], &guid[7], &guid[8], &guid[9], &guid[10], &guid[11],
3355 &guid[12], &guid[13], &guid[14], &guid[15]);
3356
3357 for (i = 0; i < sizeof (stmfGuid); i++) {
3358 inGuid.guid[i] = guid[i];
3359 }
3360
3361 if ((stmfRet = stmfGetViewEntryList(&inGuid, &viewEntryList))
3362 != STMF_STATUS_SUCCESS) {
3363
3364 switch (stmfRet) {
3365 case STMF_ERROR_BUSY:
3366 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
3367 sGuid, gettext("resource busy"));
3368 break;
3369 case STMF_ERROR_SERVICE_NOT_FOUND:
3370 (void) fprintf(stderr, "%s: %s\n", cmdName,
3371 gettext("STMF service not found"));
3372 break;
3373 case STMF_ERROR_SERVICE_DATA_VERSION:
3374 (void) fprintf(stderr, "%s: %s\n", cmdName,
3375 gettext("STMF service version incorrect"));
3376 break;
3377 case STMF_ERROR_PERM:
3378 (void) fprintf(stderr, "%s: %s\n", cmdName,
3379 gettext("permission denied"));
3380 break;
3381 default:
3382 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
3383 sGuid, gettext("unknown error"));
3384 break;
3385 }
3386 return (1);
3387 }
3388
3389 if (viewEntryList->cnt == 0) {
3390 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
3391 sGuid, gettext("no views found"));
3392 return (1);
3393 }
3394
3395 if (all) {
3396 count = viewEntryList->cnt;
3397 } else {
3398 count = operandLen;
3399 }
3400
3401 for (i = 0; i < count; i++) {
3402 if (all) {
3403 veNbr = viewEntryList->ve[i].veIndex;
3404 } else {
3405 endPtr = NULL;
3406 veNbr = strtol(operands[i], &endPtr, 10);
3407 if (endPtr && *endPtr != 0) {
3408 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
3409 operands[i], gettext("invalid input"));
3410 continue;
3411 }
3412 }
3413 stmfRet = stmfRemoveViewEntry(&inGuid, veNbr);
3414 switch (stmfRet) {
3415 case STMF_STATUS_SUCCESS:
3416 break;
3417 case STMF_ERROR_NOT_FOUND:
3418 (void) fprintf(stderr, "%s: %s: %d: %s\n",
3419 cmdName, sGuid, veNbr,
3420 gettext("not found"));
3421 ret++;
3422 break;
3423 case STMF_ERROR_BUSY:
3424 (void) fprintf(stderr, "%s: %s: %s\n", cmdName,
3425 sGuid, gettext("resource busy"));
3426 ret++;
3427 break;
3428 case STMF_ERROR_SERVICE_NOT_FOUND:
3429 (void) fprintf(stderr, "%s: %s\n", cmdName,
3430 gettext("STMF service not found"));
3431 ret++;
3432 break;
3433 case STMF_ERROR_CONFIG_NONE:
3434 (void) fprintf(stderr, "%s: %s\n", cmdName,
3435 gettext("STMF service is not initialized"));
3436 ret++;
3437 break;
3438 case STMF_ERROR_SERVICE_DATA_VERSION:
3439 (void) fprintf(stderr, "%s: %s\n", cmdName,
3440 gettext("STMF service version incorrect"));
3441 ret++;
3442 break;
3443 default:
3444 (void) fprintf(stderr, "%s: %s, %d: %s",
3445 cmdName, sGuid, veNbr,
3446 gettext("unknown error"));
3447 ret++;
3448 break;
3449 }
3450 }
3451
3452 return (ret);
3453 }
3454
3455 /*
3456 * input:
3457 * execFullName - exec name of program (argv[0])
3458 *
3459 * copied from usr/src/cmd/zoneadm/zoneadm.c in OS/Net
3460 * (changed name to lowerCamelCase to keep consistent with this file)
3461 *
3462 * Returns:
3463 * command name portion of execFullName
3464 */
3465 static char *
3466 getExecBasename(char *execFullname)
3467 {
3468 char *lastSlash, *execBasename;
3469
3470 /* guard against '/' at end of command invocation */
3471 for (;;) {
3472 lastSlash = strrchr(execFullname, '/');
3473 if (lastSlash == NULL) {
3474 execBasename = execFullname;
3475 break;
3476 } else {
3477 execBasename = lastSlash + 1;
3478 if (*execBasename == '\0') {
3479 *lastSlash = '\0';
3480 continue;
3481 }
3482 break;
3483 }
3484 }
3485 return (execBasename);
3486 }
3487
3488 int
3489 main(int argc, char *argv[])
3490 {
3491 synTables_t synTables;
3492 char versionString[VERSION_STRING_MAX_LEN];
3493 int ret;
3494 int funcRet;
3495 void *subcommandArgs = NULL;
3496
3497 (void) setlocale(LC_ALL, "");
3498 (void) textdomain(TEXT_DOMAIN);
3499 /* set global command name */
3500 cmdName = getExecBasename(argv[0]);
3501
3502 (void) snprintf(versionString, VERSION_STRING_MAX_LEN, "%s.%s",
3503 VERSION_STRING_MAJOR, VERSION_STRING_MINOR);
3504 synTables.versionString = versionString;
3505 synTables.longOptionTbl = &longOptions[0];
3506 synTables.subCommandPropsTbl = &subcommands[0];
3507
3508 ret = cmdParse(argc, argv, synTables, subcommandArgs, &funcRet);
3509 if (ret != 0) {
3510 return (ret);
3511 }
3512
3513 return (funcRet);
3514 } /* end main */
Unleashed OS