contrib/ofed/libibverbs/examples/devinfo.c

   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 }