PostgreSQL Source Code  git master
smgr.h File Reference
#include "lib/ilist.h"
#include "storage/block.h"
#include "storage/relfilenode.h"
Include dependency graph for smgr.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  SMgrRelationData
 

Macros

#define SmgrIsTemp(smgr)   RelFileNodeBackendIsTemp((smgr)->smgr_rnode)
 

Typedefs

typedef struct SMgrRelationData SMgrRelationData
 
typedef SMgrRelationDataSMgrRelation
 

Functions

void smgrinit (void)
 
SMgrRelation smgropen (RelFileNode rnode, BackendId backend)
 
bool smgrexists (SMgrRelation reln, ForkNumber forknum)
 
void smgrsetowner (SMgrRelation *owner, SMgrRelation reln)
 
void smgrclearowner (SMgrRelation *owner, SMgrRelation reln)
 
void smgrclose (SMgrRelation reln)
 
void smgrcloseall (void)
 
void smgrclosenode (RelFileNodeBackend rnode)
 
void smgrcreate (SMgrRelation reln, ForkNumber forknum, bool isRedo)
 
void smgrdosyncall (SMgrRelation *rels, int nrels)
 
void smgrdounlinkall (SMgrRelation *rels, int nrels, bool isRedo)
 
void smgrextend (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
 
bool smgrprefetch (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
 
void smgrread (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer)
 
void smgrwrite (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
 
void smgrwriteback (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, BlockNumber nblocks)
 
BlockNumber smgrnblocks (SMgrRelation reln, ForkNumber forknum)
 
void smgrtruncate (SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nblocks)
 
void smgrimmedsync (SMgrRelation reln, ForkNumber forknum)
 
void AtEOXact_SMgr (void)
 

Macro Definition Documentation

◆ SmgrIsTemp

#define SmgrIsTemp (   smgr)    RelFileNodeBackendIsTemp((smgr)->smgr_rnode)

Definition at line 79 of file smgr.h.

Referenced by mdextend(), mdtruncate(), mdwrite(), ReadBuffer_common(), and register_dirty_segment().

Typedef Documentation

◆ SMgrRelation

Definition at line 77 of file smgr.h.

◆ SMgrRelationData

Function Documentation

◆ AtEOXact_SMgr()

void AtEOXact_SMgr ( void  )

Definition at line 638 of file smgr.c.

References Assert, dlist_mutable_iter::cur, dlist_container, dlist_foreach_modify, SMgrRelationData::smgr_owner, and smgrclose().

Referenced by AbortTransaction(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), CommitTransaction(), PrepareTransaction(), and WalWriterMain().

639 {
640  dlist_mutable_iter iter;
641 
642  /*
643  * Zap all unowned SMgrRelations. We rely on smgrclose() to remove each
644  * one from the list.
645  */
647  {
649  iter.cur);
650 
651  Assert(rel->smgr_owner == NULL);
652 
653  smgrclose(rel);
654  }
655 }
void smgrclose(SMgrRelation reln)
Definition: smgr.c:256
dlist_node * cur
Definition: ilist.h:180
#define dlist_foreach_modify(iter, lhead)
Definition: ilist.h:524
#define dlist_container(type, membername, ptr)
Definition: ilist.h:477
struct SMgrRelationData ** smgr_owner
Definition: smgr.h:45
#define Assert(condition)
Definition: c.h:738
static dlist_head unowned_relns
Definition: smgr.c:95

◆ smgrclearowner()

void smgrclearowner ( SMgrRelation owner,
SMgrRelation  reln 
)

Definition at line 227 of file smgr.c.

References dlist_push_tail(), SMgrRelationData::node, and SMgrRelationData::smgr_owner.

Referenced by FreeFakeRelcacheEntry().

228 {
229  /* Do nothing if the SMgrRelation object is not owned by the owner */
230  if (reln->smgr_owner != owner)
231  return;
232 
233  /* unset the owner's reference */
234  *owner = NULL;
235 
236  /* unset our reference to the owner */
237  reln->smgr_owner = NULL;
238 
239  /* add to list of unowned relations */
241 }
static void dlist_push_tail(dlist_head *head, dlist_node *node)
Definition: ilist.h:317
struct SMgrRelationData ** smgr_owner
Definition: smgr.h:45
dlist_node node
Definition: smgr.h:74
static dlist_head unowned_relns
Definition: smgr.c:95

◆ smgrclose()

void smgrclose ( SMgrRelation  reln)

Definition at line 256 of file smgr.c.

References dlist_delete(), elog, ERROR, HASH_REMOVE, hash_search(), MAX_FORKNUM, SMgrRelationData::node, f_smgr::smgr_close, SMgrRelationData::smgr_owner, SMgrRelationData::smgr_rnode, and SMgrRelationData::smgr_which.

Referenced by AtEOXact_SMgr(), DropRelationFiles(), heapam_relation_copy_data(), heapam_relation_set_new_filenode(), index_copy_data(), RelationSetNewRelfilenode(), smgrcloseall(), smgrclosenode(), and smgrDoPendingDeletes().

257 {
258  SMgrRelation *owner;
259  ForkNumber forknum;
260 
261  for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
262  smgrsw[reln->smgr_which].smgr_close(reln, forknum);
263 
264  owner = reln->smgr_owner;
265 
266  if (!owner)
267  dlist_delete(&reln->node);
268 
270  (void *) &(reln->smgr_rnode),
271  HASH_REMOVE, NULL) == NULL)
272  elog(ERROR, "SMgrRelation hashtable corrupted");
273 
274  /*
275  * Unhook the owner pointer, if any. We do this last since in the remote
276  * possibility of failure above, the SMgrRelation object will still exist.
277  */
278  if (owner)
279  *owner = NULL;
280 }
static const f_smgr smgrsw[]
Definition: smgr.c:66
void(* smgr_close)(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:44
static HTAB * SMgrRelationHash
Definition: smgr.c:93
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:908
#define ERROR
Definition: elog.h:43
RelFileNodeBackend smgr_rnode
Definition: smgr.h:42
static void dlist_delete(dlist_node *node)
Definition: ilist.h:358
ForkNumber
Definition: relpath.h:40
struct SMgrRelationData ** smgr_owner
Definition: smgr.h:45
int smgr_which
Definition: smgr.h:64
#define MAX_FORKNUM
Definition: relpath.h:55
#define elog(elevel,...)
Definition: elog.h:214
dlist_node node
Definition: smgr.h:74

◆ smgrcloseall()

void smgrcloseall ( void  )

Definition at line 286 of file smgr.c.

References hash_seq_init(), hash_seq_search(), smgrclose(), and status().

Referenced by BackgroundWriterMain(), CheckpointerMain(), RelationCacheInvalidate(), RequestCheckpoint(), WalWriterMain(), and XLogDropDatabase().

287 {
289  SMgrRelation reln;
290 
291  /* Nothing to do if hashtable not set up */
292  if (SMgrRelationHash == NULL)
293  return;
294 
296 
297  while ((reln = (SMgrRelation) hash_seq_search(&status)) != NULL)
298  smgrclose(reln);
299 }
void smgrclose(SMgrRelation reln)
Definition: smgr.c:256
static HTAB * SMgrRelationHash
Definition: smgr.c:93
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1391
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1381
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:225

◆ smgrclosenode()

void smgrclosenode ( RelFileNodeBackend  rnode)

Definition at line 310 of file smgr.c.

References HASH_FIND, hash_search(), and smgrclose().

Referenced by LocalExecuteInvalidationMessage().

311 {
312  SMgrRelation reln;
313 
314  /* Nothing to do if hashtable not set up */
315  if (SMgrRelationHash == NULL)
316  return;
317 
319  (void *) &rnode,
320  HASH_FIND, NULL);
321  if (reln != NULL)
322  smgrclose(reln);
323 }
void smgrclose(SMgrRelation reln)
Definition: smgr.c:256
SMgrRelationData * SMgrRelation
Definition: smgr.h:77
static HTAB * SMgrRelationHash
Definition: smgr.c:93
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:908

