Logo Search packages:      
Sourcecode: db2 version File versions  Download package

mp_fget.c

/*-
 * See the file LICENSE for redistribution information.
 *
 * Copyright (c) 1996, 1997, 1998
 *    Sleepycat Software.  All rights reserved.
 */
#include "config.h"

#ifndef lint
static const char sccsid[] = "@(#)mp_fget.c     10.48 (Sleepycat) 6/2/98";
#endif /* not lint */

#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>

#include <errno.h>
#include <string.h>
#endif

#include "db_int.h"
#include "shqueue.h"
#include "db_shash.h"
#include "mp.h"
#include "common_ext.h"

/*
 * memp_fget --
 *    Get a page from the file.
 */
int
memp_fget(dbmfp, pgnoaddr, flags, addrp)
      DB_MPOOLFILE *dbmfp;
      db_pgno_t *pgnoaddr;
      u_int32_t flags;
      void *addrp;
{
      BH *bhp;
      DB_MPOOL *dbmp;
      MPOOL *mp;
      MPOOLFILE *mfp;
      size_t bucket, mf_offset;
      u_int32_t st_hsearch;
      int b_incr, first, ret;

      dbmp = dbmfp->dbmp;
      mp = dbmp->mp;
      mfp = dbmfp->mfp;

      /*
       * Validate arguments.
       *
       * !!!
       * Don't test for DB_MPOOL_CREATE and DB_MPOOL_NEW flags for readonly
       * files here, and create non-existent pages in readonly files if the
       * flags are set, later.  The reason is that the hash access method
       * wants to get empty pages that don't really exist in readonly files.
       * The only alternative is for hash to write the last "bucket" all the
       * time, which we don't want to do because one of our big goals in life
       * is to keep database files small.  It's sleazy as hell, but we catch
       * any attempt to actually write the file in memp_fput().
       */
#define     OKFLAGS     (DB_MPOOL_CREATE | DB_MPOOL_LAST | DB_MPOOL_NEW)
      if (flags != 0) {
            if ((ret =
                __db_fchk(dbmp->dbenv, "memp_fget", flags, OKFLAGS)) != 0)
                  return (ret);

            switch (flags) {
            case DB_MPOOL_CREATE:
            case DB_MPOOL_LAST:
            case DB_MPOOL_NEW:
            case 0:
                  break;
            default:
                  return (__db_ferr(dbmp->dbenv, "memp_fget", 1));
            }
      }

#ifdef DIAGNOSTIC
      /*
       * XXX
       * We want to switch threads as often as possible.  Sleep every time
       * we get a new page to make it more likely.
       */
      if (DB_GLOBAL(db_pageyield) &&
          (__db_yield == NULL || __db_yield() != 0))
            __db_sleep(0, 1);
#endif

      /* Initialize remaining local variables. */
      mf_offset = R_OFFSET(dbmp, mfp);
      bhp = NULL;
      st_hsearch = 0;
      b_incr = ret = 0;

      /* Determine the hash bucket where this page will live. */
      bucket = BUCKET(mp, mf_offset, *pgnoaddr);

      LOCKREGION(dbmp);

      /*
       * Check for the last or last + 1 page requests.
       *
       * Examine and update the file's last_pgno value.  We don't care if
       * the last_pgno value immediately changes due to another thread --
       * at this instant in time, the value is correct.  We do increment the
       * current last_pgno value if the thread is asking for a new page,
       * however, to ensure that two threads creating pages don't get the
       * same one.
       */
      if (LF_ISSET(DB_MPOOL_LAST | DB_MPOOL_NEW)) {
            if (LF_ISSET(DB_MPOOL_NEW))
                  ++mfp->last_pgno;
            *pgnoaddr = mfp->last_pgno;
            bucket = BUCKET(mp, mf_offset, mfp->last_pgno);

            if (LF_ISSET(DB_MPOOL_NEW))
                  goto alloc;
      }

      /*
       * If mmap'ing the file and the page is not past the end of the file,
       * just return a pointer.
       *
       * The page may be past the end of the file, so check the page number
       * argument against the original length of the file.  If we previously
       * returned pages past the original end of the file, last_pgno will
       * have been updated to match the "new" end of the file, and checking
       * against it would return pointers past the end of the mmap'd region.
       *
       * If another process has opened the file for writing since we mmap'd
       * it, we will start playing the game by their rules, i.e. everything
       * goes through the cache.  All pages previously returned will be safe,
       * as long as the correct locking protocol was observed.
       *
       * XXX
       * We don't discard the map because we don't know when all of the
       * pages will have been discarded from the process' address space.
       * It would be possible to do so by reference counting the open
       * pages from the mmap, but it's unclear to me that it's worth it.
       */
      if (dbmfp->addr != NULL && F_ISSET(mfp, MP_CAN_MMAP)) {
            if (*pgnoaddr > mfp->orig_last_pgno) {
                  /*
                   * !!!
                   * See the comment above about non-existent pages and
                   * the hash access method.
                   */
                  if (!LF_ISSET(DB_MPOOL_CREATE)) {
                        __db_err(dbmp->dbenv,
                            "%s: page %lu doesn't exist",
                            __memp_fn(dbmfp), (u_long)*pgnoaddr);
                        ret = EINVAL;
                        goto err;
                  }
            } else {
                  *(void **)addrp =
                      R_ADDR(dbmfp, *pgnoaddr * mfp->stat.st_pagesize);
                  ++mp->stat.st_map;
                  ++mfp->stat.st_map;
                  goto done;
            }
      }

      /* Search the hash chain for the page. */
      for (bhp = SH_TAILQ_FIRST(&dbmp->htab[bucket], __bh);
          bhp != NULL; bhp = SH_TAILQ_NEXT(bhp, hq, __bh)) {
            ++st_hsearch;
            if (bhp->pgno != *pgnoaddr || bhp->mf_offset != mf_offset)
                  continue;

            /* Increment the reference count. */
            if (bhp->ref == UINT16_T_MAX) {
                  __db_err(dbmp->dbenv,
                      "%s: page %lu: reference count overflow",
                      __memp_fn(dbmfp), (u_long)bhp->pgno);
                  ret = EINVAL;
                  goto err;
            }

            /*
             * Increment the reference count.  We may discard the region
             * lock as we evaluate and/or read the buffer, so we need to
             * ensure that it doesn't move and that its contents remain
             * unchanged.
             */
            ++bhp->ref;
            b_incr = 1;

            /*
             * Any buffer we find might be trouble.
             *
             * BH_LOCKED --
             * I/O is in progress.  Because we've incremented the buffer
             * reference count, we know the buffer can't move.  Unlock
             * the region lock, wait for the I/O to complete, and reacquire
             * the region.
             */
            for (first = 1; F_ISSET(bhp, BH_LOCKED); first = 0) {
                  UNLOCKREGION(dbmp);

                  /*
                   * Explicitly yield the processor if it's not the first
                   * pass through this loop -- if we don't, we might end
                   * up running to the end of our CPU quantum as we will
                   * simply be swapping between the two locks.
                   */
                  if (!first && (__db_yield == NULL || __db_yield() != 0))
                        __db_sleep(0, 1);

                  LOCKBUFFER(dbmp, bhp);
                  /* Wait for I/O to finish... */
                  UNLOCKBUFFER(dbmp, bhp);
                  LOCKREGION(dbmp);
            }

            /*
             * BH_TRASH --
             * The contents of the buffer are garbage.  Shouldn't happen,
             * and this read is likely to fail, but might as well try.
             */
            if (F_ISSET(bhp, BH_TRASH))
                  goto reread;

            /*
             * BH_CALLPGIN --
             * The buffer was converted so it could be written, and the
             * contents need to be converted again.
             */
            if (F_ISSET(bhp, BH_CALLPGIN)) {
                  if ((ret = __memp_pg(dbmfp, bhp, 1)) != 0)
                        goto err;
                  F_CLR(bhp, BH_CALLPGIN);
            }

            ++mp->stat.st_cache_hit;
            ++mfp->stat.st_cache_hit;
            *(void **)addrp = bhp->buf;
            goto done;
      }

alloc:      /* Allocate new buffer header and data space. */
      if ((ret = __memp_ralloc(dbmp, sizeof(BH) -
          sizeof(u_int8_t) + mfp->stat.st_pagesize, NULL, &bhp)) != 0)
            goto err;

#ifdef DIAGNOSTIC
      if ((ALIGNTYPE)bhp->buf & (sizeof(size_t) - 1)) {
            __db_err(dbmp->dbenv,
                "Internal error: BH data NOT size_t aligned.");
            ret = EINVAL;
            goto err;
      }
#endif
      /* Initialize the BH fields. */
      memset(bhp, 0, sizeof(BH));
      LOCKINIT(dbmp, &bhp->mutex);
      bhp->ref = 1;
      bhp->pgno = *pgnoaddr;
      bhp->mf_offset = mf_offset;

      /*
       * Prepend the bucket header to the head of the appropriate MPOOL
       * bucket hash list.  Append the bucket header to the tail of the
       * MPOOL LRU chain.
       */
      SH_TAILQ_INSERT_HEAD(&dbmp->htab[bucket], bhp, hq, __bh);
      SH_TAILQ_INSERT_TAIL(&mp->bhq, bhp, q);

      /*
       * If we created the page, zero it out and continue.
       *
       * !!!
       * Note: DB_MPOOL_NEW specifically doesn't call the pgin function.
       * If DB_MPOOL_CREATE is used, then the application's pgin function
       * has to be able to handle pages of 0's -- if it uses DB_MPOOL_NEW,
       * it can detect all of its page creates, and not bother.
       *
       * Otherwise, read the page into memory, optionally creating it if
       * DB_MPOOL_CREATE is set.
       */
      if (LF_ISSET(DB_MPOOL_NEW)) {
            if (mfp->clear_len == 0)
                  memset(bhp->buf, 0, mfp->stat.st_pagesize);
            else {
                  memset(bhp->buf, 0, mfp->clear_len);
#ifdef DIAGNOSTIC
                  memset(bhp->buf + mfp->clear_len, 0xff,
                      mfp->stat.st_pagesize - mfp->clear_len);
#endif
            }

            ++mp->stat.st_page_create;
            ++mfp->stat.st_page_create;
      } else {
            /*
             * It's possible for the read function to fail, which means
             * that we fail as well.  Note, the __memp_pgread() function
             * discards the region lock, so the buffer must be pinned
             * down so that it cannot move and its contents are unchanged.
             */
reread:           if ((ret = __memp_pgread(dbmfp,
                bhp, LF_ISSET(DB_MPOOL_CREATE))) != 0) {
                  /*
                   * !!!
                   * Discard the buffer unless another thread is waiting
                   * on our I/O to complete.  Regardless, the header has
                   * the BH_TRASH flag set.
                   */
                  if (bhp->ref == 1)
                        __memp_bhfree(dbmp, mfp, bhp, 1);
                  goto err;
            }

            ++mp->stat.st_cache_miss;
            ++mfp->stat.st_cache_miss;
      }

      /*
       * If we're returning a page after our current notion of the last-page,
       * update our information.  Note, there's no way to un-instantiate this
       * page, it's going to exist whether it's returned to us dirty or not.
       */
      if (bhp->pgno > mfp->last_pgno)
            mfp->last_pgno = bhp->pgno;

      ++mp->stat.st_page_clean;
      *(void **)addrp = bhp->buf;

done: /* Update the chain search statistics. */
      if (st_hsearch) {
            ++mp->stat.st_hash_searches;
            if (st_hsearch > mp->stat.st_hash_longest)
                  mp->stat.st_hash_longest = st_hsearch;
            mp->stat.st_hash_examined += st_hsearch;
      }

      UNLOCKREGION(dbmp);

      LOCKHANDLE(dbmp, dbmfp->mutexp);
      ++dbmfp->pinref;
      UNLOCKHANDLE(dbmp, dbmfp->mutexp);

      return (0);

err:  /* Discard our reference. */
      if (b_incr)
            --bhp->ref;
      UNLOCKREGION(dbmp);

      *(void **)addrp = NULL;
      return (ret);
}

Generated by  Doxygen 1.6.0   Back to index