efence: clang-format
authorBarret Rhoden <brho@cs.berkeley.edu>
Tue, 6 Jun 2017 21:13:50 +0000 (17:13 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Wed, 7 Jun 2017 15:38:14 +0000 (11:38 -0400)
Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
user/electric-fence/efence.c
user/electric-fence/eftest.c
user/electric-fence/page.c
user/electric-fence/print.c

index eaa0dbe..655135a 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * Electric Fence - Red-Zone memory allocator.
  * Bruce Perens, 1988, 1993
- * 
+ *
  * For email below, drop spaces and <spam-buster> tag.
  * MODIFIED:  March 20, 2014 (jric<spam-buster> @ <spam-buster> chegg DOT com)
  *
  *
  */
 #include "efence.h"
-#include <stdlib.h>
-#include <unistd.h>
+#include <errno.h>
 #include <memory.h>
-#include <string.h>
 #include <pthread.h>
-#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
 
 #include <parlib/spinlock.h>
 #include <parlib/stdio.h>
  * system at one time. We'll break that memory down into smaller pieces for
  * malloc buffers. One megabyte is probably a good value.
  */
-#define                        MEMORY_CREATION_SIZE    1024 * 1024
+#define MEMORY_CREATION_SIZE 1024 * 1024
 
 /*
  * Enum Mode indicates the status of a malloc buffer.
  */
 enum _Mode {
-       NOT_IN_USE = 0, /* Available to represent a malloc buffer. */
-       FREE,           /* A free buffer. */
-       ALLOCATED,      /* A buffer that is in use. */
-       PROTECTED,      /* A freed buffer that can not be allocated again. */
-       INTERNAL_USE    /* A buffer used internally by malloc(). */
+       NOT_IN_USE = 0, /* Available to represent a malloc buffer. */
+       FREE,           /* A free buffer. */
+       ALLOCATED,      /* A buffer that is in use. */
+       PROTECTED,      /* A freed buffer that can not be allocated again. */
+       INTERNAL_USE    /* A buffer used internally by malloc(). */
 };
-typedef enum _Mode     Mode;
+typedef enum _Mode Mode;
 
 /*
  * Struct Slot contains all of the information about a malloc buffer except
  * for the contents of its memory.
  */
 struct _Slot {
-       void *          userAddress;
-       void *          internalAddress;
-       size_t          userSize;
-       size_t          internalSize;
-       Mode            mode;
+       void *userAddress;
+       void *internalAddress;
+       size_t userSize;
+       size_t internalSize;
+       Mode mode;
 };
-typedef struct _Slot   Slot;
+typedef struct _Slot Slot;
 
 /*
  * EF_ALIGNMENT is a global variable used to control the default alignment
@@ -84,7 +84,7 @@ typedef struct _Slot  Slot;
  * If the value is -1, it will be set from the environment or sizeof(int)
  * at run time.
  */
-int            EF_ALIGNMENT = -1;
+int EF_ALIGNMENT = -1;
 
 /*
  * EF_PROTECT_FREE is a global variable used to control the disposition of
@@ -97,7 +97,7 @@ int           EF_ALIGNMENT = -1;
  * until it is reallocated.
  * If the value is -1, it will be set from the environment or to 0 at run-time.
  */
-int            EF_PROTECT_FREE = -1;
+int EF_PROTECT_FREE = -1;
 
 /*
  * EF_PROTECT_BELOW is used to modify the behavior of the allocator. When
@@ -109,56 +109,56 @@ int               EF_PROTECT_FREE = -1;
  * If the value is -1, it will be set from the environment or to zero at
  * run-time
  */
-int            EF_PROTECT_BELOW = -1;
+int EF_PROTECT_BELOW = -1;
 
 /*
  * EF_ALLOW_MALLOC_0 is set if Electric Fence is to allow malloc(0). I
  * trap malloc(0) by default because it is a common source of bugs.
  */
-int            EF_ALLOW_MALLOC_0 = -1;
+int EF_ALLOW_MALLOC_0 = -1;
 
 /*
  * EF_FREE_WIPES is set if Electric Fence is to wipe the memory content
  * of freed blocks.  This makes it easier to check if memory is freed or
  * not
  */
-int            EF_FREE_WIPES = -1;
+int EF_FREE_WIPES = -1;
 
 /*
  * allocationList points to the array of slot structures used to manage the
  * malloc arena.
  */
-static Slot *          allocationList = 0;
+static Slot *allocationList = 0;
 
 /*
  * allocationListSize is the size of the allocation list. This will always
  * be a multiple of the page size.
  */
-static size_t          allocationListSize = 0;
+static size_t allocationListSize = 0;
 
 /*
  * slotCount is the number of Slot structures in allocationList.
  */
-static size_t          slotCount = 0;
+static size_t slotCount = 0;
 
 /*
  * unUsedSlots is the number of Slot structures that are currently available
  * to represent new malloc buffers. When this number gets too low, we will
  * create new slots.
  */
-static size_t          unUsedSlots = 0;
+static size_t unUsedSlots = 0;
 
 /*
  * slotsPerPage is the number of slot structures that fit in a virtual
  * memory page.
  */
-static size_t          slotsPerPage = 0;
+static size_t slotsPerPage = 0;
 
 /*
  * internalUse is set when allocating and freeing the allocatior-internal
  * data structures.
  */
-static int             internalUse = 0;
+static int internalUse = 0;
 
 /*
  * noAllocationListProtection is set to tell malloc() and free() not to
@@ -166,15 +166,15 @@ static int                internalUse = 0;
  * realloc(), which does it to save on slow system calls, and in
  * allocateMoreSlots(), which does it because it changes the allocation list.
  */
-static int             noAllocationListProtection = 0;
+static int noAllocationListProtection = 0;
 
 /*
  * bytesPerPage is set at run-time to the number of bytes per virtual-memory
  * page, as returned by Page_Size().
  */
-static size_t          bytesPerPage = 0;
+static size_t bytesPerPage = 0;
 
- /*
+/*
  * mutex to enable multithreaded operation
  */
 static struct spin_pdr_lock pdr_lock = SPINPDR_INITIALIZER;
@@ -218,8 +218,7 @@ static void unlock(void)
  * internalError is called for those "shouldn't happen" errors in the
  * allocator.
  */
-static void
-internalError(void)
+static void internalError(void)
 {
        EF_Abort("Internal error in allocator.");
 }
@@ -228,13 +227,12 @@ internalError(void)
  * initialize sets up the memory allocation arena and the run-time
  * configuration information.
  */
-static void
-initialize(void)
+static void initialize(void)
 {
-       size_t  size = MEMORY_CREATION_SIZE;
-       size_t  slack;
-       char *  string;
-       Slot *  slot;
+       size_t size = MEMORY_CREATION_SIZE;
+       size_t slack;
+       char *string;
+       Slot *slot;
 
        /*
         * Import the user's environment specification of the default
@@ -255,8 +253,8 @@ initialize(void)
         * there are other functions that break, too. Some in X Windows, one
         * in Sam Leffler's TIFF library, and doubtless many others.
         */
-       if ( EF_ALIGNMENT == -1 ) {
-               if ( (string = getenv("EF_ALIGNMENT")) != 0 )
+       if (EF_ALIGNMENT == -1) {
+               if ((string = getenv("EF_ALIGNMENT")) != 0)
                        EF_ALIGNMENT = (size_t)atoi(string);
                else
                        EF_ALIGNMENT = sizeof(int);
@@ -266,8 +264,8 @@ initialize(void)
         * See if the user wants to protect the address space below a buffer,
         * rather than that above a buffer.
         */
-       if ( EF_PROTECT_BELOW == -1 ) {
-               if ( (string = getenv("EF_PROTECT_BELOW")) != 0 )
+       if (EF_PROTECT_BELOW == -1) {
+               if ((string = getenv("EF_PROTECT_BELOW")) != 0)
                        EF_PROTECT_BELOW = (atoi(string) != 0);
                else
                        EF_PROTECT_BELOW = 0;
@@ -277,8 +275,8 @@ initialize(void)
         * See if the user wants to protect memory that has been freed until
         * the program exits, rather than until it is re-allocated.
         */
-       if ( EF_PROTECT_FREE == -1 ) {
-               if ( (string = getenv("EF_PROTECT_FREE")) != 0 )
+       if (EF_PROTECT_FREE == -1) {
+               if ((string = getenv("EF_PROTECT_FREE")) != 0)
                        EF_PROTECT_FREE = (atoi(string) != 0);
                else
                        EF_PROTECT_FREE = 0;
@@ -287,8 +285,8 @@ initialize(void)
        /*
         * See if the user wants to allow malloc(0).
         */
-       if ( EF_ALLOW_MALLOC_0 == -1 ) {
-               if ( (string = getenv("EF_ALLOW_MALLOC_0")) != 0 )
+       if (EF_ALLOW_MALLOC_0 == -1) {
+               if ((string = getenv("EF_ALLOW_MALLOC_0")) != 0)
                        EF_ALLOW_MALLOC_0 = (atoi(string) != 0);
                else
                        EF_ALLOW_MALLOC_0 = 0;
@@ -297,16 +295,16 @@ initialize(void)
        /*
         * See if the user wants us to wipe out freed memory.
         */
-       if ( EF_FREE_WIPES == -1 ) {
-               if ( (string = getenv("EF_FREE_WIPES")) != 0 )
-                       EF_FREE_WIPES = (atoi(string) != 0);
-               else
-                       EF_FREE_WIPES = 0;
+       if (EF_FREE_WIPES == -1) {
+               if ((string = getenv("EF_FREE_WIPES")) != 0)
+                       EF_FREE_WIPES = (atoi(string) != 0);
+               else
+                       EF_FREE_WIPES = 0;
        }
 
        /*
         * Get the run-time configuration of the virtual memory page size.
-        */
+        */
        bytesPerPage = Page_Size();
 
        /*
@@ -315,10 +313,10 @@ initialize(void)
        slotCount = slotsPerPage = bytesPerPage / sizeof(Slot);
        allocationListSize = bytesPerPage;
 
-       if ( allocationListSize > size )
+       if (allocationListSize > size)
                size = allocationListSize;
 
-       if ( (slack = size % bytesPerPage) != 0 )
+       if ((slack = size % bytesPerPage) != 0)
                size += bytesPerPage - slack;
 
        /*
@@ -332,11 +330,10 @@ initialize(void)
        slot[0].internalSize = slot[0].userSize = allocationListSize;
        slot[0].internalAddress = slot[0].userAddress = allocationList;
        slot[0].mode = INTERNAL_USE;
-       if ( size > allocationListSize ) {
-               slot[1].internalAddress = slot[1].userAddress
-                = ((char *)slot[0].internalAddress) + slot[0].internalSize;
-               slot[1].internalSize
-                = slot[1].userSize = size - slot[0].internalSize;
+       if (size > allocationListSize) {
+               slot[1].internalAddress = slot[1].userAddress =
+                   ((char *)slot[0].internalAddress) + slot[0].internalSize;
+               slot[1].internalSize = slot[1].userSize = size - slot[0].internalSize;
                slot[1].mode = FREE;
        }
 
@@ -356,12 +353,11 @@ initialize(void)
  * allocateMoreSlots is called when there are only enough slot structures
  * left to support the allocation of a single malloc buffer.
  */
-static void
-allocateMoreSlots(void)
+static void allocateMoreSlots(void)
 {
-       size_t  newSize = allocationListSize + bytesPerPage;
-       void *  newAllocation;
-       void *  oldAllocation = allocationList;
+       size_t newSize = allocationListSize + bytesPerPage;
+       void *newAllocation;
+       void *oldAllocation = allocationList;
 
        Page_AllowAccess(allocationList, allocationListSize);
        noAllocationListProtection = 1;
@@ -381,7 +377,7 @@ allocateMoreSlots(void)
        /*
         * Keep access to the allocation list open at this point, because
         * I am returning to memalign(), which needs that access.
-        */
+        */
        noAllocationListProtection = 0;
        internalUse = 0;
 }
@@ -402,36 +398,35 @@ allocateMoreSlots(void)
  * functions on Sun systems, which do word references to the string memory
  * and may refer to memory up to three bytes beyond the end of the string.
  * For this reason, I take the alignment requests to memalign() and valloc()
- * seriously, and 
- * 
+ * seriously, and
+ *
  * Electric Fence wastes lots of memory. I do a best-fit allocator here
  * so that it won't waste even more. It's slow, but thrashing because your
- * working set is too big for a system's RAM is even slower. 
+ * working set is too big for a system's RAM is even slower.
  */
-extern C_LINKAGE void *
-memalign(size_t alignment, size_t userSize)
+extern C_LINKAGE void *memalign(size_t alignment, size_t userSize)
 {
-       register Slot * slot;
-       register size_t count;
-       Slot *          fullSlot = 0;
-       Slot *          emptySlots[2];
-       size_t          internalSize;
-       size_t          slack;
-       char *          address;
-
-       if ( allocationList == 0 )
+       register Slot *slot;
+       register size_t count;
+       Slot *fullSlot = 0;
+       Slot *emptySlots[2];
+       size_t internalSize;
+       size_t slack;
+       char *address;
+
+       if (allocationList == 0)
                initialize();
 
        lock();
-       if ( userSize == 0 && !EF_ALLOW_MALLOC_0 )
+       if (userSize == 0 && !EF_ALLOW_MALLOC_0)
                EF_Abort("Allocating 0 bytes, probably a bug.");
 
        /*
         * If EF_PROTECT_BELOW is set, all addresses returned by malloc()
         * and company will be page-aligned.
-        */
-       if ( !EF_PROTECT_BELOW && alignment > 1 ) {
-               if ( (slack = userSize % alignment) != 0 )
+        */
+       if (!EF_PROTECT_BELOW && alignment > 1) {
+               if ((slack = userSize % alignment) != 0)
                        userSize += alignment - slack;
        }
 
@@ -441,7 +436,7 @@ memalign(size_t alignment, size_t userSize)
         * dead page.
         */
        internalSize = userSize + bytesPerPage;
-       if ( (slack = internalSize % bytesPerPage) != 0 )
+       if ((slack = internalSize % bytesPerPage) != 0)
                internalSize += bytesPerPage - slack;
 
        /*
@@ -457,18 +452,18 @@ memalign(size_t alignment, size_t userSize)
         * inaccessable, so that errant programs won't scrawl on the
         * allocator's arena. I'll un-protect it here so that I can make
         * a new allocation. I'll re-protect it before I return.
-        */
-       if ( !noAllocationListProtection )
+        */
+       if (!noAllocationListProtection)
                Page_AllowAccess(allocationList, allocationListSize);
 
        /*
         * If I'm running out of empty slots, create some more before
         * I don't have enough slots left to make an allocation.
         */
-       if ( !internalUse && unUsedSlots < 7 ) {
+       if (!internalUse && unUsedSlots < 7) {
                allocateMoreSlots();
        }
-       
+
        /*
         * Iterate through all of the slot structures. Attempt to find a slot
         * containing free memory of the exact right size. Accept a slot with
@@ -478,48 +473,43 @@ memalign(size_t alignment, size_t userSize)
         * we have to create new memory and mark it as free.
         *
         */
-       
-       for ( slot = allocationList, count = slotCount ; count > 0; count-- ) {
-               if ( slot->mode == FREE
-                && slot->internalSize >= internalSize ) {
-                       if ( !fullSlot
-                        ||slot->internalSize < fullSlot->internalSize){
+
+       for (slot = allocationList, count = slotCount; count > 0; count--) {
+               if (slot->mode == FREE && slot->internalSize >= internalSize) {
+                       if (!fullSlot || slot->internalSize < fullSlot->internalSize) {
                                fullSlot = slot;
-                               if ( slot->internalSize == internalSize
-                                && emptySlots[0] )
-                                       break;  /* All done, */
+                               if (slot->internalSize == internalSize && emptySlots[0])
+                                       break; /* All done, */
                        }
-               }
-               else if ( slot->mode == NOT_IN_USE ) {
-                       if ( !emptySlots[0] )
+               } else if (slot->mode == NOT_IN_USE) {
+                       if (!emptySlots[0])
                                emptySlots[0] = slot;
-                       else if ( !emptySlots[1] )
+                       else if (!emptySlots[1])
                                emptySlots[1] = slot;
-                       else if ( fullSlot
-                        && fullSlot->internalSize == internalSize )
-                               break;  /* All done. */
+                       else if (fullSlot && fullSlot->internalSize == internalSize)
+                               break; /* All done. */
                }
                slot++;
        }
-       if ( !emptySlots[0] )
+       if (!emptySlots[0])
                internalError();
 
-       if ( !fullSlot ) {
+       if (!fullSlot) {
                /*
                 * I get here if I haven't been able to find a free buffer
                 * with all of the memory I need. I'll have to create more
                 * memory. I'll mark it all as free, and then split it into
                 * free and allocated portions later.
                 */
-               size_t  chunkSize = MEMORY_CREATION_SIZE;
+               size_t chunkSize = MEMORY_CREATION_SIZE;
 
-               if ( !emptySlots[1] )
+               if (!emptySlots[1])
                        internalError();
 
-               if ( chunkSize < internalSize )
+               if (chunkSize < internalSize)
                        chunkSize = internalSize;
 
-               if ( (slack = chunkSize % bytesPerPage) != 0 )
+               if ((slack = chunkSize % bytesPerPage) != 0)
                        chunkSize += bytesPerPage - slack;
 
                /* Use up one of the empty slots to make the full slot. */
@@ -536,7 +526,7 @@ memalign(size_t alignment, size_t userSize)
         * mark it INTERNAL_USE so that no errant software will be able to
         * free it.
         */
-       if ( internalUse )
+       if (internalUse)
                fullSlot->mode = INTERNAL_USE;
        else
                fullSlot->mode = ALLOCATED;
@@ -546,17 +536,16 @@ memalign(size_t alignment, size_t userSize)
         * an allocated buffer with the exact amount of memory I need, and
         * a free buffer containing the surplus memory.
         */
-       if ( fullSlot->internalSize > internalSize ) {
-               emptySlots[0]->internalSize
-                = fullSlot->internalSize - internalSize;
-               emptySlots[0]->internalAddress
-                = ((char *)fullSlot->internalAddress) + internalSize;
+       if (fullSlot->internalSize > internalSize) {
+               emptySlots[0]->internalSize = fullSlot->internalSize - internalSize;
+               emptySlots[0]->internalAddress =
+                   ((char *)fullSlot->internalAddress) + internalSize;
                emptySlots[0]->mode = FREE;
                fullSlot->internalSize = internalSize;
                unUsedSlots--;
        }
 
-       if ( !EF_PROTECT_BELOW ) {
+       if (!EF_PROTECT_BELOW) {
                /*
                 * Arrange the buffer so that it is followed by an inaccessable
                 * memory page. A buffer overrun that touches that page will
@@ -565,11 +554,10 @@ memalign(size_t alignment, size_t userSize)
                address = (char *)fullSlot->internalAddress;
 
                /* Set up the "live" page. */
-               if ( internalSize - bytesPerPage > 0 )
-                               Page_AllowAccess(
-                                fullSlot->internalAddress
-                               ,internalSize - bytesPerPage);
-                       
+               if (internalSize - bytesPerPage > 0)
+                       Page_AllowAccess(fullSlot->internalAddress,
+                                        internalSize - bytesPerPage);
+
                address += internalSize - bytesPerPage;
 
                /* Set up the "dead" page. */
@@ -577,8 +565,7 @@ memalign(size_t alignment, size_t userSize)
 
                /* Figure out what address to give the user. */
                address -= userSize;
-       }
-       else {  /* EF_PROTECT_BELOW != 0 */
+       } else { /* EF_PROTECT_BELOW != 0 */
                /*
                 * Arrange the buffer so that it is preceded by an inaccessable
                 * memory page. A buffer underrun that touches that page will
@@ -588,11 +575,11 @@ memalign(size_t alignment, size_t userSize)
 
                /* Set up the "dead" page. */
                Page_DenyAccess(address, bytesPerPage);
-                       
+
                address += bytesPerPage;
 
                /* Set up the "live" page. */
-               if ( internalSize - bytesPerPage > 0 )
+               if (internalSize - bytesPerPage > 0)
                        Page_AllowAccess(address, internalSize - bytesPerPage);
        }
 
@@ -603,7 +590,7 @@ memalign(size_t alignment, size_t userSize)
         * Make the pool's internal memory inaccessable, so that the program
         * being debugged can't stomp on it.
         */
-       if ( !internalUse )
+       if (!internalUse)
                Page_DenyAccess(allocationList, allocationListSize);
 
        unlock();
@@ -613,14 +600,13 @@ memalign(size_t alignment, size_t userSize)
 /*
  * Find the slot structure for a user address.
  */
-static Slot *
-slotForUserAddress(void * address)
+static Slot *slotForUserAddress(void *address)
 {
-       register Slot * slot = allocationList;
-       register size_t count = slotCount;
-       
-       for ( ; count > 0; count-- ) {
-               if ( slot->userAddress == address )
+       register Slot *slot = allocationList;
+       register size_t count = slotCount;
+
+       for (; count > 0; count--) {
+               if (slot->userAddress == address)
                        return slot;
                slot++;
        }
@@ -631,14 +617,13 @@ slotForUserAddress(void * address)
 /*
  * Find the slot structure for an internal address.
  */
-static Slot *
-slotForInternalAddress(void * address)
+static Slot *slotForInternalAddress(void *address)
 {
-       register Slot * slot = allocationList;
-       register size_t count = slotCount;
-       
-       for ( ; count > 0; count-- ) {
-               if ( slot->internalAddress == address )
+       register Slot *slot = allocationList;
+       register size_t count = slotCount;
+
+       for (; count > 0; count--) {
+               if (slot->internalAddress == address)
                        return slot;
                slot++;
        }
@@ -650,73 +635,68 @@ slotForInternalAddress(void * address)
  * before that buffer in the address space. This is used by free() to
  * coalesce two free buffers into one.
  */
-static Slot *
-slotForInternalAddressPreviousTo(void * address)
+static Slot *slotForInternalAddressPreviousTo(void *address)
 {
-       register Slot * slot = allocationList;
-       register size_t count = slotCount;
-       
-       for ( ; count > 0; count-- ) {
-               if ( ((char *)slot->internalAddress)
-                + slot->internalSize == address )
+       register Slot *slot = allocationList;
+       register size_t count = slotCount;
+
+       for (; count > 0; count--) {
+               if (((char *)slot->internalAddress) + slot->internalSize == address)
                        return slot;
                slot++;
        }
        return 0;
 }
 
-extern C_LINKAGE void
-free(void * address)
+extern C_LINKAGE void free(void *address)
 {
-       Slot *  slot;
-       Slot *  previousSlot = 0;
-       Slot *  nextSlot = 0;
+       Slot *slot;
+       Slot *previousSlot = 0;
+       Slot *nextSlot = 0;
 
-        lock();
+       lock();
 
-        if ( address == 0 ) {
-                unlock();
-                return;
-        }
+       if (address == 0) {
+               unlock();
+               return;
+       }
 
-       if ( allocationList == 0 )
+       if (allocationList == 0)
                EF_Abort("free() called before first malloc().");
 
-       if ( !noAllocationListProtection )
+       if (!noAllocationListProtection)
                Page_AllowAccess(allocationList, allocationListSize);
 
        slot = slotForUserAddress(address);
 
-       if ( !slot )
+       if (!slot)
                EF_Abort("free(%a): address not from malloc().", address);
 
-       if ( slot->mode != ALLOCATED ) {
-               if ( internalUse && slot->mode == INTERNAL_USE )
+       if (slot->mode != ALLOCATED) {
+               if (internalUse && slot->mode == INTERNAL_USE)
                        /* Do nothing. */;
                else {
-                       EF_Abort(
-                        "free(%a): freeing free memory."
-                       ,address);
+                       EF_Abort("free(%a): freeing free memory.", address);
                }
        }
 
-       if ( EF_PROTECT_FREE )
+       if (EF_PROTECT_FREE)
                slot->mode = PROTECTED;
        else
                slot->mode = FREE;
 
-       if ( EF_FREE_WIPES )
-               memset(slot->userAddress, 0xbd, slot->userSize);
+       if (EF_FREE_WIPES)
+               memset(slot->userAddress, 0xbd, slot->userSize);
 
        previousSlot = slotForInternalAddressPreviousTo(slot->internalAddress);
-       nextSlot = slotForInternalAddress(
-        ((char *)slot->internalAddress) + slot->internalSize);
+       nextSlot = slotForInternalAddress(((char *)slot->internalAddress) +
+                                         slot->internalSize);
 
-       if ( previousSlot
-        && (previousSlot->mode == FREE || previousSlot->mode == PROTECTED) ) {
+       if (previousSlot &&
+           (previousSlot->mode == FREE || previousSlot->mode == PROTECTED)) {
                /* Coalesce previous slot with this one. */
                previousSlot->internalSize += slot->internalSize;
-               if ( EF_PROTECT_FREE )
+               if (EF_PROTECT_FREE)
                        previousSlot->mode = PROTECTED;
 
                slot->internalAddress = slot->userAddress = 0;
@@ -725,8 +705,7 @@ free(void * address)
                slot = previousSlot;
                unUsedSlots++;
        }
-       if ( nextSlot
-        && (nextSlot->mode == FREE || nextSlot->mode == PROTECTED) ) {
+       if (nextSlot && (nextSlot->mode == FREE || nextSlot->mode == PROTECTED)) {
                /* Coalesce next slot with this one. */
                slot->internalSize += nextSlot->internalSize;
                nextSlot->internalAddress = nextSlot->userAddress = 0;
@@ -741,53 +720,50 @@ free(void * address)
        /*
         * Free memory is _always_ set to deny access. When EF_PROTECT_FREE
         * is true, free memory is never reallocated, so it remains access
-        * denied for the life of the process. When EF_PROTECT_FREE is false, 
+        * denied for the life of the process. When EF_PROTECT_FREE is false,
         * the memory may be re-allocated, at which time access to it will be
         * allowed again.
         */
        Page_DenyAccess(slot->internalAddress, slot->internalSize);
 
-       if ( !noAllocationListProtection )
+       if (!noAllocationListProtection)
                Page_DenyAccess(allocationList, allocationListSize);
 
-        unlock();
+       unlock();
 }
 
-extern C_LINKAGE void *
-realloc(void * oldBuffer, size_t newSize)
+extern C_LINKAGE void *realloc(void *oldBuffer, size_t newSize)
 {
-       void *  newBuffer = malloc(newSize);
+       void *newBuffer = malloc(newSize);
 
-        lock();
+       lock();
 
-       if ( oldBuffer ) {
-               size_t  size;
-               Slot *  slot;
+       if (oldBuffer) {
+               size_t size;
+               Slot *slot;
 
                Page_AllowAccess(allocationList, allocationListSize);
                noAllocationListProtection = 1;
-               
+
                slot = slotForUserAddress(oldBuffer);
 
-               if ( slot == 0 )
-                       EF_Abort(
-                        "realloc(%a, %d): address not from malloc()."
-                       ,oldBuffer
-                       ,newSize);
+               if (slot == 0)
+                       EF_Abort("realloc(%a, %d): address not from malloc().", oldBuffer,
+                                newSize);
 
-               if ( newSize < (size = slot->userSize) )
+               if (newSize < (size = slot->userSize))
                        size = newSize;
 
-               if ( size > 0 )
+               if (size > 0)
                        memcpy(newBuffer, oldBuffer, size);
 
                free(oldBuffer);
                noAllocationListProtection = 0;
                Page_DenyAccess(allocationList, allocationListSize);
 
-               if ( size < newSize )
+               if (size < newSize)
                        memset(&(((char *)newBuffer)[size]), 0, newSize - size);
-               
+
                /* Internal memory was re-protected in free() */
        }
        unlock();
@@ -795,60 +771,58 @@ realloc(void * oldBuffer, size_t newSize)
        return newBuffer;
 }
 
-extern C_LINKAGE void *
-malloc(size_t size)
+extern C_LINKAGE void *malloc(size_t size)
 {
        if (!allocationList)
-               initialize();   /* This sets EF_ALIGNMENT */
+               initialize(); /* This sets EF_ALIGNMENT */
        return memalign(EF_ALIGNMENT, size);
 }
 
-extern C_LINKAGE char *
-strdup(const char *s1)
+extern C_LINKAGE char *strdup(const char *s1)
 {
-        if (!s1) return 0;
-        char *s2 = malloc(strlen(s1) + 1);
+       if (!s1)
+               return 0;
+       char *s2 = malloc(strlen(s1) + 1);
 
-        if (!s2) {
-                errno = ENOMEM;
-                return 0;
-        }
+       if (!s2) {
+               errno = ENOMEM;
+               return 0;
+       }
 
-        return strcpy(s2, s1);
+       return strcpy(s2, s1);
 }
 
-extern C_LINKAGE char *
-strndup(const char *s1, size_t n)
+extern C_LINKAGE char *strndup(const char *s1, size_t n)
 {
-        if (!s1) return 0;
-        int complete_size = n;  /* includes terminating null */
-        for (int i = 0; i < n - 1; i++) {
-                if (!s1[i]) {
-                        complete_size = i + 2;
-                        break;
-                }
-        }
-        char *s2 = malloc(complete_size);
-
-        if (!s2) {
-                errno = ENOMEM;
-                return 0;
-        }
-
-        strncpy(s2, s1, complete_size - 1);
-        s2[complete_size - 1] = '\0';
-
-        return s2;
+       if (!s1)
+               return 0;
+       int complete_size = n; /* includes terminating null */
+       for (int i = 0; i < n - 1; i++) {
+               if (!s1[i]) {
+                       complete_size = i + 2;
+                       break;
+               }
+       }
+       char *s2 = malloc(complete_size);
+
+       if (!s2) {
+               errno = ENOMEM;
+               return 0;
+       }
+
+       strncpy(s2, s1, complete_size - 1);
+       s2[complete_size - 1] = '\0';
+
+       return s2;
 }
 
-extern C_LINKAGE void *
-calloc(size_t nelem, size_t elsize)
+extern C_LINKAGE void *calloc(size_t nelem, size_t elsize)
 {
-       size_t  size = nelem * elsize;
-        void * allocation;
-        
-        allocation = malloc(size);
-        memset(allocation, 0, size);
+       size_t size = nelem * elsize;
+       void *allocation;
+
+       allocation = malloc(size);
+       memset(allocation, 0, size);
 
        return allocation;
 }
@@ -857,14 +831,13 @@ calloc(size_t nelem, size_t elsize)
  * This will catch more bugs if you remove the page alignment, but it
  * will break some software.
  */
-extern C_LINKAGE void *
-valloc (size_t size)
+extern C_LINKAGE void *valloc(size_t size)
 {
        return memalign(bytesPerPage, size);
 }
 
-extern C_LINKAGE int
-posix_memalign(void **memptr, size_t alignment, size_t size)
+extern C_LINKAGE int posix_memalign(void **memptr, size_t alignment,
+                                    size_t size)
 {
        *memptr = memalign(alignment, size);
        if (!*memptr) {
@@ -874,8 +847,7 @@ posix_memalign(void **memptr, size_t alignment, size_t size)
        return 0;
 }
 
-extern C_LINKAGE void *
-aligned_alloc(size_t alignment, size_t size)
+extern C_LINKAGE void *aligned_alloc(size_t alignment, size_t size)
 {
        return memalign(alignment, size);
 }
index 372ac59..d185f3f 100644 (file)
-#include <stdlib.h>
+#include "efence.h"
+#include <setjmp.h>
+#include <signal.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include <setjmp.h>
-#include <signal.h>
-#include "efence.h"
 
 /*
  * Electric Fence confidence tests.
  * Make sure all of the various functions of Electric Fence work correctly.
  */
 
-#ifndef        PAGE_PROTECTION_VIOLATED_SIGNAL
-#define        PAGE_PROTECTION_VIOLATED_SIGNAL SIGSEGV
+#ifndef PAGE_PROTECTION_VIOLATED_SIGNAL
+#define PAGE_PROTECTION_VIOLATED_SIGNAL SIGSEGV
 #endif
 
 struct diagnostic {
-       int             (*test)(void);
-       int             expectedStatus;
-       const char *    explanation;
+       int (*test)(void);
+       int expectedStatus;
+       const char *explanation;
 };
 
-extern int     EF_PROTECT_BELOW;
-extern int     EF_ALIGNMENT;
+extern int EF_PROTECT_BELOW;
+extern int EF_ALIGNMENT;
 
-static sigjmp_buf      env;
+static sigjmp_buf env;
 
 /*
  * There is still too little standardization of the arguments and return
  * type of signal handler functions.
  */
-static
-void
-segmentationFaultHandler(
-int signalNumber
-#if ( defined(_AIX) )
-, ...
+static void segmentationFaultHandler(int signalNumber
+#if (defined(_AIX))
+                                     ,
+                                     ...
 #endif
-)
- {
+                                     )
+{
        signal(PAGE_PROTECTION_VIOLATED_SIGNAL, SIG_DFL);
        siglongjmp(env, 1);
 }
 
-static int
-gotSegmentationFault(int (*test)(void))
+static int gotSegmentationFault(int (*test)(void))
 {
-       if ( sigsetjmp(env,1) == 0 ) {
-               int                     status;
+       if (sigsetjmp(env, 1) == 0) {
+               int status;
 
-               signal(PAGE_PROTECTION_VIOLATED_SIGNAL
-               ,segmentationFaultHandler);
+               signal(PAGE_PROTECTION_VIOLATED_SIGNAL, segmentationFaultHandler);
                status = (*test)();
                signal(PAGE_PROTECTION_VIOLATED_SIGNAL, SIG_DFL);
                return status;
-       }
-       else
+       } else
                return 1;
 }
 
-static char *  allocation;
+static char *allocation;
 /* c is global so that assignments to it won't be optimized out. */
-char   c;
+char c;
 
-static int
-testSizes(void)
+static int testSizes(void)
 {
        /*
         * If ef_number can't hold all of the bits of a void *, have the user
         * add -DUSE_ LONG_LONG to the compiler flags so that ef_number will be
         * declared as "unsigned long long" instead of "unsigned long".
         */
-       return ( sizeof(ef_number) < sizeof(void *) );
+       return (sizeof(ef_number) < sizeof(void *));
 }
 
-static int
-allocateMemory(void)
+static int allocateMemory(void)
 {
        allocation = (char *)malloc(1);
 
-       if ( allocation != 0 )
+       if (allocation != 0)
                return 0;
        else
                return 1;
 }
 
-static int
-freeMemory(void)
+static int freeMemory(void)
 {
        free(allocation);
        return 0;
 }
 
-static int
-protectBelow(void)
+static int protectBelow(void)
 {
        EF_PROTECT_BELOW = 1;
        return 0;
 }
 
-static int
-read0(void)
+static int read0(void)
 {
        c = *allocation;
 
        return 0;
 }
 
-static int
-write0(void)
+static int write0(void)
 {
        *allocation = 1;
 
        return 0;
 }
 
-static int
-read1(void)
+static int read1(void)
 {
        c = allocation[1];
 
        return 0;
 }
 
-static int
-readMinus1(void)
+static int readMinus1(void)
 {
        c = allocation[-1];
        return 0;
 }
 
 static struct diagnostic diagnostics[] = {
-       {
-               testSizes, 0,
-               "Please add -DLONG_LONG to the compiler flags and recompile."
-       },
-       {
-               allocateMemory, 0,
-               "Allocation 1: This test allocates a single byte of memory."
-       },
-       {
-               read0, 0,
-               "Read valid memory 1: This test reads the allocated memory."
-       },
-       {
-               write0, 0,
-               "Write valid memory 1: This test writes the allocated memory."
-       },
-       {
-               read1, 1,
-               "Read overrun: This test reads beyond the end of the buffer."
-       },
-       {
-               freeMemory, 0,
-               "Free memory: This test frees the allocated memory."
-       },
-       {
-               protectBelow, 0,
-               "Protect below: This sets Electric Fence to protect\n"
-               "the lower boundary of a malloc buffer, rather than the\n"
-               "upper boundary."
-       },
-       {
-               allocateMemory, 0,
-               "Allocation 2: This allocates memory with the lower boundary"
-               " protected."
-       },
-       {
-               read0, 0,
-               "Read valid memory 2: This test reads the allocated memory."
-       },
-       {
-               write0, 0,
-               "Write valid memory 2: This test writes the allocated memory."
-       },
-       {
-               readMinus1, 1,
-               "Read underrun: This test reads before the beginning of the"
-               " buffer."
-       },
-       {
-               0, 0, 0
-       }
-};
-
-static const char      failedTest[]
- = "Electric Fence confidence test failed.\n";
-
-static const char      newline = '\n';
-
-int
-main(int argc, char * * argv)
+    {testSizes, 0,
+     "Please add -DLONG_LONG to the compiler flags and recompile."},
+    {allocateMemory, 0,
+     "Allocation 1: This test allocates a single byte of memory."},
+    {read0, 0, "Read valid memory 1: This test reads the allocated memory."},
+    {write0, 0, "Write valid memory 1: This test writes the allocated memory."},
+    {read1, 1, "Read overrun: This test reads beyond the end of the buffer."},
+    {freeMemory, 0, "Free memory: This test frees the allocated memory."},
+    {protectBelow, 0,
+     "Protect below: This sets Electric Fence to protect\n"
+     "the lower boundary of a malloc buffer, rather than the\n"
+     "upper boundary."},
+    {allocateMemory, 0,
+     "Allocation 2: This allocates memory with the lower boundary"
+     " protected."},
+    {read0, 0, "Read valid memory 2: This test reads the allocated memory."},
+    {write0, 0, "Write valid memory 2: This test writes the allocated memory."},
+    {readMinus1, 1,
+     "Read underrun: This test reads before the beginning of the"
+     " buffer."},
+    {0, 0, 0}};
+
+static const char failedTest[] = "Electric Fence confidence test failed.\n";
+
+static const char newline = '\n';
+
+int main(int argc, char **argv)
 {
-       static const struct diagnostic *        diag = diagnostics;
-       
+       static const struct diagnostic *diag = diagnostics;
 
        EF_PROTECT_BELOW = 0;
        EF_ALIGNMENT = 0;
 
-       while ( diag->explanation != 0 ) {
-               int     status = gotSegmentationFault(diag->test);
+       while (diag->explanation != 0) {
+               int status = gotSegmentationFault(diag->test);
 
-               if ( status != diag->expectedStatus ) {
+               if (status != diag->expectedStatus) {
                        /*
                         * Don't use stdio to print here, because stdio
                         * uses malloc() and we've just proven that malloc()
index bc925e7..bf09606 100644 (file)
@@ -1,24 +1,23 @@
 /* For email below, drop spaces and <spam-buster> tag.
  * MODIFIED:  March 20, 2014 (jric<spam-buster> @ <spam-buster> chegg DOT com)
-*/
+ */
 #include "efence.h"
-#include <stdlib.h>
-#include <unistd.h>
 #include <fcntl.h>
-#include <sys/mman.h>
+#include <parlib/uthread.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <parlib/uthread.h>
+#include <sys/mman.h>
+#include <unistd.h>
 
-static caddr_t startAddr = (caddr_t) 0;
+static caddr_t startAddr = (caddr_t)0;
 
 /*
  * Create memory.
  */
-void *
-Page_Create(size_t size)
+void *Page_Create(size_t size)
 {
-       caddr_t         allocation;
+       caddr_t allocation;
 
        /*
         * In this version, "startAddr" is a _hint_, not a demand.
@@ -30,13 +29,8 @@ Page_Create(size_t size)
         * the MMAP_FIXED flag, but I don't want to stomp on memory mappings
         * generated by other software, etc.
         */
-       allocation = (caddr_t) mmap(
-        startAddr
-       ,size
-       ,PROT_READ|PROT_WRITE
-       ,MAP_PRIVATE|MAP_ANONYMOUS
-       ,-1
-       ,0);
+       allocation = (caddr_t)mmap(startAddr, size, PROT_READ | PROT_WRITE,
+                                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 
        /*
         * Set the "address hint" for the next mmap() so that it will abut
@@ -50,41 +44,35 @@ Page_Create(size_t size)
         */
        startAddr = allocation + size;
 
-       if ( allocation == (caddr_t)-1 )
+       if (allocation == (caddr_t)-1)
                EF_Exit("mmap() failed: %r");
 
        return (void *)allocation;
 }
 
-static void
-mprotectFailed(void)
+static void mprotectFailed(void)
 {
        EF_Exit("mprotect() failed: %r");
 }
 
-void
-Page_AllowAccess(void * address, size_t size)
+void Page_AllowAccess(void *address, size_t size)
 {
-       if ( mprotect((caddr_t)address, size, PROT_READ|PROT_WRITE) < 0 )
+       if (mprotect((caddr_t)address, size, PROT_READ | PROT_WRITE) < 0)
                mprotectFailed();
 }
 
-void
-Page_DenyAccess(void * address, size_t size)
+void Page_DenyAccess(void *address, size_t size)
 {
-       if ( mprotect((caddr_t)address, size, PROT_NONE) < 0 )
+       if (mprotect((caddr_t)address, size, PROT_NONE) < 0)
                mprotectFailed();
 }
 
-void
-Page_Delete(void * address, size_t size)
+void Page_Delete(void *address, size_t size)
 {
        Page_DenyAccess(address, size);
 }
 
-
-size_t
-Page_Size(void)
+size_t Page_Size(void)
 {
        return PGSIZE;
 }
index c28189e..7ce8597 100644 (file)
@@ -1,9 +1,9 @@
 #include "efence.h"
-#include <stdlib.h>
-#include <unistd.h>
+#include <signal.h>
 #include <stdarg.h>
+#include <stdlib.h>
 #include <string.h>
-#include <signal.h>
+#include <unistd.h>
 
 /*
  * These routines do their printing without using stdio. Stdio can't
  * NUMBER_BUFFER_SIZE is the longest character string that could be needed
  * to represent an unsigned integer, assuming we might print in base 2.
  */
-#define        NUMBER_BUFFER_SIZE      (sizeof(ef_number) * NBBY)
+#define NUMBER_BUFFER_SIZE (sizeof(ef_number) * NBBY)
 
-static void
-printNumber(ef_number number, ef_number base)
+static void printNumber(ef_number number, ef_number base)
 {
-       char            buffer[NUMBER_BUFFER_SIZE];
-       char *          s = &buffer[NUMBER_BUFFER_SIZE];
-       int             size;
-       
+       char buffer[NUMBER_BUFFER_SIZE];
+       char *s = &buffer[NUMBER_BUFFER_SIZE];
+       int size;
+
        do {
-               ef_number       digit;
+               ef_number digit;
 
-               if ( --s == buffer )
+               if (--s == buffer)
                        EF_Abort("Internal error printing number.");
 
                digit = number % base;
 
-               if ( digit < 10 )
+               if (digit < 10)
                        *s = '0' + digit;
                else
                        *s = 'a' + digit - 10;
 
-       } while ( (number /= base) > 0 );
+       } while ((number /= base) > 0);
 
        size = &buffer[NUMBER_BUFFER_SIZE] - s;
 
-       if ( size > 0 )
+       if (size > 0)
                write(2, s, size);
 }
 
-static void
-vprint(const char * pattern, va_list args)
+static void vprint(const char *pattern, va_list args)
 {
-       static const char       bad_pattern[] =
-        "\nBad pattern specifier %%%c in EF_Print().\n";
-       const char *    s = pattern;
-       char            c;
+       static const char bad_pattern[] =
+           "\nBad pattern specifier %%%c in EF_Print().\n";
+       const char *s = pattern;
+       char c;
 
-       while ( (c = *s++) != '\0' ) {
-               if ( c == '%' ) {
+       while ((c = *s++) != '\0') {
+               if (c == '%') {
                        c = *s++;
-                       switch ( c ) {
+                       switch (c) {
                        case '%':
-                               (void) write(2, &c, 1);
+                               (void)write(2, &c, 1);
                                break;
                        case 'a':
                                /*
@@ -67,59 +65,47 @@ vprint(const char * pattern, va_list args)
                                 * it is large enough to contain all of the
                                 * bits of a void pointer.
                                 */
-                               printNumber(
-                                (ef_number)va_arg(args, void *)
-                               ,0x10);
-                               break;
-                       case 's':
-                               {
-                                       const char *    string;
-                                       size_t          length;
-
-                                       string = va_arg(args, char *);
-                                       length = strlen(string);
-
-                                       (void) write(2, string, length);
-                               }
+                               printNumber((ef_number)va_arg(args, void *), 0x10);
                                break;
-                       case 'd':
-                               {
-                                       int     n = va_arg(args, int);
-
-                                       if ( n < 0 ) {
-                                               char    c = '-';
-                                               write(2, &c, 1);
-                                               n = -n;
-                                       }
-                                       printNumber(n, 10);
+                       case 's': {
+                               const char *string;
+                               size_t length;
+
+                               string = va_arg(args, char *);
+                               length = strlen(string);
+
+                               (void)write(2, string, length);
+                       } break;
+                       case 'd': {
+                               int n = va_arg(args, int);
+
+                               if (n < 0) {
+                                       char c = '-';
+                                       write(2, &c, 1);
+                                       n = -n;
                                }
-                               break;
+                               printNumber(n, 10);
+                       } break;
                        case 'x':
                                printNumber(va_arg(args, u_int), 0x10);
                                break;
-                       case 'c':
-                               { /*Cast used, since char gets promoted to int in ... */
-                                       char    c = (char) va_arg(args, int);
-                                       
-                                       (void) write(2, &c, 1);
-                               }
-                               break;
-                       default:
-                               {
-                                       EF_Print(bad_pattern, c);
-                               }
-               
+                       case 'c': { /*Cast used, since char gets promoted to int in ... */
+                               char c = (char)va_arg(args, int);
+
+                               (void)write(2, &c, 1);
+                       } break;
+                       default: {
+                               EF_Print(bad_pattern, c);
                        }
-               }
-               else
-                       (void) write(2, &c, 1);
+                       }
+               else
+                       (void)write(2, &c, 1);
        }
 }
 
-void
-EF_Abort(const char * pattern, ...)
+void EF_Abort(const char *pattern, ...)
 {
-       va_list args;
+       va_list args;
 
        va_start(args, pattern);
 
@@ -139,10 +125,9 @@ EF_Abort(const char * pattern, ...)
        _exit(-1);
 }
 
-void
-EF_Exit(const char * pattern, ...)
+void EF_Exit(const char *pattern, ...)
 {
-       va_list args;
+       va_list args;
 
        va_start(args, pattern);
 
@@ -159,10 +144,9 @@ EF_Exit(const char * pattern, ...)
        _exit(-1);
 }
 
-void
-EF_Print(const char * pattern, ...)
+void EF_Print(const char *pattern, ...)
 {
-       va_list args;
+       va_list args;
 
        va_start(args, pattern);
        vprint(pattern, args);