mm/ file clean-up

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@4943 42af7a65-404d-4744-a932-0658087f49c3

18 files changed, 493 insertions, 439 deletions

diff --git a/nuttx/ChangeLog b/nuttx/ChangeLog
index 54e2ad3a8..23d3084ae 100644
--- a/nuttx/ChangeLog
+++ b/nuttx/ChangeLog
@@ -2994,3 +2994,4 @@
 	* sched/: Stylistic clean-up of all files.  Some of these files are pretty old
 	  and do not follow current NuttX coding standards in detail.
 	* fs/: More stylistic file clean-up.
+	* mm/: More stylistic file clean-up.
diff --git a/nuttx/mm/Makefile b/nuttx/mm/Makefile
index d4ee105d5..7e6eb68a7 100644
--- a/nuttx/mm/Makefile
+++ b/nuttx/mm/Makefile
@@ -2,7 +2,7 @@
 # mm/Makefile
 #
 #   Copyright (C) 2007 Gregory Nutt. All rights reserved.
-#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#   Author: Gregory Nutt <gnutt@nuttx.org>
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
@@ -74,4 +74,3 @@ distclean: clean
 	@rm -f Make.dep .depend
 
 -include Make.dep
-
diff --git a/nuttx/mm/Makefile.test b/nuttx/mm/Makefile.test
index 26839de81..63cab910e 100644
--- a/nuttx/mm/Makefile.test
+++ b/nuttx/mm/Makefile.test
@@ -1,8 +1,8 @@
 ############################################################################
-# Makefile.test
+# mm/Makefile.test
 #
 #   Copyright (C) 2007, 2008 Gregory Nutt. All rights reserved.
-#   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+#   Author: Gregory Nutt <gnutt@nuttx.org>
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
diff --git a/nuttx/mm/mm_addfreechunk.c b/nuttx/mm/mm_addfreechunk.c
index 0cf2fcf42..fdda3ed8d 100644
--- a/nuttx/mm/mm_addfreechunk.c
+++ b/nuttx/mm/mm_addfreechunk.c
@@ -1,8 +1,8 @@
-/************************************************************************
+/****************************************************************************
  * mm/mm_addfreechunk.c
  *
  *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,35 +31,35 @@
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Included Files
- ************************************************************************/
+ ****************************************************************************/
 
 #include "mm_environment.h"
 #include "mm_internal.h"
 
