diff options
Diffstat (limited to 'pr/include')
67 files changed, 3872 insertions, 439 deletions
diff --git a/pr/include/MANIFEST b/pr/include/MANIFEST index 9cb2adea..6ef1b6d0 100644 --- a/pr/include/MANIFEST +++ b/pr/include/MANIFEST @@ -7,6 +7,7 @@ pratom.h prbit.h prclist.h prcmon.h +prcountr.h prcvar.h prdtoa.h prenv.h @@ -23,13 +24,16 @@ prmem.h prmon.h prmwait.h prnetdb.h +prolock.h prpdce.h prprf.h prproces.h prsystem.h prthread.h prtime.h +prtrace.h prtypes.h +prvrsion.h prwin16.h obsolete/protypes.h @@ -39,6 +43,3 @@ obsolete/probslet.h private/prpriv.h private/pprio.h private/pprthred.h - -md/prosdep.h -md/_macos.h diff --git a/pr/include/md/Makefile b/pr/include/md/Makefile index afb752ea..a365ef91 100644 --- a/pr/include/md/Makefile +++ b/pr/include/md/Makefile @@ -24,7 +24,11 @@ HEADERS = $(wildcard *.h) include $(MOD_DEPTH)/config/rules.mk ifeq ($(OS_ARCH),IRIX) -MDCPUCFG_H = _irix.cfg +ifeq ($(USE_64), 1) +MDCPUCFG_H = _irix64.cfg +else +MDCPUCFG_H = _irix32.cfg +endif endif ifeq ($(OS_ARCH),WINNT) @@ -55,12 +59,20 @@ ifeq ($(OS_ARCH),FreeBSD) MDCPUCFG_H = _freebsd.cfg endif +ifeq ($(OS_ARCH),OpenBSD) +MDCPUCFG_H = _openbsd.cfg +endif + ifeq ($(OS_ARCH),NetBSD) MDCPUCFG_H = _netbsd.cfg endif ifeq ($(OS_ARCH),HP-UX) -MDCPUCFG_H = _hpux.cfg +ifeq ($(USE_64), 1) +MDCPUCFG_H = _hpux64.cfg +else +MDCPUCFG_H = _hpux32.cfg +endif endif ifeq ($(OS_ARCH),Linux) diff --git a/pr/include/md/_aix.h b/pr/include/md/_aix.h index 7ea19b7f..cc7906c8 100644 --- a/pr/include/md/_aix.h +++ b/pr/include/md/_aix.h @@ -54,15 +54,31 @@ #define HAVE_DLL #define USE_DLFCN #define _PR_HAVE_SOCKADDR_LEN +#define _PR_POLL_AVAILABLE +#define _PR_USE_POLL +#define _PR_STAT_HAS_ONLY_ST_ATIME +/* Timer operations */ +#define AIX_TIMERS +#if defined(AIX_TIMERS) +extern PRIntervalTime _MD_AixGetInterval(void); +#define _MD_GET_INTERVAL _MD_AixGetInterval + +extern PRIntervalTime _MD_AixIntervalPerSec(void); +#define _MD_INTERVAL_PER_SEC _MD_AixIntervalPerSec + +#else /* defined(AIX_TIMERS) */ #define _MD_GET_INTERVAL _PR_UNIX_GetInterval #define _MD_INTERVAL_PER_SEC _PR_UNIX_TicksPerSecond +#endif /* defined(AIX_TIMERS) */ /* The atomic operations */ #include <sys/atomic_op.h> #define _PR_HAVE_ATOMIC_OPS +#define _PR_HAVE_ATOMIC_CAS #define _MD_INIT_ATOMIC() #define _MD_ATOMIC_INCREMENT(val) ((PRInt32)fetch_and_add((atomic_p)val, 1) + 1) +#define _MD_ATOMIC_ADD(ptr, val) ((PRInt32)fetch_and_add((atomic_p)ptr, val) + val) #define _MD_ATOMIC_DECREMENT(val) ((PRInt32)fetch_and_add((atomic_p)val, -1) - 1) #define _MD_ATOMIC_SET(val, newval) _AIX_AtomicSet(val, newval) @@ -138,6 +154,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; diff --git a/pr/include/md/_bsdi.h b/pr/include/md/_bsdi.h index 3e3eca9f..2639b2e3 100644 --- a/pr/include/md/_bsdi.h +++ b/pr/include/md/_bsdi.h @@ -37,6 +37,8 @@ #define HAVE_BSD_FLOCK #define NEED_TIME_R #define _PR_HAVE_SOCKADDR_LEN +#define _PR_STAT_HAS_ST_ATIMESPEC +#define _PR_NO_LARGE_FILES #if defined(BSDI_2) #define PROT_NONE 0x0 @@ -110,6 +112,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; diff --git a/pr/include/md/_darwin.cfg b/pr/include/md/_darwin.cfg index 73fc491c..a0787fc9 100644 --- a/pr/include/md/_darwin.cfg +++ b/pr/include/md/_darwin.cfg @@ -27,8 +27,14 @@ #define RHAPOSDY #endif +#if defined(i386) +#undef IS_BIG_ENDIAN +#define IS_LITTLE_ENDIAN 1 +#else #undef IS_LITTLE_ENDIAN #define IS_BIG_ENDIAN 1 +#endif + #define HAVE_LONG_LONG #undef HAVE_ALIGNED_DOUBLES #define HAVE_ALIGNED_LONGLONGS 1 @@ -53,6 +59,7 @@ #define PR_BITS_PER_FLOAT 32 #define PR_BITS_PER_DOUBLE 64 #define PR_BITS_PER_WORD 32 +#define PR_BITS_PER_DWORD 64 #define PR_BITS_PER_BYTE_LOG2 3 #define PR_BITS_PER_SHORT_LOG2 4 @@ -117,3 +124,4 @@ #endif /* NO_NSPR_10_SUPPORT */ #endif /* nspr_cpucfg___ */ + diff --git a/pr/include/md/_darwin.h b/pr/include/md/_darwin.h index 052da11f..476b8e38 100644 --- a/pr/include/md/_darwin.h +++ b/pr/include/md/_darwin.h @@ -38,24 +38,23 @@ #define _MD_MMAP_FLAGS MAP_PRIVATE #undef HAVE_STACK_GROWING_UP -#define HAVE_WEAK_MALLOC_SYMBOLS -/* do this until I figure out the rhapsody dll stuff. */ #define HAVE_DLL -#define USE_RLD -#define _PR_HAVE_SOCKADDR_LEN +#define _PR_HAVE_SOCKADDR_LEN +#define _PR_STAT_HAS_ST_ATIMESPEC +#define _PR_TIMESPEC_HAS_TS_SEC +#define _PR_NO_LARGE_FILES #define USE_SETJMP -#ifndef _PR_PTHREADS +#if !defined(_PR_PTHREADS) #include <setjmp.h> #define PR_CONTEXT_TYPE jmp_buf -#define CONTEXT(_th) ((_th)->md.context) - -#define _MD_GET_SP(_th) (_th)->md.context[0] -#define PR_NUM_GCREGS _JBLEN +#define CONTEXT(_th) ((_th)->md.context) +#define _MD_GET_SP(_th) (((struct sigcontext *) (_th)->md.context)->sc_onstack) +#define PR_NUM_GCREGS _JBLEN /* ** Initialize a thread context to run "_main()" when started @@ -66,7 +65,7 @@ if (setjmp(CONTEXT(_thread))) { \ _main(); \ } \ - _MD_GET_SP(_thread) = (int) ((_sp) - 64); \ + _MD_GET_SP(_thread) = (unsigned char*) ((_sp) - 64); \ } #define _MD_SWITCH_CONTEXT(_thread) \ @@ -113,6 +112,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; @@ -149,14 +184,14 @@ extern void _MD_YIELD(void); #endif /* ! _PR_PTHREADS */ -extern void _MD_EarlyInit(void); -extern PRIntervalTime _PR_UNIX_GetInterval(void); -extern PRIntervalTime _PR_UNIX_TicksPerSecond(void); - -#define _MD_EARLY_INIT _MD_EarlyInit +#define _MD_EARLY_INIT _MD_EarlyInit #define _MD_FINAL_INIT _PR_UnixInit -#define _MD_GET_INTERVAL _PR_UNIX_GetInterval -#define _MD_INTERVAL_PER_SEC _PR_UNIX_TicksPerSecond +#define _MD_GET_INTERVAL _PR_UNIX_GetInterval +#define _MD_INTERVAL_PER_SEC _PR_UNIX_TicksPerSecond + +extern void _MD_EarlyInit(void); +extern PRIntervalTime _PR_UNIX_GetInterval(void); +extern PRIntervalTime _PR_UNIX_TicksPerSecond(void); /* * We wrapped the select() call. _MD_SELECT refers to the built-in, diff --git a/pr/include/md/_dgux.cfg b/pr/include/md/_dgux.cfg index 4fb5dd46..4cde625a 100644 --- a/pr/include/md/_dgux.cfg +++ b/pr/include/md/_dgux.cfg @@ -71,9 +71,6 @@ #define PR_ALIGN_OF_DOUBLE 4 #define PR_ALIGN_OF_POINTER 4 -#define _PR_USE_POLL -#define _PR_POLL_AVAILABLE - #ifndef NO_NSPR_10_SUPPORT #define BYTES_PER_BYTE PR_BYTES_PER_BYTE diff --git a/pr/include/md/_dgux.h b/pr/include/md/_dgux.h index 2c3e4f49..f428e03a 100644 --- a/pr/include/md/_dgux.h +++ b/pr/include/md/_dgux.h @@ -44,6 +44,8 @@ #define NEED_STRFTIME_LOCK #define NEED_TIME_R #define _PR_NEED_STRCASECMP +#define _PR_POLL_AVAILABLE +#define _PR_USE_POLL #define USE_SETJMP diff --git a/pr/include/md/_freebsd.h b/pr/include/md/_freebsd.h index 916c11c2..6e459fb5 100644 --- a/pr/include/md/_freebsd.h +++ b/pr/include/md/_freebsd.h @@ -37,6 +37,8 @@ #define HAVE_DLL #define USE_DLFCN #define _PR_HAVE_SOCKADDR_LEN +#define _PR_STAT_HAS_ST_ATIMESPEC +#define _PR_NO_LARGE_FILES #define USE_SETJMP @@ -106,6 +108,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; diff --git a/pr/include/md/_hpux.h b/pr/include/md/_hpux.h index 2675a97e..f9e312a4 100644 --- a/pr/include/md/_hpux.h +++ b/pr/include/md/_hpux.h @@ -43,6 +43,9 @@ #ifndef HAVE_STRERROR #define HAVE_STRERROR #endif +#define _PR_POLL_AVAILABLE +#define _PR_USE_POLL +#define _PR_STAT_HAS_ONLY_ST_ATIME #undef _PR_HAVE_ATOMIC_OPS @@ -117,6 +120,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; @@ -150,8 +189,16 @@ struct _MDCPU { #define _MD_FINAL_INIT _PR_UnixInit #endif +#if defined(HPUX_LW_TIMER) +extern void _PR_HPUX_LW_IntervalInit(void); +extern PRIntervalTime _PR_HPUX_LW_GetInterval(void); +#define _MD_INTERVAL_INIT _PR_HPUX_LW_IntervalInit +#define _MD_GET_INTERVAL _PR_HPUX_LW_GetInterval +#define _MD_INTERVAL_PER_SEC() 1000 +#else #define _MD_GET_INTERVAL _PR_UNIX_GetInterval #define _MD_INTERVAL_PER_SEC _PR_UNIX_TicksPerSecond +#endif /* * We wrapped the select() call. _MD_SELECT refers to the built-in, @@ -160,8 +207,6 @@ struct _MDCPU { #define _MD_SELECT(nfds,r,w,e,tv) syscall(SYS_select,nfds,r,w,e,tv) #define _MD_POLL(fds,nfds,timeout) syscall(SYS_poll,fds,nfds,timeout) -extern void _MD_hpux_install_sigfpe_handler(void); - #ifdef HPUX11 extern void _MD_hpux_map_sendfile_error(int err); #if !defined(_PR_PTHREADS) diff --git a/pr/include/md/_hpux.cfg b/pr/include/md/_hpux32.cfg index 885af381..2889f693 100644 --- a/pr/include/md/_hpux.cfg +++ b/pr/include/md/_hpux32.cfg @@ -69,9 +69,9 @@ #define PR_ALIGN_OF_DOUBLE 8 #define PR_ALIGN_OF_POINTER 4 -#undef HAVE_LONG_LONG +#define HAVE_LONG_LONG #define HAVE_ALIGNED_DOUBLES -#undef HAVE_ALIGNED_LONGLONGS +#define HAVE_ALIGNED_LONGLONGS #ifndef NO_NSPR_10_SUPPORT diff --git a/pr/include/md/_hpux64.cfg b/pr/include/md/_hpux64.cfg new file mode 100644 index 00000000..f790215c --- /dev/null +++ b/pr/include/md/_hpux64.cfg @@ -0,0 +1,122 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef nspr_cpucfg___ +#define nspr_cpucfg___ + +#ifndef XP_UNIX +#define XP_UNIX +#endif + +#ifndef HPUX +#define HPUX +#endif + +#undef IS_LITTLE_ENDIAN +#define IS_BIG_ENDIAN 1 +#define IS_64 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 8 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 8 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BYTES_PER_WORD_LOG2 3 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 64 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 64 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 6 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 6 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 4 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 8 + +#define HAVE_LONG_LONG +#define HAVE_ALIGNED_DOUBLES +#define HAVE_ALIGNED_LONGLONGS + +#ifndef NO_NSPR_10_SUPPORT + +#define BYTES_PER_BYTE PR_BYTES_PER_BYTE +#define BYTES_PER_SHORT PR_BYTES_PER_SHORT +#define BYTES_PER_INT PR_BYTES_PER_INT +#define BYTES_PER_INT64 PR_BYTES_PER_INT64 +#define BYTES_PER_LONG PR_BYTES_PER_LONG +#define BYTES_PER_FLOAT PR_BYTES_PER_FLOAT +#define BYTES_PER_DOUBLE PR_BYTES_PER_DOUBLE +#define BYTES_PER_WORD PR_BYTES_PER_WORD +#define BYTES_PER_DWORD PR_BYTES_PER_DWORD + +#define BITS_PER_BYTE PR_BITS_PER_BYTE +#define BITS_PER_SHORT PR_BITS_PER_SHORT +#define BITS_PER_INT PR_BITS_PER_INT +#define BITS_PER_INT64 PR_BITS_PER_INT64 +#define BITS_PER_LONG PR_BITS_PER_LONG +#define BITS_PER_FLOAT PR_BITS_PER_FLOAT +#define BITS_PER_DOUBLE PR_BITS_PER_DOUBLE +#define BITS_PER_WORD PR_BITS_PER_WORD + +#define BITS_PER_BYTE_LOG2 PR_BITS_PER_BYTE_LOG2 +#define BITS_PER_SHORT_LOG2 PR_BITS_PER_SHORT_LOG2 +#define BITS_PER_INT_LOG2 PR_BITS_PER_INT_LOG2 +#define BITS_PER_INT64_LOG2 PR_BITS_PER_INT64_LOG2 +#define BITS_PER_LONG_LOG2 PR_BITS_PER_LONG_LOG2 +#define BITS_PER_FLOAT_LOG2 PR_BITS_PER_FLOAT_LOG2 +#define BITS_PER_DOUBLE_LOG2 PR_BITS_PER_DOUBLE_LOG2 +#define BITS_PER_WORD_LOG2 PR_BITS_PER_WORD_LOG2 + +#define ALIGN_OF_SHORT PR_ALIGN_OF_SHORT +#define ALIGN_OF_INT PR_ALIGN_OF_INT +#define ALIGN_OF_LONG PR_ALIGN_OF_LONG +#define ALIGN_OF_INT64 PR_ALIGN_OF_INT64 +#define ALIGN_OF_FLOAT PR_ALIGN_OF_FLOAT +#define ALIGN_OF_DOUBLE PR_ALIGN_OF_DOUBLE +#define ALIGN_OF_POINTER PR_ALIGN_OF_POINTER +#define ALIGN_OF_WORD PR_ALIGN_OF_WORD + +#define BYTES_PER_WORD_LOG2 PR_BYTES_PER_WORD_LOG2 +#define BYTES_PER_DWORD_LOG2 PR_BYTES_PER_DWORD_LOG2 +#define WORDS_PER_DWORD_LOG2 PR_WORDS_PER_DWORD_LOG2 + +#endif /* NO_NSPR_10_SUPPORT */ + +#endif /* nspr_cpucfg___ */ diff --git a/pr/include/md/_irix.h b/pr/include/md/_irix.h index 694b809b..b6b2b034 100644 --- a/pr/include/md/_irix.h +++ b/pr/include/md/_irix.h @@ -19,6 +19,13 @@ #ifndef nspr_irix_defs_h___ #define nspr_irix_defs_h___ +#define _PR_HAVE_ATOMIC_CAS + +/* + * MipsPro assembler defines _LANGUAGE_ASSEMBLY + */ +#ifndef _LANGUAGE_ASSEMBLY + #include "prclist.h" #include "prthread.h" #include <sys/ucontext.h> @@ -46,6 +53,11 @@ #define HAVE_DLL #define USE_DLFCN #define _PR_HAVE_ATOMIC_OPS +#define _PR_POLL_AVAILABLE +#define _PR_USE_POLL +#define _PR_STAT_HAS_ST_ATIM +#define _PR_HAVE_OFF64_T +#define HAVE_POINTER_LOCALTIME_R /* Initialization entry points */ PR_EXTERN(void) _MD_EarlyInit(void); @@ -57,11 +69,11 @@ PR_EXTERN(void) _MD_IrixInit(void); #define _MD_INIT_IO() /* Timer operations */ -PR_EXTERN(PRIntervalTime) _MD_GetInterval(void); -#define _MD_GET_INTERVAL _MD_GetInterval +PR_EXTERN(PRIntervalTime) _MD_IrixGetInterval(void); +#define _MD_GET_INTERVAL _MD_IrixGetInterval -PR_EXTERN(PRIntervalTime) _MD_IntervalPerSec(void); -#define _MD_INTERVAL_PER_SEC _MD_IntervalPerSec +PR_EXTERN(PRIntervalTime) _MD_IrixIntervalPerSec(void); +#define _MD_INTERVAL_PER_SEC _MD_IrixIntervalPerSec /* GC operations */ PR_EXTERN(void *) _MD_GetSP(PRThread *thread); @@ -71,6 +83,7 @@ PR_EXTERN(void *) _MD_GetSP(PRThread *thread); #include <mutex.h> #define _MD_INIT_ATOMIC() #define _MD_ATOMIC_INCREMENT(val) add_then_test((unsigned long*)val, 1) +#define _MD_ATOMIC_ADD(ptr, val) add_then_test((unsigned long*)ptr, (unsigned long)val) #define _MD_ATOMIC_DECREMENT(val) add_then_test((unsigned long*)val, 0xffffffff) #define _MD_ATOMIC_SET(val, newval) test_and_set((unsigned long*)val, newval) @@ -107,8 +120,8 @@ struct sproc_private_data { extern char *_nspr_sproc_private; #define _PR_PRDA() ((struct sproc_private_data *) _nspr_sproc_private) -#define _MD_CURRENT_THREAD() (_PR_PRDA()->me) #define _MD_SET_CURRENT_THREAD(_thread) _PR_PRDA()->me = (_thread) +#define _MD_THIS_THREAD() (_PR_PRDA()->me) #define _MD_LAST_THREAD() (_PR_PRDA()->last) #define _MD_SET_LAST_THREAD(_thread) _PR_PRDA()->last = (_thread) #define _MD_CURRENT_CPU() (_PR_PRDA()->cpu) @@ -120,13 +133,16 @@ extern char *_nspr_sproc_private; #define _MD_GET_SPROC_PID() (_PR_PRDA()->sproc_pid) PR_EXTERN(struct PRThread*) _MD_get_attached_thread(void); +PR_EXTERN(struct PRThread*) _MD_get_current_thread(void); #define _MD_GET_ATTACHED_THREAD() _MD_get_attached_thread() +#define _MD_CURRENT_THREAD() _MD_get_current_thread() #define _MD_CHECK_FOR_EXIT() { \ - if (_pr_irix_exit_now) { \ + if (_pr_irix_exit_now) { \ _PR_POST_SEM(_pr_irix_exit_sem); \ - exit(0); \ - } \ + _MD_Wakeup_CPUs(); \ + _exit(0); \ + } \ } #define _MD_ATTACH_THREAD(threadp) @@ -137,23 +153,26 @@ PR_EXTERN(struct PRThread*) _MD_get_attached_thread(void); extern struct _PRCPU *_pr_primordialCPU; extern usema_t *_pr_irix_exit_sem; extern PRInt32 _pr_irix_exit_now; +extern int _pr_irix_primoridal_cpu_fd[]; +extern PRInt32 _pr_irix_process_exit; +extern PRInt32 _pr_irix_process_exit_code; /* Thread operations */ #define _PR_LOCK_HEAP() { \ PRIntn _is; \ if (_pr_primordialCPU) { \ - if (_PR_MD_CURRENT_THREAD() && \ + if (_MD_GET_ATTACHED_THREAD() && \ !_PR_IS_NATIVE_THREAD( \ - _PR_MD_CURRENT_THREAD())) \ + _MD_GET_ATTACHED_THREAD())) \ _PR_INTSOFF(_is); \ _PR_LOCK(_pr_heapLock); \ } #define _PR_UNLOCK_HEAP() if (_pr_primordialCPU) { \ _PR_UNLOCK(_pr_heapLock); \ - if (_PR_MD_CURRENT_THREAD() && \ + if (_MD_GET_ATTACHED_THREAD() && \ !_PR_IS_NATIVE_THREAD( \ - _PR_MD_CURRENT_THREAD())) \ + _MD_GET_ATTACHED_THREAD())) \ _PR_INTSON(_is); \ } \ } @@ -179,7 +198,7 @@ struct _MDLock { #define _PR_LOCK(lock) { \ PRIntn _is; \ - PRThread *me = _PR_MD_CURRENT_THREAD(); \ + PRThread *me = _MD_GET_ATTACHED_THREAD(); \ if (me && !_PR_IS_NATIVE_THREAD(me)) \ _PR_INTSOFF(_is); \ ussetlock(lock); \ @@ -189,7 +208,7 @@ struct _MDLock { #define _PR_UNLOCK(lock) { \ PRIntn _is; \ - PRThread *me = _PR_MD_CURRENT_THREAD(); \ + PRThread *me = _MD_GET_ATTACHED_THREAD(); \ if (me && !_PR_IS_NATIVE_THREAD(me)) \ _PR_INTSOFF(_is); \ usunsetlock(lock); \ @@ -216,9 +235,6 @@ struct _MDThread { PRInt32 id; PRInt32 suspending_id; int errcode; - PRStatus *creation_status; /* points to the variable in which - * a newly created child thread is - * to store its creation status */ }; struct _MDThreadStack { @@ -237,6 +253,43 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + + struct _MDCPU { PRInt32 id; PRInt32 suspending_id; @@ -290,9 +343,13 @@ struct _MDCPU { longjmp(jb, 1); \ PR_END_MACRO -PR_EXTERN(PRStatus) _MD_InitThread(struct PRThread *thread, PRBool wakeup_parent); +PR_EXTERN(PRStatus) _MD_InitThread(struct PRThread *thread, + PRBool wakeup_parent); +PR_EXTERN(PRStatus) _MD_InitAttachedThread(struct PRThread *thread, + PRBool wakeup_parent); #define _MD_INIT_THREAD(thread) _MD_InitThread(thread, PR_TRUE) -#define _MD_INIT_ATTACHED_THREAD(thread) _MD_InitThread(thread, PR_FALSE) +#define _MD_INIT_ATTACHED_THREAD(thread) \ + _MD_InitAttachedThread(thread, PR_FALSE) PR_EXTERN(void) _MD_ExitThread(struct PRThread *thread); #define _MD_EXIT_THREAD _MD_ExitThread @@ -329,6 +386,9 @@ PR_EXTERN(void) _MD_CleanThread(struct PRThread *thread); PR_EXTERN(PRStatus) _MD_wait(struct PRThread *, PRIntervalTime timeout); #define _MD_WAIT _MD_wait +PR_EXTERN(void) _PR_MD_primordial_cpu(); +PR_EXTERN(void) _PR_MD_WAKEUP_PRIMORDIAL_CPU(); + PR_EXTERN(PRStatus) _MD_WakeupWaiter(struct PRThread *); #define _MD_WAKEUP_WAITER _MD_WakeupWaiter @@ -353,6 +413,8 @@ PR_EXTERN(PRStatus) _MD_CreateThread( extern void _MD_CleanupBeforeExit(void); #define _MD_CLEANUP_BEFORE_EXIT _MD_CleanupBeforeExit +PR_EXTERN(void) _PR_MD_PRE_CLEANUP(PRThread *me); + /* The following defines the unwrapped versions of select() and poll(). */ extern int _select(int nfds, fd_set *readfds, fd_set *writefds, @@ -375,4 +437,6 @@ PR_EXTERN(void) _MD_InitRunningCPU(struct _PRCPU *cpu); #endif /* defined(_PR_PTHREADS) */ +#endif /* _LANGUAGE_ASSEMBLY */ + #endif /* nspr_irix_defs_h___ */ diff --git a/pr/include/md/_irix.cfg b/pr/include/md/_irix32.cfg index 2070760b..c5016880 100644 --- a/pr/include/md/_irix.cfg +++ b/pr/include/md/_irix32.cfg @@ -78,8 +78,7 @@ #define HAVE_ALIGNED_DOUBLES #define HAVE_ALIGNED_LONGLONGS -#define _PR_POLL_AVAILABLE -#define _PR_USE_POLL +#define _PR_POLL_BACKCOMPAT #ifndef NO_NSPR_10_SUPPORT diff --git a/pr/include/md/_irix64.cfg b/pr/include/md/_irix64.cfg new file mode 100644 index 00000000..7df5f997 --- /dev/null +++ b/pr/include/md/_irix64.cfg @@ -0,0 +1,127 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef nspr_cpucfg___ +#define nspr_cpucfg___ + +#ifndef _SGI_MP_SOURCE +#define _SGI_MP_SOURCE +#endif + +#ifndef XP_UNIX +#define XP_UNIX +#endif + +#ifndef IRIX +#define IRIX +#endif + +#undef IS_LITTLE_ENDIAN +#define IS_BIG_ENDIAN 1 +#define IS_64 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 8 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 8 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 64 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 64 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 6 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 6 + +#define PR_BYTES_PER_WORD_LOG2 3 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 4 +#define PR_ALIGN_OF_WORD 4 + +#define HAVE_LONG_LONG +#define HAVE_ALIGNED_DOUBLES +#define HAVE_ALIGNED_LONGLONGS + +#ifndef NO_NSPR_10_SUPPORT + +#define BYTES_PER_BYTE PR_BYTES_PER_BYTE +#define BYTES_PER_SHORT PR_BYTES_PER_SHORT +#define BYTES_PER_INT PR_BYTES_PER_INT +#define BYTES_PER_INT64 PR_BYTES_PER_INT64 +#define BYTES_PER_LONG PR_BYTES_PER_LONG +#define BYTES_PER_FLOAT PR_BYTES_PER_FLOAT +#define BYTES_PER_DOUBLE PR_BYTES_PER_DOUBLE +#define BYTES_PER_WORD PR_BYTES_PER_WORD +#define BYTES_PER_DWORD PR_BYTES_PER_DWORD + +#define BITS_PER_BYTE PR_BITS_PER_BYTE +#define BITS_PER_SHORT PR_BITS_PER_SHORT +#define BITS_PER_INT PR_BITS_PER_INT +#define BITS_PER_INT64 PR_BITS_PER_INT64 +#define BITS_PER_LONG PR_BITS_PER_LONG +#define BITS_PER_FLOAT PR_BITS_PER_FLOAT +#define BITS_PER_DOUBLE PR_BITS_PER_DOUBLE +#define BITS_PER_WORD PR_BITS_PER_WORD + +#define BITS_PER_BYTE_LOG2 PR_BITS_PER_BYTE_LOG2 +#define BITS_PER_SHORT_LOG2 PR_BITS_PER_SHORT_LOG2 +#define BITS_PER_INT_LOG2 PR_BITS_PER_INT_LOG2 +#define BITS_PER_INT64_LOG2 PR_BITS_PER_INT64_LOG2 +#define BITS_PER_LONG_LOG2 PR_BITS_PER_LONG_LOG2 +#define BITS_PER_FLOAT_LOG2 PR_BITS_PER_FLOAT_LOG2 +#define BITS_PER_DOUBLE_LOG2 PR_BITS_PER_DOUBLE_LOG2 +#define BITS_PER_WORD_LOG2 PR_BITS_PER_WORD_LOG2 + +#define ALIGN_OF_SHORT PR_ALIGN_OF_SHORT +#define ALIGN_OF_INT PR_ALIGN_OF_INT +#define ALIGN_OF_LONG PR_ALIGN_OF_LONG +#define ALIGN_OF_INT64 PR_ALIGN_OF_INT64 +#define ALIGN_OF_FLOAT PR_ALIGN_OF_FLOAT +#define ALIGN_OF_DOUBLE PR_ALIGN_OF_DOUBLE +#define ALIGN_OF_POINTER PR_ALIGN_OF_POINTER +#define ALIGN_OF_WORD PR_ALIGN_OF_WORD + +#define BYTES_PER_WORD_LOG2 PR_BYTES_PER_WORD_LOG2 +#define BYTES_PER_DWORD_LOG2 PR_BYTES_PER_DWORD_LOG2 +#define WORDS_PER_DWORD_LOG2 PR_WORDS_PER_DWORD_LOG2 + +#endif /* NO_NSPR_10_SUPPORT */ + +#endif /* nspr_cpucfg___ */ diff --git a/pr/include/md/_linux.h b/pr/include/md/_linux.h index 0c4a5f6a..c7c33ce8 100644 --- a/pr/include/md/_linux.h +++ b/pr/include/md/_linux.h @@ -64,6 +64,14 @@ #endif #define USE_SETJMP +#define _PR_POLL_AVAILABLE +#define _PR_USE_POLL +#define _PR_STAT_HAS_ONLY_ST_ATIME +#if defined(__alpha) +#define _PR_HAVE_LARGE_OFF_T +#else +#define _PR_NO_LARGE_FILES +#endif #ifdef _PR_PTHREADS @@ -282,6 +290,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; @@ -334,7 +378,7 @@ extern PRIntervalTime _PR_UNIX_TicksPerSecond(void); #define _MD_SELECT __select #ifdef _PR_POLL_AVAILABLE -#include <poll.h> +#include <sys/poll.h> extern int __syscall_poll(struct pollfd *ufds, unsigned long int nfds, int timeout); #define _MD_POLL __syscall_poll diff --git a/pr/include/md/_macos.h b/pr/include/md/_macos.h index f1e2d5c6..ffeb1fa8 100644 --- a/pr/include/md/_macos.h +++ b/pr/include/md/_macos.h @@ -103,6 +103,7 @@ struct _MDFileDesc { #define _MD_BLOCK_CLOCK_INTERRUPTS() #define _MD_UNBLOCK_CLOCK_INTERRUPTS() #define _MD_DISABLE_CLOCK_INTERRUPTS() +#define _MD_ENABLE_CLOCK_INTERRUPTS() /* ** CPU Related definitions @@ -462,11 +463,13 @@ typedef short PROSFD; // Errors not found in the Mac StdCLib #define EACCES 13 // Permission denied #define ENOENT -43 // No such file or directory +#define EMFILE 24 // Too many open files #define _OS_INVALID_FD_VALUE -1 #define STDERR_FILENO 2 #if !defined(MAC_NSPR_STANDALONE) +#define MAC_PATH_SEPARATOR ':' #define PATH_SEPARATOR ':' #define PATH_SEPARATOR_STR ":" #define DIRECTORY_SEPARATOR '/' @@ -476,6 +479,10 @@ typedef short PROSFD; #define UNIX_THIS_DIRECTORY_STR "./" #define UNIX_PARENT_DIRECTORY_STR "../" +#define MAX_PATH 512 +#define MAX_MAC_FILENAME 31 +#define MAXPATHLEN MAX_PATH + // Alias a few names #define getenv PR_GetEnv @@ -527,6 +534,10 @@ extern void dprintf(const char *format, ...); extern PRUint8 CallCacheFlushers(size_t blockSize); #endif +enum { + kPrivateNSPREventType = 13 +}; + #if defined(MAC_NSPR_STANDALONE) extern void* reallocSmaller(void* block, size_t newSize); #endif @@ -535,7 +546,7 @@ extern void* reallocSmaller(void* block, size_t newSize); /* ** PR_GetSystemInfo related definitions */ -#define _PR_SI_SYSNAME "Mac OS" +#define _PR_SI_SYSNAME "MacOS" #define _PR_SI_ARCHITECTURE "PowerPC" /* diff --git a/pr/include/md/_ncr.cfg b/pr/include/md/_ncr.cfg index 337b933d..dde85210 100644 --- a/pr/include/md/_ncr.cfg +++ b/pr/include/md/_ncr.cfg @@ -71,8 +71,7 @@ #define PR_ALIGN_OF_DOUBLE 4 #define PR_ALIGN_OF_POINTER 4 -#define _PR_POLL_AVAILABLE -#define _PR_USE_POLL +#define _PR_POLL_BACKCOMPAT #ifndef NO_NSPR_10_SUPPORT diff --git a/pr/include/md/_ncr.h b/pr/include/md/_ncr.h index 75fa7ded..82a84e63 100644 --- a/pr/include/md/_ncr.h +++ b/pr/include/md/_ncr.h @@ -45,6 +45,9 @@ #define HAVE_WEAK_IO_SYMBOLS #endif +#define _PR_POLL_AVAILABLE +#define _PR_USE_POLL + #undef HAVE_STACK_GROWING_UP #define HAVE_NETCONFIG #define NEED_STRFTIME_LOCK @@ -124,6 +127,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; diff --git a/pr/include/md/_nec.h b/pr/include/md/_nec.h index e949dd0c..8c5e5b5e 100644 --- a/pr/include/md/_nec.h +++ b/pr/include/md/_nec.h @@ -108,6 +108,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; diff --git a/pr/include/md/_netbsd.h b/pr/include/md/_netbsd.h index 6065f370..497d658b 100644 --- a/pr/include/md/_netbsd.h +++ b/pr/include/md/_netbsd.h @@ -134,6 +134,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; diff --git a/pr/include/md/_nspr_pthread.h b/pr/include/md/_nspr_pthread.h index 312c8def..1daeb61a 100644 --- a/pr/include/md/_nspr_pthread.h +++ b/pr/include/md/_nspr_pthread.h @@ -119,6 +119,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { jmp_buf jb; pthread_t pthread; diff --git a/pr/include/md/_openbsd.cfg b/pr/include/md/_openbsd.cfg new file mode 100644 index 00000000..967d36e5 --- /dev/null +++ b/pr/include/md/_openbsd.cfg @@ -0,0 +1,262 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef nspr_cpucfg___ +#define nspr_cpucfg___ + +#ifndef XP_UNIX +#define XP_UNIX +#endif + +#ifndef OPENBSD +#define OPENBSD +#endif + +#if defined(__i386__) || defined(__arm32__) + +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN +#define HAVE_LONG_LONG +#undef HAVE_ALIGNED_DOUBLES +#undef HAVE_ALIGNED_LONGLONGS + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 4 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 4 +#define PR_ALIGN_OF_POINTER 4 + +#elif defined(__sparc__) + +#undef IS_LITTLE_ENDIAN 1 +#define IS_BIG_ENDIAN 1 +#define HAVE_LONG_LONG +#define HAVE_ALIGNED_DOUBLES +#define HAVE_ALIGNED_LONGLONGS + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 4 + +#elif defined(__alpha__) +#define IS_LITTLE_ENDIAN 1 +#undef IS_BIG_ENDIAN +#define IS_64 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 8 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 8 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 64 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 64 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 6 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 6 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 8 +#define PR_ALIGN_OF_INT64 8 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 8 +#define PR_ALIGN_OF_POINTER 8 + +#define PR_BYTES_PER_WORD_LOG2 3 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#elif defined(__powerpc__) || defined(__m68k__) + +#undef IS_LITTLE_ENDIAN +#define IS_BIG_ENDIAN 1 + +#define PR_BYTES_PER_BYTE 1 +#define PR_BYTES_PER_SHORT 2 +#define PR_BYTES_PER_INT 4 +#define PR_BYTES_PER_INT64 8 +#define PR_BYTES_PER_LONG 4 +#define PR_BYTES_PER_FLOAT 4 +#define PR_BYTES_PER_DOUBLE 8 +#define PR_BYTES_PER_WORD 4 +#define PR_BYTES_PER_DWORD 8 + +#define PR_BITS_PER_BYTE 8 +#define PR_BITS_PER_SHORT 16 +#define PR_BITS_PER_INT 32 +#define PR_BITS_PER_INT64 64 +#define PR_BITS_PER_LONG 32 +#define PR_BITS_PER_FLOAT 32 +#define PR_BITS_PER_DOUBLE 64 +#define PR_BITS_PER_WORD 32 + +#define PR_BITS_PER_BYTE_LOG2 3 +#define PR_BITS_PER_SHORT_LOG2 4 +#define PR_BITS_PER_INT_LOG2 5 +#define PR_BITS_PER_INT64_LOG2 6 +#define PR_BITS_PER_LONG_LOG2 5 +#define PR_BITS_PER_FLOAT_LOG2 5 +#define PR_BITS_PER_DOUBLE_LOG2 6 +#define PR_BITS_PER_WORD_LOG2 5 + +#define PR_ALIGN_OF_SHORT 2 +#define PR_ALIGN_OF_INT 4 +#define PR_ALIGN_OF_LONG 4 +#define PR_ALIGN_OF_INT64 4 +#define PR_ALIGN_OF_FLOAT 4 +#define PR_ALIGN_OF_DOUBLE 4 +#define PR_ALIGN_OF_POINTER 4 + +#define PR_BYTES_PER_WORD_LOG2 2 +#define PR_BYTES_PER_DWORD_LOG2 3 + +#else + +#error Must define constants for type sizes here. + +#endif + + +#ifndef NO_NSPR_10_SUPPORT + +#define BYTES_PER_BYTE PR_BYTES_PER_BYTE +#define BYTES_PER_SHORT PR_BYTES_PER_SHORT +#define BYTES_PER_INT PR_BYTES_PER_INT +#define BYTES_PER_INT64 PR_BYTES_PER_INT64 +#define BYTES_PER_LONG PR_BYTES_PER_LONG +#define BYTES_PER_FLOAT PR_BYTES_PER_FLOAT +#define BYTES_PER_DOUBLE PR_BYTES_PER_DOUBLE +#define BYTES_PER_WORD PR_BYTES_PER_WORD +#define BYTES_PER_DWORD PR_BYTES_PER_DWORD + +#define BITS_PER_BYTE PR_BITS_PER_BYTE +#define BITS_PER_SHORT PR_BITS_PER_SHORT +#define BITS_PER_INT PR_BITS_PER_INT +#define BITS_PER_INT64 PR_BITS_PER_INT64 +#define BITS_PER_LONG PR_BITS_PER_LONG +#define BITS_PER_FLOAT PR_BITS_PER_FLOAT +#define BITS_PER_DOUBLE PR_BITS_PER_DOUBLE +#define BITS_PER_WORD PR_BITS_PER_WORD + +#define BITS_PER_BYTE_LOG2 PR_BITS_PER_BYTE_LOG2 +#define BITS_PER_SHORT_LOG2 PR_BITS_PER_SHORT_LOG2 +#define BITS_PER_INT_LOG2 PR_BITS_PER_INT_LOG2 +#define BITS_PER_INT64_LOG2 PR_BITS_PER_INT64_LOG2 +#define BITS_PER_LONG_LOG2 PR_BITS_PER_LONG_LOG2 +#define BITS_PER_FLOAT_LOG2 PR_BITS_PER_FLOAT_LOG2 +#define BITS_PER_DOUBLE_LOG2 PR_BITS_PER_DOUBLE_LOG2 +#define BITS_PER_WORD_LOG2 PR_BITS_PER_WORD_LOG2 + +#define ALIGN_OF_SHORT PR_ALIGN_OF_SHORT +#define ALIGN_OF_INT PR_ALIGN_OF_INT +#define ALIGN_OF_LONG PR_ALIGN_OF_LONG +#define ALIGN_OF_INT64 PR_ALIGN_OF_INT64 +#define ALIGN_OF_FLOAT PR_ALIGN_OF_FLOAT +#define ALIGN_OF_DOUBLE PR_ALIGN_OF_DOUBLE +#define ALIGN_OF_POINTER PR_ALIGN_OF_POINTER +#define ALIGN_OF_WORD PR_ALIGN_OF_WORD + +#define BYTES_PER_WORD_LOG2 PR_BYTES_PER_WORD_LOG2 +#define BYTES_PER_DWORD_LOG2 PR_BYTES_PER_DWORD_LOG2 +#define WORDS_PER_DWORD_LOG2 PR_WORDS_PER_DWORD_LOG2 + +#endif /* NO_NSPR_10_SUPPORT */ + +#endif /* nspr_cpucfg___ */ diff --git a/pr/include/md/_openbsd.h b/pr/include/md/_openbsd.h new file mode 100644 index 00000000..d34d5e58 --- /dev/null +++ b/pr/include/md/_openbsd.h @@ -0,0 +1,171 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef nspr_openbsd_defs_h___ +#define nspr_openbsd_defs_h___ + +#include <sys/syscall.h> + +#define PR_LINKER_ARCH "openbsd" +#define _PR_SI_SYSNAME "OpenBSD" +#if defined(__i386__) +#define _PR_SI_ARCHITECTURE "x86" +#elif defined(__alpha__) +#define _PR_SI_ARCHITECTURE "alpha" +#elif defined(__m68k__) +#define _PR_SI_ARCHITECTURE "m68k" +#elif defined(__powerpc__) +#define _PR_SI_ARCHITECTURE "powerpc" +#elif defined(__sparc__) +#define _PR_SI_ARCHITECTURE "sparc" +#elif defined(__arm32__) +#define _PR_SI_ARCHITECTURE "arm32" +#endif + +#define PR_DLL_SUFFIX ".so.1.0" + +#define _PR_VMBASE 0x30000000 +#define _PR_STACK_VMBASE 0x50000000 +#define _MD_DEFAULT_STACK_SIZE 65536L +#define _MD_MMAP_FLAGS MAP_PRIVATE + +#undef HAVE_STACK_GROWING_UP +#define HAVE_DLL +#define USE_DLFCN +#define _PR_HAVE_SOCKADDR_LEN + +#define USE_SETJMP + +#ifndef _PR_PTHREADS +#include <setjmp.h> + +#define PR_CONTEXT_TYPE sigjmp_buf + +#define CONTEXT(_th) ((_th)->md.context) + +#if defined(__i386__) || defined(__sparc__) || defined(__m68k__) || defined(__powerpc__) +#define JB_SP_INDEX 2 +#elif defined(__alpha__) +#define JB_SP_INDEX 34 +#elif defined(__arm32__) +/* + * On the arm32, the jmpbuf regs underwent a namechange after NetBSD 1.3 + */ +#ifdef JMPBUF_REG_R13 +#define JB_SP_INDEX JMPBUF_REG_R13 +#else +#define JB_SP_INDEX _JB_REG_R13 +#endif +#else +#error "Need to define SP index in jmp_buf here" +#endif +#define _MD_GET_SP(_th) (_th)->md.context[JB_SP_INDEX] + +#define PR_NUM_GCREGS _JBLEN + +/* +** Initialize a thread context to run "_main()" when started +*/ +#define _MD_INIT_CONTEXT(_thread, _sp, _main, status) \ +{ \ + *status = PR_TRUE; \ + if (sigsetjmp(CONTEXT(_thread), 1)) { \ + _main(); \ + } \ + _MD_GET_SP(_thread) = (unsigned char*) ((_sp) - 64); \ +} + +#define _MD_SWITCH_CONTEXT(_thread) \ + if (!sigsetjmp(CONTEXT(_thread), 1)) { \ + (_thread)->md.errcode = errno; \ + _PR_Schedule(); \ + } + +/* +** Restore a thread context, saved by _MD_SWITCH_CONTEXT +*/ +#define _MD_RESTORE_CONTEXT(_thread) \ +{ \ + errno = (_thread)->md.errcode; \ + _MD_SET_CURRENT_THREAD(_thread); \ + siglongjmp(CONTEXT(_thread), 1); \ +} + +/* Machine-dependent (MD) data structures */ + +struct _MDThread { + PR_CONTEXT_TYPE context; + int id; + int errcode; +}; + +struct _MDThreadStack { + PRInt8 notused; +}; + +struct _MDLock { + PRInt8 notused; +}; + +struct _MDSemaphore { + PRInt8 notused; +}; + +struct _MDCVar { + PRInt8 notused; +}; + +struct _MDSegment { + PRInt8 notused; +}; + +struct _MDCPU { + struct _MDCPU_Unix md_unix; +}; + +#define _MD_INIT_LOCKS() +#define _MD_NEW_LOCK(lock) PR_SUCCESS +#define _MD_FREE_LOCK(lock) +#define _MD_LOCK(lock) +#define _MD_UNLOCK(lock) +#define _MD_INIT_IO() +#define _MD_IOQ_LOCK() +#define _MD_IOQ_UNLOCK() + +#define _MD_INIT_RUNNING_CPU(cpu) _MD_unix_init_running_cpu(cpu) +#define _MD_INIT_THREAD _MD_InitializeThread +#define _MD_EXIT_THREAD(thread) +#define _MD_SUSPEND_THREAD(thread) _MD_suspend_thread +#define _MD_RESUME_THREAD(thread) _MD_resume_thread +#define _MD_CLEAN_THREAD(_thread) + +#endif /* ! _PR_PTHREADS */ + +#define _MD_EARLY_INIT _MD_EarlyInit +#define _MD_FINAL_INIT _PR_UnixInit +#define _MD_GET_INTERVAL _PR_UNIX_GetInterval +#define _MD_INTERVAL_PER_SEC _PR_UNIX_TicksPerSecond + +/* + * We wrapped the select() call. _MD_SELECT refers to the built-in, + * unwrapped version. + */ +#define _MD_SELECT(nfds,r,w,e,tv) syscall(SYS_select,nfds,r,w,e,tv) +#define _MD_POLL(fds,nfds,timeout) syscall(SYS_poll,fds,nfds,timeout) + +#endif /* nspr_openbsd_defs_h___ */ diff --git a/pr/include/md/_os2.h b/pr/include/md/_os2.h index ab67224a..bd38535e 100644 --- a/pr/include/md/_os2.h +++ b/pr/include/md/_os2.h @@ -245,6 +245,7 @@ extern PRInt32 _MD_CloseSocket(PRInt32 osfd); #define _MD_INIT_ATOMIC _PR_MD_INIT_ATOMIC #define _MD_ATOMIC_INCREMENT(x) _PR_MD_ATOMIC_INCREMENT(x) +#define _MD_ATOMIC_ADD(x,y) _PR_MD_ATOMIC_ADD(x,y) #define _MD_ATOMIC_DECREMENT(x) _PR_MD_ATOMIC_DECREMENT(x) #define _MD_ATOMIC_SET(x,y) _PR_MD_ATOMIC_SET(x, y) @@ -340,6 +341,7 @@ extern PRInt32 _MD_Accept(PRFileDesc *fd, PRNetAddr *raddr, PRUint32 *rlen, #define _MD_START_INTERRUPTS() #define _MD_STOP_INTERRUPTS() #define _MD_DISABLE_CLOCK_INTERRUPTS() +#define _MD_ENABLE_CLOCK_INTERRUPTS() #define _MD_BLOCK_CLOCK_INTERRUPTS() #define _MD_UNBLOCK_CLOCK_INTERRUPTS() #define _MD_EARLY_INIT _PR_MD_EARLY_INIT diff --git a/pr/include/md/_osf1.cfg b/pr/include/md/_osf1.cfg index 16bc9ac9..27ef81ca 100644 --- a/pr/include/md/_osf1.cfg +++ b/pr/include/md/_osf1.cfg @@ -75,8 +75,7 @@ #define PR_ALIGN_OF_DOUBLE 8 #define PR_ALIGN_OF_POINTER 8 -#define _PR_POLL_AVAILABLE -#define _PR_USE_POLL +#define _PR_POLL_BACKCOMPAT #ifndef NO_NSPR_10_SUPPORT diff --git a/pr/include/md/_osf1.h b/pr/include/md/_osf1.h index 473dee28..ab2baadd 100644 --- a/pr/include/md/_osf1.h +++ b/pr/include/md/_osf1.h @@ -28,15 +28,10 @@ #define _PR_SI_ARCHITECTURE "alpha" #define PR_DLL_SUFFIX ".so" -#define _PR_VMBASE 0x30000000 -#define _PR_STACK_VMBASE 0x50000000 -#define _MD_DEFAULT_STACK_SIZE 131072L -/* - * OSF1 needs the MAP_FIXED flag to ensure that mmap returns a pointer - * with the upper 32 bits zero. This is because Java sticks a pointer - * into an int. - */ -#define _MD_MMAP_FLAGS MAP_PRIVATE|MAP_FIXED +#define _PR_VMBASE 0x30000000 +#define _PR_STACK_VMBASE 0x50000000 +#define _MD_DEFAULT_STACK_SIZE 131072L +#define _MD_MMAP_FLAGS MAP_PRIVATE #undef HAVE_STACK_GROWING_UP #undef HAVE_WEAK_IO_SYMBOLS @@ -47,6 +42,13 @@ #define NEED_TIME_R #define USE_DLFCN +#define _PR_HAVE_ATOMIC_OPS +#define _PR_HAVE_ATOMIC_CAS +#define _PR_POLL_AVAILABLE +#define _PR_USE_POLL +#define _PR_STAT_HAS_ONLY_ST_ATIME +#define _PR_HAVE_LARGE_OFF_T + #define USE_SETJMP #include <setjmp.h> @@ -116,6 +118,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; @@ -159,15 +197,13 @@ extern int __poll(struct pollfd filedes[], unsigned int nfds, int timeout); /* * Atomic operations */ - -/* builtins.h is not available for OSF1 V3.2. */ -#ifndef OSF1V3 +#ifdef _PR_HAVE_ATOMIC_OPS #include <machine/builtins.h> -#define _PR_HAVE_ATOMIC_OPS #define _MD_INIT_ATOMIC() #define _MD_ATOMIC_INCREMENT(val) (__ATOMIC_INCREMENT_LONG(val) + 1) +#define _MD_ATOMIC_ADD(ptr, val) (__ATOMIC_ADD_LONG(ptr, val) + val) #define _MD_ATOMIC_DECREMENT(val) (__ATOMIC_DECREMENT_LONG(val) - 1) #define _MD_ATOMIC_SET(val, newval) __ATOMIC_EXCH_LONG(val, newval) -#endif /* OSF1V3 */ +#endif /* _PR_HAVE_ATOMIC_OPS */ #endif /* nspr_osf1_defs_h___ */ diff --git a/pr/include/md/_pth.h b/pr/include/md/_pth.h index 72ab48af..9ca91a74 100644 --- a/pr/include/md/_pth.h +++ b/pr/include/md/_pth.h @@ -25,6 +25,7 @@ #define _PR_MD_BLOCK_CLOCK_INTERRUPTS() #define _PR_MD_UNBLOCK_CLOCK_INTERRUPTS() #define _PR_MD_DISABLE_CLOCK_INTERRUPTS() +#define _PR_MD_ENABLE_CLOCK_INTERRUPTS() /* In good standards fashion, the DCE threads (based on posix-4) are not * quite the same as newer posix implementations. These are mostly name @@ -70,7 +71,7 @@ #define PTHREAD_COPY_THR_HANDLE(st, dt) (dt) = (st) #elif defined(IRIX) || defined(OSF1) || defined(AIX) || defined(SOLARIS) \ || defined(HPUX) || defined(LINUX) || defined(FREEBSD) \ - || defined(NETBSD) + || defined(NETBSD) || defined(OPENBSD) #define PTHREAD_ZERO_THR_HANDLE(t) (t) = 0 #define PTHREAD_THR_HANDLE_IS_ZERO(t) (t) == 0 #define PTHREAD_COPY_THR_HANDLE(st, dt) (dt) = (st) @@ -100,21 +101,6 @@ #error "Cannot determine pthread strategy" #endif -/* - * See if we have the privilege to set the scheduling policy and - * priority of threads. Returns 0 if privilege is available. - * Returns EPERM otherwise. - */ - -#ifdef AIX -#define PT_PRIVCHECK() privcheck(SET_PROC_RAC) -#elif defined(HPUX) && !defined(_PR_DCETHREADS) -PR_EXTERN(PRIntn) pt_hpux_privcheck(void); -#define PT_PRIVCHECK() pt_hpux_privcheck() -#else -#define PT_PRIVCHECK() 0 -#endif /* AIX */ - #if defined(_PR_DCETHREADS) #define PTHREAD_EXPLICIT_SCHED PTHREAD_DEFAULT_SCHED #endif @@ -136,7 +122,7 @@ PR_EXTERN(PRIntn) pt_hpux_privcheck(void); */ #if defined(_PR_DCETHREADS) || defined(FREEBSD) \ || (defined(LINUX) && defined(__alpha)) \ - || defined(NETBSD) + || defined(NETBSD) || defined(OPENBSD) #define PT_NO_ATFORK #endif @@ -144,7 +130,7 @@ PR_EXTERN(PRIntn) pt_hpux_privcheck(void); * These platforms don't have sigtimedwait() */ #if (defined(AIX) && !defined(AIX4_3)) || defined(LINUX) \ - || defined(FREEBSD) || defined(NETBSD) + || defined(FREEBSD) || defined(NETBSD) || defined(OPENBSD) #define PT_NO_SIGTIMEDWAIT #endif @@ -186,20 +172,26 @@ PR_EXTERN(PRIntn) pt_hpux_privcheck(void); */ #define PT_PRIO_MIN 1 #define PT_PRIO_MAX 127 -#elif defined(FREEBSD) || defined(NETBSD) /* XXX */ +#elif defined(FREEBSD) || defined(NETBSD) || defined(OPENBSD) /* XXX */ #define PT_PRIO_MIN 0 #define PT_PRIO_MAX 126 #else #error "pthreads is not supported for this architecture" #endif -/* Needed for garbage collection -- Look at PR_Suspend/PR_Resume implementation */ -#if defined(OSF1) -#define PTHREAD_YIELD() pthread_yield_np() -#elif defined(HPUX10_30) || defined(HPUX11) -#define PTHREAD_YIELD() sched_yield() -#elif defined(HPUX) +/* + * The PTHREAD_YIELD function is called from a signal handler. + * Needed for garbage collection -- Look at PR_Suspend/PR_Resume + * implementation. + */ +#if defined(_PR_DCETHREADS) #define PTHREAD_YIELD() pthread_yield() +#elif defined(OSF1) +/* + * sched_yield can't be called from a signal handler. Must use + * the _np version. + */ +#define PTHREAD_YIELD() pthread_yield_np() #elif defined(AIX) extern int (*_PT_aix_yield_fcn)(); #define PTHREAD_YIELD() (*_PT_aix_yield_fcn)() @@ -211,12 +203,9 @@ extern int (*_PT_aix_yield_fcn)(); onemillisec.tv_nsec = 1000000L; \ nanosleep(&onemillisec,NULL); \ PR_END_MACRO -#elif defined(SOLARIS) -#define PTHREAD_YIELD() sched_yield() -#elif defined(LINUX) +#elif defined(HPUX) || defined(LINUX) || defined(SOLARIS) \ + || defined(FREEBSD) || defined(NETBSD) || defined(OPENBSD) #define PTHREAD_YIELD() sched_yield() -#elif defined(FREEBSD) || defined(NETBSD) -#define PTHREAD_YIELD() pthread_yield() #else #error "Need to define PTHREAD_YIELD for this platform" #endif diff --git a/pr/include/md/_reliantunix.cfg b/pr/include/md/_reliantunix.cfg index 634acfe3..9cf253d8 100644 --- a/pr/include/md/_reliantunix.cfg +++ b/pr/include/md/_reliantunix.cfg @@ -76,8 +76,7 @@ #define PR_ALIGN_OF_DOUBLE 8 #define PR_ALIGN_OF_POINTER 4 -#define _PR_POLL_AVAILABLE -#define _PR_USE_POLL +#define _PR_POLL_BACKCOMPAT #ifndef NO_NSPR_10_SUPPORT diff --git a/pr/include/md/_reliantunix.h b/pr/include/md/_reliantunix.h index d7afb63d..a327b122 100644 --- a/pr/include/md/_reliantunix.h +++ b/pr/include/md/_reliantunix.h @@ -47,6 +47,8 @@ #define HAVE_WEAK_IO_SYMBOLS #define HAVE_WEAK_MALLOC_SYMBOLS #define _PR_RECV_BROKEN /* recv doesn't work on Unix Domain Sockets */ +#define _PR_POLL_AVAILABLE +#define _PR_USE_POLL /* * Mike Patnode indicated that it is possibly safe now to use context-switching @@ -109,6 +111,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; diff --git a/pr/include/md/_rhapsody.cfg b/pr/include/md/_rhapsody.cfg index 73fc491c..a0787fc9 100644 --- a/pr/include/md/_rhapsody.cfg +++ b/pr/include/md/_rhapsody.cfg @@ -27,8 +27,14 @@ #define RHAPOSDY #endif +#if defined(i386) +#undef IS_BIG_ENDIAN +#define IS_LITTLE_ENDIAN 1 +#else #undef IS_LITTLE_ENDIAN #define IS_BIG_ENDIAN 1 +#endif + #define HAVE_LONG_LONG #undef HAVE_ALIGNED_DOUBLES #define HAVE_ALIGNED_LONGLONGS 1 @@ -53,6 +59,7 @@ #define PR_BITS_PER_FLOAT 32 #define PR_BITS_PER_DOUBLE 64 #define PR_BITS_PER_WORD 32 +#define PR_BITS_PER_DWORD 64 #define PR_BITS_PER_BYTE_LOG2 3 #define PR_BITS_PER_SHORT_LOG2 4 @@ -117,3 +124,4 @@ #endif /* NO_NSPR_10_SUPPORT */ #endif /* nspr_cpucfg___ */ + diff --git a/pr/include/md/_rhapsody.h b/pr/include/md/_rhapsody.h index 052da11f..476b8e38 100644 --- a/pr/include/md/_rhapsody.h +++ b/pr/include/md/_rhapsody.h @@ -38,24 +38,23 @@ #define _MD_MMAP_FLAGS MAP_PRIVATE #undef HAVE_STACK_GROWING_UP -#define HAVE_WEAK_MALLOC_SYMBOLS -/* do this until I figure out the rhapsody dll stuff. */ #define HAVE_DLL -#define USE_RLD -#define _PR_HAVE_SOCKADDR_LEN +#define _PR_HAVE_SOCKADDR_LEN +#define _PR_STAT_HAS_ST_ATIMESPEC +#define _PR_TIMESPEC_HAS_TS_SEC +#define _PR_NO_LARGE_FILES #define USE_SETJMP -#ifndef _PR_PTHREADS +#if !defined(_PR_PTHREADS) #include <setjmp.h> #define PR_CONTEXT_TYPE jmp_buf -#define CONTEXT(_th) ((_th)->md.context) - -#define _MD_GET_SP(_th) (_th)->md.context[0] -#define PR_NUM_GCREGS _JBLEN +#define CONTEXT(_th) ((_th)->md.context) +#define _MD_GET_SP(_th) (((struct sigcontext *) (_th)->md.context)->sc_onstack) +#define PR_NUM_GCREGS _JBLEN /* ** Initialize a thread context to run "_main()" when started @@ -66,7 +65,7 @@ if (setjmp(CONTEXT(_thread))) { \ _main(); \ } \ - _MD_GET_SP(_thread) = (int) ((_sp) - 64); \ + _MD_GET_SP(_thread) = (unsigned char*) ((_sp) - 64); \ } #define _MD_SWITCH_CONTEXT(_thread) \ @@ -113,6 +112,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; @@ -149,14 +184,14 @@ extern void _MD_YIELD(void); #endif /* ! _PR_PTHREADS */ -extern void _MD_EarlyInit(void); -extern PRIntervalTime _PR_UNIX_GetInterval(void); -extern PRIntervalTime _PR_UNIX_TicksPerSecond(void); - -#define _MD_EARLY_INIT _MD_EarlyInit +#define _MD_EARLY_INIT _MD_EarlyInit #define _MD_FINAL_INIT _PR_UnixInit -#define _MD_GET_INTERVAL _PR_UNIX_GetInterval -#define _MD_INTERVAL_PER_SEC _PR_UNIX_TicksPerSecond +#define _MD_GET_INTERVAL _PR_UNIX_GetInterval +#define _MD_INTERVAL_PER_SEC _PR_UNIX_TicksPerSecond + +extern void _MD_EarlyInit(void); +extern PRIntervalTime _PR_UNIX_GetInterval(void); +extern PRIntervalTime _PR_UNIX_TicksPerSecond(void); /* * We wrapped the select() call. _MD_SELECT refers to the built-in, diff --git a/pr/include/md/_scoos.cfg b/pr/include/md/_scoos.cfg index 3f414650..6ef8fa90 100644 --- a/pr/include/md/_scoos.cfg +++ b/pr/include/md/_scoos.cfg @@ -71,8 +71,7 @@ #define PR_ALIGN_OF_DOUBLE 4 #define PR_ALIGN_OF_POINTER 4 -#define _PR_POLL_AVAILABLE -#define _PR_USE_POLL +#define _PR_POLL_BACKCOMPAT #ifndef NO_NSPR_10_SUPPORT diff --git a/pr/include/md/_scoos.h b/pr/include/md/_scoos.h index 45764f74..faa8e9ff 100644 --- a/pr/include/md/_scoos.h +++ b/pr/include/md/_scoos.h @@ -45,6 +45,9 @@ #define HAVE_WEAK_IO_SYMBOLS #endif +#define _PR_POLL_AVAILABLE +#define _PR_USE_POLL + #define NEED_STRFTIME_LOCK #define NEED_TIME_R #define _PR_RECV_BROKEN /* recv doesn't work on Unix Domain Sockets */ @@ -113,6 +116,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; diff --git a/pr/include/md/_solaris.h b/pr/include/md/_solaris.h index 04d0aa91..aaa646c1 100644 --- a/pr/include/md/_solaris.h +++ b/pr/include/md/_solaris.h @@ -48,8 +48,14 @@ #undef _PR_HAVE_ATOMIC_OPS #else #define _PR_HAVE_ATOMIC_OPS +#define _PR_HAVE_ATOMIC_CAS #endif +#define _PR_POLL_AVAILABLE +#define _PR_USE_POLL +#define _PR_STAT_HAS_ST_ATIM + +#include "prinrval.h" PR_EXTERN(PRIntervalTime) _MD_Solaris_GetInterval(void); #define _MD_GET_INTERVAL _MD_Solaris_GetInterval PR_EXTERN(PRIntervalTime) _MD_Solaris_TicksPerSecond(void); @@ -64,6 +70,9 @@ PR_EXTERN(PRIntervalTime) _MD_Solaris_TicksPerSecond(void); PR_EXTERN(PRInt32) _MD_AtomicIncrement(PRInt32 *val); #define _MD_ATOMIC_INCREMENT _MD_AtomicIncrement +PR_EXTERN(PRInt32) _MD_AtomicAdd(PRInt32 *ptr, PRInt32 val); +#define _MD_ATOMIC_ADD _MD_AtomicAdd + PR_EXTERN(PRInt32) _MD_AtomicDecrement(PRInt32 *val); #define _MD_ATOMIC_DECREMENT _MD_AtomicDecrement @@ -285,6 +294,43 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field, common to all Unix platforms + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + + struct _MDCPU { struct _MDCPU_Unix md_unix; }; @@ -566,6 +612,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; diff --git a/pr/include/md/_sony.h b/pr/include/md/_sony.h index f8846024..1ff68977 100644 --- a/pr/include/md/_sony.h +++ b/pr/include/md/_sony.h @@ -103,6 +103,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; diff --git a/pr/include/md/_sunos4.h b/pr/include/md/_sunos4.h index 823d22fb..41d4258c 100644 --- a/pr/include/md/_sunos4.h +++ b/pr/include/md/_sunos4.h @@ -52,6 +52,8 @@ #define NEED_STRFTIME_LOCK #define NEED_TIME_R #define HAVE_BSD_FLOCK +#define _PR_NO_LARGE_FILES +#define _PR_STAT_HAS_ONLY_ST_ATIME #define _MD_GET_INTERVAL _PR_UNIX_GetInterval #define _MD_INTERVAL_PER_SEC _PR_UNIX_TicksPerSecond @@ -145,6 +147,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; diff --git a/pr/include/md/_unix_errors.h b/pr/include/md/_unix_errors.h index b022462c..03ca7a02 100644 --- a/pr/include/md/_unix_errors.h +++ b/pr/include/md/_unix_errors.h @@ -138,6 +138,9 @@ PR_EXTERN(void) _MD_unix_map_select_error(int err); PR_EXTERN(void) _MD_unix_map_poll_error(int err); #define _PR_MD_MAP_POLL_ERROR _MD_unix_map_poll_error +PR_EXTERN(void) _MD_unix_map_poll_revents_error(int err); +#define _PR_MD_MAP_POLL_REVENTS_ERROR _MD_unix_map_poll_revents_error + PR_EXTERN(void) _MD_unix_map_flock_error(int err); #define _PR_MD_MAP_FLOCK_ERROR _MD_unix_map_flock_error diff --git a/pr/include/md/_unixos.h b/pr/include/md/_unixos.h index 4555a948..a801553f 100644 --- a/pr/include/md/_unixos.h +++ b/pr/include/md/_unixos.h @@ -37,26 +37,27 @@ #include <stddef.h> #include <sys/stat.h> #include <dirent.h> +#include <errno.h> #include "prio.h" #include "prmem.h" #include "prclist.h" -/* To pick up fd_set */ -#if defined(HPUX) -#include <sys/time.h> -#elif defined(OSF1) || defined(AIX) || defined(SOLARIS) || defined(IRIX) \ - || defined(UNIXWARE) || defined(NCR) || defined(SNI) || defined(NEC) \ - || defined(BSDI) || defined(SONY) -#include <sys/select.h> -#elif defined(SUNOS4) || defined(SCO) || defined(FREEBSD) \ - || defined(NETBSD) || defined(RHAPSODY) || defined(DGUX) -#include <sys/types.h> -#elif defined(LINUX) +/* + * For select(), fd_set, and struct timeval. + * + * In The Single UNIX(R) Specification, Version 2, + * the header file for select() is <sys/time.h>. + * + * fd_set is defined in <sys/types.h>. Usually + * <sys/time.h> includes <sys/types.h>, but on some + * older systems <sys/time.h> does not include + * <sys/types.h>, so we include it explicitly. + */ #include <sys/time.h> #include <sys/types.h> -#else -#error Find out what include file defines fd_set on this platform +#if defined(AIX) /* Only pre-4.2 AIX needs it, but for simplicity... */ +#include <sys/select.h> #endif #define PR_DIRECTORY_SEPARATOR '/' @@ -64,7 +65,6 @@ #define PR_PATH_SEPARATOR ':' #define PR_PATH_SEPARATOR_STR ":" #define GCPTR - typedef int (*FARPROC)(); /* @@ -73,6 +73,26 @@ typedef int (*FARPROC)(); #define _PR_INTERRUPT_CHECK_INTERVAL_SECS 5 extern PRIntervalTime intr_timeout_ticks; +/* + * The bit flags for the in_flags and out_flags fields + * of _PR_UnixPollDesc + */ +#ifdef _PR_USE_POLL +#define _PR_UNIX_POLL_READ POLLIN +#define _PR_UNIX_POLL_WRITE POLLOUT +#define _PR_UNIX_POLL_EXCEPT POLLPRI +#define _PR_UNIX_POLL_ERR POLLERR +#define _PR_UNIX_POLL_NVAL POLLNVAL +#define _PR_UNIX_POLL_HUP POLLHUP +#else /* _PR_USE_POLL */ +#define _PR_UNIX_POLL_READ 0x1 +#define _PR_UNIX_POLL_WRITE 0x2 +#define _PR_UNIX_POLL_EXCEPT 0x4 +#define _PR_UNIX_POLL_ERR 0x8 +#define _PR_UNIX_POLL_NVAL 0x10 +#define _PR_UNIX_POLL_HUP 0x20 +#endif /* _PR_USE_POLL */ + typedef struct _PRUnixPollDesc { PRInt32 osfd; PRInt16 in_flags; @@ -92,8 +112,10 @@ typedef struct PRPollQueue { ((PRPollQueue*) ((char*) (_qp) - offsetof(PRPollQueue,links))) -extern PRInt32 _PR_WaitForFD(PRInt32 osfd, PRUintn how, - PRIntervalTime timeout); +extern PRInt32 _PR_WaitForMultipleFDs( + _PRUnixPollDesc *unixpds, + PRInt32 pdcnt, + PRIntervalTime timeout); extern void _PR_Unblock_IO_Wait(struct PRThread *thr); #if defined(_PR_LOCAL_THREADS_ONLY) || defined(_PR_GLOBAL_THREADS_ONLY) @@ -113,45 +135,9 @@ struct _MDDir { DIR *d; }; -/* - * md-specific cpu structure field, common to all Unix platforms - */ -#define _PR_MD_MAX_OSFD FD_SETSIZE - -struct _MDCPU_Unix { - PRCList ioQ; - PRUint32 ioq_timeout; - PRInt32 ioq_max_osfd; - PRInt32 ioq_osfd_cnt; -#ifndef _PR_USE_POLL - fd_set fd_read_set, fd_write_set, fd_exception_set; - PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], - fd_exception_cnt[_PR_MD_MAX_OSFD]; -#else - struct pollfd *ioq_pollfds; - int ioq_pollfds_size; -#endif /* _PR_USE_POLL */ -}; struct _PRCPU; extern void _MD_unix_init_running_cpu(struct _PRCPU *cpu); -#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) -#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) -#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) -#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) -#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) -#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) -#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) -#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) -#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) -#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) -#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) -#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) -#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) - -#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 - - /* ** Make a redzone at both ends of the stack segment. Disallow access ** to those pages of memory. It's ok if the mprotect call's don't @@ -248,6 +234,7 @@ extern PRStatus _MD_KillUnixProcess(struct PRProcess *process); #define _MD_START_INTERRUPTS _MD_StartInterrupts #define _MD_STOP_INTERRUPTS _MD_StopInterrupts #define _MD_DISABLE_CLOCK_INTERRUPTS _MD_DisableClockInterrupts +#define _MD_ENABLE_CLOCK_INTERRUPTS _MD_EnableClockInterrupts #define _MD_BLOCK_CLOCK_INTERRUPTS _MD_BlockClockInterrupts #define _MD_UNBLOCK_CLOCK_INTERRUPTS _MD_UnblockClockInterrupts @@ -291,7 +278,9 @@ extern void _MD_FreeSegment(PRSegment *seg); /************************************************************************/ +#if !defined(HPUX_LW_TIMER) #define _MD_INTERVAL_INIT() +#endif #define _MD_INTERVAL_PER_MILLISEC() (_PR_MD_INTERVAL_PER_SEC() / 1000) #define _MD_INTERVAL_PER_MICROSEC() (_PR_MD_INTERVAL_PER_SEC() / 1000000) @@ -304,11 +293,6 @@ extern void _MD_FreeSegment(PRSegment *seg); extern PRInt32 _MD_AvailableSocket(PRInt32 osfd); -#include <errno.h> -#include <sys/types.h> -#include <sys/time.h> -#include <sys/stat.h> - extern void _MD_InitSegs(void); extern void _MD_StartInterrupts(void); extern void _MD_StopInterrupts(void); @@ -327,7 +311,7 @@ extern PRInt32 _MD_getfileinfo64(const char *fn, PRFileInfo64 *info); extern PRInt32 _MD_getopenfileinfo(const PRFileDesc *fd, PRFileInfo *info); extern PRInt32 _MD_getopenfileinfo64(const PRFileDesc *fd, PRFileInfo64 *info); extern PRInt32 _MD_rename(const char *from, const char *to); -extern PRInt32 _MD_access(const char *name, PRIntn how); +extern PRInt32 _MD_access(const char *name, PRAccessHow how); extern PRInt32 _MD_mkdir(const char *name, PRIntn mode); extern PRInt32 _MD_rmdir(const char *name); extern PRInt32 _MD_accept_read(PRInt32 sock, PRInt32 *newSock, @@ -516,4 +500,72 @@ extern int poll(struct pollfd *, unsigned long, int); #endif /* _PR_NEED_FAKE_POLL */ +/* +** A vector of the UNIX I/O calls we use. These are here to smooth over +** the rough edges needed for large files. All of NSPR's implmentaions +** go through this vector using syntax of the form +** result = _md_iovector.xxx64(args); +*/ + +#if defined(SOLARIS2_5) +/* +** Special case: Solaris 2.5.1 +** Solaris starts to have 64-bit file I/O in 2.6. We build on Solaris +** 2.5.1 so that we can use the same binaries on both Solaris 2.5.1 and +** 2.6. At run time, we detect whether 64-bit file I/O is available by +** looking up the 64-bit file function symbols in libc. At build time, +** we need to define the 64-bit file I/O datatypes that are compatible +** with their definitions on Solaris 2.6. +*/ +typedef PRInt64 off64_t; +typedef PRUint64 ino64_t; +typedef PRUint64 blkcnt64_t; +struct stat64 { + dev_t st_dev; + long st_pad1[3]; + ino64_t st_ino; + mode_t st_mode; + nlink_t st_nlink; + uid_t st_uid; + gid_t st_gid; + dev_t st_rdev; + long t_pad2[2]; + off64_t st_size; + timestruc_t st_atim; + timestruc_t st_mtim; + timestruc_t st_ctim; + long st_blksize; + blkcnt64_t st_blocks; + char st_fstype[_ST_FSTYPSZ]; + long st_pad4[8]; +}; +typedef struct stat64 _MDStat64; + +#elif defined(_PR_HAVE_OFF64_T) +typedef struct stat64 _MDStat64; +#elif defined(_PR_HAVE_LARGE_OFF_T) || defined(_PR_NO_LARGE_FILES) +typedef struct stat _MDStat64; +#else +#error "I don't know yet" +#endif + +typedef PRIntn (*_MD_Fstat64)(PRIntn osfd, _MDStat64 *buf); +typedef PRIntn (*_MD_Open64)(const char *path, int oflag, ...); +typedef PRIntn (*_MD_Stat64)(const char *path, _MDStat64 *buf); +typedef PRInt64 (*_MD_Lseek64)(PRIntn osfd, PRInt64, PRIntn whence); +typedef PRIntn (*_MD_Lockf64)(PRIntn osfd, PRIntn function, PRInt64 size); +typedef void* (*_MD_Mmap64)( + void *addr, PRSize len, PRIntn prot, PRIntn flags, + PRIntn fildes, PRInt64 offset); +struct _MD_IOVector +{ + _MD_Open64 _open64; + _MD_Mmap64 _mmap64; + _MD_Stat64 _stat64; + _MD_Fstat64 _fstat64; + _MD_Lockf64 _lockf64; + _MD_Lseek64 _lseek64; +}; +extern struct _MD_IOVector _md_iovector; + #endif /* prunixos_h___ */ diff --git a/pr/include/md/_unixware.cfg b/pr/include/md/_unixware.cfg index d8261908..fd96a083 100644 --- a/pr/include/md/_unixware.cfg +++ b/pr/include/md/_unixware.cfg @@ -71,8 +71,7 @@ #define PR_ALIGN_OF_DOUBLE 4 #define PR_ALIGN_OF_POINTER 4 -#define _PR_USE_POLL -#define _PR_POLL_AVAILABLE +#define _PR_POLL_BACKCOMPAT #ifndef NO_NSPR_10_SUPPORT diff --git a/pr/include/md/_unixware.h b/pr/include/md/_unixware.h index 9a0afda3..b1ce660a 100644 --- a/pr/include/md/_unixware.h +++ b/pr/include/md/_unixware.h @@ -36,6 +36,8 @@ #ifndef HAVE_WEAK_IO_SYMBOLS #define HAVE_WEAK_IO_SYMBOLS #endif +#define _PR_POLL_AVAILABLE +#define _PR_USE_POLL #undef HAVE_STACK_GROWING_UP #define HAVE_NETCONFIG @@ -114,6 +116,42 @@ struct _MDSegment { PRInt8 notused; }; +/* + * md-specific cpu structure field + */ +#define _PR_MD_MAX_OSFD FD_SETSIZE + +struct _MDCPU_Unix { + PRCList ioQ; + PRUint32 ioq_timeout; + PRInt32 ioq_max_osfd; + PRInt32 ioq_osfd_cnt; +#ifndef _PR_USE_POLL + fd_set fd_read_set, fd_write_set, fd_exception_set; + PRInt16 fd_read_cnt[_PR_MD_MAX_OSFD],fd_write_cnt[_PR_MD_MAX_OSFD], + fd_exception_cnt[_PR_MD_MAX_OSFD]; +#else + struct pollfd *ioq_pollfds; + int ioq_pollfds_size; +#endif /* _PR_USE_POLL */ +}; + +#define _PR_IOQ(_cpu) ((_cpu)->md.md_unix.ioQ) +#define _PR_ADD_TO_IOQ(_pq, _cpu) PR_APPEND_LINK(&_pq.links, &_PR_IOQ(_cpu)) +#define _PR_FD_READ_SET(_cpu) ((_cpu)->md.md_unix.fd_read_set) +#define _PR_FD_READ_CNT(_cpu) ((_cpu)->md.md_unix.fd_read_cnt) +#define _PR_FD_WRITE_SET(_cpu) ((_cpu)->md.md_unix.fd_write_set) +#define _PR_FD_WRITE_CNT(_cpu) ((_cpu)->md.md_unix.fd_write_cnt) +#define _PR_FD_EXCEPTION_SET(_cpu) ((_cpu)->md.md_unix.fd_exception_set) +#define _PR_FD_EXCEPTION_CNT(_cpu) ((_cpu)->md.md_unix.fd_exception_cnt) +#define _PR_IOQ_TIMEOUT(_cpu) ((_cpu)->md.md_unix.ioq_timeout) +#define _PR_IOQ_MAX_OSFD(_cpu) ((_cpu)->md.md_unix.ioq_max_osfd) +#define _PR_IOQ_OSFD_CNT(_cpu) ((_cpu)->md.md_unix.ioq_osfd_cnt) +#define _PR_IOQ_POLLFDS(_cpu) ((_cpu)->md.md_unix.ioq_pollfds) +#define _PR_IOQ_POLLFDS_SIZE(_cpu) ((_cpu)->md.md_unix.ioq_pollfds_size) + +#define _PR_IOQ_MIN_POLLFDS_SIZE(_cpu) 32 + struct _MDCPU { struct _MDCPU_Unix md_unix; }; diff --git a/pr/include/md/_win16.h b/pr/include/md/_win16.h index bb8ba5a3..399b7c6d 100644 --- a/pr/include/md/_win16.h +++ b/pr/include/md/_win16.h @@ -296,6 +296,7 @@ extern PRStatus _PR_KillWindowsProcess(struct PRProcess *process); #define _MD_INIT_ATOMIC() #define _MD_ATOMIC_INCREMENT(x) (*x++) +#define _MD_ATOMIC_ADD(ptr, val) ((*x) += val) #define _MD_ATOMIC_DECREMENT(x) (*x--) #define _MD_ATOMIC_SET(x,y) (*x, y) @@ -388,6 +389,7 @@ PR_EXTERN(void) _MD_INIT_RUNNING_CPU(struct _PRCPU *cpu ); #define _MD_START_INTERRUPTS() #define _MD_STOP_INTERRUPTS() #define _MD_DISABLE_CLOCK_INTERRUPTS() +#define _MD_ENABLE_CLOCK_INTERRUPTS() #define _MD_BLOCK_CLOCK_INTERRUPTS() #define _MD_UNBLOCK_CLOCK_INTERRUPTS() #define _MD_EARLY_INIT _PR_MD_EARLY_INIT diff --git a/pr/include/md/_win95.h b/pr/include/md/_win95.h index 9cfbc1b4..a4710b7f 100644 --- a/pr/include/md/_win95.h +++ b/pr/include/md/_win95.h @@ -222,13 +222,17 @@ extern PRInt32 _MD_CloseSocket(PRInt32 osfd); #define _MD_SETSOCKOPT _PR_MD_SETSOCKOPT #define _MD_SELECT select #define _MD_FSYNC _PR_MD_FSYNC +#define READ_FD 1 +#define WRITE_FD 2 #define _MD_INIT_ATOMIC() #if defined(_M_IX86) || defined(_X86_) #define _MD_ATOMIC_INCREMENT _PR_MD_ATOMIC_INCREMENT +#define _MD_ATOMIC_ADD _PR_MD_ATOMIC_ADD #define _MD_ATOMIC_DECREMENT _PR_MD_ATOMIC_DECREMENT #else /* non-x86 processors */ #define _MD_ATOMIC_INCREMENT(x) InterlockedIncrement((PLONG)x) +#define _MD_ATOMIC_ADD(ptr,val) (InterlockedExchangeAdd((PLONG)ptr, (LONG)val) + val) #define _MD_ATOMIC_DECREMENT(x) InterlockedDecrement((PLONG)x) #endif /* x86 */ #define _MD_ATOMIC_SET(x,y) InterlockedExchange((PLONG)x, (LONG)y) @@ -325,6 +329,7 @@ extern PRInt32 _MD_Accept(PRFileDesc *fd, PRNetAddr *raddr, PRUint32 *rlen, #define _MD_START_INTERRUPTS() #define _MD_STOP_INTERRUPTS() #define _MD_DISABLE_CLOCK_INTERRUPTS() +#define _MD_ENABLE_CLOCK_INTERRUPTS() #define _MD_BLOCK_CLOCK_INTERRUPTS() #define _MD_UNBLOCK_CLOCK_INTERRUPTS() #define _MD_EARLY_INIT _PR_MD_EARLY_INIT @@ -368,9 +373,11 @@ extern PRStatus _PR_KillWindowsProcess(struct PRProcess *process); /* --- Native-Thread Specific Definitions ------------------------------- */ +extern struct PRThread * _MD_CURRENT_THREAD(void); + #ifdef _PR_USE_STATIC_TLS extern __declspec(thread) struct PRThread *_pr_currentThread; -#define _MD_CURRENT_THREAD() _pr_currentThread +#define _MD_GET_ATTACHED_THREAD() _pr_currentThread #define _MD_SET_CURRENT_THREAD(_thread) (_pr_currentThread = (_thread)) extern __declspec(thread) struct PRThread *_pr_thread_last_run; @@ -382,7 +389,7 @@ extern __declspec(thread) struct _PRCPU *_pr_currentCPU; #define _MD_SET_CURRENT_CPU(_cpu) (_pr_currentCPU = 0) #else /* _PR_USE_STATIC_TLS */ extern DWORD _pr_currentThreadIndex; -#define _MD_CURRENT_THREAD() ((PRThread *) TlsGetValue(_pr_currentThreadIndex)) +#define _MD_GET_ATTACHED_THREAD() ((PRThread *) TlsGetValue(_pr_currentThreadIndex)) #define _MD_SET_CURRENT_THREAD(_thread) TlsSetValue(_pr_currentThreadIndex, (_thread)) extern DWORD _pr_lastThreadIndex; diff --git a/pr/include/md/_winnt.h b/pr/include/md/_winnt.h index 7695e5f6..9de2cf05 100644 --- a/pr/include/md/_winnt.h +++ b/pr/include/md/_winnt.h @@ -34,6 +34,7 @@ #include <errno.h> #include "prio.h" +#include "prclist.h" /* * Internal configuration macros @@ -49,6 +50,7 @@ #define HAVE_SOCKET_REUSEADDR #define HAVE_SOCKET_KEEPALIVE #define _PR_HAVE_ATOMIC_OPS +#define _PR_HAVE_ATOMIC_CAS /* --- Common User-Thread/Native-Thread Definitions --------------------- */ @@ -72,9 +74,39 @@ struct _MDCPU { int unused; }; +enum _MDIOModel { + _MD_BlockingIO = 0x38, + _MD_MultiWaitIO = 0x49 +}; + +typedef struct _MDOverlapped { + OVERLAPPED overlapped; /* Used for async I/O */ + + enum _MDIOModel ioModel; /* The I/O model to implement + * using overlapped I/O. + */ + + union { + struct _MDThread *mdThread; /* For blocking I/O, this structure + * is embedded in the _MDThread + * structure. + */ + struct { + PRCList links; /* for group->io_ready list */ + struct PRRecvWait *desc; /* For multiwait I/O, this structure + * is associated with a PRRecvWait + * structure. + */ + struct PRWaitGroup *group; + struct TimerEvent *timer; + DWORD error; + } mw; + } data; +} _MDOverlapped; + struct _MDThread { /* The overlapped structure must be first! */ - OVERLAPPED overlapped; /* Used for async IO for this thread */ + struct _MDOverlapped overlapped; /* Used for async IO for this thread */ void *acceptex_buf; /* Used for AcceptEx() */ TRANSMIT_FILE_BUFFERS *xmit_bufs; /* Used for TransmitFile() */ HANDLE blocked_sema; /* Threads block on this when waiting @@ -168,6 +200,7 @@ struct _MDProcess { /* --- IO stuff --- */ +extern PRInt32 _md_Associate(HANDLE); extern PRInt32 _PR_MD_CLOSE(PRInt32 osfd, PRBool socket); #define _MD_OPEN _PR_MD_OPEN @@ -213,9 +246,11 @@ extern PRInt32 _PR_MD_CLOSE(PRInt32 osfd, PRBool socket); #define _MD_INIT_ATOMIC() #if defined(_M_IX86) || defined(_X86_) #define _MD_ATOMIC_INCREMENT _PR_MD_ATOMIC_INCREMENT +#define _MD_ATOMIC_ADD _PR_MD_ATOMIC_ADD #define _MD_ATOMIC_DECREMENT _PR_MD_ATOMIC_DECREMENT #else /* non-x86 processors */ #define _MD_ATOMIC_INCREMENT(x) InterlockedIncrement((PLONG)x) +#define _MD_ATOMIC_ADD(ptr,val) (InterlockedExchangeAdd((PLONG)ptr, (LONG)val) + val) #define _MD_ATOMIC_DECREMENT(x) InterlockedDecrement((PLONG)x) #endif /* x86 */ #define _MD_ATOMIC_SET(x,y) InterlockedExchange((PLONG)x, (LONG)y) @@ -321,6 +356,7 @@ extern struct _MDLock _pr_ioq_lock; #define _MD_START_INTERRUPTS() #define _MD_STOP_INTERRUPTS() #define _MD_DISABLE_CLOCK_INTERRUPTS() +#define _MD_ENABLE_CLOCK_INTERRUPTS() #define _MD_BLOCK_CLOCK_INTERRUPTS() #define _MD_UNBLOCK_CLOCK_INTERRUPTS() #define _MD_EARLY_INIT _PR_MD_EARLY_INIT @@ -370,43 +406,73 @@ extern PRStatus _PR_KillWindowsProcess(struct PRProcess *process); /* --- Native-Thread Specific Definitions ------------------------------- */ -#ifdef _PR_USE_STATIC_TLS +extern BOOL _pr_use_static_tls; extern __declspec(thread) struct PRThread *_pr_current_fiber; -#define _MD_CURRENT_THREAD() _pr_current_fiber -#define _MD_SET_CURRENT_THREAD(_thread) (_pr_current_fiber = (_thread)) +extern DWORD _pr_currentFiberIndex; -extern __declspec(thread) struct PRThread *_pr_fiber_last_run; -#define _MD_LAST_THREAD() _pr_fiber_last_run -#define _MD_SET_LAST_THREAD(_thread) (_pr_fiber_last_run = (_thread)) +#define _MD_GET_ATTACHED_THREAD() \ + (_pr_use_static_tls ? _pr_current_fiber \ + : (PRThread *) TlsGetValue(_pr_currentFiberIndex)) -extern __declspec(thread) struct _PRCPU *_pr_current_cpu; -#define _MD_CURRENT_CPU() _pr_current_cpu -#define _MD_SET_CURRENT_CPU(_cpu) (_pr_current_cpu = (_cpu)) +extern struct PRThread * _MD_CURRENT_THREAD(void); -extern __declspec(thread) PRUintn _pr_ints_off; -#define _MD_SET_INTSOFF(_val) (_pr_ints_off = (_val)) -#define _MD_GET_INTSOFF() _pr_ints_off +#define _MD_SET_CURRENT_THREAD(_thread) \ + PR_BEGIN_MACRO \ + if (_pr_use_static_tls) { \ + _pr_current_fiber = (_thread); \ + } else { \ + TlsSetValue(_pr_currentFiberIndex, (_thread)); \ + } \ + PR_END_MACRO -#else /* _PR_USE_STATIC_TLS */ +extern __declspec(thread) struct PRThread *_pr_fiber_last_run; +extern DWORD _pr_lastFiberIndex; -extern DWORD _pr_currentFiberIndex; -#define _MD_CURRENT_THREAD() ((PRThread *) TlsGetValue(_pr_currentFiberIndex)) -#define _MD_SET_CURRENT_THREAD(_thread) TlsSetValue(_pr_currentFiberIndex, (_thread)) +#define _MD_LAST_THREAD() \ + (_pr_use_static_tls ? _pr_fiber_last_run \ + : (PRThread *) TlsGetValue(_pr_lastFiberIndex)) -extern DWORD _pr_lastFiberIndex; -#define _MD_LAST_THREAD() ((PRThread *) TlsGetValue(_pr_lastFiberIndex)) -#define _MD_SET_LAST_THREAD(_thread) TlsSetValue(_pr_lastFiberIndex, (_thread)) +#define _MD_SET_LAST_THREAD(_thread) \ + PR_BEGIN_MACRO \ + if (_pr_use_static_tls) { \ + _pr_fiber_last_run = (_thread); \ + } else { \ + TlsSetValue(_pr_lastFiberIndex, (_thread)); \ + } \ + PR_END_MACRO +extern __declspec(thread) struct _PRCPU *_pr_current_cpu; extern DWORD _pr_currentCPUIndex; -#define _MD_CURRENT_CPU() ((struct _PRCPU *) TlsGetValue(_pr_currentCPUIndex)) -#define _MD_SET_CURRENT_CPU(_cpu) TlsSetValue(_pr_currentCPUIndex, (_cpu)) +#define _MD_CURRENT_CPU() \ + (_pr_use_static_tls ? _pr_current_cpu \ + : (struct _PRCPU *) TlsGetValue(_pr_currentCPUIndex)) + +#define _MD_SET_CURRENT_CPU(_cpu) \ + PR_BEGIN_MACRO \ + if (_pr_use_static_tls) { \ + _pr_current_cpu = (_cpu); \ + } else { \ + TlsSetValue(_pr_currentCPUIndex, (_cpu)); \ + } \ + PR_END_MACRO + +extern __declspec(thread) PRUintn _pr_ints_off; extern DWORD _pr_intsOffIndex; -#define _MD_SET_INTSOFF(_val) TlsSetValue(_pr_intsOffIndex, (LPVOID) (_val)) -#define _MD_GET_INTSOFF() ((PRUintn) TlsGetValue(_pr_intsOffIndex)) -#endif /* _PR_USE_STATIC_TLS */ +#define _MD_GET_INTSOFF() \ + (_pr_use_static_tls ? _pr_ints_off \ + : (PRUintn) TlsGetValue(_pr_intsOffIndex)) + +#define _MD_SET_INTSOFF(_val) \ + PR_BEGIN_MACRO \ + if (_pr_use_static_tls) { \ + _pr_ints_off = (_val); \ + } else { \ + TlsSetValue(_pr_intsOffIndex, (LPVOID) (_val)); \ + } \ + PR_END_MACRO /* --- Initialization stuff --- */ #define _MD_INIT_LOCKS() diff --git a/pr/include/md/prosdep.h b/pr/include/md/prosdep.h index bd8e6a19..98002558 100644 --- a/pr/include/md/prosdep.h +++ b/pr/include/md/prosdep.h @@ -50,9 +50,6 @@ PR_BEGIN_EXTERN_C #elif defined(XP_UNIX) -#include "md/_unixos.h" -#include "md/_unix_errors.h" - #if defined(AIX) #include "md/_aix.h" @@ -62,6 +59,9 @@ PR_BEGIN_EXTERN_C #elif defined(NETBSD) #include "md/_netbsd.h" +#elif defined(OPENBSD) +#include "md/_openbsd.h" + #elif defined(BSDI) #include "md/_bsdi.h" @@ -112,6 +112,9 @@ PR_BEGIN_EXTERN_C #endif +#include "md/_unixos.h" +#include "md/_unix_errors.h" + #else #error "The platform is not Unix, Windows, or Mac" diff --git a/pr/include/nspr.h b/pr/include/nspr.h index 4539af58..a2800df2 100644 --- a/pr/include/nspr.h +++ b/pr/include/nspr.h @@ -37,6 +37,7 @@ #include "prlong.h" #include "prmem.h" #include "prmon.h" +#include "prmwait.h" #include "prnetdb.h" #include "prprf.h" #include "prproces.h" diff --git a/pr/include/obsolete/pralarm.h b/pr/include/obsolete/pralarm.h index 5afb65a5..422a7b6a 100644 --- a/pr/include/obsolete/pralarm.h +++ b/pr/include/obsolete/pralarm.h @@ -46,6 +46,7 @@ #include "prtypes.h" #include "prinrval.h" + PR_BEGIN_EXTERN_C /**********************************************************************/ diff --git a/pr/include/obsolete/protypes.h b/pr/include/obsolete/protypes.h index e9fba9dc..e70b03b4 100644 --- a/pr/include/obsolete/protypes.h +++ b/pr/include/obsolete/protypes.h @@ -26,6 +26,7 @@ #if !defined(PROTYPES_H) #define PROTYPES_H + /* SVR4 typedef of uint is commonly found on UNIX machines. */ #ifdef XP_UNIX #include <sys/types.h> diff --git a/pr/include/pratom.h b/pr/include/pratom.h index 48d162a9..d8ad0a8e 100644 --- a/pr/include/pratom.h +++ b/pr/include/pratom.h @@ -25,6 +25,7 @@ #define pratom_h___ #include "prtypes.h" +#include "prlock.h" PR_BEGIN_EXTERN_C @@ -35,7 +36,7 @@ PR_BEGIN_EXTERN_C ** INPUTS: ** val: a pointer to the value to increment ** RETURN: -** the returned value has the same sign as the result +** the returned value is the result of the increment */ PR_EXTERN(PRInt32) PR_AtomicIncrement(PRInt32 *val); @@ -46,7 +47,7 @@ PR_EXTERN(PRInt32) PR_AtomicIncrement(PRInt32 *val); ** INPUTS: ** val: a pointer to the value to decrement ** RETURN: -** the returned value has the same sign as the result +** the returned value is the result of the decrement */ PR_EXTERN(PRInt32) PR_AtomicDecrement(PRInt32 *val); @@ -55,13 +56,96 @@ PR_EXTERN(PRInt32) PR_AtomicDecrement(PRInt32 *val); ** DESCRIPTION: ** Atomically set a 32 bit value. ** INPUTS: -** val: A pointer to a 32 bit value to bet set +** val: A pointer to a 32 bit value to be set ** newval: The newvalue to assign to val ** RETURN: ** Returns the prior value */ PR_EXTERN(PRInt32) PR_AtomicSet(PRInt32 *val, PRInt32 newval); +/* +** FUNCTION: PR_AtomicAdd +** DESCRIPTION: +** Atomically add a 32 bit value. +** INPUTS: +** ptr: a pointer to the value to increment +** val: value to be added +** RETURN: +** the returned value is the result of the addition +*/ +PR_EXTERN(PRInt32) PR_AtomicAdd(PRInt32 *ptr, PRInt32 val); + +/* +** LIFO linked-list (stack) +*/ +typedef struct PRStackElemStr PRStackElem; + +struct PRStackElemStr { + PRStackElem *prstk_elem_next; /* next pointer MUST be at offset 0; + assembly language code relies on this */ +}; + +typedef struct PRStackStr PRStack; + +struct PRStackStr { + PRStackElem prstk_head; /* head MUST be at offset 0; assembly + language code relies on this + */ + PRLock *prstk_lock; + char *prstk_name; +}; + + +/* +** FUNCTION: PR_CreateStack +** DESCRIPTION: +** Create a stack, a LIFO linked list +** INPUTS: +** stack_name: a pointer to string containing the name of the stack +** RETURN: +** A pointer to the created stack, if successful, else NULL. +*/ +PR_EXTERN(PRStack *) PR_CreateStack(const char *stack_name); + +/* +** FUNCTION: PR_StackPush +** DESCRIPTION: +** Push an element on the top of the stack +** INPUTS: +** stack: pointer to the stack +** stack_elem: pointer to the stack element +** RETURN: +** None +*/ +PR_EXTERN(void) PR_StackPush(PRStack *stack, PRStackElem *stack_elem); + +/* +** FUNCTION: PR_StackPop +** DESCRIPTION: +** Remove the element on the top of the stack +** INPUTS: +** stack: pointer to the stack +** RETURN: +** A pointer to the stack element removed from the top of the stack, +** if non-empty, +** else NULL +*/ +PR_EXTERN(PRStackElem *) PR_StackPop(PRStack *stack); + +/* +** FUNCTION: PR_DestroyStack +** DESCRIPTION: +** Destroy the stack +** INPUTS: +** stack: pointer to the stack +** RETURN: +** PR_SUCCESS - if successfully deleted +** PR_FAILURE - if the stack is not empty +** PR_GetError will return +** PR_INVALID_STATE_ERROR - stack is not empty +*/ +PR_EXTERN(PRStatus) PR_DestroyStack(PRStack *stack); + PR_END_EXTERN_C #endif /* pratom_h___ */ diff --git a/pr/include/prbit.h b/pr/include/prbit.h index 57853384..72beb243 100644 --- a/pr/include/prbit.h +++ b/pr/include/prbit.h @@ -20,6 +20,7 @@ #define prbit_h___ #include "prtypes.h" +PR_BEGIN_EXTERN_C /* ** A prbitmap_t is a long integer that can be used for bitmaps @@ -87,4 +88,5 @@ PR_EXTERN(PRIntn) PR_FloorLog2(PRUint32 i); (_log2) += 1; \ PR_END_MACRO +PR_END_EXTERN_C #endif /* prbit_h___ */ diff --git a/pr/include/prcountr.h b/pr/include/prcountr.h new file mode 100644 index 00000000..44d5fb43 --- /dev/null +++ b/pr/include/prcountr.h @@ -0,0 +1,512 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef prcountr_h___ +#define prcountr_h___ + +/*---------------------------------------------------------------------------- +** prcountr.h -- NSPR Instrumentation counters +** +** The NSPR Counter Feature provides a means to "count +** something." Counters can be dynamically defined, incremented, +** decremented, set, and deleted under application program +** control. +** +** The Counter Feature is intended to be used as instrumentation, +** not as operational data. If you need a counter for operational +** data, use native integral types. +** +** Counters are 32bit unsigned intergers. On overflow, a counter +** will wrap. No exception is recognized or reported. +** +** A counter can be dynamically created using a two level naming +** convention. A "handle" is returned when the counter is +** created. The counter can subsequently be addressed by its +** handle. An API is provided to get an existing counter's handle +** given the names with which it was originally created. +** Similarly, a counter's name can be retrieved given its handle. +** +** The counter naming convention is a two-level hierarchy. The +** QName is the higher level of the hierarchy; RName is the +** lower level. RNames can be thought of as existing within a +** QName. The same RName can exist within multiple QNames. QNames +** are unique. The NSPR Counter is not a near-zero overhead +** feature. Application designers should be aware of +** serialization issues when using the Counter API. Creating a +** counter locks a large asset, potentially causing a stall. This +** suggest that applications should create counters at component +** initialization, for example, and not create and destroy them +** willy-nilly. ... You have been warned. +** +** Incrementing and Adding to counters uses atomic operations. +** The performance of these operations will vary from platform +** to platform. On platforms where atomic operations are not +** supported the overhead may be substantial. +** +** When traversing the counter database with FindNext functions, +** the instantaneous values of any given counter is that at the +** moment of extraction. The state of the entire counter database +** may not be viewed as atomic. +** +** The counter interface may be disabled (No-Op'd) at compile +** time. When DEBUG is defined at compile time, the Counter +** Feature is compiled into NSPR and applications invoking it. +** When DEBUG is not defined, the counter macros compile to +** nothing. To force the Counter Feature to be compiled into an +** optimized build, define FORCE_NSPR_COUNTERS at compile time +** for both NSPR and the application intending to use it. +** +** Application designers should use the macro form of the Counter +** Feature methods to minimize performance impact in optimized +** builds. The macros normally compile to nothing on optimized +** builds. +** +** Application designers should be aware of the effects of +** debug and optimized build differences when using result of the +** Counter Feature macros in expressions. +** +** The Counter Feature is thread-safe and SMP safe. +** +** /lth. 09-Jun-1998. +*/ + +#include "prtypes.h" + +PR_BEGIN_EXTERN_C + +/* +** Opaque counter handle type. +** ... don't even think of looking in here. +** +*/ +typedef void * PRCounterHandle; + +#define PRCOUNTER_NAME_MAX 31 +#define PRCOUNTER_DESC_MAX 255 + + +#if defined(DEBUG) || defined(FORCE_NSPR_COUNTERS) + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_DEFINE_COUNTER() -- Define a PRCounterHandle +** +** DESCRIPTION: PR_DEFINE_COUNTER() is used to define a counter +** handle. +** +*/ +#define PR_DEFINE_COUNTER(name) PRCounterHandle name + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_INIT_COUNTER_HANDLE() -- Set the value of a PRCounterHandle +** +** DESCRIPTION: +** PR_INIT_COUNTER_HANDLE() sets the value of a PRCounterHandle +** to value. +** +*/ +#define PR_INIT_COUNTER_HANDLE(handle,value)\ + (handle) = (PRCounterHandle)(value) + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_CreateCounter() -- Create a counter +** +** DESCRIPTION: PR_CreateCounter() creates a counter object and +** initializes it to zero. +** +** The macro form takes as its first argument the name of the +** PRCounterHandle to receive the handle returned from +** PR_CreateCounter(). +** +** INPUTS: +** qName: The QName for the counter object. The maximum length +** of qName is defined by PRCOUNTER_NAME_MAX +** +** rName: The RName for the counter object. The maximum length +** of qName is defined by PRCOUNTER_NAME_MAX +** +** descrioption: The description of the counter object. The +** maximum length of description is defined by +** PRCOUNTER_DESC_MAX. +** +** OUTPUTS: +** +** RETURNS: +** PRCounterHandle. +** +** RESTRICTIONS: +** +*/ +#define PR_CREATE_COUNTER(handle,qName,rName,description)\ + (handle) = PR_CreateCounter((qName),(rName),(description)) + +PR_EXTERN(PRCounterHandle) + PR_CreateCounter( + const char *qName, + const char *rName, + const char *description +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_DestroyCounter() -- Destroy a counter object. +** +** DESCRIPTION: PR_DestroyCounter() removes a counter and +** unregisters its handle from the counter database. +** +** INPUTS: +** handle: the PRCounterHandle of the counter to be destroyed. +** +** OUTPUTS: +** The counter is destroyed. +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_DESTROY_COUNTER(handle) PR_DestroyCounter((handle)) + +PR_EXTERN(void) + PR_DestroyCounter( + PRCounterHandle handle +); + + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_GetCounterHandleFromName() -- Retreive a +** counter's handle give its name. +** +** DESCRIPTION: PR_GetCounterHandleFromName() retreives a +** counter's handle from the counter database, given the name +** the counter was originally created with. +** +** INPUTS: +** qName: Counter's original QName. +** rName: Counter's original RName. +** +** OUTPUTS: +** +** RETURNS: +** PRCounterHandle or PRCounterError. +** +** RESTRICTIONS: +** +*/ +#define PR_GET_COUNTER_HANDLE_FROM_NAME(handle,qName,rName)\ + (handle) = PR_GetCounterHandleFromName((qName),(rName)) + +PR_EXTERN(PRCounterHandle) + PR_GetCounterHandleFromName( + const char *qName, + const char *rName +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_GetCounterNameFromHandle() -- Retreive a +** counter's name, given its handle. +** +** DESCRIPTION: PR_GetCounterNameFromHandle() retreives a +** counter's name given its handle. +** +** INPUTS: +** qName: Where to store a pointer to qName. +** rName: Where to store a pointer to rName. +** description: Where to store a pointer to description. +** +** OUTPUTS: Pointers to the Counter Feature's copies of the names +** used when the counters were created. +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_GET_COUNTER_NAME_FROM_HANDLE(handle,qName,rName,description)\ + PR_GetCounterNameFromHandle((handle),(qName),(rName),(description)) + +PR_EXTERN(void) + PR_GetCounterNameFromHandle( + PRCounterHandle handle, + const char **qName, + const char **rName, + const char **description +); + + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_IncrementCounter() -- Add one to the referenced +** counter. +** +** DESCRIPTION: Add one to the referenced counter. +** +** INPUTS: +** handle: The PRCounterHandle of the counter to be incremented +** +** OUTPUTS: The counter is incrementd. +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_INCREMENT_COUNTER(handle) PR_IncrementCounter(handle) + +PR_EXTERN(void) + PR_IncrementCounter( + PRCounterHandle handle +); + + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_DecrementCounter() -- Subtract one from the +** referenced counter +** +** DESCRIPTION: Subtract one from the referenced counter. +** +** INPUTS: +** handle: The PRCounterHandle of the coutner to be +** decremented. +** +** OUTPUTS: the counter is decremented. +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_DECREMENT_COUNTER(handle) PR_DecrementCounter(handle) + +PR_EXTERN(void) + PR_DecrementCounter( + PRCounterHandle handle +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_AddToCounter() -- Add a value to a counter. +** +** DESCRIPTION: Add value to the counter referenced by handle. +** +** INPUTS: +** handle: the PRCounterHandle of the counter to be added to. +** +** value: the value to be added to the counter. +** +** OUTPUTS: new value for counter. +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_ADD_TO_COUNTER(handle,value)\ + PR_AddToCounter((handle),(value)) + +PR_EXTERN(void) + PR_AddToCounter( + PRCounterHandle handle, + PRUint32 value +); + + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_SubtractFromCounter() -- A value is subtracted +** from a counter. +** +** DESCRIPTION: +** Subtract a value from a counter. +** +** INPUTS: +** handle: the PRCounterHandle of the counter to be subtracted +** from. +** +** value: the value to be subtracted from the counter. +** +** OUTPUTS: new value for counter +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_SUBTRACT_FROM_COUNTER(handle,value)\ + PR_SubtractFromCounter((handle),(value)) + +PR_EXTERN(void) + PR_SubtractFromCounter( + PRCounterHandle handle, + PRUint32 value +); + + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_GetCounter() -- Retreive the value of a counter +** +** DESCRIPTION: +** Retreive the value of a counter. +** +** INPUTS: +** handle: the PR_CounterHandle of the counter to be retreived +** +** OUTPUTS: +** +** RETURNS: The value of the referenced counter +** +** RESTRICTIONS: +** +*/ +#define PR_GET_COUNTER(counter,handle)\ + (counter) = PR_GetCounter((handle)) + +PR_EXTERN(PRUint32) + PR_GetCounter( + PRCounterHandle handle +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_SetCounter() -- Replace the content of counter +** with value. +** +** DESCRIPTION: The contents of the referenced counter are +** replaced by value. +** +** INPUTS: +** handle: the PRCounterHandle of the counter whose contents +** are to be replaced. +** +** value: the new value of the counter. +** +** OUTPUTS: +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_SET_COUNTER(handle,value) PR_SetCounter((handle),(value)) + +PR_EXTERN(void) + PR_SetCounter( + PRCounterHandle handle, + PRUint32 value +); + + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_FindNextCounterQname() -- Retreive the next QName counter +** handle iterator +** +** DESCRIPTION: +** PR_FindNextCounterQname() retreives the first or next Qname +** the counter data base, depending on the value of handle. When +** handle is NULL, the function attempts to retreive the first +** QName handle in the database. When handle is a handle previosly +** retreived QName handle, then the function attempts to retreive +** the next QName handle. +** +** INPUTS: +** handle: PRCounterHandle or NULL. +** +** OUTPUTS: returned +** +** RETURNS: PRCounterHandle or NULL when no more QName counter +** handles are present. +** +** RESTRICTIONS: +** A concurrent PR_CreateCounter() or PR_DestroyCounter() may +** cause unpredictable results. +** +** A PRCounterHandle returned from this function may only be used +** in another PR_FindNextCounterQname() function call; other +** operations may cause unpredictable results. +** +*/ +#define PR_FIND_NEXT_COUNTER_QNAME(next,handle)\ + (next) = PR_FindNextCounterQname((handle)) + +PR_EXTERN(PRCounterHandle) + PR_FindNextCounterQname( + PRCounterHandle handle +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_FindNextCounterRname() -- Retreive the next RName counter +** handle iterator +** +** DESCRIPTION: +** PR_FindNextCounterRname() retreives the first or next RNname +** handle from the counter data base, depending on the +** value of handle. When handle is NULL, the function attempts to +** retreive the first RName handle in the database. When handle is +** a handle previosly retreived RName handle, then the function +** attempts to retreive the next RName handle. +** +** INPUTS: +** handle: PRCounterHandle or NULL. +** qhandle: PRCounterHandle of a previously aquired via +** PR_FIND_NEXT_QNAME_HANDLE() +** +** OUTPUTS: returned +** +** RETURNS: PRCounterHandle or NULL when no more RName counter +** handles are present. +** +** RESTRICTIONS: +** A concurrent PR_CreateCounter() or PR_DestroyCounter() may +** cause unpredictable results. +** +** A PRCounterHandle returned from this function may only be used +** in another PR_FindNextCounterRname() function call; other +** operations may cause unpredictable results. +** +*/ +#define PR_FIND_NEXT_COUNTER_RNAME(next,rhandle,qhandle)\ + (next) = PR_FindNextCounterRname((rhandle),(qhandle)) + +PR_EXTERN(PRCounterHandle) + PR_FindNextCounterRname( + PRCounterHandle rhandle, + PRCounterHandle qhandle +); + + +#else /* ( !(defined(DEBUG) || defined(FORCE_NSPR_COUNTERS)) */ +/* +** When counters are not compiled in, provide macros that +** evaluate to No-Ops. +** +*/ + +#define PR_DEFINE_COUNTER(name) PRCounterHandle name +#define PR_INIT_COUNTER_HANDLE(handle,value) +#define PR_CREATE_COUNTER(handle,qName,rName,description) +#define PR_DESTROY_COUNTER(handle) +#define PR_GET_COUNTER_HANDLE_FROM_NAME(handle,qName,rName) +#define PR_GET_COUNTER_NAME_FROM_HANDLE(handle,qName,rName,description ) +#define PR_INCREMENT_COUNTER(handle) +#define PR_DECREMENT_COUNTER(handle) +#define PR_ADD_TO_COUNTER(handle,value) +#define PR_SUBTRACT_FROM_COUNTER(handle,value) +#define PR_GET_COUNTER(counter,handle) 0 +#define PR_SET_COUNTER(handle,value) +#define PR_FIND_NEXT_COUNTER_QNAME(next,handle) NULL +#define PR_FIND_NEXT_COUNTER_RNAME(next,rhandle,qhandle) + +#endif /* ( !(defined(DEBUG) || defined(FORCE_NSPR_COUNTERS)) */ + +PR_END_EXTERN_C + +#endif /* prcountr_h___ */ diff --git a/pr/include/prdtoa.h b/pr/include/prdtoa.h index fec81a59..22cfc58c 100644 --- a/pr/include/prdtoa.h +++ b/pr/include/prdtoa.h @@ -21,12 +21,6 @@ #include "prtypes.h" -/*******************************************************************************/ -/*******************************************************************************/ -/****************** THESE FUNCTIONS MAY NOT BE THREAD SAFE *********************/ -/*******************************************************************************/ -/*******************************************************************************/ - PR_BEGIN_EXTERN_C /* diff --git a/pr/include/prerror.h b/pr/include/prerror.h index 0f56f106..dbb7256b 100644 --- a/pr/include/prerror.h +++ b/pr/include/prerror.h @@ -25,7 +25,7 @@ PR_BEGIN_EXTERN_C typedef PRInt32 PRErrorCode; -#define PR_NSPR_ERROR_BASE -2600 +#define PR_NSPR_ERROR_BASE -6000 #define PR_OUT_OF_MEMORY_ERROR PR_NSPR_ERROR_BASE + 0 /* Insufficient memory to perform request */ @@ -147,7 +147,11 @@ typedef PRInt32 PRErrorCode; #define PR_ALREADY_INITIATED_ERROR PR_NSPR_ERROR_BASE + 67 #define PR_GROUP_EMPTY_ERROR PR_NSPR_ERROR_BASE + 68 #define PR_INVALID_STATE_ERROR PR_NSPR_ERROR_BASE + 69 -#define PR_MAX_ERROR PR_NSPR_ERROR_BASE + 70 +#define PR_NETWORK_DOWN_ERROR PR_NSPR_ERROR_BASE + 70 +#define PR_SOCKET_SHUTDOWN_ERROR PR_NSPR_ERROR_BASE + 71 +#define PR_CONNECT_ABORTED_ERROR PR_NSPR_ERROR_BASE + 72 +#define PR_HOST_UNREACHABLE_ERROR PR_NSPR_ERROR_BASE + 73 +#define PR_MAX_ERROR PR_NSPR_ERROR_BASE + 74 /* Place holder for the end of the list */ /* diff --git a/pr/include/prinit.h b/pr/include/prinit.h index cf1d5fa2..7ba12fea 100644 --- a/pr/include/prinit.h +++ b/pr/include/prinit.h @@ -44,7 +44,11 @@ PR_BEGIN_EXTERN_C ** The format of the version string is ** "<major version>.<minor version> <build date>" */ -#define PR_VERSION "2.1 yyyymmdd" +#define PR_VERSION "3.0 yyyymmdd" +#define PR_VMAJOR 3 +#define PR_VMINOR 0 +#define PR_VPATCH 0 +#define PR_BETA PR_TRUE /* ** PRVersionCheck @@ -81,8 +85,7 @@ PR_EXTERN(PRBool) PR_VersionCheck(const char *importedVersion); /* ** Initialize the runtime. Attach a thread object to the currently -** executing native thread of type "type" (as if PR_AttachThread were -** called). +** executing native thread of type "type". ** ** The specificaiton of 'maxPTDs' is ignored. */ @@ -142,6 +145,12 @@ PR_EXTERN(PRStatus) PR_Cleanup(void); PR_EXTERN(void) PR_DisableClockInterrupts(void); /* +** Enables Interrupts +** Enables timer signals used for pre-emptive scheduling. +*/ +PR_EXTERN(void) PR_EnableClockInterrupts(void); + +/* ** Block Interrupts ** Blocks the timer signal used for pre-emptive scheduling */ @@ -159,6 +168,13 @@ PR_EXTERN(void) PR_UnblockClockInterrupts(void); PR_EXTERN(void) PR_SetConcurrency(PRUintn numCPUs); /* +** Control the method and size of the file descriptor (PRFileDesc*) +** cache used by the runtime. Setting 'high' to zero is for performance, +** any other value probably for debugging (see memo on FD caching). +*/ +PR_EXTERN(PRStatus) PR_SetFDCacheSize(PRIntn low, PRIntn high); + +/* * Cause an immediate, nongraceful, forced termination of the process. * It takes a PRIntn argument, which is the exit status code of the * process. diff --git a/pr/include/prio.h b/pr/include/prio.h index 1cc6719e..89ffb871 100644 --- a/pr/include/prio.h +++ b/pr/include/prio.h @@ -1408,8 +1408,7 @@ PR_EXTERN(PRInt32) PR_TransmitFile( ** void *buf ** A pointer to a buffer to receive data sent by the client. This ** buffer must be large enough to receive <amount> bytes of data -** and two PRNetAddr structures (thus allowing the runtime to align -** the addresses as needed). +** and two PRNetAddr structures, plus an extra 32 bytes. ** PRInt32 amount ** The number of bytes of client data to receive. Does not include ** the size of the PRNetAddr structures. If 0, no data will be read @@ -1425,7 +1424,8 @@ PR_EXTERN(PRInt32) PR_TransmitFile( ** will only be valid if the function return does not indicate failure. ** PRNetAddr **peerAddr, ** The address of the remote socket. This parameter will only be -** valid if the function return does not indicate failure. +** valid if the function return does not indicate failure. The +** returned address is not guaranteed to be properly aligned. ** ** RETURNS: ** The number of bytes read from the client or -1 on failure. The reason @@ -1570,12 +1570,9 @@ struct PRPollDesc { /* ** Bit values for PRPollDesc.in_flags or PRPollDesc.out_flags. Binary-or ** these together to produce the desired poll request. -** -** On Unix platforms where the poll() system call is available, -** the various PR_POLL_XXX flags are mapped to the native poll flags. */ -#if defined(XP_UNIX) && defined(_PR_POLL_AVAILABLE) +#if defined(_PR_POLL_BACKCOMPAT) #include <poll.h> #define PR_POLL_READ POLLIN @@ -1583,16 +1580,18 @@ struct PRPollDesc { #define PR_POLL_EXCEPT POLLPRI #define PR_POLL_ERR POLLERR /* only in out_flags */ #define PR_POLL_NVAL POLLNVAL /* only in out_flags when fd is bad */ +#define PR_POLL_HUP POLLHUP /* only in out_flags */ -#else /* XP_UNIX, _PR_POLL_AVAILABLE */ +#else /* _PR_POLL_BACKCOMPAT */ #define PR_POLL_READ 0x1 #define PR_POLL_WRITE 0x2 #define PR_POLL_EXCEPT 0x4 #define PR_POLL_ERR 0x8 /* only in out_flags */ #define PR_POLL_NVAL 0x10 /* only in out_flags when fd is bad */ +#define PR_POLL_HUP 0x20 /* only in out_flags */ -#endif /* XP_UNIX, _PR_POLL_AVAILABLE */ +#endif /* _PR_POLL_BACKCOMPAT */ /* ************************************************************************* @@ -1632,6 +1631,55 @@ struct PRPollDesc { PR_EXTERN(PRInt32) PR_Poll( PRPollDesc *pds, PRIntn npds, PRIntervalTime timeout); +/* +************************************************************************** +** +** Pollable events +** +** A pollable event is a special kind of file descriptor. +** The only I/O operation you can perform on a pollable event +** is to poll it with the PR_POLL_READ flag. You can't +** read from or write to a pollable event. +** +** The purpose of a pollable event is to combine event waiting +** with I/O waiting in a single PR_Poll call. Pollable events +** are implemented using a pipe or a pair of TCP sockets +** connected via the loopback address, therefore setting and +** waiting for pollable events are expensive operating system +** calls. Do not use pollable events for general thread +** synchronization. Use condition variables instead. +** +** A pollable event has two states: set and unset. Events +** are not queued, so there is no notion of an event count. +** A pollable event is either set or unset. +** +** A new pollable event is created by a PR_NewPollableEvent +** call and is initially in the unset state. +** +** PR_WaitForPollableEvent blocks the calling thread until +** the pollable event is set, and then it atomically unsets +** the pollable event before it returns. +** +** To set a pollable event, call PR_SetPollableEvent. +** +** One can call PR_Poll with the PR_POLL_READ flag on a pollable +** event. When the pollable event is set, PR_Poll returns with +** the PR_POLL_READ flag set in the out_flags. +** +** To close a pollable event, call PR_DestroyPollableEvent +** (not PR_Close). +** +************************************************************************** +*/ + +PR_EXTERN(PRFileDesc *) PR_NewPollableEvent(void); + +PR_EXTERN(PRStatus) PR_DestroyPollableEvent(PRFileDesc *event); + +PR_EXTERN(PRStatus) PR_SetPollableEvent(PRFileDesc *event); + +PR_EXTERN(PRStatus) PR_WaitForPollableEvent(PRFileDesc *event); + PR_END_EXTERN_C #endif /* prio_h___ */ diff --git a/pr/include/private/Makefile b/pr/include/private/Makefile index c2e38c41..3a8b1e9f 100644 --- a/pr/include/private/Makefile +++ b/pr/include/private/Makefile @@ -24,7 +24,7 @@ include $(MOD_DEPTH)/config/config.mk RELEASE_HEADERS = pprio.h pprthred.h prpriv.h RELEASE_HEADERS_DEST = $(RELEASE_INCLUDE_DIR)/private -HEADERS = $(RELEASE_HEADERS) primpl.h +HEADERS = $(RELEASE_HEADERS) pprmwait.h primpl.h include $(MOD_DEPTH)/config/rules.mk diff --git a/pr/include/private/pprio.h b/pr/include/private/pprio.h index c9d6eec1..7e73b31e 100644 --- a/pr/include/private/pprio.h +++ b/pr/include/private/pprio.h @@ -28,8 +28,19 @@ #include "prtypes.h" #include "prio.h" -NSPR_BEGIN_EXTERN_C +PR_BEGIN_EXTERN_C +/* +** File descriptors of the NSPR layer can be in one of the +** following states (stored in the 'state' field of struct +** PRFilePrivate): +** - _PR_FILEDESC_OPEN: The OS fd is open. +** - _PR_FILEDESC_CLOSED: The OS fd is closed. The PRFileDesc +** is still open but is unusable. The only operation allowed +** on the PRFileDesc is PR_Close(). +** - _PR_FILEDESC_FREED: The OS fd is closed and the PRFileDesc +** structure is freed. +*/ #define _PR_FILEDESC_OPEN 0xaaaaaaaa /* 1010101... */ #define _PR_FILEDESC_CLOSED 0x55555555 /* 0101010... */ @@ -186,6 +197,6 @@ PR_EXTERN(void) PR_NT_UseNonblock(); #endif /* WIN32 */ -NSPR_END_EXTERN_C +PR_END_EXTERN_C #endif /* pprio_h___ */ diff --git a/pr/include/private/pprmwait.h b/pr/include/private/pprmwait.h new file mode 100644 index 00000000..edad3420 --- /dev/null +++ b/pr/include/private/pprmwait.h @@ -0,0 +1,112 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#if defined(_PPRMWAIT_H) +#else +#define _PPRMWAIT_H + +#include "prlock.h" +#include "prcvar.h" +#include "prclist.h" +#include "prthread.h" + +#define _PR_HASH_OFFSET 75013 +#define MAX_POLLING_INTERVAL 100 +#define _PR_POLL_COUNT_FUDGE 64 +#define MAX_POLLING_INTERVAL 100 +#define _PR_DEFAULT_HASH_LENGTH 59 + +#define _MW_REHASH(a, i, m) _MW_HASH((PRUptrdiff)(a) + (i) + _PR_HASH_OFFSET, m) +#define _MW_HASH(a, m) ((((PRUptrdiff)(a) >> 4) ^ ((PRUptrdiff)(a) >> 10)) % (m)) +#define _MW_ABORTED(_rv) \ + ((PR_FAILURE == (_rv)) && (PR_PENDING_INTERRUPT_ERROR == PR_GetError())) + +typedef enum {_prmw_success, _prmw_rehash, _prmw_error} _PR_HashStory; + +typedef struct _PRWaiterHash +{ + PRUint16 count; /* current number in hash table */ + PRUint16 length; /* current size of the hash table */ + PRRecvWait *recv_wait; /* hash table of receive wait objects */ +} _PRWaiterHash; + +typedef enum {_prmw_running, _prmw_stopping, _prmw_stopped} PRMWGroupState; + +struct PRWaitGroup +{ + PRCList group_link; /* all groups are linked to each other */ + PRCList io_ready; /* list of I/O requests that are ready */ + PRMWGroupState state; /* state of this group (so we can shut down) */ + + PRLock *ml; /* lock for synchronizing this wait group */ + PRCondVar *io_taken; /* calling threads notify when they take I/O */ + PRCondVar *io_complete; /* calling threads wait here for completions */ + PRCondVar *new_business; /* polling thread waits here more work */ + PRCondVar *mw_manage; /* used to manage group lists */ + PRThread* poller; /* thread that's actually doing the poll() */ + PRUint16 waiting_threads; /* number of threads waiting for recv */ + PRUint16 polling_count; /* number of elements in the polling list */ + PRUint32 p_timestamp; /* pseudo-time group had element removed */ + PRPollDesc *polling_list; /* list poller builds for polling */ + PRIntervalTime last_poll; /* last time we polled */ + _PRWaiterHash *waiter; /* pointer to hash table of wait receive objects */ + +#ifdef WINNT + /* + * On NT, idle threads are responsible for getting completed i/o. + * They need to add completed i/o to the io_ready list. Since + * idle threads cannot use nspr locks, we have to use an md lock + * to protect the io_ready list. + */ + _MDLock mdlock; /* protect io_ready, waiter, and wait_list */ + PRCList wait_list; /* used in place of io_complete. reuse + * waitQLinks in the PRThread structure. */ +#endif /* WINNT */ +}; + +/********************************************************************** +*********************************************************************** +******************** Wait group enumerations ************************** +*********************************************************************** +**********************************************************************/ +typedef struct _PRGlobalState +{ + PRCList group_list; /* master of the group list */ + PRWaitGroup *group; /* the default (NULL) group */ +} _PRGlobalState; + +#ifdef WINNT +extern PRStatus NT_HashRemoveInternal(PRWaitGroup *group, PRFileDesc *fd); +#endif + +typedef enum {_PR_ENUM_UNSEALED=0, _PR_ENUM_SEALED=0x0eadface} _PREnumSeal; + +struct PRMWaitEnumerator +{ + PRWaitGroup *group; /* group this enumerator is bound to */ + PRThread *thread; /* thread in midst of an enumeration */ + _PREnumSeal seal; /* trying to detect deleted objects */ + PRUint32 p_timestamp; /* when enumeration was (re)started */ + PRRecvWait **waiter; /* pointer into hash table */ + PRUintn index; /* position in hash table */ + void *pad[4]; /* some room to grow */ +}; + +#endif /* defined(_PPRMWAIT_H) */ + +/* pprmwait.h */ diff --git a/pr/include/private/primpl.h b/pr/include/private/primpl.h index 0d4bd69d..f4c32230 100644 --- a/pr/include/private/primpl.h +++ b/pr/include/private/primpl.h @@ -46,6 +46,8 @@ #include "nspr.h" #include "prpriv.h" +typedef struct PRSegment PRSegment; + #ifdef XP_MAC #include "prosdep.h" #include "probslet.h" @@ -128,18 +130,6 @@ typedef struct _MDFileMap _MDFileMap; ** stuff, this is a pretty small set. */ -struct _PT_Bookeeping -{ - PRLock *ml; /* a lock to protect ourselves */ - PRCondVar *cv; /* used to signal global things */ - PRUint16 system, user; /* a count of the two different types */ - PRUintn this_many; /* number of threads allowed for exit */ - pthread_key_t key; /* private private data key */ - pthread_key_t highwater; /* ordinal value of next key to be allocated */ - PRThread *first, *last; /* list of threads we know about */ - PRInt32 minPrio, maxPrio; /* range of scheduling priorities */ -}; - #define PT_CV_NOTIFIED_LENGTH 6 typedef struct _PT_Notified _PT_Notified; struct _PT_Notified @@ -162,7 +152,8 @@ struct _PT_Notified #define PT_THREAD_PRIMORD 0x08 /* this is the primordial thread */ #define PT_THREAD_ABORTED 0x10 /* thread has been interrupted */ #define PT_THREAD_GCABLE 0x20 /* thread is garbage collectible */ -#define PT_THREAD_SUSPENDED 0x40 /* thread has been suspended */ +#define PT_THREAD_SUSPENDED 0x40 /* thread has been suspended */ +#define PT_THREAD_FOREIGN 0x80 /* thread is not one of ours */ /* ** Possible values for thread's suspend field @@ -189,13 +180,23 @@ typedef struct PTDebug PRUintn cvars_notified, delayed_cv_deletes; } PTDebug; -PR_EXTERN(PTDebug) PT_GetStats(void); +PR_EXTERN(void) PT_GetStats(PTDebug* here); PR_EXTERN(void) PT_FPrintStats(PRFileDesc *fd, const char *msg); +#else + +typedef PRUintn PTDebug; +#define PT_GetStats(_p) +#define PT_FPrintStats(_fd, _msg) + #endif /* defined(DEBUG) */ #else /* defined(_PR_PTHREADS) */ +typedef PRUintn PTDebug; +#define PT_GetStats(_p) +#define PT_FPrintStats(_fd, _msg) + /* ** This section is contains those parts needed to implement NSPR on ** platforms in general. One would assume that the pthreads implementation @@ -273,7 +274,7 @@ typedef struct _PRInterruptTable { #define _PR_CPU_PTR(_qp) \ ((_PRCPU*) ((char*) (_qp) - offsetof(_PRCPU,links))) -#if !defined(IRIX) +#if !defined(IRIX) && !defined(WIN32) #define _MD_GET_ATTACHED_THREAD() (_PR_MD_CURRENT_THREAD()) #endif @@ -305,8 +306,6 @@ PR_EXTERN(PRInt32) _pr_intsOff; #define _MD_GET_INTSOFF() 0 #define _MD_SET_INTSOFF(_val) -#define _PR_SET_INTSOFF(_is) -#define _PR_GET_INTSOFF(_is) #define _PR_INTSOFF(_is) #define _PR_FAST_INTSON(_is) #define _PR_INTSON(_is) @@ -337,11 +336,6 @@ PR_EXTERN(PRInt32) _pr_intsOff; #else -#define _PR_SET_INTSOFF(_val) \ - PR_BEGIN_MACRO \ - _PR_MD_SET_INTSOFF(_val); \ - PR_END_MACRO - #define _PR_INTSOFF(_is) \ PR_BEGIN_MACRO \ (_is) = _PR_MD_GET_INTSOFF(); \ @@ -556,14 +550,6 @@ typedef struct _PRPerThreadExit { void *arg; } _PRPerThreadExit; -/* - * Thread private data destructor array - * There is a destructor (or NULL) associated with each key and - * applied to all threads known to the system. - * Storage allocated in prtpd.c. - */ -extern PRThreadPrivateDTOR *_pr_tpd_destructors; - /* PRThread.flags */ #define _PR_SYSTEM 0x01 #define _PR_INTERRUPT 0x02 @@ -575,7 +561,7 @@ extern PRThreadPrivateDTOR *_pr_tpd_destructors; #define _PR_GLOBAL_SCOPE 0x80 /* thread is global scope */ #define _PR_IDLE_THREAD 0x200 /* this is an idle thread */ #define _PR_GCABLE_THREAD 0x400 /* this is a collectable thread */ -#define _PR_BOUND_THREAD 0x800 /* a bound thread (only on solaris) */ +#define _PR_BOUND_THREAD 0x800 /* a bound thread */ /* PRThread.state */ #define _PR_UNBORN 0 @@ -667,9 +653,9 @@ extern PRUint32 _pr_utid; extern struct _PRCPU *_pr_primordialCPU; extern PRLock *_pr_activeLock; /* lock for userActive and systemActive */ -extern PRUintn _pr_userActive; /* number of active user threads */ -extern PRUintn _pr_systemActive; /* number of active system threads */ -extern PRUintn _pr_primordialExitCount; /* number of user threads left +extern PRInt32 _pr_userActive; /* number of active user threads */ +extern PRInt32 _pr_systemActive; /* number of active system threads */ +extern PRInt32 _pr_primordialExitCount; /* number of user threads left * before the primordial thread * can exit. */ extern PRCondVar *_pr_primordialExitCVar; /* the condition variable for @@ -718,10 +704,13 @@ PR_EXTERN(PRThread*) _PR_CreateThread(PRThreadType type, extern void _PR_NativeDestroyThread(PRThread *thread); extern void _PR_UserDestroyThread(PRThread *thread); -PR_EXTERN(PRThread*) _PRI_AttachThread( +extern PRThread* _PRI_AttachThread( PRThreadType type, PRThreadPriority priority, PRThreadStack *stack, PRUint32 flags); +extern void _PRI_DetachThread(void); + + #define _PR_IO_PENDING(_thread) ((_thread)->io_pending) PR_EXTERN(void) _PR_MD_INIT_CPUS(); @@ -735,6 +724,9 @@ PR_EXTERN(void) _PR_MD_WAKEUP_CPUS(); PR_EXTERN(void) _PR_MD_STOP_INTERRUPTS(void); #define _PR_MD_STOP_INTERRUPTS _MD_STOP_INTERRUPTS +PR_EXTERN(void) _PR_MD_ENABLE_CLOCK_INTERRUPTS(void); +#define _PR_MD_ENABLE_CLOCK_INTERRUPTS _MD_ENABLE_CLOCK_INTERRUPTS + PR_EXTERN(void) _PR_MD_DISABLE_CLOCK_INTERRUPTS(void); #define _PR_MD_DISABLE_CLOCK_INTERRUPTS _MD_DISABLE_CLOCK_INTERRUPTS @@ -995,34 +987,16 @@ extern PRInt32 _PR_MD_WRITEV( PRInt32 iov_size, PRIntervalTime timeout); #define _PR_MD_WRITEV _MD_WRITEV -extern PRInt32 _PR_MD_LSEEK(PRFileDesc *fd, PRInt32 offset, int whence); -#define _PR_MD_LSEEK _MD_LSEEK - -extern PRInt64 _PR_MD_LSEEK64(PRFileDesc *fd, PRInt64 offset, int whence); -#define _PR_MD_LSEEK64 _MD_LSEEK64 - extern PRInt32 _PR_MD_FSYNC(PRFileDesc *fd); #define _PR_MD_FSYNC _MD_FSYNC extern PRInt32 _PR_MD_DELETE(const char *name); #define _PR_MD_DELETE _MD_DELETE -extern PRInt32 _PR_MD_GETFILEINFO(const char *fn, PRFileInfo *info); -#define _PR_MD_GETFILEINFO _MD_GETFILEINFO - -extern PRInt32 _PR_MD_GETFILEINFO64(const char *fn, PRFileInfo64 *info); -#define _PR_MD_GETFILEINFO64 _MD_GETFILEINFO64 - -extern PRInt32 _PR_MD_GETOPENFILEINFO(const PRFileDesc *fd, PRFileInfo *info); -#define _PR_MD_GETOPENFILEINFO _MD_GETOPENFILEINFO - -extern PRInt32 _PR_MD_GETOPENFILEINFO64(const PRFileDesc *fd, PRFileInfo64 *info); -#define _PR_MD_GETOPENFILEINFO64 _MD_GETOPENFILEINFO64 - extern PRInt32 _PR_MD_RENAME(const char *from, const char *to); #define _PR_MD_RENAME _MD_RENAME -extern PRInt32 _PR_MD_ACCESS(const char *name, PRIntn how); +extern PRInt32 _PR_MD_ACCESS(const char *name, PRAccessHow how); #define _PR_MD_ACCESS _MD_ACCESS extern PRInt32 _PR_MD_STAT(const char *name, struct stat *buf); @@ -1174,16 +1148,63 @@ PR_EXTERN(void *) _PR_MD_GET_SP(PRThread *thread); *************************************************************************/ /************************************************************************/ +extern PRInt32 _PR_MD_LSEEK(PRFileDesc *fd, PRInt32 offset, PRSeekWhence whence); +#define _PR_MD_LSEEK _MD_LSEEK + +extern PRInt64 _PR_MD_LSEEK64(PRFileDesc *fd, PRInt64 offset, PRSeekWhence whence); +#define _PR_MD_LSEEK64 _MD_LSEEK64 + +extern PRInt32 _PR_MD_GETFILEINFO(const char *fn, PRFileInfo *info); +#define _PR_MD_GETFILEINFO _MD_GETFILEINFO + +extern PRInt32 _PR_MD_GETFILEINFO64(const char *fn, PRFileInfo64 *info); +#define _PR_MD_GETFILEINFO64 _MD_GETFILEINFO64 + +extern PRInt32 _PR_MD_GETOPENFILEINFO(const PRFileDesc *fd, PRFileInfo *info); +#define _PR_MD_GETOPENFILEINFO _MD_GETOPENFILEINFO + +extern PRInt32 _PR_MD_GETOPENFILEINFO64(const PRFileDesc *fd, PRFileInfo64 *info); +#define _PR_MD_GETOPENFILEINFO64 _MD_GETOPENFILEINFO64 + + +/*****************************************************************************/ +/************************** File descriptor caching **************************/ +/*****************************************************************************/ +extern void _PR_InitFdCache(void); +extern void _PR_CleanupFdCache(void); +extern PRFileDesc *_PR_Getfd(void); +extern void _PR_Putfd(PRFileDesc *fd); + +/* + * These flags are used by NSPR temporarily in the poll + * descriptor's out_flags field to record the mapping of + * NSPR's poll flags to the system poll flags. + * + * If _PR_POLL_READ_SYS_WRITE bit is set, it means the + * PR_POLL_READ flag specified by the topmost layer is + * mapped to the WRITE flag at the system layer. Similarly + * for the other three _PR_POLL_XXX_SYS_YYY flags. It is + * assumed that the PR_POLL_EXCEPT flag doesn't get mapped + * to other flags. + */ +#define _PR_POLL_READ_SYS_READ 0x1 +#define _PR_POLL_READ_SYS_WRITE 0x2 +#define _PR_POLL_WRITE_SYS_READ 0x4 +#define _PR_POLL_WRITE_SYS_WRITE 0x8 + /* ** These methods are coerced into file descriptor methods table ** when the intended service is inappropriate for the particular ** type of file descriptor. */ extern PRIntn _PR_InvalidInt(void); +extern PRInt16 _PR_InvalidInt16(void); extern PRInt64 _PR_InvalidInt64(void); extern PRStatus _PR_InvalidStatus(void); extern PRFileDesc *_PR_InvalidDesc(void); +extern PRIOMethods _pr_faulty_methods; + extern PRStatus _PR_MapOptionName( PRSockOption optname, PRInt32 *level, PRInt32 *name); extern void _PR_InitThreads( @@ -1229,9 +1250,9 @@ struct PRCondVar { struct PRMonitor { const char* name; /* monitor name for debugging */ #if defined(_PR_PTHREADS) - PRLock lock; /* the lock struture structure */ + PRLock lock; /* the lock struture structure */ pthread_t owner; /* the owner of the lock or zero */ - PRCondVar cvar; /* condition variable queue */ + PRCondVar *cvar; /* condition variable queue */ #else /* defined(_PR_PTHREADS) */ PRCondVar *cvar; /* associated lock and condition variable queue */ #endif /* defined(_PR_PTHREADS) */ @@ -1274,19 +1295,23 @@ struct PRThreadStack { #endif /* defined(_PR_PTHREADS) */ }; +/* + * Thread private data destructor array + * There is a destructor (or NULL) associated with each key and + * applied to all threads known to the system. + * Storage allocated in prtpd.c. + */ +extern PRThreadPrivateDTOR *_pr_tpd_destructors; +extern void _PR_DestroyThreadPrivate(PRThread*); +typedef void (PR_CALLBACK *_PRStartFn)(void *); struct PRThread { PRUint32 state; /* thread's creation state */ PRThreadPriority priority; /* apparent priority, loosly defined */ - PRInt32 errorStringSize; /* byte length of current error string | zero */ - PRErrorCode errorCode; /* current NSPR error code | zero */ - PRInt32 osErrorCode; /* mapping of errorCode | zero */ - - char *errorString; /* current error string | NULL */ void *arg; /* argument to the client's entry point */ - void (PR_CALLBACK *startFunc)(void *arg); /* the root of the client's thread */ + _PRStartFn startFunc; /* the root of the client's thread */ PRThreadStack *stack; /* info about thread's stack (for GC) */ void *environment; /* pointer to execution environment */ @@ -1294,6 +1319,16 @@ struct PRThread { PRThreadDumpProc dump; /* dump thread info out */ void *dumpArg; /* argument for the dump function */ + /* + ** Per thread private data + */ + PRUint32 tpdLength; /* thread's current vector length */ + void **privateData; /* private data vector or NULL */ + PRInt32 errorStringSize; /* byte length of current error string | zero */ + PRErrorCode errorCode; /* current NSPR error code | zero */ + PRInt32 osErrorCode; /* mapping of errorCode | zero */ + char *errorString; /* current error string | NULL */ + #if defined(_PR_PTHREADS) pthread_t id; /* pthread identifier for the thread */ PRBool okToDelete; /* ok to delete the PRThread struct? */ @@ -1308,13 +1343,13 @@ struct PRThread { #endif #else /* defined(_PR_PTHREADS) */ _MDLock threadLock; /* Lock to protect thread state variables. - * Protects the following fields: - * state - * priority - * links - * wait - * cpu - */ + * Protects the following fields: + * state + * priority + * links + * wait + * cpu + */ PRUint32 queueCount; PRUint32 waitCount; @@ -1330,17 +1365,24 @@ struct PRThread { PRUint32 id; PRUint32 flags; - PRUint32 no_sched; + PRUint32 no_sched; /* Don't schedule the thread to run. + * This flag has relevance only when + * multiple NSPR CPUs are created. + * When a thread is de-scheduled, there + * is a narrow window of time in which + * the thread is put on the run queue + * but the scheduler is actually using + * the stack of this thread. It is safe + * to run this thread on a different CPU + * only when its stack is not in use on + * any other CPU. The no_sched flag is + * set during this interval to prevent + * the thread from being scheduled on a + * different CPU. + */ PRUint32 numExits; _PRPerThreadExit *ptes; - - /* - ** Per thread private data - */ - PRUint32 tpdLength; /* thread's current vector length */ - void **privateData; /* private data vector or NULL */ - /* thread termination condition variable for join */ PRCondVar *term; @@ -1413,6 +1455,7 @@ extern void _PR_InitLinker(void); extern void _PR_InitAtomic(void); extern void _PR_InitCPUs(void); extern void _PR_InitDtoa(void); +extern void _PR_InitMW(void); extern void _PR_NotifyCondVar(PRCondVar *cvar, PRThread *me); extern void _PR_CleanupThread(PRThread *thread); extern void _PR_CleanupTPD(void); @@ -1427,7 +1470,6 @@ extern PRBool _PR_Obsolete(const char *obsolete, const char *preferred); /************************************************************************/ struct PRSegment { - PRSegmentAccess access; void *vaddr; PRUint32 size; PRUintn flags; @@ -1440,6 +1482,32 @@ struct PRSegment { /* PRSegment.flags */ #define _PR_SEG_VM 0x1 +/*********************************************************************** +** FUNCTION: _PR_NewSegment() +** DESCRIPTION: +** Allocate a memory segment. The "size" value is rounded up to the +** native system page size and a page aligned portion of memory is +** returned. This memory is not part of the malloc heap. If "vaddr" is +** not NULL then PR tries to allocate the segment at the desired virtual +** address. +** INPUTS: size: size of the desired memory segment +** vaddr: address at which the newly aquired segment is to be +** mapped into memory. +** OUTPUTS: a memory segment is allocated, a PRSegment is allocated +** RETURN: pointer to PRSegment +***********************************************************************/ +extern PRSegment* _PR_NewSegment(PRUint32 size, void *vaddr); + +/*********************************************************************** +** FUNCTION: _PR_DestroySegment() +** DESCRIPTION: +** The memory segment and the PRSegment are freed +** INPUTS: seg: pointer to PRSegment to be freed +** OUTPUTS: the the PRSegment and its associated memory segment are freed +** RETURN: void +***********************************************************************/ +extern void _PR_DestroySegment(PRSegment *seg); + /************************************************************************/ extern PRInt32 _pr_pageSize; @@ -1465,14 +1533,9 @@ extern PRBool _pr_ipv6_enabled; /* defined in prnetdb.c */ /* Overriding malloc, free, etc. */ #if !defined(_PR_NO_PREEMPT) && defined(XP_UNIX) \ - && (!defined(SOLARIS) || !defined(_PR_GLOBAL_THREADS_ONLY)) \ - && (!defined(AIX) || !defined(_PR_PTHREADS)) \ - && (!defined(OSF1) || !defined(_PR_PTHREADS)) \ - && (!defined(HPUX) || !defined(_PR_PTHREADS)) \ - && (!defined(IRIX) || !defined(_PR_PTHREADS)) \ - && (!defined(LINUX) || !defined(_PR_PTHREADS)) \ - && (!defined(RHAPSODY)) \ + && !defined(_PR_PTHREADS) && !defined(_PR_GLOBAL_THREADS_ONLY) \ && !defined(PURIFY) \ + && !defined(RHAPSODY) \ && !(defined (UNIXWARE) && defined (USE_SVR4_THREADS)) #define _PR_OVERRIDE_MALLOC #endif @@ -1531,6 +1594,9 @@ extern void _PR_MD_INIT_ATOMIC(void); extern PRInt32 _PR_MD_ATOMIC_INCREMENT(PRInt32 *); #define _PR_MD_ATOMIC_INCREMENT _MD_ATOMIC_INCREMENT +extern PRInt32 _PR_MD_ATOMIC_ADD(PRInt32 *, PRInt32); +#define _PR_MD_ATOMIC_ADD _MD_ATOMIC_ADD + extern PRInt32 _PR_MD_ATOMIC_DECREMENT(PRInt32 *); #define _PR_MD_ATOMIC_DECREMENT _MD_ATOMIC_DECREMENT diff --git a/pr/include/prlog.h b/pr/include/prlog.h index 9be6c13f..8369c64c 100644 --- a/pr/include/prlog.h +++ b/pr/include/prlog.h @@ -74,7 +74,12 @@ PR_BEGIN_EXTERN_C ** log buffer to <size>. ** ** The environment variable NSPR_LOG_FILE specifies the log file to use -** unless the default of "stderr" is acceptable. +** unless the default of "stderr" is acceptable. For MS Windows +** systems, NSPR_LOG_FILE can be set to a special value: "WinDebug" +** (case sensitive). This value causes PR_LOG() output to be written +** using the Windows API OutputDebugString(). OutputDebugString() +** writes to the debugger window; some people find this helpful. +** ** ** To put log messages in your programs, use the PR_LOG macro: ** @@ -141,11 +146,6 @@ typedef struct PRLogModuleInfo { PR_EXTERN(PRLogModuleInfo*) PR_NewLogModule(const char *name); /* -** Destroys a log module. -*/ -PR_EXTERN(void) PR_DestroyLogModule(PRLogModuleInfo* logModule); - -/* ** Set the file to use for logging. Returns PR_FALSE if the file cannot ** be created */ diff --git a/pr/include/prmem.h b/pr/include/prmem.h index dc88f755..2a6c766a 100644 --- a/pr/include/prmem.h +++ b/pr/include/prmem.h @@ -135,109 +135,6 @@ PR_EXTERN(void) PR_Free(void *ptr); ***********************************************************************/ #define PR_FREEIF(_ptr) if (_ptr) PR_DELETE(_ptr) -/*********************************************************************** -** Typedef ENUM: PRSegmentAccess -** DESCRIPTION: -** Defines a number of segment accessor types for PR_Seg* functions -** -***********************************************************************/ -typedef struct PRSegment PRSegment; -typedef enum { - PR_SEGMENT_NONE, - PR_SEGMENT_RDONLY, - PR_SEGMENT_RDWR -} PRSegmentAccess; - -/*********************************************************************** -** FUNCTION: PR_NewSegment() -** DESCRIPTION: -** Allocate a memory segment. The "size" value is rounded up to the -** native system page size and a page aligned portion of memory is -** returned. This memory is not part of the malloc heap. If "vaddr" is -** not NULL then PR tries to allocate the segment at the desired virtual -** address. Segments are mapped PR_SEGMENT_RDWR when created. -** INPUTS: size: size of the desired memory segment -** vaddr: address at which the newly aquired segment is to be -** mapped into memory. -** OUTPUTS: a memory segment is allocated, a PRSegment is allocated -** RETURN: pointer to PRSegment -***********************************************************************/ -PR_EXTERN(PRSegment*) PR_NewSegment(PRUint32 size, void *vaddr); - -/*********************************************************************** -** FUNCTION: PR_DestroySegment() -** DESCRIPTION: -** The memory segment and the PRSegment are freed -** INPUTS: seg: pointer to PRSegment to be freed -** OUTPUTS: the the PRSegment and its associated memory segment are freed -** RETURN: void -***********************************************************************/ -PR_EXTERN(void) PR_DestroySegment(PRSegment *seg); - -/*********************************************************************** -** FUNCTION: PR_GrowSegment() -** DESCRIPTION: -** Attempt to grow/shrink a memory segment. If deltaBytes is positive, -** the segment is grown. If deltaBytes is negative, the segment is -** shrunk. This returns the number of bytes added to the segment if -** successful, zero otherwise. -** INPUTS: seg: pointer to a PRSegment -** OUTPUTS: -** RETURN: PRUint32: number of bytes added to the memory segment or zero -***********************************************************************/ -PR_EXTERN(PRUint32) PR_GrowSegment(PRSegment *seg, PRInt32 deltaBytes); - -/*********************************************************************** -** FUNCTION: PR_GetSegmentVaddr() -** DESCRIPTION: -** PR_Segment member accessor function. -** Return the virtual address of the memory segment -** -** INPUTS: seg: pointer to a PRSegment -** OUTPUTS: none -** RETURN: void*: Address where the memory segment is mapped. -***********************************************************************/ -PR_EXTERN(void*) PR_GetSegmentVaddr(PRSegment *seg); - -/*********************************************************************** -** FUNCTION: PR_GetSegmentSize() -** DESCRIPTION: -** PR_Segment member accessor function. -** Return the size of the associated memory segment -** INPUTS: seg: pointer to a PRSegment -** OUTPUTS: none -** RETURN: size_t: size of the associated memory segment -***********************************************************************/ -PR_EXTERN(size_t) PR_GetSegmentSize(PRSegment *seg); - -/*********************************************************************** -** FUNCTION: PR_MapSegment() -** DESCRIPTION: -** Change the mapping on a segment. -** "how" == PR_SEGMENT_NONE: the segment becomes unmapped -** "how" == PR_SEGMENT_RDONLY: the segment becomes mapped and readable -** "how" == PR_SEGMENT_RDWR: the segment becomes mapped read/write -** -** Note: If a segment can be read then it is also possible to execute -** code in it. -** INPUTS: seg: pointer to a PRSegment -** how: one of PRSegmentAccess enumerated values -** OUTPUTS: the access for the associated memory segment is changed -** RETURN: void -***********************************************************************/ -PR_EXTERN(void) PR_MapSegment(PRSegment *seg, PRSegmentAccess how); - -/*********************************************************************** -** FUNCTION: PR_GetSegmentAccess() -** DESCRIPTION: -** PR_Segment member accessor function. -** Return a memory segment's current access rights -** INPUTS: seg: pointer to a PRSegment -** OUTPUTS: -** RETURN: PRSegmentAccess: current access rights -***********************************************************************/ -PR_EXTERN(PRSegmentAccess) PR_GetSegmentAccess(PRSegment *seg); - PR_END_EXTERN_C #endif /* prmem_h___ */ diff --git a/pr/include/prmwait.h b/pr/include/prmwait.h index c63398bd..91f44393 100644 --- a/pr/include/prmwait.h +++ b/pr/include/prmwait.h @@ -53,7 +53,7 @@ typedef struct PRWaitGroup PRWaitGroup; ** ENUMERATION: PRMWStatus ** DESCRIPTION: ** This enumeration is used to indicate the completion status of -** a recieve wait object. Generally stated, a positive value indicates +** a receive wait object. Generally stated, a positive value indicates ** that the operation is not yet complete. A zero value indicates ** success (similar to PR_SUCCESS) and any negative value is an ** indication of failure. The reason for the failure can be retrieved @@ -94,6 +94,15 @@ typedef struct PRMemoryDescriptor } PRMemoryDescriptor; /* +** STRUCTURE: PRMWaitClientData +** DESCRIPTION: +** An opague stucture for which a client MAY give provide a concrete +** definition and associate with a receive descriptor. The NSPR runtime +** does not manage this field. It is completely up to the client. +*/ +typedef struct PRMWaitClientData PRMWaitClientData; + +/* ** STRUCTURE: PRRecvWait ** DESCRIPTION: ** A receive wait object contains the file descriptor that is subject @@ -117,10 +126,22 @@ typedef struct PRRecvWait PRMWStatus outcome; /* outcome of the current/last operation */ PRIntervalTime timeout; /* time allowed for entire operation */ - PRInt32 bytesRecv; /* number of bytes transferred into buffer */ + PRInt32 bytesRecv; /* number of bytes transferred into buffer */ PRMemoryDescriptor buffer; /* where to store first segment of input data */ + PRMWaitClientData *client; /* pointer to arbitrary client defined data */ } PRRecvWait; +/* +** STRUCTURE: PRMWaitEnumerator +** DESCRIPTION: +** An enumeration object is used to store the state of an existing +** enumeration over a wait group. The opaque object must be allocated +** by the client and the reference presented on each call to the +** pseudo-stateless enumerator. The enumeration objects are sharable +** only in serial fashion. +*/ +typedef struct PRMWaitEnumerator PRMWaitEnumerator; + /* ** FUNCTION: PR_AddWaitFileDesc @@ -139,7 +160,7 @@ typedef struct PRRecvWait ** to semantically group various file descriptors by the ** client's application. ** desc A reference to a valid PRRecvWait. The object of the -** reference must be preserved and treated as read-only +** reference must be preserved and not be modified ** until its ownership is returned to the client. ** RETURN ** PRStatus An indication of success. If equal to PR_FAILUE details @@ -295,12 +316,76 @@ PR_EXTERN(PRWaitGroup*) PR_CreateWaitGroup(PRInt32 size); ** ** ERRORS ** PR_INVALID_ARGUMENT_ERROR - The 'group' argument does not reference a known object. +** The 'group' argument does not reference a known object. ** PR_INVALID_STATE_ERROR ** The group still contains receive wait objects. */ PR_EXTERN(PRStatus) PR_DestroyWaitGroup(PRWaitGroup *group); +/* +** FUNCTION: PR_CreateMWaitEnumerator +** DESCRIPTION: +** The PR_CreateMWaitEnumerator() function returns a reference to an +** opaque PRMWaitEnumerator object. The enumerator object is required +** as an argument for each successive call in the stateless enumeration +** of the indicated wait group. +** +** group The wait group that the enumeration is intended to +** process. It may be be the default wait group (NULL). +** RETURN +** PRMWaitEnumerator* group +** A reference to an object that will be used to store +** intermediate state of enumerations. +** ERRORS +** Errors are indicated by the function returning a NULL. +** PR_INVALID_ARGUMENT_ERROR +** The 'group' argument does not reference a known object. +** PR_OUT_OF_MEMORY_ERROR +*/ +PR_EXTERN(PRMWaitEnumerator*) PR_CreateMWaitEnumerator(PRWaitGroup *group); + +/* +** FUNCTION: PR_DestroyMWaitEnumerator +** DESCRIPTION: +** Destroys the object created by PR_CreateMWaitEnumerator(). The reference +** used as an argument becomes invalid. +** +** INPUT +** PRMWaitEnumerator* enumerator +** The PRMWaitEnumerator object to destroy. +** RETURN +** PRStatus +** PR_SUCCESS if successful, PR_FAILURE otherwise. +** ERRORS +** PR_INVALID_ARGUMENT_ERROR +** The enumerator is invalid. +*/ +PR_EXTERN(PRStatus) PR_DestroyMWaitEnumerator(PRMWaitEnumerator* enumerator); + +/* +** FUNCTION: PR_EnumerateWaitGroup +** DESCRIPTION: +** PR_EnumerateWaitGroup is a thread safe enumerator over a wait group. +** Each call to the enumerator must present a valid PRMWaitEnumerator +** rererence and a pointer to the "previous" element returned from the +** enumeration process or a NULL. +** +** An enumeration is started by passing a NULL as the "previous" value. +** Subsequent calls to the enumerator must pass in the result of the +** previous call. The enumeration end is signaled by the runtime returning +** a NULL as the result. +** +** Modifications to the content of the wait group are allowed during +** an enumeration. The effect is that the enumeration may have to be +** "reset" and that may result in duplicates being returned from the +** enumeration. +** +** An enumeration may be abandoned at any time. The runtime is not +** keeping any state, so there are no issues in that regard. +*/ +PR_EXTERN(PRRecvWait*) PR_EnumerateWaitGroup( + PRMWaitEnumerator *enumerator, const PRRecvWait *previous); + PR_END_EXTERN_C #endif /* defined(_PRMWAIT_H) */ diff --git a/pr/include/prolock.h b/pr/include/prolock.h new file mode 100644 index 00000000..b9dcd9f9 --- /dev/null +++ b/pr/include/prolock.h @@ -0,0 +1,196 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef prolock_h___ +#define prolock_h___ + +#include "prtypes.h" + +PR_BEGIN_EXTERN_C + +#if defined(DEBUG) || defined(FORCE_NSPR_ORDERED_LOCKS) + +/* +** A locking mechanism, built on the existing PRLock definiion, +** is provided that will permit applications to define a Lock +** Hierarchy (or Lock Ordering) schema. An application designed +** using the Ordered Lock functions will terminate with a +** diagnostic message when a lock inversion condition is +** detected. +** +** The lock ordering detection is complile-time enabled only. in +** optimized builds of NSPR, the Ordered Lock functions map +** directly to PRLock functions, providing no lock order +** detection. +** +** The Ordered Lock Facility is compiled in when DEBUG is defined at +** compile time. Ordered Lock can be forced on in optimized builds by +** defining FORCE_NSPR_ORDERED_LOCK at compile time. Both the +** application using Ordered Lock and NSPR must be compiled with the +** facility enabled to achieve the desired results. +** +** Application designers should use the macro interfaces to the Ordered +** Lock facility to ensure that it is compiled out in optimized builds. +** +** Application designers are responsible for defining their own +** lock hierarchy. +** +** Ordered Lock is thread-safe and SMP safe. +** +** See Also: prlock.h +** +** /lth. 10-Jun-1998. +** +*/ + +/* +** Opaque type for ordered lock. +** ... Don't even think of looking in here. +** +*/ + +typedef void * PROrderedLock; + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_CreateOrderedLock() -- Create an Ordered Lock +** +** DESCRIPTION: PR_CreateOrderedLock() creates an ordered lock. +** +** INPUTS: +** order: user defined order of this lock. +** name: name of the lock. For debugging purposes. +** +** OUTPUTS: returned +** +** RETURNS: PR_OrderedLock pointer +** +** RESTRICTIONS: +** +*/ +#define PR_CREATE_ORDERED_LOCK(order,name)\ + PR_CreateOrderedLock((order),(name)) + +PR_EXTERN(PROrderedLock *) + PR_CreateOrderedLock( + PRInt32 order, + const char *name +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_DestroyOrderedLock() -- Destroy an Ordered Lock +** +** DESCRIPTION: PR_DestroyOrderedLock() destroys the ordered lock +** referenced by lock. +** +** INPUTS: lock: pointer to a PROrderedLock +** +** OUTPUTS: the lock is destroyed +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_DESTROY_ORDERED_LOCK(lock) PR_DestroyOrderedLock((lock)) + +PR_EXTERN(void) + PR_DestroyOrderedLock( + PROrderedLock *lock +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_LockOrderedLock() -- Lock an ordered lock +** +** DESCRIPTION: PR_LockOrderedLock() locks the ordered lock +** referenced by lock. If the order of lock is less than or equal +** to the order of the highest lock held by the locking thread, +** the function asserts. +** +** INPUTS: lock: a pointer to a PROrderedLock +** +** OUTPUTS: The lock is held or the fucntion asserts. +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_LOCK_ORDERED_LOCK(lock) PR_LockOrderedLock((lock)) + +PR_EXTERN(void) + PR_LockOrderedLock( + PROrderedLock *lock +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_UnlockOrderedLock() -- unlock and Ordered Lock +** +** DESCRIPTION: PR_UnlockOrderedLock() unlocks the lock referenced +** by lock. +** +** INPUTS: lock: a pointer to a PROrderedLock +** +** OUTPUTS: the lock is unlocked +** +** RETURNS: +** PR_SUCCESS +** PR_FAILURE +** +** RESTRICTIONS: +** +*/ +#define PR_UNLOCK_ORDERED_LOCK(lock) PR_UnlockOrderedLock((lock)) + +PR_EXTERN(PRStatus) + PR_UnlockOrderedLock( + PROrderedLock *lock +); + +#else /* !(defined(DEBUG) || defined(FORCE_NSPR_ORDERED_LOCKS)) */ +/* +** Map PROrderedLock and methods onto PRLock when ordered locking +** is not compiled in. +** +*/ +#include <prlock.h> + +typedef PRLock PROrderedLock; + +#define PR_CREATE_ORDERED_LOCK(order) PR_NewLock() +#define PR_DESTROY_ORDERED_LOCK(lock) PR_DestroyLock((lock)) +#define PR_LOCK_ORDERED_LOCK(lock) PR_Lock((lock)) +#define PR_UNLOCK_ORDERED_LOCK(lock) PR_Unlock((lock)) + +#endif /* !(defined(DEBUG) || defined(FORCE_NSPR_ORDERED_LOCKS)) */ + +PR_END_EXTERN_C + +#endif /* prolock_h___ */ + + + + + + + + + + + + + diff --git a/pr/include/prpdce.h b/pr/include/prpdce.h index 32a5cf58..b0bc7853 100644 --- a/pr/include/prpdce.h +++ b/pr/include/prpdce.h @@ -31,6 +31,8 @@ #include "prtypes.h" #include "prinrval.h" +PR_BEGIN_EXTERN_C + #define _PR_NAKED_CV_LOCK (PRLock*)0xdce1dce1 /* @@ -92,4 +94,6 @@ PR_EXTERN(PRStatus) PRP_NakedNotify(PRCondVar *cvar); */ PR_EXTERN(PRStatus) PRP_NakedBroadcast(PRCondVar *cvar); +PR_END_EXTERN_C + #endif /* PRPDCE_H */ diff --git a/pr/include/prtrace.h b/pr/include/prtrace.h new file mode 100644 index 00000000..807d4e45 --- /dev/null +++ b/pr/include/prtrace.h @@ -0,0 +1,635 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef prtrace_h___ +#define prtrace_h___ +/* +** prtrace.h -- NSPR's Trace Facility. +** +** The Trace Facility provides a means to trace application +** program events within a process. When implementing an +** application program an engineer may insert a "Trace" function +** call, passing arguments to be traced. The "Trace" function +** combines the user trace data with identifying data and +** writes this data in time ordered sequence into a circular +** in-memory buffer; when the buffer fills, it wraps. +** +** Functions are provided to set and/or re-configure the size of +** the trace buffer, control what events are recorded in the +** buffer, enable and disable tracing based on specific user +** supplied data and other control functions. Methods are provided +** to record the trace entries in the in-memory trace buffer to +** a file. +** +** Tracing may cause a performance degredation to the application +** depending on the number and placement of calls to the tracing +** facility. When tracing is compiled in and all tracing is +** disabled via the runtime controls, the overhead should be +** minimal. ... Famous last words, eh? +** +** When DEBUG is defined at compile time, the Trace Facility is +** compiled as part of NSPR and any application using NSPR's +** header files will have tracing compiled in. When DEBUG is not +** defined, the Trace Facility is not compiled into NSPR nor +** exported in its header files. If the Trace Facility is +** desired in a non-debug build, then FORCE_NSPR_TRACE may be +** defined at compile time for both the optimized build of NSPR +** and the application. NSPR and any application using NSPR's +** Trace Facility must be compiled with the same level of trace +** conditioning or unresolved references may be realized at link +** time. +** +** For any of the Trace Facility methods that requires a trace +** handle as an input argument, the caller must ensure that the +** trace handle argument is valid. An invalid trace handle +** argument may cause unpredictable results. +** +** Trace Facility methods are thread-safe and SMP safe. +** +** Users of the Trace Facility should use the defined macros to +** invoke trace methods, not the function calls directly. e.g. +** PR_TRACE( h1,0,1,2, ...); not PR_Trace(h1,0,1,2, ...); +** +** Application designers should be aware of the effects of +** debug and optimized build differences when using result of the +** Trace Facility macros in expressions. +** +** See Also: prcountr.h +** +** /lth. 08-Jun-1998. +*/ + +#include "prtypes.h" +#include "prthread.h" +#include "prtime.h" + +PR_BEGIN_EXTERN_C + +/* +** Opaque type for the trace handle +** ... Don't even think about looking in here. +** +*/ +typedef void * PRTraceHandle; + +#if defined (DEBUG) || defined (FORCE_NSPR_TRACE) +/* +** PRTraceEntry -- A trace entry in the in-memory trace buffer +** looks like this. +** +*/ +typedef struct PRTraceEntry +{ + PRThread *thread; /* The thread creating the trace entry */ + PRTraceHandle handle; /* PRTraceHandle creating the trace entry */ + PRTime time; /* Value of PR_Now() at time of trace entry */ + PRUint32 userData[8]; /* user supplied trace data */ +} PRTraceEntry; + +/* +** PRTraceOption -- command operands to +** PR_[Set|Get]TraceOption(). See descriptive meanings there. +** +*/ +typedef enum PRTraceOption +{ + PRTraceBufSize, + PRTraceEnable, + PRTraceDisable, + PRTraceSuspend, + PRTraceResume, + PRTraceSuspendRecording, + PRTraceResumeRecording, + PRTraceLockHandles, + PRTraceUnLockHandles, + PRTraceStopRecording +} PRTraceOption; + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_DEFINE_TRACE() -- Define a PRTraceHandle +** +** DESCRIPTION: PR_DEFINE_TRACE() is used to define a trace +** handle. +** +*/ +#define PR_DEFINE_TRACE(name) PRTraceHandle name + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_INIT_TRACE_HANDLE() -- Set the value of a PRTraceHandle +** +** DESCRIPTION: +** PR_INIT_TRACE_HANDLE() sets the value of a PRTraceHandle +** to value. e.g. PR_INIT_TRACE_HANDLE( myHandle, NULL ); +** +*/ +#define PR_INIT_TRACE_HANDLE(handle,value)\ + (handle) = (PRCounterHandle)(value) + + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_CreateTrace() -- Create a trace handle +** +** DESCRIPTION: +** PR_CreateTrace() creates a new trace handle. Tracing is +** enabled for this handle when it is created. The trace handle +** is intended for use in other Trace Facility calls. +** +** PR_CreateTrace() registers the QName, RName and description +** data so that this data can be retrieved later. +** +** INPUTS: +** qName: pointer to string. QName for this trace handle. +** +** rName: pointer to string. RName for this trace handle. +** +** description: pointer to string. Descriptive data about this +** trace handle. +** +** OUTPUTS: +** Creates the trace handle. +** Registers the QName and RName with the trace facility. +** +** RETURNS: +** PRTraceHandle +** +** RESTRICTIONS: +** qName is limited to 31 characters. +** rName is limited to 31 characters. +** description is limited to 255 characters. +** +*/ +#define PRTRACE_NAME_MAX 31 +#define PRTRACE_DESC_MAX 255 + +#define PR_CREATE_TRACE(handle,qName,rName,description)\ + (handle) = PR_CreateTrace((qName),(rName),(description)) + +PR_EXTERN(PRTraceHandle) + PR_CreateTrace( + const char *qName, /* QName for this trace handle */ + const char *rName, /* RName for this trace handle */ + const char *description /* description for this trace handle */ +); + + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_DestroyTrace() -- Destroy a trace handle +** +** DESCRIPTION: +** PR_DestroyTrace() removes the referenced trace handle and +** associated QName, RName and description data from the Trace +** Facility. +** +** INPUTS: handle. A PRTraceHandle +** +** OUTPUTS: +** The trace handle is unregistered. +** The QName, RName and description are removed. +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_DESTROY_TRACE(handle)\ + PR_DestroyTrace((handle)) + +PR_EXTERN(void) + PR_DestroyTrace( + PRTraceHandle handle /* Handle to be destroyed */ +); + + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_Trace() -- Make a trace entry in the in-memory trace +** +** DESCRIPTION: +** PR_Trace() makes an entry in the in-memory trace buffer for +** the referenced trace handle. The next logically available +** PRTraceEntry is used; when the next trace entry would overflow +** the trace table, the table wraps. +** +** PR_Trace() for a specific trace handle may be disabled by +** calling PR_SetTraceOption() specifying PRTraceDisable for the +** trace handle to be disabled. +** +** INPUTS: +** handle: PRTraceHandle. The trace handle for this trace. +** +** userData[0..7]: unsigned 32bit integers. user supplied data +** that is copied into the PRTraceEntry +** +** OUTPUTS: +** A PRTraceEntry is (conditionally) formatted in the in-memory +** trace buffer. +** +** RETURNS: void. +** +** RESTRICTIONS: +** +*/ +#define PR_TRACE(handle,ud0,ud1,ud2,ud3,ud4,ud5,ud6,ud7)\ + PR_Trace((handle),(ud0),(ud1),(ud2),(ud3),(ud4),(ud5),(ud6),(ud7)) + +PR_EXTERN(void) + PR_Trace( + PRTraceHandle handle, /* use this trace handle */ + PRUint32 userData0, /* User supplied data word 0 */ + PRUint32 userData1, /* User supplied data word 1 */ + PRUint32 userData2, /* User supplied data word 2 */ + PRUint32 userData3, /* User supplied data word 3 */ + PRUint32 userData4, /* User supplied data word 4 */ + PRUint32 userData5, /* User supplied data word 5 */ + PRUint32 userData6, /* User supplied data word 6 */ + PRUint32 userData7 /* User supplied data word 7 */ +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_SetTraceOption() -- Control the Trace Facility +** +** DESCRIPTION: +** PR_SetTraceOption() controls the Trace Facility. Depending on +** command and value, attributes of the Trace Facility may be +** changed. +** +** INPUTS: +** command: An enumerated value in the set of PRTraceOption. +** value: pointer to the data to be set. Type of the data is +** dependent on command; for each value of command, the type +** and meaning of dereferenced value is shown. +** +** PRTraceBufSize: unsigned long: the size of the trace buffer, +** in bytes. +** +** PRTraceEnable: PRTraceHandle. The trace handle to be +** enabled. +** +** PRTraceDisable: PRTraceHandle. The trace handle to be +** disabled. +** +** PRTraceSuspend: void. value must be NULL. All tracing is +** suspended. +** +** PRTraceResume: void. value must be NULL. Tracing for all +** previously enabled, prior to a PRTraceSuspend, is resumed. +** +** PRTraceStopRecording: void. value must be NULL. If recording +** (see: ** PR_RecordTraceEntries()) is being done, +** PRTraceStopRecording causes PR_RecordTraceEntries() to return +** to its caller. If recording is not being done, this function +** has no effect. +** +** PRTraceSuspendRecording: void. Must be NULL. If recording is +** being done, PRTraceSuspendRecording causes further writes to +** the trace file to be suspended. Data in the in-memory +** trace buffer that would ordinarily be written to the +** trace file will not be written. Trace entries will continue +** to be entered in the in-memory buffer. If the Trace Facility +** recording is already in a suspended state, the call has no +** effect. +** +** PRTraceResumeRecording: void. value must be NULL. If +** recording for the Trace Facility has been previously been +** suspended, this causes recording to resume. Recording resumes +** with the next in-memory buffer segment that would be written +** if trace recording had not been suspended. If recording is +** not currently suspended, the call has no effect. +** +** PRTraceLockHandles: void. value must be NULL. Locks the +** trace handle lock. While the trace handle lock is held, +** calls to PR_CreateTrace() will block until the lock is +** released. +** +** PRTraceUnlockHandles: void. value must be NULL. Unlocks the +** trace handle lock. +** +** OUTPUTS: +** The operation of the Trace Facility may be changed. +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_SET_TRACE_OPTION(command,value)\ + PR_SetTraceOption((command),(value)) + +PR_EXTERN(void) + PR_SetTraceOption( + PRTraceOption command, /* One of the enumerated values */ + void *value /* command value or NULL */ +); + + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_GetTraceOption() -- Retrieve settings from the Trace Facility +** +** DESCRIPTION: +** PR_GetTraceOption() retrieves the current setting of the +** Trace Facility control depending on command. +** +** +** PRTraceBufSize: unsigned long: the size of the trace buffer, +** in bytes. +** +** +** INPUTS: +** command: one of the enumerated values in PRTraceOptions +** valid for PR_GetTraceOption(). +** +** OUTPUTS: +** dependent on command. +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_GET_TRACE_OPTION(command,value)\ + PR_GetTraceOption((command),(value)) + +PR_EXTERN(void) + PR_GetTraceOption( + PRTraceOption command, /* One of the enumerated values */ + void *value /* command value or NULL */ +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_GetTraceHandleFromName() -- Retrieve an existing +** handle by name. +** +** DESCRIPTION: +** PR_GetTraceHandleFromName() retreives an existing tracehandle +** using the name specified by qName and rName. +** +** INPUTS: +** qName: pointer to string. QName for this trace handle. +** +** rName: pointer to string. RName for this trace handle. +** +** +** OUTPUTS: returned. +** +** RETURNS: +** PRTraceHandle associated with qName and rName or NULL when +** there is no match. +** +** RESTRICTIONS: +** +*/ +#define PR_GET_TRACE_HANDLE_FROM_NAME(handle,qName,rName)\ + (handle) = PR_GetTraceHandleFromName((qName),(rName)) + +PR_EXTERN(PRTraceHandle) + PR_GetTraceHandleFromName( + const char *qName, /* QName search argument */ + const char *rName /* RName search argument */ +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_GetTraceNameFromHandle() -- Retreive trace name +** by bandle. +** +** DESCRIPTION: +** PR_GetTraceNameFromHandle() retreives the existing qName, +** rName, and description for the referenced trace handle. +** +** INPUTS: handle: PRTraceHandle. +** +** OUTPUTS: pointers to the Trace Facility's copy of qName, +** rName and description. ... Don't mess with these values. +** They're mine. +** +** RETURNS: void +** +** RESTRICTIONS: +** +*/ +#define PR_GET_TRACE_NAME_FROM_HANDLE(handle,qName,rName,description)\ + PR_GetTraceNameFromHandle((handle),(qName),(rName),(description)) + +PR_EXTERN(void) + PR_GetTraceNameFromHandle( + PRTraceHandle handle, /* handle as search argument */ + const char **qName, /* pointer to associated QName */ + const char **rName, /* pointer to associated RName */ + const char **description /* pointer to associated description */ +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_FindNextTraceQname() -- Retrieive a QName handle +** iterator. +** +** DESCRIPTION: +** PR_FindNextTraceQname() retreives the first or next trace +** QName handle, depending on the value of handle, from the trace +** database. The PRTraceHandle returned can be used as an +** iterator to traverse the QName handles in the Trace database. +** +** INPUTS: +** handle: When NULL, PR_FindNextQname() returns the first QName +** handle. When a handle is a valid PRTraceHandle previously +** retreived using PR_FindNextQname() the next QName handle is +** retreived. +** +** OUTPUTS: returned. +** +** RETURNS: +** PRTraceHandle or NULL when there are no trace handles. +** +** RESTRICTIONS: +** Iterating thru the trace handles via FindFirst/FindNext +** should be done under protection of the trace handle lock. +** See: PR_SetTraceOption( PRLockTraceHandles ). +** +*/ +#define PR_FIND_NEXT_TRACE_QNAME(next,handle)\ + (next) = PR_FindNextTraceQname((handle)) + +PR_EXTERN(PRTraceHandle) + PR_FindNextTraceQname( + PRTraceHandle handle +); + + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_FindNextTraceRname() -- Retrieive an RName handle +** iterator. +** +** DESCRIPTION: +** PR_FindNextTraceRname() retreives the first or next trace +** RName handle, depending on the value of handle, from the trace +** database. The PRTraceHandle returned can be used as an +** iterator to traverse the RName handles in the Trace database. +** +** INPUTS: +** rhandle: When NULL, PR_FindNextRname() returns the first +** RName handle. When a handle is a valid PRTraceHandle +** previously retreived using PR_FindNextRname() the next RName +** handle is retreived. +** qhandle: A valid PRTraceHandle retruned from a previous call +** to PR_FIND_NEXT_TRACE_QNAME(). +** +** OUTPUTS: returned. +** +** RETURNS: +** PRTraceHandle or NULL when there are no trace handles. +** +** RESTRICTIONS: +** Iterating thru the trace handles via FindNext should be done +** under protection of the trace handle lock. See: ( +** PR_SetTraceOption( PRLockTraceHandles ). +** +*/ +#define PR_FIND_NEXT_TRACE_RNAME(next,rhandle,qhandle)\ + (next) = PR_FindNextTraceRname((rhandle),(qhandle)) + +PR_EXTERN(PRTraceHandle) + PR_FindNextTraceRname( + PRTraceHandle rhandle, + PRTraceHandle qhandle +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_RecordTraceEntries() -- Write trace entries to external media +** +** DESCRIPTION: +** PR_RecordTraceEntries() causes entries in the in-memory trace +** buffer to be written to external media. +** +** When PR_RecordTraceEntries() is called from an application +** thread, the function appears to block until another thread +** calls PR_SetTraceOption() with the PRTraceStopRecording +** option. This suggests that PR_RecordTraceEntries() should be +** called from a user supplied thread whose only job is to +** record trace entries. +** +** The environment variable NSPR_TRACE_LOG controls the operation +** of this function. When NSPR_TRACE_LOG is not defined in the +** environment, no recording of trace entries occurs. When +** NSPR_TRACE_LOG is defined, the value of its definition must be +** the filename of the file to receive the trace entry buffer. +** +** PR_RecordTraceEntries() attempts to record the in-memory +** buffer to a file, subject to the setting of the environment +** variable NSPR_TRACE_LOG. It is possible because of system +** load, the thread priority of the recording thread, number of +** active trace records being written over time, and other +** variables that some trace records can be lost. ... In other +** words: don't bet the farm on getting everything. +** +** INPUTS: none +** +** OUTPUTS: none +** +** RETURNS: PR_STATUS +** PR_SUCCESS no errors were found. +** PR_FAILURE errors were found. +** +** RESTRICTIONS: +** Only one thread can call PR_RecordTraceEntries() within a +** process. +** +** On error, PR_RecordTraceEntries() may return prematurely. +** +*/ +#define PR_RECORD_TRACE_ENTRIES()\ + PR_RecordTraceEntries() + +PR_EXTERN(void) + PR_RecordTraceEntries( + void +); + +/* ----------------------------------------------------------------------- +** FUNCTION: PR_GetTraceEntries() -- Retreive trace entries from +** the Trace Facility +** +** DESCRIPTION: +** PR_GetTraceEntries() retreives trace entries from the Trace +** Facility. Up to count trace entries are copied from the Trace +** Facility into buffer. Only those trace entries that have not +** been copied via a previous call to PR_GetTraceEntries() are +** copied. The actual number copied is placed in the PRInt32 +** variable pointed to by found. +** +** If more than count trace entries have entered the Trace +** Facility since the last call to PR_GetTraceEntries() +** a lost data condition is returned. In this case, the most +** recent count trace entries are copied into buffer and found is +** set to count. +** +** INPUTS: +** count. The number of trace entries to be copied into buffer. +** +** +** OUTPUTS: +** buffer. An array of PRTraceEntries. The buffer is supplied +** by the caller. +** +** found: 32bit signed integer. The number of PRTraceEntries +** actually copied. found is always less than or equal to count. +** +** RETURNS: +** zero when there is no lost data. +** non-zero when some PRTraceEntries have been lost. +** +** RESTRICTIONS: +** This is a real performance pig. The copy out operation is bad +** enough, but depending on then frequency of calls to the +** function, serious performance impact to the operating +** application may be realized. ... YMMV. +** +*/ +#define PR_GET_TRACE_ENTRIES(buffer,count,found)\ + PR_GetTraceEntries((buffer),(count),(found)) + + +PR_EXTERN(PRIntn) + PR_GetTraceEntries( + PRTraceEntry *buffer, /* where to write output */ + PRInt32 count, /* number to get */ + PRInt32 *found /* number you got */ +); + +#else /* !(defined (DEBUG) || defined (FORCE_NSPR_TRACE)) */ +/* +** Define the Trace Facility macros as No-Ops for when the trace +** facility is to be compiled-out of the application. +** +*/ +#define PR_DEFINE_TRACE(name) PRTraceHandle name +#define PR_INIT_TRACE_HANDLE(handle,value) +#define PR_CREATE_TRACE(handle,qName,rName,description) +#define PR_DESTROY_TRACE(handle) +#define PR_TRACE(handle,ud0,ud1,ud2,ud3,ud4,ud5,ud6,ud7) +#define PR_SET_TRACE_OPTION(command,value) +#define PR_GET_TRACE_OPTION(command,value) +#define PR_GET_TRACE_HANDLE_FROM_NAME(handle,qName,rName) +#define PR_GET_TRACE_NAME_FROM_HANDLE(handle,qName,rName,description) +#define PR_FIND_NEXT_TRACE_QNAME(next,handle) +#define PR_FIND_NEXT_TRACE_RNAME(next,rhandle,qhandle) +#define PR_GET_TRACE_ENTRIES(buffer,count,found) +#define PR_RECORD_TRACE_ENTRIES() + +#endif /* !(defined (DEBUG) || defined (FORCE_NSPR_TRACE)) */ + +PR_END_EXTERN_C + +#endif /* prtrace_h___ */ + diff --git a/pr/include/prtypes.h b/pr/include/prtypes.h index 16112b13..8e10743c 100644 --- a/pr/include/prtypes.h +++ b/pr/include/prtypes.h @@ -120,10 +120,6 @@ #endif -#if !defined(NO_NSPR_10_SUPPORT) -#define PR_PUBLIC_API PR_IMPLEMENT -#endif - /*********************************************************************** ** MACROS: PR_BEGIN_MACRO ** PR_END_MACRO @@ -179,7 +175,21 @@ PR_BEGIN_EXTERN_C ************************************************************************/ #if PR_BYTES_PER_BYTE == 1 typedef unsigned char PRUint8; +/* +** Some cfront-based C++ compilers do not like 'signed char' and +** issue the warning message: +** warning: "signed" not implemented (ignored) +** For these compilers, we have to define PRInt8 as plain 'char'. +** Make sure that plain 'char' is indeed signed under these compilers. +*/ +#if (defined(HPUX) && defined(__cplusplus) \ + && !defined(__GNUC__) && __cplusplus < 199707L) \ + || (defined(SCO) && defined(__cplusplus) \ + && !defined(__GNUC__) && __cplusplus == 1L) +typedef char PRInt8; +#else typedef signed char PRInt8; +#endif #else #error No suitable type for PRInt8/PRUint8 #endif @@ -333,6 +343,8 @@ typedef enum { PR_FAILURE = -1, PR_SUCCESS = 0 } PRStatus; ** Fundamental NSPR macros, used nearly everywhere. */ +#define PR_PUBLIC_API PR_IMPLEMENT + /* ** Macro body brackets so that macros with compound statement definitions ** behave syntactically more like functions when called. diff --git a/pr/include/prvrsion.h b/pr/include/prvrsion.h new file mode 100755 index 00000000..a8a0bf3c --- /dev/null +++ b/pr/include/prvrsion.h @@ -0,0 +1,108 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + + +/* author: jstewart */ + +#if defined(_PRVERSION_H) +#else +#define _PRVERSION_H + +#include "prtypes.h" + +PR_BEGIN_EXTERN_C + +/* All components participating in the PR version protocol must expose + * a structure and a function. The structure is defined below and named + * according to the naming conventions outlined further below. The function + * is called libVersionPoint and returns a pointer to this structure. + */ + +/* on NT, always pack the structure the same. */ +#ifdef _WIN32 +#pragma pack(push, 8) +#endif + +typedef struct { + /* + * The first field defines which version of this structure is in use. + * At this time, only version 2 is specified. If this value is not + * 2, you must read no further into the structure. + */ + PRInt32 version; + + /* for Version 2, this is the body format. */ + PRInt64 buildTime; /* 64 bits - usecs since midnight, 1/1/1970 */ + char * buildTimeString;/* a human readable version of the time */ + + PRUint8 vMajor; /* Major version of this component */ + PRUint8 vMinor; /* Minor version of this component */ + PRUint8 vPatch; /* Patch level of this component */ + + PRBool beta; /* true if this is a beta component */ + PRBool debug; /* true if this is a debug component */ + PRBool special; /* true if this component is a special build */ + + char * filename; /* The original filename */ + char * description; /* description of this component */ + char * security; /* level of security in this component */ + char * copyright; /* The copyright for this file */ + char * comment; /* free form field for misc usage */ + char * specialString; /* the special variant for this build */ +} PRVersionDescription; + +/* on NT, restore the previous packing */ +#ifdef _WIN32 +#pragma pack(pop) +#endif + +/* + * All components must define an entrypoint named libVersionPoint which + * is of type versionEntryPointType. + */ +PR_EXTERN(const PRVersionDescription *) libVersionPoint(void); + +typedef const PRVersionDescription *(*versionEntryPointType)(void); + +/* + * Where you declare your libVersionPoint, do it like this: + * PR_IMPLEMENT(const PRVersionDescription *) libVersionPoint(void) { + * fill it in... + * } + */ + +/* + * NAMING CONVENTION FOR struct + * + * all components should also expose a static PRVersionDescription + * The name of the struct should be calculated as follows: + * Take the value of filename. (If filename is not specified, calculate + * a short, unique string.) Convert all non-alphanumeric characters + * to '_'. To this, prepend "PRVersionDescription_". Thus for libfoo.so, + * the symbol name is "PRVersionDescription_libfoo_so". + * so the file should have + * PRVersionDescription PRVersionDescription_libfoo_so { fill it in }; + * on NT, this file should be declspec export. + */ + +PR_END_EXTERN_C + +#endif /* defined(_PRVERSION_H) */ + +/* prvrsion.h */ + |