Coverage Report

Created: 2025-07-01 06:25

/src/nspr/pr/include/md/_unixos.h
Line
Count
Source (jump to first uncovered line)
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 prunixos_h___
7
#define prunixos_h___
8
9
/*
10
 * If FD_SETSIZE is not defined on the command line, set the default value
11
 * before include select.h
12
 */
13
/*
14
 * Linux: FD_SETSIZE is defined in /usr/include/sys/select.h and should
15
 * not be redefined.
16
 */
17
#if !defined(LINUX) && !defined(__GNU__) && !defined(__GLIBC__) \
18
    && !defined(DARWIN)
19
#ifndef FD_SETSIZE
20
#define FD_SETSIZE  4096
21
#endif
22
#endif
23
24
#include <unistd.h>
25
#include <stddef.h>
26
#include <sys/stat.h>
27
#include <dirent.h>
28
#include <errno.h>
29
30
#include "prio.h"
31
#include "prmem.h"
32
#include "prclist.h"
33
34
/*
35
 * For select(), fd_set, and struct timeval.
36
 *
37
 * In The Single UNIX(R) Specification, Version 2,
38
 * the header file for select() is <sys/time.h>.
39
 * In Version 3, the header file for select() is
40
 * changed to <sys/select.h>.
41
 *
42
 * fd_set is defined in <sys/types.h>.  Usually
43
 * <sys/time.h> includes <sys/types.h>, but on some
44
 * older systems <sys/time.h> does not include
45
 * <sys/types.h>, so we include it explicitly.
46
 */
47
#include <sys/time.h>
48
#include <sys/types.h>
49
#if defined(AIX)
50
#include <sys/select.h>
51
#endif
52
53
#define HAVE_NETINET_TCP_H
54
55
#define _PR_HAVE_O_APPEND
56
57
0
#define PR_DIRECTORY_SEPARATOR      '/'
58
#define PR_DIRECTORY_SEPARATOR_STR  "/"
59
0
#define PR_PATH_SEPARATOR       ':'
60
#define PR_PATH_SEPARATOR_STR       ":"
61
typedef int (*FARPROC)();
62
63
/*
64
 * intervals at which GLOBAL threads wakeup to check for pending interrupt
65
 */
66
#define _PR_INTERRUPT_CHECK_INTERVAL_SECS 5
67
extern PRIntervalTime intr_timeout_ticks;
68
69
/*
70
 * The bit flags for the in_flags and out_flags fields
71
 * of _PR_UnixPollDesc
72
 */
73
#ifdef _PR_USE_POLL
74
#define _PR_UNIX_POLL_READ    POLLIN
75
#define _PR_UNIX_POLL_WRITE   POLLOUT
76
#define _PR_UNIX_POLL_EXCEPT  POLLPRI
77
#define _PR_UNIX_POLL_ERR     POLLERR
78
#define _PR_UNIX_POLL_NVAL    POLLNVAL
79
#define _PR_UNIX_POLL_HUP     POLLHUP
80
#else /* _PR_USE_POLL */
81
#define _PR_UNIX_POLL_READ    0x1
82
#define _PR_UNIX_POLL_WRITE   0x2
83
#define _PR_UNIX_POLL_EXCEPT  0x4
84
#define _PR_UNIX_POLL_ERR     0x8
85
#define _PR_UNIX_POLL_NVAL    0x10
86
#define _PR_UNIX_POLL_HUP     0x20
87
#endif /* _PR_USE_POLL */
88
89
typedef struct _PRUnixPollDesc {
90
    PRInt32 osfd;
91
    PRInt16 in_flags;
92
    PRInt16 out_flags;
93
} _PRUnixPollDesc;
94
95
typedef struct PRPollQueue {
96
    PRCList links;        /* for linking PRPollQueue's together */
97
    _PRUnixPollDesc *pds;        /* array of poll descriptors */
98
    PRUintn npds;            /* length of the array */
99
    PRPackedBool on_ioq;    /* is this on the async i/o work q? */
100
    PRIntervalTime timeout;        /* timeout, in ticks */
101
    struct PRThread *thr;
102
} PRPollQueue;
103
104
#define _PR_POLLQUEUE_PTR(_qp) \
105
    ((PRPollQueue*) ((char*) (_qp) - offsetof(PRPollQueue,links)))
