mux/src/alloc.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"

Include dependency graph for alloc.cpp:

Go to the source code of this file.

Data Structures
struct	pool_header_unaligned
struct	pool_header
struct	pool_footer
struct	pooldata
Typedefs
typedef pool_header_unaligned	POOLHDR_UNALIGNED
typedef pool_header	POOLHDR
typedef pool_footer	POOLFTR
typedef pooldata	POOL
Functions
void	pool_init (int poolnum, int poolsize)
static void	pool_err (const char *logsys, int logflag, int poolnum, const char *tag, POOLHDR *ph, const char *action, const char *reason, const char *file, const int line)
static void	pool_vfy (int poolnum, const char *tag, const char *file, const int line)
static void	pool_check (const char *tag, const char *file, const int line)
char *	pool_alloc (int poolnum, const char *tag, const char *file, const int line)
char *	pool_alloc_lbuf (const char *tag, const char *file, const int line)
void	pool_free (int poolnum, char *buf, const char *file, const int line)
void	pool_free_lbuf (char *buf, const char *file, const int line)
static void	pool_trace (dbref player, int poolnum, const char *text)
void	list_bufstats (dbref player)
void	list_buftrace (dbref player)
void	pool_reset (void)
Variables
static POOL	pools [NUM_POOLS]
static const char *	poolnames []

---

Typedef Documentation

typedef struct pooldata POOL

typedef struct pool_footer POOLFTR

typedef struct pool_header POOLHDR

typedef struct pool_header_unaligned POOLHDR_UNALIGNED

---

Function Documentation

void list_bufstats

(

dbref

player

)

Definition at line 518 of file alloc.cpp.

References MBUF_SIZE, mux_i64toa(), notify, NUM_POOLS, poolnames, and pools.

Referenced by do_list().

{
    char buff[MBUF_SIZE];

    notify(player, "Buffer Stats  Size     InUse     Total        Allocs   Lost");

    int i;
    for (i = 0; i < NUM_POOLS; i++)
    {
        char szNumAlloc[22];
        char szMaxAlloc[22];
        char szTotAlloc[22];
        char szNumLost[22];

        mux_i64toa(pools[i].num_alloc, szNumAlloc);
        mux_i64toa(pools[i].max_alloc, szMaxAlloc);
        mux_i64toa(pools[i].tot_alloc, szTotAlloc);
        mux_i64toa(pools[i].num_lost,  szNumLost);

        sprintf(buff, "%-12s %5d%10s%10s%14s%7s",
            poolnames[i], (int)pools[i].pool_size,
            szNumAlloc, szMaxAlloc, szTotAlloc, szNumLost);
        notify(player, buff);
    }
}

void list_buftrace

(

dbref

player

)

Definition at line 544 of file alloc.cpp.

References NUM_POOLS, pool_trace(), and poolnames.

Referenced by do_list().

{
    int i;
    for (i = 0; i < NUM_POOLS; i++)
    {
        pool_trace(player, i, poolnames[i]);
    }
}

char* pool_alloc	(	int	poolnum,
		const char *	tag,
		const char *	file,
		const int	line
	)

Definition at line 162 of file alloc.cpp.

References pool_header::buf_tag, pooldata::chain_head, statedata::debug_cmd, end_log(), pooldata::free_head, ISOUTOFMEMORY, Log, LOG_ALLOCATE, LOG_ALWAYS, confdata::log_options, LOG_PROBLEMS, statedata::logging, pool_header::magicnum, pool_footer::magicnum, pooldata::max_alloc, MEMALLOC, mudconf, mudstate, pool_header::next, pooldata::num_alloc, pooldata::num_lost, pool_header::nxtfree, confdata::paranoid_alloc, pool_check(), pool_err(), pool_header::pool_size, pooldata::pool_size, pooldata::poolmagic, pools, start_log(), CLogFile::tinyprintf(), and pooldata::tot_alloc.

