blob: 2ef7f6de8a648d8396176457742cb58cedcea59d (
plain)
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
|
/*-------------------------------------------------------------------------
*
* spin.h
* Hardware-independent implementation of spinlocks.
*
*
* The hardware-independent interface to spinlocks is defined by the
* typedef "slock_t" and these macros:
*
* void SpinLockInit(slock_t *lock)
* Initialize a spinlock (to the unlocked state).
*
* void SpinLockAcquire(slock_t *lock)
* Acquire a spinlock, waiting if necessary.
* Time out and abort() if unable to acquire the lock in a
* "reasonable" amount of time --- typically ~ 1 minute.
* Cancel/die interrupts are held off until the lock is released.
*
* void SpinLockRelease(slock_t *lock)
* Unlock a previously acquired lock.
* Release the cancel/die interrupt holdoff.
*
* void SpinLockAcquire_NoHoldoff(slock_t *lock)
* void SpinLockRelease_NoHoldoff(slock_t *lock)
* Same as above, except no interrupt holdoff processing is done.
* This pair of macros may be used when there is a surrounding
* interrupt holdoff.
*
* bool SpinLockFree(slock_t *lock)
* Tests if the lock is free. Returns TRUE if free, FALSE if locked.
* This does *not* change the state of the lock.
*
* Callers must beware that the macro argument may be evaluated multiple
* times!
*
* The macros are implemented in terms of hardware-dependent macros
* supplied by s_lock.h.
*
*
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $Id: spin.h,v 1.18 2001/10/28 06:26:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef SPIN_H
#define SPIN_H
#include "storage/s_lock.h"
#include "miscadmin.h"
#define SpinLockInit(lock) S_INIT_LOCK(lock)
#define SpinLockAcquire(lock) \
do { \
HOLD_INTERRUPTS(); \
S_LOCK(lock); \
} while (0)
#define SpinLockAcquire_NoHoldoff(lock) S_LOCK(lock)
#define SpinLockRelease(lock) \
do { \
S_UNLOCK(lock); \
RESUME_INTERRUPTS(); \
} while (0)
#define SpinLockRelease_NoHoldoff(lock) S_UNLOCK(lock)
#define SpinLockFree(lock) S_LOCK_FREE(lock)
extern void CreateSpinlocks(void);
#endif /* SPIN_H */
|