106
107
108
extern PRInt32 _PR_WaitForMultipleFDs(
109
    _PRUnixPollDesc *unixpds,
110
    PRInt32 pdcnt,
111
    PRIntervalTime timeout);
112
extern void _PR_Unblock_IO_Wait(struct PRThread *thr);
113
114
#if defined(_PR_LOCAL_THREADS_ONLY) || defined(_PR_GLOBAL_THREADS_ONLY)
115
#define _MD_CHECK_FOR_EXIT()
116
#endif
117
118
extern fd_set _pr_md_read_set, _pr_md_write_set, _pr_md_exception_set;
119
extern PRInt16 _pr_md_read_cnt[], _pr_md_write_cnt[], _pr_md_exception_cnt[];
120
extern PRInt32 _pr_md_ioq_max_osfd;
121
extern PRUint32 _pr_md_ioq_timeout;
122
123
struct _MDFileDesc {
124
    int osfd;
125
#if defined(LINUX) && defined(_PR_PTHREADS)
126
    int tcp_nodelay;  /* used by pt_LinuxSendFile */
127
#endif
128
};
129
130
struct _MDDir {
131
    DIR *d;
132
};
133
134
struct _PRCPU;
135
extern void _MD_unix_init_running_cpu(struct _PRCPU *cpu);
136
137
/*
138
** Make a redzone at both ends of the stack segment. Disallow access
139
** to those pages of memory. It's ok if the mprotect call's don't
140
** work - it just means that we don't really have a functional
141
** redzone.
142
*/
143
#include <sys/mman.h>
144
#ifndef PROT_NONE
145
#define PROT_NONE 0x0
146
#endif
147
148
#if defined(DEBUG) && !defined(DARWIN)
149
#if !defined(SOLARIS)
150
#include <string.h>  /* for memset() */
151
#define _MD_INIT_STACK(ts,REDZONE)                  \
152
    PR_BEGIN_MACRO                                  \
153
    (void) mprotect((void*)ts->seg->vaddr, REDZONE, PROT_NONE); \
154
    (void) mprotect((void*) ((char*)ts->seg->vaddr + REDZONE + ts->stackSize),\
155
            REDZONE, PROT_NONE);                \
156
    /*                                  \
157
    ** Fill stack memory with something that turns into an illegal  \
158
    ** pointer value. This will sometimes find runtime references to    \
159
    ** uninitialized pointers. We don't do this for solaris because we  \
160
    ** can use purify instead.                      \
161
    */                                  \
162
    if (_pr_debugStacks) {                      \
163
    memset(ts->allocBase + REDZONE, 0xf7, ts->stackSize);       \
164
    }                                   \
165
    PR_END_MACRO
166
#else   /* !SOLARIS */
167
#define _MD_INIT_STACK(ts,REDZONE)                  \
168
    PR_BEGIN_MACRO                                  \
169
    (void) mprotect((void*)ts->seg->vaddr, REDZONE, PROT_NONE); \
170
    (void) mprotect((void*) ((char*)ts->seg->vaddr + REDZONE + ts->stackSize),\
171
            REDZONE, PROT_NONE);                \
172
    PR_END_MACRO
173
#endif  /* !SOLARIS */
174
175
/*
176
 * _MD_CLEAR_STACK
177
 *  Allow access to the redzone pages; the access was turned off in
178
 *  _MD_INIT_STACK.
179
 */
180
#define _MD_CLEAR_STACK(ts)                     \
181
    PR_BEGIN_MACRO                                  \
182
    (void) mprotect((void*)ts->seg->vaddr, REDZONE, PROT_READ|PROT_WRITE);\
183
    (void) mprotect((void*) ((char*)ts->seg->vaddr + REDZONE + ts->stackSize),\
184
            REDZONE, PROT_READ|PROT_WRITE);         \
185
    PR_END_MACRO
