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