x86: Fix kernel-doc atomic.h warnings

rddunlap · KAGA-KOKO · commit 4331f4d5ada5 · 2018-09-03T12:41:41.000+02:00
Fix kernel-doc warnings in arch/x86/include/asm/atomic.h that are caused by having a #define macro between the kernel-doc notation and the function name. Fixed by moving the #define macro to after the function implementation. Make the same change for atomic64_{32,64}.h for consistency even though there were no kernel-doc warnings found in these header files, but there would be if they were used in generation of documentation. Fixes these kernel-doc warnings: ../arch/x86/include/asm/atomic.h:84: warning: Excess function parameter 'i' description in 'arch_atomic_sub_and_test' ../arch/x86/include/asm/atomic.h:84: warning: Excess function parameter 'v' description in 'arch_atomic_sub_and_test' ../arch/x86/include/asm/atomic.h:96: warning: Excess function parameter 'v' description in 'arch_atomic_inc' ../arch/x86/include/asm/atomic.h:109: warning: Excess function parameter 'v' description in 'arch_atomic_dec' ../arch/x86/include/asm/atomic.h:124: warning: Excess function parameter 'v' description in 'arch_atomic_dec_and_test' ../arch/x86/include/asm/atomic.h:138: warning: Excess function parameter 'v' description in 'arch_atomic_inc_and_test' ../arch/x86/include/asm/atomic.h:153: warning: Excess function parameter 'i' description in 'arch_atomic_add_negative' ../arch/x86/include/asm/atomic.h:153: warning: Excess function parameter 'v' description in 'arch_atomic_add_negative' Fixes: 18cc181 ("atomics/treewide: Make test ops optional") Signed-off-by: Randy Dunlap <rdunlap@infradead.org> Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Cc: Mark Rutland <mark.rutland@arm.com> Link: https://lkml.kernel.org/r/0a1e678d-c8c5-b32c-2640-ed4e94d399d2@infradead.org
diff --git a/arch/x86/include/asm/atomic.h b/arch/x86/include/asm/atomic.h
@@ -80,37 +80,37 @@ static __always_inline void arch_atomic_sub(int i, atomic_t *v)
  * true if the result is zero, or false for all
  * other cases.
  */
-#define arch_atomic_sub_and_test arch_atomic_sub_and_test
 static __always_inline bool arch_atomic_sub_and_test(int i, atomic_t *v)
 {
 	GEN_BINARY_RMWcc(LOCK_PREFIX "subl", v->counter, "er", i, "%0", e);
 }
+#define arch_atomic_sub_and_test arch_atomic_sub_and_test
 
 /**
  * arch_atomic_inc - increment atomic variable
  * @v: pointer of type atomic_t
  *
  * Atomically increments @v by 1.
  */
-#define arch_atomic_inc arch_atomic_inc
 static __always_inline void arch_atomic_inc(atomic_t *v)
 {
 	asm volatile(LOCK_PREFIX "incl %0"
 		     : "+m" (v->counter));
 }
+#define arch_atomic_inc arch_atomic_inc
 
 /**
  * arch_atomic_dec - decrement atomic variable
  * @v: pointer of type atomic_t
  *
  * Atomically decrements @v by 1.
  */
-#define arch_atomic_dec arch_atomic_dec
 static __always_inline void arch_atomic_dec(atomic_t *v)
 {
 	asm volatile(LOCK_PREFIX "decl %0"
 		     : "+m" (v->counter));
 }
+#define arch_atomic_dec arch_atomic_dec
 
 /**
  * arch_atomic_dec_and_test - decrement and test
@@ -120,11 +120,11 @@ static __always_inline void arch_atomic_dec(atomic_t *v)
  * returns true if the result is 0, or false for all other
  * cases.
  */
-#define arch_atomic_dec_and_test arch_atomic_dec_and_test
 static __always_inline bool arch_atomic_dec_and_test(atomic_t *v)
 {
 	GEN_UNARY_RMWcc(LOCK_PREFIX "decl", v->counter, "%0", e);
 }
