1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* smgr.c
|
1997-09-07 07:04:48 +02:00
|
|
|
* public interface routines to storage manager switch.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* All file system operations in POSTGRES dispatch through these
|
|
|
|
* routines.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
|
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2000-10-28 18:21:00 +02:00
|
|
|
* $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgr.c,v 1.42 2000/10/28 16:20:57 vadim Exp $
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
|
1996-11-03 06:08:01 +01:00
|
|
|
#include "storage/smgr.h"
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2000-10-02 23:45:33 +02:00
|
|
|
static void smgrshutdown(void);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
typedef struct f_smgr
|
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
int (*smgr_init) (void); /* may be NULL */
|
|
|
|
int (*smgr_shutdown) (void); /* may be NULL */
|
2000-04-09 06:43:20 +02:00
|
|
|
int (*smgr_create) (Relation reln);
|
|
|
|
int (*smgr_unlink) (Relation reln);
|
|
|
|
int (*smgr_extend) (Relation reln, char *buffer);
|
|
|
|
int (*smgr_open) (Relation reln);
|
|
|
|
int (*smgr_close) (Relation reln);
|
|
|
|
int (*smgr_read) (Relation reln, BlockNumber blocknum,
|
2000-04-12 19:17:23 +02:00
|
|
|
char *buffer);
|
2000-04-09 06:43:20 +02:00
|
|
|
int (*smgr_write) (Relation reln, BlockNumber blocknum,
|
2000-04-12 19:17:23 +02:00
|
|
|
char *buffer);
|
2000-04-09 06:43:20 +02:00
|
|
|
int (*smgr_flush) (Relation reln, BlockNumber blocknum,
|
2000-04-12 19:17:23 +02:00
|
|
|
char *buffer);
|
2000-10-16 16:52:28 +02:00
|
|
|
int (*smgr_blindwrt) (RelFileNode rnode, BlockNumber blkno,
|
|
|
|
char *buffer, bool dofsync);
|
2000-04-09 06:43:20 +02:00
|
|
|
int (*smgr_markdirty) (Relation reln, BlockNumber blkno);
|
2000-10-16 16:52:28 +02:00
|
|
|
int (*smgr_blindmarkdirty) (RelFileNode, BlockNumber blkno);
|
2000-04-09 06:43:20 +02:00
|
|
|
int (*smgr_nblocks) (Relation reln);
|
|
|
|
int (*smgr_truncate) (Relation reln, int nblocks);
|
2000-04-12 19:17:23 +02:00
|
|
|
int (*smgr_commit) (void); /* may be NULL */
|
|
|
|
int (*smgr_abort) (void); /* may be NULL */
|
2000-10-28 18:21:00 +02:00
|
|
|
#ifdef XLOG
|
|
|
|
int (*smgr_sync) (void);
|
|
|
|
#endif
|
1997-09-08 23:56:23 +02:00
|
|
|
} f_smgr;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* The weird placement of commas in this init block is to keep the compiler
|
|
|
|
* happy, regardless of what storage managers we have (or don't have).
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
static f_smgr smgrsw[] = {
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/* magnetic disk */
|
|
|
|
{mdinit, NULL, mdcreate, mdunlink, mdextend, mdopen, mdclose,
|
2000-04-12 19:17:23 +02:00
|
|
|
mdread, mdwrite, mdflush, mdblindwrt, mdmarkdirty, mdblindmarkdirty,
|
2000-10-28 18:21:00 +02:00
|
|
|
#ifdef XLOG
|
|
|
|
mdnblocks, mdtruncate, mdcommit, mdabort, mdsync},
|
|
|
|
#else
|
2000-04-12 19:17:23 +02:00
|
|
|
mdnblocks, mdtruncate, mdcommit, mdabort},
|
2000-10-28 18:21:00 +02:00
|
|
|
#endif
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-06-23 17:35:48 +02:00
|
|
|
#ifdef STABLE_MEMORY_STORAGE
|
1997-09-07 07:04:48 +02:00
|
|
|
/* main memory */
|
|
|
|
{mminit, mmshutdown, mmcreate, mmunlink, mmextend, mmopen, mmclose,
|
2000-04-12 19:17:23 +02:00
|
|
|
mmread, mmwrite, mmflush, mmblindwrt, mmmarkdirty, mmblindmarkdirty,
|
|
|
|
mmnblocks, NULL, mmcommit, mmabort},
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-06-23 17:35:48 +02:00
|
|
|
#endif
|
1996-07-09 08:22:35 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* This array records which storage managers are write-once, and which
|
|
|
|
* support overwrite. A 'true' entry means that the storage manager is
|
|
|
|
* write-once. In the best of all possible worlds, there would be no
|
|
|
|
* write-once storage managers.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
|
1998-10-08 20:30:52 +02:00
|
|
|
#ifdef NOT_USED
|
1997-09-08 04:41:22 +02:00
|
|
|
static bool smgrwo[] = {
|
1997-09-07 07:04:48 +02:00
|
|
|
false, /* magnetic disk */
|
1998-06-23 17:35:48 +02:00
|
|
|
#ifdef STABLE_MEMORY_STORAGE
|
1997-09-07 07:04:48 +02:00
|
|
|
false, /* main memory */
|
1998-06-23 17:35:48 +02:00
|
|
|
#endif
|
1996-07-09 08:22:35 +02:00
|
|
|
};
|
1999-05-25 18:15:34 +02:00
|
|
|
|
1998-10-08 20:30:52 +02:00
|
|
|
#endif
|
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
static int NSmgr = lengthof(smgrsw);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgrinit(), smgrshutdown() -- Initialize or shut down all storage
|
|
|
|
* managers.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgrinit()
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int i;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
for (i = 0; i < NSmgr; i++)
|
|
|
|
{
|
|
|
|
if (smgrsw[i].smgr_init)
|
|
|
|
{
|
|
|
|
if ((*(smgrsw[i].smgr_init)) () == SM_FAIL)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(FATAL, "initialization failed on %s: %m",
|
2000-06-05 09:29:25 +02:00
|
|
|
DatumGetCString(DirectFunctionCall1(smgrout,
|
|
|
|
Int16GetDatum(i))));
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
/* register the shutdown proc */
|
2000-10-02 21:42:56 +02:00
|
|
|
on_proc_exit(smgrshutdown, 0);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return SM_SUCCESS;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1997-08-19 23:40:56 +02:00
|
|
|
static void
|
2000-10-02 23:45:33 +02:00
|
|
|
smgrshutdown(void)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int i;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
for (i = 0; i < NSmgr; i++)
|
|
|
|
{
|
|
|
|
if (smgrsw[i].smgr_shutdown)
|
|
|
|
{
|
|
|
|
if ((*(smgrsw[i].smgr_shutdown)) () == SM_FAIL)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(FATAL, "shutdown failed on %s: %m",
|
2000-06-05 09:29:25 +02:00
|
|
|
DatumGetCString(DirectFunctionCall1(smgrout,
|
|
|
|
Int16GetDatum(i))));
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgrcreate() -- Create a new relation.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* This routine takes a reldesc, creates the relation on the appropriate
|
|
|
|
* device, and returns a file descriptor for it.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgrcreate(int16 which, Relation reln)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int fd;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if ((fd = (*(smgrsw[which].smgr_create)) (reln)) < 0)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(ERROR, "cannot create %s: %m", RelationGetRelationName(reln));
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return fd;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgrunlink() -- Unlink a relation.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* The relation is removed from the store.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgrunlink(int16 which, Relation reln)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int status;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if ((status = (*(smgrsw[which].smgr_unlink)) (reln)) == SM_FAIL)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(ERROR, "cannot unlink %s: %m", RelationGetRelationName(reln));
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return status;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgrextend() -- Add a new block to a file.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Returns SM_SUCCESS on success; aborts the current transaction on
|
|
|
|
* failure.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgrextend(int16 which, Relation reln, char *buffer)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int status;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
status = (*(smgrsw[which].smgr_extend)) (reln, buffer);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (status == SM_FAIL)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(ERROR, "cannot extend %s: %m.\n\tCheck free disk space.",
|
2000-04-12 19:17:23 +02:00
|
|
|
RelationGetRelationName(reln));
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return status;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgropen() -- Open a relation using a particular storage manager.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Returns the fd for the open relation on success, aborts the
|
|
|
|
* transaction on failure.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgropen(int16 which, Relation reln)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int fd;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1999-11-04 09:01:09 +01:00
|
|
|
if ((fd = (*(smgrsw[which].smgr_open)) (reln)) < 0 &&
|
|
|
|
!reln->rd_unlinked)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(ERROR, "cannot open %s: %m", RelationGetRelationName(reln));
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return fd;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgrclose() -- Close a relation.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1999-09-02 04:57:50 +02:00
|
|
|
* NOTE: underlying manager should allow case where relation is
|
|
|
|
* already closed. Indeed relation may have been unlinked!
|
|
|
|
* This is currently called only from RelationFlushRelation() when
|
|
|
|
* the relation cache entry is about to be dropped; could be doing
|
|
|
|
* simple relation cache clear, or finishing up DROP TABLE.
|
2000-04-12 19:17:23 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Returns SM_SUCCESS on success, aborts on failure.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgrclose(int16 which, Relation reln)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if ((*(smgrsw[which].smgr_close)) (reln) == SM_FAIL)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(ERROR, "cannot close %s: %m", RelationGetRelationName(reln));
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return SM_SUCCESS;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgrread() -- read a particular block from a relation into the supplied
|
|
|
|
* buffer.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* This routine is called from the buffer manager in order to
|
|
|
|
* instantiate pages in the shared buffer cache. All storage managers
|
|
|
|
* return pages in the format that POSTGRES expects. This routine
|
|
|
|
* dispatches the read. On success, it returns SM_SUCCESS. On failure,
|
|
|
|
* the current transaction is aborted.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgrread(int16 which, Relation reln, BlockNumber blocknum, char *buffer)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int status;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
status = (*(smgrsw[which].smgr_read)) (reln, blocknum, buffer);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (status == SM_FAIL)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(ERROR, "cannot read block %d of %s: %m",
|
1999-11-08 00:08:36 +01:00
|
|
|
blocknum, RelationGetRelationName(reln));
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return status;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgrwrite() -- Write the supplied buffer out.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* This is not a synchronous write -- the interface for that is
|
|
|
|
* smgrflush(). The buffer is written out via the appropriate
|
|
|
|
* storage manager. This routine returns SM_SUCCESS or aborts
|
|
|
|
* the current transaction.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgrwrite(int16 which, Relation reln, BlockNumber blocknum, char *buffer)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int status;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
status = (*(smgrsw[which].smgr_write)) (reln, blocknum, buffer);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (status == SM_FAIL)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(ERROR, "cannot write block %d of %s: %m",
|
1999-11-08 00:08:36 +01:00
|
|
|
blocknum, RelationGetRelationName(reln));
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return status;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgrflush() -- A synchronous smgrwrite().
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgrflush(int16 which, Relation reln, BlockNumber blocknum, char *buffer)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int status;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
status = (*(smgrsw[which].smgr_flush)) (reln, blocknum, buffer);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if (status == SM_FAIL)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(ERROR, "cannot flush block %d of %s to stable store: %m",
|
1999-11-08 00:08:36 +01:00
|
|
|
blocknum, RelationGetRelationName(reln));
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return status;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgrblindwrt() -- Write a page out blind.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* In some cases, we may find a page in the buffer cache that we
|
|
|
|
* can't make a reldesc for. This happens, for example, when we
|
|
|
|
* want to reuse a dirty page that was written by a transaction
|
|
|
|
* that has not yet committed, which created a new relation. In
|
|
|
|
* this case, the buffer manager will call smgrblindwrt() with
|
|
|
|
* the name and OID of the database and the relation to which the
|
|
|
|
* buffer belongs. Every storage manager must be able to force
|
2000-04-12 19:17:23 +02:00
|
|
|
* this page down to stable storage in this circumstance. The
|
2000-04-11 01:41:52 +02:00
|
|
|
* write should be synchronous if dofsync is true.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2000-10-16 16:52:28 +02:00
|
|
|
int
|
|
|
|
smgrblindwrt(int16 which,
|
|
|
|
RelFileNode rnode,
|
|
|
|
BlockNumber blkno,
|
|
|
|
char *buffer,
|
|
|
|
bool dofsync)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = (*(smgrsw[which].smgr_blindwrt)) (rnode, blkno, buffer, dofsync);
|
|
|
|
|
|
|
|
if (status == SM_FAIL)
|
|
|
|
elog(ERROR, "cannot write block %d of %u/%u blind: %m",
|
|
|
|
blkno, rnode.tblNode, rnode.relNode);
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2000-04-09 06:43:20 +02:00
|
|
|
/*
|
|
|
|
* smgrmarkdirty() -- Mark a page dirty (needs fsync).
|
|
|
|
*
|
|
|
|
* Mark the specified page as needing to be fsync'd before commit.
|
|
|
|
* Ordinarily, the storage manager will do this implicitly during
|
|
|
|
* smgrwrite(). However, the buffer manager may discover that some
|
|
|
|
* other backend has written a buffer that we dirtied in the current
|
|
|
|
* transaction. In that case, we still need to fsync the file to be
|
|
|
|
* sure the page is down to disk before we commit.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgrmarkdirty(int16 which,
|
|
|
|
Relation reln,
|
|
|
|
BlockNumber blkno)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = (*(smgrsw[which].smgr_markdirty)) (reln, blkno);
|
|
|
|
|
|
|
|
if (status == SM_FAIL)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(ERROR, "cannot mark block %d of %s: %m",
|
2000-04-09 06:43:20 +02:00
|
|
|
blkno, RelationGetRelationName(reln));
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* smgrblindmarkdirty() -- Mark a page dirty, "blind".
|
|
|
|
*
|
|
|
|
* Just like smgrmarkdirty, except we don't have a reldesc.
|
|
|
|
*/
|
2000-10-16 16:52:28 +02:00
|
|
|
int
|
|
|
|
smgrblindmarkdirty(int16 which,
|
|
|
|
RelFileNode rnode,
|
|
|
|
BlockNumber blkno)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = (*(smgrsw[which].smgr_blindmarkdirty)) (rnode, blkno);
|
|
|
|
|
|
|
|
if (status == SM_FAIL)
|
|
|
|
elog(ERROR, "cannot mark block %d of %u/%u blind: %m",
|
|
|
|
blkno, rnode.tblNode, rnode.relNode);
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgrnblocks() -- Calculate the number of POSTGRES blocks in the
|
|
|
|
* supplied relation.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Returns the number of blocks on success, aborts the current
|
|
|
|
* transaction on failure.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgrnblocks(int16 which, Relation reln)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int nblocks;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
if ((nblocks = (*(smgrsw[which].smgr_nblocks)) (reln)) < 0)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(ERROR, "cannot count blocks for %s: %m",
|
2000-04-12 19:17:23 +02:00
|
|
|
RelationGetRelationName(reln));
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return nblocks;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1996-11-27 08:25:52 +01:00
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgrtruncate() -- Truncate supplied relation to a specified number
|
|
|
|
* of blocks
|
1996-11-27 08:25:52 +01:00
|
|
|
*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Returns the number of blocks on success, aborts the current
|
|
|
|
* transaction on failure.
|
1996-11-27 08:25:52 +01:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgrtruncate(int16 which, Relation reln, int nblocks)
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int newblks;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
newblks = nblocks;
|
|
|
|
if (smgrsw[which].smgr_truncate)
|
|
|
|
{
|
|
|
|
if ((newblks = (*(smgrsw[which].smgr_truncate)) (reln, nblocks)) < 0)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(ERROR, "cannot truncate %s to %d blocks: %m",
|
1999-11-08 00:08:36 +01:00
|
|
|
RelationGetRelationName(reln), nblocks);
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return newblks;
|
1996-11-27 08:25:52 +01:00
|
|
|
}
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* smgrcommit(), smgrabort() -- Commit or abort changes made during the
|
|
|
|
* current transaction.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
smgrcommit()
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int i;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
for (i = 0; i < NSmgr; i++)
|
|
|
|
{
|
|
|
|
if (smgrsw[i].smgr_commit)
|
|
|
|
{
|
|
|
|
if ((*(smgrsw[i].smgr_commit)) () == SM_FAIL)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(FATAL, "transaction commit failed on %s: %m",
|
2000-06-05 09:29:25 +02:00
|
|
|
DatumGetCString(DirectFunctionCall1(smgrout,
|
|
|
|
Int16GetDatum(i))));
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return SM_SUCCESS;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
smgrabort()
|
|
|
|
{
|
1997-09-08 04:41:22 +02:00
|
|
|
int i;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
for (i = 0; i < NSmgr; i++)
|
|
|
|
{
|
|
|
|
if (smgrsw[i].smgr_abort)
|
|
|
|
{
|
|
|
|
if ((*(smgrsw[i].smgr_abort)) () == SM_FAIL)
|
2000-06-20 01:37:08 +02:00
|
|
|
elog(FATAL, "transaction abort failed on %s: %m",
|
2000-06-05 09:29:25 +02:00
|
|
|
DatumGetCString(DirectFunctionCall1(smgrout,
|
|
|
|
Int16GetDatum(i))));
|
1997-09-07 07:04:48 +02:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return SM_SUCCESS;
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2000-10-28 18:21:00 +02:00
|
|
|
#ifdef XLOG
|
|
|
|
int
|
|
|
|
smgrsync()
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < NSmgr; i++)
|
|
|
|
{
|
|
|
|
if (smgrsw[i].smgr_sync)
|
|
|
|
{
|
|
|
|
if ((*(smgrsw[i].smgr_sync)) () == SM_FAIL)
|
|
|
|
elog(STOP, "storage sync failed on %s: %m",
|
|
|
|
DatumGetCString(DirectFunctionCall1(smgrout,
|
|
|
|
Int16GetDatum(i))));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return SM_SUCCESS;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1998-10-08 20:30:52 +02:00
|
|
|
#ifdef NOT_USED
|
1996-07-09 08:22:35 +02:00
|
|
|
bool
|
|
|
|
smgriswo(int16 smgrno)
|
|
|
|
{
|
1997-09-07 07:04:48 +02:00
|
|
|
if (smgrno < 0 || smgrno >= NSmgr)
|
1998-01-07 22:07:04 +01:00
|
|
|
elog(ERROR, "illegal storage manager number %d", smgrno);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-09-01 05:29:17 +02:00
|
|
|
return smgrwo[smgrno];
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
1999-05-25 18:15:34 +02:00
|
|
|
|
1998-10-08 20:30:52 +02:00
|
|
|
#endif
|
2000-10-21 17:43:36 +02:00
|
|
|
|
|
|
|
#ifdef XLOG
|
|
|
|
#include "access/xlog.h"
|
|
|
|
|
|
|
|
void smgr_redo(XLogRecPtr lsn, XLogRecord *record);
|
|
|
|
void smgr_undo(XLogRecPtr lsn, XLogRecord *record);
|
|
|
|
void smgr_desc(char *buf, uint8 xl_info, char* rec);
|
|
|
|
|
|
|
|
void
|
|
|
|
smgr_redo(XLogRecPtr lsn, XLogRecord *record)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
smgr_undo(XLogRecPtr lsn, XLogRecord *record)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
smgr_desc(char *buf, uint8 xl_info, char* rec)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|