c linux mprotect signal-handling system-calls

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;


This protects pagesize bytes of memory starting at buffer against any reads or writes.

Second, I try to read the memory:

p = buffer;
a = *p 

This will generate a SIGSEGV, and my handler will be called.
So far so good. My problem is that, once the handler is called, I want to change the access write of the memory by doing


and continue normal functioning of my code. I do not want to exit the function.
On future writes to the same memory, I want to catch the signal again and modify the write rights and then record that event.

Here is the code:

#include <signal.h>
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/mman.h>

#define handle_error(msg) \
    do { perror(msg); exit(EXIT_FAILURE); } while (0)

char *buffer;
int flag=0;

static void handler(int sig, siginfo_t *si, void *unused)
    printf("Got SIGSEGV at address: 0x%lx\n",(long) si->si_addr);
    printf("Implements the handler only\n");

int main(int argc, char *argv[])
    char *p; char a;
    int pagesize;
    struct sigaction sa;

    sa.sa_flags = SA_SIGINFO;
    sa.sa_sigaction = handler;
    if (sigaction(SIGSEGV, &sa, NULL) == -1)


    /* Allocate a buffer aligned on a page boundary;
       initial protection is PROT_READ | PROT_WRITE */

    buffer = memalign(pagesize, 4 * pagesize);
    if (buffer == NULL)

    printf("Start of region:        0x%lx\n", (long) buffer);
    printf("Start of region:        0x%lx\n", (long) buffer+pagesize);
    printf("Start of region:        0x%lx\n", (long) buffer+2*pagesize);
    printf("Start of region:        0x%lx\n", (long) buffer+3*pagesize);
    //if (mprotect(buffer + pagesize * 0, pagesize,PROT_NONE) == -1)
    if (mprotect(buffer + pagesize * 0, pagesize,PROT_NONE) == -1)

    //for (p = buffer ; ; )
        p = buffer+pagesize/2;
        printf("It comes here before reading memory\n");
        a = *p; //trying to read the memory
        printf("It comes here after reading memory\n");
        if (mprotect(buffer + pagesize * 0, pagesize,PROT_READ) == -1)
        a = *p;
        printf("Now i can read the memory\n");

/*  for (p = buffer;p<=buffer+4*pagesize ;p++ ) 
        //a = *(p);
        *(p) = 'a';
        printf("Writing at address %p\n",p);


    printf("Loop completed\n");     /* Should never happen */

The problem is that only the signal handler runs and I can’t return to the main function after catching the signal.


  • 2

    thanks nos for editing..I appreciate that. I need to spend some time to learn editing my questions..

    – Adi

    Apr 18, 2010 at 18:59

  • 1

    when compiling, always enable all the warnings, then fix those warnings. (for gcc, at a minimum use: -Wall -Wextra -pedantic I also use: -Wconversion -std=gnu99 ) The compiler will tell you: 1) parameter argc unused 2) parameter argv unused (suggest using main() signature of: int main( void ) 3) local variable p used in the else code block without being initialized. 4) parameter unused unused, suggest: add statement: (void)unused; as first line in that function. 5) local variable a set but not used.

    Sep 3, 2016 at 20:51

  • 1

    NEVER use printf() in a signal handler! The function write() would be ok to use, but best to not do any I/O in a signal handler, just set a flag and let the main line of code be checking that flag

    Sep 3, 2016 at 20:52

  • the variable pagesize is declared as an int, but it should be declared as a size_t

    Sep 3, 2016 at 20:54

  • the sig parameter should be compared to SIGSEGV, as there are other signals, and such a comparison would removed the compiler message about a unused sig parameter

    Sep 3, 2016 at 20:59


When your signal handler returns (assuming it doesn’t call exit or longjmp or something that prevents it from actually returning), the code will continue at the point the signal occurred, reexecuting the same instruction. Since at this point, the memory protection has not been changed, it will just throw the signal again, and you’ll be back in your signal handler in an infinite loop.

So to make it work, you have to call mprotect in the signal handler. Unfortunately, as Steven Schansker notes, mprotect is not async-safe, so you can’t safely call it from the signal handler. So, as far as POSIX is concerned, you’re screwed.

