1N/A/*-
1N/A * See the file LICENSE for redistribution information.
1N/A *
1N/A * Copyright (c) 1998
1N/A * Sleepycat Software. All rights reserved.
1N/A */
1N/A
1N/A#pragma ident "%Z%%M% %I% %E% SMI"
1N/A
1N/A#include "config.h"
1N/A
1N/A#ifndef lint
1N/Astatic const char sccsid[] = "@(#)db_am.c 10.15 (Sleepycat) 12/30/98";
1N/A#endif /* not lint */
1N/A
1N/A#ifndef NO_SYSTEM_INCLUDES
1N/A#include <sys/types.h>
1N/A
1N/A#include <errno.h>
1N/A#include <stdlib.h>
1N/A#include <string.h>
1N/A#endif
1N/A
1N/A#include "db_int.h"
1N/A#include "shqueue.h"
1N/A#include "db_page.h"
1N/A#include "db_shash.h"
1N/A#include "mp.h"
1N/A#include "btree.h"
1N/A#include "hash.h"
1N/A#include "db_am.h"
1N/A#include "db_ext.h"
1N/A
1N/Astatic int __db_c_close __P((DBC *));
1N/Astatic int __db_cursor __P((DB *, DB_TXN *, DBC **, u_int32_t));
1N/Astatic int __db_fd __P((DB *, int *));
1N/Astatic int __db_get __P((DB *, DB_TXN *, DBT *, DBT *, u_int32_t));
1N/Astatic int __db_put __P((DB *, DB_TXN *, DBT *, DBT *, u_int32_t));
1N/A
1N/A/*
1N/A * __db_init_wrapper --
1N/A * Wrapper layer to implement generic DB functions.
1N/A *
1N/A * PUBLIC: int __db_init_wrapper __P((DB *));
1N/A */
1N/Aint
1N/A__db_init_wrapper(dbp)
1N/A DB *dbp;
1N/A{
1N/A dbp->close = __db_close;
1N/A dbp->cursor = __db_cursor;
1N/A dbp->del = NULL; /* !!! Must be set by access method. */
1N/A dbp->fd = __db_fd;
1N/A dbp->get = __db_get;
1N/A dbp->join = __db_join;
1N/A dbp->put = __db_put;
1N/A dbp->stat = NULL; /* !!! Must be set by access method. */
1N/A dbp->sync = __db_sync;
1N/A
1N/A return (0);
1N/A}
1N/A
1N/A/*
1N/A * __db_cursor --
1N/A * Allocate and return a cursor.
1N/A */
1N/Astatic int
1N/A__db_cursor(dbp, txn, dbcp, flags)
1N/A DB *dbp;
1N/A DB_TXN *txn;
1N/A DBC **dbcp;
1N/A u_int32_t flags;
1N/A{
1N/A DBC *dbc, *adbc;
1N/A int ret;
1N/A db_lockmode_t mode;
1N/A u_int32_t op;
1N/A
1N/A DB_PANIC_CHECK(dbp);
1N/A
1N/A /* Take one from the free list if it's available. */
1N/A DB_THREAD_LOCK(dbp);
1N/A if ((dbc = TAILQ_FIRST(&dbp->free_queue)) != NULL)
1N/A TAILQ_REMOVE(&dbp->free_queue, dbc, links);
1N/A else {
1N/A DB_THREAD_UNLOCK(dbp);
1N/A
1N/A if ((ret = __os_calloc(1, sizeof(DBC), &dbc)) != 0)
1N/A return (ret);
1N/A
1N/A dbc->dbp = dbp;
1N/A dbc->c_close = __db_c_close;
1N/A
1N/A /* Set up locking information. */
1N/A if (F_ISSET(dbp, DB_AM_LOCKING | DB_AM_CDB)) {
1N/A /*
1N/A * If we are not threaded, then there is no need to
1N/A * create new locker ids. We know that no one else
1N/A * is running concurrently using this DB, so we can
1N/A * take a peek at any cursors on the active queue.
1N/A */
1N/A if (!F_ISSET(dbp, DB_AM_THREAD) &&
1N/A (adbc = TAILQ_FIRST(&dbp->active_queue)) != NULL)
1N/A dbc->lid = adbc->lid;
1N/A else
1N/A if ((ret = lock_id(dbp->dbenv->lk_info,
1N/A &dbc->lid)) != 0)
1N/A goto err;
1N/A
1N/A memcpy(dbc->lock.fileid, dbp->fileid, DB_FILE_ID_LEN);
1N/A if (F_ISSET(dbp, DB_AM_CDB)) {
1N/A dbc->lock_dbt.size = DB_FILE_ID_LEN;
1N/A dbc->lock_dbt.data = dbc->lock.fileid;
1N/A } else {
1N/A dbc->lock_dbt.size = sizeof(dbc->lock);
1N/A dbc->lock_dbt.data = &dbc->lock;
1N/A }
1N/A }
1N/A
1N/A switch (dbp->type) {
1N/A case DB_BTREE:
1N/A case DB_RECNO:
1N/A if ((ret = __bam_c_init(dbc)) != 0)
1N/A goto err;
1N/A break;
1N/A case DB_HASH:
1N/A if ((ret = __ham_c_init(dbc)) != 0)
1N/A goto err;
1N/A break;
1N/A default:
1N/A ret = EINVAL;
1N/A goto err;
1N/A }
1N/A
1N/A DB_THREAD_LOCK(dbp);
1N/A }
1N/A
1N/A if ((dbc->txn = txn) == NULL)
1N/A dbc->locker = dbc->lid;
1N/A else
1N/A dbc->locker = txn->txnid;
1N/A
1N/A TAILQ_INSERT_TAIL(&dbp->active_queue, dbc, links);
1N/A DB_THREAD_UNLOCK(dbp);
1N/A
1N/A /*
1N/A * If this is the concurrent DB product, then we do all locking
1N/A * in the interface, which is right here.
1N/A */
1N/A if (F_ISSET(dbp, DB_AM_CDB)) {
1N/A op = LF_ISSET(DB_OPFLAGS_MASK);
1N/A mode = (op == DB_WRITELOCK) ? DB_LOCK_WRITE :
1N/A (LF_ISSET(DB_RMW) ? DB_LOCK_IWRITE : DB_LOCK_READ);
1N/A if ((ret = lock_get(dbp->dbenv->lk_info, dbc->locker, 0,
1N/A &dbc->lock_dbt, mode, &dbc->mylock)) != 0) {
1N/A (void)__db_c_close(dbc);
1N/A return (EAGAIN);
1N/A }
1N/A if (LF_ISSET(DB_RMW))
1N/A F_SET(dbc, DBC_RMW);
1N/A if (op == DB_WRITELOCK)
1N/A F_SET(dbc, DBC_WRITER);
1N/A }
1N/A
1N/A *dbcp = dbc;
1N/A return (0);
1N/A
1N/Aerr: __os_free(dbc, sizeof(*dbc));
1N/A return (ret);
1N/A}
1N/A
1N/A/*
1N/A * __db_c_close --
1N/A * Close the cursor (recycle for later use).
1N/A */
1N/Astatic int
1N/A__db_c_close(dbc)
1N/A DBC *dbc;
1N/A{
1N/A DB *dbp;
1N/A int ret, t_ret;
1N/A
1N/A dbp = dbc->dbp;
1N/A
1N/A DB_PANIC_CHECK(dbp);
1N/A
1N/A ret = 0;
1N/A
1N/A /*
1N/A * We cannot release the lock until after we've called the
1N/A * access method specific routine, since btrees may have pending
1N/A * deletes.
1N/A */
1N/A
1N/A /* Remove the cursor from the active queue. */
1N/A DB_THREAD_LOCK(dbp);
1N/A TAILQ_REMOVE(&dbp->active_queue, dbc, links);
1N/A DB_THREAD_UNLOCK(dbp);
1N/A
1N/A /* Call the access specific cursor close routine. */
1N/A if ((t_ret = dbc->c_am_close(dbc)) != 0 && ret == 0)
1N/A t_ret = ret;
1N/A
1N/A /* Release the lock. */
1N/A if (F_ISSET(dbc->dbp, DB_AM_CDB) && dbc->mylock != LOCK_INVALID) {
1N/A ret = lock_put(dbc->dbp->dbenv->lk_info, dbc->mylock);
1N/A dbc->mylock = LOCK_INVALID;
1N/A }
1N/A
1N/A /* Clean up the cursor. */
1N/A dbc->flags = 0;
1N/A
1N/A#ifdef DEBUG
1N/A /*
1N/A * Check for leftover locks, unless we're running with transactions.
1N/A *
1N/A * If we're running tests, display any locks currently held. It's
1N/A * possible that some applications may hold locks for long periods,
1N/A * e.g., conference room locks, but the DB tests should never close
1N/A * holding locks.
1N/A */
1N/A if (F_ISSET(dbp, DB_AM_LOCKING) && dbc->lid == dbc->locker) {
1N/A DB_LOCKREQ request;
1N/A
1N/A request.op = DB_LOCK_DUMP;
1N/A if ((t_ret = lock_vec(dbp->dbenv->lk_info,
1N/A dbc->locker, 0, &request, 1, NULL)) != 0 && ret == 0)
1N/A ret = EAGAIN;
1N/A }
1N/A#endif
1N/A /* Move the cursor to the free queue. */
1N/A DB_THREAD_LOCK(dbp);
1N/A TAILQ_INSERT_TAIL(&dbp->free_queue, dbc, links);
1N/A DB_THREAD_UNLOCK(dbp);
1N/A
1N/A return (ret);
1N/A}
1N/A
1N/A#ifdef DEBUG
1N/A/*
1N/A * __db_cprint --
1N/A * Display the current cursor list.
1N/A *
1N/A * PUBLIC: int __db_cprint __P((DB *));
1N/A */
1N/Aint
1N/A__db_cprint(dbp)
1N/A DB *dbp;
1N/A{
1N/A static const FN fn[] = {
1N/A { DBC_RECOVER, "recover" },
1N/A { DBC_RMW, "read-modify-write" },
1N/A { 0 },
1N/A };
1N/A DBC *dbc;
1N/A
1N/A DB_THREAD_LOCK(dbp);
1N/A for (dbc = TAILQ_FIRST(&dbp->active_queue);
1N/A dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) {
1N/A fprintf(stderr,
1N/A "%#0x: dbp: %#0x txn: %#0x lid: %lu locker: %lu",
1N/A (u_int)dbc, (u_int)dbc->dbp, (u_int)dbc->txn,
1N/A (u_long)dbc->lid, (u_long)dbc->locker);
1N/A __db_prflags(dbc->flags, fn, stderr);
1N/A fprintf(stderr, "\n");
1N/A }
1N/A DB_THREAD_UNLOCK(dbp);
1N/A
1N/A return (0);
1N/A}
1N/A#endif /* DEBUG */
1N/A
1N/A/*
1N/A * __db_c_destroy --
1N/A * Destroy the cursor.
1N/A *
1N/A * PUBLIC: int __db_c_destroy __P((DBC *));
1N/A */
1N/Aint
1N/A__db_c_destroy(dbc)
1N/A DBC *dbc;
1N/A{
1N/A DB *dbp;
1N/A int ret;
1N/A
1N/A dbp = dbc->dbp;
1N/A
1N/A /* Remove the cursor from the free queue. */
1N/A DB_THREAD_LOCK(dbp);
1N/A TAILQ_REMOVE(&dbp->free_queue, dbc, links);
1N/A DB_THREAD_UNLOCK(dbp);
1N/A
1N/A /* Call the access specific cursor destroy routine. */
1N/A ret = dbc->c_am_destroy == NULL ? 0 : dbc->c_am_destroy(dbc);
1N/A
1N/A /* Free up allocated memory. */
1N/A if (dbc->rkey.data != NULL)
1N/A __os_free(dbc->rkey.data, dbc->rkey.ulen);
1N/A if (dbc->rdata.data != NULL)
1N/A __os_free(dbc->rdata.data, dbc->rdata.ulen);
1N/A __os_free(dbc, sizeof(*dbc));
1N/A
1N/A return (0);
1N/A}
1N/A
1N/A/*
1N/A * db_fd --
1N/A * Return a file descriptor for flock'ing.
1N/A */
1N/Astatic int
1N/A__db_fd(dbp, fdp)
1N/A DB *dbp;
1N/A int *fdp;
1N/A{
1N/A DB_PANIC_CHECK(dbp);
1N/A
1N/A /*
1N/A * XXX
1N/A * Truly spectacular layering violation.
1N/A */
1N/A return (__mp_xxx_fd(dbp->mpf, fdp));
1N/A}
1N/A
1N/A/*
1N/A * __db_get --
1N/A * Return a key/data pair.
1N/A */
1N/Astatic int
1N/A__db_get(dbp, txn, key, data, flags)
1N/A DB *dbp;
1N/A DB_TXN *txn;
1N/A DBT *key, *data;
1N/A u_int32_t flags;
1N/A{
1N/A DBC *dbc;
1N/A int ret, t_ret;
1N/A
1N/A DB_PANIC_CHECK(dbp);
1N/A
1N/A if ((ret = __db_getchk(dbp, key, data, flags)) != 0)
1N/A return (ret);
1N/A
1N/A if ((ret = dbp->cursor(dbp, txn, &dbc, 0)) != 0)
1N/A return (ret);
1N/A
1N/A DEBUG_LREAD(dbc, txn, "__db_get", key, NULL, flags);
1N/A
1N/A ret = dbc->c_get(dbc, key, data,
1N/A flags == 0 || flags == DB_RMW ? flags | DB_SET : flags);
1N/A
1N/A if ((t_ret = __db_c_close(dbc)) != 0 && ret == 0)
1N/A ret = t_ret;
1N/A
1N/A return (ret);
1N/A}
1N/A
1N/A/*
1N/A * __db_put --
1N/A * Store a key/data pair.
1N/A */
1N/Astatic int
1N/A__db_put(dbp, txn, key, data, flags)
1N/A DB *dbp;
1N/A DB_TXN *txn;
1N/A DBT *key, *data;
1N/A u_int32_t flags;
1N/A{
1N/A DBC *dbc;
1N/A DBT tdata;
1N/A int ret, t_ret;
1N/A
1N/A DB_PANIC_CHECK(dbp);
1N/A
1N/A if ((ret = __db_putchk(dbp, key, data,
1N/A flags, F_ISSET(dbp, DB_AM_RDONLY), F_ISSET(dbp, DB_AM_DUP))) != 0)
1N/A return (ret);
1N/A
1N/A if ((ret = dbp->cursor(dbp, txn, &dbc, DB_WRITELOCK)) != 0)
1N/A return (ret);
1N/A
1N/A DEBUG_LWRITE(dbc, txn, "__db_put", key, data, flags);
1N/A
1N/A if (flags == DB_NOOVERWRITE) {
1N/A /*
1N/A * Set DB_DBT_USERMEM, this might be a threaded application and
1N/A * the flags checking will catch us. We don't want the actual
1N/A * data, so request a partial of length 0.
1N/A */
1N/A memset(&tdata, 0, sizeof(tdata));
1N/A F_SET(&tdata, DB_DBT_USERMEM | DB_DBT_PARTIAL);
1N/A if ((ret = dbc->c_get(dbc, key, &tdata, DB_SET | DB_RMW)) == 0)
1N/A ret = DB_KEYEXIST;
1N/A else if (ret == DB_NOTFOUND)
1N/A ret = 0;
1N/A }
1N/A if (ret == 0)
1N/A ret = dbc->c_put(dbc, key, data, DB_KEYLAST);
1N/A
1N/A if ((t_ret = __db_c_close(dbc)) != 0 && ret == 0)
1N/A ret = t_ret;
1N/A
1N/A return (ret);
1N/A}
1N/A
1N/A/*
1N/A * __db_sync --
1N/A * Flush the database cache.
1N/A *
1N/A * PUBLIC: int __db_sync __P((DB *, u_int32_t));
1N/A */
1N/Aint
1N/A__db_sync(dbp, flags)
1N/A DB *dbp;
1N/A u_int32_t flags;
1N/A{
1N/A int ret;
1N/A
1N/A DB_PANIC_CHECK(dbp);
1N/A
1N/A if ((ret = __db_syncchk(dbp, flags)) != 0)
1N/A return (ret);
1N/A
1N/A /* If it wasn't possible to modify the file, we're done. */
1N/A if (F_ISSET(dbp, DB_AM_INMEM | DB_AM_RDONLY))
1N/A return (0);
1N/A
1N/A /* Flush any dirty pages from the cache to the backing file. */
1N/A if ((ret = memp_fsync(dbp->mpf)) == DB_INCOMPLETE)
1N/A ret = 0;
1N/A
1N/A return (ret);
1N/A}