rdma/res.h

   1 /* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */
   2 /*
   3  * res.h        RDMA tool
   4  * Authors:     Leon Romanovsky <leonro@mellanox.com>
   5  */
   6 #ifndef _RDMA_TOOL_RES_H_
   7 #define _RDMA_TOOL_RES_H_
   8
   9 #include "rdma.h"
  10
  11 int _res_send_msg(struct rd *rd, uint32_t command, mnl_cb_t callback);
  12 int _res_send_idx_msg(struct rd *rd, uint32_t command, mnl_cb_t callback,
  13                       uint32_t idx, uint32_t id);
  14
  15 int res_pd_parse_cb(const struct nlmsghdr *nlh, void *data);
  16 int res_pd_idx_parse_cb(const struct nlmsghdr *nlh, void *data);
  17 int res_mr_parse_cb(const struct nlmsghdr *nlh, void *data);
  18 int res_mr_idx_parse_cb(const struct nlmsghdr *nlh, void *data);
  19 int res_cq_parse_cb(const struct nlmsghdr *nlh, void *data);
  20 int res_cq_idx_parse_cb(const struct nlmsghdr *nlh, void *data);
  21 int res_cm_id_parse_cb(const struct nlmsghdr *nlh, void *data);
  22 int res_cm_id_idx_parse_cb(const struct nlmsghdr *nlh, void *data);
  23 int res_qp_parse_cb(const struct nlmsghdr *nlh, void *data);
  24 int res_qp_idx_parse_cb(const struct nlmsghdr *nlh, void *data);
  25
  26 static inline uint32_t res_get_command(uint32_t command, struct rd *rd)
  27 {
  28         if (!rd->show_raw)
  29                 return command;
  30
  31         switch (command) {
  32         case RDMA_NLDEV_CMD_RES_QP_GET:
  33                 return RDMA_NLDEV_CMD_RES_QP_GET_RAW;
  34         case RDMA_NLDEV_CMD_RES_CQ_GET:
  35                 return RDMA_NLDEV_CMD_RES_CQ_GET_RAW;
  36         default:
  37                 return command;
  38         }
  39 }
  40
  41 #define RES_FUNC(name, command, valid_filters, strict_port, id)                        \
  42         static inline int _##name(struct rd *rd)                                       \
  43         {                                                                              \
  44                 uint32_t idx, _command;                                                \
  45                 int ret;                                                               \
  46                 _command = res_get_command(command, rd);                               \
  47                 if (id) {                                                              \
  48                         ret = rd_doit_index(rd, &idx);                                 \
  49                         if (ret) {                                                     \
  50                                 rd->suppress_errors = true;                            \
  51                                 ret = _res_send_idx_msg(rd, _command,                  \
  52                                                         name##_idx_parse_cb,           \
  53                                                         idx, id);                      \
  54                                 if (!ret || rd->show_raw)                              \
  55                                         return ret;                                    \
  56                                 /* Fallback for old systems without .doit callbacks.   \
  57                                  * Kernel that supports raw, for sure supports doit.   \
  58                                  */                                                    \
  59                         }                                                              \
  60                 }                                                                      \
  61                 return _res_send_msg(rd, _command, name##_parse_cb);                   \
  62         }                                                                              \
  63         static inline int name(struct rd *rd)                                          \
  64         {                                                                              \
  65                 int ret = rd_build_filter(rd, valid_filters);                          \
  66                 if (ret)                                                               \
  67                         return ret;                                                    \
  68                 if ((uintptr_t)valid_filters != (uintptr_t)NULL) {                     \
  69                         ret = rd_set_arg_to_devname(rd);                               \
  70                         if (ret)                                                       \
  71                                 return ret;                                            \
  72                 }                                                                      \
  73                 if (strict_port)                                                       \
  74                         return rd_exec_dev(rd, _##name);                               \
  75                 else                                                                   \
  76                         return rd_exec_link(rd, _##name, strict_port);                 \
  77         }
  78
  79 static const
  80 struct filters pd_valid_filters[MAX_NUMBER_OF_FILTERS] = {
  81         { .name = "dev", .is_number = false },
  82         { .name = "users", .is_number = true },
  83         { .name = "pid", .is_number = true },
  84         { .name = "ctxn", .is_number = true },
  85         { .name = "pdn", .is_number = true, .is_doit = true },
  86         { .name = "ctxn", .is_number = true }
  87 };
  88
  89 RES_FUNC(res_pd, RDMA_NLDEV_CMD_RES_PD_GET, pd_valid_filters, true,
  90          RDMA_NLDEV_ATTR_RES_PDN);
  91
  92 static const
  93 struct filters mr_valid_filters[MAX_NUMBER_OF_FILTERS] = {
  94         { .name = "dev", .is_number = false },
  95         { .name = "rkey", .is_number = true },
  96         { .name = "lkey", .is_number = true },
  97         { .name = "mrlen", .is_number = true },
  98         { .name = "pid", .is_number = true },
  99         { .name = "mrn", .is_number = true, .is_doit = true },
 100         { .name = "pdn", .is_number = true }
 101 };
 102
 103 RES_FUNC(res_mr, RDMA_NLDEV_CMD_RES_MR_GET, mr_valid_filters, true,
 104          RDMA_NLDEV_ATTR_RES_MRN);
 105
 106 static const
 107 struct filters cq_valid_filters[MAX_NUMBER_OF_FILTERS] = {
 108         { .name = "dev", .is_number = false },
 109         { .name = "users", .is_number = true },
 110         { .name = "poll-ctx", .is_number = false },
 111         { .name = "pid", .is_number = true },
 112         { .name = "cqn", .is_number = true, .is_doit = true },
 113         { .name = "ctxn", .is_number = true }
 114 };
 115
 116 RES_FUNC(res_cq, RDMA_NLDEV_CMD_RES_CQ_GET, cq_valid_filters, true,
 117          RDMA_NLDEV_ATTR_RES_CQN);
 118
 119 static const
 120 struct filters cm_id_valid_filters[MAX_NUMBER_OF_FILTERS] = {
 121         { .name = "link", .is_number = false },
 122         { .name = "lqpn", .is_number = true },
 123         { .name = "qp-type", .is_number = false },
 124         { .name = "state", .is_number = false },
 125         { .name = "ps", .is_number = false },
 126         { .name = "dev-type", .is_number = false },
 127         { .name = "transport-type", .is_number = false },
 128         { .name = "pid", .is_number = true },
 129         { .name = "src-addr", .is_number = false },
 130         { .name = "src-port", .is_number = true },
 131         { .name = "dst-addr", .is_number = false },
 132         { .name = "dst-port", .is_number = true },
 133         { .name = "cm-idn", .is_number = true, .is_doit = true }
 134 };
 135
 136 RES_FUNC(res_cm_id, RDMA_NLDEV_CMD_RES_CM_ID_GET, cm_id_valid_filters, false,
 137          RDMA_NLDEV_ATTR_RES_CM_IDN);
 138
 139 static const struct
 140 filters qp_valid_filters[MAX_NUMBER_OF_FILTERS] = {
 141         { .name = "link", .is_number = false },
 142         { .name = "lqpn", .is_number = true, .is_doit = true },
 143         { .name = "rqpn", .is_number = true },
 144         { .name = "pid",  .is_number = true },
 145         { .name = "sq-psn", .is_number = true },
 146         { .name = "rq-psn", .is_number = true },
 147         { .name = "type", .is_number = false },
 148         { .name = "path-mig-state", .is_number = false },
 149         { .name = "state", .is_number = false },
 150         { .name = "pdn", .is_number = true },
 151 };
 152
 153 RES_FUNC(res_qp, RDMA_NLDEV_CMD_RES_QP_GET, qp_valid_filters, false,
 154          RDMA_NLDEV_ATTR_RES_LQPN);
 155
 156 char *get_task_name(uint32_t pid);
 157 void print_dev(struct rd *rd, uint32_t idx, const char *name);
 158 void print_link(struct rd *rd, uint32_t idx, const char *name, uint32_t port,
 159                 struct nlattr **nla_line);
 160 void print_key(struct rd *rd, const char *name, uint64_t val,
 161                struct nlattr *nlattr);
 162 void res_print_uint(struct rd *rd, const char *name, uint64_t val,
 163                     struct nlattr *nlattr);
 164 void print_comm(struct rd *rd, const char *str, struct nlattr **nla_line);
 165 const char *qp_types_to_str(uint8_t idx);
 166
 167 #endif /* _RDMA_TOOL_RES_H_ */