2014-02-01 04:45:17 +01:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* slot.c
|
|
|
|
* Replication slot management.
|
|
|
|
*
|
|
|
|
*
|
2022-01-08 01:04:57 +01:00
|
|
|
* Copyright (c) 2012-2022, PostgreSQL Global Development Group
|
2014-02-01 04:45:17 +01:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
|
|
|
* src/backend/replication/slot.c
|
|
|
|
*
|
|
|
|
* NOTES
|
|
|
|
*
|
|
|
|
* Replication slots are used to keep state about replication streams
|
|
|
|
* originating from this cluster. Their primary purpose is to prevent the
|
|
|
|
* premature removal of WAL or of old tuple versions in a manner that would
|
2014-02-02 02:28:18 +01:00
|
|
|
* interfere with replication; they are also useful for monitoring purposes.
|
2014-02-01 04:45:17 +01:00
|
|
|
* Slots need to be permanent (to allow restarts), crash-safe, and allocatable
|
|
|
|
* on standbys (to support cascading setups). The requirement that slots be
|
|
|
|
* usable on standbys precludes storing them in the system catalogs.
|
|
|
|
*
|
|
|
|
* Each replication slot gets its own directory inside the $PGDATA/pg_replslot
|
|
|
|
* directory. Inside that directory the state file will contain the slot's
|
|
|
|
* own data. Additional data can be stored alongside that file if required.
|
|
|
|
* While the server is running, the state data is also cached in memory for
|
|
|
|
* efficiency.
|
|
|
|
*
|
|
|
|
* ReplicationSlotAllocationLock must be taken in exclusive mode to allocate
|
|
|
|
* or free a slot. ReplicationSlotControlLock must be taken in shared mode
|
|
|
|
* to iterate over the slots, and in exclusive mode to change the in_use flag
|
|
|
|
* of a slot. The remaining data in each slot is protected by its mutex.
|
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "postgres.h"
|
|
|
|
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
|
|
|
#include "access/transam.h"
|
2015-08-11 12:34:31 +02:00
|
|
|
#include "access/xlog_internal.h"
|
2015-01-03 20:51:52 +01:00
|
|
|
#include "common/string.h"
|
2014-02-01 04:45:17 +01:00
|
|
|
#include "miscadmin.h"
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
#include "pgstat.h"
|
2014-02-01 04:45:17 +01:00
|
|
|
#include "replication/slot.h"
|
|
|
|
#include "storage/fd.h"
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
#include "storage/proc.h"
|
2014-02-01 04:45:17 +01:00
|
|
|
#include "storage/procarray.h"
|
2016-12-08 18:00:00 +01:00
|
|
|
#include "utils/builtins.h"
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Replication slot on-disk data structure.
|
|
|
|
*/
|
|
|
|
typedef struct ReplicationSlotOnDisk
|
|
|
|
{
|
|
|
|
/* first part of this struct needs to be version independent */
|
|
|
|
|
|
|
|
/* data not covered by checksum */
|
|
|
|
uint32 magic;
|
2015-04-14 16:03:42 +02:00
|
|
|
pg_crc32c checksum;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* data covered by checksum */
|
|
|
|
uint32 version;
|
|
|
|
uint32 length;
|
|
|
|
|
2014-11-12 18:52:49 +01:00
|
|
|
/*
|
|
|
|
* The actual data in the slot that follows can differ based on the above
|
|
|
|
* 'version'.
|
|
|
|
*/
|
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
ReplicationSlotPersistentData slotdata;
|
|
|
|
} ReplicationSlotOnDisk;
|
|
|
|
|
2014-11-12 18:52:49 +01:00
|
|
|
/* size of version independent data */
|
2014-02-01 04:45:17 +01:00
|
|
|
#define ReplicationSlotOnDiskConstantSize \
|
|
|
|
offsetof(ReplicationSlotOnDisk, slotdata)
|
2014-11-12 18:52:49 +01:00
|
|
|
/* size of the part of the slot not covered by the checksum */
|
2021-11-24 03:36:55 +01:00
|
|
|
#define ReplicationSlotOnDiskNotChecksummedSize \
|
2014-11-12 18:52:49 +01:00
|
|
|
offsetof(ReplicationSlotOnDisk, version)
|
|
|
|
/* size of the part covered by the checksum */
|
2021-11-24 03:36:55 +01:00
|
|
|
#define ReplicationSlotOnDiskChecksummedSize \
|
|
|
|
sizeof(ReplicationSlotOnDisk) - ReplicationSlotOnDiskNotChecksummedSize
|
2015-05-20 18:44:46 +02:00
|
|
|
/* size of the slot data that is version dependent */
|
2014-11-12 18:52:49 +01:00
|
|
|
#define ReplicationSlotOnDiskV2Size \
|
2014-02-01 04:45:17 +01:00
|
|
|
sizeof(ReplicationSlotOnDisk) - ReplicationSlotOnDiskConstantSize
|
|
|
|
|
|
|
|
#define SLOT_MAGIC 0x1051CA1 /* format identifier */
|
2014-11-12 18:52:49 +01:00
|
|
|
#define SLOT_VERSION 2 /* version for new files */
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* Control array for replication slot management */
|
|
|
|
ReplicationSlotCtlData *ReplicationSlotCtl = NULL;
|
|
|
|
|
|
|
|
/* My backend's replication slot in the shared memory array */
|
|
|
|
ReplicationSlot *MyReplicationSlot = NULL;
|
|
|
|
|
|
|
|
/* GUCs */
|
|
|
|
int max_replication_slots = 0; /* the maximum number of replication
|
|
|
|
* slots */
|
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
static void ReplicationSlotDropAcquired(void);
|
2016-12-08 18:00:00 +01:00
|
|
|
static void ReplicationSlotDropPtr(ReplicationSlot *slot);
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
/* internal persistency functions */
|
|
|
|
static void RestoreSlotFromDisk(const char *name);
|
|
|
|
static void CreateSlotOnDisk(ReplicationSlot *slot);
|
|
|
|
static void SaveSlotToPath(ReplicationSlot *slot, const char *path, int elevel);
|
|
|
|
|
|
|
|
/*
|
2019-08-13 06:53:41 +02:00
|
|
|
* Report shared-memory space needed by ReplicationSlotsShmemInit.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
|
|
|
Size
|
|
|
|
ReplicationSlotsShmemSize(void)
|
|
|
|
{
|
|
|
|
Size size = 0;
|
|
|
|
|
|
|
|
if (max_replication_slots == 0)
|
|
|
|
return size;
|
|
|
|
|
|
|
|
size = offsetof(ReplicationSlotCtlData, replication_slots);
|
|
|
|
size = add_size(size,
|
|
|
|
mul_size(max_replication_slots, sizeof(ReplicationSlot)));
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2020-05-18 04:23:26 +02:00
|
|
|
* Allocate and initialize shared memory for replication slots.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
ReplicationSlotsShmemInit(void)
|
|
|
|
{
|
|
|
|
bool found;
|
|
|
|
|
|
|
|
if (max_replication_slots == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ReplicationSlotCtl = (ReplicationSlotCtlData *)
|
|
|
|
ShmemInitStruct("ReplicationSlot Ctl", ReplicationSlotsShmemSize(),
|
|
|
|
&found);
|
|
|
|
|
|
|
|
if (!found)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* First time through, so initialize */
|
|
|
|
MemSet(ReplicationSlotCtl, 0, ReplicationSlotsShmemSize());
|
|
|
|
|
|
|
|
for (i = 0; i < max_replication_slots; i++)
|
|
|
|
{
|
|
|
|
ReplicationSlot *slot = &ReplicationSlotCtl->replication_slots[i];
|
|
|
|
|
|
|
|
/* everything else is zeroed by the memset above */
|
|
|
|
SpinLockInit(&slot->mutex);
|
2020-05-16 00:11:03 +02:00
|
|
|
LWLockInitialize(&slot->io_in_progress_lock,
|
|
|
|
LWTRANCHE_REPLICATION_SLOT_IO);
|
2017-07-25 19:26:49 +02:00
|
|
|
ConditionVariableInit(&slot->active_cv);
|
2014-02-01 04:45:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check whether the passed slot name is valid and report errors at elevel.
|
|
|
|
*
|
|
|
|
* Slot names may consist out of [a-z0-9_]{1,NAMEDATALEN-1} which should allow
|
2014-02-02 02:28:18 +01:00
|
|
|
* the name to be used as a directory name on every supported OS.
|
2014-02-01 04:45:17 +01:00
|
|
|
*
|
|
|
|
* Returns whether the directory name is valid or not if elevel < ERROR.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
ReplicationSlotValidateName(const char *name, int elevel)
|
|
|
|
{
|
|
|
|
const char *cp;
|
|
|
|
|
|
|
|
if (strlen(name) == 0)
|
|
|
|
{
|
|
|
|
ereport(elevel,
|
|
|
|
(errcode(ERRCODE_INVALID_NAME),
|
|
|
|
errmsg("replication slot name \"%s\" is too short",
|
|
|
|
name)));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strlen(name) >= NAMEDATALEN)
|
|
|
|
{
|
|
|
|
ereport(elevel,
|
|
|
|
(errcode(ERRCODE_NAME_TOO_LONG),
|
|
|
|
errmsg("replication slot name \"%s\" is too long",
|
|
|
|
name)));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (cp = name; *cp; cp++)
|
|
|
|
{
|
|
|
|
if (!((*cp >= 'a' && *cp <= 'z')
|
|
|
|
|| (*cp >= '0' && *cp <= '9')
|
|
|
|
|| (*cp == '_')))
|
|
|
|
{
|
|
|
|
ereport(elevel,
|
|
|
|
(errcode(ERRCODE_INVALID_NAME),
|
|
|
|
errmsg("replication slot name \"%s\" contains invalid character",
|
|
|
|
name),
|
2015-10-03 15:29:08 +02:00
|
|
|
errhint("Replication slot names may only contain lower case letters, numbers, and the underscore character.")));
|
2014-02-01 04:45:17 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a new replication slot and mark it as used by this backend.
|
|
|
|
*
|
|
|
|
* name: Name of the slot
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
* db_specific: logical decoding is db specific; if the slot is going to
|
2014-02-01 04:45:17 +01:00
|
|
|
* be used for that pass true, otherwise false.
|
2021-03-03 02:58:43 +01:00
|
|
|
* two_phase: Allows decoding of prepared transactions. We allow this option
|
|
|
|
* to be enabled only at the slot creation time. If we allow this option
|
|
|
|
* to be changed during decoding then it is quite possible that we skip
|
|
|
|
* prepare first time because this option was not enabled. Now next time
|
|
|
|
* during getting changes, if the two_phase option is enabled it can skip
|
|
|
|
* prepare because by that time start decoding point has been moved. So the
|
|
|
|
* user will only get commit prepared.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
|
|
|
void
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
ReplicationSlotCreate(const char *name, bool db_specific,
|
2021-03-03 02:58:43 +01:00
|
|
|
ReplicationSlotPersistency persistency, bool two_phase)
|
2014-02-01 04:45:17 +01:00
|
|
|
{
|
|
|
|
ReplicationSlot *slot = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
Assert(MyReplicationSlot == NULL);
|
|
|
|
|
|
|
|
ReplicationSlotValidateName(name, ERROR);
|
|
|
|
|
|
|
|
/*
|
2015-06-11 03:30:17 +02:00
|
|
|
* If some other backend ran this code concurrently with us, we'd likely
|
2014-02-01 04:45:17 +01:00
|
|
|
* both allocate the same slot, and that would be bad. We'd also be at
|
|
|
|
* risk of missing a name collision. Also, we don't want to try to create
|
|
|
|
* a new slot while somebody's busy cleaning up an old one, because we
|
|
|
|
* might both be monkeying with the same directory.
|
|
|
|
*/
|
|
|
|
LWLockAcquire(ReplicationSlotAllocationLock, LW_EXCLUSIVE);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for name collision, and identify an allocatable slot. We need to
|
|
|
|
* hold ReplicationSlotControlLock in shared mode for this, so that nobody
|
|
|
|
* else can change the in_use flags while we're looking at them.
|
|
|
|
*/
|
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
|
|
|
|
for (i = 0; i < max_replication_slots; i++)
|
|
|
|
{
|
|
|
|
ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
|
|
|
|
|
|
|
|
if (s->in_use && strcmp(name, NameStr(s->data.name)) == 0)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_DUPLICATE_OBJECT),
|
|
|
|
errmsg("replication slot \"%s\" already exists", name)));
|
|
|
|
if (!s->in_use && slot == NULL)
|
|
|
|
slot = s;
|
|
|
|
}
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
|
|
|
|
/* If all slots are in use, we're out of luck. */
|
|
|
|
if (slot == NULL)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED),
|
|
|
|
errmsg("all replication slots are in use"),
|
|
|
|
errhint("Free one or increase max_replication_slots.")));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since this slot is not in use, nobody should be looking at any part of
|
|
|
|
* it other than the in_use field unless they're trying to allocate it.
|
|
|
|
* And since we hold ReplicationSlotAllocationLock, nobody except us can
|
|
|
|
* be doing that. So it's safe to initialize the slot.
|
|
|
|
*/
|
|
|
|
Assert(!slot->in_use);
|
2015-04-21 11:51:06 +02:00
|
|
|
Assert(slot->active_pid == 0);
|
2016-08-17 22:15:03 +02:00
|
|
|
|
|
|
|
/* first initialize persistent data */
|
|
|
|
memset(&slot->data, 0, sizeof(ReplicationSlotPersistentData));
|
2020-08-10 18:51:31 +02:00
|
|
|
namestrcpy(&slot->data.name, name);
|
2014-02-01 04:45:17 +01:00
|
|
|
slot->data.database = db_specific ? MyDatabaseId : InvalidOid;
|
2016-08-17 22:15:03 +02:00
|
|
|
slot->data.persistency = persistency;
|
2021-03-03 02:58:43 +01:00
|
|
|
slot->data.two_phase = two_phase;
|
Add support for prepared transactions to built-in logical replication.
To add support for streaming transactions at prepare time into the
built-in logical replication, we need to do the following things:
* Modify the output plugin (pgoutput) to implement the new two-phase API
callbacks, by leveraging the extended replication protocol.
* Modify the replication apply worker, to properly handle two-phase
transactions by replaying them on prepare.
* Add a new SUBSCRIPTION option "two_phase" to allow users to enable
two-phase transactions. We enable the two_phase once the initial data sync
is over.
We however must explicitly disable replication of two-phase transactions
during replication slot creation, even if the plugin supports it. We
don't need to replicate the changes accumulated during this phase,
and moreover, we don't have a replication connection open so we don't know
where to send the data anyway.
The streaming option is not allowed with this new two_phase option. This
can be done as a separate patch.
We don't allow to toggle two_phase option of a subscription because it can
lead to an inconsistent replica. For the same reason, we don't allow to
refresh the publication once the two_phase is enabled for a subscription
unless copy_data option is false.
Author: Peter Smith, Ajin Cherian and Amit Kapila based on previous work by Nikhil Sontakke and Stas Kelvich
Reviewed-by: Amit Kapila, Sawada Masahiko, Vignesh C, Dilip Kumar, Takamichi Osumi, Greg Nancarrow
Tested-By: Haiying Tang
Discussion: https://postgr.es/m/02DA5F5E-CECE-4D9C-8B4B-418077E2C010@postgrespro.ru
Discussion: https://postgr.es/m/CAA4eK1+opiV4aFTmWWUF9h_32=HfPOW9vZASHarT0UA5oBrtGw@mail.gmail.com
2021-07-14 04:03:50 +02:00
|
|
|
slot->data.two_phase_at = InvalidXLogRecPtr;
|
2016-08-17 22:15:03 +02:00
|
|
|
|
|
|
|
/* and then data only present in shared memory */
|
|
|
|
slot->just_dirtied = false;
|
|
|
|
slot->dirty = false;
|
|
|
|
slot->effective_xmin = InvalidTransactionId;
|
|
|
|
slot->effective_catalog_xmin = InvalidTransactionId;
|
|
|
|
slot->candidate_catalog_xmin = InvalidTransactionId;
|
|
|
|
slot->candidate_xmin_lsn = InvalidXLogRecPtr;
|
|
|
|
slot->candidate_restart_valid = InvalidXLogRecPtr;
|
|
|
|
slot->candidate_restart_lsn = InvalidXLogRecPtr;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the slot on disk. We haven't actually marked the slot allocated
|
|
|
|
* yet, so no special cleanup is required if this errors out.
|
|
|
|
*/
|
|
|
|
CreateSlotOnDisk(slot);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to briefly prevent any other backend from iterating over the
|
|
|
|
* slots while we flip the in_use flag. We also need to set the active
|
|
|
|
* flag while holding the ControlLock as otherwise a concurrent
|
2019-08-13 06:53:41 +02:00
|
|
|
* ReplicationSlotAcquire() could acquire the slot as well.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_EXCLUSIVE);
|
|
|
|
|
|
|
|
slot->in_use = true;
|
|
|
|
|
|
|
|
/* We can now mark the slot active, and that makes it our slot. */
|
2015-10-06 21:45:02 +02:00
|
|
|
SpinLockAcquire(&slot->mutex);
|
|
|
|
Assert(slot->active_pid == 0);
|
|
|
|
slot->active_pid = MyProcPid;
|
|
|
|
SpinLockRelease(&slot->mutex);
|
|
|
|
MyReplicationSlot = slot;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
|
2020-10-08 05:39:08 +02:00
|
|
|
/*
|
|
|
|
* Create statistics entry for the new logical slot. We don't collect any
|
|
|
|
* stats for physical slots, so no need to create an entry for the same.
|
|
|
|
* See ReplicationSlotDropPtr for why we need to do this before releasing
|
|
|
|
* ReplicationSlotAllocationLock.
|
|
|
|
*/
|
|
|
|
if (SlotIsLogical(slot))
|
2021-04-27 05:39:11 +02:00
|
|
|
pgstat_report_replslot_create(NameStr(slot->data.name));
|
2020-10-08 05:39:08 +02:00
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
/*
|
2017-07-25 19:26:49 +02:00
|
|
|
* Now that the slot has been marked as in_use and active, it's safe to
|
2014-02-01 04:45:17 +01:00
|
|
|
* let somebody else try to allocate a slot.
|
|
|
|
*/
|
|
|
|
LWLockRelease(ReplicationSlotAllocationLock);
|
2017-07-25 19:26:49 +02:00
|
|
|
|
|
|
|
/* Let everybody know we've modified this slot */
|
|
|
|
ConditionVariableBroadcast(&slot->active_cv);
|
2014-02-01 04:45:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2020-06-19 10:15:52 +02:00
|
|
|
* Search for the named replication slot.
|
2020-04-08 00:35:00 +02:00
|
|
|
*
|
2020-06-19 10:15:52 +02:00
|
|
|
* Return the replication slot if found, otherwise NULL.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
2020-10-08 05:39:08 +02:00
|
|
|
ReplicationSlot *
|
2021-04-27 05:39:11 +02:00
|
|
|
SearchNamedReplicationSlot(const char *name, bool need_lock)
|
2014-02-01 04:45:17 +01:00
|
|
|
{
|
|
|
|
int i;
|
2021-04-27 05:39:11 +02:00
|
|
|
ReplicationSlot *slot = NULL;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
2021-04-27 05:39:11 +02:00
|
|
|
if (need_lock)
|
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
for (i = 0; i < max_replication_slots; i++)
|
|
|
|
{
|
|
|
|
ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
|
|
|
|
|
|
|
|
if (s->in_use && strcmp(name, NameStr(s->data.name)) == 0)
|
|
|
|
{
|
|
|
|
slot = s;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-27 05:39:11 +02:00
|
|
|
if (need_lock)
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
|
2020-06-19 10:15:52 +02:00
|
|
|
return slot;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find a previously created slot and mark it as used by this process.
|
|
|
|
*
|
2021-06-11 21:48:26 +02:00
|
|
|
* An error is raised if nowait is true and the slot is currently in use. If
|
|
|
|
* nowait is false, we sleep until the slot is released by the owning process.
|
2020-06-19 10:15:52 +02:00
|
|
|
*/
|
2021-06-11 21:48:26 +02:00
|
|
|
void
|
|
|
|
ReplicationSlotAcquire(const char *name, bool nowait)
|
2020-06-19 10:15:52 +02:00
|
|
|
{
|
|
|
|
ReplicationSlot *s;
|
|
|
|
int active_pid;
|
|
|
|
|
2021-06-11 21:48:26 +02:00
|
|
|
AssertArg(name != NULL);
|
2020-06-19 10:15:52 +02:00
|
|
|
|
|
|
|
retry:
|
|
|
|
Assert(MyReplicationSlot == NULL);
|
|
|
|
|
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Search for the slot with the specified name if the slot to acquire is
|
|
|
|
* not given. If the slot is not found, we either return -1 or error out.
|
|
|
|
*/
|
2021-06-11 21:48:26 +02:00
|
|
|
s = SearchNamedReplicationSlot(name, false);
|
2020-06-19 10:15:52 +02:00
|
|
|
if (s == NULL || !s->in_use)
|
|
|
|
{
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_UNDEFINED_OBJECT),
|
2020-06-19 10:15:52 +02:00
|
|
|
errmsg("replication slot \"%s\" does not exist",
|
2021-06-11 21:48:26 +02:00
|
|
|
name)));
|
2020-06-19 10:15:52 +02:00
|
|
|
}
|
2017-07-25 19:26:49 +02:00
|
|
|
|
|
|
|
/*
|
2020-06-19 10:15:52 +02:00
|
|
|
* This is the slot we want; check if it's active under some other
|
|
|
|
* process. In single user mode, we don't need this check.
|
|
|
|
*/
|
|
|
|
if (IsUnderPostmaster)
|
|
|
|
{
|
|
|
|
/*
|
2021-06-14 22:31:12 +02:00
|
|
|
* Get ready to sleep on the slot in case it is active. (We may end
|
|
|
|
* up not sleeping, but we don't want to do this while holding the
|
|
|
|
* spinlock.)
|
2020-06-19 10:15:52 +02:00
|
|
|
*/
|
2021-06-11 21:48:26 +02:00
|
|
|
if (!nowait)
|
2020-06-19 10:15:52 +02:00
|
|
|
ConditionVariablePrepareToSleep(&s->active_cv);
|
|
|
|
|
|
|
|
SpinLockAcquire(&s->mutex);
|
|
|
|
if (s->active_pid == 0)
|
|
|
|
s->active_pid = MyProcPid;
|
|
|
|
active_pid = s->active_pid;
|
|
|
|
SpinLockRelease(&s->mutex);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
active_pid = MyProcPid;
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we found the slot but it's already active in another process, we
|
2021-06-14 22:31:12 +02:00
|
|
|
* wait until the owning process signals us that it's been released, or
|
|
|
|
* error out.
|
2017-07-25 19:26:49 +02:00
|
|
|
*/
|
2016-12-08 18:00:00 +01:00
|
|
|
if (active_pid != MyProcPid)
|
2017-07-25 19:26:49 +02:00
|
|
|
{
|
2021-06-11 21:48:26 +02:00
|
|
|
if (!nowait)
|
2021-06-14 22:31:12 +02:00
|
|
|
{
|
|
|
|
/* Wait here until we get signaled, and then restart */
|
|
|
|
ConditionVariableSleep(&s->active_cv,
|
|
|
|
WAIT_EVENT_REPLICATION_SLOT_DROP);
|
|
|
|
ConditionVariableCancelSleep();
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_OBJECT_IN_USE),
|
|
|
|
errmsg("replication slot \"%s\" is active for PID %d",
|
|
|
|
NameStr(s->data.name), active_pid)));
|
2017-07-25 19:26:49 +02:00
|
|
|
}
|
2021-06-11 21:48:26 +02:00
|
|
|
else if (!nowait)
|
2020-06-19 10:15:52 +02:00
|
|
|
ConditionVariableCancelSleep(); /* no sleep needed after all */
|
2017-07-25 19:26:49 +02:00
|
|
|
|
|
|
|
/* Let everybody know we've modified this slot */
|
2020-06-19 10:15:52 +02:00
|
|
|
ConditionVariableBroadcast(&s->active_cv);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* We made this slot active, so it's ours now. */
|
2020-06-19 10:15:52 +02:00
|
|
|
MyReplicationSlot = s;
|
2014-02-01 04:45:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2017-07-25 19:26:49 +02:00
|
|
|
* Release the replication slot that this backend considers to own.
|
|
|
|
*
|
|
|
|
* This or another backend can re-acquire the slot later.
|
|
|
|
* Resources this slot requires will be preserved.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
ReplicationSlotRelease(void)
|
|
|
|
{
|
|
|
|
ReplicationSlot *slot = MyReplicationSlot;
|
|
|
|
|
2015-04-21 11:51:06 +02:00
|
|
|
Assert(slot != NULL && slot->active_pid != 0);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
if (slot->data.persistency == RS_EPHEMERAL)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Delete the slot. There is no !PANIC case where this is allowed to
|
|
|
|
* fail, all that may happen is an incomplete cleanup of the on-disk
|
|
|
|
* data.
|
|
|
|
*/
|
|
|
|
ReplicationSlotDropAcquired();
|
|
|
|
}
|
Preserve required !catalog tuples while computing initial decoding snapshot.
The logical decoding machinery already preserved all the required
catalog tuples, which is sufficient in the course of normal logical
decoding, but did not guarantee that non-catalog tuples were preserved
during computation of the initial snapshot when creating a slot over
the replication protocol.
This could cause a corrupted initial snapshot being exported. The
time window for issues is usually not terribly large, but on a busy
server it's perfectly possible to it hit it. Ongoing decoding is not
affected by this bug.
To avoid increased overhead for the SQL API, only retain additional
tuples when a logical slot is being created over the replication
protocol. To do so this commit changes the signature of
CreateInitDecodingContext(), but it seems unlikely that it's being
used in an extension, so that's probably ok.
In a drive-by fix, fix handling of
ReplicationSlotsComputeRequiredXmin's already_locked argument, which
should only apply to ProcArrayLock, not ReplicationSlotControlLock.
Reported-By: Erik Rijkers
Analyzed-By: Petr Jelinek
Author: Petr Jelinek, heavily editorialized by Andres Freund
Reviewed-By: Andres Freund
Discussion: https://postgr.es/m/9a897b86-46e1-9915-ee4c-da02e4ff6a95@2ndquadrant.com
Backport: 9.4, where logical decoding was introduced.
2017-04-24 05:41:29 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If slot needed to temporarily restrain both data and catalog xmin to
|
|
|
|
* create the catalog snapshot, remove that temporary constraint.
|
|
|
|
* Snapshots can only be exported while the initial snapshot is still
|
|
|
|
* acquired.
|
|
|
|
*/
|
|
|
|
if (!TransactionIdIsValid(slot->data.xmin) &&
|
|
|
|
TransactionIdIsValid(slot->effective_xmin))
|
|
|
|
{
|
|
|
|
SpinLockAcquire(&slot->mutex);
|
|
|
|
slot->effective_xmin = InvalidTransactionId;
|
|
|
|
SpinLockRelease(&slot->mutex);
|
|
|
|
ReplicationSlotsComputeRequiredXmin(false);
|
|
|
|
}
|
|
|
|
|
2017-07-25 19:26:49 +02:00
|
|
|
if (slot->data.persistency == RS_PERSISTENT)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Mark persistent slot inactive. We're not freeing it, just
|
|
|
|
* disconnecting, but wake up others that may be waiting for it.
|
|
|
|
*/
|
|
|
|
SpinLockAcquire(&slot->mutex);
|
|
|
|
slot->active_pid = 0;
|
|
|
|
SpinLockRelease(&slot->mutex);
|
|
|
|
ConditionVariableBroadcast(&slot->active_cv);
|
|
|
|
}
|
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
MyReplicationSlot = NULL;
|
|
|
|
|
|
|
|
/* might not have been set when we've been a plain slot */
|
2021-11-11 15:03:29 +01:00
|
|
|
LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
|
2020-11-16 23:42:55 +01:00
|
|
|
MyProc->statusFlags &= ~PROC_IN_LOGICAL_DECODING;
|
|
|
|
ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
LWLockRelease(ProcArrayLock);
|
2014-02-01 04:45:17 +01:00
|
|
|
}
|
|
|
|
|
2016-12-08 18:00:00 +01:00
|
|
|
/*
|
|
|
|
* Cleanup all temporary slots created in current session.
|
|
|
|
*/
|
|
|
|
void
|
2017-04-06 05:56:35 +02:00
|
|
|
ReplicationSlotCleanup(void)
|
2016-12-08 18:00:00 +01:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
Assert(MyReplicationSlot == NULL);
|
|
|
|
|
2017-07-25 19:26:49 +02:00
|
|
|
restart:
|
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
|
2016-12-08 18:00:00 +01:00
|
|
|
for (i = 0; i < max_replication_slots; i++)
|
|
|
|
{
|
|
|
|
ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
|
|
|
|
|
2017-07-25 19:26:49 +02:00
|
|
|
if (!s->in_use)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
SpinLockAcquire(&s->mutex);
|
2016-12-08 18:00:00 +01:00
|
|
|
if (s->active_pid == MyProcPid)
|
|
|
|
{
|
2017-07-25 19:26:49 +02:00
|
|
|
Assert(s->data.persistency == RS_TEMPORARY);
|
|
|
|
SpinLockRelease(&s->mutex);
|
|
|
|
LWLockRelease(ReplicationSlotControlLock); /* avoid deadlock */
|
2016-12-08 18:00:00 +01:00
|
|
|
|
|
|
|
ReplicationSlotDropPtr(s);
|
2017-07-25 19:26:49 +02:00
|
|
|
|
|
|
|
ConditionVariableBroadcast(&s->active_cv);
|
|
|
|
goto restart;
|
2016-12-08 18:00:00 +01:00
|
|
|
}
|
2017-07-25 19:26:49 +02:00
|
|
|
else
|
|
|
|
SpinLockRelease(&s->mutex);
|
2016-12-08 18:00:00 +01:00
|
|
|
}
|
2017-07-25 19:26:49 +02:00
|
|
|
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
2016-12-08 18:00:00 +01:00
|
|
|
}
|
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
/*
|
|
|
|
* Permanently drop replication slot identified by the passed in name.
|
|
|
|
*/
|
|
|
|
void
|
2017-07-25 19:26:49 +02:00
|
|
|
ReplicationSlotDrop(const char *name, bool nowait)
|
2014-02-01 04:45:17 +01:00
|
|
|
{
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
Assert(MyReplicationSlot == NULL);
|
|
|
|
|
2021-06-11 21:48:26 +02:00
|
|
|
ReplicationSlotAcquire(name, nowait);
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
|
|
|
|
ReplicationSlotDropAcquired();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-12-08 18:00:00 +01:00
|
|
|
* Permanently drop the currently acquired replication slot.
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ReplicationSlotDropAcquired(void)
|
|
|
|
{
|
|
|
|
ReplicationSlot *slot = MyReplicationSlot;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
Assert(MyReplicationSlot != NULL);
|
|
|
|
|
|
|
|
/* slot isn't acquired anymore */
|
|
|
|
MyReplicationSlot = NULL;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
2016-12-08 18:00:00 +01:00
|
|
|
ReplicationSlotDropPtr(slot);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Permanently drop the replication slot which will be released by the point
|
|
|
|
* this function returns.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ReplicationSlotDropPtr(ReplicationSlot *slot)
|
|
|
|
{
|
|
|
|
char path[MAXPGPATH];
|
|
|
|
char tmppath[MAXPGPATH];
|
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
/*
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
* If some other backend ran this code concurrently with us, we might try
|
|
|
|
* to delete a slot with a certain name while someone else was trying to
|
|
|
|
* create a slot with the same name.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
|
|
|
LWLockAcquire(ReplicationSlotAllocationLock, LW_EXCLUSIVE);
|
|
|
|
|
|
|
|
/* Generate pathnames. */
|
|
|
|
sprintf(path, "pg_replslot/%s", NameStr(slot->data.name));
|
|
|
|
sprintf(tmppath, "pg_replslot/%s.tmp", NameStr(slot->data.name));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Rename the slot directory on disk, so that we'll no longer recognize
|
|
|
|
* this as a valid slot. Note that if this fails, we've got to mark the
|
2016-12-08 18:00:00 +01:00
|
|
|
* slot inactive before bailing out. If we're dropping an ephemeral or a
|
|
|
|
* temporary slot, we better never fail hard as the caller won't expect
|
|
|
|
* the slot to survive and this might get called during error handling.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
if (rename(path, tmppath) == 0)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We need to fsync() the directory we just renamed and its parent to
|
|
|
|
* make sure that our changes are on disk in a crash-safe fashion. If
|
|
|
|
* fsync() fails, we can't be sure whether the changes are on disk or
|
|
|
|
* not. For now, we handle that by panicking;
|
|
|
|
* StartupReplicationSlots() will try to straighten it out after
|
|
|
|
* restart.
|
|
|
|
*/
|
|
|
|
START_CRIT_SECTION();
|
|
|
|
fsync_fname(tmppath, true);
|
|
|
|
fsync_fname("pg_replslot", true);
|
|
|
|
END_CRIT_SECTION();
|
|
|
|
}
|
|
|
|
else
|
2014-02-01 04:45:17 +01:00
|
|
|
{
|
2016-12-08 18:00:00 +01:00
|
|
|
bool fail_softly = slot->data.persistency != RS_PERSISTENT;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
SpinLockAcquire(&slot->mutex);
|
2015-10-06 21:45:02 +02:00
|
|
|
slot->active_pid = 0;
|
2014-02-01 04:45:17 +01:00
|
|
|
SpinLockRelease(&slot->mutex);
|
|
|
|
|
2017-07-25 19:26:49 +02:00
|
|
|
/* wake up anyone waiting on this slot */
|
|
|
|
ConditionVariableBroadcast(&slot->active_cv);
|
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
ereport(fail_softly ? WARNING : ERROR,
|
2014-02-01 04:45:17 +01:00
|
|
|
(errcode_for_file_access(),
|
2014-09-05 07:20:33 +02:00
|
|
|
errmsg("could not rename file \"%s\" to \"%s\": %m",
|
2014-02-01 04:45:17 +01:00
|
|
|
path, tmppath)));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The slot is definitely gone. Lock out concurrent scans of the array
|
2017-07-25 19:26:49 +02:00
|
|
|
* long enough to kill it. It's OK to clear the active PID here without
|
2014-02-01 04:45:17 +01:00
|
|
|
* grabbing the mutex because nobody else can be scanning the array here,
|
|
|
|
* and nobody can be attached to this slot and thus access it without
|
|
|
|
* scanning the array.
|
2017-07-25 19:26:49 +02:00
|
|
|
*
|
|
|
|
* Also wake up processes waiting for it.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_EXCLUSIVE);
|
2015-04-21 11:51:06 +02:00
|
|
|
slot->active_pid = 0;
|
2014-02-01 04:45:17 +01:00
|
|
|
slot->in_use = false;
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
2017-07-25 19:26:49 +02:00
|
|
|
ConditionVariableBroadcast(&slot->active_cv);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Slot is dead and doesn't prevent resource removal anymore, recompute
|
|
|
|
* limits.
|
|
|
|
*/
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
ReplicationSlotsComputeRequiredXmin(false);
|
2014-02-01 04:45:17 +01:00
|
|
|
ReplicationSlotsComputeRequiredLSN();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If removing the directory fails, the worst thing that will happen is
|
|
|
|
* that the user won't be able to create a new slot with the same name
|
|
|
|
* until the next server restart. We warn about it, but that's all.
|
|
|
|
*/
|
|
|
|
if (!rmtree(tmppath, true))
|
|
|
|
ereport(WARNING,
|
2018-09-04 20:06:04 +02:00
|
|
|
(errmsg("could not remove directory \"%s\"", tmppath)));
|
2014-02-01 04:45:17 +01:00
|
|
|
|
2020-10-08 05:39:08 +02:00
|
|
|
/*
|
|
|
|
* Send a message to drop the replication slot to the stats collector.
|
|
|
|
* Since there is no guarantee of the order of message transfer on a UDP
|
|
|
|
* connection, it's possible that a message for creating a new slot
|
|
|
|
* reaches before a message for removing the old slot. We send the drop
|
|
|
|
* and create messages while holding ReplicationSlotAllocationLock to
|
|
|
|
* reduce that possibility. If the messages reached in reverse, we would
|
|
|
|
* lose one statistics update message. But the next update message will
|
|
|
|
* create the statistics for the replication slot.
|
2021-04-27 05:39:11 +02:00
|
|
|
*
|
|
|
|
* XXX In case, the messages for creation and drop slot of the same name
|
|
|
|
* get lost and create happens before (auto)vacuum cleans up the dead
|
|
|
|
* slot, the stats will be accumulated into the old slot. One can imagine
|
|
|
|
* having OIDs for each slot to avoid the accumulation of stats but that
|
|
|
|
* doesn't seem worth doing as in practice this won't happen frequently.
|
2020-10-08 05:39:08 +02:00
|
|
|
*/
|
|
|
|
if (SlotIsLogical(slot))
|
|
|
|
pgstat_report_replslot_drop(NameStr(slot->data.name));
|
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
/*
|
|
|
|
* We release this at the very end, so that nobody starts trying to create
|
|
|
|
* a slot while we're still cleaning up the detritus of the old one.
|
|
|
|
*/
|
|
|
|
LWLockRelease(ReplicationSlotAllocationLock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Serialize the currently acquired slot's state from memory to disk, thereby
|
|
|
|
* guaranteeing the current state will survive a crash.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ReplicationSlotSave(void)
|
|
|
|
{
|
|
|
|
char path[MAXPGPATH];
|
|
|
|
|
|
|
|
Assert(MyReplicationSlot != NULL);
|
|
|
|
|
|
|
|
sprintf(path, "pg_replslot/%s", NameStr(MyReplicationSlot->data.name));
|
|
|
|
SaveSlotToPath(MyReplicationSlot, path, ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Signal that it would be useful if the currently acquired slot would be
|
|
|
|
* flushed out to disk.
|
|
|
|
*
|
|
|
|
* Note that the actual flush to disk can be delayed for a long time, if
|
|
|
|
* required for correctness explicitly do a ReplicationSlotSave().
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ReplicationSlotMarkDirty(void)
|
|
|
|
{
|
2015-10-06 21:45:02 +02:00
|
|
|
ReplicationSlot *slot = MyReplicationSlot;
|
2016-06-10 00:02:36 +02:00
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
Assert(MyReplicationSlot != NULL);
|
|
|
|
|
2015-10-06 21:45:02 +02:00
|
|
|
SpinLockAcquire(&slot->mutex);
|
|
|
|
MyReplicationSlot->just_dirtied = true;
|
|
|
|
MyReplicationSlot->dirty = true;
|
|
|
|
SpinLockRelease(&slot->mutex);
|
2014-02-01 04:45:17 +01:00
|
|
|
}
|
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
/*
|
2015-04-02 13:45:19 +02:00
|
|
|
* Convert a slot that's marked as RS_EPHEMERAL to a RS_PERSISTENT slot,
|
2015-05-20 15:18:11 +02:00
|
|
|
* guaranteeing it will be there after an eventual crash.
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
ReplicationSlotPersist(void)
|
|
|
|
{
|
|
|
|
ReplicationSlot *slot = MyReplicationSlot;
|
|
|
|
|
|
|
|
Assert(slot != NULL);
|
|
|
|
Assert(slot->data.persistency != RS_PERSISTENT);
|
|
|
|
|
2015-10-06 21:45:02 +02:00
|
|
|
SpinLockAcquire(&slot->mutex);
|
|
|
|
slot->data.persistency = RS_PERSISTENT;
|
|
|
|
SpinLockRelease(&slot->mutex);
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
|
|
|
|
ReplicationSlotMarkDirty();
|
|
|
|
ReplicationSlotSave();
|
|
|
|
}
|
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
/*
|
|
|
|
* Compute the oldest xmin across all slots and store it in the ProcArray.
|
Preserve required !catalog tuples while computing initial decoding snapshot.
The logical decoding machinery already preserved all the required
catalog tuples, which is sufficient in the course of normal logical
decoding, but did not guarantee that non-catalog tuples were preserved
during computation of the initial snapshot when creating a slot over
the replication protocol.
This could cause a corrupted initial snapshot being exported. The
time window for issues is usually not terribly large, but on a busy
server it's perfectly possible to it hit it. Ongoing decoding is not
affected by this bug.
To avoid increased overhead for the SQL API, only retain additional
tuples when a logical slot is being created over the replication
protocol. To do so this commit changes the signature of
CreateInitDecodingContext(), but it seems unlikely that it's being
used in an extension, so that's probably ok.
In a drive-by fix, fix handling of
ReplicationSlotsComputeRequiredXmin's already_locked argument, which
should only apply to ProcArrayLock, not ReplicationSlotControlLock.
Reported-By: Erik Rijkers
Analyzed-By: Petr Jelinek
Author: Petr Jelinek, heavily editorialized by Andres Freund
Reviewed-By: Andres Freund
Discussion: https://postgr.es/m/9a897b86-46e1-9915-ee4c-da02e4ff6a95@2ndquadrant.com
Backport: 9.4, where logical decoding was introduced.
2017-04-24 05:41:29 +02:00
|
|
|
*
|
|
|
|
* If already_locked is true, ProcArrayLock has already been acquired
|
|
|
|
* exclusively.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
|
|
|
void
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
ReplicationSlotsComputeRequiredXmin(bool already_locked)
|
2014-02-01 04:45:17 +01:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
TransactionId agg_xmin = InvalidTransactionId;
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
TransactionId agg_catalog_xmin = InvalidTransactionId;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
Assert(ReplicationSlotCtl != NULL);
|
|
|
|
|
Preserve required !catalog tuples while computing initial decoding snapshot.
The logical decoding machinery already preserved all the required
catalog tuples, which is sufficient in the course of normal logical
decoding, but did not guarantee that non-catalog tuples were preserved
during computation of the initial snapshot when creating a slot over
the replication protocol.
This could cause a corrupted initial snapshot being exported. The
time window for issues is usually not terribly large, but on a busy
server it's perfectly possible to it hit it. Ongoing decoding is not
affected by this bug.
To avoid increased overhead for the SQL API, only retain additional
tuples when a logical slot is being created over the replication
protocol. To do so this commit changes the signature of
CreateInitDecodingContext(), but it seems unlikely that it's being
used in an extension, so that's probably ok.
In a drive-by fix, fix handling of
ReplicationSlotsComputeRequiredXmin's already_locked argument, which
should only apply to ProcArrayLock, not ReplicationSlotControlLock.
Reported-By: Erik Rijkers
Analyzed-By: Petr Jelinek
Author: Petr Jelinek, heavily editorialized by Andres Freund
Reviewed-By: Andres Freund
Discussion: https://postgr.es/m/9a897b86-46e1-9915-ee4c-da02e4ff6a95@2ndquadrant.com
Backport: 9.4, where logical decoding was introduced.
2017-04-24 05:41:29 +02:00
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
for (i = 0; i < max_replication_slots; i++)
|
|
|
|
{
|
|
|
|
ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
|
|
|
|
TransactionId effective_xmin;
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
TransactionId effective_catalog_xmin;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
if (!s->in_use)
|
|
|
|
continue;
|
|
|
|
|
2015-10-06 21:45:02 +02:00
|
|
|
SpinLockAcquire(&s->mutex);
|
|
|
|
effective_xmin = s->effective_xmin;
|
|
|
|
effective_catalog_xmin = s->effective_catalog_xmin;
|
|
|
|
SpinLockRelease(&s->mutex);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* check the data xmin */
|
|
|
|
if (TransactionIdIsValid(effective_xmin) &&
|
|
|
|
(!TransactionIdIsValid(agg_xmin) ||
|
|
|
|
TransactionIdPrecedes(effective_xmin, agg_xmin)))
|
|
|
|
agg_xmin = effective_xmin;
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
|
|
|
|
/* check the catalog xmin */
|
|
|
|
if (TransactionIdIsValid(effective_catalog_xmin) &&
|
|
|
|
(!TransactionIdIsValid(agg_catalog_xmin) ||
|
|
|
|
TransactionIdPrecedes(effective_catalog_xmin, agg_catalog_xmin)))
|
|
|
|
agg_catalog_xmin = effective_catalog_xmin;
|
2014-02-01 04:45:17 +01:00
|
|
|
}
|
|
|
|
|
Preserve required !catalog tuples while computing initial decoding snapshot.
The logical decoding machinery already preserved all the required
catalog tuples, which is sufficient in the course of normal logical
decoding, but did not guarantee that non-catalog tuples were preserved
during computation of the initial snapshot when creating a slot over
the replication protocol.
This could cause a corrupted initial snapshot being exported. The
time window for issues is usually not terribly large, but on a busy
server it's perfectly possible to it hit it. Ongoing decoding is not
affected by this bug.
To avoid increased overhead for the SQL API, only retain additional
tuples when a logical slot is being created over the replication
protocol. To do so this commit changes the signature of
CreateInitDecodingContext(), but it seems unlikely that it's being
used in an extension, so that's probably ok.
In a drive-by fix, fix handling of
ReplicationSlotsComputeRequiredXmin's already_locked argument, which
should only apply to ProcArrayLock, not ReplicationSlotControlLock.
Reported-By: Erik Rijkers
Analyzed-By: Petr Jelinek
Author: Petr Jelinek, heavily editorialized by Andres Freund
Reviewed-By: Andres Freund
Discussion: https://postgr.es/m/9a897b86-46e1-9915-ee4c-da02e4ff6a95@2ndquadrant.com
Backport: 9.4, where logical decoding was introduced.
2017-04-24 05:41:29 +02:00
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
|
|
|
|
ProcArraySetReplicationSlotXmin(agg_xmin, agg_catalog_xmin, already_locked);
|
2014-02-01 04:45:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute the oldest restart LSN across all slots and inform xlog module.
|
2020-04-08 00:35:00 +02:00
|
|
|
*
|
|
|
|
* Note: while max_slot_wal_keep_size is theoretically relevant for this
|
|
|
|
* purpose, we don't try to account for that, because this module doesn't
|
|
|
|
* know what to compare against.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
ReplicationSlotsComputeRequiredLSN(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
XLogRecPtr min_required = InvalidXLogRecPtr;
|
|
|
|
|
|
|
|
Assert(ReplicationSlotCtl != NULL);
|
|
|
|
|
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
|
|
|
|
for (i = 0; i < max_replication_slots; i++)
|
|
|
|
{
|
|
|
|
ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
|
|
|
|
XLogRecPtr restart_lsn;
|
|
|
|
|
|
|
|
if (!s->in_use)
|
|
|
|
continue;
|
|
|
|
|
2015-10-06 21:45:02 +02:00
|
|
|
SpinLockAcquire(&s->mutex);
|
|
|
|
restart_lsn = s->data.restart_lsn;
|
|
|
|
SpinLockRelease(&s->mutex);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
if (restart_lsn != InvalidXLogRecPtr &&
|
|
|
|
(min_required == InvalidXLogRecPtr ||
|
|
|
|
restart_lsn < min_required))
|
|
|
|
min_required = restart_lsn;
|
|
|
|
}
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
|
|
|
|
XLogSetReplicationSlotMinimumLSN(min_required);
|
|
|
|
}
|
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
/*
|
|
|
|
* Compute the oldest WAL LSN required by *logical* decoding slots..
|
|
|
|
*
|
2015-08-11 12:32:48 +02:00
|
|
|
* Returns InvalidXLogRecPtr if logical decoding is disabled or no logical
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
* slots exist.
|
|
|
|
*
|
|
|
|
* NB: this returns a value >= ReplicationSlotsComputeRequiredLSN(), since it
|
|
|
|
* ignores physical replication slots.
|
|
|
|
*
|
|
|
|
* The results aren't required frequently, so we don't maintain a precomputed
|
|
|
|
* value like we do for ComputeRequiredLSN() and ComputeRequiredXmin().
|
|
|
|
*/
|
|
|
|
XLogRecPtr
|
|
|
|
ReplicationSlotsComputeLogicalRestartLSN(void)
|
|
|
|
{
|
|
|
|
XLogRecPtr result = InvalidXLogRecPtr;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (max_replication_slots <= 0)
|
|
|
|
return InvalidXLogRecPtr;
|
|
|
|
|
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
|
|
|
|
|
|
|
|
for (i = 0; i < max_replication_slots; i++)
|
|
|
|
{
|
2015-10-06 21:45:02 +02:00
|
|
|
ReplicationSlot *s;
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
XLogRecPtr restart_lsn;
|
|
|
|
|
|
|
|
s = &ReplicationSlotCtl->replication_slots[i];
|
|
|
|
|
|
|
|
/* cannot change while ReplicationSlotCtlLock is held */
|
|
|
|
if (!s->in_use)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* we're only interested in logical slots */
|
2015-08-11 12:32:48 +02:00
|
|
|
if (!SlotIsLogical(s))
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* read once, it's ok if it increases while we're checking */
|
|
|
|
SpinLockAcquire(&s->mutex);
|
|
|
|
restart_lsn = s->data.restart_lsn;
|
|
|
|
SpinLockRelease(&s->mutex);
|
|
|
|
|
2020-04-08 00:35:00 +02:00
|
|
|
if (restart_lsn == InvalidXLogRecPtr)
|
|
|
|
continue;
|
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
if (result == InvalidXLogRecPtr ||
|
|
|
|
restart_lsn < result)
|
|
|
|
result = restart_lsn;
|
|
|
|
}
|
|
|
|
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ReplicationSlotsCountDBSlots -- count the number of slots that refer to the
|
|
|
|
* passed database oid.
|
|
|
|
*
|
|
|
|
* Returns true if there are any slots referencing the database. *nslots will
|
|
|
|
* be set to the absolute number of slots in the database, *nactive to ones
|
|
|
|
* currently active.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
ReplicationSlotsCountDBSlots(Oid dboid, int *nslots, int *nactive)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
*nslots = *nactive = 0;
|
|
|
|
|
|
|
|
if (max_replication_slots <= 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
|
|
|
|
for (i = 0; i < max_replication_slots; i++)
|
|
|
|
{
|
2015-10-06 21:45:02 +02:00
|
|
|
ReplicationSlot *s;
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
|
|
|
|
s = &ReplicationSlotCtl->replication_slots[i];
|
|
|
|
|
|
|
|
/* cannot change while ReplicationSlotCtlLock is held */
|
|
|
|
if (!s->in_use)
|
|
|
|
continue;
|
|
|
|
|
2015-08-11 12:32:48 +02:00
|
|
|
/* only logical slots are database specific, skip */
|
|
|
|
if (!SlotIsLogical(s))
|
2014-03-07 17:42:18 +01:00
|
|
|
continue;
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
|
|
|
|
/* not our database, skip */
|
|
|
|
if (s->data.database != dboid)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* count slots with spinlock held */
|
|
|
|
SpinLockAcquire(&s->mutex);
|
|
|
|
(*nslots)++;
|
2015-04-21 11:51:06 +02:00
|
|
|
if (s->active_pid != 0)
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
(*nactive)++;
|
|
|
|
SpinLockRelease(&s->mutex);
|
|
|
|
}
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
|
|
|
|
if (*nslots > 0)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-03-28 16:05:21 +02:00
|
|
|
/*
|
|
|
|
* ReplicationSlotsDropDBSlots -- Drop all db-specific slots relating to the
|
|
|
|
* passed database oid. The caller should hold an exclusive lock on the
|
|
|
|
* pg_database oid for the database to prevent creation of new slots on the db
|
|
|
|
* or replay from existing slots.
|
|
|
|
*
|
|
|
|
* Another session that concurrently acquires an existing slot on the target DB
|
|
|
|
* (most likely to drop it) may cause this function to ERROR. If that happens
|
|
|
|
* it may have dropped some but not all slots.
|
2017-04-06 05:56:35 +02:00
|
|
|
*
|
|
|
|
* This routine isn't as efficient as it could be - but we don't drop
|
|
|
|
* databases often, especially databases with lots of slots.
|
2017-03-28 16:05:21 +02:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
ReplicationSlotsDropDBSlots(Oid dboid)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (max_replication_slots <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
restart:
|
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
|
|
|
|
for (i = 0; i < max_replication_slots; i++)
|
|
|
|
{
|
|
|
|
ReplicationSlot *s;
|
2017-04-06 05:56:35 +02:00
|
|
|
char *slotname;
|
2017-03-28 16:05:21 +02:00
|
|
|
int active_pid;
|
|
|
|
|
|
|
|
s = &ReplicationSlotCtl->replication_slots[i];
|
|
|
|
|
|
|
|
/* cannot change while ReplicationSlotCtlLock is held */
|
|
|
|
if (!s->in_use)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* only logical slots are database specific, skip */
|
|
|
|
if (!SlotIsLogical(s))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* not our database, skip */
|
|
|
|
if (s->data.database != dboid)
|
|
|
|
continue;
|
|
|
|
|
2017-04-06 05:56:35 +02:00
|
|
|
/* acquire slot, so ReplicationSlotDropAcquired can be reused */
|
2017-03-28 16:05:21 +02:00
|
|
|
SpinLockAcquire(&s->mutex);
|
2017-04-06 05:56:35 +02:00
|
|
|
/* can't change while ReplicationSlotControlLock is held */
|
|
|
|
slotname = NameStr(s->data.name);
|
2017-03-28 16:05:21 +02:00
|
|
|
active_pid = s->active_pid;
|
|
|
|
if (active_pid == 0)
|
|
|
|
{
|
|
|
|
MyReplicationSlot = s;
|
|
|
|
s->active_pid = MyProcPid;
|
|
|
|
}
|
|
|
|
SpinLockRelease(&s->mutex);
|
|
|
|
|
|
|
|
/*
|
2017-04-06 05:56:35 +02:00
|
|
|
* Even though we hold an exclusive lock on the database object a
|
|
|
|
* logical slot for that DB can still be active, e.g. if it's
|
|
|
|
* concurrently being dropped by a backend connected to another DB.
|
2017-03-28 16:05:21 +02:00
|
|
|
*
|
2017-04-06 05:56:35 +02:00
|
|
|
* That's fairly unlikely in practice, so we'll just bail out.
|
2017-03-28 16:05:21 +02:00
|
|
|
*/
|
|
|
|
if (active_pid)
|
2017-04-06 05:56:35 +02:00
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_OBJECT_IN_USE),
|
|
|
|
errmsg("replication slot \"%s\" is active for PID %d",
|
|
|
|
slotname, active_pid)));
|
2017-03-28 16:05:21 +02:00
|
|
|
|
|
|
|
/*
|
2017-04-06 05:56:35 +02:00
|
|
|
* To avoid duplicating ReplicationSlotDropAcquired() and to avoid
|
|
|
|
* holding ReplicationSlotControlLock over filesystem operations,
|
|
|
|
* release ReplicationSlotControlLock and use
|
|
|
|
* ReplicationSlotDropAcquired.
|
2017-03-28 16:05:21 +02:00
|
|
|
*
|
2017-04-06 05:56:35 +02:00
|
|
|
* As that means the set of slots could change, restart scan from the
|
|
|
|
* beginning each time we release the lock.
|
2017-03-28 16:05:21 +02:00
|
|
|
*/
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
ReplicationSlotDropAcquired();
|
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
}
|
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
/*
|
|
|
|
* Check whether the server's configuration supports using replication
|
|
|
|
* slots.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
CheckSlotRequirements(void)
|
|
|
|
{
|
2018-10-31 22:47:41 +01:00
|
|
|
/*
|
|
|
|
* NB: Adding a new requirement likely means that RestoreSlotFromDisk()
|
|
|
|
* needs the same check.
|
|
|
|
*/
|
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
if (max_replication_slots == 0)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
2020-01-30 17:32:04 +01:00
|
|
|
errmsg("replication slots can only be used if max_replication_slots > 0")));
|
2014-02-01 04:45:17 +01:00
|
|
|
|
2016-03-01 02:01:54 +01:00
|
|
|
if (wal_level < WAL_LEVEL_REPLICA)
|
2014-02-01 04:45:17 +01:00
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
2016-04-05 03:17:54 +02:00
|
|
|
errmsg("replication slots can only be used if wal_level >= replica")));
|
2014-02-01 04:45:17 +01:00
|
|
|
}
|
|
|
|
|
2021-09-14 03:15:49 +02:00
|
|
|
/*
|
|
|
|
* Check whether the user has privilege to use replication slots.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
CheckSlotPermissions(void)
|
|
|
|
{
|
|
|
|
if (!superuser() && !has_rolreplication(GetUserId()))
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
|
|
|
|
errmsg("must be superuser or replication role to use replication slots")));
|
|
|
|
}
|
|
|
|
|
2015-08-11 12:34:31 +02:00
|
|
|
/*
|
|
|
|
* Reserve WAL for the currently active slot.
|
|
|
|
*
|
|
|
|
* Compute and set restart_lsn in a manner that's appropriate for the type of
|
|
|
|
* the slot and concurrency safe.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ReplicationSlotReserveWal(void)
|
|
|
|
{
|
|
|
|
ReplicationSlot *slot = MyReplicationSlot;
|
|
|
|
|
|
|
|
Assert(slot != NULL);
|
|
|
|
Assert(slot->data.restart_lsn == InvalidXLogRecPtr);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The replication slot mechanism is used to prevent removal of required
|
|
|
|
* WAL. As there is no interlock between this routine and checkpoints, WAL
|
|
|
|
* segments could concurrently be removed when a now stale return value of
|
|
|
|
* ReplicationSlotsComputeRequiredLSN() is used. In the unlikely case that
|
|
|
|
* this happens we'll just retry.
|
|
|
|
*/
|
|
|
|
while (true)
|
|
|
|
{
|
|
|
|
XLogSegNo segno;
|
2018-06-11 23:52:34 +02:00
|
|
|
XLogRecPtr restart_lsn;
|
2015-08-11 12:34:31 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For logical slots log a standby snapshot and start logical decoding
|
|
|
|
* at exactly that position. That allows the slot to start up more
|
|
|
|
* quickly.
|
|
|
|
*
|
|
|
|
* That's not needed (or indeed helpful) for physical slots as they'll
|
|
|
|
* start replay at the last logged checkpoint anyway. Instead return
|
|
|
|
* the location of the last redo LSN. While that slightly increases
|
|
|
|
* the chance that we have to retry, it's where a base backup has to
|
|
|
|
* start replay at.
|
|
|
|
*/
|
|
|
|
if (!RecoveryInProgress() && SlotIsLogical(slot))
|
|
|
|
{
|
|
|
|
XLogRecPtr flushptr;
|
|
|
|
|
|
|
|
/* start at current insert position */
|
2018-06-11 23:52:34 +02:00
|
|
|
restart_lsn = GetXLogInsertRecPtr();
|
2018-06-01 20:30:55 +02:00
|
|
|
SpinLockAcquire(&slot->mutex);
|
2018-06-11 23:52:34 +02:00
|
|
|
slot->data.restart_lsn = restart_lsn;
|
2018-06-01 20:30:55 +02:00
|
|
|
SpinLockRelease(&slot->mutex);
|
2015-08-11 12:34:31 +02:00
|
|
|
|
|
|
|
/* make sure we have enough information to start */
|
|
|
|
flushptr = LogStandbySnapshot();
|
|
|
|
|
|
|
|
/* and make sure it's fsynced to disk */
|
|
|
|
XLogFlush(flushptr);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2018-06-11 23:52:34 +02:00
|
|
|
restart_lsn = GetRedoRecPtr();
|
2018-06-01 20:30:55 +02:00
|
|
|
SpinLockAcquire(&slot->mutex);
|
2018-06-11 23:52:34 +02:00
|
|
|
slot->data.restart_lsn = restart_lsn;
|
2018-06-01 20:30:55 +02:00
|
|
|
SpinLockRelease(&slot->mutex);
|
2015-08-11 12:34:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* prevent WAL removal as fast as possible */
|
|
|
|
ReplicationSlotsComputeRequiredLSN();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If all required WAL is still there, great, otherwise retry. The
|
|
|
|
* slot should prevent further removal of WAL, unless there's a
|
|
|
|
* concurrent ReplicationSlotsComputeRequiredLSN() after we've written
|
|
|
|
* the new restart_lsn above, so normally we should never need to loop
|
|
|
|
* more than twice.
|
|
|
|
*/
|
Make WAL segment size configurable at initdb time.
For performance reasons a larger segment size than the default 16MB
can be useful. A larger segment size has two main benefits: Firstly,
in setups using archiving, it makes it easier to write scripts that
can keep up with higher amounts of WAL, secondly, the WAL has to be
written and synced to disk less frequently.
But at the same time large segment size are disadvantageous for
smaller databases. So far the segment size had to be configured at
compile time, often making it unrealistic to choose one fitting to a
particularly load. Therefore change it to a initdb time setting.
This includes a breaking changes to the xlogreader.h API, which now
requires the current segment size to be configured. For that and
similar reasons a number of binaries had to be taught how to recognize
the current segment size.
Author: Beena Emerson, editorialized by Andres Freund
Reviewed-By: Andres Freund, David Steele, Kuntal Ghosh, Michael
Paquier, Peter Eisentraut, Robert Hass, Tushar Ahuja
Discussion: https://postgr.es/m/CAOG9ApEAcQ--1ieKbhFzXSQPw_YLmepaa4hNdnY5+ZULpt81Mw@mail.gmail.com
2017-09-20 07:03:48 +02:00
|
|
|
XLByteToSeg(slot->data.restart_lsn, segno, wal_segment_size);
|
2015-08-11 12:34:31 +02:00
|
|
|
if (XLogGetLastRemovedSegno() < segno)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-08 00:35:00 +02:00
|
|
|
/*
|
2021-06-11 18:16:14 +02:00
|
|
|
* Helper for InvalidateObsoleteReplicationSlots -- acquires the given slot
|
|
|
|
* and mark it invalid, if necessary and possible.
|
2020-04-08 00:35:00 +02:00
|
|
|
*
|
2021-06-11 18:16:14 +02:00
|
|
|
* Returns whether ReplicationSlotControlLock was released in the interim (and
|
|
|
|
* in that case we're not holding the lock at return, otherwise we are).
|
|
|
|
*
|
2021-07-16 18:07:30 +02:00
|
|
|
* Sets *invalidated true if the slot was invalidated. (Untouched otherwise.)
|
|
|
|
*
|
2021-06-11 18:16:14 +02:00
|
|
|
* This is inherently racy, because we release the LWLock
|
|
|
|
* for syscalls, so caller must restart if we return true.
|
2020-04-08 00:35:00 +02:00
|
|
|
*/
|
2021-06-11 18:16:14 +02:00
|
|
|
static bool
|
2021-07-16 18:07:30 +02:00
|
|
|
InvalidatePossiblyObsoleteSlot(ReplicationSlot *s, XLogRecPtr oldestLSN,
|
|
|
|
bool *invalidated)
|
2020-04-08 00:35:00 +02:00
|
|
|
{
|
2021-06-11 18:16:14 +02:00
|
|
|
int last_signaled_pid = 0;
|
|
|
|
bool released_lock = false;
|
2020-04-08 00:35:00 +02:00
|
|
|
|
2021-06-11 18:16:14 +02:00
|
|
|
for (;;)
|
2020-04-08 00:35:00 +02:00
|
|
|
{
|
2021-06-11 18:16:14 +02:00
|
|
|
XLogRecPtr restart_lsn;
|
Don't call palloc() while holding a spinlock, either.
Fix some more violations of the "only straight-line code inside a
spinlock" rule. These are hazardous not only because they risk
holding the lock for an excessively long time, but because it's
possible for palloc to throw elog(ERROR), leaving a stuck spinlock
behind.
copy_replication_slot() had two separate places that did pallocs
while holding a spinlock. We can make the code simpler and safer
by copying the whole ReplicationSlot struct into a local variable
while holding the spinlock, and then referencing that copy.
(While that's arguably more cycles than we really need to spend
holding the lock, the struct isn't all that big, and this way seems
far more maintainable than copying fields piecemeal. Anyway this
is surely much cheaper than a palloc.) That bug goes back to v12.
InvalidateObsoleteReplicationSlots() not only did a palloc while
holding a spinlock, but for extra sloppiness then leaked the memory
--- probably for the lifetime of the checkpointer process, though
I didn't try to verify that. Fortunately that silliness is new
in HEAD.
pg_get_replication_slots() had a cosmetic violation of the rule,
in that it only assumed it's safe to call namecpy() while holding
a spinlock. Still, that's a hazard waiting to bite somebody, and
there were some other cosmetic coding-rule violations in the same
function, so clean it up. I back-patched this as far as v10; the
code exists before that but it looks different, and this didn't
seem important enough to adapt the patch further back.
Discussion: https://postgr.es/m/20200602.161518.1399689010416646074.horikyota.ntt@gmail.com
2020-06-03 18:36:00 +02:00
|
|
|
NameData slotname;
|
2021-06-11 18:16:14 +02:00
|
|
|
int active_pid = 0;
|
|
|
|
|
|
|
|
Assert(LWLockHeldByMeInMode(ReplicationSlotControlLock, LW_SHARED));
|
2020-04-08 00:35:00 +02:00
|
|
|
|
|
|
|
if (!s->in_use)
|
2021-06-11 18:16:14 +02:00
|
|
|
{
|
|
|
|
if (released_lock)
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
break;
|
|
|
|
}
|
2020-04-08 00:35:00 +02:00
|
|
|
|
2021-06-11 18:16:14 +02:00
|
|
|
/*
|
|
|
|
* Check if the slot needs to be invalidated. If it needs to be
|
|
|
|
* invalidated, and is not currently acquired, acquire it and mark it
|
|
|
|
* as having been invalidated. We do this with the spinlock held to
|
|
|
|
* avoid race conditions -- for example the restart_lsn could move
|
|
|
|
* forward, or the slot could be dropped.
|
|
|
|
*/
|
2020-04-08 00:35:00 +02:00
|
|
|
SpinLockAcquire(&s->mutex);
|
2021-06-11 18:16:14 +02:00
|
|
|
|
2020-04-08 00:35:00 +02:00
|
|
|
restart_lsn = s->data.restart_lsn;
|
2020-06-19 10:15:52 +02:00
|
|
|
|
2021-06-11 18:16:14 +02:00
|
|
|
/*
|
|
|
|
* If the slot is already invalid or is fresh enough, we don't need to
|
|
|
|
* do anything.
|
|
|
|
*/
|
2020-06-19 10:15:52 +02:00
|
|
|
if (XLogRecPtrIsInvalid(restart_lsn) || restart_lsn >= oldestLSN)
|
2021-06-11 18:16:14 +02:00
|
|
|
{
|
|
|
|
SpinLockRelease(&s->mutex);
|
|
|
|
if (released_lock)
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
slotname = s->data.name;
|
|
|
|
active_pid = s->active_pid;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the slot can be acquired, do so and mark it invalidated
|
|
|
|
* immediately. Otherwise we'll signal the owning process, below, and
|
|
|
|
* retry.
|
|
|
|
*/
|
|
|
|
if (active_pid == 0)
|
|
|
|
{
|
|
|
|
MyReplicationSlot = s;
|
|
|
|
s->active_pid = MyProcPid;
|
|
|
|
s->data.invalidated_at = restart_lsn;
|
|
|
|
s->data.restart_lsn = InvalidXLogRecPtr;
|
2021-07-16 18:07:30 +02:00
|
|
|
|
|
|
|
/* Let caller know */
|
|
|
|
*invalidated = true;
|
2021-06-11 18:16:14 +02:00
|
|
|
}
|
2020-04-08 00:35:00 +02:00
|
|
|
|
2021-06-11 18:16:14 +02:00
|
|
|
SpinLockRelease(&s->mutex);
|
2020-06-19 10:15:52 +02:00
|
|
|
|
2021-06-11 18:16:14 +02:00
|
|
|
if (active_pid != 0)
|
2020-04-08 00:35:00 +02:00
|
|
|
{
|
2020-06-19 10:15:52 +02:00
|
|
|
/*
|
2021-06-11 18:16:14 +02:00
|
|
|
* Prepare the sleep on the slot's condition variable before
|
|
|
|
* releasing the lock, to close a possible race condition if the
|
|
|
|
* slot is released before the sleep below.
|
2020-06-19 10:15:52 +02:00
|
|
|
*/
|
2021-06-11 18:16:14 +02:00
|
|
|
ConditionVariablePrepareToSleep(&s->active_cv);
|
2020-04-08 00:35:00 +02:00
|
|
|
|
2021-06-11 18:16:14 +02:00
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
released_lock = true;
|
2020-04-08 00:35:00 +02:00
|
|
|
|
2020-06-19 10:15:52 +02:00
|
|
|
/*
|
2021-06-11 18:16:14 +02:00
|
|
|
* Signal to terminate the process that owns the slot, if we
|
|
|
|
* haven't already signalled it. (Avoidance of repeated
|
|
|
|
* signalling is the only reason for there to be a loop in this
|
|
|
|
* routine; otherwise we could rely on caller's restart loop.)
|
2020-06-19 10:15:52 +02:00
|
|
|
*
|
2021-06-11 18:16:14 +02:00
|
|
|
* There is the race condition that other process may own the slot
|
|
|
|
* after its current owner process is terminated and before this
|
|
|
|
* process owns it. To handle that, we signal only if the PID of
|
|
|
|
* the owning process has changed from the previous time. (This
|
|
|
|
* logic assumes that the same PID is not reused very quickly.)
|
2020-06-19 10:15:52 +02:00
|
|
|
*/
|
2021-06-11 18:16:14 +02:00
|
|
|
if (last_signaled_pid != active_pid)
|
2020-06-19 10:15:52 +02:00
|
|
|
{
|
|
|
|
ereport(LOG,
|
2021-06-11 18:16:14 +02:00
|
|
|
(errmsg("terminating process %d to release replication slot \"%s\"",
|
|
|
|
active_pid, NameStr(slotname))));
|
|
|
|
|
|
|
|
(void) kill(active_pid, SIGTERM);
|
|
|
|
last_signaled_pid = active_pid;
|
2020-06-19 10:15:52 +02:00
|
|
|
}
|
2020-04-08 00:35:00 +02:00
|
|
|
|
2021-06-11 18:16:14 +02:00
|
|
|
/* Wait until the slot is released. */
|
|
|
|
ConditionVariableSleep(&s->active_cv,
|
|
|
|
WAIT_EVENT_REPLICATION_SLOT_DROP);
|
|
|
|
|
|
|
|
/*
|
2021-06-11 21:48:26 +02:00
|
|
|
* Re-acquire lock and start over; we expect to invalidate the
|
|
|
|
* slot next time (unless another process acquires the slot in the
|
2021-06-11 18:16:14 +02:00
|
|
|
* meantime).
|
|
|
|
*/
|
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
|
|
|
|
continue;
|
2020-04-08 00:35:00 +02:00
|
|
|
}
|
2021-06-11 18:16:14 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We hold the slot now and have already invalidated it; flush it
|
|
|
|
* to ensure that state persists.
|
|
|
|
*
|
|
|
|
* Don't want to hold ReplicationSlotControlLock across file
|
|
|
|
* system operations, so release it now but be sure to tell caller
|
|
|
|
* to restart from scratch.
|
|
|
|
*/
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
|
|
|
released_lock = true;
|
2020-04-08 00:35:00 +02:00
|
|
|
|
2021-06-11 18:16:14 +02:00
|
|
|
/* Make sure the invalidated state persists across server restart */
|
|
|
|
ReplicationSlotMarkDirty();
|
|
|
|
ReplicationSlotSave();
|
|
|
|
ReplicationSlotRelease();
|
2020-06-19 10:15:52 +02:00
|
|
|
|
2021-06-11 18:16:14 +02:00
|
|
|
ereport(LOG,
|
|
|
|
(errmsg("invalidating slot \"%s\" because its restart_lsn %X/%X exceeds max_slot_wal_keep_size",
|
|
|
|
NameStr(slotname),
|
|
|
|
LSN_FORMAT_ARGS(restart_lsn))));
|
2020-04-08 00:35:00 +02:00
|
|
|
|
2021-06-11 18:16:14 +02:00
|
|
|
/* done with this slot for now */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2020-06-27 02:41:29 +02:00
|
|
|
|
2021-06-11 18:16:14 +02:00
|
|
|
Assert(released_lock == !LWLockHeldByMe(ReplicationSlotControlLock));
|
2020-04-08 00:35:00 +02:00
|
|
|
|
2021-06-11 18:16:14 +02:00
|
|
|
return released_lock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mark any slot that points to an LSN older than the given segment
|
|
|
|
* as invalid; it requires WAL that's about to be removed.
|
|
|
|
*
|
2021-07-16 18:07:30 +02:00
|
|
|
* Returns true when any slot have got invalidated.
|
|
|
|
*
|
2021-06-11 18:16:14 +02:00
|
|
|
* NB - this runs as part of checkpoint, so avoid raising errors if possible.
|
|
|
|
*/
|
2021-07-16 18:07:30 +02:00
|
|
|
bool
|
2021-06-11 18:16:14 +02:00
|
|
|
InvalidateObsoleteReplicationSlots(XLogSegNo oldestSegno)
|
|
|
|
{
|
|
|
|
XLogRecPtr oldestLSN;
|
2021-07-16 18:07:30 +02:00
|
|
|
bool invalidated = false;
|
2021-06-11 18:16:14 +02:00
|
|
|
|
|
|
|
XLogSegNoOffsetToRecPtr(oldestSegno, 0, wal_segment_size, oldestLSN);
|
|
|
|
|
|
|
|
restart:
|
|
|
|
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
|
|
|
|
for (int i = 0; i < max_replication_slots; i++)
|
|
|
|
{
|
|
|
|
ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
|
|
|
|
|
|
|
|
if (!s->in_use)
|
|
|
|
continue;
|
|
|
|
|
2021-07-16 18:07:30 +02:00
|
|
|
if (InvalidatePossiblyObsoleteSlot(s, oldestLSN, &invalidated))
|
2021-06-11 18:16:14 +02:00
|
|
|
{
|
|
|
|
/* if the lock was released, start from scratch */
|
|
|
|
goto restart;
|
|
|
|
}
|
2020-04-08 00:35:00 +02:00
|
|
|
}
|
|
|
|
LWLockRelease(ReplicationSlotControlLock);
|
2021-07-16 18:07:30 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If any slots have been invalidated, recalculate the resource limits.
|
|
|
|
*/
|
|
|
|
if (invalidated)
|
|
|
|
{
|
|
|
|
ReplicationSlotsComputeRequiredXmin(false);
|
|
|
|
ReplicationSlotsComputeRequiredLSN();
|
|
|
|
}
|
|
|
|
|
|
|
|
return invalidated;
|
2020-04-08 00:35:00 +02:00
|
|
|
}
|
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
/*
|
|
|
|
* Flush all replication slots to disk.
|
|
|
|
*
|
|
|
|
* This needn't actually be part of a checkpoint, but it's a convenient
|
|
|
|
* location.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
CheckPointReplicationSlots(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2014-11-12 02:00:58 +01:00
|
|
|
elog(DEBUG1, "performing replication slot checkpoint");
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Prevent any slot from being created/dropped while we're active. As we
|
|
|
|
* explicitly do *not* want to block iterating over replication_slots or
|
|
|
|
* acquiring a slot we cannot take the control lock - but that's OK,
|
|
|
|
* because holding ReplicationSlotAllocationLock is strictly stronger, and
|
|
|
|
* enough to guarantee that nobody can change the in_use bits on us.
|
|
|
|
*/
|
|
|
|
LWLockAcquire(ReplicationSlotAllocationLock, LW_SHARED);
|
|
|
|
|
|
|
|
for (i = 0; i < max_replication_slots; i++)
|
|
|
|
{
|
|
|
|
ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
|
|
|
|
char path[MAXPGPATH];
|
|
|
|
|
|
|
|
if (!s->in_use)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* save the slot to disk, locking is handled in SaveSlotToPath() */
|
|
|
|
sprintf(path, "pg_replslot/%s", NameStr(s->data.name));
|
|
|
|
SaveSlotToPath(s, path, LOG);
|
|
|
|
}
|
|
|
|
LWLockRelease(ReplicationSlotAllocationLock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Load all replication slots from disk into memory at server startup. This
|
|
|
|
* needs to be run before we start crash recovery.
|
|
|
|
*/
|
|
|
|
void
|
2014-06-12 13:23:46 +02:00
|
|
|
StartupReplicationSlots(void)
|
2014-02-01 04:45:17 +01:00
|
|
|
{
|
|
|
|
DIR *replication_dir;
|
|
|
|
struct dirent *replication_de;
|
|
|
|
|
2014-11-12 02:00:58 +01:00
|
|
|
elog(DEBUG1, "starting up replication slots");
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* restore all slots by iterating over all on-disk entries */
|
|
|
|
replication_dir = AllocateDir("pg_replslot");
|
|
|
|
while ((replication_de = ReadDir(replication_dir, "pg_replslot")) != NULL)
|
|
|
|
{
|
|
|
|
struct stat statbuf;
|
2017-04-11 20:13:31 +02:00
|
|
|
char path[MAXPGPATH + 12];
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
if (strcmp(replication_de->d_name, ".") == 0 ||
|
|
|
|
strcmp(replication_de->d_name, "..") == 0)
|
|
|
|
continue;
|
|
|
|
|
2017-04-11 20:13:31 +02:00
|
|
|
snprintf(path, sizeof(path), "pg_replslot/%s", replication_de->d_name);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* we're only creating directories here, skip if it's not our's */
|
|
|
|
if (lstat(path, &statbuf) == 0 && !S_ISDIR(statbuf.st_mode))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* we crashed while a slot was being setup or deleted, clean up */
|
2015-01-03 20:51:52 +01:00
|
|
|
if (pg_str_endswith(replication_de->d_name, ".tmp"))
|
2014-02-01 04:45:17 +01:00
|
|
|
{
|
|
|
|
if (!rmtree(path, true))
|
|
|
|
{
|
|
|
|
ereport(WARNING,
|
2018-09-04 20:06:04 +02:00
|
|
|
(errmsg("could not remove directory \"%s\"",
|
|
|
|
path)));
|
2014-02-01 04:45:17 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
fsync_fname("pg_replslot", true);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* looks like a slot in a normal state, restore */
|
|
|
|
RestoreSlotFromDisk(replication_de->d_name);
|
|
|
|
}
|
|
|
|
FreeDir(replication_dir);
|
|
|
|
|
|
|
|
/* currently no slots exist, we're done. */
|
|
|
|
if (max_replication_slots <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Now that we have recovered all the data, compute replication xmin */
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
ReplicationSlotsComputeRequiredXmin(false);
|
2014-02-01 04:45:17 +01:00
|
|
|
ReplicationSlotsComputeRequiredLSN();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ----
|
2015-08-11 12:32:48 +02:00
|
|
|
* Manipulation of on-disk state of replication slots
|
2014-02-01 04:45:17 +01:00
|
|
|
*
|
|
|
|
* NB: none of the routines below should take any notice whether a slot is the
|
|
|
|
* current one or not, that's all handled a layer above.
|
|
|
|
* ----
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
CreateSlotOnDisk(ReplicationSlot *slot)
|
|
|
|
{
|
|
|
|
char tmppath[MAXPGPATH];
|
|
|
|
char path[MAXPGPATH];
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* No need to take out the io_in_progress_lock, nobody else can see this
|
2014-02-02 02:28:18 +01:00
|
|
|
* slot yet, so nobody else will write. We're reusing SaveSlotToPath which
|
2014-02-01 04:45:17 +01:00
|
|
|
* takes out the lock, if we'd take the lock here, we'd deadlock.
|
|
|
|
*/
|
|
|
|
|
|
|
|
sprintf(path, "pg_replslot/%s", NameStr(slot->data.name));
|
|
|
|
sprintf(tmppath, "pg_replslot/%s.tmp", NameStr(slot->data.name));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It's just barely possible that some previous effort to create or drop a
|
|
|
|
* slot with this name left a temp directory lying around. If that seems
|
|
|
|
* to be the case, try to remove it. If the rmtree() fails, we'll error
|
2018-04-07 23:45:39 +02:00
|
|
|
* out at the MakePGDirectory() below, so we don't bother checking
|
|
|
|
* success.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
|
|
|
if (stat(tmppath, &st) == 0 && S_ISDIR(st.st_mode))
|
|
|
|
rmtree(tmppath, true);
|
|
|
|
|
|
|
|
/* Create and fsync the temporary slot directory. */
|
2018-04-07 23:45:39 +02:00
|
|
|
if (MakePGDirectory(tmppath) < 0)
|
2014-02-01 04:45:17 +01:00
|
|
|
ereport(ERROR,
|
|
|
|
(errcode_for_file_access(),
|
|
|
|
errmsg("could not create directory \"%s\": %m",
|
|
|
|
tmppath)));
|
|
|
|
fsync_fname(tmppath, true);
|
|
|
|
|
|
|
|
/* Write the actual state file. */
|
|
|
|
slot->dirty = true; /* signal that we really need to write */
|
|
|
|
SaveSlotToPath(slot, tmppath, ERROR);
|
|
|
|
|
|
|
|
/* Rename the directory into place. */
|
|
|
|
if (rename(tmppath, path) != 0)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode_for_file_access(),
|
|
|
|
errmsg("could not rename file \"%s\" to \"%s\": %m",
|
|
|
|
tmppath, path)));
|
|
|
|
|
|
|
|
/*
|
2014-02-02 02:28:18 +01:00
|
|
|
* If we'd now fail - really unlikely - we wouldn't know whether this slot
|
2014-02-01 04:45:17 +01:00
|
|
|
* would persist after an OS crash or not - so, force a restart. The
|
2016-02-05 14:11:00 +01:00
|
|
|
* restart would try to fsync this again till it works.
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
|
|
|
START_CRIT_SECTION();
|
|
|
|
|
|
|
|
fsync_fname(path, true);
|
|
|
|
fsync_fname("pg_replslot", true);
|
|
|
|
|
|
|
|
END_CRIT_SECTION();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Shared functionality between saving and creating a replication slot.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
SaveSlotToPath(ReplicationSlot *slot, const char *dir, int elevel)
|
|
|
|
{
|
|
|
|
char tmppath[MAXPGPATH];
|
|
|
|
char path[MAXPGPATH];
|
|
|
|
int fd;
|
|
|
|
ReplicationSlotOnDisk cp;
|
|
|
|
bool was_dirty;
|
|
|
|
|
|
|
|
/* first check whether there's something to write out */
|
2015-10-06 21:45:02 +02:00
|
|
|
SpinLockAcquire(&slot->mutex);
|
|
|
|
was_dirty = slot->dirty;
|
|
|
|
slot->just_dirtied = false;
|
|
|
|
SpinLockRelease(&slot->mutex);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* and don't do anything if there's nothing to write */
|
|
|
|
if (!was_dirty)
|
|
|
|
return;
|
|
|
|
|
2016-01-29 15:44:29 +01:00
|
|
|
LWLockAcquire(&slot->io_in_progress_lock, LW_EXCLUSIVE);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* silence valgrind :( */
|
|
|
|
memset(&cp, 0, sizeof(ReplicationSlotOnDisk));
|
|
|
|
|
|
|
|
sprintf(tmppath, "%s/state.tmp", dir);
|
|
|
|
sprintf(path, "%s/state", dir);
|
|
|
|
|
2017-09-23 15:49:22 +02:00
|
|
|
fd = OpenTransientFile(tmppath, O_CREAT | O_EXCL | O_WRONLY | PG_BINARY);
|
2014-02-01 04:45:17 +01:00
|
|
|
if (fd < 0)
|
|
|
|
{
|
2020-03-26 11:51:39 +01:00
|
|
|
/*
|
|
|
|
* If not an ERROR, then release the lock before returning. In case
|
|
|
|
* of an ERROR, the error recovery path automatically releases the
|
2020-04-05 10:02:00 +02:00
|
|
|
* lock, but no harm in explicitly releasing even in that case. Note
|
|
|
|
* that LWLockRelease() could affect errno.
|
2020-03-26 11:51:39 +01:00
|
|
|
*/
|
2020-04-05 10:02:00 +02:00
|
|
|
int save_errno = errno;
|
|
|
|
|
2020-03-26 11:51:39 +01:00
|
|
|
LWLockRelease(&slot->io_in_progress_lock);
|
2020-04-05 10:02:00 +02:00
|
|
|
errno = save_errno;
|
2014-02-01 04:45:17 +01:00
|
|
|
ereport(elevel,
|
|
|
|
(errcode_for_file_access(),
|
|
|
|
errmsg("could not create file \"%s\": %m",
|
|
|
|
tmppath)));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
cp.magic = SLOT_MAGIC;
|
Switch to CRC-32C in WAL and other places.
The old algorithm was found to not be the usual CRC-32 algorithm, used by
Ethernet et al. We were using a non-reflected lookup table with code meant
for a reflected lookup table. That's a strange combination that AFAICS does
not correspond to any bit-wise CRC calculation, which makes it difficult to
reason about its properties. Although it has worked well in practice, seems
safer to use a well-known algorithm.
Since we're changing the algorithm anyway, we might as well choose a
different polynomial. The Castagnoli polynomial has better error-correcting
properties than the traditional CRC-32 polynomial, even if we had
implemented it correctly. Another reason for picking that is that some new
CPUs have hardware support for calculating CRC-32C, but not CRC-32, let
alone our strange variant of it. This patch doesn't add any support for such
hardware, but a future patch could now do that.
The old algorithm is kept around for tsquery and pg_trgm, which use the
values in indexes that need to remain compatible so that pg_upgrade works.
While we're at it, share the old lookup table for CRC-32 calculation
between hstore, ltree and core. They all use the same table, so might as
well.
2014-11-04 10:35:15 +01:00
|
|
|
INIT_CRC32C(cp.checksum);
|
2014-11-12 18:52:49 +01:00
|
|
|
cp.version = SLOT_VERSION;
|
|
|
|
cp.length = ReplicationSlotOnDiskV2Size;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
SpinLockAcquire(&slot->mutex);
|
|
|
|
|
|
|
|
memcpy(&cp.slotdata, &slot->data, sizeof(ReplicationSlotPersistentData));
|
|
|
|
|
|
|
|
SpinLockRelease(&slot->mutex);
|
|
|
|
|
Switch to CRC-32C in WAL and other places.
The old algorithm was found to not be the usual CRC-32 algorithm, used by
Ethernet et al. We were using a non-reflected lookup table with code meant
for a reflected lookup table. That's a strange combination that AFAICS does
not correspond to any bit-wise CRC calculation, which makes it difficult to
reason about its properties. Although it has worked well in practice, seems
safer to use a well-known algorithm.
Since we're changing the algorithm anyway, we might as well choose a
different polynomial. The Castagnoli polynomial has better error-correcting
properties than the traditional CRC-32 polynomial, even if we had
implemented it correctly. Another reason for picking that is that some new
CPUs have hardware support for calculating CRC-32C, but not CRC-32, let
alone our strange variant of it. This patch doesn't add any support for such
hardware, but a future patch could now do that.
The old algorithm is kept around for tsquery and pg_trgm, which use the
values in indexes that need to remain compatible so that pg_upgrade works.
While we're at it, share the old lookup table for CRC-32 calculation
between hstore, ltree and core. They all use the same table, so might as
well.
2014-11-04 10:35:15 +01:00
|
|
|
COMP_CRC32C(cp.checksum,
|
2021-11-24 03:36:55 +01:00
|
|
|
(char *) (&cp) + ReplicationSlotOnDiskNotChecksummedSize,
|
|
|
|
ReplicationSlotOnDiskChecksummedSize);
|
2014-11-12 18:52:49 +01:00
|
|
|
FIN_CRC32C(cp.checksum);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
2018-08-04 22:31:18 +02:00
|
|
|
errno = 0;
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
pgstat_report_wait_start(WAIT_EVENT_REPLICATION_SLOT_WRITE);
|
2014-02-01 04:45:17 +01:00
|
|
|
if ((write(fd, &cp, sizeof(cp))) != sizeof(cp))
|
|
|
|
{
|
|
|
|
int save_errno = errno;
|
2014-05-06 18:12:18 +02:00
|
|
|
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
pgstat_report_wait_end();
|
2014-02-01 04:45:17 +01:00
|
|
|
CloseTransientFile(fd);
|
2020-03-26 11:51:39 +01:00
|
|
|
LWLockRelease(&slot->io_in_progress_lock);
|
2018-06-25 04:19:05 +02:00
|
|
|
|
|
|
|
/* if write didn't set errno, assume problem is no disk space */
|
|
|
|
errno = save_errno ? save_errno : ENOSPC;
|
2014-02-01 04:45:17 +01:00
|
|
|
ereport(elevel,
|
|
|
|
(errcode_for_file_access(),
|
|
|
|
errmsg("could not write to file \"%s\": %m",
|
|
|
|
tmppath)));
|
|
|
|
return;
|
|
|
|
}
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
pgstat_report_wait_end();
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* fsync the temporary file */
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
pgstat_report_wait_start(WAIT_EVENT_REPLICATION_SLOT_SYNC);
|
2014-02-01 04:45:17 +01:00
|
|
|
if (pg_fsync(fd) != 0)
|
|
|
|
{
|
|
|
|
int save_errno = errno;
|
2014-05-06 18:12:18 +02:00
|
|
|
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
pgstat_report_wait_end();
|
2014-02-01 04:45:17 +01:00
|
|
|
CloseTransientFile(fd);
|
2020-03-26 11:51:39 +01:00
|
|
|
LWLockRelease(&slot->io_in_progress_lock);
|
2014-02-01 04:45:17 +01:00
|
|
|
errno = save_errno;
|
|
|
|
ereport(elevel,
|
|
|
|
(errcode_for_file_access(),
|
|
|
|
errmsg("could not fsync file \"%s\": %m",
|
|
|
|
tmppath)));
|
|
|
|
return;
|
|
|
|
}
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
pgstat_report_wait_end();
|
2014-02-01 04:45:17 +01:00
|
|
|
|
2019-07-06 23:18:46 +02:00
|
|
|
if (CloseTransientFile(fd) != 0)
|
2019-04-17 03:01:22 +02:00
|
|
|
{
|
2020-04-05 10:02:00 +02:00
|
|
|
int save_errno = errno;
|
|
|
|
|
2020-03-26 11:51:39 +01:00
|
|
|
LWLockRelease(&slot->io_in_progress_lock);
|
2020-04-05 10:02:00 +02:00
|
|
|
errno = save_errno;
|
Tighten use of OpenTransientFile and CloseTransientFile
This fixes two sets of issues related to the use of transient files in
the backend:
1) OpenTransientFile() has been used in some code paths with read-write
flags while read-only is sufficient, so switch those calls to be
read-only where necessary. These have been reported by Joe Conway.
2) When opening transient files, it is up to the caller to close the
file descriptors opened. In error code paths, CloseTransientFile() gets
called to clean up things before issuing an error. However in normal
exit paths, a lot of callers of CloseTransientFile() never actually
reported errors, which could leave a file descriptor open without
knowing about it. This is an issue I complained about a couple of
times, but never had the courage to write and submit a patch, so here we
go.
Note that one frontend code path is impacted by this commit so as an
error is issued when fetching control file data, making backend and
frontend to be treated consistently.
Reported-by: Joe Conway, Michael Paquier
Author: Michael Paquier
Reviewed-by: Álvaro Herrera, Georgios Kokolatos, Joe Conway
Discussion: https://postgr.es/m/20190301023338.GD1348@paquier.xyz
Discussion: https://postgr.es/m/c49b69ec-e2f7-ff33-4f17-0eaa4f2cef27@joeconway.com
2019-03-09 00:50:55 +01:00
|
|
|
ereport(elevel,
|
|
|
|
(errcode_for_file_access(),
|
|
|
|
errmsg("could not close file \"%s\": %m",
|
|
|
|
tmppath)));
|
2019-04-17 03:01:22 +02:00
|
|
|
return;
|
|
|
|
}
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* rename to permanent file, fsync file and directory */
|
|
|
|
if (rename(tmppath, path) != 0)
|
|
|
|
{
|
2020-04-05 10:02:00 +02:00
|
|
|
int save_errno = errno;
|
|
|
|
|
2020-03-26 11:51:39 +01:00
|
|
|
LWLockRelease(&slot->io_in_progress_lock);
|
2020-04-05 10:02:00 +02:00
|
|
|
errno = save_errno;
|
2014-02-01 04:45:17 +01:00
|
|
|
ereport(elevel,
|
|
|
|
(errcode_for_file_access(),
|
2014-09-05 07:20:33 +02:00
|
|
|
errmsg("could not rename file \"%s\" to \"%s\": %m",
|
2014-02-01 04:45:17 +01:00
|
|
|
tmppath, path)));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-07-01 03:00:23 +02:00
|
|
|
/*
|
|
|
|
* Check CreateSlotOnDisk() for the reasoning of using a critical section.
|
|
|
|
*/
|
2014-02-01 04:45:17 +01:00
|
|
|
START_CRIT_SECTION();
|
|
|
|
|
|
|
|
fsync_fname(path, false);
|
2016-03-10 03:53:53 +01:00
|
|
|
fsync_fname(dir, true);
|
2014-02-01 04:45:17 +01:00
|
|
|
fsync_fname("pg_replslot", true);
|
|
|
|
|
|
|
|
END_CRIT_SECTION();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Successfully wrote, unset dirty bit, unless somebody dirtied again
|
|
|
|
* already.
|
|
|
|
*/
|
2015-10-06 21:45:02 +02:00
|
|
|
SpinLockAcquire(&slot->mutex);
|
|
|
|
if (!slot->just_dirtied)
|
|
|
|
slot->dirty = false;
|
|
|
|
SpinLockRelease(&slot->mutex);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
2016-01-29 15:44:29 +01:00
|
|
|
LWLockRelease(&slot->io_in_progress_lock);
|
2014-02-01 04:45:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Load a single slot from disk into memory.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
RestoreSlotFromDisk(const char *name)
|
|
|
|
{
|
|
|
|
ReplicationSlotOnDisk cp;
|
|
|
|
int i;
|
2018-09-02 21:40:30 +02:00
|
|
|
char slotdir[MAXPGPATH + 12];
|
2017-04-11 20:13:31 +02:00
|
|
|
char path[MAXPGPATH + 22];
|
2014-02-01 04:45:17 +01:00
|
|
|
int fd;
|
|
|
|
bool restored = false;
|
|
|
|
int readBytes;
|
2015-04-14 16:03:42 +02:00
|
|
|
pg_crc32c checksum;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* no need to lock here, no concurrent access allowed yet */
|
|
|
|
|
|
|
|
/* delete temp file if it exists */
|
2018-09-02 21:40:30 +02:00
|
|
|
sprintf(slotdir, "pg_replslot/%s", name);
|
|
|
|
sprintf(path, "%s/state.tmp", slotdir);
|
2014-02-01 04:45:17 +01:00
|
|
|
if (unlink(path) < 0 && errno != ENOENT)
|
|
|
|
ereport(PANIC,
|
|
|
|
(errcode_for_file_access(),
|
2014-09-05 07:20:33 +02:00
|
|
|
errmsg("could not remove file \"%s\": %m", path)));
|
2014-02-01 04:45:17 +01:00
|
|
|
|
2018-09-02 21:40:30 +02:00
|
|
|
sprintf(path, "%s/state", slotdir);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
elog(DEBUG1, "restoring replication slot from \"%s\"", path);
|
|
|
|
|
2019-10-04 22:08:51 +02:00
|
|
|
/* on some operating systems fsyncing a file requires O_RDWR */
|
|
|
|
fd = OpenTransientFile(path, O_RDWR | PG_BINARY);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We do not need to handle this as we are rename()ing the directory into
|
|
|
|
* place only after we fsync()ed the state file.
|
|
|
|
*/
|
|
|
|
if (fd < 0)
|
|
|
|
ereport(PANIC,
|
|
|
|
(errcode_for_file_access(),
|
|
|
|
errmsg("could not open file \"%s\": %m", path)));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sync state file before we're reading from it. We might have crashed
|
|
|
|
* while it wasn't synced yet and we shouldn't continue on that basis.
|
|
|
|
*/
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
pgstat_report_wait_start(WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC);
|
2014-02-01 04:45:17 +01:00
|
|
|
if (pg_fsync(fd) != 0)
|
|
|
|
ereport(PANIC,
|
|
|
|
(errcode_for_file_access(),
|
|
|
|
errmsg("could not fsync file \"%s\": %m",
|
|
|
|
path)));
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
pgstat_report_wait_end();
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* Also sync the parent directory */
|
|
|
|
START_CRIT_SECTION();
|
2018-09-02 21:40:30 +02:00
|
|
|
fsync_fname(slotdir, true);
|
2014-02-01 04:45:17 +01:00
|
|
|
END_CRIT_SECTION();
|
|
|
|
|
|
|
|
/* read part of statefile that's guaranteed to be version independent */
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
pgstat_report_wait_start(WAIT_EVENT_REPLICATION_SLOT_READ);
|
2014-02-01 04:45:17 +01:00
|
|
|
readBytes = read(fd, &cp, ReplicationSlotOnDiskConstantSize);
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
pgstat_report_wait_end();
|
2014-02-01 04:45:17 +01:00
|
|
|
if (readBytes != ReplicationSlotOnDiskConstantSize)
|
|
|
|
{
|
Rework error messages around file handling
Some error messages related to file handling are using the code path
context to define their state. For example, 2PC-related errors are
referring to "two-phase status files", or "relation mapping file" is
used for catalog-to-filenode mapping, however those prove to be
difficult to translate, and are not more helpful than just referring to
the path of the file being worked on. So simplify all those error
messages by just referring to files with their path used. In some
cases, like the manipulation of WAL segments, the context is actually
helpful so those are kept.
Calls to the system function read() have also been rather inconsistent
with their error handling sometimes not reporting the number of bytes
read, and some other code paths trying to use an errno which has not
been set. The in-core functions are using a more consistent pattern
with this patch, which checks for both errno if set or if an
inconsistent read is happening.
So as to care about pluralization when reading an unexpected number of
byte(s), "could not read: read %d of %zu" is used as error message, with
%d field being the output result of read() and %zu the expected size.
This simplifies the work of translators with less variations of the same
message.
Author: Michael Paquier
Reviewed-by: Álvaro Herrera
Discussion: https://postgr.es/m/20180520000522.GB1603@paquier.xyz
2018-07-18 01:01:23 +02:00
|
|
|
if (readBytes < 0)
|
|
|
|
ereport(PANIC,
|
|
|
|
(errcode_for_file_access(),
|
|
|
|
errmsg("could not read file \"%s\": %m", path)));
|
|
|
|
else
|
|
|
|
ereport(PANIC,
|
2018-07-23 02:37:36 +02:00
|
|
|
(errcode(ERRCODE_DATA_CORRUPTED),
|
|
|
|
errmsg("could not read file \"%s\": read %d of %zu",
|
Rework error messages around file handling
Some error messages related to file handling are using the code path
context to define their state. For example, 2PC-related errors are
referring to "two-phase status files", or "relation mapping file" is
used for catalog-to-filenode mapping, however those prove to be
difficult to translate, and are not more helpful than just referring to
the path of the file being worked on. So simplify all those error
messages by just referring to files with their path used. In some
cases, like the manipulation of WAL segments, the context is actually
helpful so those are kept.
Calls to the system function read() have also been rather inconsistent
with their error handling sometimes not reporting the number of bytes
read, and some other code paths trying to use an errno which has not
been set. The in-core functions are using a more consistent pattern
with this patch, which checks for both errno if set or if an
inconsistent read is happening.
So as to care about pluralization when reading an unexpected number of
byte(s), "could not read: read %d of %zu" is used as error message, with
%d field being the output result of read() and %zu the expected size.
This simplifies the work of translators with less variations of the same
message.
Author: Michael Paquier
Reviewed-by: Álvaro Herrera
Discussion: https://postgr.es/m/20180520000522.GB1603@paquier.xyz
2018-07-18 01:01:23 +02:00
|
|
|
path, readBytes,
|
2018-07-18 02:51:53 +02:00
|
|
|
(Size) ReplicationSlotOnDiskConstantSize)));
|
2014-02-01 04:45:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* verify magic */
|
|
|
|
if (cp.magic != SLOT_MAGIC)
|
|
|
|
ereport(PANIC,
|
2018-09-04 20:06:04 +02:00
|
|
|
(errcode(ERRCODE_DATA_CORRUPTED),
|
2015-10-29 01:23:53 +01:00
|
|
|
errmsg("replication slot file \"%s\" has wrong magic number: %u instead of %u",
|
2014-02-01 04:45:17 +01:00
|
|
|
path, cp.magic, SLOT_MAGIC)));
|
|
|
|
|
|
|
|
/* verify version */
|
|
|
|
if (cp.version != SLOT_VERSION)
|
|
|
|
ereport(PANIC,
|
2018-09-04 20:06:04 +02:00
|
|
|
(errcode(ERRCODE_DATA_CORRUPTED),
|
2014-02-01 04:45:17 +01:00
|
|
|
errmsg("replication slot file \"%s\" has unsupported version %u",
|
|
|
|
path, cp.version)));
|
|
|
|
|
|
|
|
/* boundary check on length */
|
2014-11-12 18:52:49 +01:00
|
|
|
if (cp.length != ReplicationSlotOnDiskV2Size)
|
2014-02-01 04:45:17 +01:00
|
|
|
ereport(PANIC,
|
2018-09-04 20:06:04 +02:00
|
|
|
(errcode(ERRCODE_DATA_CORRUPTED),
|
2014-02-01 04:45:17 +01:00
|
|
|
errmsg("replication slot file \"%s\" has corrupted length %u",
|
|
|
|
path, cp.length)));
|
|
|
|
|
|
|
|
/* Now that we know the size, read the entire file */
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
pgstat_report_wait_start(WAIT_EVENT_REPLICATION_SLOT_READ);
|
2014-02-01 04:45:17 +01:00
|
|
|
readBytes = read(fd,
|
|
|
|
(char *) &cp + ReplicationSlotOnDiskConstantSize,
|
|
|
|
cp.length);
|
Create and use wait events for read, write, and fsync operations.
Previous commits, notably 53be0b1add7064ca5db3cd884302dfc3268d884e and
6f3bd98ebfc008cbd676da777bb0b2376c4c4bfa, made it possible to see from
pg_stat_activity when a backend was stuck waiting for another backend,
but it's also fairly common for a backend to be stuck waiting for an
I/O. Add wait events for those operations, too.
Rushabh Lathia, with further hacking by me. Reviewed and tested by
Michael Paquier, Amit Kapila, Rajkumar Raghuwanshi, and Rahila Syed.
Discussion: http://postgr.es/m/CAGPqQf0LsYHXREPAZqYGVkDqHSyjf=KsD=k0GTVPAuzyThh-VQ@mail.gmail.com
2017-03-18 12:43:01 +01:00
|
|
|
pgstat_report_wait_end();
|
2014-02-01 04:45:17 +01:00
|
|
|
if (readBytes != cp.length)
|
|
|
|
{
|
Rework error messages around file handling
Some error messages related to file handling are using the code path
context to define their state. For example, 2PC-related errors are
referring to "two-phase status files", or "relation mapping file" is
used for catalog-to-filenode mapping, however those prove to be
difficult to translate, and are not more helpful than just referring to
the path of the file being worked on. So simplify all those error
messages by just referring to files with their path used. In some
cases, like the manipulation of WAL segments, the context is actually
helpful so those are kept.
Calls to the system function read() have also been rather inconsistent
with their error handling sometimes not reporting the number of bytes
read, and some other code paths trying to use an errno which has not
been set. The in-core functions are using a more consistent pattern
with this patch, which checks for both errno if set or if an
inconsistent read is happening.
So as to care about pluralization when reading an unexpected number of
byte(s), "could not read: read %d of %zu" is used as error message, with
%d field being the output result of read() and %zu the expected size.
This simplifies the work of translators with less variations of the same
message.
Author: Michael Paquier
Reviewed-by: Álvaro Herrera
Discussion: https://postgr.es/m/20180520000522.GB1603@paquier.xyz
2018-07-18 01:01:23 +02:00
|
|
|
if (readBytes < 0)
|
|
|
|
ereport(PANIC,
|
|
|
|
(errcode_for_file_access(),
|
|
|
|
errmsg("could not read file \"%s\": %m", path)));
|
|
|
|
else
|
|
|
|
ereport(PANIC,
|
2018-07-23 02:37:36 +02:00
|
|
|
(errcode(ERRCODE_DATA_CORRUPTED),
|
|
|
|
errmsg("could not read file \"%s\": read %d of %zu",
|
Rework error messages around file handling
Some error messages related to file handling are using the code path
context to define their state. For example, 2PC-related errors are
referring to "two-phase status files", or "relation mapping file" is
used for catalog-to-filenode mapping, however those prove to be
difficult to translate, and are not more helpful than just referring to
the path of the file being worked on. So simplify all those error
messages by just referring to files with their path used. In some
cases, like the manipulation of WAL segments, the context is actually
helpful so those are kept.
Calls to the system function read() have also been rather inconsistent
with their error handling sometimes not reporting the number of bytes
read, and some other code paths trying to use an errno which has not
been set. The in-core functions are using a more consistent pattern
with this patch, which checks for both errno if set or if an
inconsistent read is happening.
So as to care about pluralization when reading an unexpected number of
byte(s), "could not read: read %d of %zu" is used as error message, with
%d field being the output result of read() and %zu the expected size.
This simplifies the work of translators with less variations of the same
message.
Author: Michael Paquier
Reviewed-by: Álvaro Herrera
Discussion: https://postgr.es/m/20180520000522.GB1603@paquier.xyz
2018-07-18 01:01:23 +02:00
|
|
|
path, readBytes, (Size) cp.length)));
|
2014-02-01 04:45:17 +01:00
|
|
|
}
|
|
|
|
|
2019-07-06 23:18:46 +02:00
|
|
|
if (CloseTransientFile(fd) != 0)
|
Tighten use of OpenTransientFile and CloseTransientFile
This fixes two sets of issues related to the use of transient files in
the backend:
1) OpenTransientFile() has been used in some code paths with read-write
flags while read-only is sufficient, so switch those calls to be
read-only where necessary. These have been reported by Joe Conway.
2) When opening transient files, it is up to the caller to close the
file descriptors opened. In error code paths, CloseTransientFile() gets
called to clean up things before issuing an error. However in normal
exit paths, a lot of callers of CloseTransientFile() never actually
reported errors, which could leave a file descriptor open without
knowing about it. This is an issue I complained about a couple of
times, but never had the courage to write and submit a patch, so here we
go.
Note that one frontend code path is impacted by this commit so as an
error is issued when fetching control file data, making backend and
frontend to be treated consistently.
Reported-by: Joe Conway, Michael Paquier
Author: Michael Paquier
Reviewed-by: Álvaro Herrera, Georgios Kokolatos, Joe Conway
Discussion: https://postgr.es/m/20190301023338.GD1348@paquier.xyz
Discussion: https://postgr.es/m/c49b69ec-e2f7-ff33-4f17-0eaa4f2cef27@joeconway.com
2019-03-09 00:50:55 +01:00
|
|
|
ereport(PANIC,
|
|
|
|
(errcode_for_file_access(),
|
|
|
|
errmsg("could not close file \"%s\": %m", path)));
|
2014-02-01 04:45:17 +01:00
|
|
|
|
Switch to CRC-32C in WAL and other places.
The old algorithm was found to not be the usual CRC-32 algorithm, used by
Ethernet et al. We were using a non-reflected lookup table with code meant
for a reflected lookup table. That's a strange combination that AFAICS does
not correspond to any bit-wise CRC calculation, which makes it difficult to
reason about its properties. Although it has worked well in practice, seems
safer to use a well-known algorithm.
Since we're changing the algorithm anyway, we might as well choose a
different polynomial. The Castagnoli polynomial has better error-correcting
properties than the traditional CRC-32 polynomial, even if we had
implemented it correctly. Another reason for picking that is that some new
CPUs have hardware support for calculating CRC-32C, but not CRC-32, let
alone our strange variant of it. This patch doesn't add any support for such
hardware, but a future patch could now do that.
The old algorithm is kept around for tsquery and pg_trgm, which use the
values in indexes that need to remain compatible so that pg_upgrade works.
While we're at it, share the old lookup table for CRC-32 calculation
between hstore, ltree and core. They all use the same table, so might as
well.
2014-11-04 10:35:15 +01:00
|
|
|
/* now verify the CRC */
|
|
|
|
INIT_CRC32C(checksum);
|
|
|
|
COMP_CRC32C(checksum,
|
2021-11-24 03:36:55 +01:00
|
|
|
(char *) &cp + ReplicationSlotOnDiskNotChecksummedSize,
|
|
|
|
ReplicationSlotOnDiskChecksummedSize);
|
2014-11-12 18:52:49 +01:00
|
|
|
FIN_CRC32C(checksum);
|
2014-02-01 04:45:17 +01:00
|
|
|
|
Switch to CRC-32C in WAL and other places.
The old algorithm was found to not be the usual CRC-32 algorithm, used by
Ethernet et al. We were using a non-reflected lookup table with code meant
for a reflected lookup table. That's a strange combination that AFAICS does
not correspond to any bit-wise CRC calculation, which makes it difficult to
reason about its properties. Although it has worked well in practice, seems
safer to use a well-known algorithm.
Since we're changing the algorithm anyway, we might as well choose a
different polynomial. The Castagnoli polynomial has better error-correcting
properties than the traditional CRC-32 polynomial, even if we had
implemented it correctly. Another reason for picking that is that some new
CPUs have hardware support for calculating CRC-32C, but not CRC-32, let
alone our strange variant of it. This patch doesn't add any support for such
hardware, but a future patch could now do that.
The old algorithm is kept around for tsquery and pg_trgm, which use the
values in indexes that need to remain compatible so that pg_upgrade works.
While we're at it, share the old lookup table for CRC-32 calculation
between hstore, ltree and core. They all use the same table, so might as
well.
2014-11-04 10:35:15 +01:00
|
|
|
if (!EQ_CRC32C(checksum, cp.checksum))
|
2014-02-01 04:45:17 +01:00
|
|
|
ereport(PANIC,
|
2015-10-29 01:23:53 +01:00
|
|
|
(errmsg("checksum mismatch for replication slot file \"%s\": is %u, should be %u",
|
2014-02-01 04:45:17 +01:00
|
|
|
path, checksum, cp.checksum)));
|
|
|
|
|
2014-07-24 14:32:34 +02:00
|
|
|
/*
|
|
|
|
* If we crashed with an ephemeral slot active, don't restore but delete
|
|
|
|
* it.
|
|
|
|
*/
|
|
|
|
if (cp.slotdata.persistency != RS_PERSISTENT)
|
|
|
|
{
|
2018-09-02 21:40:30 +02:00
|
|
|
if (!rmtree(slotdir, true))
|
2014-07-24 14:32:34 +02:00
|
|
|
{
|
|
|
|
ereport(WARNING,
|
2018-09-04 20:06:04 +02:00
|
|
|
(errmsg("could not remove directory \"%s\"",
|
|
|
|
slotdir)));
|
2014-07-24 14:32:34 +02:00
|
|
|
}
|
|
|
|
fsync_fname("pg_replslot", true);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-10-31 22:47:41 +01:00
|
|
|
/*
|
|
|
|
* Verify that requirements for the specific slot type are met. That's
|
|
|
|
* important because if these aren't met we're not guaranteed to retain
|
|
|
|
* all the necessary resources for the slot.
|
|
|
|
*
|
|
|
|
* NB: We have to do so *after* the above checks for ephemeral slots,
|
|
|
|
* because otherwise a slot that shouldn't exist anymore could prevent
|
|
|
|
* restarts.
|
|
|
|
*
|
|
|
|
* NB: Changing the requirements here also requires adapting
|
|
|
|
* CheckSlotRequirements() and CheckLogicalDecodingRequirements().
|
|
|
|
*/
|
|
|
|
if (cp.slotdata.database != InvalidOid && wal_level < WAL_LEVEL_LOGICAL)
|
|
|
|
ereport(FATAL,
|
|
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
2018-11-01 18:44:29 +01:00
|
|
|
errmsg("logical replication slot \"%s\" exists, but wal_level < logical",
|
2018-10-31 22:47:41 +01:00
|
|
|
NameStr(cp.slotdata.name)),
|
2018-11-05 21:02:25 +01:00
|
|
|
errhint("Change wal_level to be logical or higher.")));
|
2018-10-31 22:47:41 +01:00
|
|
|
else if (wal_level < WAL_LEVEL_REPLICA)
|
|
|
|
ereport(FATAL,
|
|
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
2018-11-01 18:44:29 +01:00
|
|
|
errmsg("physical replication slot \"%s\" exists, but wal_level < replica",
|
2018-10-31 22:47:41 +01:00
|
|
|
NameStr(cp.slotdata.name)),
|
|
|
|
errhint("Change wal_level to be replica or higher.")));
|
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
/* nothing can be active yet, don't lock anything */
|
|
|
|
for (i = 0; i < max_replication_slots; i++)
|
|
|
|
{
|
|
|
|
ReplicationSlot *slot;
|
|
|
|
|
|
|
|
slot = &ReplicationSlotCtl->replication_slots[i];
|
|
|
|
|
|
|
|
if (slot->in_use)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* restore the entire set of persistent data */
|
|
|
|
memcpy(&slot->data, &cp.slotdata,
|
|
|
|
sizeof(ReplicationSlotPersistentData));
|
|
|
|
|
|
|
|
/* initialize in memory state */
|
|
|
|
slot->effective_xmin = cp.slotdata.xmin;
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
slot->effective_catalog_xmin = cp.slotdata.catalog_xmin;
|
|
|
|
|
|
|
|
slot->candidate_catalog_xmin = InvalidTransactionId;
|
|
|
|
slot->candidate_xmin_lsn = InvalidXLogRecPtr;
|
|
|
|
slot->candidate_restart_lsn = InvalidXLogRecPtr;
|
|
|
|
slot->candidate_restart_valid = InvalidXLogRecPtr;
|
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
slot->in_use = true;
|
2015-04-21 11:51:06 +02:00
|
|
|
slot->active_pid = 0;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
restored = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!restored)
|
2018-11-01 23:59:24 +01:00
|
|
|
ereport(FATAL,
|
2014-02-01 04:45:17 +01:00
|
|
|
(errmsg("too many replication slots active before shutdown"),
|
|
|
|
errhint("Increase max_replication_slots and try again.")));
|
|
|
|
}
|