mpool.c File Reference

#include <sys/param.h>
#include <sys/queue.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "../include/db.h"
#include <mpool.h>

Include dependency graph for mpool.c:

Go to the source code of this file.

Macros
#define	__APPLE__
#define	__MPOOLINTERFACE_PRIVATE
#define	mpool_close   __mpool_close
#define	mpool_filter   __mpool_filter
#define	mpool_get   __mpool_get
#define	mpool_new   __mpool_new
#define	mpool_open   __mpool_open
#define	mpool_put   __mpool_put
#define	mpool_sync   __mpool_sync

Functions
static BKT *mpool_bkt	__P ((MPOOL *))
static int mpool_write	__P ((MPOOL *, BKT *))
static BKT *mpool_look	__P ((MPOOL *, pgno_t))
static BKT *	mpool_bkt (MPOOL *mp)
int	mpool_close (MPOOL *mp)
void	mpool_filter (MPOOL *mp, void *pgin, void *pgout, void *pgcookie)
void *	mpool_get (MPOOL *mp, pgno_t pgno, u_int flags)
static BKT *	mpool_look (MPOOL *mp, pgno_t pgno)
void *	mpool_new (MPOOL *mp, pgno_t *pgnoaddr)
MPOOL *	mpool_open (void *key, int fd, pgno_t pagesize, pgno_t maxcache)
int	mpool_put (MPOOL *mp, void *page, u_int flags)
int	mpool_sync (MPOOL *mp)
static int	mpool_write (MPOOL *mp, BKT *bp)

Macro Definition Documentation

__APPLE__

#define __APPLE__

Definition at line 316 of file mpool.c.

__MPOOLINTERFACE_PRIVATE

#define __MPOOLINTERFACE_PRIVATE

Definition at line 50 of file mpool.c.

mpool_close

#define mpool_close   __mpool_close

Definition at line 62 of file mpool.c.

mpool_filter

#define mpool_filter   __mpool_filter

Definition at line 57 of file mpool.c.

mpool_get

#define mpool_get   __mpool_get

Definition at line 59 of file mpool.c.

mpool_new

#define mpool_new   __mpool_new

Definition at line 58 of file mpool.c.

mpool_open

#define mpool_open   __mpool_open

Definition at line 56 of file mpool.c.

mpool_put

#define mpool_put   __mpool_put

Definition at line 60 of file mpool.c.

mpool_sync

#define mpool_sync   __mpool_sync

Definition at line 61 of file mpool.c.

Function Documentation

__P() [1/3]

static BKT *mpool_bkt __P ( (MPOOL *)  )

static

__P() [2/3]

static int mpool_write __P ( (MPOOL *, BKT *)  )

static

__P() [3/3]

static BKT *mpool_look __P ( (MPOOL *, pgno_t)  )

static

mpool_bkt()

static BKT * mpool_bkt ( MPOOL *  mp )

static

Definition at line 343 of file mpool.c.

{
    struct _hqh *head;
    BKT *bp;
 
    /* If under the max cached, always create a new page. */
    if (mp->curcache < mp->maxcache)
        goto new;
 
    /*
     * If the cache is max'd out, walk the lru list for a buffer we
     * can flush.  If we find one, write it (if necessary) and take it
     * off any lists.  If we don't find anything we grow the cache anyway.
     * The cache never shrinks.
     */
    for (bp = mp->lqh.cqh_first;
        bp != (void *)&mp->lqh; bp = bp->q.cqe_next)
        if (!(bp->flags & MPOOL_PINNED)) {
            /* Flush if dirty. */
            if (bp->flags & MPOOL_DIRTY &&
                mpool_write(mp, bp) == RET_ERROR)
                return (NULL);
#ifdef STATISTICS
            ++mp->pageflush;
#endif
            /* Remove from the hash and lru queues. */
            head = &mp->hqh[HASHKEY(bp->pgno)];
            CIRCLEQ_REMOVE(head, bp, hq);
            CIRCLEQ_REMOVE(&mp->lqh, bp, q);
#ifdef DEBUG
            { void *spage;
                spage = bp->page;
                memset(bp, 0xff, sizeof(BKT) + mp->pagesize);
                bp->page = spage;
            }
#endif
            return (bp);
        }
 
new:    if ((bp = (BKT *) calloc(1, sizeof(BKT) + mp->pagesize)) == NULL)
        return (NULL);
#ifdef STATISTICS
    ++mp->pagealloc;
#endif
#if defined(DEBUG) || defined(PURIFY)
    memset(bp, 0xff, sizeof(BKT) + mp->pagesize);
#endif
    bp->page = (char *)bp + sizeof(BKT);
    ++mp->curcache;
    return (bp);
}