◆ smgrcreate()

void smgrcreate ( SMgrRelation  reln,
ForkNumber  forknum,
bool  isRedo 
)

Definition at line 333 of file smgr.c.

References f_smgr::smgr_create, and SMgrRelationData::smgr_which.

Referenced by fsm_extend(), heapam_relation_copy_data(), heapam_relation_set_new_filenode(), index_build(), index_copy_data(), RelationCreateStorage(), smgr_redo(), vm_extend(), and XLogReadBufferExtended().

334 {
335  smgrsw[reln->smgr_which].smgr_create(reln, forknum, isRedo);
336 }
static const f_smgr smgrsw[]
Definition: smgr.c:66
void(* smgr_create)(SMgrRelation reln, ForkNumber forknum, bool isRedo)
Definition: smgr.c:45
int smgr_which
Definition: smgr.h:64

◆ smgrdosyncall()

void smgrdosyncall ( SMgrRelation rels,
int  nrels 
)

Definition at line 348 of file smgr.c.

References FlushRelationsAllBuffers(), i, MAX_FORKNUM, f_smgr::smgr_exists, f_smgr::smgr_immedsync, and SMgrRelationData::smgr_which.

Referenced by smgrDoPendingSyncs().

349 {
350  int i = 0;
351  ForkNumber forknum;
352 
353  if (nrels == 0)
354  return;
355 
356  FlushRelationsAllBuffers(rels, nrels);
357 
358  /*
359  * Sync the physical file(s).
360  */
361  for (i = 0; i < nrels; i++)
362  {
363  int which = rels[i]->smgr_which;
364 
365  for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
366  {
367  if (smgrsw[which].smgr_exists(rels[i], forknum))
368  smgrsw[which].smgr_immedsync(rels[i], forknum);
369  }
370  }
371 }
static const f_smgr smgrsw[]
Definition: smgr.c:66
void(* smgr_immedsync)(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:63
void FlushRelationsAllBuffers(SMgrRelation *smgrs, int nrels)
Definition: bufmgr.c:3316
ForkNumber
Definition: relpath.h:40
int smgr_which
Definition: smgr.h:64
#define MAX_FORKNUM
Definition: relpath.h:55
int i

◆ smgrdounlinkall()

void smgrdounlinkall ( SMgrRelation rels,
int  nrels,
bool  isRedo 
)

Definition at line 384 of file smgr.c.

References CacheInvalidateSmgr(), DropRelFileNodesAllBuffers(), i, MAX_FORKNUM, palloc(), pfree(), f_smgr::smgr_close, SMgrRelationData::smgr_rnode, f_smgr::smgr_unlink, and SMgrRelationData::smgr_which.

Referenced by DropRelationFiles(), and smgrDoPendingDeletes().

385 {
386  int i = 0;
387  RelFileNodeBackend *rnodes;
388  ForkNumber forknum;
389 
390  if (nrels == 0)
391  return;
392 
393  /*
394  * create an array which contains all relations to be dropped, and close
395  * each relation's forks at the smgr level while at it
396  */
397  rnodes = palloc(sizeof(RelFileNodeBackend) * nrels);
398  for (i = 0; i < nrels; i++)
399  {
400  RelFileNodeBackend rnode = rels[i]->smgr_rnode;
401  int which = rels[i]->smgr_which;
402 
403  rnodes[i] = rnode;
404 
405  /* Close the forks at smgr level */
406  for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
407  smgrsw[which].smgr_close(rels[i], forknum);
408  }
409 
410  /*
411  * Get rid of any remaining buffers for the relations. bufmgr will just
412  * drop them without bothering to write the contents.
413  */
414  DropRelFileNodesAllBuffers(rnodes, nrels);
415 
416  /*
417  * It'd be nice to tell the stats collector to forget them immediately,
418  * too. But we can't because we don't know the OIDs.
419  */
420 
421  /*
422  * Send a shared-inval message to force other backends to close any
423  * dangling smgr references they may have for these rels. We should do
424  * this before starting the actual unlinking, in case we fail partway
425  * through that step. Note that the sinval messages will eventually come
426  * back to this backend, too, and thereby provide a backstop that we
427  * closed our own smgr rel.
428  */
429  for (i = 0; i < nrels; i++)
430  CacheInvalidateSmgr(rnodes[i]);
431 
432  /*
433  * Delete the physical file(s).
434  *
435  * Note: smgr_unlink must treat deletion failure as a WARNING, not an
436  * ERROR, because we've already decided to commit or abort the current
437  * xact.
438  */
439 
440  for (i = 0; i < nrels; i++)
441  {
442  int which = rels[i]->smgr_which;
443 
444  for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
445  smgrsw[which].smgr_unlink(rnodes[i], forknum, isRedo);
446  }
447 
448  pfree(rnodes);
449 }
void CacheInvalidateSmgr(RelFileNodeBackend rnode)
Definition: inval.c:1369
static const f_smgr smgrsw[]
Definition: smgr.c:66
void pfree(void *pointer)
Definition: mcxt.c:1056
RelFileNodeBackend smgr_rnode
Definition: smgr.h:42
ForkNumber
Definition: relpath.h:40
void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes)
Definition: bufmgr.c:3016
int smgr_which
Definition: smgr.h:64
#define MAX_FORKNUM
Definition: relpath.h:55
void * palloc(Size size)
Definition: mcxt.c:949
int i

