src/include/storage/smgr.h

   1 /*-------------------------------------------------------------------------
   2  *
   3  * smgr.h
   4  *        storage manager switch public interface declarations.
   5  *
   6  *
   7  * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
   8  * Portions Copyright (c) 1994, Regents of the University of California
   9  *
  10  * src/include/storage/smgr.h
  11  *
  12  *-------------------------------------------------------------------------
  13  */
  14 #ifndef SMGR_H
  15 #define SMGR_H
  16
  17 #include "access/xlog.h"
  18 #include "fmgr.h"
  19 #include "storage/backendid.h"
  20 #include "storage/block.h"
  21 #include "storage/relfilenode.h"
  22
  23
  24 /*
  25  * smgr.c maintains a table of SMgrRelation objects, which are essentially
  26  * cached file handles.  An SMgrRelation is created (if not already present)
  27  * by smgropen(), and destroyed by smgrclose().  Note that neither of these
  28  * operations imply I/O, they just create or destroy a hashtable entry.
  29  * (But smgrclose() may release associated resources, such as OS-level file
  30  * descriptors.)
  31  *
  32  * An SMgrRelation may have an "owner", which is just a pointer to it from
  33  * somewhere else; smgr.c will clear this pointer if the SMgrRelation is
  34  * closed.      We use this to avoid dangling pointers from relcache to smgr
  35  * without having to make the smgr explicitly aware of relcache.  There
  36  * can't be more than one "owner" pointer per SMgrRelation, but that's
  37  * all we need.
  38  */
  39 typedef struct SMgrRelationData
  40 {
  41         /* rnode is the hashtable lookup key, so it must be first! */
  42         RelFileNodeBackend smgr_rnode;          /* relation physical identifier */
  43
  44         /* pointer to owning pointer, or NULL if none */
  45         struct SMgrRelationData **smgr_owner;
  46
  47         /*
  48          * These next three fields are not actually used or manipulated by smgr,
  49          * except that they are reset to InvalidBlockNumber upon a cache flush
  50          * event (in particular, upon truncation of the relation).      Higher levels
  51          * store cached state here so that it will be reset when truncation
  52          * happens.  In all three cases, InvalidBlockNumber means "unknown".
  53          */
  54         BlockNumber smgr_targblock; /* current insertion target block */
  55         BlockNumber smgr_fsm_nblocks;           /* last known size of fsm fork */
  56         BlockNumber smgr_vm_nblocks;    /* last known size of vm fork */
  57
  58         /* additional public fields may someday exist here */
  59
  60         /*
  61          * Fields below here are intended to be private to smgr.c and its
  62          * submodules.  Do not touch them from elsewhere.
  63          */
  64         int                     smgr_which;             /* storage manager selector */
  65
  66         /* for md.c; NULL for forks that are not open */
  67         struct _MdfdVec *md_fd[MAX_FORKNUM + 1];
  68 } SMgrRelationData;
  69
  70 typedef SMgrRelationData *SMgrRelation;
  71
  72 #define SmgrIsTemp(smgr) \
  73         ((smgr)->smgr_rnode.backend != InvalidBackendId)
  74
  75 extern void smgrinit(void);
  76 extern SMgrRelation smgropen(RelFileNode rnode, BackendId backend);
  77 extern bool smgrexists(SMgrRelation reln, ForkNumber forknum);
  78 extern void smgrsetowner(SMgrRelation *owner, SMgrRelation reln);
  79 extern void smgrclose(SMgrRelation reln);
  80 extern void smgrcloseall(void);
  81 extern void smgrclosenode(RelFileNodeBackend rnode);
  82 extern void smgrcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo);
  83 extern void smgrdounlink(SMgrRelation reln, ForkNumber forknum,
  84                          bool isRedo);
  85 extern void smgrextend(SMgrRelation reln, ForkNumber forknum,
  86                    BlockNumber blocknum, char *buffer, bool skipFsync);
  87 extern void smgrprefetch(SMgrRelation reln, ForkNumber forknum,
  88                          BlockNumber blocknum);
  89 extern void smgrread(SMgrRelation reln, ForkNumber forknum,
  90                  BlockNumber blocknum, char *buffer);
  91 extern void smgrwrite(SMgrRelation reln, ForkNumber forknum,
  92                   BlockNumber blocknum, char *buffer, bool skipFsync);
  93 extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum);
  94 extern void smgrtruncate(SMgrRelation reln, ForkNumber forknum,
  95                          BlockNumber nblocks);
  96 extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
  97 extern void smgrpreckpt(void);
  98 extern void smgrsync(void);
  99 extern void smgrpostckpt(void);
 100
 101
 102 /* internals: move me elsewhere -- ay 7/94 */
 103
 104 /* in md.c */
 105 extern void mdinit(void);
 106 extern void mdclose(SMgrRelation reln, ForkNumber forknum);
 107 extern void mdcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo);
 108 extern bool mdexists(SMgrRelation reln, ForkNumber forknum);
 109 extern void mdunlink(RelFileNodeBackend rnode, ForkNumber forknum, bool isRedo);
 110 extern void mdextend(SMgrRelation reln, ForkNumber forknum,
 111                  BlockNumber blocknum, char *buffer, bool skipFsync);
 112 extern void mdprefetch(SMgrRelation reln, ForkNumber forknum,
 113                    BlockNumber blocknum);
 114 extern void mdread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 115            char *buffer);
 116 extern void mdwrite(SMgrRelation reln, ForkNumber forknum,
 117                 BlockNumber blocknum, char *buffer, bool skipFsync);
 118 extern BlockNumber mdnblocks(SMgrRelation reln, ForkNumber forknum);
 119 extern void mdtruncate(SMgrRelation reln, ForkNumber forknum,
 120                    BlockNumber nblocks);
 121 extern void mdimmedsync(SMgrRelation reln, ForkNumber forknum);
 122 extern void mdpreckpt(void);
 123 extern void mdsync(void);
 124 extern void mdpostckpt(void);
 125
 126 extern void SetForwardFsyncRequests(void);
 127 extern void RememberFsyncRequest(RelFileNodeBackend rnode, ForkNumber forknum,
 128                                          BlockNumber segno);
 129 extern void ForgetRelationFsyncRequests(RelFileNodeBackend rnode,
 130                                                         ForkNumber forknum);
 131 extern void ForgetDatabaseFsyncRequests(Oid dbid);
 132
 133 /* smgrtype.c */
 134 extern Datum smgrout(PG_FUNCTION_ARGS);
 135 extern Datum smgrin(PG_FUNCTION_ARGS);
 136 extern Datum smgreq(PG_FUNCTION_ARGS);
 137 extern Datum smgrne(PG_FUNCTION_ARGS);
 138
 139 #endif   /* SMGR_H */