Commit 81d2c6f8 authored by Daniel Axtens's avatar Daniel Axtens Committed by Michael Ellerman
Browse files

kasan: support instrumented bitops combined with generic bitops 



Currently bitops-instrumented.h assumes that the architecture provides
atomic, non-atomic and locking bitops (e.g. both set_bit and __set_bit).
This is true on x86 and s390, but is not always true: there is a
generic bitops/non-atomic.h header that provides generic non-atomic
operations, and also a generic bitops/lock.h for locking operations.

powerpc uses the generic non-atomic version, so it does not have it's
own e.g. __set_bit that could be renamed arch___set_bit.

Split up bitops-instrumented.h to mirror the atomic/non-atomic/lock
split. This allows arches to only include the headers where they
have arch-specific versions to rename. Update x86 and s390.

(The generic operations are automatically instrumented because they're
written in C, not asm.)

Suggested-by: default avatarChristophe Leroy <christophe.leroy@c-s.fr>
Reviewed-by: default avatarChristophe Leroy <christophe.leroy@c-s.fr>
Signed-off-by: default avatarDaniel Axtens <dja@axtens.net>
Acked-by: default avatarMarco Elver <elver@google.com>
Signed-off-by: default avatarMichael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/20190820024941.12640-1-dja@axtens.net
parent da0c9ea1

Documentation/core-api/kernel-api.rst

+16 −1
Original line number Original line Diff line number Diff line
@@ -57,7 +57,22 @@ The Linux kernel provides more basic utility functions. 
Bit Operations

Bit Operations

--------------

--------------





.. kernel-doc:: include/asm-generic/bitops-instrumented.h

Atomic Operations

~~~~~~~~~~~~~~~~~



.. kernel-doc:: include/asm-generic/bitops/instrumented-atomic.h

   :internal:



Non-atomic Operations

~~~~~~~~~~~~~~~~~~~~~



.. kernel-doc:: include/asm-generic/bitops/instrumented-non-atomic.h

   :internal:



Locking Operations

~~~~~~~~~~~~~~~~~~



.. kernel-doc:: include/asm-generic/bitops/instrumented-lock.h

   :internal:

   :internal:





Bitmap Operations

Bitmap Operations

arch/s390/include/asm/bitops.h

+3 −1
Original line number Original line Diff line number Diff line
@@ -241,7 +241,9 @@ static inline void arch___clear_bit_unlock(unsigned long nr, 
	arch___clear_bit(nr, ptr);

	arch___clear_bit(nr, ptr);

}

}





#include <asm-generic/bitops-instrumented.h>

#include <asm-generic/bitops/instrumented-atomic.h>

#include <asm-generic/bitops/instrumented-non-atomic.h>

#include <asm-generic/bitops/instrumented-lock.h>





/*

/*

 * Functions which use MSB0 bit numbering.

 * Functions which use MSB0 bit numbering.

arch/x86/include/asm/bitops.h

+3 −1
Original line number Original line Diff line number Diff line
@@ -388,7 +388,9 @@ static __always_inline int fls64(__u64 x) 




#include <asm-generic/bitops/const_hweight.h>

#include <asm-generic/bitops/const_hweight.h>





#include <asm-generic/bitops-instrumented.h>

#include <asm-generic/bitops/instrumented-atomic.h>

#include <asm-generic/bitops/instrumented-non-atomic.h>

#include <asm-generic/bitops/instrumented-lock.h>





#include <asm-generic/bitops/le.h>

#include <asm-generic/bitops/le.h>

include/asm-generic/bitops/instrumented-atomic.h

0 → 100644
+100 −0
Original line number Original line Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */



/*

 * This file provides wrappers with sanitizer instrumentation for atomic bit

 * operations.

 *

 * To use this functionality, an arch's bitops.h file needs to define each of

 * the below bit operations with an arch_ prefix (e.g. arch_set_bit(),

 * arch___set_bit(), etc.).

 */

#ifndef _ASM_GENERIC_BITOPS_INSTRUMENTED_ATOMIC_H

#define _ASM_GENERIC_BITOPS_INSTRUMENTED_ATOMIC_H



#include <linux/kasan-checks.h>



/**

 * set_bit - Atomically set a bit in memory

 * @nr: the bit to set

 * @addr: the address to start counting from

 *

 * This is a relaxed atomic operation (no implied memory barriers).

 *

 * Note that @nr may be almost arbitrarily large; this function is not

 * restricted to acting on a single-word quantity.

 */

static inline void set_bit(long nr, volatile unsigned long *addr)

{

	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));

	arch_set_bit(nr, addr);

}



/**

 * clear_bit - Clears a bit in memory

 * @nr: Bit to clear

 * @addr: Address to start counting from

 *

 * This is a relaxed atomic operation (no implied memory barriers).

 */

