Summary: | editors/Emacs causes SIGSEGV | ||
---|---|---|---|
Product: | Ports & Packages | Reporter: | Gardner Bell <gbell72> |
Component: | Individual Port(s) | Assignee: | Giorgos Keramidas <keramida> |
Status: | Closed FIXED | ||
Severity: | Affects Only Me | ||
Priority: | Normal | ||
Version: | Latest | ||
Hardware: | Any | ||
OS: | Any |
Description
Gardner Bell
2007-07-28 19:00:09 UTC
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? |