186
187
#else   /* DEBUG */
188
189
#define _MD_INIT_STACK(ts,REDZONE)
190
#define _MD_CLEAR_STACK(ts)
191
192
#endif  /* DEBUG */
193
194
#if !defined(SOLARIS)
195
196
#define PR_SET_INTSOFF(newval)
197
198
#endif
199
200
/************************************************************************/
201
202
extern void _PR_UnixInit(void);
203
204
extern void _PR_UnixCleanup(void);
205
0
#define _MD_EARLY_CLEANUP _PR_UnixCleanup
206
207
/************************************************************************/
208
209
struct _MDProcess {
210
    pid_t pid;
211
};
212
213
struct PRProcess;
214
struct PRProcessAttr;
215
216
/* Create a new process (fork() + exec()) */
217
0
#define _MD_CREATE_PROCESS _MD_CreateUnixProcess
218
extern struct PRProcess * _MD_CreateUnixProcess(
219
    const char *path,
220
    char *const *argv,
221
    char *const *envp,
222
    const struct PRProcessAttr *attr
223
);
224
225
0
#define _MD_DETACH_PROCESS _MD_DetachUnixProcess
226
extern PRStatus _MD_DetachUnixProcess(struct PRProcess *process);
227
228
/* Wait for a child process to terminate */
229
0
#define _MD_WAIT_PROCESS _MD_WaitUnixProcess
230
extern PRStatus _MD_WaitUnixProcess(struct PRProcess *process,
231
                                    PRInt32 *exitCode);
232
233
0
#define _MD_KILL_PROCESS _MD_KillUnixProcess
234
extern PRStatus _MD_KillUnixProcess(struct PRProcess *process);
235
236
/************************************************************************/
237
238
extern void _MD_EnableClockInterrupts(void);
239
extern void _MD_DisableClockInterrupts(void);
240
241
#define _MD_START_INTERRUPTS            _MD_StartInterrupts
242
#define _MD_STOP_INTERRUPTS             _MD_StopInterrupts
243
#define _MD_DISABLE_CLOCK_INTERRUPTS    _MD_DisableClockInterrupts
244
#define _MD_ENABLE_CLOCK_INTERRUPTS     _MD_EnableClockInterrupts
245
#define _MD_BLOCK_CLOCK_INTERRUPTS      _MD_BlockClockInterrupts
246
#define _MD_UNBLOCK_CLOCK_INTERRUPTS    _MD_UnblockClockInterrupts
247
248
/************************************************************************/
249
250
extern void     _MD_InitCPUS(void);
251
#define _MD_INIT_CPUS           _MD_InitCPUS
252
253
extern void     _MD_Wakeup_CPUs(void);
254
#define _MD_WAKEUP_CPUS _MD_Wakeup_CPUs
255
256
#define _MD_PAUSE_CPU           _MD_PauseCPU
257
258
#if defined(_PR_LOCAL_THREADS_ONLY) || defined(_PR_GLOBAL_THREADS_ONLY)
259
#define _MD_CLEANUP_BEFORE_EXIT()
260
#endif
261
262
#define _MD_EXIT(status)        _exit(status)
263
264
/************************************************************************/
265
266
0
#define _MD_GET_ENV             getenv
267
0
#define _MD_PUT_ENV             putenv
268
269
/************************************************************************/
270
271
#define _MD_INIT_FILEDESC(fd)
272
273
extern void     _MD_MakeNonblock(PRFileDesc *fd);
274
#define _MD_MAKE_NONBLOCK           _MD_MakeNonblock
275
276
/************************************************************************/
277
278
#if !defined(_PR_PTHREADS)
279
280
extern void     _MD_InitSegs(void);
281
extern PRStatus _MD_AllocSegment(PRSegment *seg, PRUint32 size,
282
                                 void *vaddr);
