[mirror_iproute2.git] / rdma / link.c

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

#include "rdma.h"

static int link_help(struct rd *rd)
{
	pr_out("Usage: %s link show [DEV/PORT_INDEX]\n", rd->filename);
	pr_out("Usage: %s link add NAME type TYPE netdev NETDEV\n",
	       rd->filename);
	pr_out("Usage: %s link delete NAME\n", rd->filename);
	return 0;
}

static const char *caps_to_str(uint32_t idx)
{
#define RDMA_PORT_FLAGS_LOW(x) \
	x(RESERVED, 0) \
	x(SM, 1) \
	x(NOTICE, 2) \
	x(TRAP, 3) \
	x(OPT_IPD, 4) \
	x(AUTO_MIGR, 5) \
	x(SL_MAP, 6) \
	x(MKEY_NVRAM, 7) \
	x(PKEY_NVRAM, 8) \
	x(LED_INFO, 9) \
	x(SM_DISABLED, 10) \
	x(SYS_IMAGE_GUID, 11) \
	x(PKEY_SW_EXT_PORT_TRAP, 12) \
	x(CABLE_INFO, 13) \
	x(EXTENDED_SPEEDS, 14) \
	x(CAP_MASK2, 15) \
	x(CM, 16) \
	x(SNMP_TUNNEL, 17) \
	x(REINIT, 18) \
	x(DEVICE_MGMT, 19) \
	x(VENDOR_CLASS, 20) \
	x(DR_NOTICE, 21) \
	x(CAP_MASK_NOTICE, 22) \
	x(BOOT_MGMT, 23) \
	x(LINK_LATENCY, 24) \
	x(CLIENT_REG, 25) \
	x(OTHER_LOCAL_CHANGES, 26) \
	x(LINK_SPPED_WIDTH, 27) \
	x(VENDOR_SPECIFIC_MADS, 28) \
	x(MULT_PKER_TRAP, 29) \
	x(MULT_FDB, 30) \
	x(HIERARCHY_INFO, 31)

#define RDMA_PORT_FLAGS_HIGH(x) \
	x(SET_NODE_DESC, 0) \
	x(EXT_INFO, 1) \
	x(VIRT, 2) \
	x(SWITCH_POR_STATE_TABLE, 3) \
	x(LINK_WIDTH_2X, 4) \
	x(LINK_SPEED_HDR, 5)

	/*
	 * 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_PORT_FLAGS_LOW(RDMA_BITMAP_ENUM) };
	enum { RDMA_PORT_FLAGS_HIGH(RDMA_BITMAP_ENUM) };

	static const char * const
		rdma_port_names_low[] = { RDMA_PORT_FLAGS_LOW(RDMA_BITMAP_NAMES) };
	static const char * const
		rdma_port_names_high[] = { RDMA_PORT_FLAGS_HIGH(RDMA_BITMAP_NAMES) };
	uint32_t high_idx;
	#undef RDMA_PORT_FLAGS_LOW
	#undef RDMA_PORT_FLAGS_HIGH

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

	high_idx = idx - ARRAY_SIZE(rdma_port_names_low);
	if (high_idx < ARRAY_SIZE(rdma_port_names_high) &&
	    rdma_port_names_high[high_idx])
		return rdma_port_names_high[high_idx];

	return "UNKNOWN";
}

static void link_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",
					   caps_to_str(idx));
		caps >>= 0x1;
	}
	close_json_array(PRINT_ANY, ">");
}

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

	if (!tb[RDMA_NLDEV_ATTR_SUBNET_PREFIX])
		return;

	subnet_prefix = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_SUBNET_PREFIX]);
	memcpy(vp, &subnet_prefix, 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, "subnet_prefix",
			   "subnet_prefix %s ", str);
}

static void link_print_lid(struct rd *rd, struct nlattr **tb)
{
	uint32_t lid;

	if (!tb[RDMA_NLDEV_ATTR_LID])
		return;

	lid = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_LID]);
	print_color_uint(PRINT_ANY, COLOR_NONE, "lid", "lid %u ", lid);
}

static void link_print_sm_lid(struct rd *rd, struct nlattr **tb)
{
	uint32_t sm_lid;

	if (!tb[RDMA_NLDEV_ATTR_SM_LID])
		return;

	sm_lid = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_SM_LID]);
	print_color_uint(PRINT_ANY, COLOR_NONE, "sm_lid", "sm_lid %u ", sm_lid);
}

static void link_print_lmc(struct rd *rd, struct nlattr **tb)
{
	uint8_t lmc;

	if (!tb[RDMA_NLDEV_ATTR_LMC])
		return;

	lmc = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_LMC]);
	print_color_uint(PRINT_ANY, COLOR_NONE, "lmc", "lmc %u ", lmc);
}

static const char *link_state_to_str(uint8_t link_state)
{
	static const char * const link_state_str[] = { "NOP", "DOWN",
						       "INIT", "ARMED",
						       "ACTIVE",
						       "ACTIVE_DEFER" };
	if (link_state < ARRAY_SIZE(link_state_str))
		return link_state_str[link_state];
	return "UNKNOWN";
}

static void link_print_state(struct rd *rd, struct nlattr **tb)
{
	uint8_t state;

	if (!tb[RDMA_NLDEV_ATTR_PORT_STATE])
		return;

	state = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_PORT_STATE]);
	print_color_string(PRINT_ANY, COLOR_NONE, "state", "state %s ",
			   link_state_to_str(state));
}

static const char *phys_state_to_str(uint8_t phys_state)
{
	static const char * const phys_state_str[] = { "NOP", "SLEEP",
						       "POLLING", "DISABLED",
						       "ARMED", "LINK_UP",
						       "LINK_ERROR_RECOVER",
						       "PHY_TEST", "UNKNOWN",
						       "OPA_OFFLINE",
						       "UNKNOWN", "OPA_TEST" };
	if (phys_state < ARRAY_SIZE(phys_state_str))
		return phys_state_str[phys_state];
	return "UNKNOWN";
};

static void link_print_phys_state(struct rd *rd, struct nlattr **tb)
{
	uint8_t phys_state;

	if (!tb[RDMA_NLDEV_ATTR_PORT_PHYS_STATE])
		return;

	phys_state = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_PORT_PHYS_STATE]);
	print_color_string(PRINT_ANY, COLOR_NONE, "physical_state",
			   "physical_state %s ", phys_state_to_str(phys_state));
}

static void link_print_netdev(struct rd *rd, struct nlattr **tb)
{
	const char *netdev_name;
	uint32_t idx;

	if (!tb[RDMA_NLDEV_ATTR_NDEV_NAME] || !tb[RDMA_NLDEV_ATTR_NDEV_INDEX])
		return;

	netdev_name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_NDEV_NAME]);
	idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_NDEV_INDEX]);
	print_color_string(PRINT_ANY, COLOR_NONE, "netdev", "netdev %s ",
			   netdev_name);
	print_color_uint(PRINT_ANY, COLOR_NONE, "netdev_index",
			 rd->show_details ? "netdev_index %u " : "", idx);
}

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

	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;

	if (!tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
		pr_err("This tool doesn't support switches yet\n");
		return MNL_CB_ERROR;
	}

	idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
	port = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
	name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);

	open_json_object(NULL);
	print_color_uint(PRINT_JSON, COLOR_NONE, "ifindex", NULL, idx);
	print_color_string(PRINT_ANY, COLOR_NONE, "ifname", "link %s/", name);
	print_color_uint(PRINT_ANY, COLOR_NONE, "port", "%u ", port);
	link_print_subnet_prefix(rd, tb);
	link_print_lid(rd, tb);
	link_print_sm_lid(rd, tb);
	link_print_lmc(rd, tb);
	link_print_state(rd, tb);
	link_print_phys_state(rd, tb);
	link_print_netdev(rd, tb);
	if (rd->show_details)
		link_print_caps(rd, tb);

	newline(rd);
	return MNL_CB_OK;
}

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

	rd_prepare_msg(rd, RDMA_NLDEV_CMD_PORT_GET, &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_ATTR_PORT_INDEX, rd->port_idx);
	ret = rd_send_msg(rd);
	if (ret)
		return ret;

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

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

	if (!rd->port_idx)
		return 0;

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

static int link_show(struct rd *rd)
{
	return rd_exec_link(rd, link_one_show, true);
}

static int link_add_netdev(struct rd *rd)
{
	char *link_netdev;
	uint32_t seq;

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

	link_netdev = rd_argv(rd);
	rd_prepare_msg(rd, RDMA_NLDEV_CMD_NEWLINK, &seq,
		       (NLM_F_REQUEST | NLM_F_ACK));
	mnl_attr_put_strz(rd->nlh, RDMA_NLDEV_ATTR_DEV_NAME, rd->link_name);
	mnl_attr_put_strz(rd->nlh, RDMA_NLDEV_ATTR_LINK_TYPE, rd->link_type);
	mnl_attr_put_strz(rd->nlh, RDMA_NLDEV_ATTR_NDEV_NAME, link_netdev);
	return rd_sendrecv_msg(rd, seq);
}

static int link_add_type(struct rd *rd)
{
	const struct rd_cmd cmds[] = {
		{ NULL,		link_help},
		{ "netdev",	link_add_netdev},
		{ 0 }
	};

	if (rd_no_arg(rd)) {
		pr_err("Please provide a link type name.\n");
		return -EINVAL;
	}
	rd->link_type = rd_argv(rd);
	rd_arg_inc(rd);
	return rd_exec_cmd(rd, cmds, "parameter");
}

static int link_add(struct rd *rd)
{
	const struct rd_cmd cmds[] = {
		{ NULL,		link_help},
		{ "type",	link_add_type},
		{ 0 }
	};

	if (rd_no_arg(rd)) {
		pr_err("Please provide a link name to add.\n");
		return -EINVAL;
	}
	rd->link_name = rd_argv(rd);
	rd_arg_inc(rd);

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

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

	if (!rd_no_arg(rd)) {
		pr_err("Unknown parameter %s\n", rd_argv(rd));
		return -EINVAL;
	}
	rd_prepare_msg(rd, RDMA_NLDEV_CMD_DELLINK, &seq,
		       (NLM_F_REQUEST | NLM_F_ACK));
	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
	return rd_sendrecv_msg(rd, seq);
}

static int link_del(struct rd *rd)
{
	return rd_exec_require_dev(rd, _link_del);
}

int cmd_link(struct rd *rd)
{
	const struct rd_cmd cmds[] = {
		{ NULL,		link_show },
		{ "add",	link_add },
		{ "delete",	link_del },
		{ "show",	link_show },
		{ "list",	link_show },
		{ "help",	link_help },
		{ 0 }
	};

	return rd_exec_cmd(rd, cmds, "link command");
}
Commit	Line	Data
835d8321	1	// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
da990ab4 LR	2	/*
da990ab4 LR	3	* link.c RDMA tool
da990ab4 LR	4	* Authors: Leon Romanovsky <leonro@mellanox.com>
	5	*/
	6
	7	#include "rdma.h"
	8
	9	static int link_help(struct rd *rd)
	10	{
	11	pr_out("Usage: %s link show [DEV/PORT_INDEX]\n", rd->filename);
4336c582 SW	12	pr_out("Usage: %s link add NAME type TYPE netdev NETDEV\n",
	13	rd->filename);
	14	pr_out("Usage: %s link delete NAME\n", rd->filename);
da990ab4 LR	15	return 0;
	16	}
	17
	18	static const char *caps_to_str(uint32_t idx)
	19	{
40fc8c2c	20	#define RDMA_PORT_FLAGS_LOW(x) \
d090fbf3	21	x(RESERVED, 0) \
da990ab4 LR	22	x(SM, 1) \
	23	x(NOTICE, 2) \
	24	x(TRAP, 3) \
	25	x(OPT_IPD, 4) \
	26	x(AUTO_MIGR, 5) \
	27	x(SL_MAP, 6) \
	28	x(MKEY_NVRAM, 7) \
	29	x(PKEY_NVRAM, 8) \
	30	x(LED_INFO, 9) \
	31	x(SM_DISABLED, 10) \
4e2eb9fd	32	x(SYS_IMAGE_GUID, 11) \
da990ab4	33	x(PKEY_SW_EXT_PORT_TRAP, 12) \
d090fbf3	34	x(CABLE_INFO, 13) \
da990ab4	35	x(EXTENDED_SPEEDS, 14) \
d090fbf3	36	x(CAP_MASK2, 15) \
da990ab4 LR	37	x(CM, 16) \
	38	x(SNMP_TUNNEL, 17) \
	39	x(REINIT, 18) \
	40	x(DEVICE_MGMT, 19) \
	41	x(VENDOR_CLASS, 20) \
	42	x(DR_NOTICE, 21) \
	43	x(CAP_MASK_NOTICE, 22) \
	44	x(BOOT_MGMT, 23) \
	45	x(LINK_LATENCY, 24) \
8f478ec2	46	x(CLIENT_REG, 25) \
d090fbf3 LR	47	x(OTHER_LOCAL_CHANGES, 26) \
	48	x(LINK_SPPED_WIDTH, 27) \
	49	x(VENDOR_SPECIFIC_MADS, 28) \
	50	x(MULT_PKER_TRAP, 29) \
	51	x(MULT_FDB, 30) \
	52	x(HIERARCHY_INFO, 31)
da990ab4	53
40fc8c2c MG	54	#define RDMA_PORT_FLAGS_HIGH(x) \
	55	x(SET_NODE_DESC, 0) \
	56	x(EXT_INFO, 1) \
	57	x(VIRT, 2) \
	58	x(SWITCH_POR_STATE_TABLE, 3) \
	59	x(LINK_WIDTH_2X, 4) \
	60	x(LINK_SPEED_HDR, 5)
da990ab4	61
40fc8c2c MG	62	/*
	63	* Separation below is needed to allow compilation of rdmatool
	64	* on 32bits systems. On such systems, C-enum is limited to be
	65	* int and can't hold more than 32 bits.
	66	*/
	67	enum { RDMA_PORT_FLAGS_LOW(RDMA_BITMAP_ENUM) };
	68	enum { RDMA_PORT_FLAGS_HIGH(RDMA_BITMAP_ENUM) };
	69
	70	static const char * const
	71	rdma_port_names_low[] = { RDMA_PORT_FLAGS_LOW(RDMA_BITMAP_NAMES) };
da990ab4	72	static const char * const
40fc8c2c MG	73	rdma_port_names_high[] = { RDMA_PORT_FLAGS_HIGH(RDMA_BITMAP_NAMES) };
	74	uint32_t high_idx;
	75	#undef RDMA_PORT_FLAGS_LOW
	76	#undef RDMA_PORT_FLAGS_HIGH
	77
	78	if (idx < ARRAY_SIZE(rdma_port_names_low) && rdma_port_names_low[idx])
	79	return rdma_port_names_low[idx];
	80
	81	high_idx = idx - ARRAY_SIZE(rdma_port_names_low);
	82	if (high_idx < ARRAY_SIZE(rdma_port_names_high) &&
	83	rdma_port_names_high[high_idx])
	84	return rdma_port_names_high[high_idx];
da990ab4	85
40fc8c2c	86	return "UNKNOWN";
da990ab4 LR	87	}
da990ab4 LR	88
7fc75744	89	static void link_print_caps(struct rd rd, struct nlattr *tb)
da990ab4 LR	90	{
	91	uint64_t caps;
	92	uint32_t idx;
	93
	94	if (!tb[RDMA_NLDEV_ATTR_CAP_FLAGS])
	95	return;
	96
	97	caps = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_CAP_FLAGS]);
	98