-/************************************************************************
+/****************************************************************************
  * Pre-processor Definitions
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Private Functions
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Global Functions
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
- * mm_addfreechunk
+/****************************************************************************
+ * Name: mm_addfreechunk
  *
  * Description:
- *   Add a free chunk to the node next
- *   It is assumed that the caller holds the mm semaphore
+ *   Add a free chunk to the node next.  It is assumed that the caller holds
+ *   the mm semaphore
  *
- ************************************************************************/
+ ****************************************************************************/
 
 void mm_addfreechunk(FAR struct mm_freenode_s *node)
 {
diff --git a/nuttx/mm/mm_calloc.c b/nuttx/mm/mm_calloc.c
index 47c75d42f..576081a16 100644
--- a/nuttx/mm/mm_calloc.c
+++ b/nuttx/mm/mm_calloc.c
@@ -1,8 +1,8 @@
-/************************************************************************
- * mm_calloc.c
+/****************************************************************************
+ * mm/mm_calloc.c
  *
  *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,29 +31,30 @@
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Included Files
- ************************************************************************/
+ ****************************************************************************/
 
 #include "mm_environment.h"
 #include "mm_internal.h"
 
-/************************************************************************
+/****************************************************************************
  * Pre-processor Definitions
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Global Functions
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
- * calloc
+/****************************************************************************
+ * Name: calloc
  *
  * Descripton:
- *   calloc calculates the size and calls zalloc
- ************************************************************************/
+ *   calloc calculates the size of the allocation and calls zalloc
+ *
+ ****************************************************************************/
 
 FAR void *calloc(size_t n, size_t elem_size)
 {
diff --git a/nuttx/mm/mm_environment.h b/nuttx/mm/mm_environment.h
index ef4f14f7a..70e611116 100644
--- a/nuttx/mm/mm_environment.h
+++ b/nuttx/mm/mm_environment.h
@@ -2,7 +2,7 @@
  * mm/mm_environment.h
  *
  *   Copyright (C) 2007-2009, 2011 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -40,33 +40,32 @@
  * Included Files
  ****************************************************************************/
 
-/* The platform configuratioin file will not be included
- * when the memory manager is built for the host-based
- * test harness.
+/* The platform configuratioin file will not be included when the memory
+ * manager is built for the host-based test harness.
  */
 
 #ifndef MM_TEST
-# include <nuttx/config.h>
-# include <nuttx/compiler.h>
-# include <sys/types.h>
-# include <stdlib.h>
-# include <string.h>
-# include <debug.h>
-# include <errno.h>
-# include <assert.h>
-# include <nuttx/mm.h>
+#  include <nuttx/config.h>
+#  include <nuttx/compiler.h>
+#  include <sys/types.h>
+#  include <stdlib.h>
+#  include <string.h>
+#  include <debug.h>
+#  include <errno.h>
+#  include <assert.h>
+#  include <nuttx/mm.h>
 #else
-# include <sys/types.h>
-# include <string.h>
-# include <assert.h>
+#  include <sys/types.h>
+#  include <string.h>
+#  include <assert.h>
 #endif
 
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/
 
-/* Special definitions used when the memory mnager is built
- * for the host-based test harness.
+/* Special definitions used when the memory mnager is built for the host-
+ * based test harness.
  */
 
 #ifdef MM_TEST
@@ -86,9 +85,8 @@ extern void mm_addregion(FAR void *heapstart, size_t heapsize);
 
 # define mm_errno errno
 
-/* When built for the test harness, we change the names of the
- * exported functions so that they do not collide with the
- * host libc names.
+/* When built for the test harness, we change the names of the exported
+ * functions so that they do not collide with the host libc names.
  */
 
 # define malloc    mm_malloc
diff --git a/nuttx/mm/mm_free.c b/nuttx/mm/mm_free.c
index 20135484b..b34b8a459 100644
--- a/nuttx/mm/mm_free.c
+++ b/nuttx/mm/mm_free.c
@@ -1,8 +1,8 @@
-/************************************************************************
+/****************************************************************************
  * mm/mm_free.c
  *
  *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,36 +31,37 @@
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Included Files
- ************************************************************************/
+ ****************************************************************************/
 
 #include <assert.h>
+
 #include "mm_environment.h"
 #include "mm_internal.h"
 
-/************************************************************************
+/****************************************************************************
  * Pre-processor Definitions
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Private Functions
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Public Functions
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
- * free
+/****************************************************************************
+ * Name: free
  *
  * Description:
- *   Returns a chunk of memory into the list of free nodes,
- *   merging with adjacent free chunks if possible.
+ *   Returns a chunk of memory into the list of free nodes,  merging with
+ *   adjacent free chunks if possible.
  *
- ************************************************************************/
+ ****************************************************************************/
 
 void free(FAR void *mem)
 {
diff --git a/nuttx/mm/mm_initialize.c b/nuttx/mm/mm_initialize.c
index 351948c2f..3a21d1759 100644
--- a/nuttx/mm/mm_initialize.c
+++ b/nuttx/mm/mm_initialize.c
@@ -2,7 +2,7 @@
  * mm/mm_initialize.c
  *
  *   Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -61,9 +61,9 @@ FAR struct mm_allocnode_s *g_heapend[CONFIG_MM_REGIONS];
 int g_nregions;
 #endif
 
-/* All free nodes are maintained in a doubly linked list.  This
- * array provides some hooks into the list at various points to
- * speed searches for free nodes.
+/* All free nodes are maintained in a doubly linked list.  This array
+ * provides some hooks into the list at various points to speed searches for
+ * free nodes.
  */
 
 FAR struct mm_freenode_s g_nodelist[MM_NNODES];
@@ -73,11 +73,10 @@ FAR struct mm_freenode_s g_nodelist[MM_NNODES];
  ****************************************************************************/
 
 /****************************************************************************
- * Function:  mm_initialize
+ * Name: mm_initialize
  *
  * Description:
- *   This is an internal OS function called only at power-up
- *   boot time.
+ *   This is an internal OS function called only at power-up boot time.
  *
  * Parameters:
  *   heapstart - Start of the initial heap region
@@ -135,11 +134,10 @@ void mm_initialize(FAR void *heapstart, size_t heapsize)
 }
 
 /****************************************************************************
- * Function:  mm_addregion
+ * Name: mm_addregion
  *
  * Description:
- *   This function gives a region of contiguous memory to
- *   the memory manager
+ *   This function gives a region of contiguous memory to the memory manager
  *
  * Parameters:
  *   heapstart - Start of the heap region
@@ -163,17 +161,17 @@ void mm_addregion(FAR void *heapstart, size_t heapsize)
 # define IDX 0
 #endif
 
-  /* If the MCU handles wide addresses but the memory manager
-   * is configured for a small heap, then verify that the caller
-   * not doing something crazy.
+  /* If the MCU handles wide addresses but the memory manager is configured
+   * for a small heap, then verify that the caller is  not doing something
+   * crazy.
    */
 
 #if defined(CONFIG_MM_SMALL) && !defined(CONFIG_SMALL_MEMORY)
   DEBUGASSERT(heapsize <= MMSIZE_MAX+1);
 #endif
 
-  /* Adjust the provide heap start and size so that they are
-   * both aligned with the MM_MIN_CHUNK size.
+  /* Adjust the provide heap start and size so that they are both aligned
+   * with the MM_MIN_CHUNK size.
    */
 
   heapbase = MM_ALIGN_UP((uintptr_t)heapstart);
diff --git a/nuttx/mm/mm_internal.h b/nuttx/mm/mm_internal.h
index 4fb2d1778..21cf253d7 100644
--- a/nuttx/mm/mm_internal.h
+++ b/nuttx/mm/mm_internal.h
@@ -1,8 +1,8 @@
-/************************************************************************
+/****************************************************************************
  * mm/mm_internal.h
  *
  *   Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,19 +31,19 @@
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
- ************************************************************************/
+ ****************************************************************************/
 
 #ifndef __MM_MM_INTERNAL_H
 #define __MM_MM_INTERNAL_H
 
-/************************************************************************
+/****************************************************************************
  * Included Files
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Pre-processor Definitions
- ************************************************************************/
-/* Configuration ********************************************************/
+ ****************************************************************************/
+/* Configuration ************************************************************/
 /* If the MCU has a small (16-bit) address capability, then we will use
  * a smaller chunk header that contains 16-bit size/offset information.
  * We will also use the smaller header on MCUs with wider addresses if
@@ -60,7 +60,7 @@
 #  define CONFIG_MM_SMALL 1
 #endif
 
-/* Chunk Header Definitions *********************************************/
+/* Chunk Header Definitions *************************************************/
 /* These definitions define the characteristics of allocator
  *
  * MM_MIN_SHIFT is used to define MM_MIN_CHUNK.
@@ -79,11 +79,11 @@
  */
 
 #ifdef CONFIG_MM_SMALL
-# define MM_MIN_SHIFT      4  /* 16 bytes */
-# define MM_MAX_SHIFT     15  /* 32 Kb */
+#  define MM_MIN_SHIFT    4  /* 16 bytes */
+#  define MM_MAX_SHIFT   15  /* 32 Kb */
 #else
-# define MM_MIN_SHIFT      4  /* 16 bytes */
-# define MM_MAX_SHIFT     22  /*  4 Mb */
+#  define MM_MIN_SHIFT    4  /* 16 bytes */
+#  define MM_MAX_SHIFT   22  /*  4 Mb */
 #endif
 
 /* All other definitions derive from these two */
@@ -109,9 +109,9 @@
 #define MM_IS_ALLOCATED(n) \
   ((int)((struct mm_allocnode_s*)(n)->preceding) < 0))
 
-/************************************************************************
+/****************************************************************************
  * Public Types
- ************************************************************************/
+ ****************************************************************************/
 
 /* Determine the size of the chunk size/offset type */
 
@@ -186,9 +186,9 @@ struct mallinfo
 };
 #endif
 
-/************************************************************************
+/****************************************************************************
  * Global Variables
- ************************************************************************/
+ ****************************************************************************/
 
 /* This is the size of the heap provided to mm */
 
@@ -212,35 +212,32 @@ extern int g_nregions;
 
 extern FAR struct mm_freenode_s g_nodelist[MM_NNODES];
 
-/************************************************************************
+/****************************************************************************
  * Public Function Prototypes
- ************************************************************************/
-
-/* Normally defined in malloc.h */
+ ****************************************************************************/
 
 #ifdef MM_TEST
- extern FAR void *mm_malloc(size_t);
- extern void      mm_free(void*);
- extern FAR void *mm_realloc(void*, size_t);
- extern FAR void *mm_memalign(size_t, size_t);
- extern FAR void *mm_zalloc(size_t);
- extern FAR void *mm_calloc(size_t, size_t);
+FAR void  *mm_malloc(size_t);
+void       mm_free(void*);
+FAR void  *mm_realloc(void*, size_t);
+FAR void  *mm_memalign(size_t, size_t);
+FAR void  *mm_zalloc(size_t);
+FAR void  *mm_calloc(size_t, size_t);
 #ifdef CONFIG_CAN_PASS_STRUCTS
- extern struct mallinfo mallinfo(void);
+struct mallinfo mallinfo(void);
 #else
- extern int       mallinfo(struct mallinfo *info);
+int        mallinfo(struct mallinfo *info);
 #endif
 #endif
 
-extern void       mm_shrinkchunk(FAR struct mm_allocnode_s *node,
-                                 size_t size);
-extern void       mm_addfreechunk(FAR struct mm_freenode_s *node);
-extern int        mm_size2ndx(size_t size);
-extern void       mm_seminitialize(void);
-extern void       mm_takesemaphore(void);
-extern void       mm_givesemaphore(void);
+void       mm_shrinkchunk(FAR struct mm_allocnode_s *node, size_t size);
+void       mm_addfreechunk(FAR struct mm_freenode_s *node);
+int        mm_size2ndx(size_t size);
+void       mm_seminitialize(void);
+void       mm_takesemaphore(void);
+void       mm_givesemaphore(void);
 #ifdef MM_TEST
- extern int       mm_getsemaphore(void);
+int        mm_getsemaphore(void);
 #endif
 
 #endif /* __MM_MM_INTERNAL_H */
diff --git a/nuttx/mm/mm_mallinfo.c b/nuttx/mm/mm_mallinfo.c
index a7f6d9df6..b725535d1 100644
--- a/nuttx/mm/mm_mallinfo.c
+++ b/nuttx/mm/mm_mallinfo.c
@@ -2,7 +2,7 @@
  * mm/mm_mallinfo.c
  *
  *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -38,6 +38,7 @@
  ****************************************************************************/
 
 #include <assert.h>
+
 #include "mm_environment.h"
 #include "mm_internal.h"
 
@@ -58,7 +59,7 @@
  ****************************************************************************/
 
 /****************************************************************************
- * mallinfo
+ * Name: mallinfo
  *
  * Description:
  *   mallinfo returns a copy of updated current mallinfo.
diff --git a/nuttx/mm/mm_malloc.c b/nuttx/mm/mm_malloc.c
index dbcba33a8..8a21e7324 100644
--- a/nuttx/mm/mm_malloc.c
+++ b/nuttx/mm/mm_malloc.c
@@ -1,8 +1,8 @@
-/************************************************************
+/****************************************************************************
  * mm/mm_malloc.c
  *
  *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,59 +31,59 @@
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
- ************************************************************/
+ ****************************************************************************/
 
-/************************************************************
+/****************************************************************************
  * Included Files
- ************************************************************/
+ ****************************************************************************/
 
-/* Special definitions when we operate in the normal vs. the
- * host-pc test environement.
+/* Special definitions when we operate in the normal vs. the host-pc test
+ * environement.
  */
 
 #include <assert.h>
+
 #include "mm_environment.h"
 #include "mm_internal.h"
 
-/************************************************************
+/****************************************************************************
  * Pre-processor Definitions
- ************************************************************/
+ ****************************************************************************/
 
 #ifndef NULL
 #  define NULL ((void*)0)
 #endif
 
-/************************************************************
+/****************************************************************************
  * Type Definitions
- ************************************************************/
+ ****************************************************************************/
 
-/************************************************************
+/****************************************************************************
  * Private Data
- ************************************************************/
+ ****************************************************************************/
 
-/************************************************************
+/****************************************************************************
  * Public Data
- ************************************************************/
+ ****************************************************************************/
 
-/************************************************************
+/****************************************************************************
  * Private Functions
- ************************************************************/
+ ****************************************************************************/
 
-/************************************************************
+/****************************************************************************
  * Public Functions
- ************************************************************/
+ ****************************************************************************/
 
-/************************************************************
- * malloc
+/****************************************************************************
+ * Name: malloc
  *
  * Description:
- *  Find the smallest chunk that satisfies the request.
- *  Take the memory from that chunk, save the remaining,
- *  smaller chunk (if any).
+ *  Find the smallest chunk that satisfies the request. Take the memory from
+ *  that chunk, save the remaining, smaller chunk (if any).
  *
  *  8-byte alignment of the allocated data is assured.
  *
- ************************************************************/
+ ****************************************************************************/
 
 FAR void *malloc(size_t size)
 {
@@ -98,21 +98,18 @@ FAR void *malloc(size_t size)
       return NULL;
     }
 
-  /* Adjust the size to account for (1) the size of the allocated
-   * node and (2) to make sure that it is an even multiple of
-   * our granule size.
+  /* Adjust the size to account for (1) the size of the allocated node and
+   * (2) to make sure that it is an even multiple of our granule size.
    */
 
   size = MM_ALIGN_UP(size + SIZEOF_MM_ALLOCNODE);
 
-  /* We need to hold the MM semaphore while we muck with the
-   * nodelist.
-   */
+  /* We need to hold the MM semaphore while we muck with the nodelist. */
 
   mm_takesemaphore();
 
-  /* Get the location in the node list to start the search.
-   * Special case really big alloctions
+  /* Get the location in the node list to start the search. Special case
+   * really big allocations
    */
 
   if (size >= MM_MAX_CHUNK)
@@ -126,18 +123,18 @@ FAR void *malloc(size_t size)
       ndx = mm_size2ndx(size);
     }
 
