MIME-Version: 1.0
From: Srinath Reddy Sadipiralla <srinath2133@gmail.com>
Date: Fri, 10 Jul 2026 09:48:33 +0530
Message-ID: 
 <CAFC+b6oYzmAgp7F0ivrhfZT46-CjvCTrU9pWuMNcem-52YjOTw@mail.gmail.com>
Subject: Fix "unexpected logical decoding status change" error; from
 concurrent logical decoding activation
To: PostgreSQL Hackers <pgsql-hackers@lists.postgresql.org>
Cc: Masahiko Sawada <sawada.mshk@gmail.com>
Content-Type: multipart/mixed; boundary="00000000000055fd5606563a0979"
Archived-At: 
 <https://www.postgresql.org/message-id/CAFC%2Bb6oYzmAgp7F0ivrhfZT46-CjvCTrU9pWuMNcem-52YjOTw%40mail.gmail.com>
Precedence: bulk

--00000000000055fd5606563a0979
Content-Type: multipart/alternative; boundary="00000000000055fd5506563a0977"

--00000000000055fd5506563a0977
Content-Type: text/plain; charset="UTF-8"

Hi,

While stress-testing REPACK CONCURRENTLY, I was in that
area looking at BUG #19519 (REPACK failing with "missingchunk
number N for toast value" [0]; note that one reproduces with plain
REPACK too, since it's the shared copy_table_data() path, so
it's independent of what follows), I hit a different, reproducible
failure under high concurrency:
    ERROR:  unexpected logical decoding status change 1

I believe this is a race bug in the on-demand logical decoding
activation machinery (logicalctl.c), exposed by
REPACK CONCURRENTLY but not actually specific to it, as
this can be reproduced using pg_create_logical_replication_slot
and CREATE_REPLICATION_SLOT.

At wal_level = 'replica', logical decoding is toggled on the first time a
logical slot is created.  EnableLogicalDecoding() sets the shared
logical_decoding_enabled flag and writes an
XLOG_LOGICAL_DECODING_STATUS_CHANGE record so standbys
learn about the change.  On the decoding side, xlog_decode() treats
that record as unreachable:
elog(ERROR, "unexpected logical decoding status change %d", ...);

The reasoning (per the comment there) is that no running decoder can ever
have such a record within the LSN range it scans: there is exactly one
enable record per disabled->enabled transition, and it precedes the
decoding start point reserved by any slot.

That case does not hold under concurrency.  EnableLogicalDecoding()
does:

    LWLockAcquire(LogicalDecodingControlLock, EXCLUSIVE);
    if (logical_decoding_enabled)     /* already on? -> done */
        { ... return; }
    LWLockRelease(...);

    WaitForProcSignalBarrier(...);    /* lock released here */

    LWLockAcquire(LogicalDecodingControlLock, EXCLUSIVE);
    logical_decoding_enabled = true;
    write_logical_decoding_status_update_record(true);   /* the record */
    LWLockRelease(...);

The "already enabled?" check and the record write happen under two
separate lock acquisitions, with the barrier wait in between.  The lock
must be dropped across the barrier; backends absorbing the barrier
take LogicalDecodingControlLock in shared mode (via
IsXLogLogicalInfoEnabled()), so holding it across WaitForProcSignalBarrier()
would deadlock.

So if two backends create the first logical slot(s) at the same time,
both can pass the initial check while the flag is still false, and both
end up writing a status-change record.  The second (redundant) record
lands after the decoding start point the other slot already reserved,
so that slot scans it and trips the elog() above.

REPACK CONCURRENTLY makes this easy to hit because each operation
creates a temporary logical slot (max_repack_replication_slots), so firing
many REPACKs in parallel from the disabled state gives you many backends
racing to perform the very first activation.  But nothing here is
REPACK-specific.

To reproduce this i have added a test using logical-decoding-activation
injection point in 051_effective_wal_level.pl

I also hit it with a stress script [1] which was again related to the
BUG #19519, instead of vacuum full i replaced it with REPACK (concurrently).

To fix this I re-checked the flag after re-acquiring the lock and skipped
the state change/WAL write if another backend had already completed
the transition.

    LWLockAcquire(LogicalDecodingControlLock, EXCLUSIVE);

    if (LogicalDecodingCtl->logical_decoding_enabled)
    {
        LogicalDecodingCtl->pending_disable = false;
        LWLockRelease(LogicalDecodingControlLock);
        return;
    }

    START_CRIT_SECTION();

