src/include/storage/smgr.h

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