[mirror_ubuntu-jammy-kernel.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,
	},
};

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 (!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;

	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	},
71921690 MK	83	};
	84
	85	struct strset_req_info {
	86	struct ethnl_req_info base;
	87	u32 req_ids;
	88	bool counts_only;
	89	};
	90
	91	#define STRSET_REQINFO(__req_base) \
	92	container_of(__req_base, struct strset_req_info, base)
	93
	94	struct strset_reply_data {
	95	struct ethnl_reply_data base;
	96	struct strset_info sets[ETH_SS_COUNT];
	97	};
	98
	99	#define STRSET_REPDATA(__reply_base) \
	100	container_of(__reply_base, struct strset_reply_data, base)
	101
ff419afa	102	const struct nla_policy ethnl_strset_get_policy[] = {
329d9c33 JK	103	[ETHTOOL_A_STRSET_HEADER] =
329d9c33 JK	104	NLA_POLICY_NESTED(ethnl_header_policy),
71921690	105	[ETHTOOL_A_STRSET_STRINGSETS] = { .type = NLA_NESTED },
db972e53	106	[ETHTOOL_A_STRSET_COUNTS_ONLY] = { .type = NLA_FLAG },
71921690 MK	107	};
71921690 MK	108
ff419afa	109	static const struct nla_policy get_stringset_policy[] = {
71921690	110	[ETHTOOL_A_STRINGSET_ID] = { .type = NLA_U32 },
71921690 MK	111	};
	112
	113	/**
	114	* strset_include() - test if a string set should be included in reply
d2c4b444	115	* @info: parsed client request
71921690 MK	116	* @data: pointer to request data structure
	117	* @id: id of string set to check (ETH_SS_* constants)
	118	*/
	119	static bool strset_include(const struct strset_req_info *info,
	120	const struct strset_reply_data *data, u32 id)
	121	{
	122	bool per_dev;
	123
	124	BUILD_BUG_ON(ETH_SS_COUNT >= BITS_PER_BYTE * sizeof(info->req_ids));
	125
	126	if (info->req_ids)
	127	return info->req_ids & (1U << id);
	128	per_dev = data->sets[id].per_dev;
	129	if (!per_dev && !data->sets[id].strings)
	130	return false;
	131
	132	return data->base.dev ? per_dev : !per_dev;
	133	}
	134
	135	static int strset_get_id(const struct nlattr nest, u32 val,
	136	struct netlink_ext_ack *extack)
	137	{
ff419afa	138	struct nlattr *tb[ARRAY_SIZE(get_stringset_policy)];
71921690 MK	139	int ret;
71921690 MK	140
ff419afa	141	ret = nla_parse_nested(tb, ARRAY_SIZE(get_stringset_policy) - 1, nest,
71921690 MK	142	get_stringset_policy, extack);
	143	if (ret < 0)
	144	return ret;
	145	if (!tb[ETHTOOL_A_STRINGSET_ID])
	146	return -EINVAL;
	147
	148	*val = nla_get_u32(tb[ETHTOOL_A_STRINGSET_ID]);
	149	return 0;
	150	}
	151
