Release 4.12 include/linux/bitops.h

Directory: include/linux
#ifndef _LINUX_BITOPS_H

#define _LINUX_BITOPS_H
#include <asm/types.h>

#ifdef	__KERNEL__

#define BIT(nr)			(1UL << (nr))

#define BIT_ULL(nr)		(1ULL << (nr))

#define BIT_MASK(nr)		(1UL << ((nr) % BITS_PER_LONG))

#define BIT_WORD(nr)		((nr) / BITS_PER_LONG)

#define BIT_ULL_MASK(nr)	(1ULL << ((nr) % BITS_PER_LONG_LONG))

#define BIT_ULL_WORD(nr)	((nr) / BITS_PER_LONG_LONG)

#define BITS_PER_BYTE		8

#define BITS_TO_LONGS(nr)	DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
#endif

/*
 * Create a contiguous bitmask starting at bit position @l and ending at
 * position @h. For example
 * GENMASK_ULL(39, 21) gives us the 64bit vector 0x000000ffffe00000.
 */

#define GENMASK(h, l) \
	(((~0UL) << (l)) & (~0UL >> (BITS_PER_LONG - 1 - (h))))


#define GENMASK_ULL(h, l) \
	(((~0ULL) << (l)) & (~0ULL >> (BITS_PER_LONG_LONG - 1 - (h))))

extern unsigned int __sw_hweight8(unsigned int w);
extern unsigned int __sw_hweight16(unsigned int w);
extern unsigned int __sw_hweight32(unsigned int w);
extern unsigned long __sw_hweight64(__u64 w);

/*
 * Include this here because some architectures need generic_ffs/fls in
 * scope
 */
#include <asm/bitops.h>


#define for_each_set_bit(bit, addr, size) \
	for ((bit) = find_first_bit((addr), (size));            \
             (bit) < (size);                                    \
             (bit) = find_next_bit((addr), (size), (bit) + 1))

/* same as for_each_set_bit() but use bit as value to start with */

#define for_each_set_bit_from(bit, addr, size) \
	for ((bit) = find_next_bit((addr), (size), (bit));      \
             (bit) < (size);                                    \
             (bit) = find_next_bit((addr), (size), (bit) + 1))


#define for_each_clear_bit(bit, addr, size) \
	for ((bit) = find_first_zero_bit((addr), (size));       \
             (bit) < (size);                                    \
             (bit) = find_next_zero_bit((addr), (size), (bit) + 1))

/* same as for_each_clear_bit() but use bit as value to start with */

#define for_each_clear_bit_from(bit, addr, size) \
	for ((bit) = find_next_zero_bit((addr), (size), (bit)); \
             (bit) < (size);                                    \
             (bit) = find_next_zero_bit((addr), (size), (bit) + 1))



static inline int get_bitmask_order(unsigned int count)
{
	int order;

	order = fls(count);
	return order;	/* We could be slightly more clever with -1 here... */
}

Contributors
Person Tokens Prop Commits CommitProp
Pavel Machek 23 92.00% 1 33.33%
Yoshinori Sato 1 4.00% 1 33.33%
Denys Vlasenko 1 4.00% 1 33.33%
Total 25 100.00% 3 100.00%



static __always_inline unsigned long hweight_long(unsigned long w)
{
	return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
}

Contributors
Person Tokens Prop Commits CommitProp
Andrew Morton 27 90.00% 1 33.33%
Akinobu Mita 2 6.67% 1 33.33%
Denys Vlasenko 1 3.33% 1 33.33%
Total 30 100.00% 3 100.00%

/**
 * rol64 - rotate a 64-bit value left
 * @word: value to rotate
 * @shift: bits to roll
 */


static inline __u64 rol64(__u64 word, unsigned int shift)
{
	return (word << shift) | (word >> (64 - shift));
}

Contributors
Person Tokens Prop Commits CommitProp
Alexey Dobriyan 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/**
 * ror64 - rotate a 64-bit value right
 * @word: value to rotate
 * @shift: bits to roll
 */


static inline __u64 ror64(__u64 word, unsigned int shift)
{
	return (word >> shift) | (word << (64 - shift));
}

Contributors
Person Tokens Prop Commits CommitProp
Alexey Dobriyan 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/**
 * rol32 - rotate a 32-bit value left
 * @word: value to rotate
 * @shift: bits to roll
 */


