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
|
|
|
*
|
2012-01-02 00:01:58 +01:00
|
|
|
* Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2010-09-20 22:08:53 +02:00
|
|
|
* src/backend/storage/smgr/smgr.c
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
|
2004-07-11 21:52:52 +02:00
|
|
|
#include "commands/tablespace.h"
|
2000-11-08 23:10:03 +01:00
|
|
|
#include "storage/bufmgr.h"
|
2001-09-29 06:02:27 +02:00
|
|
|
#include "storage/ipc.h"
|
1996-11-03 06:08:01 +01:00
|
|
|
#include "storage/smgr.h"
|
2011-09-04 07:13:16 +02:00
|
|
|
#include "utils/hsearch.h"
|
2010-02-03 02:14:17 +01:00
|
|
|
#include "utils/inval.h"
|
2000-11-08 23:10:03 +01:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2004-02-10 02:55:27 +01:00
|
|
|
/*
|
|
|
|
* This struct of function pointers defines the API between smgr.c and
|
|
|
|
* any individual storage manager module. Note that smgr subfunctions are
|
2007-01-03 19:11:01 +01:00
|
|
|
* generally expected to report problems via elog(ERROR). An exception is
|
|
|
|
* that smgr_unlink should use elog(WARNING), rather than erroring out,
|
|
|
|
* because we normally unlink relations during post-commit/abort cleanup,
|
|
|
|
* and so it's too late to raise an error. Also, various conditions that
|
|
|
|
* would normally be errors should be allowed during bootstrap and/or WAL
|
|
|
|
* recovery --- see comments in md.c for details.
|
2004-02-10 02:55:27 +01:00
|
|
|
*/
|
1997-09-07 07:04:48 +02:00
|
|
|
typedef struct f_smgr
|
|
|
|
{
|
2007-01-03 19:11:01 +01:00
|
|
|
void (*smgr_init) (void); /* may be NULL */
|
|
|
|
void (*smgr_shutdown) (void); /* may be NULL */
|
2008-08-11 13:05:11 +02:00
|
|
|
void (*smgr_close) (SMgrRelation reln, ForkNumber forknum);
|
|
|
|
void (*smgr_create) (SMgrRelation reln, ForkNumber forknum,
|
2009-06-11 16:49:15 +02:00
|
|
|
bool isRedo);
|
2008-08-11 13:05:11 +02:00
|
|
|
bool (*smgr_exists) (SMgrRelation reln, ForkNumber forknum);
|
2010-08-13 22:10:54 +02:00
|
|
|
void (*smgr_unlink) (RelFileNodeBackend rnode, ForkNumber forknum,
|
2009-06-11 16:49:15 +02:00
|
|
|
bool isRedo);
|
2008-08-11 13:05:11 +02:00
|
|
|
void (*smgr_extend) (SMgrRelation reln, ForkNumber forknum,
|
2011-04-10 17:42:00 +02:00
|
|
|
BlockNumber blocknum, char *buffer, bool skipFsync);
|
2009-01-12 06:10:45 +01:00
|
|
|
void (*smgr_prefetch) (SMgrRelation reln, ForkNumber forknum,
|
2009-06-11 16:49:15 +02:00
|
|
|
BlockNumber blocknum);
|
2008-08-11 13:05:11 +02:00
|
|
|
void (*smgr_read) (SMgrRelation reln, ForkNumber forknum,
|
2009-06-11 16:49:15 +02:00
|
|
|
BlockNumber blocknum, char *buffer);
|
|
|
|
void (*smgr_write) (SMgrRelation reln, ForkNumber forknum,
|
2011-04-10 17:42:00 +02:00
|
|
|
BlockNumber blocknum, char *buffer, bool skipFsync);
|
2008-08-11 13:05:11 +02:00
|
|
|
BlockNumber (*smgr_nblocks) (SMgrRelation reln, ForkNumber forknum);
|
|
|
|
void (*smgr_truncate) (SMgrRelation reln, ForkNumber forknum,
|
2011-04-10 17:42:00 +02:00
|
|
|
BlockNumber nblocks);
|
2008-08-11 13:05:11 +02:00
|
|
|
void (*smgr_immedsync) (SMgrRelation reln, ForkNumber forknum);
|
2007-11-15 22:14:46 +01:00
|
|
|
void (*smgr_pre_ckpt) (void); /* may be NULL */
|
|
|
|
void (*smgr_sync) (void); /* may be NULL */
|
|
|
|
void (*smgr_post_ckpt) (void); /* may be NULL */
|
1997-09-08 23:56:23 +02:00
|
|
|
} f_smgr;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
|
2004-02-10 02:55:27 +01:00
|
|
|
static const f_smgr smgrsw[] = {
|
1997-09-07 07:04:48 +02:00
|
|
|
/* magnetic disk */
|
2008-08-11 13:05:11 +02:00
|
|
|
{mdinit, NULL, mdclose, mdcreate, mdexists, mdunlink, mdextend,
|
2009-01-12 06:10:45 +01:00
|
|
|
mdprefetch, mdread, mdwrite, mdnblocks, mdtruncate, mdimmedsync,
|
2008-11-19 11:34:52 +01:00
|
|
|
mdpreckpt, mdsync, mdpostckpt
|
2004-02-10 02:55:27 +01:00
|
|
|
}
|
1996-07-09 08:22:35 +02:00
|
|
|
};
|
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
static const int NSmgr = lengthof(smgrsw);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1998-10-08 20:30:52 +02:00
|
|
|
|
2004-02-10 02:55:27 +01:00
|
|
|
/*
|
|
|
|
* Each backend has a hashtable that stores all extant SMgrRelation objects.
|
|
|
|
*/
|
|
|
|
static HTAB *SMgrRelationHash = NULL;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2004-02-10 02:55:27 +01:00
|
|
|
/* local function prototypes */
|
|
|
|
static void smgrshutdown(int code, Datum arg);
|
|
|
|
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
2005-08-08 05:12:16 +02:00
|
|
|
* smgrinit(), smgrshutdown() -- Initialize or shut down storage
|
1997-09-07 07:04:48 +02:00
|
|
|
* managers.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2005-08-08 05:12:16 +02:00
|
|
|
* Note: smgrinit is called during backend startup (normal or standalone
|
|
|
|
* case), *not* during postmaster start. Therefore, any resources created
|
|
|
|
* here or destroyed in smgrshutdown are backend-local.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2004-02-10 02:55:27 +01:00
|
|
|
void
|
2002-08-06 04:36:35 +02:00
|
|
|
smgrinit(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_init)
|
2007-01-03 19:11:01 +01:00
|
|
|
(*(smgrsw[i].smgr_init)) ();
|
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
|
|
|
}
|
|
|
|
|
2005-08-08 05:12:16 +02:00
|
|
|
/*
|
|
|
|
* on_proc_exit hook for smgr cleanup during backend shutdown
|
|
|
|
*/
|
1997-08-19 23:40:56 +02:00
|
|
|
static void
|
2003-12-12 19:45:10 +01:00
|
|
|
smgrshutdown(int code, Datum arg)
|
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)
|
2007-01-03 19:11:01 +01:00
|
|
|
(*(smgrsw[i].smgr_shutdown)) ();
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-02-10 02:55:27 +01:00
|
|
|
/*
|
|
|
|
* smgropen() -- Return an SMgrRelation object, creating it if need be.
|
|
|
|
*
|
|
|
|
* This does not attempt to actually open the object.
|
|
|
|
*/
|
|
|
|
SMgrRelation
|
2010-08-13 22:10:54 +02:00
|
|
|
smgropen(RelFileNode rnode, BackendId backend)
|
2004-02-10 02:55:27 +01:00
|
|
|
{
|
2010-08-13 22:10:54 +02:00
|
|
|
RelFileNodeBackend brnode;
|
2004-08-29 07:07:03 +02:00
|
|
|
SMgrRelation reln;
|
2004-02-10 02:55:27 +01:00
|
|
|
bool found;
|
|
|
|
|
|
|
|
if (SMgrRelationHash == NULL)
|
|
|
|
{
|
|
|
|
/* First time through: initialize the hash table */
|
|
|
|
HASHCTL ctl;
|
|
|
|
|
|
|
|
MemSet(&ctl, 0, sizeof(ctl));
|
2010-08-13 22:10:54 +02:00
|
|
|
ctl.keysize = sizeof(RelFileNodeBackend);
|
2004-02-10 02:55:27 +01:00
|
|
|
ctl.entrysize = sizeof(SMgrRelationData);
|
|
|
|
ctl.hash = tag_hash;
|
|
|
|
SMgrRelationHash = hash_create("smgr relation table", 400,
|
|
|
|
&ctl, HASH_ELEM | HASH_FUNCTION);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Look up or create an entry */
|
2010-08-13 22:10:54 +02:00
|
|
|
brnode.node = rnode;
|
|
|
|
brnode.backend = backend;
|
2004-02-10 02:55:27 +01:00
|
|
|
reln = (SMgrRelation) hash_search(SMgrRelationHash,
|
2010-08-13 22:10:54 +02:00
|
|
|
(void *) &brnode,
|
2004-02-10 02:55:27 +01:00
|
|
|
HASH_ENTER, &found);
|
|
|
|
|
|
|
|
/* Initialize it if not present before */
|
|
|
|
if (!found)
|
|
|
|
{
|
2009-06-11 16:49:15 +02:00
|
|
|
int forknum;
|
2008-08-11 13:05:11 +02:00
|
|
|
|
2004-02-10 02:55:27 +01:00
|
|
|
/* hash_search already filled in the lookup key */
|
2005-01-10 21:02:24 +01:00
|
|
|
reln->smgr_owner = NULL;
|
2010-02-09 22:43:30 +01:00
|
|
|
reln->smgr_targblock = InvalidBlockNumber;
|
|
|
|
reln->smgr_fsm_nblocks = InvalidBlockNumber;
|
|
|
|
reln->smgr_vm_nblocks = InvalidBlockNumber;
|
2011-06-10 19:43:02 +02:00
|
|
|
reln->smgr_transient = false;
|
2004-02-10 02:55:27 +01:00
|
|
|
reln->smgr_which = 0; /* we only have md.c at present */
|
2008-08-11 13:05:11 +02:00
|
|
|
|
|
|
|
/* mark it not open */
|
2009-06-11 16:49:15 +02:00
|
|
|
for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
|
2008-08-11 13:05:11 +02:00
|
|
|
reln->md_fd[forknum] = NULL;
|
2004-02-10 02:55:27 +01:00
|
|
|
}
|
2011-06-10 19:43:02 +02:00
|
|
|
else
|
|
|
|
/* if it was transient before, it no longer is */
|
|
|
|
reln->smgr_transient = false;
|
2004-02-10 02:55:27 +01:00
|
|
|
|
|
|
|
return reln;
|
|
|
|
}
|
|
|
|
|
2011-06-10 19:43:02 +02:00
|
|
|
/*
|
|
|
|
* smgrsettransient() -- mark an SMgrRelation object as transaction-bound
|
|
|
|
*
|
|
|
|
* The main effect of this is that all opened files are marked to be
|
|
|
|
* kernel-level closed (but not necessarily VFD-closed) when the current
|
|
|
|
* transaction ends.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
smgrsettransient(SMgrRelation reln)
|
|
|
|
{
|
|
|
|
reln->smgr_transient = true;
|
|
|
|
}
|
|
|
|
|
2004-02-10 02:55:27 +01:00
|
|
|
/*
|
2005-01-10 21:02:24 +01:00
|
|
|
* smgrsetowner() -- Establish a long-lived reference to an SMgrRelation object
|
2004-02-10 02:55:27 +01:00
|
|
|
*
|
2005-01-10 21:02:24 +01:00
|
|
|
* There can be only one owner at a time; this is sufficient since currently
|
|
|
|
* the only such owners exist in the relcache.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
smgrsetowner(SMgrRelation *owner, SMgrRelation reln)
|
|
|
|
{
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* First, unhook any old owner. (Normally there shouldn't be any, but it
|
|
|
|
* seems possible that this can happen during swap_relation_files()
|
2005-01-10 21:02:24 +01:00
|
|
|
* depending on the order of processing. It's ok to close the old
|
|
|
|
* relcache entry early in that case.)
|
|
|
|
*/
|
|
|
|
if (reln->smgr_owner)
|
|
|
|
*(reln->smgr_owner) = NULL;
|
|
|
|
|
|
|
|
/* Now establish the ownership relationship. */
|
|
|
|
reln->smgr_owner = owner;
|
|
|
|
*owner = reln;
|
|
|
|
}
|
|
|
|
|
2008-08-11 13:05:11 +02:00
|
|
|
/*
|
|
|
|
* smgrexists() -- Does the underlying file for a fork exist?
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
smgrexists(SMgrRelation reln, ForkNumber forknum)
|
|
|
|
{
|
|
|
|
return (*(smgrsw[reln->smgr_which].smgr_exists)) (reln, forknum);
|
|
|
|
}
|
|
|
|
|
2005-01-10 21:02:24 +01:00
|
|
|
/*
|
|
|
|
* smgrclose() -- Close and delete an SMgrRelation object.
|
2004-02-10 02:55:27 +01:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
smgrclose(SMgrRelation reln)
|
|
|
|
{
|
2005-01-10 21:02:24 +01:00
|
|
|
SMgrRelation *owner;
|
2009-06-11 16:49:15 +02:00
|
|
|
ForkNumber forknum;
|
2005-01-10 21:02:24 +01:00
|
|
|
|
2008-08-11 13:05:11 +02:00
|
|
|
for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
|
|
|
|
(*(smgrsw[reln->smgr_which].smgr_close)) (reln, forknum);
|
2004-02-10 02:55:27 +01:00
|
|
|
|
2005-01-10 21:02:24 +01:00
|
|
|
owner = reln->smgr_owner;
|
|
|
|
|
2004-02-10 02:55:27 +01:00
|
|
|
if (hash_search(SMgrRelationHash,
|
|
|
|
(void *) &(reln->smgr_rnode),
|
|
|
|
HASH_REMOVE, NULL) == NULL)
|
|
|
|
elog(ERROR, "SMgrRelation hashtable corrupted");
|
2005-01-10 21:02:24 +01:00
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Unhook the owner pointer, if any. We do this last since in the remote
|
|
|
|
* possibility of failure above, the SMgrRelation object will still exist.
|
2005-01-10 21:02:24 +01:00
|
|
|
*/
|
|
|
|
if (owner)
|
|
|
|
*owner = NULL;
|
2004-02-10 02:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* smgrcloseall() -- Close all existing SMgrRelation objects.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
smgrcloseall(void)
|
|
|
|
{
|
|
|
|
HASH_SEQ_STATUS status;
|
|
|
|
SMgrRelation reln;
|
|
|
|
|
|
|
|
/* Nothing to do if hashtable not set up */
|
|
|
|
if (SMgrRelationHash == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
hash_seq_init(&status, SMgrRelationHash);
|
|
|
|
|
|
|
|
while ((reln = (SMgrRelation) hash_seq_search(&status)) != NULL)
|
|
|
|
smgrclose(reln);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* smgrclosenode() -- Close SMgrRelation object for given RelFileNode,
|
|
|
|
* if one exists.
|
|
|
|
*
|
|
|
|
* This has the same effects as smgrclose(smgropen(rnode)), but it avoids
|
|
|
|
* uselessly creating a hashtable entry only to drop it again when no
|
|
|
|
* such entry exists already.
|
|
|
|
*/
|
|
|
|
void
|
2010-08-13 22:10:54 +02:00
|
|
|
smgrclosenode(RelFileNodeBackend rnode)
|
2004-02-10 02:55:27 +01:00
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
SMgrRelation reln;
|
2004-02-10 02:55:27 +01:00
|
|
|
|
|
|
|
/* Nothing to do if hashtable not set up */
|
|
|
|
if (SMgrRelationHash == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
reln = (SMgrRelation) hash_search(SMgrRelationHash,
|
|
|
|
(void *) &rnode,
|
|
|
|
HASH_FIND, NULL);
|
|
|
|
if (reln != NULL)
|
|
|
|
smgrclose(reln);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
*
|
2004-02-10 02:55:27 +01:00
|
|
|
* Given an already-created (but presumably unused) SMgrRelation,
|
2008-08-11 13:05:11 +02:00
|
|
|
* cause the underlying disk file or other storage for the fork
|
|
|
|
* to be created.
|
2004-02-10 02:55:27 +01:00
|
|
|
*
|
|
|
|
* If isRedo is true, it is okay for the underlying file to exist
|
2008-11-19 11:34:52 +01:00
|
|
|
* already because we are in a WAL replay sequence.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2004-02-10 02:55:27 +01:00
|
|
|
void
|
2008-11-19 11:34:52 +01:00
|
|
|
smgrcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2008-06-12 11:12:31 +02:00
|
|
|
/*
|
2009-06-11 16:49:15 +02:00
|
|
|
* Exit quickly in WAL replay mode if we've already opened the file. If
|
|
|
|
* it's open, it surely must exist.
|
|
|
|
*/
|
2008-08-11 13:05:11 +02:00
|
|
|
if (isRedo && reln->md_fd[forknum] != NULL)
|
2008-06-12 11:12:31 +02:00
|
|
|
return;
|
|
|
|
|
2004-07-11 21:52:52 +02:00
|
|
|
/*
|
|
|
|
* We may be using the target table space for the first time in this
|
|
|
|
* database, so create a per-database subdirectory if needed.
|
|
|
|
*
|
2005-11-22 19:17:34 +01:00
|
|
|
* XXX this is a fairly ugly violation of module layering, but this seems
|
|
|
|
* to be the best place to put the check. Maybe TablespaceCreateDbspace
|
2005-10-15 04:49:52 +02:00
|
|
|
* should be here and not in commands/tablespace.c? But that would imply
|
|
|
|
* importing a lot of stuff that smgr.c oughtn't know, either.
|
2004-07-11 21:52:52 +02:00
|
|
|
*/
|
2010-08-13 22:10:54 +02:00
|
|
|
TablespaceCreateDbspace(reln->smgr_rnode.node.spcNode,
|
|
|
|
reln->smgr_rnode.node.dbNode,
|
2004-07-11 21:52:52 +02:00
|
|
|
isRedo);
|
|
|
|
|
2008-08-11 13:05:11 +02:00
|
|
|
(*(smgrsw[reln->smgr_which].smgr_create)) (reln, forknum, isRedo);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-06-07 23:42:27 +02:00
|
|
|
* smgrdounlink() -- Immediately unlink all forks of a relation.
|
|
|
|
*
|
|
|
|
* All forks of the relation are removed from the store. This should
|
|
|
|
* not be used during transactional operations, since it can't be undone.
|
|
|
|
*
|
|
|
|
* If isRedo is true, it is okay for the underlying file(s) to be gone
|
|
|
|
* already.
|
|
|
|
*
|
|
|
|
* This is equivalent to calling smgrdounlinkfork for each fork, but
|
|
|
|
* it's significantly quicker so should be preferred when possible.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
smgrdounlink(SMgrRelation reln, bool isRedo)
|
|
|
|
{
|
|
|
|
RelFileNodeBackend rnode = reln->smgr_rnode;
|
|
|
|
int which = reln->smgr_which;
|
|
|
|
ForkNumber forknum;
|
|
|
|
|
|
|
|
/* Close the forks at smgr level */
|
|
|
|
for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
|
|
|
|
(*(smgrsw[which].smgr_close)) (reln, forknum);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get rid of any remaining buffers for the relation. bufmgr will just
|
|
|
|
* drop them without bothering to write the contents.
|
|
|
|
*/
|
|
|
|
DropRelFileNodeAllBuffers(rnode);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It'd be nice to tell the stats collector to forget it immediately, too.
|
|
|
|
* But we can't because we don't know the OID (and in cases involving
|
|
|
|
* relfilenode swaps, it's not always clear which table OID to forget,
|
|
|
|
* anyway).
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Send a shared-inval message to force other backends to close any
|
|
|
|
* dangling smgr references they may have for this rel. We should do this
|
|
|
|
* before starting the actual unlinking, in case we fail partway through
|
|
|
|
* that step. Note that the sinval message will eventually come back to
|
|
|
|
* this backend, too, and thereby provide a backstop that we closed our
|
|
|
|
* own smgr rel.
|
|
|
|
*/
|
|
|
|
CacheInvalidateSmgr(rnode);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Delete the physical file(s).
|
|
|
|
*
|
|
|
|
* Note: smgr_unlink must treat deletion failure as a WARNING, not an
|
|
|
|
* ERROR, because we've already decided to commit or abort the current
|
|
|
|
* xact.
|
|
|
|
*/
|
|
|
|
for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
|
|
|
|
(*(smgrsw[which].smgr_unlink)) (rnode, forknum, isRedo);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* smgrdounlinkfork() -- Immediately unlink one fork of a relation.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2008-08-11 13:05:11 +02:00
|
|
|
* The specified fork of the relation is removed from the store. This
|
|
|
|
* should not be used during transactional operations, since it can't be
|
|
|
|
* undone.
|
2001-05-10 22:38:49 +02:00
|
|
|
*
|
2004-02-10 02:55:27 +01:00
|
|
|
* If isRedo is true, it is okay for the underlying file to be gone
|
2005-06-18 00:32:51 +02:00
|
|
|
* already.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2004-02-10 02:55:27 +01:00
|
|
|
void
|
2012-06-07 23:42:27 +02:00
|
|
|
smgrdounlinkfork(SMgrRelation reln, ForkNumber forknum, bool isRedo)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2010-08-13 22:10:54 +02:00
|
|
|
RelFileNodeBackend rnode = reln->smgr_rnode;
|
2004-02-10 02:55:27 +01:00
|
|
|
int which = reln->smgr_which;
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2012-06-07 23:42:27 +02:00
|
|
|
/* Close the fork at smgr level */
|
2008-08-11 13:05:11 +02:00
|
|
|
(*(smgrsw[which].smgr_close)) (reln, forknum);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2004-02-10 02:55:27 +01:00
|
|
|
/*
|
2012-06-07 23:42:27 +02:00
|
|
|
* Get rid of any remaining buffers for the fork. bufmgr will just
|
2005-03-20 23:00:54 +01:00
|
|
|
* drop them without bothering to write the contents.
|
2004-02-10 02:55:27 +01:00
|
|
|
*/
|
2010-08-13 22:10:54 +02:00
|
|
|
DropRelFileNodeBuffers(rnode, forknum, 0);
|
2004-02-10 02:55:27 +01:00
|
|
|
|
2006-03-31 00:11:55 +02:00
|
|
|
/*
|
2007-07-09 00:23:16 +02:00
|
|
|
* It'd be nice to tell the stats collector to forget it immediately, too.
|
|
|
|
* But we can't because we don't know the OID (and in cases involving
|
|
|
|
* relfilenode swaps, it's not always clear which table OID to forget,
|
|
|
|
* anyway).
|
2006-03-31 00:11:55 +02:00
|
|
|
*/
|
2006-01-18 21:35:06 +01:00
|
|
|
|
2010-02-09 22:43:30 +01:00
|
|
|
/*
|
|
|
|
* Send a shared-inval message to force other backends to close any
|
2010-02-26 03:01:40 +01:00
|
|
|
* dangling smgr references they may have for this rel. We should do this
|
|
|
|
* before starting the actual unlinking, in case we fail partway through
|
|
|
|
* that step. Note that the sinval message will eventually come back to
|
|
|
|
* this backend, too, and thereby provide a backstop that we closed our
|
|
|
|
* own smgr rel.
|
2010-02-09 22:43:30 +01:00
|
|
|
*/
|
|
|
|
CacheInvalidateSmgr(rnode);
|
|
|
|
|
2004-02-10 02:55:27 +01:00
|
|
|
/*
|
2010-02-03 02:14:17 +01:00
|
|
|
* Delete the physical file(s).
|
2004-02-10 02:55:27 +01:00
|
|
|
*
|
2007-01-03 19:11:01 +01:00
|
|
|
* Note: smgr_unlink must treat deletion failure as a WARNING, not an
|
|
|
|
* ERROR, because we've already decided to commit or abort the current
|
|
|
|
* xact.
|
2004-02-10 02:55:27 +01:00
|
|
|
*/
|
2008-08-11 13:05:11 +02:00
|
|
|
(*(smgrsw[which].smgr_unlink)) (rnode, forknum, isRedo);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2004-02-10 02:55:27 +01:00
|
|
|
* smgrextend() -- Add a new block to a file.
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2007-01-03 19:11:01 +01:00
|
|
|
* The semantics are nearly the same as smgrwrite(): write at the
|
|
|
|
* specified position. However, this is to be used for the case of
|
|
|
|
* extending a relation (i.e., blocknum is at or beyond the current
|
|
|
|
* EOF). Note that we assume writing a block beyond current EOF
|
|
|
|
* causes intervening file space to become filled with zeroes.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2004-02-10 02:55:27 +01:00
|
|
|
void
|
2009-06-11 16:49:15 +02:00
|
|
|
smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
|
2010-08-13 22:10:54 +02:00
|
|
|
char *buffer, bool skipFsync)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2008-08-11 13:05:11 +02:00
|
|
|
(*(smgrsw[reln->smgr_which].smgr_extend)) (reln, forknum, blocknum,
|
2010-08-13 22:10:54 +02:00
|
|
|
buffer, skipFsync);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
2009-01-12 06:10:45 +01:00
|
|
|
/*
|
|
|
|
* smgrprefetch() -- Initiate asynchronous read of the specified block of a relation.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
smgrprefetch(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum)
|
|
|
|
{
|
|
|
|
(*(smgrsw[reln->smgr_which].smgr_prefetch)) (reln, forknum, blocknum);
|
|
|
|
}
|
|
|
|
|
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
|
2004-02-10 02:55:27 +01:00
|
|
|
* return pages in the format that POSTGRES expects.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2004-02-10 02:55:27 +01:00
|
|
|
void
|
2009-06-11 16:49:15 +02:00
|
|
|
smgrread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
|
2008-08-11 13:05:11 +02:00
|
|
|
char *buffer)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2008-08-11 13:05:11 +02:00
|
|
|
(*(smgrsw[reln->smgr_which].smgr_read)) (reln, forknum, blocknum, buffer);
|
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
|
|
|
*
|
2007-01-03 19:11:01 +01:00
|
|
|
* This is to be used only for updating already-existing blocks of a
|
|
|
|
* relation (ie, those before the current EOF). To extend a relation,
|
|
|
|
* use smgrextend().
|
|
|
|
*
|
2002-08-06 04:36:35 +02:00
|
|
|
* This is not a synchronous write -- the block is not necessarily
|
2004-05-31 22:31:33 +02:00
|
|
|
* on disk at return, only dumped out to the kernel. However,
|
|
|
|
* provisions will be made to fsync the write before the next checkpoint.
|
|
|
|
*
|
2010-08-13 22:10:54 +02:00
|
|
|
* skipFsync indicates that the caller will make other provisions to
|
|
|
|
* fsync the relation, so we needn't bother. Temporary relations also
|
|
|
|
* do not require fsync.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2004-02-10 02:55:27 +01:00
|
|
|
void
|
2009-06-11 16:49:15 +02:00
|
|
|
smgrwrite(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
|
2010-08-13 22:10:54 +02:00
|
|
|
char *buffer, bool skipFsync)
|
2000-10-16 16:52:28 +02:00
|
|
|
{
|
2008-08-11 13:05:11 +02:00
|
|
|
(*(smgrsw[reln->smgr_which].smgr_write)) (reln, forknum, blocknum,
|
2010-08-13 22:10:54 +02:00
|
|
|
buffer, skipFsync);
|
2000-10-16 16:52:28 +02:00
|
|
|
}
|
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
/*
|
2004-01-06 19:07:32 +01:00
|
|
|
* smgrnblocks() -- Calculate the number of blocks in the
|
1997-09-07 07:04:48 +02:00
|
|
|
* supplied relation.
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2001-06-28 01:31:40 +02:00
|
|
|
BlockNumber
|
2008-08-11 13:05:11 +02:00
|
|
|
smgrnblocks(SMgrRelation reln, ForkNumber forknum)
|
1996-07-09 08:22:35 +02:00
|
|
|
{
|
2008-08-11 13:05:11 +02:00
|
|
|
return (*(smgrsw[reln->smgr_which].smgr_nblocks)) (reln, forknum);
|
1996-07-09 08:22:35 +02:00
|
|
|
}
|
|
|
|
|
1996-11-27 08:25:52 +01:00
|
|
|
/*
|
2004-01-06 19:07:32 +01:00
|
|
|
* smgrtruncate() -- Truncate supplied relation to the specified number
|
|
|
|
* of blocks
|
2010-02-03 02:14:17 +01:00
|
|
|
*
|
|
|
|
* The truncation is done immediately, so this can't be rolled back.
|
1996-11-27 08:25:52 +01:00
|
|
|
*/
|
2007-01-03 19:11:01 +01:00
|
|
|
void
|
2010-08-13 22:10:54 +02:00
|
|
|
smgrtruncate(SMgrRelation reln, ForkNumber forknum, BlockNumber nblocks)
|
1996-11-27 08:25:52 +01:00
|
|
|
{
|
2005-03-20 23:00:54 +01:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
|
|
|
|
* just drop them without bothering to write the contents.
|
2005-03-20 23:00:54 +01:00
|
|
|
*/
|
2010-08-13 22:10:54 +02:00
|
|
|
DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nblocks);
|
2005-03-20 23:00:54 +01:00
|
|
|
|
2010-02-03 02:14:17 +01:00
|
|
|
/*
|
|
|
|
* Send a shared-inval message to force other backends to close any smgr
|
|
|
|
* references they may have for this rel. This is useful because they
|
2010-02-09 22:43:30 +01:00
|
|
|
* might have open file pointers to segments that got removed, and/or
|
2010-02-26 03:01:40 +01:00
|
|
|
* smgr_targblock variables pointing past the new rel end. (The inval
|
2010-02-03 02:14:17 +01:00
|
|
|
* message will come back to our backend, too, causing a
|
2010-02-09 22:43:30 +01:00
|
|
|
* probably-unnecessary local smgr flush. But we don't expect that this
|
2010-02-26 03:01:40 +01:00
|
|
|
* is a performance-critical path.) As in the unlink code, we want to be
|
|
|
|
* sure the message is sent before we start changing things on-disk.
|
2010-02-03 02:14:17 +01:00
|
|
|
*/
|
|
|
|
CacheInvalidateSmgr(reln->smgr_rnode);
|
2010-02-09 22:43:30 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Do the truncation.
|
|
|
|
*/
|
2010-08-13 22:10:54 +02:00
|
|
|
(*(smgrsw[reln->smgr_which].smgr_truncate)) (reln, forknum, nblocks);
|
1996-11-27 08:25:52 +01:00
|
|
|
}
|
|
|
|
|
2004-06-02 19:28:18 +02:00
|
|
|
/*
|
|
|
|
* smgrimmedsync() -- Force the specified relation to stable storage.
|
|
|
|
*
|
2005-06-20 20:37:02 +02:00
|
|
|
* Synchronously force all previous writes to the specified relation
|
|
|
|
* down to disk.
|
2004-06-02 19:28:18 +02:00
|
|
|
*
|
2004-08-16 01:44:46 +02:00
|
|
|
* This is useful for building completely new relations (eg, new
|
|
|
|
* indexes). Instead of incrementally WAL-logging the index build
|
|
|
|
* steps, we can just write completed index pages to disk with smgrwrite
|
2004-06-02 19:28:18 +02:00
|
|
|
* or smgrextend, and then fsync the completed index file before
|
|
|
|
* committing the transaction. (This is sufficient for purposes of
|
|
|
|
* crash recovery, since it effectively duplicates forcing a checkpoint
|
2004-08-16 01:44:46 +02:00
|
|
|
* for the completed index. But it is *not* sufficient if one wishes
|
|
|
|
* to use the WAL log for PITR or replication purposes: in that case
|
|
|
|
* we have to make WAL entries as well.)
|
2004-06-02 19:28:18 +02:00
|
|
|
*
|
2010-08-13 22:10:54 +02:00
|
|
|
* The preceding writes should specify skipFsync = true to avoid
|
2004-06-02 19:28:18 +02:00
|
|
|
* duplicative fsyncs.
|
2005-06-20 20:37:02 +02:00
|
|
|
*
|
|
|
|
* Note that you need to do FlushRelationBuffers() first if there is
|
|
|
|
* any possibility that there are dirty buffers for the relation;
|
|
|
|
* otherwise the sync is not very meaningful.
|
2004-06-02 19:28:18 +02:00
|
|
|
*/
|
|
|
|
void
|
2008-08-11 13:05:11 +02:00
|
|
|
smgrimmedsync(SMgrRelation reln, ForkNumber forknum)
|
2004-06-02 19:28:18 +02:00
|
|
|
{
|
2008-08-11 13:05:11 +02:00
|
|
|
(*(smgrsw[reln->smgr_which].smgr_immedsync)) (reln, forknum);
|
2004-06-02 19:28:18 +02:00
|
|
|
}
|
|
|
|
|
2005-06-18 00:32:51 +02:00
|
|
|
|
2002-08-06 04:36:35 +02:00
|
|
|
/*
|
2007-11-15 21:36:40 +01:00
|
|
|
* smgrpreckpt() -- Prepare for checkpoint.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
smgrpreckpt(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < NSmgr; i++)
|
|
|
|
{
|
|
|
|
if (smgrsw[i].smgr_pre_ckpt)
|
|
|
|
(*(smgrsw[i].smgr_pre_ckpt)) ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* smgrsync() -- Sync files to disk during checkpoint.
|
2002-08-06 04:36:35 +02:00
|
|
|
*/
|
2004-02-10 02:55:27 +01:00
|
|
|
void
|
2002-08-06 04:36:35 +02:00
|
|
|
smgrsync(void)
|
2000-10-28 18:21:00 +02:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < NSmgr; i++)
|
|
|
|
{
|
|
|
|
if (smgrsw[i].smgr_sync)
|
2007-01-03 19:11:01 +01:00
|
|
|
(*(smgrsw[i].smgr_sync)) ();
|
2000-10-28 18:21:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-11-15 21:36:40 +01:00
|
|
|
/*
|
|
|
|
* smgrpostckpt() -- Post-checkpoint cleanup.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
smgrpostckpt(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < NSmgr; i++)
|
|
|
|
{
|
|
|
|
if (smgrsw[i].smgr_post_ckpt)
|
|
|
|
(*(smgrsw[i].smgr_post_ckpt)) ();
|
|
|
|
}
|
|
|
|
}
|