l4/pkg/valgrind/src/valgrind-3.6.0-svn/helgrind/tests/tc20_verifywrap.c

   1 /* This program attempts to verify that all functions that are
   2    supposed to be wrapped by tc_intercepts.c really are wrapped.  The
   3    main way it does this is to cause failures in those functions, so
   4    as to obtain various error messages which imply that the wrapper
   5    really did engage.
   6
   7    Any regressions shown up by this program are potentially serious
   8    and should be investigated carefully. */
   9
  10 /* Needed for older glibcs (2.3 and older, at least) who don't
  11    otherwise "know" about some more exotic pthread stuff, in this case
  12    PTHREAD_MUTEX_ERRORCHECK. */
  13 #define _GNU_SOURCE 1
  14 #include <stdio.h>
  15 #include <string.h>
  16 #include <assert.h>
  17 #include <unistd.h>
  18 #include <pthread.h>
  19 #include <semaphore.h>
  20
  21 #if !defined(_AIX) && !defined(__APPLE__)
  22
  23 #if !defined(__GLIBC_PREREQ)
  24 # error "This program needs __GLIBC_PREREQ (in /usr/include/features.h)"
  25 #endif
  26
  27 short unprotected = 0;
  28
  29 void* lazy_child ( void* v ) {
  30    assert(0); /* does not run */
  31 }
  32
  33 void* racy_child ( void* v ) {
  34    unprotected = 1234;
  35    return NULL;
  36 }
  37
  38 int main ( void )
  39 {
  40    int r;
  41    /* pthread_t thr; */
  42    /* pthread_attr_t thra; */
  43    pthread_mutexattr_t mxa, mxa2;
  44    pthread_mutex_t mx, mx2, mx3, mx4;
  45    pthread_cond_t cv;
  46    struct timespec abstime;
  47    pthread_rwlock_t rwl;
  48    pthread_rwlock_t rwl2;
  49    pthread_rwlock_t rwl3;
  50    sem_t s1;
  51
  52 #  if __GLIBC_PREREQ(2,4)
  53    fprintf(stderr,
  54            "\n\n------ This is output for >= glibc 2.4 ------\n");
  55 #  else
  56    fprintf(stderr,
  57            "\n\n------ This is output for < glibc 2.4 ------\n");
  58 #  endif
  59
  60    /* --------- pthread_create/join --------- */
  61
  62    fprintf(stderr,
  63    "\n---------------- pthread_create/join ----------------\n\n");
  64
  65    /* make pthread_create fail */
  66    /* It's amazingly difficult to make pthread_create fail
  67       without first soaking up all the machine's resources.
  68       Instead, in order to demonstrate that it's really wrapped,
  69       create a child thread, generate a race error, and join with it
  70       again. */
  71    /* This just segfaults:
  72       memset( &thra, 0xFF, sizeof(thra) );
  73       r= pthread_create( &thr, NULL, lazy_child, NULL ); assert(r);
  74    */
  75    { pthread_t child;
  76      r= pthread_create( &child, NULL, racy_child, NULL ); assert(!r);
  77      sleep(1); /* just to ensure parent thread reports race, not child */
  78      unprotected = 5678;
  79      r= pthread_join( child, NULL ); assert(!r);
  80    }
  81
  82    /* make pthread_join fail */
  83    r= pthread_join( pthread_self(), NULL ); assert(r);
  84
  85    /* --------- pthread_mutex_lock et al --------- */
  86
  87    fprintf(stderr,
  88    "\n---------------- pthread_mutex_lock et al ----------------\n\n");
  89
  90    /* make pthread_mutex_init fail */
  91    memset( &mxa, 0xFF, sizeof(mxa) );
  92    r= pthread_mutex_init( &mx, &mxa );
  93 #  if __GLIBC_PREREQ(2,4)
  94    assert(r); /* glibc >= 2.4: the call should fail */
  95 #  else
  96    assert(!r); /* glibc < 2.4: oh well, glibc didn't bounce this */
  97 #  endif
  98
  99    /* make pthread_mutex_destroy fail */
 100    r= pthread_mutex_init( &mx2, NULL ); assert(!r);
 101    r= pthread_mutex_lock( &mx2 ); assert(!r);
 102    r= pthread_mutex_destroy( &mx2 ); assert(r);
 103
 104    /* make pthread_mutex_lock fail (skipped on < glibc 2.4 because it
 105       doesn't fail, hence hangs the test) */
 106 #  if __GLIBC_PREREQ(2,4)
 107    memset( &mx3, 0xFF, sizeof(mx3) );
 108    r= pthread_mutex_lock( &mx3 ); assert(r);
 109 #  else
 110    fprintf(stderr, "\nmake pthread_mutex_lock fail: "
 111                    "skipped on glibc < 2.4\n\n");
 112 #  endif
 113
 114    /* make pthread_mutex_trylock fail */
 115    memset( &mx3, 0xFF, sizeof(mx3) );
 116    r= pthread_mutex_trylock( &mx3 ); assert(r);
 117
 118    /* make pthread_mutex_timedlock fail */
 119    memset( &abstime, 0, sizeof(abstime) );
 120    memset( &mx3, 0xFF, sizeof(mx3) );
 121    r= pthread_mutex_timedlock( &mx3, &abstime ); assert(r);
 122
 123    /* make pthread_mutex_unlock fail */
 124    memset( &mx3, 0xFF, sizeof(mx3) );
 125    r= pthread_mutex_unlock( &mx3 );
 126 #  if __GLIBC_PREREQ(2,4)
 127    assert(r);
 128 #  else
 129    assert(!r);
 130 #  endif
 131
 132    /* --------- pthread_cond_wait et al --------- */
 133
 134    fprintf(stderr,
 135    "\n---------------- pthread_cond_wait et al ----------------\n\n");
 136
 137    /* make pthread_cond_wait fail.  This is difficult.  Our cunning
 138       plan (tm) is to show up at pthread_cond_wait bearing a
 139       not-locked mutex of the ERRORCHECK flavour and hope (as is
 140       indeed the case with glibc-2.5) that pthread_cond_wait notices
 141       it is not locked, and bounces our request. */
 142    r= pthread_mutexattr_init( &mxa2 ); assert(!r);
 143    r= pthread_mutexattr_settype( &mxa2, PTHREAD_MUTEX_ERRORCHECK );
 144       assert(!r);
 145    r= pthread_mutex_init( &mx4, &mxa2 ); assert(!r);
 146    r= pthread_cond_init( &cv, NULL ); assert(!r);
 147    r= pthread_cond_wait( &cv, &mx4 ); assert(r);
 148    r= pthread_mutexattr_destroy( &mxa2 ); assert(!r);
 149
 150    /* make pthread_cond_signal fail.  FIXME: can't figure out how
 151       to */
 152    r= pthread_cond_signal( &cv ); assert(!r);
 153    fprintf(stderr, "\nFIXME: can't figure out how to "
 154                    "verify wrap of pthread_cond_signal\n\n");
 155
 156    /* make pthread_cond_broadcast fail.  FIXME: can't figure out how
 157       to */
 158    r= pthread_cond_broadcast( &cv ); assert(!r);
 159    fprintf(stderr, "\nFIXME: can't figure out how to "
 160                    "verify wrap of pthread_broadcast_signal\n\n");
 161
 162    /* make pthread_cond_timedwait fail. */
 163    memset( &abstime, 0, sizeof(abstime) );
 164    abstime.tv_nsec = 1000000000 + 1;
 165    r= pthread_cond_timedwait( &cv, &mx4, &abstime ); assert(r);
 166
 167    /* --------- pthread_rwlock_* --------- */
 168
 169    fprintf(stderr,
 170    "\n---------------- pthread_rwlock_* ----------------\n\n");
 171
 172    /* pthread_rwlock_init, pthread_rwlock_unlock */
 173    /* pthread_rwlock_init: can't make glibc's implementation fail.
 174       However, can demonstrate interceptedness by initialising but not
 175       locking a lock and then unlocking it.  Then the unlock call
 176       should say "first seen at .. the init call."  So this tests
 177       wrappedness of both calls. */
 178    r= pthread_rwlock_init( &rwl, NULL ); assert(!r);
 179    r= pthread_rwlock_unlock( &rwl );
 180    /* assert(r); *//* glibc doesn't complain.  It really ought to. Oh well. */
 181
 182    /* We can infer the presence of wrapping for pthread_rwlock_rdlock,
 183       pthread_rwlock_wrlock and pthread_rwlock_unlock by making
 184       Thrcheck count the lockedness state, and warning when we unlock
 185       a not-locked lock.  Thusly: */
 186    r= pthread_rwlock_init( &rwl2, NULL ); assert(!r);
 187
 188    /* w-lock it */
 189    fprintf(stderr, "(1) no error on next line\n");
 190    r= pthread_rwlock_wrlock( &rwl2 ); assert(!r);
 191    /* unlock it */
 192    fprintf(stderr, "(2) no error on next line\n");
 193    r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
 194    /* unlock it again, get an error */
 195    fprintf(stderr, "(3)    ERROR on next line\n");
 196    r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
 197
 198    /* same game with r-locks */
 199    r= pthread_rwlock_init( &rwl2, NULL ); assert(!r);
 200    /* r-lock it twice */
 201    fprintf(stderr, "(4) no error on next line\n");
 202    r= pthread_rwlock_rdlock( &rwl2 ); assert(!r);
 203    fprintf(stderr, "(5) no error on next line\n");
 204    r= pthread_rwlock_rdlock( &rwl2 ); assert(!r);
 205    /* unlock it twice */
 206    fprintf(stderr, "(6) no error on next line\n");
 207    r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
 208    fprintf(stderr, "(7) no error on next line\n");
 209    r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
 210    /* unlock it again, get an error */
 211    fprintf(stderr, "(8)    ERROR on next line\n");
 212    r= pthread_rwlock_unlock( &rwl2 ); assert(!r);
 213
 214    /* Lock rwl3 so the locked-lock-at-dealloc check can complain about
 215       it. */
 216    r= pthread_rwlock_init( &rwl3, NULL ); assert(!r);
 217    r= pthread_rwlock_rdlock( &rwl3 ); assert(!r);
 218
 219    /* ------------- sem_* ------------- */
 220
 221    /* This is pretty lame, and duplicates tc18_semabuse.c. */
 222
 223    fprintf(stderr,
 224    "\n---------------- sem_* ----------------\n\n");
 225
 226    /* verifies wrap of sem_init */
 227    /* Do sem_init with huge initial count - fails */
 228    r= sem_init(&s1, 0, ~0); assert(r);
 229
 230    /* initialise properly */
 231    r= sem_init(&s1, 0, 0);
 232
 233    /* in glibc, sem_destroy is a no-op; making it fail is
 234       impossible. */
 235    fprintf(stderr, "\nFIXME: can't figure out how to verify wrap of "
 236                    "sem_destroy\n\n");
 237
 238    /* verifies wrap of sem_wait */
 239    /* Do 'wait' on a bogus semaphore.  This should fail, but on glibc
 240       it succeeds. */
 241    memset(&s1, 0x55, sizeof(s1));
 242    r= sem_wait(&s1); /* assert(r != 0); */
 243
 244    /* this only fails with glibc 2.7 or later. */
 245    r= sem_post(&s1);
 246    fprintf(stderr, "\nFIXME: can't figure out how to verify wrap of "
 247                    "sem_post\n\n");
 248
 249    sem_destroy(&s1);
 250
 251    /* ------------- dealloc of mem holding locks ------------- */
 252
 253    fprintf(stderr,
 254    "\n------------ dealloc of mem holding locks ------------\n\n");
 255
 256    /* At this point it should complain about deallocation
 257       of memory containing locked locks:
 258          rwl3
 259    */
 260
 261    return 0;
 262 }
 263
 264 #else /* defined(_AIX) */
 265 int main ( void )
 266 {
 267    fprintf(stderr, "This program does not work on AIX.\n");
 268    return 0;
 269 }
 270 #endif