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