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);
}
