diff options
Diffstat (limited to 'erts/lib_src/common')
| -rw-r--r-- | erts/lib_src/common/erl_memory_trace_parser.c | 1956 | ||||
| -rw-r--r-- | erts/lib_src/common/erl_misc_utils.c | 967 | ||||
| -rw-r--r-- | erts/lib_src/common/erl_printf.c | 427 | ||||
| -rw-r--r-- | erts/lib_src/common/erl_printf_format.c | 940 | ||||
| -rw-r--r-- | erts/lib_src/common/ethread.c | 3346 |
5 files changed, 7636 insertions, 0 deletions
diff --git a/erts/lib_src/common/erl_memory_trace_parser.c b/erts/lib_src/common/erl_memory_trace_parser.c new file mode 100644 index 0000000000..54c3dfadec --- /dev/null +++ b/erts/lib_src/common/erl_memory_trace_parser.c @@ -0,0 +1,1956 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 2004-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% + */ + + +/* + * Description: + * + * Author: Rickard Green + */ + +#include "erl_memory_trace_parser.h" +#include "erl_memory_trace_protocol.h" +#include <string.h> /* For memcpy */ + +#ifdef DEBUG +#include <assert.h> +#define ASSERT assert +#define PRINT_ERROR_ORIGIN 1 +#if PRINT_ERROR_ORIGIN +#include <stdio.h> +#endif +#define PRINT_PARSED_OP 0 +#if PRINT_PARSED_OP +#include <stdio.h> +static void print_op(emtp_operation *op_p); +#endif +static void hexdump(void *start, void *end); +#else +#define PRINT_ERROR_ORIGIN 0 +#define PRINT_PARSED_OP 0 +#define ASSERT(B) +#endif + + +#if ERTS_MT_MAJOR_VSN != 2 || ERTS_MT_MINOR_VSN != 0 +#error trace version mismatch (expected version 2.0) +/* Make sure that older versions are supported when implementing + support for newer versions! */ +#endif + + +#if defined(__GNUC__) +# define EMTP_CAN_INLINE 1 +# define EMTP_INLINE __inline__ +#elif defined(__WIN32__) +# define EMTP_CAN_INLINE 1 +# define EMTP_INLINE __forceinline +#else +# define EMTP_CAN_INLINE 0 +# define EMTP_INLINE +#endif + + +#define UI8_SZ 1 +#define UI16_SZ 2 +#define UI32_SZ 4 +#define UI64_SZ 8 + +#define MAX(X, Y) ((X) > (Y) ? (X) : (Y)) +#define MIN(X, Y) ((X) < (Y) ? (X) : (Y)) + +#define DEFAULT_OVERFLOW_BUF_SZ 128 + +#define UNKNOWN_BLOCK_TYPE_IX (-1) +#define UNKNOWN_ALLOCATOR_IX (-1) + +#define INVALID_SIZE (((sgnd_int_32) 1) << 31) +#define INVALID_RESULT ((int) INVALID_SIZE) + +typedef enum { + EMTP_PROGRESS_PARSE_HDR_VSN, + EMTP_PROGRESS_PARSE_HDR_PROLOG, + EMTP_PROGRESS_ALLOC_HDR_INFO, + EMTP_PROGRESS_PARSE_TAGGED_HDR, + EMTP_PROGRESS_PARSE_BODY, + EMTP_PROGRESS_ENDED +} emtp_progress; + +struct emtp_state_ { + + /* Trace version */ + emtp_version version; + + /* Flags */ + usgnd_int_32 flags; + + /* Progress */ + emtp_progress progress; + + /* Name, host, and pid as strings */ + char nodename[256]; + char hostname[256]; + char pid[256]; + + /* Local time on the traced node when the node started */ + struct { + usgnd_int_32 year; + usgnd_int_32 month; + usgnd_int_32 day; + usgnd_int_32 hour; + usgnd_int_32 minute; + usgnd_int_32 second; + usgnd_int_32 micro_second; + } start_time; + + /* Function to parse body with */ + int (*parse_body_func)(emtp_state *, + usgnd_int_8 **, + usgnd_int_8 *, + emtp_operation **, + emtp_operation *, + size_t); + /* Current time elapsed */ + struct { + usgnd_int_32 secs; + usgnd_int_32 usecs; + } time; + + /* */ + + int force_return; + + /* Overflow buffer */ + size_t overflow_size; + size_t overflow_buf_size; + usgnd_int_8 * overflow; + sgnd_int_32 fetch_size; + int known_need; + + usgnd_int_16 segment_ix; + usgnd_int_16 max_allocator_ix; + emtp_allocator ** allocator; + usgnd_int_16 max_block_type_ix; + emtp_block_type ** block_type; + + /* Memory allocation functions */ + void * (*alloc)(size_t); + void * (*realloc)(void *, size_t); + void (*free)(void *); + +}; + +static char unknown_allocator[] = "unknown_allocator"; +static char unknown_block_type[] = "unknown_block_type"; + +const char * +emtp_error_string(int res) +{ + switch (res) { + case EMTP_NO_TRACE_ERROR: + return "no trace error"; + case EMTP_HEADER_TAG_IN_BODY_ERROR: + return "header tag in body error"; + case EMTP_BODY_TAG_IN_HEADER_ERROR: + return "body tag in header error"; + case EMTP_NOT_SUPPORTED_MTRACE_VERSION_ERROR: + return "not supported mtrace version error"; + case EMTP_NOT_AN_ERL_MTRACE_ERROR: + return "not an erl mtrace error"; + case EMTP_NO_MEMORY_ERROR: + return "no memory error"; + case EMTP_BAD_OP_SIZE_ERROR: + return "bad op size error"; + case EMTP_NO_OPERATIONS_ERROR: + return "no operations error"; + case EMTP_NOT_SUPPORTED_64_BITS_TRACE_ERROR: + return "not supported 64 bits trace error"; + case EMTP_PARSE_ERROR: + return "parse error"; + case EMTP_UNKNOWN_TAG_ERROR: + return "unknown tag error"; + case EMTP_END_OF_TRACE: + return "end of trace"; + case EMTP_END_OF_TRACE_GARBAGE_FOLLOWS: + return "end of trace; garbage follows"; + case EMTP_ALL_OPS_FILLED: + return "all operations filled"; + case EMTP_NEED_MORE_TRACE: + return "need more trace"; + case EMTP_HEADER_PARSED: + return "header parsed"; + default: + return NULL; + } + +} + +int +emtp_get_info(emtp_info *infop, size_t *info_szp, emtp_state *statep) +{ + if (!infop || !info_szp || *info_szp < sizeof(emtp_info)) + return 0; + + infop->version.parser.major = ERTS_MT_MAJOR_VSN; + infop->version.parser.minor = ERTS_MT_MINOR_VSN; + + *info_szp = sizeof(emtp_version); + + if (!statep || statep->version.major == 0) + return 1; + + infop->version.trace.major = statep->version.major; + infop->version.trace.minor = statep->version.minor; + + *info_szp = sizeof(emtp_versions); + + if (statep->progress != EMTP_PROGRESS_PARSE_BODY + && statep->progress != EMTP_PROGRESS_ENDED) + return 1; + + infop->bits = (statep->flags & ERTS_MT_64_BIT_FLAG + ? 64 + : 32); + + infop->nodename = statep->nodename; + infop->hostname = statep->hostname; + infop->pid = statep->pid; + + infop->start_time.year = statep->start_time.year; + infop->start_time.month = statep->start_time.month; + infop->start_time.day = statep->start_time.day; + infop->start_time.hour = statep->start_time.hour; + infop->start_time.minute = statep->start_time.minute; + infop->start_time.second = statep->start_time.second; + infop->start_time.micro_second = statep->start_time.micro_second; + + infop->have_carrier_info = statep->flags & ERTS_MT_CRR_INFO; + infop->have_segment_carrier_info = statep->flags & ERTS_MT_SEG_CRR_INFO; + infop->segment_ix = statep->segment_ix; + infop->max_allocator_ix = statep->max_allocator_ix; + infop->allocator = statep->allocator; + infop->max_block_type_ix = statep->max_block_type_ix; + infop->block_type = statep->block_type; + + *info_szp = sizeof(emtp_info); + + return 1; +} + +emtp_state * +emtp_state_new(void * (*alloc)(size_t), + void * (*realloc)(void *, size_t), + void (*free)(void *)) +{ + emtp_state *statep; + + if (!alloc || !realloc || !free) + return NULL; + + statep = (emtp_state *) (*alloc)(sizeof(emtp_state)); + if (!statep) + return NULL; + + statep->version.major = 0; + statep->version.minor = 0; + statep->flags = 0; + statep->progress = EMTP_PROGRESS_PARSE_HDR_VSN; + + statep->nodename[0] = '\0'; + statep->hostname[0] = '\0'; + statep->pid[0] = '\0'; + + statep->start_time.year = 0; + statep->start_time.month = 0; + statep->start_time.day = 0; + statep->start_time.hour = 0; + statep->start_time.minute = 0; + statep->start_time.second = 0; + statep->start_time.micro_second = 0; + + statep->parse_body_func = NULL; + statep->time.secs = 0; + statep->time.usecs = 0; + statep->force_return = 0; + statep->overflow_size = 0; + statep->overflow_buf_size = DEFAULT_OVERFLOW_BUF_SZ; + statep->overflow = + (usgnd_int_8 *) (*alloc)(DEFAULT_OVERFLOW_BUF_SZ*sizeof(usgnd_int_8)); + statep->fetch_size = 0; + statep->known_need = 0; + statep->segment_ix = 0; + statep->max_allocator_ix = 0; + statep->allocator = NULL; + statep->max_block_type_ix = 0; + statep->block_type = NULL; + statep->alloc = alloc; + statep->realloc = realloc; + statep->free = free; + + return statep; +} + +void +emtp_state_destroy(emtp_state *statep) +{ + void (*freep)(void *); + int i; + + if (!statep) + return; + + freep = statep->free; + + if (statep->overflow) + (*freep)((void *) statep->overflow); + + if (statep->allocator) { + for (i = -1; i <= statep->max_allocator_ix; i++) { + if (statep->allocator[i]) { + if (statep->allocator[i]->name + && statep->allocator[i]->name != unknown_allocator) + (*freep)((void *) statep->allocator[i]->name); + if (statep->allocator[i]->carrier.provider) + (*freep)((void *) statep->allocator[i]->carrier.provider); + (*freep)((void *) statep->allocator[i]); + } + } + statep->allocator--; + (*freep)((void *) statep->allocator); + } + + if (statep->block_type) { + for (i = -1; i <= statep->max_block_type_ix; i++) { + if (statep->block_type[i]) { + if (statep->block_type[i]->name + && statep->block_type[i]->name != unknown_block_type) + (*freep)((void *) statep->block_type[i]->name); + (*freep)((void *) statep->block_type[i]); + } + } + statep->block_type--; + (*freep)((void *) statep->block_type); + } + + (*freep)((void *) statep); +} + +/* + * The following macros are for use in emtp_parse(), parse_vX_body, + * and parse_header. + * + * Note that some of them depend on function local variable names + * and lables: + * + * Variables: + * * result -> the result to return + * * statep -> pointer to the state + * + * Lables: + * * restore_return -> restore then return result + */ + + +#define GET_UI8(UI, BP) ((UI) = *((BP)++)) +#define GET_UI16(UI, BP) \ + do { \ + (UI) = ((( (usgnd_int_16) (BP)[0]) << 8) \ + | ((usgnd_int_16) (BP)[1])); \ + (BP) += UI16_SZ; \ +} while(0) + +#define GET_UI32(UI, BP) \ + do { \ + (UI) = ((( (usgnd_int_32) (BP)[0]) << 24) \ + | (((usgnd_int_32) (BP)[1]) << 16) \ + | (((usgnd_int_32) (BP)[2]) << 8) \ + | ( (usgnd_int_32) (BP)[3])); \ + (BP) += UI32_SZ; \ +} while(0) + +#define GET_UI64(UI, BP) \ + do { \ + (UI) = ((( (usgnd_int_64) (BP)[0]) << 56) \ + | (((usgnd_int_64) (BP)[1]) << 48) \ + | (((usgnd_int_64) (BP)[2]) << 40) \ + | (((usgnd_int_64) (BP)[3]) << 32) \ + | (((usgnd_int_64) (BP)[4]) << 24) \ + | (((usgnd_int_64) (BP)[5]) << 16) \ + | (((usgnd_int_64) (BP)[6]) << 8) \ + | ( (usgnd_int_64) (BP)[7])); \ + (BP) += UI64_SZ; \ +} while(0) + +#define GET_VSZ_UI16(UI, BP, MSB) \ +do { \ + usgnd_int_16 ui_ = 0; \ + switch ((MSB)) { \ + case 1: ui_ |= (usgnd_int_16) *((BP)++); ui_ <<= 8; \ + case 0: ui_ |= (usgnd_int_16) *((BP)++); break; \ + default: ERROR(EMTP_PARSE_ERROR); \ + } \ + (UI) = ui_; \ +} while (0) + +#define GET_VSZ_UI32(UI, BP, MSB) \ +do { \ + usgnd_int_32 ui_ = 0; \ + switch ((MSB)) { \ + case 3: ui_ |= (usgnd_int_32) *((BP)++); ui_ <<= 8; \ + case 2: ui_ |= (usgnd_int_32) *((BP)++); ui_ <<= 8; \ + case 1: ui_ |= (usgnd_int_32) *((BP)++); ui_ <<= 8; \ + case 0: ui_ |= (usgnd_int_32) *((BP)++); break; \ + default: ERROR(EMTP_PARSE_ERROR); \ + } \ + (UI) = ui_; \ +} while (0) + +#define GET_VSZ_UI64(UI, BP, MSB) \ +do { \ + usgnd_int_64 ui_ = 0; \ + switch ((MSB)) { \ + case 7: ui_ |= (usgnd_int_64) *((BP)++); ui_ <<= 8; \ + case 6: ui_ |= (usgnd_int_64) *((BP)++); ui_ <<= 8; \ + case 5: ui_ |= (usgnd_int_64) *((BP)++); ui_ <<= 8; \ + case 4: ui_ |= (usgnd_int_64) *((BP)++); ui_ <<= 8; \ + case 3: ui_ |= (usgnd_int_64) *((BP)++); ui_ <<= 8; \ + case 2: ui_ |= (usgnd_int_64) *((BP)++); ui_ <<= 8; \ + case 1: ui_ |= (usgnd_int_64) *((BP)++); ui_ <<= 8; \ + case 0: ui_ |= (usgnd_int_64) *((BP)++); break; \ + default: ERROR(EMTP_PARSE_ERROR); \ + } \ + (UI) = ui_; \ +} while (0) + + +#if HAVE_INT_64 +#define GET_VSZ_UIMAX(UI, BP, MSB) \ +do { \ + usgnd_int_64 ui64_; \ + GET_VSZ_UI64(ui64_, (BP), (MSB)); \ + (UI) = (usgnd_int_max) ui64_; \ +} while (0) +#else +#define GET_VSZ_UIMAX(UI, BP, MSB) \ +do { \ + usgnd_int_32 ui32_; \ + GET_VSZ_UI32(ui32_, (BP), (MSB)); \ + (UI) = (usgnd_int_max) ui32_; \ +} while (0) +#endif + + + +#define INC_TIME(C_SECS, C_USECS, SECS, USECS) \ +do { \ + if ((USECS) >= 1000000) \ + ERROR(EMTP_PARSE_ERROR); \ + (C_SECS) += (SECS); \ + (C_USECS) += (USECS); \ + if ((C_USECS) >= 1000000) { \ + (C_USECS) -= 1000000; \ + (C_SECS)++; \ + } \ +} while (0) + +#if PRINT_ERROR_ORIGIN +#include <stdio.h> +#define ERROR(E) \ +do { \ + result = (E); \ + fprintf(stderr,"ERROR:%s:%d: result=%d\n",__FILE__,__LINE__,result);\ + statep->force_return = 1; abort(); \ + goto restore_return; \ +} while (0) +#else +#define ERROR(E) do { \ + result = (E); \ + statep->force_return = 1; \ + goto restore_return; \ +} while (0) +#endif + +#define NEED(NSZ, TSZ) \ +do { \ + sgnd_int_32 need_ = (NSZ); \ + if (need_ > (TSZ)) { \ + statep->known_need = 1; \ + statep->fetch_size = need_; \ + result = EMTP_NEED_MORE_TRACE; \ + goto restore_return; \ + } \ +} while (0) + +#define NEED_AT_LEAST(NSZ, FSZ, TSZ) \ +do { \ + sgnd_int_32 need_ = (NSZ); \ + ASSERT(need_ <= (FSZ)); \ + if (need_ > (TSZ)) { \ + statep->known_need = 0; \ + statep->fetch_size = (FSZ); \ + result = EMTP_NEED_MORE_TRACE; \ + goto restore_return; \ + } \ +} while (0) + + +#define SECS_PER_DAY (60*60*24) +#define IS_LEAP_YEAR(X) (((X) % 4 == 0 && (X) % 100 != 0) || (X) % 400 == 0) + +static void +set_start_time(emtp_state *state, + usgnd_int_32 giga_seconds, + usgnd_int_32 seconds, + usgnd_int_32 micro_seconds) +{ + /* Input is elapsed time since 1970-01-01 00:00.000000 (UTC) */ + + usgnd_int_32 year, days_of_this_year, days, secs, month; + usgnd_int_32 days_of_month[] = {0,31,28,31,30,31,30,31,31,30,31,30,31}; + + days = 1000000000 / SECS_PER_DAY; + secs = 1000000000 % SECS_PER_DAY; + days *= giga_seconds; + secs *= giga_seconds; + secs += seconds; + days += secs / SECS_PER_DAY; + secs %= SECS_PER_DAY; + days++; + + year = 1969; + days_of_this_year = 0; + while (days > days_of_this_year) { + days -= days_of_this_year; + year++; + days_of_this_year = 365 + (IS_LEAP_YEAR(year) ? 1 : 0); + } + + for (month = 1; month <= 12; month++) { + usgnd_int_32 days_of_this_month = days_of_month[month]; + if (month == 2 && IS_LEAP_YEAR(year)) + days_of_this_month++; + if (days <= days_of_this_month) + break; + days -= days_of_this_month; + } + + state->start_time.year = year; + state->start_time.month = month; + state->start_time.day = days; + state->start_time.hour = secs / (60*60); + secs %= 60*60; + state->start_time.minute = secs / 60; + state->start_time.second = secs % 60; + state->start_time.micro_second = micro_seconds; +} + +static int +parse_v1_body(emtp_state *statep, + usgnd_int_8 **tracepp, usgnd_int_8 *trace_endp, + emtp_operation **op_pp, emtp_operation *op_endp, size_t op_size) +{ + /* "cache" some frequently used values */ + register usgnd_int_8 *c_p = *tracepp; + register emtp_operation *op_p = *op_pp; + register usgnd_int_32 current_secs = statep->time.secs; + register usgnd_int_32 current_usecs = statep->time.usecs; + + sgnd_int_32 trace_size = trace_endp - c_p; + usgnd_int_8 *tracep = c_p; + int result = 0; + + usgnd_int_16 max_block_type = statep->max_block_type_ix; + + while (trace_size >= UI16_SZ) { + usgnd_int_16 ehdr, tag; + unsigned time_inc_msb; + + GET_UI16(ehdr, c_p); + tag = ehdr & ERTS_MT_TAG_EHDR_FLD_MSK; + switch (tag) { + case ERTS_MT_V1_ALLOC_TAG: + + op_p->type = EMTP_ALLOC; + + alloc_common: { + usgnd_int_16 block_type; + unsigned block_type_msb, new_ptr_msb, new_size_msb; + + ehdr >>= ERTS_MT_TAG_EHDR_FLD_SZ; + block_type_msb = ehdr & ERTS_MT_UI16_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI16_MSB_EHDR_FLD_SZ; + new_ptr_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + new_size_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + time_inc_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + NEED(UI16_SZ + + 4 + + block_type_msb + + new_ptr_msb + + new_size_msb + + time_inc_msb, + trace_size); + + GET_VSZ_UI16(block_type, c_p, block_type_msb); + if (block_type > max_block_type) + ERROR(EMTP_PARSE_ERROR); + op_p->u.block.type = (int) block_type; + + GET_VSZ_UIMAX(op_p->u.block.new_ptr, c_p, new_ptr_msb); + GET_VSZ_UIMAX(op_p->u.block.new_size, c_p, new_size_msb); + + op_p->u.block.prev_ptr = 0; + } + + read_time_inc: { + usgnd_int_32 secs, usecs, time_inc; + + GET_VSZ_UI32(time_inc, c_p, time_inc_msb); + + secs = ((time_inc >> ERTS_MT_TIME_INC_SECS_SHIFT) + & ERTS_MT_TIME_INC_SECS_MASK); + usecs = ((time_inc >> ERTS_MT_TIME_INC_USECS_SHIFT) + & ERTS_MT_TIME_INC_USECS_MASK); + + INC_TIME(current_secs, current_usecs, secs, usecs); + + op_p->time.secs = current_secs; + op_p->time.usecs = current_usecs; + +#if PRINT_PARSED_OP + print_op(op_p); +#endif + + op_p = (emtp_operation *) (((char *) op_p) + op_size); + break; + } + + case ERTS_MT_V1_REALLOC_NPB_TAG: + op_p->type = EMTP_REALLOC; + goto alloc_common; + + case ERTS_MT_V1_REALLOC_MV_TAG: { + unsigned new_ptr_msb, prev_ptr_msb, new_size_msb; + + op_p->type = EMTP_REALLOC; + + ehdr >>= ERTS_MT_TAG_EHDR_FLD_SZ; + new_ptr_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + prev_ptr_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + new_size_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + time_inc_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + NEED(UI16_SZ + + 4 + + new_ptr_msb + + prev_ptr_msb + + new_size_msb + + time_inc_msb, + trace_size); + + GET_VSZ_UIMAX(op_p->u.block.new_ptr, c_p, new_ptr_msb); + GET_VSZ_UIMAX(op_p->u.block.prev_ptr, c_p, prev_ptr_msb); + GET_VSZ_UIMAX(op_p->u.block.new_size, c_p, new_size_msb); + + op_p->u.block.type = UNKNOWN_BLOCK_TYPE_IX; + goto read_time_inc; + } + + case ERTS_MT_V1_REALLOC_NMV_TAG: { + usgnd_int_max new_ptr; + unsigned new_ptr_msb, new_size_msb; + + op_p->type = EMTP_REALLOC; + + ehdr >>= ERTS_MT_TAG_EHDR_FLD_SZ; + new_ptr_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + new_size_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + time_inc_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + NEED(UI16_SZ + + 3 + + new_ptr_msb + + new_size_msb + + time_inc_msb, + trace_size); + + GET_VSZ_UIMAX(new_ptr, c_p, new_ptr_msb); + GET_VSZ_UIMAX(op_p->u.block.new_size, c_p, new_size_msb); + + op_p->u.block.new_ptr = new_ptr; + op_p->u.block.prev_ptr = new_ptr; + + op_p->u.block.type = UNKNOWN_BLOCK_TYPE_IX; + goto read_time_inc; + } + + case ERTS_MT_V1_FREE_TAG: { + unsigned prev_ptr_msb; + + op_p->type = EMTP_FREE; + + ehdr >>= ERTS_MT_TAG_EHDR_FLD_SZ; + prev_ptr_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + time_inc_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + NEED(UI16_SZ + + 2 + + prev_ptr_msb + + time_inc_msb, + trace_size); + + GET_VSZ_UIMAX(op_p->u.block.prev_ptr, c_p, prev_ptr_msb); + + op_p->u.block.new_ptr = 0; + op_p->u.block.new_size = 0; + + op_p->u.block.type = UNKNOWN_BLOCK_TYPE_IX; + goto read_time_inc; + } + + case ERTS_MT_V1_TIME_INC_TAG: { + unsigned secs_msb, usecs_msb; + usgnd_int_32 secs, usecs; + + ehdr >>= ERTS_MT_TAG_EHDR_FLD_SZ; + + secs_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI32_MSB_EHDR_FLD_SZ; + + usecs_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + NEED(UI16_SZ + 2 + secs_msb + usecs_msb, trace_size); + + GET_VSZ_UI32(secs, c_p, secs_msb); + GET_VSZ_UI32(usecs, c_p, usecs_msb); + + INC_TIME(current_secs, current_usecs, secs, usecs); + + break; + } + + case ERTS_MT_V1_STOP_TAG: + + op_p->type = EMTP_STOP; + + ehdr >>= ERTS_MT_TAG_EHDR_FLD_SZ; + + time_inc_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + NEED(UI16_SZ + 1 + time_inc_msb, trace_size); + + goto read_ending_time_inc; + + case ERTS_MT_V1_EXIT_TAG: { + unsigned exit_status_msb; + + op_p->type = EMTP_EXIT; + + ehdr >>= ERTS_MT_TAG_EHDR_FLD_SZ; + exit_status_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI32_MSB_EHDR_FLD_SZ; + time_inc_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + NEED(UI16_SZ + 2 + exit_status_msb + time_inc_msb, + trace_size); + + GET_VSZ_UI32(op_p->u.exit_status, c_p, exit_status_msb); + + read_ending_time_inc: { + usgnd_int_32 secs, usecs, time_inc; + + GET_VSZ_UI32(time_inc, c_p, time_inc_msb); + + secs = ((time_inc >> ERTS_MT_TIME_INC_SECS_SHIFT) + & ERTS_MT_TIME_INC_SECS_MASK); + usecs = ((time_inc >> ERTS_MT_TIME_INC_USECS_SHIFT) + & ERTS_MT_TIME_INC_USECS_MASK); + + INC_TIME(current_secs, current_usecs, secs, usecs); + + op_p->time.secs = current_secs; + op_p->time.usecs = current_usecs; + +#if PRINT_PARSED_OP + print_op(op_p); +#endif + + op_p = (emtp_operation *) (((char *) op_p) + op_size); + statep->force_return = 1; + statep->progress = EMTP_PROGRESS_ENDED; + + tracep = c_p; + trace_size = trace_endp - tracep; + result = (trace_size + ? EMTP_END_OF_TRACE_GARBAGE_FOLLOWS + : EMTP_END_OF_TRACE); + goto restore_return; + } + } + + case ERTS_MT_V1_ALLOCATOR_TAG: + case ERTS_MT_V1_BLOCK_TYPE_TAG: + +#ifdef DEBUG + hexdump(tracep, trace_endp); +#endif + ERROR(EMTP_HEADER_TAG_IN_BODY_ERROR); + + default: + +#ifdef DEBUG + hexdump(tracep, trace_endp); +#endif + ERROR(EMTP_UNKNOWN_TAG_ERROR); + } + + tracep = c_p; + trace_size = trace_endp - tracep; + + if (op_p >= op_endp) { + statep->force_return = 1; + result = EMTP_ALL_OPS_FILLED; + goto restore_return; + } + } + + statep->known_need = 0; + statep->fetch_size = ERTS_MT_MAX_V1_BODY_ENTRY_SIZE; + + result = EMTP_NEED_MORE_TRACE; + + restore_return: + *tracepp = tracep; + *op_pp = op_p; + statep->time.secs = current_secs; + statep->time.usecs = current_usecs; + + return result; +} + +#define GET_ALLOC_MSBS(EHDR, BT, NP, NS, TI) \ +do { \ + (BT) = (EHDR) & ERTS_MT_UI16_MSB_EHDR_FLD_MSK; \ + (EHDR) >>= ERTS_MT_UI16_MSB_EHDR_FLD_SZ; \ + (NP) = (EHDR) & ERTS_MT_UI_MSB_EHDR_FLD_MSK; \ + (EHDR) >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; \ + (NS) = (EHDR) & ERTS_MT_UI_MSB_EHDR_FLD_MSK; \ + (EHDR) >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; \ + (TI) = (EHDR) & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; \ +} while (0) + + +static EMTP_INLINE int +parse_v2_body(emtp_state *statep, + usgnd_int_8 **tracepp, usgnd_int_8 *trace_endp, + emtp_operation **op_pp, emtp_operation *op_endp, size_t op_size) +{ + /* "cache" some frequently used values */ + register usgnd_int_8 *c_p = *tracepp; + register emtp_operation *op_p = *op_pp; + register usgnd_int_32 current_secs = statep->time.secs; + register usgnd_int_32 current_usecs = statep->time.usecs; + + sgnd_int_32 trace_size = trace_endp - c_p; + usgnd_int_8 *tracep = c_p; + int result = 0; + + while (trace_size >= UI8_SZ + UI16_SZ) { + usgnd_int_8 tag; + usgnd_int_16 ehdr; + unsigned time_inc_msb; + + tag = *(c_p++); + + GET_UI16(ehdr, c_p); + + switch (tag) { + + case ERTS_MT_CRR_ALLOC_BDY_TAG: { + usgnd_int_16 type; + unsigned carrier_bytes, carrier_type_msb, block_type_msb, + new_ptr_msb, new_size_msb; + + op_p->type = EMTP_CARRIER_ALLOC; + + carrier_type_msb = ehdr & ERTS_MT_UI16_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI16_MSB_EHDR_FLD_SZ; + + if (trace_size < ERTS_MT_MAX_CRR_ALLOC_SIZE) + NEED_AT_LEAST(UI8_SZ + UI16_SZ + 1 + carrier_type_msb, + ERTS_MT_MAX_CRR_ALLOC_SIZE, + trace_size); + + GET_VSZ_UI16(type, c_p, carrier_type_msb); + op_p->u.block.carrier_type = (int) type; + + carrier_bytes = carrier_type_msb + 1; + goto alloc_common; + + case ERTS_MT_ALLOC_BDY_TAG: + + op_p->type = EMTP_ALLOC; + carrier_bytes = 0; + + alloc_common: + block_type_msb = ehdr & ERTS_MT_UI16_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI16_MSB_EHDR_FLD_SZ; + new_ptr_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + new_size_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + time_inc_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + if (trace_size < ERTS_MT_MAX_CRR_ALLOC_SIZE) + NEED(UI8_SZ + + UI16_SZ + + 4 + + carrier_bytes + + block_type_msb + + new_ptr_msb + + new_size_msb + + time_inc_msb, + trace_size); + + GET_VSZ_UI16(type, c_p, block_type_msb); + op_p->u.block.type = (int) type; + + GET_VSZ_UIMAX(op_p->u.block.new_ptr, c_p, new_ptr_msb); + GET_VSZ_UIMAX(op_p->u.block.new_size, c_p, new_size_msb); + + op_p->u.block.prev_ptr = 0; + } + + read_time_inc: { + usgnd_int_32 secs, usecs, time_inc; + + GET_VSZ_UI32(time_inc, c_p, time_inc_msb); + + secs = ((time_inc >> ERTS_MT_TIME_INC_SECS_SHIFT) + & ERTS_MT_TIME_INC_SECS_MASK); + usecs = ((time_inc >> ERTS_MT_TIME_INC_USECS_SHIFT) + & ERTS_MT_TIME_INC_USECS_MASK); + + INC_TIME(current_secs, current_usecs, secs, usecs); + + op_p->time.secs = current_secs; + op_p->time.usecs = current_usecs; + +#if PRINT_PARSED_OP + print_op(op_p); +#endif + + op_p = (emtp_operation *) (((char *) op_p) + op_size); + break; + } + + case ERTS_MT_CRR_REALLOC_BDY_TAG: { + usgnd_int_16 type; + unsigned carrier_bytes, carrier_type_msb, block_type_msb, + new_ptr_msb, prev_ptr_msb, new_size_msb; + + op_p->type = EMTP_CARRIER_REALLOC; + + carrier_type_msb = ehdr & ERTS_MT_UI16_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI16_MSB_EHDR_FLD_SZ; + + if (trace_size < ERTS_MT_MAX_CRR_REALLOC_SIZE) + NEED_AT_LEAST(UI8_SZ + UI16_SZ + 1 + carrier_type_msb, + ERTS_MT_MAX_CRR_REALLOC_SIZE, + trace_size); + + GET_VSZ_UI16(type, c_p, carrier_type_msb); + op_p->u.block.carrier_type = (int) type; + + carrier_bytes = carrier_type_msb + 1; + goto realloc_common; + + case ERTS_MT_REALLOC_BDY_TAG: + + op_p->type = EMTP_REALLOC; + carrier_bytes = 0; + + realloc_common: + + block_type_msb = ehdr & ERTS_MT_UI16_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI16_MSB_EHDR_FLD_SZ; + new_ptr_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + prev_ptr_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + new_size_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + time_inc_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + if (trace_size < ERTS_MT_MAX_CRR_REALLOC_SIZE) + NEED(UI8_SZ + + UI16_SZ + + 5 + + carrier_bytes + + block_type_msb + + new_ptr_msb + + prev_ptr_msb + + new_size_msb + + time_inc_msb, + trace_size); + + GET_VSZ_UI16(op_p->u.block.type, c_p, block_type_msb); + GET_VSZ_UIMAX(op_p->u.block.new_ptr, c_p, new_ptr_msb); + GET_VSZ_UIMAX(op_p->u.block.prev_ptr, c_p, prev_ptr_msb); + GET_VSZ_UIMAX(op_p->u.block.new_size, c_p, new_size_msb); + + goto read_time_inc; + } + + case ERTS_MT_CRR_FREE_BDY_TAG: { + usgnd_int_16 type; + unsigned carrier_bytes, carrier_type_msb, block_type_msb, + prev_ptr_msb; + + op_p->type = EMTP_CARRIER_FREE; + + carrier_type_msb = ehdr & ERTS_MT_UI16_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI16_MSB_EHDR_FLD_SZ; + + if (trace_size < ERTS_MT_MAX_CRR_FREE_SIZE) + NEED_AT_LEAST(UI8_SZ + UI16_SZ + 1 + carrier_type_msb, + ERTS_MT_MAX_CRR_FREE_SIZE, + trace_size); + + GET_VSZ_UI16(type, c_p, carrier_type_msb); + op_p->u.block.carrier_type = (int) type; + + carrier_bytes = carrier_type_msb + 1; + goto free_common; + + case ERTS_MT_FREE_BDY_TAG: + + op_p->type = EMTP_FREE; + carrier_bytes = 0; + + free_common: + + block_type_msb = ehdr & ERTS_MT_UI16_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI16_MSB_EHDR_FLD_SZ; + prev_ptr_msb = ehdr & ERTS_MT_UI_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI_MSB_EHDR_FLD_SZ; + time_inc_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + if (trace_size < ERTS_MT_MAX_CRR_FREE_SIZE) + NEED(UI8_SZ + + UI16_SZ + + 3 + + carrier_bytes + + block_type_msb + + prev_ptr_msb + + time_inc_msb, + trace_size); + + GET_VSZ_UI16(op_p->u.block.type, c_p, block_type_msb); + GET_VSZ_UIMAX(op_p->u.block.prev_ptr, c_p, prev_ptr_msb); + + op_p->u.block.new_ptr = 0; + op_p->u.block.new_size = 0; + + goto read_time_inc; + } + + case ERTS_MT_TIME_INC_BDY_TAG: { + unsigned secs_msb, usecs_msb; + usgnd_int_32 secs, usecs; + + secs_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI32_MSB_EHDR_FLD_SZ; + usecs_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + NEED(UI8_SZ + UI16_SZ + 2 + secs_msb + usecs_msb, trace_size); + + GET_VSZ_UI32(secs, c_p, secs_msb); + GET_VSZ_UI32(usecs, c_p, usecs_msb); + + INC_TIME(current_secs, current_usecs, secs, usecs); + + break; + } + + case ERTS_MT_STOP_BDY_TAG: + + op_p->type = EMTP_STOP; + + time_inc_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + NEED(UI16_SZ + 1 + time_inc_msb, trace_size); + + goto read_ending_time_inc; + + case ERTS_MT_EXIT_BDY_TAG: { + unsigned exit_status_msb; + + op_p->type = EMTP_EXIT; + + exit_status_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + ehdr >>= ERTS_MT_UI32_MSB_EHDR_FLD_SZ; + time_inc_msb = ehdr & ERTS_MT_UI32_MSB_EHDR_FLD_MSK; + + NEED(UI16_SZ + 2 + exit_status_msb + time_inc_msb, trace_size); + + GET_VSZ_UI32(op_p->u.exit_status, c_p, exit_status_msb); + + read_ending_time_inc: { + usgnd_int_32 secs, usecs, time_inc; + + GET_VSZ_UI32(time_inc, c_p, time_inc_msb); + + secs = ((time_inc >> ERTS_MT_TIME_INC_SECS_SHIFT) + & ERTS_MT_TIME_INC_SECS_MASK); + usecs = ((time_inc >> ERTS_MT_TIME_INC_USECS_SHIFT) + & ERTS_MT_TIME_INC_USECS_MASK); + + INC_TIME(current_secs, current_usecs, secs, usecs); + + op_p->time.secs = current_secs; + op_p->time.usecs = current_usecs; + +#if PRINT_PARSED_OP + print_op(op_p); +#endif + + op_p = (emtp_operation *) (((char *) op_p) + op_size); + statep->force_return = 1; + statep->progress = EMTP_PROGRESS_ENDED; + + tracep = c_p; + trace_size = trace_endp - tracep; + result = (trace_size + ? EMTP_END_OF_TRACE_GARBAGE_FOLLOWS + : EMTP_END_OF_TRACE); + goto restore_return; + } + } + + case ERTS_MT_X_BDY_TAG: { + /* X for extension + * ehdr contains total size of entry + * + * Entry should at least consist of tag (1 byte), + * total size (2 bytes) and subtag (1 byte). + */ + if (ehdr < UI8_SZ + UI16_SZ + UI8_SZ) + ERROR(EMTP_PARSE_ERROR); + NEED(ehdr, trace_size); + c_p = tracep + ehdr; /* No subtags known yet skip entry... */ + break; + } + + default: +#ifdef DEBUG + hexdump(c_p-2, trace_endp); +#endif + ERROR(EMTP_UNKNOWN_TAG_ERROR); + } + + tracep = c_p; + trace_size = trace_endp - tracep; + + if (op_p >= op_endp) { + statep->force_return = 1; + result = EMTP_ALL_OPS_FILLED; + goto restore_return; + } + } + + statep->known_need = 0; + statep->fetch_size = ERTS_MT_MAX_BODY_ENTRY_SIZE; + + result = EMTP_NEED_MORE_TRACE; + + restore_return: + *tracepp = tracep; + *op_pp = op_p; + statep->time.secs = current_secs; + statep->time.usecs = current_usecs; + + return result; +} + +static void +remove_unused_allocators(emtp_state *statep) +{ + emtp_allocator *allctr; + sgnd_int_32 i, j, k; + for (i = -1; i <= statep->max_block_type_ix; i++) { + if (statep->block_type[i]->valid) { + allctr = statep->allocator[statep->block_type[i]->allocator]; + if (allctr->name != unknown_allocator) + allctr->valid = 1; + } + } + for (i = -1; i <= statep->max_allocator_ix; i++) { + allctr = statep->allocator[i]; + if (allctr->valid && allctr->carrier.provider) { + for (j = 0; j < allctr->carrier.no_providers; j++) { + k = allctr->carrier.provider[j]; + if (statep->allocator[k]->name != unknown_allocator) + statep->allocator[k]->valid = 1; + } + } + } + for (i = -1; i <= statep->max_allocator_ix; i++) { + allctr = statep->allocator[i]; + if (!allctr->valid) { + allctr->flags = 0; + if (allctr->name != unknown_allocator) { + (*statep->free)((void *) allctr->name); + allctr->name = unknown_allocator; + } + allctr->carrier.no_providers = 0; + if (allctr->carrier.provider) { + (*statep->free)((void *) allctr->carrier.provider); + } + } + } +} + +static int +parse_header(emtp_state *statep, + usgnd_int_8 **tracepp, usgnd_int_8 *trace_endp) +{ + sgnd_int_32 trace_size; + usgnd_int_8 *tracep; + int i, result; + + tracep = *tracepp; + + switch (statep->progress) { + case EMTP_PROGRESS_PARSE_HDR_VSN: { + usgnd_int_32 start_word; + + trace_size = trace_endp - tracep; + NEED(3*UI32_SZ, trace_size); + + GET_UI32(start_word, tracep); + if (start_word != ERTS_MT_START_WORD) + return EMTP_NOT_AN_ERL_MTRACE_ERROR; + + GET_UI32(statep->version.major, tracep); + GET_UI32(statep->version.minor, tracep); + + statep->progress = EMTP_PROGRESS_PARSE_HDR_PROLOG; + } + case EMTP_PROGRESS_PARSE_HDR_PROLOG: + + trace_size = trace_endp - tracep; + + switch (statep->version.major) { + case 1: { + usgnd_int_32 hdr_sz; + NEED(2*UI32_SZ + 2*UI16_SZ, trace_size); + + GET_UI32(statep->flags, tracep); + GET_UI32(hdr_sz, tracep); /* ignore this; may contain garbage! */ + GET_UI16(statep->max_allocator_ix, tracep); + GET_UI16(statep->max_block_type_ix, tracep); + + statep->parse_body_func = parse_v1_body; + + break; + } + case 2: { + usgnd_int_32 giga_seconds; + usgnd_int_32 seconds; + usgnd_int_32 micro_seconds; + usgnd_int_8 len; + usgnd_int_8 *hdr_prolog_start; + usgnd_int_32 hdr_prolog_sz; + NEED(UI32_SZ, trace_size); + hdr_prolog_start = tracep; + GET_UI32(hdr_prolog_sz, tracep); + NEED(hdr_prolog_sz - UI32_SZ, trace_size); + + GET_UI32(statep->flags, tracep); + GET_UI16(statep->segment_ix, tracep); + GET_UI16(statep->max_allocator_ix, tracep); + GET_UI16(statep->max_block_type_ix, tracep); + + GET_UI32(giga_seconds, tracep); + GET_UI32(seconds, tracep); + GET_UI32(micro_seconds, tracep); + + set_start_time(statep, giga_seconds, seconds, micro_seconds); + + GET_UI8(len, tracep); + memcpy((void *) statep->nodename, (void *) tracep, (size_t) len); + statep->nodename[len] = '\0'; + tracep += len; + + GET_UI8(len, tracep); + memcpy((void *) statep->hostname, (void *) tracep, (size_t) len); + statep->hostname[len] = '\0'; + tracep += len; + + GET_UI8(len, tracep); + memcpy((void *) statep->pid, (void *) tracep, (size_t) len); + statep->pid[len] = '\0'; + tracep += len; + + + + /* Skip things in header prolog we dont know about */ + tracep = hdr_prolog_start + hdr_prolog_sz; + +#if EMTP_CAN_INLINE + statep->parse_body_func = NULL; +#else + statep->parse_body_func = parse_v2_body; +#endif + + break; + } + default: + return EMTP_NOT_SUPPORTED_MTRACE_VERSION_ERROR; + } + + statep->progress = EMTP_PROGRESS_ALLOC_HDR_INFO; + + case EMTP_PROGRESS_ALLOC_HDR_INFO: + + /* Allocator info */ + if (!statep->allocator) { + statep->allocator = (emtp_allocator **) + (*statep->alloc)((statep->max_allocator_ix + 2) + * sizeof(emtp_allocator *)); + if (!statep->allocator) + ERROR(EMTP_NO_MEMORY_ERROR); + statep->allocator++; + for (i = -1; i <= statep->max_allocator_ix; i++) + statep->allocator[i] = NULL; + for (i = -1; i <= statep->max_allocator_ix; i++) { + statep->allocator[i] = (emtp_allocator *) + (*statep->alloc)(sizeof(emtp_allocator)); + if (!statep->allocator[i]) + ERROR(EMTP_NO_MEMORY_ERROR); + statep->allocator[i]->valid = 0; + statep->allocator[i]->flags = 0; + statep->allocator[i]->name = unknown_allocator; + statep->allocator[i]->carrier.no_providers = 0; + statep->allocator[i]->carrier.provider = NULL; + } + + } + + /* Block type info */ + if (!statep->block_type) { + statep->block_type = (emtp_block_type **) + (*statep->alloc)((statep->max_block_type_ix + 2) + * sizeof(emtp_block_type *)); + if (!statep->block_type) + ERROR(EMTP_NO_MEMORY_ERROR); + statep->block_type++; + for (i = -1; i <= statep->max_block_type_ix; i++) + statep->block_type[i] = NULL; + for (i = -1; i <= statep->max_block_type_ix; i++) { + statep->block_type[i] = (emtp_block_type *) + (*statep->alloc)(sizeof(emtp_block_type)); + if (!statep->block_type[i]) + ERROR(EMTP_NO_MEMORY_ERROR); + statep->block_type[i]->valid = 0; + statep->block_type[i]->flags = 0; + statep->block_type[i]->name = unknown_block_type; + statep->block_type[i]->allocator = UNKNOWN_ALLOCATOR_IX; + } + + } + + statep->progress = EMTP_PROGRESS_PARSE_TAGGED_HDR; + + case EMTP_PROGRESS_PARSE_TAGGED_HDR: { + usgnd_int_8 *c_p = tracep; + trace_size = trace_endp - tracep; + + switch (statep->version.major) { + case 1: /* Version 1.X ---------------------------------------------- */ + + while (trace_size >= UI16_SZ) { + size_t str_len; + usgnd_int_16 ehdr; + + GET_UI16(ehdr, c_p); + + switch (ehdr & ERTS_MT_TAG_EHDR_FLD_MSK) { + case ERTS_MT_V1_ALLOCATOR_TAG: { + usgnd_int_16 a_ix; + + NEED_AT_LEAST(2*UI16_SZ + UI8_SZ, + ERTS_MT_MAX_HEADER_ENTRY_SIZE, + trace_size); + + GET_UI16(a_ix, c_p); + if (a_ix > statep->max_allocator_ix) + ERROR(EMTP_PARSE_ERROR); + + GET_UI8(str_len, c_p); + + NEED(2*UI16_SZ + UI8_SZ + str_len, trace_size); + + statep->allocator[a_ix]->name + = (char *) (*statep->alloc)(str_len + 1); + if (!statep->allocator[a_ix]->name) + ERROR(EMTP_NO_MEMORY_ERROR); + + memcpy((void *) statep->allocator[a_ix]->name, + (void *) c_p, + str_len); + c_p += str_len; + + statep->allocator[a_ix]->name[str_len] = '\0'; + break; + } + case ERTS_MT_V1_BLOCK_TYPE_TAG: { + usgnd_int_16 bt_ix, a_ix; + + NEED_AT_LEAST(2*UI16_SZ + UI8_SZ, + ERTS_MT_MAX_HEADER_ENTRY_SIZE, + trace_size); + + GET_UI16(bt_ix, c_p); + if (bt_ix > statep->max_block_type_ix) + ERROR(EMTP_PARSE_ERROR); + + GET_UI8(str_len, c_p); + + NEED(2*UI16_SZ + UI8_SZ + str_len + UI16_SZ, trace_size); + + statep->block_type[bt_ix]->name + = (char *) (*statep->alloc)(str_len + 1); + + if (!statep->block_type[bt_ix]->name) + ERROR(EMTP_NO_MEMORY_ERROR); + + memcpy((void *) statep->block_type[bt_ix]->name, + (void *) c_p, + str_len); + c_p += str_len; + + statep->block_type[bt_ix]->name[str_len] = '\0'; + + GET_UI16(a_ix, c_p); + + if (a_ix > statep->max_allocator_ix) + ERROR(EMTP_PARSE_ERROR); + + statep->block_type[bt_ix]->allocator = (sgnd_int_32) a_ix; + statep->block_type[bt_ix]->valid = 1; + break; + } + + case ERTS_MT_V1_ALLOC_TAG: + case ERTS_MT_V1_REALLOC_NPB_TAG: + case ERTS_MT_V1_REALLOC_MV_TAG: + case ERTS_MT_V1_REALLOC_NMV_TAG: + case ERTS_MT_V1_FREE_TAG: + case ERTS_MT_V1_TIME_INC_TAG: + case ERTS_MT_V1_STOP_TAG: + case ERTS_MT_V1_EXIT_TAG: + remove_unused_allocators(statep); + statep->progress = EMTP_PROGRESS_PARSE_BODY; + result = EMTP_HEADER_PARSED; + statep->force_return = 1; + goto restore_return; + default: + ERROR(EMTP_UNKNOWN_TAG_ERROR); + } + + tracep = c_p; + trace_size = trace_endp - tracep; + } + + statep->fetch_size = ERTS_MT_MAX_V1_HEADER_ENTRY_SIZE; + break; + + case 2: /* Version 2.X ---------------------------------------------- */ + + while (trace_size >= UI8_SZ + UI16_SZ) { + usgnd_int_16 entry_sz; + size_t str_len; + usgnd_int_8 tag; + + GET_UI8(tag, c_p); + GET_UI16(entry_sz, c_p); + NEED(entry_sz, trace_size); + + switch (tag) { + case ERTS_MT_ALLOCATOR_HDR_TAG: { + usgnd_int_8 crr_prvds; + usgnd_int_16 a_ix, aflgs; + + if (entry_sz + < UI8_SZ + 3*UI16_SZ + UI8_SZ + 0 + UI8_SZ) + ERROR(EMTP_PARSE_ERROR); + + GET_UI16(aflgs, c_p); + GET_UI16(a_ix, c_p); + if (a_ix > statep->max_allocator_ix) + ERROR(EMTP_PARSE_ERROR); + + if (aflgs & ERTS_MT_ALLCTR_USD_CRR_INFO) + statep->allocator[a_ix]->flags + |= EMTP_ALLOCATOR_FLAG_HAVE_USED_CARRIERS_INFO; + + GET_UI8(str_len, c_p); + + if (entry_sz + < UI8_SZ + 3*UI16_SZ + UI8_SZ + str_len + UI8_SZ) + ERROR(EMTP_PARSE_ERROR); + + statep->allocator[a_ix]->name + = (char *) (*statep->alloc)(str_len + 1); + if (!statep->allocator[a_ix]->name) + ERROR(EMTP_NO_MEMORY_ERROR); + + memcpy((void *) statep->allocator[a_ix]->name, + (void *) c_p, + str_len); + c_p += str_len; + + statep->allocator[a_ix]->name[str_len] = '\0'; + + GET_UI8(crr_prvds, c_p); + if (entry_sz < (UI8_SZ + + 3*UI16_SZ + + UI8_SZ + + str_len + + UI8_SZ + + crr_prvds*UI16_SZ)) + ERROR(EMTP_PARSE_ERROR); + statep->allocator[a_ix]->carrier.no_providers + = (usgnd_int_16) crr_prvds; + statep->allocator[a_ix]->carrier.provider = (usgnd_int_16 *) + (*statep->alloc)(crr_prvds*sizeof(usgnd_int_16)); + if (!statep->allocator[a_ix]->carrier.provider) + ERROR(EMTP_NO_MEMORY_ERROR); + for (i = 0; i < crr_prvds; i++) { + usgnd_int_16 cp_ix; + GET_UI16(cp_ix, c_p); + if (cp_ix > statep->max_allocator_ix) + ERROR(EMTP_PARSE_ERROR); + statep->allocator[a_ix]->carrier.provider[i] = cp_ix; + } + + break; + } + + case ERTS_MT_BLOCK_TYPE_HDR_TAG: { + usgnd_int_16 bt_ix, a_ix, btflgs; + + if (entry_sz + < UI8_SZ + 3*UI16_SZ + UI8_SZ + 0 + UI16_SZ) + ERROR(EMTP_PARSE_ERROR); + + GET_UI16(btflgs, c_p); + GET_UI16(bt_ix, c_p); + if (bt_ix > statep->max_block_type_ix) + ERROR(EMTP_PARSE_ERROR); + + GET_UI8(str_len, c_p); + + if (entry_sz + < UI8_SZ + 3*UI16_SZ + UI8_SZ + str_len + UI16_SZ) + ERROR(EMTP_PARSE_ERROR); + + statep->block_type[bt_ix]->name + = (char *) (*statep->alloc)(str_len + 1); + + if (!statep->block_type[bt_ix]->name) + ERROR(EMTP_NO_MEMORY_ERROR); + + memcpy((void *) statep->block_type[bt_ix]->name, + (void *) c_p, + str_len); + c_p += str_len; + + statep->block_type[bt_ix]->name[str_len] = '\0'; + + GET_UI16(a_ix, c_p); + + if (a_ix > statep->max_allocator_ix) + ERROR(EMTP_PARSE_ERROR); + + statep->block_type[bt_ix]->allocator = (sgnd_int_32) a_ix; + statep->block_type[bt_ix]->valid = 1; + break; + } + + case ERTS_MT_END_OF_HDR_TAG: + tracep = tracep + ((size_t) entry_sz); + remove_unused_allocators(statep); + statep->progress = EMTP_PROGRESS_PARSE_BODY; + result = EMTP_HEADER_PARSED; + statep->force_return = 1; + goto restore_return; + + default: + /* Skip tags that we do not understand. */ + break; + } + + tracep = tracep + ((size_t) entry_sz); + ASSERT(c_p <= tracep); + c_p = tracep; + trace_size = trace_endp - tracep; + } + + statep->fetch_size = UI8_SZ + UI16_SZ; + break; + default: /* Not supported version --------------------------------- */ + ASSERT(0); + } + + break; + } + default: + ASSERT(0); + } + + statep->known_need = 0; + result = EMTP_NEED_MORE_TRACE; + + restore_return: + + *tracepp = tracep; + + return result; + +} + + +int +emtp_parse(emtp_state *statep, + usgnd_int_8 **tracepp, size_t *trace_lenp, + emtp_operation *op_start, size_t op_size, size_t *op_lenp) +{ + int result, have_all_in_overflow; + usgnd_int_8 *tracep, *trace_endp; + emtp_operation *op_p, *op_endp; + + + have_all_in_overflow = 0; + + op_p = op_start; + + if (!statep) + return EMTP_NO_MEMORY_ERROR; + + if (!tracepp || !trace_lenp) + return EMTP_NO_TRACE_ERROR; + + if (*trace_lenp <= 0) { + if (op_lenp) + *op_lenp = 0; + return EMTP_NEED_MORE_TRACE; + } + + statep->force_return = 0; + + if (statep->overflow_size) { /* Overflow from prevoius parse */ + sgnd_int_32 tsz; + sgnd_int_32 sz; + + fetch_for_overflow: + sz = statep->fetch_size - statep->overflow_size; + ASSERT(sz > 0); + + if (*trace_lenp <= sz) { + have_all_in_overflow = 1; + sz = *trace_lenp; + } + + if (sz > statep->overflow_buf_size) { + size_t buf_sz = statep->overflow_size + sz; + void *buf = (*statep->realloc)((void *) statep->overflow, buf_sz); + if (!buf) + return EMTP_NO_MEMORY_ERROR; + statep->overflow_buf_size = buf_sz; + statep->overflow = (usgnd_int_8 *) buf; + } + + memcpy((void *) (statep->overflow + statep->overflow_size), + (void *) *tracepp, + sz); + + tsz = statep->overflow_size + sz; + + tracep = statep->overflow; + trace_endp = statep->overflow + tsz; + + if (tsz < statep->fetch_size && statep->known_need) { + ASSERT(have_all_in_overflow); + statep->overflow_size = tsz; + op_endp = NULL; + result = EMTP_NEED_MORE_TRACE; + goto restore_return; + } + } + else { + tracep = *tracepp; + trace_endp = tracep + *trace_lenp; + } + + if (statep->progress == EMTP_PROGRESS_PARSE_BODY) { + +#if !HAVE_INT_64 + if (statep->flags & ERTS_MT_64_BIT_FLAG) + return EMTP_NOT_SUPPORTED_64_BITS_TRACE_ERROR; +#endif + + if (op_size < sizeof(emtp_operation)) + return EMTP_BAD_OP_SIZE_ERROR; + if (!op_start || !op_lenp || *op_lenp < 1) + return EMTP_NO_OPERATIONS_ERROR; + op_endp = (emtp_operation *) (((char *) op_start) + (*op_lenp)*op_size); + + restart_parse_body: +#if EMTP_CAN_INLINE + if (statep->parse_body_func) +#endif + result = (*statep->parse_body_func)(statep, + &tracep, trace_endp, + &op_p, op_endp, op_size); +#if EMTP_CAN_INLINE + else + result = parse_v2_body(statep, + &tracep, trace_endp, + &op_p, op_endp, op_size); +#endif + } + else { + restart_parse_header: + op_endp = NULL; + if (statep->progress == EMTP_PROGRESS_ENDED) { + result = EMTP_END_OF_TRACE; + goto restore_return; + } + result = parse_header(statep, &tracep, trace_endp); + } + + /* Check overflow */ + if (statep->overflow_size) { + if (tracep == statep->overflow) { + /* Nothing parsed, i.e. less new input than 1 entry :( */ + if (!have_all_in_overflow) + goto fetch_for_overflow; + statep->overflow_size = trace_endp - tracep; + trace_endp = tracep = *tracepp + *trace_lenp; + } + else { + size_t sz = tracep - (statep->overflow + statep->overflow_size); + + ASSERT(sz > 0); + + statep->overflow_size = 0; + + tracep = *tracepp + sz; + trace_endp = *tracepp + *trace_lenp; + ASSERT(trace_endp >= tracep); + if (!statep->force_return && (trace_endp - tracep)) { + if (statep->progress == EMTP_PROGRESS_PARSE_BODY) + goto restart_parse_body; + else + goto restart_parse_header; + } + /* else: got it all in the overflow buffer */ + } + } + else { + size_t sz = trace_endp - tracep; + if (!statep->force_return && sz) { + if (sz >= statep->fetch_size) { + ASSERT(0); + ERROR(EMTP_PARSE_ERROR); + } + if (sz > statep->overflow_buf_size) { + (*statep->free)((void *) statep->overflow); + statep->overflow = (usgnd_int_8 *) (*statep->alloc)(sz); + if (!statep->overflow) { + statep->overflow_buf_size = 0; + return EMTP_NO_MEMORY_ERROR; + } + statep->overflow_buf_size = sz; + } + memcpy((void *) statep->overflow, tracep, sz); + statep->overflow_size = sz; + ASSERT(tracep + sz == trace_endp); + tracep = trace_endp; + } + } + + restore_return: + ASSERT(trace_endp >= tracep); + + *tracepp = tracep; + *trace_lenp = trace_endp - tracep; + + if (op_lenp && op_size > 0) + *op_lenp = (int) (((char *) op_p) - ((char *) op_start))/op_size; + + return result; +} + +#ifdef DEBUG +static void +hexdump(void *start, void *end) +{ + unsigned char *p = (unsigned char *) start; + + fprintf(stderr, "hexdump: "); + while ((void *) p < end) { + fprintf(stderr, "%x", (unsigned) *p); + p++; + } + fprintf(stderr, "\n"); +} + +#if PRINT_PARSED_OP +static void +print_op(emtp_operation *op_p) +{ + switch (op_p->type) { + case EMTP_ALLOC: + fprintf(stderr, + "alloc: " + "type=%" USGND_INT_16_FSTR ", " + "ptr=%" USGND_INT_MAX_FSTR ", " + "sz=%" USGND_INT_MAX_FSTR ", " + "(secs=%" USGND_INT_32_FSTR ", usecs=%" USGND_INT_32_FSTR ")" + "\n", + op_p->u.block.type, + op_p->u.block.new_ptr, + op_p->u.block.new_size, + op_p->time.secs, + op_p->time.usecs); + break; + case EMTP_REALLOC: + fprintf(stderr, + "realloc: " + "type=%" USGND_INT_16_FSTR ", " + "ptr=%" USGND_INT_MAX_FSTR ", " + "prev_ptr=%" USGND_INT_MAX_FSTR ", " + "sz=%" USGND_INT_MAX_FSTR ", " + "(secs=%" USGND_INT_32_FSTR ", usecs=%" USGND_INT_32_FSTR ")" + "\n", + op_p->u.block.type, + op_p->u.block.new_ptr, + op_p->u.block.prev_ptr, + op_p->u.block.new_size, + op_p->time.secs, + op_p->time.usecs); + break; + case EMTP_FREE: + fprintf(stderr, + "free: " + "type=%" USGND_INT_16_FSTR ", " + "ptr=%" USGND_INT_MAX_FSTR ", " + "(secs=%" USGND_INT_32_FSTR ", usecs=%" USGND_INT_32_FSTR ")" + "\n", + op_p->u.block.type, + op_p->u.block.prev_ptr, + op_p->time.secs, + op_p->time.usecs); + break; + case EMTP_CARRIER_ALLOC: + fprintf(stderr, + "carrier_alloc: " + "type=%" USGND_INT_16_FSTR ", " + "carrier_type=%" USGND_INT_16_FSTR ", " + "ptr=%" USGND_INT_MAX_FSTR ", " + "sz=%" USGND_INT_MAX_FSTR ", " + "(secs=%" USGND_INT_32_FSTR ", usecs=%" USGND_INT_32_FSTR ")" + "\n", + op_p->u.block.type, + op_p->u.block.carrier_type, + op_p->u.block.new_ptr, + op_p->u.block.new_size, + op_p->time.secs, + op_p->time.usecs); + break; + case EMTP_CARRIER_REALLOC: + fprintf(stderr, + "carrier_realloc: " + "type=%" USGND_INT_16_FSTR ", " + "carrier_type=%" USGND_INT_16_FSTR ", " + "ptr=%" USGND_INT_MAX_FSTR ", " + "prev_ptr=%" USGND_INT_MAX_FSTR ", " + "sz=%" USGND_INT_MAX_FSTR ", " + "(secs=%" USGND_INT_32_FSTR ", usecs=%" USGND_INT_32_FSTR ")" + "\n", + op_p->u.block.type, + op_p->u.block.carrier_type, + op_p->u.block.new_ptr, + op_p->u.block.prev_ptr, + op_p->u.block.new_size, + op_p->time.secs, + op_p->time.usecs); + break; + case EMTP_CARRIER_FREE: + fprintf(stderr, + "carrier_free: " + "type=%" USGND_INT_16_FSTR ", " + "carrier_type=%" USGND_INT_16_FSTR ", " + "ptr=%" USGND_INT_MAX_FSTR ", " + "(secs=%" USGND_INT_32_FSTR ", usecs=%" USGND_INT_32_FSTR ")" + "\n", + op_p->u.block.type, + op_p->u.block.carrier_type, + op_p->u.block.prev_ptr, + op_p->time.secs, + op_p->time.usecs); + break; + case EMTP_STOP: + fprintf(stderr, + "stop: " + "(secs=%" USGND_INT_32_FSTR ", usecs=%" USGND_INT_32_FSTR ")" + "\n", + op_p->time.secs, + op_p->time.usecs); + break; + case EMTP_EXIT: + fprintf(stderr, + "exit: " + "status=%" USGND_INT_32_FSTR ", " + "(secs=%" USGND_INT_32_FSTR ", usecs=%" USGND_INT_32_FSTR ")" + "\n", + op_p->u.exit_status, + op_p->time.secs, + op_p->time.usecs); + break; + default: + fprintf(stderr, "Unknown op type: %d\n", op_p->type); + break; + } +} + +#endif +#endif diff --git a/erts/lib_src/common/erl_misc_utils.c b/erts/lib_src/common/erl_misc_utils.c new file mode 100644 index 0000000000..9c25d33a3c --- /dev/null +++ b/erts/lib_src/common/erl_misc_utils.c @@ -0,0 +1,967 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 2006-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% + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "erl_misc_utils.h" + +#if defined(__WIN32__) +# include <windows.h> +#elif defined(VXWORKS) +# include <selectLib.h> +#else /* UNIX */ +# include <stdio.h> +# include <sys/types.h> +# include <sys/param.h> +# include <limits.h> +# include <dirent.h> +# include <sys/stat.h> +# include <fcntl.h> +# ifdef SYS_SELECT_H +# include <sys/select.h> +# endif +# if TIME_WITH_SYS_TIME +# include <sys/time.h> +# include <time.h> +# else +# if HAVE_SYS_TIME_H +# include <sys/time.h> +# else +# include <time.h> +# endif +# endif +# include <string.h> +# ifdef HAVE_UNISTD_H +# include <unistd.h> +# endif +# if (defined(NO_SYSCONF) || !defined(_SC_NPROCESSORS_CONF)) +# ifdef HAVE_SYS_SYSCTL_H +# include <sys/sysctl.h> +# endif +# endif +#endif + +#ifdef HAVE_SCHED_xETAFFINITY +# include <sched.h> +#endif +#ifdef HAVE_PSET_INFO +# include <sys/pset.h> +#endif +#ifdef HAVE_PROCESSOR_BIND +# include <sys/processor.h> +# include <sys/procset.h> +#endif + +#include <stdlib.h> +#ifdef HAVE_LIMITS_H +#include <limits.h> +#endif + +#ifdef __linux__ +# define ERTS_SYS_NODE_PATH "/sys/devices/system/node" +# define ERTS_SYS_CPU_PATH "/sys/devices/system/cpu" +#endif + +static int read_topology(erts_cpu_info_t *cpuinfo); + +int +erts_milli_sleep(long ms) +{ + if (ms > 0) { +#ifdef __WIN32__ + Sleep((DWORD) ms); +#else + struct timeval tv; + tv.tv_sec = ms / 1000; + tv.tv_usec = (ms % 1000) * 1000; + if (select(0, NULL, NULL, NULL, &tv) < 0) + return errno == EINTR ? 1 : -1; +#endif + } + return 0; +} + +struct erts_cpu_info_t_ { + int configured; + int online; + int available; + int topology_size; + erts_cpu_topology_t *topology; +#if defined(HAVE_SCHED_xETAFFINITY) + char *affinity_str; + char affinity_str_buf[CPU_SETSIZE/4+2]; + cpu_set_t cpuset; + pid_t pid; +#elif defined(HAVE_PSET_INFO) + processorid_t *cpuids; +#endif +}; + +erts_cpu_info_t * +erts_cpu_info_create(void) +{ + erts_cpu_info_t *cpuinfo = malloc(sizeof(erts_cpu_info_t)); + if (!cpuinfo) + return NULL; +#if defined(HAVE_SCHED_xETAFFINITY) + cpuinfo->affinity_str = NULL; + cpuinfo->pid = getpid(); +#elif defined(HAVE_PSET_INFO) + cpuinfo->cpuids = NULL; +#endif + cpuinfo->topology_size = 0; + cpuinfo->topology = NULL; + erts_cpu_info_update(cpuinfo); + return cpuinfo; +} + +void +erts_cpu_info_destroy(erts_cpu_info_t *cpuinfo) +{ + if (cpuinfo) { + cpuinfo->configured = 0; + cpuinfo->online = 0; + cpuinfo->available = 0; +#ifdef HAVE_PSET_INFO + if (cpuinfo->cpuids) + free(cpuinfo->cpuids); +#endif + cpuinfo->topology_size = 0; + if (cpuinfo->topology) { + cpuinfo->topology = NULL; + free(cpuinfo->topology); + } + free(cpuinfo); + } +} + +void +erts_cpu_info_update(erts_cpu_info_t *cpuinfo) +{ + cpuinfo->configured = 0; + cpuinfo->online = 0; + cpuinfo->available = 0; + +#ifdef __WIN32__ + { + SYSTEM_INFO sys_info; + GetSystemInfo(&sys_info); + cpuinfo->configured = (int) sys_info.dwNumberOfProcessors; + + } +#elif !defined(NO_SYSCONF) && (defined(_SC_NPROCESSORS_CONF) \ + || defined(_SC_NPROCESSORS_ONLN)) +#ifdef _SC_NPROCESSORS_CONF + cpuinfo->configured = (int) sysconf(_SC_NPROCESSORS_CONF); + if (cpuinfo->configured < 0) + cpuinfo->configured = 0; +#endif +#ifdef _SC_NPROCESSORS_ONLN + cpuinfo->online = (int) sysconf(_SC_NPROCESSORS_ONLN); + if (cpuinfo->online < 0) + cpuinfo->online = 0; +#endif +#elif defined(HAVE_SYS_SYSCTL_H) && defined(CTL_HW) && (defined(HW_NCPU) \ + || defined(HW_AVAILCPU)) + { + int mib[2]; + size_t len; + +#ifdef HW_NCPU + len = sizeof(int); + mib[0] = CTL_HW; + mib[1] = HW_NCPU; + if (sysctl(&mib[0], 2, &cpuinfo->configured, &len, NULL, 0) < 0) + cpuinfo->configured = 0; +#endif +#ifdef HW_AVAILCPU + len = sizeof(int); + mib[0] = CTL_HW; + mib[1] = HW_AVAILCPU; + if (sysctl(&mib[0], 2, &cpuinfo->online, &len, NULL, 0) < 0) + cpuinfo->online = 0; +#endif + } +#endif + + if (cpuinfo->online > cpuinfo->configured) + cpuinfo->online = cpuinfo->configured; + +#ifdef HAVE_SCHED_xETAFFINITY + if (sched_getaffinity(cpuinfo->pid, sizeof(cpu_set_t), &cpuinfo->cpuset) == 0) { + int i, c, cn, si; + c = cn = 0; + si = sizeof(cpuinfo->affinity_str_buf) - 1; + cpuinfo->affinity_str_buf[si] = '\0'; + for (i = 0; i < CPU_SETSIZE; i++) { + if (CPU_ISSET(i, &cpuinfo->cpuset)) { + c |= 1 << cn; + cpuinfo->available++; + } + cn++; + if (cn == 4) { + cpuinfo->affinity_str_buf[--si] = (c < 10 + ? '0' + c + : 'A' + c - 10); + c = cn = 0; + } + } + if (c) + cpuinfo->affinity_str_buf[--si] = (c < 10 + ? '0' + c + : 'A' + c - 10); + while (cpuinfo->affinity_str_buf[si] == '0') + si++; + cpuinfo->affinity_str = &cpuinfo->affinity_str_buf[si]; + } +#elif defined(HAVE_PSET_INFO) + { + uint_t numcpus = cpuinfo->configured; + if (cpuinfo->cpuids) + free(cpuinfo->cpuids); + cpuinfo->cpuids = malloc(sizeof(processorid_t)*numcpus); + if (cpuinfo->cpuids) { + if (pset_info(PS_MYID, NULL, &numcpus, &cpuinfo->cpuids) == 0) + cpuinfo->available = (int) numcpus; + if (cpuinfo->available < 0) { + free(cpuinfo->cpuid); + cpuinfo->available = 0; + } + } + } +#endif + + if (cpuinfo->available > cpuinfo->online) + cpuinfo->available = cpuinfo->online; + + read_topology(cpuinfo); + +} + +int +erts_get_cpu_configured(erts_cpu_info_t *cpuinfo) +{ + if (!cpuinfo) + return -EINVAL; + if (cpuinfo->configured <= 0) + return -ENOTSUP; + return cpuinfo->configured; +} + +int +erts_get_cpu_online(erts_cpu_info_t *cpuinfo) +{ + if (!cpuinfo) + return -EINVAL; + if (cpuinfo->online <= 0) + return -ENOTSUP; + return cpuinfo->online; +} + +int +erts_get_cpu_available(erts_cpu_info_t *cpuinfo) +{ + if (!cpuinfo) + return -EINVAL; + if (cpuinfo->available <= 0) + return -ENOTSUP; + return cpuinfo->available; +} + +char * +erts_get_unbind_from_cpu_str(erts_cpu_info_t *cpuinfo) +{ +#if defined(HAVE_SCHED_xETAFFINITY) + if (!cpuinfo) + return "false"; + return cpuinfo->affinity_str; +#else + return "true"; +#endif +} + +int +erts_get_available_cpu(erts_cpu_info_t *cpuinfo, int no) +{ + if (!cpuinfo || no < 1 || cpuinfo->available < no) + return -EINVAL; +#ifdef HAVE_SCHED_xETAFFINITY + { + cpu_set_t *allowed = &cpuinfo->cpuset; + int ix, n; + for (ix = 0, n = 1; ix < CPU_SETSIZE; ix++) { + if (CPU_ISSET(ix, allowed)) { + if (no == n) + return ix; + n++; + } + } + } + return -EINVAL; +#elif defined(HAVE_PROCESSOR_BIND) +#if defined(HAVE_PSET_INFO) + return (int) cpuinfo->cpuids[no-1]; +#elif defined(HAVE_KSTAT) + if (cpuinfo->topology && cpuinfo->online <= no) { + /* May not be available, but this is the best we can do */ + return cpuinfo->topology[no-1].logical; + } + return -EINVAL; +#endif +#else + return -ENOTSUP; +#endif +} + +int +erts_is_cpu_available(erts_cpu_info_t *cpuinfo, int id) +{ + if (cpuinfo && 0 <= id) { +#ifdef HAVE_SCHED_xETAFFINITY + if (id <= CPU_SETSIZE) + return CPU_ISSET(id, &cpuinfo->cpuset); +#elif defined(HAVE_PROCESSOR_BIND) + int no; +#if defined(HAVE_PSET_INFO) + for (no = 0; no < cpuinfo->available; no++) + if (id == (int) cpuinfo->cpuids[no]) + return 1; +#elif defined(HAVE_KSTAT) + if (cpuinfo->topology) { + for (no = 0; no < cpuinfo->online; no++) { + if (id == (int) cpuinfo->topology[no].logical) { + /* May not be available, but this is the best we can do... */ + return 1; + } + } + } +#endif +#endif + } + return 0; +} + +int +erts_get_cpu_topology_size(erts_cpu_info_t *cpuinfo) +{ + return cpuinfo->topology_size; +} + +int +erts_get_cpu_topology(erts_cpu_info_t *cpuinfo, + erts_cpu_topology_t *topology) +{ + if (!cpuinfo->topology) + return 0; + memcpy((void *) topology, + (void *) cpuinfo->topology, + cpuinfo->configured*sizeof(erts_cpu_topology_t)); + return cpuinfo->configured; +} + +int +erts_bind_to_cpu(erts_cpu_info_t *cpuinfo, int cpu) +{ + /* + * Caller can test for available functionality by + * passing a negative cpu id. If functionality is + * available -EINVAL is returned; otherwise, + * -ENOTSUP. + */ + if (!cpuinfo) + return -EINVAL; +#ifdef HAVE_SCHED_xETAFFINITY + { + cpu_set_t bind_set; + if (cpu < 0) + return -EINVAL; + if (!CPU_ISSET(cpu, &cpuinfo->cpuset)) + return -EINVAL; + + CPU_ZERO(&bind_set); + CPU_SET(cpu, &bind_set); + if (sched_setaffinity(0, sizeof(cpu_set_t), &bind_set) != 0) + return -errno; + return 0; + } +#elif defined(HAVE_PROCESSOR_BIND) + if (cpu < 0) + return -EINVAL; + if (processor_bind(P_LWPID, P_MYID, (processorid_t) cpu, NULL) != 0) + return -errno; + return 0; +#else + return -ENOTSUP; +#endif +} + +int +erts_unbind_from_cpu(erts_cpu_info_t *cpuinfo) +{ + if (!cpuinfo) + return -EINVAL; +#if defined(HAVE_SCHED_xETAFFINITY) + if (sched_setaffinity(0, sizeof(cpu_set_t), &cpuinfo->cpuset) != 0) + return -errno; + return 0; +#elif defined(HAVE_PROCESSOR_BIND) + if (processor_bind(P_LWPID, P_MYID, PBIND_NONE, NULL) != 0) + return -errno; + return 0; +#else + return -ENOTSUP; +#endif +} + +int +erts_unbind_from_cpu_str(char *str) +{ +#if defined(HAVE_SCHED_xETAFFINITY) + char *c = str; + int cpus = 0; + int shft = 0; + cpu_set_t cpuset; + + CPU_ZERO(&cpuset); + + if (!c) + return -EINVAL; + + while (*c) + c++; + + while (c != str) { + int shft2; + int mask = 0; + c--; + switch (*c) { + case '0': mask = 0; break; + case '1': mask = 1; break; + case '2': mask = 2; break; + case '3': mask = 3; break; + case '4': mask = 4; break; + case '5': mask = 5; break; + case '6': mask = 6; break; + case '7': mask = 7; break; + case '8': mask = 8; break; + case '9': mask = 9; break; + case 'A': case 'a': mask = 10; break; + case 'B': case 'b': mask = 11; break; + case 'C': case 'c': mask = 12; break; + case 'D': case 'd': mask = 13; break; + case 'E': case 'e': mask = 14; break; + case 'F': case 'f': mask = 15; break; + default: return -EINVAL; + } + for (shft2 = 0; shft2 < 4; shft2++) { + if (mask & (1 << shft2)) { + int cpu = shft + shft2; + if (cpu >= CPU_SETSIZE) + return -EINVAL; + cpus++; + CPU_SET(cpu, &cpuset); + } + } + shft += 4; + } + + if (!cpus) + return -EINVAL; + + if (sched_setaffinity(0, sizeof(cpu_set_t), &cpuset) != 0) + return -errno; + return 0; +#elif defined(HAVE_PROCESSOR_BIND) + if (processor_bind(P_LWPID, P_MYID, PBIND_NONE, NULL) != 0) + return -errno; + return 0; +#else + return -ENOTSUP; +#endif +} + + +static int +pn_cmp(const void *vx, const void *vy) +{ + erts_cpu_topology_t *x = (erts_cpu_topology_t *) vx; + erts_cpu_topology_t *y = (erts_cpu_topology_t *) vy; + + if (x->processor != y->processor) + return x->processor - y->processor; + if (x->node != y->node) + return x->node - y->node; + if (x->processor_node != y->processor_node) + return x->processor_node - y->processor_node; + if (x->core != y->core) + return x->core - y->core; + if (x->thread != y->thread) + return x->thread - y->thread; + if (x->logical != y->logical) + return x->logical - y->logical; + return 0; +} + +static int +cpu_cmp(const void *vx, const void *vy) +{ + erts_cpu_topology_t *x = (erts_cpu_topology_t *) vx; + erts_cpu_topology_t *y = (erts_cpu_topology_t *) vy; + + if (x->node != y->node) + return x->node - y->node; + if (x->processor != y->processor) + return x->processor - y->processor; + if (x->processor_node != y->processor_node) + return x->processor_node - y->processor_node; + if (x->core != y->core) + return x->core - y->core; + if (x->thread != y->thread) + return x->thread - y->thread; + if (x->logical != y->logical) + return x->logical - y->logical; + return 0; +} + +#ifdef __linux__ + +static int +read_file(char *path, char *buf, int size) +{ + int ix = 0; + ssize_t sz = size-1; + int fd = open(path, O_RDONLY); + if (fd < 0) + goto error; + while (size > ix) { + sz = read(fd, &buf[ix], size - ix); + if (sz <= 0) { + if (sz == 0) + break; + if (errno == EINTR) + continue; + goto error; + } + ix += sz; + } + buf[ix] = '\0'; + close(fd); + return ix; + + error: { + int saved_errno = errno; + if (fd >= 0) + close(fd); + if (saved_errno) + return -saved_errno; + else + return -EINVAL; + } +} + +static int +read_topology(erts_cpu_info_t *cpuinfo) +{ + char npath[MAXPATHLEN]; + char cpath[MAXPATHLEN]; + char tpath[MAXPATHLEN]; + char fpath[MAXPATHLEN]; + DIR *ndir = NULL; + DIR *cdir = NULL; + struct dirent *nde; + int ix; + int res = 0; + int got_nodes = 0; + int no_nodes = 0; + + errno = 0; + + if (cpuinfo->topology) + free(cpuinfo->topology); + + if (cpuinfo->configured < 1) + goto error; + + cpuinfo->topology = malloc(sizeof(erts_cpu_topology_t) + * cpuinfo->configured); + if (!cpuinfo) + goto error; + + for (ix = 0; ix < cpuinfo->configured; ix++) { + cpuinfo->topology[ix].node = -1; + cpuinfo->topology[ix].processor = -1; + cpuinfo->topology[ix].processor_node = -1; + cpuinfo->topology[ix].core = -1; + cpuinfo->topology[ix].thread = -1; + cpuinfo->topology[ix].logical = -1; + } + + ix = -1; + + if (realpath(ERTS_SYS_NODE_PATH, npath)) { + got_nodes = 1; + ndir = opendir(npath); + } + + do { + int node_id = -1; + + if (!got_nodes) { + if (!realpath(ERTS_SYS_CPU_PATH, cpath)) + goto error; + } + else { + + nde = readdir(ndir); + + if (!nde) + break; + + if (sscanf(nde->d_name, "node%d", &node_id) != 1) + continue; + + no_nodes++; + + sprintf(tpath, "%s/node%d", npath, node_id); + + if (!realpath(tpath, cpath)) + goto error; + } + + cdir = opendir(cpath); + if (!cdir) + goto error; + + while (1) { + int cpu_id; + struct dirent *cde = readdir(cdir); + if (!cde) { + closedir(cdir); + cdir = NULL; + break; + } + if (sscanf(cde->d_name, "cpu%d", &cpu_id) == 1) { + char buf[50]; /* Much more than enough for an integer */ + int processor_id, core_id; + sprintf(tpath, "%s/cpu%d/topology/physical_package_id", + cpath, cpu_id); + if (!realpath(tpath, fpath)) + continue; + if (read_file(fpath, buf, sizeof(buf)) <= 0) + continue; + if (sscanf(buf, "%d", &processor_id) != 1) + continue; + sprintf(tpath, "%s/cpu%d/topology/core_id", + cpath, cpu_id); + if (!realpath(tpath, fpath)) + continue; + if (read_file(fpath, buf, sizeof(buf)) <= 0) + continue; + if (sscanf(buf, "%d", &core_id) != 1) + continue; + + /* + * We now know node id, processor id, and + * core id of the logical processor with + * the cpu id 'cpu_id'. + */ + ix++; + cpuinfo->topology[ix].node = node_id; + cpuinfo->topology[ix].processor = processor_id; + cpuinfo->topology[ix].processor_node = -1; /* Fixed later */ + cpuinfo->topology[ix].core = core_id; + cpuinfo->topology[ix].thread = 0; /* we'll numerate later */ + cpuinfo->topology[ix].logical = cpu_id; + } + } + } while (got_nodes); + + res = ix+1; + + if (!res || res < cpuinfo->online) + res = 0; + else { + erts_cpu_topology_t *prev, *this, *last; + + cpuinfo->topology_size = res; + + if (cpuinfo->topology_size != cpuinfo->configured) { + void *t = realloc(cpuinfo->topology, (sizeof(erts_cpu_topology_t) + * cpuinfo->topology_size)); + if (t) + cpuinfo->topology = t; + } + + if (no_nodes > 1) { + int processor = -1; + int processor_node = 0; + int node = -1; + + qsort(cpuinfo->topology, + cpuinfo->topology_size, + sizeof(erts_cpu_topology_t), + pn_cmp); + + prev = NULL; + this = &cpuinfo->topology[0]; + last = &cpuinfo->topology[cpuinfo->configured-1]; + while (1) { + if (processor == this->processor) { + if (node != this->node) + processor_node = 1; + } + else { + if (processor_node) { + make_processor_node: + while (prev->processor == processor) { + prev->processor_node = prev->node; + prev->node = -1; + if (prev == &cpuinfo->topology[0]) + break; + prev--; + } + processor_node = 0; + } + processor = this->processor; + node = this->node; + } + if (this == last) { + if (processor_node) { + prev = this; + goto make_processor_node; + } + break; + } + prev = this++; + } + } + + qsort(cpuinfo->topology, + cpuinfo->topology_size, + sizeof(erts_cpu_topology_t), + cpu_cmp); + + this = &cpuinfo->topology[0]; + this->thread = 0; + + if (res > 1) { + prev = this++; + last = &cpuinfo->topology[cpuinfo->configured-1]; + + while (1) { + this->thread = ((this->node == prev->node + && this->processor == prev->processor + && this->processor_node == prev->processor_node + && this->core == prev->core) + ? prev->thread + 1 + : 0); + if (this == last) + break; + prev = this++; + } + } + } + + error: + + if (res == 0) { + cpuinfo->topology_size = 0; + if (cpuinfo->topology) { + free(cpuinfo->topology); + cpuinfo->topology = NULL; + } + if (errno) + res = -errno; + else + res = -EINVAL; + } + + if (ndir) + closedir(ndir); + if (cdir) + closedir(cdir); + + return res; +} + +#elif defined(HAVE_KSTAT) /* SunOS kstat */ + +#include <kstat.h> + +static int +data_lookup_int(kstat_t *ks, char *what) +{ + int res; + kstat_named_t *ks_n; + + ks_n = kstat_data_lookup(ks, what); + if (!ks_n) + return 0; + + switch (ks_n->data_type) { + case KSTAT_DATA_CHAR: + res = atoi(ks_n->value.c); + break; + case KSTAT_DATA_INT32: + res = (int) ks_n->value.i32; + break; + case KSTAT_DATA_UINT32: + res = (int) ks_n->value.ui32; + break; + case KSTAT_DATA_INT64: + res = (int) ks_n->value.i64; + break; + case KSTAT_DATA_UINT64: + res = (int) ks_n->value.ui64; + break; + default: + res = 0; + break; + } + return res; +} + +static int +read_topology(erts_cpu_info_t *cpuinfo) +{ + int res = 0; + int ix; + kstat_ctl_t *ks_ctl; + kstat_t *ks; + + errno = 0; + + if (cpuinfo->topology) + free(cpuinfo->topology); + + if (cpuinfo->configured < 1) + goto error; + + cpuinfo->topology = malloc(sizeof(erts_cpu_topology_t) + * cpuinfo->configured); + if (!cpuinfo) + goto error; + + for (ix = 0; ix < cpuinfo->configured; ix++) { + cpuinfo->topology[ix].node = -1; + cpuinfo->topology[ix].processor = -1; + cpuinfo->topology[ix].processor_node = -1; + cpuinfo->topology[ix].core = -1; + cpuinfo->topology[ix].thread = -1; + cpuinfo->topology[ix].logical = -1; + } + + ks_ctl = kstat_open(); + if (!ks_ctl) + goto error; + + ix = 0; + for (ks = ks_ctl->kc_chain; ks; ks = ks->ks_next) { + if (strcmp("cpu_info", ks->ks_module) == 0) { + kstat_read(ks_ctl, ks, NULL); + if (ks->ks_type == KSTAT_TYPE_NAMED) { + /* + * Don't know how to figure numa nodes out; + * hope there is none... + */ + cpuinfo->topology[ix].node = -1; + cpuinfo->topology[ix].processor = data_lookup_int(ks,"chip_id"); + cpuinfo->topology[ix].processor_node = -1; + cpuinfo->topology[ix].core = data_lookup_int(ks, "core_id"); + cpuinfo->topology[ix].thread = 0; /* we'll numerate later */ + cpuinfo->topology[ix].logical = ks->ks_instance; + if (++ix == cpuinfo->configured) + break; + } + } + } + + kstat_close(ks_ctl); + + res = ix; + + if (!res || res < cpuinfo->online) + res = 0; + else { + erts_cpu_topology_t *prev, *this, *last; + + cpuinfo->topology_size = res; + + if (cpuinfo->topology_size != cpuinfo->configured) { + void *t = realloc(cpuinfo->topology, (sizeof(erts_cpu_topology_t) + * cpuinfo->topology_size)); + if (t) + cpuinfo->topology = t; + } + + qsort(cpuinfo->topology, + cpuinfo->topology_size, + sizeof(erts_cpu_topology_t), + cpu_cmp); + + this = &cpuinfo->topology[0]; + this->thread = 0; + + if (res > 1) { + prev = this++; + last = &cpuinfo->topology[cpuinfo->configured-1]; + + while (1) { + this->thread = ((this->node == prev->node + && this->processor == prev->processor + && this->processor_node == prev->processor_node + && this->core == prev->core) + ? prev->thread + 1 + : 0); + if (this == last) + break; + prev = this++; + } + } + } + + error: + + if (res == 0) { + cpuinfo->topology_size = 0; + if (cpuinfo->topology) { + free(cpuinfo->topology); + cpuinfo->topology = NULL; + } + if (errno) + res = -errno; + else + res = -EINVAL; + } + + return res; + +} + +#else + +static int +read_topology(erts_cpu_info_t *cpuinfo) +{ + return -ENOTSUP; +} + +#endif diff --git a/erts/lib_src/common/erl_printf.c b/erts/lib_src/common/erl_printf.c new file mode 100644 index 0000000000..72d18ab6f1 --- /dev/null +++ b/erts/lib_src/common/erl_printf.c @@ -0,0 +1,427 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 2005-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% + */ + +/* Without this, variable argument lists break on VxWorks */ +#ifdef VXWORKS +#include <vxWorks.h> +#endif + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <string.h> +#include "erl_errno.h" +#ifdef __WIN32__ +# include <io.h> +#else +# include <unistd.h> +#endif +#include "erl_printf.h" +#include "erl_printf_format.h" + +#ifdef DEBUG +#include <assert.h> +#define ASSERT(X) assert(X) +#else +#define ASSERT(X) +#endif + +#if defined(__WIN32__) && !defined(__GNUC__) +typedef int ssize_t; +#endif + +int (*erts_printf_stdout_func)(char *, va_list) = NULL; +int (*erts_printf_stderr_func)(char *, va_list) = NULL; + +int erts_printf_add_cr_to_stdout = 0; +int erts_printf_add_cr_to_stderr = 0; + +int (*erts_printf_block_fpe)(void) = NULL; +void (*erts_printf_unblock_fpe)(int) = NULL; + +#undef FLOCKFILE +#undef FUNLOCKFILE +#undef PUTC +#undef FWRITE +#undef PUTC_ON_SMALL_WRITES + +#if defined(USE_THREADS) && defined(HAVE_FLOCKFILE) +# define FLOCKFILE(FP) flockfile(FP) +# define FUNLOCKFILE(FP) funlockfile(FP) +# ifdef HAVE_PUTC_UNLOCKED +# define PUTC putc_unlocked +# define PUTC_ON_SMALL_WRITES +# endif +# ifdef HAVE_FWRITE_UNLOCKED +# define FWRITE fwrite_unlocked +# endif +#endif +#if !defined(USE_THREADS) && defined(putc) && !defined(fwrite) +# define PUTC_ON_SMALL_WRITES +#endif +#if !defined(FLOCKFILE) || !defined(FUNLOCKFILE) +# define FLOCKFILE(FP) +# define FUNLOCKFILE(FP) +#endif +#ifndef PUTC +# define PUTC putc +#endif +#ifndef FWRITE +# define FWRITE fwrite +#endif + +static int +get_error_result(void) +{ + int res = errno; + if (res <= 0) + res = EIO; + return -res; +} + + +static int +write_f_add_cr(void *vfp, char* buf, size_t len) +{ + size_t i; + ASSERT(vfp); + for (i = 0; i < len; i++) { + if (buf[i] == '\n' && PUTC('\r', (FILE *) vfp) == EOF) + return get_error_result(); + if (PUTC(buf[i], (FILE *) vfp) == EOF) + return get_error_result(); + } + return 0; +} + +static int +write_f(void *vfp, char* buf, size_t len) +{ + ASSERT(vfp); +#ifdef PUTC_ON_SMALL_WRITES + if (len <= 64) { /* Try to optimize writes of small bufs. */ + int i; + for (i = 0; i < len; i++) + if (PUTC(buf[i], (FILE *) vfp) == EOF) + return get_error_result(); + } + else +#endif + if (FWRITE((void *) buf, sizeof(char), len, (FILE *) vfp) != len) + return get_error_result(); + return 0; +} + +static int +write_fd(void *vfdp, char* buf, size_t len) +{ + ssize_t size; + ASSERT(vfdp); + + while (len) { + size = write(*((int *) vfdp), (void *) buf, len); + if (size < 0) { +#ifdef EINTR + if (errno == EINTR) + continue; +#endif + return get_error_result(); + } + if (size > len) + return -EIO; + len -= size; + } + + return 0; +} + +static int +write_s(void *vwbufpp, char* bufp, size_t len) +{ + char **wbufpp = (char **) vwbufpp; + ASSERT(wbufpp && *wbufpp); + ASSERT(len > 0); + memcpy((void *) *wbufpp, (void *) bufp, len); + *wbufpp += len; + return 0; +} + + +typedef struct { + char *buf; + size_t len; +} write_sn_arg_t; + +static int +write_sn(void *vwsnap, char* buf, size_t len) +{ + write_sn_arg_t *wsnap = (write_sn_arg_t *) vwsnap; + ASSERT(wsnap); + ASSERT(len > 0); + if (wsnap->len > 0) { + size_t sz = len; + if (sz >= wsnap->len) + sz = wsnap->len; + memcpy((void *) wsnap->buf, (void *) buf, sz); + wsnap->buf += sz; + wsnap->len -= sz; + } + return 0; +} + +static int +write_ds(void *vdsbufp, char* buf, size_t len) +{ + erts_dsprintf_buf_t *dsbufp = (erts_dsprintf_buf_t *) vdsbufp; + size_t need_len = len + 1; /* Also trailing '\0' */ + ASSERT(dsbufp); + ASSERT(len > 0); + ASSERT(dsbufp->str_len <= dsbufp->size); + if (need_len > dsbufp->size - dsbufp->str_len) { + dsbufp = (*dsbufp->grow)(dsbufp, need_len); + if (!dsbufp) + return -ENOMEM; + } + memcpy((void *) (dsbufp->str + dsbufp->str_len), (void *) buf, len); + dsbufp->str_len += len; + return 0; +} + +int +erts_printf(const char *format, ...) +{ + int res; + va_list arglist; + va_start(arglist, format); + errno = 0; + if (erts_printf_stdout_func) + res = (*erts_printf_stdout_func)((char *) format, arglist); + else { + FLOCKFILE(stdout); + res = erts_printf_format(erts_printf_add_cr_to_stdout + ? write_f_add_cr + : write_f, + (void *) stdout, + (char *) format, + arglist); + FUNLOCKFILE(stdout); + } + va_end(arglist); + return res; +} + +int +erts_fprintf(FILE *filep, const char *format, ...) +{ + int res; + va_list arglist; + va_start(arglist, format); + errno = 0; + if (erts_printf_stdout_func && filep == stdout) + res = (*erts_printf_stdout_func)((char *) format, arglist); + else if (erts_printf_stderr_func && filep == stderr) + res = (*erts_printf_stderr_func)((char *) format, arglist); + else { + int (*fmt_f)(void*, char*, size_t); + if (erts_printf_add_cr_to_stdout && filep == stdout) + fmt_f = write_f_add_cr; + else if (erts_printf_add_cr_to_stderr && filep == stderr) + fmt_f = write_f_add_cr; + else + fmt_f = write_f; + FLOCKFILE(filep); + res = erts_printf_format(fmt_f,(void *)filep,(char *)format,arglist); + FUNLOCKFILE(filep); + } + va_end(arglist); + return res; +} + +int +erts_fdprintf(int fd, const char *format, ...) +{ + int res; + va_list arglist; + va_start(arglist, format); + errno = 0; + res = erts_printf_format(write_fd,(void *)&fd,(char *)format,arglist); + va_end(arglist); + return res; +} + +int +erts_sprintf(char *buf, const char *format, ...) +{ + int res; + char *p = buf; + va_list arglist; + va_start(arglist, format); + errno = 0; + res = erts_printf_format(write_s, (void *) &p, (char *) format, arglist); + if (res < 0) + buf[0] = '\0'; + else + buf[res] = '\0'; + va_end(arglist); + return res; +} + +int +erts_snprintf(char *buf, size_t size, const char *format, ...) +{ + write_sn_arg_t wsnap; + int res; + va_list arglist; + if (size < 1) + return -EINVAL; + wsnap.buf = buf; + wsnap.len = size-1; /* Always need room for trailing '\0' */ + va_start(arglist, format); + errno = 0; + res = erts_printf_format(write_sn, (void *)&wsnap, (char *)format, arglist); + if (res < 0) + buf[0] = '\0'; + else if (res < size) + buf[res] = '\0'; + else + buf[size-1] = '\0'; + va_end(arglist); + return res; +} + +int +erts_dsprintf(erts_dsprintf_buf_t *dsbufp, const char *format, ...) +{ + int res; + va_list arglist; + if (!dsbufp) + return -EINVAL; + va_start(arglist, format); + errno = 0; + res = erts_printf_format(write_ds, (void *)dsbufp, (char *)format, arglist); + if (dsbufp->str) { + if (res < 0) + dsbufp->str[0] = '\0'; + else + dsbufp->str[dsbufp->str_len] = '\0'; + } + va_end(arglist); + return res; +} + +int +erts_vprintf(const char *format, va_list arglist) +{ + int res; + if (erts_printf_stdout_func) + res = (*erts_printf_stdout_func)((char *) format, arglist); + else { + errno = 0; + res = erts_printf_format(erts_printf_add_cr_to_stdout + ? write_f_add_cr + : write_f, + (void *) stdout, + (char *) format, + arglist); + } + return res; +} + +int +erts_vfprintf(FILE *filep, const char *format, va_list arglist) +{ + int res; + if (erts_printf_stdout_func && filep == stdout) + res = (*erts_printf_stdout_func)((char *) format, arglist); + else if (erts_printf_stderr_func && filep == stderr) + res = (*erts_printf_stderr_func)((char *) format, arglist); + else { + int (*fmt_f)(void*, char*, size_t); + errno = 0; + if (erts_printf_add_cr_to_stdout && filep == stdout) + fmt_f = write_f_add_cr; + else if (erts_printf_add_cr_to_stderr && filep == stderr) + fmt_f = write_f_add_cr; + else + fmt_f = write_f; + res = erts_printf_format(fmt_f,(void *)filep,(char *)format,arglist); + } + return res; +} + +int +erts_vfdprintf(int fd, const char *format, va_list arglist) +{ + int res; + errno = 0; + res = erts_printf_format(write_fd,(void *)&fd,(char *)format,arglist); + return res; +} + +int +erts_vsprintf(char *buf, const char *format, va_list arglist) +{ + int res; + char *p = buf; + errno = 0; + res = erts_printf_format(write_s, (void *) &p, (char *) format, arglist); + if (res < 0) + buf[0] = '\0'; + else + buf[res] = '\0'; + return res; +} + +int +erts_vsnprintf(char *buf, size_t size, const char *format, va_list arglist) +{ + write_sn_arg_t wsnap; + int res; + if (size < 1) + return -EINVAL; + wsnap.buf = buf; + wsnap.len = size-1; /* Always need room for trailing '\0' */ + errno = 0; + res = erts_printf_format(write_sn, (void *)&wsnap, (char *)format, arglist); + if (res < 0) + buf[0] = '\0'; + else if (res < size) + buf[res] = '\0'; + else + buf[size-1] = '\0'; + return res; +} + +int +erts_vdsprintf(erts_dsprintf_buf_t *dsbufp, const char *format, va_list arglist) +{ + int res; + if (!dsbufp) + return -EINVAL; + errno = 0; + res = erts_printf_format(write_ds, (void *)dsbufp, (char *)format, arglist); + if (dsbufp->str) { + if (res < 0) + dsbufp->str[0] = '\0'; + else + dsbufp->str[dsbufp->str_len] = '\0'; + } + return res; +} diff --git a/erts/lib_src/common/erl_printf_format.c b/erts/lib_src/common/erl_printf_format.c new file mode 100644 index 0000000000..bd3d38e649 --- /dev/null +++ b/erts/lib_src/common/erl_printf_format.c @@ -0,0 +1,940 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 2005-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% + */ + +/* + * fmt: + * '%' <flag>* [ <width> [.<precision>]][<length>]<conversion> + * + * flag: # | O | - | <sp> | + | ' | I + * width: [0-9]+ | '*' + * precision: [0-9]+ | '*' + * length: hh | h | l | ll | L | j | t | b<sz> + * conversion: d,i | o,u,x,X | e,E | f,F | g,G | a,A | c | s | T | + * p | n | % + * sz: 8 | 16 | 32 | 64 | p + */ + +/* Without this, variable argument lists break on VxWorks */ +#ifdef VXWORKS +#include <vxWorks.h> +#endif + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#ifdef __WIN32__ +#undef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#include <windows.h> +#endif + +#include <ctype.h> +#include <string.h> +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include "erl_errno.h" +#include <limits.h> +#include "erl_printf.h" +#include "erl_printf_format.h" + +#ifdef DEBUG +#include <assert.h> +#define ASSERT(X) assert(X) +#else +#define ASSERT(X) +#endif + +#ifdef __WIN32__ +#define long_long LONGLONG +#define signed_long_long LONGLONG +#define unsigned_long_long ULONGLONG +#undef SIZEOF_LONG_LONG +#define SIZEOF_LONG_LONG 8 +#else +#if SIZEOF_LONG_LONG +#define long_long long long +#define signed_long_long signed long long +#define unsigned_long_long unsigned long long +#endif +#endif + +#if defined(__GNUC__) +# undef inline +# define inline __inline__ +#elif defined(__WIN32__) +# undef inline +# define inline __forceinline +#else +# ifndef inline +# define inline +# endif +#endif + +#define FMTC_d 0x0000 +#define FMTC_i 0x0001 +#define FMTC_o 0x0002 +#define FMTC_u 0x0003 +#define FMTC_x 0x0004 +#define FMTC_X 0x0005 +#define FMTC_e 0x0006 +#define FMTC_E 0x0007 +#define FMTC_f 0x0008 +#define FMTC_T 0x0009 +#define FMTC_g 0x000a +#define FMTC_G 0x000b +#define FMTC_c 0x000c +#define FMTC_s 0x000d +#define FMTC_p 0x000e +#define FMTC_n 0x000f +#define FMTC_MASK 0x000f + +#define FMTL_no 0x0000 +#define FMTL_hh 0x0010 +#define FMTL_h 0x0020 +#define FMTL_l 0x0030 +#define FMTL_ll 0x0040 +#define FMTL_L 0x0050 +#define FMTL_j 0x0060 +#define FMTL_t 0x0070 +#define FMTL_MASK 0x00f0 + +#define FMTF_alt 0x0100 /* # alterlate form ie 0x */ +#define FMTF_pad 0x0200 /* 0 zero pad */ +#define FMTF_adj 0x0400 /* left adjust */ +#define FMTF_blk 0x0800 /* add blank */ +#define FMTF_sgn 0x1000 /* add sign */ +#define FMTF_cnv 0x2000 /* decimal conversion */ +#define FMTF_cnV 0x4000 /* alternate decimal conversion */ +#define FMTF_MASK 0x7f00 + + +static char zeros[] = "00000000000000000000000000000000"; +static char blanks[] = " "; +static char hex[] = "0123456789abcdef"; +static char heX[] = "0123456789ABCDEF"; + +#define FMT(fn,arg,buf,len,count) do { \ + int res__ = (fn)((arg),(buf),(len)); \ + if (res__ < 0) \ + return res__; \ + (count) += (len); \ + } while(0) + +#define FILL(fn,arg,cs,len, count) do { \ + int __i = (len); \ + while(__i >= sizeof(cs)-1) { \ + FMT((fn),(arg),(cs),sizeof(cs)-1,(count)); \ + __i -= sizeof(cs)-1; \ + } \ + if (__i) FMT((fn),(arg),(cs),__i,(count)); \ + } while(0) + +#define BLANKS(fn,arg,n,count) FILL((fn),(arg),blanks,(n),count) +#define ZEROS(fn,arg,n,count) FILL((fn),(arg),zeros,(n),count) + +#define SIGN(X) ((X) > 0 ? 1 : ((X) < 0 ? -1 : 0)) +#define USIGN(X) ((X) == 0 ? 0 : 1) + +int (*erts_printf_eterm_func)(fmtfn_t, void*, unsigned long, long) = NULL; + +static int +noop_fn(void *vfp, char* buf, size_t len) +{ + return 0; +} + +static int fmt_fld(fmtfn_t fn,void* arg, + char* wbuf, int w, int sign, + int width,int precision,int fmt,int* count) +{ + char prefix[8]; + char* pp = prefix; + int pw = 0; + int len; + + /* format the prefix */ + if ((sign || (fmt & (FMTF_sgn|FMTF_blk))) && + (((fmt & FMTC_MASK) == FMTC_d) || ((fmt & FMTC_MASK) == FMTC_i))) { + if (sign < 0) + *pp++ = '-'; + else if ((fmt & FMTF_sgn)) + *pp++ = '+'; + else if (fmt & FMTF_blk) + *pp++ = ' '; + } + + if ((fmt & FMTF_alt)) { + switch((fmt & FMTC_MASK)) { + case FMTC_X: *pp++ = '0'; *pp++ = 'X'; break; + case FMTC_x: *pp++ = '0'; *pp++ = 'x'; break; + case FMTC_o: *pp++ = '0'; if (precision>1) precision--; break; + } + } + + pw = pp-prefix; + len = ((w < precision) ? precision : w) + pw; + + if (fmt & FMTF_adj) { /* left adjust */ + if (pw) + FMT(fn,arg,prefix,pw,*count); + if (w < precision) + ZEROS(fn,arg,precision-w,*count); + FMT(fn,arg, wbuf, w, *count); + if (len < width) + BLANKS(fn,arg,width-len,*count); + } + else if ((fmt & FMTF_pad) && (precision<0)) { /* pad zeros */ + if (pw) + FMT(fn,arg, prefix, pw, *count); + if (w < precision) + ZEROS(fn, arg, precision-w, *count); + if (len < width) + ZEROS(fn,arg,width-len,*count); + FMT(fn,arg,wbuf,w,*count); + } + else { + if (len < width) + BLANKS(fn,arg,width-len,*count); + if (pw) + FMT(fn,arg,prefix,pw,*count); + if (w < precision) + ZEROS(fn,arg,precision-w,*count); + FMT(fn,arg,wbuf,w,*count); + } + return 0; +} + +static int fmt_long(fmtfn_t fn,void* arg,int sign,unsigned long uval, + int width,int precision,int fmt,int* count) +{ + char buf[32]; + int base = 10; + int w = 0; + char* dc = hex; + char* p = buf+sizeof(buf); + + switch(fmt & FMTC_MASK) { + case FMTC_d: + case FMTC_i: + case FMTC_u: + break; + case FMTC_o: + base = 8; + break; + case FMTC_X: + dc = heX; + case FMTC_x: + base = 16; + break; + default: + return -EINVAL; + } + + /* format the unsigned value */ + if (!sign && precision) { + *--p = '0'; + w++; + } + else { + while(uval) { + *--p = dc[(uval % base)]; + uval /= base; + w++; + } + } + return fmt_fld(fn, arg, p, w, sign, width, precision, fmt, count); +} + +#if SIZEOF_LONG_LONG + +static inline int +do_div(unsigned_long_long *n, unsigned_long_long base) +{ + unsigned_long_long q = *n/base; + int mod = (int) (*n - q*base); + *n = q; + return mod; +} + +static int fmt_long_long(fmtfn_t fn,void* arg,int sign, + unsigned_long_long uval, + int width,int precision,int fmt,int* count) +{ + char buf[32]; + int base = 10; + int w = 0; + char* dc = hex; + char* p = buf+sizeof(buf); + + switch(fmt & FMTC_MASK) { + case FMTC_d: + case FMTC_i: + case FMTC_u: + break; + case FMTC_o: + base = 8; + break; + case FMTC_X: + dc = heX; + case FMTC_x: + base = 16; + break; + default: + return -EINVAL; + } + + /* format the unsigned value */ + if (!sign && precision) { + *--p = '0'; + w++; + } + else { + while(uval) { + int m = do_div(&uval,base); + *--p = dc[m]; + w++; + } + } + return fmt_fld(fn, arg, p, w, sign, width, precision, fmt, count); +} + +#endif /* #if SIZEOF_LONG_LONG */ + +static int fmt_double(fmtfn_t fn,void*arg,double val, + int width, int precision, int fmt,int* count) +{ + int res; + int fi = 0; + char format_str[7]; + char sbuf[32]; + char *bufp; + double dexp; + int exp; + size_t max_size = 1; + size_t size; + int new_fmt = fmt; + int fpe_was_unmasked; + + fpe_was_unmasked = erts_printf_block_fpe ? (*erts_printf_block_fpe)() : 0; + + if (val < 0.0) + dexp = log10(-val); + else if (val == 0.0) + dexp = 0.0; + else + dexp = log10(val); + exp = (int) dexp; + + new_fmt &= ~FMTF_sgn; + new_fmt &= ~FMTF_blk; + + format_str[fi++] = '%'; + if (fmt & FMTF_alt) + format_str[fi++] = '#'; + if (fmt & FMTF_sgn) + format_str[fi++] = '+'; + else if (fmt & FMTF_blk) + format_str[fi++] = ' '; + format_str[fi++] = '0'; + format_str[fi++] = '.'; + format_str[fi++] = '*'; + + switch(fmt & FMTC_MASK) { + case FMTC_G: + format_str[fi] = 'E'; + goto gG_common; + case FMTC_g: + format_str[fi] = 'e'; + gG_common: + if (dexp < -4.0 || exp >= precision) { + fi++; + precision--; + if (precision < 1) + precision = 1; + goto eE_common; + } + /* fall through ... */ + case FMTC_f: + format_str[fi++] = 'f'; + max_size += exp > 0 ? exp : 1; + max_size++; + if (precision) + max_size += precision; + else if (fmt && FMTF_alt) + max_size++; + break; + case FMTC_E: + format_str[fi++] = 'E'; + goto eE_common; + case FMTC_e: + format_str[fi++] = 'e'; + eE_common: { + int aexp; + + max_size += 4; + if (precision) + max_size += precision; + else if (fmt && FMTF_alt) + max_size++; + aexp = exp >= 0 ? exp : -exp; + if (aexp < 100) + max_size += 2; + else { + while (aexp) { + max_size++; + aexp /= 10; + } + } + break; + } + default: + res = -EINVAL; + goto out; + } + + format_str[fi++] = '\0'; + ASSERT(fi <= sizeof(format_str)); + + max_size++; /* '\0' */ + + if (max_size < sizeof(sbuf)) + bufp = sbuf; + else { + bufp = (char *) malloc(sizeof(char)*max_size); + if (!bufp) { + res = -ENOMEM; + goto out; + } + } + + size = sprintf(bufp, format_str, precision, val); + if (size < 0) { + if (errno > 0) + res = -errno; + else + res = -EIO; + goto out; + } + + ASSERT(max_size >= size); + + res = fmt_fld(fn, arg, bufp, size, 0, width, 0, new_fmt, count); + + if (bufp != sbuf) + free((void *) bufp); + + out: + if (erts_printf_unblock_fpe) + (*erts_printf_unblock_fpe)(fpe_was_unmasked); + return res; +} + +int erts_printf_format(fmtfn_t fn, void* arg, char* fmt, va_list ap) +{ + char* ptr0 = fmt; + char* ptr = ptr0; + int count = 0; + int n; + int res = 0; + + while(*ptr) { + unsigned long ul_val; + int fmt = 0; + int width = -1; + int precision = -1; + + if (res < 0) + return res; + + if (*ptr == '%') { + if ((n=ptr-ptr0)) + FMT(fn,arg,ptr0,n,count); + ptr++; + + do_flag: + switch(*ptr) { + case '#': fmt |= FMTF_alt; ptr++; goto do_flag; + case '0': fmt |= FMTF_pad; ptr++; goto do_flag; + case '-': fmt |= FMTF_adj; ptr++; goto do_flag; + case ' ': fmt |= FMTF_blk; ptr++; goto do_flag; + case '+': fmt |= FMTF_sgn; ptr++; goto do_flag; + case '\'': fmt |= FMTF_cnv; ptr++; goto do_flag; + case 'I': fmt |= FMTF_cnV; ptr++; goto do_flag; + } + + /* width */ + if (*ptr == '*') { + width = va_arg(ap, int); + ptr++; + } + else if (isdigit((int) *ptr)) { + width = *ptr++ - '0'; + while(isdigit((int) *ptr)) + width = 10*width + (*ptr++ - '0'); + } + + /* precision */ + if (*ptr == '.') { + ptr++; + if (*ptr == '*') { + precision = va_arg(ap, int); + ptr++; + } + else if (isdigit((int) *ptr)) { + precision = *ptr++ - '0'; + while(isdigit((int) *ptr)) + precision = 10*precision + (*ptr++ - '0'); + } + } + + /* length modifier */ + switch(*ptr) { + case 'b': { + ptr++; + if (*ptr == 'p') { + ptr++; +#if SIZEOF_INT == SIZEOF_VOID_P +#elif SIZEOF_LONG == SIZEOF_VOID_P + fmt |= FMTL_l; +#elif SIZEOF_LONG_LONG == SIZEOF_VOID_P + fmt |= FMTL_ll; +#else +#error No integer datatype with the same size as 'void *' found +#endif + } + else { + int bits = 0; + while(isdigit((int) *ptr)) + bits = 10*bits + (*ptr++ - '0'); + switch (bits) { + case 64: +#if SIZEOF_INT == 8 +#elif SIZEOF_LONG == 8 + fmt |= FMTL_l; +#elif SIZEOF_LONG_LONG == 8 + fmt |= FMTL_ll; +#else +#error No 64-bit integer datatype found +#endif + break; + case 32: +#if SIZEOF_INT == 4 +#elif SIZEOF_SHORT == 4 + fmt |= FMTL_h; +#elif SIZEOF_LONG == 4 + fmt |= FMTL_l; +#elif SIZEOF_LONG_LONG == 4 + fmt |= FMTL_ll; +#else +#error No 32-bit integer datatype found +#endif + break; + case 16: +#if SIZEOF_INT == 2 +#elif SIZEOF_SHORT == 2 + fmt |= FMTL_h; +#elif SIZEOF_LONG == 2 + fmt |= FMTL_l; +#else +#error No 16-bit integer datatype found +#endif + case 8: +#if SIZEOF_CHAR == 1 + fmt |= FMTL_hh; +#else +#error Unexpected size of char +#endif + break; + default: + return -EINVAL; + } + } + break; + } + case 'h': + ptr++; + if (*ptr == 'h') { + ptr++; + fmt |= FMTL_hh; + } + else + fmt |= FMTL_h; + break; + case 'l': + ptr++; + if (*ptr == 'l') { + ptr++; +#if SIZEOF_LONG_LONG + fmt |= FMTL_ll; +#else + fmt |= FMTL_l; +#endif + } + else + fmt |= FMTL_l; + break; + case 'L': ptr++; fmt |= FMTL_L; break; + case 'j': ptr++; fmt |= FMTL_j; break; + case 't': ptr++; fmt |= FMTL_t; break; + } + + /* specifier */ + switch(*ptr) { + case 'd': ptr++; fmt |= FMTC_d; break; + case 'i': ptr++; fmt |= FMTC_i; break; + case 'o': ptr++; fmt |= FMTC_o; break; + case 'u': ptr++; fmt |= FMTC_u; break; + case 'x': ptr++; fmt |= FMTC_x; break; + case 'X': ptr++; fmt |= FMTC_X; break; + case 'e': ptr++; fmt |= FMTC_e; break; + case 'E': ptr++; fmt |= FMTC_E; break; + case 'f': ptr++; fmt |= FMTC_f; break; + case 'g': ptr++; fmt |= FMTC_g; break; + case 'G': ptr++; fmt |= FMTC_G; break; + case 'c': ptr++; fmt |= FMTC_c; break; + case 's': ptr++; fmt |= FMTC_s; break; + case 'p': ptr++; fmt |= FMTC_p; break; + case 'n': ptr++; fmt |= FMTC_n; break; + case 'T': ptr++; fmt |= FMTC_T; break; + case '%': + FMT(fn,arg,ptr,1,count); + ptr++; + ptr0 = ptr; + continue; + default: + /* ignore */ + ptr0 = ptr; + continue; + } + + switch(fmt & FMTC_MASK) { + case FMTC_d: + case FMTC_i: + switch(fmt & FMTL_MASK) { + case FMTL_hh: { + signed char tval = (signed char) va_arg(ap,int); + ul_val = (unsigned long) (tval < 0 ? (-tval) : tval); + res = fmt_long(fn,arg,SIGN(tval),ul_val, + width,precision,fmt,&count); + break; + } + case FMTL_h: { + signed short tval = (signed short) va_arg(ap,int); + ul_val = (unsigned long) (tval < 0 ? (-tval) : tval); + res = fmt_long(fn,arg,SIGN(tval),ul_val, + width,precision,fmt,&count); + break; + } + case FMTL_l: { + signed long tval = (signed long) va_arg(ap,long); + ul_val = (unsigned long) (tval < 0 ? (-tval) : tval); + res = fmt_long(fn,arg,SIGN(tval),ul_val, + width,precision,fmt,&count); + break; + } +#if SIZEOF_LONG_LONG + case FMTL_ll: { + unsigned_long_long ull_val; + signed_long_long tval; + tval = (signed_long_long) va_arg(ap,long_long); + ull_val = (unsigned_long_long) (tval < 0 ? (-tval) : tval); + res = fmt_long_long(fn,arg,SIGN(tval),ull_val, + width,precision,fmt,&count); + break; + } +#endif + default: { + signed int tval = (signed int) va_arg(ap,int); + ul_val = (unsigned long) (tval < 0 ? (-tval) : tval); + res = fmt_long(fn,arg,SIGN(tval),ul_val, + width,precision,fmt,&count); + break; + } + } + break; + case FMTC_o: + case FMTC_u: + case FMTC_x: + case FMTC_X: + switch(fmt & FMTL_MASK) { + case FMTL_hh: { + unsigned char tval = (unsigned char) va_arg(ap,int); + ul_val = (unsigned long) tval; + res = fmt_long(fn,arg,USIGN(tval),ul_val, + width,precision,fmt,&count); + break; + } + case FMTL_h: { + unsigned short tval = (unsigned short) va_arg(ap,int); + ul_val = (unsigned long) tval; + res = fmt_long(fn,arg,USIGN(tval),ul_val, + width,precision,fmt,&count); + break; + } + case FMTL_l: { + ul_val = (unsigned long) va_arg(ap,long); + res = fmt_long(fn,arg,USIGN(ul_val),ul_val, + width,precision,fmt,&count); + break; + } +#if SIZEOF_LONG_LONG + case FMTL_ll: { + unsigned_long_long ull_val; + ull_val = (signed_long_long) va_arg(ap,long_long); + res = fmt_long_long(fn,arg,USIGN(ull_val),ull_val, + width,precision,fmt,&count); + break; + } +#endif + default: { + unsigned int tval = (unsigned int) va_arg(ap,int); + ul_val = (unsigned long) tval; + res = fmt_long(fn,arg,USIGN(tval),ul_val, + width,precision,fmt,&count); + break; + } + } + break; + case FMTC_e: + case FMTC_E: + case FMTC_f: + case FMTC_g: + case FMTC_G: + if (precision < 0) + precision = 6; + switch(fmt & FMTL_MASK) { + case FMTL_L: + return -EINVAL; + break; + default: + res = fmt_double(fn,arg,va_arg(ap,double), + width,precision,fmt,&count); + break; + } + break; + + case FMTC_c: { + /* fixme: add wide char support l-modifier */ + char c = va_arg(ap,int); + int len = 1; + if (precision == 0) + len = 0; + if (width > 0 && !(fmt & FMTF_adj)) { + if (width > len) + BLANKS(fn, arg, width - len, count); + } + if (len) + FMT(fn,arg,&c,len,count); + if (width > len && fmt & FMTF_adj) + BLANKS(fn, arg, width - len, count); + break; + } + + case FMTC_s: { + char* str = va_arg(ap,char*); + int len = strlen(str); + if (precision >= 0 && precision < len) + len = precision; + if (width > 0 && !(fmt & FMTF_adj)) { + if (width > len) + BLANKS(fn, arg, width - len, count); + } + if (len) + FMT(fn,arg,str,len,count); + if (width > len && fmt & FMTF_adj) + BLANKS(fn, arg, width - len, count); + break; + } + + case FMTC_p: { + void* addr = va_arg(ap, void*); + + res = fmt_long(fn, + arg, + USIGN((unsigned long) addr), + (unsigned long) addr, + width < 0 ? ((int) 2*sizeof(void *)) : width, + (precision < 0 + ? ((int) 2*sizeof(void *)) + : precision), + FMTC_x|FMTF_pad|FMTF_alt, + &count); + break; + } + + case FMTC_n: + switch(fmt & FMTL_MASK) { + case FMTL_hh: *va_arg(ap,char*) = count; break; + case FMTL_h: *va_arg(ap,short*) = count; break; + case FMTL_l: *va_arg(ap,long*) = count; break; +#if SIZEOF_LONG_LONG + case FMTL_ll: *va_arg(ap,long_long*) = count; break; +#endif + default: *va_arg(ap,int*) = count; break; + } + break; + case FMTC_T: { + long prec; + unsigned long eterm; + if (!erts_printf_eterm_func) + return -EINVAL; + if (precision < 0) + prec = 100000; + else if (precision == INT_MAX) + prec = LONG_MAX; + else + prec = (long) precision; + eterm = va_arg(ap, unsigned long); + if (width > 0 && !(fmt & FMTF_adj)) { + res = (*erts_printf_eterm_func)(noop_fn, NULL, eterm, prec); + if (res < 0) + return res; + if (width > res) + BLANKS(fn, arg, width - res, count); + } + res = (*erts_printf_eterm_func)(fn, arg, eterm, prec); + if (res < 0) + return res; + count += res; + if (width > res && fmt & FMTF_adj) + BLANKS(fn, arg, width - res, count); + break; + } + default: + if ((n=ptr-ptr0)) + FMT(fn,arg,ptr0,n,count); + } + ptr0 = ptr; + } + else + ptr++; + } + + if ((n=ptr-ptr0)) + FMT(fn,arg,ptr0,n,count); + return count; +} + + +int +erts_printf_char(fmtfn_t fn, void *arg, char c) +{ + return (*fn)(arg, &c, 1); +} + +int +erts_printf_string(fmtfn_t fn, void *arg, char *str) +{ + size_t sz = strlen(str); + return (*fn)(arg, str, sz); +} + +int +erts_printf_buf(fmtfn_t fn, void *arg, char *buf, size_t sz) +{ + return (*fn)(arg, buf, sz); +} + +int +erts_printf_pointer(fmtfn_t fn, void *arg, void *ptr) +{ + int count = 0; + int res = fmt_long(fn, arg, USIGN((unsigned long) ptr), + (unsigned long) ptr, 2*sizeof(void *), + 2*sizeof(void *), FMTC_x|FMTF_pad|FMTF_alt, &count); + if (res < 0) + return res; + return count; +} + +int +erts_printf_ulong(fmtfn_t fn, void *arg, char conv, int pad, int width, + unsigned long val) +{ + int count = 0; + int res; + int fmt = 0; + int prec = -1; + switch (conv) { + case 'o': fmt |= FMTC_o; break; + case 'u': fmt |= FMTC_u; break; + case 'x': fmt |= FMTC_x; break; + case 'X': fmt |= FMTC_X; break; + case 'p': fmt |= FMTC_p; break; + default: + return -EINVAL; + } + if (pad) + prec = width; + res = fmt_long(fn, arg, USIGN(val), val, width, prec, fmt, &count); + if (res < 0) + return res; + return count; +} + +extern int +erts_printf_slong(fmtfn_t fn, void *arg, char conv, int pad, int width, + signed long val) +{ + int count = 0; + int res; + int fmt = 0; + int prec = -1; + unsigned long ul_val; + switch (conv) { + case 'd': fmt |= FMTC_d; break; + case 'i': fmt |= FMTC_i; break; + case 'o': fmt |= FMTC_o; break; + case 'x': fmt |= FMTC_x; break; + case 'X': fmt |= FMTC_X; break; + default: + return -EINVAL; + } + if (pad) + prec = width; + ul_val = (unsigned long) (val < 0 ? -val : val); + res = fmt_long(fn, arg, SIGN(val), ul_val, width, prec, fmt, &count); + if (res < 0) + return res; + return count; +} + +int +erts_printf_double(fmtfn_t fn, void *arg, char conv, int precision, int width, + double val) +{ + int count = 0; + int res; + int fmt = 0; + switch (conv) { + case 'e': fmt |= FMTC_e; break; + case 'E': fmt |= FMTC_E; break; + case 'f': fmt |= FMTC_f; break; + case 'g': fmt |= FMTC_g; break; + case 'G': fmt |= FMTC_G; break; + default: + return -EINVAL; + } + res = fmt_double(fn, arg, val, width, precision, fmt, &count); + if (res < 0) + return res; + return count; +} diff --git a/erts/lib_src/common/ethread.c b/erts/lib_src/common/ethread.c new file mode 100644 index 0000000000..eb4d0cad20 --- /dev/null +++ b/erts/lib_src/common/ethread.c @@ -0,0 +1,3346 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 2004-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% + */ + +/* + * Description: A Thread library for use in the ERTS and other OTP + * applications. + * Author: Rickard Green + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#undef ETHR_STACK_GUARD_SIZE + +#if defined(ETHR_PTHREADS) + +#ifdef ETHR_TIME_WITH_SYS_TIME +# include <time.h> +# include <sys/time.h> +#else +# ifdef ETHR_HAVE_SYS_TIME_H +# include <sys/time.h> +# else +# include <time.h> +# endif +#endif +#include <sys/types.h> +#include <unistd.h> +#include <signal.h> + +#ifdef ETHR_HAVE_PTHREAD_ATTR_SETGUARDSIZE +# define ETHR_STACK_GUARD_SIZE (pagesize) +#endif + +#elif defined(ETHR_WIN32_THREADS) + +#undef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#include <windows.h> +#include <process.h> +#include <winerror.h> + +#else +#error "Missing thread implementation" +#endif + +#include <limits.h> + +#define ETHR_FORCE_INLINE_FUNCS +#define ETHR_INLINE_FUNC_NAME_(X) X ## __ +#include "ethread.h" + +#ifndef ETHR_HAVE_ETHREAD_DEFINES +#error Missing configure defines +#endif + +/* + * ---------------------------------------------------------------------------- + * Common stuff + * ---------------------------------------------------------------------------- + */ + +#define ETHR_MAX_THREADS 2048 /* Has to be an even power of 2 */ + +static int ethr_not_inited = 1; + +#define ASSERT(A) ETHR_ASSERT((A)) + +static void *(*allocp)(size_t) = malloc; +static void *(*reallocp)(void *, size_t) = realloc; +static void (*freep)(void *) = free; + +#ifndef ETHR_HAVE_OPTIMIZED_ATOMIC_OPS +ethr_atomic_protection_t ethr_atomic_protection__[1 << ETHR_ATOMIC_ADDR_BITS]; +#endif + +void *(*thread_create_prepare_func)(void) = NULL; +void (*thread_create_parent_func)(void *) = NULL; +void (*thread_create_child_func)(void *) = NULL; + +typedef struct ethr_xhndl_list_ ethr_xhndl_list; +struct ethr_xhndl_list_ { + ethr_xhndl_list *next; + void (*funcp)(void); +}; + +static size_t pagesize; +#define ETHR_PAGE_ALIGN(SZ) (((((size_t) (SZ)) - 1)/pagesize + 1)*pagesize) +static size_t min_stack_size; /* kilo words */ +static size_t max_stack_size; /* kilo words */ +#define ETHR_B2KW(B) ((((size_t) (B)) - 1)/(sizeof(void *)*1024) + 1) +#define ETHR_KW2B(KW) (((size_t) (KW))*sizeof(void *)*1024) + +ethr_mutex xhndl_mtx; +ethr_xhndl_list *xhndl_list; + +static int +init_common(ethr_init_data *id) +{ + int res; + if (id) { + allocp = id->alloc; + reallocp = id->realloc; + freep = id->free; + thread_create_prepare_func = id->thread_create_prepare_func; + thread_create_parent_func = id->thread_create_parent_func; + thread_create_child_func = id->thread_create_child_func; + } + if (!allocp || !reallocp || !freep) + return EINVAL; + +#ifdef _SC_PAGESIZE + pagesize = (size_t) sysconf(_SC_PAGESIZE); +#elif defined(HAVE_GETPAGESIZE) + pagesize = (size_t) getpagesize(); +#else + pagesize = (size_t) 4*1024; /* Guess 4 KB */ +#endif + + /* User needs at least 4 KB */ + min_stack_size = 4*1024; +#if SIZEOF_VOID_P == 8 + /* Double that on 64-bit archs */ + min_stack_size *= 2; +#endif + /* On some systems as much as about 4 KB is used by the system */ + min_stack_size += 4*1024; + /* There should be room for signal handlers */ +#ifdef SIGSTKSZ + min_stack_size += SIGSTKSZ; +#else + min_stack_size += pagesize; +#endif + /* The system may think that we need more stack */ +#if defined(PTHREAD_STACK_MIN) + if (min_stack_size < PTHREAD_STACK_MIN) + min_stack_size = PTHREAD_STACK_MIN; +#elif defined(_SC_THREAD_STACK_MIN) + { + size_t thr_min_stk_sz = (size_t) sysconf(_SC_THREAD_STACK_MIN); + if (min_stack_size < thr_min_stk_sz) + min_stack_size = thr_min_stk_sz; + } +#endif + /* The guard is at least on some platforms included in the stack size + passed when creating threads */ +#ifdef ETHR_STACK_GUARD_SIZE + min_stack_size += ETHR_STACK_GUARD_SIZE; +#endif + min_stack_size = ETHR_PAGE_ALIGN(min_stack_size); + + min_stack_size = ETHR_B2KW(min_stack_size); + + max_stack_size = 32*1024*1024; +#if SIZEOF_VOID_P == 8 + max_stack_size *= 2; +#endif + max_stack_size = ETHR_B2KW(max_stack_size); + + xhndl_list = NULL; + + res = ethr_mutex_init(&xhndl_mtx); + if (res != 0) + return res; + + res = ethr_mutex_set_forksafe(&xhndl_mtx); + if (res != 0 && res != ENOTSUP) + return res; + + return 0; +} + +int +ethr_install_exit_handler(void (*funcp)(void)) +{ + ethr_xhndl_list *xhp; + int res; + +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } +#endif + + if (!funcp) + return EINVAL; + + xhp = (ethr_xhndl_list *) (*allocp)(sizeof(ethr_xhndl_list)); + if (!xhp) + return ENOMEM; + + res = ethr_mutex_lock__(&xhndl_mtx); + if (res != 0) { + (*freep)((void *) xhp); + return res; + } + + xhp->funcp = funcp; + xhp->next = xhndl_list; + xhndl_list = xhp; + + res = ethr_mutex_unlock__(&xhndl_mtx); + if (res != 0) + abort(); + + return res; +} + +static void +run_exit_handlers(void) +{ + int res; + ethr_xhndl_list *xhp; + + res = ethr_mutex_lock__(&xhndl_mtx); + if (res != 0) + abort(); + + xhp = xhndl_list; + + res = ethr_mutex_unlock__(&xhndl_mtx); + if (res != 0) + abort(); + + for (; xhp; xhp = xhp->next) + (*xhp->funcp)(); +} + +#if defined(ETHR_PTHREADS) +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\ + * pthread implementation * +\* */ + +typedef struct { + pthread_mutex_t mtx; + pthread_cond_t cnd; + int initialized; + void *(*thr_func)(void *); + void *arg; + void *prep_func_res; +} thr_wrap_data_; + +static int no_ethreads; +static ethr_mutex no_ethrs_mtx; + +#ifndef ETHR_HAVE_PTHREAD_ATFORK +#define ETHR_HAVE_PTHREAD_ATFORK 0 +#endif + +#if !ETHR_HAVE_PTHREAD_ATFORK +#warning "Cannot enforce fork-safety" +#endif + +/* + * ---------------------------------------------------------------------------- + * Static functions + * ---------------------------------------------------------------------------- + */ + +/* + * Functions with safe_ prefix aborts on failure. To be used when + * we cannot recover after failure. + */ + +static ETHR_INLINE void +safe_mutex_lock(pthread_mutex_t *mtxp) +{ + int res = pthread_mutex_lock(mtxp); + if (res != 0) + abort(); +} + +static ETHR_INLINE void +safe_mutex_unlock(pthread_mutex_t *mtxp) +{ + int res = pthread_mutex_unlock(mtxp); + if (res != 0) + abort(); +} + +static ETHR_INLINE void +safe_cond_signal(pthread_cond_t *cndp) +{ + int res = pthread_cond_signal(cndp); + if (res != 0) + abort(); +} + +#ifdef ETHR_HAVE_ETHR_REC_MUTEX_INIT + +static volatile int rec_mtx_attr_need_init = 1; +static pthread_mutexattr_t rec_mtx_attr; + +static int init_rec_mtx_attr(void); + +#endif + +#if ETHR_HAVE_PTHREAD_ATFORK + +static ethr_mutex forksafe_mtx = ETHR_MUTEX_INITER; + +static void lock_mutexes(void) +{ + ethr_mutex *m = &forksafe_mtx; + do { + + safe_mutex_lock(&m->pt_mtx); + + m = m->next; + + } while (m != &forksafe_mtx); +} + +static void unlock_mutexes(void) +{ + ethr_mutex *m = forksafe_mtx.prev; + do { + + safe_mutex_unlock(&m->pt_mtx); + + m = m->prev; + + } while (m->next != &forksafe_mtx); +} + +#if ETHR_INIT_MUTEX_IN_CHILD_AT_FORK + +static void reinit_mutexes(void) +{ + ethr_mutex *m = forksafe_mtx.prev; + do { + pthread_mutexattr_t *attrp = NULL; + +#ifdef ETHR_HAVE_ETHR_REC_MUTEX_INIT + if (m->is_rec_mtx) { + if (rec_mtx_attr_need_init) { + int res = init_rec_mtx_attr(); + if (res != 0) + abort(); + } + attrp = &rec_mtx_attr; + } +#endif + if (pthread_mutex_init(&m->pt_mtx, attrp) != 0) + abort(); + + m = m->prev; + + } while (m->next != &forksafe_mtx); +} + +#endif + +static int +init_forksafe(void) +{ + static int init_done = 0; + int res = 0; + + if (init_done) + return res; + + forksafe_mtx.prev = &forksafe_mtx; + forksafe_mtx.next = &forksafe_mtx; + + res = pthread_atfork(lock_mutexes, + unlock_mutexes, +#if ETHR_INIT_MUTEX_IN_CHILD_AT_FORK + reinit_mutexes +#else + unlock_mutexes +#endif + ); + + init_done = 1; + return res; +} + +#endif + + +#ifdef ETHR_HAVE_ETHR_REC_MUTEX_INIT + +#if defined(ETHR_HAVE_PTHREAD_MUTEXATTR_SETTYPE) + +#define SET_REC_MUTEX_ATTR(AP) \ + pthread_mutexattr_settype((AP), PTHREAD_MUTEX_RECURSIVE); + +#elif defined(ETHR_HAVE_PTHREAD_MUTEXATTR_SETKIND_NP) + +#define SET_REC_MUTEX_ATTR(AP) \ + pthread_mutexattr_setkind_np((AP), PTHREAD_MUTEX_RECURSIVE_NP); + +#else + +#error "Don't know how to set recursive mutex attributes" + +#endif + +static int +init_rec_mtx_attr(void) +{ + int res, mres; + static pthread_mutex_t attrinit_mtx = PTHREAD_MUTEX_INITIALIZER; + + mres = pthread_mutex_lock(&attrinit_mtx); + if (mres != 0) + return mres; + /* Got here under race conditions; check again ... */ + if (!rec_mtx_attr_need_init) + res = 0; + else { + res = pthread_mutexattr_init(&rec_mtx_attr); + if (res == 0) { + res = SET_REC_MUTEX_ATTR(&rec_mtx_attr); + if (res == 0) + rec_mtx_attr_need_init = 0; + else + (void) pthread_mutexattr_destroy(&rec_mtx_attr); + } + } + + mres = pthread_mutex_unlock(&attrinit_mtx); + if (mres != 0) + return mres; + return res; +} + +#endif /* #if ETHR_HAVE_ETHR_REC_MUTEX_INIT */ + +static ETHR_INLINE void thr_exit_cleanup(void) +{ + run_exit_handlers(); + safe_mutex_lock(&no_ethrs_mtx.pt_mtx); + ASSERT(no_ethreads > 0); + no_ethreads--; + safe_mutex_unlock(&no_ethrs_mtx.pt_mtx); +} + +static void *thr_wrapper(void *vtwd) +{ + void *res; + thr_wrap_data_ *twd = (thr_wrap_data_ *) vtwd; + void *(*thr_func)(void *) = twd->thr_func; + void *arg = twd->arg; + + safe_mutex_lock(&twd->mtx); + + if (thread_create_child_func) + (*thread_create_child_func)(twd->prep_func_res); + + twd->initialized = 1; + + safe_cond_signal(&twd->cnd); + safe_mutex_unlock(&twd->mtx); + + res = (*thr_func)(arg); + thr_exit_cleanup(); + return res; +} + + +/* + * ---------------------------------------------------------------------------- + * Exported functions + * ---------------------------------------------------------------------------- + */ + +int +ethr_init(ethr_init_data *id) +{ + int res; + + if (!ethr_not_inited) + return EINVAL; + + ethr_not_inited = 0; + + res = init_common(id); + if (res != 0) + goto error; + +#if ETHR_HAVE_PTHREAD_ATFORK + init_forksafe(); +#endif + + no_ethreads = 1; + res = ethr_mutex_init(&no_ethrs_mtx); + if (res != 0) + goto error; + res = ethr_mutex_set_forksafe(&no_ethrs_mtx); + if (res != 0 && res != ENOTSUP) + goto error; + +#ifndef ETHR_HAVE_OPTIMIZED_ATOMIC_OPS + { + int i; + for (i = 0; i < (1 << ETHR_ATOMIC_ADDR_BITS); i++) { +#ifdef ETHR_HAVE_PTHREAD_SPIN_LOCK + res = pthread_spin_init(ðr_atomic_protection__[i].u.spnlck, 0); +#else + res = ethr_mutex_init(ðr_atomic_protection__[i].u.mtx); +#endif + if (res != 0) + goto error; + } + } +#endif + + return 0; + + error: + ethr_not_inited = 1; + return res; + +} + +int +ethr_thr_create(ethr_tid *tid, void * (*func)(void *), void *arg, + ethr_thr_opts *opts) +{ + thr_wrap_data_ twd; + pthread_attr_t attr; + int res, dres; + int use_stack_size = (opts && opts->suggested_stack_size >= 0 + ? opts->suggested_stack_size + : -1 /* Use system default */); + +#ifdef ETHR_MODIFIED_DEFAULT_STACK_SIZE + if (use_stack_size < 0) + use_stack_size = ETHR_MODIFIED_DEFAULT_STACK_SIZE; +#endif + + twd.initialized = 0; + twd.thr_func = func; + twd.arg = arg; + +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!tid || !func) { + ASSERT(0); + return EINVAL; + } +#endif + + /* Call prepare func if it exist */ + if (thread_create_prepare_func) + twd.prep_func_res = (*thread_create_prepare_func)(); + else + twd.prep_func_res = NULL; + + /* Set som thread attributes */ + res = pthread_attr_init(&attr); + if (res != 0) + goto cleanup_parent_func; + res = pthread_mutex_init(&twd.mtx, NULL); + if (res != 0) + goto cleanup_attr_destroy; + res = pthread_cond_init(&twd.cnd, NULL); + if (res != 0) + goto cleanup_mutex_destroy; + + /* Schedule child thread in system scope (if possible) ... */ + res = pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM); + if (res != 0 && res != ENOTSUP) + goto cleanup_cond_destroy; + + if (use_stack_size >= 0) { + size_t suggested_stack_size = (size_t) use_stack_size; + size_t stack_size; +#ifdef DEBUG + suggested_stack_size /= 2; /* Make sure we got margin */ +#endif +#ifdef ETHR_STACK_GUARD_SIZE + /* The guard is at least on some platforms included in the stack size + passed when creating threads */ + suggested_stack_size += ETHR_B2KW(ETHR_STACK_GUARD_SIZE); +#endif + if (suggested_stack_size < min_stack_size) + stack_size = ETHR_KW2B(min_stack_size); + else if (suggested_stack_size > max_stack_size) + stack_size = ETHR_KW2B(max_stack_size); + else + stack_size = ETHR_PAGE_ALIGN(ETHR_KW2B(suggested_stack_size)); + (void) pthread_attr_setstacksize(&attr, stack_size); + } + +#ifdef ETHR_STACK_GUARD_SIZE + (void) pthread_attr_setguardsize(&attr, ETHR_STACK_GUARD_SIZE); +#endif + + /* Detached or joinable... */ + res = pthread_attr_setdetachstate(&attr, + (opts && opts->detached + ? PTHREAD_CREATE_DETACHED + : PTHREAD_CREATE_JOINABLE)); + if (res != 0) + goto cleanup_cond_destroy; + + res = pthread_mutex_lock(&twd.mtx); + + if (res != 0) + goto cleanup_cond_destroy; + + safe_mutex_lock(&no_ethrs_mtx.pt_mtx); + if (no_ethreads < ETHR_MAX_THREADS) { + no_ethreads++; + safe_mutex_unlock(&no_ethrs_mtx.pt_mtx); + } + else { + res = EAGAIN; + safe_mutex_unlock(&no_ethrs_mtx.pt_mtx); + goto cleanup_mutex_unlock; + } + + res = pthread_create((pthread_t *) tid, &attr, thr_wrapper, (void *) &twd); + + if (res != 0) { + safe_mutex_lock(&no_ethrs_mtx.pt_mtx); + ASSERT(no_ethreads > 0); + no_ethreads--; + safe_mutex_unlock(&no_ethrs_mtx.pt_mtx); + } + else { + + /* Wait for child to initialize... */ + while (!twd.initialized) { + res = pthread_cond_wait(&twd.cnd, &twd.mtx); + if (res != 0 && res != EINTR) + break; + } + + } + + /* Cleanup... */ + cleanup_mutex_unlock: + dres = pthread_mutex_unlock(&twd.mtx); + if (res == 0) + res = dres; + cleanup_cond_destroy: + dres = pthread_cond_destroy(&twd.cnd); + if (res == 0) + res = dres; + cleanup_mutex_destroy: + dres = pthread_mutex_destroy(&twd.mtx); + if (res == 0) + res = dres; + cleanup_attr_destroy: + dres = pthread_attr_destroy(&attr); + if (res == 0) + res = dres; + cleanup_parent_func: + if (thread_create_parent_func) + (*thread_create_parent_func)(twd.prep_func_res); + + return res; +} + +int +ethr_thr_join(ethr_tid tid, void **res) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } +#endif + return pthread_join((pthread_t) tid, res); +} + +int +ethr_thr_detach(ethr_tid tid) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } +#endif + return pthread_detach((pthread_t) tid); +} + +void +ethr_thr_exit(void *res) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return; + } +#endif + thr_exit_cleanup(); + pthread_exit(res); +} + +ethr_tid +ethr_self(void) +{ + return (ethr_tid) pthread_self(); +} + +int +ethr_equal_tids(ethr_tid tid1, ethr_tid tid2) +{ + return pthread_equal((pthread_t) tid1, (pthread_t) tid2); +} + + +/* + * Mutex functions + */ + + +int +ethr_mutex_init(ethr_mutex *mtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx) { + ASSERT(0); + return EINVAL; + } + mtx->initialized = ETHR_MUTEX_INITIALIZED; +#endif + mtx->prev = NULL; + mtx->next = NULL; + mtx->is_rec_mtx = 0; + return pthread_mutex_init(&mtx->pt_mtx, NULL); +} + +#ifdef ETHR_HAVE_ETHR_REC_MUTEX_INIT + +int +ethr_rec_mutex_init(ethr_mutex *mtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx) { + ASSERT(0); + return EINVAL; + } + mtx->initialized = ETHR_MUTEX_INITIALIZED; +#endif + if (rec_mtx_attr_need_init) + init_rec_mtx_attr(); + + mtx->prev = NULL; + mtx->next = NULL; + mtx->is_rec_mtx = 1; + return pthread_mutex_init(&mtx->pt_mtx, &rec_mtx_attr); +} + +#endif /* #if ETHR_HAVE_ETHR_REC_MUTEX_INIT */ + +int +ethr_mutex_destroy(ethr_mutex *mtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx || mtx->initialized != ETHR_MUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + if (mtx->next) { + ASSERT(mtx->prev); + ethr_mutex_unset_forksafe(mtx); + } +#if ETHR_XCHK + mtx->initialized = 0; +#endif + return pthread_mutex_destroy(&mtx->pt_mtx); +} + +int ethr_mutex_set_forksafe(ethr_mutex *mtx) +{ + int res; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx || mtx->initialized != ETHR_MUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif +#if ETHR_HAVE_PTHREAD_ATFORK + res = pthread_mutex_lock(&forksafe_mtx.pt_mtx); + if (res != 0) + return res; + if (!forksafe_mtx.next) { + ASSERT(!forksafe_mtx.prev); + init_forksafe(); + } + if (mtx->next) { + /* forksafe already set for this mutex */ + ASSERT(mtx->prev); + } + else { + mtx->next = forksafe_mtx.next; + mtx->prev = &forksafe_mtx; + forksafe_mtx.next->prev = mtx; + forksafe_mtx.next = mtx; + } + + res = pthread_mutex_unlock(&forksafe_mtx.pt_mtx); + +#else /* #if ETHR_HAVE_PTHREAD_ATFORK */ + res = ENOTSUP; +#endif /* #if ETHR_HAVE_PTHREAD_ATFORK */ + return res; +} + +int ethr_mutex_unset_forksafe(ethr_mutex *mtx) +{ + int res; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx || mtx->initialized != ETHR_MUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif +#if ETHR_HAVE_PTHREAD_ATFORK + res = pthread_mutex_lock(&forksafe_mtx.pt_mtx); + if (res != 0) + return res; + if (!forksafe_mtx.next) { + ASSERT(!forksafe_mtx.prev); + init_forksafe(); + } + if (!mtx->next) { + /* forksafe already unset for this mutex */ + ASSERT(!mtx->prev); + } + else { + mtx->prev->next = mtx->next; + mtx->next->prev = mtx->prev; + mtx->next = NULL; + mtx->prev = NULL; + } + res = pthread_mutex_unlock(&forksafe_mtx.pt_mtx); + +#else /* #if ETHR_HAVE_PTHREAD_ATFORK */ + res = ENOTSUP; +#endif /* #if ETHR_HAVE_PTHREAD_ATFORK */ + return res; +} + +int +ethr_mutex_trylock(ethr_mutex *mtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx || mtx->initialized != ETHR_MUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_mutex_trylock__(mtx); +} + +int +ethr_mutex_lock(ethr_mutex *mtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx || mtx->initialized != ETHR_MUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_mutex_lock__(mtx); +} + +int +ethr_mutex_unlock(ethr_mutex *mtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx || mtx->initialized != ETHR_MUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_mutex_unlock__(mtx); +} + +/* + * Condition variable functions + */ + +int +ethr_cond_init(ethr_cond *cnd) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!cnd) { + ASSERT(0); + return EINVAL; + } + cnd->initialized = ETHR_COND_INITIALIZED; +#endif + return pthread_cond_init(&cnd->pt_cnd, NULL); +} + +int +ethr_cond_destroy(ethr_cond *cnd) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!cnd || cnd->initialized != ETHR_COND_INITIALIZED) { + ASSERT(0); + return EINVAL; + } + cnd->initialized = 0; +#endif + return pthread_cond_destroy(&cnd->pt_cnd); +} + +int +ethr_cond_signal(ethr_cond *cnd) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!cnd || cnd->initialized != ETHR_COND_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return pthread_cond_signal(&cnd->pt_cnd); +} + +int +ethr_cond_broadcast(ethr_cond *cnd) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!cnd || cnd->initialized != ETHR_COND_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return pthread_cond_broadcast(&cnd->pt_cnd); +} + +int +ethr_cond_wait(ethr_cond *cnd, ethr_mutex *mtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!cnd + || cnd->initialized != ETHR_COND_INITIALIZED + || !mtx + || mtx->initialized != ETHR_MUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return pthread_cond_wait(&cnd->pt_cnd, &mtx->pt_mtx); +} + +int +ethr_cond_timedwait(ethr_cond *cnd, ethr_mutex *mtx, ethr_timeval *timeout) +{ + struct timespec to; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!cnd + || cnd->initialized != ETHR_COND_INITIALIZED + || !mtx + || mtx->initialized != ETHR_MUTEX_INITIALIZED + || !timeout) { + ASSERT(0); + return EINVAL; + } +#endif + + to.tv_sec = timeout->tv_sec; + to.tv_nsec = timeout->tv_nsec; + + return pthread_cond_timedwait(&cnd->pt_cnd, &mtx->pt_mtx, &to); +} + + +#ifdef ETHR_HAVE_PTHREAD_RWLOCK_INIT + +int +ethr_rwmutex_init(ethr_rwmutex *rwmtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!rwmtx) { + ASSERT(0); + return EINVAL; + } + rwmtx->initialized = ETHR_RWMUTEX_INITIALIZED; +#endif + return pthread_rwlock_init(&rwmtx->pt_rwlock, NULL); +} + +int +ethr_rwmutex_destroy(ethr_rwmutex *rwmtx) +{ + int res; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + res = pthread_rwlock_destroy(&rwmtx->pt_rwlock); +#if ETHR_XCHK + rwmtx->initialized = 0; +#endif + return res; +} + +int +ethr_rwmutex_tryrlock(ethr_rwmutex *rwmtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_rwmutex_tryrlock__(rwmtx); +} + +int +ethr_rwmutex_rlock(ethr_rwmutex *rwmtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_rwmutex_rlock__(rwmtx); +} + +int +ethr_rwmutex_runlock(ethr_rwmutex *rwmtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_rwmutex_runlock__(rwmtx); +} + +int +ethr_rwmutex_tryrwlock(ethr_rwmutex *rwmtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_rwmutex_tryrwlock__(rwmtx); +} + +int +ethr_rwmutex_rwlock(ethr_rwmutex *rwmtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_rwmutex_rwlock__(rwmtx); +} + +int +ethr_rwmutex_rwunlock(ethr_rwmutex *rwmtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_rwmutex_rwunlock__(rwmtx); +} + +#endif /* #ifdef ETHR_HAVE_PTHREAD_RWLOCK_INIT */ + +/* + * Current time + */ + +int +ethr_time_now(ethr_timeval *time) +{ + int res; + struct timeval tv; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!time) { + ASSERT(0); + return EINVAL; + } +#endif + + res = gettimeofday(&tv, NULL); + time->tv_sec = (long) tv.tv_sec; + time->tv_nsec = ((long) tv.tv_usec)*1000; + return res; +} + +/* + * Thread specific data + */ + +int +ethr_tsd_key_create(ethr_tsd_key *keyp) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!keyp) { + ASSERT(0); + return EINVAL; + } +#endif + return pthread_key_create((pthread_key_t *) keyp, NULL); +} + +int +ethr_tsd_key_delete(ethr_tsd_key key) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } +#endif + return pthread_key_delete((pthread_key_t) key); +} + +int +ethr_tsd_set(ethr_tsd_key key, void *value) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } +#endif + return pthread_setspecific((pthread_key_t) key, value); +} + +void * +ethr_tsd_get(ethr_tsd_key key) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return NULL; + } +#endif + return pthread_getspecific((pthread_key_t) key); +} + +/* + * Signal functions + */ + +#if ETHR_HAVE_ETHR_SIG_FUNCS + +int ethr_sigmask(int how, const sigset_t *set, sigset_t *oset) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!set && !oset) { + ASSERT(0); + return EINVAL; + } +#endif + return pthread_sigmask(how, set, oset); +} + +int ethr_sigwait(const sigset_t *set, int *sig) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!set || !sig) { + ASSERT(0); + return EINVAL; + } +#endif + if (sigwait(set, sig) < 0) + return errno; + return 0; +} + +#endif /* #if ETHR_HAVE_ETHR_SIG_FUNCS */ + +#elif defined(ETHR_WIN32_THREADS) +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\ + * Native win32 threads implementation * +\* */ + +#define INVALID_TID -1 + +/* The spin count values are more or less taken out of the blue */ +#define ETHR_MUTEX_SPIN_COUNT 5000 +#define ETHR_COND_SPIN_COUNT 1000 + +ethr_tid serial_shift; /* Bits to shift serial when constructing a tid */ +ethr_tid last_serial; /* Last thread table serial used */ +ethr_tid last_ix; /* Last thread table index used */ +ethr_tid thr_ix_mask; /* Mask used to mask out thread table index from a tid */ + +/* Event used for conditional variables. On per thread. */ +/*typedef struct cnd_wait_event__ cnd_wait_event_;*/ +struct cnd_wait_event__ { + HANDLE handle; + cnd_wait_event_ *prev; + cnd_wait_event_ *next; + int in_queue; +}; + +/* Thread specific data. Stored in the thread table */ +typedef struct { + ethr_tid thr_id; + HANDLE thr_handle; + ethr_tid joiner; + void *result; + cnd_wait_event_ wait_event; +} thr_data_; + +/* Argument passed to thr_wrapper() */ +typedef struct { + void * (*func)(void *); + void * arg; + thr_data_ *ptd; + thr_data_ *td; + int res; + void *prep_func_res; +} thr_wrap_data_; + + +static CRITICAL_SECTION thr_table_cs; /* Critical section used to protect + the thread table from concurrent + accesses. */ +static CRITICAL_SECTION fake_static_init_cs; /* Critical section used to protect + initialazition of 'statically + initialized' mutexes */ +static thr_data_ * thr_table[ETHR_MAX_THREADS]; /* The thread table */ + +static DWORD tls_own_thr_data; + +static thr_data_ main_thr_data; + +#define THR_IX(TID) ((TID) & thr_ix_mask) +#define OWN_THR_DATA ((thr_data_ *) TlsGetValue(tls_own_thr_data)) + +/* + * ---------------------------------------------------------------------------- + * Static functions + * ---------------------------------------------------------------------------- + */ + +static int +get_errno(void) +{ + switch (GetLastError()) { + case ERROR_INVALID_FUNCTION: return EINVAL; /* 1 */ + case ERROR_FILE_NOT_FOUND: return ENOENT; /* 2 */ + case ERROR_PATH_NOT_FOUND: return ENOENT; /* 3 */ + case ERROR_TOO_MANY_OPEN_FILES: return EMFILE; /* 4 */ + case ERROR_ACCESS_DENIED: return EACCES; /* 5 */ + case ERROR_INVALID_HANDLE: return EBADF; /* 6 */ + case ERROR_ARENA_TRASHED: return ENOMEM; /* 7 */ + case ERROR_NOT_ENOUGH_MEMORY: return ENOMEM; /* 8 */ + case ERROR_INVALID_BLOCK: return ENOMEM; /* 9 */ + case ERROR_BAD_ENVIRONMENT: return E2BIG; /* 10 */ + case ERROR_BAD_FORMAT: return ENOEXEC; /* 11 */ + case ERROR_INVALID_ACCESS: return EINVAL; /* 12 */ + case ERROR_INVALID_DATA: return EINVAL; /* 13 */ + case ERROR_OUTOFMEMORY: return ENOMEM; /* 14 */ + case ERROR_INVALID_DRIVE: return ENOENT; /* 15 */ + case ERROR_CURRENT_DIRECTORY: return EACCES; /* 16 */ + case ERROR_NOT_SAME_DEVICE: return EXDEV; /* 17 */ + case ERROR_NO_MORE_FILES: return ENOENT; /* 18 */ + case ERROR_WRITE_PROTECT: return EACCES; /* 19 */ + case ERROR_BAD_UNIT: return EACCES; /* 20 */ + case ERROR_NOT_READY: return EACCES; /* 21 */ + case ERROR_BAD_COMMAND: return EACCES; /* 22 */ + case ERROR_CRC: return EACCES; /* 23 */ + case ERROR_BAD_LENGTH: return EACCES; /* 24 */ + case ERROR_SEEK: return EACCES; /* 25 */ + case ERROR_NOT_DOS_DISK: return EACCES; /* 26 */ + case ERROR_SECTOR_NOT_FOUND: return EACCES; /* 27 */ + case ERROR_OUT_OF_PAPER: return EACCES; /* 28 */ + case ERROR_WRITE_FAULT: return EACCES; /* 29 */ + case ERROR_READ_FAULT: return EACCES; /* 30 */ + case ERROR_GEN_FAILURE: return EACCES; /* 31 */ + case ERROR_SHARING_VIOLATION: return EACCES; /* 32 */ + case ERROR_LOCK_VIOLATION: return EACCES; /* 33 */ + case ERROR_WRONG_DISK: return EACCES; /* 34 */ + case ERROR_SHARING_BUFFER_EXCEEDED: return EACCES; /* 36 */ + case ERROR_BAD_NETPATH: return ENOENT; /* 53 */ + case ERROR_NETWORK_ACCESS_DENIED: return EACCES; /* 65 */ + case ERROR_BAD_NET_NAME: return ENOENT; /* 67 */ + case ERROR_FILE_EXISTS: return EEXIST; /* 80 */ + case ERROR_CANNOT_MAKE: return EACCES; /* 82 */ + case ERROR_FAIL_I24: return EACCES; /* 83 */ + case ERROR_INVALID_PARAMETER: return EINVAL; /* 87 */ + case ERROR_NO_PROC_SLOTS: return EAGAIN; /* 89 */ + case ERROR_DRIVE_LOCKED: return EACCES; /* 108 */ + case ERROR_BROKEN_PIPE: return EPIPE; /* 109 */ + case ERROR_DISK_FULL: return ENOSPC; /* 112 */ + case ERROR_INVALID_TARGET_HANDLE: return EBADF; /* 114 */ + case ERROR_WAIT_NO_CHILDREN: return ECHILD; /* 128 */ + case ERROR_CHILD_NOT_COMPLETE: return ECHILD; /* 129 */ + case ERROR_DIRECT_ACCESS_HANDLE: return EBADF; /* 130 */ + case ERROR_NEGATIVE_SEEK: return EINVAL; /* 131 */ + case ERROR_SEEK_ON_DEVICE: return EACCES; /* 132 */ + case ERROR_DIR_NOT_EMPTY: return ENOTEMPTY;/* 145 */ + case ERROR_NOT_LOCKED: return EACCES; /* 158 */ + case ERROR_BAD_PATHNAME: return ENOENT; /* 161 */ + case ERROR_MAX_THRDS_REACHED: return EAGAIN; /* 164 */ + case ERROR_LOCK_FAILED: return EACCES; /* 167 */ + case ERROR_ALREADY_EXISTS: return EEXIST; /* 183 */ + case ERROR_INVALID_STARTING_CODESEG: return ENOEXEC; /* 188 */ + case ERROR_INVALID_STACKSEG: return ENOEXEC; /* 189 */ + case ERROR_INVALID_MODULETYPE: return ENOEXEC; /* 190 */ + case ERROR_INVALID_EXE_SIGNATURE: return ENOEXEC; /* 191 */ + case ERROR_EXE_MARKED_INVALID: return ENOEXEC; /* 192 */ + case ERROR_BAD_EXE_FORMAT: return ENOEXEC; /* 193 */ + case ERROR_ITERATED_DATA_EXCEEDS_64k: return ENOEXEC; /* 194 */ + case ERROR_INVALID_MINALLOCSIZE: return ENOEXEC; /* 195 */ + case ERROR_DYNLINK_FROM_INVALID_RING: return ENOEXEC; /* 196 */ + case ERROR_IOPL_NOT_ENABLED: return ENOEXEC; /* 197 */ + case ERROR_INVALID_SEGDPL: return ENOEXEC; /* 198 */ + case ERROR_AUTODATASEG_EXCEEDS_64k: return ENOEXEC; /* 199 */ + case ERROR_RING2SEG_MUST_BE_MOVABLE: return ENOEXEC; /* 200 */ + case ERROR_RELOC_CHAIN_XEEDS_SEGLIM: return ENOEXEC; /* 201 */ + case ERROR_INFLOOP_IN_RELOC_CHAIN: return ENOEXEC; /* 202 */ + case ERROR_FILENAME_EXCED_RANGE: return ENOENT; /* 206 */ + case ERROR_NESTING_NOT_ALLOWED: return EAGAIN; /* 215 */ + case ERROR_NOT_ENOUGH_QUOTA: return ENOMEM; /* 1816 */ + default: return EINVAL; + } +} + +static ETHR_INLINE thr_data_ * +tid2thr(ethr_tid tid) +{ + ethr_tid ix; + thr_data_ *td; + + if (tid < 0) + return NULL; + ix = THR_IX(tid); + if (ix >= ETHR_MAX_THREADS) + return NULL; + td = thr_table[ix]; + if (!td) + return NULL; + if (td->thr_id != tid) + return NULL; + return td; +} + +static ETHR_INLINE void +new_tid(ethr_tid *new_tid, ethr_tid *new_serial, ethr_tid *new_ix) +{ + ethr_tid tmp_serial = last_serial; + ethr_tid tmp_ix = last_ix + 1; + ethr_tid start_ix = tmp_ix; + + + do { + if (tmp_ix >= ETHR_MAX_THREADS) { + tmp_serial++; + if ((tmp_serial << serial_shift) < 0) + tmp_serial = 0; + tmp_ix = 0; + } + if (!thr_table[tmp_ix]) { + *new_tid = (tmp_serial << serial_shift) | tmp_ix; + *new_serial = tmp_serial; + *new_ix = tmp_ix; + return; + } + tmp_ix++; + } while (tmp_ix != start_ix); + + *new_tid = INVALID_TID; + *new_serial = INVALID_TID; + *new_ix = INVALID_TID; + +} + + +static void thr_exit_cleanup(thr_data_ *td, void *res) +{ + + ASSERT(td == OWN_THR_DATA); + + run_exit_handlers(); + + EnterCriticalSection(&thr_table_cs); + CloseHandle(td->wait_event.handle); + if (td->thr_handle == INVALID_HANDLE_VALUE) { + /* We are detached; cleanup thread table */ + ASSERT(td->joiner == INVALID_TID); + ASSERT(td == thr_table[THR_IX(td->thr_id)]); + thr_table[THR_IX(td->thr_id)] = NULL; + if (td != &main_thr_data) + (*freep)((void *) td); + } + else { + /* Save result and let joining thread cleanup */ + td->result = res; + } + LeaveCriticalSection(&thr_table_cs); +} + +static unsigned __stdcall thr_wrapper(LPVOID args) +{ + void *(*func)(void*) = ((thr_wrap_data_ *) args)->func; + void *arg = ((thr_wrap_data_ *) args)->arg; + thr_data_ *td = ((thr_wrap_data_ *) args)->td; + + td->wait_event.handle = CreateEvent(NULL, FALSE, FALSE, NULL); + if (td->wait_event.handle == INVALID_HANDLE_VALUE + || !TlsSetValue(tls_own_thr_data, (LPVOID) td)) { + ((thr_wrap_data_ *) args)->res = get_errno(); + if (td->wait_event.handle != INVALID_HANDLE_VALUE) + CloseHandle(td->wait_event.handle); + SetEvent(((thr_wrap_data_ *) args)->ptd->wait_event.handle); + _endthreadex((unsigned) 0); + ASSERT(0); + } + + td->wait_event.prev = NULL; + td->wait_event.next = NULL; + td->wait_event.in_queue = 0; + + if (thread_create_child_func) + (*thread_create_child_func)(((thr_wrap_data_ *) args)->prep_func_res); + + ASSERT(td == OWN_THR_DATA); + + ((thr_wrap_data_ *) args)->res = 0; + SetEvent(((thr_wrap_data_ *) args)->ptd->wait_event.handle); + + thr_exit_cleanup(td, (*func)(arg)); + return 0; +} + +int +ethr_fake_static_mutex_init(ethr_mutex *mtx) +{ + EnterCriticalSection((CRITICAL_SECTION *) &fake_static_init_cs); + /* Got here under race conditions; check again... */ + if (!mtx->initialized) { + if (!InitializeCriticalSectionAndSpinCount(&mtx->cs, + ETHR_MUTEX_SPIN_COUNT)) + return get_errno(); + mtx->initialized = ETHR_MUTEX_INITIALIZED; + } + LeaveCriticalSection((CRITICAL_SECTION *) &fake_static_init_cs); + return 0; +} + +static int +fake_static_cond_init(ethr_cond *cnd) +{ + EnterCriticalSection((CRITICAL_SECTION *) &fake_static_init_cs); + /* Got here under race conditions; check again... */ + if (!cnd->initialized) { + if (!InitializeCriticalSectionAndSpinCount(&cnd->cs, + ETHR_COND_SPIN_COUNT)) + return get_errno(); + cnd->queue = NULL; + cnd->queue_end = NULL; + cnd->initialized = ETHR_COND_INITIALIZED; + } + LeaveCriticalSection((CRITICAL_SECTION *) &fake_static_init_cs); + return 0; +} + +#ifdef __GNUC__ +#define LL_LITERAL(X) X##LL +#else +#define LL_LITERAL(X) X##i64 +#endif + +#define EPOCH_JULIAN_DIFF LL_LITERAL(11644473600) + +static ETHR_INLINE void +get_curr_time(long *sec, long *nsec) +{ + SYSTEMTIME t; + FILETIME ft; + LONGLONG lft; + + GetSystemTime(&t); + SystemTimeToFileTime(&t, &ft); + memcpy(&lft, &ft, sizeof(lft)); + *nsec = ((long) (lft % LL_LITERAL(10000000)))*100; + *sec = (long) ((lft / LL_LITERAL(10000000)) - EPOCH_JULIAN_DIFF); +} + +static cnd_wait_event_ *cwe_freelist; +static CRITICAL_SECTION cwe_cs; + +static int +alloc_cwe(cnd_wait_event_ **cwe_res) +{ + cnd_wait_event_ *cwe; + EnterCriticalSection(&cwe_cs); + cwe = cwe_freelist; + if (cwe) { + cwe_freelist = cwe->next; + LeaveCriticalSection(&cwe_cs); + } + else { + LeaveCriticalSection(&cwe_cs); + cwe = (*allocp)(sizeof(cnd_wait_event_)); + if (!cwe) + return ENOMEM; + cwe->handle = CreateEvent(NULL, FALSE, FALSE, NULL); + if (cwe->handle == INVALID_HANDLE_VALUE) { + int res = get_errno(); + (*freep)(cwe); + return res; + } + } + *cwe_res = cwe; + return 0; +} + +static +free_cwe(cnd_wait_event_ *cwe) +{ + EnterCriticalSection(&cwe_cs); + cwe->next = cwe_freelist; + cwe_freelist = cwe; + LeaveCriticalSection(&cwe_cs); +} + +static ETHR_INLINE int +condwait(ethr_cond *cnd, + ethr_mutex *mtx, + int with_timeout, + ethr_timeval *timeout) +{ + int res; + thr_data_ *td; + cnd_wait_event_ *cwe; + DWORD code; + long time; /* time until timeout in milli seconds */ + +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + + if (!mtx + || mtx->initialized != ETHR_MUTEX_INITIALIZED + || !cnd + || (cnd->initialized && cnd->initialized != ETHR_COND_INITIALIZED) + || (with_timeout && !timeout)) { + ASSERT(0); + return EINVAL; + } +#endif + + td = OWN_THR_DATA; + if (td) + cwe = &td->wait_event; + else { /* A non-ethread thread */ + res = alloc_cwe(&cwe); + if (res != 0) + return res; + } + + if (!cnd->initialized) + fake_static_cond_init(cnd); + EnterCriticalSection(&cnd->cs); + + ASSERT(!cwe->in_queue); + if (cnd->queue_end) { + ASSERT(cnd->queue); + cwe->prev = cnd->queue_end; + cwe->next = NULL; + cnd->queue_end->next = cwe; + cnd->queue_end = cwe; + } + else { + ASSERT(!cnd->queue); + cwe->prev = NULL; + cwe->next = NULL; + cnd->queue = cwe; + cnd->queue_end = cwe; + } + cwe->in_queue = 1; + + LeaveCriticalSection(&cnd->cs); + + LeaveCriticalSection(&mtx->cs); + + if (!with_timeout) + time = INFINITE; + else { + long sec, nsec; + ASSERT(timeout); + get_curr_time(&sec, &nsec); + time = (timeout->tv_sec - sec)*1000; + time += (timeout->tv_nsec - nsec + 500)/1000000; + if (time < 0) + time = 0; + } + + /* wait for event to signal */ + code = WaitForSingleObject(cwe->handle, time); + + EnterCriticalSection(&mtx->cs); + + if (code == WAIT_OBJECT_0) { + /* We were woken by a signal or a broadcast ... */ + res = 0; + + /* ... no need to remove event from wait queue since this was + taken care of by the signal or broadcast */ +#ifdef DEBUG + EnterCriticalSection(&cnd->cs); + ASSERT(!cwe->in_queue); + LeaveCriticalSection(&cnd->cs); +#endif + + } + else { + /* We timed out... */ + res = ETIMEDOUT; + + /* ... probably have to remove event from wait queue ... */ + EnterCriticalSection(&cnd->cs); + + if (cwe->in_queue) { /* ... but we must check that we are in queue + since a signal or broadcast after timeout + may have removed us from the queue */ + if (cwe->prev) { + cwe->prev->next = cwe->next; + } + else { + ASSERT(cnd->queue == cwe); + cnd->queue = cwe->next; + } + + if (cwe->next) { + cwe->next->prev = cwe->prev; + } + else { + ASSERT(cnd->queue_end == cwe); + cnd->queue_end = cwe->prev; + } + cwe->in_queue = 0; + } + + LeaveCriticalSection(&cnd->cs); + + } + + if (!td) + free_cwe(cwe); + + return res; + +} + + +/* + * ---------------------------------------------------------------------------- + * Exported functions + * ---------------------------------------------------------------------------- + */ + +int +ethr_init(ethr_init_data *id) +{ +#ifdef _WIN32_WINNT + DWORD major = (_WIN32_WINNT >> 8) & 0xff; + DWORD minor = _WIN32_WINNT & 0xff; + OSVERSIONINFO os_version; +#endif + int err = 0; + thr_data_ *td = &main_thr_data; + unsigned long i; + + if (!ethr_not_inited) + return EINVAL; + +#ifdef _WIN32_WINNT + os_version.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + GetVersionEx(&os_version); + if (os_version.dwPlatformId != VER_PLATFORM_WIN32_NT + || os_version.dwMajorVersion < major + || (os_version.dwMajorVersion == major + && os_version.dwMinorVersion < minor)) + return ENOTSUP; +#endif + + ASSERT(ETHR_MAX_THREADS > 0); + for (i = ETHR_MAX_THREADS - 1, serial_shift = 0; + i; + serial_shift++, i >>= 1); + thr_ix_mask = ~(~((ethr_tid) 0) << serial_shift); + + tls_own_thr_data = TlsAlloc(); + if (tls_own_thr_data == TLS_OUT_OF_INDEXES) + goto error; + + last_serial = 0; + last_ix = 0; + + td->thr_id = 0; + td->thr_handle = GetCurrentThread(); + td->joiner = INVALID_TID; + td->result = NULL; + td->wait_event.handle = CreateEvent(NULL, FALSE, FALSE, NULL); + if (td->wait_event.handle == INVALID_HANDLE_VALUE) + goto error; + td->wait_event.prev = NULL; + td->wait_event.next = NULL; + td->wait_event.in_queue = 0; + thr_table[0] = td; + + if (!TlsSetValue(tls_own_thr_data, (LPVOID) td)) + goto error; + + ASSERT(td == OWN_THR_DATA); + + + cwe_freelist = NULL; + if (!InitializeCriticalSectionAndSpinCount(&cwe_cs, + ETHR_MUTEX_SPIN_COUNT)) + goto error; + + for (i = 1; i < ETHR_MAX_THREADS; i++) + thr_table[i] = NULL; + + if (!InitializeCriticalSectionAndSpinCount(&thr_table_cs, + ETHR_MUTEX_SPIN_COUNT)) + goto error; + if (!InitializeCriticalSectionAndSpinCount(&fake_static_init_cs, + ETHR_MUTEX_SPIN_COUNT)) + goto error; + ethr_not_inited = 0; + + err = init_common(id); + if (err) + goto error; + + return 0; + + error: + ethr_not_inited = 1; + if (err == 0) + err = get_errno(); + ASSERT(err != 0); + if (td->thr_handle != INVALID_HANDLE_VALUE) + CloseHandle(td->thr_handle); + if (td->wait_event.handle != INVALID_HANDLE_VALUE) + CloseHandle(td->wait_event.handle); + return err; +} + +/* + * Thread functions. + */ + +int +ethr_thr_create(ethr_tid *tid, void * (*func)(void *), void *arg, + ethr_thr_opts *opts) +{ + int err = 0; + thr_wrap_data_ twd; + thr_data_ *my_td, *child_td = NULL; + ethr_tid child_tid, child_serial, child_ix; + DWORD code; + unsigned ID; + unsigned stack_size = 0; /* 0 = system default */ + int use_stack_size = (opts && opts->suggested_stack_size >= 0 + ? opts->suggested_stack_size + : -1 /* Use system default */); + +#ifdef ETHR_MODIFIED_DEFAULT_STACK_SIZE + if (use_stack_size < 0) + use_stack_size = ETHR_MODIFIED_DEFAULT_STACK_SIZE; +#endif + +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!tid || !func) { + ASSERT(0); + return EINVAL; + } +#endif + + my_td = OWN_THR_DATA; + if (!my_td) { + /* Only ethreads are allowed to call this function */ + ASSERT(0); + return EACCES; + } + + if (use_stack_size >= 0) { + size_t suggested_stack_size = (size_t) use_stack_size; +#ifdef DEBUG + suggested_stack_size /= 2; /* Make sure we got margin */ +#endif + if (suggested_stack_size < min_stack_size) + stack_size = (unsigned) ETHR_KW2B(min_stack_size); + else if (suggested_stack_size > max_stack_size) + stack_size = (unsigned) ETHR_KW2B(max_stack_size); + else + stack_size = + (unsigned) ETHR_PAGE_ALIGN(ETHR_KW2B(suggested_stack_size)); + } + + EnterCriticalSection(&thr_table_cs); + + /* Call prepare func if it exist */ + if (thread_create_prepare_func) + twd.prep_func_res = (*thread_create_prepare_func)(); + else + twd.prep_func_res = NULL; + + /* Find a new thread id to use */ + new_tid(&child_tid, &child_serial, &child_ix); + if (child_tid == INVALID_TID) { + err = EAGAIN; + goto error; + } + + ASSERT(child_ix == THR_IX(child_tid)); + + *tid = child_tid; + + ASSERT(!thr_table[child_ix]); + + /* Alloc thread data */ + thr_table[child_ix] = child_td = (thr_data_ *) (*allocp)(sizeof(thr_data_)); + if (!child_td) { + err = ENOMEM; + goto error; + } + + /* Init thread data */ + + child_td->thr_id = child_tid; + child_td->thr_handle = INVALID_HANDLE_VALUE; + child_td->joiner = INVALID_TID; + child_td->result = NULL; + /* 'child_td->wait_event' is initialized by child thread */ + + + /* Init thread wrapper data */ + + twd.func = func; + twd.arg = arg; + twd.ptd = my_td; + twd.td = child_td; + twd.res = 0; + + ASSERT(!my_td->wait_event.in_queue); + + /* spawn the thr_wrapper function */ + child_td->thr_handle = (HANDLE) _beginthreadex(NULL, + stack_size, + thr_wrapper, + (LPVOID) &twd, + 0, + &ID); + if (child_td->thr_handle == (HANDLE) 0) { + child_td->thr_handle = INVALID_HANDLE_VALUE; + goto error; + } + + ASSERT(child_td->thr_handle != INVALID_HANDLE_VALUE); + + /* Wait for child to finish initialization */ + code = WaitForSingleObject(my_td->wait_event.handle, INFINITE); + if (twd.res || code != WAIT_OBJECT_0) { + err = twd.res; + goto error; + } + + if (opts && opts->detached) { + CloseHandle(child_td->thr_handle); + child_td->thr_handle = INVALID_HANDLE_VALUE; + } + + last_serial = child_serial; + last_ix = child_ix; + + ASSERT(thr_table[child_ix] == child_td); + + if (thread_create_parent_func) + (*thread_create_parent_func)(twd.prep_func_res); + + LeaveCriticalSection(&thr_table_cs); + + return 0; + + error: + + if (err == 0) + err = get_errno(); + ASSERT(err != 0); + + if (thread_create_parent_func) + (*thread_create_parent_func)(twd.prep_func_res); + + if (child_ix != INVALID_TID) { + + if (child_td) { + ASSERT(thr_table[child_ix] == child_td); + + if (child_td->thr_handle != INVALID_HANDLE_VALUE) { + WaitForSingleObject(child_td->thr_handle, INFINITE); + CloseHandle(child_td->thr_handle); + } + + (*freep)((void *) child_td); + thr_table[child_ix] = NULL; + } + } + + *tid = INVALID_TID; + + LeaveCriticalSection(&thr_table_cs); + return err; +} + +int ethr_thr_join(ethr_tid tid, void **res) +{ + int err = 0; + DWORD code; + thr_data_ *td; + thr_data_ *my_td; + +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } +#endif + + my_td = OWN_THR_DATA; + + if (!my_td) { + /* Only ethreads are allowed to call this function */ + ASSERT(0); + return EACCES; + } + + EnterCriticalSection(&thr_table_cs); + + td = tid2thr(tid); + if (!td) + err = ESRCH; + else if (td->thr_handle == INVALID_HANDLE_VALUE /* i.e. detached */ + || td->joiner != INVALID_TID) /* i.e. someone else is joining */ + err = EINVAL; + else if (my_td == td) + err = EDEADLK; + else + td->joiner = my_td->thr_id; + + LeaveCriticalSection(&thr_table_cs); + + if (err) + goto error; + + /* Wait for thread to terminate */ + code = WaitForSingleObject(td->thr_handle, INFINITE); + if (code != WAIT_OBJECT_0) + goto error; + + EnterCriticalSection(&thr_table_cs); + + ASSERT(td == tid2thr(tid)); + ASSERT(td->thr_handle != INVALID_HANDLE_VALUE); + ASSERT(td->joiner == my_td->thr_id); + + if (res) + *res = td->result; + + CloseHandle(td->thr_handle); + ASSERT(td == thr_table[THR_IX(td->thr_id)]); + thr_table[THR_IX(td->thr_id)] = NULL; + if (td != &main_thr_data) + (*freep)((void *) td); + + LeaveCriticalSection(&thr_table_cs); + + return 0; + + error: + if (err == 0) + err = get_errno(); + ASSERT(err != 0); + return err; +} + + +int +ethr_thr_detach(ethr_tid tid) +{ + int res; + DWORD code; + thr_data_ *td; + +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } +#endif + + if (!OWN_THR_DATA) { + /* Only ethreads are allowed to call this function */ + ASSERT(0); + return EACCES; + } + + EnterCriticalSection(&thr_table_cs); + + td = tid2thr(tid); + if (!td) + res = ESRCH; + if (td->thr_handle == INVALID_HANDLE_VALUE /* i.e. detached */ + || td->joiner != INVALID_TID) /* i.e. someone is joining */ + res = EINVAL; + else { + res = 0; + CloseHandle(td->thr_handle); + td->thr_handle = INVALID_HANDLE_VALUE; + } + + LeaveCriticalSection(&thr_table_cs); + + return res; +} + + +void +ethr_thr_exit(void *res) +{ + thr_data_ *td; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return; + } +#endif + td = OWN_THR_DATA; + if (!td) { + /* Only ethreads are allowed to call this function */ + ASSERT(0); + return; + } + thr_exit_cleanup(td, res); + _endthreadex((unsigned) 0); +} + +ethr_tid +ethr_self(void) +{ + thr_data_ *td; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return INVALID_TID; + } +#endif + /* It is okay for non-ethreads (i.e. native win32 threads) to call + ethr_self(). They will however be returned the INVALID_TID. */ + td = OWN_THR_DATA; + if (!td) + return INVALID_TID; + return td->thr_id; +} + +int +ethr_equal_tids(ethr_tid tid1, ethr_tid tid2) +{ + /* INVALID_TID does not equal any tid, not even the INVALID_TID */ + return tid1 == tid2 && tid1 != INVALID_TID; +} + +/* + * Mutex functions. + */ + +int +ethr_mutex_init(ethr_mutex *mtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx) { + ASSERT(0); + return EINVAL; + } +#endif + if (!InitializeCriticalSectionAndSpinCount(&mtx->cs, ETHR_MUTEX_SPIN_COUNT)) + return get_errno(); + mtx->initialized = ETHR_MUTEX_INITIALIZED; +#if ETHR_XCHK + mtx->is_rec_mtx = 0; +#endif + return 0; +} + +int +ethr_rec_mutex_init(ethr_mutex *mtx) +{ + int res; + res = ethr_mutex_init(mtx); +#if ETHR_XCHK + mtx->is_rec_mtx = 1; +#endif + return res; +} + +int +ethr_mutex_destroy(ethr_mutex *mtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx || mtx->initialized != ETHR_MUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + DeleteCriticalSection(&mtx->cs); + mtx->initialized = 0; + return 0; +} + +int ethr_mutex_set_forksafe(ethr_mutex *mtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } +#endif + return 0; /* No fork() */ +} + +int ethr_mutex_unset_forksafe(ethr_mutex *mtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } +#endif + return 0; /* No fork() */ +} + +int +ethr_mutex_trylock(ethr_mutex *mtx) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx + || (mtx->initialized && mtx->initialized != ETHR_MUTEX_INITIALIZED)) { + ASSERT(0); + return EINVAL; + } +#endif + if (!mtx->initialized) { + int res = ethr_fake_static_mutex_init(mtx); + if (res != 0) + return res; + } + return ethr_mutex_trylock__(mtx); +} + +int +ethr_mutex_lock(ethr_mutex *mtx) +{ + int res; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx + || (mtx->initialized && mtx->initialized != ETHR_MUTEX_INITIALIZED)) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_mutex_lock__(mtx); +} + +int +ethr_mutex_unlock(ethr_mutex *mtx) +{ +#if ETHR_XCHK + int res; + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!mtx || mtx->initialized != ETHR_MUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_mutex_unlock__(mtx); +} + +/* + * Condition variable functions. + */ + +int +ethr_cond_init(ethr_cond *cnd) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!cnd) { + ASSERT(0); + return EINVAL; + } +#endif + if (!InitializeCriticalSectionAndSpinCount(&cnd->cs, ETHR_COND_SPIN_COUNT)) + return get_errno(); + cnd->queue = NULL; + cnd->queue_end = NULL; + cnd->initialized = ETHR_COND_INITIALIZED; + return 0; +} + +int +ethr_cond_destroy(ethr_cond *cnd) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!cnd + || (cnd->initialized && cnd->initialized != ETHR_COND_INITIALIZED) + || cnd->queue) { + ASSERT(0); + return EINVAL; + } +#endif + DeleteCriticalSection(&cnd->cs); + cnd->initialized = 0; + return 0; +} + +int +ethr_cond_signal(ethr_cond *cnd) +{ + cnd_wait_event_ *cwe; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!cnd + || (cnd->initialized && cnd->initialized != ETHR_COND_INITIALIZED)) { + ASSERT(0); + return EINVAL; + } +#endif + if (!cnd->initialized) { + int res = fake_static_cond_init(cnd); + if (res != 0) + return res; + } + EnterCriticalSection(&cnd->cs); + cwe = cnd->queue; + if (cwe) { + ASSERT(cwe->in_queue); + SetEvent(cnd->queue->handle); + if (cwe->next) + cwe->next->prev = NULL; + else { + ASSERT(cnd->queue_end == cnd->queue); + cnd->queue_end = NULL; + } + cnd->queue = cwe->next; + cwe->in_queue = 0; + } + LeaveCriticalSection(&cnd->cs); + return 0; +} + +int +ethr_cond_broadcast(ethr_cond *cnd) +{ + cnd_wait_event_ *cwe; + +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!cnd + || (cnd->initialized && cnd->initialized != ETHR_COND_INITIALIZED)) { + ASSERT(0); + return EINVAL; + } +#endif + if (!cnd->initialized) { + int res = fake_static_cond_init(cnd); + if (res != 0) + return res; + } + EnterCriticalSection(&cnd->cs); + for (cwe = cnd->queue; cwe; cwe = cwe->next) { + ASSERT(cwe->in_queue); + SetEvent(cwe->handle); + cwe->in_queue = 0; + } + cnd->queue = NULL; + cnd->queue_end = NULL; + LeaveCriticalSection(&cnd->cs); + return 0; + +} + +int +ethr_cond_wait(ethr_cond *cnd, ethr_mutex *mtx) +{ + return condwait(cnd, mtx, 0, NULL); +} + +int +ethr_cond_timedwait(ethr_cond *cnd, ethr_mutex *mtx, ethr_timeval *timeout) +{ + return condwait(cnd, mtx, 1, timeout); +} + +int +ethr_time_now(ethr_timeval *time) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!time) { + ASSERT(0); + return EINVAL; + } +#endif + get_curr_time(&time->tv_sec, &time->tv_nsec); + return 0; +} + +/* + * Thread specific data + */ + +int +ethr_tsd_key_create(ethr_tsd_key *keyp) +{ + DWORD key; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!keyp) { + ASSERT(0); + return EINVAL; + } +#endif + key = TlsAlloc(); + if (key == TLS_OUT_OF_INDEXES) + return get_errno(); + *keyp = (ethr_tsd_key) key; + return 0; +} + +int +ethr_tsd_key_delete(ethr_tsd_key key) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } +#endif + if (!TlsFree((DWORD) key)) + return get_errno(); + return 0; +} + +int +ethr_tsd_set(ethr_tsd_key key, void *value) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } +#endif + if (!TlsSetValue((DWORD) key, (LPVOID) value)) + return get_errno(); + return 0; +} + +void * +ethr_tsd_get(ethr_tsd_key key) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return NULL; + } +#endif + return (void *) TlsGetValue((DWORD) key); +} + +/* Misc */ + +#ifndef ETHR_HAVE_OPTIMIZED_LOCKS + +int +ethr_do_spinlock_init(ethr_spinlock_t *lock) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!lock) { + ASSERT(0); + return EINVAL; + } +#endif + if (InitializeCriticalSectionAndSpinCount(&lock->cs, INT_MAX)) + return 0; + else + return get_errno(); +} + +int +ethr_do_rwlock_init(ethr_rwlock_t *lock) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!lock) { + ASSERT(0); + return EINVAL; + } +#endif + lock->counter = 0; + if (InitializeCriticalSectionAndSpinCount(&lock->cs, INT_MAX)) + return 0; + else + return get_errno(); +} + +#endif /* #ifndef ETHR_HAVE_OPTIMIZED_ATOMIC_OPS */ + +#else +#error "Missing thread implementation" +#endif + +/* Atomics */ + +int +ethr_atomic_init(ethr_atomic_t *var, long i) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!var) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_init__(var, i); +} + +int +ethr_atomic_set(ethr_atomic_t *var, long i) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!var) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_set__(var, i); +} + +int +ethr_atomic_read(ethr_atomic_t *var, long *i) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!var || !i) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_read__(var, i); +} + + +int +ethr_atomic_addtest(ethr_atomic_t *var, long incr, long *testp) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!var || !testp) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_addtest__(var, incr, testp); +} + +int +ethr_atomic_inctest(ethr_atomic_t *incp, long *testp) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!incp || !testp) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_inctest__(incp, testp); +} + +int +ethr_atomic_dectest(ethr_atomic_t *decp, long *testp) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!decp || !testp) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_dectest__(decp, testp); +} + +int +ethr_atomic_add(ethr_atomic_t *var, long incr) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!var) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_add__(var, incr); +} + +int +ethr_atomic_inc(ethr_atomic_t *incp) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!incp) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_inc__(incp); +} + +int +ethr_atomic_dec(ethr_atomic_t *decp) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!decp) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_dec__(decp); +} + +int +ethr_atomic_and_old(ethr_atomic_t *var, long mask, long *old) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!var || !old) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_and_old__(var, mask, old); +} + +int +ethr_atomic_or_old(ethr_atomic_t *var, long mask, long *old) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!var || !old) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_or_old__(var, mask, old); +} + +int +ethr_atomic_xchg(ethr_atomic_t *var, long new, long *old) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!var || !old) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_xchg__(var, new, old); +} + +int +ethr_atomic_cmpxchg(ethr_atomic_t *var, long new, long expected, long *old) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!var || !old) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_atomic_cmpxchg__(var, new, expected, old); +} + +/* Spinlocks and rwspinlocks */ + +int +ethr_spinlock_init(ethr_spinlock_t *lock) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!lock) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_spinlock_init__(lock); +} + +int +ethr_spinlock_destroy(ethr_spinlock_t *lock) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!lock) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_spinlock_destroy__(lock); +} + + +int +ethr_spin_unlock(ethr_spinlock_t *lock) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!lock) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_spin_unlock__(lock); +} + +int +ethr_spin_lock(ethr_spinlock_t *lock) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!lock) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_spin_lock__(lock); +} + +int +ethr_rwlock_init(ethr_rwlock_t *lock) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!lock) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_rwlock_init__(lock); +} + +int +ethr_rwlock_destroy(ethr_rwlock_t *lock) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!lock) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_rwlock_destroy__(lock); +} + +int +ethr_read_unlock(ethr_rwlock_t *lock) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!lock) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_read_unlock__(lock); +} + +int +ethr_read_lock(ethr_rwlock_t *lock) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!lock) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_read_lock__(lock); +} + +int +ethr_write_unlock(ethr_rwlock_t *lock) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!lock) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_write_unlock__(lock); +} + +int +ethr_write_lock(ethr_rwlock_t *lock) +{ +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!lock) { + ASSERT(0); + return EINVAL; + } +#endif + return ethr_write_lock__(lock); +} + + +int +ethr_gate_init(ethr_gate *gp) +{ + int res; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!gp) { + ASSERT(0); + return EINVAL; + } +#endif + res = ethr_mutex_init(&gp->mtx); + if (res != 0) + return res; + res = ethr_cond_init(&gp->cnd); + if (res != 0) { + ethr_mutex_destroy(&gp->mtx); + return res; + } + gp->open = 0; + return 0; +} + +int +ethr_gate_destroy(ethr_gate *gp) +{ + int res, dres; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!gp) { + ASSERT(0); + return EINVAL; + } +#endif + res = ethr_mutex_destroy(&gp->mtx); + dres = ethr_cond_destroy(&gp->cnd); + if (res == 0) + res = dres; + gp->open = 0; + return res; +} + +int +ethr_gate_close(ethr_gate *gp) +{ + int res; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!gp) { + ASSERT(0); + return EINVAL; + } +#endif + res = ethr_mutex_lock__(&gp->mtx); + if (res != 0) + return res; + gp->open = 0; + res = ethr_mutex_unlock__(&gp->mtx); + return res; +} + +int +ethr_gate_let_through(ethr_gate *gp, unsigned no) +{ + int res, ures; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!gp) { + ASSERT(0); + return EINVAL; + } +#endif + res = ethr_mutex_lock__(&gp->mtx); + if (res != 0) + return res; + gp->open += no; + res = (gp->open == 1 + ? ethr_cond_signal(&gp->cnd) + : ethr_cond_broadcast(&gp->cnd)); + ures = ethr_mutex_unlock__(&gp->mtx); + if (res != 0) + res = ures; + return res; +} + +int +ethr_gate_swait(ethr_gate *gp, int spincount) +{ + int res, ures, n; +#if ETHR_XCHK + if (ethr_not_inited) { + ASSERT(0); + return EACCES; + } + if (!gp) { + ASSERT(0); + return EINVAL; + } +#endif + n = spincount; + res = ethr_mutex_lock__(&gp->mtx); + if (res != 0) + return res; + while (n >= 0 && !gp->open) { + res = ethr_mutex_unlock__(&gp->mtx); + if (res != 0) + return res; + res = ethr_mutex_lock__(&gp->mtx); + if (res != 0) + return res; + n--; + } + while (!gp->open) { + res = ethr_cond_wait(&gp->cnd, &gp->mtx); + if (res != 0 && res != EINTR) + goto done; + } + gp->open--; + done: + ures = ethr_mutex_unlock__(&gp->mtx); + if (res == 0) + res = ures; + return res; +} + + +int +ethr_gate_wait(ethr_gate *gp) +{ + return ethr_gate_swait(gp, 0); +} + + +/* rwmutex fallback */ +#ifdef ETHR_USE_RWMTX_FALLBACK + +int +ethr_rwmutex_init(ethr_rwmutex *rwmtx) +{ + int res; +#if ETHR_XCHK + if (!rwmtx) { + ASSERT(0); + return EINVAL; + } +#endif + res = ethr_mutex_init(&rwmtx->mtx); + if (res != 0) + return res; + ethr_cond_init(&rwmtx->rcnd); + if (res != 0) + goto error_cleanup1; + res = ethr_cond_init(&rwmtx->wcnd); + if (res != 0) + goto error_cleanup2; + rwmtx->readers = 0; + rwmtx->waiting_readers = 0; + rwmtx->waiting_writers = 0; +#if ETHR_XCHK + rwmtx->initialized = ETHR_RWMUTEX_INITIALIZED; +#endif + return 0; + error_cleanup2: + ethr_cond_destroy(&rwmtx->rcnd); + error_cleanup1: + ethr_mutex_destroy(&rwmtx->mtx); + return res; +} + +int +ethr_rwmutex_destroy(ethr_rwmutex *rwmtx) +{ + int res, pres; +#if ETHR_XCHK + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } + rwmtx->initialized = 0; +#endif + res = ethr_mutex_destroy(&rwmtx->mtx); + pres = ethr_cond_destroy(&rwmtx->rcnd); + if (res == 0) + res = pres; + pres = ethr_cond_destroy(&rwmtx->wcnd); + if (res == 0) + res = pres; + return res; +} + +int +ethr_rwmutex_tryrlock(ethr_rwmutex *rwmtx) +{ + int res; +#if ETHR_XCHK + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + res = ethr_mutex_trylock__(&rwmtx->mtx); + if (res != 0) + return res; + if (!rwmtx->waiting_writers) { + res = ethr_mutex_unlock__(&rwmtx->mtx); + if (res == 0) + return EBUSY; + return res; + } + rwmtx->readers++; + return ethr_mutex_unlock__(&rwmtx->mtx); +} + +int +ethr_rwmutex_rlock(ethr_rwmutex *rwmtx) +{ + int res; +#if ETHR_XCHK + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + res = ethr_mutex_lock__(&rwmtx->mtx); + if (res != 0) + return res; + while (rwmtx->waiting_writers) { + rwmtx->waiting_readers++; + res = ethr_cond_wait(&rwmtx->rcnd, &rwmtx->mtx); + rwmtx->waiting_readers--; + if (res != 0 && res != EINTR) { + (void) ethr_mutex_unlock__(&rwmtx->mtx); + return res; + } + } + rwmtx->readers++; + return ethr_mutex_unlock__(&rwmtx->mtx); +} + +int +ethr_rwmutex_runlock(ethr_rwmutex *rwmtx) +{ + int res, ures; +#if ETHR_XCHK + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + res = ethr_mutex_lock__(&rwmtx->mtx); + if (res != 0) + return res; + rwmtx->readers--; + if (!rwmtx->readers && rwmtx->waiting_writers) + res = ethr_cond_signal(&rwmtx->wcnd); + ures = ethr_mutex_unlock__(&rwmtx->mtx); + if (res == 0) + res = ures; + return res; +} + +int +ethr_rwmutex_tryrwlock(ethr_rwmutex *rwmtx) +{ + int res; +#if ETHR_XCHK + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + res = ethr_mutex_trylock__(&rwmtx->mtx); + if (res != 0) + return res; + if (!rwmtx->readers && !rwmtx->waiting_writers) + return 0; + else { + res = ethr_mutex_unlock__(&rwmtx->mtx); + if (res == 0) + return EBUSY; + return res; + } +} + +int +ethr_rwmutex_rwlock(ethr_rwmutex *rwmtx) +{ + int res; +#if ETHR_XCHK + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + res = ethr_mutex_lock__(&rwmtx->mtx); + if (res != 0) + return res; + if (!rwmtx->readers && !rwmtx->waiting_writers) + return 0; + + while (rwmtx->readers) { + rwmtx->waiting_writers++; + res = ethr_cond_wait(&rwmtx->wcnd, &rwmtx->mtx); + rwmtx->waiting_writers--; + if (res != 0 && res != EINTR) { + (void) ethr_rwmutex_rwunlock(rwmtx); + return res; + } + } + return 0; +} + +int +ethr_rwmutex_rwunlock(ethr_rwmutex *rwmtx) +{ + int res, ures; +#if ETHR_XCHK + if (!rwmtx || rwmtx->initialized != ETHR_RWMUTEX_INITIALIZED) { + ASSERT(0); + return EINVAL; + } +#endif + res = 0; + if (rwmtx->waiting_writers) + res = ethr_cond_signal(&rwmtx->wcnd); + else if (rwmtx->waiting_readers) + res = ethr_cond_broadcast(&rwmtx->rcnd); + ures = ethr_mutex_unlock__(&rwmtx->mtx); + if (res == 0) + res = ures; + return res; +} + +#endif /* #ifdef ETHR_USE_RWMTX_FALLBACK */ + +void +ethr_compiler_barrier(void) +{ + +} + +#ifdef DEBUG + +#include <stdio.h> +int ethr_assert_failed(char *f, int l, char *a) +{ + fprintf(stderr, "%s:%d: Assertion failed: %s\n", f, l, a); + abort(); + return 0; +} + +#endif + + |