Skip to contentSkip to conversation

bitops kernel-doc: expand macro

PATCH In review Randy Dunlap 6 participants 15 messages Oct 24, 2007 – Oct 27, 2007

lore
Share & tools
lore
#0 lore raw

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

#1 lore raw
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-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 '

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
---
 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
---
#2 lore raw
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-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 '

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
---
 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

#3 lore raw

PATCH v2 1/1 bitops kernel-doc: inline instead of macro

In reply to Nick Piggin
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-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 '

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
#4 lore raw

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-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 '

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_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
#5 lore raw

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
#6 lore raw

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_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
#7 lore raw

Re: [PATCH v2] bitops kernel-doc: inline instead of macro

In reply to Randy Dunlap

include/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?

#8 lore raw

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
#9 lore raw

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_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
#10 lore raw

PATCH 1/1 x86 bitops: fix code style issues

In reply to Andrew Morton

From: 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(unsi
 	clear_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;
 
#11 lore raw

Re: [PATCH v2] bitops kernel-doc: inline instead of macro

In reply to Andrew Morton
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.

-apw

#12 lore raw

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

#13 lore raw

Re: [PATCH v2] bitops kernel-doc: inline instead of macro

In reply to Andy Whitcroft
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.

Yes, use __inline__ if and only if it is exported to userspace.

-hpa

#14 lore raw

Re: [PATCH v2] bitops kernel-doc: inline instead of macro

In reply to Randy Dunlap
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.

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_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 +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