libmudflap/mf-impl.h

   1 /* Implementation header for mudflap runtime library.
   2    Mudflap: narrow-pointer bounds-checking by tree rewriting.
   3    Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
   4    Contributed by Frank Ch. Eigler <fche@redhat.com>
   5    and Graydon Hoare <graydon@redhat.com>
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 2, or (at your option) any later
  12 version.
  13
  14 In addition to the permissions in the GNU General Public License, the
  15 Free Software Foundation gives you unlimited permission to link the
  16 compiled version of this file into combinations with other programs,
  17 and to distribute those combinations without any restriction coming
  18 from the use of this file.  (The General Public License restrictions
  19 do apply in other respects; for example, they cover modification of
  20 the file, and distribution when not linked into a combine
  21 executable.)
  22
  23 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  24 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  25 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  26 for more details.
  27
  28 You should have received a copy of the GNU General Public License
  29 along with GCC; see the file COPYING.  If not, write to the Free
  30 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  31 02110-1301, USA.  */
  32
  33 #ifndef __MF_IMPL_H
  34 #define __MF_IMPL_H
  35
  36 #ifdef _MUDFLAP
  37 #error "Do not compile this file with -fmudflap!"
  38 #endif
  39
  40 #if HAVE_PTHREAD_H
  41 #include <pthread.h>
  42 #elif LIBMUDFLAPTH
  43 #error "Cannot build libmudflapth without pthread.h."
  44 #endif
  45
  46 #if HAVE_STDINT_H
  47 #include <stdint.h>
  48 #else
  49 typedef __mf_uintptr_t uintptr_t;
  50 #endif
  51
  52 /* Private definitions related to mf-runtime.h  */
  53
  54 #define __MF_TYPE_MAX_CEM  __MF_TYPE_STACK  /* largest type# for the cemetary */
  55 #define __MF_TYPE_MAX __MF_TYPE_GUESS
  56
  57
  58 #ifndef max
  59 #define max(a,b) ((a) > (b) ? (a) : (b))
  60 #endif
  61
  62 #ifndef min
  63 #define min(a,b) ((a) < (b) ? (a) : (b))
  64 #endif
  65
  66 /* Address calculation macros.  */
  67
  68 #define MINPTR ((uintptr_t) 0)
  69 #define MAXPTR (~ (uintptr_t) 0)
  70
  71 /* Clamp the addition/subtraction of uintptr_t's to [MINPTR,MAXPTR] */
  72 #define CLAMPSUB(ptr,offset) (((uintptr_t) ptr) >= (offset) ? ((uintptr_t) ptr)-((uintptr_t) offset) : MINPTR)
  73 #define CLAMPADD(ptr,offset) (((uintptr_t) ptr) <= MAXPTR-(offset) ? ((uintptr_t) ptr)+((uintptr_t) offset) : MAXPTR)
  74 #define CLAMPSZ(ptr,size) ((size) ? (((uintptr_t) ptr) <= MAXPTR-(size)+1 ? ((uintptr_t) ptr)+((uintptr_t) size) - 1 : MAXPTR) : ((uintptr_t) ptr))
  75
  76 #define __MF_CACHE_INDEX(ptr) ((((uintptr_t) (ptr)) >> __mf_lc_shift) & __mf_lc_mask)
  77 #define __MF_CACHE_MISS_P(ptr,sz) ({ \
  78              struct __mf_cache *elem = & __mf_lookup_cache[__MF_CACHE_INDEX((ptr))]; \
  79              ((elem->low > (uintptr_t) (ptr)) ||                  \
  80               (elem->high < (CLAMPADD((uintptr_t) (ptr), (uintptr_t) CLAMPSUB(sz,1) )))); })
  81 /* XXX: the above should use CLAMPSZ () */
  82
  83
  84
  85 /* Private functions. */
  86
  87 extern void __mf_violation (void *ptr, size_t sz,
  88                             uintptr_t pc, const char *location,
  89                             int type);
  90 extern size_t __mf_backtrace (char ***, void *, unsigned);
  91 extern int __mf_heuristic_check (uintptr_t, uintptr_t);
  92
  93 /* ------------------------------------------------------------------------ */
  94 /* Type definitions. */
  95 /* ------------------------------------------------------------------------ */
  96
  97 /* The mf_state type codes describe recursion and initialization order.
  98
  99    reentrant means we are inside a mf-runtime support routine, such as
 100    __mf_register, and thus there should be no calls to any wrapped functions,
 101    such as the wrapped malloc.  This indicates a bug if it occurs.
 102    in_malloc means we are inside a real malloc call inside a wrapped malloc
 103    call, and thus there should be no calls to any wrapped functions like the
 104    wrapped mmap.  This happens on some systems due to how the system libraries
 105    are constructed.  */
 106
 107 enum __mf_state_enum { active, reentrant, in_malloc };
 108
 109 /* The __mf_options structure records optional or tunable aspects of the
 110  mudflap library's behavior. There is a single global instance of this
 111  structure which is populated from user input (in an environment variable)
 112  when the library initializes. */
 113
 114 struct __mf_options
 115 {
 116   /* Emit a trace message for each call. */
 117   unsigned trace_mf_calls;
 118
 119   /* Collect and emit statistics. */
 120   unsigned collect_stats;
 121
 122   /* Set up a SIGUSR1 -> __mf_report handler. */
 123   unsigned sigusr1_report;
 124
 125   /* Execute internal checking code. */
 126   unsigned internal_checking;
 127
 128   /* Age object liveness periodically. */
 129   unsigned tree_aging;
 130
 131   /* Adapt the lookup cache to working set. */
 132   unsigned adapt_cache;
 133
 134   /* Print list of leaked heap objects on shutdown. */
 135   unsigned print_leaks;
 136
 137 #ifdef HAVE___LIBC_FREERES
 138   /* Call __libc_freeres before leak analysis. */
 139   unsigned call_libc_freeres;
 140 #endif
 141
 142   /* Detect reads of uninitialized objects. */
 143   unsigned check_initialization;
 144
 145   /* Print verbose description of violations. */
 146   unsigned verbose_violations;
 147
 148   /* Abbreviate duplicate object descriptions.  */
 149   unsigned abbreviate;
 150
 151   /* Emit internal tracing message. */
 152   unsigned verbose_trace;
 153
 154   /* Wipe stack/heap objects upon unwind.  */
 155   unsigned wipe_stack;
 156   unsigned wipe_heap;
 157
 158   /* Maintain a queue of this many deferred free()s,
 159      to trap use of freed memory. */
 160   unsigned free_queue_length;
 161
 162   /* Maintain a history of this many past unregistered objects. */
 163   unsigned persistent_count;
 164
 165   /* Pad allocated extents by this many bytes on either side. */
 166   unsigned crumple_zone;
 167
 168   /* Maintain this many stack frames for contexts. */
 169   unsigned backtrace;
 170
 171   /* Ignore read operations even if mode_check is in effect.  */
 172   unsigned ignore_reads;
 173
 174   /* Collect register/unregister timestamps.  */
 175   unsigned timestamps;
 176
 177 #ifdef LIBMUDFLAPTH
 178   /* Thread stack size.  */
 179   unsigned thread_stack;
 180 #endif
 181
 182   /* Major operation mode */
 183 #define mode_nop 0      /* Do nothing.  */
 184 #define mode_populate 1 /* Populate tree but do not check for violations.  */
 185 #define mode_check 2    /* Populate and check for violations (normal).  */
 186 #define mode_violate 3  /* Trigger a violation on every call (diagnostic).  */
 187   unsigned mudflap_mode;
 188
 189   /* How to handle a violation. */
 190 #define viol_nop 0   /* Return control to application. */
 191 #define viol_segv 1  /* Signal self with segv. */
 192 #define viol_abort 2 /* Call abort (). */
 193 #define viol_gdb 3   /* Fork a debugger on self */
 194   unsigned violation_mode;
 195
 196   /* Violation heuristics selection. */
 197   unsigned heur_stack_bound; /* allow current stack region */
 198   unsigned heur_proc_map;  /* allow & cache /proc/self/map regions.  */
 199   unsigned heur_start_end; /* allow _start .. _end */
 200   unsigned heur_std_data; /* allow & cache stdlib data */
 201 };
 202
 203
 204 #ifdef PIC
 205
 206 /* This is a table of dynamically resolved function pointers. */
 207
 208 struct __mf_dynamic_entry
 209 {
 210   void *pointer;
 211   char *name;
 212   char *version;
 213 };
 214
 215 /* The definition of the array (mf-runtime.c) must match the enums!  */
 216 extern struct __mf_dynamic_entry __mf_dynamic[];
 217 enum __mf_dynamic_index
 218 {
 219   dyn_calloc, dyn_free, dyn_malloc, dyn_mmap,
 220   dyn_munmap, dyn_realloc,
 221   dyn_INITRESOLVE,  /* Marker for last init-time resolution. */
 222 #ifdef LIBMUDFLAPTH
 223   dyn_pthread_create
 224 #endif
 225 };
 226
 227 #endif /* PIC */
 228
 229 /* ------------------------------------------------------------------------ */
 230 /* Private global variables. */
 231 /* ------------------------------------------------------------------------ */
 232
 233 #ifdef LIBMUDFLAPTH
 234 extern pthread_mutex_t __mf_biglock;
 235 #define LOCKTH() do { extern unsigned long __mf_lock_contention; \
 236                       int rc = pthread_mutex_trylock (& __mf_biglock); \
 237                       if (rc) { __mf_lock_contention ++; \
 238                                 rc = pthread_mutex_lock (& __mf_biglock); } \
 239                       assert (rc==0); } while (0)
 240 #define UNLOCKTH() do { int rc = pthread_mutex_unlock (& __mf_biglock); \
 241                         assert (rc==0); } while (0)
 242 #else
 243 #define LOCKTH() do {} while (0)
 244 #define UNLOCKTH() do {} while (0)
 245 #endif
 246
 247 #if defined(LIBMUDFLAPTH) && !defined(HAVE_TLS)
 248 extern enum __mf_state_enum __mf_get_state (void);
 249 extern void __mf_set_state (enum __mf_state_enum);
 250 #else
 251 # ifdef LIBMUDFLAPTH
 252 extern __thread enum __mf_state_enum __mf_state_1;
 253 # else
 254 extern enum __mf_state_enum __mf_state_1;
 255 # endif
 256 static inline enum __mf_state_enum __mf_get_state (void)
 257 {
 258   return __mf_state_1;
 259 }
 260 static inline void __mf_set_state (enum __mf_state_enum s)
 261 {
 262   __mf_state_1 = s;
 263 }
 264 #endif
 265
 266 extern int __mf_starting_p;
 267 extern struct __mf_options __mf_opts;
 268
 269 /* ------------------------------------------------------------------------ */
 270 /* Utility macros. */
 271 /* ------------------------------------------------------------------------ */
 272
 273 #define UNLIKELY(e) (__builtin_expect (!!(e), 0))
 274 #define LIKELY(e) (__builtin_expect (!!(e), 1))
 275 #define STRINGIFY2(e) #e
 276 #define STRINGIFY(e) STRINGIFY2(e)
 277
 278 #ifdef LIBMUDFLAPTH
 279 #define VERBOSE_TRACE(...) \
 280   do { if (UNLIKELY (__mf_opts.verbose_trace)) {  \
 281       fprintf (stderr, "mf(%u): ", (unsigned) pthread_self ()); \
 282       fprintf (stderr, __VA_ARGS__); \
 283     } } while (0)
 284 #define TRACE(...) \
 285   do { if (UNLIKELY (__mf_opts.trace_mf_calls)) { \
 286       fprintf (stderr, "mf(%u): ", (unsigned) pthread_self ()); \
 287       fprintf (stderr, __VA_ARGS__); \
 288     } } while (0)
 289 #else
 290 #define VERBOSE_TRACE(...) \
 291   do { if (UNLIKELY (__mf_opts.verbose_trace)) {  \
 292       fprintf (stderr, "mf: "); \
 293       fprintf (stderr, __VA_ARGS__); \
 294     } } while (0)
 295 #define TRACE(...) \
 296   do { if (UNLIKELY (__mf_opts.trace_mf_calls)) { \
 297       fprintf (stderr, "mf: "); \
 298       fprintf (stderr, __VA_ARGS__); \
 299     } } while (0)
 300 #endif
 301
 302
 303 #define __MF_PERSIST_MAX 256
 304 #define __MF_FREEQ_MAX 256
 305
 306 /*
 307    Wrapping and redirection:
 308
 309    Mudflap redirects a number of libc functions into itself, for "cheap"
 310    verification (eg. strcpy, bzero, memcpy) and also to register /
 311    unregister regions of memory as they are manipulated by the program
 312    (eg. malloc/free, mmap/munmap).
 313
 314    There are two methods of wrapping.
 315
 316    (1) The static method involves a list of -wrap=foo flags being passed to
 317    the linker, which then links references to "foo" to the symbol
 318    "__wrap_foo", and links references to "__real_foo" to the symbol "foo".
 319    When compiled without -DPIC, libmudflap.a contains such __wrap_foo
 320    functions which delegate to __real_foo functions in libc to get their
 321    work done.
 322
 323    (2) The dynamic method involves providing a definition of symbol foo in
 324    libmudflap.so and linking it earlier in the compiler command line,
 325    before libc.so. The function "foo" in libmudflap must then call
 326    dlsym(RTLD_NEXT, "foo") to acquire a pointer to the "real" libc foo, or
 327    at least the "next" foo in the dynamic link resolution order.
 328
 329    We switch between these two techniques by the presence of the -DPIC
 330    #define passed in by libtool when building libmudflap.
 331 */
 332
 333
 334 #ifdef PIC
 335
 336 extern void __mf_resolve_single_dynamic (struct __mf_dynamic_entry *);
 337
 338 #define _GNU_SOURCE
 339 #include <dlfcn.h>
 340
 341 #define WRAPPER(ret, fname, ...)                      \
 342 ret __wrap_ ## fname (__VA_ARGS__)                    \
 343     __attribute__ (( alias  (#fname)  ));             \
 344 ret __real_ ## fname (__VA_ARGS__)                    \
 345     __attribute__ (( alias  (#fname)  ));             \
 346 ret fname (__VA_ARGS__)
 347 #define DECLARE(ty, fname, ...)                       \
 348  typedef ty (*__mf_fn_ ## fname) (__VA_ARGS__);       \
 349  extern ty __mf_0fn_ ## fname (__VA_ARGS__);
 350 #define CALL_REAL(fname, ...)                         \
 351   ({__mf_starting_p \
 352      ? __mf_0fn_ ## fname (__VA_ARGS__) \
 353     : (__mf_resolve_single_dynamic (& __mf_dynamic[dyn_ ## fname]), \
 354        (((__mf_fn_ ## fname)(__mf_dynamic[dyn_ ## fname].pointer)) (__VA_ARGS__)));})
 355 #define CALL_BACKUP(fname, ...)                       \
 356   __mf_0fn_ ## fname(__VA_ARGS__)
 357
 358 #else /* not PIC --> static library */
 359
 360 #define WRAPPER(ret, fname, ...)            \
 361 ret __wrap_ ## fname (__VA_ARGS__)
 362 #define DECLARE(ty, fname, ...)             \
 363  extern ty __real_ ## fname (__VA_ARGS__)
 364 #define CALL_REAL(fname, ...)               \
 365  __real_ ## fname (__VA_ARGS__)
 366 #define CALL_BACKUP(fname, ...)             \
 367   __real_ ## fname(__VA_ARGS__)
 368
 369 #endif /* PIC */
 370
 371 /* WRAPPER2 is for functions intercepted via macros at compile time. */
 372 #define WRAPPER2(ret, fname, ...)                     \
 373 ret __mfwrap_ ## fname (__VA_ARGS__)
 374
 375
 376 /* Utility macros for mf-hooks*.c */
 377
 378 #define MF_VALIDATE_EXTENT(value,size,acc,context) \
 379  do { \
 380   if (UNLIKELY (size > 0 && __MF_CACHE_MISS_P (value, size))) \
 381     if (acc == __MF_CHECK_WRITE || ! __mf_opts.ignore_reads) \
 382     __mf_check ((void *) (value), (size), acc, "(" context ")"); \
 383  } while (0)
 384 #define BEGIN_PROTECT(fname, ...)       \
 385   if (UNLIKELY (__mf_starting_p)) \
 386   {                                         \
 387     return CALL_BACKUP(fname, __VA_ARGS__); \
 388   }                                         \
 389   else if (UNLIKELY (__mf_get_state () == reentrant))   \
 390   {                                         \
 391     extern unsigned long __mf_reentrancy;   \
 392     __mf_reentrancy ++; \
 393     return CALL_REAL(fname, __VA_ARGS__);   \
 394   }                                         \
 395   else if (UNLIKELY (__mf_get_state () == in_malloc))   \
 396   {                                         \
 397     return CALL_REAL(fname, __VA_ARGS__);   \
 398   }                                         \
 399   else                                      \
 400   {                                         \
 401     TRACE ("%s\n", __PRETTY_FUNCTION__); \
 402   }
 403
 404 /* There is an assumption here that these will only be called in routines
 405    that call BEGIN_PROTECT at the start, and hence the state must always
 406    be active when BEGIN_MALLOC_PROTECT is called.  */
 407 #define BEGIN_MALLOC_PROTECT() \
 408   __mf_set_state (in_malloc)
 409
 410 #define END_MALLOC_PROTECT() \
 411   __mf_set_state (active)
 412
 413 /* Unlocked variants of main entry points from mf-runtime.h.  */
 414 extern void __mfu_check (void *ptr, size_t sz, int type, const char *location);
 415 extern void __mfu_register (void *ptr, size_t sz, int type, const char *name);
 416 extern void __mfu_unregister (void *ptr, size_t sz, int type);
 417 extern void __mfu_report ();
 418 extern int __mfu_set_options (const char *opts);
 419
 420
 421 #endif /* __MF_IMPL_H */