References calloc, CIRCLEQ_REMOVE, MPOOL::curcache, _bkt::flags, HASHKEY, MPOOL::maxcache, MPOOL_DIRTY, MPOOL_PINNED, mpool_write(), NULL, _bkt::page, MPOOL::pagesize, _bkt::pgno, and RET_ERROR.

Referenced by mpool_get(), and mpool_new().

mpool_close()

int mpool_close

(

MPOOL *

mp

)

Definition at line 279 of file mpool.c.

{
    BKT *bp;
 
    /* Free up any space allocated to the lru pages. */
    while ((bp = mp->lqh.cqh_first) != (void *)&mp->lqh) {
        CIRCLEQ_REMOVE(&mp->lqh, mp->lqh.cqh_first, q);
        free(bp);
    }
 
    /* Free the MPOOL cookie. */
    free(mp);
    return (RET_SUCCESS);
}

References CIRCLEQ_REMOVE, free(), and RET_SUCCESS.

Referenced by __bt_close().

mpool_filter()

void mpool_filter	(	MPOOL *	mp,
		void *	pgin,
		void *	pgout,
		void *	pgcookie
	)

Definition at line 114 of file mpool.c.

{
    mp->pgin = pgin;
    mp->pgout = pgout;
    mp->pgcookie = pgcookie;
}

Referenced by __bt_open().

mpool_get()

void * mpool_get	(	MPOOL *	mp,
		pgno_t	pgno,
		u_int	flags
	)

Definition at line 165 of file mpool.c.

{
    struct _hqh *head;
    BKT *bp;
    off_t off;
    int nr;
 
    /* Check for attempt to retrieve a non-existent page. */
    if (pgno >= mp->npages) {
        errno = EINVAL;
        return (NULL);
    }
 
#ifdef STATISTICS
    ++mp->pageget;
#endif
 
    /* Check for a page that is cached. */
    if ((bp = mpool_look(mp, pgno)) != NULL) {
#ifdef DEBUG
        if (bp->flags & MPOOL_PINNED) {
            (void)fprintf(stderr,
                "mpool_get: page %d already pinned\n", bp->pgno);
            abort();
        }
#endif
        /*
         * Move the page to the head of the hash chain and the tail
         * of the lru chain.
         */
        head = &mp->hqh[HASHKEY(bp->pgno)];
        CIRCLEQ_REMOVE(head, bp, hq);
        CIRCLEQ_INSERT_HEAD(head, bp, hq);
        CIRCLEQ_REMOVE(&mp->lqh, bp, q);
        CIRCLEQ_INSERT_TAIL(&mp->lqh, bp, q);
 
        /* Return a pinned page. */
        bp->flags |= MPOOL_PINNED;
        return (bp->page);
    }
 
    /* Get a page from the cache. */
    if ((bp = mpool_bkt(mp)) == NULL)
        return (NULL);
 
    /* Read in the contents. */
#ifdef STATISTICS
    ++mp->pageread;
#endif
    off = mp->pagesize * pgno;
    if (lseek(mp->fd, off, SEEK_SET) != off)
        return (NULL);
    if ((u_long) (nr = read(mp->fd, bp->page, mp->pagesize))
        != mp->pagesize) {
        if (nr >= 0)
            errno = EFTYPE;
        return (NULL);
    }
 
    /* Set the page number, pin the page. */
    bp->pgno = pgno;
    bp->flags = MPOOL_PINNED;
 
    /*
     * Add the page to the head of the hash chain and the tail
     * of the lru chain.
     */
    head = &mp->hqh[HASHKEY(bp->pgno)];
    CIRCLEQ_INSERT_HEAD(head, bp, hq);
    CIRCLEQ_INSERT_TAIL(&mp->lqh, bp, q);
 
    /* Run through the user's filter. */
    if (mp->pgin != NULL)
        (mp->pgin)(mp->pgcookie, bp->pgno, bp->page);
 
    return (bp->page);
}