ff419afa	152	static const struct nla_policy strset_stringsets_policy[] = {
71921690 MK	153	[ETHTOOL_A_STRINGSETS_STRINGSET] = { .type = NLA_NESTED },
	154	};
	155
	156	static int strset_parse_request(struct ethnl_req_info *req_base,
	157	struct nlattr **tb,
	158	struct netlink_ext_ack *extack)
	159	{
	160	struct strset_req_info *req_info = STRSET_REQINFO(req_base);
	161	struct nlattr *nest = tb[ETHTOOL_A_STRSET_STRINGSETS];
	162	struct nlattr *attr;
	163	int rem, ret;
	164
	165	if (!nest)
	166	return 0;
ff419afa JK	167	ret = nla_validate_nested(nest,
ff419afa JK	168	ARRAY_SIZE(strset_stringsets_policy) - 1,
71921690 MK	169	strset_stringsets_policy, extack);
	170	if (ret < 0)
	171	return ret;
	172
	173	req_info->counts_only = tb[ETHTOOL_A_STRSET_COUNTS_ONLY];
	174	nla_for_each_nested(attr, nest, rem) {
	175	u32 id;
	176
	177	if (WARN_ONCE(nla_type(attr) != ETHTOOL_A_STRINGSETS_STRINGSET,
	178	"unexpected attrtype %u in ETHTOOL_A_STRSET_STRINGSETS\n",
	179	nla_type(attr)))
	180	return -EINVAL;
	181
	182	ret = strset_get_id(attr, &id, extack);
	183	if (ret < 0)
	184	return ret;
efb796f5	185	if (id >= ETH_SS_COUNT) {
71921690 MK	186	NL_SET_ERR_MSG_ATTR(extack, attr,
	187	"unknown string set id");
	188	return -EOPNOTSUPP;
	189	}
	190
	191	req_info->req_ids \|= (1U << id);
	192	}
	193
	194	return 0;
	195	}
	196
	197	static void strset_cleanup_data(struct ethnl_reply_data *reply_base)
	198	{
	199	struct strset_reply_data *data = STRSET_REPDATA(reply_base);
	200	unsigned int i;
	201
	202	for (i = 0; i < ETH_SS_COUNT; i++)
	203	if (data->sets[i].free_strings) {
	204	kfree(data->sets[i].strings);
	205	data->sets[i].strings = NULL;
	206	data->sets[i].free_strings = false;
	207	}
	208	}
	209
	210	static int strset_prepare_set(struct strset_info info, struct net_device dev,
	211	unsigned int id, bool counts_only)
	212	{
17809516	213	const struct ethtool_phy_ops *phy_ops = ethtool_phy_ops;
71921690 MK	214	const struct ethtool_ops *ops = dev->ethtool_ops;
	215	void *strings;
	216	int count, ret;
	217
	218	if (id == ETH_SS_PHY_STATS && dev->phydev &&
17809516 FF	219	!ops->get_ethtool_phy_stats && phy_ops &&
	220	phy_ops->get_sset_count)
	221	ret = phy_ops->get_sset_count(dev->phydev);
71921690 MK	222	else if (ops->get_sset_count && ops->get_strings)
	223	ret = ops->get_sset_count(dev, id);
	224	else
	225	ret = -EOPNOTSUPP;
	226	if (ret <= 0) {
	227	info->count = 0;
	228	return 0;
	229	}
	230
	231	count = ret;
	232	if (!counts_only) {
	233	strings = kcalloc(count, ETH_GSTRING_LEN, GFP_KERNEL);
	234	if (!strings)
	235	return -ENOMEM;
	236	if (id == ETH_SS_PHY_STATS && dev->phydev &&
17809516 FF	237	!ops->get_ethtool_phy_stats && phy_ops &&
	238	phy_ops->get_strings)
	239	phy_ops->get_strings(dev->phydev, strings);
71921690 MK	240	else
	241	ops->get_strings(dev, id, strings);
	242	info->strings = strings;
	243	info->free_strings = true;
	244	}
	245	info->count = count;
	246
	247	return 0;
	248	}
	249
	250	static int strset_prepare_data(const struct ethnl_req_info *req_base,
	251	struct ethnl_reply_data *reply_base,
	252	struct genl_info *info)
	253	{
	254	const struct strset_req_info *req_info = STRSET_REQINFO(req_base);
	255	struct strset_reply_data *data = STRSET_REPDATA(reply_base);
	256	struct net_device *dev = reply_base->dev;
	257	unsigned int i;
	258	int ret;
	259
	260	BUILD_BUG_ON(ARRAY_SIZE(info_template) != ETH_SS_COUNT);
	261	memcpy(&data->sets, &info_template, sizeof(data->sets));
	262
	263	if (!dev) {
	264	for (i = 0; i < ETH_SS_COUNT; i++) {
	265	if ((req_info->req_ids & (1U << i)) &&
	266	data->sets[i].per_dev) {
	267	if (info)
	268	GENL_SET_ERR_MSG(info, "requested per device strings without dev");
	269	return -EINVAL;
	270	}
	271	}
ac9c41d5	272	return 0;
71921690 MK	273	}
	274
	275	ret = ethnl_ops_begin(dev);
	276	if (ret < 0)
	277	goto err_strset;
	278	for (i = 0; i < ETH_SS_COUNT; i++) {
	279	if (!strset_include(req_info, data, i) \|\|
	280	!data->sets[i].per_dev)
	281	continue;
	282
	283	ret = strset_prepare_set(&data->sets[i], dev, i,
	284	req_info->counts_only);
	285	if (ret < 0)
	286	goto err_ops;
	287	}
	288	ethnl_ops_complete(dev);
	289
	290	return 0;
	291	err_ops:
	292	ethnl_ops_complete(dev);
	293	err_strset:
	294	strset_cleanup_data(reply_base);
	295	return ret;
	296	}
	297
	298	/* calculate size of ETHTOOL_A_STRSET_STRINGSET nest for one string set */
	299	static int strset_set_size(const struct strset_info *info, bool counts_only)
	300	{
	301	unsigned int len = 0;
	302	unsigned int i;
	303
	304	if (info->count == 0)
	305	return 0;
	306	if (counts_only)
	307	return nla_total_size(2 * nla_total_size(sizeof(u32)));
	308
	309	for (i = 0; i < info->count; i++) {
	310	const char *str = info->strings[i];
	311
	312	/* ETHTOOL_A_STRING_INDEX, ETHTOOL_A_STRING_VALUE, nest */
	313	len += nla_total_size(nla_total_size(sizeof(u32)) +
	314	ethnl_strz_size(str));
	315	}
	316	/* ETHTOOL_A_STRINGSET_ID, ETHTOOL_A_STRINGSET_COUNT */
	317	len = 2 * nla_total_size(sizeof(u32)) + nla_total_size(len);
	318
	319	return nla_total_size(len);
	320	}
	321
	322	static int strset_reply_size(const struct ethnl_req_info *req_base,
	323	const struct ethnl_reply_data *reply_base)
	324	{
	325	const struct strset_req_info *req_info = STRSET_REQINFO(req_base);
	326	const struct strset_reply_data *data = STRSET_REPDATA(reply_base);
	327	unsigned int i;
	328	int len = 0;
	329	int ret;
	330
71921690 MK	331	for (i = 0; i < ETH_SS_COUNT; i++) {
	332	const struct strset_info *set_info = &data->sets[i];
	333
	334	if (!strset_include(req_info, data, i))
	335	continue;
	336
	337	ret = strset_set_size(set_info, req_info->counts_only);
	338	if (ret < 0)
	339	return ret;
	340	len += ret;
	341	}
	342
	343	return len;
	344	}
	345
	346	/* fill one string into reply */
	347	static int strset_fill_string(struct sk_buff *skb,
	348	const struct strset_info *set_info, u32 idx)
	349	{
	350	struct nlattr *string_attr;
	351	const char *value;
	352
	353	value = set_info->strings[idx];
	354
	355	string_attr = nla_nest_start(skb, ETHTOOL_A_STRINGS_STRING);
	356	if (!string_attr)
	357	return -EMSGSIZE;
	358	if (nla_put_u32(skb, ETHTOOL_A_STRING_INDEX, idx) \|\|
	359	ethnl_put_strz(skb, ETHTOOL_A_STRING_VALUE, value))
	360	goto nla_put_failure;
	361	nla_nest_end(skb, string_attr);
	362
	363	return 0;
	364	nla_put_failure:
	365	nla_nest_cancel(skb, string_attr);
	366	return -EMSGSIZE;
	367	}
	368
	369	/* fill one string set into reply */
	370	static int strset_fill_set(struct sk_buff *skb,
	371	const struct strset_info *set_info, u32 id,
	372	bool counts_only)
	373	{
	374	struct nlattr *stringset_attr;
	375	struct nlattr *strings_attr;
	376	unsigned int i;
	377
	378	if (!set_info->per_dev && !set_info->strings)
	379	return -EOPNOTSUPP;
	380	if (set_info->count == 0)
	381	return 0;
	382	stringset_attr = nla_nest_start(skb, ETHTOOL_A_STRINGSETS_STRINGSET);
	383	if (!stringset_attr)
	384	return -EMSGSIZE;
	385
	386	if (nla_put_u32(skb, ETHTOOL_A_STRINGSET_ID, id) \|\|
	387	nla_put_u32(skb, ETHTOOL_A_STRINGSET_COUNT, set_info->count))
	388	goto nla_put_failure;
	389
	390	if (!counts_only) {
	391	strings_attr = nla_nest_start(skb, ETHTOOL_A_STRINGSET_STRINGS);
	392	if (!strings_attr)
	393	goto nla_put_failure;
	394	for (i = 0; i < set_info->count; i++) {
395	if (strset_fill_string(skb, set_info, i) < 0)
396	goto nla_put_failure;
397	}
398	nla_nest_end(skb, strings_attr);
399	}
400
401	nla_nest_end(skb, stringset_attr);
402	return 0;
403
404	nla_put_failure:
405	nla_nest_cancel(skb, stringset_attr);
406	return -EMSGSIZE;
407	}
408
409	static int strset_fill_reply(struct sk_buff *skb,
410	const struct ethnl_req_info *req_base,
411	const struct ethnl_reply_data *reply_base)
412	{
413	const struct strset_req_info *req_info = STRSET_REQINFO(req_base);
414	const struct strset_reply_data *data = STRSET_REPDATA(reply_base);
415	struct nlattr *nest;
416	unsigned int i;
417	int ret;
418
419	nest = nla_nest_start(skb, ETHTOOL_A_STRSET_STRINGSETS);
420	if (!nest)
421	return -EMSGSIZE;
422
423	for (i = 0; i < ETH_SS_COUNT; i++) {
424	if (strset_include(req_info, data, i)) {
425	ret = strset_fill_set(skb, &data->sets[i], i,
426	req_info->counts_only);
427	if (ret < 0)
428	goto nla_put_failure;
429	}
430	}
431
432	nla_nest_end(skb, nest);
433	return 0;
434
435	nla_put_failure:
436	nla_nest_cancel(skb, nest);
437	return ret;
438	}
439
440	const struct ethnl_request_ops ethnl_strset_request_ops = {
441	.request_cmd = ETHTOOL_MSG_STRSET_GET,
442	.reply_cmd = ETHTOOL_MSG_STRSET_GET_REPLY,
443	.hdr_attr = ETHTOOL_A_STRSET_HEADER,
71921690 MK	444	.req_info_size = sizeof(struct strset_req_info),
71921690 MK	445	.reply_data_size = sizeof(struct strset_reply_data),
71921690 MK	446	.allow_nodev_do = true,
	447
	448	.parse_request = strset_parse_request,
	449	.prepare_data = strset_prepare_data,
	450	.reply_size = strset_reply_size,
	451	.fill_reply = strset_fill_reply,
	452	.cleanup_data = strset_cleanup_data,
	453	};