[PATCH] bitops kernel-doc: expand macro

[PATCH] bitops kernel-doc: expand macro

[Randy Dunlap]

From: Randy Dunlap <randy.dunlap@oracle.com>

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 '

Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
---
 include/asm-x86/bitops_32.h |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

--- linux-2.6.24-rc1.orig/include/asm-x86/bitops_32.h
+++ linux-2.6.24-rc1/include/asm-x86/bitops_32.h
@@ -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

Re: [PATCH] bitops kernel-doc: expand macro

[Nick Piggin]

On Wednesday 24 October 2007 15:09, Randy Dunlap wrote:
> From: Randy Dunlap <randy.dunlap@oracle.com>
>
> 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?

>
> Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
> ---
>  include/asm-x86/bitops_32.h |    2 +-
>  1 file changed, 1 insertion(+), 1 deletion(-)
>
> --- linux-2.6.24-rc1.orig/include/asm-x86/bitops_32.h
> +++ linux-2.6.24-rc1/include/asm-x86/bitops_32.h
> @@ -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
> ---

Re: [PATCH] bitops kernel-doc: expand macro

[Randy Dunlap]

On Wed, 24 Oct 2007 18:00:19 +1000 Nick Piggin wrote:

> On Wednesday 24 October 2007 15:09, Randy Dunlap wrote:
> > From: Randy Dunlap <randy.dunlap@oracle.com>
> >
> > 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?

That's probably best, yes.
Would you do the honors?


> > Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
> > ---
> >  include/asm-x86/bitops_32.h |    2 +-
> >  1 file changed, 1 insertion(+), 1 deletion(-)
> >
> > --- linux-2.6.24-rc1.orig/include/asm-x86/bitops_32.h
> > +++ linux-2.6.24-rc1/include/asm-x86/bitops_32.h
> > @@ -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

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

[Randy Dunlap]

On Wed, 24 Oct 2007 18:00:19 +1000 Nick Piggin wrote:

> On Wednesday 24 October 2007 15:09, Randy Dunlap wrote:
> > From: Randy Dunlap <randy.dunlap@oracle.com>
> >
> > 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?

---

From: Randy Dunlap <randy.dunlap@oracle.com>

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 '

Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
---
 include/asm-x86/bitops_32.h |   13 +++++++++++--
 include/asm-x86/bitops_64.h |   13 +++++++++++--
 2 files changed, 22 insertions(+), 4 deletions(-)

--- linux-2.6.24-rc1.orig/include/asm-x86/bitops_32.h
+++ linux-2.6.24-rc1/include/asm-x86/bitops_32.h
@@ -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
--- linux-2.6.24-rc1.orig/include/asm-x86/bitops_64.h
+++ linux-2.6.24-rc1/include/asm-x86/bitops_64.h
@@ -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

[Thomas Gleixner]

On Thu, 25 Oct 2007, Randy Dunlap wrote:

> On Wed, 24 Oct 2007 18:00:19 +1000 Nick Piggin wrote:
> 
> > On Wednesday 24 October 2007 15:09, Randy Dunlap wrote:
> > > From: Randy Dunlap <randy.dunlap@oracle.com>
> > >
> > > 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?
> 
> ---
> 
> From: Randy Dunlap <randy.dunlap@oracle.com>
> 
> 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
 
> 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 '
> 
> Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
> ---
>  include/asm-x86/bitops_32.h |   13 +++++++++++--
>  include/asm-x86/bitops_64.h |   13 +++++++++++--
>  2 files changed, 22 insertions(+), 4 deletions(-)
> 
> --- linux-2.6.24-rc1.orig/include/asm-x86/bitops_32.h
> +++ linux-2.6.24-rc1/include/asm-x86/bitops_32.h
> @@ -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
> --- linux-2.6.24-rc1.orig/include/asm-x86/bitops_64.h
> +++ linux-2.6.24-rc1/include/asm-x86/bitops_64.h
> @@ -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

[Randy Dunlap]

> 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 <randy.dunlap@oracle.com>

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 '

Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
---
 include/asm-x86/bitops_32.h |    7 +++++--
 include/asm-x86/bitops_64.h |    7 +++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

--- linux-2.6.24-rc1.orig/include/asm-x86/bitops_32.h
+++ linux-2.6.24-rc1/include/asm-x86/bitops_32.h
@@ -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
--- linux-2.6.24-rc1.orig/include/asm-x86/bitops_64.h
+++ linux-2.6.24-rc1/include/asm-x86/bitops_64.h
@@ -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

