/usr/include/nspr/prolock.h is in libnspr4-dev 2:4.11-1ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 definiion,
** 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 complile-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___ */
|