[mirror_iproute2.git] / rdma / utils.c

/*
 * utils.c	RDMA tool
 *
 *              This program is free software; you can redistribute it and/or
 *              modify it under the terms of the GNU General Public License
 *              as published by the Free Software Foundation; either version
 *              2 of the License, or (at your option) any later version.
 *
 * Authors:     Leon Romanovsky <leonro@mellanox.com>
 */

#include "rdma.h"

static int rd_argc(struct rd *rd)
{
	return rd->argc;
}

char *rd_argv(struct rd *rd)
{
	if (!rd_argc(rd))
		return NULL;
	return *rd->argv;
}

static int strcmpx(const char *str1, const char *str2)
{
	if (strlen(str1) > strlen(str2))
		return -1;
	return strncmp(str1, str2, strlen(str1));
}

static bool rd_argv_match(struct rd *rd, const char *pattern)
{
	if (!rd_argc(rd))
		return false;
	return strcmpx(rd_argv(rd), pattern) == 0;
}

void rd_arg_inc(struct rd *rd)
{
	if (!rd_argc(rd))
		return;
	rd->argc--;
	rd->argv++;
}

bool rd_no_arg(struct rd *rd)
{
	return rd_argc(rd) == 0;
}

uint32_t get_port_from_argv(struct rd *rd)
{
	char *slash;

	slash = strchr(rd_argv(rd), '/');
	/* if no port found, return 0 */
	return slash ? atoi(slash + 1) : 0;
}

static struct dev_map *dev_map_alloc(const char *dev_name)
{
	struct dev_map *dev_map;

	dev_map = calloc(1, sizeof(*dev_map));
	if (!dev_map)
		return NULL;
	dev_map->dev_name = strdup(dev_name);

	return dev_map;
}

static void dev_map_cleanup(struct rd *rd)
{
	struct dev_map *dev_map, *tmp;

	list_for_each_entry_safe(dev_map, tmp,
				 &rd->dev_map_list, list) {
		list_del(&dev_map->list);
		free(dev_map->dev_name);
		free(dev_map);
	}
}

static const enum mnl_attr_data_type nldev_policy[RDMA_NLDEV_ATTR_MAX] = {
	[RDMA_NLDEV_ATTR_DEV_INDEX] = MNL_TYPE_U32,
	[RDMA_NLDEV_ATTR_DEV_NAME] = MNL_TYPE_NUL_STRING,
	[RDMA_NLDEV_ATTR_PORT_INDEX] = MNL_TYPE_U32,
	[RDMA_NLDEV_ATTR_CAP_FLAGS] = MNL_TYPE_U64,
	[RDMA_NLDEV_ATTR_FW_VERSION] = MNL_TYPE_NUL_STRING,
	[RDMA_NLDEV_ATTR_NODE_GUID] = MNL_TYPE_U64,
	[RDMA_NLDEV_ATTR_SYS_IMAGE_GUID] = MNL_TYPE_U64,
	[RDMA_NLDEV_ATTR_LID] = MNL_TYPE_U32,
	[RDMA_NLDEV_ATTR_SM_LID] = MNL_TYPE_U32,
	[RDMA_NLDEV_ATTR_LMC] = MNL_TYPE_U8,
	[RDMA_NLDEV_ATTR_PORT_STATE] = MNL_TYPE_U8,
	[RDMA_NLDEV_ATTR_PORT_PHYS_STATE] = MNL_TYPE_U8,
	[RDMA_NLDEV_ATTR_DEV_NODE_TYPE] = MNL_TYPE_U8,
};

int rd_attr_cb(const struct nlattr *attr, void *data)
{
	const struct nlattr **tb = data;
	int type;

	if (mnl_attr_type_valid(attr, RDMA_NLDEV_ATTR_MAX) < 0)
		return MNL_CB_ERROR;

	type = mnl_attr_get_type(attr);

	if (mnl_attr_validate(attr, nldev_policy[type]) < 0)
		return MNL_CB_ERROR;

	tb[type] = attr;
	return MNL_CB_OK;
}

int rd_dev_init_cb(const struct nlmsghdr *nlh, void *data)
{
	struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
	struct dev_map *dev_map;
	struct rd *rd = data;
	const char *dev_name;

	mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
	if (!tb[RDMA_NLDEV_ATTR_DEV_NAME] || !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
		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;
	}

	dev_name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);

	dev_map = dev_map_alloc(dev_name);
	if (!dev_map)
		/* The main function will cleanup the allocations */
		return MNL_CB_ERROR;
	list_add_tail(&dev_map->list, &rd->dev_map_list);

	dev_map->num_ports = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
	dev_map->idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
	return MNL_CB_OK;
}