-  /* Search for a large enough chunk in the list of nodes.
-   * This list is ordered by size, but will have occasional
-   * zero sized nodes as we visit other g_nodelist[] entries.
+  /* Search for a large enough chunk in the list of nodes. This list is
+   * ordered by size, but will have occasional zero sized nodes as we visit
+   * other g_nodelist[] entries.
    */
 
   for (node = g_nodelist[ndx].flink;
        node && node->size < size;
        node = node->flink);
 
-  /* If we found a node with non-zero size, then this is one
-   * to use. Since the list is ordered, we know that is must be
-   * best fitting chunk available.
+  /* If we found a node with non-zero size, then this is one to use. Since
+   * the list is ordered, we know that is must be best fitting chunk
+   * available.
    */
 
   if (node)
@@ -146,8 +143,8 @@ FAR void *malloc(size_t size)
       FAR struct mm_freenode_s *next;
       size_t remaining;
 
-      /* Remove the node.  There must be a predecessor, but there may
-       * not be a successor node.
+      /* Remove the node.  There must be a predecessor, but there may not be
+       * a successor node.
        */
 
       DEBUGASSERT(node->blink);
@@ -157,11 +154,11 @@ FAR void *malloc(size_t size)
           node->flink->blink = node->blink;
         }
 
-      /* Check if we have to split the free node into one of the
-       * allocated size and another smaller freenode.  In some
-       * cases, the remaining bytes can be smaller (they may be
-       * SIZEOF_MM_ALLOCNODE).  In that case, we will just carry
-       * the few wasted bytes at the end of the allocation.
+      /* Check if we have to split the free node into one of the allocated
+       * size and another smaller freenode.  In some cases, the remaining
+       * bytes can be smaller (they may be SIZEOF_MM_ALLOCNODE).  In that
+       * case, we will just carry the few wasted bytes at the end of the
+       * allocation.
        */
 
       remaining = node->size - size;
@@ -181,8 +178,8 @@ FAR void *malloc(size_t size)
 
           node->size = size;
 
-          /* Adjust the 'preceding' size of the (old) next node,
-           * preserving the allocated flag.
+          /* Adjust the 'preceding' size of the (old) next node, preserving
+           * the allocated flag.
            */
 
           next->preceding = remaining | (next->preceding & MM_ALLOC_BIT);
diff --git a/nuttx/mm/mm_memalign.c b/nuttx/mm/mm_memalign.c
index d40f72348..87547c96b 100644
--- a/nuttx/mm/mm_memalign.c
+++ b/nuttx/mm/mm_memalign.c
@@ -1,8 +1,8 @@
-/************************************************************
+/****************************************************************************
  * mm/mm_memalign.c
  *
  *   Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,37 +31,37 @@
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
- ************************************************************/
+ ****************************************************************************/
 
-/************************************************************
+/****************************************************************************
  * Included Files
- ************************************************************/
+ ****************************************************************************/
 
 #include <assert.h>
+
 #include "mm_environment.h"
 #include "mm_internal.h"
 
