Modified: subversion/branches/ev2-export/subversion/tests/svn_test_fs.c URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/subversion/tests/svn_test_fs.c?rev=1412731&r1=1412730&r2=1412731&view=diff ============================================================================== --- subversion/branches/ev2-export/subversion/tests/svn_test_fs.c (original) +++ subversion/branches/ev2-export/subversion/tests/svn_test_fs.c Fri Nov 23 01:12:18 2012 @@ -115,10 +115,14 @@ create_fs(svn_fs_t **fs_p, if (apr_stat(&finfo, name, APR_FINFO_TYPE, pool) == APR_SUCCESS) { if (finfo.filetype == APR_DIR) - SVN_ERR(svn_fs_delete_fs(name, pool)); + SVN_ERR_W(svn_fs_delete_fs(name, pool), + apr_psprintf(pool, + "cannot create fs '%s' there is already " + "a directory of that name", name)); else return svn_error_createf(SVN_ERR_TEST_FAILED, NULL, - "there is already a file named '%s'", name); + "cannot create fs '%s' there is already " + "a file of that name", name); } SVN_ERR(svn_fs_create(fs_p, name, fs_config, pool));
Modified: subversion/branches/ev2-export/tools/server-side/fsfs-reorg.c URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/tools/server-side/fsfs-reorg.c?rev=1412731&r1=1412730&r2=1412731&view=diff ============================================================================== --- subversion/branches/ev2-export/tools/server-side/fsfs-reorg.c (original) +++ subversion/branches/ev2-export/tools/server-side/fsfs-reorg.c Fri Nov 23 01:12:18 2012 @@ -47,165 +47,376 @@ #define ERROR_TAG "diff: " +/* forward declarations */ typedef struct noderev_t noderev_t; typedef struct revision_info_t revision_info_t; +/* A FSFS rev file is sequence of fragments and unused space (the latter + * only being inserted by this tool and not during ordinary SVN operation). + * + * This type defines the type of any fragment. + * + * Please note that the classification as "property", "dir" or "file" + * fragments is only to be used while determining the future placement + * of a representation. If the rep is shared, the same rep may be used + * as *any* of the 3 kinds. + */ enum fragment_kind_t { + /* the 2 number line containing changes and root node offsets */ header_fragment, + + /* list of all changes in a revision */ changes_fragment, - noderep_fragment, + + /* (the textual representation of) a noderev */ + noderev_fragment, + + /* a property rep (including PLAIN / DELTA header) */ property_fragment, + + /* a directory rep (including PLAIN / DELTA header) */ dir_fragment, + + /* a file rep (including PLAIN / DELTA header) */ file_fragment }; +/* A fragment. This is used to represent the final ordering, i.e. there + * will be an array containing elements of this type that basically put + * a fragment at some location in the target file. + */ typedef struct fragment_t { + /* position in the target file */ apr_size_t position; - void *data; + + /* kind of fragment */ enum fragment_kind_t kind; + + /* pointer to the fragment struct; type depends on KIND */ + void *data; } fragment_t; +/* Location info for a single revision. + */ typedef struct revision_location_t { + /* pack file offset (manifest value), 0 for non-packed files */ apr_size_t offset; + + /* offset of the changes list relative to OFFSET */ apr_size_t changes; + + /* length of the changes list on bytes */ apr_size_t changes_len; + + /* first offset behind the revision data in the pack file (file length + * for non-packed revs) */ apr_size_t end; } revision_location_t; +/* Absolute position and size of some item. + */ typedef struct location_t { + /* absolute offset in the file */ apr_size_t offset; + + /* item length in bytes */ apr_size_t size; } location_t; +/* A parsed directory entry. Note that instances of this struct may be + * shared between different DIRECTORY_T containers. + */ typedef struct direntry_t { + /* (local) entry / path name */ const char *name; + + /* strlen (name) */ apr_size_t name_len; + + /* node rev providing ID and representation(s) */ noderev_t *node; } direntry_t; +/* Representation of a parsed directory content. + */ typedef struct directory_t { + /* array of pointers to DIRENTRY_T */ apr_array_header_t *entries; + + /* MD5 of the textual representation. Will be set lazily as a side-effect + * of determining the length of this dir's textual representation. */ unsigned char target_md5[16]; + + /* (expanded) length of the textual representation. + * Determined lazily during the write process. */ apr_size_t size; } directory_t; +/* A representation fragment. + */ typedef struct representation_t { + /* location in the source file */ location_t original; + + /* location in the reordered target file */ location_t target; + + /* length of the PLAIN / DELTA line in the source file in bytes */ apr_size_t header_size; + + /* deltification base, or NULL if there is none */ struct representation_t *delta_base; + + /* revision that contains this representation + * (may be referenced by other revisions, though) */ revision_info_t *revision; + + /* representation content parsed as a directory. This will be NULL, if + * *no* directory noderev uses this representation. */ directory_t *dir; + + /* the source content has a PLAIN header, so we may simply copy the + * source content into the target */ svn_boolean_t is_plain; + + /* coloring flag used in the reordering algorithm to keep track of + * representations that still need to be placed. */ svn_boolean_t covered; } representation_t; +/* A node rev. + */ struct noderev_t { + /* location within the source file */ location_t original; + + /* location within the reorganized target file. */ location_t target; + + /* predecessor node, or NULL if there is none */ noderev_t *predecessor; + + /* content representation; may be NULL if there is none */ representation_t *text; + + /* properties representation; may be NULL if there is none */ representation_t *props; + + /* revision that this noderev belongs to */ revision_info_t *revision; + + /* coloring flag used in the reordering algorithm to keep track of + * representations that still need to be placed. */ svn_boolean_t covered; }; +/* Represents a single revision. + * There will be only one instance per revision. */ struct revision_info_t { + /* number of this revision */ svn_revnum_t revision; + + /* position in the source file */ revision_location_t original; + + /* position in the reorganized target file */ revision_location_t target; + + /* noderev of the root directory */ noderev_t *root_noderev; + + /* all noderevs_t of this revision (in no particular order), + * i.e. those that point back to this struct */ apr_array_header_t *node_revs; + + /* all representation_t of this revision (in no particular order), + * i.e. those that point back to this struct */ apr_array_header_t *representations; }; +/* Represents a packed revision file. + */ typedef struct revision_pack_t { + /* first revision in the pack file */ svn_revnum_t base; + + /* revision_info_t* of all revisions in the pack file; in revision order. */ apr_array_header_t *info; + + /* list of fragments to place in the target pack file; in target order. */ apr_array_header_t *fragments; + + /* source pack file length */ apr_size_t filesize; + + /* temporary value. Equal to the number of bytes in the target pack file + * already allocated to fragments. */ apr_size_t target_offset; } revision_pack_t; +/* Cache for revision source content. All content is stored in DATA and + * the HASH maps revision number to an svn_string_t instance whose data + * member points into DATA. + * + * Once TOTAL_SIZE exceeds LIMIT, all content will be discarded. Similarly, + * the hash gets cleared every 10000 insertions to keep the HASH_POOL + * memory usage in check. + */ typedef struct content_cache_t { - apr_pool_t *pool; + /* pool used for HASH */ apr_pool_t *hash_pool; + /* svn_revnum_t -> svn_string_t. + * The strings become (potentially) invalid when adding new cache entries. */ apr_hash_t *hash; + /* data buffer. the first TOTAL_SIZE bytes are actually being used. */ char *data; + + /* DATA capacity */ apr_size_t limit; + /* number of bytes used in DATA */ apr_size_t total_size; + + /* number of insertions since the last hash cleanup */ apr_size_t insert_count; } content_cache_t; +/* A cached directory. In contrast to directory_t, this stored the data as + * the plain hash that the normal FSFS will use to serialize & diff dirs. + */ typedef struct dir_cache_entry_t { + /* revision containing the representation */ svn_revnum_t revision; + + /* offset of the representation within that revision */ apr_size_t offset; - + + /* key-value representation of the directory entries */ apr_hash_t *hash; } dir_cache_entry_t; +/* Directory cache. (revision, offset) will be mapped directly into the + * ENTRIES array of ENTRY_COUNT buckets (many entries will be NULL). + * Two alternating pools will be used to allocate dir content. + * + * If the INSERT_COUNT exceeds a given limit, the pools get exchanged and + * the older of the two will be cleared. This is to keep dir objects valid + * for at least one insertion. + */ typedef struct dir_cache_t { + /* fixed-size array of ENTRY_COUNT elements */ dir_cache_entry_t *entries; + /* currently used for entry allocations */ apr_pool_t *pool1; + + /* previously used for entry allocations */ apr_pool_t *pool2; + + /* size of ENTRIES in elements */ apr_size_t entry_count; + + /* number of directory elements added. I.e. usually >> #cached dirs */ apr_size_t insert_count; } dir_cache_t; +/* A cached, undeltified txdelta window. + */ typedef struct window_cache_entry_t { + /* revision containing the window */ svn_revnum_t revision; + + /* offset of the deltified window within that revision */ apr_size_t offset; + /* window content */ svn_stringbuf_t *window; } window_cache_entry_t; +/* Cache for undeltified txdelta windows. (revision, offset) will be mapped + * directly into the ENTRIES array of INSERT_COUNT buckets (most entries + * will be NULL). + * + * The cache will be cleared when USED exceeds CAPACITY. + */ typedef struct window_cache_t { + /* fixed-size array of ENTRY_COUNT elements */ window_cache_entry_t *entries; + /* used to allocate windows */ apr_pool_t *pool; + + /* size of ENTRIES in elements */ apr_size_t entry_count; + + /* maximum combined size of all cached windows */ apr_size_t capacity; + + /* current combined size of all cached windows */ apr_size_t used; } window_cache_t; +/* Root data structure containing all information about a given repository. + */ typedef struct fs_fs_t { + /* repository to reorg */ const char *path; + + /* revision to start at (must be 0, ATM) */ svn_revnum_t start_revision; + + /* FSFS format number */ int format; + /* highest revision number in the repo */ svn_revnum_t max_revision; + + /* first non-packed revision */ svn_revnum_t min_unpacked_rev; + + /* sharing size*/ int max_files_per_dir; + /* all revisions */ apr_array_header_t *revisions; + + /* all packed files */ apr_array_header_t *packs; + /* empty representation. + * Used as a dummy base for DELTA reps without base. */ representation_t *null_base; + + /* revision content cache */ content_cache_t *cache; + + /* directory hash cache */ dir_cache_t *dir_cache; + + /* undeltified txdelta window cache */ window_cache_t *window_cache; } fs_fs_t; +/* Return the rev pack folder for revision REV in FS. + */ static const char * get_pack_folder(fs_fs_t *fs, svn_revnum_t rev, @@ -215,6 +426,8 @@ get_pack_folder(fs_fs_t *fs, fs->path, rev / fs->max_files_per_dir); } +/* Return the path of the file containing revision REV in FS. + */ static const char * rev_or_pack_file_name(fs_fs_t *fs, svn_revnum_t rev, @@ -226,6 +439,8 @@ rev_or_pack_file_name(fs_fs_t *fs, rev / fs->max_files_per_dir, rev); } +/* Open the file containing revision REV in FS and return it in *FILE. + */ static svn_error_t * open_rev_or_pack_file(apr_file_t **file, fs_fs_t *fs, @@ -239,6 +454,9 @@ open_rev_or_pack_file(apr_file_t **file, pool); } +/* Read the whole content of the file containing REV in FS and return that + * in *CONTENT. + */ static svn_error_t * read_rev_or_pack_file(svn_stringbuf_t **content, fs_fs_t *fs, @@ -250,13 +468,15 @@ read_rev_or_pack_file(svn_stringbuf_t ** pool); } +/* Return a new content cache with the given size LIMIT. Use POOL for + * all cache-related allocations. + */ static content_cache_t * create_content_cache(apr_pool_t *pool, apr_size_t limit) { content_cache_t *result = apr_pcalloc(pool, sizeof(*result)); - result->pool = pool; result->hash_pool = svn_pool_create(pool); result->hash = svn_hash__make(result->hash_pool); result->limit = limit; @@ -267,6 +487,9 @@ create_content_cache(apr_pool_t *pool, return result; } +/* Return the content of revision REVISION from CACHE. Return NULL upon a + * cache miss. This is a cache-internal function. + */ static svn_string_t * get_cached_content(content_cache_t *cache, svn_revnum_t revision) @@ -274,6 +497,9 @@ get_cached_content(content_cache_t *cach return apr_hash_get(cache->hash, &revision, sizeof(revision)); } +/* Take the content in DATA and store it under REVISION in CACHE. + * This is a cache-internal function. + */ static void set_cached_content(content_cache_t *cache, svn_revnum_t revision, @@ -281,11 +507,14 @@ set_cached_content(content_cache_t *cach { svn_string_t *content; svn_revnum_t *key; - + + /* double insertion? -> broken cache logic */ assert(get_cached_content(cache, revision) == NULL); + /* purge the cache upon overflow */ if (cache->total_size + data->len > cache->limit) { + /* the hash pool grows slowly over time; clear it once in a while */ if (cache->insert_count > 10000) { svn_pool_clear(cache->hash_pool); @@ -296,8 +525,13 @@ set_cached_content(content_cache_t *cach cache->hash = svn_hash__make(cache->hash_pool); cache->total_size = 0; + + /* buffer overflow / revision too large */ + if (data->len > cache->limit) + SVN_ERR_MALFUNCTION_NO_RETURN(); } + /* copy data to cache and update he index (hash) */ content = apr_palloc(cache->hash_pool, sizeof(*content)); content->data = cache->data + cache->total_size; content->len = data->len; @@ -312,6 +546,9 @@ set_cached_content(content_cache_t *cach ++cache->insert_count; } +/* Get the file content of revision REVISION in FS and return it in *DATA. + * Use SCRATCH_POOL for temporary allocations. + */ static svn_error_t * get_content(svn_string_t **data, fs_fs_t *fs, @@ -322,7 +559,8 @@ get_content(svn_string_t **data, revision_info_t *revision_info; svn_stringbuf_t *temp; apr_off_t temp_offset; - + + /* try getting the data from our cache */ svn_string_t *result = get_cached_content(fs->cache, revision); if (result) { @@ -330,6 +568,7 @@ get_content(svn_string_t **data, return SVN_NO_ERROR; } + /* not in cache. Is the revision valid at all? */ if (revision - fs->start_revision > fs->revisions->nelts) return svn_error_createf(SVN_ERR_BAD_VERSION_FILE_FORMAT, NULL, _("Unknown revision %ld"), revision); @@ -337,6 +576,8 @@ get_content(svn_string_t **data, revision - fs->start_revision, revision_info_t*); + /* read the revision content. Assume that the file has *not* been + * reorg'ed, yet, i.e. all data is in one place. */ temp = svn_stringbuf_create_ensure( revision_info->original.end - revision_info->original.offset, scratch_pool); @@ -350,6 +591,7 @@ get_content(svn_string_t **data, revision_info->original.offset = (apr_size_t)temp_offset; SVN_ERR(svn_io_file_read(file, temp->data, &temp->len, scratch_pool)); + /* cache the result and return it */ set_cached_content(fs->cache, revision, svn_stringbuf__morph_into_string(temp)); *data = get_cached_content(fs->cache, revision); @@ -357,6 +599,9 @@ get_content(svn_string_t **data, return SVN_NO_ERROR; } +/* Return a new directory cache with ENTRY_COUNT buckets in its index. + * Use POOL for all cache-related allocations. + */ static dir_cache_t * create_dir_cache(apr_pool_t *pool, apr_size_t entry_count) @@ -372,6 +617,9 @@ create_dir_cache(apr_pool_t *pool, return result; } +/* Return the position within FS' dir cache ENTRIES index for the given + * (REVISION, OFFSET) pair. This is a cache-internal function. + */ static apr_size_t get_dir_cache_index(fs_fs_t *fs, svn_revnum_t revision, @@ -380,12 +628,18 @@ get_dir_cache_index(fs_fs_t *fs, return (revision + offset * 0xd1f3da69) % fs->dir_cache->entry_count; } +/* Return the currently active pool of FS' dir cache. Note that it may be + * cleared after *2* insertions. + */ static apr_pool_t * get_cached_dir_pool(fs_fs_t *fs) { return fs->dir_cache->pool1; } +/* Return the cached directory content stored in REPRESENTAION within FS. + * If that has not been found in cache, return NULL. + */ static apr_hash_t * get_cached_dir(fs_fs_t *fs, representation_t *representation) @@ -401,17 +655,21 @@ get_cached_dir(fs_fs_t *fs, : NULL; } +/* Cache the directory HASH for REPRESENTAION within FS. + */ static void set_cached_dir(fs_fs_t *fs, representation_t *representation, apr_hash_t *hash) { + /* select the entry to use */ svn_revnum_t revision = representation->revision->revision; apr_size_t offset = representation->original.offset; apr_size_t i = get_dir_cache_index(fs, revision, offset); dir_cache_entry_t *entry = &fs->dir_cache->entries[i]; + /* clean the cache and rotate pools at regular intervals */ fs->dir_cache->insert_count += apr_hash_count(hash); if (fs->dir_cache->insert_count >= fs->dir_cache->entry_count * 100) { @@ -428,11 +686,16 @@ set_cached_dir(fs_fs_t *fs, fs->dir_cache->pool1 = pool; } + /* write data to cache */ entry->hash = hash; entry->offset = offset; entry->revision = revision; } +/* Return a new txdelta window cache with ENTRY_COUNT buckets in its index + * and a the total CAPACITY given in bytes. + * Use POOL for all cache-related allocations. + */ static window_cache_t * create_window_cache(apr_pool_t *pool, apr_size_t entry_count, @@ -449,6 +712,9 @@ create_window_cache(apr_pool_t *pool, return result; } +/* Return the position within FS' window cache ENTRIES index for the given + * (REVISION, OFFSET) pair. This is a cache-internal function. + */ static apr_size_t get_window_cache_index(fs_fs_t *fs, svn_revnum_t revision, @@ -457,6 +723,9 @@ get_window_cache_index(fs_fs_t *fs, return (revision + offset * 0xd1f3da69) % fs->window_cache->entry_count; } +/* Return the cached txdelta window stored in REPRESENTAION within FS. + * If that has not been found in cache, return NULL. + */ static svn_stringbuf_t * get_cached_window(fs_fs_t *fs, representation_t *representation, @@ -473,17 +742,21 @@ get_cached_window(fs_fs_t *fs, : NULL; } +/* Cache the undeltified txdelta WINDOW for REPRESENTAION within FS. + */ static void set_cached_window(fs_fs_t *fs, representation_t *representation, svn_stringbuf_t *window) { + /* select entry */ svn_revnum_t revision = representation->revision->revision; apr_size_t offset = representation->original.offset; apr_size_t i = get_window_cache_index(fs, revision, offset); window_cache_entry_t *entry = &fs->window_cache->entries[i]; + /* if the capacity is exceeded, clear the cache */ fs->window_cache->used += window->len; if (fs->window_cache->used >= fs->window_cache->capacity) { @@ -494,6 +767,7 @@ set_cached_window(fs_fs_t *fs, fs->window_cache->used = window->len; } + /* set the entry to a copy of the window data */ entry->window = svn_stringbuf_dup(window, fs->window_cache->pool); entry->offset = offset; entry->revision = revision; @@ -554,7 +828,7 @@ read_revision_header(apr_size_t *changes { char buf[64]; const char *line; - const char *space; + char *space; apr_uint64_t val; apr_size_t len; @@ -583,7 +857,7 @@ read_revision_header(apr_size_t *changes return svn_error_create(SVN_ERR_FS_CORRUPT, NULL, _("Final line in revision file missing space")); - *(char *)space = 0; + *space = 0; SVN_ERR(svn_cstring_strtoui64(&val, line+1, 0, APR_SIZE_MAX, 10)); *root_noderev = (apr_size_t)val; @@ -724,8 +998,13 @@ key_matches(svn_string_t *string, const static int compare_noderev_offsets(const void *data, const void *key) { - return (*(const noderev_t **)data)->original.offset - - *(const apr_size_t *)key; + apr_ssize_t diff = (*(const noderev_t *const *)data)->original.offset + - *(const apr_size_t *)key; + + /* sizeof(int) may be < sizeof(ssize_t) */ + if (diff < 0) + return -1; + return diff > 0 ? 1 : 0; } static svn_error_t * @@ -771,14 +1050,14 @@ find_noderev(noderev_t **result, compare_noderev_offsets); if ((idx < 0) || (idx >= revision_info->node_revs->nelts)) return svn_error_createf(SVN_ERR_BAD_VERSION_FILE_FORMAT, NULL, - _("No noderev found at offset %" APR_OFF_T_FMT), - offset); + _("No noderev found at offset %ld"), + (long)offset); *result = APR_ARRAY_IDX(revision_info->node_revs, idx, noderev_t *); if ((*result)->original.offset != offset) return svn_error_createf(SVN_ERR_BAD_VERSION_FILE_FORMAT, NULL, - _("No noderev found at offset %" APR_OFF_T_FMT), - offset); + _("No noderev found at offset %ld"), + (long)offset); return SVN_NO_ERROR; } @@ -800,8 +1079,13 @@ parse_pred(noderev_t **result, static int compare_representation_offsets(const void *data, const void *key) { - return (*(const representation_t **)data)->original.offset - - *(const apr_size_t *)key; + apr_ssize_t diff = (*(const representation_t *const *)data)->original.offset + - *(const apr_size_t *)key; + + /* sizeof(int) may be < sizeof(ssize_t) */ + if (diff < 0) + return -1; + return diff > 0 ? 1 : 0; } static representation_t * @@ -1662,7 +1946,7 @@ add_noderev_recursively(fs_fs_t *fs, node->target.offset = *current_pos; fragment.data = node; - fragment.kind = noderep_fragment; + fragment.kind = noderev_fragment; fragment.position = *current_pos; APR_ARRAY_PUSH(fragments, fragment_t) = fragment; @@ -1794,7 +2078,7 @@ get_content_length(apr_size_t *length, case dir_fragment: *length = content->len + 16; break; - case noderep_fragment: + case noderev_fragment: *length = content->len + 3; break; default: @@ -1836,7 +2120,7 @@ move_fragment(fragment_t *fragment, representation->target.offset = new_position; break; - case noderep_fragment: + case noderev_fragment: node = fragment->data; node->target.offset = new_position; break; @@ -2006,7 +2290,7 @@ write_revisions(fs_fs_t *fs, revision_info_t *info = APR_ARRAY_IDX(pack->info, i, revision_info_t *); SVN_ERR(svn_stream_printf(stream, itempool, - "%" APR_UINT64_T_FMT "\n", + "%" APR_SIZE_T_FMT "\n", info->target.offset)); svn_pool_clear(itempool); } @@ -2187,8 +2471,8 @@ update_text(svn_stringbuf_t *node_rev, char *newline_pos = strchr(val_pos, '\n'); svn_checksum_t checksum = {representation->dir->target_md5, svn_checksum_md5}; - const char* temp = apr_psprintf(scratch_pool, "%ld %" APR_UINT64_T_FMT " %" - APR_UINT64_T_FMT" %" APR_SIZE_T_FMT " %s", + const char* temp = apr_psprintf(scratch_pool, "%ld %" APR_SIZE_T_FMT " %" + APR_SIZE_T_FMT" %" APR_SIZE_T_FMT " %s", representation->revision->revision, representation->target.offset - representation->revision->target.offset, representation->target.size, @@ -2207,7 +2491,7 @@ update_text(svn_stringbuf_t *node_rev, val_pos = end_pos + 1; end_pos = strchr(strchr(val_pos, ' ') + 1, ' '); - temp = apr_psprintf(scratch_pool, "%" APR_UINT64_T_FMT " %" APR_UINT64_T_FMT, + temp = apr_psprintf(scratch_pool, "%" APR_SIZE_T_FMT " %" APR_SIZE_T_FMT, representation->target.offset - representation->revision->target.offset, representation->target.size); @@ -2236,7 +2520,7 @@ get_fragment_content(svn_string_t **cont case header_fragment: info = fragment->data; *content = svn_string_createf(pool, - "\n%" APR_UINT64_T_FMT " %" APR_UINT64_T_FMT "\n", + "\n%" APR_SIZE_T_FMT " %" APR_SIZE_T_FMT "\n", info->root_noderev->target.offset - info->target.offset, info->target.changes); return SVN_NO_ERROR; @@ -2273,7 +2557,7 @@ get_fragment_content(svn_string_t **cont header = svn_stringbuf_create("DELTA\n", pool); else header = svn_stringbuf_createf(pool, - "DELTA %ld %" APR_UINT64_T_FMT " %" APR_UINT64_T_FMT "\n", + "DELTA %ld %" APR_SIZE_T_FMT " %" APR_SIZE_T_FMT "\n", representation->delta_base->revision->revision, representation->delta_base->target.offset - representation->delta_base->revision->target.offset, @@ -2316,7 +2600,7 @@ get_fragment_content(svn_string_t **cont { representation_t *base_rep = representation->delta_base; header = svn_stringbuf_createf(pool, - "DELTA %ld %" APR_UINT64_T_FMT " %" APR_UINT64_T_FMT "\n", + "DELTA %ld %" APR_SIZE_T_FMT " %" APR_SIZE_T_FMT "\n", base_rep->revision->revision, base_rep->target.offset - base_rep->revision->target.offset, base_rep->target.size); @@ -2342,7 +2626,7 @@ get_fragment_content(svn_string_t **cont return SVN_NO_ERROR; - case noderep_fragment: + case noderev_fragment: node = fragment->data; SVN_ERR(get_content(&revision_content, fs, node->revision->revision, pool)); Modified: subversion/branches/ev2-export/tools/server-side/svn-backup-dumps.py URL: http://svn.apache.org/viewvc/subversion/branches/ev2-export/tools/server-side/svn-backup-dumps.py?rev=1412731&r1=1412730&r2=1412731&view=diff ============================================================================== --- subversion/branches/ev2-export/tools/server-side/svn-backup-dumps.py (original) +++ subversion/branches/ev2-export/tools/server-side/svn-backup-dumps.py Fri Nov 23 01:12:18 2012 @@ -686,7 +686,7 @@ if __name__ == "__main__": print("Everything OK.") sys.exit(0) else: - print("An error occured!") + print("An error occurred!") sys.exit(1) # vim:et:ts=4:sw=4
