summaryrefslogtreecommitdiffstats
path: root/nsprpub/pr/include/prolock.h
blob: 5e5a40935cd3f3212f6494174f316162f7c473d6 (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
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef prolock_h___
#define prolock_h___

#include "prtypes.h"

PR_BEGIN_EXTERN_C

/*
** A locking mechanism, built on the existing PRLock definition,
** is provided that will permit applications to define a Lock
** Hierarchy (or Lock Ordering) schema. An application designed
** using the Ordered Lock functions will terminate with a
** diagnostic message when a lock inversion condition is
** detected. 
** 
** The lock ordering detection is compile-time enabled only. In
** optimized builds of NSPR, the Ordered Lock functions map
** directly to PRLock functions, providing no lock order
** detection.
** 
** The Ordered Lock Facility is compiled in when DEBUG is defined at
** compile-time. Ordered Lock can be forced on in optimized builds by
** defining FORCE_NSPR_ORDERED_LOCK at compile-time. Both the
** application using Ordered Lock and NSPR must be compiled with the
** facility enabled to achieve the desired results.
** 
** Application designers should use the macro interfaces to the Ordered
** Lock facility to ensure that it is compiled out in optimized builds.
**
** Application designers are responsible for defining their own
** lock hierarchy. 
**
** Ordered Lock is thread-safe and SMP safe.
**
** See Also: prlock.h
**
** /lth. 10-Jun-1998.
**
*/

/*
** Opaque type for ordered lock.
** ... Don't even think of looking in here.
**
*/

#if defined(DEBUG) || defined(FORCE_NSPR_ORDERED_LOCKS)
typedef void * PROrderedLock;
#else
/*
** Map PROrderedLock and methods onto PRLock when ordered locking
** is not compiled in.
**  
*/
#include "prlock.h"

typedef PRLock PROrderedLock;
#endif

/* -----------------------------------------------------------------------
** FUNCTION: PR_CreateOrderedLock() -- Create an Ordered Lock
** 
** DESCRIPTION: PR_CreateOrderedLock() creates an ordered lock.
** 
** INPUTS:
**  order: user defined order of this lock.
**  name: name of the lock. For debugging purposes.
** 
** OUTPUTS: returned
** 
** RETURNS: PR_OrderedLock pointer
** 
** RESTRICTIONS:
** 
*/
#if defined(DEBUG) || defined(FORCE_NSPR_ORDERED_LOCKS)
#define PR_CREATE_ORDERED_LOCK(order,name)\
    PR_CreateOrderedLock((order),(name))
#else
#define PR_CREATE_ORDERED_LOCK(order) PR_NewLock()
#endif

NSPR_API(PROrderedLock *) 
    PR_CreateOrderedLock( 
        PRInt32 order,
        const char *name
);

/* -----------------------------------------------------------------------
** FUNCTION: PR_DestroyOrderedLock() -- Destroy an Ordered Lock
** 
** DESCRIPTION: PR_DestroyOrderedLock() destroys the ordered lock
** referenced by lock.
** 
** INPUTS: lock: pointer to a PROrderedLock
** 
** OUTPUTS: the lock is destroyed
** 
** RETURNS: void
** 
** RESTRICTIONS:
** 
*/
#if defined(DEBUG) || defined(FORCE_NSPR_ORDERED_LOCKS)
#define PR_DESTROY_ORDERED_LOCK(lock) PR_DestroyOrderedLock((lock))
#else
#define PR_DESTROY_ORDERED_LOCK(lock) PR_DestroyLock((lock))
#endif

NSPR_API(void) 
    PR_DestroyOrderedLock( 
        PROrderedLock *lock 
);

/* -----------------------------------------------------------------------
** FUNCTION: PR_LockOrderedLock() -- Lock an ordered lock
** 
** DESCRIPTION: PR_LockOrderedLock() locks the ordered lock
** referenced by lock. If the order of lock is less than or equal
** to the order of the highest lock held by the locking thread,
** the function asserts.
** 
** INPUTS: lock: a pointer to a PROrderedLock
** 
** OUTPUTS: The lock is held or the function asserts.
** 
** RETURNS: void
** 
** RESTRICTIONS:
** 
*/
#if defined(DEBUG) || defined(FORCE_NSPR_ORDERED_LOCKS)
#define PR_LOCK_ORDERED_LOCK(lock) PR_LockOrderedLock((lock))
#else
#define PR_LOCK_ORDERED_LOCK(lock) PR_Lock((lock))
#endif

NSPR_API(void) 
    PR_LockOrderedLock( 
        PROrderedLock *lock 
);

/* -----------------------------------------------------------------------
** FUNCTION: PR_UnlockOrderedLock() -- unlock and Ordered Lock
** 
** DESCRIPTION: PR_UnlockOrderedLock() unlocks the lock referenced
** by lock.
** 
** INPUTS: lock: a pointer to a PROrderedLock
** 
** OUTPUTS: the lock is unlocked
** 
** RETURNS:
**  PR_SUCCESS
**  PR_FAILURE
** 
** RESTRICTIONS:
** 
*/
#if defined(DEBUG) || defined(FORCE_NSPR_ORDERED_LOCKS)
#define PR_UNLOCK_ORDERED_LOCK(lock) PR_UnlockOrderedLock((lock))
#else
#define PR_UNLOCK_ORDERED_LOCK(lock) PR_Unlock((lock))
#endif

NSPR_API(PRStatus) 
    PR_UnlockOrderedLock( 
        PROrderedLock *lock 
);

PR_END_EXTERN_C

#endif /* prolock_h___ */