[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 "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);
	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]);

	if (rd->json_output) {
		jsonw_name(rd->jw, "caps");
		jsonw_start_array(rd->jw);
	} else {
		pr_out("\n    caps: <");
	}
	for (idx = 0; caps; idx++) {
		if (caps & 0x1) {
			if (rd->json_output) {
				jsonw_string(rd->jw, dev_caps_to_str(idx));
			} else {
				pr_out("%s", dev_caps_to_str(idx));
				if (caps >> 0x1)
					pr_out(", ");
			}
		}
		caps >>= 0x1;
	}

	if (rd->json_output)
		jsonw_end_array(rd->jw);
	else
		pr_out(">");
}

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]);
	if (rd->json_output)
		jsonw_string_field(rd->jw, "fw", str);
	else
		pr_out("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]);
	if (rd->json_output)
		jsonw_string_field(rd->jw, "node_guid", str);
	else
		pr_out("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]);
	if (rd->json_output)
		jsonw_string_field(rd->jw, "sys_image_guid", str);
	else
		pr_out("sys_image_guid %s ", str);
}

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_dp" };
	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);
	if (rd->json_output)
		jsonw_string_field(rd->jw, "node_type", node_str);
	else
		pr_out("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;

	idx =  mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
	name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
	if (rd->json_output) {
		jsonw_uint_field(rd->jw, "ifindex", idx);
		jsonw_string_field(rd->jw, "ifname", name);
	} else {
		pr_out("%u: %s: ", idx, 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_caps(rd, tb);

	if (!rd->json_output)
		pr_out("\n");
	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;

	if (rd->json_output)
		jsonw_start_object(rd->jw);
	ret = rd_recv_msg(rd, dev_parse_cb, rd, seq);
	if (rd->json_output)
		jsonw_end_object(rd->jw);
	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_send_msg(rd);
}

static int dev_one_set(struct rd *rd)
{
	const struct rd_cmd cmds[] = {
		{ NULL,		dev_help},
		{ "name",	dev_set_name},
		{ 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
	7	#include "rdma.h"
	8
	9	static int dev_help(struct rd *rd)
	10	{
	11	pr_out("Usage: %s dev show [DEV]\n", rd->filename);
4443c9c6	12	pr_out(" %s dev set [DEV] name DEVNAME\n", rd->filename);
40df8263 LR	13	return 0;
	14	}
	15
	16	static const char *dev_caps_to_str(uint32_t idx)
	17	{
378dd31b	18	#define RDMA_DEV_FLAGS_LOW(x) \
40df8263 LR	19	x(RESIZE_MAX_WR, 0) \
	20	x(BAD_PKEY_CNTR, 1) \
	21	x(BAD_QKEY_CNTR, 2) \
	22	x(RAW_MULTI, 3) \
	23	x(AUTO_PATH_MIG, 4) \
	24	x(CHANGE_PHY_PORT, 5) \
	25	x(UD_AV_PORT_ENFORCE_PORT_ENFORCE, 6) \
	26	x(CURR_QP_STATE_MOD, 7) \
	27	x(SHUTDOWN_PORT, 8) \
	28	x(INIT_TYPE, 9) \
	29	x(PORT_ACTIVE_EVENT, 10) \
	30	x(SYS_IMAGE_GUID, 11) \
	31	x(RC_RNR_NAK_GEN, 12) \
	32	x(SRQ_RESIZE, 13) \
	33	x(N_NOTIFY_CQ, 14) \
	34	x(LOCAL_DMA_LKEY, 15) \
	35	x(MEM_WINDOW, 17) \
	36	x(UD_IP_CSUM, 18) \
	37	x(UD_TSO, 19) \
	38	x(XRC, 20) \
	39	x(MEM_MGT_EXTENSIONS, 21) \
	40	x(BLOCK_MULTICAST_LOOPBACK, 22) \
	41	x(MEM_WINDOW_TYPE_2A, 23) \
	42	x(MEM_WINDOW_TYPE_2B, 24) \
	43	x(RC_IP_CSUM, 25) \
	44	x(RAW_IP_CSUM, 26) \
	45	x(CROSS_CHANNEL, 27) \
	46	x(MANAGED_FLOW_STEERING, 29) \
	47	x(SIGNATURE_HANDOVER, 30) \
378dd31b	48	x(ON_DEMAND_PAGING, 31)
40df8263	49
378dd31b LR	50	#define RDMA_DEV_FLAGS_HIGH(x) \
	51	x(SG_GAPS_REG, 0) \
	52	x(VIRTUAL_FUNCTION, 1) \
	53	x(RAW_SCATTER_FCS, 2) \
	54	x(RDMA_NETDEV_OPA_VNIC, 3) \
	55	x(PCI_WRITE_END_PADDING, 4)
40df8263	56
378dd31b LR	57	/*
	58	* Separation below is needed to allow compilation of rdmatool
	59	* on 32bits systems. On such systems, C-enum is limited to be
	60	* int and can't hold more than 32 bits.
	61	*/
	62	enum { RDMA_DEV_FLAGS_LOW(RDMA_BITMAP_ENUM) };
	63	enum { RDMA_DEV_FLAGS_HIGH(RDMA_BITMAP_ENUM) };
	64
	65	static const char * const
	66	rdma_dev_names_low[] = { RDMA_DEV_FLAGS_LOW(RDMA_BITMAP_NAMES) };
40df8263	67	static const char * const
378dd31b LR	68	rdma_dev_names_high[] = { RDMA_DEV_FLAGS_HIGH(RDMA_BITMAP_NAMES) };
	69	uint32_t high_idx;
	70	#undef RDMA_DEV_FLAGS_LOW
	71	#undef RDMA_DEV_FLAGS_HIGH
	72
	73	if (idx < ARRAY_SIZE(rdma_dev_names_low) && rdma_dev_names_low[idx])
	74	return rdma_dev_names_low[idx];
	75
	76	high_idx = idx - ARRAY_SIZE(rdma_dev_names_low);
	77	if (high_idx < ARRAY_SIZE(rdma_dev_names_high) &&
	78	rdma_dev_names_high[high_idx])
	79	return rdma_dev_names_high[high_idx];
40df8263	80
40df8263 LR	81	return "UNKNOWN";
	82	}
	83
ef353e2e	84	static void dev_print_caps(struct rd rd, struct nlattr *tb)
40df8263 LR	85	{
	86	uint64_t caps;
	87	uint32_t idx;
	88
	89	if (!tb[RDMA_NLDEV_ATTR_CAP_FLAGS])
	90	return;
	91
	92	caps = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_CAP_FLAGS]);
	93
ef353e2e LR	94	if (rd->json_output) {
	95	jsonw_name(rd->jw, "caps");
	96	jsonw_start_array(rd->jw);
	97	} else {
	98	pr_out("\n caps: <");
	99	}
40df8263 LR	100	for (idx = 0; caps; idx++) {
40df8263 LR	101	if (caps & 0x1) {
ef353e2e LR	102	if (rd->json_output) {
	103	jsonw_string(rd->jw, dev_caps_to_str(idx));
	104	} else {
	105	pr_out("%s", dev_caps_to_str(idx));
	106	if (caps >> 0x1)
	107	pr_out(", ");
	108	}
40df8263 LR	109	}
	110	caps >>= 0x1;
	111	}
	112
ef353e2e LR	113	if (rd->json_output)
	114	jsonw_end_array(rd->jw);
	115	else
	116	pr_out(">");
40df8263 LR	117	}
40df8263 LR	118
ef353e2e	119	static void dev_print_fw(struct rd rd, struct nlattr *tb)
40df8263	120	{
ef353e2e	121	const char *str;
40df8263 LR	122	if (!tb[RDMA_NLDEV_ATTR_FW_VERSION])
	123	return;
	124
ef353e2e LR	125	str = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_FW_VERSION]);
	126	if (rd->json_output)
	127	jsonw_string_field(rd->jw, "fw", str);
	128	else
	129	pr_out("fw %s ", str);
40df8263 LR	130	}
40df8263 LR	131
ef353e2e	132	static void dev_print_node_guid(struct rd rd, struct nlattr *tb)
40df8263 LR	133	{
40df8263 LR	134	uint64_t node_guid;
ef353e2e LR	135	uint16_t vp[4];
ef353e2e LR	136	char str[32];
40df8263 LR	137
	138	if (!tb[RDMA_NLDEV_ATTR_NODE_GUID])
	139	return;
	140
	141	node_guid = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_NODE_GUID]);
