xref: /freebsd/contrib/ofed/infiniband-diags/src/ibdiag_common.c (revision 52c2bb75163559a6e2866ad374a7de67a4ea1273)
1 /*
2  * Copyright (c) 2006-2007 The Regents of the University of California.
3  * Copyright (c) 2004-2009 Voltaire, Inc. All rights reserved.
4  * Copyright (c) 2002-2010 Mellanox Technologies LTD. All rights reserved.
5  * Copyright (c) 1996-2003 Intel Corporation. All rights reserved.
6  * Copyright (c) 2009 HNR Consulting. All rights reserved.
7  * Copyright (c) 2011 Lawrence Livermore National Security. All rights reserved.
8  *
9  * This software is available to you under a choice of one of two
10  * licenses.  You may choose to be licensed under the terms of the GNU
11  * General Public License (GPL) Version 2, available from the file
12  * COPYING in the main directory of this source tree, or the
13  * OpenIB.org BSD license below:
14  *
15  *     Redistribution and use in source and binary forms, with or
16  *     without modification, are permitted provided that the following
17  *     conditions are met:
18  *
19  *      - Redistributions of source code must retain the above
20  *        copyright notice, this list of conditions and the following
21  *        disclaimer.
22  *
23  *      - Redistributions in binary form must reproduce the above
24  *        copyright notice, this list of conditions and the following
25  *        disclaimer in the documentation and/or other materials
26  *        provided with the distribution.
27  *
28  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
29  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
30  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
31  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
32  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
33  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
34  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
35  * SOFTWARE.
36  *
37  */
38 
39 /**
40  * Define common functions which can be included in the various C based diags.
41  */
42 
43 #define _GNU_SOURCE
44 #include <stdio.h>
45 #include <errno.h>
46 #include <string.h>
47 #include <stdlib.h>
48 #include <stdarg.h>
49 #include <sys/types.h>
50 #include <unistd.h>
51 #include <ctype.h>
52 #include <config.h>
53 #include <getopt.h>
54 #include <limits.h>
55 #include <sys/stat.h>
56 #include <stdarg.h>
57 
58 #include <infiniband/umad.h>
59 #include <infiniband/mad.h>
60 #include <ibdiag_common.h>
61 #include <ibdiag_version.h>
62 
63 int ibverbose;
64 enum MAD_DEST ibd_dest_type = IB_DEST_LID;
65 ib_portid_t *ibd_sm_id;
66 static ib_portid_t sm_portid = { 0 };
67 
68 /* general config options */
69 #define IBDIAG_CONFIG_GENERAL IBDIAG_CONFIG_PATH"/ibdiag.conf"
70 char *ibd_ca = NULL;
71 int ibd_ca_port = 0;
72 int ibd_timeout = 0;
73 uint32_t ibd_ibnetdisc_flags = IBND_CONFIG_MLX_EPI;
74 uint64_t ibd_mkey;
75 uint64_t ibd_sakey = 0;
76 int show_keys = 0;
77 char *ibd_nd_format = NULL;
78 
79 static const char *prog_name;
80 static const char *prog_args;
81 static const char **prog_examples;
82 static struct option *long_opts = NULL;
83 static const struct ibdiag_opt *opts_map[256];
84 
85 static const char *get_build_version(void)
86 {
87 	return "BUILD VERSION: " IBDIAG_VERSION;
88 }
89 
90 static void pretty_print(int start, int width, const char *str)
91 {
92 	int len = width - start;
93 	const char *p, *e;
94 
95 	while (1) {
96 		while (isspace(*str))
97 			str++;
98 		p = str;
99 		do {
100 			e = p + 1;
101 			p = strchr(e, ' ');
102 		} while (p && p - str < len);
103 		if (!p) {
104 			fprintf(stderr, "%s", str);
105 			break;
106 		}
107 		if (e - str == 1)
108 			e = p;
109 		fprintf(stderr, "%.*s\n%*s", (int)(e - str), str, start, "");
110 		str = e;
111 	}
112 }
113 
114 static inline int val_str_true(const char *val_str)
115 {
116 	return ((strncmp(val_str, "TRUE", strlen("TRUE")) == 0) ||
117 		(strncmp(val_str, "true", strlen("true")) == 0));
118 }
119 
120 void read_ibdiag_config(const char *file)
121 {
122 	char buf[1024];
123 	FILE *config_fd = NULL;
124 	char *p_prefix, *p_last;
125 	char *name;
126 	char *val_str;
127 	struct stat statbuf;
128 
129 	/* silently ignore missing config file */
130 	if (stat(file, &statbuf))
131 		return;
132 
133 	config_fd = fopen(file, "r");
134 	if (!config_fd)
135 		return;
136 
137 	while (fgets(buf, sizeof buf, config_fd) != NULL) {
138 		p_prefix = strtok_r(buf, "\n", &p_last);
139 		if (!p_prefix)
140 			continue; /* ignore blank lines */
141 
142 		if (*p_prefix == '#')
143 			continue; /* ignore comment lines */
144 
145 		name = strtok_r(p_prefix, "=", &p_last);
146 		val_str = strtok_r(NULL, "\n", &p_last);
147 
148 		if (strncmp(name, "CA", strlen("CA")) == 0) {
149 			free(ibd_ca);
150 			ibd_ca = strdup(val_str);
151 		} else if (strncmp(name, "Port", strlen("Port")) == 0) {
152 			ibd_ca_port = strtoul(val_str, NULL, 0);
153 		} else if (strncmp(name, "timeout", strlen("timeout")) == 0) {
154 			ibd_timeout = strtoul(val_str, NULL, 0);
155 		} else if (strncmp(name, "MLX_EPI", strlen("MLX_EPI")) == 0) {
156 			if (val_str_true(val_str)) {
157 				ibd_ibnetdisc_flags |= IBND_CONFIG_MLX_EPI;
158 			} else {
159 				ibd_ibnetdisc_flags &= ~IBND_CONFIG_MLX_EPI;
160 			}
161 		} else if (strncmp(name, "m_key", strlen("m_key")) == 0) {
162 			ibd_mkey = strtoull(val_str, 0, 0);
163 		} else if (strncmp(name, "sa_key",
164 				   strlen("sa_key")) == 0) {
165 			ibd_sakey = strtoull(val_str, 0, 0);
166 		} else if (strncmp(name, "nd_format",
167 				   strlen("nd_format")) == 0) {
168 			ibd_nd_format = strdup(val_str);
169 		}
170 	}
171 
172 	fclose(config_fd);
173 }
174 
175 
176 void ibdiag_show_usage()
177 {
178 	struct option *o = long_opts;
179 	int n;
180 
181 	fprintf(stderr, "\nUsage: %s [options] %s\n\n", prog_name,
182 		prog_args ? prog_args : "");
183 
184 	if (long_opts[0].name)
185 		fprintf(stderr, "Options:\n");
186 	for (o = long_opts; o->name; o++) {
187 		const struct ibdiag_opt *io = opts_map[o->val];
188 		n = fprintf(stderr, "  --%s", io->name);
189 		if (isprint(io->letter))
190 			n += fprintf(stderr, ", -%c", io->letter);
191 		if (io->has_arg)
192 			n += fprintf(stderr, " %s",
193 				     io->arg_tmpl ? io->arg_tmpl : "<val>");
194 		if (io->description && *io->description) {
195 			n += fprintf(stderr, "%*s  ", 24 - n > 0 ? 24 - n : 0,
196 				     "");
197 			pretty_print(n, 74, io->description);
198 		}
199 		fprintf(stderr, "\n");
200 	}
201 
202 	if (prog_examples) {
203 		const char **p;
204 		fprintf(stderr, "\nExamples:\n");
205 		for (p = prog_examples; *p && **p; p++)
206 			fprintf(stderr, "  %s %s\n", prog_name, *p);
207 	}
208 
209 	fprintf(stderr, "\n");
210 
211 	exit(2);
212 }
213 
214 static int process_opt(int ch, char *optarg)
215 {
216 	char *endp;
217 	long val;
218 
219 	switch (ch) {
220 	case 'z':
221 		read_ibdiag_config(optarg);
222 		break;
223 	case 'h':
224 		ibdiag_show_usage();
225 		break;
226 	case 'V':
227 		fprintf(stderr, "%s %s\n", prog_name, get_build_version());
228 		exit(0);
229 	case 'e':
230 		madrpc_show_errors(1);
231 		break;
232 	case 'v':
233 		ibverbose++;
234 		break;
235 	case 'd':
236 		ibdebug++;
237 		madrpc_show_errors(1);
238 		umad_debug(ibdebug - 1);
239 		break;
240 	case 'C':
241 		ibd_ca = optarg;
242 		break;
243 	case 'P':
244 		ibd_ca_port = strtoul(optarg, 0, 0);
245 		if (ibd_ca_port < 0)
246 			IBEXIT("cannot resolve CA port %d", ibd_ca_port);
247 		break;
248 	case 'D':
249 		ibd_dest_type = IB_DEST_DRPATH;
250 		break;
251 	case 'L':
252 		ibd_dest_type = IB_DEST_LID;
253 		break;
254 	case 'G':
255 		ibd_dest_type = IB_DEST_GUID;
256 		break;
257 	case 't':
258 		errno = 0;
259 		val = strtol(optarg, &endp, 0);
260 		if (errno || (endp && *endp != '\0') || val <= 0 ||
261 		    val > INT_MAX)
262 			IBEXIT("Invalid timeout \"%s\".  Timeout requires a "
263 				"positive integer value < %d.", optarg, INT_MAX);
264 		else {
265 			madrpc_set_timeout((int)val);
266 			ibd_timeout = (int)val;
267 		}
268 		break;
269 	case 's':
270 		/* srcport is not required when resolving via IB_DEST_LID */
271 		if (resolve_portid_str(ibd_ca, ibd_ca_port, &sm_portid, optarg,
272 				IB_DEST_LID, 0, NULL) < 0)
273 			IBEXIT("cannot resolve SM destination port %s",
274 				optarg);
275 		ibd_sm_id = &sm_portid;
276 		break;
277 	case 'K':
278 		show_keys = 1;
279 		break;
280 	case 'y':
281 		errno = 0;
282 		ibd_mkey = strtoull(optarg, &endp, 0);
283 		if (errno || *endp != '\0') {
284 			errno = 0;
285 			ibd_mkey = strtoull(getpass("M_Key: "), &endp, 0);
286 			if (errno || *endp != '\0') {
287 				IBEXIT("Bad M_Key");
288 			}
289                 }
290                 break;
291 	default:
292 		return -1;
293 	}
294 
295 	return 0;
296 }
297 
298 static const struct ibdiag_opt common_opts[] = {
299 	{"config", 'z', 1, "<config>", "use config file, default: " IBDIAG_CONFIG_GENERAL},
300 	{"Ca", 'C', 1, "<ca>", "Ca name to use"},
301 	{"Port", 'P', 1, "<port>", "Ca port number to use"},
302 	{"Direct", 'D', 0, NULL, "use Direct address argument"},
303 	{"Lid", 'L', 0, NULL, "use LID address argument"},
304 	{"Guid", 'G', 0, NULL, "use GUID address argument"},
305 	{"timeout", 't', 1, "<ms>", "timeout in ms"},
306 	{"sm_port", 's', 1, "<lid>", "SM port lid"},
307 	{"show_keys", 'K', 0, NULL, "display security keys in output"},
308 	{"m_key", 'y', 1, "<key>", "M_Key to use in request"},
309 	{"errors", 'e', 0, NULL, "show send and receive errors"},
310 	{"verbose", 'v', 0, NULL, "increase verbosity level"},
311 	{"debug", 'd', 0, NULL, "raise debug level"},
312 	{"help", 'h', 0, NULL, "help message"},
313 	{"version", 'V', 0, NULL, "show version"},
314 	{0}
315 };
316 
317 static void make_opt(struct option *l, const struct ibdiag_opt *o,
318 		     const struct ibdiag_opt *map[])
319 {
320 	l->name = o->name;
321 	l->has_arg = o->has_arg;
322 	l->flag = NULL;
323 	l->val = o->letter;
324 	if (!map[l->val])
325 		map[l->val] = o;
326 }
327 
328 static struct option *make_long_opts(const char *exclude_str,
329 				     const struct ibdiag_opt *custom_opts,
330 				     const struct ibdiag_opt *map[])
331 {
332 	struct option *long_opts, *l;
333 	const struct ibdiag_opt *o;
334 	unsigned n = 0;
335 
336 	if (custom_opts)
337 		for (o = custom_opts; o->name; o++)
338 			n++;
339 
340 	long_opts = malloc((sizeof(common_opts) / sizeof(common_opts[0]) + n) *
341 			   sizeof(*long_opts));
342 	if (!long_opts)
343 		return NULL;
344 
345 	l = long_opts;
346 
347 	if (custom_opts)
348 		for (o = custom_opts; o->name; o++)
349 			make_opt(l++, o, map);
350 
351 	for (o = common_opts; o->name; o++) {
352 		if (exclude_str && strchr(exclude_str, o->letter))
353 			continue;
354 		make_opt(l++, o, map);
355 	}
356 
357 	memset(l, 0, sizeof(*l));
358 
359 	return long_opts;
360 }
361 
362 static void make_str_opts(const struct option *o, char *p, unsigned size)
363 {
364 	unsigned i, n = 0;
365 
366 	for (n = 0; o->name && n + 2 + o->has_arg < size; o++) {
367 		p[n++] = (char)o->val;
368 		for (i = 0; i < (unsigned)o->has_arg; i++)
369 			p[n++] = ':';
370 	}
371 	p[n] = '\0';
372 }
373 
374 int ibdiag_process_opts(int argc, char *const argv[], void *cxt,
375 			const char *exclude_common_str,
376 			const struct ibdiag_opt custom_opts[],
377 			int (*custom_handler) (void *cxt, int val,
378 					       char *optarg),
379 			const char *usage_args, const char *usage_examples[])
380 {
381 	char str_opts[1024];
382 	const struct ibdiag_opt *o;
383 
384 	prog_name = argv[0];
385 	prog_args = usage_args;
386 	prog_examples = usage_examples;
387 
388 	if (long_opts)
389 		free(long_opts);
390 
391 	long_opts = make_long_opts(exclude_common_str, custom_opts, opts_map);
392 	if (!long_opts)
393 		return -1;
394 
395 	read_ibdiag_config(IBDIAG_CONFIG_GENERAL);
396 
397 	make_str_opts(long_opts, str_opts, sizeof(str_opts));
398 
399 	while (1) {
400 		int ch = getopt_long(argc, argv, str_opts, long_opts, NULL);
401 		if (ch == -1)
402 			break;
403 		o = opts_map[ch];
404 		if (!o)
405 			ibdiag_show_usage();
406 		if (custom_handler) {
407 			if (custom_handler(cxt, ch, optarg) &&
408 			    process_opt(ch, optarg))
409 				ibdiag_show_usage();
410 		} else if (process_opt(ch, optarg))
411 			ibdiag_show_usage();
412 	}
413 
414 	return 0;
415 }
416 
417 void ibexit(const char *fn, char *msg, ...)
418 {
419 	char buf[512];
420 	va_list va;
421 	int n;
422 
423 	va_start(va, msg);
424 	n = vsprintf(buf, msg, va);
425 	va_end(va);
426 	buf[n] = 0;
427 
428 	if (ibdebug)
429 		printf("%s: iberror: [pid %d] %s: failed: %s\n",
430 		       prog_name ? prog_name : "", getpid(), fn, buf);
431 	else
432 		printf("%s: iberror: failed: %s\n",
433 		       prog_name ? prog_name : "", buf);
434 
435 	exit(-1);
436 }
437 
438 char *
439 conv_cnt_human_readable(uint64_t val64, float *val, int data)
440 {
441 	uint64_t tmp = val64;
442 	int ui = 0;
443 	int div = 1;
444 
445 	tmp /= 1024;
446 	while (tmp) {
447 		ui++;
448 		tmp /= 1024;
449 		div *= 1024;
450 	}
451 
452 	*val = (float)(val64);
453 	if (data) {
454 		*val *= 4;
455 		if (*val/div > 1024) {
456 			ui++;
457 			div *= 1024;
458 		}
459 	}
460 	*val /= div;
461 
462 	if (data) {
463 		switch (ui) {
464 			case 0:
465 				return ("B");
466 			case 1:
467 				return ("KB");
468 			case 2:
469 				return ("MB");
470 			case 3:
471 				return ("GB");
472 			case 4:
473 				return ("TB");
474 			case 5:
475 				return ("PB");
476 			case 6:
477 				return ("EB");
478 			default:
479 				return ("");
480 		}
481 	} else {
482 		switch (ui) {
483 			case 0:
484 				return ("");
485 			case 1:
486 				return ("K");
487 			case 2:
488 				return ("M");
489 			case 3:
490 				return ("G");
491 			case 4:
492 				return ("T");
493 			case 5:
494 				return ("P");
495 			case 6:
496 				return ("E");
497 			default:
498 				return ("");
499 		}
500 	}
501 	return ("");
502 }
503 
504 int is_port_info_extended_supported(ib_portid_t * dest, int port,
505 				    struct ibmad_port *srcport)
506 {
507 	uint8_t data[IB_SMP_DATA_SIZE] = { 0 };
508 	uint32_t cap_mask;
509 	uint16_t cap_mask2;
510 
511 	if (!smp_query_via(data, dest, IB_ATTR_PORT_INFO, port, 0, srcport))
512 		IBEXIT("port info query failed");
513 
514 	mad_decode_field(data, IB_PORT_CAPMASK_F, &cap_mask);
515 	if (cap_mask & CL_NTOH32(IB_PORT_CAP_HAS_CAP_MASK2)) {
516 		mad_decode_field(data, IB_PORT_CAPMASK2_F, &cap_mask2);
517 		if (!(cap_mask2 &
518 		      CL_NTOH16(IB_PORT_CAP2_IS_PORT_INFO_EXT_SUPPORTED))) {
519 			IBWARN("port info capability mask2 = 0x%x doesn't"
520 			       " indicate PortInfoExtended support", cap_mask2);
521 			return 0;
522 		}
523 	} else {
524 		IBWARN("port info capability mask2 not supported");
525 		return 0;
526 	}
527 
528 	return 1;
529 }
530 
531 int is_mlnx_ext_port_info_supported(uint32_t vendorid,
532 				    uint16_t devid)
533 {
534 	if (ibd_ibnetdisc_flags & IBND_CONFIG_MLX_EPI) {
535 
536 		if ((devid >= 0xc738 && devid <= 0xc73b) || devid == 0xcb20 || devid == 0xcf08 ||
537 		    ((vendorid == 0x119f) &&
538 		     /* Bull SwitchX */
539 		     (devid == 0x1b02 || devid == 0x1b50 ||
540 		      /* Bull SwitchIB and SwitchIB2 */
541 		      devid == 0x1ba0 ||
542 		      (devid >= 0x1bd0 && devid <= 0x1bd5))))
543 			return 1;
544 		if ((devid >= 0x1003 && devid <= 0x1017) ||
545 		    ((vendorid == 0x119f) &&
546 		     /* Bull ConnectX3 */
547 		     (devid == 0x1b33 || devid == 0x1b73 ||
548 		      devid == 0x1b40 || devid == 0x1b41 ||
549 		      devid == 0x1b60 || devid == 0x1b61 ||
550 		      /* Bull ConnectIB */
551 		      devid == 0x1b83 ||
552 		      devid == 0x1b93 || devid == 0x1b94 ||
553 		      /* Bull ConnectX4 */
554 		      devid == 0x1bb4 || devid == 0x1bb5 ||
555 		      devid == 0x1bc4)))
556 			return 1;
557 	}
558 
559 	return 0;
560 }
561 
562 /** =========================================================================
563  * Resolve the SM portid using the umad layer rather than using
564  * ib_resolve_smlid_via which requires a PortInfo query on the local port.
565  */
566 int resolve_sm_portid(char *ca_name, uint8_t portnum, ib_portid_t *sm_id)
567 {
568 	umad_port_t port;
569 	int rc;
570 
571 	if (!sm_id)
572 		return (-1);
573 
574 	if ((rc = umad_get_port(ca_name, portnum, &port)) < 0)
575 		return rc;
576 
577 	memset(sm_id, 0, sizeof(*sm_id));
578 	sm_id->lid = port.sm_lid;
579 	sm_id->sl = port.sm_sl;
580 
581 	umad_release_port(&port);
582 
583 	return 0;
584 }
585 
586 /** =========================================================================
587  * Resolve local CA characteristics using the umad layer rather than using
588  * ib_resolve_self_via which requires SMP queries on the local port.
589  */
590 int resolve_self(char *ca_name, uint8_t ca_port, ib_portid_t *portid,
591 		 int *portnum, ibmad_gid_t *gid)
592 {
593 	umad_port_t port;
594 	uint64_t prefix, guid;
595 	int rc;
596 
597 	if (!(portid || portnum || gid))
598 		return (-1);
599 
600 	if ((rc = umad_get_port(ca_name, ca_port, &port)) < 0)
601 		return rc;
602 
603 	if (portid) {
604 		memset(portid, 0, sizeof(*portid));
605 		portid->lid = port.base_lid;
606 		portid->sl = port.sm_sl;
607 	}
608 	if (portnum)
609 		*portnum = port.portnum;
610 	if (gid) {
611 		memset(gid, 0, sizeof(*gid));
612 		prefix = cl_ntoh64(port.gid_prefix);
613 		guid = cl_ntoh64(port.port_guid);
614 		mad_encode_field(*gid, IB_GID_PREFIX_F, &prefix);
615 		mad_encode_field(*gid, IB_GID_GUID_F, &guid);
616 	}
617 
618 	umad_release_port(&port);
619 
620 	return 0;
621 }
622 
623 int resolve_gid(char *ca_name, uint8_t ca_port, ib_portid_t * portid,
624 		ibmad_gid_t gid, ib_portid_t * sm_id,
625 		const struct ibmad_port *srcport)
626 {
627 	ib_portid_t sm_portid;
628 	char buf[IB_SA_DATA_SIZE] = { 0 };
629 
630 	if (!sm_id) {
631 		sm_id = &sm_portid;
632 		if (resolve_sm_portid(ca_name, ca_port, sm_id) < 0)
633 			return -1;
634 	}
635 
636 	if ((portid->lid =
637 	     ib_path_query_via(srcport, gid, gid, sm_id, buf)) < 0)
638 		return -1;
639 
640 	return 0;
641 }
642 
643 int resolve_guid(char *ca_name, uint8_t ca_port, ib_portid_t *portid,
644 		 uint64_t *guid, ib_portid_t *sm_id,
645 		 const struct ibmad_port *srcport)
646 {
647 	ib_portid_t sm_portid;
648 	uint8_t buf[IB_SA_DATA_SIZE] = { 0 };
649 	uint64_t prefix;
650 	ibmad_gid_t selfgid;
651 
652 	if (!sm_id) {
653 		sm_id = &sm_portid;
654 		if (resolve_sm_portid(ca_name, ca_port, sm_id) < 0)
655 			return -1;
656 	}
657 
658 	if (resolve_self(ca_name, ca_port, NULL, NULL, &selfgid) < 0)
659 		return -1;
660 
661 	memcpy(&prefix, portid->gid, sizeof(prefix));
662 	if (!prefix)
663 		mad_set_field64(portid->gid, 0, IB_GID_PREFIX_F,
664 				IB_DEFAULT_SUBN_PREFIX);
665 	if (guid)
666 		mad_set_field64(portid->gid, 0, IB_GID_GUID_F, *guid);
667 
668 	if ((portid->lid =
669 	     ib_path_query_via(srcport, selfgid, portid->gid, sm_id, buf)) < 0)
670 		return -1;
671 
672 	mad_decode_field(buf, IB_SA_PR_SL_F, &portid->sl);
673 	return 0;
674 }
675 
676 /*
677  * Callers of this function should ensure their ibmad_port has been opened with
678  * IB_SA_CLASS as this function may require the SA to resolve addresses.
679  */
680 int resolve_portid_str(char *ca_name, uint8_t ca_port, ib_portid_t * portid,
681 		       char *addr_str, enum MAD_DEST dest_type,
682 		       ib_portid_t *sm_id, const struct ibmad_port *srcport)
683 {
684 	ibmad_gid_t gid;
685 	uint64_t guid;
686 	int lid;
687 	char *routepath;
688 	ib_portid_t selfportid = { 0 };
689 	int selfport = 0;
690 
691 	memset(portid, 0, sizeof *portid);
692 
693 	switch (dest_type) {
694 	case IB_DEST_LID:
695 		lid = strtol(addr_str, 0, 0);
696 		if (!IB_LID_VALID(lid))
697 			return -1;
698 		return ib_portid_set(portid, lid, 0, 0);
699 
700 	case IB_DEST_DRPATH:
701 		if (str2drpath(&portid->drpath, addr_str, 0, 0) < 0)
702 			return -1;
703 		return 0;
704 
705 	case IB_DEST_GUID:
706 		if (!(guid = strtoull(addr_str, 0, 0)))
707 			return -1;
708 
709 		/* keep guid in portid? */
710 		return resolve_guid(ca_name, ca_port, portid, &guid, sm_id,
711 				    srcport);
712 
713 	case IB_DEST_DRSLID:
714 		lid = strtol(addr_str, &routepath, 0);
715 		routepath++;
716 		if (!IB_LID_VALID(lid))
717 			return -1;
718 		ib_portid_set(portid, lid, 0, 0);
719 
720 		/* handle DR parsing and set DrSLID to local lid */
721 		if (resolve_self(ca_name, ca_port, &selfportid, &selfport,
722 				 NULL) < 0)
723 			return -1;
724 		if (str2drpath(&portid->drpath, routepath, selfportid.lid, 0) <
725 		    0)
726 			return -1;
727 		return 0;
728 
729 	case IB_DEST_GID:
730 		if (inet_pton(AF_INET6, addr_str, &gid) <= 0)
731 			return -1;
732 		return resolve_gid(ca_name, ca_port, portid, gid, sm_id,
733 				   srcport);
734 	default:
735 		IBWARN("bad dest_type %d", dest_type);
736 	}
737 
738 	return -1;
739 }
740 
741 static unsigned int get_max_width(unsigned int num)
742 {
743 	unsigned r = 0;			/* 1x */
744 
745 	if (num & 8)
746 		r = 3;			/* 12x */
747 	else {
748 		if (num & 4)
749 			r = 2;		/* 8x */
750 		else if (num & 2)
751 			r = 1;		/* 4x */
752 		else if (num & 0x10)
753 			r = 4;		/* 2x */
754 	}
755 
756         return (1 << r);
757 }
758 
759 static unsigned int get_max(unsigned int num)
760 {
761 	unsigned r = 0;		// r will be lg(num)
762 
763 	while (num >>= 1)	// unroll for more speed...
764 		r++;
765 
766 	return (1 << r);
767 }
768 
769 void get_max_msg(char *width_msg, char *speed_msg, int msg_size, ibnd_port_t * port)
770 {
771 	char buf[64];
772 	uint32_t max_speed = 0;
773 	uint32_t cap_mask, rem_cap_mask, fdr10;
774 	uint8_t *info = NULL;
775 
776 	uint32_t max_width = get_max_width(mad_get_field(port->info, 0,
777 						   IB_PORT_LINK_WIDTH_SUPPORTED_F)
778 				     & mad_get_field(port->remoteport->info, 0,
779 						     IB_PORT_LINK_WIDTH_SUPPORTED_F));
780 	if ((max_width & mad_get_field(port->info, 0,
781 				       IB_PORT_LINK_WIDTH_ACTIVE_F)) == 0)
782 		// we are not at the max supported width
783 		// print what we could be at.
784 		snprintf(width_msg, msg_size, "Could be %s",
785 			 mad_dump_val(IB_PORT_LINK_WIDTH_ACTIVE_F,
786 				      buf, 64, &max_width));
787 
788 	if (port->node->type == IB_NODE_SWITCH) {
789 		if (port->node->ports[0])
790 			info = (uint8_t *)&port->node->ports[0]->info;
791 	}
792 	else
793 		info = (uint8_t *)&port->info;
794 
795 	if (info)
796 		cap_mask = mad_get_field(info, 0, IB_PORT_CAPMASK_F);
797 	else
798 		cap_mask = 0;
799 
800 	info = NULL;
801 	if (port->remoteport->node->type == IB_NODE_SWITCH) {
802 		if (port->remoteport->node->ports[0])
803 			info = (uint8_t *)&port->remoteport->node->ports[0]->info;
804 	} else
805 		info = (uint8_t *)&port->remoteport->info;
806 
807 	if (info)
808 		rem_cap_mask = mad_get_field(info, 0, IB_PORT_CAPMASK_F);
809 	else
810 		rem_cap_mask = 0;
811 	if (cap_mask & CL_NTOH32(IB_PORT_CAP_HAS_EXT_SPEEDS) &&
812 	    rem_cap_mask & CL_NTOH32(IB_PORT_CAP_HAS_EXT_SPEEDS))
813 		goto check_ext_speed;
814 check_fdr10_supp:
815 	fdr10 = (mad_get_field(port->ext_info, 0,
816 			       IB_MLNX_EXT_PORT_LINK_SPEED_SUPPORTED_F) & FDR10)
817 		&& (mad_get_field(port->remoteport->ext_info, 0,
818 				  IB_MLNX_EXT_PORT_LINK_SPEED_SUPPORTED_F) & FDR10);
819 	if (fdr10)
820 		goto check_fdr10_active;
821 
822 	max_speed = get_max(mad_get_field(port->info, 0,
823 					  IB_PORT_LINK_SPEED_SUPPORTED_F)
824 			    & mad_get_field(port->remoteport->info, 0,
825 					    IB_PORT_LINK_SPEED_SUPPORTED_F));
826 	if ((max_speed & mad_get_field(port->info, 0,
827 				       IB_PORT_LINK_SPEED_ACTIVE_F)) == 0)
828 		// we are not at the max supported speed
829 		// print what we could be at.
830 		snprintf(speed_msg, msg_size, "Could be %s",
831 			 mad_dump_val(IB_PORT_LINK_SPEED_ACTIVE_F,
832 				      buf, 64, &max_speed));
833 	return;
834 
835 check_ext_speed:
836 	if (mad_get_field(port->info, 0,
837 			  IB_PORT_LINK_SPEED_EXT_SUPPORTED_F) == 0 ||
838 	    mad_get_field(port->remoteport->info, 0,
839 			  IB_PORT_LINK_SPEED_EXT_SUPPORTED_F) == 0)
840 		goto check_fdr10_supp;
841 	max_speed = get_max(mad_get_field(port->info, 0,
842 					  IB_PORT_LINK_SPEED_EXT_SUPPORTED_F)
843 			    & mad_get_field(port->remoteport->info, 0,
844 					    IB_PORT_LINK_SPEED_EXT_SUPPORTED_F));
845 	if ((max_speed & mad_get_field(port->info, 0,
846 				       IB_PORT_LINK_SPEED_EXT_ACTIVE_F)) == 0)
847 		// we are not at the max supported extended speed
848 		// print what we could be at.
849 		snprintf(speed_msg, msg_size, "Could be %s",
850 			 mad_dump_val(IB_PORT_LINK_SPEED_EXT_ACTIVE_F,
851 				      buf, 64, &max_speed));
852 	return;
853 
854 check_fdr10_active:
855 	if ((mad_get_field(port->ext_info, 0,
856 			   IB_MLNX_EXT_PORT_LINK_SPEED_ACTIVE_F) & FDR10) == 0) {
857 		/* Special case QDR to try to avoid confusion with FDR10 */
858 		if (mad_get_field(port->info, 0, IB_PORT_LINK_SPEED_ACTIVE_F) == 4)	/* QDR (10.0 Gbps) */
859 			snprintf(speed_msg, msg_size,
860 				 "Could be FDR10 (Found link at QDR but expected speed is FDR10)");
861 		else
862 			snprintf(speed_msg, msg_size, "Could be FDR10");
863 	}
864 }
865 
866 int vsnprint_field(char *buf, size_t n, enum MAD_FIELDS f, int spacing,
867 		   const char *format, va_list va_args)
868 {
869 	int len, i, ret;
870 
871 	len = strlen(mad_field_name(f));
872 	if (len + 2 > n || spacing + 1 > n)
873 		return 0;
874 
875 	strncpy(buf, mad_field_name(f), n);
876 	buf[len] = ':';
877 	for (i = len+1; i < spacing+1; i++) {
878 		buf[i] = '.';
879 	}
880 
881 	ret = vsnprintf(&buf[spacing+1], n - spacing, format, va_args);
882 	if (ret >= n - spacing)
883 		buf[n] = '\0';
884 
885 	return ret + spacing;
886 }
887 
888 int snprint_field(char *buf, size_t n, enum MAD_FIELDS f, int spacing,
889 		  const char *format, ...)
890 {
891 	va_list val;
892 	int ret;
893 
894 	va_start(val, format);
895 	ret = vsnprint_field(buf, n, f, spacing, format, val);
896 	va_end(val);
897 
898 	return ret;
899 }
900 
901 void dump_portinfo(void *pi, int tabs)
902 {
903 	int field, i;
904 	char val[64];
905 	char buf[1024];
906 
907 	for (field = IB_PORT_FIRST_F; field < IB_PORT_LAST_F; field++) {
908 		for (i=0;i<tabs;i++)
909 			printf("\t");
910 		if (field == IB_PORT_MKEY_F && show_keys == 0) {
911 			snprint_field(buf, 1024, field, 32, NOT_DISPLAYED_STR);
912 		} else {
913 			mad_decode_field(pi, field, val);
914 			if (!mad_dump_field(field, buf, 1024, val))
915 				return;
916 		}
917 		printf("%s\n", buf);
918 	}
919 
920 	for (field = IB_PORT_CAPMASK2_F;
921 	     field < IB_PORT_LINK_SPEED_EXT_LAST_F; field++) {
922 		for (i=0;i<tabs;i++)
923 			printf("\t");
924 		mad_decode_field(pi, field, val);
925 		if (!mad_dump_field(field, buf, 1024, val))
926 			return;
927 		printf("%s\n", buf);
928 	}
929 }
930 
931 op_fn_t *match_op(const match_rec_t match_tbl[], char *name)
932 {
933 	const match_rec_t *r;
934 	for (r = match_tbl; r->name; r++)
935 		if (!strcasecmp(r->name, name) ||
936 		    (r->alias && !strcasecmp(r->alias, name)))
937 			return r->fn;
938 	return NULL;
939 }
940