← Back to branch summary

~ubuntu-branches/ubuntu/trusty/erlang/trusty

« back to all changes in this revision

Viewing changes to erts/lib_src/common/ethr_atomics.c

  • Committer: Bazaar Package Importer
  • Author(s): Clint Byrum
  • Date: 2011-05-05 15:48:43 UTC
  • mfrom: (3.5.13 sid)
  • Revision ID: james.westby@ubuntu.com-20110505154843-0om6ekzg6m7ugj27
Tags: 1:14.b.2-dfsg-3ubuntu1
* Merge from debian unstable.  Remaining changes:
  - Drop libwxgtk2.8-dev build dependency. Wx isn't in main, and not
    supposed to.
  - Drop erlang-wx binary.
  - Drop erlang-wx dependency from -megaco, -common-test, and -reltool, they
    do not really need wx. Also drop it from -debugger; the GUI needs wx,
    but it apparently has CLI bits as well, and is also needed by -megaco,
    so let's keep the package for now.
  - debian/patches/series: Do what I meant, and enable build-options.patch
    instead.
* Additional changes:
  - Drop erlang-wx from -et
* Dropped Changes:
  - patches/pcre-crash.patch: CVE-2008-2371: outer level option with
    alternatives caused crash. (Applied Upstream)
  - fix for ssl certificate verification in newSSL: 
    ssl_cacertfile_fix.patch (Applied Upstream)
  - debian/patches/series: Enable native.patch again, to get stripped beam
    files and reduce the package size again. (build-options is what
    actually accomplished this)
  - Remove build-options.patch on advice from upstream and because it caused
    odd build failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
erts/lib_src/common/ethr_atomics.c
 
1
/*
 
2
 * %CopyrightBegin%
 
3
 *
 
4
 * Copyright Ericsson AB 2010. All Rights Reserved.
 
5
 *
 
6
 * The contents of this file are subject to the Erlang Public License,
 
7
 * Version 1.1, (the "License"); you may not use this file except in
 
8
 * compliance with the License. You should have received a copy of the
 
9
 * Erlang Public License along with this software. If not, it can be
 
10
 * retrieved online at http://www.erlang.org/.
 
11
 *
 
12
 * Software distributed under the License is distributed on an "AS IS"
 
13
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 
14
 * the License for the specific language governing rights and limitations
 
15
 * under the License.
 
16
 *
 
17
 * %CopyrightEnd%
 
18
 */
 
19
 
 
20
/*
 
21
 * Description: The ethread atomic API
 
22
 * Author: Rickard Green
 
23
 */
 
24
 
 
25
#ifdef HAVE_CONFIG_H
 
26
#include "config.h"
 
27
#endif
 
28
 
 
29
#define ETHR_INLINE_FUNC_NAME_(X) X ## __
 
30
#define ETHR_ATOMIC_IMPL__
 
31
 
 
32
#include "ethread.h"
 
33
#include "ethr_internal.h"
 
34
 
 
35
#ifndef ETHR_HAVE_NATIVE_ATOMICS
 
36
ethr_atomic_protection_t ethr_atomic_protection__[1 << ETHR_ATOMIC_ADDR_BITS];
 
37
#endif
 
38
 
 
39
int
 
40
ethr_init_atomics(void)
 
41
{
 
42
#ifndef ETHR_HAVE_NATIVE_ATOMICS
 
43
    {
 
44
        int i;
 
45
        for (i = 0; i < (1 << ETHR_ATOMIC_ADDR_BITS); i++) {
 
46
            int res = ethr_spinlock_init(&ethr_atomic_protection__[i].u.lck);
 
47
            if (res != 0)
 
48
                return res;
 
49
        }
 
50
    }
 
51
#endif
 
52
    return 0;
 
53
}
 
54
 
 
55
/*
 
56
 * --- Pointer size atomics ---------------------------------------------------
 
57
 */
 
58
 
 
59
ethr_sint_t *
 
60
ethr_atomic_addr(ethr_atomic_t *var)
 
61
{
 
62
    ETHR_ASSERT(var);
 
63
    return ethr_atomic_addr__(var);
 
64
}
 
65
 
 
66
void
 
67
ethr_atomic_init(ethr_atomic_t *var, ethr_sint_t i)
 
68
{
 
69
    ETHR_ASSERT(var);
 
70
    ethr_atomic_init__(var, i);
 
71
}
 
72
 
 
73
void
 
74
ethr_atomic_set(ethr_atomic_t *var, ethr_sint_t i)
 
75
{
 
76
    ETHR_ASSERT(!ethr_not_inited__);
 
77
    ETHR_ASSERT(var);
 
78
    ethr_atomic_set__(var, i);
 
79
}
 
