[mirror_iproute2.git] / rdma / dev.c

// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
/*
 * dev.c	RDMA tool
 * Authors:     Leon Romanovsky <leonro@mellanox.com>
 */

#include <fcntl.h>
#include "rdma.h"

static int dev_help(struct rd *rd)
{
	pr_out("Usage: %s dev show [DEV]\n", rd->filename);
	pr_out("       %s dev set [DEV] name DEVNAME\n", rd->filename);
	pr_out("       %s dev set [DEV] netns NSNAME\n", rd->filename);
	pr_out("       %s dev set [DEV] adaptive-moderation [on|off]\n", rd->filename);
	return 0;
}

static const char *dev_caps_to_str(uint32_t idx)
{
#define RDMA_DEV_FLAGS_LOW(x) \
	x(RESIZE_MAX_WR, 0) \
	x(BAD_PKEY_CNTR, 1) \
	x(BAD_QKEY_CNTR, 2) \
	x(RAW_MULTI, 3) \
	x(AUTO_PATH_MIG, 4) \
	x(CHANGE_PHY_PORT, 5) \
	x(UD_AV_PORT_ENFORCE_PORT_ENFORCE, 6) \
	x(CURR_QP_STATE_MOD, 7) \
	x(SHUTDOWN_PORT, 8) \
	x(INIT_TYPE, 9) \
	x(PORT_ACTIVE_EVENT, 10) \
	x(SYS_IMAGE_GUID, 11) \
	x(RC_RNR_NAK_GEN, 12) \
	x(SRQ_RESIZE, 13) \
	x(N_NOTIFY_CQ, 14) \
	x(LOCAL_DMA_LKEY, 15) \
	x(MEM_WINDOW, 17) \
	x(UD_IP_CSUM, 18) \
	x(UD_TSO, 19) \
	x(XRC, 20) \
	x(MEM_MGT_EXTENSIONS, 21) \
	x(BLOCK_MULTICAST_LOOPBACK, 22) \
	x(MEM_WINDOW_TYPE_2A, 23) \
	x(MEM_WINDOW_TYPE_2B, 24) \
	x(RC_IP_CSUM, 25) \
	x(RAW_IP_CSUM, 26) \
	x(CROSS_CHANNEL, 27) \
	x(MANAGED_FLOW_STEERING, 29) \
	x(SIGNATURE_HANDOVER, 30) \
	x(ON_DEMAND_PAGING, 31)

#define RDMA_DEV_FLAGS_HIGH(x) \
	x(SG_GAPS_REG, 0) \
	x(VIRTUAL_FUNCTION, 1) \
	x(RAW_SCATTER_FCS, 2) \
	x(RDMA_NETDEV_OPA_VNIC, 3) \
	x(PCI_WRITE_END_PADDING, 4)

	/*
	 * Separation below is needed to allow compilation of rdmatool
	 * on 32bits systems. On such systems, C-enum is limited to be
	 * int and can't hold more than 32 bits.
	 */
	enum { RDMA_DEV_FLAGS_LOW(RDMA_BITMAP_ENUM) };
	enum { RDMA_DEV_FLAGS_HIGH(RDMA_BITMAP_ENUM) };

	static const char * const
		rdma_dev_names_low[] = { RDMA_DEV_FLAGS_LOW(RDMA_BITMAP_NAMES) };
	static const char * const
		rdma_dev_names_high[] = { RDMA_DEV_FLAGS_HIGH(RDMA_BITMAP_NAMES) };
	uint32_t high_idx;
	#undef RDMA_DEV_FLAGS_LOW
	#undef RDMA_DEV_FLAGS_HIGH

	if (idx < ARRAY_SIZE(rdma_dev_names_low) && rdma_dev_names_low[idx])
		return rdma_dev_names_low[idx];

	high_idx = idx - ARRAY_SIZE(rdma_dev_names_low);
	if (high_idx <  ARRAY_SIZE(rdma_dev_names_high) &&
	    rdma_dev_names_high[high_idx])
		return rdma_dev_names_high[high_idx];

	return "UNKNOWN";
}