[Thomas Gleixner]

On Thu, 25 Oct 2007, Randy Dunlap wrote:

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

> ---
> 
> From: Randy Dunlap <randy.dunlap@oracle.com>
> 
> 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 '
> 
> Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
> ---
>  include/asm-x86/bitops_32.h |    7 +++++--
>  include/asm-x86/bitops_64.h |    7 +++++--
>  2 files changed, 10 insertions(+), 4 deletions(-)
> 
> --- linux-2.6.24-rc1.orig/include/asm-x86/bitops_32.h
> +++ linux-2.6.24-rc1/include/asm-x86/bitops_32.h
> @@ -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
> --- linux-2.6.24-rc1.orig/include/asm-x86/bitops_64.h
> +++ linux-2.6.24-rc1/include/asm-x86/bitops_64.h
> @@ -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

[Andrew Morton]

On Thu, 25 Oct 2007 09:55:40 -0700
Randy Dunlap <rdunlap@xenotime.net> wrote:

> -#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] bitops kernel-doc: inline instead of macro

[Randy Dunlap]

> 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 <randy.dunlap@oracle.com>

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 '

Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
---
 include/asm-x86/bitops_32.h |    7 +++++--
 include/asm-x86/bitops_64.h |    7 +++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

--- linux-2.6.24-rc1.orig/include/asm-x86/bitops_32.h
+++ linux-2.6.24-rc1/include/asm-x86/bitops_32.h
@@ -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
--- linux-2.6.24-rc1.orig/include/asm-x86/bitops_64.h
+++ linux-2.6.24-rc1/include/asm-x86/bitops_64.h
@@ -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

[Thomas Gleixner]

Randy,

On Thu, 25 Oct 2007, Randy Dunlap wrote:
> > 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

> Usage of __inline__ is fixed in the next patch (after this one).
> 
 ---
> 
> From: Randy Dunlap <randy.dunlap@oracle.com>
> 
> 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 '
> 
> Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
> ---
>  include/asm-x86/bitops_32.h |    7 +++++--
>  include/asm-x86/bitops_64.h |    7 +++++--
>  2 files changed, 10 insertions(+), 4 deletions(-)
> 
> --- linux-2.6.24-rc1.orig/include/asm-x86/bitops_32.h
> +++ linux-2.6.24-rc1/include/asm-x86/bitops_32.h
> @@ -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
> --- linux-2.6.24-rc1.orig/include/asm-x86/bitops_64.h
> +++ linux-2.6.24-rc1/include/asm-x86/bitops_64.h
> @@ -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] x86 bitops: fix code style issues

[Randy Dunlap]

From: Randy Dunlap <randy.dunlap@oracle.com>

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

Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
---
 include/asm-x86/bitops_64.h |   52 ++++++++++++++++++++++----------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

--- linux-2.6.24-rc1.orig/include/asm-x86/bitops_64.h
+++ linux-2.6.24-rc1/include/asm-x86/bitops_64.h
@@ -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;
 

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

[Andy Whitcroft]

On Thu, Oct 25, 2007 at 01:48:14PM -0700, Andrew Morton wrote:

> 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

[Andy Whitcroft]

On Sat, Oct 27, 2007 at 11:43:28AM +0100, Andy Whitcroft wrote:
> On Thu, Oct 25, 2007 at 01:48:14PM -0700, Andrew Morton wrote:
> 
> > 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

[H. Peter Anvin]

Andy Whitcroft wrote:
> On Thu, Oct 25, 2007 at 01:48:14PM -0700, Andrew Morton wrote:
> 
>> 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

[Nick Piggin]

On Friday 26 October 2007 02:55, Randy Dunlap wrote:
> > 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!

>
> ---
>
> From: Randy Dunlap <randy.dunlap@oracle.com>
>
> 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 '
>
> Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
> ---
>  include/asm-x86/bitops_32.h |    7 +++++--
>  include/asm-x86/bitops_64.h |    7 +++++--
>  2 files changed, 10 insertions(+), 4 deletions(-)
>
> --- linux-2.6.24-rc1.orig/include/asm-x86/bitops_32.h
> +++ linux-2.6.24-rc1/include/asm-x86/bitops_32.h
> @@ -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
> --- linux-2.6.24-rc1.orig/include/asm-x86/bitops_64.h
> +++ linux-2.6.24-rc1/include/asm-x86/bitops_64.h
> @@ -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