~ttx/openldap/lucid-gssapi-495418

« back to all changes in this revision

Viewing changes to include/ldap_pvt_thread.h

  • Committer: Bazaar Package Importer
  • Author(s): Mathias Gug
  • Date: 2008-07-10 14:45:49 UTC
  • Revision ID: james.westby@ubuntu.com-20080710144549-wck73med0e72gfyo
Tags: upstream-2.4.10
ImportĀ upstreamĀ versionĀ 2.4.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* ldap_pvt_thread.h - ldap threads header file */
 
2
/* $OpenLDAP: pkg/ldap/include/ldap_pvt_thread.h,v 1.51.2.10 2008/03/21 00:46:03 hyc Exp $ */
 
3
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
 
4
 * 
 
5
 * Copyright 1998-2008 The OpenLDAP Foundation.
 
6
 * All rights reserved.
 
7
 *
 
8
 * Redistribution and use in source and binary forms, with or without
 
9
 * modification, are permitted only as authorized by the OpenLDAP
 
10
 * Public License.
 
11
 *
 
12
 * A copy of this license is available in file LICENSE in the
 
13
 * top-level directory of the distribution or, alternatively, at
 
14
 * <http://www.OpenLDAP.org/license.html>.
 
15
 */
 
16
 
 
17
#ifndef _LDAP_PVT_THREAD_H
 
18
#define _LDAP_PVT_THREAD_H /* libldap_r/ldap_thr_debug.h #undefines this */
 
19
 
 
20
#include "ldap_cdefs.h"
 
21
#include "ldap_int_thread.h"
 
22
 
 
23
LDAP_BEGIN_DECL
 
24
 
 
25
#ifndef LDAP_PVT_THREAD_H_DONE
 
26
typedef ldap_int_thread_t                       ldap_pvt_thread_t;
 
27
#ifdef LDAP_THREAD_DEBUG_WRAP
 
28
typedef ldap_debug_thread_mutex_t       ldap_pvt_thread_mutex_t;
 
29
typedef ldap_debug_thread_cond_t        ldap_pvt_thread_cond_t;
 
30
typedef ldap_debug_thread_rdwr_t        ldap_pvt_thread_rdwr_t;
 
31
#else
 
32
typedef ldap_int_thread_mutex_t         ldap_pvt_thread_mutex_t;
 
33
typedef ldap_int_thread_cond_t          ldap_pvt_thread_cond_t;
 
34
typedef ldap_int_thread_rdwr_t          ldap_pvt_thread_rdwr_t;
 
35
#endif
 
36
typedef ldap_int_thread_rmutex_t        ldap_pvt_thread_rmutex_t;
 
37
typedef ldap_int_thread_key_t   ldap_pvt_thread_key_t;
 
38
#endif /* !LDAP_PVT_THREAD_H_DONE */
 
39
 
 
40
#define ldap_pvt_thread_equal           ldap_int_thread_equal
 
41
 
 
42
LDAP_F( int )
 
43
ldap_pvt_thread_initialize LDAP_P(( void ));
 
44
 
 
45
LDAP_F( int )
 
46
ldap_pvt_thread_destroy LDAP_P(( void ));
 
47
 
 
48
LDAP_F( unsigned int )
 
49
ldap_pvt_thread_sleep LDAP_P(( unsigned int s ));
 
50
 
 
51
LDAP_F( int )
 
52
ldap_pvt_thread_get_concurrency LDAP_P(( void ));
 
53
 
 
54
LDAP_F( int )
 
55
ldap_pvt_thread_set_concurrency LDAP_P(( int ));
 
56
 
 
57
#define LDAP_PVT_THREAD_CREATE_JOINABLE 0
 
58
#define LDAP_PVT_THREAD_CREATE_DETACHED 1
 
59
 
 
60
#ifndef LDAP_PVT_THREAD_H_DONE
 
61
#define LDAP_PVT_THREAD_SET_STACK_SIZE
 
62
#ifndef LDAP_PVT_THREAD_STACK_SIZE
 
63
        /* LARGE stack. Will be twice as large on 64 bit machine. */
 
