bitops kernel-doc: expand macro
PATCH 1/1 bitops kernel-doc: expand macro
From: Randy Dunlap <[email protected]>
Can we expand this macro definition, or should I look for a way to fool^W teach kernel-doc about this?
scripts/kernel-doc says:Error(linux-2.6.24-rc1//include/asm-x86/bitops_32.h:188): cannot understand prototype: 'test_and_set_bit_lock test_and_set_bit '
--- include/asm-x86/bitops_32.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
include/asm-x86/bitops_32.h +1 -1
@@ -185,7 +185,7 @@ static inline int test_and_set_bit(int n* * This is the same as test_and_set_bit on x86 */ -#define test_and_set_bit_lock test_and_set_bit +#define test_and_set_bit_lock (nr, addr) test_and_set_bit(nr, addr)/** * __test_and_set_bit - Set a bit and return its old value
---
~Randy
Quoted 8 lines · Randy Dunlap
From: Randy Dunlap <[email protected]>
Can we expand this macro definition, or should I look for a way to fool^W teach kernel-doc about this?
scripts/kernel-docsays:Error(linux-2.6.24-rc1//include/asm-x86/bitops_32.h:188): cannot understand
prototype: 'test_and_set_bit_locktest_and_set_bit'
Actually, it probably looks a bit nicer like this anyway. If you grep for it, then you can actually see the parameters...
On third thoughts, an inline function might be the best thing to do, and also avoid setting a bad example. What do you think?
Quoted 18 lines
Signed-off-by Randy Dunlap <[email protected]>--- include/asm-x86/bitops_32.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)include/asm-x86/bitops_32.h +1
-2@@ -185,7 +185,7 @@ static inline int test_and_set_bit(int n* * This is the same as test_and_set_bit on x86 */ -#define test_and_set_bit_lock test_and_set_bit +#define test_and_set_bit_lock (nr, addr) test_and_set_bit(nr, addr)/** * __test_and_set_bit - Set a bit and return its old value ---
Quoted 10 lines · On Wed, 24 Oct 2007 18:00:19 +1000 Nick Piggin wrote:
Quoted 8 lines · Randy Dunlap
From: Randy Dunlap <[email protected]>
Can we expand this macro definition, or should I look for a way to fool^W teach kernel-doc about this?
scripts/kernel-docsays:Error(linux-2.6.24-rc1//include/asm-x86/bitops_32.h:188): cannot understand
prototype: 'test_and_set_bit_locktest_and_set_bit'
Quoted 5 lines
Actually, it probably looks a bit nicer like this anyway. If you grep for it, then you can actually see the parameters...
On third thoughts, an inline function might be the best thing to do, and also avoid setting a bad example. What do you think?
That's probably best, yes.
Would you do the honors?
Quoted 14 lines
Quoted 14 lines
Signed-off-by Randy Dunlap <[email protected]>--- include/asm-x86/bitops_32.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)include/asm-x86/bitops_32.h +1
-1@@ -185,7 +185,7 @@ static inline int test_and_set_bit(int n* * This is the same as test_and_set_bit on x86 */ -#define test_and_set_bit_lock test_and_set_bit +#define test_and_set_bit_lock (nr, addr) test_and_set_bit(nr, addr)
Quoted 3 lines
include/asm-x86/bitops_32.h static inline int test_and_set_bit(int n
Quoted 3 lines
include/asm-x86/bitops_32.h +0
-1/** * __test_and_set_bit - Set a bit and return its old value ---
---
~Randy
PATCH v2 1/1 bitops kernel-doc: inline instead of macro
In reply to Nick PigginQuoted 10 lines · On Wed, 24 Oct 2007 18:00:19 +1000 Nick Piggin wrote:
Quoted 8 lines · Randy Dunlap
From: Randy Dunlap <[email protected]>
Can we expand this macro definition, or should I look for a way to fool^W teach kernel-doc about this?
scripts/kernel-docsays:Error(linux-2.6.24-rc1//include/asm-x86/bitops_32.h:188): cannot understand
prototype: 'test_and_set_bit_locktest_and_set_bit'
Quoted 5 lines
Actually, it probably looks a bit nicer like this anyway. If you grep for it, then you can actually see the parameters...
On third thoughts, an inline function might be the best thing to do, and also avoid setting a bad example. What do you think?
---
From: Randy Dunlap <[email protected]>
Use duplicated inline functions for test_and_set_bit_lock() on x86 instead of #define macros, thus avoiding a bad example. This allows kernel-doc to run cleanly instead of terminating with an error:
Error(linux-2.6.24-rc1//include/asm-x86/bitops_32.h:188): cannot understand prototype: 'test_and_set_bit_lock test_and_set_bit '
--- include/asm-x86/bitops_32.h | 13 +++++++++++-- include/asm-x86/bitops_64.h | 13 +++++++++++-- 2 files changed, 22 insertions(+), 4 deletions(-)
include/asm-x86/bitops_32.h +11 -2
@@ -183,9 +183,18 @@ static inline int test_and_set_bit(int n* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static inline int test_and_set_bit_lock (int nr,volatile unsigned long * addr) +{ +int oldbit; + + __asm__ __volatile__(LOCK_PREFIX +"btsl %2,%1\n\tsbbl %0,%0" + :"=r" (oldbit),"+m" (ADDR ) + :"Ir" (nr) :"memory" ); +return oldbit; +}/** * __test_and_set_bit - Set a bit and return its old value
include/asm-x86/bitops_64.h +11 -2
@@ -173,9 +173,18 @@ static __inline__ int test_and_set_bit(i* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static __inline__int test_and_set_bit_lock (int nr,volatile void * addr) +{ +int oldbit; + + __asm__ __volatile__(LOCK_PREFIX +"btsl %2,%1\n\tsbbl %0,%0" + :"=r" (oldbit),ADDR + :"dIr" (nr) :"memory" ); +return oldbit; +}/** * __test_and_set_bit - Set a bit and return its old value
Re: [PATCH v2] bitops kernel-doc: inline instead of macro
Quoted 18 lines · Randy Dunlap
Quoted 10 lines · On Wed, 24 Oct 2007 18:00:19 +1000 Nick Piggin wrote:
Quoted 8 lines · Randy Dunlap
From: Randy Dunlap <[email protected]>
Can we expand this macro definition, or should I look for a way to fool^W teach kernel-doc about this?
scripts/kernel-docsays:Error(linux-2.6.24-rc1//include/asm-x86/bitops_32.h:188): cannot understand
prototype: 'test_and_set_bit_locktest_and_set_bit'Quoted 5 lines
Actually, it probably looks a bit nicer like this anyway. If you grep for it, then you can actually see the parameters...
On third thoughts, an inline function might be the best thing to do, and also avoid setting a bad example. What do you think?
Quoted 7 lines
---
From: Randy Dunlap <[email protected]>
Use duplicated inline functions for
test_and_set_bit_lock()on x86 instead of #define macros, thus avoiding a bad example. This allows kernel-doc to run cleanly instead of terminating with an error:
Hmm, can we simply do
static inline int test_and_set_bit_lock(int nr, volatile unsigned long * addr)
{
return test_and_set_bit(nr, addr);
}please ?
tglx
Quoted 55 lines
Error(linux-2.6.24-rc1//include/asm-x86/bitops_32.h:188): cannot understand prototype: 'test_and_set_bit_locktest_and_set_bit'Signed-off-by Randy Dunlap <[email protected]>--- include/asm-x86/bitops_32.h | 13 +++++++++++-- include/asm-x86/bitops_64.h | 13 +++++++++++-- 2 files changed, 22 insertions(+), 4 deletions(-)include/asm-x86/bitops_32.h +11
-2@@ -183,9 +183,18 @@ static inline int test_and_set_bit(int n* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static inline int test_and_set_bit_lock (int nr,volatile unsigned long * addr) +{ +int oldbit; + + __asm__ __volatile__(LOCK_PREFIX +"btsl %2,%1\n\tsbbl %0,%0" + :"=r" (oldbit),"+m" (ADDR ) + :"Ir" (nr) :"memory" ); +return oldbit; +}/** * __test_and_set_bit - Set a bit and return its old value include/asm-x86/bitops_64.h +11
-2@@ -173,9 +173,18 @@ static __inline__ int test_and_set_bit(i* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static __inline__int test_and_set_bit_lock (int nr,volatile void * addr) +{ +int oldbit; + + __asm__ __volatile__(LOCK_PREFIX +"btsl %2,%1\n\tsbbl %0,%0" + :"=r" (oldbit),ADDR + :"dIr" (nr) :"memory" ); +return oldbit; +}/** * __test_and_set_bit - Set a bit and return its old value
Re: [PATCH v2] bitops kernel-doc: inline instead of macro
Quoted 8 lines
Hmm, can we simply do
static inline int
test_and_set_bit_lock(int nr, volatile unsigned long * addr){ return test_and_set_bit(nr, addr); }please ?
Certainly. That does look better.
---
From: Randy Dunlap <[email protected]>
Use duplicated inline functions for test_and_set_bit_lock() on x86 instead of #define macros, thus avoiding a bad example. This allows kernel-doc to run cleanly instead of terminating with an error:
Error(linux-2.6.24-rc1//include/asm-x86/bitops_32.h:188): cannot understand prototype: 'test_and_set_bit_lock test_and_set_bit '
--- include/asm-x86/bitops_32.h | 7 +++++-- include/asm-x86/bitops_64.h | 7 +++++-- 2 files changed, 10 insertions(+), 4 deletions(-)
include/asm-x86/bitops_32.h +5 -2
@@ -183,9 +183,12 @@ static inline int test_and_set_bit(int n* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static inline int test_and_set_bit_lock (int nr,volatile unsigned long * addr) +{ +return test_and_set_bit (nr, addr); +}/** * __test_and_set_bit - Set a bit and return its old value
include/asm-x86/bitops_64.h +5 -2
@@ -173,9 +173,12 @@ static __inline__ int test_and_set_bit(i* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static __inline__int test_and_set_bit_lock (int nr,volatile void * addr) +{ +return test_and_set_bit (nr, addr); +}/** * __test_and_set_bit - Set a bit and return its old value
Re: [PATCH v2] bitops kernel-doc: inline instead of macro
Quoted 10 lines · Randy Dunlap
Quoted 8 lines
Hmm, can we simply do
static inline int
test_and_set_bit_lock(int nr, volatile unsigned long * addr){ return test_and_set_bit(nr, addr); }please ?
Certainly. That does look better.
Yup. Applied, thanks
tglx
Quoted 51 lines
---
From: Randy Dunlap <[email protected]>
Use duplicated inline functions for
test_and_set_bit_lock()on x86 instead of #define macros, thus avoiding a bad example. This allows kernel-doc to run cleanly instead of terminating with an error:
Error(linux-2.6.24-rc1//include/asm-x86/bitops_32.h:188): cannot understand prototype: 'test_and_set_bit_locktest_and_set_bit'Signed-off-by Randy Dunlap <[email protected]>--- include/asm-x86/bitops_32.h | 7 +++++-- include/asm-x86/bitops_64.h | 7 +++++-- 2 files changed, 10 insertions(+), 4 deletions(-)include/asm-x86/bitops_32.h +5
-2@@ -183,9 +183,12 @@ static inline int test_and_set_bit(int n* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static inline int test_and_set_bit_lock (int nr,volatile unsigned long * addr) +{ +return test_and_set_bit (nr, addr); +}/** * __test_and_set_bit - Set a bit and return its old value include/asm-x86/bitops_64.h +5
-2@@ -173,9 +173,12 @@ static __inline__ int test_and_set_bit(i* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static __inline__int test_and_set_bit_lock (int nr,volatile void * addr) +{ +return test_and_set_bit (nr, addr); +}/** * __test_and_set_bit - Set a bit and return its old value
Re: [PATCH v2] bitops kernel-doc: inline instead of macro
In reply to Randy Dunlapinclude/asm-x86/bitops_64.h static __inline__ int test_and_set_bit(i · line 178
Quoted 2 lines · On Thu, 25 Oct 2007 09:55:40 -0700 Randy Dunlap <[email protected]> wrote:
include/asm-x86/bitops_64.h +1
-1-#define test_and_set_bit_lock test_and_set_bit +static __inline__int test_and_set_bit_lock (int nr,volatile void * addr)
mutter.
ERROR: "foo * bar" should be "foo *bar"
#80: FILE: include/asm-x86/bitops_32.h:188:
+static inline int test_and_set_bit_lock(int nr, volatile unsigned long * addr)
WARNING: Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt #80: FILE: include/asm-x86/bitops_32.h:188:
+static inline int test_and_set_bit_lock(int nr, volatile unsigned long * addr)
ERROR: "foo * bar" should be "foo *bar"
#97: FILE: include/asm-x86/bitops_64.h:178:
+static __inline__ int test_and_set_bit_lock(int nr, volatile void * addr)
WARNING: Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt #97: FILE: include/asm-x86/bitops_64.h:178:
+static __inline__ int test_and_set_bit_lock(int nr, volatile void * addr)
total: 2 errors, 2 warnings, 28 lines checked
Your patch has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
We might as well clean stuff up as we're churning the code.
Andy, I thought we were going to whine about __inline__ and __inline, too?
PATCH v3 1/1 bitops kernel-doc: inline instead of macro
Quoted 4 lines
We might as well clean stuff up as we're churning the code.
Andy, I thought we were going to whine about
__inline__and__inline, too?
Thomas, can you replace the previous patch with this one?
Usage of __inline__ is fixed in the next patch (after this one).
---
From: Randy Dunlap <[email protected]>
Use duplicated inline functions for test_and_set_bit_lock() on x86 instead of #define macros, thus avoiding a bad example. This allows kernel-doc to run cleanly instead of terminating with an error:
Error(linux-2.6.24-rc1//include/asm-x86/bitops_32.h:188): cannot understand prototype: 'test_and_set_bit_lock test_and_set_bit '
--- include/asm-x86/bitops_32.h | 7 +++++-- include/asm-x86/bitops_64.h | 7 +++++-- 2 files changed, 10 insertions(+), 4 deletions(-)
include/asm-x86/bitops_32.h +5 -2
@@ -183,9 +183,12 @@ static inline int test_and_set_bit(int n* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static inline int test_and_set_bit_lock (int nr,volatile unsigned long *addr) +{ +return test_and_set_bit (nr, addr); +}/** * __test_and_set_bit - Set a bit and return its old value
include/asm-x86/bitops_64.h +5 -2
@@ -173,9 +173,12 @@ static __inline__ int test_and_set_bit(i* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static __inline__int test_and_set_bit_lock (int nr,volatile void *addr) +{ +return test_and_set_bit (nr, addr); +}/** * __test_and_set_bit - Set a bit and return its old value
Re: [PATCH v3] bitops kernel-doc: inline instead of macro
Randy,
Quoted 6 lines · Randy Dunlap
Quoted 4 lines
We might as well clean stuff up as we're churning the code.
Andy, I thought we were going to whine about
__inline__and__inline, too?Thomas, can you replace the previous patch with this one?
Sure. Darn, I did not run yours through the usual procedure :)
tglx
Quoted 2 lines
Usage of
__inline__is fixed in the next patch (after this one).
---
Quoted 50 lines
From: Randy Dunlap <[email protected]>
Use duplicated inline functions for
test_and_set_bit_lock()on x86 instead of #define macros, thus avoiding a bad example. This allows kernel-doc to run cleanly instead of terminating with an error:
Error(linux-2.6.24-rc1//include/asm-x86/bitops_32.h:188): cannot understand prototype: 'test_and_set_bit_locktest_and_set_bit'Signed-off-by Randy Dunlap <[email protected]>--- include/asm-x86/bitops_32.h | 7 +++++-- include/asm-x86/bitops_64.h | 7 +++++-- 2 files changed, 10 insertions(+), 4 deletions(-)include/asm-x86/bitops_32.h +5
-2@@ -183,9 +183,12 @@ static inline int test_and_set_bit(int n* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static inline int test_and_set_bit_lock (int nr,volatile unsigned long *addr) +{ +return test_and_set_bit (nr, addr); +}/** * __test_and_set_bit - Set a bit and return its old value include/asm-x86/bitops_64.h +5
-2@@ -173,9 +173,12 @@ static __inline__ int test_and_set_bit(i* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static __inline__int test_and_set_bit_lock (int nr,volatile void *addr) +{ +return test_and_set_bit (nr, addr); +}/** * __test_and_set_bit - Set a bit and return its old value
PATCH 1/1 x86 bitops: fix code style issues
In reply to Andrew MortonFrom: Randy Dunlap <[email protected]>
Coding style cleanups:
- change __inline__ to inline;
- drop space in "* addr" parameters;
- drop space between func. name and '('
The "volatile" keywords are correct according to email from one Linus Torvalds.
[Several other arches need some of this also.]
--- include/asm-x86/bitops_64.h | 52 ++++++++++++++++++++++---------------------- 1 file changed, 26 insertions(+), 26 deletions(-)
include/asm-x86/bitops_64.h +26 -26
@@ -29,7 +29,7 @@* 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 void * addr) +static inline void set_bit (int nr,volatile void *addr) { __asm__ __volatile__(LOCK_PREFIX "btsl %1,%0"
@@ -46,7 +46,7 @@ static __inline__ void set_bit(int nr, v* 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) +static inline void __set_bit (int nr,volatile void *addr) { __asm__volatile ( "btsl %1,%0"
@@ -64,7 +64,7 @@ static __inline__ void __set_bit(int nr,* 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 void * addr) +static inline void clear_bit (int nr,volatile void *addr) { __asm__ __volatile__(LOCK_PREFIX "btrl %1,%0"
@@ -86,7 +86,7 @@ static inline void clear_bit_unlock(unsiclear_bit (nr, addr); } -static __inline__void __clear_bit (int nr,volatile void * addr) +static inline void __clear_bit (int nr,volatile void *addr) { __asm__ __volatile__( "btrl %1,%0"
@@ -124,7 +124,7 @@ static inline void __clear_bit_unlock(un* 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) +static inline void __change_bit (int nr,volatile void *addr) { __asm__ __volatile__( "btcl %1,%0"
@@ -141,7 +141,7 @@ static __inline__ void __change_bit(int* 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 void * addr) +static inline void change_bit (int nr,volatile void *addr) { __asm__ __volatile__(LOCK_PREFIX "btcl %1,%0"
@@ -157,7 +157,7 @@ static __inline__ void change_bit(int nr* This operation is atomic and cannot be reordered. * It also implies a memory barrier. */ -static __inline__int test_and_set_bit (int nr,volatile void * addr) +static inline int test_and_set_bit (int nr,volatile void *addr) {int oldbit;
@@ -175,7 +175,7 @@ static __inline__ int test_and_set_bit(i* * This is the same as test_and_set_bit on x86. */ -static __inline__int test_and_set_bit_lock (int nr,volatile void *addr) +static inline int test_and_set_bit_lock (int nr,volatile void *addr) {return test_and_set_bit (nr, addr); }
@@ -189,7 +189,7 @@ static __inline__ int test_and_set_bit_l* 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) +static inline int __test_and_set_bit (int nr,volatile void *addr) {int oldbit;
@@ -208,7 +208,7 @@ static __inline__ int __test_and_set_bit* This operation is atomic and cannot be reordered. * It also implies a memory barrier. */ -static __inline__int test_and_clear_bit (int nr,volatile void * addr) +static inline int test_and_clear_bit (int nr,volatile void *addr) {int oldbit;
@@ -228,7 +228,7 @@ static __inline__ int test_and_clear_bit* 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) +static inline int __test_and_clear_bit (int nr,volatile void *addr) {int oldbit;
@@ -240,7 +240,7 @@ static __inline__ int __test_and_clear_b }/* WARNING: non atomic and it can be reordered! */ -static __inline__int __test_and_change_bit (int nr,volatile void * addr) +static inline int __test_and_change_bit (int nr,volatile void *addr) {int oldbit;
@@ -259,7 +259,7 @@ static __inline__ int __test_and_change_* This operation is atomic and cannot be reordered. * It also implies a memory barrier. */ -static __inline__int test_and_change_bit (int nr,volatile void * addr) +static inline int test_and_change_bit (int nr,volatile void *addr) {int oldbit;
@@ -276,15 +276,15 @@ static __inline__ int test_and_change_bi* @nr: bit number to test * @addr: Address to start counting from */ -static int test_bit (int nr,const volatile void * addr); +static int test_bit (int nr,const volatile void *addr);#endif -static __inline__int constant_test_bit (int nr,const volatile void * addr) +static inline int constant_test_bit (int nr,const volatile void *addr) {return ((1UL << (nr &31 )) & (((const volatile unsigned int *) addr)[nr >>5 ])) !=0 ; } -static __inline__int variable_test_bit (int nr,volatile const void * addr) +static inline int variable_test_bit (int nr,volatile const void *addr) {int oldbit;
@@ -302,10 +302,10 @@ static __inline__ int variable_test_bit(#undef ADDR -extern long find_first_zero_bit (const unsigned long * addr,unsigned long size); -extern long find_next_zero_bit (const unsigned long * addr,long size,long offset); -extern long find_first_bit (const unsigned long * addr,unsigned long size); -extern long find_next_bit (const unsigned long * addr,long size,long offset); +extern long find_first_zero_bit (const unsigned long *addr,unsigned long size); +extern long find_next_zero_bit (const unsigned long *addr,long size,long offset); +extern long find_first_bit (const unsigned long *addr,unsigned long size); +extern long find_next_bit (const unsigned long *addr,long size,long offset);/* return index of first bet set in val or max when no bit is set */ static inline long __scanbit (unsigned long val,unsigned long max)
@@ -366,7 +366,7 @@ static inline void __clear_bit_string(un* * Undefined if no zero exists, so code should check against ~0UL first. */ -static __inline__unsigned long ffz (unsigned long word) +static inline unsigned long ffz (unsigned long word) { __asm__("bsfq %1,%0" :"=r" (word)
@@ -380,7 +380,7 @@ static __inline__ unsigned long ffz(unsi* * Undefined if no bit exists, so code should check against 0 first. */ -static __inline__unsigned long __ffs (unsigned long word) +static inline unsigned long __ffs (unsigned long word) { __asm__("bsfq %1,%0" :"=r" (word)
@@ -394,7 +394,7 @@ static __inline__ unsigned long __ffs(un* * Undefined if no zero exists, so code should check against ~0UL first. */ -static __inline__unsigned long __fls (unsigned long word) +static inline unsigned long __fls (unsigned long word) { __asm__("bsrq %1,%0" :"=r" (word)
@@ -414,7 +414,7 @@ static __inline__ unsigned long __fls(un* the libc and compiler builtin ffs routines, therefore * differs in spirit from the above ffz (man ffs). */ -static __inline__int ffs (int x) +static inline int ffs (int x) {int r;
@@ -430,7 +430,7 @@ static __inline__ int ffs(int x)* * This is defined the same way as fls. */ -static __inline__int fls64 (__u64 x) +static inline int fls64 (__u64 x) {if (x ==0 )return 0 ;
@@ -443,7 +443,7 @@ static __inline__ int fls64(__u64 x)* * This is defined the same way as ffs. */ -static __inline__int fls (int x) +static inline int fls (int x) {int r;
Re: [PATCH v2] bitops kernel-doc: inline instead of macro
In reply to Andrew MortonQuoted 1 line · Andrew Morton
Andy, I thought we were going to whine about
__inline__and__inline, too?
Hmmm, I don't remember that coming up, but I'll add it to the todo. I am assuming plain 'inline' is preferred over both of these -- yell if you meant something else.
-apw
Re: [PATCH v2] bitops kernel-doc: inline instead of macro
Quoted 7 lines · Andy Whitcroft
Quoted 1 line · Andrew Morton
Andy, I thought we were going to whine about
__inline__and__inline, too?Hmmm, I don't remember that coming up, but I'll add it to the todo. I am assuming plain 'inline' is preferred over both of these -- yell if you meant something else.
Ok, this will be in the next release and is in -next.
WARNING: plain inline is preferred over __inline #4: FILE: tmp/testset-28768.c:1:
+static __inline int foo(void)
-apw
Re: [PATCH v2] bitops kernel-doc: inline instead of macro
In reply to Andy WhitcroftQuoted 7 lines · Andy Whitcroft
Quoted 1 line · Andrew Morton
Andy, I thought we were going to whine about
__inline__and__inline, too?Hmmm, I don't remember that coming up, but I'll add it to the todo. I am assuming plain 'inline' is preferred over both of these -- yell if you meant something else.
Yes, use __inline__ if and only if it is exported to userspace.
-hpa
Re: [PATCH v2] bitops kernel-doc: inline instead of macro
In reply to Randy DunlapQuoted 10 lines · Randy Dunlap
Quoted 8 lines
Hmm, can we simply do
static inline int test_and_set_bit_lock(int nr, volatile unsigned long *
addr) { return test_and_set_bit(nr, addr); }please ?
Certainly. That does look better.
Thanks!
Quoted 52 lines
---
From: Randy Dunlap <[email protected]>
Use duplicated inline functions for
test_and_set_bit_lock()on x86 instead of #define macros, thus avoiding a bad example. This allows kernel-doc to run cleanly instead of terminating with an error:
Error(linux-2.6.24-rc1//include/asm-x86/bitops_32.h:188): cannot understand
prototype: 'test_and_set_bit_locktest_and_set_bit'Signed-off-by Randy Dunlap <[email protected]>--- include/asm-x86/bitops_32.h | 7 +++++-- include/asm-x86/bitops_64.h | 7 +++++-- 2 files changed, 10 insertions(+), 4 deletions(-)include/asm-x86/bitops_32.h +4
-2@@ -183,9 +183,12 @@ static inline int test_and_set_bit(int n* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static inline int test_and_set_bit_lock (int nr,volatile unsigned long * addr) +{ +return test_and_set_bit (nr, addr); +}/** * __test_and_set_bit - Set a bit and return its old value include/asm-x86/bitops_64.h +5
-2@@ -173,9 +173,12 @@ static __inline__ int test_and_set_bit(i* @nr: Bit to set * @addr: Address to count from * -* This is the same as test_and_set_bit on x86 +* This is the same as test_and_set_bit on x86. */ -#define test_and_set_bit_lock test_and_set_bit +static __inline__int test_and_set_bit_lock (int nr,volatile void * addr) +{ +return test_and_set_bit (nr, addr); +}/** * __test_and_set_bit - Set a bit and return its old value