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

source code of linux/net/ethtool/strset.c