b0a688a5 IK	99	print_color_string(PRINT_FP, COLOR_NONE, NULL, "\n caps: <", NULL);
b0a688a5 IK	100	open_json_array(PRINT_JSON, "caps");
da990ab4	101	for (idx = 0; caps; idx++) {
b0a688a5 IK	102	if (caps & 0x1)
	103	print_color_string(PRINT_ANY, COLOR_NONE, NULL,
	104	caps >> 0x1 ? "%s, " : "%s",
	105	caps_to_str(idx));
da990ab4 LR	106	caps >>= 0x1;
da990ab4 LR	107	}
b0a688a5	108	close_json_array(PRINT_ANY, ">");
da990ab4 LR	109	}
da990ab4 LR	110
7fc75744	111	static void link_print_subnet_prefix(struct rd rd, struct nlattr *tb)
da990ab4 LR	112	{
da990ab4 LR	113	uint64_t subnet_prefix;
7fc75744 LR	114	uint16_t vp[4];
7fc75744 LR	115	char str[32];
da990ab4 LR	116
	117	if (!tb[RDMA_NLDEV_ATTR_SUBNET_PREFIX])
	118	return;
	119
	120	subnet_prefix = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_SUBNET_PREFIX]);
7fc75744 LR	121	memcpy(vp, &subnet_prefix, sizeof(uint64_t));
7fc75744 LR	122	snprintf(str, 32, "%04x:%04x:%04x:%04x", vp[3], vp[2], vp[1], vp[0]);
b0a688a5 IK	123	print_color_string(PRINT_ANY, COLOR_NONE, "subnet_prefix",
b0a688a5 IK	124	"subnet_prefix %s ", str);
da990ab4 LR	125	}
da990ab4 LR	126
7fc75744	127	static void link_print_lid(struct rd rd, struct nlattr *tb)
da990ab4	128	{
7fc75744 LR	129	uint32_t lid;
7fc75744 LR	130
da990ab4 LR	131	if (!tb[RDMA_NLDEV_ATTR_LID])
	132	return;
	133
7fc75744	134	lid = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_LID]);
b0a688a5	135	print_color_uint(PRINT_ANY, COLOR_NONE, "lid", "lid %u ", lid);
da990ab4 LR	136	}
da990ab4 LR	137
7fc75744	138	static void link_print_sm_lid(struct rd rd, struct nlattr *tb)
da990ab4	139	{
7fc75744 LR	140	uint32_t sm_lid;
7fc75744 LR	141
da990ab4 LR	142	if (!tb[RDMA_NLDEV_ATTR_SM_LID])
	143	return;
	144
7fc75744	145	sm_lid = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_SM_LID]);
b0a688a5	146	print_color_uint(PRINT_ANY, COLOR_NONE, "sm_lid", "sm_lid %u ", sm_lid);
da990ab4 LR	147	}
da990ab4 LR	148
7fc75744	149	static void link_print_lmc(struct rd rd, struct nlattr *tb)
da990ab4	150	{
7fc75744 LR	151	uint8_t lmc;
7fc75744 LR	152
da990ab4 LR	153	if (!tb[RDMA_NLDEV_ATTR_LMC])
	154	return;
	155
7fc75744	156	lmc = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_LMC]);
b0a688a5	157	print_color_uint(PRINT_ANY, COLOR_NONE, "lmc", "lmc %u ", lmc);
da990ab4 LR	158	}
	159
	160	static const char *link_state_to_str(uint8_t link_state)
	161	{
	162	static const char * const link_state_str[] = { "NOP", "DOWN",
	163	"INIT", "ARMED",
	164	"ACTIVE",
	165	"ACTIVE_DEFER" };
	166	if (link_state < ARRAY_SIZE(link_state_str))
	167	return link_state_str[link_state];
	168	return "UNKNOWN";
	169	}
	170
