/* SPDX-License-Identifier: GPL-2.0-or-later *//* * Generic C implementation of atomic counter operations. Usable on * UP systems only. Do not include in machine independent code. * * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) */#ifndef __ASM_GENERIC_ATOMIC_H#define __ASM_GENERIC_ATOMIC_H #include <asm/cmpxchg.h>#include <asm/barrier.h> /* * atomic_$op() - $op integer to atomic variable * @i: integer value to $op * @v: pointer to the atomic variable * * Atomically $ops @i to @v. Does not strictly guarantee a memory-barrier, use * smp_mb__{before,after}_atomic(). */ /* * atomic_$op_return() - $op interer to atomic variable and returns the result * @i: integer value to $op * @v: pointer to the atomic variable * * Atomically $ops @i to @v. Does imply a full memory barrier. */ #ifdef CONFIG_SMP /* we can build all atomic primitives from cmpxchg */ #define ATOMIC_OP(op, c_op)						\static inline void atomic_##op(int i, atomic_t *v)			\{									\	int c, old;							\									\	c = v->counter;							\	while ((old = cmpxchg(&v->counter, c, c c_op i)) != c)		\		c = old;						\} #define ATOMIC_OP_RETURN(op, c_op)					\static inline int atomic_##op##_return(int i, atomic_t *v)		\{									\	int c, old;							\									\	c = v->counter;							\	while ((old = cmpxchg(&v->counter, c, c c_op i)) != c)		\		c = old;						\									\	return c c_op i;						\} #define ATOMIC_FETCH_OP(op, c_op)					\static inline int atomic_fetch_##op(int i, atomic_t *v)			\{									\	int c, old;							\									\	c = v->counter;							\	while ((old = cmpxchg(&v->counter, c, c c_op i)) != c)		\		c = old;						\									\	return c;							\} #else #include <linux/irqflags.h> #define ATOMIC_OP(op, c_op)						\static inline void atomic_##op(int i, atomic_t *v)			\{									\	unsigned long flags;						\									\	raw_local_irq_save(flags);					\	v->counter = v->counter c_op i;					\	raw_local_irq_restore(flags);					\} #define ATOMIC_OP_RETURN(op, c_op)					\static inline int atomic_##op##_return(int i, atomic_t *v)		\{									\	unsigned long flags;						\	int ret;							\									\	raw_local_irq_save(flags);					\	ret = (v->counter = v->counter c_op i);				\	raw_local_irq_restore(flags);					\									\	return ret;							\} #define ATOMIC_FETCH_OP(op, c_op)					\static inline int atomic_fetch_##op(int i, atomic_t *v)			\{									\	unsigned long flags;						\	int ret;							\									\	raw_local_irq_save(flags);					\	ret = v->counter;						\	v->counter = v->counter c_op i;					\	raw_local_irq_restore(flags);					\									\	return ret;							\} #endif /* CONFIG_SMP */ #ifndef atomic_add_returnATOMIC_OP_RETURN(add, +)#endif #ifndef atomic_sub_returnATOMIC_OP_RETURN(sub, -)#endif #ifndef atomic_fetch_addATOMIC_FETCH_OP(add, +)#endif #ifndef atomic_fetch_subATOMIC_FETCH_OP(sub, -)#endif #ifndef atomic_fetch_andATOMIC_FETCH_OP(and, &)#endif #ifndef atomic_fetch_orATOMIC_FETCH_OP(or, |)#endif #ifndef atomic_fetch_xorATOMIC_FETCH_OP(xor, ^)#endif #ifndef atomic_andATOMIC_OP(and, &)#endif #ifndef atomic_orATOMIC_OP(or, |)#endif #ifndef atomic_xorATOMIC_OP(xor, ^)#endif #undef ATOMIC_FETCH_OP#undef ATOMIC_OP_RETURN#undef ATOMIC_OP /* * Atomic operations that C can't guarantee us.  Useful for * resource counting etc.. */ #define ATOMIC_INIT(i)	{ (i) } /** * atomic_read - read atomic variable * @v: pointer of type atomic_t * * Atomically reads the value of @v. */#ifndef atomic_read#define atomic_read(v)	READ_ONCE((v)->counter)#endif /** * atomic_set - set atomic variable * @v: pointer of type atomic_t * @i: required value * * Atomically sets the value of @v to @i. */#define atomic_set(v, i) WRITE_ONCE(((v)->counter), (i)) #include <linux/irqflags.h> static inline void atomic_add(int i, atomic_t *v){	atomic_add_return(i, v);} static inline void atomic_sub(int i, atomic_t *v){	atomic_sub_return(i, v);} #define atomic_xchg(ptr, v)		(xchg(&(ptr)->counter, (v)))#define atomic_cmpxchg(v, old, new)	(cmpxchg(&((v)->counter), (old), (new))) #endif /* __ASM_GENERIC_ATOMIC_H */