◆ smgrexists()

bool smgrexists ( SMgrRelation  reln,
ForkNumber  forknum 
)

◆ smgrextend()

void smgrextend ( SMgrRelation  reln,
ForkNumber  forknum,
BlockNumber  blocknum,
char *  buffer,
bool  skipFsync 
)

Definition at line 462 of file smgr.c.

References f_smgr::smgr_extend, and SMgrRelationData::smgr_which.

Referenced by _bt_blwritepage(), _hash_alloc_buckets(), end_heap_rewrite(), fsm_extend(), raw_heap_insert(), ReadBuffer_common(), RelationCopyStorage(), and vm_extend().

464 {
465  smgrsw[reln->smgr_which].smgr_extend(reln, forknum, blocknum,
466  buffer, skipFsync);
467 }
static const f_smgr smgrsw[]
Definition: smgr.c:66
int smgr_which
Definition: smgr.h:64
void(* smgr_extend)(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
Definition: smgr.c:50

◆ smgrimmedsync()

void smgrimmedsync ( SMgrRelation  reln,
ForkNumber  forknum 
)

Definition at line 620 of file smgr.c.

References f_smgr::smgr_immedsync, and SMgrRelationData::smgr_which.

Referenced by _bt_load(), blbuildempty(), btbuildempty(), end_heap_rewrite(), heapam_relation_set_new_filenode(), RelationCopyStorage(), and spgbuildempty().

621 {
622  smgrsw[reln->smgr_which].smgr_immedsync(reln, forknum);
623 }
static const f_smgr smgrsw[]
Definition: smgr.c:66
void(* smgr_immedsync)(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:63
int smgr_which
Definition: smgr.h:64

◆ smgrinit()

void smgrinit ( void  )

Definition at line 110 of file smgr.c.

References i, NSmgr, on_proc_exit(), f_smgr::smgr_init, and smgrshutdown().

Referenced by BaseInit().

111 {
112  int i;
113 
114  for (i = 0; i < NSmgr; i++)
115  {
116  if (smgrsw[i].smgr_init)
117  smgrsw[i].smgr_init();
118  }
119 
120  /* register the shutdown proc */
122 }
void on_proc_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:305
static const f_smgr smgrsw[]
Definition: smgr.c:66
static void smgrshutdown(int code, Datum arg)
Definition: smgr.c:128
void(* smgr_init)(void)
Definition: smgr.c:41
static const int NSmgr
Definition: smgr.c:87
int i

◆ smgrnblocks()

BlockNumber smgrnblocks ( SMgrRelation  reln,
ForkNumber  forknum 
)

◆ smgropen()

SMgrRelation smgropen ( RelFileNode  rnode,
BackendId  backend 
)

Definition at line 145 of file smgr.c.

References RelFileNodeBackend::backend, dlist_init(), dlist_push_tail(), HASHCTL::entrysize, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), InvalidBlockNumber, HASHCTL::keysize, MemSet, RelFileNodeBackend::node, SMgrRelationData::node, SMgrRelationData::smgr_fsm_nblocks, f_smgr::smgr_open, SMgrRelationData::smgr_owner, SMgrRelationData::smgr_targblock, SMgrRelationData::smgr_vm_nblocks, and SMgrRelationData::smgr_which.

Referenced by DropRelationFiles(), FlushBuffer(), heapam_relation_copy_data(), index_copy_data(), IssuePendingWritebacks(), LocalBufferAlloc(), mdsyncfiletag(), ReadBufferWithoutRelcache(), RelationCreateStorage(), smgr_redo(), smgrDoPendingDeletes(), smgrDoPendingSyncs(), and XLogReadBufferExtended().

146 {
147  RelFileNodeBackend brnode;
148  SMgrRelation reln;
149  bool found;
150 
151  if (SMgrRelationHash == NULL)
152  {
153  /* First time through: initialize the hash table */
154  HASHCTL ctl;
155 
156  MemSet(&ctl, 0, sizeof(ctl));
157  ctl.keysize = sizeof(RelFileNodeBackend);
158  ctl.entrysize = sizeof(SMgrRelationData);
159  SMgrRelationHash = hash_create("smgr relation table", 400,
160  &ctl, HASH_ELEM | HASH_BLOBS);
162  }
163 
164  /* Look up or create an entry */
165  brnode.node = rnode;
166  brnode.backend = backend;
168  (void *) &brnode,
169  HASH_ENTER, &found);
170 
171  /* Initialize it if not present before */
172  if (!found)
173  {
174  /* hash_search already filled in the lookup key */
175  reln->smgr_owner = NULL;
179  reln->smgr_which = 0; /* we only have md.c at present */
180 
181  /* implementation-specific initialization */
182  smgrsw[reln->smgr_which].smgr_open(reln);
183 
184  /* it has no owner yet */
186  }
187 
188  return reln;
189 }
struct SMgrRelationData SMgrRelationData
BlockNumber smgr_vm_nblocks
Definition: smgr.h:56
#define HASH_ELEM
Definition: hsearch.h:87
SMgrRelationData * SMgrRelation
Definition: smgr.h:77
static const f_smgr smgrsw[]
Definition: smgr.c:66
static void dlist_push_tail(dlist_head *head, dlist_node *node)
Definition: ilist.h:317
Size entrysize
Definition: hsearch.h:73
static HTAB * SMgrRelationHash
Definition: smgr.c:93
#define MemSet(start, val, len)
Definition: c.h:971
BlockNumber smgr_fsm_nblocks
Definition: smgr.h:55
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:908
void(* smgr_open)(SMgrRelation reln)
Definition: smgr.c:43
struct SMgrRelationData ** smgr_owner
Definition: smgr.h:45
#define HASH_BLOBS
Definition: hsearch.h:88
HTAB * hash_create(const char *tabname, long nelem, HASHCTL *info, int flags)
Definition: dynahash.c:318
int smgr_which
Definition: smgr.h:64
struct RelFileNodeBackend RelFileNodeBackend
Size keysize
Definition: hsearch.h:72
static void dlist_init(dlist_head *head)
Definition: ilist.h:278
RelFileNode node
Definition: relfilenode.h:74
BlockNumber smgr_targblock
Definition: smgr.h:54
BackendId backend
Definition: relfilenode.h:75
#define InvalidBlockNumber
Definition: block.h:33
dlist_node node
Definition: smgr.h:74
static dlist_head unowned_relns
Definition: smgr.c:95

