rdma/utils.c

   1 /*
   2  * utils.c      RDMA tool
   3  *
   4  *              This program is free software; you can redistribute it and/or
   5  *              modify it under the terms of the GNU General Public License
   6  *              as published by the Free Software Foundation; either version
   7  *              2 of the License, or (at your option) any later version.
   8  *
   9  * Authors:     Leon Romanovsky <leonro@mellanox.com>
  10  */
  11
  12 #include "rdma.h"
  13 #include <ctype.h>
  14 #include <inttypes.h>
  15
  16 int rd_argc(struct rd *rd)
  17 {
  18         return rd->argc;
  19 }
  20
  21 char *rd_argv(struct rd *rd)
  22 {
  23         if (!rd_argc(rd))
  24                 return NULL;
  25         return *rd->argv;
  26 }
  27
  28 int strcmpx(const char *str1, const char *str2)
  29 {
  30         if (strlen(str1) > strlen(str2))
  31                 return -1;
  32         return strncmp(str1, str2, strlen(str1));
  33 }
  34
  35 static bool rd_argv_match(struct rd *rd, const char *pattern)
  36 {
  37         if (!rd_argc(rd))
  38                 return false;
  39         return strcmpx(rd_argv(rd), pattern) == 0;
  40 }
  41
  42 void rd_arg_inc(struct rd *rd)
  43 {
  44         if (!rd_argc(rd))
  45                 return;
  46         rd->argc--;
  47         rd->argv++;
  48 }
  49
  50 bool rd_no_arg(struct rd *rd)
  51 {
  52         return rd_argc(rd) == 0;
  53 }
  54
  55 /*
  56  * Possible input:output
  57  * dev/port    | first port | is_dump_all
  58  * mlx5_1      | 0          | true
  59  * mlx5_1/     | 0          | true
  60  * mlx5_1/0    | 0          | false
  61  * mlx5_1/1    | 1          | false
  62  * mlx5_1/-    | 0          | false
  63  *
  64  * In strict mode, /- will return error.
  65  */
  66 static int get_port_from_argv(struct rd *rd, uint32_t *port,
  67                               bool *is_dump_all, bool strict_port)
  68 {
  69         char *slash;
  70
  71         *port = 0;
  72         *is_dump_all = true;
  73
  74         slash = strchr(rd_argv(rd), '/');
  75         /* if no port found, return 0 */
  76         if (slash++) {
  77                 if (*slash == '-') {
  78                         if (strict_port)
  79                                 return -EINVAL;
  80                         *is_dump_all = false;
  81                         return 0;
  82                 }
  83
  84                 if (isdigit(*slash)) {
  85                         *is_dump_all = false;
  86                         *port = atoi(slash);
  87                 }
  88                 if (!*port && strlen(slash))
  89                         return -EINVAL;
  90         }
  91         return 0;
  92 }
  93
  94 static struct dev_map *dev_map_alloc(const char *dev_name)
  95 {
  96         struct dev_map *dev_map;
  97
  98         dev_map = calloc(1, sizeof(*dev_map));
  99         if (!dev_map)
 100                 return NULL;
 101         dev_map->dev_name = strdup(dev_name);
 102         if (!dev_map->dev_name) {
 103                 free(dev_map);
 104                 return NULL;
 105         }
 106
 107         return dev_map;
 108 }
 109
 110 static void dev_map_cleanup(struct rd *rd)
 111 {
 112         struct dev_map *dev_map, *tmp;
 113
 114         list_for_each_entry_safe(dev_map, tmp,
 115                                  &rd->dev_map_list, list) {
 116                 list_del(&dev_map->list);
 117                 free(dev_map->dev_name);
 118                 free(dev_map);
 119         }
 120 }
 121
 122 static int add_filter(struct rd *rd, char *key, char *value,
 123                       const struct filters valid_filters[])
 124 {
 125         char cset[] = "1234567890,-";
 126         struct filter_entry *fe;
 127         bool key_found = false;
 128         int idx = 0;
 129         int ret;
 130
 131         fe = calloc(1, sizeof(*fe));
 132         if (!fe)
 133                 return -ENOMEM;
 134
 135         while (idx < MAX_NUMBER_OF_FILTERS && valid_filters[idx].name) {
 136                 if (!strcmpx(key, valid_filters[idx].name)) {
 137                         key_found = true;
 138                         break;
 139                 }
 140                 idx++;
 141         }
 142         if (!key_found) {
 143                 pr_err("Unsupported filter option: %s\n", key);
 144                 ret = -EINVAL;
 145                 goto err;
 146         }
 147
 148         /*
 149          * Check the filter validity, not optimal, but works
 150          *
 151          * Actually, there are three types of filters
 152          *  numeric - for example PID or QPN
 153          *  string  - for example states
 154          *  link    - user requested to filter on specific link
 155          *            e.g. mlx5_1/1, mlx5_1/-, mlx5_1 ...
 156          */
 157         if (valid_filters[idx].is_number &&
 158             strspn(value, cset) != strlen(value)) {
 159                 pr_err("%s filter accepts \"%s\" characters only\n", key, cset);
 160                 ret = -EINVAL;
 161                 goto err;
 162         }
 163
 164         fe->key = strdup(key);
 165         fe->value = strdup(value);
 166         if (!fe->key || !fe->value) {
 167                 ret = -ENOMEM;
 168                 goto err_alloc;
 169         }
 170
 171         for (idx = 0; idx < strlen(fe->value); idx++)
 172                 fe->value[idx] = tolower(fe->value[idx]);
 173
 174         list_add_tail(&fe->list, &rd->filter_list);
 175         return 0;
 176
 177 err_alloc:
 178         free(fe->value);
 179         free(fe->key);
 180 err:
 181         free(fe);
 182         return ret;
 183 }
 184
 185 int rd_build_filter(struct rd *rd, const struct filters valid_filters[])
 186 {
 187         int ret = 0;
 188         int idx = 0;
 189
 190         if (!valid_filters || !rd_argc(rd))
 191                 goto out;
 192
 193         if (rd_argc(rd) == 1) {
 194                 pr_err("No filter data was supplied to filter option %s\n", rd_argv(rd));
 195                 ret = -EINVAL;
 196                 goto out;
 197         }
 198
 199         if (rd_argc(rd) % 2) {
 200                 pr_err("There is filter option without data\n");
 201                 ret = -EINVAL;
 202                 goto out;
 203         }
 204
 205         while (idx != rd_argc(rd)) {
 206                 /*
 207                  * We can do micro-optimization and skip "dev"
 208                  * and "link" filters, but it is not worth of it.
 209                  */
 210                 ret = add_filter(rd, *(rd->argv + idx),
 211                                  *(rd->argv + idx + 1), valid_filters);
 212                 if (ret)
 213                         goto out;
 214                 idx += 2;
 215         }
 216
 217 out:
 218         return ret;
 219 }
 220
 221 bool rd_check_is_key_exist(struct rd *rd, const char *key)
 222 {
 223         struct filter_entry *fe;
 224
 225         list_for_each_entry(fe, &rd->filter_list, list) {
 226                 if (!strcmpx(fe->key, key))
 227                         return true;
 228         }
 229
 230         return false;
 231 }
 232
 233 /*
 234  * Check if string entry is filtered:
 235  *  * key doesn't exist -> user didn't request -> not filtered
 236  */
 237 bool rd_check_is_string_filtered(struct rd *rd,
 238                                  const char *key, const char *val)
 239 {
 240         bool key_is_filtered = false;
 241         struct filter_entry *fe;
 242         char *p = NULL;
 243         char *str;
 244
 245         list_for_each_entry(fe, &rd->filter_list, list) {
 246                 if (!strcmpx(fe->key, key)) {
 247                         /* We found the key */
 248                         p = strdup(fe->value);
 249                         key_is_filtered = true;
 250                         if (!p) {
 251                                 /*
 252                                  * Something extremely wrong if we fail
 253                                  * to allocate small amount of bytes.
 254                                  */
 255                                 pr_err("Found key, but failed to allocate memory to store value\n");
 256                                 return key_is_filtered;
 257                         }
 258
 259                         /*
 260                          * Need to check if value in range
 261                          * It can come in the following formats
 262                          * and their permutations:
 263                          * str
 264                          * str1,str2
 265                          */
 266                         str = strtok(p, ",");
 267                         while (str) {
 268                                 if (strlen(str) == strlen(val) &&
 269                                     !strcasecmp(str, val)) {
 270                                         key_is_filtered = false;
 271                                         goto out;
 272                                 }
 273                                 str = strtok(NULL, ",");
 274                         }
 275                         goto out;
 276                 }
 277         }
 278
 279 out:
 280         free(p);
 281         return key_is_filtered;
 282 }
 283
 284 /*
 285  * Check if key is filtered:
 286  * key doesn't exist -> user didn't request -> not filtered
 287  */
 288 bool rd_check_is_filtered(struct rd *rd, const char *key, uint32_t val)
 289 {
 290         bool key_is_filtered = false;
 291         struct filter_entry *fe;
 292
 293         list_for_each_entry(fe, &rd->filter_list, list) {
 294                 uint32_t left_val = 0, fe_value = 0;
 295                 bool range_check = false;
 296                 char *p = fe->value;
 297
 298                 if (!strcmpx(fe->key, key)) {
 299                         /* We found the key */
 300                         key_is_filtered = true;
 301                         /*
 302                          * Need to check if value in range
 303                          * It can come in the following formats
 304                          * (and their permutations):
 305                          * numb
 306                          * numb1,numb2
 307                          * ,numb1,numb2
 308                          * numb1-numb2
 309                          * numb1,numb2-numb3,numb4-numb5
 310                          */
 311                         while (*p) {
 312                                 if (isdigit(*p)) {
 313                                         fe_value = strtol(p, &p, 10);
 314                                         if (fe_value == val ||
 315                                             (range_check && left_val < val &&
 316                                              val < fe_value)) {
 317                                                 key_is_filtered = false;
 318                                                 goto out;
 319                                         }
 320                                         range_check = false;
 321                                 } else {
 322                                         if (*p == '-') {
 323                                                 left_val = fe_value;
 324                                                 range_check = true;
 325                                         }
 326                                         p++;
 327                                 }
 328                         }
 329                         goto out;
 330                 }
 331         }
 332
 333 out:
 334         return key_is_filtered;
 335 }
 336
 337 static void filters_cleanup(struct rd *rd)
 338 {
 339         struct filter_entry *fe, *tmp;
 340
 341         list_for_each_entry_safe(fe, tmp,
 342                                  &rd->filter_list, list) {
 343                 list_del(&fe->list);
 344                 free(fe->key);
 345                 free(fe->value);
 346                 free(fe);
 347         }
 348 }
 349
 350 static const enum mnl_attr_data_type nldev_policy[RDMA_NLDEV_ATTR_MAX] = {
 351         [RDMA_NLDEV_ATTR_DEV_INDEX] = MNL_TYPE_U32,
 352         [RDMA_NLDEV_ATTR_DEV_NAME] = MNL_TYPE_NUL_STRING,
 353         [RDMA_NLDEV_ATTR_PORT_INDEX] = MNL_TYPE_U32,
 354         [RDMA_NLDEV_ATTR_CAP_FLAGS] = MNL_TYPE_U64,
 355         [RDMA_NLDEV_ATTR_FW_VERSION] = MNL_TYPE_NUL_STRING,
 356         [RDMA_NLDEV_ATTR_NODE_GUID] = MNL_TYPE_U64,
 357         [RDMA_NLDEV_ATTR_SYS_IMAGE_GUID] = MNL_TYPE_U64,
 358         [RDMA_NLDEV_ATTR_LID] = MNL_TYPE_U32,
 359         [RDMA_NLDEV_ATTR_SM_LID] = MNL_TYPE_U32,
 360         [RDMA_NLDEV_ATTR_LMC] = MNL_TYPE_U8,
 361         [RDMA_NLDEV_ATTR_PORT_STATE] = MNL_TYPE_U8,
 362         [RDMA_NLDEV_ATTR_PORT_PHYS_STATE] = MNL_TYPE_U8,
 363         [RDMA_NLDEV_ATTR_DEV_NODE_TYPE] = MNL_TYPE_U8,
 364         [RDMA_NLDEV_ATTR_RES_SUMMARY]   = MNL_TYPE_NESTED,
 365         [RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY]     = MNL_TYPE_NESTED,
 366         [RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME] = MNL_TYPE_NUL_STRING,
 367         [RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR] = MNL_TYPE_U64,
 368         [RDMA_NLDEV_ATTR_RES_QP]                = MNL_TYPE_NESTED,
 369         [RDMA_NLDEV_ATTR_RES_QP_ENTRY]          = MNL_TYPE_NESTED,
 370         [RDMA_NLDEV_ATTR_RES_LQPN]      = MNL_TYPE_U32,
 371         [RDMA_NLDEV_ATTR_RES_RQPN]      = MNL_TYPE_U32,
 372         [RDMA_NLDEV_ATTR_RES_RQ_PSN]            = MNL_TYPE_U32,
 373         [RDMA_NLDEV_ATTR_RES_SQ_PSN]            = MNL_TYPE_U32,
 374         [RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE]    = MNL_TYPE_U8,
 375         [RDMA_NLDEV_ATTR_RES_TYPE]              = MNL_TYPE_U8,
 376         [RDMA_NLDEV_ATTR_RES_STATE]             = MNL_TYPE_U8,
 377         [RDMA_NLDEV_ATTR_RES_PID]               = MNL_TYPE_U32,
 378         [RDMA_NLDEV_ATTR_RES_KERN_NAME] = MNL_TYPE_NUL_STRING,
 379         [RDMA_NLDEV_ATTR_RES_CM_ID]             = MNL_TYPE_NESTED,
 380         [RDMA_NLDEV_ATTR_RES_CM_ID_ENTRY]       = MNL_TYPE_NESTED,
 381         [RDMA_NLDEV_ATTR_RES_PS]                = MNL_TYPE_U32,
 382         [RDMA_NLDEV_ATTR_RES_SRC_ADDR]          = MNL_TYPE_UNSPEC,
 383         [RDMA_NLDEV_ATTR_RES_DST_ADDR]          = MNL_TYPE_UNSPEC,
 384         [RDMA_NLDEV_ATTR_RES_CQ] = MNL_TYPE_NESTED,
 385         [RDMA_NLDEV_ATTR_RES_CQ_ENTRY] = MNL_TYPE_NESTED,
 386         [RDMA_NLDEV_ATTR_RES_CQE] = MNL_TYPE_U32,
 387         [RDMA_NLDEV_ATTR_RES_USECNT] = MNL_TYPE_U64,
 388         [RDMA_NLDEV_ATTR_RES_POLL_CTX] = MNL_TYPE_U8,
 389         [RDMA_NLDEV_ATTR_RES_MR] = MNL_TYPE_NESTED,
 390         [RDMA_NLDEV_ATTR_RES_MR_ENTRY] = MNL_TYPE_NESTED,
 391         [RDMA_NLDEV_ATTR_RES_RKEY] = MNL_TYPE_U32,
 392         [RDMA_NLDEV_ATTR_RES_LKEY] = MNL_TYPE_U32,
 393         [RDMA_NLDEV_ATTR_RES_IOVA] = MNL_TYPE_U64,
 394         [RDMA_NLDEV_ATTR_RES_MRLEN] = MNL_TYPE_U64,
 395         [RDMA_NLDEV_ATTR_NDEV_INDEX]            = MNL_TYPE_U32,
 396         [RDMA_NLDEV_ATTR_NDEV_NAME]             = MNL_TYPE_NUL_STRING,
 397         [RDMA_NLDEV_ATTR_DRIVER] = MNL_TYPE_NESTED,
 398         [RDMA_NLDEV_ATTR_DRIVER_ENTRY] = MNL_TYPE_NESTED,
 399         [RDMA_NLDEV_ATTR_DRIVER_STRING] = MNL_TYPE_NUL_STRING,
 400         [RDMA_NLDEV_ATTR_DRIVER_PRINT_TYPE] = MNL_TYPE_U8,
 401         [RDMA_NLDEV_ATTR_DRIVER_S32] = MNL_TYPE_U32,
 402         [RDMA_NLDEV_ATTR_DRIVER_U32] = MNL_TYPE_U32,
 403         [RDMA_NLDEV_ATTR_DRIVER_S64] = MNL_TYPE_U64,
 404         [RDMA_NLDEV_ATTR_DRIVER_U64] = MNL_TYPE_U64,
 405 };
 406
 407 int rd_attr_check(const struct nlattr *attr, int *typep)
 408 {
 409         int type;
 410
 411         if (mnl_attr_type_valid(attr, RDMA_NLDEV_ATTR_MAX) < 0)
 412                 return MNL_CB_ERROR;
 413
 414         type = mnl_attr_get_type(attr);
 415
 416         if (mnl_attr_validate(attr, nldev_policy[type]) < 0)
 417                 return MNL_CB_ERROR;
 418
 419         *typep = nldev_policy[type];
 420         return MNL_CB_OK;
 421 }
 422
 423 int rd_attr_cb(const struct nlattr *attr, void *data)
 424 {
 425         const struct nlattr **tb = data;
 426         int type;
 427
 428         if (mnl_attr_type_valid(attr, RDMA_NLDEV_ATTR_MAX - 1) < 0)
 429                 /* We received unknown attribute */
 430                 return MNL_CB_OK;
 431
 432         type = mnl_attr_get_type(attr);
 433
 434         if (mnl_attr_validate(attr, nldev_policy[type]) < 0)
 435                 return MNL_CB_ERROR;
 436
 437         tb[type] = attr;
 438         return MNL_CB_OK;
 439 }
 440
 441 int rd_dev_init_cb(const struct nlmsghdr *nlh, void *data)
 442 {
 443         struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
 444         struct dev_map *dev_map;
 445         struct rd *rd = data;
 446         const char *dev_name;
 447
 448         mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
 449         if (!tb[RDMA_NLDEV_ATTR_DEV_NAME] || !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
 450                 return MNL_CB_ERROR;
 451         if (!tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
 452                 pr_err("This tool doesn't support switches yet\n");
 453                 return MNL_CB_ERROR;
 454         }
 455
 456         dev_name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
 457
 458         dev_map = dev_map_alloc(dev_name);
 459         if (!dev_map)
 460                 /* The main function will cleanup the allocations */
 461                 return MNL_CB_ERROR;
 462         list_add_tail(&dev_map->list, &rd->dev_map_list);
 463
 464         dev_map->num_ports = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
 465         dev_map->idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
 466         return MNL_CB_OK;
 467 }
 468
 469 void rd_free(struct rd *rd)
 470 {
 471         if (!rd)
 472                 return;
 473         free(rd->buff);
 474         dev_map_cleanup(rd);
 475         filters_cleanup(rd);
 476 }
 477
 478 int rd_set_arg_to_devname(struct rd *rd)
 479 {
 480         int ret = 0;
 481
 482         while (!rd_no_arg(rd)) {
 483                 if (rd_argv_match(rd, "dev") || rd_argv_match(rd, "link")) {
 484                         rd_arg_inc(rd);
 485                         if (rd_no_arg(rd)) {
 486                                 pr_err("No device name was supplied\n");
 487                                 ret = -EINVAL;
 488                         }
 489                         goto out;
 490                 }
 491                 rd_arg_inc(rd);
 492         }
 493 out:
 494         return ret;
 495 }
 496
 497 int rd_exec_link(struct rd *rd, int (*cb)(struct rd *rd), bool strict_port)
 498 {
 499         struct dev_map *dev_map;
 500         uint32_t port;
 501         int ret = 0;
 502
 503         if (rd->json_output)
 504                 jsonw_start_array(rd->jw);
 505         if (rd_no_arg(rd)) {
 506                 list_for_each_entry(dev_map, &rd->dev_map_list, list) {
 507                         rd->dev_idx = dev_map->idx;
 508                         port = (strict_port) ? 1 : 0;
 509                         for (; port < dev_map->num_ports + 1; port++) {
 510                                 rd->port_idx = port;
 511                                 ret = cb(rd);
 512                                 if (ret)
 513                                         goto out;
 514                         }
 515                 }
 516
 517         } else {
 518                 bool is_dump_all;
 519
 520                 dev_map = dev_map_lookup(rd, true);
 521                 ret = get_port_from_argv(rd, &port, &is_dump_all, strict_port);
 522                 if (!dev_map || port > dev_map->num_ports || (!port && ret)) {
 523                         pr_err("Wrong device name\n");
 524                         ret = -ENOENT;
 525                         goto out;
 526                 }
 527                 rd_arg_inc(rd);
 528                 rd->dev_idx = dev_map->idx;
 529                 rd->port_idx = port;
 530                 for (; rd->port_idx < dev_map->num_ports + 1; rd->port_idx++) {
 531                         ret = cb(rd);
 532                         if (ret)
 533                                 goto out;
 534                         if (!is_dump_all)
 535                                 /*
 536                                  * We got request to show link for devname
 537                                  * with port index.
 538                                  */
 539                                 break;
 540                 }
 541         }
 542
 543 out:
 544         if (rd->json_output)
 545                 jsonw_end_array(rd->jw);
 546         return ret;
 547 }
 548
 549 int rd_exec_dev(struct rd *rd, int (*cb)(struct rd *rd))
 550 {
 551         struct dev_map *dev_map;
 552         int ret = 0;
 553
 554         if (rd->json_output)
 555                 jsonw_start_array(rd->jw);
 556         if (rd_no_arg(rd)) {
 557                 list_for_each_entry(dev_map, &rd->dev_map_list, list) {
 558                         rd->dev_idx = dev_map->idx;
 559                         ret = cb(rd);
 560                         if (ret)
 561                                 goto out;
 562                 }
 563         } else {
 564                 dev_map = dev_map_lookup(rd, false);
 565                 if (!dev_map) {
 566                         pr_err("Wrong device name - %s\n", rd_argv(rd));
 567                         ret = -ENOENT;
 568                         goto out;
 569                 }
 570                 rd_arg_inc(rd);
 571                 rd->dev_idx = dev_map->idx;
 572                 ret = cb(rd);
 573         }
 574 out:
 575         if (rd->json_output)
 576                 jsonw_end_array(rd->jw);
 577         return ret;
 578 }
 579
 580 int rd_exec_require_dev(struct rd *rd, int (*cb)(struct rd *rd))
 581 {
 582         if (rd_no_arg(rd)) {
 583                 pr_err("Please provide device name.\n");
 584                 return -EINVAL;
 585         }
 586
 587         return rd_exec_dev(rd, cb);
 588 }
 589
 590 int rd_exec_cmd(struct rd *rd, const struct rd_cmd *cmds, const char *str)
 591 {
 592         const struct rd_cmd *c;
 593
 594         /* First argument in objs table is default variant */
 595         if (rd_no_arg(rd))
 596                 return cmds->func(rd);
 597
 598         for (c = cmds + 1; c->cmd; ++c) {
 599                 if (rd_argv_match(rd, c->cmd)) {
 600                         /* Move to next argument */
 601                         rd_arg_inc(rd);
 602                         return c->func(rd);
 603                 }
 604         }
 605
 606         pr_err("Unknown %s '%s'.\n", str, rd_argv(rd));
 607         return 0;
 608 }
 609
 610 void rd_prepare_msg(struct rd *rd, uint32_t cmd, uint32_t *seq, uint16_t flags)
 611 {
 612         *seq = time(NULL);
 613
 614         rd->nlh = mnl_nlmsg_put_header(rd->buff);
 615         rd->nlh->nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, cmd);
 616         rd->nlh->nlmsg_seq = *seq;
 617         rd->nlh->nlmsg_flags = flags;
 618 }
 619
 620 int rd_send_msg(struct rd *rd)
 621 {
 622         int ret;
 623
 624         rd->nl = mnl_socket_open(NETLINK_RDMA);
 625         if (!rd->nl) {
 626                 pr_err("Failed to open NETLINK_RDMA socket\n");
 627                 return -ENODEV;
 628         }
 629
 630         ret = mnl_socket_bind(rd->nl, 0, MNL_SOCKET_AUTOPID);
 631         if (ret < 0) {
 632                 pr_err("Failed to bind socket with err %d\n", ret);
 633                 goto err;
 634         }
 635
 636         ret = mnl_socket_sendto(rd->nl, rd->nlh, rd->nlh->nlmsg_len);
 637         if (ret < 0) {
 638                 pr_err("Failed to send to socket with err %d\n", ret);
 639                 goto err;
 640         }
 641         return 0;
 642
 643 err:
 644         mnl_socket_close(rd->nl);
 645         return ret;
 646 }
 647
 648 int rd_recv_msg(struct rd *rd, mnl_cb_t callback, void *data, unsigned int seq)
 649 {
 650         int ret;
 651         unsigned int portid;
 652         char buf[MNL_SOCKET_BUFFER_SIZE];
 653
 654         portid = mnl_socket_get_portid(rd->nl);
 655         do {
 656                 ret = mnl_socket_recvfrom(rd->nl, buf, sizeof(buf));
 657                 if (ret <= 0)
 658                         break;
 659
 660                 ret = mnl_cb_run(buf, ret, seq, portid, callback, data);
 661         } while (ret > 0);
 662
 663         mnl_socket_close(rd->nl);
 664         return ret;
 665 }
 666
 667 static struct dev_map *_dev_map_lookup(struct rd *rd, const char *dev_name)
 668 {
 669         struct dev_map *dev_map;
 670
 671         list_for_each_entry(dev_map, &rd->dev_map_list, list)
 672                 if (strcmp(dev_name, dev_map->dev_name) == 0)
 673                         return dev_map;
 674
 675         return NULL;
 676 }
 677
 678 struct dev_map *dev_map_lookup(struct rd *rd, bool allow_port_index)
 679 {
 680         struct dev_map *dev_map;
 681         char *dev_name;
 682         char *slash;
 683
 684         if (rd_no_arg(rd))
 685                 return NULL;
 686
 687         dev_name = strdup(rd_argv(rd));
 688         if (allow_port_index) {
 689                 slash = strrchr(dev_name, '/');
 690                 if (slash)
 691                         *slash = '\0';
 692         }
 693
 694         dev_map = _dev_map_lookup(rd, dev_name);
 695         free(dev_name);
 696         return dev_map;
 697 }
 698
 699 #define nla_type(attr) ((attr)->nla_type & NLA_TYPE_MASK)
 700
 701 void newline(struct rd *rd)
 702 {
 703         if (rd->json_output)
 704                 jsonw_end_array(rd->jw);
 705         else
 706                 pr_out("\n");
 707 }
 708
 709 void newline_indent(struct rd *rd)
 710 {
 711         newline(rd);
 712         if (!rd->json_output)
 713                 pr_out("    ");
 714 }
 715
 716 static int print_driver_string(struct rd *rd, const char *key_str,
 717                                  const char *val_str)
 718 {
 719         if (rd->json_output) {
 720                 jsonw_string_field(rd->jw, key_str, val_str);
 721                 return 0;
 722         } else {
 723                 return pr_out("%s %s ", key_str, val_str);
 724         }
 725 }
 726
 727 static int print_driver_s32(struct rd *rd, const char *key_str, int32_t val,
 728                               enum rdma_nldev_print_type print_type)
 729 {
 730         if (rd->json_output) {
 731                 jsonw_int_field(rd->jw, key_str, val);
 732                 return 0;
 733         }
 734         switch (print_type) {
 735         case RDMA_NLDEV_PRINT_TYPE_UNSPEC:
 736                 return pr_out("%s %d ", key_str, val);
 737         case RDMA_NLDEV_PRINT_TYPE_HEX:
 738                 return pr_out("%s 0x%x ", key_str, val);
 739         default:
 740                 return -EINVAL;
 741         }
 742 }
 743
 744 static int print_driver_u32(struct rd *rd, const char *key_str, uint32_t val,
 745                               enum rdma_nldev_print_type print_type)
 746 {
 747         if (rd->json_output) {
 748                 jsonw_int_field(rd->jw, key_str, val);
 749                 return 0;
 750         }
 751         switch (print_type) {
 752         case RDMA_NLDEV_PRINT_TYPE_UNSPEC:
 753                 return pr_out("%s %u ", key_str, val);
 754         case RDMA_NLDEV_PRINT_TYPE_HEX:
 755                 return pr_out("%s 0x%x ", key_str, val);
 756         default:
 757                 return -EINVAL;
 758         }
 759 }
 760
 761 static int print_driver_s64(struct rd *rd, const char *key_str, int64_t val,
 762                               enum rdma_nldev_print_type print_type)
 763 {
 764         if (rd->json_output) {
 765                 jsonw_int_field(rd->jw, key_str, val);
 766                 return 0;
 767         }
 768         switch (print_type) {
 769         case RDMA_NLDEV_PRINT_TYPE_UNSPEC:
 770                 return pr_out("%s %" PRId64 " ", key_str, val);
 771         case RDMA_NLDEV_PRINT_TYPE_HEX:
 772                 return pr_out("%s 0x%" PRIx64 " ", key_str, val);
 773         default:
 774                 return -EINVAL;
 775         }
 776 }
 777
 778 static int print_driver_u64(struct rd *rd, const char *key_str, uint64_t val,
 779                               enum rdma_nldev_print_type print_type)
 780 {
 781         if (rd->json_output) {
 782                 jsonw_int_field(rd->jw, key_str, val);
 783                 return 0;
 784         }
 785         switch (print_type) {
 786         case RDMA_NLDEV_PRINT_TYPE_UNSPEC:
 787                 return pr_out("%s %" PRIu64 " ", key_str, val);
 788         case RDMA_NLDEV_PRINT_TYPE_HEX:
 789                 return pr_out("%s 0x%" PRIx64 " ", key_str, val);
 790         default:
 791                 return -EINVAL;
 792         }
 793 }
 794
 795 static int print_driver_entry(struct rd *rd, struct nlattr *key_attr,
 796                                 struct nlattr *val_attr,
 797                                 enum rdma_nldev_print_type print_type)
 798 {
 799         const char *key_str = mnl_attr_get_str(key_attr);
 800         int attr_type = nla_type(val_attr);
 801
 802         switch (attr_type) {
 803         case RDMA_NLDEV_ATTR_DRIVER_STRING:
 804                 return print_driver_string(rd, key_str,
 805                                 mnl_attr_get_str(val_attr));
 806         case RDMA_NLDEV_ATTR_DRIVER_S32:
 807                 return print_driver_s32(rd, key_str,
 808                                 mnl_attr_get_u32(val_attr), print_type);
 809         case RDMA_NLDEV_ATTR_DRIVER_U32:
 810                 return print_driver_u32(rd, key_str,
 811                                 mnl_attr_get_u32(val_attr), print_type);
 812         case RDMA_NLDEV_ATTR_DRIVER_S64:
 813                 return print_driver_s64(rd, key_str,
 814                                 mnl_attr_get_u64(val_attr), print_type);
 815         case RDMA_NLDEV_ATTR_DRIVER_U64:
 816                 return print_driver_u64(rd, key_str,
 817                                 mnl_attr_get_u64(val_attr), print_type);
 818         }
 819         return -EINVAL;
 820 }
 821
 822 void print_driver_table(struct rd *rd, struct nlattr *tb)
 823 {
 824         int print_type = RDMA_NLDEV_PRINT_TYPE_UNSPEC;
 825         struct nlattr *tb_entry, *key = NULL, *val;
 826         int type, cc = 0;
 827         int ret;
 828
 829         if (!rd->show_driver_details || !tb)
 830                 return;
 831
 832         if (rd->pretty_output)
 833                 newline_indent(rd);
 834
 835         /*
 836          * Driver attrs are tuples of {key, [print-type], value}.
 837          * The key must be a string.  If print-type is present, it
 838          * defines an alternate printf format type vs the native format
 839          * for the attribute.  And the value can be any available
 840          * driver type.
 841          */
 842         mnl_attr_for_each_nested(tb_entry, tb) {
 843
 844                 if (cc > MAX_LINE_LENGTH) {
 845                         if (rd->pretty_output)
 846                                 newline_indent(rd);
 847                         cc = 0;
 848                 }
 849                 if (rd_attr_check(tb_entry, &type) != MNL_CB_OK)
 850                         return;
 851                 if (!key) {
 852                         if (type != MNL_TYPE_NUL_STRING)
 853                                 return;
 854                         key = tb_entry;
 855                 } else if (type == MNL_TYPE_U8) {
 856                         print_type = mnl_attr_get_u8(tb_entry);
 857                 } else {
 858                         val = tb_entry;
 859                         ret = print_driver_entry(rd, key, val, print_type);
 860                         if (ret < 0)
 861                                 return;
 862                         cc += ret;
 863                         print_type = RDMA_NLDEV_PRINT_TYPE_UNSPEC;
 864                         key = NULL;
 865                 }
 866         }
 867         return;
 868 }