PostgreSQL Source Code  git master
walsender.h File Reference
#include <signal.h>
Include dependency graph for walsender.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define WalSndWakeupRequest()   do { wake_wal_senders = true; } while (0)
 
#define WalSndWakeupProcessRequests()
 

Enumerations

enum  CRSSnapshotAction { CRS_EXPORT_SNAPSHOT, CRS_NOEXPORT_SNAPSHOT, CRS_USE_SNAPSHOT }
 

Functions

void InitWalSender (void)
 
bool exec_replication_command (const char *query_string)
 
void WalSndErrorCleanup (void)
 
void WalSndSignals (void)
 
Size WalSndShmemSize (void)
 
void WalSndShmemInit (void)
 
void WalSndWakeup (void)
 
void WalSndInitStopping (void)
 
void WalSndWaitStopping (void)
 
void HandleWalSndInitStopping (void)
 
void WalSndRqstFileReload (void)
 

Variables

bool am_walsender
 
bool am_cascading_walsender
 
bool am_db_walsender
 
bool wake_wal_senders
 
int max_wal_senders
 
int wal_sender_timeout
 
bool log_replication_commands
 

Macro Definition Documentation

◆ WalSndWakeupProcessRequests

#define WalSndWakeupProcessRequests ( )
Value:
do \
{ \
{ \
wake_wal_senders = false; \
if (max_wal_senders > 0) \
WalSndWakeup(); \
} \
} while (0)
int max_wal_senders
Definition: walsender.c:121
bool wake_wal_senders
Definition: walsender.c:130

Definition at line 62 of file walsender.h.

Referenced by XLogBackgroundFlush(), and XLogFlush().

◆ WalSndWakeupRequest

#define WalSndWakeupRequest ( )    do { wake_wal_senders = true; } while (0)

Definition at line 56 of file walsender.h.

Referenced by XLogWrite().

Enumeration Type Documentation

◆ CRSSnapshotAction

Enumerator
CRS_EXPORT_SNAPSHOT 
CRS_NOEXPORT_SNAPSHOT 
CRS_USE_SNAPSHOT 

Definition at line 20 of file walsender.h.

Function Documentation

◆ exec_replication_command()

bool exec_replication_command ( const char *  query_string)

Definition at line 1461 of file walsender.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CHECK_FOR_INTERRUPTS, CommitTransactionCommand(), CreateDestReceiver(), CreateReplicationSlot(), CurrentMemoryContext, DEBUG1, generate_unaccent_rules::dest, DestRemote, DestRemoteSimple, DropReplicationSlot(), elog, EndCommand(), ereport, errcode(), errmsg(), errmsg_internal(), ERROR, GetPGVariable(), got_STOPPING, IdentifySystem(), initStringInfo(), InvalidOid, IsA, IsAbortedTransactionBlockState(), IsTransactionBlock(), StartReplicationCmd::kind, LOG, log_replication_commands, MemoryContextDelete(), MemoryContextSwitchTo(), MyDatabaseId, VariableShowStmt::name, pgstat_report_activity(), PreventInTransactionBlock(), REPLICATION_KIND_PHYSICAL, replication_parse_result, replication_scanner_init(), replication_yyparse(), SendBaseBackup(), SendTimeLineHistory(), SnapBuildClearExportedSnapshot(), StartLogicalReplication(), StartReplication(), StartTransactionCommand(), WalSnd::state, STATE_IDLE, STATE_RUNNING, T_BaseBackupCmd, T_CreateReplicationSlotCmd, T_DropReplicationSlotCmd, T_IdentifySystemCmd, T_SQLCmd, T_StartReplicationCmd, T_TimeLineHistoryCmd, T_VariableShowStmt, TimeLineHistoryCmd::type, Node::type, WalSndSetState(), and WALSNDSTATE_STOPPING.

Referenced by PostgresMain().

