[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] = {};
	struct rd *rd = data;

	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";

		if (rd->json_output)
			jsonw_string_field(rd->jw, "netns", mode_str);
		else
			pr_out("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] = {};
	23	struct rd *rd = data;
	24
	25	mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
	26
	27	if (tb[RDMA_NLDEV_SYS_ATTR_NETNS_MODE]) {
	28	const char *mode_str;
	29	uint8_t netns_mode;
	30
	31	netns_mode =
	32	mnl_attr_get_u8(tb[RDMA_NLDEV_SYS_ATTR_NETNS_MODE]);
	33
	34	if (netns_mode <= ARRAY_SIZE(netns_modes_str))
	35	mode_str = netns_modes_str[netns_mode];
	36	else
	37	mode_str = "unknown";
	38
	39	if (rd->json_output)
	40	jsonw_string_field(rd->jw, "netns", mode_str);
	41	else
	42	pr_out("netns %s\n", mode_str);
	43	}
	44	return MNL_CB_OK;
	45	}
	46
	47	static int sys_show_no_args(struct rd *rd)
	48	{
	49	uint32_t seq;
	50	int ret;
	51
	52	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SYS_GET,
	53	&seq, (NLM_F_REQUEST \| NLM_F_ACK));
	54	ret = rd_send_msg(rd);
	55	if (ret)
	56	return ret;
	57
	58	return rd_recv_msg(rd, sys_show_parse_cb, rd, seq);
	59	}
	60
	61	static int sys_show(struct rd *rd)
	62	{
	63	const struct rd_cmd cmds[] = {
	64	{ NULL, sys_show_no_args},
65	{ "netns", sys_show_no_args},
66	{ 0 }
67	};
68
69	return rd_exec_cmd(rd, cmds, "parameter");
70	}
71
72	static int sys_set_netns_cmd(struct rd *rd, bool enable)
73	{
74	uint32_t seq;
75
76	rd_prepare_msg(rd, RDMA_NLDEV_CMD_SYS_SET,
77	&seq, (NLM_F_REQUEST \| NLM_F_ACK));
78	mnl_attr_put_u8(rd->nlh, RDMA_NLDEV_SYS_ATTR_NETNS_MODE, enable);
79
80	return rd_sendrecv_msg(rd, seq);
81	}
82
83	static bool sys_valid_netns_cmd(const char *cmd)
84	{
85	int i;
86
87	for (i = 0; i < ARRAY_SIZE(netns_modes_str); i++) {
88	if (!strcmp(cmd, netns_modes_str[i]))
89	return true;
90	}
91	return false;
92	}
93
94	static int sys_set_netns_args(struct rd *rd)
95	{
96	bool cmd;
97
98	if (rd_no_arg(rd) \|\| !sys_valid_netns_cmd(rd_argv(rd))) {
99	pr_err("valid options are: { shared \| exclusive }\n");
100	return -EINVAL;
101	}
102
103	cmd = (strcmp(rd_argv(rd), "shared") == 0) ? true : false;
104
105	return sys_set_netns_cmd(rd, cmd);
106	}
107
108	static int sys_set_help(struct rd *rd)
109	{
110	pr_out("Usage: %s system set [PARAM] value\n", rd->filename);
111	pr_out(" system set netns { shared \| exclusive }\n");
112	return 0;
113	}
114
115	static int sys_set(struct rd *rd)
116	{
117	const struct rd_cmd cmds[] = {
118	{ NULL, sys_set_help },
119	{ "help", sys_set_help },
120	{ "netns", sys_set_netns_args},
121	{ 0 }
122	};
123
124	return rd_exec_cmd(rd, cmds, "parameter");
125	}
126
127	int cmd_sys(struct rd *rd)
128	{
129	const struct rd_cmd cmds[] = {
130	{ NULL, sys_show },
131	{ "show", sys_show },
132	{ "set", sys_set },
133	{ "help", sys_help },
134	{ 0 }
135	};
136
137	return rd_exec_cmd(rd, cmds, "system command");
138	}