static inline void clear_bit(long nr, volatile unsigned long *addr)

{

	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));

	arch_clear_bit(nr, addr);

}



/**

 * change_bit - Toggle a bit in memory

 * @nr: Bit to change

 * @addr: Address to start counting from

 *

 * This is a relaxed atomic operation (no implied memory barriers).

 *

 * Note that @nr may be almost arbitrarily large; this function is not

 * restricted to acting on a single-word quantity.

 */

static inline void change_bit(long nr, volatile unsigned long *addr)

{

	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));

	arch_change_bit(nr, addr);

}



/**

 * test_and_set_bit - Set a bit and return its old value

 * @nr: Bit to set

 * @addr: Address to count from

 *

 * This is an atomic fully-ordered operation (implied full memory barrier).

 */

static inline bool test_and_set_bit(long nr, volatile unsigned long *addr)

{

	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));

	return arch_test_and_set_bit(nr, addr);

}



/**

 * test_and_clear_bit - Clear a bit and return its old value

 * @nr: Bit to clear

 * @addr: Address to count from

 *

 * This is an atomic fully-ordered operation (implied full memory barrier).

 */

static inline bool test_and_clear_bit(long nr, volatile unsigned long *addr)

{

	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));

	return arch_test_and_clear_bit(nr, addr);

}



/**

 * test_and_change_bit - Change a bit and return its old value

 * @nr: Bit to change

 * @addr: Address to count from

 *

 * This is an atomic fully-ordered operation (implied full memory barrier).

 */

static inline bool test_and_change_bit(long nr, volatile unsigned long *addr)

{

	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));

	return arch_test_and_change_bit(nr, addr);

}



#endif /* _ASM_GENERIC_BITOPS_INSTRUMENTED_NON_ATOMIC_H */

include/asm-generic/bitops/instrumented-lock.h

0 → 100644
+81 −0
Original line number Original line Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */



/*

 * This file provides wrappers with sanitizer instrumentation for bit

 * locking operations.

 *

 * To use this functionality, an arch's bitops.h file needs to define each of

 * the below bit operations with an arch_ prefix (e.g. arch_set_bit(),

 * arch___set_bit(), etc.).

 */

#ifndef _ASM_GENERIC_BITOPS_INSTRUMENTED_LOCK_H

#define _ASM_GENERIC_BITOPS_INSTRUMENTED_LOCK_H



#include <linux/kasan-checks.h>



/**

 * clear_bit_unlock - Clear a bit in memory, for unlock

 * @nr: the bit to set

 * @addr: the address to start counting from

 *

 * This operation is atomic and provides release barrier semantics.

 */

static inline void clear_bit_unlock(long nr, volatile unsigned long *addr)

{

	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));

	arch_clear_bit_unlock(nr, addr);

}



/**

 * __clear_bit_unlock - Clears a bit in memory

 * @nr: Bit to clear

 * @addr: Address to start counting from

 *

 * This is a non-atomic operation but implies a release barrier before the

 * memory operation. It can be used for an unlock if no other CPUs can

 * concurrently modify other bits in the word.

 */

static inline void __clear_bit_unlock(long nr, volatile unsigned long *addr)

{

	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));

	arch___clear_bit_unlock(nr, addr);

}



/**

 * test_and_set_bit_lock - Set a bit and return its old value, for lock

 * @nr: Bit to set

 * @addr: Address to count from

 *

 * This operation is atomic and provides acquire barrier semantics if

 * the returned value is 0.

 * It can be used to implement bit locks.

 */

static inline bool test_and_set_bit_lock(long nr, volatile unsigned long *addr)

{

	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));

	return arch_test_and_set_bit_lock(nr, addr);

}



#if defined(arch_clear_bit_unlock_is_negative_byte)

/**

 * clear_bit_unlock_is_negative_byte - Clear a bit in memory and test if bottom

 *                                     byte is negative, for unlock.

 * @nr: the bit to clear

 * @addr: the address to start counting from

 *

 * This operation is atomic and provides release barrier semantics.

 *

 * This is a bit of a one-trick-pony for the filemap code, which clears

 * PG_locked and tests PG_waiters,

 */

static inline bool

clear_bit_unlock_is_negative_byte(long nr, volatile unsigned long *addr)

{

	kasan_check_write(addr + BIT_WORD(nr), sizeof(long));

	return arch_clear_bit_unlock_is_negative_byte(nr, addr);

}

/* Let everybody know we have it. */

#define clear_bit_unlock_is_negative_byte clear_bit_unlock_is_negative_byte

#endif



#endif /* _ASM_GENERIC_BITOPS_INSTRUMENTED_LOCK_H */

CRA Git | Maintained and supported by SUSTech CRA and CCSE