[mirror_iproute2.git] / rdma / res.h

/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */
/*
 * res.h	RDMA tool
 * Authors:     Leon Romanovsky <leonro@mellanox.com>
 */
#ifndef _RDMA_TOOL_RES_H_
#define _RDMA_TOOL_RES_H_

#include "rdma.h"

int _res_send_msg(struct rd *rd, uint32_t command, mnl_cb_t callback);
int _res_send_idx_msg(struct rd *rd, uint32_t command, mnl_cb_t callback,
		      uint32_t idx, uint32_t id);

int res_pd_parse_cb(const struct nlmsghdr *nlh, void *data);
int res_pd_idx_parse_cb(const struct nlmsghdr *nlh, void *data);
int res_mr_parse_cb(const struct nlmsghdr *nlh, void *data);
int res_mr_idx_parse_cb(const struct nlmsghdr *nlh, void *data);
int res_cq_parse_cb(const struct nlmsghdr *nlh, void *data);
int res_cq_idx_parse_cb(const struct nlmsghdr *nlh, void *data);
int res_cm_id_parse_cb(const struct nlmsghdr *nlh, void *data);
int res_cm_id_idx_parse_cb(const struct nlmsghdr *nlh, void *data);
int res_qp_parse_cb(const struct nlmsghdr *nlh, void *data);
int res_qp_idx_parse_cb(const struct nlmsghdr *nlh, void *data);

static inline uint32_t res_get_command(uint32_t command, struct rd *rd)
{
	if (!rd->show_raw)
		return command;

	switch (command) {
	case RDMA_NLDEV_CMD_RES_QP_GET:
		return RDMA_NLDEV_CMD_RES_QP_GET_RAW;
	case RDMA_NLDEV_CMD_RES_CQ_GET:
		return RDMA_NLDEV_CMD_RES_CQ_GET_RAW;
	case RDMA_NLDEV_CMD_RES_MR_GET:
		return RDMA_NLDEV_CMD_RES_MR_GET_RAW;
	default:
		return command;
	}
}

