xref: /linux/net/ethtool/strset.c (revision 2da68a77) 
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 			       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 		}
297 		return 0;
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 
356 	len += nla_total_size(0); /* ETHTOOL_A_STRSET_STRINGSETS */
357 
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,
471 	.req_info_size		= sizeof(struct strset_req_info),
472 	.reply_data_size	= sizeof(struct strset_reply_data),
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 };
481