{
    if (mudconf.paranoid_alloc)
    {
        pool_check(tag, file, line);
    }

    char *p;
    POOLFTR *pf;
    POOLHDR *ph = (POOLHDR *)pools[poolnum].free_head;
    if (  ph
       && ph->magicnum == pools[poolnum].poolmagic)
    {
        p = (char *)(ph + 1);
        pf = (POOLFTR *)(p + pools[poolnum].pool_size);
        pools[poolnum].free_head = ph->nxtfree;

        // Check for corrupted footer, just report and fix it.
        //
        if (pf->magicnum != pools[poolnum].poolmagic)
        {
            pool_err("BUG", LOG_ALWAYS, poolnum, tag, ph, "Alloc",
                "corrupted buffer footer", file, line);
            pf->magicnum = pools[poolnum].poolmagic;
        }
    }
    else
    {
        if (ph)
        {
            // Header is corrupt. Throw away the freelist and start a new
            // one.
            pool_err("BUG", LOG_ALWAYS, poolnum, tag, ph, "Alloc",
                "corrupted buffer header", file, line);

            // Start a new free list and record stats.
            //
            pools[poolnum].free_head = NULL;
            pools[poolnum].num_lost += (pools[poolnum].tot_alloc
                                     -  pools[poolnum].num_alloc);
            pools[poolnum].tot_alloc = pools[poolnum].num_alloc;
        }

        ph = (POOLHDR *)MEMALLOC(pools[poolnum].pool_size + sizeof(POOLHDR)
           + sizeof(POOLFTR));
        ISOUTOFMEMORY(ph);
        p = (char *)(ph + 1);
        pf = (POOLFTR *)(p + pools[poolnum].pool_size);

        // Initialize.
        //
        ph->next = pools[poolnum].chain_head;
        ph->nxtfree = NULL;
        ph->magicnum = pools[poolnum].poolmagic;
        ph->pool_size = pools[poolnum].pool_size;
        pf->magicnum = pools[poolnum].poolmagic;
        *((unsigned int *)p) = pools[poolnum].poolmagic;
        pools[poolnum].chain_head = ph;
        pools[poolnum].max_alloc++;
    }

    ph->buf_tag = (char *)tag;
    pools[poolnum].tot_alloc++;
    pools[poolnum].num_alloc++;

    if (  (LOG_ALLOCATE & mudconf.log_options)
       && mudstate.logging == 0
       && start_log("DBG", "ALLOC"))
    {
        Log.tinyprintf("Alloc[%d] (tag %s) in %s line %d buffer at %lx. (%s)",
            pools[poolnum].pool_size, tag, file, line, (long)ph, mudstate.debug_cmd);
        end_log();
    }

    // If the buffer was modified after it was last freed, log it.
    //
    unsigned int *pui = (unsigned int *)p;
    if (*pui != pools[poolnum].poolmagic)
    {
        pool_err("BUG", LOG_PROBLEMS, poolnum, tag, ph, "Alloc",
            "buffer modified after free", file, line);
    }
    *pui = 0;
    return p;
}

char* pool_alloc_lbuf	(	const char *	tag,
		const char *	file,
		const int	line
	)

Definition at line 248 of file alloc.cpp.

References pool_header::buf_tag, pooldata::chain_head, statedata::debug_cmd, end_log(), pooldata::free_head, ISOUTOFMEMORY, LBUF_SIZE, Log, LOG_ALLOCATE, LOG_ALWAYS, confdata::log_options, LOG_PROBLEMS, statedata::logging, pool_header::magicnum, pool_footer::magicnum, pooldata::max_alloc, MEMALLOC, mudconf, mudstate, pool_header::next, pooldata::num_alloc, pooldata::num_lost, pool_header::nxtfree, confdata::paranoid_alloc, pool_check(), pool_err(), POOL_LBUF, pool_header::pool_size, pooldata::poolmagic, pools, start_log(), CLogFile::tinyprintf(), and pooldata::tot_alloc.

Referenced by atr_get_real(), and atr_pget_real().

