pg_query 2.2.0 → 6.1.0

data/ext/pg_query/include/storage/lwlock.h

@@ -1,233 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * lwlock.h
- *	  Lightweight lock manager
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/lwlock.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef LWLOCK_H
-#define LWLOCK_H
-
-#ifdef FRONTEND
-#error "lwlock.h may not be included from frontend code"
-#endif
-
-#include "port/atomics.h"
-#include "storage/proclist_types.h"
-#include "storage/s_lock.h"
-
-struct PGPROC;
-
-/*
- * Code outside of lwlock.c should not manipulate the contents of this
- * structure directly, but we have to declare it here to allow LWLocks to be
- * incorporated into other data structures.
- */
-typedef struct LWLock
-{
-	uint16		tranche;		/* tranche ID */
-	pg_atomic_uint32 state;		/* state of exclusive/nonexclusive lockers */
-	proclist_head waiters;		/* list of waiting PGPROCs */
-#ifdef LOCK_DEBUG
-	pg_atomic_uint32 nwaiters;	/* number of waiters */
-	struct PGPROC *owner;		/* last exclusive owner of the lock */
-#endif
-} LWLock;
-
-/*
- * In most cases, it's desirable to force each tranche of LWLocks to be aligned
- * on a cache line boundary and make the array stride a power of 2.  This saves
- * a few cycles in indexing, but more importantly ensures that individual
- * LWLocks don't cross cache line boundaries.  This reduces cache contention
- * problems, especially on AMD Opterons.  In some cases, it's useful to add
- * even more padding so that each LWLock takes up an entire cache line; this is
- * useful, for example, in the main LWLock array, where the overall number of
- * locks is small but some are heavily contended.
- *
- * When allocating a tranche that contains data other than LWLocks, it is
- * probably best to include a bare LWLock and then pad the resulting structure
- * as necessary for performance.  For an array that contains only LWLocks,
- * LWLockMinimallyPadded can be used for cases where we just want to ensure
- * that we don't cross cache line boundaries within a single lock, while
- * LWLockPadded can be used for cases where we want each lock to be an entire
- * cache line.
- *
- * An LWLockMinimallyPadded might contain more than the absolute minimum amount
- * of padding required to keep a lock from crossing a cache line boundary,
- * because an unpadded LWLock will normally fit into 16 bytes.  We ignore that
- * possibility when determining the minimal amount of padding.  Older releases
- * had larger LWLocks, so 32 really was the minimum, and packing them in
- * tighter might hurt performance.
- *
- * LWLOCK_MINIMAL_SIZE should be 32 on basically all common platforms, but
- * because pg_atomic_uint32 is more than 4 bytes on some obscure platforms, we
- * allow for the possibility that it might be 64.  Even on those platforms,
- * we probably won't exceed 32 bytes unless LOCK_DEBUG is defined.
- */
-#define LWLOCK_PADDED_SIZE	PG_CACHE_LINE_SIZE
-#define LWLOCK_MINIMAL_SIZE (sizeof(LWLock) <= 32 ? 32 : 64)
-
-/* LWLock, padded to a full cache line size */
-typedef union LWLockPadded
-{
-	LWLock		lock;
-	char		pad[LWLOCK_PADDED_SIZE];
-} LWLockPadded;
-
-/* LWLock, minimally padded */
-typedef union LWLockMinimallyPadded
-{
-	LWLock		lock;
-	char		pad[LWLOCK_MINIMAL_SIZE];
-} LWLockMinimallyPadded;
-
-extern PGDLLIMPORT LWLockPadded *MainLWLockArray;
-
-/* struct for storing named tranche information */
-typedef struct NamedLWLockTranche
-{
-	int			trancheId;
-	char	   *trancheName;
-} NamedLWLockTranche;
-
-extern PGDLLIMPORT NamedLWLockTranche *NamedLWLockTrancheArray;
-extern PGDLLIMPORT int NamedLWLockTrancheRequests;
-
-/* Names for fixed lwlocks */
-#include "storage/lwlocknames.h"
-
-/*
- * It's a bit odd to declare NUM_BUFFER_PARTITIONS and NUM_LOCK_PARTITIONS
- * here, but we need them to figure out offsets within MainLWLockArray, and
- * having this file include lock.h or bufmgr.h would be backwards.
- */
-
-/* Number of partitions of the shared buffer mapping hashtable */
-#define NUM_BUFFER_PARTITIONS  128
-
-/* Number of partitions the shared lock tables are divided into */
-#define LOG2_NUM_LOCK_PARTITIONS  4
-#define NUM_LOCK_PARTITIONS  (1 << LOG2_NUM_LOCK_PARTITIONS)
-
-/* Number of partitions the shared predicate lock tables are divided into */
-#define LOG2_NUM_PREDICATELOCK_PARTITIONS  4
-#define NUM_PREDICATELOCK_PARTITIONS  (1 << LOG2_NUM_PREDICATELOCK_PARTITIONS)
-
-/* Offsets for various chunks of preallocated lwlocks. */
-#define BUFFER_MAPPING_LWLOCK_OFFSET	NUM_INDIVIDUAL_LWLOCKS
-#define LOCK_MANAGER_LWLOCK_OFFSET		\
-	(BUFFER_MAPPING_LWLOCK_OFFSET + NUM_BUFFER_PARTITIONS)
-#define PREDICATELOCK_MANAGER_LWLOCK_OFFSET \
-	(LOCK_MANAGER_LWLOCK_OFFSET + NUM_LOCK_PARTITIONS)
-#define NUM_FIXED_LWLOCKS \
-	(PREDICATELOCK_MANAGER_LWLOCK_OFFSET + NUM_PREDICATELOCK_PARTITIONS)
-
-typedef enum LWLockMode
-{
-	LW_EXCLUSIVE,
-	LW_SHARED,
-	LW_WAIT_UNTIL_FREE			/* A special mode used in PGPROC->lwWaitMode,
-								 * when waiting for lock to become free. Not
-								 * to be used as LWLockAcquire argument */
-} LWLockMode;
-
-
-#ifdef LOCK_DEBUG
-extern bool Trace_lwlocks;
-#endif
-
-extern bool LWLockAcquire(LWLock *lock, LWLockMode mode);
-extern bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode);
-extern bool LWLockAcquireOrWait(LWLock *lock, LWLockMode mode);
-extern void LWLockRelease(LWLock *lock);
-extern void LWLockReleaseClearVar(LWLock *lock, uint64 *valptr, uint64 val);
-extern void LWLockReleaseAll(void);
-extern bool LWLockHeldByMe(LWLock *lock);
-extern bool LWLockAnyHeldByMe(LWLock *lock, int nlocks, size_t stride);
-extern bool LWLockHeldByMeInMode(LWLock *lock, LWLockMode mode);
-
-extern bool LWLockWaitForVar(LWLock *lock, uint64 *valptr, uint64 oldval, uint64 *newval);
-extern void LWLockUpdateVar(LWLock *lock, uint64 *valptr, uint64 value);
-
-extern Size LWLockShmemSize(void);
-extern void CreateLWLocks(void);
-extern void InitLWLockAccess(void);
-
-extern const char *GetLWLockIdentifier(uint32 classId, uint16 eventId);
-
-/*
- * Extensions (or core code) can obtain an LWLocks by calling
- * RequestNamedLWLockTranche() during postmaster startup.  Subsequently,
- * call GetNamedLWLockTranche() to obtain a pointer to an array containing
- * the number of LWLocks requested.
- */
-extern void RequestNamedLWLockTranche(const char *tranche_name, int num_lwlocks);
-extern LWLockPadded *GetNamedLWLockTranche(const char *tranche_name);
-
-/*
- * There is another, more flexible method of obtaining lwlocks. First, call
- * LWLockNewTrancheId just once to obtain a tranche ID; this allocates from
- * a shared counter.  Next, each individual process using the tranche should
- * call LWLockRegisterTranche() to associate that tranche ID with a name.
- * Finally, LWLockInitialize should be called just once per lwlock, passing
- * the tranche ID as an argument.
- *
- * It may seem strange that each process using the tranche must register it
- * separately, but dynamic shared memory segments aren't guaranteed to be
- * mapped at the same address in all coordinating backends, so storing the
- * registration in the main shared memory segment wouldn't work for that case.
- */
-extern int	LWLockNewTrancheId(void);
-extern void LWLockRegisterTranche(int tranche_id, const char *tranche_name);
-extern void LWLockInitialize(LWLock *lock, int tranche_id);
-
-/*
- * Every tranche ID less than NUM_INDIVIDUAL_LWLOCKS is reserved; also,
- * we reserve additional tranche IDs for builtin tranches not included in
- * the set of individual LWLocks.  A call to LWLockNewTrancheId will never
- * return a value less than LWTRANCHE_FIRST_USER_DEFINED.
- */
-typedef enum BuiltinTrancheIds
-{
-	LWTRANCHE_XACT_BUFFER = NUM_INDIVIDUAL_LWLOCKS,
-	LWTRANCHE_COMMITTS_BUFFER,
-	LWTRANCHE_SUBTRANS_BUFFER,
-	LWTRANCHE_MULTIXACTOFFSET_BUFFER,
-	LWTRANCHE_MULTIXACTMEMBER_BUFFER,
-	LWTRANCHE_NOTIFY_BUFFER,
-	LWTRANCHE_SERIAL_BUFFER,
-	LWTRANCHE_WAL_INSERT,
-	LWTRANCHE_BUFFER_CONTENT,
-	LWTRANCHE_BUFFER_IO,
-	LWTRANCHE_REPLICATION_ORIGIN_STATE,
-	LWTRANCHE_REPLICATION_SLOT_IO,
-	LWTRANCHE_LOCK_FASTPATH,
-	LWTRANCHE_BUFFER_MAPPING,
-	LWTRANCHE_LOCK_MANAGER,
-	LWTRANCHE_PREDICATE_LOCK_MANAGER,
-	LWTRANCHE_PARALLEL_HASH_JOIN,
-	LWTRANCHE_PARALLEL_QUERY_DSA,
-	LWTRANCHE_PER_SESSION_DSA,
-	LWTRANCHE_PER_SESSION_RECORD_TYPE,
-	LWTRANCHE_PER_SESSION_RECORD_TYPMOD,
-	LWTRANCHE_SHARED_TUPLESTORE,
-	LWTRANCHE_SHARED_TIDBITMAP,
-	LWTRANCHE_PARALLEL_APPEND,
-	LWTRANCHE_PER_XACT_PREDICATE_LIST,
-	LWTRANCHE_FIRST_USER_DEFINED
-}			BuiltinTrancheIds;
-
-/*
- * Prior to PostgreSQL 9.4, we used an enum type called LWLockId to refer
- * to LWLocks.  New code should instead use LWLock *.  However, for the
- * convenience of third-party code, we include the following typedef.
- */
-typedef LWLock *LWLockId;
-
-#endif							/* LWLOCK_H */

