subversion/libsvn_fs_x/rev_file.c - subversion - Git at Google

 /* rev_file.c --- revision file and index access functions
  *
  * ====================================================================
  *    Licensed to the Apache Software Foundation (ASF) under one
  *    or more contributor license agreements.  See the NOTICE file
  *    distributed with this work for additional information
  *    regarding copyright ownership.  The ASF licenses this file
  *    to you under the Apache License, Version 2.0 (the
  *    "License"); you may not use this file except in compliance
  *    with the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing,
  *    software distributed under the License is distributed on an
  *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  *    KIND, either express or implied.  See the License for the
  *    specific language governing permissions and limitations
  *    under the License.
  * ====================================================================
  */

 #include "svn_pools.h"

 #include "rev_file.h"
 #include "fs_x.h"
 #include "index.h"
 #include "low_level.h"
 #include "util.h"

 #include "../libsvn_fs/fs-loader.h"

 #include "private/svn_io_private.h"
 #include "svn_private_config.h"

 struct svn_fs_x__revision_file_t
 {
   /* the filesystem that this revision file belongs to */
   svn_fs_t *fs;

   /* Meta-data to FILE. */
   svn_fs_x__rev_file_info_t file_info;

   /* rev / pack file */
   apr_file_t *file;

   /* stream based on FILE and not NULL exactly when FILE is not NULL */
   svn_stream_t *stream;

   /* the opened P2L index stream or NULL.  Always NULL for txns. */
   svn_fs_x__packed_number_stream_t *p2l_stream;

   /* the opened L2P index stream or NULL.  Always NULL for txns. */
   svn_fs_x__packed_number_stream_t *l2p_stream;

   /* Copied from FS->FFD->BLOCK_SIZE upon creation.  It allows us to
    * use aligned seek() without having the FS handy. */
   apr_off_t block_size;

   /* Info on the L2P index within FILE.
    * Elements are -1 / NULL until svn_fs_x__auto_read_footer gets called. */
   svn_fs_x__index_info_t l2p_info;

   /* Info on the P2L index within FILE.
    * Elements are -1 / NULL until svn_fs_x__auto_read_footer gets called. */
   svn_fs_x__index_info_t p2l_info;

   /* Pool used for all sub-structure allocations (file, streams etc.).
      A sub-pool of OWNER. NULL until the lazily initilized. */
   apr_pool_t *pool;

   /* Pool that this structure got allocated in. */
   apr_pool_t *owner;
 };

 /* Return a new revision file instance, allocated in RESULT_POOL, for
  * filesystem FS.  Set its pool member to the provided RESULT_POOL. */
 static svn_fs_x__revision_file_t *
 create_revision_file(svn_fs_t *fs,
                      apr_pool_t *result_pool)
 {
   svn_fs_x__data_t *ffd = fs->fsap_data;

   svn_fs_x__revision_file_t *file = apr_palloc(result_pool, sizeof(*file));
   file->fs = fs;
   file->file_info.is_packed = FALSE;
   file->file_info.start_revision = SVN_INVALID_REVNUM;
   file->file = NULL;
   file->stream = NULL;
   file->p2l_stream = NULL;
   file->l2p_stream = NULL;
   file->block_size = ffd->block_size;
   file->l2p_info.start = -1;
   file->l2p_info.end = -1;
   file->l2p_info.checksum = NULL;
   file->p2l_info.start = -1;
   file->p2l_info.end = -1;
   file->p2l_info.checksum = NULL;
   file->pool = NULL;
   file->owner = result_pool;

   return file;
 }

 /* Return a new revision file instance, allocated in RESULT_POOL, for
  * REVISION in filesystem FS.  Set its pool member to the provided
  * RESULT_POOL. */
 static svn_fs_x__revision_file_t *
 init_revision_file(svn_fs_t *fs,
                    svn_revnum_t revision,
                    apr_pool_t *result_pool)
 {
   svn_fs_x__revision_file_t *file = create_revision_file(fs, result_pool);

   file->file_info.is_packed = svn_fs_x__is_packed_rev(fs, revision);
   file->file_info.start_revision = svn_fs_x__packed_base_rev(fs, revision);

   return file;
 }

 /* Baton type for set_read_only() */
 typedef struct set_read_only_baton_t
 {
   /* File to set to read-only. */
   const char *file_path;

   /* Scratch pool sufficient life time.
    * Ideally the pool that we registered the cleanup on. */
   apr_pool_t *pool;
 } set_read_only_baton_t;

 /* APR pool cleanup callback taking a set_read_only_baton_t baton and then
  * (trying to) set the specified file to r/o mode. */
 static apr_status_t
 set_read_only(void *baton)
 {
   set_read_only_baton_t *ro_baton = baton;
   apr_status_t status = APR_SUCCESS;
   svn_error_t *err;

   err = svn_io_set_file_read_only(ro_baton->file_path, TRUE, ro_baton->pool);
   if (err)
     {
       status = err->apr_err;
       svn_error_clear(err);
     }

   return status;
 }

 /* If the file at PATH is read-only, attempt to make it writable.  The
  * original state will be restored with RESULT_POOL gets cleaned up.
  * SCRATCH_POOL is for temporary allocations. */
 static svn_error_t *
 auto_make_writable(const char *path,
                    apr_pool_t *result_pool,
                    apr_pool_t *scratch_pool)
 {
   svn_boolean_t is_read_only;
   apr_finfo_t finfo;

   SVN_ERR(svn_io_stat(&finfo, path, SVN__APR_FINFO_READONLY, scratch_pool));
   SVN_ERR(svn_io__is_finfo_read_only(&is_read_only, &finfo, scratch_pool));

   if (is_read_only)
     {
       /* Tell the pool to restore the r/o state upon cleanup
          (assuming the file will still exist, failing silently otherwise). */
       set_read_only_baton_t *baton = apr_pcalloc(result_pool,
                                                   sizeof(*baton));
       baton->pool = result_pool;
       baton->file_path = apr_pstrdup(result_pool, path);
       apr_pool_cleanup_register(result_pool, baton,
                                 set_read_only, apr_pool_cleanup_null);

       /* Finally, allow write access (undoing it has already been scheduled
          and is idempotent). */
       SVN_ERR(svn_io_set_file_read_write(path, FALSE, scratch_pool));
     }

   return SVN_NO_ERROR;
 }

 /* Return the pool to be used for allocations with FILE.
    Lazily created that pool upon the first call. */
 static apr_pool_t *
 get_file_pool(svn_fs_x__revision_file_t *file)
 {
   if (file->pool == NULL)
     file->pool = svn_pool_create(file->owner);

   return file->pool;
 }

 /* Core implementation of svn_fs_x__open_pack_or_rev_file working on an
  * existing, initialized FILE structure.  If WRITABLE is TRUE, give write
  * access to the file - temporarily resetting the r/o state if necessary.
  */
 static svn_error_t *
 open_pack_or_rev_file(svn_fs_x__revision_file_t *file,
                       svn_boolean_t writable,
                       apr_pool_t *scratch_pool)
 {
   svn_error_t *err;
   svn_boolean_t retry = FALSE;
   svn_fs_t *fs = file->fs;
   svn_revnum_t rev = file->file_info.start_revision;
   apr_pool_t *file_pool = get_file_pool(file);

   do
     {
       const char *path = svn_fs_x__path_rev_absolute(fs, rev, scratch_pool);
       apr_file_t *apr_file;
       apr_int32_t flags = writable
                         ? APR_READ | APR_WRITE | APR_BUFFERED
                         : APR_READ | APR_BUFFERED;

       /* We may have to *temporarily* enable write access. */
       err = writable ? auto_make_writable(path, file_pool, scratch_pool)
                      : SVN_NO_ERROR;

       /* open the revision file in buffered r/o or r/w mode */
       if (!err)
         err = svn_io_file_open(&apr_file, path, flags, APR_OS_DEFAULT,
                                file_pool);

       if (!err)
         {
           file->file = apr_file;
           file->stream = svn_stream_from_aprfile2(apr_file, TRUE,
                                                   file_pool);

           return SVN_NO_ERROR;
         }

       if (err && APR_STATUS_IS_ENOENT(err->apr_err))
         {
           /* Could not open the file. This may happen if the
             * file once existed but got packed later. */
           svn_error_clear(err);

           /* if that was our 2nd attempt, leave it at that. */
           if (retry)
             return svn_error_createf(SVN_ERR_FS_NO_SUCH_REVISION, NULL,
                                      _("No such revision %ld"), rev);

           /* We failed for the first time. Refresh cache & retry. */
           SVN_ERR(svn_fs_x__update_min_unpacked_rev(fs, scratch_pool));
           file->file_info.start_revision = svn_fs_x__packed_base_rev(fs, rev);

           retry = TRUE;
         }
       else
         {
           retry = FALSE;
         }
     }
   while (retry);

   return svn_error_trace(err);
 }

 svn_error_t *
 svn_fs_x__rev_file_init(svn_fs_x__revision_file_t **file,
                         svn_fs_t *fs,
                         svn_revnum_t rev,
                         apr_pool_t *result_pool)
 {
   *file = init_revision_file(fs, rev, result_pool);
   return SVN_NO_ERROR;
 }

 svn_error_t *
 svn_fs_x__rev_file_open_writable(svn_fs_x__revision_file_t** file,
                                  svn_fs_t* fs,
                                  svn_revnum_t rev,
                                  apr_pool_t* result_pool,
                                  apr_pool_t *scratch_pool)
 {
   *file = init_revision_file(fs, rev, result_pool);
   return svn_error_trace(open_pack_or_rev_file(*file, TRUE, scratch_pool));
 }

 /* If the revision file in FILE has not been opened, yet, do it now. */
 static svn_error_t *
 auto_open(svn_fs_x__revision_file_t *file)
 {
   if (file->file == NULL)
     SVN_ERR(open_pack_or_rev_file(file, FALSE, get_file_pool(file)));

   return SVN_NO_ERROR;
 }

 /* If the footer data in FILE has not been read, yet, do so now.
  * Index locations will only be read upon request as we assume they get
  * cached and the FILE is usually used for REP data access only.
  * Hence, the separate step.
  */
 static svn_error_t *
 auto_read_footer(svn_fs_x__revision_file_t *file)
 {
   if (file->l2p_info.start == -1)
     {
       apr_off_t filesize = 0;
       unsigned char footer_length;
       svn_stringbuf_t *footer;

       /* Determine file size. */
       SVN_ERR(auto_open(file));
       SVN_ERR(svn_io_file_seek(file->file, APR_END, &filesize, file->pool));

       /* Read last byte (containing the length of the footer). */
       SVN_ERR(svn_io_file_aligned_seek(file->file, file->block_size, NULL,
                                        filesize - 1, file->pool));
       SVN_ERR(svn_io_file_read_full2(file->file, &footer_length,
                                      sizeof(footer_length), NULL, NULL,
                                      file->pool));

       /* Read footer. */
       footer = svn_stringbuf_create_ensure(footer_length, file->pool);
       SVN_ERR(svn_io_file_aligned_seek(file->file, file->block_size, NULL,
                                        filesize - 1 - footer_length,
                                        file->pool));
       SVN_ERR(svn_io_file_read_full2(file->file, footer->data, footer_length,
                                      &footer->len, NULL, file->pool));
       footer->data[footer->len] = '\0';

       /* Extract index locations. */
       SVN_ERR(svn_fs_x__parse_footer(&file->l2p_info.start,
                                      &file->l2p_info.checksum,
                                      &file->p2l_info.start,
                                      &file->p2l_info.checksum,
                                      footer, file->file_info.start_revision,
                                      filesize - footer_length - 1, file->pool));
       file->l2p_info.end = file->p2l_info.start;
       file->p2l_info.end = filesize - footer_length - 1;
     }

   return SVN_NO_ERROR;
 }

 svn_error_t *
 svn_fs_x__rev_file_open_proto_rev(svn_fs_x__revision_file_t **file,
                                   svn_fs_t *fs,
                                   svn_fs_x__txn_id_t txn_id,
                                   apr_pool_t* result_pool,
                                   apr_pool_t *scratch_pool)
 {
   apr_file_t *apr_file;
   SVN_ERR(svn_io_file_open(&apr_file,
                            svn_fs_x__path_txn_proto_rev(fs, txn_id,
                                                         scratch_pool),
                            APR_READ | APR_BUFFERED, APR_OS_DEFAULT,
                            result_pool));

   return svn_error_trace(svn_fs_x__rev_file_wrap_temp(file, fs, apr_file,
                                                       result_pool));
 }

 svn_error_t *
 svn_fs_x__rev_file_wrap_temp(svn_fs_x__revision_file_t **file,
                              svn_fs_t *fs,
                              apr_file_t *temp_file,
                              apr_pool_t *result_pool)
 {
   *file = create_revision_file(fs, result_pool);
   (*file)->file = temp_file;
   (*file)->stream = svn_stream_from_aprfile2(temp_file, TRUE, result_pool);

   return SVN_NO_ERROR;
 }

 svn_error_t *
 svn_fs_x__rev_file_info(svn_fs_x__rev_file_info_t *info,
                         svn_fs_x__revision_file_t *file)
 {
   SVN_ERR(auto_open(file));

   *info = file->file_info;
   return SVN_NO_ERROR;
 }

 svn_error_t *
 svn_fs_x__rev_file_name(const char **filename,
                         svn_fs_x__revision_file_t *file,
                         apr_pool_t *result_pool)
 {
   SVN_ERR(auto_open(file));

   return svn_error_trace(svn_io_file_name_get(filename, file->file,
                                               result_pool));
 }

 svn_error_t *
 svn_fs_x__rev_file_stream(svn_stream_t **stream,
                           svn_fs_x__revision_file_t *file)
 {
   SVN_ERR(auto_open(file));

   *stream = file->stream;
   return SVN_NO_ERROR;
 }

 svn_error_t *
 svn_fs_x__rev_file_get(apr_file_t **apr_file,
                        svn_fs_x__revision_file_t *file)
 {
   SVN_ERR(auto_open(file));

   *apr_file = file->file;
   return SVN_NO_ERROR;
 }

 svn_error_t *
 svn_fs_x__rev_file_l2p_index(svn_fs_x__packed_number_stream_t **stream,
                              svn_fs_x__revision_file_t *file)
 {
   if (file->l2p_stream == NULL)
     {
       SVN_ERR(auto_read_footer(file));
       SVN_ERR(svn_fs_x__packed_stream_open(&file->l2p_stream,
                                            file->file,
                                            file->l2p_info.start,
                                            file->l2p_info.end,
                                            SVN_FS_X__L2P_STREAM_PREFIX,
                                            (apr_size_t)file->block_size,
                                            file->pool,
                                            file->pool));
     }

   *stream = file->l2p_stream;
   return SVN_NO_ERROR;
 }

 svn_error_t *
 svn_fs_x__rev_file_p2l_index(svn_fs_x__packed_number_stream_t **stream,
                              svn_fs_x__revision_file_t *file)
 {
   if (file->p2l_stream== NULL)
     {
       SVN_ERR(auto_read_footer(file));
       SVN_ERR(svn_fs_x__packed_stream_open(&file->p2l_stream,
                                            file->file,
                                            file->p2l_info.start,
                                            file->p2l_info.end,
                                            SVN_FS_X__P2L_STREAM_PREFIX,
                                            (apr_size_t)file->block_size,
                                            file->pool,
                                            file->pool));
     }

   *stream = file->p2l_stream;
   return SVN_NO_ERROR;
 }

 svn_error_t *
 svn_fs_x__rev_file_l2p_info(svn_fs_x__index_info_t *info,
                             svn_fs_x__revision_file_t *file)
 {
   SVN_ERR(auto_read_footer(file));
   *info = file->l2p_info;

   return SVN_NO_ERROR;
 }

 svn_error_t *
 svn_fs_x__rev_file_p2l_info(svn_fs_x__index_info_t *info,
                             svn_fs_x__revision_file_t *file)
 {
   SVN_ERR(auto_read_footer(file));
   *info = file->p2l_info;

   return SVN_NO_ERROR;
 }

 svn_error_t *
 svn_fs_x__rev_file_seek(svn_fs_x__revision_file_t *file,
                         apr_off_t *buffer_start,
                         apr_off_t offset)
 {
   SVN_ERR(auto_open(file));
   return svn_error_trace(svn_io_file_aligned_seek(file->file,
                                                   file->block_size,
                                                   buffer_start, offset,
                                                   file->pool));
 }

 svn_error_t *
 svn_fs_x__rev_file_offset(apr_off_t *offset,
                           svn_fs_x__revision_file_t *file)
 {
   SVN_ERR(auto_open(file));
   return svn_error_trace(svn_io_file_get_offset(offset, file->file,
                                                 file->pool));
 }

 svn_error_t *
 svn_fs_x__rev_file_read(svn_fs_x__revision_file_t *file,
                         void *buf,
                         apr_size_t nbytes)
 {
   SVN_ERR(auto_open(file));
   return svn_error_trace(svn_io_file_read_full2(file->file, buf, nbytes,
                                                 NULL, NULL, file->pool));
 }

 svn_error_t *
 svn_fs_x__close_revision_file(svn_fs_x__revision_file_t *file)
 {
   /* Close sub-objects properly */
   if (file->stream)
     SVN_ERR(svn_stream_close(file->stream));
   if (file->file)
     SVN_ERR(svn_io_file_close(file->file, file->pool));

   /* Release the memory. */
   if (file->pool)
     svn_pool_clear(file->pool);

   /* Reset pointers to objects previously allocated from FILE->POOL. */
   file->file = NULL;
   file->stream = NULL;
   file->l2p_stream = NULL;
   file->p2l_stream = NULL;

   /* Cause any index data getters to re-read the footer. */
   file->l2p_info.start = -1;
   return SVN_NO_ERROR;
 }
	/* rev_file.c --- revision file and index access functions
	*
	* ====================================================================
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	* ====================================================================
	*/

	#include "svn_pools.h"

	#include "rev_file.h"
	#include "fs_x.h"
	#include "index.h"
	#include "low_level.h"
	#include "util.h"

	#include "../libsvn_fs/fs-loader.h"

	#include "private/svn_io_private.h"
	#include "svn_private_config.h"

	struct svn_fs_x__revision_file_t
	{
	/* the filesystem that this revision file belongs to */
	svn_fs_t *fs;

	/* Meta-data to FILE. */
	svn_fs_x__rev_file_info_t file_info;

	/* rev / pack file */
	apr_file_t *file;

	/* stream based on FILE and not NULL exactly when FILE is not NULL */
	svn_stream_t *stream;

	/* the opened P2L index stream or NULL. Always NULL for txns. */
	svn_fs_x__packed_number_stream_t *p2l_stream;

	/* the opened L2P index stream or NULL. Always NULL for txns. */
	svn_fs_x__packed_number_stream_t *l2p_stream;

	/* Copied from FS->FFD->BLOCK_SIZE upon creation. It allows us to
	* use aligned seek() without having the FS handy. */
	apr_off_t block_size;

	/* Info on the L2P index within FILE.
	* Elements are -1 / NULL until svn_fs_x__auto_read_footer gets called. */
	svn_fs_x__index_info_t l2p_info;

	/* Info on the P2L index within FILE.
	* Elements are -1 / NULL until svn_fs_x__auto_read_footer gets called. */
	svn_fs_x__index_info_t p2l_info;

	/* Pool used for all sub-structure allocations (file, streams etc.).
	A sub-pool of OWNER. NULL until the lazily initilized. */
	apr_pool_t *pool;

	/* Pool that this structure got allocated in. */
	apr_pool_t *owner;
	};

	/* Return a new revision file instance, allocated in RESULT_POOL, for
	* filesystem FS. Set its pool member to the provided RESULT_POOL. */
	static svn_fs_x__revision_file_t *
	create_revision_file(svn_fs_t *fs,
	apr_pool_t *result_pool)
	{
	svn_fs_x__data_t *ffd = fs->fsap_data;

	svn_fs_x__revision_file_t file = apr_palloc(result_pool, sizeof(file));
	file->fs = fs;
	file->file_info.is_packed = FALSE;
	file->file_info.start_revision = SVN_INVALID_REVNUM;
	file->file = NULL;
	file->stream = NULL;
	file->p2l_stream = NULL;
	file->l2p_stream = NULL;
	file->block_size = ffd->block_size;
	file->l2p_info.start = -1;
	file->l2p_info.end = -1;
	file->l2p_info.checksum = NULL;
	file->p2l_info.start = -1;
	file->p2l_info.end = -1;
	file->p2l_info.checksum = NULL;
	file->pool = NULL;
	file->owner = result_pool;

	return file;
	}

	/* Return a new revision file instance, allocated in RESULT_POOL, for
	* REVISION in filesystem FS. Set its pool member to the provided
	* RESULT_POOL. */
	static svn_fs_x__revision_file_t *
	init_revision_file(svn_fs_t *fs,
	svn_revnum_t revision,
	apr_pool_t *result_pool)
	{
	svn_fs_x__revision_file_t *file = create_revision_file(fs, result_pool);

	file->file_info.is_packed = svn_fs_x__is_packed_rev(fs, revision);
	file->file_info.start_revision = svn_fs_x__packed_base_rev(fs, revision);

	return file;
	}

	/* Baton type for set_read_only() */
	typedef struct set_read_only_baton_t
	{
	/* File to set to read-only. */
	const char *file_path;

	/* Scratch pool sufficient life time.
	* Ideally the pool that we registered the cleanup on. */
	apr_pool_t *pool;
	} set_read_only_baton_t;

	/* APR pool cleanup callback taking a set_read_only_baton_t baton and then
	* (trying to) set the specified file to r/o mode. */
	static apr_status_t
	set_read_only(void *baton)
	{
	set_read_only_baton_t *ro_baton = baton;
	apr_status_t status = APR_SUCCESS;
	svn_error_t *err;

	err = svn_io_set_file_read_only(ro_baton->file_path, TRUE, ro_baton->pool);
	if (err)
	{
	status = err->apr_err;
	svn_error_clear(err);
	}

	return status;
	}

	/* If the file at PATH is read-only, attempt to make it writable. The
	* original state will be restored with RESULT_POOL gets cleaned up.
	* SCRATCH_POOL is for temporary allocations. */
	static svn_error_t *
	auto_make_writable(const char *path,
	apr_pool_t *result_pool,
	apr_pool_t *scratch_pool)
	{
	svn_boolean_t is_read_only;
	apr_finfo_t finfo;

	SVN_ERR(svn_io_stat(&finfo, path, SVN__APR_FINFO_READONLY, scratch_pool));
	SVN_ERR(svn_io__is_finfo_read_only(&is_read_only, &finfo, scratch_pool));

	if (is_read_only)
	{
	/* Tell the pool to restore the r/o state upon cleanup
	(assuming the file will still exist, failing silently otherwise). */
	set_read_only_baton_t *baton = apr_pcalloc(result_pool,
	sizeof(*baton));
	baton->pool = result_pool;
	baton->file_path = apr_pstrdup(result_pool, path);
	apr_pool_cleanup_register(result_pool, baton,
	set_read_only, apr_pool_cleanup_null);

	/* Finally, allow write access (undoing it has already been scheduled
	and is idempotent). */
	SVN_ERR(svn_io_set_file_read_write(path, FALSE, scratch_pool));
	}

	return SVN_NO_ERROR;
	}

	/* Return the pool to be used for allocations with FILE.
	Lazily created that pool upon the first call. */
	static apr_pool_t *
	get_file_pool(svn_fs_x__revision_file_t *file)
	{
	if (file->pool == NULL)
	file->pool = svn_pool_create(file->owner);

	return file->pool;
	}

	/* Core implementation of svn_fs_x__open_pack_or_rev_file working on an
	* existing, initialized FILE structure. If WRITABLE is TRUE, give write
	* access to the file - temporarily resetting the r/o state if necessary.
	*/
	static svn_error_t *
	open_pack_or_rev_file(svn_fs_x__revision_file_t *file,
	svn_boolean_t writable,
	apr_pool_t *scratch_pool)
	{
	svn_error_t *err;
	svn_boolean_t retry = FALSE;
	svn_fs_t *fs = file->fs;
	svn_revnum_t rev = file->file_info.start_revision;
	apr_pool_t *file_pool = get_file_pool(file);

	do
	{
	const char *path = svn_fs_x__path_rev_absolute(fs, rev, scratch_pool);
	apr_file_t *apr_file;
	apr_int32_t flags = writable
	? APR_READ \| APR_WRITE \| APR_BUFFERED
	: APR_READ \| APR_BUFFERED;

	/* We may have to temporarily enable write access. */
	err = writable ? auto_make_writable(path, file_pool, scratch_pool)
	: SVN_NO_ERROR;

	/* open the revision file in buffered r/o or r/w mode */
	if (!err)
	err = svn_io_file_open(&apr_file, path, flags, APR_OS_DEFAULT,
	file_pool);

	if (!err)
	{
	file->file = apr_file;
	file->stream = svn_stream_from_aprfile2(apr_file, TRUE,
	file_pool);

	return SVN_NO_ERROR;
	}

	if (err && APR_STATUS_IS_ENOENT(err->apr_err))
	{
	/* Could not open the file. This may happen if the
	* file once existed but got packed later. */
	svn_error_clear(err);

	/* if that was our 2nd attempt, leave it at that. */
	if (retry)
	return svn_error_createf(SVN_ERR_FS_NO_SUCH_REVISION, NULL,
	_("No such revision %ld"), rev);

	/* We failed for the first time. Refresh cache & retry. */
	SVN_ERR(svn_fs_x__update_min_unpacked_rev(fs, scratch_pool));
	file->file_info.start_revision = svn_fs_x__packed_base_rev(fs, rev);

	retry = TRUE;
	}
	else
	{
	retry = FALSE;
	}
	}
	while (retry);

	return svn_error_trace(err);
	}

	svn_error_t *
	svn_fs_x__rev_file_init(svn_fs_x__revision_file_t **file,
	svn_fs_t *fs,
	svn_revnum_t rev,
	apr_pool_t *result_pool)
	{
	*file = init_revision_file(fs, rev, result_pool);
	return SVN_NO_ERROR;
	}

	svn_error_t *
	svn_fs_x__rev_file_open_writable(svn_fs_x__revision_file_t** file,
	svn_fs_t* fs,
	svn_revnum_t rev,
	apr_pool_t* result_pool,
	apr_pool_t *scratch_pool)
	{
	*file = init_revision_file(fs, rev, result_pool);
	return svn_error_trace(open_pack_or_rev_file(*file, TRUE, scratch_pool));
	}

	/* If the revision file in FILE has not been opened, yet, do it now. */
	static svn_error_t *
	auto_open(svn_fs_x__revision_file_t *file)
	{
	if (file->file == NULL)
	SVN_ERR(open_pack_or_rev_file(file, FALSE, get_file_pool(file)));

	return SVN_NO_ERROR;
	}

	/* If the footer data in FILE has not been read, yet, do so now.
	* Index locations will only be read upon request as we assume they get
	* cached and the FILE is usually used for REP data access only.
	* Hence, the separate step.
	*/
	static svn_error_t *
	auto_read_footer(svn_fs_x__revision_file_t *file)
	{
	if (file->l2p_info.start == -1)
	{
	apr_off_t filesize = 0;
	unsigned char footer_length;
	svn_stringbuf_t *footer;

	/* Determine file size. */
	SVN_ERR(auto_open(file));
	SVN_ERR(svn_io_file_seek(file->file, APR_END, &filesize, file->pool));

	/* Read last byte (containing the length of the footer). */
	SVN_ERR(svn_io_file_aligned_seek(file->file, file->block_size, NULL,
	filesize - 1, file->pool));
	SVN_ERR(svn_io_file_read_full2(file->file, &footer_length,
	sizeof(footer_length), NULL, NULL,
	file->pool));

	/* Read footer. */
	footer = svn_stringbuf_create_ensure(footer_length, file->pool);
	SVN_ERR(svn_io_file_aligned_seek(file->file, file->block_size, NULL,
	filesize - 1 - footer_length,
	file->pool));
	SVN_ERR(svn_io_file_read_full2(file->file, footer->data, footer_length,
	&footer->len, NULL, file->pool));
	footer->data[footer->len] = '\0';

	/* Extract index locations. */
	SVN_ERR(svn_fs_x__parse_footer(&file->l2p_info.start,
	&file->l2p_info.checksum,
	&file->p2l_info.start,
	&file->p2l_info.checksum,
	footer, file->file_info.start_revision,
	filesize - footer_length - 1, file->pool));
	file->l2p_info.end = file->p2l_info.start;
	file->p2l_info.end = filesize - footer_length - 1;
	}

	return SVN_NO_ERROR;
	}

	svn_error_t *
	svn_fs_x__rev_file_open_proto_rev(svn_fs_x__revision_file_t **file,
	svn_fs_t *fs,
	svn_fs_x__txn_id_t txn_id,
	apr_pool_t* result_pool,
	apr_pool_t *scratch_pool)
	{
	apr_file_t *apr_file;
	SVN_ERR(svn_io_file_open(&apr_file,
	svn_fs_x__path_txn_proto_rev(fs, txn_id,
	scratch_pool),
	APR_READ \| APR_BUFFERED, APR_OS_DEFAULT,
	result_pool));

	return svn_error_trace(svn_fs_x__rev_file_wrap_temp(file, fs, apr_file,
	result_pool));
	}

	svn_error_t *
	svn_fs_x__rev_file_wrap_temp(svn_fs_x__revision_file_t **file,
	svn_fs_t *fs,
	apr_file_t *temp_file,
	apr_pool_t *result_pool)
	{
	*file = create_revision_file(fs, result_pool);
	(*file)->file = temp_file;
	(*file)->stream = svn_stream_from_aprfile2(temp_file, TRUE, result_pool);

	return SVN_NO_ERROR;
	}

	svn_error_t *
	svn_fs_x__rev_file_info(svn_fs_x__rev_file_info_t *info,
	svn_fs_x__revision_file_t *file)
	{
	SVN_ERR(auto_open(file));

	*info = file->file_info;
	return SVN_NO_ERROR;
	}

	svn_error_t *
	svn_fs_x__rev_file_name(const char **filename,
	svn_fs_x__revision_file_t *file,
	apr_pool_t *result_pool)
	{
	SVN_ERR(auto_open(file));

	return svn_error_trace(svn_io_file_name_get(filename, file->file,
	result_pool));
	}

	svn_error_t *
	svn_fs_x__rev_file_stream(svn_stream_t **stream,
	svn_fs_x__revision_file_t *file)
	{
	SVN_ERR(auto_open(file));

	*stream = file->stream;
	return SVN_NO_ERROR;
	}

	svn_error_t *
	svn_fs_x__rev_file_get(apr_file_t **apr_file,
	svn_fs_x__revision_file_t *file)
	{
	SVN_ERR(auto_open(file));

	*apr_file = file->file;
	return SVN_NO_ERROR;
	}

	svn_error_t *
	svn_fs_x__rev_file_l2p_index(svn_fs_x__packed_number_stream_t **stream,
	svn_fs_x__revision_file_t *file)
	{
	if (file->l2p_stream == NULL)
	{
	SVN_ERR(auto_read_footer(file));
	SVN_ERR(svn_fs_x__packed_stream_open(&file->l2p_stream,
	file->file,
	file->l2p_info.start,
	file->l2p_info.end,
	SVN_FS_X__L2P_STREAM_PREFIX,
	(apr_size_t)file->block_size,
	file->pool,
	file->pool));
	}

	*stream = file->l2p_stream;
	return SVN_NO_ERROR;
	}

	svn_error_t *
	svn_fs_x__rev_file_p2l_index(svn_fs_x__packed_number_stream_t **stream,
	svn_fs_x__revision_file_t *file)
	{
	if (file->p2l_stream== NULL)
	{
	SVN_ERR(auto_read_footer(file));
	SVN_ERR(svn_fs_x__packed_stream_open(&file->p2l_stream,
	file->file,
	file->p2l_info.start,
	file->p2l_info.end,
	SVN_FS_X__P2L_STREAM_PREFIX,
	(apr_size_t)file->block_size,
	file->pool,
	file->pool));
	}

	*stream = file->p2l_stream;
	return SVN_NO_ERROR;
	}

	svn_error_t *
	svn_fs_x__rev_file_l2p_info(svn_fs_x__index_info_t *info,
	svn_fs_x__revision_file_t *file)
	{
	SVN_ERR(auto_read_footer(file));
	*info = file->l2p_info;

	return SVN_NO_ERROR;
	}

	svn_error_t *
	svn_fs_x__rev_file_p2l_info(svn_fs_x__index_info_t *info,
	svn_fs_x__revision_file_t *file)
	{
	SVN_ERR(auto_read_footer(file));
	*info = file->p2l_info;

	return SVN_NO_ERROR;
	}

	svn_error_t *
	svn_fs_x__rev_file_seek(svn_fs_x__revision_file_t *file,
	apr_off_t *buffer_start,
	apr_off_t offset)
	{
	SVN_ERR(auto_open(file));
	return svn_error_trace(svn_io_file_aligned_seek(file->file,
	file->block_size,
	buffer_start, offset,
	file->pool));
	}

	svn_error_t *
	svn_fs_x__rev_file_offset(apr_off_t *offset,
	svn_fs_x__revision_file_t *file)
	{
	SVN_ERR(auto_open(file));
	return svn_error_trace(svn_io_file_get_offset(offset, file->file,
	file->pool));
	}

	svn_error_t *
	svn_fs_x__rev_file_read(svn_fs_x__revision_file_t *file,
	void *buf,
	apr_size_t nbytes)
	{
	SVN_ERR(auto_open(file));
	return svn_error_trace(svn_io_file_read_full2(file->file, buf, nbytes,
	NULL, NULL, file->pool));
	}

	svn_error_t *
	svn_fs_x__close_revision_file(svn_fs_x__revision_file_t *file)
	{
	/* Close sub-objects properly */
	if (file->stream)
	SVN_ERR(svn_stream_close(file->stream));
	if (file->file)
	SVN_ERR(svn_io_file_close(file->file, file->pool));

	/* Release the memory. */
	if (file->pool)
	svn_pool_clear(file->pool);

	/* Reset pointers to objects previously allocated from FILE->POOL. */
	file->file = NULL;
	file->stream = NULL;
	file->l2p_stream = NULL;
	file->p2l_stream = NULL;

	/* Cause any index data getters to re-read the footer. */
	file->l2p_info.start = -1;
	return SVN_NO_ERROR;
	}