7fc75744	171	static void link_print_state(struct rd rd, struct nlattr *tb)
da990ab4 LR	172	{
	173	uint8_t state;
	174
	175	if (!tb[RDMA_NLDEV_ATTR_PORT_STATE])
	176	return;
	177
	178	state = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_PORT_STATE]);
b0a688a5 IK	179	print_color_string(PRINT_ANY, COLOR_NONE, "state", "state %s ",
b0a688a5 IK	180	link_state_to_str(state));
da990ab4 LR	181	}
	182
	183	static const char *phys_state_to_str(uint8_t phys_state)
	184	{
	185	static const char * const phys_state_str[] = { "NOP", "SLEEP",
	186	"POLLING", "DISABLED",
	187	"ARMED", "LINK_UP",
	188	"LINK_ERROR_RECOVER",
	189	"PHY_TEST", "UNKNOWN",
	190	"OPA_OFFLINE",
	191	"UNKNOWN", "OPA_TEST" };
	192	if (phys_state < ARRAY_SIZE(phys_state_str))
	193	return phys_state_str[phys_state];
	194	return "UNKNOWN";
	195	};
	196
7fc75744	197	static void link_print_phys_state(struct rd rd, struct nlattr *tb)
da990ab4 LR	198	{
	199	uint8_t phys_state;
	200
	201	if (!tb[RDMA_NLDEV_ATTR_PORT_PHYS_STATE])
	202	return;
	203
	204	phys_state = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_PORT_PHYS_STATE]);
