*** empty log message ***

[mLib] / track.c

/* -*-c-*-
 *
 * $Id: track.c,v 1.1 1998/06/17 23:44:42 mdw Exp $
 *
 * Tracing functions for debugging
 *
 * (c) 1998 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the mLib utilities library.
 *
 * mLib is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * mLib is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with mLib; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------*
 *
 * $Log: track.c,v $
 * Revision 1.1  1998/06/17 23:44:42  mdw
 * Initial revision
 *
 */

/*----- Header files ------------------------------------------------------*/

/* --- ANSI headers --- */

#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* --- Local headers --- */

#include "trace.h"
#include "track.h"

/*----- Type definitions --------------------------------------------------*/

/* --- A track block --- *
 *
 * This gets prefixed to every block I manage.
 */

typedef union track__block {
  struct {
    union track__block *next;		/* Link to previous block */
    union track__block *prev;		/* Link to next block */
    size_t sz;				/* Size of the block */
    const char *ctx;			/* Pointer to allocating context */
  } x;					/* Main data area */
  long double _ld;			/* Long double for alignment */
  void *_p;				/* Void pointer for alignment */
} track__block;

/*----- Private state -----------------------------------------------------*/

/* --- Tracking memory usage --- */

static unsigned int track__used = 0;	/* Count of bytes occupied */
static track__block *track__list;	/* List of allocated blocks */

/* --- Trace level for verbose messages --- */

static unsigned int track__vLevel = 0;

/* --- Context tracking --- */

static track_ctx track__baseContext = {
  0, "[unknown context]"
};

static track_ctx *track__context = &track__baseContext;

/*----- Functions provided ------------------------------------------------*/

/* --- @track_setLevel@ --- *
 *
 * Arguments:	@unsigned int l@ = tracing level for allocation messages
 *
 * Returns:	---
 *
 * Use:		Sets the trace level for allocation messages.
 */

void track_setLevel(unsigned int l)
{
  track__vLevel = l;
}

/* --- @track_pushContext@ --- *
 *
 * Arguments:	@track_ctx *ctx@ = context holder to push
 *
 * Returns:	---
 *
 * Use:		Pushes the given context block onto the stack.
 */

void track_pushContext(track_ctx *ctx)
{
  ctx->next = track__context;
  track__context = ctx;
}

/* --- @track_popContext@ --- *
 *
 * Arguments:	@track_ctx *ctx@ = context holder to pop
 *
 * Returns:	---
 *
 * Use:		Removes the given context block from the stack.
 */

void track_popContext(track_ctx *ctx)
{
  track__context = ctx->next;
}

/* --- @track_malloc@ --- *
 *
 * Arguments:	@size_t sz@ = size requested
 *
 * Returns:	Pointer to allocated space, or null
 *
 * Use:		Allocates memory, and tracks how much is allocated.
 */

void *track_malloc(size_t sz)
{
  track__block *q = (malloc)(sz + sizeof(track__block));
  if (q) {
    track__used += sz;
    if (track__vLevel) {
      trace(track__vLevel, "(track) allocated %lu at %p in %s",
	    (unsigned long)sz, (void *)(q + 1), track__context->s);
    }
    q->x.sz = sz;
    q->x.next = track__list;
    q->x.prev = 0;
    q->x.ctx = track__context->s;
    if (q->x.next)
      q->x.next->x.prev = q;
    track__list = q;
    return (q + 1);
  }
  return (0);
}

/* --- @track_free@ --- *
 *
 * Arguments:	@void *p@ = pointer to an allocated block
 *
 * Returns:	---
 *
 * Use:		Frees memory, and tracks how much is still allocated.
 */

void track_free(void *p)
{
  track__block *q;

  if (!p)
    return;
  q = (track__block *)p - 1;
  if (track__vLevel) {
    trace(track__vLevel, "(track) freed %lu at %p for %s in %s",
	  (unsigned long)q->x.sz, (void *)(q + 1),
	  q->x.ctx, track__context->s);
  }
  if (q->x.next)
    q->x.next->x.prev = q->x.prev;
  if (q->x.prev)
    q->x.prev->x.next = q->x.next;
  else
    track__list = q->x.next;
  track__used -= q->x.sz;
  (free)(q);
}

/* --- @track_realloc@ --- *
 *
 * Arguments:	@void *p@ = pointer to an allocated block
 *		@size_t sz@ = how big it wants to be
 *
 * Returns:	Pointer to the new block.
 *
 * Use:		Reallocates a block, tracking how much memory is still
 *		available.
 */

void *track_realloc(void *p, size_t sz)
{
  size_t osz;
  track__block *q, *qq;
  if (p) {
    q = (track__block *)p - 1;
    osz = q->x.sz;
    if (q->x.next)
      q->x.next->x.prev = q->x.prev;
    if (q->x.prev)
      q->x.prev->x.next = q->x.next;
    else
      track__list = q->x.next;
  } else {
    q = 0;
    osz = 0;
  }
  qq = (realloc)(q, sz + sizeof(track__block));
  if (qq) {
    if (track__vLevel) {
      trace(track__vLevel,
	    "(track) reallocated %lu at %p to %lu for %s in %s",
	    (unsigned long)osz, (void *)(q + 1),
	    (unsigned long)sz,  (void *)(qq + 1),
	    qq->x.ctx, track__context->s);
    }
    qq->x.sz = sz;
    qq->x.next = track__list;
    qq->x.prev = 0;
    if (qq->x.next)
      qq->x.next->x.prev = qq;
    track__list = qq;
    track__used += sz - osz;
    qq->x.sz = sz;
    return (qq + 1);
  }
  return (0);
}

/* --- @track_used@ --- *
 *
 * Arguments:	---
 *
 * Returns:	A count of how much memory is used currently.
 *
 * Use:		Returns the amount of memory which the @track_@-functions
 *		above have counted as being currently allocated.
 */

unsigned long track_used(void)
{
  return (track__used);
}

/* --- @track_list@ --- *
 *
 * Arguments:	@unsigned int l@ = trace level to use
 *
 * Returns:	---
 *
 * Use:		Traces a dump of the currently known blocks.  Combined with
 *		a verbose dump of allocations and deallocations, and a
 *		good idea of which blocks were allocated where, this can
 *		be useful for locating memory leaks.  It's not exactly a
 *		picnic, though.
 */

void track_list(unsigned int l)
{
  track__block *q = track__list;

  if (!(tracing() & l))
    return;

  trace(l, "(track dump) Dumping all blocks.  Stand well back...");
  while (q) {
    trace(l, "(track dump) %p: %lu in %s",
	  (void *)(q + 1), (unsigned long)q->x.sz, q->x.ctx);
    q = q->x.next;
  }
}

/*----- That's all, folks -------------------------------------------------*/