OSDN Git Service

6a14cb2adfa0551ae2c74fbbbc30fe80d2b1fb19
[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 static struct pthread_info* 
177 __mf_find_threadinfo ()
178 {
179   pthread_t it = pthread_self ();
180   unsigned *hash = & __mf_pthread_info_idx [PTHREAD_HASH (it)];
181   struct pthread_info *result = NULL;
182   static pthread_t last;
183   static int main_thread_seen_p;
184
185   /* Check out the lookup cache; failing that, do a linear search
186      around the table.  */
187   {
188     struct pthread_info* pi = & __mf_pthread_info [*hash];
189     unsigned i;
190
191     if (pi->used_p && pi->self == it)
192       result = pi;
193     else for (i = 0; i < LIBMUDFLAPTH_THREADS_MAX; i++)
194       {
195         struct pthread_info* pi2 = & __mf_pthread_info [i];
196         if (pi2->used_p && pi2->self == it) 
197           {
198             *hash = i;
199             result = pi2;
200             break;
201           }
202       }
203   }    
204
205   if (result == NULL)
206     {
207       /* Create a __mf_pthread_info record for the main thread.  It's
208          different from the auto-recognized worker bees because for
209          example we can assume that it's a fully stack/errno-equipped
210          thread. */
211
212       /* This must be the main thread, until now unseen in libmudflap.  */
213       unsigned *hash = & __mf_pthread_info_idx [PTHREAD_HASH (it)];
214       struct pthread_info* pi = __mf_allocate_blank_threadinfo (hash);
215       assert (pi != NULL);
216       assert (pi->used_p);
217       result = pi;
218       result->self = it;
219
220       if (! main_thread_seen_p)
221         {
222           result->state = active;
223           /* NB: leave result->thread_errno unset, as main thread's errno
224              has already been registered in __mf_init.  */
225           /* NB: leave stack-related fields unset, to avoid
226              deallocation.  */
227           main_thread_seen_p = 1;
228           VERBOSE_TRACE ("identified self as main thread\n");
229         }
230       else
231         {
232           result->state = reentrant;
233           /* NB: leave result->thread_errno unset, as worker thread's
234              errno is unlikely to be used, and user threads fill them
235              in during __mf_pthread_spawn().  */
236           /* NB: leave stack-related fields unset, leaving pthread_create
237              to fill them in for user threads, leaving them empty for
238              other threads.  */
239           VERBOSE_TRACE ("identified self as new aux or user thread\n");
240         }
241     }
242
243   if (last != it)
244     {
245       VERBOSE_TRACE ("found threadinfo for %u, slot %u\n", 
246                      (unsigned) it,
247                      (unsigned) *hash);
248       last = it;
249     }
250
251   assert (result != NULL);
252   assert (result->self == it);
253
254   return result;
255 }
256
257
258
259 /* Return a pointer to the per-thread __mf_state variable.  */
260 enum __mf_state_enum *
261 __mf_state_perthread ()
262 {
263   assert (! __mf_starting_p);
264   return & (__mf_find_threadinfo()->state);
265 }
266
267
268 static void 
269 __mf_pthread_cleanup (void *arg)
270 {
271   struct pthread_info *pi = arg;
272
273   /* XXX: This unregistration is not safe on platforms where distinct
274      threads share errno (or at least its virtual address).  */
275   if (pi->thread_errno != NULL)
276     __mf_unregister (pi->thread_errno, sizeof (int));
277
278   /* XXX: Only detached threads should designate themselves as dead
279      here.  Non-detached threads are marked dead after their
280      personalized pthread_join() call.  */
281   pi->state = reentrant;
282   pi->dead_p = 1;
283
284   VERBOSE_TRACE ("thread pi %p exiting\n", pi);
285 }
286
287
288 static void *
289 __mf_pthread_spawner (void *arg)
290 {
291   struct pthread_info *pi = __mf_find_threadinfo ();
292   void *result = NULL;
293
294   /* Turn off reentrancy indications.  */
295   assert (pi->state == reentrant);
296   pi->state = active;
297
298   VERBOSE_TRACE ("new user thread\n");
299   
300   if (__mf_opts.heur_std_data)
301     {
302       pi->thread_errno = & errno;
303       __mf_register (pi->thread_errno, sizeof (int), 
304                      __MF_TYPE_GUESS, "errno area (thread)");
305       /* NB: we could use __MF_TYPE_STATIC above, but we guess that
306          the thread errno is coming out of some dynamically allocated
307          pool that we already know of as __MF_TYPE_HEAP. */
308     }
309
310   /* We considered using pthread_key_t objects instead of these
311      cleanup stacks, but they were less cooperative with the
312      interposed malloc hooks in libmudflap.  */
313   pthread_cleanup_push (& __mf_pthread_cleanup, pi);
314
315   /* Call user thread */
316   {
317     /* Extract given entry point and argument.  */
318     struct pthread_start_info *psi = arg;
319     void * (*user_fn)(void *) = psi->user_fn;
320     void *user_arg = psi->user_arg;
321
322     /* Signal the main thread to resume.  */
323     psi->thread_info = pi;
324       
325     result = (*user_fn)(user_arg);
326   }
327
328   pthread_cleanup_pop (1 /* execute */);
329
330   /* NB: there is a slight race here.  The pthread_info field will now
331      say this thread is dead, but it may still be running .. right
332      here.  We try to check for this possibility using the
333      pthread_kill test below. */
334
335   return result;
336 }
337
338
339 #if PIC
340 /* A special bootstrap variant. */
341 int
342 __mf_0fn_pthread_create (pthread_t *thr, const pthread_attr_t *attr, 
343                          void * (*start) (void *), void *arg)
344 {
345   return -1;
346 }
347 #endif
348
349
350 #undef pthread_create
351 WRAPPER(int, pthread_create, pthread_t *thr, const pthread_attr_t *attr, 
352          void * (*start) (void *), void *arg)
353 {
354   DECLARE(int, munmap, void *p, size_t l);
355   DECLARE(void *, mmap, void *p, size_t l, int prot, int flags, int fd, off_t of);
356   DECLARE(int, pthread_create, pthread_t *thr, const pthread_attr_t *attr, 
357           void * (*start) (void *), void *arg);
358   int result;
359   pthread_attr_t override_attr;
360   void *override_stack;
361   size_t override_stacksize;
362   void *override_stack_alloc = (void *) 0;
363   size_t override_stacksize_alloc = 0;
364   unsigned i;
365
366   TRACE ("pthread_create\n");
367
368   /* Garbage-collect dead threads' stacks.  */
369   LOCKTH ();
370   for (i = 0; i < LIBMUDFLAPTH_THREADS_MAX; i++)
371     {
372       struct pthread_info *pi = & __mf_pthread_info [i];
373       if (! pi->used_p)
374         continue;
375       if (! pi->dead_p)
376         continue;
377
378       /* VERBOSE_TRACE ("thread %u pi %p stack cleanup deferred (%u)\n",
379          (unsigned) pi->self, pi, pi->dead_p); */
380               
381       /* Delay actual deallocation by a few cycles, try to discourage the
382          race mentioned at the end of __mf_pthread_spawner().  */
383       if (pi->dead_p)
384         pi->dead_p ++;
385       if (pi->dead_p >= 10 /* XXX */)
386         {
387           if (pi->stack)
388             CALL_REAL (munmap, pi->stack_alloc, pi->stack_size_alloc);
389
390           VERBOSE_TRACE ("slot %u freed, stack %p\n", i, pi->stack_alloc);
391           memset (pi, 0, sizeof (*pi));
392
393           /* One round of garbage collection is enough.  */
394           break;
395         }
396     }
397   UNLOCKTH ();
398
399   /* Let's allocate a stack for this thread, if one is not already
400      supplied by the caller.  We don't want to let e.g. the
401      linuxthreads manager thread do this allocation.  */
402   if (attr != NULL)
403     override_attr = *attr;
404   else
405     pthread_attr_init (& override_attr);
406
407   /* Get supplied attributes, if any.  */
408   /* XXX: consider using POSIX2K attr_getstack() */
409   if (pthread_attr_getstackaddr (& override_attr, & override_stack) != 0 ||
410       pthread_attr_getstacksize (& override_attr, & override_stacksize) != 0)
411     {
412       override_stack = NULL;
413       override_stacksize = 0;
414     }
415
416   /* Do we need to allocate the new thread's stack?  */
417   if (__mf_opts.thread_stack && override_stack == NULL)
418     {
419       uintptr_t alignment = 256; /* power of two */
420
421       /* Perturb the initial stack addresses slightly, to encourage
422          threads to have nonconflicting entries in the lookup cache
423          for their tracked stack objects.  */
424       static unsigned perturb = 0;
425       const unsigned perturb_delta = 32;
426       const unsigned perturb_count = 16;
427       perturb += perturb_delta;
428       if (perturb > perturb_delta*perturb_count) perturb = 0;
429
430       /* Use glibc x86 defaults */
431 /* Should have been defined in <limits.h> */
432 #ifndef PTHREAD_STACK_MIN
433 #define PTHREAD_STACK_MIN 65536
434 #endif
435       override_stacksize = max (PTHREAD_STACK_MIN, __mf_opts.thread_stack * 1024);
436
437
438 #if defined(MAP_ANONYMOUS)
439 #define MF_MAP_ANON MAP_ANONYMOUS
440 #elif defined(MAP_ANON)
441 #define MF_MAP_ANON MAP_ANON
442 #endif
443
444 #ifndef MAP_FAILED
445 #define MAP_FAILED ((void *) -1)
446 #endif
447
448 #ifdef MF_MAP_ANON
449       override_stack = CALL_REAL (mmap, NULL, override_stacksize, 
450                                   PROT_READ|PROT_WRITE, 
451                                   MAP_PRIVATE|MF_MAP_ANON,
452                                   0, 0);
453 #else
454       /* Try mapping /dev/zero instead.  */
455       {
456         static int zerofd = -1;
457         if (zerofd == -1)
458           zerofd = open ("/dev/zero", O_RDWR);
459         if (zerofd == -1)
460           override_stack = MAP_FAILED;
461         else
462           override_stack = CALL_REAL (mmap, NULL, override_stacksize, 
463                                       PROT_READ|PROT_WRITE, 
464                                       MAP_PRIVATE, zerofd, 0);
465       }
466 #endif
467
468       if (override_stack == 0 || override_stack == MAP_FAILED)
469         {
470           errno = EAGAIN;
471           return -1;
472         }
473
474       VERBOSE_TRACE ("thread stack alloc %p size %lu\n", 
475                      override_stack, (unsigned long) override_stacksize);
476
477       /* Save the original allocated values for later deallocation.  */
478       override_stack_alloc = override_stack;
479       override_stacksize_alloc = override_stacksize;
480
481       /* The stackaddr pthreads attribute is a candidate stack pointer.
482          It must point near the top or the bottom of this buffer, depending
483          on whether stack grows downward or upward, and suitably aligned.
484          On the x86, it grows down, so we set stackaddr near the top.  */
485       /* XXX: port logic */
486       override_stack = (void *)
487         (((uintptr_t) override_stack + override_stacksize - alignment - perturb)
488          & (~(uintptr_t)(alignment-1)));
489       
490       /* XXX: consider using POSIX2K attr_setstack() */
491       if (pthread_attr_setstackaddr (& override_attr, override_stack) != 0 ||
492           pthread_attr_setstacksize (& override_attr, 
493                                      override_stacksize - alignment - perturb) != 0)
494         {
495           /* This should not happen.  */
496           CALL_REAL (munmap, override_stack, override_stacksize);
497           errno = EAGAIN;
498           return -1;
499         }
500   }
501
502   /* Actually start the child thread.  */
503   {
504     struct pthread_start_info psi;
505     struct pthread_info *pi = NULL;
506     
507     /* Fill in startup-control fields.  */
508     psi.user_fn = start;
509     psi.user_arg = arg;
510     psi.thread_info = NULL;
511     
512     /* Actually create the thread.  */
513     __mf_state = reentrant;
514     result = CALL_REAL (pthread_create, thr, & override_attr,
515                         & __mf_pthread_spawner, (void *) & psi);
516     __mf_state = active;
517     /* We also hook pthread_join/pthread_exit to get into reentrant
518        mode during thread shutdown/cleanup.  */
519
520     /* Wait until child thread has progressed far enough into its
521        __mf_pthread_spawner() call.  */
522     while (1) /* XXX: timeout? */
523       {
524         volatile struct pthread_start_info *psip = & psi;
525         pi = psip->thread_info;
526         if (pi != NULL) 
527           break;
528         sched_yield ();
529       }
530
531     /* Fill in remaining fields in pthread_info. */
532     pi->stack = override_stack;
533     pi->stack_size = override_stacksize;
534     pi->stack_alloc = override_stack_alloc;
535     pi->stack_size_alloc = override_stacksize_alloc;
536     /* XXX: this might be too late for future heuristics that attempt
537        to use thread stack bounds.  We may need to put the new thread
538        to sleep. */
539   }
540
541
542   /* May need to clean up if we created a pthread_attr_t of our own.  */
543   if (attr == NULL)
544     pthread_attr_destroy (& override_attr); /* NB: this shouldn't deallocate stack */
545
546   return result;
547 }
548
549
550
551 #if PIC
552 /* A special bootstrap variant. */
553 int
554 __mf_0fn_pthread_join (pthread_t thr, void **rc)
555 {
556   return -1;
557 }
558 #endif
559
560
561 #undef pthread_join
562 WRAPPER(int, pthread_join, pthread_t thr, void **rc)
563 {
564   DECLARE(int, pthread_join, pthread_t thr, void **rc);
565   int result;
566
567   TRACE ("pthread_join\n");
568   __mf_state = reentrant;
569   result = CALL_REAL (pthread_join, thr, rc);
570   __mf_state = active;
571   
572   return result;
573 }
574
575
576 #if PIC
577 /* A special bootstrap variant. */
578 void
579 __mf_0fn_pthread_exit (void *rc)
580 {
581 }
582 #endif
583
584
585 #undef pthread_exit
586 WRAPPER(void, pthread_exit, void *rc)
587 {
588   DECLARE(void, pthread_exit, void *rc);
589
590   TRACE ("pthread_exit\n");
591   /* __mf_state = reentrant; */
592   CALL_REAL (pthread_exit, rc);
593   /* NOTREACHED */
594 }