283
extern void     _MD_FreeSegment(PRSegment *seg);
284
285
#define _MD_INIT_SEGS           _MD_InitSegs
286
#define _MD_ALLOC_SEGMENT       _MD_AllocSegment
287
#define _MD_FREE_SEGMENT        _MD_FreeSegment
288
289
#endif /* !defined(_PR_PTHREADS) */
290
291
/************************************************************************/
292
293
#ifdef _MD_INTERVAL_USE_GTOD
294
extern PRIntervalTime   _PR_UNIX_GetInterval(void);
295
extern PRIntervalTime   _PR_UNIX_TicksPerSecond(void);
296
#define _MD_INTERVAL_INIT()
297
#define _MD_GET_INTERVAL        _PR_UNIX_GetInterval
298
#define _MD_INTERVAL_PER_SEC        _PR_UNIX_TicksPerSecond
299
#endif
300
301
#ifdef _PR_HAVE_CLOCK_MONOTONIC
302
extern PRIntervalTime   _PR_UNIX_GetInterval2(void);
303
extern PRIntervalTime   _PR_UNIX_TicksPerSecond2(void);
304
#define _MD_INTERVAL_INIT()
305
0
#define _MD_GET_INTERVAL        _PR_UNIX_GetInterval2
306
0
#define _MD_INTERVAL_PER_SEC        _PR_UNIX_TicksPerSecond2
307
#endif
308
309
#define _MD_INTERVAL_PER_MILLISEC() (_PR_MD_INTERVAL_PER_SEC() / 1000)
310
#define _MD_INTERVAL_PER_MICROSEC() (_PR_MD_INTERVAL_PER_SEC() / 1000000)
311
312
/************************************************************************/
313
314
0
#define _MD_ERRNO()                 (errno)
315
#define _MD_GET_SOCKET_ERROR()      (errno)
316
317
/************************************************************************/
318
319
extern PRInt32 _MD_AvailableSocket(PRInt32 osfd);
320
321
extern void _MD_StartInterrupts(void);
322
extern void _MD_StopInterrupts(void);
323
extern void _MD_DisableClockInterrupts(void);
324
extern void _MD_BlockClockInterrupts(void);
325
extern void _MD_UnblockClockInterrupts(void);
326
extern void _MD_PauseCPU(PRIntervalTime timeout);
327
328
extern PRStatus _MD_open_dir(struct _MDDir *, const char *);
329
extern PRInt32  _MD_close_dir(struct _MDDir *);
330
extern char *   _MD_read_dir(struct _MDDir *, PRIntn);
331
extern PRInt32  _MD_open(const char *name, PRIntn osflags, PRIntn mode);
332
extern PRInt32  _MD_delete(const char *name);
333
extern PRInt32  _MD_getfileinfo(const char *fn, PRFileInfo *info);
334
extern PRInt32  _MD_getfileinfo64(const char *fn, PRFileInfo64 *info);
335
extern PRInt32  _MD_getopenfileinfo(const PRFileDesc *fd, PRFileInfo *info);
336
extern PRInt32  _MD_getopenfileinfo64(const PRFileDesc *fd, PRFileInfo64 *info);
337
extern PRInt32  _MD_rename(const char *from, const char *to);
338
extern PRInt32  _MD_access(const char *name, PRAccessHow how);
339
extern PRInt32  _MD_mkdir(const char *name, PRIntn mode);
340
extern PRInt32  _MD_rmdir(const char *name);
341
extern PRInt32  _MD_accept_read(PRInt32 sock, PRInt32 *newSock,
342
                                PRNetAddr **raddr, void *buf, PRInt32 amount);
343
extern PRInt32  _PR_UnixSendFile(PRFileDesc *sd, PRSendFileData *sfd,
344
                                 PRTransmitFileFlags flags, PRIntervalTime timeout);
345
346
extern PRStatus _MD_LockFile(PRInt32 osfd);
347
extern PRStatus _MD_TLockFile(PRInt32 osfd);
348
extern PRStatus _MD_UnlockFile(PRInt32 osfd);
349
350
#define _MD_OPEN_DIR(dir, name)         _MD_open_dir(dir, name)
351
#define _MD_CLOSE_DIR(dir)              _MD_close_dir(dir)
352
#define _MD_READ_DIR(dir, flags)        _MD_read_dir(dir, flags)
353
#define _MD_OPEN(name, osflags, mode)   _MD_open(name, osflags, mode)
354
#define _MD_OPEN_FILE(name, osflags, mode)  _MD_open(name, osflags, mode)
355
extern PRInt32 _MD_read(PRFileDesc *fd, void *buf, PRInt32 amount);
356
#define _MD_READ(fd,buf,amount)         _MD_read(fd,buf,amount)
357
extern PRInt32 _MD_write(PRFileDesc *fd, const void *buf, PRInt32 amount);
358
#define _MD_WRITE(fd,buf,amount)        _MD_write(fd,buf,amount)
359
#define _MD_DELETE(name)                _MD_delete(name)
360
0
#define _MD_GETFILEINFO(fn, info)       _MD_getfileinfo(fn, info)
361
0
#define _MD_GETFILEINFO64(fn, info)     _MD_getfileinfo64(fn, info)
362
0
#define _MD_GETOPENFILEINFO(fd, info)   _MD_getopenfileinfo(fd, info)
363
0
#define _MD_GETOPENFILEINFO64(fd, info) _MD_getopenfileinfo64(fd, info)
364
#define _MD_RENAME(from, to)            _MD_rename(from, to)
365
#define _MD_ACCESS(name, how)           _MD_access(name, how)
366
#define _MD_MKDIR(name, mode)           _MD_mkdir(name, mode)
367
#define _MD_MAKE_DIR(name, mode)        _MD_mkdir(name, mode)
368
#define _MD_RMDIR(name)                 _MD_rmdir(name)
369
#define _MD_ACCEPT_READ(sock, newSock, raddr, buf, amount)  _MD_accept_read(sock, newSock, raddr, buf, amount)
370
371
0
#define _MD_LOCKFILE _MD_LockFile
372
0
#define _MD_TLOCKFILE _MD_TLockFile
373
0
#define _MD_UNLOCKFILE _MD_UnlockFile
374
375
376
extern PRInt32      _MD_socket(int af, int type, int flags);
377
#define _MD_SOCKET  _MD_socket
378
extern PRInt32      _MD_connect(PRFileDesc *fd, const PRNetAddr *addr,
379
                                PRUint32 addrlen, PRIntervalTime timeout);
