[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"
#include <ctype.h>

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

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

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

/*
 * Possible input:output
 * dev/port    | first port | is_dump_all
 * mlx5_1      | 0          | true
 * mlx5_1/     | 0          | true
 * mlx5_1/0    | 0          | false
 * mlx5_1/1    | 1          | false
 * mlx5_1/-    | 0          | false
 *
 * In strict mode, /- will return error.
 */
static int get_port_from_argv(struct rd *rd, uint32_t *port,
			      bool *is_dump_all, bool strict_port)
{
	char *slash;

	*port = 0;
	*is_dump_all = true;

	slash = strchr(rd_argv(rd), '/');
	/* if no port found, return 0 */
	if (slash++) {
		if (*slash == '-') {
			if (strict_port)
				return -EINVAL;
			*is_dump_all = false;
			return 0;
		}

		if (isdigit(*slash)) {
			*is_dump_all = false;
			*port = atoi(slash);
		}
		if (!*port && strlen(slash))
			return -EINVAL;
	}
	return 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);
	if (!dev_map->dev_name) {
		free(dev_map);
		return NULL;
	}

	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 int add_filter(struct rd *rd, char *key, char *value,
		      const struct filters valid_filters[])
{
	char cset[] = "1234567890,-";
	struct filter_entry *fe;
	bool key_found = false;
	int idx = 0;
	int ret;

	fe = calloc(1, sizeof(*fe));
	if (!fe)
		return -ENOMEM;

	while (idx < MAX_NUMBER_OF_FILTERS && valid_filters[idx].name) {
		if (!strcmpx(key, valid_filters[idx].name)) {
			key_found = true;
			break;
		}
		idx++;
	}
	if (!key_found) {
		pr_err("Unsupported filter option: %s\n", key);
		ret = -EINVAL;
		goto err;
	}

	/*
	 * Check the filter validity, not optimal, but works
	 *
	 * Actually, there are three types of filters
	 *  numeric - for example PID or QPN
	 *  string  - for example states
	 *  link    - user requested to filter on specific link
	 *            e.g. mlx5_1/1, mlx5_1/-, mlx5_1 ...
	 */
	if (valid_filters[idx].is_number &&
	    strspn(value, cset) != strlen(value)) {
		pr_err("%s filter accepts \"%s\" characters only\n", key, cset);
		ret = -EINVAL;
		goto err;
	}

	fe->key = strdup(key);
	fe->value = strdup(value);
	if (!fe->key || !fe->value) {
		ret = -ENOMEM;
		goto err_alloc;
	}

	for (idx = 0; idx < strlen(fe->value); idx++)
		fe->value[idx] = tolower(fe->value[idx]);

	list_add_tail(&fe->list, &rd->filter_list);
	return 0;

err_alloc:
	free(fe->value);
	free(fe->key);
err:
	free(fe);
	return ret;
}

int rd_build_filter(struct rd *rd, const struct filters valid_filters[])
{
	int ret = 0;
	int idx = 0;

	if (!valid_filters || !rd_argc(rd))
		goto out;

	if (rd_argc(rd) == 1) {
		pr_err("No filter data was supplied to filter option %s\n", rd_argv(rd));
		ret = -EINVAL;
		goto out;
	}

	if (rd_argc(rd) % 2) {
		pr_err("There is filter option without data\n");
		ret = -EINVAL;
		goto out;
	}

	while (idx != rd_argc(rd)) {
		/*
		 * We can do micro-optimization and skip "dev"
		 * and "link" filters, but it is not worth of it.
		 */
		ret = add_filter(rd, *(rd->argv + idx),
				 *(rd->argv + idx + 1), valid_filters);
		if (ret)
			goto out;
		idx += 2;
	}

out:
	return ret;
}

bool rd_check_is_key_exist(struct rd *rd, const char *key)
{
	struct filter_entry *fe;

	list_for_each_entry(fe, &rd->filter_list, list) {
		if (!strcmpx(fe->key, key))
			return true;
	}

	return false;
}

/*
 * Check if string entry is filtered:
 *  * key doesn't exist -> user didn't request -> not filtered
 */
bool rd_check_is_string_filtered(struct rd *rd,
				 const char *key, const char *val)
{
	bool key_is_filtered = false;
	struct filter_entry *fe;
	char *p = NULL;
	char *str;

	list_for_each_entry(fe, &rd->filter_list, list) {
		if (!strcmpx(fe->key, key)) {
			/* We found the key */
			p = strdup(fe->value);
			key_is_filtered = true;
			if (!p) {
				/*
				 * Something extremely wrong if we fail
				 * to allocate small amount of bytes.
				 */
				pr_err("Found key, but failed to allocate memory to store value\n");
				return key_is_filtered;
			}

			/*
			 * Need to check if value in range
			 * It can come in the following formats
			 * and their permutations:
			 * str
			 * str1,str2
			 */
			str = strtok(p, ",");
			while (str) {
				if (strlen(str) == strlen(val) &&
				    !strcasecmp(str, val)) {
					key_is_filtered = false;
					goto out;
				}
				str = strtok(NULL, ",");
			}
			goto out;
		}
	}

out:
	free(p);
	return key_is_filtered;
}

/*
 * Check if key is filtered:
 * key doesn't exist -> user didn't request -> not filtered
 */
bool rd_check_is_filtered(struct rd *rd, const char *key, uint32_t val)
{
	bool key_is_filtered = false;
	struct filter_entry *fe;

	list_for_each_entry(fe, &rd->filter_list, list) {
		uint32_t left_val = 0, fe_value = 0;
		bool range_check = false;
		char *p = fe->value;

		if (!strcmpx(fe->key, key)) {
			/* We found the key */
			key_is_filtered = true;
			/*
			 * Need to check if value in range
			 * It can come in the following formats
			 * (and their permutations):
			 * numb
			 * numb1,numb2
			 * ,numb1,numb2
			 * numb1-numb2
			 * numb1,numb2-numb3,numb4-numb5
			 */
			while (*p) {
				if (isdigit(*p)) {
					fe_value = strtol(p, &p, 10);
					if (fe_value == val ||
					    (range_check && left_val < val &&
					     val < fe_value)) {
						key_is_filtered = false;
						goto out;
					}
					range_check = false;
				} else {
					if (*p == '-') {
						left_val = fe_value;
						range_check = true;
					}
					p++;
				}
			}
			goto out;
		}
	}

out:
	return key_is_filtered;
}

static void filters_cleanup(struct rd *rd)
{
	struct filter_entry *fe, *tmp;

	list_for_each_entry_safe(fe, tmp,
				 &rd->filter_list, list) {
		list_del(&fe->list);
		free(fe->key);
		free(fe->value);
		free(fe);
	}
}

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,
	[RDMA_NLDEV_ATTR_RES_SUMMARY]	= MNL_TYPE_NESTED,
	[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY]	= MNL_TYPE_NESTED,
	[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME] = MNL_TYPE_NUL_STRING,
	[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR] = MNL_TYPE_U64,
	[RDMA_NLDEV_ATTR_RES_QP]		= MNL_TYPE_NESTED,
	[RDMA_NLDEV_ATTR_RES_QP_ENTRY]		= MNL_TYPE_NESTED,
	[RDMA_NLDEV_ATTR_RES_LQPN]	= MNL_TYPE_U32,
	[RDMA_NLDEV_ATTR_RES_RQPN]	= MNL_TYPE_U32,
	[RDMA_NLDEV_ATTR_RES_RQ_PSN]		= MNL_TYPE_U32,
	[RDMA_NLDEV_ATTR_RES_SQ_PSN]		= MNL_TYPE_U32,
	[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE]	= MNL_TYPE_U8,
	[RDMA_NLDEV_ATTR_RES_TYPE]		= MNL_TYPE_U8,
	[RDMA_NLDEV_ATTR_RES_STATE]		= MNL_TYPE_U8,
	[RDMA_NLDEV_ATTR_RES_PID]		= MNL_TYPE_U32,
	[RDMA_NLDEV_ATTR_RES_KERN_NAME]	= MNL_TYPE_NUL_STRING,
	[RDMA_NLDEV_ATTR_RES_CM_ID]		= MNL_TYPE_NESTED,
	[RDMA_NLDEV_ATTR_RES_CM_ID_ENTRY]	= MNL_TYPE_NESTED,
	[RDMA_NLDEV_ATTR_RES_PS]		= MNL_TYPE_U32,
	[RDMA_NLDEV_ATTR_RES_SRC_ADDR]		= MNL_TYPE_UNSPEC,
	[RDMA_NLDEV_ATTR_RES_DST_ADDR]		= MNL_TYPE_UNSPEC,
	[RDMA_NLDEV_ATTR_RES_CQ] = MNL_TYPE_NESTED,
	[RDMA_NLDEV_ATTR_RES_CQ_ENTRY] = MNL_TYPE_NESTED,
	[RDMA_NLDEV_ATTR_RES_CQE] = MNL_TYPE_U32,
	[RDMA_NLDEV_ATTR_RES_USECNT] = MNL_TYPE_U64,
	[RDMA_NLDEV_ATTR_RES_POLL_CTX] = 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);
	filters_cleanup(rd);
}