b0a688a5 IK	205	print_color_string(PRINT_ANY, COLOR_NONE, "physical_state",
b0a688a5 IK	206	"physical_state %s ", phys_state_to_str(phys_state));
da990ab4 LR	207	}
da990ab4 LR	208
15259427 LR	209	static void link_print_netdev(struct rd rd, struct nlattr *tb)
	210	{
	211	const char *netdev_name;
	212	uint32_t idx;
	213
	214	if (!tb[RDMA_NLDEV_ATTR_NDEV_NAME] \|\| !tb[RDMA_NLDEV_ATTR_NDEV_INDEX])
	215	return;
	216
	217	netdev_name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_NDEV_NAME]);
	218	idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_NDEV_INDEX]);
b0a688a5 IK	219	print_color_string(PRINT_ANY, COLOR_NONE, "netdev", "netdev %s ",
	220	netdev_name);
	221	print_color_uint(PRINT_ANY, COLOR_NONE, "netdev_index",
	222	rd->show_details ? "netdev_index %u " : "", idx);
15259427 LR	223	}
15259427 LR	224
da990ab4 LR	225	static int link_parse_cb(const struct nlmsghdr nlh, void data)
	226	{
	227	struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
	228	struct rd *rd = data;
7fc75744	229	uint32_t port, idx;
b0a688a5	230	const char *name;
da990ab4 LR	231
	232	mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
	233	if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] \|\| !tb[RDMA_NLDEV_ATTR_DEV_NAME])
	234	return MNL_CB_ERROR;
	235
	236	if (!tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
	237	pr_err("This tool doesn't support switches yet\n");
	238	return MNL_CB_ERROR;
	239	}
	240
