From 30707da3e5eb68d1efbc5594696da47ad7f72bab Mon Sep 17 00:00:00 2001 From: Melanie Plageman Date: Tue, 8 Feb 2022 19:01:18 -0500 Subject: [PATCH 1/4] Add unbuffered IO API Wrap unbuffered extends and writes in a new API, directmgr. When writing data outside of shared buffers, the backend must do a series of steps to ensure the data is both durable and recoverable. When writing or extending a page of data for a WAL-logged table fork, the backend must log, checksum (if page is not empty), and write out the page before moving on. Additionally, the backend must fsync the page data to ensure it reaches permanent storage since checkpointer is unaware of the buffer and could move the Redo pointer past the associated WAL for this write/extend before it fsyncs the data. This API is also used for non-WAL-logged and non-self-fsync'd table forks but with the appropriate exceptions to the above steps. This commit introduces no functional change. It replaces all current callers of smgrimmedsync(), smgrextend(), and smgrwrite() with the equivalent directmgr functions. Consolidating these steps makes IO outside of shared buffers less error-prone. --- src/backend/access/gist/gistbuild.c | 36 +++++++---- src/backend/access/hash/hashpage.c | 18 +++--- src/backend/access/heap/heapam_handler.c | 15 +++-- src/backend/access/heap/rewriteheap.c | 53 +++++---------- src/backend/access/heap/visibilitymap.c | 10 ++- src/backend/access/nbtree/nbtree.c | 18 ++---- src/backend/access/nbtree/nbtsort.c | 56 ++++++---------- src/backend/access/spgist/spginsert.c | 39 ++++------- src/backend/catalog/storage.c | 30 +++------ src/backend/storage/Makefile | 2 +- src/backend/storage/direct/Makefile | 17 +++++ src/backend/storage/direct/directmgr.c | 79 +++++++++++++++++++++++ src/backend/storage/freespace/freespace.c | 14 ++-- src/include/catalog/storage.h | 1 + src/include/storage/directmgr.h | 57 ++++++++++++++++ 15 files changed, 276 insertions(+), 169 deletions(-) create mode 100644 src/backend/storage/direct/Makefile create mode 100644 src/backend/storage/direct/directmgr.c create mode 100644 src/include/storage/directmgr.h diff --git a/src/backend/access/gist/gistbuild.c b/src/backend/access/gist/gistbuild.c index e081e6571a4..8fabc2a42d7 100644 --- a/src/backend/access/gist/gistbuild.c +++ b/src/backend/access/gist/gistbuild.c @@ -43,6 +43,7 @@ #include "miscadmin.h" #include "optimizer/optimizer.h" #include "storage/bufmgr.h" +#include "storage/directmgr.h" #include "storage/smgr.h" #include "utils/memutils.h" #include "utils/rel.h" @@ -91,6 +92,7 @@ typedef struct int64 indtuples; /* number of tuples indexed */ + UnBufferedWriteState ub_wstate; /* * Extra data structures used during a buffering build. 'gfbb' contains * information related to managing the build buffers. 'parentMap' is a @@ -409,14 +411,16 @@ gist_indexsortbuild(GISTBuildState *state) state->pages_allocated = 0; state->pages_written = 0; state->ready_num_pages = 0; + unbuffered_prep(&state->ub_wstate, false, false); /* * Write an empty page as a placeholder for the root page. It will be * replaced with the real root page at the end. */ page = palloc0(BLCKSZ); - smgrextend(RelationGetSmgr(state->indexrel), MAIN_FORKNUM, GIST_ROOT_BLKNO, - page, true); + unbuffered_extend(&state->ub_wstate, false, + RelationGetSmgr(state->indexrel), MAIN_FORKNUM, GIST_ROOT_BLKNO, + page, true); state->pages_allocated++; state->pages_written++; @@ -458,12 +462,13 @@ gist_indexsortbuild(GISTBuildState *state) /* Write out the root */ PageSetLSN(levelstate->pages[0], GistBuildLSN); - PageSetChecksumInplace(levelstate->pages[0], GIST_ROOT_BLKNO); - smgrwrite(RelationGetSmgr(state->indexrel), MAIN_FORKNUM, GIST_ROOT_BLKNO, - levelstate->pages[0], true); - if (RelationNeedsWAL(state->indexrel)) - log_newpage(&state->indexrel->rd_node, MAIN_FORKNUM, GIST_ROOT_BLKNO, - levelstate->pages[0], true); + + unbuffered_write(&state->ub_wstate, RelationNeedsWAL(state->indexrel), + RelationGetSmgr(state->indexrel), MAIN_FORKNUM, GIST_ROOT_BLKNO, + levelstate->pages[0]); + + unbuffered_finish(&state->ub_wstate, RelationGetSmgr(state->indexrel), + MAIN_FORKNUM); pfree(levelstate->pages[0]); pfree(levelstate); @@ -645,6 +650,8 @@ gist_indexsortbuild_flush_ready_pages(GISTBuildState *state) if (state->ready_num_pages == 0) return; + unbuffered_prep(&state->ub_wstate, false, false); + for (int i = 0; i < state->ready_num_pages; i++) { Page page = state->ready_pages[i]; @@ -655,9 +662,13 @@ gist_indexsortbuild_flush_ready_pages(GISTBuildState *state) elog(ERROR, "unexpected block number to flush GiST sorting build"); PageSetLSN(page, GistBuildLSN); - PageSetChecksumInplace(page, blkno); - smgrextend(RelationGetSmgr(state->indexrel), MAIN_FORKNUM, blkno, page, - true); + + /* + * These will be WAL logged below + */ + unbuffered_extend(&state->ub_wstate, false, + RelationGetSmgr(state->indexrel), MAIN_FORKNUM, blkno, page, + false); state->pages_written++; } @@ -666,6 +677,9 @@ gist_indexsortbuild_flush_ready_pages(GISTBuildState *state) log_newpages(&state->indexrel->rd_node, MAIN_FORKNUM, state->ready_num_pages, state->ready_blknos, state->ready_pages, true); + unbuffered_finish(&state->ub_wstate, RelationGetSmgr(state->indexrel), + MAIN_FORKNUM); + for (int i = 0; i < state->ready_num_pages; i++) pfree(state->ready_pages[i]); diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c index 28c5297a1dc..6096604438e 100644 --- a/src/backend/access/hash/hashpage.c +++ b/src/backend/access/hash/hashpage.c @@ -33,6 +33,7 @@ #include "access/xloginsert.h" #include "miscadmin.h" #include "port/pg_bitutils.h" +#include "storage/directmgr.h" #include "storage/lmgr.h" #include "storage/predicate.h" #include "storage/smgr.h" @@ -991,6 +992,7 @@ _hash_alloc_buckets(Relation rel, BlockNumber firstblock, uint32 nblocks) PGAlignedBlock zerobuf; Page page; HashPageOpaque ovflopaque; + UnBufferedWriteState ub_wstate; lastblock = firstblock + nblocks - 1; @@ -1001,6 +1003,8 @@ _hash_alloc_buckets(Relation rel, BlockNumber firstblock, uint32 nblocks) if (lastblock < firstblock || lastblock == InvalidBlockNumber) return false; + unbuffered_prep(&ub_wstate, false, true); + page = (Page) zerobuf.data; /* @@ -1018,16 +1022,10 @@ _hash_alloc_buckets(Relation rel, BlockNumber firstblock, uint32 nblocks) ovflopaque->hasho_flag = LH_UNUSED_PAGE; ovflopaque->hasho_page_id = HASHO_PAGE_ID; - if (RelationNeedsWAL(rel)) - log_newpage(&rel->rd_node, - MAIN_FORKNUM, - lastblock, - zerobuf.data, - true); - - PageSetChecksumInplace(page, lastblock); - smgrextend(RelationGetSmgr(rel), MAIN_FORKNUM, lastblock, zerobuf.data, - false); + unbuffered_extend(&ub_wstate, RelationNeedsWAL(rel), RelationGetSmgr(rel), + MAIN_FORKNUM, lastblock, zerobuf.data, false); + + unbuffered_finish(&ub_wstate, RelationGetSmgr(rel), MAIN_FORKNUM); return true; } diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c index 39ef8a0b77d..9fd6a6f4474 100644 --- a/src/backend/access/heap/heapam_handler.c +++ b/src/backend/access/heap/heapam_handler.c @@ -38,6 +38,7 @@ #include "pgstat.h" #include "storage/bufmgr.h" #include "storage/bufpage.h" +#include "storage/directmgr.h" #include "storage/lmgr.h" #include "storage/predicate.h" #include "storage/procarray.h" @@ -575,7 +576,9 @@ heapam_relation_set_new_filenode(Relation rel, MultiXactId *minmulti) { SMgrRelation srel; + UnBufferedWriteState ub_wstate; + unbuffered_prep(&ub_wstate, true, false); /* * Initialize to the minimum XID that could put tuples in the table. We * know that no xacts older than RecentXmin are still running, so that @@ -597,12 +600,10 @@ heapam_relation_set_new_filenode(Relation rel, /* * If required, set up an init fork for an unlogged table so that it can - * be correctly reinitialized on restart. An immediate sync is required - * even if the page has been logged, because the write did not go through - * shared_buffers and therefore a concurrent checkpoint may have moved the - * redo pointer past our xlog record. Recovery may as well remove it - * while replaying, for example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE - * record. Therefore, logging is necessary even if wal_level=minimal. + * be correctly reinitialized on restart. + * Recovery may as well remove our xlog record while replaying, for + * example, XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE record. Therefore, + * logging is necessary even if wal_level=minimal. */ if (persistence == RELPERSISTENCE_UNLOGGED) { @@ -611,7 +612,7 @@ heapam_relation_set_new_filenode(Relation rel, rel->rd_rel->relkind == RELKIND_TOASTVALUE); smgrcreate(srel, INIT_FORKNUM, false); log_smgrcreate(newrnode, INIT_FORKNUM); - smgrimmedsync(srel, INIT_FORKNUM); + unbuffered_finish(&ub_wstate, srel, INIT_FORKNUM); } smgrclose(srel); diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c index 2a53826736e..12bdd6ff601 100644 --- a/src/backend/access/heap/rewriteheap.c +++ b/src/backend/access/heap/rewriteheap.c @@ -119,6 +119,7 @@ #include "replication/logical.h" #include "replication/slot.h" #include "storage/bufmgr.h" +#include "storage/directmgr.h" #include "storage/fd.h" #include "storage/procarray.h" #include "storage/smgr.h" @@ -152,6 +153,7 @@ typedef struct RewriteStateData HTAB *rs_old_new_tid_map; /* unmatched B tuples */ HTAB *rs_logical_mappings; /* logical remapping files */ uint32 rs_num_rewrite_mappings; /* # in memory mappings */ + UnBufferedWriteState rs_unbuffered_wstate; } RewriteStateData; /* @@ -265,6 +267,9 @@ begin_heap_rewrite(Relation old_heap, Relation new_heap, TransactionId oldest_xm state->rs_cutoff_multi = cutoff_multi; state->rs_cxt = rw_cxt; + unbuffered_prep(&state->rs_unbuffered_wstate, + RelationNeedsWAL(state->rs_new_rel), false); + /* Initialize hash tables used to track update chains */ hash_ctl.keysize = sizeof(TidHashKey); hash_ctl.entrysize = sizeof(UnresolvedTupData); @@ -317,28 +322,14 @@ end_heap_rewrite(RewriteState state) /* Write the last page, if any */ if (state->rs_buffer_valid) { - if (RelationNeedsWAL(state->rs_new_rel)) - log_newpage(&state->rs_new_rel->rd_node, - MAIN_FORKNUM, - state->rs_blockno, - state->rs_buffer, - true); - - PageSetChecksumInplace(state->rs_buffer, state->rs_blockno); - - smgrextend(RelationGetSmgr(state->rs_new_rel), MAIN_FORKNUM, - state->rs_blockno, (char *) state->rs_buffer, true); + unbuffered_extend(&state->rs_unbuffered_wstate, + RelationNeedsWAL(state->rs_new_rel), + RelationGetSmgr(state->rs_new_rel), MAIN_FORKNUM, + state->rs_blockno, state->rs_buffer, false); } - /* - * When we WAL-logged rel pages, we must nonetheless fsync them. The - * reason is the same as in storage.c's RelationCopyStorage(): we're - * writing data that's not in shared buffers, and so a CHECKPOINT - * occurring during the rewriteheap operation won't have fsync'd data we - * wrote before the checkpoint. - */ - if (RelationNeedsWAL(state->rs_new_rel)) - smgrimmedsync(RelationGetSmgr(state->rs_new_rel), MAIN_FORKNUM); + unbuffered_finish(&state->rs_unbuffered_wstate, + RelationGetSmgr(state->rs_new_rel), MAIN_FORKNUM); logical_end_heap_rewrite(state); @@ -676,24 +667,10 @@ raw_heap_insert(RewriteState state, HeapTuple tup) * contains a tuple. Hence, unlike RelationGetBufferForTuple(), * enforce saveFreeSpace unconditionally. */ - - /* XLOG stuff */ - if (RelationNeedsWAL(state->rs_new_rel)) - log_newpage(&state->rs_new_rel->rd_node, - MAIN_FORKNUM, - state->rs_blockno, - page, - true); - - /* - * Now write the page. We say skipFsync = true because there's no - * need for smgr to schedule an fsync for this write; we'll do it - * ourselves in end_heap_rewrite. - */ - PageSetChecksumInplace(page, state->rs_blockno); - - smgrextend(RelationGetSmgr(state->rs_new_rel), MAIN_FORKNUM, - state->rs_blockno, (char *) page, true); + unbuffered_extend(&state->rs_unbuffered_wstate, + RelationNeedsWAL(state->rs_new_rel), + RelationGetSmgr(state->rs_new_rel), MAIN_FORKNUM, + state->rs_blockno, page, false); state->rs_blockno++; state->rs_buffer_valid = false; diff --git a/src/backend/access/heap/visibilitymap.c b/src/backend/access/heap/visibilitymap.c index e09f25a684c..897de5ec1fc 100644 --- a/src/backend/access/heap/visibilitymap.c +++ b/src/backend/access/heap/visibilitymap.c @@ -93,6 +93,7 @@ #include "miscadmin.h" #include "port/pg_bitutils.h" #include "storage/bufmgr.h" +#include "storage/directmgr.h" #include "storage/lmgr.h" #include "storage/smgr.h" #include "utils/inval.h" @@ -617,6 +618,7 @@ vm_extend(Relation rel, BlockNumber vm_nblocks) BlockNumber vm_nblocks_now; PGAlignedBlock pg; SMgrRelation reln; + UnBufferedWriteState ub_wstate; PageInit((Page) pg.data, BLCKSZ, 0); @@ -631,6 +633,7 @@ vm_extend(Relation rel, BlockNumber vm_nblocks) * by the time we get the lock. */ LockRelationForExtension(rel, ExclusiveLock); + unbuffered_prep(&ub_wstate, false, true); /* * Caution: re-using this smgr pointer could fail if the relcache entry @@ -655,12 +658,13 @@ vm_extend(Relation rel, BlockNumber vm_nblocks) /* Now extend the file */ while (vm_nblocks_now < vm_nblocks) { - PageSetChecksumInplace((Page) pg.data, vm_nblocks_now); - - smgrextend(reln, VISIBILITYMAP_FORKNUM, vm_nblocks_now, pg.data, false); + unbuffered_extend(&ub_wstate, false, reln, VISIBILITYMAP_FORKNUM, + vm_nblocks_now, (Page) pg.data, false); vm_nblocks_now++; } + unbuffered_finish(&ub_wstate, reln, VISIBILITYMAP_FORKNUM); + /* * Send a shared-inval message to force other backends to close any smgr * references they may have for this rel, which we are about to change. diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c index c9b4964c1e8..1ec7493ad39 100644 --- a/src/backend/access/nbtree/nbtree.c +++ b/src/backend/access/nbtree/nbtree.c @@ -30,6 +30,7 @@ #include "pgstat.h" #include "postmaster/autovacuum.h" #include "storage/condition_variable.h" +#include "storage/directmgr.h" #include "storage/indexfsm.h" #include "storage/ipc.h" #include "storage/lmgr.h" @@ -152,6 +153,9 @@ void btbuildempty(Relation index) { Page metapage; + UnBufferedWriteState wstate; + + unbuffered_prep(&wstate, true, false); /* Construct metapage. */ metapage = (Page) palloc(BLCKSZ); @@ -164,18 +168,10 @@ btbuildempty(Relation index) * XLOG_DBASE_CREATE or XLOG_TBLSPC_CREATE record. Therefore, we need * this even when wal_level=minimal. */ - PageSetChecksumInplace(metapage, BTREE_METAPAGE); - smgrwrite(RelationGetSmgr(index), INIT_FORKNUM, BTREE_METAPAGE, - (char *) metapage, true); - log_newpage(&RelationGetSmgr(index)->smgr_rnode.node, INIT_FORKNUM, - BTREE_METAPAGE, metapage, true); + unbuffered_write(&wstate, true, RelationGetSmgr(index), INIT_FORKNUM, + BTREE_METAPAGE, metapage); - /* - * An immediate sync is required even if we xlog'd the page, because the - * write did not go through shared_buffers and therefore a concurrent - * checkpoint may have moved the redo pointer past our xlog record. - */ - smgrimmedsync(RelationGetSmgr(index), INIT_FORKNUM); + unbuffered_finish(&wstate, RelationGetSmgr(index), INIT_FORKNUM); } /* diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c index 8a19de2f66c..c7a65a99727 100644 --- a/src/backend/access/nbtree/nbtsort.c +++ b/src/backend/access/nbtree/nbtsort.c @@ -57,6 +57,7 @@ #include "executor/instrument.h" #include "miscadmin.h" #include "pgstat.h" +#include "storage/directmgr.h" #include "storage/smgr.h" #include "tcop/tcopprot.h" /* pgrminclude ignore */ #include "utils/rel.h" @@ -256,6 +257,7 @@ typedef struct BTWriteState BlockNumber btws_pages_alloced; /* # pages allocated */ BlockNumber btws_pages_written; /* # pages written out */ Page btws_zeropage; /* workspace for filling zeroes */ + UnBufferedWriteState ub_wstate; } BTWriteState; @@ -643,13 +645,6 @@ _bt_blnewpage(uint32 level) static void _bt_blwritepage(BTWriteState *wstate, Page page, BlockNumber blkno) { - /* XLOG stuff */ - if (wstate->btws_use_wal) - { - /* We use the XLOG_FPI record type for this */ - log_newpage(&wstate->index->rd_node, MAIN_FORKNUM, blkno, page, true); - } - /* * If we have to write pages nonsequentially, fill in the space with * zeroes until we come back and overwrite. This is not logically @@ -661,32 +656,27 @@ _bt_blwritepage(BTWriteState *wstate, Page page, BlockNumber blkno) { if (!wstate->btws_zeropage) wstate->btws_zeropage = (Page) palloc0(BLCKSZ); - /* don't set checksum for all-zero page */ - smgrextend(RelationGetSmgr(wstate->index), MAIN_FORKNUM, - wstate->btws_pages_written++, - (char *) wstate->btws_zeropage, - true); + + unbuffered_extend(&wstate->ub_wstate, false, + RelationGetSmgr(wstate->index), MAIN_FORKNUM, + wstate->btws_pages_written++, wstate->btws_zeropage, true); } - PageSetChecksumInplace(page, blkno); - /* - * Now write the page. There's no need for smgr to schedule an fsync for - * this write; we'll do it ourselves before ending the build. - */ + /* Now write the page. Either we are extending the file... */ if (blkno == wstate->btws_pages_written) { - /* extending the file... */ - smgrextend(RelationGetSmgr(wstate->index), MAIN_FORKNUM, blkno, - (char *) page, true); + unbuffered_extend(&wstate->ub_wstate, wstate->btws_use_wal, + RelationGetSmgr(wstate->index), MAIN_FORKNUM, blkno, page, + false); + wstate->btws_pages_written++; } + + /* or we are overwriting a block we zero-filled before. */ else - { - /* overwriting a block we zero-filled before */ - smgrwrite(RelationGetSmgr(wstate->index), MAIN_FORKNUM, blkno, - (char *) page, true); - } + unbuffered_write(&wstate->ub_wstate, wstate->btws_use_wal, + RelationGetSmgr(wstate->index), MAIN_FORKNUM, blkno, page); pfree(page); } @@ -1195,6 +1185,9 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2) int64 tuples_done = 0; bool deduplicate; + + unbuffered_prep(&wstate->ub_wstate, wstate->btws_use_wal, false); + deduplicate = wstate->inskey->allequalimage && !btspool->isunique && BTGetDeduplicateItems(wstate->index); @@ -1421,17 +1414,8 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2) /* Close down final pages and write the metapage */ _bt_uppershutdown(wstate, state); - /* - * When we WAL-logged index pages, we must nonetheless fsync index files. - * Since we're building outside shared buffers, a CHECKPOINT occurring - * during the build has no way to flush the previously written data to - * disk (indeed it won't know the index even exists). A crash later on - * would replay WAL from the checkpoint, therefore it wouldn't replay our - * earlier WAL entries. If we do not fsync those pages here, they might - * still not be on disk when the crash occurs. - */ - if (wstate->btws_use_wal) - smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM); + unbuffered_finish(&wstate->ub_wstate, RelationGetSmgr(wstate->index), + MAIN_FORKNUM); } /* diff --git a/src/backend/access/spgist/spginsert.c b/src/backend/access/spgist/spginsert.c index bfb74049d0c..e232ba4b866 100644 --- a/src/backend/access/spgist/spginsert.c +++ b/src/backend/access/spgist/spginsert.c @@ -25,6 +25,7 @@ #include "catalog/index.h" #include "miscadmin.h" #include "storage/bufmgr.h" +#include "storage/directmgr.h" #include "storage/smgr.h" #include "utils/memutils.h" #include "utils/rel.h" @@ -156,48 +157,30 @@ void spgbuildempty(Relation index) { Page page; + UnBufferedWriteState wstate; + + unbuffered_prep(&wstate, true, false); /* Construct metapage. */ page = (Page) palloc(BLCKSZ); SpGistInitMetapage(page); - /* - * Write the page and log it unconditionally. This is important - * particularly for indexes created on tablespaces and databases whose - * creation happened after the last redo pointer as recovery removes any - * of their existing content when the corresponding create records are - * replayed. - */ - PageSetChecksumInplace(page, SPGIST_METAPAGE_BLKNO); - smgrwrite(RelationGetSmgr(index), INIT_FORKNUM, SPGIST_METAPAGE_BLKNO, - (char *) page, true); - log_newpage(&(RelationGetSmgr(index))->smgr_rnode.node, INIT_FORKNUM, - SPGIST_METAPAGE_BLKNO, page, true); + unbuffered_write(&wstate, true, RelationGetSmgr(index), INIT_FORKNUM, + SPGIST_METAPAGE_BLKNO, page); /* Likewise for the root page. */ SpGistInitPage(page, SPGIST_LEAF); - PageSetChecksumInplace(page, SPGIST_ROOT_BLKNO); - smgrwrite(RelationGetSmgr(index), INIT_FORKNUM, SPGIST_ROOT_BLKNO, - (char *) page, true); - log_newpage(&(RelationGetSmgr(index))->smgr_rnode.node, INIT_FORKNUM, - SPGIST_ROOT_BLKNO, page, true); + unbuffered_write(&wstate, true, RelationGetSmgr(index), INIT_FORKNUM, + SPGIST_ROOT_BLKNO, page); /* Likewise for the null-tuples root page. */ SpGistInitPage(page, SPGIST_LEAF | SPGIST_NULLS); - PageSetChecksumInplace(page, SPGIST_NULL_BLKNO); - smgrwrite(RelationGetSmgr(index), INIT_FORKNUM, SPGIST_NULL_BLKNO, - (char *) page, true); - log_newpage(&(RelationGetSmgr(index))->smgr_rnode.node, INIT_FORKNUM, - SPGIST_NULL_BLKNO, page, true); + unbuffered_write(&wstate, true, RelationGetSmgr(index), INIT_FORKNUM, + SPGIST_NULL_BLKNO, page); - /* - * An immediate sync is required even if we xlog'd the pages, because the - * writes did not go through shared buffers and therefore a concurrent - * checkpoint may have moved the redo pointer past our xlog record. - */ - smgrimmedsync(RelationGetSmgr(index), INIT_FORKNUM); + unbuffered_finish(&wstate, RelationGetSmgr(index), INIT_FORKNUM); } /* diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c index 9b8075536a7..1ec90e00abf 100644 --- a/src/backend/catalog/storage.c +++ b/src/backend/catalog/storage.c @@ -28,6 +28,7 @@ #include "catalog/storage.h" #include "catalog/storage_xlog.h" #include "miscadmin.h" +#include "storage/directmgr.h" #include "storage/freespace.h" #include "storage/smgr.h" #include "utils/hsearch.h" @@ -420,6 +421,8 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst, bool copying_initfork; BlockNumber nblocks; BlockNumber blkno; + UnBufferedWriteState wstate; + page = (Page) buf.data; @@ -440,6 +443,8 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst, use_wal = XLogIsNeeded() && (relpersistence == RELPERSISTENCE_PERMANENT || copying_initfork); + unbuffered_prep(&wstate, (use_wal || copying_initfork), false); + nblocks = smgrnblocks(src, forkNum); for (blkno = 0; blkno < nblocks; blkno++) @@ -474,30 +479,15 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst, * page this is, so we have to log the full page including any unused * space. */ - if (use_wal) - log_newpage(&dst->smgr_rnode.node, forkNum, blkno, page, false); - PageSetChecksumInplace(page, blkno); + // TODO: is it okay to pass the page here to unbuffered_extend so that + // it can be WAL-logged as a full page even though smgrextend used to + // take just buf.data? + unbuffered_extend(&wstate, use_wal, dst, forkNum, blkno, page, false); - /* - * Now write the page. We say skipFsync = true because there's no - * need for smgr to schedule an fsync for this write; we'll do it - * ourselves below. - */ - smgrextend(dst, forkNum, blkno, buf.data, true); } - /* - * When we WAL-logged rel pages, we must nonetheless fsync them. The - * reason is that since we're copying outside shared buffers, a CHECKPOINT - * occurring during the copy has no way to flush the previously written - * data to disk (indeed it won't know the new rel even exists). A crash - * later on would replay WAL from the checkpoint, therefore it wouldn't - * replay our earlier WAL entries. If we do not fsync those pages here, - * they might still not be on disk when the crash occurs. - */ - if (use_wal || copying_initfork) - smgrimmedsync(dst, forkNum); + unbuffered_finish(&wstate, dst, forkNum); } /* diff --git a/src/backend/storage/Makefile b/src/backend/storage/Makefile index 8376cdfca20..501fae5f9d0 100644 --- a/src/backend/storage/Makefile +++ b/src/backend/storage/Makefile @@ -8,6 +8,6 @@ subdir = src/backend/storage top_builddir = ../../.. include $(top_builddir)/src/Makefile.global -SUBDIRS = buffer file freespace ipc large_object lmgr page smgr sync +SUBDIRS = buffer direct file freespace ipc large_object lmgr page smgr sync include $(top_srcdir)/src/backend/common.mk diff --git a/src/backend/storage/direct/Makefile b/src/backend/storage/direct/Makefile new file mode 100644 index 00000000000..d82bbed48c2 --- /dev/null +++ b/src/backend/storage/direct/Makefile @@ -0,0 +1,17 @@ +#------------------------------------------------------------------------- +# +# Makefile-- +# Makefile for storage/direct +# +# IDENTIFICATION +# src/backend/storage/direct/Makefile +# +#------------------------------------------------------------------------- + +subdir = src/backend/storage/direct +top_builddir = ../../../.. +include $(top_builddir)/src/Makefile.global + +OBJS = directmgr.o + +include $(top_srcdir)/src/backend/common.mk diff --git a/src/backend/storage/direct/directmgr.c b/src/backend/storage/direct/directmgr.c new file mode 100644 index 00000000000..371ff5602fe --- /dev/null +++ b/src/backend/storage/direct/directmgr.c @@ -0,0 +1,79 @@ +/*------------------------------------------------------------------------- + * + * directmgr.c + * routines for managing unbuffered IO + * + * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * IDENTIFICATION + * src/backend/storage/direct/directmgr.c + * + *------------------------------------------------------------------------- + */ +#include "postgres.h" + + +#include "access/xloginsert.h" +#include "storage/directmgr.h" + +void +unbuffered_prep(UnBufferedWriteState *wstate, bool fsync_self, bool + request_fsync) +{ + wstate->fsync_self = fsync_self; + wstate->request_fsync = request_fsync; +} + +void +unbuffered_write(UnBufferedWriteState *wstate, bool do_wal, SMgrRelation + smgrrel, ForkNumber forknum, BlockNumber blocknum, Page page) +{ + PageSetChecksumInplace(page, blocknum); + + smgrwrite(smgrrel, forknum, blocknum, (char *) page, + !wstate->request_fsync); + + if (do_wal) + log_newpage(&(smgrrel)->smgr_rnode.node, forknum, + blocknum, page, true); +} + +void +unbuffered_extend(UnBufferedWriteState *wstate, bool do_wal, SMgrRelation + smgrrel, ForkNumber forknum, BlockNumber blocknum, Page page, bool + empty) +{ + /* + * Don't checksum empty pages + */ + if (!empty) + PageSetChecksumInplace(page, blocknum); + + smgrextend(smgrrel, forknum, blocknum, (char *) page, + !wstate->request_fsync); + + if (do_wal) + log_newpage(&(smgrrel)->smgr_rnode.node, forknum, + blocknum, page, true); + +} + +/* + * When writing data outside shared buffers, a concurrent CHECKPOINT can move + * the redo pointer past our WAL entries and won't flush our data to disk. If + * the database crashes before the data makes it to disk, our WAL won't be + * replayed and the data will be lost. + * Thus, if a CHECKPOINT begins between unbuffered_prep() and + * unbuffered_finish(), the backend must fsync the data itself. + */ +void +unbuffered_finish(UnBufferedWriteState *wstate, SMgrRelation smgrrel, + ForkNumber forknum) +{ + if (!wstate->fsync_self) + return; + + smgrimmedsync(smgrrel, forknum); +} diff --git a/src/backend/storage/freespace/freespace.c b/src/backend/storage/freespace/freespace.c index 78c073b7c98..4326ea8f015 100644 --- a/src/backend/storage/freespace/freespace.c +++ b/src/backend/storage/freespace/freespace.c @@ -27,6 +27,7 @@ #include "access/xloginsert.h" #include "access/xlogutils.h" #include "miscadmin.h" +#include "storage/directmgr.h" #include "storage/freespace.h" #include "storage/fsm_internals.h" #include "storage/lmgr.h" @@ -609,9 +610,11 @@ fsm_extend(Relation rel, BlockNumber fsm_nblocks) BlockNumber fsm_nblocks_now; PGAlignedBlock pg; SMgrRelation reln; + UnBufferedWriteState ub_wstate; PageInit((Page) pg.data, BLCKSZ, 0); + /* * We use the relation extension lock to lock out other backends trying to * extend the FSM at the same time. It also locks out extension of the @@ -624,6 +627,8 @@ fsm_extend(Relation rel, BlockNumber fsm_nblocks) */ LockRelationForExtension(rel, ExclusiveLock); + unbuffered_prep(&ub_wstate, false, true); + /* * Caution: re-using this smgr pointer could fail if the relcache entry * gets closed. It's safe as long as we only do smgr-level operations @@ -648,14 +653,15 @@ fsm_extend(Relation rel, BlockNumber fsm_nblocks) /* Extend as needed. */ while (fsm_nblocks_now < fsm_nblocks) { - PageSetChecksumInplace((Page) pg.data, fsm_nblocks_now); - - smgrextend(reln, FSM_FORKNUM, fsm_nblocks_now, - pg.data, false); + unbuffered_extend(&ub_wstate, false, reln, FSM_FORKNUM, + fsm_nblocks_now, (Page) pg.data, false); fsm_nblocks_now++; } + unbuffered_finish(&ub_wstate, reln, FSM_FORKNUM); + UnlockRelationForExtension(rel, ExclusiveLock); + } /* diff --git a/src/include/catalog/storage.h b/src/include/catalog/storage.h index 9ffc7419131..b097d09c9fc 100644 --- a/src/include/catalog/storage.h +++ b/src/include/catalog/storage.h @@ -15,6 +15,7 @@ #define STORAGE_H #include "storage/block.h" +#include "storage/directmgr.h" #include "storage/relfilenode.h" #include "storage/smgr.h" #include "utils/relcache.h" diff --git a/src/include/storage/directmgr.h b/src/include/storage/directmgr.h new file mode 100644 index 00000000000..47653d0d1bb --- /dev/null +++ b/src/include/storage/directmgr.h @@ -0,0 +1,57 @@ +/*------------------------------------------------------------------------- + * + * directmgr.h + * POSTGRES unbuffered IO manager definitions. + * + * + * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/storage/directmgr.h + * + *------------------------------------------------------------------------- + */ +#ifndef DIRECTMGR_H +#define DIRECTMGR_H + +#include "common/relpath.h" +#include "storage/block.h" +#include "storage/bufpage.h" +#include "storage/smgr.h" + +/* + * After committing the pg_buffer_stats patch, this will contain a pointer to a + * PgBufferAccess struct to count the writes and extends done in this way. + */ +typedef struct UnBufferedWriteState +{ + /* + * When writing logged table data outside of shared buffers, there is a + * risk of a concurrent CHECKPOINT moving the redo pointer past the data's + * associated WAL entries. To avoid this, callers in this situation must + * fsync the pages they have written themselves. + * + * Callers able to use the checkpointer's sync request queue when writing + * data outside shared buffers (like fsm and vm) can set request_fsync to + * true so that these fsync requests are added to the queue. + */ + bool fsync_self; + bool request_fsync; +} UnBufferedWriteState; +/* + * prototypes for functions in directmgr.c + */ +extern void +unbuffered_prep(UnBufferedWriteState *wstate, bool fsync_self, bool + request_fsync); +extern void +unbuffered_write(UnBufferedWriteState *wstate, bool do_wal, SMgrRelation + smgrrel, ForkNumber forknum, BlockNumber blocknum, Page page); +extern void +unbuffered_extend(UnBufferedWriteState *wstate, bool do_wal, SMgrRelation smgrrel, + ForkNumber forknum, BlockNumber blocknum, Page page, bool empty); +extern void +unbuffered_finish(UnBufferedWriteState *wstate, SMgrRelation smgrrel, + ForkNumber forknum); + +#endif /* DIRECTMGR_H */ -- 2.17.1