◆ smgrprefetch()

bool smgrprefetch ( SMgrRelation  reln,
ForkNumber  forknum,
BlockNumber  blocknum 
)

Definition at line 477 of file smgr.c.

References f_smgr::smgr_prefetch, and SMgrRelationData::smgr_which.

Referenced by PrefetchLocalBuffer(), and PrefetchSharedBuffer().

478 {
479  return smgrsw[reln->smgr_which].smgr_prefetch(reln, forknum, blocknum);
480 }
static const f_smgr smgrsw[]
Definition: smgr.c:66
bool(* smgr_prefetch)(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
Definition: smgr.c:52
int smgr_which
Definition: smgr.h:64

◆ smgrread()

void smgrread ( SMgrRelation  reln,
ForkNumber  forknum,
BlockNumber  blocknum,
char *  buffer 
)

Definition at line 491 of file smgr.c.

References f_smgr::smgr_read, and SMgrRelationData::smgr_which.

Referenced by pg_prewarm(), ReadBuffer_common(), and RelationCopyStorage().

493 {
494  smgrsw[reln->smgr_which].smgr_read(reln, forknum, blocknum, buffer);
495 }
static const f_smgr smgrsw[]
Definition: smgr.c:66
void(* smgr_read)(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer)
Definition: smgr.c:54
int smgr_which
Definition: smgr.h:64

◆ smgrsetowner()

void smgrsetowner ( SMgrRelation owner,
SMgrRelation  reln 
)

Definition at line 198 of file smgr.c.

References Assert, dlist_delete(), SMgrRelationData::node, and SMgrRelationData::smgr_owner.

199 {
200  /* We don't support "disowning" an SMgrRelation here, use smgrclearowner */
201  Assert(owner != NULL);
202 
203  /*
204  * First, unhook any old owner. (Normally there shouldn't be any, but it
205  * seems possible that this can happen during swap_relation_files()
206  * depending on the order of processing. It's ok to close the old
207  * relcache entry early in that case.)
208  *
209  * If there isn't an old owner, then the reln should be in the unowned
210  * list, and we need to remove it.
211  */
212  if (reln->smgr_owner)
213  *(reln->smgr_owner) = NULL;
214  else
215  dlist_delete(&reln->node);
216 
217  /* Now establish the ownership relationship. */
218  reln->smgr_owner = owner;
219  *owner = reln;
220 }
static void dlist_delete(dlist_node *node)
Definition: ilist.h:358
struct SMgrRelationData ** smgr_owner
Definition: smgr.h:45
#define Assert(condition)
Definition: c.h:738
dlist_node node
Definition: smgr.h:74

◆ smgrtruncate()

void smgrtruncate ( SMgrRelation  reln,
ForkNumber forknum,
int  nforks,
BlockNumber nblocks 
)

Definition at line 554 of file smgr.c.

References CacheInvalidateSmgr(), DropRelFileNodeBuffers(), FSM_FORKNUM, i, SMgrRelationData::smgr_fsm_nblocks, SMgrRelationData::smgr_rnode, f_smgr::smgr_truncate, SMgrRelationData::smgr_vm_nblocks, SMgrRelationData::smgr_which, and VISIBILITYMAP_FORKNUM.

Referenced by pg_truncate_visibility_map(), RelationTruncate(), and smgr_redo().

555 {
556  int i;
557 
558  /*
559  * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
560  * just drop them without bothering to write the contents.
561  */
562  DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
563 
564  /*
565  * Send a shared-inval message to force other backends to close any smgr
566  * references they may have for this rel. This is useful because they
567  * might have open file pointers to segments that got removed, and/or
568  * smgr_targblock variables pointing past the new rel end. (The inval
569  * message will come back to our backend, too, causing a
570  * probably-unnecessary local smgr flush. But we don't expect that this
571  * is a performance-critical path.) As in the unlink code, we want to be
572  * sure the message is sent before we start changing things on-disk.
573  */
575 
576  /* Do the truncation */
577  for (i = 0; i < nforks; i++)
578  {
579  smgrsw[reln->smgr_which].smgr_truncate(reln, forknum[i], nblocks[i]);
580 
581  /*
582  * We might as well update the local smgr_fsm_nblocks and
583  * smgr_vm_nblocks settings. The smgr cache inval message that this
584  * function sent will cause other backends to invalidate their copies
585  * of smgr_fsm_nblocks and smgr_vm_nblocks, and these ones too at the
586  * next command boundary. But these ensure they aren't outright wrong
587  * until then.
588  */
589  if (forknum[i] == FSM_FORKNUM)
590  reln->smgr_fsm_nblocks = nblocks[i];
591  if (forknum[i] == VISIBILITYMAP_FORKNUM)
592  reln->smgr_vm_nblocks = nblocks[i];
593  }
594 }
void CacheInvalidateSmgr(RelFileNodeBackend rnode)
Definition: inval.c:1369
void(* smgr_truncate)(SMgrRelation reln, ForkNumber forknum, BlockNumber nblocks)
Definition: smgr.c:61
BlockNumber smgr_vm_nblocks
Definition: smgr.h:56
static const f_smgr smgrsw[]
Definition: smgr.c:66
BlockNumber smgr_fsm_nblocks
Definition: smgr.h:55
RelFileNodeBackend smgr_rnode
Definition: smgr.h:42
int smgr_which
Definition: smgr.h:64
void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum, int nforks, BlockNumber *firstDelBlock)
Definition: bufmgr.c:2947
int i

