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

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

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