xref: /linux/net/ethtool/strset.c (revision 3ade6ce1255e6e97f91b8ba77408dce9d2292df2)
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 	},
53 	[ETH_SS_MSG_CLASSES] = {
54 		.per_dev	= false,
55 		.count		= NETIF_MSG_CLASS_COUNT,
56 		.strings	= netif_msg_class_names,
57 	},
58 	[ETH_SS_WOL_MODES] = {
59 		.per_dev	= false,
60 		.count		= WOL_MODE_COUNT,
61 		.strings	= wol_mode_names,
62 	},
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 	},
78 	[ETH_SS_UDP_TUNNEL_TYPES] = {
79 		.per_dev	= false,
80 		.count		= __ETHTOOL_UDP_TUNNEL_TYPE_CNT,
81 		.strings	= udp_tunnel_type_names,
82 	},
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 	},
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 	},
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 	},
103 	[ETH_SS_STATS_RMON] = {
104 		.per_dev	= false,
105 		.count		= __ETHTOOL_A_STATS_RMON_CNT,
106 		.strings	= stats_rmon_names,
107 	},
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 
127 const struct nla_policy ethnl_strset_get_policy[] = {
128 	[ETHTOOL_A_STRSET_HEADER]	=
129 		NLA_POLICY_NESTED(ethnl_header_policy),
130 	[ETHTOOL_A_STRSET_STRINGSETS]	= { .type = NLA_NESTED },
131 	[ETHTOOL_A_STRSET_COUNTS_ONLY]	= { .type = NLA_FLAG },
132 };
133 
134 static const struct nla_policy get_stringset_policy[] = {
135 	[ETHTOOL_A_STRINGSET_ID]	= { .type = NLA_U32 },
136 };
137 
138 /**
139  * strset_include() - test if a string set should be included in reply
140  * @info: parsed client request
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 {
163 	struct nlattr *tb[ARRAY_SIZE(get_stringset_policy)];
164 	int ret;
165 
166 	ret = nla_parse_nested(tb, ARRAY_SIZE(get_stringset_policy) - 1, nest,
167 			       get_stringset_policy, extack);
168 	if (ret < 0)
169 		return ret;
170 	if (NL_REQ_ATTR_CHECK(extack, nest, tb, ETHTOOL_A_STRINGSET_ID))
171 		return -EINVAL;
172 
173 	*val = nla_get_u32(tb[ETHTOOL_A_STRINGSET_ID]);
174 	return 0;
175 }
176 
177 static const struct nla_policy strset_stringsets_policy[] = {
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;
192 	ret = nla_validate_nested(nest,
193 				  ARRAY_SIZE(strset_stringsets_policy) - 1,
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;
210 		if (id >= ETH_SS_COUNT) {
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 {
238 	const struct ethtool_phy_ops *phy_ops = ethtool_phy_ops;
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 &&
244 	    !ops->get_ethtool_phy_stats && phy_ops &&
245 	    phy_ops->get_sset_count)
246 		ret = phy_ops->get_sset_count(dev->phydev);
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 &&
262 		    !ops->get_ethtool_phy_stats && phy_ops &&
263 		    phy_ops->get_strings)
264 			phy_ops->get_strings(dev->phydev, strings);
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 			       const 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 				GENL_SET_ERR_MSG(info, "requested per device strings without dev");
293 				return -EINVAL;
294 			}
295 		}
296 		return 0;
297 	}
298 
299 	ret = ethnl_ops_begin(dev);
300 	if (ret < 0)
301 		goto err_strset;
302 	for (i = 0; i < ETH_SS_COUNT; i++) {
303 		if (!strset_include(req_info, data, i) ||
304 		    !data->sets[i].per_dev)
305 			continue;
306 
307 		ret = strset_prepare_set(&data->sets[i], dev, i,
308 					 req_info->counts_only);
309 		if (ret < 0)
310 			goto err_ops;
311 	}
312 	ethnl_ops_complete(dev);
313 
314 	return 0;
315 err_ops:
316 	ethnl_ops_complete(dev);
317 err_strset:
318 	strset_cleanup_data(reply_base);
319 	return ret;
320 }
321 
322 /* calculate size of ETHTOOL_A_STRSET_STRINGSET nest for one string set */
323 static int strset_set_size(const struct strset_info *info, bool counts_only)
324 {
325 	unsigned int len = 0;
326 	unsigned int i;
327 
328 	if (info->count == 0)
329 		return 0;
330 	if (counts_only)
331 		return nla_total_size(2 * nla_total_size(sizeof(u32)));
332 
333 	for (i = 0; i < info->count; i++) {
334 		const char *str = info->strings[i];
335 
336 		/* ETHTOOL_A_STRING_INDEX, ETHTOOL_A_STRING_VALUE, nest */
337 		len += nla_total_size(nla_total_size(sizeof(u32)) +
338 				      ethnl_strz_size(str));
339 	}
340 	/* ETHTOOL_A_STRINGSET_ID, ETHTOOL_A_STRINGSET_COUNT */
341 	len = 2 * nla_total_size(sizeof(u32)) + nla_total_size(len);
342 
343 	return nla_total_size(len);
344 }
345 
346 static int strset_reply_size(const struct ethnl_req_info *req_base,
347 			     const struct ethnl_reply_data *reply_base)
348 {
349 	const struct strset_req_info *req_info = STRSET_REQINFO(req_base);
350 	const struct strset_reply_data *data = STRSET_REPDATA(reply_base);
351 	unsigned int i;
352 	int len = 0;
353 	int ret;
354 
355 	len += nla_total_size(0); /* ETHTOOL_A_STRSET_STRINGSETS */
356 
357 	for (i = 0; i < ETH_SS_COUNT; i++) {
358 		const struct strset_info *set_info = &data->sets[i];
359 
360 		if (!strset_include(req_info, data, i))
361 			continue;
362 
363 		ret = strset_set_size(set_info, req_info->counts_only);
364 		if (ret < 0)
365 			return ret;
366 		len += ret;
367 	}
368 
369 	return len;
370 }
371 
372 /* fill one string into reply */
373 static int strset_fill_string(struct sk_buff *skb,
374 			      const struct strset_info *set_info, u32 idx)
375 {
376 	struct nlattr *string_attr;
377 	const char *value;
378 
379 	value = set_info->strings[idx];
380 
381 	string_attr = nla_nest_start(skb, ETHTOOL_A_STRINGS_STRING);
382 	if (!string_attr)
383 		return -EMSGSIZE;
384 	if (nla_put_u32(skb, ETHTOOL_A_STRING_INDEX, idx) ||
385 	    ethnl_put_strz(skb, ETHTOOL_A_STRING_VALUE, value))
386 		goto nla_put_failure;
387 	nla_nest_end(skb, string_attr);
388 
389 	return 0;
390 nla_put_failure:
391 	nla_nest_cancel(skb, string_attr);
392 	return -EMSGSIZE;
393 }
394 
395 /* fill one string set into reply */
396 static int strset_fill_set(struct sk_buff *skb,
397 			   const struct strset_info *set_info, u32 id,
398 			   bool counts_only)
399 {
400 	struct nlattr *stringset_attr;
401 	struct nlattr *strings_attr;
402 	unsigned int i;
403 
404 	if (!set_info->per_dev && !set_info->strings)
405 		return -EOPNOTSUPP;
406 	if (set_info->count == 0)
407 		return 0;
408 	stringset_attr = nla_nest_start(skb, ETHTOOL_A_STRINGSETS_STRINGSET);
409 	if (!stringset_attr)
410 		return -EMSGSIZE;
411 
412 	if (nla_put_u32(skb, ETHTOOL_A_STRINGSET_ID, id) ||
413 	    nla_put_u32(skb, ETHTOOL_A_STRINGSET_COUNT, set_info->count))
414 		goto nla_put_failure;
415 
416 	if (!counts_only) {
417 		strings_attr = nla_nest_start(skb, ETHTOOL_A_STRINGSET_STRINGS);
418 		if (!strings_attr)
419 			goto nla_put_failure;
420 		for (i = 0; i < set_info->count; i++) {
421 			if (strset_fill_string(skb, set_info, i) < 0)
422 				goto nla_put_failure;
423 		}
424 		nla_nest_end(skb, strings_attr);
425 	}
426 
427 	nla_nest_end(skb, stringset_attr);
428 	return 0;
429 
430 nla_put_failure:
431 	nla_nest_cancel(skb, stringset_attr);
432 	return -EMSGSIZE;
433 }
434 
435 static int strset_fill_reply(struct sk_buff *skb,
436 			     const struct ethnl_req_info *req_base,
437 			     const struct ethnl_reply_data *reply_base)
438 {
439 	const struct strset_req_info *req_info = STRSET_REQINFO(req_base);
440 	const struct strset_reply_data *data = STRSET_REPDATA(reply_base);
441 	struct nlattr *nest;
442 	unsigned int i;
443 	int ret;
444 
445 	nest = nla_nest_start(skb, ETHTOOL_A_STRSET_STRINGSETS);
446 	if (!nest)
447 		return -EMSGSIZE;
448 
449 	for (i = 0; i < ETH_SS_COUNT; i++) {
450 		if (strset_include(req_info, data, i)) {
451 			ret = strset_fill_set(skb, &data->sets[i], i,
452 					      req_info->counts_only);
453 			if (ret < 0)
454 				goto nla_put_failure;
455 		}
456 	}
457 
458 	nla_nest_end(skb, nest);
459 	return 0;
460 
461 nla_put_failure:
462 	nla_nest_cancel(skb, nest);
463 	return ret;
464 }
465 
466 const struct ethnl_request_ops ethnl_strset_request_ops = {
467 	.request_cmd		= ETHTOOL_MSG_STRSET_GET,
468 	.reply_cmd		= ETHTOOL_MSG_STRSET_GET_REPLY,
469 	.hdr_attr		= ETHTOOL_A_STRSET_HEADER,
470 	.req_info_size		= sizeof(struct strset_req_info),
471 	.reply_data_size	= sizeof(struct strset_reply_data),
472 	.allow_nodev_do		= true,
473 
474 	.parse_request		= strset_parse_request,
475 	.prepare_data		= strset_prepare_data,
476 	.reply_size		= strset_reply_size,
477 	.fill_reply		= strset_fill_reply,
478 	.cleanup_data		= strset_cleanup_data,
479 };
480