Bug 114993 - editors/Emacs causes SIGSEGV
Summary: editors/Emacs causes SIGSEGV
Status: Closed FIXED
Alias: None
Product: Ports & Packages
Classification: Unclassified
Component: Individual Port(s) (show other bugs)
Version: Latest
Hardware: Any Any
: Normal Affects Only Me
Assignee: Giorgos Keramidas
URL:
Keywords:
Depends on:
Blocks:
 
Reported: 2007-07-28 19:00 UTC by Gardner Bell
Modified: 2007-10-09 00:40 UTC (History)
0 users

See Also:


Attachments

Note You need to log in before you can comment on or make changes to this bug.
Description Gardner Bell 2007-07-28 19:00:09 UTC
While editing any plain text file in emacs version 22.1.1 I receive the following SIGSEGV with partial backtrace.


Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0x8351000 (LWP 100062)]
0x08182d6c in calloc ()
(gdb) where
#0  0x08182d6c in calloc ()
#1  0x08183067 in free ()
#2  0x081316c8 in abort ()
#3  0x08183057 in free ()
#4  0x288ad98b in g_slice_get_config () from /usr/local/lib/libglib-2.0.so.0
#5  0x288adc41 in g_slice_get_config () from /usr/local/lib/libglib-2.0.so.0
#6  0x288adc95 in g_slice_get_config () from /usr/local/lib/libglib-2.0.so.0
#7  0x288ae689 in g_slice_free1 () from /usr/local/lib/libglib-2.0.so.0
#8  0x2888c0b1 in g_hash_table_lookup_extended ()
   from /usr/local/lib/libglib-2.0.so.0
#9  0x2888caaa in g_hash_table_remove () from /usr/local/lib/libglib-2.0.so.0
#10 0x2884d9db in g_signal_handlers_destroy ()
   from /usr/local/lib/libgobject-2.0.so.0
#11 0x283077af in gtk_object_destroy () from /usr/local/lib/libgtk-x11-2.0.so.0
#12 0x283e1f46 in gtk_widget_get_default_style ()
   from /usr/local/lib/libgtk-x11-2.0.so.0
#13 0x28266d68 in gtk_container_set_resize_mode ()
   from /usr/local/lib/libgtk-x11-2.0.so.0
#14 0x282f570a in gtk_menu_item_new_with_label ()
   from /usr/local/lib/libgtk-x11-2.0.so.0
#15 0x28847c59 in g_cclosure_marshal_VOID__VOID ()
   from /usr/local/lib/libgobject-2.0.so.0
#16 0x2883993d in g_value_set_static_boxed ()
   from /usr/local/lib/libgobject-2.0.so.0
#17 0x2883b217 in g_closure_invoke () from /usr/local/lib/libgobject-2.0.so.0
#18 0x288501f2 in g_signal_has_handler_pending ()
   from /usr/local/lib/libgobject-2.0.so.0
#19 0x28850bb8 in g_signal_emit_valist ()
   from /usr/local/lib/libgobject-2.0.so.0
#20 0x28850fab in g_signal_emit () from /usr/local/lib/libgobject-2.0.so.0
#21 0x28307886 in gtk_object_destroy () from /usr/local/lib/libgtk-x11-2.0.so.0
#22 0x283e921d in gtk_widget_hide () from /usr/local/lib/libgtk-x11-2.0.so.0
#23 0x2883d7d9 in g_object_run_dispose ()
   from /usr/local/lib/libgobject-2.0.so.0
#24 0x28307605 in gtk_object_destroy () from /usr/local/lib/libgtk-x11-2.0.so.0
#25 0x283e947b in gtk_widget_destroy () from /usr/local/lib/libgtk-x11-2.0.so.0
#26 0x282f5f62 in gtk_menu_shell_select_first ()
   from /usr/local/lib/libgtk-x11-2.0.so.0
#27 0x28266477 in gtk_container_foreach ()
   from /usr/local/lib/libgtk-x11-2.0.so.0
#28 0x28266d52 in gtk_container_set_resize_mode ()
   from /usr/local/lib/libgtk-x11-2.0.so.0
#29 0x282ed9e6 in gtk_menu_attach_to_widget ()
   from /usr/local/lib/libgtk-x11-2.0.so.0
#30 0x28847c59 in g_cclosure_marshal_VOID__VOID ()
   from /usr/local/lib/libgobject-2.0.so.0
#31 0x2883993d in g_value_set_static_boxed ()
   from /usr/local/lib/libgobject-2.0.so.0
#32 0x2883b29a in g_closure_invoke () from /usr/local/lib/libgobject-2.0.so.0
#33 0x288501f2 in g_signal_has_handler_pending ()
   from /usr/local/lib/libgobject-2.0.so.0
#34 0x28850bb8 in g_signal_emit_valist ()
   from /usr/local/lib/libgobject-2.0.so.0
#35 0x28850fab in g_signal_emit () from /usr/local/lib/libgobject-2.0.so.0
#36 0x28307886 in gtk_object_destroy () from /usr/local/lib/libgtk-x11-2.0.so.0
#37 0x283e921d in gtk_widget_hide () from /usr/local/lib/libgtk-x11-2.0.so.0
#38 0x2883d7d9 in g_object_run_dispose ()
   from /usr/local/lib/libgobject-2.0.so.0
