Date: Sun, 26 Apr 2026 14:56:19 +0900 (JST)
Message-Id: <20260426.145619.2101180528950972824.ishii@postgresql.org>
To: pgpool-hackers@lists.postgresql.org
Subject: Re: Problem with pcp process
From: Tatsuo Ishii <ishii@postgresql.org>
In-Reply-To: <20260425.223051.1207744844622514060.ishii@postgresql.org>
References: <20260425.223051.1207744844622514060.ishii@postgresql.org>
Mime-Version: 1.0
Content-Type: Multipart/Mixed;
 boundary="--Next_Part(Sun_Apr_26_14_56_19_2026_014)--"
Content-Transfer-Encoding: 7bit
Archived-At: 
 <https://www.postgresql.org/message-id/20260426.145619.2101180528950972824.ishii%40postgresql.org>
Precedence: bulk

----Next_Part(Sun_Apr_26_14_56_19_2026_014)--
Content-Type: Text/Plain; charset=us-ascii
Content-Transfer-Encoding: 7bit

> Koshino told me off-list that following script does not work:
> -------------------------------------
> pgpool_setup -n 3 --no-stop
> pg_ctl -D data2 stop
> while true
> do
>     psql -p 11000 -c "show pool_nodes" test
>     if [ $? = 0 ];then
> 	break;
>     fi
>     sleep 1
> done
> psql -p 11000 -c "show pool_nodes" test
> pcp_recovery_node -p 11001 -n 2;pcp_promote_node -p 11001 -n 2 -s -g
> -------------------------------------
> 
> pcp_recovery_node reports success but pcp_promote_node just hangs. I
> found pcp worker process loops infinitely around line 584 in
> pool_detach_node (pcp_worker.c):
> 
> 	while (!pcp_worker_wakeup_request)
> 	{
> 		struct timeval t = {1, 0};
> 
> 		select(0, NULL, NULL, NULL, &t);
> 	}
> 
> pcp_worker_wakeup_request is a variable supposed to be set to 1 by
> SIGUSR2 signal handler. When pgpool main finishes failover requests
> from pcp, it sends SIGUSR2 to pcp main process, then it forwards to
> pcp worker process, and its signal handler sets the variable to 1. To
> find the process id to forward the signal, pcp main process keeps a
> list of pids of forked children (pcp worker process) in its local
> memory.
> 
> Upon failover, pgpool main sends a signal to pcp main process to
> request restarting, and pgpool main restarts. Problem is, when pcp
> main restarts, it forgets the list of pids. As a result, when pgpool
> main sends SIGUSR2 to pcp main, it cannot find the pid to send the
> signal to, which causes the infinite loop in pcp worker process.
> 
> To fix the problem, we could delay the restarting of pcp main until it
> delivers the signal. Unfortunately this does not work, since pgpool
> main waits for pcp main process to exit. Thus processing failover does
> not proceed in pgpool main.
> 
> So I decided to add a new shared memory area to hold the pcp workers
> pids as an array. Upon restarting of pcp main process, it reads the
> pids from the shared memory into its local memory. When child process
> is forked, its pid is added to the shared memory array. When child
> process exits, its pid in the array is cleared to 0, representing an
> empty slot.
> 
> Attached is a patch to implement it.

In the patch there were duplicate for loops in
pcp_child.c:reaper(). Attached v2 patch removes it. Also update
copright year of pcp_child.c.

Regards,
--
Tatsuo Ishii
SRA OSS K.K.
English: http://www.sraoss.co.jp/index_en/
Japanese:http://www.sraoss.co.jp

----Next_Part(Sun_Apr_26_14_56_19_2026_014)--
Content-Type: Application/Octet-Stream
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
 filename="v2-0001-Fix-pcp-main-process-to-remember-child-pids-upon-.patch"
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----Next_Part(Sun_Apr_26_14_56_19_2026_014)----