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 "utils/wait_event.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 102 of file md.c.
139{
141} MdPathStr;
142
143
144/* local routines */
149 MdfdVec *seg);
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 */
422 register_unlink_tombstone(rlocator);
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 ssize_t 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 */
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 */
606 {
607 int ret = 0;
608
609#ifdef HAVE_POSIX_FALLOCATE
611 {
615 }
616 else
617#endif
618 {
620 file_extend_method);
621 }
622 if (ret != 0)
623 {
625 errcode_for_file_access(),
629 }
630 }
631 else
632 {
633 int ret;
634
635 /*
636 * Even if we don't want to use fallocate, we can still extend a
637 * bit more efficiently than writing each 8kB block individually.
638 * pg_pwrite_zeros() (via FileZero()) uses pg_pwritev_with_retry()
639 * to avoid multiple writes or needing a zeroed buffer for the
640 * whole length of the extension.
641 */
645 if (ret < 0)
647 errcode_for_file_access(),
651 }
652
655
657
660 }
661}
662
663/*
664 * mdopenfork() -- Open one fork of the specified relation.
665 *
666 * Note we only open the first segment, when there are multiple segments.
667 *
668 * If first segment is not present, either ereport or return NULL according
669 * to "behavior". We treat EXTENSION_CREATE the same as EXTENSION_FAIL;
670 * EXTENSION_CREATE means it's OK to extend an existing relation, not to
671 * invent one out of whole cloth.
672 */
675{
677 RelPathStr path;
679
680 /* No work if already open */
683
685
687
689 {
694 (errcode_for_file_access(),
696 }
697
701 mdfd->mdfd_segno = 0;
702
704
706}
707
708/*
709 * mdopen() -- Initialize newly-opened relation.
710 */
711void
713{
714 /* mark it not open */
716 reln->md_num_open_segs[forknum] = 0;
717}
718
719/*
720 * mdclose() -- Close the specified relation, if it isn't closed already.
721 */
722void
724{
726
727 /* No work if already closed */
729 return;
730
731 /* close segments starting from the end */
733 {
735
738 nopensegs--;
739 }
740}
741
742/*
743 * mdprefetch() -- Initiate asynchronous read of the specified blocks of a relation
744 */
745bool
747 int nblocks)
748{
749#ifdef USE_PREFETCH
750
752
754 return false;
755
756 while (nblocks > 0)
757 {
758 pgoff_t seekpos;
759 MdfdVec *v;
761
765 return false;
766
768
770
771 nblocks_this_segment =
772 Min(nblocks,
774
777
778 blocknum += nblocks_this_segment;
779 nblocks -= nblocks_this_segment;
780 }
781#endif /* USE_PREFETCH */
782
783 return true;
784}
785
786/*
787 * Convert an array of buffer address into an array of iovec objects, and
788 * return the number that were required. 'iov' must have enough space for up
789 * to 'nblocks' elements, but the number used may be less depending on
790 * merging. In the case of a run of fully contiguous buffers, a single iovec
791 * will be populated that can be handled as a plain non-vectored I/O.
792 */
793static int
795{
798
799 Assert(nblocks >= 1);
800
801 /* If this build supports direct I/O, buffers must be I/O aligned. */
803 {
807 }
808
809 /* Start the first iovec off with the first buffer. */
811 iovp->iov_base = buffers[0];
813 iovcnt = 1;
814
815 /* Try to merge the rest. */
817 {
819
821 {
822 /* Contiguous with the last iovec. */
824 }
825 else
826 {
827 /* Need a new iovec. */
828 iovp++;
829 iovp->iov_base = buffer;
831 iovcnt++;
832 }
833 }
834
836}
837
838/*
839 * mdmaxcombine() -- Return the maximum number of total blocks that can be
840 * combined with an IO starting at blocknum.
841 */
842uint32
844 BlockNumber blocknum)
845{
846 BlockNumber segoff;
847
849
851}
852
853/*
854 * mdreadv() -- Read the specified blocks from a relation.
855 */
856void
859{
860 while (nblocks > 0)
861 {
864 pgoff_t seekpos;
865 ssize_t nbytes;
866 MdfdVec *v;
870
873
875
877
878 nblocks_this_segment =
879 Min(nblocks,
882
885
888 transferred_this_segment = 0;
889
890 /*
891 * Inner loop to continue after a short read. We'll keep going until
892 * we hit EOF rather than assuming that a short read means we hit the
893 * end.
894 */
895 for (;;)
896 {
897 TRACE_POSTGRESQL_SMGR_MD_READ_START(forknum, blocknum,
898 reln->smgr_rlocator.locator.spcOid,
899 reln->smgr_rlocator.locator.dbOid,
900 reln->smgr_rlocator.locator.relNumber,
901 reln->smgr_rlocator.backend);
904 TRACE_POSTGRESQL_SMGR_MD_READ_DONE(forknum, blocknum,
905 reln->smgr_rlocator.locator.spcOid,
906 reln->smgr_rlocator.locator.dbOid,
907 reln->smgr_rlocator.locator.relNumber,
908 reln->smgr_rlocator.backend,
909 nbytes,
911
912#ifdef SIMULATE_SHORT_READ
913 nbytes = Min(nbytes, 4096);
914#endif
915
916 if (nbytes < 0)
918 (errcode_for_file_access(),
920 blocknum,
921 blocknum + nblocks_this_segment - 1,
923
924 if (nbytes == 0)
925 {
926 /*
927 * We are at or past EOF, or we read a partial block at EOF.
928 * Normally this is an error; upper levels should never try to
929 * read a nonexistent block. However, if zero_damaged_pages
930 * is ON or we are InRecovery, we should instead return zeroes
931 * without complaining. This allows, for example, the case of
932 * trying to update a block that was later truncated away.
933 *
934 * NB: We think that this codepath is unreachable in recovery
935 * and incomplete with zero_damaged_pages, as missing segments
936 * are not created. Putting blocks into the buffer-pool that
937 * do not exist on disk is rather problematic, as it will not
938 * be found by scans that rely on smgrnblocks(), as they are
939 * beyond EOF. It also can cause weird problems with relation
940 * extension, as relation extension does not expect blocks
941 * beyond EOF to exist.
942 *
943 * Therefore we do not want to copy the logic into
944 * mdstartreadv(), where it would have to be more complicated
945 * due to potential differences in the zero_damaged_pages
946 * setting between the definer and completor of IO.
947 *
948 * For PG 18, we are putting an Assert(false) in mdreadv()
949 * (triggering failures in assertion-enabled builds, but
950 * continuing to work in production builds). Afterwards we
951 * plan to remove this code entirely.
952 */
954 {
956
959 ++i)
961 break;
962 }
963 else
967 blocknum,
968 blocknum + nblocks_this_segment - 1,
971 size_this_segment)));
972 }
973
974 /* One loop should usually be enough. */
975 transferred_this_segment += nbytes;
978 break;
979
980 /* Adjust position and vectors after a short read. */
981 seekpos += nbytes;
983 }
984
985 nblocks -= nblocks_this_segment;
986 buffers += nblocks_this_segment;
987 blocknum += nblocks_this_segment;
988 }
989}
990
991/*
992 * mdstartreadv() -- Asynchronous version of mdreadv().
993 */
994void
998{
999 pgoff_t seekpos;
1000 MdfdVec *v;
1004 int ret;
1005
1008
1010
1012
1013 nblocks_this_segment =
1014 Min(nblocks,
1016
1019
1021
1023
1025
1027
1030
1032 reln,
1033 forknum,
1034 blocknum,
1035 nblocks,
1036 false);
1038
1040 if (ret != 0)
1042 (errcode_for_file_access(),
1044 blocknum,
1045 blocknum + nblocks_this_segment - 1,
1047
1048 /*
1049 * The error checks corresponding to the post-read checks in mdreadv() are
1050 * in md_readv_complete().
1051 *
1052 * However we chose, at least for now, to not implement the
1053 * zero_damaged_pages logic present in mdreadv(). As outlined in mdreadv()
1054 * that logic is rather problematic, and we want to get rid of it. Here
1055 * equivalent logic would have to be more complicated due to potential
1056 * differences in the zero_damaged_pages setting between the definer and
1057 * completor of IO.
1058 */
1059}
1060
1061/*
1062 * mdwritev() -- Write the supplied blocks at the appropriate location.
1063 *
1064 * This is to be used only for updating already-existing blocks of a
1065 * relation (ie, those before the current EOF). To extend a relation,
1066 * use mdextend().
1067 */
1068void
1071{
1072 /* This assert is too expensive to have on normally ... */
1073#ifdef CHECK_WRITE_VS_EXTEND
1075#endif
1076
1077 while (nblocks > 0)
1078 {
1081 pgoff_t seekpos;
1082 ssize_t nbytes;
1083 MdfdVec *v;
1087
1090
1092
1094
1095 nblocks_this_segment =
1096 Min(nblocks,
1099
1102
1105 transferred_this_segment = 0;
1106
1107 /*
1108 * Inner loop to continue after a short write. If the reason is that
1109 * we're out of disk space, a future attempt should get an ENOSPC
1110 * error from the kernel.
1111 */
1112 for (;;)
1113 {
1114 TRACE_POSTGRESQL_SMGR_MD_WRITE_START(forknum, blocknum,
1115 reln->smgr_rlocator.locator.spcOid,
1116 reln->smgr_rlocator.locator.dbOid,
1117 reln->smgr_rlocator.locator.relNumber,
1118 reln->smgr_rlocator.backend);
1120 WAIT_EVENT_DATA_FILE_WRITE);
1121 TRACE_POSTGRESQL_SMGR_MD_WRITE_DONE(forknum, blocknum,
1122 reln->smgr_rlocator.locator.spcOid,
1123 reln->smgr_rlocator.locator.dbOid,
1124 reln->smgr_rlocator.locator.relNumber,
1125 reln->smgr_rlocator.backend,
1126 nbytes,
1128
1129#ifdef SIMULATE_SHORT_WRITE
1130 nbytes = Min(nbytes, 4096);
1131#endif
1132
1133 if (nbytes < 0)
1134 {
1136
1138 (errcode_for_file_access(),
1140 blocknum,
1141 blocknum + nblocks_this_segment - 1,
1144 }
1145
1146 /* One loop should usually be enough. */
1147 transferred_this_segment += nbytes;
1150 break;
1151
1152 /* Adjust position and iovecs after a short write. */
1153 seekpos += nbytes;
1155 }
1156
1159
1160 nblocks -= nblocks_this_segment;
1161 buffers += nblocks_this_segment;
1162 blocknum += nblocks_this_segment;
1163 }
1164}
1165
1166
1167/*
1168 * mdwriteback() -- Tell the kernel to write pages back to storage.
1169 *
1170 * This accepts a range of blocks because flushing several pages at once is
1171 * considerably more efficient than doing so individually.
1172 */
1173void
1176{
1178
1179 /*
1180 * Issue flush requests in as few requests as possible; have to split at
1181 * segment boundaries though, since those are actually separate files.
1182 */
1183 while (nblocks > 0)
1184 {
1186 pgoff_t seekpos;
1187 MdfdVec *v;
1189 segnum_end;
1190
1192 EXTENSION_DONT_OPEN);
1193
1194 /*
1195 * We might be flushing buffers of already removed relations, that's
1196 * ok, just ignore that case. If the segment file wasn't open already
1197 * (ie from a recent mdwrite()), then we don't want to re-open it, to
1198 * avoid a race with PROCSIGNAL_BARRIER_SMGRRELEASE that might leave
1199 * us with a descriptor to a file that is about to be unlinked.
1200 */
1201 if (!v)
1202 return;
1203
1204 /* compute offset inside the current segment */
1206
1207 /* compute number of desired writes within the current segment */
1211
1214
1216
1218
1219 nblocks -= nflush;
1220 blocknum += nflush;
1221 }
1222}
1223
1224/*
1225 * mdnblocks() -- Get the number of blocks stored in a relation.
1226 *
1227 * Important side effect: all active segments of the relation are opened
1228 * and added to the md_seg_fds array. If this routine has not been
1229 * called, then only segments up to the last one actually touched
1230 * are present in the array.
1231 */
1232BlockNumber
1234{
1235 MdfdVec *v;
1236 BlockNumber nblocks;
1237 BlockNumber segno;
1238
1240
1241 /* mdopen has opened the first segment */
1243
1244 /*
1245 * Start from the last open segments, to avoid redundant seeks. We have
1246 * previously verified that these segments are exactly RELSEG_SIZE long,
1247 * and it's useless to recheck that each time.
1248 *
1249 * NOTE: this assumption could only be wrong if another backend has
1250 * truncated the relation. We rely on higher code levels to handle that
1251 * scenario by closing and re-opening the md fd, which is handled via
1252 * relcache flush. (Since the checkpointer doesn't participate in
1253 * relcache flush, it could have segment entries for inactive segments;
1254 * that's OK because the checkpointer never needs to compute relation
1255 * size.)
1256 */
1257 segno = reln->md_num_open_segs[forknum] - 1;
1258 v = &reln->md_seg_fds[forknum][segno];
1259
1260 for (;;)
1261 {
1267
1268 /*
1269 * If segment is exactly RELSEG_SIZE, advance to next one.
1270 */
1271 segno++;
1272
1273 /*
1274 * We used to pass O_CREAT here, but that has the disadvantage that it
1275 * might create a segment which has vanished through some operating
1276 * system misadventure. In such a case, creating the segment here
1277 * undermines _mdfd_getseg's attempts to notice and report an error
1278 * upon access to a missing segment.
1279 */
1283 }
1284}
1285
1286/*
1287 * mdtruncate() -- Truncate relation to specified number of blocks.
1288 *
1289 * Guaranteed not to allocate memory, so it can be used in a critical section.
1290 * Caller must have called smgrnblocks() to obtain curnblk while holding a
1291 * sufficient lock to prevent a change in relation size, and not used any smgr
1292 * functions for this relation or handled interrupts in between. This makes
1293 * sure we have opened all active segments, so that truncate loop will get
1294 * them all!
1295 *
1296 * If nblocks > curnblk, the request is ignored when we are InRecovery,
1297 * otherwise, an error is raised.
1298 */
1299void
1302{
1305
1307 {
1308 /* Bogus request ... but no complaint if InRecovery */
1310 return;
1314 nblocks, curnblk)));
1315 }
1317 return; /* no work */
1318
1319 /*
1320 * Truncate segments, starting at the last one. Starting at the end makes
1321 * managing the memory for the fd array easier, should there be errors.
1322 */
1325 {
1326 MdfdVec *v;
1327
1329
1331
1333 {
1334 /*
1335 * This segment is no longer active. We truncate the file, but do
1336 * not delete it, for reasons explained in the header comments.
1337 */
1340 (errcode_for_file_access(),
1343
1346
1347 /* we never drop the 1st segment */
1349
1352 }
1354 {
1355 /*
1356 * This is the last segment we want to keep. Truncate the file to
1357 * the right length. NOTE: if nblocks is exactly a multiple K of
1358 * RELSEG_SIZE, we will truncate the K+1st segment to 0 length but
1359 * keep it. This adheres to the invariant given in the header
1360 * comments.
1361 */
1363
1364 if (FileTruncate(v->mdfd_vfd, (pgoff_t) lastsegblocks * BLCKSZ, WAIT_EVENT_DATA_FILE_TRUNCATE) < 0)
1366 (errcode_for_file_access(),
1369 nblocks)));
1372 }
1373 else
1374 {
1375 /*
1376 * We still need this segment, so nothing to do for this and any
1377 * earlier segment.
1378 */
1379 break;
1380 }
1381 curopensegs--;
1382 }
1383}
1384
1385/*
1386 * mdregistersync() -- Mark whole relation as needing fsync
1387 */
1388void
1390{
1391 int segno;
1393
1394 /*
1395 * NOTE: mdnblocks makes sure we have opened all active segments, so that
1396 * the loop below will get them all!
1397 */
1399
1401
1402 /*
1403 * Temporarily open inactive segments, then close them after sync. There
1404 * may be some inactive segments left opened after error, but that is
1405 * harmless. We don't bother to clean them up and take a risk of further
1406 * trouble. The next mdclose() will soon close them.
1407 */
1409 segno++;
1410
1411 while (segno > 0)
1412 {
1414
1416
1417 /* Close inactive segments immediately */
1419 {
1422 }
1423
1424 segno--;
1425 }
1426}
1427
1428/*
1429 * mdimmedsync() -- Immediately sync a relation to stable storage.
1430 *
1431 * Note that only writes already issued are synced; this routine knows
1432 * nothing of dirty buffers that may exist inside the buffer manager. We
1433 * sync active and inactive segments; smgrDoPendingSyncs() relies on this.
1434 * Consider a relation skipping WAL. Suppose a checkpoint syncs blocks of
1435 * some segment, then mdtruncate() renders that segment inactive. If we
1436 * crash before the next checkpoint syncs the newly-inactive segment, that
1437 * segment may survive recovery, reintroducing unwanted data into the table.
1438 */
1439void
1441{
1442 int segno;
1444
1445 /*
1446 * NOTE: mdnblocks makes sure we have opened all active segments, so that
1447 * the loop below will get them all!
1448 */
1450
1452
1453 /*
1454 * Temporarily open inactive segments, then close them after sync. There
1455 * may be some inactive segments left opened after fsync() error, but that
1456 * is harmless. We don't bother to clean them up and take a risk of
1457 * further trouble. The next mdclose() will soon close them.
1458 */
1460 segno++;
1461
1462 while (segno > 0)
1463 {
1465
1466 /*
1467 * fsyncs done through mdimmedsync() should be tracked in a separate
1468 * IOContext than those done through mdsyncfiletag() to differentiate
1469 * between unavoidable client backend fsyncs (e.g. those done during
1470 * index build) and those which ideally would have been done by the
1471 * checkpointer. Since other IO operations bypassing the buffer
1472 * manager could also be tracked in such an IOContext, wait until
1473 * these are also tracked to track immediate fsyncs.
1474 */
1477 (errcode_for_file_access(),
1480
1481 /* Close inactive segments immediately */
1483 {
1486 }
1487
1488 segno--;
1489 }
1490}
1491
1492int
1494{
1496
1498 EXTENSION_FAIL);
1499
1501
1503
1505}
1506
1507/*
1508 * register_dirty_segment() -- Mark a relation segment as needing fsync
1509 *
1510 * If there is a local pending-ops table, just make an entry in it for
1511 * ProcessSyncRequests to process later. Otherwise, try to pass off the
1512 * fsync request to the checkpointer process. If that fails, just do the
1513 * fsync locally before returning (we hope this will not happen often
1514 * enough to be a performance problem).
1515 */
1516static void
1518{
1519 FileTag tag;
1520
1522
1523 /* Temp relations should never be fsync'd */
1525
1527 {
1529
1532
1534
1537 (errcode_for_file_access(),
1540
1541 /*
1542 * We have no way of knowing if the current IOContext is
1543 * IOCONTEXT_NORMAL or IOCONTEXT_[BULKREAD, BULKWRITE, VACUUM] at this
1544 * point, so count the fsync as being in the IOCONTEXT_NORMAL
1545 * IOContext. This is probably okay, because the number of backend
1546 * fsyncs doesn't say anything about the efficacy of the
1547 * BufferAccessStrategy. And counting both fsyncs done in
1548 * IOCONTEXT_NORMAL and IOCONTEXT_[BULKREAD, BULKWRITE, VACUUM] under
1549 * IOCONTEXT_NORMAL is likely clearer when investigating the number of
1550 * backend fsyncs.
1551 */
1554 }
1555}
1556
1557/*
1558 * register_unlink_tombstone() -- Schedule a tombstone file to be deleted
1559 *
1560 * A tombstone file is an empty first segment of a relation that has already
1561 * been dropped (see mdunlink()). This function schedules it to be deleted
1562 * after the next checkpoint.
1563 */
1564static void
1566{
1567 FileTag tag;
1568
1570
1571 /* Should never be used with temp relations */
1573
1575}
1576
1577/*
1578 * register_forget_request() -- forget any fsyncs for a relation fork's segment
1579 */
1580static void
1582 BlockNumber segno)
1583{
1584 FileTag tag;
1585
1587
1589}
1590
1591/*
1592 * ForgetDatabaseSyncRequests -- forget any fsyncs and unlinks for a DB
1593 */
1594void
1596{
1597 FileTag tag;
1598 RelFileLocator rlocator;
1599
1600 rlocator.dbOid = dbid;
1601 rlocator.spcOid = 0;
1602 rlocator.relNumber = 0;
1603
1605
1607}
1608
1609/*
1610 * DropRelationFiles -- drop files of all given relations
1611 */
1612void
1614{
1617
1620 {
1622
1624 {
1626
1629 }
1631 }
1632
1634
1638}
1639
1640
1641/*
1642 * _fdvec_resize() -- Resize the fork's open segments array
1643 */
1644static void
1646 ForkNumber forknum,
1648{
1650 {
1652 {
1655 }
1656 }
1658 {
1659 reln->md_seg_fds[forknum] =
1661 }
1663 {
1664 /*
1665 * It doesn't seem worthwhile complicating the code to amortize
1666 * repalloc() calls. Those are far faster than PathNameOpenFile() or
1667 * FileClose(), and the memory context internally will sometimes avoid
1668 * doing an actual reallocation.
1669 */
1670 reln->md_seg_fds[forknum] =
1673 }
1674 else
1675 {
1676 /*
1677 * We don't reallocate a smaller array, because we want mdtruncate()
1678 * to be able to promise that it won't allocate memory, so that it is
1679 * allowed in a critical section. This means that a bit of space in
1680 * the array is now wasted, until the next time we add a segment and
1681 * reallocate.
1682 */
1683 }
1684
1686}
1687
1688/*
1689 * Return the filename for the specified segment of the relation. The
1690 * returned string is palloc'd.
1691 */
1694{
1695 RelPathStr path;
1696 MdPathStr fullpath;
1697
1699
1700 if (segno > 0)
1702 else
1704
1705 return fullpath;
1706}
1707
1708/*
1709 * Open the specified segment of the relation,
1710 * and make a MdfdVec object for it. Returns NULL on failure.
1711 */
1715{
1716 MdfdVec *v;
1718 MdPathStr fullpath;
1719
1721
1722 /* open the file */
1724
1727
1728 /*
1729 * Segments are always opened in order from lowest to highest, so we must
1730 * be adding a new one at the end.
1731 */
1733
1735
1736 /* fill the entry */
1737 v = &reln->md_seg_fds[forknum][segno];
1739 v->mdfd_segno = segno;
1740
1742
1743 /* all done */
1744 return v;
1745}
1746
1747/*
1748 * _mdfd_getseg() -- Find the segment of the relation holding the
1749 * specified block.
1750 *
1751 * If the segment doesn't exist, we ereport, return NULL, or create the
1752 * segment, according to "behavior". Note: skipFsync is only used in the
1753 * EXTENSION_CREATE case.
1754 */
1758{
1759 MdfdVec *v;
1762
1763 /* some way to handle non-existent segments needs to be specified */
1764 Assert(behavior &
1766 EXTENSION_DONT_OPEN));
1767
1769
1770 /* if an existing and opened segment, we're done */
1772 {
1774 return v;
1775 }
1776
1777 /* The caller only wants the segment if we already had it open. */
1780
1781 /*
1782 * The target segment is not yet open. Iterate over all the segments
1783 * between the last opened and the target segment. This way missing
1784 * segments either raise an error, or get created (according to
1785 * 'behavior'). Start with either the last opened, or the first segment if
1786 * none was opened before.
1787 */
1790 else
1791 {
1793 if (!v)
1795 }
1796
1799 {
1801 int flags = 0;
1802
1804
1807
1810 {
1811 /*
1812 * Normally we will create new segments only if authorized by the
1813 * caller (i.e., we are doing mdextend()). But when doing WAL
1814 * recovery, create segments anyway; this allows cases such as
1815 * replaying WAL data that has a write into a high-numbered
1816 * segment of a relation that was later deleted. We want to go
1817 * ahead and create the segments so we can finish out the replay.
1818 *
1819 * We have to maintain the invariant that segments before the last
1820 * active segment are of size RELSEG_SIZE; therefore, if
1821 * extending, pad them out with zeroes if needed. (This only
1822 * matters if in recovery, or if the caller is extending the
1823 * relation discontiguously, but that can happen in hash indexes.)
1824 */
1826 {
1828 MCXT_ALLOC_ZERO);
1829
1834 }
1835 flags = O_CREAT;
1836 }
1838 {
1839 /*
1840 * When not extending, only open the next segment if the current
1841 * one is exactly RELSEG_SIZE. If not (this branch), either
1842 * return NULL or fail.
1843 */
1845 {
1846 /*
1847 * Some callers discern between reasons for _mdfd_getseg()
1848 * returning NULL based on errno. As there's no failing
1849 * syscall involved in this case, explicitly set errno to
1850 * ENOENT, as that seems the closest interpretation.
1851 */
1854 }
1855
1857 (errcode_for_file_access(),
1860 blkno, nblocks)));
1861 }
1862
1864
1866 {
1871 (errcode_for_file_access(),
1874 blkno)));
1875 }
1876 }
1877
1878 return v;
1879}
1880
1881/*
1882 * Get number of blocks present in a single disk file
1883 */
1886{
1888
1892 (errcode_for_file_access(),
1895 /* note that this calculation will ignore any partial block at EOF */
1897}
1898
1899/*
1900 * Sync a file to disk, given a file tag. Write the path into an output
1901 * buffer so the caller can use it in error messages.
1902 *
1903 * Return 0 on success, -1 on failure, with errno set.
1904 */
1905int
1907{
1909 File file;
1913 save_errno;
1914
1915 /* See if we already have the file open, or need to open it. */
1917 {
1921 }
1922 else
1923 {
1924 MdPathStr p;
1925
1928
1930 if (file < 0)
1931 return -1;
1933 }
1934
1936
1937 /* Sync the file. */
1940
1942 FileClose(file);
1943
1946
1949}
1950
1951/*
1952 * Unlink a file, given a file tag. Write the path into an output
1953 * buffer so the caller can use it in error messages.
1954 *
1955 * Return 0 on success, -1 on failure, with errno set.
1956 */
1957int
1959{
1960 RelPathStr p;
1961
1962 /* We only unlink tombstone files through this mechanism */
1964
1965 /* Compute the path. */
1968
1969 /* Try to unlink the file. */
1971}
1972
1973/*
1974 * Check if a given candidate request matches a given tag, when processing
1975 * a SYNC_FILTER_REQUEST request. This will be called for all pending
1976 * requests to find out whether to forget them.
1977 */
1978bool
1980{
1981 /*
1982 * For now we only use filter requests as a way to drop all scheduled
1983 * callbacks relating to a given database, when dropping the database.
1984 * We'll return true for all candidates that have the same database OID as
1985 * the ftag from the SYNC_FILTER_REQUEST request, so they're forgotten.
1986 */
1988}
1989
1990/*
1991 * AIO completion callback for mdstartreadv().
1992 */
1995{
1998
2000 {
2003 /* For "hard" errors, track the error number in error_data */
2005 result.result = 0;
2006
2007 /*
2008 * Immediately log a message about the IO error, but only to the
2009 * server log. The reason to do so immediately is that the originator
2010 * might not process the query result immediately (because it is busy
2011 * doing another part of query processing) or at all (e.g. if it was
2012 * cancelled or errored out due to another IO also failing). The
2013 * definer of the IO will emit an ERROR when processing the IO's
2014 * results
2015 */
2017
2019 }
2020
2021 /*
2022 * As explained above smgrstartreadv(), the smgr API operates on the level
2023 * of blocks, rather than bytes. Convert.
2024 */
2026
2028
2030 {
2031 /* consider 0 blocks read a failure */
2034 result.error_data = 0;
2035
2036 /* see comment above the "hard error" case */
2038
2040 }
2041
2044 {
2045 /* partial reads should be retried at upper level */
2048 }
2049
2051}
2052
2053/*
2054 * AIO error reporting callback for mdstartreadv().
2055 *
2056 * Errors are encoded as follows:
2057 * - PgAioResult.error_data != 0 encodes IO that failed with that errno
2058 * - PgAioResult.error_data == 0 encodes IO that didn't read all data
2059 */
2060static void
2062{
2063 RelPathStr path;
2064
2067 td->smgr.forkNum);
2068
2070 {
2071 /* for errcode_for_file_access() and %m */
2073
2074 ereport(elevel,
2075 errcode_for_file_access(),
2079 path.str));
2080 }
2081 else
2082 {
2083 /*
2084 * NB: This will typically only be output in debug messages, while
2085 * retrying a partial IO.
2086 */
2087 ereport(elevel,
2092 path.str,
2095 }
2096}
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:114
int errhint(const char *fmt,...) pg_attribute_printf(1
int int errmsg_internal(const char *fmt,...) pg_attribute_printf(1
void FileWriteback(File file, pgoff_t offset, pgoff_t nbytes, uint32 wait_event_info)
Definition fd.c:2123
int FileStartReadV(PgAioHandle *ioh, File file, int iovcnt, pgoff_t offset, uint32 wait_event_info)
Definition fd.c:2205
ssize_t FileReadV(File file, const struct iovec *iov, int iovcnt, pgoff_t offset, uint32 wait_event_info)
Definition fd.c:2149
int FileFallocate(File file, pgoff_t offset, pgoff_t amount, uint32 wait_event_info)
Definition fd.c:2408
int FileZero(File file, pgoff_t offset, pgoff_t amount, uint32 wait_event_info)
Definition fd.c:2363
int FilePrefetch(File file, pgoff_t offset, pgoff_t amount, uint32 wait_event_info)
Definition fd.c:2067
ssize_t FileWriteV(File file, const struct iovec *iov, int iovcnt, pgoff_t offset, uint32 wait_event_info)
Definition fd.c:2231
static ssize_t FileWrite(File file, const void *buffer, size_t amount, pgoff_t offset, uint32 wait_event_info)
Definition fd.h:237
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:2062
static void register_forget_request(RelFileLocatorBackend rlocator, ForkNumber forknum, BlockNumber segno)
Definition md.c:1582
void mdtruncate(SMgrRelation reln, ForkNumber forknum, BlockNumber curnblk, BlockNumber nblocks)
Definition md.c:1301
static BlockNumber _mdnblocks(SMgrRelation reln, ForkNumber forknum, MdfdVec *seg)
Definition md.c:1886
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:1070
bool mdfiletagmatches(const FileTag *ftag, const FileTag *candidate)
Definition md.c:1980
void mdreadv(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, void **buffers, BlockNumber nblocks)
Definition md.c:858
static MdPathStr _mdfd_segpath(SMgrRelation reln, ForkNumber forknum, BlockNumber segno)
Definition md.c:1694
int mdfd(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, uint32 *off)
Definition md.c:1494
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:1995
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:1714
static void register_dirty_segment(SMgrRelation reln, ForkNumber forknum, MdfdVec *seg)
Definition md.c:1518
void mdwriteback(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, BlockNumber nblocks)
Definition md.c:1175
uint32 mdmaxcombine(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
Definition md.c:844
static MdfdVec * _mdfd_getseg(SMgrRelation reln, ForkNumber forknum, BlockNumber blkno, bool skipFsync, int behavior)
Definition md.c:1757
void mdstartreadv(PgAioHandle *ioh, SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, void **buffers, BlockNumber nblocks)
Definition md.c:996
bool mdprefetch(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, int nblocks)
Definition md.c:747
static MdfdVec * mdopenfork(SMgrRelation reln, ForkNumber forknum, int behavior)
Definition md.c:675
void DropRelationFiles(RelFileLocator *delrels, int ndelrels, bool isRedo)
Definition md.c:1614
static int buffers_to_iovec(struct iovec *iov, void **buffers, int nblocks)
Definition md.c:795
static void _fdvec_resize(SMgrRelation reln, ForkNumber forknum, int nseg)
Definition md.c:1646
static void register_unlink_tombstone(RelFileLocatorBackend rlocator)
Definition md.c:1566
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:105
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:77
bool RegisterSyncRequest(const FileTag *ftag, SyncRequestType type, bool retryOnError)
Definition sync.c:581
Definition aio_types.h:62
struct PgAioTargetData::@129 smgr
void XLogDropRelation(RelFileLocator rlocator, ForkNumber forknum)
Definition xlogutils.c:654
◆ MD_PATH_STR_MAXLEN
| #define MD_PATH_STR_MAXLEN |
Value:
◆ SEGMENT_CHARS
Typedef Documentation
◆ MdfdVec
◆ MdPathStr
Function Documentation
◆ _fdvec_resize()
|
static |
Definition at line 1646 of file md.c.
1649{
1651 {
1653 {
1656 }
1657 }
1659 {
1660 reln->md_seg_fds[forknum] =
1662 }
1664 {
1665 /*
1666 * It doesn't seem worthwhile complicating the code to amortize
1667 * repalloc() calls. Those are far faster than PathNameOpenFile() or
1668 * FileClose(), and the memory context internally will sometimes avoid
1669 * doing an actual reallocation.
1670 */
1671 reln->md_seg_fds[forknum] =
1674 }
1675 else
1676 {
1677 /*
1678 * We don't reallocate a smaller array, because we want mdtruncate()
1679 * to be able to promise that it won't allocate memory, so that it is
1680 * allowed in a critical section. This means that a bit of space in
1681 * the array is now wasted, until the next time we add a segment and
1682 * reallocate.
1683 */
1684 }
1685
1687}
References fb(), MdCxt, MemoryContextAlloc(), pfree(), and repalloc().
Referenced by _mdfd_openseg(), mdclose(), mdcreate(), mdimmedsync(), mdopenfork(), mdregistersync(), and mdtruncate().
◆ _mdfd_getseg()
|
static |
Definition at line 1757 of file md.c.
1759{
1760 MdfdVec *v;
1763
1764 /* some way to handle non-existent segments needs to be specified */
1765 Assert(behavior &
1767 EXTENSION_DONT_OPEN));
1768
1770
1771 /* if an existing and opened segment, we're done */
1773 {
1775 return v;
1776 }
1777
1778 /* The caller only wants the segment if we already had it open. */
1781
1782 /*
1783 * The target segment is not yet open. Iterate over all the segments
1784 * between the last opened and the target segment. This way missing
1785 * segments either raise an error, or get created (according to
1786 * 'behavior'). Start with either the last opened, or the first segment if
1787 * none was opened before.
1788 */
1791 else
1792 {
1794 if (!v)
1796 }
1797
1800 {
1802 int flags = 0;
1803
1805
1808
1811 {
1812 /*
1813 * Normally we will create new segments only if authorized by the
1814 * caller (i.e., we are doing mdextend()). But when doing WAL
1815 * recovery, create segments anyway; this allows cases such as
1816 * replaying WAL data that has a write into a high-numbered
1817 * segment of a relation that was later deleted. We want to go
1818 * ahead and create the segments so we can finish out the replay.
1819 *
1820 * We have to maintain the invariant that segments before the last
1821 * active segment are of size RELSEG_SIZE; therefore, if
1822 * extending, pad them out with zeroes if needed. (This only
1823 * matters if in recovery, or if the caller is extending the
1824 * relation discontiguously, but that can happen in hash indexes.)
1825 */
1827 {
1829 MCXT_ALLOC_ZERO);
1830
1835 }
1836 flags = O_CREAT;
1837 }
1839 {
1840 /*
1841 * When not extending, only open the next segment if the current
1842 * one is exactly RELSEG_SIZE. If not (this branch), either
1843 * return NULL or fail.
1844 */
1846 {
1847 /*
1848 * Some callers discern between reasons for _mdfd_getseg()
1849 * returning NULL based on errno. As there's no failing
1850 * syscall involved in this case, explicitly set errno to
1851 * ENOENT, as that seems the closest interpretation.
1852 */
1855 }
1856
1858 (errcode_for_file_access(),
1861 blkno, nblocks)));
1862 }
1863
1865
1867 {
1872 (errcode_for_file_access(),
1875 blkno)));
1876 }
1877 }
1878
1879 return v;
1880}
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 1714 of file md.c.
1716{
1717 MdfdVec *v;
1719 MdPathStr fullpath;
1720
1722
1723 /* open the file */
1725
1728
1729 /*
1730 * Segments are always opened in order from lowest to highest, so we must
1731 * be adding a new one at the end.
1732 */
1734
1736
1737 /* fill the entry */
1738 v = &reln->md_seg_fds[forknum][segno];
1740 v->mdfd_segno = segno;
1741
1743
1744 /* all done */
1745 return v;
1746}
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 1694 of file md.c.
1695{
1696 RelPathStr path;
1697 MdPathStr fullpath;
1698
1700
1701 if (segno > 0)
1703 else
1705
1706 return fullpath;
1707}
References fb(), relpath, sprintf, MdPathStr::str, and RelPathStr::str.
Referenced by _mdfd_getseg(), _mdfd_openseg(), and mdsyncfiletag().
◆ _mdnblocks()
|
static |
Definition at line 1886 of file md.c.
1887{
1889
1893 (errcode_for_file_access(),
1896 /* note that this calculation will ignore any partial block at EOF */
1898}
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 795 of file md.c.
796{
799
800 Assert(nblocks >= 1);
801
802 /* If this build supports direct I/O, buffers must be I/O aligned. */
804 {
808 }
809
810 /* Start the first iovec off with the first buffer. */
812 iovp->iov_base = buffers[0];
814 iovcnt = 1;
815
816 /* Try to merge the rest. */
818 {
820
822 {
823 /* Contiguous with the last iovec. */
825 }
826 else
827 {
828 /* Need a new iovec. */
829 iovp++;
830 iovp->iov_base = buffer;
832 iovcnt++;
833 }
834 }
835
837}
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 1614 of file md.c.
1615{
1618
1621 {
1623
1625 {
1627
1630 }
1632 }
1633
1635
1639}
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 1596 of file md.c.
1597{
1598 FileTag tag;
1599 RelFileLocator rlocator;
1600
1601 rlocator.dbOid = dbid;
1602 rlocator.spcOid = 0;
1603 rlocator.relNumber = 0;
1604
1606
1608}
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 1995 of file md.c.
1996{
1999
2001 {
2004 /* For "hard" errors, track the error number in error_data */
2006 result.result = 0;
2007
2008 /*
2009 * Immediately log a message about the IO error, but only to the
2010 * server log. The reason to do so immediately is that the originator
2011 * might not process the query result immediately (because it is busy
2012 * doing another part of query processing) or at all (e.g. if it was
2013 * cancelled or errored out due to another IO also failing). The
2014 * definer of the IO will emit an ERROR when processing the IO's
2015 * results
2016 */
2018
2020 }
2021
2022 /*
2023 * As explained above smgrstartreadv(), the smgr API operates on the level
2024 * of blocks, rather than bytes. Convert.
2025 */
2027
2029
2031 {
2032 /* consider 0 blocks read a failure */
2035 result.error_data = 0;
2036
2037 /* see comment above the "hard error" case */
2039
2041 }
2042
2045 {
2046 /* partial reads should be retried at upper level */
2049 }
2050
2052}
References Assert, fb(), LOG_SERVER_ONLY, PgAioTargetData::nblocks, PGAIO_HCB_MD_READV, pgaio_io_get_target_data(), pgaio_result_report(), PGAIO_RS_ERROR, PGAIO_RS_PARTIAL, result, PgAioTargetData::smgr, and PgAioResult::status.
◆ md_readv_report()
|
static |
Definition at line 2062 of file md.c.
2063{
2064 RelPathStr path;
2065
2068 td->smgr.forkNum);
2069
2071 {
2072 /* for errcode_for_file_access() and %m */
2074
2075 ereport(elevel,
2076 errcode_for_file_access(),
2080 path.str));
2081 }
2082 else
2083 {
2084 /*
2085 * NB: This will typically only be output in debug messages, while
2086 * retrying a partial IO.
2087 */
2088 ereport(elevel,
2093 path.str,
2096 }
2097}
References PgAioTargetData::blockNum, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errcode_for_file_access(), errmsg, fb(), PgAioTargetData::forkNum, INVALID_PROC_NUMBER, PgAioTargetData::is_temp, MyProcNumber, PgAioTargetData::nblocks, relpathbackend, result, PgAioTargetData::rlocator, PgAioTargetData::smgr, and RelPathStr::str.
◆ mdclose()
| void mdclose | ( | SMgrRelation | reln, |
| ForkNumber | forknum | ||
| ) |
Definition at line 724 of file md.c.
725{
727
728 /* No work if already closed */
730 return;
731
732 /* close segments starting from the end */
734 {
736
739 nopensegs--;
740 }
741}
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 ssize_t 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 */
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 1494 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 1980 of file md.c.
1981{
1982 /*
1983 * For now we only use filter requests as a way to drop all scheduled
1984 * callbacks relating to a given database, when dropping the database.
1985 * We'll return true for all candidates that have the same database OID as
1986 * the ftag from the SYNC_FILTER_REQUEST request, so they're forgotten.
1987 */
1989}
References RelFileLocator::dbOid, fb(), and FileTag::rlocator.
◆ mdimmedsync()
| void mdimmedsync | ( | SMgrRelation | reln, |
| ForkNumber | forknum | ||
| ) |
Definition at line 1441 of file md.c.
1442{
1443 int segno;
1445
1446 /*
1447 * NOTE: mdnblocks makes sure we have opened all active segments, so that
1448 * the loop below will get them all!
1449 */
1451
1453
1454 /*
1455 * Temporarily open inactive segments, then close them after sync. There
1456 * may be some inactive segments left opened after fsync() error, but that
1457 * is harmless. We don't bother to clean them up and take a risk of
1458 * further trouble. The next mdclose() will soon close them.
1459 */
1461 segno++;
1462
1463 while (segno > 0)
1464 {
1466
1467 /*
1468 * fsyncs done through mdimmedsync() should be tracked in a separate
1469 * IOContext than those done through mdsyncfiletag() to differentiate
1470 * between unavoidable client backend fsyncs (e.g. those done during
1471 * index build) and those which ideally would have been done by the
1472 * checkpointer. Since other IO operations bypassing the buffer
1473 * manager could also be tracked in such an IOContext, wait until
1474 * these are also tracked to track immediate fsyncs.
1475 */
1478 (errcode_for_file_access(),
1481
1482 /* Close inactive segments immediately */
1484 {
1487 }
1488
1489 segno--;
1490 }
1491}
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 1234 of file md.c.
1235{
1236 MdfdVec *v;
1237 BlockNumber nblocks;
1238 BlockNumber segno;
1239
1241
1242 /* mdopen has opened the first segment */
1244
1245 /*
1246 * Start from the last open segments, to avoid redundant seeks. We have
1247 * previously verified that these segments are exactly RELSEG_SIZE long,
1248 * and it's useless to recheck that each time.
1249 *
1250 * NOTE: this assumption could only be wrong if another backend has
1251 * truncated the relation. We rely on higher code levels to handle that
1252 * scenario by closing and re-opening the md fd, which is handled via
1253 * relcache flush. (Since the checkpointer doesn't participate in
1254 * relcache flush, it could have segment entries for inactive segments;
1255 * that's OK because the checkpointer never needs to compute relation
1256 * size.)
1257 */
1258 segno = reln->md_num_open_segs[forknum] - 1;
1259 v = &reln->md_seg_fds[forknum][segno];
1260
1261 for (;;)
1262 {
1268
1269 /*
1270 * If segment is exactly RELSEG_SIZE, advance to next one.
1271 */
1272 segno++;
1273
1274 /*
1275 * We used to pass O_CREAT here, but that has the disadvantage that it
1276 * might create a segment which has vanished through some operating
1277 * system misadventure. In such a case, creating the segment here
1278 * undermines _mdfd_getseg's attempts to notice and report an error
1279 * upon access to a missing segment.
1280 */
1284 }
1285}
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 713 of file md.c.
References fb(), and MAX_FORKNUM.
◆ mdopenfork()
|
static |
Definition at line 675 of file md.c.
676{
678 RelPathStr path;
680
681 /* No work if already open */
684
686
688
690 {
695 (errcode_for_file_access(),
697 }
698
702 mdfd->mdfd_segno = 0;
703
705
707}
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 747 of file md.c.
749{
750#ifdef USE_PREFETCH
751
753
755 return false;
756
757 while (nblocks > 0)
758 {
759 pgoff_t seekpos;
760 MdfdVec *v;
762
766 return false;
767
769
771
772 nblocks_this_segment =
773 Min(nblocks,
775
778
779 blocknum += nblocks_this_segment;
780 nblocks -= nblocks_this_segment;
781 }
782#endif /* USE_PREFETCH */
783
784 return true;
785}
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 858 of file md.c.
860{
861 while (nblocks > 0)
862 {
865 pgoff_t seekpos;
866 ssize_t nbytes;
867 MdfdVec *v;
871
874
876
878
879 nblocks_this_segment =
880 Min(nblocks,
883
886
889 transferred_this_segment = 0;
890
891 /*
892 * Inner loop to continue after a short read. We'll keep going until
893 * we hit EOF rather than assuming that a short read means we hit the
894 * end.
895 */
896 for (;;)
897 {
898 TRACE_POSTGRESQL_SMGR_MD_READ_START(forknum, blocknum,
899 reln->smgr_rlocator.locator.spcOid,
900 reln->smgr_rlocator.locator.dbOid,
901 reln->smgr_rlocator.locator.relNumber,
902 reln->smgr_rlocator.backend);
905 TRACE_POSTGRESQL_SMGR_MD_READ_DONE(forknum, blocknum,
906 reln->smgr_rlocator.locator.spcOid,
907 reln->smgr_rlocator.locator.dbOid,
908 reln->smgr_rlocator.locator.relNumber,
909 reln->smgr_rlocator.backend,
910 nbytes,
912
913#ifdef SIMULATE_SHORT_READ
914 nbytes = Min(nbytes, 4096);
915#endif
916
917 if (nbytes < 0)
919 (errcode_for_file_access(),
921 blocknum,
922 blocknum + nblocks_this_segment - 1,
924
925 if (nbytes == 0)
926 {
927 /*
928 * We are at or past EOF, or we read a partial block at EOF.
929 * Normally this is an error; upper levels should never try to
930 * read a nonexistent block. However, if zero_damaged_pages
931 * is ON or we are InRecovery, we should instead return zeroes
932 * without complaining. This allows, for example, the case of
933 * trying to update a block that was later truncated away.
934 *
935 * NB: We think that this codepath is unreachable in recovery
936 * and incomplete with zero_damaged_pages, as missing segments
937 * are not created. Putting blocks into the buffer-pool that
938 * do not exist on disk is rather problematic, as it will not
939 * be found by scans that rely on smgrnblocks(), as they are
940 * beyond EOF. It also can cause weird problems with relation
941 * extension, as relation extension does not expect blocks
942 * beyond EOF to exist.
943 *
944 * Therefore we do not want to copy the logic into
945 * mdstartreadv(), where it would have to be more complicated
946 * due to potential differences in the zero_damaged_pages
947 * setting between the definer and completor of IO.
948 *
949 * For PG 18, we are putting an Assert(false) in mdreadv()
950 * (triggering failures in assertion-enabled builds, but
951 * continuing to work in production builds). Afterwards we
952 * plan to remove this code entirely.
953 */
955 {
957
960 ++i)
962 break;
963 }
964 else
968 blocknum,
969 blocknum + nblocks_this_segment - 1,
972 size_this_segment)));
973 }
974
975 /* One loop should usually be enough. */
976 transferred_this_segment += nbytes;
979 break;
980
981 /* Adjust position and vectors after a short read. */
982 seekpos += nbytes;
984 }
985
986 nblocks -= nblocks_this_segment;
987 buffers += nblocks_this_segment;
988 blocknum += nblocks_this_segment;
989 }
990}
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 1390 of file md.c.
1391{
1392 int segno;
1394
1395 /*
1396 * NOTE: mdnblocks makes sure we have opened all active segments, so that
1397 * the loop below will get them all!
1398 */
1400
1402
1403 /*
1404 * Temporarily open inactive segments, then close them after sync. There
1405 * may be some inactive segments left opened after error, but that is
1406 * harmless. We don't bother to clean them up and take a risk of further
1407 * trouble. The next mdclose() will soon close them.
1408 */
1410 segno++;
1411
1412 while (segno > 0)
1413 {
1415
1417
1418 /* Close inactive segments immediately */
1420 {
1423 }
1424
1425 segno--;
1426 }
1427}
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 996 of file md.c.
999{
1000 pgoff_t seekpos;
1001 MdfdVec *v;
1005 int ret;
1006
1009
1011
1013
1014 nblocks_this_segment =
1015 Min(nblocks,
1017
1020
1022
1024
1026
1028
1031
1033 reln,
1034 forknum,
1035 blocknum,
1036 nblocks,
1037 false);
1039
1041 if (ret != 0)
1043 (errcode_for_file_access(),
1045 blocknum,
1046 blocknum + nblocks_this_segment - 1,
1048
1049 /*
1050 * The error checks corresponding to the post-read checks in mdreadv() are
1051 * in md_readv_complete().
1052 *
1053 * However we chose, at least for now, to not implement the
1054 * zero_damaged_pages logic present in mdreadv(). As outlined in mdreadv()
1055 * that logic is rather problematic, and we want to get rid of it. Here
1056 * equivalent logic would have to be more complicated due to potential
1057 * differences in the zero_damaged_pages setting between the definer and
1058 * completor of IO.
1059 */
1060}
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 1907 of file md.c.
1908{
1910 File file;
1914 save_errno;
1915
1916 /* See if we already have the file open, or need to open it. */
1918 {
1922 }
1923 else
1924 {
1925 MdPathStr p;
1926
1929
1931 if (file < 0)
1932 return -1;
1934 }
1935
1937
1938 /* Sync the file. */
1941
1943 FileClose(file);
1944
1947
1950}
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(), result, 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 1301 of file md.c.
1303{
1306
1308 {
1309 /* Bogus request ... but no complaint if InRecovery */
1311 return;
1315 nblocks, curnblk)));
1316 }
1318 return; /* no work */
1319
1320 /*
1321 * Truncate segments, starting at the last one. Starting at the end makes
1322 * managing the memory for the fd array easier, should there be errors.
1323 */
1326 {
1327 MdfdVec *v;
1328
1330
1332
1334 {
1335 /*
1336 * This segment is no longer active. We truncate the file, but do
1337 * not delete it, for reasons explained in the header comments.
1338 */
1341 (errcode_for_file_access(),
1344
1347
1348 /* we never drop the 1st segment */
1350
1353 }
1355 {
1356 /*
1357 * This is the last segment we want to keep. Truncate the file to
1358 * the right length. NOTE: if nblocks is exactly a multiple K of
1359 * RELSEG_SIZE, we will truncate the K+1st segment to 0 length but
1360 * keep it. This adheres to the invariant given in the header
1361 * comments.
1362 */
1364
1365 if (FileTruncate(v->mdfd_vfd, (pgoff_t) lastsegblocks * BLCKSZ, WAIT_EVENT_DATA_FILE_TRUNCATE) < 0)
1367 (errcode_for_file_access(),
1370 nblocks)));
1373 }
1374 else
1375 {
1376 /*
1377 * We still need this segment, so nothing to do for this and any
1378 * earlier segment.
1379 */
1380 break;
1381 }
1382 curopensegs--;
1383 }
1384}
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 1959 of file md.c.
1960{
1961 RelPathStr p;
1962
1963 /* We only unlink tombstone files through this mechanism */
1965
1966 /* Compute the path. */
1969
1970 /* Try to unlink the file. */
1972}
References Assert, fb(), FileTag::forknum, MAIN_FORKNUM, MAXPGPATH, relpathperm, FileTag::rlocator, FileTag::segno, 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 */
423 register_unlink_tombstone(rlocator);
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_tombstone(), RelFileLocatorBackendIsTemp, relpath, sprintf, RelPathStr::str, and WARNING.
Referenced by mdunlink().
◆ mdwriteback()
| void mdwriteback | ( | SMgrRelation | reln, |
| ForkNumber | forknum, | ||
| BlockNumber | blocknum, | ||
| BlockNumber | nblocks | ||
| ) |
Definition at line 1175 of file md.c.
1177{
1179
1180 /*
1181 * Issue flush requests in as few requests as possible; have to split at
1182 * segment boundaries though, since those are actually separate files.
1183 */
1184 while (nblocks > 0)
1185 {
1187 pgoff_t seekpos;
1188 MdfdVec *v;
1190 segnum_end;
1191
1193 EXTENSION_DONT_OPEN);
1194
1195 /*
1196 * We might be flushing buffers of already removed relations, that's
1197 * ok, just ignore that case. If the segment file wasn't open already
1198 * (ie from a recent mdwrite()), then we don't want to re-open it, to
1199 * avoid a race with PROCSIGNAL_BARRIER_SMGRRELEASE that might leave
1200 * us with a descriptor to a file that is about to be unlinked.
1201 */
1202 if (!v)
1203 return;
1204
1205 /* compute offset inside the current segment */
1207
1208 /* compute number of desired writes within the current segment */
1212
1215
1217
1219
1220 nblocks -= nflush;
1221 blocknum += nflush;
1222 }
1223}
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 1070 of file md.c.
1072{
1073 /* This assert is too expensive to have on normally ... */
1074#ifdef CHECK_WRITE_VS_EXTEND
1076#endif
1077
1078 while (nblocks > 0)
1079 {
1082 pgoff_t seekpos;
1083 ssize_t nbytes;
1084 MdfdVec *v;
1088
1091
1093
1095
1096 nblocks_this_segment =
1097 Min(nblocks,
1100
1103
1106 transferred_this_segment = 0;
1107
1108 /*
1109 * Inner loop to continue after a short write. If the reason is that
1110 * we're out of disk space, a future attempt should get an ENOSPC
1111 * error from the kernel.
1112 */
1113 for (;;)
1114 {
1115 TRACE_POSTGRESQL_SMGR_MD_WRITE_START(forknum, blocknum,
1116 reln->smgr_rlocator.locator.spcOid,
1117 reln->smgr_rlocator.locator.dbOid,
1118 reln->smgr_rlocator.locator.relNumber,
1119 reln->smgr_rlocator.backend);
1121 WAIT_EVENT_DATA_FILE_WRITE);
1122 TRACE_POSTGRESQL_SMGR_MD_WRITE_DONE(forknum, blocknum,
1123 reln->smgr_rlocator.locator.spcOid,
1124 reln->smgr_rlocator.locator.dbOid,
1125 reln->smgr_rlocator.locator.relNumber,
1126 reln->smgr_rlocator.backend,
1127 nbytes,
1129
1130#ifdef SIMULATE_SHORT_WRITE
1131 nbytes = Min(nbytes, 4096);
1132#endif
1133
1134 if (nbytes < 0)
1135 {
1137
1139 (errcode_for_file_access(),
1141 blocknum,
1142 blocknum + nblocks_this_segment - 1,
1145 }
1146
1147 /* One loop should usually be enough. */
1148 transferred_this_segment += nbytes;
1151 break;
1152
1153 /* Adjust position and iovecs after a short write. */
1154 seekpos += nbytes;
1156 }
1157
1160
1161 nblocks -= nblocks_this_segment;
1162 buffers += nblocks_this_segment;
1163 blocknum += nblocks_this_segment;
1164 }
1165}
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 */
607 {
608 int ret = 0;
609
610#ifdef HAVE_POSIX_FALLOCATE
612 {
616 }
617 else
618#endif
619 {
621 file_extend_method);
622 }
623 if (ret != 0)
624 {
626 errcode_for_file_access(),
630 }
631 }
632 else
633 {
634 int ret;
635
636 /*
637 * Even if we don't want to use fallocate, we can still extend a
638 * bit more efficiently than writing each 8kB block individually.
639 * pg_pwrite_zeros() (via FileZero()) uses pg_pwritev_with_retry()
640 * to avoid multiple writes or needing a zeroed buffer for the
641 * whole length of the extension.
642 */
646 if (ret < 0)
648 errcode_for_file_access(),
652 }
653
656
658
661 }
662}
References _mdfd_getseg(), _mdnblocks(), Assert, elog, ereport, errcode(), errcode_for_file_access(), errhint(), errmsg, ERROR, EXTENSION_CREATE, fb(), file_extend_method, FILE_EXTEND_METHOD_WRITE_ZEROS, FileFallocate(), FilePathName(), FileZero(), InvalidBlockNumber, _MdfdVec::mdfd_vfd, mdnblocks(), register_dirty_segment(), relpath, and SmgrIsTemp.
◆ register_dirty_segment()
|
static |
Definition at line 1518 of file md.c.
1519{
1520 FileTag tag;
1521
1523
1524 /* Temp relations should never be fsync'd */
1526
1528 {
1530
1533
1535
1538 (errcode_for_file_access(),
1541
1542 /*
1543 * We have no way of knowing if the current IOContext is
1544 * IOCONTEXT_NORMAL or IOCONTEXT_[BULKREAD, BULKWRITE, VACUUM] at this
1545 * point, so count the fsync as being in the IOCONTEXT_NORMAL
1546 * IOContext. This is probably okay, because the number of backend
1547 * fsyncs doesn't say anything about the efficacy of the
1548 * BufferAccessStrategy. And counting both fsyncs done in
1549 * IOCONTEXT_NORMAL and IOCONTEXT_[BULKREAD, BULKWRITE, VACUUM] under
1550 * IOCONTEXT_NORMAL is likely clearer when investigating the number of
1551 * backend fsyncs.
1552 */
1555 }
1556}
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 1582 of file md.c.
References INIT_MD_FILETAG, RelFileLocatorBackend::locator, RegisterSyncRequest(), and SYNC_FORGET_REQUEST.
Referenced by mdunlinkfork().
◆ register_unlink_tombstone()
|
static |
Definition at line 1566 of file md.c.
References Assert, INIT_MD_FILETAG, RelFileLocatorBackend::locator, MAIN_FORKNUM, 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 98 of file md.c.
Referenced by _fdvec_resize(), and mdinit().
