1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 * 21 * 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * 25 * raidctl.c is the entry file of RAID configuration utility. 26 */ 27 28 #include <ctype.h> 29 #include <sys/types.h> 30 #include <sys/stat.h> 31 #include <fcntl.h> 32 #include <langinfo.h> 33 #include <regex.h> 34 #include <locale.h> 35 #include <libintl.h> 36 #include <stdio.h> 37 #include <stdlib.h> 38 #include <string.h> 39 #include <strings.h> 40 #include <unistd.h> 41 #include <errno.h> 42 #include <libgen.h> 43 #include <raidcfg.h> 44 45 46 #define TRUE 1 47 #define FALSE 0 48 49 #ifndef TEXT_DOMAIN 50 #define TEXT_DOMAIN "SYS_TEST" 51 #endif 52 53 /* 54 * Return value of command 55 */ 56 #define SUCCESS 0 57 #define INVALID_ARG 1 58 #define FAILURE 2 59 60 /* 61 * Initial value of variables 62 */ 63 #define INIT_HANDLE_VALUE -3 64 #define MAX64BIT 0xffffffffffffffffull 65 #define MAX32BIT 0xfffffffful 66 67 /* 68 * Flag of set or unset HSP 69 */ 70 #define HSP_SET 1 71 #define HSP_UNSET 0 72 73 /* 74 * Operate codes of command 75 */ 76 #define DO_HW_RAID_NOP -1 77 #define DO_HW_RAID_HELP 0 78 #define DO_HW_RAID_CREATEO 1 79 #define DO_HW_RAID_CREATEN 2 80 #define DO_HW_RAID_DELETE 3 81 #define DO_HW_RAID_LIST 4 82 #define DO_HW_RAID_FLASH 5 83 #define DO_HW_RAID_HSP 6 84 #define DO_HW_RAID_SET_ATTR 7 85 #define DO_HW_RAID_SNAPSHOT 8 86 87 #define LOWER_H (1 << 0) 88 #define LOWER_C (1 << 1) 89 #define LOWER_D (1 << 2) 90 #define LOWER_L (1 << 3) 91 #define LOWER_R (1 << 4) 92 #define LOWER_Z (1 << 5) 93 #define LOWER_G (1 << 6) 94 #define LOWER_A (1 << 7) 95 #define LOWER_S (1 << 8) 96 #define LOWER_P (1 << 9) 97 #define LOWER_F (1 << 10) 98 #define UPPER_S (1 << 11) 99 #define UPPER_C (1 << 12) 100 #define UPPER_F (1 << 13) 101 102 /* Add a ARRAY state (temporary) */ 103 #define ARRAY_STATE_SYNC 100 104 105 /* 106 * Function and strings to properly localize our prompt. 107 * So for example in German it would ask (ja/nein) or (yes/no) in 108 * english. 109 */ 110 #ifndef SCHAR_MAX 111 #define SCHAR_MAX 10 112 #endif 113 114 #define RAIDCTL_LOCKF "/var/run/lockf_raidctl" 115 116 /* Locale setting */ 117 static int yes(void); 118 static int rpmatch(char *s); 119 static char *yesstr = NULL; 120 static char *nostr = NULL; 121 static char *yesexpr = NULL; 122 123 static char *default_yesexpr = "^[yY]"; 124 static char *default_yesstr = "yes"; 125 static char *default_nostr = "no"; 126 127 static regex_t re; 128 129 #define SET_DEFAULT_STRS \ 130 regfree(&re); \ 131 free(yesexpr); \ 132 free(yesstr); \ 133 free(nostr); \ 134 yesexpr = default_yesexpr; \ 135 yesstr = default_yesstr; \ 136 nostr = default_nostr; 137 138 #define FREE_STRS \ 139 if (yesexpr != default_yesexpr) \ 140 free(yesexpr); \ 141 if (yesstr != default_yesstr) \ 142 free(yesstr); \ 143 if (nostr != default_nostr) \ 144 free(nostr); 145 146 /* program name */ 147 static char *prog_namep; 148 149 150 /* 151 * Functions declaration 152 */ 153 static void helpinfo(char *prog_namep); 154 static int do_create_cidl(char *raid_levelp, char *capacityp, char *disk_argp, 155 char *stripe_sizep, uint32_t f_flag, char **argv, uint32_t optind); 156 static int do_create_ctd(char *raid_levelp, char **disks_argpp, 157 uint32_t disks_num, uint32_t argindex, uint32_t f_flag); 158 static int do_list(char *disk_argp, char **argv, uint32_t optind, 159 uint8_t is_snapshot); 160 static int do_delete(uint32_t f_flag, char **argv, uint32_t optind); 161 static int do_flash(uint8_t f_flag, char *filep, char **ctls_argpp, 162 uint32_t index, uint32_t ctl_num); 163 static int do_set_hsp(char *a_argp, char *disk_argp, char **argv, 164 uint32_t optind); 165 static int do_set_array_attr(uint32_t f_flag, char *p_argp, char **argv, 166 uint32_t optind); 167 static int snapshot_raidsystem(uint8_t recursive, uint8_t indent, 168 uint8_t is_snapshot); 169 static int snapshot_ctl(raid_obj_handle_t ctl_handle, uint8_t recursive, 170 uint8_t indent, uint8_t is_snapshot); 171 static int snapshot_array(raid_obj_handle_t array_handle, 172 uint8_t indent, uint8_t is_sub, uint8_t is_snapshot); 173 static int snapshot_disk(uint32_t ctl_tag, raid_obj_handle_t disk_handle, 174 uint8_t indent, uint8_t is_snapshot); 175 static int print_ctl_table(raid_obj_handle_t ctl_handle); 176 static int print_array_table(raid_obj_handle_t ctl_handle, 177 raid_obj_handle_t array_handle); 178 static int print_disk_table(raid_obj_handle_t ctl_handle, 179 raid_obj_handle_t disk_handle); 180 static int print_ctl_attr(raidcfg_controller_t *attrp); 181 static int print_array_attr(raidcfg_array_t *attrp); 182 static int print_arraypart_attr(raidcfg_arraypart_t *attrp); 183 static int print_disk_attr(raid_obj_handle_t ctl_handle, 184 raid_obj_handle_t disk_handle, raidcfg_disk_t *attrp); 185 static void print_indent(uint8_t indent); 186 static int get_disk_handle_cidl(uint32_t ctl_tag, char *disks_argp, 187 int *comps_nump, raid_obj_handle_t **handlespp); 188 static int get_disk_handle_ctd(int disks_num, char **disks_argpp, 189 uint32_t *ctl_tagp, raid_obj_handle_t *disks_handlep); 190 static int get_ctl_tag(char *argp, uint32_t *ctl_tagp); 191 static int get_array_tag(char *argp, uint32_t *ctl_tagp, 192 array_tag_t *array_tagp); 193 static int get_disk_tag_ctd(char *argp, disk_tag_t *disk_tagp, 194 uint32_t *controller_id); 195 static int get_disk_tag_cidl(char *argp, disk_tag_t *disk_tagp); 196 static int calc_size(char *sizep, uint64_t *valp); 197 static int is_fully_numeric(char *strp); 198 static int size_to_string(uint64_t size, char *string, int len); 199 static int enter_raidctl_lock(int *fd); 200 static void exit_raidctl_lock(int fd); 201 202 /* 203 * Entry function of raidctl command 204 */ 205 int 206 main(int argc, char **argv) 207 { 208 /* operation index */ 209 int8_t findex = DO_HW_RAID_NOP; 210 211 /* argument pointers */ 212 char *r_argp = NULL; 213 char *z_argp = NULL; 214 char *g_argp = NULL; 215 char *a_argp = NULL; 216 char *s_argp = NULL; 217 char *p_argp = NULL; 218 char *F_argp = NULL; 219 char *C_argp = NULL; 220 221 /* 222 * operation flags. 223 */ 224 uint8_t r_flag = FALSE; 225 uint8_t f_flag = FALSE; 226 uint8_t action = FALSE; 227 uint64_t options = 0; 228 229 /* index and temporary variables */ 230 int ret; 231 int status; 232 int c; 233 234 /* fd for the filelock */ 235 int fd; 236 237 if (enter_raidctl_lock(&fd) != SUCCESS) { 238 return (FAILURE); 239 } 240 241 (void) setlocale(LC_ALL, ""); 242 (void) textdomain(TEXT_DOMAIN); 243 244 /* parse command line, and get program name */ 245 if ((prog_namep = strrchr(argv[0], '/')) == NULL) { 246 prog_namep = argv[0]; 247 } else { 248 prog_namep++; 249 } 250 251 /* close error option messages from getopt */ 252 opterr = 0; 253 254 /* get yes expression according to current locale */ 255 yesexpr = strdup(nl_langinfo(YESEXPR)); 256 yesstr = strdup(nl_langinfo(YESSTR)); 257 nostr = strdup(nl_langinfo(NOSTR)); 258 if (yesexpr == NULL || yesstr == NULL || nostr == NULL) { 259 return (FAILURE); 260 } 261 262 /* 263 * If the was no expression or if there is a compile error 264 * use default yes expression. 265 */ 266 status = regcomp(&re, yesexpr, REG_EXTENDED | REG_NOSUB); 267 if ((*yesexpr == '\0') || 268 (*yesstr == '\0') || 269 (*nostr == '\0') || 270 (status != 0)) { 271 SET_DEFAULT_STRS; 272 if (regcomp(&re, default_yesexpr, 273 REG_EXTENDED | REG_NOSUB) != 0) { 274 return (FALSE); 275 } 276 } 277 278 while ((c = getopt(argc, argv, 279 "?hC:cdlF:r:z:g:a:s:p:fS")) != EOF) { 280 switch (c) { 281 case 'h': 282 case '?': 283 if (action == FALSE) { 284 findex = DO_HW_RAID_HELP; 285 action = TRUE; 286 options |= LOWER_H; 287 } else { 288 findex = DO_HW_RAID_NOP; 289 } 290 break; 291 case 'C': 292 if (action == FALSE) { 293 findex = DO_HW_RAID_CREATEN; 294 C_argp = optarg; 295 action = TRUE; 296 options |= UPPER_C; 297 } else { 298 findex = DO_HW_RAID_NOP; 299 } 300 break; 301 case 'c': 302 if (action == FALSE) { 303 findex = DO_HW_RAID_CREATEO; 304 action = TRUE; 305 options |= LOWER_C; 306 } else { 307 findex = DO_HW_RAID_NOP; 308 } 309 break; 310 case 'd': 311 if (action == FALSE) { 312 findex = DO_HW_RAID_DELETE; 313 action = TRUE; 314 options |= LOWER_D; 315 } else { 316 findex = DO_HW_RAID_NOP; 317 } 318 break; 319 case 'l': 320 if (action == FALSE) { 321 findex = DO_HW_RAID_LIST; 322 action = TRUE; 323 options |= LOWER_L; 324 } else { 325 findex = DO_HW_RAID_NOP; 326 } 327 break; 328 case 'F': 329 if (action == FALSE) { 330 findex = DO_HW_RAID_FLASH; 331 F_argp = optarg; 332 action = TRUE; 333 options |= UPPER_F; 334 } else { 335 findex = DO_HW_RAID_NOP; 336 } 337 break; 338 case 'a': 339 if (action == FALSE) { 340 findex = DO_HW_RAID_HSP; 341 a_argp = optarg; 342 action = TRUE; 343 options |= LOWER_A; 344 } else { 345 findex = DO_HW_RAID_NOP; 346 } 347 break; 348 case 'p': 349 if (action == FALSE) { 350 findex = DO_HW_RAID_SET_ATTR; 351 p_argp = optarg; 352 action = TRUE; 353 options |= LOWER_P; 354 } else { 355 findex = DO_HW_RAID_NOP; 356 } 357 break; 358 case 'r': 359 r_argp = optarg; 360 r_flag = TRUE; 361 options |= LOWER_R; 362 break; 363 case 'z': 364 z_argp = optarg; 365 options |= LOWER_Z; 366 break; 367 case 'g': 368 g_argp = optarg; 369 options |= LOWER_G; 370 break; 371 case 's': 372 s_argp = optarg; 373 options |= LOWER_S; 374 break; 375 case 'f': 376 f_flag = TRUE; 377 options |= LOWER_F; 378 break; 379 case 'S': 380 if (action == FALSE) { 381 findex = DO_HW_RAID_SNAPSHOT; 382 action = TRUE; 383 options |= UPPER_S; 384 } else { 385 findex = DO_HW_RAID_NOP; 386 } 387 break; 388 default: 389 (void) fprintf(stderr, 390 gettext("Invalid argument(s).\n")); 391 exit_raidctl_lock(fd); 392 FREE_STRS; 393 regfree(&re); 394 return (INVALID_ARG); 395 } 396 } 397 398 /* parse options */ 399 switch (findex) { 400 case DO_HW_RAID_HELP: 401 if ((options & ~(LOWER_H)) != 0) { 402 ret = INVALID_ARG; 403 } else { 404 helpinfo(prog_namep); 405 ret = SUCCESS; 406 } 407 break; 408 case DO_HW_RAID_CREATEO: 409 if ((options & ~(LOWER_F | LOWER_C | LOWER_R)) != 0) { 410 ret = INVALID_ARG; 411 } else { 412 if (r_flag != FALSE && f_flag == FALSE) { 413 ret = do_create_ctd(r_argp, argv, argc - 4, 414 optind, f_flag); 415 } else if (r_flag == FALSE && f_flag == FALSE) { 416 ret = do_create_ctd(NULL, argv, argc - 2, 417 optind, f_flag); 418 } else if (r_flag != FALSE && f_flag != FALSE) { 419 ret = do_create_ctd(r_argp, argv, argc - 5, 420 optind, f_flag); 421 } else { 422 ret = do_create_ctd(NULL, argv, argc - 3, 423 optind, f_flag); 424 } 425 } 426 break; 427 case DO_HW_RAID_CREATEN: 428 if ((options & ~(LOWER_F | UPPER_C | LOWER_R | LOWER_Z | 429 LOWER_S)) != 0) { 430 ret = INVALID_ARG; 431 } else { 432 ret = do_create_cidl(r_argp, z_argp, C_argp, s_argp, 433 f_flag, argv, optind); 434 } 435 break; 436 case DO_HW_RAID_DELETE: 437 if ((options & ~(LOWER_F | LOWER_D)) != 0) { 438 ret = INVALID_ARG; 439 } else { 440 ret = do_delete(f_flag, argv, optind); 441 } 442 break; 443 case DO_HW_RAID_LIST: 444 if ((options & ~(LOWER_L | LOWER_G)) != 0) { 445 ret = INVALID_ARG; 446 } else { 447 ret = do_list(g_argp, argv, optind, FALSE); 448 } 449 break; 450 case DO_HW_RAID_SNAPSHOT: 451 if ((options & ~(UPPER_S | LOWER_G)) != 0) { 452 ret = INVALID_ARG; 453 } else { 454 ret = do_list(g_argp, argv, optind, TRUE); 455 } 456 break; 457 case DO_HW_RAID_FLASH: 458 if ((options & ~(LOWER_F | UPPER_F)) != 0) { 459 ret = INVALID_ARG; 460 } else { 461 if (f_flag == FALSE) { 462 ret = do_flash(f_flag, F_argp, argv, optind, 463 argc - 3); 464 } else { 465 ret = do_flash(f_flag, F_argp, argv, optind, 466 argc - 4); 467 } 468 } 469 break; 470 case DO_HW_RAID_HSP: 471 if ((options & ~(LOWER_A | LOWER_G)) != 0) { 472 ret = INVALID_ARG; 473 } else { 474 ret = do_set_hsp(a_argp, g_argp, argv, optind); 475 } 476 break; 477 case DO_HW_RAID_SET_ATTR: 478 if ((options & ~(LOWER_F | LOWER_P)) != 0) { 479 ret = INVALID_ARG; 480 } else { 481 ret = do_set_array_attr(f_flag, p_argp, argv, optind); 482 } 483 break; 484 case DO_HW_RAID_NOP: 485 if (argc == 1) { 486 ret = do_list(g_argp, argv, optind, FALSE); 487 } else { 488 ret = INVALID_ARG; 489 } 490 break; 491 default: 492 ret = INVALID_ARG; 493 break; 494 } 495 496 if (ret == INVALID_ARG) { 497 (void) fprintf(stderr, 498 gettext("Invalid argument(s).\n")); 499 } 500 exit_raidctl_lock(fd); 501 502 FREE_STRS; 503 regfree(&re); 504 return (ret); 505 } 506 507 /* 508 * helpinfo(prog_namep) 509 * This function prints help informations for usrs. 510 */ 511 static void 512 helpinfo(char *prog_namep) 513 { 514 char quote = '"'; 515 516 (void) printf(gettext("%s [-f] -C %c<disks>%c [-r <raid_level>] " 517 "[-z <capacity>] [-s <stripe_size>] <controller>\n"), prog_namep, 518 quote, quote); 519 520 (void) printf(gettext("%s [-f] -d <volume>\n"), prog_namep); 521 522 (void) printf(gettext("%s [-f] -F <filename> <controller1> " 523 "[<controller2> ...]\n"), prog_namep); 524 525 (void) printf(gettext("%s [-f] -p %c<param>=<value>%c <volume>\n"), 526 prog_namep, quote, quote); 527 528 (void) printf(gettext("%s [-f] -c [-r <raid_level>] <disk1> <disk2> " 529 "[<disk3> ...]\n"), prog_namep); 530 531 (void) printf(gettext("%s [-l]\n"), prog_namep); 532 533 (void) printf(gettext("%s -l -g <disk> <controller>\n"), prog_namep); 534 535 (void) printf(gettext("%s -l <volume>\n"), prog_namep); 536 537 (void) printf(gettext("%s -l <controller1> [<controller2> ...]\n"), 538 prog_namep); 539 540 (void) printf(gettext("%s -a {set | unset} -g <disk> " 541 "{<volume> | <controller>}\n"), prog_namep); 542 543 (void) printf(gettext("%s -S [<volume> | <controller>]\n"), prog_namep); 544 545 (void) printf(gettext("%s -S -g <disk> <controller>\n"), prog_namep); 546 547 (void) printf(gettext("%s -h\n"), prog_namep); 548 } 549 550 /* 551 * do_create_cidl(raid_levelp, capacityp, disks_argp, stripe_sizep, 552 * f_flag, argv, optind) 553 * This function creates a new RAID volume with specified arguments, 554 * and returns result as SUCCESS, INVALID_ARG or FAILURE. 555 * The "c.id.l" is used to express single physical disk. 'c' expresses 556 * bus number, 'id' expresses target number, and 'l' expresses lun. 557 * The physical disks represented by c.id.l may be invisible to OS, which 558 * means physical disks attached to controllers are not accessible by 559 * OS directly. The disks should be organized as a logical volume, and 560 * the logical volume is exported to OS as a single unit. Some hardware 561 * RAID controllers also support physical disks accessed by OS directly, 562 * for example LSI1068. In this case, it's both OK to express physical 563 * disk by c.id.l format or canonical ctd format. 564 */ 565 static int 566 do_create_cidl(char *raid_levelp, char *capacityp, char *disks_argp, 567 char *stripe_sizep, uint32_t f_flag, char **argv, uint32_t optind) 568 { 569 uint32_t ctl_tag = MAX32BIT; 570 raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE; 571 uint32_t raid_level = RAID_LEVEL_1; 572 uint64_t capacity = 0; 573 uint64_t stripe_size = (uint64_t)OBJ_ATTR_NONE; 574 raid_obj_handle_t *disk_handlesp = NULL; 575 raid_obj_handle_t array_handle = INIT_HANDLE_VALUE; 576 raidcfg_controller_t ctl_attr; 577 int comps_num = 0; 578 int ret = 0; 579 580 raidcfg_array_t array_attr; 581 582 if (argv[optind] == NULL || argv[optind + 1] != NULL) { 583 return (INVALID_ARG); 584 } 585 586 if (disks_argp == NULL) { 587 return (INVALID_ARG); 588 } 589 590 /* Check controller tag */ 591 if (get_ctl_tag(argv[optind], &ctl_tag) != SUCCESS) { 592 return (INVALID_ARG); 593 } 594 595 ctl_handle = raidcfg_get_controller(ctl_tag); 596 if (ctl_handle <= 0) { 597 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ctl_handle)); 598 return (FAILURE); 599 } 600 601 if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) { 602 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 603 return (FAILURE); 604 } 605 606 /* Get raid level */ 607 if (raid_levelp != NULL) { 608 if (*raid_levelp == '1' && 609 (*(raid_levelp + 1) == 'E' || *(raid_levelp + 1) == 'e')) { 610 raid_level = RAID_LEVEL_1E; 611 } else { 612 if (is_fully_numeric(raid_levelp) == FALSE) { 613 return (INVALID_ARG); 614 } 615 616 switch (atoi(raid_levelp)) { 617 case 0: 618 raid_level = RAID_LEVEL_0; 619 break; 620 case 1: 621 raid_level = RAID_LEVEL_1; 622 break; 623 case 5: 624 raid_level = RAID_LEVEL_5; 625 break; 626 case 10: 627 raid_level = RAID_LEVEL_10; 628 break; 629 case 50: 630 raid_level = RAID_LEVEL_50; 631 break; 632 default: 633 return (INVALID_ARG); 634 } 635 } 636 } 637 638 /* 639 * The rang check of capacity and stripe size is performed in library, 640 * and it relates to hardware feature. 641 */ 642 643 /* Capacity in bytes. Capacity 0 means max available space. */ 644 if (capacityp != NULL) { 645 if (*capacityp == '-' || 646 calc_size(capacityp, &capacity) != SUCCESS) { 647 return (INVALID_ARG); 648 } 649 } 650 651 /* Stripe size in bytes */ 652 if (stripe_sizep != NULL) { 653 if (calc_size(stripe_sizep, &stripe_size) != SUCCESS || 654 *stripe_sizep == '-') { 655 return (INVALID_ARG); 656 } 657 } 658 659 /* Open controller before accessing its object */ 660 if ((ret = raidcfg_open_controller(ctl_handle, NULL)) < 0) { 661 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 662 return (FAILURE); 663 } 664 665 /* Get disks' handles */ 666 if ((ret = get_disk_handle_cidl(ctl_tag, disks_argp, &comps_num, 667 &disk_handlesp)) != SUCCESS) { 668 (void) raidcfg_close_controller(ctl_handle, NULL); 669 return (ret); 670 } 671 672 if (f_flag == FALSE) { 673 (void) fprintf(stdout, gettext("Creating RAID volume " 674 "will destroy all data on spare space of member disks, " 675 "proceed (%s/%s)? "), yesstr, nostr); 676 if (!yes()) { 677 (void) fprintf(stdout, gettext("RAID volume " 678 "not created.\n\n")); 679 (void) raidcfg_close_controller(ctl_handle, NULL); 680 free(disk_handlesp); 681 return (SUCCESS); 682 } 683 } 684 685 /* Create array */ 686 array_handle = raidcfg_create_array(comps_num, 687 disk_handlesp, raid_level, capacity, stripe_size, NULL); 688 689 if (array_handle <= 0) { 690 (void) fprintf(stderr, "%s\n", raidcfg_errstr(array_handle)); 691 free(disk_handlesp); 692 (void) raidcfg_close_controller(ctl_handle, NULL); 693 return (FAILURE); 694 } 695 696 /* Get attribute of the new created array */ 697 if ((ret = raidcfg_get_attr(array_handle, &array_attr)) < 0) { 698 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 699 free(disk_handlesp); 700 (void) raidcfg_close_controller(ctl_handle, NULL); 701 return (FAILURE); 702 } 703 704 (void) fprintf(stdout, gettext("Volume c%ut%llud%llu is created " 705 "successfully!\n"), ctl_tag, array_attr.tag.idl.target_id, 706 array_attr.tag.idl.lun); 707 708 /* Print attribute of array */ 709 (void) print_array_table(ctl_handle, array_handle); 710 711 /* Close controller */ 712 (void) raidcfg_close_controller(ctl_handle, NULL); 713 714 free(disk_handlesp); 715 return (SUCCESS); 716 } 717 718 /* 719 * do_create_ctd(raid_levelp, disks_argpp, disks_num, argindex, f_flag) 720 * This function creates array with specified arguments, and return result 721 * as SUCCESS, FAILURE, or INVALID_ARG. It only supports LSI MPT controller 722 * to be compatible with old raidctl. The capacity and stripe size can't 723 * be specified for LSI MPT controller, and they use zero and default value. 724 * The "ctd" is the canonical expression of physical disks which are 725 * accessible by OS. 726 */ 727 static int 728 do_create_ctd(char *raid_levelp, char **disks_argpp, uint32_t disks_num, 729 uint32_t argindex, uint32_t f_flag) 730 { 731 uint32_t ctl_tag = MAX32BIT; 732 raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE; 733 uint32_t raid_level = RAID_LEVEL_1; 734 uint64_t capacity = 0; 735 uint32_t stripe_size = (uint32_t)OBJ_ATTR_NONE; 736 raid_obj_handle_t *disk_handlesp = NULL; 737 raid_obj_handle_t array_handle = INIT_HANDLE_VALUE; 738 raidcfg_controller_t ctl_attr; 739 int ret; 740 741 raidcfg_array_t array_attr; 742 int i, j; 743 744 /* Check disks parameter */ 745 if (disks_argpp == NULL || disks_num < 2) { 746 return (INVALID_ARG); 747 } 748 749 for (i = 0, j = argindex; i < disks_num; i++, j++) { 750 if (disks_argpp[j] == NULL) { 751 return (INVALID_ARG); 752 } 753 } 754 755 /* 756 * We need check if the raid_level string is fully numeric. If user 757 * input string with unsupported letters, such as "s10", atoi() will 758 * return zero because it is an illegal string, but it doesn't mean 759 * RAID_LEVEL_0. 760 */ 761 if (raid_levelp != NULL) { 762 if (*raid_levelp == '1' && 763 (*(raid_levelp + 1) == 'E' || *(raid_levelp + 1) == 'e')) { 764 raid_level = RAID_LEVEL_1E; 765 } else { 766 if (is_fully_numeric(raid_levelp) == FALSE) { 767 return (INVALID_ARG); 768 } 769 770 switch (atoi(raid_levelp)) { 771 case 0: 772 raid_level = RAID_LEVEL_0; 773 break; 774 case 1: 775 raid_level = RAID_LEVEL_1; 776 break; 777 case 5: 778 raid_level = RAID_LEVEL_5; 779 break; 780 default: 781 return (INVALID_ARG); 782 } 783 } 784 } 785 786 /* Get disks tag and controller tag */ 787 disk_handlesp = (raid_obj_handle_t *)calloc(disks_num + 2, 788 sizeof (raid_obj_handle_t)); 789 if (disk_handlesp == NULL) { 790 return (FAILURE); 791 } 792 793 disk_handlesp[0] = OBJ_SEPARATOR_BEGIN; 794 disk_handlesp[disks_num + 1] = OBJ_SEPARATOR_END; 795 796 if ((ret = get_disk_handle_ctd(disks_num, &disks_argpp[argindex], 797 &ctl_tag, &disk_handlesp[1])) != SUCCESS) { 798 free(disk_handlesp); 799 return (ret); 800 } 801 802 /* LIB API should check whether all disks here belong to one ctl. */ 803 /* get_disk_handle_ctd has opened controller. */ 804 ctl_handle = raidcfg_get_controller(ctl_tag); 805 806 if (ctl_handle <= 0) { 807 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ctl_handle)); 808 (void) raidcfg_close_controller(ctl_handle, NULL); 809 free(disk_handlesp); 810 return (FAILURE); 811 } 812 813 /* Check if the controller is host raid type */ 814 if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) { 815 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 816 (void) raidcfg_close_controller(ctl_handle, NULL); 817 free(disk_handlesp); 818 return (FAILURE); 819 } 820 821 if ((ctl_attr.capability & RAID_CAP_DISK_TRANS) == 0) { 822 /* -c only support host raid controller, return failure here */ 823 (void) fprintf(stderr, 824 gettext("Option -c only supports host raid controller.\n")); 825 (void) raidcfg_close_controller(ctl_handle, NULL); 826 free(disk_handlesp); 827 return (FAILURE); 828 } 829 830 if (f_flag == FALSE) { 831 (void) fprintf(stdout, gettext("Creating RAID volume " 832 "will destroy all data on spare space of member disks, " 833 "proceed (%s/%s)? "), yesstr, nostr); 834 if (!yes()) { 835 (void) fprintf(stdout, gettext("RAID volume " 836 "not created.\n\n")); 837 free(disk_handlesp); 838 (void) raidcfg_close_controller(ctl_handle, NULL); 839 return (SUCCESS); 840 } 841 } 842 843 /* 844 * For old raidctl, capacity is 0, which means to creates 845 * max possible capacity of array. 846 */ 847 848 array_handle = raidcfg_create_array(disks_num + 2, 849 disk_handlesp, raid_level, capacity, stripe_size, NULL); 850 851 if (array_handle <= 0) { 852 (void) fprintf(stderr, "%s\n", raidcfg_errstr(array_handle)); 853 free(disk_handlesp); 854 (void) raidcfg_close_controller(ctl_handle, NULL); 855 return (FAILURE); 856 } 857 858 /* Get attribute of array */ 859 if ((ret = raidcfg_get_attr(array_handle, &array_attr)) < 0) { 860 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 861 free(disk_handlesp); 862 (void) raidcfg_close_controller(ctl_handle, NULL); 863 return (FAILURE); 864 } 865 866 /* Close controller */ 867 (void) raidcfg_close_controller(ctl_handle, NULL); 868 869 /* Print feedback for user */ 870 (void) fprintf(stdout, 871 gettext("Volume c%ut%llud%llu is created successfully!\n"), 872 ctl_tag, array_attr.tag.idl.target_id, 873 array_attr.tag.idl.lun); 874 free(disk_handlesp); 875 return (SUCCESS); 876 } 877 878 /* 879 * do_list(disk_arg, argv, optind, is_snapshot) 880 * This function lists RAID's system configuration. It supports various RAID 881 * controller. The return value can be SUCCESS, FAILURE, or INVALID_ARG. 882 */ 883 static int 884 do_list(char *disk_argp, char **argv, uint32_t optind, uint8_t is_snapshot) 885 { 886 uint32_t ctl_tag = MAX32BIT; 887 raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE; 888 raid_obj_handle_t disk_handle = INIT_HANDLE_VALUE; 889 raid_obj_handle_t array_handle = INIT_HANDLE_VALUE; 890 disk_tag_t disk_tag; 891 array_tag_t array_tag; 892 893 int ret; 894 895 /* print RAID system */ 896 if (disk_argp == NULL) { 897 if (argv[optind] == NULL) { 898 ret = snapshot_raidsystem(TRUE, 0, is_snapshot); 899 return (ret); 900 } else { 901 if (is_fully_numeric(argv[optind]) == TRUE) { 902 while (argv[optind] != NULL) { 903 if (get_ctl_tag(argv[optind], &ctl_tag) 904 != SUCCESS) { 905 ret = INVALID_ARG; 906 optind++; 907 continue; 908 } 909 ctl_handle = 910 raidcfg_get_controller(ctl_tag); 911 if (ctl_handle <= 0) { 912 (void) fprintf(stderr, "%s\n", 913 raidcfg_errstr(ctl_handle)); 914 ret = FAILURE; 915 optind++; 916 continue; 917 } 918 ret = 919 raidcfg_open_controller(ctl_handle, 920 NULL); 921 if (ret < 0) { 922 (void) fprintf(stderr, "%s\n", 923 raidcfg_errstr(ret)); 924 ret = FAILURE; 925 optind++; 926 continue; 927 } 928 if (is_snapshot == FALSE) { 929 ret = 930 print_ctl_table(ctl_handle); 931 } else { 932 ret = 933 snapshot_ctl(ctl_handle, 934 FALSE, 0, is_snapshot); 935 } 936 (void) raidcfg_close_controller( 937 ctl_handle, NULL); 938 optind++; 939 } 940 } else { 941 if (get_array_tag(argv[optind], 942 &ctl_tag, &array_tag) != SUCCESS) { 943 return (INVALID_ARG); 944 } 945 ctl_handle = raidcfg_get_controller(ctl_tag); 946 if (ctl_handle <= 0) { 947 (void) fprintf(stderr, "%s\n", 948 raidcfg_errstr(ctl_handle)); 949 return (FAILURE); 950 } 951 952 ret = raidcfg_open_controller(ctl_handle, NULL); 953 if (ret < 0) { 954 (void) fprintf(stderr, "%s\n", 955 raidcfg_errstr(ret)); 956 return (FAILURE); 957 } 958 959 array_handle = raidcfg_get_array(ctl_handle, 960 array_tag.idl.target_id, array_tag.idl.lun); 961 if (array_handle <= 0) { 962 (void) fprintf(stderr, "%s\n", 963 raidcfg_errstr(array_handle)); 964 (void) raidcfg_close_controller( 965 ctl_handle, NULL); 966 return (FAILURE); 967 } 968 if (is_snapshot == FALSE) { 969 ret = print_array_table(ctl_handle, 970 array_handle); 971 } else { 972 ret = snapshot_array(array_handle, 0, 973 FALSE, is_snapshot); 974 } 975 (void) raidcfg_close_controller( 976 ctl_handle, NULL); 977 } 978 } 979 } else { 980 if (argv[optind + 1] != NULL) { 981 return (INVALID_ARG); 982 } 983 984 if (get_ctl_tag(argv[optind], &ctl_tag) != SUCCESS) { 985 return (INVALID_ARG); 986 } 987 988 ctl_handle = raidcfg_get_controller(ctl_tag); 989 if (ctl_handle <= 0) { 990 (void) fprintf(stderr, "%s\n", 991 raidcfg_errstr(ctl_handle)); 992 return (FAILURE); 993 } 994 995 if (get_disk_tag_cidl(disk_argp, &disk_tag) != SUCCESS) { 996 return (INVALID_ARG); 997 } 998 999 ret = raidcfg_open_controller(ctl_handle, NULL); 1000 if (ret < 0) { 1001 (void) fprintf(stderr, "%s\n", 1002 raidcfg_errstr(ret)); 1003 return (FAILURE); 1004 } 1005 1006 disk_handle = raidcfg_get_disk(ctl_handle, disk_tag); 1007 if (disk_handle <= 0) { 1008 (void) fprintf(stderr, "%s\n", 1009 raidcfg_errstr(disk_handle)); 1010 (void) raidcfg_close_controller(ctl_handle, NULL); 1011 return (FAILURE); 1012 } 1013 1014 if (is_snapshot == FALSE) { 1015 ret = print_disk_table(ctl_handle, disk_handle); 1016 } else { 1017 ret = snapshot_disk(ctl_tag, disk_handle, 0, 1018 is_snapshot); 1019 } 1020 (void) raidcfg_close_controller(ctl_handle, NULL); 1021 } 1022 return (ret); 1023 } 1024 1025 /* 1026 * do_delete(f_flag, argv, optind) 1027 * This function deletes a specified array, and return result as SUCCESS, 1028 * FAILURE or INVALID_ARG. 1029 */ 1030 static int 1031 do_delete(uint32_t f_flag, char **argv, uint32_t optind) 1032 { 1033 uint32_t ctl_tag; 1034 char *array_argp; 1035 array_tag_t array_tag; 1036 raid_obj_handle_t ctl_handle; 1037 raid_obj_handle_t array_handle; 1038 int ret; 1039 1040 array_argp = argv[optind]; 1041 if (array_argp == NULL || argv[optind + 1] != NULL) { 1042 return (INVALID_ARG); 1043 } 1044 1045 if (get_array_tag(array_argp, &ctl_tag, &array_tag) != SUCCESS) { 1046 return (INVALID_ARG); 1047 } 1048 1049 ctl_handle = raidcfg_get_controller(ctl_tag); 1050 if (ctl_handle <= 0) { 1051 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ctl_handle)); 1052 return (INVALID_ARG); 1053 } 1054 1055 ret = raidcfg_open_controller(ctl_handle, NULL); 1056 if (ret < 0) { 1057 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1058 return (FAILURE); 1059 } 1060 1061 array_handle = raidcfg_get_array(ctl_handle, array_tag.idl.target_id, 1062 array_tag.idl.lun); 1063 if (array_handle <= 0) { 1064 (void) fprintf(stderr, "%s\n", raidcfg_errstr(array_handle)); 1065 (void) raidcfg_close_controller(ctl_handle, NULL); 1066 return (FAILURE); 1067 } 1068 1069 if (f_flag == FALSE) { 1070 (void) fprintf(stdout, gettext("Deleting RAID volume " 1071 "%s will destroy all data it contains, " 1072 "proceed (%s/%s)? "), array_argp, yesstr, nostr); 1073 if (!yes()) { 1074 (void) fprintf(stdout, gettext("RAID Volume " 1075 "%s not deleted.\n\n"), array_argp); 1076 (void) raidcfg_close_controller(ctl_handle, NULL); 1077 return (SUCCESS); 1078 } 1079 } 1080 1081 1082 if ((ret = raidcfg_delete_array(array_handle, NULL)) < 0) { 1083 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1084 (void) raidcfg_close_controller(ctl_handle, NULL); 1085 return (FAILURE); 1086 } 1087 1088 (void) fprintf(stdout, gettext("Volume %s is deleted successfully!\n"), 1089 array_argp); 1090 (void) raidcfg_close_controller(ctl_handle, NULL); 1091 1092 return (SUCCESS); 1093 } 1094 1095 /* 1096 * do_flash(f_flag, filep, ctls_argpp, index, ctl_num) 1097 * This function downloads and updates firmware for specified controller, and 1098 * return result as SUCCESS, FAILURE or INVALID_ARG. 1099 */ 1100 static int 1101 do_flash(uint8_t f_flag, char *filep, char **ctls_argpp, 1102 uint32_t index, uint32_t ctl_num) 1103 { 1104 uint32_t ctl_tag = MAX32BIT; 1105 char *ctl_argp = NULL; 1106 raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE; 1107 int ret; 1108 int i, j; 1109 1110 if (ctl_num == 0) 1111 return (INVALID_ARG); 1112 1113 for (i = 0, j = index; i < ctl_num; i++, j++) { 1114 ctl_argp = ctls_argpp[j]; 1115 if (get_ctl_tag(ctl_argp, &ctl_tag) != SUCCESS) { 1116 return (INVALID_ARG); 1117 } 1118 1119 /* Ask user to confirm operation. */ 1120 if (f_flag == FALSE) { 1121 (void) fprintf(stdout, gettext("Update flash image on " 1122 "controller %d (%s/%s)? "), ctl_tag, yesstr, nostr); 1123 if (!yes()) { 1124 (void) fprintf(stdout, 1125 gettext("Controller %d not " 1126 "flashed.\n\n"), ctl_tag); 1127 return (SUCCESS); 1128 } 1129 } 1130 1131 if ((ctl_handle = raidcfg_get_controller(ctl_tag)) < 0) { 1132 (void) fprintf(stderr, "%s\n", 1133 raidcfg_errstr(ctl_handle)); 1134 return (FAILURE); 1135 } 1136 1137 ret = raidcfg_open_controller(ctl_handle, NULL); 1138 if (ret < 0) { 1139 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1140 return (FAILURE); 1141 } 1142 1143 (void) fprintf(stdout, gettext("Start updating controller " 1144 "c%u firmware....\n"), ctl_tag); 1145 1146 if ((ret = raidcfg_update_fw(ctl_handle, filep, NULL)) < 0) { 1147 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1148 (void) raidcfg_close_controller(ctl_handle, NULL); 1149 return (FAILURE); 1150 } 1151 1152 (void) fprintf(stdout, gettext("Update controller " 1153 "c%u firmware successfully.\n"), ctl_tag); 1154 1155 (void) raidcfg_close_controller(ctl_handle, NULL); 1156 } 1157 1158 return (SUCCESS); 1159 } 1160 1161 /* 1162 * do_set_hsp(a_argp, disk_argp, argv, optind) 1163 * This function set or unset HSP relationship between disk and controller/ 1164 * array, and return result as SUCCESS, FAILURE or INVALID_ARG. 1165 */ 1166 static int 1167 do_set_hsp(char *a_argp, char *disk_argp, char **argv, uint32_t optind) 1168 { 1169 uint32_t flag = MAX32BIT; 1170 uint32_t ctl_tag = MAX32BIT; 1171 array_tag_t array_tag; 1172 raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE; 1173 raid_obj_handle_t disk_handle = INIT_HANDLE_VALUE; 1174 raid_obj_handle_t array_handle = INIT_HANDLE_VALUE; 1175 raidcfg_controller_t ctl_attr; 1176 disk_tag_t disk_tag; 1177 1178 int ret; 1179 int hsp_type; 1180 raidcfg_hsp_relation_t hsp_relation; 1181 1182 (void) memset(&hsp_relation, 0, sizeof (raidcfg_hsp_relation_t)); 1183 1184 if (a_argp == NULL) { 1185 return (INVALID_ARG); 1186 } 1187 1188 if (strcmp(a_argp, "set") == 0) { 1189 flag = HSP_SET; 1190 } else if (strcmp(a_argp, "unset") == 0) { 1191 flag = HSP_UNSET; 1192 } else { 1193 return (INVALID_ARG); 1194 } 1195 1196 if (disk_argp == NULL) { 1197 return (INVALID_ARG); 1198 } 1199 1200 if (argv[optind] == NULL || argv[optind + 1] != NULL) { 1201 return (INVALID_ARG); 1202 } else if (is_fully_numeric(argv[optind]) == TRUE) { 1203 /* Global HSP */ 1204 hsp_type = 0; 1205 if (get_disk_tag_cidl(disk_argp, &disk_tag) != SUCCESS) { 1206 return (INVALID_ARG); 1207 } 1208 1209 if (get_ctl_tag(argv[optind], &ctl_tag) != SUCCESS) { 1210 return (INVALID_ARG); 1211 } 1212 1213 ctl_handle = raidcfg_get_controller(ctl_tag); 1214 if (ctl_handle <= 0) { 1215 (void) fprintf(stderr, "%s\n", 1216 raidcfg_errstr(ctl_handle)); 1217 return (FAILURE); 1218 } 1219 1220 ret = raidcfg_open_controller(ctl_handle, NULL); 1221 if (ret < 0) { 1222 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1223 return (FAILURE); 1224 } 1225 1226 disk_handle = raidcfg_get_disk(ctl_handle, disk_tag); 1227 if (disk_handle <= 0) { 1228 (void) fprintf(stderr, "%s\n", 1229 raidcfg_errstr(disk_handle)); 1230 (void) raidcfg_close_controller(ctl_handle, NULL); 1231 return (FAILURE); 1232 } 1233 } else { 1234 /* Local HSP */ 1235 hsp_type = 1; 1236 if (get_array_tag(argv[optind], &ctl_tag, &array_tag) != 1237 SUCCESS) { 1238 return (INVALID_ARG); 1239 } 1240 1241 /* Open controller */ 1242 ctl_handle = raidcfg_get_controller(ctl_tag); 1243 if (ctl_handle <= 0) { 1244 (void) fprintf(stderr, "%s\n", 1245 raidcfg_errstr(ctl_handle)); 1246 return (FAILURE); 1247 } 1248 1249 ret = raidcfg_open_controller(ctl_handle, NULL); 1250 if (ret < 0) { 1251 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1252 return (FAILURE); 1253 } 1254 1255 /* Get controller's attribute */ 1256 if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) { 1257 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1258 (void) raidcfg_close_controller(ctl_handle, NULL); 1259 return (FAILURE); 1260 } 1261 1262 if (get_disk_tag_cidl(disk_argp, &disk_tag) != SUCCESS) { 1263 (void) raidcfg_close_controller(ctl_handle, NULL); 1264 return (INVALID_ARG); 1265 } 1266 1267 /* Get disk handle */ 1268 disk_handle = raidcfg_get_disk(ctl_handle, disk_tag); 1269 if (disk_handle <= 0) { 1270 (void) fprintf(stderr, "%s\n", 1271 raidcfg_errstr(disk_handle)); 1272 (void) raidcfg_close_controller(ctl_handle, NULL); 1273 return (FAILURE); 1274 } 1275 1276 /* Get array handle */ 1277 array_handle = raidcfg_get_array(ctl_handle, 1278 array_tag.idl.target_id, array_tag.idl.lun); 1279 if (array_handle <= 0) { 1280 (void) fprintf(stderr, "%s\n", 1281 raidcfg_errstr(array_handle)); 1282 (void) raidcfg_close_controller(ctl_handle, NULL); 1283 return (FAILURE); 1284 } 1285 } 1286 1287 hsp_relation.disk_handle = disk_handle; 1288 if (hsp_type) { 1289 /* Set or unset local HSP */ 1290 hsp_relation.array_handle = array_handle; 1291 } else { 1292 /* Set or unset global HSP */ 1293 hsp_relation.array_handle = OBJ_ATTR_NONE; 1294 } 1295 1296 /* Perform operation of set or unset */ 1297 if (flag == HSP_SET) { 1298 if ((ret = raidcfg_set_hsp(&hsp_relation, NULL)) < 0) { 1299 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1300 (void) raidcfg_close_controller(ctl_handle, NULL); 1301 return (FAILURE); 1302 } 1303 1304 if (hsp_type) { 1305 (void) printf(gettext("Set local HSP between disk %s " 1306 "and RAID volume %s successfully.\n"), 1307 disk_argp, argv[optind]); 1308 } else { 1309 (void) printf(gettext("Set global HSP between disk %s " 1310 "and controller %s successfully.\n"), 1311 disk_argp, argv[optind]); 1312 } 1313 } else { 1314 if ((ret = raidcfg_unset_hsp(&hsp_relation, NULL)) < 0) { 1315 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1316 (void) raidcfg_close_controller(ctl_handle, NULL); 1317 return (FAILURE); 1318 } 1319 1320 if (hsp_type) { 1321 (void) printf(gettext("Unset local HSP between " 1322 "disk %s and RAID volume %s successfully.\n"), 1323 disk_argp, argv[optind]); 1324 } else { 1325 (void) printf(gettext("Unset global HSP between " 1326 "disk %s and controller %s successfully.\n"), 1327 disk_argp, argv[optind]); 1328 } 1329 } 1330 (void) raidcfg_close_controller(ctl_handle, NULL); 1331 return (SUCCESS); 1332 } 1333 1334 /* 1335 * do_set_array_attr(f_flag, p_argp, argv, optind) 1336 * This function changes array's attribute when array is running. 1337 * The changeable attribute is up to controller's feature. 1338 * The return value can be SUCCESS, FAILURE or INVALID_ARG. 1339 */ 1340 static int 1341 do_set_array_attr(uint32_t f_flag, char *p_argp, char **argv, uint32_t optind) 1342 { 1343 uint32_t ctl_tag = MAX32BIT; 1344 array_tag_t array_tag; 1345 uint32_t type = MAX32BIT; 1346 uint32_t value = MAX32BIT; 1347 raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE; 1348 raid_obj_handle_t array_handle = INIT_HANDLE_VALUE; 1349 1350 char *param, *op = "="; 1351 1352 int ret; 1353 1354 if (argv[optind] == NULL || argv[optind + 1] != NULL) { 1355 return (INVALID_ARG); 1356 } 1357 1358 if (p_argp != NULL) { 1359 param = strtok(p_argp, op); 1360 if (strcmp(param, "wp") == 0) { 1361 type = SET_CACHE_WR_PLY; 1362 param = strtok(NULL, op); 1363 if (strcmp(param, "on") == 0) { 1364 value = CACHE_WR_ON; 1365 } else if (strcmp(param, "off") == 0) { 1366 value = CACHE_WR_OFF; 1367 } else { 1368 return (INVALID_ARG); 1369 } 1370 } else if (strcmp(param, "state") == 0) { 1371 type = SET_ACTIVATION_PLY; 1372 param = strtok(NULL, op); 1373 if (strcmp(param, "activate") == 0) { 1374 value = ARRAY_ACT_ACTIVATE; 1375 } else { 1376 return (INVALID_ARG); 1377 } 1378 } else { 1379 return (INVALID_ARG); 1380 } 1381 } else { 1382 return (INVALID_ARG); 1383 } 1384 1385 if (get_array_tag(argv[optind], &ctl_tag, &array_tag) != SUCCESS) { 1386 return (INVALID_ARG); 1387 } 1388 1389 ctl_handle = raidcfg_get_controller(ctl_tag); 1390 if (ctl_handle <= 0) { 1391 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ctl_handle)); 1392 return (FAILURE); 1393 } 1394 1395 ret = raidcfg_open_controller(ctl_handle, NULL); 1396 if (ret < 0) { 1397 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1398 return (FAILURE); 1399 } 1400 1401 array_handle = raidcfg_get_array(ctl_handle, array_tag.idl.target_id, 1402 array_tag.idl.lun); 1403 if (array_handle <= 0) { 1404 (void) fprintf(stderr, "%s\n", raidcfg_errstr(array_handle)); 1405 return (FAILURE); 1406 } 1407 1408 /* Ask user to confirm operation. */ 1409 if (f_flag == FALSE) { 1410 (void) fprintf(stdout, gettext("Update attribute of " 1411 "array %s (%s/%s)? "), argv[optind], yesstr, nostr); 1412 if (!yes()) { 1413 (void) fprintf(stdout, 1414 gettext("Array %s not " 1415 "changed.\n\n"), argv[optind]); 1416 (void) raidcfg_close_controller(ctl_handle, NULL); 1417 return (SUCCESS); 1418 } 1419 } 1420 1421 if ((ret = raidcfg_set_attr(array_handle, type, &value, NULL)) < 0) { 1422 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1423 (void) raidcfg_close_controller(ctl_handle, NULL); 1424 return (FAILURE); 1425 } 1426 1427 (void) printf(gettext("Set attribute of RAID volume %s " 1428 "successfully.\n"), argv[optind]); 1429 (void) raidcfg_close_controller(ctl_handle, NULL); 1430 1431 return (SUCCESS); 1432 } 1433 1434 /* 1435 * snapshot_raidsystem(recursive, indent, is_snapshot) 1436 * This function prints the snapshot of whole RAID's system configuration, 1437 * and return result as SUCCESS or FAILURE. 1438 */ 1439 static int 1440 snapshot_raidsystem(uint8_t recursive, uint8_t indent, uint8_t is_snapshot) 1441 { 1442 raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE; 1443 int ret; 1444 1445 ctl_handle = raidcfg_list_head(OBJ_SYSTEM, OBJ_TYPE_CONTROLLER); 1446 while (ctl_handle > 0) { 1447 ret = raidcfg_open_controller(ctl_handle, NULL); 1448 if (ret == 0) { 1449 if (snapshot_ctl(ctl_handle, recursive, indent, 1450 is_snapshot) == FAILURE) { 1451 (void) raidcfg_close_controller(ctl_handle, 1452 NULL); 1453 } 1454 } 1455 ctl_handle = raidcfg_list_next(ctl_handle); 1456 } 1457 return (SUCCESS); 1458 } 1459 1460 /* 1461 * snapshot_ctl(ctl_handle, recursive, indent, is_snapshot) 1462 * This function prints snapshot of specified controller's configuration, 1463 * and return result as SUCCESS or FAILURE. 1464 */ 1465 static int 1466 snapshot_ctl(raid_obj_handle_t ctl_handle, uint8_t recursive, uint8_t indent, 1467 uint8_t is_snapshot) 1468 { 1469 raid_obj_handle_t array_handle = INIT_HANDLE_VALUE; 1470 raid_obj_handle_t disk_handle = INIT_HANDLE_VALUE; 1471 raidcfg_controller_t ctl_attr; 1472 uint32_t ctl_tag; 1473 char ctlbuf[256]; 1474 int ret; 1475 1476 if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) { 1477 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1478 return (FAILURE); 1479 } 1480 1481 ctl_tag = ctl_attr.controller_id; 1482 if (is_snapshot == FALSE) { 1483 print_indent(indent); 1484 (void) fprintf(stdout, gettext("Controller: %u\n"), ctl_tag); 1485 } else { 1486 (void) snprintf(ctlbuf, sizeof (ctlbuf), "%u \"%s\"", 1487 ctl_tag, ctl_attr.controller_type); 1488 (void) fprintf(stdout, "%s", ctlbuf); 1489 1490 (void) fprintf(stdout, "\n"); 1491 } 1492 1493 if (recursive == TRUE) { 1494 array_handle = raidcfg_list_head(ctl_handle, OBJ_TYPE_ARRAY); 1495 while (array_handle > 0) { 1496 if (snapshot_array(array_handle, 1497 indent + 1, FALSE, is_snapshot) == FAILURE) { 1498 return (FAILURE); 1499 } 1500 1501 array_handle = raidcfg_list_next(array_handle); 1502 } 1503 1504 disk_handle = raidcfg_list_head(ctl_handle, OBJ_TYPE_DISK); 1505 while (disk_handle > 0) { 1506 if (snapshot_disk(ctl_tag, disk_handle, 1507 indent + 1, is_snapshot) == FAILURE) { 1508 return (FAILURE); 1509 } 1510 1511 disk_handle = raidcfg_list_next(disk_handle); 1512 } 1513 } 1514 return (SUCCESS); 1515 } 1516 1517 1518 /* 1519 * snapshot_array(array_handle, indent, is_sub, is_snapshot) 1520 * This function prints snapshot of specified array's configuration, 1521 * and return result as SUCCESS or FAILURE. 1522 */ 1523 static int 1524 snapshot_array(raid_obj_handle_t array_handle, uint8_t indent, uint8_t is_sub, 1525 uint8_t is_snapshot) 1526 { 1527 raid_obj_handle_t ctl_handle; 1528 raid_obj_handle_t subarray_handle; 1529 raid_obj_handle_t arraypart_handle; 1530 raid_obj_handle_t task_handle; 1531 1532 raidcfg_controller_t ctl_attr; 1533 raidcfg_array_t array_attr; 1534 raidcfg_arraypart_t arraypart_attr; 1535 raidcfg_task_t task_attr; 1536 1537 char arraybuf[256] = "\0"; 1538 char diskbuf[256] = "\0"; 1539 char tempbuf[256] = "\0"; 1540 int disknum = 0; 1541 1542 uint32_t ctl_tag; 1543 int ret; 1544 1545 ctl_handle = raidcfg_get_container(array_handle); 1546 ret = raidcfg_get_attr(ctl_handle, &ctl_attr); 1547 if (ret < 0) { 1548 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1549 return (FAILURE); 1550 } 1551 ctl_tag = ctl_attr.controller_id; 1552 1553 /* Print array attribute */ 1554 if ((ret = raidcfg_get_attr(array_handle, &array_attr)) < 0) { 1555 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1556 return (FAILURE); 1557 } 1558 1559 if (is_snapshot == FALSE) { 1560 print_indent(indent); 1561 if (is_sub == FALSE) { 1562 (void) fprintf(stdout, gettext("Volume:" 1563 "c%ut%llud%llu\n"), 1564 ctl_tag, array_attr.tag.idl.target_id, 1565 array_attr.tag.idl.lun); 1566 } else { 1567 (void) fprintf(stdout, gettext("Sub-Volume\n")); 1568 } 1569 } else { 1570 (void) snprintf(arraybuf, sizeof (arraybuf), "c%ut%llud%llu ", 1571 ctl_tag, array_attr.tag.idl.target_id, 1572 array_attr.tag.idl.lun); 1573 1574 /* Check if array is in sync state */ 1575 task_handle = raidcfg_list_head(array_handle, OBJ_TYPE_TASK); 1576 if (task_handle > 0) { 1577 (void) raidcfg_get_attr(task_handle, &task_attr); 1578 if (task_attr.task_func == TASK_FUNC_BUILD) { 1579 array_attr.state = ARRAY_STATE_SYNC; 1580 } 1581 } else { 1582 subarray_handle = raidcfg_list_head(array_handle, 1583 OBJ_TYPE_ARRAY); 1584 while (subarray_handle > 0) { 1585 task_handle = raidcfg_list_head(subarray_handle, 1586 OBJ_TYPE_TASK); 1587 if (task_handle > 0) { 1588 (void) raidcfg_get_attr(task_handle, 1589 &task_attr); 1590 if (task_attr.task_func == 1591 TASK_FUNC_BUILD) { 1592 array_attr.state = 1593 ARRAY_STATE_SYNC; 1594 } 1595 break; 1596 } 1597 subarray_handle = 1598 raidcfg_list_next(subarray_handle); 1599 } 1600 } 1601 1602 /* Print sub array */ 1603 subarray_handle = raidcfg_list_head(array_handle, 1604 OBJ_TYPE_ARRAY); 1605 while (subarray_handle > 0) { 1606 /* print subarraypart */ 1607 arraypart_handle = raidcfg_list_head(subarray_handle, 1608 OBJ_TYPE_ARRAY_PART); 1609 while (arraypart_handle > 0) { 1610 if ((ret = raidcfg_get_attr(arraypart_handle, 1611 &arraypart_attr)) < 0) { 1612 (void) fprintf(stderr, "%s\n", 1613 raidcfg_errstr(ret)); 1614 return (FAILURE); 1615 } 1616 1617 if (arraypart_attr.tag.cidl.bus == MAX64BIT) { 1618 (void) snprintf(tempbuf, 1619 sizeof (tempbuf), 1620 gettext("N/A")); 1621 } else { 1622 (void) snprintf(tempbuf, 1623 sizeof (tempbuf), 1624 "%llu.%llu.%llu", 1625 arraypart_attr.tag.cidl.bus, 1626 arraypart_attr.tag.cidl.target_id, 1627 arraypart_attr.tag.cidl.lun); 1628 } 1629 (void) strlcat(diskbuf, tempbuf, 1630 sizeof (diskbuf)); 1631 (void) strcat(diskbuf, " "); 1632 disknum++; 1633 arraypart_handle = 1634 raidcfg_list_next(arraypart_handle); 1635 } 1636 subarray_handle = raidcfg_list_next(subarray_handle); 1637 } 1638 1639 /* Print arraypart */ 1640 arraypart_handle = raidcfg_list_head(array_handle, 1641 OBJ_TYPE_ARRAY_PART); 1642 while (arraypart_handle > 0) { 1643 if ((ret = raidcfg_get_attr(arraypart_handle, 1644 &arraypart_attr)) < 0) { 1645 (void) fprintf(stderr, "%s\n", 1646 raidcfg_errstr(ret)); 1647 return (FAILURE); 1648 } 1649 1650 if (arraypart_attr.tag.cidl.bus == MAX64BIT) { 1651 (void) snprintf(tempbuf, sizeof (tempbuf), 1652 gettext("N/A")); 1653 } else { 1654 (void) snprintf(tempbuf, sizeof (tempbuf), 1655 "%llu.%llu.%llu", 1656 arraypart_attr.tag.cidl.bus, 1657 arraypart_attr.tag.cidl.target_id, 1658 arraypart_attr.tag.cidl.lun); 1659 } 1660 (void) strlcat(diskbuf, tempbuf, sizeof (diskbuf)); 1661 (void) strcat(diskbuf, " "); 1662 disknum++; 1663 arraypart_handle = raidcfg_list_next(arraypart_handle); 1664 } 1665 (void) snprintf(tempbuf, sizeof (tempbuf), "%u ", disknum); 1666 (void) strlcat(arraybuf, tempbuf, sizeof (arraybuf)); 1667 (void) strlcat(arraybuf, diskbuf, sizeof (arraybuf)); 1668 1669 switch (array_attr.raid_level) { 1670 case RAID_LEVEL_0: 1671 (void) sprintf(tempbuf, "0"); 1672 break; 1673 case RAID_LEVEL_1: 1674 (void) sprintf(tempbuf, "1"); 1675 break; 1676 case RAID_LEVEL_1E: 1677 (void) sprintf(tempbuf, "1E"); 1678 break; 1679 case RAID_LEVEL_5: 1680 (void) sprintf(tempbuf, "5"); 1681 break; 1682 case RAID_LEVEL_10: 1683 (void) sprintf(tempbuf, "10"); 1684 break; 1685 case RAID_LEVEL_50: 1686 (void) sprintf(tempbuf, "50"); 1687 break; 1688 default: 1689 (void) snprintf(tempbuf, sizeof (tempbuf), 1690 gettext("N/A")); 1691 break; 1692 } 1693 (void) strlcat(arraybuf, tempbuf, sizeof (arraybuf)); 1694 (void) fprintf(stdout, "%s ", arraybuf); 1695 1696 switch (array_attr.state) { 1697 case ARRAY_STATE_OPTIMAL: 1698 (void) fprintf(stdout, gettext("OPTIMAL")); 1699 break; 1700 case ARRAY_STATE_DEGRADED: 1701 (void) fprintf(stdout, gettext("DEGRADED")); 1702 break; 1703 case ARRAY_STATE_FAILED: 1704 (void) fprintf(stdout, gettext("FAILED")); 1705 break; 1706 case ARRAY_STATE_SYNC: 1707 (void) fprintf(stdout, gettext("SYNC")); 1708 break; 1709 case ARRAY_STATE_MISSING: 1710 (void) fprintf(stdout, gettext("MISSING")); 1711 break; 1712 default: 1713 (void) fprintf(stdout, gettext("N/A")); 1714 break; 1715 } 1716 (void) fprintf(stdout, "\n"); 1717 } 1718 1719 return (SUCCESS); 1720 } 1721 1722 /* 1723 * snapshot_disk(ctl_tag, disk_handle, indent, is_snapshot) 1724 * This function prints snapshot of specified disk's configuration, and return 1725 * result as SUCCESS or FAILURE. 1726 */ 1727 static int 1728 snapshot_disk(uint32_t ctl_tag, raid_obj_handle_t disk_handle, uint8_t indent, 1729 uint8_t is_snapshot) 1730 { 1731 raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE; 1732 raid_obj_handle_t hsp_handle; 1733 1734 raidcfg_controller_t ctl_attr; 1735 raidcfg_disk_t disk_attr; 1736 char diskbuf[256] = ""; 1737 char tempbuf[256] = ""; 1738 1739 int ret; 1740 1741 ctl_handle = raidcfg_get_controller(ctl_tag); 1742 ret = raidcfg_get_attr(ctl_handle, &ctl_attr); 1743 if (ret < 0) { 1744 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1745 return (FAILURE); 1746 } 1747 1748 /* Print attribute of disk */ 1749 if ((ret = raidcfg_get_attr(disk_handle, &disk_attr)) < 0) { 1750 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1751 return (FAILURE); 1752 } 1753 1754 if (is_snapshot == FALSE) { 1755 print_indent(indent); 1756 1757 hsp_handle = raidcfg_list_head(disk_handle, OBJ_TYPE_HSP); 1758 1759 if (disk_attr.tag.cidl.bus == MAX64BIT) { 1760 (void) fprintf(stdout, gettext("Disk: N/A")); 1761 } else { 1762 (void) fprintf(stdout, gettext("Disk: %llu.%llu.%llu"), 1763 disk_attr.tag.cidl.bus, 1764 disk_attr.tag.cidl.target_id, 1765 disk_attr.tag.cidl.lun); 1766 } 1767 if (hsp_handle > 0) { 1768 (void) fprintf(stdout, "(HSP)"); 1769 } 1770 (void) fprintf(stdout, "\n"); 1771 } else { 1772 if (disk_attr.tag.cidl.bus == MAX64BIT) { 1773 (void) fprintf(stdout, gettext("N/A")); 1774 } else { 1775 (void) snprintf(diskbuf, sizeof (diskbuf), 1776 "%llu.%llu.%llu ", 1777 disk_attr.tag.cidl.bus, 1778 disk_attr.tag.cidl.target_id, 1779 disk_attr.tag.cidl.lun); 1780 } 1781 hsp_handle = raidcfg_list_head(disk_handle, OBJ_TYPE_HSP); 1782 if (hsp_handle > 0) { 1783 (void) snprintf(tempbuf, sizeof (tempbuf), 1784 gettext("HSP")); 1785 } else if (disk_attr.state == DISK_STATE_GOOD) { 1786 (void) snprintf(tempbuf, sizeof (tempbuf), 1787 gettext("GOOD")); 1788 } else if (disk_attr.state == DISK_STATE_FAILED) { 1789 (void) snprintf(tempbuf, sizeof (tempbuf), 1790 gettext("FAILED")); 1791 } else { 1792 (void) snprintf(tempbuf, sizeof (tempbuf), 1793 gettext("N/A")); 1794 } 1795 1796 (void) strlcat(diskbuf, tempbuf, sizeof (diskbuf)); 1797 (void) fprintf(stdout, "%s\n", diskbuf); 1798 } 1799 1800 return (SUCCESS); 1801 } 1802 1803 static int 1804 print_ctl_table(raid_obj_handle_t ctl_handle) 1805 { 1806 raidcfg_controller_t ctl_attr; 1807 char controller[8]; 1808 int ret; 1809 1810 if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) { 1811 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1812 return (FAILURE); 1813 } 1814 1815 (void) fprintf(stdout, gettext("Controller\tType\t\tVersion")); 1816 (void) fprintf(stdout, "\n"); 1817 (void) fprintf(stdout, "--------------------------------"); 1818 (void) fprintf(stdout, "--------------------------------"); 1819 (void) fprintf(stdout, "\n"); 1820 1821 (void) snprintf(controller, sizeof (controller), "%u", 1822 ctl_attr.controller_id); 1823 (void) printf("c%s\t\t", controller); 1824 1825 (void) print_ctl_attr(&ctl_attr); 1826 (void) fprintf(stdout, "\n"); 1827 1828 return (SUCCESS); 1829 } 1830 1831 static int 1832 print_array_table(raid_obj_handle_t ctl_handle, raid_obj_handle_t array_handle) 1833 { 1834 raidcfg_controller_t ctl_attr; 1835 raidcfg_array_t array_attr; 1836 raidcfg_array_t subarray_attr; 1837 raidcfg_arraypart_t arraypart_attr; 1838 raidcfg_task_t task_attr; 1839 1840 raid_obj_handle_t subarray_handle; 1841 raid_obj_handle_t arraypart_handle; 1842 raid_obj_handle_t task_handle; 1843 1844 char array[16]; 1845 char arraypart[8]; 1846 int ret; 1847 int i; 1848 1849 /* Controller attribute */ 1850 if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) { 1851 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1852 return (FAILURE); 1853 } 1854 1855 /* Array attribute */ 1856 if ((ret = raidcfg_get_attr(array_handle, &array_attr)) < 0) { 1857 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1858 return (FAILURE); 1859 } 1860 1861 /* print header */ 1862 (void) fprintf(stdout, gettext("Volume\t\t\tSize\tStripe\tStatus\t" 1863 " Cache\tRAID")); 1864 (void) fprintf(stdout, "\n"); 1865 (void) fprintf(stdout, gettext("\tSub\t\t\tSize\t\t\tLevel")); 1866 (void) fprintf(stdout, "\n"); 1867 (void) fprintf(stdout, gettext("\t\tDisk\t\t\t\t\t")); 1868 (void) fprintf(stdout, "\n"); 1869 (void) fprintf(stdout, "--------------------------------"); 1870 (void) fprintf(stdout, "--------------------------------"); 1871 (void) fprintf(stdout, "\n"); 1872 1873 /* print array */ 1874 (void) snprintf(array, sizeof (array), "c%ut%llud%llu", 1875 ctl_attr.controller_id, array_attr.tag.idl.target_id, 1876 array_attr.tag.idl.lun); 1877 (void) fprintf(stdout, "%s\t\t", array); 1878 if (strlen(array) < 8) 1879 (void) fprintf(stdout, "\t"); 1880 1881 1882 /* check if array is in sync state */ 1883 task_handle = raidcfg_list_head(array_handle, OBJ_TYPE_TASK); 1884 if (task_handle > 0) { 1885 (void) raidcfg_get_attr(task_handle, &task_attr); 1886 if (task_attr.task_func == TASK_FUNC_BUILD) { 1887 array_attr.state = ARRAY_STATE_SYNC; 1888 } 1889 } else { 1890 subarray_handle = raidcfg_list_head(array_handle, 1891 OBJ_TYPE_ARRAY); 1892 while (subarray_handle > 0) { 1893 task_handle = raidcfg_list_head(subarray_handle, 1894 OBJ_TYPE_TASK); 1895 if (task_handle > 0) { 1896 (void) raidcfg_get_attr(task_handle, 1897 &task_attr); 1898 if (task_attr.task_func == TASK_FUNC_BUILD) { 1899 array_attr.state = ARRAY_STATE_SYNC; 1900 } 1901 break; 1902 } 1903 subarray_handle = raidcfg_list_next(subarray_handle); 1904 } 1905 } 1906 1907 (void) print_array_attr(&array_attr); 1908 (void) fprintf(stdout, "\n"); 1909 1910 /* Print sub array */ 1911 i = 0; /* Count sub array number */ 1912 subarray_handle = raidcfg_list_head(array_handle, OBJ_TYPE_ARRAY); 1913 while (subarray_handle > 0) { 1914 if ((ret = raidcfg_get_attr(subarray_handle, 1915 &subarray_attr)) < 0) { 1916 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1917 return (FAILURE); 1918 } 1919 1920 /* Use sub0/sub1 here, not cxtxd0 for subarray */ 1921 (void) snprintf(array, sizeof (array), "sub%u", i++); 1922 (void) fprintf(stdout, "\t%s\t\t", array); 1923 1924 /* Check if array is in sync */ 1925 task_handle = raidcfg_list_head(subarray_handle, OBJ_TYPE_TASK); 1926 if (task_handle > 0) { 1927 (void) raidcfg_get_attr(task_handle, &task_attr); 1928 if (task_attr.task_func == TASK_FUNC_BUILD) { 1929 subarray_attr.state = ARRAY_STATE_SYNC; 1930 } 1931 } 1932 1933 (void) print_array_attr(&subarray_attr); 1934 (void) fprintf(stdout, "\n"); 1935 1936 /* Print subarraypart */ 1937 arraypart_handle = raidcfg_list_head(subarray_handle, 1938 OBJ_TYPE_ARRAY_PART); 1939 while (arraypart_handle > 0) { 1940 if ((ret = raidcfg_get_attr(arraypart_handle, 1941 &arraypart_attr)) < 0) { 1942 (void) fprintf(stderr, "%s\n", 1943 raidcfg_errstr(ret)); 1944 return (FAILURE); 1945 } 1946 1947 if (arraypart_attr.tag.cidl.bus == MAX64BIT) { 1948 (void) snprintf(arraypart, sizeof (arraypart), 1949 gettext("N/A")); 1950 } else { 1951 (void) snprintf(arraypart, sizeof (arraypart), 1952 "%llu.%llu.%llu", 1953 arraypart_attr.tag.cidl.bus, 1954 arraypart_attr.tag.cidl.target_id, 1955 arraypart_attr.tag.cidl.lun); 1956 } 1957 1958 (void) fprintf(stdout, "\t\t%s\t", arraypart); 1959 (void) print_arraypart_attr(&arraypart_attr); 1960 (void) fprintf(stdout, "\n"); 1961 arraypart_handle = raidcfg_list_next(arraypart_handle); 1962 } 1963 subarray_handle = raidcfg_list_next(subarray_handle); 1964 } 1965 1966 /* Print arraypart */ 1967 arraypart_handle = raidcfg_list_head(array_handle, 1968 OBJ_TYPE_ARRAY_PART); 1969 while (arraypart_handle > 0) { 1970 if ((ret = raidcfg_get_attr(arraypart_handle, 1971 &arraypart_attr)) < 0) { 1972 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 1973 return (FAILURE); 1974 } 1975 1976 if (arraypart_attr.tag.cidl.bus == MAX64BIT) { 1977 (void) snprintf(arraypart, sizeof (arraypart), 1978 gettext("N/A")); 1979 } else { 1980 (void) snprintf(arraypart, sizeof (arraypart), 1981 "%llu.%llu.%llu", 1982 arraypart_attr.tag.cidl.bus, 1983 arraypart_attr.tag.cidl.target_id, 1984 arraypart_attr.tag.cidl.lun); 1985 } 1986 1987 (void) fprintf(stdout, "\t\t%s\t", arraypart); 1988 (void) print_arraypart_attr(&arraypart_attr); 1989 (void) fprintf(stdout, "\n"); 1990 arraypart_handle = raidcfg_list_next(arraypart_handle); 1991 } 1992 1993 return (SUCCESS); 1994 } 1995 1996 static int 1997 print_disk_table(raid_obj_handle_t ctl_handle, raid_obj_handle_t disk_handle) 1998 { 1999 raidcfg_controller_t ctl_attr; 2000 raidcfg_disk_t disk_attr; 2001 raidcfg_prop_t *prop_attr, *prop_attr2; 2002 raid_obj_handle_t prop_handle; 2003 char disk[8]; 2004 int ret; 2005 2006 if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) { 2007 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 2008 return (FAILURE); 2009 } 2010 2011 if ((ret = raidcfg_get_attr(disk_handle, &disk_attr)) < 0) { 2012 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 2013 return (FAILURE); 2014 } 2015 2016 /* Print header */ 2017 (void) fprintf(stdout, gettext("Disk\tVendor Product " 2018 "Firmware\tCapacity\tStatus\tHSP")); 2019 (void) fprintf(stdout, "\n"); 2020 (void) fprintf(stdout, "--------------------------------------"); 2021 (void) fprintf(stdout, "--------------------------------------"); 2022 (void) fprintf(stdout, "\n"); 2023 2024 2025 (void) snprintf(disk, sizeof (disk), "%llu.%llu.%llu", 2026 disk_attr.tag.cidl.bus, 2027 disk_attr.tag.cidl.target_id, 2028 disk_attr.tag.cidl.lun); 2029 2030 (void) fprintf(stdout, "%s\t", disk); 2031 2032 (void) print_disk_attr(ctl_handle, disk_handle, &disk_attr); 2033 2034 prop_attr = calloc(1, sizeof (raidcfg_prop_t)); 2035 if (prop_attr == NULL) { 2036 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ERR_NOMEM)); 2037 return (FAILURE); 2038 } 2039 2040 prop_handle = raidcfg_list_head(disk_handle, OBJ_TYPE_PROP); 2041 if (prop_handle == 0) { 2042 free(prop_attr); 2043 return (SUCCESS); 2044 } 2045 2046 do { 2047 prop_attr->prop_size = 0; 2048 if ((ret = raidcfg_get_attr(prop_handle, prop_attr)) < 0) { 2049 free(prop_attr); 2050 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 2051 return (FAILURE); 2052 } 2053 if (prop_attr->prop_type == PROP_GUID) 2054 break; 2055 } while (prop_handle != 0); 2056 2057 prop_attr2 = realloc(prop_attr, 2058 sizeof (raidcfg_prop_t) + prop_attr->prop_size); 2059 free(prop_attr); 2060 if (prop_attr2 == NULL) { 2061 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ERR_NOMEM)); 2062 return (FAILURE); 2063 } 2064 2065 if ((ret = raidcfg_get_attr(prop_handle, prop_attr2)) < 0) { 2066 free(prop_attr2); 2067 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 2068 return (FAILURE); 2069 } 2070 2071 (void) fprintf(stdout, "GUID:%s\n", prop_attr2->prop); 2072 2073 free(prop_attr2); 2074 return (SUCCESS); 2075 } 2076 2077 /* 2078 * print_ctl_attr(attrp) 2079 * This function prints attribute of specified controller, and return 2080 * result as SUCCESS or FAILURE. 2081 */ 2082 static int 2083 print_ctl_attr(raidcfg_controller_t *attrp) 2084 { 2085 char type[CONTROLLER_TYPE_LEN]; 2086 char version[CONTROLLER_FW_LEN]; 2087 2088 if (attrp == NULL) { 2089 return (FAILURE); 2090 } 2091 2092 (void) snprintf(type, sizeof (type), "%s", attrp->controller_type); 2093 (void) fprintf(stdout, "%-16s", type); 2094 2095 (void) snprintf(version, sizeof (version), "%s", attrp->fw_version); 2096 (void) fprintf(stdout, "%s", version); 2097 2098 return (SUCCESS); 2099 } 2100 2101 /* 2102 * print_array_attr(attrp) 2103 * This function prints attribute of specified array, and return 2104 * result as SUCCESS or FAILURE. 2105 */ 2106 static int 2107 print_array_attr(raidcfg_array_t *attrp) 2108 { 2109 char capacity[8]; 2110 char stripe_size[8]; 2111 char raid_level[8]; 2112 2113 if (attrp == NULL) { 2114 return (FAILURE); 2115 } 2116 2117 if (attrp->capacity != MAX64BIT) { 2118 if (size_to_string(attrp->capacity, capacity, 8) != SUCCESS) { 2119 return (FAILURE); 2120 } 2121 (void) printf("%s\t", capacity); 2122 } else { 2123 (void) printf(gettext("N/A\t")); 2124 } 2125 2126 if (attrp->stripe_size != MAX32BIT) { 2127 (void) snprintf(stripe_size, sizeof (stripe_size), "%uK", 2128 attrp->stripe_size / 1024); 2129 (void) printf("%s\t", stripe_size); 2130 } else { 2131 (void) printf(gettext("N/A\t")); 2132 } 2133 2134 if (attrp->state & ARRAY_STATE_INACTIVATE) 2135 (void) printf("%-8s", gettext("INACTIVE")); 2136 else { 2137 switch (attrp->state) { 2138 case ARRAY_STATE_OPTIMAL: 2139 (void) printf("%-8s", gettext("OPTIMAL")); 2140 break; 2141 case ARRAY_STATE_DEGRADED: 2142 (void) printf("%-8s", gettext("DEGRADED")); 2143 break; 2144 case ARRAY_STATE_FAILED: 2145 (void) printf("%-8s", gettext("FAILED")); 2146 break; 2147 case ARRAY_STATE_SYNC: 2148 (void) printf("%-8s", gettext("SYNC")); 2149 break; 2150 case ARRAY_STATE_MISSING: 2151 (void) printf("%-8s", gettext("MISSING")); 2152 break; 2153 default: 2154 (void) printf("%-8s", gettext("N/A")); 2155 break; 2156 } 2157 } 2158 (void) printf(" "); 2159 2160 if (attrp->write_policy == CACHE_WR_OFF) { 2161 (void) printf(gettext("OFF")); 2162 } else if (attrp->write_policy == CACHE_WR_ON) { 2163 (void) printf(gettext("ON")); 2164 } else { 2165 (void) printf(gettext("N/A")); 2166 } 2167 (void) printf("\t"); 2168 2169 switch (attrp->raid_level) { 2170 case RAID_LEVEL_0: 2171 (void) sprintf(raid_level, "RAID0"); 2172 break; 2173 case RAID_LEVEL_1: 2174 (void) sprintf(raid_level, "RAID1"); 2175 break; 2176 case RAID_LEVEL_1E: 2177 (void) sprintf(raid_level, "RAID1E"); 2178 break; 2179 case RAID_LEVEL_5: 2180 (void) sprintf(raid_level, "RAID5"); 2181 break; 2182 case RAID_LEVEL_10: 2183 (void) sprintf(raid_level, "RAID10"); 2184 break; 2185 case RAID_LEVEL_50: 2186 (void) sprintf(raid_level, "RAID50"); 2187 break; 2188 default: 2189 (void) snprintf(raid_level, sizeof (raid_level), 2190 gettext("N/A")); 2191 break; 2192 } 2193 (void) printf("%s", raid_level); 2194 2195 return (SUCCESS); 2196 } 2197 2198 /* 2199 * print_arraypart_attr(attrp) 2200 * This function print attribute of specified arraypart, and return 2201 * result as SUCCESS or FAILURE. 2202 */ 2203 static int 2204 print_arraypart_attr(raidcfg_arraypart_t *attrp) 2205 { 2206 char size[8]; 2207 2208 if (attrp == NULL) { 2209 return (FAILURE); 2210 } 2211 2212 if (attrp->size != MAX64BIT) { 2213 if (size_to_string(attrp->size, size, 8) != SUCCESS) { 2214 return (FAILURE); 2215 } 2216 (void) printf("%s\t", size); 2217 } else { 2218 (void) printf(gettext("N/A\t")); 2219 } 2220 2221 (void) printf("\t"); 2222 2223 if (attrp->state == DISK_STATE_GOOD) { 2224 (void) printf(gettext("GOOD")); 2225 } else if (attrp->state == DISK_STATE_FAILED) { 2226 (void) printf(gettext("FAILED")); 2227 } else { 2228 (void) printf(gettext("N/A")); 2229 } 2230 (void) printf("\t"); 2231 2232 return (SUCCESS); 2233 } 2234 2235 /* 2236 * print_disk_attr(ctl_handle, disk_handle, attrp) 2237 * This function prints attribute of specified disk, and return 2238 * result as SUCCESS or FAILURE. 2239 */ 2240 static int 2241 print_disk_attr(raid_obj_handle_t ctl_handle, raid_obj_handle_t disk_handle, 2242 raidcfg_disk_t *attrp) 2243 { 2244 char vendor[DISK_VENDER_LEN + 1]; 2245 char product[DISK_PRODUCT_LEN + 1]; 2246 char revision[DISK_REV_LEN + 1]; 2247 char capacity[16]; 2248 char hsp[16]; 2249 2250 raid_obj_handle_t hsp_handle; 2251 raidcfg_hsp_t hsp_attr; 2252 raidcfg_controller_t ctl_attr; 2253 int ret; 2254 char is_indent; 2255 2256 if (attrp == NULL) { 2257 return (FAILURE); 2258 } 2259 2260 (void) memccpy(vendor, attrp->vendorid, '\0', DISK_VENDER_LEN); 2261 vendor[DISK_VENDER_LEN] = '\0'; 2262 (void) printf("%-9s", vendor); 2263 2264 (void) memccpy(product, attrp->productid, '\0', DISK_PRODUCT_LEN); 2265 product[DISK_PRODUCT_LEN] = '\0'; 2266 (void) printf("%-17s", product); 2267 2268 (void) memccpy(revision, attrp->revision, '\0', DISK_REV_LEN); 2269 revision[DISK_REV_LEN] = '\0'; 2270 (void) printf("%s\t\t", revision); 2271 2272 if (attrp->capacity != MAX64BIT) { 2273 if (size_to_string(attrp->capacity, capacity, 16) != SUCCESS) { 2274 return (FAILURE); 2275 } 2276 (void) printf("%s\t\t", capacity); 2277 } else { 2278 (void) printf(gettext("N/A")); 2279 } 2280 2281 if (attrp->state == DISK_STATE_GOOD) { 2282 (void) printf(gettext("GOOD")); 2283 } else if (attrp->state == DISK_STATE_FAILED) { 2284 (void) printf(gettext("FAILED")); 2285 } else { 2286 (void) printf(gettext("N/A")); 2287 } 2288 (void) printf("\t"); 2289 2290 /* Controller attribute */ 2291 if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) { 2292 (void) fprintf(stderr, "%s\n", raidcfg_errstr(ret)); 2293 return (FAILURE); 2294 } 2295 2296 hsp_handle = raidcfg_list_head(disk_handle, OBJ_TYPE_HSP); 2297 if (hsp_handle == 0) { 2298 (void) printf(gettext("N/A\n")); 2299 } else { 2300 is_indent = FALSE; 2301 while (hsp_handle > 0) { 2302 if ((ret = raidcfg_get_attr(hsp_handle, 2303 &hsp_attr)) < 0) { 2304 (void) fprintf(stderr, "%s\n", 2305 raidcfg_errstr(ret)); 2306 return (FAILURE); 2307 } 2308 2309 if (is_indent == TRUE) { 2310 (void) printf("\t\t\t\t\t\t\t"); 2311 } else { 2312 is_indent = TRUE; 2313 } 2314 2315 if (hsp_attr.type == HSP_TYPE_LOCAL) { 2316 (void) snprintf(hsp, sizeof (hsp), 2317 "c%ut%llud%llu", 2318 ctl_attr.controller_id, 2319 hsp_attr.tag.idl.target_id, 2320 hsp_attr.tag.idl.lun); 2321 (void) printf("%s\n", hsp); 2322 } else if (hsp_attr.type == HSP_TYPE_GLOBAL) { 2323 (void) printf(gettext("Global\n")); 2324 } else { 2325 return (FAILURE); 2326 } 2327 2328 hsp_handle = raidcfg_list_next(hsp_handle); 2329 } 2330 } 2331 return (SUCCESS); 2332 } 2333 2334 2335 /* 2336 * print_indent(indent) 2337 * This function prints specified number of tab characters. It's used to 2338 * format layout. 2339 */ 2340 static void 2341 print_indent(uint8_t indent) 2342 { 2343 uint32_t i; 2344 for (i = 0; i < indent; i++) { 2345 (void) fprintf(stdout, "\t"); 2346 } 2347 } 2348 2349 /* 2350 * get_disk_handle_cidl(ctl_tag, disks_argp, comps_num, handlespp) 2351 * This function parses the string of disk argument, and gets the disks tag 2352 * and separators from the string. Then it translates the tag to handle, and 2353 * stores handles and separators to new buffer pointed by parameter handlespp. 2354 * The format of disk_arg must be C:ID:L, for example, it is 0.1.0. The first 2355 * "0" is channel number, and the second "1" is target number, and the third 2356 * "0" is LUN number. The disk tags are separated by comma and parenthesis. 2357 * Function returns SUCCESS or FAILURE. 2358 */ 2359 static int 2360 get_disk_handle_cidl(uint32_t ctl_tag, char *disks_argp, int *comps_nump, 2361 raid_obj_handle_t **handlespp) 2362 { 2363 int len = 0; 2364 int i = 0, j = 0; 2365 char *p, *t; 2366 char *delimit = " "; 2367 char *disks_str; 2368 disk_tag_t disk_tag; 2369 2370 if (disks_argp == NULL || comps_nump == NULL) { 2371 return (FAILURE); 2372 } 2373 2374 p = disks_argp; 2375 len = strlen(disks_argp); 2376 2377 if ((disks_str = (char *)malloc(3 * len + 4)) == NULL) { 2378 return (FAILURE); 2379 } 2380 2381 /* Insert whitespace between disk tags, '(' , and ')' */ 2382 disks_str[j ++] = '('; 2383 disks_str[j ++] = ' '; 2384 2385 while (p[i] != '\0') { 2386 if (p[i] == ')' || p[i] == '(') { 2387 disks_str[j ++] = ' '; 2388 disks_str[j ++] = p[i]; 2389 disks_str[j ++] = ' '; 2390 } else 2391 disks_str[j ++] = p[i]; 2392 i ++; 2393 } 2394 disks_str[j ++] = ' '; 2395 disks_str[j ++] = ')'; 2396 disks_str[j] = '\0'; 2397 2398 len = strlen(disks_str) + 1; 2399 2400 if ((t = (char *)malloc(len)) == NULL) { 2401 return (FAILURE); 2402 } 2403 (void) memcpy(t, disks_str, len); 2404 p = strtok(t, delimit); 2405 while (p != NULL) { 2406 (*comps_nump)++; 2407 p = strtok(NULL, delimit); 2408 } 2409 free(t); 2410 2411 *handlespp = calloc(*comps_nump, sizeof (raid_obj_handle_t)); 2412 if (*handlespp == NULL) { 2413 return (FAILURE); 2414 } 2415 2416 for (i = 0; i < *comps_nump; i++) 2417 (*handlespp)[i] = INIT_HANDLE_VALUE; 2418 2419 i = 0; 2420 p = strtok(disks_str, delimit); 2421 while (p != NULL) { 2422 if (*p == '(') { 2423 (*handlespp)[i] = OBJ_SEPARATOR_BEGIN; 2424 } else if (*p == ')') { 2425 (*handlespp)[i] = OBJ_SEPARATOR_END; 2426 } else { 2427 if (get_disk_tag_cidl(p, &disk_tag) != SUCCESS) { 2428 free(*handlespp); 2429 free(disks_str); 2430 return (INVALID_ARG); 2431 } 2432 (*handlespp)[i] = 2433 raidcfg_get_disk(raidcfg_get_controller(ctl_tag), 2434 disk_tag); 2435 if ((*handlespp)[i] <= 0) { 2436 (void) fprintf(stderr, "%s\n", 2437 raidcfg_errstr((*handlespp)[i])); 2438 free(*handlespp); 2439 free(disks_str); 2440 return (FAILURE); 2441 } 2442 } 2443 p = strtok(NULL, delimit); 2444 i++; 2445 } 2446 2447 free(disks_str); 2448 return (SUCCESS); 2449 } 2450 2451 /* 2452 * get_disk_handle_ctd(disks_num, disks_argpp, ctl_tagp, disks_handlep) 2453 * This function parses string of single disk with "ctd" format, for example, 2454 * c0t0d0, and translates it to controller tag and disk tag. 2455 * Then it calls lib api and get disk handle. The controller tag and disk 2456 * handle are both returned by out parameters. 2457 * The return value is SUCCESS or FAILURE. 2458 */ 2459 static int 2460 get_disk_handle_ctd(int disks_num, char **disks_argpp, uint32_t *ctl_tagp, 2461 raid_obj_handle_t *disks_handlep) 2462 { 2463 raid_obj_handle_t ctl_handle; 2464 disk_tag_t disk_tag; 2465 uint32_t ctl_id; 2466 int i; 2467 int ret; 2468 2469 if (disks_handlep == NULL) { 2470 return (FAILURE); 2471 } 2472 2473 for (i = 0; i < disks_num; i++) { 2474 if (get_disk_tag_ctd(disks_argpp[i], &disk_tag, &ctl_id) != 2475 SUCCESS) { 2476 return (INVALID_ARG); 2477 } 2478 2479 *ctl_tagp = ctl_id; 2480 2481 if (i == 0) { 2482 ctl_handle = raidcfg_get_controller(*ctl_tagp); 2483 if (ctl_handle <= 0) { 2484 (void) fprintf(stderr, "%s\n", 2485 raidcfg_errstr(ctl_handle)); 2486 return (FAILURE); 2487 } 2488 ret = raidcfg_open_controller(ctl_handle, NULL); 2489 if (ret < 0) { 2490 (void) fprintf(stderr, "%s\n", 2491 raidcfg_errstr(ret)); 2492 return (FAILURE); 2493 } 2494 } 2495 2496 if ((disks_handlep[i] = 2497 raidcfg_get_disk(ctl_handle, disk_tag)) < 0) { 2498 (void) fprintf(stderr, "%s\n", 2499 raidcfg_errstr(disks_handlep[i])); 2500 (void) raidcfg_close_controller(ctl_handle, NULL); 2501 return (FAILURE); 2502 } 2503 } 2504 2505 return (SUCCESS); 2506 } 2507 2508 /* 2509 * get_ctl_tag(argp) 2510 * This function translates controller string to tag. The return value is 2511 * SUCCESS if the string has legal format and is parsed successfully, 2512 * or FAILURE if it fails. 2513 */ 2514 static int 2515 get_ctl_tag(char *argp, uint32_t *ctl_tagp) 2516 { 2517 if (argp == NULL || is_fully_numeric(argp) == FALSE || 2518 ctl_tagp == NULL) { 2519 return (FAILURE); 2520 } 2521 *ctl_tagp = (atoi(argp)); 2522 return (SUCCESS); 2523 } 2524 2525 /* 2526 * get_array_tag(argp, ctl_tagp, array_tagp) 2527 * This function parses array string to get array tag and controller tag. 2528 * The return value is SUCCESS if the string has legal format, or 2529 * FAILURE if it fails. 2530 */ 2531 static int 2532 get_array_tag(char *argp, uint32_t *ctl_tagp, array_tag_t *array_tagp) 2533 { 2534 char *t = NULL; 2535 char *cp = NULL; 2536 char *tp = NULL; 2537 char *dp = NULL; 2538 2539 uint32_t value_c = MAX32BIT; 2540 uint32_t value_t = MAX32BIT; 2541 uint32_t value_d = MAX32BIT; 2542 2543 int len = 0; 2544 2545 if (argp == NULL || (len = strlen(argp)) == 0 || 2546 array_tagp == NULL) { 2547 return (FAILURE); 2548 } 2549 2550 t = (char *)malloc(len + 1); 2551 if (t == NULL) { 2552 return (FAILURE); 2553 } 2554 2555 (void) memcpy(t, argp, len + 1); 2556 2557 /* Now remmber to release t memory if exception occurs */ 2558 if (((dp = strchr(t, 'd')) == NULL) || 2559 ((tp = strchr(t, 't')) == NULL) || 2560 ((cp = strchr(t, 'c')) == NULL)) { 2561 free(t); 2562 return (FAILURE); 2563 } 2564 cp = t; 2565 2566 *dp = '\0'; 2567 dp++; 2568 *tp = '\0'; 2569 tp++; 2570 cp++; 2571 2572 if (is_fully_numeric(dp) == FALSE || 2573 is_fully_numeric(tp) == FALSE || 2574 is_fully_numeric(cp) == FALSE) { 2575 free(t); 2576 return (FAILURE); 2577 } 2578 2579 value_c = atoi(cp); 2580 value_t = atoi(tp); 2581 value_d = atoi(dp); 2582 2583 array_tagp->idl.target_id = value_t; 2584 array_tagp->idl.lun = value_d; 2585 2586 if (ctl_tagp != NULL) { 2587 *ctl_tagp = value_c; 2588 } 2589 2590 free(t); 2591 return (SUCCESS); 2592 } 2593 2594 /* 2595 * get_disk_tag_ctd(argp, disk_tagp) 2596 * This function parses disk string of ctd format, and translates it to 2597 * disk tag and controller tag. The tags is returned by out parameters. 2598 * The return value is SUCCESS if the string has legal format, or FAILURE 2599 * if it fails. 2600 */ 2601 static int 2602 get_disk_tag_ctd(char *argp, disk_tag_t *disk_tagp, uint32_t *ctl_tag) 2603 { 2604 char *t = NULL; 2605 char *cp = NULL; 2606 char *tp = NULL; 2607 char *dp = NULL; 2608 2609 uint32_t value_c = MAX32BIT; 2610 uint32_t value_t = MAX32BIT; 2611 uint32_t value_d = MAX32BIT; 2612 2613 int len = 0; 2614 2615 if (argp == NULL || (len = strlen(argp)) == 0 || 2616 disk_tagp == NULL) { 2617 return (FAILURE); 2618 } 2619 2620 t = (char *)malloc(len + 1); 2621 if (t == NULL) { 2622 return (FAILURE); 2623 } 2624 2625 (void) memcpy(t, argp, len + 1); 2626 2627 /* Now remmber to release t memory if exception occurs */ 2628 if (((dp = strchr(t, 'd')) == NULL) || 2629 ((tp = strchr(t, 't')) == NULL) || 2630 ((cp = strchr(t, 'c')) == NULL)) { 2631 free(t); 2632 return (FAILURE); 2633 } 2634 cp = t; 2635 2636 *dp = '\0'; 2637 dp++; 2638 *tp = '\0'; 2639 tp++; 2640 cp++; 2641 2642 if (is_fully_numeric(dp) == FALSE || 2643 is_fully_numeric(tp) == FALSE || 2644 is_fully_numeric(cp) == FALSE) { 2645 free(t); 2646 return (FAILURE); 2647 } 2648 2649 value_c = atoi(cp); 2650 value_t = atoi(tp); 2651 value_d = atoi(dp); 2652 2653 disk_tagp->cidl.bus = 0; 2654 disk_tagp->cidl.target_id = value_t; 2655 disk_tagp->cidl.lun = value_d; 2656 *ctl_tag = value_c; 2657 2658 free(t); 2659 return (SUCCESS); 2660 } 2661 2662 /* 2663 * get_disk_tag_cidl(argp, disk_tagp) 2664 * This function parses disk string of cidl format and translates it to tag. 2665 * The return value is disk tag if the string has legal format, or FAILURE 2666 * if it fails. 2667 */ 2668 static int 2669 get_disk_tag_cidl(char *argp, disk_tag_t *disk_tagp) 2670 { 2671 int len = 0; 2672 char *p = NULL; 2673 char *t = NULL; 2674 char *dot1p = NULL; 2675 char *dot2p = NULL; 2676 2677 if (argp == NULL || (len = strlen(argp)) == 0) { 2678 return (FAILURE); 2679 } 2680 2681 if (disk_tagp == NULL) { 2682 return (FAILURE); 2683 } 2684 2685 t = (char *)malloc(len + 1); 2686 if (t == NULL) { 2687 return (FAILURE); 2688 } 2689 2690 (void) memcpy(t, argp, len + 1); 2691 p = t; 2692 2693 dot2p = strrchr(p, '.'); 2694 if (dot2p == NULL) { 2695 free(t); 2696 return (FAILURE); 2697 } 2698 *dot2p = '\0'; 2699 dot2p++; 2700 2701 dot1p = strrchr(p, '.'); 2702 if (dot1p == NULL) { 2703 free(t); 2704 return (FAILURE); 2705 } 2706 *dot1p = '\0'; 2707 dot1p++; 2708 2709 /* Assert only 2 dots in this string */ 2710 if (strrchr(p, '.') != NULL) { 2711 free(t); 2712 return (FAILURE); 2713 } 2714 2715 while (*p == ' ') 2716 p++; 2717 2718 if (is_fully_numeric(p) == FALSE || 2719 is_fully_numeric(dot1p) == FALSE || 2720 is_fully_numeric(dot2p) == FALSE) { 2721 free(t); 2722 return (FAILURE); 2723 } 2724 2725 disk_tagp->cidl.bus = atoi(p); 2726 disk_tagp->cidl.target_id = atoi(dot1p); 2727 disk_tagp->cidl.lun = atoi(dot2p); 2728 2729 free(t); 2730 return (SUCCESS); 2731 } 2732 2733 /* 2734 * calc_size(sizep, valp) 2735 * This function calculates the value represented by string sizep. 2736 * The string sizep can be decomposed into three parts: an initial, 2737 * possibly empty, sequence of white-space characters; a subject digital 2738 * sequence interpreted as an integer with unit k/K/m/M/g/G/t/T; and a 2739 * final string of one or more unrecognized characters or white-sapce 2740 * characters, including the terminating null. If unrecognized character 2741 * exists or overflow happens, the conversion must fail and return 2742 * INVALID_ARG. If the conversion is performed successfully, result will 2743 * be saved into valp and function returns SUCCESS. It returns FAILURE 2744 * when memory allocation fails. 2745 */ 2746 static int 2747 calc_size(char *sizep, uint64_t *valp) 2748 { 2749 int len; 2750 uint64_t size; 2751 uint64_t unit; 2752 char *t = NULL; 2753 char *tailp = NULL; 2754 2755 if (sizep == NULL || valp == NULL) { 2756 return (INVALID_ARG); 2757 } 2758 2759 if (is_fully_numeric(sizep) == TRUE) { 2760 *valp = atoi(sizep); 2761 return (SUCCESS); 2762 } 2763 2764 len = strlen(sizep); 2765 if (len == 0) { 2766 return (INVALID_ARG); 2767 } 2768 2769 t = (char *)malloc(len + 1); 2770 if (t == NULL) { 2771 return (FAILURE); 2772 } 2773 2774 (void) memcpy(t, sizep, len + 1); 2775 2776 switch (*(t + len - 1)) { 2777 case 'k': 2778 case 'K': 2779 unit = 1024ull; 2780 errno = 0; 2781 size = strtoll(t, &tailp, 0); 2782 break; 2783 case 'm': 2784 case 'M': 2785 unit = 1024ull * 1024ull; 2786 errno = 0; 2787 size = strtoll(t, &tailp, 0); 2788 break; 2789 case 'g': 2790 case 'G': 2791 unit = 1024ull * 1024ull * 1024ull; 2792 errno = 0; 2793 size = strtoll(t, &tailp, 0); 2794 break; 2795 case 't': 2796 case 'T': 2797 unit = 1024ull * 1024ull * 1024ull * 1024ull; 2798 errno = 0; 2799 size = strtoll(t, &tailp, 0); 2800 break; 2801 default: 2802 /* The unit must be kilobyte at least. */ 2803 free(t); 2804 return (INVALID_ARG); 2805 } 2806 2807 *(t + len - 1) = '\0'; 2808 if (is_fully_numeric(t) != TRUE) { 2809 free(t); 2810 return (INVALID_ARG); 2811 } 2812 2813 errno = 0; 2814 size = strtoll(t, &tailp, 0); 2815 2816 /* Check overflow condition */ 2817 if (errno == ERANGE || (size > (MAX64BIT / unit))) { 2818 free(t); 2819 return (INVALID_ARG); 2820 } 2821 2822 *valp = size * unit; 2823 free(t); 2824 return (SUCCESS); 2825 } 2826 2827 /* 2828 * is_fully_numeric(str) 2829 * This function checks if the string are legal numeric string. The beginning 2830 * or ending characters can be white spaces. 2831 * Return value is TRUE if the string are legal numeric string, or FALSE 2832 * otherwise. 2833 */ 2834 static int 2835 is_fully_numeric(char *strp) 2836 { 2837 uint32_t len; 2838 uint32_t i; 2839 2840 if (strp == NULL) { 2841 return (FALSE); 2842 } 2843 2844 len = strlen(strp); 2845 if (len == 0) { 2846 return (FALSE); 2847 } 2848 2849 /* Skip whitespace characters */ 2850 for (i = 0; i < len; i++) { 2851 if (strp[i] != ' ') { 2852 break; 2853 } 2854 } 2855 2856 /* if strp points all space characters */ 2857 if (i == len) { 2858 return (FALSE); 2859 } 2860 2861 /* Check the digitals in string */ 2862 for (; i < len; i++) { 2863 if (!isdigit(strp[i])) { 2864 break; 2865 } 2866 } 2867 2868 /* Check the ending string */ 2869 for (; i < len; i++) { 2870 if (strp[i] != ' ') { 2871 return (FALSE); 2872 } 2873 } 2874 2875 return (TRUE); 2876 } 2877 2878 static int 2879 yes(void) 2880 { 2881 int i, b; 2882 char ans[SCHAR_MAX + 1]; 2883 2884 for (i = 0; ; i++) { 2885 b = getchar(); 2886 if (b == '\n' || b == '\0' || b == EOF) { 2887 ans[i] = 0; 2888 break; 2889 } 2890 if (i < SCHAR_MAX) { 2891 ans[i] = b; 2892 } 2893 } 2894 if (i >= SCHAR_MAX) { 2895 i = SCHAR_MAX; 2896 ans[SCHAR_MAX] = 0; 2897 } 2898 2899 return (rpmatch(ans)); 2900 } 2901 2902 /* 2903 * Function: int rpmatch(char *) 2904 * 2905 * Description: 2906 * 2907 * Internationalized get yes / no answer. 2908 * 2909 * Inputs: 2910 * s -> Pointer to answer to compare against. 2911 * 2912 * Returns: 2913 * TRUE -> Answer was affirmative 2914 * FALSE -> Answer was negative 2915 */ 2916 2917 static int 2918 rpmatch(char *s) 2919 { 2920 int status; 2921 2922 /* match yesexpr */ 2923 status = regexec(&re, s, (size_t)0, NULL, 0); 2924 if (status != 0) { 2925 return (FALSE); 2926 } 2927 return (TRUE); 2928 } 2929 2930 static int 2931 size_to_string(uint64_t size, char *string, int len) 2932 { 2933 int i = 0; 2934 uint32_t remainder; 2935 char unit[][2] = {" ", "K", "M", "G", "T"}; 2936 2937 if (string == NULL) { 2938 return (FAILURE); 2939 } 2940 while (size > 1023) { 2941 remainder = size % 1024; 2942 size /= 1024; 2943 i++; 2944 } 2945 2946 if (i > 4) { 2947 return (FAILURE); 2948 } 2949 2950 remainder /= 103; 2951 if (remainder == 0) { 2952 (void) snprintf(string, len, "%llu", size); 2953 } else { 2954 (void) snprintf(string, len, "%llu.%1u", size, 2955 remainder); 2956 } 2957 2958 /* make sure there is one byte for unit */ 2959 if ((strlen(string) + 1) >= len) { 2960 return (FAILURE); 2961 } 2962 (void) strlcat(string, unit[i], len); 2963 2964 return (SUCCESS); 2965 } 2966 2967 /* 2968 * Only one raidctl is running at one time. 2969 */ 2970 static int 2971 enter_raidctl_lock(int *fd) 2972 { 2973 int fd0 = -1; 2974 struct flock lock; 2975 2976 fd0 = open(RAIDCTL_LOCKF, O_CREAT|O_WRONLY, 0600); 2977 if (fd0 < 0) { 2978 if (errno == EACCES) { 2979 (void) fprintf(stderr, 2980 gettext("raidctl:must be root to run raidctl" 2981 ": %s\n"), strerror(errno)); 2982 } else { 2983 (void) fprintf(stderr, 2984 gettext("raidctl:failed to open lockfile" 2985 " '"RAIDCTL_LOCKF"': %s\n"), strerror(errno)); 2986 } 2987 return (FAILURE); 2988 } 2989 2990 *fd = fd0; 2991 lock.l_type = F_WRLCK; 2992 lock.l_whence = SEEK_SET; 2993 lock.l_start = 0; 2994 lock.l_len = 0; 2995 2996 if ((fcntl(fd0, F_SETLK, &lock) == -1) && 2997 (errno == EAGAIN || errno == EDEADLK)) { 2998 if (fcntl(fd0, F_GETLK, &lock) == -1) { 2999 (void) fprintf(stderr, 3000 gettext("raidctl:enter_filelock error\n")); 3001 return (FAILURE); 3002 } 3003 (void) fprintf(stderr, gettext("raidctl:" 3004 "enter_filelock:filelock is owned " 3005 "by 'process %d'\n"), lock.l_pid); 3006 return (FAILURE); 3007 } 3008 3009 return (SUCCESS); 3010 } 3011 3012 static void 3013 exit_raidctl_lock(int fd) 3014 { 3015 struct flock lock; 3016 3017 lock.l_type = F_UNLCK; 3018 lock.l_whence = SEEK_SET; 3019 lock.l_start = 0; 3020 lock.l_len = 0; 3021 if (fcntl(fd, F_SETLK, &lock) == -1) { 3022 (void) fprintf(stderr, gettext("raidctl: failed to" 3023 " exit_filelock: %s\n"), 3024 strerror(errno)); 3025 } 3026 (void) close(fd); 3027 } 3028