static inline __u32 rol32(__u32 word, unsigned int shift)
{
	return (word << shift) | (word >> ((-shift) & 31));
}

Contributors
Person Tokens Prop Commits CommitProp
Matt Mackall 30 88.24% 2 66.67%
Sasha Levin 4 11.76% 1 33.33%
Total 34 100.00% 3 100.00%

/**
 * ror32 - rotate a 32-bit value right
 * @word: value to rotate
 * @shift: bits to roll
 */


static inline __u32 ror32(__u32 word, unsigned int shift)
{
	return (word >> shift) | (word << (32 - shift));
}

Contributors
Person Tokens Prop Commits CommitProp
Matt Mackall 31 100.00% 2 100.00%
Total 31 100.00% 2 100.00%

/**
 * rol16 - rotate a 16-bit value left
 * @word: value to rotate
 * @shift: bits to roll
 */


static inline __u16 rol16(__u16 word, unsigned int shift)
{
	return (word << shift) | (word >> (16 - shift));
}

Contributors
Person Tokens Prop Commits CommitProp
Harvey Harrison 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/**
 * ror16 - rotate a 16-bit value right
 * @word: value to rotate
 * @shift: bits to roll
 */


static inline __u16 ror16(__u16 word, unsigned int shift)
{
	return (word >> shift) | (word << (16 - shift));
}

Contributors
Person Tokens Prop Commits CommitProp
Harvey Harrison 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/**
 * rol8 - rotate an 8-bit value left
 * @word: value to rotate
 * @shift: bits to roll
 */


static inline __u8 rol8(__u8 word, unsigned int shift)
{
	return (word << shift) | (word >> (8 - shift));
}

Contributors
Person Tokens Prop Commits CommitProp
Harvey Harrison 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/**
 * ror8 - rotate an 8-bit value right
 * @word: value to rotate
 * @shift: bits to roll
 */


static inline __u8 ror8(__u8 word, unsigned int shift)
{
	return (word >> shift) | (word << (8 - shift));
}

Contributors
Person Tokens Prop Commits CommitProp
Harvey Harrison 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/**
 * sign_extend32 - sign extend a 32-bit value using specified bit as sign-bit
 * @value: value to sign extend
 * @index: 0 based bit index (0<=index<32) to sign bit
 *
 * This is safe to use for 16- and 8-bit types as well.
 */


static inline __s32 sign_extend32(__u32 value, int index)
{
	__u8 shift = 31 - index;
	return (__s32)(value << shift) >> shift;
}

Contributors
Person Tokens Prop Commits CommitProp
Andreas Herrmann 24 75.00% 1 50.00%
Martin Kepplinger 8 25.00% 1 50.00%
Total 32 100.00% 2 100.00%

/**
 * sign_extend64 - sign extend a 64-bit value using specified bit as sign-bit
 * @value: value to sign extend
 * @index: 0 based bit index (0<=index<64) to sign bit
 */


