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 smgrdounlink (SMgrRelation reln, bool isRedo)
 
void smgrdounlinkall (SMgrRelation *rels, int nrels, bool isRedo)
 
void smgrextend (SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
 
void 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 655 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().

656 {
657  dlist_mutable_iter iter;
658 
659  /*
660  * Zap all unowned SMgrRelations. We rely on smgrclose() to remove each
661  * one from the list.
662  */
664  {
666  iter.cur);
667 
668  Assert(rel->smgr_owner == NULL);
669 
670  smgrclose(rel);
671  }
672 }
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:733
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:906
#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:228
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:1389
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1379
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:226

◆ 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:906

◆ 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

◆ smgrdounlink()

void smgrdounlink ( SMgrRelation  reln,
bool  isRedo 
)

Definition at line 348 of file smgr.c.

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

349 {
350  RelFileNodeBackend rnode = reln->smgr_rnode;
351  int which = reln->smgr_which;
352  ForkNumber forknum;
353 
354  /* Close the forks at smgr level */
355  for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
356  smgrsw[which].smgr_close(reln, forknum);
357 
358  /*
359  * Get rid of any remaining buffers for the relation. bufmgr will just
360  * drop them without bothering to write the contents.
361  */
362  DropRelFileNodesAllBuffers(&rnode, 1);
363 
364  /*
365  * It'd be nice to tell the stats collector to forget it immediately, too.
366  * But we can't because we don't know the OID (and in cases involving
367  * relfilenode swaps, it's not always clear which table OID to forget,
368  * anyway).
369  */
370 
371  /*
372  * Send a shared-inval message to force other backends to close any
373  * dangling smgr references they may have for this rel. We should do this
374  * before starting the actual unlinking, in case we fail partway through
375  * that step. Note that the sinval message will eventually come back to
376  * this backend, too, and thereby provide a backstop that we closed our
377  * own smgr rel.
378  */
379  CacheInvalidateSmgr(rnode);
380 
381  /*
382  * Delete the physical file(s).
383  *
384  * Note: smgr_unlink must treat deletion failure as a WARNING, not an
385  * ERROR, because we've already decided to commit or abort the current
386  * xact.
387  */
388  smgrsw[which].smgr_unlink(rnode, InvalidForkNumber, isRedo);
389 }
void CacheInvalidateSmgr(RelFileNodeBackend rnode)
Definition: inval.c:1369
static const f_smgr smgrsw[]
Definition: smgr.c:66
RelFileNodeBackend smgr_rnode
Definition: smgr.h:42
void(* smgr_unlink)(RelFileNodeBackend rnode, ForkNumber forknum, bool isRedo)
Definition: smgr.c:48
ForkNumber
Definition: relpath.h:40
void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes)
Definition: bufmgr.c:2996
int smgr_which
Definition: smgr.h:64
#define MAX_FORKNUM
Definition: relpath.h:55

◆ smgrdounlinkall()

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

Definition at line 405 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().

406 {
407  int i = 0;
408  RelFileNodeBackend *rnodes;
409  ForkNumber forknum;
410 
411  if (nrels == 0)
412  return;
413 
414  /*
415  * create an array which contains all relations to be dropped, and close
416  * each relation's forks at the smgr level while at it
417  */
418  rnodes = palloc(sizeof(RelFileNodeBackend) * nrels);
419  for (i = 0; i < nrels; i++)
420  {
421  RelFileNodeBackend rnode = rels[i]->smgr_rnode;
422  int which = rels[i]->smgr_which;
423 
424  rnodes[i] = rnode;
425 
426  /* Close the forks at smgr level */
427  for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
428  smgrsw[which].smgr_close(rels[i], forknum);
429  }
430 
431  /*
432  * Get rid of any remaining buffers for the relations. bufmgr will just
433  * drop them without bothering to write the contents.
434  */
435  DropRelFileNodesAllBuffers(rnodes, nrels);
436 
437  /*
438  * It'd be nice to tell the stats collector to forget them immediately,
439  * too. But we can't because we don't know the OIDs.
440  */
441 
442  /*
443  * Send a shared-inval message to force other backends to close any
444  * dangling smgr references they may have for these rels. We should do
445  * this before starting the actual unlinking, in case we fail partway
446  * through that step. Note that the sinval messages will eventually come
447  * back to this backend, too, and thereby provide a backstop that we
448  * closed our own smgr rel.
449  */
450  for (i = 0; i < nrels; i++)
451  CacheInvalidateSmgr(rnodes[i]);
452 
453  /*
454  * Delete the physical file(s).
455  *
456  * Note: smgr_unlink must treat deletion failure as a WARNING, not an
457  * ERROR, because we've already decided to commit or abort the current
458  * xact.
459  */
460 
461  for (i = 0; i < nrels; i++)
462  {
463  int which = rels[i]->smgr_which;
464 
465  for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
466  smgrsw[which].smgr_unlink(rnodes[i], forknum, isRedo);
467  }
468 
469  pfree(rnodes);
470 }
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:2996
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 
)

