Replace implementation of pg_log as a relation accessed through the
buffer manager with 'pg_clog', a specialized access method modeled on pg_xlog. This simplifies startup (don't need to play games to open pg_log; among other things, OverrideTransactionSystem goes away), should improve performance a little, and opens the door to recycling commit log space by removing no-longer-needed segments of the commit log. Actual recycling is not there yet, but I felt I should commit this part separately since it'd still be useful if we chose not to do transaction ID wraparound.
This commit is contained in:
Tom Lane
parent
4699d81dc9
commit
2589735da0
@ -1,4 +1,4 @@
|
||||
<!-- $Header: /cvsroot/pgsql/doc/src/sgml/backup.sgml,v 2.11 2001/08/16 04:30:41 ishii Exp $ -->
|
||||
<!-- $Header: /cvsroot/pgsql/doc/src/sgml/backup.sgml,v 2.12 2001/08/25 18:52:41 tgl Exp $ -->
|
||||
<chapter id="backup">
|
||||
<title>Backup and Restore</title>
|
||||
|
||||
@ -339,11 +339,11 @@ tar -cf backup.tar /usr/local/pgsql/data
|
||||
individual tables or databases from their respective files or
|
||||
directories. This will <emphasis>not</> work because the
|
||||
information contained in these files contains only half the
|
||||
truth. The other half is in the file
|
||||
<filename>pg_log</filename>, which contains the commit status of
|
||||
truth. The other half is in the commit log files
|
||||
<filename>pg_clog/*</filename>, which contain the commit status of
|
||||
all transactions. A table file is only usable with this
|
||||
information. Of course it is also impossible to restore only a
|
||||
table and the associated <filename>pg_log</filename> file
|
||||
table and the associated <filename>pg_clog</filename> data
|
||||
because that will render all other tables in the database
|
||||
cluster useless.
|
||||
</para>
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
<!-- $Header: /cvsroot/pgsql/doc/src/sgml/wal.sgml,v 1.7 2001/05/17 21:50:16 petere Exp $ -->
|
||||
<!-- $Header: /cvsroot/pgsql/doc/src/sgml/wal.sgml,v 1.8 2001/08/25 18:52:41 tgl Exp $ -->
|
||||
|
||||
<chapter id="wal">
|
||||
<title>Write-Ahead Logging (<acronym>WAL</acronym>)</title>
|
||||
@ -83,12 +83,12 @@
|
||||
In this first release of <acronym>WAL</acronym>, UNDO operation is
|
||||
not implemented, because of lack of time. This means that changes
|
||||
made by aborted transactions will still occupy disk space and that
|
||||
we still need a permanent <filename>pg_log</filename> file to hold
|
||||
we still need a permanent <filename>pg_clog</filename> file to hold
|
||||
the status of transactions, since we are not able to re-use
|
||||
transaction identifiers. Once UNDO is implemented,
|
||||
<filename>pg_log</filename> will no longer be required to be
|
||||
<filename>pg_clog</filename> will no longer be required to be
|
||||
permanent; it will be possible to remove
|
||||
<filename>pg_log</filename> at shutdown, split it into segments
|
||||
<filename>pg_clog</filename> at shutdown, split it into segments
|
||||
and remove old segments.
|
||||
</para>
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
# Makefile for access/transam
|
||||
#
|
||||
# IDENTIFICATION
|
||||
# $Header: /cvsroot/pgsql/src/backend/access/transam/Makefile,v 1.14 2001/08/24 14:07:48 petere Exp $
|
||||
# $Header: /cvsroot/pgsql/src/backend/access/transam/Makefile,v 1.15 2001/08/25 18:52:41 tgl Exp $
|
||||
#
|
||||
#-------------------------------------------------------------------------
|
||||
|
||||
@ -12,7 +12,7 @@ subdir = src/backend/access/transam
|
||||
top_builddir = ../../../..
|
||||
include $(top_builddir)/src/Makefile.global
|
||||
|
||||
OBJS = transam.o transsup.o varsup.o xact.o xid.o xlog.o xlogutils.o rmgr.o
|
||||
OBJS = clog.o transam.o varsup.o xact.o xid.o xlog.o xlogutils.o rmgr.o
|
||||
|
||||
all: SUBSYS.o
|
||||
|
||||
|
||||
987
src/backend/access/transam/clog.c
Normal file
987
src/backend/access/transam/clog.c
Normal file
@ -0,0 +1,987 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* clog.c
|
||||
* PostgreSQL transaction-commit-log manager
|
||||
*
|
||||
* This module replaces the old "pg_log" access code, which treated pg_log
|
||||
* essentially like a relation, in that it went through the regular buffer
|
||||
* manager. The problem with that was that there wasn't any good way to
|
||||
* recycle storage space for transactions so old that they'll never be
|
||||
* looked up again. Now we use specialized access code so that the commit
|
||||
* log can be broken into relatively small, independent segments.
|
||||
*
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/clog.c,v 1.1 2001/08/25 18:52:41 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#include "postgres.h"
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <dirent.h>
|
||||
#include <errno.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "access/clog.h"
|
||||
#include "storage/s_lock.h"
|
||||
#include "miscadmin.h"
|
||||
|
||||
|
||||
/*
|
||||
* Defines for CLOG page and segment sizes. A page is the same BLCKSZ
|
||||
* as is used everywhere else in Postgres. The CLOG segment size can be
|
||||
* chosen somewhat arbitrarily; we make it 1 million transactions by default,
|
||||
* or 256Kb.
|
||||
*
|
||||
* Note: because TransactionIds are 32 bits and wrap around at 0xFFFFFFFF,
|
||||
* CLOG page numbering also wraps around at 0xFFFFFFFF/CLOG_XACTS_PER_PAGE,
|
||||
* and CLOG segment numbering at 0xFFFFFFFF/CLOG_XACTS_PER_SEGMENT. We need
|
||||
* take no explicit notice of that fact in this module, except when comparing
|
||||
* segment and page numbers in TruncateCLOG (see CLOGPagePrecedes).
|
||||
*/
|
||||
|
||||
#define CLOG_BLCKSZ BLCKSZ
|
||||
|
||||
/* We need two bits per xact, so four xacts fit in a byte */
|
||||
#define CLOG_BITS_PER_XACT 2
|
||||
#define CLOG_XACTS_PER_BYTE 4
|
||||
#define CLOG_XACTS_PER_PAGE (CLOG_BLCKSZ * CLOG_XACTS_PER_BYTE)
|
||||
#define CLOG_XACT_BITMASK ((1 << CLOG_BITS_PER_XACT) - 1)
|
||||
|
||||
#define CLOG_XACTS_PER_SEGMENT 0x100000
|
||||
#define CLOG_PAGES_PER_SEGMENT (CLOG_XACTS_PER_SEGMENT / CLOG_XACTS_PER_PAGE)
|
||||
|
||||
#define TransactionIdToPage(xid) ((xid) / (TransactionId) CLOG_XACTS_PER_PAGE)
|
||||
#define TransactionIdToPgIndex(xid) ((xid) % (TransactionId) CLOG_XACTS_PER_PAGE)
|
||||
#define TransactionIdToByte(xid) (TransactionIdToPgIndex(xid) / CLOG_XACTS_PER_BYTE)
|
||||
#define TransactionIdToBIndex(xid) ((xid) % (TransactionId) CLOG_XACTS_PER_BYTE)
|
||||
|
||||
|
||||
/*----------
|
||||
* Shared-memory data structures for CLOG control
|
||||
*
|
||||
* We use a simple least-recently-used scheme to manage a pool of page
|
||||
* buffers for the CLOG. Under ordinary circumstances we expect that write
|
||||
* traffic will occur mostly to the latest CLOG page (and to the just-prior
|
||||
* page, soon after a page transition). Read traffic will probably touch
|
||||
* a larger span of pages, but in any case a fairly small number of page
|
||||
* buffers should be sufficient. So, we just search the buffers using plain
|
||||
* linear search; there's no need for a hashtable or anything fancy.
|
||||
* The management algorithm is straight LRU except that we will never swap
|
||||
* out the latest page (since we know it's going to be hit again eventually).
|
||||
*
|
||||
* We use an overall spinlock to protect the shared data structures, plus
|
||||
* per-buffer spinlocks that synchronize I/O for each buffer. A process
|
||||
* that is reading in or writing out a page buffer does not hold the control
|
||||
* lock, only the per-buffer lock for the buffer it is working on.
|
||||
*
|
||||
* To change the page number or state of a buffer, one must normally hold
|
||||
* the control lock. (The sole exception to this rule is that a writer
|
||||
* process changes the state from DIRTY to WRITE_IN_PROGRESS while holding
|
||||
* only the per-buffer lock.) If the buffer's state is neither EMPTY nor
|
||||
* CLEAN, then there may be processes doing (or waiting to do) I/O on the
|
||||
* buffer, so the page number may not be changed, and the only allowed state
|
||||
* transition is to change WRITE_IN_PROGRESS to DIRTY after dirtying the page.
|
||||
* To do any other state transition involving a buffer with potential I/O
|
||||
* processes, one must hold both the per-buffer lock and the control lock.
|
||||
* (Note the control lock must be acquired second; do not wait on a buffer
|
||||
* lock while holding the control lock.) A process wishing to read a page
|
||||
* marks the buffer state as READ_IN_PROGRESS, then drops the control lock,
|
||||
* acquires the per-buffer lock, and rechecks the state before proceeding.
|
||||
* This recheck takes care of the possibility that someone else already did
|
||||
* the read, while the early marking prevents someone else from trying to
|
||||
* read the same page into a different buffer.
|
||||
*
|
||||
* Note we are assuming that read and write of the state value is atomic,
|
||||
* since I/O processes may examine and change the state while not holding
|
||||
* the control lock.
|
||||
*
|
||||
* As with the regular buffer manager, it is possible for another process
|
||||
* to re-dirty a page that is currently being written out. This is handled
|
||||
* by setting the page's state from WRITE_IN_PROGRESS to DIRTY. The writing
|
||||
* process must notice this and not mark the page CLEAN when it's done.
|
||||
*
|
||||
* XXX it's probably okay to use a spinlock for the control lock, since
|
||||
* that lock is only held for very short operations. It'd be nice to use
|
||||
* some other form of lock for the per-buffer I/O locks, however.
|
||||
*
|
||||
* XLOG interactions: this module generates an XLOG record whenever a new
|
||||
* CLOG page is initialized to zeroes. Other writes of CLOG come from
|
||||
* recording of transaction commit or abort in xact.c, which generates its
|
||||
* own XLOG records for these events and will re-perform the status update
|
||||
* on redo; so we need make no additional XLOG entry here. Also, the XLOG
|
||||
* is guaranteed flushed through the XLOG commit record before we are called
|
||||
* to log a commit, so the WAL rule "write xlog before data" is satisfied
|
||||
* automatically for commits, and we don't really care for aborts. Therefore,
|
||||
* we don't need to mark XLOG pages with LSN information; we have enough
|
||||
* synchronization already.
|
||||
*----------
|
||||
*/
|
||||
#define NUM_CLOG_BUFFERS 8
|
||||
|
||||
typedef enum
|
||||
{
|
||||
CLOG_PAGE_EMPTY, /* CLOG buffer is not in use */
|
||||
CLOG_PAGE_READ_IN_PROGRESS, /* CLOG page is being read in */
|
||||
CLOG_PAGE_CLEAN, /* CLOG page is valid and not dirty */
|
||||
CLOG_PAGE_DIRTY, /* CLOG page is valid but needs write */
|
||||
CLOG_PAGE_WRITE_IN_PROGRESS /* CLOG page is being written out in */
|
||||
} ClogPageStatus;
|
||||
|
||||
/*
|
||||
* Shared-memory state for CLOG.
|
||||
*/
|
||||
typedef struct ClogCtlData
|
||||
{
|
||||
/*
|
||||
* Info for each buffer slot. Page number is undefined when status is
|
||||
* EMPTY. lru_count is essentially the number of operations since last
|
||||
* use of this page; the page with highest lru_count is the best candidate
|
||||
* to replace.
|
||||
*/
|
||||
char *page_buffer[NUM_CLOG_BUFFERS];
|
||||
ClogPageStatus page_status[NUM_CLOG_BUFFERS];
|
||||
int page_number[NUM_CLOG_BUFFERS];
|
||||
unsigned int page_lru_count[NUM_CLOG_BUFFERS];
|
||||
/*
|
||||
* latest_page_number is the page number of the current end of the
|
||||
* CLOG; this is not critical data, since we use it only to avoid
|
||||
* swapping out the latest page.
|
||||
*/
|
||||
int latest_page_number;
|
||||
|
||||
slock_t control_lck; /* Lock for ClogCtlData itself */
|
||||
slock_t buffer_lck[NUM_CLOG_BUFFERS]; /* Per-buffer I/O locks */
|
||||
} ClogCtlData;
|
||||
|
||||
static ClogCtlData *ClogCtl = NULL;
|
||||
|
||||
/*
|
||||
* ClogDir is set during CLOGShmemInit and does not change thereafter.
|
||||
* The value is automatically inherited by backends via fork, and
|
||||
* doesn't need to be in shared memory.
|
||||
*/
|
||||
static char ClogDir[MAXPGPATH];
|
||||
|
||||
#define ClogFileName(path, seg) \
|
||||
snprintf(path, MAXPGPATH, "%s/%04X", ClogDir, seg)
|
||||
|
||||
/*
|
||||
* Macro to mark a buffer slot "most recently used".
|
||||
*/
|
||||
#define ClogRecentlyUsed(slotno) \
|
||||
do { \
|
||||
int iilru; \
|
||||
for (iilru = 0; iilru < NUM_CLOG_BUFFERS; iilru++) \
|
||||
ClogCtl->page_lru_count[iilru]++; \
|
||||
ClogCtl->page_lru_count[slotno] = 0; \
|
||||
} while (0)
|
||||
|
||||
|
||||
static int ZeroCLOGPage(int pageno, bool writeXlog);
|
||||
static int ReadCLOGPage(int pageno);
|
||||
static void WriteCLOGPage(int slotno);
|
||||
static void CLOGPhysicalReadPage(int pageno, int slotno);
|
||||
static void CLOGPhysicalWritePage(int pageno, int slotno);
|
||||
static int SelectLRUCLOGPage(int pageno);
|
||||
static bool ScanCLOGDirectory(int cutoffPage, bool doDeletions);
|
||||
static bool CLOGPagePrecedes(int page1, int page2);
|
||||
static void WriteZeroPageXlogRec(int pageno);
|
||||
|
||||
|
||||
/*
|
||||
* Record the final state of a transaction in the commit log.
|
||||
*
|
||||
* NB: this is a low-level routine and is NOT the preferred entry point
|
||||
* for most uses; TransactionLogUpdate() in transam.c is the intended caller.
|
||||
*/
|
||||
void
|
||||
TransactionIdSetStatus(TransactionId xid, XidStatus status)
|
||||
{
|
||||
int pageno = TransactionIdToPage(xid);
|
||||
int byteno = TransactionIdToByte(xid);
|
||||
int bshift = TransactionIdToBIndex(xid) * CLOG_BITS_PER_XACT;
|
||||
int slotno;
|
||||
char *byteptr;
|
||||
|
||||
Assert(status == TRANSACTION_STATUS_COMMITTED ||
|
||||
status == TRANSACTION_STATUS_ABORTED);
|
||||
|
||||
S_LOCK(&(ClogCtl->control_lck));
|
||||
|
||||
slotno = ReadCLOGPage(pageno);
|
||||
byteptr = ClogCtl->page_buffer[slotno] + byteno;
|
||||
|
||||
/* Current state should be 0 or target state */
|
||||
Assert(((*byteptr >> bshift) & CLOG_XACT_BITMASK) == 0 ||
|
||||
((*byteptr >> bshift) & CLOG_XACT_BITMASK) == status);
|
||||
|
||||
*byteptr |= (status << bshift);
|
||||
|
||||
ClogCtl->page_status[slotno] = CLOG_PAGE_DIRTY;
|
||||
|
||||
S_UNLOCK(&(ClogCtl->control_lck));
|
||||
}
|
||||
|
||||
/*
|
||||
* Interrogate the state of a transaction in the commit log.
|
||||
*
|
||||
* NB: this is a low-level routine and is NOT the preferred entry point
|
||||
* for most uses; TransactionLogTest() in transam.c is the intended caller.
|
||||
*/
|
||||
XidStatus
|
||||
TransactionIdGetStatus(TransactionId xid)
|
||||
{
|
||||
int pageno = TransactionIdToPage(xid);
|
||||
int byteno = TransactionIdToByte(xid);
|
||||
int bshift = TransactionIdToBIndex(xid) * CLOG_BITS_PER_XACT;
|
||||
int slotno;
|
||||
char *byteptr;
|
||||
XidStatus status;
|
||||
|
||||
S_LOCK(&(ClogCtl->control_lck));
|
||||
|
||||
slotno = ReadCLOGPage(pageno);
|
||||
byteptr = ClogCtl->page_buffer[slotno] + byteno;
|
||||
|
||||
status = (*byteptr >> bshift) & CLOG_XACT_BITMASK;
|
||||
|
||||
S_UNLOCK(&(ClogCtl->control_lck));
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Initialization of shared memory for CLOG
|
||||
*/
|
||||
|
||||
int
|
||||
CLOGShmemSize(void)
|
||||
{
|
||||
return MAXALIGN(sizeof(ClogCtlData) + CLOG_BLCKSZ * NUM_CLOG_BUFFERS);
|
||||
}
|
||||
|
||||
void
|
||||
CLOGShmemInit(void)
|
||||
{
|
||||
bool found;
|
||||
char *bufptr;
|
||||
int slotno;
|
||||
|
||||
/* this must agree with space requested by CLOGShmemSize() */
|
||||
ClogCtl = (ClogCtlData *)
|
||||
ShmemInitStruct("CLOG Ctl",
|
||||
MAXALIGN(sizeof(ClogCtlData) +
|
||||
CLOG_BLCKSZ * NUM_CLOG_BUFFERS),
|
||||
&found);
|
||||
Assert(!found);
|
||||
|
||||
memset(ClogCtl, 0, sizeof(ClogCtlData));
|
||||
|
||||
S_INIT_LOCK(&(ClogCtl->control_lck));
|
||||
|
||||
bufptr = ((char *) ClogCtl) + sizeof(ClogCtlData);
|
||||
|
||||
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++)
|
||||
{
|
||||
ClogCtl->page_buffer[slotno] = bufptr;
|
||||
ClogCtl->page_status[slotno] = CLOG_PAGE_EMPTY;
|
||||
S_INIT_LOCK(&(ClogCtl->buffer_lck[slotno]));
|
||||
bufptr += CLOG_BLCKSZ;
|
||||
}
|
||||
|
||||
/* ClogCtl->latest_page_number will be set later */
|
||||
|
||||
/* Init CLOG directory path */
|
||||
snprintf(ClogDir, MAXPGPATH, "%s/pg_clog", DataDir);
|
||||
}
|
||||
|
||||
/*
|
||||
* This func must be called ONCE on system install. It creates
|
||||
* the initial CLOG segment. (The CLOG directory is assumed to
|
||||
* have been created by the initdb shell script, and CLOGShmemInit
|
||||
* must have been called already.)
|
||||
*/
|
||||
void
|
||||
BootStrapCLOG(void)
|
||||
{
|
||||
int slotno;
|
||||
|
||||
S_LOCK(&(ClogCtl->control_lck));
|
||||
|
||||
/* Create and zero the first page of the commit log */
|
||||
slotno = ZeroCLOGPage(0, false);
|
||||
|
||||
/* Make sure it's written out */
|
||||
WriteCLOGPage(slotno);
|
||||
Assert(ClogCtl->page_status[slotno] == CLOG_PAGE_CLEAN);
|
||||
|
||||
S_UNLOCK(&(ClogCtl->control_lck));
|
||||
}
|
||||
|
||||
/*
|
||||
* Initialize (or reinitialize) a page of CLOG to zeroes.
|
||||
* If writeXlog is TRUE, also emit an XLOG record saying we did this.
|
||||
*
|
||||
* The page is not actually written, just set up in shared memory.
|
||||
* The slot number of the new page is returned.
|
||||
*
|
||||
* Control lock must be held at entry, and will be held at exit.
|
||||
*/
|
||||
static int
|
||||
ZeroCLOGPage(int pageno, bool writeXlog)
|
||||
{
|
||||
int slotno;
|
||||
|
||||
/* Find a suitable buffer slot for the page */
|
||||
slotno = SelectLRUCLOGPage(pageno);
|
||||
Assert(ClogCtl->page_status[slotno] == CLOG_PAGE_EMPTY ||
|
||||
ClogCtl->page_status[slotno] == CLOG_PAGE_CLEAN ||
|
||||
ClogCtl->page_number[slotno] == pageno);
|
||||
|
||||
/* Mark the slot as containing this page */
|
||||
ClogCtl->page_number[slotno] = pageno;
|
||||
ClogCtl->page_status[slotno] = CLOG_PAGE_DIRTY;
|
||||
ClogRecentlyUsed(slotno);
|
||||
|
||||
/* Set the buffer to zeroes */
|
||||
MemSet(ClogCtl->page_buffer[slotno], 0, CLOG_BLCKSZ);
|
||||
|
||||
/* Assume this page is now the latest active page */
|
||||
ClogCtl->latest_page_number = pageno;
|
||||
|
||||
if (writeXlog)
|
||||
WriteZeroPageXlogRec(pageno);
|
||||
|
||||
return slotno;
|
||||
}
|
||||
|
||||
/*
|
||||
* Find a CLOG page in a shared buffer, reading it in if necessary.
|
||||
* The page number must correspond to an already-initialized page.
|
||||
*
|
||||
* Return value is the shared-buffer slot number now holding the page.
|
||||
* The buffer's LRU access info is updated.
|
||||
*
|
||||
* Control lock must be held at entry, and will be held at exit.
|
||||
*/
|
||||
static int
|
||||
ReadCLOGPage(int pageno)
|
||||
{
|
||||
/* Outer loop handles restart if we lose the buffer to someone else */
|
||||
for (;;)
|
||||
{
|
||||
int slotno;
|
||||
|
||||
/* See if page already is in memory; if not, pick victim slot */
|
||||
slotno = SelectLRUCLOGPage(pageno);
|
||||
|
||||
/* Did we find the page in memory? */
|
||||
if (ClogCtl->page_number[slotno] == pageno &&
|
||||
ClogCtl->page_status[slotno] != CLOG_PAGE_EMPTY)
|
||||
{
|
||||
/* If page is still being read in, we cannot use it yet */
|
||||
if (ClogCtl->page_status[slotno] != CLOG_PAGE_READ_IN_PROGRESS)
|
||||
{
|
||||
/* otherwise, it's ready to use */
|
||||
ClogRecentlyUsed(slotno);
|
||||
return slotno;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* We found no match; assert we selected a freeable slot */
|
||||
Assert(ClogCtl->page_status[slotno] == CLOG_PAGE_EMPTY ||
|
||||
ClogCtl->page_status[slotno] == CLOG_PAGE_CLEAN);
|
||||
}
|
||||
|
||||
/* Mark the slot read-busy (no-op if it already was) */
|
||||
ClogCtl->page_number[slotno] = pageno;
|
||||
ClogCtl->page_status[slotno] = CLOG_PAGE_READ_IN_PROGRESS;
|
||||
|
||||
/*
|
||||
* Temporarily mark page as recently-used to discourage
|
||||
* SelectLRUCLOGPage from selecting it again for someone else.
|
||||
*/
|
||||
ClogCtl->page_lru_count[slotno] = 0;
|
||||
|
||||
/* Release shared lock, grab per-buffer lock instead */
|
||||
S_UNLOCK(&(ClogCtl->control_lck));
|
||||
S_LOCK(&(ClogCtl->buffer_lck[slotno]));
|
||||
|
||||
/*
|
||||
* Check to see if someone else already did the read, or took the
|
||||
* buffer away from us. If so, restart from the top.
|
||||
*/
|
||||
if (ClogCtl->page_number[slotno] != pageno ||
|
||||
ClogCtl->page_status[slotno] != CLOG_PAGE_READ_IN_PROGRESS)
|
||||
{
|
||||
S_UNLOCK(&(ClogCtl->buffer_lck[slotno]));
|
||||
S_LOCK(&(ClogCtl->control_lck));
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Okay, do the read */
|
||||
CLOGPhysicalReadPage(pageno, slotno);
|
||||
|
||||
/* Re-acquire shared control lock and update page state */
|
||||
S_LOCK(&(ClogCtl->control_lck));
|
||||
|
||||
Assert(ClogCtl->page_number[slotno] == pageno &&
|
||||
ClogCtl->page_status[slotno] == CLOG_PAGE_READ_IN_PROGRESS);
|
||||
|
||||
ClogCtl->page_status[slotno] = CLOG_PAGE_CLEAN;
|
||||
|
||||
S_UNLOCK(&(ClogCtl->buffer_lck[slotno]));
|
||||
|
||||
ClogRecentlyUsed(slotno);
|
||||
return slotno;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Write a CLOG page from a shared buffer, if necessary.
|
||||
* Does nothing if the specified slot is not dirty.
|
||||
*
|
||||
* NOTE: only one write attempt is made here. Hence, it is possible that
|
||||
* the page is still dirty at exit (if someone else re-dirtied it during
|
||||
* the write). However, we *do* attempt a fresh write even if the page
|
||||
* is already being written; this is for checkpoints.
|
||||
*
|
||||
* Control lock must be held at entry, and will be held at exit.
|
||||
*/
|
||||
static void
|
||||
WriteCLOGPage(int slotno)
|
||||
{
|
||||
int pageno;
|
||||
|
||||
/* Do nothing if page does not need writing */
|
||||
if (ClogCtl->page_status[slotno] != CLOG_PAGE_DIRTY &&
|
||||
ClogCtl->page_status[slotno] != CLOG_PAGE_WRITE_IN_PROGRESS)
|
||||
return;
|
||||
|
||||
pageno = ClogCtl->page_number[slotno];
|
||||
|
||||
/* Release shared lock, grab per-buffer lock instead */
|
||||
S_UNLOCK(&(ClogCtl->control_lck));
|
||||
S_LOCK(&(ClogCtl->buffer_lck[slotno]));
|
||||
|
||||
/*
|
||||
* Check to see if someone else already did the write, or took the
|
||||
* buffer away from us. If so, do nothing. NOTE: we really should
|
||||
* never see WRITE_IN_PROGRESS here, since that state should only
|
||||
* occur while the writer is holding the buffer lock. But accept it
|
||||
* so that we have a recovery path if a writer aborts.
|
||||
*/
|
||||
if (ClogCtl->page_number[slotno] != pageno ||
|
||||
(ClogCtl->page_status[slotno] != CLOG_PAGE_DIRTY &&
|
||||
ClogCtl->page_status[slotno] != CLOG_PAGE_WRITE_IN_PROGRESS))
|
||||
{
|
||||
S_UNLOCK(&(ClogCtl->buffer_lck[slotno]));
|
||||
S_LOCK(&(ClogCtl->control_lck));
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Mark the slot write-busy. After this point, a transaction status
|
||||
* update on this page will mark it dirty again. NB: we are assuming
|
||||
* that read/write of the page status field is atomic, since we change
|
||||
* the state while not holding control lock. However, we cannot set
|
||||
* this state any sooner, or we'd possibly fool a previous writer
|
||||
* into thinking he's successfully dumped the page when he hasn't.
|
||||
* (Scenario: other writer starts, page is redirtied, we come along and
|
||||
* set WRITE_IN_PROGRESS again, other writer completes and sets CLEAN
|
||||
* because redirty info has been lost, then we think it's clean too.)
|
||||
*/
|
||||
ClogCtl->page_status[slotno] = CLOG_PAGE_WRITE_IN_PROGRESS;
|
||||
|
||||
/* Okay, do the write */
|
||||
CLOGPhysicalWritePage(pageno, slotno);
|
||||
|
||||
/* Re-acquire shared control lock and update page state */
|
||||
S_LOCK(&(ClogCtl->control_lck));
|
||||
|
||||
Assert(ClogCtl->page_number[slotno] == pageno &&
|
||||
(ClogCtl->page_status[slotno] == CLOG_PAGE_WRITE_IN_PROGRESS ||
|
||||
ClogCtl->page_status[slotno] == CLOG_PAGE_DIRTY));
|
||||
|
||||
/* Cannot set CLEAN if someone re-dirtied page since write started */
|
||||
if (ClogCtl->page_status[slotno] == CLOG_PAGE_WRITE_IN_PROGRESS)
|
||||
ClogCtl->page_status[slotno] = CLOG_PAGE_CLEAN;
|
||||
|
||||
S_UNLOCK(&(ClogCtl->buffer_lck[slotno]));
|
||||
}
|
||||
|
||||
/*
|
||||
* Physical read of a (previously existing) page into a buffer slot
|
||||
*
|
||||
* For now, assume it's not worth keeping a file pointer open across
|
||||
* read/write operations. We could cache one virtual file pointer ...
|
||||
*/
|
||||
static void
|
||||
CLOGPhysicalReadPage(int pageno, int slotno)
|
||||
{
|
||||
int segno = pageno / CLOG_PAGES_PER_SEGMENT;
|
||||
int rpageno = pageno % CLOG_PAGES_PER_SEGMENT;
|
||||
int offset = rpageno * CLOG_BLCKSZ;
|
||||
char path[MAXPGPATH];
|
||||
int fd;
|
||||
|
||||
ClogFileName(path, segno);
|
||||
|
||||
/*
|
||||
* In a crash-and-restart situation, it's possible for us to receive
|
||||
* commands to set the commit status of transactions whose bits are
|
||||
* in already-truncated segments of the commit log (see notes in
|
||||
* CLOGPhysicalWritePage). Hence, if we are InRecovery, allow the
|
||||
* case where the file doesn't exist, and return zeroes instead.
|
||||
*/
|
||||
fd = BasicOpenFile(path, O_RDWR | PG_BINARY, S_IRUSR | S_IWUSR);
|
||||
if (fd < 0)
|
||||
{
|
||||
if (errno != ENOENT || !InRecovery)
|
||||
elog(STOP, "open of %s failed: %m", path);
|
||||
elog(DEBUG, "clog file %s doesn't exist, reading as zeroes", path);
|
||||
MemSet(ClogCtl->page_buffer[slotno], 0, CLOG_BLCKSZ);
|
||||
return;
|
||||
}
|
||||
|
||||
if (lseek(fd, (off_t) offset, SEEK_SET) < 0)
|
||||
elog(STOP, "lseek of clog file %u, offset %u failed: %m",
|
||||
segno, offset);
|
||||
|
||||
errno = 0;
|
||||
if (read(fd, ClogCtl->page_buffer[slotno], CLOG_BLCKSZ) != CLOG_BLCKSZ)
|
||||
elog(STOP, "read of clog file %u, offset %u failed: %m",
|
||||
segno, offset);
|
||||
|
||||
close(fd);
|
||||
}
|
||||
|
||||
/*
|
||||
* Physical write of a page from a buffer slot
|
||||
*
|
||||
* For now, assume it's not worth keeping a file pointer open across
|
||||
* read/write operations. We could cache one virtual file pointer ...
|
||||
*/
|
||||
static void
|
||||
CLOGPhysicalWritePage(int pageno, int slotno)
|
||||
{
|
||||
int segno = pageno / CLOG_PAGES_PER_SEGMENT;
|
||||
int rpageno = pageno % CLOG_PAGES_PER_SEGMENT;
|
||||
int offset = rpageno * CLOG_BLCKSZ;
|
||||
char path[MAXPGPATH];
|
||||
int fd;
|
||||
|
||||
ClogFileName(path, segno);
|
||||
|
||||
/*
|
||||
* If the file doesn't already exist, we should create it. It is possible
|
||||
* for this to need to happen when writing a page that's not first in
|
||||
* its segment; we assume the OS can cope with that. (Note: it might seem
|
||||
* that it'd be okay to create files only when ZeroCLOGPage is called for
|
||||
* the first page of a segment. However, if after a crash and restart
|
||||
* the REDO logic elects to replay the log from a checkpoint before the
|
||||
* latest one, then it's possible that we will get commands to set
|
||||
* transaction status of transactions that have already been truncated
|
||||
* from the commit log. Easiest way to deal with that is to accept
|
||||
* references to nonexistent files here and in CLOGPhysicalReadPage.)
|
||||
*/
|
||||
fd = BasicOpenFile(path, O_RDWR | PG_BINARY, S_IRUSR | S_IWUSR);
|
||||
if (fd < 0)
|
||||
{
|
||||
if (errno != ENOENT)
|
||||
elog(STOP, "open of %s failed: %m", path);
|
||||
fd = BasicOpenFile(path, O_RDWR | O_CREAT | O_EXCL | PG_BINARY,
|
||||
S_IRUSR | S_IWUSR);
|
||||
if (fd < 0)
|
||||
elog(STOP, "creation of file %s failed: %m", path);
|
||||
}
|
||||
|
||||
if (lseek(fd, (off_t) offset, SEEK_SET) < 0)
|
||||
elog(STOP, "lseek of clog file %u, offset %u failed: %m",
|
||||
segno, offset);
|
||||
|
||||
errno = 0;
|
||||
if (write(fd, ClogCtl->page_buffer[slotno], CLOG_BLCKSZ) != CLOG_BLCKSZ)
|
||||
{
|
||||
/* if write didn't set errno, assume problem is no disk space */
|
||||
if (errno == 0)
|
||||
errno = ENOSPC;
|
||||
elog(STOP, "write of clog file %u, offset %u failed: %m",
|
||||
segno, offset);
|
||||
}
|
||||
|
||||
close(fd);
|
||||
}
|
||||
|
||||
/*
|
||||
* Select the slot to re-use when we need a free slot.
|
||||
*
|
||||
* The target page number is passed because we need to consider the
|
||||
* possibility that some other process reads in the target page while
|
||||
* we are doing I/O to free a slot. Hence, check or recheck to see if
|
||||
* any slot already holds the target page, and return that slot if so.
|
||||
* Thus, the returned slot is *either* a slot already holding the pageno
|
||||
* (could be any state except EMPTY), *or* a freeable slot (state EMPTY
|
||||
* or CLEAN).
|
||||
*
|
||||
* Control lock must be held at entry, and will be held at exit.
|
||||
*/
|
||||
static int
|
||||
SelectLRUCLOGPage(int pageno)
|
||||
{
|
||||
/* Outer loop handles restart after I/O */
|
||||
for (;;)
|
||||
{
|
||||
int slotno;
|
||||
int bestslot = 0;
|
||||
unsigned int bestcount = 0;
|
||||
|
||||
/* See if page already has a buffer assigned */
|
||||
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++)
|
||||
{
|
||||
if (ClogCtl->page_number[slotno] == pageno &&
|
||||
ClogCtl->page_status[slotno] != CLOG_PAGE_EMPTY)
|
||||
return slotno;
|
||||
}
|
||||
|
||||
/*
|
||||
* If we find any EMPTY slot, just select that one.
|
||||
* Else locate the least-recently-used slot that isn't the
|
||||
* latest CLOG page.
|
||||
*/
|
||||
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++)
|
||||
{
|
||||
if (ClogCtl->page_status[slotno] == CLOG_PAGE_EMPTY)
|
||||
return slotno;
|
||||
if (ClogCtl->page_lru_count[slotno] > bestcount &&
|
||||
ClogCtl->page_number[slotno] != ClogCtl->latest_page_number)
|
||||
{
|
||||
bestslot = slotno;
|
||||
bestcount = ClogCtl->page_lru_count[slotno];
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* If the selected page is clean, we're set.
|
||||
*/
|
||||
if (ClogCtl->page_status[bestslot] == CLOG_PAGE_CLEAN)
|
||||
return bestslot;
|
||||
|
||||
/*
|
||||
* We need to do I/O. Normal case is that we have to write it out,
|
||||
* but it's possible in the worst case to have selected a read-busy
|
||||
* page. In that case we use ReadCLOGPage to wait for the read to
|
||||
* complete.
|
||||
*/
|
||||
if (ClogCtl->page_status[bestslot] == CLOG_PAGE_READ_IN_PROGRESS)
|
||||
(void) ReadCLOGPage(ClogCtl->page_number[bestslot]);
|
||||
else
|
||||
WriteCLOGPage(bestslot);
|
||||
|
||||
/*
|
||||
* Now loop back and try again. This is the easiest way of dealing
|
||||
* with corner cases such as the victim page being re-dirtied while
|
||||
* we wrote it.
|
||||
*/
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* This must be called ONCE during postmaster or standalone-backend startup,
|
||||
* after StartupXLOG has initialized ShmemVariableCache->nextXid.
|
||||
*/
|
||||
void
|
||||
StartupCLOG(void)
|
||||
{
|
||||
/*
|
||||
* Initialize our idea of the latest page number.
|
||||
*/
|
||||
ClogCtl->latest_page_number = TransactionIdToPage(ShmemVariableCache->nextXid);
|
||||
}
|
||||
|
||||
/*
|
||||
* This must be called ONCE during postmaster or standalone-backend shutdown
|
||||
*/
|
||||
void
|
||||
ShutdownCLOG(void)
|
||||
{
|
||||
int slotno;
|
||||
|
||||
S_LOCK(&(ClogCtl->control_lck));
|
||||
|
||||
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++)
|
||||
{
|
||||
WriteCLOGPage(slotno);
|
||||
Assert(ClogCtl->page_status[slotno] == CLOG_PAGE_EMPTY ||
|
||||
ClogCtl->page_status[slotno] == CLOG_PAGE_CLEAN);
|
||||
}
|
||||
|
||||
S_UNLOCK(&(ClogCtl->control_lck));
|
||||
}
|
||||
|
||||
/*
|
||||
* Perform a checkpoint --- either during shutdown, or on-the-fly
|
||||
*/
|
||||
void
|
||||
CheckPointCLOG(void)
|
||||
{
|
||||
int slotno;
|
||||
|
||||
S_LOCK(&(ClogCtl->control_lck));
|
||||
|
||||
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++)
|
||||
{
|
||||
WriteCLOGPage(slotno);
|
||||
/*
|
||||
* We cannot assert that the slot is clean now, since another
|
||||
* process might have re-dirtied it already. That's okay.
|
||||
*/
|
||||
}
|
||||
|
||||
S_UNLOCK(&(ClogCtl->control_lck));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Make sure that CLOG has room for a newly-allocated XID.
|
||||
*
|
||||
* NB: this is called while holding XidGenLock. We want it to be very fast
|
||||
* most of the time; even when it's not so fast, no actual I/O need happen
|
||||
* unless we're forced to write out a dirty clog or xlog page to make room
|
||||
* in shared memory.
|
||||
*/
|
||||
void
|
||||
ExtendCLOG(TransactionId newestXact)
|
||||
{
|
||||
int pageno;
|
||||
|
||||
/* No work except at first XID of a page */
|
||||
if (TransactionIdToPgIndex(newestXact) != 0)
|
||||
return;
|
||||
|
||||
pageno = TransactionIdToPage(newestXact);
|
||||
|
||||
S_LOCK(&(ClogCtl->control_lck));
|
||||
|
||||
/* Zero the page and make an XLOG entry about it */
|
||||
ZeroCLOGPage(pageno, true);
|
||||
|
||||
S_UNLOCK(&(ClogCtl->control_lck));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Remove all CLOG segments before the one holding the passed transaction ID
|
||||
*
|
||||
* When this is called, we know that the database logically contains no
|
||||
* reference to transaction IDs older than oldestXact. However, we must
|
||||
* not truncate the CLOG until we have performed a checkpoint, to ensure
|
||||
* that no such references remain on disk either; else a crash just after
|
||||
* the truncation might leave us with a problem. Since CLOG segments hold
|
||||
* a large number of transactions, the opportunity to actually remove a
|
||||
* segment is fairly rare, and so it seems best not to do the checkpoint
|
||||
* unless we have confirmed that there is a removable segment. Therefore
|
||||
* we issue the checkpoint command here, not in higher-level code as might
|
||||
* seem cleaner.
|
||||
*/
|
||||
void
|
||||
TruncateCLOG(TransactionId oldestXact)
|
||||
{
|
||||
int cutoffPage;
|
||||
int slotno;
|
||||
|
||||
/*
|
||||
* The cutoff point is the start of the segment containing oldestXact.
|
||||
*/
|
||||
oldestXact -= oldestXact % CLOG_XACTS_PER_SEGMENT;
|
||||
cutoffPage = TransactionIdToPage(oldestXact);
|
||||
|
||||
if (!ScanCLOGDirectory(cutoffPage, false))
|
||||
return; /* nothing to remove */
|
||||
|
||||
/* Perform a CHECKPOINT */
|
||||
CreateCheckPoint(false);
|
||||
|
||||
/*
|
||||
* Scan CLOG shared memory and remove any pages preceding the cutoff
|
||||
* page, to ensure we won't rewrite them later. (Any dirty pages
|
||||
* should have been flushed already during the checkpoint, we're
|
||||
* just being extra careful here.)
|
||||
*/
|
||||
S_LOCK(&(ClogCtl->control_lck));
|
||||
|
||||
restart:;
|
||||
|
||||
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++)
|
||||
{
|
||||
if (ClogCtl->page_status[slotno] == CLOG_PAGE_EMPTY)
|
||||
continue;
|
||||
if (!CLOGPagePrecedes(ClogCtl->page_number[slotno], cutoffPage))
|
||||
continue;
|
||||
/*
|
||||
* If page is CLEAN, just change state to EMPTY (expected case).
|
||||
*/
|
||||
if (ClogCtl->page_status[slotno] == CLOG_PAGE_CLEAN)
|
||||
{
|
||||
ClogCtl->page_status[slotno] = CLOG_PAGE_EMPTY;
|
||||
continue;
|
||||
}
|
||||
/*
|
||||
* Hmm, we have (or may have) I/O operations acting on the page,
|
||||
* so we've got to wait for them to finish and then start again.
|
||||
* This is the same logic as in SelectLRUCLOGPage.
|
||||
*/
|
||||
if (ClogCtl->page_status[slotno] == CLOG_PAGE_READ_IN_PROGRESS)
|
||||
(void) ReadCLOGPage(ClogCtl->page_number[slotno]);
|
||||
else
|
||||
WriteCLOGPage(slotno);
|
||||
goto restart;
|
||||
}
|
||||
|
||||
S_UNLOCK(&(ClogCtl->control_lck));
|
||||
|
||||
/* Now we can remove the old CLOG segment(s) */
|
||||
(void) ScanCLOGDirectory(cutoffPage, true);
|
||||
}
|
||||
|
||||
/*
|
||||
* TruncateCLOG subroutine: scan CLOG directory for removable segments.
|
||||
* Actually remove them iff doDeletions is true. Return TRUE iff any
|
||||
* removable segments were found. Note: no locking is needed.
|
||||
*/
|
||||
static bool
|
||||
ScanCLOGDirectory(int cutoffPage, bool doDeletions)
|
||||
{
|
||||
bool found = false;
|
||||
DIR *cldir;
|
||||
struct dirent *clde;
|
||||
int segno;
|
||||
int segpage;
|
||||
char path[MAXPGPATH];
|
||||
|
||||
cldir = opendir(ClogDir);
|
||||
if (cldir == NULL)
|
||||
elog(STOP, "could not open transaction-commit log directory (%s): %m",
|
||||
ClogDir);
|
||||
|
||||
errno = 0;
|
||||
while ((clde = readdir(cldir)) != NULL)
|
||||
{
|
||||
if (strlen(clde->d_name) == 4 &&
|
||||
strspn(clde->d_name, "0123456789ABCDEF") == 4)
|
||||
{
|
||||
segno = (int) strtol(clde->d_name, NULL, 16);
|
||||
segpage = segno * CLOG_PAGES_PER_SEGMENT;
|
||||
if (CLOGPagePrecedes(segpage, cutoffPage))
|
||||
{
|
||||
found = true;
|
||||
if (doDeletions)
|
||||
{
|
||||
snprintf(path, MAXPGPATH, "%s/%s", ClogDir, clde->d_name);
|
||||
unlink(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
errno = 0;
|
||||
}
|
||||
if (errno)
|
||||
elog(STOP, "could not read transaction-commit log directory (%s): %m",
|
||||
ClogDir);
|
||||
closedir(cldir);
|
||||
|
||||
return found;
|
||||
}
|
||||
|
||||
/*
|
||||
* Decide which of two CLOG page numbers is "older" for truncation purposes.
|
||||
*
|
||||
* We need to use comparison of TransactionIds here in order to do the right
|
||||
* thing with wraparound XID arithmetic. However, if we are asked about
|
||||
* page number zero, we don't want to hand InvalidTransactionId to
|
||||
* TransactionIdPrecedes: it'll get weird about permanent xact IDs. So,
|
||||
* offset both xids by FirstNormalTransactionId to avoid that.
|
||||
*/
|
||||
static bool
|
||||
CLOGPagePrecedes(int page1, int page2)
|
||||
{
|
||||
TransactionId xid1;
|
||||
TransactionId xid2;
|
||||
|
||||
xid1 = (TransactionId) page1 * CLOG_XACTS_PER_PAGE;
|
||||
xid1 += FirstNormalTransactionId;
|
||||
xid2 = (TransactionId) page2 * CLOG_XACTS_PER_PAGE;
|
||||
xid2 += FirstNormalTransactionId;
|
||||
|
||||
return TransactionIdPrecedes(xid1, xid2);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Write a ZEROPAGE xlog record
|
||||
*
|
||||
* Note: xlog record is marked as outside transaction control, since we
|
||||
* want it to be redone whether the invoking transaction commits or not.
|
||||
* (Besides which, this is normally done just before entering a transaction.)
|
||||
*/
|
||||
static void
|
||||
WriteZeroPageXlogRec(int pageno)
|
||||
{
|
||||
XLogRecData rdata;
|
||||
|
||||
rdata.buffer = InvalidBuffer;
|
||||
rdata.data = (char *) (&pageno);
|
||||
rdata.len = sizeof(int);
|
||||
rdata.next = NULL;
|
||||
(void) XLogInsert(RM_CLOG_ID, CLOG_ZEROPAGE | XLOG_NO_TRAN, &rdata);
|
||||
}
|
||||
|
||||
/*
|
||||
* CLOG resource manager's routines
|
||||
*/
|
||||
void
|
||||
clog_redo(XLogRecPtr lsn, XLogRecord *record)
|
||||
{
|
||||
uint8 info = record->xl_info & ~XLR_INFO_MASK;
|
||||
|
||||
if (info == CLOG_ZEROPAGE)
|
||||
{
|
||||
int pageno;
|
||||
int slotno;
|
||||
|
||||
memcpy(&pageno, XLogRecGetData(record), sizeof(int));
|
||||
|
||||
S_LOCK(&(ClogCtl->control_lck));
|
||||
|
||||
slotno = ZeroCLOGPage(pageno, false);
|
||||
WriteCLOGPage(slotno);
|
||||
Assert(ClogCtl->page_status[slotno] == CLOG_PAGE_CLEAN);
|
||||
|
||||
S_UNLOCK(&(ClogCtl->control_lck));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
clog_undo(XLogRecPtr lsn, XLogRecord *record)
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
clog_desc(char *buf, uint8 xl_info, char *rec)
|
||||
{
|
||||
uint8 info = xl_info & ~XLR_INFO_MASK;
|
||||
|
||||
if (info == CLOG_ZEROPAGE)
|
||||
{
|
||||
int pageno;
|
||||
|
||||
memcpy(&pageno, rec, sizeof(int));
|
||||
sprintf(buf + strlen(buf), "zeropage: %d", pageno);
|
||||
}
|
||||
else
|
||||
strcat(buf, "UNKNOWN");
|
||||
}
|
||||
@ -1,4 +1,13 @@
|
||||
/*
|
||||
* rmgr.c
|
||||
*
|
||||
* Resource managers definition
|
||||
*
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/rmgr.c,v 1.9 2001/08/25 18:52:41 tgl Exp $
|
||||
*/
|
||||
#include "postgres.h"
|
||||
|
||||
#include "access/clog.h"
|
||||
#include "access/gist.h"
|
||||
#include "access/hash.h"
|
||||
#include "access/heapam.h"
|
||||
@ -9,11 +18,12 @@
|
||||
#include "storage/smgr.h"
|
||||
#include "commands/sequence.h"
|
||||
|
||||
|
||||
RmgrData RmgrTable[] = {
|
||||
{"XLOG", xlog_redo, xlog_undo, xlog_desc},
|
||||
{"Transaction", xact_redo, xact_undo, xact_desc},
|
||||
{"Storage", smgr_redo, smgr_undo, smgr_desc},
|
||||
{"Reserved 3", NULL, NULL, NULL},
|
||||
{"CLOG", clog_redo, clog_undo, clog_desc},
|
||||
{"Reserved 4", NULL, NULL, NULL},
|
||||
{"Reserved 5", NULL, NULL, NULL},
|
||||
{"Reserved 6", NULL, NULL, NULL},
|
||||
|
||||
@ -1,14 +1,14 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* transam.c
|
||||
* postgres transaction log/time interface routines
|
||||
* postgres transaction log interface routines
|
||||
*
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.46 2001/08/23 23:06:37 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.47 2001/08/25 18:52:41 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* This file contains the high level access-method interface to the
|
||||
@ -19,27 +19,14 @@
|
||||
|
||||
#include "postgres.h"
|
||||
|
||||
#include "access/heapam.h"
|
||||
#include "access/clog.h"
|
||||
#include "access/transam.h"
|
||||
#include "catalog/catname.h"
|
||||
#include "miscadmin.h"
|
||||
|
||||
|
||||
static int RecoveryCheckingEnabled(void);
|
||||
static void TransRecover(Relation logRelation);
|
||||
static bool TransactionLogTest(TransactionId transactionId, XidStatus status);
|
||||
static void TransactionLogUpdate(TransactionId transactionId,
|
||||
XidStatus status);
|
||||
|
||||
/* ----------------
|
||||
* global variables holding pointers to relations used
|
||||
* by the transaction system. These are initialized by
|
||||
* InitializeTransactionLog().
|
||||
* ----------------
|
||||
*/
|
||||
|
||||
Relation LogRelation = (Relation) NULL;
|
||||
|
||||
/* ----------------
|
||||
* Single-item cache for results of TransactionLogTest.
|
||||
* ----------------
|
||||
@ -47,48 +34,12 @@ Relation LogRelation = (Relation) NULL;
|
||||
static TransactionId cachedTestXid = InvalidTransactionId;
|
||||
static XidStatus cachedTestXidStatus;
|
||||
|
||||
/* ----------------
|
||||
* transaction recovery state variables
|
||||
*
|
||||
* When the transaction system is initialized, we may
|
||||
* need to do recovery checking. This decision is decided
|
||||
* by the postmaster or the user by supplying the backend
|
||||
* with a special flag. In general, we want to do recovery
|
||||
* checking whenever we are running without a postmaster
|
||||
* or when the number of backends running under the postmaster
|
||||
* goes from zero to one. -cim 3/21/90
|
||||
* ----------------
|
||||
*/
|
||||
static int RecoveryCheckingEnableState = 0;
|
||||
|
||||
/* ----------------
|
||||
* recovery checking accessors
|
||||
* ----------------
|
||||
*/
|
||||
static int
|
||||
RecoveryCheckingEnabled(void)
|
||||
{
|
||||
return RecoveryCheckingEnableState;
|
||||
}
|
||||
|
||||
#ifdef NOT_USED
|
||||
static void
|
||||
SetRecoveryCheckingEnabled(bool state)
|
||||
{
|
||||
RecoveryCheckingEnableState = (state == true);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* postgres log access method interface
|
||||
*
|
||||
* TransactionLogTest
|
||||
* TransactionLogUpdate
|
||||
* ========
|
||||
* these functions do work for the interface
|
||||
* functions - they search/retrieve and append/update
|
||||
* information in the log and time relations.
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
@ -102,59 +53,42 @@ static bool /* true/false: does transaction id have
|
||||
TransactionLogTest(TransactionId transactionId, /* transaction id to test */
|
||||
XidStatus status) /* transaction status */
|
||||
{
|
||||
BlockNumber blockNumber;
|
||||
XidStatus xidstatus; /* recorded status of xid */
|
||||
bool fail = false; /* success/failure */
|
||||
|
||||
/*
|
||||
* during initialization consider all transactions as having been
|
||||
* committed
|
||||
*/
|
||||
if (!RelationIsValid(LogRelation))
|
||||
return (bool) (status == XID_COMMIT);
|
||||
|
||||
/*
|
||||
* before going to the buffer manager, check our single item cache to
|
||||
* Before going to the commit log manager, check our single item cache to
|
||||
* see if we didn't just check the transaction status a moment ago.
|
||||
*/
|
||||
if (TransactionIdEquals(transactionId, cachedTestXid))
|
||||
return (bool)
|
||||
(status == cachedTestXidStatus);
|
||||
return (status == cachedTestXidStatus);
|
||||
|
||||
/*
|
||||
* compute the item pointer corresponding to the page containing our
|
||||
* transaction id. We save the item in our cache to speed up things
|
||||
* if we happen to ask for the same xid's status more than once.
|
||||
* Also, check to see if the transaction ID is a permanent one.
|
||||
*/
|
||||
TransComputeBlockNumber(LogRelation, transactionId, &blockNumber);
|
||||
xidstatus = TransBlockNumberGetXidStatus(LogRelation,
|
||||
blockNumber,
|
||||
transactionId,
|
||||
&fail);
|
||||
|
||||
if (!fail)
|
||||
if (! TransactionIdIsNormal(transactionId))
|
||||
{
|
||||
|
||||
/*
|
||||
* DO NOT cache status for transactions in unknown state !!!
|
||||
*/
|
||||
if (xidstatus == XID_COMMIT || xidstatus == XID_ABORT)
|
||||
{
|
||||
TransactionIdStore(transactionId, &cachedTestXid);
|
||||
cachedTestXidStatus = xidstatus;
|
||||
}
|
||||
return (bool) (status == xidstatus);
|
||||
if (TransactionIdEquals(transactionId, BootstrapTransactionId))
|
||||
return (status == TRANSACTION_STATUS_COMMITTED);
|
||||
if (TransactionIdEquals(transactionId, FrozenTransactionId))
|
||||
return (status == TRANSACTION_STATUS_COMMITTED);
|
||||
return (status == TRANSACTION_STATUS_ABORTED);
|
||||
}
|
||||
|
||||
/*
|
||||
* here the block didn't contain the information we wanted
|
||||
* Get the status.
|
||||
*/
|
||||
elog(ERROR, "TransactionLogTest: failed to get xidstatus");
|
||||
xidstatus = TransactionIdGetStatus(transactionId);
|
||||
|
||||
/*
|
||||
* so lint is happy...
|
||||
*/
|
||||
return false;
|
||||
/*
|
||||
* DO NOT cache status for unfinished transactions!
|
||||
*/
|
||||
if (xidstatus != TRANSACTION_STATUS_IN_PROGRESS)
|
||||
{
|
||||
TransactionIdStore(transactionId, &cachedTestXid);
|
||||
cachedTestXidStatus = xidstatus;
|
||||
}
|
||||
|
||||
return (status == xidstatus);
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
@ -165,24 +99,10 @@ static void
|
||||
TransactionLogUpdate(TransactionId transactionId, /* trans id to update */
|
||||
XidStatus status) /* new trans status */
|
||||
{
|
||||
BlockNumber blockNumber;
|
||||
bool fail = false; /* success/failure */
|
||||
|
||||
/*
|
||||
* during initialization we don't record any updates.
|
||||
* update the commit log
|
||||
*/
|
||||
if (!RelationIsValid(LogRelation))
|
||||
return;
|
||||
|
||||
/*
|
||||
* update the log relation
|
||||
*/
|
||||
TransComputeBlockNumber(LogRelation, transactionId, &blockNumber);
|
||||
TransBlockNumberSetXidStatus(LogRelation,
|
||||
blockNumber,
|
||||
transactionId,
|
||||
status,
|
||||
&fail);
|
||||
TransactionIdSetStatus(transactionId, status);
|
||||
|
||||
/*
|
||||
* update (invalidate) our single item TransactionLogTest cache.
|
||||
@ -191,85 +111,21 @@ TransactionLogUpdate(TransactionId transactionId, /* trans id to update */
|
||||
cachedTestXidStatus = status;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* transaction recovery code
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* --------------------------------
|
||||
* TransRecover
|
||||
* AmiTransactionOverride
|
||||
*
|
||||
* preform transaction recovery checking.
|
||||
*
|
||||
* Note: this should only be preformed if no other backends
|
||||
* are running. This is known by the postmaster and
|
||||
* conveyed by the postmaster passing a "do recovery checking"
|
||||
* flag to the backend.
|
||||
*
|
||||
* here we get the last recorded transaction from the log,
|
||||
* get the "last" and "next" transactions from the variable relation
|
||||
* and then preform some integrity tests:
|
||||
*
|
||||
* 1) No transaction may exist higher then the "next" available
|
||||
* transaction recorded in the variable relation. If this is the
|
||||
* case then it means either the log or the variable relation
|
||||
* has become corrupted.
|
||||
*
|
||||
* 2) The last committed transaction may not be higher then the
|
||||
* next available transaction for the same reason.
|
||||
*
|
||||
* 3) The last recorded transaction may not be lower then the
|
||||
* last committed transaction. (the reverse is ok - it means
|
||||
* that some transactions have aborted since the last commit)
|
||||
*
|
||||
* Here is what the proper situation looks like. The line
|
||||
* represents the data stored in the log. 'c' indicates the
|
||||
* transaction was recorded as committed, 'a' indicates an
|
||||
* abortted transaction and '.' represents information not
|
||||
* recorded. These may correspond to in progress transactions.
|
||||
*
|
||||
* c c a c . . a . . . . . . . . . .
|
||||
* | |
|
||||
* last next
|
||||
*
|
||||
* Since "next" is only incremented by GetNewTransactionId() which
|
||||
* is called when transactions are started. Hence if there
|
||||
* are commits or aborts after "next", then it means we committed
|
||||
* or aborted BEFORE we started the transaction. This is the
|
||||
* rational behind constraint (1).
|
||||
*
|
||||
* Likewise, "last" should never greater then "next" for essentially
|
||||
* the same reason - it would imply we committed before we started.
|
||||
* This is the reasoning for (2).
|
||||
*
|
||||
* (3) implies we may never have a situation such as:
|
||||
*
|
||||
* c c a c . . a c . . . . . . . . .
|
||||
* | |
|
||||
* last next
|
||||
*
|
||||
* where there is a 'c' greater then "last".
|
||||
*
|
||||
* Recovery checking is more difficult in the case where
|
||||
* several backends are executing concurrently because the
|
||||
* transactions may be executing in the other backends.
|
||||
* So, we only do recovery stuff when the backend is explicitly
|
||||
* passed a flag on the command line.
|
||||
* This function is used to manipulate the bootstrap flag.
|
||||
* --------------------------------
|
||||
*/
|
||||
static void
|
||||
TransRecover(Relation logRelation)
|
||||
void
|
||||
AmiTransactionOverride(bool flag)
|
||||
{
|
||||
AMI_OVERRIDE = flag;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* Interface functions
|
||||
*
|
||||
* InitializeTransactionLog
|
||||
* ========
|
||||
* this function (called near cinit) initializes
|
||||
* the transaction log, time and variable relations.
|
||||
*
|
||||
* TransactionId DidCommit
|
||||
* TransactionId DidAbort
|
||||
* TransactionId IsInProgress
|
||||
@ -279,104 +135,13 @@ TransRecover(Relation logRelation)
|
||||
*
|
||||
* TransactionId Commit
|
||||
* TransactionId Abort
|
||||
* TransactionId SetInProgress
|
||||
* ========
|
||||
* these functions set the transaction status
|
||||
* of the specified xid. TransactionIdCommit() also
|
||||
* records the current time in the time relation
|
||||
* and updates the variable relation counter.
|
||||
* of the specified xid.
|
||||
*
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/*
|
||||
* InitializeTransactionLog
|
||||
* Initializes transaction logging.
|
||||
*/
|
||||
void
|
||||
InitializeTransactionLog(void)
|
||||
{
|
||||
Relation logRelation;
|
||||
MemoryContext oldContext;
|
||||
|
||||
/*
|
||||
* don't do anything during bootstrapping
|
||||
*/
|
||||
if (AMI_OVERRIDE)
|
||||
return;
|
||||
|
||||
/*
|
||||
* disable the transaction system so the access methods don't
|
||||
* interfere during initialization.
|
||||
*/
|
||||
OverrideTransactionSystem(true);
|
||||
|
||||
/*
|
||||
* make sure allocations occur within the top memory context so that
|
||||
* our log management structures are protected from garbage collection
|
||||
* at the end of every transaction.
|
||||
*/
|
||||
oldContext = MemoryContextSwitchTo(TopMemoryContext);
|
||||
|
||||
/*
|
||||
* first open the log and time relations (these are created by amiint
|
||||
* so they are guaranteed to exist)
|
||||
*/
|
||||
logRelation = heap_openr(LogRelationName, NoLock);
|
||||
|
||||
/*
|
||||
* XXX TransactionLogUpdate requires that LogRelation is valid so we
|
||||
* temporarily set it so we can initialize things properly. This could
|
||||
* be done cleaner.
|
||||
*/
|
||||
LogRelation = logRelation;
|
||||
|
||||
/*
|
||||
* if we have a virgin database, we initialize the log relation by
|
||||
* committing the BootstrapTransactionId and we initialize the
|
||||
* variable relation by setting the next available transaction id to
|
||||
* FirstNormalTransactionId. OID initialization happens as a side
|
||||
* effect of bootstrapping in varsup.c.
|
||||
*/
|
||||
SpinAcquire(OidGenLockId);
|
||||
if (!TransactionIdDidCommit(BootstrapTransactionId))
|
||||
{
|
||||
TransactionLogUpdate(BootstrapTransactionId, XID_COMMIT);
|
||||
Assert(!IsUnderPostmaster &&
|
||||
TransactionIdEquals(ShmemVariableCache->nextXid,
|
||||
FirstNormalTransactionId));
|
||||
ShmemVariableCache->nextXid = FirstNormalTransactionId;
|
||||
}
|
||||
else if (RecoveryCheckingEnabled())
|
||||
{
|
||||
|
||||
/*
|
||||
* if we have a pre-initialized database and if the perform
|
||||
* recovery checking flag was passed then we do our database
|
||||
* integrity checking.
|
||||
*/
|
||||
TransRecover(logRelation);
|
||||
}
|
||||
LogRelation = (Relation) NULL;
|
||||
SpinRelease(OidGenLockId);
|
||||
|
||||
/*
|
||||
* now re-enable the transaction system
|
||||
*/
|
||||
OverrideTransactionSystem(false);
|
||||
|
||||
/*
|
||||
* instantiate the global variables
|
||||
*/
|
||||
LogRelation = logRelation;
|
||||
|
||||
/*
|
||||
* restore the memory context to the previous context before we return
|
||||
* from initialization.
|
||||
*/
|
||||
MemoryContextSwitchTo(oldContext);
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
* TransactionId DidCommit
|
||||
* TransactionId DidAbort
|
||||
@ -397,16 +162,15 @@ TransactionIdDidCommit(TransactionId transactionId)
|
||||
if (AMI_OVERRIDE)
|
||||
return true;
|
||||
|
||||
return TransactionLogTest(transactionId, XID_COMMIT);
|
||||
return TransactionLogTest(transactionId, TRANSACTION_STATUS_COMMITTED);
|
||||
}
|
||||
|
||||
/*
|
||||
* TransactionIdDidAborted
|
||||
* TransactionIdDidAbort
|
||||
* True iff transaction associated with the identifier did abort.
|
||||
*
|
||||
* Note:
|
||||
* Assumes transaction identifier is valid.
|
||||
* XXX Is this unneeded?
|
||||
*/
|
||||
bool /* true if given transaction aborted */
|
||||
TransactionIdDidAbort(TransactionId transactionId)
|
||||
@ -414,7 +178,7 @@ TransactionIdDidAbort(TransactionId transactionId)
|
||||
if (AMI_OVERRIDE)
|
||||
return false;
|
||||
|
||||
return TransactionLogTest(transactionId, XID_ABORT);
|
||||
return TransactionLogTest(transactionId, TRANSACTION_STATUS_ABORTED);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -422,22 +186,22 @@ TransactionIdDidAbort(TransactionId transactionId)
|
||||
* PROC structures of all running backend. - vadim 11/26/96
|
||||
*
|
||||
* Old comments:
|
||||
* true if given transaction neither committed nor aborted
|
||||
|
||||
* true if given transaction has neither committed nor aborted
|
||||
*/
|
||||
#ifdef NOT_USED
|
||||
bool
|
||||
TransactionIdIsInProgress(TransactionId transactionId)
|
||||
{
|
||||
if (AMI_OVERRIDE)
|
||||
return false;
|
||||
|
||||
return TransactionLogTest(transactionId, XID_INPROGRESS);
|
||||
return TransactionLogTest(transactionId, TRANSACTION_STATUS_IN_PROGRESS);
|
||||
}
|
||||
*/
|
||||
#endif /* NOT_USED */
|
||||
|
||||
/* --------------------------------
|
||||
* TransactionId Commit
|
||||
* TransactionId Abort
|
||||
* TransactionId SetInProgress
|
||||
* --------------------------------
|
||||
*/
|
||||
|
||||
@ -454,7 +218,7 @@ TransactionIdCommit(TransactionId transactionId)
|
||||
if (AMI_OVERRIDE)
|
||||
return;
|
||||
|
||||
TransactionLogUpdate(transactionId, XID_COMMIT);
|
||||
TransactionLogUpdate(transactionId, TRANSACTION_STATUS_COMMITTED);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -470,5 +234,5 @@ TransactionIdAbort(TransactionId transactionId)
|
||||
if (AMI_OVERRIDE)
|
||||
return;
|
||||
|
||||
TransactionLogUpdate(transactionId, XID_ABORT);
|
||||
TransactionLogUpdate(transactionId, TRANSACTION_STATUS_ABORTED);
|
||||
}
|
||||
|
||||
@ -1,466 +0,0 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* transsup.c
|
||||
* postgres transaction access method support code
|
||||
*
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/transsup.c,v 1.31 2001/07/12 04:11:13 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* This file contains support functions for the high
|
||||
* level access method interface routines found in transam.c
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#include "postgres.h"
|
||||
|
||||
#include "access/xact.h"
|
||||
#include "utils/bit.h"
|
||||
|
||||
|
||||
/* ----------------
|
||||
* transaction system version id
|
||||
*
|
||||
* this is stored on the first page of the log, time and variable
|
||||
* relations on the first 4 bytes. This is so that if we improve
|
||||
* the format of the transaction log after postgres version 2, then
|
||||
* people won't have to rebuild their databases.
|
||||
*
|
||||
* TRANS_SYSTEM_VERSION 100 means major version 1 minor version 0.
|
||||
* Two databases with the same major version should be compatible,
|
||||
* even if their minor versions differ.
|
||||
*
|
||||
* XXX This isn't actually being used!
|
||||
* ----------------
|
||||
*/
|
||||
#define TRANS_SYSTEM_VERSION 200
|
||||
|
||||
/* ----------------
|
||||
* LogRelationContents structure
|
||||
*
|
||||
* This structure describes the storage of the data in the
|
||||
* first 128 bytes of the log relation. This storage is never
|
||||
* used for transaction status because transaction id's begin
|
||||
* their numbering at 512.
|
||||
*
|
||||
* The first 4 bytes of this relation store the version
|
||||
* number of the transaction system.
|
||||
*
|
||||
* XXX This isn't actually being used!
|
||||
* ----------------
|
||||
*/
|
||||
typedef struct LogRelationContentsData
|
||||
{
|
||||
XLogRecPtr LSN; /* temp hack: LSN is member of any block */
|
||||
/* so should be described in bufmgr */
|
||||
int TransSystemVersion;
|
||||
} LogRelationContentsData;
|
||||
|
||||
typedef LogRelationContentsData *LogRelationContents;
|
||||
|
||||
|
||||
/* ----------------
|
||||
* BitIndexOf computes the index of the Nth xid on a given block
|
||||
* ----------------
|
||||
*/
|
||||
#define BitIndexOf(N) ((N) * 2)
|
||||
|
||||
/* ----------------
|
||||
* transaction page definitions
|
||||
* ----------------
|
||||
*/
|
||||
#define TP_DataSize (BLCKSZ - sizeof(XLogRecPtr))
|
||||
#define TP_NumXidStatusPerBlock (TP_DataSize * 4)
|
||||
|
||||
|
||||
static XidStatus TransBlockGetXidStatus(Block tblock,
|
||||
TransactionId transactionId);
|
||||
static void TransBlockSetXidStatus(Block tblock,
|
||||
TransactionId transactionId, XidStatus xstatus);
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* general support routines
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* --------------------------------
|
||||
* AmiTransactionOverride
|
||||
*
|
||||
* This function is used to manipulate the bootstrap flag.
|
||||
* --------------------------------
|
||||
*/
|
||||
void
|
||||
AmiTransactionOverride(bool flag)
|
||||
{
|
||||
AMI_OVERRIDE = flag;
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
* TransComputeBlockNumber
|
||||
* --------------------------------
|
||||
*/
|
||||
void
|
||||
TransComputeBlockNumber(Relation relation, /* relation to test */
|
||||
TransactionId transactionId, /* transaction id to
|
||||
* test */
|
||||
BlockNumber *blockNumberOutP)
|
||||
{
|
||||
uint32 itemsPerBlock = 0;
|
||||
|
||||
/*
|
||||
* we calculate the block number of our transaction by dividing the
|
||||
* transaction id by the number of transaction things per block.
|
||||
*/
|
||||
if (relation == LogRelation)
|
||||
itemsPerBlock = TP_NumXidStatusPerBlock;
|
||||
else
|
||||
elog(ERROR, "TransComputeBlockNumber: unknown relation");
|
||||
|
||||
/* ----------------
|
||||
* warning! if the transaction id's get too large
|
||||
* then a BlockNumber may not be large enough to hold the results
|
||||
* of our division.
|
||||
*
|
||||
* XXX this will all vanish soon when we implement an improved
|
||||
* transaction id schema -cim 3/23/90
|
||||
*
|
||||
* This has vanished now that xid's are 4 bytes (no longer 5).
|
||||
* -mer 5/24/92
|
||||
* ----------------
|
||||
*/
|
||||
(*blockNumberOutP) = transactionId / itemsPerBlock;
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* trans block support routines
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* --------------------------------
|
||||
* TransBlockGetLastTransactionIdStatus
|
||||
*
|
||||
* This returns the status and transaction id of the last
|
||||
* transaction information recorded on the given TransBlock.
|
||||
* --------------------------------
|
||||
*/
|
||||
|
||||
#ifdef NOT_USED
|
||||
static XidStatus
|
||||
TransBlockGetLastTransactionIdStatus(Block tblock,
|
||||
TransactionId baseXid,
|
||||
TransactionId *returnXidP)
|
||||
{
|
||||
Index index;
|
||||
Index maxIndex;
|
||||
bits8 bit1;
|
||||
bits8 bit2;
|
||||
BitIndex offset;
|
||||
XidStatus xstatus;
|
||||
|
||||
/*
|
||||
* sanity check
|
||||
*/
|
||||
Assert((tblock != NULL));
|
||||
|
||||
/*
|
||||
* search downward from the top of the block data, looking for the
|
||||
* first Non-in progress transaction status. Since we are scanning
|
||||
* backward, this will be last recorded transaction status on the
|
||||
* block.
|
||||
*/
|
||||
maxIndex = TP_NumXidStatusPerBlock;
|
||||
for (index = maxIndex; index > 0; index--)
|
||||
{
|
||||
offset = BitIndexOf(index - 1);
|
||||
bit1 = ((bits8) BitArrayBitIsSet((BitArray) tblock, offset++)) << 1;
|
||||
bit2 = (bits8) BitArrayBitIsSet((BitArray) tblock, offset);
|
||||
|
||||
xstatus = (bit1 | bit2);
|
||||
|
||||
/*
|
||||
* here we have the status of some transaction, so test if the
|
||||
* status is recorded as "in progress". If so, then we save the
|
||||
* transaction id in the place specified by the caller.
|
||||
*/
|
||||
if (xstatus != XID_INPROGRESS)
|
||||
{
|
||||
if (returnXidP != NULL)
|
||||
TransactionIdStore(baseXid + (index - 1), returnXidP);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* if we get here and index is 0 it means we couldn't find a
|
||||
* non-inprogress transaction on the block. For now we just return
|
||||
* this info to the user. They can check if the return status is "in
|
||||
* progress" to know this condition has arisen.
|
||||
*/
|
||||
if (index == 0)
|
||||
{
|
||||
if (returnXidP != NULL)
|
||||
TransactionIdStore(baseXid, returnXidP);
|
||||
}
|
||||
|
||||
/*
|
||||
* return the status to the user
|
||||
*/
|
||||
return xstatus;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/* --------------------------------
|
||||
* TransBlockGetXidStatus
|
||||
*
|
||||
* This returns the status of the desired transaction
|
||||
* --------------------------------
|
||||
*/
|
||||
|
||||
static XidStatus
|
||||
TransBlockGetXidStatus(Block tblock,
|
||||
TransactionId transactionId)
|
||||
{
|
||||
Index index;
|
||||
bits8 bit1;
|
||||
bits8 bit2;
|
||||
BitIndex offset;
|
||||
|
||||
tblock = (Block) ((char *) tblock + sizeof(XLogRecPtr));
|
||||
|
||||
/* ----------------
|
||||
* calculate the index into the transaction data where
|
||||
* our transaction status is located
|
||||
*
|
||||
* XXX this will be replaced soon when we move to the
|
||||
* new transaction id scheme -cim 3/23/90
|
||||
*
|
||||
* The old system has now been replaced. -mer 5/24/92
|
||||
* ----------------
|
||||
*/
|
||||
index = transactionId % TP_NumXidStatusPerBlock;
|
||||
|
||||
/*
|
||||
* get the data at the specified index
|
||||
*/
|
||||
offset = BitIndexOf(index);
|
||||
bit1 = ((bits8) BitArrayBitIsSet((BitArray) tblock, offset++)) << 1;
|
||||
bit2 = (bits8) BitArrayBitIsSet((BitArray) tblock, offset);
|
||||
|
||||
/*
|
||||
* return the transaction status to the caller
|
||||
*/
|
||||
return (XidStatus) (bit1 | bit2);
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
* TransBlockSetXidStatus
|
||||
*
|
||||
* This sets the status of the desired transaction
|
||||
* --------------------------------
|
||||
*/
|
||||
static void
|
||||
TransBlockSetXidStatus(Block tblock,
|
||||
TransactionId transactionId,
|
||||
XidStatus xstatus)
|
||||
{
|
||||
Index index;
|
||||
BitIndex offset;
|
||||
|
||||
tblock = (Block) ((char *) tblock + sizeof(XLogRecPtr));
|
||||
|
||||
/* ----------------
|
||||
* calculate the index into the transaction data where
|
||||
* we sould store our transaction status.
|
||||
*
|
||||
* XXX this will be replaced soon when we move to the
|
||||
* new transaction id scheme -cim 3/23/90
|
||||
*
|
||||
* The new scheme is here -mer 5/24/92
|
||||
* ----------------
|
||||
*/
|
||||
index = transactionId % TP_NumXidStatusPerBlock;
|
||||
|
||||
offset = BitIndexOf(index);
|
||||
|
||||
/*
|
||||
* store the transaction value at the specified offset
|
||||
*/
|
||||
switch (xstatus)
|
||||
{
|
||||
case XID_COMMIT: /* set 10 */
|
||||
BitArraySetBit((BitArray) tblock, offset);
|
||||
BitArrayClearBit((BitArray) tblock, offset + 1);
|
||||
break;
|
||||
case XID_ABORT: /* set 01 */
|
||||
BitArrayClearBit((BitArray) tblock, offset);
|
||||
BitArraySetBit((BitArray) tblock, offset + 1);
|
||||
break;
|
||||
case XID_INPROGRESS: /* set 00 */
|
||||
BitArrayClearBit((BitArray) tblock, offset);
|
||||
BitArrayClearBit((BitArray) tblock, offset + 1);
|
||||
break;
|
||||
default:
|
||||
elog(NOTICE,
|
||||
"TransBlockSetXidStatus: invalid status: %d (ignored)",
|
||||
xstatus);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* transam i/o support routines
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* --------------------------------
|
||||
* TransBlockNumberGetXidStatus
|
||||
* --------------------------------
|
||||
*/
|
||||
XidStatus
|
||||
TransBlockNumberGetXidStatus(Relation relation,
|
||||
BlockNumber blockNumber,
|
||||
TransactionId xid,
|
||||
bool *failP)
|
||||
{
|
||||
Buffer buffer; /* buffer associated with block */
|
||||
Block block; /* block containing xstatus */
|
||||
XidStatus xstatus; /* recorded status of xid */
|
||||
bool localfail; /* bool used if failP = NULL */
|
||||
|
||||
/*
|
||||
* get the page containing the transaction information
|
||||
*/
|
||||
buffer = ReadBuffer(relation, blockNumber);
|
||||
LockBuffer(buffer, BUFFER_LOCK_SHARE);
|
||||
block = BufferGetBlock(buffer);
|
||||
|
||||
/*
|
||||
* get the status from the block. note, for now we always return
|
||||
* false in failP.
|
||||
*/
|
||||
if (failP == NULL)
|
||||
failP = &localfail;
|
||||
(*failP) = false;
|
||||
|
||||
xstatus = TransBlockGetXidStatus(block, xid);
|
||||
|
||||
/*
|
||||
* release the buffer and return the status
|
||||
*/
|
||||
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
|
||||
ReleaseBuffer(buffer);
|
||||
|
||||
return xstatus;
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
* TransBlockNumberSetXidStatus
|
||||
* --------------------------------
|
||||
*/
|
||||
void
|
||||
TransBlockNumberSetXidStatus(Relation relation,
|
||||
BlockNumber blockNumber,
|
||||
TransactionId xid,
|
||||
XidStatus xstatus,
|
||||
bool *failP)
|
||||
{
|
||||
Buffer buffer; /* buffer associated with block */
|
||||
Block block; /* block containing xstatus */
|
||||
bool localfail; /* bool used if failP = NULL */
|
||||
|
||||
/*
|
||||
* get the block containing the transaction status
|
||||
*/
|
||||
buffer = ReadBuffer(relation, blockNumber);
|
||||
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
|
||||
block = BufferGetBlock(buffer);
|
||||
|
||||
/*
|
||||
* attempt to update the status of the transaction on the block. if we
|
||||
* are successful, write the block. otherwise release the buffer.
|
||||
* note, for now we always return false in failP.
|
||||
*/
|
||||
if (failP == NULL)
|
||||
failP = &localfail;
|
||||
(*failP) = false;
|
||||
|
||||
TransBlockSetXidStatus(block, xid, xstatus);
|
||||
|
||||
LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
|
||||
if ((*failP) == false)
|
||||
WriteBuffer(buffer);
|
||||
else
|
||||
ReleaseBuffer(buffer);
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
* TransGetLastRecordedTransaction
|
||||
* --------------------------------
|
||||
*/
|
||||
#ifdef NOT_USED
|
||||
void
|
||||
TransGetLastRecordedTransaction(Relation relation,
|
||||
TransactionId xid, /* return: transaction
|
||||
* id */
|
||||
bool *failP)
|
||||
{
|
||||
BlockNumber blockNumber; /* block number */
|
||||
Buffer buffer; /* buffer associated with block */
|
||||
Block block; /* block containing xid status */
|
||||
BlockNumber n; /* number of blocks in the relation */
|
||||
TransactionId baseXid;
|
||||
|
||||
(*failP) = false;
|
||||
|
||||
/*
|
||||
* SOMEDAY gain exclusive access to the log relation
|
||||
*
|
||||
* That someday is today 5 Aug. 1991 -mer It looks to me like we only
|
||||
* need to set a read lock here, despite the above comment about
|
||||
* exclusive access. The block is never actually written into, we
|
||||
* only check status bits.
|
||||
*/
|
||||
RelationSetLockForRead(relation);
|
||||
|
||||
/*
|
||||
* we assume the last block of the log contains the last recorded
|
||||
* transaction. If the relation is empty we return failure to the
|
||||
* user.
|
||||
*/
|
||||
n = RelationGetNumberOfBlocks(relation);
|
||||
if (n == 0)
|
||||
{
|
||||
(*failP) = true;
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* get the block containing the transaction information
|
||||
*/
|
||||
blockNumber = n - 1;
|
||||
buffer = ReadBuffer(relation, blockNumber);
|
||||
block = BufferGetBlock(buffer);
|
||||
|
||||
/*
|
||||
* get the last xid on the block
|
||||
*/
|
||||
baseXid = blockNumber * TP_NumXidStatusPerBlock;
|
||||
|
||||
/* XXX ???? xid won't get returned! - AY '94 */
|
||||
TransBlockGetLastTransactionIdStatus(block, baseXid, &xid);
|
||||
|
||||
ReleaseBuffer(buffer);
|
||||
|
||||
/*
|
||||
* SOMEDAY release our lock on the log relation
|
||||
*/
|
||||
RelationUnsetLockForRead(relation);
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -6,15 +6,15 @@
|
||||
* Copyright (c) 2000, PostgreSQL Global Development Group
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/varsup.c,v 1.44 2001/08/23 23:06:37 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/varsup.c,v 1.45 2001/08/25 18:52:41 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "postgres.h"
|
||||
|
||||
#include "access/clog.h"
|
||||
#include "access/transam.h"
|
||||
#include "access/xlog.h"
|
||||
#include "storage/proc.h"
|
||||
|
||||
|
||||
@ -32,25 +32,34 @@ VariableCache ShmemVariableCache = NULL;
|
||||
/*
|
||||
* Allocate the next XID for my new transaction.
|
||||
*/
|
||||
void
|
||||
GetNewTransactionId(TransactionId *xid)
|
||||
TransactionId
|
||||
GetNewTransactionId(void)
|
||||
{
|
||||
TransactionId xid;
|
||||
|
||||
/*
|
||||
* During bootstrap initialization, we return the special bootstrap
|
||||
* transaction id.
|
||||
*/
|
||||
if (AMI_OVERRIDE)
|
||||
{
|
||||
*xid = BootstrapTransactionId;
|
||||
return;
|
||||
}
|
||||
return BootstrapTransactionId;
|
||||
|
||||
SpinAcquire(XidGenLockId);
|
||||
|
||||
*xid = ShmemVariableCache->nextXid;
|
||||
xid = ShmemVariableCache->nextXid;
|
||||
|
||||
TransactionIdAdvance(ShmemVariableCache->nextXid);
|
||||
|
||||
/*
|
||||
* If we have just allocated the first XID of a new page of the
|
||||
* commit log, zero out that commit-log page before returning.
|
||||
* We must do this while holding XidGenLock, else another xact could
|
||||
* acquire and commit a later XID before we zero the page. Fortunately,
|
||||
* a page of the commit log holds 32K or more transactions, so we don't
|
||||
* have to do this very often.
|
||||
*/
|
||||
ExtendCLOG(xid);
|
||||
|
||||
/*
|
||||
* Must set MyProc->xid before releasing XidGenLock. This ensures that
|
||||
* when GetSnapshotData calls ReadNewTransactionId, all active XIDs
|
||||
@ -72,30 +81,33 @@ GetNewTransactionId(TransactionId *xid)
|
||||
* removed while holding the lock.)
|
||||
*/
|
||||
if (MyProc != (PROC *) NULL)
|
||||
MyProc->xid = *xid;
|
||||
MyProc->xid = xid;
|
||||
|
||||
SpinRelease(XidGenLockId);
|
||||
|
||||
return xid;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read nextXid but don't allocate it.
|
||||
*/
|
||||
void
|
||||
ReadNewTransactionId(TransactionId *xid)
|
||||
TransactionId
|
||||
ReadNewTransactionId(void)
|
||||
{
|
||||
TransactionId xid;
|
||||
|
||||
/*
|
||||
* During bootstrap initialization, we return the special bootstrap
|
||||
* transaction id.
|
||||
*/
|
||||
if (AMI_OVERRIDE)
|
||||
{
|
||||
*xid = BootstrapTransactionId;
|
||||
return;
|
||||
}
|
||||
return BootstrapTransactionId;
|
||||
|
||||
SpinAcquire(XidGenLockId);
|
||||
*xid = ShmemVariableCache->nextXid;
|
||||
xid = ShmemVariableCache->nextXid;
|
||||
SpinRelease(XidGenLockId);
|
||||
|
||||
return xid;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.108 2001/07/16 22:43:33 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.109 2001/08/25 18:52:41 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* Transaction aborts can now occur two ways:
|
||||
@ -228,22 +228,6 @@ int CommitSiblings = 5; /* number of concurrent xacts needed to
|
||||
static void (*_RollbackFunc) (void *) = NULL;
|
||||
static void *_RollbackData = NULL;
|
||||
|
||||
/* ----------------
|
||||
* info returned when the system is disabled
|
||||
*
|
||||
* Apparently a lot of this code is inherited from other prototype systems.
|
||||
*
|
||||
* For DisabledStartTime, use a symbolic value to make the relationships clearer.
|
||||
* The old value of 1073741823 corresponds to a date in y2004, which is coming closer
|
||||
* every day. It appears that if we return a value guaranteed larger than
|
||||
* any real time associated with a transaction then comparisons in other
|
||||
* modules will still be correct. Let's use BIG_ABSTIME for this. tgl 2/14/97
|
||||
* ----------------
|
||||
*/
|
||||
static CommandId DisabledCommandId = (CommandId) -1;
|
||||
|
||||
static AbsoluteTime DisabledStartTime = (AbsoluteTime) BIG_ABSTIME;
|
||||
|
||||
/* ----------------
|
||||
* catalog creation transaction bootstrapping flag.
|
||||
* This should be eliminated and added to the transaction
|
||||
@ -309,8 +293,6 @@ IsTransactionState(void)
|
||||
return true;
|
||||
case TRANS_ABORT:
|
||||
return true;
|
||||
case TRANS_DISABLED:
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -339,44 +321,9 @@ IsAbortedTransactionBlockState(void)
|
||||
return false;
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
* OverrideTransactionSystem
|
||||
*
|
||||
* This is used to temporarily disable the transaction
|
||||
* processing system in order to do initialization of
|
||||
* the transaction system data structures and relations
|
||||
* themselves.
|
||||
* --------------------------------
|
||||
*/
|
||||
static int SavedTransactionState;
|
||||
|
||||
void
|
||||
OverrideTransactionSystem(bool flag)
|
||||
{
|
||||
TransactionState s = CurrentTransactionState;
|
||||
|
||||
if (flag == true)
|
||||
{
|
||||
if (s->state == TRANS_DISABLED)
|
||||
return;
|
||||
|
||||
SavedTransactionState = s->state;
|
||||
s->state = TRANS_DISABLED;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (s->state != TRANS_DISABLED)
|
||||
return;
|
||||
|
||||
s->state = SavedTransactionState;
|
||||
}
|
||||
}
|
||||
|
||||
/* --------------------------------
|
||||
* GetCurrentTransactionId
|
||||
*
|
||||
* This returns the id of the current transaction, or
|
||||
* the id of the "disabled" transaction.
|
||||
* --------------------------------
|
||||
*/
|
||||
TransactionId
|
||||
@ -384,16 +331,6 @@ GetCurrentTransactionId(void)
|
||||
{
|
||||
TransactionState s = CurrentTransactionState;
|
||||
|
||||
/*
|
||||
* if the transaction system is disabled, we return the special
|
||||
* "disabled" transaction id.
|
||||
*/
|
||||
if (s->state == TRANS_DISABLED)
|
||||
return DisabledTransactionId;
|
||||
|
||||
/*
|
||||
* otherwise return the current transaction id.
|
||||
*/
|
||||
return s->transactionIdData;
|
||||
}
|
||||
|
||||
@ -407,13 +344,6 @@ GetCurrentCommandId(void)
|
||||
{
|
||||
TransactionState s = CurrentTransactionState;
|
||||
|
||||
/*
|
||||
* if the transaction system is disabled, we return the special
|
||||
* "disabled" command id.
|
||||
*/
|
||||
if (s->state == TRANS_DISABLED)
|
||||
return DisabledCommandId;
|
||||
|
||||
return s->commandId;
|
||||
}
|
||||
|
||||
@ -422,13 +352,6 @@ GetScanCommandId(void)
|
||||
{
|
||||
TransactionState s = CurrentTransactionState;
|
||||
|
||||
/*
|
||||
* if the transaction system is disabled, we return the special
|
||||
* "disabled" command id.
|
||||
*/
|
||||
if (s->state == TRANS_DISABLED)
|
||||
return DisabledCommandId;
|
||||
|
||||
return s->scanCommandId;
|
||||
}
|
||||
|
||||
@ -442,13 +365,6 @@ GetCurrentTransactionStartTime(void)
|
||||
{
|
||||
TransactionState s = CurrentTransactionState;
|
||||
|
||||
/*
|
||||
* if the transaction system is disabled, we return the special
|
||||
* "disabled" starting time.
|
||||
*/
|
||||
if (s->state == TRANS_DISABLED)
|
||||
return DisabledStartTime;
|
||||
|
||||
return s->startTime;
|
||||
}
|
||||
|
||||
@ -523,16 +439,6 @@ SetScanCommandId(CommandId savedId)
|
||||
CurrentTransactionStateData.scanCommandId = savedId;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* initialization stuff
|
||||
* ----------------------------------------------------------------
|
||||
*/
|
||||
void
|
||||
InitializeTransactionSystem(void)
|
||||
{
|
||||
InitializeTransactionLog();
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------
|
||||
* StartTransaction stuff
|
||||
* ----------------------------------------------------------------
|
||||
@ -617,15 +523,19 @@ AtStart_Memory(void)
|
||||
* --------------------------------
|
||||
*/
|
||||
void
|
||||
RecordTransactionCommit()
|
||||
RecordTransactionCommit(void)
|
||||
{
|
||||
TransactionId xid;
|
||||
bool leak;
|
||||
|
||||
xid = GetCurrentTransactionId();
|
||||
|
||||
leak = BufferPoolCheckLeak();
|
||||
|
||||
xid = GetCurrentTransactionId();
|
||||
|
||||
/*
|
||||
* We needn't write anything in xlog or clog if the transaction was
|
||||
* read-only, which we check by testing if it made any xlog entries.
|
||||
*/
|
||||
if (MyLastRecPtr.xrecoff != 0)
|
||||
{
|
||||
XLogRecData rdata;
|
||||
@ -673,6 +583,7 @@ RecordTransactionCommit()
|
||||
/* Break the chain of back-links in the XLOG records I output */
|
||||
MyLastRecPtr.xrecoff = 0;
|
||||
|
||||
/* Mark the transaction committed in clog */
|
||||
TransactionIdCommit(xid);
|
||||
|
||||
END_CRIT_SECTION();
|
||||
@ -765,7 +676,10 @@ RecordTransactionAbort(void)
|
||||
TransactionId xid = GetCurrentTransactionId();
|
||||
|
||||
/*
|
||||
* Double check here is to catch case that we aborted partway through
|
||||
* We needn't write anything in xlog or clog if the transaction was
|
||||
* read-only, which we check by testing if it made any xlog entries.
|
||||
*
|
||||
* Extra check here is to catch case that we aborted partway through
|
||||
* RecordTransactionCommit ...
|
||||
*/
|
||||
if (MyLastRecPtr.xrecoff != 0 && !TransactionIdDidCommit(xid))
|
||||
@ -782,8 +696,17 @@ RecordTransactionAbort(void)
|
||||
|
||||
START_CRIT_SECTION();
|
||||
|
||||
/*
|
||||
* SHOULD SAVE ARRAY OF RELFILENODE-s TO DROP
|
||||
*/
|
||||
recptr = XLogInsert(RM_XACT_ID, XLOG_XACT_ABORT, &rdata);
|
||||
|
||||
/*
|
||||
* There's no need for XLogFlush here, since the default assumption
|
||||
* would be that we aborted, anyway.
|
||||
*/
|
||||
|
||||
/* Mark the transaction aborted in clog */
|
||||
TransactionIdAbort(xid);
|
||||
|
||||
END_CRIT_SECTION();
|
||||
@ -913,7 +836,7 @@ StartTransaction(void)
|
||||
* fix to a communications problem, and we keep having to deal with it
|
||||
* here. We should fix the comm channel code. mao 080891
|
||||
*/
|
||||
if (s->state == TRANS_DISABLED || s->state == TRANS_INPROGRESS)
|
||||
if (s->state == TRANS_INPROGRESS)
|
||||
return;
|
||||
|
||||
/*
|
||||
@ -927,7 +850,7 @@ StartTransaction(void)
|
||||
/*
|
||||
* generate a new transaction id
|
||||
*/
|
||||
GetNewTransactionId(&(s->transactionIdData));
|
||||
s->transactionIdData = GetNewTransactionId();
|
||||
|
||||
XactLockTableInsert(s->transactionIdData);
|
||||
|
||||
@ -984,11 +907,8 @@ CommitTransaction(void)
|
||||
/*
|
||||
* check the current transaction state
|
||||
*/
|
||||
if (s->state == TRANS_DISABLED)
|
||||
return;
|
||||
|
||||
if (s->state != TRANS_INPROGRESS)
|
||||
elog(NOTICE, "CommitTransaction and not in in-progress state ");
|
||||
elog(NOTICE, "CommitTransaction and not in in-progress state");
|
||||
|
||||
/*
|
||||
* Tell the trigger manager that this transaction is about to be
|
||||
@ -1109,12 +1029,6 @@ AbortTransaction(void)
|
||||
/*
|
||||
* check the current transaction state
|
||||
*/
|
||||
if (s->state == TRANS_DISABLED)
|
||||
{
|
||||
RESUME_INTERRUPTS();
|
||||
return;
|
||||
}
|
||||
|
||||
if (s->state != TRANS_INPROGRESS)
|
||||
elog(NOTICE, "AbortTransaction and not in in-progress state");
|
||||
|
||||
@ -1138,7 +1052,7 @@ AbortTransaction(void)
|
||||
CloseSequences();
|
||||
AtEOXact_portals();
|
||||
|
||||
/* Advertise the fact that we aborted in pg_log. */
|
||||
/* Advertise the fact that we aborted in pg_clog. */
|
||||
RecordTransactionAbort();
|
||||
|
||||
/*
|
||||
@ -1191,9 +1105,6 @@ CleanupTransaction(void)
|
||||
{
|
||||
TransactionState s = CurrentTransactionState;
|
||||
|
||||
if (s->state == TRANS_DISABLED)
|
||||
return;
|
||||
|
||||
/*
|
||||
* State should still be TRANS_ABORT from AbortTransaction().
|
||||
*/
|
||||
@ -1464,9 +1375,6 @@ BeginTransactionBlock(void)
|
||||
/*
|
||||
* check the current transaction state
|
||||
*/
|
||||
if (s->state == TRANS_DISABLED)
|
||||
return;
|
||||
|
||||
if (s->blockState != TBLOCK_DEFAULT)
|
||||
elog(NOTICE, "BEGIN: already a transaction in progress");
|
||||
|
||||
@ -1498,9 +1406,6 @@ EndTransactionBlock(void)
|
||||
/*
|
||||
* check the current transaction state
|
||||
*/
|
||||
if (s->state == TRANS_DISABLED)
|
||||
return;
|
||||
|
||||
if (s->blockState == TBLOCK_INPROGRESS)
|
||||
{
|
||||
|
||||
@ -1552,9 +1457,6 @@ AbortTransactionBlock(void)
|
||||
/*
|
||||
* check the current transaction state
|
||||
*/
|
||||
if (s->state == TRANS_DISABLED)
|
||||
return;
|
||||
|
||||
if (s->blockState == TBLOCK_INPROGRESS)
|
||||
{
|
||||
|
||||
@ -1591,12 +1493,6 @@ UserAbortTransactionBlock(void)
|
||||
{
|
||||
TransactionState s = CurrentTransactionState;
|
||||
|
||||
/*
|
||||
* check the current transaction state
|
||||
*/
|
||||
if (s->state == TRANS_DISABLED)
|
||||
return;
|
||||
|
||||
/*
|
||||
* if the transaction has already been automatically aborted with an
|
||||
* error, and the user subsequently types 'abort', allow it. (the
|
||||
@ -1665,7 +1561,6 @@ AbortOutOfAnyTransaction(void)
|
||||
CleanupTransaction();
|
||||
break;
|
||||
case TRANS_DEFAULT:
|
||||
case TRANS_DISABLED:
|
||||
/* Not in a transaction, do nothing */
|
||||
break;
|
||||
}
|
||||
@ -1700,7 +1595,10 @@ xact_redo(XLogRecPtr lsn, XLogRecord *record)
|
||||
/* SHOULD REMOVE FILES OF ALL DROPPED RELATIONS */
|
||||
}
|
||||
else if (info == XLOG_XACT_ABORT)
|
||||
{
|
||||
TransactionIdAbort(record->xl_xid);
|
||||
/* SHOULD REMOVE FILES OF ALL FAILED-TO-BE-CREATED RELATIONS */
|
||||
}
|
||||
else
|
||||
elog(STOP, "xact_redo: unknown op code %u", info);
|
||||
}
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/xlog.c,v 1.74 2001/08/23 23:06:37 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/xlog.c,v 1.75 2001/08/25 18:52:41 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -26,8 +26,11 @@
|
||||
#include <locale.h>
|
||||
#endif
|
||||
|
||||
#include "access/clog.h"
|
||||
#include "access/transam.h"
|
||||
#include "access/xact.h"
|
||||
#include "access/xlog.h"
|
||||
#include "access/xlogutils.h"
|
||||
#include "catalog/catversion.h"
|
||||
#include "catalog/pg_control.h"
|
||||
#include "storage/sinval.h"
|
||||
@ -35,8 +38,6 @@
|
||||
#include "storage/spin.h"
|
||||
#include "storage/s_lock.h"
|
||||
#include "storage/bufpage.h"
|
||||
#include "access/xlog.h"
|
||||
#include "access/xlogutils.h"
|
||||
#include "utils/builtins.h"
|
||||
#include "utils/relcache.h"
|
||||
#include "utils/selfuncs.h"
|
||||
@ -1580,7 +1581,7 @@ MoveOfflineLogs(uint32 log, uint32 seg, XLogRecPtr endptr)
|
||||
strspn(xlde->d_name, "0123456789ABCDEF") == 16 &&
|
||||
strcmp(xlde->d_name, lastoff) <= 0)
|
||||
{
|
||||
sprintf(path, "%s/%s", XLogDir, xlde->d_name);
|
||||
snprintf(path, MAXPGPATH, "%s/%s", XLogDir, xlde->d_name);
|
||||
if (XLOG_archive_dir[0])
|
||||
{
|
||||
elog(LOG, "archiving transaction log file %s",
|
||||
@ -2409,6 +2410,9 @@ BootStrapXLOG(void)
|
||||
/* some additional ControlFile fields are set in WriteControlFile() */
|
||||
|
||||
WriteControlFile();
|
||||
|
||||
/* Bootstrap the commit log, too */
|
||||
BootStrapCLOG();
|
||||
}
|
||||
|
||||
static char *
|
||||
@ -2543,7 +2547,6 @@ StartupXLOG(void)
|
||||
ControlFile->time = time(NULL);
|
||||
UpdateControlFile();
|
||||
|
||||
XLogOpenLogRelation(); /* open pg_log */
|
||||
XLogInitRelationCache();
|
||||
|
||||
/* Is REDO required ? */
|
||||
@ -2724,6 +2727,9 @@ StartupXLOG(void)
|
||||
ThisStartUpID++;
|
||||
XLogCtl->ThisStartUpID = ThisStartUpID;
|
||||
|
||||
/* Start up the commit log, too */
|
||||
StartupCLOG();
|
||||
|
||||
elog(LOG, "database system is ready");
|
||||
CritSectionCount--;
|
||||
|
||||
@ -2845,6 +2851,7 @@ ShutdownXLOG(void)
|
||||
CritSectionCount++;
|
||||
CreateDummyCaches();
|
||||
CreateCheckPoint(true);
|
||||
ShutdownCLOG();
|
||||
CritSectionCount--;
|
||||
|
||||
elog(LOG, "database system is shut down");
|
||||
@ -2981,6 +2988,9 @@ CreateCheckPoint(bool shutdown)
|
||||
*/
|
||||
FlushBufferPool();
|
||||
|
||||
/* And commit-log buffers, too */
|
||||
CheckPointCLOG();
|
||||
|
||||
/*
|
||||
* Now insert the checkpoint record into XLOG.
|
||||
*/
|
||||
|
||||
@ -6,24 +6,21 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/xlogutils.c,v 1.17 2001/08/23 23:06:37 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/transam/xlogutils.c,v 1.18 2001/08/25 18:52:41 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#include "postgres.h"
|
||||
|
||||
#include "access/xlog.h"
|
||||
#include "access/transam.h"
|
||||
#include "access/xact.h"
|
||||
#include "storage/bufpage.h"
|
||||
#include "storage/bufmgr.h"
|
||||
#include "storage/smgr.h"
|
||||
#include "access/htup.h"
|
||||
#include "access/xlogutils.h"
|
||||
#include "catalog/pg_database.h"
|
||||
#include "lib/hasht.h"
|
||||
#include "storage/bufpage.h"
|
||||
#include "storage/smgr.h"
|
||||
#include "utils/relcache.h"
|
||||
|
||||
|
||||
/*
|
||||
* ---------------------------------------------------------------
|
||||
*
|
||||
@ -152,33 +149,6 @@ XLogIsValidTuple(RelFileNode hnode, ItemPointer iptr)
|
||||
return (true);
|
||||
}
|
||||
|
||||
/*
|
||||
* Open pg_log in recovery
|
||||
*/
|
||||
extern Relation LogRelation; /* pg_log relation */
|
||||
|
||||
void
|
||||
XLogOpenLogRelation(void)
|
||||
{
|
||||
Relation logRelation;
|
||||
|
||||
Assert(!LogRelation);
|
||||
logRelation = (Relation) malloc(sizeof(RelationData));
|
||||
memset(logRelation, 0, sizeof(RelationData));
|
||||
logRelation->rd_rel = (Form_pg_class) malloc(sizeof(FormData_pg_class));
|
||||
memset(logRelation->rd_rel, 0, sizeof(FormData_pg_class));
|
||||
|
||||
sprintf(RelationGetPhysicalRelationName(logRelation), "pg_log");
|
||||
logRelation->rd_node.tblNode = InvalidOid;
|
||||
logRelation->rd_node.relNode = RelOid_pg_log;
|
||||
logRelation->rd_targblock = InvalidBlockNumber;
|
||||
logRelation->rd_fd = -1;
|
||||
logRelation->rd_fd = smgropen(DEFAULT_SMGR, logRelation, false);
|
||||
if (logRelation->rd_fd < 0)
|
||||
elog(STOP, "XLogOpenLogRelation: failed to open pg_log");
|
||||
LogRelation = logRelation;
|
||||
}
|
||||
|
||||
/*
|
||||
* ---------------------------------------------------------------
|
||||
*
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
#
|
||||
# Makefile for catalog
|
||||
#
|
||||
# $Header: /cvsroot/pgsql/src/backend/catalog/Makefile,v 1.36 2001/08/24 14:07:48 petere Exp $
|
||||
# $Header: /cvsroot/pgsql/src/backend/catalog/Makefile,v 1.37 2001/08/25 18:52:41 tgl Exp $
|
||||
#
|
||||
#-------------------------------------------------------------------------
|
||||
|
||||
@ -31,7 +31,7 @@ POSTGRES_BKI_SRCS := $(addprefix $(top_srcdir)/src/include/catalog/,\
|
||||
pg_operator.h pg_opclass.h pg_am.h pg_amop.h pg_amproc.h \
|
||||
pg_language.h pg_largeobject.h pg_aggregate.h pg_statistic.h \
|
||||
pg_rewrite.h pg_trigger.h pg_listener.h pg_description.h \
|
||||
pg_database.h pg_shadow.h pg_group.h pg_log.h indexing.h \
|
||||
pg_database.h pg_shadow.h pg_group.h indexing.h \
|
||||
)
|
||||
|
||||
pg_includes := $(sort -I$(top_srcdir)/src/include -I$(top_builddir)/src/include)
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.174 2001/08/10 18:57:33 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.175 2001/08/25 18:52:41 tgl Exp $
|
||||
*
|
||||
*
|
||||
* INTERFACE ROUTINES
|
||||
@ -252,11 +252,6 @@ heap_create(char *relname,
|
||||
tblNode = InvalidOid;
|
||||
relid = RelOid_pg_database;
|
||||
}
|
||||
else if (strcmp(LogRelationName, relname) == 0)
|
||||
{
|
||||
tblNode = InvalidOid;
|
||||
relid = RelOid_pg_log;
|
||||
}
|
||||
else
|
||||
{
|
||||
relid = newoid();
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.247 2001/08/21 16:36:03 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.248 2001/08/25 18:52:41 tgl Exp $
|
||||
*
|
||||
* HISTORY
|
||||
* AUTHOR DATE MAJOR EVENT
|
||||
@ -51,7 +51,6 @@
|
||||
#include <ctype.h>
|
||||
|
||||
#include "access/htup.h"
|
||||
#include "catalog/catname.h"
|
||||
#include "catalog/pg_type.h"
|
||||
#include "nodes/params.h"
|
||||
#include "nodes/parsenodes.h"
|
||||
@ -5423,11 +5422,7 @@ relation_name: SpecialRuleRelation
|
||||
}
|
||||
| ColId
|
||||
{
|
||||
/* disallow refs to variable system tables */
|
||||
if (strcmp(LogRelationName, $1) == 0)
|
||||
elog(ERROR,"%s cannot be accessed by users",$1);
|
||||
else
|
||||
$$ = $1;
|
||||
$$ = $1;
|
||||
}
|
||||
;
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
$Header: /cvsroot/pgsql/src/backend/storage/buffer/README,v 1.1 2001/07/06 21:04:25 tgl Exp $
|
||||
$Header: /cvsroot/pgsql/src/backend/storage/buffer/README,v 1.2 2001/08/25 18:52:42 tgl Exp $
|
||||
|
||||
Notes about shared buffer access rules
|
||||
--------------------------------------
|
||||
@ -66,7 +66,7 @@ at about the same time would OR the same bits into the field, so there
|
||||
is little or no risk of conflicting update; what's more, if there did
|
||||
manage to be a conflict it would merely mean that one bit-update would
|
||||
be lost and need to be done again later. These four bits are only hints
|
||||
(they cache the results of transaction status lookups in pg_log), so no
|
||||
(they cache the results of transaction status lookups in pg_clog), so no
|
||||
great harm is done if they get reset to zero by conflicting updates.
|
||||
|
||||
5. To physically remove a tuple or compact free space on a page, one
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipci.c,v 1.41 2001/06/27 23:31:39 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipci.c,v 1.42 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -17,6 +17,7 @@
|
||||
#include <sys/types.h>
|
||||
|
||||
#include "miscadmin.h"
|
||||
#include "access/clog.h"
|
||||
#include "access/xlog.h"
|
||||
#include "storage/bufmgr.h"
|
||||
#include "storage/freespace.h"
|
||||
@ -51,6 +52,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int maxBackends)
|
||||
size = BufferShmemSize();
|
||||
size += LockShmemSize(maxBackends);
|
||||
size += XLOGShmemSize();
|
||||
size += CLOGShmemSize();
|
||||
size += SLockShmemSize();
|
||||
size += SInvalShmemSize(maxBackends);
|
||||
size += FreeSpaceShmemSize();
|
||||
@ -80,9 +82,10 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int maxBackends)
|
||||
InitShmemAllocation(seghdr);
|
||||
|
||||
/*
|
||||
* Set up xlog and buffers
|
||||
* Set up xlog, clog, and buffers
|
||||
*/
|
||||
XLOGShmemInit();
|
||||
CLOGShmemInit();
|
||||
InitBufferPool();
|
||||
|
||||
/*
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/sinval.c,v 1.38 2001/08/23 23:06:37 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/sinval.c,v 1.39 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -327,7 +327,7 @@ GetSnapshotData(bool serializable)
|
||||
*--------------------
|
||||
*/
|
||||
|
||||
ReadNewTransactionId(&(snapshot->xmax));
|
||||
snapshot->xmax = ReadNewTransactionId();
|
||||
|
||||
for (index = 0; index < segP->lastBackend; index++)
|
||||
{
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.49 2001/07/09 22:18:33 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.50 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -373,7 +373,7 @@ XactLockTableWait(TransactionId xid)
|
||||
|
||||
/*
|
||||
* Transaction was committed/aborted/crashed - we have to update
|
||||
* pg_log if transaction is still marked as running.
|
||||
* pg_clog if transaction is still marked as running.
|
||||
*/
|
||||
if (!TransactionIdDidCommit(xid) && !TransactionIdDidAbort(xid))
|
||||
TransactionIdAbort(xid);
|
||||
|
||||
9
src/backend/utils/cache/relcache.c
vendored
9
src/backend/utils/cache/relcache.c
vendored
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.142 2001/08/10 18:57:37 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.143 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -43,7 +43,6 @@
|
||||
#include "catalog/indexing.h"
|
||||
#include "catalog/pg_attrdef.h"
|
||||
#include "catalog/pg_index.h"
|
||||
#include "catalog/pg_log.h"
|
||||
#include "catalog/pg_proc.h"
|
||||
#include "catalog/pg_relcheck.h"
|
||||
#include "catalog/pg_rewrite.h"
|
||||
@ -67,7 +66,6 @@ static FormData_pg_attribute Desc_pg_class[Natts_pg_class] = {Schema_pg_class};
|
||||
static FormData_pg_attribute Desc_pg_attribute[Natts_pg_attribute] = {Schema_pg_attribute};
|
||||
static FormData_pg_attribute Desc_pg_proc[Natts_pg_proc] = {Schema_pg_proc};
|
||||
static FormData_pg_attribute Desc_pg_type[Natts_pg_type] = {Schema_pg_type};
|
||||
static FormData_pg_attribute Desc_pg_log[Natts_pg_log] = {Schema_pg_log};
|
||||
|
||||
/*
|
||||
* Hash tables that index the relation cache
|
||||
@ -2120,7 +2118,6 @@ RelationCacheInitialize(void)
|
||||
formrdesc(AttributeRelationName, Natts_pg_attribute, Desc_pg_attribute);
|
||||
formrdesc(ProcedureRelationName, Natts_pg_proc, Desc_pg_proc);
|
||||
formrdesc(TypeRelationName, Natts_pg_type, Desc_pg_type);
|
||||
formrdesc(LogRelationName, Natts_pg_log, Desc_pg_log);
|
||||
|
||||
/*
|
||||
* init_irels() used to be called here. It is changed to be called in
|
||||
@ -2167,10 +2164,6 @@ RelationCacheInitializePhase2(void)
|
||||
fixrdesc(AttributeRelationName);
|
||||
fixrdesc(ProcedureRelationName);
|
||||
fixrdesc(TypeRelationName);
|
||||
|
||||
/*
|
||||
* We don't bother to update the entries for pg_log.
|
||||
*/
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/init/globals.c,v 1.58 2001/06/12 05:55:50 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/init/globals.c,v 1.59 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* Globals used all over the place should be declared here and not
|
||||
@ -102,7 +102,6 @@ char *SharedSystemRelationNames[] = {
|
||||
GroupRelationName,
|
||||
GroupNameIndex,
|
||||
GroupSysidIndex,
|
||||
LogRelationName,
|
||||
ShadowRelationName,
|
||||
ShadowNameIndex,
|
||||
ShadowSysidIndex,
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/init/postinit.c,v 1.87 2001/06/16 22:58:16 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/init/postinit.c,v 1.88 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
@ -285,26 +285,15 @@ InitPostgres(const char *dbname, const char *username)
|
||||
elog(FATAL, "InitPostgres: bad backend id %d", MyBackendId);
|
||||
|
||||
/*
|
||||
* Initialize the transaction system and the relation descriptor
|
||||
* cache. Note we have to make certain the lock manager is off while
|
||||
* we do this.
|
||||
* Initialize the transaction system override state.
|
||||
*/
|
||||
AmiTransactionOverride(IsBootstrapProcessingMode());
|
||||
LockDisable(true);
|
||||
AmiTransactionOverride(bootstrap);
|
||||
|
||||
/*
|
||||
* Part of the initialization processing done here sets a read lock on
|
||||
* pg_log. Since locking is disabled the set doesn't have intended
|
||||
* effect of locking out writers, but this is ok, since we only lock
|
||||
* it to examine AMI transaction status, and this is never written
|
||||
* after initdb is done. -mer 15 June 1992
|
||||
* Initialize the relation descriptor cache.
|
||||
* The pre-allocated reldescs are created here.
|
||||
*/
|
||||
RelationCacheInitialize(); /* pre-allocated reldescs created here */
|
||||
|
||||
InitializeTransactionSystem(); /* pg_log,etc init/crash recovery
|
||||
* here */
|
||||
|
||||
LockDisable(false);
|
||||
RelationCacheInitialize();
|
||||
|
||||
/*
|
||||
* Initialize the access methods. Does not touch files (?) - thomas
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/misc/Attic/database.c,v 1.47 2001/05/30 20:52:34 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/misc/Attic/database.c,v 1.48 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -193,7 +193,7 @@ GetRawDatabaseInfo(const char *name, Oid *db_id, char *path)
|
||||
* happens right here. We cannot really determine if the
|
||||
* tuple is valid without checking transaction commit status,
|
||||
* and the only way to do that at init time is to paw over
|
||||
* pg_log by hand, too. Instead of checking, we assume that
|
||||
* pg_clog by hand, too. Instead of checking, we assume that
|
||||
* the inserting transaction committed, and that any deleting
|
||||
* transaction did also, unless shown otherwise by on-row
|
||||
* commit status bits.
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.40 2001/08/23 23:06:38 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.41 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -611,12 +611,12 @@ HeapTupleSatisfiesVacuum(HeapTupleHeader tuple, TransactionId XmaxRecent)
|
||||
* If the inserting transaction aborted, then the tuple was never visible
|
||||
* to any other transaction, so we can delete it immediately.
|
||||
*
|
||||
* NOTE: must check TransactionIdIsInProgress (which looks in shared mem)
|
||||
* NOTE: must check TransactionIdIsInProgress (which looks in PROC array)
|
||||
* before TransactionIdDidCommit/TransactionIdDidAbort (which look in
|
||||
* pg_log). Otherwise we have a race condition where we might decide
|
||||
* pg_clog). Otherwise we have a race condition where we might decide
|
||||
* that a just-committed transaction crashed, because none of the tests
|
||||
* succeed. xact.c is careful to record commit/abort in pg_log before
|
||||
* it unsets MyProc->xid in shared memory.
|
||||
* succeed. xact.c is careful to record commit/abort in pg_clog before
|
||||
* it unsets MyProc->xid in PROC array.
|
||||
*/
|
||||
if (!(tuple->t_infomask & HEAP_XMIN_COMMITTED))
|
||||
{
|
||||
|
||||
@ -27,7 +27,7 @@
|
||||
# Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
# Portions Copyright (c) 1994, Regents of the University of California
|
||||
#
|
||||
# $Header: /cvsroot/pgsql/src/bin/initdb/Attic/initdb.sh,v 1.133 2001/08/25 00:31:17 petere Exp $
|
||||
# $Header: /cvsroot/pgsql/src/bin/initdb/Attic/initdb.sh,v 1.134 2001/08/25 18:52:42 tgl Exp $
|
||||
#
|
||||
#-------------------------------------------------------------------------
|
||||
|
||||
@ -440,6 +440,12 @@ else
|
||||
mkdir "$PGDATA"/pg_xlog || exit_nicely
|
||||
echo "ok"
|
||||
fi
|
||||
if [ ! -d "$PGDATA"/pg_clog ]
|
||||
then
|
||||
$ECHO_N "creating directory $PGDATA/pg_clog... "$ECHO_C
|
||||
mkdir "$PGDATA"/pg_clog || exit_nicely
|
||||
echo "ok"
|
||||
fi
|
||||
fi
|
||||
|
||||
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
# pg_upgrade: update a database without needing a full dump/reload cycle.
|
||||
# CAUTION: read the manual page before trying to use this!
|
||||
|
||||
# $Header: /cvsroot/pgsql/src/bin/pg_dump/Attic/pg_upgrade,v 1.16 2000/12/18 16:30:07 momjian Exp $
|
||||
# $Header: /cvsroot/pgsql/src/bin/pg_dump/Attic/pg_upgrade,v 1.17 2001/08/25 18:52:42 tgl Exp $
|
||||
#
|
||||
# NOTE: we must be sure to update the version-checking code a few dozen lines
|
||||
# below for each new PostgreSQL release.
|
||||
@ -127,9 +127,9 @@ fi
|
||||
echo "Input script $INPUT complete, fixing row commit statuses..."
|
||||
|
||||
# Now vacuum each result database to mark all system-table rows as committed,
|
||||
# because when pg_log is replaced with the saved version, the transaction
|
||||
# because when pg_clog is replaced with the saved version, the transaction
|
||||
# statuses will no longer match the data. VACUUM will force the on-row
|
||||
# status flags to the right value so that pg_log will not matter anymore.
|
||||
# status flags to the right value so that pg_clog will not matter anymore.
|
||||
# Note: we used to try to do this as part of the previous step, but that
|
||||
# risks permissions problems if VACUUM is run as the wrong user.
|
||||
# Note: the initial VACUUM does template1, then we do everything else.
|
||||
@ -171,7 +171,7 @@ do
|
||||
fi
|
||||
done
|
||||
|
||||
mv -f $OLDDIR/pg_log data
|
||||
mv -f $OLDDIR/pg_clog data
|
||||
mv -f $OLDDIR/pg_variable data
|
||||
|
||||
echo "You must stop/start the postmaster before doing anything else."
|
||||
|
||||
47
src/include/access/clog.h
Normal file
47
src/include/access/clog.h
Normal file
@ -0,0 +1,47 @@
|
||||
/*
|
||||
* clog.h
|
||||
*
|
||||
* PostgreSQL transaction-commit-log manager
|
||||
*
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: clog.h,v 1.1 2001/08/25 18:52:42 tgl Exp $
|
||||
*/
|
||||
#ifndef CLOG_H
|
||||
#define CLOG_H
|
||||
|
||||
#include "access/xlog.h"
|
||||
|
||||
/*
|
||||
* Possible transaction statuses --- note that all-zeroes is the initial
|
||||
* state.
|
||||
*/
|
||||
typedef int XidStatus;
|
||||
|
||||
#define TRANSACTION_STATUS_IN_PROGRESS 0x00
|
||||
#define TRANSACTION_STATUS_COMMITTED 0x01
|
||||
#define TRANSACTION_STATUS_ABORTED 0x02
|
||||
/* 0x03 is available without changing commit log space allocation */
|
||||
|
||||
|
||||
extern void TransactionIdSetStatus(TransactionId xid, XidStatus status);
|
||||
extern XidStatus TransactionIdGetStatus(TransactionId xid);
|
||||
|
||||
extern int CLOGShmemSize(void);
|
||||
extern void CLOGShmemInit(void);
|
||||
extern void BootStrapCLOG(void);
|
||||
extern void StartupCLOG(void);
|
||||
extern void ShutdownCLOG(void);
|
||||
extern void CheckPointCLOG(void);
|
||||
extern void ExtendCLOG(TransactionId newestXact);
|
||||
extern void TruncateCLOG(TransactionId oldestXact);
|
||||
|
||||
/* XLOG stuff */
|
||||
#define CLOG_ZEROPAGE 0x00
|
||||
|
||||
extern void clog_redo(XLogRecPtr lsn, XLogRecord *record);
|
||||
extern void clog_undo(XLogRecPtr lsn, XLogRecord *record);
|
||||
extern void clog_desc(char *buf, uint8 xl_info, char *rec);
|
||||
|
||||
#endif /* CLOG_H */
|
||||
@ -1,9 +1,9 @@
|
||||
/*
|
||||
*
|
||||
* rmgr.h
|
||||
*
|
||||
* Resource managers definition
|
||||
*
|
||||
* $Id: rmgr.h,v 1.6 2001/08/25 18:52:42 tgl Exp $
|
||||
*/
|
||||
#ifndef RMGR_H
|
||||
#define RMGR_H
|
||||
@ -16,6 +16,7 @@ typedef uint8 RmgrId;
|
||||
#define RM_XLOG_ID 0
|
||||
#define RM_XACT_ID 1
|
||||
#define RM_SMGR_ID 2
|
||||
#define RM_CLOG_ID 3
|
||||
#define RM_HEAP_ID 10
|
||||
#define RM_BTREE_ID 11
|
||||
#define RM_HASH_ID 12
|
||||
|
||||
@ -7,33 +7,30 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: transam.h,v 1.38 2001/08/23 23:06:38 tgl Exp $
|
||||
* $Id: transam.h,v 1.39 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#ifndef TRANSAM_H
|
||||
#define TRANSAM_H
|
||||
|
||||
#include "storage/bufmgr.h"
|
||||
#include "storage/spin.h"
|
||||
|
||||
|
||||
/* ----------------
|
||||
* Special transaction ID values
|
||||
*
|
||||
* We do not use any transaction IDs less than 512 --- this leaves the first
|
||||
* 128 bytes of pg_log available for special purposes such as version number
|
||||
* storage. (Currently, we do not actually use them for anything.)
|
||||
*
|
||||
* BootstrapTransactionId is the XID for "bootstrap" operations. It should
|
||||
* BootstrapTransactionId is the XID for "bootstrap" operations, and
|
||||
* FrozenTransactionId is used for very old tuples. Both should
|
||||
* always be considered valid.
|
||||
*
|
||||
* FirstNormalTransactionId is the first "normal" transaction id.
|
||||
* ----------------
|
||||
*/
|
||||
#define InvalidTransactionId ((TransactionId) 0)
|
||||
#define DisabledTransactionId ((TransactionId) 1)
|
||||
#define BootstrapTransactionId ((TransactionId) 512)
|
||||
#define FirstNormalTransactionId ((TransactionId) 514)
|
||||
#define BootstrapTransactionId ((TransactionId) 1)
|
||||
#define FrozenTransactionId ((TransactionId) 2)
|
||||
#define FirstNormalTransactionId ((TransactionId) 3)
|
||||
|
||||
/* ----------------
|
||||
* transaction ID manipulation macros
|
||||
@ -56,19 +53,6 @@
|
||||
(dest) = FirstNormalTransactionId; \
|
||||
} while(0)
|
||||
|
||||
/* ----------------
|
||||
* transaction status values
|
||||
*
|
||||
* someday we will use "11" = 3 = XID_COMMIT_CHILD to mean the
|
||||
* commiting of child xactions.
|
||||
* ----------------
|
||||
*/
|
||||
#define XID_INPROGRESS 0 /* transaction in progress */
|
||||
#define XID_ABORT 1 /* transaction aborted */
|
||||
#define XID_COMMIT 2 /* transaction commited */
|
||||
#define XID_COMMIT_CHILD 3 /* child xact commited */
|
||||
|
||||
typedef unsigned char XidStatus; /* (2 bits) */
|
||||
|
||||
/* ----------
|
||||
* Object ID (OID) zero is InvalidOid.
|
||||
@ -116,25 +100,15 @@ typedef VariableCacheData *VariableCache;
|
||||
/*
|
||||
* prototypes for functions in transam/transam.c
|
||||
*/
|
||||
extern void InitializeTransactionLog(void);
|
||||
extern void AmiTransactionOverride(bool flag);
|
||||
extern bool TransactionIdDidCommit(TransactionId transactionId);
|
||||
extern bool TransactionIdDidAbort(TransactionId transactionId);
|
||||
extern void TransactionIdCommit(TransactionId transactionId);
|
||||
extern void TransactionIdAbort(TransactionId transactionId);
|
||||
|
||||
/* in transam/transsup.c */
|
||||
extern void AmiTransactionOverride(bool flag);
|
||||
extern void TransComputeBlockNumber(Relation relation,
|
||||
TransactionId transactionId, BlockNumber *blockNumberOutP);
|
||||
extern XidStatus TransBlockNumberGetXidStatus(Relation relation,
|
||||
BlockNumber blockNumber, TransactionId xid, bool *failP);
|
||||
extern void TransBlockNumberSetXidStatus(Relation relation,
|
||||
BlockNumber blockNumber, TransactionId xid, XidStatus xstatus,
|
||||
bool *failP);
|
||||
|
||||
/* in transam/varsup.c */
|
||||
extern void GetNewTransactionId(TransactionId *xid);
|
||||
extern void ReadNewTransactionId(TransactionId *xid);
|
||||
extern TransactionId GetNewTransactionId(void);
|
||||
extern TransactionId ReadNewTransactionId(void);
|
||||
extern Oid GetNewObjectId(void);
|
||||
extern void CheckMaxObjectId(Oid assigned_oid);
|
||||
|
||||
@ -143,9 +117,6 @@ extern void CheckMaxObjectId(Oid assigned_oid);
|
||||
* ----------------
|
||||
*/
|
||||
|
||||
/* in transam.c */
|
||||
extern Relation LogRelation;
|
||||
|
||||
/* in xact.c */
|
||||
extern bool AMI_OVERRIDE;
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: xact.h,v 1.34 2001/07/12 04:11:13 tgl Exp $
|
||||
* $Id: xact.h,v 1.35 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -54,7 +54,6 @@ typedef TransactionStateData *TransactionState;
|
||||
#define TRANS_INPROGRESS 2
|
||||
#define TRANS_COMMIT 3
|
||||
#define TRANS_ABORT 4
|
||||
#define TRANS_DISABLED 5
|
||||
|
||||
/* ----------------
|
||||
* transaction block states
|
||||
@ -100,7 +99,6 @@ extern int TransactionFlushEnabled(void);
|
||||
extern void SetTransactionFlushEnabled(bool state);
|
||||
|
||||
extern bool IsAbortedTransactionBlockState(void);
|
||||
extern void OverrideTransactionSystem(bool flag);
|
||||
extern TransactionId GetCurrentTransactionId(void);
|
||||
extern CommandId GetCurrentCommandId(void);
|
||||
extern CommandId GetScanCommandId(void);
|
||||
@ -110,7 +108,6 @@ extern bool TransactionIdIsCurrentTransactionId(TransactionId xid);
|
||||
extern bool CommandIdIsCurrentCommandId(CommandId cid);
|
||||
extern bool CommandIdGEScanCommandId(CommandId cid);
|
||||
extern void CommandCounterIncrement(void);
|
||||
extern void InitializeTransactionSystem(void);
|
||||
extern void StartTransactionCommand(void);
|
||||
extern void CommitTransactionCommand(void);
|
||||
extern void AbortCurrentTransaction(void);
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: xlog.h,v 1.24 2001/07/19 02:12:35 tgl Exp $
|
||||
* $Id: xlog.h,v 1.25 2001/08/25 18:52:42 tgl Exp $
|
||||
*/
|
||||
#ifndef XLOG_H
|
||||
#define XLOG_H
|
||||
@ -14,6 +14,7 @@
|
||||
#include "access/rmgr.h"
|
||||
#include "access/transam.h"
|
||||
#include "access/xlogdefs.h"
|
||||
#include "storage/bufmgr.h"
|
||||
#include "utils/pg_crc.h"
|
||||
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: xlogdefs.h,v 1.3 2001/03/22 04:00:32 momjian Exp $
|
||||
* $Id: xlogdefs.h,v 1.4 2001/08/25 18:52:42 tgl Exp $
|
||||
*/
|
||||
#ifndef XLOG_DEFS_H
|
||||
#define XLOG_DEFS_H
|
||||
@ -52,7 +52,7 @@ typedef struct XLogRecPtr
|
||||
|
||||
/*
|
||||
* StartUpID (SUI) - system startups counter. It's to allow removing
|
||||
* pg_log after shutdown, in future.
|
||||
* pg_clog after shutdown, in future.
|
||||
*/
|
||||
typedef uint32 StartUpID;
|
||||
|
||||
|
||||
@ -6,20 +6,20 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: xlogutils.h,v 1.7 2001/03/22 04:00:32 momjian Exp $
|
||||
* $Id: xlogutils.h,v 1.8 2001/08/25 18:52:42 tgl Exp $
|
||||
*/
|
||||
#ifndef XLOG_UTILS_H
|
||||
#define XLOG_UTILS_H
|
||||
|
||||
#include "access/rmgr.h"
|
||||
#include "storage/buf.h"
|
||||
#include "storage/itemptr.h"
|
||||
#include "utils/rel.h"
|
||||
|
||||
extern int XLogIsOwnerOfTuple(RelFileNode hnode, ItemPointer iptr,
|
||||
TransactionId xid, CommandId cid);
|
||||
extern bool XLogIsValidTuple(RelFileNode hnode, ItemPointer iptr);
|
||||
|
||||
extern void XLogOpenLogRelation(void);
|
||||
|
||||
extern void XLogInitRelationCache(void);
|
||||
extern void XLogCloseRelationCache(void);
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: catname.h,v 1.19 2001/05/14 20:30:21 momjian Exp $
|
||||
* $Id: catname.h,v 1.20 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -29,7 +29,6 @@
|
||||
#define LanguageRelationName "pg_language"
|
||||
#define LargeObjectRelationName "pg_largeobject"
|
||||
#define ListenerRelationName "pg_listener"
|
||||
#define LogRelationName "pg_log"
|
||||
#define OperatorClassRelationName "pg_opclass"
|
||||
#define OperatorRelationName "pg_operator"
|
||||
#define ProcedureRelationName "pg_proc"
|
||||
|
||||
@ -37,7 +37,7 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: catversion.h,v 1.91 2001/08/21 16:36:05 tgl Exp $
|
||||
* $Id: catversion.h,v 1.92 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -53,6 +53,6 @@
|
||||
*/
|
||||
|
||||
/* yyyymmddN */
|
||||
#define CATALOG_VERSION_NO 200108211
|
||||
#define CATALOG_VERSION_NO 200108241
|
||||
|
||||
#endif
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: pg_attribute.h,v 1.74 2001/08/10 18:57:40 tgl Exp $
|
||||
* $Id: pg_attribute.h,v 1.75 2001/08/25 18:52:42 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* the genbki.sh script reads this file and generates .bki
|
||||
@ -474,25 +474,13 @@ DATA(insert ( 1259 cmax 29 0 4 -6 0 -1 -1 t p f i f f));
|
||||
DATA(insert ( 1259 tableoid 26 0 4 -7 0 -1 -1 t p f i f f));
|
||||
|
||||
/* ----------------
|
||||
* pg_log - this relation is modified by special purpose access
|
||||
* method code. The following is garbage but is needed
|
||||
* so that the reldesc code works properly.
|
||||
* pg_xactlock - this is not a real relation, but is a placeholder
|
||||
* to allow a relation OID to be used for transaction
|
||||
* waits. We need a pg_xactlock entry in pg_class only to
|
||||
* ensure that that OID can never be allocated to a real
|
||||
* table; and this entry is just to link to that one.
|
||||
* ----------------
|
||||
*/
|
||||
#define Schema_pg_log \
|
||||
{ 1269, {"logfoo"}, 26, 0, 4, 1, 0, -1, -1, true, 'p', false, 'i', false, false }
|
||||
|
||||
DATA(insert ( 1269 logfoo 26 0 4 1 0 -1 -1 t p f i f f));
|
||||
|
||||
/* ----------------
|
||||
* pg_xactlock - this relation is modified by special purpose access
|
||||
* method code. The following is garbage but is needed
|
||||
* so that the reldesc code works properly.
|
||||
* ----------------
|
||||
*/
|
||||
#define Schema_pg_xactlock \
|
||||
{ 376, {"xactlockfoo"}, 26, 0, 4, 1, 0, -1, -1, true, 'p', false, 'i', false, false }
|
||||
|
||||
DATA(insert ( 376 xactlockfoo 26 0 4 1 0 -1 -1 t p f i f f));
|
||||
|
||||
#endif /* PG_ATTRIBUTE_H */
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: pg_class.h,v 1.52 2001/08/10 18:57:40 tgl Exp $
|
||||
* $Id: pg_class.h,v 1.53 2001/08/25 18:52:43 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* the genbki.sh script reads this file and generates .bki
|
||||
@ -144,8 +144,6 @@ DATA(insert OID = 1261 ( pg_group 87 PGUID 0 1261 0 0 0 0 f t r 3 0 0 0 0 0 f
|
||||
DESCR("");
|
||||
DATA(insert OID = 1262 ( pg_database 88 PGUID 0 1262 0 0 0 0 f t r 7 0 0 0 0 0 t f f f _null_ ));
|
||||
DESCR("");
|
||||
DATA(insert OID = 1269 ( pg_log 99 PGUID 0 1269 0 0 0 0 f t s 1 0 0 0 0 0 f f f f _null_ ));
|
||||
DESCR("");
|
||||
DATA(insert OID = 376 ( pg_xactlock 0 PGUID 0 0 0 0 0 0 f t s 1 0 0 0 0 0 f f f f _null_ ));
|
||||
DESCR("");
|
||||
|
||||
@ -156,7 +154,6 @@ DESCR("");
|
||||
#define RelOid_pg_shadow 1260
|
||||
#define RelOid_pg_group 1261
|
||||
#define RelOid_pg_database 1262
|
||||
#define RelOid_pg_log 1269
|
||||
|
||||
/* Xact lock pseudo-table */
|
||||
#define XactLockTableId 376
|
||||
|
||||
@ -1,41 +0,0 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* pg_log.h
|
||||
* the system log relation "pg_log" is not a "heap" relation.
|
||||
* it is automatically created by the transam/ code and the
|
||||
* information here is all bogus and is just here to make the
|
||||
* relcache code happy.
|
||||
*
|
||||
*
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: pg_log.h,v 1.9 2001/08/10 18:57:40 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* The structures and macros used by the transam/ code
|
||||
* to access pg_log should some day go here -cim 6/18/90
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#ifndef PG_LOG_H
|
||||
#define PG_LOG_H
|
||||
|
||||
/* ----------------
|
||||
* postgres.h contains the system type definintions and the
|
||||
* CATALOG(), BOOTSTRAP and DATA() sugar words so this file
|
||||
* can be read by both genbki.sh and the C compiler.
|
||||
* ----------------
|
||||
*/
|
||||
|
||||
CATALOG(pg_log) BOOTSTRAP BKI_WITHOUT_OIDS
|
||||
{
|
||||
Oid logfoo;
|
||||
} FormData_pg_log;
|
||||
|
||||
typedef FormData_pg_log *Form_pg_log;
|
||||
|
||||
#define Natts_pg_log 1
|
||||
#define Anum_pg_log_logfoo 1
|
||||
|
||||
#endif /* PG_LOG_H */
|
||||
@ -8,7 +8,7 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: pg_type.h,v 1.109 2001/06/12 05:55:50 tgl Exp $
|
||||
* $Id: pg_type.h,v 1.110 2001/08/25 18:52:43 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* the genbki.sh script reads this file and generates .bki
|
||||
@ -239,7 +239,6 @@ DATA(insert OID = 83 ( pg_class PGUID 4 4 t c t \054 1259 0 int4in int4out int4
|
||||
DATA(insert OID = 86 ( pg_shadow PGUID 4 4 t c t \054 1260 0 int4in int4out int4in int4out i p _null_));
|
||||
DATA(insert OID = 87 ( pg_group PGUID 4 4 t c t \054 1261 0 int4in int4out int4in int4out i p _null_));
|
||||
DATA(insert OID = 88 ( pg_database PGUID 4 4 t c t \054 1262 0 int4in int4out int4in int4out i p _null_));
|
||||
DATA(insert OID = 99 ( pg_log PGUID 4 4 t c t \054 1269 0 int4in int4out int4in int4out i p _null_));
|
||||
|
||||
/* OIDS 100 - 199 */
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: bufpage.h,v 1.42 2001/05/14 22:06:41 momjian Exp $
|
||||
* $Id: bufpage.h,v 1.43 2001/08/25 18:52:43 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -54,10 +54,6 @@
|
||||
* obviously, a page is not formatted before it is initialized with by
|
||||
* a call to PageInit.
|
||||
*
|
||||
* The contents of the special pg_log tables are raw disk blocks with
|
||||
* special formats. these are the only "access methods" that need not
|
||||
* write disk pages.
|
||||
*
|
||||
* NOTES:
|
||||
*
|
||||
* linp1..N form an ItemId array. ItemPointers point into this array
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user