[linux-block.git] / net / ethtool / strset.c

// SPDX-License-Identifier: GPL-2.0-only

#include <linux/ethtool.h>
#include <linux/phy.h>
#include "netlink.h"
#include "common.h"

struct strset_info {
	bool per_dev;
	bool free_strings;
	unsigned int count;
	const char (*strings)[ETH_GSTRING_LEN];
};

static const struct strset_info info_template[] = {
	[ETH_SS_TEST] = {
		.per_dev	= true,
	},
	[ETH_SS_STATS] = {
		.per_dev	= true,
	},
	[ETH_SS_PRIV_FLAGS] = {
		.per_dev	= true,
	},
	[ETH_SS_FEATURES] = {
		.per_dev	= false,
		.count		= ARRAY_SIZE(netdev_features_strings),
		.strings	= netdev_features_strings,
	},
	[ETH_SS_RSS_HASH_FUNCS] = {
		.per_dev	= false,
		.count		= ARRAY_SIZE(rss_hash_func_strings),
		.strings	= rss_hash_func_strings,
	},
	[ETH_SS_TUNABLES] = {
		.per_dev	= false,
		.count		= ARRAY_SIZE(tunable_strings),
		.strings	= tunable_strings,
	},
	[ETH_SS_PHY_STATS] = {
		.per_dev	= true,
	},
	[ETH_SS_PHY_TUNABLES] = {
		.per_dev	= false,
		.count		= ARRAY_SIZE(phy_tunable_strings),
		.strings	= phy_tunable_strings,
	},
	[ETH_SS_LINK_MODES] = {
		.per_dev	= false,
		.count		= __ETHTOOL_LINK_MODE_MASK_NBITS,
		.strings	= link_mode_names,
	},
	[ETH_SS_MSG_CLASSES] = {
		.per_dev	= false,
		.count		= NETIF_MSG_CLASS_COUNT,
		.strings	= netif_msg_class_names,
	},
	[ETH_SS_WOL_MODES] = {
		.per_dev	= false,
		.count		= WOL_MODE_COUNT,
		.strings	= wol_mode_names,
	},
	[ETH_SS_SOF_TIMESTAMPING] = {
		.per_dev	= false,
		.count		= __SOF_TIMESTAMPING_CNT,
		.strings	= sof_timestamping_names,
	},
	[ETH_SS_TS_TX_TYPES] = {
		.per_dev	= false,
		.count		= __HWTSTAMP_TX_CNT,
		.strings	= ts_tx_type_names,
	},
	[ETH_SS_TS_RX_FILTERS] = {
		.per_dev	= false,
		.count		= __HWTSTAMP_FILTER_CNT,
		.strings	= ts_rx_filter_names,
	},
	[ETH_SS_UDP_TUNNEL_TYPES] = {
		.per_dev	= false,
		.count		= __ETHTOOL_UDP_TUNNEL_TYPE_CNT,
		.strings	= udp_tunnel_type_names,
	},
	[ETH_SS_STATS_STD] = {
		.per_dev	= false,
		.count		= __ETHTOOL_STATS_CNT,
		.strings	= stats_std_names,
	},
	[ETH_SS_STATS_ETH_PHY] = {
		.per_dev	= false,
		.count		= __ETHTOOL_A_STATS_ETH_PHY_CNT,
		.strings	= stats_eth_phy_names,
	},
	[ETH_SS_STATS_ETH_MAC] = {
		.per_dev	= false,
		.count		= __ETHTOOL_A_STATS_ETH_MAC_CNT,
		.strings	= stats_eth_mac_names,
	},
	[ETH_SS_STATS_ETH_CTRL] = {
		.per_dev	= false,
		.count		= __ETHTOOL_A_STATS_ETH_CTRL_CNT,
		.strings	= stats_eth_ctrl_names,
	},
	[ETH_SS_STATS_RMON] = {
		.per_dev	= false,
		.count		= __ETHTOOL_A_STATS_RMON_CNT,
		.strings	= stats_rmon_names,
	},
};

struct strset_req_info {
	struct ethnl_req_info		base;
	u32				req_ids;
	bool				counts_only;
};

#define STRSET_REQINFO(__req_base) \
	container_of(__req_base, struct strset_req_info, base)

struct strset_reply_data {
	struct ethnl_reply_data		base;
	struct strset_info		sets[ETH_SS_COUNT];
};

#define STRSET_REPDATA(__reply_base) \
	container_of(__reply_base, struct strset_reply_data, base)