{
    if (mudconf.paranoid_alloc)
    {
        pool_check(tag, file, line);
    }

    char *p;
    POOLFTR *pf;
    POOLHDR *ph = (POOLHDR *)pools[POOL_LBUF].free_head;
    if (  ph
       && ph->magicnum == pools[POOL_LBUF].poolmagic)
    {
        p = (char *)(ph + 1);
        pf = (POOLFTR *)(p + LBUF_SIZE);
        pools[POOL_LBUF].free_head = ph->nxtfree;

        // Check for corrupted footer, just report and fix it.
        //
        if (pf->magicnum != pools[POOL_LBUF].poolmagic)
        {
            pool_err("BUG", LOG_ALWAYS, POOL_LBUF, tag, ph, "Alloc",
                "corrupted buffer footer", file, line);
            pf->magicnum = pools[POOL_LBUF].poolmagic;
        }
    }
    else
    {
        if (ph)
        {
            // Header is corrupt. Throw away the freelist and start a new
            // one.
            pool_err("BUG", LOG_ALWAYS, POOL_LBUF, tag, ph, "Alloc",
                "corrupted buffer header", file, line);

            // Start a new free list and record stats.
            //
            pools[POOL_LBUF].free_head = NULL;
            pools[POOL_LBUF].num_lost += (pools[POOL_LBUF].tot_alloc
                                     -  pools[POOL_LBUF].num_alloc);
            pools[POOL_LBUF].tot_alloc = pools[POOL_LBUF].num_alloc;
        }

        ph = (POOLHDR *)MEMALLOC(LBUF_SIZE + sizeof(POOLHDR)
           + sizeof(POOLFTR));
        ISOUTOFMEMORY(ph);
        p = (char *)(ph + 1);
        pf = (POOLFTR *)(p + LBUF_SIZE);

        // Initialize.
        //
        ph->next = pools[POOL_LBUF].chain_head;
        ph->nxtfree = NULL;
        ph->magicnum = pools[POOL_LBUF].poolmagic;
        ph->pool_size = LBUF_SIZE;
        pf->magicnum = pools[POOL_LBUF].poolmagic;
        *((unsigned int *)p) = pools[POOL_LBUF].poolmagic;
        pools[POOL_LBUF].chain_head = ph;
        pools[POOL_LBUF].max_alloc++;
    }

    ph->buf_tag = (char *)tag;
    pools[POOL_LBUF].tot_alloc++;
    pools[POOL_LBUF].num_alloc++;

    if (  (LOG_ALLOCATE & mudconf.log_options)
       && mudstate.logging == 0
       && start_log("DBG", "ALLOC"))
    {
        Log.tinyprintf("Alloc[%d] (tag %s) in %s line %d buffer at %lx. (%s)",
            LBUF_SIZE, tag, file, line, (long)ph, mudstate.debug_cmd);
        end_log();
    }

    // If the buffer was modified after it was last freed, log it.
    //
    unsigned int *pui = (unsigned int *)p;
    if (*pui != pools[POOL_LBUF].poolmagic)
    {
        pool_err("BUG", LOG_PROBLEMS, POOL_LBUF, tag, ph, "Alloc",
            "buffer modified after free", file, line);
    }
    *pui = 0;
    return p;
}

static void pool_check	(	const char *	tag,
		const char *	file,
		const int	line
	)			[static]

Definition at line 153 of file alloc.cpp.

References NUM_POOLS, and pool_vfy().

Referenced by pool_alloc(), pool_alloc_lbuf(), pool_free(), and pool_free_lbuf().

{
    int i;
    for (i = 0; i < NUM_POOLS; i++)
    {
        pool_vfy(i, tag, file, line);
    }
}

static void pool_err	(	const char *	logsys,
		int	logflag,
		int	poolnum,
		const char *	tag,
		POOLHDR *	ph,
		const char *	action,
		const char *	reason,
		const char *	file,
		const int	line
	)			[static]

Definition at line 74 of file alloc.cpp.

References statedata::debug_cmd, ENDLINE, ENDLOG, Log, LOG_ALLOCATE, statedata::logging, mudstate, pools, STARTLOG, and CLogFile::tinyprintf().

Referenced by pool_alloc(), pool_alloc_lbuf(), pool_free(), pool_free_lbuf(), and pool_vfy().

{
    if (mudstate.logging == 0)
    {
        STARTLOG(logflag, logsys, "ALLOC");
        Log.tinyprintf("%s[%d] (tag %s) %s in %s line %d at %lx. (%s)", action,
            pools[poolnum].pool_size, tag, reason, file, line, (long)ph,
            mudstate.debug_cmd);
        ENDLOG;
    }
    else if (logflag != LOG_ALLOCATE)
    {
        Log.tinyprintf(ENDLINE "***< %s[%d] (tag %s) %s in %s line %d at %lx. >***",
            action, pools[poolnum].pool_size, tag, reason, file, line, (long)ph);
    }
}

void pool_free	(	int	poolnum,
		char *	buf,
		const char *	file,
		const int	line
	)

Definition at line 334 of file alloc.cpp.

