Commit | Line | Data |
---|---|---|
10b518d4 MK |
1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | ||
3 | #include <linux/ethtool_netlink.h> | |
4 | #include <linux/bitmap.h> | |
5 | #include "netlink.h" | |
6 | #include "bitset.h" | |
7 | ||
8 | /* Some bitmaps are internally represented as an array of unsigned long, some | |
9 | * as an array of u32 (some even as single u32 for now). To avoid the need of | |
10 | * wrappers on caller side, we provide two set of functions: those with "32" | |
11 | * suffix in their names expect u32 based bitmaps, those without it expect | |
12 | * unsigned long bitmaps. | |
13 | */ | |
14 | ||
15 | static u32 ethnl_lower_bits(unsigned int n) | |
16 | { | |
17 | return ~(u32)0 >> (32 - n % 32); | |
18 | } | |
19 | ||
20 | static u32 ethnl_upper_bits(unsigned int n) | |
21 | { | |
22 | return ~(u32)0 << (n % 32); | |
23 | } | |
24 | ||
25 | /** | |
26 | * ethnl_bitmap32_clear() - Clear u32 based bitmap | |
27 | * @dst: bitmap to clear | |
28 | * @start: beginning of the interval | |
29 | * @end: end of the interval | |
30 | * @mod: set if bitmap was modified | |
31 | * | |
32 | * Clear @nbits bits of a bitmap with indices @start <= i < @end | |
33 | */ | |
34 | static void ethnl_bitmap32_clear(u32 *dst, unsigned int start, unsigned int end, | |
35 | bool *mod) | |
36 | { | |
37 | unsigned int start_word = start / 32; | |
38 | unsigned int end_word = end / 32; | |
39 | unsigned int i; | |
40 | u32 mask; | |
41 | ||
42 | if (end <= start) | |
43 | return; | |
44 | ||
45 | if (start % 32) { | |
46 | mask = ethnl_upper_bits(start); | |
47 | if (end_word == start_word) { | |
48 | mask &= ethnl_lower_bits(end); | |
49 | if (dst[start_word] & mask) { | |
50 | dst[start_word] &= ~mask; | |
51 | *mod = true; | |
52 | } | |
53 | return; | |
54 | } | |
55 | if (dst[start_word] & mask) { | |
56 | dst[start_word] &= ~mask; | |
57 | *mod = true; | |
58 | } | |
59 | start_word++; | |
60 | } | |
61 | ||
62 | for (i = start_word; i < end_word; i++) { | |
63 | if (dst[i]) { | |
64 | dst[i] = 0; | |
65 | *mod = true; | |
66 | } | |
67 | } | |
68 | if (end % 32) { | |
69 | mask = ethnl_lower_bits(end); | |
70 | if (dst[end_word] & mask) { | |
71 | dst[end_word] &= ~mask; | |
72 | *mod = true; | |
73 | } | |
74 | } | |
75 | } | |
76 | ||
77 | /** | |
78 | * ethnl_bitmap32_not_zero() - Check if any bit is set in an interval | |
79 | * @map: bitmap to test | |
80 | * @start: beginning of the interval | |
81 | * @end: end of the interval | |
82 | * | |
83 | * Return: true if there is non-zero bit with index @start <= i < @end, | |
84 | * false if the whole interval is zero | |
85 | */ | |
86 | static bool ethnl_bitmap32_not_zero(const u32 *map, unsigned int start, | |
87 | unsigned int end) | |
88 | { | |
89 | unsigned int start_word = start / 32; | |
90 | unsigned int end_word = end / 32; | |
91 | u32 mask; | |
92 | ||
93 | if (end <= start) | |
94 | return true; | |
95 | ||
96 | if (start % 32) { | |
97 | mask = ethnl_upper_bits(start); | |
98 | if (end_word == start_word) { | |
99 | mask &= ethnl_lower_bits(end); | |
100 | return map[start_word] & mask; | |
101 | } | |
102 | if (map[start_word] & mask) | |
103 | return true; | |
104 | start_word++; | |
105 | } | |
106 | ||
107 | if (!memchr_inv(map + start_word, '\0', | |
108 | (end_word - start_word) * sizeof(u32))) | |
109 | return true; | |
110 | if (end % 32 == 0) | |
111 | return true; | |
112 | return map[end_word] & ethnl_lower_bits(end); | |
113 | } | |
114 | ||
115 | /** | |
116 | * ethnl_bitmap32_update() - Modify u32 based bitmap according to value/mask | |
117 | * pair | |
118 | * @dst: bitmap to update | |
119 | * @nbits: bit size of the bitmap | |
120 | * @value: values to set | |
121 | * @mask: mask of bits to set | |
122 | * @mod: set to true if bitmap is modified, preserve if not | |
123 | * | |
124 | * Set bits in @dst bitmap which are set in @mask to values from @value, leave | |
125 | * the rest untouched. If destination bitmap was modified, set @mod to true, | |
126 | * leave as it is if not. | |
127 | */ | |
128 | static void ethnl_bitmap32_update(u32 *dst, unsigned int nbits, | |
129 | const u32 *value, const u32 *mask, bool *mod) | |
130 | { | |
131 | while (nbits > 0) { | |
132 | u32 real_mask = mask ? *mask : ~(u32)0; | |
133 | u32 new_value; | |
134 | ||
135 | if (nbits < 32) | |
136 | real_mask &= ethnl_lower_bits(nbits); | |
137 | new_value = (*dst & ~real_mask) | (*value & real_mask); | |
138 | if (new_value != *dst) { | |
139 | *dst = new_value; | |
140 | *mod = true; | |
141 | } | |
142 | ||
143 | if (nbits <= 32) | |
144 | break; | |
145 | dst++; | |
146 | nbits -= 32; | |
147 | value++; | |
148 | if (mask) | |
149 | mask++; | |
150 | } | |
151 | } | |
152 | ||
153 | static bool ethnl_bitmap32_test_bit(const u32 *map, unsigned int index) | |
154 | { | |
155 | return map[index / 32] & (1U << (index % 32)); | |
156 | } | |
157 | ||
158 | /** | |
159 | * ethnl_bitset32_size() - Calculate size of bitset nested attribute | |
160 | * @val: value bitmap (u32 based) | |
161 | * @mask: mask bitmap (u32 based, optional) | |
162 | * @nbits: bit length of the bitset | |
163 | * @names: array of bit names (optional) | |
164 | * @compact: assume compact format for output | |
165 | * | |
166 | * Estimate length of netlink attribute composed by a later call to | |
167 | * ethnl_put_bitset32() call with the same arguments. | |
168 | * | |
169 | * Return: negative error code or attribute length estimate | |
170 | */ | |
171 | int ethnl_bitset32_size(const u32 *val, const u32 *mask, unsigned int nbits, | |
172 | ethnl_string_array_t names, bool compact) | |
173 | { | |
174 | unsigned int len = 0; | |
175 | ||
176 | /* list flag */ | |
177 | if (!mask) | |
178 | len += nla_total_size(sizeof(u32)); | |
179 | /* size */ | |
180 | len += nla_total_size(sizeof(u32)); | |
181 | ||
182 | if (compact) { | |
183 | unsigned int nwords = DIV_ROUND_UP(nbits, 32); | |
184 | ||
185 | /* value, mask */ | |
186 | len += (mask ? 2 : 1) * nla_total_size(nwords * sizeof(u32)); | |
187 | } else { | |
188 | unsigned int bits_len = 0; | |
189 | unsigned int bit_len, i; | |
190 | ||
191 | for (i = 0; i < nbits; i++) { | |
192 | const char *name = names ? names[i] : NULL; | |
193 | ||
194 | if (!ethnl_bitmap32_test_bit(mask ?: val, i)) | |
195 | continue; | |
196 | /* index */ | |
197 | bit_len = nla_total_size(sizeof(u32)); | |
198 | /* name */ | |
199 | if (name) | |
200 | bit_len += ethnl_strz_size(name); | |
201 | /* value */ | |
202 | if (mask && ethnl_bitmap32_test_bit(val, i)) | |
203 | bit_len += nla_total_size(0); | |
204 | ||
205 | /* bit nest */ | |
206 | bits_len += nla_total_size(bit_len); | |
207 | } | |
208 | /* bits nest */ | |
209 | len += nla_total_size(bits_len); | |
210 | } | |
211 | ||
212 | /* outermost nest */ | |
213 | return nla_total_size(len); | |
214 | } | |
215 | ||
216 | /** | |
217 | * ethnl_put_bitset32() - Put a bitset nest into a message | |
218 | * @skb: skb with the message | |
219 | * @attrtype: attribute type for the bitset nest | |
220 | * @val: value bitmap (u32 based) | |
221 | * @mask: mask bitmap (u32 based, optional) | |
222 | * @nbits: bit length of the bitset | |
223 | * @names: array of bit names (optional) | |
224 | * @compact: use compact format for the output | |
225 | * | |
226 | * Compose a nested attribute representing a bitset. If @mask is null, simple | |
227 | * bitmap (bit list) is created, if @mask is provided, represent a value/mask | |
228 | * pair. Bit names are only used in verbose mode and when provided by calller. | |
229 | * | |
230 | * Return: 0 on success, negative error value on error | |
231 | */ | |
232 | int ethnl_put_bitset32(struct sk_buff *skb, int attrtype, const u32 *val, | |
233 | const u32 *mask, unsigned int nbits, | |
234 | ethnl_string_array_t names, bool compact) | |
235 | { | |
236 | struct nlattr *nest; | |
237 | struct nlattr *attr; | |
238 | ||
239 | nest = nla_nest_start(skb, attrtype); | |
240 | if (!nest) | |
241 | return -EMSGSIZE; | |
242 | ||
243 | if (!mask && nla_put_flag(skb, ETHTOOL_A_BITSET_NOMASK)) | |
244 | goto nla_put_failure; | |
245 | if (nla_put_u32(skb, ETHTOOL_A_BITSET_SIZE, nbits)) | |
246 | goto nla_put_failure; | |
247 | if (compact) { | |
248 | unsigned int nwords = DIV_ROUND_UP(nbits, 32); | |
249 | unsigned int nbytes = nwords * sizeof(u32); | |
250 | u32 *dst; | |
251 | ||
252 | attr = nla_reserve(skb, ETHTOOL_A_BITSET_VALUE, nbytes); | |
253 | if (!attr) | |
254 | goto nla_put_failure; | |
255 | dst = nla_data(attr); | |
256 | memcpy(dst, val, nbytes); | |
257 | if (nbits % 32) | |
258 | dst[nwords - 1] &= ethnl_lower_bits(nbits); | |
259 | ||
260 | if (mask) { | |
261 | attr = nla_reserve(skb, ETHTOOL_A_BITSET_MASK, nbytes); | |
262 | if (!attr) | |
263 | goto nla_put_failure; | |
264 | dst = nla_data(attr); | |
265 | memcpy(dst, mask, nbytes); | |
266 | if (nbits % 32) | |
267 | dst[nwords - 1] &= ethnl_lower_bits(nbits); | |
268 | } | |
269 | } else { | |
270 | struct nlattr *bits; | |
271 | unsigned int i; | |
272 | ||
273 | bits = nla_nest_start(skb, ETHTOOL_A_BITSET_BITS); | |
274 | if (!bits) | |
275 | goto nla_put_failure; | |
276 | for (i = 0; i < nbits; i++) { | |
277 | const char *name = names ? names[i] : NULL; | |
278 | ||
279 | if (!ethnl_bitmap32_test_bit(mask ?: val, i)) | |
280 | continue; | |
281 | attr = nla_nest_start(skb, ETHTOOL_A_BITSET_BITS_BIT); | |
282 | if (!attr) | |
283 | goto nla_put_failure; | |
284 | if (nla_put_u32(skb, ETHTOOL_A_BITSET_BIT_INDEX, i)) | |
285 | goto nla_put_failure; | |
286 | if (name && | |
287 | ethnl_put_strz(skb, ETHTOOL_A_BITSET_BIT_NAME, name)) | |
288 | goto nla_put_failure; | |
289 | if (mask && ethnl_bitmap32_test_bit(val, i) && | |
290 | nla_put_flag(skb, ETHTOOL_A_BITSET_BIT_VALUE)) | |
291 | goto nla_put_failure; | |
292 | nla_nest_end(skb, attr); | |
293 | } | |
294 | nla_nest_end(skb, bits); | |
295 | } | |
296 | ||
297 | nla_nest_end(skb, nest); | |
298 | return 0; | |
299 | ||
300 | nla_put_failure: | |
301 | nla_nest_cancel(skb, nest); | |
302 | return -EMSGSIZE; | |
303 | } | |
304 | ||
305 | static const struct nla_policy bitset_policy[ETHTOOL_A_BITSET_MAX + 1] = { | |
306 | [ETHTOOL_A_BITSET_UNSPEC] = { .type = NLA_REJECT }, | |
307 | [ETHTOOL_A_BITSET_NOMASK] = { .type = NLA_FLAG }, | |
e34f1753 MK |
308 | [ETHTOOL_A_BITSET_SIZE] = NLA_POLICY_MAX(NLA_U32, |
309 | ETHNL_MAX_BITSET_SIZE), | |
10b518d4 MK |
310 | [ETHTOOL_A_BITSET_BITS] = { .type = NLA_NESTED }, |
311 | [ETHTOOL_A_BITSET_VALUE] = { .type = NLA_BINARY }, | |
312 | [ETHTOOL_A_BITSET_MASK] = { .type = NLA_BINARY }, | |
313 | }; | |
314 | ||
315 | static const struct nla_policy bit_policy[ETHTOOL_A_BITSET_BIT_MAX + 1] = { | |
316 | [ETHTOOL_A_BITSET_BIT_UNSPEC] = { .type = NLA_REJECT }, | |
317 | [ETHTOOL_A_BITSET_BIT_INDEX] = { .type = NLA_U32 }, | |
318 | [ETHTOOL_A_BITSET_BIT_NAME] = { .type = NLA_NUL_STRING }, | |
319 | [ETHTOOL_A_BITSET_BIT_VALUE] = { .type = NLA_FLAG }, | |
320 | }; | |
321 | ||
322 | /** | |
323 | * ethnl_bitset_is_compact() - check if bitset attribute represents a compact | |
324 | * bitset | |
325 | * @bitset: nested attribute representing a bitset | |
326 | * @compact: pointer for return value | |
327 | * | |
328 | * Return: 0 on success, negative error code on failure | |
329 | */ | |
330 | int ethnl_bitset_is_compact(const struct nlattr *bitset, bool *compact) | |
331 | { | |
332 | struct nlattr *tb[ETHTOOL_A_BITSET_MAX + 1]; | |
333 | int ret; | |
334 | ||
335 | ret = nla_parse_nested(tb, ETHTOOL_A_BITSET_MAX, bitset, | |
336 | bitset_policy, NULL); | |
337 | if (ret < 0) | |
338 | return ret; | |
339 | ||
340 | if (tb[ETHTOOL_A_BITSET_BITS]) { | |
341 | if (tb[ETHTOOL_A_BITSET_VALUE] || tb[ETHTOOL_A_BITSET_MASK]) | |
342 | return -EINVAL; | |
343 | *compact = false; | |
344 | return 0; | |
345 | } | |
346 | if (!tb[ETHTOOL_A_BITSET_SIZE] || !tb[ETHTOOL_A_BITSET_VALUE]) | |
347 | return -EINVAL; | |
348 | ||
349 | *compact = true; | |
350 | return 0; | |
351 | } | |
352 | ||
353 | /** | |
354 | * ethnl_name_to_idx() - look up string index for a name | |
355 | * @names: array of ETH_GSTRING_LEN sized strings | |
356 | * @n_names: number of strings in the array | |
357 | * @name: name to look up | |
358 | * | |
359 | * Return: index of the string if found, -ENOENT if not found | |
360 | */ | |
361 | static int ethnl_name_to_idx(ethnl_string_array_t names, unsigned int n_names, | |
362 | const char *name) | |
363 | { | |
364 | unsigned int i; | |
365 | ||
366 | if (!names) | |
367 | return -ENOENT; | |
368 | ||
369 | for (i = 0; i < n_names; i++) { | |
370 | /* names[i] may not be null terminated */ | |
371 | if (!strncmp(names[i], name, ETH_GSTRING_LEN) && | |
372 | strlen(name) <= ETH_GSTRING_LEN) | |
373 | return i; | |
374 | } | |
375 | ||
376 | return -ENOENT; | |
377 | } | |
378 | ||
379 | static int ethnl_parse_bit(unsigned int *index, bool *val, unsigned int nbits, | |
380 | const struct nlattr *bit_attr, bool no_mask, | |
381 | ethnl_string_array_t names, | |
382 | struct netlink_ext_ack *extack) | |
383 | { | |
384 | struct nlattr *tb[ETHTOOL_A_BITSET_BIT_MAX + 1]; | |
385 | int ret, idx; | |
386 | ||
387 | ret = nla_parse_nested(tb, ETHTOOL_A_BITSET_BIT_MAX, bit_attr, | |
388 | bit_policy, extack); | |
389 | if (ret < 0) | |
390 | return ret; | |
391 | ||
392 | if (tb[ETHTOOL_A_BITSET_BIT_INDEX]) { | |
393 | const char *name; | |
394 | ||
395 | idx = nla_get_u32(tb[ETHTOOL_A_BITSET_BIT_INDEX]); | |
396 | if (idx >= nbits) { | |
397 | NL_SET_ERR_MSG_ATTR(extack, | |
398 | tb[ETHTOOL_A_BITSET_BIT_INDEX], | |
399 | "bit index too high"); | |
400 | return -EOPNOTSUPP; | |
401 | } | |
402 | name = names ? names[idx] : NULL; | |
403 | if (tb[ETHTOOL_A_BITSET_BIT_NAME] && name && | |
404 | strncmp(nla_data(tb[ETHTOOL_A_BITSET_BIT_NAME]), name, | |
405 | nla_len(tb[ETHTOOL_A_BITSET_BIT_NAME]))) { | |
406 | NL_SET_ERR_MSG_ATTR(extack, bit_attr, | |
407 | "bit index and name mismatch"); | |
408 | return -EINVAL; | |
409 | } | |
410 | } else if (tb[ETHTOOL_A_BITSET_BIT_NAME]) { | |
411 | idx = ethnl_name_to_idx(names, nbits, | |
412 | nla_data(tb[ETHTOOL_A_BITSET_BIT_NAME])); | |
413 | if (idx < 0) { | |
414 | NL_SET_ERR_MSG_ATTR(extack, | |
415 | tb[ETHTOOL_A_BITSET_BIT_NAME], | |
416 | "bit name not found"); | |
417 | return -EOPNOTSUPP; | |
418 | } | |
419 | } else { | |
420 | NL_SET_ERR_MSG_ATTR(extack, bit_attr, | |
421 | "neither bit index nor name specified"); | |
422 | return -EINVAL; | |
423 | } | |
424 | ||
425 | *index = idx; | |
426 | *val = no_mask || tb[ETHTOOL_A_BITSET_BIT_VALUE]; | |
427 | return 0; | |
428 | } | |
429 | ||
430 | static int | |
431 | ethnl_update_bitset32_verbose(u32 *bitmap, unsigned int nbits, | |
432 | const struct nlattr *attr, struct nlattr **tb, | |
433 | ethnl_string_array_t names, | |
434 | struct netlink_ext_ack *extack, bool *mod) | |
435 | { | |
436 | struct nlattr *bit_attr; | |
437 | bool no_mask; | |
438 | int rem; | |
439 | int ret; | |
440 | ||
441 | if (tb[ETHTOOL_A_BITSET_VALUE]) { | |
442 | NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_BITSET_VALUE], | |
443 | "value only allowed in compact bitset"); | |
444 | return -EINVAL; | |
445 | } | |
446 | if (tb[ETHTOOL_A_BITSET_MASK]) { | |
447 | NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_BITSET_MASK], | |
448 | "mask only allowed in compact bitset"); | |
449 | return -EINVAL; | |
450 | } | |
66991703 | 451 | |
10b518d4 | 452 | no_mask = tb[ETHTOOL_A_BITSET_NOMASK]; |
66991703 MK |
453 | if (no_mask) |
454 | ethnl_bitmap32_clear(bitmap, 0, nbits, mod); | |
10b518d4 MK |
455 | |
456 | nla_for_each_nested(bit_attr, tb[ETHTOOL_A_BITSET_BITS], rem) { | |
457 | bool old_val, new_val; | |
458 | unsigned int idx; | |
459 | ||
460 | if (nla_type(bit_attr) != ETHTOOL_A_BITSET_BITS_BIT) { | |
461 | NL_SET_ERR_MSG_ATTR(extack, bit_attr, | |
462 | "only ETHTOOL_A_BITSET_BITS_BIT allowed in ETHTOOL_A_BITSET_BITS"); | |
463 | return -EINVAL; | |
464 | } | |
465 | ret = ethnl_parse_bit(&idx, &new_val, nbits, bit_attr, no_mask, | |
466 | names, extack); | |
467 | if (ret < 0) | |
468 | return ret; | |
469 | old_val = bitmap[idx / 32] & ((u32)1 << (idx % 32)); | |
470 | if (new_val != old_val) { | |
471 | if (new_val) | |
472 | bitmap[idx / 32] |= ((u32)1 << (idx % 32)); | |
473 | else | |
474 | bitmap[idx / 32] &= ~((u32)1 << (idx % 32)); | |
475 | *mod = true; | |
476 | } | |
477 | } | |
478 | ||
479 | return 0; | |
480 | } | |
481 | ||
482 | static int ethnl_compact_sanity_checks(unsigned int nbits, | |
483 | const struct nlattr *nest, | |
484 | struct nlattr **tb, | |
485 | struct netlink_ext_ack *extack) | |
486 | { | |
487 | bool no_mask = tb[ETHTOOL_A_BITSET_NOMASK]; | |
488 | unsigned int attr_nbits, attr_nwords; | |
489 | const struct nlattr *test_attr; | |
490 | ||
491 | if (no_mask && tb[ETHTOOL_A_BITSET_MASK]) { | |
492 | NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_BITSET_MASK], | |
493 | "mask not allowed in list bitset"); | |
494 | return -EINVAL; | |
495 | } | |
496 | if (!tb[ETHTOOL_A_BITSET_SIZE]) { | |
497 | NL_SET_ERR_MSG_ATTR(extack, nest, | |
498 | "missing size in compact bitset"); | |
499 | return -EINVAL; | |
500 | } | |
501 | if (!tb[ETHTOOL_A_BITSET_VALUE]) { | |
502 | NL_SET_ERR_MSG_ATTR(extack, nest, | |
503 | "missing value in compact bitset"); | |
504 | return -EINVAL; | |
505 | } | |
506 | if (!no_mask && !tb[ETHTOOL_A_BITSET_MASK]) { | |
507 | NL_SET_ERR_MSG_ATTR(extack, nest, | |
508 | "missing mask in compact nonlist bitset"); | |
509 | return -EINVAL; | |
510 | } | |
511 | ||
512 | attr_nbits = nla_get_u32(tb[ETHTOOL_A_BITSET_SIZE]); | |
513 | attr_nwords = DIV_ROUND_UP(attr_nbits, 32); | |
514 | if (nla_len(tb[ETHTOOL_A_BITSET_VALUE]) != attr_nwords * sizeof(u32)) { | |
515 | NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_BITSET_VALUE], | |
516 | "bitset value length does not match size"); | |
517 | return -EINVAL; | |
518 | } | |
519 | if (tb[ETHTOOL_A_BITSET_MASK] && | |
520 | nla_len(tb[ETHTOOL_A_BITSET_MASK]) != attr_nwords * sizeof(u32)) { | |
521 | NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_BITSET_MASK], | |
522 | "bitset mask length does not match size"); | |
523 | return -EINVAL; | |
524 | } | |
525 | if (attr_nbits <= nbits) | |
526 | return 0; | |
527 | ||
528 | test_attr = no_mask ? tb[ETHTOOL_A_BITSET_VALUE] : | |
529 | tb[ETHTOOL_A_BITSET_MASK]; | |
530 | if (ethnl_bitmap32_not_zero(nla_data(test_attr), nbits, attr_nbits)) { | |
531 | NL_SET_ERR_MSG_ATTR(extack, test_attr, | |
532 | "cannot modify bits past kernel bitset size"); | |
533 | return -EINVAL; | |
534 | } | |
535 | return 0; | |
536 | } | |
537 | ||
538 | /** | |
539 | * ethnl_update_bitset32() - Apply a bitset nest to a u32 based bitmap | |
540 | * @bitmap: bitmap to update | |
541 | * @nbits: size of the updated bitmap in bits | |
542 | * @attr: nest attribute to parse and apply | |
543 | * @names: array of bit names; may be null for compact format | |
544 | * @extack: extack for error reporting | |
545 | * @mod: set this to true if bitmap is modified, leave as it is if not | |
546 | * | |
547 | * Apply bitset netsted attribute to a bitmap. If the attribute represents | |
548 | * a bit list, @bitmap is set to its contents; otherwise, bits in mask are | |
549 | * set to values from value. Bitmaps in the attribute may be longer than | |
550 | * @nbits but the message must not request modifying any bits past @nbits. | |
551 | * | |
552 | * Return: negative error code on failure, 0 on success | |
553 | */ | |
554 | int ethnl_update_bitset32(u32 *bitmap, unsigned int nbits, | |
555 | const struct nlattr *attr, ethnl_string_array_t names, | |
556 | struct netlink_ext_ack *extack, bool *mod) | |
557 | { | |
558 | struct nlattr *tb[ETHTOOL_A_BITSET_MAX + 1]; | |
559 | unsigned int change_bits; | |
560 | bool no_mask; | |
561 | int ret; | |
562 | ||
563 | if (!attr) | |
564 | return 0; | |
565 | ret = nla_parse_nested(tb, ETHTOOL_A_BITSET_MAX, attr, bitset_policy, | |
566 | extack); | |
567 | if (ret < 0) | |
568 | return ret; | |
569 | ||
570 | if (tb[ETHTOOL_A_BITSET_BITS]) | |
571 | return ethnl_update_bitset32_verbose(bitmap, nbits, attr, tb, | |
572 | names, extack, mod); | |
573 | ret = ethnl_compact_sanity_checks(nbits, attr, tb, extack); | |
574 | if (ret < 0) | |
575 | return ret; | |
576 | ||
577 | no_mask = tb[ETHTOOL_A_BITSET_NOMASK]; | |
578 | change_bits = min_t(unsigned int, | |
579 | nla_get_u32(tb[ETHTOOL_A_BITSET_SIZE]), nbits); | |
580 | ethnl_bitmap32_update(bitmap, change_bits, | |
581 | nla_data(tb[ETHTOOL_A_BITSET_VALUE]), | |
582 | no_mask ? NULL : | |
583 | nla_data(tb[ETHTOOL_A_BITSET_MASK]), | |
584 | mod); | |
585 | if (no_mask && change_bits < nbits) | |
586 | ethnl_bitmap32_clear(bitmap, change_bits, nbits, mod); | |
587 | ||
588 | return 0; | |
589 | } | |
590 | ||
591 | #if BITS_PER_LONG == 64 && defined(__BIG_ENDIAN) | |
592 | ||
593 | /* 64-bit big endian architectures are the only case when u32 based bitmaps | |
594 | * and unsigned long based bitmaps have different memory layout so that we | |
595 | * cannot simply cast the latter to the former and need actual wrappers | |
596 | * converting the latter to the former. | |
597 | * | |
598 | * To reduce the number of slab allocations, the wrappers use fixed size local | |
599 | * variables for bitmaps up to ETHNL_SMALL_BITMAP_BITS bits which is the | |
600 | * majority of bitmaps used by ethtool. | |
601 | */ | |
602 | #define ETHNL_SMALL_BITMAP_BITS 128 | |
603 | #define ETHNL_SMALL_BITMAP_WORDS DIV_ROUND_UP(ETHNL_SMALL_BITMAP_BITS, 32) | |
604 | ||
605 | int ethnl_bitset_size(const unsigned long *val, const unsigned long *mask, | |
606 | unsigned int nbits, ethnl_string_array_t names, | |
607 | bool compact) | |
608 | { | |
609 | u32 small_mask32[ETHNL_SMALL_BITMAP_WORDS]; | |
610 | u32 small_val32[ETHNL_SMALL_BITMAP_WORDS]; | |
611 | u32 *mask32; | |
612 | u32 *val32; | |
613 | int ret; | |
614 | ||
615 | if (nbits > ETHNL_SMALL_BITMAP_BITS) { | |
616 | unsigned int nwords = DIV_ROUND_UP(nbits, 32); | |
617 | ||
618 | val32 = kmalloc_array(2 * nwords, sizeof(u32), GFP_KERNEL); | |
619 | if (!val32) | |
620 | return -ENOMEM; | |
621 | mask32 = val32 + nwords; | |
622 | } else { | |
623 | val32 = small_val32; | |
624 | mask32 = small_mask32; | |
625 | } | |
626 | ||
627 | bitmap_to_arr32(val32, val, nbits); | |
628 | if (mask) | |
629 | bitmap_to_arr32(mask32, mask, nbits); | |
630 | else | |
631 | mask32 = NULL; | |
632 | ret = ethnl_bitset32_size(val32, mask32, nbits, names, compact); | |
633 | ||
634 | if (nbits > ETHNL_SMALL_BITMAP_BITS) | |
635 | kfree(val32); | |
636 | ||
637 | return ret; | |
638 | } | |
639 | ||
640 | int ethnl_put_bitset(struct sk_buff *skb, int attrtype, | |
641 | const unsigned long *val, const unsigned long *mask, | |
642 | unsigned int nbits, ethnl_string_array_t names, | |
643 | bool compact) | |
644 | { | |
645 | u32 small_mask32[ETHNL_SMALL_BITMAP_WORDS]; | |
646 | u32 small_val32[ETHNL_SMALL_BITMAP_WORDS]; | |
647 | u32 *mask32; | |
648 | u32 *val32; | |
649 | int ret; | |
650 | ||
651 | if (nbits > ETHNL_SMALL_BITMAP_BITS) { | |
652 | unsigned int nwords = DIV_ROUND_UP(nbits, 32); | |
653 | ||
654 | val32 = kmalloc_array(2 * nwords, sizeof(u32), GFP_KERNEL); | |
655 | if (!val32) | |
656 | return -ENOMEM; | |
657 | mask32 = val32 + nwords; | |
658 | } else { | |
659 | val32 = small_val32; | |
660 | mask32 = small_mask32; | |
661 | } | |
662 | ||
663 | bitmap_to_arr32(val32, val, nbits); | |
664 | if (mask) | |
665 | bitmap_to_arr32(mask32, mask, nbits); | |
666 | else | |
667 | mask32 = NULL; | |
668 | ret = ethnl_put_bitset32(skb, attrtype, val32, mask32, nbits, names, | |
669 | compact); | |
670 | ||
671 | if (nbits > ETHNL_SMALL_BITMAP_BITS) | |
672 | kfree(val32); | |
673 | ||
674 | return ret; | |
675 | } | |
676 | ||
677 | int ethnl_update_bitset(unsigned long *bitmap, unsigned int nbits, | |
678 | const struct nlattr *attr, ethnl_string_array_t names, | |
679 | struct netlink_ext_ack *extack, bool *mod) | |
680 | { | |
681 | u32 small_bitmap32[ETHNL_SMALL_BITMAP_WORDS]; | |
682 | u32 *bitmap32 = small_bitmap32; | |
683 | bool u32_mod = false; | |
684 | int ret; | |
685 | ||
686 | if (nbits > ETHNL_SMALL_BITMAP_BITS) { | |
687 | unsigned int dst_words = DIV_ROUND_UP(nbits, 32); | |
688 | ||
689 | bitmap32 = kmalloc_array(dst_words, sizeof(u32), GFP_KERNEL); | |
690 | if (!bitmap32) | |
691 | return -ENOMEM; | |
692 | } | |
693 | ||
694 | bitmap_to_arr32(bitmap32, bitmap, nbits); | |
695 | ret = ethnl_update_bitset32(bitmap32, nbits, attr, names, extack, | |
696 | &u32_mod); | |
697 | if (u32_mod) { | |
698 | bitmap_from_arr32(bitmap, bitmap32, nbits); | |
699 | *mod = true; | |
700 | } | |
701 | ||
702 | if (nbits > ETHNL_SMALL_BITMAP_BITS) | |
703 | kfree(bitmap32); | |
704 | ||
705 | return ret; | |
706 | } | |
707 | ||
708 | #else | |
709 | ||
710 | /* On little endian 64-bit and all 32-bit architectures, an unsigned long | |
711 | * based bitmap can be interpreted as u32 based one using a simple cast. | |
712 | */ | |
713 | ||
714 | int ethnl_bitset_size(const unsigned long *val, const unsigned long *mask, | |
715 | unsigned int nbits, ethnl_string_array_t names, | |
716 | bool compact) | |
717 | { | |
718 | return ethnl_bitset32_size((const u32 *)val, (const u32 *)mask, nbits, | |
719 | names, compact); | |
720 | } | |
721 | ||
722 | int ethnl_put_bitset(struct sk_buff *skb, int attrtype, | |
723 | const unsigned long *val, const unsigned long *mask, | |
724 | unsigned int nbits, ethnl_string_array_t names, | |
725 | bool compact) | |
726 | { | |
727 | return ethnl_put_bitset32(skb, attrtype, (const u32 *)val, | |
728 | (const u32 *)mask, nbits, names, compact); | |
729 | } | |
730 | ||
731 | int ethnl_update_bitset(unsigned long *bitmap, unsigned int nbits, | |
732 | const struct nlattr *attr, ethnl_string_array_t names, | |
733 | struct netlink_ext_ack *extack, bool *mod) | |
734 | { | |
735 | return ethnl_update_bitset32((u32 *)bitmap, nbits, attr, names, extack, | |
736 | mod); | |
737 | } | |
738 | ||
739 | #endif /* BITS_PER_LONG == 64 && defined(__BIG_ENDIAN) */ |