1462 {
1463  int parse_rc;
1464  Node *cmd_node;
1465  MemoryContext cmd_context;
1466  MemoryContext old_context;
1467 
1468  /*
1469  * If WAL sender has been told that shutdown is getting close, switch its
1470  * status accordingly to handle the next replication commands correctly.
1471  */
1472  if (got_STOPPING)
1474 
1475  /*
1476  * Throw error if in stopping mode. We need prevent commands that could
1477  * generate WAL while the shutdown checkpoint is being written. To be
1478  * safe, we just prohibit all new commands.
1479  */
1481  ereport(ERROR,
1482  (errmsg("cannot execute new commands while WAL sender is in stopping mode")));
1483 
1484  /*
1485  * CREATE_REPLICATION_SLOT ... LOGICAL exports a snapshot until the next
1486  * command arrives. Clean up the old stuff if there's anything.
1487  */
1489 
1491 
1493  "Replication command context",
1495  old_context = MemoryContextSwitchTo(cmd_context);
1496 
1497  replication_scanner_init(cmd_string);
1498  parse_rc = replication_yyparse();
1499  if (parse_rc != 0)
1500  ereport(ERROR,
1501  (errcode(ERRCODE_SYNTAX_ERROR),
1502  errmsg_internal("replication command parser returned %d",
1503  parse_rc)));
1504 
1505  cmd_node = replication_parse_result;
1506 
1507  /*
1508  * Log replication command if log_replication_commands is enabled. Even
1509  * when it's disabled, log the command with DEBUG1 level for backward
1510  * compatibility. Note that SQL commands are not logged here, and will be
1511  * logged later if log_statement is enabled.
1512  */
1513  if (cmd_node->type != T_SQLCmd)
1515  (errmsg("received replication command: %s", cmd_string)));
1516 
1517  /*
1518  * CREATE_REPLICATION_SLOT ... LOGICAL exports a snapshot. If it was
1519  * called outside of transaction the snapshot should be cleared here.
1520  */
1521  if (!IsTransactionBlock())
1523 
1524  /*
1525  * For aborted transactions, don't allow anything except pure SQL, the
1526  * exec_simple_query() will handle it correctly.
1527  */
1528  if (IsAbortedTransactionBlockState() && !IsA(cmd_node, SQLCmd))
1529  ereport(ERROR,
1530  (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
1531  errmsg("current transaction is aborted, "
1532  "commands ignored until end of transaction block")));
1533 
1535 
1536  /*
1537  * Allocate buffers that will be used for each outgoing and incoming
1538  * message. We do this just once per command to reduce palloc overhead.
1539  */
1543 
1544  /* Report to pgstat that this process is running */
1546 
1547  switch (cmd_node->type)
1548  {
1549  case T_IdentifySystemCmd:
1550  IdentifySystem();
1551  break;
1552 
1553  case T_BaseBackupCmd:
1554  PreventInTransactionBlock(true, "BASE_BACKUP");
1555  SendBaseBackup((BaseBackupCmd *) cmd_node);
1556  break;
1557 
1560  break;
1561 
1564  break;
1565 
1566  case T_StartReplicationCmd:
1567  {
1568  StartReplicationCmd *cmd = (StartReplicationCmd *) cmd_node;
1569 
1570  PreventInTransactionBlock(true, "START_REPLICATION");
1571 
1572  if (cmd->kind == REPLICATION_KIND_PHYSICAL)
1573  StartReplication(cmd);
1574  else
1576  break;
1577  }
1578 
1579  case T_TimeLineHistoryCmd:
1580  PreventInTransactionBlock(true, "TIMELINE_HISTORY");
1582  break;
1583 
1584  case T_VariableShowStmt:
1585  {
1587  VariableShowStmt *n = (VariableShowStmt *) cmd_node;
1588 
1589  /* syscache access needs a transaction environment */
1591  GetPGVariable(n->name, dest);
1593  }
1594  break;
1595 
1596  case T_SQLCmd:
1597  if (MyDatabaseId == InvalidOid)
1598  ereport(ERROR,
1599  (errmsg("cannot execute SQL commands in WAL sender for physical replication")));
1600 
1601  /* Report to pgstat that this process is now idle */
1603 
1604  /* Tell the caller that this wasn't a WalSender command. */
1605  return false;
1606 
1607  default:
1608  elog(ERROR, "unrecognized replication command node tag: %u",
1609  cmd_node->type);
1610  }
1611 
1612  /* done */
1613  MemoryContextSwitchTo(old_context);
1614  MemoryContextDelete(cmd_context);
1615 
1616  /* Send CommandComplete message */
1617  EndCommand("SELECT", DestRemote);
1618 
1619  /* Report to pgstat that this process is now idle */
1621 
1622  return true;
1623 }
#define IsA(nodeptr, _type_)
Definition: nodes.h:576
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:211
#define AllocSetContextCreate
Definition: memutils.h:170
#define DEBUG1
Definition: elog.h:25
void pgstat_report_activity(BackendState state, const char *cmd_str)
Definition: pgstat.c:3117
static void SendTimeLineHistory(TimeLineHistoryCmd *cmd)
Definition: walsender.c:435
static void DropReplicationSlot(DropReplicationSlotCmd *cmd)
Definition: walsender.c:1075
void CommitTransactionCommand(void)
Definition: xact.c:2898
bool IsAbortedTransactionBlockState(void)
Definition: xact.c:375
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
Definition: nodes.h:525
static StringInfoData output_message
Definition: walsender.c:153
static volatile sig_atomic_t got_STOPPING
Definition: walsender.c:183
int errcode(int sqlerrcode)
Definition: elog.c:608
#define LOG
Definition: elog.h:26
void GetPGVariable(const char *name, DestReceiver *dest)
Definition: guc.c:8849
Node * replication_parse_result
bool IsTransactionBlock(void)
Definition: xact.c:4635
ReplicationKind kind
Definition: replnodes.h:82
void EndCommand(const char *commandTag, CommandDest dest)
Definition: dest.c:166
#define ERROR
Definition: elog.h:43
void SendBaseBackup(BaseBackupCmd *cmd)
Definition: basebackup.c:761
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:192
WalSndState state
NodeTag type
Definition: nodes.h:527
DestReceiver * CreateDestReceiver(CommandDest dest)
Definition: dest.c:113
static void StartReplication(StartReplicationCmd *cmd)
Definition: walsender.c:541
void PreventInTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3331
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
#define ereport(elevel, rest)
Definition: elog.h:141
int replication_yyparse(void)
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
static StringInfoData reply_message
Definition: walsender.c:154
static void StartLogicalReplication(StartReplicationCmd *cmd)
Definition: walsender.c:1086
Oid MyDatabaseId
Definition: globals.c:85
WalSnd * MyWalSnd
Definition: walsender.c:112
#define InvalidOid
Definition: postgres_ext.h:36
int errmsg_internal(const char *fmt,...)
Definition: elog.c:909
void WalSndSetState(WalSndState state)
Definition: walsender.c:3135
void StartTransactionCommand(void)
Definition: xact.c:2797
static void CreateReplicationSlot(CreateReplicationSlotCmd *cmd)
Definition: walsender.c:875
static StringInfoData tmpbuf
Definition: walsender.c:155
bool log_replication_commands
Definition: walsender.c:125
int errmsg(const char *fmt,...)
Definition: elog.c:822
#define elog(elevel,...)
Definition: elog.h:228
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99
static void IdentifySystem(void)
Definition: walsender.c:346
void SnapBuildClearExportedSnapshot(void)
Definition: snapbuild.c:692
void replication_scanner_init(const char *query_string)