data/ext/pg_query/include/storage/lwlocknames.h

@@ -1,51 +0,0 @@
-/* autogenerated from src/backend/storage/lmgr/lwlocknames.txt, do not edit */
-/* there is deliberately not an #ifndef LWLOCKNAMES_H here */
-
-#define ShmemIndexLock (&MainLWLockArray[1].lock)
-#define OidGenLock (&MainLWLockArray[2].lock)
-#define XidGenLock (&MainLWLockArray[3].lock)
-#define ProcArrayLock (&MainLWLockArray[4].lock)
-#define SInvalReadLock (&MainLWLockArray[5].lock)
-#define SInvalWriteLock (&MainLWLockArray[6].lock)
-#define WALBufMappingLock (&MainLWLockArray[7].lock)
-#define WALWriteLock (&MainLWLockArray[8].lock)
-#define ControlFileLock (&MainLWLockArray[9].lock)
-#define CheckpointLock (&MainLWLockArray[10].lock)
-#define XactSLRULock (&MainLWLockArray[11].lock)
-#define SubtransSLRULock (&MainLWLockArray[12].lock)
-#define MultiXactGenLock (&MainLWLockArray[13].lock)
-#define MultiXactOffsetSLRULock (&MainLWLockArray[14].lock)
-#define MultiXactMemberSLRULock (&MainLWLockArray[15].lock)
-#define RelCacheInitLock (&MainLWLockArray[16].lock)
-#define CheckpointerCommLock (&MainLWLockArray[17].lock)
-#define TwoPhaseStateLock (&MainLWLockArray[18].lock)
-#define TablespaceCreateLock (&MainLWLockArray[19].lock)
-#define BtreeVacuumLock (&MainLWLockArray[20].lock)
-#define AddinShmemInitLock (&MainLWLockArray[21].lock)
-#define AutovacuumLock (&MainLWLockArray[22].lock)
-#define AutovacuumScheduleLock (&MainLWLockArray[23].lock)
-#define SyncScanLock (&MainLWLockArray[24].lock)
-#define RelationMappingLock (&MainLWLockArray[25].lock)
-#define NotifySLRULock (&MainLWLockArray[26].lock)
-#define NotifyQueueLock (&MainLWLockArray[27].lock)
-#define SerializableXactHashLock (&MainLWLockArray[28].lock)
-#define SerializableFinishedListLock (&MainLWLockArray[29].lock)
-#define SerializablePredicateListLock (&MainLWLockArray[30].lock)
-#define SerialSLRULock (&MainLWLockArray[31].lock)
-#define SyncRepLock (&MainLWLockArray[32].lock)
-#define BackgroundWorkerLock (&MainLWLockArray[33].lock)
-#define DynamicSharedMemoryControlLock (&MainLWLockArray[34].lock)
-#define AutoFileLock (&MainLWLockArray[35].lock)
-#define ReplicationSlotAllocationLock (&MainLWLockArray[36].lock)
-#define ReplicationSlotControlLock (&MainLWLockArray[37].lock)
-#define CommitTsSLRULock (&MainLWLockArray[38].lock)
-#define CommitTsLock (&MainLWLockArray[39].lock)
-#define ReplicationOriginLock (&MainLWLockArray[40].lock)
-#define MultiXactTruncationLock (&MainLWLockArray[41].lock)
-#define OldSnapshotTimeMapLock (&MainLWLockArray[42].lock)
-#define LogicalRepWorkerLock (&MainLWLockArray[43].lock)
-#define XactTruncationLock (&MainLWLockArray[44].lock)
-#define WrapLimitsVacuumLock (&MainLWLockArray[46].lock)
-#define NotifyQueueTailLock (&MainLWLockArray[47].lock)
-
-#define NUM_INDIVIDUAL_LWLOCKS		48

