pg_query 5.0.0 → 6.0.0

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

@@ -1,37 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * sharedfileset.h
- *	  Shared temporary file management.
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/sharedfileset.h
- *
- *-------------------------------------------------------------------------
- */
-
-#ifndef SHAREDFILESET_H
-#define SHAREDFILESET_H
-
-#include "storage/dsm.h"
-#include "storage/fd.h"
-#include "storage/fileset.h"
-#include "storage/spin.h"
-
-/*
- * A set of temporary files that can be shared by multiple backends.
- */
-typedef struct SharedFileSet
-{
-	FileSet		fs;
-	slock_t		mutex;			/* mutex protecting the reference count */
-	int			refcnt;			/* number of attached backends */
-} SharedFileSet;
-
-extern void SharedFileSetInit(SharedFileSet *fileset, dsm_segment *seg);
-extern void SharedFileSetAttach(SharedFileSet *fileset, dsm_segment *seg);
-extern void SharedFileSetDeleteAll(SharedFileSet *fileset);
-
-#endif

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

@@ -1,86 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * shm_mq.h
- *	  single-reader, single-writer shared memory message queue
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/shm_mq.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef SHM_MQ_H
-#define SHM_MQ_H
-
-#include "postmaster/bgworker.h"
-#include "storage/dsm.h"
-#include "storage/proc.h"
-
-/* The queue itself, in shared memory. */
-struct shm_mq;
-typedef struct shm_mq shm_mq;
-
-/* Backend-private state. */
-struct shm_mq_handle;
-typedef struct shm_mq_handle shm_mq_handle;
-
-/* Descriptors for a single write spanning multiple locations. */
-typedef struct
-{
-	const char *data;
-	Size		len;
-} shm_mq_iovec;
-
-/* Possible results of a send or receive operation. */
-typedef enum
-{
-	SHM_MQ_SUCCESS,				/* Sent or received a message. */
-	SHM_MQ_WOULD_BLOCK,			/* Not completed; retry later. */
-	SHM_MQ_DETACHED				/* Other process has detached queue. */
-} shm_mq_result;
-
-/*
- * Primitives to create a queue and set the sender and receiver.
- *
- * Both the sender and the receiver must be set before any messages are read
- * or written, but they need not be set by the same process.  Each must be
- * set exactly once.
- */
-extern shm_mq *shm_mq_create(void *address, Size size);
-extern void shm_mq_set_receiver(shm_mq *mq, PGPROC *);
-extern void shm_mq_set_sender(shm_mq *mq, PGPROC *);
-
-/* Accessor methods for sender and receiver. */
-extern PGPROC *shm_mq_get_receiver(shm_mq *);
-extern PGPROC *shm_mq_get_sender(shm_mq *);
-
-/* Set up backend-local queue state. */
-extern shm_mq_handle *shm_mq_attach(shm_mq *mq, dsm_segment *seg,
-									BackgroundWorkerHandle *handle);
-
-/* Associate worker handle with shm_mq. */
-extern void shm_mq_set_handle(shm_mq_handle *, BackgroundWorkerHandle *);
-
-/* Break connection, release handle resources. */
-extern void shm_mq_detach(shm_mq_handle *mqh);
-
-/* Get the shm_mq from handle. */
-extern shm_mq *shm_mq_get_queue(shm_mq_handle *mqh);
-
-/* Send or receive messages. */
-extern shm_mq_result shm_mq_send(shm_mq_handle *mqh,
-								 Size nbytes, const void *data, bool nowait,
-								 bool force_flush);
-extern shm_mq_result shm_mq_sendv(shm_mq_handle *mqh, shm_mq_iovec *iov,
-								  int iovcnt, bool nowait, bool force_flush);
-extern shm_mq_result shm_mq_receive(shm_mq_handle *mqh,
-									Size *nbytesp, void **datap, bool nowait);
-
-/* Wait for our counterparty to attach to the queue. */
-extern shm_mq_result shm_mq_wait_for_attach(shm_mq_handle *mqh);
-
-/* Smallest possible queue. */
-extern PGDLLIMPORT const Size shm_mq_minimum_size;
-
-#endif							/* SHM_MQ_H */

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

