open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Buffer manager modifications to keep a local buffer-dirtied bit as well

Browse Source 
as a shared dirtybit for each shared buffer.  The shared dirtybit still
controls writing the buffer, but the local bit controls whether we need
to fsync the buffer's file.  This arrangement fixes a bug that allowed
some required fsyncs to be missed, and should improve performance as well.
For more info see my post of same date on pghackers.
REL7_0_PATCHES
Tom Lane 26 years ago
parent 9c38a8d296
commit 1f6d8b90b8
13 changed files with 951 additions and 431 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 11
      src/backend/access/transam/xact.c
  2. 74
      src/backend/catalog/catalog.c
  3. 14
      src/backend/storage/buffer/buf_init.c
  4. 606
      src/backend/storage/buffer/bufmgr.c
  5. 8
      src/backend/storage/buffer/freelist.c
  6. 107
      src/backend/storage/file/fd.c
  7. 374
      src/backend/storage/smgr/md.c
  8. 114
      src/backend/storage/smgr/smgr.c
  9. 4
      src/include/catalog/catalog.h
  10. 19
      src/include/storage/buf_internals.h
  11. 4
      src/include/storage/bufmgr.h
  12. 5
      src/include/storage/fd.h
  13. 42
      src/include/storage/smgr.h

11
src/backend/access/transam/xact.c
Unescape View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.62 2000/03/17 02:36:05 tgl Exp $ * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.63 2000/04/09 04:43:16 tgl Exp $
* *
* NOTES * NOTES
* Transaction aborts can now occur two ways: * Transaction aborts can now occur two ways:
@ -642,7 +642,7 @@ RecordTransactionCommit()
{ {
FlushBufferPool(); FlushBufferPool();
if (leak) if (leak)
ResetBufferPool(); ResetBufferPool(true);
/* /*
* have the transaction access methods record the status * have the transaction access methods record the status
@ -658,7 +658,7 @@ RecordTransactionCommit()
} }
if (leak) if (leak)
ResetBufferPool(); ResetBufferPool(true);
} }
@ -759,7 +759,10 @@ RecordTransactionAbort()
if (SharedBufferChanged && !TransactionIdDidCommit(xid)) if (SharedBufferChanged && !TransactionIdDidCommit(xid))
TransactionIdAbort(xid); TransactionIdAbort(xid);
ResetBufferPool(); /*
* Tell bufmgr and smgr to release resources.
*/
ResetBufferPool(false); /* false -> is abort */
} }
/* -------------------------------- /* --------------------------------

74
src/backend/catalog/catalog.c
Unescape View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/catalog/catalog.c,v 1.30 2000/01/26 05:56:10 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/catalog/catalog.c,v 1.31 2000/04/09 04:43:15 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -23,25 +23,87 @@
#include "utils/syscache.h" #include "utils/syscache.h"
/* /*
* relpath - path to the relation * relpath - construct path to a relation's file
* Perhaps this should be in-line code in relopen(). *
* Note that this only works with relations that are visible to the current
* backend, ie, either in the current database or shared system relations.
*
* Result is a palloc'd string.
*/ */
char * char *
relpath(const char *relname) relpath(const char *relname)
{ {
char *path; char *path;
size_t bufsize = 0;
if (IsSharedSystemRelationName(relname)) if (IsSharedSystemRelationName(relname))
{ {
bufsize = strlen(DataDir) + sizeof(NameData) + 2; /* Shared system relations live in DataDir */
size_t bufsize = strlen(DataDir) + sizeof(NameData) + 2;
path = (char *) palloc(bufsize); path = (char *) palloc(bufsize);
snprintf(path, bufsize, "%s/%s", DataDir, relname); snprintf(path, bufsize, "%s%c%s", DataDir, SEP_CHAR, relname);
return path; return path;
} }
/*
* If it is in the current database, assume it is in current working
* directory. NB: this does not work during bootstrap!
*/
return pstrdup(relname); return pstrdup(relname);
} }
/*
* relpath_blind - construct path to a relation's file
*
* Construct the path using only the info available to smgrblindwrt,
* namely the names and OIDs of the database and relation. (Shared system
* relations are identified with dbid = 0.) Note that we may have to
* access a relation belonging to a different database!
*
* Result is a palloc'd string.
*/
char *
relpath_blind(const char *dbname, const char *relname,
Oid dbid, Oid relid)
{
char *path;
if (dbid == (Oid) 0)
{
/* Shared system relations live in DataDir */
path = (char *) palloc(strlen(DataDir) + sizeof(NameData) + 2);
sprintf(path, "%s%c%s", DataDir, SEP_CHAR, relname);
}
else if (dbid == MyDatabaseId)
{
/* XXX why is this inconsistent with relpath() ? */
path = (char *) palloc(strlen(DatabasePath) + sizeof(NameData) + 2);
sprintf(path, "%s%c%s", DatabasePath, SEP_CHAR, relname);
}
else
{
/* this is work around only !!! */
char dbpathtmp[MAXPGPATH];
Oid id;
char *dbpath;
GetRawDatabaseInfo(dbname, &id, dbpathtmp);
if (id != dbid)
elog(FATAL, "relpath_blind: oid of db %s is not %u",
dbname, dbid);
dbpath = ExpandDatabasePath(dbpathtmp);
if (dbpath == NULL)
elog(FATAL, "relpath_blind: can't expand path for db %s",
dbname);
path = (char *) palloc(strlen(dbpath) + sizeof(NameData) + 2);
sprintf(path, "%s%c%s", dbpath, SEP_CHAR, relname);
pfree(dbpath);
}
return path;
}
/* /*
* IsSystemRelationName * IsSystemRelationName
* True iff name is the name of a system catalog relation. * True iff name is the name of a system catalog relation.

14
src/backend/storage/buffer/buf_init.c
Unescape View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_init.c,v 1.32 2000/01/26 05:56:50 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_init.c,v 1.33 2000/04/09 04:43:18 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -65,9 +65,11 @@ long *NWaitIOBackendP;
extern IpcSemaphoreId WaitIOSemId; extern IpcSemaphoreId WaitIOSemId;
long *PrivateRefCount; /* also used in freelist.c */ long *PrivateRefCount; /* also used in freelist.c */
bits8 *BufferLocks; /* */ bits8 *BufferLocks; /* flag bits showing locks I have set */
long *CommitInfoNeedsSave;/* to write buffers where we have filled BufferTag *BufferTagLastDirtied; /* tag buffer had when last dirtied by me */
* in t_infomask */ BufferBlindId *BufferBlindLastDirtied; /* and its BlindId too */
bool *BufferDirtiedByMe; /* T if buf has been dirtied in cur xact */
/* /*
* Data Structures: * Data Structures:
@ -247,7 +249,9 @@ InitBufferPool(IPCKey key)
#endif #endif
PrivateRefCount = (long *) calloc(NBuffers, sizeof(long)); PrivateRefCount = (long *) calloc(NBuffers, sizeof(long));
BufferLocks = (bits8 *) calloc(NBuffers, sizeof(bits8)); BufferLocks = (bits8 *) calloc(NBuffers, sizeof(bits8));
CommitInfoNeedsSave = (long *) calloc(NBuffers, sizeof(long)); BufferTagLastDirtied = (BufferTag *) calloc(NBuffers, sizeof(BufferTag));
BufferBlindLastDirtied = (BufferBlindId *) calloc(NBuffers, sizeof(BufferBlindId));
BufferDirtiedByMe = (bool *) calloc(NBuffers, sizeof(bool));
} }
/* ----------------------------------------------------- /* -----------------------------------------------------

606
src/backend/storage/buffer/bufmgr.c
View File

File diff suppressed because it is too large Load Diff

8
src/backend/storage/buffer/freelist.c
Unescape View File

@ -9,7 +9,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/buffer/freelist.c,v 1.20 2000/01/26 05:56:52 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/freelist.c,v 1.21 2000/04/09 04:43:19 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -122,7 +122,7 @@ PinBuffer_Debug(char *file, int line, BufferDesc *buf)
fprintf(stderr, "PIN(Pin) %ld relname = %s, blockNum = %d, \ fprintf(stderr, "PIN(Pin) %ld relname = %s, blockNum = %d, \
refcount = %ld, file: %s, line: %d\n", refcount = %ld, file: %s, line: %d\n",
buffer, buf->sb_relname, buf->tag.blockNum, buffer, buf->blind.relname, buf->tag.blockNum,
PrivateRefCount[buffer - 1], file, line); PrivateRefCount[buffer - 1], file, line);
} }
} }
@ -168,7 +168,7 @@ UnpinBuffer_Debug(char *file, int line, BufferDesc *buf)
fprintf(stderr, "UNPIN(Unpin) %ld relname = %s, blockNum = %d, \ fprintf(stderr, "UNPIN(Unpin) %ld relname = %s, blockNum = %d, \
refcount = %ld, file: %s, line: %d\n", refcount = %ld, file: %s, line: %d\n",
buffer, buf->sb_relname, buf->tag.blockNum, buffer, buf->blind.relname, buf->tag.blockNum,
PrivateRefCount[buffer - 1], file, line); PrivateRefCount[buffer - 1], file, line);
} }
} }
@ -304,7 +304,7 @@ PrintBufferFreeList()
int i = (buf - BufferDescriptors); int i = (buf - BufferDescriptors);
printf("[%-2d] (%s, %d) flags=0x%x, refcnt=%d %ld, nxt=%ld prv=%ld)\n", printf("[%-2d] (%s, %d) flags=0x%x, refcnt=%d %ld, nxt=%ld prv=%ld)\n",
i, buf->sb_relname, buf->tag.blockNum, i, buf->blind.relname, buf->tag.blockNum,
buf->flags, buf->refcount, PrivateRefCount[i], buf->flags, buf->refcount, PrivateRefCount[i],
buf->freeNext, buf->freePrev); buf->freeNext, buf->freePrev);

107
src/backend/storage/file/fd.c
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/file/fd.c,v 1.54 2000/03/17 02:36:19 tgl Exp $ * $Header: /cvsroot/pgsql/src/backend/storage/file/fd.c,v 1.55 2000/04/09 04:43:19 tgl Exp $
* *
* NOTES: * NOTES:
* *
@ -293,7 +293,7 @@ LruDelete(File file)
vfdP->seekPos = (long) lseek(vfdP->fd, 0L, SEEK_CUR); vfdP->seekPos = (long) lseek(vfdP->fd, 0L, SEEK_CUR);
Assert(vfdP->seekPos != -1); Assert(vfdP->seekPos != -1);
/* if we have written to the file, sync it */ /* if we have written to the file, sync it before closing */
if (vfdP->fdstate & FD_DIRTY) if (vfdP->fdstate & FD_DIRTY)
{ {
returnValue = pg_fsync(vfdP->fd); returnValue = pg_fsync(vfdP->fd);
@ -381,9 +381,6 @@ tryAgain:
returnValue = lseek(vfdP->fd, vfdP->seekPos, SEEK_SET); returnValue = lseek(vfdP->fd, vfdP->seekPos, SEEK_SET);
Assert(returnValue != -1); Assert(returnValue != -1);
} }
/* Update state as appropriate for re-open (needed?) */
vfdP->fdstate &= ~FD_DIRTY;
} }
/* /*
@ -804,7 +801,7 @@ FileWrite(File file, char *buffer, int amount)
if (returnCode > 0) if (returnCode > 0)
VfdCache[file].seekPos += returnCode; VfdCache[file].seekPos += returnCode;
/* record the write */ /* mark the file as needing fsync */
VfdCache[file].fdstate |= FD_DIRTY; VfdCache[file].fdstate |= FD_DIRTY;
return returnCode; return returnCode;
@ -873,6 +870,35 @@ FileTruncate(File file, long offset)
return returnCode; return returnCode;
} }
/*
* FileSync --- if a file is marked as dirty, fsync it.
*
* The FD_DIRTY bit is slightly misnamed: it doesn't mean that we need to
* write the file, but that we *have* written it and need to execute an
* fsync() to ensure the changes are down on disk before we mark the current
* transaction committed.
*
* FD_DIRTY is set by FileWrite or by an explicit FileMarkDirty() call.
* It is cleared after successfully fsync'ing the file. FileClose() will
* fsync a dirty File that is about to be closed, since there will be no
* other place to remember the need to fsync after the VFD is gone.
*
* Note that the DIRTY bit is logically associated with the actual disk file,
* not with any particular kernel FD we might have open for it. We assume
* that fsync will force out any dirty buffers for that file, whether or not
* they were written through the FD being used for the fsync call --- they
* might even have been written by some other backend!
*
* Note also that LruDelete currently fsyncs a dirty file that it is about
* to close the kernel file descriptor for. The idea there is to avoid
* having to re-open the kernel descriptor later. But it's not real clear
* that this is a performance win; we could end up fsyncing the same file
* multiple times in a transaction, which would probably cost more time
* than is saved by avoiding an open() call. This should be studied.
*
* This routine used to think it could skip the fsync if the file is
* physically closed, but that is now WRONG; see comments for FileMarkDirty.
*/
int int
FileSync(File file) FileSync(File file)
{ {
@ -880,23 +906,66 @@ FileSync(File file)
Assert(FileIsValid(file)); Assert(FileIsValid(file));
/* if (!(VfdCache[file].fdstate & FD_DIRTY))
* If the file isn't open, then we don't need to sync it; we always {
* sync files when we close them. Also, if we haven't done any writes /* Need not sync if file is not dirty. */
* that we haven't already synced, we can ignore the request.
*/
if (VfdCache[file].fd < 0 || !(VfdCache[file].fdstate & FD_DIRTY))
returnCode = 0; returnCode = 0;
else }
else if (disableFsync)
{ {
returnCode = pg_fsync(VfdCache[file].fd); /* Don't force the file open if pg_fsync isn't gonna sync it. */
returnCode = 0;
VfdCache[file].fdstate &= ~FD_DIRTY; VfdCache[file].fdstate &= ~FD_DIRTY;
} }
else
{
/* We don't use FileAccess() because we don't want to force the
* file to the front of the LRU ring; we aren't expecting to
* access it again soon.
*/
if (FileIsNotOpen(file))
{
returnCode = LruInsert(file);
if (returnCode != 0)
return returnCode;
}
returnCode = pg_fsync(VfdCache[file].fd);
if (returnCode == 0)
VfdCache[file].fdstate &= ~FD_DIRTY;
}
return returnCode; return returnCode;
} }
/*
* FileMarkDirty --- mark a file as needing fsync at transaction commit.
*
* Since FileWrite marks the file dirty, this routine is not needed in
* normal use. It is called when the buffer manager detects that some other
* backend has written out a shared buffer that this backend dirtied (but
* didn't write) in the current xact. In that scenario, we need to fsync
* the file before we can commit. We cannot assume that the other backend
* has fsync'd the file yet; we need to do our own fsync to ensure that
* (a) the disk page is written and (b) this backend's commit is delayed
* until the write is complete.
*
* Note we are assuming that an fsync issued by this backend will write
* kernel disk buffers that were dirtied by another backend. Furthermore,
* it doesn't matter whether we currently have the file physically open;
* we must fsync even if we have to re-open the file to do it.
*/
void
FileMarkDirty(File file)
{
Assert(FileIsValid(file));
DO_DB(elog(DEBUG, "FileMarkDirty: %d (%s)",
file, VfdCache[file].fileName));
VfdCache[file].fdstate |= FD_DIRTY;
}
/* /*
* Routines that want to use stdio (ie, FILE*) should use AllocateFile * Routines that want to use stdio (ie, FILE*) should use AllocateFile
* rather than plain fopen(). This lets fd.c deal with freeing FDs if * rather than plain fopen(). This lets fd.c deal with freeing FDs if
@ -992,6 +1061,12 @@ closeAllVfds()
* exit (it doesn't particularly care which). All still-open temporary-file * exit (it doesn't particularly care which). All still-open temporary-file
* VFDs are closed, which also causes the underlying files to be deleted. * VFDs are closed, which also causes the underlying files to be deleted.
* Furthermore, all "allocated" stdio files are closed. * Furthermore, all "allocated" stdio files are closed.
*
* This routine is not involved in fsync'ing non-temporary files at xact
* commit; that is done by FileSync under control of the buffer manager.
* During a commit, that is done *before* control gets here. If we still
* have any needs-fsync bits set when we get here, we assume this is abort
* and clear them.
*/ */
void void
AtEOXact_Files(void) AtEOXact_Files(void)
@ -1006,6 +1081,8 @@ AtEOXact_Files(void)
if ((VfdCache[i].fdstate & FD_TEMPORARY) && if ((VfdCache[i].fdstate & FD_TEMPORARY) &&
VfdCache[i].fileName != NULL) VfdCache[i].fileName != NULL)
FileClose(i); FileClose(i);
else
VfdCache[i].fdstate &= ~FD_DIRTY;
} }
} }