static void dev_print_caps(struct rd *rd, struct nlattr **tb)
{
	uint64_t caps;
	uint32_t idx;

	if (!tb[RDMA_NLDEV_ATTR_CAP_FLAGS])
		return;

	caps = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_CAP_FLAGS]);

	print_color_string(PRINT_FP, COLOR_NONE, NULL, "\n    caps: <", NULL);
	open_json_array(PRINT_JSON, "caps");
	for (idx = 0; caps; idx++) {
		if (caps & 0x1)
			print_color_string(PRINT_ANY, COLOR_NONE, NULL,
					   caps >> 0x1 ? "%s, " : "%s",
					   dev_caps_to_str(idx));
		caps >>= 0x1;
	}
	close_json_array(PRINT_ANY, ">");
}

static void dev_print_fw(struct rd *rd, struct nlattr **tb)
{
	const char *str;
	if (!tb[RDMA_NLDEV_ATTR_FW_VERSION])
		return;

	str = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_FW_VERSION]);
	print_color_string(PRINT_ANY, COLOR_NONE, "fw", "fw %s ", str);
}

static void dev_print_node_guid(struct rd *rd, struct nlattr **tb)
{
	uint64_t node_guid;
	uint16_t vp[4];
	char str[32];

	if (!tb[RDMA_NLDEV_ATTR_NODE_GUID])
		return;

	node_guid = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_NODE_GUID]);
	memcpy(vp, &node_guid, sizeof(uint64_t));
	snprintf(str, 32, "%04x:%04x:%04x:%04x", vp[3], vp[2], vp[1], vp[0]);
	print_color_string(PRINT_ANY, COLOR_NONE, "node_guid", "node_guid %s ",
			   str);
}

static void dev_print_sys_image_guid(struct rd *rd, struct nlattr **tb)
{
	uint64_t sys_image_guid;
	uint16_t vp[4];
	char str[32];

	if (!tb[RDMA_NLDEV_ATTR_SYS_IMAGE_GUID])
		return;

	sys_image_guid = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_SYS_IMAGE_GUID]);
	memcpy(vp, &sys_image_guid, sizeof(uint64_t));
	snprintf(str, 32, "%04x:%04x:%04x:%04x", vp[3], vp[2], vp[1], vp[0]);
	print_color_string(PRINT_ANY, COLOR_NONE, "sys_image_guid",
			   "sys_image_guid %s ", str);
}

static void dev_print_dim_setting(struct rd *rd, struct nlattr **tb)
{
	uint8_t dim_setting;

	if (!tb[RDMA_NLDEV_ATTR_DEV_DIM])
		return;

	dim_setting = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_DEV_DIM]);
	if (dim_setting > 1)
		return;

	print_on_off(PRINT_ANY, "adaptive-moderation", "adaptive-moderation %s ", dim_setting);

}

static const char *node_type_to_str(uint8_t node_type)
{
	static const char * const node_type_str[] = { "unknown", "ca",
						      "switch", "router",
						      "rnic", "usnic",
						      "usnic_udp",
						      "unspecified" };
	if (node_type < ARRAY_SIZE(node_type_str))
		return node_type_str[node_type];
	return "unknown";
}

static void dev_print_node_type(struct rd *rd, struct nlattr **tb)
{
	const char *node_str;
	uint8_t node_type;

	if (!tb[RDMA_NLDEV_ATTR_DEV_NODE_TYPE])
		return;

	node_type = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_DEV_NODE_TYPE]);
	node_str = node_type_to_str(node_type);
	print_color_string(PRINT_ANY, COLOR_NONE, "node_type", "node_type %s ",
			   node_str);
}

static int dev_parse_cb(const struct nlmsghdr *nlh, void *data)
{
	struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
	struct rd *rd = data;
	const char *name;
	uint32_t idx;

	mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
	if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !tb[RDMA_NLDEV_ATTR_DEV_NAME])
		return MNL_CB_ERROR;
	open_json_object(NULL);
	idx =  mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
	name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
	print_color_uint(PRINT_ANY, COLOR_NONE, "ifindex", "%u: ", idx);
	print_color_string(PRINT_ANY, COLOR_NONE, "ifname", "%s: ", name);

	dev_print_node_type(rd, tb);
	dev_print_fw(rd, tb);
	dev_print_node_guid(rd, tb);
	dev_print_sys_image_guid(rd, tb);
	if (rd->show_details) {
		dev_print_dim_setting(rd, tb);
		dev_print_caps(rd, tb);
	}

	newline(rd);
	return MNL_CB_OK;
}