References CIRCLEQ_INSERT_HEAD, CIRCLEQ_INSERT_TAIL, CIRCLEQ_REMOVE, EFTYPE, errno, MPOOL::fd, _bkt::flags, HASHKEY, mpool_bkt(), mpool_look(), MPOOL_PINNED, MPOOL::npages, NULL, _bkt::page, MPOOL::pagesize, MPOOL::pgcookie, and _bkt::pgno.

Referenced by __bt_curdel(), __bt_delete(), __bt_first(), __bt_new(), __bt_pdelete(), __bt_put(), __bt_relink(), __bt_search(), __bt_seqadv(), __bt_seqset(), __bt_snext(), __bt_split(), __bt_sprev(), __bt_stkacq(), __ovfl_delete(), __ovfl_get(), __rec_open(), __rec_search(), bt_fast(), bt_meta(), bt_page(), bt_preserve(), and nroot().

mpool_look()

static BKT * mpool_look ( MPOOL *  mp, pgno_t  pgno  )

static

Definition at line 430 of file mpool.c.

{
    struct _hqh *head;
    BKT *bp;
 
    head = &mp->hqh[HASHKEY(pgno)];
    for (bp = head->cqh_first; bp != (void *)head; bp = bp->hq.cqe_next)
        if (bp->pgno == pgno) {
#ifdef STATISTICS
            ++mp->cachehit;
#endif
            return (bp);
        }
#ifdef STATISTICS
    ++mp->cachemiss;
#endif
    return (NULL);
}

References HASHKEY, NULL, and _bkt::pgno.

Referenced by mpool_get().

mpool_new()

void * mpool_new	(	MPOOL *	mp,
		pgno_t *	pgnoaddr
	)

Definition at line 130 of file mpool.c.

{
    struct _hqh *head;
    BKT *bp;
 
    if (mp->npages == MAX_PAGE_NUMBER) {
        (void)fprintf(stderr, "mpool_new: page allocation overflow.\n");
        abort();
    }
#ifdef STATISTICS
    ++mp->pagenew;
#endif
    /*
     * Get a BKT from the cache.  Assign a new page number, attach
     * it to the head of the hash chain, the tail of the lru chain,
     * and return.
     */
    if ((bp = mpool_bkt(mp)) == NULL)
        return (NULL);
    *pgnoaddr = bp->pgno = mp->npages++;
    bp->flags = MPOOL_PINNED;
 
    head = &mp->hqh[HASHKEY(bp->pgno)];
    CIRCLEQ_INSERT_HEAD(head, bp, hq);
    CIRCLEQ_INSERT_TAIL(&mp->lqh, bp, q);
    return (bp->page);
}

References CIRCLEQ_INSERT_HEAD, CIRCLEQ_INSERT_TAIL, _bkt::flags, HASHKEY, MAX_PAGE_NUMBER, mpool_bkt(), MPOOL_PINNED, MPOOL::npages, NULL, _bkt::page, and _bkt::pgno.

Referenced by __bt_new(), and nroot().

mpool_open()

MPOOL * mpool_open	(	void *	key,
		int	fd,
		pgno_t	pagesize,
		pgno_t	maxcache
	)

Definition at line 74 of file mpool.c.