64
#define LDAP_PVT_THREAD_STACK_SIZE      ( 1 * 1024 * 1024 * sizeof(void *) )
 
65
/* May be explicitly defined to zero to disable it */
 
66
#elif LDAP_PVT_THREAD_STACK_SIZE == 0
 
67
#undef LDAP_PVT_THREAD_SET_STACK_SIZE
 
68
#endif
 
69
#endif /* !LDAP_PVT_THREAD_H_DONE */
 
70
 
 
71
LDAP_F( int )
 
72
ldap_pvt_thread_create LDAP_P((
 
73
        ldap_pvt_thread_t * thread,
 
74
        int     detach,
 
75
        void *(*start_routine)( void * ),
 
76
        void *arg));
 
77
 
 
78
LDAP_F( void )
 
79
ldap_pvt_thread_exit LDAP_P(( void *retval ));
 
80
 
 
81
LDAP_F( int )
 
82
ldap_pvt_thread_join LDAP_P(( ldap_pvt_thread_t thread, void **status ));
 
83
 
 
84
LDAP_F( int )
 
85
ldap_pvt_thread_kill LDAP_P(( ldap_pvt_thread_t thread, int signo ));
 
86
 
 
87
LDAP_F( int )
 
88
ldap_pvt_thread_yield LDAP_P(( void ));
 
89
 
 
90
LDAP_F( int )
 
91
ldap_pvt_thread_cond_init LDAP_P(( ldap_pvt_thread_cond_t *cond ));
 
92
 
 
93
LDAP_F( int )
 
94
ldap_pvt_thread_cond_destroy LDAP_P(( ldap_pvt_thread_cond_t *cond ));
 
95
 
 
96
LDAP_F( int )
 
97
ldap_pvt_thread_cond_signal LDAP_P(( ldap_pvt_thread_cond_t *cond ));
 
98
 
 
99
LDAP_F( int )
 
100
ldap_pvt_thread_cond_broadcast LDAP_P(( ldap_pvt_thread_cond_t *cond ));
 
101
 
 
102
LDAP_F( int )
 
103
ldap_pvt_thread_cond_wait LDAP_P((
 
104
        ldap_pvt_thread_cond_t *cond,
 
105
        ldap_pvt_thread_mutex_t *mutex ));
 
106
 
 
107
LDAP_F( int )
 
108
ldap_pvt_thread_mutex_init LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
 
109
 
 
110
LDAP_F( int )
 
111
ldap_pvt_thread_mutex_destroy LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
 
112
 
 
113
LDAP_F( int )
 
114
ldap_pvt_thread_mutex_lock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
 
115
 
 
116
LDAP_F( int )
 
117
ldap_pvt_thread_mutex_trylock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
 
118
 
 
119
LDAP_F( int )
 
120
ldap_pvt_thread_mutex_unlock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
 
121
 
 
122
LDAP_F( int )
 
123
ldap_pvt_thread_rmutex_init LDAP_P(( ldap_pvt_thread_rmutex_t *rmutex ));
 
124
 
 
125
LDAP_F( int )
 
126
ldap_pvt_thread_rmutex_destroy LDAP_P(( ldap_pvt_thread_rmutex_t *rmutex ));
 
127
 
 
128
LDAP_F( int )
 
129
ldap_pvt_thread_rmutex_lock LDAP_P(( ldap_pvt_thread_rmutex_t *rmutex,
 
130
        ldap_pvt_thread_t owner));
 
131
 
 
132
LDAP_F( int )
 
133
ldap_pvt_thread_rmutex_trylock LDAP_P(( ldap_pvt_thread_rmutex_t *rmutex,
 
134
        ldap_pvt_thread_t owner));
 
135
 
 
136
LDAP_F( int )
 
137
ldap_pvt_thread_rmutex_unlock LDAP_P(( ldap_pvt_thread_rmutex_t *rmutex,
 
138
        ldap_pvt_thread_t owner));
 
139
 
 
140
LDAP_F( ldap_pvt_thread_t )
 