static int dev_no_args(struct rd *rd)
{
	uint32_t seq;
	int ret;

	rd_prepare_msg(rd, RDMA_NLDEV_CMD_GET,
		       &seq, (NLM_F_REQUEST | NLM_F_ACK));
	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
	ret = rd_send_msg(rd);
	if (ret)
		return ret;

	ret = rd_recv_msg(rd, dev_parse_cb, rd, seq);
	return ret;
}

static int dev_one_show(struct rd *rd)
{
	const struct rd_cmd cmds[] = {
		{ NULL,		dev_no_args},
		{ 0 }
	};

	return rd_exec_cmd(rd, cmds, "parameter");
}

static int dev_set_name(struct rd *rd)
{
	uint32_t seq;

	if (rd_no_arg(rd)) {
		pr_err("Please provide device new name.\n");
		return -EINVAL;
	}

	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SET,
		       &seq, (NLM_F_REQUEST | NLM_F_ACK));
	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
	mnl_attr_put_strz(rd->nlh, RDMA_NLDEV_ATTR_DEV_NAME, rd_argv(rd));

	return rd_sendrecv_msg(rd, seq);
}

static int dev_set_netns(struct rd *rd)
{
	char *netns_path;
	uint32_t seq;
	int netns;
	int ret;

	if (rd_no_arg(rd)) {
		pr_err("Please provide device name.\n");
		return -EINVAL;
	}

	if (asprintf(&netns_path, "%s/%s", NETNS_RUN_DIR, rd_argv(rd)) < 0)
		return -ENOMEM;

	netns = open(netns_path, O_RDONLY | O_CLOEXEC);
	if (netns < 0) {
		fprintf(stderr, "Cannot open network namespace \"%s\": %s\n",
			rd_argv(rd), strerror(errno));
		ret = -EINVAL;
		goto done;
	}

	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SET,
		       &seq, (NLM_F_REQUEST | NLM_F_ACK));
	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_NET_NS_FD, netns);
	ret = rd_sendrecv_msg(rd, seq);
	close(netns);
done:
	free(netns_path);
	return ret;
}

static int dev_set_dim_sendmsg(struct rd *rd, uint8_t dim_setting)
{
	uint32_t seq;

	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SET, &seq,
		       (NLM_F_REQUEST | NLM_F_ACK));
	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
	mnl_attr_put_u8(rd->nlh, RDMA_NLDEV_ATTR_DEV_DIM, dim_setting);

	return rd_sendrecv_msg(rd, seq);
}

static int dev_set_dim_off(struct rd *rd)
{
	return dev_set_dim_sendmsg(rd, 0);
}

static int dev_set_dim_on(struct rd *rd)
{
	return dev_set_dim_sendmsg(rd, 1);
}

static int dev_set_dim(struct rd *rd)
{
	const struct rd_cmd cmds[] = {
		{ NULL,		dev_help},
		{ "on",		dev_set_dim_on},
		{ "off",	dev_set_dim_off},
		{ 0 }
	};

	return rd_exec_cmd(rd, cmds, "parameter");
}

static int dev_one_set(struct rd *rd)
{
	const struct rd_cmd cmds[] = {
		{ NULL,		dev_help},
		{ "name",	dev_set_name},
		{ "netns",	dev_set_netns},
		{ "adaptive-moderation",	dev_set_dim},
		{ 0 }
	};

	return rd_exec_cmd(rd, cmds, "parameter");
}

static int dev_show(struct rd *rd)
{
	return rd_exec_dev(rd, dev_one_show);
}

static int dev_set(struct rd *rd)
{
	return rd_exec_require_dev(rd, dev_one_set);
}

int cmd_dev(struct rd *rd)
{
	const struct rd_cmd cmds[] = {
		{ NULL,		dev_show },
		{ "show",	dev_show },
		{ "list",	dev_show },
		{ "set",	dev_set },
		{ "help",	dev_help },
		{ 0 }
	};

	return rd_exec_cmd(rd, cmds, "dev command");
}
Commit	Line	Data
835d8321	1	// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
40df8263 LR	2	/*
40df8263 LR	3	* dev.c RDMA tool
40df8263 LR	4	* Authors: Leon Romanovsky <leonro@mellanox.com>
	5	*/
	6
