subversion/libsvn_fs_fs/index.c

78   /* global offset on the page within the index file */
79   apr_uint64_t offset;
130   /* phys offset + 1 of the data container. 0 for "new revision" entries. */
131   apr_uint64_t offset;
138  * an array with one offset value for each rev file cluster.
190    * (i.e. which offset will reported as offset 0 by packed_stream_offset). */
193   /* First offset within FILE after the stream data.
205   /* offset in FILE from which the first entry in BUFFER has been read */
208   /* offset in FILE from which the next number has to be read */
223  * name ("%s") and the current read offset (e.g. "0x%lx").
231   apr_off_t offset;
234   SVN_ERR(svn_io_file_get_offset(&offset, stream->file, stream->pool));
239                                         (apr_uint64_t)offset));
289       _("Can't read index file '%s' at offset 0x%s"));
299       _("Unexpected end of index file %s at offset 0x%s"));
420 /* Navigate STREAM to packed stream offset OFFSET.  There will be no checks
425                    apr_off_t offset)
427   apr_off_t file_offset = offset + stream->stream_start;
430       || offset < stream->start_offset
431       || offset >= stream->next_offset)
453 /* Return the packed stream offset of at which the next number in the stream
636                                 _("File offset 0x%s too large, max = 0x%s"),
665   SVN_ERR(write_uint64_to_proto_index(proto_index, entry.offset,
684   SVN_ERR(read_uint64_from_proto_index(proto_index, &entry->offset, eof,
738   entry.offset = 0;
747                                      apr_off_t offset,
754   SVN_ERR_ASSERT(offset >= -1);
756   /* we support offset '-1' as a "not used" indication */
757   entry.offset = (apr_uint64_t)offset + 1;
830       if (eof || (entry > 0 && proto_entry.offset == 0))
881           APR_ARRAY_IDX(entries, idx, apr_uint64_t) = proto_entry.offset;
977   apr_off_t offset;
1073   offset = packed_stream_offset(rev_file->l2p_stream);
1076       result->page_table[page].offset = offset;
1077       offset += result->page_table[page].size;
1103   /* offset of ITEM_INDEX within that page */
1122   /* revision offset within the index file */
1338   packed_stream_seek(rev_file->l2p_stream, table_entry->offset);
1357       != table_entry->offset + table_entry->size)
1432       if (   entry->offset < (apr_uint64_t)min_offset
1433           || entry->offset + entry->size > (apr_uint64_t)max_offset)
1472   /* offset within the cached page */
1476   /* absolute item or container offset in rev / pack file */
1477   apr_uint64_t offset;
1480 /* Return the rev / pack file offset of the item at BATON->PAGE_OFFSET in
1499   baton->offset = offsets[baton->page_offset];
1524 /* Using the log-to-phys indexes in FS, find the absolute offset in the
1529 l2p_index_lookup(apr_off_t *offset,
1576         = APR_ALIGN(info_baton.entry.offset + info_baton.entry.size,
1630   *offset = page_baton.offset;
1636  * absolute offset in the proto rev file for the given ITEM_INDEX and return
1640 l2p_proto_index_lookup(apr_off_t *offset,
1655   *offset = -1;
1667           *offset = (apr_off_t)entry.offset - 1;
1791           /* for data in txns, item_index *is* the offset */
1812          item_index *is* the offset */
1848   SVN_ERR_ASSERT(entry->offset >= 0);
1860   SVN_ERR(write_uint64_to_proto_index(proto_index, entry->offset,
1889   SVN_ERR(read_off_t_from_proto_index(proto_index, &entry->offset,
1938   apr_off_t offset = 0;
1941   SVN_ERR(svn_io_file_seek(proto_index, APR_END, &offset, scratch_pool));
1942   if (offset == 0)
1950       offset -= P2L_PROTO_INDEX_ENTRY_SIZE;
1952       SVN_ERR(svn_io_file_seek(proto_index, APR_SET, &offset, scratch_pool));
1956       /* Return next offset. */
1957       *next_offset = entry.offset + entry.size;
1984   apr_uint64_t last_buffer_size = 0;  /* byte offset in the spill buffer at
2027           entry.offset = last_entry_end;
2028           entry.size = APR_ALIGN(entry.offset, page_size) - entry.offset;
2042       entry_end = entry.offset + entry.size;
2054       /* this entry starts a new table -> store its offset
2059                                       encode_uint(encoded, entry.offset),
2169   apr_off_t offset;
2204                    _("Index offset and rev / pack file size do not match"));
2229   /* correct the offset values */
2230   offset = packed_stream_offset(rev_file->p2l_stream);
2232     result->offsets[i] += offset;
2252   /* offset within the page in rev / pack file */
2253   apr_off_t offset;
2262   /* offset within the p2l index file describing this page */
2265   /* offset within the p2l index file describing the following page */
2286   /* if the requested offset is out of bounds, return info for
2289   if (baton->offset / header->page_size < header->page_count)
2292       baton->page_no = (apr_size_t)(baton->offset / header->page_size);
2334  * index page for the rev / pack file offset BATON->OFFSET.  Use REV_FILE
2369  * RESULT.  *ITEM_INDEX contains the phys offset for the entry and will
2383   entry.offset = *item_offset;
2428   if ((apr_uint64_t)entry.offset + (apr_uint64_t)entry.size > off_t_max)
2439  * offset PAGE_START from the index for START_REVISION in FS.  The data
2460   apr_off_t offset;
2468   /* read rev file offset of the first page entry (all page entries will
2492           offset = packed_stream_offset(rev_file->p2l_stream);
2494       while (offset < next_offset);
2496       /* We should now be exactly at the next offset, i.e. the numbers in
2498       if (offset != next_offset)
2602              apr_off_t offset,
2609   page_info.offset = offset;
2613   /* if the offset refers to a non-existent page, bail out */
2617                               apr_off_t_toa(scratch_pool, offset), revision);
2646   apr_off_t diff = entry->offset - start;
2669       if (entry->offset + entry->size > block_start)
2677       if (entry->offset >= block_end)
2776           prefetch_info.offset = original_page_start;
2777           while (prefetch_info.offset >= prefetch_info.page_size && !end)
2781               prefetch_info.offset -= prefetch_info.page_size;
2803           if (  entry->offset + entry->size
2823           prefetch_info.offset = original_page_start;
2830               prefetch_info.offset += prefetch_info.page_size;
2853       apr_off_t entry_end = entry->offset + entry->size;
2859               entry->size = block_end - entry->offset;
2865               entry->offset = entry_end;
2907       block_start = entry->offset + entry->size;
2916                                         svn_fs_fs__p2l_entry_t).offset
2917                           >= entry->offset + entry->size);
2927 /* compare_fn_t comparing a svn_fs_fs__p2l_entry_t at LHS with an offset
2934   apr_off_t offset = *(const apr_off_t *)rhs;
2936   return entry->offset < offset ? -1 : (entry->offset == offset ? 0 : 1);
2942  * the start offset of any item. Use SCRATCH_POOL for temporary allocations.
2946                                apr_uint64_t offset,
2959   /* search of the offset we want */
2960   entry = svn_sort__array_lookup(entries, &offset, NULL,
2982   *out = entry && entry->offset == *(apr_off_t *)baton
2994                             apr_off_t offset,
3006   SVN_ERR(get_p2l_keys(&page_info, &key, rev_file, fs, revision, offset,
3010                                  p2l_entry_lookup_func, &offset,
3018       SVN_ERR(p2l_index_lookup(entries, rev_file, fs, revision, offset,
3019                                offset + 1, scratch_pool));
3022       *entry_p = svn_sort__array_lookup(entries, &offset, NULL,
3030  * to the largest the first offset not covered by this P2L index.
3049 p2l_get_max_offset(apr_off_t *offset,
3071       *offset = *offset_p;
3077   *offset = header->file_size;
3083 svn_fs_fs__p2l_get_max_offset(apr_off_t *offset,
3089   return svn_error_trace(p2l_get_max_offset(offset, fs, rev_file, revision,
3093 /* Calculate the FNV1 checksum over the offset range in REV_FILE, covered by
3117   SVN_ERR(svn_io_file_seek(rev_file->file, APR_SET, &entry->offset,
3248                                                    entry->offset,