/* rev-table.c : working with the `revisions' table * * ==================================================================== * Copyright (c) 2000-2004 CollabNet. All rights reserved. * * This software is licensed as described in the file COPYING, which * you should have received as part of this distribution. The terms * are also available at http://subversion.tigris.org/license-1.html. * If newer versions of this license are posted there, you may use a * newer version instead, at your option. * * This software consists of voluntary contributions made by many * individuals. For exact contribution history, see the revision * history and logs, available at http://subversion.tigris.org/. * ==================================================================== */ #include "bdb_compat.h" #include "svn_fs.h" #include "../fs.h" #include "../err.h" #include "../util/skel.h" #include "../util/fs_skels.h" #include "../../libsvn_fs/fs-loader.h" #include "bdb-err.h" #include "dbt.h" #include "rev-table.h" #include "svn_private_config.h" /* Opening/creating the `revisions' table. */ int svn_fs_bdb__open_revisions_table(DB **revisions_p, DB_ENV *env, svn_boolean_t create) { const u_int32_t open_flags = (create ? (DB_CREATE | DB_EXCL) : 0); DB *revisions; BDB_ERR(svn_fs_bdb__check_version()); BDB_ERR(db_create(&revisions, env, 0)); BDB_ERR(revisions->open(SVN_BDB_OPEN_PARAMS(revisions, NULL), "revisions", 0, DB_RECNO, open_flags, 0666)); *revisions_p = revisions; return 0; } /* Storing and retrieving filesystem revisions. */ svn_error_t * svn_fs_bdb__get_rev(revision_t **revision_p, svn_fs_t *fs, svn_revnum_t rev, trail_t *trail, apr_pool_t *pool) { base_fs_data_t *bfd = fs->fsap_data; int db_err; DBT key, value; skel_t *skel; revision_t *revision; /* Turn the revision number into a Berkeley DB record number. Revisions are numbered starting with zero; Berkeley DB record numbers begin with one. */ db_recno_t recno = rev + 1; svn_fs_base__trail_debug(trail, "revisions", "get"); db_err = bfd->revisions->get(bfd->revisions, trail->db_txn, svn_fs_base__set_dbt(&key, &recno, sizeof(recno)), svn_fs_base__result_dbt(&value), 0); svn_fs_base__track_dbt(&value, pool); /* If there's no such revision, return an appropriately specific error. */ if (db_err == DB_NOTFOUND) return svn_fs_base__err_dangling_rev(fs, rev); /* Handle any other error conditions. */ SVN_ERR(BDB_WRAP(fs, _("reading filesystem revision"), db_err)); /* Parse REVISION skel. */ skel = svn_fs_base__parse_skel(value.data, value.size, pool); if (! skel) return svn_fs_base__err_corrupt_fs_revision(fs, rev); /* Convert skel to native type. */ SVN_ERR(svn_fs_base__parse_revision_skel(&revision, skel, pool)); *revision_p = revision; return SVN_NO_ERROR; } /* Write REVISION to FS as part of TRAIL. If *REV is a valid revision number, write this revision as one that corresponds to *REV, else write a new revision and return its newly created revision number in *REV. */ svn_error_t * svn_fs_bdb__put_rev(svn_revnum_t *rev, svn_fs_t *fs, const revision_t *revision, trail_t *trail, apr_pool_t *pool) { base_fs_data_t *bfd = fs->fsap_data; int db_err; db_recno_t recno = 0; skel_t *skel; DBT key, value; /* Convert native type to skel. */ SVN_ERR(svn_fs_base__unparse_revision_skel(&skel, revision, pool)); if (SVN_IS_VALID_REVNUM(*rev)) { DBT query, result; /* Update the filesystem revision with the new skel. */ recno = *rev + 1; svn_fs_base__trail_debug(trail, "revisions", "put"); db_err = bfd->revisions->put (bfd->revisions, trail->db_txn, svn_fs_base__set_dbt(&query, &recno, sizeof(recno)), svn_fs_base__skel_to_dbt(&result, skel, pool), 0); return BDB_WRAP(fs, "updating filesystem revision", db_err); } svn_fs_base__trail_debug(trail, "revisions", "put"); db_err = bfd->revisions->put(bfd->revisions, trail->db_txn, svn_fs_base__recno_dbt(&key, &recno), svn_fs_base__skel_to_dbt(&value, skel, pool), DB_APPEND); SVN_ERR(BDB_WRAP(fs, "storing filesystem revision", db_err)); /* Turn the record number into a Subversion revision number. Revisions are numbered starting with zero; Berkeley DB record numbers begin with one. */ *rev = recno - 1; return SVN_NO_ERROR; } /* Getting the youngest revision. */ svn_error_t * svn_fs_bdb__youngest_rev(svn_revnum_t *youngest_p, svn_fs_t *fs, trail_t *trail, apr_pool_t *pool) { base_fs_data_t *bfd = fs->fsap_data; int db_err; DBC *cursor = 0; DBT key, value; db_recno_t recno; SVN_ERR(svn_fs_base__check_fs(fs)); /* Create a database cursor. */ svn_fs_base__trail_debug(trail, "revisions", "cursor"); SVN_ERR(BDB_WRAP(fs, "getting youngest revision (creating cursor)", bfd->revisions->cursor(bfd->revisions, trail->db_txn, &cursor, 0))); /* Find the last entry in the `revisions' table. */ db_err = cursor->c_get(cursor, svn_fs_base__recno_dbt(&key, &recno), svn_fs_base__nodata_dbt(&value), DB_LAST); if (db_err) { /* Free the cursor. Ignore any error value --- the error above is more interesting. */ cursor->c_close(cursor); if (db_err == DB_NOTFOUND) /* The revision 0 should always be present, at least. */ return svn_error_createf (SVN_ERR_FS_CORRUPT, 0, "Corrupt DB: revision 0 missing from 'revisions' table, in " "filesystem '%s'", fs->path); SVN_ERR(BDB_WRAP(fs, "getting youngest revision (finding last entry)", db_err)); } /* You can't commit a transaction with open cursors, because: 1) key/value pairs don't get deleted until the cursors referring to them are closed, so closing a cursor can fail for various reasons, and txn_commit shouldn't fail that way, and 2) using a cursor after committing its transaction can cause undetectable database corruption. */ SVN_ERR(BDB_WRAP(fs, "getting youngest revision (closing cursor)", cursor->c_close(cursor))); /* Turn the record number into a Subversion revision number. Revisions are numbered starting with zero; Berkeley DB record numbers begin with one. */ *youngest_p = recno - 1; return SVN_NO_ERROR; }