+#define arch_atomic_dec_and_test arch_atomic_dec_and_test
 
 /**
  * arch_atomic_inc_and_test - increment and test
@@ -134,11 +134,11 @@ static __always_inline bool arch_atomic_dec_and_test(atomic_t *v)
  * and returns true if the result is zero, or false for all
  * other cases.
  */
-#define arch_atomic_inc_and_test arch_atomic_inc_and_test
 static __always_inline bool arch_atomic_inc_and_test(atomic_t *v)
 {
 	GEN_UNARY_RMWcc(LOCK_PREFIX "incl", v->counter, "%0", e);
 }
+#define arch_atomic_inc_and_test arch_atomic_inc_and_test
 
 /**
  * arch_atomic_add_negative - add and test if negative
@@ -149,11 +149,11 @@ static __always_inline bool arch_atomic_inc_and_test(atomic_t *v)
  * if the result is negative, or false when
  * result is greater than or equal to zero.
  */
-#define arch_atomic_add_negative arch_atomic_add_negative
 static __always_inline bool arch_atomic_add_negative(int i, atomic_t *v)
 {
 	GEN_BINARY_RMWcc(LOCK_PREFIX "addl", v->counter, "er", i, "%0", s);
 }
+#define arch_atomic_add_negative arch_atomic_add_negative
 
 /**
  * arch_atomic_add_return - add integer and return
diff --git a/arch/x86/include/asm/atomic64_32.h b/arch/x86/include/asm/atomic64_32.h
@@ -205,25 +205,25 @@ static inline long long arch_atomic64_sub(long long i, atomic64_t *v)
  *
  * Atomically increments @v by 1.
  */
-#define arch_atomic64_inc arch_atomic64_inc
 static inline void arch_atomic64_inc(atomic64_t *v)
 {
 	__alternative_atomic64(inc, inc_return, /* no output */,
 			       "S" (v) : "memory", "eax", "ecx", "edx");
 }
+#define arch_atomic64_inc arch_atomic64_inc
 
 /**
  * arch_atomic64_dec - decrement atomic64 variable
  * @v: pointer to type atomic64_t
  *
  * Atomically decrements @v by 1.
  */
-#define arch_atomic64_dec arch_atomic64_dec
 static inline void arch_atomic64_dec(atomic64_t *v)
 {
 	__alternative_atomic64(dec, dec_return, /* no output */,
 			       "S" (v) : "memory", "eax", "ecx", "edx");
 }
+#define arch_atomic64_dec arch_atomic64_dec
 
 /**
  * arch_atomic64_add_unless - add unless the number is a given value
@@ -245,23 +245,23 @@ static inline int arch_atomic64_add_unless(atomic64_t *v, long long a,
 	return (int)a;
 }
 
-#define arch_atomic64_inc_not_zero arch_atomic64_inc_not_zero
 static inline int arch_atomic64_inc_not_zero(atomic64_t *v)
 {
 	int r;
 	alternative_atomic64(inc_not_zero, "=&a" (r),
 			     "S" (v) : "ecx", "edx", "memory");
 	return r;
 }
+#define arch_atomic64_inc_not_zero arch_atomic64_inc_not_zero
 
-#define arch_atomic64_dec_if_positive arch_atomic64_dec_if_positive
 static inline long long arch_atomic64_dec_if_positive(atomic64_t *v)
 {
 	long long r;
 	alternative_atomic64(dec_if_positive, "=&A" (r),
 			     "S" (v) : "ecx", "memory");
 	return r;
 }
+#define arch_atomic64_dec_if_positive arch_atomic64_dec_if_positive
 
 #undef alternative_atomic64
 #undef __alternative_atomic64
diff --git a/arch/x86/include/asm/atomic64_64.h b/arch/x86/include/asm/atomic64_64.h
@@ -71,39 +71,39 @@ static inline void arch_atomic64_sub(long i, atomic64_t *v)
  * true if the result is zero, or false for all
  * other cases.
  */
-#define arch_atomic64_sub_and_test arch_atomic64_sub_and_test
 static inline bool arch_atomic64_sub_and_test(long i, atomic64_t *v)
 {
 	GEN_BINARY_RMWcc(LOCK_PREFIX "subq", v->counter, "er", i, "%0", e);
 }
