malloc/tst-malloc-stats-cancellation.c

   1 /* Bug 22830: malloc_stats fails to re-enable cancellation on exit.
   2    Copyright (C) 2018 Free Software Foundation.
   3    Copying and distribution of this file, with or without modification,
   4    are permitted in any medium without royalty provided the copyright
   5    notice and this notice are preserved. This file is offered as-is,
   6    without any warranty.  */
   7
   8 #include <errno.h>
   9 #include <stdio.h>
  10 #include <string.h>
  11
  12 #include <pthread.h>
  13 #include <sys/stat.h>
  14 #include <sys/types.h>
  15 #include <fcntl.h>
  16 #include <unistd.h>
  17
  18 #include <malloc.h>
  19
  20 static void *
  21 test_threadproc (void *gatep)
  22 {
  23   /* When we are released from the barrier, there is a cancellation
  24      request pending for this thread.  N.B. pthread_barrier_wait is
  25      not itself a cancellation point (oddly enough).  */
  26   pthread_barrier_wait ((pthread_barrier_t *)gatep);
  27   malloc_stats ();
  28   fputs ("this call should trigger cancellation\n", stderr);
  29   return 0;
  30 }
  31
  32 /* We cannot replace stderr with a memstream because writes to memstreams
  33    do not trigger cancellation.  Instead, main swaps out fd 2 to point to
  34    a pipe, and this thread reads from the pipe and writes to a memstream
  35    until EOF, then returns the data accumulated in the memstream.  main
  36    can't do that itself because, when the test thread gets cancelled,
  37    it doesn't close the pipe.  */
  38
  39 struct buffer_tp_args
  40 {
  41   int ifd;
  42   FILE *real_stderr;
  43 };
  44
  45 static void *
  46 buffer_threadproc (void *argp)
  47 {
  48   struct buffer_tp_args *args = argp;
  49   int ifd = args->ifd;
  50   char block[BUFSIZ], *p;
  51   ssize_t nread;
  52   size_t nwritten;
  53
  54   char *obuf = 0;
  55   size_t obufsz = 0;
  56   FILE *ofp = open_memstream (&obuf, &obufsz);
  57   if (!ofp)
  58     {
  59       fprintf (args->real_stderr,
  60                "buffer_threadproc: open_memstream: %s\n", strerror (errno));
  61       return 0;
  62     }
  63
  64   while ((nread = read (ifd, block, BUFSIZ)) > 0)
  65     {
  66       p = block;
  67       do
  68         {
  69           nwritten = fwrite_unlocked (p, 1, nread, ofp);
  70           if (nwritten == 0)
  71             {
  72               fprintf (args->real_stderr,
  73                        "buffer_threadproc: fwrite_unlocked: %s\n",
  74                        strerror (errno));
  75               return 0;
  76             }
  77           nread -= nwritten;
  78           p += nwritten;
  79         }
  80       while (nread > 0);
  81     }
  82   if (nread == -1)
  83     {
  84       fprintf (args->real_stderr, "buffer_threadproc: read: %s\n",
  85                strerror (errno));
  86       return 0;
  87     }
  88   close (ifd);
  89   fclose (ofp);
  90   return obuf;
  91 }
  92
  93
  94 int
  95 main (void)
  96 {
  97   int result = 0, err, real_stderr_fd, bufpipe[2];
  98   pthread_t t_thr, b_thr;
  99   pthread_barrier_t gate;
 100   void *rv;
 101   FILE *real_stderr;
 102   char *obuf;
 103   void *obuf_v;
 104   struct buffer_tp_args b_args;
 105
 106   real_stderr_fd = dup (2);
 107   if (real_stderr_fd == -1)
 108     {
 109       perror ("dup");
 110       return 2;
 111     }
 112   real_stderr = fdopen(real_stderr_fd, "w");
 113   if (!real_stderr)
 114     {
 115       perror ("fdopen");
 116       return 2;
 117     }
 118   if (setvbuf (real_stderr, 0, _IOLBF, 0))
 119     {
 120       perror ("setvbuf(real_stderr)");
 121       return 2;
 122     }
 123
 124   if (pipe (bufpipe))
 125     {
 126       perror ("pipe");
 127       return 2;
 128     }
 129
 130   /* Below this point, nobody other than the test_threadproc should use
 131      the normal stderr.  */
 132   if (dup2 (bufpipe[1], 2) == -1)
 133     {
 134       fprintf (real_stderr, "dup2: %s\n", strerror (errno));
 135       return 2;
 136     }
 137   close (bufpipe[1]);
 138
 139   b_args.ifd = bufpipe[0];
 140   b_args.real_stderr = real_stderr;
 141   err = pthread_create (&b_thr, 0, buffer_threadproc, &b_args);
 142   if (err)
 143     {
 144       fprintf (real_stderr, "pthread_create(buffer_thr): %s\n",
 145                strerror (err));
 146       return 2;
 147     }
 148
 149   err = pthread_barrier_init (&gate, 0, 2);
 150   if (err)
 151     {
 152       fprintf (real_stderr, "pthread_barrier_init: %s\n", strerror (err));
 153       return 2;
 154     }
 155
 156   err = pthread_create (&t_thr, 0, test_threadproc, &gate);
 157   if (err)
 158     {
 159       fprintf (real_stderr, "pthread_create(test_thr): %s\n", strerror (err));
 160       return 2;
 161     }
 162
 163   err = pthread_cancel (t_thr);
 164   if (err)
 165     {
 166       fprintf (real_stderr, "pthread_cancel: %s\n", strerror (err));
 167       return 2;
 168     }
 169
 170   pthread_barrier_wait (&gate); /* cannot fail */
 171
 172   err = pthread_join (t_thr, &rv);
 173   if (err)
 174     {
 175       fprintf (real_stderr, "pthread_join(test_thr): %s\n", strerror (err));
 176       return 2;
 177     }
 178
 179   /* Closing the normal stderr releases the buffer_threadproc from its
 180      loop.  */
 181   fclose (stderr);
 182   err = pthread_join (b_thr, &obuf_v);
 183   if (err)
 184     {
 185       fprintf (real_stderr, "pthread_join(buffer_thr): %s\n", strerror (err));
 186       return 2;
 187     }
 188   obuf = obuf_v;
 189   if (obuf == 0)
 190     return 2; /* error within buffer_threadproc, already reported */
 191
 192   if (rv != PTHREAD_CANCELED)
 193     {
 194       fputs ("FAIL: thread was not cancelled\n", real_stderr);
 195       result = 1;
 196     }
 197   /* obuf should have received all of the text printed by malloc_stats,
 198      but not the text printed by the final call to fputs.  */
 199   if (!strstr (obuf, "max mmap bytes"))
 200     {
 201       fputs ("FAIL: malloc_stats output incomplete\n", real_stderr);
 202       result = 1;
 203     }
 204   if (strstr (obuf, "this call should trigger cancellation"))
 205     {
 206       fputs ("FAIL: fputs produced output\n", real_stderr);
 207       result = 1;
 208     }
 209
 210   if (result == 1)
 211     {
 212       fputs ("--- output from thread below ---\n", real_stderr);
 213       fputs (obuf, real_stderr);
 214     }
 215   return result;
 216 }