◆ HandleWalSndInitStopping()

void HandleWalSndInitStopping ( void  )

Definition at line 2945 of file walsender.c.

References am_walsender, Assert, got_STOPPING, kill, MyProcPid, and replication_active.

Referenced by procsignal_sigusr1_handler().

2946 {
2948 
2949  /*
2950  * If replication has not yet started, die like with SIGTERM. If
2951  * replication is active, only set a flag and wake up the main loop. It
2952  * will send any outstanding WAL, wait for it to be replicated to the
2953  * standby, and then exit gracefully.
2954  */
2955  if (!replication_active)
2956  kill(MyProcPid, SIGTERM);
2957  else
2958  got_STOPPING = true;
2959 }
int MyProcPid
Definition: globals.c:40
static volatile sig_atomic_t got_STOPPING
Definition: walsender.c:183
#define kill(pid, sig)
Definition: win32_port.h:426
bool am_walsender
Definition: walsender.c:115
static volatile sig_atomic_t replication_active
Definition: walsender.c:191
#define Assert(condition)
Definition: c.h:738

◆ InitWalSender()

void InitWalSender ( void  )

Referenced by PostgresMain().

◆ WalSndErrorCleanup()

void WalSndErrorCleanup ( void  )

Definition at line 299 of file walsender.c.

References close, ConditionVariableCancelSleep(), DestNone, DestRemote, got_SIGUSR2, got_STOPPING, LWLockReleaseAll(), MyReplicationSlot, pgstat_report_wait_end(), proc_exit(), replication_active, ReplicationSlotCleanup(), ReplicationSlotRelease(), WalSndSetState(), WalSndShutdown(), WALSNDSTATE_STARTUP, whereToSendOutput, and WALOpenSegment::ws_file.