+#define arch_atomic64_sub_and_test arch_atomic64_sub_and_test
 
 /**
  * arch_atomic64_inc - increment atomic64 variable
  * @v: pointer to type atomic64_t
  *
  * Atomically increments @v by 1.
  */
-#define arch_atomic64_inc arch_atomic64_inc
 static __always_inline void arch_atomic64_inc(atomic64_t *v)
 {
 	asm volatile(LOCK_PREFIX "incq %0"
 		     : "=m" (v->counter)
 		     : "m" (v->counter));
 }
+#define arch_atomic64_inc arch_atomic64_inc
 
 /**
  * arch_atomic64_dec - decrement atomic64 variable
  * @v: pointer to type atomic64_t
  *
  * Atomically decrements @v by 1.
  */
-#define arch_atomic64_dec arch_atomic64_dec
 static __always_inline void arch_atomic64_dec(atomic64_t *v)
 {
 	asm volatile(LOCK_PREFIX "decq %0"
 		     : "=m" (v->counter)
 		     : "m" (v->counter));
 }
+#define arch_atomic64_dec arch_atomic64_dec
 
 /**
  * arch_atomic64_dec_and_test - decrement and test
@@ -113,11 +113,11 @@ static __always_inline void arch_atomic64_dec(atomic64_t *v)
  * returns true if the result is 0, or false for all other
  * cases.
  */
-#define arch_atomic64_dec_and_test arch_atomic64_dec_and_test
 static inline bool arch_atomic64_dec_and_test(atomic64_t *v)
 {
 	GEN_UNARY_RMWcc(LOCK_PREFIX "decq", v->counter, "%0", e);
 }
+#define arch_atomic64_dec_and_test arch_atomic64_dec_and_test
 
 /**
  * arch_atomic64_inc_and_test - increment and test
@@ -127,11 +127,11 @@ static inline bool arch_atomic64_dec_and_test(atomic64_t *v)
  * and returns true if the result is zero, or false for all
  * other cases.
  */
-#define arch_atomic64_inc_and_test arch_atomic64_inc_and_test
 static inline bool arch_atomic64_inc_and_test(atomic64_t *v)
 {
 	GEN_UNARY_RMWcc(LOCK_PREFIX "incq", v->counter, "%0", e);
 }
+#define arch_atomic64_inc_and_test arch_atomic64_inc_and_test
 
 /**
  * arch_atomic64_add_negative - add and test if negative
@@ -142,11 +142,11 @@ static inline bool arch_atomic64_inc_and_test(atomic64_t *v)
  * if the result is negative, or false when
  * result is greater than or equal to zero.
  */
-#define arch_atomic64_add_negative arch_atomic64_add_negative
 static inline bool arch_atomic64_add_negative(long i, atomic64_t *v)
 {
 	GEN_BINARY_RMWcc(LOCK_PREFIX "addq", v->counter, "er", i, "%0", s);
 }
+#define arch_atomic64_add_negative arch_atomic64_add_negative
 
 /**
  * arch_atomic64_add_return - add and return

Original file line number	Diff line number	Diff line change
`@@ -80,37 +80,37 @@ static __always_inline void arch_atomic_sub(int i, atomic_t *v)`
`80`	`80`	`* true if the result is zero, or false for all`
`81`	`81`	`* other cases.`
`82`	`82`	`*/`
`83`		`-#define arch_atomic_sub_and_test arch_atomic_sub_and_test`
`84`	`83`	`static __always_inline bool arch_atomic_sub_and_test(int i, atomic_t *v)`
`85`	`84`	`{`
`86`	`85`	`GEN_BINARY_RMWcc(LOCK_PREFIX "subl", v->counter, "er", i, "%0", e);`
`87`	`86`	`}`
	`87`	`+#define arch_atomic_sub_and_test arch_atomic_sub_and_test`
