Eric Lee / smarc-fsl-linux-kernel

11 Aug, 2020

1 commit

  • 444da3f52   bitfield.h: don't compile-time validate _val in FIELD_FIT ... Browse Code »

    When ur_load_imm_any() is inlined into jeq_imm(), it's possible for the
    compiler to deduce a case where _val can only have the value of -1 at
    compile time. Specifically,

    /* struct bpf_insn: _s32 imm */
    u64 imm = insn->imm; /* sign extend */
    if (imm >> 32) { /* non-zero only if insn->imm is negative */
    /* inlined from ur_load_imm_any */
    u32 __imm = imm >> 32; /* therefore, always 0xffffffff */
    if (__builtin_constant_p(__imm) && __imm > 255)
    compiletime_assert_XXX()

    This can result in tripping a BUILD_BUG_ON() in __BF_FIELD_CHECK() that
    checks that a given value is representable in one byte (interpreted as
    unsigned).

    FIELD_FIT() should return true or false at runtime for whether a value
    can fit for not. Don't break the build over a value that's too large for
    the mask. We'd prefer to keep the inlining and compiler optimizations
    though we know this case will always return false.

    Cc: stable@vger.kernel.org
    Fixes: 1697599ee301a ("bitfield.h: add FIELD_FIT() helper")
    Link: https://lore.kernel.org/kernel-hardening/CAK7LNASvb0UDJ0U5wkYYRzTAdnEs64HjXpEUL7d=V0CXiAXcNw@mail.gmail.com/
    Reported-by: Masahiro Yamada
    Debugged-by: Sami Tolvanen
    Signed-off-by: Jakub Kicinski
    Signed-off-by: Nick Desaulniers
    Signed-off-by: David S. Miller

    Jakub Kicinski
     

13 Mar, 2020

1 commit

  • e31a50162   bitfield.h: add FIELD_MAX() and field_max() ... Browse Code »

    Define FIELD_MAX(), which supplies the maximum value that can be
    represented by a field value. Define field_max() as well, to go
    along with the lower-case forms of the field mask functions.

    Signed-off-by: Alex Elder
    Acked-by: Jakub Kicinski
    Signed-off-by: David S. Miller

    Alex Elder
     

31 May, 2019

1 commit

  • 1802d0bee   treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 174 ... Browse Code »

    Based on 1 normalized pattern(s):

    this program is free software you can redistribute it and or modify
    it under the terms of the gnu general public license version 2 as
    published by the free software foundation this program is
    distributed in the hope that it will be useful but without any
    warranty without even the implied warranty of merchantability or
    fitness for a particular purpose see the gnu general public license
    for more details

    extracted by the scancode license scanner the SPDX license identifier

    GPL-2.0-only

    has been chosen to replace the boilerplate/reference in 655 file(s).

    Signed-off-by: Thomas Gleixner
    Reviewed-by: Allison Randal
    Reviewed-by: Kate Stewart
    Reviewed-by: Richard Fontana
    Cc: linux-spdx@vger.kernel.org
    Link: https://lkml.kernel.org/r/20190527070034.575739538@linutronix.de
    Signed-off-by: Greg Kroah-Hartman

    Thomas Gleixner
     

18 Aug, 2018

1 commit

  • e36488c83   bitfield: avoid gcc-8 -Wint-in-bool-context warning ... Browse Code »

    Passing an enum into FIELD_GET() produces a long but harmless warning on
    newer compilers:

    from include/linux/linkage.h:7,
    from include/linux/kernel.h:7,
    from include/linux/skbuff.h:17,
    from include/linux/if_ether.h:23,
    from include/linux/etherdevice.h:25,
    from drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c:63:
    drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c: In function 'iwl_mvm_rx_mpdu_mq':
    include/linux/bitfield.h:56:20: error: enum constant in boolean context [-Werror=int-in-bool-context]
    BUILD_BUG_ON_MSG(!(_mask), _pfx "mask is zero"); \
    ^
    ...
    include/linux/bitfield.h:103:3: note: in expansion of macro '__BF_FIELD_CHECK'
    __BF_FIELD_CHECK(_mask, _reg, 0U, "FIELD_GET: "); \
    ^~~~~~~~~~~~~~~~
    drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c:1025:21: note: in expansion of macro 'FIELD_GET'
    le16_encode_bits(FIELD_GET(IWL_RX_HE_PHY_SIBG_SYM_OR_USER_NUM_MASK,

    The problem here is that the caller has no idea how the macro gets
    expanding, leading to a false-positive. It can be trivially avoided by
    doing a comparison against zero.

    This only recently started appearing as the iwlwifi driver was patched
    to use FIELD_GET.

    Link: http://lkml.kernel.org/r/20180813220950.194841-1-arnd@arndb.de
    Fixes: 514c30696fbc ("iwlwifi: add support for IEEE802.11ax")
    Signed-off-by: Arnd Bergmann
    Cc: Masahiro Yamada
    Cc: Johannes Berg
    Cc: Jakub Kicinski
    Cc: Andy Shevchenko
    Cc: Al Viro
    Cc: David Laight
    Signed-off-by: Andrew Morton
    Signed-off-by: Linus Torvalds

    Arnd Bergmann
     

27 Jun, 2018

2 commits

  • 37a3862e1   bitfield: add u8 helpers ... Browse Code »

    There's no reason why we shouldn't pack/unpack bits into/from
    u8 values/registers/etc., so add u8 helpers.

    Use the ____MAKE_OP() macro directly to avoid having nonsense
    le8_encode_bits() and similar functions.

    Reviewed-by: Andy Shevchenko
    Signed-off-by: Johannes Berg
    Signed-off-by: Kalle Valo

    Johannes Berg
     
  • e7d4a95da   bitfield: fix *_encode_bits() ... Browse Code »

    There's a bug in *_encode_bits() in using ~field_multiplier() for
    the check whether or not the constant value fits into the field,
    this is wrong and clearly ~field_mask() was intended. This was
    triggering for me for both constant and non-constant values.

    Additionally, make this case actually into an compile error.
    Declaring the extern function that will never exist with just a
    warning is pointless as then later we'll just get a link error.

    While at it, also fix the indentation in those lines I'm touching.

    Finally, as suggested by Andy Shevchenko, add some tests and for
    that introduce also u8 helpers. The tests don't compile without
    the fix, showing that it's necessary.

    Fixes: 00b0c9b82663 ("Add primitives for manipulating bitfields both in host- and fixed-endian.")
    Reviewed-by: Andy Shevchenko
    Signed-off-by: Johannes Berg
    Signed-off-by: Kalle Valo

    Johannes Berg
     

18 Dec, 2017

1 commit

  • 00b0c9b82   Add primitives for manipulating bitfields both in host- and fixed-endian. ... Browse Code »

    The following primitives are defined in linux/bitfield.h:

    * u32 le32_get_bits(__le32 val, u32 field) extracts the contents of the
    bitfield specified by @field in little-endian 32bit object @val and
    converts it to host-endian.

    * void le32p_replace_bits(__le32 *p, u32 v, u32 field) replaces
    the contents of the bitfield specified by @field in little-endian
    32bit object pointed to by @p with the value of @v. New value is
    given in host-endian and stored as little-endian.

    * __le32 le32_replace_bits(__le32 old, u32 v, u32 field) is equivalent to
    ({__le32 tmp = old; le32p_replace_bits(&tmp, v, field); tmp;})
    In other words, instead of modifying an object in memory, it takes
    the initial value and returns the modified one.

    * __le32 le32_encode_bits(u32 v, u32 field) is equivalent to
    le32_replace_bits(0, v, field). In other words, it returns a little-endian
    32bit object with the bitfield specified by @field containing the
    value of @v and all bits outside that bitfield being zero.

    Such set of helpers is defined for each of little-, big- and host-endian
    types; e.g. u64_get_bits(val, field) will return the contents of the bitfield
    specified by @field in host-endian 64bit object @val, etc. Of course, for
    host-endian no conversion is involved.

    Fields to access are specified as GENMASK() values - an N-bit field
    starting at bit #M is encoded as GENMASK(M + N - 1, M). Note that
    bit numbers refer to endianness of the object we are working with -
    e.g. GENMASK(11, 0) in __be16 refers to the second byte and the lower
    4 bits of the first byte. In __le16 it would refer to the first byte
    and the lower 4 bits of the second byte, etc.

    Field specification must be a constant; __builtin_constant_p() doesn't
    have to be true for it, but compiler must be able to evaluate it at
    build time. If it cannot or if the value does not encode any bitfield,
    the build will fail.

    If the value being stored in a bitfield is a constant that does not fit
    into that bitfield, a warning will be generated at compile time.

    Signed-off-by: Al Viro

    Al Viro
     

18 Nov, 2017

1 commit

04 Oct, 2017

1 commit

11 Feb, 2017

1 commit

09 Sep, 2016

1 commit

  • 3e9b3112e   add basic register-field manipulation macros ... Browse Code »

    Common approach to accessing register fields is to define
    structures or sets of macros containing mask and shift pair.
    Operations on the register are then performed as follows:

    field = (reg >> shift) & mask;

    reg &= ~(mask << shift);
    reg |= (field & mask) << shift;

    Defining shift and mask separately is tedious. Ivo van Doorn
    came up with an idea of computing them at compilation time
    based on a single shifted mask (later refined by Felix) which
    can be used like this:

    #define REG_FIELD 0x000ff000

    field = FIELD_GET(REG_FIELD, reg);

    reg &= ~REG_FIELD;
    reg |= FIELD_PREP(REG_FIELD, field);

    FIELD_{GET,PREP} macros take care of finding out what the
    appropriate shift is based on compilation time ffs operation.

    GENMASK can be used to define registers (which is usually
    less error-prone and easier to match with datasheets).

    This approach is the most convenient I've seen so to limit code
    multiplication let's move the macros to a global header file.
    Attempts to use static inlines instead of macros failed due
    to false positive triggering of BUILD_BUG_ON()s, especially with
    GCC < 6.0.

    Signed-off-by: Jakub Kicinski
    Reviewed-by: Dinan Gunawardena
    Signed-off-by: Kalle Valo

    Jakub Kicinski