generic bitops
Subsystems (6)
cover generic bitops
Large number of boilerplate bit operations which are written in C-language are scattered around include/asm-*/bitops.h.
This patch series gathers them into include/asm-generic/bitops/*.h . It will be the benefit to:
- kill duplicated code and comment (about 4000 lines)
- use better C-language equivalents
- help porting new architecture
Major changes since previous version:
- put each class of bitop into its own header file in asm-generic/bitops/
- change __ffs()
- fix warning fix
Todo:
- improve hweight*() routines
--
PATCH 1/44 ia64: use cpu_set() instead of __set_bit()
__set_bit() --> cpu_set() cleanup
arch/ia64/kernel/mca.c | 3 ++- 1 files changed, 2 insertions(+), 1 deletion(-)
Index: 2.6-git/arch/ia64/kernel/mca.c =================================--- 2.6-git.orig/arch/ia64/kernel/mca.c +++ 2.6-git/arch/ia64/kernel/mca.c
@@ -69,6 +69,7 @@
#include <linux/kernel.h>
#include <linux/smp.h>
#include <linux/workqueue.h>
+#include <linux/cpumask.h>
#include <asm/delay.h>
#include <asm/kdebug.h>
@@ -1430,7 +1431,7 @@ format_mca_init_stack(void *mca_data, un
ti->cpu = cpu;
p->thread_info = ti;
p->state = TASK_UNINTERRUPTIBLE;
- __set_bit(cpu, &p->cpus_allowed);
+ cpu_set(cpu, p->cpus_allowed);
INIT_LIST_HEAD(&p->tasks);
p->parent = p->real_parent = p->group_leader = p; INIT_LIST_HEAD(&p->children);
--
PATCH 2/44 parisc: add ()-pair in __ffz() macro
In reply to Akinobu MitaNoticed by Michael Tokarev
add missing ()-pair in __ffz() macro for parisc
include/asm-parisc/bitops.h | 2 +- 1 files changed, 1 insertion(+), 1 deletion(-)
include/asm-parisc/bitops.h +1 -1
@@ -220,7 +220,7 @@ static __inline__ unsigned long __ffs(un }/* Undefined if no bit is zero. */ -#define ffz (x) __ffs(~x) +#define ffz (x) __ffs(~(x))/* * ffs: find first bit set. returns 1 to BITS_PER_LONG or 0 (if none set)
--
PATCH 3/44 cris: remove unnecessary local_irq_restore()
In reply to Akinobu Mitaremove unnecessary local_irq_restore() after cris_atomic_restore() in test_and_set_bit().
include/asm-cris/bitops.h | 1 - 1 files changed, 1 deletion(-)
include/asm-cris/bitops.h +0 -1
@@ -101,7 +101,6 @@ static inline int test_and_set_bit(int n retval = (mask & *adr) !=0 ; *adr |= mask;cris_atomic_restore (addr, flags); -local_irq_restore (flags);return retval; }
--
PATCH 4/44 use non atomic operations for minix_*_bit() and ext2_*_bit()
In reply to Akinobu MitaBitmap functions for the minix filesystem and the ext2 filesystem do not require the atomic guarantees except ext2_set_bit_atomic() and ext2_clear_bit_atomic().
But these are defined by using atomic bit operations on several architectures. (cris, frv, h8300, ia64, m32r, m68k, m68knommu, mips, s390, sh, sh64, sparc,
sparc64, v850, and xtensa)
This patch switches to non atomic bit operation.
include/asm-cris/bitops.h | 8 ++++---- include/asm-frv/bitops.h | 14 +++++++------- include/asm-h8300/bitops.h | 6 +++--- include/asm-ia64/bitops.h | 10 +++++----- include/asm-m32r/bitops.h | 2 +- include/asm-m68k/bitops.h | 10 +++++----- include/asm-m68knommu/bitops.h | 6 +++--- include/asm-mips/bitops.h | 6 +++--- include/asm-s390/bitops.h | 10 +++++----- include/asm-sh/bitops.h | 16 +++++----------- include/asm-sh64/bitops.h | 16 +++++----------- include/asm-sparc/bitops.h | 6 +++--- include/asm-sparc64/bitops.h | 6 +++--- include/asm-v850/bitops.h | 10 +++++----- include/asm-xtensa/bitops.h | 6 +++--- 15 files changed, 60 insertions(+), 72 deletions(-)
include/asm-h8300/bitops.h +3 -3
@@ -397,9 +397,9 @@ found_middle: }/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) test_and_clear_bit(nr,addr) +#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) +#define minix_set_bit (nr,addr) __set_bit(nr,addr) +#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr)#define minix_test_bit (nr,addr) test_bit(nr,addr)#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size)
include/asm-ia64/bitops.h +5 -5
@@ -394,18 +394,18 @@ extern int __find_next_bit(const void *a#define __clear_bit (nr, addr) clear_bit(nr, addr) -#define ext2_set_bit test_and_set_bit +#define ext2_set_bit __test_and_set_bit#define ext2_set_bit_atomic (l,n,a) test_and_set_bit(n,a) -#define ext2_clear_bit test_and_clear_bit +#define ext2_clear_bit __test_and_clear_bit#define ext2_clear_bit_atomic (l,n,a) test_and_clear_bit(n,a)#define ext2_test_bit test_bit#define ext2_find_first_zero_bit find_first_zero_bit#define ext2_find_next_zero_bit find_next_zero_bit/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) test_and_clear_bit(nr,addr) +#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) +#define minix_set_bit (nr,addr) __set_bit(nr,addr) +#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr)#define minix_test_bit (nr,addr) test_bit(nr,addr)#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size)
include/asm-mips/bitops.h +3 -3
@@ -956,9 +956,9 @@ found_middle:* FIXME: These assume that Minix uses the native byte/bitorder. * This limits the Minix filesystem's value for data exchange very much. */ -#define minix_test_and_set_bit (nr,addr) test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) test_and_clear_bit(nr,addr) +#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) +#define minix_set_bit (nr,addr) __set_bit(nr,addr) +#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr)#define minix_test_bit (nr,addr) test_bit(nr,addr)#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size)
include/asm-s390/bitops.h +5 -5
@@ -871,11 +871,11 @@ static inline int sched_find_first_bit(u*/ #define ext2_set_bit (nr, addr) \ - test_and_set_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr) + __test_and_set_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)#define ext2_set_bit_atomic (lock, nr, addr) \ test_and_set_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)#define ext2_clear_bit (nr, addr) \ - test_and_clear_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr) + __test_and_clear_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)#define ext2_clear_bit_atomic (lock, nr, addr) \ test_and_clear_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)#define ext2_test_bit (nr, addr) \
@@ -1014,11 +1014,11 @@ ext2_find_next_zero_bit(void *vaddr, uns/* Bitmap functions for the minix filesystem. */ /* FIXME !!! */ #define minix_test_and_set_bit (nr,addr) \ - test_and_set_bit(nr,(unsigned long *)addr) + __test_and_set_bit(nr,(unsigned long *)addr)#define minix_set_bit (nr,addr) \ - set_bit(nr,(unsigned long *)addr) + __set_bit(nr,(unsigned long *)addr)#define minix_test_and_clear_bit (nr,addr) \ - test_and_clear_bit(nr,(unsigned long *)addr) + __test_and_clear_bit(nr,(unsigned long *)addr)#define minix_test_bit (nr,addr) \ test_bit(nr,(unsigned long *)addr)#define minix_find_first_zero_bit (addr,size) \
include/asm-sh/bitops.h +5 -11
@@ -339,8 +339,8 @@ static inline int sched_find_first_bit(c }#ifdef __LITTLE_ENDIAN__ -#define ext2_set_bit (nr, addr) test_and_set_bit((nr), (addr)) -#define ext2_clear_bit (nr, addr) test_and_clear_bit((nr), (addr)) +#define ext2_set_bit (nr, addr) __test_and_set_bit((nr), (addr)) +#define ext2_clear_bit (nr, addr) __test_and_clear_bit((nr), (addr))#define ext2_test_bit (nr, addr) test_bit((nr), (addr))#define ext2_find_first_zero_bit (addr, size) find_first_zero_bit((addr), (size))#define ext2_find_next_zero_bit (addr, size, offset) \
@@ -349,30 +349,24 @@ static inline int sched_find_first_bit(cstatic __inline__int ext2_set_bit (int nr,volatile void * addr) {int mask, retval; -unsigned long flags;volatile unsigned char *ADDR = (unsigned char *) addr;ADDR += nr >>3 ; mask =1 << (nr &0x07 ); -local_irq_save (flags); retval = (mask & *ADDR ) !=0 ; *ADDR |= mask; -local_irq_restore (flags);return retval; }static __inline__int ext2_clear_bit (int nr,volatile void * addr) {int mask, retval; -unsigned long flags;volatile unsigned char *ADDR = (unsigned char *) addr;ADDR += nr >>3 ; mask =1 << (nr &0x07 ); -local_irq_save (flags); retval = (mask & *ADDR ) !=0 ; *ADDR &= ~mask; -local_irq_restore (flags);return retval; }
@@ -459,9 +453,9 @@ found_middle: })/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) test_and_clear_bit(nr,addr) +#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) +#define minix_set_bit (nr,addr) __set_bit(nr,addr) +#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr)#define minix_test_bit (nr,addr) test_bit(nr,addr)#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size)
include/asm-sh64/bitops.h +5 -11
@@ -382,8 +382,8 @@ static inline int sched_find_first_bit(u#define hweight8 (x) generic_hweight8(x)#ifdef __LITTLE_ENDIAN__ -#define ext2_set_bit (nr, addr) test_and_set_bit((nr), (addr)) -#define ext2_clear_bit (nr, addr) test_and_clear_bit((nr), (addr)) +#define ext2_set_bit (nr, addr) __test_and_set_bit((nr), (addr)) +#define ext2_clear_bit (nr, addr) __test_and_clear_bit((nr), (addr))#define ext2_test_bit (nr, addr) test_bit((nr), (addr))#define ext2_find_first_zero_bit (addr, size) find_first_zero_bit((addr), (size))#define ext2_find_next_zero_bit (addr, size, offset) \
@@ -392,30 +392,24 @@ static inline int sched_find_first_bit(ustatic __inline__int ext2_set_bit (int nr,volatile void * addr) {int mask, retval; -unsigned long flags;volatile unsigned char *ADDR = (unsigned char *) addr;ADDR += nr >>3 ; mask =1 << (nr &0x07 ); -local_irq_save (flags); retval = (mask & *ADDR ) !=0 ; *ADDR |= mask; -local_irq_restore (flags);return retval; }static __inline__int ext2_clear_bit (int nr,volatile void * addr) {int mask, retval; -unsigned long flags;volatile unsigned char *ADDR = (unsigned char *) addr;ADDR += nr >>3 ; mask =1 << (nr &0x07 ); -local_irq_save (flags); retval = (mask & *ADDR ) !=0 ; *ADDR &= ~mask; -local_irq_restore (flags);return retval; }
@@ -502,9 +496,9 @@ found_middle: })/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) test_and_clear_bit(nr,addr) +#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) +#define minix_set_bit (nr,addr) __set_bit(nr,addr) +#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr)#define minix_test_bit (nr,addr) test_bit(nr,addr)#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size)
include/asm-sparc/bitops.h +3 -3
@@ -523,11 +523,11 @@ found_middle:/* Bitmap functions for the minix filesystem. */ #define minix_test_and_set_bit (nr,addr) \ - test_and_set_bit((nr),(unsigned long *)(addr)) + __test_and_set_bit((nr),(unsigned long *)(addr))#define minix_set_bit (nr,addr) \ - set_bit((nr),(unsigned long *)(addr)) + __set_bit((nr),(unsigned long *)(addr))#define minix_test_and_clear_bit (nr,addr) \ - test_and_clear_bit((nr),(unsigned long *)(addr)) + __test_and_clear_bit((nr),(unsigned long *)(addr))#define minix_test_bit (nr,addr) \ test_bit((nr),(unsigned long *)(addr))#define minix_find_first_zero_bit (addr,size) \
include/asm-sparc64/bitops.h +3 -3
@@ -280,11 +280,11 @@ extern unsigned long find_next_zero_le_b/* Bitmap functions for the minix filesystem. */ #define minix_test_and_set_bit (nr,addr) \ - test_and_set_bit((nr),(unsigned long *)(addr)) + __test_and_set_bit((nr),(unsigned long *)(addr))#define minix_set_bit (nr,addr) \ - set_bit((nr),(unsigned long *)(addr)) + __set_bit((nr),(unsigned long *)(addr))#define minix_test_and_clear_bit (nr,addr) \ - test_and_clear_bit((nr),(unsigned long *)(addr)) + __test_and_clear_bit((nr),(unsigned long *)(addr))#define minix_test_bit (nr,addr) \ test_bit((nr),(unsigned long *)(addr))#define minix_find_first_zero_bit (addr,size) \
include/asm-v850/bitops.h +5 -5
@@ -336,18 +336,18 @@ static inline int sched_find_first_bit(u#define hweight16 (x) generic_hweight16 (x)#define hweight8 (x) generic_hweight8 (x) -#define ext2_set_bit test_and_set_bit +#define ext2_set_bit __test_and_set_bit#define ext2_set_bit_atomic (l,n,a) test_and_set_bit(n,a) -#define ext2_clear_bit test_and_clear_bit +#define ext2_clear_bit __test_and_clear_bit#define ext2_clear_bit_atomic (l,n,a) test_and_clear_bit(n,a)#define ext2_test_bit test_bit#define ext2_find_first_zero_bit find_first_zero_bit#define ext2_find_next_zero_bit find_next_zero_bit/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit test_and_set_bit -#define minix_set_bit set_bit -#define minix_test_and_clear_bit test_and_clear_bit +#define minix_test_and_set_bit __test_and_set_bit +#define minix_set_bit __set_bit +#define minix_test_and_clear_bit __test_and_clear_bit#define minix_test_bit test_bit#define minix_find_first_zero_bit find_first_zero_bit
include/asm-xtensa/bitops.h +3 -3
@@ -436,9 +436,9 @@ static inline int sched_find_first_bit(c/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) test_and_clear_bit(nr,addr) +#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) +#define minix_set_bit (nr,addr) __set_bit(nr,addr) +#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr)#define minix_test_bit (nr,addr) test_bit(nr,addr)#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size)
include/asm-m32r/bitops.h +1 -1
@@ -575,7 +575,7 @@ found_middle:*/ #ifdef __LITTLE_ENDIAN__ -#define ext2_set_bit test_and_set_bit +#define ext2_set_bit __test_and_set_bit#define ext2_clear_bit __test_and_clear_bit#define ext2_test_bit test_bit#define ext2_find_first_zero_bit find_first_zero_bit
include/asm-cris/bitops.h +4 -4
@@ -352,17 +352,17 @@ found_middle:#define find_first_bit (addr, size) \ find_next_bit((addr), (size), 0) -#define ext2_set_bit test_and_set_bit +#define ext2_set_bit __test_and_set_bit#define ext2_set_bit_atomic (l,n,a) test_and_set_bit(n,a) -#define ext2_clear_bit test_and_clear_bit +#define ext2_clear_bit __test_and_clear_bit#define ext2_clear_bit_atomic (l,n,a) test_and_clear_bit(n,a)#define ext2_test_bit test_bit#define ext2_find_first_zero_bit find_first_zero_bit#define ext2_find_next_zero_bit find_next_zero_bit/* Bitmap functions for the minix filesystem. */ -#define minix_set_bit (nr,addr) test_and_set_bit(nr,addr) -#define minix_clear_bit (nr,addr) test_and_clear_bit(nr,addr) +#define minix_set_bit (nr,addr) __test_and_set_bit(nr,addr) +#define minix_clear_bit (nr,addr) __test_and_clear_bit(nr,addr)#define minix_test_bit (nr,addr) test_bit(nr,addr)#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size)
include/asm-frv/bitops.h +7 -7
@@ -259,11 +259,11 @@ static inline int sched_find_first_bit(c#define hweight16 (x) generic_hweight16(x)#define hweight8 (x) generic_hweight8(x) -#define ext2_set_bit (nr, addr) test_and_set_bit ((nr) ^ 0x18, (addr)) -#define ext2_clear_bit (nr, addr) test_and_clear_bit((nr) ^ 0x18, (addr)) +#define ext2_set_bit (nr, addr) __test_and_set_bit ((nr) ^ 0x18, (addr)) +#define ext2_clear_bit (nr, addr) __test_and_clear_bit((nr) ^ 0x18, (addr)) -#define ext2_set_bit_atomic (lock,nr,addr) ext2_set_bit((nr), addr) -#define ext2_clear_bit_atomic (lock,nr,addr) ext2_clear_bit((nr), addr) +#define ext2_set_bit_atomic (lock,nr,addr) test_and_set_bit ((nr) ^ 0x18, (addr)) +#define ext2_clear_bit_atomic (lock,nr,addr) test_and_clear_bit((nr) ^ 0x18, (addr))static inline int ext2_test_bit (int nr,const volatile void * addr) {
@@ -331,9 +331,9 @@ found_middle: }/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) ext2_set_bit(nr,addr) -#define minix_set_bit (nr,addr) ext2_set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) ext2_clear_bit(nr,addr) +#define minix_test_and_set_bit (nr,addr) __test_and_set_bit ((nr) ^ 0x18, (addr)) +#define minix_set_bit (nr,addr) __set_bit((nr) ^ 0x18, (addr)) +#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit((nr) ^ 0x18, (addr))#define minix_test_bit (nr,addr) ext2_test_bit(nr,addr)#define minix_find_first_zero_bit (addr,size) ext2_find_first_zero_bit(addr,size)
include/asm-m68k/bitops.h +5 -5
@@ -365,9 +365,9 @@ static inline int minix_find_first_zero_return ((p - addr) <<4 ) + (res ^31 ); } -#define minix_test_and_set_bit (nr, addr) test_and_set_bit((nr) ^ 16, (unsigned long *)(addr)) -#define minix_set_bit (nr,addr) set_bit((nr) ^ 16, (unsigned long *)(addr)) -#define minix_test_and_clear_bit (nr, addr) test_and_clear_bit((nr) ^ 16, (unsigned long *)(addr)) +#define minix_test_and_set_bit (nr, addr) __test_and_set_bit((nr) ^ 16, (unsigned long *)(addr)) +#define minix_set_bit (nr,addr) __set_bit((nr) ^ 16, (unsigned long *)(addr)) +#define minix_test_and_clear_bit (nr, addr) __test_and_clear_bit((nr) ^ 16, (unsigned long *)(addr))static inline int minix_test_bit (int nr,const void *vaddr) {
@@ -377,9 +377,9 @@ static inline int minix_test_bit(int nr,/* Bitmap functions for the ext2 filesystem. */ -#define ext2_set_bit (nr, addr) test_and_set_bit((nr) ^ 24, (unsigned long *)(addr)) +#define ext2_set_bit (nr, addr) __test_and_set_bit((nr) ^ 24, (unsigned long *)(addr))#define ext2_set_bit_atomic (lock, nr, addr) test_and_set_bit((nr) ^ 24, (unsigned long *)(addr)) -#define ext2_clear_bit (nr, addr) test_and_clear_bit((nr) ^ 24, (unsigned long *)(addr)) +#define ext2_clear_bit (nr, addr) __test_and_clear_bit((nr) ^ 24, (unsigned long *)(addr))#define ext2_clear_bit_atomic (lock, nr, addr) test_and_clear_bit((nr) ^ 24, (unsigned long *)(addr))static inline int ext2_test_bit (int nr,const void *vaddr)
include/asm-m68knommu/bitops.h +3 -3
@@ -476,9 +476,9 @@ found_middle: }/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) test_and_clear_bit(nr,addr) +#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) +#define minix_set_bit (nr,addr) __set_bit(nr,addr) +#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr)#define minix_test_bit (nr,addr) test_bit(nr,addr)#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size)
--
PATCH 5/44 generic {,test_and_}{set,clear,change}_bit()
In reply to Akinobu MitaThis patch introduces the C-language equivalents of the functions below:
void set_bit(int nr, volatile unsigned long *addr); void clear_bit(int nr, volatile unsigned long *addr); void change_bit(int nr, volatile unsigned long *addr); int test_and_set_bit(int nr, volatile unsigned long *addr); int test_and_clear_bit(int nr, volatile unsigned long *addr); int test_and_change_bit(int nr, volatile unsigned long *addr);
In include/asm-generic/bitops/atomic.h
This code largely copied from:
include/asm-powerpc/bitops.hinclude/asm-parisc/bitops.hinclude/asm-parisc/atomic.h
include/asm-generic/bitops/atomic.h | 191 ++++++++++++++++++++++++++++++++++++ 1 files changed, 191 insertions(+)
include/asm-generic/bitops/atomic.h new file +191 -0
@@ -0,0 +1,191 @@ +#ifndef _ASM_GENERIC_BITOPS_ATOMIC_H_ +#define _ASM_GENERIC_BITOPS_ATOMIC_H_ + +#include <asm/types.h> + +#define BITOP_MASK (nr) (1UL << ((nr) % BITS_PER_LONG)) +#define BITOP_WORD (nr) ((nr) / BITS_PER_LONG) + +#ifdef CONFIG_SMP +#include <asm/spinlock.h> +#include <asm/cache.h> /* we use L1_CACHE_BYTES */ + +/* Use an array of spinlocks for our atomic_ts. +* Hash function to index into a different SPINLOCK. +* Since "a" is usually an address, use one spinlock per cacheline. +*/ +# define ATOMIC_HASH_SIZE 4 +# define ATOMIC_HASH (a) (&(__atomic_hash[ (((unsigned long) a)/L1_CACHE_BYTES) & (ATOMIC_HASH_SIZE-1) ])) + +extern raw_spinlock_t __atomic_hash[ATOMIC_HASH_SIZE] __lock_aligned; + +/* Can't use raw_spin_lock_irq because of #include problems, so +* this is the substitute */ +#define _atomic_spin_lock_irqsave (l,f) do { \ + raw_spinlock_t *s = ATOMIC_HASH(l); \ + local_irq_save(f); \ + __raw_spin_lock(s); \ +} while(0) + +#define _atomic_spin_unlock_irqrestore (l,f) do { \ + raw_spinlock_t *s = ATOMIC_HASH(l); \ + __raw_spin_unlock(s); \ + local_irq_restore(f); \ +} while(0) + + +#else +# define _atomic_spin_lock_irqsave (l,f) do { local_irq_save(f); } while (0) +# define _atomic_spin_unlock_irqrestore (l,f) do { local_irq_restore(f); } while (0) +#endif + +/* +* NMI events can occur at any time, including when interrupts have been +* disabled by *_irqsave(). So you can get NMI events occurring while a +* *_bit fucntion is holding a spin lock. If the NMI handler also wants +* to do bit manipulation (and they do) then you can get a deadlock +* between the original caller of *_bit() and the NMI handler. +* +* by Keith Owens +*/ + +/** +* 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) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); +unsigned long flags; + +_atomic_spin_lock_irqsave (p, flags); + *p |= mask; +_atomic_spin_unlock_irqrestore (p, flags); +} + +/** +* 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) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); +unsigned long flags; + +_atomic_spin_lock_irqsave (p, flags); + *p &= ~mask; +_atomic_spin_unlock_irqrestore (p, flags); +} + +/** +* 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) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); +unsigned long flags; + +_atomic_spin_lock_irqsave (p, flags); + *p ^= mask; +_atomic_spin_unlock_irqrestore (p, flags); +} + +/** +* 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) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); +unsigned long old; +unsigned long flags; + +_atomic_spin_lock_irqsave (p, flags); + old = *p; + *p = old | mask; +_atomic_spin_unlock_irqrestore (p, flags); + +return (old & mask) !=0 ; +} + +/** +* 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) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); +unsigned long old; +unsigned long flags; + +_atomic_spin_lock_irqsave (p, flags); + old = *p; + *p = old & ~mask; +_atomic_spin_unlock_irqrestore (p, flags); + +return (old & mask) !=0 ; +} + +/** +* 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) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); +unsigned long old; +unsigned long flags; + +_atomic_spin_lock_irqsave (p, flags); + old = *p; + *p = old ^ mask; +_atomic_spin_unlock_irqrestore (p, flags); + +return (old & mask) !=0 ; +} + +#endif /* _ASM_GENERIC_BITOPS_ATOMIC_H */
--
Re: [patch 05/44] generic {,test_and_}{set,clear,change}_bit()
hoi :)
include/asm-generic/bitops/atomic.h line 76
Quoted 10 lines · Akinobu Mita
include/asm-generic/bitops/atomic.h new file +10
-0+static __inline__void set_bit (int nr,volatile unsigned long *addr) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); +unsigned long flags; + +_atomic_spin_lock_irqsave (p, flags); + *p |= mask; +_atomic_spin_unlock_irqrestore (p, flags); +}
You could even use your new generic non-atomic bitops to implement these
Signature · 1 line
Martin Waitz
Re: [patch 05/44] generic {,test_and_}{set,clear,change}_bit()
Quoted 13 lines · Martin Waitz
include/asm-generic/bitops/atomic.h line 76
Quoted 10 lines · Akinobu Mita
include/asm-generic/bitops/atomic.h new file +10
-0+static __inline__void set_bit (int nr,volatile unsigned long *addr) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); +unsigned long flags; + +_atomic_spin_lock_irqsave (p, flags); + *p |= mask; +_atomic_spin_unlock_irqrestore (p, flags); +}You could even use your new generic non-atomic bitops to implement these
Depends - to do so would increase the amount of code within the locked region, which raises the probability of contention since the locked time becomes longer.
Signature · 3 lines
Russell King Linux kernel 2.6 ARM Linux - http://www.arm.linux.org.uk/ maintainer of: 2.6 Serial core
PATCH 6/44 generic __{,test_and_}{set,clear,change}_bit() and test_bit()
In reply to Akinobu MitaThis patch introduces the C-language equivalents of the functions below:
void __set_bit(int nr, volatile unsigned long *addr); void __clear_bit(int nr, volatile unsigned long *addr); void __change_bit(int nr, volatile unsigned long *addr); int __test_and_set_bit(int nr, volatile unsigned long *addr); int __test_and_clear_bit(int nr, volatile unsigned long *addr); int __test_and_change_bit(int nr, volatile unsigned long *addr); int test_bit(int nr, const volatile unsigned long *addr);
In include/asm-generic/bitops/non-atomic.h
This code largely copied from:asm-powerpc/bitops.h
include/asm-generic/bitops/non-atomic.h | 111 ++++++++++++++++++++++++++++++++ 1 files changed, 111 insertions(+)
include/asm-generic/bitops/non-atomic.h new file +111 -0
@@ -0,0 +1,111 @@ +#ifndef _ASM_GENERIC_BITOPS_NON_ATOMIC_H_ +#define _ASM_GENERIC_BITOPS_NON_ATOMIC_H_ + +#include <asm/types.h> + +#define BITOP_MASK (nr) (1UL << ((nr) % BITS_PER_LONG)) +#define BITOP_WORD (nr) ((nr) / BITS_PER_LONG) + +/** +* __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) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); + + *p |= mask; +} + +static __inline__void __clear_bit (int nr,volatile unsigned long *addr) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); + + *p &= ~mask; +} + +/** +* __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) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); + + *p ^= mask; +} + +/** +* __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) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); +unsigned long old = *p; + + *p = old | mask; +return (old & mask) !=0 ; +} + +/** +* __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) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); +unsigned long old = *p; + + *p = old & ~mask; +return (old & mask) !=0 ; +} + +/* WARNING: non atomic and it can be reordered! */ +static __inline__int __test_and_change_bit (int nr, +volatile unsigned long *addr) +{ +unsigned long mask =BITOP_MASK (nr); +unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); +unsigned long old = *p; + + *p = old ^ mask; +return (old & mask) !=0 ; +} + +/** +* test_bit - Determine whether a bit is set +* @nr: bit number to test +* @addr: Address to start counting from +*/ +static __inline__ int test_bit(int nr, __const__ volatile unsigned long *addr) +{ +return 1UL & (addr[BITOP_WORD (nr)] >> (nr & (BITS_PER_LONG -1 ))); +} + +#endif /* _ASM_GENERIC_BITOPS_NON_ATOMIC_H_ */
--
PATCH 7/44 generic __ffs()
In reply to Akinobu MitaThis patch introduces the C-language equivalent of the function:
unsigned long __ffs(unsigned long word);
In include/asm-generic/bitops/__ffs.h
This code largely copied from:include/asm-sparc/bitops.h
include/asm-generic/bitops/__ffs.h | 43 +++++++++++++++++++++++++++++++++++++ 1 files changed, 43 insertions(+)
include/asm-generic/bitops/__ffs.h new file +43 -0
@@ -0,0 +1,43 @@ +#ifndef _ASM_GENERIC_BITOPS___FFS_H_ +#define _ASM_GENERIC_BITOPS___FFS_H_ + +#include <asm/types.h> + +/** +* __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) +{ +int num =0 ; + +#if BITS_PER_LONG ==64 +if ((word &0xffffffff ) ==0 ) { + num +=32 ; + word >>=32 ; + } +#endif +if ((word &0xffff ) ==0 ) { + num +=16 ; + word >>=16 ; + } +if ((word &0xff ) ==0 ) { + num +=8 ; + word >>=8 ; + } +if ((word &0xf ) ==0 ) { + num +=4 ; + word >>=4 ; + } +if ((word &0x3 ) ==0 ) { + num +=2 ; + word >>=2 ; + } +if ((word &0x1 ) ==0 ) + num +=1 ; +return num; +} + +#endif /* _ASM_GENERIC_BITOPS___FFS_H_ */
--
PATCH 8/44 generic ffz()
In reply to Akinobu MitaThis patch introduces the C-language equivalent of the function:
unsigned long ffz(unsigned long word);
In include/asm-generic/bitops/ffz.h
This code largely copied from:include/asm-parisc/bitops.h
include/asm-generic/bitops/ffz.h | 12 ++++++++++++ 1 files changed, 12 insertions(+)
include/asm-generic/bitops/ffz.h new file +12 -0
@@ -0,0 +1,12 @@ +#ifndef _ASM_GENERIC_BITOPS_FFZ_H_ +#define _ASM_GENERIC_BITOPS_FFZ_H_ + +/* +* ffz - find first zero in word. +* @word: The word to search +* +* Undefined if no zero exists, so code should check against ~0UL first. +*/ +#define ffz (x) __ffs(~(x)) + +#endif /* _ASM_GENERIC_BITOPS_FFZ_H_ */
--
PATCH 9/44 generic fls()
In reply to Akinobu MitaThis patch introduces the C-language equivalent of the function:
int fls(int x);
In include/asm-generic/bitops/fls.h
This code largely copied from:include/linux/bitops.h
include/asm-generic/bitops/fls.h | 41 +++++++++++++++++++++++++++++++++++++++ 1 files changed, 41 insertions(+)
include/asm-generic/bitops/fls.h new file +41 -0
@@ -0,0 +1,41 @@ +#ifndef _ASM_GENERIC_BITOPS_FLS_H_ +#define _ASM_GENERIC_BITOPS_FLS_H_ + +/** +* fls - find last (most-significant) bit set +* @x: the word to search +* +* This is defined the same way as ffs. +* Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32. +*/ + +static __inline__int fls (int x) +{ +int r =32 ; + +if (!x) +return 0 ; +if (!(x &0xffff0000u )) { + x <<=16 ; + r -=16 ; + } +if (!(x &0xff000000u )) { + x <<=8 ; + r -=8 ; + } +if (!(x &0xf0000000u )) { + x <<=4 ; + r -=4 ; + } +if (!(x &0xc0000000u )) { + x <<=2 ; + r -=2 ; + } +if (!(x &0x80000000u )) { + x <<=1 ; + r -=1 ; + } +return r; +} + +#endif /* _ASM_GENERIC_BITOPS_FLS_H_ */
--
PATCH 10/44 generic fls64()
In reply to Akinobu MitaThis patch introduces the C-language equivalent of the function:
int fls64(__u64 x);
In include/asm-generic/bitops/fls64.h
This code largely copied from:include/linux/bitops.h
include/asm-generic/bitops/fls64.h | 12 ++++++++++++ 1 files changed, 12 insertions(+)
Index: 2.6-git/include/asm-generic/bitops/fls64.h
=================================--- /dev/null
+++ 2.6-git/include/asm-generic/bitops/fls64.h
@@ -0,0 +1,12 @@
+#ifndef _ASM_GENERIC_BITOPS_FLS64_H_
+#define _ASM_GENERIC_BITOPS_FLS64_H_
+
+static inline int fls64(__u64 x)
+{
+ __u32 h = x >> 32;
+ if (h)
+ return fls(x) + 32;
+ return fls(x);
+}
+
+#endif /* _ASM_GENERIC_BITOPS_FLS64_H_ */
--
PATCH 11/44 generic find_{next,first}{,_zero}_bit()
In reply to Akinobu MitaThis patch introduces the C-language equivalents of the functions below:
unsigned logn find_next_bit(const unsigned long *addr, unsigned long size,
unsigned long offset);
unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
unsigned long offset);
unsigned long find_first_zero_bit(const unsigned long *addr,
unsigned long size);unsigned long find_first_bit(const unsigned long *addr, unsigned long size);
In include/asm-generic/bitops/find.h
This code largely copied from:arch/powerpc/lib/bitops.c
include/asm-generic/bitops/find.h | 99 ++++++++++++++++++++++++++++++++++++++ 1 files changed, 99 insertions(+)
Index: 2.6-git/include/asm-generic/bitops/find.h =================================--- /dev/null
+++ 2.6-git/include/asm-generic/bitops/find.h
@@ -0,0 +1,99 @@
+#ifndef _ASM_GENERIC_BITOPS_FIND_H_
+#define _ASM_GENERIC_BITOPS_FIND_H_
+
+#include <asm/types.h>
+
+#define BITOP_WORD(nr) ((nr) / BITS_PER_LONG)
+
+/**
+ * find_next_bit - find the next 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
+ */
+static inline unsigned long find_next_bit(const unsigned long *addr,
+ unsigned long size, unsigned long offset)
+{
+ const unsigned long *p = addr + BITOP_WORD(offset);
+ unsigned long result = offset & ~(BITS_PER_LONG-1);
+ unsigned long tmp;
+
+ if (offset >= size)
+ return size;
+ size -= result;
+ offset %= BITS_PER_LONG;
+ if (offset) {
+ tmp = *(p++);
+ tmp &= (~0UL << offset);
+ if (size < BITS_PER_LONG)
+ goto found_first;
+ if (tmp)
+ goto found_middle;
+ size -= BITS_PER_LONG;
+ result += BITS_PER_LONG;
+ }
+ while (size & ~(BITS_PER_LONG-1)) {
+ if ((tmp = *(p++)))
+ goto found_middle;
+ result += BITS_PER_LONG;
+ size -= BITS_PER_LONG;
+ }
+ if (!size)
+ return result;
+ tmp = *p;
+
+found_first:
+ tmp &= (~0UL >> (BITS_PER_LONG - size));
+ if (tmp = 0UL) /* Are any bits set? */
+ return result + size; /* Nope. */
+found_middle:
+ return result + __ffs(tmp);
+}
+
+/*
+ * This implementation of find_{first,next}_zero_bit was stolen from
+ * Linus' asm-alpha/bitops.h.
+ */
+static inline unsigned long find_next_zero_bit(const unsigned long *addr,
+ unsigned long size, unsigned long offset)
+{
+ const unsigned long *p = addr + BITOP_WORD(offset);
+ unsigned long result = offset & ~(BITS_PER_LONG-1);
+ unsigned long tmp;
+
+ if (offset >= size)
+ return size;
+ size -= result;
+ offset %= BITS_PER_LONG;
+ if (offset) {
+ tmp = *(p++);
+ tmp |= ~0UL >> (BITS_PER_LONG - offset);
+ if (size < BITS_PER_LONG)
+ goto found_first;
+ if (~tmp)
+ goto found_middle;
+ size -= BITS_PER_LONG;
+ result += BITS_PER_LONG;
+ }
+ while (size & ~(BITS_PER_LONG-1)) {
+ if (~(tmp = *(p++)))
+ goto found_middle;
+ result += BITS_PER_LONG;
+ size -= BITS_PER_LONG;
+ }
+ if (!size)
+ return result;
+ tmp = *p;
+
+found_first:
+ tmp |= ~0UL << size;
+ if (tmp = ~0UL) /* Are any bits zero? */
+ return result + size; /* Nope. */
+found_middle:
+ return result + ffz(tmp);
+}
+
+#define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0) +#define find_first_bit(addr, size) find_next_bit((addr), (size), 0) +
+#endif /*_ASM_GENERIC_BITOPS_FIND_H_ */
--
Re: [patch 11/44] generic find_{next,first}{,_zero}_bit()
Quoted 9 lines · Akinobu Mita
This patch introduces the C-language equivalents of the functions below:
unsigned logn find_next_bit(const unsigned long *addr, unsigned long size,
unsigned long offset); unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size, unsigned long offset); unsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size);unsigned long
find_first_bit(const unsigned long *addr, unsigned long size);
These big functions should perhaps be out of line.
David
Re: [patch 11/44] generic find_{next,first}{,_zero}_bit()
Quoted 12 lines · David Howells
Quoted 9 lines · Akinobu Mita
This patch introduces the C-language equivalents of the functions below:
unsigned logn find_next_bit(const unsigned long *addr, unsigned long size,
unsigned long offset); unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size, unsigned long offset); unsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size);unsigned long
find_first_bit(const unsigned long *addr, unsigned long size);
Quoted 1 line
These big functions should perhaps be out of line.
Yes. I'll make them and below out of line.
- hweight*()
- ext2_find_*_zero_bit()
- minix_find_first_zero_bit()
PATCH 12/44 generic sched_find_first_bit()
In reply to Akinobu MitaThis patch introduces the C-language equivalent of the function:
int sched_find_first_bit(const unsigned long *b);
In include/asm-generic/bitops/sched.h
This code largely copied from:include/asm-powerpc/bitops.h
include/asm-generic/bitops/sched.h | 36 ++++++++++++++++++++++++++++++++++++ 1 files changed, 36 insertions(+)
Index: 2.6-git/include/asm-generic/bitops/sched.h =================================--- /dev/null
+++ 2.6-git/include/asm-generic/bitops/sched.h
@@ -0,0 +1,36 @@
+#ifndef _ASM_GENERIC_BITOPS_SCHED_H_
+#define _ASM_GENERIC_BITOPS_SCHED_H_
+
+#include <linux/compiler.h> /* unlikely() */
+#include <asm/types.h>
+
+/*
+ * 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 BITS_PER_LONG = 64
+ if (unlikely(b[0]))
+ return __ffs(b[0]);
+ if (unlikely(b[1]))
+ return __ffs(b[1]) + 64;
+ return __ffs(b[2]) + 128;
+#elif BITS_PER_LONG = 32
+ 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;
+#else
+#error BITS_PER_LONG not defined
+#endif
+}
+
+#endif /* _ASM_GENERIC_BITOPS_SCHED_H_ */
--
Re: [parisc-linux] [patch 12/44] generic sched_find_first_bit()
Quoted 2 lines · Akinobu Mita
This patch introduces the C-language equivalent of the function:
intsched_find_first_bit(const unsigned long *b);
Akinobu, would you prefer this is a slightly cleaner way? (Not compile tested)
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]) + BITS_PER_LONG;
#if BITS_PER_LONG == 32
if (unlikely(b[2]))
return __ffs(b[2]) + 64;
if (b[3])
return __ffs(b[3]) + 96;
#endif
return __ffs(b[128/BITS_PER_LONG]) + 128;
}If BITS_PER_LONG isn't defined, the link step will fail and point at a some unknown .o as the offender. But it's the responsibility of the header file to make sure it's including the BITS_PER_LONG definition, not the code that calls sched_find_first_bit().
hth,
grant
Re: [parisc-linux] [patch 12/44] generic sched_find_first_bit()
In reply to Akinobu MitaQuoted 2 lines · Akinobu Mita
This patch introduces the C-language equivalent of the function:
intsched_find_first_bit(const unsigned long *b);
Akinobu, would you prefer this is a slightly cleaner way? (Not compile tested)
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]) + BITS_PER_LONG;
#if BITS_PER_LONG == 32
if (unlikely(b[2]))
return __ffs(b[2]) + 64;
if (b[3])
return __ffs(b[3]) + 96;
#endif
return __ffs(b[128/BITS_PER_LONG]) + 128;
}If BITS_PER_LONG isn't defined, the link step will fail and point at a some unknown .o as the offender. But it's the responsibility of the header file to make sure it's including the BITS_PER_LONG definition, not the code that calls sched_find_first_bit().
hth,
grant
_______________________________________________
parisc-linux mailing list
[email protected]
http://lists.parisc-linux.org/mailman/listinfo/parisc-linux
PATCH 13/44 generic ffs()
In reply to Akinobu MitaThis patch introduces the C-language equivalent of the function:
int ffs(int x);
In include/asm-generic/bitops/ffs.h
This code largely copied from:include/linux/bitops.h
include/asm-generic/bitops/ffs.h | 41 +++++++++++++++++++++++++++++++++++++++ 1 files changed, 41 insertions(+)
Index: 2.6-git/include/asm-generic/bitops/ffs.h =================================--- /dev/null +++ 2.6-git/include/asm-generic/bitops/ffs.h
@@ -0,0 +1,41 @@
+#ifndef _ASM_GENERIC_BITOPS_FFS_H_
+#define _ASM_GENERIC_BITOPS_FFS_H_
+
+/**
+ * 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 = 1;
+
+ if (!x)
+ return 0;
+ if (!(x & 0xffff)) {
+ x >>= 16;
+ r += 16;
+ }
+ if (!(x & 0xff)) {
+ x >>= 8;
+ r += 8;
+ }
+ if (!(x & 0xf)) {
+ x >>= 4;
+ r += 4;
+ }
+ if (!(x & 3)) {
+ x >>= 2;
+ r += 2;
+ }
+ if (!(x & 1)) {
+ x >>= 1;
+ r += 1;
+ }
+ return r;
+}
+
+#endif /* _ASM_GENERIC_BITOPS_FFS_H_ */
--
PATCH 14/44 generic hweight{64,32,16,8}()
In reply to Akinobu MitaThis patch introduces the C-language equivalents of the functions below:
unsigned int hweight32(unsigned int w); unsigned int hweight16(unsigned int w); unsigned int hweight8(unsigned int w); unsigned long hweight64(__u64 w);
In include/asm-generic/bitops/hweight.h
This code largely copied from:include/linux/bitops.h
include/asm-generic/bitops/hweight.h | 54 +++++++++++++++++++++++++++++++++++ 1 files changed, 54 insertions(+)
Index: 2.6-git/include/asm-generic/bitops/hweight.h =================================--- /dev/null
+++ 2.6-git/include/asm-generic/bitops/hweight.h
@@ -0,0 +1,54 @@
+#ifndef _ASM_GENERIC_BITOPS_HWEIGHT_H_
+#define _ASM_GENERIC_BITOPS_HWEIGHT_H_
+
+#include <asm/types.h>
+
+/**
+ * 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.
+ */
+
+static inline unsigned int hweight32(unsigned int w)
+{
+ unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555); + res = (res & 0x33333333) + ((res >> 2) & 0x33333333); + res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F); + res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF); + return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF);
+}
+
+static inline unsigned int hweight16(unsigned int w) +{
+ unsigned int res = (w & 0x5555) + ((w >> 1) & 0x5555); + res = (res & 0x3333) + ((res >> 2) & 0x3333); + res = (res & 0x0F0F) + ((res >> 4) & 0x0F0F); + return (res & 0x00FF) + ((res >> 8) & 0x00FF);
+}
+
+static inline unsigned int hweight8(unsigned int w) +{
+ unsigned int res = (w & 0x55) + ((w >> 1) & 0x55); + res = (res & 0x33) + ((res >> 2) & 0x33); + return (res & 0x0F) + ((res >> 4) & 0x0F);
+}
+
+static inline unsigned long hweight64(__u64 w) +{
+#if BITS_PER_LONG = 32
+ return hweight32((unsigned int)(w >> 32)) + hweight32((unsigned int)w);
+#elif BITS_PER_LONG = 64
+ u64 res;
+ res = (w & 0x5555555555555555ul) + ((w >> 1) & 0x5555555555555555ul);
+ res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
+ res = (res & 0x0F0F0F0F0F0F0F0Ful) + ((res >> 4) & 0x0F0F0F0F0F0F0F0Ful);
+ res = (res & 0x00FF00FF00FF00FFul) + ((res >> 8) & 0x00FF00FF00FF00FFul);
+ res = (res & 0x0000FFFF0000FFFFul) + ((res >> 16) & 0x0000FFFF0000FFFFul);
+ return (res & 0x00000000FFFFFFFFul) + ((res >> 32) & 0x00000000FFFFFFFFul);
+#else
+#error BITS_PER_LONG not defined +#endif
+}
+
+#endif /* _ASM_GENERIC_BITOPS_HWEIGHT_H_ */
--
Re: [patch 14/44] generic hweight{64,32,16,8}()
Review
Quoted 8 lines · Akinobu Mita
(quoted diff) +8
-0+static inline unsigned int hweight32(unsigned int w) +{ + unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555); + res = (res & 0x33333333) + ((res >> 2) & 0x33333333); + res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F); + res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF); + return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF); +}
How large are these functions on x86? Maybe it would be better to not inline them, but put it into some C file out of line.
-Andi
Re: [patch 14/44] generic hweight{64,32,16,8}()
Quoted 3 lines · Andi Kleen
Quoted 1 line · Akinobu Mita
+static inline unsigned int hweight32(unsigned int w)
[]
Quoted 2 lines
How large are these functions on x86? Maybe it would be better to not inline them, but put it into some C file out of line.
hweight8 47 bytes
hweight16 76 bytes
hweight32 97 bytes
hweight64 56 bytes (NOT inlining hweight32)
hweight64 197 bytes (inlining hweight32)
Those are when compiled as separate non-inlined functions, with pushl %ebp and ret.
/mjt
Re: [patch 14/44] generic hweight{64,32,16,8}()
Quoted 8 lines · Michael Tokarev
Quoted 3 lines · Andi Kleen
Quoted 1 line · Akinobu Mita
+static inline unsigned int hweight32(unsigned int w)
[]
Quoted 2 lines
How large are these functions on x86? Maybe it would be better to not inline them, but put it into some C file out of line.
Quoted 8 lines
hweight8 47 bytes
hweight16 76 bytes
hweight32 97 bytes
hweight64 56 bytes (NOT inlining hweight32)
hweight64 197 bytes (inlining hweight32)Those are when compiled as separate non-inlined functions, with pushl %ebp and ret.
This would argue for moving them out of line.
-Andi
Re: [patch 14/44] generic hweight{64,32,16,8}()
Quoted 15 lines · Andi Kleen
Quoted 14 lines · Michael Tokarev
Quoted 3 lines · Andi Kleen
Quoted 1 line · Akinobu Mita
+static inline unsigned int hweight32(unsigned int w)
[]
Quoted 2 lines
How large are these functions on x86? Maybe it would be better to not inline them, but put it into some C file out of line.
hweight8 47 bytes
hweight16 76 bytes
hweight32 97 bytes
hweight64 56 bytes (NOT inlining hweight32)
hweight64 197 bytes (inlining hweight32)
Quoted 4 lines
Quoted 2 lines
Those are when compiled as separate non-inlined functions, with pushl %ebp and ret.
This would argue for moving them out of line.
This patch will put hweight*() into lib/hweight.c
include/asm-generic/bitops/hweight.h +4 -49
@@ -1,54 +1,9 @@#ifndef _ASM_GENERIC_BITOPS_HWEIGHT_H_#define _ASM_GENERIC_BITOPS_HWEIGHT_H_ -#include <asm/types.h> - -/** -* 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. -*/ - -static inline unsigned int hweight32 (unsigned int w) -{ -unsigned int res = (w &0x55555555 ) + ((w >>1 ) &0x55555555 ); - res = (res &0x33333333 ) + ((res >>2 ) &0x33333333 ); - res = (res &0x0F0F0F0F ) + ((res >>4 ) &0x0F0F0F0F ); - res = (res &0x00FF00FF ) + ((res >>8 ) &0x00FF00FF ); -return (res &0x0000FFFF ) + ((res >>16 ) &0x0000FFFF ); -} - -static inline unsigned int hweight16 (unsigned int w) -{ -unsigned int res = (w &0x5555 ) + ((w >>1 ) &0x5555 ); - res = (res &0x3333 ) + ((res >>2 ) &0x3333 ); - res = (res &0x0F0F ) + ((res >>4 ) &0x0F0F ); -return (res &0x00FF ) + ((res >>8 ) &0x00FF ); -} - -static inline unsigned int hweight8 (unsigned int w) -{ -unsigned int res = (w &0x55 ) + ((w >>1 ) &0x55 ); - res = (res &0x33 ) + ((res >>2 ) &0x33 ); -return (res &0x0F ) + ((res >>4 ) &0x0F ); -} - -static inline unsigned long hweight64 (__u64 w) -{ -#if BITS_PER_LONG ==32 -return hweight32 ((unsigned int )(w >>32 )) +hweight32 ((unsigned int )w); -#elif BITS_PER_LONG ==64 -u64 res; - res = (w &0x5555555555555555ul ) + ((w >>1 ) &0x5555555555555555ul ); - res = (res &0x3333333333333333ul ) + ((res >>2 ) &0x3333333333333333ul ); - res = (res &0x0F0F0F0F0F0F0F0Ful ) + ((res >>4 ) &0x0F0F0F0F0F0F0F0Ful ); - res = (res &0x00FF00FF00FF00FFul ) + ((res >>8 ) &0x00FF00FF00FF00FFul ); - res = (res &0x0000FFFF0000FFFFul ) + ((res >>16 ) &0x0000FFFF0000FFFFul ); -return (res &0x00000000FFFFFFFFul ) + ((res >>32 ) &0x00000000FFFFFFFFul ); -#else -#error BITS_PER_LONG not defined -#endif -} +extern unsigned int hweight32 (unsigned int w); +extern unsigned int hweight16 (unsigned int w); +extern unsigned int hweight8 (unsigned int w); +extern unsigned long hweight64 (__u64 w);#endif /* _ASM_GENERIC_BITOPS_HWEIGHT_H_ */
lib/Makefile +1 -1
@@ -5,7 +5,7 @@ lib-y := errno.o ctype.o string.o vsprintf.o cmdline.o \ bust_spinlocks.o rbtree.o radix-tree.o dump_stack.o \ idr.o div64.o int_sqrt.o bitmap.o extable.o prio_tree.o \ - sha1.o + sha1.o hweight.o lib-y += kobject.o kref.o kobject_uevent.o klist.o
lib/hweight.c new file +54 -0
54 lines not on this page · raw message
PATCH 1/1 alpha: remove __alpha_cix__ and __alpha_fix__
Quoted 1 line · mita
This patch will put hweight*() into
lib/hweight.c
I realized that this patch broke ia64 and alpha.
I want to fix it by making new config option like CONFIG_GENERIC_HWEIGHT. But there is a difficulty to define CONFIG_GENERIC_HWEIGHT on alpha. So I want to add the patch below. Does it cause anything bad?
arch/alpha/lib/ev6-memchr.S +1 -1
@@ -84,7 +84,7 @@ $last_quad: beq $2, $not_found # U : U L U L $found_it: -#if defined(__alpha_fix__) && defined(__alpha_cix__) +#ifdef CONFIG_ALPHA_EV67 /* * Since we are guaranteed to have set one of the bits, we don't * have to worry about coming back with a 0x40 out of cttz...
arch/alpha/lib/fpreg.c +4 -4
@@ -4,7 +4,7 @@* (C) Copyright 1998 Linus Torvalds */ -#if defined(__alpha_cix__) || defined(__alpha_fix__) +#if defined(CONFIG_ALPHA_EV6 ) || defined(CONFIG_ALPHA_EV67 )#define STT (reg,val) asm volatile ("ftoit $f"#reg",%0" : "=r"(val));#else #define STT (reg,val) asm volatile ("stt $f"#reg",%0" : "=m"(val));
@@ -53,7 +53,7 @@ alpha_read_fp_reg (unsigned long reg)return val; } -#if defined(__alpha_cix__) || defined(__alpha_fix__) +#if defined(CONFIG_ALPHA_EV6 ) || defined(CONFIG_ALPHA_EV67 )#define LDT (reg,val) asm volatile ("itoft %0,$f"#reg : : "r"(val));#else #define LDT (reg,val) asm volatile ("ldt $f"#reg",%0" : : "m"(val));
@@ -98,7 +98,7 @@ alpha_write_fp_reg (unsigned long reg, u } } -#if defined(__alpha_cix__) || defined(__alpha_fix__) +#if defined(CONFIG_ALPHA_EV6 ) || defined(CONFIG_ALPHA_EV67 )#define STS (reg,val) asm volatile ("ftois $f"#reg",%0" : "=r"(val));#else #define STS (reg,val) asm volatile ("sts $f"#reg",%0" : "=m"(val));
@@ -147,7 +147,7 @@ alpha_read_fp_reg_s (unsigned long reg)return val; } -#if defined(__alpha_cix__) || defined(__alpha_fix__) +#if defined(CONFIG_ALPHA_EV6 ) || defined(CONFIG_ALPHA_EV67 )#define LDS (reg,val) asm volatile ("itofs %0,$f"#reg : : "r"(val));#else #define LDS (reg,val) asm volatile ("lds $f"#reg",%0" : : "m"(val));
include/asm-alpha/bitops.h +5 -5
@@ -261,7 +261,7 @@ static inline unsigned long ffz_b(unsignstatic inline unsigned long ffz (unsigned long word) { -#if defined(__alpha_cix__) && defined(__alpha_fix__) +#if defined(CONFIG_ALPHA_EV6 ) && defined(CONFIG_ALPHA_EV67 )/* Whee. EV67 can calculate it directly. */ return __kernel_cttz (~word);#else
@@ -281,7 +281,7 @@ static inline unsigned long ffz(unsigned*/ static inline unsigned long __ffs (unsigned long word) { -#if defined(__alpha_cix__) && defined(__alpha_fix__) +#if defined(CONFIG_ALPHA_EV6 ) && defined(CONFIG_ALPHA_EV67 )/* Whee. EV67 can calculate it directly. */ return __kernel_cttz (word);#else
@@ -313,7 +313,7 @@ static inline int ffs(int word)/* * fls: find last bit set. */ -#if defined(__alpha_cix__) && defined(__alpha_fix__) +#if defined(CONFIG_ALPHA_EV6 ) && defined(CONFIG_ALPHA_EV67 )static inline int fls (int word) {return 64 -__kernel_ctlz (word &0xffffffff );
@@ -326,7 +326,7 @@ static inline int fls(int word)/* Compute powers of two for the given integer. */ static inline long floor_log2 (unsigned long word) { -#if defined(__alpha_cix__) && defined(__alpha_fix__) +#if defined(CONFIG_ALPHA_EV6 ) && defined(CONFIG_ALPHA_EV67 )return 63 -__kernel_ctlz (word);#else long bit;
@@ -347,7 +347,7 @@ static inline long ceil_log2(unsigned lo* of bits set) of a N-bit word */ -#if defined(__alpha_cix__) && defined(__alpha_fix__) +#if defined(CONFIG_ALPHA_EV6 ) && defined(CONFIG_ALPHA_EV67 )/* Whee. EV67 can calculate it directly. */ static inline unsigned long hweight64 (unsigned long w) {
include/asm-alpha/fpu.h +2 -2
@@ -130,7 +130,7 @@ rdfpcr(void) {unsigned long tmp, ret; -#if defined(__alpha_cix__) || defined(__alpha_fix__) +#if defined(CONFIG_ALPHA_EV6 ) || defined(CONFIG_ALPHA_EV67 ) __asm__ __volatile__ ("ftoit $f0,%0\n\t" "mf_fpcr $f0\n\t"
@@ -154,7 +154,7 @@ wrfpcr(unsigned long val) {unsigned long tmp; -#if defined(__alpha_cix__) || defined(__alpha_fix__) +#if defined(CONFIG_ALPHA_EV6 ) || defined(CONFIG_ALPHA_EV67 ) __asm__ __volatile__ ("ftoit $f0,%0\n\t" "itoft %1,$f0\n\t"
Re: [PATCH] alpha: remove __alpha_cix__ and __alpha_fix__
arch/alpha/lib/ev6-memchr.S $last_quad: · line 87
Quoted 2 lines · Akinobu Mita
arch/alpha/lib/ev6-memchr.S +1
-1-#if defined(__alpha_fix__) && defined(__alpha_cix__) +#ifdef CONFIG_ALPHA_EV67
What in the world is this supposed to fix? You aren't seriously suggesting that the compiler has stopped defining these, have you?
r~
Re: [PATCH] alpha: remove __alpha_cix__ and __alpha_fix__
Quoted 6 lines · Richard Henderson
arch/alpha/lib/ev6-memchr.S $last_quad: · line 87
Quoted 2 lines · Akinobu Mita
arch/alpha/lib/ev6-memchr.S +1
-1-#if defined(__alpha_fix__) && defined(__alpha_cix__) +#ifdef CONFIG_ALPHA_EV67What in the world is this supposed to fix? You aren't seriously suggesting that the compiler has stopped defining these, have you?
I just want to imply the use of optimized hweight*() routines to kbuild system. In other word I want to tell the kbuild system the condition of "defined(__alpha_fix__) && defined(__alpha_cix__)".
So I suggested to add previous patch and write below lines in arch/alpha/Kconfig
config GENERIC_HWEIGHT
bool
default y if !ALPHA_EV6 && !ALPHA_EV67Also, I wonder why there are such gcc builtin definition in kernel code. Even if the gcc built with the support architecture extensions like CIX and FIX, It doesn't mean the vmlinux built by that gcc always run on those machines.
Re: [patch 14/44] generic hweight{64,32,16,8}()
In reply to Akinobu MitaQuoted 31 lines · Akinobu Mita
This patch introduces the C-language equivalents of the functions below:
unsigned int hweight32(unsigned int w); unsigned int hweight16(unsigned int w); unsigned int hweight8(unsigned int w); unsigned long
hweight64(__u64 w);In
include/asm-generic/bitops/hweight.hThis code largely copied from:
include/linux/bitops.hSigned-off-by Akinobu Mita <[email protected]>include/asm-generic/bitops/hweight.h | 54 +++++++++++++++++++++++++++++++++++ 1 files changed, 54 insertions(+)Index:
2.6-git/include/asm-generic/bitops/hweight.h=================================> ---/dev/null+++2.6-git/include/asm-generic/bitops/hweight.h(quoted diff) +10
-0@@ -0,0 +1,54 @@ +#ifndef _ASM_GENERIC_BITOPS_HWEIGHT_H_ +#define _ASM_GENERIC_BITOPS_HWEIGHT_H_ + +#include <asm/types.h> + +/** + * 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.
Review line 20
Quoted 10 lines
(quoted diff) +10
-0+ */ + +static inline unsigned int hweight32(unsigned int w) +{ + unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555); + res = (res & 0x33333333) + ((res >> 2) & 0x33333333); + res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F); + res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF); + return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF); +}
The first step can be implemented slightly better:
unsigned int res = w-((w>>1)&0x55555555);
as I found once on the web[1].
Several of the following steps can also be simplified by omitting the masking when the result can't possibly cause a carry to propagate too far.
This might also have a non negligible impact
on code size.
Quoted 25 lines
(quoted diff) +24
-0+ +static inline unsigned int hweight16(unsigned int w) +{ + unsigned int res = (w & 0x5555) + ((w >> 1) & 0x5555); + res = (res & 0x3333) + ((res >> 2) & 0x3333); + res = (res & 0x0F0F) + ((res >> 4) & 0x0F0F); + return (res & 0x00FF) + ((res >> 8) & 0x00FF); +} + +static inline unsigned int hweight8(unsigned int w) +{ + unsigned int res = (w & 0x55) + ((w >> 1) & 0x55); + res = (res & 0x33) + ((res >> 2) & 0x33); + return (res & 0x0F) + ((res >> 4) & 0x0F); +} + +static inline unsigned long hweight64(__u64 w) +{ +#if BITS_PER_LONG = 32 + return hweight32((unsigned int)(w >> 32)) + hweight32((unsigned int)w); +#elif BITS_PER_LONG = 64 + u64 res; + res = (w & 0x5555555555555555ul) + ((w >> 1) & 0x5555555555555555ul); + res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
Review line 54
Quoted 10 lines
(quoted diff) +10
-0+ res = (res & 0x0F0F0F0F0F0F0F0Ful) + ((res >> 4) & 0x0F0F0F0F0F0F0F0Ful); + res = (res & 0x00FF00FF00FF00FFul) + ((res >> 8) & 0x00FF00FF00FF00FFul); + res = (res & 0x0000FFFF0000FFFFul) + ((res >> 16) & 0x0000FFFF0000FFFFul); + return (res & 0x00000000FFFFFFFFul) + ((res >> 32) & 0x00000000FFFFFFFFul); +#else +#error BITS_PER_LONG not defined +#endif +} + +#endif /* _ASM_GENERIC_BITOPS_HWEIGHT_H_ */
Regards,
Gabriel
[1] It might be better to write the first line
unsigned res = w - ((w&0xaaaaaaaa)>>1);
but I can never remember what the C standard guarantess about right shifts values (very little IIRC). I believe that it will work properly on all architectures that GCC supports, however, and that it will help on many.
Re: [patch 14/44] generic hweight{64,32,16,8}()
Quoted 5 lines · Gabriel Paubert
The first step can be implemented slightly better:
unsigned int res = w-((w>>1)&0x55555555);
Yes. I've got many advices about hweight speedup.
static unsigned int hweight32(unsigned int w)
{
unsigned int res = w - ((w >> 1) & 0x55555555);
res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
res = (res + (res >> 4)) & 0x0F0F0F0F;
res = res + (res >> 8);
return (res + (res >> 16)) & 0x000000FF;
}static unsigned int hweight16(unsigned int w)
{
unsigned int res = w - ((w >> 1) & 0x5555);
res = (res & 0x3333) + ((res >> 2) & 0x3333);
res = (res + (res >> 4)) & 0x0F0F;
return (res + (res >> 8)) & 0x00FF;
}static unsigned int hweight8(unsigned int w)
{
unsigned int res = w - ((w >> 1) & 0x55);
res = (res & 0x33) + ((res >> 2) & 0x33);
return (res + (res >> 4)) & 0x0F;
}static unsigned long hweight64(__u64 w)
{
#if BITS_PER_LONG < 64 return hweight32((unsigned int)(w >> 32)) + hweight32((unsigned int)w); #else __u64 res = w - ((w >> 1) & 0x5555555555555555ul); res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul); res = (res + (res >> 4)) & 0x0F0F0F0F0F0F0F0Ful; res = res + (res >> 8); res = res + (res >> 16); return (res + (res >> 32)) & 0x00000000000000FFul;
#endif
}
Re: [patch 14/44] generic hweight{64,32,16,8}()
In reply to Akinobu MitaQuoted 4 lines · Akinobu Mita
unsigned int hweight32(unsigned int w); unsigned int hweight16(unsigned int w); unsigned int hweight8(unsigned int w); unsigned long
hweight64(__u64 w);
IMHO, this should use explicitly sized integers like __u8, __u16 etc, unless there are stringent reasons like better register use - which is hard to tell for generic C code. Also, why on earth is the returntype for hweight64 a long?
Review
Quoted 4 lines
(quoted diff) +4
-0+static inline unsigned int hweight32(unsigned int w) +{ + unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555); + res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
[...]
Why not use unsigned constants here?
Quoted 2 lines
(quoted diff) +2
-0+static inline unsigned long hweight64(__u64 w) +{
[..]
Review
Quoted 2 lines
(quoted diff) +2
-0+ u64 res; + res = (w & 0x5555555555555555ul) + ((w >> 1) & 0x5555555555555555ul);
Why not use initialisation here, too?
just my 2c
Uli
PATCH 15/44 generic ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
In reply to Akinobu MitaThis patch introduces the C-language equivalents of the functions below:
int ext2_set_bit(int nr, volatile unsigned long *addr); int ext2_clear_bit(int nr, volatile unsigned long *addr); int ext2_test_bit(int nr, const volatile unsigned long *addr); unsigned long ext2_find_first_zero_bit(const unsigned long *addr,
unsigned long size);
unsinged long ext2_find_next_zero_bit(const unsigned long *addr,
unsigned long size);In include/asm-generic/bitops/ext2-non-atomic.h
This code largely copied from:
include/asm-powerpc/bitops.hinclude/asm-parisc/bitops.h
include/asm-generic/bitops/ext2-non-atomic.h | 18 +++ include/asm-generic/bitops/le.h | 126 +++++++++++++++++++++++++++ 2 files changed, 144 insertions(+)
Index: 2.6-git/include/asm-generic/bitops/ext2-non-atomic.h =================================--- /dev/null
+++ 2.6-git/include/asm-generic/bitops/ext2-non-atomic.h
@@ -0,0 +1,18 @@
+#ifndef _ASM_GENERIC_BITOPS_EXT2_NON_ATOMIC_H_
+#define _ASM_GENERIC_BITOPS_EXT2_NON_ATOMIC_H_
+
+#include <asm-generic/bitops/le.h>
+
+#define ext2_set_bit(nr,addr) \
+ generic___test_and_set_le_bit((nr),(unsigned long *)(addr))
+#define ext2_clear_bit(nr,addr) \
+ generic___test_and_clear_le_bit((nr),(unsigned long *)(addr))
+
+#define ext2_test_bit(nr,addr) \
+ generic_test_le_bit((nr),(unsigned long *)(addr))
+#define ext2_find_first_zero_bit(addr, size) \
+ generic_find_first_zero_le_bit((unsigned long *)(addr), (size))
+#define ext2_find_next_zero_bit(addr, size, off) \
+ generic_find_next_zero_le_bit((unsigned long *)(addr), (size), (off))
+
+#endif /* _ASM_GENERIC_BITOPS_EXT2_NON_ATOMIC_H_ */
Index: 2.6-git/include/asm-generic/bitops/le.h =================================--- /dev/null
+++ 2.6-git/include/asm-generic/bitops/le.h
@@ -0,0 +1,126 @@
+#ifndef _ASM_GENERIC_BITOPS_LE_H_
+#define _ASM_GENERIC_BITOPS_LE_H_
+
+#include <asm/types.h>
+#include <asm/byteorder.h>
+
+#define BITOP_WORD(nr) ((nr) / BITS_PER_LONG)
+#define BITOP_LE_SWIZZLE ((BITS_PER_LONG-1) & ~0x7)
+
+#if defined(__LITTLE_ENDIAN)
+
+static __inline__ int generic_test_le_bit(unsigned long nr,
+ __const__ unsigned long *addr)
+{
+ __const__ unsigned char *tmp = (__const__ unsigned char *) addr;
+ return (tmp[nr >> 3] >> (nr & 7)) & 1;
+}
+
+#define generic___set_le_bit(nr, addr) __set_bit(nr, addr)
+#define generic___clear_le_bit(nr, addr) __clear_bit(nr, addr)
+
+#define generic_test_and_set_le_bit(nr, addr) test_and_set_bit(nr, addr) +#define generic_test_and_clear_le_bit(nr, addr) test_and_clear_bit(nr, addr)
+
+#define generic___test_and_set_le_bit(nr, addr) __test_and_set_bit(nr, addr) +#define generic___test_and_clear_le_bit(nr, addr) __test_and_clear_bit(nr, addr) +
+#define generic_find_next_zero_le_bit(addr, size, offset) find_next_zero_bit(addr, size, offset) +
+#elif defined(__BIG_ENDIAN)
+
+static __inline__ int generic_test_le_bit(unsigned long nr,
+ __const__ unsigned long *addr)
+{
+ __const__ unsigned char *tmp = (__const__ unsigned char *) addr;
+ return (tmp[nr >> 3] >> (nr & 7)) & 1;
+}
+
+#define generic___set_le_bit(nr, addr) \
+ __set_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+#define generic___clear_le_bit(nr, addr) \
+ __clear_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+
+#define generic_test_and_set_le_bit(nr, addr) \
+ test_and_set_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+#define generic_test_and_clear_le_bit(nr, addr) \
+ test_and_clear_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+
+#define generic___test_and_set_le_bit(nr, addr) \
+ __test_and_set_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+#define generic___test_and_clear_le_bit(nr, addr) \
+ __test_and_clear_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
+
+/* include/linux/byteorder does not support "unsigned long" type */
+static inline unsigned long ext2_swabp(const unsigned long * x)
+{
+#if BITS_PER_LONG = 64
+ return (unsigned long) __swab64p((u64 *) x);
+#elif BITS_PER_LONG = 32
+ return (unsigned long) __swab32p((u32 *) x);
+#else
+#error BITS_PER_LONG not defined
+#endif
+}
+
+/* include/linux/byteorder doesn't support "unsigned long" type */
+static inline unsigned long ext2_swab(const unsigned long y)
+{
+#if BITS_PER_LONG = 64
+ return (unsigned long) __swab64((u64) y);
+#elif BITS_PER_LONG = 32
+ return (unsigned long) __swab32((u32) y);
+#else
+#error BITS_PER_LONG not defined
+#endif
+}
+
+static __inline__ unsigned long generic_find_next_zero_le_bit(const unsigned long *addr,
+ unsigned long size, unsigned long offset)
+{
+ const unsigned long *p = addr + BITOP_WORD(offset);
+ unsigned long result = offset & ~(BITS_PER_LONG - 1);
+ unsigned long tmp;
+
+ if (offset >= size)
+ return size;
+ size -= result;
+ offset &= (BITS_PER_LONG - 1UL);
+ if (offset) {
+ tmp = ext2_swabp(p++);
+ tmp |= (~0UL >> (BITS_PER_LONG - offset));
+ if (size < BITS_PER_LONG)
+ goto found_first;
+ if (~tmp)
+ goto found_middle;
+ size -= BITS_PER_LONG;
+ result += BITS_PER_LONG;
+ }
+
+ while (size & ~(BITS_PER_LONG - 1)) {
+ if (~(tmp = *(p++)))
+ goto found_middle_swap;
+ result += BITS_PER_LONG;
+ size -= BITS_PER_LONG;
+ }
+ if (!size)
+ return result;
+ tmp = ext2_swabp(p);
+found_first:
+ tmp |= ~0UL << size;
+ if (tmp = ~0UL) /* Are any bits zero? */
+ return result + size; /* Nope. Skip ffz */
+found_middle:
+ return result + ffz(tmp);
+
+found_middle_swap:
+ return result + ffz(ext2_swab(tmp));
+}
+#else
+#error "Please fix <asm/byteorder.h>"
+#endif
+
+#define generic_find_first_zero_le_bit(addr, size) \
+ generic_find_next_zero_le_bit((addr), (size), 0)
+
+#endif /* _ASM_GENERIC_BITOPS_LE_H_ */
--
Re: [patch 15/44] generic ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
Hi,
Review
Quoted 6 lines · Akinobu Mita
(quoted diff) +6
-0+static __inline__ int generic_test_le_bit(unsigned long nr, + __const__ unsigned long *addr) +{ + __const__ unsigned char *tmp = (__const__ unsigned char *) addr; + return (tmp[nr >> 3] >> (nr & 7)) & 1; +}
The underscores are not needed.
For the inline version I would prefer this version:
{
const unsigned char *tmp = (const unsigned char *)addr;
return (tmp[nr >> 3] & (unsigned char)(1 << (nr & 7))) != 0;
}Although this would be a good alternative as well:
{
return (addr[nr >> 5] & (1 << ((nr ^ 24) & 31))) != 0;
}bye, Roman
Re: [patch 15/44] generic ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
Quoted 9 lines · Roman Zippel
Review
Quoted 6 lines
(quoted diff) +6
-0+static __inline__ int generic_test_le_bit(unsigned long nr, + __const__ unsigned long *addr) +{ + __const__ unsigned char *tmp = (__const__ unsigned char *) addr; + return (tmp[nr >> 3] >> (nr & 7)) & 1; +}The underscores are not needed.
Thanks, I converted to 'inline' and 'const'.
Re: [patch 15/44] generic ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
In reply to Roman ZippelQuoted 7 lines · Roman Zippel
For the inline version I would prefer this version:
{ const unsigned char *tmp = (const unsigned char *)addr; return (tmp[nr >> 3] & (unsigned char)(1 << (nr & 7))) != 0; }
Quoted 5 lines
Although this would be a good alternative as well:
{ return (addr[nr >> 5] & (1 << ((nr ^ 24) & 31))) != 0; }
Thanks, maybe I could use BITOP_LE_SWIZZLE similar to other *_le_bit().
#define BITOP_LE_SWIZZLE ((BITS_PER_LONG-1) & ~0x7)
:
#define generic_test_le_bit(nr, addr) test_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
:
#endif /* __BIG_ENDIAN */
PATCH 16/44 generic ext2_{set,clear}_bit_atomic()
In reply to Akinobu MitaThis patch introduces the C-language equivalents of the functions below:
int ext2_set_bit_atomic(int nr, volatile unsigned long *addr); int ext2_clear_bit_atomic(int nr, volatile unsigned long *addr);
In include/asm-generic/bitops/ext2-atomic.h
This code largely copied from:include/asm-sparc/bitops.h
include/asm-generic/bitops/ext2-atomic.h | 22 ++++++++++++++++++++++ 1 files changed, 22 insertions(+)
Index: 2.6-git/include/asm-generic/bitops/ext2-atomic.h =================================--- /dev/null +++ 2.6-git/include/asm-generic/bitops/ext2-atomic.h @@ -0,0 +1,22 @@
+#ifndef _ASM_GENERIC_BITOPS_EXT2_ATOMIC_H_ +#define _ASM_GENERIC_BITOPS_EXT2_ATOMIC_H_
+
+#define ext2_set_bit_atomic(lock, nr, addr) \
+ ({ \
+ int ret; \
+ spin_lock(lock); \
+ ret = ext2_set_bit((nr), (unsigned long *)(addr)); \
+ spin_unlock(lock); \
+ ret; \
+ })
+
+#define ext2_clear_bit_atomic(lock, nr, addr) \
+ ({ \
+ int ret; \
+ spin_lock(lock); \
+ ret = ext2_clear_bit((nr), (unsigned long *)(addr)); \
+ spin_unlock(lock); \
+ ret; \
+ })
+
+#endif /* _ASM_GENERIC_BITOPS_EXT2_ATOMIC_H_ */
--
PATCH 17/44 generic minix_{test,set,test_and_clear,test,find_first_zero}_bit()
In reply to Akinobu MitaThis patch introduces the C-language equivalents of the functions below:
int minix_test_and_set_bit(int nr, volatile unsigned long *addr); int minix_set_bit(int nr, volatile unsigned long *addr); int minix_test_and_clear_bit(int nr, volatile unsigned long *addr); int minix_test_bit(int nr, const volatile unsigned long *addr); unsigned long minix_find_first_zero_bit(const unsigned long *addr,
unsigned long size);
In include/asm-generic/bitops/minix.h
and include/asm-generic/bitops/minix-le.h
This code largely copied from:include/asm-sparc/bitops.h
include/asm-generic/bitops/minix-le.h | 17 +++++++++++++++++ include/asm-generic/bitops/minix.h | 15 +++++++++++++++ 2 files changed, 32 insertions(+)
Index: 2.6-git/include/asm-generic/bitops/minix.h =================================--- /dev/null +++ 2.6-git/include/asm-generic/bitops/minix.h @@ -0,0 +1,15 @@
+#ifndef _ASM_GENERIC_BITOPS_MINIX_H_ +#define _ASM_GENERIC_BITOPS_MINIX_H_
+
+#define minix_test_and_set_bit(nr,addr) \
+ __test_and_set_bit((nr),(unsigned long *)(addr))
+#define minix_set_bit(nr,addr) \
+ __set_bit((nr),(unsigned long *)(addr))
+#define minix_test_and_clear_bit(nr,addr) \
+ __test_and_clear_bit((nr),(unsigned long *)(addr))
+#define minix_test_bit(nr,addr) \
+ test_bit((nr),(unsigned long *)(addr))
+#define minix_find_first_zero_bit(addr,size) \
+ find_first_zero_bit((unsigned long *)(addr),(size))
+
+#endif /* _ASM_GENERIC_BITOPS_MINIX_H_ */
Index: 2.6-git/include/asm-generic/bitops/minix-le.h =================================--- /dev/null +++ 2.6-git/include/asm-generic/bitops/minix-le.h @@ -0,0 +1,17 @@
+#ifndef _ASM_GENERIC_BITOPS_MINIX_LE_H_ +#define _ASM_GENERIC_BITOPS_MINIX_LE_H_
+
+#include <asm-generic/bitops/le.h>
+
+#define minix_test_and_set_bit(nr,addr) \
+ generic___test_and_set_le_bit((nr),(unsigned long *)(addr))
+#define minix_set_bit(nr,addr) \
+ generic___set_le_bit((nr),(unsigned long *)(addr))
+#define minix_test_and_clear_bit(nr,addr) \
+ generic___test_and_clear_le_bit((nr),(unsigned long *)(addr))
+#define minix_test_bit(nr,addr) \
+ generic_test_le_bit((nr),(unsigned long *)(addr))
+#define minix_find_first_zero_bit(addr,size) \
+ generic_find_first_zero_le_bit((unsigned long *)(addr),(size))
+
+#endif /* _ASM_GENERIC_BITOPS_MINIX_LE_H_ */
--
PATCH 18/44 alpha: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- unless defined(__alpha_cix__) and defined(__alpha_fix__)
- remove generic_fls()
- remove generic_hweight{64,32,16,8}()
- remove generic_fls64()
- remove find_{next,first}{,_zero}_bit()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
include/asm-alpha/bitops.h | 204 +-------------------------------------------- 1 files changed, 8 insertions(+), 196 deletions(-)
include/asm-alpha/bitops.h +8 -196
@@ -38,17 +38,6 @@ set_bit(unsigned long nr, volatile void :"Ir" (1UL << (nr & 31)), "m" (*m)); } -/* -* WARNING: non atomic version. -*/ -static inline void -__set_bit (unsigned long nr,volatile void * addr) -{ -int *m = ((int *) addr) + (nr >>5 ); - - *m |=1 << (nr &31 ); -} -#define smp_mb__before_clear_bit () smp_mb()#define smp_mb__after_clear_bit () smp_mb()
@@ -70,17 +59,6 @@ clear_bit(unsigned long nr, volatile voi :"Ir" (1UL << (nr & 31)), "m" (*m)); } -/* -* WARNING: non atomic version. -*/ -static __inline__void -__clear_bit (unsigned long nr,volatile void * addr) -{ -int *m = ((int *) addr) + (nr >>5 ); - - *m &= ~(1 << (nr &31 )); -} -static inline void change_bit (unsigned long nr,volatile void * addr) {
@@ -99,17 +77,6 @@ change_bit(unsigned long nr, volatile vo :"Ir" (1UL << (nr & 31)), "m" (*m)); } -/* -* WARNING: non atomic version. -*/ -static __inline__void -__change_bit (unsigned long nr,volatile void * addr) -{ -int *m = ((int *) addr) + (nr >>5 ); - - *m ^=1 << (nr &31 ); -} -static inline int test_and_set_bit (unsigned long nr,volatile void *addr) {
@@ -137,20 +104,6 @@ test_and_set_bit(unsigned long nr, volatreturn oldbit !=0 ; } -/* -* WARNING: non atomic version. -*/ -static inline int -__test_and_set_bit (unsigned long nr,volatile void * addr) -{ -unsigned long mask =1 << (nr &0x1f ); -int *m = ((int *) addr) + (nr >>5 ); -int old = *m; - - *m = old | mask; -return (old & mask) !=0 ; -} -static inline int test_and_clear_bit (unsigned long nr,volatile void * addr) {
@@ -178,20 +131,6 @@ test_and_clear_bit(unsigned long nr, volreturn oldbit !=0 ; } -/* -* WARNING: non atomic version. -*/ -static inline int -__test_and_clear_bit (unsigned long nr,volatile void * addr) -{ -unsigned long mask =1 << (nr &0x1f ); -int *m = ((int *) addr) + (nr >>5 ); -int old = *m; - - *m = old & ~mask; -return (old & mask) !=0 ; -} -static inline int test_and_change_bit (unsigned long nr,volatile void * addr) {
@@ -217,25 +156,7 @@ test_and_change_bit(unsigned long nr, voreturn oldbit !=0 ; } -/* -* WARNING: non atomic version. -*/ -static __inline__int -__test_and_change_bit (unsigned long nr,volatile void * addr) -{ -unsigned long mask =1 << (nr &0x1f ); -int *m = ((int *) addr) + (nr >>5 ); -int old = *m; - - *m = old ^ mask; -return (old & mask) !=0 ; -} - -static inline int -test_bit (int nr,const volatile void * addr) -{ -return (1UL & (((const int *) addr)[nr >>5 ] >> (nr &31 ))) !=0UL ; -} +#include <asm-generic/bitops/non-atomic.h> /* * ffz = Find First Zero in word. Undefined if no zero exists,
@@ -319,9 +240,9 @@ static inline int fls(int word) return 64 - __kernel_ctlz(word & 0xffffffff); }#else -#define fls generic_fls +#include <asm-generic/bitops/fls.h> #endif -#define fls64 generic_fls64 +#include <asm-generic/bitops/fls64.h> /* Compute powers of two for the given integer. */ static inline long floor_log2 (unsigned long word)
@@ -358,112 +279,12 @@ static inline unsigned long hweight64(un#define hweight16 (x) (unsigned int) hweight64((x) & 0xfffful)#define hweight8 (x) (unsigned int) hweight64((x) & 0xfful)#else -static inline unsigned long hweight64 (unsigned long w) -{ -unsigned long result; -for (result =0 ; w ; w >>=1 ) - result += (w &1 ); -return result; -} - -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) +#include <asm-generic/bitops/hweight.h> #endif #endif /* __KERNEL__ */ -/* -* Find next zero bit in a bitmap reasonably efficiently.. -*/ -static inline unsigned long -find_next_zero_bit (const void *addr,unsigned long size,unsigned long offset) -{ -const unsigned long *p = addr; -unsigned long result = offset & ~63UL ; -unsigned long tmp; - - p += offset >>6 ; -if (offset >= size) -return size; - size -= result; - offset &=63UL ; -if (offset) { - tmp = *(p++); - tmp |= ~0UL >> (64 -offset); -if (size <64 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=64 ; - result +=64 ; - } -while (size & ~63UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=64 ; - size -=64 ; - } -if (!size) -return result; - tmp = *p; - found_first: - tmp |= ~0UL << size; -if (tmp == ~0UL )/* Are any bits zero? */ -return result + size;/* Nope. */ - found_middle: -return result +ffz (tmp); -} - -/* -* Find next one bit in a bitmap reasonably efficiently. -*/ -static inline unsigned long -find_next_bit (const void * addr,unsigned long size,unsigned long offset) -{ -const unsigned long *p = addr; -unsigned long result = offset & ~63UL ; -unsigned long tmp; - - p += offset >>6 ; -if (offset >= size) -return size; - size -= result; - offset &=63UL ; -if (offset) { - tmp = *(p++); - tmp &= ~0UL << offset; -if (size <64 ) - goto found_first; -if (tmp) - goto found_middle; - size -=64 ; - result +=64 ; - } -while (size & ~63UL ) { -if ((tmp = *(p++))) - goto found_middle; - result +=64 ; - size -=64 ; - } -if (!size) -return result; - tmp = *p; - found_first: - tmp &= ~0UL >> (64 - size); -if (!tmp) -return result + size; - found_middle: -return result +__ffs (tmp); -} - -/* -* The optimizer actually does good code for this case. -*/ -#define find_first_zero_bit (addr, size) \ - find_next_zero_bit((addr), (size), 0) -#define find_first_bit (addr, size) \ - find_next_bit((addr), (size), 0) +#include <asm-generic/bitops/find.h> #ifdef __KERNEL__
@@ -487,21 +308,12 @@ sched_find_first_bit(unsigned long b[3]) return __ffs(b0) + ofs; } +#include <asm-generic/bitops/ext2-non-atomic.h> -#define ext2_set_bit __test_and_set_bit#define ext2_set_bit_atomic (l,n,a) test_and_set_bit(n,a) -#define ext2_clear_bit __test_and_clear_bit#define ext2_clear_bit_atomic (l,n,a) test_and_clear_bit(n,a) -#define ext2_test_bit test_bit -#define ext2_find_first_zero_bit find_first_zero_bit -#define ext2_find_next_zero_bit find_next_zero_bit - -/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) __set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr) -#define minix_test_bit (nr,addr) test_bit(nr,addr) -#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size) + +#include <asm-generic/bitops/minix.h> #endif /* __KERNEL__ */
--
PATCH 19/44 arm: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- if __LINUX_ARM_ARCH__ < 5
- remove ffz()
- remove __ffs()
- remove generic_fls()
- remove generic_ffs()
- remove generic_fls64()
- remove sched_find_first_bit()
- remove generic_hweight{32,16,8}()
include/asm-arm/bitops.h | 146 +++-------------------------------------------- 1 files changed, 10 insertions(+), 136 deletions(-)
include/asm-arm/bitops.h +10 -136
@@ -117,65 +117,7 @@ ____atomic_test_and_change_bit(unsignedreturn res & mask; } -/* -* Now the non-atomic variants. We let the compiler handle all -* optimisations for these. These are all _native_ endian. -*/ -static inline void __set_bit (int nr,volatile unsigned long *p) -{ - p[nr >>5 ] |= (1UL << (nr &31 )); -} - -static inline void __clear_bit (int nr,volatile unsigned long *p) -{ - p[nr >>5 ] &= ~(1UL << (nr &31 )); -} - -static inline void __change_bit (int nr,volatile unsigned long *p) -{ - p[nr >>5 ] ^= (1UL << (nr &31 )); -} - -static inline int __test_and_set_bit (int nr,volatile unsigned long *p) -{ -unsigned long oldval, mask =1UL << (nr &31 ); - - p += nr >>5 ; - - oldval = *p; - *p = oldval | mask; -return oldval & mask; -} - -static inline int __test_and_clear_bit (int nr,volatile unsigned long *p) -{ -unsigned long oldval, mask =1UL << (nr &31 ); - - p += nr >>5 ; - - oldval = *p; - *p = oldval & ~mask; -return oldval & mask; -} - -static inline int __test_and_change_bit (int nr,volatile unsigned long *p) -{ -unsigned long oldval, mask =1UL << (nr &31 ); - - p += nr >>5 ; - - oldval = *p; - *p = oldval ^ mask; -return oldval & mask; -} - -/* -* This routine doesn't need to be atomic. -*/ -static inline int __test_bit (int nr,const volatile unsigned long * p) -{ -return (p[nr >>5 ] >> (nr &31 )) &1UL ; -} +#include <asm-generic/bitops/non-atomic.h> /* * A note about Endian-ness.
@@ -261,7 +203,6 @@ extern int _find_next_bit_be(const unsig#define test_and_set_bit (nr,p) ATOMIC_BITOP_LE(test_and_set_bit,nr,p)#define test_and_clear_bit (nr,p) ATOMIC_BITOP_LE(test_and_clear_bit,nr,p)#define test_and_change_bit (nr,p) ATOMIC_BITOP_LE(test_and_change_bit,nr,p) -#define test_bit (nr,p) __test_bit(nr,p)#define find_first_zero_bit (p,sz) _find_first_zero_bit_le(p,sz)#define find_next_zero_bit (p,sz,off) _find_next_zero_bit_le(p,sz,off)#define find_first_bit (p,sz) _find_first_bit_le(p,sz)
@@ -280,7 +221,6 @@ extern int _find_next_bit_be(const unsig#define test_and_set_bit (nr,p) ATOMIC_BITOP_BE(test_and_set_bit,nr,p)#define test_and_clear_bit (nr,p) ATOMIC_BITOP_BE(test_and_clear_bit,nr,p)#define test_and_change_bit (nr,p) ATOMIC_BITOP_BE(test_and_change_bit,nr,p) -#define test_bit (nr,p) __test_bit(nr,p)#define find_first_zero_bit (p,sz) _find_first_zero_bit_be(p,sz)#define find_next_zero_bit (p,sz,off) _find_next_zero_bit_be(p,sz,off)#define find_first_bit (p,sz) _find_first_bit_be(p,sz)
@@ -292,55 +232,10 @@ extern int _find_next_bit_be(const unsig#if __LINUX_ARM_ARCH__ <5 -/* -* ffz = Find First Zero in word. Undefined if no zero exists, -* so code should check against ~0UL first.. -*/ -static inline unsigned long ffz (unsigned long word) -{ -int k; - - word = ~word; - k =31 ; -if (word &0x0000ffff ) { k -=16 ; word <<=16 ; } -if (word &0x00ff0000 ) { k -=8 ; word <<=8 ; } -if (word &0x0f000000 ) { k -=4 ; word <<=4 ; } -if (word &0x30000000 ) { k -=2 ; word <<=2 ; } -if (word &0x40000000 ) { k -=1 ; } -return k; -} - -/* -* ffz = Find First Zero in word. Undefined if no zero exists, -* so code should check against ~0UL first.. -*/ -static inline unsigned long __ffs (unsigned long word) -{ -int k; - - k =31 ; -if (word &0x0000ffff ) { k -=16 ; word <<=16 ; } -if (word &0x00ff0000 ) { k -=8 ; word <<=8 ; } -if (word &0x0f000000 ) { k -=4 ; word <<=4 ; } -if (word &0x30000000 ) { k -=2 ; word <<=2 ; } -if (word &0x40000000 ) { k -=1 ; } -return k; -} - -/* -* fls: find last bit set. -*/ - -#define fls (x) generic_fls(x) -#define fls64 (x) generic_fls64(x) - -/* -* ffs: find first bit set. This is defined the same way as -* the libc and compiler builtin ffs routines, therefore -* differs in spirit from the above ffz (man ffs). -*/ - -#define ffs (x) generic_ffs(x) +#include <asm-generic/bitops/ffz.h> +#include <asm-generic/bitops/__ffs.h> +#include <asm-generic/bitops/fls.h> +#include <asm-generic/bitops/ffs.h> #else
@@ -352,37 +247,16 @@ static inline unsigned long __ffs(unsign#define fls (x) \ ( __builtin_constant_p(x) ? generic_fls(x) : \ ({ int __r; asm("clz\t%0, %1" : "=r"(__r) : "r"(x) : "cc"); 32-__r; }) ) -#define fls64 (x) generic_fls64(x)#define ffs (x) ({ unsigned long __t = (x); fls(__t & -__t); })#define __ffs (x) (ffs(x) - 1)#define ffz (x) __ffs( ~(x) )#endif -/* -* Find first bit set in a 168-bit bitmap, where the first -* 128 bits are unlikely to be set. -*/ -static inline int sched_find_first_bit (const unsigned long *b) -{ -unsigned long v; -unsigned int off; - -for (off =0 ; v = b[off], off <4 ; off++) { -if (unlikely (v)) -break ; - } -return __ffs (v) + off *32 ; -} - -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ +#include <asm-generic/bitops/fls64.h> -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/hweight.h> /* * Ext2 is defined to use little-endian byte ordering.
@@ -397,7 +271,7 @@ static inline int sched_find_first_bit(c#define ext2_clear_bit_atomic (lock,nr,p) \ test_and_clear_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))#define ext2_test_bit (nr,p) \ - __test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p)) + test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))#define ext2_find_first_zero_bit (p,sz) \ _find_first_zero_bit_le(p,sz)#define ext2_find_next_zero_bit (p,sz,off) \
@@ -410,7 +284,7 @@ static inline int sched_find_first_bit(c#define minix_set_bit (nr,p) \ __set_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))#define minix_test_bit (nr,p) \ - __test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p)) + test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))#define minix_test_and_set_bit (nr,p) \ __test_and_set_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))#define minix_test_and_clear_bit (nr,p) \
--
PATCH 20/44 arm26: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- remove ffz()
- remove __ffs()
- remove generic_fls()
- remove generic_fls64()
- remove generic_ffs()
- remove sched_find_first_bit()
- remove generic_hweight{32,16,8}()
include/asm-arm26/bitops.h | 146 +++------------------------------------------ 1 files changed, 10 insertions(+), 136 deletions(-)
include/asm-arm26/bitops.h +10 -136
@@ -117,65 +117,7 @@ ____atomic_test_and_change_bit(unsignedreturn res & mask; } -/* -* Now the non-atomic variants. We let the compiler handle all -* optimisations for these. These are all _native_ endian. -*/ -static inline void __set_bit (int nr,volatile unsigned long *p) -{ - p[nr >>5 ] |= (1UL << (nr &31 )); -} - -static inline void __clear_bit (int nr,volatile unsigned long *p) -{ - p[nr >>5 ] &= ~(1UL << (nr &31 )); -} - -static inline void __change_bit (int nr,volatile unsigned long *p) -{ - p[nr >>5 ] ^= (1UL << (nr &31 )); -} - -static inline int __test_and_set_bit (int nr,volatile unsigned long *p) -{ -unsigned long oldval, mask =1UL << (nr &31 ); - - p += nr >>5 ; - - oldval = *p; - *p = oldval | mask; -return oldval & mask; -} - -static inline int __test_and_clear_bit (int nr,volatile unsigned long *p) -{ -unsigned long oldval, mask =1UL << (nr &31 ); - - p += nr >>5 ; - - oldval = *p; - *p = oldval & ~mask; -return oldval & mask; -} - -static inline int __test_and_change_bit (int nr,volatile unsigned long *p) -{ -unsigned long oldval, mask =1UL << (nr &31 ); - - p += nr >>5 ; - - oldval = *p; - *p = oldval ^ mask; -return oldval & mask; -} - -/* -* This routine doesn't need to be atomic. -*/ -static inline int __test_bit (int nr,const volatile unsigned long * p) -{ -return (p[nr >>5 ] >> (nr &31 )) &1UL ; -} +#include <asm-generic/bitops/non-atomic.h> /* * Little endian assembly bitops. nr = 0 -> byte 0 bit 0.
@@ -211,7 +153,6 @@ extern int _find_next_bit_le(const unsig#define test_and_set_bit (nr,p) ATOMIC_BITOP_LE(test_and_set_bit,nr,p)#define test_and_clear_bit (nr,p) ATOMIC_BITOP_LE(test_and_clear_bit,nr,p)#define test_and_change_bit (nr,p) ATOMIC_BITOP_LE(test_and_change_bit,nr,p) -#define test_bit (nr,p) __test_bit(nr,p)#define find_first_zero_bit (p,sz) _find_first_zero_bit_le(p,sz)#define find_next_zero_bit (p,sz,off) _find_next_zero_bit_le(p,sz,off)#define find_first_bit (p,sz) _find_first_bit_le(p,sz)
@@ -219,80 +160,13 @@ extern int _find_next_bit_le(const unsig#define WORD_BITOFF_TO_LE (x) ((x)) -/* -* ffz = Find First Zero in word. Undefined if no zero exists, -* so code should check against ~0UL first.. -*/ -static inline unsigned long ffz (unsigned long word) -{ -int k; - - word = ~word; - k =31 ; -if (word &0x0000ffff ) { k -=16 ; word <<=16 ; } -if (word &0x00ff0000 ) { k -=8 ; word <<=8 ; } -if (word &0x0f000000 ) { k -=4 ; word <<=4 ; } -if (word &0x30000000 ) { k -=2 ; word <<=2 ; } -if (word &0x40000000 ) { k -=1 ; } -return k; -} - -/* -* ffz = Find First Zero in word. Undefined if no zero exists, -* so code should check against ~0UL first.. -*/ -static inline unsigned long __ffs (unsigned long word) -{ -int k; - - k =31 ; -if (word &0x0000ffff ) { k -=16 ; word <<=16 ; } -if (word &0x00ff0000 ) { k -=8 ; word <<=8 ; } -if (word &0x0f000000 ) { k -=4 ; word <<=4 ; } -if (word &0x30000000 ) { k -=2 ; word <<=2 ; } -if (word &0x40000000 ) { k -=1 ; } -return k; -} - -/* -* fls: find last bit set. -*/ - -#define fls (x) generic_fls(x) -#define fls64 (x) generic_fls64(x) - -/* -* ffs: find first bit set. This is defined the same way as -* the libc and compiler builtin ffs routines, therefore -* differs in spirit from the above ffz (man ffs). -*/ - -#define ffs (x) generic_ffs(x) - -/* -* Find first bit set in a 168-bit bitmap, where the first -* 128 bits are unlikely to be set. -*/ -static inline int sched_find_first_bit (unsigned long *b) -{ -unsigned long v; -unsigned int off; - -for (off =0 ; v = b[off], off <4 ; off++) { -if (unlikely (v)) -break ; - } -return __ffs (v) + off *32 ; -} - -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ - -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) +#include <asm-generic/bitops/ffz.h> +#include <asm-generic/bitops/__ffs.h> +#include <asm-generic/bitops/fls.h> +#include <asm-generic/bitops/fls64.h> +#include <asm-generic/bitops/ffs.h> +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/hweight.h> /* * Ext2 is defined to use little-endian byte ordering.
@@ -307,7 +181,7 @@ static inline int sched_find_first_bit(u#define ext2_clear_bit_atomic (lock,nr,p) \ test_and_clear_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))#define ext2_test_bit (nr,p) \ - __test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p)) + test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))#define ext2_find_first_zero_bit (p,sz) \ _find_first_zero_bit_le(p,sz)#define ext2_find_next_zero_bit (p,sz,off) \
@@ -320,7 +194,7 @@ static inline int sched_find_first_bit(u#define minix_set_bit (nr,p) \ __set_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))#define minix_test_bit (nr,p) \ - __test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p)) + test_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))#define minix_test_and_set_bit (nr,p) \ __test_and_set_bit(WORD_BITOFF_TO_LE(nr), (unsigned long *)(p))#define minix_test_and_clear_bit (nr,p) \
--
PATCH 21/44 cris: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- remove generic_fls()
- remove generic_fls64()
- remove generic_hweight{32,16,8}()
- remove find_{next,first}{,_zero}_bit()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
- remove sched_find_first_bit()
include/asm-cris/bitops.h | 234 +--------------------------------------------- 1 files changed, 8 insertions(+), 226 deletions(-)
include/asm-cris/bitops.h +8 -226
@@ -39,8 +39,6 @@ struct __dummy { unsigned long a[100]; }#define set_bit (nr, addr) (void)test_and_set_bit(nr, addr) -#define __set_bit (nr, addr) (void)__test_and_set_bit(nr, addr) -/* * clear_bit - Clears a bit in memory * @nr: Bit to clear
@@ -54,8 +52,6 @@ struct __dummy { unsigned long a[100]; }#define clear_bit (nr, addr) (void)test_and_clear_bit(nr, addr) -#define __clear_bit (nr, addr) (void)__test_and_clear_bit(nr, addr) -/* * change_bit - Toggle a bit in memory * @nr: Bit to change
@@ -68,18 +64,6 @@ struct __dummy { unsigned long a[100]; }#define change_bit (nr, addr) (void)test_and_change_bit(nr, addr) -/* -* __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. -*/ - -#define __change_bit (nr, addr) (void)__test_and_change_bit(nr, addr) -/** * test_and_set_bit - Set a bit and return its old value * @nr: Bit to set
@@ -104,18 +88,6 @@ static inline int test_and_set_bit(int nreturn retval; } -static inline int __test_and_set_bit (int nr,volatile unsigned long *addr) -{ -unsigned int mask, retval; -unsigned int *adr = (unsigned int *)addr; - - adr += nr >>5 ; - mask =1 << (nr &0x1f ); - retval = (mask & *adr) !=0 ; - *adr |= mask; -return retval; -} -/* * clear_bit() doesn't provide any barrier for the compiler. */
@@ -147,27 +119,6 @@ static inline int test_and_clear_bit(int }/** -* __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) -{ -unsigned int mask, retval; -unsigned int *adr = (unsigned int *)addr; - - adr += nr >>5 ; - mask =1 << (nr &0x1f ); - retval = (mask & *adr) !=0 ; - *adr &= ~mask; -return retval; -} -/** * test_and_change_bit - Change a bit and return its old value * @nr: Bit to change * @addr: Address to count from
@@ -190,42 +141,7 @@ static inline int test_and_change_bit(inreturn retval; } -/* WARNING: non atomic and it can be reordered! */ - -static inline int __test_and_change_bit (int nr,volatile unsigned long *addr) -{ -unsigned int mask, retval; -unsigned int *adr = (unsigned int *)addr; - - adr += nr >>5 ; - mask =1 << (nr &0x1f ); - retval = (mask & *adr) !=0 ; - *adr ^= mask; - -return retval; -} - -/** -* test_bit - Determine whether a bit is set -* @nr: bit number to test -* @addr: Address to start counting from -* -* This routine doesn't need to be atomic. -*/ - -static inline int test_bit (int nr,const volatile unsigned long *addr) -{ -unsigned int mask; -unsigned int *adr = (unsigned int *)addr; - - adr += nr >>5 ; - mask =1 << (nr &0x1f ); -return ((mask & *adr) !=0 ); -} - -/* -* Find-bit routines.. -*/ +#include <asm-generic/bitops/non-atomic.h> /* * Since we define it "external", it collides with the built-in
@@ -234,152 +150,18 @@ static inline int test_bit(int nr, const*/ #define ffs kernel_ffs -/* -* fls: find last bit set. -*/ +#include <asm-generic/bitops/fls.h> +#include <asm-generic/bitops/fls64.h> +#include <asm-generic/bitops/hweight.h> +#include <asm-generic/bitops/find.h> -#define fls (x) generic_fls(x) -#define fls64 (x) generic_fls64(x) +#include <asm-generic/bitops/ext2-non-atomic.h> -/* -* 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) - -/** -* 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 -*/ -static inline int find_next_zero_bit (const unsigned long * addr,int size,int offset) -{ -unsigned long *p = ((unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *(p++); - tmp |= ~0UL >> (32 -offset); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - - found_first: - tmp |= ~0UL >> size; - found_middle: -return result +ffz (tmp); -} - -/** -* 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 -*/ -static __inline__int find_next_bit (const unsigned long *addr,int size,int offset) -{ -unsigned long *p = ((unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *(p++); - tmp &= (~0UL << offset); -if (size <32 ) - goto found_first; -if (tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if ((tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp &= (~0UL >> (32 - size)); -if (tmp ==0UL )/* Are any bits set? */ -return result + size;/* Nope. */ -found_middle: -return result +__ffs (tmp); -} - -/** -* 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. -*/ - -#define find_first_zero_bit (addr, size) \ - find_next_zero_bit((addr), (size), 0) -#define find_first_bit (addr, size) \ - find_next_bit((addr), (size), 0) - -#define ext2_set_bit __test_and_set_bit#define ext2_set_bit_atomic (l,n,a) test_and_set_bit(n,a) -#define ext2_clear_bit __test_and_clear_bit#define ext2_clear_bit_atomic (l,n,a) test_and_clear_bit(n,a) -#define ext2_test_bit test_bit -#define ext2_find_first_zero_bit find_first_zero_bit -#define ext2_find_next_zero_bit find_next_zero_bit - -/* Bitmap functions for the minix filesystem. */ -#define minix_set_bit (nr,addr) __test_and_set_bit(nr,addr) -#define minix_clear_bit (nr,addr) __test_and_clear_bit(nr,addr) -#define minix_test_bit (nr,addr) test_bit(nr,addr) -#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size) -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 (unlikely (b[3 ])) -return __ffs (b[3 ]) +96 ; -if (b[4 ]) -return __ffs (b[4 ]) +128 ; -return __ffs (b[5 ]) +32 +128 ; -} +#include <asm-generic/bitops/minix.h> +#include <asm-generic/bitops/sched.h> #endif /* __KERNEL__ */
--
PATCH 22/44 frv: use generic bitops
In reply to Akinobu Mita- remove ffz()
- remove find_{next,first}{,_zero}_bit()
- remove generic_ffs()
- remove __ffs()
- remove generic_fls64()
- remove sched_find_first_bit()
- remove generic_hweight{32,16,8}()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
include/asm-frv/bitops.h | 170 ++--------------------------------------------- 1 files changed, 9 insertions(+), 161 deletions(-)
include/asm-frv/bitops.h +9 -161
@@ -22,20 +22,7 @@#ifdef __KERNEL__ -/* -* ffz = Find First Zero in word. Undefined if no zero exists, -* so code should check against ~0UL first.. -*/ -static inline unsigned long ffz (unsigned long word) -{ -unsigned long result =0 ; - -while (word &1 ) { - result++; - word >>=1 ; - } -return result; -} +#include <asm-generic/bitops/ffz.h> /* * clear_bit() doesn't provide any barrier for the compiler.
@@ -171,51 +158,9 @@ static inline int __test_bit(int nr, con __constant_test_bit((nr),(addr)) : \ __test_bit((nr),(addr))) -extern int find_next_bit (const unsigned long *addr,int size,int offset); - -#define find_first_bit (addr, size) find_next_bit(addr, size, 0) - -#define find_first_zero_bit (addr, size) \ - find_next_zero_bit((addr), (size), 0) - -static inline int find_next_zero_bit (const void *addr,int size,int offset) -{ -const unsigned long *p = ((const unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *(p++); - tmp |= ~0UL >> (32 -offset); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp |= ~0UL >> size; -found_middle: -return result +ffz (tmp); -} - -#define ffs (x) generic_ffs(x) -#define __ffs (x) (ffs(x) - 1) +#include <asm-generic/bitops/ffs.h> +#include <asm-generic/bitops/__ffs.h> +#include <asm-generic/bitops/find.h> /* * fls: find last bit set.
@@ -228,114 +173,17 @@ found_middle: \ bit ?33 - bit : bit; \ }) -#define fls64 (x) generic_fls64(x) -/* -* 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 ; -} +#include <asm-generic/bitops/fls64.h> +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/hweight.h> - -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ - -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) - -#define ext2_set_bit (nr, addr) __test_and_set_bit ((nr) ^ 0x18, (addr)) -#define ext2_clear_bit (nr, addr) __test_and_clear_bit((nr) ^ 0x18, (addr)) +#include <asm-generic/bitops/ext2-non-atomic.h> #define ext2_set_bit_atomic (lock,nr,addr) test_and_set_bit ((nr) ^ 0x18, (addr))#define ext2_clear_bit_atomic (lock,nr,addr) test_and_clear_bit((nr) ^ 0x18, (addr)) -static inline int ext2_test_bit (int nr,const volatile void * addr) -{ -const volatile unsigned char *ADDR = (const unsigned char *) addr; -int mask; - -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); -return ((mask & *ADDR ) !=0 ); -} - -#define ext2_find_first_zero_bit (addr, size) \ - ext2_find_next_zero_bit((addr), (size), 0) - -static inline unsigned long ext2_find_next_zero_bit (const void *addr, -unsigned long size, -unsigned long offset) -{ -const unsigned long *p = ((const unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { -/* We hold the little endian value in tmp, but then the -* shift is illegal. So we could keep a big endian value -* in tmp, like this: -* -* tmp = __swab32(*(p++)); -* tmp |= ~0UL >> (32-offset); -* -* but this would decrease preformance, so we change the -* shift: -*/ - tmp = *(p++); - tmp |=__swab32 (~0UL >> (32 -offset)); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: -/* tmp is little endian, so we would have to swab the shift, -* see above. But then we have to swab tmp below for ffz, so -* we might as well do this here. -*/ -return result +ffz (__swab32 (tmp) | (~0UL << size)); -found_middle: -return result +ffz (__swab32 (tmp)); -} - -/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) __test_and_set_bit ((nr) ^ 0x18, (addr)) -#define minix_set_bit (nr,addr) __set_bit((nr) ^ 0x18, (addr)) -#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit((nr) ^ 0x18, (addr)) -#define minix_test_bit (nr,addr) ext2_test_bit(nr,addr) -#define minix_find_first_zero_bit (addr,size) ext2_find_first_zero_bit(addr,size) +#include <asm-generic/bitops/minix-le.h> #endif /* __KERNEL__ */
--
PATCH 23/44 h8300: use generic bitops
In reply to Akinobu Mita- remove generic_ffs()
- remove find_{next,first}{,_zero}_bit()
- remove sched_find_first_bit()
- remove generic_hweight{32,16,8}()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove ext2_{set,clear}_bit_atomic()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
- remove generic_fls()
- remove generic_fls64()
include/asm-h8300/bitops.h | 222 +-------------------------------------------- 1 files changed, 9 insertions(+), 213 deletions(-)
include/asm-h8300/bitops.h +9 -213
@@ -8,7 +8,6 @@#include <linux/config.h> #include <linux/compiler.h> -#include <asm/byteorder.h> /* swab32 */ #include <asm/system.h> #ifdef __KERNEL__
@@ -177,10 +176,7 @@ H8300_GEN_TEST_BITOP(test_and_change_bit#undef H8300_GEN_TEST_BITOP_CONST_INT#undef H8300_GEN_TEST_BITOP -#define find_first_zero_bit (addr, size) \ - find_next_zero_bit((addr), (size), 0) - -#define ffs (x) generic_ffs(x) +#include <asm-generic/bitops/ffs.h> static __inline__unsigned long __ffs (unsigned long word) {
@@ -196,216 +192,16 @@ static __inline__ unsigned long __ffs(unreturn result; } -static __inline__int find_next_zero_bit (const unsigned long * addr,int size,int offset) -{ -unsigned long *p = (unsigned long *)(((unsigned long )addr + (offset >>3 )) & ~3 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *(p++); - tmp |= ~0UL >> (32 -offset); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp |= ~0UL >> size; -found_middle: -return result +ffz (tmp); -} - -static __inline__unsigned long find_next_bit (const unsigned long *addr, -unsigned long size,unsigned long offset) -{ -unsigned long *p = (unsigned long *)(((unsigned long )addr + (offset >>3 )) & ~3 ); -unsigned int result = offset & ~31UL ; -unsigned int tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *(p++); - tmp &= ~0UL << offset; -if (size <32 ) - goto found_first; -if (tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size >=32 ) { -if ((tmp = *p++) !=0 ) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp &= ~0UL >> (32 - size); -if (tmp ==0UL ) -return result + size; -found_middle: -return result +__ffs (tmp); -} - -#define find_first_bit (addr, size) find_next_bit(addr, size, 0) - -/* -* 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 (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 ; -} - -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ - -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) - -static __inline__int ext2_set_bit (int nr,volatile void * addr) -{ -int mask, retval; -unsigned long flags; -volatile unsigned char *ADDR = (unsigned char *) addr; - -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); -local_irq_save (flags); - retval = (mask & *ADDR ) !=0 ; - *ADDR |= mask; -local_irq_restore (flags); -return retval; -} -#define ext2_set_bit_atomic (lock, nr, addr) ext2_set_bit(nr, addr) - -static __inline__int ext2_clear_bit (int nr,volatile void * addr) -{ -int mask, retval; -unsigned long flags; -volatile unsigned char *ADDR = (unsigned char *) addr; - -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); -local_irq_save (flags); - retval = (mask & *ADDR ) !=0 ; - *ADDR &= ~mask; -local_irq_restore (flags); -return retval; -} -#define ext2_clear_bit_atomic (lock, nr, addr) ext2_set_bit(nr, addr) - -static __inline__int ext2_test_bit (int nr,const volatile void * addr) -{ -int mask; -const volatile unsigned char *ADDR = (const unsigned char *) addr; - -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); -return ((mask & *ADDR ) !=0 ); -} - -#define ext2_find_first_zero_bit (addr, size) \ - ext2_find_next_zero_bit((addr), (size), 0) - -static __inline__unsigned long ext2_find_next_zero_bit (void *addr,unsigned long size,unsigned long offset) -{ -unsigned long *p = ((unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { -/* We hold the little endian value in tmp, but then the -* shift is illegal. So we could keep a big endian value -* in tmp, like this: -* -* tmp = __swab32(*(p++)); -* tmp |= ~0UL >> (32-offset); -* -* but this would decrease performance, so we change the -* shift: -*/ - tmp = *(p++); - tmp |=__swab32 (~0UL >> (32 -offset)); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: -/* tmp is little endian, so we would have to swab the shift, -* see above. But then we have to swab tmp below for ffz, so -* we might as well do this here. -*/ -return result +ffz (__swab32 (tmp) | (~0UL << size)); -found_middle: -return result +ffz (__swab32 (tmp)); -} - -/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) __set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr) -#define minix_test_bit (nr,addr) test_bit(nr,addr) -#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size) +#include <asm-generic/bitops/find.h> +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/hweight.h> +#include <asm-generic/bitops/ext2-non-atomic.h> +#include <asm-generic/bitops/ext2-atomic.h> +#include <asm-generic/bitops/minix.h> #endif /* __KERNEL__ */ -#define fls (x) generic_fls(x) -#define fls64 (x) generic_fls64(x) +#include <asm-generic/bitops/fls.h> +#include <asm-generic/bitops/fls64.h> #endif /* _H8300_BITOPS_H */
--
PATCH 24/44 i386: use generic bitops
In reply to Akinobu Mita- remove generic_fls64()
- remove sched_find_first_bit()
- remove generic_hweight{32,16,8}()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
include/asm-i386/bitops.h | 55 ++++++---------------------------------------- 1 files changed, 8 insertions(+), 47 deletions(-)
include/asm-i386/bitops.h +8 -47
@@ -367,28 +367,9 @@ static inline unsigned long ffz(unsignedreturn 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 ; -} +#include <asm-generic/bitops/sched.h> /** * ffs - find first bit set
@@ -426,42 +407,22 @@ static inline int fls(int 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) +#include <asm-generic/bitops/hweight.h> #endif /* __KERNEL__ */ +#include <asm-generic/bitops/fls64.h> +#ifdef __KERNEL__ -#define ext2_set_bit (nr,addr) \ - __test_and_set_bit((nr),(unsigned long*)addr) +#include <asm-generic/bitops/ext2-non-atomic.h> +#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) + +#include <asm-generic/bitops/minix.h> #endif /* __KERNEL__ */
--
PATCH 25/44 ia64: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- remove generic_fls64()
- remove find_{next,first}{,_zero}_bit()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
- remove sched_find_first_bit()
arch/ia64/lib/Makefile | 2 arch/ia64/lib/bitop.c | 88 ------------------------ include/asm-ia64/bitops.h | 168 ++++------------------------------------------ 3 files changed, 19 insertions(+), 239 deletions(-)
Index: 2.6-git/include/asm-ia64/bitops.h =================================--- 2.6-git.orig/include/asm-ia64/bitops.h +++ 2.6-git/include/asm-ia64/bitops.h
@@ -5,8 +5,8 @@
* Copyright (C) 1998-2003 Hewlett-Packard Co
* David Mosberger-Tang <[email protected]>
*
- * 02/06/02 find_next_bit() and find_first_bit() added from Erich Focht's ia64 O(1)
- * scheduler patch
+ * 02/06/02 find_next_bit() and find_first_bit() added from Erich Focht's ia64
+ * O(1) scheduler patch
*/
#include <linux/compiler.h>
@@ -25,9 +25,9 @@
* restricted to acting on a single-word quantity.
*
* The address must be (at least) "long" aligned.
- * Note that there are driver (e.g., eepro100) which use these operations to operate on
- * hw-defined data-structures, so we can't easily change these operations to force a
- * bigger alignment.
+ * Note that there are driver (e.g., eepro100) which use these operations to
+ * operate on hw-defined data-structures, so we can't easily change these
+ * operations to force a bigger alignment.
*
* bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
*/
@@ -47,21 +47,6 @@ set_bit (int nr, volatile void *addr)
} while (cmpxchg_acq(m, old, new) != old);
}
-/**
- * __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 void *addr)
-{
- *((__u32 *) addr + (nr >> 5)) |= (1 << (nr & 31));
-}
-
/*
* clear_bit() has "acquire" semantics.
*/
@@ -95,17 +80,6 @@ clear_bit (int nr, volatile void *addr)
}
/**
- * __clear_bit - Clears a bit in memory (non-atomic version)
- */
-static __inline__ void
-__clear_bit (int nr, volatile void *addr)
-{
- volatile __u32 *p = (__u32 *) addr + (nr >> 5);
- __u32 m = 1 << (nr & 31);
- *p &= ~m;
-}
-
-/**
* change_bit - Toggle a bit in memory
* @nr: Bit to clear
* @addr: Address to start counting from
@@ -131,21 +105,6 @@ change_bit (int nr, volatile void *addr)
}
/**
- * __change_bit - Toggle a bit in memory
- * @nr: the bit to set
- * @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 void *addr)
-{
- *((__u32 *) addr + (nr >> 5)) ^= (1 << (nr & 31));
-}
-
-/**
* test_and_set_bit - Set a bit and return its old value
* @nr: Bit to set
* @addr: Address to count from
@@ -171,26 +130,6 @@ test_and_set_bit (int nr, volatile void
}
/**
- * __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 void *addr)
-{
- __u32 *p = (__u32 *) addr + (nr >> 5);
- __u32 m = 1 << (nr & 31);
- int oldbitset = (*p & m) != 0;
-
- *p |= m;
- return oldbitset;
-}
-
-/**
* test_and_clear_bit - Clear a bit and return its old value
* @nr: Bit to set
* @addr: Address to count from
@@ -216,26 +155,6 @@ test_and_clear_bit (int nr, volatile voi
}
/**
- * __test_and_clear_bit - Clear 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_clear_bit(int nr, volatile void * addr)
-{
- __u32 *p = (__u32 *) addr + (nr >> 5);
- __u32 m = 1 << (nr & 31);
- int oldbitset = *p & m;
-
- *p &= ~m;
- return oldbitset;
-}
-
-/**
* test_and_change_bit - Change a bit and return its old value
* @nr: Bit to set
* @addr: Address to count from
@@ -260,32 +179,14 @@ test_and_change_bit (int nr, volatile vo
return (old & bit) != 0;
}
-/*
- * WARNING: non atomic version.
- */
-static __inline__ int
-__test_and_change_bit (int nr, void *addr)
-{
- __u32 old, bit = (1 << (nr & 31));
- __u32 *m = (__u32 *) addr + (nr >> 5);
-
- old = *m;
- *m = old ^ bit;
- return (old & bit) != 0;
-}
-
-static __inline__ int
-test_bit (int nr, const volatile void *addr)
-{
- return 1 & (((const volatile __u32 *) addr)[nr >> 5] >> (nr & 31));
-}
+#include <asm-generic/bitops/non-atomic.h>
/**
* ffz - find the first zero bit in a long word
* @x: The long word to find the bit in
*
- * Returns the bit-number (0..63) of the first (least significant) zero bit. Undefined if
- * no zero exists, so code should check against ~0UL first...
+ * Returns the bit-number (0..63) of the first (least significant) zero bit.
+ * Undefined if no zero exists, so code should check against ~0UL first... */
static inline unsigned long
ffz (unsigned long x)
@@ -345,13 +246,14 @@ fls (int t)
x |= x >> 16;
return ia64_popcnt(x);
}
-#define fls64(x) generic_fls64(x)
+
+#include <asm-generic/bitops/fls64.h>
/*
- * ffs: find first bit set. This is defined the same way as the libc and compiler builtin
- * ffs routines, therefore differs in spirit from the above ffz (man ffs): it operates on
- * "int" values only and the result value is the bit number + 1. ffs(0) is defined to
- * return zero.
+ * ffs: find first bit set. This is defined the same way as the libc and
+ * compiler builtin ffs routines, therefore differs in spirit from the above
+ * ffz (man ffs): it operates on "int" values only and the result value is the
+ * bit number + 1. ffs(0) is defined to return zero.
*/
#define ffs(x) __builtin_ffs(x)
@@ -373,51 +275,17 @@ hweight64 (unsigned long x)
#endif /* __KERNEL__ */
-extern int __find_next_zero_bit (const void *addr, unsigned long size,
- unsigned long offset);
-extern int __find_next_bit(const void *addr, unsigned long size,
- unsigned long offset);
-
-#define find_next_zero_bit(addr, size, offset) \
- __find_next_zero_bit((addr), (size), (offset))
-#define find_next_bit(addr, size, offset) \
- __find_next_bit((addr), (size), (offset))
-
-/*
- * The optimizer actually does good code for this case..
- */
-#define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0) -
-#define find_first_bit(addr, size) find_next_bit((addr), (size), 0) +#include <asm-generic/bitops/find.h>
#ifdef __KERNEL__
-#define __clear_bit(nr, addr) clear_bit(nr, addr)
+#include <asm-generic/bitops/ext2-non-atomic.h>
-#define ext2_set_bit __test_and_set_bit
#define ext2_set_bit_atomic(l,n,a) test_and_set_bit(n,a)
-#define ext2_clear_bit __test_and_clear_bit
#define ext2_clear_bit_atomic(l,n,a) test_and_clear_bit(n,a)
-#define ext2_test_bit test_bit
-#define ext2_find_first_zero_bit find_first_zero_bit
-#define ext2_find_next_zero_bit find_next_zero_bit
-
-/* Bitmap functions for the minix filesystem. */
-#define minix_test_and_set_bit(nr,addr) __test_and_set_bit(nr,addr)
-#define minix_set_bit(nr,addr) __set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr) __test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr) test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
-static inline int
-sched_find_first_bit (unsigned long *b)
-{
- if (unlikely(b[0]))
- return __ffs(b[0]);
- if (unlikely(b[1]))
- return 64 + __ffs(b[1]);
- return __ffs(b[2]) + 128;
-}
+#include <asm-generic/bitops/minix.h>
+#include <asm-generic/bitops/sched.h>
#endif /* __KERNEL__ */
Index: 2.6-git/arch/ia64/lib/Makefile =================================--- 2.6-git.orig/arch/ia64/lib/Makefile +++ 2.6-git/arch/ia64/lib/Makefile
@@ -6,7 +6,7 @@ obj-y := io.o
lib-y := __divsi3.o __udivsi3.o __modsi3.o __umodsi3.o \
__divdi3.o __udivdi3.o __moddi3.o __umoddi3.o \
- bitop.o checksum.o clear_page.o csum_partial_copy.o \
+ checksum.o clear_page.o csum_partial_copy.o \
clear_user.o strncpy_from_user.o strlen_user.o strnlen_user.o \
flush.o ip_fast_csum.o do_csum.o \
memset.o strlen.o
Index: 2.6-git/arch/ia64/lib/bitop.c =================================--- 2.6-git.orig/arch/ia64/lib/bitop.c +++ /dev/null
@@ -1,88 +0,0 @@
-#include <linux/compiler.h>
-#include <linux/types.h>
-#include <asm/intrinsics.h>
-#include <linux/module.h>
-#include <linux/bitops.h>
-
-/*
- * Find next zero bit in a bitmap reasonably efficiently..
- */
-
-int __find_next_zero_bit (const void *addr, unsigned long size, unsigned long offset) -{
- unsigned long *p = ((unsigned long *) addr) + (offset >> 6);
- unsigned long result = offset & ~63UL;
- unsigned long tmp;
-
- if (offset >= size)
- return size;
- size -= result;
- offset &= 63UL;
- if (offset) {
- tmp = *(p++);
- tmp |= ~0UL >> (64-offset);
- if (size < 64)
- goto found_first;
- if (~tmp)
- goto found_middle;
- size -= 64;
- result += 64;
- }
- while (size & ~63UL) {
- if (~(tmp = *(p++)))
- goto found_middle;
- result += 64;
- size -= 64;
- }
- if (!size)
- return result;
- tmp = *p;
-found_first:
- tmp |= ~0UL << size;
- if (tmp = ~0UL) /* any bits zero? */
- return result + size; /* nope */
-found_middle:
- return result + ffz(tmp);
-}
-EXPORT_SYMBOL(__find_next_zero_bit);
-
-/*
- * Find next bit in a bitmap reasonably efficiently..
- */
-int __find_next_bit(const void *addr, unsigned long size, unsigned long offset) -{
- unsigned long *p = ((unsigned long *) addr) + (offset >> 6);
- unsigned long result = offset & ~63UL;
- unsigned long tmp;
-
- if (offset >= size)
- return size;
- size -= result;
- offset &= 63UL;
- if (offset) {
- tmp = *(p++);
- tmp &= ~0UL << offset;
- if (size < 64)
- goto found_first;
- if (tmp)
- goto found_middle;
- size -= 64;
- result += 64;
- }
- while (size & ~63UL) {
- if ((tmp = *(p++)))
- goto found_middle;
- result += 64;
- size -= 64;
- }
- if (!size)
- return result;
- tmp = *p;
- found_first:
- tmp &= ~0UL >> (64-size);
- if (tmp = 0UL) /* Are any bits set? */
- return result + size; /* Nope. */
- found_middle:
- return result + __ffs(tmp);
-}
-EXPORT_SYMBOL(__find_next_bit);
--
PATCH 26/44 m32r: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- remove ffz()
- remove find_{next,first}{,_zero}_bit()
- remove __ffs()
- remove generic_fls()
- remove generic_fls64()
- remove sched_find_first_bit()
- remove generic_ffs()
- remove generic_hweight{32,16,8}()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove ext2_{set,clear}_bit_atomic()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
include/asm-m32r/bitops.h | 457 +--------------------------------------------- 1 files changed, 12 insertions(+), 445 deletions(-)
include/asm-m32r/bitops.h +12 -445
@@ -63,25 +63,6 @@ static __inline__ void set_bit(int nr, v }/** -* __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 void * addr) -{ -__u32 mask; -volatile __u32 *a = addr; - - a += (nr >>5 ); - mask = (1 << (nr &0x1F )); - *a |= mask; -} - -/** * clear_bit - Clears a bit in memory * @nr: Bit to clear * @addr: Address to start counting from
@@ -118,39 +99,10 @@ static __inline__ void clear_bit(int nr,local_irq_restore (flags); } -static __inline__void __clear_bit (int nr,volatile unsigned long * addr) -{ -unsigned long mask; -volatile unsigned long *a = addr; - - a += (nr >>5 ); - mask = (1 << (nr &0x1F )); - *a &= ~mask; -} -#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 set -* @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 void * addr) -{ -__u32 mask; -volatile __u32 *a = addr; - - a += (nr >>5 ); - mask = (1 << (nr &0x1F )); - *a ^= mask; -} - -/** * change_bit - Toggle a bit in memory * @nr: Bit to clear * @addr: Address to start counting from
@@ -221,28 +173,6 @@ static __inline__ int test_and_set_bit(i }/** -* __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 void * addr) -{ -__u32 mask, oldbit; -volatile __u32 *a = addr; - - a += (nr >>5 ); - mask = (1 << (nr &0x1F )); - oldbit = (*a & mask); - *a |= mask; - -return (oldbit !=0 ); -} - -/** * test_and_clear_bit - Clear a bit and return its old value * @nr: Bit to set * @addr: Address to count from
@@ -280,42 +210,6 @@ static __inline__ int test_and_clear_bit }/** -* __test_and_clear_bit - Clear 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_clear_bit (int nr,volatile void * addr) -{ -__u32 mask, oldbit; -volatile __u32 *a = addr; - - a += (nr >>5 ); - mask = (1 << (nr &0x1F )); - oldbit = (*a & mask); - *a &= ~mask; - -return (oldbit !=0 ); -} - -/* WARNING: non atomic and it can be reordered! */ -static __inline__int __test_and_change_bit (int nr,volatile void * addr) -{ -__u32 mask, oldbit; -volatile __u32 *a = addr; - - a += (nr >>5 ); - mask = (1 << (nr &0x1F )); - oldbit = (*a & mask); - *a ^= mask; - -return (oldbit !=0 ); -} - -/** * test_and_change_bit - Change a bit and return its old value * @nr: Bit to set * @addr: Address to count from
@@ -350,353 +244,26 @@ static __inline__ int test_and_change_bireturn (oldbit !=0 ); } -/** -* test_bit - Determine whether a bit is set -* @nr: bit number to test -* @addr: Address to start counting from -*/ -static __inline__int test_bit (int nr,const volatile void * addr) -{ -__u32 mask; -const volatile __u32 *a = addr; - - a += (nr >>5 ); - mask = (1 << (nr &0x1F )); - -return ((*a & mask) !=0 ); -} - -/** -* 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) -{ -int k; - - word = ~word; - k =0 ; -if (!(word &0x0000ffff )) { k +=16 ; word >>=16 ; } -if (!(word &0x000000ff )) { k +=8 ; word >>=8 ; } -if (!(word &0x0000000f )) { k +=4 ; word >>=4 ; } -if (!(word &0x00000003 )) { k +=2 ; word >>=2 ; } -if (!(word &0x00000001 )) { k +=1 ; } - -return k; -} - -/** -* 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. -*/ - -#define find_first_zero_bit (addr, size) \ - find_next_zero_bit((addr), (size), 0) - -/** -* 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 -*/ -static __inline__int find_next_zero_bit (const unsigned long *addr, -int size,int offset) -{ -const unsigned long *p = addr + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *(p++); - tmp |= ~0UL >> (32 -offset); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp |= ~0UL << size; -found_middle: -return result +ffz (tmp); -} - -/** -* __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) -{ -int k =0 ; - -if (!(word &0x0000ffff )) { k +=16 ; word >>=16 ; } -if (!(word &0x000000ff )) { k +=8 ; word >>=8 ; } -if (!(word &0x0000000f )) { k +=4 ; word >>=4 ; } -if (!(word &0x00000003 )) { k +=2 ; word >>=2 ; } -if (!(word &0x00000001 )) { k +=1 ;} - -return k; -} - -/* -* fls: find last bit set. -*/ -#define fls (x) generic_fls(x) -#define fls64 (x) generic_fls64(x) +#include <asm-generic/bitops/non-atomic.h> +#include <asm-generic/bitops/ffz.h> +#include <asm-generic/bitops/__ffs.h> +#include <asm-generic/bitops/fls.h> +#include <asm-generic/bitops/fls64.h> #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 (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 ; -} - -/** -* 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 -*/ -static inline unsigned long find_next_bit (const unsigned long *addr, -unsigned long size,unsigned long offset) -{ -unsigned int *p = ((unsigned int *) addr) + (offset >>5 ); -unsigned int result = offset & ~31UL ; -unsigned int tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *p++; - tmp &= ~0UL << offset; -if (size <32 ) - goto found_first; -if (tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size >=32 ) { -if ((tmp = *p++) !=0 ) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp &= ~0UL >> (32 - size); -if (tmp ==0UL )/* Are any bits set? */ -return result + size;/* Nope. */ -found_middle: -return result +__ffs (tmp); -} - -/** -* 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. -*/ -#define find_first_bit (addr, size) \ - find_next_bit((addr), (size), 0) - -/** -* 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). -*/ -#define ffs (x) generic_ffs(x) - -/** -* 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) +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/find.h> +#include <asm-generic/bitops/ffs.h> +#include <asm-generic/bitops/hweight.h> #endif /* __KERNEL__ */ #ifdef __KERNEL__ -/* -* ext2_XXXX function -* orig: include/asm-sh/bitops.h -*/ - -#ifdef __LITTLE_ENDIAN__ -#define ext2_set_bit __test_and_set_bit -#define ext2_clear_bit __test_and_clear_bit -#define ext2_test_bit test_bit -#define ext2_find_first_zero_bit find_first_zero_bit -#define ext2_find_next_zero_bit find_next_zero_bit -#else -static inline int ext2_set_bit (int nr,volatile void * addr) -{ -__u8 mask, oldbit; -volatile __u8 *a = addr; - - a += (nr >>3 ); - mask = (1 << (nr &0x07 )); - oldbit = (*a & mask); - *a |= mask; - -return (oldbit !=0 ); -} - -static inline int ext2_clear_bit (int nr,volatile void * addr) -{ -__u8 mask, oldbit; -volatile __u8 *a = addr; - - a += (nr >>3 ); - mask = (1 << (nr &0x07 )); - oldbit = (*a & mask); - *a &= ~mask; - -return (oldbit !=0 ); -} - -static inline int ext2_test_bit (int nr,const volatile void * addr) -{ -__u32 mask; -const volatile __u8 *a = addr; - - a += (nr >>3 ); - mask = (1 << (nr &0x07 )); - -return ((mask & *a) !=0 ); -} - -#define ext2_find_first_zero_bit (addr, size) \ - ext2_find_next_zero_bit((addr), (size), 0) - -static inline unsigned long ext2_find_next_zero_bit (void *addr, -unsigned long size,unsigned long offset) -{ -unsigned long *p = ((unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { -/* We hold the little endian value in tmp, but then the -* shift is illegal. So we could keep a big endian value -* in tmp, like this: -* -* tmp = __swab32(*(p++)); -* tmp |= ~0UL >> (32-offset); -* -* but this would decrease preformance, so we change the -* shift: -*/ - tmp = *(p++); - tmp |=__swab32 (~0UL >> (32 -offset)); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: -/* tmp is little endian, so we would have to swab the shift, -* see above. But then we have to swab tmp below for ffz, so -* we might as well do this here. -*/ -return result +ffz (__swab32 (tmp) | (~0UL << size)); -found_middle: -return result +ffz (__swab32 (tmp)); -} -#endif - -#define ext2_set_bit_atomic (lock, nr, addr) \ - ({ \ - int ret; \ - spin_lock(lock); \ - ret = ext2_set_bit((nr), (addr)); \ - spin_unlock(lock); \ - ret; \ - }) - -#define ext2_clear_bit_atomic (lock, nr, addr) \ - ({ \ - int ret; \ - spin_lock(lock); \ - ret = ext2_clear_bit((nr), (addr)); \ - spin_unlock(lock); \ - ret; \ - }) - -/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) __set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr) -#define minix_test_bit (nr,addr) test_bit(nr,addr) -#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size) +#include <asm-generic/bitops/ext2-non-atomic.h> +#include <asm-generic/bitops/ext2-atomic.h> +#include <asm-generic/bitops/minix.h> #endif /* __KERNEL__ */
--
PATCH 27/44 m68k: use generic bitops
In reply to Akinobu Mita- remove generic_fls64()
- remove sched_find_first_bit()
- remove generic_hweight()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
include/asm-m68k/bitops.h | 86 ++-------------------------------------------- 1 files changed, 5 insertions(+), 81 deletions(-)
include/asm-m68k/bitops.h +5 -81
@@ -310,36 +310,10 @@ static inline int fls(int x)return 32 - cnt; } -#define fls64 (x) generic_fls64(x) - -/* -* 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 ; -} - -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ - -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) +#include <asm-generic/bitops/fls64.h> +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/hweight.h> /* Bitmap functions for the minix filesystem */
@@ -377,61 +351,11 @@ static inline int minix_test_bit(int nr,/* Bitmap functions for the ext2 filesystem. */ -#define ext2_set_bit (nr, addr) __test_and_set_bit((nr) ^ 24, (unsigned long *)(addr)) +#include <asm-generic/bitops/ext2-non-atomic.h> +#define ext2_set_bit_atomic (lock, nr, addr) test_and_set_bit((nr) ^ 24, (unsigned long *)(addr)) -#define ext2_clear_bit (nr, addr) __test_and_clear_bit((nr) ^ 24, (unsigned long *)(addr))#define ext2_clear_bit_atomic (lock, nr, addr) test_and_clear_bit((nr) ^ 24, (unsigned long *)(addr)) -static inline int ext2_test_bit (int nr,const void *vaddr) -{ -const unsigned char *p = vaddr; -return (p[nr >>3 ] & (1U << (nr &7 ))) !=0 ; -} - -static inline int ext2_find_first_zero_bit (const void *vaddr,unsigned size) -{ -const unsigned long *p = vaddr, *addr = vaddr; -int res; - -if (!size) -return 0 ; - - size = (size >>5 ) + ((size &31 ) >0 ); -while (*p++ == ~0UL ) - { -if (--size ==0 ) -return (p - addr) <<5 ; - } - - --p; -for (res =0 ; res <32 ; res++) -if (!ext2_test_bit (res, p)) -break ; -return (p - addr) *32 + res; -} - -static inline int ext2_find_next_zero_bit (const void *vaddr,unsigned size, -unsigned offset) -{ -const unsigned long *addr = vaddr; -const unsigned long *p = addr + (offset >>5 ); -int bit = offset &31UL , res; - -if (offset >= size) -return size; - -if (bit) { -/* Look for zero in first longword */ -for (res = bit; res <32 ; res++) -if (!ext2_test_bit (res, p)) -return (p - addr) *32 + res; - p++; - } -/* No zero yet, search remaining full bytes for a zero */ - res =ext2_find_first_zero_bit (p, size -32 * (p - addr)); -return (p - addr) *32 + res; -} -#endif /* __KERNEL__ */ #endif /* _M68K_BITOPS_H */
--
PATCH 28/44 m68knommu: use generic bitops
In reply to Akinobu Mita- remove ffs()
- remove __ffs()
- remove sched_find_first_bit()
- remove ffz()
- remove find_{next,first}{,_zero}_bit()
- remove generic_hweight()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
- remove generic_fls()
- remove generic_fls64()
include/asm-m68knommu/bitops.h | 221 +---------------------------------------- 1 files changed, 9 insertions(+), 212 deletions(-)
include/asm-m68knommu/bitops.h +9 -212
@@ -12,104 +12,10 @@#ifdef __KERNEL__ -/* -* Generic ffs(). -*/ -static inline int ffs (int x) -{ -int r =1 ; - -if (!x) -return 0 ; -if (!(x &0xffff )) { - x >>=16 ; - r +=16 ; - } -if (!(x &0xff )) { - x >>=8 ; - r +=8 ; - } -if (!(x &0xf )) { - x >>=4 ; - r +=4 ; - } -if (!(x &3 )) { - x >>=2 ; - r +=2 ; - } -if (!(x &1 )) { - x >>=1 ; - r +=1 ; - } -return r; -} - -/* -* Generic __ffs(). -*/ -static inline int __ffs (int x) -{ -int r =0 ; - -if (!x) -return 0 ; -if (!(x &0xffff )) { - x >>=16 ; - r +=16 ; - } -if (!(x &0xff )) { - x >>=8 ; - r +=8 ; - } -if (!(x &0xf )) { - x >>=4 ; - r +=4 ; - } -if (!(x &3 )) { - x >>=2 ; - r +=2 ; - } -if (!(x &1 )) { - x >>=1 ; - r +=1 ; - } -return r; -} - -/* -* 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 (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 ; -} - -/* -* ffz = Find First Zero in word. Undefined if no zero exists, -* so code should check against ~0UL first.. -*/ -static __inline__unsigned long ffz (unsigned long word) -{ -unsigned long result =0 ; - -while (word &1 ) { - result++; - word >>=1 ; - } -return result; -} - +#include <asm-generic/bitops/ffs.h> +#include <asm-generic/bitops/__ffs.h> +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/ffz.h> static __inline__void set_bit (int nr,volatile unsigned long * addr) {
@@ -254,98 +160,8 @@ static __inline__ int __test_bit(int nr, __constant_test_bit((nr),(addr)) : \ __test_bit((nr),(addr))) -#define find_first_zero_bit (addr, size) \ - find_next_zero_bit((addr), (size), 0) -#define find_first_bit (addr, size) \ - find_next_bit((addr), (size), 0) - -static __inline__int find_next_zero_bit (const void * addr,int size,int offset) -{ -unsigned long *p = ((unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *(p++); - tmp |= ~0UL >> (32 -offset); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp |= ~0UL << size; -found_middle: -return result +ffz (tmp); -} - -/* -* Find next one bit in a bitmap reasonably efficiently. -*/ -static __inline__unsigned long find_next_bit (const unsigned long *addr, -unsigned long size,unsigned long offset) -{ -unsigned int *p = ((unsigned int *) addr) + (offset >>5 ); -unsigned int result = offset & ~31UL ; -unsigned int tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *p++; - tmp &= ~0UL << offset; -if (size <32 ) - goto found_first; -if (tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size >=32 ) { -if ((tmp = *p++) !=0 ) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp &= ~0UL >> (32 - size); -if (tmp ==0UL )/* Are any bits set? */ -return result + size;/* Nope. */ -found_middle: -return result +__ffs (tmp); -} - -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ - -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) - +#include <asm-generic/bitops/find.h> +#include <asm-generic/bitops/hweight.h> static __inline__int ext2_set_bit (int nr,volatile void * addr) {
@@ -475,30 +291,11 @@ found_middle:return result +ffz (__swab32 (tmp)); } -/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) __set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr) -#define minix_test_bit (nr,addr) test_bit(nr,addr) -#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size) - -/** -* 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) +#include <asm-generic/bitops/minix.h> #endif /* __KERNEL__ */ -/* -* fls: find last bit set. -*/ -#define fls (x) generic_fls(x) -#define fls64 (x) generic_fls64(x) +#include <asm-generic/bitops/fls.h> +#include <asm-generic/bitops/fls64.h> #endif /* _M68KNOMMU_BITOPS_H */
--
PATCH 29/44 mips: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- unless defined(CONFIG_CPU_MIPS32) or defined(CONFIG_CPU_MIPS64)
- remove __ffs()
- remove ffs()
- remove ffz()
- remove fls()
- remove fls64()
- remove find_{next,first}{,_zero}_bit()
- remove sched_find_first_bit()
- remove generic_hweight64()
- remove generic_hweight{32,16,8}()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove ext2_{set,clear}_bit_atomic()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
include/asm-mips/bitops.h | 456 +--------------------------------------------- 1 files changed, 17 insertions(+), 439 deletions(-)
include/asm-mips/bitops.h +17 -439
@@ -105,22 +105,6 @@ static inline void set_bit(unsigned long }/* -* __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 (unsigned long nr,volatile unsigned long * addr) -{ -unsigned long * m = ((unsigned long *) addr) + (nr >>SZLONG_LOG ); - - *m |=1UL << (nr &SZLONG_MASK ); -} - -/* * clear_bit - Clears a bit in memory * @nr: Bit to clear * @addr: Address to start counting from
@@ -169,22 +153,6 @@ static inline void clear_bit(unsigned lo }/* -* __clear_bit - Clears a bit in memory -* @nr: Bit to clear -* @addr: Address to start counting from -* -* Unlike clear_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 __clear_bit (unsigned long nr,volatile unsigned long * addr) -{ -unsigned long * m = ((unsigned long *) addr) + (nr >>SZLONG_LOG ); - - *m &= ~(1UL << (nr &SZLONG_MASK )); -} - -/* * change_bit - Toggle a bit in memory * @nr: Bit to change * @addr: Address to start counting from
@@ -235,22 +203,6 @@ static inline void change_bit(unsigned l }/* -* __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 (unsigned long nr,volatile unsigned long * addr) -{ -unsigned long * m = ((unsigned long *) addr) + (nr >>SZLONG_LOG ); - - *m ^=1UL << (nr &SZLONG_MASK ); -} - -/* * test_and_set_bit - Set a bit and return its old value * @nr: Bit to set * @addr: Address to count from
@@ -321,30 +273,6 @@ static inline int test_and_set_bit(unsig }/* -* __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 (unsigned long nr, -volatile unsigned long *addr) -{ -volatile unsigned long *a = addr; -unsigned long mask; -int retval; - - a += nr >>SZLONG_LOG ; - mask =1UL << (nr &SZLONG_MASK ); - retval = (mask & *a) !=0 ; - *a |= mask; - -return retval; -} - -/* * test_and_clear_bit - Clear a bit and return its old value * @nr: Bit to clear * @addr: Address to count from
@@ -417,30 +345,6 @@ static inline int test_and_clear_bit(uns }/* -* __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 (unsigned long nr, -volatile unsigned long * addr) -{ -volatile unsigned long *a = addr; -unsigned long mask; -int retval; - - a += (nr >>SZLONG_LOG ); - mask =1UL << (nr &SZLONG_MASK ); - retval = ((mask & *a) !=0 ); - *a &= ~mask; - -return retval; -} - -/* * test_and_change_bit - Change a bit and return its old value * @nr: Bit to change * @addr: Address to count from
@@ -509,43 +413,11 @@ static inline int test_and_change_bit(un } } -/* -* __test_and_change_bit - Change a bit and return its old value -* @nr: Bit to change -* @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_change_bit (unsigned long nr, -volatile unsigned long *addr) -{ -volatile unsigned long *a = addr; -unsigned long mask; -int retval; - - a += (nr >>SZLONG_LOG ); - mask =1UL << (nr &SZLONG_MASK ); - retval = ((mask & *a) !=0 ); - *a ^= mask; - -return retval; -} -#undef __bi_flags#undef __bi_local_irq_save#undef __bi_local_irq_restore -/* -* test_bit - Determine whether a bit is set -* @nr: bit number to test -* @addr: Address to start counting from -*/ -static inline int test_bit (unsigned long nr,const volatile unsigned long *addr) -{ -return 1UL & (addr[nr >>SZLONG_LOG ] >> (nr &SZLONG_MASK )); -} +#include <asm-generic/bitops/non-atomic.h> /* * Return the bit position (0..63) of the most significant 1 bit in a word
@@ -580,6 +452,8 @@ static inline int __ilog2(unsigned longreturn 63 - lz; } +#if defined(CONFIG_CPU_MIPS32 ) || defined(CONFIG_CPU_MIPS64 ) +/* * __ffs - find first bit in word. * @word: The word to search
@@ -589,31 +463,7 @@ static inline int __ilog2(unsigned long*/ static inline unsigned long __ffs (unsigned long word) { -#if defined(CONFIG_CPU_MIPS32 ) || defined(CONFIG_CPU_MIPS64 )return __ilog2 (word & -word); -#else -int b =0 , s; - -#ifdef CONFIG_32BIT - s =16 ;if (word <<16 !=0 ) s =0 ; b += s; word >>= s; - s =8 ;if (word <<24 !=0 ) s =0 ; b += s; word >>= s; - s =4 ;if (word <<28 !=0 ) s =0 ; b += s; word >>= s; - s =2 ;if (word <<30 !=0 ) s =0 ; b += s; word >>= s; - s =1 ;if (word <<31 !=0 ) s =0 ; b += s; - -return b; -#endif -#ifdef CONFIG_64BIT - s =32 ;if (word <<32 !=0 ) s =0 ; b += s; word >>= s; - s =16 ;if (word <<48 !=0 ) s =0 ; b += s; word >>= s; - s =8 ;if (word <<56 !=0 ) s =0 ; b += s; word >>= s; - s =4 ;if (word <<60 !=0 ) s =0 ; b += s; word >>= s; - s =2 ;if (word <<62 !=0 ) s =0 ; b += s; word >>= s; - s =1 ;if (word <<63 !=0 ) s =0 ; b += s; - -return b; -#endif -#endif }/*
@@ -652,33 +502,7 @@ static inline unsigned long ffz(unsigned*/ static inline unsigned long flz (unsigned long word) { -#if defined(CONFIG_CPU_MIPS32 ) || defined(CONFIG_CPU_MIPS64 )return __ilog2 (~word); -#else -#ifdef CONFIG_32BIT -int r =31 , s; - word = ~word; - s =16 ;if ((word &0xffff0000 )) s =0 ; r -= s; word <<= s; - s =8 ;if ((word &0xff000000 )) s =0 ; r -= s; word <<= s; - s =4 ;if ((word &0xf0000000 )) s =0 ; r -= s; word <<= s; - s =2 ;if ((word &0xc0000000 )) s =0 ; r -= s; word <<= s; - s =1 ;if ((word &0x80000000 )) s =0 ; r -= s; - -return r; -#endif -#ifdef CONFIG_64BIT -int r =63 , s; - word = ~word; - s =32 ;if ((word &0xffffffff00000000UL )) s =0 ; r -= s; word <<= s; - s =16 ;if ((word &0xffff000000000000UL )) s =0 ; r -= s; word <<= s; - s =8 ;if ((word &0xff00000000000000UL )) s =0 ; r -= s; word <<= s; - s =4 ;if ((word &0xf000000000000000UL )) s =0 ; r -= s; word <<= s; - s =2 ;if ((word &0xc000000000000000UL )) s =0 ; r -= s; word <<= s; - s =1 ;if ((word &0x8000000000000000UL )) s =0 ; r -= s; - -return r; -#endif -#endif }/*
@@ -695,272 +519,26 @@ static inline unsigned long fls(unsigned return flz(~word) + 1; } -#define fls64 (x) generic_fls64(x) -/* -* 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 -*/ -static inline unsigned long find_next_zero_bit (const unsigned long *addr, -unsigned long size,unsigned long offset) -{ -const unsigned long *p = addr + (offset >>SZLONG_LOG ); -unsigned long result = offset & ~SZLONG_MASK ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=SZLONG_MASK ; -if (offset) { - tmp = *(p++); - tmp |= ~0UL >> (_MIPS_SZLONG-offset); -if (size < _MIPS_SZLONG) - goto found_first; -if (~tmp) - goto found_middle; - size -= _MIPS_SZLONG; - result += _MIPS_SZLONG; - } -while (size & ~SZLONG_MASK ) { -if (~(tmp = *(p++))) - goto found_middle; - result += _MIPS_SZLONG; - size -= _MIPS_SZLONG; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp |= ~0UL << size; -if (tmp == ~0UL )/* Are any bits zero? */ -return result + size;/* Nope. */ -found_middle: -return result +ffz (tmp); -} - -#define find_first_zero_bit (addr, size) \ - find_next_zero_bit((addr), (size), 0) - -/* -* find_next_bit - find the next 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 -*/ -static inline unsigned long find_next_bit (const unsigned long *addr, -unsigned long size,unsigned long offset) -{ -const unsigned long *p = addr + (offset >>SZLONG_LOG ); -unsigned long result = offset & ~SZLONG_MASK ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=SZLONG_MASK ; -if (offset) { - tmp = *(p++); - tmp &= ~0UL << offset; -if (size < _MIPS_SZLONG) - goto found_first; -if (tmp) - goto found_middle; - size -= _MIPS_SZLONG; - result += _MIPS_SZLONG; - } -while (size & ~SZLONG_MASK ) { -if ((tmp = *(p++))) - goto found_middle; - result += _MIPS_SZLONG; - size -= _MIPS_SZLONG; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp &= ~0UL >> (_MIPS_SZLONG - size); -if (tmp ==0UL )/* Are any bits set? */ -return result + size;/* Nope. */ -found_middle: -return result +__ffs (tmp); -} - -/* -* 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. -*/ -#define find_first_bit (addr, size) \ - find_next_bit((addr), (size), 0) - -#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) -{ -#ifdef CONFIG_32BIT -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 ; -#endif -#ifdef CONFIG_64BIT -if (unlikely (b[0 ])) -return __ffs (b[0 ]); -if (unlikely (b[1 ])) -return __ffs (b[1 ]) +64 ; -return __ffs (b[2 ]) +128 ; -#endif -} - -/* -* 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 hweight64 (x) generic_hweight64(x) -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) - -static inline int __test_and_set_le_bit (unsigned long nr,unsigned long *addr) -{ -unsigned char *ADDR = (unsigned char *) addr; -int mask, retval; - -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); - retval = (mask & *ADDR ) !=0 ; - *ADDR |= mask; - -return retval; -} - -static inline int __test_and_clear_le_bit (unsigned long nr,unsigned long *addr) -{ -unsigned char *ADDR = (unsigned char *) addr; -int mask, retval; - -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); - retval = (mask & *ADDR ) !=0 ; - *ADDR &= ~mask; - -return retval; -} - -static inline int test_le_bit (unsigned long nr,const unsigned long * addr) -{ -const unsigned char *ADDR = (const unsigned char *) addr; -int mask; +#else -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); +#include <asm-generic/bitops/__ffs.h> +#include <asm-generic/bitops/ffs.h> +#include <asm-generic/bitops/ffz.h> +#include <asm-generic/bitops/fls.h> -return ((mask & *ADDR ) !=0 ); -} +#endif /*defined(CONFIG_CPU_MIPS32) || defined(CONFIG_CPU_MIPS64) */ -static inline unsigned long find_next_zero_le_bit (unsigned long *addr, -unsigned long size,unsigned long offset) -{ -unsigned long *p = ((unsigned long *) addr) + (offset >>SZLONG_LOG ); -unsigned long result = offset & ~SZLONG_MASK ; -unsigned long tmp; +#include <asm-generic/bitops/fls64.h> +#include <asm-generic/bitops/find.h> -if (offset >= size) -return size; - size -= result; - offset &=SZLONG_MASK ; -if (offset) { - tmp =cpu_to_lelongp (p++); - tmp |= ~0UL >> (_MIPS_SZLONG-offset);/* bug or feature ? */ -if (size < _MIPS_SZLONG) - goto found_first; -if (~tmp) - goto found_middle; - size -= _MIPS_SZLONG; - result += _MIPS_SZLONG; - } -while (size & ~SZLONG_MASK ) { -if (~(tmp =cpu_to_lelongp (p++))) - goto found_middle; - result += _MIPS_SZLONG; - size -= _MIPS_SZLONG; - } -if (!size) -return result; - tmp =cpu_to_lelongp (p); - -found_first: - tmp |= ~0UL << size; -if (tmp == ~0UL )/* Are any bits zero? */ -return result + size;/* Nope. */ - -found_middle: -return result +ffz (tmp); -} - -#define find_first_zero_le_bit (addr, size) \ - find_next_zero_le_bit((addr), (size), 0) - -#define ext2_set_bit (nr,addr) \ - __test_and_set_le_bit((nr),(unsigned long*)addr) -#define ext2_clear_bit (nr, addr) \ - __test_and_clear_le_bit((nr),(unsigned long*)addr) -#define ext2_set_bit_atomic (lock, nr, addr) \ -({ \ - int ret; \ - spin_lock(lock); \ - ret = ext2_set_bit((nr), (addr)); \ - spin_unlock(lock); \ - ret; \ -}) - -#define ext2_clear_bit_atomic (lock, nr, addr) \ -({ \ - int ret; \ - spin_lock(lock); \ - ret = ext2_clear_bit((nr), (addr)); \ - spin_unlock(lock); \ - ret; \ -}) -#define ext2_test_bit (nr, addr) test_le_bit((nr),(unsigned long*)addr) -#define ext2_find_first_zero_bit (addr, size) \ - find_first_zero_le_bit((unsigned long*)addr, size) -#define ext2_find_next_zero_bit (addr, size, off) \ - find_next_zero_le_bit((unsigned long*)addr, size, off) +#ifdef __KERNEL__ -/* -* Bitmap functions for the minix filesystem. -* -* FIXME: These assume that Minix uses the native byte/bitorder. -* This limits the Minix filesystem's value for data exchange very much. -*/ -#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) __set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr) -#define minix_test_bit (nr,addr) test_bit(nr,addr) -#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size) +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/hweight.h> +#include <asm-generic/bitops/ext2-non-atomic.h> +#include <asm-generic/bitops/ext2-atomic.h> +#include <asm-generic/bitops/minix.h> #endif /* __KERNEL__ */
--
PATCH 30/44 parisc: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- remove ffz()
- remove generic_fls64()
- remove generic_hweight{32,16,8}()
- remove generic_hweight64()
- remove sched_find_first_bit()
- remove find_{next,first}{,_zero}_bit()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
include/asm-parisc/bitops.h | 286 +------------------------------------------- 1 files changed, 9 insertions(+), 277 deletions(-)
include/asm-parisc/bitops.h +9 -277
@@ -35,13 +35,6 @@ static __inline__ void set_bit(int nr, v_atomic_spin_unlock_irqrestore (addr, flags); } -static __inline__void __set_bit (unsigned long nr,volatile unsigned long * addr) -{ -unsigned long *m = (unsigned long *) addr + (nr >>SHIFT_PER_LONG ); - - *m |=1UL <<CHOP_SHIFTCOUNT (nr); -} -static __inline__void clear_bit (int nr,volatile unsigned long * addr) {unsigned long mask = ~(1UL <<CHOP_SHIFTCOUNT (nr));
@@ -53,13 +46,6 @@ static __inline__ void clear_bit(int nr,_atomic_spin_unlock_irqrestore (addr, flags); } -static __inline__void __clear_bit (unsigned long nr,volatile unsigned long * addr) -{ -unsigned long *m = (unsigned long *) addr + (nr >>SHIFT_PER_LONG ); - - *m &= ~(1UL <<CHOP_SHIFTCOUNT (nr)); -} -static __inline__void change_bit (int nr,volatile unsigned long * addr) {unsigned long mask =1UL <<CHOP_SHIFTCOUNT (nr);
@@ -71,13 +57,6 @@ static __inline__ void change_bit(int nr_atomic_spin_unlock_irqrestore (addr, flags); } -static __inline__void __change_bit (unsigned long nr,volatile unsigned long * addr) -{ -unsigned long *m = (unsigned long *) addr + (nr >>SHIFT_PER_LONG ); - - *m ^=1UL <<CHOP_SHIFTCOUNT (nr); -} -static __inline__int test_and_set_bit (int nr,volatile unsigned long * addr) {unsigned long mask =1UL <<CHOP_SHIFTCOUNT (nr);
@@ -93,18 +72,6 @@ static __inline__ int test_and_set_bit(ireturn (oldbit & mask) ?1 :0 ; } -static __inline__int __test_and_set_bit (int nr,volatile unsigned long * address) -{ -unsigned long mask =1UL <<CHOP_SHIFTCOUNT (nr); -unsigned long oldbit; -unsigned long *addr = (unsigned long *)address + (nr >>SHIFT_PER_LONG ); - - oldbit = *addr; - *addr = oldbit | mask; - -return (oldbit & mask) ?1 :0 ; -} -static __inline__int test_and_clear_bit (int nr,volatile unsigned long * addr) {unsigned long mask =1UL <<CHOP_SHIFTCOUNT (nr);
@@ -120,18 +87,6 @@ static __inline__ int test_and_clear_bitreturn (oldbit & mask) ?1 :0 ; } -static __inline__int __test_and_clear_bit (int nr,volatile unsigned long * address) -{ -unsigned long mask =1UL <<CHOP_SHIFTCOUNT (nr); -unsigned long *addr = (unsigned long *)address + (nr >>SHIFT_PER_LONG ); -unsigned long oldbit; - - oldbit = *addr; - *addr = oldbit & ~mask; - -return (oldbit & mask) ?1 :0 ; -} -static __inline__int test_and_change_bit (int nr,volatile unsigned long * addr) {unsigned long mask =1UL <<CHOP_SHIFTCOUNT (nr);
@@ -147,25 +102,7 @@ static __inline__ int test_and_change_bireturn (oldbit & mask) ?1 :0 ; } -static __inline__int __test_and_change_bit (int nr,volatile unsigned long * address) -{ -unsigned long mask =1UL <<CHOP_SHIFTCOUNT (nr); -unsigned long *addr = (unsigned long *)address + (nr >>SHIFT_PER_LONG ); -unsigned long oldbit; - - oldbit = *addr; - *addr = oldbit ^ mask; - -return (oldbit & mask) ?1 :0 ; -} - -static __inline__int test_bit (int nr,const volatile unsigned long *address) -{ -unsigned long mask =1UL <<CHOP_SHIFTCOUNT (nr); -const unsigned long *addr = (const unsigned long *)address + (nr >>SHIFT_PER_LONG ); - -return !!(*addr & mask); -} +#include <asm-generic/bitops/non-atomic.h> #ifdef __KERNEL__
@@ -219,8 +156,7 @@ static __inline__ unsigned long __ffs(unreturn ret; } -/* Undefined if no bit is zero. */ -#define ffz (x) __ffs(~(x)) +#include <asm-generic/bitops/ffz.h> /* * ffs: find first bit set. returns 1 to BITS_PER_LONG or 0 (if none set)
@@ -263,155 +199,22 @@ static __inline__ int fls(int x) return ret; } -#define fls64 (x) generic_fls64(x) -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ -#define hweight64 (x) generic_hweight64(x) -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) - -/* -* 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) -{ -#ifdef __LP64__ -if (unlikely (b[0 ])) -return __ffs (b[0 ]); -if (unlikely (b[1 ])) -return __ffs (b[1 ]) +64 ; -return __ffs (b[2 ]) +128 ; -#else -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 ; -#endif -} +#include <asm-generic/bitops/fls64.h> +#include <asm-generic/bitops/hweight.h> +#include <asm-generic/bitops/sched.h> #endif /* __KERNEL__ */ -/* -* This implementation of find_{first,next}_zero_bit was stolen from -* Linus' asm-alpha/bitops.h. -*/ -#define find_first_zero_bit (addr, size) \ - find_next_zero_bit((addr), (size), 0) - -static __inline__unsigned long find_next_zero_bit (const void * addr,unsigned long size,unsigned long offset) -{ -const unsigned long * p = ((unsigned long *) addr) + (offset >>SHIFT_PER_LONG ); -unsigned long result = offset & ~(BITS_PER_LONG -1 ); -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &= (BITS_PER_LONG -1 ); -if (offset) { - tmp = *(p++); - tmp |= ~0UL >> (BITS_PER_LONG -offset); -if (size <BITS_PER_LONG ) - goto found_first; -if (~tmp) - goto found_middle; - size -=BITS_PER_LONG ; - result +=BITS_PER_LONG ; - } -while (size & ~(BITS_PER_LONG -1 )) { -if (~(tmp = *(p++))) - goto found_middle; - result +=BITS_PER_LONG ; - size -=BITS_PER_LONG ; - } -if (!size) -return result; - tmp = *p; -found_first: - tmp |= ~0UL << size; -found_middle: -return result +ffz (tmp); -} - -static __inline__unsigned long find_next_bit (const unsigned long *addr,unsigned long size,unsigned long offset) -{ -const unsigned long *p = addr + (offset >>SHIFT_PER_LONG ); -unsigned long result = offset & ~(BITS_PER_LONG -1 ); -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &= (BITS_PER_LONG -1 ); -if (offset) { - tmp = *(p++); - tmp &= (~0UL << offset); -if (size <BITS_PER_LONG ) - goto found_first; -if (tmp) - goto found_middle; - size -=BITS_PER_LONG ; - result +=BITS_PER_LONG ; - } -while (size & ~(BITS_PER_LONG -1 )) { -if ((tmp = *(p++))) - goto found_middle; - result +=BITS_PER_LONG ; - size -=BITS_PER_LONG ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp &= (~0UL >> (BITS_PER_LONG - size)); -if (tmp ==0UL )/* Are any bits set? */ -return result + size;/* Nope. */ -found_middle: -return result +__ffs (tmp); -} - -/** -* 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. -*/ -#define find_first_bit (addr, size) \ - find_next_bit((addr), (size), 0) - -#define _EXT2_HAVE_ASM_BITOPS_ +#include <asm-generic/bitops/find.h> #ifdef __KERNEL__ -/* -* test_and_{set,clear}_bit guarantee atomicity without -* disabling interrupts. -*/ + +#include <asm-generic/bitops/ext2-non-atomic.h> /* '3' is bits per byte */ #define LE_BYTE_ADDR ((sizeof(unsigned long) - 1) << 3) -#define ext2_test_bit (nr, addr) \ - test_bit((nr) ^ LE_BYTE_ADDR, (unsigned long *)addr) -#define ext2_set_bit (nr, addr) \ - __test_and_set_bit((nr) ^ LE_BYTE_ADDR, (unsigned long *)addr) -#define ext2_clear_bit (nr, addr) \ - __test_and_clear_bit((nr) ^ LE_BYTE_ADDR, (unsigned long *)addr) -#define ext2_set_bit_atomic (l,nr,addr) \ test_and_set_bit((nr) ^ LE_BYTE_ADDR, (unsigned long *)addr)#define ext2_clear_bit_atomic (l,nr,addr) \
@@ -419,77 +222,6 @@ found_middle:#endif /* __KERNEL__ */ - -#define ext2_find_first_zero_bit (addr, size) \ - ext2_find_next_zero_bit((addr), (size), 0) - -/* include/linux/byteorder does not support "unsigned long" type */ -static inline unsigned long ext2_swabp (unsigned long * x) -{ -#ifdef __LP64__ -return (unsigned long )__swab64p ((u64 *) x); -#else -return (unsigned long )__swab32p ((u32 *) x); -#endif -} - -/* include/linux/byteorder doesn't support "unsigned long" type */ -static inline unsigned long ext2_swab (unsigned long y) -{ -#ifdef __LP64__ -return (unsigned long )__swab64 ((u64 ) y); -#else -return (unsigned long )__swab32 ((u32 ) y); -#endif -} - -static __inline__unsigned long ext2_find_next_zero_bit (void *addr,unsigned long size,unsigned long offset) -{ -unsigned long *p = (unsigned long *) addr + (offset >>SHIFT_PER_LONG ); -unsigned long result = offset & ~(BITS_PER_LONG -1 ); -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &= (BITS_PER_LONG -1UL ); -if (offset) { - tmp =ext2_swabp (p++); - tmp |= (~0UL >> (BITS_PER_LONG - offset)); -if (size <BITS_PER_LONG ) - goto found_first; -if (~tmp) - goto found_middle; - size -=BITS_PER_LONG ; - result +=BITS_PER_LONG ; - } - -while (size & ~(BITS_PER_LONG -1 )) { -if (~(tmp = *(p++))) - goto found_middle_swap; - result +=BITS_PER_LONG ; - size -=BITS_PER_LONG ; - } -if (!size) -return result; - tmp =ext2_swabp (p); -found_first: - tmp |= ~0UL << size; -if (tmp == ~0UL )/* Are any bits zero? */ -return result + size;/* Nope. Skip ffz */ -found_middle: -return result +ffz (tmp); - -found_middle_swap: -return result +ffz (ext2_swab (tmp)); -} - - -/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) ext2_set_bit(nr,addr) -#define minix_set_bit (nr,addr) ((void)ext2_set_bit(nr,addr)) -#define minix_test_and_clear_bit (nr,addr) ext2_clear_bit(nr,addr) -#define minix_test_bit (nr,addr) ext2_test_bit(nr,addr) -#define minix_find_first_zero_bit (addr,size) ext2_find_first_zero_bit(addr,size) +#include <asm-generic/bitops/minix-le.h> #endif /* _PARISC_BITOPS_H */
--
PATCH 31/44 powerpc: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- remove generic_fls64()
- remove generic_hweight{64,32,16,8}()
- remove sched_find_first_bit()
include/asm-powerpc/bitops.h | 105 +------------------------------------------ 1 files changed, 4 insertions(+), 101 deletions(-)
include/asm-powerpc/bitops.h +4 -101
@@ -184,72 +184,7 @@ static __inline__ void set_bits(unsigned : "cc"); } -/* Non-atomic versions */ -static __inline__int test_bit (unsigned long nr, - __const__ volatile unsigned long *addr) -{ -return 1UL & (addr[BITOP_WORD (nr)] >> (nr & (BITS_PER_LONG -1 ))); -} - -static __inline__void __set_bit (unsigned long nr, -volatile unsigned long *addr) -{ -unsigned long mask =BITOP_MASK (nr); -unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); - - *p |= mask; -} - -static __inline__void __clear_bit (unsigned long nr, -volatile unsigned long *addr) -{ -unsigned long mask =BITOP_MASK (nr); -unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); - - *p &= ~mask; -} - -static __inline__void __change_bit (unsigned long nr, -volatile unsigned long *addr) -{ -unsigned long mask =BITOP_MASK (nr); -unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); - - *p ^= mask; -} - -static __inline__int __test_and_set_bit (unsigned long nr, -volatile unsigned long *addr) -{ -unsigned long mask =BITOP_MASK (nr); -unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); -unsigned long old = *p; - - *p = old | mask; -return (old & mask) !=0 ; -} - -static __inline__int __test_and_clear_bit (unsigned long nr, -volatile unsigned long *addr) -{ -unsigned long mask =BITOP_MASK (nr); -unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); -unsigned long old = *p; - - *p = old & ~mask; -return (old & mask) !=0 ; -} - -static __inline__int __test_and_change_bit (unsigned long nr, -volatile unsigned long *addr) -{ -unsigned long mask =BITOP_MASK (nr); -unsigned long *p = ((unsigned long *)addr) +BITOP_WORD (nr); -unsigned long old = *p; - - *p = old ^ mask; -return (old & mask) !=0 ; -} +#include <asm-generic/bitops/non-atomic.h> /* * Return the zero-based bit position (LE, not IBM bit numbering) of
@@ -310,16 +245,9 @@ static __inline__ int fls(unsigned int x asm ("cntlzw %0,%1" :"=r" (lz) :"r" (x));return 32 - lz; } -#define fls64 (x) generic_fls64(x) +#include <asm-generic/bitops/fls64.h> -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ -#define hweight64 (x) generic_hweight64(x) -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) +#include <asm-generic/bitops/hweight.h> #define find_first_zero_bit (addr, size) find_next_zero_bit((addr), (size), 0) unsigned long find_next_zero_bit(const unsigned long *addr,
@@ -397,32 +325,7 @@ unsigned long find_next_zero_le_bit(cons#define minix_find_first_zero_bit (addr,size) \ find_first_zero_le_bit((unsigned long *)addr, size) -/* -* 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) -{ -#ifdef CONFIG_PPC64 -if (unlikely (b[0 ])) -return __ffs (b[0 ]); -if (unlikely (b[1 ])) -return __ffs (b[1 ]) +64 ; -return __ffs (b[2 ]) +128 ; -#else -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 ; -#endif -} +#include <asm-generic/bitops/sched.h> #endif /* __KERNEL__ */
--
PATCH 32/44 s390: use generic bitops
In reply to Akinobu Mita- remove generic_ffs()
- remove generic_fls()
- remove generic_fls64()
- remove generic_hweight{64,32,16,8}()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
include/asm-s390/bitops.h | 44 +++++--------------------------------------- 1 files changed, 5 insertions(+), 39 deletions(-)
include/asm-s390/bitops.h +5 -39
@@ -828,35 +828,12 @@ static inline int sched_find_first_bit(ureturn find_first_bit (b,140 ); } -/* -* ffs: find first bit set. This is defined the same way as -* the libc and compiler builtin ffs routines, therefore -* differs in spirit from the above ffz (man ffs). -*/ -#define ffs (x) generic_ffs(x) +#include <asm-generic/bitops/ffs.h> -/* -* fls: find last bit set. -*/ -#define fls (x) generic_fls(x) -#define fls64 (x) generic_fls64(x) - -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ -#define hweight64 (x) \ -({ \ - unsigned long __x = (x); \ - unsigned int __w; \ - __w = generic_hweight32((unsigned int) __x); \ - __w += generic_hweight32((unsigned int) (__x>>32)); \ - __w; \ -}) -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) +#include <asm-generic/bitops/fls.h> +#include <asm-generic/bitops/fls64.h> +#include <asm-generic/bitops/hweight.h> #ifdef __KERNEL__
@@ -1011,18 +988,7 @@ ext2_find_next_zero_bit(void *vaddr, uns return offset + ext2_find_first_zero_bit(p, size); } -/* Bitmap functions for the minix filesystem. */ -/* FIXME !!! */ -#define minix_test_and_set_bit (nr,addr) \ - __test_and_set_bit(nr,(unsigned long *)addr) -#define minix_set_bit (nr,addr) \ - __set_bit(nr,(unsigned long *)addr) -#define minix_test_and_clear_bit (nr,addr) \ - __test_and_clear_bit(nr,(unsigned long *)addr) -#define minix_test_bit (nr,addr) \ - test_bit(nr,(unsigned long *)addr) -#define minix_find_first_zero_bit (addr,size) \ - find_first_zero_bit(addr,size) +#include <asm-generic/bitops/minix.h> #endif /* __KERNEL__ */
--
PATCH 33/44 sh: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- remove find_{next,first}{,_zero}_bit()
- remove generic_ffs()
- remove generic_hweight{32,16,8}()
- remove sched_find_first_bit()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove ext2_{set,clear}_bit_atomic()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
- remove generic_fls()
- remove generic_fls64()
include/asm-sh/bitops.h | 342 +----------------------------------------------- 1 files changed, 10 insertions(+), 332 deletions(-)
include/asm-sh/bitops.h +10 -332
@@ -19,16 +19,6 @@ static __inline__ void set_bit(int nr, vlocal_irq_restore (flags); } -static __inline__void __set_bit (int nr,volatile void * addr) -{ -int mask; -volatile unsigned int *a = addr; - - a += nr >>5 ; - mask =1 << (nr &0x1f ); - *a |= mask; -} -/* * clear_bit() doesn't provide any barrier for the compiler. */
@@ -47,16 +37,6 @@ static __inline__ void clear_bit(int nr,local_irq_restore (flags); } -static __inline__void __clear_bit (int nr,volatile void * addr) -{ -int mask; -volatile unsigned int *a = addr; - - a += nr >>5 ; - mask =1 << (nr &0x1f ); - *a &= ~mask; -} -static __inline__void change_bit (int nr,volatile void * addr) {int mask;
@@ -70,16 +50,6 @@ static __inline__ void change_bit(int nrlocal_irq_restore (flags); } -static __inline__void __change_bit (int nr,volatile void * addr) -{ -int mask; -volatile unsigned int *a = addr; - - a += nr >>5 ; - mask =1 << (nr &0x1f ); - *a ^= mask; -} -static __inline__int test_and_set_bit (int nr,volatile void * addr) {int mask, retval;
@@ -96,19 +66,6 @@ static __inline__ int test_and_set_bit(ireturn retval; } -static __inline__int __test_and_set_bit (int nr,volatile void * addr) -{ -int mask, retval; -volatile unsigned int *a = addr; - - a += nr >>5 ; - mask =1 << (nr &0x1f ); - retval = (mask & *a) !=0 ; - *a |= mask; - -return retval; -} -static __inline__int test_and_clear_bit (int nr,volatile void * addr) {int mask, retval;
@@ -125,19 +82,6 @@ static __inline__ int test_and_clear_bitreturn retval; } -static __inline__int __test_and_clear_bit (int nr,volatile void * addr) -{ -int mask, retval; -volatile unsigned int *a = addr; - - a += nr >>5 ; - mask =1 << (nr &0x1f ); - retval = (mask & *a) !=0 ; - *a &= ~mask; - -return retval; -} -static __inline__int test_and_change_bit (int nr,volatile void * addr) {int mask, retval;
@@ -154,23 +98,7 @@ static __inline__ int test_and_change_bireturn retval; } -static __inline__int __test_and_change_bit (int nr,volatile void * addr) -{ -int mask, retval; -volatile unsigned int *a = addr; - - a += nr >>5 ; - mask =1 << (nr &0x1f ); - retval = (mask & *a) !=0 ; - *a ^= mask; - -return retval; -} - -static __inline__int test_bit (int nr,const volatile void *addr) -{ -return 1UL & (((const volatile unsigned int *) addr)[nr >>5 ] >> (nr &31 )); -} +#include <asm-generic/bitops/non-atomic.h> static __inline__unsigned long ffz (unsigned long word) {
@@ -206,265 +134,15 @@ static __inline__ unsigned long __ffs(un return result; } -/** -* find_next_bit - find the next 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 -*/ -static __inline__unsigned long find_next_bit (const unsigned long *addr, -unsigned long size,unsigned long offset) -{ -unsigned int *p = ((unsigned int *) addr) + (offset >>5 ); -unsigned int result = offset & ~31UL ; -unsigned int tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *p++; - tmp &= ~0UL << offset; -if (size <32 ) - goto found_first; -if (tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size >=32 ) { -if ((tmp = *p++) !=0 ) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp &= ~0UL >> (32 - size); -if (tmp ==0UL )/* Are any bits set? */ -return result + size;/* Nope. */ -found_middle: -return result +__ffs (tmp); -} - -/** -* 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. -*/ -#define find_first_bit (addr, size) \ - find_next_bit((addr), (size), 0) - -static __inline__int find_next_zero_bit (const unsigned long *addr,int size,int offset) -{ -const unsigned long *p = ((unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *(p++); - tmp |= ~0UL >> (32 -offset); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp |= ~0UL << size; -found_middle: -return result +ffz (tmp); -} - -#define find_first_zero_bit (addr, size) \ - find_next_zero_bit((addr), (size), 0) - -/* -* ffs: find first bit set. This is defined the same way as -* the libc and compiler builtin ffs routines, therefore -* differs in spirit from the above ffz (man ffs). -*/ - -#define ffs (x) generic_ffs(x) - -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ - -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) - -/* -* 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 ; -} - -#ifdef __LITTLE_ENDIAN__ -#define ext2_set_bit (nr, addr) __test_and_set_bit((nr), (addr)) -#define ext2_clear_bit (nr, addr) __test_and_clear_bit((nr), (addr)) -#define ext2_test_bit (nr, addr) test_bit((nr), (addr)) -#define ext2_find_first_zero_bit (addr, size) find_first_zero_bit((addr), (size)) -#define ext2_find_next_zero_bit (addr, size, offset) \ - find_next_zero_bit((unsigned long *)(addr), (size), (offset)) -#else -static __inline__int ext2_set_bit (int nr,volatile void * addr) -{ -int mask, retval; -volatile unsigned char *ADDR = (unsigned char *) addr; - -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); - retval = (mask & *ADDR ) !=0 ; - *ADDR |= mask; -return retval; -} - -static __inline__int ext2_clear_bit (int nr,volatile void * addr) -{ -int mask, retval; -volatile unsigned char *ADDR = (unsigned char *) addr; - -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); - retval = (mask & *ADDR ) !=0 ; - *ADDR &= ~mask; -return retval; -} - -static __inline__int ext2_test_bit (int nr,const volatile void * addr) -{ -int mask; -const volatile unsigned char *ADDR = (const unsigned char *) addr; - -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); -return ((mask & *ADDR ) !=0 ); -} - -#define ext2_find_first_zero_bit (addr, size) \ - ext2_find_next_zero_bit((addr), (size), 0) - -static __inline__unsigned long ext2_find_next_zero_bit (void *addr,unsigned long size,unsigned long offset) -{ -unsigned long *p = ((unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { -/* We hold the little endian value in tmp, but then the -* shift is illegal. So we could keep a big endian value -* in tmp, like this: -* -* tmp = __swab32(*(p++)); -* tmp |= ~0UL >> (32-offset); -* -* but this would decrease preformance, so we change the -* shift: -*/ - tmp = *(p++); - tmp |=__swab32 (~0UL >> (32 -offset)); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: -/* tmp is little endian, so we would have to swab the shift, -* see above. But then we have to swab tmp below for ffz, so -* we might as well do this here. -*/ -return result +ffz (__swab32 (tmp) | (~0UL << size)); -found_middle: -return result +ffz (__swab32 (tmp)); -} -#endif - -#define ext2_set_bit_atomic (lock, nr, addr) \ - ({ \ - int ret; \ - spin_lock(lock); \ - ret = ext2_set_bit((nr), (addr)); \ - spin_unlock(lock); \ - ret; \ - }) - -#define ext2_clear_bit_atomic (lock, nr, addr) \ - ({ \ - int ret; \ - spin_lock(lock); \ - ret = ext2_clear_bit((nr), (addr)); \ - spin_unlock(lock); \ - ret; \ - }) - -/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) __set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr) -#define minix_test_bit (nr,addr) test_bit(nr,addr) -#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size) - -/* -* fls: find last bit set. -*/ - -#define fls (x) generic_fls(x) -#define fls64 (x) generic_fls64(x) +#include <asm-generic/bitops/find.h> +#include <asm-generic/bitops/ffs.h> +#include <asm-generic/bitops/hweight.h> +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/ext2-non-atomic.h> +#include <asm-generic/bitops/ext2-atomic.h> +#include <asm-generic/bitops/minix.h> +#include <asm-generic/bitops/fls.h> +#include <asm-generic/bitops/fls64.h> #endif /* __KERNEL__ */
--
PATCH 34/44 sh64: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- remove __ffs()
- remove find_{next,first}{,_zero}_bit()
- remove generic_hweight{32,16,8}()
- remove sched_find_first_bit()
- remove generic_ffs()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove ext2_{set,clear}_bit_atomic()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
- remove generic_fls()
- remove generic_fls64()
include/asm-sh64/bitops.h | 384 +--------------------------------------------- 1 files changed, 11 insertions(+), 373 deletions(-)
include/asm-sh64/bitops.h +11 -373
@@ -31,16 +31,6 @@ static __inline__ void set_bit(int nr, vlocal_irq_restore (flags); } -static inline void __set_bit (int nr,void *addr) -{ -int mask; -unsigned int *a = addr; - - a += nr >>5 ; - mask =1 << (nr &0x1f ); - *a |= mask; -} -/* * clear_bit() doesn't provide any barrier for the compiler. */
@@ -58,15 +48,6 @@ static inline void clear_bit(int nr, vollocal_irq_restore (flags); } -static inline void __clear_bit (int nr,volatile unsigned long *a) -{ -int mask; - - a += nr >>5 ; - mask =1 << (nr &0x1f ); - *a &= ~mask; -} -static __inline__void change_bit (int nr,volatile void * addr) {int mask;
@@ -80,16 +61,6 @@ static __inline__ void change_bit(int nrlocal_irq_restore (flags); } -static __inline__void __change_bit (int nr,volatile void * addr) -{ -int mask; -volatile unsigned int *a = addr; - - a += nr >>5 ; - mask =1 << (nr &0x1f ); - *a ^= mask; -} -static __inline__int test_and_set_bit (int nr,volatile void * addr) {int mask, retval;
@@ -106,19 +77,6 @@ static __inline__ int test_and_set_bit(ireturn retval; } -static __inline__int __test_and_set_bit (int nr,volatile void * addr) -{ -int mask, retval; -volatile unsigned int *a = addr; - - a += nr >>5 ; - mask =1 << (nr &0x1f ); - retval = (mask & *a) !=0 ; - *a |= mask; - -return retval; -} -static __inline__int test_and_clear_bit (int nr,volatile void * addr) {int mask, retval;
@@ -135,19 +93,6 @@ static __inline__ int test_and_clear_bitreturn retval; } -static __inline__int __test_and_clear_bit (int nr,volatile void * addr) -{ -int mask, retval; -volatile unsigned int *a = addr; - - a += nr >>5 ; - mask =1 << (nr &0x1f ); - retval = (mask & *a) !=0 ; - *a &= ~mask; - -return retval; -} -static __inline__int test_and_change_bit (int nr,volatile void * addr) {int mask, retval;
@@ -164,23 +109,7 @@ static __inline__ int test_and_change_bireturn retval; } -static __inline__int __test_and_change_bit (int nr,volatile void * addr) -{ -int mask, retval; -volatile unsigned int *a = addr; - - a += nr >>5 ; - mask =1 << (nr &0x1f ); - retval = (mask & *a) !=0 ; - *a ^= mask; - -return retval; -} - -static __inline__int test_bit (int nr,const volatile void *addr) -{ -return 1UL & (((const volatile unsigned int *) addr)[nr >>5 ] >> (nr &31 )); -} +#include <asm-generic/bitops/non-atomic.h> static __inline__unsigned long ffz (unsigned long word) {
@@ -204,307 +133,16 @@ static __inline__ unsigned long ffz(unsi return result; } -/** -* __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) -{ -int r =0 ; - -if (!word) -return 0 ; -if (!(word &0xffff )) { - word >>=16 ; - r +=16 ; - } -if (!(word &0xff )) { - word >>=8 ; - r +=8 ; - } -if (!(word &0xf )) { - word >>=4 ; - r +=4 ; - } -if (!(word &3 )) { - word >>=2 ; - r +=2 ; - } -if (!(word &1 )) { - word >>=1 ; - r +=1 ; - } -return r; -} - -/** -* find_next_bit - find the next 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 -*/ -static inline unsigned long find_next_bit (const unsigned long *addr, -unsigned long size,unsigned long offset) -{ -unsigned int *p = ((unsigned int *) addr) + (offset >>5 ); -unsigned int result = offset & ~31UL ; -unsigned int tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *p++; - tmp &= ~0UL << offset; -if (size <32 ) - goto found_first; -if (tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size >=32 ) { -if ((tmp = *p++) !=0 ) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp &= ~0UL >> (32 - size); -if (tmp ==0UL )/* Are any bits set? */ -return result + size;/* Nope. */ -found_middle: -return result +__ffs (tmp); -} - -/** -* 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. -*/ -#define find_first_bit (addr, size) \ - find_next_bit((addr), (size), 0) - - -static inline int find_next_zero_bit (void *addr,int size,int offset) -{ -unsigned long *p = ((unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *(p++); - tmp |= ~0UL >> (32 -offset); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp |= ~0UL << size; -found_middle: -return result +ffz (tmp); -} - -#define find_first_zero_bit (addr, size) \ - find_next_zero_bit((addr), (size), 0) - -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ - -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) - -/* -* 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 (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. This is defined the same way as -* the libc and compiler builtin ffs routines, therefore -* differs in spirit from the above ffz (man ffs). -*/ - -#define ffs (x) generic_ffs(x) - -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ - -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) - -#ifdef __LITTLE_ENDIAN__ -#define ext2_set_bit (nr, addr) __test_and_set_bit((nr), (addr)) -#define ext2_clear_bit (nr, addr) __test_and_clear_bit((nr), (addr)) -#define ext2_test_bit (nr, addr) test_bit((nr), (addr)) -#define ext2_find_first_zero_bit (addr, size) find_first_zero_bit((addr), (size)) -#define ext2_find_next_zero_bit (addr, size, offset) \ - find_next_zero_bit((addr), (size), (offset)) -#else -static __inline__int ext2_set_bit (int nr,volatile void * addr) -{ -int mask, retval; -volatile unsigned char *ADDR = (unsigned char *) addr; - -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); - retval = (mask & *ADDR ) !=0 ; - *ADDR |= mask; -return retval; -} - -static __inline__int ext2_clear_bit (int nr,volatile void * addr) -{ -int mask, retval; -volatile unsigned char *ADDR = (unsigned char *) addr; - -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); - retval = (mask & *ADDR ) !=0 ; - *ADDR &= ~mask; -return retval; -} - -static __inline__int ext2_test_bit (int nr,const volatile void * addr) -{ -int mask; -const volatile unsigned char *ADDR = (const unsigned char *) addr; - -ADDR += nr >>3 ; - mask =1 << (nr &0x07 ); -return ((mask & *ADDR ) !=0 ); -} - -#define ext2_find_first_zero_bit (addr, size) \ - ext2_find_next_zero_bit((addr), (size), 0) - -static __inline__unsigned long ext2_find_next_zero_bit (void *addr,unsigned long size,unsigned long offset) -{ -unsigned long *p = ((unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { -/* We hold the little endian value in tmp, but then the -* shift is illegal. So we could keep a big endian value -* in tmp, like this: -* -* tmp = __swab32(*(p++)); -* tmp |= ~0UL >> (32-offset); -* -* but this would decrease preformance, so we change the -* shift: -*/ - tmp = *(p++); - tmp |=__swab32 (~0UL >> (32 -offset)); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: -/* tmp is little endian, so we would have to swab the shift, -* see above. But then we have to swab tmp below for ffz, so -* we might as well do this here. -*/ -return result +ffz (__swab32 (tmp) | (~0UL << size)); -found_middle: -return result +ffz (__swab32 (tmp)); -} -#endif - -#define ext2_set_bit_atomic (lock, nr, addr) \ - ({ \ - int ret; \ - spin_lock(lock); \ - ret = ext2_set_bit((nr), (addr)); \ - spin_unlock(lock); \ - ret; \ - }) - -#define ext2_clear_bit_atomic (lock, nr, addr) \ - ({ \ - int ret; \ - spin_lock(lock); \ - ret = ext2_clear_bit((nr), (addr)); \ - spin_unlock(lock); \ - ret; \ - }) - -/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) __set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr) -#define minix_test_bit (nr,addr) test_bit(nr,addr) -#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size) - -#define ffs (x) generic_ffs(x) -#define fls (x) generic_fls(x) -#define fls64 (x) generic_fls64(x) +#include <asm-generic/bitops/__ffs.h> +#include <asm-generic/bitops/find.h> +#include <asm-generic/bitops/hweight.h> +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/ffs.h> +#include <asm-generic/bitops/ext2-non-atomic.h> +#include <asm-generic/bitops/ext2-atomic.h> +#include <asm-generic/bitops/minix.h> +#include <asm-generic/bitops/fls.h> +#include <asm-generic/bitops/fls64.h> #endif /* __KERNEL__ */
--
PATCH 35/44 sparc: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- remove ffz()
- remove __ffs()
- remove sched_find_first_bit()
- remove ffs()
- remove generic_fls()
- remove generic_fls64()
- remove generic_hweight{32,16,8}()
- remove find_{next,first}{,_zero}_bit()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove ext2_{set,clear}_bit_atomic()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
include/asm-sparc/bitops.h | 388 +-------------------------------------------- 1 files changed, 12 insertions(+), 376 deletions(-)
Index: 2.6-git/include/asm-sparc/bitops.h =================================--- 2.6-git.orig/include/asm-sparc/bitops.h +++ 2.6-git/include/asm-sparc/bitops.h
@@ -152,386 +152,22 @@ static inline void change_bit(unsigned l
: "memory", "cc");
}
-/*
- * non-atomic versions
- */
-static inline void __set_bit(int nr, volatile unsigned long *addr) -{
- unsigned long mask = 1UL << (nr & 0x1f);
- unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
-
- *p |= mask;
-}
-
-static inline void __clear_bit(int nr, volatile unsigned long *addr) -{
- unsigned long mask = 1UL << (nr & 0x1f);
- unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
-
- *p &= ~mask;
-}
-
-static inline void __change_bit(int nr, volatile unsigned long *addr) -{
- unsigned long mask = 1UL << (nr & 0x1f);
- unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
-
- *p ^= mask;
-}
-
-static inline int __test_and_set_bit(int nr, volatile unsigned long *addr) -{
- unsigned long mask = 1UL << (nr & 0x1f);
- unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
- unsigned long old = *p;
-
- *p = old | mask;
- return (old & mask) != 0;
-}
-
-static inline int __test_and_clear_bit(int nr, volatile unsigned long *addr) -{
- unsigned long mask = 1UL << (nr & 0x1f);
- unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
- unsigned long old = *p;
-
- *p = old & ~mask;
- return (old & mask) != 0;
-}
-
-static inline int __test_and_change_bit(int nr, volatile unsigned long *addr) -{
- unsigned long mask = 1UL << (nr & 0x1f);
- unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
- unsigned long old = *p;
-
- *p = old ^ mask;
- return (old & mask) != 0;
-}
+#include <asm-generic/bitops/non-atomic.h>
#define smp_mb__before_clear_bit() do { } while(0)
#define smp_mb__after_clear_bit() do { } while(0)
-/* The following routine need not be atomic. */
-static inline int test_bit(int nr, __const__ volatile unsigned long *addr) -{
- return (1UL & (((unsigned long *)addr)[nr >> 5] >> (nr & 31))) != 0UL;
-}
-
-/* The easy/cheese version for now. */
-static inline unsigned long ffz(unsigned long word)
-{
- unsigned long result = 0;
-
- while(word & 1) {
- result++;
- word >>= 1;
- }
- return result;
-}
-
-/**
- * __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 int __ffs(unsigned long word)
-{
- int num = 0;
-
- if ((word & 0xffff) = 0) {
- num += 16;
- word >>= 16;
- }
- if ((word & 0xff) = 0) {
- num += 8;
- word >>= 8;
- }
- if ((word & 0xf) = 0) {
- num += 4;
- word >>= 4;
- }
- if ((word & 0x3) = 0) {
- num += 2;
- word >>= 2;
- }
- if ((word & 0x1) = 0)
- num += 1;
- return num;
-}
-
-/*
- * 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(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. 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)
-{
- if (!x)
- return 0;
- return __ffs((unsigned long)x) + 1;
-}
-
-/*
- * fls: find last (most-significant) bit set.
- * Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.
- */
-#define fls(x) generic_fls(x)
-#define fls64(x) generic_fls64(x)
-
-/*
- * hweightN: returns the hamming weight (i.e. the number
- * of bits set) of a N-bit word
- */
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
-
-/*
- * find_next_zero_bit() finds the first zero bit in a bit string of length
- * 'size' bits, starting the search at bit 'offset'. This is largely based
- * on Linus's ALPHA routines, which are pretty portable BTW.
- */
-static inline unsigned long find_next_zero_bit(const unsigned long *addr,
- unsigned long size, unsigned long offset)
-{
- const unsigned long *p = addr + (offset >> 5);
- unsigned long result = offset & ~31UL;
- unsigned long tmp;
-
- if (offset >= size)
- return size;
- size -= result;
- offset &= 31UL;
- if (offset) {
- tmp = *(p++);
- tmp |= ~0UL >> (32-offset);
- if (size < 32)
- goto found_first;
- if (~tmp)
- goto found_middle;
- size -= 32;
- result += 32;
- }
- while (size & ~31UL) {
- if (~(tmp = *(p++)))
- goto found_middle;
- result += 32;
- size -= 32;
- }
- if (!size)
- return result;
- tmp = *p;
-
-found_first:
- tmp |= ~0UL << size;
- if (tmp = ~0UL) /* Are any bits zero? */
- return result + size; /* Nope. */
-found_middle:
- return result + ffz(tmp);
-}
-
-/*
- * Linus sez that gcc can optimize the following correctly, we'll see if this
- * holds on the Sparc as it does for the ALPHA.
- */
-#define find_first_zero_bit(addr, size) \
- find_next_zero_bit((addr), (size), 0)
-
-/**
- * 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
- *
- * Scheduler induced bitop, do not use.
- */
-static inline int find_next_bit(const unsigned long *addr, int size, int offset) -{
- const unsigned long *p = addr + (offset >> 5);
- int num = offset & ~0x1f;
- unsigned long word;
-
- word = *p++;
- word &= ~((1 << (offset & 0x1f)) - 1);
- while (num < size) {
- if (word != 0) {
- return __ffs(word) + num;
- }
- word = *p++;
- num += 0x20;
- }
- return num;
-}
-
-/**
- * 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.
- */
-#define find_first_bit(addr, size) \
- find_next_bit((addr), (size), 0)
-
-/*
- */
-static inline int test_le_bit(int nr, __const__ unsigned long * addr) -{
- __const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
- return (ADDR[nr >> 3] >> (nr & 7)) & 1;
-}
-
-/*
- * non-atomic versions
- */
-static inline void __set_le_bit(int nr, unsigned long *addr)
-{
- unsigned char *ADDR = (unsigned char *)addr;
-
- ADDR += nr >> 3;
- *ADDR |= 1 << (nr & 0x07);
-}
-
-static inline void __clear_le_bit(int nr, unsigned long *addr)
-{
- unsigned char *ADDR = (unsigned char *)addr;
-
- ADDR += nr >> 3;
- *ADDR &= ~(1 << (nr & 0x07));
-}
-
-static inline int __test_and_set_le_bit(int nr, unsigned long *addr) -{
- int mask, retval;
- unsigned char *ADDR = (unsigned char *)addr;
-
- ADDR += nr >> 3;
- mask = 1 << (nr & 0x07);
- retval = (mask & *ADDR) != 0;
- *ADDR |= mask;
- return retval;
-}
-
-static inline int __test_and_clear_le_bit(int nr, unsigned long *addr) -{
- int mask, retval;
- unsigned char *ADDR = (unsigned char *)addr;
-
- ADDR += nr >> 3;
- mask = 1 << (nr & 0x07);
- retval = (mask & *ADDR) != 0;
- *ADDR &= ~mask;
- return retval;
-}
-
-static inline unsigned long find_next_zero_le_bit(const unsigned long *addr,
- unsigned long size, unsigned long offset)
-{
- const unsigned long *p = addr + (offset >> 5);
- unsigned long result = offset & ~31UL;
- unsigned long tmp;
-
- if (offset >= size)
- return size;
- size -= result;
- offset &= 31UL;
- if(offset) {
- tmp = *(p++);
- tmp |= __swab32(~0UL >> (32-offset));
- if(size < 32)
- goto found_first;
- if(~tmp)
- goto found_middle;
- size -= 32;
- result += 32;
- }
- while(size & ~31UL) {
- if(~(tmp = *(p++)))
- goto found_middle;
- result += 32;
- size -= 32;
- }
- if(!size)
- return result;
- tmp = *p;
-
-found_first:
- tmp = __swab32(tmp) | (~0UL << size);
- if (tmp = ~0UL) /* Are any bits zero? */
- return result + size; /* Nope. */
- return result + ffz(tmp);
-
-found_middle:
- return result + ffz(__swab32(tmp));
-}
-
-#define find_first_zero_le_bit(addr, size) \
- find_next_zero_le_bit((addr), (size), 0)
-
-#define ext2_set_bit(nr,addr) \
- __test_and_set_le_bit((nr),(unsigned long *)(addr))
-#define ext2_clear_bit(nr,addr) \
- __test_and_clear_le_bit((nr),(unsigned long *)(addr))
-
-#define ext2_set_bit_atomic(lock, nr, addr) \
- ({ \
- int ret; \
- spin_lock(lock); \
- ret = ext2_set_bit((nr), (unsigned long *)(addr)); \
- spin_unlock(lock); \
- ret; \
- })
-
-#define ext2_clear_bit_atomic(lock, nr, addr) \
- ({ \
- int ret; \
- spin_lock(lock); \
- ret = ext2_clear_bit((nr), (unsigned long *)(addr)); \
- spin_unlock(lock); \
- ret; \
- })
-
-#define ext2_test_bit(nr,addr) \
- test_le_bit((nr),(unsigned long *)(addr))
-#define ext2_find_first_zero_bit(addr, size) \
- find_first_zero_le_bit((unsigned long *)(addr), (size))
-#define ext2_find_next_zero_bit(addr, size, off) \
- find_next_zero_le_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),(unsigned long *)(addr))
-#define minix_set_bit(nr,addr) \
- __set_bit((nr),(unsigned long *)(addr))
-#define minix_test_and_clear_bit(nr,addr) \
- __test_and_clear_bit((nr),(unsigned long *)(addr))
-#define minix_test_bit(nr,addr) \
- test_bit((nr),(unsigned long *)(addr))
-#define minix_find_first_zero_bit(addr,size) \
- find_first_zero_bit((unsigned long *)(addr),(size))
+#include <asm-generic/bitops/ffz.h>
+#include <asm-generic/bitops/__ffs.h>
+#include <asm-generic/bitops/sched.h>
+#include <asm-generic/bitops/ffs.h>
+#include <asm-generic/bitops/fls.h>
+#include <asm-generic/bitops/fls64.h>
+#include <asm-generic/bitops/hweight.h>
+#include <asm-generic/bitops/find.h>
+#include <asm-generic/bitops/ext2-non-atomic.h>
+#include <asm-generic/bitops/ext2-atomic.h>
+#include <asm-generic/bitops/minix.h>
#endif /* __KERNEL__ */
--
PATCH 36/44 sparc64: use generic bitops
In reply to Akinobu Mita- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- remove ffz()
- remove __ffs()
- remove generic_fls()
- remove generic_fls64()
- remove sched_find_first_bit()
- remove ffs()
- unless defined(ULTRA_HAS_POPULATION_COUNT)
- remove generic_hweight{64,32,16,8}()
- remove find_{next,first}{,_zero}_bit()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
arch/sparc64/kernel/sparc64_ksyms.c | 5 arch/sparc64/lib/Makefile | 2 arch/sparc64/lib/find_bit.c | 127 -------------------- include/asm-sparc64/bitops.h | 221 ++---------------------------------- 4 files changed, 15 insertions(+), 340 deletions(-)
Index: 2.6-git/include/asm-sparc64/bitops.h =================================--- 2.6-git.orig/include/asm-sparc64/bitops.h +++ 2.6-git/include/asm-sparc64/bitops.h
@@ -18,58 +18,7 @@ extern void set_bit(unsigned long nr, vo
extern void clear_bit(unsigned long nr, volatile unsigned long *addr); extern void change_bit(unsigned long nr, volatile unsigned long *addr);
-/* "non-atomic" versions... */
-
-static inline void __set_bit(int nr, volatile unsigned long *addr) -{
- unsigned long *m = ((unsigned long *)addr) + (nr >> 6);
-
- *m |= (1UL << (nr & 63));
-}
-
-static inline void __clear_bit(int nr, volatile unsigned long *addr) -{
- unsigned long *m = ((unsigned long *)addr) + (nr >> 6);
-
- *m &= ~(1UL << (nr & 63));
-}
-
-static inline void __change_bit(int nr, volatile unsigned long *addr) -{
- unsigned long *m = ((unsigned long *)addr) + (nr >> 6);
-
- *m ^= (1UL << (nr & 63));
-}
-
-static inline int __test_and_set_bit(int nr, volatile unsigned long *addr) -{
- unsigned long *m = ((unsigned long *)addr) + (nr >> 6);
- unsigned long old = *m;
- unsigned long mask = (1UL << (nr & 63));
-
- *m = (old | mask);
- return ((old & mask) != 0);
-}
-
-static inline int __test_and_clear_bit(int nr, volatile unsigned long *addr) -{
- unsigned long *m = ((unsigned long *)addr) + (nr >> 6);
- unsigned long old = *m;
- unsigned long mask = (1UL << (nr & 63));
-
- *m = (old & ~mask);
- return ((old & mask) != 0);
-}
-
-static inline int __test_and_change_bit(int nr, volatile unsigned long *addr) -{
- unsigned long *m = ((unsigned long *)addr) + (nr >> 6);
- unsigned long old = *m;
- unsigned long mask = (1UL << (nr & 63));
-
- *m = (old ^ mask);
- return ((old & mask) != 0);
-}
+#include <asm-generic/bitops/non-atomic.h>
#ifdef CONFIG_SMP
#define smp_mb__before_clear_bit() membar_storeload_loadload()
@@ -79,78 +28,15 @@ static inline int __test_and_change_bit(
#define smp_mb__after_clear_bit() barrier()
#endif
-static inline int test_bit(int nr, __const__ volatile unsigned long *addr) -{
- return (1UL & (addr[nr >> 6] >> (nr & 63))) != 0UL;
-}
-
-/* The easy/cheese version for now. */
-static inline unsigned long ffz(unsigned long word)
-{
- unsigned long result;
-
- result = 0;
- while(word & 1) {
- result++;
- word >>= 1;
- }
- return result;
-}
-
-/**
- * __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)
-{
- unsigned long result = 0;
-
- while (!(word & 1UL)) {
- result++;
- word >>= 1;
- }
- return result;
-}
-
-/*
- * fls: find last bit set.
- */
-
-#define fls(x) generic_fls(x)
-#define fls64(x) generic_fls64(x)
+#include <asm-generic/bitops/ffz.h>
+#include <asm-generic/bitops/__ffs.h>
+#include <asm-generic/bitops/fls.h>
+#include <asm-generic/bitops/fls64.h>
#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(unsigned long *b) -{
- if (unlikely(b[0]))
- return __ffs(b[0]);
- if (unlikely(((unsigned int)b[1])))
- return __ffs(b[1]) + 64;
- if (b[1] >> 32)
- return __ffs(b[1] >> 32) + 96;
- return __ffs(b[2]) + 128;
-}
-
-/*
- * ffs: find first bit set. 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)
-{
- if (!x)
- return 0;
- return __ffs((unsigned long)x) + 1;
-}
+#include <asm-generic/bitops/sched.h>
+#include <asm-generic/bitops/ffs.h>
/*
* hweightN: returns the hamming weight (i.e. the number
@@ -193,102 +79,23 @@ static inline unsigned int hweight8(unsi
#else
-#define hweight64(x) generic_hweight64(x)
-#define hweight32(x) generic_hweight32(x)
-#define hweight16(x) generic_hweight16(x)
-#define hweight8(x) generic_hweight8(x)
+#include <asm-generic/bitops/hweight.h>
#endif
#endif /* __KERNEL__ */
-/**
- * find_next_bit - find the next 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
- */
-extern unsigned long find_next_bit(const unsigned long *, unsigned long,
- unsigned long);
-
-/**
- * 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.
- */
-#define find_first_bit(addr, size) \
- find_next_bit((addr), (size), 0)
-
-/* find_next_zero_bit() finds the first zero bit in a bit string of length
- * 'size' bits, starting the search at bit 'offset'. This is largely based
- * on Linus's ALPHA routines, which are pretty portable BTW.
- */
-
-extern unsigned long find_next_zero_bit(const unsigned long *,
- unsigned long, unsigned long);
-
-#define find_first_zero_bit(addr, size) \
- find_next_zero_bit((addr), (size), 0)
-
-#define test_and_set_le_bit(nr,addr) \
- test_and_set_bit((nr) ^ 0x38, (addr))
-#define test_and_clear_le_bit(nr,addr) \
- test_and_clear_bit((nr) ^ 0x38, (addr))
-
-static inline int test_le_bit(int nr, __const__ unsigned long * addr)
-{
- int mask;
- __const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
-
- ADDR += nr >> 3;
- mask = 1 << (nr & 0x07);
- return ((mask & *ADDR) != 0);
-}
-
-#define find_first_zero_le_bit(addr, size) \
- find_next_zero_le_bit((addr), (size), 0)
-
-extern unsigned long find_next_zero_le_bit(unsigned long *, unsigned long, unsigned long); +#include <asm-generic/bitops/find.h>
#ifdef __KERNEL__
-#define __set_le_bit(nr, addr) \
- __set_bit((nr) ^ 0x38, (addr))
-#define __clear_le_bit(nr, addr) \
- __clear_bit((nr) ^ 0x38, (addr))
-#define __test_and_clear_le_bit(nr, addr) \
- __test_and_clear_bit((nr) ^ 0x38, (addr))
-#define __test_and_set_le_bit(nr, addr) \
- __test_and_set_bit((nr) ^ 0x38, (addr))
+#include <asm-generic/bitops/ext2-non-atomic.h>
-#define ext2_set_bit(nr,addr) \
- __test_and_set_le_bit((nr),(unsigned long *)(addr))
#define ext2_set_bit_atomic(lock,nr,addr) \
- test_and_set_le_bit((nr),(unsigned long *)(addr))
-#define ext2_clear_bit(nr,addr) \
- __test_and_clear_le_bit((nr),(unsigned long *)(addr))
+ test_and_set_bit((nr) ^ 0x38,(unsigned long *)(addr))
#define ext2_clear_bit_atomic(lock,nr,addr) \
- test_and_clear_le_bit((nr),(unsigned long *)(addr))
-#define ext2_test_bit(nr,addr) \
- test_le_bit((nr),(unsigned long *)(addr))
-#define ext2_find_first_zero_bit(addr, size) \
- find_first_zero_le_bit((unsigned long *)(addr), (size))
-#define ext2_find_next_zero_bit(addr, size, off) \
- find_next_zero_le_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),(unsigned long *)(addr))
-#define minix_set_bit(nr,addr) \
- __set_bit((nr),(unsigned long *)(addr))
-#define minix_test_and_clear_bit(nr,addr) \
- __test_and_clear_bit((nr),(unsigned long *)(addr))
-#define minix_test_bit(nr,addr) \
- test_bit((nr),(unsigned long *)(addr))
-#define minix_find_first_zero_bit(addr,size) \
- find_first_zero_bit((unsigned long *)(addr),(size))
+ test_and_clear_bit((nr) ^ 0x38,(unsigned long *)(addr))
+
+#include <asm-generic/bitops/minix.h>
#endif /* __KERNEL__ */
Index: 2.6-git/arch/sparc64/kernel/sparc64_ksyms.c =================================--- 2.6-git.orig/arch/sparc64/kernel/sparc64_ksyms.c +++ 2.6-git/arch/sparc64/kernel/sparc64_ksyms.c
@@ -170,11 +170,6 @@ EXPORT_SYMBOL(set_bit);
EXPORT_SYMBOL(clear_bit);
EXPORT_SYMBOL(change_bit);
-/* Bit searching */
-EXPORT_SYMBOL(find_next_bit); -EXPORT_SYMBOL(find_next_zero_bit); -EXPORT_SYMBOL(find_next_zero_le_bit);
-
EXPORT_SYMBOL(ivector_table);
EXPORT_SYMBOL(enable_irq);
EXPORT_SYMBOL(disable_irq);
Index: 2.6-git/arch/sparc64/lib/Makefile =================================--- 2.6-git.orig/arch/sparc64/lib/Makefile +++ 2.6-git/arch/sparc64/lib/Makefile
@@ -12,6 +12,6 @@ lib-y := PeeCeeI.o copy_page.o clear_pag
U1memcpy.o U1copy_from_user.o U1copy_to_user.o \
U3memcpy.o U3copy_from_user.o U3copy_to_user.o U3patch.o \
copy_in_user.o user_fixup.o memmove.o \
- mcount.o ipcsum.o rwsem.o xor.o find_bit.o delay.o
+ mcount.o ipcsum.o rwsem.o xor.o delay.o
obj-y += iomap.o
Index: 2.6-git/arch/sparc64/lib/find_bit.c
=================================--- 2.6-git.orig/arch/sparc64/lib/find_bit.c
+++ /dev/null
@@ -1,127 +0,0 @@
-#include <linux/bitops.h>
-
-/**
- * find_next_bit - find the next 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
- */
-unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
- unsigned long offset)
-{
- const unsigned long *p = addr + (offset >> 6);
- unsigned long result = offset & ~63UL;
- unsigned long tmp;
-
- if (offset >= size)
- return size;
- size -= result;
- offset &= 63UL;
- if (offset) {
- tmp = *(p++);
- tmp &= (~0UL << offset);
- if (size < 64)
- goto found_first;
- if (tmp)
- goto found_middle;
- size -= 64;
- result += 64;
- }
- while (size & ~63UL) {
- if ((tmp = *(p++)))
- goto found_middle;
- result += 64;
- size -= 64;
- }
- if (!size)
- return result;
- tmp = *p;
-
-found_first:
- tmp &= (~0UL >> (64 - size));
- if (tmp = 0UL) /* Are any bits set? */
- return result + size; /* Nope. */
-found_middle:
- return result + __ffs(tmp);
-}
-
-/* find_next_zero_bit() finds the first zero bit in a bit string of length
- * 'size' bits, starting the search at bit 'offset'. This is largely based
- * on Linus's ALPHA routines, which are pretty portable BTW.
- */
-
-unsigned long find_next_zero_bit(const unsigned long *addr,
- unsigned long size, unsigned long offset)
-{
- const unsigned long *p = addr + (offset >> 6);
- unsigned long result = offset & ~63UL;
- unsigned long tmp;
-
- if (offset >= size)
- return size;
- size -= result;
- offset &= 63UL;
- if (offset) {
- tmp = *(p++);
- tmp |= ~0UL >> (64-offset);
- if (size < 64)
- goto found_first;
- if (~tmp)
- goto found_middle;
- size -= 64;
- result += 64;
- }
- while (size & ~63UL) {
- if (~(tmp = *(p++)))
- goto found_middle;
- result += 64;
- size -= 64;
- }
- if (!size)
- return result;
- tmp = *p;
-
-found_first:
- tmp |= ~0UL << size;
- if (tmp = ~0UL) /* Are any bits zero? */
- return result + size; /* Nope. */
-found_middle:
- return result + ffz(tmp);
-}
-
-unsigned long find_next_zero_le_bit(unsigned long *addr, unsigned long size, unsigned long offset) -{
- unsigned long *p = addr + (offset >> 6);
- unsigned long result = offset & ~63UL;
- unsigned long tmp;
-
- if (offset >= size)
- return size;
- size -= result;
- offset &= 63UL;
- if(offset) {
- tmp = __swab64p(p++);
- tmp |= (~0UL >> (64-offset));
- if(size < 64)
- goto found_first;
- if(~tmp)
- goto found_middle;
- size -= 64;
- result += 64;
- }
- while(size & ~63) {
- if(~(tmp = __swab64p(p++)))
- goto found_middle;
- result += 64;
- size -= 64;
- }
- if(!size)
- return result;
- tmp = __swab64p(p);
-found_first:
- tmp |= (~0UL << size);
- if (tmp = ~0UL) /* Are any bits zero? */
- return result + size; /* Nope. */
-found_middle:
- return result + ffz(tmp);
-}
--
PATCH 37/44 v850: use generic bitops
In reply to Akinobu Mita- remove ffz()
- remove find_{next,first}{,_zero}_bit()
- remove generic_ffs()
- remove generic_fls()
- remove generic_fls64()
- remove __ffs()
- remove sched_find_first_bit()
- remove generic_hweight{32,16,8}()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
include/asm-v850/bitops.h | 222 ++-------------------------------------------- 1 files changed, 12 insertions(+), 210 deletions(-)
include/asm-v850/bitops.h +12 -210
@@ -22,25 +22,11 @@#ifdef __KERNEL__ -/* -* The __ functions are not atomic -*/ +#include <asm-generic/bitops/ffz.h> /* -* ffz = Find First Zero in word. Undefined if no zero exists, -* so code should check against ~0UL first.. +* The __ functions are not atomic */ -static inline unsigned long ffz (unsigned long word) -{ -unsigned long result =0 ; - -while (word &1 ) { - result++; - word >>=1 ; - } -return result; -} -/* In the following constant-bit-op macros, a "g" constraint is used when we really need an integer ("i" constraint). This is to avoid
@@ -153,203 +139,19 @@ static inline int __test_bit (int nr, co#define smp_mb__before_clear_bit () barrier ()#define smp_mb__after_clear_bit () barrier () +#include <asm-generic/bitops/ffs.h> +#include <asm-generic/bitops/fls.h> +#include <asm-generic/bitops/fls64.h> +#include <asm-generic/bitops/__ffs.h> +#include <asm-generic/bitops/find.h> +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/hweight.h> -#define find_first_zero_bit (addr, size) \ - find_next_zero_bit ((addr), (size), 0) - -static inline int find_next_zero_bit (const void *addr,int size,int offset) -{ -unsigned long *p = ((unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = * (p++); - tmp |= ~0UL >> (32 -offset); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~ (tmp = * (p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - - found_first: - tmp |= ~0UL >> size; - found_middle: -return result +ffz (tmp); -} - - -/* This is the same as generic_ffs, but we can't use that because it's -inline and the #include order mucks things up. */ -static inline int generic_ffs_for_find_next_bit (int x) -{ -int r =1 ; - -if (!x) -return 0 ; -if (!(x &0xffff )) { - x >>=16 ; - r +=16 ; - } -if (!(x &0xff )) { - x >>=8 ; - r +=8 ; - } -if (!(x &0xf )) { - x >>=4 ; - r +=4 ; - } -if (!(x &3 )) { - x >>=2 ; - r +=2 ; - } -if (!(x &1 )) { - x >>=1 ; - r +=1 ; - } -return r; -} - -/* -* Find next one bit in a bitmap reasonably efficiently. -*/ -static __inline__unsigned long find_next_bit (const unsigned long *addr, -unsigned long size,unsigned long offset) -{ -unsigned int *p = ((unsigned int *) addr) + (offset >>5 ); -unsigned int result = offset & ~31UL ; -unsigned int tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *p++; - tmp &= ~0UL << offset; -if (size <32 ) - goto found_first; -if (tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size >=32 ) { -if ((tmp = *p++) !=0 ) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp &= ~0UL >> (32 - size); -if (tmp ==0UL )/* Are any bits set? */ -return result + size;/* Nope. */ -found_middle: -return result +generic_ffs_for_find_next_bit (tmp); -} - -/* -* find_first_bit - find the first set bit in a memory region -*/ -#define find_first_bit (addr, size) \ - find_next_bit((addr), (size), 0) - - -#define ffs (x) generic_ffs (x) -#define fls (x) generic_fls (x) -#define fls64 (x) generic_fls64(x) -#define __ffs (x) ffs(x) - - -/* -* This is just `generic_ffs' from <linux/bitops.h>, except that it assumes -* that at least one bit is set, and returns the real index of the bit -* (rather than the bit index + 1, like ffs does). -*/ -static inline int sched_ffs (int x) -{ -int r =0 ; - -if (!(x &0xffff )) { - x >>=16 ; - r +=16 ; - } -if (!(x &0xff )) { - x >>=8 ; - r +=8 ; - } -if (!(x &0xf )) { - x >>=4 ; - r +=4 ; - } -if (!(x &3 )) { - x >>=2 ; - r +=2 ; - } -if (!(x &1 )) { - x >>=1 ; - r +=1 ; - } -return r; -} - -/* -* 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 set. -*/ -static inline int sched_find_first_bit (unsigned long *b) -{ -unsigned offs =0 ; -while (! *b) { - b++; - offs +=32 ; - } -return sched_ffs (*b) + offs; -} - -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ -#define hweight32 (x) generic_hweight32 (x) -#define hweight16 (x) generic_hweight16 (x) -#define hweight8 (x) generic_hweight8 (x) - -#define ext2_set_bit __test_and_set_bit +#include <asm-generic/bitops/ext2-non-atomic.h> #define ext2_set_bit_atomic (l,n,a) test_and_set_bit(n,a) -#define ext2_clear_bit __test_and_clear_bit#define ext2_clear_bit_atomic (l,n,a) test_and_clear_bit(n,a) -#define ext2_test_bit test_bit -#define ext2_find_first_zero_bit find_first_zero_bit -#define ext2_find_next_zero_bit find_next_zero_bit - -/* Bitmap functions for the minix filesystem. */ -#define minix_test_and_set_bit __test_and_set_bit -#define minix_set_bit __set_bit -#define minix_test_and_clear_bit __test_and_clear_bit -#define minix_test_bit test_bit -#define minix_find_first_zero_bit find_first_zero_bit + +#include <asm-generic/bitops/minix.h> #endif /* __KERNEL__ */
--
PATCH 38/44 x86_64: use generic bitops
In reply to Akinobu Mita- remove sched_find_first_bit()
- remove generic_hweight{64,32,16,8}()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
include/asm-x86_64/bitops.h | 42 ++++++------------------------------------ 1 files changed, 6 insertions(+), 36 deletions(-)
include/asm-x86_64/bitops.h +6 -36
@@ -356,14 +356,7 @@ static __inline__ unsigned long __fls(un#ifdef __KERNEL__ -static inline int sched_find_first_bit (const unsigned long *b) -{ -if (b[0 ]) -return __ffs (b[0 ]); -if (b[1 ]) -return __ffs (b[1 ]) +64 ; -return __ffs (b[2 ]) +128 ; -} +#include <asm-generic/bitops/sched.h> /** * ffs - find first bit set
@@ -412,43 +405,20 @@ static __inline__ int fls(int 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 hweight64 (x) generic_hweight64(x) -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) +#include <asm-generic/bitops/hweight.h> #endif /* __KERNEL__ */ #ifdef __KERNEL__ -#define ext2_set_bit (nr,addr) \ - __test_and_set_bit((nr),(unsigned long*)addr) +#include <asm-generic/bitops/ext2-non-atomic.h> +#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) + +#include <asm-generic/bitops/minix.h> #endif /* __KERNEL__ */
--
PATCH 39/44 xtensa: use generic bitops
In reply to Akinobu Mita- remove {,test_and_}{set,clear,change}_bit()
- remove __{,test_and_}{set,clear,change}_bit() and test_bit()
- remove generic_fls64()
- remove find_{next,first}{,_zero}_bit()
- remove ext2_{set,clear,test,find_first_zero,find_next_zero}_bit()
- remove generic_hweight{32,16,8}()
- remove sched_find_first_bit()
- remove minix_{test,set,test_and_clear,test,find_first_zero}_bit()
include/asm-xtensa/bitops.h | 340 +------------------------------------------- 1 files changed, 8 insertions(+), 332 deletions(-)
include/asm-xtensa/bitops.h +8 -332
@@ -23,156 +23,11 @@# error SMP not supported on this architecture#endif -static __inline__void set_bit (int nr,volatile void * addr) -{ -unsigned long mask =1 << (nr &0x1f ); -unsigned long *a = ((unsigned long *)addr) + (nr >>5 ); -unsigned long flags; - -local_irq_save (flags); - *a |= mask; -local_irq_restore (flags); -} - -static __inline__void __set_bit (int nr,volatile unsigned long * addr) -{ -unsigned long mask =1 << (nr &0x1f ); -unsigned long *a = ((unsigned long *)addr) + (nr >>5 ); - - *a |= mask; -} - -static __inline__void clear_bit (int nr,volatile void * addr) -{ -unsigned long mask =1 << (nr &0x1f ); -unsigned long *a = ((unsigned long *)addr) + (nr >>5 ); -unsigned long flags; - -local_irq_save (flags); - *a &= ~mask; -local_irq_restore (flags); -} - -static __inline__void __clear_bit (int nr,volatile unsigned long *addr) -{ -unsigned long mask =1 << (nr &0x1f ); -unsigned long *a = ((unsigned long *)addr) + (nr >>5 ); - - *a &= ~mask; -} - -/* -* clear_bit() doesn't provide any barrier for the compiler. -*/ -#define smp_mb__before_clear_bit () barrier()#define smp_mb__after_clear_bit () barrier() -static __inline__void change_bit (int nr,volatile void * addr) -{ -unsigned long mask =1 << (nr &0x1f ); -unsigned long *a = ((unsigned long *)addr) + (nr >>5 ); -unsigned long flags; - -local_irq_save (flags); - *a ^= mask; -local_irq_restore (flags); -} - -static __inline__void __change_bit (int nr,volatile void * addr) -{ -unsigned long mask =1 << (nr &0x1f ); -unsigned long *a = ((unsigned long *)addr) + (nr >>5 ); - - *a ^= mask; -} - -static __inline__int test_and_set_bit (int nr,volatile void * addr) -{ -unsigned long retval; -unsigned long mask =1 << (nr &0x1f ); -unsigned long *a = ((unsigned long *)addr) + (nr >>5 ); -unsigned long flags; - -local_irq_save (flags); - retval = (mask & *a) !=0 ; - *a |= mask; -local_irq_restore (flags); - -return retval; -} - -static __inline__int __test_and_set_bit (int nr,volatile void * addr) -{ -unsigned long retval; -unsigned long mask =1 << (nr &0x1f ); -unsigned long *a = ((unsigned long *)addr) + (nr >>5 ); - - retval = (mask & *a) !=0 ; - *a |= mask; - -return retval; -} - -static __inline__int test_and_clear_bit (int nr,volatile void * addr) -{ -unsigned long retval; -unsigned long mask =1 << (nr &0x1f ); -unsigned long *a = ((unsigned long *)addr) + (nr >>5 ); -unsigned long flags; - -local_irq_save (flags); - retval = (mask & *a) !=0 ; - *a &= ~mask; -local_irq_restore (flags); - -return retval; -} - -static __inline__int __test_and_clear_bit (int nr,volatile void * addr) -{ -unsigned long mask =1 << (nr &0x1f ); -unsigned long *a = ((unsigned long *)addr) + (nr >>5 ); -unsigned long old = *a; - - *a = old & ~mask; -return (old & mask) !=0 ; -} - -static __inline__int test_and_change_bit (int nr,volatile void * addr) -{ -unsigned long retval; -unsigned long mask =1 << (nr &0x1f ); -unsigned long *a = ((unsigned long *)addr) + (nr >>5 ); -unsigned long flags; - -local_irq_save (flags); - - retval = (mask & *a) !=0 ; - *a ^= mask; -local_irq_restore (flags); - -return retval; -} - -/* -* non-atomic version; can be reordered -*/ - -static __inline__int __test_and_change_bit (int nr,volatile void *addr) -{ -unsigned long mask =1 << (nr &0x1f ); -unsigned long *a = ((unsigned long *)addr) + (nr >>5 ); -unsigned long old = *a; - - *a = old ^ mask; -return (old & mask) !=0 ; -} - -static __inline__int test_bit (int nr,const volatile void *addr) -{ -return 1UL & (((const volatile unsigned int *)addr)[nr>>5 ] >> (nr&31 )); -} +#include <asm-generic/bitops/atomic.h> +#include <asm-generic/bitops/non-atomic.h> #if XCHAL_HAVE_NSA
@@ -245,202 +100,23 @@ static __inline__ int fls (unsigned int {return __cntlz (x); } -#define fls64 (x) generic_fls64(x) - -static __inline__int -find_next_bit (const unsigned long *addr,int size,int offset) -{ -const unsigned long *p = addr + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *p++; - tmp &= ~0UL << offset; -if (size <32 ) - goto found_first; -if (tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size >=32 ) { -if ((tmp = *p++) !=0 ) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp &= ~0UL >> (32 - size); -if (tmp ==0UL )/* Are any bits set? */ -return result + size;/* Nope. */ -found_middle: -return result +__ffs (tmp); -} - -/** -* 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. -*/ - -#define find_first_bit (addr, size) \ - find_next_bit((addr), (size), 0) - -static __inline__int -find_next_zero_bit (const unsigned long *addr,int size,int offset) -{ -const unsigned long *p = addr + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { - tmp = *p++; - tmp |= ~0UL >> (32 -offset); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *p++)) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: - tmp |= ~0UL << size; -found_middle: -return result +ffz (tmp); -} - -#define find_first_zero_bit (addr, size) \ - find_next_zero_bit((addr), (size), 0) +#include <asm-generic/bitops/fls64.h> +#include <asm-generic/bitops/find.h> +#include <asm-generic/bitops/ext2-non-atomic.h> #ifdef __XTENSA_EL__ -# define ext2_set_bit (nr,addr) __test_and_set_bit((nr), (addr))# define ext2_set_bit_atomic (lock,nr,addr) test_and_set_bit((nr),(addr)) -# define ext2_clear_bit (nr,addr) __test_and_clear_bit((nr), (addr))# define ext2_clear_bit_atomic (lock,nr,addr) test_and_clear_bit((nr),(addr)) -# define ext2_test_bit (nr,addr) test_bit((nr), (addr)) -# define ext2_find_first_zero_bit (addr, size) find_first_zero_bit((addr),(size)) -# define ext2_find_next_zero_bit (addr, size, offset) \ - find_next_zero_bit((addr), (size), (offset))#elif defined(__XTENSA_EB__) -# define ext2_set_bit (nr,addr) __test_and_set_bit((nr) ^ 0x18, (addr))# define ext2_set_bit_atomic (lock,nr,addr) test_and_set_bit((nr) ^ 0x18, (addr)) -# define ext2_clear_bit (nr,addr) __test_and_clear_bit((nr) ^ 18, (addr))# define ext2_clear_bit_atomic (lock,nr,addr) test_and_clear_bit((nr)^0x18,(addr)) -# define ext2_test_bit (nr,addr) test_bit((nr) ^ 0x18, (addr)) -# define ext2_find_first_zero_bit (addr, size) \ - ext2_find_next_zero_bit((addr), (size), 0) - -static __inline__unsigned long ext2_find_next_zero_bit (void *addr,unsigned long size,unsigned long offset) -{ -unsigned long *p = ((unsigned long *) addr) + (offset >>5 ); -unsigned long result = offset & ~31UL ; -unsigned long tmp; - -if (offset >= size) -return size; - size -= result; - offset &=31UL ; -if (offset) { -/* We hold the little endian value in tmp, but then the -* shift is illegal. So we could keep a big endian value -* in tmp, like this: -* -* tmp = __swab32(*(p++)); -* tmp |= ~0UL >> (32-offset); -* -* but this would decrease preformance, so we change the -* shift: -*/ - tmp = *(p++); - tmp |=__swab32 (~0UL >> (32 -offset)); -if (size <32 ) - goto found_first; -if (~tmp) - goto found_middle; - size -=32 ; - result +=32 ; - } -while (size & ~31UL ) { -if (~(tmp = *(p++))) - goto found_middle; - result +=32 ; - size -=32 ; - } -if (!size) -return result; - tmp = *p; - -found_first: -/* tmp is little endian, so we would have to swab the shift, -* see above. But then we have to swab tmp below for ffz, so -* we might as well do this here. -*/ -return result +ffz (__swab32 (tmp) | (~0UL << size)); -found_middle: -return result +ffz (__swab32 (tmp)); -} -#else # error processor byte order undefined!#endif - -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) - -/* -* Find the first bit set in a 140-bit bitmap. -* The first 100 bits are unlikely to be set. -*/ - -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 ; -} - - -/* Bitmap functions for the minix filesystem. */ - -#define minix_test_and_set_bit (nr,addr) __test_and_set_bit(nr,addr) -#define minix_set_bit (nr,addr) __set_bit(nr,addr) -#define minix_test_and_clear_bit (nr,addr) __test_and_clear_bit(nr,addr) -#define minix_test_bit (nr,addr) test_bit(nr,addr) -#define minix_find_first_zero_bit (addr,size) find_first_zero_bit(addr,size) +#include <asm-generic/bitops/hweight.h> +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/minix.h> #endif /* __KERNEL__ */
--
PATCH 40/44 update include/asm-generic/bitops.h
In reply to Akinobu MitaCurrently include/asm-generic/bitops.h is not referenced from anywhere. But it will be the benefit of those who are trying to port Linux to another architecture.
So update it by same manner
include/asm-generic/bitops.h | 78 +++++++------------------------------------ 1 files changed, 14 insertions(+), 64 deletions(-)
include/asm-generic/bitops.h +14 -64
@@ -5,77 +5,27 @@* For the benefit of those who are trying to port Linux to another * architecture, here are some C-language equivalents. You should * recode these in the native assembly language, if at all possible. -* To guarantee atomicity, these routines call cli() and sti() to -* disable interrupts while they operate. (You have to provide inline -* routines to cli() and sti().) -* -* Also note, these routines assume that you have 32 bit longs. -* You will have to change this if you are trying to port Linux to the -* Alpha architecture or to a Cray. :-) * * C language equivalents written by Theodore Ts'o, 9/26/92 */ -extern __inline__int set_bit (int nr,long * addr) -{ -int mask, retval; - - addr += nr >>5 ; - mask =1 << (nr &0x1f ); -cli (); - retval = (mask & *addr) !=0 ; - *addr |= mask; -sti (); -return retval; -} - -extern __inline__int clear_bit (int nr,long * addr) -{ -int mask, retval; - - addr += nr >>5 ; - mask =1 << (nr &0x1f ); -cli (); - retval = (mask & *addr) !=0 ; - *addr &= ~mask; -sti (); -return retval; -} - -extern __inline__int test_bit (int nr,const unsigned long * addr) -{ -int mask; - - addr += nr >>5 ; - mask =1 << (nr &0x1f ); -return ((mask & *addr) !=0 ); -} - -/* -* fls: find last bit set. -*/ - -#define fls (x) generic_fls(x) -#define fls64 (x) generic_fls64(x) +#include <asm-generic/bitops/atomic.h> +#include <asm-generic/bitops/non-atomic.h> +#include <asm-generic/bitops/__ffs.h> +#include <asm-generic/bitops/ffz.h> +#include <asm-generic/bitops/fls.h> +#include <asm-generic/bitops/fls64.h> +#include <asm-generic/bitops/find.h> #ifdef __KERNEL__ -/* -* ffs: find first bit set. This is defined the same way as -* the libc and compiler builtin ffs routines, therefore -* differs in spirit from the above ffz (man ffs). -*/ - -#define ffs (x) generic_ffs(x) - -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ - -#define hweight32 (x) generic_hweight32(x) -#define hweight16 (x) generic_hweight16(x) -#define hweight8 (x) generic_hweight8(x) +#include <asm-generic/bitops/sched.h> +#include <asm-generic/bitops/ffs.h> +#include <asm-generic/bitops/hweight.h> + +#include <asm-generic/bitops/ext2-non-atomic.h> +#include <asm-generic/bitops/ext2-atomic.h> +#include <asm-generic/bitops/minix.h> #endif /* __KERNEL__ */
--
PATCH 41/44 make thread_info.flags an unsigned long
In reply to Akinobu MitaThe *_bit() routines are defined to work on a pointer to unsigned long. And the thread_info.flags is passed to *_bit() routines in include/linux/thread_info.h. But
- alpha: flags is unsigned int
- ia64, sh, x86_64: flags is __u32
So flags should be changed to unsigned long instead.
The only affected 64-platforms are little endian, so it will work without this change. But it's better to change it before people copy the code to a big endian platform.
include/asm-alpha/thread_info.h | 2 +- include/asm-ia64/thread_info.h | 2 +- include/asm-sh/thread_info.h | 2 +- include/asm-x86_64/thread_info.h | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-)
Index: 2.6-git/include/asm-alpha/thread_info.h =================================--- 2.6-git.orig/include/asm-alpha/thread_info.h +++ 2.6-git/include/asm-alpha/thread_info.h
@@ -14,7 +14,7 @@ struct thread_info {
struct pcb_struct pcb; /* palcode state */
struct task_struct *task; /* main task structure */
- unsigned int flags; /* low level flags */
+ unsigned long flags; /* low level flags */
unsigned int ieee_state; /* see fpu.h */
struct exec_domain *exec_domain; /* execution domain */
Index: 2.6-git/include/asm-ia64/thread_info.h =================================--- 2.6-git.orig/include/asm-ia64/thread_info.h +++ 2.6-git/include/asm-ia64/thread_info.h
@@ -24,7 +24,7 @@
struct thread_info {
struct task_struct *task; /* XXX not really needed, except for dup_task_struct() */
struct exec_domain *exec_domain;/* execution domain */
- __u32 flags; /* thread_info flags (see TIF_*) */
+ unsigned long flags; /* thread_info flags (see TIF_*) */
__u32 cpu; /* current CPU */
mm_segment_t addr_limit; /* user-level address space limit */
int preempt_count; /* 0=premptable, <0=BUG; will also serve as bh-counter */
Index: 2.6-git/include/asm-sh/thread_info.h =================================--- 2.6-git.orig/include/asm-sh/thread_info.h +++ 2.6-git/include/asm-sh/thread_info.h
@@ -18,7 +18,7 @@
struct thread_info {
struct task_struct *task; /* main task structure */
struct exec_domain *exec_domain; /* execution domain */
- __u32 flags; /* low level flags */
+ unsigned long flags; /* low level flags */
__u32 cpu;
int preempt_count; /* 0 => preemptable, <0 => BUG */
struct restart_block restart_block;
Index: 2.6-git/include/asm-x86_64/thread_info.h =================================--- 2.6-git.orig/include/asm-x86_64/thread_info.h +++ 2.6-git/include/asm-x86_64/thread_info.h
@@ -26,7 +26,7 @@ struct exec_domain;
struct thread_info {
struct task_struct *task; /* main task structure */
struct exec_domain *exec_domain; /* execution domain */
- __u32 flags; /* low level flags */
+ unsigned long flags; /* low level flags */
__u32 status; /* thread synchronous flags */
__u32 cpu; /* current CPU */
int preempt_count; /* 0 => preemptable, <0 => BUG */
--
PATCH 42/44 ia64: make partial_page.bitmap an unsigned long
In reply to Akinobu MitaThe *_bit() routines are defined to work on a pointer to unsigned long. But partial_page.bitmap is unsigned int and it is passed to find_*_bit() in arch/ia64/ia32/sys_ia32.c. So the compiler will print warnings.
This patch changes to unsigned long instead.
arch/ia64/ia32/ia32priv.h | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-)
Index: 2.6-git/arch/ia64/ia32/ia32priv.h =================================--- 2.6-git.orig/arch/ia64/ia32/ia32priv.h +++ 2.6-git/arch/ia64/ia32/ia32priv.h
@@ -29,9 +29,9 @@
struct partial_page {
struct partial_page *next; /* linked list, sorted by address */
struct rb_node pp_rb;
- /* 64K is the largest "normal" page supported by ia64 ABI. So 4K*32
+ /* 64K is the largest "normal" page supported by ia64 ABI. So 4K*64
* should suffice.*/
- unsigned int bitmap;
+ unsigned long bitmap;
unsigned int base;
};
--
PATCH 43/44 ntfs: remove generic_ffs()
In reply to Akinobu MitaNow the only user who are using generic_ffs() is ntfs filesystem. This patch isolates generic_ffs() as ntfs_ffs() for ntfs.
fs/ntfs/logfile.c | 4 ++-- fs/ntfs/mft.c | 2 +- fs/ntfs/ntfs.h | 29 +++++++++++++++++++++++++++++ 3 files changed, 32 insertions(+), 3 deletions(-)
fs/ntfs/logfile.c +2 -2
@@ -515,10 +515,10 @@ BOOL ntfs_check_logfile(struct inode *lo log_page_size =PAGE_CACHE_SIZE ; log_page_mask = log_page_size -1 ;/* -* Use generic_ffs() instead of ffs() to enable the compiler to +* Use ntfs_ffs() instead of ffs() to enable the compiler to * optimize log_page_size and log_page_bits into constants. */ - log_page_bits =generic_ffs (log_page_size) -1 ; + log_page_bits =ntfs_ffs (log_page_size) -1 ; size &= ~(s64)(log_page_size -1 );/* * Ensure the log file is big enough to store at least the two restart
fs/ntfs/mft.c +1 -1
@@ -2672,7 +2672,7 @@ mft_rec_already_initialized: ni->name_len =4 ; ni->itype.index.block_size =4096 ; - ni->itype.index.block_size_bits =generic_ffs (4096 ) -1 ; + ni->itype.index.block_size_bits =ntfs_ffs (4096 ) -1 ; ni->itype.index.collation_rule =COLLATION_FILE_NAME ;if (vol->cluster_size <= ni->itype.index.block_size) { ni->itype.index.vcn_size = vol->cluster_size;
fs/ntfs/ntfs.h +29 -0
@@ -132,4 +132,33 @@ extern int ntfs_ucstonls(const ntfs_volu/* From fs/ntfs/upcase.c */ extern ntfschar *generate_default_upcase (void ); +static inline int ntfs_ffs (int x) +{ +int r =1 ; + +if (!x) +return 0 ; +if (!(x &0xffff )) { + x >>=16 ; + r +=16 ; + } +if (!(x &0xff )) { + x >>=8 ; + r +=8 ; + } +if (!(x &0xf )) { + x >>=4 ; + r +=4 ; + } +if (!(x &3 )) { + x >>=2 ; + r +=2 ; + } +if (!(x &1 )) { + x >>=1 ; + r +=1 ; + } +return r; +} +#endif /* _LINUX_NTFS_H */
--
PATCH 44/44 remove unused generic bitops in include/linux/bitops.h
In reply to Akinobu Mitageneric_{ffs,fls,fls64,hweight{64,32,16,8}}() were moved into include/asm-generic/bitops.h. So all architectures don't use them.
include/linux/bitops.h | 124 ------------------------------------------------- 1 files changed, 1 insertion(+), 123 deletions(-)
include/linux/bitops.h +1 -123
@@ -3,88 +3,11 @@#include <asm/types.h> /* -* ffs: find first bit set. 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 generic_ffs (int x) -{ -int r =1 ; - -if (!x) -return 0 ; -if (!(x &0xffff )) { - x >>=16 ; - r +=16 ; - } -if (!(x &0xff )) { - x >>=8 ; - r +=8 ; - } -if (!(x &0xf )) { - x >>=4 ; - r +=4 ; - } -if (!(x &3 )) { - x >>=2 ; - r +=2 ; - } -if (!(x &1 )) { - x >>=1 ; - r +=1 ; - } -return r; -} - -/* -* fls: find last bit set. -*/ - -static __inline__int generic_fls (int x) -{ -int r =32 ; - -if (!x) -return 0 ; -if (!(x &0xffff0000u )) { - x <<=16 ; - r -=16 ; - } -if (!(x &0xff000000u )) { - x <<=8 ; - r -=8 ; - } -if (!(x &0xf0000000u )) { - x <<=4 ; - r -=4 ; - } -if (!(x &0xc0000000u )) { - x <<=2 ; - r -=2 ; - } -if (!(x &0x80000000u )) { - x <<=1 ; - r -=1 ; - } -return r; -} - -/* * Include this here because some architectures need generic_ffs/fls in * scope */ #include <asm/bitops.h> - -static inline int generic_fls64 (__u64 x) -{ -__u32 h = x >>32 ; -if (h) -return fls (x) +32 ; -return fls (x); -} -static __inline__int get_bitmask_order (unsigned int count) {int order;
@@ -103,54 +26,9 @@ static __inline__ int get_count_order(unreturn order; } -/* -* hweightN: returns the hamming weight (i.e. the number -* of bits set) of a N-bit word -*/ - -static inline unsigned int generic_hweight32 (unsigned int w) -{ -unsigned int res = (w &0x55555555 ) + ((w >>1 ) &0x55555555 ); - res = (res &0x33333333 ) + ((res >>2 ) &0x33333333 ); - res = (res &0x0F0F0F0F ) + ((res >>4 ) &0x0F0F0F0F ); - res = (res &0x00FF00FF ) + ((res >>8 ) &0x00FF00FF ); -return (res &0x0000FFFF ) + ((res >>16 ) &0x0000FFFF ); -} - -static inline unsigned int generic_hweight16 (unsigned int w) -{ -unsigned int res = (w &0x5555 ) + ((w >>1 ) &0x5555 ); - res = (res &0x3333 ) + ((res >>2 ) &0x3333 ); - res = (res &0x0F0F ) + ((res >>4 ) &0x0F0F ); -return (res &0x00FF ) + ((res >>8 ) &0x00FF ); -} - -static inline unsigned int generic_hweight8 (unsigned int w) -{ -unsigned int res = (w &0x55 ) + ((w >>1 ) &0x55 ); - res = (res &0x33 ) + ((res >>2 ) &0x33 ); -return (res &0x0F ) + ((res >>4 ) &0x0F ); -} - -static inline unsigned long generic_hweight64 (__u64 w) -{ -#if BITS_PER_LONG <64 -return generic_hweight32 ((unsigned int )(w >>32 )) + -generic_hweight32 ((unsigned int )w); -#else -u64 res; - res = (w &0x5555555555555555ul ) + ((w >>1 ) &0x5555555555555555ul ); - res = (res &0x3333333333333333ul ) + ((res >>2 ) &0x3333333333333333ul ); - res = (res &0x0F0F0F0F0F0F0F0Ful ) + ((res >>4 ) &0x0F0F0F0F0F0F0F0Ful ); - res = (res &0x00FF00FF00FF00FFul ) + ((res >>8 ) &0x00FF00FF00FF00FFul ); - res = (res &0x0000FFFF0000FFFFul ) + ((res >>16 ) &0x0000FFFF0000FFFFul ); -return (res &0x00000000FFFFFFFFul ) + ((res >>32 ) &0x00000000FFFFFFFFul ); -#endif -} -static inline unsigned long hweight_long (unsigned long w) { -return sizeof (w) ==4 ?generic_hweight32 (w) :generic_hweight64 (w); +return sizeof (w) ==4 ?hweight32 (w) :hweight64 (w); }/*
--