Date: Fri, 03 Oct 2025 21:19:57 +0900 (JST)
Message-Id: <20251003.211957.2067537305399895611.ishii@postgresql.org>
To: pgpool@list.imperialat.at
Cc: pgpool-hackers@lists.postgresql.org
Subject: Re: [pgpool-hackers: 4583] Fix time_t warnings on OpenBSD
From: Tatsuo Ishii <ishii@postgresql.org>
In-Reply-To: 
 <050e2e86b048f6371d9ee65a5195402678bec50b.camel@list.imperialat.at>
References: 
 <050e2e86b048f6371d9ee65a5195402678bec50b.camel@list.imperialat.at>
Mime-Version: 1.0
Content-Type: Multipart/Mixed;
 boundary="--Next_Part(Fri_Oct__3_21_19_57_2025_512)--"
Content-Transfer-Encoding: 7bit
Archived-At: 
 <https://www.postgresql.org/message-id/20251003.211957.2067537305399895611.ishii%40postgresql.org>
Precedence: bulk

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

Hello Martijn,

Sorry for not responding earlier.  (I have replied on the new
pgpool-hackers mailing list. We have migrated from pgpool.net ML to
PostgreSQL.org ML in July 2025).

I have read through your first patch (posted on 03 May 2025) again and
have started to think that upcasting time calculations to long long is
a good idea. So I rebased the patch against master branch. See
attached patch.

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

From: Martijn van Duren <pgpool@list.imperialat.at>
Subject: [pgpool-hackers: 4583] Fix time_t warnings on OpenBSD
Date: Sat, 03 May 2025 16:20:09 +0200
Message-ID: <050e2e86b048f6371d9ee65a5195402678bec50b.camel@list.imperialat.at>

