GlusterFS 的原子操作封装头文件

这个 atomic.h 是 GlusterFS 的跨平台原子操作封装库，让多线程环境下整数操作既安全又高效，同时屏蔽了不同平台和编译器的差异。

This file is part of GlusterFS.

This file is licensed to you under your choice of the GNU Lesser

General Public License, version 3 or any later version (LGPLv3 or

later), or the GNU General Public License, version 2 (GPLv2), in all

cases as published by the Free Software Foundation.

#ifndef _ATOMIC_H

#define _ATOMIC_H

#include <inttypes.h>

#include <stdbool.h>

#include "glusterfs/locking.h"

/* Macros used to join two arguments and generate a new macro name. */

#define GF_ATOMIC_MACRO_1(_macro) _macro

#define GF_ATOMIC_MACRO(_base, _name) GF_ATOMIC_MACRO_1(_base##_name)

/* There's a problem on 32-bit architectures when we try to use atomic

* builtins with 64-bit types. Only way to solve the problem is to use

* a mutex to protect the access to the atomic, but we don't want to

* use mutexes for other smaller types that could work with the atomic

* builtins.

* So on each atomic type we add a field for the mutex if atomic operation

* is not supported and a dummy zero size field if it's supported. This way

* we can have different atomic types, some with a mutex and some without.

* To define these types, we use two macros:

* GF_ATOMIC_MUTEX_FIELD_0 = char lk[0]

* GF_ATOMIC_MUTEX_FILED_1 = gf_lock_t lk

* Both macros define the 'lk' field that will be used in the atomic

* structure. One when the atomic is supported by the architecture and

* another when not. We need to define the field even if it won't be

* used. Otherwise the compiler will return an error.

* Now we need to take the mutex or not depending on the existence of

* the mutex field in the structure. To do so we check the size of the

* structure, and if it's bigger than uint64_t (all structures with a

* mutex will be bigger), we use the mutex-based version. Otherwise we

* use the atomic builtin. This check is easily optimized out by the

* compiler, leaving a clean and efficient compiled code. */

#define GF_ATOMIC_MUTEX_FIELD_0 char lk[0] // GCC 扩展属性， GCC 的零长度数组扩展

#define GF_ATOMIC_MUTEX_FIELD_1 gf_lock_t lk

/* We'll use SIZEOF_LONG to determine the architecture. 32-bit machines

* will have 4 here, while 64-bit machines will have 8. If additional

* needs or restrictions appear on other platforms, these tests can be

* extended to handle them. */

/* GF_ATOMIC_SIZE_X macros map each type size to one of the

* GF_ATOMIC_MUTEX_FIELD_X macros, depending on detected conditions. */

// 判断宏定义的较新的 GCC/Clang 原子内建函数或者旧式 __sync_* 内建函数

#if defined(HAVE_ATOMIC_BUILTINS) || defined(HAVE_SYNC_BUILTINS)

#define GF_ATOMIC_SIZE_1 GF_ATOMIC_MUTEX_FIELD_0

#define GF_ATOMIC_SIZE_2 GF_ATOMIC_MUTEX_FIELD_0

#define GF_ATOMIC_SIZE_4 GF_ATOMIC_MUTEX_FIELD_0

#if SIZEOF_LONG >= 8

#define GF_ATOMIC_SIZE_8 GF_ATOMIC_MUTEX_FIELD_0

#endif

#endif /* HAVE_(ATOMIC|SYNC)_BUILTINS */

/* Any GF_ATOMIC_SIZE_X macro not yet defined will use the mutex version */

#ifndef GF_ATOMIC_SIZE_1

#define GF_ATOMIC_SIZE_1 GF_ATOMIC_MUTEX_FIELD_1

#endif

#ifndef GF_ATOMIC_SIZE_2

#define GF_ATOMIC_SIZE_2 GF_ATOMIC_MUTEX_FIELD_1

#endif

#ifndef GF_ATOMIC_SIZE_4

#define GF_ATOMIC_SIZE_4 GF_ATOMIC_MUTEX_FIELD_1

#endif

#ifndef GF_ATOMIC_SIZE_8

#define GF_ATOMIC_SIZE_8 GF_ATOMIC_MUTEX_FIELD_1

#endif

/* This macro is used to define all atomic types supported. First field

* represents the size of the type in bytes, and the second one the name. */

#define GF_ATOMIC_TYPE(_size, _name) \

typedef struct _gf_atomic_##_name##_t { \

GF_ATOMIC_MACRO(GF_ATOMIC_SIZE_, _size); \

_name##_t value; \

} gf_atomic_##_name##_t

/* The atomic types we support */

GF_ATOMIC_TYPE(1, int8); /* gf_atomic_int8_t */

GF_ATOMIC_TYPE(2, int16); /* gf_atomic_int16_t */

GF_ATOMIC_TYPE(4, int32); /* gf_atomic_int32_t */

GF_ATOMIC_TYPE(8, int64); /* gf_atomic_int64_t */

GF_ATOMIC_TYPE(SIZEOF_LONG, intptr); /* gf_atomic_intptr_t */

GF_ATOMIC_TYPE(1, uint8); /* gf_atomic_uint8_t */

GF_ATOMIC_TYPE(2, uint16); /* gf_atomic_uint16_t */

GF_ATOMIC_TYPE(4, uint32); /* gf_atomic_uint32_t */

GF_ATOMIC_TYPE(8, uint64); /* gf_atomic_uint64_t */

GF_ATOMIC_TYPE(SIZEOF_LONG, uintptr); /* gf_atomic_uintptr_t */

/* Define the default atomic type as int64_t */

#define gf_atomic_t gf_atomic_int64_t

/* This macro will choose between the mutex based version and the atomic

* builtin version depending on the size of the atomic structure. */

#define GF_ATOMIC_CHOOSE(_atomic, _op, _args...) \

((sizeof(_atomic) > sizeof(uint64_t)) \

? ({ \

GF_ATOMIC_MACRO(GF_ATOMIC_LOCK_, _op) \

(_atomic, ##_args); \

}) \

: ({ \

GF_ATOMIC_MACRO(GF_ATOMIC_BASE_, _op) \

(_atomic, ##_args); \

}))

/* Macros to implement the mutex-based atomics. */

#define GF_ATOMIC_OP_PREPARE(_atomic, _name) \

typeof(_atomic) *__atomic = &(_atomic); \

gf_lock_t *__lock = (gf_lock_t *)&__atomic->lk; \

LOCK(__lock); \

typeof(__atomic->value) _name = __atomic->value

#define GF_ATOMIC_OP_STORE(_value) (__atomic->value = (_value))

#define GF_ATOMIC_OP_RETURN(_value) \

({ \

UNLOCK(__lock); \

_value; \

})

#define GF_ATOMIC_LOCK_INIT(_atomic, _value) \

do { \

typeof(_atomic) *__atomic = &(_atomic); \

LOCK_INIT((gf_lock_t *)&__atomic->lk); \

__atomic->value = (_value); \

} while (0)

#define GF_ATOMIC_LOCK_GET(_atomic) \

({ \