@@ -1,58 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * shm_toc.h
- *	  shared memory segment table of contents
- *
- * This is intended to provide a simple way to divide a chunk of shared
- * memory (probably dynamic shared memory allocated via dsm_create) into
- * a number of regions and keep track of the addresses of those regions or
- * key data structures within those regions.  This is not intended to
- * scale to a large number of keys and will perform poorly if used that
- * way; if you need a large number of pointers, store them within some
- * other data structure within the segment and only put the pointer to
- * the data structure itself in the table of contents.
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/shm_toc.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef SHM_TOC_H
-#define SHM_TOC_H
-
-#include "storage/shmem.h"		/* for add_size() */
-
-/* shm_toc is an opaque type known only within shm_toc.c */
-typedef struct shm_toc shm_toc;
-
-extern shm_toc *shm_toc_create(uint64 magic, void *address, Size nbytes);
-extern shm_toc *shm_toc_attach(uint64 magic, void *address);
-extern void *shm_toc_allocate(shm_toc *toc, Size nbytes);
-extern Size shm_toc_freespace(shm_toc *toc);
-extern void shm_toc_insert(shm_toc *toc, uint64 key, void *address);
-extern void *shm_toc_lookup(shm_toc *toc, uint64 key, bool noError);
-
-/*
- * Tools for estimating how large a chunk of shared memory will be needed
- * to store a TOC and its dependent objects.  Note: we don't really support
- * large numbers of keys, but it's convenient to declare number_of_keys
- * as a Size anyway.
- */
-typedef struct
-{
-	Size		space_for_chunks;
-	Size		number_of_keys;
-} shm_toc_estimator;
-
-#define shm_toc_initialize_estimator(e) \
-	((e)->space_for_chunks = 0, (e)->number_of_keys = 0)
-#define shm_toc_estimate_chunk(e, sz) \
-	((e)->space_for_chunks = add_size((e)->space_for_chunks, BUFFERALIGN(sz)))
-#define shm_toc_estimate_keys(e, cnt) \
-	((e)->number_of_keys = add_size((e)->number_of_keys, cnt))
-
-extern Size shm_toc_estimate(shm_toc_estimator *e);
-
-#endif							/* SHM_TOC_H */

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

@@ -1,59 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * shmem.h
- *	  shared memory management structures
- *
- * Historical note:
- * A long time ago, Postgres' shared memory region was allowed to be mapped
- * at a different address in each process, and shared memory "pointers" were
- * passed around as offsets relative to the start of the shared memory region.
- * That is no longer the case: each process must map the shared memory region
- * at the same address.  This means shared memory pointers can be passed
- * around directly between different processes.
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/shmem.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef SHMEM_H
-#define SHMEM_H
-
-#include "utils/hsearch.h"
-
-
-/* shmem.c */
-extern void InitShmemAccess(void *seghdr);
-extern void InitShmemAllocation(void);
-extern void *ShmemAlloc(Size size);
-extern void *ShmemAllocNoError(Size size);
-extern void *ShmemAllocUnlocked(Size size);
-extern bool ShmemAddrIsValid(const void *addr);
-extern void InitShmemIndex(void);
-extern HTAB *ShmemInitHash(const char *name, long init_size, long max_size,
-						   HASHCTL *infoP, int hash_flags);
-extern void *ShmemInitStruct(const char *name, Size size, bool *foundPtr);
-extern Size add_size(Size s1, Size s2);
-extern Size mul_size(Size s1, Size s2);
-
-/* ipci.c */
-extern void RequestAddinShmemSpace(Size size);
-
-/* size constants for the shmem index table */
- /* max size of data structure string name */
-#define SHMEM_INDEX_KEYSIZE		 (48)
- /* estimated size of the shmem index table (not a hard limit) */
-#define SHMEM_INDEX_SIZE		 (64)
-
-/* this is a hash bucket in the shmem index table */
-typedef struct
-{
-	char		key[SHMEM_INDEX_KEYSIZE];	/* string name */
-	void	   *location;		/* location in shared mem */
-	Size		size;			/* # bytes requested for the structure */
-	Size		allocated_size; /* # bytes actually allocated */
-} ShmemIndexEnt;
-
-#endif							/* SHMEM_H */

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