static inline __s64 sign_extend64(__u64 value, int index)
{
	__u8 shift = 63 - index;
	return (__s64)(value << shift) >> shift;
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Kepplinger 24 75.00% 1 50.00%
Andreas Herrmann 8 25.00% 1 50.00%
Total 32 100.00% 2 100.00%



static inline unsigned fls_long(unsigned long l)
{
	if (sizeof(l) == 4)
		return fls(l);
	return fls64(l);
}

Contributors
Person Tokens Prop Commits CommitProp
Andrew Morton 32 100.00% 1 100.00%
Total 32 100.00% 1 100.00%



static inline int get_count_order(unsigned int count)
{
	int order;

	order = fls(count) - 1;
	if (count & (count - 1))
		order++;
	return order;
}

Contributors
Person Tokens Prop Commits CommitProp
zijun_hu 39 100.00% 1 100.00%
Total 39 100.00% 1 100.00%

/**
 * get_count_order_long - get order after rounding @l up to power of 2
 * @l: parameter
 *
 * it is same as get_count_order() but with long type parameter
 */


static inline int get_count_order_long(unsigned long l)
{
	if (l == 0UL)
		return -1;
	else if (l & (l - 1UL))
		return (int)fls_long(l);
	else
		return (int)fls_long(l) - 1;
}

Contributors
Person Tokens Prop Commits CommitProp
zijun_hu 53 100.00% 1 100.00%
Total 53 100.00% 1 100.00%

/**
 * __ffs64 - find first set bit in a 64 bit word
 * @word: The 64 bit word
 *
 * On 64 bit arches this is a synomyn for __ffs
 * The result is not defined if no bits are set, so check that @word
 * is non-zero before calling this.
 */


static inline unsigned long __ffs64(u64 word)
{
#if BITS_PER_LONG == 32
	if (((u32)word) == 0UL)
		return __ffs((u32)(word >> 32)) + 32;
#elif BITS_PER_LONG != 64
#error BITS_PER_LONG not 32 or 64
#endif
	return __ffs((unsigned long)word);
}

Contributors
Person Tokens Prop Commits CommitProp
Steven Whitehouse 62 100.00% 1 100.00%
Total 62 100.00% 1 100.00%

#ifdef __KERNEL__

#ifndef set_mask_bits

#define set_mask_bits(ptr, _mask, _bits)	\
({                                                              \
        const typeof(*ptr) mask = (_mask), bits = (_bits);      \
        typeof(*ptr) old, new;                                  \
                                                                \
        do {                                                    \
                old = ACCESS_ONCE(*ptr);                        \
                new = (old & ~mask) | bits;                     \
        } while (cmpxchg(ptr, old, new) != old);                \
                                                                \
        new;                                                    \
})
#endif

#ifndef bit_clear_unless

#define bit_clear_unless(ptr, _clear, _test)	\
({                                                              \
        const typeof(*ptr) clear = (_clear), test = (_test);    \
        typeof(*ptr) old, new;                                  \
                                                                \
        do {                                                    \
                old = ACCESS_ONCE(*ptr);                        \
                new = old & ~clear;                             \
        } while (!(old & test) &&                               \
                 cmpxchg(ptr, old, new) != old);                \
                                                                \
        !(old & test);                                          \
})
#endif

#ifndef find_last_bit
/**
 * find_last_bit - find the last set bit in a memory region
 * @addr: The address to start the search at
 * @size: The number of bits to search
 *
 * Returns the bit number of the last set bit, or size.
 */
extern unsigned long find_last_bit(const unsigned long *addr,
				   unsigned long size);
#endif

#endif /* __KERNEL__ */
#endif
Overall Contributors
Person Tokens Prop Commits CommitProp
Harvey Harrison 128 15.74% 1 2.70%
zijun_hu 93 11.44% 1 2.70%
Alexey Dobriyan 64 7.87% 1 2.70%
Steven Whitehouse 63 7.75% 1 2.70%
Matt Mackall 61 7.50% 2 5.41%
Andrew Morton 60 7.38% 2 5.41%
Akinobu Mita 45 5.54% 5 13.51%
Borislav Petkov 39 4.80% 1 2.70%
Martin Kepplinger 34 4.18% 2 5.41%
Andreas Herrmann 32 3.94% 1 2.70%
Jiri Slaby 30 3.69% 2 5.41%
Pavel Machek 25 3.08% 1 2.70%
Srinivas Pandruvada 21 2.58% 1 2.70%
Rusty Russell 18 2.21% 1 2.70%
Theodore Y. Ts'o 17 2.09% 1 2.70%
Chen Gong 17 2.09% 1 2.70%
Guoqing Jiang 17 2.09% 1 2.70%
Shannon Nelson 10 1.23% 1 2.70%
Linus Torvalds (pre-git) 8 0.98% 1 2.70%
Eric Dumazet 7 0.86% 1 2.70%
David Howells 4 0.49% 1 2.70%
Alexander van Heukelum 4 0.49% 1 2.70%
Sasha Levin 4 0.49% 1 2.70%
Maxime Coquelin 4 0.49% 1 2.70%
Robert P. J. Day 2 0.25% 1 2.70%
Denys Vlasenko 2 0.25% 1 2.70%
Robert Richter 2 0.25% 1 2.70%
Yoshinori Sato 1 0.12% 1 2.70%
Yury Norov 1 0.12% 1 2.70%
Total 813 100.00% 37 100.00%
Directory: include/linux

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Pavel Machek	23	92.00%	1	33.33%
Yoshinori Sato	1	4.00%	1	33.33%
Denys Vlasenko	1	4.00%	1	33.33%
Total	25	100.00%	3	100.00%
cregit-Linux how code gets into the kernel

Release 4.12 include/linux/bitops.h

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