d17a0248	7	#include <fcntl.h>
40df8263 LR	8	#include "rdma.h"
	9
	10	static int dev_help(struct rd *rd)
	11	{
	12	pr_out("Usage: %s dev show [DEV]\n", rd->filename);
4443c9c6	13	pr_out(" %s dev set [DEV] name DEVNAME\n", rd->filename);
d17a0248	14	pr_out(" %s dev set [DEV] netns NSNAME\n", rd->filename);
8a56ef32	15	pr_out(" %s dev set [DEV] adaptive-moderation [on\|off]\n", rd->filename);
40df8263 LR	16	return 0;
	17	}
	18
	19	static const char *dev_caps_to_str(uint32_t idx)
	20	{
378dd31b	21	#define RDMA_DEV_FLAGS_LOW(x) \
40df8263 LR	22	x(RESIZE_MAX_WR, 0) \
	23	x(BAD_PKEY_CNTR, 1) \
	24	x(BAD_QKEY_CNTR, 2) \
	25	x(RAW_MULTI, 3) \
	26	x(AUTO_PATH_MIG, 4) \
	27	x(CHANGE_PHY_PORT, 5) \
	28	x(UD_AV_PORT_ENFORCE_PORT_ENFORCE, 6) \
	29	x(CURR_QP_STATE_MOD, 7) \
	30	x(SHUTDOWN_PORT, 8) \
	31	x(INIT_TYPE, 9) \
	32	x(PORT_ACTIVE_EVENT, 10) \
	33	x(SYS_IMAGE_GUID, 11) \
	34	x(RC_RNR_NAK_GEN, 12) \
	35	x(SRQ_RESIZE, 13) \
	36	x(N_NOTIFY_CQ, 14) \
	37	x(LOCAL_DMA_LKEY, 15) \
	38	x(MEM_WINDOW, 17) \
	39	x(UD_IP_CSUM, 18) \
	40	x(UD_TSO, 19) \
	41	x(XRC, 20) \
	42	x(MEM_MGT_EXTENSIONS, 21) \
	43	x(BLOCK_MULTICAST_LOOPBACK, 22) \
	44	x(MEM_WINDOW_TYPE_2A, 23) \
	45	x(MEM_WINDOW_TYPE_2B, 24) \
	46	x(RC_IP_CSUM, 25) \
	47	x(RAW_IP_CSUM, 26) \
	48	x(CROSS_CHANNEL, 27) \
	49	x(MANAGED_FLOW_STEERING, 29) \
	50	x(SIGNATURE_HANDOVER, 30) \
378dd31b	51	x(ON_DEMAND_PAGING, 31)
40df8263	52
378dd31b LR	53	#define RDMA_DEV_FLAGS_HIGH(x) \
	54	x(SG_GAPS_REG, 0) \
	55	x(VIRTUAL_FUNCTION, 1) \
	56	x(RAW_SCATTER_FCS, 2) \
	57	x(RDMA_NETDEV_OPA_VNIC, 3) \
	58	x(PCI_WRITE_END_PADDING, 4)
40df8263	59
378dd31b LR	60	/*
	61	* Separation below is needed to allow compilation of rdmatool
	62	* on 32bits systems. On such systems, C-enum is limited to be
	63	* int and can't hold more than 32 bits.
	64	*/
	65	enum { RDMA_DEV_FLAGS_LOW(RDMA_BITMAP_ENUM) };
	66	enum { RDMA_DEV_FLAGS_HIGH(RDMA_BITMAP_ENUM) };
	67
	68	static const char * const
	69	rdma_dev_names_low[] = { RDMA_DEV_FLAGS_LOW(RDMA_BITMAP_NAMES) };
40df8263	70	static const char * const
378dd31b LR	71	rdma_dev_names_high[] = { RDMA_DEV_FLAGS_HIGH(RDMA_BITMAP_NAMES) };
	72	uint32_t high_idx;
	73	#undef RDMA_DEV_FLAGS_LOW
	74	#undef RDMA_DEV_FLAGS_HIGH
	75
	76	if (idx < ARRAY_SIZE(rdma_dev_names_low) && rdma_dev_names_low[idx])
	77	return rdma_dev_names_low[idx];
	78
	79	high_idx = idx - ARRAY_SIZE(rdma_dev_names_low);
	80	if (high_idx < ARRAY_SIZE(rdma_dev_names_high) &&
	81	rdma_dev_names_high[high_idx])
	82	return rdma_dev_names_high[high_idx];
40df8263	83
40df8263 LR	84	return "UNKNOWN";
	85	}
	86