`88`	`88`
`89`	`89`	`/**`
`90`	`90`	`* arch_atomic_inc - increment atomic variable`
`91`	`91`	`* @v: pointer of type atomic_t`
`92`	`92`	`*`
`93`	`93`	`* Atomically increments @v by 1.`
`94`	`94`	`*/`
`95`		`-#define arch_atomic_inc arch_atomic_inc`
`96`	`95`	`static __always_inline void arch_atomic_inc(atomic_t *v)`
`97`	`96`	`{`
`98`	`97`	`asm volatile(LOCK_PREFIX "incl %0"`
`99`	`98`	`: "+m" (v->counter));`
`100`	`99`	`}`
	`100`	`+#define arch_atomic_inc arch_atomic_inc`
`101`	`101`
`102`	`102`	`/**`
`103`	`103`	`* arch_atomic_dec - decrement atomic variable`
`104`	`104`	`* @v: pointer of type atomic_t`
`105`	`105`	`*`
`106`	`106`	`* Atomically decrements @v by 1.`
`107`	`107`	`*/`
`108`		`-#define arch_atomic_dec arch_atomic_dec`
`109`	`108`	`static __always_inline void arch_atomic_dec(atomic_t *v)`
`110`	`109`	`{`
`111`	`110`	`asm volatile(LOCK_PREFIX "decl %0"`
`112`	`111`	`: "+m" (v->counter));`
`113`	`112`	`}`
	`113`	`+#define arch_atomic_dec arch_atomic_dec`
`114`	`114`
`115`	`115`	`/**`
`116`	`116`	`* arch_atomic_dec_and_test - decrement and test`
`@@ -120,11 +120,11 @@ static __always_inline void arch_atomic_dec(atomic_t *v)`
`120`	`120`	`* returns true if the result is 0, or false for all other`
`121`	`121`	`* cases.`
`122`	`122`	`*/`
`123`		`-#define arch_atomic_dec_and_test arch_atomic_dec_and_test`
`124`	`123`	`static __always_inline bool arch_atomic_dec_and_test(atomic_t *v)`
`125`	`124`	`{`
`126`	`125`	`GEN_UNARY_RMWcc(LOCK_PREFIX "decl", v->counter, "%0", e);`
`127`	`126`	`}`
	`127`	`+#define arch_atomic_dec_and_test arch_atomic_dec_and_test`
`128`	`128`
`129`	`129`	`/**`
`130`	`130`	`* arch_atomic_inc_and_test - increment and test`
`@@ -134,11 +134,11 @@ static __always_inline bool arch_atomic_dec_and_test(atomic_t *v)`
`134`	`134`	`* and returns true if the result is zero, or false for all`
`135`	`135`	`* other cases.`
`136`	`136`	`*/`
`137`		`-#define arch_atomic_inc_and_test arch_atomic_inc_and_test`
`138`	`137`	`static __always_inline bool arch_atomic_inc_and_test(atomic_t *v)`
`139`	`138`	`{`
`140`	`139`	`GEN_UNARY_RMWcc(LOCK_PREFIX "incl", v->counter, "%0", e);`
`141`	`140`	`}`
	`141`	`+#define arch_atomic_inc_and_test arch_atomic_inc_and_test`
`142`	`142`
`143`	`143`	`/**`
`144`	`144`	`* arch_atomic_add_negative - add and test if negative`
`@@ -149,11 +149,11 @@ static __always_inline bool arch_atomic_inc_and_test(atomic_t *v)`
`149`	`149`	`* if the result is negative, or false when`
`150`	`150`	`* result is greater than or equal to zero.`
`151`	`151`	`*/`
`152`		`-#define arch_atomic_add_negative arch_atomic_add_negative`
`153`	`152`	`static __always_inline bool arch_atomic_add_negative(int i, atomic_t *v)`
`154`	`153`	`{`
`155`	`154`	`GEN_BINARY_RMWcc(LOCK_PREFIX "addl", v->counter, "er", i, "%0", s);`
`156`	`155`	`}`
	`156`	`+#define arch_atomic_add_negative arch_atomic_add_negative`
