smgr.h

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * smgr.h
 *    storage manager switch public interface declarations.
 *
 *
 * Portions Copyright (c) 1996-2025, 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/aio_types.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 smgrdestroy().  Note that neither of these
 * operations imply I/O, they just create or destroy a hashtable entry.  (But
 * smgrdestroy() may release associated resources, such as OS-level file
 * descriptors.)
 *
 * An SMgrRelation may be "pinned", to prevent it from being destroyed while
 * it's in use.  We use this to prevent pointers in relcache to smgr from being
 * invalidated.  SMgrRelations that are not pinned 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 */
 
    /*
     * 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];
 
    /*
     * Pinning support.  If unpinned (ie. pincount == 0), 'node' is a list
     * link in list of all unpinned SMgrRelations.
     */
    int         pincount;
    dlist_node  node;
} SMgrRelationData;
 
typedef SMgrRelationData *SMgrRelation;
 
#define SmgrIsTemp(smgr) \
    RelFileLocatorBackendIsTemp((smgr)->smgr_rlocator)
 
extern PGDLLIMPORT const PgAioTargetInfo aio_smgr_target_info;
 
extern void smgrinit(void);
extern SMgrRelation smgropen(RelFileLocator rlocator, ProcNumber backend);
extern bool smgrexists(SMgrRelation reln, ForkNumber forknum);
extern void smgrpin(SMgrRelation reln);
extern void smgrunpin(SMgrRelation reln);
extern void smgrclose(SMgrRelation reln);
extern void smgrdestroyall(void);
extern void smgrrelease(SMgrRelation reln);
extern void smgrreleaseall(void);
extern void smgrreleaserellocator(RelFileLocatorBackend rlocator);
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 uint32 smgrmaxcombine(SMgrRelation reln, ForkNumber forknum,
                             BlockNumber blocknum);
extern void smgrreadv(SMgrRelation reln, ForkNumber forknum,
                      BlockNumber blocknum,
                      void **buffers, BlockNumber nblocks);
extern void smgrstartreadv(PgAioHandle *ioh,
                           SMgrRelation reln, ForkNumber forknum,
                           BlockNumber blocknum,
                           void **buffers, BlockNumber nblocks);
extern void smgrwritev(SMgrRelation reln, ForkNumber forknum,
                       BlockNumber blocknum,
                       const void **buffers, 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 *old_nblocks,
                         BlockNumber *nblocks);
extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
extern void smgrregistersync(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);
}
 
extern void pgaio_io_set_target_smgr(PgAioHandle *ioh,
                                     SMgrRelationData *smgr,
                                     ForkNumber forknum,
                                     BlockNumber blocknum,
                                     int nblocks,
                                     bool skip_fsync);
 
#endif                          /* SMGR_H */