131 lines
5.0 KiB
C
131 lines
5.0 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* smgr.h
|
|
* storage manager switch public interface declarations.
|
|
*
|
|
*
|
|
* Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
* src/include/storage/smgr.h
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#ifndef SMGR_H
|
|
#define SMGR_H
|
|
|
|
#include "lib/ilist.h"
|
|
#include "storage/block.h"
|
|
#include "storage/relfilelocator.h"
|
|
|
|
/*
|
|
* smgr.c maintains a table of SMgrRelation objects, which are essentially
|
|
* cached file handles. An SMgrRelation is created (if not already present)
|
|
* by smgropen(), and destroyed by smgrclose(). Note that neither of these
|
|
* operations imply I/O, they just create or destroy a hashtable entry.
|
|
* (But smgrclose() may release associated resources, such as OS-level file
|
|
* descriptors.)
|
|
*
|
|
* An SMgrRelation may have an "owner", which is just a pointer to it from
|
|
* somewhere else; smgr.c will clear this pointer if the SMgrRelation is
|
|
* closed. We use this to avoid dangling pointers from relcache to smgr
|
|
* without having to make the smgr explicitly aware of relcache. There
|
|
* can't be more than one "owner" pointer per SMgrRelation, but that's
|
|
* all we need.
|
|
*
|
|
* SMgrRelations that do not have an "owner" are considered to be transient,
|
|
* and are deleted at end of transaction.
|
|
*/
|
|
typedef struct SMgrRelationData
|
|
{
|
|
/* rlocator is the hashtable lookup key, so it must be first! */
|
|
RelFileLocatorBackend smgr_rlocator; /* relation physical identifier */
|
|
|
|
/* pointer to owning pointer, or NULL if none */
|
|
struct SMgrRelationData **smgr_owner;
|
|
|
|
/*
|
|
* The following fields are reset to InvalidBlockNumber upon a cache flush
|
|
* event, and hold the last known size for each fork. This information is
|
|
* currently only reliable during recovery, since there is no cache
|
|
* invalidation for fork extension.
|
|
*/
|
|
BlockNumber smgr_targblock; /* current insertion target block */
|
|
BlockNumber smgr_cached_nblocks[MAX_FORKNUM + 1]; /* last known size */
|
|
|
|
/* additional public fields may someday exist here */
|
|
|
|
/*
|
|
* Fields below here are intended to be private to smgr.c and its
|
|
* submodules. Do not touch them from elsewhere.
|
|
*/
|
|
int smgr_which; /* storage manager selector */
|
|
|
|
/*
|
|
* for md.c; per-fork arrays of the number of open segments
|
|
* (md_num_open_segs) and the segments themselves (md_seg_fds).
|
|
*/
|
|
int md_num_open_segs[MAX_FORKNUM + 1];
|
|
struct _MdfdVec *md_seg_fds[MAX_FORKNUM + 1];
|
|
|
|
/* if unowned, list link in list of all unowned SMgrRelations */
|
|
dlist_node node;
|
|
} SMgrRelationData;
|
|
|
|
typedef SMgrRelationData *SMgrRelation;
|
|
|
|
#define SmgrIsTemp(smgr) \
|
|
RelFileLocatorBackendIsTemp((smgr)->smgr_rlocator)
|
|
|
|
extern void smgrinit(void);
|
|
extern SMgrRelation smgropen(RelFileLocator rlocator, BackendId backend);
|
|
extern bool smgrexists(SMgrRelation reln, ForkNumber forknum);
|
|
extern void smgrsetowner(SMgrRelation *owner, SMgrRelation reln);
|
|
extern void smgrclearowner(SMgrRelation *owner, SMgrRelation reln);
|
|
extern void smgrclose(SMgrRelation reln);
|
|
extern void smgrcloseall(void);
|
|
extern void smgrcloserellocator(RelFileLocatorBackend rlocator);
|
|
extern void smgrrelease(SMgrRelation reln);
|
|
extern void smgrreleaseall(void);
|
|
extern void smgrcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo);
|
|
extern void smgrdosyncall(SMgrRelation *rels, int nrels);
|
|
extern void smgrdounlinkall(SMgrRelation *rels, int nrels, bool isRedo);
|
|
extern void smgrextend(SMgrRelation reln, ForkNumber forknum,
|
|
BlockNumber blocknum, const void *buffer, bool skipFsync);
|
|
extern void smgrzeroextend(SMgrRelation reln, ForkNumber forknum,
|
|
BlockNumber blocknum, int nblocks, bool skipFsync);
|
|
extern bool smgrprefetch(SMgrRelation reln, ForkNumber forknum,
|
|
BlockNumber blocknum, int nblocks);
|
|
extern void smgrreadv(SMgrRelation reln, ForkNumber forknum,
|
|
BlockNumber blocknum,
|
|
void **buffer, BlockNumber nblocks);
|
|
extern void smgrwritev(SMgrRelation reln, ForkNumber forknum,
|
|
BlockNumber blocknum,
|
|
const void **buffer, BlockNumber nblocks,
|
|
bool skipFsync);
|
|
extern void smgrwriteback(SMgrRelation reln, ForkNumber forknum,
|
|
BlockNumber blocknum, BlockNumber nblocks);
|
|
extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum);
|
|
extern BlockNumber smgrnblocks_cached(SMgrRelation reln, ForkNumber forknum);
|
|
extern void smgrtruncate(SMgrRelation reln, ForkNumber *forknum,
|
|
int nforks, BlockNumber *nblocks);
|
|
extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
|
|
extern void AtEOXact_SMgr(void);
|
|
extern bool ProcessBarrierSmgrRelease(void);
|
|
|
|
static inline void
|
|
smgrread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
|
|
void *buffer)
|
|
{
|
|
smgrreadv(reln, forknum, blocknum, &buffer, 1);
|
|
}
|
|
|
|
static inline void
|
|
smgrwrite(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
|
|
const void *buffer, bool skipFsync)
|
|
{
|
|
smgrwritev(reln, forknum, blocknum, &buffer, 1, skipFsync);
|
|
}
|
|
|
|
#endif /* SMGR_H */
|