80
 
 
81
ethr_sint_t
 
82
ethr_atomic_read(ethr_atomic_t *var)
 
83
{
 
84
    ETHR_ASSERT(!ethr_not_inited__);
 
85
    ETHR_ASSERT(var);
 
86
    return ethr_atomic_read__(var);
 
87
}
 
88
 
 
89
ethr_sint_t
 
90
ethr_atomic_add_read(ethr_atomic_t *var, ethr_sint_t incr)
 
91
{
 
92
    ETHR_ASSERT(!ethr_not_inited__);
 
93
    ETHR_ASSERT(var);
 
94
    return ethr_atomic_add_read__(var, incr);
 
95
}   
 
96
 
 
97
ethr_sint_t
 
98
ethr_atomic_inc_read(ethr_atomic_t *var)
 
99
{
 
100
    ETHR_ASSERT(!ethr_not_inited__);
 
101
    ETHR_ASSERT(var);
 
102
    return ethr_atomic_inc_read__(var);
 
103
}
 
104
 
 
105
ethr_sint_t
 
106
ethr_atomic_dec_read(ethr_atomic_t *var)
 
107
{
 
108
    ETHR_ASSERT(!ethr_not_inited__);
 
109
    ETHR_ASSERT(var);
 
110
    return ethr_atomic_dec_read__(var);
 
111
}
 
112
 
 
113
void
 
114
ethr_atomic_add(ethr_atomic_t *var, ethr_sint_t incr)
 
115
{
 
116
    ETHR_ASSERT(!ethr_not_inited__);
 
117
    ETHR_ASSERT(var);
 
118
    ethr_atomic_add__(var, incr);
 
119
}   
 
120
    
 
121
void
 
122
ethr_atomic_inc(ethr_atomic_t *var)
 
123
{
 
124
    ETHR_ASSERT(!ethr_not_inited__);
 
125
    ETHR_ASSERT(var);
 
126
    ethr_atomic_inc__(var);
 
127
}
 
128
 
 
129
void
 
130
ethr_atomic_dec(ethr_atomic_t *var)
 
131
{
 
132
    ETHR_ASSERT(!ethr_not_inited__);
 
133
    ETHR_ASSERT(var);
 
134
    ethr_atomic_dec__(var);
 
135
}
 
136
 
 
137
ethr_sint_t
 
138
ethr_atomic_read_band(ethr_atomic_t *var, ethr_sint_t mask)
 
139
{
 
140
    ETHR_ASSERT(!ethr_not_inited__);
 
141
    ETHR_ASSERT(var);
 
142
    return ethr_atomic_read_band__(var, mask);
 
143
}
 
144
 
 
145
ethr_sint_t
 
146
ethr_atomic_read_bor(ethr_atomic_t *var, ethr_sint_t mask)
 
147
{
 
148
    ETHR_ASSERT(!ethr_not_inited__);
 
149
    ETHR_ASSERT(var);
 
150
    return ethr_atomic_read_bor__(var, mask);
 
151
}
 
152
 
 
153
ethr_sint_t
 
154
ethr_atomic_xchg(ethr_atomic_t *var, ethr_sint_t new)
 
155
{
 
156
    ETHR_ASSERT(!ethr_not_inited__);
 
157
    ETHR_ASSERT(var);
 
158
    return ethr_atomic_xchg__(var, new);
 
159
}   
 
160
 
 
161
ethr_sint_t
 
162
ethr_atomic_cmpxchg(ethr_atomic_t *var, ethr_sint_t new, ethr_sint_t expected)
 
163
{
 
164
    ETHR_ASSERT(!ethr_not_inited__);
 
165
    ETHR_ASSERT(var);
 
166
    return ethr_atomic_cmpxchg__(var, new, expected);
 
167
}
 
168
 
 
169
ethr_sint_t
 
170
ethr_atomic_read_acqb(ethr_atomic_t *var)
 
171
{
 
172
    ETHR_ASSERT(!ethr_not_inited__);
 
173
    ETHR_ASSERT(var);
 
174
    return ethr_atomic_read_acqb__(var);
 
175
}
 
176
 
 
177
ethr_sint_t
 
178
ethr_atomic_inc_read_acqb(ethr_atomic_t *var)
 
179
{
 
180
    ETHR_ASSERT(!ethr_not_inited__);
 
181
    ETHR_ASSERT(var);
 
182
    return ethr_atomic_inc_read_acqb__(var);
 
183
}
 
184
 
 
185
void
 
186
ethr_atomic_set_relb(ethr_atomic_t *var, ethr_sint_t i)
 