-/************************************************************
+/****************************************************************************
  * Pre-processor Definitions
- ************************************************************/
+ ****************************************************************************/
 
-/************************************************************
+/****************************************************************************
  * Global Functions
- ************************************************************/
+ ****************************************************************************/
 
-/************************************************************
- * memalign
+/****************************************************************************
+ * Name: memalign
  *
  * Description:
- *   memalign requests more than enough space from malloc,
- *   finds a region within that chunk that meets the alignment
- *   request and then frees any leading or trailing space. 
+ *   memalign requests more than enough space from malloc, finds a region
+ *   within that chunk that meets the alignment request and then frees any
+ *   leading or trailing space. 
  *
- *   The alignment argument must be a power of two (not
- *   checked).  8-byte alignment is guaranteed by normal
- *   malloc calls.
+ *   The alignment argument must be a power of two (not checked).  8-byte
+ *   alignment is guaranteed by normal malloc calls.
  *
- ************************************************************/
+ ****************************************************************************/
 
 FAR void *memalign(size_t alignment, size_t size)
 {
@@ -71,9 +71,8 @@ FAR void *memalign(size_t alignment, size_t size)
   size_t mask = (size_t)(alignment - 1);
   size_t allocsize;
 
-  /* If this requested alignement less than or equal to the
-   * natural alignment of malloc, then just let malloc do the
-   * work.
+  /* If this requested alignement less than or equal to the natural alignment
+   * of malloc, then just let malloc do the work.
    */
 
   if (alignment <= MM_MIN_CHUNK)
@@ -81,17 +80,16 @@ FAR void *memalign(size_t alignment, size_t size)
       return malloc(size);
     }
 
-  /* Adjust the size to account for (1) the size of the allocated
-   * node, (2) to make sure that it is an even multiple of
-   * our granule size, and to include the alignment amount.
+  /* Adjust the size to account for (1) the size of the allocated node, (2)
+   * to make sure that it is an even multiple of our granule size, and to
+   * include the alignment amount.
    *
-   * Notice that we increase the allocation size by twice the
-   * the requested alignment.  We do this so that there will
-   * be at least two valid alignment points within the allocated
-   * memory.
+   * Notice that we increase the allocation size by twice the requested
+   * alignment.  We do this so that there will be at least two valid
+   * alignment points within the allocated memory.
    *
-   * NOTE:  These are sizes given to malloc and not chunk sizes.
-   * The do not include SIZEOF_MM_ALLOCNODE.
+   * NOTE:  These are sizes given to malloc and not chunk sizes. They do
+   * not include SIZEOF_MM_ALLOCNODE.
    */
 
   size      = MM_ALIGN_UP(size);   /* Make multiples of our granule size */
@@ -105,14 +103,14 @@ FAR void *memalign(size_t alignment, size_t size)
       return NULL;
     }
 
-  /* We need to hold the MM semaphore while we muck with the
-   * chunks and nodelist.
+  /* We need to hold the MM semaphore while we muck with the chunks and
+   * nodelist.
    */
 
   mm_takesemaphore();
 
-  /* Get the node associated with the allocation and the next
-   * node after the allocation.
+  /* Get the node associated with the allocation and the next node after
+   * the allocation.
    */
 
   node = (FAR struct mm_allocnode_s*)(rawchunk - SIZEOF_MM_ALLOCNODE);
@@ -147,12 +145,12 @@ FAR void *memalign(size_t alignment, size_t size)
 
       precedingsize = (size_t)newnode - (size_t)node;
 
-      /* If we were unlucky, then the alignedchunk can lie in such
-       * a position that precedingsize < SIZEOF_NODE_FREENODE.  We 
-       * can't let that happen because we are going to cast 'node' to
-       * struct mm_freenode_s below.  This is why we allocated memory
-       * large enough to support two alignment points.  In this case,
-       * we will simply use the second alignment point.
+      /* If we were unlucky, then the alignedchunk can lie in such a position
+       * that precedingsize < SIZEOF_NODE_FREENODE.  We can't let that happen
+       * because we are going to cast 'node' to struct mm_freenode_s below.
+       * This is why we allocated memory large enough to support two
+       * alignment points.  In this case, we will simply use the second
+       * alignment point.
        */
 
       if (precedingsize < SIZEOF_MM_FREENODE)
@@ -176,8 +174,8 @@ FAR void *memalign(size_t alignment, size_t size)
 
       next->preceding = newnode->size | (next->preceding & MM_ALLOC_BIT);
 
-      /* Convert the newnode chunk size back into malloc-compatible
-       * size by subtracting the header size SIZEOF_MM_ALLOCNODE.
+      /* Convert the newnode chunk size back into malloc-compatible size by
+       * subtracting the header size SIZEOF_MM_ALLOCNODE.
        */
 
       allocsize = newnode->size - SIZEOF_MM_ALLOCNODE;
@@ -197,9 +195,9 @@ FAR void *memalign(size_t alignment, size_t size)
 
   if (allocsize > size)
     {
-      /* Shrink the chunk by that much -- remember, mm_shrinkchunk
-       * wants internal chunk sizes that include SIZEOF_MM_ALLOCNODE,
-       * and not the malloc-compatible sizes that we have.
+      /* Shrink the chunk by that much -- remember, mm_shrinkchunk wants
+       * internal chunk sizes that include SIZEOF_MM_ALLOCNODE, and not the
+       * malloc-compatible sizes that we have.
        */
 
       mm_shrinkchunk(node, size + SIZEOF_MM_ALLOCNODE);
diff --git a/nuttx/mm/mm_realloc.c b/nuttx/mm/mm_realloc.c
index d97bf53a5..b44938995 100644
--- a/nuttx/mm/mm_realloc.c
+++ b/nuttx/mm/mm_realloc.c
@@ -1,8 +1,8 @@
-/************************************************************
+/****************************************************************************
  * mm/mm_realloc.c
  *
  *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,47 +31,47 @@
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
- ************************************************************/
+ ****************************************************************************/
 
-/************************************************************
+/****************************************************************************
  * Included Files
- ************************************************************/
+ ****************************************************************************/
 
 #include <string.h>
 #include "mm_environment.h"
-#include <stdio.h> /* For NULL */
+#include <stdio.h>
 #include "mm_internal.h"
 
-/************************************************************
+/****************************************************************************
  * Pre-processor Definitions
- ************************************************************/
+ ****************************************************************************/
 
-/************************************************************
+/****************************************************************************
  * Global Functions
- ************************************************************/
+ ****************************************************************************/
 
-/************************************************************
- * realloc
+/****************************************************************************
+ * Name: realloc
  *
  * Description:
  *   If the reallocation is for less space, then:
+ *
  *     (1) the current allocation is reduced in size
- *     (2) the remainder at the end of the allocation is
- *         returned to the free list.
+ *     (2) the remainder at the end of the allocation is returned to the
+ *         free list.
+ *
+ *  If the request is for more space and the current allocation can be
+ *  extended, it will be extended by:
  *
- *  If the request is for more space and the current
- *  allocation can be extended, it will be extended by:
- *     (1) Taking the additional space from the following
- *         free chunk, or
- *     (2) Taking the additional space from the preceding
- *         free chunk.
+ *     (1) Taking the additional space from the following free chunk, or
+ *     (2) Taking the additional space from the preceding free chunk.
  *     (3) Or both
  *
- *  If the request is for more space but the current chunk
- *  cannot be extended, then malloc a new buffer, copy the
- *  data into the new buffer, and free the old buffer.
+ *  If the request is for more space but the current chunk cannot be
+ *  extended, then malloc a new buffer, copy the data into the new buffer,
+ *  and free the old buffer.
  *
- ************************************************************/
+ ****************************************************************************/
 
 FAR void *realloc(FAR void *oldmem, size_t size)
 {
@@ -98,9 +98,8 @@ FAR void *realloc(FAR void *oldmem, size_t size)
       return NULL;
     }
 
-  /* Adjust the size to account for (1) the size of the allocated
-   * node and (2) to make sure that it is an even multiple of
-   * our granule size.
+  /* Adjust the size to account for (1) the size of the allocated node and
+   * (2) to make sure that it is an even multiple of our granule size.
    */
 
   size = MM_ALIGN_UP(size + SIZEOF_MM_ALLOCNODE);
@@ -109,9 +108,7 @@ FAR void *realloc(FAR void *oldmem, size_t size)
 
   oldnode = (FAR struct mm_allocnode_s *)((FAR char*)oldmem - SIZEOF_MM_ALLOCNODE);
 
-  /* We need to hold the MM semaphore while we muck with the
-   * nodelist.
-   */
+  /* We need to hold the MM semaphore while we muck with the nodelist. */
 
   mm_takesemaphore();
 
@@ -120,13 +117,14 @@ FAR void *realloc(FAR void *oldmem, size_t size)
   oldsize = oldnode->size;
   if (size <= oldsize)
     {
-      /* Handle the special case where we are not going to change the
-       * size of the allocation.
+      /* Handle the special case where we are not going to change the size
+       * of the allocation.
        */
+
       if (size < oldsize)
         {
           mm_shrinkchunk(oldnode, size);
-      }
+        }
 
       /* Then return the original address */
 
@@ -135,8 +133,8 @@ FAR void *realloc(FAR void *oldmem, size_t size)
     }
 
   /* This is a request to increase the size of the allocation,  Get the
-   * available sizes before and after the oldnode so that we can make
-   * the best decision
+   * available sizes before and after the oldnode so that we can make the
+   * best decision
    */
 
   next = (FAR struct mm_freenode_s *)((FAR char*)oldnode + oldnode->size);