380
#define _MD_CONNECT _MD_connect
381
extern PRInt32      _MD_accept(PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen,
382
                               PRIntervalTime timeout);
383
#define _MD_ACCEPT  _MD_accept
384
extern PRInt32      _MD_bind(PRFileDesc *fd, const PRNetAddr *addr, PRUint32 addrlen);
385
#define _MD_BIND    _MD_bind
386
extern PRInt32      _MD_listen(PRFileDesc *fd, PRIntn backlog);
387
#define _MD_LISTEN  _MD_listen
388
extern PRInt32      _MD_shutdown(PRFileDesc *fd, PRIntn how);
389
#define _MD_SHUTDOWN    _MD_shutdown
390
391
extern PRInt32      _MD_recv(PRFileDesc *fd, void *buf, PRInt32 amount,
392
                             PRIntn flags, PRIntervalTime timeout);
393
#define _MD_RECV    _MD_recv
394
extern PRInt32      _MD_send(PRFileDesc *fd, const void *buf, PRInt32 amount,
395
                             PRIntn flags, PRIntervalTime timeout);
396
#define _MD_SEND    _MD_send
397
extern PRInt32      _MD_recvfrom(PRFileDesc *fd, void *buf, PRInt32 amount,
398
                                 PRIntn flags, PRNetAddr *addr, PRUint32 *addrlen,
399
                                 PRIntervalTime timeout);
400
#define _MD_RECVFROM    _MD_recvfrom
401
extern PRInt32 _MD_sendto(PRFileDesc *fd, const void *buf, PRInt32 amount,
402
                          PRIntn flags, const PRNetAddr *addr, PRUint32 addrlen,
403
                          PRIntervalTime timeout);
404
#define _MD_SENDTO  _MD_sendto
405
extern PRInt32      _MD_writev(PRFileDesc *fd, const struct PRIOVec *iov,
406
                               PRInt32 iov_size, PRIntervalTime timeout);
407
#define _MD_WRITEV  _MD_writev
408
409
extern PRInt32      _MD_socketavailable(PRFileDesc *fd);
410
#define _MD_SOCKETAVAILABLE     _MD_socketavailable
411
extern PRInt64      _MD_socketavailable64(PRFileDesc *fd);
412
#define _MD_SOCKETAVAILABLE64       _MD_socketavailable64
413
414
#define _MD_PIPEAVAILABLE       _MD_socketavailable
415
416
extern PRInt32 _MD_pr_poll(PRPollDesc *pds, PRIntn npds,
417
                           PRIntervalTime timeout);
418
#define _MD_PR_POLL     _MD_pr_poll
419
420
extern PRInt32      _MD_close(PRInt32 osfd);
421
#define _MD_CLOSE_FILE  _MD_close
422
extern PRInt32      _MD_lseek(PRFileDesc*, PRInt32, PRSeekWhence);
423
0
#define _MD_LSEEK   _MD_lseek
424
extern PRInt64      _MD_lseek64(PRFileDesc*, PRInt64, PRSeekWhence);
425
0
#define _MD_LSEEK64 _MD_lseek64
426
extern PRInt32      _MD_fsync(PRFileDesc *fd);
427
#define _MD_FSYNC   _MD_fsync
428
429
extern PRInt32 _MD_socketpair(int af, int type, int flags, PRInt32 *osfd);
430
#define _MD_SOCKETPAIR      _MD_socketpair
431
432
#define _MD_CLOSE_SOCKET    _MD_close
433
434
#ifndef NO_NSPR_10_SUPPORT
435
#define _MD_STAT    stat
436
#endif
437
438
extern PRStatus _MD_getpeername(PRFileDesc *fd, PRNetAddr *addr,
439
                                PRUint32 *addrlen);