374
src/backend/storage/smgr/md.c
Unescape View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.64 2000/02/07 02:38:18 inoue Exp $ * $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.65 2000/04/09 04:43:20 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -48,7 +48,12 @@
typedef struct _MdfdVec typedef struct _MdfdVec
{ {
int mdfd_vfd; /* fd number in vfd pool */ int mdfd_vfd; /* fd number in vfd pool */
uint16 mdfd_flags; /* clean, dirty, free */ int mdfd_flags; /* free, temporary */
/* these are the assigned bits in mdfd_flags: */
#define MDFD_FREE (1 << 0)/* unused entry */
#define MDFD_TEMP (1 << 1)/* close this entry at transaction end */
int mdfd_lstbcnt; /* most recent block count */ int mdfd_lstbcnt; /* most recent block count */
int mdfd_nextFree; /* next free vector */ int mdfd_nextFree; /* next free vector */
#ifndef LET_OS_MANAGE_FILESIZE #ifndef LET_OS_MANAGE_FILESIZE
@ -62,13 +67,13 @@ static int Md_Free = -1; /* head of freelist of unused fdvec entries */
static int CurFd = 0; /* first never-used fdvec index */ static int CurFd = 0; /* first never-used fdvec index */
static MemoryContext MdCxt; /* context for all my allocations */ static MemoryContext MdCxt; /* context for all my allocations */
#define MDFD_DIRTY (uint16) 0x01
#define MDFD_FREE (uint16) 0x02
/* routines declared here */ /* routines declared here */
static void mdclose_fd(int fd);
static int _mdfd_getrelnfd(Relation reln); static int _mdfd_getrelnfd(Relation reln);
static MdfdVec *_mdfd_openseg(Relation reln, int segno, int oflags); static MdfdVec *_mdfd_openseg(Relation reln, int segno, int oflags);
static MdfdVec *_mdfd_getseg(Relation reln, int blkno); static MdfdVec *_mdfd_getseg(Relation reln, int blkno);
static MdfdVec *_mdfd_blind_getseg(char *dbname, char *relname,
Oid dbid, Oid relid, int blkno);
static int _fdvec_alloc(void); static int _fdvec_alloc(void);
static void _fdvec_free(int); static void _fdvec_free(int);
static BlockNumber _mdnblocks(File file, Size blcksz); static BlockNumber _mdnblocks(File file, Size blcksz);
@ -186,6 +191,8 @@ mdcreate(Relation reln)
#endif #endif
Md_fdvec[vfd].mdfd_lstbcnt = 0; Md_fdvec[vfd].mdfd_lstbcnt = 0;
pfree(path);
return vfd; return vfd;
} }
@ -290,9 +297,6 @@ mdextend(Relation reln, char *buffer)
return SM_FAIL; return SM_FAIL;
} }
/* remember that we did a write, so we can sync at xact commit */
v->mdfd_flags |= MDFD_DIRTY;
/* try to keep the last block count current, though it's just a hint */ /* try to keep the last block count current, though it's just a hint */
#ifndef LET_OS_MANAGE_FILESIZE #ifndef LET_OS_MANAGE_FILESIZE
if ((v->mdfd_lstbcnt = (++nblocks % RELSEG_SIZE)) == 0) if ((v->mdfd_lstbcnt = (++nblocks % RELSEG_SIZE)) == 0)
@ -367,6 +371,8 @@ mdopen(Relation reln)
#endif #endif
#endif #endif
pfree(path);
return vfd; return vfd;
} }
@ -382,13 +388,24 @@ int
mdclose(Relation reln) mdclose(Relation reln)
{ {
int fd; int fd;
MdfdVec *v;
MemoryContext oldcxt;
fd = RelationGetFile(reln); fd = RelationGetFile(reln);
if (fd < 0) if (fd < 0)
return SM_SUCCESS; /* already closed, so no work */ return SM_SUCCESS; /* already closed, so no work */
mdclose_fd(fd);
reln->rd_fd = -1;
return SM_SUCCESS;
}
static void
mdclose_fd(int fd)
{
MdfdVec *v;
MemoryContext oldcxt;
oldcxt = MemoryContextSwitchTo(MdCxt); oldcxt = MemoryContextSwitchTo(MdCxt);
#ifndef LET_OS_MANAGE_FILESIZE #ifndef LET_OS_MANAGE_FILESIZE
for (v = &Md_fdvec[fd]; v != (MdfdVec *) NULL;) for (v = &Md_fdvec[fd]; v != (MdfdVec *) NULL;)
@ -398,17 +415,14 @@ mdclose(Relation reln)
/* if not closed already */ /* if not closed already */
if (v->mdfd_vfd >= 0) if (v->mdfd_vfd >= 0)
{ {
/* /*
* We sync the file descriptor so that we don't need to reopen * We sync the file descriptor so that we don't need to reopen
* it at transaction commit to force changes to disk. * it at transaction commit to force changes to disk. (This
* is not really optional, because we are about to forget that
* the file even exists...)
*/ */
FileSync(v->mdfd_vfd); FileSync(v->mdfd_vfd);
FileClose(v->mdfd_vfd); FileClose(v->mdfd_vfd);
/* mark this file descriptor as clean in our private table */
v->mdfd_flags &= ~MDFD_DIRTY;
} }
/* Now free vector */ /* Now free vector */
v = v->mdfd_chain; v = v->mdfd_chain;
@ -423,28 +437,20 @@ mdclose(Relation reln)
{ {
if (v->mdfd_vfd >= 0) if (v->mdfd_vfd >= 0)
{ {
/* /*
* We sync the file descriptor so that we don't need to reopen * We sync the file descriptor so that we don't need to reopen
* it at transaction commit to force changes to disk. * it at transaction commit to force changes to disk. (This
* is not really optional, because we are about to forget that
* the file even exists...)
*/ */
FileSync(v->mdfd_vfd); FileSync(v->mdfd_vfd);
FileClose(v->mdfd_vfd); FileClose(v->mdfd_vfd);
/* mark this file descriptor as clean in our private table */
v->mdfd_flags &= ~MDFD_DIRTY;
} }
} }
#endif #endif
MemoryContextSwitchTo(oldcxt); MemoryContextSwitchTo(oldcxt);
_fdvec_free(fd); _fdvec_free(fd);
/* be sure to mark relation closed */
reln->rd_fd = -1;
return SM_SUCCESS;
} }
/* /*
@ -521,8 +527,6 @@ mdwrite(Relation reln, BlockNumber blocknum, char *buffer)
if (FileWrite(v->mdfd_vfd, buffer, BLCKSZ) != BLCKSZ) if (FileWrite(v->mdfd_vfd, buffer, BLCKSZ) != BLCKSZ)
status = SM_FAIL; status = SM_FAIL;
v->mdfd_flags |= MDFD_DIRTY;
return status; return status;
} }
@ -560,14 +564,6 @@ mdflush(Relation reln, BlockNumber blocknum, char *buffer)
|| FileSync(v->mdfd_vfd) < 0) || FileSync(v->mdfd_vfd) < 0)
status = SM_FAIL; status = SM_FAIL;
/*
* By here, the block is written and changes have been forced to
* stable storage. Mark the descriptor as clean until the next write,
* so we don't sync it again unnecessarily at transaction commit.
*/
v->mdfd_flags &= ~MDFD_DIRTY;
return status; return status;
} }
@ -575,139 +571,87 @@ mdflush(Relation reln, BlockNumber blocknum, char *buffer)
* mdblindwrt() -- Write a block to disk blind. * mdblindwrt() -- Write a block to disk blind.
* *
* We have to be able to do this using only the name and OID of * We have to be able to do this using only the name and OID of
* the database and relation in which the block belongs. This * the database and relation in which the block belongs. Otherwise
* is a synchronous write. * this is just like mdwrite().
*/ */
int int
mdblindwrt(char *dbstr, mdblindwrt(char *dbname,
char *relstr, char *relname,
Oid dbid, Oid dbid,
Oid relid, Oid relid,
BlockNumber blkno, BlockNumber blkno,
char *buffer) char *buffer)
{ {
int fd;
int segno;
long seekpos;
int status; int status;
char *path; long seekpos;
MdfdVec *v;
#ifndef LET_OS_MANAGE_FILESIZE
int nchars;
/* be sure we have enough space for the '.segno', if any */
segno = blkno / RELSEG_SIZE;
if (segno > 0)
nchars = 10;
else
nchars = 0;
/* construct the path to the file and open it */ v = _mdfd_blind_getseg(dbname, relname, dbid, relid, blkno);
/* system table? then put in system area... */
if (dbid == (Oid) 0)
{
path = (char *) palloc(strlen(DataDir) + sizeof(NameData) + 2 + nchars);
if (segno == 0)
sprintf(path, "%s/%s", DataDir, relstr);
else
sprintf(path, "%s/%s.%d", DataDir, relstr, segno);
}
/* user table? then put in user database area... */
else if (dbid == MyDatabaseId)
{
path = (char *) palloc(strlen(DatabasePath) + 2 * sizeof(NameData) + 2 + nchars);
if (segno == 0)
sprintf(path, "%s%c%s", DatabasePath, SEP_CHAR, relstr);
else
sprintf(path, "%s%c%s.%d", DatabasePath, SEP_CHAR, relstr, segno);
}
else
/* this is work arround only !!! */
{
char dbpath[MAXPGPATH];
Oid id;
char *tmpPath;
GetRawDatabaseInfo(dbstr, &id, dbpath);
if (id != dbid)
elog(FATAL, "mdblindwrt: oid of db %s is not %u", dbstr, dbid);
tmpPath = ExpandDatabasePath(dbpath);
if (tmpPath == NULL)
elog(FATAL, "mdblindwrt: can't expand path for db %s", dbstr);
path = (char *) palloc(strlen(tmpPath) + 2 * sizeof(NameData) + 2 + nchars);
if (segno == 0)
sprintf(path, "%s%c%s", tmpPath, SEP_CHAR, relstr);
else
sprintf(path, "%s%c%s.%d", tmpPath, SEP_CHAR, relstr, segno);
pfree(tmpPath);
}
#else
/* construct the path to the file and open it */
/* system table? then put in system area... */
if (dbid == (Oid) 0)
{
path = (char *) palloc(strlen(DataDir) + sizeof(NameData) + 2);
sprintf(path, "%s/%s", DataDir, relstr);
}
/* user table? then put in user database area... */
else if (dbid == MyDatabaseId)
{
path = (char *) palloc(strlen(DatabasePath) + 2 * sizeof(NameData) + 2);
sprintf(path, "%s%c%s", DatabasePath, SEP_CHAR, relstr);
}
else
/* this is work arround only !!! */
{
char dbpath[MAXPGPATH];
Oid id;
char *tmpPath;
GetRawDatabaseInfo(dbstr, &id, dbpath);
if (id != dbid)
elog(FATAL, "mdblindwrt: oid of db %s is not %u", dbstr, dbid);
tmpPath = ExpandDatabasePath(dbpath);
if (tmpPath == NULL)
elog(FATAL, "mdblindwrt: can't expand path for db %s", dbstr);
path = (char *) palloc(strlen(tmpPath) + 2 * sizeof(NameData) + 2);
sprintf(path, "%s%c%s", tmpPath, SEP_CHAR, relstr);
pfree(tmpPath);
}
#endif
#ifndef __CYGWIN32__ if (v == NULL)
if ((fd = open(path, O_RDWR, 0600)) < 0)
#else
if ((fd = open(path, O_RDWR | O_BINARY, 0600)) < 0)
#endif
return SM_FAIL; return SM_FAIL;
/* seek to the right spot */
#ifndef LET_OS_MANAGE_FILESIZE #ifndef LET_OS_MANAGE_FILESIZE
seekpos = (long) (BLCKSZ * (blkno % RELSEG_SIZE)); seekpos = (long) (BLCKSZ * (blkno % RELSEG_SIZE));
#ifdef DIAGNOSTIC
if (seekpos >= BLCKSZ * RELSEG_SIZE)
elog(FATAL, "seekpos too big!");
#endif
#else #else
seekpos = (long) (BLCKSZ * (blkno)); seekpos = (long) (BLCKSZ * (blkno));
#endif #endif
if (lseek(fd, seekpos, SEEK_SET) != seekpos) if (FileSeek(v->mdfd_vfd, seekpos, SEEK_SET) != seekpos)
{
close(fd);
return SM_FAIL; return SM_FAIL;
}
status = SM_SUCCESS; status = SM_SUCCESS;
if (FileWrite(v->mdfd_vfd, buffer, BLCKSZ) != BLCKSZ)
/* write and sync the block */
if (write(fd, buffer, BLCKSZ) != BLCKSZ || (pg_fsync(fd) < 0))
status = SM_FAIL; status = SM_FAIL;
if (close(fd) < 0) return status;
status = SM_FAIL; }
pfree(path); /*
* mdmarkdirty() -- Mark the specified block "dirty" (ie, needs fsync).
*
* Returns SM_SUCCESS or SM_FAIL.
*/
int
mdmarkdirty(Relation reln, BlockNumber blkno)
{
MdfdVec *v;
return status; v = _mdfd_getseg(reln, blkno);
FileMarkDirty(v->mdfd_vfd);
return SM_SUCCESS;
}
/*
* mdblindmarkdirty() -- Mark the specified block "dirty" (ie, needs fsync).
*
* We have to be able to do this using only the name and OID of
* the database and relation in which the block belongs. Otherwise
* this is just like mdmarkdirty().
*/
int
mdblindmarkdirty(char *dbname,
char *relname,
Oid dbid,
Oid relid,
BlockNumber blkno)
{
MdfdVec *v;
v = _mdfd_blind_getseg(dbname, relname, dbid, relid, blkno);
if (v == NULL)
return SM_FAIL;
FileMarkDirty(v->mdfd_vfd);
return SM_SUCCESS;
} }
/* /*
@ -873,19 +817,26 @@ mdcommit()
for (i = 0; i < CurFd; i++) for (i = 0; i < CurFd; i++)
{ {
v = &Md_fdvec[i];
if (v->mdfd_flags & MDFD_FREE)
continue;
if (v->mdfd_flags & MDFD_TEMP)
{
/* Sync and close the file */
mdclose_fd(i);
}
else
{
/* Sync, but keep the file entry */
#ifndef LET_OS_MANAGE_FILESIZE #ifndef LET_OS_MANAGE_FILESIZE
for (v = &Md_fdvec[i]; v != (MdfdVec *) NULL; v = v->mdfd_chain) for ( ; v != (MdfdVec *) NULL; v = v->mdfd_chain)
#else #else
v = &Md_fdvec[i]; if (v != (MdfdVec *) NULL)
if (v != (MdfdVec *) NULL)
#endif #endif
{
if (v->mdfd_flags & MDFD_DIRTY)
{ {
if (FileSync(v->mdfd_vfd) < 0) if (FileSync(v->mdfd_vfd) < 0)
return SM_FAIL; return SM_FAIL;
v->mdfd_flags &= ~MDFD_DIRTY;
} }
} }
} }
@ -908,13 +859,14 @@ mdabort()
for (i = 0; i < CurFd; i++) for (i = 0; i < CurFd; i++)
{ {
#ifndef LET_OS_MANAGE_FILESIZE
for (v = &Md_fdvec[i]; v != (MdfdVec *) NULL; v = v->mdfd_chain)
v->mdfd_flags &= ~MDFD_DIRTY;
#else
v = &Md_fdvec[i]; v = &Md_fdvec[i];
v->mdfd_flags &= ~MDFD_DIRTY; if (v->mdfd_flags & MDFD_FREE)
#endif continue;
if (v->mdfd_flags & MDFD_TEMP)
{
/* Close the file */
mdclose_fd(i);
}
} }
return SM_SUCCESS; return SM_SUCCESS;
@ -995,7 +947,6 @@ _fdvec_free(int fdvec)
Md_fdvec[fdvec].mdfd_nextFree = Md_Free; Md_fdvec[fdvec].mdfd_nextFree = Md_Free;
Md_fdvec[fdvec].mdfd_flags = MDFD_FREE; Md_fdvec[fdvec].mdfd_flags = MDFD_FREE;
Md_Free = fdvec; Md_Free = fdvec;
} }
static MdfdVec * static MdfdVec *
@ -1004,19 +955,17 @@ _mdfd_openseg(Relation reln, int segno, int oflags)
MemoryContext oldcxt; MemoryContext oldcxt;
MdfdVec *v; MdfdVec *v;
int fd; int fd;
bool dofree;
char *path, char *path,
*fullpath; *fullpath;
/* be sure we have enough space for the '.segno', if any */ /* be sure we have enough space for the '.segno', if any */
path = relpath(RelationGetPhysicalRelationName(reln)); path = relpath(RelationGetPhysicalRelationName(reln));
dofree = false;
if (segno > 0) if (segno > 0)
{ {
dofree = true;
fullpath = (char *) palloc(strlen(path) + 12); fullpath = (char *) palloc(strlen(path) + 12);
sprintf(fullpath, "%s.%d", path, segno); sprintf(fullpath, "%s.%d", path, segno);
pfree(path);
} }
else else
fullpath = path; fullpath = path;
@ -1028,8 +977,7 @@ _mdfd_openseg(Relation reln, int segno, int oflags)
fd = FileNameOpenFile(fullpath, O_RDWR | O_BINARY | oflags, 0600); fd = FileNameOpenFile(fullpath, O_RDWR | O_BINARY | oflags, 0600);
#endif #endif
if (dofree) pfree(fullpath);
pfree(fullpath);
if (fd < 0) if (fd < 0)
return (MdfdVec *) NULL; return (MdfdVec *) NULL;
@ -1109,6 +1057,104 @@ _mdfd_getseg(Relation reln, int blkno)
return v; return v;
} }
/* Find the segment of the relation holding the specified block.
* This is the same as _mdfd_getseg() except that we must work
* "blind" with no Relation struct.
*
* NOTE: we have no easy way to tell whether a FD already exists for the
* target relation, so we always make a new one. This should probably
* be improved somehow, but I doubt it's a significant performance issue
* under normal circumstances. The FD is marked to be closed at end of xact
* so that we don't accumulate a lot of dead FDs.
*/
static MdfdVec *
_mdfd_blind_getseg(char *dbname, char *relname, Oid dbid, Oid relid,
int blkno)
{
MdfdVec *v;
char *path;
int fd;
int vfd;
#ifndef LET_OS_MANAGE_FILESIZE
int segno;
int targsegno;
#endif
/* construct the path to the file and open it */
path = relpath_blind(dbname, relname, dbid, relid);
#ifndef __CYGWIN32__
fd = FileNameOpenFile(path, O_RDWR, 0600);
#else
fd = FileNameOpenFile(path, O_RDWR | O_BINARY, 0600);
#endif
if (fd < 0)
return NULL;
vfd = _fdvec_alloc();
if (vfd < 0)
return NULL;
Md_fdvec[vfd].mdfd_vfd = fd;
Md_fdvec[vfd].mdfd_flags = MDFD_TEMP;
Md_fdvec[vfd].mdfd_lstbcnt = _mdnblocks(fd, BLCKSZ);
#ifndef LET_OS_MANAGE_FILESIZE
Md_fdvec[vfd].mdfd_chain = (MdfdVec *) NULL;
#ifdef DIAGNOSTIC
if (Md_fdvec[vfd].mdfd_lstbcnt > RELSEG_SIZE)
elog(FATAL, "segment too big on relopen!");
#endif
targsegno = blkno / RELSEG_SIZE;
for (v = &Md_fdvec[vfd], segno = 1; segno <= targsegno; segno++)
{
char *segpath;
MdfdVec *newv;
MemoryContext oldcxt;
segpath = (char *) palloc(strlen(path) + 12);
sprintf(segpath, "%s.%d", path, segno);
#ifndef __CYGWIN32__
fd = FileNameOpenFile(segpath, O_RDWR | O_CREAT, 0600);
#else
fd = FileNameOpenFile(segpath, O_RDWR | O_BINARY | O_CREAT, 0600);
#endif
pfree(segpath);
if (fd < 0)
return (MdfdVec *) NULL;
/* allocate an mdfdvec entry for it */
oldcxt = MemoryContextSwitchTo(MdCxt);
newv = (MdfdVec *) palloc(sizeof(MdfdVec));
MemoryContextSwitchTo(oldcxt);
/* fill the entry */
newv->mdfd_vfd = fd;
newv->mdfd_flags = MDFD_TEMP;
newv->mdfd_lstbcnt = _mdnblocks(fd, BLCKSZ);
newv->mdfd_chain = (MdfdVec *) NULL;
#ifdef DIAGNOSTIC
if (newv->mdfd_lstbcnt > RELSEG_SIZE)
elog(FATAL, "segment too big on open!");
#endif
v->mdfd_chain = newv;
v = newv;
}
#else
v = &Md_fdvec[vfd];
#endif
pfree(path);
return v;
}
static BlockNumber static BlockNumber
_mdnblocks(File file, Size blcksz) _mdnblocks(File file, Size blcksz)
{ {

114
src/backend/storage/smgr/smgr.c
Unescape View File

@ -11,7 +11,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgr.c,v 1.32 2000/01/26 05:57:05 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgr.c,v 1.33 2000/04/09 04:43:20 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -23,21 +23,30 @@ static void smgrshutdown(int dummy);
typedef struct f_smgr typedef struct f_smgr
{ {
int (*smgr_init) ();/* may be NULL */ int (*smgr_init) (void); /* may be NULL */
int (*smgr_shutdown) (); /* may be NULL */ int (*smgr_shutdown) (void); /* may be NULL */
int (*smgr_create) (); int (*smgr_create) (Relation reln);
int (*smgr_unlink) (); int (*smgr_unlink) (Relation reln);
int (*smgr_extend) (); int (*smgr_extend) (Relation reln, char *buffer);
int (*smgr_open) (); int (*smgr_open) (Relation reln);
int (*smgr_close) (); int (*smgr_close) (Relation reln);
int (*smgr_read) (); int (*smgr_read) (Relation reln, BlockNumber blocknum,
int (*smgr_write) (); char *buffer);
int (*smgr_flush) (); int (*smgr_write) (Relation reln, BlockNumber blocknum,
int (*smgr_blindwrt) (); char *buffer);
int (*smgr_nblocks) (); int (*smgr_flush) (Relation reln, BlockNumber blocknum,
int (*smgr_truncate) (); char *buffer);
int (*smgr_commit) (); /* may be NULL */ int (*smgr_blindwrt) (char *dbname, char *relname,
int (*smgr_abort) (); /* may be NULL */ Oid dbid, Oid relid,
BlockNumber blkno, char *buffer);
int (*smgr_markdirty) (Relation reln, BlockNumber blkno);
int (*smgr_blindmarkdirty) (char *dbname, char *relname,
Oid dbid, Oid relid,
BlockNumber blkno);
int (*smgr_nblocks) (Relation reln);
int (*smgr_truncate) (Relation reln, int nblocks);
int (*smgr_commit) (void); /* may be NULL */
int (*smgr_abort) (void); /* may be NULL */
} f_smgr; } f_smgr;
/* /*
@ -49,14 +58,14 @@ static f_smgr smgrsw[] = {
/* magnetic disk */ /* magnetic disk */
{mdinit, NULL, mdcreate, mdunlink, mdextend, mdopen, mdclose, {mdinit, NULL, mdcreate, mdunlink, mdextend, mdopen, mdclose,
mdread, mdwrite, mdflush, mdblindwrt, mdnblocks, mdtruncate, mdread, mdwrite, mdflush, mdblindwrt, mdmarkdirty, mdblindmarkdirty,
mdcommit, mdabort}, mdnblocks, mdtruncate, mdcommit, mdabort},
#ifdef STABLE_MEMORY_STORAGE #ifdef STABLE_MEMORY_STORAGE
/* main memory */ /* main memory */
{mminit, mmshutdown, mmcreate, mmunlink, mmextend, mmopen, mmclose, {mminit, mmshutdown, mmcreate, mmunlink, mmextend, mmopen, mmclose,
mmread, mmwrite, mmflush, mmblindwrt, mmnblocks, NULL, mmread, mmwrite, mmflush, mmblindwrt, mmmarkdirty, mmblindmarkdirty,
mmcommit, mmabort}, mmnblocks, NULL, mmcommit, mmabort},
#endif #endif
}; };
@ -299,6 +308,7 @@ smgrblindwrt(int16 which,
char *relstr; char *relstr;
int status; int status;
/* strdup here is probably redundant */
dbstr = pstrdup(dbname); dbstr = pstrdup(dbname);
relstr = pstrdup(relname); relstr = pstrdup(relname);
@ -315,6 +325,67 @@ smgrblindwrt(int16 which,
return status; return status;
} }
/*
* smgrmarkdirty() -- Mark a page dirty (needs fsync).
*
* Mark the specified page as needing to be fsync'd before commit.
* Ordinarily, the storage manager will do this implicitly during
* smgrwrite(). However, the buffer manager may discover that some
* other backend has written a buffer that we dirtied in the current
* transaction. In that case, we still need to fsync the file to be
* sure the page is down to disk before we commit.
*/
int
smgrmarkdirty(int16 which,
Relation reln,
BlockNumber blkno)
{
int status;
status = (*(smgrsw[which].smgr_markdirty)) (reln, blkno);
if (status == SM_FAIL)
elog(ERROR, "cannot mark block %d of %s",
blkno, RelationGetRelationName(reln));
return status;
}
/*
* smgrblindmarkdirty() -- Mark a page dirty, "blind".
*
* Just like smgrmarkdirty, except we don't have a reldesc.
*/
int
smgrblindmarkdirty(int16 which,
char *dbname,
char *relname,
Oid dbid,
Oid relid,
BlockNumber blkno)
{
char *dbstr;
char *relstr;
int status;
/* strdup here is probably redundant */
dbstr = pstrdup(dbname);
relstr = pstrdup(relname);
status = (*(smgrsw[which].smgr_blindmarkdirty)) (dbstr, relstr,
dbid, relid,
blkno);
if (status == SM_FAIL)
elog(ERROR, "cannot mark block %d of %s [%s] blind",
blkno, relstr, dbstr);
pfree(dbstr);
pfree(relstr);
return status;
}
/* /*
* smgrnblocks() -- Calculate the number of POSTGRES blocks in the * smgrnblocks() -- Calculate the number of POSTGRES blocks in the
* supplied relation. * supplied relation.
@ -378,7 +449,6 @@ smgrcommit()
return SM_SUCCESS; return SM_SUCCESS;
} }
#ifdef NOT_USED
int int
smgrabort() smgrabort()
{ {
@ -396,8 +466,6 @@ smgrabort()
return SM_SUCCESS; return SM_SUCCESS;
} }
#endif
#ifdef NOT_USED #ifdef NOT_USED
bool bool
smgriswo(int16 smgrno) smgriswo(int16 smgrno)

4
src/include/catalog/catalog.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $Id: catalog.h,v 1.10 2000/01/26 05:57:56 momjian Exp $ * $Id: catalog.h,v 1.11 2000/04/09 04:43:14 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -17,6 +17,8 @@
#include "access/tupdesc.h" #include "access/tupdesc.h"
extern char *relpath(const char *relname); extern char *relpath(const char *relname);
extern char *relpath_blind(const char *dbname, const char *relname,
Oid dbid, Oid relid);
extern bool IsSystemRelationName(const char *relname); extern bool IsSystemRelationName(const char *relname);
extern bool IsSharedSystemRelationName(const char *relname); extern bool IsSharedSystemRelationName(const char *relname);
extern Oid newoid(void); extern Oid newoid(void);

19
src/include/storage/buf_internals.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $Id: buf_internals.h,v 1.35 2000/01/26 05:58:32 momjian Exp $ * $Id: buf_internals.h,v 1.36 2000/04/09 04:43:18 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -61,6 +61,16 @@ typedef struct buftag
(a)->relId = (xx_reln)->rd_lockInfo.lockRelId \ (a)->relId = (xx_reln)->rd_lockInfo.lockRelId \
) )
/* If we have to write a buffer "blind" (without a relcache entry),
* the BufferTag is not enough information. BufferBlindId carries the
* additional information needed.
*/
typedef struct bufblindid
{
char dbname[NAMEDATALEN]; /* name of db in which buf belongs */
char relname[NAMEDATALEN]; /* name of reln */
} BufferBlindId;
#define BAD_BUFFER_ID(bid) ((bid) < 1 || (bid) > NBuffers) #define BAD_BUFFER_ID(bid) ((bid) < 1 || (bid) > NBuffers)
#define INVALID_DESCRIPTOR (-3) #define INVALID_DESCRIPTOR (-3)
@ -98,8 +108,7 @@ typedef struct sbufdesc
bool ri_lock; /* read-intent lock */ bool ri_lock; /* read-intent lock */
bool w_lock; /* context exclusively locked */ bool w_lock; /* context exclusively locked */
char sb_dbname[NAMEDATALEN]; /* name of db in which buf belongs */ BufferBlindId blind; /* extra info to support blind write */
char sb_relname[NAMEDATALEN]; /* name of reln */
} BufferDesc; } BufferDesc;
/* /*
@ -164,7 +173,9 @@ extern BufferDesc *BufferDescriptors;
extern BufferBlock BufferBlocks; extern BufferBlock BufferBlocks;
extern long *PrivateRefCount; extern long *PrivateRefCount;
extern bits8 *BufferLocks; extern bits8 *BufferLocks;
extern long *CommitInfoNeedsSave; extern BufferTag *BufferTagLastDirtied;
extern BufferBlindId *BufferBlindLastDirtied;
extern bool *BufferDirtiedByMe;
extern SPINLOCK BufMgrLock; extern SPINLOCK BufMgrLock;
/* localbuf.c */ /* localbuf.c */

