/* SPDX-License-Identifier: GPL-2.0 */ #ifndef _ASM_X86_BITOPS_H #define _ASM_X86_BITOPS_H /* * Copyright 1992, Linus Torvalds. * * Note: inlines with more than a single statement should be marked * __always_inline to avoid problems with older gcc's inlining heuristics. */ #ifndef _LINUX_BITOPS_H #error only <linux/bitops.h> can be included directly #endif #include <linux/compiler.h> #include <asm/alternative.h> #include <asm/rmwcc.h> #include <asm/barrier.h> #if BITS_PER_LONG == 32 #define _BITOPS_LONG_SHIFT … #elif BITS_PER_LONG == 64 #define _BITOPS_LONG_SHIFT … #else # error "Unexpected BITS_PER_LONG" #endif #define BIT_64(n) … /* * These have to be done with inline assembly: that way the bit-setting * is guaranteed to be atomic. All bit operations return 0 if the bit * was cleared before the operation and != 0 if it was not. * * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1). */ #define RLONG_ADDR(x) … #define WBYTE_ADDR(x) … #define ADDR … /* * We do the locked ops that don't return the old value as * a mask operation on a byte. */ #define CONST_MASK_ADDR(nr, addr) … #define CONST_MASK(nr) … static __always_inline void arch_set_bit(long nr, volatile unsigned long *addr) { … } static __always_inline void arch___set_bit(unsigned long nr, volatile unsigned long *addr) { … } static __always_inline void arch_clear_bit(long nr, volatile unsigned long *addr) { … } static __always_inline void arch_clear_bit_unlock(long nr, volatile unsigned long *addr) { … } static __always_inline void arch___clear_bit(unsigned long nr, volatile unsigned long *addr) { … } static __always_inline bool arch_xor_unlock_is_negative_byte(unsigned long mask, volatile unsigned long *addr) { … } #define arch_xor_unlock_is_negative_byte … static __always_inline void arch___clear_bit_unlock(long nr, volatile unsigned long *addr) { … } static __always_inline void arch___change_bit(unsigned long nr, volatile unsigned long *addr) { … } static __always_inline void arch_change_bit(long nr, volatile unsigned long *addr) { … } static __always_inline bool arch_test_and_set_bit(long nr, volatile unsigned long *addr) { … } static __always_inline bool arch_test_and_set_bit_lock(long nr, volatile unsigned long *addr) { … } static __always_inline bool arch___test_and_set_bit(unsigned long nr, volatile unsigned long *addr) { … } static __always_inline bool arch_test_and_clear_bit(long nr, volatile unsigned long *addr) { … } /* * Note: the operation is performed atomically with respect to * the local CPU, but not other CPUs. Portable code should not * rely on this behaviour. * KVM relies on this behaviour on x86 for modifying memory that is also * accessed from a hypervisor on the same CPU if running in a VM: don't change * this without also updating arch/x86/kernel/kvm.c */ static __always_inline bool arch___test_and_clear_bit(unsigned long nr, volatile unsigned long *addr) { … } static __always_inline bool arch___test_and_change_bit(unsigned long nr, volatile unsigned long *addr) { … } static __always_inline bool arch_test_and_change_bit(long nr, volatile unsigned long *addr) { … } static __always_inline bool constant_test_bit(long nr, const volatile unsigned long *addr) { … } static __always_inline bool constant_test_bit_acquire(long nr, const volatile unsigned long *addr) { … } static __always_inline bool variable_test_bit(long nr, volatile const unsigned long *addr) { … } static __always_inline bool arch_test_bit(unsigned long nr, const volatile unsigned long *addr) { … } static __always_inline bool arch_test_bit_acquire(unsigned long nr, const volatile unsigned long *addr) { … } static __always_inline unsigned long variable__ffs(unsigned long word) { … } /** * __ffs - find first set bit in word * @word: The word to search * * Undefined if no bit exists, so code should check against 0 first. */ #define __ffs(word) … static __always_inline unsigned long variable_ffz(unsigned long word) { … } /** * ffz - find first zero bit in word * @word: The word to search * * Undefined if no zero exists, so code should check against ~0UL first. */ #define ffz(word) … /* * __fls: find last set bit in word * @word: The word to search * * Undefined if no set bit exists, so code should check against 0 first. */ static __always_inline unsigned long __fls(unsigned long word) { … } #undef ADDR #ifdef __KERNEL__ static __always_inline int variable_ffs(int x) { … } /** * ffs - find first set bit in word * @x: the word to search * * This is defined the same way as the libc and compiler builtin ffs * routines, therefore differs in spirit from the other bitops. * * ffs(value) returns 0 if value is 0 or the position of the first * set bit if value is nonzero. The first (least significant) bit * is at position 1. */ #define ffs(x) … /** * fls - find last set bit in word * @x: the word to search * * This is defined in a similar way as the libc and compiler builtin * ffs, but returns the position of the most significant set bit. * * fls(value) returns 0 if value is 0 or the position of the last * set bit if value is nonzero. The last (most significant) bit is * at position 32. */ static __always_inline int fls(unsigned int x) { … } /** * fls64 - find last set bit in a 64-bit word * @x: the word to search * * This is defined in a similar way as the libc and compiler builtin * ffsll, but returns the position of the most significant set bit. * * fls64(value) returns 0 if value is 0 or the position of the last * set bit if value is nonzero. The last (most significant) bit is * at position 64. */ #ifdef CONFIG_X86_64 static __always_inline int fls64(__u64 x) { … } #else #include <asm-generic/bitops/fls64.h> #endif #include <asm-generic/bitops/sched.h> #include <asm/arch_hweight.h> #include <asm-generic/bitops/const_hweight.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/ext2-atomic-setbit.h> #endif /* __KERNEL__ */ #endif /* _ASM_X86_BITOPS_H */
Codebase Browser
linux