@@ -165,52 +163,52 @@ FAR void *realloc(FAR void *oldmem, size_t size)
 
       if (prevsize > 0 && (nextsize >= prevsize || nextsize <= 0))
         {
-           /* Can we get everything we need from the previous chunk? */
-
-           if (needed > prevsize)
-             {
-               /* No, take the whole previous chunk and get the
-                * rest that we need from the next chunk.
-                */
-
-               takeprev = prevsize;
-               takenext = needed - prevsize;
-             }
-           else
-             {
-               /* Yes, take what we need from the previous chunk */
-
-               takeprev = needed;
-               takenext = 0;
-             }
-
-           needed = 0;
-         }
-
-      /* Check if we can extend into the next chunk and if we still
-       * need more memory.
+          /* Can we get everything we need from the previous chunk? */
+
+          if (needed > prevsize)
+            {
+              /* No, take the whole previous chunk and get the
+               * rest that we need from the next chunk.
+               */
+
+              takeprev = prevsize;
+              takenext = needed - prevsize;
+            }
+          else
+            {
+              /* Yes, take what we need from the previous chunk */
+
+              takeprev = needed;
+              takenext = 0;
+            }
+
+          needed = 0;
+        }
+
+      /* Check if we can extend into the next chunk and if we still need
+       * more memory.
        */
 
       if (nextsize > 0 && needed)
         {
-           /* Can we get everything we need from the next chunk? */
-
-           if (needed > nextsize)
-             {
-               /* No, take the whole next chunk and get the
-                * rest that we need from the previous chunk.
-                */
-
-               takeprev = needed - nextsize;
-               takenext = nextsize;
-             }
-           else
-             {
-               /* Yes, take what we need from the previous chunk */
-
-               takeprev = 0;
-               takenext = needed;
-             }
+          /* Can we get everything we need from the next chunk? */
+
+          if (needed > nextsize)
+            {
+              /* No, take the whole next chunk and get the rest that we
+               * need from the previous chunk.
+               */
+
+              takeprev = needed - nextsize;
+              takenext = nextsize;
+            }
+          else
+            {
+              /* Yes, take what we need from the previous chunk */
+
+              takeprev = 0;
+              takenext = needed;
+            }
         }
 
       /* Extend into the previous free chunk */
