Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * blkreftable.c
4 : : * Block reference tables.
5 : : *
6 : : * A block reference table is used to keep track of which blocks have
7 : : * been modified by WAL records within a certain LSN range.
8 : : *
9 : : * For each relation fork, we keep track of all blocks that have appeared
10 : : * in block reference in the WAL. We also keep track of the "limit block",
11 : : * which is the smallest relation length in blocks known to have occurred
12 : : * during that range of WAL records. This should be set to 0 if the relation
13 : : * fork is created or destroyed, and to the post-truncation length if
14 : : * truncated.
15 : : *
16 : : * Whenever we set the limit block, we also forget about any modified blocks
17 : : * beyond that point. Those blocks don't exist any more. Such blocks can
18 : : * later be marked as modified again; if that happens, it means the relation
19 : : * was re-extended.
20 : : *
21 : : * Portions Copyright (c) 2010-2026, PostgreSQL Global Development Group
22 : : *
23 : : * src/common/blkreftable.c
24 : : *
25 : : *-------------------------------------------------------------------------
26 : : */
27 : :
28 : :
29 : : #ifndef FRONTEND
30 : : #include "postgres.h"
31 : : #else
32 : : #include "postgres_fe.h"
33 : : #endif
34 : :
35 : : #ifdef FRONTEND
36 : : #include "common/logging.h"
37 : : #endif
38 : :
39 : : #include "common/blkreftable.h"
40 : : #include "common/hashfn.h"
41 : : #include "port/pg_crc32c.h"
42 : :
43 : : /*
44 : : * A block reference table keeps track of the status of each relation
45 : : * fork individually.
46 : : */
47 : : typedef struct BlockRefTableKey
48 : : {
49 : : RelFileLocator rlocator;
50 : : ForkNumber forknum;
51 : : } BlockRefTableKey;
52 : :
53 : : /*
54 : : * We could need to store data either for a relation in which only a
55 : : * tiny fraction of the blocks have been modified or for a relation in
56 : : * which nearly every block has been modified, and we want a
57 : : * space-efficient representation in both cases. To accomplish this,
58 : : * we divide the relation into chunks of 2^16 blocks and choose between
59 : : * an array representation and a bitmap representation for each chunk.
60 : : *
61 : : * When the number of modified blocks in a given chunk is small, we
62 : : * essentially store an array of block numbers, but we need not store the
63 : : * entire block number: instead, we store each block number as a 2-byte
64 : : * offset from the start of the chunk.
65 : : *
66 : : * When the number of modified blocks in a given chunk is large, we switch
67 : : * to a bitmap representation.
68 : : *
69 : : * These same basic representational choices are used both when a block
70 : : * reference table is stored in memory and when it is serialized to disk.
71 : : *
72 : : * In the in-memory representation, we initially allocate each chunk with
73 : : * space for a number of entries given by INITIAL_ENTRIES_PER_CHUNK and
74 : : * increase that as necessary until we reach MAX_ENTRIES_PER_CHUNK.
75 : : * Any chunk whose allocated size reaches MAX_ENTRIES_PER_CHUNK is converted
76 : : * to a bitmap, and thus never needs to grow further.
77 : : */
78 : : #define BLOCKS_PER_CHUNK (1 << 16)
79 : : #define BLOCKS_PER_ENTRY (BITS_PER_BYTE * sizeof(uint16))
80 : : #define MAX_ENTRIES_PER_CHUNK (BLOCKS_PER_CHUNK / BLOCKS_PER_ENTRY)
81 : : #define INITIAL_ENTRIES_PER_CHUNK 16
82 : : typedef uint16 *BlockRefTableChunk;
83 : :
84 : : /*
85 : : * State for one relation fork.
86 : : *
87 : : * 'rlocator' and 'forknum' identify the relation fork to which this entry
88 : : * pertains.
89 : : *
90 : : * 'limit_block' is the shortest known length of the relation in blocks
91 : : * within the LSN range covered by a particular block reference table.
92 : : * It should be set to 0 if the relation fork is created or dropped. If the
93 : : * relation fork is truncated, it should be set to the number of blocks that
94 : : * remain after truncation.
95 : : *
96 : : * 'nchunks' is the allocated length of each of the three arrays that follow.
97 : : * We can only represent the status of block numbers less than nchunks *
98 : : * BLOCKS_PER_CHUNK.
99 : : *
100 : : * 'chunk_size' is an array storing the allocated size of each chunk.
101 : : *
102 : : * 'chunk_usage' is an array storing the number of elements used in each
103 : : * chunk. If that value is less than MAX_ENTRIES_PER_CHUNK, the corresponding
104 : : * chunk is used as an array; else the corresponding chunk is used as a bitmap.
105 : : * When used as a bitmap, the least significant bit of the first array element
106 : : * is the status of the lowest-numbered block covered by this chunk.
107 : : *
108 : : * 'chunk_data' is the array of chunks.
109 : : */
110 : : struct BlockRefTableEntry
111 : : {
112 : : BlockRefTableKey key;
113 : : BlockNumber limit_block;
114 : : char status;
115 : : uint32 nchunks;
116 : : uint16 *chunk_size;
117 : : uint16 *chunk_usage;
118 : : BlockRefTableChunk *chunk_data;
119 : : };
120 : :
121 : : /* Declare and define a hash table over type BlockRefTableEntry. */
122 : : #define SH_PREFIX blockreftable
123 : : #define SH_ELEMENT_TYPE BlockRefTableEntry
124 : : #define SH_KEY_TYPE BlockRefTableKey
125 : : #define SH_KEY key
126 : : #define SH_HASH_KEY(tb, key) \
127 : : hash_bytes((const unsigned char *) &key, sizeof(BlockRefTableKey))
128 : : #define SH_EQUAL(tb, a, b) (memcmp(&a, &b, sizeof(BlockRefTableKey)) == 0)
129 : : #define SH_SCOPE static inline
130 : : #ifdef FRONTEND
131 : : #define SH_RAW_ALLOCATOR pg_malloc0
132 : : #endif
133 : : #define SH_DEFINE
134 : : #define SH_DECLARE
135 : : #include "lib/simplehash.h"
136 : :
137 : : /*
138 : : * A block reference table is basically just the hash table, but we don't
139 : : * want to expose that to outside callers.
140 : : *
141 : : * We keep track of the memory context in use explicitly too, so that it's
142 : : * easy to place all of our allocations in the same context.
143 : : */
144 : : struct BlockRefTable
145 : : {
146 : : blockreftable_hash *hash;
147 : : #ifndef FRONTEND
148 : : MemoryContext mcxt;
149 : : #endif
150 : : };
151 : :
152 : : /*
153 : : * On-disk serialization format for block reference table entries.
154 : : */
155 : : typedef struct BlockRefTableSerializedEntry
156 : : {
157 : : RelFileLocator rlocator;
158 : : ForkNumber forknum;
159 : : BlockNumber limit_block;
160 : : uint32 nchunks;
161 : : } BlockRefTableSerializedEntry;
162 : :
163 : : /*
164 : : * Buffer size, so that we avoid doing many small I/Os.
165 : : */
166 : : #define BUFSIZE 65536
167 : :
168 : : /*
169 : : * Ad-hoc buffer for file I/O.
170 : : */
171 : : typedef struct BlockRefTableBuffer
172 : : {
173 : : io_callback_fn io_callback;
174 : : void *io_callback_arg;
175 : : char data[BUFSIZE];
176 : : size_t used;
177 : : size_t cursor;
178 : : pg_crc32c crc;
179 : : } BlockRefTableBuffer;
180 : :
181 : : /*
182 : : * State for keeping track of progress while incrementally reading a block
183 : : * table reference file from disk.
184 : : *
185 : : * total_chunks means the number of chunks for the RelFileLocator/ForkNumber
186 : : * combination that is currently being read, and consumed_chunks is the number
187 : : * of those that have been read. (We always read all the information for
188 : : * a single chunk at one time, so we don't need to be able to represent the
189 : : * state where a chunk has been partially read.)
190 : : *
191 : : * chunk_size is the array of chunk sizes. The length is given by total_chunks.
192 : : *
193 : : * chunk_data holds the current chunk.
194 : : *
195 : : * chunk_position helps us figure out how much progress we've made in returning
196 : : * the block numbers for the current chunk to the caller. If the chunk is a
197 : : * bitmap, it's the number of bits we've scanned; otherwise, it's the number
198 : : * of chunk entries we've scanned.
199 : : */
200 : : struct BlockRefTableReader
201 : : {
202 : : BlockRefTableBuffer buffer;
203 : : char *error_filename;
204 : : report_error_fn error_callback;
205 : : void *error_callback_arg;
206 : : uint32 total_chunks;
207 : : uint32 consumed_chunks;
208 : : uint16 *chunk_size;
209 : : uint16 chunk_data[MAX_ENTRIES_PER_CHUNK];
210 : : uint32 chunk_position;
211 : : };
212 : :
213 : : /*
214 : : * State for keeping track of progress while incrementally writing a block
215 : : * reference table file to disk.
216 : : */
217 : : struct BlockRefTableWriter
218 : : {
219 : : BlockRefTableBuffer buffer;
220 : : };
221 : :
222 : : /* Function prototypes. */
223 : : static int BlockRefTableComparator(const void *a, const void *b);
224 : : static void BlockRefTableFlush(BlockRefTableBuffer *buffer);
225 : : static void BlockRefTableRead(BlockRefTableReader *reader, void *data,
226 : : size_t length);
227 : : static void BlockRefTableWrite(BlockRefTableBuffer *buffer, void *data,
228 : : size_t length);
229 : : static void BlockRefTableFileTerminate(BlockRefTableBuffer *buffer);
230 : :
231 : : /*
232 : : * Create an empty block reference table.
233 : : */
234 : : BlockRefTable *
235 : 45 : CreateEmptyBlockRefTable(void)
236 : : {
237 : 45 : BlockRefTable *brtab = palloc_object(BlockRefTable);
238 : :
239 : : /*
240 : : * Even completely empty database has a few hundred relation forks, so it
241 : : * seems best to size the hash on the assumption that we're going to have
242 : : * at least a few thousand entries.
243 : : */
244 : : #ifdef FRONTEND
245 : 0 : brtab->hash = blockreftable_create(4096, NULL);
246 : : #else
247 : 45 : brtab->mcxt = CurrentMemoryContext;
248 : 45 : brtab->hash = blockreftable_create(brtab->mcxt, 4096, NULL);
249 : : #endif
250 : :
251 : 45 : return brtab;
252 : : }
253 : :
254 : : /*
255 : : * Set the "limit block" for a relation fork and forget any modified blocks
256 : : * with equal or higher block numbers.
257 : : *
258 : : * The "limit block" is the shortest known length of the relation within the
259 : : * range of WAL records covered by this block reference table.
260 : : */
261 : : void
262 : 439 : BlockRefTableSetLimitBlock(BlockRefTable *brtab,
263 : : const RelFileLocator *rlocator,
264 : : ForkNumber forknum,
265 : : BlockNumber limit_block)
266 : : {
267 : : BlockRefTableEntry *brtentry;
268 : 439 : BlockRefTableKey key = {0}; /* make sure any padding is zero */
269 : : bool found;
270 : :
271 : 439 : memcpy(&key.rlocator, rlocator, sizeof(RelFileLocator));
272 : 439 : key.forknum = forknum;
273 : 439 : brtentry = blockreftable_insert(brtab->hash, key, &found);
274 : :
275 [ + + ]: 439 : if (!found)
276 : : {
277 : : /*
278 : : * We have no existing data about this relation fork, so just record
279 : : * the limit_block value supplied by the caller, and make sure other
280 : : * parts of the entry are properly initialized.
281 : : */
282 : 433 : brtentry->limit_block = limit_block;
283 : 433 : brtentry->nchunks = 0;
284 : 433 : brtentry->chunk_size = NULL;
285 : 433 : brtentry->chunk_usage = NULL;
286 : 433 : brtentry->chunk_data = NULL;
287 : 433 : return;
288 : : }
289 : :
290 : 6 : BlockRefTableEntrySetLimitBlock(brtentry, limit_block);
291 : : }
292 : :
293 : : /*
294 : : * Mark a block in a given relation fork as known to have been modified.
295 : : */
296 : : void
297 : 77575 : BlockRefTableMarkBlockModified(BlockRefTable *brtab,
298 : : const RelFileLocator *rlocator,
299 : : ForkNumber forknum,
300 : : BlockNumber blknum)
301 : : {
302 : : BlockRefTableEntry *brtentry;
303 : 77575 : BlockRefTableKey key = {0}; /* make sure any padding is zero */
304 : : bool found;
305 : : #ifndef FRONTEND
306 : 77575 : MemoryContext oldcontext = MemoryContextSwitchTo(brtab->mcxt);
307 : : #endif
308 : :
309 : 77575 : memcpy(&key.rlocator, rlocator, sizeof(RelFileLocator));
310 : 77575 : key.forknum = forknum;
311 : 77575 : brtentry = blockreftable_insert(brtab->hash, key, &found);
312 : :
313 [ + + ]: 77575 : if (!found)
314 : : {
315 : : /*
316 : : * We want to set the initial limit block value to something higher
317 : : * than any legal block number. InvalidBlockNumber fits the bill.
318 : : */
319 : 1016 : brtentry->limit_block = InvalidBlockNumber;
320 : 1016 : brtentry->nchunks = 0;
321 : 1016 : brtentry->chunk_size = NULL;
322 : 1016 : brtentry->chunk_usage = NULL;
323 : 1016 : brtentry->chunk_data = NULL;
324 : : }
325 : :
326 : 77575 : BlockRefTableEntryMarkBlockModified(brtentry, forknum, blknum);
327 : :
328 : : #ifndef FRONTEND
329 : 77575 : MemoryContextSwitchTo(oldcontext);
330 : : #endif
331 : 77575 : }
332 : :
333 : : /*
334 : : * Get an entry from a block reference table.
335 : : *
336 : : * If the entry does not exist, this function returns NULL. Otherwise, it
337 : : * returns the entry and sets *limit_block to the value from the entry.
338 : : */
339 : : BlockRefTableEntry *
340 : 21825 : BlockRefTableGetEntry(BlockRefTable *brtab, const RelFileLocator *rlocator,
341 : : ForkNumber forknum, BlockNumber *limit_block)
342 : : {
343 : 21825 : BlockRefTableKey key = {0}; /* make sure any padding is zero */
344 : : BlockRefTableEntry *entry;
345 : :
346 : : Assert(limit_block != NULL);
347 : :
348 : 21825 : memcpy(&key.rlocator, rlocator, sizeof(RelFileLocator));
349 : 21825 : key.forknum = forknum;
350 : 21825 : entry = blockreftable_lookup(brtab->hash, key);
351 : :
352 [ + + ]: 21825 : if (entry != NULL)
353 : 328 : *limit_block = entry->limit_block;
354 : :
355 : 21825 : return entry;
356 : : }
357 : :
358 : : /*
359 : : * Get block numbers from a table entry.
360 : : *
361 : : * 'blocks' must point to enough space to hold at least 'nblocks' block
362 : : * numbers, and any block numbers we manage to get will be written there.
363 : : * The return value is the number of block numbers actually written.
364 : : *
365 : : * We do not return block numbers unless they are greater than or equal to
366 : : * start_blkno and strictly less than stop_blkno.
367 : : */
368 : : int
369 : 47 : BlockRefTableEntryGetBlocks(BlockRefTableEntry *entry,
370 : : BlockNumber start_blkno,
371 : : BlockNumber stop_blkno,
372 : : BlockNumber *blocks,
373 : : int nblocks)
374 : : {
375 : : uint32 start_chunkno;
376 : : uint32 stop_chunkno;
377 : : uint32 chunkno;
378 : 47 : int nresults = 0;
379 : :
380 : : Assert(entry != NULL);
381 : :
382 : : /*
383 : : * Figure out which chunks could potentially contain blocks of interest.
384 : : *
385 : : * We need to be careful about overflow here, because stop_blkno could be
386 : : * InvalidBlockNumber or something very close to it.
387 : : */
388 : 47 : start_chunkno = start_blkno / BLOCKS_PER_CHUNK;
389 : 47 : stop_chunkno = stop_blkno / BLOCKS_PER_CHUNK;
390 [ + - ]: 47 : if ((stop_blkno % BLOCKS_PER_CHUNK) != 0)
391 : 47 : ++stop_chunkno;
392 [ + + ]: 47 : if (stop_chunkno > entry->nchunks)
393 : 1 : stop_chunkno = entry->nchunks;
394 : :
395 : : /*
396 : : * Loop over chunks.
397 : : */
398 [ + + ]: 93 : for (chunkno = start_chunkno; chunkno < stop_chunkno; ++chunkno)
399 : : {
400 : 46 : uint16 chunk_usage = entry->chunk_usage[chunkno];
401 : 46 : BlockRefTableChunk chunk_data = entry->chunk_data[chunkno];
402 : 46 : unsigned start_offset = 0;
403 : 46 : unsigned stop_offset = BLOCKS_PER_CHUNK;
404 : :
405 : : /*
406 : : * If the start and/or stop block number falls within this chunk, the
407 : : * whole chunk may not be of interest. Figure out which portion we
408 : : * care about, if it's not the whole thing.
409 : : */
410 [ + - ]: 46 : if (chunkno == start_chunkno)
411 : 46 : start_offset = start_blkno % BLOCKS_PER_CHUNK;
412 [ + - ]: 46 : if (chunkno == stop_chunkno - 1)
413 : : {
414 : : Assert(stop_blkno > chunkno * BLOCKS_PER_CHUNK);
415 : 46 : stop_offset = stop_blkno - (chunkno * BLOCKS_PER_CHUNK);
416 : : Assert(stop_offset <= BLOCKS_PER_CHUNK);
417 : : }
418 : :
419 : : /*
420 : : * Handling differs depending on whether this is an array of offsets
421 : : * or a bitmap.
422 : : */
423 [ - + ]: 46 : if (chunk_usage == MAX_ENTRIES_PER_CHUNK)
424 : : {
425 : : unsigned i;
426 : :
427 : : /* It's a bitmap, so test every relevant bit. */
428 [ # # ]: 0 : for (i = start_offset; i < stop_offset; ++i)
429 : : {
430 : 0 : uint16 w = chunk_data[i / BLOCKS_PER_ENTRY];
431 : :
432 [ # # ]: 0 : if ((w & (1 << (i % BLOCKS_PER_ENTRY))) != 0)
433 : : {
434 : 0 : BlockNumber blkno = chunkno * BLOCKS_PER_CHUNK + i;
435 : :
436 : 0 : blocks[nresults++] = blkno;
437 : :
438 : : /* Early exit if we run out of output space. */
439 [ # # ]: 0 : if (nresults == nblocks)
440 : 0 : return nresults;
441 : : }
442 : : }
443 : : }
444 : : else
445 : : {
446 : : unsigned i;
447 : :
448 : : /* It's an array of offsets, so check each one. */
449 [ + + ]: 135 : for (i = 0; i < chunk_usage; ++i)
450 : : {
451 : 89 : uint16 offset = chunk_data[i];
452 : :
453 [ + - + - ]: 89 : if (offset >= start_offset && offset < stop_offset)
454 : : {
455 : 89 : BlockNumber blkno = chunkno * BLOCKS_PER_CHUNK + offset;
456 : :
457 : 89 : blocks[nresults++] = blkno;
458 : :
459 : : /* Early exit if we run out of output space. */
460 [ - + ]: 89 : if (nresults == nblocks)
461 : 0 : return nresults;
462 : : }
463 : : }
464 : : }
465 : : }
466 : :
467 : 47 : return nresults;
468 : : }
469 : :
470 : : /*
471 : : * Serialize a block reference table to a file.
472 : : */
473 : : void
474 : 28 : WriteBlockRefTable(BlockRefTable *brtab,
475 : : io_callback_fn write_callback,
476 : : void *write_callback_arg)
477 : : {
478 : 28 : BlockRefTableSerializedEntry *sdata = NULL;
479 : : BlockRefTableBuffer buffer;
480 : 28 : uint32 magic = BLOCKREFTABLE_MAGIC;
481 : :
482 : : /* Prepare buffer. */
483 : 28 : memset(&buffer, 0, sizeof(BlockRefTableBuffer));
484 : 28 : buffer.io_callback = write_callback;
485 : 28 : buffer.io_callback_arg = write_callback_arg;
486 : 28 : INIT_CRC32C(buffer.crc);
487 : :
488 : : /* Write magic number. */
489 : 28 : BlockRefTableWrite(&buffer, &magic, sizeof(uint32));
490 : :
491 : : /* Write the entries, assuming there are some. */
492 [ + + ]: 28 : if (brtab->hash->members > 0)
493 : : {
494 : 23 : unsigned i = 0;
495 : : blockreftable_iterator it;
496 : : BlockRefTableEntry *brtentry;
497 : :
498 : : /* Extract entries into serializable format and sort them. */
499 : : sdata =
500 : 23 : palloc_array(BlockRefTableSerializedEntry, brtab->hash->members);
501 : 23 : blockreftable_start_iterate(brtab->hash, &it);
502 [ + + ]: 1087 : while ((brtentry = blockreftable_iterate(brtab->hash, &it)) != NULL)
503 : : {
504 : 1064 : BlockRefTableSerializedEntry *sentry = &sdata[i++];
505 : :
506 : 1064 : sentry->rlocator = brtentry->key.rlocator;
507 : 1064 : sentry->forknum = brtentry->key.forknum;
508 : 1064 : sentry->limit_block = brtentry->limit_block;
509 : 1064 : sentry->nchunks = brtentry->nchunks;
510 : :
511 : : /* trim trailing zero entries */
512 [ + + ]: 16725 : while (sentry->nchunks > 0 &&
513 [ + + ]: 16704 : brtentry->chunk_usage[sentry->nchunks - 1] == 0)
514 : 15661 : sentry->nchunks--;
515 : : }
516 : : Assert(i == brtab->hash->members);
517 : 23 : qsort(sdata, i, sizeof(BlockRefTableSerializedEntry),
518 : : BlockRefTableComparator);
519 : :
520 : : /* Loop over entries in sorted order and serialize each one. */
521 [ + + ]: 1087 : for (i = 0; i < brtab->hash->members; ++i)
522 : : {
523 : 1064 : BlockRefTableSerializedEntry *sentry = &sdata[i];
524 : 1064 : BlockRefTableKey key = {0}; /* make sure any padding is zero */
525 : : unsigned j;
526 : :
527 : : /* Write the serialized entry itself. */
528 : 1064 : BlockRefTableWrite(&buffer, sentry,
529 : : sizeof(BlockRefTableSerializedEntry));
530 : :
531 : : /* Look up the original entry so we can access the chunks. */
532 : 1064 : memcpy(&key.rlocator, &sentry->rlocator, sizeof(RelFileLocator));
533 : 1064 : key.forknum = sentry->forknum;
534 : 1064 : brtentry = blockreftable_lookup(brtab->hash, key);
535 : : Assert(brtentry != NULL);
536 : :
537 : : /* Write the untruncated portion of the chunk length array. */
538 [ + + ]: 1064 : if (sentry->nchunks != 0)
539 : 1043 : BlockRefTableWrite(&buffer, brtentry->chunk_usage,
540 : 1043 : sentry->nchunks * sizeof(uint16));
541 : :
542 : : /* Write the contents of each chunk. */
543 [ + + ]: 17768 : for (j = 0; j < brtentry->nchunks; ++j)
544 : : {
545 [ + + ]: 16704 : if (brtentry->chunk_usage[j] == 0)
546 : 15661 : continue;
547 : 1043 : BlockRefTableWrite(&buffer, brtentry->chunk_data[j],
548 : 1043 : brtentry->chunk_usage[j] * sizeof(uint16));
549 : : }
550 : : }
551 : : }
552 : :
553 : : /* Write out appropriate terminator and CRC and flush buffer. */
554 : 28 : BlockRefTableFileTerminate(&buffer);
555 : 28 : }
556 : :
557 : : /*
558 : : * Prepare to incrementally read a block reference table file.
559 : : *
560 : : * 'read_callback' is a function that can be called to read data from the
561 : : * underlying file (or other data source) into our internal buffer.
562 : : *
563 : : * 'read_callback_arg' is an opaque argument to be passed to read_callback.
564 : : *
565 : : * 'error_filename' is the filename that should be included in error messages
566 : : * if the file is found to be malformed. The value is not copied, so the
567 : : * caller should ensure that it remains valid until done with this
568 : : * BlockRefTableReader.
569 : : *
570 : : * 'error_callback' is a function to be called if the file is found to be
571 : : * malformed. This is not used for I/O errors, which must be handled internally
572 : : * by read_callback.
573 : : *
574 : : * 'error_callback_arg' is an opaque argument to be passed to error_callback.
575 : : */
576 : : BlockRefTableReader *
577 : 30 : CreateBlockRefTableReader(io_callback_fn read_callback,
578 : : void *read_callback_arg,
579 : : char *error_filename,
580 : : report_error_fn error_callback,
581 : : void *error_callback_arg)
582 : : {
583 : : BlockRefTableReader *reader;
584 : : uint32 magic;
585 : :
586 : : /* Initialize data structure. */
587 : 30 : reader = palloc0_object(BlockRefTableReader);
588 : 30 : reader->buffer.io_callback = read_callback;
589 : 30 : reader->buffer.io_callback_arg = read_callback_arg;
590 : 30 : reader->error_filename = error_filename;
591 : 30 : reader->error_callback = error_callback;
592 : 30 : reader->error_callback_arg = error_callback_arg;
593 : 30 : INIT_CRC32C(reader->buffer.crc);
594 : :
595 : : /* Verify magic number. */
596 : 30 : BlockRefTableRead(reader, &magic, sizeof(uint32));
597 [ - + ]: 30 : if (magic != BLOCKREFTABLE_MAGIC)
598 : 0 : error_callback(error_callback_arg,
599 : : "file \"%s\" has wrong magic number: expected %u, found %u",
600 : : error_filename,
601 : : BLOCKREFTABLE_MAGIC, magic);
602 : :
603 : 30 : return reader;
604 : : }
605 : :
606 : : /*
607 : : * Read next relation fork covered by this block reference table file.
608 : : *
609 : : * After calling this function, you must call BlockRefTableReaderGetBlocks
610 : : * until it returns 0 before calling it again.
611 : : */
612 : : bool
613 : 758 : BlockRefTableReaderNextRelation(BlockRefTableReader *reader,
614 : : RelFileLocator *rlocator,
615 : : ForkNumber *forknum,
616 : : BlockNumber *limit_block)
617 : : {
618 : : BlockRefTableSerializedEntry sentry;
619 : 758 : BlockRefTableSerializedEntry zentry = {0};
620 : :
621 : : /*
622 : : * Sanity check: caller must read all blocks from all chunks before moving
623 : : * on to the next relation.
624 : : */
625 : : Assert(reader->total_chunks == reader->consumed_chunks);
626 : :
627 : : /* Read serialized entry. */
628 : 758 : BlockRefTableRead(reader, &sentry,
629 : : sizeof(BlockRefTableSerializedEntry));
630 : :
631 : : /*
632 : : * If we just read the sentinel entry indicating that we've reached the
633 : : * end, read and check the CRC.
634 : : */
635 [ + + ]: 758 : if (memcmp(&sentry, &zentry, sizeof(BlockRefTableSerializedEntry)) == 0)
636 : : {
637 : : pg_crc32c expected_crc;
638 : : pg_crc32c actual_crc;
639 : :
640 : : /*
641 : : * We want to know the CRC of the file excluding the 4-byte CRC
642 : : * itself, so copy the current value of the CRC accumulator before
643 : : * reading those bytes, and use the copy to finalize the calculation.
644 : : */
645 : 30 : expected_crc = reader->buffer.crc;
646 : 30 : FIN_CRC32C(expected_crc);
647 : :
648 : : /* Now we can read the actual value. */
649 : 30 : BlockRefTableRead(reader, &actual_crc, sizeof(pg_crc32c));
650 : :
651 : : /* Throw an error if there is a mismatch. */
652 [ - + ]: 30 : if (!EQ_CRC32C(expected_crc, actual_crc))
653 : 0 : reader->error_callback(reader->error_callback_arg,
654 : : "file \"%s\" has wrong checksum: expected %08X, found %08X",
655 : : reader->error_filename, expected_crc, actual_crc);
656 : :
657 : 30 : return false;
658 : : }
659 : :
660 : : /* Sanity-check the fork number. */
661 [ + - - + ]: 728 : if (sentry.forknum < 0 || sentry.forknum > MAX_FORKNUM)
662 : : {
663 : 0 : reader->error_callback(reader->error_callback_arg,
664 : : "file \"%s\" has invalid fork number %d",
665 : 0 : reader->error_filename, sentry.forknum);
666 : 0 : return false;
667 : : }
668 : :
669 : : /*
670 : : * Sanity-check the nchunks value. In the backend, palloc_array would
671 : : * enforce this anyway (with a more generic error message); but in
672 : : * frontend it would not, potentially allowing BlockRefTableRead's length
673 : : * parameter to overflow.
674 : : */
675 [ - + ]: 728 : if (sentry.nchunks > MaxAllocSize / sizeof(uint16))
676 : : {
677 : 0 : reader->error_callback(reader->error_callback_arg,
678 : : "file \"%s\" has oversized chunk size array",
679 : : reader->error_filename);
680 : 0 : return false;
681 : : }
682 : :
683 : : /* Read chunk size array. */
684 [ + + ]: 728 : if (reader->chunk_size != NULL)
685 : 707 : pfree(reader->chunk_size);
686 : 728 : reader->chunk_size = palloc_array(uint16, sentry.nchunks);
687 : 728 : BlockRefTableRead(reader, reader->chunk_size,
688 : 728 : sentry.nchunks * sizeof(uint16));
689 : :
690 : : /* Sanity-check the chunk sizes. */
691 [ + + ]: 1344 : for (unsigned i = 0; i < sentry.nchunks; ++i)
692 : : {
693 [ - + ]: 616 : if (reader->chunk_size[i] > MAX_ENTRIES_PER_CHUNK)
694 : : {
695 : 0 : reader->error_callback(reader->error_callback_arg,
696 : : "file \"%s\" chunk %u has invalid size %u",
697 : : reader->error_filename, i,
698 : 0 : (unsigned) reader->chunk_size[i]);
699 : 0 : return false;
700 : : }
701 : : }
702 : :
703 : : /* Set up for chunk scan. */
704 : 728 : reader->total_chunks = sentry.nchunks;
705 : 728 : reader->consumed_chunks = 0;
706 : :
707 : : /* Return data to caller. */
708 : 728 : memcpy(rlocator, &sentry.rlocator, sizeof(RelFileLocator));
709 : 728 : *forknum = sentry.forknum;
710 : 728 : *limit_block = sentry.limit_block;
711 : 728 : return true;
712 : : }
713 : :
714 : : /*
715 : : * Get modified blocks associated with the relation fork returned by
716 : : * the most recent call to BlockRefTableReaderNextRelation.
717 : : *
718 : : * On return, block numbers will be written into the 'blocks' array, whose
719 : : * length should be passed via 'nblocks'. The return value is the number of
720 : : * entries actually written into the 'blocks' array, which may be less than
721 : : * 'nblocks' if we run out of modified blocks in the relation fork before
722 : : * we run out of room in the array.
723 : : */
724 : : unsigned
725 : 1342 : BlockRefTableReaderGetBlocks(BlockRefTableReader *reader,
726 : : BlockNumber *blocks,
727 : : int nblocks)
728 : : {
729 : 1342 : unsigned blocks_found = 0;
730 : :
731 : : /* Must provide space for at least one block number to be returned. */
732 : : Assert(nblocks > 0);
733 : :
734 : : /* Loop collecting blocks to return to caller. */
735 : : for (;;)
736 : 616 : {
737 : : uint16 next_chunk_size;
738 : :
739 : : /*
740 : : * If we've read at least one chunk, maybe it contains some block
741 : : * numbers that could satisfy caller's request.
742 : : */
743 [ + + ]: 1958 : if (reader->consumed_chunks > 0)
744 : : {
745 : 1230 : uint32 chunkno = reader->consumed_chunks - 1;
746 : 1230 : uint16 chunk_size = reader->chunk_size[chunkno];
747 : :
748 [ - + ]: 1230 : if (chunk_size == MAX_ENTRIES_PER_CHUNK)
749 : : {
750 : : /* Bitmap format, so search for bits that are set. */
751 [ # # ]: 0 : while (reader->chunk_position < BLOCKS_PER_CHUNK &&
752 [ # # ]: 0 : blocks_found < nblocks)
753 : : {
754 : 0 : uint16 chunkoffset = reader->chunk_position;
755 : : uint16 w;
756 : :
757 : 0 : w = reader->chunk_data[chunkoffset / BLOCKS_PER_ENTRY];
758 [ # # ]: 0 : if ((w & (1u << (chunkoffset % BLOCKS_PER_ENTRY))) != 0)
759 : 0 : blocks[blocks_found++] =
760 : 0 : chunkno * BLOCKS_PER_CHUNK + chunkoffset;
761 : 0 : ++reader->chunk_position;
762 : : }
763 : : }
764 : : else
765 : : {
766 : : /* Not in bitmap format, so each entry is a 2-byte offset. */
767 [ + + ]: 3231 : while (reader->chunk_position < chunk_size &&
768 [ + - ]: 2001 : blocks_found < nblocks)
769 : : {
770 : 2001 : blocks[blocks_found++] = chunkno * BLOCKS_PER_CHUNK
771 : 2001 : + reader->chunk_data[reader->chunk_position];
772 : 2001 : ++reader->chunk_position;
773 : : }
774 : : }
775 : : }
776 : :
777 : : /* We found enough blocks, so we're done. */
778 [ - + ]: 1958 : if (blocks_found >= nblocks)
779 : 0 : break;
780 : :
781 : : /*
782 : : * We didn't find enough blocks, so we must need the next chunk. If
783 : : * there are none left, though, then we're done anyway.
784 : : */
785 [ + + ]: 1958 : if (reader->consumed_chunks == reader->total_chunks)
786 : 1342 : break;
787 : :
788 : : /*
789 : : * Read data for next chunk and reset scan position to beginning of
790 : : * chunk. Note that the next chunk might be empty, in which case we
791 : : * consume the chunk without actually consuming any bytes from the
792 : : * underlying file.
793 : : */
794 : 616 : next_chunk_size = reader->chunk_size[reader->consumed_chunks];
795 [ + - ]: 616 : if (next_chunk_size > 0)
796 : 616 : BlockRefTableRead(reader, reader->chunk_data,
797 : : next_chunk_size * sizeof(uint16));
798 : 616 : ++reader->consumed_chunks;
799 : 616 : reader->chunk_position = 0;
800 : : }
801 : :
802 : 1342 : return blocks_found;
803 : : }
804 : :
805 : : /*
806 : : * Release memory used while reading a block reference table from a file.
807 : : */
808 : : void
809 : 30 : DestroyBlockRefTableReader(BlockRefTableReader *reader)
810 : : {
811 [ + + ]: 30 : if (reader->chunk_size != NULL)
812 : : {
813 : 21 : pfree(reader->chunk_size);
814 : 21 : reader->chunk_size = NULL;
815 : : }
816 : 30 : pfree(reader);
817 : 30 : }
818 : :
819 : : /*
820 : : * Prepare to write a block reference table file incrementally.
821 : : *
822 : : * Caller must be able to supply BlockRefTableEntry objects sorted in the
823 : : * appropriate order.
824 : : */
825 : : BlockRefTableWriter *
826 : 0 : CreateBlockRefTableWriter(io_callback_fn write_callback,
827 : : void *write_callback_arg)
828 : : {
829 : : BlockRefTableWriter *writer;
830 : 0 : uint32 magic = BLOCKREFTABLE_MAGIC;
831 : :
832 : : /* Prepare buffer and CRC check and save callbacks. */
833 : 0 : writer = palloc0_object(BlockRefTableWriter);
834 : 0 : writer->buffer.io_callback = write_callback;
835 : 0 : writer->buffer.io_callback_arg = write_callback_arg;
836 : 0 : INIT_CRC32C(writer->buffer.crc);
837 : :
838 : : /* Write magic number. */
839 : 0 : BlockRefTableWrite(&writer->buffer, &magic, sizeof(uint32));
840 : :
841 : 0 : return writer;
842 : : }
843 : :
844 : : /*
845 : : * Append one entry to a block reference table file.
846 : : *
847 : : * Note that entries must be written in the proper order, that is, sorted by
848 : : * tablespace, then database, then relfilenumber, then fork number. Caller
849 : : * is responsible for supplying data in the correct order. If that seems hard,
850 : : * use an in-memory BlockRefTable instead.
851 : : */
852 : : void
853 : 0 : BlockRefTableWriteEntry(BlockRefTableWriter *writer, BlockRefTableEntry *entry)
854 : : {
855 : : BlockRefTableSerializedEntry sentry;
856 : : unsigned j;
857 : :
858 : : /* Convert to serialized entry format. */
859 : 0 : sentry.rlocator = entry->key.rlocator;
860 : 0 : sentry.forknum = entry->key.forknum;
861 : 0 : sentry.limit_block = entry->limit_block;
862 : 0 : sentry.nchunks = entry->nchunks;
863 : :
864 : : /* Trim trailing zero entries. */
865 [ # # # # ]: 0 : while (sentry.nchunks > 0 && entry->chunk_usage[sentry.nchunks - 1] == 0)
866 : 0 : sentry.nchunks--;
867 : :
868 : : /* Write the serialized entry itself. */
869 : 0 : BlockRefTableWrite(&writer->buffer, &sentry,
870 : : sizeof(BlockRefTableSerializedEntry));
871 : :
872 : : /* Write the untruncated portion of the chunk length array. */
873 [ # # ]: 0 : if (sentry.nchunks != 0)
874 : 0 : BlockRefTableWrite(&writer->buffer, entry->chunk_usage,
875 : 0 : sentry.nchunks * sizeof(uint16));
876 : :
877 : : /* Write the contents of each chunk. */
878 [ # # ]: 0 : for (j = 0; j < entry->nchunks; ++j)
879 : : {
880 [ # # ]: 0 : if (entry->chunk_usage[j] == 0)
881 : 0 : continue;
882 : 0 : BlockRefTableWrite(&writer->buffer, entry->chunk_data[j],
883 : 0 : entry->chunk_usage[j] * sizeof(uint16));
884 : : }
885 : 0 : }
886 : :
887 : : /*
888 : : * Finalize an incremental write of a block reference table file.
889 : : */
890 : : void
891 : 0 : DestroyBlockRefTableWriter(BlockRefTableWriter *writer)
892 : : {
893 : 0 : BlockRefTableFileTerminate(&writer->buffer);
894 : 0 : pfree(writer);
895 : 0 : }
896 : :
897 : : /*
898 : : * Allocate a standalone BlockRefTableEntry.
899 : : *
900 : : * When we're manipulating a full in-memory BlockRefTable, the entries are
901 : : * part of the hash table and are allocated by simplehash. This routine is
902 : : * used by callers that want to write out a BlockRefTable to a file without
903 : : * needing to store the whole thing in memory at once.
904 : : *
905 : : * Entries allocated by this function can be manipulated using the functions
906 : : * BlockRefTableEntrySetLimitBlock and BlockRefTableEntryMarkBlockModified
907 : : * and then written using BlockRefTableWriteEntry and freed using
908 : : * BlockRefTableFreeEntry.
909 : : */
910 : : BlockRefTableEntry *
911 : 0 : CreateBlockRefTableEntry(RelFileLocator rlocator, ForkNumber forknum)
912 : : {
913 : 0 : BlockRefTableEntry *entry = palloc0_object(BlockRefTableEntry);
914 : :
915 : 0 : memcpy(&entry->key.rlocator, &rlocator, sizeof(RelFileLocator));
916 : 0 : entry->key.forknum = forknum;
917 : 0 : entry->limit_block = InvalidBlockNumber;
918 : :
919 : 0 : return entry;
920 : : }
921 : :
922 : : /*
923 : : * Update a BlockRefTableEntry with a new value for the "limit block" and
924 : : * forget any equal-or-higher-numbered modified blocks.
925 : : *
926 : : * The "limit block" is the shortest known length of the relation within the
927 : : * range of WAL records covered by this block reference table.
928 : : */
929 : : void
930 : 6 : BlockRefTableEntrySetLimitBlock(BlockRefTableEntry *entry,
931 : : BlockNumber limit_block)
932 : : {
933 : : unsigned chunkno;
934 : : unsigned limit_chunkno;
935 : : unsigned limit_chunkoffset;
936 : : BlockRefTableChunk limit_chunk;
937 : :
938 : : /* If we already have an equal or lower limit block, do nothing. */
939 [ + + ]: 6 : if (limit_block >= entry->limit_block)
940 : 4 : return;
941 : :
942 : : /* Record the new limit block value. */
943 : 2 : entry->limit_block = limit_block;
944 : :
945 : : /*
946 : : * Figure out which chunk would store the state of the new limit block,
947 : : * and which offset within that chunk.
948 : : */
949 : 2 : limit_chunkno = limit_block / BLOCKS_PER_CHUNK;
950 : 2 : limit_chunkoffset = limit_block % BLOCKS_PER_CHUNK;
951 : :
952 : : /*
953 : : * If the number of chunks is not large enough for any blocks with equal
954 : : * or higher block numbers to exist, then there is nothing further to do.
955 : : */
956 [ - + ]: 2 : if (limit_chunkno >= entry->nchunks)
957 : 0 : return;
958 : :
959 : : /* Discard entire contents of any higher-numbered chunks. */
960 [ + + ]: 32 : for (chunkno = limit_chunkno + 1; chunkno < entry->nchunks; ++chunkno)
961 : 30 : entry->chunk_usage[chunkno] = 0;
962 : :
963 : : /*
964 : : * Next, we need to discard any offsets within the chunk that would
965 : : * contain the limit_block. We must handle this differently depending on
966 : : * whether the chunk that would contain limit_block is a bitmap or an
967 : : * array of offsets.
968 : : */
969 : 2 : limit_chunk = entry->chunk_data[limit_chunkno];
970 [ - + ]: 2 : if (entry->chunk_usage[limit_chunkno] == MAX_ENTRIES_PER_CHUNK)
971 : : {
972 : : unsigned chunkoffset;
973 : :
974 : : /* It's a bitmap. Unset bits. */
975 [ # # ]: 0 : for (chunkoffset = limit_chunkoffset; chunkoffset < BLOCKS_PER_CHUNK;
976 : 0 : ++chunkoffset)
977 : 0 : limit_chunk[chunkoffset / BLOCKS_PER_ENTRY] &=
978 : 0 : ~(1 << (chunkoffset % BLOCKS_PER_ENTRY));
979 : : }
980 : : else
981 : : {
982 : : unsigned i,
983 : 2 : j = 0;
984 : :
985 : : /* It's an offset array. Filter out large offsets. */
986 [ + + ]: 4 : for (i = 0; i < entry->chunk_usage[limit_chunkno]; ++i)
987 : : {
988 : : Assert(j <= i);
989 [ + + ]: 2 : if (limit_chunk[i] < limit_chunkoffset)
990 : 1 : limit_chunk[j++] = limit_chunk[i];
991 : : }
992 : : Assert(j <= entry->chunk_usage[limit_chunkno]);
993 : 2 : entry->chunk_usage[limit_chunkno] = j;
994 : : }
995 : : }
996 : :
997 : : /*
998 : : * Mark a block in a given BlockRefTableEntry as known to have been modified.
999 : : */
1000 : : void
1001 : 77575 : BlockRefTableEntryMarkBlockModified(BlockRefTableEntry *entry,
1002 : : ForkNumber forknum,
1003 : : BlockNumber blknum)
1004 : : {
1005 : : unsigned chunkno;
1006 : : unsigned chunkoffset;
1007 : : unsigned i;
1008 : :
1009 : : /*
1010 : : * Which chunk should store the state of this block? And what is the
1011 : : * offset of this block relative to the start of that chunk?
1012 : : */
1013 : 77575 : chunkno = blknum / BLOCKS_PER_CHUNK;
1014 : 77575 : chunkoffset = blknum % BLOCKS_PER_CHUNK;
1015 : :
1016 : : /*
1017 : : * If 'nchunks' isn't big enough for us to be able to represent the state
1018 : : * of this block, we need to enlarge our arrays.
1019 : : */
1020 [ + + ]: 77575 : if (chunkno >= entry->nchunks)
1021 : : {
1022 : : unsigned max_chunks;
1023 : : unsigned extra_chunks;
1024 : :
1025 : : /*
1026 : : * New array size is a power of 2, at least 16, big enough so that
1027 : : * chunkno will be a valid array index.
1028 : : */
1029 : 1325 : max_chunks = Max(16, entry->nchunks);
1030 [ - + ]: 1325 : while (max_chunks < chunkno + 1)
1031 : 0 : max_chunks *= 2;
1032 : 1325 : extra_chunks = max_chunks - entry->nchunks;
1033 : :
1034 [ + - ]: 1325 : if (entry->nchunks == 0)
1035 : : {
1036 : 1325 : entry->chunk_size = palloc0_array(uint16, max_chunks);
1037 : 1325 : entry->chunk_usage = palloc0_array(uint16, max_chunks);
1038 : 1325 : entry->chunk_data = palloc0_array(BlockRefTableChunk, max_chunks);
1039 : : }
1040 : : else
1041 : : {
1042 : 0 : entry->chunk_size = repalloc(entry->chunk_size,
1043 : : sizeof(uint16) * max_chunks);
1044 : 0 : memset(&entry->chunk_size[entry->nchunks], 0,
1045 : : extra_chunks * sizeof(uint16));
1046 : 0 : entry->chunk_usage = repalloc(entry->chunk_usage,
1047 : : sizeof(uint16) * max_chunks);
1048 : 0 : memset(&entry->chunk_usage[entry->nchunks], 0,
1049 : : extra_chunks * sizeof(uint16));
1050 : 0 : entry->chunk_data = repalloc(entry->chunk_data,
1051 : : sizeof(BlockRefTableChunk) * max_chunks);
1052 : 0 : memset(&entry->chunk_data[entry->nchunks], 0,
1053 : : extra_chunks * sizeof(BlockRefTableChunk));
1054 : : }
1055 : 1325 : entry->nchunks = max_chunks;
1056 : : }
1057 : :
1058 : : /*
1059 : : * If the chunk that covers this block number doesn't exist yet, create it
1060 : : * as an array and add the appropriate offset to it. We make it pretty
1061 : : * small initially, because there might only be 1 or a few block
1062 : : * references in this chunk and we don't want to use up too much memory.
1063 : : */
1064 [ + + ]: 77575 : if (entry->chunk_size[chunkno] == 0)
1065 : : {
1066 : 2650 : entry->chunk_data[chunkno] =
1067 : 1325 : palloc_array(uint16, INITIAL_ENTRIES_PER_CHUNK);
1068 : 1325 : entry->chunk_size[chunkno] = INITIAL_ENTRIES_PER_CHUNK;
1069 : 1325 : entry->chunk_data[chunkno][0] = chunkoffset;
1070 : 1325 : entry->chunk_usage[chunkno] = 1;
1071 : 1325 : return;
1072 : : }
1073 : :
1074 : : /*
1075 : : * If the number of entries in this chunk is already maximum, it must be a
1076 : : * bitmap. Just set the appropriate bit.
1077 : : */
1078 [ - + ]: 76250 : if (entry->chunk_usage[chunkno] == MAX_ENTRIES_PER_CHUNK)
1079 : : {
1080 : 0 : BlockRefTableChunk chunk = entry->chunk_data[chunkno];
1081 : :
1082 : 0 : chunk[chunkoffset / BLOCKS_PER_ENTRY] |=
1083 : 0 : 1 << (chunkoffset % BLOCKS_PER_ENTRY);
1084 : 0 : return;
1085 : : }
1086 : :
1087 : : /*
1088 : : * There is an existing chunk and it's in array format. Let's find out
1089 : : * whether it already has an entry for this block. If so, we do not need
1090 : : * to do anything.
1091 : : */
1092 [ + + ]: 482227 : for (i = 0; i < entry->chunk_usage[chunkno]; ++i)
1093 : : {
1094 [ + + ]: 479410 : if (entry->chunk_data[chunkno][i] == chunkoffset)
1095 : 73433 : return;
1096 : : }
1097 : :
1098 : : /*
1099 : : * If the number of entries currently used is one less than the maximum,
1100 : : * it's time to convert to bitmap format.
1101 : : */
1102 [ - + ]: 2817 : if (entry->chunk_usage[chunkno] == MAX_ENTRIES_PER_CHUNK - 1)
1103 : : {
1104 : : BlockRefTableChunk newchunk;
1105 : : unsigned j;
1106 : :
1107 : : /* Allocate a new chunk. */
1108 : 0 : newchunk = palloc0(MAX_ENTRIES_PER_CHUNK * sizeof(uint16));
1109 : :
1110 : : /* Set the bit for each existing entry. */
1111 [ # # ]: 0 : for (j = 0; j < entry->chunk_usage[chunkno]; ++j)
1112 : : {
1113 : 0 : unsigned coff = entry->chunk_data[chunkno][j];
1114 : :
1115 : 0 : newchunk[coff / BLOCKS_PER_ENTRY] |=
1116 : 0 : 1 << (coff % BLOCKS_PER_ENTRY);
1117 : : }
1118 : :
1119 : : /* Set the bit for the new entry. */
1120 : 0 : newchunk[chunkoffset / BLOCKS_PER_ENTRY] |=
1121 : 0 : 1 << (chunkoffset % BLOCKS_PER_ENTRY);
1122 : :
1123 : : /* Swap the new chunk into place and update metadata. */
1124 : 0 : pfree(entry->chunk_data[chunkno]);
1125 : 0 : entry->chunk_data[chunkno] = newchunk;
1126 : 0 : entry->chunk_size[chunkno] = MAX_ENTRIES_PER_CHUNK;
1127 : 0 : entry->chunk_usage[chunkno] = MAX_ENTRIES_PER_CHUNK;
1128 : 0 : return;
1129 : : }
1130 : :
1131 : : /*
1132 : : * OK, we currently have an array, and we don't need to convert to a
1133 : : * bitmap, but we do need to add a new element. If there's not enough
1134 : : * room, we'll have to expand the array.
1135 : : */
1136 [ + + ]: 2817 : if (entry->chunk_usage[chunkno] == entry->chunk_size[chunkno])
1137 : : {
1138 : 60 : unsigned newsize = entry->chunk_size[chunkno] * 2;
1139 : :
1140 : : Assert(newsize <= MAX_ENTRIES_PER_CHUNK);
1141 : 60 : entry->chunk_data[chunkno] = repalloc(entry->chunk_data[chunkno],
1142 : : newsize * sizeof(uint16));
1143 : 60 : entry->chunk_size[chunkno] = newsize;
1144 : : }
1145 : :
1146 : : /* Now we can add the new entry. */
1147 : 2817 : entry->chunk_data[chunkno][entry->chunk_usage[chunkno]] =
1148 : : chunkoffset;
1149 : 2817 : entry->chunk_usage[chunkno]++;
1150 : : }
1151 : :
1152 : : /*
1153 : : * Release memory for a BlockRefTableEntry that was created by
1154 : : * CreateBlockRefTableEntry.
1155 : : */
1156 : : void
1157 : 0 : BlockRefTableFreeEntry(BlockRefTableEntry *entry)
1158 : : {
1159 [ # # ]: 0 : if (entry->chunk_size != NULL)
1160 : : {
1161 : 0 : pfree(entry->chunk_size);
1162 : 0 : entry->chunk_size = NULL;
1163 : : }
1164 : :
1165 [ # # ]: 0 : if (entry->chunk_usage != NULL)
1166 : : {
1167 : 0 : pfree(entry->chunk_usage);
1168 : 0 : entry->chunk_usage = NULL;
1169 : : }
1170 : :
1171 [ # # ]: 0 : if (entry->chunk_data != NULL)
1172 : : {
1173 : 0 : pfree(entry->chunk_data);
1174 : 0 : entry->chunk_data = NULL;
1175 : : }
1176 : :
1177 : 0 : pfree(entry);
1178 : 0 : }
1179 : :
1180 : : /*
1181 : : * Comparator for BlockRefTableSerializedEntry objects.
1182 : : *
1183 : : * We make the tablespace OID the first column of the sort key to match
1184 : : * the on-disk tree structure.
1185 : : */
1186 : : static int
1187 : 7350 : BlockRefTableComparator(const void *a, const void *b)
1188 : : {
1189 : 7350 : const BlockRefTableSerializedEntry *sa = a;
1190 : 7350 : const BlockRefTableSerializedEntry *sb = b;
1191 : :
1192 [ + + ]: 7350 : if (sa->rlocator.spcOid > sb->rlocator.spcOid)
1193 : 210 : return 1;
1194 [ + + ]: 7140 : if (sa->rlocator.spcOid < sb->rlocator.spcOid)
1195 : 195 : return -1;
1196 : :
1197 [ - + ]: 6945 : if (sa->rlocator.dbOid > sb->rlocator.dbOid)
1198 : 0 : return 1;
1199 [ - + ]: 6945 : if (sa->rlocator.dbOid < sb->rlocator.dbOid)
1200 : 0 : return -1;
1201 : :
1202 [ + + ]: 6945 : if (sa->rlocator.relNumber > sb->rlocator.relNumber)
1203 : 3342 : return 1;
1204 [ + + ]: 3603 : if (sa->rlocator.relNumber < sb->rlocator.relNumber)
1205 : 3409 : return -1;
1206 : :
1207 [ + + ]: 194 : if (sa->forknum > sb->forknum)
1208 : 87 : return 1;
1209 [ + - ]: 107 : if (sa->forknum < sb->forknum)
1210 : 107 : return -1;
1211 : :
1212 : 0 : return 0;
1213 : : }
1214 : :
1215 : : /*
1216 : : * Flush any buffered data out of a BlockRefTableBuffer.
1217 : : */
1218 : : static void
1219 : 28 : BlockRefTableFlush(BlockRefTableBuffer *buffer)
1220 : : {
1221 : 28 : buffer->io_callback(buffer->io_callback_arg, buffer->data, buffer->used);
1222 : 28 : buffer->used = 0;
1223 : 28 : }
1224 : :
1225 : : /*
1226 : : * Read data from a BlockRefTableBuffer, and update the running CRC
1227 : : * calculation for the returned data (but not any data that we may have
1228 : : * buffered but not yet actually returned).
1229 : : */
1230 : : static void
1231 : 2162 : BlockRefTableRead(BlockRefTableReader *reader, void *data, size_t length)
1232 : : {
1233 : 2162 : BlockRefTableBuffer *buffer = &reader->buffer;
1234 : :
1235 : : /* Loop until read is fully satisfied. */
1236 [ + + ]: 4242 : while (length > 0)
1237 : : {
1238 [ + + ]: 2080 : if (buffer->cursor < buffer->used)
1239 : : {
1240 : : /*
1241 : : * If any buffered data is available, use that to satisfy as much
1242 : : * of the request as possible.
1243 : : */
1244 : 2050 : size_t bytes_to_copy = Min(length, buffer->used - buffer->cursor);
1245 : :
1246 : 2050 : memcpy(data, &buffer->data[buffer->cursor], bytes_to_copy);
1247 : 2050 : COMP_CRC32C(buffer->crc, &buffer->data[buffer->cursor],
1248 : : bytes_to_copy);
1249 : 2050 : buffer->cursor += bytes_to_copy;
1250 : 2050 : data = ((char *) data) + bytes_to_copy;
1251 : 2050 : length -= bytes_to_copy;
1252 : : }
1253 [ - + ]: 30 : else if (length >= BUFSIZE)
1254 : : {
1255 : : /*
1256 : : * If the request length is long, read directly into caller's
1257 : : * buffer.
1258 : : */
1259 : : size_t bytes_read;
1260 : :
1261 : 0 : bytes_read = buffer->io_callback(buffer->io_callback_arg,
1262 : : data, length);
1263 : 0 : COMP_CRC32C(buffer->crc, data, bytes_read);
1264 : 0 : data = ((char *) data) + bytes_read;
1265 : 0 : length -= bytes_read;
1266 : :
1267 : : /* If we didn't get anything, that's bad. */
1268 [ # # ]: 0 : if (bytes_read == 0)
1269 : 0 : reader->error_callback(reader->error_callback_arg,
1270 : : "file \"%s\" ends unexpectedly",
1271 : : reader->error_filename);
1272 : : }
1273 : : else
1274 : : {
1275 : : /*
1276 : : * Refill our buffer.
1277 : : */
1278 : 60 : buffer->used = buffer->io_callback(buffer->io_callback_arg,
1279 : 30 : buffer->data, BUFSIZE);
1280 : 30 : buffer->cursor = 0;
1281 : :
1282 : : /* If we didn't get anything, that's bad. */
1283 [ - + ]: 30 : if (buffer->used == 0)
1284 : 0 : reader->error_callback(reader->error_callback_arg,
1285 : : "file \"%s\" ends unexpectedly",
1286 : : reader->error_filename);
1287 : : }
1288 : : }
1289 : 2162 : }
1290 : :
1291 : : /*
1292 : : * Supply data to a BlockRefTableBuffer for write to the underlying File,
1293 : : * and update the running CRC calculation for that data.
1294 : : */
1295 : : static void
1296 : 3234 : BlockRefTableWrite(BlockRefTableBuffer *buffer, void *data, size_t length)
1297 : : {
1298 : : /* Update running CRC calculation. */
1299 : 3234 : COMP_CRC32C(buffer->crc, data, length);
1300 : :
1301 : : /* If the new data can't fit into the buffer, flush the buffer. */
1302 [ - + ]: 3234 : if (buffer->used + length > BUFSIZE)
1303 : : {
1304 : 0 : buffer->io_callback(buffer->io_callback_arg, buffer->data,
1305 : : buffer->used);
1306 : 0 : buffer->used = 0;
1307 : : }
1308 : :
1309 : : /* If the new data would fill the buffer, or more, write it directly. */
1310 [ - + ]: 3234 : if (length >= BUFSIZE)
1311 : : {
1312 : 0 : buffer->io_callback(buffer->io_callback_arg, data, length);
1313 : 0 : return;
1314 : : }
1315 : :
1316 : : /* Otherwise, copy the new data into the buffer. */
1317 : 3234 : memcpy(&buffer->data[buffer->used], data, length);
1318 : 3234 : buffer->used += length;
1319 : : Assert(buffer->used <= BUFSIZE);
1320 : : }
1321 : :
1322 : : /*
1323 : : * Generate the sentinel and CRC required at the end of a block reference
1324 : : * table file and flush them out of our internal buffer.
1325 : : */
1326 : : static void
1327 : 28 : BlockRefTableFileTerminate(BlockRefTableBuffer *buffer)
1328 : : {
1329 : 28 : BlockRefTableSerializedEntry zentry = {0};
1330 : : pg_crc32c crc;
1331 : :
1332 : : /* Write a sentinel indicating that there are no more entries. */
1333 : 28 : BlockRefTableWrite(buffer, &zentry,
1334 : : sizeof(BlockRefTableSerializedEntry));
1335 : :
1336 : : /*
1337 : : * Writing the checksum will perturb the ongoing checksum calculation, so
1338 : : * copy the state first and finalize the computation using the copy.
1339 : : */
1340 : 28 : crc = buffer->crc;
1341 : 28 : FIN_CRC32C(crc);
1342 : 28 : BlockRefTableWrite(buffer, &crc, sizeof(pg_crc32c));
1343 : :
1344 : : /* Flush any leftover data out of our buffer. */
1345 : 28 : BlockRefTableFlush(buffer);
1346 : 28 : }
|