@@ -1,153 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * sinval.h
- *	  POSTGRES shared cache invalidation communication definitions.
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/sinval.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef SINVAL_H
-#define SINVAL_H
-
-#include <signal.h>
-
-#include "storage/relfilelocator.h"
-
-/*
- * We support several types of shared-invalidation messages:
- *	* invalidate a specific tuple in a specific catcache
- *	* invalidate all catcache entries from a given system catalog
- *	* invalidate a relcache entry for a specific logical relation
- *	* invalidate all relcache entries
- *	* invalidate an smgr cache entry for a specific physical relation
- *	* invalidate the mapped-relation mapping for a given database
- *	* invalidate any saved snapshot that might be used to scan a given relation
- * More types could be added if needed.  The message type is identified by
- * the first "int8" field of the message struct.  Zero or positive means a
- * specific-catcache inval message (and also serves as the catcache ID field).
- * Negative values identify the other message types, as per codes below.
- *
- * Catcache inval events are initially driven by detecting tuple inserts,
- * updates and deletions in system catalogs (see CacheInvalidateHeapTuple).
- * An update can generate two inval events, one for the old tuple and one for
- * the new, but this is reduced to one event if the tuple's hash key doesn't
- * change.  Note that the inval events themselves don't actually say whether
- * the tuple is being inserted or deleted.  Also, since we transmit only a
- * hash key, there is a small risk of unnecessary invalidations due to chance
- * matches of hash keys.
- *
- * Note that some system catalogs have multiple caches on them (with different
- * indexes).  On detecting a tuple invalidation in such a catalog, separate
- * catcache inval messages must be generated for each of its caches, since
- * the hash keys will generally be different.
- *
- * Catcache, relcache, and snapshot invalidations are transactional, and so
- * are sent to other backends upon commit.  Internally to the generating
- * backend, they are also processed at CommandCounterIncrement so that later
- * commands in the same transaction see the new state.  The generating backend
- * also has to process them at abort, to flush out any cache state it's loaded
- * from no-longer-valid entries.
- *
- * smgr and relation mapping invalidations are non-transactional: they are
- * sent immediately when the underlying file change is made.
- */
-
-typedef struct
-{
-	int8		id;				/* cache ID --- must be first */
-	Oid			dbId;			/* database ID, or 0 if a shared relation */
-	uint32		hashValue;		/* hash value of key for this catcache */
-} SharedInvalCatcacheMsg;
-
-#define SHAREDINVALCATALOG_ID	(-1)
-
-typedef struct
-{
-	int8		id;				/* type field --- must be first */
-	Oid			dbId;			/* database ID, or 0 if a shared catalog */
-	Oid			catId;			/* ID of catalog whose contents are invalid */
-} SharedInvalCatalogMsg;
-
-#define SHAREDINVALRELCACHE_ID	(-2)
-
-typedef struct
-{
-	int8		id;				/* type field --- must be first */
-	Oid			dbId;			/* database ID, or 0 if a shared relation */
-	Oid			relId;			/* relation ID, or 0 if whole relcache */
-} SharedInvalRelcacheMsg;
-
-#define SHAREDINVALSMGR_ID		(-3)
-
-typedef struct
-{
-	/* note: field layout chosen to pack into 16 bytes */
-	int8		id;				/* type field --- must be first */
-	int8		backend_hi;		/* high bits of backend ID, if temprel */
-	uint16		backend_lo;		/* low bits of backend ID, if temprel */
-	RelFileLocator rlocator;	/* spcOid, dbOid, relNumber */
-} SharedInvalSmgrMsg;
-
-#define SHAREDINVALRELMAP_ID	(-4)
-
-typedef struct
-{
-	int8		id;				/* type field --- must be first */
-	Oid			dbId;			/* database ID, or 0 for shared catalogs */
-} SharedInvalRelmapMsg;
-
-#define SHAREDINVALSNAPSHOT_ID	(-5)
-
-typedef struct
-{
-	int8		id;				/* type field --- must be first */
-	Oid			dbId;			/* database ID, or 0 if a shared relation */
-	Oid			relId;			/* relation ID */
-} SharedInvalSnapshotMsg;
-
-typedef union
-{
-	int8		id;				/* type field --- must be first */
-	SharedInvalCatcacheMsg cc;
-	SharedInvalCatalogMsg cat;
-	SharedInvalRelcacheMsg rc;
-	SharedInvalSmgrMsg sm;
-	SharedInvalRelmapMsg rm;
-	SharedInvalSnapshotMsg sn;
-} SharedInvalidationMessage;
-
-
-/* Counter of messages processed; don't worry about overflow. */
-extern PGDLLIMPORT uint64 SharedInvalidMessageCounter;
-
-extern PGDLLIMPORT volatile sig_atomic_t catchupInterruptPending;
-
-extern void SendSharedInvalidMessages(const SharedInvalidationMessage *msgs,
-									  int n);
-extern void ReceiveSharedInvalidMessages(void (*invalFunction) (SharedInvalidationMessage *msg),
-										 void (*resetFunction) (void));
-
-/* signal handler for catchup events (PROCSIG_CATCHUP_INTERRUPT) */
-extern void HandleCatchupInterrupt(void);
-
-/*
- * enable/disable processing of catchup events directly from signal handler.
- * The enable routine first performs processing of any catchup events that
- * have occurred since the last disable.
- */
-extern void ProcessCatchupInterrupt(void);
-
-extern int	xactGetCommittedInvalidationMessages(SharedInvalidationMessage **msgs,
-												 bool *RelcacheInitFileInval);
-extern void ProcessCommittedInvalidationMessages(SharedInvalidationMessage *msgs,
-												 int nmsgs, bool RelcacheInitFileInval,
-												 Oid dbid, Oid tsid);
-
-extern void LocalExecuteInvalidationMessage(SharedInvalidationMessage *msg);
-
-#endif							/* SINVAL_H */

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

