net/ethtool/bitset.c

   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[] = {
 306         [ETHTOOL_A_BITSET_NOMASK]       = { .type = NLA_FLAG },
 307         [ETHTOOL_A_BITSET_SIZE]         = NLA_POLICY_MAX(NLA_U32,
 308                                                          ETHNL_MAX_BITSET_SIZE),
 309         [ETHTOOL_A_BITSET_BITS]         = { .type = NLA_NESTED },
 310         [ETHTOOL_A_BITSET_VALUE]        = { .type = NLA_BINARY },
 311         [ETHTOOL_A_BITSET_MASK]         = { .type = NLA_BINARY },
 312 };
 313
 314 static const struct nla_policy bit_policy[] = {
 315         [ETHTOOL_A_BITSET_BIT_INDEX]    = { .type = NLA_U32 },
 316         [ETHTOOL_A_BITSET_BIT_NAME]     = { .type = NLA_NUL_STRING },
 317         [ETHTOOL_A_BITSET_BIT_VALUE]    = { .type = NLA_FLAG },
 318 };
 319
 320 /**
 321  * ethnl_bitset_is_compact() - check if bitset attribute represents a compact
 322  *                             bitset
 323  * @bitset:  nested attribute representing a bitset
 324  * @compact: pointer for return value
 325  *
 326  * Return: 0 on success, negative error code on failure
 327  */
 328 int ethnl_bitset_is_compact(const struct nlattr *bitset, bool *compact)
 329 {
 330         struct nlattr *tb[ARRAY_SIZE(bitset_policy)];
 331         int ret;
 332
 333         ret = nla_parse_nested(tb, ARRAY_SIZE(bitset_policy) - 1, bitset,
 334                                bitset_policy, NULL);
 335         if (ret < 0)
 336                 return ret;
 337
 338         if (tb[ETHTOOL_A_BITSET_BITS]) {
 339                 if (tb[ETHTOOL_A_BITSET_VALUE] || tb[ETHTOOL_A_BITSET_MASK])
 340                         return -EINVAL;
 341                 *compact = false;
 342                 return 0;
 343         }
 344         if (!tb[ETHTOOL_A_BITSET_SIZE] || !tb[ETHTOOL_A_BITSET_VALUE])
 345                 return -EINVAL;
 346
 347         *compact = true;
 348         return 0;
 349 }
 350
 351 /**
 352  * ethnl_name_to_idx() - look up string index for a name
 353  * @names:   array of ETH_GSTRING_LEN sized strings
 354  * @n_names: number of strings in the array
 355  * @name:    name to look up
 356  *
 357  * Return: index of the string if found, -ENOENT if not found
 358  */
 359 static int ethnl_name_to_idx(ethnl_string_array_t names, unsigned int n_names,
 360                              const char *name)
 361 {
 362         unsigned int i;
 363
 364         if (!names)
 365                 return -ENOENT;
 366
 367         for (i = 0; i < n_names; i++) {
 368                 /* names[i] may not be null terminated */
 369                 if (!strncmp(names[i], name, ETH_GSTRING_LEN) &&
 370                     strlen(name) <= ETH_GSTRING_LEN)
 371                         return i;
 372         }
 373
 374         return -ENOENT;
 375 }
 376
 377 static int ethnl_parse_bit(unsigned int *index, bool *val, unsigned int nbits,
 378                            const struct nlattr *bit_attr, bool no_mask,
 379                            ethnl_string_array_t names,
 380                            struct netlink_ext_ack *extack)
 381 {
 382         struct nlattr *tb[ARRAY_SIZE(bit_policy)];
 383         int ret, idx;
 384
 385         ret = nla_parse_nested(tb, ARRAY_SIZE(bit_policy) - 1, bit_attr,
 386                                bit_policy, extack);
 387         if (ret < 0)
 388                 return ret;
 389
 390         if (tb[ETHTOOL_A_BITSET_BIT_INDEX]) {
 391                 const char *name;
 392
 393                 idx = nla_get_u32(tb[ETHTOOL_A_BITSET_BIT_INDEX]);
 394                 if (idx >= nbits) {
 395                         NL_SET_ERR_MSG_ATTR(extack,
 396                                             tb[ETHTOOL_A_BITSET_BIT_INDEX],
 397                                             "bit index too high");
 398                         return -EOPNOTSUPP;
 399                 }
 400                 name = names ? names[idx] : NULL;
 401                 if (tb[ETHTOOL_A_BITSET_BIT_NAME] && name &&
 402                     strncmp(nla_data(tb[ETHTOOL_A_BITSET_BIT_NAME]), name,
 403                             nla_len(tb[ETHTOOL_A_BITSET_BIT_NAME]))) {
 404                         NL_SET_ERR_MSG_ATTR(extack, bit_attr,
 405                                             "bit index and name mismatch");
 406                         return -EINVAL;
 407                 }
 408         } else if (tb[ETHTOOL_A_BITSET_BIT_NAME]) {
 409                 idx = ethnl_name_to_idx(names, nbits,
 410                                         nla_data(tb[ETHTOOL_A_BITSET_BIT_NAME]));
 411                 if (idx < 0) {
 412                         NL_SET_ERR_MSG_ATTR(extack,
 413                                             tb[ETHTOOL_A_BITSET_BIT_NAME],
 414                                             "bit name not found");
 415                         return -EOPNOTSUPP;
 416                 }
 417         } else {
 418                 NL_SET_ERR_MSG_ATTR(extack, bit_attr,
 419                                     "neither bit index nor name specified");
 420                 return -EINVAL;
 421         }
 422
 423         *index = idx;
 424         *val = no_mask || tb[ETHTOOL_A_BITSET_BIT_VALUE];
 425         return 0;
 426 }
 427
 428 static int
 429 ethnl_update_bitset32_verbose(u32 *bitmap, unsigned int nbits,
 430                               const struct nlattr *attr, struct nlattr **tb,
 431                               ethnl_string_array_t names,
 432                               struct netlink_ext_ack *extack, bool *mod)
 433 {
 434         u32 *orig_bitmap, *saved_bitmap = NULL;
 435         struct nlattr *bit_attr;
 436         bool no_mask;
 437         bool dummy;
 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         }
 451
 452         no_mask = tb[ETHTOOL_A_BITSET_NOMASK];
 453         if (no_mask) {
 454                 unsigned int nwords = DIV_ROUND_UP(nbits, 32);
 455                 unsigned int nbytes = nwords * sizeof(u32);
 456
 457                 /* The bitmap size is only the size of the map part without
 458                  * its mask part.
 459                  */
 460                 saved_bitmap = kcalloc(nwords, sizeof(u32), GFP_KERNEL);
 461                 if (!saved_bitmap)
 462                         return -ENOMEM;
 463                 memcpy(saved_bitmap, bitmap, nbytes);
 464                 ethnl_bitmap32_clear(bitmap, 0, nbits, &dummy);
 465                 orig_bitmap = saved_bitmap;
 466         } else {
 467                 orig_bitmap = bitmap;
 468         }
 469
 470         nla_for_each_nested(bit_attr, tb[ETHTOOL_A_BITSET_BITS], rem) {
 471                 bool old_val, new_val;
 472                 unsigned int idx;
 473
 474                 if (nla_type(bit_attr) != ETHTOOL_A_BITSET_BITS_BIT) {
 475                         NL_SET_ERR_MSG_ATTR(extack, bit_attr,
 476                                             "only ETHTOOL_A_BITSET_BITS_BIT allowed in ETHTOOL_A_BITSET_BITS");
 477                         ret = -EINVAL;
 478                         goto out;
 479                 }
 480                 ret = ethnl_parse_bit(&idx, &new_val, nbits, bit_attr, no_mask,
 481                                       names, extack);
 482                 if (ret < 0)
 483                         goto out;
 484                 old_val = orig_bitmap[idx / 32] & ((u32)1 << (idx % 32));
 485                 if (new_val != old_val) {
 486                         if (new_val)
 487                                 bitmap[idx / 32] |= ((u32)1 << (idx % 32));
 488                         else
 489                                 bitmap[idx / 32] &= ~((u32)1 << (idx % 32));
 490                         *mod = true;
 491                 }
 492         }
 493
 494         ret = 0;
 495 out:
 496         kfree(saved_bitmap);
 497         return ret;
 498 }
 499
 500 static int ethnl_compact_sanity_checks(unsigned int nbits,
 501                                        const struct nlattr *nest,
 502                                        struct nlattr **tb,
 503                                        struct netlink_ext_ack *extack)
 504 {
 505         bool no_mask = tb[ETHTOOL_A_BITSET_NOMASK];
 506         unsigned int attr_nbits, attr_nwords;
 507         const struct nlattr *test_attr;
 508
 509         if (no_mask && tb[ETHTOOL_A_BITSET_MASK]) {
 510                 NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_BITSET_MASK],
 511                                     "mask not allowed in list bitset");
 512                 return -EINVAL;
 513         }
 514         if (!tb[ETHTOOL_A_BITSET_SIZE]) {
 515                 NL_SET_ERR_MSG_ATTR(extack, nest,
 516                                     "missing size in compact bitset");
 517                 return -EINVAL;
 518         }
 519         if (!tb[ETHTOOL_A_BITSET_VALUE]) {
 520                 NL_SET_ERR_MSG_ATTR(extack, nest,
 521                                     "missing value in compact bitset");
 522                 return -EINVAL;
 523         }
 524         if (!no_mask && !tb[ETHTOOL_A_BITSET_MASK]) {
 525                 NL_SET_ERR_MSG_ATTR(extack, nest,
 526                                     "missing mask in compact nonlist bitset");
 527                 return -EINVAL;
 528         }
 529
 530         attr_nbits = nla_get_u32(tb[ETHTOOL_A_BITSET_SIZE]);
 531         attr_nwords = DIV_ROUND_UP(attr_nbits, 32);
 532         if (nla_len(tb[ETHTOOL_A_BITSET_VALUE]) != attr_nwords * sizeof(u32)) {
 533                 NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_BITSET_VALUE],
 534                                     "bitset value length does not match size");
 535                 return -EINVAL;
 536         }
 537         if (tb[ETHTOOL_A_BITSET_MASK] &&
 538             nla_len(tb[ETHTOOL_A_BITSET_MASK]) != attr_nwords * sizeof(u32)) {
 539                 NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_BITSET_MASK],
 540                                     "bitset mask length does not match size");
 541                 return -EINVAL;
 542         }
 543         if (attr_nbits <= nbits)
 544                 return 0;
 545
 546         test_attr = no_mask ? tb[ETHTOOL_A_BITSET_VALUE] :
 547                               tb[ETHTOOL_A_BITSET_MASK];
 548         if (ethnl_bitmap32_not_zero(nla_data(test_attr), nbits, attr_nbits)) {
 549                 NL_SET_ERR_MSG_ATTR(extack, test_attr,
 550                                     "cannot modify bits past kernel bitset size");
 551                 return -EINVAL;
 552         }
 553         return 0;
 554 }
 555
 556 /**
 557  * ethnl_update_bitset32() - Apply a bitset nest to a u32 based bitmap
 558  * @bitmap:  bitmap to update
 559  * @nbits:   size of the updated bitmap in bits
 560  * @attr:    nest attribute to parse and apply
 561  * @names:   array of bit names; may be null for compact format
 562  * @extack:  extack for error reporting
 563  * @mod:     set this to true if bitmap is modified, leave as it is if not
 564  *
 565  * Apply bitset netsted attribute to a bitmap. If the attribute represents
 566  * a bit list, @bitmap is set to its contents; otherwise, bits in mask are
 567  * set to values from value. Bitmaps in the attribute may be longer than
 568  * @nbits but the message must not request modifying any bits past @nbits.
 569  *
 570  * Return: negative error code on failure, 0 on success
 571  */
 572 int ethnl_update_bitset32(u32 *bitmap, unsigned int nbits,
 573                           const struct nlattr *attr, ethnl_string_array_t names,
 574                           struct netlink_ext_ack *extack, bool *mod)
 575 {
 576         struct nlattr *tb[ARRAY_SIZE(bitset_policy)];
 577         unsigned int change_bits;
 578         bool no_mask;
 579         int ret;
 580
 581         if (!attr)
 582                 return 0;
 583         ret = nla_parse_nested(tb, ARRAY_SIZE(bitset_policy) - 1, attr,
 584                                bitset_policy, extack);
 585         if (ret < 0)
 586                 return ret;
 587
 588         if (tb[ETHTOOL_A_BITSET_BITS])
 589                 return ethnl_update_bitset32_verbose(bitmap, nbits, attr, tb,
 590                                                      names, extack, mod);
 591         ret = ethnl_compact_sanity_checks(nbits, attr, tb, extack);
 592         if (ret < 0)
 593                 return ret;
 594
 595         no_mask = tb[ETHTOOL_A_BITSET_NOMASK];
 596         change_bits = min_t(unsigned int,
 597                             nla_get_u32(tb[ETHTOOL_A_BITSET_SIZE]), nbits);
 598         ethnl_bitmap32_update(bitmap, change_bits,
 599                               nla_data(tb[ETHTOOL_A_BITSET_VALUE]),
 600                               no_mask ? NULL :
 601                                         nla_data(tb[ETHTOOL_A_BITSET_MASK]),
 602                               mod);
 603         if (no_mask && change_bits < nbits)
 604                 ethnl_bitmap32_clear(bitmap, change_bits, nbits, mod);
 605
 606         return 0;
 607 }
 608
 609 /**
 610  * ethnl_parse_bitset() - Compute effective value and mask from bitset nest
 611  * @val:     unsigned long based bitmap to put value into
 612  * @mask:    unsigned long based bitmap to put mask into
 613  * @nbits:   size of @val and @mask bitmaps
 614  * @attr:    nest attribute to parse and apply
 615  * @names:   array of bit names; may be null for compact format
 616  * @extack:  extack for error reporting
 617  *
 618  * Provide @nbits size long bitmaps for value and mask so that
 619  * x = (val & mask) | (x & ~mask) would modify any @nbits sized bitmap x
 620  * the same way ethnl_update_bitset() with the same bitset attribute would.
 621  *
 622  * Return:   negative error code on failure, 0 on success
 623  */
 624 int ethnl_parse_bitset(unsigned long *val, unsigned long *mask,
 625                        unsigned int nbits, const struct nlattr *attr,
 626                        ethnl_string_array_t names,
 627                        struct netlink_ext_ack *extack)
 628 {
 629         struct nlattr *tb[ARRAY_SIZE(bitset_policy)];
 630         const struct nlattr *bit_attr;
 631         bool no_mask;
 632         int rem;
 633         int ret;
 634
 635         if (!attr)
 636                 return 0;
 637         ret = nla_parse_nested(tb, ARRAY_SIZE(bitset_policy) - 1, attr,
 638                                bitset_policy, extack);
 639         if (ret < 0)
 640                 return ret;
 641         no_mask = tb[ETHTOOL_A_BITSET_NOMASK];
 642
 643         if (!tb[ETHTOOL_A_BITSET_BITS]) {
 644                 unsigned int change_bits;
 645
 646                 ret = ethnl_compact_sanity_checks(nbits, attr, tb, extack);
 647                 if (ret < 0)
 648                         return ret;
 649
 650                 change_bits = nla_get_u32(tb[ETHTOOL_A_BITSET_SIZE]);
 651                 if (change_bits > nbits)
 652                         change_bits = nbits;
 653                 bitmap_from_arr32(val, nla_data(tb[ETHTOOL_A_BITSET_VALUE]),
 654                                   change_bits);
 655                 if (change_bits < nbits)
 656                         bitmap_clear(val, change_bits, nbits - change_bits);
 657                 if (no_mask) {
 658                         bitmap_fill(mask, nbits);
 659                 } else {
 660                         bitmap_from_arr32(mask,
 661                                           nla_data(tb[ETHTOOL_A_BITSET_MASK]),
 662                                           change_bits);
 663                         if (change_bits < nbits)
 664                                 bitmap_clear(mask, change_bits,
 665                                              nbits - change_bits);
 666                 }
 667
 668                 return 0;
 669         }
 670
 671         if (tb[ETHTOOL_A_BITSET_VALUE]) {
 672                 NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_BITSET_VALUE],
 673                                     "value only allowed in compact bitset");
 674                 return -EINVAL;
 675         }
 676         if (tb[ETHTOOL_A_BITSET_MASK]) {
 677                 NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_BITSET_MASK],
 678                                     "mask only allowed in compact bitset");
 679                 return -EINVAL;
 680         }
 681
 682         bitmap_zero(val, nbits);
 683         if (no_mask)
 684                 bitmap_fill(mask, nbits);
 685         else
 686                 bitmap_zero(mask, nbits);
 687
 688         nla_for_each_nested(bit_attr, tb[ETHTOOL_A_BITSET_BITS], rem) {
 689                 unsigned int idx;
 690                 bool bit_val;
 691
 692                 ret = ethnl_parse_bit(&idx, &bit_val, nbits, bit_attr, no_mask,
 693                                       names, extack);
 694                 if (ret < 0)
 695                         return ret;
 696                 if (bit_val)
 697                         __set_bit(idx, val);
 698                 if (!no_mask)
 699                         __set_bit(idx, mask);
 700         }
 701
 702         return 0;
 703 }
 704
 705 #if BITS_PER_LONG == 64 && defined(__BIG_ENDIAN)
 706
 707 /* 64-bit big endian architectures are the only case when u32 based bitmaps
 708  * and unsigned long based bitmaps have different memory layout so that we
 709  * cannot simply cast the latter to the former and need actual wrappers
 710  * converting the latter to the former.
 711  *
 712  * To reduce the number of slab allocations, the wrappers use fixed size local
 713  * variables for bitmaps up to ETHNL_SMALL_BITMAP_BITS bits which is the
 714  * majority of bitmaps used by ethtool.
 715  */
 716 #define ETHNL_SMALL_BITMAP_BITS 128
 717 #define ETHNL_SMALL_BITMAP_WORDS DIV_ROUND_UP(ETHNL_SMALL_BITMAP_BITS, 32)
 718
 719 int ethnl_bitset_size(const unsigned long *val, const unsigned long *mask,
 720                       unsigned int nbits, ethnl_string_array_t names,
 721                       bool compact)
 722 {
 723         u32 small_mask32[ETHNL_SMALL_BITMAP_WORDS];
 724         u32 small_val32[ETHNL_SMALL_BITMAP_WORDS];
 725         u32 *mask32;
 726         u32 *val32;
 727         int ret;
 728
 729         if (nbits > ETHNL_SMALL_BITMAP_BITS) {
 730                 unsigned int nwords = DIV_ROUND_UP(nbits, 32);
 731
 732                 val32 = kmalloc_array(2 * nwords, sizeof(u32), GFP_KERNEL);
 733                 if (!val32)
 734                         return -ENOMEM;
 735                 mask32 = val32 + nwords;
 736         } else {
 737                 val32 = small_val32;
 738                 mask32 = small_mask32;
 739         }
 740
 741         bitmap_to_arr32(val32, val, nbits);
 742         if (mask)
 743                 bitmap_to_arr32(mask32, mask, nbits);
 744         else
 745                 mask32 = NULL;
 746         ret = ethnl_bitset32_size(val32, mask32, nbits, names, compact);
 747
 748         if (nbits > ETHNL_SMALL_BITMAP_BITS)
 749                 kfree(val32);
 750
 751         return ret;
 752 }
 753
 754 int ethnl_put_bitset(struct sk_buff *skb, int attrtype,
 755                      const unsigned long *val, const unsigned long *mask,
 756                      unsigned int nbits, ethnl_string_array_t names,
 757                      bool compact)
 758 {
 759         u32 small_mask32[ETHNL_SMALL_BITMAP_WORDS];
 760         u32 small_val32[ETHNL_SMALL_BITMAP_WORDS];
 761         u32 *mask32;
 762         u32 *val32;
 763         int ret;
 764
 765         if (nbits > ETHNL_SMALL_BITMAP_BITS) {
 766                 unsigned int nwords = DIV_ROUND_UP(nbits, 32);
 767
 768                 val32 = kmalloc_array(2 * nwords, sizeof(u32), GFP_KERNEL);
 769                 if (!val32)
 770                         return -ENOMEM;
 771                 mask32 = val32 + nwords;
 772         } else {
 773                 val32 = small_val32;
 774                 mask32 = small_mask32;
 775         }
 776
 777         bitmap_to_arr32(val32, val, nbits);
 778         if (mask)
 779                 bitmap_to_arr32(mask32, mask, nbits);
 780         else
 781                 mask32 = NULL;
 782         ret = ethnl_put_bitset32(skb, attrtype, val32, mask32, nbits, names,
 783                                  compact);
 784
 785         if (nbits > ETHNL_SMALL_BITMAP_BITS)
 786                 kfree(val32);
 787
 788         return ret;
 789 }
 790
 791 int ethnl_update_bitset(unsigned long *bitmap, unsigned int nbits,
 792                         const struct nlattr *attr, ethnl_string_array_t names,
 793                         struct netlink_ext_ack *extack, bool *mod)
 794 {
 795         u32 small_bitmap32[ETHNL_SMALL_BITMAP_WORDS];
 796         u32 *bitmap32 = small_bitmap32;
 797         bool u32_mod = false;
 798         int ret;
 799
 800         if (nbits > ETHNL_SMALL_BITMAP_BITS) {
 801                 unsigned int dst_words = DIV_ROUND_UP(nbits, 32);
 802
 803                 bitmap32 = kmalloc_array(dst_words, sizeof(u32), GFP_KERNEL);
 804                 if (!bitmap32)
 805                         return -ENOMEM;
 806         }
 807
 808         bitmap_to_arr32(bitmap32, bitmap, nbits);
 809         ret = ethnl_update_bitset32(bitmap32, nbits, attr, names, extack,
 810                                     &u32_mod);
 811         if (u32_mod) {
 812                 bitmap_from_arr32(bitmap, bitmap32, nbits);
 813                 *mod = true;
 814         }
 815
 816         if (nbits > ETHNL_SMALL_BITMAP_BITS)
 817                 kfree(bitmap32);
 818
 819         return ret;
 820 }
 821
 822 #else
 823
 824 /* On little endian 64-bit and all 32-bit architectures, an unsigned long
 825  * based bitmap can be interpreted as u32 based one using a simple cast.
 826  */
 827
 828 int ethnl_bitset_size(const unsigned long *val, const unsigned long *mask,
 829                       unsigned int nbits, ethnl_string_array_t names,
 830                       bool compact)
 831 {
 832         return ethnl_bitset32_size((const u32 *)val, (const u32 *)mask, nbits,
 833                                    names, compact);
 834 }
 835
 836 int ethnl_put_bitset(struct sk_buff *skb, int attrtype,
 837                      const unsigned long *val, const unsigned long *mask,
 838                      unsigned int nbits, ethnl_string_array_t names,
 839                      bool compact)
 840 {
 841         return ethnl_put_bitset32(skb, attrtype, (const u32 *)val,
 842                                   (const u32 *)mask, nbits, names, compact);
 843 }
 844
 845 int ethnl_update_bitset(unsigned long *bitmap, unsigned int nbits,
 846                         const struct nlattr *attr, ethnl_string_array_t names,
 847                         struct netlink_ext_ack *extack, bool *mod)
 848 {
 849         return ethnl_update_bitset32((u32 *)bitmap, nbits, attr, names, extack,
 850                                      mod);
 851 }
 852
 853 #endif /* BITS_PER_LONG == 64 && defined(__BIG_ENDIAN) */