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] = |
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 | }; |
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; |
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, |
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 */ |
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), |
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 | }; |