141
ldap_pvt_thread_self LDAP_P(( void ));
 
142
 
 
143
#ifdef  LDAP_INT_THREAD_ASSERT_MUTEX_OWNER
 
144
#define LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER LDAP_INT_THREAD_ASSERT_MUTEX_OWNER
 
145
#else
 
146
#define LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER(mutex) ((void) 0)
 
147
#endif
 
148
 
 
149
LDAP_F( int )
 
150
ldap_pvt_thread_rdwr_init LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
 
151
 
 
152
LDAP_F( int )
 
153
ldap_pvt_thread_rdwr_destroy LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
 
154
 
 
155
LDAP_F( int )
 
156
ldap_pvt_thread_rdwr_rlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
 
157
 
 
158
LDAP_F( int )
 
159
ldap_pvt_thread_rdwr_rtrylock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
 
160
 
 
161
LDAP_F( int )
 
162
ldap_pvt_thread_rdwr_runlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
 
163
 
 
164
LDAP_F( int )
 
165
ldap_pvt_thread_rdwr_wlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
 
166
 
 
167
LDAP_F( int )
 
168
ldap_pvt_thread_rdwr_wtrylock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
 
169
 
 
170
LDAP_F( int )
 
171
ldap_pvt_thread_rdwr_wunlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
 
172
 
 
173
LDAP_F( int )
 
174
ldap_pvt_thread_key_create LDAP_P((ldap_pvt_thread_key_t *keyp));
 
175
 
 
176
LDAP_F( int )
 
177
ldap_pvt_thread_key_destroy LDAP_P((ldap_pvt_thread_key_t key));
 
178
 
 
179
LDAP_F( int )
 
180
ldap_pvt_thread_key_setdata LDAP_P((ldap_pvt_thread_key_t key, void *data));
 
181
 
 
182
LDAP_F( int )
 
183
ldap_pvt_thread_key_getdata LDAP_P((ldap_pvt_thread_key_t key, void **data));
 
184
 
 
185
#ifdef LDAP_DEBUG
 
186
LDAP_F( int )
 
187
ldap_pvt_thread_rdwr_readers LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
 
188
 
 
189
LDAP_F( int )
 
190
ldap_pvt_thread_rdwr_writers LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
 
191
 
 
192
LDAP_F( int )
 
193
ldap_pvt_thread_rdwr_active LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
 
194
#endif /* LDAP_DEBUG */
 
195
 
 
196
#define LDAP_PVT_THREAD_EINVAL EINVAL
 
197
#define LDAP_PVT_THREAD_EBUSY EINVAL
 
198
 
 
199
#ifndef LDAP_PVT_THREAD_H_DONE
 
200
typedef ldap_int_thread_pool_t ldap_pvt_thread_pool_t;
 
201
 
 
202
typedef void * (ldap_pvt_thread_start_t) LDAP_P((void *ctx, void *arg));
 
203
typedef void (ldap_pvt_thread_pool_keyfree_t) LDAP_P((void *key, void *data));
 
204
#endif /* !LDAP_PVT_THREAD_H_DONE */
 
205
 
 
206
LDAP_F( int )
 
207
ldap_pvt_thread_pool_init LDAP_P((
 
208
        ldap_pvt_thread_pool_t *pool_out,
 
209
        int max_threads,
 
210
        int max_pending ));
 
211
 
 
212
LDAP_F( int )
 
213
ldap_pvt_thread_pool_submit LDAP_P((
 
214
        ldap_pvt_thread_pool_t *pool,
 
215
        ldap_pvt_thread_start_t *start,
 
216
        void *arg ));
 
217
 
 
218
LDAP_F( int )
 
219
ldap_pvt_thread_pool_maxthreads LDAP_P((
 
220
        ldap_pvt_thread_pool_t *pool,
 
221
        int max_threads ));
 
222
 
 
223
#ifndef LDAP_PVT_THREAD_H_DONE
 