Referenced by PostgresMain().

300 {
304 
305  if (sendSeg->ws_file >= 0)
306  {
308  sendSeg->ws_file = -1;
309  }
310 
311  if (MyReplicationSlot != NULL)
313 
315 
316  replication_active = false;
317 
318  if (got_STOPPING || got_SIGUSR2)
319  proc_exit(0);
320 
321  /* Revert back to startup state */
323 }
static volatile sig_atomic_t got_STOPPING
Definition: walsender.c:183
void proc_exit(int code)
Definition: ipc.c:104
void ConditionVariableCancelSleep(void)
void ReplicationSlotRelease(void)
Definition: slot.c:424
static WALOpenSegment * sendSeg
Definition: walsender.c:132
static void pgstat_report_wait_end(void)
Definition: pgstat.h:1344
static volatile sig_atomic_t got_SIGUSR2
Definition: walsender.c:182
static volatile sig_atomic_t replication_active
Definition: walsender.c:191
ReplicationSlot * MyReplicationSlot
Definition: slot.c:96
void WalSndSetState(WalSndState state)
Definition: walsender.c:3135
void ReplicationSlotCleanup(void)
Definition: slot.c:479
void LWLockReleaseAll(void)
Definition: lwlock.c:1826
#define close(a)
Definition: win32.h:12

◆ WalSndInitStopping()

void WalSndInitStopping ( void  )

Definition at line 3071 of file walsender.c.

References i, InvalidBackendId, max_wal_senders, WalSnd::mutex, WalSnd::pid, PROCSIG_WALSND_INIT_STOPPING, SendProcSignal(), SpinLockAcquire, SpinLockRelease, and WalSndCtlData::walsnds.

Referenced by ShutdownXLOG().

3072 {
3073  int i;
3074 
3075  for (i = 0; i < max_wal_senders; i++)
3076  {
3077  WalSnd *walsnd = &WalSndCtl->walsnds[i];
3078  pid_t pid;
3079 
3080  SpinLockAcquire(&walsnd->mutex);
3081  pid = walsnd->pid;
3082  SpinLockRelease(&walsnd->mutex);
3083 
3084  if (pid == 0)
3085  continue;
3086 
3088  }
3089 }
WalSndCtlData * WalSndCtl
Definition: walsender.c:109
WalSnd walsnds[FLEXIBLE_ARRAY_MEMBER]
slock_t mutex
#define SpinLockAcquire(lock)
Definition: spin.h:62
int SendProcSignal(pid_t pid, ProcSignalReason reason, BackendId backendId)
Definition: procsignal.c:250
int max_wal_senders
Definition: walsender.c:121
#define SpinLockRelease(lock)
Definition: spin.h:64
#define InvalidBackendId
Definition: backendid.h:23
int i

◆ WalSndRqstFileReload()

void WalSndRqstFileReload ( void  )

Definition at line 2922 of file walsender.c.

References i, max_wal_senders, WalSnd::mutex, WalSnd::needreload, WalSnd::pid, SpinLockAcquire, SpinLockRelease, and WalSndCtlData::walsnds.

Referenced by KeepFileRestoredFromArchive().

2923 {
2924  int i;
2925 
2926  for (i = 0; i < max_wal_senders; i++)
2927  {
2928  WalSnd *walsnd = &WalSndCtl->walsnds[i];
2929 
2930  SpinLockAcquire(&walsnd->mutex);
2931  if (walsnd->pid == 0)
2932  {
2933  SpinLockRelease(&walsnd->mutex);
2934  continue;
2935  }
2936  walsnd->needreload = true;
2937  SpinLockRelease(&walsnd->mutex);
2938  }
2939 }
WalSndCtlData * WalSndCtl
Definition: walsender.c:109
WalSnd walsnds[FLEXIBLE_ARRAY_MEMBER]
slock_t mutex
#define SpinLockAcquire(lock)
Definition: spin.h:62
int max_wal_senders
Definition: walsender.c:121
#define SpinLockRelease(lock)
Definition: spin.h:64
bool needreload
int i

◆ WalSndShmemInit()

void WalSndShmemInit ( void  )

Definition at line 3010 of file walsender.c.