data/ext/pg_query/include/storage/off.h

@@ -1,57 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * off.h
- *	  POSTGRES disk "offset" definitions.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/off.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef OFF_H
-#define OFF_H
-
-#include "storage/itemid.h"
-/*
- * OffsetNumber:
- *
- * this is a 1-based index into the linp (ItemIdData) array in the
- * header of each disk page.
- */
-typedef uint16 OffsetNumber;
-
-#define InvalidOffsetNumber		((OffsetNumber) 0)
-#define FirstOffsetNumber		((OffsetNumber) 1)
-#define MaxOffsetNumber			((OffsetNumber) (BLCKSZ / sizeof(ItemIdData)))
-
-/* ----------------
- *		support macros
- * ----------------
- */
-
-/*
- * OffsetNumberIsValid
- *		True iff the offset number is valid.
- */
-#define OffsetNumberIsValid(offsetNumber) \
-	((bool) ((offsetNumber != InvalidOffsetNumber) && \
-			 (offsetNumber <= MaxOffsetNumber)))
-
-/*
- * OffsetNumberNext
- * OffsetNumberPrev
- *		Increments/decrements the argument.  These macros look pointless
- *		but they help us disambiguate the different manipulations on
- *		OffsetNumbers (e.g., sometimes we subtract one from an
- *		OffsetNumber to move back, and sometimes we do so to form a
- *		real C array index).
- */
-#define OffsetNumberNext(offsetNumber) \
-	((OffsetNumber) (1 + (offsetNumber)))
-#define OffsetNumberPrev(offsetNumber) \
-	((OffsetNumber) (-1 + (offsetNumber)))
-
-#endif							/* OFF_H */

