Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * xlogfuncs.c
4 : : *
5 : : * PostgreSQL write-ahead log manager user interface functions
6 : : *
7 : : * This file contains WAL control and information functions.
8 : : *
9 : : *
10 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
11 : : * Portions Copyright (c) 1994, Regents of the University of California
12 : : *
13 : : * src/backend/access/transam/xlogfuncs.c
14 : : *
15 : : *-------------------------------------------------------------------------
16 : : */
17 : : #include "postgres.h"
18 : :
19 : : #include <unistd.h>
20 : :
21 : : #include "access/htup_details.h"
22 : : #include "access/xlog_internal.h"
23 : : #include "access/xlogbackup.h"
24 : : #include "access/xlogrecovery.h"
25 : : #include "catalog/pg_type.h"
26 : : #include "funcapi.h"
27 : : #include "miscadmin.h"
28 : : #include "pgstat.h"
29 : : #include "replication/walreceiver.h"
30 : : #include "storage/fd.h"
31 : : #include "storage/latch.h"
32 : : #include "storage/standby.h"
33 : : #include "utils/builtins.h"
34 : : #include "utils/memutils.h"
35 : : #include "utils/pg_lsn.h"
36 : : #include "utils/timestamp.h"
37 : :
38 : : /*
39 : : * Backup-related variables.
40 : : */
41 : : static BackupState *backup_state = NULL;
42 : : static StringInfo tablespace_map = NULL;
43 : :
44 : : /* Session-level context for the SQL-callable backup functions */
45 : : static MemoryContext backupcontext = NULL;
46 : :
47 : : /*
48 : : * pg_backup_start: set up for taking an on-line backup dump
49 : : *
50 : : * Essentially what this does is to create the contents required for the
51 : : * backup_label file and the tablespace map.
52 : : *
53 : : * Permission checking for this function is managed through the normal
54 : : * GRANT system.
55 : : */
56 : : Datum
57 : 0 : pg_backup_start(PG_FUNCTION_ARGS)
58 : : {
59 : 0 : text *backupid = PG_GETARG_TEXT_PP(0);
60 : 0 : bool fast = PG_GETARG_BOOL(1);
61 : 0 : char *backupidstr;
62 : 0 : SessionBackupState status = get_backup_status();
63 : 0 : MemoryContext oldcontext;
64 : :
65 : 0 : backupidstr = text_to_cstring(backupid);
66 : :
67 [ # # ]: 0 : if (status == SESSION_BACKUP_RUNNING)
68 [ # # # # ]: 0 : ereport(ERROR,
69 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
70 : : errmsg("a backup is already in progress in this session")));
71 : :
72 : : /*
73 : : * backup_state and tablespace_map need to be long-lived as they are used
74 : : * in pg_backup_stop(). These are allocated in a dedicated memory context
75 : : * child of TopMemoryContext, deleted at the end of pg_backup_stop(). If
76 : : * an error happens before ending the backup, memory would be leaked in
77 : : * this context until pg_backup_start() is called again.
78 : : */
79 [ # # ]: 0 : if (backupcontext == NULL)
80 : : {
81 : 0 : backupcontext = AllocSetContextCreate(TopMemoryContext,
82 : : "on-line backup context",
83 : : ALLOCSET_START_SMALL_SIZES);
84 : 0 : }
85 : : else
86 : : {
87 : 0 : backup_state = NULL;
88 : 0 : tablespace_map = NULL;
89 : 0 : MemoryContextReset(backupcontext);
90 : : }
91 : :
92 : 0 : oldcontext = MemoryContextSwitchTo(backupcontext);
93 : 0 : backup_state = palloc0_object(BackupState);
94 : 0 : tablespace_map = makeStringInfo();
95 : 0 : MemoryContextSwitchTo(oldcontext);
96 : :
97 : 0 : register_persistent_abort_backup_handler();
98 : 0 : do_pg_backup_start(backupidstr, fast, NULL, backup_state, tablespace_map);
99 : :
100 : 0 : PG_RETURN_LSN(backup_state->startpoint);
101 : 0 : }
102 : :
103 : :
104 : : /*
105 : : * pg_backup_stop: finish taking an on-line backup.
106 : : *
107 : : * The first parameter (variable 'waitforarchive'), which is optional,
108 : : * allows the user to choose if they want to wait for the WAL to be archived
109 : : * or if we should just return as soon as the WAL record is written.
110 : : *
111 : : * This function stops an in-progress backup, creates backup_label contents and
112 : : * it returns the backup stop LSN, backup_label and tablespace_map contents.
113 : : *
114 : : * The backup_label contains the user-supplied label string (typically this
115 : : * would be used to tell where the backup dump will be stored), the starting
116 : : * time, starting WAL location for the dump and so on. It is the caller's
117 : : * responsibility to write the backup_label and tablespace_map files in the
118 : : * data folder that will be restored from this backup.
119 : : *
120 : : * Permission checking for this function is managed through the normal
121 : : * GRANT system.
122 : : */
123 : : Datum
124 : 0 : pg_backup_stop(PG_FUNCTION_ARGS)
125 : : {
126 : : #define PG_BACKUP_STOP_V2_COLS 3
127 : 0 : TupleDesc tupdesc;
128 : 0 : Datum values[PG_BACKUP_STOP_V2_COLS] = {0};
129 : 0 : bool nulls[PG_BACKUP_STOP_V2_COLS] = {0};
130 : 0 : bool waitforarchive = PG_GETARG_BOOL(0);
131 : 0 : char *backup_label;
132 : 0 : SessionBackupState status = get_backup_status();
133 : :
134 : : /* Initialize attributes information in the tuple descriptor */
135 [ # # ]: 0 : if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
136 [ # # # # ]: 0 : elog(ERROR, "return type must be a row type");
137 : :
138 [ # # ]: 0 : if (status != SESSION_BACKUP_RUNNING)
139 [ # # # # ]: 0 : ereport(ERROR,
140 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
141 : : errmsg("backup is not in progress"),
142 : : errhint("Did you call pg_backup_start()?")));
143 : :
144 [ # # ]: 0 : Assert(backup_state != NULL);
145 [ # # ]: 0 : Assert(tablespace_map != NULL);
146 : :
147 : : /* Stop the backup */
148 : 0 : do_pg_backup_stop(backup_state, waitforarchive);
149 : :
150 : : /* Build the contents of backup_label */
151 : 0 : backup_label = build_backup_content(backup_state, false);
152 : :
153 : 0 : values[0] = LSNGetDatum(backup_state->stoppoint);
154 : 0 : values[1] = CStringGetTextDatum(backup_label);
155 : 0 : values[2] = CStringGetTextDatum(tablespace_map->data);
156 : :
157 : : /* Deallocate backup-related variables */
158 : 0 : pfree(backup_label);
159 : :
160 : : /* Clean up the session-level state and its memory context */
161 : 0 : backup_state = NULL;
162 : 0 : tablespace_map = NULL;
163 : 0 : MemoryContextDelete(backupcontext);
164 : 0 : backupcontext = NULL;
165 : :
166 : : /* Returns the record as Datum */
167 : 0 : PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
168 : 0 : }
169 : :
170 : : /*
171 : : * pg_switch_wal: switch to next xlog file
172 : : *
173 : : * Permission checking for this function is managed through the normal
174 : : * GRANT system.
175 : : */
176 : : Datum
177 : 0 : pg_switch_wal(PG_FUNCTION_ARGS)
178 : : {
179 : 0 : XLogRecPtr switchpoint;
180 : :
181 [ # # ]: 0 : if (RecoveryInProgress())
182 [ # # # # ]: 0 : ereport(ERROR,
183 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
184 : : errmsg("recovery is in progress"),
185 : : errhint("WAL control functions cannot be executed during recovery.")));
186 : :
187 : 0 : switchpoint = RequestXLogSwitch(false);
188 : :
189 : : /*
190 : : * As a convenience, return the WAL location of the switch record
191 : : */
192 : 0 : PG_RETURN_LSN(switchpoint);
193 : 0 : }
194 : :
195 : : /*
196 : : * pg_log_standby_snapshot: call LogStandbySnapshot()
197 : : *
198 : : * Permission checking for this function is managed through the normal
199 : : * GRANT system.
200 : : */
201 : : Datum
202 : 0 : pg_log_standby_snapshot(PG_FUNCTION_ARGS)
203 : : {
204 : 0 : XLogRecPtr recptr;
205 : :
206 [ # # ]: 0 : if (RecoveryInProgress())
207 [ # # # # ]: 0 : ereport(ERROR,
208 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
209 : : errmsg("recovery is in progress"),
210 : : errhint("%s cannot be executed during recovery.",
211 : : "pg_log_standby_snapshot()")));
212 : :
213 [ # # ]: 0 : if (!XLogStandbyInfoActive())
214 [ # # # # ]: 0 : ereport(ERROR,
215 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
216 : : errmsg("pg_log_standby_snapshot() can only be used if \"wal_level\" >= \"replica\"")));
217 : :
218 : 0 : recptr = LogStandbySnapshot();
219 : :
220 : : /*
221 : : * As a convenience, return the WAL location of the last inserted record
222 : : */
223 : 0 : PG_RETURN_LSN(recptr);
224 : 0 : }
225 : :
226 : : /*
227 : : * pg_create_restore_point: a named point for restore
228 : : *
229 : : * Permission checking for this function is managed through the normal
230 : : * GRANT system.
231 : : */
232 : : Datum
233 : 0 : pg_create_restore_point(PG_FUNCTION_ARGS)
234 : : {
235 : 0 : text *restore_name = PG_GETARG_TEXT_PP(0);
236 : 0 : char *restore_name_str;
237 : 0 : XLogRecPtr restorepoint;
238 : :
239 [ # # ]: 0 : if (RecoveryInProgress())
240 [ # # # # ]: 0 : ereport(ERROR,
241 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
242 : : errmsg("recovery is in progress"),
243 : : errhint("WAL control functions cannot be executed during recovery.")));
244 : :
245 [ # # ]: 0 : if (!XLogIsNeeded())
246 [ # # # # ]: 0 : ereport(ERROR,
247 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
248 : : errmsg("WAL level not sufficient for creating a restore point"),
249 : : errhint("\"wal_level\" must be set to \"replica\" or \"logical\" at server start.")));
250 : :
251 : 0 : restore_name_str = text_to_cstring(restore_name);
252 : :
253 [ # # ]: 0 : if (strlen(restore_name_str) >= MAXFNAMELEN)
254 [ # # # # ]: 0 : ereport(ERROR,
255 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
256 : : errmsg("value too long for restore point (maximum %d characters)", MAXFNAMELEN - 1)));
257 : :
258 : 0 : restorepoint = XLogRestorePoint(restore_name_str);
259 : :
260 : : /*
261 : : * As a convenience, return the WAL location of the restore point record
262 : : */
263 : 0 : PG_RETURN_LSN(restorepoint);
264 : 0 : }
265 : :
266 : : /*
267 : : * Report the current WAL write location (same format as pg_backup_start etc)
268 : : *
269 : : * This is useful for determining how much of WAL is visible to an external
270 : : * archiving process. Note that the data before this point is written out
271 : : * to the kernel, but is not necessarily synced to disk.
272 : : */
273 : : Datum
274 : 1 : pg_current_wal_lsn(PG_FUNCTION_ARGS)
275 : : {
276 : 1 : XLogRecPtr current_recptr;
277 : :
278 [ + - ]: 1 : if (RecoveryInProgress())
279 [ # # # # ]: 0 : ereport(ERROR,
280 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
281 : : errmsg("recovery is in progress"),
282 : : errhint("WAL control functions cannot be executed during recovery.")));
283 : :
284 : 1 : current_recptr = GetXLogWriteRecPtr();
285 : :
286 : 2 : PG_RETURN_LSN(current_recptr);
287 : 1 : }
288 : :
289 : : /*
290 : : * Report the current WAL insert location (same format as pg_backup_start etc)
291 : : *
292 : : * This function is mostly for debugging purposes.
293 : : */
294 : : Datum
295 : 0 : pg_current_wal_insert_lsn(PG_FUNCTION_ARGS)
296 : : {
297 : 0 : XLogRecPtr current_recptr;
298 : :
299 [ # # ]: 0 : if (RecoveryInProgress())
300 [ # # # # ]: 0 : ereport(ERROR,
301 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
302 : : errmsg("recovery is in progress"),
303 : : errhint("WAL control functions cannot be executed during recovery.")));
304 : :
305 : 0 : current_recptr = GetXLogInsertRecPtr();
306 : :
307 : 0 : PG_RETURN_LSN(current_recptr);
308 : 0 : }
309 : :
310 : : /*
311 : : * Report the current WAL flush location (same format as pg_backup_start etc)
312 : : *
313 : : * This function is mostly for debugging purposes.
314 : : */
315 : : Datum
316 : 0 : pg_current_wal_flush_lsn(PG_FUNCTION_ARGS)
317 : : {
318 : 0 : XLogRecPtr current_recptr;
319 : :
320 [ # # ]: 0 : if (RecoveryInProgress())
321 [ # # # # ]: 0 : ereport(ERROR,
322 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
323 : : errmsg("recovery is in progress"),
324 : : errhint("WAL control functions cannot be executed during recovery.")));
325 : :
326 : 0 : current_recptr = GetFlushRecPtr(NULL);
327 : :
328 : 0 : PG_RETURN_LSN(current_recptr);
329 : 0 : }
330 : :
331 : : /*
332 : : * Report the last WAL receive location (same format as pg_backup_start etc)
333 : : *
334 : : * This is useful for determining how much of WAL is guaranteed to be received
335 : : * and synced to disk by walreceiver.
336 : : */
337 : : Datum
338 : 0 : pg_last_wal_receive_lsn(PG_FUNCTION_ARGS)
339 : : {
340 : 0 : XLogRecPtr recptr;
341 : :
342 : 0 : recptr = GetWalRcvFlushRecPtr(NULL, NULL);
343 : :
344 [ # # ]: 0 : if (!XLogRecPtrIsValid(recptr))
345 : 0 : PG_RETURN_NULL();
346 : :
347 : 0 : PG_RETURN_LSN(recptr);
348 : 0 : }
349 : :
350 : : /*
351 : : * Report the last WAL replay location (same format as pg_backup_start etc)
352 : : *
353 : : * This is useful for determining how much of WAL is visible to read-only
354 : : * connections during recovery.
355 : : */
356 : : Datum
357 : 0 : pg_last_wal_replay_lsn(PG_FUNCTION_ARGS)
358 : : {
359 : 0 : XLogRecPtr recptr;
360 : :
361 : 0 : recptr = GetXLogReplayRecPtr(NULL);
362 : :
363 [ # # ]: 0 : if (!XLogRecPtrIsValid(recptr))
364 : 0 : PG_RETURN_NULL();
365 : :
366 : 0 : PG_RETURN_LSN(recptr);
367 : 0 : }
368 : :
369 : : /*
370 : : * Compute an xlog file name and decimal byte offset given a WAL location,
371 : : * such as is returned by pg_backup_stop() or pg_switch_wal().
372 : : */
373 : : Datum
374 : 3 : pg_walfile_name_offset(PG_FUNCTION_ARGS)
375 : : {
376 : 3 : XLogSegNo xlogsegno;
377 : 3 : uint32 xrecoff;
378 : 3 : XLogRecPtr locationpoint = PG_GETARG_LSN(0);
379 : 3 : char xlogfilename[MAXFNAMELEN];
380 : 3 : Datum values[2];
381 : 3 : bool isnull[2];
382 : 3 : TupleDesc resultTupleDesc;
383 : 3 : HeapTuple resultHeapTuple;
384 : 3 : Datum result;
385 : :
386 [ + - ]: 3 : if (RecoveryInProgress())
387 [ # # # # ]: 0 : ereport(ERROR,
388 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
389 : : errmsg("recovery is in progress"),
390 : : errhint("%s cannot be executed during recovery.",
391 : : "pg_walfile_name_offset()")));
392 : :
393 : : /*
394 : : * Construct a tuple descriptor for the result row. This must match this
395 : : * function's pg_proc entry!
396 : : */
397 : 3 : resultTupleDesc = CreateTemplateTupleDesc(2);
398 : 3 : TupleDescInitEntry(resultTupleDesc, (AttrNumber) 1, "file_name",
399 : : TEXTOID, -1, 0);
400 : 3 : TupleDescInitEntry(resultTupleDesc, (AttrNumber) 2, "file_offset",
401 : : INT4OID, -1, 0);
402 : :
403 : 3 : resultTupleDesc = BlessTupleDesc(resultTupleDesc);
404 : :
405 : : /*
406 : : * xlogfilename
407 : : */
408 : 3 : XLByteToSeg(locationpoint, xlogsegno, wal_segment_size);
409 : 6 : XLogFileName(xlogfilename, GetWALInsertionTimeLine(), xlogsegno,
410 : 3 : wal_segment_size);
411 : :
412 : 3 : values[0] = CStringGetTextDatum(xlogfilename);
413 : 3 : isnull[0] = false;
414 : :
415 : : /*
416 : : * offset
417 : : */
418 : 3 : xrecoff = XLogSegmentOffset(locationpoint, wal_segment_size);
419 : :
420 : 3 : values[1] = UInt32GetDatum(xrecoff);
421 : 3 : isnull[1] = false;
422 : :
423 : : /*
424 : : * Tuple jam: Having first prepared your Datums, then squash together
425 : : */
426 : 3 : resultHeapTuple = heap_form_tuple(resultTupleDesc, values, isnull);
427 : :
428 : 3 : result = HeapTupleGetDatum(resultHeapTuple);
429 : :
430 : 6 : PG_RETURN_DATUM(result);
431 : 3 : }
432 : :
433 : : /*
434 : : * Compute an xlog file name given a WAL location,
435 : : * such as is returned by pg_backup_stop() or pg_switch_wal().
436 : : */
437 : : Datum
438 : 0 : pg_walfile_name(PG_FUNCTION_ARGS)
439 : : {
440 : 0 : XLogSegNo xlogsegno;
441 : 0 : XLogRecPtr locationpoint = PG_GETARG_LSN(0);
442 : 0 : char xlogfilename[MAXFNAMELEN];
443 : :
444 [ # # ]: 0 : if (RecoveryInProgress())
445 [ # # # # ]: 0 : ereport(ERROR,
446 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
447 : : errmsg("recovery is in progress"),
448 : : errhint("%s cannot be executed during recovery.",
449 : : "pg_walfile_name()")));
450 : :
451 : 0 : XLByteToSeg(locationpoint, xlogsegno, wal_segment_size);
452 : 0 : XLogFileName(xlogfilename, GetWALInsertionTimeLine(), xlogsegno,
453 : 0 : wal_segment_size);
454 : :
455 : 0 : PG_RETURN_TEXT_P(cstring_to_text(xlogfilename));
456 : 0 : }
457 : :
458 : : /*
459 : : * Extract the sequence number and the timeline ID from given a WAL file
460 : : * name.
461 : : */
462 : : Datum
463 : 6 : pg_split_walfile_name(PG_FUNCTION_ARGS)
464 : : {
465 : : #define PG_SPLIT_WALFILE_NAME_COLS 2
466 : 6 : char *fname = text_to_cstring(PG_GETARG_TEXT_PP(0));
467 : 6 : char *fname_upper;
468 : 6 : char *p;
469 : 6 : TimeLineID tli;
470 : 6 : XLogSegNo segno;
471 : 6 : Datum values[PG_SPLIT_WALFILE_NAME_COLS] = {0};
472 : 6 : bool isnull[PG_SPLIT_WALFILE_NAME_COLS] = {0};
473 : 6 : TupleDesc tupdesc;
474 : 6 : HeapTuple tuple;
475 : 6 : char buf[256];
476 : 6 : Datum result;
477 : :
478 : 6 : fname_upper = pstrdup(fname);
479 : :
480 : : /* Capitalize WAL file name. */
481 [ + + ]: 133 : for (p = fname_upper; *p; p++)
482 : 127 : *p = pg_ascii_toupper((unsigned char) *p);
483 : :
484 [ + + ]: 6 : if (!IsXLogFileName(fname_upper))
485 [ + - + - ]: 1 : ereport(ERROR,
486 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
487 : : errmsg("invalid WAL file name \"%s\"", fname)));
488 : :
489 : 5 : XLogFromFileName(fname_upper, &tli, &segno, wal_segment_size);
490 : :
491 [ + - ]: 5 : if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
492 [ # # # # ]: 0 : elog(ERROR, "return type must be a row type");
493 : :
494 : : /* Convert to numeric. */
495 : 5 : snprintf(buf, sizeof buf, UINT64_FORMAT, segno);
496 : 5 : values[0] = DirectFunctionCall3(numeric_in,
497 : : CStringGetDatum(buf),
498 : : ObjectIdGetDatum(0),
499 : : Int32GetDatum(-1));
500 : :
501 : 5 : values[1] = Int64GetDatum(tli);
502 : :
503 : 5 : tuple = heap_form_tuple(tupdesc, values, isnull);
504 : 5 : result = HeapTupleGetDatum(tuple);
505 : :
506 : 10 : PG_RETURN_DATUM(result);
507 : :
508 : : #undef PG_SPLIT_WALFILE_NAME_COLS
509 : 5 : }
510 : :
511 : : /*
512 : : * pg_wal_replay_pause - Request to pause recovery
513 : : *
514 : : * Permission checking for this function is managed through the normal
515 : : * GRANT system.
516 : : */
517 : : Datum
518 : 0 : pg_wal_replay_pause(PG_FUNCTION_ARGS)
519 : : {
520 [ # # ]: 0 : if (!RecoveryInProgress())
521 [ # # # # ]: 0 : ereport(ERROR,
522 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
523 : : errmsg("recovery is not in progress"),
524 : : errhint("Recovery control functions can only be executed during recovery.")));
525 : :
526 [ # # ]: 0 : if (PromoteIsTriggered())
527 [ # # # # ]: 0 : ereport(ERROR,
528 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
529 : : errmsg("standby promotion is ongoing"),
530 : : errhint("%s cannot be executed after promotion is triggered.",
531 : : "pg_wal_replay_pause()")));
532 : :
533 : 0 : SetRecoveryPause(true);
534 : :
535 : : /* wake up the recovery process so that it can process the pause request */
536 : 0 : WakeupRecovery();
537 : :
538 : 0 : PG_RETURN_VOID();
539 : : }
540 : :
541 : : /*
542 : : * pg_wal_replay_resume - resume recovery now
543 : : *
544 : : * Permission checking for this function is managed through the normal
545 : : * GRANT system.
546 : : */
547 : : Datum
548 : 0 : pg_wal_replay_resume(PG_FUNCTION_ARGS)
549 : : {
550 [ # # ]: 0 : if (!RecoveryInProgress())
551 [ # # # # ]: 0 : ereport(ERROR,
552 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
553 : : errmsg("recovery is not in progress"),
554 : : errhint("Recovery control functions can only be executed during recovery.")));
555 : :
556 [ # # ]: 0 : if (PromoteIsTriggered())
557 [ # # # # ]: 0 : ereport(ERROR,
558 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
559 : : errmsg("standby promotion is ongoing"),
560 : : errhint("%s cannot be executed after promotion is triggered.",
561 : : "pg_wal_replay_resume()")));
562 : :
563 : 0 : SetRecoveryPause(false);
564 : :
565 : 0 : PG_RETURN_VOID();
566 : : }
567 : :
568 : : /*
569 : : * pg_is_wal_replay_paused
570 : : */
571 : : Datum
572 : 0 : pg_is_wal_replay_paused(PG_FUNCTION_ARGS)
573 : : {
574 [ # # ]: 0 : if (!RecoveryInProgress())
575 [ # # # # ]: 0 : ereport(ERROR,
576 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
577 : : errmsg("recovery is not in progress"),
578 : : errhint("Recovery control functions can only be executed during recovery.")));
579 : :
580 : 0 : PG_RETURN_BOOL(GetRecoveryPauseState() != RECOVERY_NOT_PAUSED);
581 : : }
582 : :
583 : : /*
584 : : * pg_get_wal_replay_pause_state - Returns the recovery pause state.
585 : : *
586 : : * Returned values:
587 : : *
588 : : * 'not paused' - if pause is not requested
589 : : * 'pause requested' - if pause is requested but recovery is not yet paused
590 : : * 'paused' - if recovery is paused
591 : : */
592 : : Datum
593 : 0 : pg_get_wal_replay_pause_state(PG_FUNCTION_ARGS)
594 : : {
595 : 0 : char *statestr = NULL;
596 : :
597 [ # # ]: 0 : if (!RecoveryInProgress())
598 [ # # # # ]: 0 : ereport(ERROR,
599 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
600 : : errmsg("recovery is not in progress"),
601 : : errhint("Recovery control functions can only be executed during recovery.")));
602 : :
603 : : /* get the recovery pause state */
604 [ # # # # ]: 0 : switch (GetRecoveryPauseState())
605 : : {
606 : : case RECOVERY_NOT_PAUSED:
607 : 0 : statestr = "not paused";
608 : 0 : break;
609 : : case RECOVERY_PAUSE_REQUESTED:
610 : 0 : statestr = "pause requested";
611 : 0 : break;
612 : : case RECOVERY_PAUSED:
613 : 0 : statestr = "paused";
614 : 0 : break;
615 : : }
616 : :
617 [ # # ]: 0 : Assert(statestr != NULL);
618 : 0 : PG_RETURN_TEXT_P(cstring_to_text(statestr));
619 : 0 : }
620 : :
621 : : /*
622 : : * Returns timestamp of latest processed commit/abort record.
623 : : *
624 : : * When the server has been started normally without recovery the function
625 : : * returns NULL.
626 : : */
627 : : Datum
628 : 0 : pg_last_xact_replay_timestamp(PG_FUNCTION_ARGS)
629 : : {
630 : 0 : TimestampTz xtime;
631 : :
632 : 0 : xtime = GetLatestXTime();
633 [ # # ]: 0 : if (xtime == 0)
634 : 0 : PG_RETURN_NULL();
635 : :
636 : 0 : PG_RETURN_TIMESTAMPTZ(xtime);
637 : 0 : }
638 : :
639 : : /*
640 : : * Returns bool with current recovery mode, a global state.
641 : : */
642 : : Datum
643 : 0 : pg_is_in_recovery(PG_FUNCTION_ARGS)
644 : : {
645 : 0 : PG_RETURN_BOOL(RecoveryInProgress());
646 : : }
647 : :
648 : : /*
649 : : * Compute the difference in bytes between two WAL locations.
650 : : */
651 : : Datum
652 : 0 : pg_wal_lsn_diff(PG_FUNCTION_ARGS)
653 : : {
654 : 0 : Datum result;
655 : :
656 : 0 : result = DirectFunctionCall2(pg_lsn_mi,
657 : : PG_GETARG_DATUM(0),
658 : : PG_GETARG_DATUM(1));
659 : :
660 : 0 : PG_RETURN_DATUM(result);
661 : 0 : }
662 : :
663 : : /*
664 : : * Promotes a standby server.
665 : : *
666 : : * A result of "true" means that promotion has been completed if "wait" is
667 : : * "true", or initiated if "wait" is false.
668 : : */
669 : : Datum
670 : 0 : pg_promote(PG_FUNCTION_ARGS)
671 : : {
672 : 0 : bool wait = PG_GETARG_BOOL(0);
673 : 0 : int wait_seconds = PG_GETARG_INT32(1);
674 : 0 : FILE *promote_file;
675 : 0 : int i;
676 : :
677 [ # # ]: 0 : if (!RecoveryInProgress())
678 [ # # # # ]: 0 : ereport(ERROR,
679 : : (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
680 : : errmsg("recovery is not in progress"),
681 : : errhint("Recovery control functions can only be executed during recovery.")));
682 : :
683 [ # # ]: 0 : if (wait_seconds <= 0)
684 [ # # # # ]: 0 : ereport(ERROR,
685 : : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
686 : : errmsg("\"wait_seconds\" must not be negative or zero")));
687 : :
688 : : /* create the promote signal file */
689 : 0 : promote_file = AllocateFile(PROMOTE_SIGNAL_FILE, "w");
690 [ # # ]: 0 : if (!promote_file)
691 [ # # # # ]: 0 : ereport(ERROR,
692 : : (errcode_for_file_access(),
693 : : errmsg("could not create file \"%s\": %m",
694 : : PROMOTE_SIGNAL_FILE)));
695 : :
696 [ # # ]: 0 : if (FreeFile(promote_file))
697 [ # # # # ]: 0 : ereport(ERROR,
698 : : (errcode_for_file_access(),
699 : : errmsg("could not write file \"%s\": %m",
700 : : PROMOTE_SIGNAL_FILE)));
701 : :
702 : : /* signal the postmaster */
703 [ # # ]: 0 : if (kill(PostmasterPid, SIGUSR1) != 0)
704 : : {
705 : 0 : (void) unlink(PROMOTE_SIGNAL_FILE);
706 [ # # # # ]: 0 : ereport(ERROR,
707 : : (errcode(ERRCODE_SYSTEM_ERROR),
708 : : errmsg("failed to send signal to postmaster: %m")));
709 : 0 : }
710 : :
711 : : /* return immediately if waiting was not requested */
712 [ # # ]: 0 : if (!wait)
713 : 0 : PG_RETURN_BOOL(true);
714 : :
715 : : /* wait for the amount of time wanted until promotion */
716 : : #define WAITS_PER_SECOND 10
717 [ # # ]: 0 : for (i = 0; i < WAITS_PER_SECOND * wait_seconds; i++)
718 : : {
719 : 0 : int rc;
720 : :
721 : 0 : ResetLatch(MyLatch);
722 : :
723 [ # # ]: 0 : if (!RecoveryInProgress())
724 : 0 : PG_RETURN_BOOL(true);
725 : :
726 [ # # ]: 0 : CHECK_FOR_INTERRUPTS();
727 : :
728 : 0 : rc = WaitLatch(MyLatch,
729 : : WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH,
730 : : 1000L / WAITS_PER_SECOND,
731 : : WAIT_EVENT_PROMOTE);
732 : :
733 : : /*
734 : : * Emergency bailout if postmaster has died. This is to avoid the
735 : : * necessity for manual cleanup of all postmaster children.
736 : : */
737 [ # # ]: 0 : if (rc & WL_POSTMASTER_DEATH)
738 [ # # # # ]: 0 : ereport(FATAL,
739 : : (errcode(ERRCODE_ADMIN_SHUTDOWN),
740 : : errmsg("terminating connection due to unexpected postmaster exit"),
741 : : errcontext("while waiting on promotion")));
742 [ # # ]: 0 : }
743 : :
744 [ # # # # ]: 0 : ereport(WARNING,
745 : : (errmsg_plural("server did not promote within %d second",
746 : : "server did not promote within %d seconds",
747 : : wait_seconds,
748 : : wait_seconds)));
749 : 0 : PG_RETURN_BOOL(false);
750 : 0 : }
|