References i, max_wal_senders, MemSet, WalSnd::mutex, NUM_SYNC_REP_WAIT_MODE, ShmemInitStruct(), SHMQueueInit(), SpinLockInit, WalSndCtlData::SyncRepQueue, WalSndCtlData::walsnds, and WalSndShmemSize().

Referenced by CreateSharedMemoryAndSemaphores().

3011 {
3012  bool found;
3013  int i;
3014 
3015  WalSndCtl = (WalSndCtlData *)
3016  ShmemInitStruct("Wal Sender Ctl", WalSndShmemSize(), &found);
3017 
3018  if (!found)
3019  {
3020  /* First time through, so initialize */
3022 
3023  for (i = 0; i < NUM_SYNC_REP_WAIT_MODE; i++)
3025 
3026  for (i = 0; i < max_wal_senders; i++)
3027  {
3028  WalSnd *walsnd = &WalSndCtl->walsnds[i];
3029 
3030  SpinLockInit(&walsnd->mutex);
3031  }
3032  }
3033 }
Size WalSndShmemSize(void)
Definition: walsender.c:2998
#define SpinLockInit(lock)
Definition: spin.h:60
WalSndCtlData * WalSndCtl
Definition: walsender.c:109
#define MemSet(start, val, len)
Definition: c.h:971
WalSnd walsnds[FLEXIBLE_ARRAY_MEMBER]
slock_t mutex
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:392
SHM_QUEUE SyncRepQueue[NUM_SYNC_REP_WAIT_MODE]
int max_wal_senders
Definition: walsender.c:121
void SHMQueueInit(SHM_QUEUE *queue)
Definition: shmqueue.c:36
int i
#define NUM_SYNC_REP_WAIT_MODE
Definition: syncrep.h:28

◆ WalSndShmemSize()

Size WalSndShmemSize ( void  )

Definition at line 2998 of file walsender.c.

References add_size(), max_wal_senders, mul_size(), and offsetof.

Referenced by CreateSharedMemoryAndSemaphores(), and WalSndShmemInit().

2999 {
3000  Size size = 0;
3001 
3002  size = offsetof(WalSndCtlData, walsnds);
3003  size = add_size(size, mul_size(max_wal_senders, sizeof(WalSnd)));
3004 
3005  return size;
3006 }
int max_wal_senders
Definition: walsender.c:121
Size mul_size(Size s1, Size s2)
Definition: shmem.c:515
Size add_size(Size s1, Size s2)
Definition: shmem.c:498
size_t Size
Definition: c.h:466
#define offsetof(type, field)
Definition: c.h:661

◆ WalSndSignals()

void WalSndSignals ( void  )

Definition at line 2979 of file walsender.c.

References die, InitializeTimeouts(), pqsignal(), procsignal_sigusr1_handler(), quickdie(), SIG_DFL, SIG_IGN, SIGCHLD, SIGHUP, SignalHandlerForConfigReload(), SIGPIPE, SIGQUIT, SIGUSR1, SIGUSR2, StatementCancelHandler(), and WalSndLastCycleHandler().

Referenced by PostgresMain().

2980 {
2981  /* Set up signal handlers */
2983  pqsignal(SIGINT, StatementCancelHandler); /* query cancel */
2984  pqsignal(SIGTERM, die); /* request shutdown */
2985  pqsignal(SIGQUIT, quickdie); /* hard crash time */
2986  InitializeTimeouts(); /* establishes SIGALRM handler */
2989  pqsignal(SIGUSR2, WalSndLastCycleHandler); /* request a last cycle and
2990  * shutdown */
2991 
2992  /* Reset some signals that are accepted by postmaster but not here */
2994 }
void InitializeTimeouts(void)
Definition: timeout.c:346
#define SIGQUIT
Definition: win32_port.h:154
#define SIGUSR1
Definition: win32_port.h:165
static void WalSndLastCycleHandler(SIGNAL_ARGS)
Definition: walsender.c:2967
#define SIGCHLD
Definition: win32_port.h:163
void SignalHandlerForConfigReload(SIGNAL_ARGS)
Definition: interrupt.c:56
#define SIGPIPE
Definition: win32_port.h:158
#define SIGUSR2
Definition: win32_port.h:166
void StatementCancelHandler(SIGNAL_ARGS)
Definition: postgres.c:2842
#define SIGHUP
Definition: win32_port.h:153
#define SIG_IGN
Definition: win32_port.h:150
pqsigfunc pqsignal(int signum, pqsigfunc handler)
Definition: signal.c:170
#define SIG_DFL
Definition: win32_port.h:148
void procsignal_sigusr1_handler(SIGNAL_ARGS)
Definition: procsignal.c:533
void quickdie(SIGNAL_ARGS)
Definition: postgres.c:2744
#define die(msg)
Definition: pg_test_fsync.c:96