4
src/include/storage/bufmgr.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $Id: bufmgr.h,v 1.35 2000/03/31 02:43:30 tgl Exp $ * $Id: bufmgr.h,v 1.36 2000/04/09 04:43:18 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -164,7 +164,7 @@ extern int FlushBuffer(Buffer buffer, bool release);
extern void InitBufferPool(IPCKey key); extern void InitBufferPool(IPCKey key);
extern void PrintBufferUsage(FILE *statfp); extern void PrintBufferUsage(FILE *statfp);
extern void ResetBufferUsage(void); extern void ResetBufferUsage(void);
extern void ResetBufferPool(void); extern void ResetBufferPool(bool isCommit);
extern int BufferPoolCheckLeak(void); extern int BufferPoolCheckLeak(void);
extern void FlushBufferPool(void); extern void FlushBufferPool(void);
extern BlockNumber BufferGetBlockNumber(Buffer buffer); extern BlockNumber BufferGetBlockNumber(Buffer buffer);

5
src/include/storage/fd.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $Id: fd.h,v 1.19 2000/01/26 05:58:32 momjian Exp $ * $Id: fd.h,v 1.20 2000/04/09 04:43:18 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -15,7 +15,7 @@
/* /*
* calls: * calls:
* *
* File {Close, Read, Write, Seek, Tell, Sync} * File {Close, Read, Write, Seek, Tell, MarkDirty, Sync}
* {File Name Open, Allocate, Free} File * {File Name Open, Allocate, Free} File
* *
* These are NOT JUST RENAMINGS OF THE UNIX ROUTINES. * These are NOT JUST RENAMINGS OF THE UNIX ROUTINES.
@ -58,6 +58,7 @@ extern int FileWrite(File file, char *buffer, int amount);
extern long FileSeek(File file, long offset, int whence); extern long FileSeek(File file, long offset, int whence);
extern int FileTruncate(File file, long offset); extern int FileTruncate(File file, long offset);
extern int FileSync(File file); extern int FileSync(File file);
extern void FileMarkDirty(File file);
/* Operations that allow use of regular stdio --- USE WITH CAUTION */ /* Operations that allow use of regular stdio --- USE WITH CAUTION */
extern FILE *AllocateFile(char *name, char *mode); extern FILE *AllocateFile(char *name, char *mode);