440
#define _MD_GETPEERNAME _MD_getpeername
441
extern PRStatus _MD_getsockname(PRFileDesc *fd, PRNetAddr *addr,
442
                                PRUint32 *addrlen);
443
#define _MD_GETSOCKNAME _MD_getsockname
444
445
extern PRStatus _MD_getsockopt(PRFileDesc *fd, PRInt32 level,
446
                               PRInt32 optname, char* optval, PRInt32* optlen);
447
#define _MD_GETSOCKOPT      _MD_getsockopt
448
extern PRStatus _MD_setsockopt(PRFileDesc *fd, PRInt32 level,
449
                               PRInt32 optname, const char* optval, PRInt32 optlen);
450
#define _MD_SETSOCKOPT      _MD_setsockopt
451
452
extern PRStatus _MD_set_fd_inheritable(PRFileDesc *fd, PRBool inheritable);
453
#define _MD_SET_FD_INHERITABLE _MD_set_fd_inheritable
454
455
extern void _MD_init_fd_inheritable(PRFileDesc *fd, PRBool imported);
456
#define _MD_INIT_FD_INHERITABLE _MD_init_fd_inheritable
457
458
extern void _MD_query_fd_inheritable(PRFileDesc *fd);
459
0
#define _MD_QUERY_FD_INHERITABLE _MD_query_fd_inheritable
460
461
extern PRStatus _MD_gethostname(char *name, PRUint32 namelen);
462
0
#define _MD_GETHOSTNAME     _MD_gethostname
463
464
extern PRStatus _MD_getsysinfo(PRSysInfo cmd, char *name, PRUint32 namelen);
465
0
#define _MD_GETSYSINFO      _MD_getsysinfo
466
467
extern int _MD_unix_get_nonblocking_connect_error(int osfd);
468
469
/* Memory-mapped files */
470
471
struct _MDFileMap {
472
    PRIntn prot;
473
    PRIntn flags;
474
    PRBool isAnonFM; /* when true, PR_CloseFileMap() must close the related fd */
475
};
476
477
extern PRStatus _MD_CreateFileMap(struct PRFileMap *fmap, PRInt64 size);
478
0
#define _MD_CREATE_FILE_MAP _MD_CreateFileMap
479
480
0
#define _MD_GET_MEM_MAP_ALIGNMENT() PR_GetPageSize()
481
482
extern void * _MD_MemMap(struct PRFileMap *fmap, PRInt64 offset,
483
                         PRUint32 len);
484
0
#define _MD_MEM_MAP _MD_MemMap
485
486
extern PRStatus _MD_MemUnmap(void *addr, PRUint32 size);
487
0
#define _MD_MEM_UNMAP _MD_MemUnmap
488
489
extern PRStatus _MD_CloseFileMap(struct PRFileMap *fmap);
490
0
#define _MD_CLOSE_FILE_MAP _MD_CloseFileMap
491
492
extern PRStatus _MD_SyncMemMap(
493
    PRFileDesc *fd,
494
    void *addr,
495
    PRUint32 len);
496
0
#define _MD_SYNC_MEM_MAP _MD_SyncMemMap
497
498
/*
499
 * The standard (XPG4) gettimeofday() (from BSD) takes two arguments.
500
 * On some SVR4 derivatives, gettimeofday() takes only one argument.
501
 * The GETTIMEOFDAY macro is intended to hide this difference.
502
 */
503
#ifdef HAVE_SVID_GETTOD
504
#define GETTIMEOFDAY(tp) gettimeofday(tp)
505
#else
506
0
#define GETTIMEOFDAY(tp) gettimeofday((tp), NULL)
507
#endif
508
509
#if defined(_PR_PTHREADS) && !defined(_PR_POLL_AVAILABLE)
510
#define _PR_NEED_FAKE_POLL
511
#endif
512
513
#if defined(_PR_NEED_FAKE_POLL)
514
515
/*
516
 * Some platforms don't have poll(), but our pthreads code calls poll().
517
 * As a temporary measure, I implemented a fake poll() using select().
518
 * Here are the struct and macro definitions copied from sys/poll.h
519
 * on Solaris 2.5.
520
 */
