/
atomic.h
147 lines (130 loc) · 5.52 KB
/
atomic.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
/* $NetBSD: atomic.h,v 1.6 2007/11/30 17:13:10 ad Exp $ */
/*-
* Copyright (c) 2007 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Jason R. Thorpe.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the NetBSD
* Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _SYS_ATOMIC_H_
#define _SYS_ATOMIC_H_
#include <sys/types.h>
#if !defined(_KERNEL)
#include <stdint.h>
#endif
/*
* Atomic ADD
*/
void atomic_add_32(volatile uint32_t *, int32_t);
void atomic_add_int(volatile unsigned int *, int);
void atomic_add_long(volatile unsigned long *, long);
void atomic_add_ptr(volatile void *, ssize_t);
void atomic_add_64(volatile uint64_t *, int64_t);
uint32_t atomic_add_32_nv(volatile uint32_t *, int32_t);
unsigned int atomic_add_int_nv(volatile unsigned int *, int);
unsigned long atomic_add_long_nv(volatile unsigned long *, long);
void * atomic_add_ptr_nv(volatile void *, ssize_t);
uint64_t atomic_add_64_nv(volatile uint64_t *, int64_t);
/*
* Atomic AND
*/
void atomic_and_32(volatile uint32_t *, uint32_t);
void atomic_and_uint(volatile unsigned int *, unsigned int);
void atomic_and_ulong(volatile unsigned long *, unsigned long);
void atomic_and_64(volatile uint64_t *, uint64_t);
uint32_t atomic_and_32_nv(volatile uint32_t *, uint32_t);
unsigned int atomic_and_uint_nv(volatile unsigned int *, unsigned int);
unsigned long atomic_and_ulong_nv(volatile unsigned long *, unsigned long);
uint64_t atomic_and_64_nv(volatile uint64_t *, uint64_t);
/*
* Atomic OR
*/
void atomic_or_32(volatile uint32_t *, uint32_t);
void atomic_or_uint(volatile unsigned int *, unsigned int);
void atomic_or_ulong(volatile unsigned long *, unsigned long);
void atomic_or_64(volatile uint64_t *, uint64_t);
uint32_t atomic_or_32_nv(volatile uint32_t *, uint32_t);
unsigned int atomic_or_uint_nv(volatile unsigned int *, unsigned int);
unsigned long atomic_or_ulong_nv(volatile unsigned long *, unsigned long);
uint64_t atomic_or_64_nv(volatile uint64_t *, uint64_t);
/*
* Atomic COMPARE-AND-SWAP
*/
uint32_t atomic_cas_32(volatile uint32_t *, uint32_t, uint32_t);
unsigned int atomic_cas_uint(volatile unsigned int *, unsigned int,
unsigned int);
unsigned long atomic_cas_ulong(volatile unsigned long *, unsigned long,
unsigned long);
void * atomic_cas_ptr(volatile void *, void *, void *);
uint64_t atomic_cas_64(volatile uint64_t *, uint64_t, uint64_t);
/*
* Atomic SWAP
*/
uint32_t atomic_swap_32(volatile uint32_t *, uint32_t);
unsigned int atomic_swap_uint(volatile unsigned int *, unsigned int);
unsigned long atomic_swap_ulong(volatile unsigned long *, unsigned long);
void * atomic_swap_ptr(volatile void *, void *);
uint64_t atomic_swap_64(volatile uint64_t *, uint64_t);
/*
* Atomic DECREMENT
*/
void atomic_dec_32(volatile uint32_t *);
void atomic_dec_uint(volatile unsigned int *);
void atomic_dec_ulong(volatile unsigned long *);
void atomic_dec_ptr(volatile void *);
void atomic_dec_64(volatile uint64_t *);
uint32_t atomic_dec_32_nv(volatile uint32_t *);
unsigned int atomic_dec_uint_nv(volatile unsigned int *);
unsigned long atomic_dec_ulong_nv(volatile unsigned long *);
void * atomic_dec_ptr_nv(volatile void *);
uint64_t atomic_dec_64_nv(volatile uint64_t *);
/*
* Atomic INCREMENT
*/
void atomic_inc_32(volatile uint32_t *);
void atomic_inc_uint(volatile unsigned int *);
void atomic_inc_ulong(volatile unsigned long *);
void atomic_inc_ptr(volatile void *);
void atomic_inc_64(volatile uint64_t *);
uint32_t atomic_inc_32_nv(volatile uint32_t *);
unsigned int atomic_inc_uint_nv(volatile unsigned int *);
unsigned long atomic_inc_ulong_nv(volatile unsigned long *);
void * atomic_inc_ptr_nv(volatile void *);
uint64_t atomic_inc_64_nv(volatile uint64_t *);
/*
* Memory barrier operations
*/
void membar_enter(void);
void membar_exit(void);
void membar_producer(void);
void membar_consumer(void);
void membar_sync(void);
#endif /* ! _SYS_ATOMIC_H_ */