You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by ju...@apache.org on 2015/01/20 18:52:21 UTC
svn commit: r1653314 [9/20] - in /subversion/branches/move-tracking-2: ./
notes/ subversion/ subversion/bindings/swig/
subversion/bindings/swig/include/ subversion/bindings/swig/perl/native/
subversion/bindings/swig/perl/native/t/ subversion/bindings/s...
Modified: subversion/branches/move-tracking-2/subversion/libsvn_fs_x/pack.c
URL: http://svn.apache.org/viewvc/subversion/branches/move-tracking-2/subversion/libsvn_fs_x/pack.c?rev=1653314&r1=1653313&r2=1653314&view=diff
==============================================================================
--- subversion/branches/move-tracking-2/subversion/libsvn_fs_x/pack.c (original)
+++ subversion/branches/move-tracking-2/subversion/libsvn_fs_x/pack.c Tue Jan 20 17:52:18 2015
@@ -101,7 +101,7 @@ typedef struct path_order_t
svn_prefix_string__t *path;
/* node ID for this PATH in REVISION */
- svn_fs_x__id_part_t node_id;
+ svn_fs_x__id_t node_id;
/* when this change happened */
svn_revnum_t revision;
@@ -113,10 +113,10 @@ typedef struct path_order_t
apr_int64_t expanded_size;
/* item ID of the noderev linked to the change. May be (0, 0). */
- svn_fs_x__id_part_t noderev_id;
+ svn_fs_x__id_t noderev_id;
/* item ID of the representation containing the new data. May be (0, 0). */
- svn_fs_x__id_part_t rep_id;
+ svn_fs_x__id_t rep_id;
} path_order_t;
/* Represents a reference from item FROM to item TO. FROM may be a noderev
@@ -125,8 +125,8 @@ typedef struct path_order_t
*/
typedef struct reference_t
{
- svn_fs_x__id_part_t to;
- svn_fs_x__id_part_t from;
+ svn_fs_x__id_t to;
+ svn_fs_x__id_t from;
} reference_t;
/* This structure keeps track of all the temporary data and status that
@@ -251,7 +251,7 @@ initialize_pack_context(pack_context_t *
void *cancel_baton,
apr_pool_t *pool)
{
- fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__data_t *ffd = fs->fsap_data;
const char *temp_dir;
int max_revs = MIN(ffd->max_files_per_dir, max_items);
@@ -326,24 +326,24 @@ initialize_pack_context(pack_context_t *
}
/* Clean up / free all revision range specific data and files in CONTEXT.
- * Use POOL for temporary allocations.
+ * Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
reset_pack_context(pack_context_t *context,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
apr_array_clear(context->changes);
- SVN_ERR(svn_io_file_trunc(context->changes_file, 0, pool));
+ SVN_ERR(svn_io_file_trunc(context->changes_file, 0, scratch_pool));
apr_array_clear(context->file_props);
- SVN_ERR(svn_io_file_trunc(context->file_props_file, 0, pool));
+ SVN_ERR(svn_io_file_trunc(context->file_props_file, 0, scratch_pool));
apr_array_clear(context->dir_props);
- SVN_ERR(svn_io_file_trunc(context->dir_props_file, 0, pool));
+ SVN_ERR(svn_io_file_trunc(context->dir_props_file, 0, scratch_pool));
apr_array_clear(context->rev_offsets);
apr_array_clear(context->path_order);
apr_array_clear(context->references);
apr_array_clear(context->reps);
- SVN_ERR(svn_io_file_trunc(context->reps_file, 0, pool));
+ SVN_ERR(svn_io_file_trunc(context->reps_file, 0, scratch_pool));
svn_pool_clear(context->info_pool);
@@ -351,50 +351,52 @@ reset_pack_context(pack_context_t *conte
}
/* Call this after the last revision range. It will finalize all index files
- * for CONTEXT and close any open files. Use POOL for temporary allocations.
+ * for CONTEXT and close any open files.
+ * Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
close_pack_context(pack_context_t *context,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
const char *proto_l2p_index_path;
const char *proto_p2l_index_path;
/* need the file names for the actual index creation call further down */
SVN_ERR(svn_io_file_name_get(&proto_l2p_index_path,
- context->proto_l2p_index, pool));
+ context->proto_l2p_index, scratch_pool));
SVN_ERR(svn_io_file_name_get(&proto_p2l_index_path,
- context->proto_p2l_index, pool));
+ context->proto_p2l_index, scratch_pool));
/* finalize proto index files */
- SVN_ERR(svn_io_file_close(context->proto_l2p_index, pool));
- SVN_ERR(svn_io_file_close(context->proto_p2l_index, pool));
+ SVN_ERR(svn_io_file_close(context->proto_l2p_index, scratch_pool));
+ SVN_ERR(svn_io_file_close(context->proto_p2l_index, scratch_pool));
/* Append the actual index data to the pack file. */
SVN_ERR(svn_fs_x__add_index_data(context->fs, context->pack_file,
proto_l2p_index_path,
proto_p2l_index_path,
context->shard_rev,
- pool));
+ scratch_pool));
/* remove proto index files */
- SVN_ERR(svn_io_remove_file2(proto_l2p_index_path, FALSE, pool));
- SVN_ERR(svn_io_remove_file2(proto_p2l_index_path, FALSE, pool));
+ SVN_ERR(svn_io_remove_file2(proto_l2p_index_path, FALSE, scratch_pool));
+ SVN_ERR(svn_io_remove_file2(proto_p2l_index_path, FALSE, scratch_pool));
- SVN_ERR(svn_io_file_close(context->pack_file, pool));
+ SVN_ERR(svn_io_file_close(context->pack_file, scratch_pool));
return SVN_NO_ERROR;
}
/* Efficiently copy SIZE bytes from SOURCE to DEST. Invoke the CANCEL_FUNC
- * from CONTEXT at regular intervals. Use POOL for allocations.
+ * from CONTEXT at regular intervals.
+ * Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
copy_file_data(pack_context_t *context,
apr_file_t *dest,
apr_file_t *source,
apr_off_t size,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
/* most non-representation items will be small. Minimize the buffer
* and infrastructure overhead in that case. */
@@ -405,17 +407,17 @@ copy_file_data(pack_context_t *context,
/* copy small data using a fixed-size buffer on stack */
char buffer[STACK_BUFFER_SIZE];
SVN_ERR(svn_io_file_read_full2(source, buffer, (apr_size_t)size,
- NULL, NULL, pool));
+ NULL, NULL, scratch_pool));
SVN_ERR(svn_io_file_write_full(dest, buffer, (apr_size_t)size,
- NULL, pool));
+ NULL, scratch_pool));
}
else
{
/* use streaming copies for larger data blocks. That may require
* the allocation of larger buffers and we should make sure that
* this extra memory is released asap. */
- fs_x_data_t *ffd = context->fs->fsap_data;
- apr_pool_t *copypool = svn_pool_create(pool);
+ svn_fs_x__data_t *ffd = context->fs->fsap_data;
+ apr_pool_t *copypool = svn_pool_create(scratch_pool);
char *buffer = apr_palloc(copypool, ffd->block_size);
while (size)
@@ -425,9 +427,9 @@ copy_file_data(pack_context_t *context,
SVN_ERR(context->cancel_func(context->cancel_baton));
SVN_ERR(svn_io_file_read_full2(source, buffer, to_copy,
- NULL, NULL, pool));
+ NULL, NULL, scratch_pool));
SVN_ERR(svn_io_file_write_full(dest, buffer, to_copy,
- NULL, pool));
+ NULL, scratch_pool));
size -= to_copy;
}
@@ -438,12 +440,13 @@ copy_file_data(pack_context_t *context,
return SVN_NO_ERROR;
}
-/* Writes SIZE bytes, all 0, to DEST. Uses POOL for allocations.
+/* Writes SIZE bytes, all 0, to DEST.
+ * Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
write_null_bytes(apr_file_t *dest,
apr_off_t size,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
/* Have a collection of high-quality, easy to access NUL bytes handy. */
enum { BUFFER_SIZE = 1024 };
@@ -453,7 +456,8 @@ write_null_bytes(apr_file_t *dest,
while (size)
{
apr_size_t to_write = MIN(size, BUFFER_SIZE);
- SVN_ERR(svn_io_file_write_full(dest, buffer, to_write, NULL, pool));
+ SVN_ERR(svn_io_file_write_full(dest, buffer, to_write, NULL,
+ scratch_pool));
size -= to_write;
}
@@ -463,7 +467,8 @@ write_null_bytes(apr_file_t *dest,
/* Copy the "simple" item (changed paths list or property representation)
* from the current position in REV_FILE to TEMP_FILE using CONTEXT. Add
* a copy of ENTRY to ENTRIES but with an updated offset value that points
- * to the copy destination in TEMP_FILE. Use POOL for allocations.
+ * to the copy destination in TEMP_FILE.
+ * Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
copy_item_to_temp(pack_context_t *context,
@@ -471,16 +476,17 @@ copy_item_to_temp(pack_context_t *contex
apr_file_t *temp_file,
svn_fs_x__revision_file_t *rev_file,
svn_fs_x__p2l_entry_t *entry,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
svn_fs_x__p2l_entry_t *new_entry
= svn_fs_x__p2l_entry_dup(entry, context->info_pool);
- new_entry->offset = 0;
- SVN_ERR(svn_io_file_seek(temp_file, APR_CUR, &new_entry->offset, pool));
+
+ SVN_ERR(svn_fs_x__get_file_offset(&new_entry->offset, temp_file,
+ scratch_pool));
APR_ARRAY_PUSH(entries, svn_fs_x__p2l_entry_t *) = new_entry;
SVN_ERR(copy_file_data(context, temp_file, rev_file->file, entry->size,
- pool));
+ scratch_pool));
return SVN_NO_ERROR;
}
@@ -530,7 +536,7 @@ add_item_rep_mapping(pack_context_t *con
*/
static svn_fs_x__p2l_entry_t *
get_item(pack_context_t *context,
- const svn_fs_x__id_part_t *id,
+ const svn_fs_x__id_t *id,
svn_boolean_t reset)
{
svn_fs_x__p2l_entry_t *result = NULL;
@@ -551,13 +557,14 @@ get_item(pack_context_t *context,
/* Copy representation item identified by ENTRY from the current position
* in REV_FILE into CONTEXT->REPS_FILE. Add all tracking into needed by
- * our placement algorithm to CONTEXT. Use POOL for temporary allocations.
+ * our placement algorithm to CONTEXT.
+ * Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
copy_rep_to_temp(pack_context_t *context,
svn_fs_x__revision_file_t *rev_file,
svn_fs_x__p2l_entry_t *entry,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
svn_fs_x__rep_header_t *rep_header;
apr_off_t source_offset = entry->offset;
@@ -565,14 +572,13 @@ copy_rep_to_temp(pack_context_t *context
/* create a copy of ENTRY, make it point to the copy destination and
* store it in CONTEXT */
entry = svn_fs_x__p2l_entry_dup(entry, context->info_pool);
- entry->offset = 0;
- SVN_ERR(svn_io_file_seek(context->reps_file, APR_CUR, &entry->offset,
- pool));
+ SVN_ERR(svn_fs_x__get_file_offset(&entry->offset, context->reps_file,
+ scratch_pool));
add_item_rep_mapping(context, entry);
/* read & parse the representation header */
- SVN_ERR(svn_fs_x__read_rep_header(&rep_header, rev_file->stream, pool,
- pool));
+ SVN_ERR(svn_fs_x__read_rep_header(&rep_header, rev_file->stream,
+ scratch_pool, scratch_pool));
/* if the representation is a delta against some other rep, link the two */
if ( rep_header->type == svn_fs_x__rep_delta
@@ -588,9 +594,10 @@ copy_rep_to_temp(pack_context_t *context
}
/* copy the whole rep (including header!) to our temp file */
- SVN_ERR(svn_io_file_seek(rev_file->file, APR_SET, &source_offset, pool));
+ SVN_ERR(svn_io_file_seek(rev_file->file, APR_SET, &source_offset,
+ scratch_pool));
SVN_ERR(copy_file_data(context, context->reps_file, rev_file->file,
- entry->size, pool));
+ entry->size, scratch_pool));
return SVN_NO_ERROR;
}
@@ -667,35 +674,37 @@ tweak_path_for_ordering(const char *orig
/* Copy node revision item identified by ENTRY from the current position
* in REV_FILE into CONTEXT->REPS_FILE. Add all tracking into needed by
- * our placement algorithm to CONTEXT. Use POOL for temporary allocations.
+ * our placement algorithm to CONTEXT.
+ * Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
copy_node_to_temp(pack_context_t *context,
svn_fs_x__revision_file_t *rev_file,
svn_fs_x__p2l_entry_t *entry,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
path_order_t *path_order = apr_pcalloc(context->info_pool,
sizeof(*path_order));
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
const char *sort_path;
apr_off_t source_offset = entry->offset;
/* read & parse noderev */
- SVN_ERR(svn_fs_x__read_noderev(&noderev, rev_file->stream, pool, pool));
+ SVN_ERR(svn_fs_x__read_noderev(&noderev, rev_file->stream, scratch_pool,
+ scratch_pool));
/* create a copy of ENTRY, make it point to the copy destination and
* store it in CONTEXT */
entry = svn_fs_x__p2l_entry_dup(entry, context->info_pool);
- entry->offset = 0;
- SVN_ERR(svn_io_file_seek(context->reps_file, APR_CUR,
- &entry->offset, pool));
+ SVN_ERR(svn_fs_x__get_file_offset(&entry->offset, context->reps_file,
+ scratch_pool));
add_item_rep_mapping(context, entry);
/* copy the noderev to our temp file */
- SVN_ERR(svn_io_file_seek(rev_file->file, APR_SET, &source_offset, pool));
+ SVN_ERR(svn_io_file_seek(rev_file->file, APR_SET, &source_offset,
+ scratch_pool));
SVN_ERR(copy_file_data(context, context->reps_file, rev_file->file,
- entry->size, pool));
+ entry->size, scratch_pool));
/* if the node has a data representation, make that the node's "base".
* This will (often) cause the noderev to be placed right in front of
@@ -718,12 +727,12 @@ copy_node_to_temp(pack_context_t *contex
/* Sort path is the key used for ordering noderevs and associated reps.
* It will not be stored in the final pack file. */
- sort_path = tweak_path_for_ordering(noderev->created_path, pool);
+ sort_path = tweak_path_for_ordering(noderev->created_path, scratch_pool);
path_order->path = svn_prefix_string__create(context->paths, sort_path);
- path_order->node_id = *svn_fs_x__id_node_id(noderev->id);
- path_order->revision = svn_fs_x__id_rev(noderev->id);
+ path_order->node_id = noderev->node_id;
+ path_order->revision = svn_fs_x__get_revnum(noderev->noderev_id.change_set);
path_order->is_dir = noderev->kind == svn_node_dir;
- path_order->noderev_id = *svn_fs_x__id_noderev_id(noderev->id);
+ path_order->noderev_id = noderev->noderev_id;
APR_ARRAY_PUSH(context->path_order, path_order_t *) = path_order;
return SVN_NO_ERROR;
@@ -777,7 +786,7 @@ compare_path_order(const path_order_t *
return diff;
/* reverse order on node (i.e. latest first) */
- diff = svn_fs_x__id_part_compare(&rhs->node_id, &lhs->node_id);
+ diff = svn_fs_x__id_compare(&rhs->node_id, &lhs->node_id);
if (diff)
return diff;
@@ -797,8 +806,8 @@ compare_references(const reference_t * c
const reference_t * lhs = *lhs_p;
const reference_t * rhs = *rhs_p;
- int diff = svn_fs_x__id_part_compare(&lhs->to, &rhs->to);
- return diff ? diff : svn_fs_x__id_part_compare(&lhs->from, &rhs->from);
+ int diff = svn_fs_x__id_compare(&lhs->to, &rhs->to);
+ return diff ? diff : svn_fs_x__id_compare(&lhs->from, &rhs->from);
}
/* Order the data collected in CONTEXT such that we can place them in the
@@ -819,20 +828,20 @@ sort_reps(pack_context_t *context)
static apr_ssize_t
get_block_left(pack_context_t *context)
{
- fs_x_data_t *ffd = context->fs->fsap_data;
+ svn_fs_x__data_t *ffd = context->fs->fsap_data;
return ffd->block_size - (context->pack_offset % ffd->block_size);
}
/* To prevent items from overlapping a block boundary, we will usually
* put them into the next block and top up the old one with NUL bytes.
* Pad CONTEXT's pack file to the end of the current block, if that padding
- * is short enough. Use POOL for allocations.
+ * is short enough. Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
auto_pad_block(pack_context_t *context,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- fs_x_data_t *ffd = context->fs->fsap_data;
+ svn_fs_x__data_t *ffd = context->fs->fsap_data;
/* This is the maximum number of bytes "wasted" that way per block.
* Larger items will cross the block boundaries. */
@@ -855,9 +864,9 @@ auto_pad_block(pack_context_t *context,
null_entry.item_count = 0;
null_entry.items = NULL;
- SVN_ERR(write_null_bytes(context->pack_file, padding, pool));
+ SVN_ERR(write_null_bytes(context->pack_file, padding, scratch_pool));
SVN_ERR(svn_fs_x__p2l_proto_index_add_entry
- (context->proto_p2l_index, &null_entry, pool));
+ (context->proto_p2l_index, &null_entry, scratch_pool));
context->pack_offset += padding;
}
@@ -881,7 +890,7 @@ find_first_reference(pack_context_t *con
reference_t *reference
= APR_ARRAY_IDX(context->references, current, reference_t *);
- if (svn_fs_x__id_part_compare(&reference->to, item->items) < 0)
+ if (svn_fs_x__id_compare(&reference->to, item->items) < 0)
lower = current + 1;
else
upper = current - 1;
@@ -902,7 +911,7 @@ is_reference_match(pack_context_t *conte
return FALSE;
reference = APR_ARRAY_IDX(context->references, idx, reference_t *);
- return svn_fs_x__id_part_eq(&reference->to, item->items);
+ return svn_fs_x__id_eq(&reference->to, item->items);
}
/* Starting at IDX in CONTEXT->PATH_ORDER, select all representations and
@@ -939,8 +948,7 @@ select_reps(pack_context_t *context,
path_order_t *current_path
= APR_ARRAY_IDX(path_order, idx, path_order_t *);
- if (!svn_fs_x__id_part_eq(&start_path->node_id,
- ¤t_path->node_id))
+ if (!svn_fs_x__id_eq(&start_path->node_id, ¤t_path->node_id))
break;
APR_ARRAY_IDX(path_order, idx, path_order_t *) = NULL;
@@ -1039,7 +1047,7 @@ write_nodes_container(pack_context_t *co
container_entry->type = SVN_FS_X__ITEM_TYPE_NODEREVS_CONT;
container_entry->item_count = items->nelts;
container_entry->items = apr_palloc(context->info_pool,
- sizeof(svn_fs_x__id_part_t) * container_entry->item_count);
+ sizeof(svn_fs_x__id_t) * container_entry->item_count);
for (i = 0; i < items->nelts; ++i)
container_entry->items[i]
@@ -1094,7 +1102,7 @@ store_nodes(pack_context_t *context,
apr_size_t pack_savings = 0;
for (i = 0; i < node_parts->nelts; ++i)
{
- node_revision_t *noderev;
+ svn_fs_x__noderev_t *noderev;
svn_fs_x__p2l_entry_t *entry
= APR_ARRAY_IDX(node_parts, i, svn_fs_x__p2l_entry_t *);
@@ -1161,14 +1169,14 @@ store_nodes(pack_context_t *context,
/* Finalize CONTAINER and write it to CONTEXT's pack file.
* Append an P2L entry containing the given SUB_ITEMS to NEW_ENTRIES.
- * Use POOL for temporary allocations.
+ * Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
write_reps_container(pack_context_t *context,
svn_fs_x__reps_builder_t *container,
apr_array_header_t *sub_items,
apr_array_header_t *new_entries,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
apr_off_t offset = 0;
svn_fs_x__p2l_entry_t container_entry;
@@ -1177,42 +1185,44 @@ write_reps_container(pack_context_t *con
= svn_checksum__wrap_write_stream_fnv1a_32x4
(&container_entry.fnv1_checksum,
svn_stream_from_aprfile2(context->pack_file,
- TRUE, pool),
- pool);
+ TRUE, scratch_pool),
+ scratch_pool);
- SVN_ERR(svn_fs_x__write_reps_container(pack_stream, container, pool));
+ SVN_ERR(svn_fs_x__write_reps_container(pack_stream, container,
+ scratch_pool));
SVN_ERR(svn_stream_close(pack_stream));
- SVN_ERR(svn_io_file_seek(context->pack_file, APR_CUR, &offset, pool));
+ SVN_ERR(svn_io_file_seek(context->pack_file, APR_CUR, &offset,
+ scratch_pool));
container_entry.offset = context->pack_offset;
container_entry.size = offset - container_entry.offset;
container_entry.type = SVN_FS_X__ITEM_TYPE_REPS_CONT;
container_entry.item_count = sub_items->nelts;
- container_entry.items = (svn_fs_x__id_part_t *)sub_items->elts;
+ container_entry.items = (svn_fs_x__id_t *)sub_items->elts;
context->pack_offset = offset;
APR_ARRAY_PUSH(new_entries, svn_fs_x__p2l_entry_t *)
= svn_fs_x__p2l_entry_dup(&container_entry, context->info_pool);
SVN_ERR(svn_fs_x__p2l_proto_index_add_entry
- (context->proto_p2l_index, &container_entry, pool));
+ (context->proto_p2l_index, &container_entry, scratch_pool));
return SVN_NO_ERROR;
}
/* Read the (property) representations identified by svn_fs_x__p2l_entry_t
* elements in ENTRIES from TEMP_FILE, aggregate them and write them into
- * CONTEXT->PACK_FILE. Use POOL for temporary allocations.
+ * CONTEXT->PACK_FILE. Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
write_reps_containers(pack_context_t *context,
apr_array_header_t *entries,
apr_file_t *temp_file,
apr_array_header_t *new_entries,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- apr_pool_t *iterpool = svn_pool_create(pool);
- apr_pool_t *container_pool = svn_pool_create(pool);
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+ apr_pool_t *container_pool = svn_pool_create(scratch_pool);
int i;
apr_ssize_t block_left = get_block_left(context);
@@ -1220,15 +1230,16 @@ write_reps_containers(pack_context_t *co
svn_fs_x__reps_builder_t *container
= svn_fs_x__reps_builder_create(context->fs, container_pool);
apr_array_header_t *sub_items
- = apr_array_make(pool, 64, sizeof(svn_fs_x__id_part_t));
+ = apr_array_make(scratch_pool, 64, sizeof(svn_fs_x__id_t));
svn_fs_x__revision_file_t *file;
- SVN_ERR(svn_fs_x__wrap_temp_rev_file(&file, context->fs, temp_file, pool));
+ SVN_ERR(svn_fs_x__wrap_temp_rev_file(&file, context->fs, temp_file,
+ scratch_pool));
/* copy all items in strict order */
for (i = entries->nelts-1; i >= 0; --i)
{
- representation_t representation = { 0 };
+ svn_fs_x__representation_t representation = { 0 };
svn_stringbuf_t *contents;
svn_stream_t *stream;
apr_size_t list_index;
@@ -1286,7 +1297,7 @@ write_reps_containers(pack_context_t *co
SVN_ERR_ASSERT(list_index == sub_items->nelts);
block_left -= entry->size;
- APR_ARRAY_PUSH(sub_items, svn_fs_x__id_part_t) = entry->items[0];
+ APR_ARRAY_PUSH(sub_items, svn_fs_x__id_t) = entry->items[0];
svn_pool_clear(iterpool);
}
@@ -1328,17 +1339,17 @@ should_flush_nodes_container(pack_contex
/* Read the contents of the first COUNT non-NULL, non-empty items in ITEMS
* from TEMP_FILE and write them to CONTEXT->PACK_FILE.
- * Use POOL for allocations.
+ * Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
store_items(pack_context_t *context,
apr_file_t *temp_file,
apr_array_header_t *items,
int count,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
int i;
- apr_pool_t *iterpool = svn_pool_create(pool);
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
/* copy all items in strict order */
for (i = 0; i < count; ++i)
@@ -1375,26 +1386,26 @@ store_items(pack_context_t *context,
/* Copy (append) the items identified by svn_fs_x__p2l_entry_t * elements
* in ENTRIES strictly in order from TEMP_FILE into CONTEXT->PACK_FILE.
- * Use POOL for temporary allocations.
+ * Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
copy_reps_from_temp(pack_context_t *context,
apr_file_t *temp_file,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- fs_x_data_t *ffd = context->fs->fsap_data;
+ svn_fs_x__data_t *ffd = context->fs->fsap_data;
- apr_pool_t *iterpool = svn_pool_create(pool);
- apr_pool_t *container_pool = svn_pool_create(pool);
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+ apr_pool_t *container_pool = svn_pool_create(scratch_pool);
apr_array_header_t *path_order = context->path_order;
apr_array_header_t *reps = context->reps;
- apr_array_header_t *selected = apr_array_make(pool, 16,
+ apr_array_header_t *selected = apr_array_make(scratch_pool, 16,
path_order->elt_size);
- apr_array_header_t *node_parts = apr_array_make(pool, 16,
+ apr_array_header_t *node_parts = apr_array_make(scratch_pool, 16,
reps->elt_size);
- apr_array_header_t *rep_parts = apr_array_make(pool, 16,
+ apr_array_header_t *rep_parts = apr_array_make(scratch_pool, 16,
reps->elt_size);
- apr_array_header_t *nodes_in_container = apr_array_make(pool, 16,
+ apr_array_header_t *nodes_in_container = apr_array_make(scratch_pool, 16,
reps->elt_size);
int i, k;
int initial_reps_count = reps->nelts;
@@ -1450,7 +1461,8 @@ copy_reps_from_temp(pack_context_t *cont
iterpool));
/* copy all items in strict order */
- SVN_ERR(store_items(context, temp_file, reps, initial_reps_count, pool));
+ SVN_ERR(store_items(context, temp_file, reps, initial_reps_count,
+ scratch_pool));
/* vaccum ENTRIES array: eliminate NULL entries */
for (i = 0, k = 0; i < reps->nelts; ++i)
@@ -1473,14 +1485,14 @@ copy_reps_from_temp(pack_context_t *cont
/* Finalize CONTAINER and write it to CONTEXT's pack file.
* Append an P2L entry containing the given SUB_ITEMS to NEW_ENTRIES.
- * Use POOL for temporary allocations.
+ * Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
write_changes_container(pack_context_t *context,
svn_fs_x__changes_t *container,
apr_array_header_t *sub_items,
apr_array_header_t *new_entries,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
apr_off_t offset = 0;
svn_fs_x__p2l_entry_t container_entry;
@@ -1489,43 +1501,44 @@ write_changes_container(pack_context_t *
= svn_checksum__wrap_write_stream_fnv1a_32x4
(&container_entry.fnv1_checksum,
svn_stream_from_aprfile2(context->pack_file,
- TRUE, pool),
- pool);
+ TRUE, scratch_pool),
+ scratch_pool);
SVN_ERR(svn_fs_x__write_changes_container(pack_stream,
container,
- pool));
+ scratch_pool));
SVN_ERR(svn_stream_close(pack_stream));
- SVN_ERR(svn_io_file_seek(context->pack_file, APR_CUR, &offset, pool));
+ SVN_ERR(svn_io_file_seek(context->pack_file, APR_CUR, &offset,
+ scratch_pool));
container_entry.offset = context->pack_offset;
container_entry.size = offset - container_entry.offset;
container_entry.type = SVN_FS_X__ITEM_TYPE_CHANGES_CONT;
container_entry.item_count = sub_items->nelts;
- container_entry.items = (svn_fs_x__id_part_t *)sub_items->elts;
+ container_entry.items = (svn_fs_x__id_t *)sub_items->elts;
context->pack_offset = offset;
APR_ARRAY_PUSH(new_entries, svn_fs_x__p2l_entry_t *)
= svn_fs_x__p2l_entry_dup(&container_entry, context->info_pool);
SVN_ERR(svn_fs_x__p2l_proto_index_add_entry
- (context->proto_p2l_index, &container_entry, pool));
+ (context->proto_p2l_index, &container_entry, scratch_pool));
return SVN_NO_ERROR;
}
/* Read the change lists identified by svn_fs_x__p2l_entry_t * elements
* in ENTRIES strictly in from TEMP_FILE, aggregate them and write them
- * into CONTEXT->PACK_FILE. Use POOL for temporary allocations.
+ * into CONTEXT->PACK_FILE. Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
write_changes_containers(pack_context_t *context,
apr_array_header_t *entries,
apr_file_t *temp_file,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- apr_pool_t *iterpool = svn_pool_create(pool);
- apr_pool_t *container_pool = svn_pool_create(pool);
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+ apr_pool_t *container_pool = svn_pool_create(scratch_pool);
int i;
apr_ssize_t block_left = get_block_left(context);
@@ -1534,11 +1547,11 @@ write_changes_containers(pack_context_t
svn_fs_x__changes_t *container
= svn_fs_x__changes_create(1000, container_pool);
apr_array_header_t *sub_items
- = apr_array_make(pool, 64, sizeof(svn_fs_x__id_part_t));
+ = apr_array_make(scratch_pool, 64, sizeof(svn_fs_x__id_t));
apr_array_header_t *new_entries
= apr_array_make(context->info_pool, 16, entries->elt_size);
svn_stream_t *temp_stream
- = svn_stream_from_aprfile2(temp_file, TRUE, pool);
+ = svn_stream_from_aprfile2(temp_file, TRUE, scratch_pool);
/* copy all items in strict order */
for (i = entries->nelts-1; i >= 0; --i)
@@ -1594,13 +1607,14 @@ write_changes_containers(pack_context_t
* the container */
SVN_ERR(svn_io_file_seek(temp_file, APR_SET, &entry->offset,
iterpool));
- SVN_ERR(svn_fs_x__read_changes(&changes, temp_stream, pool, iterpool));
+ SVN_ERR(svn_fs_x__read_changes(&changes, temp_stream, scratch_pool,
+ iterpool));
SVN_ERR(svn_fs_x__changes_append_list(&list_index, container, changes));
SVN_ERR_ASSERT(list_index == sub_items->nelts);
block_left -= estimated_size;
estimated_addition += estimated_size;
- APR_ARRAY_PUSH(sub_items, svn_fs_x__id_part_t) = entry->items[0];
+ APR_ARRAY_PUSH(sub_items, svn_fs_x__id_t) = entry->items[0];
svn_pool_clear(iterpool);
}
@@ -1618,19 +1632,19 @@ write_changes_containers(pack_context_t
/* Read the (property) representations identified by svn_fs_x__p2l_entry_t
* elements in ENTRIES from TEMP_FILE, aggregate them and write them into
- * CONTEXT->PACK_FILE. Use POOL for temporary allocations.
+ * CONTEXT->PACK_FILE. Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
write_property_containers(pack_context_t *context,
apr_array_header_t *entries,
apr_file_t *temp_file,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
apr_array_header_t *new_entries
= apr_array_make(context->info_pool, 16, entries->elt_size);
SVN_ERR(write_reps_containers(context, entries, temp_file, new_entries,
- pool));
+ scratch_pool));
*entries = *new_entries;
@@ -1692,15 +1706,15 @@ write_l2p_index(pack_context_t *context,
}
/* Pack the current revision range of CONTEXT, i.e. this covers phases 2
- * to 4. Use POOL for allocations.
+ * to 4. Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
pack_range(pack_context_t *context,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- fs_x_data_t *ffd = context->fs->fsap_data;
- apr_pool_t *revpool = svn_pool_create(pool);
- apr_pool_t *iterpool = svn_pool_create(pool);
+ svn_fs_x__data_t *ffd = context->fs->fsap_data;
+ apr_pool_t *revpool = svn_pool_create(scratch_pool);
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
/* Phase 2: Copy items into various buckets and build tracking info */
svn_revnum_t revision;
@@ -1818,15 +1832,15 @@ pack_range(pack_context_t *context,
/* Append CONTEXT->START_REV to the context's pack file with no re-ordering.
* This function will only be used for very large revisions (>>100k changes).
- * Use POOL for temporary allocations.
+ * Use SCRATCH_POOL for temporary allocations.
*/
static svn_error_t *
append_revision(pack_context_t *context,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- fs_x_data_t *ffd = context->fs->fsap_data;
+ svn_fs_x__data_t *ffd = context->fs->fsap_data;
apr_off_t offset = 0;
- apr_pool_t *iterpool = svn_pool_create(pool);
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
svn_fs_x__revision_file_t *rev_file;
apr_finfo_t finfo;
@@ -1834,19 +1848,19 @@ append_revision(pack_context_t *context,
const char *path = svn_dirent_join(context->shard_dir,
apr_psprintf(iterpool, "%ld",
context->start_rev),
- pool);
- SVN_ERR(svn_io_stat(&finfo, path, APR_FINFO_SIZE, pool));
+ scratch_pool);
+ SVN_ERR(svn_io_stat(&finfo, path, APR_FINFO_SIZE, scratch_pool));
/* Copy all the bits from the rev file to the end of the pack file. */
SVN_ERR(svn_fs_x__open_pack_or_rev_file(&rev_file, context->fs,
- context->start_rev, pool,
+ context->start_rev, scratch_pool,
iterpool));
SVN_ERR(copy_file_data(context, context->pack_file, rev_file->file,
finfo.size, iterpool));
/* mark the start of a new revision */
SVN_ERR(svn_fs_x__l2p_proto_index_add_revision(context->proto_l2p_index,
- pool));
+ scratch_pool));
/* read the phys-to-log index file until we covered the whole rev file.
* That index contains enough info to build both target indexes from it. */
@@ -1899,9 +1913,9 @@ append_revision(pack_context_t *context,
/* Format 7 packing logic.
*
* Pack the revision shard starting at SHARD_REV in filesystem FS from
- * SHARD_DIR into the PACK_FILE_DIR, using POOL for allocations. Limit
- * the extra memory consumption to MAX_MEM bytes. CANCEL_FUNC and
- * CANCEL_BATON are what you think they are.
+ * SHARD_DIR into the PACK_FILE_DIR, using SCRATCH_POOL for temporary
+ * allocations. Limit the extra memory consumption to MAX_MEM bytes.
+ * CANCEL_FUNC and CANCEL_BATON are what you think they are.
*/
static svn_error_t *
pack_log_addressed(svn_fs_t *fs,
@@ -1911,7 +1925,7 @@ pack_log_addressed(svn_fs_t *fs,
apr_size_t max_mem,
svn_cancel_func_t cancel_func,
void *cancel_baton,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
enum
{
@@ -1931,17 +1945,17 @@ pack_log_addressed(svn_fs_t *fs,
pack_context_t context = { 0 };
int i;
apr_size_t item_count = 0;
- apr_pool_t *iterpool = svn_pool_create(pool);
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
/* set up a pack context */
SVN_ERR(initialize_pack_context(&context, fs, pack_file_dir, shard_dir,
shard_rev, max_items, cancel_func,
- cancel_baton, pool));
+ cancel_baton, scratch_pool));
/* phase 1: determine the size of the revisions to pack */
SVN_ERR(svn_fs_x__l2p_get_max_ids(&max_ids, fs, shard_rev,
context.shard_end_rev - shard_rev,
- pool, pool));
+ scratch_pool, scratch_pool));
/* pack revisions in ranges that don't exceed MAX_MEM */
for (i = 0; i < max_ids->nelts; ++i)
@@ -1989,14 +2003,14 @@ pack_log_addressed(svn_fs_t *fs,
}
/* Given REV in FS, set *REV_OFFSET to REV's offset in the packed file.
- Use POOL for temporary allocations. */
+ Use SCRATCH_POOL for temporary allocations. */
svn_error_t *
svn_fs_x__get_packed_offset(apr_off_t *rev_offset,
svn_fs_t *fs,
svn_revnum_t rev,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__data_t *ffd = fs->fsap_data;
svn_stream_t *manifest_stream;
svn_boolean_t is_cached;
svn_revnum_t shard;
@@ -2014,20 +2028,22 @@ svn_fs_x__get_packed_offset(apr_off_t *r
SVN_ERR(svn_cache__get_partial((void **) rev_offset, &is_cached,
ffd->packed_offset_cache, &shard,
svn_fs_x__get_sharded_offset, &shard_pos,
- pool));
+ scratch_pool));
if (is_cached)
return SVN_NO_ERROR;
/* Open the manifest file. */
SVN_ERR(svn_stream_open_readonly(&manifest_stream,
- svn_fs_x__path_rev_packed(fs, rev, PATH_MANIFEST, pool),
- pool, pool));
+ svn_fs_x__path_rev_packed(fs, rev, PATH_MANIFEST,
+ scratch_pool),
+ scratch_pool, scratch_pool));
/* While we're here, let's just read the entire manifest file into an array,
so we can cache the entire thing. */
- iterpool = svn_pool_create(pool);
- manifest = apr_array_make(pool, ffd->max_files_per_dir, sizeof(apr_off_t));
+ iterpool = svn_pool_create(scratch_pool);
+ manifest = apr_array_make(scratch_pool, ffd->max_files_per_dir,
+ sizeof(apr_off_t));
while (1)
{
svn_boolean_t eof;
@@ -2048,14 +2064,15 @@ svn_fs_x__get_packed_offset(apr_off_t *r
/* Close up shop and cache the array. */
SVN_ERR(svn_stream_close(manifest_stream));
- return svn_cache__set(ffd->packed_offset_cache, &shard, manifest, pool);
+ return svn_cache__set(ffd->packed_offset_cache, &shard, manifest,
+ scratch_pool);
}
/* In filesystem FS, pack the revision SHARD containing exactly
* MAX_FILES_PER_DIR revisions from SHARD_PATH into the PACK_FILE_DIR,
- * using POOL for allocations. Try to limit the amount of temporary
- * memory needed to MAX_MEM bytes. CANCEL_FUNC and CANCEL_BATON are what
- * you think they are.
+ * using SCRATCH_POOL for temporary allocations. Try to limit the amount of
+ * temporary memory needed to MAX_MEM bytes. CANCEL_FUNC and CANCEL_BATON
+ * are what you think they are.
*
* If for some reason we detect a partial packing already performed, we
* remove the pack file and start again.
@@ -2071,36 +2088,37 @@ pack_rev_shard(svn_fs_t *fs,
apr_size_t max_mem,
svn_cancel_func_t cancel_func,
void *cancel_baton,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
const char *pack_file_path;
svn_revnum_t shard_rev = (svn_revnum_t) (shard * max_files_per_dir);
/* Some useful paths. */
- pack_file_path = svn_dirent_join(pack_file_dir, PATH_PACKED, pool);
+ pack_file_path = svn_dirent_join(pack_file_dir, PATH_PACKED, scratch_pool);
/* Remove any existing pack file for this shard, since it is incomplete. */
SVN_ERR(svn_io_remove_dir2(pack_file_dir, TRUE, cancel_func, cancel_baton,
- pool));
+ scratch_pool));
/* Create the new directory and pack file. */
- SVN_ERR(svn_io_dir_make(pack_file_dir, APR_OS_DEFAULT, pool));
+ SVN_ERR(svn_io_dir_make(pack_file_dir, APR_OS_DEFAULT, scratch_pool));
/* Index information files */
SVN_ERR(pack_log_addressed(fs, pack_file_dir, shard_path, shard_rev,
- max_mem, cancel_func, cancel_baton, pool));
+ max_mem, cancel_func, cancel_baton,
+ scratch_pool));
- SVN_ERR(svn_io_copy_perms(shard_path, pack_file_dir, pool));
- SVN_ERR(svn_io_set_file_read_only(pack_file_path, FALSE, pool));
+ SVN_ERR(svn_io_copy_perms(shard_path, pack_file_dir, scratch_pool));
+ SVN_ERR(svn_io_set_file_read_only(pack_file_path, FALSE, scratch_pool));
return SVN_NO_ERROR;
}
/* In the file system at FS_PATH, pack the SHARD in REVS_DIR and
- * REVPROPS_DIR containing exactly MAX_FILES_PER_DIR revisions, using POOL
- * for allocations. REVPROPS_DIR will be NULL if revprop packing is not
- * supported. COMPRESSION_LEVEL and MAX_PACK_SIZE will be ignored in that
- * case.
+ * REVPROPS_DIR containing exactly MAX_FILES_PER_DIR revisions, using
+ * SCRATCH_POOL temporary for allocations. REVPROPS_DIR will be NULL if
+ * revprop packing is not supported. COMPRESSION_LEVEL and MAX_PACK_SIZE
+ * will be ignored in that case.
*
* CANCEL_FUNC and CANCEL_BATON are what you think they are; similarly
* NOTIFY_FUNC and NOTIFY_BATON.
@@ -2120,43 +2138,43 @@ pack_shard(const char *revs_dir,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__data_t *ffd = fs->fsap_data;
const char *rev_shard_path, *rev_pack_file_dir;
const char *revprops_shard_path, *revprops_pack_file_dir;
/* Notify caller we're starting to pack this shard. */
if (notify_func)
SVN_ERR(notify_func(notify_baton, shard, svn_fs_pack_notify_start,
- pool));
+ scratch_pool));
/* Some useful paths. */
rev_pack_file_dir = svn_dirent_join(revs_dir,
- apr_psprintf(pool,
+ apr_psprintf(scratch_pool,
"%" APR_INT64_T_FMT PATH_EXT_PACKED_SHARD,
shard),
- pool);
+ scratch_pool);
rev_shard_path = svn_dirent_join(revs_dir,
- apr_psprintf(pool, "%" APR_INT64_T_FMT, shard),
- pool);
+ apr_psprintf(scratch_pool, "%" APR_INT64_T_FMT, shard),
+ scratch_pool);
/* pack the revision content */
SVN_ERR(pack_rev_shard(fs, rev_pack_file_dir, rev_shard_path,
shard, max_files_per_dir, DEFAULT_MAX_MEM,
- cancel_func, cancel_baton, pool));
+ cancel_func, cancel_baton, scratch_pool));
/* if enabled, pack the revprops in an equivalent way */
if (revsprops_dir)
{
revprops_pack_file_dir = svn_dirent_join(revsprops_dir,
- apr_psprintf(pool,
+ apr_psprintf(scratch_pool,
"%" APR_INT64_T_FMT PATH_EXT_PACKED_SHARD,
shard),
- pool);
+ scratch_pool);
revprops_shard_path = svn_dirent_join(revsprops_dir,
- apr_psprintf(pool, "%" APR_INT64_T_FMT, shard),
- pool);
+ apr_psprintf(scratch_pool, "%" APR_INT64_T_FMT, shard),
+ scratch_pool);
SVN_ERR(svn_fs_x__pack_revprops_shard(revprops_pack_file_dir,
revprops_shard_path,
@@ -2164,20 +2182,20 @@ pack_shard(const char *revs_dir,
(int)(0.9 * max_pack_size),
compression_level,
cancel_func, cancel_baton,
- pool));
+ scratch_pool));
}
/* Update the min-unpacked-rev file to reflect our newly packed shard. */
SVN_ERR(svn_fs_x__write_min_unpacked_rev(fs,
(svn_revnum_t)((shard + 1) * max_files_per_dir),
- pool));
+ scratch_pool));
ffd->min_unpacked_rev = (svn_revnum_t)((shard + 1) * max_files_per_dir);
/* Finally, remove the existing shard directories.
* For revprops, clean up older obsolete shards as well as they might
* have been left over from an interrupted FS upgrade. */
SVN_ERR(svn_io_remove_dir2(rev_shard_path, TRUE,
- cancel_func, cancel_baton, pool));
+ cancel_func, cancel_baton, scratch_pool));
if (revsprops_dir)
{
svn_node_kind_t kind = svn_node_dir;
@@ -2188,15 +2206,17 @@ pack_shard(const char *revs_dir,
to_cleanup,
max_files_per_dir,
cancel_func, cancel_baton,
- pool));
+ scratch_pool));
/* If the previous shard exists, clean it up as well.
Don't try to clean up shard 0 as it we can't tell quickly
whether it actually needs cleaning up. */
revprops_shard_path = svn_dirent_join(revsprops_dir,
- apr_psprintf(pool, "%" APR_INT64_T_FMT, --to_cleanup),
- pool);
- SVN_ERR(svn_io_check_path(revprops_shard_path, &kind, pool));
+ apr_psprintf(scratch_pool,
+ "%" APR_INT64_T_FMT,
+ --to_cleanup),
+ scratch_pool);
+ SVN_ERR(svn_io_check_path(revprops_shard_path, &kind, scratch_pool));
}
while (kind == svn_node_dir && to_cleanup > 0);
}
@@ -2204,24 +2224,24 @@ pack_shard(const char *revs_dir,
/* Notify caller we're starting to pack this shard. */
if (notify_func)
SVN_ERR(notify_func(notify_baton, shard, svn_fs_pack_notify_end,
- pool));
+ scratch_pool));
return SVN_NO_ERROR;
}
-struct pack_baton
+typedef struct pack_baton_t
{
svn_fs_t *fs;
svn_fs_pack_notify_t notify_func;
void *notify_baton;
svn_cancel_func_t cancel_func;
void *cancel_baton;
-};
+} pack_baton_t;
/* The work-horse for svn_fs_x__pack, called with the FS write lock.
This implements the svn_fs_x__with_write_lock() 'body' callback
- type. BATON is a 'struct pack_baton *'.
+ type. BATON is a 'pack_baton_t *'.
WARNING: if you add a call to this function, please note:
The code currently assumes that any piece of code running with
@@ -2235,10 +2255,10 @@ struct pack_baton
*/
static svn_error_t *
pack_body(void *baton,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- struct pack_baton *pb = baton;
- fs_x_data_t *ffd = pb->fs->fsap_data;
+ pack_baton_t *pb = baton;
+ svn_fs_x__data_t *ffd = pb->fs->fsap_data;
apr_int64_t completed_shards;
apr_int64_t i;
svn_revnum_t youngest;
@@ -2248,20 +2268,20 @@ pack_body(void *baton,
/* If we aren't using sharding, we can't do any packing, so quit. */
SVN_ERR(svn_fs_x__read_min_unpacked_rev(&ffd->min_unpacked_rev, pb->fs,
- pool));
+ scratch_pool));
- SVN_ERR(svn_fs_x__youngest_rev(&youngest, pb->fs, pool));
+ SVN_ERR(svn_fs_x__youngest_rev(&youngest, pb->fs, scratch_pool));
completed_shards = (youngest + 1) / ffd->max_files_per_dir;
/* See if we've already completed all possible shards thus far. */
if (ffd->min_unpacked_rev == (completed_shards * ffd->max_files_per_dir))
return SVN_NO_ERROR;
- rev_data_path = svn_dirent_join(pb->fs->path, PATH_REVS_DIR, pool);
+ rev_data_path = svn_dirent_join(pb->fs->path, PATH_REVS_DIR, scratch_pool);
revprops_data_path = svn_dirent_join(pb->fs->path, PATH_REVPROPS_DIR,
- pool);
+ scratch_pool);
- iterpool = svn_pool_create(pool);
+ iterpool = svn_pool_create(scratch_pool);
for (i = ffd->min_unpacked_rev / ffd->max_files_per_dir;
i < completed_shards;
i++)
@@ -2291,13 +2311,13 @@ svn_fs_x__pack(svn_fs_t *fs,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- struct pack_baton pb = { 0 };
+ pack_baton_t pb = { 0 };
pb.fs = fs;
pb.notify_func = notify_func;
pb.notify_baton = notify_baton;
pb.cancel_func = cancel_func;
pb.cancel_baton = cancel_baton;
- return svn_fs_x__with_pack_lock(fs, pack_body, &pb, pool);
+ return svn_fs_x__with_pack_lock(fs, pack_body, &pb, scratch_pool);
}
Modified: subversion/branches/move-tracking-2/subversion/libsvn_fs_x/pack.h
URL: http://svn.apache.org/viewvc/subversion/branches/move-tracking-2/subversion/libsvn_fs_x/pack.h?rev=1653314&r1=1653313&r2=1653314&view=diff
==============================================================================
--- subversion/branches/move-tracking-2/subversion/libsvn_fs_x/pack.h (original)
+++ subversion/branches/move-tracking-2/subversion/libsvn_fs_x/pack.h Tue Jan 20 17:52:18 2015
@@ -28,6 +28,7 @@
/* Possibly pack the repository at PATH. This just take full shards, and
combines all the revision files into a single one, with a manifest header.
Use optional CANCEL_FUNC/CANCEL_BATON for cancellation support.
+ Use SCRATCH_POOL for temporary allocations.
Existing filesystem references need not change. */
svn_error_t *
@@ -36,18 +37,18 @@ svn_fs_x__pack(svn_fs_t *fs,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
- apr_pool_t *pool);
+ apr_pool_t *scratch_pool);
/**
- * For the packed revision @a rev in @a fs, determine the offset within
- * the revision pack file and return it in @a rev_offset. Use @a pool for
- * allocations.
+ * For the packed revision REV in FS, determine the offset within the
+ * revision pack file and return it in REV_OFFSET.
+ * Use SCRATCH_POOL for temporary allocations.
*/
svn_error_t *
svn_fs_x__get_packed_offset(apr_off_t *rev_offset,
svn_fs_t *fs,
svn_revnum_t rev,
- apr_pool_t *pool);
+ apr_pool_t *scratch_pool);
/* Return the svn_dir_entry_t* objects of DIRECTORY in an APR array
* allocated in POOL with entries added in storage (on-disk) order.
Modified: subversion/branches/move-tracking-2/subversion/libsvn_fs_x/recovery.c
URL: http://svn.apache.org/viewvc/subversion/branches/move-tracking-2/subversion/libsvn_fs_x/recovery.c?rev=1653314&r1=1653313&r2=1653314&view=diff
==============================================================================
--- subversion/branches/move-tracking-2/subversion/libsvn_fs_x/recovery.c (original)
+++ subversion/branches/move-tracking-2/subversion/libsvn_fs_x/recovery.c Tue Jan 20 17:52:18 2015
@@ -39,9 +39,11 @@
#include "svn_private_config.h"
/* Part of the recovery procedure. Return the largest revision *REV in
- filesystem FS. Use POOL for temporary allocation. */
+ filesystem FS. Use SCRATCH_POOL for temporary allocation. */
static svn_error_t *
-recover_get_largest_revision(svn_fs_t *fs, svn_revnum_t *rev, apr_pool_t *pool)
+recover_get_largest_revision(svn_fs_t *fs,
+ svn_revnum_t *rev,
+ apr_pool_t *scratch_pool)
{
/* Discovering the largest revision in the filesystem would be an
expensive operation if we did a readdir() or searched linearly,
@@ -50,7 +52,7 @@ recover_get_largest_revision(svn_fs_t *f
apr_pool_t *iterpool;
svn_revnum_t left, right = 1;
- iterpool = svn_pool_create(pool);
+ iterpool = svn_pool_create(scratch_pool);
/* Keep doubling right, until we find a revision that doesn't exist. */
while (1)
{
@@ -104,38 +106,40 @@ recover_get_largest_revision(svn_fs_t *f
}
/* Baton used for recover_body below. */
-struct recover_baton {
+typedef struct recover_baton_t {
svn_fs_t *fs;
svn_cancel_func_t cancel_func;
void *cancel_baton;
-};
+} recover_baton_t;
/* The work-horse for svn_fs_x__recover, called with the FS
write lock. This implements the svn_fs_x__with_write_lock()
- 'body' callback type. BATON is a 'struct recover_baton *'. */
+ 'body' callback type. BATON is a 'recover_baton_t *'. */
static svn_error_t *
-recover_body(void *baton, apr_pool_t *pool)
+recover_body(void *baton,
+ apr_pool_t *scratch_pool)
{
- struct recover_baton *b = baton;
+ recover_baton_t *b = baton;
svn_fs_t *fs = b->fs;
- fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__data_t *ffd = fs->fsap_data;
svn_revnum_t max_rev;
svn_revnum_t youngest_rev;
- svn_node_kind_t youngest_revprops_kind;
+ svn_boolean_t revprop_missing = TRUE;
+ svn_boolean_t revprop_accessible = FALSE;
/* Lose potentially corrupted data in temp files */
- SVN_ERR(svn_fs_x__reset_revprop_generation_file(fs, pool));
+ SVN_ERR(svn_fs_x__reset_revprop_generation_file(fs, scratch_pool));
/* The admin may have created a plain copy of this repo before attempting
to recover it (hotcopy may or may not work with corrupted repos).
Bump the instance ID. */
- SVN_ERR(svn_fs_x__set_uuid(fs, fs->uuid, NULL, pool));
+ SVN_ERR(svn_fs_x__set_uuid(fs, fs->uuid, NULL, scratch_pool));
/* We need to know the largest revision in the filesystem. */
- SVN_ERR(recover_get_largest_revision(fs, &max_rev, pool));
+ SVN_ERR(recover_get_largest_revision(fs, &max_rev, scratch_pool));
/* Get the expected youngest revision */
- SVN_ERR(svn_fs_x__youngest_rev(&youngest_rev, fs, pool));
+ SVN_ERR(svn_fs_x__youngest_rev(&youngest_rev, fs, scratch_pool));
/* Policy note:
@@ -176,35 +180,49 @@ recover_body(void *baton, apr_pool_t *po
/* Before setting current, verify that there is a revprops file
for the youngest revision. (Issue #2992) */
- SVN_ERR(svn_io_check_path(svn_fs_x__path_revprops(fs, max_rev, pool),
- &youngest_revprops_kind, pool));
- if (youngest_revprops_kind == svn_node_none)
- {
- svn_boolean_t missing = TRUE;
- if (!svn_fs_x__packed_revprop_available(&missing, fs, max_rev, pool))
- {
- if (missing)
- {
- return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
- _("Revision %ld has a revs file but no "
- "revprops file"),
- max_rev);
- }
- else
- {
- return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
- _("Revision %ld has a revs file but the "
- "revprops file is inaccessible"),
- max_rev);
- }
- }
- }
- else if (youngest_revprops_kind != svn_node_file)
- {
- return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
- _("Revision %ld has a non-file where its "
- "revprops file should be"),
- max_rev);
+ if (svn_fs_x__is_packed_revprop(fs, max_rev))
+ {
+ revprop_accessible
+ = svn_fs_x__packed_revprop_available(&revprop_missing, fs, max_rev,
+ scratch_pool);
+ }
+ else
+ {
+ svn_node_kind_t youngest_revprops_kind;
+ SVN_ERR(svn_io_check_path(svn_fs_x__path_revprops(fs, max_rev,
+ scratch_pool),
+ &youngest_revprops_kind, scratch_pool));
+
+ if (youngest_revprops_kind == svn_node_file)
+ {
+ revprop_missing = FALSE;
+ revprop_accessible = TRUE;
+ }
+ else if (youngest_revprops_kind != svn_node_none)
+ {
+ return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
+ _("Revision %ld has a non-file where its "
+ "revprops file should be"),
+ max_rev);
+ }
+ }
+
+ if (!revprop_accessible)
+ {
+ if (revprop_missing)
+ {
+ return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
+ _("Revision %ld has a revs file but no "
+ "revprops file"),
+ max_rev);
+ }
+ else
+ {
+ return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
+ _("Revision %ld has a revs file but the "
+ "revprops file is inaccessible"),
+ max_rev);
+ }
}
/* Prune younger-than-(newfound-youngest) revisions from the rep
@@ -214,23 +232,25 @@ recover_body(void *baton, apr_pool_t *po
{
svn_boolean_t rep_cache_exists;
- SVN_ERR(svn_fs_x__exists_rep_cache(&rep_cache_exists, fs, pool));
+ SVN_ERR(svn_fs_x__exists_rep_cache(&rep_cache_exists, fs,
+ scratch_pool));
if (rep_cache_exists)
- SVN_ERR(svn_fs_x__del_rep_reference(fs, max_rev, pool));
+ SVN_ERR(svn_fs_x__del_rep_reference(fs, max_rev, scratch_pool));
}
/* Now store the discovered youngest revision, and the next IDs if
relevant, in a new 'current' file. */
- return svn_fs_x__write_current(fs, max_rev, pool);
+ return svn_fs_x__write_current(fs, max_rev, scratch_pool);
}
/* This implements the fs_library_vtable_t.recover() API. */
svn_error_t *
svn_fs_x__recover(svn_fs_t *fs,
- svn_cancel_func_t cancel_func, void *cancel_baton,
- apr_pool_t *pool)
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *scratch_pool)
{
- struct recover_baton b;
+ recover_baton_t b;
/* We have no way to take out an exclusive lock in FSX, so we're
restricted as to the types of recovery we can do. Luckily,
@@ -239,5 +259,5 @@ svn_fs_x__recover(svn_fs_t *fs,
b.fs = fs;
b.cancel_func = cancel_func;
b.cancel_baton = cancel_baton;
- return svn_fs_x__with_all_locks(fs, recover_body, &b, pool);
+ return svn_fs_x__with_all_locks(fs, recover_body, &b, scratch_pool);
}
Modified: subversion/branches/move-tracking-2/subversion/libsvn_fs_x/recovery.h
URL: http://svn.apache.org/viewvc/subversion/branches/move-tracking-2/subversion/libsvn_fs_x/recovery.h?rev=1653314&r1=1653313&r2=1653314&view=diff
==============================================================================
--- subversion/branches/move-tracking-2/subversion/libsvn_fs_x/recovery.h (original)
+++ subversion/branches/move-tracking-2/subversion/libsvn_fs_x/recovery.h Tue Jan 20 17:52:18 2015
@@ -27,10 +27,11 @@
/* Recover the fsx associated with filesystem FS.
Use optional CANCEL_FUNC/CANCEL_BATON for cancellation support.
- Use POOL for temporary allocations. */
-svn_error_t *svn_fs_x__recover(svn_fs_t *fs,
- svn_cancel_func_t cancel_func,
- void *cancel_baton,
- apr_pool_t *pool);
+ Use SCRATCH_POOL for temporary allocations. */
+svn_error_t *
+svn_fs_x__recover(svn_fs_t *fs,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *scratch_pool);
#endif
Modified: subversion/branches/move-tracking-2/subversion/libsvn_fs_x/rep-cache.c
URL: http://svn.apache.org/viewvc/subversion/branches/move-tracking-2/subversion/libsvn_fs_x/rep-cache.c?rev=1653314&r1=1653313&r2=1653314&view=diff
==============================================================================
--- subversion/branches/move-tracking-2/subversion/libsvn_fs_x/rep-cache.c (original)
+++ subversion/branches/move-tracking-2/subversion/libsvn_fs_x/rep-cache.c Tue Jan 20 17:52:18 2015
@@ -27,6 +27,7 @@
#include "fs_x.h"
#include "fs.h"
#include "rep-cache.h"
+#include "util.h"
#include "../libsvn_fs/fs-loader.h"
#include "svn_path.h"
@@ -58,17 +59,17 @@ path_rep_cache_db(const char *fs_path,
*/
static svn_error_t *
open_rep_cache(void *baton,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
svn_fs_t *fs = baton;
- fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__data_t *ffd = fs->fsap_data;
svn_sqlite__db_t *sdb;
const char *db_path;
int version;
/* Open (or create) the sqlite database. It will be automatically
closed when fs->pool is destroyed. */
- db_path = path_rep_cache_db(fs->path, pool);
+ db_path = path_rep_cache_db(fs->path, scratch_pool);
#ifndef WIN32
{
/* We want to extend the permissions that apply to the repository
@@ -76,11 +77,11 @@ open_rep_cache(void *baton,
to umask. */
svn_boolean_t exists;
- SVN_ERR(svn_fs_x__exists_rep_cache(&exists, fs, pool));
+ SVN_ERR(svn_fs_x__exists_rep_cache(&exists, fs, scratch_pool));
if (!exists)
{
- const char *current = svn_fs_x__path_current(fs, pool);
- svn_error_t *err = svn_io_file_create_empty(db_path, pool);
+ const char *current = svn_fs_x__path_current(fs, scratch_pool);
+ svn_error_t *err = svn_io_file_create_empty(db_path, scratch_pool);
if (err && !APR_STATUS_IS_EEXIST(err->apr_err))
/* A real error. */
@@ -90,16 +91,16 @@ open_rep_cache(void *baton,
svn_error_clear(err);
else
/* We created the file. */
- SVN_ERR(svn_io_copy_perms(current, db_path, pool));
+ SVN_ERR(svn_io_copy_perms(current, db_path, scratch_pool));
}
}
#endif
SVN_ERR(svn_sqlite__open(&sdb, db_path,
svn_sqlite__mode_rwcreate, statements,
0, NULL, 0,
- fs->pool, pool));
+ fs->pool, scratch_pool));
- SVN_ERR(svn_sqlite__read_schema_version(&version, sdb, pool));
+ SVN_ERR(svn_sqlite__read_schema_version(&version, sdb, scratch_pool));
if (version < REP_CACHE_SCHEMA_FORMAT)
{
/* Must be 0 -- an uninitialized (no schema) database. Create
@@ -116,22 +117,23 @@ open_rep_cache(void *baton,
svn_error_t *
svn_fs_x__open_rep_cache(svn_fs_t *fs,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__data_t *ffd = fs->fsap_data;
svn_error_t *err = svn_atomic__init_once(&ffd->rep_cache_db_opened,
- open_rep_cache, fs, pool);
+ open_rep_cache, fs, scratch_pool);
return svn_error_quick_wrap(err, _("Couldn't open rep-cache database"));
}
svn_error_t *
svn_fs_x__exists_rep_cache(svn_boolean_t *exists,
- svn_fs_t *fs, apr_pool_t *pool)
+ svn_fs_t *fs,
+ apr_pool_t *scratch_pool)
{
svn_node_kind_t kind;
- SVN_ERR(svn_io_check_path(path_rep_cache_db(fs->path, pool),
- &kind, pool));
+ SVN_ERR(svn_io_check_path(path_rep_cache_db(fs->path, scratch_pool),
+ &kind, scratch_pool));
*exists = (kind != svn_node_none);
return SVN_NO_ERROR;
@@ -141,24 +143,24 @@ svn_error_t *
svn_fs_x__walk_rep_reference(svn_fs_t *fs,
svn_revnum_t start,
svn_revnum_t end,
- svn_error_t *(*walker)(representation_t *,
+ svn_error_t *(*walker)(svn_fs_x__representation_t *,
void *,
svn_fs_t *,
apr_pool_t *),
void *walker_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__data_t *ffd = fs->fsap_data;
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
int iterations = 0;
- apr_pool_t *iterpool = svn_pool_create(pool);
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
if (! ffd->rep_cache_db)
- SVN_ERR(svn_fs_x__open_rep_cache(fs, pool));
+ SVN_ERR(svn_fs_x__open_rep_cache(fs, scratch_pool));
/* Check global invariants. */
if (start == 0)
@@ -183,7 +185,7 @@ svn_fs_x__walk_rep_reference(svn_fs_t *f
SVN_ERR(svn_sqlite__step(&have_row, stmt));
while (have_row)
{
- representation_t *rep;
+ svn_fs_x__representation_t *rep;
const char *sha1_digest;
svn_error_t *err;
svn_checksum_t *checksum;
@@ -200,7 +202,7 @@ svn_fs_x__walk_rep_reference(svn_fs_t *f
return svn_error_compose_create(err, svn_sqlite__reset(stmt));
}
- /* Construct a representation_t. */
+ /* Construct a svn_fs_x__representation_t. */
rep = apr_pcalloc(iterpool, sizeof(*rep));
sha1_digest = svn_sqlite__column_text(stmt, 0, iterpool);
err = svn_checksum_parse_hex(&checksum, svn_checksum_sha1,
@@ -234,18 +236,19 @@ svn_fs_x__walk_rep_reference(svn_fs_t *f
If you extend this function, check the callsite to see if you have
to make it not-ignore additional error codes. */
svn_error_t *
-svn_fs_x__get_rep_reference(representation_t **rep,
+svn_fs_x__get_rep_reference(svn_fs_x__representation_t **rep,
svn_fs_t *fs,
svn_checksum_t *checksum,
- apr_pool_t *pool)
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
{
- fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__data_t *ffd = fs->fsap_data;
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
SVN_ERR_ASSERT(ffd->rep_sharing_allowed);
if (! ffd->rep_cache_db)
- SVN_ERR(svn_fs_x__open_rep_cache(fs, pool));
+ SVN_ERR(svn_fs_x__open_rep_cache(fs, scratch_pool));
/* We only allow SHA1 checksums in this table. */
if (checksum->kind != svn_checksum_sha1)
@@ -255,12 +258,12 @@ svn_fs_x__get_rep_reference(representati
SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db, STMT_GET_REP));
SVN_ERR(svn_sqlite__bindf(stmt, "s",
- svn_checksum_to_cstring(checksum, pool)));
+ svn_checksum_to_cstring(checksum, scratch_pool)));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
if (have_row)
{
- *rep = apr_pcalloc(pool, sizeof(**rep));
+ *rep = apr_pcalloc(result_pool, sizeof(**rep));
memcpy((*rep)->sha1_digest, checksum->digest,
sizeof((*rep)->sha1_digest));
(*rep)->has_sha1 = TRUE;
@@ -278,12 +281,12 @@ svn_fs_x__get_rep_reference(representati
{
/* Check that REP refers to a revision that exists in FS. */
svn_revnum_t revision = svn_fs_x__get_revnum((*rep)->id.change_set);
- svn_error_t *err = svn_fs_x__ensure_revision_exists(revision, fs, pool);
+ svn_error_t *err = svn_fs_x__ensure_revision_exists(revision, fs,
+ scratch_pool);
if (err)
return svn_error_createf(SVN_ERR_FS_CORRUPT, err,
- "Checksum '%s' in rep-cache is beyond HEAD",
- svn_checksum_to_cstring_display(checksum,
- pool));
+ "Checksum '%s' in rep-cache is beyond HEAD",
+ svn_checksum_to_cstring_display(checksum, scratch_pool));
}
return SVN_NO_ERROR;
@@ -291,10 +294,10 @@ svn_fs_x__get_rep_reference(representati
svn_error_t *
svn_fs_x__set_rep_reference(svn_fs_t *fs,
- representation_t *rep,
- apr_pool_t *pool)
+ svn_fs_x__representation_t *rep,
+ apr_pool_t *scratch_pool)
{
- fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__data_t *ffd = fs->fsap_data;
svn_sqlite__stmt_t *stmt;
svn_error_t *err;
svn_checksum_t checksum;
@@ -303,7 +306,7 @@ svn_fs_x__set_rep_reference(svn_fs_t *fs
SVN_ERR_ASSERT(ffd->rep_sharing_allowed);
if (! ffd->rep_cache_db)
- SVN_ERR(svn_fs_x__open_rep_cache(fs, pool));
+ SVN_ERR(svn_fs_x__open_rep_cache(fs, scratch_pool));
/* We only allow SHA1 checksums in this table. */
if (! rep->has_sha1)
@@ -313,7 +316,7 @@ svn_fs_x__set_rep_reference(svn_fs_t *fs
SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db, STMT_SET_REP));
SVN_ERR(svn_sqlite__bindf(stmt, "siiii",
- svn_checksum_to_cstring(&checksum, pool),
+ svn_checksum_to_cstring(&checksum, scratch_pool),
(apr_int64_t) rep->id.change_set,
(apr_int64_t) rep->id.number,
(apr_int64_t) rep->size,
@@ -322,7 +325,7 @@ svn_fs_x__set_rep_reference(svn_fs_t *fs
err = svn_sqlite__insert(NULL, stmt);
if (err)
{
- representation_t *old_rep;
+ svn_fs_x__representation_t *old_rep;
if (err->apr_err != SVN_ERR_SQLITE_CONSTRAINT)
return svn_error_trace(err);
@@ -332,7 +335,8 @@ svn_fs_x__set_rep_reference(svn_fs_t *fs
/* Constraint failed so the mapping for SHA1_CHECKSUM->REP
should exist. If so that's cool -- just do nothing. If not,
that's a red flag! */
- SVN_ERR(svn_fs_x__get_rep_reference(&old_rep, fs, &checksum, pool));
+ SVN_ERR(svn_fs_x__get_rep_reference(&old_rep, fs, &checksum,
+ scratch_pool, scratch_pool));
if (!old_rep)
{
@@ -349,13 +353,13 @@ svn_fs_x__set_rep_reference(svn_fs_t *fs
svn_error_t *
svn_fs_x__del_rep_reference(svn_fs_t *fs,
svn_revnum_t youngest,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__data_t *ffd = fs->fsap_data;
svn_sqlite__stmt_t *stmt;
if (! ffd->rep_cache_db)
- SVN_ERR(svn_fs_x__open_rep_cache(fs, pool));
+ SVN_ERR(svn_fs_x__open_rep_cache(fs, scratch_pool));
SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db,
STMT_DEL_REPS_YOUNGER_THAN_REV));
@@ -367,12 +371,12 @@ svn_fs_x__del_rep_reference(svn_fs_t *fs
svn_error_t *
svn_fs_x__lock_rep_cache(svn_fs_t *fs,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
- fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__data_t *ffd = fs->fsap_data;
if (! ffd->rep_cache_db)
- SVN_ERR(svn_fs_x__open_rep_cache(fs, pool));
+ SVN_ERR(svn_fs_x__open_rep_cache(fs, scratch_pool));
SVN_ERR(svn_sqlite__exec_statements(ffd->rep_cache_db, STMT_LOCK_REP));
Modified: subversion/branches/move-tracking-2/subversion/libsvn_fs_x/rep-cache.h
URL: http://svn.apache.org/viewvc/subversion/branches/move-tracking-2/subversion/libsvn_fs_x/rep-cache.h?rev=1653314&r1=1653313&r2=1653314&view=diff
==============================================================================
--- subversion/branches/move-tracking-2/subversion/libsvn_fs_x/rep-cache.h (original)
+++ subversion/branches/move-tracking-2/subversion/libsvn_fs_x/rep-cache.h Tue Jan 20 17:52:18 2015
@@ -35,63 +35,64 @@ extern "C" {
#define REP_CACHE_DB_NAME "rep-cache.db"
/* Open and create, if needed, the rep cache database associated with FS.
- Use POOL for temporary allocations. */
+ Use SCRATCH_POOL for temporary allocations. */
svn_error_t *
svn_fs_x__open_rep_cache(svn_fs_t *fs,
- apr_pool_t *pool);
+ apr_pool_t *scratch_pool);
/* Set *EXISTS to TRUE iff the rep-cache DB file exists. */
svn_error_t *
svn_fs_x__exists_rep_cache(svn_boolean_t *exists,
svn_fs_t *fs,
- apr_pool_t *pool);
+ apr_pool_t *scratch_pool);
/* Iterate all representations currently in FS's cache. */
svn_error_t *
svn_fs_x__walk_rep_reference(svn_fs_t *fs,
svn_revnum_t start,
svn_revnum_t end,
- svn_error_t *(*walker)(representation_t *rep,
+ svn_error_t *(*walker)(svn_fs_x__representation_t *rep,
void *walker_baton,
svn_fs_t *fs,
apr_pool_t *scratch_pool),
void *walker_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
- apr_pool_t *pool);
+ apr_pool_t *scratch_pool);
/* Return the representation REP in FS which has fulltext CHECKSUM.
- REP is allocated in POOL. If the rep cache database has not been
- opened, just set *REP to NULL. Returns SVN_ERR_FS_CORRUPT if
- a reference beyond HEAD is detected. */
+ REP is allocated in RESULT_POOL. If the rep cache database has not been
+ opened, just set *REP to NULL. Returns SVN_ERR_FS_CORRUPT if a reference
+ beyond HEAD is detected. Uses SCRATCH_POOL for temporary allocations. */
svn_error_t *
-svn_fs_x__get_rep_reference(representation_t **rep,
+svn_fs_x__get_rep_reference(svn_fs_x__representation_t **rep,
svn_fs_t *fs,
svn_checksum_t *checksum,
- apr_pool_t *pool);
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool);
/* Set the representation REP in FS, using REP->CHECKSUM.
- Use POOL for temporary allocations. Returns SVN_ERR_FS_CORRUPT if
- an existing reference beyond HEAD is detected.
+ Use SCRATCH_POOL for temporary allocations. Returns SVN_ERR_FS_CORRUPT
+ if an existing reference beyond HEAD is detected.
If the rep cache database has not been opened, this may be a no op. */
svn_error_t *
svn_fs_x__set_rep_reference(svn_fs_t *fs,
- representation_t *rep,
- apr_pool_t *pool);
+ svn_fs_x__representation_t *rep,
+ apr_pool_t *scratch_pool);
/* Delete from the cache all reps corresponding to revisions younger
than YOUNGEST. */
svn_error_t *
svn_fs_x__del_rep_reference(svn_fs_t *fs,
svn_revnum_t youngest,
- apr_pool_t *pool);
+ apr_pool_t *scratch_pool);
/* Start a transaction to take an SQLite reserved lock that prevents
other writes. */
svn_error_t *
svn_fs_x__lock_rep_cache(svn_fs_t *fs,
- apr_pool_t *pool);
+ apr_pool_t *scratch_pool);
#ifdef __cplusplus
}
Modified: subversion/branches/move-tracking-2/subversion/libsvn_fs_x/reps.c
URL: http://svn.apache.org/viewvc/subversion/branches/move-tracking-2/subversion/libsvn_fs_x/reps.c?rev=1653314&r1=1653313&r2=1653314&view=diff
==============================================================================
--- subversion/branches/move-tracking-2/subversion/libsvn_fs_x/reps.c (original)
+++ subversion/branches/move-tracking-2/subversion/libsvn_fs_x/reps.c Tue Jan 20 17:52:18 2015
@@ -302,38 +302,40 @@ hash_to_index(hash_t *hash, hash_key_t a
return (adler32 * 0xd1f3da69) >> hash->shift;
}
-/* Allocate and initialized SIZE buckets in POOL. Assign them to HASH.
+/* Allocate and initialized SIZE buckets in RESULT_POOL.
+ * Assign them to HASH.
*/
static void
allocate_hash_members(hash_t *hash,
apr_size_t size,
- apr_pool_t *pool)
+ apr_pool_t *result_pool)
{
apr_size_t i;
- hash->pool = pool;
+ hash->pool = result_pool;
hash->size = size;
- hash->prefixes = apr_pcalloc(pool, size);
- hash->last_matches = apr_pcalloc(pool, sizeof(*hash->last_matches) * size);
- hash->offsets = apr_palloc(pool, sizeof(*hash->offsets) * size);
+ hash->prefixes = apr_pcalloc(result_pool, size);
+ hash->last_matches = apr_pcalloc(result_pool,
+ sizeof(*hash->last_matches) * size);
+ hash->offsets = apr_palloc(result_pool, sizeof(*hash->offsets) * size);
for (i = 0; i < size; ++i)
hash->offsets[i] = NO_OFFSET;
}
/* Initialize the HASH data structure with 2**TWOPOWER buckets allocated
- * in POOL.
+ * in RESULT_POOL.
*/
static void
init_hash(hash_t *hash,
apr_size_t twoPower,
- apr_pool_t *pool)
+ apr_pool_t *result_pool)
{
hash->used = 0;
hash->shift = sizeof(hash_key_t) * 8 - twoPower;
- allocate_hash_members(hash, 1 << twoPower, pool);
+ allocate_hash_members(hash, 1 << twoPower, result_pool);
}
/* Make HASH have at least MIN_SIZE buckets but at least double the number
@@ -384,24 +386,26 @@ grow_hash(hash_t *hash,
svn_fs_x__reps_builder_t *
svn_fs_x__reps_builder_create(svn_fs_t *fs,
- apr_pool_t *pool)
+ apr_pool_t *result_pool)
{
- svn_fs_x__reps_builder_t *result = apr_pcalloc(pool, sizeof(*result));
+ svn_fs_x__reps_builder_t *result = apr_pcalloc(result_pool,
+ sizeof(*result));
result->fs = fs;
- result->text = svn_stringbuf_create_empty(pool);
- init_hash(&result->hash, 4, pool);
+ result->text = svn_stringbuf_create_empty(result_pool);
+ init_hash(&result->hash, 4, result_pool);
- result->bases = apr_array_make(pool, 0, sizeof(base_t));
- result->reps = apr_array_make(pool, 0, sizeof(rep_t));
- result->instructions = apr_array_make(pool, 0, sizeof(instruction_t));
+ result->bases = apr_array_make(result_pool, 0, sizeof(base_t));
+ result->reps = apr_array_make(result_pool, 0, sizeof(rep_t));
+ result->instructions = apr_array_make(result_pool, 0,
+ sizeof(instruction_t));
return result;
}
svn_error_t *
svn_fs_x__reps_add_base(svn_fs_x__reps_builder_t *builder,
- representation_t *rep,
+ svn_fs_x__representation_t *rep,
int priority,
apr_pool_t *scratch_pool)
{
@@ -689,10 +693,10 @@ svn_fs_x__extractor_drive(svn_stringbuf_
svn_error_t *
svn_fs_x__write_reps_container(svn_stream_t *stream,
const svn_fs_x__reps_builder_t *builder,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
int i;
- svn_packed__data_root_t *root = svn_packed__data_create_root(pool);
+ svn_packed__data_root_t *root = svn_packed__data_create_root(scratch_pool);
/* one top-level stream for each array */
svn_packed__int_stream_t *bases_stream
@@ -755,7 +759,7 @@ svn_fs_x__write_reps_container(svn_strea
svn_packed__add_uint(misc_stream, 0);
/* write to stream */
- SVN_ERR(svn_packed__data_write(stream, root, pool));
+ SVN_ERR(svn_packed__data_write(stream, root, scratch_pool));
return SVN_NO_ERROR;
}
Modified: subversion/branches/move-tracking-2/subversion/libsvn_fs_x/reps.h
URL: http://svn.apache.org/viewvc/subversion/branches/move-tracking-2/subversion/libsvn_fs_x/reps.h?rev=1653314&r1=1653313&r2=1653314&view=diff
==============================================================================
--- subversion/branches/move-tracking-2/subversion/libsvn_fs_x/reps.h (original)
+++ subversion/branches/move-tracking-2/subversion/libsvn_fs_x/reps.h Tue Jan 20 17:52:18 2015
@@ -71,11 +71,11 @@ typedef struct svn_fs_x__reps_baton_t
/* Create and populate noderev containers. */
-/* Create and return a new builder object, allocated in POOL.
+/* Create and return a new builder object, allocated in RESULT_POOL.
*/
svn_fs_x__reps_builder_t *
svn_fs_x__reps_builder_create(svn_fs_t *fs,
- apr_pool_t *pool);
+ apr_pool_t *result_pool);
/* To BUILDER, add reference to the fulltext currently stored in
* representation REP. Substrings matching with any of the base reps
@@ -91,7 +91,7 @@ svn_fs_x__reps_builder_create(svn_fs_t *
*/
svn_error_t *
svn_fs_x__reps_add_base(svn_fs_x__reps_builder_t *builder,
- representation_t *rep,
+ svn_fs_x__representation_t *rep,
int priority,
apr_pool_t *scratch_pool);
@@ -141,12 +141,12 @@ svn_fs_x__extractor_drive(svn_stringbuf_
/* I/O interface. */
/* Write a serialized representation of the final container described by
- * BUILDER to STREAM. Use POOL for temporary allocations.
+ * BUILDER to STREAM. Use SCRATCH_POOL for temporary allocations.
*/
svn_error_t *
svn_fs_x__write_reps_container(svn_stream_t *stream,
const svn_fs_x__reps_builder_t *builder,
- apr_pool_t *pool);
+ apr_pool_t *scratch_pool);
/* Read a representations container from its serialized representation in
* STREAM. Allocate the result in RESULT_POOL and return it in *CONTAINER.
Modified: subversion/branches/move-tracking-2/subversion/libsvn_fs_x/rev_file.c
URL: http://svn.apache.org/viewvc/subversion/branches/move-tracking-2/subversion/libsvn_fs_x/rev_file.c?rev=1653314&r1=1653313&r2=1653314&view=diff
==============================================================================
--- subversion/branches/move-tracking-2/subversion/libsvn_fs_x/rev_file.c (original)
+++ subversion/branches/move-tracking-2/subversion/libsvn_fs_x/rev_file.c Tue Jan 20 17:52:18 2015
@@ -37,7 +37,7 @@ static svn_fs_x__revision_file_t *
create_revision_file(svn_fs_t *fs,
apr_pool_t *result_pool)
{
- fs_x_data_t *ffd = fs->fsap_data;
+ svn_fs_x__data_t *ffd = fs->fsap_data;
svn_fs_x__revision_file_t *file = apr_palloc(result_pool, sizeof(*file));
file->is_packed = FALSE;