ef353e2e	87	static void dev_print_caps(struct rd rd, struct nlattr *tb)
40df8263 LR	88	{
	89	uint64_t caps;
	90	uint32_t idx;
	91
	92	if (!tb[RDMA_NLDEV_ATTR_CAP_FLAGS])
	93	return;
	94
	95	caps = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_CAP_FLAGS]);
	96
b0a688a5 IK	97	print_color_string(PRINT_FP, COLOR_NONE, NULL, "\n caps: <", NULL);
b0a688a5 IK	98	open_json_array(PRINT_JSON, "caps");
40df8263	99	for (idx = 0; caps; idx++) {
b0a688a5 IK	100	if (caps & 0x1)
	101	print_color_string(PRINT_ANY, COLOR_NONE, NULL,
	102	caps >> 0x1 ? "%s, " : "%s",
	103	dev_caps_to_str(idx));
40df8263 LR	104	caps >>= 0x1;
40df8263 LR	105	}
b0a688a5	106	close_json_array(PRINT_ANY, ">");
40df8263 LR	107	}
40df8263 LR	108
ef353e2e	109	static void dev_print_fw(struct rd rd, struct nlattr *tb)
40df8263	110	{
ef353e2e	111	const char *str;
40df8263 LR	112	if (!tb[RDMA_NLDEV_ATTR_FW_VERSION])
	113	return;
	114
ef353e2e	115	str = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_FW_VERSION]);
b0a688a5	116	print_color_string(PRINT_ANY, COLOR_NONE, "fw", "fw %s ", str);
40df8263 LR	117	}
40df8263 LR	118
ef353e2e	119	static void dev_print_node_guid(struct rd rd, struct nlattr *tb)
40df8263 LR	120	{
40df8263 LR	121	uint64_t node_guid;
ef353e2e LR	122	uint16_t vp[4];
ef353e2e LR	123	char str[32];
40df8263 LR	124
	125	if (!tb[RDMA_NLDEV_ATTR_NODE_GUID])
	126	return;
	127
	128	node_guid = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_NODE_GUID]);
ef353e2e LR	129	memcpy(vp, &node_guid, sizeof(uint64_t));
ef353e2e LR	130	snprintf(str, 32, "%04x:%04x:%04x:%04x", vp[3], vp[2], vp[1], vp[0]);
b0a688a5 IK	131	print_color_string(PRINT_ANY, COLOR_NONE, "node_guid", "node_guid %s ",
b0a688a5 IK	132	str);
40df8263 LR	133	}
40df8263 LR	134
ef353e2e	135	static void dev_print_sys_image_guid(struct rd rd, struct nlattr *tb)
40df8263 LR	136	{
40df8263 LR	137	uint64_t sys_image_guid;
ef353e2e LR	138	uint16_t vp[4];
ef353e2e LR	139	char str[32];
40df8263 LR	140
	141	if (!tb[RDMA_NLDEV_ATTR_SYS_IMAGE_GUID])
	142	return;
	143
	144	sys_image_guid = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_SYS_IMAGE_GUID]);
ef353e2e LR	145	memcpy(vp, &sys_image_guid, sizeof(uint64_t));
ef353e2e LR	146	snprintf(str, 32, "%04x:%04x:%04x:%04x", vp[3], vp[2], vp[1], vp[0]);
b0a688a5 IK	147	print_color_string(PRINT_ANY, COLOR_NONE, "sys_image_guid",
b0a688a5 IK	148	"sys_image_guid %s ", str);
40df8263 LR	149	}
40df8263 LR	150
8a56ef32 YF	151	static void dev_print_dim_setting(struct rd rd, struct nlattr *tb)
	152	{
	153	uint8_t dim_setting;
	154
	155	if (!tb[RDMA_NLDEV_ATTR_DEV_DIM])
	156	return;
	157
	158	dim_setting = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_DEV_DIM]);
	159	if (dim_setting > 1)
	160	return;
	161
