Release 4.18 arch/x86/include/asm/atomic64_32.h
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _ASM_X86_ATOMIC64_32_H
#define _ASM_X86_ATOMIC64_32_H
#include <linux/compiler.h>
#include <linux/types.h>
//#include <asm/cmpxchg.h>
/* An 64bit atomic type */
typedef struct {
u64 __aligned(8) counter;
} atomic64_t;
#define ATOMIC64_INIT(val) { (val) }
#define __ATOMIC64_DECL(sym) void atomic64_##sym(atomic64_t *, ...)
#ifndef ATOMIC64_EXPORT
#define ATOMIC64_DECL_ONE __ATOMIC64_DECL
#else
#define ATOMIC64_DECL_ONE(sym) __ATOMIC64_DECL(sym); \
ATOMIC64_EXPORT(atomic64_##sym)
#endif
#ifdef CONFIG_X86_CMPXCHG64
#define __alternative_atomic64(f, g, out, in...) \
asm volatile("call %P[func]" \
: out : [func] "i" (atomic64_##g##_cx8), ## in)
#define ATOMIC64_DECL(sym) ATOMIC64_DECL_ONE(sym##_cx8)
#else
#define __alternative_atomic64(f, g, out, in...) \
alternative_call(atomic64_##f##_386, atomic64_##g##_cx8, \
X86_FEATURE_CX8, ASM_OUTPUT2(out), ## in)
#define ATOMIC64_DECL(sym) ATOMIC64_DECL_ONE(sym##_cx8); \
ATOMIC64_DECL_ONE(sym##_386)
ATOMIC64_DECL_ONE(add_386);
ATOMIC64_DECL_ONE(sub_386);
ATOMIC64_DECL_ONE(inc_386);
ATOMIC64_DECL_ONE(dec_386);
#endif
#define alternative_atomic64(f, out, in...) \
__alternative_atomic64(f, f, ASM_OUTPUT2(out), ## in)
ATOMIC64_DECL(read);
ATOMIC64_DECL(set);
ATOMIC64_DECL(xchg);
ATOMIC64_DECL(add_return);
ATOMIC64_DECL(sub_return);
ATOMIC64_DECL(inc_return);
ATOMIC64_DECL(dec_return);
ATOMIC64_DECL(dec_if_positive);
ATOMIC64_DECL(inc_not_zero);
ATOMIC64_DECL(add_unless);
#undef ATOMIC64_DECL
#undef ATOMIC64_DECL_ONE
#undef __ATOMIC64_DECL
#undef ATOMIC64_EXPORT
/**
* arch_atomic64_cmpxchg - cmpxchg atomic64 variable
* @v: pointer to type atomic64_t
* @o: expected value
* @n: new value
*
* Atomically sets @v to @n if it was equal to @o and returns
* the old value.
*/
static inline long long arch_atomic64_cmpxchg(atomic64_t *v, long long o,
long long n)
{
return arch_cmpxchg64(&v->counter, o, n);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Luca Barbieri | 25 | 75.76% | 1 | 33.33% |
| Brian Gerst | 6 | 18.18% | 1 | 33.33% |
| Dmitriy Vyukov | 2 | 6.06% | 1 | 33.33% |
| Total | 33 | 100.00% | 3 | 100.00% |
/**
* arch_atomic64_xchg - xchg atomic64 variable
* @v: pointer to type atomic64_t
* @n: value to assign
*
* Atomically xchgs the value of @v to @n and returns
* the old value.
*/
static inline long long arch_atomic64_xchg(atomic64_t *v, long long n)
{
long long o;
unsigned high = (unsigned)(n >> 32);
unsigned low = (unsigned)n;
alternative_atomic64(xchg, "=&A" (o),
"S" (v), "b" (low), "c" (high)
: "memory");
return o;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Luca Barbieri | 37 | 52.86% | 1 | 25.00% |
| Jan Beulich | 27 | 38.57% | 1 | 25.00% |
| Brian Gerst | 5 | 7.14% | 1 | 25.00% |
| Dmitriy Vyukov | 1 | 1.43% | 1 | 25.00% |
| Total | 70 | 100.00% | 4 | 100.00% |
/**
* arch_atomic64_set - set atomic64 variable
* @v: pointer to type atomic64_t
* @i: value to assign
*
* Atomically sets the value of @v to @n.
*/
static inline void arch_atomic64_set(atomic64_t *v, long long i)
{
unsigned high = (unsigned)(i >> 32);
unsigned low = (unsigned)i;
alternative_atomic64(set, /* no output */,
"S" (v), "b" (low), "c" (high)
: "eax", "edx", "memory");
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 28 | 44.44% | 1 | 25.00% |
| Luca Barbieri | 28 | 44.44% | 1 | 25.00% |
| Brian Gerst | 6 | 9.52% | 1 | 25.00% |
| Dmitriy Vyukov | 1 | 1.59% | 1 | 25.00% |
| Total | 63 | 100.00% | 4 | 100.00% |
/**
* arch_atomic64_read - read atomic64 variable
* @v: pointer to type atomic64_t
*
* Atomically reads the value of @v and returns it.
*/
static inline long long arch_atomic64_read(const atomic64_t *v)
{
long long r;
alternative_atomic64(read, "=&A" (r), "c" (v) : "memory");
return r;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 17 | 45.95% | 1 | 20.00% |
| Brian Gerst | 11 | 29.73% | 1 | 20.00% |
| Luca Barbieri | 7 | 18.92% | 1 | 20.00% |
| H. Peter Anvin | 1 | 2.70% | 1 | 20.00% |
| Dmitriy Vyukov | 1 | 2.70% | 1 | 20.00% |
| Total | 37 | 100.00% | 5 | 100.00% |
/**
* arch_atomic64_add_return - add and return
* @i: integer value to add
* @v: pointer to type atomic64_t
*
* Atomically adds @i to @v and returns @i + *@v
*/
static inline long long arch_atomic64_add_return(long long i, atomic64_t *v)
{
alternative_atomic64(add_return,
ASM_OUTPUT2("+A" (i), "+c" (v)),
ASM_NO_INPUT_CLOBBER("memory"));
return i;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 23 | 54.76% | 1 | 25.00% |
| Luca Barbieri | 13 | 30.95% | 1 | 25.00% |
| Brian Gerst | 5 | 11.90% | 1 | 25.00% |
| Dmitriy Vyukov | 1 | 2.38% | 1 | 25.00% |
| Total | 42 | 100.00% | 4 | 100.00% |
/*
* Other variants with different arithmetic operators:
*/
static inline long long arch_atomic64_sub_return(long long i, atomic64_t *v)
{
alternative_atomic64(sub_return,
ASM_OUTPUT2("+A" (i), "+c" (v)),
ASM_NO_INPUT_CLOBBER("memory"));
return i;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 23 | 54.76% | 1 | 25.00% |
| Luca Barbieri | 13 | 30.95% | 1 | 25.00% |
| Brian Gerst | 5 | 11.90% | 1 | 25.00% |
| Dmitriy Vyukov | 1 | 2.38% | 1 | 25.00% |
| Total | 42 | 100.00% | 4 | 100.00% |
static inline long long arch_atomic64_inc_return(atomic64_t *v)
{
long long a;
alternative_atomic64(inc_return, "=&A" (a),
"S" (v) : "memory", "ecx");
return a;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 19 | 50.00% | 1 | 25.00% |
| Luca Barbieri | 14 | 36.84% | 1 | 25.00% |
| Brian Gerst | 4 | 10.53% | 1 | 25.00% |
| Dmitriy Vyukov | 1 | 2.63% | 1 | 25.00% |
| Total | 38 | 100.00% | 4 | 100.00% |
static inline long long arch_atomic64_dec_return(atomic64_t *v)
{
long long a;
alternative_atomic64(dec_return, "=&A" (a),
"S" (v) : "memory", "ecx");
return a;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 19 | 50.00% | 1 | 25.00% |
| Luca Barbieri | 14 | 36.84% | 1 | 25.00% |
| Brian Gerst | 4 | 10.53% | 1 | 25.00% |
| Dmitriy Vyukov | 1 | 2.63% | 1 | 25.00% |
| Total | 38 | 100.00% | 4 | 100.00% |
/**
* arch_atomic64_add - add integer to atomic64 variable
* @i: integer value to add
* @v: pointer to type atomic64_t
*
* Atomically adds @i to @v.
*/
static inline long long arch_atomic64_add(long long i, atomic64_t *v)
{
__alternative_atomic64(add, add_return,
ASM_OUTPUT2("+A" (i), "+c" (v)),
ASM_NO_INPUT_CLOBBER("memory"));
return i;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 25 | 56.82% | 1 | 25.00% |
| Luca Barbieri | 13 | 29.55% | 1 | 25.00% |
| Brian Gerst | 5 | 11.36% | 1 | 25.00% |
| Dmitriy Vyukov | 1 | 2.27% | 1 | 25.00% |
| Total | 44 | 100.00% | 4 | 100.00% |
/**
* arch_atomic64_sub - subtract the atomic64 variable
* @i: integer value to subtract
* @v: pointer to type atomic64_t
*
* Atomically subtracts @i from @v.
*/
static inline long long arch_atomic64_sub(long long i, atomic64_t *v)
{
__alternative_atomic64(sub, sub_return,
ASM_OUTPUT2("+A" (i), "+c" (v)),
ASM_NO_INPUT_CLOBBER("memory"));
return i;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 25 | 56.82% | 1 | 25.00% |
| Luca Barbieri | 13 | 29.55% | 1 | 25.00% |
| Brian Gerst | 5 | 11.36% | 1 | 25.00% |
| Dmitriy Vyukov | 1 | 2.27% | 1 | 25.00% |
| Total | 44 | 100.00% | 4 | 100.00% |
/**
* arch_atomic64_sub_and_test - subtract value from variable and test result
* @i: integer value to subtract
* @v: pointer to type atomic64_t
*
* Atomically subtracts @i from @v and returns
* true if the result is zero, or false for all
* other cases.
*/
static inline int arch_atomic64_sub_and_test(long long i, atomic64_t *v)
{
return arch_atomic64_sub_return(i, v) == 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Luca Barbieri | 17 | 68.00% | 1 | 33.33% |
| Brian Gerst | 6 | 24.00% | 1 | 33.33% |
| Dmitriy Vyukov | 2 | 8.00% | 1 | 33.33% |
| Total | 25 | 100.00% | 3 | 100.00% |
/**
* arch_atomic64_inc - increment atomic64 variable
* @v: pointer to type atomic64_t
*
* Atomically increments @v by 1.
*/
static inline void arch_atomic64_inc(atomic64_t *v)
{
__alternative_atomic64(inc, inc_return, /* no output */,
"S" (v) : "memory", "eax", "ecx", "edx");
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 22 | 66.67% | 1 | 25.00% |
| Luca Barbieri | 5 | 15.15% | 1 | 25.00% |
| Brian Gerst | 5 | 15.15% | 1 | 25.00% |
| Dmitriy Vyukov | 1 | 3.03% | 1 | 25.00% |
| Total | 33 | 100.00% | 4 | 100.00% |
/**
* arch_atomic64_dec - decrement atomic64 variable
* @v: pointer to type atomic64_t
*
* Atomically decrements @v by 1.
*/
static inline void arch_atomic64_dec(atomic64_t *v)
{
__alternative_atomic64(dec, dec_return, /* no output */,
"S" (v) : "memory", "eax", "ecx", "edx");
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 22 | 66.67% | 1 | 25.00% |
| Luca Barbieri | 5 | 15.15% | 1 | 25.00% |
| Brian Gerst | 5 | 15.15% | 1 | 25.00% |
| Dmitriy Vyukov | 1 | 3.03% | 1 | 25.00% |
| Total | 33 | 100.00% | 4 | 100.00% |
/**
* arch_atomic64_dec_and_test - decrement and test
* @v: pointer to type atomic64_t
*
* Atomically decrements @v by 1 and
* returns true if the result is 0, or false for all other
* cases.
*/
static inline int arch_atomic64_dec_and_test(atomic64_t *v)
{
return arch_atomic64_dec_return(v) == 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Luca Barbieri | 12 | 63.16% | 1 | 33.33% |
| Brian Gerst | 5 | 26.32% | 1 | 33.33% |
| Dmitriy Vyukov | 2 | 10.53% | 1 | 33.33% |
| Total | 19 | 100.00% | 3 | 100.00% |
/**
* atomic64_inc_and_test - increment and test
* @v: pointer to type atomic64_t
*
* Atomically increments @v by 1
* and returns true if the result is zero, or false for all
* other cases.
*/
static inline int arch_atomic64_inc_and_test(atomic64_t *v)
{
return arch_atomic64_inc_return(v) == 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Luca Barbieri | 12 | 63.16% | 1 | 33.33% |
| Brian Gerst | 5 | 26.32% | 1 | 33.33% |
| Dmitriy Vyukov | 2 | 10.53% | 1 | 33.33% |
| Total | 19 | 100.00% | 3 | 100.00% |
/**
* arch_atomic64_add_negative - add and test if negative
* @i: integer value to add
* @v: pointer to type atomic64_t
*
* Atomically adds @i to @v and returns true
* if the result is negative, or false when
* result is greater than or equal to zero.
*/
static inline int arch_atomic64_add_negative(long long i, atomic64_t *v)
{
return arch_atomic64_add_return(i, v) < 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Luca Barbieri | 18 | 72.00% | 1 | 33.33% |
| Brian Gerst | 5 | 20.00% | 1 | 33.33% |
| Dmitriy Vyukov | 2 | 8.00% | 1 | 33.33% |
| Total | 25 | 100.00% | 3 | 100.00% |
/**
* arch_atomic64_add_unless - add unless the number is a given value
* @v: pointer of type atomic64_t
* @a: the amount to add to v...
* @u: ...unless v is equal to u.
*
* Atomically adds @a to @v, so long as it was not @u.
* Returns non-zero if the add was done, zero otherwise.
*/
static inline int arch_atomic64_add_unless(atomic64_t *v, long long a,
long long u)
{
unsigned low = (unsigned)u;
unsigned high = (unsigned)(u >> 32);
alternative_atomic64(add_unless,
ASM_OUTPUT2("+A" (a), "+c" (low), "+D" (high)),
"S" (v) : "memory");
return (int)a;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Luca Barbieri | 44 | 58.67% | 1 | 25.00% |
| Jan Beulich | 30 | 40.00% | 2 | 50.00% |
| Dmitriy Vyukov | 1 | 1.33% | 1 | 25.00% |
| Total | 75 | 100.00% | 4 | 100.00% |
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;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 21 | 55.26% | 1 | 25.00% |
| Luca Barbieri | 15 | 39.47% | 1 | 25.00% |
| Brian Gerst | 1 | 2.63% | 1 | 25.00% |
| Dmitriy Vyukov | 1 | 2.63% | 1 | 25.00% |
| Total | 38 | 100.00% | 4 | 100.00% |
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;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 19 | 50.00% | 1 | 33.33% |
| Luca Barbieri | 18 | 47.37% | 1 | 33.33% |
| Dmitriy Vyukov | 1 | 2.63% | 1 | 33.33% |
| Total | 38 | 100.00% | 3 | 100.00% |
#undef alternative_atomic64
#undef __alternative_atomic64
static inline void arch_atomic64_and(long long i, atomic64_t *v)
{
long long old, c = 0;
while ((old = arch_atomic64_cmpxchg(v, c, c & i)) != c)
c = old;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Dmitriy Vyukov | 43 | 93.48% | 2 | 66.67% |
| Peter Zijlstra | 3 | 6.52% | 1 | 33.33% |
| Total | 46 | 100.00% | 3 | 100.00% |
static inline long long arch_atomic64_fetch_and(long long i, atomic64_t *v)
{
long long old, c = 0;
while ((old = arch_atomic64_cmpxchg(v, c, c & i)) != c)
c = old;
return old;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Dmitriy Vyukov | 44 | 88.00% | 2 | 66.67% |
| Peter Zijlstra | 6 | 12.00% | 1 | 33.33% |
| Total | 50 | 100.00% | 3 | 100.00% |
static inline void arch_atomic64_or(long long i, atomic64_t *v)
{
long long old, c = 0;
while ((old = arch_atomic64_cmpxchg(v, c, c | i)) != c)
c = old;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Dmitriy Vyukov | 41 | 89.13% | 2 | 66.67% |
| Peter Zijlstra | 5 | 10.87% | 1 | 33.33% |
| Total | 46 | 100.00% | 3 | 100.00% |
static inline long long arch_atomic64_fetch_or(long long i, atomic64_t *v)
{
long long old, c = 0;
while ((old = arch_atomic64_cmpxchg(v, c, c | i)) != c)
c = old;
return old;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Dmitriy Vyukov | 44 | 88.00% | 2 | 50.00% |
| Peter Zijlstra | 6 | 12.00% | 2 | 50.00% |
| Total | 50 | 100.00% | 4 | 100.00% |
static inline void arch_atomic64_xor(long long i, atomic64_t *v)
{
long long old, c = 0;
while ((old = arch_atomic64_cmpxchg(v, c, c ^ i)) != c)
c = old;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Dmitriy Vyukov | 43 | 93.48% | 2 | 66.67% |
| Peter Zijlstra | 3 | 6.52% | 1 | 33.33% |
| Total | 46 | 100.00% | 3 | 100.00% |
static inline long long arch_atomic64_fetch_xor(long long i, atomic64_t *v)
{
long long old, c = 0;
while ((old = arch_atomic64_cmpxchg(v, c, c ^ i)) != c)
c = old;
return old;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Dmitriy Vyukov | 47 | 94.00% | 2 | 66.67% |
| Peter Zijlstra | 3 | 6.00% | 1 | 33.33% |
| Total | 50 | 100.00% | 3 | 100.00% |
static inline long long arch_atomic64_fetch_add(long long i, atomic64_t *v)
{
long long old, c = 0;
while ((old = arch_atomic64_cmpxchg(v, c, c + i)) != c)
c = old;
return old;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Dmitriy Vyukov | 50 | 100.00% | 2 | 100.00% |
| Total | 50 | 100.00% | 2 | 100.00% |
#define arch_atomic64_fetch_sub(i, v) arch_atomic64_fetch_add(-(i), (v))
#endif /* _ASM_X86_ATOMIC64_32_H */
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jan Beulich | 467 | 35.03% | 2 | 20.00% |
| Dmitriy Vyukov | 358 | 26.86% | 2 | 20.00% |
| Luca Barbieri | 354 | 26.56% | 1 | 10.00% |
| Brian Gerst | 126 | 9.45% | 1 | 10.00% |
| Peter Zijlstra | 26 | 1.95% | 2 | 20.00% |
| Greg Kroah-Hartman | 1 | 0.08% | 1 | 10.00% |
| H. Peter Anvin | 1 | 0.08% | 1 | 10.00% |
| Linus Torvalds | | 0.00% | 0 | 0.00% |
| Total | 1333 | 100.00% | 10 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.