7fc75744 LR	241	idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
7fc75744 LR	242	port = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
b0a688a5	243	name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
7fc75744	244
b0a688a5 IK	245	open_json_object(NULL);
	246	print_color_uint(PRINT_JSON, COLOR_NONE, "ifindex", NULL, idx);
	247	print_color_string(PRINT_ANY, COLOR_NONE, "ifname", "link %s/", name);
	248	print_color_uint(PRINT_ANY, COLOR_NONE, "port", "%u ", port);
7fc75744 LR	249	link_print_subnet_prefix(rd, tb);
	250	link_print_lid(rd, tb);
	251	link_print_sm_lid(rd, tb);
	252	link_print_lmc(rd, tb);
	253	link_print_state(rd, tb);
	254	link_print_phys_state(rd, tb);
15259427	255	link_print_netdev(rd, tb);
da990ab4	256	if (rd->show_details)
7fc75744	257	link_print_caps(rd, tb);
da990ab4	258
b0a688a5	259	newline(rd);
da990ab4 LR	260	return MNL_CB_OK;
	261	}
	262
	263	static int link_no_args(struct rd *rd)
	264	{
	265	uint32_t seq;
	266	int ret;
	267
	268	rd_prepare_msg(rd, RDMA_NLDEV_CMD_PORT_GET, &seq,
	269	(NLM_F_REQUEST \| NLM_F_ACK));
	270	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
	271	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_PORT_INDEX, rd->port_idx);
	272	ret = rd_send_msg(rd);
	273	if (ret)
	274	return ret;
	275
