1251881Speter/* 2251881Speter * fs_loader.h: Declarations for the FS loader library 3251881Speter * 4251881Speter * ==================================================================== 5251881Speter * Licensed to the Apache Software Foundation (ASF) under one 6251881Speter * or more contributor license agreements. See the NOTICE file 7251881Speter * distributed with this work for additional information 8251881Speter * regarding copyright ownership. The ASF licenses this file 9251881Speter * to you under the Apache License, Version 2.0 (the 10251881Speter * "License"); you may not use this file except in compliance 11251881Speter * with the License. You may obtain a copy of the License at 12251881Speter * 13251881Speter * http://www.apache.org/licenses/LICENSE-2.0 14251881Speter * 15251881Speter * Unless required by applicable law or agreed to in writing, 16251881Speter * software distributed under the License is distributed on an 17251881Speter * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 18251881Speter * KIND, either express or implied. See the License for the 19251881Speter * specific language governing permissions and limitations 20251881Speter * under the License. 21251881Speter * ==================================================================== 22251881Speter */ 23251881Speter 24251881Speter 25251881Speter#ifndef LIBSVN_FS_FS_H 26251881Speter#define LIBSVN_FS_FS_H 27251881Speter 28251881Speter#include "svn_types.h" 29251881Speter#include "svn_fs.h" 30251881Speter 31251881Speter#ifdef __cplusplus 32251881Speterextern "C" { 33251881Speter#endif /* __cplusplus */ 34251881Speter 35251881Speter 36251881Speter/* The FS loader library implements the a front end to "filesystem 37251881Speter abstract providers" (FSAPs), which implement the svn_fs API. 38251881Speter 39251881Speter The loader library divides up the FS API into several categories: 40251881Speter 41251881Speter - Top-level functions, which operate on paths to an FS 42251881Speter - Functions which operate on an FS object 43251881Speter - Functions which operate on a transaction object 44251881Speter - Functions which operate on a root object 45251881Speter - Functions which operate on a history object 46251881Speter - Functions which operate on a noderev-ID object 47251881Speter 48251881Speter Some generic fields of the FS, transaction, root, and history 49251881Speter objects are defined by the loader library; the rest are stored in 50251881Speter the "fsap_data" field which is defined by the FSAP. Likewise, some 51251881Speter of the very simple svn_fs API functions (such as svn_fs_root_fs) 52251881Speter are defined by the loader library, while the rest are implemented 53251881Speter through vtable calls defined by the FSAP. 54251881Speter 55251881Speter If you are considering writing a new database-backed filesystem 56251881Speter implementation, it may be appropriate to add a second, lower-level 57251881Speter abstraction to the libsvn_fs_base library which currently 58251881Speter implements the BDB filesystem type. Consult the dev list for 59251881Speter details on the "FSP-level" abstraction concept. 60251881Speter*/ 61251881Speter 62251881Speter 63251881Speter 64251881Speter/*** Top-level library vtable type ***/ 65251881Speter 66251881Spetertypedef struct fs_library_vtable_t 67251881Speter{ 68251881Speter /* This field should always remain first in the vtable. 69251881Speter Apart from that, it can be changed however you like, since exact 70251881Speter version equality is required between loader and module. This policy 71251881Speter was weaker during 1.1.x, but only in ways which do not conflict with 72251881Speter this statement, now that the minor version has increased. */ 73251881Speter const svn_version_t *(*get_version)(void); 74251881Speter 75251881Speter /* The open_fs/create/open_fs_for_recovery/upgrade_fs functions are 76251881Speter serialized so that they may use the common_pool parameter to 77251881Speter allocate fs-global objects such as the bdb env cache. */ 78251881Speter svn_error_t *(*create)(svn_fs_t *fs, const char *path, apr_pool_t *pool, 79251881Speter apr_pool_t *common_pool); 80251881Speter svn_error_t *(*open_fs)(svn_fs_t *fs, const char *path, apr_pool_t *pool, 81251881Speter apr_pool_t *common_pool); 82251881Speter /* open_for_recovery() is like open(), but used to fill in an fs pointer 83251881Speter that will be passed to recover(). We assume that the open() method 84251881Speter might not be immediately appropriate for recovery. */ 85251881Speter svn_error_t *(*open_fs_for_recovery)(svn_fs_t *fs, const char *path, 86251881Speter apr_pool_t *pool, 87251881Speter apr_pool_t *common_pool); 88251881Speter svn_error_t *(*upgrade_fs)(svn_fs_t *fs, const char *path, apr_pool_t *pool, 89251881Speter apr_pool_t *common_pool); 90251881Speter svn_error_t *(*verify_fs)(svn_fs_t *fs, const char *path, 91251881Speter svn_revnum_t start, 92251881Speter svn_revnum_t end, 93251881Speter svn_fs_progress_notify_func_t notify_func, 94251881Speter void *notify_baton, 95251881Speter svn_cancel_func_t cancel_func, 96251881Speter void *cancel_baton, 97251881Speter apr_pool_t *pool, 98251881Speter apr_pool_t *common_pool); 99251881Speter svn_error_t *(*delete_fs)(const char *path, apr_pool_t *pool); 100251881Speter svn_error_t *(*hotcopy)(svn_fs_t *src_fs, svn_fs_t *dst_fs, 101251881Speter const char *src_path, const char *dst_path, 102251881Speter svn_boolean_t clean, svn_boolean_t incremental, 103251881Speter svn_cancel_func_t cancel_func, void *cancel_baton, 104251881Speter apr_pool_t *pool); 105251881Speter const char *(*get_description)(void); 106251881Speter svn_error_t *(*recover)(svn_fs_t *fs, 107251881Speter svn_cancel_func_t cancel_func, void *cancel_baton, 108251881Speter apr_pool_t *pool); 109251881Speter svn_error_t *(*pack_fs)(svn_fs_t *fs, const char *path, 110251881Speter svn_fs_pack_notify_t notify_func, void *notify_baton, 111251881Speter svn_cancel_func_t cancel_func, void *cancel_baton, 112251881Speter apr_pool_t *pool, apr_pool_t *common_pool); 113251881Speter 114251881Speter /* Provider-specific functions should go here, even if they could go 115251881Speter in an object vtable, so that they are all kept together. */ 116251881Speter svn_error_t *(*bdb_logfiles)(apr_array_header_t **logfiles, 117251881Speter const char *path, svn_boolean_t only_unused, 118251881Speter apr_pool_t *pool); 119251881Speter 120251881Speter /* This is to let the base provider implement the deprecated 121251881Speter svn_fs_parse_id, which we've decided doesn't belong in the FS 122251881Speter API. If we change our minds and decide to add a real 123251881Speter svn_fs_parse_id variant which takes an FS object, it should go 124251881Speter into the FS vtable. */ 125251881Speter svn_fs_id_t *(*parse_id)(const char *data, apr_size_t len, 126251881Speter apr_pool_t *pool); 127251881Speter /* Allow an FSAP to call svn_fs_open(), which is in a higher-level library 128251881Speter (libsvn_fs-1.so) and cannot easily be moved to libsvn_fs_util. */ 129251881Speter svn_error_t *(*set_svn_fs_open)(svn_fs_t *fs, 130251881Speter svn_error_t *(*svn_fs_open_)(svn_fs_t **, 131251881Speter const char *, 132251881Speter apr_hash_t *, 133251881Speter apr_pool_t *)); 134251881Speter 135251881Speter} fs_library_vtable_t; 136251881Speter 137251881Speter/* This is the type of symbol an FS module defines to fetch the 138251881Speter library vtable. The LOADER_VERSION parameter must remain first in 139251881Speter the list, and the function must use the C calling convention on all 140251881Speter platforms, so that the init functions can safely read the version 141251881Speter parameter. The COMMON_POOL parameter must be a pool with a greater 142251881Speter lifetime than the fs module so that fs global state can be kept 143251881Speter in it and cleaned up on termination before the fs module is unloaded. 144251881Speter Calls to these functions are globally serialized so that they have 145251881Speter exclusive access to the COMMON_POOL parameter. 146251881Speter 147251881Speter ### need to force this to be __cdecl on Windows... how?? */ 148251881Spetertypedef svn_error_t *(*fs_init_func_t)(const svn_version_t *loader_version, 149251881Speter fs_library_vtable_t **vtable, 150251881Speter apr_pool_t* common_pool); 151251881Speter 152251881Speter/* Here are the declarations for the FS module init functions. If we 153251881Speter are using DSO loading, they won't actually be linked into 154251881Speter libsvn_fs. Note that these private functions have a common_pool 155251881Speter parameter that may be used for fs module scoped variables such as 156251881Speter the bdb cache. This will be the same common_pool that is passed 157251881Speter to the create and open functions and these init functions (as well 158251881Speter as the open and create functions) are globally serialized so that 159251881Speter they have exclusive access to the common_pool. */ 160251881Spetersvn_error_t *svn_fs_base__init(const svn_version_t *loader_version, 161251881Speter fs_library_vtable_t **vtable, 162251881Speter apr_pool_t* common_pool); 163251881Spetersvn_error_t *svn_fs_fs__init(const svn_version_t *loader_version, 164251881Speter fs_library_vtable_t **vtable, 165251881Speter apr_pool_t* common_pool); 166251881Speter 167251881Speter 168251881Speter 169251881Speter/*** vtable types for the abstract FS objects ***/ 170251881Speter 171251881Spetertypedef struct fs_vtable_t 172251881Speter{ 173251881Speter svn_error_t *(*youngest_rev)(svn_revnum_t *youngest_p, svn_fs_t *fs, 174251881Speter apr_pool_t *pool); 175251881Speter svn_error_t *(*revision_prop)(svn_string_t **value_p, svn_fs_t *fs, 176251881Speter svn_revnum_t rev, const char *propname, 177251881Speter apr_pool_t *pool); 178251881Speter svn_error_t *(*revision_proplist)(apr_hash_t **table_p, svn_fs_t *fs, 179251881Speter svn_revnum_t rev, apr_pool_t *pool); 180251881Speter svn_error_t *(*change_rev_prop)(svn_fs_t *fs, svn_revnum_t rev, 181251881Speter const char *name, 182251881Speter const svn_string_t *const *old_value_p, 183251881Speter const svn_string_t *value, 184251881Speter apr_pool_t *pool); 185251881Speter /* There is no get_uuid(); see svn_fs_t.uuid docstring. */ 186251881Speter svn_error_t *(*set_uuid)(svn_fs_t *fs, const char *uuid, apr_pool_t *pool); 187251881Speter svn_error_t *(*revision_root)(svn_fs_root_t **root_p, svn_fs_t *fs, 188251881Speter svn_revnum_t rev, apr_pool_t *pool); 189251881Speter svn_error_t *(*begin_txn)(svn_fs_txn_t **txn_p, svn_fs_t *fs, 190251881Speter svn_revnum_t rev, apr_uint32_t flags, 191251881Speter apr_pool_t *pool); 192251881Speter svn_error_t *(*open_txn)(svn_fs_txn_t **txn, svn_fs_t *fs, 193251881Speter const char *name, apr_pool_t *pool); 194251881Speter svn_error_t *(*purge_txn)(svn_fs_t *fs, const char *txn_id, 195251881Speter apr_pool_t *pool); 196251881Speter svn_error_t *(*list_transactions)(apr_array_header_t **names_p, 197251881Speter svn_fs_t *fs, apr_pool_t *pool); 198251881Speter svn_error_t *(*deltify)(svn_fs_t *fs, svn_revnum_t rev, apr_pool_t *pool); 199251881Speter svn_error_t *(*lock)(svn_lock_t **lock, svn_fs_t *fs, 200251881Speter const char *path, const char *token, 201251881Speter const char *comment, svn_boolean_t is_dav_comment, 202251881Speter apr_time_t expiration_date, 203251881Speter svn_revnum_t current_rev, svn_boolean_t steal_lock, 204251881Speter apr_pool_t *pool); 205251881Speter svn_error_t *(*generate_lock_token)(const char **token, svn_fs_t *fs, 206251881Speter apr_pool_t *pool); 207251881Speter svn_error_t *(*unlock)(svn_fs_t *fs, const char *path, const char *token, 208251881Speter svn_boolean_t break_lock, apr_pool_t *pool); 209251881Speter svn_error_t *(*get_lock)(svn_lock_t **lock, svn_fs_t *fs, 210251881Speter const char *path, apr_pool_t *pool); 211251881Speter svn_error_t *(*get_locks)(svn_fs_t *fs, const char *path, svn_depth_t depth, 212251881Speter svn_fs_get_locks_callback_t get_locks_func, 213251881Speter void *get_locks_baton, 214251881Speter apr_pool_t *pool); 215251881Speter svn_error_t *(*verify_root)(svn_fs_root_t *root, 216251881Speter apr_pool_t *pool); 217251881Speter svn_error_t *(*freeze)(svn_fs_t *fs, 218251881Speter svn_fs_freeze_func_t freeze_func, 219251881Speter void *freeze_baton, apr_pool_t *pool); 220251881Speter svn_error_t *(*bdb_set_errcall)(svn_fs_t *fs, 221251881Speter void (*handler)(const char *errpfx, 222251881Speter char *msg)); 223251881Speter} fs_vtable_t; 224251881Speter 225251881Speter 226251881Spetertypedef struct txn_vtable_t 227251881Speter{ 228251881Speter svn_error_t *(*commit)(const char **conflict_p, svn_revnum_t *new_rev, 229251881Speter svn_fs_txn_t *txn, apr_pool_t *pool); 230251881Speter svn_error_t *(*abort)(svn_fs_txn_t *txn, apr_pool_t *pool); 231251881Speter svn_error_t *(*get_prop)(svn_string_t **value_p, svn_fs_txn_t *txn, 232251881Speter const char *propname, apr_pool_t *pool); 233251881Speter svn_error_t *(*get_proplist)(apr_hash_t **table_p, svn_fs_txn_t *txn, 234251881Speter apr_pool_t *pool); 235251881Speter svn_error_t *(*change_prop)(svn_fs_txn_t *txn, const char *name, 236251881Speter const svn_string_t *value, apr_pool_t *pool); 237251881Speter svn_error_t *(*root)(svn_fs_root_t **root_p, svn_fs_txn_t *txn, 238251881Speter apr_pool_t *pool); 239251881Speter svn_error_t *(*change_props)(svn_fs_txn_t *txn, const apr_array_header_t *props, 240251881Speter apr_pool_t *pool); 241251881Speter} txn_vtable_t; 242251881Speter 243251881Speter 244251881Speter/* Some of these operations accept multiple root arguments. Since the 245251881Speter roots may not all have the same vtable, we need a rule to determine 246251881Speter which root's vtable is used. The rule is: if one of the roots is 247251881Speter named "target", we use that root's vtable; otherwise, we use the 248251881Speter first root argument's vtable. 249251881Speter These callbacks correspond to svn_fs_* functions in include/svn_fs.h, 250251881Speter see there for details. 251251881Speter Note: delete_node() corresponds to svn_fs_delete(). */ 252251881Spetertypedef struct root_vtable_t 253251881Speter{ 254251881Speter /* Determining what has changed in a root */ 255251881Speter svn_error_t *(*paths_changed)(apr_hash_t **changed_paths_p, 256251881Speter svn_fs_root_t *root, 257251881Speter apr_pool_t *pool); 258251881Speter 259251881Speter /* Generic node operations */ 260251881Speter svn_error_t *(*check_path)(svn_node_kind_t *kind_p, svn_fs_root_t *root, 261251881Speter const char *path, apr_pool_t *pool); 262251881Speter svn_error_t *(*node_history)(svn_fs_history_t **history_p, 263251881Speter svn_fs_root_t *root, const char *path, 264251881Speter apr_pool_t *pool); 265251881Speter svn_error_t *(*node_id)(const svn_fs_id_t **id_p, svn_fs_root_t *root, 266251881Speter const char *path, apr_pool_t *pool); 267251881Speter svn_error_t *(*node_created_rev)(svn_revnum_t *revision, 268251881Speter svn_fs_root_t *root, const char *path, 269251881Speter apr_pool_t *pool); 270251881Speter svn_error_t *(*node_origin_rev)(svn_revnum_t *revision, 271251881Speter svn_fs_root_t *root, const char *path, 272251881Speter apr_pool_t *pool); 273251881Speter svn_error_t *(*node_created_path)(const char **created_path, 274251881Speter svn_fs_root_t *root, const char *path, 275251881Speter apr_pool_t *pool); 276251881Speter svn_error_t *(*delete_node)(svn_fs_root_t *root, const char *path, 277251881Speter apr_pool_t *pool); 278251881Speter svn_error_t *(*copied_from)(svn_revnum_t *rev_p, const char **path_p, 279251881Speter svn_fs_root_t *root, const char *path, 280251881Speter apr_pool_t *pool); 281251881Speter svn_error_t *(*closest_copy)(svn_fs_root_t **root_p, const char **path_p, 282251881Speter svn_fs_root_t *root, const char *path, 283251881Speter apr_pool_t *pool); 284251881Speter 285251881Speter /* Property operations */ 286251881Speter svn_error_t *(*node_prop)(svn_string_t **value_p, svn_fs_root_t *root, 287251881Speter const char *path, const char *propname, 288251881Speter apr_pool_t *pool); 289251881Speter svn_error_t *(*node_proplist)(apr_hash_t **table_p, svn_fs_root_t *root, 290251881Speter const char *path, apr_pool_t *pool); 291251881Speter svn_error_t *(*change_node_prop)(svn_fs_root_t *root, const char *path, 292251881Speter const char *name, 293251881Speter const svn_string_t *value, 294251881Speter apr_pool_t *pool); 295251881Speter svn_error_t *(*props_changed)(int *changed_p, svn_fs_root_t *root1, 296251881Speter const char *path1, svn_fs_root_t *root2, 297251881Speter const char *path2, apr_pool_t *pool); 298251881Speter 299251881Speter /* Directories */ 300251881Speter svn_error_t *(*dir_entries)(apr_hash_t **entries_p, svn_fs_root_t *root, 301251881Speter const char *path, apr_pool_t *pool); 302251881Speter svn_error_t *(*make_dir)(svn_fs_root_t *root, const char *path, 303251881Speter apr_pool_t *pool); 304251881Speter svn_error_t *(*copy)(svn_fs_root_t *from_root, const char *from_path, 305251881Speter svn_fs_root_t *to_root, const char *to_path, 306251881Speter apr_pool_t *pool); 307251881Speter svn_error_t *(*revision_link)(svn_fs_root_t *from_root, 308251881Speter svn_fs_root_t *to_root, 309251881Speter const char *path, 310251881Speter apr_pool_t *pool); 311251881Speter 312251881Speter /* Files */ 313251881Speter svn_error_t *(*file_length)(svn_filesize_t *length_p, svn_fs_root_t *root, 314251881Speter const char *path, apr_pool_t *pool); 315251881Speter svn_error_t *(*file_checksum)(svn_checksum_t **checksum, 316251881Speter svn_checksum_kind_t kind, svn_fs_root_t *root, 317251881Speter const char *path, apr_pool_t *pool); 318251881Speter svn_error_t *(*file_contents)(svn_stream_t **contents, 319251881Speter svn_fs_root_t *root, const char *path, 320251881Speter apr_pool_t *pool); 321251881Speter svn_error_t *(*try_process_file_contents)(svn_boolean_t *success, 322251881Speter svn_fs_root_t *target_root, 323251881Speter const char *target_path, 324251881Speter svn_fs_process_contents_func_t processor, 325251881Speter void* baton, 326251881Speter apr_pool_t *pool); 327251881Speter svn_error_t *(*make_file)(svn_fs_root_t *root, const char *path, 328251881Speter apr_pool_t *pool); 329251881Speter svn_error_t *(*apply_textdelta)(svn_txdelta_window_handler_t *contents_p, 330251881Speter void **contents_baton_p, 331251881Speter svn_fs_root_t *root, const char *path, 332251881Speter svn_checksum_t *base_checksum, 333251881Speter svn_checksum_t *result_checksum, 334251881Speter apr_pool_t *pool); 335251881Speter svn_error_t *(*apply_text)(svn_stream_t **contents_p, svn_fs_root_t *root, 336251881Speter const char *path, svn_checksum_t *result_checksum, 337251881Speter apr_pool_t *pool); 338251881Speter svn_error_t *(*contents_changed)(int *changed_p, svn_fs_root_t *root1, 339251881Speter const char *path1, svn_fs_root_t *root2, 340251881Speter const char *path2, apr_pool_t *pool); 341251881Speter svn_error_t *(*get_file_delta_stream)(svn_txdelta_stream_t **stream_p, 342251881Speter svn_fs_root_t *source_root, 343251881Speter const char *source_path, 344251881Speter svn_fs_root_t *target_root, 345251881Speter const char *target_path, 346251881Speter apr_pool_t *pool); 347251881Speter 348251881Speter /* Merging. */ 349251881Speter svn_error_t *(*merge)(const char **conflict_p, 350251881Speter svn_fs_root_t *source_root, 351251881Speter const char *source_path, 352251881Speter svn_fs_root_t *target_root, 353251881Speter const char *target_path, 354251881Speter svn_fs_root_t *ancestor_root, 355251881Speter const char *ancestor_path, 356251881Speter apr_pool_t *pool); 357251881Speter /* Mergeinfo. */ 358251881Speter svn_error_t *(*get_mergeinfo)(svn_mergeinfo_catalog_t *catalog, 359251881Speter svn_fs_root_t *root, 360251881Speter const apr_array_header_t *paths, 361251881Speter svn_mergeinfo_inheritance_t inherit, 362251881Speter svn_boolean_t include_descendants, 363251881Speter svn_boolean_t adjust_inherited_mergeinfo, 364251881Speter apr_pool_t *result_pool, 365251881Speter apr_pool_t *scratch_pool); 366251881Speter} root_vtable_t; 367251881Speter 368251881Speter 369251881Spetertypedef struct history_vtable_t 370251881Speter{ 371251881Speter svn_error_t *(*prev)(svn_fs_history_t **prev_history_p, 372251881Speter svn_fs_history_t *history, svn_boolean_t cross_copies, 373251881Speter apr_pool_t *pool); 374251881Speter svn_error_t *(*location)(const char **path, svn_revnum_t *revision, 375251881Speter svn_fs_history_t *history, apr_pool_t *pool); 376251881Speter} history_vtable_t; 377251881Speter 378251881Speter 379251881Spetertypedef struct id_vtable_t 380251881Speter{ 381251881Speter svn_string_t *(*unparse)(const svn_fs_id_t *id, apr_pool_t *pool); 382251881Speter int (*compare)(const svn_fs_id_t *a, const svn_fs_id_t *b); 383251881Speter} id_vtable_t; 384251881Speter 385251881Speter 386251881Speter 387251881Speter/*** Definitions of the abstract FS object types ***/ 388251881Speter 389251881Speter/* These are transaction properties that correspond to the bitfields 390251881Speter in the 'flags' argument to svn_fs_lock(). */ 391251881Speter#define SVN_FS__PROP_TXN_CHECK_LOCKS SVN_PROP_PREFIX "check-locks" 392251881Speter#define SVN_FS__PROP_TXN_CHECK_OOD SVN_PROP_PREFIX "check-ood" 393251881Speter 394251881Speterstruct svn_fs_t 395251881Speter{ 396251881Speter /* The pool in which this fs object is allocated */ 397251881Speter apr_pool_t *pool; 398251881Speter 399251881Speter /* The path to the repository's top-level directory */ 400251881Speter char *path; 401251881Speter 402251881Speter /* A callback for printing warning messages */ 403251881Speter svn_fs_warning_callback_t warning; 404251881Speter void *warning_baton; 405251881Speter 406251881Speter /* The filesystem configuration */ 407251881Speter apr_hash_t *config; 408251881Speter 409251881Speter /* An access context indicating who's using the fs */ 410251881Speter svn_fs_access_t *access_ctx; 411251881Speter 412251881Speter /* FSAP-specific vtable and private data */ 413251881Speter fs_vtable_t *vtable; 414251881Speter void *fsap_data; 415251881Speter 416251881Speter /* UUID, stored by open(), create(), and set_uuid(). */ 417251881Speter const char *uuid; 418251881Speter}; 419251881Speter 420251881Speter 421251881Speterstruct svn_fs_txn_t 422251881Speter{ 423251881Speter /* The filesystem to which this transaction belongs */ 424251881Speter svn_fs_t *fs; 425251881Speter 426251881Speter /* The revision on which this transaction is based, or 427251881Speter SVN_INVALID_REVISION if the transaction is not based on a 428251881Speter revision at all */ 429251881Speter svn_revnum_t base_rev; 430251881Speter 431251881Speter /* The ID of this transaction */ 432251881Speter const char *id; 433251881Speter 434251881Speter /* FSAP-specific vtable and private data */ 435251881Speter txn_vtable_t *vtable; 436251881Speter void *fsap_data; 437251881Speter}; 438251881Speter 439251881Speter 440251881Speterstruct svn_fs_root_t 441251881Speter{ 442251881Speter /* A pool managing this root (and only this root!) */ 443251881Speter apr_pool_t *pool; 444251881Speter 445251881Speter /* The filesystem to which this root belongs */ 446251881Speter svn_fs_t *fs; 447251881Speter 448251881Speter /* The kind of root this is */ 449251881Speter svn_boolean_t is_txn_root; 450251881Speter 451251881Speter /* For transaction roots, the name of the transaction */ 452251881Speter const char *txn; 453251881Speter 454251881Speter /* For transaction roots, flags describing the txn's behavior. */ 455251881Speter apr_uint32_t txn_flags; 456251881Speter 457251881Speter /* For revision roots, the number of the revision; for transaction 458251881Speter roots, the number of the revision on which the transaction is 459251881Speter based. */ 460251881Speter svn_revnum_t rev; 461251881Speter 462251881Speter /* FSAP-specific vtable and private data */ 463251881Speter root_vtable_t *vtable; 464251881Speter void *fsap_data; 465251881Speter}; 466251881Speter 467251881Speter 468251881Speterstruct svn_fs_history_t 469251881Speter{ 470251881Speter /* FSAP-specific vtable and private data */ 471251881Speter history_vtable_t *vtable; 472251881Speter void *fsap_data; 473251881Speter}; 474251881Speter 475251881Speter 476251881Speterstruct svn_fs_id_t 477251881Speter{ 478251881Speter /* FSAP-specific vtable and private data */ 479251881Speter id_vtable_t *vtable; 480251881Speter void *fsap_data; 481251881Speter}; 482251881Speter 483251881Speter 484251881Speterstruct svn_fs_access_t 485251881Speter{ 486251881Speter /* An authenticated username using the fs */ 487251881Speter const char *username; 488251881Speter 489251881Speter /* A collection of lock-tokens supplied by the fs caller. 490251881Speter Hash maps (const char *) UUID --> (void *) 1 491251881Speter fs functions should really only be interested whether a UUID 492251881Speter exists as a hash key at all; the value is irrelevant. */ 493251881Speter apr_hash_t *lock_tokens; 494251881Speter}; 495251881Speter 496251881Speter 497251881Speter 498251881Speter#ifdef __cplusplus 499251881Speter} 500251881Speter#endif /* __cplusplus */ 501251881Speter 502251881Speter#endif 503