@@ -218,55 +216,55 @@ FAR void *realloc(FAR void *oldmem, size_t size)
       newmem = oldmem;
       if (takeprev)
         {
-           FAR struct mm_allocnode_s *newnode;
+          FAR struct mm_allocnode_s *newnode;
 
-           /* Remove the previous node.  There must be a predecessor,
-            * but there may not be a successor node.
-            */
+          /* Remove the previous node.  There must be a predecessor, but
+           * there may not be a successor node.
+           */
 
-           DEBUGASSERT(prev->blink);
-           prev->blink->flink = prev->flink;
-           if (prev->flink)
-             {
-               prev->flink->blink = prev->blink;
-             }
+          DEBUGASSERT(prev->blink);
+          prev->blink->flink = prev->flink;
+          if (prev->flink)
+            {
+              prev->flink->blink = prev->blink;
+            }
 
-           /* Extend the node into the previous free chunk */
+          /* Extend the node into the previous free chunk */
 
-           newnode = (FAR struct mm_allocnode_s *)((FAR char*)oldnode - takeprev);
+          newnode = (FAR struct mm_allocnode_s *)((FAR char*)oldnode - takeprev);
 
-           /* Did we consume the entire preceding chunk? */
+          /* Did we consume the entire preceding chunk? */
 
-           if (takeprev < prevsize)
-             {
-               /* No.. just take what we need from the previous chunk
-                * and put it back into the free list
-                */
+          if (takeprev < prevsize)
+            {
+              /* No.. just take what we need from the previous chunk and put
+               * it back into the free list
+               */
 
-               prev->size        -= takeprev;
-               newnode->size      = oldsize + takeprev;
-               newnode->preceding = prev->size | MM_ALLOC_BIT;
-               next->preceding    = newnode->size | (next->preceding & MM_ALLOC_BIT);
+              prev->size        -= takeprev;
+              newnode->size      = oldsize + takeprev;
+              newnode->preceding = prev->size | MM_ALLOC_BIT;
+              next->preceding    = newnode->size | (next->preceding & MM_ALLOC_BIT);
 
-               /* Return the previous free node to the nodelist (with the new size) */
+              /* Return the previous free node to the nodelist (with the new size) */
 
-               mm_addfreechunk(prev);
+              mm_addfreechunk(prev);
 
-              /* Now we want to return newnode */
+             /* Now we want to return newnode */
 
-               oldnode = newnode;
-             }
-           else
-             {
-                /* Yes.. update its size (newnode->preceding is already set) */
+              oldnode = newnode;
+            }
+          else
+            {
+              /* Yes.. update its size (newnode->preceding is already set) */
 
-               newnode->size      += oldsize;
-               newnode->preceding |= MM_ALLOC_BIT;
-               next->preceding     = newnode->size | (next->preceding & MM_ALLOC_BIT);
-             }
+              newnode->size      += oldsize;
+              newnode->preceding |= MM_ALLOC_BIT;
+              next->preceding     = newnode->size | (next->preceding & MM_ALLOC_BIT);
+            }
 
-           oldnode = newnode;
-           oldsize = newnode->size;
+          oldnode = newnode;
+          oldsize = newnode->size;
 
           /* Now we have to move the user contents 'down' in memory.  memcpy should
            * should be save for this.
@@ -283,12 +281,14 @@ FAR void *realloc(FAR void *oldmem, size_t size)
           FAR struct mm_freenode_s *newnode;
           FAR struct mm_allocnode_s *andbeyond;
 
-          /* Get the chunk following the next node (which could be the tail chunk) */
+          /* Get the chunk following the next node (which could be the tail
+           * chunk)
+           */
 
           andbeyond = (FAR struct mm_allocnode_s*)((char*)next + nextsize);
 
-          /* Remove the next node.  There must be a predecessor,
-           * but there may not be a successor node.
+          /* Remove the next node.  There must be a predecessor, but there
+           * may not be a successor node.
            */
 
           DEBUGASSERT(next->blink);
@@ -307,8 +307,8 @@ FAR void *realloc(FAR void *oldmem, size_t size)
 
           if (takenext < nextsize)
             {
-              /* No, take what we need from the next chunk and return it
-               * to the free nodelist.
+              /* No, take what we need from the next chunk and return it to
+               * the free nodelist.
                */
 
               newnode->size        = nextsize - takenext;
@@ -335,20 +335,18 @@ FAR void *realloc(FAR void *oldmem, size_t size)
 
   else
     {
-       /* Allocate a new block.  On failure, realloc must return NULL but
-        * leave the original memory in place.
-        */
-
-       mm_givesemaphore();
-       newmem = (FAR void*)malloc(size);
-       if (newmem)
-         {
-           memcpy(newmem, oldmem, oldsize);
-           free(oldmem);
-         }
-
-       return newmem;
-    }
+      /* Allocate a new block.  On failure, realloc must return NULL but
+       * leave the original memory in place.
+       */
 
-}
+      mm_givesemaphore();
+      newmem = (FAR void*)malloc(size);
+      if (newmem)
+        {
+          memcpy(newmem, oldmem, oldsize);
+          free(oldmem);
+        }
 
+      return newmem;
+    }
+}
diff --git a/nuttx/mm/mm_sem.c b/nuttx/mm/mm_sem.c
index a2d9d5cd1..19fff780b 100644
--- a/nuttx/mm/mm_sem.c
+++ b/nuttx/mm/mm_sem.c
@@ -38,10 +38,12 @@
  ****************************************************************************/
 
 #include "mm_environment.h"
+
 #include <unistd.h>
 #include <semaphore.h>
 #include <errno.h>
 #include <assert.h>
+
 #include "mm_internal.h"
 
 /****************************************************************************
@@ -73,9 +75,9 @@
 /* Mutually exclusive access to this data set is enforced with
  * the following (un-named) semaphore. */
 
-static  sem_t g_mm_semaphore;
-static  pid_t g_holder;
-static  int   g_counts_held;
+static sem_t g_mm_semaphore;
+static pid_t g_holder;
+static int   g_counts_held;
 
 /****************************************************************************
  * Public Functions
@@ -91,8 +93,8 @@ static  int   g_counts_held;
 
 void mm_seminitialize(void)
 {
-  /* Initialize the MM semaphore to one (to support one-at-
-   * a-time access to private data sets.
+  /* Initialize the MM semaphore to one (to support one-at-a-time access to
+   * private data sets.
    */
 
   (void)sem_init(&g_mm_semaphore, 0, 1);
@@ -105,11 +107,10 @@ void mm_seminitialize(void)
  * Name: mm_trysemaphore
  *
  * Description:
- *   Try to take the MM mutex.  This is called only from the
- *   OS in certain conditions when it is necessary to have
- *   exclusive access to the memory manager but it is
- *   impossible to wait on a semaphore (e.g., the idle process
- *   when it performs its background memory cleanup).
+ *   Try to take the MM mutex.  This is called only from the OS in certain
+ *   conditions when it is necessary to have exclusive access to the memory
+ *   manager but it is impossible to wait on a semaphore (e.g., the idle
+ *   process when it performs its background memory cleanup).
  *
  ****************************************************************************/
 
@@ -149,8 +150,8 @@ int mm_trysemaphore(void)
  * Name: mm_takesemaphore
  *
  * Description:
- *   Take the MM mutex.  This is the normal action before all
- *   memory management actions.
+ *   Take the MM mutex.  This is the normal action before all memory
+ *   management actions.
  *
  ****************************************************************************/
 
@@ -172,13 +173,13 @@ void mm_takesemaphore(void)
 
       msemdbg("PID=%d taking\n", my_pid);
       while (sem_wait(&g_mm_semaphore) != 0)
-       {
-         /* The only case that an error should occur here is if
-          * the wait was awakened by a signal.
-          */
+        {
+          /* The only case that an error should occur here is if
+           * the wait was awakened by a signal.
+           */
 
-         ASSERT(mm_errno == EINTR);
-       }
+          ASSERT(mm_errno == EINTR);
+        }
 
       /* We have it.  Claim the stake and return */
 
@@ -186,8 +187,7 @@ void mm_takesemaphore(void)
       g_counts_held = 1;
     }
 
-  msemdbg("Holder=%d count=%d\n",
-          g_holder, g_counts_held);
+  msemdbg("Holder=%d count=%d\n", g_holder, g_counts_held);
 }
 
 /****************************************************************************
@@ -215,8 +215,7 @@ void mm_givesemaphore(void)
       /* Yes, just release one count and return */
 
       g_counts_held--;