ef353e2e LR	142	memcpy(vp, &node_guid, sizeof(uint64_t));
	143	snprintf(str, 32, "%04x:%04x:%04x:%04x", vp[3], vp[2], vp[1], vp[0]);
	144	if (rd->json_output)
	145	jsonw_string_field(rd->jw, "node_guid", str);
	146	else
	147	pr_out("node_guid %s ", str);
40df8263 LR	148	}
40df8263 LR	149
ef353e2e	150	static void dev_print_sys_image_guid(struct rd rd, struct nlattr *tb)
40df8263 LR	151	{
40df8263 LR	152	uint64_t sys_image_guid;
ef353e2e LR	153	uint16_t vp[4];
ef353e2e LR	154	char str[32];
40df8263 LR	155
	156	if (!tb[RDMA_NLDEV_ATTR_SYS_IMAGE_GUID])
	157	return;
	158
	159	sys_image_guid = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_SYS_IMAGE_GUID]);
ef353e2e LR	160	memcpy(vp, &sys_image_guid, sizeof(uint64_t));
	161	snprintf(str, 32, "%04x:%04x:%04x:%04x", vp[3], vp[2], vp[1], vp[0]);
	162	if (rd->json_output)
	163	jsonw_string_field(rd->jw, "sys_image_guid", str);
	164	else
	165	pr_out("sys_image_guid %s ", str);