187
{
 
188
    ETHR_ASSERT(!ethr_not_inited__);
 
189
    ETHR_ASSERT(var);
 
190
    ethr_atomic_set_relb__(var, i);
 
191
}
 
192
 
 
193
void
 
194
ethr_atomic_dec_relb(ethr_atomic_t *var)
 
195
{
 
196
    ETHR_ASSERT(!ethr_not_inited__);
 
197
    ETHR_ASSERT(var);
 
198
    ethr_atomic_dec_relb__(var);
 
199
}
 
200
 
 
201
ethr_sint_t
 
202
ethr_atomic_dec_read_relb(ethr_atomic_t *var)
 
203
{
 
204
    ETHR_ASSERT(!ethr_not_inited__);
 
205
    ETHR_ASSERT(var);
 
206
    return ethr_atomic_dec_read_relb__(var);
 
207
}
 
208
 
 
209
ethr_sint_t
 
210
ethr_atomic_cmpxchg_acqb(ethr_atomic_t *var, ethr_sint_t new, ethr_sint_t exp)
 
211
{
 
212
    ETHR_ASSERT(!ethr_not_inited__);
 
213
    ETHR_ASSERT(var);
 
214
    return ethr_atomic_cmpxchg_acqb__(var, new, exp);
 
215
}
 
216
 
 
217
ethr_sint_t
 
218
ethr_atomic_cmpxchg_relb(ethr_atomic_t *var, ethr_sint_t new, ethr_sint_t exp)
 
219
{
 
220
    ETHR_ASSERT(!ethr_not_inited__);
 
221
    ETHR_ASSERT(var);
 
222
    return ethr_atomic_cmpxchg_relb__(var, new, exp);
 
223
}
 
224
 
 
225
 
 
226
/*
 
227
 * --- 32-bit atomics ---------------------------------------------------------
 
228
 */
 
229
 
 
230
ethr_sint32_t *
 
231
ethr_atomic32_addr(ethr_atomic32_t *var)
 
232
{
 
233
    ETHR_ASSERT(var);
 
234
    return ethr_atomic32_addr__(var);
 
235
}
 
236
 
 
237
void
 
238
ethr_atomic32_init(ethr_atomic32_t *var, ethr_sint32_t i)
 
239
{
 
240
    ETHR_ASSERT(var);
 
241
    ethr_atomic32_init__(var, i);
 
242
}
 
243
 
 
244
void
 
245
ethr_atomic32_set(ethr_atomic32_t *var, ethr_sint32_t i)
 
246
{
 
247
    ETHR_ASSERT(!ethr_not_inited__);
 
248
    ETHR_ASSERT(var);
 
249
    ethr_atomic32_set__(var, i);
 
250
}
 
251
 
 
252
ethr_sint32_t
 
253
ethr_atomic32_read(ethr_atomic32_t *var)
 
254
{
 
255
    ETHR_ASSERT(!ethr_not_inited__);
 
256
    ETHR_ASSERT(var);
 
257
    return ethr_atomic32_read__(var);
 
258
}
 
259
 
 
260
 
 
261
ethr_sint32_t
 
262
ethr_atomic32_add_read(ethr_atomic32_t *var, ethr_sint32_t incr)
 
263
{
 
264
    ETHR_ASSERT(!ethr_not_inited__);
 
265
    ETHR_ASSERT(var);
 
266
    return ethr_atomic32_add_read__(var, incr);
 
267
}   
 
268
 
 
269
ethr_sint32_t
 
270
ethr_atomic32_inc_read(ethr_atomic32_t *var)
 
271
{
 
272
    ETHR_ASSERT(!ethr_not_inited__);
 
273
    ETHR_ASSERT(var);
 
274
    return ethr_atomic32_inc_read__(var);
 
275
}
 
276
 
 
277
ethr_sint32_t
 
278
ethr_atomic32_dec_read(ethr_atomic32_t *var)
 
279
{
 
280
    ETHR_ASSERT(!ethr_not_inited__);
 
281
    ETHR_ASSERT(var);
 
282
    return ethr_atomic32_dec_read__(var);
 
283
}
 
284
 
 
285
void
 
286
ethr_atomic32_add(ethr_atomic32_t *var, ethr_sint32_t incr)
 
287
{
 
288
    ETHR_ASSERT(!ethr_not_inited__);
 
289
    ETHR_ASSERT(var);
 
290
    ethr_atomic32_add__(var, incr);
 
291
}   
 
292
    
 
293
void
 
294
ethr_atomic32_inc(ethr_atomic32_t *var)
 
295
{
 
296
    ETHR_ASSERT(!ethr_not_inited__);
 
297
    ETHR_ASSERT(var);
 
298
    ethr_atomic32_inc__(var);
 
299
}
 