data/ext/pg_query/include/storage/pg_sema.h

@@ -1,61 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * pg_sema.h
- *	  Platform-independent API for semaphores.
- *
- * PostgreSQL requires counting semaphores (the kind that keep track of
- * multiple unlock operations, and will allow an equal number of subsequent
- * lock operations before blocking).  The underlying implementation is
- * not the same on every platform.  This file defines the API that must
- * be provided by each port.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/pg_sema.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PG_SEMA_H
-#define PG_SEMA_H
-
-/*
- * struct PGSemaphoreData and pointer type PGSemaphore are the data structure
- * representing an individual semaphore.  The contents of PGSemaphoreData vary
- * across implementations and must never be touched by platform-independent
- * code; hence, PGSemaphoreData is declared as an opaque struct here.
- *
- * However, Windows is sufficiently unlike our other ports that it doesn't
- * seem worth insisting on ABI compatibility for Windows too.  Hence, on
- * that platform just define PGSemaphore as HANDLE.
- */
-#ifndef USE_WIN32_SEMAPHORES
-typedef struct PGSemaphoreData *PGSemaphore;
-#else
-typedef HANDLE PGSemaphore;
-#endif
-
-
-/* Report amount of shared memory needed */
-extern Size PGSemaphoreShmemSize(int maxSemas);
-
-/* Module initialization (called during postmaster start or shmem reinit) */
-extern void PGReserveSemaphores(int maxSemas);
-
-/* Allocate a PGSemaphore structure with initial count 1 */
-extern PGSemaphore PGSemaphoreCreate(void);
-
-/* Reset a previously-initialized PGSemaphore to have count 0 */
-extern void PGSemaphoreReset(PGSemaphore sema);
-
-/* Lock a semaphore (decrement count), blocking if count would be < 0 */
-extern void PGSemaphoreLock(PGSemaphore sema);
-
-/* Unlock a semaphore (increment count) */
-extern void PGSemaphoreUnlock(PGSemaphore sema);
-
-/* Lock a semaphore only if able to do so without blocking */
-extern bool PGSemaphoreTryLock(PGSemaphore sema);
-
-#endif							/* PG_SEMA_H */

