MIME-Version: 1.0
References: 
 <CAHGQGwFzNYroAxSoyJhqTU-pH=t4Ej6RyvhVmBZ91Exj_TPMMQ@mail.gmail.com>
 <CAA4eK1+CrQNqiPDKv1wYfdkbX0FARJoi1=0ioaAqkLzbq2vG1w@mail.gmail.com>
 <CAHGQGwHABvuCoyM24HUiFZ5oJq_CoFomjt_cqD-0cJLMjFXJjQ@mail.gmail.com>
 <CAA4eK1LzZGfRANPAnv6NpKCH2ENuZO6HswgY14A=xsOXmucPhw@mail.gmail.com>
 <CABdArM6nepct0uxizCnZqy-kAjjTOndvu7bWtaNcmknuxx82Hg@mail.gmail.com>
 <CAJpy0uBhJB4HqouLXegD=miSkZfZp86tTC2K0K6nf=bHCcsPLQ@mail.gmail.com>
In-Reply-To: 
 <CAJpy0uBhJB4HqouLXegD=miSkZfZp86tTC2K0K6nf=bHCcsPLQ@mail.gmail.com>
From: Nisha Moond <nisha.moond412@gmail.com>
Date: Fri, 27 Mar 2026 10:27:43 +0530
Message-ID: 
 <CABdArM6Mfhk2+9TVR_D3cgfPWPfHDuZEg7MOc5KqULwt0OcQUg@mail.gmail.com>
Subject: Re: Use SIGTERM instead of SIGUSR1 for slotsync worker to exit during
 promotion?
To: shveta malik <shveta.malik@gmail.com>
Cc: Amit Kapila <amit.kapila16@gmail.com>,
 Fujii Masao <masao.fujii@gmail.com>,
	PostgreSQL Hackers <pgsql-hackers@lists.postgresql.org>
Content-Type: multipart/mixed; boundary="0000000000001ef2e3064dfa58d4"
Archived-At: 
 <https://www.postgresql.org/message-id/CABdArM6Mfhk2%2B9TVR_D3cgfPWPfHDuZEg7MOc5KqULwt0OcQUg%40mail.gmail.com>
Precedence: bulk

--0000000000001ef2e3064dfa58d4
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Fri, Mar 27, 2026 at 9:28=E2=80=AFAM shveta malik <shveta.malik@gmail.co=
m> wrote:
>
> On Thu, Mar 26, 2026 at 4:08=E2=80=AFPM Nisha Moond <nisha.moond412@gmail=
.com> wrote:
> >
> > On Thu, Mar 26, 2026 at 3:40=E2=80=AFPM Amit Kapila <amit.kapila16@gmai=
l.com> wrote:
> > >
> > > On Mon, Mar 23, 2026 at 11:21=E2=80=AFAM Fujii Masao <masao.fujii@gma=
il.com> wrote:
> > > >
> > > > On Sun, Mar 22, 2026 at 1:52=E2=80=AFAM Amit Kapila <amit.kapila16@=
gmail.com> wrote:
> > > > >
> > > > > On Wed, Mar 18, 2026 at 9:35=E2=80=AFPM Fujii Masao <masao.fujii@=
gmail.com> wrote:
> > > > > >
> > > > > > I noticed that during standby promotion the startup process sen=
ds SIGUSR1 to
> > > > > > the slotsync worker to make it exit. Is there a reason for usin=
g SIGUSR1?
> > > > > >
> > > > >
> > > > > IIRC, this same signal is used for both the backend executing
> > > > > pg_sync_replication_slots() and slotsync worker. We want the work=
er to
> > > > > exit and error_out backend. Using SIGTERM for backend could resul=
t in
> > > > > its exit.
> > > >
> > > > Why do we want the backend running pg_sync_replication_slots() to t=
hrow
> > > > an error here, rather than just exit? If emitting an error is reall=
y required,
> > > > another option would be to store the process type in SlotSyncCtx an=
d send
> > > > different signals accordingly, for example, SIGTERM for the slotsyn=
c worker
> > > > and another signal for a backend. But it seems simpler and sufficie=
nt to have
> > > > the backend exit in this case as well.
> > > >
> > >
> > > As we want to retain the existing behavior for API, so instead of
> > > using two signals, we can achieve what you intend to achieve by one
> > > signal (SIGUSR1) only. We can use SendProcSignal mechanism as is used
> > > ParallelWorkerShutdown. On promotion, we send a SIGUSR1 signal to
> > > slotsync worker/backend via SendProcSignal. Then in
> > > procsignal_sigusr1_handler(), it will call HandleSlotSyncInterrupt.
> > > HandleSlotSyncInterrupt() will set the InterruptPending and
> > > SlotSyncPending flag. Then ProcessInterrupt() will call a slotsync
> > > specific function based on the flag and do what we currently do in
> > > ProcessSlotSyncInterrupts. I think this should address the issue you
> > > are worried about.
> > >
> >
> > +1
> > Retaining the current behavior for the API backend keeps it consistent
> > with other backends that continue after promotion.
> >
> > In the reproduced case, the worker (or API backend) is waiting in:
> > libpqsrv_get_result -> WaitLatchOrSocket -> WaitEventSetWait.
> > When SIGUSR1 is received, it only sets the latch but does not mark any
> > interrupt as pending. As a result, CHECK_FOR_INTERRUPTS() is
> > effectively a no-op, and the process goes back to waiting. So, control
> > never returns to the slotsync code path, and we cannot rely on
> > stopSignaled to handle exit/error separately.
> > Only SIGTERM works here because its handler sets
> > INTERRUPTS_PENDING_CONDITION, allowing ProcessInterrupts() to run and
> > break the loop. The other signals like SIGUSR1 or SIGINT do not do
> > this, so simply using another signal might not solve the API error
> > handling case.
> >
> > I=E2=80=99ve implemented the above approach suggested by Amit in the at=
tached
> > patch and verified it for both worker and API scenarios. With this,
> > the API can now error-out without exiting the backend.
> >
>
> +1 on the idea. Few comments:
>

Thanks for the review.

> 1)
> It was not clear initially as to why SetLatch is not done in
> HandleSlotSyncShutdownInterrupt(), digging it further revealed that
> procsignal_sigusr1_handler() will do SetLatch outside. Perhaps you can
> add below comment at the end of HandleSlotSyncShutdownInterrupt()
> similar to how other functions (HandleProcSignalBarrierInterrupt,
> HandleRecoveryConflictInterrupt etc) do.
>
> /* latch will be set by procsignal_sigusr1_handler */
>

Fixed.

> 2)
> In ProcessSlotSyncInterrupts(), now we don't need the below logic right?
>
> if (SlotSyncCtx->stopSignaled)
>     {
>         if (AmLogicalSlotSyncWorkerProcess())
>         {
>             ...
>             proc_exit(0);
>         }
>         else
>         {
>             /*
>              * For the backend executing SQL function
>              * pg_sync_replication_slots().
>              */
>             ereport(ERROR,
>                     errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
>                     errmsg("replication slot synchronization will stop
> because promotion is triggered"));
>         }
>     }
>

Right. Attached patch with the suggested changes.

--
Thanks,
Nisha

--0000000000001ef2e3064dfa58d4
Content-Type: application/octet-stream;
	name="v3-0001-Prevent-slotsync-worker-API-hang-during-standby-p.patch"
Content-Disposition: attachment;
	filename="v3-0001-Prevent-slotsync-worker-API-hang-during-standby-p.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mn8fivev0>
X-Attachment-Id: f_mn8fivev0
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--0000000000001ef2e3064dfa58d4--