rdma/res.c

   1 /*
   2  * res.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 "res.h"
  13 #include <inttypes.h>
  14
  15 static int res_help(struct rd *rd)
  16 {
  17         pr_out("Usage: %s resource\n", rd->filename);
  18         pr_out("          resource show [DEV]\n");
  19         pr_out("          resource show [qp|cm_id|pd|mr|cq]\n");
  20         pr_out("          resource show qp link [DEV/PORT]\n");
  21         pr_out("          resource show qp link [DEV/PORT] [FILTER-NAME FILTER-VALUE]\n");
  22         pr_out("          resource show cm_id link [DEV/PORT]\n");
  23         pr_out("          resource show cm_id link [DEV/PORT] [FILTER-NAME FILTER-VALUE]\n");
  24         pr_out("          resource show cq link [DEV/PORT]\n");
  25         pr_out("          resource show cq link [DEV/PORT] [FILTER-NAME FILTER-VALUE]\n");
  26         pr_out("          resource show pd dev [DEV]\n");
  27         pr_out("          resource show pd dev [DEV] [FILTER-NAME FILTER-VALUE]\n");
  28         pr_out("          resource show mr dev [DEV]\n");
  29         pr_out("          resource show mr dev [DEV] [FILTER-NAME FILTER-VALUE]\n");
  30         return 0;
  31 }
  32
  33 static int res_print_summary(struct rd *rd, struct nlattr **tb)
  34 {
  35         struct nlattr *nla_table = tb[RDMA_NLDEV_ATTR_RES_SUMMARY];
  36         struct nlattr *nla_entry;
  37         const char *name;
  38         uint64_t curr;
  39         int err;
  40
  41         mnl_attr_for_each_nested(nla_entry, nla_table) {
  42                 struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {};
  43                 char json_name[32];
  44
  45                 err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line);
  46                 if (err != MNL_CB_OK)
  47                         return -EINVAL;
  48
  49                 if (!nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME] ||
  50                     !nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR]) {
  51                         return -EINVAL;
  52                 }
  53
  54                 name = mnl_attr_get_str(nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME]);
  55                 curr = mnl_attr_get_u64(nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR]);
  56                 if (rd->json_output) {
  57                         snprintf(json_name, 32, "%s", name);
  58                         jsonw_lluint_field(rd->jw, json_name, curr);
  59                 } else {
  60                         pr_out("%s %"PRId64 " ", name, curr);
  61                 }
  62         }
  63         return 0;
  64 }
  65
  66 static int res_no_args_parse_cb(const struct nlmsghdr *nlh, void *data)
  67 {
  68         struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
  69         struct rd *rd = data;
  70         const char *name;
  71         uint32_t idx;
  72
  73         mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
  74         if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] ||
  75             !tb[RDMA_NLDEV_ATTR_DEV_NAME] ||
  76             !tb[RDMA_NLDEV_ATTR_RES_SUMMARY])
  77                 return MNL_CB_ERROR;
  78
  79         idx =  mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
  80         name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
  81         if (rd->json_output) {
  82                 jsonw_uint_field(rd->jw, "ifindex", idx);
  83                 jsonw_string_field(rd->jw, "ifname", name);
  84         } else {
  85                 pr_out("%u: %s: ", idx, name);
  86         }
  87
  88         res_print_summary(rd, tb);
  89
  90         if (!rd->json_output)
  91                 pr_out("\n");
  92         return MNL_CB_OK;
  93 }
  94
  95 int _res_send_msg(struct rd *rd, uint32_t command, mnl_cb_t callback)
  96 {
  97         uint32_t flags = NLM_F_REQUEST | NLM_F_ACK;
  98         uint32_t seq;
  99         int ret;
 100
 101         if (command != RDMA_NLDEV_CMD_RES_GET)
 102                 flags |= NLM_F_DUMP;
 103
 104         rd_prepare_msg(rd, command, &seq, flags);
 105         mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
 106         if (rd->port_idx)
 107                 mnl_attr_put_u32(rd->nlh,
 108                                  RDMA_NLDEV_ATTR_PORT_INDEX, rd->port_idx);
 109
 110         ret = rd_send_msg(rd);
 111         if (ret)
 112                 return ret;
 113
 114         if (rd->json_output)
 115                 jsonw_start_object(rd->jw);
 116         ret = rd_recv_msg(rd, callback, rd, seq);
 117         if (rd->json_output)
 118                 jsonw_end_object(rd->jw);
 119         return ret;
 120 }
 121
 122 static const char *path_mig_to_str(uint8_t idx)
 123 {
 124         static const char * const path_mig_str[] = { "MIGRATED",
 125                                                      "REARM", "ARMED" };
 126
 127         if (idx < ARRAY_SIZE(path_mig_str))
 128                 return path_mig_str[idx];
 129         return "UNKNOWN";
 130 }
 131
 132 static const char *qp_states_to_str(uint8_t idx)
 133 {
 134         static const char * const qp_states_str[] = { "RESET", "INIT",
 135                                                       "RTR", "RTS", "SQD",
 136                                                       "SQE", "ERR" };
 137
 138         if (idx < ARRAY_SIZE(qp_states_str))
 139                 return qp_states_str[idx];
 140         return "UNKNOWN";
 141 }
 142
 143 const char *qp_types_to_str(uint8_t idx)
 144 {
 145         static const char * const qp_types_str[] = { "SMI", "GSI", "RC",
 146                                                      "UC", "UD", "RAW_IPV6",
 147                                                      "RAW_ETHERTYPE",
 148                                                      "UNKNOWN", "RAW_PACKET",
 149                                                      "XRC_INI", "XRC_TGT" };
 150
 151         if (idx < ARRAY_SIZE(qp_types_str))
 152                 return qp_types_str[idx];
 153         return "UNKNOWN";
 154 }
 155
 156 void print_lqpn(struct rd *rd, uint32_t val)
 157 {
 158         if (rd->json_output)
 159                 jsonw_uint_field(rd->jw, "lqpn", val);
 160         else
 161                 pr_out("lqpn %u ", val);
 162 }
 163
 164 static void print_rqpn(struct rd *rd, uint32_t val, struct nlattr **nla_line)
 165 {
 166         if (!nla_line[RDMA_NLDEV_ATTR_RES_RQPN])
 167                 return;
 168
 169         if (rd->json_output)
 170                 jsonw_uint_field(rd->jw, "rqpn", val);
 171         else
 172                 pr_out("rqpn %u ", val);
 173 }
 174
 175 static void print_type(struct rd *rd, uint32_t val)
 176 {
 177         if (rd->json_output)
 178                 jsonw_string_field(rd->jw, "type",
 179                                    qp_types_to_str(val));
 180         else
 181                 pr_out("type %s ", qp_types_to_str(val));
 182 }
 183
 184 static void print_state(struct rd *rd, uint32_t val)
 185 {
 186         if (rd->json_output)
 187                 jsonw_string_field(rd->jw, "state",
 188                                    qp_states_to_str(val));
 189         else
 190                 pr_out("state %s ", qp_states_to_str(val));
 191 }
 192
 193 static void print_rqpsn(struct rd *rd, uint32_t val, struct nlattr **nla_line)
 194 {
 195         if (!nla_line[RDMA_NLDEV_ATTR_RES_RQ_PSN])
 196                 return;
 197
 198         if (rd->json_output)
 199                 jsonw_uint_field(rd->jw, "rq-psn", val);
 200         else
 201                 pr_out("rq-psn %u ", val);
 202 }
 203
 204 static void print_sqpsn(struct rd *rd, uint32_t val)
 205 {
 206         if (rd->json_output)
 207                 jsonw_uint_field(rd->jw, "sq-psn", val);
 208         else
 209                 pr_out("sq-psn %u ", val);
 210 }
 211
 212 static void print_pathmig(struct rd *rd, uint32_t val,
 213                           struct nlattr **nla_line)
 214 {
 215         if (!nla_line[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE])
 216                 return;
 217
 218         if (rd->json_output)
 219                 jsonw_string_field(rd->jw,
 220                                    "path-mig-state",
 221                                    path_mig_to_str(val));
 222         else
 223                 pr_out("path-mig-state %s ", path_mig_to_str(val));
 224 }
 225
 226 void print_pid(struct rd *rd, uint32_t val)
 227 {
 228         if (rd->json_output)
 229                 jsonw_uint_field(rd->jw, "pid", val);
 230         else
 231                 pr_out("pid %u ", val);
 232 }
 233
 234 void print_comm(struct rd *rd, const char *str, struct nlattr **nla_line)
 235 {
 236         char tmp[18];
 237
 238         if (rd->json_output) {
 239                 /* Don't beatify output in JSON format */
 240                 jsonw_string_field(rd->jw, "comm", str);
 241                 return;
 242         }
 243
 244         if (nla_line[RDMA_NLDEV_ATTR_RES_PID])
 245                 snprintf(tmp, sizeof(tmp), "%s", str);
 246         else
 247                 snprintf(tmp, sizeof(tmp), "[%s]", str);
 248
 249         pr_out("comm %s ", tmp);
 250 }
 251
 252 void print_dev(struct rd *rd, uint32_t idx, const char *name)
 253 {
 254         if (rd->json_output) {
 255                 jsonw_uint_field(rd->jw, "ifindex", idx);
 256                 jsonw_string_field(rd->jw, "ifname", name);
 257         } else {
 258                 pr_out("dev %s ", name);
 259         }
 260 }
 261
 262 void print_link(struct rd *rd, uint32_t idx, const char *name, uint32_t port,
 263                 struct nlattr **nla_line)
 264 {
 265         if (rd->json_output) {
 266                 jsonw_uint_field(rd->jw, "ifindex", idx);
 267
 268                 if (nla_line[RDMA_NLDEV_ATTR_PORT_INDEX])
 269                         jsonw_uint_field(rd->jw, "port", port);
 270
 271                 jsonw_string_field(rd->jw, "ifname", name);
 272         } else {
 273                 if (nla_line[RDMA_NLDEV_ATTR_PORT_INDEX])
 274                         pr_out("link %s/%u ", name, port);
 275                 else
 276                         pr_out("link %s/- ", name);
 277         }
 278 }
 279
 280 char *get_task_name(uint32_t pid)
 281 {
 282         char *comm;
 283         FILE *f;
 284
 285         if (asprintf(&comm, "/proc/%d/comm", pid) < 0)
 286                 return NULL;
 287
 288         f = fopen(comm, "r");
 289         free(comm);
 290         if (!f)
 291                 return NULL;
 292
 293         if (fscanf(f, "%ms\n", &comm) != 1)
 294                 comm = NULL;
 295
 296         fclose(f);
 297
 298         return comm;
 299 }
 300
 301 void print_key(struct rd *rd, const char *name, uint64_t val)
 302 {
 303         if (rd->json_output)
 304                 jsonw_xint_field(rd->jw, name, val);
 305         else
 306                 pr_out("%s 0x%" PRIx64 " ", name, val);
 307 }
 308
 309 void res_print_uint(struct rd *rd, const char *name, uint64_t val)
 310 {
 311         if (rd->json_output)
 312                 jsonw_uint_field(rd->jw, name, val);
 313         else
 314                 pr_out("%s %" PRIu64 " ", name, val);
 315 }
 316
 317 static int res_qp_parse_cb(const struct nlmsghdr *nlh, void *data)
 318 {
 319         struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
 320         struct nlattr *nla_table, *nla_entry;
 321         struct rd *rd = data;
 322         const char *name;
 323         uint32_t idx;
 324
 325         mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
 326         if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] ||
 327             !tb[RDMA_NLDEV_ATTR_DEV_NAME] ||
 328             !tb[RDMA_NLDEV_ATTR_RES_QP])
 329                 return MNL_CB_ERROR;
 330
 331         name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
 332         idx =  mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
 333         nla_table = tb[RDMA_NLDEV_ATTR_RES_QP];
 334
 335         mnl_attr_for_each_nested(nla_entry, nla_table) {
 336                 struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {};
 337                 uint32_t lqpn, rqpn = 0, rq_psn = 0, sq_psn;
 338                 uint8_t type, state, path_mig_state = 0;
 339                 uint32_t port = 0, pid = 0;
 340                 uint32_t pdn = 0;
 341                 char *comm = NULL;
 342                 int err;
 343
 344                 err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line);
 345                 if (err != MNL_CB_OK)
 346                         return MNL_CB_ERROR;
 347
 348                 if (!nla_line[RDMA_NLDEV_ATTR_RES_LQPN] ||
 349                     !nla_line[RDMA_NLDEV_ATTR_RES_SQ_PSN] ||
 350                     !nla_line[RDMA_NLDEV_ATTR_RES_TYPE] ||
 351                     !nla_line[RDMA_NLDEV_ATTR_RES_STATE] ||
 352                     (!nla_line[RDMA_NLDEV_ATTR_RES_PID] &&
 353                      !nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME])) {
 354                         return MNL_CB_ERROR;
 355                 }
 356
 357                 if (nla_line[RDMA_NLDEV_ATTR_PORT_INDEX])
 358                         port = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_PORT_INDEX]);
 359
 360                 if (port != rd->port_idx)
 361                         continue;
 362
 363                 lqpn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_LQPN]);
 364                 if (rd_check_is_filtered(rd, "lqpn", lqpn))
 365                         continue;
 366
 367                 if (nla_line[RDMA_NLDEV_ATTR_RES_PDN])
 368                         pdn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_PDN]);
 369                 if (rd_check_is_filtered(rd, "pdn", pdn))
 370                         continue;
 371
 372                 if (nla_line[RDMA_NLDEV_ATTR_RES_RQPN]) {
 373                         rqpn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_RQPN]);
 374                         if (rd_check_is_filtered(rd, "rqpn", rqpn))
 375                                 continue;
 376                 } else {
 377                         if (rd_check_is_key_exist(rd, "rqpn"))
 378                                 continue;
 379                 }
 380
 381                 if (nla_line[RDMA_NLDEV_ATTR_RES_RQ_PSN]) {
 382                         rq_psn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_RQ_PSN]);
 383                         if (rd_check_is_filtered(rd, "rq-psn", rq_psn))
 384                                 continue;
 385                 } else {
 386                         if (rd_check_is_key_exist(rd, "rq-psn"))
 387                                 continue;
 388                 }
 389
 390                 sq_psn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_SQ_PSN]);
 391                 if (rd_check_is_filtered(rd, "sq-psn", sq_psn))
 392                         continue;
 393
 394                 if (nla_line[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE]) {
 395                         path_mig_state = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE]);
 396                         if (rd_check_is_string_filtered(rd, "path-mig-state", path_mig_to_str(path_mig_state)))
 397                                 continue;
 398                 } else {
 399                         if (rd_check_is_key_exist(rd, "path-mig-state"))
 400                                 continue;
 401                 }
 402
 403                 type = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_TYPE]);
 404                 if (rd_check_is_string_filtered(rd, "type", qp_types_to_str(type)))
 405                         continue;
 406
 407                 state = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_STATE]);
 408                 if (rd_check_is_string_filtered(rd, "state", qp_states_to_str(state)))
 409                         continue;
 410
 411                 if (nla_line[RDMA_NLDEV_ATTR_RES_PID]) {
 412                         pid = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_PID]);
 413                         comm = get_task_name(pid);
 414                 }
 415
 416                 if (rd_check_is_filtered(rd, "pid", pid)) {
 417                         free(comm);
 418                         continue;
 419                 }
 420
 421                 if (nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME])
 422                         /* discard const from mnl_attr_get_str */
 423                         comm = (char *)mnl_attr_get_str(nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME]);
 424
 425                 if (rd->json_output)
 426                         jsonw_start_array(rd->jw);
 427
 428                 print_link(rd, idx, name, port, nla_line);
 429
 430                 print_lqpn(rd, lqpn);
 431                 if (nla_line[RDMA_NLDEV_ATTR_RES_PDN])
 432                         res_print_uint(rd, "pdn", pdn);
 433                 print_rqpn(rd, rqpn, nla_line);
 434
 435                 print_type(rd, type);
 436                 print_state(rd, state);
 437
 438                 print_rqpsn(rd, rq_psn, nla_line);
 439                 print_sqpsn(rd, sq_psn);
 440
 441                 print_pathmig(rd, path_mig_state, nla_line);
 442                 print_pid(rd, pid);
 443                 print_comm(rd, comm, nla_line);
 444
 445                 if (nla_line[RDMA_NLDEV_ATTR_RES_PID])
 446                         free(comm);
 447
 448                 print_driver_table(rd, nla_line[RDMA_NLDEV_ATTR_DRIVER]);
 449                 newline(rd);
 450         }
 451         return MNL_CB_OK;
 452 }
 453
 454 void print_users(struct rd *rd, uint64_t val)
 455 {
 456         if (rd->json_output)
 457                 jsonw_uint_field(rd->jw, "users", val);
 458         else
 459                 pr_out("users %" PRIu64 " ", val);
 460 }
 461
 462 RES_FUNC(res_no_args,   RDMA_NLDEV_CMD_RES_GET, NULL, true);
 463
 464 static const struct
 465 filters qp_valid_filters[MAX_NUMBER_OF_FILTERS] = {
 466         { .name = "link", .is_number = false },
 467         { .name = "lqpn", .is_number = true },
 468         { .name = "rqpn", .is_number = true },
 469         { .name = "pid",  .is_number = true },
 470         { .name = "sq-psn", .is_number = true },
 471         { .name = "rq-psn", .is_number = true },
 472         { .name = "type", .is_number = false },
 473         { .name = "path-mig-state", .is_number = false },
 474         { .name = "state", .is_number = false },
 475         { .name = "pdn", .is_number = true },
 476 };
 477
 478 RES_FUNC(res_qp,        RDMA_NLDEV_CMD_RES_QP_GET, qp_valid_filters, false);
 479
 480 static int res_show(struct rd *rd)
 481 {
 482         const struct rd_cmd cmds[] = {
 483                 { NULL,         res_no_args     },
 484                 { "qp",         res_qp          },
 485                 { "cm_id",      res_cm_id       },
 486                 { "cq",         res_cq          },
 487                 { "mr",         res_mr          },
 488                 { "pd",         res_pd          },
 489                 { 0 }
 490         };
 491
 492         /*
 493          * Special case to support "rdma res show DEV_NAME"
 494          */
 495         if (rd_argc(rd) == 1 && dev_map_lookup(rd, false))
 496                 return rd_exec_dev(rd, _res_no_args);
 497
 498         return rd_exec_cmd(rd, cmds, "parameter");
 499 }
 500
 501 int cmd_res(struct rd *rd)
 502 {
 503         const struct rd_cmd cmds[] = {
 504                 { NULL,         res_show },
 505                 { "show",       res_show },
 506                 { "list",       res_show },
 507                 { "help",       res_help },
 508                 { 0 }
 509         };
 510
 511         return rd_exec_cmd(rd, cmds, "resource command");
 512 }