`157`	`157`
`158`	`158`	`/**`
`159`	`159`	`* arch_atomic_add_return - add integer and return`
Original file line number	Diff line number	Diff line change
`@@ -205,25 +205,25 @@ static inline long long arch_atomic64_sub(long long i, atomic64_t *v)`
`205`	`205`	`*`
`206`	`206`	`* Atomically increments @v by 1.`
`207`	`207`	`*/`
`208`		`-#define arch_atomic64_inc arch_atomic64_inc`
`209`	`208`	`static inline void arch_atomic64_inc(atomic64_t *v)`
`210`	`209`	`{`
`211`	`210`	`__alternative_atomic64(inc, inc_return, /* no output */,`
`212`	`211`	`"S" (v) : "memory", "eax", "ecx", "edx");`
`213`	`212`	`}`
	`213`	`+#define arch_atomic64_inc arch_atomic64_inc`
`214`	`214`
`215`	`215`	`/**`
`216`	`216`	`* arch_atomic64_dec - decrement atomic64 variable`
`217`	`217`	`* @v: pointer to type atomic64_t`
`218`	`218`	`*`
`219`	`219`	`* Atomically decrements @v by 1.`
`220`	`220`	`*/`
`221`		`-#define arch_atomic64_dec arch_atomic64_dec`
`222`	`221`	`static inline void arch_atomic64_dec(atomic64_t *v)`
`223`	`222`	`{`
`224`	`223`	`__alternative_atomic64(dec, dec_return, /* no output */,`
`225`	`224`	`"S" (v) : "memory", "eax", "ecx", "edx");`
`226`	`225`	`}`
	`226`	`+#define arch_atomic64_dec arch_atomic64_dec`
`227`	`227`
`228`	`228`	`/**`
`229`	`229`	`* arch_atomic64_add_unless - add unless the number is a given value`
`@@ -245,23 +245,23 @@ static inline int arch_atomic64_add_unless(atomic64_t *v, long long a,`
`245`	`245`	`return (int)a;`
`246`	`246`	`}`
`247`	`247`
`248`		`-#define arch_atomic64_inc_not_zero arch_atomic64_inc_not_zero`
`249`	`248`	`static inline int arch_atomic64_inc_not_zero(atomic64_t *v)`
`250`	`249`	`{`
`251`	`250`	`int r;`
`252`	`251`	`alternative_atomic64(inc_not_zero, "=&a" (r),`
`253`	`252`	`"S" (v) : "ecx", "edx", "memory");`
`254`	`253`	`return r;`
`255`	`254`	`}`
	`255`	`+#define arch_atomic64_inc_not_zero arch_atomic64_inc_not_zero`
`256`	`256`
`257`		`-#define arch_atomic64_dec_if_positive arch_atomic64_dec_if_positive`
`258`	`257`	`static inline long long arch_atomic64_dec_if_positive(atomic64_t *v)`
`259`	`258`	`{`
`260`	`259`	`long long r;`
`261`	`260`	`alternative_atomic64(dec_if_positive, "=&A" (r),`
`262`	`261`	`"S" (v) : "ecx", "memory");`
`263`	`262`	`return r;`
`264`	`263`	`}`
	`264`	`+#define arch_atomic64_dec_if_positive arch_atomic64_dec_if_positive`
`265`	`265`
`266`	`266`	`#undef alternative_atomic64`
`267`	`267`	`#undef __alternative_atomic64`
Original file line number	Diff line number	Diff line change
`@@ -71,39 +71,39 @@ static inline void arch_atomic64_sub(long i, atomic64_t *v)`
`71`	`71`	`* true if the result is zero, or false for all`
`72`	`72`	`* other cases.`
`73`	`73`	`*/`
`74`		`-#define arch_atomic64_sub_and_test arch_atomic64_sub_and_test`
`75`	`74`	`static inline bool arch_atomic64_sub_and_test(long i, atomic64_t *v)`
`76`	`75`	`{`
`77`	`76`	`GEN_BINARY_RMWcc(LOCK_PREFIX "subq", v->counter, "er", i, "%0", e);`
`78`	`77`	`}`
	`78`	`+#define arch_atomic64_sub_and_test arch_atomic64_sub_and_test`