#39 0x28307605 in gtk_object_destroy () from /usr/local/lib/libgtk-x11-2.0.so.0
#40 0x283e947b in gtk_widget_destroy () from /usr/local/lib/libgtk-x11-2.0.so.0
#41 0x080e11c3 in ?? ()
#42 0x29a27950 in ?? ()
#43 0x086c1b40 in ?? ()
#44 0xbfbfde58 in ?? ()
#45 0x080e116e in ?? ()
#46 0x080866fc in ?? ()
#47 0x29a2fda0 in ?? ()
#48 0x08618400 in ?? ()
#49 0x29a27750 in ?? ()

#50 0x0860da80 in ?? ()
#51 0x29a97c50 in ?? ()
#52 0x08917a00 in ?? ()
#53 0x00000001 in ?? ()
#54 0x00000000 in ?? ()
#55 0x29a300c0 in ?? ()
#56 0x08646100 in ?? ()
#57 0x29a27750 in ?? ()
#58 0x29a2fda0 in ?? ()
#59 0x29a97b70 in ?? ()
#60 0xbfbfdea8 in ?? ()
#61 0x080e11e8 in ?? ()
#62 0x080866fc in ?? ()
#63 0x08085da4 in ?? ()
#64 0x08087374 in ?? ()
#65 0x086c1b40 in ?? ()
#66 0x29a16260 in ?? ()
#67 0x085298c8 in ?? ()
#68 0x08618400 in ?? ()
#69 0x29a27150 in ?? ()
#70 0x0860da80 in ?? ()
#71 0x29a97eb0 in ?? ()
#72 0x08917a80 in ?? ()
#73 0x00000001 in ?? ()
#74 0x00000000 in ?? ()
#75 0x29a2fda0 in ?? ()
#76 0x08646100 in ?? ()
#77 0x29a97980 in ?? ()
#78 0x29a27150 in ?? ()
#79 0x088e0580 in ?? ()
#80 0xbfbfdee8 in ?? ()
#81 0x080e1825 in ?? ()
#82 0x080866fc in ?? ()
#83 0x08085da4 in ?? ()
#84 0x08087374 in ?? ()
#85 0x086c1b40 in ?? ()
#86 0x08301801 in ?? ()
#87 0x086c1b40 in ?? ()
#88 0x29a16260 in ?? ()
#89 0x081415ec in abort ()
Previous frame inner to this frame (corrupt stack?)

(gdb) info frame
Stack level 0, frame at 0xbfbfcec0:
 eip = 0x80e5d64 in abort; saved eip 0x8183067
 called by frame at 0xbfbfcee0
 Arglist at 0xbfbfceb8, args: 
 Locals at 0xbfbfceb8, Previous frame's sp is 0xbfbfcec0
 Saved registers:
 ebp at 0xbfbfceb8, eip at 0xbfbfcebc

(gdb) info threads
* 2 Thread 0x8351000 (LWP 100062)  0x080e5d64 in abort ()

(gdb) info reg
eax            0xffffffff       -1
ecx            0x186af  100015
edx            0x357e3000       897462272
ebx            0x217af  137135
esp            0xbfbfcb5c       0xbfbfcb5c
ebp            0xbfbfceb8       0xbfbfceb8
esi            0x8883bf8        143145976
edi            0x217af  137135
eip            0x80e5d64        0x80e5d64
eflags         0x206    518
cs             0x33     51
ss             0x3b     59
ds             0x3b     59
es             0x3b     59
fs             0x3b     59
gs             0x1b     27

How-To-Repeat: open any text file to edit.
Comment 1 Edwin Groothuis freebsd_committer 2007-07-29 09:51:38 UTC
Responsible Changed
From-To: freebsd-ports-bugs->gnome

Let's see if gnome@ knows anything about this.
Comment 2 Edwin Groothuis freebsd_committer 2007-07-29 09:51:38 UTC
Responsible Changed
From-To: freebsd-ports-bugs->freebsd-ports-bugs

Looks like edit-pr on freebsd is still broken.
Comment 3 Edwin Groothuis freebsd_committer 2007-07-29 09:54:59 UTC
State Changed
From-To: open->feedback

Awaiting maintainers feedback
Comment 4 Giorgos Keramidas freebsd_committer 2007-07-30 01:21:58 UTC
On 2007-07-28 17:58, Gardner Bell <gbell72@rogers.com> wrote:
> >Number:         114993
> >Category:       ports
> >Synopsis:       editors/Emacs causes SIGSEGV

> FreeBSD home.bsdca.com 7.0-CURRENT FreeBSD 7.0-CURRENT #3: Thu Jul 26
> 15:29:51 EDT 2007     root@home.bsdca.com:/usr/obj/usr/src/sys/HOME
> i386
> 
> >Description:
> While editing any plain text file in emacs version 22.1.1 I receive
> the following SIGSEGV with partial backtrace.
> 
> Program received signal SIGSEGV, Segmentation fault.
> [Switching to Thread 0x8351000 (LWP 100062)]
> 0x08182d6c in calloc ()
> (gdb) where
> #0  0x08182d6c in calloc ()
> #1  0x08183067 in free ()
> #2  0x081316c8 in abort ()
> #3  0x08183057 in free ()
> #4  0x288ad98b in g_slice_get_config () from /usr/local/lib/libglib-2.0.so.0

