x86: Code atomic[64]_read and atomic[64]_set in C not CPP
Subsystems (2)
PATCH 1/1 x86: Code atomic[64]_read and atomic[64]_set in C not CPP
Occasionally we get bugs where atomic_read or atomic_set are used on atomic64_t variables or vice versa. These bugs don't generate warnings on x86 because atomic_read and atomic_set are coded as macros rather than C functions, so we don't get any type-checking on their arguments; similarly for atomic64_read and atomic64_set in 64-bit kernels.
This converts them to C functions so that the arguments are type-checked and bugs like this will get caught more easily. It also converts atomic_cmpxchg and atomic_xchg, and atomic64_cmpxchg and atomic64_xchg on 64-bit, so we get type-checking on their arguments too.
Compiling a typical 64-bit x86 config, this generates no new warnings, and the vmlinux text is 86 bytes smaller.
---
I have no idea why the text gets smaller with this patch, sorry.
By the way, I noticed while I was doing this that atomic64_t is unsigned on 32-bit x86 but signed on 64-bit x86. Somebody might like to make them consistent one day.
arch/x86/include/asm/atomic_32.h | 25 +++++++++++++++++----- arch/x86/include/asm/atomic_64.h | 42 ++++++++++++++++++++++++++++++------- 2 files changed, 53 insertions(+), 14 deletions(-)
arch/x86/include/asm/atomic_32.h +19 -6
@@ -19,7 +19,10 @@* * Atomically reads the value of @v. */ -#define atomic_read (v) ((v)->counter) +static inline int atomic_read (const atomic_t *v) +{ +return v->counter; +}/** * atomic_set - set atomic variable
@@ -28,7 +31,10 @@* * Atomically sets the value of @v to @i. */ -#define atomic_set (v, i) (((v)->counter) = (i)) +static inline void atomic_set (atomic_t *v,int i) +{ + v->counter = i; +}/** * atomic_add - add integer to atomic variable
@@ -200,8 +206,15 @@ static inline int atomic_sub_return(int i, atomic_t *v)return atomic_add_return (-i, v); } -#define atomic_cmpxchg (v, old, new) (cmpxchg(&((v)->counter), (old), (new))) -#define atomic_xchg (v, new) (xchg(&((v)->counter), (new))) +static inline int atomic_cmpxchg (atomic_t *v,int old,int new) +{ +return cmpxchg (&v->counter, old, new); +} + +static inline int atomic_xchg (atomic_t *v,int new) +{ +return xchg (&v->counter, new); +}/** * atomic_add_unless - add unless the number is already a given value
@@ -306,7 +319,7 @@ atomic64_xchg(atomic64_t *ptr, unsigned long long new_val)unsigned long long old_val;do { - old_val =atomic_read (ptr); + old_val =__atomic64_read (ptr); }while (atomic64_cmpxchg (ptr, old_val, new_val) != old_val);return old_val;
@@ -354,7 +367,7 @@ atomic64_add_return(unsigned long long delta, atomic64_t *ptr)unsigned long long old_val, new_val;do { - old_val =atomic_read (ptr); + old_val =__atomic64_read (ptr); new_val = old_val + delta; }while (atomic64_cmpxchg (ptr, old_val, new_val) != old_val);
arch/x86/include/asm/atomic_64.h +34 -8
73 lines not on this page · raw message
Signature · 1 line
1.6.0.4
Quoted 13 lines · Paul Mackerras
Occasionally we get bugs where
atomic_readoratomic_setare used onatomic64_tvariables or vice versa. These bugs don't generate warnings on x86 becauseatomic_readandatomic_setare coded as macros rather than C functions, so we don't get any type-checking on their arguments; similarly foratomic64_readandatomic64_setin 64-bit kernels.This converts them to C functions so that the arguments are type-checked and bugs like this will get caught more easily. It also converts
atomic_cmpxchgandatomic_xchg, andatomic64_cmpxchgandatomic64_xchgon 64-bit, so we get type-checking on their arguments too.
Quoted 4 lines
Compiling a typical 64-bit x86 config, this generates no new warnings, and the vmlinux text is 86 bytes smaller.
Signed-off-by Paul Mackerras <[email protected]>
Nice!