[mirror_iproute2.git] / rdma / sys.c

// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
/*
 * sys.c	RDMA tool
 */

#include "rdma.h"

static int sys_help(struct rd *rd)
{
	pr_out("Usage: %s system show [ netns ]\n", rd->filename);
	pr_out("       %s system set netns { shared | exclusive }\n", rd->filename);
	return 0;
}

static const char *netns_modes_str[] = {
	"exclusive",
	"shared",
};

static int sys_show_parse_cb(const struct nlmsghdr *nlh, void *data)
{
	struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};

	mnl_attr_parse(nlh, 0, rd_attr_cb, tb);

	if (tb[RDMA_NLDEV_SYS_ATTR_NETNS_MODE]) {
		const char *mode_str;
		uint8_t netns_mode;

		netns_mode =
			mnl_attr_get_u8(tb[RDMA_NLDEV_SYS_ATTR_NETNS_MODE]);

		if (netns_mode < ARRAY_SIZE(netns_modes_str))
			mode_str = netns_modes_str[netns_mode];
		else
			mode_str = "unknown";

		print_color_string(PRINT_ANY, COLOR_NONE, "netns", "netns %s\n",
				   mode_str);
	}
	return MNL_CB_OK;
}

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

	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SYS_GET,
		       &seq, (NLM_F_REQUEST | NLM_F_ACK));
	ret = rd_send_msg(rd);
	if (ret)
		return ret;

	return rd_recv_msg(rd, sys_show_parse_cb, rd, seq);
}

static int sys_show(struct rd *rd)
{
	const struct rd_cmd cmds[] = {
		{ NULL,		sys_show_no_args},
		{ "netns",	sys_show_no_args},
		{ 0 }
	};

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

static int sys_set_netns_cmd(struct rd *rd, bool enable)
{
	uint32_t seq;

	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SYS_SET,
		       &seq, (NLM_F_REQUEST | NLM_F_ACK));
	mnl_attr_put_u8(rd->nlh, RDMA_NLDEV_SYS_ATTR_NETNS_MODE, enable);

	return rd_sendrecv_msg(rd, seq);
}

static bool sys_valid_netns_cmd(const char *cmd)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(netns_modes_str); i++) {
		if (!strcmp(cmd, netns_modes_str[i]))
			return true;
	}
	return false;
}

static int sys_set_netns_args(struct rd *rd)
{
	bool cmd;

	if (rd_no_arg(rd) || !sys_valid_netns_cmd(rd_argv(rd))) {
		pr_err("valid options are: { shared | exclusive }\n");
		return -EINVAL;
	}

	cmd = (strcmp(rd_argv(rd), "shared") == 0) ? true : false;

	return sys_set_netns_cmd(rd, cmd);
}

static int sys_set_help(struct rd *rd)
{
	pr_out("Usage: %s system set [PARAM] value\n", rd->filename);
	pr_out("            system set netns { shared | exclusive }\n");
	return 0;
}