With this, only the backend that actually performs the disabled->enabled
transition writes a record, and every slot's start point stays at or after
it, restoring the case xlog_decode() depends on.

Patch attached.  It fixes logicalctl.c and adds a regression test to
051_effective_wal_level.pl reusing the existing injection-point
infrastructure.  With the fix the test passes; without it it fails with
the exact error above.

[0] -
https://www.postgresql.org/message-id/flat/19519-fe02d8ff679d834d%40postgresql.org
[1] -
https://www.postgresql.org/message-id/18351-f6e06364b3a2e669%40postgresql.org

-- 
Thanks :)
Srinath Reddy Sadipiralla
EDB: https://www.enterprisedb.com/

--00000000000055fd5506563a0977
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div>Hi,<br><br>While stress-testing REPACK CONCURRENTLY, =
I was in that<br>area looking at BUG #19519 (REPACK failing with &quot;miss=
ingchunk<br>number N for toast value&quot; [0]; note that one reproduces wi=
th plain<br>REPACK too, since it&#39;s the shared copy_table_data() path, s=
o<br>it&#39;s independent of what follows), I hit a different, reproducible=
<br>failure under high concurrency:<br>=C2=A0 =C2=A0 ERROR: =C2=A0unexpecte=
d logical decoding status change 1<br><br>I believe this is a race bug in t=
he on-demand logical decoding<br>activation machinery (logicalctl.c), expos=
ed by<br>REPACK CONCURRENTLY but not actually specific to it, as<br>this ca=
n be reproduced using pg_create_logical_replication_slot and=C2=A0CREATE_RE=
PLICATION_SLOT.<br><br>At wal_level =3D &#39;replica&#39;, logical decoding=
 is toggled on the first time a<br>logical slot is created.=C2=A0 EnableLog=
icalDecoding() sets the shared<br>logical_decoding_enabled flag and writes =
an<br>XLOG_LOGICAL_DECODING_STATUS_CHANGE record so standbys<br>learn about=
 the change.=C2=A0 On the decoding side, xlog_decode() treats<br>that recor=
d as unreachable:<br>elog(ERROR, &quot;unexpected logical decoding status c=
hange %d&quot;, ...);<br><br>The reasoning (per the comment there) is that =
no running decoder can ever<br>have such a record within the LSN range it s=
cans: there is exactly one<br>enable record per disabled-&gt;enabled transi=
tion, and it precedes the<br>decoding start point reserved by any slot.<br>=
<br>That case does not hold under concurrency.=C2=A0 EnableLogicalDecoding(=
)<br>does:<br><br>=C2=A0 =C2=A0 LWLockAcquire(LogicalDecodingControlLock, E=
XCLUSIVE);<br>=C2=A0 =C2=A0 if (logical_decoding_enabled) =C2=A0 =C2=A0 /* =
already on? -&gt; done */<br>=C2=A0 =C2=A0 =C2=A0 =C2=A0 { ... return; }<br=
>=C2=A0 =C2=A0 LWLockRelease(...);<br><br>=C2=A0 =C2=A0 WaitForProcSignalBa=
rrier(...); =C2=A0 =C2=A0/* lock released here */<br><br>=C2=A0 =C2=A0 LWLo=
ckAcquire(LogicalDecodingControlLock, EXCLUSIVE);<br>=C2=A0 =C2=A0 logical_=
decoding_enabled =3D true;<br>=C2=A0 =C2=A0 write_logical_decoding_status_u=
pdate_record(true); =C2=A0 /* the record */<br>=C2=A0 =C2=A0 LWLockRelease(=
...);<br><br>The &quot;already enabled?&quot; check and the record write ha=
ppen under two<br>separate lock acquisitions, with the barrier wait in betw=
een.=C2=A0 The lock<br>must be dropped across the barrier; backends absorbi=
ng the barrier<br>take LogicalDecodingControlLock in shared mode (via<br>Is=
XLogLogicalInfoEnabled()), so holding it across WaitForProcSignalBarrier()<=
br>would deadlock.<br><br>So if two backends create the first logical slot(=
s) at the same time,<br>both can pass the initial check while the flag is s=
till false, and both<br>end up writing a status-change record.=C2=A0 The se=
cond (redundant) record<br>lands after the decoding start point the other s=
lot already reserved,<br>so that slot scans it and trips the elog() above.<=
br><br>REPACK CONCURRENTLY makes this easy to hit because each operation<br=
>creates a temporary logical slot (max_repack_replication_slots), so firing=
<br>many REPACKs in parallel from the disabled state gives you many backend=
s<br>racing to perform the very first activation.=C2=A0 But nothing here is=
 REPACK-specific.<br><br>To reproduce this i have added a test using=C2=A0l=