data/ext/pg_query/include/storage/pg_shmem.h

@@ -1,90 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * pg_shmem.h
- *	  Platform-independent API for shared memory support.
- *
- * Every port is expected to support shared memory with approximately
- * SysV-ish semantics; in particular, a memory block is not anonymous
- * but has an ID, and we must be able to tell whether there are any
- * remaining processes attached to a block of a specified ID.
- *
- * To simplify life for the SysV implementation, the ID is assumed to
- * consist of two unsigned long values (these are key and ID in SysV
- * terms).  Other platforms may ignore the second value if they need
- * only one ID number.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/pg_shmem.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PG_SHMEM_H
-#define PG_SHMEM_H
-
-#include "storage/dsm_impl.h"
-
-typedef struct PGShmemHeader	/* standard header for all Postgres shmem */
-{
-	int32		magic;			/* magic # to identify Postgres segments */
-#define PGShmemMagic  679834894
-	pid_t		creatorPID;		/* PID of creating process (set but unread) */
-	Size		totalsize;		/* total size of segment */
-	Size		freeoffset;		/* offset to first free space */
-	dsm_handle	dsm_control;	/* ID of dynamic shared memory control seg */
-	void	   *index;			/* pointer to ShmemIndex table */
-#ifndef WIN32					/* Windows doesn't have useful inode#s */
-	dev_t		device;			/* device data directory is on */
-	ino_t		inode;			/* inode number of data directory */
-#endif
-} PGShmemHeader;
-
-/* GUC variables */
-extern int	shared_memory_type;
-extern int	huge_pages;
-
-/* Possible values for huge_pages */
-typedef enum
-{
-	HUGE_PAGES_OFF,
-	HUGE_PAGES_ON,
-	HUGE_PAGES_TRY
-}			HugePagesType;
-
-/* Possible values for shared_memory_type */
-typedef enum
-{
-	SHMEM_TYPE_WINDOWS,
-	SHMEM_TYPE_SYSV,
-	SHMEM_TYPE_MMAP
-}			PGShmemType;
-
-#ifndef WIN32
-extern unsigned long UsedShmemSegID;
-#else
-extern HANDLE UsedShmemSegID;
-extern void *ShmemProtectiveRegion;
-#endif
-extern void *UsedShmemSegAddr;
-
-#if !defined(WIN32) && !defined(EXEC_BACKEND)
-#define DEFAULT_SHARED_MEMORY_TYPE SHMEM_TYPE_MMAP
-#elif !defined(WIN32)
-#define DEFAULT_SHARED_MEMORY_TYPE SHMEM_TYPE_SYSV
-#else
-#define DEFAULT_SHARED_MEMORY_TYPE SHMEM_TYPE_WINDOWS
-#endif
-
-#ifdef EXEC_BACKEND
-extern void PGSharedMemoryReAttach(void);
-extern void PGSharedMemoryNoReAttach(void);
-#endif
-
-extern PGShmemHeader *PGSharedMemoryCreate(Size size,
-										   PGShmemHeader **shim);
-extern bool PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2);
-extern void PGSharedMemoryDetach(void);
-
-#endif							/* PG_SHMEM_H */