#define RES_FUNC(name, command, valid_filters, strict_port, id)                        \
	static inline int _##name(struct rd *rd)                                       \
	{                                                                              \
		uint32_t idx, _command;                                                \
		int ret;                                                               \
		_command = res_get_command(command, rd);			       \
		if (id) {                                                              \
			ret = rd_doit_index(rd, &idx);                                 \
			if (ret) {                                                     \
				rd->suppress_errors = true;                            \
				ret = _res_send_idx_msg(rd, _command,                  \
							name##_idx_parse_cb,           \
							idx, id);                      \
				if (!ret || rd->show_raw)                              \
					return ret;                                    \
				/* Fallback for old systems without .doit callbacks.   \
				 * Kernel that supports raw, for sure supports doit.   \
				 */						       \
			}                                                              \
		}                                                                      \
		return _res_send_msg(rd, _command, name##_parse_cb);                   \
	}                                                                              \
	static inline int name(struct rd *rd)                                          \
	{                                                                              \
		int ret = rd_build_filter(rd, valid_filters);                          \
		if (ret)                                                               \
			return ret;                                                    \
		if ((uintptr_t)valid_filters != (uintptr_t)NULL) {                     \
			ret = rd_set_arg_to_devname(rd);                               \
			if (ret)                                                       \
				return ret;                                            \
		}                                                                      \
		if (strict_port)                                                       \
			return rd_exec_dev(rd, _##name);                               \
		else                                                                   \
			return rd_exec_link(rd, _##name, strict_port);                 \
	}

static const
struct filters pd_valid_filters[MAX_NUMBER_OF_FILTERS] = {
	{ .name = "dev", .is_number = false },
	{ .name = "users", .is_number = true },
	{ .name = "pid", .is_number = true },
	{ .name = "ctxn", .is_number = true },
	{ .name = "pdn", .is_number = true, .is_doit = true },
	{ .name = "ctxn", .is_number = true }
};

RES_FUNC(res_pd, RDMA_NLDEV_CMD_RES_PD_GET, pd_valid_filters, true,
	 RDMA_NLDEV_ATTR_RES_PDN);

static const
struct filters mr_valid_filters[MAX_NUMBER_OF_FILTERS] = {
	{ .name = "dev", .is_number = false },
	{ .name = "rkey", .is_number = true },
	{ .name = "lkey", .is_number = true },
	{ .name = "mrlen", .is_number = true },
	{ .name = "pid", .is_number = true },
	{ .name = "mrn", .is_number = true, .is_doit = true },
	{ .name = "pdn", .is_number = true }
};

RES_FUNC(res_mr, RDMA_NLDEV_CMD_RES_MR_GET, mr_valid_filters, true,
	 RDMA_NLDEV_ATTR_RES_MRN);

static const
struct filters cq_valid_filters[MAX_NUMBER_OF_FILTERS] = {
	{ .name = "dev", .is_number = false },
	{ .name = "users", .is_number = true },
	{ .name = "poll-ctx", .is_number = false },
	{ .name = "pid", .is_number = true },
	{ .name = "cqn", .is_number = true, .is_doit = true },
	{ .name = "ctxn", .is_number = true }
};

RES_FUNC(res_cq, RDMA_NLDEV_CMD_RES_CQ_GET, cq_valid_filters, true,
	 RDMA_NLDEV_ATTR_RES_CQN);

static const
struct filters cm_id_valid_filters[MAX_NUMBER_OF_FILTERS] = {
	{ .name = "link", .is_number = false },
	{ .name = "lqpn", .is_number = true },
	{ .name = "qp-type", .is_number = false },
	{ .name = "state", .is_number = false },
	{ .name = "ps", .is_number = false },
	{ .name = "dev-type", .is_number = false },
	{ .name = "transport-type", .is_number = false },
	{ .name = "pid", .is_number = true },
	{ .name = "src-addr", .is_number = false },
	{ .name = "src-port", .is_number = true },
	{ .name = "dst-addr", .is_number = false },
	{ .name = "dst-port", .is_number = true },
	{ .name = "cm-idn", .is_number = true, .is_doit = true }
};

RES_FUNC(res_cm_id, RDMA_NLDEV_CMD_RES_CM_ID_GET, cm_id_valid_filters, false,
	 RDMA_NLDEV_ATTR_RES_CM_IDN);

static const struct
filters qp_valid_filters[MAX_NUMBER_OF_FILTERS] = {
	{ .name = "link", .is_number = false },
	{ .name = "lqpn", .is_number = true, .is_doit = true },
	{ .name = "rqpn", .is_number = true },
	{ .name = "pid",  .is_number = true },
	{ .name = "sq-psn", .is_number = true },
	{ .name = "rq-psn", .is_number = true },
	{ .name = "type", .is_number = false },
	{ .name = "path-mig-state", .is_number = false },
	{ .name = "state", .is_number = false },
	{ .name = "pdn", .is_number = true },
};

RES_FUNC(res_qp, RDMA_NLDEV_CMD_RES_QP_GET, qp_valid_filters, false,
	 RDMA_NLDEV_ATTR_RES_LQPN);

char *get_task_name(uint32_t pid);
void print_dev(struct rd *rd, uint32_t idx, const char *name);
void print_link(struct rd *rd, uint32_t idx, const char *name, uint32_t port,
		struct nlattr **nla_line);
void print_key(struct rd *rd, const char *name, uint64_t val,
	       struct nlattr *nlattr);
void res_print_uint(struct rd *rd, const char *name, uint64_t val,
		    struct nlattr *nlattr);
void print_comm(struct rd *rd, const char *str, struct nlattr **nla_line);
const char *qp_types_to_str(uint8_t idx);

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