Content-Type: multipart/mixed; boundary="------------oI5Xg7YJplHC6vtejkzX7ngW"
Message-ID: <25cba756-9459-4811-aeaf-4a8715735c82@postgrespro.ru>
Date: Mon, 25 May 2026 17:20:02 +0300
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: Deadlock detector fails to activate on a hot standby replica
To: Fujii Masao <masao.fujii@gmail.com>
Cc: pgsql-hackers@lists.postgresql.org
References: <44c24dcf-5710-410f-b1b6-d10b315f3d51@postgrespro.ru>
 <b178ea8d-9ed9-48b3-b4f7-5cfc3ff6ee44@postgrespro.ru>
 <CAHGQGwExVv1-mtPEX-JFGBXNY2r8DfP+sQVPD8GpDTefW0KdsQ@mail.gmail.com>
Content-Language: en-US
From: Vitaly Davydov <v.davydov@postgrespro.ru>
In-Reply-To: 
 <CAHGQGwExVv1-mtPEX-JFGBXNY2r8DfP+sQVPD8GpDTefW0KdsQ@mail.gmail.com>
Archived-At: 
 <https://www.postgresql.org/message-id/25cba756-9459-4811-aeaf-4a8715735c82%40postgrespro.ru>
Precedence: bulk

This is a multi-part message in MIME format.
--------------oI5Xg7YJplHC6vtejkzX7ngW
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit

Dear Fujii Masao,

Thank you for the review of the patch. Based on your comments I propose
a new version of the patch.

 > +#include "storage/buf_internals.h"
 > This include should be placed in alphabetical order.

I removed the include of the header file. I'm not sure, that it is a good
way to expose buffer internals here. Instead, I implemented a new function
BufferGetRefCount to be used in standby.c.

 > + uint32 buf_refcount = BUF_STATE_GET_REFCOUNT(buf_state);
 > <snip>
 > + if (buf_refcount > 1)
 > + continue;
 >
 > Wouldn't it be better to check explicitly whether we're still the waiter,
 > instead of using BUF_STATE_GET_REFCOUNT()?
 >
 >     (buf_state & BM_PIN_COUNT_WAITER) != 0 &&
 >     bufHdr->wait_backend_pgprocno == MyProcNumber

This is a precondition for the ResolveRecoveryConflictWithBufferPin function
that the current process should be a waiter process. See LockBufferForCleanup
where this state is set before the call of ResolveRecoveryConflictWithBufferPin.
I believe, there is no sense to check the waiter state because it doesn't
change in this function. Instead, I think, it is enough to just check for
refcount. One of the suggestions is to add an assert to check that the current
process is a waiter process, but I'm not sure about it. Let me know please if
I missed anything.

 > The current control flow in the loop feels a bit hard to follow.
 > Would something like the following be simpler?

I reorganized the control flow as well.

I also added a new tap-test as a part of the patch. I did some changes in the
tap test to make it stable. Let me know, please, if it should be in a separate
commit.

With best regards,
Vitaly
--------------oI5Xg7YJplHC6vtejkzX7ngW
Content-Type: text/x-patch; charset=UTF-8;
 name="v2-0001-Fix-deadlock-detector-activation-in-a-recovery-confl.patch"
Content-Disposition: attachment;
 filename*0="v2-0001-Fix-deadlock-detector-activation-in-a-recovery-confl";
 filename*1=".patch"
Content-Transfer-Encoding: base64
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==

--------------oI5Xg7YJplHC6vtejkzX7ngW--