42
src/include/storage/smgr.h
Unescape View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $Id: smgr.h,v 1.17 2000/01/26 05:58:33 momjian Exp $ * $Id: smgr.h,v 1.18 2000/04/09 04:43:18 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -29,17 +29,23 @@ extern int smgrunlink(int16 which, Relation reln);
extern int smgrextend(int16 which, Relation reln, char *buffer); extern int smgrextend(int16 which, Relation reln, char *buffer);
extern int smgropen(int16 which, Relation reln); extern int smgropen(int16 which, Relation reln);
extern int smgrclose(int16 which, Relation reln); extern int smgrclose(int16 which, Relation reln);
extern int smgrread(int16 which, Relation reln, BlockNumber blocknum, extern int smgrread(int16 which, Relation reln, BlockNumber blocknum,
char *buffer); char *buffer);
extern int smgrwrite(int16 which, Relation reln, BlockNumber blocknum, extern int smgrwrite(int16 which, Relation reln, BlockNumber blocknum,
char *buffer); char *buffer);
extern int smgrflush(int16 which, Relation reln, BlockNumber blocknum, extern int smgrflush(int16 which, Relation reln, BlockNumber blocknum,
char *buffer); char *buffer);
extern int smgrblindwrt(int16 which, char *dbname, char *relname, Oid dbid, extern int smgrblindwrt(int16 which, char *dbname, char *relname,
Oid relid, BlockNumber blkno, char *buffer); Oid dbid, Oid relid,
BlockNumber blkno, char *buffer);
extern int smgrmarkdirty(int16 which, Relation reln, BlockNumber blkno);
extern int smgrblindmarkdirty(int16 which, char *dbname, char *relname,
Oid dbid, Oid relid,
BlockNumber blkno);
extern int smgrnblocks(int16 which, Relation reln); extern int smgrnblocks(int16 which, Relation reln);
extern int smgrtruncate(int16 which, Relation reln, int nblocks); extern int smgrtruncate(int16 which, Relation reln, int nblocks);
extern int smgrcommit(void); extern int smgrcommit(void);
extern int smgrabort(void);
@ -55,8 +61,11 @@ extern int mdclose(Relation reln);
extern int mdread(Relation reln, BlockNumber blocknum, char *buffer); extern int mdread(Relation reln, BlockNumber blocknum, char *buffer);
extern int mdwrite(Relation reln, BlockNumber blocknum, char *buffer); extern int mdwrite(Relation reln, BlockNumber blocknum, char *buffer);
extern int mdflush(Relation reln, BlockNumber blocknum, char *buffer); extern int mdflush(Relation reln, BlockNumber blocknum, char *buffer);
extern int mdblindwrt(char *dbstr, char *relstr, Oid dbid, Oid relid, extern int mdblindwrt(char *dbname, char *relname, Oid dbid, Oid relid,
BlockNumber blkno, char *buffer); BlockNumber blkno, char *buffer);
extern int mdmarkdirty(Relation reln, BlockNumber blkno);
extern int mdblindmarkdirty(char *dbname, char *relname, Oid dbid, Oid relid,
BlockNumber blkno);
extern int mdnblocks(Relation reln); extern int mdnblocks(Relation reln);
extern int mdtruncate(Relation reln, int nblocks); extern int mdtruncate(Relation reln, int nblocks);
extern int mdcommit(void); extern int mdcommit(void);
@ -66,7 +75,6 @@ extern int mdabort(void);
extern SPINLOCK MMCacheLock; extern SPINLOCK MMCacheLock;
extern int mminit(void); extern int mminit(void);
extern int mmshutdown(void);
extern int mmcreate(Relation reln); extern int mmcreate(Relation reln);
extern int mmunlink(Relation reln); extern int mmunlink(Relation reln);
extern int mmextend(Relation reln, char *buffer); extern int mmextend(Relation reln, char *buffer);
@ -75,11 +83,17 @@ extern int mmclose(Relation reln);
extern int mmread(Relation reln, BlockNumber blocknum, char *buffer); extern int mmread(Relation reln, BlockNumber blocknum, char *buffer);
extern int mmwrite(Relation reln, BlockNumber blocknum, char *buffer); extern int mmwrite(Relation reln, BlockNumber blocknum, char *buffer);
extern int mmflush(Relation reln, BlockNumber blocknum, char *buffer); extern int mmflush(Relation reln, BlockNumber blocknum, char *buffer);
extern int mmblindwrt(char *dbstr, char *relstr, Oid dbid, Oid relid, extern int mmblindwrt(char *dbname, char *relname, Oid dbid, Oid relid,
BlockNumber blkno, char *buffer); BlockNumber blkno, char *buffer);
extern int mmmarkdirty(Relation reln, BlockNumber blkno);
extern int mmblindmarkdirty(char *dbname, char *relname, Oid dbid, Oid relid,
BlockNumber blkno);
extern int mmnblocks(Relation reln); extern int mmnblocks(Relation reln);
extern int mmtruncate(Relation reln, int nblocks);
extern int mmcommit(void); extern int mmcommit(void);
extern int mmabort(void); extern int mmabort(void);
extern int mmshutdown(void);
extern int MMShmemSize(void); extern int MMShmemSize(void);
/* smgrtype.c */ /* smgrtype.c */

Write Preview
Loading…
Cancel
Save