xref: /illumos-gate/usr/src/lib/cfgadm_plugins/fp/common/cfga_utils.c (revision 0778188f242b11e5d53f771c9e8a069354b3d5d4)
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
recurse_dev(const char * basedir,void * arg,fpcfga_recur_t (* fcn)(const char * lpath,void * arg))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
do_recurse_dev(const char * path,const struct stat * sbuf,int type,struct FTW * ftwp)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
err_cvt(fpcfga_ret_t fp_err)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 *
pathdup(const char * path,int * l_errnop)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
apidt_create(const char * ap_id,apid_t * apidp,char ** errstring)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
lunlist_free(struct luninfo_list * lunlist)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
apidt_free(apid_t * apidp)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
walk_tree(const char * physpath,void * arg,uint_t init_flags,walkarg_t * up,fpcfga_cmd_t cmd,int * l_errnop)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
msg_idx(msgid_t msgid)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
cfga_err(char ** errstring,int l_errno,...)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
cfga_msg(struct cfga_msg * msgp,...)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 *
cfga_str(int append_newline,...)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
msg_common(char ** msgpp,int append_newline,int l_errno,va_list ap)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
devctl_cmd(const char * physpath,fpcfga_cmd_t cmd,uint_t * statep,int * l_errnop)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
known_state(di_node_t node)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
list_free(ldata_list_t ** llpp)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
physpath_to_devlink(const char * basedir,char * xport_phys,char ** xport_logpp,int * l_errnop,int match_minor)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
lookup_dev(const char * lpath,void * arg)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
hba_dev_cmp(const char * hba,const char * devpath)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
dev_cmp(const char * dev1,const char * dev2,int match_minor)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
getAdapterAttrs(HBA_HANDLE handle,HBA_ADAPTERATTRIBUTES * attrs)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
getPortAttrsByWWN(HBA_HANDLE handle,HBA_WWN wwn,HBA_PORTATTRIBUTES * attrs)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
getAdapterPortAttrs(HBA_HANDLE handle,int portIndex,HBA_PORTATTRIBUTES * attrs)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
getDiscPortAttrs(HBA_HANDLE handle,int portIndex,int discIndex,HBA_PORTATTRIBUTES * attrs)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
findMatchingAdapterPort(char * portPath,HBA_HANDLE * matchingHandle,int * matchingPortIndex,HBA_PORTATTRIBUTES * matchingPortAttrs,char ** errstring)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