`79`	`79`
`80`	`80`	`/**`
`81`	`81`	`* arch_atomic64_inc - increment atomic64 variable`
`82`	`82`	`* @v: pointer to type atomic64_t`
`83`	`83`	`*`
`84`	`84`	`* Atomically increments @v by 1.`
`85`	`85`	`*/`
`86`		`-#define arch_atomic64_inc arch_atomic64_inc`
`87`	`86`	`static __always_inline void arch_atomic64_inc(atomic64_t *v)`
`88`	`87`	`{`
`89`	`88`	`asm volatile(LOCK_PREFIX "incq %0"`
`90`	`89`	`: "=m" (v->counter)`
`91`	`90`	`: "m" (v->counter));`
`92`	`91`	`}`
	`92`	`+#define arch_atomic64_inc arch_atomic64_inc`
`93`	`93`
`94`	`94`	`/**`
`95`	`95`	`* arch_atomic64_dec - decrement atomic64 variable`
`96`	`96`	`* @v: pointer to type atomic64_t`
`97`	`97`	`*`
`98`	`98`	`* Atomically decrements @v by 1.`
`99`	`99`	`*/`
`100`		`-#define arch_atomic64_dec arch_atomic64_dec`
`101`	`100`	`static __always_inline void arch_atomic64_dec(atomic64_t *v)`
`102`	`101`	`{`
`103`	`102`	`asm volatile(LOCK_PREFIX "decq %0"`
`104`	`103`	`: "=m" (v->counter)`
`105`	`104`	`: "m" (v->counter));`
`106`	`105`	`}`
	`106`	`+#define arch_atomic64_dec arch_atomic64_dec`
`107`	`107`
`108`	`108`	`/**`
`109`	`109`	`* arch_atomic64_dec_and_test - decrement and test`
`@@ -113,11 +113,11 @@ static __always_inline void arch_atomic64_dec(atomic64_t *v)`
`113`	`113`	`* returns true if the result is 0, or false for all other`
`114`	`114`	`* cases.`
`115`	`115`	`*/`
`116`		`-#define arch_atomic64_dec_and_test arch_atomic64_dec_and_test`
`117`	`116`	`static inline bool arch_atomic64_dec_and_test(atomic64_t *v)`
`118`	`117`	`{`
`119`	`118`	`GEN_UNARY_RMWcc(LOCK_PREFIX "decq", v->counter, "%0", e);`
`120`	`119`	`}`
	`120`	`+#define arch_atomic64_dec_and_test arch_atomic64_dec_and_test`
`121`	`121`
`122`	`122`	`/**`
`123`	`123`	`* arch_atomic64_inc_and_test - increment and test`
`@@ -127,11 +127,11 @@ static inline bool arch_atomic64_dec_and_test(atomic64_t *v)`
`127`	`127`	`* and returns true if the result is zero, or false for all`
`128`	`128`	`* other cases.`
`129`	`129`	`*/`
`130`		`-#define arch_atomic64_inc_and_test arch_atomic64_inc_and_test`
`131`	`130`	`static inline bool arch_atomic64_inc_and_test(atomic64_t *v)`
`132`	`131`	`{`
`133`	`132`	`GEN_UNARY_RMWcc(LOCK_PREFIX "incq", v->counter, "%0", e);`
`134`	`133`	`}`
	`134`	`+#define arch_atomic64_inc_and_test arch_atomic64_inc_and_test`
`135`	`135`
`136`	`136`	`/**`
`137`	`137`	`* arch_atomic64_add_negative - add and test if negative`
`@@ -142,11 +142,11 @@ static inline bool arch_atomic64_inc_and_test(atomic64_t *v)`
`142`	`142`	`* if the result is negative, or false when`
`143`	`143`	`* result is greater than or equal to zero.`
`144`	`144`	`*/`
`145`		`-#define arch_atomic64_add_negative arch_atomic64_add_negative`
`146`	`145`	`static inline bool arch_atomic64_add_negative(long i, atomic64_t *v)`
`147`	`146`	`{`
`148`	`147`	`GEN_BINARY_RMWcc(LOCK_PREFIX "addq", v->counter, "er", i, "%0", s);`
`149`	`148`	`}`
	`149`	`+#define arch_atomic64_add_negative arch_atomic64_add_negative`
`150`	`150`
`151`	`151`	`/**`
`152`	`152`	`* arch_atomic64_add_return - add and return`