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 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 * Copyright 2018 OmniOS Community Edition (OmniOSce) Association. 26 * Copyright (c) 2018, Joyent, Inc. 27 */ 28 29 #include <sys/param.h> 30 #include <sys/stat.h> 31 #include <errno.h> 32 #include <string.h> 33 #include <dirent.h> 34 #include "cfga_sata.h" 35 36 /* 37 * This file contains the entry points to the plug-in as defined in the 38 * config_admin(3X) man page. 39 */ 40 41 /* 42 * Set the version number for the cfgadm library's use. 43 */ 44 int cfga_version = CFGA_HSL_V2; 45 46 enum { 47 HELP_HEADER = 1, 48 HELP_CONFIG, 49 HELP_RESET_PORT, 50 HELP_RESET_DEVICE, 51 HELP_RESET_ALL, 52 HELP_PORT_DEACTIVATE, 53 HELP_PORT_ACTIVATE, 54 HELP_PORT_SELF_TEST, 55 HELP_CNTRL_SELF_TEST, 56 HELP_UNKNOWN 57 }; 58 59 /* SATA specific help messages */ 60 static char *sata_help[] = { 61 NULL, 62 "SATA specific commands:\n", 63 " cfgadm -c [configure|unconfigure|disconnect|connect] ap_id " 64 "[ap_id...]\n", 65 " cfgadm -x sata_reset_port ap_id [ap_id...]\n", 66 " cfgadm -x sata_reset_device ap_id [ap_id...]\n", 67 " cfgadm -x sata_reset_all ap_id\n", 68 " cfgadm -x sata_port_deactivate ap_id [ap_id...]\n", 69 " cfgadm -x sata_port_activate ap_id [ap_id...]\n", 70 " cfgadm -x sata_port_self_test ap_id [ap_id...]\n", 71 " cfgadm -t ap_id\n", 72 "\tunknown command or option:\n", 73 NULL 74 }; /* End help messages */ 75 76 77 /* 78 * Messages. 79 */ 80 static msgcvt_t sata_msgs[] = { 81 /* CFGA_SATA_OK */ 82 { CVT, CFGA_OK, "" }, 83 84 /* CFGA_SATA_NACK */ 85 { CVT, CFGA_NACK, "" }, 86 87 /* CFGA_SATA_DEVICE_UNCONFIGURED */ 88 { CVT, CFGA_OK, "Device unconfigured prior to disconnect" }, 89 90 /* CFGA_SATA_UNKNOWN / CFGA_LIB_ERROR -> "Library error" */ 91 { CVT, CFGA_LIB_ERROR, "Unknown message; internal error" }, 92 93 /* CFGA_SATA_INTERNAL_ERROR / CFGA_LIB_ERROR -> "Library error" */ 94 { CVT, CFGA_LIB_ERROR, "Internal error" }, 95 96 /* CFGA_SATA_DATA_ERROR / CFGA_DATA_ERROR -> "Data error" */ 97 { CVT, CFGA_DATA_ERROR, "cfgadm data error" }, 98 99 /* CFGA_SATA_OPTIONS / CFGA_ERROR -> "Hardware specific failure" */ 100 { CVT, CFGA_ERROR, "Hardware specific option not supported" }, 101 102 /* CFGA_SATA_HWOPNOTSUPP / CFGA_ERROR -> "Hardware specific failure" */ 103 { CVT, CFGA_ERROR, "Hardware specific operation not supported" }, 104 105 /* 106 * CFGA_SATA_DYNAMIC_AP / 107 * CFGA_LIB_ERROR -> "Configuration operation invalid" 108 */ 109 { CVT, CFGA_INVAL, "Cannot identify attached device" }, 110 111 /* CFGA_SATA_AP / CFGA_APID_NOEXIST -> "Attachment point not found" */ 112 { CVT, CFGA_APID_NOEXIST, "" }, 113 114 /* CFGA_SATA_PORT / CFGA_LIB_ERROR -> "Library error" */ 115 { CVT, CFGA_LIB_ERROR, "Cannot determine sata port number for " }, 116 117 /* CFGA_SATA_DEVCTL / CFGA_LIB_ERROR -> "Library error" */ 118 { CVT, CFGA_LIB_ERROR, "Internal error: " 119 "Cannot allocate devctl handle " }, 120 121 /* 122 * CFGA_SATA_DEV_CONFIGURE / 123 * CFGA_ERROR -> "Hardware specific failure" 124 */ 125 { CVT, CFGA_ERROR, "Failed to config device at " }, 126 127 /* 128 * CFGA_SATA_DEV_UNCONFIGURE / 129 * CFGA_ERROR -> "Hardware specific failure" 130 */ 131 { CVT, CFGA_ERROR, "Failed to unconfig device at " }, 132 133 /* 134 * CFGA_SATA_DISCONNECTED 135 * CFGA_INVAL -> "Configuration operation invalid" 136 */ 137 { CVT, CFGA_INVAL, "Port already disconnected " }, 138 139 /* 140 * CFGA_SATA_NOT_CONNECTED 141 * CFGA_INVAL -> "Configuration operation invalid" 142 */ 143 { CVT, CFGA_INVAL, "No device connected to " }, 144 145 /* 146 * CFGA_SATA_NOT_CONFIGURED / 147 * CFGA_INVAL -> "Configuration operation invalid" 148 */ 149 { CVT, CFGA_INVAL, "No device configured at " }, 150 151 /* 152 * CFGA_SATA_ALREADY_CONNECTED / 153 * CFGA_INVAL -> "Configuration operation invalid" 154 */ 155 { CVT, CFGA_INVAL, "Device already connected to " }, 156 157 /* 158 * CFGA_SATA_ALREADY_CONFIGURED / 159 * CFGA_INVAL -> "Configuration operation invalid" 160 */ 161 { CVT, CFGA_INVAL, "Device already configured at " }, 162 163 /* 164 * CFGA_SATA_INVALID_DEVNAME / 165 * CFGA_INVAL -> "Configuration operation invalid" 166 */ 167 { CVT, CFGA_INVAL, "Cannot specify device name" }, 168 169 /* CFGA_SATA_OPEN / CFGA_LIB_ERROR -> "Library error" */ 170 { CVT, CFGA_LIB_ERROR, "Cannot open " }, 171 172 /* CFGA_SATA_IOCTL / CFGA_ERROR -> "Hardware specific failure" */ 173 { CVT, CFGA_ERROR, "Driver ioctl failed " }, 174 175 /* 176 * CFGA_SATA_BUSY / 177 * CFGA_SYSTEM_BUSY -> "System is busy, try again" 178 */ 179 { CVT, CFGA_SYSTEM_BUSY, "" }, 180 181 /* CFGA_SATA_ALLOC_FAIL / CFGA_LIB_ERROR -> "Library error" */ 182 { CVT, CFGA_LIB_ERROR, "Memory allocation failure" }, 183 184 /* 185 * CFGA_SATA_OPNOTSUPP / 186 * CFGA_OPNOTSUPP -> "Configuration operation not supported" 187 */ 188 { CVT, CFGA_OPNOTSUPP, "Operation not supported" }, 189 190 /* CFGA_SATA_DEVLINK / CFGA_LIB_ERROR -> "Library error" */ 191 { CVT, CFGA_LIB_ERROR, "Could not find /dev/cfg link for " }, 192 193 /* CFGA_SATA_STATE / CFGA_LIB_ERROR -> "Library error" */ 194 { CVT, CFGA_LIB_ERROR, "Internal error: Unrecognized ap state" }, 195 196 /* CFGA_SATA_PRIV / CFGA_PRIV -> "Insufficient privileges" */ 197 { CVT, CFGA_PRIV, "" }, 198 199 /* CFGA_SATA_NVLIST / CFGA_ERROR -> "Hardware specific failure" */ 200 { CVT, CFGA_ERROR, "Internal error (nvlist)" }, 201 202 /* CFGA_SATA_ZEROLEN / CFGA_ERROR -> "Hardware specific failure" */ 203 { CVT, CFGA_ERROR, "Internal error (zerolength string)" }, 204 205 /* CFGA_SATA_RCM_HANDLE / CFGA_ERROR -> "Hardware specific failure" */ 206 { CVT, CFGA_ERROR, "cannot get RCM handle"}, 207 208 /* 209 * CFGA_SATA_RCM_ONLINE / 210 * CFGA_SYSTEM_BUSY -> "System is busy, try again" 211 */ 212 { CVT, CFGA_SYSTEM_BUSY, "failed to online: "}, 213 214 /* 215 * CFGA_SATA_RCM_OFFLINE / 216 * CFGA_SYSTEM_BUSY -> "System is busy, try again" 217 */ 218 { CVT, CFGA_SYSTEM_BUSY, "failed to offline: "}, 219 220 /* CFGA_SATA_RCM_INFO / CFGA_ERROR -> "Hardware specific failure" */ 221 { CVT, CFGA_ERROR, "failed to query: "} 222 223 }; /* End error messages */ 224 225 static cfga_sata_ret_t 226 verify_params(const char *ap_id, const char *options, char **errstring); 227 228 229 static cfga_sata_ret_t 230 setup_for_devctl_cmd(const char *ap_id, devctl_hdl_t *devctl_hdl, 231 nvlist_t **user_nvlistp, uint_t oflag); 232 233 static cfga_sata_ret_t 234 port_state(devctl_hdl_t hdl, nvlist_t *list, 235 ap_rstate_t *rstate, ap_ostate_t *ostate); 236 237 static cfga_sata_ret_t 238 do_control_ioctl(const char *ap_id, sata_cfga_apctl_t subcommand, uint_t arg, 239 void **descrp, size_t *sizep); 240 241 static void 242 cleanup_after_devctl_cmd(devctl_hdl_t devctl_hdl, nvlist_t *user_nvlist); 243 244 static char * 245 sata_get_devicepath(const char *ap_id); 246 247 static int 248 sata_confirm(struct cfga_confirm *confp, char *msg); 249 250 static cfga_sata_ret_t 251 get_port_num(const char *ap_id, uint32_t *port); 252 253 /* Utilities */ 254 255 static cfga_sata_ret_t 256 physpath_to_devlink(const char *basedir, const char *node_path, 257 char **logpp, int *l_errnop) 258 { 259 char *linkpath; 260 char *buf; 261 char *real_path; 262 DIR *dp; 263 struct dirent *dep, *newdep; 264 int deplen; 265 boolean_t found = B_FALSE; 266 int err = 0; 267 struct stat sb; 268 char *p; 269 cfga_sata_ret_t rv = CFGA_SATA_INTERNAL_ERROR; 270 271 /* 272 * Using libdevinfo for this is overkill and kills performance 273 * when multiple consumers of libcfgadm are executing 274 * concurrently. 275 */ 276 if ((dp = opendir(basedir)) == NULL) { 277 *l_errnop = errno; 278 return (CFGA_SATA_INTERNAL_ERROR); 279 } 280 281 linkpath = malloc(PATH_MAX); 282 buf = malloc(PATH_MAX); 283 real_path = malloc(PATH_MAX); 284 285 deplen = pathconf(basedir, _PC_NAME_MAX); 286 deplen = (deplen <= 0 ? MAXNAMELEN : deplen) + 287 sizeof (struct dirent); 288 dep = (struct dirent *)malloc(deplen); 289 290 if (dep == NULL || linkpath == NULL || buf == NULL || 291 real_path == NULL) { 292 *l_errnop = ENOMEM; 293 rv = CFGA_SATA_ALLOC_FAIL; 294 goto pp_cleanup; 295 } 296 297 *logpp = NULL; 298 299 while (!found && (err = readdir_r(dp, dep, &newdep)) == 0 && 300 newdep != NULL) { 301 302 assert(newdep == dep); 303 304 if (strcmp(dep->d_name, ".") == 0 || 305 strcmp(dep->d_name, "..") == 0) 306 continue; 307 308 (void) snprintf(linkpath, MAXPATHLEN, 309 "%s/%s", basedir, dep->d_name); 310 311 if (lstat(linkpath, &sb) < 0) 312 continue; 313 314 if (S_ISDIR(sb.st_mode)) { 315 316 if ((rv = physpath_to_devlink(linkpath, node_path, 317 logpp, l_errnop)) != CFGA_SATA_OK) { 318 319 goto pp_cleanup; 320 } 321 322 if (*logpp != NULL) 323 found = B_TRUE; 324 325 } else if (S_ISLNK(sb.st_mode)) { 326 327 bzero(buf, PATH_MAX); 328 if (readlink(linkpath, buf, PATH_MAX) < 0) 329 continue; 330 331 332 /* 333 * realpath() is too darn slow, so fake 334 * it, by using what we know about /dev 335 * links: they are always of the form: 336 * <"../">+/devices/<path> 337 */ 338 p = buf; 339 while (strncmp(p, "../", 3) == 0) 340 p += 3; 341 342 if (p != buf) 343 p--; /* back up to get a slash */ 344 345 assert (*p == '/'); 346 347 if (strcmp(p, node_path) == 0) { 348 *logpp = strdup(linkpath); 349 if (*logpp == NULL) { 350 351 rv = CFGA_SATA_ALLOC_FAIL; 352 goto pp_cleanup; 353 } 354 355 found = B_TRUE; 356 } 357 } 358 } 359 360 free(linkpath); 361 free(buf); 362 free(real_path); 363 free(dep); 364 (void) closedir(dp); 365 366 if (err != 0) { 367 *l_errnop = err; 368 return (CFGA_SATA_INTERNAL_ERROR); 369 } 370 371 return (CFGA_SATA_OK); 372 373 pp_cleanup: 374 375 if (dp) 376 (void) closedir(dp); 377 if (dep) 378 free(dep); 379 if (linkpath) 380 free(linkpath); 381 if (buf) 382 free(buf); 383 if (real_path) 384 free(real_path); 385 if (*logpp) { 386 free(*logpp); 387 *logpp = NULL; 388 } 389 return (rv); 390 } 391 392 393 /* 394 * Given the index into a table (msgcvt_t) of messages, get the message 395 * string, converting it to the proper locale if necessary. 396 * NOTE: Indexes are defined in cfga_sata.h 397 */ 398 static const char * 399 get_msg(uint_t msg_index, msgcvt_t *msg_tbl, uint_t tbl_size) 400 { 401 if (msg_index >= tbl_size) { 402 msg_index = CFGA_SATA_UNKNOWN; 403 } 404 405 return ((msg_tbl[msg_index].intl) ? 406 dgettext(TEXT_DOMAIN, msg_tbl[msg_index].msgstr) : 407 msg_tbl[msg_index].msgstr); 408 } 409 410 /* 411 * Allocates and creates a message string (in *ret_str), 412 * by concatenating all the (char *) args together, in order. 413 * Last arg MUST be NULL. 414 */ 415 static void 416 set_msg(char **ret_str, ...) 417 { 418 char *str; 419 size_t total_len; 420 va_list valist; 421 422 va_start(valist, ret_str); 423 424 total_len = (*ret_str == NULL) ? 0 : strlen(*ret_str); 425 426 while ((str = va_arg(valist, char *)) != NULL) { 427 size_t len = strlen(str); 428 char *old_str = *ret_str; 429 430 *ret_str = (char *)realloc(*ret_str, total_len + len + 1); 431 if (*ret_str == NULL) { 432 /* We're screwed */ 433 free(old_str); 434 va_end(valist); 435 return; 436 } 437 438 (void) strcpy(*ret_str + total_len, str); 439 total_len += len; 440 } 441 442 va_end(valist); 443 } 444 445 /* 446 * Error message handling. 447 * For the rv passed in, looks up the corresponding error message string(s), 448 * internationalized if necessary, and concatenates it into a new 449 * memory buffer, and points *errstring to it. 450 * Note not all rvs will result in an error message return, as not all 451 * error conditions warrant a SATA-specific error message - for those 452 * conditions the cfgadm generic messages are sufficient. 453 * 454 * Some messages may display ap_id or errno, which is why they are passed 455 * in. 456 */ 457 458 cfga_err_t 459 sata_err_msg( 460 char **errstring, 461 cfga_sata_ret_t rv, 462 const char *ap_id, 463 int l_errno) 464 { 465 if (errstring == NULL) { 466 return (sata_msgs[rv].cfga_err); 467 } 468 469 /* 470 * Generate the appropriate SATA-specific error message(s) (if any). 471 */ 472 switch (rv) { 473 case CFGA_SATA_OK: 474 case CFGA_NACK: 475 /* Special case - do nothing. */ 476 break; 477 478 case CFGA_SATA_UNKNOWN: 479 case CFGA_SATA_DYNAMIC_AP: 480 case CFGA_SATA_INTERNAL_ERROR: 481 case CFGA_SATA_OPTIONS: 482 case CFGA_SATA_ALLOC_FAIL: 483 case CFGA_SATA_STATE: 484 case CFGA_SATA_PRIV: 485 case CFGA_SATA_OPNOTSUPP: 486 case CFGA_SATA_DATA_ERROR: 487 /* These messages require no additional strings passed. */ 488 set_msg(errstring, ERR_STR(rv), NULL); 489 break; 490 491 case CFGA_SATA_HWOPNOTSUPP: 492 /* hardware-specific help needed */ 493 set_msg(errstring, ERR_STR(rv), NULL); 494 set_msg(errstring, "\n", 495 dgettext(TEXT_DOMAIN, sata_help[HELP_HEADER]), NULL); 496 set_msg(errstring, sata_help[HELP_RESET_PORT], NULL); 497 set_msg(errstring, sata_help[HELP_RESET_DEVICE], NULL); 498 set_msg(errstring, sata_help[HELP_RESET_ALL], NULL); 499 set_msg(errstring, sata_help[HELP_PORT_ACTIVATE], NULL); 500 set_msg(errstring, sata_help[HELP_PORT_DEACTIVATE], NULL); 501 set_msg(errstring, sata_help[HELP_PORT_SELF_TEST], NULL); 502 set_msg(errstring, sata_help[HELP_CNTRL_SELF_TEST], NULL); 503 break; 504 505 case CFGA_SATA_AP: 506 case CFGA_SATA_PORT: 507 case CFGA_SATA_NOT_CONNECTED: 508 case CFGA_SATA_NOT_CONFIGURED: 509 case CFGA_SATA_ALREADY_CONNECTED: 510 case CFGA_SATA_ALREADY_CONFIGURED: 511 case CFGA_SATA_BUSY: 512 case CFGA_SATA_DEVLINK: 513 case CFGA_SATA_RCM_HANDLE: 514 case CFGA_SATA_RCM_ONLINE: 515 case CFGA_SATA_RCM_OFFLINE: 516 case CFGA_SATA_RCM_INFO: 517 case CFGA_SATA_DEV_CONFIGURE: 518 case CFGA_SATA_DEV_UNCONFIGURE: 519 case CFGA_SATA_DISCONNECTED: 520 /* These messages also print ap_id. */ 521 set_msg(errstring, ERR_STR(rv), "ap_id: ", ap_id, "", NULL); 522 break; 523 524 525 case CFGA_SATA_IOCTL: 526 case CFGA_SATA_NVLIST: 527 /* These messages also print errno. */ 528 { 529 char *errno_str = l_errno ? strerror(l_errno) : ""; 530 531 set_msg(errstring, ERR_STR(rv), errno_str, 532 l_errno ? "\n" : "", NULL); 533 break; 534 } 535 536 case CFGA_SATA_OPEN: 537 /* These messages also apid and errno. */ 538 { 539 char *errno_str = l_errno ? strerror(l_errno) : ""; 540 541 set_msg(errstring, ERR_STR(rv), "ap_id: ", ap_id, "\n", 542 errno_str, l_errno ? "\n" : "", NULL); 543 break; 544 } 545 546 default: 547 set_msg(errstring, ERR_STR(CFGA_SATA_INTERNAL_ERROR), NULL); 548 549 } /* end switch */ 550 551 552 /* 553 * Determine the proper error code to send back to the cfgadm library. 554 */ 555 return (sata_msgs[rv].cfga_err); 556 } 557 558 559 /* 560 * Entry points 561 */ 562 /* cfgadm entry point */ 563 /*ARGSUSED*/ 564 cfga_err_t 565 cfga_change_state( 566 cfga_cmd_t state_change_cmd, 567 const char *ap_id, 568 const char *options, 569 struct cfga_confirm *confp, 570 struct cfga_msg *msgp, 571 char **errstring, 572 cfga_flags_t flags) 573 { 574 int ret; 575 int len; 576 char *msg; 577 char *devpath; 578 nvlist_t *nvl = NULL; 579 ap_rstate_t rstate; 580 ap_ostate_t ostate; 581 devctl_hdl_t hdl = NULL; 582 cfga_sata_ret_t rv = CFGA_SATA_OK; 583 char *pdyn; 584 char *str_type; 585 size_t size; 586 boolean_t pmult = B_FALSE; 587 588 /* 589 * All sub-commands which can change state of device require 590 * root privileges. 591 */ 592 if (geteuid() != 0) { 593 rv = CFGA_SATA_PRIV; 594 goto bailout; 595 } 596 597 if ((rv = verify_params(ap_id, options, errstring)) != CFGA_SATA_OK) { 598 (void) cfga_help(msgp, options, flags); 599 goto bailout; 600 } 601 602 if ((rv = setup_for_devctl_cmd(ap_id, &hdl, &nvl, 603 DC_RDONLY)) != CFGA_SATA_OK) { 604 goto bailout; 605 } 606 607 /* 608 * Checking device type. A port multiplier is not configurable - it is 609 * already configured as soon as it is connected. 610 */ 611 if ((rv = do_control_ioctl(ap_id, SATA_CFGA_GET_AP_TYPE, NULL, 612 (void **)&str_type, &size)) != CFGA_SATA_OK) { 613 /* no such deivce */ 614 goto bailout; 615 } 616 if (strncmp(str_type, "sata-pmult", sizeof ("sata-pmult")) == 0) { 617 pmult = B_TRUE; 618 } 619 620 switch (state_change_cmd) { 621 case CFGA_CMD_CONFIGURE: 622 if (pmult == B_TRUE) { 623 rv = CFGA_SATA_HWOPNOTSUPP; 624 goto bailout; 625 } 626 627 if ((rv = port_state(hdl, nvl, &rstate, &ostate)) != 628 CFGA_SATA_OK) 629 goto bailout; 630 631 if (ostate == AP_OSTATE_CONFIGURED) { 632 rv = CFGA_SATA_ALREADY_CONFIGURED; 633 goto bailout; 634 } 635 /* Disallow dynamic AP name component */ 636 if (GET_DYN(ap_id) != NULL) { 637 rv = CFGA_SATA_INVALID_DEVNAME; 638 goto bailout; 639 } 640 641 if (rstate == AP_RSTATE_EMPTY) { 642 rv = CFGA_SATA_NOT_CONNECTED; 643 goto bailout; 644 } 645 rv = CFGA_SATA_OK; 646 647 if (devctl_ap_configure(hdl, nvl) != 0) { 648 rv = CFGA_SATA_DEV_CONFIGURE; 649 goto bailout; 650 } 651 652 devpath = sata_get_devicepath(ap_id); 653 if (devpath == NULL) { 654 int i; 655 /* 656 * Try for some time as SATA hotplug thread 657 * takes a while to create the path then 658 * eventually give up. 659 */ 660 for (i = 0; i < 12 && (devpath == NULL); i++) { 661 (void) sleep(6); 662 devpath = sata_get_devicepath(ap_id); 663 } 664 665 if (devpath == NULL) { 666 rv = CFGA_SATA_DEV_CONFIGURE; 667 break; 668 } 669 } 670 671 S_FREE(devpath); 672 break; 673 674 case CFGA_CMD_UNCONFIGURE: 675 if (pmult == B_TRUE) { 676 rv = CFGA_SATA_HWOPNOTSUPP; 677 goto bailout; 678 } 679 680 if ((rv = port_state(hdl, nvl, &rstate, &ostate)) != 681 CFGA_SATA_OK) 682 goto bailout; 683 684 if (rstate != AP_RSTATE_CONNECTED) { 685 rv = CFGA_SATA_NOT_CONNECTED; 686 goto bailout; 687 } 688 689 if (ostate != AP_OSTATE_CONFIGURED) { 690 rv = CFGA_SATA_NOT_CONFIGURED; 691 goto bailout; 692 } 693 /* Strip off AP name dynamic component, if present */ 694 if ((pdyn = GET_DYN(ap_id)) != NULL) { 695 *pdyn = '\0'; 696 } 697 698 rv = CFGA_SATA_OK; 699 700 len = strlen(SATA_CONFIRM_DEVICE) + 701 strlen(SATA_CONFIRM_DEVICE_SUSPEND) + 702 strlen("Unconfigure") + strlen(ap_id); 703 if ((msg = (char *)calloc(len +3, 1)) != NULL) { 704 (void) snprintf(msg, len + 3, "Unconfigure" 705 " %s%s\n%s", 706 SATA_CONFIRM_DEVICE, ap_id, 707 SATA_CONFIRM_DEVICE_SUSPEND); 708 } 709 710 if (!sata_confirm(confp, msg)) { 711 free(msg); 712 rv = CFGA_SATA_NACK; 713 break; 714 } 715 free(msg); 716 717 devpath = sata_get_devicepath(ap_id); 718 if (devpath == NULL) { 719 (void) printf( 720 "cfga_change_state: get device path failed\n"); 721 rv = CFGA_SATA_DEV_UNCONFIGURE; 722 break; 723 } 724 725 if ((rv = sata_rcm_offline(ap_id, errstring, devpath, flags)) 726 != CFGA_SATA_OK) { 727 break; 728 } 729 730 ret = devctl_ap_unconfigure(hdl, nvl); 731 732 if (ret != 0) { 733 rv = CFGA_SATA_DEV_UNCONFIGURE; 734 if (errno == EBUSY) { 735 rv = CFGA_SATA_BUSY; 736 } 737 (void) sata_rcm_online(ap_id, errstring, devpath, 738 flags); 739 } else { 740 (void) sata_rcm_remove(ap_id, errstring, devpath, 741 flags); 742 743 } 744 S_FREE(devpath); 745 746 break; 747 748 case CFGA_CMD_DISCONNECT: 749 if ((rv = port_state(hdl, nvl, &rstate, &ostate)) != 750 CFGA_SATA_OK) 751 goto bailout; 752 753 if (rstate == AP_RSTATE_DISCONNECTED) { 754 rv = CFGA_SATA_DISCONNECTED; 755 goto bailout; 756 } 757 758 /* Strip off AP name dynamic component, if present */ 759 if ((pdyn = GET_DYN(ap_id)) != NULL) { 760 *pdyn = '\0'; 761 } 762 763 764 rv = CFGA_SATA_OK; /* other statuses don't matter */ 765 766 /* 767 * If the port originally with device attached and was 768 * unconfigured already, the devicepath for the sd will be 769 * removed. sata_get_devicepath in this case is not necessary. 770 */ 771 /* only call rcm_offline if the state was CONFIGURED */ 772 if (ostate == AP_OSTATE_CONFIGURED && 773 pmult == B_FALSE) { 774 devpath = sata_get_devicepath(ap_id); 775 if (devpath == NULL) { 776 (void) printf( 777 "cfga_change_state: get path failed\n"); 778 rv = CFGA_SATA_DEV_UNCONFIGURE; 779 break; 780 } 781 782 len = strlen(SATA_CONFIRM_DEVICE) + 783 strlen(SATA_CONFIRM_DEVICE_SUSPEND) + 784 strlen("Disconnect") + strlen(ap_id); 785 if ((msg = (char *)calloc(len +3, 1)) != NULL) { 786 (void) snprintf(msg, len + 3, 787 "Disconnect" 788 " %s%s\n%s", 789 SATA_CONFIRM_DEVICE, ap_id, 790 SATA_CONFIRM_DEVICE_SUSPEND); 791 } 792 if (!sata_confirm(confp, msg)) { 793 free(msg); 794 rv = CFGA_SATA_NACK; 795 break; 796 } 797 free(msg); 798 799 if ((rv = sata_rcm_offline(ap_id, errstring, 800 devpath, flags)) != CFGA_SATA_OK) { 801 break; 802 } 803 804 ret = devctl_ap_unconfigure(hdl, nvl); 805 if (ret != 0) { 806 (void) printf( 807 "devctl_ap_unconfigure failed\n"); 808 rv = CFGA_SATA_DEV_UNCONFIGURE; 809 if (errno == EBUSY) 810 rv = CFGA_SATA_BUSY; 811 (void) sata_rcm_online(ap_id, errstring, 812 devpath, flags); 813 S_FREE(devpath); 814 815 /* 816 * The current policy is that if unconfigure 817 * failed, do not continue with disconnect. 818 * If the port needs to be forced into the 819 * disconnect (shutdown) state, 820 * the -x sata_port_poweroff command should be 821 * used instead of -c disconnect 822 */ 823 break; 824 } else { 825 (void) printf("%s\n", 826 ERR_STR(CFGA_SATA_DEVICE_UNCONFIGURED)); 827 (void) sata_rcm_remove(ap_id, errstring, 828 devpath, flags); 829 } 830 S_FREE(devpath); 831 } else if (rstate == AP_RSTATE_CONNECTED || 832 rstate == AP_RSTATE_EMPTY) { 833 len = strlen(SATA_CONFIRM_PORT) + 834 strlen(SATA_CONFIRM_PORT_DISABLE) + 835 strlen("Deactivate Port") + strlen(ap_id); 836 if ((msg = (char *)calloc(len +3, 1)) != NULL) { 837 (void) snprintf(msg, len +3, 838 "Disconnect" 839 " %s%s\n%s", 840 SATA_CONFIRM_PORT, ap_id, 841 SATA_CONFIRM_PORT_DISABLE); 842 } 843 if (!sata_confirm(confp, msg)) { 844 free(msg); 845 rv = CFGA_SATA_NACK; 846 break; 847 } 848 } 849 ret = devctl_ap_disconnect(hdl, nvl); 850 if (ret != 0) { 851 rv = CFGA_SATA_IOCTL; 852 if (errno == EBUSY) { 853 rv = CFGA_SATA_BUSY; 854 } 855 } 856 break; 857 858 case CFGA_CMD_CONNECT: 859 if ((rv = port_state(hdl, nvl, &rstate, &ostate)) != 860 CFGA_SATA_OK) 861 goto bailout; 862 863 if (rstate == AP_RSTATE_CONNECTED) { 864 rv = CFGA_SATA_ALREADY_CONNECTED; 865 goto bailout; 866 } 867 868 len = strlen(SATA_CONFIRM_PORT) + 869 strlen(SATA_CONFIRM_PORT_ENABLE) + 870 strlen("Activate Port") + strlen(ap_id); 871 if ((msg = (char *)calloc(len +3, 1)) != NULL) { 872 (void) snprintf(msg, len +3, "Activate" 873 " %s%s\n%s", 874 SATA_CONFIRM_PORT, ap_id, 875 SATA_CONFIRM_PORT_ENABLE); 876 } 877 if (!sata_confirm(confp, msg)) { 878 rv = CFGA_SATA_NACK; 879 break; 880 } 881 882 /* Disallow dynamic AP name component */ 883 if (GET_DYN(ap_id) != NULL) { 884 rv = CFGA_SATA_INVALID_DEVNAME; 885 goto bailout; 886 } 887 888 ret = devctl_ap_connect(hdl, nvl); 889 if (ret != 0) { 890 rv = CFGA_SATA_IOCTL; 891 } else { 892 rv = CFGA_SATA_OK; 893 } 894 895 break; 896 897 case CFGA_CMD_LOAD: 898 case CFGA_CMD_UNLOAD: 899 (void) cfga_help(msgp, options, flags); 900 rv = CFGA_SATA_OPNOTSUPP; 901 break; 902 903 case CFGA_CMD_NONE: 904 default: 905 (void) cfga_help(msgp, options, flags); 906 rv = CFGA_SATA_INTERNAL_ERROR; 907 } 908 909 bailout: 910 cleanup_after_devctl_cmd(hdl, nvl); 911 912 return (sata_err_msg(errstring, rv, ap_id, errno)); 913 } 914 915 /* cfgadm entry point */ 916 cfga_err_t 917 cfga_private_func( 918 const char *func, 919 const char *ap_id, 920 const char *options, 921 struct cfga_confirm *confp, 922 struct cfga_msg *msgp, 923 char **errstring, 924 cfga_flags_t flags) 925 { 926 int len; 927 char *msg; 928 nvlist_t *list = NULL; 929 ap_ostate_t ostate; 930 ap_rstate_t rstate; 931 devctl_hdl_t hdl = NULL; 932 cfga_sata_ret_t rv; 933 char *str_p; 934 size_t size; 935 936 if ((rv = verify_params(ap_id, NULL, errstring)) != CFGA_SATA_OK) { 937 (void) cfga_help(msgp, options, flags); 938 return (sata_err_msg(errstring, rv, ap_id, errno)); 939 } 940 941 /* 942 * All subcommands which can change state of device require 943 * root privileges. 944 */ 945 if (geteuid() != 0) { 946 rv = CFGA_SATA_PRIV; 947 goto bailout; 948 } 949 950 if (func == NULL) { 951 (void) printf("No valid option specified\n"); 952 rv = CFGA_SATA_OPTIONS; 953 goto bailout; 954 } 955 956 if ((rv = setup_for_devctl_cmd(ap_id, &hdl, &list, 0)) != 957 CFGA_SATA_OK) { 958 goto bailout; 959 } 960 961 /* We do not care here about dynamic AP name component */ 962 if ((str_p = GET_DYN(ap_id)) != NULL) { 963 *str_p = '\0'; 964 } 965 966 rv = CFGA_SATA_OK; 967 968 if (strcmp(func, SATA_RESET_PORT) == 0) { 969 len = strlen(SATA_CONFIRM_PORT) + 970 strlen(SATA_CONFIRM_DEVICE_ABORT) + 971 strlen("Reset Port") + strlen(ap_id); 972 973 if ((msg = (char *)calloc(len +3, 1)) != NULL) { 974 (void) snprintf(msg, len +3, "Reset" 975 " %s%s\n%s", 976 SATA_CONFIRM_PORT, ap_id, 977 SATA_CONFIRM_DEVICE_ABORT); 978 } else { 979 rv = CFGA_SATA_NACK; 980 goto bailout; 981 } 982 983 if (!sata_confirm(confp, msg)) { 984 rv = CFGA_SATA_NACK; 985 goto bailout; 986 } 987 988 rv = do_control_ioctl(ap_id, SATA_CFGA_RESET_PORT, NULL, 989 (void **)&str_p, &size); 990 991 } else if (strcmp(func, SATA_RESET_DEVICE) == 0) { 992 if ((rv = port_state(hdl, list, &rstate, &ostate)) != 993 CFGA_SATA_OK) 994 goto bailout; 995 /* 996 * Reset device function requires device to be connected 997 */ 998 if (rstate != AP_RSTATE_CONNECTED) { 999 rv = CFGA_SATA_NOT_CONNECTED; 1000 goto bailout; 1001 } 1002 1003 len = strlen(SATA_CONFIRM_DEVICE) + 1004 strlen(SATA_CONFIRM_DEVICE_ABORT) + 1005 strlen("Reset Device") + strlen(ap_id); 1006 1007 if ((msg = (char *)calloc(len +3, 1)) != NULL) { 1008 (void) snprintf(msg, len +3, "Reset" 1009 " %s%s\n%s", 1010 SATA_CONFIRM_DEVICE, ap_id, 1011 SATA_CONFIRM_DEVICE_ABORT); 1012 } else { 1013 rv = CFGA_SATA_NACK; 1014 goto bailout; 1015 } 1016 1017 if (!sata_confirm(confp, msg)) { 1018 rv = CFGA_SATA_NACK; 1019 goto bailout; 1020 } 1021 1022 rv = do_control_ioctl(ap_id, SATA_CFGA_RESET_DEVICE, NULL, 1023 (void **)&str_p, &size); 1024 1025 } else if (strcmp(func, SATA_RESET_ALL) == 0) { 1026 len = strlen(SATA_CONFIRM_CONTROLLER) + 1027 strlen(SATA_CONFIRM_CONTROLLER_ABORT) + 1028 strlen("Reset All") + strlen(ap_id); 1029 1030 if ((msg = (char *)calloc(len +3, 1)) != NULL) { 1031 (void) snprintf(msg, len +3, "Reset" 1032 " %s%s\n%s", 1033 SATA_CONFIRM_CONTROLLER, ap_id, 1034 SATA_CONFIRM_CONTROLLER_ABORT); 1035 } else { 1036 rv = CFGA_SATA_NACK; 1037 goto bailout; 1038 } 1039 1040 if (!sata_confirm(confp, msg)) { 1041 rv = CFGA_SATA_NACK; 1042 goto bailout; 1043 } 1044 rv = do_control_ioctl(ap_id, SATA_CFGA_RESET_ALL, NULL, 1045 (void **)&str_p, &size); 1046 1047 } else if (strcmp(func, SATA_PORT_DEACTIVATE) == 0) { 1048 len = strlen(SATA_CONFIRM_PORT) + 1049 strlen(SATA_CONFIRM_PORT_DISABLE) + 1050 strlen("Deactivate Port") + strlen(ap_id); 1051 1052 if ((msg = (char *)calloc(len +3, 1)) != NULL) { 1053 (void) snprintf(msg, len +3, "Deactivate" 1054 " %s%s\n%s", 1055 SATA_CONFIRM_PORT, ap_id, 1056 SATA_CONFIRM_PORT_DISABLE); 1057 } else { 1058 rv = CFGA_SATA_NACK; 1059 goto bailout; 1060 } 1061 if (!sata_confirm(confp, msg)) { 1062 rv = CFGA_SATA_NACK; 1063 goto bailout; 1064 } 1065 1066 rv = do_control_ioctl(ap_id, SATA_CFGA_PORT_DEACTIVATE, NULL, 1067 (void **)&str_p, &size); 1068 1069 } else if (strcmp(func, SATA_PORT_ACTIVATE) == 0) { 1070 len = strlen(SATA_CONFIRM_PORT) + 1071 strlen(SATA_CONFIRM_PORT_ENABLE) + 1072 strlen("Activate Port") + strlen(ap_id); 1073 1074 if ((msg = (char *)calloc(len +3, 1)) != NULL) { 1075 (void) snprintf(msg, len +3, "Activate" 1076 " %s%s\n%s", 1077 SATA_CONFIRM_PORT, ap_id, 1078 SATA_CONFIRM_PORT_ENABLE); 1079 } else { 1080 rv = CFGA_SATA_NACK; 1081 goto bailout; 1082 } 1083 if (!sata_confirm(confp, msg)) { 1084 rv = CFGA_SATA_NACK; 1085 goto bailout; 1086 } 1087 1088 rv = do_control_ioctl(ap_id, SATA_CFGA_PORT_ACTIVATE, 1089 NULL, (void **)&str_p, &size); 1090 goto bailout; 1091 1092 } else if (strcmp(func, SATA_PORT_SELF_TEST) == 0) { 1093 len = strlen(SATA_CONFIRM_PORT) + 1094 strlen(SATA_CONFIRM_DEVICE_SUSPEND) + 1095 strlen("Self Test Port") + strlen(ap_id); 1096 1097 if ((msg = (char *)calloc(len +3, 1)) != NULL) { 1098 (void) snprintf(msg, len +3, "Self Test" 1099 " %s%s\n%s", 1100 SATA_CONFIRM_PORT, ap_id, 1101 SATA_CONFIRM_DEVICE_SUSPEND); 1102 } else { 1103 rv = CFGA_SATA_NACK; 1104 goto bailout; 1105 } 1106 if (!sata_confirm(confp, msg)) { 1107 rv = CFGA_SATA_NACK; 1108 goto bailout; 1109 } 1110 1111 rv = do_control_ioctl(ap_id, SATA_CFGA_PORT_SELF_TEST, 1112 NULL, (void **)&str_p, &size); 1113 } else { 1114 /* Unrecognized operation request */ 1115 rv = CFGA_SATA_HWOPNOTSUPP; 1116 } 1117 1118 bailout: 1119 cleanup_after_devctl_cmd(hdl, list); 1120 1121 return (sata_err_msg(errstring, rv, ap_id, errno)); 1122 1123 } 1124 1125 /* cfgadm entry point */ 1126 /*ARGSUSED*/ 1127 cfga_err_t 1128 cfga_test( 1129 const char *ap_id, 1130 const char *options, 1131 struct cfga_msg *msgp, 1132 char **errstring, 1133 cfga_flags_t flags) 1134 { 1135 /* Should call ioctl for self test - phase 2 */ 1136 return (CFGA_OPNOTSUPP); 1137 } 1138 1139 1140 int 1141 sata_check_target_node(di_node_t node, void *arg) 1142 { 1143 char *minorpath; 1144 char *cp; 1145 1146 minorpath = di_devfs_minor_path(di_minor_next(node, DI_MINOR_NIL)); 1147 if (minorpath != NULL) { 1148 if (strstr(minorpath, arg) != NULL) { 1149 cp = strrchr(minorpath, (int)*MINOR_SEP); 1150 if (cp != NULL) { 1151 (void) strcpy(arg, cp); 1152 } 1153 free(minorpath); 1154 return (DI_WALK_TERMINATE); 1155 } 1156 free(minorpath); 1157 } 1158 return (DI_WALK_CONTINUE); 1159 } 1160 1161 struct chk_dev { 1162 int c_isblk; 1163 char *c_minor; 1164 }; 1165 1166 /*ARGSUSED*/ 1167 static int 1168 chk_dev_fcn(di_node_t node, di_minor_t minor, void *arg) 1169 { 1170 char *mn; 1171 struct chk_dev *chkp = (struct chk_dev *)arg; 1172 1173 mn = di_minor_name(minor); 1174 if (mn == NULL) 1175 return (DI_WALK_CONTINUE); 1176 1177 if (strcmp(mn, chkp->c_minor) != 0) 1178 return (DI_WALK_CONTINUE); 1179 1180 chkp->c_isblk = di_minor_spectype(minor) == S_IFBLK ? 1 : 0; 1181 1182 return (DI_WALK_TERMINATE); 1183 } 1184 1185 /* 1186 * Don't use devfs if stat() in /devices fails. Use libdevinfo instead. 1187 * Retired devices don't show up in devfs. 1188 * 1189 * Returns: 1190 * 1 - minor exists and is of type BLK 1191 * 0 - minor does not exist or is not of type BLK. 1192 */ 1193 static int 1194 is_devinfo_blk(char *minor_path) 1195 { 1196 char *minor_portion; 1197 struct chk_dev chk_dev; 1198 di_node_t node; 1199 int rv; 1200 1201 /* 1202 * prune minor path for di_init() - no /devices prefix and no minor name 1203 */ 1204 if (strncmp(minor_path, "/devices/", strlen("/devices/")) != 0) 1205 return (0); 1206 1207 minor_portion = strrchr(minor_path, *MINOR_SEP); 1208 if (minor_portion == NULL) 1209 return (0); 1210 1211 *minor_portion = 0; 1212 1213 node = di_init(minor_path + strlen("/devices"), DINFOMINOR); 1214 1215 *minor_portion = *MINOR_SEP; 1216 1217 if (node == DI_NODE_NIL) 1218 return (0); 1219 1220 chk_dev.c_isblk = 0; 1221 chk_dev.c_minor = minor_portion + 1; 1222 1223 rv = di_walk_minor(node, NULL, 0, &chk_dev, chk_dev_fcn); 1224 1225 di_fini(node); 1226 1227 if (rv == 0 && chk_dev.c_isblk) 1228 return (1); 1229 else 1230 return (0); 1231 } 1232 1233 /* 1234 * The dynamic component buffer returned by this function has to be freed! 1235 */ 1236 int 1237 sata_make_dyncomp(const char *ap_id, char **dyncomp, const char *type) 1238 { 1239 char *devpath = NULL; 1240 char *cp = NULL; 1241 int l_errno; 1242 char minor_path[MAXPATHLEN]; 1243 char name_part[MAXNAMELEN]; 1244 char *devlink = NULL; 1245 char *minor_portion = NULL; 1246 int deplen; 1247 int err; 1248 DIR *dp = NULL; 1249 struct stat sb; 1250 struct dirent *dep = NULL; 1251 struct dirent *newdep = NULL; 1252 char *p; 1253 1254 assert(dyncomp != NULL); 1255 1256 /* 1257 * Get target node path 1258 */ 1259 devpath = sata_get_devicepath(ap_id); 1260 if (devpath == NULL) { 1261 1262 (void) printf("cfga_list_ext: cannot locate target device\n"); 1263 return (CFGA_SATA_DYNAMIC_AP); 1264 1265 } else { 1266 1267 cp = strrchr(devpath, *PATH_SEP); 1268 assert(cp != NULL); 1269 *cp = 0; /* terminate path for opendir() */ 1270 1271 (void) strncpy(name_part, cp + 1, MAXNAMELEN); 1272 1273 /* 1274 * Using libdevinfo for this is overkill and kills 1275 * performance when many consumers are using libcfgadm 1276 * concurrently. 1277 */ 1278 if ((dp = opendir(devpath)) == NULL) { 1279 goto bailout; 1280 } 1281 1282 /* 1283 * deplen is large enough to fit the largest path- 1284 * struct dirent includes one byte (the terminator) 1285 * so we don't add 1 to the calculation here. 1286 */ 1287 deplen = pathconf(devpath, _PC_NAME_MAX); 1288 deplen = ((deplen <= 0) ? MAXNAMELEN : deplen) + 1289 sizeof (struct dirent); 1290 dep = (struct dirent *)malloc(deplen); 1291 if (dep == NULL) 1292 goto bailout; 1293 1294 while ((err = readdir_r(dp, dep, &newdep)) == 0 && 1295 newdep != NULL) { 1296 1297 assert(newdep == dep); 1298 1299 if (strcmp(dep->d_name, ".") == 0 || 1300 strcmp(dep->d_name, "..") == 0 || 1301 (minor_portion = strchr(dep->d_name, 1302 *MINOR_SEP)) == NULL) 1303 continue; 1304 1305 *minor_portion = 0; 1306 if (strcmp(dep->d_name, name_part) != 0) 1307 continue; 1308 *minor_portion = *MINOR_SEP; 1309 1310 (void) snprintf(minor_path, MAXPATHLEN, 1311 "%s/%s", devpath, dep->d_name); 1312 1313 /* 1314 * Break directly for tape device 1315 */ 1316 if (strcmp(type, "tape") == 0) 1317 break; 1318 1319 /* 1320 * If stat() fails, the device *may* be retired. 1321 * Check via libdevinfo if the device has a BLK minor. 1322 * We don't use libdevinfo all the time, since taking 1323 * a snapshot is slower than a stat(). 1324 */ 1325 if (stat(minor_path, &sb) < 0) { 1326 if (is_devinfo_blk(minor_path)) { 1327 break; 1328 } else { 1329 continue; 1330 } 1331 } 1332 1333 if (S_ISBLK(sb.st_mode)) 1334 break; 1335 1336 } 1337 1338 (void) closedir(dp); 1339 free(dep); 1340 free(devpath); 1341 1342 dp = NULL; 1343 dep = NULL; 1344 devpath = NULL; 1345 1346 /* 1347 * If there was an error, or we didn't exit the loop 1348 * by finding a block or character device, bail out. 1349 */ 1350 if (err != 0 || newdep == NULL) 1351 goto bailout; 1352 1353 /* 1354 * Look for links to the physical path in /dev/dsk 1355 * and /dev/rmt. So far, sata modue supports disk, 1356 * dvd and tape devices, so we will first look for 1357 * BLOCK devices, and then look for tape devices. 1358 */ 1359 (void) physpath_to_devlink("/dev/dsk", 1360 minor_path, &devlink, &l_errno); 1361 1362 /* postprocess and copy logical name here */ 1363 if (devlink != NULL) { 1364 /* 1365 * For disks, remove partition/slice info 1366 */ 1367 if ((cp = strstr(devlink, "dsk/")) != NULL) { 1368 /* cXtYdZ[(s[0..15])|(p[0..X])] */ 1369 if ((p = strchr(cp + 4, 'd')) != NULL) { 1370 p++; /* Skip the 'd' */ 1371 while (*p != 0 && isdigit(*p)) 1372 p++; 1373 *p = 0; 1374 } 1375 *dyncomp = strdup(cp); 1376 } 1377 1378 free(devlink); 1379 } else if (strcmp(type, "tape") == 0) { 1380 1381 /* 1382 * For tape device, logical name looks like 1383 * rmt/X 1384 */ 1385 (void) physpath_to_devlink("/dev/rmt", 1386 minor_path, &devlink, &l_errno); 1387 1388 if (devlink != NULL) { 1389 if ((cp = strstr(devlink, "rmt/")) != NULL) { 1390 *dyncomp = strdup(cp); 1391 } 1392 1393 free(devlink); 1394 } 1395 } 1396 1397 return (SATA_CFGA_OK); 1398 } 1399 1400 bailout: 1401 if (dp) 1402 (void) closedir(dp); 1403 if (devpath) 1404 free(devpath); 1405 if (dep) 1406 free(dep); 1407 return (CFGA_SATA_DYNAMIC_AP); 1408 } 1409 1410 /* cfgadm entry point */ 1411 /*ARGSUSED*/ 1412 cfga_err_t 1413 cfga_list_ext( 1414 const char *ap_id, 1415 cfga_list_data_t **ap_id_list, 1416 int *nlistp, 1417 const char *options, 1418 const char *listopts, 1419 char **errstring, 1420 cfga_flags_t flags) 1421 { 1422 int l_errno; 1423 char *ap_id_log = NULL; 1424 size_t size; 1425 nvlist_t *user_nvlist = NULL; 1426 devctl_hdl_t devctl_hdl = NULL; 1427 cfga_sata_ret_t rv = CFGA_SATA_OK; 1428 devctl_ap_state_t devctl_ap_state; 1429 char *pdyn; 1430 boolean_t pmult = B_FALSE; 1431 uint32_t port; 1432 1433 1434 if ((rv = verify_params(ap_id, options, errstring)) != CFGA_SATA_OK) { 1435 goto bailout; 1436 } 1437 /* We do not care here about dynamic AP name component */ 1438 if ((pdyn = GET_DYN(ap_id)) != NULL) { 1439 *pdyn = '\0'; 1440 } 1441 1442 if (ap_id_list == NULL || nlistp == NULL) { 1443 rv = CFGA_SATA_DATA_ERROR; 1444 goto bailout; 1445 } 1446 1447 /* Get ap status */ 1448 if ((rv = setup_for_devctl_cmd(ap_id, &devctl_hdl, &user_nvlist, 1449 DC_RDONLY)) != CFGA_SATA_OK) { 1450 goto bailout; 1451 } 1452 1453 /* will call dc_cmd to send IOCTL to kernel */ 1454 if (devctl_ap_getstate(devctl_hdl, user_nvlist, 1455 &devctl_ap_state) == -1) { 1456 cleanup_after_devctl_cmd(devctl_hdl, user_nvlist); 1457 rv = CFGA_SATA_IOCTL; 1458 goto bailout; 1459 } 1460 1461 cleanup_after_devctl_cmd(devctl_hdl, user_nvlist); 1462 1463 /* 1464 * Create cfga_list_data_t struct. 1465 */ 1466 if ((*ap_id_list = 1467 (cfga_list_data_t *)malloc(sizeof (**ap_id_list))) == NULL) { 1468 rv = CFGA_SATA_ALLOC_FAIL; 1469 goto bailout; 1470 } 1471 *nlistp = 1; 1472 1473 /* 1474 * Rest of the code fills in the cfga_list_data_t struct. 1475 */ 1476 1477 /* Get /dev/cfg path to corresponding to the physical ap_id */ 1478 /* Remember ap_id_log must be freed */ 1479 rv = physpath_to_devlink(CFGA_DEV_DIR, (char *)ap_id, 1480 &ap_id_log, &l_errno); 1481 1482 if (rv != 0) { 1483 rv = CFGA_SATA_DEVLINK; 1484 goto bailout; 1485 } 1486 1487 /* Get logical ap_id corresponding to the physical */ 1488 if (ap_id_log == NULL || strstr(ap_id_log, CFGA_DEV_DIR) == NULL) { 1489 rv = CFGA_SATA_DEVLINK; 1490 goto bailout; 1491 } 1492 1493 (void) strlcpy((*ap_id_list)->ap_log_id, 1494 /* Strip off /dev/cfg/ */ ap_id_log + strlen(CFGA_DEV_DIR)+ 1, 1495 sizeof ((*ap_id_list)->ap_log_id)); 1496 1497 free(ap_id_log); 1498 ap_id_log = NULL; 1499 1500 (void) strlcpy((*ap_id_list)->ap_phys_id, ap_id, 1501 sizeof ((*ap_id_list)->ap_phys_id)); 1502 1503 switch (devctl_ap_state.ap_rstate) { 1504 case AP_RSTATE_EMPTY: 1505 (*ap_id_list)->ap_r_state = CFGA_STAT_EMPTY; 1506 break; 1507 1508 case AP_RSTATE_DISCONNECTED: 1509 (*ap_id_list)->ap_r_state = CFGA_STAT_DISCONNECTED; 1510 break; 1511 1512 case AP_RSTATE_CONNECTED: 1513 (*ap_id_list)->ap_r_state = CFGA_STAT_CONNECTED; 1514 break; 1515 1516 default: 1517 rv = CFGA_SATA_STATE; 1518 goto bailout; 1519 } 1520 1521 switch (devctl_ap_state.ap_ostate) { 1522 case AP_OSTATE_CONFIGURED: 1523 (*ap_id_list)->ap_o_state = CFGA_STAT_CONFIGURED; 1524 break; 1525 1526 case AP_OSTATE_UNCONFIGURED: 1527 (*ap_id_list)->ap_o_state = CFGA_STAT_UNCONFIGURED; 1528 break; 1529 1530 default: 1531 rv = CFGA_SATA_STATE; 1532 goto bailout; 1533 } 1534 1535 switch (devctl_ap_state.ap_condition) { 1536 case AP_COND_OK: 1537 (*ap_id_list)->ap_cond = CFGA_COND_OK; 1538 break; 1539 1540 case AP_COND_FAILING: 1541 (*ap_id_list)->ap_cond = CFGA_COND_FAILING; 1542 break; 1543 1544 case AP_COND_FAILED: 1545 (*ap_id_list)->ap_cond = CFGA_COND_FAILED; 1546 break; 1547 1548 case AP_COND_UNUSABLE: 1549 (*ap_id_list)->ap_cond = CFGA_COND_UNUSABLE; 1550 break; 1551 1552 case AP_COND_UNKNOWN: 1553 (*ap_id_list)->ap_cond = CFGA_COND_UNKNOWN; 1554 break; 1555 1556 default: 1557 rv = CFGA_SATA_STATE; 1558 goto bailout; 1559 } 1560 1561 (*ap_id_list)->ap_class[0] = '\0'; /* Filled by libcfgadm */ 1562 (*ap_id_list)->ap_busy = devctl_ap_state.ap_in_transition; 1563 (*ap_id_list)->ap_status_time = devctl_ap_state.ap_last_change; 1564 (*ap_id_list)->ap_info[0] = NULL; 1565 1566 if ((*ap_id_list)->ap_r_state == CFGA_STAT_CONNECTED) { 1567 char *str_p; 1568 int skip, i; 1569 1570 /* 1571 * Fill in the 'Information' field for the -v option 1572 * Model (MOD:) 1573 */ 1574 if ((rv = do_control_ioctl(ap_id, SATA_CFGA_GET_MODEL_INFO, 1575 NULL, (void **)&str_p, &size)) != CFGA_SATA_OK) { 1576 (void) printf( 1577 "SATA_CFGA_GET_MODULE_INFO ioctl failed\n"); 1578 goto bailout; 1579 } 1580 /* drop leading and trailing spaces */ 1581 skip = strspn(str_p, " "); 1582 for (i = size - 1; i >= 0; i--) { 1583 if (str_p[i] == '\040') 1584 str_p[i] = '\0'; 1585 else if (str_p[i] != '\0') 1586 break; 1587 } 1588 1589 (void) strlcpy((*ap_id_list)->ap_info, "Mod: ", 1590 sizeof ((*ap_id_list)->ap_info)); 1591 (void) strlcat((*ap_id_list)->ap_info, str_p + skip, 1592 sizeof ((*ap_id_list)->ap_info)); 1593 1594 free(str_p); 1595 1596 /* 1597 * Fill in the 'Information' field for the -v option 1598 * Firmware revision (FREV:) 1599 */ 1600 if ((rv = do_control_ioctl(ap_id, 1601 SATA_CFGA_GET_REVFIRMWARE_INFO, 1602 NULL, (void **)&str_p, &size)) != CFGA_SATA_OK) { 1603 (void) printf( 1604 "SATA_CFGA_GET_REVFIRMWARE_INFO ioctl failed\n"); 1605 goto bailout; 1606 } 1607 /* drop leading and trailing spaces */ 1608 skip = strspn(str_p, " "); 1609 for (i = size - 1; i >= 0; i--) { 1610 if (str_p[i] == '\040') 1611 str_p[i] = '\0'; 1612 else if (str_p[i] != '\0') 1613 break; 1614 } 1615 (void) strlcat((*ap_id_list)->ap_info, " FRev: ", 1616 sizeof ((*ap_id_list)->ap_info)); 1617 (void) strlcat((*ap_id_list)->ap_info, str_p + skip, 1618 sizeof ((*ap_id_list)->ap_info)); 1619 1620 free(str_p); 1621 1622 1623 /* 1624 * Fill in the 'Information' field for the -v option 1625 * Serial Number (SN:) 1626 */ 1627 if ((rv = do_control_ioctl(ap_id, 1628 SATA_CFGA_GET_SERIALNUMBER_INFO, 1629 NULL, (void **)&str_p, &size)) != CFGA_SATA_OK) { 1630 (void) printf( 1631 "SATA_CFGA_GET_SERIALNUMBER_INFO ioctl failed\n"); 1632 goto bailout; 1633 } 1634 /* drop leading and trailing spaces */ 1635 skip = strspn(str_p, " "); 1636 for (i = size - 1; i >= 0; i--) { 1637 if (str_p[i] == '\040') 1638 str_p[i] = '\0'; 1639 else if (str_p[i] != '\0') 1640 break; 1641 } 1642 (void) strlcat((*ap_id_list)->ap_info, " SN: ", 1643 sizeof ((*ap_id_list)->ap_info)); 1644 (void) strlcat((*ap_id_list)->ap_info, str_p + skip, 1645 sizeof ((*ap_id_list)->ap_info)); 1646 1647 free(str_p); 1648 1649 1650 1651 /* Fill in ap_type which is collected from HBA driver */ 1652 /* call do_control_ioctl TBD */ 1653 if ((rv = do_control_ioctl(ap_id, SATA_CFGA_GET_AP_TYPE, NULL, 1654 (void **)&str_p, &size)) != CFGA_SATA_OK) { 1655 (void) printf( 1656 "SATA_CFGA_GET_AP_TYPE ioctl failed\n"); 1657 goto bailout; 1658 } 1659 1660 (void) strlcpy((*ap_id_list)->ap_type, str_p, 1661 sizeof ((*ap_id_list)->ap_type)); 1662 1663 free(str_p); 1664 1665 /* 1666 * Checking device type. Port multiplier has no dynamic 1667 * suffix. 1668 */ 1669 if (strncmp((*ap_id_list)->ap_type, "sata-pmult", 1670 sizeof ("sata-pmult")) == 0) 1671 pmult = B_TRUE; 1672 1673 if ((*ap_id_list)->ap_o_state == CFGA_STAT_CONFIGURED && 1674 pmult == B_FALSE) { 1675 1676 char *dyncomp = NULL; 1677 1678 /* 1679 * This is the case where we need to generate 1680 * a dynamic component of the ap_id, i.e. device. 1681 */ 1682 rv = sata_make_dyncomp(ap_id, &dyncomp, 1683 (*ap_id_list)->ap_type); 1684 if (rv != CFGA_SATA_OK) 1685 goto bailout; 1686 if (dyncomp != NULL) { 1687 (void) strcat((*ap_id_list)->ap_log_id, 1688 DYN_SEP); 1689 (void) strlcat((*ap_id_list)->ap_log_id, 1690 dyncomp, 1691 sizeof ((*ap_id_list)->ap_log_id)); 1692 free(dyncomp); 1693 } 1694 } 1695 1696 } else { 1697 /* This is an empty port */ 1698 if (get_port_num(ap_id, &port) != CFGA_SATA_OK) { 1699 goto bailout; 1700 } 1701 1702 if (port & SATA_CFGA_PMPORT_QUAL) { 1703 (void) strlcpy((*ap_id_list)->ap_type, "pmult-port", 1704 sizeof ((*ap_id_list)->ap_type)); 1705 } else { 1706 (void) strlcpy((*ap_id_list)->ap_type, "sata-port", 1707 sizeof ((*ap_id_list)->ap_type)); 1708 } 1709 } 1710 1711 return (sata_err_msg(errstring, rv, ap_id, errno)); 1712 1713 bailout: 1714 if (*ap_id_list != NULL) { 1715 free(*ap_id_list); 1716 } 1717 if (ap_id_log != NULL) { 1718 free(ap_id_log); 1719 } 1720 1721 return (sata_err_msg(errstring, rv, ap_id, errno)); 1722 } 1723 /* 1724 * This routine accepts a string adn prints it using 1725 * the message print routine argument. 1726 */ 1727 static void 1728 cfga_msg(struct cfga_msg *msgp, const char *str) 1729 { 1730 int len; 1731 char *q; 1732 1733 if (msgp == NULL || msgp->message_routine == NULL) { 1734 (void) printf("cfga_msg: NULL msgp\n"); 1735 return; 1736 } 1737 1738 if ((len = strlen(str)) == 0) { 1739 (void) printf("cfga_msg: null str\n"); 1740 return; 1741 } 1742 1743 if ((q = (char *)calloc(len + 1, 1)) == NULL) { 1744 perror("cfga_msg"); 1745 return; 1746 } 1747 1748 (void) strcpy(q, str); 1749 (void) (*msgp->message_routine)(msgp->appdata_ptr, q); 1750 1751 free(q); 1752 } 1753 1754 /* cfgadm entry point */ 1755 /* ARGSUSED */ 1756 cfga_err_t 1757 cfga_help(struct cfga_msg *msgp, const char *options, cfga_flags_t flags) 1758 { 1759 if (options != NULL) { 1760 cfga_msg(msgp, dgettext(TEXT_DOMAIN, sata_help[HELP_UNKNOWN])); 1761 cfga_msg(msgp, options); 1762 } 1763 cfga_msg(msgp, dgettext(TEXT_DOMAIN, sata_help[HELP_HEADER])); 1764 cfga_msg(msgp, sata_help[HELP_CONFIG]); 1765 cfga_msg(msgp, sata_help[HELP_RESET_PORT]); 1766 cfga_msg(msgp, sata_help[HELP_RESET_DEVICE]); 1767 cfga_msg(msgp, sata_help[HELP_RESET_ALL]); 1768 cfga_msg(msgp, sata_help[HELP_PORT_ACTIVATE]); 1769 cfga_msg(msgp, sata_help[HELP_PORT_DEACTIVATE]); 1770 cfga_msg(msgp, sata_help[HELP_PORT_SELF_TEST]); 1771 cfga_msg(msgp, sata_help[HELP_CNTRL_SELF_TEST]); 1772 1773 return (CFGA_OK); 1774 } 1775 1776 1777 /* 1778 * Ensure the ap_id passed is in the correct (physical ap_id) form: 1779 * path/device:xx[.xx] 1780 * where xx is a one or two-digit number. 1781 * 1782 * Note the library always calls the plugin with a physical ap_id. 1783 */ 1784 static int 1785 verify_valid_apid(const char *ap_id) 1786 { 1787 char *l_ap_id; 1788 1789 if (ap_id == NULL) 1790 return (-1); 1791 1792 l_ap_id = strrchr(ap_id, (int)*MINOR_SEP); 1793 l_ap_id++; 1794 1795 if (strspn(l_ap_id, "0123456789.") != strlen(l_ap_id)) { 1796 /* Bad characters in the ap_id */ 1797 return (-1); 1798 } 1799 1800 if (strstr(l_ap_id, "..") != NULL) { 1801 /* ap_id has 1..2 or more than 2 dots */ 1802 return (-1); 1803 } 1804 1805 return (0); 1806 } 1807 1808 1809 1810 /* 1811 * Verify the params passed in are valid. 1812 */ 1813 static cfga_sata_ret_t 1814 verify_params( 1815 const char *ap_id, 1816 const char *options, 1817 char **errstring) 1818 { 1819 char *pdyn, *lap_id; 1820 int rv; 1821 1822 if (errstring != NULL) { 1823 *errstring = NULL; 1824 } 1825 1826 if (options != NULL) { 1827 return (CFGA_SATA_OPTIONS); 1828 } 1829 1830 /* Strip dynamic AP name component if it is present. */ 1831 lap_id = strdup(ap_id); 1832 if (lap_id == NULL) { 1833 return (CFGA_SATA_ALLOC_FAIL); 1834 } 1835 if ((pdyn = GET_DYN(lap_id)) != NULL) { 1836 *pdyn = '\0'; 1837 } 1838 1839 if (verify_valid_apid(lap_id) != 0) { 1840 rv = CFGA_SATA_AP; 1841 } else { 1842 rv = CFGA_SATA_OK; 1843 } 1844 free(lap_id); 1845 1846 return (rv); 1847 } 1848 1849 /* 1850 * Takes a validated ap_id and extracts the port number. 1851 * Port multiplier is supported now. 1852 */ 1853 static cfga_sata_ret_t 1854 get_port_num(const char *ap_id, uint32_t *port) 1855 { 1856 uint32_t cport, pmport = 0, qual = 0; 1857 char *cport_str, *pmport_str; 1858 1859 /* Get the cport number */ 1860 cport_str = strrchr(ap_id, (int)*MINOR_SEP) + strlen(MINOR_SEP); 1861 1862 errno = 0; 1863 cport = strtol(cport_str, NULL, 10); 1864 if ((cport & ~SATA_CFGA_CPORT_MASK) != 0 || errno != 0) { 1865 return (CFGA_SATA_PORT); 1866 } 1867 1868 /* Get pmport number if there is a PORT_SEPARATOR */ 1869 errno = 0; 1870 if ((pmport_str = strrchr(ap_id, (int)*PORT_SEPARATOR)) != 0) { 1871 pmport_str += strlen(PORT_SEPARATOR); 1872 pmport = strtol(pmport_str, NULL, 10); 1873 qual = SATA_CFGA_PMPORT_QUAL; 1874 if ((pmport & ~SATA_CFGA_PMPORT_MASK) != 0 || errno != 0) { 1875 return (CFGA_SATA_PORT); 1876 } 1877 } 1878 1879 *port = cport | (pmport << SATA_CFGA_PMPORT_SHIFT) | qual; 1880 return (CFGA_SATA_OK); 1881 } 1882 1883 /* 1884 * Pair of routines to set up for/clean up after a devctl_ap_* lib call. 1885 */ 1886 static void 1887 cleanup_after_devctl_cmd(devctl_hdl_t devctl_hdl, nvlist_t *user_nvlist) 1888 { 1889 if (user_nvlist != NULL) { 1890 nvlist_free(user_nvlist); 1891 } 1892 if (devctl_hdl != NULL) { 1893 devctl_release(devctl_hdl); 1894 } 1895 } 1896 1897 static cfga_sata_ret_t 1898 setup_for_devctl_cmd( 1899 const char *ap_id, 1900 devctl_hdl_t *devctl_hdl, 1901 nvlist_t **user_nvlistp, 1902 uint_t oflag) 1903 { 1904 1905 uint_t port; 1906 cfga_sata_ret_t rv = CFGA_SATA_OK; 1907 char *lap_id, *pdyn; 1908 1909 lap_id = strdup(ap_id); 1910 if (lap_id == NULL) 1911 return (CFGA_SATA_ALLOC_FAIL); 1912 if ((pdyn = GET_DYN(lap_id)) != NULL) { 1913 *pdyn = '\0'; 1914 } 1915 1916 /* Get a devctl handle to pass to the devctl_ap_XXX functions */ 1917 if ((*devctl_hdl = devctl_ap_acquire((char *)lap_id, oflag)) == NULL) { 1918 (void) fprintf(stderr, "[libcfgadm:sata] " 1919 "setup_for_devctl_cmd: devctl_ap_acquire failed: %s\n", 1920 strerror(errno)); 1921 rv = CFGA_SATA_DEVCTL; 1922 goto bailout; 1923 } 1924 1925 /* Set up nvlist to pass the port number down to the driver */ 1926 if (nvlist_alloc(user_nvlistp, NV_UNIQUE_NAME_TYPE, NULL) != 0) { 1927 *user_nvlistp = NULL; 1928 rv = CFGA_SATA_NVLIST; 1929 (void) printf("nvlist_alloc failed\n"); 1930 goto bailout; 1931 } 1932 1933 /* 1934 * Get port id, for Port Multiplier port, things could be a little bit 1935 * complicated because of "port.port" format in ap_id, thus for 1936 * port multiplier port, port number should be coded as 32bit int 1937 * with the sig 16 bit as sata channel number, least 16 bit as 1938 * the port number of sata port multiplier port. 1939 */ 1940 if ((rv = get_port_num(lap_id, &port)) != CFGA_SATA_OK) { 1941 (void) printf( 1942 "setup_for_devctl_cmd: get_port_num, errno: %d\n", 1943 errno); 1944 goto bailout; 1945 } 1946 1947 /* Creates an int32_t entry */ 1948 if (nvlist_add_int32(*user_nvlistp, PORT, port) == -1) { 1949 (void) printf("nvlist_add_int32 failed\n"); 1950 rv = CFGA_SATA_NVLIST; 1951 goto bailout; 1952 } 1953 1954 free(lap_id); 1955 return (rv); 1956 1957 bailout: 1958 free(lap_id); 1959 (void) cleanup_after_devctl_cmd(*devctl_hdl, *user_nvlistp); 1960 1961 return (rv); 1962 } 1963 1964 1965 static cfga_sata_ret_t 1966 port_state(devctl_hdl_t hdl, nvlist_t *list, 1967 ap_rstate_t *rstate, ap_ostate_t *ostate) 1968 { 1969 devctl_ap_state_t devctl_ap_state; 1970 1971 if (devctl_ap_getstate(hdl, list, &devctl_ap_state) == -1) { 1972 (void) printf("devctl_ap_getstate failed, errno: %d\n", errno); 1973 return (CFGA_SATA_IOCTL); 1974 } 1975 *rstate = devctl_ap_state.ap_rstate; 1976 *ostate = devctl_ap_state.ap_ostate; 1977 return (CFGA_SATA_OK); 1978 } 1979 1980 1981 /* 1982 * Given a subcommand to the DEVCTL_AP_CONTROL ioctl, rquest the size of 1983 * the data to be returned, allocate a buffer, then get the data. 1984 * Returns *descrp (which must be freed) and size. 1985 * 1986 * Note SATA_DESCR_TYPE_STRING returns an ASCII NULL-terminated string, 1987 * not a string descr. 1988 */ 1989 cfga_sata_ret_t 1990 do_control_ioctl(const char *ap_id, sata_cfga_apctl_t subcommand, uint_t arg, 1991 void **descrp, size_t *sizep) 1992 { 1993 int fd = -1; 1994 uint_t port; 1995 uint32_t local_size; 1996 cfga_sata_ret_t rv = CFGA_SATA_OK; 1997 struct sata_ioctl_data ioctl_data; 1998 1999 assert(descrp != NULL); 2000 *descrp = NULL; 2001 assert(sizep != NULL); 2002 2003 if ((rv = get_port_num(ap_id, &port)) != CFGA_SATA_OK) { 2004 goto bailout; 2005 } 2006 2007 if ((fd = open(ap_id, O_RDONLY)) == -1) { 2008 (void) printf("do_control_ioctl: open failed: errno:%d\n", 2009 errno); 2010 rv = CFGA_SATA_OPEN; 2011 if (errno == EBUSY) { 2012 rv = CFGA_SATA_BUSY; 2013 } 2014 goto bailout; 2015 } 2016 2017 ioctl_data.cmd = subcommand; 2018 ioctl_data.port = port; 2019 ioctl_data.misc_arg = (uint_t)arg; 2020 2021 /* 2022 * Find out how large a buf we need to get the data. 2023 * Note the ioctls only accept/return a 32-bit int for a get_size 2024 * to avoid 32/64 and BE/LE issues. 2025 */ 2026 if ((subcommand == SATA_CFGA_GET_AP_TYPE) || 2027 (subcommand == SATA_CFGA_GET_DEVICE_PATH) || 2028 (subcommand == SATA_CFGA_GET_MODEL_INFO) || 2029 (subcommand == SATA_CFGA_GET_REVFIRMWARE_INFO) || 2030 (subcommand == SATA_CFGA_GET_SERIALNUMBER_INFO)) { 2031 ioctl_data.get_size = B_TRUE; 2032 ioctl_data.buf = (caddr_t)&local_size; 2033 ioctl_data.bufsiz = sizeof (local_size); 2034 2035 if (ioctl(fd, DEVCTL_AP_CONTROL, &ioctl_data) != 0) { 2036 perror("ioctl failed (size)"); 2037 rv = CFGA_SATA_IOCTL; 2038 goto bailout; 2039 } 2040 *sizep = local_size; 2041 2042 if (local_size == 0) { 2043 (void) printf("zero length data\n"); 2044 rv = CFGA_SATA_ZEROLEN; 2045 goto bailout; 2046 } 2047 if ((*descrp = malloc(*sizep)) == NULL) { 2048 (void) printf("do_control_ioctl: malloc failed\n"); 2049 rv = CFGA_SATA_ALLOC_FAIL; 2050 goto bailout; 2051 } 2052 } else { 2053 *sizep = 0; 2054 } 2055 ioctl_data.get_size = B_FALSE; 2056 ioctl_data.buf = *descrp; 2057 ioctl_data.bufsiz = *sizep; 2058 2059 /* Execute IOCTL */ 2060 2061 if (ioctl(fd, DEVCTL_AP_CONTROL, &ioctl_data) != 0) { 2062 rv = CFGA_SATA_IOCTL; 2063 goto bailout; 2064 } 2065 2066 (void) close(fd); 2067 2068 return (rv); 2069 2070 bailout: 2071 if (fd != -1) { 2072 (void) close(fd); 2073 } 2074 if (*descrp != NULL) { 2075 free(*descrp); 2076 *descrp = NULL; 2077 } 2078 2079 if (rv == CFGA_SATA_IOCTL && errno == EBUSY) { 2080 rv = CFGA_SATA_BUSY; 2081 } 2082 2083 return (rv); 2084 } 2085 2086 2087 static int 2088 sata_confirm(struct cfga_confirm *confp, char *msg) 2089 { 2090 int rval; 2091 2092 if (confp == NULL || confp->confirm == NULL) { 2093 return (0); 2094 } 2095 rval = (*confp->confirm)(confp->appdata_ptr, msg); 2096 2097 return (rval); 2098 } 2099 2100 2101 static char * 2102 sata_get_devicepath(const char *ap_id) 2103 { 2104 char *devpath = NULL; 2105 size_t size; 2106 cfga_sata_ret_t rv; 2107 2108 rv = do_control_ioctl(ap_id, SATA_CFGA_GET_DEVICE_PATH, NULL, 2109 (void **)&devpath, &size); 2110 2111 if (rv == CFGA_SATA_OK) { 2112 return (devpath); 2113 } else { 2114 return ((char *)NULL); 2115 } 2116 2117 } 2118