if (hentry == NULL)
elog(PANIC, "_xl_remove_hash_entry: file was not found in cache");
- if (rdesc->reldata.rd_smgr != NULL)
- smgrclose(rdesc->reldata.rd_smgr);
+ RelationCloseSmgr(&(rdesc->reldata));
memset(rdesc, 0, sizeof(XLogRelDesc));
memset(tpgc, 0, sizeof(FormData_pg_class));
hentry->rdesc = res;
res->reldata.rd_targblock = InvalidBlockNumber;
- res->reldata.rd_smgr = smgropen(res->reldata.rd_node);
+ res->reldata.rd_smgr = NULL;
+ RelationOpenSmgr(&(res->reldata));
/*
* Create the target file if it doesn't already exist. This lets
rdesc = hentry->rdesc;
- if (rdesc->reldata.rd_smgr != NULL)
- smgrclose(rdesc->reldata.rd_smgr);
- rdesc->reldata.rd_smgr = NULL;
+ RelationCloseSmgr(&(rdesc->reldata));
}
if (create_storage)
{
Assert(rel->rd_smgr == NULL);
- rel->rd_smgr = smgropen(rel->rd_node);
+ RelationOpenSmgr(rel);
smgrcreate(rel->rd_smgr, rel->rd_istemp, false);
}
if (rel->rd_rel->relkind != RELKIND_VIEW &&
rel->rd_rel->relkind != RELKIND_COMPOSITE_TYPE)
{
- if (rel->rd_smgr == NULL)
- rel->rd_smgr = smgropen(rel->rd_node);
+ RelationOpenSmgr(rel);
smgrscheduleunlink(rel->rd_smgr, rel->rd_istemp);
- rel->rd_smgr = NULL;
}
/*
*/
FlushRelationBuffers(userIndexRelation, (BlockNumber) 0);
- if (userIndexRelation->rd_smgr == NULL)
- userIndexRelation->rd_smgr = smgropen(userIndexRelation->rd_node);
+ RelationOpenSmgr(userIndexRelation);
smgrscheduleunlink(userIndexRelation->rd_smgr,
userIndexRelation->rd_istemp);
- userIndexRelation->rd_smgr = NULL;
/*
* Close and flush the index's relcache entry, to ensure relcache
smgrclose(srel);
/* schedule unlinking old relfilenode */
- if (relation->rd_smgr == NULL)
- relation->rd_smgr = smgropen(relation->rd_node);
+ RelationOpenSmgr(relation);
smgrscheduleunlink(relation->rd_smgr, relation->rd_istemp);
- relation->rd_smgr = NULL;
/* update the pg_class row */
rd_rel->relfilenode = newrelfilenode;
copy_relation_data(rel, dstrel);
/* schedule unlinking old physical file */
- if (rel->rd_smgr == NULL)
- rel->rd_smgr = smgropen(rel->rd_node);
+ RelationOpenSmgr(rel);
smgrscheduleunlink(rel->rd_smgr, rel->rd_istemp);
- rel->rd_smgr = NULL;
/*
* Now drop smgr references. The source was already dropped by
/*
* After any checkpoint, close all smgr files. This is so we
* won't hang onto smgr references to deleted files
- * indefinitely. (It is safe to do this because this process
- * does not have a relcache, and so no dangling references
- * could remain.)
+ * indefinitely.
*/
smgrcloseall();
*/
if (RelisBecomingView)
{
- if (event_relation->rd_smgr == NULL)
- event_relation->rd_smgr = smgropen(event_relation->rd_node);
+ RelationOpenSmgr(event_relation);
smgrscheduleunlink(event_relation->rd_smgr, event_relation->rd_istemp);
- event_relation->rd_smgr = NULL;
}
/* Close rel, but keep lock till commit... */
isLocalBuf = reln->rd_istemp;
/* Open it at the smgr level if not already done */
- if (reln->rd_smgr == NULL)
- reln->rd_smgr = smgropen(reln->rd_node);
+ RelationOpenSmgr(reln);
/* Substitute proper block number if caller asked for P_NEW */
if (isExtend)
RelationGetNumberOfBlocks(Relation relation)
{
/* Open it at the smgr level if not already done */
- if (relation->rd_smgr == NULL)
- relation->rd_smgr = smgropen(relation->rd_node);
+ RelationOpenSmgr(relation);
return smgrnblocks(relation->rd_smgr);
}
RelationTruncate(Relation rel, BlockNumber nblocks)
{
/* Open it at the smgr level if not already done */
- if (rel->rd_smgr == NULL)
- rel->rd_smgr = smgropen(rel->rd_node);
+ RelationOpenSmgr(rel);
/* Make sure rd_targblock isn't pointing somewhere past end */
rel->rd_targblock = InvalidBlockNumber;
BufferDesc *bufHdr;
/* Open rel at the smgr level if not already done */
- if (rel->rd_smgr == NULL)
- rel->rd_smgr = smgropen(rel->rd_node);
+ RelationOpenSmgr(rel);
if (rel->rd_istemp)
{
*/
if (bufHdr->flags & BM_DIRTY || bufHdr->cntxDirty)
{
- SMgrRelation reln;
+ SMgrRelation oreln;
/* Find smgr relation for buffer */
- reln = smgropen(bufHdr->tag.rnode);
+ oreln = smgropen(bufHdr->tag.rnode);
/* And write... */
- smgrwrite(reln,
+ smgrwrite(oreln,
bufHdr->tag.blockNum,
(char *) MAKE_PTR(bufHdr->data),
true);
if (!found)
{
/* hash_search already filled in the lookup key */
+ reln->smgr_owner = NULL;
reln->smgr_which = 0; /* we only have md.c at present */
reln->md_fd = NULL; /* mark it not open */
}
}
/*
- * smgrclose() -- Close and delete an SMgrRelation object.
+ * smgrsetowner() -- Establish a long-lived reference to an SMgrRelation object
*
- * It is the caller's responsibility not to leave any dangling references
- * to the object. (Pointers should be cleared after successful return;
- * on the off chance of failure, the SMgrRelation object will still exist.)
+ * 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)
+{
+ /*
+ * First, unhook any old owner. (Normally there shouldn't be any, but
+ * it seems possible that this can happen during swap_relation_files()
+ * 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;
+}
+
+/*
+ * smgrclose() -- Close and delete an SMgrRelation object.
*/
void
smgrclose(SMgrRelation reln)
{
+ SMgrRelation *owner;
+
if (!(*(smgrsw[reln->smgr_which].smgr_close)) (reln))
ereport(ERROR,
(errcode_for_file_access(),
reln->smgr_rnode.dbNode,
reln->smgr_rnode.relNode)));
+ owner = reln->smgr_owner;
+
if (hash_search(SMgrRelationHash,
(void *) &(reln->smgr_rnode),
HASH_REMOVE, NULL) == NULL)
elog(ERROR, "SMgrRelation hashtable corrupted");
+
+ /*
+ * Unhook the owner pointer, if any. We do this last since in the
+ * remote possibility of failure above, the SMgrRelation object will still
+ * exist.
+ */
+ if (owner)
+ *owner = NULL;
}
/*
* smgrcloseall() -- Close all existing SMgrRelation objects.
- *
- * It is the caller's responsibility not to leave any dangling references.
*/
void
smgrcloseall(void)
* 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.
- *
- * It is the caller's responsibility not to leave any dangling references.
*/
void
smgrclosenode(RelFileNode rnode)
}
else if (msg->id == SHAREDINVALRELCACHE_ID)
{
- /*
- * If the message includes a valid relfilenode, we must ensure
- * that smgr cache entry gets zapped. The relcache will handle
- * this if called, otherwise we must do it directly.
- */
if (msg->rc.dbId == MyDatabaseId || msg->rc.dbId == InvalidOid)
{
- if (OidIsValid(msg->rc.physId.relNode))
- RelationCacheInvalidateEntry(msg->rc.relId, &msg->rc.physId);
- else
- RelationCacheInvalidateEntry(msg->rc.relId, NULL);
+ RelationCacheInvalidateEntry(msg->rc.relId);
for (i = 0; i < cache_callback_count; i++)
{
(*ccitem->function) (ccitem->arg, msg->rc.relId);
}
}
- else
- {
- /* might have smgr entry even if not in our database */
- if (OidIsValid(msg->rc.physId.relNode))
- smgrclosenode(msg->rc.physId);
- }
+ /*
+ * If the message includes a valid relfilenode, we must ensure
+ * the smgr cache entry gets zapped. This might not have happened
+ * above since the relcache entry might not have existed or might
+ * have been associated with a different relfilenode.
+ *
+ * XXX there is no real good reason for rnode inval to be in the
+ * same message at all. FIXME in 8.1.
+ */
+ if (OidIsValid(msg->rc.physId.relNode))
+ smgrclosenode(msg->rc.physId);
}
else
elog(FATAL, "unrecognized SI message id: %d", msg->id);
* ensures that the low-level file access state is updated after, say,
* a vacuum truncation.
*/
- if (relation->rd_smgr)
- {
- smgrclose(relation->rd_smgr);
- relation->rd_smgr = NULL;
- }
+ RelationCloseSmgr(relation);
/*
* Never, never ever blow away a nailed-in system relation, because
*
* Any relcache entry matching the relid must be flushed. (Note: caller has
* already determined that the relid belongs to our database or is a shared
- * relation.) If rnode isn't NULL, we must also ensure that any smgr cache
- * entry matching that rnode is flushed.
- *
- * Ordinarily, if rnode is supplied then it will match the relfilenode of
- * the target relid. However, it's possible for rnode to be different if
- * someone is engaged in a relfilenode change. In that case we want to
- * make sure we clear the right cache entries. This has to be done here
- * to keep things in sync between relcache and smgr cache --- we can't have
- * someone flushing an smgr cache entry that a relcache entry still points
- * to.
+ * relation.)
*
* We used to skip local relations, on the grounds that they could
* not be targets of cross-backend SI update messages; but it seems
* local and nonlocal relations.
*/
void
-RelationCacheInvalidateEntry(Oid relationId, RelFileNode *rnode)
+RelationCacheInvalidateEntry(Oid relationId)
{
Relation relation;
if (PointerIsValid(relation))
{
relcacheInvalsReceived++;
- if (rnode)
- {
- /* Need to be sure smgr is flushed, but don't do it twice */
- if (relation->rd_smgr == NULL ||
- !RelFileNodeEquals(*rnode, relation->rd_node))
- smgrclosenode(*rnode);
- }
RelationFlushRelation(relation);
}
- else
- {
- if (rnode)
- smgrclosenode(*rnode);
- }
}
/*
relation = idhentry->reldesc;
/* Must close all smgr references to avoid leaving dangling ptrs */
- if (relation->rd_smgr)
- {
- smgrclose(relation->rd_smgr);
- relation->rd_smgr = NULL;
- }
+ RelationCloseSmgr(relation);
/* Ignore new relations, since they are never SI targets */
if (relation->rd_createSubid != InvalidSubTransactionId)
* operations imply I/O, they just create or destroy a hashtable entry.
* (But smgrclose() may release associated resources, such as OS-level file
* descriptors.)
+ *
+ * An SMgrRelation may have an "owner", which is just a pointer to it from
+ * somewhere else; smgr.c will clear this pointer if the SMgrRelation is
+ * closed. We use this to avoid dangling pointers from relcache to smgr
+ * without having to make the smgr explicitly aware of relcache. There
+ * can't be more than one "owner" pointer per SMgrRelation, but that's
+ * all we need.
*/
typedef struct SMgrRelationData
{
/* rnode is the hashtable lookup key, so it must be first! */
RelFileNode smgr_rnode; /* relation physical identifier */
+ /* pointer to owning pointer, or NULL if none */
+ struct SMgrRelationData **smgr_owner;
+
/* additional public fields may someday exist here */
/*
extern void smgrinit(void);
extern SMgrRelation smgropen(RelFileNode rnode);
+extern void smgrsetowner(SMgrRelation *owner, SMgrRelation reln);
extern void smgrclose(SMgrRelation reln);
extern void smgrcloseall(void);
extern void smgrclosenode(RelFileNode rnode);
#define RelationGetNamespace(relation) \
((relation)->rd_rel->relnamespace)
+/*
+ * RelationOpenSmgr
+ * Open the relation at the smgr level, if not already done.
+ */
+#define RelationOpenSmgr(relation) \
+ do { \
+ if ((relation)->rd_smgr == NULL) \
+ smgrsetowner(&((relation)->rd_smgr), smgropen((relation)->rd_node)); \
+ } while (0)
+
+/*
+ * RelationCloseSmgr
+ * Close the relation at the smgr level, if not already done.
+ *
+ * Note: smgrclose should unhook from owner pointer, hence the Assert.
+ */
+#define RelationCloseSmgr(relation) \
+ do { \
+ if ((relation)->rd_smgr != NULL) \
+ { \
+ smgrclose((relation)->rd_smgr); \
+ Assert((relation)->rd_smgr == NULL); \
+ } \
+ } while (0)
+
/*
* RELATION_IS_LOCAL
* If a rel is either temp or newly created in the current transaction,
*/
extern void RelationForgetRelation(Oid rid);
-extern void RelationCacheInvalidateEntry(Oid relationId, RelFileNode *rnode);
+extern void RelationCacheInvalidateEntry(Oid relationId);
extern void RelationCacheInvalidate(void);
projects / users / bernd / postgres.git / commitdiff