Fortunately on most implementations (all modern UNIX and Linux variants as far as I know), mprotect is a system call, so is safe to call from within a signal handler, so you can do most of what you want. The problem is that if you want to change the protections back after the read, you’ll have to do that in the main program after the read.

Another possibility is to do something with the third argument to the signal handler, which points at an OS and arch specific structure that contains info about where the signal occurred. On Linux, this is a ucontext structure, which contains machine-specific info about the $PC address and other register contents where the signal occurred. If you modify this, you change where the signal handler will return to, so you can change the $PC to be just after the faulting instruction so it won’t re-execute after the handler returns. This is very tricky to get right (and non-portable too).


The ucontext structure is defined in <ucontext.h>. Within the ucontext the field uc_mcontext contains the machine context, and within that, the array gregs contains the general register context. So in your signal handler:

ucontext *u = (ucontext *)unused;
unsigned char *pc = (unsigned char *)u->uc_mcontext.gregs[REG_RIP];

will give you the pc where the exception occurred. You can read it to figure out what instruction it
was that faulted, and do something different.

As far as the portability of calling mprotect in the signal handler is concerned, any system that follows either the SVID spec or the BSD4 spec should be safe — they allow calling any system call (anything in section 2 of the manual) in a signal handler.


  • Right, you can perform the memory access on behalf of the program (like a VM) and then update the instruction pointer. Calling mprotect is definitely easier.

    – Ben Voigt

    Apr 18, 2010 at 19:22

  • hi chris, You have given me some useful information. Thanks for that.. Can you tell me how can i read the info in the ucontext structure (3rd argument and change the $PC) . I am curious to know about it.

    – Adi

    Apr 18, 2010 at 19:25

  • @ Ben Voigt, I did not understand clearly what are u saying, request you to be slightly more elaborate.

    – Adi

    Apr 18, 2010 at 19:26

  • @chris, looks like i can do mprotect inside the signal handler and then return back safely to do my normal execution. I am not sure about portability as you guys mentioned , but I hope it is fine in my case. Thanks all for the help..

    – Adi

    Apr 18, 2010 at 19:43

  • @chris thanks for the explanation, i will see the PC using ur technique .

    – Adi

    Apr 19, 2010 at 6:34


You’ve fallen into the trap that all people do when they first try to handle signals. The trap? Thinking that you can actually do anything useful with signal handlers. From a signal handler, you are only allowed to call asynchronous and reentrant-safe library calls.

See this CERT advisory as to why and a list of the POSIX functions that are safe.

Note that printf(), which you are already calling, is not on that list.

Nor is mprotect. You’re not allowed to call it from a signal handler. It might work, but I can promise you’ll run into problems down the road. Be really careful with signal handlers, they’re tricky to get right!


Since I’m being a portability douchebag at the moment already, I’ll point out that you also shouldn’t write to shared (i.e. global) variables without taking the proper precautions.


  • 1

    Hi steven , If I can’t do anything useful inside the signal handler, I will be OK if I can update some counters inside it and return back to main and normally run my code, is it possible ?

    – Adi

    Apr 18, 2010 at 19:03

  • quoting from the CERT advisory, “they may call other functions provided that all implementations to which the code is ported guarantee that these functions are asynchronous—safe”. On linux that includes a lot more functions.

    – Ben Voigt

    Apr 18, 2010 at 19:29

  • Sure, but you have to just be aware of the problem! I can’t name off the top of my head which functions are and aren’t signal safe, and I doubt many could!

    Apr 19, 2010 at 1:59

  • 2

    The CERT Secure Coding is a great site, I didn’t know about it. It seems I got some new reading for a while 🙂

    – alecov

    Aug 12, 2010 at 5:47

  • 1

    “You’re not allowed to call [mprotect] from a signal handler.” Only if you need to strictly conform to POSIX. Glibc’s mprotect today is async-signal-safe:…

    Sep 26, 2018 at 19:59


You can recover from SIGSEGV on linux. Also you can recover from segmentation faults on Windows (you’ll see a structured exception instead of a signal). But the POSIX standard doesn’t guarantee recovery, so your code will be very non-portable.

Take a look at libsigsegv.