OSDN Git Service

* mf-runtime.c (__mfu_unregister): Warning fix for char unsigned.
[pf3gnuchains/gcc-fork.git] / libmudflap / mf-hooks3.c
1 /* Mudflap: narrow-pointer bounds-checking by tree rewriting.
2    Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3    Contributed by Frank Ch. Eigler <fche@redhat.com>
4    and Graydon Hoare <graydon@redhat.com>
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
11 version.
12
13 In addition to the permissions in the GNU General Public License, the
14 Free Software Foundation gives you unlimited permission to link the
15 compiled version of this file into combinations with other programs,
16 and to distribute those combinations without any restriction coming
17 from the use of this file.  (The General Public License restrictions
18 do apply in other respects; for example, they cover modification of
19 the file, and distribution when not linked into a combine
20 executable.)
21
22 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
23 WARRANTY; without even the implied warranty of MERCHANTABILITY or
24 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
25 for more details.
26
27 You should have received a copy of the GNU General Public License
28 along with GCC; see the file COPYING.  If not, write to the Free
29 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
30 02111-1307, USA.  */
31
32
33 #include "config.h"
34
35 #ifndef HAVE_SOCKLEN_T
36 #define socklen_t int
37 #endif
38
39 /* These attempt to coax various unix flavours to declare all our
40    needed tidbits in the system headers.  */
41 #if !defined(__FreeBSD__) && !defined(__APPLE__)
42 #define _POSIX_SOURCE
43 #endif /* Some BSDs break <sys/socket.h> if this is defined. */
44 #define _GNU_SOURCE
45 #define _XOPEN_SOURCE
46 #define _BSD_TYPES
47 #define __EXTENSIONS__
48 #define _ALL_SOURCE
49 #define _LARGE_FILE_API
50 #define _XOPEN_SOURCE_EXTENDED 1
51
52 #include <string.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <sys/types.h>
56 #include <sys/mman.h>
57 #include <unistd.h>
58 #include <assert.h>
59 #include <errno.h>
60 #include <limits.h>
61 #include <sched.h>
62 #include <fcntl.h>
63
64 #include "mf-runtime.h"
65 #include "mf-impl.h"
66
67 #ifdef _MUDFLAP
68 #error "Do not compile this file with -fmudflap!"
69 #endif
70
71
72 /* Multithreading support hooks.  */
73
74
75
76 #ifndef LIBMUDFLAPTH
77 #error "pthreadstuff is to be included only in libmudflapth"
78 #endif
79
80
81
82 /* Describe a thread (dead or alive). */
83 struct pthread_info
84 {
85   short used_p;  /* Is this slot in use?  */
86   short dead_p;  /* Is this thread dead?  */
87   pthread_t self; /* The thread id.  */
88
89   /* If libmudflapth allocated the stack, store its adjusted base/size.  */
90   void *stack;
91   size_t stack_size;
92   /* The _alloc fields store unadjusted values from the moment of allocation.  */
93   void *stack_alloc;
94   size_t stack_size_alloc;
95
96   int *thread_errno;
97   enum __mf_state_enum state;
98 };
99
100
101 /* Describe the startup information for a new user thread.  */
102 struct pthread_start_info
103 {
104   /* The user's thread entry point and argument.  */
105   void * (*user_fn)(void *);
106   void *user_arg;
107
108   /* Set by user thread when this startup struct may be disposed of.  */
109   struct pthread_info *thread_info;
110 };
111
112
113
114
115 /* To avoid dynamic memory allocation, use static array to store these
116    thread description structs.  The second (_idx) array is used as a
117    simple caching hash table, mapping PTHREAD_HASH(thread) to its
118    index in __mf_pthread_info[]. */
119
120 #define LIBMUDFLAPTH_THREADS_MAX 1024
121 static struct pthread_info __mf_pthread_info[LIBMUDFLAPTH_THREADS_MAX];
122 static unsigned __mf_pthread_info_idx[LIBMUDFLAPTH_THREADS_MAX];
123 #define PTHREAD_HASH(p) ((unsigned) (p) % LIBMUDFLAPTH_THREADS_MAX)
124
125
126 /* Find any old empty entry in __mf_pthread_info; mark it used and
127    return it.  Return NULL if there are no more available slots.  */
128 struct pthread_info*
129 __mf_allocate_blank_threadinfo (unsigned* idx)
130 {
131   static unsigned probe = LIBMUDFLAPTH_THREADS_MAX-1;
132   unsigned probe_at_start = probe;
133   static pthread_mutex_t mutex =
134 #ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
135     PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
136 #else
137     PTHREAD_MUTEX_INITIALIZER;
138 #endif
139   int rc;
140
141   rc = pthread_mutex_lock (& mutex);
142   assert (rc == 0);
143
144   /* Look for a blank spot starting one past the last one we found. */
145   do
146     {
147       probe = (probe + 1) % LIBMUDFLAPTH_THREADS_MAX;
148       struct pthread_info* pi = & __mf_pthread_info [probe];
149       if (! pi->used_p)
150         {
151           /* memset (pi, 0, sizeof (*pi)); */
152           pi->used_p = 1;
153           if (idx != NULL) *idx = probe;
154           /* VERBOSE_TRACE ("allocated threadinfo slot %u\n", probe); */
155           rc = pthread_mutex_unlock (& mutex);
156           assert (rc == 0);
157           return pi;
158         }
159     }
160   while (probe != probe_at_start);
161
162   rc = pthread_mutex_unlock (& mutex);
163   assert (rc == 0);
164   return NULL;
165 }
166
167
168 /* Find and return the pthread_info struct for the current thread.
169    There might already be one in __mf_pthread_info for this thread, in
170    which case return it.  There may not be one (if this is a main
171    thread, an auxiliary -lpthread manager, or an actual user thread
172    making an early call into libmudflap.  In these cases, create a new
173    entry.  If not it's not the main thread, put it into reentrant
174    initial state.
175
176    NB: VERBOSE_TRACE type functions are not generally safe to call
177    from this context, since a new thread might just be "booting up",
178    making printf unsafe to call.
179 */
180 static struct pthread_info*
181 __mf_find_threadinfo ()
182 {
183   pthread_t it = pthread_self ();
184   unsigned *hash = & __mf_pthread_info_idx [PTHREAD_HASH (it)];
185   struct pthread_info *result = NULL;
186   static pthread_t last;
187   static int main_thread_seen_p;
188
189   /* Check out the lookup cache; failing that, do a linear search
190      around the table.  */
191   {
192     struct pthread_info* pi = & __mf_pthread_info [*hash];
193     unsigned i;
194
195     if (pi->used_p && pi->self == it)
196       result = pi;
197     else for (i = 0; i < LIBMUDFLAPTH_THREADS_MAX; i++)
198       {
199         struct pthread_info* pi2 = & __mf_pthread_info [i];
200         if (pi2->used_p && pi2->self == it)
201           {
202             *hash = i;
203             result = pi2;
204             break;
205           }
206       }
207   }
208
209   if (result == NULL)
210     {
211       /* Create a __mf_pthread_info record for the main thread.  It's
212          different from the auto-recognized worker bees because for
213          example we can assume that it's a fully stack/errno-equipped
214          thread. */
215
216       /* This must be the main thread, until now unseen in libmudflap.  */
217       unsigned *hash = & __mf_pthread_info_idx [PTHREAD_HASH (it)];
218       struct pthread_info* pi = __mf_allocate_blank_threadinfo (hash);
219       assert (pi != NULL);
220       assert (pi->used_p);
221       result = pi;
222       result->self = it;
223
224       if (! main_thread_seen_p)
225         {
226           result->state = active;
227           /* NB: leave result->thread_errno unset, as main thread's errno
228              has already been registered in __mf_init.  */
229           /* NB: leave stack-related fields unset, to avoid
230              deallocation.  */
231           main_thread_seen_p = 1;
232           /* VERBOSE_TRACE ("identified self as main thread\n"); */
233         }
234       else
235         {
236           result->state = reentrant;
237           /* NB: leave result->thread_errno unset, as worker thread's
238              errno is unlikely to be used, and user threads fill them
239              in during __mf_pthread_spawn().  */
240           /* NB: leave stack-related fields unset, leaving pthread_create
241              to fill them in for user threads, leaving them empty for
242              other threads.  */
243           /* VERBOSE_TRACE ("identified self as new aux or user thread\n"); */
244         }
245     }
246
247   if (last != it)
248     {
249       /*
250       VERBOSE_TRACE ("found threadinfo for %u, slot %u\n",
251                      (unsigned) it,
252                      (unsigned) *hash);
253       */
254       last = it;
255     }
256
257   assert (result != NULL);
258   assert (result->self == it);
259
260   return result;
261 }
262
263
264
265 /* Return a pointer to the per-thread __mf_state variable.  */
266 enum __mf_state_enum *
267 __mf_state_perthread ()
268 {
269   assert (! __mf_starting_p);
270   return & (__mf_find_threadinfo()->state);
271 }
272
273
274 static void
275 __mf_pthread_cleanup (void *arg)
276 {
277   struct pthread_info *pi = arg;
278
279   /* XXX: This unregistration is not safe on platforms where distinct
280      threads share errno (or at least its virtual address).  */
281   if (pi->thread_errno != NULL)
282     __mf_unregister (pi->thread_errno, sizeof (int), __MF_TYPE_GUESS);
283
284   /* XXX: Only detached threads should designate themselves as dead
285      here.  Non-detached threads are marked dead after their
286      personalized pthread_join() call.  */
287   pi->state = reentrant;
288   pi->dead_p = 1;
289
290   VERBOSE_TRACE ("thread pi %p exiting\n", pi);
291 }
292
293
294 static void *
295 __mf_pthread_spawner (void *arg)
296 {
297   struct pthread_info *pi = __mf_find_threadinfo ();
298   void *result = NULL;
299
300   /* Turn off reentrancy indications.  */
301   assert (pi->state == reentrant);
302   pi->state = active;
303
304   VERBOSE_TRACE ("new user thread\n");
305
306   if (__mf_opts.heur_std_data)
307     {
308       pi->thread_errno = & errno;
309       __mf_register (pi->thread_errno, sizeof (int),
310                      __MF_TYPE_GUESS, "errno area (thread)");
311       /* NB: we could use __MF_TYPE_STATIC above, but we guess that
312          the thread errno is coming out of some dynamically allocated
313          pool that we already know of as __MF_TYPE_HEAP. */
314     }
315
316   /* We considered using pthread_key_t objects instead of these
317      cleanup stacks, but they were less cooperative with the
318      interposed malloc hooks in libmudflap.  */
319   pthread_cleanup_push (& __mf_pthread_cleanup, pi);
320
321   /* Call user thread */
322   {
323     /* Extract given entry point and argument.  */
324     struct pthread_start_info *psi = arg;
325     void * (*user_fn)(void *) = psi->user_fn;
326     void *user_arg = psi->user_arg;
327
328     /* Signal the main thread to resume.  */
329     psi->thread_info = pi;
330
331     result = (*user_fn)(user_arg);
332   }
333
334   pthread_cleanup_pop (1 /* execute */);
335
336   /* NB: there is a slight race here.  The pthread_info field will now
337      say this thread is dead, but it may still be running .. right
338      here.  We try to check for this possibility using the
339      pthread_kill test below. */
340
341   return result;
342 }
343
344
345 #if PIC
346 /* A special bootstrap variant. */
347 int
348 __mf_0fn_pthread_create (pthread_t *thr, const pthread_attr_t *attr,
349                          void * (*start) (void *), void *arg)
350 {
351   return -1;
352 }
353 #endif
354
355
356 #undef pthread_create
357 WRAPPER(int, pthread_create, pthread_t *thr, const pthread_attr_t *attr,
358          void * (*start) (void *), void *arg)
359 {
360   DECLARE(int, munmap, void *p, size_t l);
361   DECLARE(void *, mmap, void *p, size_t l, int prot, int flags, int fd, off_t of);
362   DECLARE(int, pthread_create, pthread_t *thr, const pthread_attr_t *attr,
363           void * (*start) (void *), void *arg);
364   int result;
365   pthread_attr_t override_attr;
366   void *override_stack;
367   size_t override_stacksize;
368   void *override_stack_alloc = (void *) 0;
369   size_t override_stacksize_alloc = 0;
370   unsigned i;
371
372   TRACE ("pthread_create\n");
373
374   /* Garbage-collect dead threads' stacks.  */
375   LOCKTH ();
376   for (i = 0; i < LIBMUDFLAPTH_THREADS_MAX; i++)
377     {
378       struct pthread_info *pi = & __mf_pthread_info [i];
379       if (! pi->used_p)
380         continue;
381       if (! pi->dead_p)
382         continue;
383
384       /* VERBOSE_TRACE ("thread %u pi %p stack cleanup deferred (%u)\n",
385          (unsigned) pi->self, pi, pi->dead_p); */
386
387       /* Delay actual deallocation by a few cycles, try to discourage the
388          race mentioned at the end of __mf_pthread_spawner().  */
389       if (pi->dead_p)
390         pi->dead_p ++;
391       if (pi->dead_p >= 10 /* XXX */)
392         {
393           if (pi->stack)
394             CALL_REAL (munmap, pi->stack_alloc, pi->stack_size_alloc);
395
396           VERBOSE_TRACE ("slot %u freed, stack %p\n", i, pi->stack_alloc);
397           memset (pi, 0, sizeof (*pi));
398
399           /* One round of garbage collection is enough.  */
400           break;
401         }
402     }
403   UNLOCKTH ();
404
405   /* Let's allocate a stack for this thread, if one is not already
406      supplied by the caller.  We don't want to let e.g. the
407      linuxthreads manager thread do this allocation.  */
408   if (attr != NULL)
409     override_attr = *attr;
410   else
411     pthread_attr_init (& override_attr);
412
413   /* Get supplied attributes, if any.  */
414   /* XXX: consider using POSIX2K attr_getstack() */
415   if (pthread_attr_getstackaddr (& override_attr, & override_stack) != 0 ||
416       pthread_attr_getstacksize (& override_attr, & override_stacksize) != 0)
417     {
418       override_stack = NULL;
419       override_stacksize = 0;
420     }
421
422   /* Do we need to allocate the new thread's stack?  */
423   if (__mf_opts.thread_stack && override_stack == NULL)
424     {
425       uintptr_t alignment = 256; /* power of two */
426
427       /* Perturb the initial stack addresses slightly, to encourage
428          threads to have nonconflicting entries in the lookup cache
429          for their tracked stack objects.  */
430       static unsigned perturb = 0;
431       const unsigned perturb_delta = 32;
432       const unsigned perturb_count = 16;
433       perturb += perturb_delta;
434       if (perturb > perturb_delta*perturb_count) perturb = 0;
435
436       /* Use glibc x86 defaults */
437 /* Should have been defined in <limits.h> */
438 #ifndef PTHREAD_STACK_MIN
439 #define PTHREAD_STACK_MIN 65536
440 #endif
441       override_stacksize = max (PTHREAD_STACK_MIN, __mf_opts.thread_stack * 1024);
442
443
444 #if defined(MAP_ANONYMOUS)
445 #define MF_MAP_ANON MAP_ANONYMOUS
446 #elif defined(MAP_ANON)
447 #define MF_MAP_ANON MAP_ANON
448 #endif
449
450 #ifndef MAP_FAILED
451 #define MAP_FAILED ((void *) -1)
452 #endif
453
454 #ifdef MF_MAP_ANON
455       override_stack = CALL_REAL (mmap, NULL, override_stacksize,
456                                   PROT_READ|PROT_WRITE,
457                                   MAP_PRIVATE|MF_MAP_ANON,
458                                   0, 0);
459 #else
460       /* Try mapping /dev/zero instead.  */
461       {
462         static int zerofd = -1;
463         if (zerofd == -1)
464           zerofd = open ("/dev/zero", O_RDWR);
465         if (zerofd == -1)
466           override_stack = MAP_FAILED;
467         else
468           override_stack = CALL_REAL (mmap, NULL, override_stacksize,
469                                       PROT_READ|PROT_WRITE,
470                                       MAP_PRIVATE, zerofd, 0);
471       }
472 #endif
473
474       if (override_stack == 0 || override_stack == MAP_FAILED)
475         {
476           errno = EAGAIN;
477           return -1;
478         }
479
480       VERBOSE_TRACE ("thread stack alloc %p size %lu\n",
481                      override_stack, (unsigned long) override_stacksize);
482
483       /* Save the original allocated values for later deallocation.  */
484       override_stack_alloc = override_stack;
485       override_stacksize_alloc = override_stacksize;
486
487       /* The stackaddr pthreads attribute is a candidate stack pointer.
488          It must point near the top or the bottom of this buffer, depending
489          on whether stack grows downward or upward, and suitably aligned.
490          On the x86, it grows down, so we set stackaddr near the top.  */
491       /* XXX: port logic */
492       override_stack = (void *)
493         (((uintptr_t) override_stack + override_stacksize - alignment - perturb)
494          & (~(uintptr_t)(alignment-1)));
495
496       /* XXX: consider using POSIX2K attr_setstack() */
497       if (pthread_attr_setstackaddr (& override_attr, override_stack) != 0 ||
498           pthread_attr_setstacksize (& override_attr,
499                                      override_stacksize - alignment - perturb) != 0)
500         {
501           /* This should not happen.  */
502           CALL_REAL (munmap, override_stack, override_stacksize);
503           errno = EAGAIN;
504           return -1;
505         }
506   }
507
508   /* Actually start the child thread.  */
509   {
510     struct pthread_start_info psi;
511     struct pthread_info *pi = NULL;
512
513     /* Fill in startup-control fields.  */
514     psi.user_fn = start;
515     psi.user_arg = arg;
516     psi.thread_info = NULL;
517
518     /* Actually create the thread.  */
519     __mf_state = reentrant;
520     result = CALL_REAL (pthread_create, thr, & override_attr,
521                         & __mf_pthread_spawner, (void *) & psi);
522     __mf_state = active;
523     /* We also hook pthread_join/pthread_exit to get into reentrant
524        mode during thread shutdown/cleanup.  */
525
526     /* Wait until child thread has progressed far enough into its
527        __mf_pthread_spawner() call.  */
528     while (1) /* XXX: timeout? */
529       {
530         volatile struct pthread_start_info *psip = & psi;
531         pi = psip->thread_info;
532         if (pi != NULL)
533           break;
534         sched_yield ();
535       }
536
537     /* Fill in remaining fields in pthread_info. */
538     pi->stack = override_stack;
539     pi->stack_size = override_stacksize;
540     pi->stack_alloc = override_stack_alloc;
541     pi->stack_size_alloc = override_stacksize_alloc;
542     /* XXX: this might be too late for future heuristics that attempt
543        to use thread stack bounds.  We may need to put the new thread
544        to sleep. */
545   }
546
547
548   /* May need to clean up if we created a pthread_attr_t of our own.  */
549   if (attr == NULL)
550     pthread_attr_destroy (& override_attr); /* NB: this shouldn't deallocate stack */
551
552   return result;
553 }
554
555
556
557 #if PIC
558 /* A special bootstrap variant. */
559 int
560 __mf_0fn_pthread_join (pthread_t thr, void **rc)
561 {
562   return -1;
563 }
564 #endif
565
566
567 #undef pthread_join
568 WRAPPER(int, pthread_join, pthread_t thr, void **rc)
569 {
570   DECLARE(int, pthread_join, pthread_t thr, void **rc);
571   int result;
572
573   TRACE ("pthread_join\n");
574   __mf_state = reentrant;
575   result = CALL_REAL (pthread_join, thr, rc);
576   __mf_state = active;
577
578   return result;
579 }
580
581
582 #if PIC
583 /* A special bootstrap variant. */
584 void
585 __mf_0fn_pthread_exit (void *rc)
586 {
587 }
588 #endif
589
590
591 #undef pthread_exit
592 WRAPPER(void, pthread_exit, void *rc)
593 {
594   DECLARE(void, pthread_exit, void *rc);
595
596   TRACE ("pthread_exit\n");
597   /* __mf_state = reentrant; */
598   CALL_REAL (pthread_exit, rc);
599   /* NOTREACHED */
600   exit (0);  /* Satisfy noreturn attribute of pthread_exit.  */
601 }