◆ smgrwrite()

void smgrwrite ( SMgrRelation  reln,
ForkNumber  forknum,
BlockNumber  blocknum,
char *  buffer,
bool  skipFsync 
)

Definition at line 513 of file smgr.c.

References SMgrRelationData::smgr_which, and f_smgr::smgr_write.

Referenced by _bt_blwritepage(), blbuildempty(), btbuildempty(), FlushBuffer(), FlushRelationBuffers(), LocalBufferAlloc(), and spgbuildempty().

515 {
516  smgrsw[reln->smgr_which].smgr_write(reln, forknum, blocknum,
517  buffer, skipFsync);
518 }
void(* smgr_write)(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
Definition: smgr.c:56
static const f_smgr smgrsw[]
Definition: smgr.c:66
int smgr_which
Definition: smgr.h:64

◆ smgrwriteback()

void smgrwriteback ( SMgrRelation  reln,
ForkNumber  forknum,
BlockNumber  blocknum,
BlockNumber  nblocks 
)

Definition at line 526 of file smgr.c.

References SMgrRelationData::smgr_which, and f_smgr::smgr_writeback.

Referenced by IssuePendingWritebacks().

528 {
529  smgrsw[reln->smgr_which].smgr_writeback(reln, forknum, blocknum,
530  nblocks);
531 }
static const f_smgr smgrsw[]
Definition: smgr.c:66
int smgr_which
Definition: smgr.h:64
void(* smgr_writeback)(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, BlockNumber nblocks)
Definition: smgr.c:58