1 /* 2 * Copyright (c) 2005 Cisco Systems. All rights reserved. 3 * Copyright (c) 2005 Mellanox Technologies Ltd. All rights reserved. 4 * 5 * This software is available to you under a choice of one of two 6 * licenses. You may choose to be licensed under the terms of the GNU 7 * General Public License (GPL) Version 2, available from the file 8 * COPYING in the main directory of this source tree, or the 9 * OpenIB.org BSD license below: 10 * 11 * Redistribution and use in source and binary forms, with or 12 * without modification, are permitted provided that the following 13 * conditions are met: 14 * 15 * - Redistributions of source code must retain the above 16 * copyright notice, this list of conditions and the following 17 * disclaimer. 18 * 19 * - Redistributions in binary form must reproduce the above 20 * copyright notice, this list of conditions and the following 21 * disclaimer in the documentation and/or other materials 22 * provided with the distribution. 23 * 24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 31 * SOFTWARE. 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 <string.h> 42 #include <getopt.h> 43 #include <netinet/in.h> 44 #include <endian.h> 45 #include <byteswap.h> 46 47 #include <infiniband/verbs.h> 48 #include <infiniband/driver.h> 49 #include <infiniband/arch.h> 50 51 static int verbose; 52 53 static int null_gid(union ibv_gid *gid) 54 { 55 return !(gid->raw[8] | gid->raw[9] | gid->raw[10] | gid->raw[11] | 56 gid->raw[12] | gid->raw[13] | gid->raw[14] | gid->raw[15]); 57 } 58 59 static const char *guid_str(uint64_t node_guid, char *str) 60 { 61 node_guid = ntohll(node_guid); 62 sprintf(str, "%04x:%04x:%04x:%04x", 63 (unsigned) (node_guid >> 48) & 0xffff, 64 (unsigned) (node_guid >> 32) & 0xffff, 65 (unsigned) (node_guid >> 16) & 0xffff, 66 (unsigned) (node_guid >> 0) & 0xffff); 67 return str; 68 } 69 70 static const char *transport_str(enum ibv_transport_type transport) 71 { 72 switch (transport) { 73 case IBV_TRANSPORT_IB: return "InfiniBand"; 74 case IBV_TRANSPORT_IWARP: return "iWARP"; 75 default: return "invalid transport"; 76 } 77 } 78 79 static const char *port_state_str(enum ibv_port_state pstate) 80 { 81 switch (pstate) { 82 case IBV_PORT_DOWN: return "PORT_DOWN"; 83 case IBV_PORT_INIT: return "PORT_INIT"; 84 case IBV_PORT_ARMED: return "PORT_ARMED"; 85 case IBV_PORT_ACTIVE: return "PORT_ACTIVE"; 86 default: return "invalid state"; 87 } 88 } 89 90 static const char *port_phy_state_str(uint8_t phys_state) 91 { 92 switch (phys_state) { 93 case 1: return "SLEEP"; 94 case 2: return "POLLING"; 95 case 3: return "DISABLED"; 96 case 4: return "PORT_CONFIGURATION TRAINNING"; 97 case 5: return "LINK_UP"; 98 case 6: return "LINK_ERROR_RECOVERY"; 99 case 7: return "PHY TEST"; 100 default: return "invalid physical state"; 101 } 102 } 103 104 static const char *atomic_cap_str(enum ibv_atomic_cap atom_cap) 105 { 106 switch (atom_cap) { 107 case IBV_ATOMIC_NONE: return "ATOMIC_NONE"; 108 case IBV_ATOMIC_HCA: return "ATOMIC_HCA"; 109 case IBV_ATOMIC_GLOB: return "ATOMIC_GLOB"; 110 default: return "invalid atomic capability"; 111 } 112 } 113 114 static const char *mtu_str(enum ibv_mtu max_mtu) 115 { 116 switch (max_mtu) { 117 case IBV_MTU_256: return "256"; 118 case IBV_MTU_512: return "512"; 119 case IBV_MTU_1024: return "1024"; 120 case IBV_MTU_2048: return "2048"; 121 case IBV_MTU_4096: return "4096"; 122 default: return "invalid MTU"; 123 } 124 } 125 126 static const char *width_str(uint8_t width) 127 { 128 switch (width) { 129 case 1: return "1"; 130 case 2: return "4"; 131 case 4: return "8"; 132 case 8: return "12"; 133 default: return "invalid width"; 134 } 135 } 136 137 static const char *speed_str(uint8_t speed) 138 { 139 switch (speed) { 140 case 1: return "2.5 Gbps"; 141 case 2: return "5.0 Gbps"; 142 case 4: return "10.0 Gbps"; 143 default: return "invalid speed"; 144 } 145 } 146 147 static const char *vl_str(uint8_t vl_num) 148 { 149 switch (vl_num) { 150 case 1: return "1"; 151 case 2: return "2"; 152 case 3: return "4"; 153 case 4: return "8"; 154 case 5: return "15"; 155 default: return "invalid value"; 156 } 157 } 158 159 static int print_all_port_gids(struct ibv_context *ctx, uint8_t port_num, int tbl_len) 160 { 161 union ibv_gid gid; 162 int rc = 0; 163 int i; 164 165 for (i = 0; i < tbl_len; i++) { 166 rc = ibv_query_gid(ctx, port_num, i, &gid); 167 if (rc) { 168 fprintf(stderr, "Failed to query gid to port %d, index %d\n", 169 port_num, i); 170 return rc; 171 } 172 if (!null_gid(&gid)) 173 printf("\t\t\tGID[%3d]:\t\t%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x\n", 174 i, 175 gid.raw[ 0], gid.raw[ 1], 176 gid.raw[ 2], gid.raw[ 3], 177 gid.raw[ 4], gid.raw[ 5], 178 gid.raw[ 6], gid.raw[ 7], 179 gid.raw[ 8], gid.raw[ 9], 180 gid.raw[10], gid.raw[11], 181 gid.raw[12], gid.raw[13], 182 gid.raw[14], gid.raw[15]); 183 } 184 return rc; 185 } 186 187 static const char *link_layer_str(uint8_t link_layer) 188 { 189 switch (link_layer) { 190 case IBV_LINK_LAYER_UNSPECIFIED: 191 case IBV_LINK_LAYER_INFINIBAND: 192 return "IB"; 193 case IBV_LINK_LAYER_ETHERNET: 194 return "Ethernet"; 195 default: 196 return "Unknown"; 197 } 198 } 199 200 static int print_hca_cap(struct ibv_device *ib_dev, uint8_t ib_port) 201 { 202 struct ibv_context *ctx; 203 struct ibv_device_attr device_attr; 204 struct ibv_port_attr port_attr; 205 int rc = 0; 206 uint8_t port; 207 char buf[256]; 208 209 ctx = ibv_open_device(ib_dev); 210 if (!ctx) { 211 fprintf(stderr, "Failed to open device\n"); 212 rc = 1; 213 goto cleanup; 214 } 215 if (ibv_query_device(ctx, &device_attr)) { 216 fprintf(stderr, "Failed to query device props"); 217 rc = 2; 218 goto cleanup; 219 } 220 221 printf("hca_id:\t%s\n", ibv_get_device_name(ib_dev)); 222 printf("\ttransport:\t\t\t%s (%d)\n", 223 transport_str(ib_dev->transport_type), ib_dev->transport_type); 224 if (strlen(device_attr.fw_ver)) 225 printf("\tfw_ver:\t\t\t\t%s\n", device_attr.fw_ver); 226 printf("\tnode_guid:\t\t\t%s\n", guid_str(device_attr.node_guid, buf)); 227 printf("\tsys_image_guid:\t\t\t%s\n", guid_str(device_attr.sys_image_guid, buf)); 228 printf("\tvendor_id:\t\t\t0x%04x\n", device_attr.vendor_id); 229 printf("\tvendor_part_id:\t\t\t%d\n", device_attr.vendor_part_id); 230 printf("\thw_ver:\t\t\t\t0x%X\n", device_attr.hw_ver); 231 232 if (ibv_read_sysfs_file(ib_dev->ibdev_path, "board_id", buf, sizeof buf) > 0) 233 printf("\tboard_id:\t\t\t%s\n", buf); 234 235 printf("\tphys_port_cnt:\t\t\t%d\n", device_attr.phys_port_cnt); 236 237 if (verbose) { 238 printf("\tmax_mr_size:\t\t\t0x%llx\n", 239 (unsigned long long) device_attr.max_mr_size); 240 printf("\tpage_size_cap:\t\t\t0x%llx\n", 241 (unsigned long long) device_attr.page_size_cap); 242 printf("\tmax_qp:\t\t\t\t%d\n", device_attr.max_qp); 243 printf("\tmax_qp_wr:\t\t\t%d\n", device_attr.max_qp_wr); 244 printf("\tdevice_cap_flags:\t\t0x%08x\n", device_attr.device_cap_flags); 245 printf("\tmax_sge:\t\t\t%d\n", device_attr.max_sge); 246 printf("\tmax_sge_rd:\t\t\t%d\n", device_attr.max_sge_rd); 247 printf("\tmax_cq:\t\t\t\t%d\n", device_attr.max_cq); 248 printf("\tmax_cqe:\t\t\t%d\n", device_attr.max_cqe); 249 printf("\tmax_mr:\t\t\t\t%d\n", device_attr.max_mr); 250 printf("\tmax_pd:\t\t\t\t%d\n", device_attr.max_pd); 251 printf("\tmax_qp_rd_atom:\t\t\t%d\n", device_attr.max_qp_rd_atom); 252 printf("\tmax_ee_rd_atom:\t\t\t%d\n", device_attr.max_ee_rd_atom); 253 printf("\tmax_res_rd_atom:\t\t%d\n", device_attr.max_res_rd_atom); 254 printf("\tmax_qp_init_rd_atom:\t\t%d\n", device_attr.max_qp_init_rd_atom); 255 printf("\tmax_ee_init_rd_atom:\t\t%d\n", device_attr.max_ee_init_rd_atom); 256 printf("\tatomic_cap:\t\t\t%s (%d)\n", 257 atomic_cap_str(device_attr.atomic_cap), device_attr.atomic_cap); 258 printf("\tmax_ee:\t\t\t\t%d\n", device_attr.max_ee); 259 printf("\tmax_rdd:\t\t\t%d\n", device_attr.max_rdd); 260 printf("\tmax_mw:\t\t\t\t%d\n", device_attr.max_mw); 261 printf("\tmax_raw_ipv6_qp:\t\t%d\n", device_attr.max_raw_ipv6_qp); 262 printf("\tmax_raw_ethy_qp:\t\t%d\n", device_attr.max_raw_ethy_qp); 263 printf("\tmax_mcast_grp:\t\t\t%d\n", device_attr.max_mcast_grp); 264 printf("\tmax_mcast_qp_attach:\t\t%d\n", device_attr.max_mcast_qp_attach); 265 printf("\tmax_total_mcast_qp_attach:\t%d\n", 266 device_attr.max_total_mcast_qp_attach); 267 printf("\tmax_ah:\t\t\t\t%d\n", device_attr.max_ah); 268 printf("\tmax_fmr:\t\t\t%d\n", device_attr.max_fmr); 269 if (device_attr.max_fmr) 270 printf("\tmax_map_per_fmr:\t\t%d\n", device_attr.max_map_per_fmr); 271 printf("\tmax_srq:\t\t\t%d\n", device_attr.max_srq); 272 if (device_attr.max_srq) { 273 printf("\tmax_srq_wr:\t\t\t%d\n", device_attr.max_srq_wr); 274 printf("\tmax_srq_sge:\t\t\t%d\n", device_attr.max_srq_sge); 275 } 276 printf("\tmax_pkeys:\t\t\t%d\n", device_attr.max_pkeys); 277 printf("\tlocal_ca_ack_delay:\t\t%d\n", device_attr.local_ca_ack_delay); 278 } 279 280 for (port = 1; port <= device_attr.phys_port_cnt; ++port) { 281 /* if in the command line the user didn't ask for info about this port */ 282 if ((ib_port) && (port != ib_port)) 283 continue; 284 285 rc = ibv_query_port(ctx, port, &port_attr); 286 if (rc) { 287 fprintf(stderr, "Failed to query port %u props\n", port); 288 goto cleanup; 289 } 290 printf("\t\tport:\t%d\n", port); 291 printf("\t\t\tstate:\t\t\t%s (%d)\n", 292 port_state_str(port_attr.state), port_attr.state); 293 printf("\t\t\tmax_mtu:\t\t%s (%d)\n", 294 mtu_str(port_attr.max_mtu), port_attr.max_mtu); 295 printf("\t\t\tactive_mtu:\t\t%s (%d)\n", 296 mtu_str(port_attr.active_mtu), port_attr.active_mtu); 297 printf("\t\t\tsm_lid:\t\t\t%d\n", port_attr.sm_lid); 298 printf("\t\t\tport_lid:\t\t%d\n", port_attr.lid); 299 printf("\t\t\tport_lmc:\t\t0x%02x\n", port_attr.lmc); 300 printf("\t\t\tlink_layer:\t\t%s\n", link_layer_str(port_attr.link_layer)); 301 302 if (verbose) { 303 printf("\t\t\tmax_msg_sz:\t\t0x%x\n", port_attr.max_msg_sz); 304 printf("\t\t\tport_cap_flags:\t\t0x%08x\n", port_attr.port_cap_flags); 305 printf("\t\t\tmax_vl_num:\t\t%s (%d)\n", 306 vl_str(port_attr.max_vl_num), port_attr.max_vl_num); 307 printf("\t\t\tbad_pkey_cntr:\t\t0x%x\n", port_attr.bad_pkey_cntr); 308 printf("\t\t\tqkey_viol_cntr:\t\t0x%x\n", port_attr.qkey_viol_cntr); 309 printf("\t\t\tsm_sl:\t\t\t%d\n", port_attr.sm_sl); 310 printf("\t\t\tpkey_tbl_len:\t\t%d\n", port_attr.pkey_tbl_len); 311 printf("\t\t\tgid_tbl_len:\t\t%d\n", port_attr.gid_tbl_len); 312 printf("\t\t\tsubnet_timeout:\t\t%d\n", port_attr.subnet_timeout); 313 printf("\t\t\tinit_type_reply:\t%d\n", port_attr.init_type_reply); 314 printf("\t\t\tactive_width:\t\t%sX (%d)\n", 315 width_str(port_attr.active_width), port_attr.active_width); 316 printf("\t\t\tactive_speed:\t\t%s (%d)\n", 317 speed_str(port_attr.active_speed), port_attr.active_speed); 318 printf("\t\t\tphys_state:\t\t%s (%d)\n", 319 port_phy_state_str(port_attr.phys_state), port_attr.phys_state); 320 321 if (print_all_port_gids(ctx, port, port_attr.gid_tbl_len)) 322 goto cleanup; 323 } 324 printf("\n"); 325 } 326 cleanup: 327 if (ctx) 328 if (ibv_close_device(ctx)) { 329 fprintf(stderr, "Failed to close device"); 330 rc = 3; 331 } 332 return rc; 333 } 334 335 static void usage(const char *argv0) 336 { 337 printf("Usage: %s print the ca attributes\n", argv0); 338 printf("\n"); 339 printf("Options:\n"); 340 printf(" -d, --ib-dev=<dev> use IB device <dev> (default first device found)\n"); 341 printf(" -i, --ib-port=<port> use port <port> of IB device (default all ports)\n"); 342 printf(" -l, --list print only the IB devices names\n"); 343 printf(" -v, --verbose print all the attributes of the IB device(s)\n"); 344 } 345 346 int main(int argc, char *argv[]) 347 { 348 char *ib_devname = NULL; 349 int ret = 0; 350 struct ibv_device **dev_list, **orig_dev_list; 351 int num_of_hcas; 352 int ib_port = 0; 353 354 /* parse command line options */ 355 while (1) { 356 int c; 357 static struct option long_options[] = { 358 { .name = "ib-dev", .has_arg = 1, .val = 'd' }, 359 { .name = "ib-port", .has_arg = 1, .val = 'i' }, 360 { .name = "list", .has_arg = 0, .val = 'l' }, 361 { .name = "verbose", .has_arg = 0, .val = 'v' }, 362 { 0, 0, 0, 0} 363 }; 364 365 c = getopt_long(argc, argv, "d:i:lv", long_options, NULL); 366 if (c == -1) 367 break; 368 369 switch (c) { 370 case 'd': 371 ib_devname = strdup(optarg); 372 break; 373 374 case 'i': 375 ib_port = strtol(optarg, NULL, 0); 376 if (ib_port < 0) { 377 usage(argv[0]); 378 return 1; 379 } 380 break; 381 382 case 'v': 383 verbose = 1; 384 break; 385 386 case 'l': 387 dev_list = orig_dev_list = ibv_get_device_list(&num_of_hcas); 388 if (!dev_list) { 389 perror("Failed to get IB devices list"); 390 return -1; 391 } 392 393 printf("%d HCA%s found:\n", num_of_hcas, 394 num_of_hcas != 1 ? "s" : ""); 395 396 while (*dev_list) { 397 printf("\t%s\n", ibv_get_device_name(*dev_list)); 398 ++dev_list; 399 } 400 401 printf("\n"); 402 403 ibv_free_device_list(orig_dev_list); 404 405 return 0; 406 407 default: 408 usage(argv[0]); 409 return -1; 410 } 411 } 412 413 dev_list = orig_dev_list = ibv_get_device_list(NULL); 414 if (!dev_list) { 415 perror("Failed to get IB devices list"); 416 return -1; 417 } 418 419 if (ib_devname) { 420 while (*dev_list) { 421 if (!strcmp(ibv_get_device_name(*dev_list), ib_devname)) 422 break; 423 ++dev_list; 424 } 425 426 if (!*dev_list) { 427 fprintf(stderr, "IB device '%s' wasn't found\n", ib_devname); 428 return -1; 429 } 430 431 ret |= print_hca_cap(*dev_list, ib_port); 432 } else { 433 if (!*dev_list) { 434 fprintf(stderr, "No IB devices found\n"); 435 return -1; 436 } 437 438 while (*dev_list) { 439 ret |= print_hca_cap(*dev_list, ib_port); 440 ++dev_list; 441 } 442 } 443 444 if (ib_devname) 445 free(ib_devname); 446 447 ibv_free_device_list(orig_dev_list); 448 449 return ret; 450 } 451