const struct nla_policy ethnl_strset_get_policy[] = {
	[ETHTOOL_A_STRSET_HEADER]	=
		NLA_POLICY_NESTED(ethnl_header_policy),
	[ETHTOOL_A_STRSET_STRINGSETS]	= { .type = NLA_NESTED },
	[ETHTOOL_A_STRSET_COUNTS_ONLY]	= { .type = NLA_FLAG },
};

static const struct nla_policy get_stringset_policy[] = {
	[ETHTOOL_A_STRINGSET_ID]	= { .type = NLA_U32 },
};

/**
 * strset_include() - test if a string set should be included in reply
 * @info: parsed client request
 * @data: pointer to request data structure
 * @id:   id of string set to check (ETH_SS_* constants)
 */
static bool strset_include(const struct strset_req_info *info,
			   const struct strset_reply_data *data, u32 id)
{
	bool per_dev;

	BUILD_BUG_ON(ETH_SS_COUNT >= BITS_PER_BYTE * sizeof(info->req_ids));

	if (info->req_ids)
		return info->req_ids & (1U << id);
	per_dev = data->sets[id].per_dev;
	if (!per_dev && !data->sets[id].strings)
		return false;

	return data->base.dev ? per_dev : !per_dev;
}

static int strset_get_id(const struct nlattr *nest, u32 *val,
			 struct netlink_ext_ack *extack)
{
	struct nlattr *tb[ARRAY_SIZE(get_stringset_policy)];
	int ret;

	ret = nla_parse_nested(tb, ARRAY_SIZE(get_stringset_policy) - 1, nest,
			       get_stringset_policy, extack);
	if (ret < 0)
		return ret;
	if (NL_REQ_ATTR_CHECK(extack, nest, tb, ETHTOOL_A_STRINGSET_ID))
		return -EINVAL;

	*val = nla_get_u32(tb[ETHTOOL_A_STRINGSET_ID]);
	return 0;
}

static const struct nla_policy strset_stringsets_policy[] = {
	[ETHTOOL_A_STRINGSETS_STRINGSET]	= { .type = NLA_NESTED },
};

static int strset_parse_request(struct ethnl_req_info *req_base,
				struct nlattr **tb,
				struct netlink_ext_ack *extack)
{
	struct strset_req_info *req_info = STRSET_REQINFO(req_base);
	struct nlattr *nest = tb[ETHTOOL_A_STRSET_STRINGSETS];
	struct nlattr *attr;
	int rem, ret;

	if (!nest)
		return 0;
	ret = nla_validate_nested(nest,
				  ARRAY_SIZE(strset_stringsets_policy) - 1,
				  strset_stringsets_policy, extack);
	if (ret < 0)
		return ret;

	req_info->counts_only = tb[ETHTOOL_A_STRSET_COUNTS_ONLY];
	nla_for_each_nested(attr, nest, rem) {
		u32 id;

		if (WARN_ONCE(nla_type(attr) != ETHTOOL_A_STRINGSETS_STRINGSET,
			      "unexpected attrtype %u in ETHTOOL_A_STRSET_STRINGSETS\n",
			      nla_type(attr)))
			return -EINVAL;

		ret = strset_get_id(attr, &id, extack);
		if (ret < 0)
			return ret;
		if (id >= ETH_SS_COUNT) {
			NL_SET_ERR_MSG_ATTR(extack, attr,
					    "unknown string set id");
			return -EOPNOTSUPP;
		}

		req_info->req_ids |= (1U << id);
	}

	return 0;
}

static void strset_cleanup_data(struct ethnl_reply_data *reply_base)
{
	struct strset_reply_data *data = STRSET_REPDATA(reply_base);
	unsigned int i;

	for (i = 0; i < ETH_SS_COUNT; i++)
		if (data->sets[i].free_strings) {
			kfree(data->sets[i].strings);
			data->sets[i].strings = NULL;
			data->sets[i].free_strings = false;
		}
}

static int strset_prepare_set(struct strset_info *info, struct net_device *dev,
			      unsigned int id, bool counts_only)
{
	const struct ethtool_phy_ops *phy_ops = ethtool_phy_ops;
	const struct ethtool_ops *ops = dev->ethtool_ops;
	void *strings;
	int count, ret;

	if (id == ETH_SS_PHY_STATS && dev->phydev &&
	    !ops->get_ethtool_phy_stats && phy_ops &&
	    phy_ops->get_sset_count)
		ret = phy_ops->get_sset_count(dev->phydev);
	else if (ops->get_sset_count && ops->get_strings)
		ret = ops->get_sset_count(dev, id);
	else
		ret = -EOPNOTSUPP;
	if (ret <= 0) {
		info->count = 0;
		return 0;
	}

	count = ret;
	if (!counts_only) {
		strings = kcalloc(count, ETH_GSTRING_LEN, GFP_KERNEL);
		if (!strings)
			return -ENOMEM;
		if (id == ETH_SS_PHY_STATS && dev->phydev &&
		    !ops->get_ethtool_phy_stats && phy_ops &&
		    phy_ops->get_strings)
			phy_ops->get_strings(dev->phydev, strings);
		else
			ops->get_strings(dev, id, strings);
		info->strings = strings;
		info->free_strings = true;
	}
	info->count = count;

	return 0;
}