9091ff02	162	print_on_off(PRINT_ANY, "adaptive-moderation", "adaptive-moderation %s ", dim_setting);
8a56ef32 YF	163
	164	}
	165
40df8263 LR	166	static const char *node_type_to_str(uint8_t node_type)
	167	{
	168	static const char * const node_type_str[] = { "unknown", "ca",
	169	"switch", "router",
	170	"rnic", "usnic",
7087f7c0 GP	171	"usnic_udp",
7087f7c0 GP	172	"unspecified" };
40df8263 LR	173	if (node_type < ARRAY_SIZE(node_type_str))
	174	return node_type_str[node_type];
	175	return "unknown";
	176	}
	177
ef353e2e	178	static void dev_print_node_type(struct rd rd, struct nlattr *tb)
40df8263	179	{
ef353e2e	180	const char *node_str;
40df8263 LR	181	uint8_t node_type;
	182
	183	if (!tb[RDMA_NLDEV_ATTR_DEV_NODE_TYPE])
	184	return;
	185
	186	node_type = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_DEV_NODE_TYPE]);
ef353e2e	187	node_str = node_type_to_str(node_type);
b0a688a5 IK	188	print_color_string(PRINT_ANY, COLOR_NONE, "node_type", "node_type %s ",
b0a688a5 IK	189	node_str);
40df8263 LR	190	}
	191
	192	static int dev_parse_cb(const struct nlmsghdr nlh, void data)
	193	{
	194	struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
	195	struct rd *rd = data;
ef353e2e LR	196	const char *name;
ef353e2e LR	197	uint32_t idx;
40df8263 LR	198
	199	mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
	200	if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] \|\| !tb[RDMA_NLDEV_ATTR_DEV_NAME])
	201	return MNL_CB_ERROR;
b0a688a5	202	open_json_object(NULL);
ef353e2e LR	203	idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
ef353e2e LR	204	name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
b0a688a5 IK	205	print_color_uint(PRINT_ANY, COLOR_NONE, "ifindex", "%u: ", idx);
b0a688a5 IK	206	print_color_string(PRINT_ANY, COLOR_NONE, "ifname", "%s: ", name);
ef353e2e LR	207
	208	dev_print_node_type(rd, tb);
	209	dev_print_fw(rd, tb);
	210	dev_print_node_guid(rd, tb);
	211	dev_print_sys_image_guid(rd, tb);
8a56ef32 YF	212	if (rd->show_details) {
8a56ef32 YF	213	dev_print_dim_setting(rd, tb);
ef353e2e	214	dev_print_caps(rd, tb);
8a56ef32	215	}
40df8263	216
b0a688a5	217	newline(rd);
40df8263 LR	218	return MNL_CB_OK;
	219	}
	220
	221	static int dev_no_args(struct rd *rd)
	222	{
	223	uint32_t seq;
	224	int ret;
	225
	226	rd_prepare_msg(rd, RDMA_NLDEV_CMD_GET,
	227	&seq, (NLM_F_REQUEST \| NLM_F_ACK));
	228	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
	229	ret = rd_send_msg(rd);
	230	if (ret)
	231	return ret;
	232
ef353e2e	233	ret = rd_recv_msg(rd, dev_parse_cb, rd, seq);
ef353e2e	234	return ret;
40df8263 LR	235	}
	236
	237	static int dev_one_show(struct rd *rd)
	238	{
	239	const struct rd_cmd cmds[] = {
	240	{ NULL, dev_no_args},
	241	{ 0 }
	242	};
	243
	244	return rd_exec_cmd(rd, cmds, "parameter");
	245	}
	246
