lib/libkse/test/guard_b.c

   1 /*
   2  * Copyright (C) 2001 Jason Evans <jasone@freebsd.org>.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice(s), this list of conditions and the following disclaimer
  10  *    unmodified other than the allowable addition of one or more
  11  *    copyright notices.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice(s), this list of conditions and the following disclaimer in
  14  *    the documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
  21  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  24  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  25  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  26  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  27  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * $FreeBSD$
  30  *
  31  * Test thread stack guard functionality.
  32  */
  33
  34 #include <assert.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <errno.h>
  39 #include <limits.h>
  40 #include <pthread.h>
  41
  42 #define FRAME_SIZE      1024
  43 #define FRAME_OVERHEAD    40
  44
  45 struct args
  46 {
  47         void    *top;   /* Top of thread's initial stack frame. */
  48         int     cur;    /* Recursion depth. */
  49         int     max;    /* Maximum recursion depth. */
  50 };
  51
  52 void *
  53 recurse(void *args)
  54 {
  55         int             top;
  56         struct args     *parms = (struct args *)args;
  57         char            filler[FRAME_SIZE - FRAME_OVERHEAD];
  58
  59         /* Touch the memory in this stack frame. */
  60         top = 0xa5;
  61         memset(filler, 0xa5, sizeof(filler));
  62
  63         if (parms->top == NULL) {
  64                 /* Initial stack frame. */
  65                 parms->top = (void*)&top;
  66         }
  67
  68         /*
  69          * Make sure frame size is what we expect.  Getting this right involves
  70          * hand tweaking, so just print a warning rather than aborting.
  71          */
  72         if (parms->top - (void *)&top != FRAME_SIZE * parms->cur) {
  73                 fprintf(stderr,
  74                     "Stack size (%ld) != expected (%ld), frame %ld\n",
  75                     (long)parms->top - (long)&top,
  76                     (long)(FRAME_SIZE * parms->cur), (long)parms->cur);
  77         }
  78
  79         parms->cur++;
  80         if (parms->cur < parms->max)
  81                 recurse(args);
  82
  83         return NULL;
  84 }
  85
  86
  87 int
  88 main(int argc, char **argv)
  89 {
  90         size_t          def_stacksize, def_guardsize;
  91         size_t          stacksize, guardsize;
  92         pthread_t       thread;
  93         pthread_attr_t  attr;
  94         struct args     args;
  95
  96         if (argc != 3) {
  97                 fprintf(stderr, "usage: guard_b <stacksize> <guardsize>\n");
  98                 exit(1);
  99         }
 100         fprintf(stderr, "Test begin\n");
 101
 102         stacksize = strtoul(argv[1], NULL, 10);
 103         guardsize = strtoul(argv[2], NULL, 10);
 104
 105         assert(pthread_attr_init(&attr) == 0);
 106         /*
 107          * Exercise the attribute APIs more thoroughly than is strictly
 108          * necessary for the meat of this test program.
 109          */
 110         assert(pthread_attr_getstacksize(&attr, &def_stacksize) == 0);
 111         assert(pthread_attr_getguardsize(&attr, &def_guardsize) == 0);
 112         if (def_stacksize != stacksize) {
 113                 assert(pthread_attr_setstacksize(&attr, stacksize) == 0);
 114                 assert(pthread_attr_getstacksize(&attr, &def_stacksize) == 0);
 115                 assert(def_stacksize == stacksize);
 116         }
 117         if (def_guardsize != guardsize) {
 118                 assert(pthread_attr_setguardsize(&attr, guardsize) == 0);
 119                 assert(pthread_attr_getguardsize(&attr, &def_guardsize) == 0);
 120                 assert(def_guardsize >= guardsize);
 121         }
 122
 123         /*
 124          * Create a thread that will come just short of overflowing the thread
 125          * stack.  We need to leave a bit of breathing room in case the thread
 126          * is context switched, and we also have to take care not to call any
 127          * functions in the deepest stack frame.
 128          */
 129         args.top = NULL;
 130         args.cur = 0;
 131         args.max = (stacksize / FRAME_SIZE) - 1;
 132         fprintf(stderr, "No overflow:\n");
 133         assert(pthread_create(&thread, &attr, recurse, &args) == 0);
 134         assert(pthread_join(thread, NULL) == 0);
 135
 136         /*
 137          * Create a thread that will barely of overflow the thread stack.  This
 138          * should cause a segfault.
 139          */
 140         args.top = NULL;
 141         args.cur = 0;
 142         args.max = (stacksize / FRAME_SIZE) + 1;
 143         fprintf(stderr, "Overflow:\n");
 144         assert(pthread_create(&thread, &attr, recurse, &args) == 0);
 145         assert(pthread_join(thread, NULL) == 0);
 146
 147         /* Not reached. */
 148         fprintf(stderr, "Unexpected success\n");
 149         abort();
 150
 151         return 0;
 152 }