PostgreSQL Source Code  git master
smgr.c File Reference
#include "postgres.h"
#include "lib/ilist.h"
#include "storage/bufmgr.h"
#include "storage/ipc.h"
#include "storage/md.h"
#include "storage/smgr.h"
#include "utils/hsearch.h"
#include "utils/inval.h"
Include dependency graph for smgr.c:

Go to the source code of this file.

Data Structures

struct  f_smgr
 

Typedefs

typedef struct f_smgr f_smgr
 

Functions

static void smgrshutdown (int code, Datum arg)
 
void smgrinit (void)
 
SMgrRelation smgropen (RelFileNode rnode, BackendId backend)
 
void smgrsetowner (SMgrRelation *owner, SMgrRelation reln)
 
void smgrclearowner (SMgrRelation *owner, SMgrRelation reln)
 
bool smgrexists (SMgrRelation reln, ForkNumber forknum)
 
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)
 

Variables

static const f_smgr smgrsw []
 
static const int NSmgr = lengthof(smgrsw)
 
static HTABSMgrRelationHash = NULL
 
static dlist_head unowned_relns
 

Typedef Documentation

◆ f_smgr

typedef struct f_smgr f_smgr

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:732
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:226
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:227

◆ 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:955
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:732
dlist_node node
Definition: smgr.h:74

◆ smgrshutdown()

static void smgrshutdown ( int  code,
Datum  arg 
)
static

Definition at line 128 of file smgr.c.

References i, NSmgr, and f_smgr::smgr_shutdown.

Referenced by smgrinit().

129 {
130  int i;
131 
132  for (i = 0; i < NSmgr; i++)
133  {
134  if (smgrsw[i].smgr_shutdown)
136  }
137 }
static const f_smgr smgrsw[]
Definition: smgr.c:66
static const int NSmgr
Definition: smgr.c:87
int i
void(* smgr_shutdown)(void)
Definition: smgr.c:42

◆ 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

Variable Documentation

◆ NSmgr

const int NSmgr = lengthof(smgrsw)
static

Definition at line 87 of file smgr.c.

Referenced by smgrinit(), and smgrshutdown().

◆ SMgrRelationHash

HTAB* SMgrRelationHash = NULL
static

Definition at line 93 of file smgr.c.

◆ smgrsw

const f_smgr smgrsw[]
static
Initial value:
= {
{
.smgr_init = mdinit,
.smgr_shutdown = NULL,
.smgr_open = mdopen,
.smgr_close = mdclose,
.smgr_create = mdcreate,
.smgr_exists = mdexists,
.smgr_unlink = mdunlink,
.smgr_extend = mdextend,
.smgr_prefetch = mdprefetch,
.smgr_read = mdread,
.smgr_write = mdwrite,
.smgr_writeback = mdwriteback,
.smgr_nblocks = mdnblocks,
.smgr_truncate = mdtruncate,
.smgr_immedsync = mdimmedsync,
}
}
void mdimmedsync(SMgrRelation reln, ForkNumber forknum)
Definition: md.c:891
BlockNumber mdnblocks(SMgrRelation reln, ForkNumber forknum)
Definition: md.c:739
void mdinit(void)
Definition: md.c:148
void mdextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
Definition: md.c:388
void mdunlink(RelFileNodeBackend rnode, ForkNumber forkNum, bool isRedo)
Definition: md.c:278
void mdwriteback(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, BlockNumber nblocks)
Definition: md.c:560
void mdopen(SMgrRelation reln)
Definition: md.c:495
void mdtruncate(SMgrRelation reln, ForkNumber forknum, BlockNumber nblocks)
Definition: md.c:794
bool mdexists(SMgrRelation reln, ForkNumber forkNum)
Definition: md.c:161
void mdwrite(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
Definition: md.c:674
void mdprefetch(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
Definition: md.c:537
void mdclose(SMgrRelation reln, ForkNumber forknum)
Definition: md.c:506
void mdcreate(SMgrRelation reln, ForkNumber forkNum, bool isRedo)
Definition: md.c:178
void mdread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer)
Definition: md.c:609

Definition at line 66 of file smgr.c.

◆ unowned_relns

dlist_head unowned_relns
static

Definition at line 95 of file smgr.c.