data/ext/pg_query/include/storage/pmsignal.h

@@ -1,94 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * pmsignal.h
- *	  routines for signaling the postmaster from its child processes
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/pmsignal.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PMSIGNAL_H
-#define PMSIGNAL_H
-
-#include <signal.h>
-
-#ifdef HAVE_SYS_PRCTL_H
-#include "sys/prctl.h"
-#endif
-
-#ifdef HAVE_SYS_PROCCTL_H
-#include "sys/procctl.h"
-#endif
-
-/*
- * Reasons for signaling the postmaster.  We can cope with simultaneous
- * signals for different reasons.  If the same reason is signaled multiple
- * times in quick succession, however, the postmaster is likely to observe
- * only one notification of it.  This is okay for the present uses.
- */
-typedef enum
-{
-	PMSIGNAL_RECOVERY_STARTED,	/* recovery has started */
-	PMSIGNAL_BEGIN_HOT_STANDBY, /* begin Hot Standby */
-	PMSIGNAL_WAKEN_ARCHIVER,	/* send a NOTIFY signal to xlog archiver */
-	PMSIGNAL_ROTATE_LOGFILE,	/* send SIGUSR1 to syslogger to rotate logfile */
-	PMSIGNAL_START_AUTOVAC_LAUNCHER,	/* start an autovacuum launcher */
-	PMSIGNAL_START_AUTOVAC_WORKER,	/* start an autovacuum worker */
-	PMSIGNAL_BACKGROUND_WORKER_CHANGE,	/* background worker state change */
-	PMSIGNAL_START_WALRECEIVER, /* start a walreceiver */
-	PMSIGNAL_ADVANCE_STATE_MACHINE, /* advance postmaster's state machine */
-
-	NUM_PMSIGNALS				/* Must be last value of enum! */
-} PMSignalReason;
-
-/* PMSignalData is an opaque struct, details known only within pmsignal.c */
-typedef struct PMSignalData PMSignalData;
-
-/*
- * prototypes for functions in pmsignal.c
- */
-extern Size PMSignalShmemSize(void);
-extern void PMSignalShmemInit(void);
-extern void SendPostmasterSignal(PMSignalReason reason);
-extern bool CheckPostmasterSignal(PMSignalReason reason);
-extern int	AssignPostmasterChildSlot(void);
-extern bool ReleasePostmasterChildSlot(int slot);
-extern bool IsPostmasterChildWalSender(int slot);
-extern void MarkPostmasterChildActive(void);
-extern void MarkPostmasterChildInactive(void);
-extern void MarkPostmasterChildWalSender(void);
-extern bool PostmasterIsAliveInternal(void);
-extern void PostmasterDeathSignalInit(void);
-
-
-/*
- * Do we have a way to ask for a signal on parent death?
- *
- * If we do, pmsignal.c will set up a signal handler, that sets a flag when
- * the parent dies.  Checking the flag first makes PostmasterIsAlive() a lot
- * cheaper in usual case that the postmaster is alive.
- */
-#if (defined(HAVE_SYS_PRCTL_H) && defined(PR_SET_PDEATHSIG)) || \
-	(defined(HAVE_SYS_PROCCTL_H) && defined(PROC_PDEATHSIG_CTL))
-#define USE_POSTMASTER_DEATH_SIGNAL
-#endif
-
-#ifdef USE_POSTMASTER_DEATH_SIGNAL
-extern volatile sig_atomic_t postmaster_possibly_dead;
-
-static inline bool
-PostmasterIsAlive(void)
-{
-	if (likely(!postmaster_possibly_dead))
-		return true;
-	return PostmasterIsAliveInternal();
-}
-#else
-#define PostmasterIsAlive() PostmasterIsAliveInternal()
-#endif
-
-#endif							/* PMSIGNAL_H */