void rd_free(struct rd *rd)
{
	if (!rd)
		return;
	free(rd->buff);
	dev_map_cleanup(rd);
}

int rd_exec_link(struct rd *rd, int (*cb)(struct rd *rd))
{
	struct dev_map *dev_map;
	uint32_t port;
	int ret = 0;

	if (rd->json_output)
		jsonw_start_array(rd->jw);
	if (rd_no_arg(rd)) {
		list_for_each_entry(dev_map, &rd->dev_map_list, list) {
			rd->dev_idx = dev_map->idx;
			for (port = 1; port < dev_map->num_ports + 1; port++) {
				rd->port_idx = port;
				ret = cb(rd);
				if (ret)
					goto out;
			}
		}

	} else {
		dev_map = dev_map_lookup(rd, true);
		port = get_port_from_argv(rd);
		if (!dev_map || port > dev_map->num_ports) {
			pr_err("Wrong device name\n");
			ret = -ENOENT;
			goto out;
		}
		rd_arg_inc(rd);
		rd->dev_idx = dev_map->idx;
		rd->port_idx = port ? : 1;
		for (; rd->port_idx < dev_map->num_ports + 1; rd->port_idx++) {
			ret = cb(rd);
			if (ret)
				goto out;
			if (port)
				/*
				 * We got request to show link for devname
				 * with port index.
				 */
				break;
		}
	}

out:
	if (rd->json_output)
		jsonw_end_array(rd->jw);
	return ret;
}

int rd_exec_dev(struct rd *rd, int (*cb)(struct rd *rd))
{
	struct dev_map *dev_map;
	int ret = 0;

	if (rd->json_output)
		jsonw_start_array(rd->jw);
	if (rd_no_arg(rd)) {
		list_for_each_entry(dev_map, &rd->dev_map_list, list) {
			rd->dev_idx = dev_map->idx;
			ret = cb(rd);
			if (ret)
				goto out;
		}
	} else {
		dev_map = dev_map_lookup(rd, false);
		if (!dev_map) {
			pr_err("Wrong device name - %s\n", rd_argv(rd));
			ret = -ENOENT;
			goto out;
		}
		rd_arg_inc(rd);
		rd->dev_idx = dev_map->idx;
		ret = cb(rd);
	}
out:
	if (rd->json_output)
		jsonw_end_array(rd->jw);
	return ret;
}

int rd_exec_cmd(struct rd *rd, const struct rd_cmd *cmds, const char *str)
{
	const struct rd_cmd *c;

	/* First argument in objs table is default variant */
	if (rd_no_arg(rd))
		return cmds->func(rd);

	for (c = cmds + 1; c->cmd; ++c) {
		if (rd_argv_match(rd, c->cmd)) {
			/* Move to next argument */
			rd_arg_inc(rd);
			return c->func(rd);
		}
	}

	pr_err("Unknown %s '%s'.\n", str, rd_argv(rd));
	return 0;
}

void rd_prepare_msg(struct rd *rd, uint32_t cmd, uint32_t *seq, uint16_t flags)
{
	*seq = time(NULL);

	rd->nlh = mnl_nlmsg_put_header(rd->buff);
	rd->nlh->nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, cmd);
	rd->nlh->nlmsg_seq = *seq;
	rd->nlh->nlmsg_flags = flags;
}

int rd_send_msg(struct rd *rd)
{
	int ret;

	rd->nl = mnl_socket_open(NETLINK_RDMA);
	if (!rd->nl) {
		pr_err("Failed to open NETLINK_RDMA socket\n");
		return -ENODEV;
	}

	ret = mnl_socket_bind(rd->nl, 0, MNL_SOCKET_AUTOPID);
	if (ret < 0) {
		pr_err("Failed to bind socket with err %d\n", ret);
		goto err;
	}

	ret = mnl_socket_sendto(rd->nl, rd->nlh, rd->nlh->nlmsg_len);
	if (ret < 0) {
		pr_err("Failed to send to socket with err %d\n", ret);
		goto err;
	}
	return 0;

err:
	mnl_socket_close(rd->nl);
	return ret;
}

int rd_recv_msg(struct rd *rd, mnl_cb_t callback, void *data, unsigned int seq)
{
	int ret;
	unsigned int portid;
	char buf[MNL_SOCKET_BUFFER_SIZE];

	portid = mnl_socket_get_portid(rd->nl);
	do {
		ret = mnl_socket_recvfrom(rd->nl, buf, sizeof(buf));
		if (ret <= 0)
			break;

		ret = mnl_cb_run(buf, ret, seq, portid, callback, data);
	} while (ret > 0);

	mnl_socket_close(rd->nl);
	return ret;
}