300
 
 
301
void
 
302
ethr_atomic32_dec(ethr_atomic32_t *var)
 
303
{
 
304
    ETHR_ASSERT(!ethr_not_inited__);
 
305
    ETHR_ASSERT(var);
 
306
    ethr_atomic32_dec__(var);
 
307
}
 
308
 
 
309
ethr_sint32_t
 
310
ethr_atomic32_read_band(ethr_atomic32_t *var, ethr_sint32_t mask)
 
311
{
 
312
    ETHR_ASSERT(!ethr_not_inited__);
 
313
    ETHR_ASSERT(var);
 
314
    return ethr_atomic32_read_band__(var, mask);
 
315
}
 
316
 
 
317
ethr_sint32_t
 
318
ethr_atomic32_read_bor(ethr_atomic32_t *var, ethr_sint32_t mask)
 
319
{
 
320
    ETHR_ASSERT(!ethr_not_inited__);
 
321
    ETHR_ASSERT(var);
 
322
    return ethr_atomic32_read_bor__(var, mask);
 
323
}
 
324
 
 
325
ethr_sint32_t
 
326
ethr_atomic32_xchg(ethr_atomic32_t *var, ethr_sint32_t new)
 
327
{
 
328
    ETHR_ASSERT(!ethr_not_inited__);
 
329
    ETHR_ASSERT(var);
 
330
    return ethr_atomic32_xchg__(var, new);
 
331
}   
 
332
 
 
333
ethr_sint32_t
 
334
ethr_atomic32_cmpxchg(ethr_atomic32_t *var,
 
335
                      ethr_sint32_t new,
 
336
                      ethr_sint32_t expected)
 
337
{
 
338
    ETHR_ASSERT(!ethr_not_inited__);
 
339
    ETHR_ASSERT(var);
 
340
    return ethr_atomic32_cmpxchg__(var, new, expected);
 
341
}
 
342
 
 
343
ethr_sint32_t
 
344
ethr_atomic32_read_acqb(ethr_atomic32_t *var)
 
345
{
 
346
    ETHR_ASSERT(!ethr_not_inited__);
 
347
    ETHR_ASSERT(var);
 
348
    return ethr_atomic32_read_acqb__(var);
 
349
}
 
350
 
 
351
ethr_sint32_t
 
352
ethr_atomic32_inc_read_acqb(ethr_atomic32_t *var)
 
353
{
 
354
    ETHR_ASSERT(!ethr_not_inited__);
 
355
    ETHR_ASSERT(var);
 
356
    return ethr_atomic32_inc_read_acqb__(var);
 
357
}
 
358
 
 
359
void
 
360
ethr_atomic32_set_relb(ethr_atomic32_t *var, ethr_sint32_t i)
 
361
{
 
362
    ETHR_ASSERT(!ethr_not_inited__);
 
363
    ETHR_ASSERT(var);
 
364
    ethr_atomic32_set_relb__(var, i);
 
365
}
 
366
 
 
367
void
 
368
ethr_atomic32_dec_relb(ethr_atomic32_t *var)
 
369
{
 
370
    ETHR_ASSERT(!ethr_not_inited__);
 
371
    ETHR_ASSERT(var);
 
372
    ethr_atomic32_dec_relb__(var);
 
373
}
 
374
 
 
375
ethr_sint32_t
 
376
ethr_atomic32_dec_read_relb(ethr_atomic32_t *var)
 
377
{
 
378
    ETHR_ASSERT(!ethr_not_inited__);
 
379
    ETHR_ASSERT(var);
 
380
    return ethr_atomic32_dec_read_relb__(var);
 
381
}
 
382
 
 
383
ethr_sint32_t
 
384
ethr_atomic32_cmpxchg_acqb(ethr_atomic32_t *var,
 
385
                           ethr_sint32_t new,
 
386
                           ethr_sint32_t exp)
 
387
{
 
388
    ETHR_ASSERT(!ethr_not_inited__);
 
389
    ETHR_ASSERT(var);
 
390
    return ethr_atomic32_cmpxchg_acqb__(var, new, exp);
 
391
}
 
392
 
 
393
ethr_sint32_t
 
394
ethr_atomic32_cmpxchg_relb(ethr_atomic32_t *var,
 
395
                           ethr_sint32_t new,
 
396
                           ethr_sint32_t exp)
 
397
{
 
398
    ETHR_ASSERT(!ethr_not_inited__);
 
399
    ETHR_ASSERT(var);
 
400
    return ethr_atomic32_cmpxchg_relb__(var, new, exp);
 
401
}
 
402