This looks similar to crashes I've reported to the emacs-devel mailing
list for Emacs 22.  The crashes go away if onee rebuilds WITHOUT_GTK for
me on FreeBSD 7.0-CURRENT.  Can you try building the port without a GTK+
interface and see if the crash persists?  If not, we have to collect
enough information for the upstream Emacs development team, to be able
to fix this either with a local FreeBSD-specific patch or by fixing the
Emacs 22.X source tree itself in the Emacs CVS repository.
Comment 5 Gardner Bell 2007-07-30 12:33:45 UTC
--- Giorgos Keramidas <keramida@freebsd.org> wrote:

> On 2007-07-28 17:58, Gardner Bell <gbell72@rogers.com> wrote:
> > >Number:         114993
> > >Category:       ports
> > >Synopsis:       editors/Emacs causes SIGSEGV
> 
> > FreeBSD home.bsdca.com 7.0-CURRENT FreeBSD 7.0-CURRENT #3: Thu Jul
> 26
> > 15:29:51 EDT 2007     root@home.bsdca.com:/usr/obj/usr/src/sys/HOME
> > i386
> > 
> > >Description:
> > While editing any plain text file in emacs version 22.1.1 I receive
> > the following SIGSEGV with partial backtrace.
> > 
> > Program received signal SIGSEGV, Segmentation fault.
> > [Switching to Thread 0x8351000 (LWP 100062)]
> > 0x08182d6c in calloc ()
> > (gdb) where
> > #0  0x08182d6c in calloc ()
> > #1  0x08183067 in free ()
> > #2  0x081316c8 in abort ()
> > #3  0x08183057 in free ()
> > #4  0x288ad98b in g_slice_get_config () from
> /usr/local/lib/libglib-2.0.so.0
> 
> This looks similar to crashes I've reported to the emacs-devel
> mailing
> list for Emacs 22.  The crashes go away if onee rebuilds WITHOUT_GTK
> for
> me on FreeBSD 7.0-CURRENT.  Can you try building the port without a
> GTK+
> interface and see if the crash persists?  If not, we have to collect
> enough information for the upstream Emacs development team, to be
> able
> to fix this either with a local FreeBSD-specific patch or by fixing
> the
> Emacs 22.X source tree itself in the Emacs CVS repository.
> 

I just rebuilt emacs about an hour ago WITHOUT_GTK and it is working as
intended now.  Should I file a big report to emacs-devel as well with
the backtrace I submitted here or will I need to add debug symbols
first?
Comment 6 Giorgos Keramidas freebsd_committer 2007-07-30 13:15:33 UTC
On 2007-07-30 07:33, Gardner Bell <gbell72@rogers.com> wrote:
>--- Giorgos Keramidas <keramida@freebsd.org> wrote:
>>> #4  0x288ad98b in g_slice_get_config () from /usr/local/lib/libglib-2.0.so.0
>>
>> This looks similar to crashes I've reported to the emacs-devel
>> mailing list for Emacs 22.  The crashes go away if onee rebuilds
>> WITHOUT_GTK for me on FreeBSD 7.0-CURRENT.  Can you try building the
>> port without a GTK+ interface and see if the crash persists?  If not,
>> we have to collect enough information for the upstream Emacs
>> development team, to be able to fix this either with a local
>> FreeBSD-specific patch or by fixing the Emacs 22.X source tree itself
>> in the Emacs CVS repository.
>
> I just rebuilt emacs about an hour ago WITHOUT_GTK and it is working
> as intended now.  Should I file a big report to emacs-devel as well
> with the backtrace I submitted here or will I need to add debug
> symbols first?

It may be worth building a snapshot of GNU Emacs yourself, and running
Emacs 22 inside GDB.  Then, when Emacs crashes, you will be able to
debug the live process, not just a core dump.

More instructions about building Emacs with debugging symbols and
running it under GDB can be found at the source of Emacs itself.

Ultimately, it should be possible to gather a stack trace of the crashed
Emacs process, a Lisp backtrace of Emacs itself, and then we should
notify the emacs-devel mailing list with the results.  The memory
allocation of GNU Emacs 22 and the FreeBSD 7.0-CURRENT malloc() haven't
played nicely with each other for several months, but it is difficult to
track down exactly why GTK+ widgets trigger this so easily...

Please, make sure you Cc: me in any emails posted to emacs-devel, as
this GTK+-triggered Emacs crash has been of interest to me for some time.

- Giorgos
Comment 7 Volker Stolz freebsd_committer 2007-09-22 07:47:09 UTC
Responsible Changed
From-To: freebsd-ports-bugs->keramida

keramida@ is handling this.
Comment 8 Giorgos Keramidas freebsd_committer 2007-09-27 17:57:56 UTC
On 2007-07-28 17:58, Gardner Bell <gbell72@rogers.com> wrote:
> While editing any plain text file in emacs version 22.1.1 I receive
> the following SIGSEGV with partial backtrace.

