rdma/utils.c

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