granicus.if.org Git - postgresql/blob - src/include/storage/smgr.h

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