This is a long-standing bug with Emacs 22.X on FreeBSD, which is caused
by a bad interaction between the system version of posix_memalign() and
the gmalloc.c allocator of Emacs.

> From: Giorgos Keramidas <keramida@freebsd.org>
> To: Gardner Bell <gbell72@rogers.com>
> Cc: bug-followup@freebsd.org
> Subject: ports/114993: Re: ports/114993: Emacs causes SIGSEGV
> Date: Mon, 30 Jul 2007 15:15:33 +0300
>
> Please, make sure you Cc: me in any emails posted to emacs-devel, as
> this GTK+-triggered Emacs crash has been of interest to me for some
> time.

I've just replaced the release version of gmalloc.c in the Emacs 22.1
source tree with gmalloc.c from the CVS trunk of Emacs, which includes
several fixes and enhancements of the allocation functions implemented
in `gmalloc.c'.

The patch which replaces the `gmalloc.c' file with a newer snapshot is
attached below.  Using this port patch, I haven't managed to reproduce
the crashes of Emacs reported previously so far.  In fact, I'm typing
this in an Emacs buffer launched by emacsclient in an Emacs instance
which has been running for a few hours without a crash, yay! :-)

The port patch can be applied with:

        # cd /usr/ports/editors/emacs
        # gpatch -p1 < /tmp/patchfile

This patch doesn't bump the port revision, which will have to be done if
it is eventually committed.

----- patch begins here -----
Port the gmalloc.c allocator from the CVS trunk of Emacs.

This includes various enhancements and fixes, including a
serious bug caused by using gmalloc's allocation and free
functions and the system version of posix_memalign().

