public inbox for [email protected]
help / color / mirror / Atom feedFrom: Maxim Orlov <[email protected]>
To: Postgres hackers <[email protected]>
Subject: Rework SLRU I/O errors handle
Date: Thu, 26 Feb 2026 17:26:05 +0300
Message-ID: <CACG=ezZZfurhYV+66ceubxQAyWqv9vaUi0yoO4-t48OE5xc0DQ@mail.gmail.com> (raw)
Hi!
Beginning of the discussion is here [0].
Historically, the SLRU module was designed to handle 32-bit
transactions. However, it is now utilised for handling a variety of
object types, like TransactionId, MultixactId, MultiXactOffset,
QueuePosition, and so on. But the IO error reporting system is still
designed to support 32-bit XIDs exclusively.
The proposed patchset allows us to define a "custom" callback to
improve error messages.
The first two commits add a callback and test case. The subsequent ones
improve I/O error messages. The last one adds the XID epoch to the error
message. It's purely optional, but I think it would be useful.
[0]
https://www.postgresql.org/message-id/CACG%3Dezbwy1zargXDNPeYXxZwRW3jXu_aD%3DrcG-7dc4fw7Y9Ojw%40mail...
--
Best regards,
Maxim Orlov.
Attachments:
[application/octet-stream] v3-0003-Use-custom-SLRU-IO-error-msg-for-an-asynchronous-.patch (3.1K, 3-v3-0003-Use-custom-SLRU-IO-error-msg-for-an-asynchronous-.patch)
download | inline diff:
From 4433671e0b338412216d21ac2572f51fcb07a4b2 Mon Sep 17 00:00:00 2001
From: Maxim Orlov <[email protected]>
Date: Wed, 25 Feb 2026 18:04:13 +0300
Subject: [PATCH v3 3/5] Use custom SLRU IO error msg for an asynchronous
notification
---
src/backend/commands/async.c | 20 ++++++++++++++++----
1 file changed, 16 insertions(+), 4 deletions(-)
diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c
index 8afd1315a9c..254fdc398ce 100644
--- a/src/backend/commands/async.c
+++ b/src/backend/commands/async.c
@@ -569,6 +569,7 @@ bool Trace_notify = false;
int max_notify_queue_pages = 1048576;
/* local function prototypes */
+static inline int asyncQueueErrmsgForIoError(const void *opaque_data);
static inline int64 asyncQueuePageDiff(int64 p, int64 q);
static inline bool asyncQueuePagePrecedes(int64 p, int64 q);
static inline void GlobalChannelKeyInit(GlobalChannelKey *key, Oid dboid,
@@ -609,6 +610,17 @@ static uint32 notification_hash(const void *key, Size keysize);
static int notification_match(const void *key1, const void *key2, Size keysize);
static void ClearPendingActionsAndNotifies(void);
+static inline int
+asyncQueueErrmsgForIoError(const void *opaque_data)
+{
+ const QueuePosition *position = opaque_data;
+
+ Assert(position != NULL);
+
+ return errmsg("could not access status of async queue position (page=%" PRId64", offset=%d)",
+ position->page, position->offset);
+}
+
/*
* Compute the difference between two queue page numbers.
* Previously this function accounted for a wraparound.
@@ -829,7 +841,7 @@ AsyncShmemInit(void)
* names are used in order to avoid wraparound.
*/
NotifyCtl->PagePrecedes = asyncQueuePagePrecedes;
- NotifyCtl->errmsg_for_io_error = xact_errmsg_for_io_error;
+ NotifyCtl->errmsg_for_io_error = asyncQueueErrmsgForIoError;
SimpleLruInit(NotifyCtl, "notify", notify_buffers, 0,
"pg_notify", LWTRANCHE_NOTIFY_BUFFER, LWTRANCHE_NOTIFY_SLRU,
SYNC_HANDLER_NONE, true);
@@ -2068,7 +2080,7 @@ asyncQueueAddEntries(ListCell *nextNotify)
if (QUEUE_POS_IS_ZERO(queue_head))
slotno = SimpleLruZeroPage(NotifyCtl, pageno);
else
- slotno = SimpleLruReadPage(NotifyCtl, pageno, true, NULL);
+ slotno = SimpleLruReadPage(NotifyCtl, pageno, true, &queue_head);
/* Note we mark the page dirty before writing in it */
NotifyCtl->shared->page_dirty[slotno] = true;
@@ -2738,7 +2750,7 @@ asyncQueueProcessPageEntries(QueuePosition *current,
alignas(AsyncQueueEntry) char local_buf[QUEUE_PAGESIZE];
char *local_buf_end = local_buf;
- slotno = SimpleLruReadPage_ReadOnly(NotifyCtl, curpage, NULL);
+ slotno = SimpleLruReadPage_ReadOnly(NotifyCtl, curpage, current);
page_buffer = NotifyCtl->shared->page_buffer[slotno];
do
@@ -2996,7 +3008,7 @@ AsyncNotifyFreezeXids(TransactionId newFrozenXid)
lock = SimpleLruGetBankLock(NotifyCtl, pageno);
LWLockAcquire(lock, LW_EXCLUSIVE);
- slotno = SimpleLruReadPage(NotifyCtl, pageno, true, NULL);
+ slotno = SimpleLruReadPage(NotifyCtl, pageno, true, &pos);
page_buffer = NotifyCtl->shared->page_buffer[slotno];
curpage = pageno;
}
--
2.43.0
[application/octet-stream] v3-0005-Avoid-misleading-user-about-status-of-InvalidTran.patch (1.3K, 4-v3-0005-Avoid-misleading-user-about-status-of-InvalidTran.patch)
download | inline diff:
From bf50b3db60cc6c9603b5c6ff26ea2d8a79d9965d Mon Sep 17 00:00:00 2001
From: Maxim Orlov <[email protected]>
Date: Wed, 25 Feb 2026 18:20:32 +0300
Subject: [PATCH v3 5/5] Avoid misleading user about status of
InvalidTransactionId
In some cases, we use the access SLRU page without specifying the XID.
If an error occurs, you may receive a message about the inability to
obtain status of transaction 0, even though the page appears to be sane.
To avoid this, use a more general formulation in case XID is invalid.
---
src/include/access/slru.h | 7 ++++---
1 file changed, 4 insertions(+), 3 deletions(-)
diff --git a/src/include/access/slru.h b/src/include/access/slru.h
index 1e0beb26628..78ee36c05a6 100644
--- a/src/include/access/slru.h
+++ b/src/include/access/slru.h
@@ -166,10 +166,11 @@ typedef SlruCtlData *SlruCtl;
static inline int
xact_errmsg_for_io_error(const void *opaque_data)
{
- TransactionId xid = opaque_data ? (*(TransactionId *) opaque_data) :
- InvalidTransactionId;
+ if (opaque_data)
+ return errmsg("could not access status of transaction %u",
+ *(TransactionId *) opaque_data);
- return errmsg("could not access status of transaction %u", xid);
+ return errmsg("could not access slru entry"); /* InvalidTransactionId */
}
/*
--
2.43.0
[application/octet-stream] v3-0001-Add-a-callback-for-generating-an-I-O-message-in-t.patch (21.7K, 5-v3-0001-Add-a-callback-for-generating-an-I-O-message-in-t.patch)
download | inline diff:
From 4964b19d495e94050efd37454eff7dc89145a748 Mon Sep 17 00:00:00 2001
From: Maxim Orlov <[email protected]>
Date: Wed, 25 Feb 2026 16:59:38 +0300
Subject: [PATCH v3 1/5] Add a callback for generating an I/O message in the
SLRU
Historically, the SLRU module was designed to work with transaction IDs.
But now we use it to work with different objects, and even of different
types. However, I/O errors continued to be output in the
corresponding XIDs format.
This commit adds a callback that will allow to create custom IO error
messages for modules that don't work with transaction IDs.
No user-visible behavior change is expected in this commit.
---
src/backend/access/transam/clog.c | 8 +++---
src/backend/access/transam/commit_ts.c | 5 ++--
src/backend/access/transam/multixact.c | 21 ++++++++------
src/backend/access/transam/slru.c | 38 +++++++++++++++-----------
src/backend/access/transam/subtrans.c | 5 ++--
src/backend/commands/async.c | 10 +++----
src/backend/storage/lmgr/predicate.c | 5 ++--
src/include/access/slru.h | 26 ++++++++++++++++--
src/test/modules/test_slru/test_slru.c | 5 ++--
9 files changed, 78 insertions(+), 45 deletions(-)
diff --git a/src/backend/access/transam/clog.c b/src/backend/access/transam/clog.c
index b5c38bbb162..899fa7b41e1 100644
--- a/src/backend/access/transam/clog.c
+++ b/src/backend/access/transam/clog.c
@@ -381,8 +381,7 @@ TransactionIdSetPageStatusInternal(TransactionId xid, int nsubxids,
* write-busy, since we don't care if the update reaches disk sooner than
* we think.
*/
- slotno = SimpleLruReadPage(XactCtl, pageno, !XLogRecPtrIsValid(lsn),
- xid);
+ slotno = SimpleLruReadPage(XactCtl, pageno, !XLogRecPtrIsValid(lsn), &xid);
/*
* Set the main transaction id, if any.
@@ -743,7 +742,7 @@ TransactionIdGetStatus(TransactionId xid, XLogRecPtr *lsn)
/* lock is acquired by SimpleLruReadPage_ReadOnly */
- slotno = SimpleLruReadPage_ReadOnly(XactCtl, pageno, xid);
+ slotno = SimpleLruReadPage_ReadOnly(XactCtl, pageno, &xid);
byteptr = XactCtl->shared->page_buffer[slotno] + byteno;
status = (*byteptr >> bshift) & CLOG_XACT_BITMASK;
@@ -807,6 +806,7 @@ CLOGShmemInit(void)
Assert(transaction_buffers != 0);
XactCtl->PagePrecedes = CLOGPagePrecedes;
+ XactCtl->errmsg_for_io_error = xact_errmsg_for_io_error;
SimpleLruInit(XactCtl, "transaction", CLOGShmemBuffers(), CLOG_LSNS_PER_PAGE,
"pg_xact", LWTRANCHE_XACT_BUFFER,
LWTRANCHE_XACT_SLRU, SYNC_HANDLER_CLOG, false);
@@ -882,7 +882,7 @@ TrimCLOG(void)
int slotno;
char *byteptr;
- slotno = SimpleLruReadPage(XactCtl, pageno, false, xid);
+ slotno = SimpleLruReadPage(XactCtl, pageno, false, &xid);
byteptr = XactCtl->shared->page_buffer[slotno] + byteno;
/* Zero so-far-unused positions in the current byte */
diff --git a/src/backend/access/transam/commit_ts.c b/src/backend/access/transam/commit_ts.c
index 6fa2178f1dd..9563e87d9b2 100644
--- a/src/backend/access/transam/commit_ts.c
+++ b/src/backend/access/transam/commit_ts.c
@@ -227,7 +227,7 @@ SetXidCommitTsInPage(TransactionId xid, int nsubxids,
LWLockAcquire(lock, LW_EXCLUSIVE);
- slotno = SimpleLruReadPage(CommitTsCtl, pageno, true, xid);
+ slotno = SimpleLruReadPage(CommitTsCtl, pageno, true, &xid);
TransactionIdSetCommitTs(xid, ts, nodeid, slotno);
for (i = 0; i < nsubxids; i++)
@@ -332,7 +332,7 @@ TransactionIdGetCommitTsData(TransactionId xid, TimestampTz *ts,
}
/* lock is acquired by SimpleLruReadPage_ReadOnly */
- slotno = SimpleLruReadPage_ReadOnly(CommitTsCtl, pageno, xid);
+ slotno = SimpleLruReadPage_ReadOnly(CommitTsCtl, pageno, &xid);
memcpy(&entry,
CommitTsCtl->shared->page_buffer[slotno] +
SizeOfCommitTimestampEntry * entryno,
@@ -551,6 +551,7 @@ CommitTsShmemInit(void)
Assert(commit_timestamp_buffers != 0);
CommitTsCtl->PagePrecedes = CommitTsPagePrecedes;
+ CommitTsCtl->errmsg_for_io_error = xact_errmsg_for_io_error;
SimpleLruInit(CommitTsCtl, "commit_timestamp", CommitTsShmemBuffers(), 0,
"pg_commit_ts", LWTRANCHE_COMMITTS_BUFFER,
LWTRANCHE_COMMITTS_SLRU,
diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
index 90ec87d9dd6..816fb50fa4b 100644
--- a/src/backend/access/transam/multixact.c
+++ b/src/backend/access/transam/multixact.c
@@ -798,7 +798,7 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
* enough that a MultiXactId is really involved. Perhaps someday we'll
* take the trouble to generalize the slru.c error reporting code.
*/
- slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, multi);
+ slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, &multi);
offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
offptr += entryno;
@@ -827,7 +827,7 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
lock = SimpleLruGetBankLock(MultiXactOffsetCtl, next_pageno);
LWLockAcquire(lock, LW_EXCLUSIVE);
- slotno = SimpleLruReadPage(MultiXactOffsetCtl, next_pageno, true, next);
+ slotno = SimpleLruReadPage(MultiXactOffsetCtl, next_pageno, true, &next);
next_offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
next_offptr += next_entryno;
}
@@ -881,7 +881,7 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
LWLockAcquire(lock, LW_EXCLUSIVE);
prevlock = lock;
}
- slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, multi);
+ slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, &multi);
prev_pageno = pageno;
}
@@ -1206,7 +1206,7 @@ GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members,
LWLockAcquire(lock, LW_EXCLUSIVE);
/* read this multi's offset */
- slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, multi);
+ slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, &multi);
offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
offptr += entryno;
offset = *offptr;
@@ -1244,7 +1244,7 @@ GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members,
LWLockAcquire(newlock, LW_EXCLUSIVE);
lock = newlock;
}
- slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, tmpMXact);
+ slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, &tmpMXact);
}
offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
@@ -1309,7 +1309,7 @@ GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members,
lock = newlock;
}
- slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, multi);
+ slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, &multi);
prev_pageno = pageno;
}
@@ -1730,6 +1730,9 @@ MultiXactShmemInit(void)
MultiXactOffsetCtl->PagePrecedes = MultiXactOffsetPagePrecedes;
MultiXactMemberCtl->PagePrecedes = MultiXactMemberPagePrecedes;
+ MultiXactOffsetCtl->errmsg_for_io_error = xact_errmsg_for_io_error;
+ MultiXactMemberCtl->errmsg_for_io_error = xact_errmsg_for_io_error;
+
SimpleLruInit(MultiXactOffsetCtl,
"multixact_offset", multixact_offset_buffers, 0,
"pg_multixact/offsets", LWTRANCHE_MULTIXACTOFFSET_BUFFER,
@@ -1879,7 +1882,7 @@ TrimMultiXact(void)
if (entryno == 0 || nextMXact == FirstMultiXactId)
slotno = SimpleLruZeroPage(MultiXactOffsetCtl, pageno);
else
- slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, nextMXact);
+ slotno = SimpleLruReadPage(MultiXactOffsetCtl, pageno, true, &nextMXact);
offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
offptr += entryno;
@@ -1914,7 +1917,7 @@ TrimMultiXact(void)
LWLockAcquire(lock, LW_EXCLUSIVE);
memberoff = MXOffsetToMemberOffset(offset);
- slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, offset);
+ slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, &offset);
xidptr = (TransactionId *)
(MultiXactMemberCtl->shared->page_buffer[slotno] + memberoff);
@@ -2444,7 +2447,7 @@ find_multixact_start(MultiXactId multi, MultiXactOffset *result)
return false;
/* lock is acquired by SimpleLruReadPage_ReadOnly */
- slotno = SimpleLruReadPage_ReadOnly(MultiXactOffsetCtl, pageno, multi);
+ slotno = SimpleLruReadPage_ReadOnly(MultiXactOffsetCtl, pageno, &multi);
offptr = (MultiXactOffset *) MultiXactOffsetCtl->shared->page_buffer[slotno];
offptr += entryno;
offset = *offptr;
diff --git a/src/backend/access/transam/slru.c b/src/backend/access/transam/slru.c
index 549c7e3e64b..0b5bb11a18d 100644
--- a/src/backend/access/transam/slru.c
+++ b/src/backend/access/transam/slru.c
@@ -181,7 +181,8 @@ static void SlruInternalWritePage(SlruCtl ctl, int slotno, SlruWriteAll fdata);
static bool SlruPhysicalReadPage(SlruCtl ctl, int64 pageno, int slotno);
static bool SlruPhysicalWritePage(SlruCtl ctl, int64 pageno, int slotno,
SlruWriteAll fdata);
-static void SlruReportIOError(SlruCtl ctl, int64 pageno, TransactionId xid);
+static void SlruReportIOError(SlruCtl ctl, int64 pageno,
+ const void *opaque_data);
static int SlruSelectLRUPage(SlruCtl ctl, int64 pageno);
static bool SlruScanDirCbDeleteCutoff(SlruCtl ctl, char *filename,
@@ -257,6 +258,10 @@ SimpleLruInit(SlruCtl ctl, const char *name, int nslots, int nlsns,
bool found;
int nbanks = nslots / SLRU_BANK_SIZE;
+ /* Make sure callbacks are set up */
+ Assert(ctl->PagePrecedes != NULL);
+ Assert(ctl->errmsg_for_io_error != NULL);
+
Assert(nslots <= SLRU_MAX_ALLOWED_BUFFERS);
shared = (SlruShared) ShmemInitStruct(name,
@@ -525,7 +530,7 @@ SimpleLruWaitIO(SlruCtl ctl, int slotno)
*/
int
SimpleLruReadPage(SlruCtl ctl, int64 pageno, bool write_ok,
- TransactionId xid)
+ const void *opaque_data)
{
SlruShared shared = ctl->shared;
LWLock *banklock = SimpleLruGetBankLock(ctl, pageno);
@@ -601,7 +606,7 @@ SimpleLruReadPage(SlruCtl ctl, int64 pageno, bool write_ok,
/* Now it's okay to ereport if we failed */
if (!ok)
- SlruReportIOError(ctl, pageno, xid);
+ SlruReportIOError(ctl, pageno, opaque_data);
SlruRecentlyUsed(shared, slotno);
@@ -627,7 +632,7 @@ SimpleLruReadPage(SlruCtl ctl, int64 pageno, bool write_ok,
* It is unspecified whether the lock will be shared or exclusive.
*/
int
-SimpleLruReadPage_ReadOnly(SlruCtl ctl, int64 pageno, TransactionId xid)
+SimpleLruReadPage_ReadOnly(SlruCtl ctl, int64 pageno, const void *opaque_data)
{
SlruShared shared = ctl->shared;
LWLock *banklock = SimpleLruGetBankLock(ctl, pageno);
@@ -659,7 +664,7 @@ SimpleLruReadPage_ReadOnly(SlruCtl ctl, int64 pageno, TransactionId xid)
LWLockRelease(banklock);
LWLockAcquire(banklock, LW_EXCLUSIVE);
- return SimpleLruReadPage(ctl, pageno, true, xid);
+ return SimpleLruReadPage(ctl, pageno, true, opaque_data);
}
/*
@@ -682,6 +687,7 @@ SlruInternalWritePage(SlruCtl ctl, int slotno, SlruWriteAll fdata)
bool ok;
Assert(shared->page_status[slotno] != SLRU_PAGE_EMPTY);
+
Assert(LWLockHeldByMeInMode(SimpleLruGetBankLock(ctl, pageno), LW_EXCLUSIVE));
/* If a write is in progress, wait for it to finish */
@@ -739,7 +745,7 @@ SlruInternalWritePage(SlruCtl ctl, int slotno, SlruWriteAll fdata)
/* Now it's okay to ereport if we failed */
if (!ok)
- SlruReportIOError(ctl, pageno, InvalidTransactionId);
+ SlruReportIOError(ctl, pageno, NULL);
/* If part of a checkpoint, count this as a SLRU buffer written. */
if (fdata)
@@ -1070,7 +1076,7 @@ SlruPhysicalWritePage(SlruCtl ctl, int64 pageno, int slotno, SlruWriteAll fdata)
* SlruPhysicalWritePage. Call this after cleaning up shared-memory state.
*/
static void
-SlruReportIOError(SlruCtl ctl, int64 pageno, TransactionId xid)
+SlruReportIOError(SlruCtl ctl, int64 pageno, const void *opaque_data)
{
int64 segno = pageno / SLRU_PAGES_PER_SEGMENT;
int rpageno = pageno % SLRU_PAGES_PER_SEGMENT;
@@ -1084,13 +1090,13 @@ SlruReportIOError(SlruCtl ctl, int64 pageno, TransactionId xid)
case SLRU_OPEN_FAILED:
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not access status of transaction %u", xid),
+ ctl->errmsg_for_io_error(opaque_data),
errdetail("Could not open file \"%s\": %m.", path)));
break;
case SLRU_SEEK_FAILED:
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not access status of transaction %u", xid),
+ ctl->errmsg_for_io_error(opaque_data),
errdetail("Could not seek in file \"%s\" to offset %d: %m.",
path, offset)));
break;
@@ -1098,38 +1104,38 @@ SlruReportIOError(SlruCtl ctl, int64 pageno, TransactionId xid)
if (errno)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not access status of transaction %u", xid),
+ ctl->errmsg_for_io_error(opaque_data),
errdetail("Could not read from file \"%s\" at offset %d: %m.",
path, offset)));
else
ereport(ERROR,
- (errmsg("could not access status of transaction %u", xid),
+ (ctl->errmsg_for_io_error(opaque_data),
errdetail("Could not read from file \"%s\" at offset %d: read too few bytes.", path, offset)));
break;
case SLRU_WRITE_FAILED:
if (errno)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not access status of transaction %u", xid),
+ ctl->errmsg_for_io_error(opaque_data),
errdetail("Could not write to file \"%s\" at offset %d: %m.",
path, offset)));
else
ereport(ERROR,
- (errmsg("could not access status of transaction %u", xid),
+ (ctl->errmsg_for_io_error(opaque_data),
errdetail("Could not write to file \"%s\" at offset %d: wrote too few bytes.",
path, offset)));
break;
case SLRU_FSYNC_FAILED:
ereport(data_sync_elevel(ERROR),
(errcode_for_file_access(),
- errmsg("could not access status of transaction %u", xid),
+ ctl->errmsg_for_io_error(opaque_data),
errdetail("Could not fsync file \"%s\": %m.",
path)));
break;
case SLRU_CLOSE_FAILED:
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not access status of transaction %u", xid),
+ ctl->errmsg_for_io_error(opaque_data),
errdetail("Could not close file \"%s\": %m.",
path)));
break;
@@ -1411,7 +1417,7 @@ SimpleLruWriteAll(SlruCtl ctl, bool allow_redirtied)
}
}
if (!ok)
- SlruReportIOError(ctl, pageno, InvalidTransactionId);
+ SlruReportIOError(ctl, pageno, NULL);
/* Ensure that directory entries for new files are on disk. */
if (ctl->sync_handler != SYNC_HANDLER_NONE)
diff --git a/src/backend/access/transam/subtrans.c b/src/backend/access/transam/subtrans.c
index c0987f43f11..18b7da7fca1 100644
--- a/src/backend/access/transam/subtrans.c
+++ b/src/backend/access/transam/subtrans.c
@@ -95,7 +95,7 @@ SubTransSetParent(TransactionId xid, TransactionId parent)
lock = SimpleLruGetBankLock(SubTransCtl, pageno);
LWLockAcquire(lock, LW_EXCLUSIVE);
- slotno = SimpleLruReadPage(SubTransCtl, pageno, true, xid);
+ slotno = SimpleLruReadPage(SubTransCtl, pageno, true, &xid);
ptr = (TransactionId *) SubTransCtl->shared->page_buffer[slotno];
ptr += entryno;
@@ -135,7 +135,7 @@ SubTransGetParent(TransactionId xid)
/* lock is acquired by SimpleLruReadPage_ReadOnly */
- slotno = SimpleLruReadPage_ReadOnly(SubTransCtl, pageno, xid);
+ slotno = SimpleLruReadPage_ReadOnly(SubTransCtl, pageno, &xid);
ptr = (TransactionId *) SubTransCtl->shared->page_buffer[slotno];
ptr += entryno;
@@ -240,6 +240,7 @@ SUBTRANSShmemInit(void)
Assert(subtransaction_buffers != 0);
SubTransCtl->PagePrecedes = SubTransPagePrecedes;
+ SubTransCtl->errmsg_for_io_error = xact_errmsg_for_io_error;
SimpleLruInit(SubTransCtl, "subtransaction", SUBTRANSShmemBuffers(), 0,
"pg_subtrans", LWTRANCHE_SUBTRANS_BUFFER,
LWTRANCHE_SUBTRANS_SLRU, SYNC_HANDLER_NONE, false);
diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c
index 657c591618d..8afd1315a9c 100644
--- a/src/backend/commands/async.c
+++ b/src/backend/commands/async.c
@@ -829,6 +829,7 @@ AsyncShmemInit(void)
* names are used in order to avoid wraparound.
*/
NotifyCtl->PagePrecedes = asyncQueuePagePrecedes;
+ NotifyCtl->errmsg_for_io_error = xact_errmsg_for_io_error;
SimpleLruInit(NotifyCtl, "notify", notify_buffers, 0,
"pg_notify", LWTRANCHE_NOTIFY_BUFFER, LWTRANCHE_NOTIFY_SLRU,
SYNC_HANDLER_NONE, true);
@@ -2067,8 +2068,7 @@ asyncQueueAddEntries(ListCell *nextNotify)
if (QUEUE_POS_IS_ZERO(queue_head))
slotno = SimpleLruZeroPage(NotifyCtl, pageno);
else
- slotno = SimpleLruReadPage(NotifyCtl, pageno, true,
- InvalidTransactionId);
+ slotno = SimpleLruReadPage(NotifyCtl, pageno, true, NULL);
/* Note we mark the page dirty before writing in it */
NotifyCtl->shared->page_dirty[slotno] = true;
@@ -2738,8 +2738,7 @@ asyncQueueProcessPageEntries(QueuePosition *current,
alignas(AsyncQueueEntry) char local_buf[QUEUE_PAGESIZE];
char *local_buf_end = local_buf;
- slotno = SimpleLruReadPage_ReadOnly(NotifyCtl, curpage,
- InvalidTransactionId);
+ slotno = SimpleLruReadPage_ReadOnly(NotifyCtl, curpage, NULL);
page_buffer = NotifyCtl->shared->page_buffer[slotno];
do
@@ -2997,8 +2996,7 @@ AsyncNotifyFreezeXids(TransactionId newFrozenXid)
lock = SimpleLruGetBankLock(NotifyCtl, pageno);
LWLockAcquire(lock, LW_EXCLUSIVE);
- slotno = SimpleLruReadPage(NotifyCtl, pageno, true,
- InvalidTransactionId);
+ slotno = SimpleLruReadPage(NotifyCtl, pageno, true, NULL);
page_buffer = NotifyCtl->shared->page_buffer[slotno];
curpage = pageno;
}
diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c
index fe75ead3501..66eb1c9d6b1 100644
--- a/src/backend/storage/lmgr/predicate.c
+++ b/src/backend/storage/lmgr/predicate.c
@@ -811,6 +811,7 @@ SerialInit(void)
* Set up SLRU management of the pg_serial data.
*/
SerialSlruCtl->PagePrecedes = SerialPagePrecedesLogically;
+ SerialSlruCtl->errmsg_for_io_error = xact_errmsg_for_io_error;
SimpleLruInit(SerialSlruCtl, "serializable",
serializable_buffers, 0, "pg_serial",
LWTRANCHE_SERIAL_BUFFER, LWTRANCHE_SERIAL_SLRU,
@@ -930,7 +931,7 @@ SerialAdd(TransactionId xid, SerCommitSeqNo minConflictCommitSeqNo)
else
{
LWLockAcquire(lock, LW_EXCLUSIVE);
- slotno = SimpleLruReadPage(SerialSlruCtl, targetPage, true, xid);
+ slotno = SimpleLruReadPage(SerialSlruCtl, targetPage, true, &xid);
}
SerialValue(slotno, xid) = minConflictCommitSeqNo;
@@ -974,7 +975,7 @@ SerialGetMinConflictCommitSeqNo(TransactionId xid)
* but will return with that lock held, which must then be released.
*/
slotno = SimpleLruReadPage_ReadOnly(SerialSlruCtl,
- SerialPage(xid), xid);
+ SerialPage(xid), &xid);
val = SerialValue(slotno, xid);
LWLockRelease(SimpleLruGetBankLock(SerialSlruCtl, SerialPage(xid)));
return val;
diff --git a/src/include/access/slru.h b/src/include/access/slru.h
index 4cb8f478fce..1e0beb26628 100644
--- a/src/include/access/slru.h
+++ b/src/include/access/slru.h
@@ -13,6 +13,7 @@
#ifndef SLRU_H
#define SLRU_H
+#include "access/transam.h"
#include "access/xlogdefs.h"
#include "storage/lwlock.h"
#include "storage/sync.h"
@@ -146,10 +147,31 @@ typedef struct SlruCtlData
* it's always the same, it doesn't need to be in shared memory.
*/
char Dir[64];
+
+ /*
+ * Callback for creating an I/O error message.
+ *
+ * The opaque_data argument here is the same one that is passed to the
+ * SimpleLruReadPage* calls.
+ */
+ int (*errmsg_for_io_error)(const void *opaque_data);
} SlruCtlData;
typedef SlruCtlData *SlruCtl;
+/*
+ * Historically, this module was designed for handling transaction IDs,
+ * therefore this is the most common use case. Thus, make it publicly available.
+ */
+static inline int
+xact_errmsg_for_io_error(const void *opaque_data)
+{
+ TransactionId xid = opaque_data ? (*(TransactionId *) opaque_data) :
+ InvalidTransactionId;
+
+ return errmsg("could not access status of transaction %u", xid);
+}
+
/*
* Get the SLRU bank lock for given SlruCtl and the pageno.
*
@@ -174,9 +196,9 @@ extern void SimpleLruInit(SlruCtl ctl, const char *name, int nslots, int nlsns,
extern int SimpleLruZeroPage(SlruCtl ctl, int64 pageno);
extern void SimpleLruZeroAndWritePage(SlruCtl ctl, int64 pageno);
extern int SimpleLruReadPage(SlruCtl ctl, int64 pageno, bool write_ok,
- TransactionId xid);
+ const void *opaque_data);
extern int SimpleLruReadPage_ReadOnly(SlruCtl ctl, int64 pageno,
- TransactionId xid);
+ const void *opaque_data);
extern void SimpleLruWritePage(SlruCtl ctl, int slotno);
extern void SimpleLruWriteAll(SlruCtl ctl, bool allow_redirtied);
#ifdef USE_ASSERT_CHECKING
diff --git a/src/test/modules/test_slru/test_slru.c b/src/test/modules/test_slru/test_slru.c
index 4dc74e19620..a19129c366b 100644
--- a/src/test/modules/test_slru/test_slru.c
+++ b/src/test/modules/test_slru/test_slru.c
@@ -100,7 +100,7 @@ test_slru_page_read(PG_FUNCTION_ARGS)
/* find page in buffers, reading it if necessary */
LWLockAcquire(lock, LW_EXCLUSIVE);
slotno = SimpleLruReadPage(TestSlruCtl, pageno,
- write_ok, InvalidTransactionId);
+ write_ok, NULL);
data = (char *) TestSlruCtl->shared->page_buffer[slotno];
LWLockRelease(lock);
@@ -118,7 +118,7 @@ test_slru_page_readonly(PG_FUNCTION_ARGS)
/* find page in buffers, reading it if necessary */
slotno = SimpleLruReadPage_ReadOnly(TestSlruCtl,
pageno,
- InvalidTransactionId);
+ NULL);
Assert(LWLockHeldByMe(lock));
data = (char *) TestSlruCtl->shared->page_buffer[slotno];
LWLockRelease(lock);
@@ -245,6 +245,7 @@ test_slru_shmem_startup(void)
}
TestSlruCtl->PagePrecedes = test_slru_page_precedes_logically;
+ TestSlruCtl->errmsg_for_io_error = xact_errmsg_for_io_error;
SimpleLruInit(TestSlruCtl, "TestSLRU",
NUM_TEST_BUFFERS, 0, slru_dir_name,
test_buffer_tranche_id, test_tranche_id, SYNC_HANDLER_NONE,
--
2.43.0
[application/octet-stream] v3-0002-Add-test-case-for-custom-SLRU-IO-error.patch (4.5K, 6-v3-0002-Add-test-case-for-custom-SLRU-IO-error.patch)
download | inline diff:
From a86db1088a104d8ecf29fc5e762f5949c5d2e57c Mon Sep 17 00:00:00 2001
From: Maxim Orlov <[email protected]>
Date: Wed, 25 Feb 2026 17:48:42 +0300
Subject: [PATCH v3 2/5] Add test case for custom SLRU IO error
---
src/test/modules/test_slru/expected/test_slru.out | 7 +++++++
src/test/modules/test_slru/sql/test_slru.sql | 4 ++++
src/test/modules/test_slru/test_slru--1.0.sql | 2 +-
src/test/modules/test_slru/test_slru.c | 15 +++++++++++++--
4 files changed, 25 insertions(+), 3 deletions(-)
diff --git a/src/test/modules/test_slru/expected/test_slru.out b/src/test/modules/test_slru/expected/test_slru.out
index 185c56e5d62..0dda6b60f0b 100644
--- a/src/test/modules/test_slru/expected/test_slru.out
+++ b/src/test/modules/test_slru/expected/test_slru.out
@@ -23,6 +23,13 @@ SELECT test_slru_page_exists(12345);
t
(1 row)
+-- should fail with custom error msg
+SELECT test_slru_page_read(54321);
+ERROR: could not access test_slru entry
+DETAIL: Could not open file "pg_test_slru/0000000000006A1": No such file or directory.
+SELECT test_slru_page_read(54321, false, '123'::xid);
+ERROR: could not access test_slru entry 123
+DETAIL: Could not open file "pg_test_slru/0000000000006A1": No such file or directory.
-- 48 extra pages
SELECT count(test_slru_page_write(a, 'Test SLRU'))
FROM generate_series(12346, 12393, 1) as a;
diff --git a/src/test/modules/test_slru/sql/test_slru.sql b/src/test/modules/test_slru/sql/test_slru.sql
index b1b376581ab..4f66f4207b7 100644
--- a/src/test/modules/test_slru/sql/test_slru.sql
+++ b/src/test/modules/test_slru/sql/test_slru.sql
@@ -5,6 +5,10 @@ SELECT test_slru_page_write(12345, 'Test SLRU');
SELECT test_slru_page_read(12345);
SELECT test_slru_page_exists(12345);
+-- should fail with custom error msg
+SELECT test_slru_page_read(54321);
+SELECT test_slru_page_read(54321, false, '123'::xid);
+
-- 48 extra pages
SELECT count(test_slru_page_write(a, 'Test SLRU'))
FROM generate_series(12346, 12393, 1) as a;
diff --git a/src/test/modules/test_slru/test_slru--1.0.sql b/src/test/modules/test_slru/test_slru--1.0.sql
index abecb5e2183..22f4f64b988 100644
--- a/src/test/modules/test_slru/test_slru--1.0.sql
+++ b/src/test/modules/test_slru/test_slru--1.0.sql
@@ -7,7 +7,7 @@ CREATE OR REPLACE FUNCTION test_slru_page_writeall() RETURNS VOID
AS 'MODULE_PATHNAME', 'test_slru_page_writeall' LANGUAGE C;
CREATE OR REPLACE FUNCTION test_slru_page_sync(bigint) RETURNS VOID
AS 'MODULE_PATHNAME', 'test_slru_page_sync' LANGUAGE C;
-CREATE OR REPLACE FUNCTION test_slru_page_read(bigint, bool DEFAULT true) RETURNS text
+CREATE OR REPLACE FUNCTION test_slru_page_read(bigint, bool DEFAULT true, xid DEFAULT NULL) RETURNS text
AS 'MODULE_PATHNAME', 'test_slru_page_read' LANGUAGE C;
CREATE OR REPLACE FUNCTION test_slru_page_readonly(bigint) RETURNS text
AS 'MODULE_PATHNAME', 'test_slru_page_readonly' LANGUAGE C;
diff --git a/src/test/modules/test_slru/test_slru.c b/src/test/modules/test_slru/test_slru.c
index a19129c366b..9ecf74882ff 100644
--- a/src/test/modules/test_slru/test_slru.c
+++ b/src/test/modules/test_slru/test_slru.c
@@ -93,6 +93,7 @@ test_slru_page_read(PG_FUNCTION_ARGS)
{
int64 pageno = PG_GETARG_INT64(0);
bool write_ok = PG_GETARG_BOOL(1);
+ TransactionId xid = PG_GETARG_TRANSACTIONID(2);
char *data = NULL;
int slotno;
LWLock *lock = SimpleLruGetBankLock(TestSlruCtl, pageno);
@@ -100,7 +101,7 @@ test_slru_page_read(PG_FUNCTION_ARGS)
/* find page in buffers, reading it if necessary */
LWLockAcquire(lock, LW_EXCLUSIVE);
slotno = SimpleLruReadPage(TestSlruCtl, pageno,
- write_ok, NULL);
+ write_ok, PG_ARGISNULL(2) ? NULL : &xid);
data = (char *) TestSlruCtl->shared->page_buffer[slotno];
LWLockRelease(lock);
@@ -210,6 +211,16 @@ test_slru_page_precedes_logically(int64 page1, int64 page2)
return page1 < page2;
}
+static inline int
+test_slru_errmsg_for_io_error(const void *opaque_data)
+{
+ if (opaque_data)
+ return errmsg("could not access test_slru entry %u",
+ *(TransactionId *) opaque_data);
+
+ return errmsg("could not access test_slru entry");
+}
+
static void
test_slru_shmem_startup(void)
{
@@ -245,7 +256,7 @@ test_slru_shmem_startup(void)
}
TestSlruCtl->PagePrecedes = test_slru_page_precedes_logically;
- TestSlruCtl->errmsg_for_io_error = xact_errmsg_for_io_error;
+ TestSlruCtl->errmsg_for_io_error = test_slru_errmsg_for_io_error;
SimpleLruInit(TestSlruCtl, "TestSLRU",
NUM_TEST_BUFFERS, 0, slru_dir_name,
test_buffer_tranche_id, test_tranche_id, SYNC_HANDLER_NONE,
--
2.43.0
[application/octet-stream] v3-0004-Use-custom-SLRU-IO-error-msg-for-multixact.patch (3.0K, 7-v3-0004-Use-custom-SLRU-IO-error-msg-for-multixact.patch)
download | inline diff:
From b94b2c17e07e5b9c8df1510da0f687ca2b52a5c3 Mon Sep 17 00:00:00 2001
From: Maxim Orlov <[email protected]>
Date: Wed, 25 Feb 2026 18:20:01 +0300
Subject: [PATCH v3 4/5] Use custom SLRU IO error msg for multixact
---
src/backend/access/transam/multixact.c | 36 +++++++++++++++++++++++---
1 file changed, 32 insertions(+), 4 deletions(-)
diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
index 816fb50fa4b..b78cd5fe41e 100644
--- a/src/backend/access/transam/multixact.c
+++ b/src/backend/access/transam/multixact.c
@@ -277,6 +277,8 @@ static void mXactCachePut(MultiXactId multi, int nmembers,
/* management of SLRU infrastructure */
static bool MultiXactOffsetPagePrecedes(int64 page1, int64 page2);
static bool MultiXactMemberPagePrecedes(int64 page1, int64 page2);
+static inline int MultiXactOffsetIoErrorMsg(const void *opaque_data);
+static inline int MultiXactMemberIoErrorMsg(const void *opaque_data);
static void ExtendMultiXactOffset(MultiXactId multi);
static void ExtendMultiXactMember(MultiXactOffset offset, int nmembers);
static void SetOldestOffset(void);
@@ -881,7 +883,8 @@ RecordNewMultiXact(MultiXactId multi, MultiXactOffset offset,
LWLockAcquire(lock, LW_EXCLUSIVE);
prevlock = lock;
}
- slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, &multi);
+ slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true,
+ &offset);
prev_pageno = pageno;
}
@@ -1309,7 +1312,8 @@ GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members,
lock = newlock;
}
- slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true, &multi);
+ slotno = SimpleLruReadPage(MultiXactMemberCtl, pageno, true,
+ &offset);
prev_pageno = pageno;
}
@@ -1730,8 +1734,8 @@ MultiXactShmemInit(void)
MultiXactOffsetCtl->PagePrecedes = MultiXactOffsetPagePrecedes;
MultiXactMemberCtl->PagePrecedes = MultiXactMemberPagePrecedes;
- MultiXactOffsetCtl->errmsg_for_io_error = xact_errmsg_for_io_error;
- MultiXactMemberCtl->errmsg_for_io_error = xact_errmsg_for_io_error;
+ MultiXactOffsetCtl->errmsg_for_io_error = MultiXactOffsetIoErrorMsg;
+ MultiXactMemberCtl->errmsg_for_io_error = MultiXactMemberIoErrorMsg;
SimpleLruInit(MultiXactOffsetCtl,
"multixact_offset", multixact_offset_buffers, 0,
@@ -2758,6 +2762,30 @@ MultiXactMemberPagePrecedes(int64 page1, int64 page2)
return page1 < page2;
}
+/*
+ * Custom IO errmsg for MultiXactOffset.
+ */
+static inline int
+MultiXactOffsetIoErrorMsg(const void *opaque_data)
+{
+ Assert(opaque_data != NULL);
+
+ return errmsg("could not access status of multixact offset %u",
+ *(MultiXactId *) opaque_data);
+}
+
+/*
+ * Custom IO errmsg for MultiXactMember.
+ */
+static inline int
+MultiXactMemberIoErrorMsg(const void *opaque_data)
+{
+ Assert(opaque_data != NULL);
+
+ return errmsg("could not access status of multixact member %" PRIu64,
+ *(MultiXactOffset *) opaque_data);
+}
+
/*
* Decide which of two MultiXactIds is earlier.
*
--
2.43.0
[application/octet-stream] v3-0006-Expand-xact-SLRU-IO-error-to-show-epoch.patch (1.1K, 8-v3-0006-Expand-xact-SLRU-IO-error-to-show-epoch.patch)
download | inline diff:
From 0929999480cbcf901681c34bf3d7c18ae1c82acc Mon Sep 17 00:00:00 2001
From: Maxim Orlov <[email protected]>
Date: Thu, 26 Feb 2026 16:55:45 +0300
Subject: [PATCH v3 6/6] Expand xact SLRU IO-error to show epoch
---
src/include/access/slru.h | 12 ++++++++++--
1 file changed, 10 insertions(+), 2 deletions(-)
diff --git a/src/include/access/slru.h b/src/include/access/slru.h
index 78ee36c05a6..3ca2e4e92f4 100644
--- a/src/include/access/slru.h
+++ b/src/include/access/slru.h
@@ -167,8 +167,16 @@ static inline int
xact_errmsg_for_io_error(const void *opaque_data)
{
if (opaque_data)
- return errmsg("could not access status of transaction %u",
- *(TransactionId *) opaque_data);
+ {
+ FullTransactionId fxid;
+
+ fxid = FullTransactionIdFromAllowableAt(ReadNextFullTransactionId(),
+ *(TransactionId *) opaque_data);
+
+ return errmsg("could not access status of transaction %u:%u",
+ EpochFromFullTransactionId(fxid),
+ XidFromFullTransactionId(fxid));
+ }
return errmsg("could not access slru entry"); /* InvalidTransactionId */
}
--
2.43.0
view thread (2+ messages) latest in thread
reply
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Reply to all the recipients using the --to and --cc options:
reply via email
To: [email protected]
Cc: [email protected], [email protected]
Subject: Re: Rework SLRU I/O errors handle
In-Reply-To: <CACG=ezZZfurhYV+66ceubxQAyWqv9vaUi0yoO4-t48OE5xc0DQ@mail.gmail.com>
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox