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.
Responsible Changed From-To: freebsd-ports-bugs->gnome Let's see if gnome@ knows anything about this.
Responsible Changed From-To: freebsd-ports-bugs->freebsd-ports-bugs Looks like edit-pr on freebsd is still broken.
State Changed From-To: open->feedback Awaiting maintainers feedback
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.
--- 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?
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
Responsible Changed From-To: freebsd-ports-bugs->keramida keramida@ is handling this.
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 -----
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"
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?