libbacktrace/ttest.c

   1 /* ttest.c -- Test for libbacktrace library
   2    Copyright (C) 2017-2022 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Google.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions are
   7 met:
   8
   9     (1) Redistributions of source code must retain the above copyright
  10     notice, this list of conditions and the following disclaimer.
  11
  12     (2) Redistributions in binary form must reproduce the above copyright
  13     notice, this list of conditions and the following disclaimer in
  14     the documentation and/or other materials provided with the
  15     distribution.
  16
  17     (3) The name of the author may not be used to
  18     endorse or promote products derived from this software without
  19     specific prior written permission.
  20
  21 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  23 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  24 DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  25 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  30 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31 POSSIBILITY OF SUCH DAMAGE.  */
  32
  33 /* Test using the libbacktrace library from multiple threads.  */
  34
  35 #include <assert.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39
  40 #include <pthread.h>
  41
  42 #include "filenames.h"
  43
  44 #include "backtrace.h"
  45 #include "backtrace-supported.h"
  46
  47 #include "testlib.h"
  48
  49 static int f2 (int) __attribute__ ((noinline));
  50 static int f3 (int, int) __attribute__ ((noinline));
  51
  52 /* Test that a simple backtrace works.  This is called via
  53    pthread_create.  It returns the number of failures, as void *.  */
  54
  55 static void *
  56 test1_thread (void *arg ATTRIBUTE_UNUSED)
  57 {
  58   /* Returning a value here and elsewhere avoids a tailcall which
  59      would mess up the backtrace.  */
  60   return (void *) (uintptr_t) (f2 (__LINE__) - 2);
  61 }
  62
  63 static int
  64 f2 (int f1line)
  65 {
  66   return f3 (f1line, __LINE__) + 2;
  67 }
  68
  69 static int
  70 f3 (int f1line, int f2line)
  71 {
  72   struct info all[20];
  73   struct bdata data;
  74   int f3line;
  75   int i;
  76
  77   data.all = &all[0];
  78   data.index = 0;
  79   data.max = 20;
  80   data.failed = 0;
  81
  82   f3line = __LINE__ + 1;
  83   i = backtrace_full (state, 0, callback_one, error_callback_one, &data);
  84
  85   if (i != 0)
  86     {
  87       fprintf (stderr, "test1: unexpected return value %d\n", i);
  88       data.failed = 1;
  89     }
  90
  91   if (data.index < 3)
  92     {
  93       fprintf (stderr,
  94                "test1: not enough frames; got %zu, expected at least 3\n",
  95                data.index);
  96       data.failed = 1;
  97     }
  98
  99   check ("test1", 0, all, f3line, "f3", "ttest.c", &data.failed);
 100   check ("test1", 1, all, f2line, "f2", "ttest.c", &data.failed);
 101   check ("test1", 2, all, f1line, "test1_thread", "ttest.c", &data.failed);
 102
 103   return data.failed;
 104 }
 105
 106 /* Run the test with 10 threads simultaneously.  */
 107
 108 #define THREAD_COUNT 10
 109
 110 static void test1 (void) __attribute__ ((unused));
 111
 112 static void
 113 test1 (void)
 114 {
 115   pthread_t atid[THREAD_COUNT];
 116   int i;
 117   int errnum;
 118   int this_fail;
 119   void *ret;
 120
 121   for (i = 0; i < THREAD_COUNT; i++)
 122     {
 123       errnum = pthread_create (&atid[i], NULL, test1_thread, NULL);
 124       if (errnum != 0)
 125         {
 126           fprintf (stderr, "pthread_create %d: %s\n", i, strerror (errnum));
 127           exit (EXIT_FAILURE);
 128         }
 129     }
 130
 131   this_fail = 0;
 132   for (i = 0; i < THREAD_COUNT; i++)
 133     {
 134       errnum = pthread_join (atid[i], &ret);
 135       if (errnum != 0)
 136         {
 137           fprintf (stderr, "pthread_join %d: %s\n", i, strerror (errnum));
 138           exit (EXIT_FAILURE);
 139         }
 140       this_fail += (int) (uintptr_t) ret;
 141     }
 142
 143   printf ("%s: threaded backtrace_full noinline\n", this_fail > 0 ? "FAIL" : "PASS");
 144
 145   failures += this_fail;
 146 }
 147
 148 int
 149 main (int argc ATTRIBUTE_UNUSED, char **argv)
 150 {
 151   state = backtrace_create_state (argv[0], BACKTRACE_SUPPORTS_THREADS,
 152                                   error_callback_create, NULL);
 153
 154 #if BACKTRACE_SUPPORTED
 155 #if BACKTRACE_SUPPORTS_THREADS
 156   test1 ();
 157 #endif
 158 #endif
 159
 160   exit (failures ? EXIT_FAILURE : EXIT_SUCCESS);
 161 }