References pool_header::buf_tag, statedata::debug_cmd, end_log(), ENDLOG, pooldata::free_head, Log, LOG_ALLOCATE, LOG_ALWAYS, LOG_BUGS, confdata::log_options, LOG_PROBLEMS, log_text(), statedata::logging, pool_header::magicnum, pool_footer::magicnum, mudconf, mudstate, pooldata::num_alloc, pooldata::num_lost, pool_header::nxtfree, confdata::paranoid_alloc, pool_check(), pool_err(), pool_header::pool_size, pooldata::pool_size, pooldata::poolmagic, pools, start_log(), STARTLOG, CLogFile::tinyprintf(), pooldata::tot_alloc, and tprintf().

{
    if (buf == NULL)
    {
        STARTLOG(LOG_PROBLEMS, "BUG", "ALLOC")
        log_text(tprintf("Attempt to free null pointer in %s line %d.", file, line));
        ENDLOG
        return;
    }
    POOLHDR *ph = ((POOLHDR *)(buf)) - 1;
    POOLFTR *pf = (POOLFTR *)(buf + pools[poolnum].pool_size);
    unsigned int *pui = (unsigned int *)buf;

    if (mudconf.paranoid_alloc)
    {
        pool_check(ph->buf_tag, file, line);
    }

    // Make sure the buffer header is good.  If it isn't, log the error and
    // throw away the buffer.
    //
    if (ph->magicnum != pools[poolnum].poolmagic)
    {
        pool_err("BUG", LOG_ALWAYS, poolnum, ph->buf_tag, ph, "Free",
                 "corrupted buffer header", file, line);
        pools[poolnum].num_lost++;
        pools[poolnum].num_alloc--;
        pools[poolnum].tot_alloc--;
        return;
    }

    // Verify the buffer footer.  Don't unlink if damaged, just repair.
    //
    if (pf->magicnum != pools[poolnum].poolmagic)
    {
        pool_err("BUG", LOG_ALWAYS, poolnum, ph->buf_tag, ph, "Free",
             "corrupted buffer footer", file, line);
        pf->magicnum = pools[poolnum].poolmagic;
    }

    // Verify that we are not trying to free someone else's buffer.
    //
    if (ph->pool_size != pools[poolnum].pool_size)
    {
        pool_err("BUG", LOG_ALWAYS, poolnum, ph->buf_tag, ph, "Free",
                 "Attempt to free into a different pool.", file, line);
        return;
    }

    if (  (LOG_ALLOCATE & mudconf.log_options)
       && mudstate.logging == 0
       && start_log("DBG", "ALLOC"))
    {
        Log.tinyprintf("Free[%d] (tag %s) in %s line %d buffer at %lx. (%s)",
            pools[poolnum].pool_size, ph->buf_tag, file, line, (long)ph,
            mudstate.debug_cmd);
        end_log();
    }

    // Make sure we aren't freeing an already free buffer.  If we are, log an
    // error, otherwise update the pool header and stats.
    //
    if (*pui == pools[poolnum].poolmagic)
    {
        pool_err("BUG", LOG_BUGS, poolnum, ph->buf_tag, ph, "Free",
                 "buffer already freed", file, line);
    }
    else
    {
        *pui = pools[poolnum].poolmagic;
        ph->nxtfree = pools[poolnum].free_head;
        pools[poolnum].free_head = ph;
        pools[poolnum].num_alloc--;
    }
}

void pool_free_lbuf	(	char *	buf,
		const char *	file,
		const int	line
	)

Definition at line 410 of file alloc.cpp.

References pool_header::buf_tag, statedata::debug_cmd, end_log(), ENDLOG, pooldata::free_head, LBUF_SIZE, Log, LOG_ALLOCATE, LOG_ALWAYS, LOG_BUGS, confdata::log_options, LOG_PROBLEMS, log_text(), statedata::logging, pool_header::magicnum, pool_footer::magicnum, mudconf, mudstate, pooldata::num_alloc, pooldata::num_lost, pool_header::nxtfree, confdata::paranoid_alloc, pool_check(), pool_err(), POOL_LBUF, pool_header::pool_size, pooldata::poolmagic, pools, start_log(), STARTLOG, CLogFile::tinyprintf(), pooldata::tot_alloc, and tprintf().

