Rename WAIT_* constants to PG_WAIT_*.

Windows apparently has a constant named WAIT_TIMEOUT, and some of these
other names are pretty generic, too.  Insert "PG_" at the front of each
name in order to disambiguate.

Michael Paquier

diff --git a/contrib/postgres_fdw/connection.c b/contrib/postgres_fdw/connection.c
index 9badfe6a7dd9c5be60a123e15efecf84d3b05c9f..bcdddc2db58238396a5eb92ae1f527583ec25dc2 100644 (file)
--- a/contrib/postgres_fdw/connection.c
+++ b/contrib/postgres_fdw/connection.c
@@ -497,7 +497,7 @@ pgfdw_get_result(PGconn *conn, const char *query)
                        wc = WaitLatchOrSocket(MyLatch,
                                                                   WL_LATCH_SET | WL_SOCKET_READABLE,
                                                                   PQsocket(conn),
-                                                                  -1L, WAIT_EXTENSION);
+                                                                  -1L, PG_WAIT_EXTENSION);
                        ResetLatch(MyLatch);
 
                        CHECK_FOR_INTERRUPTS();

diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c
index 5c6cb6b2667add39bb55f92a4e19d16b66fd780e..a9efee8304d02785cec0d3701614e01c533934f2 100644 (file)
--- a/src/backend/postmaster/pgstat.c
+++ b/src/backend/postmaster/pgstat.c
@@ -3147,31 +3147,31 @@ pgstat_get_wait_event_type(uint32 wait_event_info)
 
        switch (classId)
        {
-               case WAIT_LWLOCK_NAMED:
+               case PG_WAIT_LWLOCK_NAMED:
                        event_type = "LWLockNamed";
                        break;
-               case WAIT_LWLOCK_TRANCHE:
+               case PG_WAIT_LWLOCK_TRANCHE:
                        event_type = "LWLockTranche";
                        break;
-               case WAIT_LOCK:
+               case PG_WAIT_LOCK:
                        event_type = "Lock";
                        break;
-               case WAIT_BUFFER_PIN:
+               case PG_WAIT_BUFFER_PIN:
                        event_type = "BufferPin";
                        break;
-               case WAIT_ACTIVITY:
+               case PG_WAIT_ACTIVITY:
                        event_type = "Activity";
                        break;
-               case WAIT_CLIENT:
+               case PG_WAIT_CLIENT:
                        event_type = "Client";
                        break;
-               case WAIT_EXTENSION:
+               case PG_WAIT_EXTENSION:
                        event_type = "Extension";
                        break;
-               case WAIT_IPC:
+               case PG_WAIT_IPC:
                        event_type = "IPC";
                        break;
-               case WAIT_TIMEOUT:
+               case PG_WAIT_TIMEOUT:
                        event_type = "Timeout";
                        break;
                default:
@@ -3204,41 +3204,41 @@ pgstat_get_wait_event(uint32 wait_event_info)
 
        switch (classId)
        {
-               case WAIT_LWLOCK_NAMED:
-               case WAIT_LWLOCK_TRANCHE:
+               case PG_WAIT_LWLOCK_NAMED:
+               case PG_WAIT_LWLOCK_TRANCHE:
                        event_name = GetLWLockIdentifier(classId, eventId);
                        break;
-               case WAIT_LOCK:
+               case PG_WAIT_LOCK:
                        event_name = GetLockNameFromTagType(eventId);
                        break;
-               case WAIT_BUFFER_PIN:
+               case PG_WAIT_BUFFER_PIN:
                        event_name = "BufferPin";
                        break;
-               case WAIT_ACTIVITY:
+               case PG_WAIT_ACTIVITY:
                        {
                                WaitEventActivity       w = (WaitEventActivity) wait_event_info;
 
                                event_name = pgstat_get_wait_activity(w);
                                break;
                        }
-               case WAIT_CLIENT:
+               case PG_WAIT_CLIENT:
                        {
                                WaitEventClient w = (WaitEventClient) wait_event_info;
 
                                event_name = pgstat_get_wait_client(w);
                                break;
                        }
-               case WAIT_EXTENSION:
+               case PG_WAIT_EXTENSION:
                        event_name = "Extension";
                        break;
-               case WAIT_IPC:
+               case PG_WAIT_IPC:
                        {
                                WaitEventIPC    w = (WaitEventIPC) wait_event_info;
 
                                event_name = pgstat_get_wait_ipc(w);
                                break;
                        }
-               case WAIT_TIMEOUT:
+               case PG_WAIT_TIMEOUT:
                        {
                                WaitEventTimeout        w = (WaitEventTimeout) wait_event_info;
 

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 91dc24c301918c132e87a835d0ae95d2fed983ea..2b63cd3ef140f7ea52aa1c299c98abcd4779b54d 100644 (file)
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -3646,7 +3646,7 @@ LockBufferForCleanup(Buffer buffer)
                        SetStartupBufferPinWaitBufId(-1);
                }
                else
-                       ProcWaitForSignal(WAIT_BUFFER_PIN);
+                       ProcWaitForSignal(PG_WAIT_BUFFER_PIN);
 
                /*
                 * Remove flag marking us as waiter. Normally this will not be set

diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c
index fb887b3230ab3bad53b725d3dc24ff47f54e889a..875dcec1eba42f9ec6f79445bf2c21590a1f750f 100644 (file)
--- a/src/backend/storage/ipc/standby.c
+++ b/src/backend/storage/ipc/standby.c
@@ -390,7 +390,7 @@ ResolveRecoveryConflictWithLock(LOCKTAG locktag)
        }
 
        /* Wait to be signaled by the release of the Relation Lock */
-       ProcWaitForSignal(WAIT_LOCK | locktag.locktag_type);
+       ProcWaitForSignal(PG_WAIT_LOCK | locktag.locktag_type);
 
        /*
         * Clear any timeout requests established above.  We assume here that the
@@ -470,7 +470,7 @@ ResolveRecoveryConflictWithBufferPin(void)
        }
 
        /* Wait to be signaled by UnpinBuffer() */
-       ProcWaitForSignal(WAIT_BUFFER_PIN);
+       ProcWaitForSignal(PG_WAIT_BUFFER_PIN);
 
        /*
         * Clear any timeout requests established above.  We assume here that the

diff --git a/src/backend/storage/lmgr/lwlock.c b/src/backend/storage/lmgr/lwlock.c
index a90b54ac860ec2032e43e687bfb4b85949f2a415..9c6862f41e01926e7db211073f78703a6bf70ed6 100644 (file)
--- a/src/backend/storage/lmgr/lwlock.c
+++ b/src/backend/storage/lmgr/lwlock.c
@@ -732,9 +732,9 @@ LWLockReportWaitStart(LWLock *lock)
        int                     lockId = T_ID(lock);
 
        if (lock->tranche == 0)
-               pgstat_report_wait_start(WAIT_LWLOCK_NAMED | (uint16) lockId);
+               pgstat_report_wait_start(PG_WAIT_LWLOCK_NAMED | (uint16) lockId);
        else
-               pgstat_report_wait_start(WAIT_LWLOCK_TRANCHE | lock->tranche);
+               pgstat_report_wait_start(PG_WAIT_LWLOCK_TRANCHE | lock->tranche);
 }
 
 /*
@@ -752,10 +752,10 @@ LWLockReportWaitEnd(void)
 const char *
 GetLWLockIdentifier(uint32 classId, uint16 eventId)
 {
-       if (classId == WAIT_LWLOCK_NAMED)
+       if (classId == PG_WAIT_LWLOCK_NAMED)
                return MainLWLockNames[eventId];
 
-       Assert(classId == WAIT_LWLOCK_TRANCHE);
+       Assert(classId == PG_WAIT_LWLOCK_TRANCHE);
 
        /*
         * It is quite possible that user has registered tranche in one of the

diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c
index dd76094bcd35b1eb65269faff2b58abeb26a5033..b2016312a51d23afa3a2b96c27f3477188600716 100644 (file)
--- a/src/backend/storage/lmgr/proc.c
+++ b/src/backend/storage/lmgr/proc.c
@@ -1214,7 +1214,7 @@ ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable)
                else
                {
                        WaitLatch(MyLatch, WL_LATCH_SET, 0,
-                                         WAIT_LOCK | locallock->tag.lock.locktag_type);
+                                         PG_WAIT_LOCK | locallock->tag.lock.locktag_type);
                        ResetLatch(MyLatch);
                        /* check for deadlocks first, as that's probably log-worthy */
                        if (got_deadlock_timeout)

diff --git a/src/include/pgstat.h b/src/include/pgstat.h
index 27be5493fd6232db314a46c94d0d6d594ac19a49..1c9bf1359e36baf2ba2d019cd08ffad6fe96e150 100644 (file)
--- a/src/include/pgstat.h
+++ b/src/include/pgstat.h
@@ -715,15 +715,15 @@ typedef enum BackendState
  * Wait Classes
  * ----------
  */
-#define WAIT_LWLOCK_NAMED                      0x01000000U
-#define WAIT_LWLOCK_TRANCHE                    0x02000000U
-#define WAIT_LOCK                                      0x03000000U
-#define WAIT_BUFFER_PIN                                0x04000000U
-#define WAIT_ACTIVITY                          0x05000000U
-#define WAIT_CLIENT                                    0x06000000U
-#define WAIT_EXTENSION                         0x07000000U
-#define WAIT_IPC                                       0x08000000U
-#define WAIT_TIMEOUT                           0x09000000U
+#define PG_WAIT_LWLOCK_NAMED           0x01000000U
+#define PG_WAIT_LWLOCK_TRANCHE         0x02000000U
+#define PG_WAIT_LOCK                           0x03000000U
+#define PG_WAIT_BUFFER_PIN                     0x04000000U
+#define PG_WAIT_ACTIVITY                       0x05000000U
+#define PG_WAIT_CLIENT                         0x06000000U
+#define PG_WAIT_EXTENSION                      0x07000000U
+#define PG_WAIT_IPC                                    0x08000000U
+#define PG_WAIT_TIMEOUT                                0x09000000U
 
 /* ----------
  * Wait Events - Activity
@@ -735,7 +735,7 @@ typedef enum BackendState
  */
 typedef enum
 {
-       WAIT_EVENT_ARCHIVER_MAIN = WAIT_ACTIVITY,
+       WAIT_EVENT_ARCHIVER_MAIN = PG_WAIT_ACTIVITY,
        WAIT_EVENT_AUTOVACUUM_MAIN,
        WAIT_EVENT_BGWRITER_HIBERNATE,
        WAIT_EVENT_BGWRITER_MAIN,
@@ -759,7 +759,7 @@ typedef enum
  */
 typedef enum
 {
-       WAIT_EVENT_CLIENT_READ = WAIT_CLIENT,
+       WAIT_EVENT_CLIENT_READ = PG_WAIT_CLIENT,
        WAIT_EVENT_CLIENT_WRITE,
        WAIT_EVENT_SSL_OPEN_SERVER,
        WAIT_EVENT_WAL_RECEIVER_WAIT_START,
@@ -776,7 +776,7 @@ typedef enum
  */
 typedef enum
 {
-       WAIT_EVENT_BGWORKER_SHUTDOWN = WAIT_IPC,
+       WAIT_EVENT_BGWORKER_SHUTDOWN = PG_WAIT_IPC,
        WAIT_EVENT_BGWORKER_STARTUP,
        WAIT_EVENT_EXECUTE_GATHER,
        WAIT_EVENT_MQ_INTERNAL,
@@ -796,7 +796,7 @@ typedef enum
  */
 typedef enum
 {
-       WAIT_EVENT_BASE_BACKUP_THROTTLE = WAIT_TIMEOUT,
+       WAIT_EVENT_BASE_BACKUP_THROTTLE = PG_WAIT_TIMEOUT,
        WAIT_EVENT_PG_SLEEP,
        WAIT_EVENT_RECOVERY_APPLY_DELAY
 } WaitEventTimeout;

diff --git a/src/test/modules/test_shm_mq/setup.c b/src/test/modules/test_shm_mq/setup.c
index cb86f3c37d4d31c6d1a75e2b4d8ae9dee5ba0826..5cfffe4471e7eab0dead2911e1c735014baa9eb7 100644 (file)
--- a/src/test/modules/test_shm_mq/setup.c
+++ b/src/test/modules/test_shm_mq/setup.c
@@ -280,7 +280,7 @@ wait_for_workers_to_become_ready(worker_state *wstate,
                }
 
                /* Wait to be signalled. */
-               WaitLatch(MyLatch, WL_LATCH_SET, 0, WAIT_EXTENSION);
+               WaitLatch(MyLatch, WL_LATCH_SET, 0, PG_WAIT_EXTENSION);
 
                /* Reset the latch so we don't spin. */
                ResetLatch(MyLatch);

diff --git a/src/test/modules/test_shm_mq/test.c b/src/test/modules/test_shm_mq/test.c
index bf11137a9630a6210596612444542d3b2513a6c0..b0f3d3daecdbf08e750365a97954193c63ee60c2 100644 (file)
--- a/src/test/modules/test_shm_mq/test.c
+++ b/src/test/modules/test_shm_mq/test.c
@@ -231,7 +231,7 @@ test_shm_mq_pipelined(PG_FUNCTION_ARGS)
                         * have read or written data and therefore there may now be work
                         * for us to do.
                         */
-                       WaitLatch(MyLatch, WL_LATCH_SET, 0, WAIT_EXTENSION);
+                       WaitLatch(MyLatch, WL_LATCH_SET, 0, PG_WAIT_EXTENSION);
                        ResetLatch(MyLatch);
                        CHECK_FOR_INTERRUPTS();
                }

diff --git a/src/test/modules/worker_spi/worker_spi.c b/src/test/modules/worker_spi/worker_spi.c
index f8395bfb57db8d209bb4f4c8d72ce8f74127a26e..5f495498ae4f7510c3c35f4c375e39a947620bd1 100644 (file)
--- a/src/test/modules/worker_spi/worker_spi.c
+++ b/src/test/modules/worker_spi/worker_spi.c
@@ -228,7 +228,7 @@ worker_spi_main(Datum main_arg)
                rc = WaitLatch(MyLatch,
                                           WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH,
                                           worker_spi_naptime * 1000L,
-                                          WAIT_EXTENSION);
+                                          PG_WAIT_EXTENSION);
                ResetLatch(MyLatch);
 
                /* emergency bailout if postmaster has died */