> Hello all,
> 
> On OpenBSD time_t is defined as __int64_t (which basically always
> results into long long). This causes a lots of compile time warnings
> since pgpool's code expects time_t to be a simple long in a lot of
> places.
> 
> POSIX defines time_t as "time_t shall be an integer type". So no
> definition of signedness or size. Since it would be dumb to make it
> unsigned (would be no pre-1970) and I know of no unsigned time_t
> based system I reckon it's safe to assume time_t to be always signed.
> For the size I would like to propose to always upcast to long long.
> This way times can't get truncated and for the places where time_t
> is actually used as a time and not a time diff this would allow pgpool
> to keep working correctly post Y2038 on 64 bit clean time_t systems
> post Y2038 (e.g. i386 OpenBSD).
> 
> While here I also changed json_get_long_value_for_key to
> json_get_llong_value_for_key and changed the parameter to long long.
> This makes it more in line _json_value's integer, which is defined as
> int64. This should also give 32 bit platforms proper retrieval of the
> max value of an integer and may or may not solve some weird integer
> overflow issues.
> 
> Mildly tested.
> Compile tested on:
> - AMD64 OpenBSD-current clang 16.0.6
> - AMD64 OpenBSD-current gcc 11.2.0
> - AMD64 Debian trixie/sid gcc 14.2.0
> 
> martijn@
> 
> [0] https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_types.h.html
> 
> diff 0ac97e82e90b360632fc6d479ff331375fb619f7 1967584b6bc2b01f6749a32f342d04ba38715512
> commit - 0ac97e82e90b360632fc6d479ff331375fb619f7
> commit + 1967584b6bc2b01f6749a32f342d04ba38715512
> blob - 67cc0255a789499bfa83abd0369af22436387221
> blob + 7e24382e70282401aca03400722368096784fdad
> --- src/include/utils/json.h
> +++ src/include/utils/json.h
> @@ -313,7 +313,7 @@ extern "C"
>  /* pgpool-II extensions */
>  json_value *json_get_value_for_key(json_value * source, const char *key);
>  int			json_get_int_value_for_key(json_value * source, const char *key, int *value);
> -int			json_get_long_value_for_key(json_value * source, const char *key, long *value);
> +int			json_get_llong_value_for_key(json_value * source, const char *key, long long *value);
>  char	   *json_get_string_value_for_key(json_value * source, const char *key);
>  int			json_get_bool_value_for_key(json_value * source, const char *key, bool *value);
>  
> blob - 34c5b9ac6615bd990c829b78478a901bd91ce431
> blob + dd788da7f963dfed71455deb6428e4de66990e98
> --- src/include/watchdog/wd_commands.h
> +++ src/include/watchdog/wd_commands.h
> @@ -52,7 +52,7 @@ typedef struct WDGenericData
>  		char	   *stringVal;
>  		int			intVal;
>  		bool		boolVal;
> -		long		longVal;
> +		long long	longVal;
>  	}			data;
>  }			WDGenericData;
>  
> blob - 7b53999ee3342459cb5beb43007dd054b5f84822
> blob + 4ad49101647be6a30804da1aa969e83262781c61
> --- src/include/watchdog/wd_json_data.h
> +++ src/include/watchdog/wd_json_data.h
> @@ -51,8 +51,8 @@ extern bool parse_node_status_json(char *json_data, in
>  
>  
>  extern bool parse_beacon_message_json(char *json_data, int data_len, int *state,
> -						  long *seconds_since_node_startup,
> -						  long *seconds_since_current_state,
> +						  long long *seconds_since_node_startup,
> +						  long long *seconds_since_current_state,
>  						  int *quorumStatus,
>  						  int *standbyNodesCount,
>  						  bool *escalated);
> blob - 2060867322a0105103161e72c71d98e8886a4961
> blob + 21c67a83898266559463650ab37e516cfa1aba27
> --- src/main/pgpool_logger.c
> +++ src/main/pgpool_logger.c
> @@ -50,7 +50,7 @@
>  #include "main/pgpool_logger.h"
>  
>  #define DEVNULL "/dev/null"
> -typedef int64 pg_time_t;
> +typedef time_t pg_time_t;
>  /*
>   * We read() into a temp buffer twice as big as a chunk, so that any fragment
>   * left after processing can be moved down to the front and we'll still have
> blob - de2658d5e2b657b75c37ecd3025fdaae4956d7e9
> blob + ddd892afd9c4d1ed497992ff59bae70090259cbb
> --- src/pcp_con/pcp_worker.c
> +++ src/pcp_con/pcp_worker.c
> @@ -933,9 +933,9 @@ inform_node_info(PCP_CONNECTION * frontend, char *buf)
>  
>  			snprintf(standby_delay_by_time_str, sizeof(standby_delay_by_time_str), "%d", bi->standby_delay_by_time);
>  
> -			snprintf(standby_delay_str, sizeof(standby_delay_str), UINT64_FORMAT, bi->standby_delay);
> +			snprintf(standby_delay_str, sizeof(standby_delay_str), "%lld", (long long)bi->standby_delay);
>  
> -			snprintf(status_changed_time_str, sizeof(status_changed_time_str), UINT64_FORMAT, bi->status_changed_time);
> +			snprintf(status_changed_time_str, sizeof(status_changed_time_str), "%lld", (long long)bi->status_changed_time);
>  
>  			pcp_write(frontend, "i", 1);
>  			wsize = htonl(sizeof(code) +
> blob - d7e1857a42350065b98ff567a349003ec7102c3d
> blob + 76937d681ee0e0c55a2ea8463e46edf46d0d4474
> --- src/protocol/pool_connection_pool.c
> +++ src/protocol/pool_connection_pool.c
> @@ -299,10 +299,10 @@ pool_create_cp(void)
>  
>  		ereport(DEBUG1,
>  				(errmsg("creating connection pool"),
> -				 errdetail("user: %s database: %s closetime: %ld",
> +				 errdetail("user: %s database: %s closetime: %lld",
>  						   CONNECTION_SLOT(p, main_node_id)->sp->user,
>  						   CONNECTION_SLOT(p, main_node_id)->sp->database,
> -						   CONNECTION_SLOT(p, main_node_id)->closetime)));
> +						   (long long)CONNECTION_SLOT(p, main_node_id)->closetime)));
>  
>  		if (CONNECTION_SLOT(p, main_node_id)->closetime < closetime)
>  		{
> @@ -363,7 +363,7 @@ pool_connection_pool_timer(POOL_CONNECTION_POOL * back
>  
>  	ereport(DEBUG1,
>  			(errmsg("setting backend connection close timer"),
> -			 errdetail("close time %ld", time(NULL))));
> +			 errdetail("close time %lld", (long long)time(NULL))));
>  
>  	/* Set connection close time */
>  	for (i = 0; i < NUM_BACKENDS; i++)
> @@ -421,7 +421,7 @@ pool_backend_timer(void)
>  	now = time(NULL);
>  
>  	ereport(DEBUG1,
> -			(errmsg("backend timer handler called at %ld", now)));
> +			(errmsg("backend timer handler called at %lld", (long long)now)));
>  
>  	for (i = 0; i < pool_config->max_pool; i++, p++)
>  	{
> @@ -439,8 +439,8 @@ pool_backend_timer(void)
>  
>  			ereport(DEBUG1,
>  					(errmsg("backend timer handler called"),
> -					 errdetail("expire time: %ld",
> -							   MAIN_CONNECTION(p)->closetime + pool_config->connection_life_time)));
> +					 errdetail("expire time: %lld",
> +							   (long long)(MAIN_CONNECTION(p)->closetime + pool_config->connection_life_time))));
>  
>  			if (now >= (MAIN_CONNECTION(p)->closetime + pool_config->connection_life_time))
>  			{
> blob - cc702074d38c1879dbb3ee77cd5af0e66518d642
> blob + 616aa085a7845fcbea5a11b185cd41bad0b3ff41
> --- src/query_cache/pool_memqcache.c
> +++ src/query_cache/pool_memqcache.c
> @@ -280,7 +280,7 @@ pool_commit_cache(POOL_CONNECTION_POOL * backend, char
>  	memqcache_expire = pool_config->memqcache_expire;
>  	ereport(DEBUG1,
>  			(errmsg("committing SELECT results to cache storage"),
> -			 errdetail("memqcache_expire = %ld", memqcache_expire)));
> +			 errdetail("memqcache_expire = %lld", (long long)memqcache_expire)));
>  
>  	if (pool_is_shmem_cache())
>  	{
> @@ -390,7 +390,7 @@ pool_catalog_commit_cache(POOL_CONNECTION_POOL * backe
>  	memqcache_expire = pool_config->relcache_expire;
>  	ereport(DEBUG1,
>  			(errmsg("committing relation cache to cache storage"),
> -			 errdetail("memqcache_expire = %ld", memqcache_expire)));
> +			 errdetail("memqcache_expire = %lld", (long long)memqcache_expire)));
>  
>  	if (pool_is_shmem_cache())
>  	{
> @@ -2887,8 +2887,8 @@ static POOL_CACHEID * pool_find_item_on_shmem_cache(PO
>  			{
>  				ereport(DEBUG1,
>  						(errmsg("memcache finding item"),
> -						 errdetail("cache expired: now: %ld timestamp: %ld",
> -								   now, cih->timestamp + cih->expire)));
> +						 errdetail("cache expired: now: %lld timestamp: %lld",
> +								   (long long)now, (long long)(cih->timestamp + cih->expire))));
>  				pool_delete_item_shmem_cache(c);
>  				return NULL;
>  			}
> blob - 319c8fdbfe62e0b6ed071b53dd12f6591ab53610
> blob + 9336fde0f2aab7fca098831da63c92e4775be38a
> --- src/utils/json.c
> +++ src/utils/json.c
> @@ -1191,7 +1191,7 @@ json_get_int_value_for_key(json_value * source, const 
>  }
>  
>  int
> -json_get_long_value_for_key(json_value * source, const char *key, long *value)
> +json_get_llong_value_for_key(json_value * source, const char *key, long long *value)
>  {
>  	json_value *jNode;
>  
> blob - 71f871bc4222600d13d217bb6fc868c8406c7863
> blob + 59109994ac929dc4791688dfe9773e27b731b853
> --- src/utils/pool_process_reporting.c
> +++ src/utils/pool_process_reporting.c
> @@ -2052,7 +2052,7 @@ get_health_check_stats(int *nrows)
>  
>  		/* status last changed */
>  		t = bi->status_changed_time;
> -		ereport(LOG,(errmsg("status_changed_time %ld", t)));
> +		ereport(LOG,(errmsg("status_changed_time %lld", (long long)t)));
>  		strftime(stats[i].last_status_change, POOLCONFIG_MAXDATELEN, "%F %T", localtime(&t));
>  
>  		snprintf(stats[i].total_count, POOLCONFIG_MAXLONGCOUNTLEN, UINT64_FORMAT, health_check_stats[i].total_count);
> blob - 32362fc6baae4f85be6953ef6a1bd70f2600211d
> blob + 1701cb5417d8f3e2f9a7f3756fccdb8f3917fd1a
> --- src/utils/pool_relcache.c
> +++ src/utils/pool_relcache.c
> @@ -187,7 +187,7 @@ pool_search_relcache(POOL_RELCACHE * relcache, POOL_CO
>  				{
>  					ereport(DEBUG1,
>  							(errmsg("searching relcache"),
> -							 errdetail("relcache for database:%s table:%s expired. now:%ld expiration time:%ld", dbname, table, now, relcache->cache[i].expire)));
> +							 errdetail("relcache for database:%s table:%s expired. now:%lld expiration time:%lld", dbname, table, (long long)now, (long long)relcache->cache[i].expire)));
>  
>  					relcache->cache[i].refcnt = 0;
>  					break;
> blob - faab4e6e5b8cd07c20226f3ed81b6cff7901740d
> blob + 83b78baa88ccc991b20989e540657b09ddbd8a76
> --- src/watchdog/watchdog.c
> +++ src/watchdog/watchdog.c
> @@ -6656,8 +6656,8 @@ watchdog_state_machine_nw_isolation(WD_EVENTS event, W
>  static bool
>  beacon_message_received_from_node(WatchdogNode * wdNode, WDPacketData * pkt)
>  {
> -	long		seconds_since_node_startup;
> -	long		seconds_since_current_state;
> +	long long	seconds_since_node_startup;
> +	long long	seconds_since_current_state;
>  	int			quorum_status;
>  	int			standby_nodes_count;
>  	bool		escalated;
> blob - 145955865d1941a877ee33999777b4943972d43d
> blob + c5cd1dcff18aa8beb52d9fbaa51508e118fffb76
> --- src/watchdog/wd_commands.c
> +++ src/watchdog/wd_commands.c
> @@ -193,9 +193,9 @@ get_wd_runtime_variable_value(char* wd_authkey, char *
>  
>  			case VALUE_DATA_TYPE_LONG:
>  				{
> -					long		longVal;
> +					long long	longVal;
>  
> -					if (json_get_long_value_for_key(root, WD_JSON_KEY_VALUE_DATA, &longVal))
> +					if (json_get_llong_value_for_key(root, WD_JSON_KEY_VALUE_DATA, &longVal))
>  					{
>  						ereport(WARNING,
>  								(errmsg("get runtime variable value from watchdog failed"),
> blob - c13e12b6c1b6de597dd6bd21ff1a2ddd033fdf5c
> blob + eab204fa826094edeed3e1cda4afc925c4a060a5
> --- src/watchdog/wd_heartbeat.c
> +++ src/watchdog/wd_heartbeat.c
> @@ -854,8 +854,8 @@ packet_to_string_hb(WdHbPacket * pkt, char *str, int m
>  {
>  	int			len;
>  
> -	len = snprintf(str, maxlen, "tv_sec=%ld tv_usec=%ld from=%s",
> -				   pkt->send_time.tv_sec, pkt->send_time.tv_usec, pkt->from);
> +	len = snprintf(str, maxlen, "tv_sec=%lld tv_usec=%lld from=%s",
> +				   (long long)pkt->send_time.tv_sec, (long long)pkt->send_time.tv_usec, pkt->from);
>  
>  	return len;
>  }
> blob - 474fc37a495ea541cb1cc8c7a05ed8161a607e29
> blob + 602e3bfbefcd2ef8c630ef13301feb5687637914
> --- src/watchdog/wd_json_data.c
> +++ src/watchdog/wd_json_data.c
> @@ -530,6 +530,7 @@ get_watchdog_node_from_json(char *json_data, int data_
>  {
>  	json_value *root = NULL;
>  	char	   *ptr;
> +	long long	longVal;
>  	WatchdogNode *wdNode = palloc0(sizeof(WatchdogNode));
>  
>  	root = json_parse(json_data, data_len);
> @@ -537,19 +538,20 @@ get_watchdog_node_from_json(char *json_data, int data_
>  	if (root == NULL || root->type != json_object)
>  		goto ERROR_EXIT;
>  
> -	if (json_get_long_value_for_key(root, "StartupTimeSecs", &wdNode->startup_time.tv_sec))
> +	if (json_get_llong_value_for_key(root, "StartupTimeSecs", &longVal))
>  	{
>  		bool		escalated;
> -		long		seconds_since_node_startup;
> -		long		seconds_since_current_state;
> +		long long	seconds_since_node_startup;
> +		long long	seconds_since_current_state;
>  		struct timeval current_time;
>  
> +		wdNode->startup_time.tv_sec = longVal;
>  		gettimeofday(&current_time, NULL);
>  
>  		/* The new version does not have StartupTimeSecs Key */
> -		if (json_get_long_value_for_key(root, "SecondsSinceStartup", &seconds_since_node_startup))
> +		if (json_get_llong_value_for_key(root, "SecondsSinceStartup", &seconds_since_node_startup))
>  			goto ERROR_EXIT;
> -		if (json_get_long_value_for_key(root, "SecondsSinceCurrentState", &seconds_since_current_state))
> +		if (json_get_llong_value_for_key(root, "SecondsSinceCurrentState", &seconds_since_current_state))
>  			goto ERROR_EXIT;
>  		if (json_get_bool_value_for_key(root, "Escalated", &escalated))
>  			goto ERROR_EXIT;
> @@ -640,8 +642,8 @@ ERROR_EXIT:
>  bool
>  parse_beacon_message_json(char *json_data, int data_len,
>  						  int *state,
> -						  long *seconds_since_node_startup,
> -						  long *seconds_since_current_state,
> +						  long long *seconds_since_node_startup,
> +						  long long *seconds_since_current_state,
>  						  int *quorumStatus,
>  						  int *standbyNodesCount,
>  						  bool *escalated)
> @@ -655,9 +657,9 @@ parse_beacon_message_json(char *json_data, int data_le
>  
>  	if (json_get_int_value_for_key(root, "State", state))
>  		goto ERROR_EXIT;
> -	if (json_get_long_value_for_key(root, "SecondsSinceStartup", seconds_since_node_startup))
> +	if (json_get_llong_value_for_key(root, "SecondsSinceStartup", seconds_since_node_startup))
>  		goto ERROR_EXIT;
> -	if (json_get_long_value_for_key(root, "SecondsSinceCurrentState", seconds_since_current_state))
> +	if (json_get_llong_value_for_key(root, "SecondsSinceCurrentState", seconds_since_current_state))
>  		goto ERROR_EXIT;
>  	if (json_get_bool_value_for_key(root, "Escalated", escalated))
>  		goto ERROR_EXIT;
> 
> _______________________________________________
> pgpool-hackers mailing list
> pgpool-hackers@pgpool.net
> http://www.pgpool.net/mailman/listinfo/pgpool-hackers

----Next_Part(Fri_Oct__3_21_19_57_2025_512)--
Content-Type: Application/Octet-Stream
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
 filename="v1-0001-Make-time-calculations-always-long-long.patch"
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----Next_Part(Fri_Oct__3_21_19_57_2025_512)----