40df8263 LR	166	}
	167
	168	static const char *node_type_to_str(uint8_t node_type)
	169	{
	170	static const char * const node_type_str[] = { "unknown", "ca",
	171	"switch", "router",
	172	"rnic", "usnic",
	173	"usnic_dp" };
	174	if (node_type < ARRAY_SIZE(node_type_str))
	175	return node_type_str[node_type];
	176	return "unknown";
	177	}
	178
ef353e2e	179	static void dev_print_node_type(struct rd rd, struct nlattr *tb)
40df8263	180	{
ef353e2e	181	const char *node_str;
40df8263 LR	182	uint8_t node_type;
	183
	184	if (!tb[RDMA_NLDEV_ATTR_DEV_NODE_TYPE])
	185	return;
	186
	187	node_type = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_DEV_NODE_TYPE]);
ef353e2e LR	188	node_str = node_type_to_str(node_type);
	189	if (rd->json_output)
	190	jsonw_string_field(rd->jw, "node_type", node_str);
	191	else
	192	pr_out("node_type %s ", node_str);
40df8263 LR	193	}
	194
	195	static int dev_parse_cb(const struct nlmsghdr nlh, void data)
	196	{
	197	struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
	198	struct rd *rd = data;
ef353e2e LR	199	const char *name;
ef353e2e LR	200	uint32_t idx;
40df8263 LR	201
	202	mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
	203	if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] \|\| !tb[RDMA_NLDEV_ATTR_DEV_NAME])
	204	return MNL_CB_ERROR;
	205
ef353e2e LR	206	idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
	207	name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
	208	if (rd->json_output) {
	209	jsonw_uint_field(rd->jw, "ifindex", idx);
	210	jsonw_string_field(rd->jw, "ifname", name);
	211	} else {
	212	pr_out("%u: %s: ", idx, name);
	213	}
	214
	215	dev_print_node_type(rd, tb);
	216	dev_print_fw(rd, tb);
	217	dev_print_node_guid(rd, tb);
	218	dev_print_sys_image_guid(rd, tb);
40df8263	219	if (rd->show_details)
ef353e2e	220	dev_print_caps(rd, tb);
40df8263	221
ef353e2e LR	222	if (!rd->json_output)
ef353e2e LR	223	pr_out("\n");
40df8263 LR	224	return MNL_CB_OK;
	225	}
	226
	227	static int dev_no_args(struct rd *rd)
	228	{
	229	uint32_t seq;
	230	int ret;
	231
	232	rd_prepare_msg(rd, RDMA_NLDEV_CMD_GET,
	233	&seq, (NLM_F_REQUEST \| NLM_F_ACK));
	234	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
	235	ret = rd_send_msg(rd);
	236	if (ret)
	237	return ret;
	238
ef353e2e LR	239	if (rd->json_output)
	240	jsonw_start_object(rd->jw);
	241	ret = rd_recv_msg(rd, dev_parse_cb, rd, seq);
	242	if (rd->json_output)
	243	jsonw_end_object(rd->jw);
	244	return ret;
40df8263 LR	245	}
	246
	247	static int dev_one_show(struct rd *rd)
	248	{
	249	const struct rd_cmd cmds[] = {
	250	{ NULL, dev_no_args},
	251	{ 0 }
	252	};
	253
	254	return rd_exec_cmd(rd, cmds, "parameter");
	255	}
	256
4443c9c6 LR	257	static int dev_set_name(struct rd *rd)
	258	{
	259	uint32_t seq;
	260
	261	if (rd_no_arg(rd)) {
	262	pr_err("Please provide device new name.\n");
	263	return -EINVAL;
	264	}
	265
	266	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SET,
	267	&seq, (NLM_F_REQUEST \| NLM_F_ACK));
	268	mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
	269	mnl_attr_put_strz(rd->nlh, RDMA_NLDEV_ATTR_DEV_NAME, rd_argv(rd));
	270
	271	return rd_send_msg(rd);
	272	}
	273
	274	static int dev_one_set(struct rd *rd)
	275	{
	276	const struct rd_cmd cmds[] = {
	277	{ NULL, dev_help},
	278	{ "name", dev_set_name},
	279	{ 0 }
	280	};
	281
	282	return rd_exec_cmd(rd, cmds, "parameter");
	283	}
	284
40df8263 LR	285	static int dev_show(struct rd *rd)
40df8263 LR	286	{
8b92a2c9	287	return rd_exec_dev(rd, dev_one_show);
40df8263 LR	288	}
40df8263 LR	289
4443c9c6 LR	290	static int dev_set(struct rd *rd)
	291	{
	292	return rd_exec_require_dev(rd, dev_one_set);
	293	}
	294
40df8263 LR	295	int cmd_dev(struct rd *rd)
	296	{
	297	const struct rd_cmd cmds[] = {
	298	{ NULL, dev_show },
	299	{ "show", dev_show },
	300	{ "list", dev_show },
4443c9c6	301	{ "set", dev_set },
40df8263 LR	302	{ "help", dev_help },
	303	{ 0 }
	304	};
	305
	306	return rd_exec_cmd(rd, cmds, "dev command");
	307	}