4443c9c6 LR	247	static int dev_set_name(struct rd *rd)
	248	{
	249	uint32_t seq;
	250
	251	if (rd_no_arg(rd)) {
	252	pr_err("Please provide device new name.\n");
	253	return -EINVAL;
	254	}
	255
	256	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SET,
	257	&seq, (NLM_F_REQUEST \| NLM_F_ACK));
	258	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
	259	mnl_attr_put_strz(rd->nlh, RDMA_NLDEV_ATTR_DEV_NAME, rd_argv(rd));
	260
8f5cfd23	261	return rd_sendrecv_msg(rd, seq);
4443c9c6 LR	262	}
4443c9c6 LR	263
d17a0248 PP	264	static int dev_set_netns(struct rd *rd)
	265	{
	266	char *netns_path;
	267	uint32_t seq;
	268	int netns;
	269	int ret;
	270
	271	if (rd_no_arg(rd)) {
	272	pr_err("Please provide device name.\n");
	273	return -EINVAL;
	274	}
	275
	276	if (asprintf(&netns_path, "%s/%s", NETNS_RUN_DIR, rd_argv(rd)) < 0)
	277	return -ENOMEM;
	278
	279	netns = open(netns_path, O_RDONLY \| O_CLOEXEC);
	280	if (netns < 0) {
	281	fprintf(stderr, "Cannot open network namespace \"%s\": %s\n",
	282	rd_argv(rd), strerror(errno));
	283	ret = -EINVAL;
	284	goto done;
	285	}
	286
	287	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SET,
	288	&seq, (NLM_F_REQUEST \| NLM_F_ACK));
	289	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
	290	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_NET_NS_FD, netns);
	291	ret = rd_sendrecv_msg(rd, seq);
	292	close(netns);
	293	done:
	294	free(netns_path);
	295	return ret;
	296	}
	297
8a56ef32 YF	298	static int dev_set_dim_sendmsg(struct rd *rd, uint8_t dim_setting)
	299	{
	300	uint32_t seq;
	301
	302	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SET, &seq,
	303	(NLM_F_REQUEST \| NLM_F_ACK));
	304	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
	305	mnl_attr_put_u8(rd->nlh, RDMA_NLDEV_ATTR_DEV_DIM, dim_setting);
	306
	307	return rd_sendrecv_msg(rd, seq);
	308	}
	309
	310	static int dev_set_dim_off(struct rd *rd)
	311	{
	312	return dev_set_dim_sendmsg(rd, 0);
	313	}
	314
	315	static int dev_set_dim_on(struct rd *rd)
	316	{
	317	return dev_set_dim_sendmsg(rd, 1);
	318	}
	319
	320	static int dev_set_dim(struct rd *rd)
	321	{
	322	const struct rd_cmd cmds[] = {
	323	{ NULL, dev_help},
	324	{ "on", dev_set_dim_on},
	325	{ "off", dev_set_dim_off},
	326	{ 0 }
	327	};
	328
	329	return rd_exec_cmd(rd, cmds, "parameter");
	330	}
	331
4443c9c6 LR	332	static int dev_one_set(struct rd *rd)
	333	{
	334	const struct rd_cmd cmds[] = {
	335	{ NULL, dev_help},
	336	{ "name", dev_set_name},
d17a0248	337	{ "netns", dev_set_netns},
8a56ef32	338	{ "adaptive-moderation", dev_set_dim},
4443c9c6 LR	339	{ 0 }
	340	};
	341
	342	return rd_exec_cmd(rd, cmds, "parameter");
	343	}
	344
40df8263 LR	345	static int dev_show(struct rd *rd)
40df8263 LR	346	{
8b92a2c9	347	return rd_exec_dev(rd, dev_one_show);
40df8263 LR	348	}
40df8263 LR	349
4443c9c6 LR	350	static int dev_set(struct rd *rd)
	351	{
	352	return rd_exec_require_dev(rd, dev_one_set);
	353	}
	354
40df8263 LR	355	int cmd_dev(struct rd *rd)
	356	{
	357	const struct rd_cmd cmds[] = {
	358	{ NULL, dev_show },
	359	{ "show", dev_show },
	360	{ "list", dev_show },
4443c9c6	361	{ "set", dev_set },
40df8263 LR	362	{ "help", dev_help },
	363	{ 0 }
	364	};
	365
	366	return rd_exec_cmd(rd, cmds, "dev command");
	367	}