static int strset_prepare_data(const struct ethnl_req_info *req_base,
			       struct ethnl_reply_data *reply_base,
			       struct genl_info *info)
{
	const struct strset_req_info *req_info = STRSET_REQINFO(req_base);
	struct strset_reply_data *data = STRSET_REPDATA(reply_base);
	struct net_device *dev = reply_base->dev;
	unsigned int i;
	int ret;

	BUILD_BUG_ON(ARRAY_SIZE(info_template) != ETH_SS_COUNT);
	memcpy(&data->sets, &info_template, sizeof(data->sets));

	if (!dev) {
		for (i = 0; i < ETH_SS_COUNT; i++) {
			if ((req_info->req_ids & (1U << i)) &&
			    data->sets[i].per_dev) {
				if (info)
					GENL_SET_ERR_MSG(info, "requested per device strings without dev");
				return -EINVAL;
			}
		}
		return 0;
	}

	ret = ethnl_ops_begin(dev);
	if (ret < 0)
		goto err_strset;
	for (i = 0; i < ETH_SS_COUNT; i++) {
		if (!strset_include(req_info, data, i) ||
		    !data->sets[i].per_dev)
			continue;

		ret = strset_prepare_set(&data->sets[i], dev, i,
					 req_info->counts_only);
		if (ret < 0)
			goto err_ops;
	}
	ethnl_ops_complete(dev);

	return 0;
err_ops:
	ethnl_ops_complete(dev);
err_strset:
	strset_cleanup_data(reply_base);
	return ret;
}

/* calculate size of ETHTOOL_A_STRSET_STRINGSET nest for one string set */
static int strset_set_size(const struct strset_info *info, bool counts_only)
{
	unsigned int len = 0;
	unsigned int i;

	if (info->count == 0)
		return 0;
	if (counts_only)
		return nla_total_size(2 * nla_total_size(sizeof(u32)));

	for (i = 0; i < info->count; i++) {
		const char *str = info->strings[i];

		/* ETHTOOL_A_STRING_INDEX, ETHTOOL_A_STRING_VALUE, nest */
		len += nla_total_size(nla_total_size(sizeof(u32)) +
				      ethnl_strz_size(str));
	}
	/* ETHTOOL_A_STRINGSET_ID, ETHTOOL_A_STRINGSET_COUNT */
	len = 2 * nla_total_size(sizeof(u32)) + nla_total_size(len);

	return nla_total_size(len);
}

static int strset_reply_size(const struct ethnl_req_info *req_base,
			     const struct ethnl_reply_data *reply_base)
{
	const struct strset_req_info *req_info = STRSET_REQINFO(req_base);
	const struct strset_reply_data *data = STRSET_REPDATA(reply_base);
	unsigned int i;
	int len = 0;
	int ret;

	len += nla_total_size(0); /* ETHTOOL_A_STRSET_STRINGSETS */

	for (i = 0; i < ETH_SS_COUNT; i++) {
		const struct strset_info *set_info = &data->sets[i];

		if (!strset_include(req_info, data, i))
			continue;

		ret = strset_set_size(set_info, req_info->counts_only);
		if (ret < 0)
			return ret;
		len += ret;
	}

	return len;
}

/* fill one string into reply */
static int strset_fill_string(struct sk_buff *skb,
			      const struct strset_info *set_info, u32 idx)
{
	struct nlattr *string_attr;
	const char *value;

	value = set_info->strings[idx];

	string_attr = nla_nest_start(skb, ETHTOOL_A_STRINGS_STRING);
	if (!string_attr)
		return -EMSGSIZE;
	if (nla_put_u32(skb, ETHTOOL_A_STRING_INDEX, idx) ||
	    ethnl_put_strz(skb, ETHTOOL_A_STRING_VALUE, value))
		goto nla_put_failure;
	nla_nest_end(skb, string_attr);

	return 0;
nla_put_failure:
	nla_nest_cancel(skb, string_attr);
	return -EMSGSIZE;
}

