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 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 27 #include "cfga_fp.h" 28 29 /* 30 * This file contains helper routines for the FP plugin 31 */ 32 33 #if !defined(TEXT_DOMAIN) 34 #define TEXT_DOMAIN "SYS_TEST" 35 #endif 36 37 typedef struct strlist { 38 const char *str; 39 struct strlist *next; 40 } strlist_t; 41 42 typedef struct { 43 fpcfga_ret_t fp_err; 44 cfga_err_t cfga_err; 45 } errcvt_t; 46 47 typedef struct { 48 fpcfga_cmd_t cmd; 49 int type; 50 int (*fcn)(const devctl_hdl_t); 51 } set_state_cmd_t; 52 53 typedef struct { 54 fpcfga_cmd_t cmd; 55 int type; 56 int (*state_fcn)(const devctl_hdl_t, uint_t *); 57 } get_state_cmd_t; 58 59 /* defines for nftw() */ 60 #define NFTW_DEPTH 1 61 #define NFTW_CONTINUE 0 62 #define NFTW_TERMINATE 1 63 #define NFTW_ERROR -1 64 #define MAX_RETRIES 10 65 66 /* Function prototypes */ 67 static int do_recurse_dev(const char *path, const struct stat *sbuf, 68 int type, struct FTW *ftwp); 69 static fpcfga_recur_t lookup_dev(const char *lpath, void *arg); 70 static void msg_common(char **err_msgpp, int append_newline, int l_errno, 71 va_list ap); 72 static void lunlist_free(struct luninfo_list *lunlist); 73 74 /* Globals */ 75 struct { 76 mutex_t mp; 77 void *arg; 78 fpcfga_recur_t (*fcn)(const char *lpath, void *arg); 79 } nftw_arg = {DEFAULTMUTEX}; 80 81 /* 82 * The string table contains most of the strings used by the fp cfgadm plugin. 83 * All strings which are to be internationalized must be in this table. 84 * Some strings which are not internationalized are also included here. 85 * Arguments to messages are NOT internationalized. 86 */ 87 msgcvt_t str_tbl[] = { 88 89 /* 90 * The first element (ERR_UNKNOWN) MUST always be present in the array. 91 */ 92 #define UNKNOWN_ERR_IDX 0 /* Keep the index in sync */ 93 94 95 /* msg_code num_args, I18N msg_string */ 96 97 /* ERRORS */ 98 {ERR_UNKNOWN, 0, 1, "unknown error"}, 99 {ERR_OP_FAILED, 0, 1, "operation failed"}, 100 {ERR_CMD_INVAL, 0, 1, "invalid command"}, 101 {ERR_NOT_BUSAPID, 0, 1, "not a FP bus apid"}, 102 {ERR_APID_INVAL, 0, 1, "invalid FP ap_id"}, 103 {ERR_NOT_BUSOP, 0, 1, "operation not supported for FC bus"}, 104 {ERR_NOT_DEVOP, 0, 1, "operation not supported for FC device"}, 105 {ERR_UNAVAILABLE, 0, 1, "unavailable"}, 106 {ERR_CTRLR_CRIT, 0, 1, "critical partition controlled by FC HBA"}, 107 {ERR_BUS_GETSTATE, 0, 1, "failed to get state for FC bus"}, 108 {ERR_BUS_NOTCONNECTED, 0, 1, "FC bus not connected"}, 109 {ERR_BUS_CONNECTED, 0, 1, "FC bus not disconnected"}, 110 {ERR_BUS_QUIESCE, 0, 1, "FC bus quiesce failed"}, 111 {ERR_BUS_UNQUIESCE, 0, 1, "FC bus unquiesce failed"}, 112 {ERR_BUS_CONFIGURE, 0, 1, "failed to configure devices on FC bus"}, 113 {ERR_BUS_UNCONFIGURE, 0, 1, "failed to unconfigure FC bus"}, 114 {ERR_DEV_CONFIGURE, 0, 1, "failed to configure FC device"}, 115 {ERR_DEV_UNCONFIGURE, 0, 1, "failed to unconfigure FC device"}, 116 {ERR_FCA_CONFIGURE, 0, 1, "failed to configure ANY device on FCA port"}, 117 {ERR_FCA_UNCONFIGURE, 0, 1, "failed to unconfigure ANY device on FCA port"}, 118 {ERR_DEV_REPLACE, 0, 1, "replace operation failed"}, 119 {ERR_DEV_INSERT, 0, 1, "insert operation failed"}, 120 {ERR_DEV_GETSTATE, 0, 1, "failed to get state for FC device"}, 121 {ERR_RESET, 0, 1, "reset failed"}, 122 {ERR_LIST, 0, 1, "list operation failed"}, 123 {ERR_SIG_STATE, 0, 1, "could not restore signal disposition"}, 124 {ERR_MAYBE_BUSY, 0, 1, "device may be busy"}, 125 {ERR_BUS_DEV_MISMATCH, 0, 1, "mismatched FC bus and device"}, 126 {ERR_MEM_ALLOC, 0, 1, "Failed to allocated memory"}, 127 {ERR_DEVCTL_OFFLINE, 0, 1, "failed to offline device"}, 128 {ERR_UPD_REP, 0, 1, "Repository update failed"}, 129 {ERR_CONF_OK_UPD_REP, 0, 1, 130 "Configuration successful, but Repository update failed"}, 131 {ERR_UNCONF_OK_UPD_REP, 0, 1, 132 "Unconfiguration successful, but Repository update failed"}, 133 {ERR_PARTIAL_SUCCESS, 0, 1, 134 "Operation partially successful. Some failures seen"}, 135 {ERR_HBA_LOAD_LIBRARY, 0, 1, 136 "HBA load library failed"}, 137 {ERR_MATCHING_HBA_PORT, 0, 1, 138 "No match HBA port found"}, 139 {ERR_NO_ADAPTER_FOUND, 0, 1, 140 "No Fibre Channel adapters found"}, 141 142 /* Errors with arguments */ 143 {ERRARG_OPT_INVAL, 1, 1, "invalid option: "}, 144 {ERRARG_HWCMD_INVAL, 1, 1, "invalid command: "}, 145 {ERRARG_DEVINFO, 1, 1, "libdevinfo failed on path: "}, 146 {ERRARG_NOT_IN_DEVLIST, 1, 1, "Device not found in fabric device list: "}, 147 {ERRARG_NOT_IN_DEVINFO, 1, 1, "Could not find entry in devinfo tree: "}, 148 {ERRARG_DI_GET_PROP, 1, 1, "Could not get libdevinfo property: "}, 149 {ERRARG_DC_DDEF_ALLOC, 1, 1, "failed to alloc ddef space: "}, 150 {ERRARG_DC_BYTE_ARRAY, 1, 1, "failed to add property: "}, 151 {ERRARG_DC_BUS_ACQUIRE, 1, 1, "failed to acquire bus handle: "}, 152 {ERRARG_BUS_DEV_CREATE, 1, 1, "failed to create device node: "}, 153 {ERRARG_BUS_DEV_CREATE_UNKNOWN, 1, 1, 154 "failed to create device node... Device may be unconfigurable: "}, 155 {ERRARG_DEV_ACQUIRE, 1, 1, "device acquire operation failed: "}, 156 {ERRARG_DEV_REMOVE, 1, 1, "remove operation failed: "}, 157 158 /* Fibre Channel operation Errors */ 159 {ERR_FC, 0, 1, "FC error"}, 160 {ERR_FC_GET_DEVLIST, 0, 1, "Failed to get fabric device list"}, 161 {ERR_FC_GET_NEXT_DEV, 0, 1, "Failed to get next device on device map"}, 162 {ERR_FC_GET_FIRST_DEV, 0, 1, "Failed to get first device on device map"}, 163 {ERRARG_FC_DEV_MAP_INIT, 1, 1, 164 "Failed to initialize device map for: "}, 165 {ERRARG_FC_PROP_LOOKUP_BYTES, 1, 1, "Failed to get property of "}, 166 {ERRARG_FC_INQUIRY, 1, 1, "inquiry failed: "}, 167 {ERRARG_FC_REP_LUNS, 1, 1, "report LUNs failed: "}, 168 {ERRARG_FC_TOPOLOGY, 1, 1, "failed to get port topology: "}, 169 {ERRARG_PATH_TOO_LONG, 1, 1, "Path length exceeds max possible: "}, 170 {ERRARG_INVALID_PATH, 1, 1, "Invalid path: "}, 171 {ERRARG_OPENDIR, 1, 1, "failure opening directory: "}, 172 173 /* MPXIO Errors */ 174 {ERRARG_VHCI_GET_PATHLIST, 1, 1, "failed to get path list from vHCI: "}, 175 {ERRARG_XPORT_NOT_IN_PHCI_LIST, 1, 1, "Transport not in pHCI list: "}, 176 177 /* RCM Errors */ 178 {ERR_RCM_HANDLE, 0, 1, "cannot get RCM handle"}, 179 {ERRARG_RCM_SUSPEND, 1, 1, "failed to suspend: "}, 180 {ERRARG_RCM_RESUME, 1, 1, "failed to resume: "}, 181 {ERRARG_RCM_OFFLINE, 1, 1, "failed to offline: "}, 182 {ERRARG_RCM_ONLINE, 1, 1, "failed to online: "}, 183 {ERRARG_RCM_REMOVE, 1, 1, "failed to remove: "}, 184 {ERRARG_RCM_INFO, 1, 1, "failed to query: "}, 185 186 /* Commands */ 187 {CMD_INSERT_DEV, 0, 0, "insert_device"}, 188 {CMD_REMOVE_DEV, 0, 0, "remove_device"}, 189 {CMD_REPLACE_DEV, 0, 0, "replace_device"}, 190 {CMD_RESET_DEV, 0, 0, "reset_device"}, 191 {CMD_RESET_BUS, 0, 0, "reset_bus"}, 192 {CMD_RESET_ALL, 0, 0, "reset_all"}, 193 194 /* help messages */ 195 {MSG_HELP_HDR, 0, 1, "\nfp attachment point specific options:\n"}, 196 {MSG_HELP_USAGE, 0, 0, 197 "\t-c configure -o force_update ap_id [ap_id..]\n" 198 "\t-c configure -o no_update ap_id [ap_id...]\n" 199 "\t-c unconfigure -o force_update ap_id [ap_id... ]\n" 200 "\t-c unconfigure -o no_update ap_id [ap_id... ]\n"}, 201 202 /* hotplug messages */ 203 {MSG_INSDEV, 1, 1, "Adding device to FC HBA: "}, 204 {MSG_RMDEV, 1, 1, "Removing FC device: "}, 205 {MSG_REPLDEV, 1, 1, "Replacing FC device: "}, 206 207 /* Hotplugging confirmation prompts */ 208 {CONF_QUIESCE_1, 1, 1, 209 "This operation will suspend activity on FC bus: "}, 210 211 {CONF_QUIESCE_2, 0, 1, "\nContinue"}, 212 213 {CONF_UNQUIESCE, 0, 1, 214 "FC bus quiesced successfully.\n" 215 "It is now safe to proceed with hotplug operation." 216 "\nEnter y if operation is complete or n to abort"}, 217 218 /* Misc. */ 219 {WARN_DISCONNECT, 0, 1, 220 "WARNING: Disconnecting critical partitions may cause system hang." 221 "\nContinue"} 222 }; 223 224 225 #define N_STRS (sizeof (str_tbl) / sizeof (str_tbl[0])) 226 227 #define GET_MSG_NARGS(i) (str_tbl[msg_idx(i)].nargs) 228 #define GET_MSG_INTL(i) (str_tbl[msg_idx(i)].intl) 229 230 static errcvt_t err_cvt_tbl[] = { 231 { FPCFGA_OK, CFGA_OK }, 232 { FPCFGA_LIB_ERR, CFGA_LIB_ERROR }, 233 { FPCFGA_APID_NOEXIST, CFGA_APID_NOEXIST }, 234 { FPCFGA_NACK, CFGA_NACK }, 235 { FPCFGA_BUSY, CFGA_BUSY }, 236 { FPCFGA_SYSTEM_BUSY, CFGA_SYSTEM_BUSY }, 237 { FPCFGA_OPNOTSUPP, CFGA_OPNOTSUPP }, 238 { FPCFGA_PRIV, CFGA_PRIV }, 239 { FPCFGA_UNKNOWN_ERR, CFGA_ERROR }, 240 { FPCFGA_ERR, CFGA_ERROR } 241 }; 242 243 #define N_ERR_CVT_TBL (sizeof (err_cvt_tbl)/sizeof (err_cvt_tbl[0])) 244 245 #define DEV_OP 0 246 #define BUS_OP 1 247 static set_state_cmd_t set_state_cmds[] = { 248 249 { FPCFGA_BUS_QUIESCE, BUS_OP, devctl_bus_quiesce }, 250 { FPCFGA_BUS_UNQUIESCE, BUS_OP, devctl_bus_unquiesce }, 251 { FPCFGA_BUS_CONFIGURE, BUS_OP, devctl_bus_configure }, 252 { FPCFGA_BUS_UNCONFIGURE, BUS_OP, devctl_bus_unconfigure }, 253 { FPCFGA_RESET_BUS, BUS_OP, devctl_bus_reset }, 254 { FPCFGA_RESET_ALL, BUS_OP, devctl_bus_resetall }, 255 { FPCFGA_DEV_CONFIGURE, DEV_OP, devctl_device_online }, 256 { FPCFGA_DEV_UNCONFIGURE, DEV_OP, devctl_device_offline }, 257 { FPCFGA_DEV_REMOVE, DEV_OP, devctl_device_remove }, 258 { FPCFGA_RESET_DEV, DEV_OP, devctl_device_reset } 259 260 }; 261 262 #define N_SET_STATE_CMDS (sizeof (set_state_cmds)/sizeof (set_state_cmds[0])) 263 264 static get_state_cmd_t get_state_cmds[] = { 265 { FPCFGA_BUS_GETSTATE, BUS_OP, devctl_bus_getstate }, 266 { FPCFGA_DEV_GETSTATE, DEV_OP, devctl_device_getstate } 267 }; 268 269 #define N_GET_STATE_CMDS (sizeof (get_state_cmds)/sizeof (get_state_cmds[0])) 270 271 /* Order is important. Earlier directories are searched first */ 272 static const char *dev_dir_hints[] = { 273 CFGA_DEV_DIR, 274 DEV_RMT, 275 DEV_DSK, 276 DEV_RDSK, 277 DEV_DIR 278 }; 279 280 #define N_DEV_DIR_HINTS (sizeof (dev_dir_hints) / sizeof (dev_dir_hints[0])) 281 282 283 /* 284 * Routine to search the /dev directory or a subtree of /dev. 285 * If the entire /dev hierarchy is to be searched, the most likely directories 286 * are searched first. 287 */ 288 fpcfga_ret_t 289 recurse_dev( 290 const char *basedir, 291 void *arg, 292 fpcfga_recur_t (*fcn)(const char *lpath, void *arg)) 293 { 294 int i, rv = NFTW_ERROR; 295 296 (void) mutex_lock(&nftw_arg.mp); 297 298 nftw_arg.arg = arg; 299 nftw_arg.fcn = fcn; 300 301 if (strcmp(basedir, DEV_DIR)) { 302 errno = 0; 303 rv = nftw(basedir, do_recurse_dev, NFTW_DEPTH, FTW_PHYS); 304 goto out; 305 } 306 307 /* 308 * Search certain selected subdirectories first if basedir == "/dev". 309 * Ignore errors as some of these directories may not exist. 310 */ 311 for (i = 0; i < N_DEV_DIR_HINTS; i++) { 312 errno = 0; 313 if ((rv = nftw(dev_dir_hints[i], do_recurse_dev, NFTW_DEPTH, 314 FTW_PHYS)) == NFTW_TERMINATE) { 315 break; 316 } 317 } 318 319 /*FALLTHRU*/ 320 out: 321 (void) mutex_unlock(&nftw_arg.mp); 322 return (rv == NFTW_ERROR ? FPCFGA_ERR : FPCFGA_OK); 323 } 324 325 /*ARGSUSED*/ 326 static int 327 do_recurse_dev( 328 const char *path, 329 const struct stat *sbuf, 330 int type, 331 struct FTW *ftwp) 332 { 333 /* We want only VALID symlinks */ 334 if (type != FTW_SL) { 335 return (NFTW_CONTINUE); 336 } 337 338 assert(nftw_arg.fcn != NULL); 339 340 if (nftw_arg.fcn(path, nftw_arg.arg) == FPCFGA_TERMINATE) { 341 /* terminate prematurely, but may not be error */ 342 errno = 0; 343 return (NFTW_TERMINATE); 344 } else { 345 return (NFTW_CONTINUE); 346 } 347 } 348 349 cfga_err_t 350 err_cvt(fpcfga_ret_t fp_err) 351 { 352 int i; 353 354 for (i = 0; i < N_ERR_CVT_TBL; i++) { 355 if (err_cvt_tbl[i].fp_err == fp_err) { 356 return (err_cvt_tbl[i].cfga_err); 357 } 358 } 359 360 return (CFGA_ERROR); 361 } 362 363 /* 364 * Removes duplicate slashes from a pathname and any trailing slashes. 365 * Returns "/" if input is "/" 366 */ 367 char * 368 pathdup(const char *path, int *l_errnop) 369 { 370 int prev_was_slash = 0; 371 char c, *dp = NULL, *dup = NULL; 372 const char *sp = NULL; 373 374 *l_errnop = 0; 375 376 if (path == NULL) { 377 return (NULL); 378 } 379 380 if ((dup = calloc(1, strlen(path) + 1)) == NULL) { 381 *l_errnop = errno; 382 return (NULL); 383 } 384 385 prev_was_slash = 0; 386 for (sp = path, dp = dup; (c = *sp) != '\0'; sp++) { 387 if (!prev_was_slash || c != '/') { 388 *dp++ = c; 389 } 390 if (c == '/') { 391 prev_was_slash = 1; 392 } else { 393 prev_was_slash = 0; 394 } 395 } 396 397 /* Remove trailing slash except if it is the first char */ 398 if (prev_was_slash && dp != dup && dp - 1 != dup) { 399 *(--dp) = '\0'; 400 } else { 401 *dp = '\0'; 402 } 403 404 return (dup); 405 } 406 407 fpcfga_ret_t 408 apidt_create(const char *ap_id, apid_t *apidp, char **errstring) 409 { 410 char *xport_phys = NULL, *dyn = NULL; 411 char *dyncomp = NULL; 412 struct luninfo_list *lunlistp = NULL; 413 int l_errno = 0; 414 size_t len = 0; 415 fpcfga_ret_t ret; 416 417 if ((xport_phys = pathdup(ap_id, &l_errno)) == NULL) { 418 cfga_err(errstring, l_errno, ERR_OP_FAILED, 0); 419 return (FPCFGA_LIB_ERR); 420 } 421 422 /* Extract the base(hba) and dynamic(device) component if any */ 423 dyncomp = NULL; 424 if ((dyn = GET_DYN(xport_phys)) != NULL) { 425 len = strlen(DYN_TO_DYNCOMP(dyn)) + 1; 426 dyncomp = calloc(1, len); 427 if (dyncomp == NULL) { 428 cfga_err(errstring, errno, ERR_OP_FAILED, 0); 429 ret = FPCFGA_LIB_ERR; 430 goto err; 431 } 432 (void) strcpy(dyncomp, DYN_TO_DYNCOMP(dyn)); 433 if (GET_LUN_DYN(dyncomp)) { 434 ret = FPCFGA_APID_NOEXIST; 435 goto err; 436 } 437 438 /* Remove the dynamic component from the base. */ 439 *dyn = '\0'; 440 } 441 442 /* Get the path of dynamic attachment point if already configured. */ 443 if (dyncomp != NULL) { 444 ret = dyn_apid_to_path(xport_phys, dyncomp, 445 &lunlistp, &l_errno); 446 if ((ret != FPCFGA_OK) && (ret != FPCFGA_APID_NOCONFIGURE)) { 447 cfga_err(errstring, l_errno, ERR_OP_FAILED, 0); 448 goto err; 449 } 450 } 451 452 assert(xport_phys != NULL); 453 454 apidp->xport_phys = xport_phys; 455 apidp->dyncomp = dyncomp; 456 apidp->lunlist = lunlistp; 457 apidp->flags = 0; 458 459 return (FPCFGA_OK); 460 461 err: 462 S_FREE(xport_phys); 463 S_FREE(dyncomp); 464 lunlist_free(lunlistp); 465 return (ret); 466 } 467 468 static void 469 lunlist_free(struct luninfo_list *lunlist) 470 { 471 struct luninfo_list *lunp; 472 473 while (lunlist != NULL) { 474 lunp = lunlist->next; 475 S_FREE(lunlist->path); 476 S_FREE(lunlist); 477 lunlist = lunp; 478 } 479 } 480 481 void 482 apidt_free(apid_t *apidp) 483 { 484 if (apidp == NULL) 485 return; 486 487 S_FREE(apidp->xport_phys); 488 S_FREE(apidp->dyncomp); 489 lunlist_free(apidp->lunlist); 490 } 491 492 fpcfga_ret_t 493 walk_tree( 494 const char *physpath, 495 void *arg, 496 uint_t init_flags, 497 walkarg_t *up, 498 fpcfga_cmd_t cmd, 499 int *l_errnop) 500 { 501 int rv; 502 di_node_t root, tree_root, fpnode; 503 char *root_path, *cp = NULL; 504 char *devfs_fp_path; 505 size_t len; 506 fpcfga_ret_t ret; 507 int found = 0; 508 509 *l_errnop = 0; 510 511 if ((root_path = strdup(physpath)) == NULL) { 512 *l_errnop = errno; 513 return (FPCFGA_LIB_ERR); 514 } 515 516 /* Fix up path for di_init() */ 517 len = strlen(DEVICES_DIR); 518 if (strncmp(root_path, DEVICES_DIR SLASH, 519 len + strlen(SLASH)) == 0) { 520 cp = root_path + len; 521 (void) memmove(root_path, cp, strlen(cp) + 1); 522 } else if (*root_path != '/') { 523 *l_errnop = 0; 524 ret = FPCFGA_ERR; 525 goto out; 526 } 527 528 /* Remove dynamic component if any */ 529 if ((cp = GET_DYN(root_path)) != NULL) { 530 *cp = '\0'; 531 } 532 533 /* Remove minor name if any */ 534 if ((cp = strrchr(root_path, ':')) != NULL) { 535 *cp = '\0'; 536 } 537 538 /* 539 * If force_flag is set 540 * do di_init with DINFOFORCE flag and get to the input fp node 541 * from the device tree. 542 * 543 * In order to get the link between path_info node and scsi_vhci node 544 * it is required to take the snapshot of the whole device tree. 545 * this behavior of libdevinfo is inefficient. For a specific 546 * fca port DINFOPROP was sufficient on the fca path prior to 547 * scsi_vhci node support. 548 * 549 */ 550 if ((up->flags & FLAG_DEVINFO_FORCE) == FLAG_DEVINFO_FORCE) { 551 tree_root = di_init("/", init_flags | DINFOFORCE); 552 } else { 553 tree_root = di_init("/", init_flags); 554 } 555 556 if (tree_root == DI_NODE_NIL) { 557 *l_errnop = errno; 558 ret = FPCFGA_LIB_ERR; 559 goto out; 560 } 561 562 fpnode = di_drv_first_node("fp", tree_root); 563 564 while (fpnode) { 565 devfs_fp_path = di_devfs_path(fpnode); 566 if ((devfs_fp_path) && !(strncmp(devfs_fp_path, 567 root_path, strlen(root_path)))) { 568 found = 1; 569 di_devfs_path_free(devfs_fp_path); 570 break; 571 } 572 di_devfs_path_free(devfs_fp_path); 573 fpnode = di_drv_next_node(fpnode); 574 } 575 if (!(found)) { 576 ret = FPCFGA_LIB_ERR; 577 goto out; 578 } else { 579 root = fpnode; 580 } 581 582 /* Walk the tree */ 583 errno = 0; 584 if (cmd == FPCFGA_WALK_NODE) { 585 rv = di_walk_node(root, up->walkmode.node_args.flags, arg, 586 up->walkmode.node_args.fcn); 587 } else { 588 assert(cmd == FPCFGA_WALK_MINOR); 589 rv = di_walk_minor(root, up->walkmode.minor_args.nodetype, 0, 590 arg, up->walkmode.minor_args.fcn); 591 } 592 593 if (rv != 0) { 594 *l_errnop = errno; 595 ret = FPCFGA_LIB_ERR; 596 } else { 597 if ((up->flags & FLAG_PATH_INFO_WALK) == FLAG_PATH_INFO_WALK) { 598 ret = stat_path_info_node(root, arg, l_errnop); 599 } else { 600 *l_errnop = 0; 601 ret = FPCFGA_OK; 602 } 603 } 604 605 di_fini(tree_root); 606 607 /*FALLTHRU*/ 608 out: 609 S_FREE(root_path); 610 return (ret); 611 } 612 613 614 int 615 msg_idx(msgid_t msgid) 616 { 617 int idx = 0; 618 619 /* The string table index and the error id may or may not be same */ 620 if (msgid >= 0 && msgid <= N_STRS - 1 && 621 str_tbl[msgid].msgid == msgid) { 622 idx = msgid; 623 } else { 624 for (idx = 0; idx < N_STRS; idx++) { 625 if (str_tbl[idx].msgid == msgid) 626 break; 627 } 628 if (idx >= N_STRS) { 629 idx = UNKNOWN_ERR_IDX; 630 } 631 } 632 633 return (idx); 634 } 635 636 /* 637 * cfga_err() accepts a variable number of message IDs and constructs 638 * a corresponding error string which is returned via the errstring argument. 639 * cfga_err() calls dgettext() to internationalize proper messages. 640 * May be called with a NULL argument. 641 */ 642 void 643 cfga_err(char **errstring, int l_errno, ...) 644 { 645 va_list ap; 646 int append_newline = 0; 647 char *tmp_str, *tmp_err_str = NULL; 648 649 if (errstring == NULL) { 650 return; 651 } 652 653 /* 654 * Don't append a newline, the application (for example cfgadm) 655 * should do that. 656 */ 657 append_newline = 0; 658 659 va_start(ap, l_errno); 660 msg_common(&tmp_err_str, append_newline, l_errno, ap); 661 va_end(ap); 662 663 if (*errstring == NULL) { 664 *errstring = tmp_err_str; 665 return; 666 } 667 668 /* 669 * *errstring != NULL 670 * There was something in errstring prior to this call. 671 * So, concatenate the old and new strings 672 */ 673 if ((tmp_str = calloc(1, 674 strlen(*errstring) + strlen(tmp_err_str) + 2)) == NULL) { 675 /* In case of error, retain only the earlier message */ 676 free(tmp_err_str); 677 return; 678 } 679 680 sprintf(tmp_str, "%s\n%s", *errstring, tmp_err_str); 681 free(tmp_err_str); 682 free(*errstring); 683 *errstring = tmp_str; 684 } 685 686 /* 687 * This routine accepts a variable number of message IDs and constructs 688 * a corresponding message string which is printed via the message print 689 * routine argument. 690 */ 691 void 692 cfga_msg(struct cfga_msg *msgp, ...) 693 { 694 char *p = NULL; 695 int append_newline = 0, l_errno = 0; 696 va_list ap; 697 698 if (msgp == NULL || msgp->message_routine == NULL) { 699 return; 700 } 701 702 /* Append a newline after message */ 703 append_newline = 1; 704 l_errno = 0; 705 706 va_start(ap, msgp); 707 msg_common(&p, append_newline, l_errno, ap); 708 va_end(ap); 709 710 (void) (*msgp->message_routine)(msgp->appdata_ptr, p); 711 712 S_FREE(p); 713 } 714 715 /* 716 * Get internationalized string corresponding to message id 717 * Caller must free the memory allocated. 718 */ 719 char * 720 cfga_str(int append_newline, ...) 721 { 722 char *p = NULL; 723 int l_errno = 0; 724 va_list ap; 725 726 va_start(ap, append_newline); 727 msg_common(&p, append_newline, l_errno, ap); 728 va_end(ap); 729 730 return (p); 731 } 732 733 static void 734 msg_common(char **msgpp, int append_newline, int l_errno, va_list ap) 735 { 736 int a = 0; 737 size_t len = 0; 738 int i = 0, n = 0; 739 char *s = NULL, *t = NULL; 740 strlist_t dummy; 741 strlist_t *savep = NULL, *sp = NULL, *tailp = NULL; 742 743 if (*msgpp != NULL) { 744 return; 745 } 746 747 dummy.next = NULL; 748 tailp = &dummy; 749 for (len = 0; (a = va_arg(ap, int)) != 0; ) { 750 n = GET_MSG_NARGS(a); /* 0 implies no additional args */ 751 for (i = 0; i <= n; i++) { 752 sp = calloc(1, sizeof (*sp)); 753 if (sp == NULL) { 754 goto out; 755 } 756 if (i == 0 && GET_MSG_INTL(a)) { 757 sp->str = dgettext(TEXT_DOMAIN, GET_MSG_STR(a)); 758 } else if (i == 0) { 759 sp->str = GET_MSG_STR(a); 760 } else { 761 sp->str = va_arg(ap, char *); 762 } 763 len += (strlen(sp->str)); 764 sp->next = NULL; 765 tailp->next = sp; 766 tailp = sp; 767 } 768 } 769 770 len += 1; /* terminating NULL */ 771 772 s = t = NULL; 773 if (l_errno) { 774 s = dgettext(TEXT_DOMAIN, ": "); 775 t = S_STR(strerror(l_errno)); 776 if (s != NULL && t != NULL) { 777 len += strlen(s) + strlen(t); 778 } 779 } 780 781 if (append_newline) { 782 len++; 783 } 784 785 if ((*msgpp = calloc(1, len)) == NULL) { 786 goto out; 787 } 788 789 **msgpp = '\0'; 790 for (sp = dummy.next; sp != NULL; sp = sp->next) { 791 (void) strcat(*msgpp, sp->str); 792 } 793 794 if (s != NULL && t != NULL) { 795 (void) strcat(*msgpp, s); 796 (void) strcat(*msgpp, t); 797 } 798 799 if (append_newline) { 800 (void) strcat(*msgpp, dgettext(TEXT_DOMAIN, "\n")); 801 } 802 803 /* FALLTHROUGH */ 804 out: 805 sp = dummy.next; 806 while (sp != NULL) { 807 savep = sp->next; 808 S_FREE(sp); 809 sp = savep; 810 } 811 } 812 813 fpcfga_ret_t 814 devctl_cmd( 815 const char *physpath, 816 fpcfga_cmd_t cmd, 817 uint_t *statep, 818 int *l_errnop) 819 { 820 int rv = -1, i, type; 821 devctl_hdl_t hdl = NULL; 822 char *cp = NULL, *path = NULL; 823 int (*func)(const devctl_hdl_t); 824 int (*state_func)(const devctl_hdl_t, uint_t *); 825 826 *l_errnop = 0; 827 828 if (statep != NULL) *statep = 0; 829 830 func = NULL; 831 state_func = NULL; 832 type = 0; 833 834 for (i = 0; i < N_GET_STATE_CMDS; i++) { 835 if (get_state_cmds[i].cmd == cmd) { 836 state_func = get_state_cmds[i].state_fcn; 837 type = get_state_cmds[i].type; 838 assert(statep != NULL); 839 break; 840 } 841 } 842 843 if (state_func == NULL) { 844 for (i = 0; i < N_SET_STATE_CMDS; i++) { 845 if (set_state_cmds[i].cmd == cmd) { 846 func = set_state_cmds[i].fcn; 847 type = set_state_cmds[i].type; 848 assert(statep == NULL); 849 break; 850 } 851 } 852 } 853 854 assert(type == BUS_OP || type == DEV_OP); 855 856 if (func == NULL && state_func == NULL) { 857 return (FPCFGA_ERR); 858 } 859 860 /* 861 * Fix up path for calling devctl. 862 */ 863 if ((path = strdup(physpath)) == NULL) { 864 *l_errnop = errno; 865 return (FPCFGA_LIB_ERR); 866 } 867 868 /* Remove dynamic component if any */ 869 if ((cp = GET_DYN(path)) != NULL) { 870 *cp = '\0'; 871 } 872 873 /* Remove minor name */ 874 if ((cp = strrchr(path, ':')) != NULL) { 875 *cp = '\0'; 876 } 877 878 errno = 0; 879 880 if (type == BUS_OP) { 881 hdl = devctl_bus_acquire(path, 0); 882 } else { 883 hdl = devctl_device_acquire(path, 0); 884 } 885 *l_errnop = errno; 886 887 S_FREE(path); 888 889 if (hdl == NULL) { 890 return (FPCFGA_ERR); 891 } 892 893 errno = 0; 894 /* Only getstate functions require a second argument */ 895 if (func != NULL && statep == NULL) { 896 rv = func(hdl); 897 *l_errnop = errno; 898 } else if (state_func != NULL && statep != NULL) { 899 rv = state_func(hdl, statep); 900 *l_errnop = errno; 901 } else { 902 rv = -1; 903 *l_errnop = 0; 904 } 905 906 devctl_release(hdl); 907 908 return ((rv == -1) ? FPCFGA_ERR : FPCFGA_OK); 909 } 910 911 /* 912 * Is device in a known state ? (One of BUSY, ONLINE, OFFLINE) 913 * BUSY --> One or more device special files are open. Implies online 914 * ONLINE --> driver attached 915 * OFFLINE --> CF1 with offline flag set. 916 * UNKNOWN --> None of the above 917 */ 918 int 919 known_state(di_node_t node) 920 { 921 uint_t state; 922 923 state = di_state(node); 924 925 /* 926 * CF1 without offline flag set is considered unknown state. 927 * We are in a known state if either CF2 (driver attached) or 928 * offline. 929 */ 930 if ((state & DI_DEVICE_OFFLINE) == DI_DEVICE_OFFLINE || 931 (state & DI_DRIVER_DETACHED) != DI_DRIVER_DETACHED) { 932 return (1); 933 } 934 935 return (0); 936 } 937 938 void 939 list_free(ldata_list_t **llpp) 940 { 941 ldata_list_t *lp, *olp; 942 943 lp = *llpp; 944 while (lp != NULL) { 945 olp = lp; 946 lp = olp->next; 947 S_FREE(olp); 948 } 949 950 *llpp = NULL; 951 } 952 953 /* 954 * Obtain the devlink from a /devices path 955 */ 956 fpcfga_ret_t 957 physpath_to_devlink( 958 const char *basedir, 959 char *xport_phys, 960 char **xport_logpp, 961 int *l_errnop, 962 int match_minor) 963 { 964 pathm_t pmt = {NULL}; 965 fpcfga_ret_t ret; 966 967 pmt.phys = xport_phys; 968 pmt.ret = FPCFGA_NO_REC; 969 pmt.match_minor = match_minor; 970 971 /* 972 * Search the /dev hierarchy starting at basedir. 973 */ 974 ret = recurse_dev(basedir, &pmt, lookup_dev); 975 if (ret == FPCFGA_OK && (ret = pmt.ret) == FPCFGA_OK) { 976 assert(pmt.log != NULL); 977 *xport_logpp = pmt.log; 978 } else { 979 if (pmt.log != NULL) { 980 S_FREE(pmt.log); 981 } 982 983 *xport_logpp = NULL; 984 *l_errnop = pmt.l_errno; 985 } 986 987 return (ret); 988 } 989 990 static fpcfga_recur_t 991 lookup_dev(const char *lpath, void *arg) 992 { 993 char ppath[PATH_MAX]; 994 pathm_t *pmtp = (pathm_t *)arg; 995 996 if (realpath(lpath, ppath) == NULL) { 997 return (FPCFGA_CONTINUE); 998 } 999 1000 ppath[sizeof (ppath) - 1] = '\0'; 1001 1002 /* Is this the physical path we are looking for */ 1003 if (dev_cmp(ppath, pmtp->phys, pmtp->match_minor)) { 1004 return (FPCFGA_CONTINUE); 1005 } 1006 1007 if ((pmtp->log = strdup(lpath)) == NULL) { 1008 pmtp->l_errno = errno; 1009 pmtp->ret = FPCFGA_LIB_ERR; 1010 } else { 1011 pmtp->ret = FPCFGA_OK; 1012 } 1013 1014 return (FPCFGA_TERMINATE); 1015 } 1016 1017 /* Compare HBA physical ap_id and device path */ 1018 int 1019 hba_dev_cmp(const char *hba, const char *devpath) 1020 { 1021 char *cp = NULL; 1022 int rv; 1023 size_t hba_len, dev_len; 1024 char l_hba[MAXPATHLEN], l_dev[MAXPATHLEN]; 1025 1026 (void) snprintf(l_hba, sizeof (l_hba), "%s", hba); 1027 (void) snprintf(l_dev, sizeof (l_dev), "%s", devpath); 1028 1029 /* Remove dynamic component if any */ 1030 if ((cp = GET_DYN(l_hba)) != NULL) { 1031 *cp = '\0'; 1032 } 1033 1034 if ((cp = GET_DYN(l_dev)) != NULL) { 1035 *cp = '\0'; 1036 } 1037 1038 1039 /* Remove minor names */ 1040 if ((cp = strrchr(l_hba, ':')) != NULL) { 1041 *cp = '\0'; 1042 } 1043 1044 if ((cp = strrchr(l_dev, ':')) != NULL) { 1045 *cp = '\0'; 1046 } 1047 1048 hba_len = strlen(l_hba); 1049 dev_len = strlen(l_dev); 1050 1051 /* Check if HBA path is component of device path */ 1052 if (rv = strncmp(l_hba, l_dev, hba_len)) { 1053 return (rv); 1054 } 1055 1056 /* devpath must have '/' and 1 char in addition to hba path */ 1057 if (dev_len >= hba_len + 2 && l_dev[hba_len] == '/') { 1058 return (0); 1059 } else { 1060 return (-1); 1061 } 1062 } 1063 1064 int 1065 dev_cmp(const char *dev1, const char *dev2, int match_minor) 1066 { 1067 char l_dev1[MAXPATHLEN], l_dev2[MAXPATHLEN]; 1068 char *mn1, *mn2; 1069 int rv; 1070 1071 (void) snprintf(l_dev1, sizeof (l_dev1), "%s", dev1); 1072 (void) snprintf(l_dev2, sizeof (l_dev2), "%s", dev2); 1073 1074 if ((mn1 = GET_DYN(l_dev1)) != NULL) { 1075 *mn1 = '\0'; 1076 } 1077 1078 if ((mn2 = GET_DYN(l_dev2)) != NULL) { 1079 *mn2 = '\0'; 1080 } 1081 1082 /* Separate out the minor names */ 1083 if ((mn1 = strrchr(l_dev1, ':')) != NULL) { 1084 *mn1++ = '\0'; 1085 } 1086 1087 if ((mn2 = strrchr(l_dev2, ':')) != NULL) { 1088 *mn2++ = '\0'; 1089 } 1090 1091 if ((rv = strcmp(l_dev1, l_dev2)) != 0 || !match_minor) { 1092 return (rv); 1093 } 1094 1095 /* 1096 * Compare minor names 1097 */ 1098 if (mn1 == NULL && mn2 == NULL) { 1099 return (0); 1100 } else if (mn1 == NULL) { 1101 return (-1); 1102 } else if (mn2 == NULL) { 1103 return (1); 1104 } else { 1105 return (strcmp(mn1, mn2)); 1106 } 1107 } 1108 1109 /* 1110 * Returns non-zero on failure (aka, HBA_STATUS_ERROR_* 1111 * Will handle retries if applicable. 1112 */ 1113 int 1114 getAdapterAttrs(HBA_HANDLE handle, HBA_ADAPTERATTRIBUTES *attrs) 1115 { 1116 int count = 0; 1117 HBA_STATUS status = HBA_STATUS_ERROR_TRY_AGAIN; /* force first pass */ 1118 1119 /* Loop as long as we have a retryable error */ 1120 while ((status == HBA_STATUS_ERROR_TRY_AGAIN || 1121 status == HBA_STATUS_ERROR_BUSY) && 1122 count++ < HBA_MAX_RETRIES) { 1123 status = HBA_GetAdapterAttributes(handle, attrs); 1124 if (status == HBA_STATUS_OK) { 1125 break; 1126 } 1127 sleep(1); 1128 } 1129 return (status); 1130 } 1131 1132 /* 1133 * Returns non-zero on failure (aka, HBA_STATUS_ERROR_* 1134 * Will handle retries if applicable. 1135 */ 1136 int 1137 getPortAttrsByWWN(HBA_HANDLE handle, HBA_WWN wwn, HBA_PORTATTRIBUTES *attrs) 1138 { 1139 int count = 0; 1140 HBA_STATUS status = HBA_STATUS_ERROR_TRY_AGAIN; /* force first pass */ 1141 1142 /* Loop as long as we have a retryable error */ 1143 while ((status == HBA_STATUS_ERROR_TRY_AGAIN || 1144 status == HBA_STATUS_ERROR_BUSY) && 1145 count++ < HBA_MAX_RETRIES) { 1146 status = HBA_GetPortAttributesByWWN(handle, wwn, attrs); 1147 if (status == HBA_STATUS_OK) { 1148 break; 1149 } 1150 1151 /* The odds of this occuring are very slim, but possible. */ 1152 if (status == HBA_STATUS_ERROR_STALE_DATA) { 1153 /* 1154 * If we hit a stale data scenario, 1155 * we'll just tell the user to try again. 1156 */ 1157 status = HBA_STATUS_ERROR_TRY_AGAIN; 1158 break; 1159 } 1160 sleep(1); 1161 } 1162 return (status); 1163 } 1164 1165 /* 1166 * Returns non-zero on failure (aka, HBA_STATUS_ERROR_* 1167 * Will handle retries if applicable. 1168 */ 1169 int 1170 getAdapterPortAttrs(HBA_HANDLE handle, int portIndex, 1171 HBA_PORTATTRIBUTES *attrs) 1172 { 1173 int count = 0; 1174 HBA_STATUS status = HBA_STATUS_ERROR_TRY_AGAIN; /* force first pass */ 1175 1176 /* Loop as long as we have a retryable error */ 1177 while ((status == HBA_STATUS_ERROR_TRY_AGAIN || 1178 status == HBA_STATUS_ERROR_BUSY) && 1179 count++ < HBA_MAX_RETRIES) { 1180 status = HBA_GetAdapterPortAttributes(handle, portIndex, attrs); 1181 if (status == HBA_STATUS_OK) { 1182 break; 1183 } 1184 1185 /* The odds of this occuring are very slim, but possible. */ 1186 if (status == HBA_STATUS_ERROR_STALE_DATA) { 1187 /* 1188 * If we hit a stale data scenario, 1189 * we'll just tell the user to try again. 1190 */ 1191 status = HBA_STATUS_ERROR_TRY_AGAIN; 1192 break; 1193 } 1194 sleep(1); 1195 } 1196 return (status); 1197 } 1198 1199 /* 1200 * Returns non-zero on failure (aka, HBA_STATUS_ERROR_* 1201 * Will handle retries if applicable. 1202 */ 1203 int 1204 getDiscPortAttrs(HBA_HANDLE handle, int portIndex, int discIndex, 1205 HBA_PORTATTRIBUTES *attrs) 1206 { 1207 int count = 0; 1208 HBA_STATUS status = HBA_STATUS_ERROR_TRY_AGAIN; /* force first pass */ 1209 1210 /* Loop as long as we have a retryable error */ 1211 while ((status == HBA_STATUS_ERROR_TRY_AGAIN || 1212 status == HBA_STATUS_ERROR_BUSY) && 1213 count++ < HBA_MAX_RETRIES) { 1214 status = HBA_GetDiscoveredPortAttributes(handle, portIndex, 1215 discIndex, attrs); 1216 if (status == HBA_STATUS_OK) { 1217 break; 1218 } 1219 1220 /* The odds of this occuring are very slim, but possible. */ 1221 if (status == HBA_STATUS_ERROR_STALE_DATA) { 1222 /* 1223 * If we hit a stale data scenario, we'll just tell the 1224 * user to try again. 1225 */ 1226 status = HBA_STATUS_ERROR_TRY_AGAIN; 1227 break; 1228 } 1229 sleep(1); 1230 } 1231 return (status); 1232 } 1233 1234 /* 1235 * Find the Adapter port that matches the portPath. 1236 * When the matching port is found the caller have to close handle 1237 * and free library. 1238 */ 1239 fpcfga_ret_t 1240 findMatchingAdapterPort(char *portPath, HBA_HANDLE *matchingHandle, 1241 int *matchingPortIndex, HBA_PORTATTRIBUTES *matchingPortAttrs, 1242 char **errstring) 1243 { 1244 HBA_HANDLE handle; 1245 HBA_ADAPTERATTRIBUTES hbaAttrs; 1246 HBA_PORTATTRIBUTES portAttrs; 1247 HBA_STATUS status = HBA_STATUS_OK; 1248 int count, retry = 0, l_errno = 0; 1249 int adapterIndex, portIndex; 1250 char adapterName[256]; 1251 char *cfg_ptr, *tmpPtr; 1252 char *logical_apid = NULL; 1253 1254 status = HBA_LoadLibrary(); 1255 if (status != HBA_STATUS_OK) { 1256 cfga_err(errstring, 0, ERR_HBA_LOAD_LIBRARY, 0); 1257 return (FPCFGA_LIB_ERR); 1258 } 1259 count = HBA_GetNumberOfAdapters(); 1260 if (count == 0) { 1261 cfga_err(errstring, 0, ERR_NO_ADAPTER_FOUND, 0); 1262 HBA_FreeLibrary(); 1263 return (FPCFGA_LIB_ERR); 1264 } 1265 1266 /* Loop over all HBAs */ 1267 for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) { 1268 status = HBA_GetAdapterName(adapterIndex, (char *)&adapterName); 1269 if (status != HBA_STATUS_OK) { 1270 /* May have been DR'd */ 1271 continue; 1272 } 1273 handle = HBA_OpenAdapter(adapterName); 1274 if (handle == 0) { 1275 /* May have been DR'd */ 1276 continue; 1277 } 1278 1279 do { 1280 if (getAdapterAttrs(handle, &hbaAttrs)) { 1281 /* Should never happen */ 1282 HBA_CloseAdapter(handle); 1283 continue; 1284 } 1285 1286 /* Loop over all HBA Ports */ 1287 for (portIndex = 0; 1288 portIndex < hbaAttrs.NumberOfPorts; portIndex++) { 1289 if ((status = getAdapterPortAttrs(handle, 1290 portIndex, 1291 &portAttrs)) != HBA_STATUS_OK) { 1292 /* Need to refresh adapter */ 1293 if (status == 1294 HBA_STATUS_ERROR_STALE_DATA) { 1295 HBA_RefreshInformation(handle); 1296 break; 1297 } else { 1298 continue; 1299 } 1300 } 1301 1302 /* 1303 * check to see if OSDeviceName is a /dev/cfg 1304 * link or the physical path 1305 */ 1306 if (strncmp(portAttrs.OSDeviceName, 1307 CFGA_DEV_DIR, 1308 strlen(CFGA_DEV_DIR)) != 0) { 1309 tmpPtr = strstr(portAttrs.OSDeviceName, 1310 MINOR_SEP); 1311 if ((tmpPtr != NULL) && 1312 strncmp(portPath, 1313 portAttrs.OSDeviceName, 1314 strlen(portAttrs.OSDeviceName) - 1315 strlen(tmpPtr)) == 0) { 1316 if (matchingHandle) 1317 *matchingHandle = 1318 handle; 1319 if (matchingPortIndex) 1320 *matchingPortIndex = 1321 portIndex; 1322 if (matchingPortAttrs) 1323 *matchingPortAttrs = 1324 portAttrs; 1325 return (FPCFGA_OK); 1326 } 1327 } else { 1328 /* 1329 * strip off the /dev/cfg/ portion of 1330 * the OSDeviceName make sure that the 1331 * OSDeviceName is at least 1332 * strlen("/dev/cfg") + 1 + 1 long. 1333 * first 1 is for the / after /dev/cfg 1334 * second 1 is to make sure there is 1335 * somthing after 1336 */ 1337 if (strlen(portAttrs.OSDeviceName) < 1338 (strlen(CFGA_DEV_DIR) + 1 + 1)) 1339 continue; 1340 cfg_ptr = portAttrs.OSDeviceName + 1341 strlen(CFGA_DEV_DIR) + 1; 1342 if (logical_apid == NULL) { 1343 /* 1344 * get the /dev/cfg link from 1345 * the portPath 1346 */ 1347 if (make_xport_logid(portPath, 1348 &logical_apid, 1349 &l_errno) != FPCFGA_OK) { 1350 cfga_err(errstring, 1351 l_errno, 1352 ERR_LIST, 0); 1353 HBA_FreeLibrary(); 1354 return 1355 (FPCFGA_LIB_ERR); 1356 } 1357 } 1358 /* compare logical ap_id */ 1359 if (strcmp(logical_apid, 1360 cfg_ptr) == 0) { 1361 if (matchingHandle) 1362 *matchingHandle = 1363 handle; 1364 if (matchingPortIndex) 1365 *matchingPortIndex = 1366 portIndex; 1367 if (matchingPortAttrs) 1368 *matchingPortAttrs = 1369 portAttrs; 1370 S_FREE(logical_apid); 1371 return (FPCFGA_OK); 1372 } 1373 } 1374 } 1375 if (logical_apid != NULL) 1376 S_FREE(logical_apid); 1377 } while ((status == HBA_STATUS_ERROR_STALE_DATA) && 1378 (retry++ < HBA_MAX_RETRIES)); 1379 1380 HBA_CloseAdapter(handle); 1381 } 1382 free(logical_apid); 1383 1384 /* Got here. No matching adapter port found. */ 1385 cfga_err(errstring, 0, ERR_MATCHING_HBA_PORT, 0); 1386 HBA_FreeLibrary(); 1387 return (FPCFGA_LIB_ERR); 1388 } 1389