helgrind/tests/shmem_abits.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <assert.h>
   4 #include <string.h>
   5 #include "helgrind/helgrind.h"
   6
   7 #define MAX 1000000
   8 static unsigned char shadow[MAX];
   9
  10
  11 #define V(cond, testline)                                               \
  12    do { if (!(cond))                                                    \
  13          fprintf (stderr, "Test at line %d Failed verif at line %d: " #cond "\n", \
  14                   testline, __LINE__); }                                \
  15    while (0)
  16
  17 #define CHK(a1,a2,a3,a4) check(__LINE__,a1,a2,a3,a4)
  18 /* Check that [p, p+len[ has access access.
  19    If heap, check that one byte before and after is unaccessible */
  20 static void check (int testline, void *p, int len, unsigned char access, int heap)
  21 {
  22    int i;
  23    long int r;
  24
  25    assert (len < 1000000); // Do not exceed the shadow array
  26
  27    if (len == 0 && p == NULL)
  28       return;
  29    // malloc(0) can return a ptr or NULL.
  30    // Let's not check NULL
  31
  32    r = VALGRIND_HG_GET_ABITS (p, shadow, len);
  33    V (r == VALGRIND_HG_GET_ABITS (p, NULL, len), testline);
  34    V (access == 0xff ? r == len : r == 0, testline);
  35    for (i = 0; i < len; i++)
  36       V(shadow[i] == access, testline);
  37    if (heap) {
  38       /* Check the range starting 1 byte before. */
  39       r = VALGRIND_HG_GET_ABITS (p-1, shadow, len+1);
  40       V (r == VALGRIND_HG_GET_ABITS (p-1, NULL, len+1), testline);
  41       V (access == 0xff ? r == len : r == 0, testline);
  42       V (shadow[0] == 0x00, testline);
  43       for (i = 1; i < len+1; i++)
  44          V (shadow[i] == access, testline);
  45       /* Same but one byte after. We need special cases for
  46          a len 0,*/
  47       r = VALGRIND_HG_GET_ABITS (p+1, shadow, len);
  48       V (r == VALGRIND_HG_GET_ABITS (p+1, NULL, len), testline);
  49       if (len == 0)
  50          V (r == 0, testline);
  51       else
  52          V (access == 0xff ? r == len-1 : r == 0, testline);
  53       for (i = 0; i < len-1; i++)
  54          V(shadow[i] == access, testline);
  55       if (len != 0)
  56          V(shadow[len-1] == 0x00, testline);
  57    }
  58 }
  59
  60 /* return an address on the stack, with big var on the stack,
  61    to ensure it is really unaddressable when calling check. */
  62 static void* popped_stack_address(void)
  63 {
  64    char s[MAX];
  65    memcpy(s, shadow, MAX);
  66    char *p;
  67
  68    p = &s[MAX/2-1-s[0]];
  69    CHK(p, 1, 0xFF, 0);
  70    return p;
  71 }
  72
  73 int main ( void )
  74 {
  75    char *p;
  76
  77    /* Basic test for an heap object */
  78    fprintf(stderr, "basic heap test\n");
  79    p = malloc (100);
  80    CHK (p, 100, 0xff, 1);
  81    free (p);
  82    CHK (p, 100, 0x00, 1);
  83
  84    /* Basic test for some code : verify 50 bytes of check function code
  85       is accessible. */
  86    fprintf(stderr, "code test\n");
  87    CHK (check, 50, 0xff, 0);
  88
  89    /* Check something on the stack */
  90    fprintf(stderr, "stack test\n");
  91    CHK (&p, sizeof(p), 0xff, 0);
  92
  93
  94    /* Now shake the heap, to verify various sizes */
  95    fprintf(stderr, "doing many heap blocks\n");
  96    int i;
  97    int j;
  98 #  define X 200
  99 #  define Y 4
 100    void *ptr[X][Y];
 101    int sz[X][Y];
 102    int f[X][Y]; // already freed or not ?
 103    for (i = 0; i < X; i++) {
 104       for (j = 0; j < Y; j++) {
 105          f[i][j] = 1;
 106          // A SecMap represents 8Kb. We test the boundaries
 107          // around such secmap (X/2 bytes before and after)
 108          // We test with blocks covering from 0 till Y-1 secmaps
 109          sz[i][j] = j * 8192 - (j == 0 ? 0 : X/2) + i;
 110          ptr[i][j] = malloc(sz[i][j]);
 111          CHK(ptr[i][j],sz[i][j], 0xff, 1);
 112       }
 113    }
 114    /* Shake and check when doing random free */
 115    fprintf(stderr, "random heap free and checks\n");
 116    for (i = 0; i < X*Y/10; i++) {
 117       int x = rand() % X;
 118       int y = rand() % Y;
 119       if (f[x][y]) {
 120          CHK(ptr[x][y],sz[x][y], 0xff, 1);
 121          free(ptr[x][y]);
 122          f[x][y] = 0;
 123       }
 124       CHK(ptr[x][y],sz[x][y], 0x00, 1);
 125    }
 126
 127 #if 0
 128    /* Check that a use after return gives unaddressable. */
 129    CHK (popped_stack_address(), 1, 0x00, 0);
 130    /* Well well, it seems helgrind keeps the stack accessible */
 131 #endif
 132    (void) popped_stack_address();
 133
 134    return 0;
 135 }
 136