-      msemdbg("Holder=%d count=%d\n",
-              g_holder, g_counts_held);
+      msemdbg("Holder=%d count=%d\n", g_holder, g_counts_held);
     }
   else
     {
@@ -233,8 +232,7 @@ void mm_givesemaphore(void)
  * Name: mm_getsemaphore
  *
  * Description:
- *   Return the current value of the MM semaphore (for test
- *   purposes only)
+ *   Return the current value of the MM semaphore (for test purposes only)
  *
  ****************************************************************************/
 
diff --git a/nuttx/mm/mm_shrinkchunk.c b/nuttx/mm/mm_shrinkchunk.c
index 9361a4f8b..e538e43ed 100644
--- a/nuttx/mm/mm_shrinkchunk.c
+++ b/nuttx/mm/mm_shrinkchunk.c
@@ -1,8 +1,8 @@
-/************************************************************************
+/****************************************************************************
  * mm/mm_shrinkchunk.c
  *
  *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,38 +31,37 @@
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Included Files
- ************************************************************************/
+ ****************************************************************************/
 
 #include "mm_environment.h"
 #include "mm_internal.h"
 
-/************************************************************************
+/****************************************************************************
  * Pre-processor Definitions
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Global Functions
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
- * mm_shrinkchunk
+/****************************************************************************
+ * Name: mm_shrinkchunk
  *
  * Description:
- *   Reduce the size of the chunk specified by the node
- *   structure to the specified size.  this internal logic
- *   is used both from memalign to dispose of any trailing
- *   memory in the aligned allocation and also by realloc
- *   when there is a request to reduce the size of an allocation.
+ *   Reduce the size of the chunk specified by the node structure to the
+ *   specified size.  this internal logic is used both from memalign to
+ *   dispose of any trailing memory in the aligned allocation and also by
+ *   realloc when there is a request to reduce the size of an allocation.
  *
  *   NOTES:
  *     (1) size is the whole chunk size (payload and header)
  *     (2) the caller must hold the MM semaphore.
  *
- ************************************************************************/
+ ****************************************************************************/
 
 void  mm_shrinkchunk(FAR struct mm_allocnode_s *node, size_t size)
 {
@@ -94,8 +93,8 @@ void  mm_shrinkchunk(FAR struct mm_allocnode_s *node, size_t size)
           next->flink->blink = next->blink;
         }
 
-      /* Create a new chunk that will hold both the next chunk
-       * and the tailing memory from the aligned chunk.
+      /* Create a new chunk that will hold both the next chunk and the
+       * tailing memory from the aligned chunk.
        */
 
       newnode = (FAR struct mm_freenode_s*)((char*)node + size);
@@ -112,16 +111,16 @@ void  mm_shrinkchunk(FAR struct mm_allocnode_s *node, size_t size)
       mm_addfreechunk(newnode);
     }
 
-  /* The next chunk is allocated.  Try to free the end portion
-   * at the end chunk to be shrunk.
+  /* The next chunk is allocated.  Try to free the end portion at the end
+   * chunk to be shrunk.
    */
 
   else if (node->size >= size + SIZEOF_MM_FREENODE)
     {
       FAR struct mm_freenode_s *newnode;
 
-      /* Create a new chunk that will hold both the next chunk
-       * and the tailing memory from the aligned chunk.
+      /* Create a new chunk that will hold both the next chunk and the
+       * tailing memory from the aligned chunk.
        */
 
       newnode = (FAR struct mm_freenode_s*)((char*)node + size);
diff --git a/nuttx/mm/mm_size2ndx.c b/nuttx/mm/mm_size2ndx.c
index 492dd8ba0..b2a0a8e14 100644
--- a/nuttx/mm/mm_size2ndx.c
+++ b/nuttx/mm/mm_size2ndx.c
@@ -1,8 +1,8 @@
-/************************************************************************
+/****************************************************************************
  * mm/mm_size2ndx.c
  *
  *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,24 +31,30 @@
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Included Files
- ************************************************************************/
+ ****************************************************************************/
 
 #include "mm_environment.h"
 #include "mm_internal.h"
 
-/************************************************************************
+/****************************************************************************
  * Pre-processor Definitions
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Public Functions
- ************************************************************************/
+ ****************************************************************************/
 
-/* Convert the size to a nodelist index */
+/****************************************************************************
+ * Name: mm_size2ndx
+ *
+ * Description:
+ *    Convert the size to a nodelist index.
+ *
+ ****************************************************************************/
 
 int mm_size2ndx(size_t size)
 {
diff --git a/nuttx/mm/mm_test.c b/nuttx/mm/mm_test.c
index e7a44dec7..b25a24095 100644
--- a/nuttx/mm/mm_test.c
+++ b/nuttx/mm/mm_test.c
@@ -2,7 +2,7 @@
  * mm/mm_test.c
  *
  *   Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -33,10 +33,18 @@
  *
  ************************************************************************/
 
+/************************************************************************
+ * Included Files
+ ************************************************************************/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+/************************************************************************
+ * Pre-processor Definitions
+ ************************************************************************/
+
 /* Fake NuttX dependencies */
 
 #define FAR
@@ -56,6 +64,10 @@
 /* #define STOP_ON_ERRORS do{}while(0) */
 #define STOP_ON_ERRORS exit(1)
 
+/************************************************************************
+ * Private Data
+ ************************************************************************/
+
 /* Test allocations */
 
 static const int   alloc_sizes[NTEST_ALLOCS] =
@@ -65,6 +77,7 @@ static const int   alloc_sizes[NTEST_ALLOCS] =
   4732,     28,    901,    480,  5011,  1536,   2011,  81647,
    646,   1646,  69179,    194,  2590,     7,    969,     70
 };
+
 static const int   realloc_sizes[NTEST_ALLOCS] =
 {
     18,   3088,    963,    123,   511, 11666,   3723,     42,
@@ -72,6 +85,7 @@ static const int   realloc_sizes[NTEST_ALLOCS] =
   8663,  91255,     28,   4346,  9172,   168,    229,   4734,
  59139,    221,   7830,  30421,  1666,     4,    812,    416
 };
+
 static const int random1[NTEST_ALLOCS] =
 {
     20,     11,      3,     31,     9,    29,      7,     17,
@@ -79,6 +93,7 @@ static const int random1[NTEST_ALLOCS] =
     27,     19,     22,     28,     8,    30,     12,     15,
      4,      1,     24,      6,    16,    13,      5,     23
 };
+
 static const int random2[NTEST_ALLOCS] =
 {
      2,     19,     12,     23,    30,    11,     27,      4,
@@ -86,6 +101,7 @@ static const int random2[NTEST_ALLOCS] =
     10,     17,     25,     31,     8,    29,      3,     26,
      9,     18,     22,     13,     1,    21,     14,      6
 };
+
 static const int random3[NTEST_ALLOCS] =
 {
     8,      17,      3,     18,     26,   23,     30,     11,
@@ -93,18 +109,24 @@ static const int random3[NTEST_ALLOCS] =
     29,     14,     19,     21,      0,   31,      7,     24,
      9,     15,      2,     28,     16,    6,     13,      5
 };
+
 static const int alignment[NTEST_ALLOCS/2] =
 {
     128,  2048, 131072,   8192,    32,  32768, 16384 , 262144,
     512,  4096,  65536,      8,     64,  1024,    16,       4
 };
+
 static void        *allocs[NTEST_ALLOCS];
 static struct       mallinfo alloc_info;
 static unsigned int g_reportedheapsize = 0;
 static unsigned int g_actualheapsize = 0;
 
 /************************************************************************
- * mm_showchunkinfo
+ * Private Functions
+ ************************************************************************/
+
+/************************************************************************
+ * Name: mm_findinfreelist
  ************************************************************************/
 
 static int mm_findinfreelist(struct mm_freenode_s *node)
@@ -120,9 +142,14 @@ static int mm_findinfreelist(struct mm_freenode_s *node)
           return 1;
         }
     }
+
   return 0;
 }
 