@@ -1,45 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * sinvaladt.h
- *	  POSTGRES shared cache invalidation data manager.
- *
- * The shared cache invalidation manager is responsible for transmitting
- * invalidation messages between backends.  Any message sent by any backend
- * must be delivered to all already-running backends before it can be
- * forgotten.  (If we run out of space, we instead deliver a "RESET"
- * message to backends that have fallen too far behind.)
- *
- * The struct type SharedInvalidationMessage, defining the contents of
- * a single message, is defined in sinval.h.
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/sinvaladt.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef SINVALADT_H
-#define SINVALADT_H
-
-#include "storage/lock.h"
-#include "storage/sinval.h"
-
-/*
- * prototypes for functions in sinvaladt.c
- */
-extern Size SInvalShmemSize(void);
-extern void CreateSharedInvalidationState(void);
-extern void SharedInvalBackendInit(bool sendOnly);
-extern PGPROC *BackendIdGetProc(int backendID);
-extern void BackendIdGetTransactionIds(int backendID, TransactionId *xid,
-									   TransactionId *xmin, int *nsubxid,
-									   bool *overflowed);
-
-extern void SIInsertDataEntries(const SharedInvalidationMessage *data, int n);
-extern int	SIGetDataEntries(SharedInvalidationMessage *data, int datasize);
-extern void SICleanupQueue(bool callerHasWriteLock, int minFree);
-
-extern LocalTransactionId GetNextLocalTransactionId(void);
-
-#endif							/* SINVALADT_H */

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