static struct dev_map *_dev_map_lookup(struct rd *rd, const char *dev_name)
{
	struct dev_map *dev_map;

	list_for_each_entry(dev_map, &rd->dev_map_list, list)
		if (strcmp(dev_name, dev_map->dev_name) == 0)
			return dev_map;

	return NULL;
}

struct dev_map *dev_map_lookup(struct rd *rd, bool allow_port_index)
{
	struct dev_map *dev_map;
	char *dev_name;
	char *slash;

	if (rd_no_arg(rd))
		return NULL;

	dev_name = strdup(rd_argv(rd));
	if (allow_port_index) {
		slash = strrchr(dev_name, '/');
		if (slash)
			*slash = '\0';
	}

	dev_map = _dev_map_lookup(rd, dev_name);
	free(dev_name);
	return dev_map;
}
Commit	Line	Data
74bd75c2 LR	1	/*
	2	* utils.c RDMA tool
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version
	7	* 2 of the License, or (at your option) any later version.
	8	*
	9	* Authors: Leon Romanovsky <leonro@mellanox.com>
	10	*/
	11
	12	#include "rdma.h"
	13
	14	static int rd_argc(struct rd *rd)
	15	{
	16	return rd->argc;
	17	}
	18
40df8263	19	char rd_argv(struct rd rd)
74bd75c2 LR	20	{
	21	if (!rd_argc(rd))
	22	return NULL;
	23	return *rd->argv;
	24	}
	25
	26	static int strcmpx(const char str1, const char str2)
	27	{
	28	if (strlen(str1) > strlen(str2))
	29	return -1;
	30	return strncmp(str1, str2, strlen(str1));
	31	}
	32
	33	static bool rd_argv_match(struct rd rd, const char pattern)
	34	{
	35	if (!rd_argc(rd))
	36	return false;
	37	return strcmpx(rd_argv(rd), pattern) == 0;
	38	}
	39
	40	void rd_arg_inc(struct rd *rd)
	41	{
	42	if (!rd_argc(rd))
	43	return;
	44	rd->argc--;
	45	rd->argv++;
	46	}
	47
	48	bool rd_no_arg(struct rd *rd)
	49	{
	50	return rd_argc(rd) == 0;
	51	}
	52
40df8263 LR	53	uint32_t get_port_from_argv(struct rd *rd)
	54	{
	55	char *slash;
	56
	57	slash = strchr(rd_argv(rd), '/');
	58	/* if no port found, return 0 */
	59	return slash ? atoi(slash + 1) : 0;
	60	}
	61
74bd75c2 LR	62	static struct dev_map dev_map_alloc(const char dev_name)
	63	{
	64	struct dev_map *dev_map;
	65
	66	dev_map = calloc(1, sizeof(*dev_map));
	67	if (!dev_map)
	68	return NULL;
	69	dev_map->dev_name = strdup(dev_name);
	70
	71	return dev_map;
	72	}
	73
