memcheck/tests/descr_belowsp.c

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