{
    if (buf == NULL)
    {
        STARTLOG(LOG_PROBLEMS, "BUG", "ALLOC")
        log_text(tprintf("Attempt to free_lbuf null pointer in %s line %d.", file, line));
        ENDLOG
        return;
    }
    POOLHDR *ph = ((POOLHDR *)(buf)) - 1;
    POOLFTR *pf = (POOLFTR *)(buf + LBUF_SIZE);
    unsigned int *pui = (unsigned int *)buf;

    if (mudconf.paranoid_alloc)
    {
        pool_check(ph->buf_tag, file, line);
    }

    if (  ph->magicnum != pools[POOL_LBUF].poolmagic
       || pf->magicnum != pools[POOL_LBUF].poolmagic
       || ph->pool_size != LBUF_SIZE
       || *pui == pools[POOL_LBUF].poolmagic)
    {
        if (ph->magicnum != pools[POOL_LBUF].poolmagic)
        {
            // The buffer header is damaged. Log the error and throw away the
            // buffer.
            //
            pool_err("BUG", LOG_ALWAYS, POOL_LBUF, ph->buf_tag, ph, "Free",
                     "corrupted buffer header", file, line);
            pools[POOL_LBUF].num_lost++;
            pools[POOL_LBUF].num_alloc--;
            pools[POOL_LBUF].tot_alloc--;
            return;
        }
        else if (pf->magicnum != pools[POOL_LBUF].poolmagic)
        {
            // The buffer footer is damaged.  Don't unlink, just repair.
            //
            pool_err("BUG", LOG_ALWAYS, POOL_LBUF, ph->buf_tag, ph, "Free",
                "corrupted buffer footer", file, line);
            pf->magicnum = pools[POOL_LBUF].poolmagic;
        }
        else if (ph->pool_size != LBUF_SIZE)
        {
            // We are trying to free someone else's buffer.
            //
            pool_err("BUG", LOG_ALWAYS, POOL_LBUF, ph->buf_tag, ph, "Free",
                "Attempt to free into a different pool.", file, line);
            return;
        }

        // If we are freeing a buffer that was already free, report an error.
        //
        if (*pui == pools[POOL_LBUF].poolmagic)
        {
            pool_err("BUG", LOG_BUGS, POOL_LBUF, ph->buf_tag, ph, "Free",
                     "buffer already freed", file, line);
            return;
        }
    }

    if (  (LOG_ALLOCATE & mudconf.log_options)
       && mudstate.logging == 0
       && start_log("DBG", "ALLOC"))
    {
        Log.tinyprintf("Free[%d] (tag %s) in %s line %d buffer at %lx. (%s)",
            LBUF_SIZE, ph->buf_tag, file, line, (long)ph, mudstate.debug_cmd);
        end_log();
    }

    // Update the pool header and stats.
    //
    *pui = pools[POOL_LBUF].poolmagic;
    ph->nxtfree = pools[POOL_LBUF].free_head;
    pools[POOL_LBUF].free_head = ph;
    pools[POOL_LBUF].num_alloc--;
}

void pool_init	(	int	poolnum,
		int	poolsize
	)

Definition at line 61 of file alloc.cpp.

References pooldata::chain_head, CRC32_ProcessInteger2(), pooldata::free_head, pooldata::max_alloc, pooldata::num_alloc, pooldata::num_lost, pooldata::pool_size, pooldata::poolmagic, pools, and pooldata::tot_alloc.

Referenced by dbconvert(), main(), and pcache_init().

{
    pools[poolnum].pool_size = poolsize;
    pools[poolnum].poolmagic = CRC32_ProcessInteger2(poolnum, poolsize);
    pools[poolnum].free_head = NULL;
    pools[poolnum].chain_head = NULL;
    pools[poolnum].tot_alloc = 0;
    pools[poolnum].num_alloc = 0;
    pools[poolnum].max_alloc = 0;
    pools[poolnum].num_lost = 0;
}

void pool_reset

(

void

)

Definition at line 553 of file alloc.cpp.

References pooldata::chain_head, pooldata::free_head, pooldata::max_alloc, MEMFREE, pool_header::next, pooldata::num_alloc, NUM_POOLS, pool_header::nxtfree, and pools.

Referenced by dispatch_FreeListReconstruction().

