(grow_heap): When growing bail even if new_size is negative.
[kopensolaris-gnu/glibc.git] / malloc / mtrace.c
index d15569c..1a9522b 100644 (file)
@@ -1,25 +1,23 @@
 /* More debugging hooks for `malloc'.
-   Copyright (C) 1991, 92, 93, 94, 96, 97, 98 Free Software Foundation, Inc.
+   Copyright (C) 1991-1994,1996-2003, 2004 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
                 Written April 2, 1991 by John Gilmore of Cygnus Support.
                 Based on mcheck.c by Mike Haertel.
 
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
 
-   This library is distributed in the hope that it will be useful,
+   The GNU C Library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
+   Lesser General Public License for more details.
 
-   You should have received a copy of the GNU Library General Public
-   License along with this library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.
-
-   The author may be reached (Email) at the address mike@ai.mit.edu,
-   or (US mail) as Mike Haertel c/o Free Software Foundation.  */
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
 
 #ifndef        _MALLOC_INTERNAL
 #define        _MALLOC_INTERNAL
 #include <bits/libc-lock.h>
 #endif
 
-#include <ldsodefs.h>
-
+#include <dlfcn.h>
+#include <fcntl.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 
 #include <stdio-common/_itoa.h>
 
-#ifdef USE_IN_LIBIO
+#ifdef _LIBC
+# include <libc-internal.h>
+
 # include <libio/iolibio.h>
-# define setvbuf(s, b, f, l) _IO_setvbuf (s, b, f, l)
+# define setvbuf(s, b, f, l) INTUSE(_IO_setvbuf) (s, b, f, l)
+# define fwrite(buf, size, count, fp) _IO_fwrite (buf, size, count, fp)
+#endif
+
+#ifndef attribute_hidden
+# define attribute_hidden
 #endif
 
 #define TRACE_BUFFER_SIZE 512
 
 static FILE *mallstream;
 static const char mallenv[]= "MALLOC_TRACE";
-static char malloc_trace_buffer[TRACE_BUFFER_SIZE];
+static char *malloc_trace_buffer;
 
 __libc_lock_define_initialized (static, lock);
 
 /* Address to breakpoint on accesses to... */
 __ptr_t mallwatch;
 
+#ifdef USE_MTRACE_FILE
 /* File name and line number information, for callers that had
    the foresight to call through a macro.  */
 char *_mtrace_file;
 int _mtrace_line;
+#endif
 
 /* Old hook values.  */
-static void (*tr_old_free_hook) __P ((__ptr_t ptr, const __ptr_t));
-static __ptr_t (*tr_old_malloc_hook) __P ((__malloc_size_t size,
-                                          const __ptr_t));
-static __ptr_t (*tr_old_realloc_hook) __P ((__ptr_t ptr,
-                                           __malloc_size_t size,
-                                           const __ptr_t));
+static void (*tr_old_free_hook) (__ptr_t ptr, const __ptr_t);
+static __ptr_t (*tr_old_malloc_hook) (__malloc_size_t size, const __ptr_t);
+static __ptr_t (*tr_old_realloc_hook) (__ptr_t ptr, __malloc_size_t size,
+                                      const __ptr_t);
+static __ptr_t (*tr_old_memalign_hook) (__malloc_size_t __alignment,
+                                       __malloc_size_t __size,
+                                       __const __ptr_t);
 
 /* This function is called when the block being alloc'd, realloc'd, or
    freed has an address matching the variable "mallwatch".  In a debugger,
    set "mallwatch" to the address of interest, then put a breakpoint on
    tr_break.  */
 
-void tr_break __P ((void));
+extern void tr_break (void) __THROW;
+libc_hidden_proto (tr_break)
 void
 tr_break ()
 {
 }
+libc_hidden_def (tr_break)
 
-static void tr_where __P ((const __ptr_t)) internal_function;
+static void tr_where (const __ptr_t) __THROW internal_function;
 static void
 internal_function
 tr_where (caller)
      const __ptr_t caller;
 {
+#ifdef USE_MTRACE_FILE
   if (_mtrace_file)
     {
       fprintf (mallstream, "@ %s:%d ", _mtrace_file, _mtrace_line);
       _mtrace_file = NULL;
     }
-  else if (caller != NULL)
+  else
+#endif
+    if (caller != NULL)
     {
 #ifdef HAVE_ELF
       Dl_info info;
-      if (_dl_addr (caller, &info))
+      if (_dl_addr (caller, &info, NULL, NULL))
        {
          char *buf = (char *) "";
-         if (info.dli_sname && info.dli_sname[0])
+         if (info.dli_sname != NULL)
            {
              size_t len = strlen (info.dli_sname);
              buf = alloca (len + 6 + 2 * sizeof (void *));
@@ -121,15 +134,19 @@ tr_where (caller)
     }
 }
 
-static void tr_freehook __P ((__ptr_t, const __ptr_t));
+static void tr_freehook (__ptr_t, const __ptr_t) __THROW;
 static void
 tr_freehook (ptr, caller)
      __ptr_t ptr;
      const __ptr_t caller;
 {
+  if (ptr == NULL)
+    return;
+  __libc_lock_lock (lock);
   tr_where (caller);
   /* Be sure to print it first.  */
   fprintf (mallstream, "- %p\n", ptr);
+  __libc_lock_unlock (lock);
   if (ptr == mallwatch)
     tr_break ();
   __libc_lock_lock (lock);
@@ -142,7 +159,7 @@ tr_freehook (ptr, caller)
   __libc_lock_unlock (lock);
 }
 
-static __ptr_t tr_mallochook __P ((__malloc_size_t, const __ptr_t));
+static __ptr_t tr_mallochook (__malloc_size_t, const __ptr_t) __THROW;
 static __ptr_t
 tr_mallochook (size, caller)
      __malloc_size_t size;
@@ -159,19 +176,20 @@ tr_mallochook (size, caller)
     hdr = (__ptr_t) malloc (size);
   __malloc_hook = tr_mallochook;
 
-  __libc_lock_unlock (lock);
-
   tr_where (caller);
   /* We could be printing a NULL here; that's OK.  */
   fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long int) size);
 
