Mercurial > trustbridge > nss-cmake-static

comparison nspr/pr/include/private/primpl.h @ 0:1e5118fa0cb1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
This is NSS with a Cmake Buildsyste To compile a static NSS library for Windows we've used the Chromium-NSS fork and added a Cmake buildsystem to compile it statically for Windows. See README.chromium for chromium changes and README.trustbridge for our modifications.
author Andre Heinecke <andre.heinecke@intevation.de>
date Mon, 28 Jul 2014 10:47:06 +0200
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:1e5118fa0cb1
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #ifndef primpl_h___
7 #define primpl_h___
8
9 /*
10 * HP-UX 10.10's pthread.h (DCE threads) includes dce/cma.h, which
11 * has:
12 * #define sigaction _sigaction_sys
13 * This macro causes chaos if signal.h gets included before pthread.h.
14 * To be safe, we include pthread.h first.
15 */
16
17 #if defined(_PR_PTHREADS)
18 #include <pthread.h>
19 #endif
20
21 #if defined(_PR_BTHREADS)
22 #include <kernel/OS.h>
23 #endif
24
25 #ifdef WIN32
26 /*
27 * Allow use of functions and symbols first defined in Win2k.
28 */
29 #if !defined(WINVER) || (WINVER < 0x0500)
30 #undef WINVER
31 #define WINVER 0x0500
32 #endif
33 #if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0500)
34 #undef _WIN32_WINNT
35 #define _WIN32_WINNT 0x0500
36 #endif
37 #endif /* WIN32 */
38
39 #include "nspr.h"
40 #include "prpriv.h"
41
42 typedef struct PRSegment PRSegment;
43
44 #include "md/prosdep.h"
45 #include "obsolete/probslet.h"
46
47 #ifdef _PR_HAVE_POSIX_SEMAPHORES
48 #include <semaphore.h>
49 #elif defined(_PR_HAVE_SYSV_SEMAPHORES)
50 #include <sys/sem.h>
51 #endif
52
53 #ifdef HAVE_SYSCALL
54 #include <sys/syscall.h>
55 #endif
56
57 /*************************************************************************
58 ***** A Word about Model Dependent Function Naming Convention ***********
59 *************************************************************************/
60
61 /*
62 NSPR 2.0 must implement its function across a range of platforms
63 including: MAC, Windows/16, Windows/95, Windows/NT, and several
64 variants of Unix. Each implementation shares common code as well
65 as having platform dependent portions. This standard describes how
66 the model dependent portions are to be implemented.
67
68 In header file pr/include/primpl.h, each publicly declared
69 platform dependent function is declared as:
70
71 NSPR_API void _PR_MD_FUNCTION( long arg1, long arg2 );
72 #define _PR_MD_FUNCTION _MD_FUNCTION
73
74 In header file pr/include/md/<platform>/_<platform>.h,
75 each #define'd macro is redefined as one of:
76
77 #define _MD_FUNCTION <blanks>
78 #define _MD_FUNCTION <expanded macro>
79 #define _MD_FUNCTION <osFunction>
80 #define _MD_FUNCTION <_MD_Function>
81
82 Where:
83
84 <blanks> is no definition at all. In this case, the function is not implemented
85 and is never called for this platform.
86 For example:
87 #define _MD_INIT_CPUS()
88
89 <expanded macro> is a C language macro expansion.
90 For example:
91 #define _MD_CLEAN_THREAD(_thread) \
92 PR_BEGIN_MACRO \
93 PR_DestroyCondVar(_thread->md.asyncIOCVar); \
94 PR_DestroyLock(_thread->md.asyncIOLock); \
95 PR_END_MACRO
96
97 <osFunction> is some function implemented by the host operating system.
98 For example:
99 #define _MD_EXIT exit
100
101 <_MD_function> is the name of a function implemented for this platform in
102 pr/src/md/<platform>/<soruce>.c file.
103 For example:
104 #define _MD_GETFILEINFO _MD_GetFileInfo
105
106 In <source>.c, the implementation is:
107 PR_IMPLEMENT(PRInt32) _MD_GetFileInfo(const char *fn, PRFileInfo *info);
108 */
109
110 PR_BEGIN_EXTERN_C
111
112 typedef struct _MDLock _MDLock;
113 typedef struct _MDCVar _MDCVar;
114 typedef struct _MDSegment _MDSegment;
115 typedef struct _MDThread _MDThread;
116 typedef struct _MDThreadStack _MDThreadStack;
117 typedef struct _MDSemaphore _MDSemaphore;
118 typedef struct _MDDir _MDDir;
119 #ifdef MOZ_UNICODE
120 typedef struct _MDDirUTF16 _MDDirUTF16;
121 #endif /* MOZ_UNICODE */
122 typedef struct _MDFileDesc _MDFileDesc;
123 typedef struct _MDProcess _MDProcess;
124 typedef struct _MDFileMap _MDFileMap;
125
126 #if defined(_PR_PTHREADS)
127
128 /*
129 ** The following definitions are unique to implementing NSPR using pthreads.
130 ** Since pthreads defines most of the thread and thread synchronization
131 ** stuff, this is a pretty small set.
132 */
133
134 #define PT_CV_NOTIFIED_LENGTH 6
135 typedef struct _PT_Notified _PT_Notified;
136 struct _PT_Notified
137 {
138 PRIntn length; /* # of used entries in this structure */
139 struct
140 {
141 PRCondVar *cv; /* the condition variable notified */
142 PRIntn times; /* and the number of times notified */
143 } cv[PT_CV_NOTIFIED_LENGTH];
144 _PT_Notified *link; /* link to another of these | NULL */
145 };
146
147 /*
148 * bits defined for pthreads 'state' field
149 */
150 #define PT_THREAD_DETACHED 0x01 /* thread can't be joined */
151 #define PT_THREAD_GLOBAL 0x02 /* a global thread (unlikely) */
152 #define PT_THREAD_SYSTEM 0x04 /* system (not user) thread */
153 #define PT_THREAD_PRIMORD 0x08 /* this is the primordial thread */
154 #define PT_THREAD_ABORTED 0x10 /* thread has been interrupted */
155 #define PT_THREAD_GCABLE 0x20 /* thread is garbage collectible */
156 #define PT_THREAD_SUSPENDED 0x40 /* thread has been suspended */
157 #define PT_THREAD_FOREIGN 0x80 /* thread is not one of ours */
158 #define PT_THREAD_BOUND 0x100 /* a bound-global thread */
159
160 #define _PT_THREAD_INTERRUPTED(thr) \
161 (!(thr->interrupt_blocked) && (thr->state & PT_THREAD_ABORTED))
162 #define _PT_THREAD_BLOCK_INTERRUPT(thr) \
163 (thr->interrupt_blocked = 1)
164 #define _PT_THREAD_UNBLOCK_INTERRUPT(thr) \
165 (thr->interrupt_blocked = 0)
166
167 #define _PT_IS_GCABLE_THREAD(thr) ((thr)->state & PT_THREAD_GCABLE)
168
169 /*
170 ** Possible values for thread's suspend field
171 ** Note that the first two can be the same as they are really mutually exclusive,
172 ** i.e. both cannot be happening at the same time. We have two symbolic names
173 ** just as a mnemonic.
174 **/
175 #define PT_THREAD_RESUMED 0x80 /* thread has been resumed */
176 #define PT_THREAD_SETGCABLE 0x100 /* set the GCAble flag */
177
178 #if defined(DEBUG)
179
180 typedef struct PTDebug
181 {
182 PRTime timeStarted;
183 PRUintn locks_created, locks_destroyed;
184 PRUintn locks_acquired, locks_released;
185 PRUintn cvars_created, cvars_destroyed;
186 PRUintn cvars_notified, delayed_cv_deletes;
187 } PTDebug;
188
189 #endif /* defined(DEBUG) */
190
191 NSPR_API(void) PT_FPrintStats(PRFileDesc *fd, const char *msg);
192
193 /*
194 * On Linux and its derivatives POSIX priority scheduling works only for
195 * real-time threads. On those platforms we set thread's nice values
196 * instead which requires us to track kernel thread IDs for each POSIX
197 * thread we create.
198 */
199 #if defined(LINUX) && defined(HAVE_SETPRIORITY) && \
200 ((defined(HAVE_SYSCALL) && defined(SYS_gettid)) || defined(HAVE_GETTID))
201 #define _PR_NICE_PRIORITY_SCHEDULING
202 #endif
203
204 #else /* defined(_PR_PTHREADS) */
205
206 NSPR_API(void) PT_FPrintStats(PRFileDesc *fd, const char *msg);
207
208 /*
209 ** This section is contains those parts needed to implement NSPR on
210 ** platforms in general. One would assume that the pthreads implementation
211 ** included lots of the same types, at least conceptually.
212 */
213
214 /*
215 * Local threads only. No multiple CPU support and hence all the
216 * following routines are no-op.
217 */
218 #ifdef _PR_LOCAL_THREADS_ONLY
219
220 #define _PR_MD_SUSPEND_THREAD(thread)
221 #define _PR_MD_RESUME_THREAD(thread)
222 #define _PR_MD_SUSPEND_CPU(cpu)
223 #define _PR_MD_RESUME_CPU(cpu)
224 #define _PR_MD_BEGIN_SUSPEND_ALL()
225 #define _PR_MD_END_SUSPEND_ALL()
226 #define _PR_MD_BEGIN_RESUME_ALL()
227 #define _PR_MD_END_RESUME_ALL()
228 #define _PR_MD_INIT_ATTACHED_THREAD(thread) PR_FAILURE
229
230 #endif
231
232 typedef struct _PRCPUQueue _PRCPUQueue;
233 typedef struct _PRCPU _PRCPU;
234 typedef struct _MDCPU _MDCPU;
235
236 struct _PRCPUQueue {
237 _MDLock runQLock; /* lock for the run + wait queues */
238 _MDLock sleepQLock; /* lock for the run + wait queues */
239 _MDLock miscQLock; /* lock for the run + wait queues */
240
241 PRCList runQ[PR_PRIORITY_LAST + 1]; /* run queue for this CPU */
242 PRUint32 runQReadyMask;
243 PRCList sleepQ;
244 PRIntervalTime sleepQmax;
245 PRCList pauseQ;
246 PRCList suspendQ;
247 PRCList waitingToJoinQ;
248
249 PRUintn numCPUs; /* number of CPUs using this Q */
250 };
251
252 struct _PRCPU {
253 PRCList links; /* link list of CPUs */
254 PRUint32 id; /* id for this CPU */
255
256 union {
257 PRInt32 bits;
258 PRUint8 missed[4];
259 } u;
260 PRIntn where; /* index into u.missed */
261 PRPackedBool paused; /* cpu is paused */
262 PRPackedBool exit; /* cpu should exit */
263
264 PRThread *thread; /* native thread for this CPUThread */
265 PRThread *idle_thread; /* user-level idle thread for this CPUThread */
266
267 PRIntervalTime last_clock; /* the last time we went into
268 * _PR_ClockInterrupt() on this CPU
269 */
270
271 _PRCPUQueue *queue;
272
273 _MDCPU md;
274 };
275
276 typedef struct _PRInterruptTable {
277 const char *name;
278 PRUintn missed_bit;
279 void (*handler)(void);
280 } _PRInterruptTable;
281
282 #define _PR_CPU_PTR(_qp) \
283 ((_PRCPU*) ((char*) (_qp) - offsetof(_PRCPU,links)))
284
285 #if !defined(IRIX) && !defined(WIN32) && !defined(XP_OS2) \
286 && !(defined(SOLARIS) && defined(_PR_GLOBAL_THREADS_ONLY))
287 #define _MD_GET_ATTACHED_THREAD() (_PR_MD_CURRENT_THREAD())
288 #endif
289
290 #ifdef _PR_LOCAL_THREADS_ONLY
291
292 NSPR_API(struct _PRCPU *) _pr_currentCPU;
293 NSPR_API(PRThread *) _pr_currentThread;
294 NSPR_API(PRThread *) _pr_lastThread;
295 NSPR_API(PRInt32) _pr_intsOff;
296
297 #define _MD_CURRENT_CPU() (_pr_currentCPU)
298 #define _MD_SET_CURRENT_CPU(_cpu) (_pr_currentCPU = (_cpu))
299 #define _MD_CURRENT_THREAD() (_pr_currentThread)
300 #define _MD_SET_CURRENT_THREAD(_thread) (_pr_currentThread = (_thread))
301 #define _MD_LAST_THREAD() (_pr_lastThread)
302 #define _MD_SET_LAST_THREAD(t) (_pr_lastThread = t)
303
304 #define _MD_GET_INTSOFF() (_pr_intsOff)
305 #define _MD_SET_INTSOFF(_val) (_pr_intsOff = _val)
306
307
308 /* The unbalanced curly braces in these two macros are intentional */
309 #define _PR_LOCK_HEAP() { PRIntn _is; if (_pr_currentCPU) _PR_INTSOFF(_is);
310 #define _PR_UNLOCK_HEAP() if (_pr_currentCPU) _PR_INTSON(_is); }
311
312 #endif /* _PR_LOCAL_THREADS_ONLY */
313
314 extern PRInt32 _native_threads_only;
315
316 #if defined(_PR_GLOBAL_THREADS_ONLY)
317
318 #define _MD_GET_INTSOFF() 0
319 #define _MD_SET_INTSOFF(_val)
320 #define _PR_INTSOFF(_is)
321 #define _PR_FAST_INTSON(_is)
322 #define _PR_INTSON(_is)
323 #define _PR_THREAD_LOCK(_thread)
324 #define _PR_THREAD_UNLOCK(_thread)
325 #define _PR_RUNQ_LOCK(cpu)
326 #define _PR_RUNQ_UNLOCK(cpu)
327 #define _PR_SLEEPQ_LOCK(thread)
328 #define _PR_SLEEPQ_UNLOCK(thread)
329 #define _PR_MISCQ_LOCK(thread)
330 #define _PR_MISCQ_UNLOCK(thread)
331 #define _PR_CPU_LIST_LOCK()
332 #define _PR_CPU_LIST_UNLOCK()
333
334 #define _PR_ADD_RUNQ(_thread, _cpu, _pri)
335 #define _PR_DEL_RUNQ(_thread)
336 #define _PR_ADD_SLEEPQ(_thread, _timeout)
337 #define _PR_DEL_SLEEPQ(_thread, _propogate)
338 #define _PR_ADD_JOINQ(_thread, _cpu)
339 #define _PR_DEL_JOINQ(_thread)
340 #define _PR_ADD_SUSPENDQ(_thread, _cpu)
341 #define _PR_DEL_SUSPENDQ(_thread)
342
343 #define _PR_THREAD_SWITCH_CPU(_thread, _newCPU)
344
345 #define _PR_IS_NATIVE_THREAD(thread) 1
346 #define _PR_IS_NATIVE_THREAD_SUPPORTED() 1
347
348 #else
349
350 #define _PR_INTSOFF(_is) \
351 PR_BEGIN_MACRO \
352 (_is) = _PR_MD_GET_INTSOFF(); \
353 _PR_MD_SET_INTSOFF(1); \
354 PR_END_MACRO
355
356 #define _PR_FAST_INTSON(_is) \
357 PR_BEGIN_MACRO \
358 _PR_MD_SET_INTSOFF(_is); \
359 PR_END_MACRO
360
361 #define _PR_INTSON(_is) \
362 PR_BEGIN_MACRO \
363 if ((_is == 0) && (_PR_MD_CURRENT_CPU())->u.bits) \
364 _PR_IntsOn((_PR_MD_CURRENT_CPU())); \
365 _PR_MD_SET_INTSOFF(_is); \
366 PR_END_MACRO
367
368 #ifdef _PR_LOCAL_THREADS_ONLY
369
370 #define _PR_IS_NATIVE_THREAD(thread) 0
371 #define _PR_THREAD_LOCK(_thread)
372 #define _PR_THREAD_UNLOCK(_thread)
373 #define _PR_RUNQ_LOCK(cpu)
374 #define _PR_RUNQ_UNLOCK(cpu)
375 #define _PR_SLEEPQ_LOCK(thread)
376 #define _PR_SLEEPQ_UNLOCK(thread)
377 #define _PR_MISCQ_LOCK(thread)
378 #define _PR_MISCQ_UNLOCK(thread)
379 #define _PR_CPU_LIST_LOCK()
380 #define _PR_CPU_LIST_UNLOCK()
381
382 #define _PR_ADD_RUNQ(_thread, _cpu, _pri) \
383 PR_BEGIN_MACRO \
384 PR_APPEND_LINK(&(_thread)->links, &_PR_RUNQ(_cpu)[_pri]); \
385 _PR_RUNQREADYMASK(_cpu) |= (1L << _pri); \
386 PR_END_MACRO
387
388 #define _PR_DEL_RUNQ(_thread) \
389 PR_BEGIN_MACRO \
390 _PRCPU *_cpu = _thread->cpu; \
391 PRInt32 _pri = _thread->priority; \
392 PR_REMOVE_LINK(&(_thread)->links); \
393 if (PR_CLIST_IS_EMPTY(&_PR_RUNQ(_cpu)[_pri])) \
394 _PR_RUNQREADYMASK(_cpu) &= ~(1L << _pri); \
395 PR_END_MACRO
396
397 #define _PR_ADD_SLEEPQ(_thread, _timeout) \
398 _PR_AddSleepQ(_thread, _timeout);
399
400 #define _PR_DEL_SLEEPQ(_thread, _propogate) \
401 _PR_DelSleepQ(_thread, _propogate);
402
403 #define _PR_ADD_JOINQ(_thread, _cpu) \
404 PR_APPEND_LINK(&(_thread)->links, &_PR_WAITINGTOJOINQ(_cpu));
405
406 #define _PR_DEL_JOINQ(_thread) \
407 PR_REMOVE_LINK(&(_thread)->links);
408
409 #define _PR_ADD_SUSPENDQ(_thread, _cpu) \
410 PR_APPEND_LINK(&(_thread)->links, &_PR_SUSPENDQ(_cpu));
411
412 #define _PR_DEL_SUSPENDQ(_thread) \
413 PR_REMOVE_LINK(&(_thread)->links);
414
415 #define _PR_THREAD_SWITCH_CPU(_thread, _newCPU)
416
417 #define _PR_IS_NATIVE_THREAD_SUPPORTED() 0
418
419 #else /* _PR_LOCAL_THREADS_ONLY */
420
421 /* These are for the "combined" thread model */
422
423 #define _PR_THREAD_LOCK(_thread) \
424 _PR_MD_LOCK(&(_thread)->threadLock);
425
426 #define _PR_THREAD_UNLOCK(_thread) \
427 _PR_MD_UNLOCK(&(_thread)->threadLock);
428
429 #define _PR_RUNQ_LOCK(_cpu) \
430 PR_BEGIN_MACRO \
431 _PR_MD_LOCK(&(_cpu)->queue->runQLock );\
432 PR_END_MACRO
433
434 #define _PR_RUNQ_UNLOCK(_cpu) \
435 PR_BEGIN_MACRO \
436 _PR_MD_UNLOCK(&(_cpu)->queue->runQLock );\
437 PR_END_MACRO
438
439 #define _PR_SLEEPQ_LOCK(_cpu) \
440 _PR_MD_LOCK(&(_cpu)->queue->sleepQLock );
441
442 #define _PR_SLEEPQ_UNLOCK(_cpu) \
443 _PR_MD_UNLOCK(&(_cpu)->queue->sleepQLock );
444
445 #define _PR_MISCQ_LOCK(_cpu) \
446 _PR_MD_LOCK(&(_cpu)->queue->miscQLock );
447
448 #define _PR_MISCQ_UNLOCK(_cpu) \
449 _PR_MD_UNLOCK(&(_cpu)->queue->miscQLock );
450
451 #define _PR_CPU_LIST_LOCK() _PR_MD_LOCK(&_pr_cpuLock)
452 #define _PR_CPU_LIST_UNLOCK() _PR_MD_UNLOCK(&_pr_cpuLock)
453
454 #define QUEUE_RUN 0x1
455 #define QUEUE_SLEEP 0x2
456 #define QUEUE_JOIN 0x4
457 #define QUEUE_SUSPEND 0x8
458 #define QUEUE_LOCK 0x10
459
460 #define _PR_ADD_RUNQ(_thread, _cpu, _pri) \
461 PR_BEGIN_MACRO \
462 PR_APPEND_LINK(&(_thread)->links, &_PR_RUNQ(_cpu)[_pri]); \
463 _PR_RUNQREADYMASK(_cpu) |= (1L << _pri); \
464 PR_ASSERT((_thread)->queueCount == 0); \
465 (_thread)->queueCount = QUEUE_RUN; \
466 PR_END_MACRO
467
468 #define _PR_DEL_RUNQ(_thread) \
469 PR_BEGIN_MACRO \
470 _PRCPU *_cpu = _thread->cpu; \
471 PRInt32 _pri = _thread->priority; \
472 PR_REMOVE_LINK(&(_thread)->links); \
473 if (PR_CLIST_IS_EMPTY(&_PR_RUNQ(_cpu)[_pri])) \
474 _PR_RUNQREADYMASK(_cpu) &= ~(1L << _pri); \
475 PR_ASSERT((_thread)->queueCount == QUEUE_RUN);\
476 (_thread)->queueCount = 0; \
477 PR_END_MACRO
478
479 #define _PR_ADD_SLEEPQ(_thread, _timeout) \
480 PR_ASSERT((_thread)->queueCount == 0); \
481 (_thread)->queueCount = QUEUE_SLEEP; \
482 _PR_AddSleepQ(_thread, _timeout);
483
484 #define _PR_DEL_SLEEPQ(_thread, _propogate) \
485 PR_ASSERT((_thread)->queueCount == QUEUE_SLEEP);\
486 (_thread)->queueCount = 0; \
487 _PR_DelSleepQ(_thread, _propogate);
488
489 #define _PR_ADD_JOINQ(_thread, _cpu) \
490 PR_ASSERT((_thread)->queueCount == 0); \
491 (_thread)->queueCount = QUEUE_JOIN; \
492 PR_APPEND_LINK(&(_thread)->links, &_PR_WAITINGTOJOINQ(_cpu));
493
494 #define _PR_DEL_JOINQ(_thread) \
495 PR_ASSERT((_thread)->queueCount == QUEUE_JOIN);\
496 (_thread)->queueCount = 0; \
497 PR_REMOVE_LINK(&(_thread)->links);
498
499 #define _PR_ADD_SUSPENDQ(_thread, _cpu) \
500 PR_ASSERT((_thread)->queueCount == 0); \
501 (_thread)->queueCount = QUEUE_SUSPEND; \
502 PR_APPEND_LINK(&(_thread)->links, &_PR_SUSPENDQ(_cpu));
503
504 #define _PR_DEL_SUSPENDQ(_thread) \
505 PR_ASSERT((_thread)->queueCount == QUEUE_SUSPEND);\
506 (_thread)->queueCount = 0; \
507 PR_REMOVE_LINK(&(_thread)->links);
508
509 #define _PR_THREAD_SWITCH_CPU(_thread, _newCPU) \
510 (_thread)->cpu = (_newCPU);
511
512 #define _PR_IS_NATIVE_THREAD(thread) (thread->flags & _PR_GLOBAL_SCOPE)
513 #define _PR_IS_NATIVE_THREAD_SUPPORTED() 1
514
515 #endif /* _PR_LOCAL_THREADS_ONLY */
516
517 #endif /* _PR_GLOBAL_THREADS_ONLY */
518
519 #define _PR_SET_RESCHED_FLAG() _PR_MD_CURRENT_CPU()->u.missed[3] = 1
520 #define _PR_CLEAR_RESCHED_FLAG() _PR_MD_CURRENT_CPU()->u.missed[3] = 0
521
522 extern _PRInterruptTable _pr_interruptTable[];
523
524 /* Bits for _pr_interruptState.u.missed[0,1] */
525 #define _PR_MISSED_CLOCK 0x1
526 #define _PR_MISSED_IO 0x2
527 #define _PR_MISSED_CHILD 0x4
528
529 extern void _PR_IntsOn(_PRCPU *cpu);
530
531 NSPR_API(void) _PR_WakeupCPU(void);
532 NSPR_API(void) _PR_PauseCPU(void);
533
534 /************************************************************************/
535
536 #define _PR_LOCK_LOCK(_lock) \
537 _PR_MD_LOCK(&(_lock)->ilock);
538 #define _PR_LOCK_UNLOCK(_lock) \
539 _PR_MD_UNLOCK(&(_lock)->ilock);
540
541 extern void _PR_UnblockLockWaiter(PRLock *lock);
542 extern PRStatus _PR_InitLock(PRLock *lock);
543 extern void _PR_FreeLock(PRLock *lock);
544
545 #define _PR_LOCK_PTR(_qp) \
546 ((PRLock*) ((char*) (_qp) - offsetof(PRLock,links)))
547
548 /************************************************************************/
549
550 #define _PR_CVAR_LOCK(_cvar) \
551 _PR_MD_LOCK(&(_cvar)->ilock);
552 #define _PR_CVAR_UNLOCK(_cvar) \
553 _PR_MD_UNLOCK(&(_cvar)->ilock);
554
555 extern PRStatus _PR_InitCondVar(PRCondVar *cvar, PRLock *lock);
556 extern void _PR_FreeCondVar(PRCondVar *cvar);
557 extern PRStatus _PR_WaitCondVar(
558 PRThread *thread, PRCondVar *cvar, PRLock *lock, PRIntervalTime timeout);
559 extern void _PR_NotifyCondVar(PRCondVar *cvar, PRThread *me);
560 extern PRUint32 _PR_CondVarToString(PRCondVar *cvar, char *buf, PRUint32 buflen);
561
562 NSPR_API(void) _PR_Notify(PRMonitor *mon, PRBool all, PRBool sticky);
563
564 /* PRThread.flags */
565 #define _PR_SYSTEM 0x01
566 #define _PR_INTERRUPT 0x02
567 #define _PR_ATTACHED 0x04 /* created via PR_AttachThread */
568 #define _PR_PRIMORDIAL 0x08 /* the thread that called PR_Init */
569 #define _PR_ON_SLEEPQ 0x10 /* thread is on the sleepQ */
570 #define _PR_ON_PAUSEQ 0x20 /* thread is on the pauseQ */
571 #define _PR_SUSPENDING 0x40 /* thread wants to suspend */
572 #define _PR_GLOBAL_SCOPE 0x80 /* thread is global scope */
573 #define _PR_IDLE_THREAD 0x200 /* this is an idle thread */
574 #define _PR_GCABLE_THREAD 0x400 /* this is a collectable thread */
575 #define _PR_BOUND_THREAD 0x800 /* a bound thread */
576 #define _PR_INTERRUPT_BLOCKED 0x1000 /* interrupts blocked */
577
578 /* PRThread.state */
579 #define _PR_UNBORN 0
580 #define _PR_RUNNABLE 1
581 #define _PR_RUNNING 2
582 #define _PR_LOCK_WAIT 3
583 #define _PR_COND_WAIT 4
584 #define _PR_JOIN_WAIT 5
585 #define _PR_IO_WAIT 6
586 #define _PR_SUSPENDED 7
587 #define _PR_DEAD_STATE 8 /* for debugging */
588
589 /* PRThreadStack.flags */
590 #define _PR_STACK_VM 0x1 /* using vm instead of malloc */
591 #define _PR_STACK_MAPPED 0x2 /* vm is mapped */
592 #define _PR_STACK_PRIMORDIAL 0x4 /* stack for primordial thread */
593
594 /*
595 ** If the default stcksize from the client is zero, we need to pick a machine
596 ** dependent value. This is only for standard user threads. For custom threads,
597 ** 0 has a special meaning.
598 ** Adjust stackSize. Round up to a page boundary.
599 */
600
601 #ifndef _MD_MINIMUM_STACK_SIZE
602 #define _MD_MINIMUM_STACK_SIZE 0
603 #endif
604
605 #if (!defined(HAVE_CUSTOM_USER_THREADS))
606 #define _PR_ADJUST_STACKSIZE(stackSize) \
607 PR_BEGIN_MACRO \
608 if (stackSize == 0) \
609 stackSize = _MD_DEFAULT_STACK_SIZE; \
610 if (stackSize < _MD_MINIMUM_STACK_SIZE) \
611 stackSize = _MD_MINIMUM_STACK_SIZE; \
612 stackSize = (stackSize + (1 << _pr_pageShift) - 1) >> _pr_pageShift; \
613 stackSize <<= _pr_pageShift; \
614 PR_END_MACRO
615 #else
616 #define _PR_ADJUST_STACKSIZE(stackSize)
617 #endif
618
619 #define _PR_IS_GCABLE_THREAD(thr) ((thr)->flags & _PR_GCABLE_THREAD)
620
621 #define _PR_PENDING_INTERRUPT(thr) \
622 (!((thr)->flags & _PR_INTERRUPT_BLOCKED) && ((thr)->flags & _PR_INTERRUPT))
623 #define _PR_THREAD_BLOCK_INTERRUPT(thr) \
624 (thr->flags |= _PR_INTERRUPT_BLOCKED)
625 #define _PR_THREAD_UNBLOCK_INTERRUPT(thr) \
626 (thr->flags &= ~_PR_INTERRUPT_BLOCKED)
627
628 #define _PR_THREAD_PTR(_qp) \
629 ((PRThread*) ((char*) (_qp) - offsetof(PRThread,links)))
630
631 #define _PR_ACTIVE_THREAD_PTR(_qp) \
632 ((PRThread*) ((char*) (_qp) - offsetof(PRThread,active)))
633
634 #define _PR_THREAD_CONDQ_PTR(_qp) \
635 ((PRThread*) ((char*) (_qp) - offsetof(PRThread,waitQLinks)))
636
637 #define _PR_THREAD_MD_TO_PTR(_md) \
638 ((PRThread*) ((char*) (_md) - offsetof(PRThread,md)))
639
640 #define _PR_THREAD_STACK_TO_PTR(_stack) \
641 ((PRThread*) (_stack->thr))
642
643 extern PRCList _pr_active_local_threadQ;
644 extern PRCList _pr_active_global_threadQ;
645 extern PRCList _pr_cpuQ;
646 extern _MDLock _pr_cpuLock;
647 extern PRInt32 _pr_md_idle_cpus;
648
649 #define _PR_ACTIVE_LOCAL_THREADQ() _pr_active_local_threadQ
650 #define _PR_ACTIVE_GLOBAL_THREADQ() _pr_active_global_threadQ
651 #define _PR_CPUQ() _pr_cpuQ
652 #define _PR_RUNQ(_cpu) ((_cpu)->queue->runQ)
653 #define _PR_RUNQREADYMASK(_cpu) ((_cpu)->queue->runQReadyMask)
654 #define _PR_SLEEPQ(_cpu) ((_cpu)->queue->sleepQ)
655 #define _PR_SLEEPQMAX(_cpu) ((_cpu)->queue->sleepQmax)
656 #define _PR_PAUSEQ(_cpu) ((_cpu)->queue->pauseQ)
657 #define _PR_SUSPENDQ(_cpu) ((_cpu)->queue->suspendQ)
658 #define _PR_WAITINGTOJOINQ(_cpu) ((_cpu)->queue->waitingToJoinQ)
659
660 extern PRUint32 _pr_recycleThreads; /* Flag for behavior on thread cleanup */
661 extern PRLock *_pr_deadQLock;
662 extern PRUint32 _pr_numNativeDead;
663 extern PRUint32 _pr_numUserDead;
664 extern PRCList _pr_deadNativeQ;
665 extern PRCList _pr_deadUserQ;
666 #define _PR_DEADNATIVEQ _pr_deadNativeQ
667 #define _PR_DEADUSERQ _pr_deadUserQ
668 #define _PR_DEADQ_LOCK PR_Lock(_pr_deadQLock);
669 #define _PR_DEADQ_UNLOCK PR_Unlock(_pr_deadQLock);
670 #define _PR_INC_DEADNATIVE (_pr_numNativeDead++)
671 #define _PR_DEC_DEADNATIVE (_pr_numNativeDead--)
672 #define _PR_NUM_DEADNATIVE (_pr_numNativeDead)
673 #define _PR_INC_DEADUSER (_pr_numUserDead++)
674 #define _PR_DEC_DEADUSER (_pr_numUserDead--)
675 #define _PR_NUM_DEADUSER (_pr_numUserDead)
676
677 extern PRUint32 _pr_utid;
678
679 extern struct _PRCPU *_pr_primordialCPU;
680
681 extern PRLock *_pr_activeLock; /* lock for userActive and systemActive */
682 extern PRInt32 _pr_userActive; /* number of active user threads */
683 extern PRInt32 _pr_systemActive; /* number of active system threads */
684 extern PRInt32 _pr_primordialExitCount; /* number of user threads left
685 * before the primordial thread
686 * can exit. */
687 extern PRCondVar *_pr_primordialExitCVar; /* the condition variable for
688 * notifying the primordial thread
689 * when all other user threads
690 * have terminated. */
691
692 extern PRUintn _pr_maxPTDs;
693
694 extern PRLock *_pr_terminationCVLock;
695
696 /*************************************************************************
697 * Internal routines either called by PR itself or from machine-dependent *
698 * code. *
699 *************************************************************************/
700
701 extern void _PR_ClockInterrupt(void);
702
703 extern void _PR_Schedule(void);
704 extern void _PR_SetThreadPriority(
705 PRThread* thread, PRThreadPriority priority);
706
707 /***********************************************************************
708 ** FUNCTION: _PR_NewSegment()
709 ** DESCRIPTION:
710 ** Allocate a memory segment. The "size" value is rounded up to the
711 ** native system page size and a page aligned portion of memory is
712 ** returned. This memory is not part of the malloc heap. If "vaddr" is
713 ** not NULL then PR tries to allocate the segment at the desired virtual
714 ** address.
715 ** INPUTS: size: size of the desired memory segment
716 ** vaddr: address at which the newly aquired segment is to be
717 ** mapped into memory.
718 ** OUTPUTS: a memory segment is allocated, a PRSegment is allocated
719 ** RETURN: pointer to PRSegment
720 ***********************************************************************/
721 extern PRSegment* _PR_NewSegment(PRUint32 size, void *vaddr);
722
723 /***********************************************************************
724 ** FUNCTION: _PR_DestroySegment()
725 ** DESCRIPTION:
726 ** The memory segment and the PRSegment are freed
727 ** INPUTS: seg: pointer to PRSegment to be freed
728 ** OUTPUTS: the the PRSegment and its associated memory segment are freed
729 ** RETURN: void
730 ***********************************************************************/
731 extern void _PR_DestroySegment(PRSegment *seg);
732
733 extern PRThreadStack * _PR_NewStack(PRUint32 stackSize);
734 extern void _PR_FreeStack(PRThreadStack *stack);
735 extern PRBool _PR_NotifyThread (PRThread *thread, PRThread *me);
736 extern void _PR_NotifyLockedThread (PRThread *thread);
737
738 NSPR_API(void) _PR_AddSleepQ(PRThread *thread, PRIntervalTime timeout);
739 NSPR_API(void) _PR_DelSleepQ(PRThread *thread, PRBool propogate_time);
740
741 extern void _PR_AddThreadToRunQ(PRThread *me, PRThread *thread);
742
743 NSPR_API(PRThread*) _PR_CreateThread(PRThreadType type,
744 void (*start)(void *arg),
745 void *arg,
746 PRThreadPriority priority,
747 PRThreadScope scope,
748 PRThreadState state,
749 PRUint32 stackSize,
750 PRUint32 flags);
751
752 extern void _PR_NativeDestroyThread(PRThread *thread);
753 extern void _PR_UserDestroyThread(PRThread *thread);
754
755 extern PRThread* _PRI_AttachThread(
756 PRThreadType type, PRThreadPriority priority,
757 PRThreadStack *stack, PRUint32 flags);
758
759 extern void _PRI_DetachThread(void);
760
761
762 #define _PR_IO_PENDING(_thread) ((_thread)->io_pending)
763
764 NSPR_API(void) _PR_MD_INIT_CPUS();
765 #define _PR_MD_INIT_CPUS _MD_INIT_CPUS
766
767 NSPR_API(void) _PR_MD_WAKEUP_CPUS();
768 #define _PR_MD_WAKEUP_CPUS _MD_WAKEUP_CPUS
769
770 /* Interrupts related */
771
772 NSPR_API(void) _PR_MD_START_INTERRUPTS(void);
773 #define _PR_MD_START_INTERRUPTS _MD_START_INTERRUPTS
774
775 NSPR_API(void) _PR_MD_STOP_INTERRUPTS(void);
776 #define _PR_MD_STOP_INTERRUPTS _MD_STOP_INTERRUPTS
777
778 NSPR_API(void) _PR_MD_ENABLE_CLOCK_INTERRUPTS(void);
779 #define _PR_MD_ENABLE_CLOCK_INTERRUPTS _MD_ENABLE_CLOCK_INTERRUPTS
780
781 NSPR_API(void) _PR_MD_DISABLE_CLOCK_INTERRUPTS(void);
782 #define _PR_MD_DISABLE_CLOCK_INTERRUPTS _MD_DISABLE_CLOCK_INTERRUPTS
783
784 NSPR_API(void) _PR_MD_BLOCK_CLOCK_INTERRUPTS(void);
785 #define _PR_MD_BLOCK_CLOCK_INTERRUPTS _MD_BLOCK_CLOCK_INTERRUPTS
786
787 NSPR_API(void) _PR_MD_UNBLOCK_CLOCK_INTERRUPTS(void);
788 #define _PR_MD_UNBLOCK_CLOCK_INTERRUPTS _MD_UNBLOCK_CLOCK_INTERRUPTS
789
790 /* The _PR_MD_WAIT_LOCK and _PR_MD_WAKEUP_WAITER functions put to sleep and
791 * awaken a thread which is waiting on a lock or cvar.
792 */
793 extern PRStatus _PR_MD_WAIT(PRThread *, PRIntervalTime timeout);
794 #define _PR_MD_WAIT _MD_WAIT
795
796 extern PRStatus _PR_MD_WAKEUP_WAITER(PRThread *);
797 #define _PR_MD_WAKEUP_WAITER _MD_WAKEUP_WAITER
798
799 #ifndef _PR_LOCAL_THREADS_ONLY /* not if only local threads supported */
800 NSPR_API(void) _PR_MD_CLOCK_INTERRUPT(void);
801 #define _PR_MD_CLOCK_INTERRUPT _MD_CLOCK_INTERRUPT
802 #endif
803
804 /* Stack debugging */
805 NSPR_API(void) _PR_MD_INIT_STACK(PRThreadStack *ts, PRIntn redzone);
806 #define _PR_MD_INIT_STACK _MD_INIT_STACK
807
808 NSPR_API(void) _PR_MD_CLEAR_STACK(PRThreadStack* ts);
809 #define _PR_MD_CLEAR_STACK _MD_CLEAR_STACK
810
811 /* CPU related */
812 NSPR_API(PRInt32) _PR_MD_GET_INTSOFF(void);
813 #define _PR_MD_GET_INTSOFF _MD_GET_INTSOFF
814
815 NSPR_API(void) _PR_MD_SET_INTSOFF(PRInt32 _val);
816 #define _PR_MD_SET_INTSOFF _MD_SET_INTSOFF
817
818 NSPR_API(_PRCPU*) _PR_MD_CURRENT_CPU(void);
819 #define _PR_MD_CURRENT_CPU _MD_CURRENT_CPU
820
821 NSPR_API(void) _PR_MD_SET_CURRENT_CPU(_PRCPU *cpu);
822 #define _PR_MD_SET_CURRENT_CPU _MD_SET_CURRENT_CPU
823
824 NSPR_API(void) _PR_MD_INIT_RUNNING_CPU(_PRCPU *cpu);
825 #define _PR_MD_INIT_RUNNING_CPU _MD_INIT_RUNNING_CPU
826
827 /*
828 * Returns the number of threads awoken or 0 if a timeout occurred;
829 */
830 extern PRInt32 _PR_MD_PAUSE_CPU(PRIntervalTime timeout);
831 #define _PR_MD_PAUSE_CPU _MD_PAUSE_CPU
832
833 extern void _PR_MD_CLEANUP_BEFORE_EXIT(void);
834 #define _PR_MD_CLEANUP_BEFORE_EXIT _MD_CLEANUP_BEFORE_EXIT
835
836 extern void _PR_MD_EXIT(PRIntn status);
837 #define _PR_MD_EXIT _MD_EXIT
838
839 /* Locks related */
840
841 NSPR_API(void) _PR_MD_INIT_LOCKS(void);
842 #define _PR_MD_INIT_LOCKS _MD_INIT_LOCKS
843
844 NSPR_API(PRStatus) _PR_MD_NEW_LOCK(_MDLock *md);
845 #define _PR_MD_NEW_LOCK _MD_NEW_LOCK
846
847 NSPR_API(void) _PR_MD_FREE_LOCK(_MDLock *md);
848 #define _PR_MD_FREE_LOCK _MD_FREE_LOCK
849
850 NSPR_API(void) _PR_MD_LOCK(_MDLock *md);
851 #define _PR_MD_LOCK _MD_LOCK
852
853 /* Return 0 on success, a nonzero value on failure. */
854 NSPR_API(PRIntn) _PR_MD_TEST_AND_LOCK(_MDLock *md);
855 #define _PR_MD_TEST_AND_LOCK _MD_TEST_AND_LOCK
856
857 NSPR_API(void) _PR_MD_UNLOCK(_MDLock *md);
858 #define _PR_MD_UNLOCK _MD_UNLOCK
859
860 NSPR_API(void) _PR_MD_IOQ_LOCK(void);
861 #define _PR_MD_IOQ_LOCK _MD_IOQ_LOCK
862
863 NSPR_API(void) _PR_MD_IOQ_UNLOCK(void);
864 #define _PR_MD_IOQ_UNLOCK _MD_IOQ_UNLOCK
865
866 #ifndef _PR_LOCAL_THREADS_ONLY /* not if only local threads supported */
867 /* Semaphore related -- only for native threads */
868 #ifdef HAVE_CVAR_BUILT_ON_SEM
869 NSPR_API(void) _PR_MD_NEW_SEM(_MDSemaphore *md, PRUintn value);
870 #define _PR_MD_NEW_SEM _MD_NEW_SEM
871
872 NSPR_API(void) _PR_MD_DESTROY_SEM(_MDSemaphore *md);
873 #define _PR_MD_DESTROY_SEM _MD_DESTROY_SEM
874
875 NSPR_API(PRStatus) _PR_MD_TIMED_WAIT_SEM(
876 _MDSemaphore *md, PRIntervalTime timeout);
877 #define _PR_MD_TIMED_WAIT_SEM _MD_TIMED_WAIT_SEM
878
879 NSPR_API(PRStatus) _PR_MD_WAIT_SEM(_MDSemaphore *md);
880 #define _PR_MD_WAIT_SEM _MD_WAIT_SEM
881
882 NSPR_API(void) _PR_MD_POST_SEM(_MDSemaphore *md);
883 #define _PR_MD_POST_SEM _MD_POST_SEM
884 #endif /* HAVE_CVAR_BUILT_ON_SEM */
885
886 #endif
887
888 /* Condition Variables related -- only for native threads */
889
890 #ifndef _PR_LOCAL_THREADS_ONLY /* not if only local threads supported */
891 NSPR_API(PRInt32) _PR_MD_NEW_CV(_MDCVar *md);
892 #define _PR_MD_NEW_CV _MD_NEW_CV
893
894 NSPR_API(void) _PR_MD_FREE_CV(_MDCVar *md);
895 #define _PR_MD_FREE_CV _MD_FREE_CV
896
897 NSPR_API(void) _PR_MD_WAIT_CV(
898 _MDCVar *mdCVar,_MDLock *mdLock,PRIntervalTime timeout);
899 #define _PR_MD_WAIT_CV _MD_WAIT_CV
900
901 NSPR_API(void) _PR_MD_NOTIFY_CV(_MDCVar *md, _MDLock *lock);
902 #define _PR_MD_NOTIFY_CV _MD_NOTIFY_CV
903
904 NSPR_API(void) _PR_MD_NOTIFYALL_CV(_MDCVar *md, _MDLock *lock);
905 #define _PR_MD_NOTIFYALL_CV _MD_NOTIFYALL_CV
906 #endif /* _PR_LOCAL_THREADS_ONLY */
907
908 /* Threads related */
909 NSPR_API(PRThread*) _PR_MD_CURRENT_THREAD(void);
910 #define _PR_MD_CURRENT_THREAD _MD_CURRENT_THREAD
911
912 NSPR_API(PRThread*) _PR_MD_GET_ATTACHED_THREAD(void);
913 #define _PR_MD_GET_ATTACHED_THREAD _MD_GET_ATTACHED_THREAD
914
915 NSPR_API(PRThread*) _PR_MD_LAST_THREAD(void);
916 #define _PR_MD_LAST_THREAD _MD_LAST_THREAD
917
918 NSPR_API(void) _PR_MD_SET_CURRENT_THREAD(PRThread *thread);
919 #define _PR_MD_SET_CURRENT_THREAD _MD_SET_CURRENT_THREAD
920
921 NSPR_API(void) _PR_MD_SET_LAST_THREAD(PRThread *thread);
922 #define _PR_MD_SET_LAST_THREAD _MD_SET_LAST_THREAD
923
924 extern PRStatus _PR_MD_INIT_THREAD(PRThread *thread);
925 #define _PR_MD_INIT_THREAD _MD_INIT_THREAD
926
927 extern void _PR_MD_EXIT_THREAD(PRThread *thread);
928 #define _PR_MD_EXIT_THREAD _MD_EXIT_THREAD
929
930 #ifndef _PR_LOCAL_THREADS_ONLY /* not if only local threads supported */
931
932 NSPR_API(PRStatus) _PR_MD_INIT_ATTACHED_THREAD(PRThread *thread);
933 #define _PR_MD_INIT_ATTACHED_THREAD _MD_INIT_ATTACHED_THREAD
934
935 extern void _PR_MD_SUSPEND_THREAD(PRThread *thread);
936 #define _PR_MD_SUSPEND_THREAD _MD_SUSPEND_THREAD
937
938 extern void _PR_MD_RESUME_THREAD(PRThread *thread);
939 #define _PR_MD_RESUME_THREAD _MD_RESUME_THREAD
940
941 extern void _PR_MD_SUSPEND_CPU(_PRCPU *cpu);
942 #define _PR_MD_SUSPEND_CPU _MD_SUSPEND_CPU
943
944 extern void _PR_MD_RESUME_CPU(_PRCPU *cpu);
945 #define _PR_MD_RESUME_CPU _MD_RESUME_CPU
946
947 extern void _PR_MD_BEGIN_SUSPEND_ALL(void);
948 #define _PR_MD_BEGIN_SUSPEND_ALL _MD_BEGIN_SUSPEND_ALL
949
950 extern void _PR_MD_END_SUSPEND_ALL(void);
951 #define _PR_MD_END_SUSPEND_ALL _MD_END_SUSPEND_ALL
952
953 extern void _PR_MD_BEGIN_RESUME_ALL(void);
954 #define _PR_MD_BEGIN_RESUME_ALL _MD_BEGIN_RESUME_ALL
955
956 extern void _PR_MD_END_RESUME_ALL(void);
957 #define _PR_MD_END_RESUME_ALL _MD_END_RESUME_ALL
958
959 #if defined(IRIX)
960 NSPR_API(void) _PR_IRIX_CHILD_PROCESS(void);
961 #endif /* IRIX */
962
963 #endif /* !_PR_LOCAL_THREADS_ONLY */
964
965 extern void _PR_MD_CLEAN_THREAD(PRThread *thread);
966 #define _PR_MD_CLEAN_THREAD _MD_CLEAN_THREAD
967
968 #ifdef HAVE_CUSTOM_USER_THREADS
969 extern void _PR_MD_CREATE_PRIMORDIAL_USER_THREAD(PRThread *);
970 #define _PR_MD_CREATE_PRIMORDIAL_USER_THREAD _MD_CREATE_PRIMORDIAL_USER_THREAD
971
972 extern PRThread* _PR_MD_CREATE_USER_THREAD(
973 PRUint32 stacksize,
974 void (*start)(void *),
975 void *arg);
976 #define _PR_MD_CREATE_USER_THREAD _MD_CREATE_USER_THREAD
977 #endif
978
979 extern PRStatus _PR_MD_CREATE_THREAD(
980 PRThread *thread,
981 void (*start) (void *),
982 PRThreadPriority priority,
983 PRThreadScope scope,
984 PRThreadState state,
985 PRUint32 stackSize);
986 #define _PR_MD_CREATE_THREAD _MD_CREATE_THREAD
987
988 extern void _PR_MD_JOIN_THREAD(_MDThread *md);
989 #define _PR_MD_JOIN_THREAD _MD_JOIN_THREAD
990
991 extern void _PR_MD_END_THREAD(void);
992 #define _PR_MD_END_THREAD _MD_END_THREAD
993
994 extern void _PR_MD_YIELD(void);
995 #define _PR_MD_YIELD _MD_YIELD
996
997 extern void _PR_MD_SET_PRIORITY(_MDThread *md, PRThreadPriority newPri);
998 #define _PR_MD_SET_PRIORITY _MD_SET_PRIORITY
999
1000 extern void _PR_MD_SET_CURRENT_THREAD_NAME(const char *name);
1001 #define _PR_MD_SET_CURRENT_THREAD_NAME _MD_SET_CURRENT_THREAD_NAME
1002
1003 NSPR_API(void) _PR_MD_SUSPENDALL(void);
1004 #define _PR_MD_SUSPENDALL _MD_SUSPENDALL
1005
1006 NSPR_API(void) _PR_MD_RESUMEALL(void);
1007 #define _PR_MD_RESUMEALL _MD_RESUMEALL
1008
1009 extern void _PR_MD_INIT_CONTEXT(
1010 PRThread *thread, char *top, void (*start) (void), PRBool *status);
1011 #define _PR_MD_INIT_CONTEXT _MD_INIT_CONTEXT
1012
1013 extern void _PR_MD_SWITCH_CONTEXT(PRThread *thread);
1014 #define _PR_MD_SWITCH_CONTEXT _MD_SWITCH_CONTEXT
1015
1016 extern void _PR_MD_RESTORE_CONTEXT(PRThread *thread);
1017 #define _PR_MD_RESTORE_CONTEXT _MD_RESTORE_CONTEXT
1018
1019 /* Segment related */
1020 extern void _PR_MD_INIT_SEGS(void);
1021 #define _PR_MD_INIT_SEGS _MD_INIT_SEGS
1022
1023 extern PRStatus _PR_MD_ALLOC_SEGMENT(PRSegment *seg, PRUint32 size, void *vaddr);
1024 #define _PR_MD_ALLOC_SEGMENT _MD_ALLOC_SEGMENT
1025
1026 extern void _PR_MD_FREE_SEGMENT(PRSegment *seg);
1027 #define _PR_MD_FREE_SEGMENT _MD_FREE_SEGMENT
1028
1029 /* Directory enumeration related */
1030 extern PRStatus _PR_MD_OPEN_DIR(_MDDir *md,const char *name);
1031 #define _PR_MD_OPEN_DIR _MD_OPEN_DIR
1032
1033 extern char * _PR_MD_READ_DIR(_MDDir *md, PRIntn flags);
1034 #define _PR_MD_READ_DIR _MD_READ_DIR
1035
1036 extern PRInt32 _PR_MD_CLOSE_DIR(_MDDir *md);
1037 #define _PR_MD_CLOSE_DIR _MD_CLOSE_DIR
1038
1039 /* Named semaphores related */
1040 extern PRSem * _PR_MD_OPEN_SEMAPHORE(
1041 const char *osname, PRIntn flags, PRIntn mode, PRUintn value);
1042 #define _PR_MD_OPEN_SEMAPHORE _MD_OPEN_SEMAPHORE
1043
1044 extern PRStatus _PR_MD_WAIT_SEMAPHORE(PRSem *sem);
1045 #define _PR_MD_WAIT_SEMAPHORE _MD_WAIT_SEMAPHORE
1046
1047 extern PRStatus _PR_MD_POST_SEMAPHORE(PRSem *sem);
1048 #define _PR_MD_POST_SEMAPHORE _MD_POST_SEMAPHORE
1049
1050 extern PRStatus _PR_MD_CLOSE_SEMAPHORE(PRSem *sem);
1051 #define _PR_MD_CLOSE_SEMAPHORE _MD_CLOSE_SEMAPHORE
1052
1053 extern PRStatus _PR_MD_DELETE_SEMAPHORE(const char *osname);
1054 #define _PR_MD_DELETE_SEMAPHORE _MD_DELETE_SEMAPHORE
1055
1056 /* I/O related */
1057 extern void _PR_MD_INIT_FILEDESC(PRFileDesc *fd);
1058 #define _PR_MD_INIT_FILEDESC _MD_INIT_FILEDESC
1059
1060 extern void _PR_MD_MAKE_NONBLOCK(PRFileDesc *fd);
1061 #define _PR_MD_MAKE_NONBLOCK _MD_MAKE_NONBLOCK
1062
1063 /* File I/O related */
1064 extern PROsfd _PR_MD_OPEN(const char *name, PRIntn osflags, PRIntn mode);
1065 #define _PR_MD_OPEN _MD_OPEN
1066
1067 extern PROsfd _PR_MD_OPEN_FILE(const char *name, PRIntn osflags, PRIntn mode);
1068 #define _PR_MD_OPEN_FILE _MD_OPEN_FILE
1069
1070 extern PRInt32 _PR_MD_CLOSE_FILE(PROsfd osfd);
1071 #define _PR_MD_CLOSE_FILE _MD_CLOSE_FILE
1072
1073 extern PRInt32 _PR_MD_READ(PRFileDesc *fd, void *buf, PRInt32 amount);
1074 #define _PR_MD_READ _MD_READ
1075
1076 extern PRInt32 _PR_MD_WRITE(PRFileDesc *fd, const void *buf, PRInt32 amount);
1077 #define _PR_MD_WRITE _MD_WRITE
1078
1079 extern PRInt32 _PR_MD_WRITEV(
1080 PRFileDesc *fd, const struct PRIOVec *iov,
1081 PRInt32 iov_size, PRIntervalTime timeout);
1082 #define _PR_MD_WRITEV _MD_WRITEV
1083
1084 extern PRInt32 _PR_MD_FSYNC(PRFileDesc *fd);
1085 #define _PR_MD_FSYNC _MD_FSYNC
1086
1087 extern PRInt32 _PR_MD_DELETE(const char *name);
1088 #define _PR_MD_DELETE _MD_DELETE
1089
1090 extern PRInt32 _PR_MD_RENAME(const char *from, const char *to);
1091 #define _PR_MD_RENAME _MD_RENAME
1092
1093 extern PRInt32 _PR_MD_ACCESS(const char *name, PRAccessHow how);
1094 #define _PR_MD_ACCESS _MD_ACCESS
1095
1096 extern PRInt32 _PR_MD_STAT(const char *name, struct stat *buf);
1097 #define _PR_MD_STAT _MD_STAT
1098
1099 extern PRInt32 _PR_MD_MKDIR(const char *name, PRIntn mode);
1100 #define _PR_MD_MKDIR _MD_MKDIR
1101
1102 extern PRInt32 _PR_MD_MAKE_DIR(const char *name, PRIntn mode);
1103 #define _PR_MD_MAKE_DIR _MD_MAKE_DIR
1104
1105 extern PRInt32 _PR_MD_RMDIR(const char *name);
1106 #define _PR_MD_RMDIR _MD_RMDIR
1107
1108 #ifdef MOZ_UNICODE
1109 /* UTF16 File I/O related */
1110 extern PRStatus _PR_MD_OPEN_DIR_UTF16(_MDDirUTF16 *md, const PRUnichar *name);
1111 #define _PR_MD_OPEN_DIR_UTF16 _MD_OPEN_DIR_UTF16
1112
1113 extern PROsfd _PR_MD_OPEN_FILE_UTF16(const PRUnichar *name, PRIntn osflags, PRIntn mode);
1114 #define _PR_MD_OPEN_FILE_UTF16 _MD_OPEN_FILE_UTF16
1115
1116 extern PRUnichar * _PR_MD_READ_DIR_UTF16(_MDDirUTF16 *md, PRIntn flags);
1117 #define _PR_MD_READ_DIR_UTF16 _MD_READ_DIR_UTF16
1118
1119 extern PRInt32 _PR_MD_CLOSE_DIR_UTF16(_MDDirUTF16 *md);
1120 #define _PR_MD_CLOSE_DIR_UTF16 _MD_CLOSE_DIR_UTF16
1121
1122 extern PRInt32 _PR_MD_GETFILEINFO64_UTF16(const PRUnichar *fn, PRFileInfo64 *info);
1123 #define _PR_MD_GETFILEINFO64_UTF16 _MD_GETFILEINFO64_UTF16
1124 #endif /* MOZ_UNICODE */
1125
1126 /* Socket I/O related */
1127 extern void _PR_MD_INIT_IO(void);
1128 #define _PR_MD_INIT_IO _MD_INIT_IO
1129
1130 extern PRInt32 _PR_MD_CLOSE_SOCKET(PROsfd osfd);
1131 #define _PR_MD_CLOSE_SOCKET _MD_CLOSE_SOCKET
1132
1133 extern PRInt32 _PR_MD_CONNECT(
1134 PRFileDesc *fd, const PRNetAddr *addr,
1135 PRUint32 addrlen, PRIntervalTime timeout);
1136 #define _PR_MD_CONNECT _MD_CONNECT
1137
1138 extern PROsfd _PR_MD_ACCEPT(
1139 PRFileDesc *fd, PRNetAddr *addr,
1140 PRUint32 *addrlen, PRIntervalTime timeout);
1141 #define _PR_MD_ACCEPT _MD_ACCEPT
1142
1143 extern PRInt32 _PR_MD_BIND(PRFileDesc *fd, const PRNetAddr *addr, PRUint32 addrlen);
1144 #define _PR_MD_BIND _MD_BIND
1145
1146 extern PRInt32 _PR_MD_LISTEN(PRFileDesc *fd, PRIntn backlog);
1147 #define _PR_MD_LISTEN _MD_LISTEN
1148
1149 extern PRInt32 _PR_MD_SHUTDOWN(PRFileDesc *fd, PRIntn how);
1150 #define _PR_MD_SHUTDOWN _MD_SHUTDOWN
1151
1152 extern PRInt32 _PR_MD_RECV(PRFileDesc *fd, void *buf, PRInt32 amount,
1153 PRIntn flags, PRIntervalTime timeout);
1154 #define _PR_MD_RECV _MD_RECV
1155
1156 extern PRInt32 _PR_MD_SEND(
1157 PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags,
1158 PRIntervalTime timeout);
1159 #define _PR_MD_SEND _MD_SEND
1160
1161 extern PRInt32 _PR_MD_ACCEPT_READ(PRFileDesc *sd, PROsfd *newSock,
1162 PRNetAddr **raddr, void *buf, PRInt32 amount,
1163 PRIntervalTime timeout);
1164 #define _PR_MD_ACCEPT_READ _MD_ACCEPT_READ
1165
1166 #ifdef WIN32
1167 extern PROsfd _PR_MD_FAST_ACCEPT(PRFileDesc *fd, PRNetAddr *addr,
1168 PRUint32 *addrlen, PRIntervalTime timeout,
1169 PRBool fast,
1170 _PR_AcceptTimeoutCallback callback,
1171 void *callbackArg);
1172
1173 extern PRInt32 _PR_MD_FAST_ACCEPT_READ(PRFileDesc *sd, PROsfd *newSock,
1174 PRNetAddr **raddr, void *buf, PRInt32 amount,
1175 PRIntervalTime timeout, PRBool fast,
1176 _PR_AcceptTimeoutCallback callback,
1177 void *callbackArg);
1178
1179 extern void _PR_MD_UPDATE_ACCEPT_CONTEXT(PROsfd s, PROsfd ls);
1180 #define _PR_MD_UPDATE_ACCEPT_CONTEXT _MD_UPDATE_ACCEPT_CONTEXT
1181 /*
1182 * The NSPR epoch (00:00:00 1 Jan 1970 UTC) in FILETIME.
1183 * We store the value in a PRTime variable for convenience.
1184 * This constant is used by _PR_FileTimeToPRTime().
1185 * This is defined in ntmisc.c
1186 */
1187 extern const PRTime _pr_filetime_offset;
1188 #endif /* WIN32 */
1189
1190 extern PRInt32 _PR_MD_SENDFILE(
1191 PRFileDesc *sock, PRSendFileData *sfd,
1192 PRInt32 flags, PRIntervalTime timeout);
1193 #define _PR_MD_SENDFILE _MD_SENDFILE
1194
1195 extern PRStatus _PR_MD_GETSOCKNAME(
1196 PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen);
1197 #define _PR_MD_GETSOCKNAME _MD_GETSOCKNAME
1198
1199 extern PRStatus _PR_MD_GETPEERNAME(
1200 PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen);
1201 #define _PR_MD_GETPEERNAME _MD_GETPEERNAME
1202
1203 extern PRStatus _PR_MD_GETSOCKOPT(
1204 PRFileDesc *fd, PRInt32 level, PRInt32 optname, char* optval, PRInt32* optlen);
1205 #define _PR_MD_GETSOCKOPT _MD_GETSOCKOPT
1206
1207 extern PRStatus _PR_MD_SETSOCKOPT(
1208 PRFileDesc *fd, PRInt32 level, PRInt32 optname,
1209 const char* optval, PRInt32 optlen);
1210 #define _PR_MD_SETSOCKOPT _MD_SETSOCKOPT
1211
1212 extern PRStatus PR_CALLBACK _PR_SocketGetSocketOption(
1213 PRFileDesc *fd, PRSocketOptionData *data);
1214
1215 extern PRStatus PR_CALLBACK _PR_SocketSetSocketOption(
1216 PRFileDesc *fd, const PRSocketOptionData *data);
1217
1218 extern PRInt32 _PR_MD_RECVFROM(
1219 PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags,
1220 PRNetAddr *addr, PRUint32 *addrlen, PRIntervalTime timeout);
1221 #define _PR_MD_RECVFROM _MD_RECVFROM
1222
1223 extern PRInt32 _PR_MD_SENDTO(
1224 PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags,
1225 const PRNetAddr *addr, PRUint32 addrlen, PRIntervalTime timeout);
1226 #define _PR_MD_SENDTO _MD_SENDTO
1227
1228 extern PRInt32 _PR_MD_SOCKETPAIR(int af, int type, int flags, PROsfd *osfd);
1229 #define _PR_MD_SOCKETPAIR _MD_SOCKETPAIR
1230
1231 extern PROsfd _PR_MD_SOCKET(int af, int type, int flags);
1232 #define _PR_MD_SOCKET _MD_SOCKET
1233
1234 extern PRInt32 _PR_MD_SOCKETAVAILABLE(PRFileDesc *fd);
1235 #define _PR_MD_SOCKETAVAILABLE _MD_SOCKETAVAILABLE
1236
1237 extern PRInt32 _PR_MD_PIPEAVAILABLE(PRFileDesc *fd);
1238 #define _PR_MD_PIPEAVAILABLE _MD_PIPEAVAILABLE
1239
1240 extern PRInt32 _PR_MD_PR_POLL(PRPollDesc *pds, PRIntn npds,
1241 PRIntervalTime timeout);
1242 #define _PR_MD_PR_POLL _MD_PR_POLL
1243
1244 /*
1245 * Initialize fd->secret->inheritable for a newly created fd.
1246 * If 'imported' is false, the osfd (i.e., fd->secret->md.osfd)
1247 * was created by NSPR and hence has the OS-dependent default
1248 * inheritable attribute. If 'imported' is true, the osfd was
1249 * not created by NSPR and hence a system call is required to
1250 * query its inheritable attribute. Since we may never need to
1251 * know the inheritable attribute of a fd, a platform may choose
1252 * to initialize fd->secret->inheritable of an imported fd to
1253 * _PR_TRI_UNKNOWN and only pay the cost of the system call
1254 * (in _PR_MD_QUERY_FD_INHERITABLE) when necessary.
1255 */
1256 extern void _PR_MD_INIT_FD_INHERITABLE(PRFileDesc *fd, PRBool imported);
1257 #define _PR_MD_INIT_FD_INHERITABLE _MD_INIT_FD_INHERITABLE
1258
1259 extern PRStatus _PR_MD_SET_FD_INHERITABLE(PRFileDesc *fd, PRBool inheritable);
1260 #define _PR_MD_SET_FD_INHERITABLE _MD_SET_FD_INHERITABLE
1261
1262
1263 #define _PR_PROCESS_TIMEOUT_INTERRUPT_ERRORS(me) \
1264 if (_PR_PENDING_INTERRUPT(me)) { \
1265 me->flags &= ~_PR_INTERRUPT; \
1266 PR_SetError( PR_PENDING_INTERRUPT_ERROR, 0); \
1267 } else { \
1268 PR_SetError(PR_IO_TIMEOUT_ERROR, 0); \
1269 }
1270
1271 extern void *_PR_MD_GET_SP(PRThread *thread);
1272 #define _PR_MD_GET_SP _MD_GET_SP
1273
1274 #endif /* defined(_PR_PTHREADS) */
1275
1276 /************************************************************************/
1277 /*************************************************************************
1278 ** The remainder of the definitions are shared by pthreads and the classic
1279 ** NSPR code. These too may be conditionalized.
1280 *************************************************************************/
1281 /************************************************************************/
1282
1283 extern PROffset32 _PR_MD_LSEEK(PRFileDesc *fd, PROffset32 offset, PRSeekWhence whence);
1284 #define _PR_MD_LSEEK _MD_LSEEK
1285
1286 extern PROffset64 _PR_MD_LSEEK64(PRFileDesc *fd, PROffset64 offset, PRSeekWhence whence);
1287 #define _PR_MD_LSEEK64 _MD_LSEEK64
1288
1289 extern PRInt32 _PR_MD_GETFILEINFO(const char *fn, PRFileInfo *info);
1290 #define _PR_MD_GETFILEINFO _MD_GETFILEINFO
1291
1292 extern PRInt32 _PR_MD_GETFILEINFO64(const char *fn, PRFileInfo64 *info);
1293 #define _PR_MD_GETFILEINFO64 _MD_GETFILEINFO64
1294
1295 extern PRInt32 _PR_MD_GETOPENFILEINFO(const PRFileDesc *fd, PRFileInfo *info);
1296 #define _PR_MD_GETOPENFILEINFO _MD_GETOPENFILEINFO
1297
1298 extern PRInt32 _PR_MD_GETOPENFILEINFO64(const PRFileDesc *fd, PRFileInfo64 *info);
1299 #define _PR_MD_GETOPENFILEINFO64 _MD_GETOPENFILEINFO64
1300
1301
1302 /*****************************************************************************/
1303 /************************** File descriptor caching **************************/
1304 /*****************************************************************************/
1305 extern void _PR_InitFdCache(void);
1306 extern void _PR_CleanupFdCache(void);
1307 extern PRFileDesc *_PR_Getfd(void);
1308 extern void _PR_Putfd(PRFileDesc *fd);
1309
1310 /*
1311 * These flags are used by NSPR temporarily in the poll
1312 * descriptor's out_flags field to record the mapping of
1313 * NSPR's poll flags to the system poll flags.
1314 *
1315 * If _PR_POLL_READ_SYS_WRITE bit is set, it means the
1316 * PR_POLL_READ flag specified by the topmost layer is
1317 * mapped to the WRITE flag at the system layer. Similarly
1318 * for the other three _PR_POLL_XXX_SYS_YYY flags. It is
1319 * assumed that the PR_POLL_EXCEPT flag doesn't get mapped
1320 * to other flags.
1321 */
1322 #define _PR_POLL_READ_SYS_READ 0x1
1323 #define _PR_POLL_READ_SYS_WRITE 0x2
1324 #define _PR_POLL_WRITE_SYS_READ 0x4
1325 #define _PR_POLL_WRITE_SYS_WRITE 0x8
1326
1327 /*
1328 ** These methods are coerced into file descriptor methods table
1329 ** when the intended service is inappropriate for the particular
1330 ** type of file descriptor.
1331 */
1332 extern PRIntn _PR_InvalidInt(void);
1333 extern PRInt16 _PR_InvalidInt16(void);
1334 extern PRInt64 _PR_InvalidInt64(void);
1335 extern PRStatus _PR_InvalidStatus(void);
1336 extern PRFileDesc *_PR_InvalidDesc(void);
1337
1338 extern PRIOMethods _pr_faulty_methods;
1339
1340 /*
1341 ** The PR_NETADDR_SIZE macro can only be called on a PRNetAddr union
1342 ** whose 'family' field is set. It returns the size of the union
1343 ** member corresponding to the specified address family.
1344 */
1345
1346 extern PRUintn _PR_NetAddrSize(const PRNetAddr* addr);
1347
1348 #if defined(_PR_INET6)
1349
1350 #define PR_NETADDR_SIZE(_addr) _PR_NetAddrSize(_addr)
1351
1352 #elif defined(_PR_HAVE_MD_SOCKADDR_IN6)
1353
1354 /*
1355 ** Under the following conditions:
1356 ** 1. _PR_INET6 is not defined;
1357 ** 2. _PR_INET6_PROBE is defined;
1358 ** 3. struct sockaddr_in6 has nonstandard fields at the end
1359 ** (e.g., on Solaris 8),
1360 ** (_addr)->ipv6 is smaller than struct sockaddr_in6, and
1361 ** hence we can't pass sizeof((_addr)->ipv6) to socket
1362 ** functions such as connect because they would fail with
1363 ** EINVAL.
1364 **
1365 ** To pass the correct socket address length to socket
1366 ** functions, define the macro _PR_HAVE_MD_SOCKADDR_IN6 and
1367 ** define struct _md_sockaddr_in6 to be isomorphic to
1368 ** struct sockaddr_in6.
1369 */
1370
1371 #if defined(XP_UNIX) || defined(XP_OS2)
1372 #define PR_NETADDR_SIZE(_addr) \
1373 ((_addr)->raw.family == PR_AF_INET \
1374 ? sizeof((_addr)->inet) \
1375 : ((_addr)->raw.family == PR_AF_INET6 \
1376 ? sizeof(struct _md_sockaddr_in6) \
1377 : sizeof((_addr)->local)))
1378 #else
1379 #define PR_NETADDR_SIZE(_addr) \
1380 ((_addr)->raw.family == PR_AF_INET \
1381 ? sizeof((_addr)->inet) \
1382 : sizeof(struct _md_sockaddr_in6))
1383 #endif /* defined(XP_UNIX) */
1384
1385 #else
1386
1387 #if defined(XP_UNIX) || defined(XP_OS2)
1388 #define PR_NETADDR_SIZE(_addr) \
1389 ((_addr)->raw.family == PR_AF_INET \
1390 ? sizeof((_addr)->inet) \
1391 : ((_addr)->raw.family == PR_AF_INET6 \
1392 ? sizeof((_addr)->ipv6) \
1393 : sizeof((_addr)->local)))
1394 #else
1395 #define PR_NETADDR_SIZE(_addr) \
1396 ((_addr)->raw.family == PR_AF_INET \
1397 ? sizeof((_addr)->inet) \
1398 : sizeof((_addr)->ipv6))
1399 #endif /* defined(XP_UNIX) */
1400
1401 #endif /* defined(_PR_INET6) */
1402
1403 extern PRStatus _PR_MapOptionName(
1404 PRSockOption optname, PRInt32 *level, PRInt32 *name);
1405 extern void _PR_InitThreads(
1406 PRThreadType type, PRThreadPriority priority, PRUintn maxPTDs);
1407
1408 struct PRLock {
1409 #if defined(_PR_PTHREADS)
1410 pthread_mutex_t mutex; /* the underlying lock */
1411 _PT_Notified notified; /* array of conditions notified */
1412 PRBool locked; /* whether the mutex is locked */
1413 pthread_t owner; /* if locked, current lock owner */
1414 #elif defined(_PR_BTHREADS)
1415 sem_id semaphoreID; /* the underlying lock */
1416 int32 benaphoreCount; /* number of people in lock */
1417 thread_id owner; /* current lock owner */
1418 #else /* not pthreads or Be threads */
1419 PRCList links; /* linkage for PRThread.lockList */
1420 struct PRThread *owner; /* current lock owner */
1421 PRCList waitQ; /* list of threads waiting for lock */
1422 PRThreadPriority priority; /* priority of lock */
1423 PRThreadPriority boostPriority; /* boosted priority of lock owner */
1424 _MDLock ilock; /* Internal Lock to protect user-level fields */
1425 #endif
1426 };
1427
1428 struct PRCondVar {
1429 PRLock *lock; /* associated lock that protects the condition */
1430 #if defined(_PR_PTHREADS)
1431 pthread_cond_t cv; /* underlying pthreads condition */
1432 PRInt32 notify_pending; /* CV has destroy pending notification */
1433 #elif defined(_PR_BTHREADS)
1434 sem_id sem; /* the underlying lock */
1435 sem_id handshakeSem; /* the lock for 'notify'-threads waiting for confirmation */
1436 sem_id signalSem; /* the lock for threads waiting for someone to notify */
1437 volatile int32 nw; /* the number waiting */
1438 volatile int32 ns; /* the number signalling */
1439 long signalBenCount; /* the number waiting on the underlying sem */
1440 #else /* not pthreads or Be threads */
1441 PRCList condQ; /* Condition variable wait Q */
1442 _MDLock ilock; /* Internal Lock to protect condQ */
1443 _MDCVar md;
1444 #endif
1445 };
1446
1447 /************************************************************************/
1448
1449 struct PRMonitor {
1450 const char* name; /* monitor name for debugging */
1451 #if defined(_PR_PTHREADS)
1452 pthread_mutex_t lock; /* lock is only held when accessing fields
1453 * of the PRMonitor, instead of being held
1454 * while the monitor is entered. The only
1455 * exception is notifyTimes, which is
1456 * protected by the monitor. */
1457 pthread_t owner; /* the owner of the monitor or invalid */
1458 pthread_cond_t entryCV; /* for threads waiting to enter the monitor */
1459
1460 pthread_cond_t waitCV; /* for threads waiting on the monitor */
1461 PRInt32 refCount; /* reference count, an atomic variable.
1462 * PR_NewMonitor adds a reference to the
1463 * newly created PRMonitor, and
1464 * PR_DestroyMonitor releases that reference.
1465 * PR_ExitMonitor adds a reference before
1466 * unlocking the internal lock if it needs to
1467 * signal entryCV, and releases the reference
1468 * after signaling entryCV. */
1469 #else /* defined(_PR_PTHREADS) */
1470 PRLock lock; /* lock is only held when accessing fields
1471 * of the PRMonitor, instead of being held
1472 * while the monitor is entered. The only
1473 * exception is notifyTimes, which is
1474 * protected by the monitor. */
1475 PRThread *owner; /* the owner of the monitor or invalid */
1476 PRCondVar entryCV; /* for threads waiting to enter the monitor */
1477
1478 PRCondVar waitCV; /* for threads waiting on the monitor */
1479 #endif /* defined(_PR_PTHREADS) */
1480 PRUint32 entryCount; /* # of times re-entered */
1481 PRIntn notifyTimes; /* number of pending notifies for waitCV.
1482 * The special value -1 means a broadcast
1483 * (PR_NotifyAll). */
1484 };
1485
1486 /************************************************************************/
1487
1488 struct PRSemaphore {
1489 #if defined(_PR_BTHREADS)
1490 sem_id sem;
1491 int32 benaphoreCount;
1492 #else
1493 PRCondVar *cvar; /* associated lock and condition variable queue */
1494 PRUintn count; /* the value of the counting semaphore */
1495 PRUint32 waiters; /* threads waiting on the semaphore */
1496 #if defined(_PR_PTHREADS)
1497 #else /* defined(_PR_PTHREADS) */
1498 _MDSemaphore md;
1499 #endif /* defined(_PR_PTHREADS) */
1500 #endif /* defined(_PR_BTHREADS) */
1501 };
1502
1503 /*************************************************************************/
1504
1505 struct PRSem {
1506 #ifdef _PR_HAVE_POSIX_SEMAPHORES
1507 sem_t *sem;
1508 #elif defined(_PR_HAVE_SYSV_SEMAPHORES)
1509 int semid;
1510 #elif defined(WIN32)
1511 HANDLE sem;
1512 #else
1513 PRInt8 notused;
1514 #endif
1515 };
1516
1517 /*************************************************************************/
1518
1519 struct PRStackStr {
1520 /* head MUST be at offset 0; assembly language code relies on this */
1521 #if defined(AIX)
1522 volatile PRStackElem prstk_head;
1523 #else
1524 PRStackElem prstk_head;
1525 #endif
1526
1527 PRLock *prstk_lock;
1528 char *prstk_name;
1529 };
1530
1531 /************************************************************************/
1532
1533 /* XXX this needs to be exported (sigh) */
1534 struct PRThreadStack {
1535 PRCList links;
1536 PRUintn flags;
1537
1538 char *allocBase; /* base of stack's allocated memory */
1539 PRUint32 allocSize; /* size of stack's allocated memory */
1540 char *stackBottom; /* bottom of stack from C's point of view */
1541 char *stackTop; /* top of stack from C's point of view */
1542 PRUint32 stackSize; /* size of usable portion of the stack */
1543
1544 PRSegment *seg;
1545 PRThread* thr; /* back pointer to thread owning this stack */
1546
1547 #if defined(_PR_PTHREADS)
1548 #else /* defined(_PR_PTHREADS) */
1549 _MDThreadStack md;
1550 #endif /* defined(_PR_PTHREADS) */
1551 };
1552
1553 extern void _PR_DestroyThreadPrivate(PRThread*);
1554
1555 typedef void (PR_CALLBACK *_PRStartFn)(void *);
1556
1557 struct PRThread {
1558 PRUint32 state; /* thread's creation state */
1559 PRThreadPriority priority; /* apparent priority, loosly defined */
1560
1561 void *arg; /* argument to the client's entry point */
1562 _PRStartFn startFunc; /* the root of the client's thread */
1563
1564 PRThreadStack *stack; /* info about thread's stack (for GC) */
1565 void *environment; /* pointer to execution environment */
1566
1567 PRThreadDumpProc dump; /* dump thread info out */
1568 void *dumpArg; /* argument for the dump function */
1569
1570 /*
1571 ** Per thread private data
1572 */
1573 PRUint32 tpdLength; /* thread's current vector length */
1574 void **privateData; /* private data vector or NULL */
1575 PRErrorCode errorCode; /* current NSPR error code | zero */
1576 PRInt32 osErrorCode; /* mapping of errorCode | zero */
1577 PRIntn errorStringLength; /* textLength from last call to PR_SetErrorText() */
1578 PRInt32 errorStringSize; /* malloc()'d size of buffer | zero */
1579 char *errorString; /* current error string | NULL */
1580 char *name; /* thread's name */
1581
1582 #if defined(_PR_PTHREADS)
1583 pthread_t id; /* pthread identifier for the thread */
1584 PRBool idSet; /* whether 'id' has been set. Protected by
1585 * pt_book.ml. */
1586 #ifdef _PR_NICE_PRIORITY_SCHEDULING
1587 pid_t tid; /* Linux-specific kernel thread ID */
1588 #endif
1589 PRBool okToDelete; /* ok to delete the PRThread struct? */
1590 PRCondVar *waiting; /* where the thread is waiting | NULL */
1591 void *sp; /* recorded sp for garbage collection */
1592 PRThread *next, *prev; /* simple linked list of all threads */
1593 PRUint32 suspend; /* used to store suspend and resume flags */
1594 #ifdef PT_NO_SIGTIMEDWAIT
1595 pthread_mutex_t suspendResumeMutex;
1596 pthread_cond_t suspendResumeCV;
1597 #endif
1598 PRUint32 interrupt_blocked; /* interrupt blocked */
1599 struct pollfd *syspoll_list; /* Unix polling list used by PR_Poll */
1600 PRUint32 syspoll_count; /* number of elements in syspoll_list */
1601 #if defined(_PR_POLL_WITH_SELECT)
1602 int *selectfd_list; /* Unix fd's that PR_Poll selects on */
1603 PRUint32 selectfd_count; /* number of elements in selectfd_list */
1604 #endif
1605 #elif defined(_PR_BTHREADS)
1606 PRUint32 flags;
1607 _MDThread md;
1608 PRBool io_pending;
1609 PRInt32 io_fd;
1610 PRBool io_suspended;
1611 #else /* not pthreads or Be threads */
1612 _MDLock threadLock; /* Lock to protect thread state variables.
1613 * Protects the following fields:
1614 * state
1615 * priority
1616 * links
1617 * wait
1618 * cpu
1619 */
1620 PRUint32 queueCount;
1621 PRUint32 waitCount;
1622
1623 PRCList active; /* on list of all active threads */
1624 PRCList links;
1625 PRCList waitQLinks; /* when thread is PR_Wait'ing */
1626 PRCList lockList; /* list of locks currently holding */
1627 PRIntervalTime sleep; /* sleep time when thread is sleeping */
1628 struct _wait {
1629 struct PRLock *lock;
1630 struct PRCondVar *cvar;
1631 } wait;
1632
1633 PRUint32 id;
1634 PRUint32 flags;
1635 PRUint32 no_sched; /* Don't schedule the thread to run.
1636 * This flag has relevance only when
1637 * multiple NSPR CPUs are created.
1638 * When a thread is de-scheduled, there
1639 * is a narrow window of time in which
1640 * the thread is put on the run queue
1641 * but the scheduler is actually using
1642 * the stack of this thread. It is safe
1643 * to run this thread on a different CPU
1644 * only when its stack is not in use on
1645 * any other CPU. The no_sched flag is
1646 * set during this interval to prevent
1647 * the thread from being scheduled on a
1648 * different CPU.
1649 */
1650
1651 /* thread termination condition variable for join */
1652 PRCondVar *term;
1653
1654 _PRCPU *cpu; /* cpu to which this thread is bound */
1655 PRUint32 threadAllocatedOnStack;/* boolean */
1656
1657 /* When an async IO is in progress and a second async IO cannot be
1658 * initiated, the io_pending flag is set to true. Some platforms will
1659 * not use the io_pending flag. If the io_pending flag is true, then
1660 * io_fd is the OS-file descriptor on which IO is pending.
1661 */
1662 PRBool io_pending;
1663 PRInt32 io_fd;
1664
1665 /* If a timeout occurs or if an outstanding IO is interrupted and the
1666 * OS doesn't support a real cancellation (NT or MAC), then the
1667 * io_suspended flag will be set to true. The thread will be resumed
1668 * but may run into trouble issuing additional IOs until the io_pending
1669 * flag can be cleared
1670 */
1671 PRBool io_suspended;
1672
1673 _MDThread md;
1674 #endif
1675 };
1676
1677 struct PRProcessAttr {
1678 PRFileDesc *stdinFd;
1679 PRFileDesc *stdoutFd;
1680 PRFileDesc *stderrFd;
1681 char *currentDirectory;
1682 char *fdInheritBuffer;
1683 PRSize fdInheritBufferSize;
1684 PRSize fdInheritBufferUsed;
1685 };
1686
1687 struct PRProcess {
1688 _MDProcess md;
1689 };
1690
1691 struct PRFileMap {
1692 PRFileDesc *fd;
1693 PRFileMapProtect prot;
1694 _MDFileMap md;
1695 };
1696
1697 /************************************************************************/
1698
1699 /*
1700 ** File descriptors of the NSPR layer can be in one of the
1701 ** following states (stored in the 'state' field of struct
1702 ** PRFilePrivate):
1703 ** - _PR_FILEDESC_OPEN: The OS fd is open.
1704 ** - _PR_FILEDESC_CLOSED: The OS fd is closed. The PRFileDesc
1705 ** is still open but is unusable. The only operation allowed
1706 ** on the PRFileDesc is PR_Close().
1707 ** - _PR_FILEDESC_FREED: The OS fd is closed and the PRFileDesc
1708 ** structure is freed.
1709 */
1710
1711 #define _PR_FILEDESC_OPEN 0xaaaaaaaa /* 1010101... */
1712 #define _PR_FILEDESC_CLOSED 0x55555555 /* 0101010... */
1713 #define _PR_FILEDESC_FREED 0x11111111
1714
1715 /*
1716 ** A boolean type with an additional "unknown" state
1717 */
1718
1719 typedef enum {
1720 _PR_TRI_TRUE = 1,
1721 _PR_TRI_FALSE = 0,
1722 _PR_TRI_UNKNOWN = -1
1723 } _PRTriStateBool;
1724
1725 struct PRFilePrivate {
1726 PRInt32 state;
1727 PRBool nonblocking;
1728 _PRTriStateBool inheritable;
1729 PRFileDesc *next;
1730 PRIntn lockCount; /* 0: not locked
1731 * -1: a native lockfile call is in progress
1732 * > 0: # times the file is locked */
1733 #ifdef _PR_HAVE_PEEK_BUFFER
1734 char *peekBuffer;
1735 PRInt32 peekBufSize;
1736 PRInt32 peekBytes;
1737 #endif
1738 #if !defined(_PR_HAVE_O_APPEND)
1739 PRBool appendMode; /* Some platforms don't have O_APPEND or its
1740 * equivalent, so they have to seek to end of
1741 * file on write if the file was opened in
1742 * append mode. See Bugzilla 4090, 276330. */
1743 #endif
1744 _MDFileDesc md;
1745 #ifdef _PR_NEED_SECRET_AF
1746 PRUint16 af; /* If the platform's implementation of accept()
1747 * requires knowing the address family of the
1748 * socket, we save the address family here. */
1749 #endif
1750 };
1751
1752 #ifdef _WIN64
1753 #define PR_PRIdOSFD "lld" /* for printing PROsfd */
1754 #define PR_PRIxOSFD "llx"
1755 #define PR_SCNdOSFD "lld" /* for scanning PROsfd */
1756 #define PR_SCNxOSFD "llx"
1757 #else
1758 #define PR_PRIdOSFD "ld" /* for printing PROsfd */
1759 #define PR_PRIxOSFD "lx"
1760 #define PR_SCNdOSFD "ld" /* for scanning PROsfd */
1761 #define PR_SCNxOSFD "lx"
1762 #endif
1763
1764 struct PRDir {
1765 PRDirEntry d;
1766 _MDDir md;
1767 };
1768
1769 #ifdef MOZ_UNICODE
1770 struct PRDirUTF16 {
1771 PRDirEntry d;
1772 _MDDirUTF16 md;
1773 };
1774 #endif /* MOZ_UNICODE */
1775
1776 extern void _PR_InitLocks(void);
1777 extern void _PR_InitSegs(void);
1778 extern void _PR_InitStacks(void);
1779 extern void _PR_InitTPD(void);
1780 extern void _PR_InitMem(void);
1781 extern void _PR_InitEnv(void);
1782 extern void _PR_InitCMon(void);
1783 extern void _PR_InitIO(void);
1784 extern void _PR_InitLog(void);
1785 extern void _PR_InitNet(void);
1786 extern void _PR_InitClock(void);
1787 extern void _PR_InitLinker(void);
1788 extern void _PR_InitAtomic(void);
1789 extern void _PR_InitCPUs(void);
1790 extern void _PR_InitDtoa(void);
1791 extern void _PR_InitTime(void);
1792 extern void _PR_InitMW(void);
1793 extern void _PR_InitRWLocks(void);
1794 extern void _PR_CleanupThread(PRThread *thread);
1795 extern void _PR_CleanupCallOnce(void);
1796 extern void _PR_CleanupMW(void);
1797 extern void _PR_CleanupTime(void);
1798 extern void _PR_CleanupDtoa(void);
1799 extern void _PR_ShutdownLinker(void);
1800 extern void _PR_CleanupEnv(void);
1801 extern void _PR_CleanupIO(void);
1802 extern void _PR_CleanupCMon(void);
1803 extern void _PR_CleanupNet(void);
1804 extern void _PR_CleanupLayerCache(void);
1805 extern void _PR_CleanupStacks(void);
1806 #ifdef WINNT
1807 extern void _PR_CleanupCPUs(void);
1808 #endif
1809 extern void _PR_CleanupThreads(void);
1810 extern void _PR_CleanupTPD(void);
1811 extern void _PR_Cleanup(void);
1812 extern void _PR_LogCleanup(void);
1813 extern void _PR_InitLayerCache(void);
1814
1815 extern PRBool _pr_initialized;
1816 extern void _PR_ImplicitInitialization(void);
1817 extern PRBool _PR_Obsolete(const char *obsolete, const char *preferred);
1818
1819 /************************************************************************/
1820
1821 struct PRSegment {
1822 void *vaddr;
1823 PRUint32 size;
1824 PRUintn flags;
1825 #if defined(_PR_PTHREADS)
1826 #else /* defined(_PR_PTHREADS) */
1827 _MDSegment md;
1828 #endif /* defined(_PR_PTHREADS) */
1829 };
1830
1831 /* PRSegment.flags */
1832 #define _PR_SEG_VM 0x1
1833
1834 /************************************************************************/
1835
1836 extern PRInt32 _pr_pageSize;
1837 extern PRInt32 _pr_pageShift;
1838
1839 extern PRLogModuleInfo *_pr_clock_lm;
1840 extern PRLogModuleInfo *_pr_cmon_lm;
1841 extern PRLogModuleInfo *_pr_io_lm;
1842 extern PRLogModuleInfo *_pr_cvar_lm;
1843 extern PRLogModuleInfo *_pr_mon_lm;
1844 extern PRLogModuleInfo *_pr_linker_lm;
1845 extern PRLogModuleInfo *_pr_sched_lm;
1846 extern PRLogModuleInfo *_pr_thread_lm;
1847 extern PRLogModuleInfo *_pr_gc_lm;
1848
1849 extern PRFileDesc *_pr_stdin;
1850 extern PRFileDesc *_pr_stdout;
1851 extern PRFileDesc *_pr_stderr;
1852
1853 /* Zone allocator */
1854 /*
1855 ** The zone allocator code has hardcoded pthread types and
1856 ** functions, so it can only be used in the pthreads version.
1857 ** This can be fixed by replacing the hardcoded pthread types
1858 ** and functions with macros that expand to the native thread
1859 ** types and functions on each platform.
1860 */
1861 #if defined(_PR_PTHREADS) && !defined(_PR_DCETHREADS)
1862 #define _PR_ZONE_ALLOCATOR
1863 #endif
1864
1865 #ifdef _PR_ZONE_ALLOCATOR
1866 extern void _PR_InitZones(void);
1867 extern void _PR_DestroyZones(void);
1868 #endif
1869
1870 /* Overriding malloc, free, etc. */
1871 #if !defined(_PR_NO_PREEMPT) && defined(XP_UNIX) \
1872 && !defined(_PR_PTHREADS) && !defined(_PR_GLOBAL_THREADS_ONLY) \
1873 && !defined(PURIFY) \
1874 && !defined(DARWIN) \
1875 && !defined(QNX) \
1876 && !(defined (UNIXWARE) && defined (USE_SVR4_THREADS))
1877 #define _PR_OVERRIDE_MALLOC
1878 #endif
1879
1880 /*************************************************************************
1881 * External machine-dependent code provided by each OS. * *
1882 *************************************************************************/
1883
1884 /* Initialization related */
1885 extern void _PR_MD_EARLY_INIT(void);
1886 #define _PR_MD_EARLY_INIT _MD_EARLY_INIT
1887
1888 extern void _PR_MD_INTERVAL_INIT(void);
1889 #define _PR_MD_INTERVAL_INIT _MD_INTERVAL_INIT
1890
1891 NSPR_API(void) _PR_MD_FINAL_INIT(void);
1892 #define _PR_MD_FINAL_INIT _MD_FINAL_INIT
1893
1894 extern void _PR_MD_EARLY_CLEANUP(void);
1895 #define _PR_MD_EARLY_CLEANUP _MD_EARLY_CLEANUP
1896
1897 /* Process control */
1898
1899 extern PRProcess * _PR_MD_CREATE_PROCESS(
1900 const char *path,
1901 char *const *argv,
1902 char *const *envp,
1903 const PRProcessAttr *attr);
1904 #define _PR_MD_CREATE_PROCESS _MD_CREATE_PROCESS
1905
1906 extern PRStatus _PR_MD_DETACH_PROCESS(PRProcess *process);
1907 #define _PR_MD_DETACH_PROCESS _MD_DETACH_PROCESS
1908
1909 extern PRStatus _PR_MD_WAIT_PROCESS(PRProcess *process, PRInt32 *exitCode);
1910 #define _PR_MD_WAIT_PROCESS _MD_WAIT_PROCESS
1911
1912 extern PRStatus _PR_MD_KILL_PROCESS(PRProcess *process);
1913 #define _PR_MD_KILL_PROCESS _MD_KILL_PROCESS
1914
1915 /* Current Time */
1916 NSPR_API(PRTime) _PR_MD_NOW(void);
1917 #define _PR_MD_NOW _MD_NOW
1918
1919 /* Environment related */
1920 extern char* _PR_MD_GET_ENV(const char *name);
1921 #define _PR_MD_GET_ENV _MD_GET_ENV
1922
1923 extern PRIntn _PR_MD_PUT_ENV(const char *name);
1924 #define _PR_MD_PUT_ENV _MD_PUT_ENV
1925
1926 /* Atomic operations */
1927
1928 extern void _PR_MD_INIT_ATOMIC(void);
1929 #define _PR_MD_INIT_ATOMIC _MD_INIT_ATOMIC
1930
1931 extern PRInt32 _PR_MD_ATOMIC_INCREMENT(PRInt32 *);
1932 #define _PR_MD_ATOMIC_INCREMENT _MD_ATOMIC_INCREMENT
1933
1934 extern PRInt32 _PR_MD_ATOMIC_ADD(PRInt32 *, PRInt32);
1935 #define _PR_MD_ATOMIC_ADD _MD_ATOMIC_ADD
1936
1937 extern PRInt32 _PR_MD_ATOMIC_DECREMENT(PRInt32 *);
1938 #define _PR_MD_ATOMIC_DECREMENT _MD_ATOMIC_DECREMENT
1939
1940 extern PRInt32 _PR_MD_ATOMIC_SET(PRInt32 *, PRInt32);
1941 #define _PR_MD_ATOMIC_SET _MD_ATOMIC_SET
1942
1943 /* Garbage collection */
1944
1945 /*
1946 ** Save the registers that the GC would find interesting into the thread
1947 ** "t". isCurrent will be non-zero if the thread state that is being
1948 ** saved is the currently executing thread. Return the address of the
1949 ** first register to be scanned as well as the number of registers to
1950 ** scan in "np".
1951 **
1952 ** If "isCurrent" is non-zero then it is allowed for the thread context
1953 ** area to be used as scratch storage to hold just the registers
1954 ** necessary for scanning.
1955 */
1956 extern PRWord *_MD_HomeGCRegisters(PRThread *t, int isCurrent, int *np);
1957
1958 /* Time intervals */
1959
1960 extern PRIntervalTime _PR_MD_GET_INTERVAL(void);
1961 #define _PR_MD_GET_INTERVAL _MD_GET_INTERVAL
1962
1963 extern PRIntervalTime _PR_MD_INTERVAL_PER_SEC(void);
1964 #define _PR_MD_INTERVAL_PER_SEC _MD_INTERVAL_PER_SEC
1965
1966 /* Affinity masks */
1967
1968 extern PRInt32 _PR_MD_SETTHREADAFFINITYMASK(PRThread *thread, PRUint32 mask );
1969 #define _PR_MD_SETTHREADAFFINITYMASK _MD_SETTHREADAFFINITYMASK
1970
1971 extern PRInt32 _PR_MD_GETTHREADAFFINITYMASK(PRThread *thread, PRUint32 *mask);
1972 #define _PR_MD_GETTHREADAFFINITYMASK _MD_GETTHREADAFFINITYMASK
1973
1974 /* File locking */
1975
1976 extern PRStatus _PR_MD_LOCKFILE(PROsfd osfd);
1977 #define _PR_MD_LOCKFILE _MD_LOCKFILE
1978
1979 extern PRStatus _PR_MD_TLOCKFILE(PROsfd osfd);
1980 #define _PR_MD_TLOCKFILE _MD_TLOCKFILE
1981
1982 extern PRStatus _PR_MD_UNLOCKFILE(PROsfd osfd);
1983 #define _PR_MD_UNLOCKFILE _MD_UNLOCKFILE
1984
1985 /* Memory-mapped files */
1986
1987 extern PRStatus _PR_MD_CREATE_FILE_MAP(PRFileMap *fmap, PRInt64 size);
1988 #define _PR_MD_CREATE_FILE_MAP _MD_CREATE_FILE_MAP
1989
1990 extern PRInt32 _PR_MD_GET_MEM_MAP_ALIGNMENT(void);
1991 #define _PR_MD_GET_MEM_MAP_ALIGNMENT _MD_GET_MEM_MAP_ALIGNMENT
1992
1993 extern void * _PR_MD_MEM_MAP(
1994 PRFileMap *fmap,
1995 PROffset64 offset,
1996 PRUint32 len);
1997 #define _PR_MD_MEM_MAP _MD_MEM_MAP
1998
1999 extern PRStatus _PR_MD_MEM_UNMAP(void *addr, PRUint32 size);
2000 #define _PR_MD_MEM_UNMAP _MD_MEM_UNMAP
2001
2002 extern PRStatus _PR_MD_CLOSE_FILE_MAP(PRFileMap *fmap);
2003 #define _PR_MD_CLOSE_FILE_MAP _MD_CLOSE_FILE_MAP
2004
2005 extern PRStatus _PR_MD_SYNC_MEM_MAP(
2006 PRFileDesc *fd,
2007 void *addr,
2008 PRUint32 len);
2009 #define _PR_MD_SYNC_MEM_MAP _MD_SYNC_MEM_MAP
2010
2011 /* Named Shared Memory */
2012
2013 /*
2014 ** Declare PRSharedMemory.
2015 */
2016 struct PRSharedMemory
2017 {
2018 char *ipcname; /* after conversion to native */
2019 PRSize size; /* from open */
2020 PRIntn mode; /* from open */
2021 PRIntn flags; /* from open */
2022 #if defined(PR_HAVE_POSIX_NAMED_SHARED_MEMORY)
2023 int id;
2024 #elif defined(PR_HAVE_SYSV_NAMED_SHARED_MEMORY)
2025 int id;
2026 #elif defined(PR_HAVE_WIN32_NAMED_SHARED_MEMORY)
2027 HANDLE handle;
2028 #else
2029 PRUint32 nothing; /* placeholder, nothing behind here */
2030 #endif
2031 PRUint32 ident; /* guard word at end of struct */
2032 #define _PR_SHM_IDENT 0xdeadbad
2033 };
2034
2035 extern PRSharedMemory * _MD_OpenSharedMemory(
2036 const char *name,
2037 PRSize size,
2038 PRIntn flags,
2039 PRIntn mode
2040 );
2041 #define _PR_MD_OPEN_SHARED_MEMORY _MD_OpenSharedMemory
2042
2043 extern void * _MD_AttachSharedMemory( PRSharedMemory *shm, PRIntn flags );
2044 #define _PR_MD_ATTACH_SHARED_MEMORY _MD_AttachSharedMemory
2045
2046 extern PRStatus _MD_DetachSharedMemory( PRSharedMemory *shm, void *addr );
2047 #define _PR_MD_DETACH_SHARED_MEMORY _MD_DetachSharedMemory
2048
2049 extern PRStatus _MD_CloseSharedMemory( PRSharedMemory *shm );
2050 #define _PR_MD_CLOSE_SHARED_MEMORY _MD_CloseSharedMemory
2051
2052 extern PRStatus _MD_DeleteSharedMemory( const char *name );
2053 #define _PR_MD_DELETE_SHARED_MEMORY _MD_DeleteSharedMemory
2054
2055 extern PRFileMap* _md_OpenAnonFileMap(
2056 const char *dirName,
2057 PRSize size,
2058 PRFileMapProtect prot
2059 );
2060 #define _PR_MD_OPEN_ANON_FILE_MAP _md_OpenAnonFileMap
2061
2062 extern PRStatus _md_ExportFileMapAsString(
2063 PRFileMap *fm,
2064 PRSize bufSize,
2065 char *buf
2066 );
2067 #define _PR_MD_EXPORT_FILE_MAP_AS_STRING _md_ExportFileMapAsString
2068
2069 extern PRFileMap * _md_ImportFileMapFromString(
2070 const char *fmstring
2071 );
2072 #define _PR_MD_IMPORT_FILE_MAP_FROM_STRING _md_ImportFileMapFromString
2073
2074
2075
2076 /* Interprocess communications (IPC) */
2077
2078 /*
2079 * The maximum length of an NSPR IPC name, including the
2080 * terminating null byte.
2081 */
2082 #define PR_IPC_NAME_SIZE 1024
2083
2084 /*
2085 * Types of NSPR IPC objects
2086 */
2087 typedef enum {
2088 _PRIPCSem, /* semaphores */
2089 _PRIPCShm /* shared memory segments */
2090 } _PRIPCType;
2091
2092 /*
2093 * Make a native IPC name from an NSPR IPC name.
2094 */
2095 extern PRStatus _PR_MakeNativeIPCName(
2096 const char *name, /* NSPR IPC name */
2097 char *result, /* result buffer */
2098 PRIntn size, /* size of result buffer */
2099 _PRIPCType type /* type of IPC object */
2100 );
2101
2102 /* Socket call error code */
2103
2104 NSPR_API(PRInt32) _PR_MD_GET_SOCKET_ERROR(void);
2105 #define _PR_MD_GET_SOCKET_ERROR _MD_GET_SOCKET_ERROR
2106
2107 /* Get name of current host */
2108 extern PRStatus _PR_MD_GETHOSTNAME(char *name, PRUint32 namelen);
2109 #define _PR_MD_GETHOSTNAME _MD_GETHOSTNAME
2110
2111 extern PRStatus _PR_MD_GETSYSINFO(PRSysInfo cmd, char *name, PRUint32 namelen);
2112 #define _PR_MD_GETSYSINFO _MD_GETSYSINFO
2113
2114 /* File descriptor inheritance */
2115
2116 /*
2117 * If fd->secret->inheritable is _PR_TRI_UNKNOWN and we need to
2118 * know the inheritable attribute of the fd, call this function
2119 * to find that out. This typically requires a system call.
2120 */
2121 extern void _PR_MD_QUERY_FD_INHERITABLE(PRFileDesc *fd);
2122 #define _PR_MD_QUERY_FD_INHERITABLE _MD_QUERY_FD_INHERITABLE
2123
2124 /* --- PR_GetRandomNoise() related things --- */
2125
2126 extern PRSize _PR_MD_GetRandomNoise( void *buf, PRSize size );
2127 #define _PR_MD_GET_RANDOM_NOISE(buf,size) _PR_MD_GetRandomNoise((buf),(size))
2128 extern PRSize _pr_CopyLowBits( void *dest, PRSize dstlen, void *src, PRSize srclen );
2129
2130 /* end PR_GetRandomNoise() related */
2131
2132 #ifdef XP_BEOS
2133
2134 extern PRLock *_connectLock;
2135
2136 typedef struct _ConnectListNode {
2137 PRInt32 osfd;
2138 PRNetAddr addr;
2139 PRUint32 addrlen;
2140 PRIntervalTime timeout;
2141 } ConnectListNode;
2142
2143 extern ConnectListNode connectList[64];
2144
2145 extern PRUint32 connectCount;
2146
2147 #endif /* XP_BEOS */
2148
2149 PR_END_EXTERN_C
2150
2151 #endif /* primpl_h___ */
This site is hosted by Intevation GmbH (Datenschutzerklärung und Impressum | Privacy Policy and Imprint)