@@ -1,113 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * smgr.h
- *	  storage manager switch public interface declarations.
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/smgr.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef SMGR_H
-#define SMGR_H
-
-#include "lib/ilist.h"
-#include "storage/block.h"
-#include "storage/relfilelocator.h"
-
-/*
- * smgr.c maintains a table of SMgrRelation objects, which are essentially
- * cached file handles.  An SMgrRelation is created (if not already present)
- * by smgropen(), and destroyed by smgrclose().  Note that neither of these
- * operations imply I/O, they just create or destroy a hashtable entry.
- * (But smgrclose() may release associated resources, such as OS-level file
- * descriptors.)
- *
- * An SMgrRelation may have an "owner", which is just a pointer to it from
- * somewhere else; smgr.c will clear this pointer if the SMgrRelation is
- * closed.  We use this to avoid dangling pointers from relcache to smgr
- * without having to make the smgr explicitly aware of relcache.  There
- * can't be more than one "owner" pointer per SMgrRelation, but that's
- * all we need.
- *
- * SMgrRelations that do not have an "owner" are considered to be transient,
- * and are deleted at end of transaction.
- */
-typedef struct SMgrRelationData
-{
-	/* rlocator is the hashtable lookup key, so it must be first! */
-	RelFileLocatorBackend smgr_rlocator;	/* relation physical identifier */
-
-	/* pointer to owning pointer, or NULL if none */
-	struct SMgrRelationData **smgr_owner;
-
-	/*
-	 * The following fields are reset to InvalidBlockNumber upon a cache flush
-	 * event, and hold the last known size for each fork.  This information is
-	 * currently only reliable during recovery, since there is no cache
-	 * invalidation for fork extension.
-	 */
-	BlockNumber smgr_targblock; /* current insertion target block */
-	BlockNumber smgr_cached_nblocks[MAX_FORKNUM + 1];	/* last known size */
-
-	/* additional public fields may someday exist here */
-
-	/*
-	 * Fields below here are intended to be private to smgr.c and its
-	 * submodules.  Do not touch them from elsewhere.
-	 */
-	int			smgr_which;		/* storage manager selector */
-
-	/*
-	 * for md.c; per-fork arrays of the number of open segments
-	 * (md_num_open_segs) and the segments themselves (md_seg_fds).
-	 */
-	int			md_num_open_segs[MAX_FORKNUM + 1];
-	struct _MdfdVec *md_seg_fds[MAX_FORKNUM + 1];
-
-	/* if unowned, list link in list of all unowned SMgrRelations */
-	dlist_node	node;
-} SMgrRelationData;
-
-typedef SMgrRelationData *SMgrRelation;
-
-#define SmgrIsTemp(smgr) \
-	RelFileLocatorBackendIsTemp((smgr)->smgr_rlocator)
-
-extern void smgrinit(void);
-extern SMgrRelation smgropen(RelFileLocator rlocator, BackendId backend);
-extern bool smgrexists(SMgrRelation reln, ForkNumber forknum);
-extern void smgrsetowner(SMgrRelation *owner, SMgrRelation reln);
-extern void smgrclearowner(SMgrRelation *owner, SMgrRelation reln);
-extern void smgrclose(SMgrRelation reln);
-extern void smgrcloseall(void);
-extern void smgrcloserellocator(RelFileLocatorBackend rlocator);
-extern void smgrrelease(SMgrRelation reln);
-extern void smgrreleaseall(void);
-extern void smgrcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo);
-extern void smgrdosyncall(SMgrRelation *rels, int nrels);
-extern void smgrdounlinkall(SMgrRelation *rels, int nrels, bool isRedo);
-extern void smgrextend(SMgrRelation reln, ForkNumber forknum,
-					   BlockNumber blocknum, const void *buffer, bool skipFsync);
-extern void smgrzeroextend(SMgrRelation reln, ForkNumber forknum,
-						   BlockNumber blocknum, int nblocks, bool skipFsync);
-extern bool smgrprefetch(SMgrRelation reln, ForkNumber forknum,
-						 BlockNumber blocknum);
-extern void smgrread(SMgrRelation reln, ForkNumber forknum,
-					 BlockNumber blocknum, void *buffer);
-extern void smgrwrite(SMgrRelation reln, ForkNumber forknum,
-					  BlockNumber blocknum, const void *buffer, bool skipFsync);
-extern void smgrwriteback(SMgrRelation reln, ForkNumber forknum,
-						  BlockNumber blocknum, BlockNumber nblocks);
-extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum);
-extern BlockNumber smgrnblocks_cached(SMgrRelation reln, ForkNumber forknum);
-extern void smgrtruncate(SMgrRelation reln, ForkNumber *forknum,
-						 int nforks, BlockNumber *nblocks);
-extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
-extern void AtEOXact_SMgr(void);
-extern bool ProcessBarrierSmgrRelease(void);
-
-#endif							/* SMGR_H */

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

