Loading...
Searching...
No Matches
md.c File Reference
#include "postgres.h"#include <limits.h>#include <unistd.h>#include <fcntl.h>#include <sys/file.h>#include "access/xlogutils.h"#include "commands/tablespace.h"#include "common/file_utils.h"#include "miscadmin.h"#include "pg_trace.h"#include "pgstat.h"#include "storage/aio.h"#include "storage/bufmgr.h"#include "storage/fd.h"#include "storage/md.h"#include "storage/relfilelocator.h"#include "storage/smgr.h"#include "storage/sync.h"#include "utils/memutils.h"
Include dependency graph for md.c:
Go to the source code of this file.
Data Structures | |
| struct | _MdfdVec |
| struct | MdPathStr |
Macros | |
| #define | INIT_MD_FILETAG(a, xx_rlocator, xx_forknum, xx_segno) |
| #define | EXTENSION_FAIL (1 << 0) |
| #define | EXTENSION_RETURN_NULL (1 << 1) |
| #define | EXTENSION_CREATE (1 << 2) |
| #define | EXTENSION_CREATE_RECOVERY (1 << 3) |
| #define | EXTENSION_DONT_OPEN (1 << 5) |
| #define | SEGMENT_CHARS OIDCHARS |
| #define | MD_PATH_STR_MAXLEN |
Typedefs | |
| typedef struct _MdfdVec | MdfdVec |
| typedef struct MdPathStr | MdPathStr |
Variables | |
| static MemoryContext | MdCxt |
| const PgAioHandleCallbacks | aio_md_readv_cb |
Macro Definition Documentation
◆ EXTENSION_CREATE
◆ EXTENSION_CREATE_RECOVERY
◆ EXTENSION_DONT_OPEN
◆ EXTENSION_FAIL
◆ EXTENSION_RETURN_NULL
◆ INIT_MD_FILETAG
| #define INIT_MD_FILETAG | ( | a, | |
| xx_rlocator, | |||
| xx_forknum, | |||
| xx_segno | |||
| ) |
Value:
( \
(a).handler = SYNC_HANDLER_MD, \
(a).rlocator = (xx_rlocator), \
(a).forknum = (xx_forknum), \
)
Definition at line 101 of file md.c.
138{
140} MdPathStr;
141
142
143/* local routines */
148 MdfdVec *seg);
150 BlockNumber segno);
152 BlockNumber segno);
154 ForkNumber forknum,
157 BlockNumber segno);
163 MdfdVec *seg);
164
167
170 .report = md_readv_report,
171};
172
173
174static inline int
176{
178
180 flags |= PG_O_DIRECT;
181
182 return flags;
183}
184
185/*
186 * mdinit() -- Initialize private state for magnetic disk storage manager.
187 */
188void
190{
192 "MdSmgr",
193 ALLOCSET_DEFAULT_SIZES);
194}
195
196/*
197 * mdexists() -- Does the physical file exist?
198 *
199 * Note: this will return true for lingering files, with pending deletions
200 */
201bool
203{
204 /*
205 * Close it first, to ensure that we notice if the fork has been unlinked
206 * since we opened it. As an optimization, we can skip that in recovery,
207 * which already closes relations when dropping them.
208 */
211
213}
214
215/*
216 * mdcreate() -- Create a new relation on magnetic disk.
217 *
218 * If isRedo is true, it's okay for the relation to exist already.
219 */
220void
222{
224 RelPathStr path;
226
228 return; /* created and opened already... */
229
231
232 /*
233 * We may be using the target table space for the first time in this
234 * database, so create a per-database subdirectory if needed.
235 *
236 * XXX this is a fairly ugly violation of module layering, but this seems
237 * to be the best place to put the check. Maybe TablespaceCreateDbspace
238 * should be here and not in commands/tablespace.c? But that would imply
239 * importing a lot of stuff that smgr.c oughtn't know, either.
240 */
242 reln->smgr_rlocator.locator.dbOid,
243 isRedo);
244
246
248
250 {
252
256 {
257 /* be sure to report the error reported by create, not open */
260 (errcode_for_file_access(),
262 }
263 }
264
268 mdfd->mdfd_segno = 0;
269
272}
273
274/*
275 * mdunlink() -- Unlink a relation.
276 *
277 * Note that we're passed a RelFileLocatorBackend --- by the time this is called,
278 * there won't be an SMgrRelation hashtable entry anymore.
279 *
280 * forknum can be a fork number to delete a specific fork, or InvalidForkNumber
281 * to delete all forks.
282 *
283 * For regular relations, we don't unlink the first segment file of the rel,
284 * but just truncate it to zero length, and record a request to unlink it after
285 * the next checkpoint. Additional segments can be unlinked immediately,
286 * however. Leaving the empty file in place prevents that relfilenumber
287 * from being reused. The scenario this protects us from is:
288 * 1. We delete a relation (and commit, and actually remove its file).
289 * 2. We create a new relation, which by chance gets the same relfilenumber as
290 * the just-deleted one (OIDs must've wrapped around for that to happen).
291 * 3. We crash before another checkpoint occurs.
292 * During replay, we would delete the file and then recreate it, which is fine
293 * if the contents of the file were repopulated by subsequent WAL entries.
294 * But if we didn't WAL-log insertions, but instead relied on fsyncing the
295 * file after populating it (as we do at wal_level=minimal), the contents of
296 * the file would be lost forever. By leaving the empty file until after the
297 * next checkpoint, we prevent reassignment of the relfilenumber until it's
298 * safe, because relfilenumber assignment skips over any existing file.
299 *
300 * Additional segments, if any, are truncated and then unlinked. The reason
301 * for truncating is that other backends may still hold open FDs for these at
302 * the smgr level, so that the kernel can't remove the file yet. We want to
303 * reclaim the disk space right away despite that.
304 *
305 * We do not need to go through this dance for temp relations, though, because
306 * we never make WAL entries for temp rels, and so a temp rel poses no threat
307 * to the health of a regular rel that has taken over its relfilenumber.
308 * The fact that temp rels and regular rels have different file naming
309 * patterns provides additional safety. Other backends shouldn't have open
310 * FDs for them, either.
311 *
312 * We also don't do it while performing a binary upgrade. There is no reuse
313 * hazard in that case, since after a crash or even a simple ERROR, the
314 * upgrade fails and the whole cluster must be recreated from scratch.
315 * Furthermore, it is important to remove the files from disk immediately,
316 * because we may be about to reuse the same relfilenumber.
317 *
318 * All the above applies only to the relation's main fork; other forks can
319 * just be removed immediately, since they are not needed to prevent the
320 * relfilenumber from being recycled. Also, we do not carefully
321 * track whether other forks have been created or not, but just attempt to
322 * unlink them unconditionally; so we should never complain about ENOENT.
323 *
324 * If isRedo is true, it's unsurprising for the relation to be already gone.
325 * Also, we should remove the file immediately instead of queuing a request
326 * for later, since during redo there's no possibility of creating a
327 * conflicting relation.
328 *
329 * Note: we currently just never warn about ENOENT at all. We could warn in
330 * the main-fork, non-isRedo case, but it doesn't seem worth the trouble.
331 *
332 * Note: any failure should be reported as WARNING not ERROR, because
333 * we are usually not in a transaction anymore when this is called.
334 */
335void
337{
338 /* Now do the per-fork work */
340 {
343 }
344 else
346}
347
348/*
349 * Truncate a file to release disk space.
350 */
351static int
353{
355 int ret;
356
357 ret = pg_truncate(path, 0);
358
359 /* Log a warning here to avoid repetition in callers. */
361 {
364 (errcode_for_file_access(),
367 }
368
369 return ret;
370}
371
372static void
374{
375 RelPathStr path;
376 int ret;
378
379 path = relpath(rlocator, forknum);
380
381 /*
382 * Truncate and then unlink the first segment, or just register a request
383 * to unlink it later, as described in the comments for mdunlink().
384 */
386 RelFileLocatorBackendIsTemp(rlocator))
387 {
389 {
390 /* Prevent other backends' fds from holding on to the disk space */
392
393 /* Forget any pending sync requests for the first segment */
397 }
398 else
399 ret = 0;
400
401 /* Next unlink the file, unless it was already found to be missing */
403 {
406 {
409 (errcode_for_file_access(),
412 }
413 }
414 }
415 else
416 {
417 /* Prevent other backends' fds from holding on to the disk space */
419
420 /* Register request to unlink first segment later */
424 }
425
426 /*
427 * Delete any additional segments.
428 *
429 * Note that because we loop until getting ENOENT, we will correctly
430 * remove all inactive segments as well as active ones. Ideally we'd
431 * continue the loop until getting exactly that errno, but that risks an
432 * infinite loop if the problem is directory-wide (for instance, if we
433 * suddenly can't read the data directory itself). We compromise by
434 * continuing after a non-ENOENT truncate error, but stopping after any
435 * unlink error. If there is indeed a directory-wide problem, additional
436 * unlink attempts wouldn't work anyway.
437 */
439 {
441 BlockNumber segno;
442
443 for (segno = 1;; segno++)
444 {
446
448 {
449 /*
450 * Prevent other backends' fds from holding on to the disk
451 * space. We're done if we see ENOENT, though.
452 */
454 break;
455
456 /*
457 * Forget any pending sync requests for this segment before we
458 * try to unlink.
459 */
460 register_forget_request(rlocator, forknum, segno);
461 }
462
464 {
465 /* ENOENT is expected after the last segment... */
468 (errcode_for_file_access(),
470 break;
471 }
472 }
473 }
474}
475
476/*
477 * mdextend() -- Add a block to the specified relation.
478 *
479 * The semantics are nearly the same as mdwrite(): write at the
480 * specified position. However, this is to be used for the case of
481 * extending a relation (i.e., blocknum is at or beyond the current
482 * EOF). Note that we assume writing a block beyond current EOF
483 * causes intervening file space to become filled with zeroes.
484 */
485void
488{
489 pgoff_t seekpos;
490 int nbytes;
491 MdfdVec *v;
492
493 /* If this build supports direct I/O, the buffer must be I/O aligned. */
496
497 /* This assert is too expensive to have on normally ... */
498#ifdef CHECK_WRITE_VS_EXTEND
500#endif
501
502 /*
503 * If a relation manages to grow to 2^32-1 blocks, refuse to extend it any
504 * more --- we mustn't create a block whose number actually is
505 * InvalidBlockNumber. (Note that this failure should be unreachable
506 * because of upstream checks in bufmgr.c.)
507 */
513 InvalidBlockNumber)));
514
516
518
520
521 if ((nbytes = FileWrite(v->mdfd_vfd, buffer, BLCKSZ, seekpos, WAIT_EVENT_DATA_FILE_EXTEND)) != BLCKSZ)
522 {
523 if (nbytes < 0)
525 (errcode_for_file_access(),
529 /* short write: complain appropriately */
534 nbytes, BLCKSZ, blocknum),
536 }
537
540
542}
543
544/*
545 * mdzeroextend() -- Add new zeroed out blocks to the specified relation.
546 *
547 * Similar to mdextend(), except the relation can be extended by multiple
548 * blocks at once and the added blocks will be filled with zeroes.
549 */
550void
553{
554 MdfdVec *v;
557
558 Assert(nblocks > 0);
559
560 /* This assert is too expensive to have on normally ... */
561#ifdef CHECK_WRITE_VS_EXTEND
563#endif
564
565 /*
566 * If a relation manages to grow to 2^32-1 blocks, refuse to extend it any
567 * more --- we mustn't create a block whose number actually is
568 * InvalidBlockNumber or larger.
569 */
575 InvalidBlockNumber)));
576
578 {
582
585 else
587
589
592
593 /*
594 * If available and useful, use posix_fallocate() (via
595 * FileFallocate()) to extend the relation. That's often more
596 * efficient than using write(), as it commonly won't cause the kernel
597 * to allocate page cache space for the extended pages.
598 *
599 * However, we don't use FileFallocate() for small extensions, as it
600 * defeats delayed allocation on some filesystems. Not clear where
601 * that decision should be made though? For now just use a cutoff of
602 * 8, anything between 4 and 8 worked OK in some local testing.
603 */
605 {
606 int ret;
607
611 if (ret != 0)
612 {
614 errcode_for_file_access(),
618 }
619 }
620 else
621 {
622 int ret;
623
624 /*
625 * Even if we don't want to use fallocate, we can still extend a
626 * bit more efficiently than writing each 8kB block individually.
627 * pg_pwrite_zeros() (via FileZero()) uses pg_pwritev_with_retry()
628 * to avoid multiple writes or needing a zeroed buffer for the
629 * whole length of the extension.
630 */
634 if (ret < 0)
636 errcode_for_file_access(),
640 }
641
644
646
649 }
650}
651
652/*
653 * mdopenfork() -- Open one fork of the specified relation.
654 *
655 * Note we only open the first segment, when there are multiple segments.
656 *
657 * If first segment is not present, either ereport or return NULL according
658 * to "behavior". We treat EXTENSION_CREATE the same as EXTENSION_FAIL;
659 * EXTENSION_CREATE means it's OK to extend an existing relation, not to
660 * invent one out of whole cloth.
661 */
664{
666 RelPathStr path;
668
669 /* No work if already open */
672
674
676
678 {
683 (errcode_for_file_access(),
685 }
686
690 mdfd->mdfd_segno = 0;
691
693
695}
696
697/*
698 * mdopen() -- Initialize newly-opened relation.
699 */
700void
702{
703 /* mark it not open */
705 reln->md_num_open_segs[forknum] = 0;
706}
707
708/*
709 * mdclose() -- Close the specified relation, if it isn't closed already.
710 */
711void
713{
715
716 /* No work if already closed */
718 return;
719
720 /* close segments starting from the end */
722 {
724
727 nopensegs--;
728 }
729}
730
731/*
732 * mdprefetch() -- Initiate asynchronous read of the specified blocks of a relation
733 */
734bool
736 int nblocks)
737{
738#ifdef USE_PREFETCH
739
741
743 return false;
744
745 while (nblocks > 0)
746 {
747 pgoff_t seekpos;
748 MdfdVec *v;
750
754 return false;
755
757
759
760 nblocks_this_segment =
761 Min(nblocks,
763
766
767 blocknum += nblocks_this_segment;
768 nblocks -= nblocks_this_segment;
769 }
770#endif /* USE_PREFETCH */
771
772 return true;
773}
774
775/*
776 * Convert an array of buffer address into an array of iovec objects, and
777 * return the number that were required. 'iov' must have enough space for up
778 * to 'nblocks' elements, but the number used may be less depending on
779 * merging. In the case of a run of fully contiguous buffers, a single iovec
780 * will be populated that can be handled as a plain non-vectored I/O.
781 */
782static int
784{
787
788 Assert(nblocks >= 1);
789
790 /* If this build supports direct I/O, buffers must be I/O aligned. */
792 {
796 }
797
798 /* Start the first iovec off with the first buffer. */
800 iovp->iov_base = buffers[0];
802 iovcnt = 1;
803
804 /* Try to merge the rest. */
806 {
808
810 {
811 /* Contiguous with the last iovec. */
813 }
814 else
815 {
816 /* Need a new iovec. */
817 iovp++;
818 iovp->iov_base = buffer;
820 iovcnt++;
821 }
822 }
823
825}
826
827/*
828 * mdmaxcombine() -- Return the maximum number of total blocks that can be
829 * combined with an IO starting at blocknum.
830 */
831uint32
833 BlockNumber blocknum)
834{
835 BlockNumber segoff;
836
838
840}
841
842/*
843 * mdreadv() -- Read the specified blocks from a relation.
844 */
845void
848{
849 while (nblocks > 0)
850 {
853 pgoff_t seekpos;
854 int nbytes;
855 MdfdVec *v;
859
862
864
866
867 nblocks_this_segment =
868 Min(nblocks,
871
874
877 transferred_this_segment = 0;
878
879 /*
880 * Inner loop to continue after a short read. We'll keep going until
881 * we hit EOF rather than assuming that a short read means we hit the
882 * end.
883 */
884 for (;;)
885 {
886 TRACE_POSTGRESQL_SMGR_MD_READ_START(forknum, blocknum,
887 reln->smgr_rlocator.locator.spcOid,
888 reln->smgr_rlocator.locator.dbOid,
889 reln->smgr_rlocator.locator.relNumber,
890 reln->smgr_rlocator.backend);
893 TRACE_POSTGRESQL_SMGR_MD_READ_DONE(forknum, blocknum,
894 reln->smgr_rlocator.locator.spcOid,
895 reln->smgr_rlocator.locator.dbOid,
896 reln->smgr_rlocator.locator.relNumber,
897 reln->smgr_rlocator.backend,
898 nbytes,
900
901#ifdef SIMULATE_SHORT_READ
902 nbytes = Min(nbytes, 4096);
903#endif
904
905 if (nbytes < 0)
907 (errcode_for_file_access(),
909 blocknum,
910 blocknum + nblocks_this_segment - 1,
912
913 if (nbytes == 0)
914 {
915 /*
916 * We are at or past EOF, or we read a partial block at EOF.
917 * Normally this is an error; upper levels should never try to
918 * read a nonexistent block. However, if zero_damaged_pages
919 * is ON or we are InRecovery, we should instead return zeroes
920 * without complaining. This allows, for example, the case of
921 * trying to update a block that was later truncated away.
922 *
923 * NB: We think that this codepath is unreachable in recovery
924 * and incomplete with zero_damaged_pages, as missing segments
925 * are not created. Putting blocks into the buffer-pool that
926 * do not exist on disk is rather problematic, as it will not
927 * be found by scans that rely on smgrnblocks(), as they are
928 * beyond EOF. It also can cause weird problems with relation
929 * extension, as relation extension does not expect blocks
930 * beyond EOF to exist.
931 *
932 * Therefore we do not want to copy the logic into
933 * mdstartreadv(), where it would have to be more complicated
934 * due to potential differences in the zero_damaged_pages
935 * setting between the definer and completor of IO.
936 *
937 * For PG 18, we are putting an Assert(false) in mdreadv()
938 * (triggering failures in assertion-enabled builds, but
939 * continuing to work in production builds). Afterwards we
940 * plan to remove this code entirely.
941 */
943 {
945
948 ++i)
950 break;
951 }
952 else
956 blocknum,
957 blocknum + nblocks_this_segment - 1,
960 size_this_segment)));
961 }
962
963 /* One loop should usually be enough. */
964 transferred_this_segment += nbytes;
967 break;
968
969 /* Adjust position and vectors after a short read. */
970 seekpos += nbytes;
972 }
973
974 nblocks -= nblocks_this_segment;
975 buffers += nblocks_this_segment;
976 blocknum += nblocks_this_segment;
977 }
978}
979
980/*
981 * mdstartreadv() -- Asynchronous version of mdreadv().
982 */
983void
987{
988 pgoff_t seekpos;
989 MdfdVec *v;
993 int ret;
994
997
999
1001
1002 nblocks_this_segment =
1003 Min(nblocks,
1005
1008
1010
1012
1014
1016
1019
1021 reln,
1022 forknum,
1023 blocknum,
1024 nblocks,
1025 false);
1027
1029 if (ret != 0)
1031 (errcode_for_file_access(),
1033 blocknum,
1034 blocknum + nblocks_this_segment - 1,
1036
1037 /*
1038 * The error checks corresponding to the post-read checks in mdreadv() are
1039 * in md_readv_complete().
1040 *
1041 * However we chose, at least for now, to not implement the
1042 * zero_damaged_pages logic present in mdreadv(). As outlined in mdreadv()
1043 * that logic is rather problematic, and we want to get rid of it. Here
1044 * equivalent logic would have to be more complicated due to potential
1045 * differences in the zero_damaged_pages setting between the definer and
1046 * completor of IO.
1047 */
1048}
1049
1050/*
1051 * mdwritev() -- Write the supplied blocks at the appropriate location.
1052 *
1053 * This is to be used only for updating already-existing blocks of a
1054 * relation (ie, those before the current EOF). To extend a relation,
1055 * use mdextend().
1056 */
1057void
1060{
1061 /* This assert is too expensive to have on normally ... */
1062#ifdef CHECK_WRITE_VS_EXTEND
1064#endif
1065
1066 while (nblocks > 0)
1067 {
1070 pgoff_t seekpos;
1071 int nbytes;
1072 MdfdVec *v;
1076
1079
1081
1083
1084 nblocks_this_segment =
1085 Min(nblocks,
1088
1091
1094 transferred_this_segment = 0;
1095
1096 /*
1097 * Inner loop to continue after a short write. If the reason is that
1098 * we're out of disk space, a future attempt should get an ENOSPC
1099 * error from the kernel.
1100 */
1101 for (;;)
1102 {
1103 TRACE_POSTGRESQL_SMGR_MD_WRITE_START(forknum, blocknum,
1104 reln->smgr_rlocator.locator.spcOid,
1105 reln->smgr_rlocator.locator.dbOid,
1106 reln->smgr_rlocator.locator.relNumber,
1107 reln->smgr_rlocator.backend);
1109 WAIT_EVENT_DATA_FILE_WRITE);
1110 TRACE_POSTGRESQL_SMGR_MD_WRITE_DONE(forknum, blocknum,
1111 reln->smgr_rlocator.locator.spcOid,
1112 reln->smgr_rlocator.locator.dbOid,
1113 reln->smgr_rlocator.locator.relNumber,
1114 reln->smgr_rlocator.backend,
1115 nbytes,
1117
1118#ifdef SIMULATE_SHORT_WRITE
1119 nbytes = Min(nbytes, 4096);
1120#endif
1121
1122 if (nbytes < 0)
1123 {
1125
1127 (errcode_for_file_access(),
1129 blocknum,
1130 blocknum + nblocks_this_segment - 1,
1133 }
1134
1135 /* One loop should usually be enough. */
1136 transferred_this_segment += nbytes;
1139 break;
1140
1141 /* Adjust position and iovecs after a short write. */
1142 seekpos += nbytes;
1144 }
1145
1148
1149 nblocks -= nblocks_this_segment;
1150 buffers += nblocks_this_segment;
1151 blocknum += nblocks_this_segment;
1152 }
1153}
1154
1155
1156/*
1157 * mdwriteback() -- Tell the kernel to write pages back to storage.
1158 *
1159 * This accepts a range of blocks because flushing several pages at once is
1160 * considerably more efficient than doing so individually.
1161 */
1162void
1165{
1167
1168 /*
1169 * Issue flush requests in as few requests as possible; have to split at
1170 * segment boundaries though, since those are actually separate files.
1171 */
1172 while (nblocks > 0)
1173 {
1175 pgoff_t seekpos;
1176 MdfdVec *v;
1178 segnum_end;
1179
1181 EXTENSION_DONT_OPEN);
1182
1183 /*
1184 * We might be flushing buffers of already removed relations, that's
1185 * ok, just ignore that case. If the segment file wasn't open already
1186 * (ie from a recent mdwrite()), then we don't want to re-open it, to
1187 * avoid a race with PROCSIGNAL_BARRIER_SMGRRELEASE that might leave
1188 * us with a descriptor to a file that is about to be unlinked.
1189 */
1190 if (!v)
1191 return;
1192
1193 /* compute offset inside the current segment */
1195
1196 /* compute number of desired writes within the current segment */
1200
1203
1205
1207
1208 nblocks -= nflush;
1209 blocknum += nflush;
1210 }
1211}
1212
1213/*
1214 * mdnblocks() -- Get the number of blocks stored in a relation.
1215 *
1216 * Important side effect: all active segments of the relation are opened
1217 * and added to the md_seg_fds array. If this routine has not been
1218 * called, then only segments up to the last one actually touched
1219 * are present in the array.
1220 */
1221BlockNumber
1223{
1224 MdfdVec *v;
1225 BlockNumber nblocks;
1226 BlockNumber segno;
1227
1229
1230 /* mdopen has opened the first segment */
1232
1233 /*
1234 * Start from the last open segments, to avoid redundant seeks. We have
1235 * previously verified that these segments are exactly RELSEG_SIZE long,
1236 * and it's useless to recheck that each time.
1237 *
1238 * NOTE: this assumption could only be wrong if another backend has
1239 * truncated the relation. We rely on higher code levels to handle that
1240 * scenario by closing and re-opening the md fd, which is handled via
1241 * relcache flush. (Since the checkpointer doesn't participate in
1242 * relcache flush, it could have segment entries for inactive segments;
1243 * that's OK because the checkpointer never needs to compute relation
1244 * size.)
1245 */
1246 segno = reln->md_num_open_segs[forknum] - 1;
1247 v = &reln->md_seg_fds[forknum][segno];
1248
1249 for (;;)
1250 {
1256
1257 /*
1258 * If segment is exactly RELSEG_SIZE, advance to next one.
1259 */
1260 segno++;
1261
1262 /*
1263 * We used to pass O_CREAT here, but that has the disadvantage that it
1264 * might create a segment which has vanished through some operating
1265 * system misadventure. In such a case, creating the segment here
1266 * undermines _mdfd_getseg's attempts to notice and report an error
1267 * upon access to a missing segment.
1268 */
1272 }
1273}
1274
1275/*
1276 * mdtruncate() -- Truncate relation to specified number of blocks.
1277 *
1278 * Guaranteed not to allocate memory, so it can be used in a critical section.
1279 * Caller must have called smgrnblocks() to obtain curnblk while holding a
1280 * sufficient lock to prevent a change in relation size, and not used any smgr
1281 * functions for this relation or handled interrupts in between. This makes
1282 * sure we have opened all active segments, so that truncate loop will get
1283 * them all!
1284 *
1285 * If nblocks > curnblk, the request is ignored when we are InRecovery,
1286 * otherwise, an error is raised.
1287 */
1288void
1291{
1294
1296 {
1297 /* Bogus request ... but no complaint if InRecovery */
1299 return;
1303 nblocks, curnblk)));
1304 }
1306 return; /* no work */
1307
1308 /*
1309 * Truncate segments, starting at the last one. Starting at the end makes
1310 * managing the memory for the fd array easier, should there be errors.
1311 */
1314 {
1315 MdfdVec *v;
1316
1318
1320
1322 {
1323 /*
1324 * This segment is no longer active. We truncate the file, but do
1325 * not delete it, for reasons explained in the header comments.
1326 */
1329 (errcode_for_file_access(),
1332
1335
1336 /* we never drop the 1st segment */
1338
1341 }
1343 {
1344 /*
1345 * This is the last segment we want to keep. Truncate the file to
1346 * the right length. NOTE: if nblocks is exactly a multiple K of
1347 * RELSEG_SIZE, we will truncate the K+1st segment to 0 length but
1348 * keep it. This adheres to the invariant given in the header
1349 * comments.
1350 */
1352
1353 if (FileTruncate(v->mdfd_vfd, (pgoff_t) lastsegblocks * BLCKSZ, WAIT_EVENT_DATA_FILE_TRUNCATE) < 0)
1355 (errcode_for_file_access(),
1358 nblocks)));
1361 }
1362 else
1363 {
1364 /*
1365 * We still need this segment, so nothing to do for this and any
1366 * earlier segment.
1367 */
1368 break;
1369 }
1370 curopensegs--;
1371 }
1372}
1373
1374/*
1375 * mdregistersync() -- Mark whole relation as needing fsync
1376 */
1377void
1379{
1380 int segno;
1382
1383 /*
1384 * NOTE: mdnblocks makes sure we have opened all active segments, so that
1385 * the loop below will get them all!
1386 */
1388
1390
1391 /*
1392 * Temporarily open inactive segments, then close them after sync. There
1393 * may be some inactive segments left opened after error, but that is
1394 * harmless. We don't bother to clean them up and take a risk of further
1395 * trouble. The next mdclose() will soon close them.
1396 */
1398 segno++;
1399
1400 while (segno > 0)
1401 {
1403
1405
1406 /* Close inactive segments immediately */
1408 {
1411 }
1412
1413 segno--;
1414 }
1415}
1416
1417/*
1418 * mdimmedsync() -- Immediately sync a relation to stable storage.
1419 *
1420 * Note that only writes already issued are synced; this routine knows
1421 * nothing of dirty buffers that may exist inside the buffer manager. We
1422 * sync active and inactive segments; smgrDoPendingSyncs() relies on this.
1423 * Consider a relation skipping WAL. Suppose a checkpoint syncs blocks of
1424 * some segment, then mdtruncate() renders that segment inactive. If we
1425 * crash before the next checkpoint syncs the newly-inactive segment, that
1426 * segment may survive recovery, reintroducing unwanted data into the table.
1427 */
1428void
1430{
1431 int segno;
1433
1434 /*
1435 * NOTE: mdnblocks makes sure we have opened all active segments, so that
1436 * the loop below will get them all!
1437 */
1439
1441
1442 /*
1443 * Temporarily open inactive segments, then close them after sync. There
1444 * may be some inactive segments left opened after fsync() error, but that
1445 * is harmless. We don't bother to clean them up and take a risk of
1446 * further trouble. The next mdclose() will soon close them.
1447 */
1449 segno++;
1450
1451 while (segno > 0)
1452 {
1454
1455 /*
1456 * fsyncs done through mdimmedsync() should be tracked in a separate
1457 * IOContext than those done through mdsyncfiletag() to differentiate
1458 * between unavoidable client backend fsyncs (e.g. those done during
1459 * index build) and those which ideally would have been done by the
1460 * checkpointer. Since other IO operations bypassing the buffer
1461 * manager could also be tracked in such an IOContext, wait until
1462 * these are also tracked to track immediate fsyncs.
1463 */
1466 (errcode_for_file_access(),
1469
1470 /* Close inactive segments immediately */
1472 {
1475 }
1476
1477 segno--;
1478 }
1479}
1480
1481int
1483{
1485
1487 EXTENSION_FAIL);
1488
1490
1492
1494}
1495
1496/*
1497 * register_dirty_segment() -- Mark a relation segment as needing fsync
1498 *
1499 * If there is a local pending-ops table, just make an entry in it for
1500 * ProcessSyncRequests to process later. Otherwise, try to pass off the
1501 * fsync request to the checkpointer process. If that fails, just do the
1502 * fsync locally before returning (we hope this will not happen often
1503 * enough to be a performance problem).
1504 */
1505static void
1507{
1508 FileTag tag;
1509
1511
1512 /* Temp relations should never be fsync'd */
1514
1516 {
1518
1521
1523
1526 (errcode_for_file_access(),
1529
1530 /*
1531 * We have no way of knowing if the current IOContext is
1532 * IOCONTEXT_NORMAL or IOCONTEXT_[BULKREAD, BULKWRITE, VACUUM] at this
1533 * point, so count the fsync as being in the IOCONTEXT_NORMAL
1534 * IOContext. This is probably okay, because the number of backend
1535 * fsyncs doesn't say anything about the efficacy of the
1536 * BufferAccessStrategy. And counting both fsyncs done in
1537 * IOCONTEXT_NORMAL and IOCONTEXT_[BULKREAD, BULKWRITE, VACUUM] under
1538 * IOCONTEXT_NORMAL is likely clearer when investigating the number of
1539 * backend fsyncs.
1540 */
1543 }
1544}
1545
1546/*
1547 * register_unlink_segment() -- Schedule a file to be deleted after next checkpoint
1548 */
1549static void
1551 BlockNumber segno)
1552{
1553 FileTag tag;
1554
1556
1557 /* Should never be used with temp relations */
1559
1561}
1562
1563/*
1564 * register_forget_request() -- forget any fsyncs for a relation fork's segment
1565 */
1566static void
1568 BlockNumber segno)
1569{
1570 FileTag tag;
1571
1573
1575}
1576
1577/*
1578 * ForgetDatabaseSyncRequests -- forget any fsyncs and unlinks for a DB
1579 */
1580void
1582{
1583 FileTag tag;
1584 RelFileLocator rlocator;
1585
1586 rlocator.dbOid = dbid;
1587 rlocator.spcOid = 0;
1588 rlocator.relNumber = 0;
1589
1591
1593}
1594
1595/*
1596 * DropRelationFiles -- drop files of all given relations
1597 */
1598void
1600{
1603
1606 {
1608
1610 {
1612
1615 }
1617 }
1618
1620
1624}
1625
1626
1627/*
1628 * _fdvec_resize() -- Resize the fork's open segments array
1629 */
1630static void
1632 ForkNumber forknum,
1634{
1636 {
1638 {
1641 }
1642 }
1644 {
1645 reln->md_seg_fds[forknum] =
1647 }
1649 {
1650 /*
1651 * It doesn't seem worthwhile complicating the code to amortize
1652 * repalloc() calls. Those are far faster than PathNameOpenFile() or
1653 * FileClose(), and the memory context internally will sometimes avoid
1654 * doing an actual reallocation.
1655 */
1656 reln->md_seg_fds[forknum] =
1659 }
1660 else
1661 {
1662 /*
1663 * We don't reallocate a smaller array, because we want mdtruncate()
1664 * to be able to promise that it won't allocate memory, so that it is
1665 * allowed in a critical section. This means that a bit of space in
1666 * the array is now wasted, until the next time we add a segment and
1667 * reallocate.
1668 */
1669 }
1670
1672}
1673
1674/*
1675 * Return the filename for the specified segment of the relation. The
1676 * returned string is palloc'd.
1677 */
1680{
1681 RelPathStr path;
1682 MdPathStr fullpath;
1683
1685
1686 if (segno > 0)
1688 else
1690
1691 return fullpath;
1692}
1693
1694/*
1695 * Open the specified segment of the relation,
1696 * and make a MdfdVec object for it. Returns NULL on failure.
1697 */
1701{
1702 MdfdVec *v;
1704 MdPathStr fullpath;
1705
1707
1708 /* open the file */
1710
1713
1714 /*
1715 * Segments are always opened in order from lowest to highest, so we must
1716 * be adding a new one at the end.
1717 */
1719
1721
1722 /* fill the entry */
1723 v = &reln->md_seg_fds[forknum][segno];
1725 v->mdfd_segno = segno;
1726
1728
1729 /* all done */
1730 return v;
1731}
1732
1733/*
1734 * _mdfd_getseg() -- Find the segment of the relation holding the
1735 * specified block.
1736 *
1737 * If the segment doesn't exist, we ereport, return NULL, or create the
1738 * segment, according to "behavior". Note: skipFsync is only used in the
1739 * EXTENSION_CREATE case.
1740 */
1744{
1745 MdfdVec *v;
1748
1749 /* some way to handle non-existent segments needs to be specified */
1750 Assert(behavior &
1752 EXTENSION_DONT_OPEN));
1753
1755
1756 /* if an existing and opened segment, we're done */
1758 {
1760 return v;
1761 }
1762
1763 /* The caller only wants the segment if we already had it open. */
1766
1767 /*
1768 * The target segment is not yet open. Iterate over all the segments
1769 * between the last opened and the target segment. This way missing
1770 * segments either raise an error, or get created (according to
1771 * 'behavior'). Start with either the last opened, or the first segment if
1772 * none was opened before.
1773 */
1776 else
1777 {
1779 if (!v)
1781 }
1782
1785 {
1787 int flags = 0;
1788
1790
1793
1796 {
1797 /*
1798 * Normally we will create new segments only if authorized by the
1799 * caller (i.e., we are doing mdextend()). But when doing WAL
1800 * recovery, create segments anyway; this allows cases such as
1801 * replaying WAL data that has a write into a high-numbered
1802 * segment of a relation that was later deleted. We want to go
1803 * ahead and create the segments so we can finish out the replay.
1804 *
1805 * We have to maintain the invariant that segments before the last
1806 * active segment are of size RELSEG_SIZE; therefore, if
1807 * extending, pad them out with zeroes if needed. (This only
1808 * matters if in recovery, or if the caller is extending the
1809 * relation discontiguously, but that can happen in hash indexes.)
1810 */
1812 {
1814 MCXT_ALLOC_ZERO);
1815
1820 }
1821 flags = O_CREAT;
1822 }
1824 {
1825 /*
1826 * When not extending, only open the next segment if the current
1827 * one is exactly RELSEG_SIZE. If not (this branch), either
1828 * return NULL or fail.
1829 */
1831 {
1832 /*
1833 * Some callers discern between reasons for _mdfd_getseg()
1834 * returning NULL based on errno. As there's no failing
1835 * syscall involved in this case, explicitly set errno to
1836 * ENOENT, as that seems the closest interpretation.
1837 */
1840 }
1841
1843 (errcode_for_file_access(),
1846 blkno, nblocks)));
1847 }
1848
1850
1852 {
1857 (errcode_for_file_access(),
1860 blkno)));
1861 }
1862 }
1863
1864 return v;
1865}
1866
1867/*
1868 * Get number of blocks present in a single disk file
1869 */
1872{
1874
1878 (errcode_for_file_access(),
1881 /* note that this calculation will ignore any partial block at EOF */
1883}
1884
1885/*
1886 * Sync a file to disk, given a file tag. Write the path into an output
1887 * buffer so the caller can use it in error messages.
1888 *
1889 * Return 0 on success, -1 on failure, with errno set.
1890 */
1891int
1893{
1895 File file;
1898 int result,
1899 save_errno;
1900
1901 /* See if we already have the file open, or need to open it. */
1903 {
1907 }
1908 else
1909 {
1910 MdPathStr p;
1911
1914
1916 if (file < 0)
1917 return -1;
1919 }
1920
1922
1923 /* Sync the file. */
1926
1928 FileClose(file);
1929
1932
1934 return result;
1935}
1936
1937/*
1938 * Unlink a file, given a file tag. Write the path into an output
1939 * buffer so the caller can use it in error messages.
1940 *
1941 * Return 0 on success, -1 on failure, with errno set.
1942 */
1943int
1945{
1946 RelPathStr p;
1947
1948 /* Compute the path. */
1951
1952 /* Try to unlink the file. */
1954}
1955
1956/*
1957 * Check if a given candidate request matches a given tag, when processing
1958 * a SYNC_FILTER_REQUEST request. This will be called for all pending
1959 * requests to find out whether to forget them.
1960 */
1961bool
1963{
1964 /*
1965 * For now we only use filter requests as a way to drop all scheduled
1966 * callbacks relating to a given database, when dropping the database.
1967 * We'll return true for all candidates that have the same database OID as
1968 * the ftag from the SYNC_FILTER_REQUEST request, so they're forgotten.
1969 */
1971}
1972
1973/*
1974 * AIO completion callback for mdstartreadv().
1975 */
1978{
1981
1983 {
1986 /* For "hard" errors, track the error number in error_data */
1988 result.result = 0;
1989
1990 /*
1991 * Immediately log a message about the IO error, but only to the
1992 * server log. The reason to do so immediately is that the originator
1993 * might not process the query result immediately (because it is busy
1994 * doing another part of query processing) or at all (e.g. if it was
1995 * cancelled or errored out due to another IO also failing). The
1996 * definer of the IO will emit an ERROR when processing the IO's
1997 * results
1998 */
2000
2001 return result;
2002 }
2003
2004 /*
2005 * As explained above smgrstartreadv(), the smgr API operates on the level
2006 * of blocks, rather than bytes. Convert.
2007 */
2009
2011
2013 {
2014 /* consider 0 blocks read a failure */
2017 result.error_data = 0;
2018
2019 /* see comment above the "hard error" case */
2021
2022 return result;
2023 }
2024
2027 {
2028 /* partial reads should be retried at upper level */
2031 }
2032
2033 return result;
2034}
2035
2036/*
2037 * AIO error reporting callback for mdstartreadv().
2038 *
2039 * Errors are encoded as follows:
2040 * - PgAioResult.error_data != 0 encodes IO that failed with that errno
2041 * - PgAioResult.error_data == 0 encodes IO that didn't read all data
2042 */
2043static void
2045{
2046 RelPathStr path;
2047
2050 td->smgr.forkNum);
2051
2053 {
2054 /* for errcode_for_file_access() and %m */
2056
2057 ereport(elevel,
2058 errcode_for_file_access(),
2062 path.str));
2063 }
2064 else
2065 {
2066 /*
2067 * NB: This will typically only be output in debug messages, while
2068 * retrying a partial IO.
2069 */
2070 ereport(elevel,
2075 path.str,
2078 }
2079}
void pgaio_io_set_flag(PgAioHandle *ioh, PgAioHandleFlags flag)
Definition aio.c:330
void pgaio_io_register_callbacks(PgAioHandle *ioh, PgAioHandleCallbackID cb_id, uint8 cb_data)
Definition aio_callback.c:86
void pgaio_result_report(PgAioResult result, const PgAioTargetData *target_data, int elevel)
Definition aio_callback.c:173
int pgaio_io_get_iovec(PgAioHandle *ioh, struct iovec **iov)
Definition aio_io.c:42
PgAioTargetData * pgaio_io_get_target_data(PgAioHandle *ioh)
Definition aio_target.c:73
void TablespaceCreateDbspace(Oid spcOid, Oid dbOid, bool isRedo)
Definition tablespace.c:112
void FileWriteback(File file, pgoff_t offset, pgoff_t nbytes, uint32 wait_event_info)
Definition fd.c:2119
int FileStartReadV(PgAioHandle *ioh, File file, int iovcnt, pgoff_t offset, uint32 wait_event_info)
Definition fd.c:2201
ssize_t FileReadV(File file, const struct iovec *iov, int iovcnt, pgoff_t offset, uint32 wait_event_info)
Definition fd.c:2145
int FileFallocate(File file, pgoff_t offset, pgoff_t amount, uint32 wait_event_info)
Definition fd.c:2404
int FileZero(File file, pgoff_t offset, pgoff_t amount, uint32 wait_event_info)
Definition fd.c:2359
int FilePrefetch(File file, pgoff_t offset, pgoff_t amount, uint32 wait_event_info)
Definition fd.c:2063
ssize_t FileWriteV(File file, const struct iovec *iov, int iovcnt, pgoff_t offset, uint32 wait_event_info)
Definition fd.c:2227
static ssize_t FileWrite(File file, const void *buffer, size_t amount, pgoff_t offset, uint32 wait_event_info)
Definition fd.h:226
int compute_remaining_iovec(struct iovec *destination, const struct iovec *source, int iovcnt, size_t transferred)
Definition file_utils.c:614
void mdunlink(RelFileLocatorBackend rlocator, ForkNumber forknum, bool isRedo)
Definition md.c:337
static void md_readv_report(PgAioResult result, const PgAioTargetData *td, int elevel)
Definition md.c:2045
static void register_forget_request(RelFileLocatorBackend rlocator, ForkNumber forknum, BlockNumber segno)
Definition md.c:1568
void mdtruncate(SMgrRelation reln, ForkNumber forknum, BlockNumber curnblk, BlockNumber nblocks)
Definition md.c:1290
static BlockNumber _mdnblocks(SMgrRelation reln, ForkNumber forknum, MdfdVec *seg)
Definition md.c:1872
static void mdunlinkfork(RelFileLocatorBackend rlocator, ForkNumber forknum, bool isRedo)
Definition md.c:374
void mdwritev(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, const void **buffers, BlockNumber nblocks, bool skipFsync)
Definition md.c:1059
bool mdfiletagmatches(const FileTag *ftag, const FileTag *candidate)
Definition md.c:1963
void mdreadv(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, void **buffers, BlockNumber nblocks)
Definition md.c:847
static MdPathStr _mdfd_segpath(SMgrRelation reln, ForkNumber forknum, BlockNumber segno)
Definition md.c:1680
static void register_unlink_segment(RelFileLocatorBackend rlocator, ForkNumber forknum, BlockNumber segno)
Definition md.c:1551
int mdfd(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, uint32 *off)
Definition md.c:1483
void mdextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, const void *buffer, bool skipFsync)
Definition md.c:487
static PgAioResult md_readv_complete(PgAioHandle *ioh, PgAioResult prior_result, uint8 cb_data)
Definition md.c:1978
void mdzeroextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, int nblocks, bool skipFsync)
Definition md.c:552
static MdfdVec * _mdfd_openseg(SMgrRelation reln, ForkNumber forknum, BlockNumber segno, int oflags)
Definition md.c:1700
static void register_dirty_segment(SMgrRelation reln, ForkNumber forknum, MdfdVec *seg)
Definition md.c:1507
void mdwriteback(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, BlockNumber nblocks)
Definition md.c:1164
uint32 mdmaxcombine(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
Definition md.c:833
static MdfdVec * _mdfd_getseg(SMgrRelation reln, ForkNumber forknum, BlockNumber blkno, bool skipFsync, int behavior)
Definition md.c:1743
void mdstartreadv(PgAioHandle *ioh, SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, void **buffers, BlockNumber nblocks)
Definition md.c:985
bool mdprefetch(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, int nblocks)
Definition md.c:736
static MdfdVec * mdopenfork(SMgrRelation reln, ForkNumber forknum, int behavior)
Definition md.c:664
void DropRelationFiles(RelFileLocator *delrels, int ndelrels, bool isRedo)
Definition md.c:1600
static int buffers_to_iovec(struct iovec *iov, void **buffers, int nblocks)
Definition md.c:784
static void _fdvec_resize(SMgrRelation reln, ForkNumber forknum, int nseg)
Definition md.c:1632
void pgstat_count_io_op_time(IOObject io_object, IOContext io_context, IOOp io_op, instr_time start_time, uint32 cnt, uint64 bytes)
Definition pgstat_io.c:122
#define RelFileLocatorBackendIsTemp(rlocator)
Definition relfilelocator.h:79
void smgrdounlinkall(SMgrRelation *rels, int nrels, bool isRedo)
Definition smgr.c:538
void pgaio_io_set_target_smgr(PgAioHandle *ioh, SMgrRelationData *smgr, ForkNumber forknum, BlockNumber blocknum, int nblocks, bool skip_fsync)
Definition smgr.c:1038
Definition aio.h:214
PgAioHandleCallbackComplete complete_shared
Definition aio.h:239
Definition aio_internal.h:103
Definition aio_types.h:100
Definition relfilelocator.h:74
Definition relfilelocator.h:59
Definition relpath.h:122
Definition smgr.h:36
Definition instr_time.h:70
bool RegisterSyncRequest(const FileTag *ftag, SyncRequestType type, bool retryOnError)
Definition sync.c:580
Definition aio_types.h:62
struct PgAioTargetData::@126 smgr
void XLogDropRelation(RelFileLocator rlocator, ForkNumber forknum)
Definition xlogutils.c:630
◆ MD_PATH_STR_MAXLEN
| #define MD_PATH_STR_MAXLEN |
Value:
◆ SEGMENT_CHARS
Typedef Documentation
◆ MdfdVec
◆ MdPathStr
Function Documentation
◆ _fdvec_resize()
|
static |
Definition at line 1632 of file md.c.
1635{
1637 {
1639 {
1642 }
1643 }
1645 {
1646 reln->md_seg_fds[forknum] =
1648 }
1650 {
1651 /*
1652 * It doesn't seem worthwhile complicating the code to amortize
1653 * repalloc() calls. Those are far faster than PathNameOpenFile() or
1654 * FileClose(), and the memory context internally will sometimes avoid
1655 * doing an actual reallocation.
1656 */
1657 reln->md_seg_fds[forknum] =
1660 }
1661 else
1662 {
1663 /*
1664 * We don't reallocate a smaller array, because we want mdtruncate()
1665 * to be able to promise that it won't allocate memory, so that it is
1666 * allowed in a critical section. This means that a bit of space in
1667 * the array is now wasted, until the next time we add a segment and
1668 * reallocate.
1669 */
1670 }
1671
1673}
References fb(), MdCxt, MemoryContextAlloc(), pfree(), and repalloc().
Referenced by _mdfd_openseg(), mdclose(), mdcreate(), mdimmedsync(), mdopenfork(), mdregistersync(), and mdtruncate().
◆ _mdfd_getseg()
|
static |
Definition at line 1743 of file md.c.
1745{
1746 MdfdVec *v;
1749
1750 /* some way to handle non-existent segments needs to be specified */
1751 Assert(behavior &
1753 EXTENSION_DONT_OPEN));
1754
1756
1757 /* if an existing and opened segment, we're done */
1759 {
1761 return v;
1762 }
1763
1764 /* The caller only wants the segment if we already had it open. */
1767
1768 /*
1769 * The target segment is not yet open. Iterate over all the segments
1770 * between the last opened and the target segment. This way missing
1771 * segments either raise an error, or get created (according to
1772 * 'behavior'). Start with either the last opened, or the first segment if
1773 * none was opened before.
1774 */
1777 else
1778 {
1780 if (!v)
1782 }
1783
1786 {
1788 int flags = 0;
1789
1791
1794
1797 {
1798 /*
1799 * Normally we will create new segments only if authorized by the
1800 * caller (i.e., we are doing mdextend()). But when doing WAL
1801 * recovery, create segments anyway; this allows cases such as
1802 * replaying WAL data that has a write into a high-numbered
1803 * segment of a relation that was later deleted. We want to go
1804 * ahead and create the segments so we can finish out the replay.
1805 *
1806 * We have to maintain the invariant that segments before the last
1807 * active segment are of size RELSEG_SIZE; therefore, if
1808 * extending, pad them out with zeroes if needed. (This only
1809 * matters if in recovery, or if the caller is extending the
1810 * relation discontiguously, but that can happen in hash indexes.)
1811 */
1813 {
1815 MCXT_ALLOC_ZERO);
1816
1821 }
1822 flags = O_CREAT;
1823 }
1825 {
1826 /*
1827 * When not extending, only open the next segment if the current
1828 * one is exactly RELSEG_SIZE. If not (this branch), either
1829 * return NULL or fail.
1830 */
1832 {
1833 /*
1834 * Some callers discern between reasons for _mdfd_getseg()
1835 * returning NULL based on errno. As there's no failing
1836 * syscall involved in this case, explicitly set errno to
1837 * ENOENT, as that seems the closest interpretation.
1838 */
1841 }
1842
1844 (errcode_for_file_access(),
1847 blkno, nblocks)));
1848 }
1849
1851
1853 {
1858 (errcode_for_file_access(),
1861 blkno)));
1862 }
1863 }
1864
1865 return v;
1866}
References _mdfd_openseg(), _mdfd_segpath(), _mdnblocks(), Assert, elog, ereport, errcode_for_file_access(), errmsg(), ERROR, EXTENSION_CREATE, EXTENSION_CREATE_RECOVERY, EXTENSION_DONT_OPEN, EXTENSION_FAIL, EXTENSION_RETURN_NULL, FATAL, fb(), FILE_POSSIBLY_DELETED, InRecovery, MCXT_ALLOC_ZERO, mdextend(), _MdfdVec::mdfd_segno, mdopenfork(), palloc_aligned(), pfree(), PG_IO_ALIGN_SIZE, and str.
Referenced by mdextend(), mdfd(), mdprefetch(), mdreadv(), mdstartreadv(), mdwriteback(), mdwritev(), and mdzeroextend().
◆ _mdfd_open_flags()
Definition at line 176 of file md.c.
References fb(), IO_DIRECT_DATA, io_direct_flags, PG_BINARY, and PG_O_DIRECT.
Referenced by _mdfd_openseg(), mdcreate(), mdopenfork(), and mdsyncfiletag().
◆ _mdfd_openseg()
|
static |
Definition at line 1700 of file md.c.
1702{
1703 MdfdVec *v;
1705 MdPathStr fullpath;
1706
1708
1709 /* open the file */
1711
1714
1715 /*
1716 * Segments are always opened in order from lowest to highest, so we must
1717 * be adding a new one at the end.
1718 */
1720
1722
1723 /* fill the entry */
1724 v = &reln->md_seg_fds[forknum][segno];
1726 v->mdfd_segno = segno;
1727
1729
1730 /* all done */
1731 return v;
1732}
References _fdvec_resize(), _mdfd_open_flags(), _mdfd_segpath(), _mdnblocks(), Assert, fb(), fd(), _MdfdVec::mdfd_segno, _MdfdVec::mdfd_vfd, PathNameOpenFile(), and MdPathStr::str.
Referenced by _mdfd_getseg(), mdimmedsync(), mdnblocks(), and mdregistersync().
◆ _mdfd_segpath()
|
static |
Definition at line 1680 of file md.c.
1681{
1682 RelPathStr path;
1683 MdPathStr fullpath;
1684
1686
1687 if (segno > 0)
1689 else
1691
1692 return fullpath;
1693}
References fb(), relpath, sprintf, MdPathStr::str, and RelPathStr::str.
Referenced by _mdfd_getseg(), _mdfd_openseg(), and mdsyncfiletag().
◆ _mdnblocks()
|
static |
Definition at line 1872 of file md.c.
1873{
1875
1879 (errcode_for_file_access(),
1882 /* note that this calculation will ignore any partial block at EOF */
1884}
References ereport, errcode_for_file_access(), errmsg(), ERROR, fb(), FilePathName(), FileSize(), len, and _MdfdVec::mdfd_vfd.
Referenced by _mdfd_getseg(), _mdfd_openseg(), mdextend(), mdnblocks(), mdopenfork(), and mdzeroextend().
◆ buffers_to_iovec()
Definition at line 784 of file md.c.
785{
788
789 Assert(nblocks >= 1);
790
791 /* If this build supports direct I/O, buffers must be I/O aligned. */
793 {
797 }
798
799 /* Start the first iovec off with the first buffer. */
801 iovp->iov_base = buffers[0];
803 iovcnt = 1;
804
805 /* Try to merge the rest. */
807 {
809
811 {
812 /* Contiguous with the last iovec. */
814 }
815 else
816 {
817 /* Need a new iovec. */
818 iovp++;
819 iovp->iov_base = buffer;
821 iovcnt++;
822 }
823 }
824
826}
References Assert, fb(), i, PG_IO_ALIGN_SIZE, PG_O_DIRECT, and TYPEALIGN.
Referenced by mdreadv(), mdstartreadv(), and mdwritev().
◆ do_truncate()
Definition at line 353 of file md.c.
354{
356 int ret;
357
358 ret = pg_truncate(path, 0);
359
360 /* Log a warning here to avoid repetition in callers. */
362 {
365 (errcode_for_file_access(),
368 }
369
370 return ret;
371}
References ereport, errcode_for_file_access(), errmsg(), fb(), pg_truncate(), and WARNING.
Referenced by mdunlinkfork().
◆ DropRelationFiles()
| void DropRelationFiles | ( | RelFileLocator * | delrels, |
| int | ndelrels, | ||
| bool | isRedo | ||
| ) |
Definition at line 1600 of file md.c.
1601{
1604
1607 {
1609
1611 {
1613
1616 }
1618 }
1619
1621
1625}
References fb(), i, INVALID_PROC_NUMBER, MAX_FORKNUM, palloc_array, pfree(), smgrclose(), smgrdounlinkall(), smgropen(), and XLogDropRelation().
Referenced by FinishPreparedTransaction(), xact_redo_abort(), and xact_redo_commit().
◆ ForgetDatabaseSyncRequests()
Definition at line 1582 of file md.c.
1583{
1584 FileTag tag;
1585 RelFileLocator rlocator;
1586
1587 rlocator.dbOid = dbid;
1588 rlocator.spcOid = 0;
1589 rlocator.relNumber = 0;
1590
1592
1594}
References RelFileLocator::dbOid, INIT_MD_FILETAG, InvalidBlockNumber, InvalidForkNumber, RegisterSyncRequest(), RelFileLocator::relNumber, RelFileLocator::spcOid, and SYNC_FILTER_REQUEST.
Referenced by createdb_failure_callback(), dbase_redo(), and dropdb().
◆ md_readv_complete()
|
static |
Definition at line 1978 of file md.c.
1979{
1982
1984 {
1987 /* For "hard" errors, track the error number in error_data */
1989 result.result = 0;
1990
1991 /*
1992 * Immediately log a message about the IO error, but only to the
1993 * server log. The reason to do so immediately is that the originator
1994 * might not process the query result immediately (because it is busy
1995 * doing another part of query processing) or at all (e.g. if it was
1996 * cancelled or errored out due to another IO also failing). The
1997 * definer of the IO will emit an ERROR when processing the IO's
1998 * results
1999 */
2001
2002 return result;
2003 }
2004
2005 /*
2006 * As explained above smgrstartreadv(), the smgr API operates on the level
2007 * of blocks, rather than bytes. Convert.
2008 */
2010
2012
2014 {
2015 /* consider 0 blocks read a failure */
2018 result.error_data = 0;
2019
2020 /* see comment above the "hard error" case */
2022
2023 return result;
2024 }
2025
2028 {
2029 /* partial reads should be retried at upper level */
2032 }
2033
2034 return result;
2035}
References Assert, PgAioResult::error_data, fb(), PgAioResult::id, LOG_SERVER_ONLY, PgAioTargetData::nblocks, PGAIO_HCB_MD_READV, pgaio_io_get_target_data(), pgaio_result_report(), PGAIO_RS_ERROR, PGAIO_RS_PARTIAL, PgAioResult::result, PgAioTargetData::smgr, and PgAioResult::status.
◆ md_readv_report()
|
static |
Definition at line 2045 of file md.c.
2046{
2047 RelPathStr path;
2048
2051 td->smgr.forkNum);
2052
2054 {
2055 /* for errcode_for_file_access() and %m */
2057
2058 ereport(elevel,
2059 errcode_for_file_access(),
2063 path.str));
2064 }
2065 else
2066 {
2067 /*
2068 * NB: This will typically only be output in debug messages, while
2069 * retrying a partial IO.
2070 */
2071 ereport(elevel,
2076 path.str,
2079 }
2080}
References PgAioTargetData::blockNum, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errcode_for_file_access(), errmsg(), PgAioResult::error_data, fb(), PgAioTargetData::forkNum, INVALID_PROC_NUMBER, PgAioTargetData::is_temp, MyProcNumber, PgAioTargetData::nblocks, relpathbackend, PgAioResult::result, PgAioTargetData::rlocator, PgAioTargetData::smgr, and RelPathStr::str.
◆ mdclose()
| void mdclose | ( | SMgrRelation | reln, |
| ForkNumber | forknum | ||
| ) |
Definition at line 713 of file md.c.
714{
716
717 /* No work if already closed */
719 return;
720
721 /* close segments starting from the end */
723 {
725
728 nopensegs--;
729 }
730}
References _fdvec_resize(), fb(), FileClose(), and _MdfdVec::mdfd_vfd.
Referenced by mdexists().
◆ mdcreate()
| void mdcreate | ( | SMgrRelation | reln, |
| ForkNumber | forknum, | ||
| bool | isRedo | ||
| ) |
Definition at line 222 of file md.c.
223{
225 RelPathStr path;
227
229 return; /* created and opened already... */
230
232
233 /*
234 * We may be using the target table space for the first time in this
235 * database, so create a per-database subdirectory if needed.
236 *
237 * XXX this is a fairly ugly violation of module layering, but this seems
238 * to be the best place to put the check. Maybe TablespaceCreateDbspace
239 * should be here and not in commands/tablespace.c? But that would imply
240 * importing a lot of stuff that smgr.c oughtn't know, either.
241 */
243 reln->smgr_rlocator.locator.dbOid,
244 isRedo);
245
247
249
251 {
253
257 {
258 /* be sure to report the error reported by create, not open */
261 (errcode_for_file_access(),
263 }
264 }
265
269 mdfd->mdfd_segno = 0;
270
273}
References _fdvec_resize(), _mdfd_open_flags(), Assert, ereport, errcode_for_file_access(), errmsg(), ERROR, fb(), fd(), mdfd(), PathNameOpenFile(), register_dirty_segment(), relpath, SmgrIsTemp, RelPathStr::str, and TablespaceCreateDbspace().
◆ mdexists()
| bool mdexists | ( | SMgrRelation | reln, |
| ForkNumber | forknum | ||
| ) |
Definition at line 203 of file md.c.
204{
205 /*
206 * Close it first, to ensure that we notice if the fork has been unlinked
207 * since we opened it. As an optimization, we can skip that in recovery,
208 * which already closes relations when dropping them.
209 */
212
214}
References EXTENSION_RETURN_NULL, fb(), InRecovery, mdclose(), and mdopenfork().
◆ mdextend()
| void mdextend | ( | SMgrRelation | reln, |
| ForkNumber | forknum, | ||
| BlockNumber | blocknum, | ||
| const void * | buffer, | ||
| bool | skipFsync | ||
| ) |
Definition at line 487 of file md.c.
489{
490 pgoff_t seekpos;
491 int nbytes;
492 MdfdVec *v;
493
494 /* If this build supports direct I/O, the buffer must be I/O aligned. */
497
498 /* This assert is too expensive to have on normally ... */
499#ifdef CHECK_WRITE_VS_EXTEND
501#endif
502
503 /*
504 * If a relation manages to grow to 2^32-1 blocks, refuse to extend it any
505 * more --- we mustn't create a block whose number actually is
506 * InvalidBlockNumber. (Note that this failure should be unreachable
507 * because of upstream checks in bufmgr.c.)
508 */
514 InvalidBlockNumber)));
515
517
519
521
522 if ((nbytes = FileWrite(v->mdfd_vfd, buffer, BLCKSZ, seekpos, WAIT_EVENT_DATA_FILE_EXTEND)) != BLCKSZ)
523 {
524 if (nbytes < 0)
526 (errcode_for_file_access(),
530 /* short write: complain appropriately */
535 nbytes, BLCKSZ, blocknum),
537 }
538
541
543}
References _mdfd_getseg(), _mdnblocks(), Assert, ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, EXTENSION_CREATE, fb(), FilePathName(), FileWrite(), InvalidBlockNumber, _MdfdVec::mdfd_vfd, mdnblocks(), PG_IO_ALIGN_SIZE, PG_O_DIRECT, register_dirty_segment(), relpath, SmgrIsTemp, and TYPEALIGN.
Referenced by _mdfd_getseg().
◆ mdfd()
| int mdfd | ( | SMgrRelation | reln, |
| ForkNumber | forknum, | ||
| BlockNumber | blocknum, | ||
| uint32 * | off | ||
| ) |
Definition at line 1483 of file md.c.
References _mdfd_getseg(), Assert, EXTENSION_FAIL, fb(), FileGetRawDesc(), _MdfdVec::mdfd_vfd, and mdopenfork().
Referenced by mdcreate(), and mdopenfork().
◆ mdfiletagmatches()
Definition at line 1963 of file md.c.
1964{
1965 /*
1966 * For now we only use filter requests as a way to drop all scheduled
1967 * callbacks relating to a given database, when dropping the database.
1968 * We'll return true for all candidates that have the same database OID as
1969 * the ftag from the SYNC_FILTER_REQUEST request, so they're forgotten.
1970 */
1972}
References RelFileLocator::dbOid, fb(), and FileTag::rlocator.
◆ mdimmedsync()
| void mdimmedsync | ( | SMgrRelation | reln, |
| ForkNumber | forknum | ||
| ) |
Definition at line 1430 of file md.c.
1431{
1432 int segno;
1434
1435 /*
1436 * NOTE: mdnblocks makes sure we have opened all active segments, so that
1437 * the loop below will get them all!
1438 */
1440
1442
1443 /*
1444 * Temporarily open inactive segments, then close them after sync. There
1445 * may be some inactive segments left opened after fsync() error, but that
1446 * is harmless. We don't bother to clean them up and take a risk of
1447 * further trouble. The next mdclose() will soon close them.
1448 */
1450 segno++;
1451
1452 while (segno > 0)
1453 {
1455
1456 /*
1457 * fsyncs done through mdimmedsync() should be tracked in a separate
1458 * IOContext than those done through mdsyncfiletag() to differentiate
1459 * between unavoidable client backend fsyncs (e.g. those done during
1460 * index build) and those which ideally would have been done by the
1461 * checkpointer. Since other IO operations bypassing the buffer
1462 * manager could also be tracked in such an IOContext, wait until
1463 * these are also tracked to track immediate fsyncs.
1464 */
1467 (errcode_for_file_access(),
1470
1471 /* Close inactive segments immediately */
1473 {
1476 }
1477
1478 segno--;
1479 }
1480}
References _fdvec_resize(), _mdfd_openseg(), data_sync_elevel(), ereport, errcode_for_file_access(), errmsg(), ERROR, fb(), FileClose(), FilePathName(), FileSync(), _MdfdVec::mdfd_vfd, and mdnblocks().
◆ mdinit()
Definition at line 190 of file md.c.
References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, MdCxt, and TopMemoryContext.
◆ mdmaxcombine()
| uint32 mdmaxcombine | ( | SMgrRelation | reln, |
| ForkNumber | forknum, | ||
| BlockNumber | blocknum | ||
| ) |
◆ mdnblocks()
| BlockNumber mdnblocks | ( | SMgrRelation | reln, |
| ForkNumber | forknum | ||
| ) |
Definition at line 1223 of file md.c.
1224{
1225 MdfdVec *v;
1226 BlockNumber nblocks;
1227 BlockNumber segno;
1228
1230
1231 /* mdopen has opened the first segment */
1233
1234 /*
1235 * Start from the last open segments, to avoid redundant seeks. We have
1236 * previously verified that these segments are exactly RELSEG_SIZE long,
1237 * and it's useless to recheck that each time.
1238 *
1239 * NOTE: this assumption could only be wrong if another backend has
1240 * truncated the relation. We rely on higher code levels to handle that
1241 * scenario by closing and re-opening the md fd, which is handled via
1242 * relcache flush. (Since the checkpointer doesn't participate in
1243 * relcache flush, it could have segment entries for inactive segments;
1244 * that's OK because the checkpointer never needs to compute relation
1245 * size.)
1246 */
1247 segno = reln->md_num_open_segs[forknum] - 1;
1248 v = &reln->md_seg_fds[forknum][segno];
1249
1250 for (;;)
1251 {
1257
1258 /*
1259 * If segment is exactly RELSEG_SIZE, advance to next one.
1260 */
1261 segno++;
1262
1263 /*
1264 * We used to pass O_CREAT here, but that has the disadvantage that it
1265 * might create a segment which has vanished through some operating
1266 * system misadventure. In such a case, creating the segment here
1267 * undermines _mdfd_getseg's attempts to notice and report an error
1268 * upon access to a missing segment.
1269 */
1273 }
1274}
References _mdfd_openseg(), _mdnblocks(), Assert, elog, EXTENSION_FAIL, FATAL, fb(), and mdopenfork().
Referenced by mdextend(), mdimmedsync(), mdregistersync(), mdwritev(), and mdzeroextend().
◆ mdopen()
| void mdopen | ( | SMgrRelation | reln | ) |
Definition at line 702 of file md.c.
References fb(), and MAX_FORKNUM.
◆ mdopenfork()
|
static |
Definition at line 664 of file md.c.
665{
667 RelPathStr path;
669
670 /* No work if already open */
673
675
677
679 {
684 (errcode_for_file_access(),
686 }
687
691 mdfd->mdfd_segno = 0;
692
694
696}
References _fdvec_resize(), _mdfd_open_flags(), _mdnblocks(), Assert, ereport, errcode_for_file_access(), errmsg(), ERROR, EXTENSION_RETURN_NULL, fb(), fd(), FILE_POSSIBLY_DELETED, mdfd(), PathNameOpenFile(), relpath, and RelPathStr::str.
Referenced by _mdfd_getseg(), mdexists(), mdfd(), and mdnblocks().
◆ mdprefetch()
| bool mdprefetch | ( | SMgrRelation | reln, |
| ForkNumber | forknum, | ||
| BlockNumber | blocknum, | ||
| int | nblocks | ||
| ) |
Definition at line 736 of file md.c.
738{
739#ifdef USE_PREFETCH
740
742
744 return false;
745
746 while (nblocks > 0)
747 {
748 pgoff_t seekpos;
749 MdfdVec *v;
751
755 return false;
756
758
760
761 nblocks_this_segment =
762 Min(nblocks,
764
767
768 blocknum += nblocks_this_segment;
769 nblocks -= nblocks_this_segment;
770 }
771#endif /* USE_PREFETCH */
772
773 return true;
774}
References _mdfd_getseg(), Assert, EXTENSION_FAIL, EXTENSION_RETURN_NULL, fb(), FilePrefetch(), InRecovery, IO_DIRECT_DATA, io_direct_flags, MaxBlockNumber, _MdfdVec::mdfd_vfd, and Min.
◆ mdreadv()
| void mdreadv | ( | SMgrRelation | reln, |
| ForkNumber | forknum, | ||
| BlockNumber | blocknum, | ||
| void ** | buffers, | ||
| BlockNumber | nblocks | ||
| ) |
Definition at line 847 of file md.c.
849{
850 while (nblocks > 0)
851 {
854 pgoff_t seekpos;
855 int nbytes;
856 MdfdVec *v;
860
863
865
867
868 nblocks_this_segment =
869 Min(nblocks,
872
875
878 transferred_this_segment = 0;
879
880 /*
881 * Inner loop to continue after a short read. We'll keep going until
882 * we hit EOF rather than assuming that a short read means we hit the
883 * end.
884 */
885 for (;;)
886 {
887 TRACE_POSTGRESQL_SMGR_MD_READ_START(forknum, blocknum,
888 reln->smgr_rlocator.locator.spcOid,
889 reln->smgr_rlocator.locator.dbOid,
890 reln->smgr_rlocator.locator.relNumber,
891 reln->smgr_rlocator.backend);
894 TRACE_POSTGRESQL_SMGR_MD_READ_DONE(forknum, blocknum,
895 reln->smgr_rlocator.locator.spcOid,
896 reln->smgr_rlocator.locator.dbOid,
897 reln->smgr_rlocator.locator.relNumber,
898 reln->smgr_rlocator.backend,
899 nbytes,
901
902#ifdef SIMULATE_SHORT_READ
903 nbytes = Min(nbytes, 4096);
904#endif
905
906 if (nbytes < 0)
908 (errcode_for_file_access(),
910 blocknum,
911 blocknum + nblocks_this_segment - 1,
913
914 if (nbytes == 0)
915 {
916 /*
917 * We are at or past EOF, or we read a partial block at EOF.
918 * Normally this is an error; upper levels should never try to
919 * read a nonexistent block. However, if zero_damaged_pages
920 * is ON or we are InRecovery, we should instead return zeroes
921 * without complaining. This allows, for example, the case of
922 * trying to update a block that was later truncated away.
923 *
924 * NB: We think that this codepath is unreachable in recovery
925 * and incomplete with zero_damaged_pages, as missing segments
926 * are not created. Putting blocks into the buffer-pool that
927 * do not exist on disk is rather problematic, as it will not
928 * be found by scans that rely on smgrnblocks(), as they are
929 * beyond EOF. It also can cause weird problems with relation
930 * extension, as relation extension does not expect blocks
931 * beyond EOF to exist.
932 *
933 * Therefore we do not want to copy the logic into
934 * mdstartreadv(), where it would have to be more complicated
935 * due to potential differences in the zero_damaged_pages
936 * setting between the definer and completor of IO.
937 *
938 * For PG 18, we are putting an Assert(false) in mdreadv()
939 * (triggering failures in assertion-enabled builds, but
940 * continuing to work in production builds). Afterwards we
941 * plan to remove this code entirely.
942 */
944 {
946
949 ++i)
951 break;
952 }
953 else
957 blocknum,
958 blocknum + nblocks_this_segment - 1,
961 size_this_segment)));
962 }
963
964 /* One loop should usually be enough. */
965 transferred_this_segment += nbytes;
968 break;
969
970 /* Adjust position and vectors after a short read. */
971 seekpos += nbytes;
973 }
974
975 nblocks -= nblocks_this_segment;
976 buffers += nblocks_this_segment;
977 blocknum += nblocks_this_segment;
978 }
979}
References _mdfd_getseg(), Assert, buffers_to_iovec(), compute_remaining_iovec(), elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errcode_for_file_access(), errmsg(), ERROR, EXTENSION_CREATE_RECOVERY, EXTENSION_FAIL, fb(), FilePathName(), FileReadV(), i, InRecovery, lengthof, _MdfdVec::mdfd_vfd, Min, PG_IOV_MAX, and zero_damaged_pages.
◆ mdregistersync()
| void mdregistersync | ( | SMgrRelation | reln, |
| ForkNumber | forknum | ||
| ) |
Definition at line 1379 of file md.c.
1380{
1381 int segno;
1383
1384 /*
1385 * NOTE: mdnblocks makes sure we have opened all active segments, so that
1386 * the loop below will get them all!
1387 */
1389
1391
1392 /*
1393 * Temporarily open inactive segments, then close them after sync. There
1394 * may be some inactive segments left opened after error, but that is
1395 * harmless. We don't bother to clean them up and take a risk of further
1396 * trouble. The next mdclose() will soon close them.
1397 */
1399 segno++;
1400
1401 while (segno > 0)
1402 {
1404
1406
1407 /* Close inactive segments immediately */
1409 {
1412 }
1413
1414 segno--;
1415 }
1416}
References _fdvec_resize(), _mdfd_openseg(), fb(), FileClose(), _MdfdVec::mdfd_vfd, mdnblocks(), and register_dirty_segment().
◆ mdstartreadv()
| void mdstartreadv | ( | PgAioHandle * | ioh, |
| SMgrRelation | reln, | ||
| ForkNumber | forknum, | ||
| BlockNumber | blocknum, | ||
| void ** | buffers, | ||
| BlockNumber | nblocks | ||
| ) |
Definition at line 985 of file md.c.
988{
989 pgoff_t seekpos;
990 MdfdVec *v;
994 int ret;
995
998
1000
1002
1003 nblocks_this_segment =
1004 Min(nblocks,
1006
1009
1011
1013
1015
1017
1020
1022 reln,
1023 forknum,
1024 blocknum,
1025 nblocks,
1026 false);
1028
1030 if (ret != 0)
1032 (errcode_for_file_access(),
1034 blocknum,
1035 blocknum + nblocks_this_segment - 1,
1037
1038 /*
1039 * The error checks corresponding to the post-read checks in mdreadv() are
1040 * in md_readv_complete().
1041 *
1042 * However we chose, at least for now, to not implement the
1043 * zero_damaged_pages logic present in mdreadv(). As outlined in mdreadv()
1044 * that logic is rather problematic, and we want to get rid of it. Here
1045 * equivalent logic would have to be more complicated due to potential
1046 * differences in the zero_damaged_pages setting between the definer and
1047 * completor of IO.
1048 */
1049}
References _mdfd_getseg(), Assert, buffers_to_iovec(), elog, ereport, errcode_for_file_access(), errmsg(), ERROR, EXTENSION_CREATE_RECOVERY, EXTENSION_FAIL, fb(), FilePathName(), FileStartReadV(), IO_DIRECT_DATA, io_direct_flags, _MdfdVec::mdfd_vfd, Min, PGAIO_HCB_MD_READV, PGAIO_HF_BUFFERED, pgaio_io_get_iovec(), pgaio_io_register_callbacks(), pgaio_io_set_flag(), and pgaio_io_set_target_smgr().
◆ mdsyncfiletag()
Definition at line 1893 of file md.c.
1894{
1896 File file;
1899 int result,
1900 save_errno;
1901
1902 /* See if we already have the file open, or need to open it. */
1904 {
1908 }
1909 else
1910 {
1911 MdPathStr p;
1912
1915
1917 if (file < 0)
1918 return -1;
1920 }
1921
1923
1924 /* Sync the file. */
1927
1929 FileClose(file);
1930
1933
1935 return result;
1936}
References _mdfd_open_flags(), _mdfd_segpath(), fb(), FileClose(), FilePathName(), FileSync(), FileTag::forknum, INVALID_PROC_NUMBER, IOCONTEXT_NORMAL, IOOBJECT_RELATION, IOOP_FSYNC, MAXPGPATH, MD_PATH_STR_MAXLEN, PathNameOpenFile(), pgstat_count_io_op_time(), pgstat_prepare_io_time(), FileTag::rlocator, FileTag::segno, smgropen(), MdPathStr::str, strlcpy(), and track_io_timing.
◆ mdtruncate()
| void mdtruncate | ( | SMgrRelation | reln, |
| ForkNumber | forknum, | ||
| BlockNumber | curnblk, | ||
| BlockNumber | nblocks | ||
| ) |
Definition at line 1290 of file md.c.
1292{
1295
1297 {
1298 /* Bogus request ... but no complaint if InRecovery */
1300 return;
1304 nblocks, curnblk)));
1305 }
1307 return; /* no work */
1308
1309 /*
1310 * Truncate segments, starting at the last one. Starting at the end makes
1311 * managing the memory for the fd array easier, should there be errors.
1312 */
1315 {
1316 MdfdVec *v;
1317
1319
1321
1323 {
1324 /*
1325 * This segment is no longer active. We truncate the file, but do
1326 * not delete it, for reasons explained in the header comments.
1327 */
1330 (errcode_for_file_access(),
1333
1336
1337 /* we never drop the 1st segment */
1339
1342 }
1344 {
1345 /*
1346 * This is the last segment we want to keep. Truncate the file to
1347 * the right length. NOTE: if nblocks is exactly a multiple K of
1348 * RELSEG_SIZE, we will truncate the K+1st segment to 0 length but
1349 * keep it. This adheres to the invariant given in the header
1350 * comments.
1351 */
1353
1354 if (FileTruncate(v->mdfd_vfd, (pgoff_t) lastsegblocks * BLCKSZ, WAIT_EVENT_DATA_FILE_TRUNCATE) < 0)
1356 (errcode_for_file_access(),
1359 nblocks)));
1362 }
1363 else
1364 {
1365 /*
1366 * We still need this segment, so nothing to do for this and any
1367 * earlier segment.
1368 */
1369 break;
1370 }
1371 curopensegs--;
1372 }
1373}
References _fdvec_resize(), Assert, ereport, errcode_for_file_access(), errmsg(), ERROR, fb(), FileClose(), FilePathName(), FileTruncate(), InRecovery, _MdfdVec::mdfd_vfd, register_dirty_segment(), relpath, and SmgrIsTemp.
◆ mdunlink()
| void mdunlink | ( | RelFileLocatorBackend | rlocator, |
| ForkNumber | forknum, | ||
| bool | isRedo | ||
| ) |
Definition at line 337 of file md.c.
338{
339 /* Now do the per-fork work */
341 {
344 }
345 else
347}
References fb(), InvalidForkNumber, MAX_FORKNUM, and mdunlinkfork().
◆ mdunlinkfiletag()
Definition at line 1945 of file md.c.
1946{
1947 RelPathStr p;
1948
1949 /* Compute the path. */
1952
1953 /* Try to unlink the file. */
1955}
References fb(), MAIN_FORKNUM, MAXPGPATH, relpathperm, FileTag::rlocator, RelPathStr::str, and strlcpy().
◆ mdunlinkfork()
|
static |
Definition at line 374 of file md.c.
375{
376 RelPathStr path;
377 int ret;
379
380 path = relpath(rlocator, forknum);
381
382 /*
383 * Truncate and then unlink the first segment, or just register a request
384 * to unlink it later, as described in the comments for mdunlink().
385 */
387 RelFileLocatorBackendIsTemp(rlocator))
388 {
390 {
391 /* Prevent other backends' fds from holding on to the disk space */
393
394 /* Forget any pending sync requests for the first segment */
398 }
399 else
400 ret = 0;
401
402 /* Next unlink the file, unless it was already found to be missing */
404 {
407 {
410 (errcode_for_file_access(),
413 }
414 }
415 }
416 else
417 {
418 /* Prevent other backends' fds from holding on to the disk space */
420
421 /* Register request to unlink first segment later */
425 }
426
427 /*
428 * Delete any additional segments.
429 *
430 * Note that because we loop until getting ENOENT, we will correctly
431 * remove all inactive segments as well as active ones. Ideally we'd
432 * continue the loop until getting exactly that errno, but that risks an
433 * infinite loop if the problem is directory-wide (for instance, if we
434 * suddenly can't read the data directory itself). We compromise by
435 * continuing after a non-ENOENT truncate error, but stopping after any
436 * unlink error. If there is indeed a directory-wide problem, additional
437 * unlink attempts wouldn't work anyway.
438 */
440 {
442 BlockNumber segno;
443
444 for (segno = 1;; segno++)
445 {
447
449 {
450 /*
451 * Prevent other backends' fds from holding on to the disk
452 * space. We're done if we see ENOENT, though.
453 */
455 break;
456
457 /*
458 * Forget any pending sync requests for this segment before we
459 * try to unlink.
460 */
461 register_forget_request(rlocator, forknum, segno);
462 }
463
465 {
466 /* ENOENT is expected after the last segment... */
469 (errcode_for_file_access(),
471 break;
472 }
473 }
474 }
475}
References do_truncate(), ereport, errcode_for_file_access(), errmsg(), fb(), IsBinaryUpgrade, MAIN_FORKNUM, register_forget_request(), register_unlink_segment(), RelFileLocatorBackendIsTemp, relpath, sprintf, RelPathStr::str, and WARNING.
Referenced by mdunlink().
◆ mdwriteback()
| void mdwriteback | ( | SMgrRelation | reln, |
| ForkNumber | forknum, | ||
| BlockNumber | blocknum, | ||
| BlockNumber | nblocks | ||
| ) |
Definition at line 1164 of file md.c.
1166{
1168
1169 /*
1170 * Issue flush requests in as few requests as possible; have to split at
1171 * segment boundaries though, since those are actually separate files.
1172 */
1173 while (nblocks > 0)
1174 {
1176 pgoff_t seekpos;
1177 MdfdVec *v;
1179 segnum_end;
1180
1182 EXTENSION_DONT_OPEN);
1183
1184 /*
1185 * We might be flushing buffers of already removed relations, that's
1186 * ok, just ignore that case. If the segment file wasn't open already
1187 * (ie from a recent mdwrite()), then we don't want to re-open it, to
1188 * avoid a race with PROCSIGNAL_BARRIER_SMGRRELEASE that might leave
1189 * us with a descriptor to a file that is about to be unlinked.
1190 */
1191 if (!v)
1192 return;
1193
1194 /* compute offset inside the current segment */
1196
1197 /* compute number of desired writes within the current segment */
1201
1204
1206
1208
1209 nblocks -= nflush;
1210 blocknum += nflush;
1211 }
1212}
References _mdfd_getseg(), Assert, EXTENSION_DONT_OPEN, fb(), FileWriteback(), IO_DIRECT_DATA, io_direct_flags, and _MdfdVec::mdfd_vfd.
◆ mdwritev()
| void mdwritev | ( | SMgrRelation | reln, |
| ForkNumber | forknum, | ||
| BlockNumber | blocknum, | ||
| const void ** | buffers, | ||
| BlockNumber | nblocks, | ||
| bool | skipFsync | ||
| ) |
Definition at line 1059 of file md.c.
1061{
1062 /* This assert is too expensive to have on normally ... */
1063#ifdef CHECK_WRITE_VS_EXTEND
1065#endif
1066
1067 while (nblocks > 0)
1068 {
1071 pgoff_t seekpos;
1072 int nbytes;
1073 MdfdVec *v;
1077
1080
1082
1084
1085 nblocks_this_segment =
1086 Min(nblocks,
1089
1092
1095 transferred_this_segment = 0;
1096
1097 /*
1098 * Inner loop to continue after a short write. If the reason is that
1099 * we're out of disk space, a future attempt should get an ENOSPC
1100 * error from the kernel.
1101 */
1102 for (;;)
1103 {
1104 TRACE_POSTGRESQL_SMGR_MD_WRITE_START(forknum, blocknum,
1105 reln->smgr_rlocator.locator.spcOid,
1106 reln->smgr_rlocator.locator.dbOid,
1107 reln->smgr_rlocator.locator.relNumber,
1108 reln->smgr_rlocator.backend);
1110 WAIT_EVENT_DATA_FILE_WRITE);
1111 TRACE_POSTGRESQL_SMGR_MD_WRITE_DONE(forknum, blocknum,
1112 reln->smgr_rlocator.locator.spcOid,
1113 reln->smgr_rlocator.locator.dbOid,
1114 reln->smgr_rlocator.locator.relNumber,
1115 reln->smgr_rlocator.backend,
1116 nbytes,
1118
1119#ifdef SIMULATE_SHORT_WRITE
1120 nbytes = Min(nbytes, 4096);
1121#endif
1122
1123 if (nbytes < 0)
1124 {
1126
1128 (errcode_for_file_access(),
1130 blocknum,
1131 blocknum + nblocks_this_segment - 1,
1134 }
1135
1136 /* One loop should usually be enough. */
1137 transferred_this_segment += nbytes;
1140 break;
1141
1142 /* Adjust position and iovecs after a short write. */
1143 seekpos += nbytes;
1145 }
1146
1149
1150 nblocks -= nblocks_this_segment;
1151 buffers += nblocks_this_segment;
1152 blocknum += nblocks_this_segment;
1153 }
1154}
References _mdfd_getseg(), Assert, buffers_to_iovec(), compute_remaining_iovec(), elog, ereport, errcode_for_file_access(), errhint(), errmsg(), ERROR, EXTENSION_CREATE_RECOVERY, EXTENSION_FAIL, fb(), FilePathName(), FileWriteV(), lengthof, _MdfdVec::mdfd_vfd, mdnblocks(), Min, PG_IOV_MAX, register_dirty_segment(), and SmgrIsTemp.
◆ mdzeroextend()
| void mdzeroextend | ( | SMgrRelation | reln, |
| ForkNumber | forknum, | ||
| BlockNumber | blocknum, | ||
| int | nblocks, | ||
| bool | skipFsync | ||
| ) |
Definition at line 552 of file md.c.
554{
555 MdfdVec *v;
558
559 Assert(nblocks > 0);
560
561 /* This assert is too expensive to have on normally ... */
562#ifdef CHECK_WRITE_VS_EXTEND
564#endif
565
566 /*
567 * If a relation manages to grow to 2^32-1 blocks, refuse to extend it any
568 * more --- we mustn't create a block whose number actually is
569 * InvalidBlockNumber or larger.
570 */
576 InvalidBlockNumber)));
577
579 {
583
586 else
588
590
593
594 /*
595 * If available and useful, use posix_fallocate() (via
596 * FileFallocate()) to extend the relation. That's often more
597 * efficient than using write(), as it commonly won't cause the kernel
598 * to allocate page cache space for the extended pages.
599 *
600 * However, we don't use FileFallocate() for small extensions, as it
601 * defeats delayed allocation on some filesystems. Not clear where
602 * that decision should be made though? For now just use a cutoff of
603 * 8, anything between 4 and 8 worked OK in some local testing.
604 */
606 {
607 int ret;
608
612 if (ret != 0)
613 {
615 errcode_for_file_access(),
619 }
620 }
621 else
622 {
623 int ret;
624
625 /*
626 * Even if we don't want to use fallocate, we can still extend a
627 * bit more efficiently than writing each 8kB block individually.
628 * pg_pwrite_zeros() (via FileZero()) uses pg_pwritev_with_retry()
629 * to avoid multiple writes or needing a zeroed buffer for the
630 * whole length of the extension.
631 */
635 if (ret < 0)
637 errcode_for_file_access(),
641 }
642
645
647
650 }
651}
References _mdfd_getseg(), _mdnblocks(), Assert, ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, EXTENSION_CREATE, fb(), FileFallocate(), FilePathName(), FileZero(), InvalidBlockNumber, _MdfdVec::mdfd_vfd, mdnblocks(), register_dirty_segment(), relpath, and SmgrIsTemp.
◆ register_dirty_segment()
|
static |
Definition at line 1507 of file md.c.
1508{
1509 FileTag tag;
1510
1512
1513 /* Temp relations should never be fsync'd */
1515
1517 {
1519
1522
1524
1527 (errcode_for_file_access(),
1530
1531 /*
1532 * We have no way of knowing if the current IOContext is
1533 * IOCONTEXT_NORMAL or IOCONTEXT_[BULKREAD, BULKWRITE, VACUUM] at this
1534 * point, so count the fsync as being in the IOCONTEXT_NORMAL
1535 * IOContext. This is probably okay, because the number of backend
1536 * fsyncs doesn't say anything about the efficacy of the
1537 * BufferAccessStrategy. And counting both fsyncs done in
1538 * IOCONTEXT_NORMAL and IOCONTEXT_[BULKREAD, BULKWRITE, VACUUM] under
1539 * IOCONTEXT_NORMAL is likely clearer when investigating the number of
1540 * backend fsyncs.
1541 */
1544 }
1545}
References Assert, data_sync_elevel(), DEBUG1, ereport, errcode_for_file_access(), errmsg(), errmsg_internal(), ERROR, fb(), FilePathName(), FileSync(), INIT_MD_FILETAG, IOCONTEXT_NORMAL, IOOBJECT_RELATION, IOOP_FSYNC, _MdfdVec::mdfd_segno, _MdfdVec::mdfd_vfd, pgstat_count_io_op_time(), pgstat_prepare_io_time(), RegisterSyncRequest(), SmgrIsTemp, SYNC_REQUEST, and track_io_timing.
Referenced by mdcreate(), mdextend(), mdregistersync(), mdtruncate(), mdwritev(), and mdzeroextend().
◆ register_forget_request()
|
static |
Definition at line 1568 of file md.c.
References INIT_MD_FILETAG, RelFileLocatorBackend::locator, RegisterSyncRequest(), and SYNC_FORGET_REQUEST.
Referenced by mdunlinkfork().
◆ register_unlink_segment()
|
static |
Definition at line 1551 of file md.c.
References Assert, INIT_MD_FILETAG, RelFileLocatorBackend::locator, RegisterSyncRequest(), RelFileLocatorBackendIsTemp, and SYNC_UNLINK_REQUEST.
Referenced by mdunlinkfork().
◆ StaticAssertDecl()
| StaticAssertDecl | ( | RELSEG_SIZE | , |
| 0 &&RELSEG_SIZE<= | INT_MAX, | ||
| "RELSEG_SIZE must fit in an integer" | |||
| ) |
Variable Documentation
◆ aio_md_readv_cb
| const PgAioHandleCallbacks aio_md_readv_cb |
Initial value:
◆ MdCxt
|
static |
Definition at line 97 of file md.c.
Referenced by _fdvec_resize(), and mdinit().
