Message-ID: <3EAF5020.9E3C6C9A@yahoo.com>
Date: Wed, 30 Apr 2003 00:25:04 -0400
From: CBFalconer <cbfalconer AT yahoo DOT com>
Organization: Ched Research
X-Mailer: Mozilla 4.75 [en] (Win98; U)
X-Accept-Language: en
MIME-Version: 1.0
To: djgpp-workers <djgpp-workers AT delorie DOT com>
Subject: nmalloc documentation revisions
Content-Type: multipart/mixed;
 boundary="------------6B82DB1E4634CE5EEBAC5710"
Reply-To: djgpp-workers AT delorie DOT com

This is a multi-part message in MIME format.
--------------6B82DB1E4634CE5EEBAC5710
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit

Attached is a zip file (malldbg.zip) containing:

  The original malloc.txh (named malloco.txh)
  The revised nmalloc.txh (named nmalloc.txh)
  A diff file malltxh.dif

The dif file is larger than any, so I fail to see its usefulness. 
At any rate it is also included below in plain text.

I will mount the revised nmalloc.zip on my site in a few days,
after getting some feedback.  Revising this documentation has
shown a couple of minor insecurities and inconsistencies.

32c32
< char *c = (char *)malloc(100);
---
> char *c = malloc(100);
62c62
< char *q = (char *)malloc(20);
---
> char *q = malloc(20);
105c105
< if (now+new > max)
---
> if (now + new > max)
107c107,108
<   char *old = p;
---
>   char  *old = p;
>   size_t oldmax;
109c110,111
<   max = now+new;
---
>   oldmax = max;
>   max = now + new;
111c113
<   if (p == NULL)
---
>   if (p == NULL) @{
112a115,116
>     max = oldmax;
>   @}
116c120
< @c
----------------------------------------------------------------------
---
> @c -------------------------------------------------------------
130,132c134,136
< intended to be used for debugging dynamic memory allocation and
tracking
< heap usage.  The @code{struct mallinfo} structure is defined by
< @file{stdlib.h} as follows:
---
> intended to be used for debugging dynamic memory allocation and
> tracking heap usage.  The @code{struct mallinfo} structure is
> defined by @file{stdlib.h} as follows:
153a158
> 
155,160c160,166
< @code{malloc}.  Note that this is not the same as
@code{sbrk(0)}, since
< @code{sbrk} allocates memory in large chunks and then subdivides
them
< and passes them to @code{malloc} as required.  In particular,
the result
< of @code{sbrk(0)} might be much larger than the @code{arena}
member of
< @code{struct mallinfo} when the DPMI host allocates memory in
< non-contiguous regions (happens on MS-Windows).
---
> @code{malloc}.  Note that this is not the same as
> @code{sbrk(0)}, since @code{sbrk} allocates memory in large
> chunks and then subdivides them and passes them to @code{malloc}
> as required.  In particular, the result of @code{sbrk(0)} might
> be much larger than the @code{arena} member of @code{struct
> mallinfo} when the DPMI host allocates memory in non-contiguous
> regions (happens on MS-Windows).
163,164c169,171
< The number of ``ordinary blocks'': the total number of allocated
and
< free blocks maintained by @code{malloc}.
---
> 
> The number of ``ordinary blocks'': the total number of allocated
> and free blocks maintained by @code{malloc}.
166a174
> 
168,173c176
< @code{malloc} was compiled with the symbol @code{NUMSMALL}
defined to a
< non-zero value.  Doing so activates an optional algorithm which
serves
< small allocations quickly from a special pool.  If this option
is
< activated, the @code{smblks} member returns the number of free
small
< blocks (the allocated small blocks are included in the value of
< @code{ordblks}).
---
> a special version of @code{malloc} was installed.
175a179,183
> 
> The count of free blocks maintained in the malloc arena.  This
> is normally much smaller than the number of freed blocks, since
> such blocks have been combined into larger blocks.
> 
177c185,187
< Always zero, kept for compatibility with other systems.
---
> 
> The size of the currently available top portion of the memory 
> assigned by sbrk.
180,181c190,192
< The space (in bytes) in ``small blocks'' that are in use.  This
is
< always zero in the DJGPP implementation.
---
> 
> The space (in bytes) in ``small blocks'' that are in use.  This
> is always zero in the DJGPP implementation.
184,186c195,197
< The space in free ``small blocks''.  Non-zero only of
@code{malloc} was
< compiled with @code{NUMSMALL} defined to a non-zero value.  In
that
< case, gives the amount of space in bytes in free small blocks.
---
> 
> The space in free ``small blocks''.  Normally zero in this
> implementation.
189,191c200,203
< The amount of space, in bytes, in the heap space currently used
by the
< application.  This does not include the small overhead (8 bytes
per
< block) used by @code{malloc} to maintain its hidden information
in each
---
> 
> The amount of space, in bytes, in the heap space currently used
> by the application.  This does not include the small overhead
> used by @code{malloc} to maintain its hidden information in each
195,196c207,209
< The amount of free heap space maintained by @code{malloc} in its
free
< list.
---
> 
> The amount of free heap space maintained by @code{malloc} in its
> free lists.
199c212,215
< Always zero, kept for compatibility.
---
> 
> The total overhead used by @code(malloc) in maintaining the 
> currently allocated blocks.
> 
201a218
> 
204c221
< The @code{mallinfo} structure filled with information.
---
> The mallinfo structure filled with information.
207a225,226
> @portability ansi, posix
> 
221c240
< @c
----------------------------------------------------------------------
---
> @c -------------------------------------------------------------
234,244c253,259
< This function attempts to determine if the heap has been
corrupted.  It
< scans all the blocks allocated by @code{malloc} and handed to
the
< application, and also all the free blocks maintained by
@code{malloc}
< and @code{free} in the internal free list.  Each block is
checked for
< consistency of the hidden bookkeeping information recorded in it
by
< @code{malloc} and @code{free}.  The blocks on the free list are
< additionally validated by chasing all the @code{next} pointers
in the
< linked list and checking them against limits for valid pointers
(between
< 0x1000 and the data segment limit), and the alignment. 
(Unaligned
< pointers are probably corrupted, since @code{malloc} always
returns a
< properly aligned storage.)
---
> This function attempts to determine if the heap has been
> corrupted.  It scans all the blocks allocated by @code{malloc}
> and handed to the application, and also all the free blocks
> maintained by @code{malloc} and @code{free} in the internal free
> list.  Each block is checked for consistency of the hidden
> bookkeeping information recorded in it by @code{malloc} and
> @code{free}. 
247,248c262,264
< @dfn{malloc diagnostics level}: for example, the block can be
reported,
< or the program may be aborted.  @xref{malloc_debug}, for the
details.
---
> @dfn{malloc diagnostics level}: for example, the block can be
> reported, or the program may be aborted.  @xref{malloc_debug},
> for the details.
252,254c268,271
< If the program isn't aborted during the function's run (this
depends on
< the current diagnostics level), @code{malloc_verify} returns 1
if the
< heap passes all tests, or zero of some of the tests failed.
---
> If the program isn't aborted during the function's run (this
> depends on the current diagnostics level), @code{malloc_verify}
> returns 1 if the heap passes all tests, or zero of some of the
> tests failed.
268c285
< @c
----------------------------------------------------------------------
---
> @c -------------------------------------------------------------
281,284c298,301
< This function sets the level of error diagnosis and reporting
during
< subsequent calls to @code{malloc}, @code{free}, @code{realloc},
and all
< functions which call them internally.  The argument @var{level}
is
< interpreted as follows:
---
> This function sets the level of error diagnosis and reporting
> during subsequent calls to @code{malloc}, @code{free},
> @code{realloc}, and all functions which call them internally.
> The argument @var{level} is interpreted as follows:
288,291c305,311
< No checking; the memory allocation functions behave as they do
if
< @code{malloc_debug} was never called.  Memory in use by the
application
< which was allocated while level 0 was in effect cannot be
checked by
< @code{malloc_verify} unless it is @code{free}d first.
---
> 
> The memory allocation functions behave as they do if
> @code{malloc_debug} was never called.  Only passive checks are
> allowed, including malloc_verify, mallocmap, and malldbgdumpfile
> (to set the output file).  In particular mallsethook() is
> disabled, to avoid accidents.  The actual functioning of the
> malloc system remains unaffected.  Any malloc hooks are reset.
294,301c314,317
< Each one of the allocated blocks is recorded in a special
structure,
< where @code{malloc_verify} can test them for corruption, even if
these
< blocks were not yet @code{free}d.  If errors are detected by
< @code{malloc_verify}, it prints diagnostic messages to the
standard
< error stream, with address and size of the offending block and
other
< pertinent information.  This level slows down memory allocation
to some
< extent due to additional overhead of calling special functions
which
< record extra debugging info.
---
> 
> All the passive checks of level 0 are allowed.  In addition
> mallsethook() is enabled, thus allowing construction of custom
> debugging packages.
304,307c320,327
< Like level 1, but in addition the consistency of the entire heap
is
< verified (by calling @code{malloc_verify}) on every call to the
memory
< allocation functions.  @emph{Warning: this may significantly
slow down
< the application.}
---
> 
> Similar to level 1, but in addition the consistency of the
> entire heap is verified (by calling @code{malloc_verify}) on
> every call to the memory allocation functions.  @emph{Warning:
> this may significantly slow down the application.}  Since the
> malloc hooks are in use to connect to this system, mallsethook
> is disabled.  If there are hooks already in use the change to
> level 2 or above is rejected.
309a330
> 
311,314c332,334
< corruption is detected.  In addition, failed allocations (i.e.@:
when
< @code{malloc} returns @code{NULL} because it cannot satisfy a
request)
< are reported to standard error.  Also, if the storage where
allocated
< blocks are recorded is exhausted, a message to that effect is
printed.
---
> corruption is detected.  In addition, failed allocations (i.e.@:
> when @code{malloc} returns @code{NULL} because it cannot satisfy
> a request) are reported to standard error.  
317,319d336
< Like level 3, but calls to @code{free} with a @code{NULL}
pointer as an
< argument are also reported.
< @end table
321,335c338,341
< When @code{malloc_debug} is first called with a positive
argument, it
< allocates storage for recording blocks in use.  To avoid
reentrancy
< problems, this storage is allocated via a direct call to
@code{sbrk},
< and its size is fixed.  The size used to allocate this storage
is by
< default 400KB, which is enough to record 100 thousand allocated
blocks.
< You can tailor the size to your needs by setting the environment
< variable @code{MALLOC_DEBUG} to the maximum number of blocks you
want to
< be able to track.  (The value of @code{MALLOC_DEBUG} should only
be as
< large as the maximum number of allocations which is expected to
be in
< use at any given time, because when a buffer is freed, it is
removed
< from this storage and its cell can be reused for another
allocation.)
< Note that the larger this storage size, the more slow-down will
your
< program experience when the diagnostic level is set to a
non-zero value,
< since the debugging code needs to search the list of recorded
blocks in
< use each time you call @code{malloc} or @code{free}.
---
> Like level 3, but calls to @code{free} with a @code{NULL}
> pointer as an argument are also reported.
> 
> @end table
355c361
< @c
----------------------------------------------------------------------
---
> @c -------------------------------------------------------------
368,375c374,377
< This function prints a map of the heap storage to standard
output.  For
< each block, its address and size are printed, as well as an
indication
< whether it is free or in use.  If the @dfn{slop} (a special free
block
< cached for performance reasons) and the small blocks are
available, they
< are printed as well (these two are variants of free blocks). 
Blocks in
< use will only be printed if the diagnostic level was set to a
non-zero
< value by a call to @code{malloc_debug} (@pxref{malloc_debug}),
since
< otherwise the allocated blocks are not recorded by
@code{malloc}.
---
> This function prints a map of the heap storage to standard
> output.  For each block, its address and size are printed, as
> well as an indication whether it is free or in use, together
> with pointers to adjacent blocks.
386c388
< @c
----------------------------------------------------------------------
---
> @c -------------------------------------------------------------
388c390
< @node malloc hook functions, memory
---
> @node mallsethook, memory
393d394
< #include <libc/malloc.h>
395,399c396,397
< void (*__libc_malloc_hook)(size_t size, void *block);
< void (*__libc_malloc_fail_hook)(size_t size);
< void (*__libc_free_hook)(void *block);
< void (*__libc_free_null_hook)(void);
< void (*__libc_realloc_hook)(void *block, size_t size);
---
> M_HOOKFN mallsethook(enum m_hook_kind which,
>                      M_HOOKFN newhook);
404,411c402,410
< These hooks are provided for building custom @code{malloc}
debugging
< packages.  Such packages typically need to be notified when
memory is
< allocated and freed by the application, in order to be able to
find
< memory leaks, code that writes beyond the limits of allocated
buffers or
< attempts to free buffers which were not allocated by
@code{malloc}, etc.
< These hooks can be used to define callback functions which will
be
< called by the library at strategic points.  Each callback is
only called
< if it is non- AT code{NULL}; by default, all of them are
initialized to a
---
> These hooks are provided for building custom @code{malloc}
> debugging packages.  Such packages typically need to be notified
> when memory is allocated and freed by the application, in order
> to be able to find memory leaks, code that writes beyond the
> limits of allocated buffers or attempts to free buffers which
> were not allocated by @code{malloc}, etc. These hooks can be
> used to define callback functions which will be called by the
> library at strategic points.  Each callback is only called if it
> is non- AT code{NULL}; by default, all of them are initialized to a
413a413,441
> The actual hook to be set is described by the following
> constants, enumerated in stdlib.h:
> 
> malloc_HK = 0    on entry to malloc
> malloc_fail_HK   when malloc fails
> free_HK          on entry to free
> free_null_HK     when free is called with a NULL pointer
> realloc_HK       on entry to realloc
> realloc_exit_HK  when realloc exits.
> HKCOUNT          The first invalid value for a hook descriptor.
> 
> 
> and each ``callback'' function is described by:
> 
>    typedef void (*M_HOOKFN)(size_t sz, void *ptr);
> 
> in stdlib.h.  Note that in some cases the parameters supplied to
> the ``callback'' function will be meaningless, in which case
> they will be zero or NULL as appropriate.  The callback function
> must NOT call any of malloc, free, or realloc.
> 
> mallsethook action is disabled unless the debug_level is set to
> 1.  This interlock avoids accidental use before enabling the
> package, and avoids altering hooks that are already in use for
> debug_level of 2 or higher.
> 
> For access to the internal storage of the malloc arena, see the
> _sysmalloc() call and the _sysinfo struct.
> 
415,436c443,465
< @item __libc_malloc_hook
< Called just before a chunk of memory is about to be returned to
the
< application in response to an allocation request.  @var{size} is
the
< size requested by the application (@strong{not} the actual size
of the
< allocated buffer, which may be larger).  @var{block} is a
pointer to the
< block that was allocated, which is 4 bytes before the pointer
that
< @code{malloc} will return to the application; these 4 bytes are
used to
< record the actual size of the buffer.  An additional copy of the
block's
< size is recorded immediately after the buffer's end.  Thus,
< @w{@code{*(size_t *)((char *)block + 4 + (BLOCK *)block->size)}}
gives
< the second copy of the block's size.
< 
< @item __libc_malloc_fail_hook
< Called if @code{malloc} failed to find a free block large enough
to
< satisfy a request, and also failed to obtain additional memory
from
< @code{sbrk}.  @var{size} is the requested allocation size.
< 
< @item __libc_free_hook
< Called when a buffer is about to be freed.  @var{block} is a
pointer 4
< bytes before the address passed to @code{free} by the
application,
< i.e.@: it is a pointer to the beginning of the size information
< maintained before the user buffer.
---
> @item malloc_HK
> 
> Called just before a chunk of memory is about to be returned to
> the application in response to an allocation request.
> @var{sz} is the size requested by the application
> (@strong{not} the actual size of the allocated buffer, which may
> be larger).  @var{ptr} is a pointer to the block that was
> allocated.
> 
> @item malloc_fail_HK
> 
> Called if @code{malloc} failed to find a free block large enough
> to satisfy a request, and also failed to obtain additional
> memory from @code{sbrk}.  @var{sz} is the requested allocation
> size.
> 
> @item free_HK
> 
> Called when a buffer is about to be freed.  @var{ptr} is a
> pointer to the block to be freed.  Its validity has not been
> checked.
> 
> @item free_null_HK
438d466
< @item __libc_free_null_hook
440,452c468,481
< @acronym{ANSI} C specifically rules that this is allowed and
should have
< no effect, but you might want to catch such cases if your
program needs
< to be portable to old compilers whose libraries don't like
@code{NULL}
< pointers in @code{free}.
< 
< @item __libc_realloc_hook
< Called at entry to @code{realloc}, before the actual
reallocation.
< @var{block} is a pointer 4 bytes before the address passed to
< @code{free} by the application, i.e.@: it is a pointer to the
beginning
< of the size information maintained before the user buffer. 
@var{size}
< is the new size requested by the application.  (This hook is
called
< @emph{in addition} to the other hooks which will be called by
< @code{free} and @code{malloc} if and when @code{realloc} calls
them.)
---
> @acronym{ANSI} C specifically rules that this is allowed and
> should have no effect, but you might want to catch such cases if
> your program needs to be portable to old compilers whose
> libraries don't like @code{NULL} pointers in @code{free}.
> 
> @item realloc_HK
> 
> Called at entry to @code{realloc}, before the actual
> reallocation. @var{ptr} is the pointer whose contents are to be
> reallocated.  @var{sz} is the new size requested by the
> application.  (This hook is called @emph{in addition} to the
> other hooks which may be called by @code{malloc} if and when
> @code{realloc} calls them.)
> 
455,461c484,593
< The @code{BLOCK} data type is used by @code{malloc} and
@code{free} to
< maintain the heap.  The only member which is always guaranteed
to be
< valid is @code{size} (the additional copy of the size, recorded
beyond
< the buffer's end, is also guaranteed to be valid).  The
@code{next}
< member is valid in all blocks that are part of the free list. 
This
< means that @code{__libc_malloc_hook} can use the @code{next}
member, but
< @code{__libc_free_hook} cannot.
---
> @subheading Return Value
> 
> @code{mallsethook} returns the previous hook pointer, (usually
> NULL). If mallsethook is disabled it will also return NULL
> 
> @subheading Portability
> 
> @portability !ansi, !posix
> 
> These hooks and the function are specific to DJGPP.
> 
> @subheading Example
> 
> @example
> 
>  static void mallocfailalert(size_t sz, void *ptr)
>  @{
>     printf("Failed to malloc %lu bytes\n", (unsigned long)sz);
>  @}
> 
>  malloc_debug(1);
>  mallsethook(malloc_fail_HK, mallocfailalert);
>  ...
>  /* any malloc failure will result in a message */
>  
> @end example
> 
> @c -------------------------------------------------------------
> 
> @node malldbgdmpfile, memory
> @subheading Syntax
> 
> @example
> #include <stdlib.h>
> 
> FILE *malldbgdmpfile(FILE *fp);
> @end example
> 
> @subheading Description
> 
> This function allows diverting the output of the malldbg package
> to any suitable text file.  By default the package uses stderr.
> 
> @subheading Return Value
> 
> The previous identity of the dumpfile.
> 
> @subheading Portability
> 
> @portability !ansi, !posix
> 
> This function is specific to DJGPP.
> 
> @subheading Example
> 
> @example
> FILE *oldfile = malldbgdmpfile(stdout);
> @end example
> 
> @c -------------------------------------------------------------
> 
> @node _sysmalloc, memory
> @subheading Syntax
> 
> @example
> #include <stdlib.h>
> 
> struct _sysquery _sysmalloc(void);
> @end example
> 
> @subheading Description
> 
> This function exports the internal structure of the malloc arena
> and thus allows construction of such packages as malldbg.  It 
> avoids accidental exposure of system critical values, and also
> permits such values to be changed and reflected in external
> packages.
> 
> @subheading Return Value
> 
> A struct _sysquery, described as follows:
> 
> struct _sysquery @{
>   unsigned char data, gdlo, sz, prvf, nxtf, nxt, prv, ohead;
>   void         *nilp;
>   void         *anchors;
>   set_m_hook    hookset;
> @};
> 
> Any unsigned char field set to 255 signifies the value is 
> meaningless.  The ohead value is not useful in the present
> implementation.  The remaining values are small offsets from the 
> internal pointers to the appropriate fields.  In particular
> data is the offset between the internal pointer and the user
> pointers.  nxt and prv link all allocated memory blocks, while 
> nxtf and prvf are used only to link free blocks. sz is the 
> internal size of the block, not the user size, and is normally
> rounded upward.  Thus the nxt field is redundant to the sz field
> (except when no nxt exists) and is used in validity checking.
> A null value in nxtf field signifies that the block is not free.
> The special value nilp is used in nxtf and prvf as a NULL value
> distinguishable from NULL.
> 
> anchors points to a NULL terminated list of sets of chains of
> memory blocks.  These were allocated by sbrk and were not
> contiguous to any previous allocations.
> 
> hookset is a pointer to a function that can set malloc hooks, as
> described in mallsethook.  It is only available through this
> link.
467c599,605
< These hooks are specific to DJGPP.
---
> This function is specific to DJGPP.
> 
> @subheading Example
> 
> @example
> struct _sysquery sysinfo = _sysmalloc();
> @end example
468a607
> @c -------------------------------------------------------------

-- 
Chuck F (cbfalconer AT yahoo DOT com) (cbfalconer AT worldnet DOT att DOT net)
   Available for consulting/temporary embedded and systems.
   <http://cbfalconer.home.att.net>  USE worldnet address!
--------------6B82DB1E4634CE5EEBAC5710
Content-Type: application/x-zip-compressed;
 name="malldbg.zip"
Content-Transfer-Encoding: base64
Content-Disposition: inline;
 filename="malldbg.zip"
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--------------6B82DB1E4634CE5EEBAC5710--