@@ -1,77 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * spin.h
- *	   Hardware-independent implementation of spinlocks.
- *
- *
- *	The hardware-independent interface to spinlocks is defined by the
- *	typedef "slock_t" and these macros:
- *
- *	void SpinLockInit(volatile slock_t *lock)
- *		Initialize a spinlock (to the unlocked state).
- *
- *	void SpinLockAcquire(volatile slock_t *lock)
- *		Acquire a spinlock, waiting if necessary.
- *		Time out and abort() if unable to acquire the lock in a
- *		"reasonable" amount of time --- typically ~ 1 minute.
- *
- *	void SpinLockRelease(volatile slock_t *lock)
- *		Unlock a previously acquired lock.
- *
- *	bool SpinLockFree(slock_t *lock)
- *		Tests if the lock is free. Returns true if free, false if locked.
- *		This does *not* change the state of the lock.
- *
- *	Callers must beware that the macro argument may be evaluated multiple
- *	times!
- *
- *	Load and store operations in calling code are guaranteed not to be
- *	reordered with respect to these operations, because they include a
- *	compiler barrier.  (Before PostgreSQL 9.5, callers needed to use a
- *	volatile qualifier to access data protected by spinlocks.)
- *
- *	Keep in mind the coding rule that spinlocks must not be held for more
- *	than a few instructions.  In particular, we assume it is not possible
- *	for a CHECK_FOR_INTERRUPTS() to occur while holding a spinlock, and so
- *	it is not necessary to do HOLD/RESUME_INTERRUPTS() in these macros.
- *
- *	These macros are implemented in terms of hardware-dependent macros
- *	supplied by s_lock.h.  There is not currently any extra functionality
- *	added by this header, but there has been in the past and may someday
- *	be again.
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/spin.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef SPIN_H
-#define SPIN_H
-
-#include "storage/s_lock.h"
-#ifndef HAVE_SPINLOCKS
-#include "storage/pg_sema.h"
-#endif
-
-
-#define SpinLockInit(lock)	S_INIT_LOCK(lock)
-
-#define SpinLockAcquire(lock) S_LOCK(lock)
-
-#define SpinLockRelease(lock) S_UNLOCK(lock)
-
-#define SpinLockFree(lock)	S_LOCK_FREE(lock)
-
-
-extern int	SpinlockSemas(void);
-extern Size SpinlockSemaSize(void);
-
-#ifndef HAVE_SPINLOCKS
-extern void SpinlockSemaInit(void);
-extern PGDLLIMPORT PGSemaphore *SpinlockSemaArray;
-#endif
-
-#endif							/* SPIN_H */