/* fill one string set into reply */
static int strset_fill_set(struct sk_buff *skb,
			   const struct strset_info *set_info, u32 id,
			   bool counts_only)
{
	struct nlattr *stringset_attr;
	struct nlattr *strings_attr;
	unsigned int i;

	if (!set_info->per_dev && !set_info->strings)
		return -EOPNOTSUPP;
	if (set_info->count == 0)
		return 0;
	stringset_attr = nla_nest_start(skb, ETHTOOL_A_STRINGSETS_STRINGSET);
	if (!stringset_attr)
		return -EMSGSIZE;

	if (nla_put_u32(skb, ETHTOOL_A_STRINGSET_ID, id) ||
	    nla_put_u32(skb, ETHTOOL_A_STRINGSET_COUNT, set_info->count))
		goto nla_put_failure;

	if (!counts_only) {
		strings_attr = nla_nest_start(skb, ETHTOOL_A_STRINGSET_STRINGS);
		if (!strings_attr)
			goto nla_put_failure;
		for (i = 0; i < set_info->count; i++) {
			if (strset_fill_string(skb, set_info, i) < 0)
				goto nla_put_failure;
		}
		nla_nest_end(skb, strings_attr);
	}

	nla_nest_end(skb, stringset_attr);
	return 0;

nla_put_failure:
	nla_nest_cancel(skb, stringset_attr);
	return -EMSGSIZE;
}

static int strset_fill_reply(struct sk_buff *skb,
			     const struct ethnl_req_info *req_base,
			     const struct ethnl_reply_data *reply_base)
{
	const struct strset_req_info *req_info = STRSET_REQINFO(req_base);
	const struct strset_reply_data *data = STRSET_REPDATA(reply_base);
	struct nlattr *nest;
	unsigned int i;
	int ret;

	nest = nla_nest_start(skb, ETHTOOL_A_STRSET_STRINGSETS);
	if (!nest)
		return -EMSGSIZE;

	for (i = 0; i < ETH_SS_COUNT; i++) {
		if (strset_include(req_info, data, i)) {
			ret = strset_fill_set(skb, &data->sets[i], i,
					      req_info->counts_only);
			if (ret < 0)
				goto nla_put_failure;
		}
	}

	nla_nest_end(skb, nest);
	return 0;

nla_put_failure:
	nla_nest_cancel(skb, nest);
	return ret;
}