data/ext/pg_query/include/storage/predicate.h

@@ -1,87 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * predicate.h
- *	  POSTGRES public predicate locking definitions.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/predicate.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PREDICATE_H
-#define PREDICATE_H
-
-#include "storage/lock.h"
-#include "utils/relcache.h"
-#include "utils/snapshot.h"
-
-
-/*
- * GUC variables
- */
-extern int	max_predicate_locks_per_xact;
-extern int	max_predicate_locks_per_relation;
-extern int	max_predicate_locks_per_page;
-
-
-/* Number of SLRU buffers to use for Serial SLRU */
-#define NUM_SERIAL_BUFFERS		16
-
-/*
- * A handle used for sharing SERIALIZABLEXACT objects between the participants
- * in a parallel query.
- */
-typedef void *SerializableXactHandle;
-
-/*
- * function prototypes
- */
-
-/* housekeeping for shared memory predicate lock structures */
-extern void InitPredicateLocks(void);
-extern Size PredicateLockShmemSize(void);
-
-extern void CheckPointPredicate(void);
-
-/* predicate lock reporting */
-extern bool PageIsPredicateLocked(Relation relation, BlockNumber blkno);
-
-/* predicate lock maintenance */
-extern Snapshot GetSerializableTransactionSnapshot(Snapshot snapshot);
-extern void SetSerializableTransactionSnapshot(Snapshot snapshot,
-											   VirtualTransactionId *sourcevxid,
-											   int sourcepid);
-extern void RegisterPredicateLockingXid(TransactionId xid);
-extern void PredicateLockRelation(Relation relation, Snapshot snapshot);
-extern void PredicateLockPage(Relation relation, BlockNumber blkno, Snapshot snapshot);
-extern void PredicateLockTID(Relation relation, ItemPointer tid, Snapshot snapshot,
-							 TransactionId insert_xid);
-extern void PredicateLockPageSplit(Relation relation, BlockNumber oldblkno, BlockNumber newblkno);
-extern void PredicateLockPageCombine(Relation relation, BlockNumber oldblkno, BlockNumber newblkno);
-extern void TransferPredicateLocksToHeapRelation(Relation relation);
-extern void ReleasePredicateLocks(bool isCommit, bool isReadOnlySafe);
-
-/* conflict detection (may also trigger rollback) */
-extern bool CheckForSerializableConflictOutNeeded(Relation relation, Snapshot snapshot);
-extern void CheckForSerializableConflictOut(Relation relation, TransactionId xid, Snapshot snapshot);
-extern void CheckForSerializableConflictIn(Relation relation, ItemPointer tid, BlockNumber blkno);
-extern void CheckTableForSerializableConflictIn(Relation relation);
-
-/* final rollback checking */
-extern void PreCommit_CheckForSerializationFailure(void);
-
-/* two-phase commit support */
-extern void AtPrepare_PredicateLocks(void);
-extern void PostPrepare_PredicateLocks(TransactionId xid);
-extern void PredicateLockTwoPhaseFinish(TransactionId xid, bool isCommit);
-extern void predicatelock_twophase_recover(TransactionId xid, uint16 info,
-										   void *recdata, uint32 len);
-
-/* parallel query support */
-extern SerializableXactHandle ShareSerializableXact(void);
-extern void AttachSerializableXact(SerializableXactHandle handle);
-
-#endif							/* PREDICATE_H */