7fc75744	276	ret = rd_recv_msg(rd, link_parse_cb, rd, seq);
7fc75744	277	return ret;
da990ab4 LR	278	}
	279
	280	static int link_one_show(struct rd *rd)
	281	{
	282	const struct rd_cmd cmds[] = {
	283	{ NULL, link_no_args},
	284	{ 0 }
	285	};
	286
e3dee3c8 LR	287	if (!rd->port_idx)
	288	return 0;
	289
da990ab4 LR	290	return rd_exec_cmd(rd, cmds, "parameter");
	291	}
	292
	293	static int link_show(struct rd *rd)
	294	{
6416d1a0	295	return rd_exec_link(rd, link_one_show, true);
da990ab4 LR	296	}
da990ab4 LR	297
4336c582 SW	298	static int link_add_netdev(struct rd *rd)
	299	{
	300	char *link_netdev;
	301	uint32_t seq;
	302
	303	if (rd_no_arg(rd)) {
	304	pr_err("Please provide a net device name.\n");
	305	return -EINVAL;
	306	}
	307
	308	link_netdev = rd_argv(rd);
	309	rd_prepare_msg(rd, RDMA_NLDEV_CMD_NEWLINK, &seq,
	310	(NLM_F_REQUEST \| NLM_F_ACK));
	311	mnl_attr_put_strz(rd->nlh, RDMA_NLDEV_ATTR_DEV_NAME, rd->link_name);
	312	mnl_attr_put_strz(rd->nlh, RDMA_NLDEV_ATTR_LINK_TYPE, rd->link_type);
	313	mnl_attr_put_strz(rd->nlh, RDMA_NLDEV_ATTR_NDEV_NAME, link_netdev);
	314	return rd_sendrecv_msg(rd, seq);
	315	}
	316
	317	static int link_add_type(struct rd *rd)
	318	{
	319	const struct rd_cmd cmds[] = {
	320	{ NULL, link_help},
	321	{ "netdev", link_add_netdev},
	322	{ 0 }
	323	};
	324
	325	if (rd_no_arg(rd)) {
	326	pr_err("Please provide a link type name.\n");
	327	return -EINVAL;
	328	}
	329	rd->link_type = rd_argv(rd);
	330	rd_arg_inc(rd);
	331	return rd_exec_cmd(rd, cmds, "parameter");
	332	}
	333
	334	static int link_add(struct rd *rd)
	335	{
	336	const struct rd_cmd cmds[] = {
	337	{ NULL, link_help},
	338	{ "type", link_add_type},
	339	{ 0 }
	340	};
	341
	342	if (rd_no_arg(rd)) {
	343	pr_err("Please provide a link name to add.\n");
	344	return -EINVAL;
	345	}
	346	rd->link_name = rd_argv(rd);
	347	rd_arg_inc(rd);
	348
	349	return rd_exec_cmd(rd, cmds, "parameter");
	350	}
	351
	352	static int _link_del(struct rd *rd)
	353	{
	354	uint32_t seq;
	355
	356	if (!rd_no_arg(rd)) {
	357	pr_err("Unknown parameter %s\n", rd_argv(rd));
	358	return -EINVAL;
	359	}
	360	rd_prepare_msg(rd, RDMA_NLDEV_CMD_DELLINK, &seq,
	361	(NLM_F_REQUEST \| NLM_F_ACK));
362	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
363	return rd_sendrecv_msg(rd, seq);
364	}
365
366	static int link_del(struct rd *rd)
367	{
368	return rd_exec_require_dev(rd, _link_del);
369	}
370
da990ab4 LR	371	int cmd_link(struct rd *rd)
	372	{
	373	const struct rd_cmd cmds[] = {
	374	{ NULL, link_show },
4336c582 SW	375	{ "add", link_add },
4336c582 SW	376	{ "delete", link_del },
da990ab4 LR	377	{ "show", link_show },
	378	{ "list", link_show },
	379	{ "help", link_help },
	380	{ 0 }
	381	};
	382
	383	return rd_exec_cmd(rd, cmds, "link command");
	384	}