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, nla: nest, |
167 | policy: 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(nla: 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(start: nest, |
193 | ARRAY_SIZE(strset_stringsets_policy) - 1, |
194 | policy: 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(nest: attr, val: &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(objp: 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(n: 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 | 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(info: req_info, data, id: i) || |
305 | !data->sets[i].per_dev) |
306 | continue; |
307 | |
308 | ret = strset_prepare_set(info: &data->sets[i], dev, id: i, |
309 | counts_only: 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(payload: 2 * nla_total_size(payload: 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(payload: nla_total_size(payload: sizeof(u32)) + |
339 | ethnl_strz_size(s: str)); |
340 | } |
341 | /* ETHTOOL_A_STRINGSET_ID, ETHTOOL_A_STRINGSET_COUNT */ |
342 | len = 2 * nla_total_size(payload: sizeof(u32)) + nla_total_size(payload: len); |
343 | |
344 | return nla_total_size(payload: 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(payload: 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(info: req_info, data, id: i)) |
362 | continue; |
363 | |
364 | ret = strset_set_size(info: set_info, counts_only: 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, attrtype: ETHTOOL_A_STRINGS_STRING); |
383 | if (!string_attr) |
384 | return -EMSGSIZE; |
385 | if (nla_put_u32(skb, attrtype: ETHTOOL_A_STRING_INDEX, value: idx) || |
386 | ethnl_put_strz(skb, attrtype: ETHTOOL_A_STRING_VALUE, s: value)) |
387 | goto nla_put_failure; |
388 | nla_nest_end(skb, start: string_attr); |
389 | |
390 | return 0; |
391 | nla_put_failure: |
392 | nla_nest_cancel(skb, start: 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, attrtype: ETHTOOL_A_STRINGSETS_STRINGSET); |
410 | if (!stringset_attr) |
411 | return -EMSGSIZE; |
412 | |
413 | if (nla_put_u32(skb, attrtype: ETHTOOL_A_STRINGSET_ID, value: id) || |
414 | nla_put_u32(skb, attrtype: ETHTOOL_A_STRINGSET_COUNT, value: set_info->count)) |
415 | goto nla_put_failure; |
416 | |
417 | if (!counts_only) { |
418 | strings_attr = nla_nest_start(skb, attrtype: 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, idx: i) < 0) |
423 | goto nla_put_failure; |
424 | } |
425 | nla_nest_end(skb, start: strings_attr); |
426 | } |
427 | |
428 | nla_nest_end(skb, start: stringset_attr); |
429 | return 0; |
430 | |
431 | nla_put_failure: |
432 | nla_nest_cancel(skb, start: 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, attrtype: ETHTOOL_A_STRSET_STRINGSETS); |
447 | if (!nest) |
448 | return -EMSGSIZE; |
449 | |
450 | for (i = 0; i < ETH_SS_COUNT; i++) { |
451 | if (strset_include(info: req_info, data, id: i)) { |
452 | ret = strset_fill_set(skb, set_info: &data->sets[i], id: i, |
453 | counts_only: req_info->counts_only); |
454 | if (ret < 0) |
455 | goto nla_put_failure; |
456 | } |
457 | } |
458 | |
459 | nla_nest_end(skb, start: nest); |
460 | return 0; |
461 | |
462 | nla_put_failure: |
463 | nla_nest_cancel(skb, start: 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 | |