{
    struct stat sb;
    MPOOL *mp;
    int entry;
 
    /*
     * Get information about the file.
     *
     * XXX
     * We don't currently handle pipes, although we should.
     */
    if (fstat(fd, &sb))
        return (NULL);
    if (!S_ISREG(sb.st_mode)) {
        errno = ESPIPE;
        return (NULL);
    }
 
    /* Allocate and initialize the MPOOL cookie. */
    if ((mp = (MPOOL *)calloc(1, sizeof(MPOOL))) == NULL)
        return (NULL);
    CIRCLEQ_INIT(&mp->lqh);
    for (entry = 0; entry < HASHSIZE; ++entry)
        CIRCLEQ_INIT(&mp->hqh[entry]);
    mp->maxcache = maxcache;
    mp->npages = sb.st_size / pagesize;
    mp->pagesize = pagesize;
    mp->fd = fd;
    return (mp);
}

References calloc, CIRCLEQ_INIT, errno, HASHSIZE, and NULL.

Referenced by __bt_open().

mpool_put()

int mpool_put	(	MPOOL *	mp,
		void *	page,
		u_int	flags
	)

Definition at line 251 of file mpool.c.

{
    BKT *bp;
 
#ifdef STATISTICS
    ++mp->pageput;
#endif
    bp = (BKT *)((char *)page - sizeof(BKT));
#ifdef DEBUG
    if (!(bp->flags & MPOOL_PINNED)) {
        (void)fprintf(stderr,
            "mpool_put: page %d not pinned\n", bp->pgno);
        abort();
    }
#endif
    bp->flags &= ~MPOOL_PINNED;
    bp->flags |= flags & MPOOL_DIRTY;
    return (RET_SUCCESS);
}

References _bkt::flags, MPOOL_DIRTY, MPOOL_PINNED, _bkt::pgno, and RET_SUCCESS.

Referenced by __bt_bdelete(), __bt_close(), __bt_curdel(), __bt_delete(), __bt_fd(), __bt_first(), __bt_free(), __bt_get(), __bt_pdelete(), __bt_put(), __bt_relink(), __bt_search(), __bt_seq(), __bt_seqadv(), __bt_seqset(), __bt_snext(), __bt_split(), __bt_sprev(), __bt_stkacq(), __bt_sync(), __ovfl_delete(), __ovfl_get(), __ovfl_put(), __rec_close(), __rec_delete(), __rec_fd(), __rec_get(), __rec_iput(), __rec_open(), __rec_put(), __rec_search(), __rec_seq(), __rec_sync(), bt_broot(), bt_fast(), bt_meta(), bt_page(), bt_preserve(), bt_rroot(), nroot(), and rec_rdelete().

mpool_sync()

int mpool_sync

(

MPOOL *

mp

)

Definition at line 300 of file mpool.c.

{
    BKT *bp;
 
    /* Walk the lru chain, flushing any dirty pages to disk. */
    for (bp = mp->lqh.cqh_first;
        bp != (void *)&mp->lqh; bp = bp->q.cqe_next)
        if (bp->flags & MPOOL_DIRTY &&
            mpool_write(mp, bp) == RET_ERROR)
            return (RET_ERROR);
 
    /* Sync the file descriptor. */
    return (fsync(mp->fd) ? RET_ERROR : RET_SUCCESS);
}

References MPOOL::fd, _bkt::flags, MPOOL_DIRTY, mpool_write(), RET_ERROR, and RET_SUCCESS.

Referenced by __bt_sync().

mpool_write()

static int mpool_write ( MPOOL *  mp, BKT *  bp  )

static

Definition at line 401 of file mpool.c.

{
    off_t off;
 
#ifdef STATISTICS
    ++mp->pagewrite;
#endif
 
    /* Run through the user's filter. */
    if (mp->pgout)
        (mp->pgout)(mp->pgcookie, bp->pgno, bp->page);
 
    off = mp->pagesize * bp->pgno;
    if (lseek(mp->fd, off, SEEK_SET) != off)
        return (RET_ERROR);
    if ((u_long) write(mp->fd, bp->page, mp->pagesize) != mp->pagesize)
        return (RET_ERROR);
 
    bp->flags &= ~MPOOL_DIRTY;
    return (RET_SUCCESS);
}

References MPOOL::fd, _bkt::flags, _bkt::page, MPOOL::pagesize, MPOOL::pgcookie, _bkt::pgno, RET_ERROR, and RET_SUCCESS.

Referenced by mpool_bkt(), and mpool_sync().