diff options
Diffstat (limited to 'erts/emulator/beam/sys.h')
| -rw-r--r-- | erts/emulator/beam/sys.h | 1257 |
1 files changed, 1257 insertions, 0 deletions
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h new file mode 100644 index 0000000000..71cb6a36cc --- /dev/null +++ b/erts/emulator/beam/sys.h @@ -0,0 +1,1257 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1996-2009. All Rights Reserved. + * + * The contents of this file are subject to the Erlang Public License, + * Version 1.1, (the "License"); you may not use this file except in + * compliance with the License. You should have received a copy of the + * Erlang Public License along with this software. If not, it can be + * retrieved online at http://www.erlang.org/. + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and limitations + * under the License. + * + * %CopyrightEnd% + */ + +#ifndef __SYS_H__ +#define __SYS_H__ + +#if defined(VALGRIND) && !defined(NO_FPE_SIGNALS) +# define NO_FPE_SIGNALS +#endif + +/* Never use elib-malloc when purify-memory-tracing */ +#if defined(PURIFY) +#undef ENABLE_ELIB_MALLOC +#undef ELIB_HEAP_SBRK +#undef ELIB_ALLOC_IS_CLIB +#endif + + +/* xxxP __VXWORKS__ */ +#ifdef VXWORKS +#include <vxWorks.h> +#endif + +#ifdef DISABLE_CHILD_WAITER_THREAD +#undef ENABLE_CHILD_WAITER_THREAD +#endif + +#if defined(ERTS_SMP) && !defined(DISABLE_CHILD_WAITER_THREAD) +#undef ENABLE_CHILD_WAITER_THREAD +#define ENABLE_CHILD_WAITER_THREAD 1 +#endif + +/* The ERTS_TIMER_TREAD #define must be visible to the + erl_${OS}_sys.h #include files: it controls whether + certain optional facilities should be defined or not. */ +#if defined(ERTS_SMP) && 0 +#define ERTS_TIMER_THREAD +#endif + +#if defined (__WIN32__) +# include "erl_win_sys.h" +#elif defined (VXWORKS) +# include "erl_vxworks_sys.h" +#elif defined (_OSE_) +# include "erl_ose_sys.h" +#else +# include "erl_unix_sys.h" +#ifndef UNIX +# define UNIX 1 +#endif +#endif + +#include "erl_misc_utils.h" + +/* + * To allow building of Universal Binaries for Mac OS X, + * we must not depend on the endian detected by the configure script. + */ +#if defined(__APPLE__) +# if defined(__BIG_ENDIAN__) && !defined(WORDS_BIGENDIAN) +# define WORDS_BIGENDIAN 1 +# elif !defined(__BIG_ENDIAN__) && defined(WORDS_BIGENDIAN) +# undef WORDS_BIGENDIAN +# endif +#endif + +/* + * Make sure we have a type for FD's (used by erl_check_io) + */ + +#ifndef ERTS_SYS_FD_TYPE +typedef int ErtsSysFdType; +#else +typedef ERTS_SYS_FD_TYPE ErtsSysFdType; +#endif + +#ifdef ERTS_INLINE +# ifndef ERTS_CAN_INLINE +# define ERTS_CAN_INLINE 1 +# endif +#else +# if defined(__GNUC__) +# define ERTS_CAN_INLINE 1 +# define ERTS_INLINE __inline__ +# elif defined(__WIN32__) +# define ERTS_CAN_INLINE 1 +# define ERTS_INLINE __inline +# else +# define ERTS_CAN_INLINE 0 +# define ERTS_INLINE +# endif +#endif + +#ifdef __GNUC__ +# if __GNUC__ < 3 && (__GNUC__ != 2 || __GNUC_MINOR__ < 96) +# define ERTS_LIKELY(BOOL) (BOOL) +# define ERTS_UNLIKELY(BOOL) (BOOL) +# else +# define ERTS_LIKELY(BOOL) __builtin_expect((BOOL), !0) +# define ERTS_UNLIKELY(BOOL) __builtin_expect((BOOL), 0) +# endif +#else +# define ERTS_LIKELY(BOOL) (BOOL) +# define ERTS_UNLIKELY(BOOL) (BOOL) +#endif + +#if defined(DEBUG) || defined(ERTS_ENABLE_LOCK_CHECK) +# undef ERTS_CAN_INLINE +# define ERTS_CAN_INLINE 0 +# undef ERTS_INLINE +# define ERTS_INLINE +#endif + +#if ERTS_CAN_INLINE +#define ERTS_GLB_INLINE static ERTS_INLINE +#else +#define ERTS_GLB_INLINE +#endif + +#if ERTS_CAN_INLINE || defined(ERTS_DO_INCL_GLB_INLINE_FUNC_DEF) +# define ERTS_GLB_INLINE_INCL_FUNC_DEF 1 +#else +# define ERTS_GLB_INLINE_INCL_FUNC_DEF 0 +#endif + +#ifndef ERTS_EXIT_AFTER_DUMP +# define ERTS_EXIT_AFTER_DUMP exit +#endif + +#ifdef DEBUG +# define ASSERT(e) \ + if (e) { \ + ; \ + } else { \ + erl_assert_error(#e, __FILE__, __LINE__); \ + } +# define ASSERT_EXPR(e) \ + ((void) ((e) ? 1 : (erl_assert_error(#e, __FILE__, __LINE__), 0))) +void erl_assert_error(char* expr, char* file, int line); +#else +# define ASSERT(e) +# define ASSERT_EXPR(e) ((void) 1) +#endif + +/* + * Microsoft C/C++: We certainly want to use stdarg.h and prototypes. + * But MSC doesn't define __STDC__, unless we compile with the -Za + * flag (strict ANSI C, no Microsoft extension). Compiling with -Za + * doesn't work: some Microsoft headers fail to compile... + * + * Solution: Test if __STDC__ or _MSC_VER is defined. + * + * Note: Simply defining __STDC__ doesn't work, as some Microsoft + * headers will fail to compile! + */ + +#include <stdarg.h> + +#if defined(__STDC__) || defined(_MSC_VER) +# define EXTERN_FUNCTION(t, f, x) extern t f x +# define FUNCTION(t, f, x) t f x +# define _DOTS_ ... +# define _VOID_ void +#elif defined(__cplusplus) +# define EXTERN_FUNCTION(f, x) extern "C" { f x } +# define FUNCTION(t, f, x) t f x +# define _DOTS_ ... +# define _VOID_ void +#else +# define EXTERN_FUNCTION(t, f, x) extern t f (/*x*/) +# define FUNCTION(t, f, x) t f (/*x*/) +# define _DOTS_ +# define _VOID_ +#endif + +/* This isn't sys-dependent, but putting it here benefits sys.c and drivers + - allow use of 'const' regardless of compiler */ + +#if !defined(__STDC__) && !defined(_MSC_VER) +# define const +#endif + +#ifdef VXWORKS +/* Replace VxWorks' printf with a real one that does fprintf(stdout, ...) */ +EXTERN_FUNCTION(int, real_printf, (const char *fmt, ...)); +# define printf real_printf +#endif + +/* In VC++, noreturn is a declspec that has to be before the types, + * but in GNUC it is an att ribute to be placed between return type + * and function name, hence __decl_noreturn <types> __noreturn <function name> + */ +#if __GNUC__ +# define __decl_noreturn +# define __noreturn __attribute__((noreturn)) +# undef __deprecated +# if __GNUC__ >= 3 +# define __deprecated __attribute__((deprecated)) +# else +# define __deprecated +# endif +#else +# if defined(__WIN32__) && defined(_MSC_VER) +# define __noreturn +# define __decl_noreturn __declspec(noreturn) +# else +# define __noreturn +# define __decl_noreturn +# endif +# define __deprecated +#endif + +/* +** Data types: +** +** Eterm: A tagged erlang term (possibly 64 bits) +** UInt: An unsigned integer exactly as large as an Eterm. +** SInt: A signed integer exactly as large as an eterm and therefor large +** enough to hold the return value of the signed_val() macro. +** Uint32: An unsigned integer of 32 bits exactly +** Sint32: A signed integer of 32 bits exactly +** Uint16: An unsigned integer of 16 bits exactly +** Sint16: A signed integer of 16 bits exactly. +*/ + +#if SIZEOF_VOID_P == 8 +#undef ARCH_32 +#define ARCH_64 +#elif SIZEOF_VOID_P == 4 +#define ARCH_32 +#undef ARCH_64 +#else +#error Neither 32 nor 64 bit architecture +#endif + +#if SIZEOF_VOID_P != SIZEOF_SIZE_T +#error sizeof(void*) != sizeof(size_t) +#endif + +#if SIZEOF_VOID_P == SIZEOF_LONG +typedef unsigned long Eterm; +typedef unsigned long Uint; +typedef long Sint; +#define ERTS_SIZEOF_ETERM SIZEOF_LONG +#elif SIZEOF_VOID_P == SIZEOF_INT +typedef unsigned int Eterm; +typedef unsigned int Uint; +typedef int Sint; +#define ERTS_SIZEOF_ETERM SIZEOF_INT +#else +#error Found no appropriate type to use for 'Eterm', 'Uint' and 'Sint' +#endif + +#ifndef HAVE_INT64 +#if SIZEOF_LONG == 8 +#define HAVE_INT64 1 +typedef unsigned long Uint64; +typedef long Sint64; +#elif SIZEOF_LONG_LONG == 8 +#define HAVE_INT64 1 +typedef unsigned long long Uint64; +typedef long long Sint64; +#else +#define HAVE_INT64 0 +#endif +#endif + +#if SIZEOF_LONG == 4 +typedef unsigned long Uint32; +typedef long Sint32; +#elif SIZEOF_INT == 4 +typedef unsigned int Uint32; +typedef int Sint32; +#else +#error Found no appropriate type to use for 'Uint32' and 'Sint32' +#endif + +#if SIZEOF_INT == 2 +typedef unsigned int Uint16; +typedef int Sint16; +#elif SIZEOF_SHORT == 2 +typedef unsigned short Uint16; +typedef short Sint16; +#else +#error Found no appropriate type to use for 'Uint16' and 'Sint16' +#endif + +#if CHAR_BIT == 8 +typedef unsigned char byte; +#else +#error Found no appropriate type to use for 'byte' +#endif + +#if defined(ARCH_64) && !HAVE_INT64 +#error 64-bit architecture, but no appropriate type to use for Uint64 and Sint64 found +#endif + +#if defined(ARCH_64) +# define ERTS_WORD_ALIGN_PAD_SZ(X) \ + (((size_t) 8) - (((size_t) (X)) & ((size_t) 7))) +#elif defined(ARCH_32) +# define ERTS_WORD_ALIGN_PAD_SZ(X) \ + (((size_t) 4) - (((size_t) (X)) & ((size_t) 3))) +#else +#error "Not supported..." +#endif + +#include "erl_lock_check.h" +#include "erl_smp.h" + +#ifdef ERTS_WANT_BREAK_HANDLING +# ifdef ERTS_SMP +extern erts_smp_atomic_t erts_break_requested; +# define ERTS_BREAK_REQUESTED ((int) erts_smp_atomic_read(&erts_break_requested)) +# else +extern volatile int erts_break_requested; +# define ERTS_BREAK_REQUESTED erts_break_requested +# endif +void erts_do_break_handling(void); +#endif + +#ifdef ERTS_WANT_GOT_SIGUSR1 +# ifndef UNIX +# define ERTS_GOT_SIGUSR1 0 +# else +# ifdef ERTS_SMP +extern erts_smp_atomic_t erts_got_sigusr1; +# define ERTS_GOT_SIGUSR1 ((int) erts_smp_atomic_read(&erts_got_sigusr1)) +# else +extern volatile int erts_got_sigusr1; +# define ERTS_GOT_SIGUSR1 erts_got_sigusr1 +# endif +# endif +#endif + +#ifdef ERTS_SMP +extern erts_smp_atomic_t erts_writing_erl_crash_dump; +#define ERTS_IS_CRASH_DUMPING \ + ((int) erts_smp_atomic_read(&erts_writing_erl_crash_dump)) +#else +extern volatile int erts_writing_erl_crash_dump; +#define ERTS_IS_CRASH_DUMPING erts_writing_erl_crash_dump +#endif + +/* Deal with memcpy() vs bcopy() etc. We want to use the mem*() functions, + but be able to fall back on bcopy() etc on systems that don't have + mem*(), but this doesn't work to well with memset()/bzero() - thus the + memzero() macro. +*/ + +/* xxxP */ +#if defined(USE_BCOPY) +# define memcpy(a, b, c) bcopy((b), (a), (c)) +# define memcmp(a, b, c) bcmp((a), (b), (c)) +# define memzero(buf, len) bzero((buf), (len)) +#else +# define memzero(buf, len) memset((buf), '\0', (len)) +#endif + +/* Stuff that is useful for port programs, drivers, etc */ + +#ifdef ISC32 /* Too much for the Makefile... */ +# define signal sigset +# define NO_ASINH +# define NO_ACOSH +# define NO_ATANH +# define NO_FTRUNCATE +# define SIG_SIGHOLD +# define _POSIX_SOURCE +# define _XOPEN_SOURCE +#endif + +#ifdef QNX /* Too much for the Makefile... */ +# define SYS_SELECT_H +# define NO_ERF +# define NO_ERFC +/* This definition doesn't take NaN into account, but matherr() gets those */ +# define finite(x) (fabs(x) != HUGE_VAL) +# define USE_MATHERR +# define HAVE_FINITE +#endif + + +#ifdef WANT_NONBLOCKING /* must define this to pull in fcntl.h/ioctl.h */ + +/* This is really a mess... We used to use fcntl O_NDELAY, but that seems + to only work on SunOS 4 - in particular, on SysV-based systems + (including Solaris 2), it does set non-blocking mode, but causes + read() to return 0!! fcntl O_NONBLOCK is specified by POSIX, and + seems to work on most systems, with the notable exception of AIX, + where the old ioctl FIONBIO is the *only* one that will set a *socket* + in non-blocking mode - and ioctl FIONBIO on AIX *doesn't* work for + pipes or ttys (O_NONBLOCK does)!!! For now, we'll use FIONBIO for AIX. */ + +# ifdef _OSE_ +static const int zero_value = 0, one_value = 1; +# define SET_BLOCKING(fd) ioctl((fd), FIONBIO, (char*)&zero_value) +# define SET_NONBLOCKING(fd) ioctl((fd), FIONBIO, (char*)&one_value) +# define ERRNO_BLOCK EWOULDBLOCK +# else + +# ifdef __WIN32__ + +static unsigned long zero_value = 0, one_value = 1; +# define SET_BLOCKING(fd) { if (ioctlsocket((fd), FIONBIO, &zero_value) != 0) fprintf(stderr, "Error setting socket to non-blocking: %d\n", WSAGetLastError()); } +# define SET_NONBLOCKING(fd) ioctlsocket((fd), FIONBIO, &one_value) + +# else +# ifdef VXWORKS +# include <fcntl.h> /* xxxP added for O_WRONLY etc ... macro:s ... */ +# include <ioLib.h> +static const int zero_value = 0, one_value = 1; +# define SET_BLOCKING(fd) ioctl((fd), FIONBIO, (int)&zero_value) +# define SET_NONBLOCKING(fd) ioctl((fd), FIONBIO, (int)&one_value) +# define ERRNO_BLOCK EWOULDBLOCK + +# else +# ifdef NB_FIONBIO /* Old BSD */ +# include <sys/ioctl.h> + static const int zero_value = 0, one_value = 1; +# define SET_BLOCKING(fd) ioctl((fd), FIONBIO, &zero_value) +# define SET_NONBLOCKING(fd) ioctl((fd), FIONBIO, &one_value) +# define ERRNO_BLOCK EWOULDBLOCK +# else /* !NB_FIONBIO */ +# include <fcntl.h> +# ifdef NB_O_NDELAY /* Nothing needs this? */ +# define NB_FLAG O_NDELAY +# ifndef ERRNO_BLOCK /* allow override (e.g. EAGAIN) via Makefile */ +# define ERRNO_BLOCK EWOULDBLOCK +# endif +# else /* !NB_O_NDELAY */ /* The True Way - POSIX!:-) */ +# define NB_FLAG O_NONBLOCK +# define ERRNO_BLOCK EAGAIN +# endif /* !NB_O_NDELAY */ +# define SET_BLOCKING(fd) fcntl((fd), F_SETFL, \ + fcntl((fd), F_GETFL, 0) & ~NB_FLAG) +# define SET_NONBLOCKING(fd) fcntl((fd), F_SETFL, \ + fcntl((fd), F_GETFL, 0) | NB_FLAG) +# endif /* !NB_FIONBIO */ +# endif /* _WXWORKS_ */ +# endif /* !__WIN32__ */ +# endif /* _OSE_ */ +#endif /* WANT_NONBLOCKING */ + +extern erts_cpu_info_t *erts_cpuinfo; /* erl_init.c */ + +__decl_noreturn void __noreturn erl_exit(int n, char*, ...); + +/* Some special erl_exit() codes: */ +#define ERTS_INTR_EXIT INT_MIN /* called from signal handler */ +#define ERTS_ABORT_EXIT (INT_MIN + 1) /* no crash dump; only abort() */ +#define ERTS_DUMP_EXIT (127) /* crash dump; then exit() */ + + +#ifndef ERTS_SMP +int check_async_ready(void); +#ifdef USE_THREADS +void sys_async_ready(int hndl); +int erts_register_async_ready_callback(void (*funcp)(void)); +#endif +#endif + +Eterm erts_check_io_info(void *p); + +/* Size of misc memory allocated from system dependent code */ +Uint erts_sys_misc_mem_sz(void); + +/* print stuff is declared here instead of in global.h, so sys stuff won't + have to include global.h */ +#include "erl_printf.h" + +/* Io constants to erts_print and erts_putc */ +#define ERTS_PRINT_STDERR (2) +#define ERTS_PRINT_STDOUT (1) +#define ERTS_PRINT_INVALID (0) /* Don't want to use 0 since CBUF was 0 */ +#define ERTS_PRINT_FILE (-1) +#define ERTS_PRINT_SBUF (-2) +#define ERTS_PRINT_SNBUF (-3) +#define ERTS_PRINT_DSBUF (-4) + +#define ERTS_PRINT_MIN ERTS_PRINT_DSBUF + +typedef struct { + char *buf; + size_t size; +} erts_print_sn_buf; + +int erts_print(int to, void *arg, char *format, ...); /* in utils.c */ +int erts_putc(int to, void *arg, char); /* in utils.c */ + +/* logger stuff is declared here instead of in global.h, so sys files + won't have to include global.h */ + +erts_dsprintf_buf_t *erts_create_logger_dsbuf(void); +int erts_send_info_to_logger(Eterm, erts_dsprintf_buf_t *); +int erts_send_warning_to_logger(Eterm, erts_dsprintf_buf_t *); +int erts_send_error_to_logger(Eterm, erts_dsprintf_buf_t *); +int erts_send_info_to_logger_str(Eterm, char *); +int erts_send_warning_to_logger_str(Eterm, char *); +int erts_send_error_to_logger_str(Eterm, char *); +int erts_send_info_to_logger_nogl(erts_dsprintf_buf_t *); +int erts_send_warning_to_logger_nogl(erts_dsprintf_buf_t *); +int erts_send_error_to_logger_nogl(erts_dsprintf_buf_t *); +int erts_send_info_to_logger_str_nogl(char *); +int erts_send_warning_to_logger_str_nogl(char *); +int erts_send_error_to_logger_str_nogl(char *); + +typedef struct preload { + char *name; /* Name of module */ + int size; /* Size of code */ + unsigned char* code; /* Code pointer */ +} Preload; + + +/* + * This structure contains options to all built in drivers. + * None of the drivers use all of the fields. + */ + +/* OSE: Want process_type and priority in here as well! Needs updates in erl_bif_ports.c! */ + +typedef struct _SysDriverOpts { + int ifd; /* Input file descriptor (fd driver). */ + int ofd; /* Outputfile descriptor (fd driver). */ + int packet_bytes; /* Number of bytes in packet header. */ + int read_write; /* Read and write bits. */ + int use_stdio; /* Use standard I/O: TRUE or FALSE. */ + int redir_stderr; /* Redirect stderr to stdout: TRUE/FALSE. */ + int hide_window; /* Hide this windows (Windows). */ + int exit_status; /* Report exit status of subprocess. */ + int overlapped_io; /* Only has effect on windows NT et al */ + char *envir; /* Environment of the port process, */ + /* in Windows format. */ + char **argv; /* Argument vector in Unix'ish format. */ + char *wd; /* Working directory. */ + unsigned spawn_type; /* Bitfield of ERTS_SPAWN_DRIVER | + ERTS_SPAWN_EXTERNAL | both*/ + +#ifdef _OSE_ + enum PROCESS_TYPE process_type; + OSPRIORITY priority; +#endif /* _OSE_ */ + +} SysDriverOpts; + +extern char *erts_default_arg0; + +extern char os_type[]; + +extern int sys_init_time(void); +#if defined(ERTS_TIMER_THREAD) +#define erts_deliver_time() +#else +extern void erts_deliver_time(void); +#endif +extern void erts_time_remaining(SysTimeval *); +extern int erts_init_time_sup(void); +extern void erts_sys_init_float(void); +extern void erts_thread_init_float(void); +extern void erts_thread_disable_fpe(void); + +ERTS_GLB_INLINE int erts_block_fpe(void); +ERTS_GLB_INLINE void erts_unblock_fpe(int); + +#if ERTS_GLB_INLINE_INCL_FUNC_DEF + +ERTS_GLB_INLINE int erts_block_fpe(void) +{ + return erts_sys_block_fpe(); +} + +ERTS_GLB_INLINE void erts_unblock_fpe(int unmasked) +{ + erts_sys_unblock_fpe(unmasked); +} + +#endif /* #if ERTS_GLB_INLINE_INCL_FUNC_DEF */ + + +/* Dynamic library/driver loading */ +typedef struct { + char* str; +}ErtsSysDdllError; +#define ERTS_SYS_DDLL_ERROR_INIT {NULL} +extern void erts_sys_ddll_free_error(ErtsSysDdllError*); +extern void erl_sys_ddll_init(void); /* to initialize mutexes etc */ +extern int erts_sys_ddll_open2(char *path, void **handle, ErtsSysDdllError*); +#define erts_sys_ddll_open(P,H) erts_sys_ddll_open2(P,H,NULL) +extern int erts_sys_ddll_open_noext(char *path, void **handle, ErtsSysDdllError*); +extern int erts_sys_ddll_load_driver_init(void *handle, void **function); +extern int erts_sys_ddll_load_nif_init(void *handle, void **function,ErtsSysDdllError*); +extern int erts_sys_ddll_close2(void *handle, ErtsSysDdllError*); +#define erts_sys_ddll_close(H) erts_sys_ddll_close2(H,NULL) +extern void *erts_sys_ddll_call_init(void *function); +extern void *erts_sys_ddll_call_nif_init(void *function); +extern int erts_sys_ddll_sym2(void *handle, char *name, void **function, ErtsSysDdllError*); +#define erts_sys_ddll_sym(H,N,F) erts_sys_ddll_sym2(H,N,F,NULL) +extern char *erts_sys_ddll_error(int code); + + + +/* + * System interfaces for startup/sae code (functions found in respective sys.c) + */ + + +#ifdef ERTS_SMP +void erts_sys_schedule_interrupt(int set); +void erts_sys_schedule_interrupt_timed(int set, long msec); +void erts_sys_main_thread(void); +#else +#define erts_sys_schedule_interrupt(Set) +#endif + +extern void erts_sys_prepare_crash_dump(void); +extern void erts_sys_pre_init(void); +extern void erl_sys_init(void); +extern void erl_sys_args(int *argc, char **argv); +extern void erl_sys_schedule(int); +#ifdef _OSE_ +extern void erl_sys_init_final(void); +#else +void sys_tty_reset(void); +#endif + +EXTERN_FUNCTION(int, sys_max_files, (_VOID_)); +void sys_init_io(void); +Preload* sys_preloaded(void); +EXTERN_FUNCTION(unsigned char*, sys_preload_begin, (Preload*)); +EXTERN_FUNCTION(void, sys_preload_end, (Preload*)); +EXTERN_FUNCTION(int, sys_get_key, (int)); +void elapsed_time_both(unsigned long *ms_user, unsigned long *ms_sys, + unsigned long *ms_user_diff, unsigned long *ms_sys_diff); +void wall_clock_elapsed_time_both(unsigned long *ms_total, + unsigned long *ms_diff); +void get_time(int *hour, int *minute, int *second); +void get_date(int *year, int *month, int *day); +void get_localtime(int *year, int *month, int *day, + int *hour, int *minute, int *second); +void get_universaltime(int *year, int *month, int *day, + int *hour, int *minute, int *second); +int univ_to_local(Sint *year, Sint *month, Sint *day, + Sint *hour, Sint *minute, Sint *second); +int local_to_univ(Sint *year, Sint *month, Sint *day, + Sint *hour, Sint *minute, Sint *second, int isdst); +void get_now(Uint*, Uint*, Uint*); +void get_sys_now(Uint*, Uint*, Uint*); +EXTERN_FUNCTION(void, set_break_quit, (void (*)(void), void (*)(void))); + +void os_flavor(char*, unsigned); +void os_version(int*, int*, int*); +void init_getenv_state(GETENV_STATE *); +char * getenv_string(GETENV_STATE *); +void fini_getenv_state(GETENV_STATE *); + +/* xxxP */ +void init_sys_float(void); +int sys_chars_to_double(char*, double*); +int sys_double_to_chars(double, char*); +void sys_get_pid(char *); + +/* erts_sys_putenv() returns, 0 on success and a value != 0 on failure. */ +int erts_sys_putenv(char *key_value, int sep_ix); +/* erts_sys_getenv() returns 0 on success (length of value string in + *size), a value > 0 if value buffer is too small (*size is set to needed + size), and a value < 0 on failure. */ +int erts_sys_getenv(char *key, char *value, size_t *size); + +/* Easier to use, but not as efficient, environment functions */ +char *erts_read_env(char *key); +void erts_free_read_env(void *value); +int erts_write_env(char *key, char *value); + +/* utils.c */ + +/* Options to sys_alloc_opt */ +#define SYS_ALLOC_OPT_TRIM_THRESHOLD 0 +#define SYS_ALLOC_OPT_TOP_PAD 1 +#define SYS_ALLOC_OPT_MMAP_THRESHOLD 2 +#define SYS_ALLOC_OPT_MMAP_MAX 3 + +/* Default values to sys_alloc_opt options */ +#define ERTS_DEFAULT_TRIM_THRESHOLD (128 * 1024) +#define ERTS_DEFAULT_TOP_PAD 0 +#define ERTS_DEFAULT_MMAP_THRESHOLD (128 * 1024) +#define ERTS_DEFAULT_MMAP_MAX 64 + +EXTERN_FUNCTION(int, sys_alloc_opt, (int, int)); + +typedef struct { + Sint trim_threshold; + Sint top_pad; + Sint mmap_threshold; + Sint mmap_max; +} SysAllocStat; + +EXTERN_FUNCTION(void, sys_alloc_stat, (SysAllocStat *)); + +/* Block the whole system... */ + +#define ERTS_BS_FLG_ALLOW_GC (((Uint32) 1) << 0) +#define ERTS_BS_FLG_ALLOW_IO (((Uint32) 1) << 1) + +/* Activities... */ +typedef enum { + ERTS_ACTIVITY_UNDEFINED, /* Undefined activity */ + ERTS_ACTIVITY_WAIT, /* Waiting */ + ERTS_ACTIVITY_GC, /* Garbage collecting */ + ERTS_ACTIVITY_IO /* I/O including message passing to erl procs */ +} erts_activity_t; + +#ifdef ERTS_SMP + +typedef enum { + ERTS_ACT_ERR_LEAVE_WAIT_UNLOCKED, + ERTS_ACT_ERR_LEAVE_UNKNOWN_ACTIVITY, + ERTS_ACT_ERR_ENTER_UNKNOWN_ACTIVITY +} erts_activity_error_t; + +typedef struct { + erts_smp_atomic_t do_block; + struct { + erts_smp_atomic_t wait; + erts_smp_atomic_t gc; + erts_smp_atomic_t io; + } in_activity; +} erts_system_block_state_t; + +extern erts_system_block_state_t erts_system_block_state; + +int erts_is_system_blocked(erts_activity_t allowed_activities); +void erts_block_me(void (*prepare)(void *), void (*resume)(void *), void *arg); +void erts_register_blockable_thread(void); +void erts_unregister_blockable_thread(void); +void erts_note_activity_begin(erts_activity_t activity); +void +erts_check_block(erts_activity_t old_activity, + erts_activity_t new_activity, + int locked, + void (*prepare)(void *), + void (*resume)(void *), + void *arg); +void erts_block_system(Uint32 allowed_activities); +int erts_emergency_block_system(long timeout, Uint32 allowed_activities); +void erts_release_system(void); +void erts_system_block_init(void); +void erts_set_activity_error(erts_activity_error_t, char *, int); +#ifdef ERTS_ENABLE_LOCK_CHECK +void erts_lc_activity_change_begin(void); +void erts_lc_activity_change_end(void); +int erts_lc_is_blocking(void); +#define ERTS_LC_IS_BLOCKING \ + (erts_smp_pending_system_block() && erts_lc_is_blocking()) +#endif +#endif + +#define erts_smp_activity_begin(NACT, PRP, RSM, ARG) \ + erts_smp_set_activity(ERTS_ACTIVITY_UNDEFINED, \ + (NACT), \ + 0, \ + (PRP), \ + (RSM), \ + (ARG), \ + __FILE__, \ + __LINE__) +#define erts_smp_activity_change(OACT, NACT, PRP, RSM, ARG) \ + erts_smp_set_activity((OACT), \ + (NACT), \ + 0, \ + (PRP), \ + (RSM), \ + (ARG), \ + __FILE__, \ + __LINE__) +#define erts_smp_activity_end(OACT, PRP, RSM, ARG) \ + erts_smp_set_activity((OACT), \ + ERTS_ACTIVITY_UNDEFINED, \ + 0, \ + (PRP), \ + (RSM), \ + (ARG), \ + __FILE__, \ + __LINE__) + +#define erts_smp_locked_activity_begin(NACT) \ + erts_smp_set_activity(ERTS_ACTIVITY_UNDEFINED, \ + (NACT), \ + 1, \ + NULL, \ + NULL, \ + NULL, \ + __FILE__, \ + __LINE__) +#define erts_smp_locked_activity_change(OACT, NACT) \ + erts_smp_set_activity((OACT), \ + (NACT), \ + 1, \ + NULL, \ + NULL, \ + NULL, \ + __FILE__, \ + __LINE__) +#define erts_smp_locked_activity_end(OACT) \ + erts_smp_set_activity((OACT), \ + ERTS_ACTIVITY_UNDEFINED, \ + 1, \ + NULL, \ + NULL, \ + NULL, \ + __FILE__, \ + __LINE__) + + +ERTS_GLB_INLINE int erts_smp_is_system_blocked(erts_activity_t allowed_activities); +ERTS_GLB_INLINE void erts_smp_block_system(Uint32 allowed_activities); +ERTS_GLB_INLINE int erts_smp_emergency_block_system(long timeout, + Uint32 allowed_activities); +ERTS_GLB_INLINE void erts_smp_release_system(void); +ERTS_GLB_INLINE int erts_smp_pending_system_block(void); +ERTS_GLB_INLINE void erts_smp_chk_system_block(void (*prepare)(void *), + void (*resume)(void *), + void *arg); +ERTS_GLB_INLINE void +erts_smp_set_activity(erts_activity_t old_activity, + erts_activity_t new_activity, + int locked, + void (*prepare)(void *), + void (*resume)(void *), + void *arg, + char *file, + int line); + +#if ERTS_GLB_INLINE_INCL_FUNC_DEF + + +ERTS_GLB_INLINE int +erts_smp_is_system_blocked(erts_activity_t allowed_activities) +{ +#ifdef ERTS_SMP + return erts_is_system_blocked(allowed_activities); +#else + return 1; +#endif +} + +ERTS_GLB_INLINE void +erts_smp_block_system(Uint32 allowed_activities) +{ +#ifdef ERTS_SMP + erts_block_system(allowed_activities); +#endif +} + +ERTS_GLB_INLINE int +erts_smp_emergency_block_system(long timeout, Uint32 allowed_activities) +{ +#ifdef ERTS_SMP + return erts_emergency_block_system(timeout, allowed_activities); +#else + return 0; +#endif +} + +ERTS_GLB_INLINE void +erts_smp_release_system(void) +{ +#ifdef ERTS_SMP + erts_release_system(); +#endif +} + +ERTS_GLB_INLINE int +erts_smp_pending_system_block(void) +{ +#ifdef ERTS_SMP + return erts_smp_atomic_read(&erts_system_block_state.do_block); +#else + return 0; +#endif +} + + +ERTS_GLB_INLINE void +erts_smp_chk_system_block(void (*prepare)(void *), + void (*resume)(void *), + void *arg) +{ +#ifdef ERTS_SMP + if (erts_smp_pending_system_block()) + erts_block_me(prepare, resume, arg); +#endif +} + +ERTS_GLB_INLINE void +erts_smp_set_activity(erts_activity_t old_activity, + erts_activity_t new_activity, + int locked, + void (*prepare)(void *), + void (*resume)(void *), + void *arg, + char *file, + int line) +{ +#ifdef ERTS_SMP +#ifdef ERTS_ENABLE_LOCK_CHECK + erts_lc_activity_change_begin(); +#endif + switch (old_activity) { + case ERTS_ACTIVITY_UNDEFINED: + break; + case ERTS_ACTIVITY_WAIT: + erts_smp_atomic_dec(&erts_system_block_state.in_activity.wait); + if (locked) { + /* You are not allowed to leave activity waiting + * without supplying the possibility to block + * unlocked. + */ + erts_set_activity_error(ERTS_ACT_ERR_LEAVE_WAIT_UNLOCKED, + file, line); + } + break; + case ERTS_ACTIVITY_GC: + erts_smp_atomic_dec(&erts_system_block_state.in_activity.gc); + break; + case ERTS_ACTIVITY_IO: + erts_smp_atomic_dec(&erts_system_block_state.in_activity.io); + break; + default: + erts_set_activity_error(ERTS_ACT_ERR_LEAVE_UNKNOWN_ACTIVITY, + file, line); + break; + } + + /* We are not allowed to block when going to activity waiting... */ + if (new_activity != ERTS_ACTIVITY_WAIT && erts_smp_pending_system_block()) + erts_check_block(old_activity,new_activity,locked,prepare,resume,arg); + + switch (new_activity) { + case ERTS_ACTIVITY_UNDEFINED: + break; + case ERTS_ACTIVITY_WAIT: + erts_smp_atomic_inc(&erts_system_block_state.in_activity.wait); + break; + case ERTS_ACTIVITY_GC: + erts_smp_atomic_inc(&erts_system_block_state.in_activity.gc); + break; + case ERTS_ACTIVITY_IO: + erts_smp_atomic_inc(&erts_system_block_state.in_activity.io); + break; + default: + erts_set_activity_error(ERTS_ACT_ERR_ENTER_UNKNOWN_ACTIVITY, + file, line); + break; + } + + switch (new_activity) { + case ERTS_ACTIVITY_WAIT: + case ERTS_ACTIVITY_GC: + case ERTS_ACTIVITY_IO: + if (erts_smp_pending_system_block()) + erts_note_activity_begin(new_activity); + break; + default: + break; + } + +#ifdef ERTS_ENABLE_LOCK_CHECK + erts_lc_activity_change_end(); +#endif + +#endif +} + +#endif /* #if ERTS_GLB_INLINE_INCL_FUNC_DEF */ + +#if defined(DEBUG) || defined(ERTS_ENABLE_LOCK_CHECK) +#undef ERTS_REFC_DEBUG +#define ERTS_REFC_DEBUG +#endif + +typedef erts_smp_atomic_t erts_refc_t; + +ERTS_GLB_INLINE void erts_refc_init(erts_refc_t *refcp, long val); +ERTS_GLB_INLINE void erts_refc_inc(erts_refc_t *refcp, long min_val); +ERTS_GLB_INLINE long erts_refc_inctest(erts_refc_t *refcp, long min_val); +ERTS_GLB_INLINE void erts_refc_dec(erts_refc_t *refcp, long min_val); +ERTS_GLB_INLINE long erts_refc_dectest(erts_refc_t *refcp, long min_val); +ERTS_GLB_INLINE void erts_refc_add(erts_refc_t *refcp, long diff, long min_val); +ERTS_GLB_INLINE long erts_refc_read(erts_refc_t *refcp, long min_val); + +#if ERTS_GLB_INLINE_INCL_FUNC_DEF + +ERTS_GLB_INLINE void +erts_refc_init(erts_refc_t *refcp, long val) +{ + erts_smp_atomic_init((erts_smp_atomic_t *) refcp, val); +} + +ERTS_GLB_INLINE void +erts_refc_inc(erts_refc_t *refcp, long min_val) +{ +#ifdef ERTS_REFC_DEBUG + long val = erts_smp_atomic_inctest((erts_smp_atomic_t *) refcp); + if (val < min_val) + erl_exit(ERTS_ABORT_EXIT, + "erts_refc_inc(): Bad refc found (refc=%ld < %ld)!\n", + val, min_val); +#else + erts_smp_atomic_inc((erts_smp_atomic_t *) refcp); +#endif +} + +ERTS_GLB_INLINE long +erts_refc_inctest(erts_refc_t *refcp, long min_val) +{ + long val = erts_smp_atomic_inctest((erts_smp_atomic_t *) refcp); +#ifdef ERTS_REFC_DEBUG + if (val < min_val) + erl_exit(ERTS_ABORT_EXIT, + "erts_refc_inctest(): Bad refc found (refc=%ld < %ld)!\n", + val, min_val); +#endif + return val; +} + +ERTS_GLB_INLINE void +erts_refc_dec(erts_refc_t *refcp, long min_val) +{ +#ifdef ERTS_REFC_DEBUG + long val = erts_smp_atomic_dectest((erts_smp_atomic_t *) refcp); + if (val < min_val) + erl_exit(ERTS_ABORT_EXIT, + "erts_refc_dec(): Bad refc found (refc=%ld < %ld)!\n", + val, min_val); +#else + erts_smp_atomic_dec((erts_smp_atomic_t *) refcp); +#endif +} + +ERTS_GLB_INLINE long +erts_refc_dectest(erts_refc_t *refcp, long min_val) +{ + long val = erts_smp_atomic_dectest((erts_smp_atomic_t *) refcp); +#ifdef ERTS_REFC_DEBUG + if (val < min_val) + erl_exit(ERTS_ABORT_EXIT, + "erts_refc_dectest(): Bad refc found (refc=%ld < %ld)!\n", + val, min_val); +#endif + return val; +} + +ERTS_GLB_INLINE void +erts_refc_add(erts_refc_t *refcp, long diff, long min_val) +{ +#ifdef ERTS_REFC_DEBUG + long val = erts_smp_atomic_addtest((erts_smp_atomic_t *) refcp, diff); + if (val < min_val) + erl_exit(ERTS_ABORT_EXIT, + "erts_refc_add(%ld): Bad refc found (refc=%ld < %ld)!\n", + diff, val, min_val); +#else + erts_smp_atomic_add((erts_smp_atomic_t *) refcp, diff); +#endif +} + +ERTS_GLB_INLINE long +erts_refc_read(erts_refc_t *refcp, long min_val) +{ + long val = erts_smp_atomic_read((erts_smp_atomic_t *) refcp); +#ifdef ERTS_REFC_DEBUG + if (val < min_val) + erl_exit(ERTS_ABORT_EXIT, + "erts_refc_read(): Bad refc found (refc=%ld < %ld)!\n", + val, min_val); +#endif + return val; +} + +#endif /* #if ERTS_GLB_INLINE_INCL_FUNC_DEF */ + +#ifdef ERTS_ENABLE_KERNEL_POLL +extern int erts_use_kernel_poll; +#endif + +void elib_ensure_initialized(void); + + +#if (defined(VXWORKS) || defined(_OSE_)) +/* NOTE! sys_calloc2 does not exist on other + platforms than VxWorks and OSE */ +EXTERN_FUNCTION(void*, sys_calloc2, (Uint, Uint)); +#endif /* VXWORKS || OSE */ + + +#define sys_memcpy(s1,s2,n) memcpy(s1,s2,n) +#define sys_memmove(s1,s2,n) memmove(s1,s2,n) +#define sys_memcmp(s1,s2,n) memcmp(s1,s2,n) +#define sys_memset(s,c,n) memset(s,c,n) +#define sys_memzero(s, n) memset(s,'\0',n) +#define sys_strcmp(s1,s2) strcmp(s1,s2) +#define sys_strncmp(s1,s2,n) strncmp(s1,s2,n) +#define sys_strcpy(s1,s2) strcpy(s1,s2) +#define sys_strncpy(s1,s2,n) strncpy(s1,s2,n) +#define sys_strlen(s) strlen(s) + +/* define function symbols (needed in sys_drv_api) */ +#define sys_fp_alloc sys_alloc +#define sys_fp_realloc sys_realloc +#define sys_fp_free sys_free +#define sys_fp_memcpy memcpy +#define sys_fp_memmove memmove +#define sys_fp_memcmp memcmp +#define sys_fp_memset memset +/* #define sys_fp_memzero elib_memzero */ +#define sys_fp_strcmp strcmp +#define sys_fp_strncmp strncmp +#define sys_fp_strcpy strcpy +#define sys_fp_strncpy strncpy +#define sys_fp_strlen strlen + + +/* Return codes from the nb_read and nb_write functions */ +#define FD_READY 1 +#define FD_CONTINUE 2 +#define FD_ERROR 3 + + + +/* Standard set of integer macros .. */ + +#define get_int64(s) ((((unsigned char*) (s))[0] << 56) | \ + (((unsigned char*) (s))[1] << 48) | \ + (((unsigned char*) (s))[2] << 40) | \ + (((unsigned char*) (s))[3] << 32) | \ + (((unsigned char*) (s))[4] << 24) | \ + (((unsigned char*) (s))[5] << 16) | \ + (((unsigned char*) (s))[6] << 8) | \ + (((unsigned char*) (s))[7])) + +#define put_int64(i, s) do {((char*)(s))[0] = (char)((Sint64)(i) >> 56) & 0xff;\ + ((char*)(s))[1] = (char)((Sint64)(i) >> 48) & 0xff;\ + ((char*)(s))[2] = (char)((Sint64)(i) >> 40) & 0xff;\ + ((char*)(s))[3] = (char)((Sint64)(i) >> 32) & 0xff;\ + ((char*)(s))[4] = (char)((Sint64)(i) >> 24) & 0xff;\ + ((char*)(s))[5] = (char)((Sint64)(i) >> 16) & 0xff;\ + ((char*)(s))[6] = (char)((Sint64)(i) >> 8) & 0xff;\ + ((char*)(s))[7] = (char)((Sint64)(i)) & 0xff;\ + } while (0) + +#define get_int32(s) ((((unsigned char*) (s))[0] << 24) | \ + (((unsigned char*) (s))[1] << 16) | \ + (((unsigned char*) (s))[2] << 8) | \ + (((unsigned char*) (s))[3])) + +#define put_int32(i, s) do {((char*)(s))[0] = (char)((i) >> 24) & 0xff; \ + ((char*)(s))[1] = (char)((i) >> 16) & 0xff; \ + ((char*)(s))[2] = (char)((i) >> 8) & 0xff; \ + ((char*)(s))[3] = (char)(i) & 0xff;} \ + while (0) + +#define get_int16(s) ((((unsigned char*) (s))[0] << 8) | \ + (((unsigned char*) (s))[1])) + + +#define put_int16(i, s) do {((char*)(s))[0] = (char)((i) >> 8) & 0xff; \ + ((char*)(s))[1] = (char)(i) & 0xff;} \ + while (0) + +#define get_int8(s) ((((unsigned char*) (s))[0] )) + + +#define put_int8(i, s) do {((unsigned char*)(s))[0] = (i) & 0xff;} while (0) + +/* + * Use DEBUGF as you would use printf, but use double parentheses: + * + * DEBUGF(("Error: %s\n", error)); + * + * The output will appear in a special console. + */ + +#ifdef DEBUG +EXTERN_FUNCTION(void, erl_debug, (char* format, ...)); +EXTERN_FUNCTION(void, erl_bin_write, (unsigned char *, int, int)); + +# define DEBUGF(x) erl_debug x +#else +# define DEBUGF(x) +#endif + + +#ifdef VXWORKS +/* This includes redefines of malloc etc + this should be done after sys_alloc, etc, above */ +# include "reclaim.h" +/*********************Malloc and friends************************ + * There is a problem with the naming of malloc and friends, + * malloc is used throughout sys.c and the resolver to mean save_alloc, + * but it should actually mean either sys_alloc or sys_alloc2, + * so the definitions from reclaim_master.h are not any + * good, i redefine the malloc family here, although it's quite + * ugly, actually it would be preferrable to use the + * names sys_alloc and so on throughout the offending code, but + * that will be saved as an later exercise... + * I also add an own calloc, to make the BSD resolver source happy. + ***************************************************************/ +/* Undefine malloc and friends */ +# ifdef malloc +# undef malloc +# endif +# ifdef calloc +# undef calloc +# endif +# ifdef realloc +# undef realloc +# endif +# ifdef free +# undef free +# endif +/* Redefine malloc and friends */ +# define malloc sys_alloc +# define calloc sys_calloc +# define realloc sys_realloc +# define free sys_free + +#endif + + +#ifdef __WIN32__ + +void call_break_handler(void); +char* last_error(void); +char* win32_errorstr(int); + + +#endif + + +#endif + |