const struct ethnl_request_ops ethnl_strset_request_ops = {
	.request_cmd		= ETHTOOL_MSG_STRSET_GET,
	.reply_cmd		= ETHTOOL_MSG_STRSET_GET_REPLY,
	.hdr_attr		= ETHTOOL_A_STRSET_HEADER,
	.req_info_size		= sizeof(struct strset_req_info),
	.reply_data_size	= sizeof(struct strset_reply_data),
	.allow_nodev_do		= true,

	.parse_request		= strset_parse_request,
	.prepare_data		= strset_prepare_data,
	.reply_size		= strset_reply_size,
	.fill_reply		= strset_fill_reply,
	.cleanup_data		= strset_cleanup_data,
};
Commit	Line	Data
71921690 MK	1	// SPDX-License-Identifier: GPL-2.0-only
	2
	3	#include <linux/ethtool.h>
	4	#include <linux/phy.h>
	5	#include "netlink.h"
	6	#include "common.h"
	7
	8	struct strset_info {
	9	bool per_dev;
	10	bool free_strings;
	11	unsigned int count;
	12	const char (*strings)[ETH_GSTRING_LEN];
	13	};
	14
	15	static const struct strset_info info_template[] = {
	16	[ETH_SS_TEST] = {
	17	.per_dev = true,
	18	},
	19	[ETH_SS_STATS] = {
	20	.per_dev = true,
	21	},
	22	[ETH_SS_PRIV_FLAGS] = {
	23	.per_dev = true,
	24	},
	25	[ETH_SS_FEATURES] = {
	26	.per_dev = false,
	27	.count = ARRAY_SIZE(netdev_features_strings),
	28	.strings = netdev_features_strings,
	29	},
	30	[ETH_SS_RSS_HASH_FUNCS] = {
	31	.per_dev = false,
	32	.count = ARRAY_SIZE(rss_hash_func_strings),
	33	.strings = rss_hash_func_strings,
	34	},
	35	[ETH_SS_TUNABLES] = {
	36	.per_dev = false,
	37	.count = ARRAY_SIZE(tunable_strings),
	38	.strings = tunable_strings,
	39	},
	40	[ETH_SS_PHY_STATS] = {
	41	.per_dev = true,
	42	},
	43	[ETH_SS_PHY_TUNABLES] = {
	44	.per_dev = false,
	45	.count = ARRAY_SIZE(phy_tunable_strings),
	46	.strings = phy_tunable_strings,
	47	},
	48	[ETH_SS_LINK_MODES] = {
	49	.per_dev = false,
	50	.count = __ETHTOOL_LINK_MODE_MASK_NBITS,
	51	.strings = link_mode_names,
	52	},
6a94b8cc MK	53	[ETH_SS_MSG_CLASSES] = {
	54	.per_dev = false,
	55	.count = NETIF_MSG_CLASS_COUNT,
	56	.strings = netif_msg_class_names,
	57	},
51ea22b0 MK	58	[ETH_SS_WOL_MODES] = {
	59	.per_dev = false,
	60	.count = WOL_MODE_COUNT,
	61	.strings = wol_mode_names,
	62	},
f76510b4 MK	63	[ETH_SS_SOF_TIMESTAMPING] = {
	64	.per_dev = false,
	65	.count = __SOF_TIMESTAMPING_CNT,
	66	.strings = sof_timestamping_names,
	67	},
	68	[ETH_SS_TS_TX_TYPES] = {
	69	.per_dev = false,
	70	.count = __HWTSTAMP_TX_CNT,
	71	.strings = ts_tx_type_names,
	72	},
	73	[ETH_SS_TS_RX_FILTERS] = {
	74	.per_dev = false,
	75	.count = __HWTSTAMP_FILTER_CNT,
	76	.strings = ts_rx_filter_names,
	77	},
c7d759eb JK	78	[ETH_SS_UDP_TUNNEL_TYPES] = {
	79	.per_dev = false,
	80	.count = __ETHTOOL_UDP_TUNNEL_TYPE_CNT,
	81	.strings = udp_tunnel_type_names,
	82	},
f09ea6fb JK	83	[ETH_SS_STATS_STD] = {
	84	.per_dev = false,
	85	.count = __ETHTOOL_STATS_CNT,
	86	.strings = stats_std_names,
	87	},
	88	[ETH_SS_STATS_ETH_PHY] = {
	89	.per_dev = false,
	90	.count = __ETHTOOL_A_STATS_ETH_PHY_CNT,
	91	.strings = stats_eth_phy_names,
	92	},
ca224454 JK	93	[ETH_SS_STATS_ETH_MAC] = {
	94	.per_dev = false,
	95	.count = __ETHTOOL_A_STATS_ETH_MAC_CNT,
	96	.strings = stats_eth_mac_names,
	97	},
bfad2b97 JK	98	[ETH_SS_STATS_ETH_CTRL] = {
	99	.per_dev = false,
	100	.count = __ETHTOOL_A_STATS_ETH_CTRL_CNT,
	101	.strings = stats_eth_ctrl_names,
	102	},
a8b06e9d JK	103	[ETH_SS_STATS_RMON] = {
	104	.per_dev = false,
	105	.count = __ETHTOOL_A_STATS_RMON_CNT,
	106	.strings = stats_rmon_names,
	107	},
71921690 MK	108	};
	109
	110	struct strset_req_info {
	111	struct ethnl_req_info base;
	112	u32 req_ids;
	113	bool counts_only;
	114	};
	115
	116	#define STRSET_REQINFO(__req_base) \
	117	container_of(__req_base, struct strset_req_info, base)
	118
	119	struct strset_reply_data {
	120	struct ethnl_reply_data base;
	121	struct strset_info sets[ETH_SS_COUNT];
	122	};
	123
	124	#define STRSET_REPDATA(__reply_base) \
	125	container_of(__reply_base, struct strset_reply_data, base)
	126