+/************************************************************************
+ * Name: mm_showchunkinfo
+ ************************************************************************/
+
 static void mm_showchunkinfo(void)
 {
   struct mm_allocnode_s *node;
@@ -146,8 +173,8 @@ static void mm_showchunkinfo(void)
       for (node = g_heapstart[region];
            node < g_heapend[region];
            node = (struct mm_allocnode_s *)((char*)node + node->size))
-         {
-           printf("       %p 0x%08x 0x%08x %s",
+        {
+          printf("       %p 0x%08x 0x%08x %s",
                  node, node->size, node->preceding & ~MM_ALLOC_BIT,
                  node->preceding & MM_ALLOC_BIT ? "Allocated" : "Free     ");
           found = mm_findinfreelist((struct mm_freenode_s *)node);
@@ -168,6 +195,10 @@ static void mm_showchunkinfo(void)
 #undef region
 }
 
+/************************************************************************
+ * Name: mm_showfreelist
+ ************************************************************************/
+
 static void mm_showfreelist(void)
 {
   struct mm_freenode_s *prev;
@@ -204,6 +235,10 @@ static void mm_showfreelist(void)
     }
 }
 
+/************************************************************************
+ * Name: mm_showmallinfo
+ ************************************************************************/
+
 static void mm_showmallinfo(void)
 {
   int sval;
@@ -213,15 +248,15 @@ static void mm_showmallinfo(void)
   alloc_info = mallinfo();
   printf("     mallinfo:\n");
   printf("       Total space allocated from system = %ld\n",
-	 alloc_info.arena);
+         alloc_info.arena);
   printf("       Number of non-inuse chunks        = %ld\n",
-	 alloc_info.ordblks);
+         alloc_info.ordblks);
   printf("       Largest non-inuse chunk           = %ld\n",
-	 alloc_info.mxordblk);
+         alloc_info.mxordblk);
   printf("       Total allocated space             = %ld\n",
-	 alloc_info.uordblks);
+         alloc_info.uordblks);
   printf("       Total non-inuse space             = %ld\n",
-	 alloc_info.fordblks);
+         alloc_info.fordblks);
 
   sval = mm_getsemaphore();
   if (sval != 1)
@@ -249,7 +284,12 @@ static void mm_showmallinfo(void)
     }
 }
 
-static void do_mallocs(void **mem, const int *size, const int *rand, int n)
+/************************************************************************
+ * Name: do_mallocs
+ ************************************************************************/
+
+static void do_mallocs(void **mem, const int *size, const int *rand,
+                       int n)
 {
   int sval;
   int i;
@@ -294,7 +334,12 @@ static void do_mallocs(void **mem, const int *size, const int *rand, int n)
     }
 }
 
-static void do_reallocs(void **mem, const int *oldsize, const int *newsize, const int *rand, int n)
+/************************************************************************
+ * Name: do_reallocs
+ ************************************************************************/
+
+static void do_reallocs(void **mem, const int *oldsize,
+                        const int *newsize, const int *rand, int n)
 {
   int sval;
   int i;
@@ -304,11 +349,11 @@ static void do_reallocs(void **mem, const int *oldsize, const int *newsize, cons
     {
       j = rand[i];
       printf("(%d)Re-allocating at %p from %d to %d bytes\n",
-	     i, mem[j], oldsize[j], newsize[j]);
+             i, mem[j], oldsize[j], newsize[j]);
       mem[j] = mm_realloc(mem[j], newsize[j]);
       printf("(%d)Memory re-allocated at %p\n", i, mem[j]);
       if (mem[j] == NULL)
-	{
+        {
           int allocsize = MM_ALIGN_UP(newsize[j] + SIZEOF_MM_ALLOCNODE);
           fprintf(stderr, "(%d)realloc failed for allocsize=%d\n", i, allocsize);
           if (allocsize > alloc_info.mxordblk)
@@ -320,7 +365,7 @@ static void do_reallocs(void **mem, const int *oldsize, const int *newsize, cons
               fprintf(stderr, "   ERROR largest free block is %ld\n", alloc_info.mxordblk);
               exit(1);
             }
-	}
+        }
       else
         {
           memset(mem[j], 0x55, newsize[j]);
@@ -337,7 +382,12 @@ static void do_reallocs(void **mem, const int *oldsize, const int *newsize, cons
     }
 }
 
-static void do_memaligns(void **mem, const int *size, const int *align, const int *rand, int n)
+/************************************************************************
+ * Name: do_memaligns
+ ************************************************************************/
+
+static void do_memaligns(void **mem, const int *size, const int *align,
+                         const int *rand, int n)
 {
   int sval;
   int i;
@@ -347,11 +397,11 @@ static void do_memaligns(void **mem, const int *size, const int *align, const in
     {
       j = rand[i];
       printf("(%d)Allocating %d bytes aligned to 0x%08x\n",
-	     i,  size[j], align[i]);
+             i,  size[j], align[i]);
       mem[j] = mm_memalign(align[i], size[j]);
       printf("(%d)Memory allocated at %p\n", i, mem[j]);
       if (mem[j] == NULL)
-	{
+        {
           int allocsize = MM_ALIGN_UP(size[j] + SIZEOF_MM_ALLOCNODE) + 2*align[i];
           fprintf(stderr, "(%d)memalign failed for allocsize=%d\n", i, allocsize);
           if (allocsize > alloc_info.mxordblk)
@@ -363,7 +413,7 @@ static void do_memaligns(void **mem, const int *size, const int *align, const in
               fprintf(stderr, "   ERROR largest free block is %ld\n", alloc_info.mxordblk);
               exit(1);
             }
-	}
+        }
       else
         {
           memset(mem[j], 0x33, size[j]);
@@ -380,6 +430,10 @@ static void do_memaligns(void **mem, const int *size, const int *align, const in
     }
 }
 
+/************************************************************************
+ * Name: do_frees
+ ************************************************************************/
+
 static void do_frees(void **mem, const int *size, const int *rand, int n)
 {
   int sval;
@@ -390,7 +444,7 @@ static void do_frees(void **mem, const int *size, const int *rand, int n)
     {
       j = rand[i];
       printf("(%d)Releasing memory at %p (size=%d bytes)\n",
-	     i, mem[j], size[j]);
+             i, mem[j], size[j]);
       mm_free(mem[j]);
       mem[j] = NULL;
 
@@ -405,6 +459,14 @@ static void do_frees(void **mem, const int *size, const int *rand, int n)
     }
 }
 
+/************************************************************************
+ * Public Functions
+ ************************************************************************/
+
+/************************************************************************
+ * Name: main
+ ************************************************************************/
+
 int main(int argc, char **argv, char **envp)
 {
   void *heap1_base;
diff --git a/nuttx/mm/mm_zalloc.c b/nuttx/mm/mm_zalloc.c
index 97f1079a6..075777d0c 100644
--- a/nuttx/mm/mm_zalloc.c
+++ b/nuttx/mm/mm_zalloc.c
@@ -1,8 +1,8 @@
-/************************************************************************
+/****************************************************************************
  * mm/mm_zalloc.c
  *
  *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
- *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,30 +31,30 @@
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Included Files
- ************************************************************************/
+ ****************************************************************************/
 
 #include "mm_environment.h"
 #include "mm_internal.h"
 
-/************************************************************************
+/****************************************************************************
  * Pre-processor Definitions
- ************************************************************************/
+ ****************************************************************************/
 
-/************************************************************************
- * Public: Functions
- ************************************************************************/
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
 
-/************************************************************************
+/****************************************************************************
  * Name: zalloc
  *
  * Description:
  *   zalloc calls malloc, then zeroes out the allocated chunk.
  *
- ************************************************************************/
+ ****************************************************************************/
 
 FAR void *zalloc(size_t size)
 {