521
522
struct pollfd {
523
    int fd;
524
    short events;
525
    short revents;
526
};
527
528
/* poll events */
529
530
#define POLLIN      0x0001      /* fd is readable */
531
#define POLLPRI     0x0002      /* high priority info at fd */
532
#define POLLOUT     0x0004      /* fd is writeable (won't block) */
533
#define POLLRDNORM  0x0040      /* normal data is readable */
534
#define POLLWRNORM  POLLOUT
535
#define POLLRDBAND  0x0080      /* out-of-band data is readable */
536
#define POLLWRBAND  0x0100      /* out-of-band data is writeable */
537
538
#define POLLNORM    POLLRDNORM
539
540
#define POLLERR     0x0008      /* fd has error condition */
541
#define POLLHUP     0x0010      /* fd has been hung up on */
542
#define POLLNVAL    0x0020      /* invalid pollfd entry */
543
544
extern int poll(struct pollfd *, unsigned long, int);
545
546
#endif /* _PR_NEED_FAKE_POLL */
547
548
/*
549
** A vector of the UNIX I/O calls we use. These are here to smooth over
550
** the rough edges needed for large files. All of NSPR's implmentaions
551
** go through this vector using syntax of the form
552
**      result = _md_iovector.xxx64(args);
553
*/
554
555
#if defined(SOLARIS2_5)
556
/*
557
** Special case: Solaris 2.5.1
558
** Solaris starts to have 64-bit file I/O in 2.6.  We build on Solaris
559
** 2.5.1 so that we can use the same binaries on both Solaris 2.5.1 and
560
** 2.6.  At run time, we detect whether 64-bit file I/O is available by
561
** looking up the 64-bit file function symbols in libc.  At build time,
562
** we need to define the 64-bit file I/O datatypes that are compatible
563
** with their definitions on Solaris 2.6.
564
*/
565
typedef PRInt64 off64_t;
566
typedef PRUint64 ino64_t;
567
typedef PRInt64 blkcnt64_t;
568
struct stat64 {
569
    dev_t st_dev;
570
    long st_pad1[3];
571
    ino64_t st_ino;
572
    mode_t st_mode;
573
    nlink_t st_nlink;
574
    uid_t st_uid;
575
    gid_t st_gid;
576
    dev_t st_rdev;
577
    long t_pad2[2];
578
    off64_t st_size;
579
    timestruc_t st_atim;
580
    timestruc_t st_mtim;
581
    timestruc_t st_ctim;
582
    long st_blksize;
583
    blkcnt64_t st_blocks;
584
    char st_fstype[_ST_FSTYPSZ];
585
    long st_pad4[8];
586
};
587
typedef struct stat64 _MDStat64;
588
typedef off64_t _MDOff64_t;
589
590
#elif defined(_PR_HAVE_OFF64_T)
591
typedef struct stat64 _MDStat64;
592
typedef off64_t _MDOff64_t;
593
#elif defined(_PR_HAVE_LARGE_OFF_T)
594
typedef struct stat _MDStat64;
595
typedef off_t _MDOff64_t;
596
#elif defined(_PR_NO_LARGE_FILES)
597
typedef struct stat _MDStat64;
598
typedef PRInt64 _MDOff64_t;
599
#else
600
#error "I don't know yet"
601
#endif
602
603
typedef PRIntn (*_MD_Fstat64)(PRIntn osfd, _MDStat64 *buf);
604
typedef PRIntn (*_MD_Open64)(const char *path, int oflag, ...);
605
typedef PRIntn (*_MD_Stat64)(const char *path, _MDStat64 *buf);
606
typedef _MDOff64_t (*_MD_Lseek64)(PRIntn osfd, _MDOff64_t, PRIntn whence);
607
typedef void* (*_MD_Mmap64)(
608
    void *addr, PRSize len, PRIntn prot, PRIntn flags,
609
    PRIntn fildes, _MDOff64_t offset);
610
struct _MD_IOVector
611
{
612
    _MD_Open64 _open64;
613
    _MD_Mmap64 _mmap64;
614
    _MD_Stat64 _stat64;
615
    _MD_Fstat64 _fstat64;
616
    _MD_Lseek64 _lseek64;
617
};
618
extern struct _MD_IOVector _md_iovector;
619
620
#endif /* prunixos_h___ */