74bd75c2 LR	74	static void dev_map_cleanup(struct rd *rd)
	75	{
	76	struct dev_map dev_map, tmp;
	77
	78	list_for_each_entry_safe(dev_map, tmp,
	79	&rd->dev_map_list, list) {
	80	list_del(&dev_map->list);
b1e6bc43 LR	81	free(dev_map->dev_name);
b1e6bc43 LR	82	free(dev_map);
74bd75c2 LR	83	}
	84	}
	85
	86	static const enum mnl_attr_data_type nldev_policy[RDMA_NLDEV_ATTR_MAX] = {
40df8263	87	[RDMA_NLDEV_ATTR_DEV_INDEX] = MNL_TYPE_U32,
74bd75c2 LR	88	[RDMA_NLDEV_ATTR_DEV_NAME] = MNL_TYPE_NUL_STRING,
74bd75c2 LR	89	[RDMA_NLDEV_ATTR_PORT_INDEX] = MNL_TYPE_U32,
40df8263 LR	90	[RDMA_NLDEV_ATTR_CAP_FLAGS] = MNL_TYPE_U64,
	91	[RDMA_NLDEV_ATTR_FW_VERSION] = MNL_TYPE_NUL_STRING,
	92	[RDMA_NLDEV_ATTR_NODE_GUID] = MNL_TYPE_U64,
	93	[RDMA_NLDEV_ATTR_SYS_IMAGE_GUID] = MNL_TYPE_U64,
da990ab4 LR	94	[RDMA_NLDEV_ATTR_LID] = MNL_TYPE_U32,
	95	[RDMA_NLDEV_ATTR_SM_LID] = MNL_TYPE_U32,
	96	[RDMA_NLDEV_ATTR_LMC] = MNL_TYPE_U8,
	97	[RDMA_NLDEV_ATTR_PORT_STATE] = MNL_TYPE_U8,
	98	[RDMA_NLDEV_ATTR_PORT_PHYS_STATE] = MNL_TYPE_U8,
40df8263	99	[RDMA_NLDEV_ATTR_DEV_NODE_TYPE] = MNL_TYPE_U8,
74bd75c2 LR	100	};
	101
	102	int rd_attr_cb(const struct nlattr attr, void data)
	103	{
	104	const struct nlattr **tb = data;
	105	int type;
	106
	107	if (mnl_attr_type_valid(attr, RDMA_NLDEV_ATTR_MAX) < 0)
	108	return MNL_CB_ERROR;
	109
	110	type = mnl_attr_get_type(attr);
	111
	112	if (mnl_attr_validate(attr, nldev_policy[type]) < 0)
	113	return MNL_CB_ERROR;
	114
	115	tb[type] = attr;
	116	return MNL_CB_OK;
	117	}
	118
	119	int rd_dev_init_cb(const struct nlmsghdr nlh, void data)
	120	{
	121	struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
	122	struct dev_map *dev_map;
	123	struct rd *rd = data;
	124	const char *dev_name;
	125
	126	mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
	127	if (!tb[RDMA_NLDEV_ATTR_DEV_NAME] \|\| !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
	128	return MNL_CB_ERROR;
	129	if (!tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
	130	pr_err("This tool doesn't support switches yet\n");
	131	return MNL_CB_ERROR;
	132	}
	133
	134	dev_name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
	135
	136	dev_map = dev_map_alloc(dev_name);
	137	if (!dev_map)
	138	/* The main function will cleanup the allocations */
	139	return MNL_CB_ERROR;
	140	list_add_tail(&dev_map->list, &rd->dev_map_list);
	141
	142	dev_map->num_ports = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
	143	dev_map->idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
	144	return MNL_CB_OK;
	145	}
	146
5fc17280	147	void rd_free(struct rd *rd)
74bd75c2 LR	148	{
	149	if (!rd)
	150	return;
5fc17280	151	free(rd->buff);
74bd75c2 LR	152	dev_map_cleanup(rd);
	153	}
	154
874c734c LR	155	int rd_exec_link(struct rd rd, int (cb)(struct rd *rd))
	156	{
	157	struct dev_map *dev_map;
	158	uint32_t port;
	159	int ret = 0;
	160
	161	if (rd->json_output)
	162	jsonw_start_array(rd->jw);
	163	if (rd_no_arg(rd)) {
	164	list_for_each_entry(dev_map, &rd->dev_map_list, list) {
	165	rd->dev_idx = dev_map->idx;
	166	for (port = 1; port < dev_map->num_ports + 1; port++) {
	167	rd->port_idx = port;
	168	ret = cb(rd);
	169	if (ret)
	170	goto out;
	171	}
	172	}
	173
	174	} else {
	175	dev_map = dev_map_lookup(rd, true);
	176	port = get_port_from_argv(rd);
	177	if (!dev_map \|\| port > dev_map->num_ports) {
	178	pr_err("Wrong device name\n");
	179	ret = -ENOENT;
	180	goto out;
	181	}
	182	rd_arg_inc(rd);
	183	rd->dev_idx = dev_map->idx;
	184	rd->port_idx = port ? : 1;
	185	for (; rd->port_idx < dev_map->num_ports + 1; rd->port_idx++) {
	186	ret = cb(rd);
	187	if (ret)
	188	goto out;
	189	if (port)
	190	/*
	191	* We got request to show link for devname
	192	* with port index.
	193	*/
	194	break;
	195	}
	196	}
	197
	198	out:
	199	if (rd->json_output)
	200	jsonw_end_array(rd->jw);
	201	return ret;
	202	}
	203
8b92a2c9 LR	204	int rd_exec_dev(struct rd rd, int (cb)(struct rd *rd))
	205	{
	206	struct dev_map *dev_map;
	207	int ret = 0;
	208
	209	if (rd->json_output)
	210	jsonw_start_array(rd->jw);
	211	if (rd_no_arg(rd)) {
	212	list_for_each_entry(dev_map, &rd->dev_map_list, list) {
	213	rd->dev_idx = dev_map->idx;
	214	ret = cb(rd);
	215	if (ret)
	216	goto out;
	217	}
	218	} else {
	219	dev_map = dev_map_lookup(rd, false);
	220	if (!dev_map) {
b5564441	221	pr_err("Wrong device name - %s\n", rd_argv(rd));
8b92a2c9 LR	222	ret = -ENOENT;
	223	goto out;
	224	}
	225	rd_arg_inc(rd);
	226	rd->dev_idx = dev_map->idx;
	227	ret = cb(rd);
	228	}
	229	out:
	230	if (rd->json_output)
	231	jsonw_end_array(rd->jw);
	232	return ret;
	233	}
	234
74bd75c2 LR	235	int rd_exec_cmd(struct rd rd, const struct rd_cmd cmds, const char *str)
	236	{
	237	const struct rd_cmd *c;
	238
	239	/* First argument in objs table is default variant */
	240	if (rd_no_arg(rd))
	241	return cmds->func(rd);
	242
	243	for (c = cmds + 1; c->cmd; ++c) {
	244	if (rd_argv_match(rd, c->cmd)) {
	245	/* Move to next argument */
	246	rd_arg_inc(rd);
	247	return c->func(rd);
	248	}
	249	}
	250
	251	pr_err("Unknown %s '%s'.\n", str, rd_argv(rd));
	252	return 0;
	253	}
	254
	255	void rd_prepare_msg(struct rd rd, uint32_t cmd, uint32_t seq, uint16_t flags)
	256	{
	257	*seq = time(NULL);
	258
	259	rd->nlh = mnl_nlmsg_put_header(rd->buff);
	260	rd->nlh->nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, cmd);
	261	rd->nlh->nlmsg_seq = *seq;
	262	rd->nlh->nlmsg_flags = flags;
	263	}
	264
	265	int rd_send_msg(struct rd *rd)
	266	{
	267	int ret;
	268
	269	rd->nl = mnl_socket_open(NETLINK_RDMA);
	270	if (!rd->nl) {
	271	pr_err("Failed to open NETLINK_RDMA socket\n");
	272	return -ENODEV;
	273	}
	274
	275	ret = mnl_socket_bind(rd->nl, 0, MNL_SOCKET_AUTOPID);
	276	if (ret < 0) {
	277	pr_err("Failed to bind socket with err %d\n", ret);
	278	goto err;
	279	}
	280
	281	ret = mnl_socket_sendto(rd->nl, rd->nlh, rd->nlh->nlmsg_len);
	282	if (ret < 0) {
	283	pr_err("Failed to send to socket with err %d\n", ret);
	284	goto err;
	285	}
	286	return 0;
	287
	288	err:
	289	mnl_socket_close(rd->nl);
	290	return ret;
	291	}
	292
	293	int rd_recv_msg(struct rd rd, mnl_cb_t callback, void data, unsigned int seq)
	294	{
	295	int ret;
	296	unsigned int portid;
	297	char buf[MNL_SOCKET_BUFFER_SIZE];
	298
299	portid = mnl_socket_get_portid(rd->nl);
300	do {
301	ret = mnl_socket_recvfrom(rd->nl, buf, sizeof(buf));
302	if (ret <= 0)
303	break;
304
305	ret = mnl_cb_run(buf, ret, seq, portid, callback, data);
306	} while (ret > 0);
307
308	mnl_socket_close(rd->nl);
309	return ret;
310	}
40df8263	311
0fc8c30b	312	static struct dev_map _dev_map_lookup(struct rd rd, const char *dev_name)
40df8263 LR	313	{
	314	struct dev_map *dev_map;
	315
	316	list_for_each_entry(dev_map, &rd->dev_map_list, list)
	317	if (strcmp(dev_name, dev_map->dev_name) == 0)
	318	return dev_map;
	319
	320	return NULL;
	321	}
	322
	323	struct dev_map dev_map_lookup(struct rd rd, bool allow_port_index)
	324	{
	325	struct dev_map *dev_map;
	326	char *dev_name;
	327	char *slash;
	328
99da9032 LR	329	if (rd_no_arg(rd))
	330	return NULL;
	331
40df8263 LR	332	dev_name = strdup(rd_argv(rd));
	333	if (allow_port_index) {
	334	slash = strrchr(dev_name, '/');
	335	if (slash)
	336	*slash = '\0';
	337	}
	338
	339	dev_map = _dev_map_lookup(rd, dev_name);
	340	free(dev_name);
	341	return dev_map;
	342	}