{
    int i;
    for (i = 0; i < NUM_POOLS; i++)
    {
        POOLHDR *newchain = NULL;
        POOLHDR *phnext;
        POOLHDR *ph;
        for (ph = pools[i].chain_head; ph != NULL; ph = phnext)
        {
            char *h = (char *)ph;
            phnext = ph->next;
            h += sizeof(POOLHDR);
            unsigned int *ibuf = (unsigned int *)h;
            if (*ibuf == pools[i].poolmagic)
            {
                MEMFREE(ph);
                ph = NULL;
            }
            else
            {
                ph->next = newchain;
                newchain = ph;
                ph->nxtfree = NULL;
            }
        }
        pools[i].chain_head = newchain;
        pools[i].free_head = NULL;
        pools[i].max_alloc = pools[i].num_alloc;
    }
}

static void pool_trace	(	dbref	player,
		int	poolnum,
		const char *	text
	)			[static]

Definition at line 489 of file alloc.cpp.

References pool_header::buf_tag, pool_header::magicnum, pool_header::next, notify, pooldata::poolmagic, pools, and tprintf().

Referenced by list_buftrace().

{
    POOLHDR *ph;
    int numfree = 0;
    notify(player, tprintf("----- %s -----", text));
    for (ph = pools[poolnum].chain_head; ph != NULL; ph = ph->next)
    {
        if (ph->magicnum != pools[poolnum].poolmagic)
        {
            notify(player, "*** CORRUPTED BUFFER HEADER, ABORTING SCAN ***");
            notify(player, tprintf("%d free %s (before corruption)",
                       numfree, text));
            return;
        }
        char *h = (char *)ph;
        h += sizeof(POOLHDR);
        unsigned int *ibuf = (unsigned int *)h;
        if (*ibuf != pools[poolnum].poolmagic)
        {
            notify(player, ph->buf_tag);
        }
        else
        {
            numfree++;
        }
    }
    notify(player, tprintf("%d free %s", numfree, text));
}

static void pool_vfy	(	int	poolnum,
		const char *	tag,
		const char *	file,
		const int	line
	)			[static]

Definition at line 101 of file alloc.cpp.

References pooldata::chain_head, LOG_ALWAYS, pool_footer::magicnum, pool_header::next, pool_err(), pooldata::pool_size, pooldata::poolmagic, and pools.

Referenced by pool_check().

{
    POOLHDR *ph, *lastph;
    POOLFTR *pf;
    char *h;

    lastph = NULL;
    size_t psize = pools[poolnum].pool_size;
    for (ph = pools[poolnum].chain_head; ph; lastph = ph, ph = ph->next)
    {
        h = (char *)ph;
        h += sizeof(POOLHDR);
        h += pools[poolnum].pool_size;
        pf = (POOLFTR *) h;

        if (ph->magicnum != pools[poolnum].poolmagic)
        {
            pool_err("BUG", LOG_ALWAYS, poolnum, tag, ph, "Verify",
                     "header corrupted (clearing freelist)", file, line);

            // Break the header chain at this point so we don't
            // generate an error for EVERY alloc and free, also we
            // can't continue the scan because the next pointer might
            // be trash too.
            //
            if (lastph)
            {
                lastph->next = NULL;
            }
            else
            {
                pools[poolnum].chain_head = NULL;
            }

            // It's not safe to continue.
            //
            return;
        }
        if (pf->magicnum != pools[poolnum].poolmagic)
        {
            pool_err("BUG", LOG_ALWAYS, poolnum, tag, ph, "Verify",
                "footer corrupted", file, line);
            pf->magicnum = pools[poolnum].poolmagic;
        }
        if (ph->pool_size != psize)
        {
            pool_err("BUG", LOG_ALWAYS, poolnum, tag, ph,
                 "Verify", "header has incorrect size", file, line);
        }
    }
}

---

Variable Documentation

const char* poolnames[] [static]

Initial value:

{
    "Lbufs", "Sbufs", "Mbufs", "Bools", "Descs", "Qentries", "Pcaches"
}

Definition at line 56 of file alloc.cpp.

Referenced by list_bufstats(), and list_buftrace().

POOL pools[NUM_POOLS] [static]

Definition at line 55 of file alloc.cpp.

Referenced by list_bufstats(), pool_alloc(), pool_alloc_lbuf(), pool_err(), pool_free(), pool_free_lbuf(), pool_init(), pool_reset(), pool_trace(), and pool_vfy().

---