ibroute.c revision 275330
1/* 2 * Copyright (c) 2004-2008 Voltaire Inc. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * OpenIB.org BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and/or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 * 32 */ 33 34#if HAVE_CONFIG_H 35# include <config.h> 36#endif /* HAVE_CONFIG_H */ 37 38#include <stdio.h> 39#include <stdlib.h> 40#include <unistd.h> 41#include <stdarg.h> 42#include <time.h> 43#include <string.h> 44#include <inttypes.h> 45#include <getopt.h> 46#include <netinet/in.h> 47#include <ctype.h> 48 49#include <infiniband/common.h> 50#include <infiniband/umad.h> 51#include <infiniband/mad.h> 52#include <complib/cl_nodenamemap.h> 53 54#include "ibdiag_common.h" 55 56static int dest_type = IB_DEST_LID; 57static int brief; 58static int verbose; 59static int dump_all; 60 61char *argv0 = "ibroute"; 62 63/*******************************************/ 64 65char * 66check_switch(ib_portid_t *portid, int *nports, uint64_t *guid, 67 uint8_t *sw, char *nd) 68{ 69 uint8_t ni[IB_SMP_DATA_SIZE] = {0}; 70 int type; 71 72 DEBUG("checking node type"); 73 if (!smp_query(ni, portid, IB_ATTR_NODE_INFO, 0, 0)) { 74 xdump(stderr, "nodeinfo\n", ni, sizeof ni); 75 return "node info failed: valid addr?"; 76 } 77 78 if (!smp_query(nd, portid, IB_ATTR_NODE_DESC, 0, 0)) 79 return "node desc failed"; 80 81 mad_decode_field(ni, IB_NODE_TYPE_F, &type); 82 if (type != IB_NODE_SWITCH) 83 return "not a switch"; 84 85 DEBUG("Gathering information about switch"); 86 mad_decode_field(ni, IB_NODE_NPORTS_F, nports); 87 mad_decode_field(ni, IB_NODE_GUID_F, guid); 88 89 if (!smp_query(sw, portid, IB_ATTR_SWITCH_INFO, 0, 0)) 90 return "switch info failed: is a switch node?"; 91 92 return 0; 93} 94 95#define IB_MLIDS_IN_BLOCK (IB_SMP_DATA_SIZE/2) 96 97int 98dump_mlid(char *str, int strlen, int mlid, int nports, 99 uint16_t mft[16][IB_MLIDS_IN_BLOCK]) 100{ 101 uint16_t mask; 102 int i, chunk, bit; 103 int nonzero = 0; 104 105 if (brief) { 106 int n = 0, chunks = ALIGN(nports + 1, 16) / 16; 107 for (i = 0; i < chunks; i++) { 108 mask = ntohs(mft[i][mlid%IB_MLIDS_IN_BLOCK]); 109 if (mask) 110 nonzero++; 111 n += snprintf(str + n, strlen - n, "%04hx", mask); 112 if (n >= strlen) { 113 n = strlen; 114 break; 115 } 116 } 117 if (!nonzero && !dump_all) { 118 str[0] = 0; 119 return 0; 120 } 121 return n; 122 } 123 for (i = 0; i <= nports; i++) { 124 chunk = i / 16; 125 bit = i % 16; 126 127 mask = ntohs(mft[chunk][mlid%IB_MLIDS_IN_BLOCK]); 128 if (mask) 129 nonzero++; 130 str[i*2] = (mask & (1 << bit)) ? 'x' : ' '; 131 str[i*2+1] = ' '; 132 } 133 if (!nonzero && !dump_all) { 134 str[0] = 0; 135 return 0; 136 } 137 str[i*2] = 0; 138 return i * 2; 139} 140 141uint16_t mft[16][IB_MLIDS_IN_BLOCK]; 142 143char * 144dump_multicast_tables(ib_portid_t *portid, int startlid, int endlid) 145{ 146 char nd[IB_SMP_DATA_SIZE] = {0}; 147 uint8_t sw[IB_SMP_DATA_SIZE] = {0}; 148 char str[512]; 149 char *s; 150 uint64_t nodeguid; 151 uint32_t mod; 152 int block, i, j, e, nports, cap, chunks; 153 int n = 0, startblock, lastblock; 154 155 if ((s = check_switch(portid, &nports, &nodeguid, sw, nd))) 156 return s; 157 158 mad_decode_field(sw, IB_SW_MCAST_FDB_CAP_F, &cap); 159 160 if (!endlid || endlid > IB_MIN_MCAST_LID + cap - 1) 161 endlid = IB_MIN_MCAST_LID + cap - 1; 162 163 if (!startlid) 164 startlid = IB_MIN_MCAST_LID; 165 166 if (startlid < IB_MIN_MCAST_LID) { 167 IBWARN("illegal start mlid %x, set to %x", startlid, IB_MIN_MCAST_LID); 168 startlid = IB_MIN_MCAST_LID; 169 } 170 171 if (endlid > IB_MAX_MCAST_LID) { 172 IBWARN("illegal end mlid %x, truncate to %x", endlid, IB_MAX_MCAST_LID); 173 endlid = IB_MAX_MCAST_LID; 174 } 175 176 printf("Multicast mlids [0x%x-0x%x] of switch %s guid 0x%016" PRIx64 " (%s):\n", 177 startlid, endlid, portid2str(portid), nodeguid, clean_nodedesc(nd)); 178 179 if (brief) 180 printf(" MLid Port Mask\n"); 181 else { 182 if (nports > 9) { 183 for (i = 0, s = str; i <= nports; i++) { 184 *s++ = (i%10) ? ' ' : '0' + i/10; 185 *s++ = ' '; 186 } 187 *s = 0; 188 printf(" %s\n", str); 189 } 190 for (i = 0, s = str; i <= nports; i++) 191 s += sprintf(s, "%d ", i%10); 192 printf(" Ports: %s\n", str); 193 printf(" MLid\n"); 194 } 195 if (verbose) 196 printf("Switch muticast mlids capability is 0x%d\n", cap); 197 198 chunks = ALIGN(nports + 1, 16) / 16; 199 200 startblock = startlid / IB_MLIDS_IN_BLOCK; 201 lastblock = endlid / IB_MLIDS_IN_BLOCK; 202 for (block = startblock; block <= lastblock; block++) { 203 for (j = 0; j < chunks; j++) { 204 mod = (block - IB_MIN_MCAST_LID/IB_MLIDS_IN_BLOCK) | (j << 28); 205 206 DEBUG("reading block %x chunk %d mod %x", block, j, mod); 207 if (!smp_query(mft + j, portid, IB_ATTR_MULTICASTFORWTBL, mod, 0)) 208 return "multicast forwarding table get failed"; 209 } 210 211 i = block * IB_MLIDS_IN_BLOCK; 212 e = i + IB_MLIDS_IN_BLOCK; 213 if (i < startlid) 214 i = startlid; 215 if (e > endlid + 1) 216 e = endlid + 1; 217 218 for (; i < e; i++) { 219 if (dump_mlid(str, sizeof str, i, nports, mft) == 0) 220 continue; 221 printf("0x%04x %s\n", i, str); 222 n++; 223 } 224 } 225 226 printf("%d %smlids dumped \n", n, dump_all ? "" : "valid "); 227 return 0; 228} 229 230int 231dump_lid(char *str, int strlen, int lid, int valid) 232{ 233 char nd[IB_SMP_DATA_SIZE] = {0}; 234 uint8_t ni[IB_SMP_DATA_SIZE] = {0}; 235 uint8_t pi[IB_SMP_DATA_SIZE] = {0}; 236 ib_portid_t lidport = {0}; 237 static int last_port_lid, base_port_lid; 238 char ntype[50], sguid[30], desc[64]; 239 static uint64_t portguid; 240 int baselid, lmc, type; 241 242 if (brief) { 243 str[0] = 0; 244 return 0; 245 } 246 247 if (lid <= last_port_lid) { 248 if (!valid) 249 return snprintf(str, strlen, ": (path #%d - illegal port)", 250 lid - base_port_lid); 251 else if (!portguid) 252 return snprintf(str, strlen, 253 ": (path #%d out of %d)", 254 lid - base_port_lid + 1, 255 last_port_lid - base_port_lid + 1); 256 else { 257 return snprintf(str, strlen, 258 ": (path #%d out of %d: portguid %s)", 259 lid - base_port_lid + 1, 260 last_port_lid - base_port_lid + 1, 261 mad_dump_val(IB_NODE_PORT_GUID_F, sguid, sizeof sguid, &portguid)); 262 } 263 } 264 265 if (!valid) 266 return snprintf(str, strlen, ": (illegal port)"); 267 268 portguid = 0; 269 lidport.lid = lid; 270 271 if (!smp_query(nd, &lidport, IB_ATTR_NODE_DESC, 0, 100) || 272 !smp_query(pi, &lidport, IB_ATTR_PORT_INFO, 0, 100) || 273 !smp_query(ni, &lidport, IB_ATTR_NODE_INFO, 0, 100)) 274 return snprintf(str, strlen, ": (unknown node and type)"); 275 276 mad_decode_field(ni, IB_NODE_PORT_GUID_F, &portguid); 277 mad_decode_field(ni, IB_NODE_TYPE_F, &type); 278 279 mad_decode_field(pi, IB_PORT_LID_F, &baselid); 280 mad_decode_field(pi, IB_PORT_LMC_F, &lmc); 281 282 if (lmc > 0) { 283 base_port_lid = baselid; 284 last_port_lid = baselid + (1 << lmc) - 1; 285 } 286 287 return snprintf(str, strlen, ": (%s portguid %s: %s)", 288 mad_dump_val(IB_NODE_TYPE_F, ntype, sizeof ntype, &type), 289 mad_dump_val(IB_NODE_PORT_GUID_F, sguid, sizeof sguid, &portguid), 290 mad_dump_val(IB_NODE_DESC_F, desc, sizeof desc, clean_nodedesc(nd))); 291} 292 293char * 294dump_unicast_tables(ib_portid_t *portid, int startlid, int endlid) 295{ 296 char lft[IB_SMP_DATA_SIZE]; 297 char nd[IB_SMP_DATA_SIZE]; 298 uint8_t sw[IB_SMP_DATA_SIZE]; 299 char str[200], *s; 300 uint64_t nodeguid; 301 int block, i, e, nports, top; 302 int n = 0, startblock, endblock; 303 304 if ((s = check_switch(portid, &nports, &nodeguid, sw, nd))) 305 return s; 306 307 mad_decode_field(sw, IB_SW_LINEAR_FDB_TOP_F, &top); 308 309 if (!endlid || endlid > top) 310 endlid = top; 311 312 if (endlid > IB_MAX_UCAST_LID) { 313 IBWARN("ilegal lft top %d, truncate to %d", endlid, IB_MAX_UCAST_LID); 314 endlid = IB_MAX_UCAST_LID; 315 } 316 317 printf("Unicast lids [0x%x-0x%x] of switch %s guid 0x%016" PRIx64 " (%s):\n", 318 startlid, endlid, portid2str(portid), nodeguid, clean_nodedesc(nd)); 319 320 DEBUG("Switch top is 0x%x\n", top); 321 322 printf(" Lid Out Destination\n"); 323 printf(" Port Info \n"); 324 startblock = startlid / IB_SMP_DATA_SIZE; 325 endblock = ALIGN(endlid, IB_SMP_DATA_SIZE) / IB_SMP_DATA_SIZE; 326 for (block = startblock; block <= endblock; block++) { 327 DEBUG("reading block %d", block); 328 if (!smp_query(lft, portid, IB_ATTR_LINEARFORWTBL, block, 0)) 329 return "linear forwarding table get failed"; 330 i = block * IB_SMP_DATA_SIZE; 331 e = i + IB_SMP_DATA_SIZE; 332 if (i < startlid) 333 i = startlid; 334 if (e > endlid + 1) 335 e = endlid + 1; 336 337 for (;i < e; i++) { 338 unsigned outport = lft[i % IB_SMP_DATA_SIZE]; 339 unsigned valid = (outport <= nports); 340 341 if (!valid && !dump_all) 342 continue; 343 dump_lid(str, sizeof str, i, valid); 344 printf("0x%04x %03u %s\n", i, outport & 0xff, str); 345 n++; 346 } 347 } 348 349 printf("%d %slids dumped \n", n, dump_all ? "" : "valid "); 350 return 0; 351} 352 353void 354usage(void) 355{ 356 char *basename; 357 358 if (!(basename = strrchr(argv0, '/'))) 359 basename = argv0; 360 else 361 basename++; 362 363 fprintf(stderr, "Usage: %s [-d(ebug)] -a(ll) -n(o_dests) -v(erbose) -D(irect) -G(uid) -M(ulticast) -s smlid -V(ersion) -C ca_name -P ca_port " 364 "-t(imeout) timeout_ms] [<dest dr_path|lid|guid> [<startlid> [<endlid>]]]\n", 365 basename); 366 fprintf(stderr, "\n\tUnicast examples:\n"); 367 fprintf(stderr, "\t\t%s 4\t# dump all lids with valid out ports of switch with lid 4\n", basename); 368 fprintf(stderr, "\t\t%s -a 4\t# same, but dump all lids, even with invalid out ports\n", basename); 369 fprintf(stderr, "\t\t%s -n 4\t# simple dump format - no destination resolving\n", basename); 370 fprintf(stderr, "\t\t%s 4 10\t# dump lids starting from 10\n", basename); 371 fprintf(stderr, "\t\t%s 4 0x10 0x20\t# dump lid range\n", basename); 372 fprintf(stderr, "\t\t%s -G 0x08f1040023\t# resolve switch by GUID\n", basename); 373 fprintf(stderr, "\t\t%s -D 0,1\t# resolve switch by direct path\n", basename); 374 375 fprintf(stderr, "\n\tMulticast examples:\n"); 376 fprintf(stderr, "\t\t%s -M 4\t# dump all non empty mlids of switch with lid 4\n", basename); 377 fprintf(stderr, "\t\t%s -M 4 0xc010 0xc020\t# same, but with range\n", basename); 378 fprintf(stderr, "\t\t%s -M -n 4\t# simple dump format\n", basename); 379 exit(-1); 380} 381 382int 383main(int argc, char **argv) 384{ 385 int mgmt_classes[3] = {IB_SMI_CLASS, IB_SMI_DIRECT_CLASS, IB_SA_CLASS}; 386 ib_portid_t portid = {0}; 387 ib_portid_t *sm_id = 0, sm_portid = {0}; 388 int timeout; 389 int multicast = 0, startlid = 0, endlid = 0; 390 char *err; 391 char *ca = 0; 392 int ca_port = 0; 393 394 static char const str_opts[] = "C:P:t:s:danvDGMVhu"; 395 static const struct option long_opts[] = { 396 { "C", 1, 0, 'C'}, 397 { "P", 1, 0, 'P'}, 398 { "debug", 0, 0, 'd'}, 399 { "all", 0, 0, 'a'}, 400 { "no_dests", 0, 0, 'n'}, 401 { "verbose", 0, 0, 'v'}, 402 { "Direct", 0, 0, 'D'}, 403 { "Guid", 0, 0, 'G'}, 404 { "Multicast", 0, 0, 'M'}, 405 { "timeout", 1, 0, 't'}, 406 { "s", 1, 0, 's'}, 407 { "Version", 0, 0, 'V'}, 408 { "help", 0, 0, 'h'}, 409 { "usage", 0, 0, 'u'}, 410 { } 411 }; 412 413 argv0 = argv[0]; 414 415 while (1) { 416 int ch = getopt_long(argc, argv, str_opts, long_opts, NULL); 417 if ( ch == -1 ) 418 break; 419 switch(ch) { 420 case 'C': 421 ca = optarg; 422 break; 423 case 'P': 424 ca_port = strtoul(optarg, 0, 0); 425 break; 426 case 'a': 427 dump_all++; 428 break; 429 case 'd': 430 ibdebug++; 431 break; 432 case 'D': 433 dest_type = IB_DEST_DRPATH; 434 break; 435 case 'G': 436 dest_type = IB_DEST_GUID; 437 break; 438 case 'M': 439 multicast++; 440 break; 441 case 'n': 442 brief++; 443 break; 444 case 's': 445 if (ib_resolve_portid_str(&sm_portid, optarg, IB_DEST_LID, 0) < 0) 446 IBERROR("can't resolve SM destination port %s", optarg); 447 sm_id = &sm_portid; 448 break; 449 case 't': 450 timeout = strtoul(optarg, 0, 0); 451 madrpc_set_timeout(timeout); 452 break; 453 case 'v': 454 madrpc_show_errors(1); 455 verbose++; 456 break; 457 case 'V': 458 fprintf(stderr, "%s %s\n", argv0, get_build_version() ); 459 exit(-1); 460 default: 461 usage(); 462 break; 463 } 464 } 465 argc -= optind; 466 argv += optind; 467 468 if (!argc) 469 usage(); 470 471 if (argc > 1) 472 startlid = strtoul(argv[1], 0, 0); 473 if (argc > 2) 474 endlid = strtoul(argv[2], 0, 0); 475 476 madrpc_init(ca, ca_port, mgmt_classes, 3); 477 478 if (!argc) { 479 if (ib_resolve_self(&portid, 0, 0) < 0) 480 IBERROR("can't resolve self addr"); 481 } else { 482 if (ib_resolve_portid_str(&portid, argv[0], dest_type, sm_id) < 0) 483 IBERROR("can't resolve destination port %s", argv[1]); 484 } 485 486 if (multicast) 487 err = dump_multicast_tables(&portid, startlid, endlid); 488 else 489 err = dump_unicast_tables(&portid, startlid, endlid); 490 491 if (err) 492 IBERROR("dump tables: %s", err); 493 494 exit(0); 495} 496