static int send_trace_buffer(void) { ssize_t ssz; size_t sz; sz = tracep - trace_buffer; tracep = trace_buffer; do { ssz = erts_sock_send(socket_desc, (void *) tracep, sz); if (ssz < 0) { int socket_errno = erts_sock_errno(); #ifdef EINTR if (socket_errno == EINTR) continue; #endif disable_trace(0, "Connection lost", socket_errno); return 0; } if (ssz > sz) { disable_trace(1, "Unexpected error", 0); return 0; } tracep += ssz; sz -= ssz; } while (sz); tracep = trace_buffer; return 1; }
void erts_mtrace_init(char *receiver, char *nodename) { char hostname[MAXHOSTNAMELEN + 1]; char pid[21]; /* enough for a 64 bit number */ socket_desc = ERTS_SOCK_INVALID_SOCKET; erts_mtrace_enabled = receiver != NULL; if (erts_mtrace_enabled) { unsigned a, b, c, d, p; byte ip_addr[4]; Uint16 port; erts_mtx_init(&mtrace_buf_mutex, "mtrace_buf", NIL, ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG); erts_mtx_init(&mtrace_op_mutex, "mtrace_op", NIL, ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_DEBUG); socket_desc = erts_sock_open(); if (socket_desc == ERTS_SOCK_INVALID_SOCKET) { disable_trace(1, "Failed to open socket", erts_sock_errno()); return; } if (5 != sscanf(receiver, "%u.%u.%u.%u:%u", &a, &b, &c, &d, &p) || a >= (1 << 8) || b >= (1 << 8)|| c >= (1 << 8) || d >= (1 << 8) || p >= (1 << 16)) { disable_trace(1, "Invalid receiver address", 0); return; } ip_addr[0] = (byte) a; ip_addr[1] = (byte) b; ip_addr[2] = (byte) c; ip_addr[3] = (byte) d; port = (Uint16) p; if (!erts_sock_connect(socket_desc, ip_addr, 4, port)) { disable_trace(1, "Failed to connect to receiver", erts_sock_errno()); return; } tracep = trace_buffer; endp = trace_buffer + TRACE_BUF_SZ; /* gethostname requires that the len is max(hostname) + 1 */ if (erts_sock_gethostname(hostname, MAXHOSTNAMELEN + 1) != 0) hostname[0] = '\0'; hostname[MAXHOSTNAMELEN] = '\0'; sys_get_pid(pid, sizeof(pid)); write_trace_header(nodename ? nodename : "", pid, hostname); erts_mtrace_update_heap_size(); } }
int main(int argc, char** argv) { // Create traces perffd = setupHandler(SIGIO); fprintf(stderr, "i address at %p\n", &i); // Set a signal handler for SIGUSR1 struct sigaction sa1 = { .sa_sigaction = fizz_handler, .sa_flags = SA_SIGINFO }; if(sigaction(SIGIO, &sa1, NULL) == -1) { fprintf(stderr, "Failed to set SIGTRAP handler: %s\n", strerror(errno)); abort(); } // Start traces enable_trace(perffd); // Shortest fizzbuzz implementation ever: for(i=0; i<2000; i++) { ; } // Disable traces disable_trace(perffd); // Read out the count of events //fprintf(stderr, "Watchpoints tripped %lu times. i is %d\n", get_trace_count(perffd), i); munmap(our_mmap, 9*4096); return 0; }
void tst_mpff() { disable_trace("mpff"); enable_trace("mpff_trace"); // enable_trace("mpff_bug"); // enable_trace("mpff_to_mpq"); // tst_div(2); tst_prev_power_2(); tst_decimal(); tst_div_core(679, 396, 279, 756, 2, 0); tst_limits(2); tst_limits(4); tst_sgn(2); tst_sgn(4); tst_sgn(8); tst_power(2); tst_power(4); tst_power(18); tst_capacity(2); tst_capacity(4); tst_capacity(8); tst_capacity(16); tst_set64(1000, 2); tst_set64(1000, 4); tst_set64(1000, 6); tst_bug2(); tst_sub(1000, 1024, 2); tst_sub(1000, 1024, 4); tst_div(1000, 1024, 2, true); tst_div(1000, 1024, 4, true); tst_mul(1000, 1024, 2); tst_mul(1000, 1024, 4); tst_add(1000, 1024, 2); tst_add(1000, 1024, 4); tst_sub(1000, UINT_MAX, 2); tst_sub(1000, UINT_MAX, 4); tst_div(1000, UINT_MAX, 2, true); tst_div(1000, UINT_MAX, 4, true); tst_mul(1000, UINT_MAX, 2); tst_mul(1000, UINT_MAX, 4); tst_add(1000, UINT_MAX, 2); tst_add(1000, UINT_MAX, 4); tst_bug2(); tst_bug(); tst_add_core(1,1, 1,1); tst_add_core(1,3, 2,3); tst1(); tst2(); tst3(); tst4(); tst5(); tst6(); tst7(); }
// The iterator variable void fizz_handler(int signum, siginfo_t* info, void* p) { // Check lib/parse_record.c of https://github.com/deater/perf_event_tests disable_trace(perffd); // fprintf(stderr, "Hihi, i is %d. Addr %p. P %p\n", i, p); //fprintf(stderr, "Hihi, i is %d. P %p\n", i, p); fprintf(stderr, "Hihi, i is %d at %p\n", i, &i); prev_head=perf_mmap_read(our_mmap,MMAP_DATA_SIZE,prev_head, sample_type,read_format,0,NULL,quiet,NULL); ioctl(perffd, PERF_EVENT_IOC_REFRESH, 1); }
void tst_algebraic() { // enable_trace("resultant_bug"); // enable_trace("poly_sign"); disable_trace("algebraic"); // enable_trace("mpbq_bug"); // enable_trace("mpz_mul2k"); // enable_trace("mpz_gcd"); tst_root(); tst_isolate_roots(); ex1(); tst_eval_sign(); tst_select_small(); tst_dejan(); tst_wilkinson(); tst1(); tst_refine_mpbq(); }
static int write_trace_header(char *nodename, char *pid, char *hostname) { #ifdef DEBUG byte *startp; #endif Uint16 entry_sz; Uint32 flags, n_len, h_len, p_len, hdr_prolog_len; int i, no, str_len; const char *str; struct { Uint32 gsec; Uint32 sec; Uint32 usec; } start_time; sys_gettimeofday(&last_tv); start_time.gsec = (Uint32) (last_tv.tv_sec / 1000000000); start_time.sec = (Uint32) (last_tv.tv_sec % 1000000000); start_time.usec = (Uint32) last_tv.tv_usec; if (!MAKE_TBUF_SZ(3*UI32_SZ)) return 0; flags = 0; #ifdef ARCH_64 flags |= ERTS_MT_64_BIT_FLAG; #endif flags |= ERTS_MT_CRR_INFO; #ifdef ERTS_CAN_TRACK_MALLOC flags |= ERTS_MT_SEG_CRR_INFO; #endif /* * The following 3 ui32 words *always* have to come * first in the trace. */ PUT_UI32(tracep, ERTS_MT_START_WORD); PUT_UI32(tracep, ERTS_MT_MAJOR_VSN); PUT_UI32(tracep, ERTS_MT_MINOR_VSN); n_len = strlen(nodename); h_len = strlen(hostname); p_len = strlen(pid); hdr_prolog_len = (2*UI32_SZ + 3*UI16_SZ + 3*UI32_SZ + 3*UI8_SZ + n_len + h_len + p_len); if (!MAKE_TBUF_SZ(hdr_prolog_len)) return 0; /* * New stuff can be added at the end the of header prolog * (EOHP). The reader should skip stuff at the end, that it * doesn't understand. */ #ifdef DEBUG startp = tracep; #endif PUT_UI32(tracep, hdr_prolog_len); PUT_UI32(tracep, flags); PUT_UI16(tracep, ERTS_MTRACE_SEGMENT_ID); PUT_UI16(tracep, ERTS_ALC_A_MAX); PUT_UI16(tracep, ERTS_ALC_N_MAX); PUT_UI32(tracep, start_time.gsec); PUT_UI32(tracep, start_time.sec); PUT_UI32(tracep, start_time.usec); PUT_UI8(tracep, (byte) n_len); memcpy((void *) tracep, (void *) nodename, n_len); tracep += n_len; PUT_UI8(tracep, (byte) h_len); memcpy((void *) tracep, (void *) hostname, h_len); tracep += h_len; PUT_UI8(tracep, (byte) p_len); memcpy((void *) tracep, (void *) pid, p_len); tracep += p_len; ASSERT(startp + hdr_prolog_len == tracep); /* * EOHP */ /* * All tags from here on should be followed by an Uint16 size * field containing the total size of the entry. * * New stuff can eigther be added at the end of an entry, or * as a new tagged entry. The reader should skip stuff at the * end, that it doesn't understand. */ for (i = ERTS_ALC_A_MIN; i <= ERTS_ALC_A_MAX; i++) { Uint16 aflags = 0; #ifndef ERTS_CAN_TRACK_MALLOC if (i != ERTS_ALC_A_SYSTEM) #endif aflags |= ERTS_MT_ALLCTR_USD_CRR_INFO; str = ERTS_ALC_A2AD(i); ASSERT(str); str_len = strlen(str); if (str_len >= (1 << 8)) { disable_trace(1, "Excessively large allocator string", 0); return 0; } entry_sz = UI8_SZ + 3*UI16_SZ + UI8_SZ; entry_sz += (erts_allctrs_info[i].alloc_util ? 2 : 1)*UI16_SZ; entry_sz += UI8_SZ + str_len; if (!MAKE_TBUF_SZ(entry_sz)) return 0; #ifdef DEBUG startp = tracep; #endif PUT_UI8(tracep, ERTS_MT_ALLOCATOR_HDR_TAG); PUT_UI16(tracep, entry_sz); PUT_UI16(tracep, aflags); PUT_UI16(tracep, (Uint16) i); PUT_UI8( tracep, (byte) str_len); memcpy((void *) tracep, (void *) str, str_len); tracep += str_len; if (erts_allctrs_info[i].alloc_util) { PUT_UI8(tracep, 2); PUT_UI16(tracep, ERTS_MTRACE_SEGMENT_ID); PUT_UI16(tracep, ERTS_ALC_A_SYSTEM); } else { PUT_UI8(tracep, 1); switch (i) { case ERTS_ALC_A_SYSTEM: PUT_UI16(tracep, ERTS_MTRACE_SEGMENT_ID); break; default: PUT_UI16(tracep, ERTS_MTRACE_SEGMENT_ID); break; } } ASSERT(startp + entry_sz == tracep); } for (i = ERTS_ALC_N_MIN; i <= ERTS_ALC_N_MAX; i++) { Uint16 nflags = 0; str = ERTS_ALC_N2TD(i); ASSERT(str); str_len = strlen(str); if (str_len >= (1 << 8)) { disable_trace(1, "Excessively large type string", 0); return 0; } no = ERTS_ALC_T2A(ERTS_ALC_N2T(i)); if (!erts_allctrs_info[no].enabled) no = ERTS_ALC_A_SYSTEM; ASSERT(ERTS_ALC_A_MIN <= no && no <= ERTS_ALC_A_MAX); entry_sz = UI8_SZ + 3*UI16_SZ + UI8_SZ + str_len + UI16_SZ; if (!MAKE_TBUF_SZ(entry_sz)) return 0; #ifdef DEBUG startp = tracep; #endif PUT_UI8(tracep, ERTS_MT_BLOCK_TYPE_HDR_TAG); PUT_UI16(tracep, entry_sz); PUT_UI16(tracep, nflags); PUT_UI16(tracep, (Uint16) i); PUT_UI8(tracep, (byte) str_len); memcpy((void *) tracep, (void *) str, str_len); tracep += str_len; PUT_UI16(tracep, no); ASSERT(startp + entry_sz == tracep); } entry_sz = UI8_SZ + UI16_SZ; if (!MAKE_TBUF_SZ(entry_sz)) return 0; PUT_UI8(tracep, ERTS_MT_END_OF_HDR_TAG); PUT_UI16(tracep, entry_sz); return 1; }
void Z3_API Z3_disable_trace(Z3_string tag) { LOG_Z3_disable_trace(tag); disable_trace(tag); }