I am purely guessing but I do suspect that it might not even be due to awkward code but instead some sort of memory error that is overflowing elsewhere "nearby" and writing all over the OP's dynamic array.
To reference a long running insider joke : what game is this about?
I'm most likely not around for long enough to get this - please enlighten me.
Ah, I didn't link the two together before Crivens mentioned it.
Please check out the link I mentioned above about gdb's internals. When using gdb's command watch gdb will try to use HW assisted breakpoint for the condition. If this can be set you won't have any performance degradation as HW (cpu) is assisting. If not sw breakpoint is used. For watch that means to go step-by-step (instruction by instruction) and verify if condition is met. That is very slow.
So far mprotect() looks like most effective for debugging my issue.
Here is a sample program that I tested. Based on the output it is observed that the interrupt is generated multiple times although I try to write only once (ptr[0] = 0). I was expecting interrupt to be generated only once.
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
static int size;
static char *m;
int *ptr;
static unsigned long cnt;
void handler(int sig_num, siginfo_t *sig, void *unused) {
cnt++;
printf("%d : Got %d for address location : 0x%lx : 0x%lx => ptr[0] = %d\n", cnt, sig_num, (long)sig->si_addr, &ptr[0], ptr[0]);
if (5 == cnt) // when count is 5, provide READ/WRITE permission
mprotect(ptr, size, PROT_READ | PROT_WRITE);
}
int main()
{
struct sigaction s;
memset(&s, 0, sizeof(s));
s.sa_flags = SA_SIGINFO;
sigemptyset(&s.sa_mask);
s.sa_sigaction = handler;
if (sigaction(SIGSEGV, &s, NULL) == -1)
{
perror("sigaction");
return(1);
}
size = sysconf(_SC_PAGE_SIZE) * sizeof(int);
ptr = (int*)malloc(size);
printf("Starting ....0x%lx : size = %lu\n", ptr, size);
sleep(5);
ptr[0] = 9;
mprotect(ptr, size, PROT_READ); // Only read permission is provided
ptr[0] = 0;
printf("All completed...\n");
//munmap(ptr, size); ****/
return 0;
}
stackoverflow.com
From the signal handler if we print backtrace, it doesn't give the trace of the code that caused the signal, rather it gives something like this :see
How to write a signal handler to catch SIGSEGV?
I want to write a signal handler to catch SIGSEGV. I protect a block of memory for read or write using char *buffer; char *p; char a; int pagesize = 4096; mprotect(buffer,pagesize,PROT_NONE) This
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <ucontext.h>
#include <stdio.h>
#include <execinfo.h>
static int size;
static char *m;
int *ptr;
static unsigned long cnt;
void print_trace(void) {
char **strings;
size_t i, size;
enum Constexpr { MAX_SIZE = 1024 };
void *array[MAX_SIZE];
size = backtrace(array, MAX_SIZE);
strings = backtrace_symbols(array, size);
for (i = 0; i < size; i++)
printf("%s\n", strings[i]);
puts("");
free(strings);
}
void handler(int sig_num, siginfo_t *sig, void *unused) {
//ucontext_t *u = (ucontext_t *)unused;
//unsigned char *pc = (unsigned char *)u->uc_mcontext.gregs[REG_RIP];
cnt++;
printf("%d : Got %d for address location : 0x%lx : 0x%lx => ptr[0] = %d\n", cnt, sig_num, (long)sig->si_addr, &ptr[0], ptr[0]);
print_trace();
if (5 == cnt)
mprotect(ptr, size, PROT_READ | PROT_WRITE);
}
void test()
{
printf("-- %s --\n", __FUNCTION__);
print_trace();
}
int main()
{
struct sigaction s;
memset(&s, 0, sizeof(s));
s.sa_flags = SA_SIGINFO;
s.sa_sigaction = handler;
sigemptyset(&s.sa_mask);
if (sigaction(SIGSEGV, &s, NULL) == -1)
{
perror("sigaction");
return(1);
}
size = sysconf(_SC_PAGE_SIZE) * sizeof(int);
ptr = (int*)malloc(size);
printf("Starting ....0x%lx : size = %lu\n", ptr, size);
sleep(5);
ptr[0] = 9;
mprotect(ptr, size, PROT_READ);
ptr[0] = 0;
printf("All completed...\n");
//munmap(ptr, size); ****/
test();
return 0;
}
That's what I've mentioned earlier. While this does make an interesting issue in general if the focus is to fix the application that is in prod then using gdb is really the way to go. Anything else will cause more issues in the prod. This drove me crazy when I read code from my French colleagues. I thought it's a "French thing". My brain is not able to process the code like this, my hemispheres were fighting over this. I always had to manually redo it to
if(cnt==5) in my local copy to make the code readable for me.I used this to build the program :
static void dump_trace() {
size_t max_frames = 1024;
void *buffer[max_frames];
size_t calls = backtrace(buffer, max_frames);
printf("##### %s #####\n", __FUNCTION__);
fprintf(stderr, "dump_trace - have %zu frames\n", calls);
backtrace_symbols_fd(buffer, calls, 2);
//_Exit(EXIT_FAILURE);
}Actually we tried a lot to repro this issue in local environment, but it's really difficult sometime to replicate customer environment (when there are huge network traffic of different types and in different sequence). If there was a local repro of this issue, it would have been lot more easier to debug this using gdb.