ogical-decoding-activation<br>injection point in <a href=3D"http://051_effe=
ctive_wal_level.pl">051_effective_wal_level.pl</a><br><br>I also hit it wit=
h a stress script [1] which was again related to the<br>BUG #19519, instead=
 of vacuum full i replaced it with=C2=A0REPACK (concurrently).<br><br>To fi=
x this I re-checked the flag after re-acquiring the lock and skipped<br>the=
 state change/WAL write if another backend had already completed<br>the tra=
nsition.<br><br>=C2=A0 =C2=A0 LWLockAcquire(LogicalDecodingControlLock, EXC=
LUSIVE);<br><br>=C2=A0 =C2=A0 if (LogicalDecodingCtl-&gt;logical_decoding_e=
nabled)<br>=C2=A0 =C2=A0 {<br>=C2=A0 =C2=A0 =C2=A0 =C2=A0 LogicalDecodingCt=
l-&gt;pending_disable =3D false;<br>=C2=A0 =C2=A0 =C2=A0 =C2=A0 LWLockRelea=
se(LogicalDecodingControlLock);<br>=C2=A0 =C2=A0 =C2=A0 =C2=A0 return;<br>=
=C2=A0 =C2=A0 }<br><br>=C2=A0 =C2=A0 START_CRIT_SECTION();<br><br>With this=
, only the backend that actually performs the disabled-&gt;enabled<br>trans=
ition writes a record, and every slot&#39;s start point stays at or after<b=
r>it, restoring the case xlog_decode() depends on.<br><br>Patch attached.=
=C2=A0 It fixes logicalctl.c and adds a regression test to<br><a href=3D"ht=
tp://051_effective_wal_level.pl">051_effective_wal_level.pl</a> reusing the=
 existing injection-point<br>infrastructure.=C2=A0 With the fix the test pa=
sses; without it it fails with<br>the exact error above.<br></div><div><br>=
[0] -=C2=A0<a href=3D"https://www.postgresql.org/message-id/flat/19519-fe02=
d8ff679d834d%40postgresql.org">https://www.postgresql.org/message-id/flat/1=
9519-fe02d8ff679d834d%40postgresql.org</a><br>[1] -=C2=A0<a href=3D"https:/=
/www.postgresql.org/message-id/18351-f6e06364b3a2e669%40postgresql.org" tar=
get=3D"_blank">https://www.postgresql.org/message-id/18351-f6e06364b3a2e669=
%40postgresql.org</a><br><br></div><span class=3D"gmail_signature_prefix">-=
- </span><br><div dir=3D"ltr" class=3D"gmail_signature" data-smartmail=3D"g=
mail_signature"><div dir=3D"ltr"><span style=3D"color:rgb(34,34,34)">Thanks=
 :)</span><br style=3D"color:rgb(34,34,34)"><span style=3D"color:rgb(34,34,=
34)">Srinath Reddy Sadipiralla</span><br style=3D"color:rgb(34,34,34)"><spa=
n style=3D"color:rgb(34,34,34)">EDB:=C2=A0</span><a href=3D"https://www.ent=
erprisedb.com/" style=3D"color:rgb(17,85,204)" target=3D"_blank">https://ww=
w.enterprisedb.com/</a></div></div></div>

--00000000000055fd5506563a0977--

--00000000000055fd5606563a0979
Content-Type: application/octet-stream;
	name="v1-0001-Avoid-writing-a-redundant-logical-decoding-status-ch.patch"
Content-Disposition: attachment;
	filename="v1-0001-Avoid-writing-a-redundant-logical-decoding-status-ch.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mref8qr80>
X-Attachment-Id: f_mref8qr80
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==
--00000000000055fd5606563a0979--