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