Definition at line 247 of file smgr.c.

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

Referenced by autoprewarm_database_main(), bt_index_check_internal(), FreeSpaceMapPrepareTruncateRel(), fsm_extend(), fsm_readbuf(), heapam_relation_copy_data(), index_build(), index_copy_data(), pg_prewarm(), RelationTruncate(), smgr_redo(), visibilitymap_prepare_truncate(), vm_extend(), and vm_readbuf().

248 {
249  return smgrsw[reln->smgr_which].smgr_exists(reln, forknum);
250 }
static const f_smgr smgrsw[]
Definition: smgr.c:66
bool(* smgr_exists)(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:47
int smgr_which
Definition: smgr.h:64

◆ smgrextend()

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

Definition at line 483 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().

485 {
486  smgrsw[reln->smgr_which].smgr_extend(reln, forknum, blocknum,
487  buffer, skipFsync);
488 }
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 637 of file smgr.c.

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

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

638 {
639  smgrsw[reln->smgr_which].smgr_immedsync(reln, forknum);
640 }
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 
)

Definition at line 555 of file smgr.c.

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

Referenced by FreeSpaceMapPrepareTruncateRel(), fsm_extend(), fsm_readbuf(), gistBuildCallback(), ReadBuffer_common(), RelationCopyStorage(), RelationGetNumberOfBlocksInFork(), table_block_relation_size(), visibilitymap_prepare_truncate(), vm_extend(), vm_readbuf(), and XLogReadBufferExtended().

556 {
557  return smgrsw[reln->smgr_which].smgr_nblocks(reln, forknum);
558 }
static const f_smgr smgrsw[]
Definition: smgr.c:66
BlockNumber(* smgr_nblocks)(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:60
int smgr_which
Definition: smgr.h:64

◆ 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(), 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:956
BlockNumber smgr_fsm_nblocks
Definition: smgr.h:55
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
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:316
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()

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

Definition at line 494 of file smgr.c.

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

Referenced by LocalPrefetchBuffer(), and PrefetchBuffer().

495 {
496  smgrsw[reln->smgr_which].smgr_prefetch(reln, forknum, blocknum);
497 }
static const f_smgr smgrsw[]
Definition: smgr.c:66
void(* 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 508 of file smgr.c.

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

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

510 {
511  smgrsw[reln->smgr_which].smgr_read(reln, forknum, blocknum, buffer);
512 }
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:733
dlist_node node
Definition: smgr.h:74

◆ smgrtruncate()

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

Definition at line 571 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().

572 {
573  int i;
574 
575  /*
576  * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
577  * just drop them without bothering to write the contents.
578  */
579  DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
580 
581  /*
582  * Send a shared-inval message to force other backends to close any smgr
583  * references they may have for this rel. This is useful because they
584  * might have open file pointers to segments that got removed, and/or
585  * smgr_targblock variables pointing past the new rel end. (The inval
586  * message will come back to our backend, too, causing a
587  * probably-unnecessary local smgr flush. But we don't expect that this
588  * is a performance-critical path.) As in the unlink code, we want to be
589  * sure the message is sent before we start changing things on-disk.
590  */
592 
593  /* Do the truncation */
594  for (i = 0; i < nforks; i++)
595  {
596  smgrsw[reln->smgr_which].smgr_truncate(reln, forknum[i], nblocks[i]);
597 
598  /*
599  * We might as well update the local smgr_fsm_nblocks and
600  * smgr_vm_nblocks settings. The smgr cache inval message that
601  * this function sent will cause other backends to invalidate
602  * their copies of smgr_fsm_nblocks and smgr_vm_nblocks,
603  * and these ones too at the next command boundary.
604  * But these ensure they aren't outright wrong until then.
605  */
606  if (forknum[i] == FSM_FORKNUM)
607  reln->smgr_fsm_nblocks = nblocks[i];
608  if (forknum[i] == VISIBILITYMAP_FORKNUM)
609  reln->smgr_vm_nblocks = nblocks[i];
610  }
611 }
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:2927
int i

◆ smgrwrite()

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

Definition at line 530 of file smgr.c.

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

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

532 {
533  smgrsw[reln->smgr_which].smgr_write(reln, forknum, blocknum,
534  buffer, skipFsync);
535 }
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 543 of file smgr.c.

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

Referenced by IssuePendingWritebacks().

545 {
546  smgrsw[reln->smgr_which].smgr_writeback(reln, forknum, blocknum,
547  nblocks);
548 }
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