+  __libc_lock_unlock (lock);
+
   if (hdr == mallwatch)
     tr_break ();
 
   return hdr;
 }
 
-static __ptr_t tr_reallochook __P ((__ptr_t, __malloc_size_t, const __ptr_t));
+static __ptr_t tr_reallochook (__ptr_t, __malloc_size_t, const __ptr_t)
+     __THROW;
 static __ptr_t
 tr_reallochook (ptr, size, caller)
      __ptr_t ptr;
@@ -196,8 +214,6 @@ tr_reallochook (ptr, size, caller)
   __malloc_hook = tr_mallochook;
   __realloc_hook = tr_reallochook;
 
-  __libc_lock_unlock (lock);
-
   tr_where (caller);
   if (hdr == NULL)
     /* Failed realloc.  */
@@ -211,20 +227,54 @@ tr_reallochook (ptr, size, caller)
       fprintf (mallstream, "> %p %#lx\n", hdr, (unsigned long int) size);
     }
 
+  __libc_lock_unlock (lock);
+
   if (hdr == mallwatch)
     tr_break ();
 
   return hdr;
 }
 
+static __ptr_t tr_memalignhook (__malloc_size_t, __malloc_size_t,
+                               const __ptr_t) __THROW;
+static __ptr_t
+tr_memalignhook (alignment, size, caller)
+     __malloc_size_t alignment, size;
+     const __ptr_t caller;
+{
+  __ptr_t hdr;
+
+  __libc_lock_lock (lock);
+
+  __memalign_hook = tr_old_memalign_hook;
+  __malloc_hook = tr_old_malloc_hook;
+  if (tr_old_memalign_hook != NULL)
+    hdr = (__ptr_t) (*tr_old_memalign_hook) (alignment, size, caller);
+  else
+    hdr = (__ptr_t) memalign (alignment, size);
+  __memalign_hook = tr_memalignhook;
+  __malloc_hook = tr_mallochook;
+
+  tr_where (caller);
+  /* We could be printing a NULL here; that's OK.  */
+  fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long int) size);
+
+  __libc_lock_unlock (lock);
+
+  if (hdr == mallwatch)
+    tr_break ();
+
+  return hdr;
+}
+
+
 
 #ifdef _LIBC
-extern void __libc_freeres (void);
 
 /* This function gets called to make sure all memory the library
    allocates get freed and so does not irritate the user when studying
    the mtrace output.  */
-static void
+static void __libc_freeres_fn_section
 release_libc_mem (void)
 {
   /* Only call the free function if we still are running in mtrace mode.  */
@@ -243,7 +293,7 @@ void
 mtrace ()
 {
 #ifdef _LIBC
-  static int added_atexit_handler = 0;
+  static int added_atexit_handler;
 #endif
   char *mallfile;
 
@@ -261,10 +311,22 @@ mtrace ()
 #endif
   if (mallfile != NULL || mallwatch != NULL)
     {
-      mallstream = fopen (mallfile != NULL ? mallfile : "/dev/null", "w");
+      char *mtb = malloc (TRACE_BUFFER_SIZE);
+      if (mtb == NULL)
+       return;
+
+      mallstream = fopen (mallfile != NULL ? mallfile : "/dev/null", "wc");
       if (mallstream != NULL)
        {
+         /* Make sure we close the file descriptor on exec.  */
+         int flags = __fcntl (fileno (mallstream), F_GETFD, 0);
+         if (flags >= 0)
+           {
+             flags |= FD_CLOEXEC;
+             __fcntl (fileno (mallstream), F_SETFD, flags);
+           }
          /* Be sure it doesn't malloc its buffer!  */
+         malloc_trace_buffer = mtb;
          setvbuf (mallstream, malloc_trace_buffer, _IOFBF, TRACE_BUFFER_SIZE);
          fprintf (mallstream, "= Start\n");
          tr_old_free_hook = __free_hook;
@@ -273,14 +335,20 @@ mtrace ()
          __malloc_hook = tr_mallochook;
          tr_old_realloc_hook = __realloc_hook;
          __realloc_hook = tr_reallochook;
+         tr_old_memalign_hook = __memalign_hook;
+         __memalign_hook = tr_memalignhook;
 #ifdef _LIBC
          if (!added_atexit_handler)
            {
+             extern void *__dso_handle __attribute__ ((__weak__));
              added_atexit_handler = 1;
-             atexit (release_libc_mem);
+             __cxa_atexit ((void (*) (void *)) release_libc_mem, NULL,
+                            &__dso_handle ? __dso_handle : NULL);
            }
 #endif
        }
+      else
+       free (mtb);
     }
 }
 
@@ -296,4 +364,5 @@ muntrace ()
   __free_hook = tr_old_free_hook;
   __malloc_hook = tr_old_malloc_hook;
   __realloc_hook = tr_old_realloc_hook;
+  __memalign_hook = tr_old_memalign_hook;
 }