db/log/log_register.c

	log_register.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*-
 * 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[] = "@(#)log_register.c    10.22 (Sleepycat) 9/27/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 "log.h"
#include "common_ext.h"

/*
 * log_register --
 *  Register a file name.
 */
int
log_register(dblp, dbp, name, type, idp)
    DB_LOG *dblp;
    DB *dbp;
    const char *name;
    DBTYPE type;
    u_int32_t *idp;
{
    DBT fid_dbt, r_name;
    DB_LSN r_unused;
    FNAME *fnp, *reuse_fnp;
    size_t len;
    u_int32_t maxid;
    int inserted, ret;
    char *fullname;
    void *namep;

    inserted = 0;
    fullname = NULL;
    fnp = namep = reuse_fnp = NULL;

    LOG_PANIC_CHECK(dblp);

    /* Check the arguments. */
    if (type != DB_BTREE && type != DB_HASH && type != DB_RECNO) {
        __db_err(dblp->dbenv, "log_register: unknown DB file type");
        return (EINVAL);
    }

    /* Get the log file id. */
    if ((ret = __db_appname(dblp->dbenv,
        DB_APP_DATA, NULL, name, 0, NULL, &fullname)) != 0)
        return (ret);

    LOCK_LOGREGION(dblp);

    /*
     * See if we've already got this file in the log, finding the
     * (maximum+1) in-use file id and some available file id (if we
     * find an available fid, we'll use it, else we'll have to allocate
     * one after the maximum that we found).
     */
    for (maxid = 0, fnp = SH_TAILQ_FIRST(&dblp->lp->fq, __fname);
        fnp != NULL; fnp = SH_TAILQ_NEXT(fnp, q, __fname)) {
        if (fnp->ref == 0) {        /* Entry is not in use. */
            if (reuse_fnp == NULL)
                reuse_fnp = fnp;
            continue;
        }
        if (!memcmp(dbp->fileid, fnp->ufid, DB_FILE_ID_LEN)) {
            ++fnp->ref;
            goto found;
        }
        if (maxid <= fnp->id)
            maxid = fnp->id + 1;
    }

    /* Fill in fnp structure. */

    if (reuse_fnp != NULL)      /* Reuse existing one. */
        fnp = reuse_fnp;
    else if ((ret = __db_shalloc(dblp->addr, sizeof(FNAME), 0, &fnp)) != 0)
        goto err;
    else                /* Allocate a new one. */
        fnp->id = maxid;

    fnp->ref = 1;
    fnp->s_type = type;
    memcpy(fnp->ufid, dbp->fileid, DB_FILE_ID_LEN);

    len = strlen(name) + 1;
    if ((ret = __db_shalloc(dblp->addr, len, 0, &namep)) != 0)
        goto err;
    fnp->name_off = R_OFFSET(dblp, namep);
    memcpy(namep, name, len);

    /* Only do the insert if we allocated a new fnp. */
    if (reuse_fnp == NULL)
        SH_TAILQ_INSERT_HEAD(&dblp->lp->fq, fnp, q, __fname);
    inserted = 1;

found:  /* Log the registry. */
    if (!F_ISSET(dblp, DBC_RECOVER)) {
        r_name.data = (void *)name;     /* XXX: Yuck! */
        r_name.size = strlen(name) + 1;
        memset(&fid_dbt, 0, sizeof(fid_dbt));
        fid_dbt.data = dbp->fileid;
        fid_dbt.size = DB_FILE_ID_LEN;
        if ((ret = __log_register_log(dblp, NULL, &r_unused,
            0, LOG_OPEN, &r_name, &fid_dbt, fnp->id, type)) != 0)
            goto err;
        if ((ret = __log_add_logid(dblp, dbp, name, fnp->id)) != 0)
            goto err;
    }

    if (0) {
err:        /*
         * XXX
         * We should grow the region.
         */
        if (inserted)
            SH_TAILQ_REMOVE(&dblp->lp->fq, fnp, q, __fname);
        if (namep != NULL)
            __db_shalloc_free(dblp->addr, namep);
        if (fnp != NULL)
            __db_shalloc_free(dblp->addr, fnp);
    }

    if (idp != NULL)
        *idp = fnp->id;
    UNLOCK_LOGREGION(dblp);

    if (fullname != NULL)
        __os_freestr(fullname);

    return (ret);
}

/*
 * log_unregister --
 *  Discard a registered file name.
 */
int
log_unregister(dblp, fid)
    DB_LOG *dblp;
    u_int32_t fid;
{
    DBT fid_dbt, r_name;
    DB_LSN r_unused;
    FNAME *fnp;
    int ret;

    LOG_PANIC_CHECK(dblp);

    ret = 0;
    LOCK_LOGREGION(dblp);

    /* Find the entry in the log. */
    for (fnp = SH_TAILQ_FIRST(&dblp->lp->fq, __fname);
        fnp != NULL; fnp = SH_TAILQ_NEXT(fnp, q, __fname))
        if (fid == fnp->id)
            break;
    if (fnp == NULL) {
        __db_err(dblp->dbenv, "log_unregister: non-existent file id");
        ret = EINVAL;
        goto ret1;
    }

    /* Unlog the registry. */
    if (!F_ISSET(dblp, DBC_RECOVER)) {
        memset(&r_name, 0, sizeof(r_name));
        r_name.data = R_ADDR(dblp, fnp->name_off);
        r_name.size = strlen(r_name.data) + 1;
        memset(&fid_dbt, 0, sizeof(fid_dbt));
        fid_dbt.data = fnp->ufid;
        fid_dbt.size = DB_FILE_ID_LEN;
        if ((ret = __log_register_log(dblp, NULL, &r_unused,
            0, LOG_CLOSE, &r_name, &fid_dbt, fid, fnp->s_type)) != 0)
            goto ret1;
    }

    /*
     * If more than 1 reference, just decrement the reference and return.
     * Otherwise, free the name.
     */
    --fnp->ref;
    if (fnp->ref == 0)
        __db_shalloc_free(dblp->addr, R_ADDR(dblp, fnp->name_off));

    /*
     * Remove from the process local table.  If this operation is taking
     * place during recovery, then the logid was never added to the table,
     * so do not remove it.
     */
    if (!F_ISSET(dblp, DBC_RECOVER))
        __log_rem_logid(dblp, fid);

ret1:   UNLOCK_LOGREGION(dblp);
    return (ret);
}