int rd_set_arg_to_devname(struct rd *rd)
{
	int ret = 0;

	while (!rd_no_arg(rd)) {
		if (rd_argv_match(rd, "dev") || rd_argv_match(rd, "link")) {
			rd_arg_inc(rd);
			if (rd_no_arg(rd)) {
				pr_err("No device name was supplied\n");
				ret = -EINVAL;
			}
			goto out;
		}
		rd_arg_inc(rd);
	}
out:
	return ret;
}

int rd_exec_link(struct rd *rd, int (*cb)(struct rd *rd), bool strict_port)
{
	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;
			port = (strict_port) ? 1 : 0;
			for (; port < dev_map->num_ports + 1; port++) {
				rd->port_idx = port;
				ret = cb(rd);
				if (ret)
					goto out;
			}
		}

	} else {
		bool is_dump_all;

		dev_map = dev_map_lookup(rd, true);
		ret = get_port_from_argv(rd, &port, &is_dump_all, strict_port);
		if (!dev_map || port > dev_map->num_ports || (!port && ret)) {
			pr_err("Wrong device name\n");
			ret = -ENOENT;
			goto out;
		}
		rd_arg_inc(rd);
		rd->dev_idx = dev_map->idx;
		rd->port_idx = port;
		for (; rd->port_idx < dev_map->num_ports + 1; rd->port_idx++) {
			ret = cb(rd);
			if (ret)
				goto out;
			if (!is_dump_all)
				/*
				 * 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"
6416d1a0	13	#include <ctype.h>
74bd75c2	14
5f4892e2	15	int rd_argc(struct rd *rd)
74bd75c2 LR	16	{
	17	return rd->argc;
	18	}
	19
40df8263	20	char rd_argv(struct rd rd)
74bd75c2 LR	21	{
	22	if (!rd_argc(rd))
	23	return NULL;
	24	return *rd->argv;
	25	}
	26
684d8209	27	int strcmpx(const char str1, const char str2)
74bd75c2 LR	28	{
	29	if (strlen(str1) > strlen(str2))
	30	return -1;
	31	return strncmp(str1, str2, strlen(str1));
	32	}
	33
	34	static bool rd_argv_match(struct rd rd, const char pattern)
	35	{
	36	if (!rd_argc(rd))
	37	return false;
	38	return strcmpx(rd_argv(rd), pattern) == 0;
	39	}
	40
	41	void rd_arg_inc(struct rd *rd)
	42	{
	43	if (!rd_argc(rd))
	44	return;
	45	rd->argc--;
	46	rd->argv++;
	47	}
	48
	49	bool rd_no_arg(struct rd *rd)
	50	{
	51	return rd_argc(rd) == 0;
	52	}
	53
6416d1a0 LR	54	/*
	55	* Possible input:output
	56	* dev/port \| first port \| is_dump_all
	57	* mlx5_1 \| 0 \| true
	58	* mlx5_1/ \| 0 \| true
	59	* mlx5_1/0 \| 0 \| false
	60	* mlx5_1/1 \| 1 \| false
	61	* mlx5_1/- \| 0 \| false
	62	*
	63	* In strict mode, /- will return error.
	64	*/
	65	static int get_port_from_argv(struct rd rd, uint32_t port,
	66	bool *is_dump_all, bool strict_port)
40df8263 LR	67	{
	68	char *slash;
	69
6416d1a0 LR	70	*port = 0;
	71	*is_dump_all = true;
	72
40df8263 LR	73	slash = strchr(rd_argv(rd), '/');
40df8263 LR	74	/* if no port found, return 0 */
6416d1a0 LR	75	if (slash++) {
	76	if (*slash == '-') {
	77	if (strict_port)
	78	return -EINVAL;
	79	*is_dump_all = false;
	80	return 0;
	81	}
	82
	83	if (isdigit(*slash)) {
	84	*is_dump_all = false;
	85	*port = atoi(slash);
	86	}
	87	if (!*port && strlen(slash))
	88	return -EINVAL;
	89	}
	90	return 0;
40df8263 LR	91	}
40df8263 LR	92
74bd75c2 LR	93	static struct dev_map dev_map_alloc(const char dev_name)
	94	{
	95	struct dev_map *dev_map;
	96
	97	dev_map = calloc(1, sizeof(*dev_map));
	98	if (!dev_map)
	99	return NULL;
	100	dev_map->dev_name = strdup(dev_name);
5f826553 LR	101	if (!dev_map->dev_name) {
	102	free(dev_map);
	103	return NULL;
	104	}
74bd75c2 LR	105
	106	return dev_map;
	107	}
	108
74bd75c2 LR	109	static void dev_map_cleanup(struct rd *rd)
	110	{
	111	struct dev_map dev_map, tmp;
	112
	113	list_for_each_entry_safe(dev_map, tmp,
	114	&rd->dev_map_list, list) {
	115	list_del(&dev_map->list);
b1e6bc43 LR	116	free(dev_map->dev_name);
b1e6bc43 LR	117	free(dev_map);
74bd75c2 LR	118	}
	119	}
	120
1174be72 LR	121	static int add_filter(struct rd rd, char key, char *value,
	122	const struct filters valid_filters[])
	123	{
	124	char cset[] = "1234567890,-";
	125	struct filter_entry *fe;
	126	bool key_found = false;
	127	int idx = 0;
	128	int ret;
	129
	130	fe = calloc(1, sizeof(*fe));
	131	if (!fe)
	132	return -ENOMEM;
	133
	134	while (idx < MAX_NUMBER_OF_FILTERS && valid_filters[idx].name) {
	135	if (!strcmpx(key, valid_filters[idx].name)) {
	136	key_found = true;
	137	break;
	138	}
	139	idx++;
	140	}
	141	if (!key_found) {
	142	pr_err("Unsupported filter option: %s\n", key);
	143	ret = -EINVAL;
	144	goto err;
	145	}
	146
	147	/*
	148	* Check the filter validity, not optimal, but works
	149	*
	150	* Actually, there are three types of filters
	151	* numeric - for example PID or QPN
	152	* string - for example states
	153	* link - user requested to filter on specific link
	154	* e.g. mlx5_1/1, mlx5_1/-, mlx5_1 ...
	155	*/
	156	if (valid_filters[idx].is_number &&
	157	strspn(value, cset) != strlen(value)) {
	158	pr_err("%s filter accepts \"%s\" characters only\n", key, cset);
	159	ret = -EINVAL;
	160	goto err;
	161	}
	162
	163	fe->key = strdup(key);
	164	fe->value = strdup(value);
	165	if (!fe->key \|\| !fe->value) {
	166	ret = -ENOMEM;
	167	goto err_alloc;
	168	}
	169
	170	for (idx = 0; idx < strlen(fe->value); idx++)
	171	fe->value[idx] = tolower(fe->value[idx]);
	172
	173	list_add_tail(&fe->list, &rd->filter_list);
	174	return 0;
	175
	176	err_alloc:
	177	free(fe->value);
	178	free(fe->key);
	179	err:
	180	free(fe);
	181	return ret;
	182	}
	183
	184	int rd_build_filter(struct rd *rd, const struct filters valid_filters[])
185	{
186	int ret = 0;
187	int idx = 0;
188
189	if (!valid_filters \|\| !rd_argc(rd))
190	goto out;
191
192	if (rd_argc(rd) == 1) {
193	pr_err("No filter data was supplied to filter option %s\n", rd_argv(rd));
194	ret = -EINVAL;
195	goto out;
196	}
197
198	if (rd_argc(rd) % 2) {
199	pr_err("There is filter option without data\n");
200	ret = -EINVAL;
201	goto out;
202	}
203
204	while (idx != rd_argc(rd)) {
205	/*
206	* We can do micro-optimization and skip "dev"
207	* and "link" filters, but it is not worth of it.
208	*/
209	ret = add_filter(rd, *(rd->argv + idx),
210	*(rd->argv + idx + 1), valid_filters);
211	if (ret)
212	goto out;
213	idx += 2;
214	}
215
216	out:
217	return ret;
218	}
219
220	bool rd_check_is_key_exist(struct rd rd, const char key)
221	{
222	struct filter_entry *fe;
223
224	list_for_each_entry(fe, &rd->filter_list, list) {
225	if (!strcmpx(fe->key, key))
226	return true;
227	}
228
229	return false;
230	}
231
232	/*
233	* Check if string entry is filtered:
234	* * key doesn't exist -> user didn't request -> not filtered
235	*/
236	bool rd_check_is_string_filtered(struct rd *rd,
237	const char key, const char val)
238	{
239	bool key_is_filtered = false;
240	struct filter_entry *fe;
241	char *p = NULL;
242	char *str;
243
244	list_for_each_entry(fe, &rd->filter_list, list) {
245	if (!strcmpx(fe->key, key)) {
246	/* We found the key */
247	p = strdup(fe->value);
248	key_is_filtered = true;
249	if (!p) {
250	/*
251	* Something extremely wrong if we fail
252	* to allocate small amount of bytes.
253	*/
254	pr_err("Found key, but failed to allocate memory to store value\n");
255	return key_is_filtered;
256	}
257
258	/*
259	* Need to check if value in range
260	* It can come in the following formats
261	* and their permutations:
262	* str
263	* str1,str2
264	*/
265	str = strtok(p, ",");
266	while (str) {
267	if (strlen(str) == strlen(val) &&
268	!strcasecmp(str, val)) {
269	key_is_filtered = false;
270	goto out;
271	}
272	str = strtok(NULL, ",");
273	}
274	goto out;
275	}
276	}
277
278	out:
279	free(p);
280	return key_is_filtered;
281	}
282
283	/*
284	* Check if key is filtered:
285	* key doesn't exist -> user didn't request -> not filtered
286	*/
287	bool rd_check_is_filtered(struct rd rd, const char key, uint32_t val)
288	{
289	bool key_is_filtered = false;
290	struct filter_entry *fe;
291
292	list_for_each_entry(fe, &rd->filter_list, list) {
293	uint32_t left_val = 0, fe_value = 0;
294	bool range_check = false;
295	char *p = fe->value;
296
297	if (!strcmpx(fe->key, key)) {
298	/* We found the key */
299	key_is_filtered = true;
300	/*
301	* Need to check if value in range
302	* It can come in the following formats
303	* (and their permutations):
304	* numb
305	* numb1,numb2
306	* ,numb1,numb2
307	* numb1-numb2
308	* numb1,numb2-numb3,numb4-numb5
309	*/
310	while (*p) {
311	if (isdigit(*p)) {
312	fe_value = strtol(p, &p, 10);
313	if (fe_value == val \|\|
314	(range_check && left_val < val &&
315	val < fe_value)) {
316	key_is_filtered = false;
317	goto out;
318	}
319	range_check = false;
320	} else {
321	if (*p == '-') {
322	left_val = fe_value;
323	range_check = true;
324	}
325	p++;
326	}
327	}
328	goto out;
329	}
330	}
331
332	out:
333	return key_is_filtered;
334	}
335
336	static void filters_cleanup(struct rd *rd)
337	{
338	struct filter_entry fe, tmp;
339
340	list_for_each_entry_safe(fe, tmp,
341	&rd->filter_list, list) {
342	list_del(&fe->list);
343	free(fe->key);
344	free(fe->value);
345	free(fe);
346	}
347	}
348
74bd75c2	349	static const enum mnl_attr_data_type nldev_policy[RDMA_NLDEV_ATTR_MAX] = {
40df8263	350	[RDMA_NLDEV_ATTR_DEV_INDEX] = MNL_TYPE_U32,
74bd75c2 LR	351	[RDMA_NLDEV_ATTR_DEV_NAME] = MNL_TYPE_NUL_STRING,
74bd75c2 LR	352	[RDMA_NLDEV_ATTR_PORT_INDEX] = MNL_TYPE_U32,
40df8263 LR	353	[RDMA_NLDEV_ATTR_CAP_FLAGS] = MNL_TYPE_U64,
	354	[RDMA_NLDEV_ATTR_FW_VERSION] = MNL_TYPE_NUL_STRING,
	355	[RDMA_NLDEV_ATTR_NODE_GUID] = MNL_TYPE_U64,
	356	[RDMA_NLDEV_ATTR_SYS_IMAGE_GUID] = MNL_TYPE_U64,
da990ab4 LR	357	[RDMA_NLDEV_ATTR_LID] = MNL_TYPE_U32,
	358	[RDMA_NLDEV_ATTR_SM_LID] = MNL_TYPE_U32,
	359	[RDMA_NLDEV_ATTR_LMC] = MNL_TYPE_U8,
	360	[RDMA_NLDEV_ATTR_PORT_STATE] = MNL_TYPE_U8,
	361	[RDMA_NLDEV_ATTR_PORT_PHYS_STATE] = MNL_TYPE_U8,
40df8263	362	[RDMA_NLDEV_ATTR_DEV_NODE_TYPE] = MNL_TYPE_U8,
923aa825 LR	363	[RDMA_NLDEV_ATTR_RES_SUMMARY] = MNL_TYPE_NESTED,
	364	[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY] = MNL_TYPE_NESTED,
	365	[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME] = MNL_TYPE_NUL_STRING,
	366	[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR] = MNL_TYPE_U64,
8ecac46a LR	367	[RDMA_NLDEV_ATTR_RES_QP] = MNL_TYPE_NESTED,
	368	[RDMA_NLDEV_ATTR_RES_QP_ENTRY] = MNL_TYPE_NESTED,
	369	[RDMA_NLDEV_ATTR_RES_LQPN] = MNL_TYPE_U32,
	370	[RDMA_NLDEV_ATTR_RES_RQPN] = MNL_TYPE_U32,
	371	[RDMA_NLDEV_ATTR_RES_RQ_PSN] = MNL_TYPE_U32,
	372	[RDMA_NLDEV_ATTR_RES_SQ_PSN] = MNL_TYPE_U32,
	373	[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE] = MNL_TYPE_U8,
	374	[RDMA_NLDEV_ATTR_RES_TYPE] = MNL_TYPE_U8,
	375	[RDMA_NLDEV_ATTR_RES_STATE] = MNL_TYPE_U8,
	376	[RDMA_NLDEV_ATTR_RES_PID] = MNL_TYPE_U32,
	377	[RDMA_NLDEV_ATTR_RES_KERN_NAME] = MNL_TYPE_NUL_STRING,
9a362cc7 SW	378	[RDMA_NLDEV_ATTR_RES_CM_ID] = MNL_TYPE_NESTED,
	379	[RDMA_NLDEV_ATTR_RES_CM_ID_ENTRY] = MNL_TYPE_NESTED,
	380	[RDMA_NLDEV_ATTR_RES_PS] = MNL_TYPE_U32,
	381	[RDMA_NLDEV_ATTR_RES_SRC_ADDR] = MNL_TYPE_UNSPEC,
	382	[RDMA_NLDEV_ATTR_RES_DST_ADDR] = MNL_TYPE_UNSPEC,
b0b8e32c SW	383	[RDMA_NLDEV_ATTR_RES_CQ] = MNL_TYPE_NESTED,
	384	[RDMA_NLDEV_ATTR_RES_CQ_ENTRY] = MNL_TYPE_NESTED,
	385	[RDMA_NLDEV_ATTR_RES_CQE] = MNL_TYPE_U32,
	386	[RDMA_NLDEV_ATTR_RES_USECNT] = MNL_TYPE_U64,
	387	[RDMA_NLDEV_ATTR_RES_POLL_CTX] = MNL_TYPE_U8,
74bd75c2 LR	388	};
	389
	390	int rd_attr_cb(const struct nlattr attr, void data)
	391	{
	392	const struct nlattr **tb = data;
	393	int type;
	394
	395	if (mnl_attr_type_valid(attr, RDMA_NLDEV_ATTR_MAX) < 0)
	396	return MNL_CB_ERROR;
	397
	398	type = mnl_attr_get_type(attr);
	399
	400	if (mnl_attr_validate(attr, nldev_policy[type]) < 0)
	401	return MNL_CB_ERROR;
	402
	403	tb[type] = attr;
	404	return MNL_CB_OK;
	405	}
	406
	407	int rd_dev_init_cb(const struct nlmsghdr nlh, void data)
	408	{
	409	struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
	410	struct dev_map *dev_map;
	411	struct rd *rd = data;
	412	const char *dev_name;
	413
	414	mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
	415	if (!tb[RDMA_NLDEV_ATTR_DEV_NAME] \|\| !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
	416	return MNL_CB_ERROR;
	417	if (!tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
	418	pr_err("This tool doesn't support switches yet\n");
	419	return MNL_CB_ERROR;
	420	}
	421
	422	dev_name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
	423
	424	dev_map = dev_map_alloc(dev_name);
	425	if (!dev_map)
	426	/* The main function will cleanup the allocations */
	427	return MNL_CB_ERROR;
	428	list_add_tail(&dev_map->list, &rd->dev_map_list);
	429
	430	dev_map->num_ports = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
	431	dev_map->idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
	432	return MNL_CB_OK;
	433	}
	434
5fc17280	435	void rd_free(struct rd *rd)
74bd75c2 LR	436	{
	437	if (!rd)
	438	return;
5fc17280	439	free(rd->buff);
74bd75c2	440	dev_map_cleanup(rd);
1174be72	441	filters_cleanup(rd);
74bd75c2 LR	442	}
74bd75c2 LR	443
6e0de6e8 LR	444	int rd_set_arg_to_devname(struct rd *rd)
	445	{
	446	int ret = 0;
	447
	448	while (!rd_no_arg(rd)) {
	449	if (rd_argv_match(rd, "dev") \|\| rd_argv_match(rd, "link")) {
	450	rd_arg_inc(rd);
	451	if (rd_no_arg(rd)) {
	452	pr_err("No device name was supplied\n");
	453	ret = -EINVAL;
	454	}
	455	goto out;
	456	}
	457	rd_arg_inc(rd);
	458	}
	459	out:
	460	return ret;
	461	}
	462
6416d1a0	463	int rd_exec_link(struct rd rd, int (cb)(struct rd *rd), bool strict_port)
874c734c LR	464	{
	465	struct dev_map *dev_map;
	466	uint32_t port;
	467	int ret = 0;
	468
	469	if (rd->json_output)
	470	jsonw_start_array(rd->jw);
	471	if (rd_no_arg(rd)) {
	472	list_for_each_entry(dev_map, &rd->dev_map_list, list) {
	473	rd->dev_idx = dev_map->idx;
6416d1a0 LR	474	port = (strict_port) ? 1 : 0;
6416d1a0 LR	475	for (; port < dev_map->num_ports + 1; port++) {
874c734c LR	476	rd->port_idx = port;
	477	ret = cb(rd);
	478	if (ret)
	479	goto out;
	480	}
	481	}
	482
	483	} else {
6416d1a0 LR	484	bool is_dump_all;
6416d1a0 LR	485
874c734c	486	dev_map = dev_map_lookup(rd, true);
6416d1a0 LR	487	ret = get_port_from_argv(rd, &port, &is_dump_all, strict_port);
6416d1a0 LR	488	if (!dev_map \|\| port > dev_map->num_ports \|\| (!port && ret)) {
874c734c LR	489	pr_err("Wrong device name\n");
	490	ret = -ENOENT;
	491	goto out;
	492	}
	493	rd_arg_inc(rd);
	494	rd->dev_idx = dev_map->idx;
6416d1a0	495	rd->port_idx = port;
874c734c LR	496	for (; rd->port_idx < dev_map->num_ports + 1; rd->port_idx++) {
	497	ret = cb(rd);
	498	if (ret)
	499	goto out;
6416d1a0	500	if (!is_dump_all)
874c734c LR	501	/*
	502	* We got request to show link for devname
	503	* with port index.
	504	*/
	505	break;
	506	}
	507	}
	508
	509	out:
	510	if (rd->json_output)
	511	jsonw_end_array(rd->jw);
	512	return ret;
	513	}
	514
8b92a2c9 LR	515	int rd_exec_dev(struct rd rd, int (cb)(struct rd *rd))
	516	{
	517	struct dev_map *dev_map;
	518	int ret = 0;
	519
	520	if (rd->json_output)
	521	jsonw_start_array(rd->jw);
	522	if (rd_no_arg(rd)) {
	523	list_for_each_entry(dev_map, &rd->dev_map_list, list) {
	524	rd->dev_idx = dev_map->idx;
	525	ret = cb(rd);
	526	if (ret)
	527	goto out;
	528	}
	529	} else {
	530	dev_map = dev_map_lookup(rd, false);
	531	if (!dev_map) {
b5564441	532	pr_err("Wrong device name - %s\n", rd_argv(rd));
8b92a2c9 LR	533	ret = -ENOENT;
	534	goto out;
	535	}
	536	rd_arg_inc(rd);
	537	rd->dev_idx = dev_map->idx;
	538	ret = cb(rd);
	539	}
	540	out:
	541	if (rd->json_output)
	542	jsonw_end_array(rd->jw);
	543	return ret;
	544	}
	545
74bd75c2 LR	546	int rd_exec_cmd(struct rd rd, const struct rd_cmd cmds, const char *str)
	547	{
	548	const struct rd_cmd *c;
	549
	550	/* First argument in objs table is default variant */
	551	if (rd_no_arg(rd))
	552	return cmds->func(rd);
	553
	554	for (c = cmds + 1; c->cmd; ++c) {
	555	if (rd_argv_match(rd, c->cmd)) {
	556	/* Move to next argument */
	557	rd_arg_inc(rd);
	558	return c->func(rd);
	559	}
	560	}
	561
	562	pr_err("Unknown %s '%s'.\n", str, rd_argv(rd));
	563	return 0;
	564	}
	565
	566	void rd_prepare_msg(struct rd rd, uint32_t cmd, uint32_t seq, uint16_t flags)
	567	{
	568	*seq = time(NULL);
	569
	570	rd->nlh = mnl_nlmsg_put_header(rd->buff);
	571	rd->nlh->nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, cmd);
	572	rd->nlh->nlmsg_seq = *seq;
	573	rd->nlh->nlmsg_flags = flags;
	574	}
	575
	576	int rd_send_msg(struct rd *rd)
	577	{
	578	int ret;
	579
	580	rd->nl = mnl_socket_open(NETLINK_RDMA);
	581	if (!rd->nl) {
	582	pr_err("Failed to open NETLINK_RDMA socket\n");
	583	return -ENODEV;
	584	}
	585
	586	ret = mnl_socket_bind(rd->nl, 0, MNL_SOCKET_AUTOPID);
	587	if (ret < 0) {
	588	pr_err("Failed to bind socket with err %d\n", ret);
	589	goto err;
	590	}
	591
	592	ret = mnl_socket_sendto(rd->nl, rd->nlh, rd->nlh->nlmsg_len);
	593	if (ret < 0) {
	594	pr_err("Failed to send to socket with err %d\n", ret);
	595	goto err;
	596	}
	597	return 0;
	598
	599	err:
	600	mnl_socket_close(rd->nl);
	601	return ret;
	602	}
	603
	604	int rd_recv_msg(struct rd rd, mnl_cb_t callback, void data, unsigned int seq)
	605	{
	606	int ret;
	607	unsigned int portid;
	608	char buf[MNL_SOCKET_BUFFER_SIZE];
	609
610	portid = mnl_socket_get_portid(rd->nl);
611	do {
612	ret = mnl_socket_recvfrom(rd->nl, buf, sizeof(buf));
613	if (ret <= 0)
614	break;
615
616	ret = mnl_cb_run(buf, ret, seq, portid, callback, data);
617	} while (ret > 0);
618
619	mnl_socket_close(rd->nl);
620	return ret;
621	}
40df8263	622
0fc8c30b	623	static struct dev_map _dev_map_lookup(struct rd rd, const char *dev_name)
40df8263 LR	624	{
	625	struct dev_map *dev_map;
	626
	627	list_for_each_entry(dev_map, &rd->dev_map_list, list)
	628	if (strcmp(dev_name, dev_map->dev_name) == 0)
	629	return dev_map;
	630
	631	return NULL;
	632	}
	633
	634	struct dev_map dev_map_lookup(struct rd rd, bool allow_port_index)
	635	{
	636	struct dev_map *dev_map;
	637	char *dev_name;
	638	char *slash;
	639
99da9032 LR	640	if (rd_no_arg(rd))
	641	return NULL;
	642
40df8263 LR	643	dev_name = strdup(rd_argv(rd));
	644	if (allow_port_index) {
	645	slash = strrchr(dev_name, '/');
	646	if (slash)
	647	*slash = '\0';
	648	}
	649
	650	dev_map = _dev_map_lookup(rd, dev_name);
	651	free(dev_name);
	652	return dev_map;
	653	}