mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-14 15:36:40 +07:00
652050aec9
Arjan van de Ven <arjan@infradead.org> Mark a number of functions as 'must inline'. The functions affected by this patch need to be inlined because they use knowledge that their arguments are constant so that most of the function optimizes away. At this point this patch does not change behavior, it's for documentation only (and for future patches in the inline series) Signed-off-by: Ingo Molnar <mingo@elte.hu> Signed-off-by: Arjan van de Ven <arjan@infradead.org> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
469 lines
12 KiB
C
469 lines
12 KiB
C
#ifndef _I386_BITOPS_H
|
|
#define _I386_BITOPS_H
|
|
|
|
/*
|
|
* Copyright 1992, Linus Torvalds.
|
|
*/
|
|
|
|
#include <linux/config.h>
|
|
#include <linux/compiler.h>
|
|
|
|
/*
|
|
* 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).
|
|
*/
|
|
|
|
#ifdef CONFIG_SMP
|
|
#define LOCK_PREFIX "lock ; "
|
|
#else
|
|
#define LOCK_PREFIX ""
|
|
#endif
|
|
|
|
#define ADDR (*(volatile long *) addr)
|
|
|
|
/**
|
|
* set_bit - Atomically set a bit in memory
|
|
* @nr: the bit to set
|
|
* @addr: the address to start counting from
|
|
*
|
|
* This function is atomic and may not be reordered. See __set_bit()
|
|
* if you do not require the atomic guarantees.
|
|
*
|
|
* Note: there are no guarantees that this function will not be reordered
|
|
* on non x86 architectures, so if you are writting portable code,
|
|
* make sure not to rely on its reordering guarantees.
|
|
*
|
|
* 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(int nr, volatile unsigned long * addr)
|
|
{
|
|
__asm__ __volatile__( LOCK_PREFIX
|
|
"btsl %1,%0"
|
|
:"+m" (ADDR)
|
|
:"Ir" (nr));
|
|
}
|
|
|
|
/**
|
|
* __set_bit - Set a bit in memory
|
|
* @nr: the bit to set
|
|
* @addr: the address to start counting from
|
|
*
|
|
* Unlike set_bit(), this function is non-atomic and may be reordered.
|
|
* If it's called on the same region of memory simultaneously, the effect
|
|
* may be that only one operation succeeds.
|
|
*/
|
|
static inline void __set_bit(int nr, volatile unsigned long * addr)
|
|
{
|
|
__asm__(
|
|
"btsl %1,%0"
|
|
:"+m" (ADDR)
|
|
:"Ir" (nr));
|
|
}
|
|
|
|
/**
|
|
* clear_bit - Clears a bit in memory
|
|
* @nr: Bit to clear
|
|
* @addr: Address to start counting from
|
|
*
|
|
* clear_bit() is atomic and may not be reordered. However, it does
|
|
* not contain a memory barrier, so if it is used for locking purposes,
|
|
* you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
|
|
* in order to ensure changes are visible on other processors.
|
|
*/
|
|
static inline void clear_bit(int nr, volatile unsigned long * addr)
|
|
{
|
|
__asm__ __volatile__( LOCK_PREFIX
|
|
"btrl %1,%0"
|
|
:"+m" (ADDR)
|
|
:"Ir" (nr));
|
|
}
|
|
|
|
static inline void __clear_bit(int nr, volatile unsigned long * addr)
|
|
{
|
|
__asm__ __volatile__(
|
|
"btrl %1,%0"
|
|
:"+m" (ADDR)
|
|
:"Ir" (nr));
|
|
}
|
|
#define smp_mb__before_clear_bit() barrier()
|
|
#define smp_mb__after_clear_bit() barrier()
|
|
|
|
/**
|
|
* __change_bit - Toggle a bit in memory
|
|
* @nr: the bit to change
|
|
* @addr: the address to start counting from
|
|
*
|
|
* Unlike change_bit(), this function is non-atomic and may be reordered.
|
|
* If it's called on the same region of memory simultaneously, the effect
|
|
* may be that only one operation succeeds.
|
|
*/
|
|
static inline void __change_bit(int nr, volatile unsigned long * addr)
|
|
{
|
|
__asm__ __volatile__(
|
|
"btcl %1,%0"
|
|
:"+m" (ADDR)
|
|
:"Ir" (nr));
|
|
}
|
|
|
|
/**
|
|
* change_bit - Toggle a bit in memory
|
|
* @nr: Bit to change
|
|
* @addr: Address to start counting from
|
|
*
|
|
* change_bit() is atomic and may not be reordered. It may be
|
|
* reordered on other architectures than x86.
|
|
* 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(int nr, volatile unsigned long * addr)
|
|
{
|
|
__asm__ __volatile__( LOCK_PREFIX
|
|
"btcl %1,%0"
|
|
:"+m" (ADDR)
|
|
:"Ir" (nr));
|
|
}
|
|
|
|
/**
|
|
* test_and_set_bit - Set a bit and return its old value
|
|
* @nr: Bit to set
|
|
* @addr: Address to count from
|
|
*
|
|
* This operation is atomic and cannot be reordered.
|
|
* It may be reordered on other architectures than x86.
|
|
* It also implies a memory barrier.
|
|
*/
|
|
static inline int test_and_set_bit(int nr, volatile unsigned long * addr)
|
|
{
|
|
int oldbit;
|
|
|
|
__asm__ __volatile__( LOCK_PREFIX
|
|
"btsl %2,%1\n\tsbbl %0,%0"
|
|
:"=r" (oldbit),"+m" (ADDR)
|
|
:"Ir" (nr) : "memory");
|
|
return oldbit;
|
|
}
|
|
|
|
/**
|
|
* __test_and_set_bit - Set a bit and return its old value
|
|
* @nr: Bit to set
|
|
* @addr: Address to count from
|
|
*
|
|
* This operation is non-atomic and can be reordered.
|
|
* If two examples of this operation race, one can appear to succeed
|
|
* but actually fail. You must protect multiple accesses with a lock.
|
|
*/
|
|
static inline int __test_and_set_bit(int nr, volatile unsigned long * addr)
|
|
{
|
|
int oldbit;
|
|
|
|
__asm__(
|
|
"btsl %2,%1\n\tsbbl %0,%0"
|
|
:"=r" (oldbit),"+m" (ADDR)
|
|
:"Ir" (nr));
|
|
return oldbit;
|
|
}
|
|
|
|
/**
|
|
* test_and_clear_bit - Clear a bit and return its old value
|
|
* @nr: Bit to clear
|
|
* @addr: Address to count from
|
|
*
|
|
* This operation is atomic and cannot be reordered.
|
|
* It can be reorderdered on other architectures other than x86.
|
|
* It also implies a memory barrier.
|
|
*/
|
|
static inline int test_and_clear_bit(int nr, volatile unsigned long * addr)
|
|
{
|
|
int oldbit;
|
|
|
|
__asm__ __volatile__( LOCK_PREFIX
|
|
"btrl %2,%1\n\tsbbl %0,%0"
|
|
:"=r" (oldbit),"+m" (ADDR)
|
|
:"Ir" (nr) : "memory");
|
|
return oldbit;
|
|
}
|
|
|
|
/**
|
|
* __test_and_clear_bit - Clear a bit and return its old value
|
|
* @nr: Bit to clear
|
|
* @addr: Address to count from
|
|
*
|
|
* This operation is non-atomic and can be reordered.
|
|
* If two examples of this operation race, one can appear to succeed
|
|
* but actually fail. You must protect multiple accesses with a lock.
|
|
*/
|
|
static inline int __test_and_clear_bit(int nr, volatile unsigned long *addr)
|
|
{
|
|
int oldbit;
|
|
|
|
__asm__(
|
|
"btrl %2,%1\n\tsbbl %0,%0"
|
|
:"=r" (oldbit),"+m" (ADDR)
|
|
:"Ir" (nr));
|
|
return oldbit;
|
|
}
|
|
|
|
/* WARNING: non atomic and it can be reordered! */
|
|
static inline int __test_and_change_bit(int nr, volatile unsigned long *addr)
|
|
{
|
|
int oldbit;
|
|
|
|
__asm__ __volatile__(
|
|
"btcl %2,%1\n\tsbbl %0,%0"
|
|
:"=r" (oldbit),"+m" (ADDR)
|
|
:"Ir" (nr) : "memory");
|
|
return oldbit;
|
|
}
|
|
|
|
/**
|
|
* test_and_change_bit - Change a bit and return its old value
|
|
* @nr: Bit to change
|
|
* @addr: Address to count from
|
|
*
|
|
* This operation is atomic and cannot be reordered.
|
|
* It also implies a memory barrier.
|
|
*/
|
|
static inline int test_and_change_bit(int nr, volatile unsigned long* addr)
|
|
{
|
|
int oldbit;
|
|
|
|
__asm__ __volatile__( LOCK_PREFIX
|
|
"btcl %2,%1\n\tsbbl %0,%0"
|
|
:"=r" (oldbit),"+m" (ADDR)
|
|
:"Ir" (nr) : "memory");
|
|
return oldbit;
|
|
}
|
|
|
|
#if 0 /* Fool kernel-doc since it doesn't do macros yet */
|
|
/**
|
|
* test_bit - Determine whether a bit is set
|
|
* @nr: bit number to test
|
|
* @addr: Address to start counting from
|
|
*/
|
|
static int test_bit(int nr, const volatile void * addr);
|
|
#endif
|
|
|
|
static __always_inline int constant_test_bit(int nr, const volatile unsigned long *addr)
|
|
{
|
|
return ((1UL << (nr & 31)) & (addr[nr >> 5])) != 0;
|
|
}
|
|
|
|
static inline int variable_test_bit(int nr, const volatile unsigned long * addr)
|
|
{
|
|
int oldbit;
|
|
|
|
__asm__ __volatile__(
|
|
"btl %2,%1\n\tsbbl %0,%0"
|
|
:"=r" (oldbit)
|
|
:"m" (ADDR),"Ir" (nr));
|
|
return oldbit;
|
|
}
|
|
|
|
#define test_bit(nr,addr) \
|
|
(__builtin_constant_p(nr) ? \
|
|
constant_test_bit((nr),(addr)) : \
|
|
variable_test_bit((nr),(addr)))
|
|
|
|
#undef ADDR
|
|
|
|
/**
|
|
* find_first_zero_bit - find the first zero bit in a memory region
|
|
* @addr: The address to start the search at
|
|
* @size: The maximum size to search
|
|
*
|
|
* Returns the bit-number of the first zero bit, not the number of the byte
|
|
* containing a bit.
|
|
*/
|
|
static inline int find_first_zero_bit(const unsigned long *addr, unsigned size)
|
|
{
|
|
int d0, d1, d2;
|
|
int res;
|
|
|
|
if (!size)
|
|
return 0;
|
|
/* This looks at memory. Mark it volatile to tell gcc not to move it around */
|
|
__asm__ __volatile__(
|
|
"movl $-1,%%eax\n\t"
|
|
"xorl %%edx,%%edx\n\t"
|
|
"repe; scasl\n\t"
|
|
"je 1f\n\t"
|
|
"xorl -4(%%edi),%%eax\n\t"
|
|
"subl $4,%%edi\n\t"
|
|
"bsfl %%eax,%%edx\n"
|
|
"1:\tsubl %%ebx,%%edi\n\t"
|
|
"shll $3,%%edi\n\t"
|
|
"addl %%edi,%%edx"
|
|
:"=d" (res), "=&c" (d0), "=&D" (d1), "=&a" (d2)
|
|
:"1" ((size + 31) >> 5), "2" (addr), "b" (addr) : "memory");
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* find_next_zero_bit - find the first zero bit in a memory region
|
|
* @addr: The address to base the search on
|
|
* @offset: The bitnumber to start searching at
|
|
* @size: The maximum size to search
|
|
*/
|
|
int find_next_zero_bit(const unsigned long *addr, int size, int offset);
|
|
|
|
/**
|
|
* __ffs - find first bit in word.
|
|
* @word: The word to search
|
|
*
|
|
* Undefined if no bit exists, so code should check against 0 first.
|
|
*/
|
|
static inline unsigned long __ffs(unsigned long word)
|
|
{
|
|
__asm__("bsfl %1,%0"
|
|
:"=r" (word)
|
|
:"rm" (word));
|
|
return word;
|
|
}
|
|
|
|
/**
|
|
* find_first_bit - find the first set bit in a memory region
|
|
* @addr: The address to start the search at
|
|
* @size: The maximum size to search
|
|
*
|
|
* Returns the bit-number of the first set bit, not the number of the byte
|
|
* containing a bit.
|
|
*/
|
|
static inline unsigned find_first_bit(const unsigned long *addr, unsigned size)
|
|
{
|
|
unsigned x = 0;
|
|
|
|
while (x < size) {
|
|
unsigned long val = *addr++;
|
|
if (val)
|
|
return __ffs(val) + x;
|
|
x += (sizeof(*addr)<<3);
|
|
}
|
|
return x;
|
|
}
|
|
|
|
/**
|
|
* find_next_bit - find the first set bit in a memory region
|
|
* @addr: The address to base the search on
|
|
* @offset: The bitnumber to start searching at
|
|
* @size: The maximum size to search
|
|
*/
|
|
int find_next_bit(const unsigned long *addr, int size, int offset);
|
|
|
|
/**
|
|
* ffz - find first zero in word.
|
|
* @word: The word to search
|
|
*
|
|
* Undefined if no zero exists, so code should check against ~0UL first.
|
|
*/
|
|
static inline unsigned long ffz(unsigned long word)
|
|
{
|
|
__asm__("bsfl %1,%0"
|
|
:"=r" (word)
|
|
:"r" (~word));
|
|
return word;
|
|
}
|
|
|
|
#define fls64(x) generic_fls64(x)
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
/*
|
|
* Every architecture must define this function. It's the fastest
|
|
* way of searching a 140-bit bitmap where the first 100 bits are
|
|
* unlikely to be set. It's guaranteed that at least one of the 140
|
|
* bits is cleared.
|
|
*/
|
|
static inline int sched_find_first_bit(const unsigned long *b)
|
|
{
|
|
if (unlikely(b[0]))
|
|
return __ffs(b[0]);
|
|
if (unlikely(b[1]))
|
|
return __ffs(b[1]) + 32;
|
|
if (unlikely(b[2]))
|
|
return __ffs(b[2]) + 64;
|
|
if (b[3])
|
|
return __ffs(b[3]) + 96;
|
|
return __ffs(b[4]) + 128;
|
|
}
|
|
|
|
/**
|
|
* ffs - find first bit set
|
|
* @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 above ffz (man ffs).
|
|
*/
|
|
static inline int ffs(int x)
|
|
{
|
|
int r;
|
|
|
|
__asm__("bsfl %1,%0\n\t"
|
|
"jnz 1f\n\t"
|
|
"movl $-1,%0\n"
|
|
"1:" : "=r" (r) : "rm" (x));
|
|
return r+1;
|
|
}
|
|
|
|
/**
|
|
* fls - find last bit set
|
|
* @x: the word to search
|
|
*
|
|
* This is defined the same way as ffs.
|
|
*/
|
|
static inline int fls(int x)
|
|
{
|
|
int r;
|
|
|
|
__asm__("bsrl %1,%0\n\t"
|
|
"jnz 1f\n\t"
|
|
"movl $-1,%0\n"
|
|
"1:" : "=r" (r) : "rm" (x));
|
|
return r+1;
|
|
}
|
|
|
|
/**
|
|
* hweightN - returns the hamming weight of a N-bit word
|
|
* @x: the word to weigh
|
|
*
|
|
* The Hamming Weight of a number is the total number of bits set in it.
|
|
*/
|
|
|
|
#define hweight32(x) generic_hweight32(x)
|
|
#define hweight16(x) generic_hweight16(x)
|
|
#define hweight8(x) generic_hweight8(x)
|
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
#define ext2_set_bit(nr,addr) \
|
|
__test_and_set_bit((nr),(unsigned long*)addr)
|
|
#define ext2_set_bit_atomic(lock,nr,addr) \
|
|
test_and_set_bit((nr),(unsigned long*)addr)
|
|
#define ext2_clear_bit(nr, addr) \
|
|
__test_and_clear_bit((nr),(unsigned long*)addr)
|
|
#define ext2_clear_bit_atomic(lock,nr, addr) \
|
|
test_and_clear_bit((nr),(unsigned long*)addr)
|
|
#define ext2_test_bit(nr, addr) test_bit((nr),(unsigned long*)addr)
|
|
#define ext2_find_first_zero_bit(addr, size) \
|
|
find_first_zero_bit((unsigned long*)addr, size)
|
|
#define ext2_find_next_zero_bit(addr, size, off) \
|
|
find_next_zero_bit((unsigned long*)addr, size, off)
|
|
|
|
/* Bitmap functions for the minix filesystem. */
|
|
#define minix_test_and_set_bit(nr,addr) __test_and_set_bit(nr,(void*)addr)
|
|
#define minix_set_bit(nr,addr) __set_bit(nr,(void*)addr)
|
|
#define minix_test_and_clear_bit(nr,addr) __test_and_clear_bit(nr,(void*)addr)
|
|
#define minix_test_bit(nr,addr) test_bit(nr,(void*)addr)
|
|
#define minix_find_first_zero_bit(addr,size) \
|
|
find_first_zero_bit((void*)addr,size)
|
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
#endif /* _I386_BITOPS_H */
|