?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / mpathadm / mpathadm.c
blob407bbdbeab92db7a4bd11f8bb7848bdff9e55128
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 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 * Copyright (c) 2016 by Delphix. All rights reserved.
25 */
26
27 /*
28 * mpathadm.c : MP API CLI program
29 *
30 */
31
32 #include <libintl.h>
33
34 #include <mpapi.h>
35 #include "cmdparse.h"
36 #include "mpathadm_text.h"
37 #include "mpathadm.h"
38
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <unistd.h>
42 #include <stdlib.h>
43 #include <devid.h>
44 #include <fcntl.h>
45
46 /* helper functions */
47 static char *getExecBasename(char *);
48
49 /* object functions per subcommand */
50 static int listFunc(int, char **, int, cmdOptions_t *, void *);
51 static int showFunc(int, char **, int, cmdOptions_t *, void *);
52 static int modifyFunc(int, char **, int, cmdOptions_t *, void *);
53 static int enableFunc(int, char **, int, cmdOptions_t *, void *);
54 static int disableFunc(int, char **, int, cmdOptions_t *, void *);
55 static int failoverFunc(int, char **, int, cmdOptions_t *, void *);
56 static int overrideFunc(int, char **, int, cmdOptions_t *, void *);
57
58 #define VERSION_STRING_MAX_LEN 10
59
60 #define OPTIONSTRING_NAME "name"
61 #define OPTIONSTRING_TPNAME "target-port name"
62 #define OPTIONSTRING_ONOFF "on/off"
63 #define OPTIONSTRING_LBTYPE "loadbalance type"
64 #define OPTIONSTRING_IPORT "initiator-port name"
65 #define OPTIONSTRING_LUNIT "logical-unit name"
66 #define OPTIONSTRING_CANCEL "cancel"
67 #define OPTIONSTRING_VALUE "value"
68
69 /*
70 * Version number: (copied from iscsiadm)
71 * MAJOR - This should only change when there is an incompatible change made
72 * to the interfaces or the output.
73 *
74 * MINOR - This should change whenever there is a new command or new feature
75 * with no incompatible change.
76 */
77 #define VERSION_STRING_MAJOR "1"
78 #define VERSION_STRING_MINOR "0"
79
80
81 /* globals */
82 static char *cmdName;
83
84
85 /*
86 * ****************************************************************************
87 *
88 * getExecBasename - copied from iscsiadm code
89 *
90 * input:
91 * execFullName - exec name of program (argv[0])
92 *
93 * Returns:
94 * command name portion of execFullName
95 *
96 * ****************************************************************************
97 */
98 static char *
99 getExecBasename(char *execFullname)
100 {
101 char *lastSlash, *execBasename;
102
103 /* guard against '/' at end of command invocation */
104 for (;;) {
105 lastSlash = strrchr(execFullname, '/');
106 if (lastSlash == NULL) {
107 execBasename = execFullname;
108 break;
109 } else {
110 execBasename = lastSlash + 1;
111 if (*execBasename == '\0') {
112 *lastSlash = '\0';
113 continue;
114 }
115 break;
116 }
117 }
118 return (execBasename);
119 }
120
121
122 /*
123 * Add new options here
124 */
125
126 /* tables set up based on cmdparse instructions */
127 optionTbl_t longOptions[] = {
128 {"inqname", required_arg, 'n', OPTIONSTRING_NAME},
129 {"target-port", required_arg, 't', OPTIONSTRING_TPNAME},
130 {"autofailback", required_arg, 'a', OPTIONSTRING_ONOFF},
131 {"autoprobe", required_arg, 'p', OPTIONSTRING_ONOFF},
132 {"loadbalance", required_arg, 'b', OPTIONSTRING_LBTYPE},
133 {"initiator-port", required_arg, 'i', OPTIONSTRING_IPORT},
134 {"logical-unit", required_arg, 'l', OPTIONSTRING_LUNIT},
135 {"cancel", no_arg, 'c', OPTIONSTRING_CANCEL},
136 {"vendor-id", required_arg, 'd', OPTIONSTRING_VALUE},
137 {NULL, 0, 0, 0}
138 };
139
140
141 /*
142 * Add new subcommands here
143 */
144 subcommand_t subcommands[] = {
145 {"list", LIST, listFunc},
146 {"show", SHOW, showFunc},
147 {"modify", MODIFY, modifyFunc},
148 {"enable", ENABLE, enableFunc},
149 {"disable", DISABLE, disableFunc},
150 {"failover", FAILOVER, failoverFunc},
151 {"override", OVERRIDE, overrideFunc},
152 {NULL, 0, NULL}
153 };
154
155 /*
156 * Add objects here
157 */
158 object_t objects[] = {
159 {"mpath-support", MPATH_SUPPORT},
160 {"logical-unit", LOGICAL_UNIT},
161 {"LU", LOGICAL_UNIT},
162 {"initiator-port", INITIATOR_PORT},
163 {"path", PATH},
164 {NULL, 0}
165 };
166
167 /*
168 * Rules for subcommands and objects
169 *
170 * command
171 *
172 * reqOpCmd -> subcommands that must have an operand
173 * optOpCmd -> subcommands that may have an operand
174 * noOpCmd -> subcommands that will have no operand
175 * invCmd -> subcommands that are invalid
176 * multOpCmd -> subcommands that can accept multiple operands
177 * operandDefinition -> Usage definition for the operand of this object
178 */
179 objectRules_t objectRules[] = {
180 {MPATH_SUPPORT, SHOW|MODIFY|ADD, LIST|REMOVE, 0,
181 ENABLE|DISABLE|FAILOVER|OVERRIDE, LIST|SHOW|MODIFY,
182 "mpath-support name"},
183 {INITIATOR_PORT, SHOW, LIST, 0,
184 MODIFY|ENABLE|DISABLE|FAILOVER|OVERRIDE|ADD|REMOVE, LIST|SHOW,
185 "initiator-port name"},
186 {LOGICAL_UNIT, SHOW|MODIFY|FAILOVER, LIST, 0,
187 ENABLE|DISABLE|OVERRIDE|ADD|REMOVE, LIST|SHOW|MODIFY,
188 "logical-unit name"},
189 {PATH, 0, 0, ENABLE|DISABLE|OVERRIDE,
190 SHOW|LIST|MODIFY|FAILOVER|ADD|REMOVE, 0,
191 "initiator-port name"},
192 {0, 0, 0, 0, 0, NULL}
193 };
194
195 /*
196 * list of objects, subcommands, valid short options, required flag and
197 * exclusive option string
198 *
199 * If it's not here, there are no options for that object.
200 */
201 optionRules_t optionRules[] = {
202 {LOGICAL_UNIT, LIST, "nt", B_FALSE, NULL},
203 {LOGICAL_UNIT, MODIFY, "apb", B_TRUE, NULL},
204 {MPATH_SUPPORT, MODIFY, "apb", B_TRUE, NULL},
205 {MPATH_SUPPORT, ADD, "d", B_TRUE, NULL},
206 {MPATH_SUPPORT, REMOVE, "d", B_TRUE, NULL},
207 {PATH, ENABLE, "itl", B_TRUE, NULL},
208 {PATH, DISABLE, "itl", B_TRUE, NULL},
209 {PATH, OVERRIDE, "itlc", B_TRUE, NULL},
210 {0, 0, 0, 0, 0}
211 };
212
213
214 /*
215 * ****************************************************************************
216 *
217 * listMpathSupport - mpathadm list mpath-support
218 *
219 * operandLen - number of operands user passed into the cli
220 * operand - pointer to operand list from user
221 *
222 * ****************************************************************************
223 */
224 int
225 listMpathSupport(int operandLen, char *operand[])
226 {
227 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
228 MP_PLUGIN_PROPERTIES pluginProps;
229 MP_OID_LIST *pPluginOidList;
230 boolean_t shown = B_FALSE;
231 /* number of plugins listed */
232 int i, op;
233
234 if ((mpstatus = MP_GetPluginOidList(&pPluginOidList))
235 != MP_STATUS_SUCCESS) {
236 (void) fprintf(stderr, "%s: %s\n", cmdName,
237 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
238 return (mpstatus);
239 }
240 if ((NULL == pPluginOidList) || (pPluginOidList->oidCount < 1)) {
241 (void) fprintf(stderr, "%s: %s\n", cmdName,
242 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
243 return (ERROR_CLI_FAILED);
244 }
245
246
247 /* loop through operands first */
248 for (op = 0; (op < operandLen) |
249 ((0 == operandLen) && (B_FALSE == shown)); op++) {
250 shown = B_TRUE;
251 for (i = 0; i < pPluginOidList->oidCount; i++) {
252
253 (void) memset(&pluginProps, 0,
254 sizeof (MP_PLUGIN_PROPERTIES));
255 mpstatus =
256 MP_GetPluginProperties(pPluginOidList->oids[i],
257 &pluginProps);
258 if (mpstatus != MP_STATUS_SUCCESS) {
259 (void) fprintf(stderr, "%s: %s\n",
260 cmdName, getTextString(ERR_NO_PROPERTIES));
261 } else {
262 if (0 == operandLen) {
263 /* if no operands, list them all */
264 (void) printf("%s %s\n",
265 getTextString(
266 TEXT_LB_MPATH_SUPPORT),
267 pluginProps.fileName);
268 } else {
269 /* if there is an operand... */
270 /* ... compare and display if match */
271 if (0 ==
272 strcmp(operand[op],
273 pluginProps.fileName)) {
274 (void) printf("%s %s\n",
275 getTextString(
276 TEXT_LB_MPATH_SUPPORT),
277 pluginProps.fileName);
278 } else {
279 /* begin back-up indentation */
280 /* LINTED E_SEC_PRINTF_VAR_FMT */
281 (void) fprintf(stderr, getTextString(
282 ERR_CANT_FIND_MPATH_SUPPORT_WITH_NAME),
283 operand[op]);
284 /* end back-up indentation */
285 (void) printf("\n");
286 }
287 }
288 }
289 }
290 }
291
292 return (mpstatus);
293 }
294
295
296 /*
297 * ****************************************************************************
298 *
299 * showMpathSupport - mpathadm show mpath-support <mpath-support name>, ...
300 *
301 * operandLen - number of operands user passed into the cli
302 * operand - pointer to operand list from user
303 *
304 * ****************************************************************************
305 */
306 int
307 showMpathSupport(int operandLen, char *operand[])
308 {
309 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
310 MP_PLUGIN_PROPERTIES pluginProps;
311 MP_OID_LIST *pPluginOidList;
312 MP_OID_LIST *deviceOidListArray;
313 MP_DEVICE_PRODUCT_PROPERTIES devProps;
314 boolean_t bListIt = B_FALSE;
315 int op, i, j;
316 MP_LOAD_BALANCE_TYPE lb;
317
318
319 if ((mpstatus = MP_GetPluginOidList(&pPluginOidList)) !=
320 MP_STATUS_SUCCESS) {
321 (void) fprintf(stderr, "%s: %s\n",
322 cmdName, getTextString(ERR_NO_MPATH_SUPPORT_LIST));
323 return (mpstatus);
324 }
325 if ((NULL == pPluginOidList) || (pPluginOidList->oidCount < 1)) {
326 (void) fprintf(stderr, "%s: %s\n",
327 cmdName, getTextString(ERR_NO_MPATH_SUPPORT_LIST));
328 return (ERROR_CLI_FAILED);
329 }
330
331 for (op = 0; op < operandLen; op++) {
332 bListIt = B_FALSE;
333
334 for (i = 0; i < pPluginOidList->oidCount; i++) {
335
336 (void) memset(&pluginProps, 0,
337 sizeof (MP_PLUGIN_PROPERTIES));
338 mpstatus =
339 MP_GetPluginProperties(pPluginOidList->oids[i],
340 &pluginProps);
341 if (MP_STATUS_SUCCESS != mpstatus) {
342 (void) fprintf(stderr, "%s: %s\n",
343 cmdName, getTextString(ERR_NO_PROPERTIES));
344 return (mpstatus);
345 }
346
347 if (0 == operandLen) {
348 /* if no operand, list it */
349 bListIt = B_TRUE;
350 } else {
351 /* ... compare and display if match */
352 if (0 ==
353 strcmp(operand[op],
354 pluginProps.fileName)) {
355 bListIt = B_TRUE;
356 }
357 }
358
359 if (B_TRUE != bListIt) {
360 break;
361 }
362
363 (void) printf("%s %s\n",
364 getTextString(TEXT_LB_MPATH_SUPPORT),
365 pluginProps.fileName);
366
367 /* display the info for this plugin */
368 (void) printf("\t%s ", getTextString(TEXT_LB_VENDOR));
369 displayWideArray(pluginProps.vendor,
370 sizeof (pluginProps.vendor));
371 (void) printf("\n\t%s ",
372 getTextString(TEXT_LB_DRIVER_NAME));
373 displayArray(pluginProps.driverName,
374 sizeof (pluginProps.driverName));
375 (void) printf("\n\t%s ",
376 getTextString(TEXT_LB_DEFAULT_LB));
377 /* don't ignore load balance type none. */
378 if (pluginProps.defaultloadBalanceType == 0) {
379 (void) printf("%s",
380 getTextString(TEXT_LBTYPE_NONE));
381 } else {
382 displayLoadBalanceString(
383 pluginProps.defaultloadBalanceType);
384 }
385 (void) printf("\n");
386
387
388 (void) printf("\t%s \n",
389 getTextString(TEXT_LB_SUPPORTED_LB));
390 /* check each bit, display string if found set */
391 if (pluginProps.supportedLoadBalanceTypes == 0) {
392 (void) printf("\t\t%s\n",
393 getTextString(TEXT_LBTYPE_NONE));
394 } else {
395 lb = 1;
396 do {
397 if (0 != (lb & pluginProps.
398 supportedLoadBalanceTypes)) {
399 (void) printf("\t\t");
400 displayLoadBalanceString(lb &
401 pluginProps.
402 supportedLoadBalanceTypes);
403 (void) printf("\n");
404 }
405 lb = lb<<1;
406 } while (lb < 0x80000000);
407 }
408
409 (void) printf("\t%s %s\n",
410 getTextString(TEXT_LB_ALLOWS_ACT_TPG),
411 (MP_TRUE == pluginProps.canSetTPGAccess)?
412 getTextString(TEXT_YES):getTextString(TEXT_NO));
413 (void) printf("\t%s %s\n",
414 getTextString(TEXT_LB_ALLOWS_PATH_OV),
415 (MP_TRUE == pluginProps.canOverridePaths)?
416 getTextString(TEXT_YES):getTextString(TEXT_NO));
417 (void) printf("\t%s %d\n",
418 getTextString(TEXT_LB_SUPP_AUTO_FB),
419 pluginProps.autoFailbackSupport);
420 if ((MP_AUTOFAILBACK_SUPPORT_PLUGIN ==
421 pluginProps.autoFailbackSupport) |
422 (MP_AUTOFAILBACK_SUPPORT_PLUGINANDMPLU
423 == pluginProps.autoFailbackSupport)) {
424 (void) printf("\t%s %s\n",
425 getTextString(TEXT_LB_AUTO_FB),
426 pluginProps.pluginAutoFailbackEnabled?\
427 getTextString(TEXT_ON):
428 getTextString(TEXT_OFF));
429 (void) printf("\t%s %d/%d\n",
430 getTextString(TEXT_LB_FB_POLLING_RATE),
431 pluginProps.currentFailbackPollingRate,
432 pluginProps.failbackPollingRateMax);
433 } else {
434 (void) printf("\t%s %s\n",
435 getTextString(TEXT_LB_AUTO_FB),
436 getTextString(TEXT_NA));
437 (void) printf("\t%s %s/%s\n",
438 getTextString(TEXT_LB_FB_POLLING_RATE),
439 getTextString(TEXT_NA),
440 getTextString(TEXT_NA));
441 }
442 (void) printf("\t%s %d\n",
443 getTextString(TEXT_LB_SUPP_AUTO_P),
444 pluginProps.autoProbingSupport);
445 if ((MP_AUTOPROBING_SUPPORT_PLUGIN ==
446 pluginProps.autoProbingSupport) |
447 (MP_AUTOPROBING_SUPPORT_PLUGIN ==
448 pluginProps.autoProbingSupport)) {
449 (void) printf("\t%s %s\n",
450 getTextString(TEXT_LB_AUTO_PROB),
451 (MP_TRUE ==
452 pluginProps.pluginAutoProbingEnabled)?\
453 getTextString(TEXT_YES):
454 getTextString(TEXT_NO));
455 (void) printf("\t%s %d/%d\n",
456 getTextString(TEXT_LB_PR_POLLING_RATE),
457 pluginProps.currentProbingPollingRate,
458 pluginProps.probingPollingRateMax);
459 } else {
460 (void) printf("\t%s %s\n",
461 getTextString(TEXT_LB_AUTO_PROB),
462 getTextString(TEXT_NA));
463 (void) printf("\t%s %s/%s\n",
464 getTextString(TEXT_LB_PR_POLLING_RATE),
465 getTextString(TEXT_NA),
466 getTextString(TEXT_NA));
467 }
468
469
470 (void) printf("\t%s\n",
471 getTextString(TEXT_LB_SUPP_DEVICES));
472
473
474 if (MP_TRUE !=
475 pluginProps.onlySupportsSpecifiedProducts) {
476 /* LINTED E_SEC_PRINTF_VAR_FMT */
477 (void) printf(getTextString(TEXT_ANY_DEVICE));
478 } else {
479 /* if only supports specific products, */
480 /* get device product properties supported */
481
482 mpstatus = MP_GetDeviceProductOidList(\
483 pPluginOidList->oids[i],
484 &deviceOidListArray);
485 if (mpstatus != MP_STATUS_SUCCESS) {
486 (void) fprintf(stderr, "%s: %s\n",
487 cmdName, getTextString(
488 ERR_NO_SUPP_DEVICE_INFO));
489 /* can't get any more info, */
490 /* so we're done with this one */
491 break;
492 }
493
494 for (j = 0; j < deviceOidListArray->oidCount;
495 j++) {
496 /* begin backup indentation */
497 (void) memset(&devProps, 0,
498 sizeof (MP_DEVICE_PRODUCT_PROPERTIES));
499 /* end backup indentation */
500 if ((mpstatus =
501 MP_GetDeviceProductProperties(\
502 deviceOidListArray->oids[j],
503 &devProps)) == MP_STATUS_SUCCESS) {
504
505 (void) printf("\t\t%s ",
506 getTextString(
507 TEXT_LB_VENDOR));
508 displayArray(devProps.vendor,
509 sizeof (devProps.vendor));
510 (void) printf("\n\t\t%s ",
511 getTextString(
512 TEXT_LB_PRODUCT));
513 displayArray(devProps.product,
514 sizeof (devProps.product));
515 (void) printf("\n\t\t%s ",
516 getTextString(
517 TEXT_LB_REVISION));
518 displayArray(devProps.revision,
519 sizeof (devProps.revision));
520
521 (void) printf("\n\t\t%s\n",
522 getTextString(
523 TEXT_LB_SUPPORTED_LB));
524 /* begin back-up indentation */
525 if (devProps.supportedLoadBalanceTypes == 0) {
526 (void) printf("\t\t\t%s\n",
527 getTextString(TEXT_LBTYPE_NONE));
528 } else {
529 lb = 1;
530 do {
531 if (0 != (lb &
532 devProps.supportedLoadBalanceTypes)) {
533 (void) printf("\t\t\t");
534 displayLoadBalanceString(lb &
535 devProps.supportedLoadBalanceTypes);
536 (void) printf("\n");
537 }
538 lb = lb<<1;
539 } while (lb < 0x80000000);
540 }
541 /* end back-up indentation */
542 (void) printf("\n");
543
544 } else {
545 (void) fprintf(stderr,
546 "%s: %s\n", cmdName,
547 getTextString(
548 ERR_NO_SUPP_DEVICE_INFO));
549 }
550 } /* for j */
551 } /* if only supports specified devices */
552
553 } /* for each plugin */
554
555 if (B_FALSE == bListIt) {
556 /* LINTED E_SEC_PRINTF_VAR_FMT */
557 (void) fprintf(stderr, getTextString(
558 ERR_CANT_FIND_MPATH_SUPPORT_WITH_NAME),
559 operand[op]);
560 (void) printf("\n");
561
562 }
563
564 } /* for each operand */
565
566
567 return (mpstatus);
568 }
569
570
571 /*
572 * ****************************************************************************
573 *
574 * modifyMpathSupport -
575 * mpathadm modify mpath-support [options] <mpath-support name>, ...
576 *
577 * operandLen - number of operands user passed into the cli
578 * operand - pointer to operand list from user
579 * options - pointer to option list from user
580 *
581 * ****************************************************************************
582 */
583 int
584 modifyMpathSupport(int operandLen, char *operand[], cmdOptions_t *options)
585 {
586 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
587 MP_PLUGIN_PROPERTIES pluginProps;
588 MP_OID_LIST *pPluginOidList;
589 boolean_t bFoundIt = B_FALSE;
590 MP_OID pluginOid;
591 cmdOptions_t *optionList = options;
592 char *cmdStr = getTextString(TEXT_UNKNOWN);
593 int op, i, lbValue;
594
595 if ((mpstatus = MP_GetPluginOidList(&pPluginOidList))
596 != MP_STATUS_SUCCESS) {
597 (void) fprintf(stderr, "%s: %s\n", cmdName,
598 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
599 return (mpstatus);
600 }
601 if ((NULL == pPluginOidList) || (pPluginOidList->oidCount < 1)) {
602 (void) fprintf(stderr, "%s: %s\n", cmdName,
603 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
604 return (ERROR_CLI_FAILED);
605 }
606
607 for (op = 0; op < operandLen; op++) {
608 bFoundIt = B_FALSE;
609 for (i = 0;
610 (i < pPluginOidList->oidCount) && (B_TRUE != bFoundIt);
611 i++) {
612
613 (void) memset(&pluginProps, 0,
614 sizeof (MP_PLUGIN_PROPERTIES));
615 if ((mpstatus =
616 MP_GetPluginProperties(pPluginOidList->oids[i],
617 &pluginProps)) == MP_STATUS_SUCCESS) {
618
619 if (0 == strcmp(operand[op],
620 pluginProps.fileName)) {
621 bFoundIt = B_TRUE;
622 pluginOid = pPluginOidList->oids[i];
623 }
624 } else {
625 (void) fprintf(stderr, "%s: %s\n",
626 cmdName, getTextString(ERR_NO_PROPERTIES));
627 }
628
629 if (B_FALSE == bFoundIt) {
630 break;
631 }
632
633 /* begin back-up indentation */
634 /* we found the plugin oid */
635 /* now change the options requested */
636 switch (optionList->optval) {
637 case 'a':
638 /* modify autofailback */
639 cmdStr = getTextString(TEXT_AUTO_FAILBACK);
640 if (0 == strcasecmp(optionList->optarg,
641 getTextString(TEXT_ON))) {
642 mpstatus =
643 MP_EnableAutoFailback(pluginOid);
644 } else if (0 ==
645 strcasecmp(optionList->optarg,
646 getTextString(TEXT_OFF))) {
647 mpstatus =
648 MP_DisableAutoFailback(pluginOid);
649 } else {
650 /* LINTED E_SEC_PRINTF_VAR_FMT */
651 (void) fprintf(stderr, getTextString(
652 ERR_FAILED_TO_CHANGE_OPTION_WITH_REASON),
653 cmdStr,
654 getTextString(TEXT_ILLEGAL_ARGUMENT));
655 (void) printf("\n");
656 return (ERROR_CLI_FAILED);
657 }
658 break;
659 case 'p':
660 /* modify autoprobing */
661 cmdStr = getTextString(TEXT_AUTO_PROBING);
662 if (0 == strcasecmp(optionList->optarg,
663 getTextString(TEXT_ON))) {
664 mpstatus =
665 MP_EnableAutoProbing(pluginOid);
666 } else if (0 ==
667 strcasecmp(optionList->optarg,
668 getTextString(TEXT_OFF))) {
669 mpstatus =
670 MP_DisableAutoProbing(pluginOid);
671 } else {
672 /* LINTED E_SEC_PRINTF_VAR_FMT */
673 (void) fprintf(stderr, getTextString(
674 ERR_FAILED_TO_CHANGE_OPTION_WITH_REASON),
675 cmdStr,
676 getTextString(TEXT_ILLEGAL_ARGUMENT));
677 (void) printf("\n");
678 return (ERROR_CLI_FAILED);
679 }
680 break;
681 case 'b':
682 /* modify loadbalance type */
683 cmdStr = getTextString(TEXT_LOAD_BALANCE);
684 /* user of the cli sends text string, we need the int */
685 /* value to pass to the mpapi */
686 lbValue = getLbValueFromString(optionList->optarg);
687 mpstatus =
688 MP_SetPluginLoadBalanceType(pluginOid,
689 lbValue);
690 break;
691
692 } /* switch */
693 if (MP_STATUS_SUCCESS != mpstatus) {
694 /* LINTED E_SEC_PRINTF_VAR_FMT */
695 (void) fprintf(stderr,
696 getTextString(
697 ERR_FAILED_TO_CHANGE_OPTION_WITH_REASON),
698 cmdStr, getMpStatusStr(mpstatus));
699 (void) printf("\n");
700 return (mpstatus);
701 }
702 /* end back-up indentation */
703
704 } /* for each plugin */
705
706 if (B_FALSE == bFoundIt) {
707 /* LINTED E_SEC_PRINTF_VAR_FMT */
708 (void) fprintf(stderr,
709 getTextString(
710 ERR_FAILED_TO_CHANGE_OPTION_WITH_REASON),
711 cmdStr,
712 getTextString(TEXT_MPATH_SUPPORT_NOT_FOUND));
713 (void) printf("\n");
714 return (ERROR_CLI_FAILED);
715 }
716
717 } /* for each operand */
718
719 return (mpstatus);
720 }
721
722
723 /*
724 * ****************************************************************************
725 *
726 * listLogicalUnit -
727 * mpathadm list {logical-unit | LU} [options] [<logical-unit name>, ...]
728 *
729 * operandLen - number of operands user passed into the cli
730 * operand - pointer to operand list from user
731 * options - pointer to option list from user
732 *
733 * ****************************************************************************
734 */
735 int
736 listLogicalUnit(int operandLen, char *operand[], cmdOptions_t *options)
737 {
738 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
739 MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES luProps;
740 MP_PLUGIN_PROPERTIES pluginProps;
741 MP_TARGET_PORT_PROPERTIES tportProps;
742 MP_OID_LIST *pPluginOidList, *pLogicalUnitOidList,
743 *pTpgOidListArray, *pTportOidListArray;
744 boolean_t bListIt = B_FALSE, bFoundOperand = B_FALSE,
745 *bFoundOption, bContinue = B_FALSE;
746 MP_OID luOid;
747 cmdOptions_t *optionList = options;
748 int opListCount = 0, i = 0, lu = 0, tpg = 0, opoffset = 0, j = 0,
749 opStart = 0, opEnd = 0, opIndex;
750
751 /* count number of options */
752 for (; optionList->optval; optionList++) {
753 opListCount++;
754 }
755
756 bFoundOption = malloc((sizeof (boolean_t)) * opListCount);
757 if (NULL == bFoundOption) {
758 (void) fprintf(stdout, "%s\n",
759 getTextString(ERR_MEMORY_ALLOCATION));
760 return (ERROR_CLI_FAILED);
761 }
762
763 /* list to keep track of multiple options */
764 optionList = options;
765 for (opIndex = 0; opIndex < opListCount; opIndex++) {
766 bFoundOption[opIndex] = B_FALSE;
767 }
768
769 optionList = options;
770
771 /* if no operands or options, list everything we find */
772 if ((0 == operandLen) && (0 == opListCount)) {
773 if ((mpstatus = MP_GetPluginOidList(&pPluginOidList))
774 != MP_STATUS_SUCCESS) {
775 (void) fprintf(stderr, "%s: %s\n", cmdName,
776 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
777 return (mpstatus);
778 }
779 if ((NULL == pPluginOidList) ||
780 (pPluginOidList->oidCount < 1)) {
781 (void) fprintf(stderr, "%s: %s\n", cmdName,
782 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
783 return (ERROR_CLI_FAILED);
784 }
785
786 for (i = 0; i < pPluginOidList->oidCount; i++) {
787 /* get properties so we can list the name */
788 (void) memset(&pluginProps, 0,
789 sizeof (MP_PLUGIN_PROPERTIES));
790 if ((mpstatus =
791 MP_GetPluginProperties(pPluginOidList->oids[i],
792 &pluginProps)) != MP_STATUS_SUCCESS) {
793 (void) fprintf(stderr, "%s: %s\n",
794 cmdName, getTextString(ERR_NO_PROPERTIES));
795 return (mpstatus);
796 }
797
798 /* attempt to find this logical unit */
799 mpstatus = MP_GetMultipathLus(pPluginOidList->oids[i],
800 &pLogicalUnitOidList);
801 if (mpstatus != MP_STATUS_SUCCESS) {
802 (void) fprintf(stderr, "%s: %s\n",
803 cmdName, getTextString(ERR_NO_LU_LIST));
804 return (mpstatus);
805 }
806
807 for (lu = 0; lu < pLogicalUnitOidList->oidCount; lu++) {
808 /* begin backup indentation */
809 /* get lu properties so we can check the name */
810 (void) memset(&luProps, 0,
811 sizeof (MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES));
812 /* end backup indentation */
813 mpstatus =
814 MP_GetMPLogicalUnitProperties(
815 pLogicalUnitOidList->oids[lu],
816 &luProps);
817 if (mpstatus != MP_STATUS_SUCCESS) {
818 (void) fprintf(stderr, "%s: %s\n",
819 cmdName,
820 getTextString(ERR_NO_PROPERTIES));
821 return (mpstatus);
822 }
823
824 luOid = pLogicalUnitOidList->oids[lu];
825 if (listIndividualLogicalUnit(luOid, luProps)
826 != 0) {
827 return (ERROR_CLI_FAILED);
828 }
829 } /* for each LU */
830 } /* for each plugin */
831 } else { /* we have operands and/or options */
832
833 /* check if we have operands */
834 if (0 == operandLen) {
835 /* no operands */
836 opStart = -1;
837 opEnd = 0;
838 } else {
839 /* operands */
840 opStart = 0;
841 opEnd = operandLen;
842 }
843
844 if ((mpstatus = MP_GetPluginOidList(&pPluginOidList))
845 != MP_STATUS_SUCCESS) {
846 (void) fprintf(stderr, "%s: %s\n", cmdName,
847 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
848 return (mpstatus);
849 }
850 if ((NULL == pPluginOidList) ||
851 (pPluginOidList->oidCount < 1)) {
852 (void) fprintf(stderr, "%s: %s\n", cmdName,
853 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
854 return (ERROR_CLI_FAILED);
855 }
856
857 for (opoffset = opStart; opoffset < opEnd; opoffset++) {
858 /* loop through operands */
859 bFoundOperand = B_FALSE;
860
861 for (i = 0; i < pPluginOidList->oidCount; i++) {
862
863 /*
864 * loop through plugin, and get properties
865 * so we can list the name
866 */
867 (void) memset(&pluginProps, 0,
868 sizeof (MP_PLUGIN_PROPERTIES));
869 if ((mpstatus =
870 MP_GetPluginProperties(
871 pPluginOidList->oids[i], &pluginProps))
872 != MP_STATUS_SUCCESS) {
873 (void) fprintf(stderr, "%s: %s\n",
874 cmdName,
875 getTextString(ERR_NO_PROPERTIES));
876 return (mpstatus);
877 }
878
879 /* attempt to find this logical unit */
880 mpstatus =
881 MP_GetMultipathLus(pPluginOidList->oids[i],
882 &pLogicalUnitOidList);
883 if (mpstatus != MP_STATUS_SUCCESS) {
884 (void) fprintf(stderr, "%s: %s\n",
885 cmdName,
886 getTextString(ERR_NO_LU_LIST));
887 return (mpstatus);
888 }
889
890 for (lu = 0;
891 (lu < pLogicalUnitOidList->oidCount);
892 lu++) {
893 bListIt = B_FALSE;
894 /* begin backup indentation */
895 /* get lu props & check the name */
896 (void) memset(&luProps, 0,
897 sizeof (MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES));
898 /* end backup indentation */
899 mpstatus =
900 MP_GetMPLogicalUnitProperties(
901 pLogicalUnitOidList->oids[lu],
902 &luProps);
903 if (mpstatus != MP_STATUS_SUCCESS) {
904 (void) fprintf(stderr,
905 "%s: %s\n", cmdName,
906 getTextString(
907 ERR_NO_PROPERTIES));
908 return (mpstatus);
909 }
910
911 /*
912 * compare operand - is it a match?
913 * If so, continue
914 */
915
916 bContinue = B_TRUE;
917 if (operandLen > 0) {
918 bContinue =
919 compareLUName(
920 operand[opoffset],
921 luProps.deviceFileName);
922 }
923
924 if (B_TRUE == bContinue) {
925
926 if (0 != opListCount) {
927 /* check options */
928
929
930 /* begin backup indentation */
931 optionList = options;
932
933 for (opIndex = 0; optionList->optval; optionList++, opIndex++) {
934 switch (optionList->optval) {
935 case 'n':
936 if (B_TRUE ==
937 compareLUName(optionList->optarg, luProps.name)) {
938 bListIt = B_TRUE;
939 bFoundOperand = B_TRUE;
940 bFoundOption[opIndex] = B_TRUE;
941 }
942 break;
943 case 't':
944 /* get TPG list */
945 mpstatus =
946 MP_GetAssociatedTPGOidList(pLogicalUnitOidList->oids[lu],
947 &pTpgOidListArray);
948 if (mpstatus != MP_STATUS_SUCCESS) {
949 (void) fprintf(stderr, "%s: %s\n", cmdName,
950 getTextString(ERR_NO_ASSOC_TPGS));
951 return (mpstatus);
952 }
953
954 /* get target ports */
955 for (tpg = 0;
956 (NULL != pTpgOidListArray) &&
957 (tpg < pTpgOidListArray->oidCount) &&
958 (B_FALSE == bListIt); tpg++) {
959 mpstatus =
960 MP_GetTargetPortOidList(pTpgOidListArray->oids[tpg],
961 &pTportOidListArray);
962 if (mpstatus != MP_STATUS_SUCCESS) {
963 (void) fprintf(stderr, "%s: %s\n",
964 cmdName,
965 getTextString(ERR_NO_ASSOC_TPORTS));
966 return (mpstatus);
967 }
968
969 /* get target port properties for the name */
970 for (j = 0; (NULL != pTportOidListArray) &&
971 (j < pTportOidListArray->oidCount) &&
972 (B_FALSE == bListIt); j++) {
973 (void) memset(&tportProps, 0,
974 sizeof (MP_TARGET_PORT_PROPERTIES));
975 mpstatus =
976 MP_GetTargetPortProperties(
977 pTportOidListArray->oids[j], &tportProps);
978 if (mpstatus != MP_STATUS_SUCCESS) {
979 (void) fprintf(stderr, "%s: %s\n",
980 cmdName,
981 getTextString(ERR_NO_PROPERTIES));
982 return (mpstatus);
983 }
984
985
986 /* check the name */
987 if (0 == strcmp(optionList->optarg,
988 tportProps.portID)) {
989 bListIt = B_TRUE;
990 bFoundOperand = B_TRUE;
991 bFoundOption[opIndex] = B_TRUE;
992 }
993 } /* for each target port */
994 } /* for each tpg */
995 } /* end switch */
996 } /* loop through options */
997 /* end back-up indentation */
998
999 } else {
1000 /*
1001 * if no options,
1002 * listit
1003 */
1004 bListIt = B_TRUE;
1005 bFoundOperand = B_TRUE;
1006 }
1007 } /* end bContinue check */
1008
1009 if (bListIt) {
1010 (void) printf("%s %s\n",
1011 getTextString(TEXT_LB_MPATH_SUPPORT),
1012 pluginProps.fileName);
1013 luOid = pLogicalUnitOidList->oids[lu];
1014 if (listIndividualLogicalUnit(luOid, luProps)
1015 != 0) {
1016 return (ERROR_CLI_FAILED);
1017 }
1018
1019 }
1020
1021 } /* end LU loop */
1022 } /* end plugin loop */
1023 if ((0 == opListCount) && (0 != operandLen)) {
1024 if (B_FALSE == bFoundOperand) {
1025 /* option/operand combo not found */
1026 /* LINTED E_SEC_PRINTF_VAR_FMT */
1027 (void) fprintf(stderr,
1028 getTextString(
1029 ERR_LU_NOT_FOUND_WITH_MISSING_LU_STR),
1030 operand[opoffset]);
1031 (void) fprintf(stderr, "\n");
1032 }
1033 }
1034
1035 optionList = options;
1036 for (opIndex = 0; optionList->optval; optionList++,
1037 opIndex++) {
1038 if (B_FALSE == bFoundOption[opIndex]) {
1039 /* LINTED E_SEC_PRINTF_VAR_FMT */
1040 (void) fprintf(stderr,
1041 getTextString(
1042 ERR_LU_NOT_FOUND_WITH_MISSING_LU_STR),
1043 optionList->optarg);
1044 (void) fprintf(stderr, "\n");
1045 }
1046 }
1047
1048
1049
1050 } /* end loop through operands */
1051 } /* we have operands and/or options */
1052
1053
1054 return (mpstatus);
1055 }
1056
1057
1058 /*
1059 * ****************************************************************************
1060 *
1061 * compareLUName -
1062 * compare names directly and via devid if no match directly
1063 *
1064 * cmpString - first string to compare
1065 * deviceProperty - string from properties
1066 * sizeToCompare - size of deviceProperty
1067 *
1068 * returns B_TRUE if the strings match either directly or via devid
1069 * B_FALSE otherwise
1070 *
1071 * ****************************************************************************
1072 */
1073 boolean_t
1074 compareLUName(MP_CHAR *cmpString, MP_CHAR *deviceProperty)
1075 {
1076
1077 boolean_t isSame = B_FALSE;
1078 int fd1, fd2;
1079 ddi_devid_t devid1 = NULL, devid2 = NULL;
1080
1081 if (0 == strcmp(cmpString, deviceProperty)) {
1082 isSame = B_TRUE;
1083 } else {
1084 /* user input didn't match, try via devid */
1085 /*
1086 * I don't see a reason to print the error for
1087 * any of these since they'll get the error at
1088 * the end anyway
1089 */
1090
1091 fd1 = fd2 = -1;
1092 if (((fd1 = open(cmpString, O_RDONLY|O_NDELAY)) >= 0) &&
1093 ((fd2 = open(deviceProperty, O_RDONLY|O_NDELAY)) >= 0) &&
1094 (devid_get(fd1, &devid1) == 0) &&
1095 (devid_get(fd2, &devid2) == 0) &&
1096 ((NULL != devid1) && (NULL != devid2))) {
1097 if (0 ==
1098 (devid_compare(devid1, devid2))) {
1099 isSame = B_TRUE;
1100 }
1101 }
1102
1103 if (NULL != devid1) {
1104 devid_free(devid1);
1105 }
1106 if (NULL != devid2) {
1107 devid_free(devid2);
1108 }
1109
1110 if (fd1 >= 0) {
1111 (void) close(fd1);
1112 }
1113 if (fd2 >= 0) {
1114 (void) close(fd2);
1115 }
1116 } /* compare */
1117
1118 return (isSame);
1119 }
1120
1121
1122 /*
1123 * ****************************************************************************
1124 *
1125 * listIndivudualLogicalUnit -
1126 * Used by list logical unit cli.
1127 * Displays info about an LU
1128 *
1129 * luOid - LU to list
1130 * luProps - properties of the LU to list
1131 *
1132 * ****************************************************************************
1133 */
1134 int
1135 listIndividualLogicalUnit(MP_OID luOid,
1136 MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES luProps)
1137 {
1138 MP_PATH_LOGICAL_UNIT_PROPERTIES pathProps;
1139 MP_OID_LIST *pPathOidListArray;
1140 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
1141 int numOperationalPaths, pa;
1142
1143 (void) printf("\t");
1144 displayArray(luProps.deviceFileName, sizeof (luProps.deviceFileName));
1145 (void) printf("\n");
1146
1147 mpstatus = MP_GetAssociatedPathOidList(luOid,
1148 &pPathOidListArray);
1149 if (mpstatus != MP_STATUS_SUCCESS) {
1150 /* LINTED E_SEC_PRINTF_VAR_FMT */
1151 (void) fprintf(stderr,
1152 getTextString(ERR_NO_LU_PATH_INFO_WITH_MISSING_LU_STR),
1153 getStringArray(luProps.deviceFileName,
1154 sizeof (luProps.deviceFileName)));
1155 (void) fprintf(stderr, "\n");
1156 return (mpstatus);
1157 }
1158 (void) printf("\t\t%s %d\n",
1159 getTextString(TEXT_LB_PATH_COUNT), pPathOidListArray->oidCount);
1160
1161 numOperationalPaths = 0;
1162 for (pa = 0; pa < pPathOidListArray->oidCount; pa++) {
1163 (void) memset(&pathProps, 0,
1164 sizeof (MP_PATH_LOGICAL_UNIT_PROPERTIES));
1165 mpstatus =
1166 MP_GetPathLogicalUnitProperties(
1167 pPathOidListArray->oids[pa], &pathProps);
1168 if (mpstatus != MP_STATUS_SUCCESS) {
1169 (void) fprintf(stderr, "%s: %s\n",
1170 cmdName, getTextString(ERR_NO_PROPERTIES));
1171 return (mpstatus);
1172 }
1173
1174 /* cycle through and check status of each for */
1175 /* operation path count */
1176 if (MP_PATH_STATE_OKAY == pathProps.pathState) {
1177 numOperationalPaths++;
1178 }
1179 }
1180
1181 (void) printf("\t\t%s %d\n",
1182 getTextString(TEXT_LB_OP_PATH_COUNT), numOperationalPaths);
1183
1184 return (mpstatus);
1185 }
1186
1187
1188 /*
1189 * ****************************************************************************
1190 *
1191 * showLogicalUnit -
1192 * mpathadm show {logical-unit | LU} <logical-unit name>, ...
1193 *
1194 * operandLen - number of operands user passed into the cli
1195 * operand - pointer to operand list from user
1196 *
1197 * ****************************************************************************
1198 */
1199 int
1200 showLogicalUnit(int operandLen, char *operand[])
1201 {
1202 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
1203 MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES luProps;
1204 MP_PLUGIN_PROPERTIES pluginProps;
1205 MP_OID luOid, pluginOid;
1206
1207 int op;
1208
1209 for (op = 0; op < operandLen; op++) {
1210 if (op > 0) {
1211 (void) printf("\n");
1212 }
1213 if (B_TRUE == getLogicalUnitOid(operand[op], &luOid)) {
1214 (void) memset(&luProps, 0,
1215 sizeof (MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES));
1216 mpstatus =
1217 MP_GetMPLogicalUnitProperties(
1218 luOid, &luProps);
1219 if (mpstatus != MP_STATUS_SUCCESS) {
1220 (void) fprintf(stderr, "%s: %s\n",
1221 cmdName, getTextString(ERR_NO_PROPERTIES));
1222 return (mpstatus);
1223 }
1224
1225 mpstatus =
1226 MP_GetAssociatedPluginOid(luOid, &pluginOid);
1227 if (mpstatus != MP_STATUS_SUCCESS) {
1228 (void) fprintf(stderr, "%s: %s\n",
1229 cmdName,
1230 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
1231 return (mpstatus);
1232 }
1233
1234 mpstatus =
1235 MP_GetPluginProperties(pluginOid, &pluginProps);
1236 if (mpstatus != MP_STATUS_SUCCESS) {
1237 (void) fprintf(stderr, "%s: %s\n",
1238 cmdName, getTextString(ERR_NO_PROPERTIES));
1239 return (mpstatus);
1240 }
1241
1242 if (showIndividualLogicalUnit(luOid, luProps,
1243 pluginProps) != 0) {
1244 return (ERROR_CLI_FAILED);
1245 }
1246
1247 } else {
1248 /* LINTED E_SEC_PRINTF_VAR_FMT */
1249 (void) fprintf(stderr, getTextString(
1250 ERR_LU_NOT_FOUND_WITH_MISSING_LU_STR),
1251 operand[op]);
1252 (void) printf("\n");
1253 }
1254
1255 } /* for each operand */
1256
1257 return (mpstatus);
1258 }
1259
1260
1261 /*
1262 * ****************************************************************************
1263 *
1264 * showIndivudualLogicalUnit -
1265 * Used by show logical unit cli.
1266 * Displays info about an LU
1267 *
1268 * luOid - LU to show
1269 * luProps - properties of the LU to show
1270 * pluginProps - propertis of the plugin this LU belongs to
1271 *
1272 * ****************************************************************************
1273 */
1274 int
1275 showIndividualLogicalUnit(MP_OID luOid,
1276 MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES luProps,
1277 MP_PLUGIN_PROPERTIES pluginProps)
1278 {
1279 MP_PATH_LOGICAL_UNIT_PROPERTIES pathProps;
1280 MP_TARGET_PORT_GROUP_PROPERTIES tpgProps;
1281 MP_TARGET_PORT_PROPERTIES tportProps;
1282 MP_INITIATOR_PORT_PROPERTIES initProps;
1283 MP_OID_LIST *pPathOidListArray, *pTPGOidListArray,
1284 *pTportOidListArray;
1285 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
1286 boolean_t showTportLabel = B_TRUE;
1287
1288 int pa, tpg, tport;
1289
1290 (void) printf("%s ", getTextString(TEXT_LB_LOGICAL_UNIT));
1291 displayArray(luProps.deviceFileName, sizeof (luProps.deviceFileName));
1292 (void) printf("\n");
1293 (void) printf("\t%s %s\n", getTextString(TEXT_LB_MPATH_SUPPORT),
1294 pluginProps.fileName);
1295
1296 (void) printf("\t%s ", getTextString(TEXT_LB_VENDOR));
1297 displayArray(luProps.vendor,
1298 sizeof (luProps.vendor));
1299 (void) printf("\n\t%s ", getTextString(TEXT_LB_PRODUCT));
1300 displayArray(luProps.product,
1301 sizeof (luProps.product));
1302 (void) printf("\n\t%s ", getTextString(TEXT_LB_REVISION));
1303 displayArray(luProps.revision,
1304 sizeof (luProps.revision));
1305 (void) printf("\n\t%s ", getTextString(TEXT_LB_INQUIRY_NAME_TYPE));
1306 displayLogicalUnitNameTypeString(luProps.nameType);
1307 (void) printf("\n\t%s ", getTextString(TEXT_LB_INQUIRY_NAME));
1308 displayArray(luProps.name, sizeof (luProps.name));
1309 (void) printf("\n\t%s %s\n", getTextString(TEXT_LB_ASYMMETRIC),
1310 (MP_TRUE == luProps.asymmetric)?
1311 getTextString(TEXT_YES):getTextString(TEXT_NO));
1312
1313 (void) printf("\t%s ", getTextString(TEXT_LB_CURR_LOAD_BALANCE));
1314 /* don't ignore load balance type none. */
1315 if (luProps.currentLoadBalanceType == 0) {
1316 (void) printf("%s", getTextString(TEXT_LBTYPE_NONE));
1317 } else {
1318 displayLoadBalanceString(luProps.currentLoadBalanceType);
1319 }
1320 (void) printf("\n");
1321
1322 (void) printf("\t%s ", getTextString(TEXT_LB_LU_GROUP_ID));
1323 if (0xffffffff == luProps.logicalUnitGroupID) {
1324 (void) printf("%s\n", getTextString(TEXT_NA));
1325 } else {
1326 (void) printf("0x%x\n", luProps.logicalUnitGroupID);
1327 }
1328
1329 (void) printf("\t%s ", getTextString(TEXT_LB_AUTO_FB));
1330 if (MP_FALSE == pluginProps.autoFailbackSupport) {
1331 (void) printf("%s\n", getTextString(TEXT_NA));
1332 } else {
1333 (void) printf("%s\n", (MP_TRUE == luProps.autoFailbackEnabled)?
1334 getTextString(TEXT_ON):getTextString(TEXT_OFF));
1335 }
1336
1337 (void) printf("\t%s ", getTextString(TEXT_LB_AUTO_PROB));
1338 if (MP_FALSE == pluginProps.autoProbingSupport) {
1339 (void) printf("%s\n", getTextString(TEXT_NA));
1340 } else {
1341 (void) printf("%s\n", (MP_TRUE == luProps.autoProbingEnabled)?
1342 getTextString(TEXT_ON):getTextString(TEXT_OFF));
1343 }
1344
1345
1346 /* get path info */
1347 mpstatus = MP_GetAssociatedPathOidList(luOid, &pPathOidListArray);
1348 if (mpstatus != MP_STATUS_SUCCESS) {
1349 (void) fprintf(stderr, "%s: %s", cmdName,
1350 getTextString(ERR_NO_LU_PATH_INFO));
1351 displayArray(luProps.deviceFileName,
1352 sizeof (luProps.deviceFileName));
1353 (void) fprintf(stderr, "\n");
1354 return (mpstatus);
1355 }
1356
1357 (void) printf("\n\t%s \n", getTextString(TEXT_LB_PATH_INFO));
1358
1359 for (pa = 0; pa < pPathOidListArray->oidCount; pa++) {
1360 (void) memset(&pathProps, 0,
1361 sizeof (MP_PATH_LOGICAL_UNIT_PROPERTIES));
1362 mpstatus = MP_GetPathLogicalUnitProperties(
1363 pPathOidListArray->oids[pa], &pathProps);
1364 if (mpstatus != MP_STATUS_SUCCESS) {
1365 (void) fprintf(stderr, "%s: %s\n",
1366 cmdName, getTextString(ERR_NO_PROPERTIES));
1367 return (mpstatus);
1368 }
1369
1370 (void) printf("\t\t%s ",
1371 getTextString(TEXT_LB_INIT_PORT_NAME));
1372 if ((mpstatus =
1373 MP_GetInitiatorPortProperties(pathProps.initiatorPortOid,
1374 &initProps)) != MP_STATUS_SUCCESS) {
1375 (void) printf("%s\n", getTextString(TEXT_UNKNOWN));
1376 } else {
1377 displayArray(initProps.portID,
1378 sizeof (initProps.portID));
1379 (void) printf("\n");
1380 }
1381
1382 (void) printf("\t\t%s ",
1383 getTextString(TEXT_LB_TARGET_PORT_NAME));
1384 if ((mpstatus =
1385 MP_GetTargetPortProperties(pathProps.targetPortOid,
1386 &tportProps)) != MP_STATUS_SUCCESS) {
1387 (void) printf("%s\n", getTextString(TEXT_UNKNOWN));
1388 } else {
1389 displayArray(tportProps.portID,
1390 sizeof (tportProps.portID));
1391 (void) printf("\n");
1392 }
1393
1394 (void) printf("\t\t%s ", getTextString(TEXT_LB_OVERRIDE_PATH));
1395 if (MP_FALSE == pluginProps.canOverridePaths) {
1396 (void) printf("%s\n", getTextString(TEXT_NA));
1397 } else if (luProps.overridePath.objectSequenceNumber ==
1398 pPathOidListArray->oids[pa].objectSequenceNumber) {
1399 (void) printf("%s\n", getTextString(TEXT_YES));
1400 } else {
1401 (void) printf("%s\n", getTextString(TEXT_NO));
1402 }
1403
1404 (void) printf("\t\t%s %s\n", getTextString(TEXT_LB_PATH_STATE),
1405 getPathStateStr(pathProps.pathState));
1406
1407 (void) printf("\t\t%s %s\n\n", getTextString(TEXT_LB_DISABLED),
1408 pathProps.disabled?getTextString(TEXT_YES):
1409 getTextString(TEXT_NO));
1410
1411 }
1412
1413 /* get tpg info */
1414 mpstatus = MP_GetAssociatedTPGOidList(luOid, &pTPGOidListArray);
1415 if (mpstatus != MP_STATUS_SUCCESS) {
1416 (void) fprintf(stderr, "%s: %s", cmdName,
1417 getTextString(ERR_NO_ASSOC_TPGS));
1418 } else {
1419
1420 /* display tpg info only if is assymetric */
1421 if (MP_TRUE == luProps.asymmetric) {
1422 (void) printf("\t%s \n", getTextString(TEXT_LB_TPG_INFO));
1423 }
1424
1425 for (tpg = 0; tpg < pTPGOidListArray->oidCount; tpg++) {
1426 (void) memset(&tpgProps, 0,
1427 sizeof (MP_TARGET_PORT_GROUP_PROPERTIES));
1428 mpstatus = MP_GetTargetPortGroupProperties(
1429 pTPGOidListArray->oids[tpg], &tpgProps);
1430 if (mpstatus != MP_STATUS_SUCCESS) {
1431 (void) fprintf(stderr, "%s: %s",
1432 cmdName, getTextString(ERR_NO_PROPERTIES));
1433 } else {
1434 /* display tpg info only if is assymetric */
1435 if (tpg > 0) {
1436 (void) printf("\n");
1437 }
1438 if (MP_TRUE == luProps.asymmetric) {
1439 (void) printf("\t\t%s %d\n",
1440 getTextString(TEXT_LB_ID),
1441 tpgProps.tpgID);
1442 (void) printf("\t\t%s %s\n",
1443 getTextString(
1444 TEXT_LB_EXPLICIT_FAILOVER),
1445 (MP_TRUE ==
1446 tpgProps.explicitFailover)?
1447 getTextString(TEXT_YES):
1448 getTextString(TEXT_NO));
1449 (void) printf("\t\t%s %s\n",
1450 getTextString(
1451 TEXT_LB_ACCESS_STATE),
1452 getAccessStateStr(
1453 tpgProps.accessState));
1454 /* display label for each tpg. */
1455 (void) printf("\t\t%s\n",
1456 getTextString(TEXT_TPORT_LIST));
1457 } else {
1458 /* display label once for symmetric. */
1459 if (B_TRUE == showTportLabel) {
1460 /* begin back-up indentation */
1461 (void) printf("\t%s\n",
1462 getTextString(TEXT_TPORT_LIST));
1463 showTportLabel = B_FALSE;
1464 /* end back-up indentation */
1465 }
1466 }
1467
1468 /* get target port info */
1469 mpstatus = MP_GetTargetPortOidList(
1470 pTPGOidListArray->oids[tpg],
1471 &pTportOidListArray);
1472 if (mpstatus != MP_STATUS_SUCCESS) {
1473 (void) fprintf(stderr, "%s: %s",
1474 cmdName,
1475 getTextString(ERR_NO_ASSOC_TPORTS));
1476 } else {
1477
1478 /* begin back-up indentation */
1479 for (tport = 0; tport < pTportOidListArray->oidCount; tport++) {
1480 (void) memset(&tportProps, 0,
1481 sizeof (MP_TARGET_PORT_PROPERTIES));
1482 if ((mpstatus =
1483 MP_GetTargetPortProperties(pTportOidListArray->oids[tport],
1484 &tportProps)) != MP_STATUS_SUCCESS) {
1485 (void) fprintf(stderr, "%s: %s",
1486 cmdName, getTextString(ERR_NO_PROPERTIES));
1487 } else {
1488 if (MP_TRUE == luProps.asymmetric) {
1489 (void) printf("\t\t\t%s ",
1490 getTextString(TEXT_LB_NAME));
1491 displayArray(tportProps.portID,
1492 sizeof (tportProps.portID));
1493 (void) printf("\n\t\t\t%s %d\n",
1494 getTextString(TEXT_LB_RELATIVE_ID),
1495 tportProps.relativePortID);
1496 } else {
1497 (void) printf("\t\t%s ",
1498 getTextString(TEXT_LB_NAME));
1499 displayArray(tportProps.portID,
1500 sizeof (tportProps.portID));
1501 (void) printf("\n\t\t%s %d\n",
1502 getTextString(TEXT_LB_RELATIVE_ID),
1503 tportProps.relativePortID);
1504 }
1505 /* insert blank line if not the last target port. */
1506 if (!(tport == (pTportOidListArray->oidCount - 1))) {
1507 (void) printf("\n");
1508 }
1509 }
1510 } /* for each target port */
1511 /* end back-up indentation */
1512
1513 } /* else got target port props */
1514 } /* else got TPG props */
1515 } /* for each TPG */
1516 } /* else got tpg list */
1517
1518
1519 return (mpstatus);
1520 }
1521
1522
1523 /*
1524 * ****************************************************************************
1525 *
1526 * modifyLogicalUnit -
1527 * mpathadm modify {logical-unit | LU} [options] <logical-unit name>, ...
1528 *
1529 * operandLen - number of operands user passed into the cli
1530 * operand - pointer to operand list from user
1531 * options - pointer to option list from user
1532 *
1533 * ****************************************************************************
1534 */
1535 int
1536 modifyLogicalUnit(int operandLen, char *operand[], cmdOptions_t *options)
1537 {
1538 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
1539 MP_OID luOid;
1540 cmdOptions_t *optionList = options;
1541 char *cmdStr = getTextString(TEXT_UNKNOWN);
1542 int op;
1543
1544 for (op = 0; op < operandLen; op++) {
1545 if (B_TRUE != getLogicalUnitOid(operand[op], &luOid)) {
1546 /* LINTED E_SEC_PRINTF_VAR_FMT */
1547 (void) fprintf(stderr,
1548 getTextString(ERR_LU_NOT_FOUND_WITH_MISSING_LU_STR),
1549 operand[op]);
1550 (void) printf("\n");
1551 return (ERROR_CLI_FAILED);
1552 }
1553
1554 /* we found the lu oid, now change the options requested */
1555 switch (optionList->optval) {
1556 case 'a':
1557 /* modify autofailback */
1558 cmdStr = getTextString(TEXT_AUTO_FAILBACK);
1559 if (0 == strcasecmp(optionList->optarg,
1560 getTextString(TEXT_ON))) {
1561 mpstatus =
1562 MP_EnableAutoFailback(luOid);
1563 } else if (0 == strcasecmp(optionList->optarg,
1564 getTextString(TEXT_OFF))) {
1565 mpstatus =
1566 MP_DisableAutoFailback(luOid);
1567 } else {
1568 /* begin back-up indentation */
1569 /* LINTED E_SEC_PRINTF_VAR_FMT */
1570 (void) fprintf(stderr, getTextString(
1571 ERR_FAILED_TO_CHANGE_OPTION_WITH_REASON),
1572 cmdStr, getTextString(
1573 TEXT_ILLEGAL_ARGUMENT));
1574 (void) printf("\n");
1575 return (ERROR_CLI_FAILED);
1576 /* start back-up indentation */
1577 }
1578 break;
1579 case 'p':
1580 /* modify autoprobing */
1581 cmdStr = getTextString(TEXT_AUTO_PROBING);
1582 if (0 == strcasecmp(optionList->optarg,
1583 getTextString(TEXT_ON))) {
1584 mpstatus =
1585 MP_EnableAutoProbing(luOid);
1586 } else if (0 == strcasecmp(optionList->optarg,
1587 getTextString(TEXT_OFF))) {
1588 mpstatus =
1589 MP_DisableAutoProbing(luOid);
1590 } else {
1591 /* begin back-up indentation */
1592 /* LINTED E_SEC_PRINTF_VAR_FMT */
1593 (void) fprintf(stderr, getTextString(
1594 ERR_FAILED_TO_CHANGE_OPTION_WITH_REASON),
1595 cmdStr, getTextString(
1596 TEXT_ILLEGAL_ARGUMENT));
1597 (void) printf("\n");
1598 return (ERROR_CLI_FAILED);
1599 /* end back-up indentation */
1600 }
1601 break;
1602 case 'b':
1603 /* modify loadbalance type */
1604 cmdStr = getTextString(TEXT_LOAD_BALANCE);
1605 mpstatus =
1606 MP_SetLogicalUnitLoadBalanceType(luOid,
1607 getLbValueFromString(optionList->optarg));
1608 break;
1609
1610 } /* switch */
1611 if (MP_STATUS_SUCCESS != mpstatus) {
1612 /* LINTED E_SEC_PRINTF_VAR_FMT */
1613 (void) fprintf(stderr,
1614 getTextString(
1615 ERR_FAILED_TO_CHANGE_OPTION_WITH_REASON),
1616 cmdStr, getMpStatusStr(mpstatus));
1617 (void) printf("\n");
1618 return (ERROR_CLI_FAILED);
1619 }
1620 } /* for each operand */
1621 return (mpstatus);
1622 }
1623
1624
1625 /*
1626 * ****************************************************************************
1627 *
1628 * failoverLogicalUnit -
1629 * mpathadm failover {logical-unit | LU} <logical-unit name>, ...
1630 *
1631 * operand - pointer to operand list from user
1632 *
1633 * ****************************************************************************
1634 */
1635 int
1636 failoverLogicalUnit(char *operand[])
1637 {
1638 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
1639 MP_OID luOid;
1640 MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES luProps;
1641 MP_TARGET_PORT_GROUP_PROPERTIES tpgProps;
1642 MP_OID_LIST *pTpgOidListArray;
1643 boolean_t bFoundIt = B_FALSE;
1644 MP_TPG_STATE_PAIR tpgStatePair;
1645
1646 int tpg;
1647
1648 if (B_TRUE != getLogicalUnitOid(operand[0], &luOid)) {
1649 /* LINTED E_SEC_PRINTF_VAR_FMT */
1650 (void) fprintf(stderr, getTextString(
1651 ERR_LU_NOT_FOUND_WITH_MISSING_LU_STR),
1652 operand[0]);
1653 (void) printf("\n");
1654 return (ERROR_CLI_FAILED);
1655 }
1656
1657 /* get LUN properties and check to be sure it's asymmetric */
1658 (void) memset(&luProps, 0,
1659 sizeof (MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES));
1660 mpstatus =
1661 MP_GetMPLogicalUnitProperties(luOid, &luProps);
1662 if (mpstatus != MP_STATUS_SUCCESS) {
1663 (void) fprintf(stderr, "%s: %s\n",
1664 cmdName, getTextString(ERR_NO_PROPERTIES));
1665 return (mpstatus);
1666 }
1667
1668 if (MP_TRUE != luProps.asymmetric) {
1669 (void) fprintf(stderr, "%s: %s\n",
1670 cmdName, getTextString(ERR_LU_NOT_ASYMMETRIC));
1671 return (ERROR_CLI_FAILED);
1672 }
1673
1674 /* get TPGs for this LUN */
1675 mpstatus =
1676 MP_GetAssociatedTPGOidList(luOid, &pTpgOidListArray);
1677 if (mpstatus != MP_STATUS_SUCCESS) {
1678 (void) fprintf(stderr, "%s: %s\n",
1679 cmdName, getTextString(ERR_NO_ASSOC_TPGS));
1680 return (mpstatus);
1681 }
1682
1683 /* pick a TPG whose state is active or standby, and change it */
1684 /* to opposite via MP_SetTPGAccessState */
1685 bFoundIt = B_FALSE;
1686 for (tpg = 0; tpg < pTpgOidListArray->oidCount; tpg++) {
1687 (void) memset(&tpgProps, 0,
1688 sizeof (MP_TARGET_PORT_GROUP_PROPERTIES));
1689 mpstatus =
1690 MP_GetTargetPortGroupProperties(
1691 pTpgOidListArray->oids[tpg], &tpgProps);
1692 if (mpstatus != MP_STATUS_SUCCESS) {
1693 (void) fprintf(stderr, "%s: %s\n",
1694 cmdName, getTextString(ERR_NO_PROPERTIES));
1695 return (ERROR_CLI_FAILED);
1696 }
1697 if (MP_FALSE == tpgProps.explicitFailover) {
1698 (void) fprintf(stderr, "%s: %s\n",
1699 cmdName, getTextString(ERR_NO_FAILOVER_ALLOWED));
1700 return (ERROR_CLI_FAILED);
1701 }
1702
1703 /* find one that is standby */
1704 if ((MP_ACCESS_STATE_STANDBY ==
1705 tpgProps.accessState) && (B_FALSE == bFoundIt)) {
1706
1707 bFoundIt = B_TRUE;
1708
1709 tpgStatePair.tpgOid =
1710 pTpgOidListArray->oids[tpg];
1711 tpgStatePair.desiredState =
1712 MP_ACCESS_STATE_ACTIVE;
1713 mpstatus =
1714 MP_SetTPGAccess(luOid, 1, &tpgStatePair);
1715 if (MP_STATUS_SUCCESS != mpstatus) {
1716 /* begin back-up indentation */
1717 /* LINTED E_SEC_PRINTF_VAR_FMT */
1718 (void) fprintf(stderr, getTextString(
1719 ERR_FAILED_TO_FAILOVER_WITH_REASON),
1720 getMpStatusStr(mpstatus));
1721 (void) printf("\n");
1722 return (mpstatus);
1723 /* end back-up indentation */
1724 }
1725 }
1726
1727
1728 } /* for each tpg */
1729
1730 if (B_FALSE == bFoundIt) {
1731 (void) fprintf(stderr, "%s: %s\n",
1732 cmdName, getTextString(ERR_LU_ACCESS_STATE_UNCHANGED));
1733 return (ERROR_CLI_FAILED);
1734 }
1735
1736 return (mpstatus);
1737 }
1738
1739
1740 /*
1741 * ****************************************************************************
1742 *
1743 * getLogicalUnitOid -
1744 * Search through all plugins and get the OID for specified logical unit
1745 *
1746 * luFileName - file name of LU (specified by the user) to find
1747 * pLuOid - OID to return
1748 *
1749 * ****************************************************************************
1750 */
1751 boolean_t
1752 getLogicalUnitOid(MP_CHAR *luFileName, MP_OID *pluOid)
1753 {
1754 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
1755 MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES luProps;
1756 MP_PLUGIN_PROPERTIES pluginProps;
1757 MP_OID_LIST *pPluginOidList, *pLogicalUnitOidList;
1758 boolean_t foundIt = B_FALSE;
1759
1760 int i, lu;
1761
1762 int fd1, fd2;
1763 ddi_devid_t devid1, devid2;
1764
1765 if (NULL == pluOid) {
1766 /* print some kind of error msg here - should never happen */
1767 /* LINTED E_SEC_PRINTF_VAR_FMT */
1768 (void) fprintf(stderr, getTextString(ERR_MEMORY_ALLOCATION));
1769 (void) printf("\n");
1770 return (B_FALSE);
1771 }
1772
1773 pluOid->objectSequenceNumber = 0;
1774 pluOid->objectType = 0;
1775 pluOid->ownerId = 0;
1776
1777 if ((mpstatus = MP_GetPluginOidList(&pPluginOidList))
1778 != MP_STATUS_SUCCESS) {
1779 (void) fprintf(stderr, "%s: %s\n", cmdName,
1780 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
1781 return (B_FALSE);
1782 }
1783 if ((NULL == pPluginOidList) || (pPluginOidList->oidCount < 1)) {
1784 (void) fprintf(stderr, "%s: %s\n", cmdName,
1785 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
1786 return (ERROR_CLI_FAILED);
1787 }
1788 for (i = 0; i < pPluginOidList->oidCount; i++) {
1789
1790 /* get properties so we can list the name */
1791 (void) memset(&pluginProps, 0, sizeof (MP_PLUGIN_PROPERTIES));
1792 if ((mpstatus =
1793 MP_GetPluginProperties(pPluginOidList->oids[i],
1794 &pluginProps)) != MP_STATUS_SUCCESS) {
1795 (void) fprintf(stderr, "%s: %s\n",
1796 cmdName, getTextString(ERR_NO_PROPERTIES));
1797 return (B_FALSE);
1798 }
1799
1800 /* attempt to find this logical unit */
1801 mpstatus = MP_GetMultipathLus(pPluginOidList->oids[i],
1802 &pLogicalUnitOidList);
1803 if (mpstatus != MP_STATUS_SUCCESS) {
1804 (void) fprintf(stderr, "%s: %s\n",
1805 cmdName, getTextString(ERR_NO_LU_LIST));
1806 return (B_FALSE);
1807 }
1808
1809 for (lu = 0; (lu < pLogicalUnitOidList->oidCount) &&
1810 (B_FALSE == foundIt); lu++) {
1811
1812 /* get lu properties so we can check the name */
1813 (void) memset(&luProps, 0,
1814 sizeof (MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES));
1815 mpstatus =
1816 MP_GetMPLogicalUnitProperties(
1817 pLogicalUnitOidList->oids[lu], &luProps);
1818 if (mpstatus != MP_STATUS_SUCCESS) {
1819 (void) fprintf(stderr, "%s: %s\n",
1820 cmdName, getTextString(ERR_NO_PROPERTIES));
1821 return (B_FALSE);
1822 }
1823
1824 if (compareLUName(luFileName, luProps.deviceFileName)
1825 == B_TRUE) {
1826 foundIt = B_TRUE;
1827 } else {
1828 /* user input didn't match, try via devid */
1829 /*
1830 * I don't see a reason to print the error for
1831 * any of these since they'll get the error at
1832 * the end anyway
1833 */
1834
1835 fd1 = fd2 = -1;
1836 devid1 = devid2 = NULL;
1837 if (((fd1 = open(luFileName,
1838 O_RDONLY|O_NDELAY)) >= 0) &&
1839 ((fd2 = open(luProps.deviceFileName,
1840 O_RDONLY|O_NDELAY)) >= 0) &&
1841 (devid_get(fd1, &devid1) == 0) &&
1842 (devid_get(fd2, &devid2) == 0) &&
1843 ((NULL != devid1) && (NULL != devid2))) {
1844 if (0 ==
1845 (devid_compare(devid1, devid2))) {
1846 foundIt = B_TRUE;
1847 }
1848 }
1849
1850 if (NULL != devid1) {
1851 devid_free(devid1);
1852 }
1853 if (NULL != devid2) {
1854 devid_free(devid2);
1855 }
1856
1857 if (fd1 >= 0) {
1858 (void) close(fd1);
1859 }
1860 if (fd2 >= 0) {
1861 (void) close(fd2);
1862 }
1863 }
1864 if (B_TRUE == foundIt) {
1865 pluOid->objectSequenceNumber =
1866 pLogicalUnitOidList->
1867 oids[lu].objectSequenceNumber;
1868 pluOid->objectType =
1869 pLogicalUnitOidList->
1870 oids[lu].objectType;
1871 pluOid->ownerId =
1872 pLogicalUnitOidList->oids[lu].ownerId;
1873 }
1874 }
1875 }
1876
1877 return (foundIt);
1878 }
1879
1880
1881 /*
1882 * ****************************************************************************
1883 *
1884 * listInitiatorPort -
1885 * mpathadm list initiator-port [<initiator-port name>, ...]
1886 *
1887 * operandLen - number of operands user passed into the cli
1888 * operand - pointer to operand list from user
1889 *
1890 * ****************************************************************************
1891 */
1892 int
1893 listInitiatorPort(int operandLen, char *operand[])
1894 {
1895 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
1896 MP_INITIATOR_PORT_PROPERTIES initProps;
1897 MP_OID_LIST *pPluginOidList, *pInitOidList;
1898 boolean_t bListIt = B_FALSE;
1899 boolean_t *foundOp;
1900
1901 int ol, i, iport;
1902
1903 foundOp = malloc((sizeof (boolean_t)) * operandLen);
1904 if (NULL == foundOp) {
1905 (void) fprintf(stdout, "%s\n",
1906 getTextString(ERR_MEMORY_ALLOCATION));
1907 return (ERROR_CLI_FAILED);
1908 }
1909
1910 for (ol = 0; ol < operandLen; ol++) {
1911 foundOp[ol] = B_FALSE;
1912 }
1913
1914 if ((mpstatus = MP_GetPluginOidList(&pPluginOidList))
1915 != MP_STATUS_SUCCESS) {
1916 (void) fprintf(stderr, "%s: %s\n", cmdName,
1917 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
1918 return (mpstatus);
1919 }
1920 if ((NULL == pPluginOidList) || (pPluginOidList->oidCount < 1)) {
1921 (void) fprintf(stderr, "%s: %s\n", cmdName,
1922 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
1923 return (ERROR_CLI_FAILED);
1924 }
1925
1926 for (i = 0; i < pPluginOidList->oidCount; i++) {
1927 mpstatus =
1928 MP_GetInitiatorPortOidList(pPluginOidList->oids[i],
1929 &pInitOidList);
1930 if (mpstatus != MP_STATUS_SUCCESS) {
1931 /* LINTED E_SEC_PRINTF_VAR_FMT */
1932 (void) fprintf(stderr,
1933 getTextString(ERR_NO_INIT_PORT_LIST_WITH_REASON),
1934 getMpStatusStr(mpstatus));
1935 (void) printf("\n");
1936 } else if ((NULL == pInitOidList) ||
1937 (pInitOidList->oidCount < 1)) {
1938 (void) fprintf(stderr, "%s: %s\n", cmdName,
1939 getTextString(ERR_NO_INIT_PORTS));
1940 } else {
1941 for (iport = 0;
1942 iport < pInitOidList->oidCount; iport ++) {
1943 bListIt = B_FALSE;
1944 if ((mpstatus =
1945 MP_GetInitiatorPortProperties(
1946 pInitOidList->oids[iport],
1947 &initProps)) != MP_STATUS_SUCCESS) {
1948 (void) fprintf(stderr,
1949 "%s: %s\n", cmdName,
1950 getTextString(ERR_NO_PROPERTIES));
1951 } else {
1952 /* if no operands listed, */
1953 /* list all we find */
1954 if (0 == operandLen) {
1955 bListIt = B_TRUE;
1956 } else {
1957
1958 /* check each operand */
1959 /* Is it */
1960 /* the one we want to list? */
1961 for (ol = 0;
1962 ol < operandLen; ol++) {
1963 if (0 ==
1964 strcmp(operand[ol],
1965 initProps.
1966 portID)) {
1967 bListIt =
1968 B_TRUE;
1969 foundOp[ol] =
1970 B_TRUE;
1971 }
1972 }
1973 }
1974 }
1975
1976 if (B_TRUE == bListIt) {
1977
1978 if (listIndividualInitiatorPort(
1979 initProps) != 0) {
1980 return (ERROR_CLI_FAILED);
1981 }
1982
1983 } /* list It */
1984
1985 } /* for each initiator port */
1986 } /* else found an init port */
1987
1988 } /* for each plugin */
1989
1990 for (ol = 0; ol < operandLen; ol++) {
1991 if (B_FALSE == foundOp[ol]) {
1992 /* LINTED E_SEC_PRINTF_VAR_FMT */
1993 (void) fprintf(stderr, getTextString(
1994 ERR_INIT_PORT_NOT_FOUND_WITH_MISSING_LU_STR),
1995 operand[ol]);
1996 (void) printf("\n");
1997 }
1998 }
1999
2000 return (mpstatus);
2001 }
2002
2003
2004 /*
2005 * ****************************************************************************
2006 *
2007 * listIndividualInitiatorPort -
2008 * used by listInitiatorPort to list info for one init port
2009 *
2010 * initProps - properties of initiator port to list
2011 *
2012 * ****************************************************************************
2013 */
2014 int
2015 listIndividualInitiatorPort(MP_INITIATOR_PORT_PROPERTIES initProps)
2016 {
2017 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
2018
2019 (void) printf("%s ", getTextString(TEXT_LB_INITATOR_PORT));
2020 displayArray(initProps.portID,
2021 sizeof (initProps.portID));
2022 (void) printf("\n");
2023
2024 return (mpstatus);
2025
2026 }
2027
2028
2029 /*
2030 * ****************************************************************************
2031 *
2032 * showInitiatorPort -
2033 * mpathadm show initiator-port <initiator-port name>, ...
2034 *
2035 * operandLen - number of operands user passed into the cli
2036 * operand - pointer to operand list from user
2037 *
2038 * ****************************************************************************
2039 */
2040 int
2041 showInitiatorPort(int operandLen, char *operand[])
2042 {
2043 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
2044 MP_INITIATOR_PORT_PROPERTIES initProps;
2045 MP_OID_LIST *pPluginOidList, *pInitOidList;
2046 boolean_t bListIt = B_FALSE, bFoundIt = B_FALSE;
2047 int op, i, iport;
2048
2049 if ((mpstatus = MP_GetPluginOidList(&pPluginOidList))
2050 != MP_STATUS_SUCCESS) {
2051 (void) fprintf(stderr, "%s: %s\n", cmdName,
2052 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
2053 return (mpstatus);
2054 }
2055 if ((NULL == pPluginOidList) || (pPluginOidList->oidCount < 1)) {
2056 (void) fprintf(stderr, "%s: %s\n", cmdName,
2057 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
2058 return (ERROR_CLI_FAILED);
2059 }
2060
2061 for (op = 0; op < operandLen; op++) {
2062 bFoundIt = B_FALSE;
2063
2064 for (i = 0; i < pPluginOidList->oidCount; i++) {
2065
2066 mpstatus =
2067 MP_GetInitiatorPortOidList(pPluginOidList->oids[i],
2068 &pInitOidList);
2069 if (mpstatus != MP_STATUS_SUCCESS) {
2070 /* LINTED E_SEC_PRINTF_VAR_FMT */
2071 (void) fprintf(stderr,
2072 getTextString(
2073 ERR_NO_INIT_PORT_LIST_WITH_REASON),
2074 getMpStatusStr(mpstatus));
2075 (void) printf("\n");
2076 } else if ((NULL == pInitOidList) ||
2077 (pInitOidList->oidCount < 1)) {
2078 (void) fprintf(stderr, "%s: %s\n", cmdName,
2079 getTextString(ERR_NO_INIT_PORTS));
2080 } else {
2081
2082 for (iport = 0;
2083 iport < pInitOidList->oidCount;
2084 iport ++) {
2085 bListIt = B_FALSE;
2086
2087 if ((mpstatus =
2088 MP_GetInitiatorPortProperties(
2089 pInitOidList->oids[iport],
2090 &initProps))
2091 != MP_STATUS_SUCCESS) {
2092 /* begin back-up indentation */
2093 (void) fprintf(stderr,
2094 "%s: %s\n", cmdName,
2095 getTextString(ERR_NO_PROPERTIES));
2096 /* end back-up indentation */
2097 } else {
2098 if (0 == strcmp(operand[op],
2099 initProps.portID)) {
2100 bListIt = B_TRUE;
2101 bFoundIt = B_TRUE;
2102 }
2103 }
2104
2105 if (B_TRUE == bListIt) {
2106 mpstatus =
2107 showIndividualInitiatorPort(
2108 initProps);
2109 if (0 != mpstatus) {
2110 return (mpstatus);
2111 }
2112
2113 } /* list It */
2114
2115 } /* for each initiator port */
2116 } /* else found an init port */
2117
2118 } /* for each plugin */
2119
2120 if (B_FALSE == bFoundIt) {
2121 /* need temp string here since we need to fill in a */
2122 /* name in the error string */
2123 /* LINTED E_SEC_PRINTF_VAR_FMT */
2124 (void) fprintf(stderr, getTextString(
2125 ERR_INIT_PORT_NOT_FOUND_WITH_MISSING_LU_STR),
2126 operand[op]);
2127 (void) printf("\n");
2128 }
2129
2130 } /* for each operand */
2131
2132 return (mpstatus);
2133 }
2134
2135
2136 /*
2137 * ****************************************************************************
2138 *
2139 * showIndividualInitiatorPort -
2140 * used by showInitiatorPort to show info for one init port
2141 *
2142 * initProps - properties of initiator port to show
2143 *
2144 * ****************************************************************************
2145 */
2146 int
2147 showIndividualInitiatorPort(MP_INITIATOR_PORT_PROPERTIES initProps)
2148 {
2149 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
2150
2151 (void) printf("%s ", getTextString(TEXT_LB_INITATOR_PORT));
2152 displayArray(initProps.portID,
2153 sizeof (initProps.portID));
2154
2155 (void) printf("\n\t%s ", getTextString(TEXT_LB_TRANSPORT_TYPE));
2156 displayTransportTypeString(initProps.portType);
2157 (void) printf("\n");
2158
2159 (void) printf("\t%s ", getTextString(TEXT_LB_OS_DEVICE_FILE));
2160 displayArray(initProps.osDeviceFile,
2161 sizeof (initProps.osDeviceFile));
2162 (void) printf("\n");
2163
2164 return (mpstatus);
2165 }
2166
2167
2168 /*
2169 * ****************************************************************************
2170 *
2171 * enablePath -
2172 * mpathadm enable path -i <initiator-port>
2173 * -t <target-port name> -l <logical-unit name>
2174 *
2175 * options - pointer to option list from user
2176 *
2177 * ****************************************************************************
2178 */
2179 int
2180 enablePath(cmdOptions_t *options)
2181 {
2182 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
2183 MP_OID pathOid;
2184
2185 cmdOptions_t *optionList = options;
2186 boolean_t bHaveInit = B_FALSE, bHaveTarg = B_FALSE, bHaveLu = B_FALSE;
2187
2188 for (; optionList->optval; optionList++) {
2189 switch (optionList->optval) {
2190 case 'i':
2191 /* have init port name */
2192 bHaveInit = B_TRUE;
2193 break;
2194 case 't':
2195 /* have target port id */
2196 bHaveTarg = B_TRUE;
2197 break;
2198 case 'l':
2199 /* have LU name */
2200 bHaveLu = B_TRUE;
2201 break;
2202 }
2203 }
2204 if (B_FALSE == bHaveInit) {
2205 /* LINTED E_SEC_PRINTF_VAR_FMT */
2206 (void) fprintf(stderr,
2207 getTextString(ERR_FAILED_TO_ENABLE_PATH_WITH_REASON),
2208 getTextString(MISSING_INIT_PORT_NAME));
2209 (void) printf("\n");
2210 return (ERROR_CLI_FAILED);
2211 } else if (B_FALSE == bHaveTarg) {
2212 /* LINTED E_SEC_PRINTF_VAR_FMT */
2213 (void) fprintf(stderr,
2214 getTextString(ERR_FAILED_TO_ENABLE_PATH_WITH_REASON),
2215 getTextString(MISSING_TARGET_PORT_NAME));
2216 (void) printf("\n");
2217 return (ERROR_CLI_FAILED);
2218 } else if (B_FALSE == bHaveLu) {
2219 /* LINTED E_SEC_PRINTF_VAR_FMT */
2220 (void) fprintf(stderr,
2221 getTextString(ERR_FAILED_TO_ENABLE_PATH_WITH_REASON),
2222 getTextString(MISSING_LU_NAME));
2223 (void) printf("\n");
2224 return (ERROR_CLI_FAILED);
2225 }
2226
2227 if (B_FALSE == getPathOid(options, &pathOid)) {
2228 /* LINTED E_SEC_PRINTF_VAR_FMT */
2229 (void) fprintf(stderr,
2230 getTextString(ERR_FAILED_TO_ENABLE_PATH_WITH_REASON),
2231 getTextString(FAILED_TO_FIND_PATH));
2232 (void) printf("\n");
2233 return (ERROR_CLI_FAILED);
2234 }
2235
2236 /* found the path, attempt to enable it */
2237 mpstatus = MP_EnablePath(pathOid);
2238 if (mpstatus != MP_STATUS_SUCCESS) {
2239 /* LINTED E_SEC_PRINTF_VAR_FMT */
2240 (void) fprintf(stderr,
2241 getTextString(ERR_FAILED_TO_ENABLE_PATH_WITH_REASON),
2242 getMpStatusStr(mpstatus));
2243 (void) printf("\n");
2244 return (mpstatus);
2245 }
2246
2247 return (mpstatus);
2248 }
2249
2250
2251 /*
2252 * ****************************************************************************
2253 *
2254 * disablePath -
2255 * mpathadm disable path -i <initiator-port>
2256 * -t <target-port name> -l <logical-unit name>
2257 *
2258 * options - pointer to option list from user
2259 *
2260 * ****************************************************************************
2261 */
2262 int
2263 disablePath(cmdOptions_t *options)
2264 {
2265 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
2266 MP_OID pathOid;
2267
2268 cmdOptions_t *optionList = options;
2269 boolean_t bHaveInit = B_FALSE, bHaveTarg = B_FALSE,
2270 bHaveLu = B_FALSE;
2271
2272 for (; optionList->optval; optionList++) {
2273 switch (optionList->optval) {
2274 case 'i':
2275 /* have init port name */
2276 bHaveInit = B_TRUE;
2277 break;
2278 case 't':
2279 /* have target port id */
2280 bHaveTarg = B_TRUE;
2281 break;
2282 case 'l':
2283 /* have LU name */
2284 bHaveLu = B_TRUE;
2285 break;
2286 }
2287 }
2288 if (B_FALSE == bHaveInit) {
2289 /* LINTED E_SEC_PRINTF_VAR_FMT */
2290 (void) fprintf(stderr,
2291 getTextString(ERR_FAILED_TO_DISABLE_PATH_WITH_REASON),
2292 getTextString(MISSING_INIT_PORT_NAME));
2293 (void) printf("\n");
2294 return (ERROR_CLI_FAILED);
2295 } else if (B_FALSE == bHaveTarg) {
2296 /* LINTED E_SEC_PRINTF_VAR_FMT */
2297 (void) fprintf(stderr,
2298 getTextString(ERR_FAILED_TO_DISABLE_PATH_WITH_REASON),
2299 getTextString(MISSING_TARGET_PORT_NAME));
2300 (void) printf("\n");
2301 return (ERROR_CLI_FAILED);
2302 } else if (B_FALSE == bHaveLu) {
2303 /* LINTED E_SEC_PRINTF_VAR_FMT */
2304 (void) fprintf(stderr,
2305 getTextString(ERR_FAILED_TO_DISABLE_PATH_WITH_REASON),
2306 getTextString(MISSING_LU_NAME));
2307 (void) printf("\n");
2308 return (ERROR_CLI_FAILED);
2309 }
2310
2311 if (B_FALSE == getPathOid(options, &pathOid)) {
2312 /* LINTED E_SEC_PRINTF_VAR_FMT */
2313 (void) fprintf(stderr,
2314 getTextString(ERR_FAILED_TO_DISABLE_PATH_WITH_REASON),
2315 getTextString(FAILED_TO_FIND_PATH));
2316 (void) printf("\n");
2317 return (ERROR_CLI_FAILED);
2318 }
2319
2320 /* found the path, attempt to enable it */
2321 mpstatus = MP_DisablePath(pathOid);
2322 if (MP_STATUS_SUCCESS != mpstatus) {
2323 /* LINTED E_SEC_PRINTF_VAR_FMT */
2324 (void) fprintf(stderr, getTextString(
2325 ERR_FAILED_TO_DISABLE_PATH_WITH_REASON),
2326 getMpStatusStr(mpstatus));
2327 (void) printf("\n");
2328 return (mpstatus);
2329 }
2330
2331
2332 return (mpstatus);
2333 }
2334
2335
2336 /*
2337 * ****************************************************************************
2338 *
2339 * overridePath -
2340 * mpathadm override path {-i <initiator-port>
2341 * -t <target-port name> | -c} <logical-unit name>
2342 *
2343 * options - pointer to option list from user
2344 *
2345 * ****************************************************************************
2346 */
2347 int
2348 overridePath(cmdOptions_t *options)
2349 {
2350 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
2351 MP_OID pathOid, luOid;
2352 boolean_t bCancelOverride = B_FALSE;
2353 MP_CHAR pLuDeviceFileName[256];
2354 cmdOptions_t *optionList = options;
2355
2356 /* First check to see if we have the cancel option, */
2357 /* May as well save off the lun while we're at it */
2358 for (; optionList->optval; optionList++) {
2359 switch (optionList->optval) {
2360 case 'c':
2361 /* we have a cancel */
2362 bCancelOverride = B_TRUE;
2363 break;
2364 case 'l':
2365 /* we have a lun- save it while we're here */
2366 (void) memcpy(pLuDeviceFileName,
2367 optionList->optarg, 256);
2368 break;
2369 }
2370 }
2371
2372 if (B_TRUE == bCancelOverride) {
2373 /* if we have the cancel option, */
2374 if (getLogicalUnitOid(pLuDeviceFileName, &luOid) == B_FALSE) {
2375 /* LINTED E_SEC_PRINTF_VAR_FMT */
2376 (void) fprintf(stderr,
2377 getTextString(
2378 ERR_FAILED_TO_CANCEL_OVERRIDE_PATH_WITH_REASON),
2379 getTextString(LU_NOT_FOUND));
2380 (void) printf("\n");
2381 return (ERROR_CLI_FAILED);
2382 }
2383
2384 /* cancel the override path for the specified LU */
2385 mpstatus = MP_CancelOverridePath(luOid);
2386 if (MP_STATUS_SUCCESS != mpstatus) {
2387 /* LINTED E_SEC_PRINTF_VAR_FMT */
2388 (void) fprintf(stderr,
2389 getTextString(
2390 ERR_FAILED_TO_CANCEL_OVERRIDE_PATH_WITH_REASON),
2391 getMpStatusStr(mpstatus));
2392 (void) printf("\n");
2393 return (mpstatus);
2394 }
2395 } else {
2396 /* must be wanting to override the path */
2397 if (getLogicalUnitOid(pLuDeviceFileName, &luOid) == B_FALSE) {
2398 /* LINTED E_SEC_PRINTF_VAR_FMT */
2399 (void) fprintf(stderr,
2400 getTextString(
2401 ERR_FAILED_TO_OVERRIDE_PATH_WITH_REASON),
2402 getTextString(LU_NOT_FOUND));
2403 (void) printf("\n");
2404 return (ERROR_CLI_FAILED);
2405 }
2406
2407 if (B_FALSE == getPathOid(options, &pathOid)) {
2408 /* LINTED E_SEC_PRINTF_VAR_FMT */
2409 (void) fprintf(stderr,
2410 getTextString(
2411 ERR_FAILED_TO_OVERRIDE_PATH_WITH_REASON),
2412 getTextString(FAILED_TO_FIND_PATH));
2413
2414 (void) printf("\n");
2415 return (ERROR_CLI_FAILED);
2416 }
2417
2418 /* attempt to set the override path */
2419 mpstatus = MP_SetOverridePath(luOid, pathOid);
2420 if (mpstatus != MP_STATUS_SUCCESS) {
2421 /* LINTED E_SEC_PRINTF_VAR_FMT */
2422 (void) fprintf(stderr,
2423 getTextString(
2424 ERR_FAILED_TO_OVERRIDE_PATH_WITH_REASON),
2425 getMpStatusStr(mpstatus));
2426 (void) printf("\n");
2427 return (mpstatus);
2428 }
2429 }
2430
2431 return (mpstatus);
2432 }
2433
2434
2435 /*
2436 * ****************************************************************************
2437 *
2438 * getPathOid -
2439 * Search through all plugins and get the OID for specified path
2440 *
2441 * operand - pointer to operand list from user
2442 * options - pointer to option list from user
2443 *
2444 * ****************************************************************************
2445 */
2446 boolean_t
2447 getPathOid(cmdOptions_t *options, MP_OID *pPathOid)
2448 {
2449 MP_STATUS mpstatus = MP_STATUS_SUCCESS;
2450 MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES luProps;
2451 MP_PATH_LOGICAL_UNIT_PROPERTIES pathProps;
2452 MP_INITIATOR_PORT_PROPERTIES initProps;
2453 MP_TARGET_PORT_PROPERTIES targProps;
2454
2455 MP_OID_LIST *pPluginOidList, *pLogicalUnitOidList,
2456 *pathOidListArray;
2457
2458 boolean_t bFoundIt = B_FALSE;
2459 MP_CHAR initPortID[256];
2460 MP_CHAR targetPortID[256];
2461 MP_CHAR luDeviceFileName[256];
2462 boolean_t bHaveTarg = B_FALSE, bHaveLu = B_FALSE,
2463 bHaveInit = B_FALSE;
2464 cmdOptions_t *optionList = options;
2465
2466 int i, lu, pa;
2467 if (NULL == pPathOid) {
2468 return (B_FALSE);
2469 }
2470
2471 for (; optionList->optval; optionList++) {
2472 switch (optionList->optval) {
2473 case 'i':
2474 /* save init port name */
2475 (void) memcpy(initPortID,
2476 optionList->optarg, 256);
2477 bHaveInit = B_TRUE;
2478 break;
2479 case 't':
2480 /* save target port id */
2481 (void) memcpy(targetPortID,
2482 optionList->optarg, 256);
2483 bHaveTarg = B_TRUE;
2484 break;
2485 case 'l':
2486 /* save LU name */
2487 (void) memcpy(luDeviceFileName,
2488 optionList->optarg, 256);
2489 bHaveLu = B_TRUE;
2490 break;
2491 }
2492 }
2493
2494
2495 if ((B_FALSE == bHaveInit) ||
2496 (B_FALSE == bHaveTarg) ||
2497 (B_FALSE == bHaveLu)) {
2498 /* if we don't have all three pieces, we can't find the path */
2499
2500 return (B_FALSE);
2501 }
2502
2503 /* get the plugin ist */
2504 if ((mpstatus = MP_GetPluginOidList(&pPluginOidList))
2505 != MP_STATUS_SUCCESS) {
2506 (void) fprintf(stderr, "%s: %s\n", cmdName,
2507 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
2508 return (B_FALSE);
2509 }
2510 if ((NULL == pPluginOidList) || (pPluginOidList->oidCount < 1)) {
2511 (void) fprintf(stderr, "%s: %s\n", cmdName,
2512 getTextString(ERR_NO_MPATH_SUPPORT_LIST));
2513 return (B_FALSE);
2514 }
2515
2516 for (i = 0; i < pPluginOidList->oidCount; i++) {
2517
2518 /* get Logical Unit list */
2519 mpstatus = MP_GetMultipathLus(pPluginOidList->oids[i],
2520 &pLogicalUnitOidList);
2521 if (mpstatus != MP_STATUS_SUCCESS) {
2522 (void) fprintf(stderr, "%s: %s\n",
2523 cmdName, getTextString(ERR_NO_LU_LIST));
2524 return (B_FALSE);
2525 }
2526
2527 for (lu = 0; (lu < pLogicalUnitOidList->oidCount) &&
2528 (B_FALSE == bFoundIt); lu++) {
2529
2530 /* get lu properties so we can check the name */
2531 (void) memset(&luProps, 0,
2532 sizeof (MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES));
2533 mpstatus =
2534 MP_GetMPLogicalUnitProperties(
2535 pLogicalUnitOidList->oids[lu], &luProps);
2536 if (mpstatus != MP_STATUS_SUCCESS) {
2537 (void) fprintf(stderr, "%s: %s\n",
2538 cmdName, getTextString(ERR_NO_PROPERTIES));
2539 return (B_FALSE);
2540 }
2541 if (compareLUName(luDeviceFileName,
2542 luProps.deviceFileName) == B_TRUE) {
2543 /* get paths for this LU and search from here */
2544 mpstatus =
2545 MP_GetAssociatedPathOidList(
2546 pLogicalUnitOidList->oids[lu],
2547 &pathOidListArray);
2548 if (mpstatus != MP_STATUS_SUCCESS) {
2549 /* LINTED E_SEC_PRINTF_VAR_FMT */
2550 (void) fprintf(stderr,
2551 getTextString(
2552 ERR_FAILED_TO_FIND_PATH));
2553 (void) printf("\n");
2554 return (B_FALSE);
2555 }
2556
2557 for (pa = 0;
2558 (pa < pathOidListArray->oidCount) &&
2559 (B_FALSE == bFoundIt); pa++) {
2560 mpstatus =
2561 MP_GetPathLogicalUnitProperties
2562 (pathOidListArray->oids[pa],
2563 &pathProps);
2564 if (mpstatus != MP_STATUS_SUCCESS) {
2565 (void) fprintf(stderr,
2566 "%s: %s\n", cmdName,
2567 getTextString(
2568 ERR_NO_PROPERTIES));
2569 return (B_FALSE);
2570 }
2571
2572 /*
2573 * get properties of iniator port and
2574 * target port to see if we have the
2575 * right path
2576 */
2577 mpstatus =
2578 MP_GetInitiatorPortProperties(
2579 pathProps.initiatorPortOid,
2580 &initProps);
2581
2582 if (mpstatus != MP_STATUS_SUCCESS) {
2583 (void) fprintf(stderr,
2584 "%s: %s\n", cmdName,
2585 getTextString(
2586 ERR_NO_PROPERTIES));
2587 return (B_FALSE);
2588 }
2589 if (0 == strcmp(initPortID, initProps.portID)) {
2590 /* lu and init port matches, check target port */
2591 mpstatus = MP_GetTargetPortProperties(pathProps.targetPortOid,
2592 &targProps);
2593 if (mpstatus != MP_STATUS_SUCCESS) {
2594 (void) fprintf(stderr, "%s: %s\n", cmdName,
2595 getTextString(ERR_NO_PROPERTIES));
2596 return (B_FALSE);
2597 }
2598
2599 if (0 == strcmp(targetPortID, targProps.portID)) {
2600 /* we found our path */
2601 pPathOid->objectSequenceNumber =
2602 pathOidListArray->oids[pa].objectSequenceNumber;
2603 pPathOid->objectType =
2604 pathOidListArray->oids[pa].objectType;
2605 pPathOid->ownerId = pathOidListArray->oids[pa].ownerId;
2606 bFoundIt = B_TRUE;
2607 }
2608 } /* init port matched */
2609
2610 } /* for each path associated with this lu */
2611
2612 } /* lu matched */
2613
2614 } /* for each lu */
2615
2616 } /* for each plugin */
2617
2618 return (bFoundIt);
2619 }
2620
2621
2622 /*
2623 * ****************************************************************************
2624 *
2625 * getLbValueFromString
2626 * Gets the MP_LOAD_BALANCE_TYPE specified load balance type string
2627 *
2628 * lbStr - load balance string defined in the .h file
2629 * This is what users will be required to feed into the
2630 * modify lu command.
2631 *
2632 * ****************************************************************************
2633 */
2634 MP_LOAD_BALANCE_TYPE
2635 getLbValueFromString(char *lbStr)
2636 {
2637 MP_LOAD_BALANCE_TYPE lbVal = MP_LOAD_BALANCE_TYPE_UNKNOWN;
2638
2639 if (0 == strcmp(lbStr, getTextString(TEXT_LBTYPE_ROUNDROBIN))) {
2640 lbVal = MP_LOAD_BALANCE_TYPE_ROUNDROBIN;
2641 } else if (0 == strcmp(lbStr, getTextString(TEXT_LBTYPE_LEASTBLOCKS))) {
2642 lbVal = MP_LOAD_BALANCE_TYPE_LEASTBLOCKS;
2643 } else if (0 == strcmp(lbStr, getTextString(TEXT_LBTYPE_LEASTIO))) {
2644 lbVal = MP_LOAD_BALANCE_TYPE_LEASTIO;
2645 } else if (0 == strcmp(lbStr, getTextString(TEXT_LBTYPE_DEVICEPROD))) {
2646 lbVal = MP_LOAD_BALANCE_TYPE_DEVICE_PRODUCT;
2647 } else if (0 == strcmp(lbStr, getTextString(TEXT_LBTYPE_LBAREGION))) {
2648 lbVal = MP_LOAD_BALANCE_TYPE_LBA_REGION;
2649 } else if (0 == strcmp(lbStr,
2650 getTextString(TEXT_LBTYPE_FAILOVER_ONLY))) {
2651 lbVal = MP_LOAD_BALANCE_TYPE_FAILOVER_ONLY;
2652 } else if (0 == strcmp(lbStr, getTextString(TEXT_LBTYPE_UNKNOWN))) {
2653 lbVal = MP_LOAD_BALANCE_TYPE_UNKNOWN;
2654 } else if (0 == strcmp(lbStr, getTextString(TEXT_LBTYPE_NONE))) {
2655 lbVal = 0;
2656 } else if (0 == strcmp(lbStr,
2657 getTextString(TEXT_LBTYPE_PROPRIETARY1))) {
2658 lbVal = ((MP_UINT32)0x00000001)<<16;
2659 } else if (0 == strcmp(lbStr,
2660 getTextString(TEXT_LBTYPE_PROPRIETARY2))) {
2661 lbVal = ((MP_UINT32)0x00000001)<<17;
2662 } else if (0 == strcmp(lbStr,
2663 getTextString(TEXT_LBTYPE_PROPRIETARY3))) {
2664 lbVal = ((MP_UINT32)0x00000001)<<18;
2665 } else if (0 == strcmp(lbStr,
2666 getTextString(TEXT_LBTYPE_PROPRIETARY4))) {
2667 lbVal = ((MP_UINT32)0x00000001)<<19;
2668 } else if (0 == strcmp(lbStr,
2669 getTextString(TEXT_LBTYPE_PROPRIETARY5))) {
2670 lbVal = ((MP_UINT32)0x00000001)<<20;
2671 } else if (0 == strcmp(lbStr,
2672 getTextString(TEXT_LBTYPE_PROPRIETARY6))) {
2673 lbVal = ((MP_UINT32)0x00000001)<<21;
2674 } else if (0 == strcmp(lbStr,
2675 getTextString(TEXT_LBTYPE_PROPRIETARY7))) {
2676 lbVal = ((MP_UINT32)0x00000001)<<22;
2677 } else if (0 == strcmp(lbStr,
2678 getTextString(TEXT_LBTYPE_PROPRIETARY8))) {
2679 lbVal = ((MP_UINT32)0x00000001)<<23;
2680 } else if (0 == strcmp(lbStr,
2681 getTextString(TEXT_LBTYPE_PROPRIETARY9))) {
2682 lbVal = ((MP_UINT32)0x00000001)<<24;
2683 } else if (0 == strcmp(lbStr,
2684 getTextString(TEXT_LBTYPE_PROPRIETARY10))) {
2685 lbVal = ((MP_UINT32)0x00000001)<<25;
2686 } else if (0 == strcmp(lbStr,
2687 getTextString(TEXT_LBTYPE_PROPRIETARY11))) {
2688 lbVal = ((MP_UINT32)0x00000001)<<26;
2689 } else if (0 == strcmp(lbStr,
2690 getTextString(TEXT_LBTYPE_PROPRIETARY12))) {
2691 lbVal = ((MP_UINT32)0x00000001)<<27;
2692 } else if (0 == strcmp(lbStr,
2693 getTextString(TEXT_LBTYPE_PROPRIETARY13))) {
2694 lbVal = ((MP_UINT32)0x00000001)<<28;
2695 } else if (0 == strcmp(lbStr,
2696 getTextString(TEXT_LBTYPE_PROPRIETARY14))) {
2697 lbVal = ((MP_UINT32)0x00000001)<<29;
2698 } else if (0 == strcmp(lbStr,
2699 getTextString(TEXT_LBTYPE_PROPRIETARY15))) {
2700 lbVal = ((MP_UINT32)0x00000001)<<30;
2701 } else if (0 == strcmp(lbStr,
2702 getTextString(TEXT_LBTYPE_PROPRIETARY16))) {
2703 lbVal = ((MP_UINT32)0x00000001)<<31;
2704 }
2705
2706 return (lbVal);
2707
2708
2709 } /* end getLbValueFromString */
2710
2711
2712 /*
2713 * ****************************************************************************
2714 *
2715 * displayLogicalUnitNameTypeString
2716 * Displays the text equivalent string for the MP_LOGICAL_UNIT_NAME_TYPE
2717 * specified load balance type
2718 *
2719 * typeVal - load balance type defined in the MPAPI spec
2720 *
2721 * ****************************************************************************
2722 */
2723 void
2724 displayLogicalUnitNameTypeString(MP_LOGICAL_UNIT_NAME_TYPE typeVal)
2725 {
2726
2727 char *typeString;
2728
2729 switch (typeVal) {
2730
2731 case MP_LU_NAME_TYPE_UNKNOWN:
2732 typeString = getTextString(TEXT_NAME_TYPE_UNKNOWN);
2733 break;
2734 case MP_LU_NAME_TYPE_VPD83_TYPE1:
2735 typeString = getTextString(TEXT_NAME_TYPE_VPD83_TYPE1);
2736 break;
2737 case MP_LU_NAME_TYPE_VPD83_TYPE2:
2738 typeString = getTextString(TEXT_NAME_TYPE_VPD83_TYPE2);
2739 break;
2740 case MP_LU_NAME_TYPE_VPD83_TYPE3:
2741 typeString = getTextString(TEXT_NAME_TYPE_VPD83_TYPE3);
2742 break;
2743 case MP_LU_NAME_TYPE_DEVICE_SPECIFIC:
2744 typeString =
2745 getTextString(TEXT_NAME_TYPE_DEVICE_SPECIFIC);
2746 break;
2747 default:
2748 typeString = getTextString(TEXT_UNKNOWN);
2749 break;
2750 }
2751
2752 (void) printf("%s", typeString);
2753
2754
2755 } /* end displayLogicalUnitNameTypeString */
2756
2757 /*
2758 * ****************************************************************************
2759 *
2760 * displayLoadBalanceString
2761 * Displays the text equivalent string for the MP_LOAD_BALANCE_TYPE
2762 * specified load balance type
2763 *
2764 * lbVal - load balance type defined in the MPAPI spec
2765 *
2766 * ****************************************************************************
2767 */
2768 void
2769 displayLoadBalanceString(MP_LOAD_BALANCE_TYPE lbVal)
2770 {
2771
2772 char *lbString;
2773
2774 switch (lbVal) {
2775
2776 case MP_LOAD_BALANCE_TYPE_UNKNOWN:
2777 lbString = getTextString(TEXT_LBTYPE_UNKNOWN);
2778 break;
2779 case MP_LOAD_BALANCE_TYPE_ROUNDROBIN:
2780 lbString = getTextString(TEXT_LBTYPE_ROUNDROBIN);
2781 break;
2782 case MP_LOAD_BALANCE_TYPE_LEASTBLOCKS:
2783 lbString = getTextString(TEXT_LBTYPE_LEASTBLOCKS);
2784 break;
2785 case MP_LOAD_BALANCE_TYPE_LEASTIO:
2786 lbString = getTextString(TEXT_LBTYPE_LEASTIO);
2787 break;
2788 case MP_LOAD_BALANCE_TYPE_DEVICE_PRODUCT:
2789 lbString = getTextString(TEXT_LBTYPE_DEVICEPROD);
2790 break;
2791 case MP_LOAD_BALANCE_TYPE_LBA_REGION:
2792 lbString = getTextString(TEXT_LBTYPE_LBAREGION);
2793 break;
2794 case MP_LOAD_BALANCE_TYPE_FAILOVER_ONLY:
2795 lbString = getTextString(TEXT_LBTYPE_FAILOVER_ONLY);
2796 break;
2797 case (((MP_UINT32)0x00000001)<<16):
2798 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY1);
2799 break;
2800 case (((MP_UINT32)0x00000001)<<17):
2801 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY2);
2802 break;
2803 case (((MP_UINT32)0x00000001)<<18):
2804 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY3);
2805 break;
2806 case (((MP_UINT32)0x00000001)<<19):
2807 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY4);
2808 break;
2809 case (((MP_UINT32)0x00000001)<<20):
2810 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY5);
2811 break;
2812 case (((MP_UINT32)0x00000001)<<21):
2813 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY6);
2814 break;
2815 case (((MP_UINT32)0x00000001)<<22):
2816 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY7);
2817 break;
2818 case (((MP_UINT32)0x00000001)<<23):
2819 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY8);
2820 break;
2821 case (((MP_UINT32)0x00000001)<<24):
2822 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY9);
2823 break;
2824 case (((MP_UINT32)0x00000001)<<25):
2825 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY10);
2826 break;
2827 case (((MP_UINT32)0x00000001)<<26):
2828 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY11);
2829 break;
2830 case (((MP_UINT32)0x00000001)<<27):
2831 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY12);
2832 break;
2833 case (((MP_UINT32)0x00000001)<<28):
2834 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY13);
2835 break;
2836 case (((MP_UINT32)0x00000001)<<29):
2837 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY14);
2838 break;
2839 case (((MP_UINT32)0x00000001)<<30):
2840 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY15);
2841 break;
2842 case (((MP_UINT32)0x00000001)<<31):
2843 lbString = getTextString(TEXT_LBTYPE_PROPRIETARY16);
2844 break;
2845 default:
2846 lbString = getTextString(TEXT_UNKNOWN);
2847 break;
2848 }
2849
2850 (void) printf("%s", lbString);
2851
2852
2853 } /* end displayLoadBalanceString */
2854
2855 /*
2856 * ****************************************************************************
2857 *
2858 * displayTransportTypeString
2859 * Displays the text equivalent string for the MP_PORT_TRANSPORT_TYPE
2860 * specified load balance type
2861 *
2862 * transportTypeVal - transport type defined in the MPAPI spec
2863 *
2864 * ****************************************************************************
2865 */
2866 void
2867 displayTransportTypeString(MP_PORT_TRANSPORT_TYPE transportTypeVal)
2868 {
2869
2870 char *ttypeString;
2871 switch (transportTypeVal) {
2872
2873 case MP_PORT_TRANSPORT_TYPE_MPNODE:
2874 ttypeString =
2875 getTextString(TEXT_TRANS_PORT_TYPE_MPNODE);
2876 break;
2877 case MP_PORT_TRANSPORT_TYPE_FC:
2878 ttypeString = getTextString(TEXT_TRANS_PORT_TYPE_FC);
2879 break;
2880 case MP_PORT_TRANSPORT_TYPE_SPI:
2881 ttypeString = getTextString(TEXT_TRANS_PORT_TYPE_SPI);
2882 break;
2883 case MP_PORT_TRANSPORT_TYPE_ISCSI:
2884 ttypeString = getTextString(TEXT_TRANS_PORT_TYPE_ISCSI);
2885 break;
2886 case MP_PORT_TRANSPORT_TYPE_IFB:
2887 ttypeString = getTextString(TEXT_TRANS_PORT_TYPE_IFB);
2888 break;
2889 default:
2890 ttypeString = getTextString(TEXT_UNKNOWN);
2891 break;
2892 }
2893
2894 (void) printf("%s", ttypeString);
2895
2896 } /* end displayTransportTypeString */
2897
2898
2899 /*
2900 * ****************************************************************************
2901 *
2902 * getMpStatusStr
2903 * Gets the string description for the specified load balance type value
2904 *
2905 * mpstatus - MP_STATUS value
2906 *
2907 * ****************************************************************************
2908 */
2909 char *
2910 getMpStatusStr(MP_STATUS mpstatus)
2911 {
2912 char *statString;
2913
2914 switch (mpstatus) {
2915 case MP_STATUS_SUCCESS:
2916 statString = getTextString(TEXT_MPSTATUS_SUCCESS);
2917 break;
2918 case MP_STATUS_INVALID_PARAMETER:
2919 statString = getTextString(TEXT_MPSTATUS_INV_PARAMETER);
2920 break;
2921 case MP_STATUS_UNKNOWN_FN:
2922 statString = getTextString(TEXT_MPSTATUS_UNKNOWN_FN);
2923 break;
2924 case MP_STATUS_FAILED:
2925 statString = getTextString(TEXT_MPSTATUS_FAILED);
2926 break;
2927 case MP_STATUS_INSUFFICIENT_MEMORY:
2928 statString = getTextString(TEXT_MPSTATUS_INSUFF_MEMORY);
2929 break;
2930 case MP_STATUS_INVALID_OBJECT_TYPE:
2931 statString = getTextString(TEXT_MPSTATUS_INV_OBJ_TYPE);
2932 break;
2933 case MP_STATUS_UNSUPPORTED:
2934 statString = getTextString(TEXT_MPSTATUS_UNSUPPORTED);
2935 break;
2936 case MP_STATUS_OBJECT_NOT_FOUND:
2937 statString = getTextString(TEXT_MPSTATUS_OBJ_NOT_FOUND);
2938 break;
2939 case MP_STATUS_ACCESS_STATE_INVALID:
2940 statString = getTextString(TEXT_MPSTATUS_UNSUPPORTED);
2941 break;
2942 case MP_STATUS_FN_REPLACED:
2943 statString = getTextString(TEXT_MPSTATUS_FN_REPLACED);
2944 break;
2945 case MP_STATUS_PATH_NONOPERATIONAL:
2946 statString = getTextString(TEXT_MPSTATUS_PATH_NONOP);
2947 break;
2948 case MP_STATUS_TRY_AGAIN:
2949 statString = getTextString(TEXT_MPSTATUS_TRY_AGAIN);
2950 break;
2951 case MP_STATUS_NOT_PERMITTED:
2952 statString = getTextString(TEXT_MPSTATUS_NOT_PERMITTED);
2953 break;
2954 default:
2955 statString = getTextString(TEXT_UNKNOWN);
2956 break;
2957 }
2958
2959 return (statString);
2960 } /* end getMpStatusStr */
2961
2962
2963 /*
2964 * ****************************************************************************
2965 *
2966 * GetPathStateStr
2967 * Gets the string description for the specified path state type value
2968 *
2969 * pathState - MP_PATH_STATE values
2970 *
2971 * ****************************************************************************
2972 */
2973 char *
2974 getPathStateStr(MP_PATH_STATE pathState)
2975 {
2976 char *pathString;
2977
2978 switch (pathState) {
2979 case MP_PATH_STATE_OKAY:
2980 pathString = getTextString(TEXT_PATH_STATE_OKAY);
2981 break;
2982 case MP_PATH_STATE_PATH_ERR:
2983 pathString = getTextString(TEXT_PATH_STATE_PATH_ERR);
2984 break;
2985 case MP_PATH_STATE_LU_ERR:
2986 pathString = getTextString(TEXT_PATH_STATE_LU_ERR);
2987 break;
2988 case MP_PATH_STATE_RESERVED:
2989 pathString = getTextString(TEXT_PATH_STATE_RESERVED);
2990 break;
2991 case MP_PATH_STATE_REMOVED:
2992 pathString = getTextString(TEXT_PATH_STATE_REMOVED);
2993 break;
2994 case MP_PATH_STATE_TRANSITIONING:
2995 pathString =
2996 getTextString(TEXT_PATH_STATE_TRANSITIONING);
2997 break;
2998 case MP_PATH_STATE_OPERATIONAL_CLOSED:
2999 pathString =
3000 getTextString(TEXT_PATH_STATE_OPERATIONAL_CLOSED);
3001 break;
3002 case MP_PATH_STATE_INVALID_CLOSED:
3003 pathString =
3004 getTextString(TEXT_PATH_STATE_INVALID_CLOSED);
3005 break;
3006 case MP_PATH_STATE_OFFLINE_CLOSED:
3007 pathString =
3008 getTextString(TEXT_PATH_STATE_OFFLINE_CLOSED);
3009 break;
3010 default:
3011 pathString = getTextString(TEXT_UNKNOWN);
3012 break;
3013 }
3014
3015 return (pathString);
3016 } /* end getPathStateStr */
3017
3018
3019
3020 /*
3021 * ****************************************************************************
3022 *
3023 * getAccessStateStr
3024 * Gets the string description for the specified access state type value
3025 *
3026 * accessState - MP_ACCESS_STATE_TYPE values
3027 *
3028 * ****************************************************************************
3029 */
3030 char *
3031 getAccessStateStr(MP_ACCESS_STATE_TYPE accessState)
3032 {
3033 char *accessString;
3034
3035 switch (accessState) {
3036 case MP_ACCESS_STATE_ACTIVE_OPTIMIZED:
3037 accessString =
3038 getTextString(TEXT_ACCESS_STATE_ACTIVE_OPTIMIZED);
3039 break;
3040 case MP_ACCESS_STATE_ACTIVE_NONOPTIMIZED:
3041 accessString =
3042 getTextString(
3043 TEXT_ACCESS_STATE_ACTIVE_NONOPTIMIZED);
3044 break;
3045 case MP_ACCESS_STATE_STANDBY:
3046 accessString =
3047 getTextString(TEXT_ACCESS_STATE_STANDBY);
3048 break;
3049 case MP_ACCESS_STATE_UNAVAILABLE:
3050 accessString =
3051 getTextString(TEXT_ACCESS_STATE_UNAVAILABLE);
3052 break;
3053 case MP_ACCESS_STATE_TRANSITIONING:
3054 accessString =
3055 getTextString(TEXT_ACCESS_STATE_TRANSITIONING);
3056 break;
3057 case MP_ACCESS_STATE_ACTIVE:
3058 accessString = getTextString(TEXT_ACCESS_STATE_ACTIVE);
3059 break;
3060 default:
3061 accessString = getTextString(TEXT_UNKNOWN);
3062 break;
3063 }
3064 return (accessString);
3065 } /* end getAccessStateStr */
3066
3067
3068 /*
3069 * ****************************************************************************
3070 *
3071 * displayArray
3072 * Print out the specified array.
3073 *
3074 * arrayToDisplay - array to display
3075 * arraySize - size of array to display
3076 *
3077 * ****************************************************************************
3078 */
3079 void
3080 displayArray(MP_CHAR *arrayToDisplay, int arraySize)
3081 {
3082 int i;
3083
3084 for (i = 0; i < arraySize; i++) {
3085 if ('\0' != arrayToDisplay[i]) {
3086 (void) fprintf(stdout, "%c", arrayToDisplay[i]);
3087 }
3088 }
3089
3090 }
3091
3092
3093 /*
3094 * ****************************************************************************
3095 *
3096 * getStringArray
3097 * Return a null terminated array for the specified array as a string,
3098 * This is used for inputting into the %s in formatted strings.
3099 *
3100 * arrayToDisplay - array to display
3101 * arraySize - size of array to display
3102 *
3103 * ****************************************************************************
3104 */
3105 MP_CHAR *
3106 getStringArray(MP_CHAR *arrayToDisplay, int arraySize)
3107 {
3108 MP_CHAR *newStr;
3109
3110 int i;
3111
3112 newStr = malloc(((sizeof (MP_CHAR)) * arraySize) + 1);
3113 if (NULL == newStr) {
3114 (void) fprintf(stdout, "%s\n",
3115 getTextString(ERR_MEMORY_ALLOCATION));
3116 } else {
3117
3118 for (i = 0; i < arraySize; i++) {
3119 newStr[i] = arrayToDisplay[i];
3120 }
3121 newStr[arraySize] = '\0';
3122 }
3123
3124 return (newStr);
3125 }
3126
3127
3128 /*
3129 * ****************************************************************************
3130 *
3131 * displayWideArray
3132 * Print out the specified wide character array as a string,
3133 * adding the null termination
3134 *
3135 * arrayToDisplay - array to display
3136 * arraySize - size of array to display
3137 *
3138 * ****************************************************************************
3139 */
3140 void
3141 displayWideArray(MP_WCHAR *arrayToDisplay, int arraySize)
3142 {
3143 int i;
3144 int numChars = arraySize/4;
3145
3146 for (i = 0; i < numChars; i++) {
3147 if (L'\0' != arrayToDisplay[i]) {
3148 (void) fprintf(stdout, "%wc", (int)arrayToDisplay[i]);
3149 }
3150 }
3151 }
3152
3153
3154 /*
3155 * ****************************************************************************
3156 *
3157 * listfunc
3158 * Used by cmdparse for list clis
3159 *
3160 * ****************************************************************************
3161 */
3162 /*ARGSUSED*/
3163 static int
3164 listFunc(int operandLen, char *operand[], int object, cmdOptions_t *options,
3165 void *addArgs)
3166 {
3167 int ret = 0;
3168
3169 switch (object) {
3170 case MPATH_SUPPORT:
3171 ret = listMpathSupport(operandLen, operand);
3172 break;
3173 case LOGICAL_UNIT:
3174 ret = listLogicalUnit(operandLen, operand, options);
3175 break;
3176 case INITIATOR_PORT:
3177 ret = listInitiatorPort(operandLen, operand);
3178 break;
3179 default:
3180 (void) fprintf(stderr, "%s: %s\n",
3181 cmdName, getTextString(TEXT_UNKNOWN_OBJECT));
3182 ret = 1;
3183 break;
3184 }
3185
3186 return (ret);
3187 }
3188
3189
3190 /*
3191 * ****************************************************************************
3192 *
3193 * showFunc
3194 * used bycmdparse for show clis
3195 *
3196 * ****************************************************************************
3197 */
3198 /*ARGSUSED*/
3199 static int
3200 showFunc(int operandLen, char *operand[], int object, cmdOptions_t *options,
3201 void *addArgs)
3202 {
3203 int ret = 0;
3204
3205 switch (object) {
3206 case MPATH_SUPPORT:
3207 ret = showMpathSupport(operandLen, operand);
3208 break;
3209 case LOGICAL_UNIT:
3210 ret = showLogicalUnit(operandLen, operand);
3211 break;
3212 case INITIATOR_PORT:
3213 ret = showInitiatorPort(operandLen, operand);
3214 break;
3215 default:
3216 ret = 1;
3217 break;
3218 }
3219
3220 return (ret);
3221 }
3222
3223
3224 /*
3225 * ****************************************************************************
3226 *
3227 * modifyFunc
3228 * Used by cmdparse for midify clis
3229 *
3230 *
3231 * ****************************************************************************
3232 */
3233 /*ARGSUSED*/
3234 static int
3235 modifyFunc(int operandLen, char *operand[], int object, cmdOptions_t *options,
3236 void *addArgs)
3237 {
3238 int ret = 0;
3239
3240 switch (object) {
3241 case MPATH_SUPPORT:
3242 ret = modifyMpathSupport(operandLen, operand, options);
3243 break;
3244 case LOGICAL_UNIT:
3245 ret = modifyLogicalUnit(operandLen, operand, options);
3246 break;
3247 default:
3248 ret = 1;
3249 break;
3250 }
3251
3252
3253 return (ret);
3254 }
3255
3256
3257 /*
3258 * ****************************************************************************
3259 *
3260 * enableFunc
3261 * Used by cmdpars for enable clis
3262 *
3263 * ****************************************************************************
3264 */
3265 /*ARGSUSED*/
3266 static int
3267 enableFunc(int operandLen, char *operand[], int object, cmdOptions_t *options,
3268 void *addArgs)
3269 {
3270 int ret = 0;
3271
3272 switch (object) {
3273 case PATH:
3274 ret = enablePath(options);
3275 break;
3276 default:
3277 ret = 1;
3278 break;
3279 }
3280
3281 return (ret);
3282 }
3283
3284
3285 /*
3286 * ****************************************************************************
3287 *
3288 * disableFunc
3289 * Used by cmdpars for disable clis
3290 *
3291 * ****************************************************************************
3292 */
3293 /*ARGSUSED*/
3294 static int
3295 disableFunc(int operandLen, char *operand[], int object, cmdOptions_t *options,
3296 void *addArgs)
3297 {
3298 int ret = 0;
3299
3300 switch (object) {
3301 case PATH:
3302 ret = disablePath(options);
3303 break;
3304 default:
3305 ret = 1;
3306 break;
3307 }
3308
3309 return (ret);
3310 }
3311
3312
3313 /*
3314 * ****************************************************************************
3315 *
3316 * failoverFunc
3317 * Used by cmdpars for failover clis
3318 *
3319 * ****************************************************************************
3320 */
3321 /*ARGSUSED*/
3322 static int
3323 failoverFunc(int operandLen, char *operand[], int object, cmdOptions_t *options,
3324 void *addArgs)
3325 {
3326 int ret = 0;
3327
3328 switch (object) {
3329 case LOGICAL_UNIT:
3330 ret = failoverLogicalUnit(operand);
3331 break;
3332 default:
3333 ret = 1;
3334 break;
3335 }
3336
3337 return (ret);
3338 }
3339
3340
3341 /*
3342 * ****************************************************************************
3343 *
3344 * overrideFunc
3345 * Used by cmdpars for override clis
3346 *
3347 * ****************************************************************************
3348 */
3349 /*ARGSUSED*/
3350 static int
3351 overrideFunc(int operandLen, char *operand[],
3352 int object, cmdOptions_t *options,
3353 void *addArgs)
3354 {
3355 int ret = 0;
3356
3357 switch (object) {
3358 case PATH:
3359 ret = overridePath(options);
3360 break;
3361 default:
3362 ret = 1;
3363 break;
3364 }
3365
3366
3367 return (ret);
3368 }
3369
3370
3371 /*
3372 * *************************************************************************
3373 *
3374 * main
3375 *
3376 * *************************************************************************
3377 */
3378 int
3379 main(int argc, char *argv[])
3380 {
3381 synTables_t synTables;
3382 char versionString[VERSION_STRING_MAX_LEN];
3383 int ret;
3384 int funcRet;
3385 void *subcommandArgs = NULL;
3386
3387 /* set global command name */
3388 cmdName = getExecBasename(argv[0]);
3389
3390 (void) sprintf(versionString, "%2s.%2s",
3391 VERSION_STRING_MAJOR, VERSION_STRING_MINOR);
3392 synTables.versionString = versionString;
3393 synTables.longOptionTbl = &longOptions[0];
3394 synTables.subcommandTbl = &subcommands[0];
3395 synTables.objectTbl = &objects[0];
3396 synTables.objectRulesTbl = &objectRules[0];
3397 synTables.optionRulesTbl = &optionRules[0];
3398
3399 ret = cmdParse(argc, argv, /* SUB_COMMAND_ISSUED, */ synTables,
3400 subcommandArgs, &funcRet);
3401 if (ret == 1) {
3402 (void) fprintf(stdout, "%s %s(1M)\n",
3403 getTextString(TEXT_MORE_INFO), cmdName);
3404 return (ERROR_CLI_FAILED);
3405 } else if (ret == -1) {
3406 perror(argv[0]);
3407 return (1);
3408 }
3409
3410 if (funcRet != 0) {
3411 (void) fprintf(stderr, "%s: %s\n",
3412 argv[0], getTextString(TEXT_UNABLE_TO_COMPLETE));
3413 return (1);
3414 }
3415 return (0);
3416
3417 } /* end main */
unleashed repo fork