static int sys_set(struct rd *rd)
{
	const struct rd_cmd cmds[] = {
		{ NULL,			sys_set_help },
		{ "help",		sys_set_help },
		{ "netns",		sys_set_netns_args},
		{ 0 }
	};

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

int cmd_sys(struct rd *rd)
{
	const struct rd_cmd cmds[] = {
		{ NULL,		sys_show },
		{ "show",	sys_show },
		{ "set",	sys_set },
		{ "help",	sys_help },
		{ 0 }
	};

	return rd_exec_cmd(rd, cmds, "system command");
}
Commit	Line	Data
c4572a46 PP	1	// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
	2	/*
	3	* sys.c RDMA tool
	4	*/
	5
	6	#include "rdma.h"
	7
	8	static int sys_help(struct rd *rd)
	9	{
	10	pr_out("Usage: %s system show [ netns ]\n", rd->filename);
	11	pr_out(" %s system set netns { shared \| exclusive }\n", rd->filename);
	12	return 0;
	13	}
	14
	15	static const char *netns_modes_str[] = {
	16	"exclusive",
	17	"shared",
	18	};
	19
	20	static int sys_show_parse_cb(const struct nlmsghdr nlh, void data)
	21	{
	22	struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
c4572a46 PP	23
	24	mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
	25
	26	if (tb[RDMA_NLDEV_SYS_ATTR_NETNS_MODE]) {
	27	const char *mode_str;
	28	uint8_t netns_mode;
	29
	30	netns_mode =
	31	mnl_attr_get_u8(tb[RDMA_NLDEV_SYS_ATTR_NETNS_MODE]);
	32
6749801b	33	if (netns_mode < ARRAY_SIZE(netns_modes_str))
c4572a46 PP	34	mode_str = netns_modes_str[netns_mode];
	35	else
	36	mode_str = "unknown";
	37
b0a688a5 IK	38	print_color_string(PRINT_ANY, COLOR_NONE, "netns", "netns %s\n",
b0a688a5 IK	39	mode_str);
c4572a46 PP	40	}
	41	return MNL_CB_OK;
	42	}
	43
	44	static int sys_show_no_args(struct rd *rd)
	45	{
	46	uint32_t seq;
	47	int ret;
	48
	49	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SYS_GET,
	50	&seq, (NLM_F_REQUEST \| NLM_F_ACK));
	51	ret = rd_send_msg(rd);
	52	if (ret)
	53	return ret;
	54
	55	return rd_recv_msg(rd, sys_show_parse_cb, rd, seq);
	56	}
	57
	58	static int sys_show(struct rd *rd)
	59	{
	60	const struct rd_cmd cmds[] = {
	61	{ NULL, sys_show_no_args},
	62	{ "netns", sys_show_no_args},
	63	{ 0 }
	64	};
	65
	66	return rd_exec_cmd(rd, cmds, "parameter");
	67	}
	68
	69	static int sys_set_netns_cmd(struct rd *rd, bool enable)
	70	{
	71	uint32_t seq;
	72
	73	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SYS_SET,
	74	&seq, (NLM_F_REQUEST \| NLM_F_ACK));
	75	mnl_attr_put_u8(rd->nlh, RDMA_NLDEV_SYS_ATTR_NETNS_MODE, enable);
	76
	77	return rd_sendrecv_msg(rd, seq);
	78	}
	79
	80	static bool sys_valid_netns_cmd(const char *cmd)
	81	{
	82	int i;
	83
	84	for (i = 0; i < ARRAY_SIZE(netns_modes_str); i++) {
	85	if (!strcmp(cmd, netns_modes_str[i]))
	86	return true;
	87	}
	88	return false;
	89	}
	90
	91	static int sys_set_netns_args(struct rd *rd)
	92	{
	93	bool cmd;
	94
	95	if (rd_no_arg(rd) \|\| !sys_valid_netns_cmd(rd_argv(rd))) {
	96	pr_err("valid options are: { shared \| exclusive }\n");
	97	return -EINVAL;
	98	}
	99
	100	cmd = (strcmp(rd_argv(rd), "shared") == 0) ? true : false;
	101
	102	return sys_set_netns_cmd(rd, cmd);
	103	}
104
105	static int sys_set_help(struct rd *rd)
106	{
107	pr_out("Usage: %s system set [PARAM] value\n", rd->filename);
108	pr_out(" system set netns { shared \| exclusive }\n");
109	return 0;
110	}
111
112	static int sys_set(struct rd *rd)
113	{
114	const struct rd_cmd cmds[] = {
115	{ NULL, sys_set_help },
116	{ "help", sys_set_help },
117	{ "netns", sys_set_netns_args},
118	{ 0 }
119	};
120
121	return rd_exec_cmd(rd, cmds, "parameter");
122	}
123
124	int cmd_sys(struct rd *rd)
125	{
126	const struct rd_cmd cmds[] = {
127	{ NULL, sys_show },
128	{ "show", sys_show },
129	{ "set", sys_set },
130	{ "help", sys_help },
131	{ 0 }
132	};
133
134	return rd_exec_cmd(rd, cmds, "system command");
135	}