helps you detect two common programming bugs:
software that overruns the boundaries of a malloc() memory
allocation, and software that touches a memory allocation that has been
released by free(). Unlike other malloc() debuggers, Electric Fence will
accesses as well as writes, and it will pinpoint the exact instruction that
causes an error. It has been in use at Pixar since 1987, and at many other
sites for years.
Electric Fence uses the virtual memory hardware of your computer to place an
inaccessible memory page immediately after (or before, at the user's option)
each memory allocation. When software reads or writes this inaccessible page,
hardware issues a segmentation fault, stopping the program at the offending
instruction. It is then trivial to find the erroneous statement using your
favorite debugger. In a similar manner, memory that has been released by
free() is made inaccessible, and any code that touches it will get a
Simply linking your application with libefence.a will allow you to detect
most, but not all, malloc buffer overruns and accesses of free memory.
If you want to be reasonably sure that you've found
bugs of this type, you'll have to read and understand the rest of this
Link your program with the library
Make sure you are
or with other malloc-debugger or malloc-enhancer libraries.
You can only use one at a time.
If your system administrator
has installed Electric Fence for public use, you'll be able to use the
argument to the linker, otherwise you'll have to put the path-name for
in the linker's command line.
Some systems will require special arguments to the linker to assure that
you are using the Electric Fence malloc() and not the one from your C library.
On AIX systems, you may have to use the flags
On Sun systems running SunOS 4.X, you'll probably have to use
Run your program
using a debugger.
It's easier to work this way than to create a
file and post-mortem debug it. Electric Fence can create
core files, and some operating systems will thus take minutes simply to dump
core! Some operating systems will not create usable core files from programs
that are linked with Electric Fence.
If your program has one of the errors detected by Electric Fence, it will
get a segmentation fault (SIGSEGV) at the offending instruction. Use the
debugger to locate the erroneous statement, and repair it.
GLOBAL AND ENVIRONMENT VARIABLES
Electric Fence has six configuration switches that can be enabled via
the shell environment, or by setting the value of global integer variables
using a debugger. These switches change what bugs Electric Fence will detect,
so it's important that you know how to use them.
This is an integer which if nonzero specifies that the usual Electric
Fence banner and copyright notice should not be printed. This is
provided for certain circumstances where the banner can be annoying
(eg, running a regression test suite that also monitors stderr). Note
that you should almost certainly not set this in your program, because
then you might leave Electric Fence linked into the production
version, which would be very bad.
This is an integer that specifies the alignment for any memory allocations
that will be returned by malloc(), calloc(), and realloc().
The value is specified in
bytes, thus a value of 4 will cause memory to be aligned to 32-bit boundaries
unless your system doesn't have a 8-bit characters. EF_ALIGNMENT is set to
sizeof(int) by default, since that is generally the word-size of your CPU.
If your program requires that allocations be aligned to 64-bit
boundaries and you have a 32-bit
you'll have to set this value to 8. This is the case when compiling with the
flag on MIPS-based systems such as those from SGI.
The memory allocation that is returned by Electric Fence malloc() is aligned
using the value in EF_ALIGNMENT, and
its size the multiple ofthat value
that is greater than or equal to the requested size.
For this reason, you will sometimes want to set EF_ALIGNMENT to 0 (no
alignment), so that
you can detect overruns of less than your CPU's word size. Be sure to read
WORD-ALIGNMENT AND OVERRUN DETECTION
in this manual page before you try this.
To change this value, set EF_ALIGNMENT in the shell environment to an
integer value, or assign
to the global integer variable EF_ALIGNMENT using a debugger.
Electric Fence usually places an inaccessible page immediately after each
memory allocation, so that software that runs past the end of the allocation
will be detected. Setting EF_PROTECT_BELOW to 1 causes Electric Fence
to place the inaccessible page
the allocation in the address space, so that under-runs will be detected
instead of over-runs.
When EF_PROTECT_BELOW is set, the EF_ALIGNMENT parameter is ignored.
All allocations will be aligned to virtual-memory-page boundaries, and
their size will be the exact size that was requested.
To change this value, set EF_PROTECT_BELOW in the shell environment to an
integer value, or assign to the global integer variable EF_PROTECT_BELOW using
When EF_PROTECT_FREE is not set (i. e. set to 0), Electric Fence returns free
memory to a pool and only checks accesses to it until it is reallocated. If
you suspect that a program may be touching free memory, set EF_PROTECT_FREE to
1. This will cause Electric Fence to never re-allocate memory once it has been
freed, so that any access to free memory will be detected. Some programs will
use tremendous amounts of memory when this parameter is set. To change this
value, set EF_PROTECT_FREE in the shell environment to an integer value, or
assign to the global integer variable EF_PROTECT_FREE using a debugger.
By default, Electric Fence traps calls to malloc() with a size of zero, because
they are often the result of a software bug. If EF_ALLOW_MALLOC_0 is non-zero,
the software will not trap calls to malloc() with a size of zero.
To change this value, set EF_ALLOW_MALLOC_0 in the shell environment to an
integer value, or assign to the global integer variable EF_ALLOW_MALLOC_0 using
By default, Electric Fence releases memory without changing the content
of the released memory block. IF EF_FREE_WIPES is non-zero, the sofware
will fill the memory block with 0xbd values before it is released.
This makes it easier to trigger illegal use of released memory, and eaiser
to understand why a memory access failed during gdb runs.
WORD-ALIGNMENT AND OVERRUN DETECTION
There is a conflict between the alignment restrictions that malloc() operates
under and the debugging strategy used by Electric Fence. When detecting
overruns, Electric Fence malloc() allocates two or more virtual memory
pages for each allocation. The last page is made inaccessible in such a way
that any read, write, or execute access will cause a segmentation fault.
Then, Electric Fence malloc() will return an address such that the first
the end of the allocation is on the inaccessible page.
Thus, any overrun
of the allocation will cause a segmentation fault.
It follows that the
address returned by malloc() is the address of the inaccessible page minus
the size of the memory allocation.
Unfortunately, malloc() is required to return
allocations, since many CPUs can only access a word when its address is aligned.
The conflict happens when software makes a memory allocation using a size that
is not a multiple of the word size, and expects to do word accesses to that
allocation. The location of the inaccessible page is fixed by hardware at
a word-aligned address. If Electric Fence malloc() is to return an aligned
address, it must increase the size of the allocation to a multiple of the
In addition, the functions memalign() and valloc() must honor explicit
specifications on the alignment of the memory allocation, and this, as well
can only be implemented by increasing the size of the allocation.
Thus, there will be situations in which the end of a memory allocation
contains some padding space, and accesses of that padding space will not
be detected, even if they are overruns.
Electric Fence provides the variable EF_ALIGNMENT so that the user can
control the default alignment used by malloc(), calloc(), and realloc().
To debug overruns as small as a single byte, you can set EF_ALIGNMENT to
zero. This will result in Electric Fence malloc() returning unaligned
addresses for allocations with sizes that are not a multiple of the word
size. This is not a problem in most cases, because compilers must pad the
size of objects so that alignment restrictions are honored when storing
those objects in arrays. The problem surfaces when software allocates
odd-sized buffers for objects that must be word-aligned. One case of this
is software that allocates a buffer to contain a structure and a
string, and the string has an odd size (this example was in a popular TIFF
library). If word references are made to un-aligned buffers, you will see
a bus error (SIGBUS) instead of a segmentation fault. The only way to fix
this is to re-write the offending code to make byte references or not make
odd-sized allocations, or to set EF_ALIGNMENT to the word size.
Another example of software incompatible with
EF_ALIGNMENT < word-size
is the strcmp() function and other string functions on SunOS (and probably
Solaris), which make word-sized accesses to character strings, and may
attempt to access up to three bytes beyond the end of a string. These
result in a segmentation fault (SIGSEGV). The only way around this is to
use versions of the string functions that perform byte references instead
of word references.
INSTRUCTIONS FOR DEBUGGING YOUR PROGRAM
Link with libefence.a as explained above.
Run your program in a debugger and fix any overruns or accesses to free memory.
Quit the debugger.
Set EF_PROTECT_BELOW = 1 in the shell environment.
Repeat step 2, this time repairing underruns if they occur.
Quit the debugger.
Read the restrictions in the section on
WORD-ALIGNMENT AND OVERRUN DETECTION.
See if you can
set EF_ALIGNMENT to 0 and repeat step 2. Sometimes this will be too much work,
or there will be problems with library routines for which you don't have the
source, that will prevent you from doing this.
MEMORY USAGE AND EXECUTION SPEED
Since Electric Fence uses at least two virtual memory pages for each of its
allocations, it's a terrible memory hog. I've sometimes found it necessary to
add a swap file using swapon(8) so that the system would have enough virtual
memory to debug my program. Also, the way we manipulate memory results in
various cache and translation buffer entries being flushed with each call
to malloc or free. The end result is that your program will be much slower
and use more resources while you are debugging it with Electric Fence.
Don't leave libefence.a linked into production software! Use it only
Electric Fence is written for ANSI C. You should be able to port it with
simple changes to the Makefile and to page.c,
which contains the memory management primitives .
Many POSIX platforms will require only a re-compile.
The operating system facilities required to port Electric Fence are:
A way to allocate memory pages
A way to make selected pages inaccessible.
A way to make the pages accessible again.
A way to detect when a program touches an inaccessible page.
A way to print messages.
Please e-mail me a copy of any changes you have to make, so that I can
merge them into the distribution.
I have tried to do as good a job as I can on this software, but I doubt
that it is even theoretically possible to make it bug-free.
This software has no warranty. It will not detect some bugs that you might
expect it to detect, and will indicate that some non-bugs are bugs.
Bruce Perens and/or Pixar will not be liable to any claims resulting
from the use of this software or the ideas within it.
The entire responsibility for its use must
be assumed by the user. If you use it and it results in loss of life
and/or property, tough. If it leads you on a wild goose chase and you waste
two weeks debugging something, too bad.
If you can't deal with the above, please don't use the software! I've written
this in an attempt to help other people, not to get myself sued or prosecuted.
Copyright 1987-1995 Bruce Perens. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, Version 2,
as published by the Free Software Foundation. A copy of this license is
distributed with this software in the file "COPYING".
This program 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. Read the
file "COPYING" for more details.
CONTACTING THE AUTHOR
1001 West Cutting Blvd., Suite 200
Richmond, CA 94804
Segmentation Fault: Examine the offending statement for violation of the
boundaries of a memory allocation.
Bus Error: See the section on
WORD-ALIGNMENT AND OVERRUN DETECTION.
in this manual page.
My explanation of the alignment issue could be improved.
Some Sun systems running SunOS 4.1 are reported to signal an access to a
protected page with
I suspect this is an undocumented feature of a particular Sun hardware
version, not just the operating system.
On these systems, eftest will fail with a bus error until you modify the
Makefile to define
There are, without doubt, other bugs and porting issues. Please contact me via
e-mail if you have any bug reports, ideas, etc.
PURIFY, from Purify Systems, does a much better job than Electric Fence, and
does much more. It's available at this writing on SPARC and HP.
I'm not affiliated with Purify, I just think it's a wonderful product
and you should check it out.