/* fs.c --- creating, opening and closing filesystems * * ==================================================================== * 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 #include #include #include /* for EINVAL */ #include #include #include #include #include "svn_fs.h" #include "svn_delta.h" #include "svn_version.h" #include "fs.h" #include "err.h" #include "dag.h" #include "fs_fs.h" #include "revs-txns.h" #include "tree.h" #include "lock.h" #include "svn_private_config.h" #include "../libsvn_fs/fs-loader.h" /* A prefix for the pool userdata variables used to hold per-repository mutexes. See fs_serialized_init. */ #if APR_HAS_THREADS #define SVN_FSFS_LOCK_USERDATA_PREFIX "svn-fsfs-lock-" #endif /* If filesystem FS is already open, then return an SVN_ERR_FS_ALREADY_OPEN error. Otherwise, return zero. */ static svn_error_t * check_already_open (svn_fs_t *fs) { if (fs->fsap_data) return svn_error_create (SVN_ERR_FS_ALREADY_OPEN, 0, _("Filesystem object already open")); else return SVN_NO_ERROR; } static svn_error_t * fs_serialized_init (svn_fs_t *fs, apr_pool_t *common_pool, apr_pool_t *pool) { #if APR_HAS_THREADS fs_fs_data_t *ffd = fs->fsap_data; const char *key; void *val; apr_thread_mutex_t *lock; apr_status_t status; /* POSIX fcntl locks are per-process, so we need a mutex for intra-process synchronization when grabbing the repository write lock. Fetch a repository-specific lock from the pool user data. Note that we are allocating a small amount of long-lived data for each separate repository opened during the lifetime of the svn_fs_initialize pool. It's unlikely that anyone will notice this modest expenditure; the alternative is to put each lock into a reference-counted structure allocated in a subpool, and add a serialized deconstructor to the FS vtable. That's more machinery than it's worth. Using the uuid to obtain the lock creates a corner case if a caller uses svn_fs_set_uuid on the repository in a process where other threads might be using the same repository through another FS object. The only real-world consumer of svn_fs_set_uuid is "svnadmin load", so this is a low-priority problem, and we don't know of a better way of associating a mutex with the repository. */ key = apr_pstrcat (pool, SVN_FSFS_LOCK_USERDATA_PREFIX, ffd->uuid, (char *) NULL); status = apr_pool_userdata_get (&val, key, common_pool); if (status) return svn_error_wrap_apr (status, _("Can't fetch FSFS mutex")); lock = val; if (!lock) { status = apr_thread_mutex_create (&lock, APR_THREAD_MUTEX_DEFAULT, common_pool); if (status) return svn_error_wrap_apr (status, _("Can't create FSFS mutex")); key = apr_pstrdup (common_pool, key); status = apr_pool_userdata_set (lock, key, NULL, common_pool); if (status) return svn_error_wrap_apr (status, _("Can't store FSFS mutex")); } ffd->lock = lock; #endif return SVN_NO_ERROR; } /* This function is provided for Subversion 1.0.x compatibility. It has no effect for fsfs backed Subversion filesystems. It conforms to the fs_library_vtable_t.bdb_set_errcall() API. */ static svn_error_t * fs_set_errcall (svn_fs_t *fs, void (*db_errcall_fcn) (const char *errpfx, char *msg)) { return SVN_NO_ERROR; } /* The vtable associated with a specific open filesystem. */ static fs_vtable_t fs_vtable = { fs_serialized_init, svn_fs_fs__youngest_rev, svn_fs_fs__revision_prop, svn_fs_fs__revision_proplist, svn_fs_fs__change_rev_prop, svn_fs_fs__get_uuid, svn_fs_fs__set_uuid, svn_fs_fs__revision_root, svn_fs_fs__begin_txn, svn_fs_fs__open_txn, svn_fs_fs__purge_txn, svn_fs_fs__list_transactions, svn_fs_fs__deltify, svn_fs_fs__lock, svn_fs_fs__generate_lock_token, svn_fs_fs__unlock, svn_fs_fs__get_lock, svn_fs_fs__get_locks, fs_set_errcall }; /* Creating a new filesystem. */ /* This implements the fs_library_vtable_t.create() API. Create a new fsfs-backed Subversion filesystem at path PATH and link it into *FS. Perform temporary allocations in POOL. */ static svn_error_t * fs_create (svn_fs_t *fs, const char *path, apr_pool_t *pool) { fs_fs_data_t *ffd; SVN_ERR (check_already_open (fs)); ffd = apr_pcalloc (fs->pool, sizeof (*ffd)); fs->vtable = &fs_vtable; fs->fsap_data = ffd; SVN_ERR (svn_fs_fs__create (fs, path, pool)); return SVN_NO_ERROR; } /* Gaining access to an existing filesystem. */ /* This implements the fs_library_vtable_t.open() API. Open an FSFS Subversion filesystem located at PATH, set *FS to point to the correct vtable for the filesystem. Use POOL for any temporary allocations. */ static svn_error_t * fs_open (svn_fs_t *fs, const char *path, apr_pool_t *pool) { fs_fs_data_t *ffd; ffd = apr_pcalloc (fs->pool, sizeof (*ffd)); fs->vtable = &fs_vtable; fs->fsap_data = ffd; SVN_ERR (svn_fs_fs__open (fs, path, pool)); return SVN_NO_ERROR; } /* This implements the fs_library_vtable_t.hotcopy() API. Copy a possibly live Subversion filesystem from SRC_PATH to DEST_PATH. The CLEAN_LOGS argument is ignored and included for Subversion 1.0.x compatibility. Perform all temporary allocations in POOL. */ static svn_error_t * fs_hotcopy (const char *src_path, const char *dest_path, svn_boolean_t clean_logs, apr_pool_t *pool) { SVN_ERR (svn_fs_fs__hotcopy (src_path, dest_path, pool)); return SVN_NO_ERROR; } /* This function is included for Subversion 1.0.x compatibility. It has no effect for fsfs backed Subversion filesystems. It conforms to the fs_library_vtable_t.bdb_recover() API. */ static svn_error_t * fs_recover (const char *path, apr_pool_t *pool) { /* This is a no-op for FSFS. */ return SVN_NO_ERROR; } /* This function is included for Subversion 1.0.x compatibility. It has no effect for fsfs backed Subversion filesystems. It conforms to the fs_library_vtable_t.bdb_logfiles() API. */ static svn_error_t * fs_logfiles (apr_array_header_t **logfiles, const char *path, svn_boolean_t only_unused, apr_pool_t *pool) { /* A no-op for FSFS. */ *logfiles = apr_array_make (pool, 0, sizeof (const char *)); return SVN_NO_ERROR; } /* Delete the filesystem located at path PATH. Perform any temporary allocations in POOL. */ static svn_error_t * fs_delete_fs (const char *path, apr_pool_t *pool) { /* Remove everything. */ SVN_ERR (svn_io_remove_dir (path, pool)); return SVN_NO_ERROR; } /* Miscellany */ const char * svn_fs_fs__canonicalize_abspath (const char *path, apr_pool_t *pool) { char *newpath; int path_len; int path_i = 0, newpath_i = 0; svn_boolean_t eating_slashes = FALSE; /* No PATH? No problem. */ if (! path) return NULL; /* Empty PATH? That's just "/". */ if (! *path) return apr_pstrdup (pool, "/"); /* Now, the fun begins. Alloc enough room to hold PATH with an added leading '/'. */ path_len = strlen (path); newpath = apr_pcalloc (pool, path_len + 2); /* No leading slash? Fix that. */ if (*path != '/') { newpath[newpath_i++] = '/'; } for (path_i = 0; path_i < path_len; path_i++) { if (path[path_i] == '/') { /* The current character is a '/'. If we are eating up extra '/' characters, skip this character. Else, note that we are now eating slashes. */ if (eating_slashes) continue; eating_slashes = TRUE; } else { /* The current character is NOT a '/'. If we were eating slashes, we need not do that any more. */ if (eating_slashes) eating_slashes = FALSE; } /* Copy the current character into our new buffer. */ newpath[newpath_i++] = path[path_i]; } /* Did we leave a '/' attached to the end of NEWPATH (other than in the root directory case)? */ if ((newpath[newpath_i - 1] == '/') && (newpath_i > 1)) newpath[newpath_i - 1] = '\0'; return newpath; } static const svn_version_t * fs_version (void) { SVN_VERSION_BODY; } static const char * fs_get_description (void) { return _("Module for working with a plain file (FSFS) repository."); } /* Base FS library vtable, used by the FS loader library. */ static fs_library_vtable_t library_vtable = { fs_version, fs_create, fs_open, fs_delete_fs, fs_hotcopy, fs_get_description, fs_recover, fs_logfiles }; svn_error_t * svn_fs_fs__init (const svn_version_t *loader_version, fs_library_vtable_t **vtable) { static const svn_version_checklist_t checklist[] = { { "svn_subr", svn_subr_version }, { "svn_delta", svn_delta_version }, { NULL, NULL } }; /* Simplified version check to make sure we can safely use the VTABLE parameter. The FS loader does a more exhaustive check. */ if (loader_version->major != SVN_VER_MAJOR) return svn_error_createf (SVN_ERR_VERSION_MISMATCH, NULL, _("Unsupported FS loader version (%d) for fsfs"), loader_version->major); SVN_ERR (svn_ver_check_list (fs_version(), checklist)); *vtable = &library_vtable; return SVN_NO_ERROR; }