224
typedef enum {
 
225
        LDAP_PVT_THREAD_POOL_PARAM_UNKNOWN = -1,
 
226
        LDAP_PVT_THREAD_POOL_PARAM_MAX,
 
227
        LDAP_PVT_THREAD_POOL_PARAM_MAX_PENDING,
 
228
        LDAP_PVT_THREAD_POOL_PARAM_OPEN,
 
229
        LDAP_PVT_THREAD_POOL_PARAM_STARTING,
 
230
        LDAP_PVT_THREAD_POOL_PARAM_ACTIVE,
 
231
        LDAP_PVT_THREAD_POOL_PARAM_PAUSING,
 
232
        LDAP_PVT_THREAD_POOL_PARAM_PENDING,
 
233
        LDAP_PVT_THREAD_POOL_PARAM_BACKLOAD,
 
234
        LDAP_PVT_THREAD_POOL_PARAM_ACTIVE_MAX,
 
235
        LDAP_PVT_THREAD_POOL_PARAM_PENDING_MAX,
 
236
        LDAP_PVT_THREAD_POOL_PARAM_BACKLOAD_MAX,
 
237
        LDAP_PVT_THREAD_POOL_PARAM_STATE
 
238
} ldap_pvt_thread_pool_param_t;
 
239
#endif /* !LDAP_PVT_THREAD_H_DONE */
 
240
 
 
241
LDAP_F( int )
 
242
ldap_pvt_thread_pool_query LDAP_P((
 
243
        ldap_pvt_thread_pool_t *pool,
 
244
        ldap_pvt_thread_pool_param_t param, void *value ));
 
245
 
 
246
LDAP_F( int )
 
247
ldap_pvt_thread_pool_pausing LDAP_P((
 
248
        ldap_pvt_thread_pool_t *pool ));
 
249
 
 
250
LDAP_F( int )
 
251
ldap_pvt_thread_pool_backload LDAP_P((
 
252
        ldap_pvt_thread_pool_t *pool ));
 
253
 
 
254
LDAP_F( int )
 
255
ldap_pvt_thread_pool_pausecheck LDAP_P((
 
256
        ldap_pvt_thread_pool_t *pool ));
 
257
 
 
258
LDAP_F( int )
 
259
ldap_pvt_thread_pool_pause LDAP_P((
 
260
        ldap_pvt_thread_pool_t *pool ));
 
261
 
 
262
LDAP_F( int )
 
263
ldap_pvt_thread_pool_resume LDAP_P((
 
264
        ldap_pvt_thread_pool_t *pool ));
 
265
 
 
266
LDAP_F( int )
 
267
ldap_pvt_thread_pool_destroy LDAP_P((
 
268
        ldap_pvt_thread_pool_t *pool,
 
269
        int run_pending ));
 
270
 
 
271
LDAP_F( int )
 
272
ldap_pvt_thread_pool_getkey LDAP_P((
 
273
        void *ctx,
 
274
        void *key,
 
275
        void **data,
 
276
        ldap_pvt_thread_pool_keyfree_t **kfree ));
 
277
 
 
278
LDAP_F( int )
 
279
ldap_pvt_thread_pool_setkey LDAP_P((
 
280
        void *ctx,
 
281
        void *key,
 
282
        void *data,
 
283
        ldap_pvt_thread_pool_keyfree_t *kfree,
 
284
        void **olddatap,
 
285
        ldap_pvt_thread_pool_keyfree_t **oldkfreep ));
 
286
 
 
287
LDAP_F( void )
 
288
ldap_pvt_thread_pool_purgekey LDAP_P(( void *key ));
 
289
 
 
290
LDAP_F( void *)
 
291
ldap_pvt_thread_pool_context LDAP_P(( void ));
 
292
 
 
293
LDAP_F( void )
 
294
ldap_pvt_thread_pool_context_reset LDAP_P(( void *key ));
 
295
 
 
296
LDAP_F( ldap_pvt_thread_t )
 
297
ldap_pvt_thread_pool_tid LDAP_P(( void *ctx ));
 
298
 
 
299
LDAP_END_DECL
 
300
 
 
301
#define LDAP_PVT_THREAD_H_DONE
 
302
#endif /* _LDAP_PVT_THREAD_H */