ff419afa	127	const struct nla_policy ethnl_strset_get_policy[] = {
329d9c33 JK	128	[ETHTOOL_A_STRSET_HEADER] =
329d9c33 JK	129	NLA_POLICY_NESTED(ethnl_header_policy),
71921690	130	[ETHTOOL_A_STRSET_STRINGSETS] = { .type = NLA_NESTED },
db972e53	131	[ETHTOOL_A_STRSET_COUNTS_ONLY] = { .type = NLA_FLAG },
71921690 MK	132	};
71921690 MK	133
ff419afa	134	static const struct nla_policy get_stringset_policy[] = {
71921690	135	[ETHTOOL_A_STRINGSET_ID] = { .type = NLA_U32 },
71921690 MK	136	};
	137
	138	/**
	139	* strset_include() - test if a string set should be included in reply
d2c4b444	140	* @info: parsed client request
71921690 MK	141	* @data: pointer to request data structure
	142	* @id: id of string set to check (ETH_SS_* constants)
	143	*/
	144	static bool strset_include(const struct strset_req_info *info,
	145	const struct strset_reply_data *data, u32 id)
	146	{
	147	bool per_dev;
	148
	149	BUILD_BUG_ON(ETH_SS_COUNT >= BITS_PER_BYTE * sizeof(info->req_ids));
	150
	151	if (info->req_ids)
	152	return info->req_ids & (1U << id);
	153	per_dev = data->sets[id].per_dev;
	154	if (!per_dev && !data->sets[id].strings)
	155	return false;
	156
	157	return data->base.dev ? per_dev : !per_dev;
	158	}
	159
	160	static int strset_get_id(const struct nlattr nest, u32 val,
	161	struct netlink_ext_ack *extack)
	162	{
ff419afa	163	struct nlattr *tb[ARRAY_SIZE(get_stringset_policy)];
71921690 MK	164	int ret;
71921690 MK	165
ff419afa	166	ret = nla_parse_nested(tb, ARRAY_SIZE(get_stringset_policy) - 1, nest,
71921690 MK	167	get_stringset_policy, extack);
	168	if (ret < 0)
	169	return ret;
08d1d0e7	170	if (NL_REQ_ATTR_CHECK(extack, nest, tb, ETHTOOL_A_STRINGSET_ID))
71921690 MK	171	return -EINVAL;
	172
	173	*val = nla_get_u32(tb[ETHTOOL_A_STRINGSET_ID]);
	174	return 0;
	175	}
	176
