memcheck/tests/descr_belowsp.c

   1 #include "../../config.h"
   2
   3 #define _GNU_SOURCE
   4 #include <stdio.h>
   5 #include <pthread.h>
   6 #include <string.h>
   7 #include <stdlib.h>
   8 #include <sys/types.h>
   9 #include <unistd.h>
  10 #include <assert.h>
  11 #include <setjmp.h>
  12 #include <signal.h>
  13 #ifdef HAVE_GETPAGESIZE
  14 #include <unistd.h>
  15 #endif
  16 #include "../../include/valgrind.h"
  17 #include "../memcheck.h"
  18
  19 typedef  unsigned long   UWord;
  20 typedef  UWord           Addr;
  21 #define VG_ROUNDDN(p, a)   ((Addr)(p) & ~((Addr)(a)-1))
  22 #define VG_ROUNDUP(p, a)   VG_ROUNDDN((p)+(a)-1, (a))
  23
  24 static pthread_t children;
  25
  26 // If != 0, will test addr description does not explode with
  27 // wrong stack registration.
  28 static int shake_with_wrong_registration = 0;
  29
  30 /* Do whatever to have the stack grown enough that
  31    we can access below sp relatively safely */
  32 static void grow_the_stack(void)
  33 {
  34    int i;
  35    char m[5000];
  36    for (i = 0; i < sizeof(m); i++)
  37       m[i] = i;
  38    sprintf(m, "do whatever %d", i);
  39    if (strlen(m) > 1000)
  40       fprintf(stderr, "something went wrong with %s\n", m);
  41 }
  42
  43 static char s[1000];
  44 static void describe (char* what, void* a)
  45 {
  46    fprintf(stderr, "describing %p %s\n", a, what);
  47    sprintf(s, "v.info location %p", a);
  48    VALGRIND_MONITOR_COMMAND(s);
  49 }
  50
  51 static void bad_things_below_sp (void)
  52 {
  53    int i;
  54    char *p = (char*)&i;
  55    describe ("1500 bytes below a local var", p-1500);
  56 }
  57
  58
  59 static volatile char *lowest_j;
  60 static jmp_buf goback;
  61
  62 static void sigsegv_handler(int signr)
  63 {
  64    longjmp(goback, 1);
  65 }
  66
  67 static void bad_things_till_guard_page(void)
  68 {
  69    char j = 0;
  70    char *p = &j;
  71
  72    for (;;) {
  73       j = j + *p;
  74       p = p - 400;
  75       lowest_j = p;
  76    }
  77 }
  78
  79 static int guess_pagesize(void)
  80 {
  81 #ifdef HAVE_GETPAGESIZE
  82    const int pagesize = getpagesize();
  83 #else
  84    const int pagesize = 4096; // let's say ?
  85 #endif
  86    return pagesize;
  87 }
  88
  89 static void describe_many(void)
  90 {
  91    const int pagesize = guess_pagesize();
  92    describe ("discovered address giving SEGV in thread stack",
  93              (void*)lowest_j);
  94    describe ("byte just above highest guardpage byte",
  95              (void*) VG_ROUNDUP(lowest_j, pagesize));
  96    describe ("highest guardpage byte",
  97              (void*) VG_ROUNDUP(lowest_j, pagesize)-1);
  98    describe ("lowest guardpage byte",
  99              (void*) VG_ROUNDDN(lowest_j, pagesize));
 100    /* Cannot test the next byte, as we cannot predict how
 101       this byte will be described. */
 102 }
 103
 104 static void* child_fn_0 ( void* arg )
 105 {
 106    grow_the_stack();
 107    bad_things_below_sp();
 108
 109    if (setjmp(goback)) {
 110       describe_many();
 111    } else
 112       bad_things_till_guard_page();
 113
 114    if (shake_with_wrong_registration) {
 115       // Do whatever stupid things we could imagine
 116       // with stack registration and see no explosion happens
 117       // Note: this is executed only if an arg is given to the program.
 118       //
 119
 120       const int pgsz = guess_pagesize();
 121       int stackid;
 122
 123       fprintf(stderr, "\n\nShaking after unregistering stack\n");
 124       // Assuming our first stack was automatically registered as nr 1
 125       VALGRIND_STACK_DEREGISTER(1);
 126       // Test with no stack registered
 127       describe_many();
 128
 129       fprintf(stderr, "\n\nShaking with small stack\n");
 130       stackid = VALGRIND_STACK_REGISTER((void*) VG_ROUNDDN(&stackid, pgsz),
 131                                         (void*) VG_ROUNDUP(&stackid, pgsz));
 132       describe_many();
 133       VALGRIND_STACK_DEREGISTER(stackid);
 134
 135       fprintf(stderr, "\n\nShaking with huge stack\n");
 136       stackid = VALGRIND_STACK_REGISTER((void*) 0x0,
 137                                         (void*) VG_ROUNDUP(&stackid, 2<<20));
 138       describe_many();
 139       VALGRIND_STACK_DEREGISTER(stackid);
 140
 141
 142    }
 143
 144    return NULL;
 145 }
 146
 147 int main(int argc, const char** argv)
 148 {
 149    struct sigaction sa;
 150    int r;
 151
 152    shake_with_wrong_registration = argc > 1;
 153
 154    /* We will discover the thread guard page using SEGV.
 155       So, prepare an handler. */
 156    sa.sa_handler = sigsegv_handler;
 157    sigemptyset(&sa.sa_mask);
 158    sa.sa_flags = 0;
 159
 160    if (sigaction (SIGSEGV, &sa, NULL) != 0)
 161       perror("sigaction");
 162
 163    grow_the_stack();
 164    bad_things_below_sp();
 165
 166    r = pthread_create(&children, NULL, child_fn_0, NULL);
 167    assert(!r);
 168
 169    r = pthread_join(children, NULL);
 170    assert(!r);
 171
 172
 173    return 0;
 174 }
 175