◆ WalSndWaitStopping()

void WalSndWaitStopping ( void  )

Definition at line 3097 of file walsender.c.

References i, max_wal_senders, WalSnd::mutex, pg_usleep(), WalSnd::pid, SpinLockAcquire, SpinLockRelease, WalSnd::state, WalSndCtlData::walsnds, and WALSNDSTATE_STOPPING.

Referenced by ShutdownXLOG().

3098 {
3099  for (;;)
3100  {
3101  int i;
3102  bool all_stopped = true;
3103 
3104  for (i = 0; i < max_wal_senders; i++)
3105  {
3106  WalSnd *walsnd = &WalSndCtl->walsnds[i];
3107 
3108  SpinLockAcquire(&walsnd->mutex);
3109 
3110  if (walsnd->pid == 0)
3111  {
3112  SpinLockRelease(&walsnd->mutex);
3113  continue;
3114  }
3115 
3116  if (walsnd->state != WALSNDSTATE_STOPPING)
3117  {
3118  all_stopped = false;
3119  SpinLockRelease(&walsnd->mutex);
3120  break;
3121  }
3122  SpinLockRelease(&walsnd->mutex);
3123  }
3124 
3125  /* safe to leave if confirmation is done for all WAL senders */
3126  if (all_stopped)
3127  return;
3128 
3129  pg_usleep(10000L); /* wait for 10 msec */
3130  }
3131 }
WalSndCtlData * WalSndCtl
Definition: walsender.c:109
WalSnd walsnds[FLEXIBLE_ARRAY_MEMBER]
slock_t mutex
#define SpinLockAcquire(lock)
Definition: spin.h:62
void pg_usleep(long microsec)
Definition: signal.c:53
WalSndState state
int max_wal_senders
Definition: walsender.c:121
#define SpinLockRelease(lock)
Definition: spin.h:64
int i

◆ WalSndWakeup()

void WalSndWakeup ( void  )

Definition at line 3042 of file walsender.c.

References i, WalSnd::latch, max_wal_senders, WalSnd::mutex, SetLatch(), SpinLockAcquire, SpinLockRelease, and WalSndCtlData::walsnds.

Referenced by KeepFileRestoredFromArchive(), StartupXLOG(), and XLogWalRcvFlush().

3043 {
3044  int i;
3045 
3046  for (i = 0; i < max_wal_senders; i++)
3047  {
3048  Latch *latch;
3049  WalSnd *walsnd = &WalSndCtl->walsnds[i];
3050 
3051  /*
3052  * Get latch pointer with spinlock held, for the unlikely case that
3053  * pointer reads aren't atomic (as they're 8 bytes).
3054  */
3055  SpinLockAcquire(&walsnd->mutex);
3056  latch = walsnd->latch;
3057  SpinLockRelease(&walsnd->mutex);
3058 
3059  if (latch != NULL)
3060  SetLatch(latch);
3061  }
3062 }
WalSndCtlData * WalSndCtl
Definition: walsender.c:109
WalSnd walsnds[FLEXIBLE_ARRAY_MEMBER]
void SetLatch(Latch *latch)
Definition: latch.c:457
slock_t mutex
#define SpinLockAcquire(lock)
Definition: spin.h:62
Latch * latch
Definition: latch.h:110
int max_wal_senders
Definition: walsender.c:121
#define SpinLockRelease(lock)
Definition: spin.h:64
int i

Variable Documentation

◆ am_cascading_walsender

◆ am_db_walsender

bool am_db_walsender

Definition at line 118 of file walsender.c.

Referenced by check_db(), InitPostgres(), and ProcessStartupPacket().

◆ am_walsender

◆ log_replication_commands

bool log_replication_commands

Definition at line 125 of file walsender.c.

Referenced by exec_replication_command().

◆ max_wal_senders

◆ wake_wal_senders

bool wake_wal_senders

Definition at line 130 of file walsender.c.

◆ wal_sender_timeout

int wal_sender_timeout