ff419afa	177	static const struct nla_policy strset_stringsets_policy[] = {
71921690 MK	178	[ETHTOOL_A_STRINGSETS_STRINGSET] = { .type = NLA_NESTED },
	179	};
	180
	181	static int strset_parse_request(struct ethnl_req_info *req_base,
	182	struct nlattr **tb,
	183	struct netlink_ext_ack *extack)
	184	{
	185	struct strset_req_info *req_info = STRSET_REQINFO(req_base);
	186	struct nlattr *nest = tb[ETHTOOL_A_STRSET_STRINGSETS];
	187	struct nlattr *attr;
	188	int rem, ret;
	189
	190	if (!nest)
	191	return 0;
ff419afa JK	192	ret = nla_validate_nested(nest,
ff419afa JK	193	ARRAY_SIZE(strset_stringsets_policy) - 1,
71921690 MK	194	strset_stringsets_policy, extack);
	195	if (ret < 0)
	196	return ret;
	197
	198	req_info->counts_only = tb[ETHTOOL_A_STRSET_COUNTS_ONLY];
	199	nla_for_each_nested(attr, nest, rem) {
	200	u32 id;
	201
	202	if (WARN_ONCE(nla_type(attr) != ETHTOOL_A_STRINGSETS_STRINGSET,
	203	"unexpected attrtype %u in ETHTOOL_A_STRSET_STRINGSETS\n",
	204	nla_type(attr)))
	205	return -EINVAL;
	206
	207	ret = strset_get_id(attr, &id, extack);
	208	if (ret < 0)
	209	return ret;
efb796f5	210	if (id >= ETH_SS_COUNT) {
71921690 MK	211	NL_SET_ERR_MSG_ATTR(extack, attr,
	212	"unknown string set id");
	213	return -EOPNOTSUPP;
	214	}
	215
	216	req_info->req_ids \|= (1U << id);
	217	}
	218
	219	return 0;
	220	}
	221
	222	static void strset_cleanup_data(struct ethnl_reply_data *reply_base)
	223	{
	224	struct strset_reply_data *data = STRSET_REPDATA(reply_base);
	225	unsigned int i;
	226
	227	for (i = 0; i < ETH_SS_COUNT; i++)
	228	if (data->sets[i].free_strings) {
	229	kfree(data->sets[i].strings);
	230	data->sets[i].strings = NULL;
	231	data->sets[i].free_strings = false;
	232	}
	233	}
	234
	235	static int strset_prepare_set(struct strset_info info, struct net_device dev,
	236	unsigned int id, bool counts_only)
	237	{
17809516	238	const struct ethtool_phy_ops *phy_ops = ethtool_phy_ops;
71921690 MK	239	const struct ethtool_ops *ops = dev->ethtool_ops;
	240	void *strings;
	241	int count, ret;
	242
	243	if (id == ETH_SS_PHY_STATS && dev->phydev &&
17809516 FF	244	!ops->get_ethtool_phy_stats && phy_ops &&
	245	phy_ops->get_sset_count)
	246	ret = phy_ops->get_sset_count(dev->phydev);
71921690 MK	247	else if (ops->get_sset_count && ops->get_strings)
	248	ret = ops->get_sset_count(dev, id);
	249	else
	250	ret = -EOPNOTSUPP;
	251	if (ret <= 0) {
	252	info->count = 0;
	253	return 0;
	254	}
	255
	256	count = ret;
	257	if (!counts_only) {
	258	strings = kcalloc(count, ETH_GSTRING_LEN, GFP_KERNEL);
	259	if (!strings)
	260	return -ENOMEM;
	261	if (id == ETH_SS_PHY_STATS && dev->phydev &&
17809516 FF	262	!ops->get_ethtool_phy_stats && phy_ops &&
	263	phy_ops->get_strings)
	264	phy_ops->get_strings(dev->phydev, strings);
71921690 MK	265	else
	266	ops->get_strings(dev, id, strings);
	267	info->strings = strings;
	268	info->free_strings = true;
	269	}
	270	info->count = count;
	271
	272	return 0;
	273	}
	274
	275	static int strset_prepare_data(const struct ethnl_req_info *req_base,
	276	struct ethnl_reply_data *reply_base,
	277	struct genl_info *info)
	278	{
	279	const struct strset_req_info *req_info = STRSET_REQINFO(req_base);
	280	struct strset_reply_data *data = STRSET_REPDATA(reply_base);
	281	struct net_device *dev = reply_base->dev;
	282	unsigned int i;
	283	int ret;
	284
	285	BUILD_BUG_ON(ARRAY_SIZE(info_template) != ETH_SS_COUNT);
	286	memcpy(&data->sets, &info_template, sizeof(data->sets));
	287
	288	if (!dev) {
	289	for (i = 0; i < ETH_SS_COUNT; i++) {
	290	if ((req_info->req_ids & (1U << i)) &&
	291	data->sets[i].per_dev) {
	292	if (info)
	293	GENL_SET_ERR_MSG(info, "requested per device strings without dev");
	294	return -EINVAL;
	295	}
	296	}
ac9c41d5	297	return 0;
71921690 MK	298	}
	299
	300	ret = ethnl_ops_begin(dev);
	301	if (ret < 0)
	302	goto err_strset;
	303	for (i = 0; i < ETH_SS_COUNT; i++) {
	304	if (!strset_include(req_info, data, i) \|\|
	305	!data->sets[i].per_dev)
	306	continue;
	307
	308	ret = strset_prepare_set(&data->sets[i], dev, i,
	309	req_info->counts_only);
	310	if (ret < 0)
	311	goto err_ops;
	312	}
	313	ethnl_ops_complete(dev);
	314
	315	return 0;
	316	err_ops:
	317	ethnl_ops_complete(dev);
	318	err_strset:
	319	strset_cleanup_data(reply_base);
	320	return ret;
	321	}
	322
	323	/* calculate size of ETHTOOL_A_STRSET_STRINGSET nest for one string set */
	324	static int strset_set_size(const struct strset_info *info, bool counts_only)
	325	{
	326	unsigned int len = 0;
	327	unsigned int i;
	328
	329	if (info->count == 0)
	330	return 0;
	331	if (counts_only)
	332	return nla_total_size(2 * nla_total_size(sizeof(u32)));
	333
	334	for (i = 0; i < info->count; i++) {
	335	const char *str = info->strings[i];
	336
	337	/* ETHTOOL_A_STRING_INDEX, ETHTOOL_A_STRING_VALUE, nest */
	338	len += nla_total_size(nla_total_size(sizeof(u32)) +
	339	ethnl_strz_size(str));
	340	}
	341	/* ETHTOOL_A_STRINGSET_ID, ETHTOOL_A_STRINGSET_COUNT */
	342	len = 2 * nla_total_size(sizeof(u32)) + nla_total_size(len);
	343
	344	return nla_total_size(len);
	345	}
	346
	347	static int strset_reply_size(const struct ethnl_req_info *req_base,
	348	const struct ethnl_reply_data *reply_base)
	349	{
	350	const struct strset_req_info *req_info = STRSET_REQINFO(req_base);
	351	const struct strset_reply_data *data = STRSET_REPDATA(reply_base);
	352	unsigned int i;
	353	int len = 0;
	354	int ret;
	355
e175aef9 JK	356	len += nla_total_size(0); /* ETHTOOL_A_STRSET_STRINGSETS */
e175aef9 JK	357
71921690 MK	358	for (i = 0; i < ETH_SS_COUNT; i++) {
	359	const struct strset_info *set_info = &data->sets[i];
	360
	361	if (!strset_include(req_info, data, i))
	362	continue;
	363
	364	ret = strset_set_size(set_info, req_info->counts_only);
	365	if (ret < 0)
	366	return ret;
	367	len += ret;
	368	}
	369
	370	return len;
	371	}
	372
	373	/* fill one string into reply */
	374	static int strset_fill_string(struct sk_buff *skb,
	375	const struct strset_info *set_info, u32 idx)
	376	{
	377	struct nlattr *string_attr;
	378	const char *value;
	379
	380	value = set_info->strings[idx];
	381
	382	string_attr = nla_nest_start(skb, ETHTOOL_A_STRINGS_STRING);
	383	if (!string_attr)
	384	return -EMSGSIZE;
	385	if (nla_put_u32(skb, ETHTOOL_A_STRING_INDEX, idx) \|\|
	386	ethnl_put_strz(skb, ETHTOOL_A_STRING_VALUE, value))
	387	goto nla_put_failure;
	388	nla_nest_end(skb, string_attr);
	389
	390	return 0;
	391	nla_put_failure:
	392	nla_nest_cancel(skb, string_attr);
	393	return -EMSGSIZE;
	394	}
	395
	396	/* fill one string set into reply */
	397	static int strset_fill_set(struct sk_buff *skb,
	398	const struct strset_info *set_info, u32 id,
	399	bool counts_only)
	400	{
	401	struct nlattr *stringset_attr;
	402	struct nlattr *strings_attr;
	403	unsigned int i;
	404
	405	if (!set_info->per_dev && !set_info->strings)
	406	return -EOPNOTSUPP;
	407	if (set_info->count == 0)
	408	return 0;
	409	stringset_attr = nla_nest_start(skb, ETHTOOL_A_STRINGSETS_STRINGSET);
	410	if (!stringset_attr)
	411	return -EMSGSIZE;
	412
	413	if (nla_put_u32(skb, ETHTOOL_A_STRINGSET_ID, id) \|\|
	414	nla_put_u32(skb, ETHTOOL_A_STRINGSET_COUNT, set_info->count))
	415	goto nla_put_failure;
	416
	417	if (!counts_only) {
	418	strings_attr = nla_nest_start(skb, ETHTOOL_A_STRINGSET_STRINGS);
	419	if (!strings_attr)
	420	goto nla_put_failure;
	421	for (i = 0; i < set_info->count; i++) {
422	if (strset_fill_string(skb, set_info, i) < 0)
423	goto nla_put_failure;
424	}
425	nla_nest_end(skb, strings_attr);
426	}
427
428	nla_nest_end(skb, stringset_attr);
429	return 0;
430
431	nla_put_failure:
432	nla_nest_cancel(skb, stringset_attr);
433	return -EMSGSIZE;
434	}
435
436	static int strset_fill_reply(struct sk_buff *skb,
437	const struct ethnl_req_info *req_base,
438	const struct ethnl_reply_data *reply_base)
439	{
440	const struct strset_req_info *req_info = STRSET_REQINFO(req_base);
441	const struct strset_reply_data *data = STRSET_REPDATA(reply_base);
442	struct nlattr *nest;
443	unsigned int i;
444	int ret;
445
446	nest = nla_nest_start(skb, ETHTOOL_A_STRSET_STRINGSETS);
447	if (!nest)
448	return -EMSGSIZE;
449
450	for (i = 0; i < ETH_SS_COUNT; i++) {
451	if (strset_include(req_info, data, i)) {
452	ret = strset_fill_set(skb, &data->sets[i], i,
453	req_info->counts_only);
454	if (ret < 0)
455	goto nla_put_failure;
456	}
457	}
458
459	nla_nest_end(skb, nest);
460	return 0;
461
462	nla_put_failure:
463	nla_nest_cancel(skb, nest);
464	return ret;
465	}
466
467	const struct ethnl_request_ops ethnl_strset_request_ops = {
468	.request_cmd = ETHTOOL_MSG_STRSET_GET,
469	.reply_cmd = ETHTOOL_MSG_STRSET_GET_REPLY,
470	.hdr_attr = ETHTOOL_A_STRSET_HEADER,
71921690 MK	471	.req_info_size = sizeof(struct strset_req_info),
71921690 MK	472	.reply_data_size = sizeof(struct strset_reply_data),
71921690 MK	473	.allow_nodev_do = true,
	474
	475	.parse_request = strset_parse_request,
	476	.prepare_data = strset_prepare_data,
	477	.reply_size = strset_reply_size,
	478	.fill_reply = strset_fill_reply,
	479	.cleanup_data = strset_cleanup_data,
	480	};