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 */
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 int 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 int 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_segment() -- Schedule a file to be deleted after next checkpoint
1559 */
1560static void
1562 BlockNumber segno)
1563{
1564 FileTag tag;
1565
1567
1568 /* Should never be used with temp relations */
1570
1572}
1573
1574/*
1575 * register_forget_request() -- forget any fsyncs for a relation fork's segment
1576 */
1577static void
1579 BlockNumber segno)
1580{
1581 FileTag tag;
1582
1584
1586}
1587
1588/*
1589 * ForgetDatabaseSyncRequests -- forget any fsyncs and unlinks for a DB
1590 */
1591void
1593{
1594 FileTag tag;
1595 RelFileLocator rlocator;
1596
1597 rlocator.dbOid = dbid;
1598 rlocator.spcOid = 0;
1599 rlocator.relNumber = 0;
1600
1602
1604}
1605
1606/*
1607 * DropRelationFiles -- drop files of all given relations
1608 */
1609void
1611{
1614
1617 {
1619
1621 {
1623
1626 }
1628 }
1629
1631
1635}
1636
1637
1638/*
1639 * _fdvec_resize() -- Resize the fork's open segments array
1640 */
1641static void
1643 ForkNumber forknum,
1645{
1647 {
1649 {
1652 }
1653 }
1655 {
1656 reln->md_seg_fds[forknum] =
1658 }
1660 {
1661 /*
1662 * It doesn't seem worthwhile complicating the code to amortize
1663 * repalloc() calls. Those are far faster than PathNameOpenFile() or
1664 * FileClose(), and the memory context internally will sometimes avoid
1665 * doing an actual reallocation.
1666 */
1667 reln->md_seg_fds[forknum] =
1670 }
1671 else
1672 {
1673 /*
1674 * We don't reallocate a smaller array, because we want mdtruncate()
1675 * to be able to promise that it won't allocate memory, so that it is
1676 * allowed in a critical section. This means that a bit of space in
1677 * the array is now wasted, until the next time we add a segment and
1678 * reallocate.
1679 */
1680 }
1681
1683}
1684
1685/*
1686 * Return the filename for the specified segment of the relation. The
1687 * returned string is palloc'd.
1688 */
1691{
1692 RelPathStr path;
1693 MdPathStr fullpath;
1694
1696
1697 if (segno > 0)
1699 else
1701
1702 return fullpath;
1703}
1704
1705/*
1706 * Open the specified segment of the relation,
1707 * and make a MdfdVec object for it. Returns NULL on failure.
1708 */
1712{
1713 MdfdVec *v;
1715 MdPathStr fullpath;
1716
1718
1719 /* open the file */
1721
1724
1725 /*
1726 * Segments are always opened in order from lowest to highest, so we must
1727 * be adding a new one at the end.
1728 */
1730
1732
1733 /* fill the entry */
1734 v = &reln->md_seg_fds[forknum][segno];
1736 v->mdfd_segno = segno;
1737
1739
1740 /* all done */
1741 return v;
1742}
1743
1744/*
1745 * _mdfd_getseg() -- Find the segment of the relation holding the
1746 * specified block.
1747 *
1748 * If the segment doesn't exist, we ereport, return NULL, or create the
1749 * segment, according to "behavior". Note: skipFsync is only used in the
1750 * EXTENSION_CREATE case.
1751 */
1755{
1756 MdfdVec *v;
1759
1760 /* some way to handle non-existent segments needs to be specified */
1761 Assert(behavior &
1763 EXTENSION_DONT_OPEN));
1764
1766
1767 /* if an existing and opened segment, we're done */
1769 {
1771 return v;
1772 }
1773
1774 /* The caller only wants the segment if we already had it open. */
1777
1778 /*
1779 * The target segment is not yet open. Iterate over all the segments
1780 * between the last opened and the target segment. This way missing
1781 * segments either raise an error, or get created (according to
1782 * 'behavior'). Start with either the last opened, or the first segment if
1783 * none was opened before.
1784 */
1787 else
1788 {
1790 if (!v)
1792 }
1793
1796 {
1798 int flags = 0;
1799
1801
1804
1807 {
1808 /*
1809 * Normally we will create new segments only if authorized by the
1810 * caller (i.e., we are doing mdextend()). But when doing WAL
1811 * recovery, create segments anyway; this allows cases such as
1812 * replaying WAL data that has a write into a high-numbered
1813 * segment of a relation that was later deleted. We want to go
1814 * ahead and create the segments so we can finish out the replay.
1815 *
1816 * We have to maintain the invariant that segments before the last
1817 * active segment are of size RELSEG_SIZE; therefore, if
1818 * extending, pad them out with zeroes if needed. (This only
1819 * matters if in recovery, or if the caller is extending the
1820 * relation discontiguously, but that can happen in hash indexes.)
1821 */
1823 {
1825 MCXT_ALLOC_ZERO);
1826
1831 }
1832 flags = O_CREAT;
1833 }
1835 {
1836 /*
1837 * When not extending, only open the next segment if the current
1838 * one is exactly RELSEG_SIZE. If not (this branch), either
1839 * return NULL or fail.
1840 */
1842 {
1843 /*
1844 * Some callers discern between reasons for _mdfd_getseg()
1845 * returning NULL based on errno. As there's no failing
1846 * syscall involved in this case, explicitly set errno to
1847 * ENOENT, as that seems the closest interpretation.
1848 */
1851 }
1852
1854 (errcode_for_file_access(),
1857 blkno, nblocks)));
1858 }
1859
1861
1863 {
1868 (errcode_for_file_access(),
1871 blkno)));
1872 }
1873 }
1874
1875 return v;
1876}
1877
1878/*
1879 * Get number of blocks present in a single disk file
1880 */
1883{
1885
1889 (errcode_for_file_access(),
1892 /* note that this calculation will ignore any partial block at EOF */
1894}
1895
1896/*
1897 * Sync a file to disk, given a file tag. Write the path into an output
1898 * buffer so the caller can use it in error messages.
1899 *
1900 * Return 0 on success, -1 on failure, with errno set.
1901 */
1902int
1904{
1906 File file;
1909 int result,
1910 save_errno;
1911
1912 /* See if we already have the file open, or need to open it. */
1914 {
1918 }
1919 else
1920 {
1921 MdPathStr p;
1922
1925
1927 if (file < 0)
1928 return -1;
1930 }
1931
1933
1934 /* Sync the file. */
1937
1939 FileClose(file);
1940
1943
1945 return result;
1946}
1947
1948/*
1949 * Unlink a file, given a file tag. Write the path into an output
1950 * buffer so the caller can use it in error messages.
1951 *
1952 * Return 0 on success, -1 on failure, with errno set.
1953 */
1954int
1956{
1957 RelPathStr p;
1958
1959 /* Compute the path. */
1962
1963 /* Try to unlink the file. */
1965}
1966
1967/*
1968 * Check if a given candidate request matches a given tag, when processing
1969 * a SYNC_FILTER_REQUEST request. This will be called for all pending
1970 * requests to find out whether to forget them.
1971 */
1972bool
1974{
1975 /*
1976 * For now we only use filter requests as a way to drop all scheduled
1977 * callbacks relating to a given database, when dropping the database.
1978 * We'll return true for all candidates that have the same database OID as
1979 * the ftag from the SYNC_FILTER_REQUEST request, so they're forgotten.
1980 */
1982}
1983
1984/*
1985 * AIO completion callback for mdstartreadv().
1986 */
1989{
1992
1994 {
1997 /* For "hard" errors, track the error number in error_data */
1999 result.result = 0;
2000
2001 /*
2002 * Immediately log a message about the IO error, but only to the
2003 * server log. The reason to do so immediately is that the originator
2004 * might not process the query result immediately (because it is busy
2005 * doing another part of query processing) or at all (e.g. if it was
2006 * cancelled or errored out due to another IO also failing). The
2007 * definer of the IO will emit an ERROR when processing the IO's
2008 * results
2009 */
2011
2012 return result;
2013 }
2014
2015 /*
2016 * As explained above smgrstartreadv(), the smgr API operates on the level
2017 * of blocks, rather than bytes. Convert.
2018 */
2020
2022
2024 {
2025 /* consider 0 blocks read a failure */
2028 result.error_data = 0;
2029
2030 /* see comment above the "hard error" case */
2032
2033 return result;
2034 }
2035
2038 {
2039 /* partial reads should be retried at upper level */
2042 }
2043
2044 return result;
2045}
2046
2047/*
2048 * AIO error reporting callback for mdstartreadv().
2049 *
2050 * Errors are encoded as follows:
2051 * - PgAioResult.error_data != 0 encodes IO that failed with that errno
2052 * - PgAioResult.error_data == 0 encodes IO that didn't read all data
2053 */
2054static void
2056{
2057 RelPathStr path;
2058
2061 td->smgr.forkNum);
2062
2064 {
2065 /* for errcode_for_file_access() and %m */
2067
2068 ereport(elevel,
2069 errcode_for_file_access(),
2073 path.str));
2074 }
2075 else
2076 {
2077 /*
2078 * NB: This will typically only be output in debug messages, while
2079 * retrying a partial IO.
2080 */
2081 ereport(elevel,
2086 path.str,
2089 }
2090}
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:2122
int FileStartReadV(PgAioHandle *ioh, File file, int iovcnt, pgoff_t offset, uint32 wait_event_info)
Definition fd.c:2204
ssize_t FileReadV(File file, const struct iovec *iov, int iovcnt, pgoff_t offset, uint32 wait_event_info)
Definition fd.c:2148
int FileFallocate(File file, pgoff_t offset, pgoff_t amount, uint32 wait_event_info)
Definition fd.c:2407
int FileZero(File file, pgoff_t offset, pgoff_t amount, uint32 wait_event_info)
Definition fd.c:2362
int FilePrefetch(File file, pgoff_t offset, pgoff_t amount, uint32 wait_event_info)
Definition fd.c:2066
ssize_t FileWriteV(File file, const struct iovec *iov, int iovcnt, pgoff_t offset, uint32 wait_event_info)
Definition fd.c:2230
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:2056
static void register_forget_request(RelFileLocatorBackend rlocator, ForkNumber forknum, BlockNumber segno)
Definition md.c:1579
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:1883
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:1974
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:1691
static void register_unlink_segment(RelFileLocatorBackend rlocator, ForkNumber forknum, BlockNumber segno)
Definition md.c:1562
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:1989
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:1711
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:1754
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:1611
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:1643
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 1643 of file md.c.
1646{
1648 {
1650 {
1653 }
1654 }
1656 {
1657 reln->md_seg_fds[forknum] =
1659 }
1661 {
1662 /*
1663 * It doesn't seem worthwhile complicating the code to amortize
1664 * repalloc() calls. Those are far faster than PathNameOpenFile() or
1665 * FileClose(), and the memory context internally will sometimes avoid
1666 * doing an actual reallocation.
1667 */
1668 reln->md_seg_fds[forknum] =
1671 }
1672 else
1673 {
1674 /*
1675 * We don't reallocate a smaller array, because we want mdtruncate()
1676 * to be able to promise that it won't allocate memory, so that it is
1677 * allowed in a critical section. This means that a bit of space in
1678 * the array is now wasted, until the next time we add a segment and
1679 * reallocate.
1680 */
1681 }
1682
1684}
References fb(), MdCxt, MemoryContextAlloc(), pfree(), and repalloc().
Referenced by _mdfd_openseg(), mdclose(), mdcreate(), mdimmedsync(), mdopenfork(), mdregistersync(), and mdtruncate().
◆ _mdfd_getseg()
|
static |
Definition at line 1754 of file md.c.
1756{
1757 MdfdVec *v;
1760
1761 /* some way to handle non-existent segments needs to be specified */
1762 Assert(behavior &
1764 EXTENSION_DONT_OPEN));
1765
1767
1768 /* if an existing and opened segment, we're done */
1770 {
1772 return v;
1773 }
1774
1775 /* The caller only wants the segment if we already had it open. */
1778
1779 /*
1780 * The target segment is not yet open. Iterate over all the segments
1781 * between the last opened and the target segment. This way missing
1782 * segments either raise an error, or get created (according to
1783 * 'behavior'). Start with either the last opened, or the first segment if
1784 * none was opened before.
1785 */
1788 else
1789 {
1791 if (!v)
1793 }
1794
1797 {
1799 int flags = 0;
1800
1802
1805
1808 {
1809 /*
1810 * Normally we will create new segments only if authorized by the
1811 * caller (i.e., we are doing mdextend()). But when doing WAL
1812 * recovery, create segments anyway; this allows cases such as
1813 * replaying WAL data that has a write into a high-numbered
1814 * segment of a relation that was later deleted. We want to go
1815 * ahead and create the segments so we can finish out the replay.
1816 *
1817 * We have to maintain the invariant that segments before the last
1818 * active segment are of size RELSEG_SIZE; therefore, if
1819 * extending, pad them out with zeroes if needed. (This only
1820 * matters if in recovery, or if the caller is extending the
1821 * relation discontiguously, but that can happen in hash indexes.)
1822 */
1824 {
1826 MCXT_ALLOC_ZERO);
1827
1832 }
1833 flags = O_CREAT;
1834 }
1836 {
1837 /*
1838 * When not extending, only open the next segment if the current
1839 * one is exactly RELSEG_SIZE. If not (this branch), either
1840 * return NULL or fail.
1841 */
1843 {
1844 /*
1845 * Some callers discern between reasons for _mdfd_getseg()
1846 * returning NULL based on errno. As there's no failing
1847 * syscall involved in this case, explicitly set errno to
1848 * ENOENT, as that seems the closest interpretation.
1849 */
1852 }
1853
1855 (errcode_for_file_access(),
1858 blkno, nblocks)));
1859 }
1860
1862
1864 {
1869 (errcode_for_file_access(),
1872 blkno)));
1873 }
1874 }
1875
1876 return v;
1877}
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 1711 of file md.c.
1713{
1714 MdfdVec *v;
1716 MdPathStr fullpath;
1717
1719
1720 /* open the file */
1722
1725
1726 /*
1727 * Segments are always opened in order from lowest to highest, so we must
1728 * be adding a new one at the end.
1729 */
1731
1733
1734 /* fill the entry */
1735 v = &reln->md_seg_fds[forknum][segno];
1737 v->mdfd_segno = segno;
1738
1740
1741 /* all done */
1742 return v;
1743}
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 1691 of file md.c.
1692{
1693 RelPathStr path;
1694 MdPathStr fullpath;
1695
1697
1698 if (segno > 0)
1700 else
1702
1703 return fullpath;
1704}
References fb(), relpath, sprintf, MdPathStr::str, and RelPathStr::str.
Referenced by _mdfd_getseg(), _mdfd_openseg(), and mdsyncfiletag().
◆ _mdnblocks()
|
static |
Definition at line 1883 of file md.c.
1884{
1886
1890 (errcode_for_file_access(),
1893 /* note that this calculation will ignore any partial block at EOF */
1895}
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 1611 of file md.c.
1612{
1615
1618 {
1620
1622 {
1624
1627 }
1629 }
1630
1632
1636}
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 1593 of file md.c.
1594{
1595 FileTag tag;
1596 RelFileLocator rlocator;
1597
1598 rlocator.dbOid = dbid;
1599 rlocator.spcOid = 0;
1600 rlocator.relNumber = 0;
1601
1603
1605}
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 1989 of file md.c.
1990{
1993
1995 {
1998 /* For "hard" errors, track the error number in error_data */
2000 result.result = 0;
2001
2002 /*
2003 * Immediately log a message about the IO error, but only to the
2004 * server log. The reason to do so immediately is that the originator
2005 * might not process the query result immediately (because it is busy
2006 * doing another part of query processing) or at all (e.g. if it was
2007 * cancelled or errored out due to another IO also failing). The
2008 * definer of the IO will emit an ERROR when processing the IO's
2009 * results
2010 */
2012
2013 return result;
2014 }
2015
2016 /*
2017 * As explained above smgrstartreadv(), the smgr API operates on the level
2018 * of blocks, rather than bytes. Convert.
2019 */
2021
2023
2025 {
2026 /* consider 0 blocks read a failure */
2029 result.error_data = 0;
2030
2031 /* see comment above the "hard error" case */
2033
2034 return result;
2035 }
2036
2039 {
2040 /* partial reads should be retried at upper level */
2043 }
2044
2045 return result;
2046}
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 2056 of file md.c.
2057{
2058 RelPathStr path;
2059
2062 td->smgr.forkNum);
2063
2065 {
2066 /* for errcode_for_file_access() and %m */
2068
2069 ereport(elevel,
2070 errcode_for_file_access(),
2074 path.str));
2075 }
2076 else
2077 {
2078 /*
2079 * NB: This will typically only be output in debug messages, while
2080 * retrying a partial IO.
2081 */
2082 ereport(elevel,
2087 path.str,
2090 }
2091}
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 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 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 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 1974 of file md.c.
1975{
1976 /*
1977 * For now we only use filter requests as a way to drop all scheduled
1978 * callbacks relating to a given database, when dropping the database.
1979 * We'll return true for all candidates that have the same database OID as
1980 * the ftag from the SYNC_FILTER_REQUEST request, so they're forgotten.
1981 */
1983}
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 int 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 1904 of file md.c.
1905{
1907 File file;
1910 int result,
1911 save_errno;
1912
1913 /* See if we already have the file open, or need to open it. */
1915 {
1919 }
1920 else
1921 {
1922 MdPathStr p;
1923
1926
1928 if (file < 0)
1929 return -1;
1931 }
1932
1934
1935 /* Sync the file. */
1938
1940 FileClose(file);
1941
1944
1946 return result;
1947}
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 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 1956 of file md.c.
1957{
1958 RelPathStr p;
1959
1960 /* Compute the path. */
1963
1964 /* Try to unlink the file. */
1966}
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 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 int 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 1579 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 1562 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().
