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)
 
BlockNumber smgrnblocks_cached (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 77 of file smgr.h.

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

Typedef Documentation

◆ SMgrRelation

Definition at line 75 of file smgr.h.

◆ SMgrRelationData

Function Documentation

◆ AtEOXact_SMgr()

void AtEOXact_SMgr ( void  )

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

679 {
680  dlist_mutable_iter iter;
681 
682  /*
683  * Zap all unowned SMgrRelations. We rely on smgrclose() to remove each
684  * one from the list.
685  */
687  {
689  iter.cur);
690 
691  Assert(rel->smgr_owner == NULL);
692 
693  smgrclose(rel);
694  }
695 }
void smgrclose(SMgrRelation reln)
Definition: smgr.c:256
dlist_node * cur
Definition: ilist.h:180
#define dlist_foreach_modify(iter, lhead)
Definition: ilist.h:543
#define dlist_container(type, membername, ptr)
Definition: ilist.h:496
struct SMgrRelationData ** smgr_owner
Definition: smgr.h:45
#define Assert(condition)
Definition: c.h:804
static dlist_head unowned_relns
Definition: smgr.c:96

◆ 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:72
static dlist_head unowned_relns
Definition: smgr.c:96

◆ 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:67
void(* smgr_close)(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:45
static HTAB * SMgrRelationHash
Definition: smgr.c:94
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:954
#define ERROR
Definition: elog.h:46
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:62
#define MAX_FORKNUM
Definition: relpath.h:55
#define elog(elevel,...)
Definition: elog.h:232
dlist_node node
Definition: smgr.h:72

◆ 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:94
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1436
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1426
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:75
static HTAB * SMgrRelationHash
Definition: smgr.c:94
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:954

◆ 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:67
void(* smgr_create)(SMgrRelation reln, ForkNumber forknum, bool isRedo)
Definition: smgr.c:46
int smgr_which
Definition: smgr.h:62

◆ 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:67
void(* smgr_immedsync)(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:64
void FlushRelationsAllBuffers(SMgrRelation *smgrs, int nrels)
Definition: bufmgr.c:3617
ForkNumber
Definition: relpath.h:40
int smgr_which
Definition: smgr.h:62
#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  * Get rid of any remaining buffers for the relations. bufmgr will just
395  * drop them without bothering to write the contents.
396  */
397  DropRelFileNodesAllBuffers(rels, nrels);
398 
399  /*
400  * create an array which contains all relations to be dropped, and close
401  * each relation's forks at the smgr level while at it
402  */
403  rnodes = palloc(sizeof(RelFileNodeBackend) * nrels);
404  for (i = 0; i < nrels; i++)
405  {
406  RelFileNodeBackend rnode = rels[i]->smgr_rnode;
407  int which = rels[i]->smgr_which;
408 
409  rnodes[i] = rnode;
410 
411  /* Close the forks at smgr level */
412  for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
413  smgrsw[which].smgr_close(rels[i], forknum);
414  }
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:1378
static const f_smgr smgrsw[]
Definition: smgr.c:67
void pfree(void *pointer)
Definition: mcxt.c:1169
RelFileNodeBackend smgr_rnode
Definition: smgr.h:42
ForkNumber
Definition: relpath.h:40
int smgr_which
Definition: smgr.h:62
#define MAX_FORKNUM
Definition: relpath.h:55
void DropRelFileNodesAllBuffers(SMgrRelation *smgr_reln, int nnodes)
Definition: bufmgr.c:3191
void * palloc(Size size)
Definition: mcxt.c:1062
int i

◆ smgrexists()

◆ smgrextend()

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

Definition at line 462 of file smgr.c.

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

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

464 {
465  smgrsw[reln->smgr_which].smgr_extend(reln, forknum, blocknum,
466  buffer, skipFsync);
467 
468  /*
469  * Normally we expect this to increase nblocks by one, but if the cached
470  * value isn't as expected, just invalidate it so the next call asks the
471  * kernel.
472  */
473  if (reln->smgr_cached_nblocks[forknum] == blocknum)
474  reln->smgr_cached_nblocks[forknum] = blocknum + 1;
475  else
476  reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
477 }
static const f_smgr smgrsw[]
Definition: smgr.c:67
BlockNumber smgr_cached_nblocks[MAX_FORKNUM+1]
Definition: smgr.h:54
int smgr_which
Definition: smgr.h:62
#define InvalidBlockNumber
Definition: block.h:33
void(* smgr_extend)(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
Definition: smgr.c:51

◆ smgrimmedsync()

void smgrimmedsync ( SMgrRelation  reln,
ForkNumber  forknum 
)

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

661 {
662  smgrsw[reln->smgr_which].smgr_immedsync(reln, forknum);
663 }
static const f_smgr smgrsw[]
Definition: smgr.c:67
void(* smgr_immedsync)(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:64
int smgr_which
Definition: smgr.h:62

◆ smgrinit()

void smgrinit ( void  )

Definition at line 111 of file smgr.c.

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

Referenced by BaseInit().

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

◆ smgrnblocks()

BlockNumber smgrnblocks ( SMgrRelation  reln,
ForkNumber  forknum 
)

Definition at line 548 of file smgr.c.

References InvalidBlockNumber, SMgrRelationData::smgr_cached_nblocks, f_smgr::smgr_nblocks, SMgrRelationData::smgr_which, and smgrnblocks_cached().

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

549 {
550  BlockNumber result;
551 
552  /* Check and return if we get the cached value for the number of blocks. */
553  result = smgrnblocks_cached(reln, forknum);
554  if (result != InvalidBlockNumber)
555  return result;
556 
557  result = smgrsw[reln->smgr_which].smgr_nblocks(reln, forknum);
558 
559  reln->smgr_cached_nblocks[forknum] = result;
560 
561  return result;
562 }
static const f_smgr smgrsw[]
Definition: smgr.c:67
uint32 BlockNumber
Definition: block.h:31
BlockNumber smgr_cached_nblocks[MAX_FORKNUM+1]
Definition: smgr.h:54
BlockNumber smgrnblocks_cached(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:572
BlockNumber(* smgr_nblocks)(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:61
int smgr_which
Definition: smgr.h:62
#define InvalidBlockNumber
Definition: block.h:33

◆ smgrnblocks_cached()

BlockNumber smgrnblocks_cached ( SMgrRelation  reln,
ForkNumber  forknum 
)

Definition at line 572 of file smgr.c.

References InRecovery, InvalidBlockNumber, and SMgrRelationData::smgr_cached_nblocks.

Referenced by DropRelFileNodeBuffers(), DropRelFileNodesAllBuffers(), and smgrnblocks().

573 {
574  /*
575  * For now, we only use cached values in recovery due to lack of a shared
576  * invalidation mechanism for changes in file size.
577  */
578  if (InRecovery && reln->smgr_cached_nblocks[forknum] != InvalidBlockNumber)
579  return reln->smgr_cached_nblocks[forknum];
580 
581  return InvalidBlockNumber;
582 }
bool InRecovery
Definition: xlog.c:207
BlockNumber smgr_cached_nblocks[MAX_FORKNUM+1]
Definition: smgr.h:54
#define InvalidBlockNumber
Definition: block.h:33

◆ smgropen()

SMgrRelation smgropen ( RelFileNode  rnode,
BackendId  backend 
)

Definition at line 146 of file smgr.c.

References RelFileNodeBackend::backend, dlist_init(), dlist_push_tail(), HASHCTL::entrysize, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), i, InvalidBlockNumber, HASHCTL::keysize, MAX_FORKNUM, SMgrRelationData::node, RelFileNodeBackend::node, SMgrRelationData::smgr_cached_nblocks, f_smgr::smgr_open, SMgrRelationData::smgr_owner, SMgrRelationData::smgr_targblock, 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().

147 {
148  RelFileNodeBackend brnode;
149  SMgrRelation reln;
150  bool found;
151 
152  if (SMgrRelationHash == NULL)
153  {
154  /* First time through: initialize the hash table */
155  HASHCTL ctl;
156 
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;
177  for (int i = 0; i <= MAX_FORKNUM; ++i)
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
#define HASH_ELEM
Definition: hsearch.h:95
SMgrRelationData * SMgrRelation
Definition: smgr.h:75
static const f_smgr smgrsw[]
Definition: smgr.c:67
static void dlist_push_tail(dlist_head *head, dlist_node *node)
Definition: ilist.h:317
Size entrysize
Definition: hsearch.h:76
static HTAB * SMgrRelationHash
Definition: smgr.c:94
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:954
BlockNumber smgr_cached_nblocks[MAX_FORKNUM+1]
Definition: smgr.h:54
void(* smgr_open)(SMgrRelation reln)
Definition: smgr.c:44
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:349
struct SMgrRelationData ** smgr_owner
Definition: smgr.h:45
#define HASH_BLOBS
Definition: hsearch.h:97
int smgr_which
Definition: smgr.h:62
struct RelFileNodeBackend RelFileNodeBackend
Size keysize
Definition: hsearch.h:75
static void dlist_init(dlist_head *head)
Definition: ilist.h:278
RelFileNode node
Definition: relfilenode.h:74
BlockNumber smgr_targblock
Definition: smgr.h:53
BackendId backend
Definition: relfilenode.h:75
#define InvalidBlockNumber
Definition: block.h:33
#define MAX_FORKNUM
Definition: relpath.h:55
int i
dlist_node node
Definition: smgr.h:72
static dlist_head unowned_relns
Definition: smgr.c:96

◆ smgrprefetch()

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

Definition at line 487 of file smgr.c.

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

Referenced by PrefetchLocalBuffer(), and PrefetchSharedBuffer().

488 {
489  return smgrsw[reln->smgr_which].smgr_prefetch(reln, forknum, blocknum);
490 }
static const f_smgr smgrsw[]
Definition: smgr.c:67
bool(* smgr_prefetch)(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
Definition: smgr.c:53
int smgr_which
Definition: smgr.h:62

◆ smgrread()

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

Definition at line 501 of file smgr.c.

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

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

503 {
504  smgrsw[reln->smgr_which].smgr_read(reln, forknum, blocknum, buffer);
505 }
static const f_smgr smgrsw[]
Definition: smgr.c:67
void(* smgr_read)(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer)
Definition: smgr.c:55
int smgr_which
Definition: smgr.h:62

◆ 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:804
dlist_node node
Definition: smgr.h:72

◆ smgrtruncate()

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

Definition at line 595 of file smgr.c.

References CacheInvalidateSmgr(), DropRelFileNodeBuffers(), i, InvalidBlockNumber, SMgrRelationData::smgr_cached_nblocks, SMgrRelationData::smgr_rnode, f_smgr::smgr_truncate, and SMgrRelationData::smgr_which.

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

596 {
597  int i;
598 
599  /*
600  * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
601  * just drop them without bothering to write the contents.
602  */
603  DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
604 
605  /*
606  * Send a shared-inval message to force other backends to close any smgr
607  * references they may have for this rel. This is useful because they
608  * might have open file pointers to segments that got removed, and/or
609  * smgr_targblock variables pointing past the new rel end. (The inval
610  * message will come back to our backend, too, causing a
611  * probably-unnecessary local smgr flush. But we don't expect that this
612  * is a performance-critical path.) As in the unlink code, we want to be
613  * sure the message is sent before we start changing things on-disk.
614  */
616 
617  /* Do the truncation */
618  for (i = 0; i < nforks; i++)
619  {
620  /* Make the cached size is invalid if we encounter an error. */
621  reln->smgr_cached_nblocks[forknum[i]] = InvalidBlockNumber;
622 
623  smgrsw[reln->smgr_which].smgr_truncate(reln, forknum[i], nblocks[i]);
624 
625  /*
626  * We might as well update the local smgr_cached_nblocks values. The
627  * smgr cache inval message that this function sent will cause other
628  * backends to invalidate their copies of smgr_fsm_nblocks and
629  * smgr_vm_nblocks, and these ones too at the next command boundary.
630  * But these ensure they aren't outright wrong until then.
631  */
632  reln->smgr_cached_nblocks[forknum[i]] = nblocks[i];
633  }
634 }
void CacheInvalidateSmgr(RelFileNodeBackend rnode)
Definition: inval.c:1378
void(* smgr_truncate)(SMgrRelation reln, ForkNumber forknum, BlockNumber nblocks)
Definition: smgr.c:62
static const f_smgr smgrsw[]
Definition: smgr.c:67
BlockNumber smgr_cached_nblocks[MAX_FORKNUM+1]
Definition: smgr.h:54
RelFileNodeBackend smgr_rnode
Definition: smgr.h:42
void DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum, int nforks, BlockNumber *firstDelBlock)
Definition: bufmgr.c:3067
int smgr_which
Definition: smgr.h:62
#define InvalidBlockNumber
Definition: block.h:33
int i

◆ smgrwrite()

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

Definition at line 523 of file smgr.c.

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

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

525 {
526  smgrsw[reln->smgr_which].smgr_write(reln, forknum, blocknum,
527  buffer, skipFsync);
528 }
void(* smgr_write)(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync)
Definition: smgr.c:57
static const f_smgr smgrsw[]
Definition: smgr.c:67
int smgr_which
Definition: smgr.h:62

◆ smgrwriteback()

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

Definition at line 536 of file smgr.c.

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

Referenced by IssuePendingWritebacks().

538 {
539  smgrsw[reln->smgr_which].smgr_writeback(reln, forknum, blocknum,
540  nblocks);
541 }
static const f_smgr smgrsw[]
Definition: smgr.c:67
int smgr_which
Definition: smgr.h:62
void(* smgr_writeback)(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, BlockNumber nblocks)
Definition: smgr.c:59