diff -r 84788b9c6cf4 -r 0d42b1ea33d4 files/patch-src-gmalloc.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/files/patch-src-gmalloc.c	Thu Sep 27 19:34:04 2007 +0300
@@ -0,0 +1,606 @@
+--- ./src/gmalloc.c.orig	2007-09-27 19:31:50.000000000 +0300
++++ ./src/gmalloc.c	2007-09-27 19:31:54.000000000 +0300
+@@ -1,9 +1,6 @@
+ /* This file is no longer automatically generated from libc.  */
+ 
+ #define _MALLOC_INTERNAL
+-#ifdef HAVE_GTK_AND_PTHREAD
+-#define USE_PTHREAD
+-#endif
+ 
+ /* The malloc headers and source files from the C library follow here.  */
+ 
+@@ -40,6 +37,10 @@
+ #include <config.h>
+ #endif
+ 
++#ifdef HAVE_GTK_AND_PTHREAD
++#define USE_PTHREAD
++#endif
++
+ #if ((defined __cplusplus || (defined (__STDC__) && __STDC__) \
+       || defined STDC_HEADERS || defined PROTOTYPES) \
+      && ! defined (BROKEN_PROTOTYPES))
+@@ -128,6 +129,8 @@
+ #if ! (defined (_MALLOC_INTERNAL) && __DJGPP__ - 0 == 1) /* Avoid conflict.  */
+ extern __ptr_t memalign PP ((__malloc_size_t __alignment,
+ 			     __malloc_size_t __size));
++extern int posix_memalign PP ((__ptr_t *, __malloc_size_t,
++			       __malloc_size_t size));
+ #endif
+ 
+ /* Allocate SIZE bytes on a page boundary.  */
+@@ -135,6 +138,10 @@
+ extern __ptr_t valloc PP ((__malloc_size_t __size));
+ #endif
+ 
++#ifdef USE_PTHREAD
++/* Set up mutexes and make malloc etc. thread-safe.  */
++extern void malloc_enable_thread PP ((void));
++#endif
+ 
+ #ifdef _MALLOC_INTERNAL
+ 
+@@ -235,14 +242,38 @@
+ extern __ptr_t _malloc_internal PP ((__malloc_size_t __size));
+ extern __ptr_t _realloc_internal PP ((__ptr_t __ptr, __malloc_size_t __size));
+ extern void _free_internal PP ((__ptr_t __ptr));
++extern __ptr_t _malloc_internal_nolock PP ((__malloc_size_t __size));
++extern __ptr_t _realloc_internal_nolock PP ((__ptr_t __ptr, __malloc_size_t __size));
++extern void _free_internal_nolock PP ((__ptr_t __ptr));
+ 
+ #ifdef USE_PTHREAD
+-extern pthread_mutex_t _malloc_mutex;
+-#define LOCK()     pthread_mutex_lock (&_malloc_mutex)
+-#define UNLOCK()   pthread_mutex_unlock (&_malloc_mutex)
++extern pthread_mutex_t _malloc_mutex, _aligned_blocks_mutex;
++extern int _malloc_thread_enabled_p;
++#define LOCK()					\
++  do {						\
++    if (_malloc_thread_enabled_p)		\
++      pthread_mutex_lock (&_malloc_mutex);	\
++  } while (0)
++#define UNLOCK()				\
++  do {						\
++    if (_malloc_thread_enabled_p)		\
++      pthread_mutex_unlock (&_malloc_mutex);	\
++  } while (0)
++#define LOCK_ALIGNED_BLOCKS()				\
++  do {							\
++    if (_malloc_thread_enabled_p)			\
++      pthread_mutex_lock (&_aligned_blocks_mutex);	\
++  } while (0)
++#define UNLOCK_ALIGNED_BLOCKS()				\
++  do {							\
++    if (_malloc_thread_enabled_p)			\
++      pthread_mutex_unlock (&_aligned_blocks_mutex);	\
++  } while (0)
+ #else
+ #define LOCK()
+ #define UNLOCK()
++#define LOCK_ALIGNED_BLOCKS()
++#define UNLOCK_ALIGNED_BLOCKS()
+ #endif
+ 
+ #endif /* _MALLOC_INTERNAL.  */
+@@ -373,7 +404,7 @@
+ extern __ptr_t bss_sbrk PP ((ptrdiff_t __size));
+ extern int bss_sbrk_did_unexec;
+ #endif
+-__ptr_t (*__morecore) PP ((ptrdiff_t __size)) = __default_morecore;
++__ptr_t (*__morecore) PP ((__malloc_ptrdiff_t __size)) = __default_morecore;
+ 
+ /* Debugging hook for `malloc'.  */
+ __ptr_t (*__malloc_hook) PP ((__malloc_size_t __size));
+@@ -553,8 +584,49 @@
+ }
+ 
+ #ifdef USE_PTHREAD
+-static pthread_once_t malloc_init_once_control = PTHREAD_ONCE_INIT;
+-pthread_mutex_t _malloc_mutex;
++pthread_mutex_t _malloc_mutex = PTHREAD_MUTEX_INITIALIZER;
++pthread_mutex_t _aligned_blocks_mutex = PTHREAD_MUTEX_INITIALIZER;
++int _malloc_thread_enabled_p;
++
++static void
++malloc_atfork_handler_prepare ()
++{
++  LOCK ();
++  LOCK_ALIGNED_BLOCKS ();
++}
++
++static void
++malloc_atfork_handler_parent ()
++{
++  UNLOCK_ALIGNED_BLOCKS ();
++  UNLOCK ();
++}
++
++static void
++malloc_atfork_handler_child ()
++{
++  UNLOCK_ALIGNED_BLOCKS ();
++  UNLOCK ();
++}
++
++/* Set up mutexes and make malloc etc. thread-safe.  */
++void
++malloc_enable_thread ()
++{
++  if (_malloc_thread_enabled_p)
++    return;
++
++  /* Some pthread implementations call malloc for statically
++     initialized mutexes when they are used first.  To avoid such a
++     situation, we initialize mutexes here while their use is
++     disabled in malloc etc.  */
++  pthread_mutex_init (&_malloc_mutex, NULL);
++  pthread_mutex_init (&_aligned_blocks_mutex, NULL);
++  pthread_atfork (malloc_atfork_handler_prepare,
++		  malloc_atfork_handler_parent,
++		  malloc_atfork_handler_child);
++  _malloc_thread_enabled_p = 1;
++}
+ #endif
+ 
+ static void
+@@ -567,17 +639,6 @@
+   if (__malloc_initialize_hook)
+     (*__malloc_initialize_hook) ();
+ 
+-#ifdef USE_PTHREAD
+-  {
+-    pthread_mutexattr_t attr;
+-
+-    pthread_mutexattr_init (&attr);
+-    pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
+-    pthread_mutex_init (&_malloc_mutex, &attr);
+-    pthread_mutexattr_destroy (&attr);
+-  }
+-#endif
+-
+   heapsize = HEAP / BLOCKSIZE;
+   _heapinfo = (malloc_info *) align (heapsize * sizeof (malloc_info));
+   if (_heapinfo == NULL)
+@@ -596,18 +657,16 @@
+   return;
+ }
+ 
+-/* Set everything up and remember that we have.  */
++/* Set everything up and remember that we have.
++   main will call malloc which calls this function.  That is before any threads
++   or signal handlers has been set up, so we don't need thread protection.  */
+ int
+ __malloc_initialize ()
+ {
+-#ifdef USE_PTHREAD
+-  pthread_once (&malloc_init_once_control, malloc_initialize_1);
+-#else
+   if (__malloc_initialized)
+     return 0;
+ 
+   malloc_initialize_1 ();
+-#endif
+ 
+   return __malloc_initialized;
+ }
+@@ -616,9 +675,9 @@
+ 
+ /* Get neatly aligned memory, initializing or
+    growing the heap info table as necessary. */
+-static __ptr_t morecore PP ((__malloc_size_t));
++static __ptr_t morecore_nolock PP ((__malloc_size_t));
+ static __ptr_t
+-morecore (size)
++morecore_nolock (size)
+      __malloc_size_t size;
+ {
+   __ptr_t result;
+@@ -661,7 +720,7 @@
+ 	     `morecore_recursing' flag and return null.  */
+ 	  int save = errno;	/* Don't want to clobber errno with ENOMEM.  */
+ 	  morecore_recursing = 1;
+-	  newinfo = (malloc_info *) _realloc_internal
++	  newinfo = (malloc_info *) _realloc_internal_nolock
+ 	    (_heapinfo, newsize * sizeof (malloc_info));
+ 	  morecore_recursing = 0;
+ 	  if (newinfo == NULL)
+@@ -717,7 +776,7 @@
+       /* Reset _heaplimit so _free_internal never decides
+ 	 it can relocate or resize the info table.  */
+       _heaplimit = 0;
+-      _free_internal (oldinfo);
++      _free_internal_nolock (oldinfo);
+       PROTECT_MALLOC_STATE (0);
+ 
+       /* The new heap limit includes the new table just allocated.  */
+@@ -732,7 +791,7 @@
+ 
+ /* Allocate memory from the heap.  */
+ __ptr_t
+-_malloc_internal (size)
++_malloc_internal_nolock (size)
+      __malloc_size_t size;
+ {
+   __ptr_t result;
+@@ -752,7 +811,6 @@
+     return NULL;
+ #endif
+ 
+-  LOCK ();
+   PROTECT_MALLOC_STATE (0);
+ 
+   if (size < sizeof (struct list))
+@@ -802,8 +860,10 @@
+ 	  /* No free fragments of the desired size, so get a new block
+ 	     and break it into fragments, returning the first.  */
+ #ifdef GC_MALLOC_CHECK
+-	  result = _malloc_internal (BLOCKSIZE);
++	  result = _malloc_internal_nolock (BLOCKSIZE);
+ 	  PROTECT_MALLOC_STATE (0);
++#elif defined (USE_PTHREAD)
++	  result = _malloc_internal_nolock (BLOCKSIZE);
+ #else
+ 	  result = malloc (BLOCKSIZE);
+ #endif
+@@ -874,7 +934,7 @@
+  		  _heaplimit += wantblocks - lastblocks;
+ 		  continue;
+ 		}
+-	      result = morecore (wantblocks * BLOCKSIZE);
++	      result = morecore_nolock (wantblocks * BLOCKSIZE);
+ 	      if (result == NULL)
+ 		goto out;
+ 	      block = BLOCK (result);
+@@ -932,7 +992,19 @@
+ 
+   PROTECT_MALLOC_STATE (1);
+  out:
++  return result;
++}
++
++__ptr_t
++_malloc_internal (size)
++     __malloc_size_t size;
++{
++  __ptr_t result;
++
++  LOCK ();
++  result = _malloc_internal_nolock (size);
+   UNLOCK ();
++
+   return result;
+ }
+ 
+@@ -940,10 +1012,21 @@
+ malloc (size)
+      __malloc_size_t size;
+ {
++  __ptr_t (*hook) (__malloc_size_t);
++
+   if (!__malloc_initialized && !__malloc_initialize ())
+     return NULL;
+ 
+-  return (__malloc_hook != NULL ? *__malloc_hook : _malloc_internal) (size);
++  /* Copy the value of __malloc_hook to an automatic variable in case
++     __malloc_hook is modified in another thread between its
++     NULL-check and the use.
++
++     Note: Strictly speaking, this is not a right solution.  We should
++     use mutexes to access non-read-only variables that are shared
++     among multiple threads.  We just leave it for compatibility with
++     glibc malloc (i.e., assignments to __malloc_hook) for now.  */
++  hook = __malloc_hook;
++  return (hook != NULL ? *hook : _malloc_internal) (size);
+ }
+ 
+ #ifndef _LIBC
+@@ -1024,9 +1107,9 @@
+ struct alignlist *_aligned_blocks = NULL;
+ 
+ /* Return memory to the heap.
+-   Like `free' but don't call a __free_hook if there is one.  */
++   Like `_free_internal' but don't lock mutex.  */
+ void
+-_free_internal (ptr)
++_free_internal_nolock (ptr)
+      __ptr_t ptr;
+ {
+   int type;
+@@ -1043,9 +1126,9 @@
+   if (ptr == NULL)
+     return;
+ 
+-  LOCK ();
+   PROTECT_MALLOC_STATE (0);
+ 
++  LOCK_ALIGNED_BLOCKS ();
+   for (l = _aligned_blocks; l != NULL; l = l->next)
+     if (l->aligned == ptr)
+       {
+@@ -1053,6 +1136,7 @@
+ 	ptr = l->exact;
+ 	break;
+       }
++  UNLOCK_ALIGNED_BLOCKS ();
+ 
+   block = BLOCK (ptr);
+ 
+@@ -1158,7 +1242,7 @@
+ 		 table's blocks to the system before we have copied them to
+ 		 the new location.  */
+ 	      _heaplimit = 0;
+-	      _free_internal (_heapinfo);
++	      _free_internal_nolock (_heapinfo);
+ 	      _heaplimit = oldlimit;
+ 
+ 	      /* Tell malloc to search from the beginning of the heap for
+@@ -1166,8 +1250,8 @@
+ 	      _heapindex = 0;
+ 
+ 	      /* Allocate new space for the info table and move its data.  */
+-	      newinfo = (malloc_info *) _malloc_internal (info_blocks
+-							  * BLOCKSIZE);
++	      newinfo = (malloc_info *) _malloc_internal_nolock (info_blocks
++								 * BLOCKSIZE);
+ 	      PROTECT_MALLOC_STATE (0);
+ 	      memmove (newinfo, _heapinfo, info_blocks * BLOCKSIZE);
+ 	      _heapinfo = newinfo;
+@@ -1230,8 +1314,8 @@
+ 	  _chunks_free -= BLOCKSIZE >> type;
+ 	  _bytes_free -= BLOCKSIZE;
+ 
+-#ifdef GC_MALLOC_CHECK
+-	  _free_internal (ADDRESS (block));
++#if defined (GC_MALLOC_CHECK) || defined (USE_PTHREAD)
++	  _free_internal_nolock (ADDRESS (block));
+ #else
+ 	  free (ADDRESS (block));
+ #endif
+@@ -1269,6 +1353,16 @@
+     }
+ 
+   PROTECT_MALLOC_STATE (1);
++}
++
++/* Return memory to the heap.
++   Like `free' but don't call a __free_hook if there is one.  */
++void
++_free_internal (ptr)
++     __ptr_t ptr;
++{
++  LOCK ();
++  _free_internal_nolock (ptr);
+   UNLOCK ();
+ }
+ 
+@@ -1278,8 +1372,10 @@
+ free (ptr)
+      __ptr_t ptr;
+ {
+-  if (__free_hook != NULL)
+-    (*__free_hook) (ptr);
++  void (*hook) (__ptr_t) = __free_hook;
++
++  if (hook != NULL)
++    (*hook) (ptr);
+   else
+     _free_internal (ptr);
+ }
+@@ -1415,7 +1511,7 @@
+    new region.  This module has incestuous knowledge of the
+    internals of both free and malloc. */
+ __ptr_t
+-_realloc_internal (ptr, size)
++_realloc_internal_nolock (ptr, size)
+      __ptr_t ptr;
+      __malloc_size_t size;
+ {
+@@ -1425,15 +1521,14 @@
+ 
+   if (size == 0)
+     {
+-      _free_internal (ptr);
+-      return _malloc_internal (0);
++      _free_internal_nolock (ptr);
++      return _malloc_internal_nolock (0);
+     }
+   else if (ptr == NULL)
+-    return _malloc_internal (size);
++    return _malloc_internal_nolock (size);
+ 
+   block = BLOCK (ptr);
+ 
+-  LOCK ();
+   PROTECT_MALLOC_STATE (0);
+ 
+   type = _heapinfo[block].busy.type;
+@@ -1443,11 +1538,11 @@
+       /* Maybe reallocate a large block to a small fragment.  */
+       if (size <= BLOCKSIZE / 2)
+ 	{
+-	  result = _malloc_internal (size);
++	  result = _malloc_internal_nolock (size);
+ 	  if (result != NULL)
+ 	    {
+ 	      memcpy (result, ptr, size);
+-	      _free_internal (ptr);
++	      _free_internal_nolock (ptr);
+ 	      goto out;
+ 	    }
+ 	}
+@@ -1467,7 +1562,7 @@
+ 	     Now we will free this chunk; increment the statistics counter
+ 	     so it doesn't become wrong when _free_internal decrements it.  */
+ 	  ++_chunks_used;
+-	  _free_internal (ADDRESS (block + blocks));
++	  _free_internal_nolock (ADDRESS (block + blocks));
+ 	  result = ptr;
+ 	}
+       else if (blocks == _heapinfo[block].busy.info.size)
+@@ -1482,8 +1577,8 @@
+ 	  /* Prevent free from actually returning memory to the system.  */
+ 	  oldlimit = _heaplimit;
+ 	  _heaplimit = 0;
+-	  _free_internal (ptr);
+-	  result = _malloc_internal (size);
++	  _free_internal_nolock (ptr);
++	  result = _malloc_internal_nolock (size);
+ 	  PROTECT_MALLOC_STATE (0);
+ 	  if (_heaplimit == 0)
+ 	    _heaplimit = oldlimit;
+@@ -1493,13 +1588,13 @@
+ 		 the thing we just freed.  Unfortunately it might
+ 		 have been coalesced with its neighbors.  */
+ 	      if (_heapindex == block)
+-	        (void) _malloc_internal (blocks * BLOCKSIZE);
++	        (void) _malloc_internal_nolock (blocks * BLOCKSIZE);
+ 	      else
+ 		{
+ 		  __ptr_t previous
+-		    = _malloc_internal ((block - _heapindex) * BLOCKSIZE);
+-		  (void) _malloc_internal (blocks * BLOCKSIZE);
+-		  _free_internal (previous);
++		    = _malloc_internal_nolock ((block - _heapindex) * BLOCKSIZE);
++		  (void) _malloc_internal_nolock (blocks * BLOCKSIZE);
++		  _free_internal_nolock (previous);
+ 		}
+ 	      goto out;
+ 	    }
+@@ -1519,18 +1614,31 @@
+ 	{
+ 	  /* The new size is different; allocate a new space,
+ 	     and copy the lesser of the new size and the old. */
+-	  result = _malloc_internal (size);
++	  result = _malloc_internal_nolock (size);
+ 	  if (result == NULL)
+ 	    goto out;
+ 	  memcpy (result, ptr, min (size, (__malloc_size_t) 1 << type));
+-	  _free_internal (ptr);
++	  _free_internal_nolock (ptr);
+ 	}
+       break;
+     }
+ 
+   PROTECT_MALLOC_STATE (1);
+  out:
++  return result;
++}
++
++__ptr_t
++_realloc_internal (ptr, size)
++     __ptr_t ptr;
++     __malloc_size_t size;
++{
++  __ptr_t result;
++
++  LOCK();
++  result = _realloc_internal_nolock (ptr, size);
+   UNLOCK ();
++
+   return result;
+ }
+ 
+@@ -1539,11 +1647,13 @@
+      __ptr_t ptr;
+      __malloc_size_t size;
+ {
++  __ptr_t (*hook) (__ptr_t, __malloc_size_t);
++
+   if (!__malloc_initialized && !__malloc_initialize ())
+     return NULL;
+ 
+-  return (__realloc_hook != NULL ? *__realloc_hook : _realloc_internal)
+-    (ptr, size);
++  hook = __realloc_hook;
++  return (hook != NULL ? *hook : _realloc_internal) (ptr, size);
+ }
+ /* Copyright (C) 1991, 1992, 1994 Free Software Foundation, Inc.
+ 
+@@ -1681,9 +1791,10 @@
+ {
+   __ptr_t result;
+   unsigned long int adj, lastadj;
++  __ptr_t (*hook) (__malloc_size_t, __malloc_size_t) = __memalign_hook;
+ 
+-  if (__memalign_hook)
+-    return (*__memalign_hook) (alignment, size);
++  if (hook)
++    return (*hook) (alignment, size);
+ 
+   /* Allocate a block with enough extra space to pad the block with up to
+      (ALIGNMENT - 1) bytes if necessary.  */
+@@ -1718,6 +1829,7 @@
+ 	 of an allocated block.  */
+ 
+       struct alignlist *l;
++      LOCK_ALIGNED_BLOCKS ();
+       for (l = _aligned_blocks; l != NULL; l = l->next)
+ 	if (l->aligned == NULL)
+ 	  /* This slot is free.  Use it.  */
+@@ -1725,21 +1837,58 @@
+       if (l == NULL)
+ 	{
+ 	  l = (struct alignlist *) malloc (sizeof (struct alignlist));
+-	  if (l == NULL)
++	  if (l != NULL)
+ 	    {
+-	      free (result);
+-	      return NULL;
++	      l->next = _aligned_blocks;
++	      _aligned_blocks = l;
+ 	    }
+-	  l->next = _aligned_blocks;
+-	  _aligned_blocks = l;
+ 	}
+-      l->exact = result;
+-      result = l->aligned = (char *) result + alignment - adj;
++      if (l != NULL)
++	{
++	  l->exact = result;
++	  result = l->aligned = (char *) result + alignment - adj;
++	}
++      UNLOCK_ALIGNED_BLOCKS ();
++      if (l == NULL)
++	{
++	  free (result);
++	  result = NULL;
++	}
+     }
+ 
+   return result;
+ }
+ 
++#ifndef ENOMEM
++#define ENOMEM 12
++#endif
++
++#ifndef EINVAL
++#define EINVAL 22
++#endif
++
++int
++posix_memalign (memptr, alignment, size)
++     __ptr_t *memptr;
++     __malloc_size_t alignment;
++     __malloc_size_t size;
++{
++  __ptr_t mem;
++
++  if (alignment == 0
++      || alignment % sizeof (__ptr_t) != 0
++      || (alignment & (alignment - 1)) != 0)
++    return EINVAL;
++
++  mem = memalign (alignment, size);
++  if (mem == NULL)
++    return ENOMEM;
++
++  *memptr = mem;
++
++  return 0;
++}
++
+ #endif /* Not DJGPP v1 */
+ /* Allocate memory on a page boundary.
+    Copyright (C) 1991, 92, 93, 94, 96 Free Software Foundation, Inc.
----- patch ends here -----
Comment 9 dfilter service freebsd_committer 2007-10-09 00:30:01 UTC
keramida    2007-10-08 23:29:47 UTC

  FreeBSD ports repository (doc committer)

  Modified files:
    editors/emacs        Makefile 
  Added files:
    editors/emacs/files  patch-src-gmalloc.c 
  Log:
  Port the gmalloc.c allocator from the CVS trunk of Emacs.
  
  This includes various enhancements and fixes, including a
  serious bug caused by using gmalloc's allocation and free
  functions and the system version of posix_memalign().
  
  PR:             ports/114993
  Submitted by:   Gardner Bell
  Reviewed by:    pav
  
  Revision  Changes    Path
  1.73      +1 -1      ports/editors/emacs/Makefile
  1.1       +606 -0    ports/editors/emacs/files/patch-src-gmalloc.c (new)
_______________________________________________
cvs-all@freebsd.org mailing list
http://lists.freebsd.org/mailman/listinfo/cvs-all
To unsubscribe, send any mail to "cvs-all-unsubscribe@freebsd.org"
Comment 10 Giorgos Keramidas freebsd_committer 2007-10-09 00:30:36 UTC
State Changed
From-To: feedback->closed

After a bit more testing on FreeBSD/i386 and 
Solaris/amd64, I've committed the patch which 
updates gmalloc and bumped editors/emacs' 
port-revision. 

Can you try with the latest CVS version of editors/emacs 
and let me know if you can still reproduce the GTK+ related 
crashes reported?