From efb7cedda533a9a03acc527a594fae6377119e26 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Sat, 24 Aug 2024 00:58:05 +0300 Subject: [PATCH 09/11] Replace all remaining Latch calls with new Interrupt calls This is a mechanical patch that replaces all remaining Latch calls, and removes the "latch.h" compatibility macros. XXX: We might want to keep the compatibility macros for extensions though. --- contrib/pg_prewarm/autoprewarm.c | 20 +++--- contrib/postgres_fdw/connection.c | 22 +++--- contrib/postgres_fdw/postgres_fdw.c | 2 +- src/backend/access/heap/vacuumlazy.c | 11 +-- src/backend/access/transam/parallel.c | 20 +++--- src/backend/access/transam/xlogfuncs.c | 12 ++-- src/backend/backup/basebackup_throttle.c | 14 ++-- src/backend/commands/async.c | 3 +- src/backend/commands/vacuum.c | 4 +- src/backend/executor/nodeGather.c | 8 ++- src/backend/libpq/auth.c | 8 +-- src/backend/libpq/be-secure-gssapi.c | 18 ++--- src/backend/libpq/be-secure-openssl.c | 6 +- src/backend/libpq/pqmq.c | 7 +- src/backend/libpq/pqsignal.c | 2 +- src/backend/postmaster/autovacuum.c | 22 +++--- src/backend/postmaster/bgworker.c | 18 ++--- src/backend/postmaster/bgwriter.c | 17 ++--- src/backend/postmaster/syslogger.c | 16 ++--- src/backend/postmaster/walsummarizer.c | 25 +++---- .../libpqwalreceiver/libpqwalreceiver.c | 32 ++++----- .../replication/logical/applyparallelworker.c | 37 +++++----- src/backend/replication/logical/launcher.c | 43 ++++++------ src/backend/replication/logical/slotsync.c | 23 ++++--- src/backend/replication/logical/tablesync.c | 29 ++++---- src/backend/replication/logical/worker.c | 15 +++-- src/backend/replication/syncrep.c | 7 +- src/backend/replication/walreceiver.c | 23 ++++--- src/backend/replication/walreceiverfuncs.c | 2 +- src/backend/storage/buffer/bufmgr.c | 1 + src/backend/storage/buffer/freelist.c | 25 ++++--- src/backend/storage/ipc/procsignal.c | 4 +- src/backend/storage/ipc/signalfuncs.c | 11 +-- src/backend/storage/ipc/sinval.c | 4 +- src/backend/storage/ipc/standby.c | 5 +- src/backend/storage/lmgr/condition_variable.c | 9 +-- src/backend/storage/lmgr/predicate.c | 1 + src/backend/storage/sync/sync.c | 2 +- src/backend/tcop/postgres.c | 9 +-- src/backend/utils/adt/misc.c | 26 +++---- src/backend/utils/adt/timestamp.c | 4 +- src/backend/utils/init/postinit.c | 11 +-- src/backend/utils/misc/timeout.c | 4 +- src/include/libpq/libpq-be-fe-helpers.h | 45 +++++++------ src/include/storage/latch.h | 67 ------------------- src/include/storage/proc.h | 1 - src/port/pgsleep.c | 6 +- src/test/modules/worker_spi/worker_spi.c | 12 ++-- 48 files changed, 335 insertions(+), 378 deletions(-) delete mode 100644 src/include/storage/latch.h diff --git a/contrib/pg_prewarm/autoprewarm.c b/contrib/pg_prewarm/autoprewarm.c index d061731706..4dbce7673b 100644 --- a/contrib/pg_prewarm/autoprewarm.c +++ b/contrib/pg_prewarm/autoprewarm.c @@ -39,8 +39,8 @@ #include "storage/dsm.h" #include "storage/dsm_registry.h" #include "storage/fd.h" +#include "storage/interrupt.h" #include "storage/ipc.h" -#include "storage/latch.h" #include "storage/lwlock.h" #include "storage/proc.h" #include "storage/procsignal.h" @@ -223,10 +223,10 @@ autoprewarm_main(Datum main_arg) if (autoprewarm_interval <= 0) { /* We're only dumping at shutdown, so just wait forever. */ - (void) WaitLatch(MyLatch, - WL_LATCH_SET | WL_EXIT_ON_PM_DEATH, - -1L, - PG_WAIT_EXTENSION); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_EXIT_ON_PM_DEATH, + -1L, + PG_WAIT_EXTENSION); } else { @@ -250,14 +250,14 @@ autoprewarm_main(Datum main_arg) } /* Sleep until the next dump time. */ - (void) WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - delay_in_ms, - PG_WAIT_EXTENSION); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + delay_in_ms, + PG_WAIT_EXTENSION); } /* Reset the latch, loop. */ - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); } /* diff --git a/contrib/postgres_fdw/connection.c b/contrib/postgres_fdw/connection.c index 12d1fec0e8..c9adec13fc 100644 --- a/contrib/postgres_fdw/connection.c +++ b/contrib/postgres_fdw/connection.c @@ -28,7 +28,7 @@ #include "pgstat.h" #include "postgres_fdw.h" #include "storage/fd.h" -#include "storage/latch.h" +#include "storage/interrupt.h" #include "utils/builtins.h" #include "utils/datetime.h" #include "utils/hsearch.h" @@ -735,8 +735,8 @@ do_sql_command_end(PGconn *conn, const char *sql, bool consume_input) /* * If requested, consume whatever data is available from the socket. (Note * that if all data is available, this allows pgfdw_get_result to call - * PQgetResult without forcing the overhead of WaitLatchOrSocket, which - * would be large compared to the overhead of PQconsumeInput.) + * PQgetResult without forcing the overhead of WaitInterruptOrSocket, + * which would be large compared to the overhead of PQconsumeInput.) */ if (consume_input && !PQconsumeInput(conn)) pgfdw_report_error(ERROR, NULL, conn, false, sql); @@ -1371,7 +1371,7 @@ pgfdw_cancel_query_end(PGconn *conn, TimestampTz endtime, bool consume_input) /* * If requested, consume whatever data is available from the socket. (Note * that if all data is available, this allows pgfdw_get_cleanup_result to - * call PQgetResult without forcing the overhead of WaitLatchOrSocket, + * call PQgetResult without forcing the overhead of WaitInterruptOrSocket, * which would be large compared to the overhead of PQconsumeInput.) */ if (consume_input && !PQconsumeInput(conn)) @@ -1465,7 +1465,7 @@ pgfdw_exec_cleanup_query_end(PGconn *conn, const char *query, /* * If requested, consume whatever data is available from the socket. (Note * that if all data is available, this allows pgfdw_get_cleanup_result to - * call PQgetResult without forcing the overhead of WaitLatchOrSocket, + * call PQgetResult without forcing the overhead of WaitInterruptOrSocket, * which would be large compared to the overhead of PQconsumeInput.) */ if (consume_input && !PQconsumeInput(conn)) @@ -1545,12 +1545,12 @@ pgfdw_get_cleanup_result(PGconn *conn, TimestampTz endtime, PGresult **result, pgfdw_we_cleanup_result = WaitEventExtensionNew("PostgresFdwCleanupResult"); /* Sleep until there's something to do */ - wc = WaitLatchOrSocket(MyLatch, - WL_LATCH_SET | WL_SOCKET_READABLE | - WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - PQsocket(conn), - cur_timeout, pgfdw_we_cleanup_result); - ResetLatch(MyLatch); + wc = WaitInterruptOrSocket(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_SOCKET_READABLE | + WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + PQsocket(conn), + cur_timeout, pgfdw_we_cleanup_result); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c index 4652851b50..771b6e9846 100644 --- a/contrib/postgres_fdw/postgres_fdw.c +++ b/contrib/postgres_fdw/postgres_fdw.c @@ -41,7 +41,7 @@ #include "optimizer/tlist.h" #include "parser/parsetree.h" #include "postgres_fdw.h" -#include "storage/latch.h" +#include "storage/waiteventset.h" #include "utils/builtins.h" #include "utils/float.h" #include "utils/guc.h" diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index d82aa3d489..0f0229ff25 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -54,6 +54,7 @@ #include "postmaster/autovacuum.h" #include "storage/bufmgr.h" #include "storage/freespace.h" +#include "storage/interrupt.h" #include "storage/lmgr.h" #include "utils/lsyscache.h" #include "utils/memutils.h" @@ -2609,11 +2610,11 @@ lazy_truncate_heap(LVRelState *vacrel) return; } - (void) WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, - WAIT_EVENT_VACUUM_TRUNCATE); - ResetLatch(MyLatch); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, + WAIT_EVENT_VACUUM_TRUNCATE); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); } /* diff --git a/src/backend/access/transam/parallel.c b/src/backend/access/transam/parallel.c index 9aba17bd5e..49cd357025 100644 --- a/src/backend/access/transam/parallel.c +++ b/src/backend/access/transam/parallel.c @@ -33,6 +33,7 @@ #include "miscadmin.h" #include "optimizer/optimizer.h" #include "pgstat.h" +#include "storage/interrupt.h" #include "storage/ipc.h" #include "storage/predicate.h" #include "storage/spin.h" @@ -742,12 +743,12 @@ WaitForParallelWorkersToAttach(ParallelContext *pcxt) * might also get set for some other reason, but if so we'll * just end up waiting for the same worker again. */ - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_EXIT_ON_PM_DEATH, - -1, WAIT_EVENT_BGWORKER_STARTUP); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_EXIT_ON_PM_DEATH, + -1, WAIT_EVENT_BGWORKER_STARTUP); - if (rc & WL_LATCH_SET) - ResetLatch(MyLatch); + if (rc & WL_INTERRUPT) + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); } } @@ -862,9 +863,10 @@ WaitForParallelWorkersToFinish(ParallelContext *pcxt) } } - (void) WaitLatch(MyLatch, WL_LATCH_SET | WL_EXIT_ON_PM_DEATH, -1, - WAIT_EVENT_PARALLEL_FINISH); - ResetLatch(MyLatch); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_EXIT_ON_PM_DEATH, -1, + WAIT_EVENT_PARALLEL_FINISH); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); } if (pcxt->toc != NULL) @@ -1017,7 +1019,7 @@ HandleParallelMessageInterrupt(void) { InterruptPending = true; ParallelMessagePending = true; - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } /* diff --git a/src/backend/access/transam/xlogfuncs.c b/src/backend/access/transam/xlogfuncs.c index b0c6d7c687..77d25447e9 100644 --- a/src/backend/access/transam/xlogfuncs.c +++ b/src/backend/access/transam/xlogfuncs.c @@ -28,7 +28,7 @@ #include "pgstat.h" #include "replication/walreceiver.h" #include "storage/fd.h" -#include "storage/latch.h" +#include "storage/interrupt.h" #include "storage/standby.h" #include "utils/builtins.h" #include "utils/memutils.h" @@ -718,17 +718,17 @@ pg_promote(PG_FUNCTION_ARGS) { int rc; - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); if (!RecoveryInProgress()) PG_RETURN_BOOL(true); CHECK_FOR_INTERRUPTS(); - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, - 1000L / WAITS_PER_SECOND, - WAIT_EVENT_PROMOTE); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_POSTMASTER_DEATH, + 1000L / WAITS_PER_SECOND, + WAIT_EVENT_PROMOTE); /* * Emergency bailout if postmaster has died. This is to avoid the diff --git a/src/backend/backup/basebackup_throttle.c b/src/backend/backup/basebackup_throttle.c index 4477945e61..16bc93dda9 100644 --- a/src/backend/backup/basebackup_throttle.c +++ b/src/backend/backup/basebackup_throttle.c @@ -17,7 +17,7 @@ #include "backup/basebackup_sink.h" #include "miscadmin.h" #include "pgstat.h" -#include "storage/latch.h" +#include "storage/interrupt.h" #include "utils/timestamp.h" typedef struct bbsink_throttle @@ -163,7 +163,7 @@ throttle(bbsink_throttle *sink, size_t increment) if (sleep <= 0) break; - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); /* We're eating a potentially set latch, so check for interrupts */ CHECK_FOR_INTERRUPTS(); @@ -172,12 +172,12 @@ throttle(bbsink_throttle *sink, size_t increment) * (TAR_SEND_SIZE / throttling_sample * elapsed_min_unit) should be * the maximum time to sleep. Thus the cast to long is safe. */ - wait_result = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - (long) (sleep / 1000), - WAIT_EVENT_BASE_BACKUP_THROTTLE); + wait_result = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + (long) (sleep / 1000), + WAIT_EVENT_BASE_BACKUP_THROTTLE); - if (wait_result & WL_LATCH_SET) + if (wait_result & WL_INTERRUPT) CHECK_FOR_INTERRUPTS(); /* Done waiting? */ diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c index 8ed503e1c1..0fd323eb1a 100644 --- a/src/backend/commands/async.c +++ b/src/backend/commands/async.c @@ -140,6 +140,7 @@ #include "libpq/libpq.h" #include "libpq/pqformat.h" #include "miscadmin.h" +#include "storage/interrupt.h" #include "storage/ipc.h" #include "storage/lmgr.h" #include "storage/procsignal.h" @@ -1812,7 +1813,7 @@ HandleNotifyInterrupt(void) notifyInterruptPending = true; /* make sure the event is processed in due course */ - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } /* diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c index 7d8e9d2045..4fe355ddb8 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -2387,8 +2387,8 @@ vacuum_delay_point(void) /* * We don't want to ignore postmaster death during very long vacuums * with vacuum_cost_delay configured. We can't use the usual - * WaitLatch() approach here because we want microsecond-based sleep - * durations above. + * WaitInterrupt() approach here because we want microsecond-based + * sleep durations above. */ if (IsUnderPostmaster && !PostmasterIsAlive()) exit(1); diff --git a/src/backend/executor/nodeGather.c b/src/backend/executor/nodeGather.c index 5d4ffe989c..9751dfeb29 100644 --- a/src/backend/executor/nodeGather.c +++ b/src/backend/executor/nodeGather.c @@ -35,6 +35,7 @@ #include "executor/nodeGather.h" #include "executor/tqueue.h" #include "miscadmin.h" +#include "storage/interrupt.h" #include "optimizer/optimizer.h" #include "utils/wait_event.h" @@ -375,9 +376,10 @@ gather_readnext(GatherState *gatherstate) return NULL; /* Nothing to do except wait for developments. */ - (void) WaitLatch(MyLatch, WL_LATCH_SET | WL_EXIT_ON_PM_DEATH, 0, - WAIT_EVENT_EXECUTE_GATHER); - ResetLatch(MyLatch); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_EXIT_ON_PM_DEATH, 0, + WAIT_EVENT_EXECUTE_GATHER); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); nvisited = 0; } } diff --git a/src/backend/libpq/auth.c b/src/backend/libpq/auth.c index 2b607c5270..0929a9874d 100644 --- a/src/backend/libpq/auth.c +++ b/src/backend/libpq/auth.c @@ -1663,8 +1663,8 @@ interpret_ident_response(const char *ident_response, * owns the tcp connection to "local_addr" * If the username is successfully retrieved, check the usermap. * - * XXX: Using WaitLatchOrSocket() and doing a CHECK_FOR_INTERRUPTS() if the - * latch was set would improve the responsiveness to timeouts/cancellations. + * XXX: Using WaitInterruptOrSocket() and doing a CHECK_FOR_INTERRUPTS() if the + * interrupt was pending would improve the responsiveness to timeouts/cancellations. */ static int ident_inet(hbaPort *port) @@ -3093,8 +3093,8 @@ PerformRadiusTransaction(const char *server, const char *secret, const char *por * packets to our port thus causing us to retry in a loop and never time * out. * - * XXX: Using WaitLatchOrSocket() and doing a CHECK_FOR_INTERRUPTS() if - * the latch was set would improve the responsiveness to + * XXX: Using WaitInterruptOrSocket() and doing a CHECK_FOR_INTERRUPTS() + * if the interrupt was pending would improve the responsiveness to * timeouts/cancellations. */ gettimeofday(&endtime, NULL); diff --git a/src/backend/libpq/be-secure-gssapi.c b/src/backend/libpq/be-secure-gssapi.c index 483636503c..4c405a16e9 100644 --- a/src/backend/libpq/be-secure-gssapi.c +++ b/src/backend/libpq/be-secure-gssapi.c @@ -414,7 +414,7 @@ be_gssapi_read(Port *port, void *ptr, size_t len) /* * Read the specified number of bytes off the wire, waiting using - * WaitLatchOrSocket if we would block. + * WaitInterruptOrSocket if we would block. * * Results are read into PqGSSRecvBuffer. * @@ -450,9 +450,10 @@ read_or_wait(Port *port, ssize_t len) */ if (ret <= 0) { - WaitLatchOrSocket(MyLatch, - WL_SOCKET_READABLE | WL_EXIT_ON_PM_DEATH, - port->sock, 0, WAIT_EVENT_GSS_OPEN_SERVER); + /* FIXME: why no WL_LATCH_SET here? */ + WaitInterruptOrSocket(INTERRUPT_GENERAL_WAKEUP, + WL_SOCKET_READABLE | WL_EXIT_ON_PM_DEATH, + port->sock, 0, WAIT_EVENT_GSS_OPEN_SERVER); /* * If we got back zero bytes, and then waited on the socket to be @@ -489,7 +490,7 @@ read_or_wait(Port *port, ssize_t len) * * Note that unlike the be_gssapi_read/be_gssapi_write functions, this * function WILL block on the socket to be ready for read/write (using - * WaitLatchOrSocket) as appropriate while establishing the GSSAPI + * WaitInterruptOrSocket) as appropriate while establishing the GSSAPI * session. */ ssize_t @@ -668,9 +669,10 @@ secure_open_gssapi(Port *port) /* Wait and retry if we couldn't write yet */ if (ret <= 0) { - WaitLatchOrSocket(MyLatch, - WL_SOCKET_WRITEABLE | WL_EXIT_ON_PM_DEATH, - port->sock, 0, WAIT_EVENT_GSS_OPEN_SERVER); + /* FIXME: Why no WL_LATCH_SET ? */ + WaitInterruptOrSocket(INTERRUPT_PROC_SET_LATCH, + WL_SOCKET_WRITEABLE | WL_EXIT_ON_PM_DEATH, + port->sock, 0, WAIT_EVENT_GSS_OPEN_SERVER); continue; } diff --git a/src/backend/libpq/be-secure-openssl.c b/src/backend/libpq/be-secure-openssl.c index 60cf5d16e7..38a6957b7e 100644 --- a/src/backend/libpq/be-secure-openssl.c +++ b/src/backend/libpq/be-secure-openssl.c @@ -32,7 +32,7 @@ #include "miscadmin.h" #include "pgstat.h" #include "storage/fd.h" -#include "storage/latch.h" +#include "storage/interrupt.h" #include "tcop/tcopprot.h" #include "utils/builtins.h" #include "utils/memutils.h" @@ -519,8 +519,8 @@ aloop: else waitfor = WL_SOCKET_WRITEABLE | WL_EXIT_ON_PM_DEATH; - (void) WaitLatchOrSocket(MyLatch, waitfor, port->sock, 0, - WAIT_EVENT_SSL_OPEN_SERVER); + (void) WaitInterruptOrSocket(INTERRUPT_GENERAL_WAKEUP, waitfor, port->sock, 0, + WAIT_EVENT_SSL_OPEN_SERVER); goto aloop; case SSL_ERROR_SYSCALL: if (r < 0 && errno != 0) diff --git a/src/backend/libpq/pqmq.c b/src/backend/libpq/pqmq.c index fd735e2fea..66062c4d75 100644 --- a/src/backend/libpq/pqmq.c +++ b/src/backend/libpq/pqmq.c @@ -19,6 +19,7 @@ #include "libpq/pqmq.h" #include "miscadmin.h" #include "pgstat.h" +#include "storage/interrupt.h" #include "replication/logicalworker.h" #include "tcop/tcopprot.h" #include "utils/builtins.h" @@ -181,9 +182,9 @@ mq_putmessage(char msgtype, const char *s, size_t len) if (result != SHM_MQ_WOULD_BLOCK) break; - (void) WaitLatch(MyLatch, WL_LATCH_SET | WL_EXIT_ON_PM_DEATH, 0, - WAIT_EVENT_MESSAGE_QUEUE_PUT_MESSAGE); - ResetLatch(MyLatch); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, WL_INTERRUPT | WL_EXIT_ON_PM_DEATH, 0, + WAIT_EVENT_MESSAGE_QUEUE_PUT_MESSAGE); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); } diff --git a/src/backend/libpq/pqsignal.c b/src/backend/libpq/pqsignal.c index 22a16c50b2..2f5eebdfec 100644 --- a/src/backend/libpq/pqsignal.c +++ b/src/backend/libpq/pqsignal.c @@ -42,7 +42,7 @@ pqinitmask(void) { sigemptyset(&UnBlockSig); - /* Note: InitializeLatchSupport() modifies UnBlockSig. */ + /* Note: InitializeWaitEventSupport() modifies UnBlockSig. */ /* First set all signals, then clear some. */ sigfillset(&BlockSig); diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index 7d0877c95e..7ec91b6ac8 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -89,8 +89,8 @@ #include "postmaster/interrupt.h" #include "postmaster/postmaster.h" #include "storage/bufmgr.h" +#include "storage/interrupt.h" #include "storage/ipc.h" -#include "storage/latch.h" #include "storage/lmgr.h" #include "storage/pmsignal.h" #include "storage/proc.h" @@ -570,10 +570,10 @@ AutoVacLauncherMain(char *startup_data, size_t startup_data_len) bool can_launch; /* - * This loop is a bit different from the normal use of WaitLatch, + * This loop is a bit different from the normal use of WaitInterrupt, * because we'd like to sleep before the first launch of a child - * process. So it's WaitLatch, then ResetLatch, then check for - * wakening conditions. + * process. So it's WaitInterrupt, then ClearInterrupt, then check + * for wakening conditions. */ launcher_determine_sleep(!dlist_is_empty(&AutoVacuumShmem->av_freeWorkers), @@ -581,14 +581,14 @@ AutoVacLauncherMain(char *startup_data, size_t startup_data_len) /* * Wait until naptime expires or we get some type of signal (all the - * signal handlers will wake us by calling SetLatch). + * signal handlers will wake us by calling RaiseInterrupt). */ - (void) WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - (nap.tv_sec * 1000L) + (nap.tv_usec / 1000L), - WAIT_EVENT_AUTOVACUUM_MAIN); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + (nap.tv_sec * 1000L) + (nap.tv_usec / 1000L), + WAIT_EVENT_AUTOVACUUM_MAIN); - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); HandleAutoVacLauncherInterrupts(); @@ -1345,7 +1345,7 @@ static void avl_sigusr2_handler(SIGNAL_ARGS) { got_SIGUSR2 = true; - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } diff --git a/src/backend/postmaster/bgworker.c b/src/backend/postmaster/bgworker.c index b83967cda3..32884eebca 100644 --- a/src/backend/postmaster/bgworker.c +++ b/src/backend/postmaster/bgworker.c @@ -21,8 +21,8 @@ #include "postmaster/postmaster.h" #include "replication/logicallauncher.h" #include "replication/logicalworker.h" +#include "storage/interrupt.h" #include "storage/ipc.h" -#include "storage/latch.h" #include "storage/lwlock.h" #include "storage/pmsignal.h" #include "storage/proc.h" @@ -1226,9 +1226,9 @@ WaitForBackgroundWorkerStartup(BackgroundWorkerHandle *handle, pid_t *pidp) if (status != BGWH_NOT_YET_STARTED) break; - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_POSTMASTER_DEATH, 0, - WAIT_EVENT_BGWORKER_STARTUP); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_POSTMASTER_DEATH, 0, + WAIT_EVENT_BGWORKER_STARTUP); if (rc & WL_POSTMASTER_DEATH) { @@ -1236,7 +1236,7 @@ WaitForBackgroundWorkerStartup(BackgroundWorkerHandle *handle, pid_t *pidp) break; } - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); } return status; @@ -1269,9 +1269,9 @@ WaitForBackgroundWorkerShutdown(BackgroundWorkerHandle *handle) if (status == BGWH_STOPPED) break; - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_POSTMASTER_DEATH, 0, - WAIT_EVENT_BGWORKER_SHUTDOWN); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_POSTMASTER_DEATH, 0, + WAIT_EVENT_BGWORKER_SHUTDOWN); if (rc & WL_POSTMASTER_DEATH) { @@ -1279,7 +1279,7 @@ WaitForBackgroundWorkerShutdown(BackgroundWorkerHandle *handle) break; } - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); } return status; diff --git a/src/backend/postmaster/bgwriter.c b/src/backend/postmaster/bgwriter.c index 0f75548759..a55c991df3 100644 --- a/src/backend/postmaster/bgwriter.c +++ b/src/backend/postmaster/bgwriter.c @@ -42,6 +42,7 @@ #include "storage/bufmgr.h" #include "storage/condition_variable.h" #include "storage/fd.h" +#include "storage/interrupt.h" #include "storage/lwlock.h" #include "storage/proc.h" #include "storage/procsignal.h" @@ -224,7 +225,7 @@ BackgroundWriterMain(char *startup_data, size_t startup_data_len) int rc; /* Clear any already-pending wakeups */ - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); HandleMainLoopInterrupts(); @@ -302,9 +303,9 @@ BackgroundWriterMain(char *startup_data, size_t startup_data_len) * down with latch events that are likely to happen frequently during * normal operation. */ - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - BgWriterDelay /* ms */ , WAIT_EVENT_BGWRITER_MAIN); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + BgWriterDelay /* ms */ , WAIT_EVENT_BGWRITER_MAIN); /* * If no latch event and BgBufferSync says nothing's happening, extend @@ -329,10 +330,10 @@ BackgroundWriterMain(char *startup_data, size_t startup_data_len) /* Ask for notification at next buffer allocation */ StrategyNotifyBgWriter(MyProcNumber); /* Sleep ... */ - (void) WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - BgWriterDelay * HIBERNATE_FACTOR, - WAIT_EVENT_BGWRITER_HIBERNATE); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + BgWriterDelay * HIBERNATE_FACTOR, + WAIT_EVENT_BGWRITER_HIBERNATE); /* Reset the notification request in case we timed out */ StrategyNotifyBgWriter(-1); } diff --git a/src/backend/postmaster/syslogger.c b/src/backend/postmaster/syslogger.c index b33033b290..264ef1bc40 100644 --- a/src/backend/postmaster/syslogger.c +++ b/src/backend/postmaster/syslogger.c @@ -44,8 +44,8 @@ #include "postmaster/syslogger.h" #include "storage/dsm.h" #include "storage/fd.h" +#include "storage/interrupt.h" #include "storage/ipc.h" -#include "storage/latch.h" #include "storage/pg_shmem.h" #include "tcop/tcopprot.h" #include "utils/guc.h" @@ -328,7 +328,7 @@ SysLoggerMain(char *startup_data, size_t startup_data_len) whereToSendOutput = DestNone; /* - * Set up a reusable WaitEventSet object we'll use to wait for our latch, + * Set up a reusable WaitEventSet object we'll use to wait for interrupts, * and (except on Windows) our socket. * * Unlike all other postmaster child processes, we'll ignore postmaster @@ -338,7 +338,7 @@ SysLoggerMain(char *startup_data, size_t startup_data_len) * (including the postmaster). */ wes = CreateWaitEventSet(NULL, 2); - AddWaitEventToSet(wes, WL_LATCH_SET, PGINVALID_SOCKET, 1 << INTERRUPT_GENERAL_WAKEUP, NULL); + AddWaitEventToSet(wes, WL_INTERRUPT, PGINVALID_SOCKET, 1 << INTERRUPT_GENERAL_WAKEUP, NULL); #ifndef WIN32 AddWaitEventToSet(wes, WL_SOCKET_READABLE, syslogPipe[0], 0, NULL); #endif @@ -356,7 +356,7 @@ SysLoggerMain(char *startup_data, size_t startup_data_len) #endif /* Clear any already-pending wakeups */ - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); /* * Process any requests or signals received recently. @@ -1185,7 +1185,7 @@ pipeThread(void *arg) if (ftell(syslogFile) >= Log_RotationSize * 1024L || (csvlogFile != NULL && ftell(csvlogFile) >= Log_RotationSize * 1024L) || (jsonlogFile != NULL && ftell(jsonlogFile) >= Log_RotationSize * 1024L)) - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } LeaveCriticalSection(&sysloggerSection); } @@ -1196,8 +1196,8 @@ pipeThread(void *arg) /* if there's any data left then force it out now */ flush_pipe_input(logbuffer, &bytes_in_logbuffer); - /* set the latch to waken the main thread, which will quit */ - SetLatch(MyLatch); + /* set the interrupt to waken the main thread, which will quit */ + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); LeaveCriticalSection(&sysloggerSection); _endthread(); @@ -1592,5 +1592,5 @@ static void sigUsr1Handler(SIGNAL_ARGS) { rotation_requested = true; - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } diff --git a/src/backend/postmaster/walsummarizer.c b/src/backend/postmaster/walsummarizer.c index ea96b40077..1219d00b3b 100644 --- a/src/backend/postmaster/walsummarizer.c +++ b/src/backend/postmaster/walsummarizer.c @@ -38,8 +38,8 @@ #include "postmaster/walsummarizer.h" #include "replication/walreceiver.h" #include "storage/fd.h" +#include "storage/interrupt.h" #include "storage/ipc.h" -#include "storage/latch.h" #include "storage/lwlock.h" #include "storage/proc.h" #include "storage/procsignal.h" @@ -315,10 +315,11 @@ WalSummarizerMain(char *startup_data, size_t startup_data_len) * So a really fast retry time doesn't seem to be especially * beneficial, and it will clutter the logs. */ - (void) WaitLatch(MyLatch, - WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - 10000, - WAIT_EVENT_WAL_SUMMARIZER_ERROR); + /* FIXME: Why no WL_LATCH_SET ? */ + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + 10000, + WAIT_EVENT_WAL_SUMMARIZER_ERROR); } /* We can now handle ereport(ERROR) */ @@ -630,8 +631,8 @@ GetOldestUnsummarizedLSN(TimeLineID *tli, bool *lsn_is_exact) * * This might not work, because there's no guarantee that the WAL summarizer * process was successfully started, and it also might have started but - * subsequently terminated. So, under normal circumstances, this will get the - * latch set, but there's no guarantee. + * subsequently terminated. So, under normal circumstances, this will send + * the interrupt, but there's no guarantee. */ void WakeupWalSummarizer(void) @@ -1635,11 +1636,11 @@ summarizer_wait_for_wal(void) } /* OK, now sleep. */ - (void) WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - sleep_quanta * MS_PER_SLEEP_QUANTUM, - WAIT_EVENT_WAL_SUMMARIZER_WAL); - ResetLatch(MyLatch); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + sleep_quanta * MS_PER_SLEEP_QUANTUM, + WAIT_EVENT_WAL_SUMMARIZER_WAL); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); /* Reset count of pages read. */ pages_read_since_last_sleep = 0; diff --git a/src/backend/replication/libpqwalreceiver/libpqwalreceiver.c b/src/backend/replication/libpqwalreceiver/libpqwalreceiver.c index c74369953f..2294d5d437 100644 --- a/src/backend/replication/libpqwalreceiver/libpqwalreceiver.c +++ b/src/backend/replication/libpqwalreceiver/libpqwalreceiver.c @@ -30,7 +30,7 @@ #include "pgstat.h" #include "pqexpbuffer.h" #include "replication/walreceiver.h" -#include "storage/latch.h" +#include "storage/interrupt.h" #include "utils/builtins.h" #include "utils/memutils.h" #include "utils/pg_lsn.h" @@ -237,16 +237,16 @@ libpqrcv_connect(const char *conninfo, bool replication, bool logical, else io_flag = WL_SOCKET_WRITEABLE; - rc = WaitLatchOrSocket(MyLatch, - WL_EXIT_ON_PM_DEATH | WL_LATCH_SET | io_flag, - PQsocket(conn->streamConn), - 0, - WAIT_EVENT_LIBPQWALRECEIVER_CONNECT); + rc = WaitInterruptOrSocket(1 << INTERRUPT_GENERAL_WAKEUP, + WL_EXIT_ON_PM_DEATH | WL_INTERRUPT | io_flag, + PQsocket(conn->streamConn), + 0, + WAIT_EVENT_LIBPQWALRECEIVER_CONNECT); /* Interrupted? */ - if (rc & WL_LATCH_SET) + if (rc & WL_INTERRUPT) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); ProcessWalRcvInterrupts(); } @@ -848,17 +848,17 @@ libpqrcv_PQgetResult(PGconn *streamConn) * since we'll get interrupted by signals and can handle any * interrupts here. */ - rc = WaitLatchOrSocket(MyLatch, - WL_EXIT_ON_PM_DEATH | WL_SOCKET_READABLE | - WL_LATCH_SET, - PQsocket(streamConn), - 0, - WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE); + rc = WaitInterruptOrSocket(1 << INTERRUPT_GENERAL_WAKEUP, + WL_EXIT_ON_PM_DEATH | WL_SOCKET_READABLE | + WL_INTERRUPT, + PQsocket(streamConn), + 0, + WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE); /* Interrupted? */ - if (rc & WL_LATCH_SET) + if (rc & WL_INTERRUPT) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); ProcessWalRcvInterrupts(); } diff --git a/src/backend/replication/logical/applyparallelworker.c b/src/backend/replication/logical/applyparallelworker.c index e7f7d4c5e4..334b5ae2f6 100644 --- a/src/backend/replication/logical/applyparallelworker.c +++ b/src/backend/replication/logical/applyparallelworker.c @@ -165,6 +165,7 @@ #include "replication/logicalworker.h" #include "replication/origin.h" #include "replication/worker_internal.h" +#include "storage/interrupt.h" #include "storage/ipc.h" #include "storage/lmgr.h" #include "tcop/tcopprot.h" @@ -804,13 +805,13 @@ LogicalParallelApplyLoop(shm_mq_handle *mqh) int rc; /* Wait for more work. */ - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - 1000L, - WAIT_EVENT_LOGICAL_PARALLEL_APPLY_MAIN); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + 1000L, + WAIT_EVENT_LOGICAL_PARALLEL_APPLY_MAIN); - if (rc & WL_LATCH_SET) - ResetLatch(MyLatch); + if (rc & WL_INTERRUPT) + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); } } else @@ -990,7 +991,7 @@ HandleParallelApplyMessageInterrupt(void) { InterruptPending = true; ParallelApplyMessagePending = true; - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } /* @@ -1182,14 +1183,14 @@ pa_send_data(ParallelApplyWorkerInfo *winfo, Size nbytes, const void *data) Assert(result == SHM_MQ_WOULD_BLOCK); /* Wait before retrying. */ - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - SHM_SEND_RETRY_INTERVAL_MS, - WAIT_EVENT_LOGICAL_APPLY_SEND_DATA); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + SHM_SEND_RETRY_INTERVAL_MS, + WAIT_EVENT_LOGICAL_APPLY_SEND_DATA); - if (rc & WL_LATCH_SET) + if (rc & WL_INTERRUPT) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); } @@ -1254,13 +1255,13 @@ pa_wait_for_xact_state(ParallelApplyWorkerInfo *winfo, break; /* Wait to be signalled. */ - (void) WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - 10L, - WAIT_EVENT_LOGICAL_PARALLEL_APPLY_STATE_CHANGE); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + 10L, + WAIT_EVENT_LOGICAL_PARALLEL_APPLY_STATE_CHANGE); /* Reset the latch so we don't spin. */ - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); /* An interrupt may have occurred while we were waiting. */ CHECK_FOR_INTERRUPTS(); diff --git a/src/backend/replication/logical/launcher.c b/src/backend/replication/logical/launcher.c index 84081dcf83..78244af7c9 100644 --- a/src/backend/replication/logical/launcher.c +++ b/src/backend/replication/logical/launcher.c @@ -34,6 +34,7 @@ #include "replication/slot.h" #include "replication/walreceiver.h" #include "replication/worker_internal.h" +#include "storage/interrupt.h" #include "storage/ipc.h" #include "storage/proc.h" #include "storage/procarray.h" @@ -221,13 +222,13 @@ WaitForReplicationWorkerAttach(LogicalRepWorker *worker, * We need timeout because we generally don't get notified via latch * about the worker attach. But we don't expect to have to wait long. */ - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - 10L, WAIT_EVENT_BGWORKER_STARTUP); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + 10L, WAIT_EVENT_BGWORKER_STARTUP); - if (rc & WL_LATCH_SET) + if (rc & WL_INTERRUPT) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); } } @@ -553,13 +554,13 @@ logicalrep_worker_stop_internal(LogicalRepWorker *worker, int signo) LWLockRelease(LogicalRepWorkerLock); /* Wait a bit --- we don't expect to have to wait long. */ - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - 10L, WAIT_EVENT_BGWORKER_STARTUP); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + 10L, WAIT_EVENT_BGWORKER_STARTUP); - if (rc & WL_LATCH_SET) + if (rc & WL_INTERRUPT) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); } @@ -594,13 +595,13 @@ logicalrep_worker_stop_internal(LogicalRepWorker *worker, int signo) LWLockRelease(LogicalRepWorkerLock); /* Wait a bit --- we don't expect to have to wait long. */ - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - 10L, WAIT_EVENT_BGWORKER_SHUTDOWN); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + 10L, WAIT_EVENT_BGWORKER_SHUTDOWN); - if (rc & WL_LATCH_SET) + if (rc & WL_INTERRUPT) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); } @@ -1221,14 +1222,14 @@ ApplyLauncherMain(Datum main_arg) MemoryContextDelete(subctx); /* Wait for more work. */ - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - wait_time, - WAIT_EVENT_LOGICAL_LAUNCHER_MAIN); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + wait_time, + WAIT_EVENT_LOGICAL_LAUNCHER_MAIN); - if (rc & WL_LATCH_SET) + if (rc & WL_INTERRUPT) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); } diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c index 2d1914ce08..3bb2131736 100644 --- a/src/backend/replication/logical/slotsync.c +++ b/src/backend/replication/logical/slotsync.c @@ -61,6 +61,7 @@ #include "replication/logical.h" #include "replication/slotsync.h" #include "replication/snapbuild.h" +#include "storage/interrupt.h" #include "storage/ipc.h" #include "storage/lmgr.h" #include "storage/proc.h" @@ -1254,13 +1255,13 @@ wait_for_slot_activity(bool some_slot_updated) sleep_ms = MIN_SLOTSYNC_WORKER_NAPTIME_MS; } - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - sleep_ms, - WAIT_EVENT_REPLICATION_SLOTSYNC_MAIN); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + sleep_ms, + WAIT_EVENT_REPLICATION_SLOTSYNC_MAIN); - if (rc & WL_LATCH_SET) - ResetLatch(MyLatch); + if (rc & WL_INTERRUPT) + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); } /* @@ -1592,13 +1593,13 @@ ShutDownSlotSync(void) int rc; /* Wait a bit, we don't expect to have to wait long */ - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - 10L, WAIT_EVENT_REPLICATION_SLOTSYNC_SHUTDOWN); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + 10L, WAIT_EVENT_REPLICATION_SLOTSYNC_SHUTDOWN); - if (rc & WL_LATCH_SET) + if (rc & WL_INTERRUPT) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); } diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index e03e761392..a59a859f5c 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -111,6 +111,7 @@ #include "replication/slot.h" #include "replication/walreceiver.h" #include "replication/worker_internal.h" +#include "storage/interrupt.h" #include "storage/ipc.h" #include "storage/lmgr.h" #include "utils/acl.h" @@ -210,11 +211,11 @@ wait_for_relation_state_change(Oid relid, char expected_state) if (!worker) break; - (void) WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - 1000L, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + 1000L, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE); - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); } return false; @@ -263,12 +264,12 @@ wait_for_worker_state_change(char expected_state) * Wait. We expect to get a latch signal back from the apply worker, * but use a timeout in case it dies without sending one. */ - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - 1000L, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + 1000L, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE); - if (rc & WL_LATCH_SET) - ResetLatch(MyLatch); + if (rc & WL_INTERRUPT) + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); } return false; @@ -773,12 +774,12 @@ copy_read_data(void *outbuf, int minread, int maxread) /* * Wait for more data or latch. */ - (void) WaitLatchOrSocket(MyLatch, - WL_SOCKET_READABLE | WL_LATCH_SET | - WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - fd, 1000L, WAIT_EVENT_LOGICAL_SYNC_DATA); + (void) WaitInterruptOrSocket(1 << INTERRUPT_GENERAL_WAKEUP, + WL_SOCKET_READABLE | WL_INTERRUPT | + WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + fd, 1000L, WAIT_EVENT_LOGICAL_SYNC_DATA); - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); } return bytesread; diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index 38c2895307..4bfb9f8917 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -177,6 +177,7 @@ #include "replication/worker_internal.h" #include "rewrite/rewriteHandler.h" #include "storage/buffile.h" +#include "storage/interrupt.h" #include "storage/ipc.h" #include "storage/lmgr.h" #include "tcop/tcopprot.h" @@ -3739,15 +3740,15 @@ LogicalRepApplyLoop(XLogRecPtr last_received) else wait_time = NAPTIME_PER_CYCLE; - rc = WaitLatchOrSocket(MyLatch, - WL_SOCKET_READABLE | WL_LATCH_SET | - WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - fd, wait_time, - WAIT_EVENT_LOGICAL_APPLY_MAIN); + rc = WaitInterruptOrSocket(1 << INTERRUPT_GENERAL_WAKEUP, + WL_SOCKET_READABLE | WL_INTERRUPT | + WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + fd, wait_time, + WAIT_EVENT_LOGICAL_APPLY_MAIN); - if (rc & WL_LATCH_SET) + if (rc & WL_INTERRUPT) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); } diff --git a/src/backend/replication/syncrep.c b/src/backend/replication/syncrep.c index d8a52405b0..e74c153402 100644 --- a/src/backend/replication/syncrep.c +++ b/src/backend/replication/syncrep.c @@ -81,6 +81,7 @@ #include "replication/syncrep.h" #include "replication/walsender.h" #include "replication/walsender_private.h" +#include "storage/interrupt.h" #include "storage/proc.h" #include "tcop/tcopprot.h" #include "utils/guc_hooks.h" @@ -230,7 +231,7 @@ SyncRepWaitForLSN(XLogRecPtr lsn, bool commit) int rc; /* Must reset the latch before testing state. */ - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); /* * Acquiring the lock is not needed, the latch ensures proper @@ -285,8 +286,8 @@ SyncRepWaitForLSN(XLogRecPtr lsn, bool commit) * Wait on latch. Any condition that should wake us up will set the * latch, so no need for timeout. */ - rc = WaitLatch(MyLatch, WL_LATCH_SET | WL_POSTMASTER_DEATH, -1, - WAIT_EVENT_SYNC_REP); + rc = WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, WL_INTERRUPT | WL_POSTMASTER_DEATH, -1, + WAIT_EVENT_SYNC_REP); /* * If the postmaster dies, we'll probably never get an acknowledgment, diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c index 40d1fa4939..04eb1db6ca 100644 --- a/src/backend/replication/walreceiver.c +++ b/src/backend/replication/walreceiver.c @@ -67,6 +67,7 @@ #include "postmaster/interrupt.h" #include "replication/walreceiver.h" #include "replication/walsender.h" +#include "storage/interrupt.h" #include "storage/ipc.h" #include "storage/proc.h" #include "storage/procarray.h" @@ -546,15 +547,15 @@ WalReceiverMain(char *startup_data, size_t startup_data_len) * avoiding some system calls. */ Assert(wait_fd != PGINVALID_SOCKET); - rc = WaitLatchOrSocket(MyLatch, - WL_EXIT_ON_PM_DEATH | WL_SOCKET_READABLE | - WL_TIMEOUT | WL_LATCH_SET, - wait_fd, - nap, - WAIT_EVENT_WAL_RECEIVER_MAIN); - if (rc & WL_LATCH_SET) + rc = WaitInterruptOrSocket(1 << INTERRUPT_GENERAL_WAKEUP, + WL_EXIT_ON_PM_DEATH | WL_SOCKET_READABLE | + WL_TIMEOUT | WL_INTERRUPT, + wait_fd, + nap, + WAIT_EVENT_WAL_RECEIVER_MAIN); + if (rc & WL_INTERRUPT) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); ProcessWalRcvInterrupts(); if (walrcv->force_reply) @@ -692,7 +693,7 @@ WalRcvWaitForStartPosition(XLogRecPtr *startpoint, TimeLineID *startpointTLI) WakeupRecovery(); for (;;) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); ProcessWalRcvInterrupts(); @@ -724,8 +725,8 @@ WalRcvWaitForStartPosition(XLogRecPtr *startpoint, TimeLineID *startpointTLI) } SpinLockRelease(&walrcv->mutex); - (void) WaitLatch(MyLatch, WL_LATCH_SET | WL_EXIT_ON_PM_DEATH, 0, - WAIT_EVENT_WAL_RECEIVER_WAIT_START); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, WL_INTERRUPT | WL_EXIT_ON_PM_DEATH, 0, + WAIT_EVENT_WAL_RECEIVER_WAIT_START); } if (update_process_title) diff --git a/src/backend/replication/walreceiverfuncs.c b/src/backend/replication/walreceiverfuncs.c index d015f03244..6212e82577 100644 --- a/src/backend/replication/walreceiverfuncs.c +++ b/src/backend/replication/walreceiverfuncs.c @@ -26,7 +26,7 @@ #include "access/xlogrecovery.h" #include "pgstat.h" #include "replication/walreceiver.h" -#include "storage/latch.h" +#include "storage/interrupt.h" #include "storage/pmsignal.h" #include "storage/proc.h" #include "storage/shmem.h" diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index 3e335b0944..9a72674eeb 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -51,6 +51,7 @@ #include "storage/buf_internals.h" #include "storage/bufmgr.h" #include "storage/fd.h" +#include "storage/interrupt.h" #include "storage/ipc.h" #include "storage/lmgr.h" #include "storage/proc.h" diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index bc32f2186e..3037429f2a 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -19,6 +19,7 @@ #include "port/atomics.h" #include "storage/buf_internals.h" #include "storage/bufmgr.h" +#include "storage/interrupt.h" #include "storage/proc.h" #define INT_ACCESS_ONCE(var) ((int)(*((volatile int *)&(var)))) @@ -219,25 +220,23 @@ StrategyGetBuffer(BufferAccessStrategy strategy, uint32 *buf_state, bool *from_r /* * If asked, we need to waken the bgwriter. Since we don't want to rely on * a spinlock for this we force a read from shared memory once, and then - * set the latch based on that value. We need to go through that length - * because otherwise bgwprocno might be reset while/after we check because - * the compiler might just reread from memory. + * send the interrupt based on that value. We need to go through that + * length because otherwise bgwprocno might be reset while/after we check + * because the compiler might just reread from memory. * - * This can possibly set the latch of the wrong process if the bgwriter - * dies in the wrong moment. But since PGPROC->procLatch is never - * deallocated the worst consequence of that is that we set the latch of - * some arbitrary process. + * This can possibly send the interrupt to the wrong process if the + * bgwriter dies in the wrong moment, but that's harmless. */ bgwprocno = INT_ACCESS_ONCE(StrategyControl->bgwprocno); if (bgwprocno != -1) { - /* reset bgwprocno first, before setting the latch */ + /* reset bgwprocno first, before sending the interrupt */ StrategyControl->bgwprocno = -1; /* - * Not acquiring ProcArrayLock here which is slightly icky. It's - * actually fine because procLatch isn't ever freed, so we just can - * potentially set the wrong process' (or no process') latch. + * Not acquiring ProcArrayLock here which is slightly icky, because we + * can potentially send the interrupt to the wrong process (or no + * process), but it's harmless. */ SendInterrupt(INTERRUPT_GENERAL_WAKEUP, bgwprocno); } @@ -420,10 +419,10 @@ StrategySyncStart(uint32 *complete_passes, uint32 *num_buf_alloc) } /* - * StrategyNotifyBgWriter -- set or clear allocation notification latch + * StrategyNotifyBgWriter -- set or clear allocation notification process * * If bgwprocno isn't -1, the next invocation of StrategyGetBuffer will - * set that latch. Pass -1 to clear the pending notification before it + * interrupt that process. Pass -1 to clear the pending notification before it * happens. This feature is used by the bgwriter process to wake itself up * from hibernation, and is not meant for anybody else to use. */ diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c index 87027f27eb..f51fe18cc9 100644 --- a/src/backend/storage/ipc/procsignal.c +++ b/src/backend/storage/ipc/procsignal.c @@ -25,8 +25,8 @@ #include "replication/logicalworker.h" #include "replication/walsender.h" #include "storage/condition_variable.h" +#include "storage/interrupt.h" #include "storage/ipc.h" -#include "storage/latch.h" #include "storage/shmem.h" #include "storage/sinval.h" #include "storage/smgr.h" @@ -712,7 +712,7 @@ procsignal_sigusr1_handler(SIGNAL_ARGS) if (CheckProcSignal(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN)) HandleRecoveryConflictInterrupt(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN); - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } /* diff --git a/src/backend/storage/ipc/signalfuncs.c b/src/backend/storage/ipc/signalfuncs.c index aa729a36e3..a354a7d065 100644 --- a/src/backend/storage/ipc/signalfuncs.c +++ b/src/backend/storage/ipc/signalfuncs.c @@ -20,6 +20,7 @@ #include "miscadmin.h" #include "pgstat.h" #include "postmaster/syslogger.h" +#include "storage/interrupt.h" #include "storage/pmsignal.h" #include "storage/proc.h" #include "storage/procarray.h" @@ -204,12 +205,12 @@ pg_wait_until_termination(int pid, int64 timeout) /* Process interrupts, if any, before waiting */ CHECK_FOR_INTERRUPTS(); - (void) WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - waittime, - WAIT_EVENT_BACKEND_TERMINATION); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + waittime, + WAIT_EVENT_BACKEND_TERMINATION); - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); remainingtime -= waittime; } while (remainingtime > 0); diff --git a/src/backend/storage/ipc/sinval.c b/src/backend/storage/ipc/sinval.c index d9b16f84d1..c292369ff6 100644 --- a/src/backend/storage/ipc/sinval.c +++ b/src/backend/storage/ipc/sinval.c @@ -16,7 +16,7 @@ #include "access/xact.h" #include "miscadmin.h" -#include "storage/latch.h" +#include "storage/interrupt.h" #include "storage/sinvaladt.h" #include "utils/inval.h" @@ -161,7 +161,7 @@ HandleCatchupInterrupt(void) catchupInterruptPending = true; /* make sure the event is processed in due course */ - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } /* diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c index 437b13da90..e181386d4a 100644 --- a/src/backend/storage/ipc/standby.c +++ b/src/backend/storage/ipc/standby.c @@ -26,6 +26,7 @@ #include "pgstat.h" #include "replication/slot.h" #include "storage/bufmgr.h" +#include "storage/interrupt.h" #include "storage/proc.h" #include "storage/procarray.h" #include "storage/sinvaladt.h" @@ -594,7 +595,7 @@ ResolveRecoveryConflictWithDatabase(Oid dbid) * ResolveRecoveryConflictWithLock is called from ProcSleep() * to resolve conflicts with other backends holding relation locks. * - * The WaitLatch sleep normally done in ProcSleep() + * The WaitInterrupt sleep normally done in ProcSleep() * (when not InHotStandby) is performed here, for code clarity. * * We either resolve conflicts immediately or set a timeout to wake us at @@ -839,7 +840,7 @@ ResolveRecoveryConflictWithBufferPin(void) * We assume that only UnpinBuffer() and the timeout requests established * above can wake us up here. WakeupRecovery() called by walreceiver or * SIGHUP signal handler, etc cannot do that because it uses the different - * latch from that ProcWaitForSignal() waits on. + * interrupt from that ProcWaitForSignal() waits on. */ WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, WL_INTERRUPT | WL_EXIT_ON_PM_DEATH, 0, WAIT_EVENT_BUFFER_PIN); diff --git a/src/backend/storage/lmgr/condition_variable.c b/src/backend/storage/lmgr/condition_variable.c index d5fabef171..5248a35504 100644 --- a/src/backend/storage/lmgr/condition_variable.c +++ b/src/backend/storage/lmgr/condition_variable.c @@ -21,6 +21,7 @@ #include "miscadmin.h" #include "portability/instr_time.h" #include "storage/condition_variable.h" +#include "storage/interrupt.h" #include "storage/proc.h" #include "storage/proclist.h" #include "storage/spin.h" @@ -147,10 +148,10 @@ ConditionVariableTimedSleep(ConditionVariable *cv, long timeout, INSTR_TIME_SET_CURRENT(start_time); Assert(timeout >= 0 && timeout <= INT_MAX); cur_timeout = timeout; - wait_events = WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH; + wait_events = WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH; } else - wait_events = WL_LATCH_SET | WL_EXIT_ON_PM_DEATH; + wait_events = WL_INTERRUPT | WL_EXIT_ON_PM_DEATH; while (true) { @@ -160,10 +161,10 @@ ConditionVariableTimedSleep(ConditionVariable *cv, long timeout, * Wait for latch to be set. (If we're awakened for some other * reason, the code below will cope anyway.) */ - (void) WaitLatch(MyLatch, wait_events, cur_timeout, wait_event_info); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, wait_events, cur_timeout, wait_event_info); /* Reset latch before examining the state of the wait list. */ - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); /* * If this process has been taken out of the wait list, then we know diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c index f0234269b6..800a7cea0d 100644 --- a/src/backend/storage/lmgr/predicate.c +++ b/src/backend/storage/lmgr/predicate.c @@ -207,6 +207,7 @@ #include "miscadmin.h" #include "pgstat.h" #include "port/pg_lfind.h" +#include "storage/interrupt.h" #include "storage/predicate.h" #include "storage/predicate_internals.h" #include "storage/proc.h" diff --git a/src/backend/storage/sync/sync.c b/src/backend/storage/sync/sync.c index cd5d1436ab..bec42f4060 100644 --- a/src/backend/storage/sync/sync.c +++ b/src/backend/storage/sync/sync.c @@ -27,7 +27,7 @@ #include "portability/instr_time.h" #include "postmaster/bgwriter.h" #include "storage/fd.h" -#include "storage/latch.h" +#include "storage/interrupt.h" #include "storage/md.h" #include "utils/hsearch.h" #include "utils/memutils.h" diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c index 8bc6bea113..f2d6c334d4 100644 --- a/src/backend/tcop/postgres.c +++ b/src/backend/tcop/postgres.c @@ -62,6 +62,7 @@ #include "replication/walsender.h" #include "rewrite/rewriteHandler.h" #include "storage/bufmgr.h" +#include "storage/interrupt.h" #include "storage/ipc.h" #include "storage/pmsignal.h" #include "storage/proc.h" @@ -540,7 +541,7 @@ ProcessClientReadInterrupt(bool blocked) if (blocked) CHECK_FOR_INTERRUPTS(); else - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } errno = save_errno; @@ -592,7 +593,7 @@ ProcessClientWriteInterrupt(bool blocked) } } else - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } errno = save_errno; @@ -2991,7 +2992,7 @@ die(SIGNAL_ARGS) pgStatSessionEndCause = DISCONNECT_KILLED; /* If we're still here, waken anything waiting on the process latch */ - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); /* * If we're in single user mode, we want to quit immediately - we can't @@ -3020,7 +3021,7 @@ StatementCancelHandler(SIGNAL_ARGS) } /* If we're still here, waken anything waiting on the process latch */ - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } /* signal handler for floating point exception */ diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c index 0e6c45807a..bc63ad4f8d 100644 --- a/src/backend/utils/adt/misc.c +++ b/src/backend/utils/adt/misc.c @@ -38,7 +38,7 @@ #include "postmaster/syslogger.h" #include "rewrite/rewriteHandler.h" #include "storage/fd.h" -#include "storage/latch.h" +#include "storage/interrupt.h" #include "tcop/tcopprot.h" #include "utils/builtins.h" #include "utils/fmgroids.h" @@ -373,16 +373,16 @@ pg_sleep(PG_FUNCTION_ARGS) float8 endtime; /* - * We sleep using WaitLatch, to ensure that we'll wake up promptly if an - * important signal (such as SIGALRM or SIGINT) arrives. Because - * WaitLatch's upper limit of delay is INT_MAX milliseconds, and the user - * might ask for more than that, we sleep for at most 10 minutes and then - * loop. + * We sleep using WaitInterrupt, to ensure that we'll wake up promptly if + * an important signal (such as SIGALRM or SIGINT) arrives. Because + * WaitInterrupt's upper limit of delay is INT_MAX milliseconds, and the + * user might ask for more than that, we sleep for at most 10 minutes and + * then loop. * * By computing the intended stop time initially, we avoid accumulation of * extra delay across multiple sleeps. This also ensures we won't delay - * less than the specified time when WaitLatch is terminated early by a - * non-query-canceling signal such as SIGHUP. + * less than the specified time when WaitInterrupt is terminated early by + * a non-query-canceling signal such as SIGHUP. */ #define GetNowFloat() ((float8) GetCurrentTimestamp() / 1000000.0) @@ -403,11 +403,11 @@ pg_sleep(PG_FUNCTION_ARGS) else break; - (void) WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - delay_ms, - WAIT_EVENT_PG_SLEEP); - ResetLatch(MyLatch); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + delay_ms, + WAIT_EVENT_PG_SLEEP); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); } PG_RETURN_VOID(); diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c index db9eea9098..22cabfb95d 100644 --- a/src/backend/utils/adt/timestamp.c +++ b/src/backend/utils/adt/timestamp.c @@ -1738,10 +1738,10 @@ TimestampDifference(TimestampTz start_time, TimestampTz stop_time, * TimestampDifferenceMilliseconds -- convert the difference between two * timestamps into integer milliseconds * - * This is typically used to calculate a wait timeout for WaitLatch() + * This is typically used to calculate a wait timeout for WaitInterrupt() * or a related function. The choice of "long" as the result type * is to harmonize with that; furthermore, we clamp the result to at most - * INT_MAX milliseconds, because that's all that WaitLatch() allows. + * INT_MAX milliseconds, because that's all that WaitInterrupt() allows. * * We expect start_time <= stop_time. If not, we return zero, * since then we're already past the previously determined stop_time. diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c index 13524ea488..c7807b3433 100644 --- a/src/backend/utils/init/postinit.c +++ b/src/backend/utils/init/postinit.c @@ -45,6 +45,7 @@ #include "replication/walsender.h" #include "storage/bufmgr.h" #include "storage/fd.h" +#include "storage/interrupt.h" #include "storage/ipc.h" #include "storage/lmgr.h" #include "storage/proc.h" @@ -1334,7 +1335,7 @@ TransactionTimeoutHandler(void) { TransactionTimeoutPending = true; InterruptPending = true; - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } static void @@ -1342,7 +1343,7 @@ IdleInTransactionSessionTimeoutHandler(void) { IdleInTransactionSessionTimeoutPending = true; InterruptPending = true; - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } static void @@ -1350,7 +1351,7 @@ IdleSessionTimeoutHandler(void) { IdleSessionTimeoutPending = true; InterruptPending = true; - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } static void @@ -1358,7 +1359,7 @@ IdleStatsUpdateTimeoutHandler(void) { IdleStatsUpdateTimeoutPending = true; InterruptPending = true; - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } static void @@ -1366,7 +1367,7 @@ ClientCheckTimeoutHandler(void) { CheckClientConnectionPending = true; InterruptPending = true; - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); } /* diff --git a/src/backend/utils/misc/timeout.c b/src/backend/utils/misc/timeout.c index ec7e570920..c45765c3d7 100644 --- a/src/backend/utils/misc/timeout.c +++ b/src/backend/utils/misc/timeout.c @@ -17,7 +17,7 @@ #include #include "miscadmin.h" -#include "storage/latch.h" +#include "storage/interrupt.h" #include "utils/timeout.h" #include "utils/timestamp.h" @@ -374,7 +374,7 @@ handle_sig_alarm(SIGNAL_ARGS) * SIGALRM is always cause for waking anything waiting on the process * latch. */ - SetLatch(MyLatch); + RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); /* * Always reset signal_pending, even if !alarm_enabled, since indeed no diff --git a/src/include/libpq/libpq-be-fe-helpers.h b/src/include/libpq/libpq-be-fe-helpers.h index fe50829274..d1510dac41 100644 --- a/src/include/libpq/libpq-be-fe-helpers.h +++ b/src/include/libpq/libpq-be-fe-helpers.h @@ -43,7 +43,7 @@ #include "libpq-fe.h" #include "miscadmin.h" #include "storage/fd.h" -#include "storage/latch.h" +#include "storage/interrupt.h" #include "utils/timestamp.h" #include "utils/wait_event.h" @@ -177,8 +177,8 @@ libpqsrv_connect_internal(PGconn *conn, uint32 wait_event_info) return; /* - * WaitLatchOrSocket() can conceivably fail, handle that case here instead - * of requiring all callers to do so. + * WaitInterruptOrSocket() can conceivably fail, handle that case here + * instead of requiring all callers to do so. */ PG_TRY(); { @@ -209,16 +209,16 @@ libpqsrv_connect_internal(PGconn *conn, uint32 wait_event_info) else io_flag = WL_SOCKET_WRITEABLE; - rc = WaitLatchOrSocket(MyLatch, - WL_EXIT_ON_PM_DEATH | WL_LATCH_SET | io_flag, - PQsocket(conn), - 0, - wait_event_info); + rc = WaitInterruptOrSocket(1 << INTERRUPT_GENERAL_WAKEUP, + WL_EXIT_ON_PM_DEATH | WL_INTERRUPT | io_flag, + PQsocket(conn), + 0, + wait_event_info); /* Interrupted? */ - if (rc & WL_LATCH_SET) + if (rc & WL_INTERRUPT) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); } @@ -341,17 +341,17 @@ libpqsrv_get_result(PGconn *conn, uint32 wait_event_info) { int rc; - rc = WaitLatchOrSocket(MyLatch, - WL_EXIT_ON_PM_DEATH | WL_LATCH_SET | - WL_SOCKET_READABLE, - PQsocket(conn), - 0, - wait_event_info); + rc = WaitInterruptOrSocket(1 << INTERRUPT_GENERAL_WAKEUP, + WL_EXIT_ON_PM_DEATH | WL_INTERRUPT | + WL_SOCKET_READABLE, + PQsocket(conn), + 0, + wait_event_info); /* Interrupted? */ - if (rc & WL_LATCH_SET) + if (rc & WL_INTERRUPT) { - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); } @@ -407,7 +407,7 @@ libpqsrv_cancel(PGconn *conn, TimestampTz endtime) PostgresPollingStatusType pollres; TimestampTz now; long cur_timeout; - int waitEvents = WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH; + int waitEvents = WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH; pollres = PQcancelPoll(cancel_conn); if (pollres == PGRES_POLLING_OK) @@ -436,10 +436,11 @@ libpqsrv_cancel(PGconn *conn, TimestampTz endtime) } /* Sleep until there's something to do */ - WaitLatchOrSocket(MyLatch, waitEvents, PQcancelSocket(cancel_conn), - cur_timeout, PG_WAIT_CLIENT); + WaitInterruptOrSocket(1 << INTERRUPT_GENERAL_WAKEUP, waitEvents, + PQcancelSocket(cancel_conn), + cur_timeout, PG_WAIT_CLIENT); - ResetLatch(MyLatch); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); } diff --git a/src/include/storage/latch.h b/src/include/storage/latch.h deleted file mode 100644 index 772787bd3d..0000000000 --- a/src/include/storage/latch.h +++ /dev/null @@ -1,67 +0,0 @@ -/*------------------------------------------------------------------------- - * - * latch.h - * Backwards-compatibility macros for the old Latch interface - * - * Latches were an inter-process signalling mechanism that was replaced - * in PostgreSQL verson 18 with Interrupts, see "storage/interrupt.h". - * This file contains macros that map old Latch calls to the new interface. - * The mapping is not perfect, it only covers the basic usage of setting - * and waiting for the current process's own latch (MyLatch), which is - * mapped to raising or waiting for INTERRUPT_GENERAL_WAKUP. - * - * The WaitEventSet functions that used to be here are now in - * "storage/waitevents.h". - * - * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group - * Portions Copyright (c) 1994, Regents of the University of California - * - * src/include/storage/latch.h - * - *------------------------------------------------------------------------- - */ - -#ifndef LATCH_H -#define LATCH_H - -#include "storage/interrupt.h" - -#define WL_LATCH_SET WL_INTERRUPT - -/* - * These compatibility macros only support operating on MyLatch. It used to - * be a pointer to a Latch struct, but now it's just a dummy int variable. - */ - -#define MyLatch 0 - -static inline void -SetLatch(int dummy) -{ - Assert(dummy == MyLatch); - RaiseInterrupt(INTERRUPT_GENERAL_WAKEUP); -} - -static inline void -ResetLatch(int dummy) -{ - Assert(dummy == MyLatch); - ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); -} - -static inline int -WaitLatch(int dummy, int wakeEvents, long timeout, uint32 wait_event_info) -{ - return WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, wakeEvents, - timeout, wait_event_info); -} - -static inline int -WaitLatchOrSocket(int dummy, int wakeEvents, pgsocket sock, long timeout, - uint32 wait_event_info) -{ - return WaitInterruptOrSocket(1 << INTERRUPT_GENERAL_WAKEUP, wakeEvents, - sock, timeout, wait_event_info); -} - -#endif diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h index 1ef39d8754..d531c2e618 100644 --- a/src/include/storage/proc.h +++ b/src/include/storage/proc.h @@ -17,7 +17,6 @@ #include "access/clog.h" #include "access/xlogdefs.h" #include "lib/ilist.h" -#include "storage/latch.h" #include "storage/lock.h" #include "storage/pg_sema.h" #include "storage/proclist_types.h" diff --git a/src/port/pgsleep.c b/src/port/pgsleep.c index 1284458bfc..34ece20d66 100644 --- a/src/port/pgsleep.c +++ b/src/port/pgsleep.c @@ -32,10 +32,10 @@ * * CAUTION: It's not a good idea to use long sleeps in the backend. They will * silently return early if a signal is caught, but that doesn't include - * latches being set on most OSes, and even signal handlers that set MyLatch + * interrupts being set on most OSes, and even signal handlers that raise an interrupt * might happen to run before the sleep begins, allowing the full delay. - * Better practice is to use WaitLatch() with a timeout, so that backends - * respond to latches and signals promptly. + * Better practice is to use WaitInterrupt() with a timeout, so that backends + * respond to interrupts and signals promptly. */ void pg_usleep(long microsec) diff --git a/src/test/modules/worker_spi/worker_spi.c b/src/test/modules/worker_spi/worker_spi.c index de8f46902b..1e484455fc 100644 --- a/src/test/modules/worker_spi/worker_spi.c +++ b/src/test/modules/worker_spi/worker_spi.c @@ -26,8 +26,8 @@ #include "miscadmin.h" #include "postmaster/bgworker.h" #include "postmaster/interrupt.h" +#include "storage/interrupt.h" #include "storage/ipc.h" -#include "storage/latch.h" #include "storage/lwlock.h" #include "storage/proc.h" #include "storage/shmem.h" @@ -231,11 +231,11 @@ worker_spi_main(Datum main_arg) * necessary, but is awakened if postmaster dies. That way the * background process goes away immediately in an emergency. */ - (void) WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, - worker_spi_naptime * 1000L, - worker_spi_wait_event_main); - ResetLatch(MyLatch); + (void) WaitInterrupt(1 << INTERRUPT_GENERAL_WAKEUP, + WL_INTERRUPT | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, + worker_spi_naptime * 1000L, + worker_spi_wait_event_main); + ClearInterrupt(INTERRUPT_GENERAL_WAKEUP); CHECK_FOR_INTERRUPTS(); -- 2.39.2