PostgreSQL Source Code git master
pg_backup_archiver.h File Reference
#include <time.h>
#include "libpq-fe.h"
#include "pg_backup.h"
#include "pqexpbuffer.h"
Include dependency graph for pg_backup_archiver.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  sqlparseInfo
 
struct  _archiveHandle
 
struct  _tocEntry
 
struct  _archiveOpts
 

Macros

#define LOBBUFSIZE   16384
 
#define BLK_DATA   1
 
#define BLK_BLOBS   3
 
#define MAKE_ARCHIVE_VERSION(major, minor, rev)   (((major) * 256 + (minor)) * 256 + (rev))
 
#define ARCHIVE_MAJOR(version)   (((version) >> 16) & 255)
 
#define ARCHIVE_MINOR(version)   (((version) >> 8) & 255)
 
#define ARCHIVE_REV(version)   (((version) ) & 255)
 
#define K_VERS_1_0   MAKE_ARCHIVE_VERSION(1, 0, 0)
 
#define K_VERS_1_2   MAKE_ARCHIVE_VERSION(1, 2, 0) /* Allow No ZLIB */
 
#define K_VERS_1_3   MAKE_ARCHIVE_VERSION(1, 3, 0) /* BLOBS */
 
#define K_VERS_1_4   MAKE_ARCHIVE_VERSION(1, 4, 0) /* Date & name in header */
 
#define K_VERS_1_5   MAKE_ARCHIVE_VERSION(1, 5, 0) /* Handle dependencies */
 
#define K_VERS_1_6   MAKE_ARCHIVE_VERSION(1, 6, 0) /* Schema field in TOCs */
 
#define K_VERS_1_7
 
#define K_VERS_1_8
 
#define K_VERS_1_9
 
#define K_VERS_1_10   MAKE_ARCHIVE_VERSION(1, 10, 0) /* add tablespace */
 
#define K_VERS_1_11
 
#define K_VERS_1_12
 
#define K_VERS_1_13
 
#define K_VERS_1_14   MAKE_ARCHIVE_VERSION(1, 14, 0) /* add tableam */
 
#define K_VERS_1_15
 
#define K_VERS_1_16
 
#define K_VERS_MAJOR   1
 
#define K_VERS_MINOR   16
 
#define K_VERS_REV   0
 
#define K_VERS_SELF   MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, K_VERS_REV)
 
#define K_VERS_MAX   MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, 255)
 
#define K_OFFSET_POS_NOT_SET   1
 
#define K_OFFSET_POS_SET   2
 
#define K_OFFSET_NO_DATA   3
 
#define WORKER_OK   0
 
#define WORKER_CREATE_DONE   10
 
#define WORKER_INHIBIT_DATA   11
 
#define WORKER_IGNORED_ERRORS   12
 
#define READ_ERROR_EXIT(fd)
 
#define WRITE_ERROR_EXIT
 
#define RESTORE_PASS_LAST   RESTORE_PASS_POST_ACL
 
#define REQ_SCHEMA   0x01 /* want schema */
 
#define REQ_DATA   0x02 /* want data */
 
#define REQ_SPECIAL   0x04 /* for special TOC entries */
 
#define ARCHIVE_OPTS(...)   &(ArchiveOpts){__VA_ARGS__}
 
#define appendStringLiteralAHX(buf, str, AH)    appendStringLiteral(buf, str, (AH)->public.encoding, (AH)->public.std_strings)
 
#define appendByteaLiteralAHX(buf, str, len, AH)    appendByteaLiteral(buf, str, len, (AH)->public.std_strings)
 

Typedefs

typedef struct _archiveHandle ArchiveHandle
 
typedef struct _tocEntry TocEntry
 
typedef enum T_Action T_Action
 
typedef void(* ClosePtrType) (ArchiveHandle *AH)
 
typedef void(* ReopenPtrType) (ArchiveHandle *AH)
 
typedef void(* ArchiveEntryPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* StartDataPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* WriteDataPtrType) (ArchiveHandle *AH, const void *data, size_t dLen)
 
typedef void(* EndDataPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* StartLOsPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* StartLOPtrType) (ArchiveHandle *AH, TocEntry *te, Oid oid)
 
typedef void(* EndLOPtrType) (ArchiveHandle *AH, TocEntry *te, Oid oid)
 
typedef void(* EndLOsPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef int(* WriteBytePtrType) (ArchiveHandle *AH, const int i)
 
typedef int(* ReadBytePtrType) (ArchiveHandle *AH)
 
typedef void(* WriteBufPtrType) (ArchiveHandle *AH, const void *c, size_t len)
 
typedef void(* ReadBufPtrType) (ArchiveHandle *AH, void *buf, size_t len)
 
typedef void(* WriteExtraTocPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* ReadExtraTocPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* PrintExtraTocPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* PrintTocDataPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef void(* PrepParallelRestorePtrType) (ArchiveHandle *AH)
 
typedef void(* ClonePtrType) (ArchiveHandle *AH)
 
typedef void(* DeClonePtrType) (ArchiveHandle *AH)
 
typedef int(* WorkerJobDumpPtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef int(* WorkerJobRestorePtrType) (ArchiveHandle *AH, TocEntry *te)
 
typedef size_t(* CustomOutPtrType) (ArchiveHandle *AH, const void *buf, size_t len)
 
typedef void struct _archiveOpts ArchiveOpts
 

Enumerations

enum  T_Action { ACT_DUMP , ACT_RESTORE }
 
enum  sqlparseState { SQL_SCAN = 0 , SQL_IN_SINGLE_QUOTE , SQL_IN_DOUBLE_QUOTE }
 
enum  ArchiverStage { STAGE_NONE = 0 , STAGE_INITIALIZING , STAGE_PROCESSING , STAGE_FINALIZING }
 
enum  ArchiverOutput { OUTPUT_SQLCMDS = 0 , OUTPUT_COPYDATA , OUTPUT_OTHERDATA }
 
enum  RestorePass { RESTORE_PASS_MAIN = 0 , RESTORE_PASS_ACL , RESTORE_PASS_POST_ACL }
 

Functions

int parallel_restore (ArchiveHandle *AH, TocEntry *te)
 
void on_exit_close_archive (Archive *AHX)
 
void warn_or_exit_horribly (ArchiveHandle *AH, const char *fmt,...) pg_attribute_printf(2
 
TocEntryArchiveEntry (Archive *AHX, CatalogId catalogId, DumpId dumpId, ArchiveOpts *opts)
 
void WriteHead (ArchiveHandle *AH)
 
void ReadHead (ArchiveHandle *AH)
 
void WriteToc (ArchiveHandle *AH)
 
void ReadToc (ArchiveHandle *AH)
 
void WriteDataChunks (ArchiveHandle *AH, struct ParallelState *pstate)
 
void WriteDataChunksForTocEntry (ArchiveHandle *AH, TocEntry *te)
 
ArchiveHandleCloneArchive (ArchiveHandle *AH)
 
void DeCloneArchive (ArchiveHandle *AH)
 
int TocIDRequired (ArchiveHandle *AH, DumpId id)
 
TocEntrygetTocEntryByDumpId (ArchiveHandle *AH, DumpId id)
 
bool checkSeek (FILE *fp)
 
size_t WriteInt (ArchiveHandle *AH, int i)
 
int ReadInt (ArchiveHandle *AH)
 
char * ReadStr (ArchiveHandle *AH)
 
size_t WriteStr (ArchiveHandle *AH, const char *c)
 
int ReadOffset (ArchiveHandle *, pgoff_t *)
 
size_t WriteOffset (ArchiveHandle *, pgoff_t, int)
 
void StartRestoreLOs (ArchiveHandle *AH)
 
void StartRestoreLO (ArchiveHandle *AH, Oid oid, bool drop)
 
void EndRestoreLO (ArchiveHandle *AH, Oid oid)
 
void EndRestoreLOs (ArchiveHandle *AH)
 
void InitArchiveFmt_Custom (ArchiveHandle *AH)
 
void InitArchiveFmt_Null (ArchiveHandle *AH)
 
void InitArchiveFmt_Directory (ArchiveHandle *AH)
 
void InitArchiveFmt_Tar (ArchiveHandle *AH)
 
bool isValidTarHeader (char *header)
 
void ReconnectToServer (ArchiveHandle *AH, const char *dbname)
 
void IssueCommandPerBlob (ArchiveHandle *AH, TocEntry *te, const char *cmdBegin, const char *cmdEnd)
 
void IssueACLPerBlob (ArchiveHandle *AH, TocEntry *te)
 
void DropLOIfExists (ArchiveHandle *AH, Oid oid)
 
void ahwrite (const void *ptr, size_t size, size_t nmemb, ArchiveHandle *AH)
 
int ahprintf (ArchiveHandle *AH, const char *fmt,...) pg_attribute_printf(2
 

Macro Definition Documentation

◆ appendByteaLiteralAHX

#define appendByteaLiteralAHX (   buf,
  str,
  len,
  AH 
)     appendByteaLiteral(buf, str, len, (AH)->public.std_strings)

Definition at line 420 of file pg_backup_archiver.h.

◆ appendStringLiteralAHX

#define appendStringLiteralAHX (   buf,
  str,
  AH 
)     appendStringLiteral(buf, str, (AH)->public.encoding, (AH)->public.std_strings)

Definition at line 417 of file pg_backup_archiver.h.

◆ ARCHIVE_MAJOR

#define ARCHIVE_MAJOR (   version)    (((version) >> 16) & 255)

Definition at line 42 of file pg_backup_archiver.h.

◆ ARCHIVE_MINOR

#define ARCHIVE_MINOR (   version)    (((version) >> 8) & 255)

Definition at line 43 of file pg_backup_archiver.h.

◆ ARCHIVE_OPTS

#define ARCHIVE_OPTS (   ...)    &(ArchiveOpts){__VA_ARGS__}

Definition at line 399 of file pg_backup_archiver.h.

◆ ARCHIVE_REV

#define ARCHIVE_REV (   version)    (((version) ) & 255)

Definition at line 44 of file pg_backup_archiver.h.

◆ BLK_BLOBS

#define BLK_BLOBS   3

Definition at line 37 of file pg_backup_archiver.h.

◆ BLK_DATA

#define BLK_DATA   1

Definition at line 36 of file pg_backup_archiver.h.

◆ K_OFFSET_NO_DATA

#define K_OFFSET_NO_DATA   3

Definition at line 77 of file pg_backup_archiver.h.

◆ K_OFFSET_POS_NOT_SET

#define K_OFFSET_POS_NOT_SET   1

Definition at line 75 of file pg_backup_archiver.h.

◆ K_OFFSET_POS_SET

#define K_OFFSET_POS_SET   2

Definition at line 76 of file pg_backup_archiver.h.

◆ K_VERS_1_0

#define K_VERS_1_0   MAKE_ARCHIVE_VERSION(1, 0, 0)

Definition at line 47 of file pg_backup_archiver.h.

◆ K_VERS_1_10

#define K_VERS_1_10   MAKE_ARCHIVE_VERSION(1, 10, 0) /* add tablespace */

Definition at line 56 of file pg_backup_archiver.h.

◆ K_VERS_1_11

#define K_VERS_1_11
Value:
MAKE_ARCHIVE_VERSION(1, 11, 0) /* add toc section
* indicator */
#define MAKE_ARCHIVE_VERSION(major, minor, rev)

Definition at line 57 of file pg_backup_archiver.h.

◆ K_VERS_1_12

#define K_VERS_1_12
Value:
MAKE_ARCHIVE_VERSION(1, 12, 0) /* add separate BLOB
* entries */

Definition at line 58 of file pg_backup_archiver.h.

◆ K_VERS_1_13

#define K_VERS_1_13
Value:
MAKE_ARCHIVE_VERSION(1, 13, 0) /* change search_path
* behavior */

Definition at line 59 of file pg_backup_archiver.h.

◆ K_VERS_1_14

#define K_VERS_1_14   MAKE_ARCHIVE_VERSION(1, 14, 0) /* add tableam */

Definition at line 60 of file pg_backup_archiver.h.

◆ K_VERS_1_15

#define K_VERS_1_15
Value:
MAKE_ARCHIVE_VERSION(1, 15, 0) /* add
* compression_algorithm
* in header */

Definition at line 61 of file pg_backup_archiver.h.

◆ K_VERS_1_16

#define K_VERS_1_16
Value:
MAKE_ARCHIVE_VERSION(1, 16, 0) /* BLOB METADATA entries
* and multiple BLOBS,
* relkind */

Definition at line 62 of file pg_backup_archiver.h.

◆ K_VERS_1_2

#define K_VERS_1_2   MAKE_ARCHIVE_VERSION(1, 2, 0) /* Allow No ZLIB */

Definition at line 48 of file pg_backup_archiver.h.

◆ K_VERS_1_3

#define K_VERS_1_3   MAKE_ARCHIVE_VERSION(1, 3, 0) /* BLOBS */

Definition at line 49 of file pg_backup_archiver.h.

◆ K_VERS_1_4

#define K_VERS_1_4   MAKE_ARCHIVE_VERSION(1, 4, 0) /* Date & name in header */

Definition at line 50 of file pg_backup_archiver.h.

◆ K_VERS_1_5

#define K_VERS_1_5   MAKE_ARCHIVE_VERSION(1, 5, 0) /* Handle dependencies */

Definition at line 51 of file pg_backup_archiver.h.

◆ K_VERS_1_6

#define K_VERS_1_6   MAKE_ARCHIVE_VERSION(1, 6, 0) /* Schema field in TOCs */

Definition at line 52 of file pg_backup_archiver.h.

◆ K_VERS_1_7

#define K_VERS_1_7
Value:
MAKE_ARCHIVE_VERSION(1, 7, 0) /* File Offset size in
* header */

Definition at line 53 of file pg_backup_archiver.h.

◆ K_VERS_1_8

#define K_VERS_1_8
Value:
MAKE_ARCHIVE_VERSION(1, 8, 0) /* change interpretation
* of ID numbers and
* dependencies */

Definition at line 54 of file pg_backup_archiver.h.

◆ K_VERS_1_9

#define K_VERS_1_9
Value:
MAKE_ARCHIVE_VERSION(1, 9, 0) /* add default_with_oids
* tracking */

Definition at line 55 of file pg_backup_archiver.h.

◆ K_VERS_MAJOR

#define K_VERS_MAJOR   1

Definition at line 65 of file pg_backup_archiver.h.

◆ K_VERS_MAX

#define K_VERS_MAX   MAKE_ARCHIVE_VERSION(K_VERS_MAJOR, K_VERS_MINOR, 255)

Definition at line 71 of file pg_backup_archiver.h.

◆ K_VERS_MINOR

#define K_VERS_MINOR   16

Definition at line 66 of file pg_backup_archiver.h.

◆ K_VERS_REV

#define K_VERS_REV   0

Definition at line 67 of file pg_backup_archiver.h.

◆ K_VERS_SELF

Definition at line 68 of file pg_backup_archiver.h.

◆ LOBBUFSIZE

#define LOBBUFSIZE   16384

Definition at line 33 of file pg_backup_archiver.h.

◆ MAKE_ARCHIVE_VERSION

#define MAKE_ARCHIVE_VERSION (   major,
  minor,
  rev 
)    (((major) * 256 + (minor)) * 256 + (rev))

Definition at line 40 of file pg_backup_archiver.h.

◆ READ_ERROR_EXIT

#define READ_ERROR_EXIT (   fd)
Value:
do { \
if (feof(fd)) \
pg_fatal("could not read from input file: end of file"); \
pg_fatal("could not read from input file: %m"); \
} while (0)
#define pg_fatal(...)
static int fd(const char *x, int i)
Definition: preproc-init.c:105

Definition at line 92 of file pg_backup_archiver.h.

◆ REQ_DATA

#define REQ_DATA   0x02 /* want data */

Definition at line 200 of file pg_backup_archiver.h.

◆ REQ_SCHEMA

#define REQ_SCHEMA   0x01 /* want schema */

Definition at line 199 of file pg_backup_archiver.h.

◆ REQ_SPECIAL

#define REQ_SPECIAL   0x04 /* for special TOC entries */

Definition at line 201 of file pg_backup_archiver.h.

◆ RESTORE_PASS_LAST

#define RESTORE_PASS_LAST   RESTORE_PASS_POST_ACL

Definition at line 196 of file pg_backup_archiver.h.

◆ WORKER_CREATE_DONE

#define WORKER_CREATE_DONE   10

Definition at line 84 of file pg_backup_archiver.h.

◆ WORKER_IGNORED_ERRORS

#define WORKER_IGNORED_ERRORS   12

Definition at line 86 of file pg_backup_archiver.h.

◆ WORKER_INHIBIT_DATA

#define WORKER_INHIBIT_DATA   11

Definition at line 85 of file pg_backup_archiver.h.

◆ WORKER_OK

#define WORKER_OK   0

Definition at line 83 of file pg_backup_archiver.h.

◆ WRITE_ERROR_EXIT

#define WRITE_ERROR_EXIT
Value:
do { \
pg_fatal("could not write to output file: %m"); \
} while (0)

Definition at line 100 of file pg_backup_archiver.h.

Typedef Documentation

◆ ArchiveEntryPtrType

typedef void(* ArchiveEntryPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 113 of file pg_backup_archiver.h.

◆ ArchiveHandle

typedef struct _archiveHandle ArchiveHandle

Definition at line 88 of file pg_backup_archiver.h.

◆ ArchiveOpts

typedef void struct _archiveOpts ArchiveOpts

◆ ClonePtrType

typedef void(* ClonePtrType) (ArchiveHandle *AH)

Definition at line 134 of file pg_backup_archiver.h.

◆ ClosePtrType

typedef void(* ClosePtrType) (ArchiveHandle *AH)

Definition at line 111 of file pg_backup_archiver.h.

◆ CustomOutPtrType

typedef size_t(* CustomOutPtrType) (ArchiveHandle *AH, const void *buf, size_t len)

Definition at line 140 of file pg_backup_archiver.h.

◆ DeClonePtrType

typedef void(* DeClonePtrType) (ArchiveHandle *AH)

Definition at line 135 of file pg_backup_archiver.h.

◆ EndDataPtrType

typedef void(* EndDataPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 117 of file pg_backup_archiver.h.

◆ EndLOPtrType

typedef void(* EndLOPtrType) (ArchiveHandle *AH, TocEntry *te, Oid oid)

Definition at line 121 of file pg_backup_archiver.h.

◆ EndLOsPtrType

typedef void(* EndLOsPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 122 of file pg_backup_archiver.h.

◆ PrepParallelRestorePtrType

typedef void(* PrepParallelRestorePtrType) (ArchiveHandle *AH)

Definition at line 133 of file pg_backup_archiver.h.

◆ PrintExtraTocPtrType

typedef void(* PrintExtraTocPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 130 of file pg_backup_archiver.h.

◆ PrintTocDataPtrType

typedef void(* PrintTocDataPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 131 of file pg_backup_archiver.h.

◆ ReadBufPtrType

typedef void(* ReadBufPtrType) (ArchiveHandle *AH, void *buf, size_t len)

Definition at line 127 of file pg_backup_archiver.h.

◆ ReadBytePtrType

typedef int(* ReadBytePtrType) (ArchiveHandle *AH)

Definition at line 125 of file pg_backup_archiver.h.

◆ ReadExtraTocPtrType

typedef void(* ReadExtraTocPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 129 of file pg_backup_archiver.h.

◆ ReopenPtrType

typedef void(* ReopenPtrType) (ArchiveHandle *AH)

Definition at line 112 of file pg_backup_archiver.h.

◆ StartDataPtrType

typedef void(* StartDataPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 115 of file pg_backup_archiver.h.

◆ StartLOPtrType

typedef void(* StartLOPtrType) (ArchiveHandle *AH, TocEntry *te, Oid oid)

Definition at line 120 of file pg_backup_archiver.h.

◆ StartLOsPtrType

typedef void(* StartLOsPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 119 of file pg_backup_archiver.h.

◆ T_Action

typedef enum T_Action T_Action

◆ TocEntry

typedef struct _tocEntry TocEntry

Definition at line 89 of file pg_backup_archiver.h.

◆ WorkerJobDumpPtrType

typedef int(* WorkerJobDumpPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 137 of file pg_backup_archiver.h.

◆ WorkerJobRestorePtrType

typedef int(* WorkerJobRestorePtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 138 of file pg_backup_archiver.h.

◆ WriteBufPtrType

typedef void(* WriteBufPtrType) (ArchiveHandle *AH, const void *c, size_t len)

Definition at line 126 of file pg_backup_archiver.h.

◆ WriteBytePtrType

typedef int(* WriteBytePtrType) (ArchiveHandle *AH, const int i)

Definition at line 124 of file pg_backup_archiver.h.

◆ WriteDataPtrType

typedef void(* WriteDataPtrType) (ArchiveHandle *AH, const void *data, size_t dLen)

Definition at line 116 of file pg_backup_archiver.h.

◆ WriteExtraTocPtrType

typedef void(* WriteExtraTocPtrType) (ArchiveHandle *AH, TocEntry *te)

Definition at line 128 of file pg_backup_archiver.h.

Enumeration Type Documentation

◆ ArchiverOutput

Enumerator
OUTPUT_SQLCMDS 
OUTPUT_COPYDATA 
OUTPUT_OTHERDATA 

Definition at line 164 of file pg_backup_archiver.h.

168{
169 STAGE_NONE = 0,
@ STAGE_NONE

◆ ArchiverStage

Enumerator
STAGE_NONE 
STAGE_INITIALIZING 
STAGE_PROCESSING 
STAGE_FINALIZING 

Definition at line 156 of file pg_backup_archiver.h.

161{
162 sqlparseState state; /* see above */
sqlparseState
Definition: regguts.h:323

◆ RestorePass

Enumerator
RESTORE_PASS_MAIN 
RESTORE_PASS_ACL 
RESTORE_PASS_POST_ACL 

Definition at line 190 of file pg_backup_archiver.h.

202{

◆ sqlparseState

Enumerator
SQL_SCAN 
SQL_IN_SINGLE_QUOTE 
SQL_IN_DOUBLE_QUOTE 

Definition at line 142 of file pg_backup_archiver.h.

154{

◆ T_Action

enum T_Action
Enumerator
ACT_DUMP 
ACT_RESTORE 

Definition at line 105 of file pg_backup_archiver.h.

106 : end of file"); \
107 else \
108 pg_fatal("could not read from input file: %m"); \
109 } while (0)
FILE * input
#define read(a, b, c)
Definition: win32.h:13

Function Documentation

◆ ahprintf()

int ahprintf ( ArchiveHandle AH,
const char *  fmt,
  ... 
)

◆ ahwrite()

void ahwrite ( const void *  ptr,
size_t  size,
size_t  nmemb,
ArchiveHandle AH 
)

Definition at line 1812 of file pg_backup_archiver.c.

1813{
1814 int bytes_written = 0;
1815
1816 if (AH->writingLO)
1817 {
1818 size_t remaining = size * nmemb;
1819
1820 while (AH->lo_buf_used + remaining > AH->lo_buf_size)
1821 {
1822 size_t avail = AH->lo_buf_size - AH->lo_buf_used;
1823
1824 memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, avail);
1825 ptr = (const char *) ptr + avail;
1826 remaining -= avail;
1827 AH->lo_buf_used += avail;
1828 dump_lo_buf(AH);
1829 }
1830
1831 memcpy((char *) AH->lo_buf + AH->lo_buf_used, ptr, remaining);
1832 AH->lo_buf_used += remaining;
1833
1834 bytes_written = size * nmemb;
1835 }
1836 else if (AH->CustomOutPtr)
1837 bytes_written = AH->CustomOutPtr(AH, ptr, size * nmemb);
1838
1839 /*
1840 * If we're doing a restore, and it's direct to DB, and we're connected
1841 * then send it to the DB.
1842 */
1843 else if (RestoringToDB(AH))
1844 bytes_written = ExecuteSqlCommandBuf(&AH->public, (const char *) ptr, size * nmemb);
1845 else
1846 {
1848
1849 if (CFH->write_func(ptr, size * nmemb, CFH))
1850 bytes_written = size * nmemb;
1851 }
1852
1853 if (bytes_written != size * nmemb)
1855}
int remaining
Definition: informix.c:692
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:76
static int RestoringToDB(ArchiveHandle *AH)
static void dump_lo_buf(ArchiveHandle *AH)
#define WRITE_ERROR_EXIT
int ExecuteSqlCommandBuf(Archive *AHX, const char *buf, size_t bufLen)
Definition: pg_backup_db.c:443
static pg_noinline void Size size
Definition: slab.c:607
bool(* write_func)(const void *ptr, size_t size, struct CompressFileHandle *CFH)
Definition: compress_io.h:139
CustomOutPtrType CustomOutPtr

References _archiveHandle::CustomOutPtr, dump_lo_buf(), ExecuteSqlCommandBuf(), if(), _archiveHandle::lo_buf, _archiveHandle::lo_buf_size, _archiveHandle::lo_buf_used, _archiveHandle::OF, _archiveHandle::public, remaining, RestoringToDB(), size, WRITE_ERROR_EXIT, CompressFileHandle::write_func, and _archiveHandle::writingLO.

Referenced by _LoadLOs(), _PrintFileData(), _PrintTocData(), _WriteData(), ahprintf(), and ReadDataFromArchiveNone().

◆ ArchiveEntry()

TocEntry * ArchiveEntry ( Archive AHX,
CatalogId  catalogId,
DumpId  dumpId,
ArchiveOpts opts 
)

Definition at line 1207 of file pg_backup_archiver.c.

1209{
1210 ArchiveHandle *AH = (ArchiveHandle *) AHX;
1211 TocEntry *newToc;
1212
1213 newToc = (TocEntry *) pg_malloc0(sizeof(TocEntry));
1214
1215 AH->tocCount++;
1216 if (dumpId > AH->maxDumpId)
1217 AH->maxDumpId = dumpId;
1218
1219 newToc->prev = AH->toc->prev;
1220 newToc->next = AH->toc;
1221 AH->toc->prev->next = newToc;
1222 AH->toc->prev = newToc;
1223
1224 newToc->catalogId = catalogId;
1225 newToc->dumpId = dumpId;
1226 newToc->section = opts->section;
1227
1228 newToc->tag = pg_strdup(opts->tag);
1229 newToc->namespace = opts->namespace ? pg_strdup(opts->namespace) : NULL;
1230 newToc->tablespace = opts->tablespace ? pg_strdup(opts->tablespace) : NULL;
1231 newToc->tableam = opts->tableam ? pg_strdup(opts->tableam) : NULL;
1232 newToc->relkind = opts->relkind;
1233 newToc->owner = opts->owner ? pg_strdup(opts->owner) : NULL;
1234 newToc->desc = pg_strdup(opts->description);
1235 newToc->defn = opts->createStmt ? pg_strdup(opts->createStmt) : NULL;
1236 newToc->dropStmt = opts->dropStmt ? pg_strdup(opts->dropStmt) : NULL;
1237 newToc->copyStmt = opts->copyStmt ? pg_strdup(opts->copyStmt) : NULL;
1238
1239 if (opts->nDeps > 0)
1240 {
1241 newToc->dependencies = (DumpId *) pg_malloc(opts->nDeps * sizeof(DumpId));
1242 memcpy(newToc->dependencies, opts->deps, opts->nDeps * sizeof(DumpId));
1243 newToc->nDeps = opts->nDeps;
1244 }
1245 else
1246 {
1247 newToc->dependencies = NULL;
1248 newToc->nDeps = 0;
1249 }
1250
1251 newToc->dataDumper = opts->dumpFn;
1252 newToc->dataDumperArg = opts->dumpArg;
1253 newToc->hadDumper = opts->dumpFn ? true : false;
1254
1255 newToc->formatData = NULL;
1256 newToc->dataLength = 0;
1257
1258 if (AH->ArchiveEntryPtr != NULL)
1259 AH->ArchiveEntryPtr(AH, newToc);
1260
1261 return newToc;
1262}
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
void * pg_malloc0(size_t size)
Definition: fe_memutils.c:53
return true
Definition: isn.c:125
static AmcheckOptions opts
Definition: pg_amcheck.c:112
int DumpId
Definition: pg_backup.h:275
struct _tocEntry * toc
ArchiveEntryPtrType ArchiveEntryPtr
struct _tocEntry * prev
teSection section
DataDumperPtr dataDumper
pgoff_t dataLength
CatalogId catalogId
struct _tocEntry * next
const void * dataDumperArg
DumpId * dependencies

References _archiveHandle::ArchiveEntryPtr, _tocEntry::catalogId, _tocEntry::copyStmt, _tocEntry::dataDumper, _tocEntry::dataDumperArg, _tocEntry::dataLength, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dropStmt, _tocEntry::dumpId, _tocEntry::formatData, _tocEntry::hadDumper, _archiveHandle::maxDumpId, _tocEntry::nDeps, _tocEntry::next, opts, _tocEntry::owner, pg_malloc(), pg_malloc0(), pg_strdup(), _tocEntry::prev, _tocEntry::relkind, _tocEntry::section, _tocEntry::tableam, _tocEntry::tablespace, _tocEntry::tag, _archiveHandle::toc, _archiveHandle::tocCount, and true.

Referenced by dumpAccessMethod(), dumpACL(), dumpAgg(), dumpAttrDef(), dumpBaseType(), dumpCast(), dumpCollation(), dumpCommentExtended(), dumpCompositeType(), dumpCompositeTypeColComments(), dumpConstraint(), dumpConversion(), dumpDatabase(), dumpDefaultACL(), dumpDomain(), dumpDumpableObject(), dumpEncoding(), dumpEnumType(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpIndex(), dumpIndexAttach(), dumpLO(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpPolicy(), dumpProcLang(), dumpPublication(), dumpPublicationNamespace(), dumpPublicationTable(), dumpRangeType(), dumpRule(), dumpSearchPath(), dumpSecLabel(), dumpSequence(), dumpSequenceData(), dumpShellType(), dumpStatisticsExt(), dumpStdStrings(), dumpSubscription(), dumpSubscriptionTable(), dumpTableAttach(), dumpTableComment(), dumpTableData(), dumpTableSchema(), dumpTableSecLabel(), dumpTransform(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpUndefinedType(), dumpUserMappings(), and refreshMatViewData().

◆ checkSeek()

bool checkSeek ( FILE *  fp)

Definition at line 4122 of file pg_backup_archiver.c.

4123{
4124 pgoff_t tpos;
4125
4126 /* Check that ftello works on this file */
4127 tpos = ftello(fp);
4128 if (tpos < 0)
4129 return false;
4130
4131 /*
4132 * Check that fseeko(SEEK_SET) works, too. NB: we used to try to test
4133 * this with fseeko(fp, 0, SEEK_CUR). But some platforms treat that as a
4134 * successful no-op even on files that are otherwise unseekable.
4135 */
4136 if (fseeko(fp, tpos, SEEK_SET) != 0)
4137 return false;
4138
4139 return true;
4140}
#define pgoff_t
Definition: port.h:401
#define ftello(stream)
Definition: win32_port.h:209
#define fseeko(stream, offset, origin)
Definition: win32_port.h:206

References fseeko, ftello, and pgoff_t.

Referenced by InitArchiveFmt_Custom(), and InitArchiveFmt_Tar().

◆ CloneArchive()

ArchiveHandle * CloneArchive ( ArchiveHandle AH)

Definition at line 4989 of file pg_backup_archiver.c.

4990{
4991 ArchiveHandle *clone;
4992
4993 /* Make a "flat" copy */
4994 clone = (ArchiveHandle *) pg_malloc(sizeof(ArchiveHandle));
4995 memcpy(clone, AH, sizeof(ArchiveHandle));
4996
4997 /* Likewise flat-copy the RestoreOptions, so we can alter them locally */
4998 clone->public.ropt = (RestoreOptions *) pg_malloc(sizeof(RestoreOptions));
4999 memcpy(clone->public.ropt, AH->public.ropt, sizeof(RestoreOptions));
5000
5001 /* Handle format-independent fields */
5002 memset(&(clone->sqlparse), 0, sizeof(clone->sqlparse));
5003
5004 /* The clone will have its own connection, so disregard connection state */
5005 clone->connection = NULL;
5006 clone->connCancel = NULL;
5007 clone->currUser = NULL;
5008 clone->currSchema = NULL;
5009 clone->currTableAm = NULL;
5010 clone->currTablespace = NULL;
5011
5012 /* savedPassword must be local in case we change it while connecting */
5013 if (clone->savedPassword)
5014 clone->savedPassword = pg_strdup(clone->savedPassword);
5015
5016 /* clone has its own error count, too */
5017 clone->public.n_errors = 0;
5018
5019 /* clones should not share lo_buf */
5020 clone->lo_buf = NULL;
5021
5022 /*
5023 * Clone connections disregard --transaction-size; they must commit after
5024 * each command so that the results are immediately visible to other
5025 * workers.
5026 */
5027 clone->public.ropt->txn_size = 0;
5028
5029 /*
5030 * Connect our new clone object to the database, using the same connection
5031 * parameters used for the original connection.
5032 */
5033 ConnectDatabase((Archive *) clone, &clone->public.ropt->cparams, true);
5034
5035 /* re-establish fixed state */
5036 if (AH->mode == archModeRead)
5038 /* in write case, setupDumpWorker will fix up connection state */
5039
5040 /* Let the format-specific code have a chance too */
5041 clone->ClonePtr(clone);
5042
5043 Assert(clone->connection != NULL);
5044 return clone;
5045}
#define Assert(condition)
Definition: c.h:815
void ConnectDatabase(Archive *AHX, const ConnParams *cparams, bool isReconnect)
Definition: pg_backup_db.c:108
@ archModeRead
Definition: pg_backup.h:52
static void _doSetFixedOutputState(ArchiveHandle *AH)
int n_errors
Definition: pg_backup.h:243
RestoreOptions * ropt
Definition: pg_backup.h:220
PGcancel *volatile connCancel
ClonePtrType ClonePtr
sqlparseInfo sqlparse
ConnParams cparams
Definition: pg_backup.h:143

References _doSetFixedOutputState(), archModeRead, Assert, _archiveHandle::ClonePtr, _archiveHandle::connCancel, ConnectDatabase(), _archiveHandle::connection, _restoreOptions::cparams, _archiveHandle::currSchema, _archiveHandle::currTableAm, _archiveHandle::currTablespace, _archiveHandle::currUser, _archiveHandle::lo_buf, _archiveHandle::mode, Archive::n_errors, pg_malloc(), pg_strdup(), _archiveHandle::public, Archive::ropt, _archiveHandle::savedPassword, _archiveHandle::sqlparse, and _restoreOptions::txn_size.

Referenced by RunWorker().

◆ DeCloneArchive()

void DeCloneArchive ( ArchiveHandle AH)

Definition at line 5053 of file pg_backup_archiver.c.

5054{
5055 /* Should not have an open database connection */
5056 Assert(AH->connection == NULL);
5057
5058 /* Clear format-specific state */
5059 AH->DeClonePtr(AH);
5060
5061 /* Clear state allocated by CloneArchive */
5062 if (AH->sqlparse.curCmd)
5064
5065 /* Clear any connection-local state */
5066 free(AH->currUser);
5067 free(AH->currSchema);
5068 free(AH->currTablespace);
5069 free(AH->currTableAm);
5070 free(AH->savedPassword);
5071
5072 free(AH);
5073}
#define free(a)
Definition: header.h:65
void destroyPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:114
DeClonePtrType DeClonePtr
PQExpBuffer curCmd

References Assert, _archiveHandle::connection, sqlparseInfo::curCmd, _archiveHandle::currSchema, _archiveHandle::currTableAm, _archiveHandle::currTablespace, _archiveHandle::currUser, _archiveHandle::DeClonePtr, destroyPQExpBuffer(), free, _archiveHandle::savedPassword, and _archiveHandle::sqlparse.

Referenced by RunWorker().

◆ DropLOIfExists()

void DropLOIfExists ( ArchiveHandle AH,
Oid  oid 
)

Definition at line 671 of file pg_backup_db.c.

672{
673 ahprintf(AH,
674 "SELECT pg_catalog.lo_unlink(oid) "
675 "FROM pg_catalog.pg_largeobject_metadata "
676 "WHERE oid = '%u';\n",
677 oid);
678}
int ahprintf(ArchiveHandle *AH, const char *fmt,...)

References ahprintf().

Referenced by _StartLO(), RestoreArchive(), and StartRestoreLO().

◆ EndRestoreLO()

void EndRestoreLO ( ArchiveHandle AH,
Oid  oid 
)

Definition at line 1507 of file pg_backup_archiver.c.

1508{
1509 if (AH->lo_buf_used > 0)
1510 {
1511 /* Write remaining bytes from the LO buffer */
1512 dump_lo_buf(AH);
1513 }
1514
1515 AH->writingLO = false;
1516
1517 if (AH->connection)
1518 {
1519 lo_close(AH->connection, AH->loFd);
1520 AH->loFd = -1;
1521 }
1522 else
1523 {
1524 ahprintf(AH, "SELECT pg_catalog.lo_close(0);\n\n");
1525 }
1526}
int lo_close(PGconn *conn, int fd)
Definition: fe-lobj.c:96

References ahprintf(), _archiveHandle::connection, dump_lo_buf(), _archiveHandle::lo_buf_used, lo_close(), _archiveHandle::loFd, and _archiveHandle::writingLO.

Referenced by _LoadLOs().

◆ EndRestoreLOs()

void EndRestoreLOs ( ArchiveHandle AH)

Definition at line 1434 of file pg_backup_archiver.c.

1435{
1436 RestoreOptions *ropt = AH->public.ropt;
1437
1438 if (!(ropt->single_txn || ropt->txn_size > 0))
1439 {
1440 if (AH->connection)
1442 else
1443 ahprintf(AH, "COMMIT;\n\n");
1444 }
1445
1446 pg_log_info(ngettext("restored %d large object",
1447 "restored %d large objects",
1448 AH->loCount),
1449 AH->loCount);
1450}
#define ngettext(s, p, n)
Definition: c.h:1138
#define pg_log_info(...)
Definition: logging.h:124
static void CommitTransaction(void)
Definition: xact.c:2227

References ahprintf(), CommitTransaction(), _archiveHandle::connection, _archiveHandle::loCount, ngettext, pg_log_info, _archiveHandle::public, Archive::ropt, _restoreOptions::single_txn, and _restoreOptions::txn_size.

Referenced by _LoadLOs().

◆ getTocEntryByDumpId()

TocEntry * getTocEntryByDumpId ( ArchiveHandle AH,
DumpId  id 
)

Definition at line 1992 of file pg_backup_archiver.c.

1993{
1994 /* build index arrays if we didn't already */
1995 if (AH->tocsByDumpId == NULL)
1997
1998 if (id > 0 && id <= AH->maxDumpId)
1999 return AH->tocsByDumpId[id];
2000
2001 return NULL;
2002}
static void buildTocEntryArrays(ArchiveHandle *AH)
struct _tocEntry ** tocsByDumpId

References buildTocEntryArrays(), and _archiveHandle::tocsByDumpId.

Referenced by _PrintTocData(), _tocEntryRequired(), IssueACLPerBlob(), parseWorkerCommand(), SortTocFromFile(), and TocIDRequired().

◆ InitArchiveFmt_Custom()

void InitArchiveFmt_Custom ( ArchiveHandle AH)

Definition at line 105 of file pg_backup_custom.c.

106{
107 lclContext *ctx;
108
109 /* Assuming static functions, this can be copied for each format. */
113 AH->EndDataPtr = _EndData;
117 AH->ReadBufPtr = _ReadBuf;
124
126 AH->StartLOPtr = _StartLO;
127 AH->EndLOPtr = _EndLO;
128 AH->EndLOsPtr = _EndLOs;
129
131 AH->ClonePtr = _Clone;
132 AH->DeClonePtr = _DeClone;
133
134 /* no parallel dump in the custom archive, only parallel restore */
135 AH->WorkerJobDumpPtr = NULL;
137
138 /* Set up a private area. */
139 ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
140 AH->formatData = ctx;
141
142 /*
143 * Now open the file
144 */
145 if (AH->mode == archModeWrite)
146 {
147 if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
148 {
149 AH->FH = fopen(AH->fSpec, PG_BINARY_W);
150 if (!AH->FH)
151 pg_fatal("could not open output file \"%s\": %m", AH->fSpec);
152 }
153 else
154 {
155 AH->FH = stdout;
156 if (!AH->FH)
157 pg_fatal("could not open output file: %m");
158 }
159
160 ctx->hasSeek = checkSeek(AH->FH);
161 }
162 else
163 {
164 if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
165 {
166 AH->FH = fopen(AH->fSpec, PG_BINARY_R);
167 if (!AH->FH)
168 pg_fatal("could not open input file \"%s\": %m", AH->fSpec);
169 }
170 else
171 {
172 AH->FH = stdin;
173 if (!AH->FH)
174 pg_fatal("could not open input file: %m");
175 }
176
177 ctx->hasSeek = checkSeek(AH->FH);
178
179 ReadHead(AH);
180 ReadToc(AH);
181
182 /*
183 * Remember location of first data block (i.e., the point after TOC)
184 * in case we have to search for desired data blocks.
185 */
186 ctx->lastFilePos = _getFilePos(AH, ctx);
187 }
188}
#define PG_BINARY_R
Definition: c.h:1232
#define PG_BINARY_W
Definition: c.h:1233
@ archModeWrite
Definition: pg_backup.h:51
bool checkSeek(FILE *fp)
void ReadHead(ArchiveHandle *AH)
void ReadToc(ArchiveHandle *AH)
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _StartData(ArchiveHandle *AH, TocEntry *te)
static void _PrintExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te)
static void _CloseArchive(ArchiveHandle *AH)
static pgoff_t _getFilePos(ArchiveHandle *AH, lclContext *ctx)
static void _DeClone(ArchiveHandle *AH)
static void _ReopenArchive(ArchiveHandle *AH)
static void _StartLOs(ArchiveHandle *AH, TocEntry *te)
static void _WriteExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _EndLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static void _EndLOs(ArchiveHandle *AH, TocEntry *te)
static int _WriteByte(ArchiveHandle *AH, const int i)
static void _PrepParallelRestore(ArchiveHandle *AH)
static void _StartLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static int _ReadByte(ArchiveHandle *AH)
static void _ReadExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _ReadBuf(ArchiveHandle *AH, void *buf, size_t len)
static void _EndData(ArchiveHandle *AH, TocEntry *te)
static int _WorkerJobRestoreCustom(ArchiveHandle *AH, TocEntry *te)
static void _Clone(ArchiveHandle *AH)
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
EndLOsPtrType EndLOsPtr
ReadExtraTocPtrType ReadExtraTocPtr
WorkerJobDumpPtrType WorkerJobDumpPtr
StartLOsPtrType StartLOsPtr
WriteDataPtrType WriteDataPtr
StartLOPtrType StartLOPtr
WriteBufPtrType WriteBufPtr
PrepParallelRestorePtrType PrepParallelRestorePtr
EndLOPtrType EndLOPtr
WriteExtraTocPtrType WriteExtraTocPtr
ReadBytePtrType ReadBytePtr
WorkerJobRestorePtrType WorkerJobRestorePtr
PrintTocDataPtrType PrintTocDataPtr
WriteBytePtrType WriteBytePtr
ReadBufPtrType ReadBufPtr
PrintExtraTocPtrType PrintExtraTocPtr
StartDataPtrType StartDataPtr
ReopenPtrType ReopenPtr
EndDataPtrType EndDataPtr
ClosePtrType ClosePtr
pgoff_t lastFilePos

References _ArchiveEntry(), _Clone(), _CloseArchive(), _DeClone(), _EndData(), _EndLO(), _EndLOs(), _getFilePos(), _PrepParallelRestore(), _PrintExtraToc(), _PrintTocData(), _ReadBuf(), _ReadByte(), _ReadExtraToc(), _ReopenArchive(), _StartData(), _StartLO(), _StartLOs(), _WorkerJobRestoreCustom(), _WriteBuf(), _WriteByte(), _WriteData(), _WriteExtraToc(), _archiveHandle::ArchiveEntryPtr, archModeWrite, checkSeek(), _archiveHandle::ClonePtr, _archiveHandle::ClosePtr, _archiveHandle::DeClonePtr, _archiveHandle::EndDataPtr, _archiveHandle::EndLOPtr, _archiveHandle::EndLOsPtr, _archiveHandle::FH, _archiveHandle::formatData, _archiveHandle::fSpec, lclContext::hasSeek, lclContext::lastFilePos, _archiveHandle::mode, PG_BINARY_R, PG_BINARY_W, pg_fatal, pg_malloc0(), _archiveHandle::PrepParallelRestorePtr, _archiveHandle::PrintExtraTocPtr, _archiveHandle::PrintTocDataPtr, _archiveHandle::ReadBufPtr, _archiveHandle::ReadBytePtr, _archiveHandle::ReadExtraTocPtr, ReadHead(), ReadToc(), _archiveHandle::ReopenPtr, _archiveHandle::StartDataPtr, _archiveHandle::StartLOPtr, _archiveHandle::StartLOsPtr, generate_unaccent_rules::stdout, _archiveHandle::WorkerJobDumpPtr, _archiveHandle::WorkerJobRestorePtr, _archiveHandle::WriteBufPtr, _archiveHandle::WriteBytePtr, _archiveHandle::WriteDataPtr, and _archiveHandle::WriteExtraTocPtr.

Referenced by _allocAH().

◆ InitArchiveFmt_Directory()

void InitArchiveFmt_Directory ( ArchiveHandle AH)

Definition at line 109 of file pg_backup_directory.c.

110{
111 lclContext *ctx;
112
113 /* Assuming static functions, this can be copied for each format. */
117 AH->EndDataPtr = _EndData;
121 AH->ReadBufPtr = _ReadBuf;
128
130 AH->StartLOPtr = _StartLO;
131 AH->EndLOPtr = _EndLO;
132 AH->EndLOsPtr = _EndLOs;
133
135 AH->ClonePtr = _Clone;
136 AH->DeClonePtr = _DeClone;
137
140
141 /* Set up our private context */
142 ctx = (lclContext *) pg_malloc0(sizeof(lclContext));
143 AH->formatData = ctx;
144
145 ctx->dataFH = NULL;
146 ctx->LOsTocFH = NULL;
147
148 /*
149 * Now open the TOC file
150 */
151
152 if (!AH->fSpec || strcmp(AH->fSpec, "") == 0)
153 pg_fatal("no output directory specified");
154
155 ctx->directory = AH->fSpec;
156
157 if (AH->mode == archModeWrite)
158 {
159 struct stat st;
160 bool is_empty = false;
161
162 /* we accept an empty existing directory */
163 if (stat(ctx->directory, &st) == 0 && S_ISDIR(st.st_mode))
164 {
165 DIR *dir = opendir(ctx->directory);
166
167 if (dir)
168 {
169 struct dirent *d;
170
171 is_empty = true;
172 while (errno = 0, (d = readdir(dir)))
173 {
174 if (strcmp(d->d_name, ".") != 0 && strcmp(d->d_name, "..") != 0)
175 {
176 is_empty = false;
177 break;
178 }
179 }
180
181 if (errno)
182 pg_fatal("could not read directory \"%s\": %m",
183 ctx->directory);
184
185 if (closedir(dir))
186 pg_fatal("could not close directory \"%s\": %m",
187 ctx->directory);
188 }
189 }
190
191 if (!is_empty && mkdir(ctx->directory, 0700) < 0)
192 pg_fatal("could not create directory \"%s\": %m",
193 ctx->directory);
194 }
195 else
196 { /* Read Mode */
197 char fname[MAXPGPATH];
198 CompressFileHandle *tocFH;
199
200 setFilePath(AH, fname, "toc.dat");
201
203 if (tocFH == NULL)
204 pg_fatal("could not open input file \"%s\": %m", fname);
205
206 ctx->dataFH = tocFH;
207
208 /*
209 * The TOC of a directory format dump shares the format code of the
210 * tar format.
211 */
212 AH->format = archTar;
213 ReadHead(AH);
214 AH->format = archDirectory;
215 ReadToc(AH);
216
217 /* Nothing else in the file, so close it again... */
218 if (!EndCompressFileHandle(tocFH))
219 pg_fatal("could not close TOC file: %m");
220 ctx->dataFH = NULL;
221 }
222}
bool EndCompressFileHandle(CompressFileHandle *CFH)
Definition: compress_io.c:288
CompressFileHandle * InitDiscoverCompressFileHandle(const char *path, const char *mode)
Definition: compress_io.c:240
int closedir(DIR *)
Definition: dirent.c:127
struct dirent * readdir(DIR *)
Definition: dirent.c:78
DIR * opendir(const char *)
Definition: dirent.c:33
@ archTar
Definition: pg_backup.h:43
@ archDirectory
Definition: pg_backup.h:45
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _StartData(ArchiveHandle *AH, TocEntry *te)
static void _PrintExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te)
static void _CloseArchive(ArchiveHandle *AH)
static void _DeClone(ArchiveHandle *AH)
static void _ReopenArchive(ArchiveHandle *AH)
static void _StartLOs(ArchiveHandle *AH, TocEntry *te)
static void _WriteExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _EndLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static void _EndLOs(ArchiveHandle *AH, TocEntry *te)
static int _WriteByte(ArchiveHandle *AH, const int i)
static void _PrepParallelRestore(ArchiveHandle *AH)
static void _StartLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static int _ReadByte(ArchiveHandle *AH)
static void _ReadExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _ReadBuf(ArchiveHandle *AH, void *buf, size_t len)
static void _EndData(ArchiveHandle *AH, TocEntry *te)
static void _Clone(ArchiveHandle *AH)
static int _WorkerJobRestoreDirectory(ArchiveHandle *AH, TocEntry *te)
static void setFilePath(ArchiveHandle *AH, char *buf, const char *relativeFilename)
static int _WorkerJobDumpDirectory(ArchiveHandle *AH, TocEntry *te)
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
#define MAXPGPATH
Definition: dirent.c:26
ArchiveFormat format
Definition: dirent.h:10
char d_name[MAX_PATH]
Definition: dirent.h:15
CompressFileHandle * LOsTocFH
CompressFileHandle * dataFH
#define stat
Definition: win32_port.h:274
#define S_ISDIR(m)
Definition: win32_port.h:315
#define mkdir(a, b)
Definition: win32_port.h:80

References _ArchiveEntry(), _Clone(), _CloseArchive(), _DeClone(), _EndData(), _EndLO(), _EndLOs(), _PrepParallelRestore(), _PrintExtraToc(), _PrintTocData(), _ReadBuf(), _ReadByte(), _ReadExtraToc(), _ReopenArchive(), _StartData(), _StartLO(), _StartLOs(), _WorkerJobDumpDirectory(), _WorkerJobRestoreDirectory(), _WriteBuf(), _WriteByte(), _WriteData(), _WriteExtraToc(), archDirectory, _archiveHandle::ArchiveEntryPtr, archModeWrite, archTar, _archiveHandle::ClonePtr, closedir(), _archiveHandle::ClosePtr, dirent::d_name, lclContext::dataFH, _archiveHandle::DeClonePtr, lclContext::directory, EndCompressFileHandle(), _archiveHandle::EndDataPtr, _archiveHandle::EndLOPtr, _archiveHandle::EndLOsPtr, _archiveHandle::format, _archiveHandle::formatData, _archiveHandle::fSpec, InitDiscoverCompressFileHandle(), lclContext::LOsTocFH, MAXPGPATH, mkdir, _archiveHandle::mode, opendir(), PG_BINARY_R, pg_fatal, pg_malloc0(), _archiveHandle::PrepParallelRestorePtr, _archiveHandle::PrintExtraTocPtr, _archiveHandle::PrintTocDataPtr, _archiveHandle::ReadBufPtr, _archiveHandle::ReadBytePtr, readdir(), _archiveHandle::ReadExtraTocPtr, ReadHead(), ReadToc(), _archiveHandle::ReopenPtr, S_ISDIR, setFilePath(), stat::st_mode, _archiveHandle::StartDataPtr, _archiveHandle::StartLOPtr, _archiveHandle::StartLOsPtr, stat, _archiveHandle::WorkerJobDumpPtr, _archiveHandle::WorkerJobRestorePtr, _archiveHandle::WriteBufPtr, _archiveHandle::WriteBytePtr, _archiveHandle::WriteDataPtr, and _archiveHandle::WriteExtraTocPtr.

Referenced by _allocAH().

◆ InitArchiveFmt_Null()

void InitArchiveFmt_Null ( ArchiveHandle AH)

Definition at line 48 of file pg_backup_null.c.

49{
50 /* Assuming static functions, this can be copied for each format. */
52 AH->EndDataPtr = _EndData;
56 AH->ReopenPtr = NULL;
58
60 AH->StartLOPtr = _StartLO;
61 AH->EndLOPtr = _EndLO;
62 AH->EndLOsPtr = _EndLOs;
63 AH->ClonePtr = NULL;
64 AH->DeClonePtr = NULL;
65
66 /*
67 * Now prevent reading...
68 */
69 if (AH->mode == archModeRead)
70 pg_fatal("this format cannot be read");
71}
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
static void _CloseArchive(ArchiveHandle *AH)
static void _StartLOs(ArchiveHandle *AH, TocEntry *te)
static void _EndLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static void _EndLOs(ArchiveHandle *AH, TocEntry *te)
static int _WriteByte(ArchiveHandle *AH, const int i)
static void _StartLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static void _EndData(ArchiveHandle *AH, TocEntry *te)
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)

References _CloseArchive(), _EndData(), _EndLO(), _EndLOs(), _PrintTocData(), _StartLO(), _StartLOs(), _WriteBuf(), _WriteByte(), _WriteData(), archModeRead, _archiveHandle::ClonePtr, _archiveHandle::ClosePtr, _archiveHandle::DeClonePtr, _archiveHandle::EndDataPtr, _archiveHandle::EndLOPtr, _archiveHandle::EndLOsPtr, _archiveHandle::mode, pg_fatal, _archiveHandle::PrintTocDataPtr, _archiveHandle::ReopenPtr, _archiveHandle::StartLOPtr, _archiveHandle::StartLOsPtr, _archiveHandle::WriteBufPtr, _archiveHandle::WriteBytePtr, and _archiveHandle::WriteDataPtr.

Referenced by _allocAH().

◆ InitArchiveFmt_Tar()

void InitArchiveFmt_Tar ( ArchiveHandle AH)

Definition at line 121 of file pg_backup_tar.c.

122{
123 lclContext *ctx;
124
125 /* Assuming static functions, this can be copied for each format. */
129 AH->EndDataPtr = _EndData;
133 AH->ReadBufPtr = _ReadBuf;
135 AH->ReopenPtr = NULL;
140
142 AH->StartLOPtr = _StartLO;
143 AH->EndLOPtr = _EndLO;
144 AH->EndLOsPtr = _EndLOs;
145 AH->ClonePtr = NULL;
146 AH->DeClonePtr = NULL;
147
148 AH->WorkerJobDumpPtr = NULL;
149 AH->WorkerJobRestorePtr = NULL;
150
151 /*
152 * Set up some special context used in compressing data.
153 */
155 AH->formatData = ctx;
156 ctx->filePos = 0;
157 ctx->isSpecialScript = 0;
158
159 /*
160 * Now open the tar file, and load the TOC if we're in read mode.
161 */
162 if (AH->mode == archModeWrite)
163 {
164 if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
165 {
166 ctx->tarFH = fopen(AH->fSpec, PG_BINARY_W);
167 if (ctx->tarFH == NULL)
168 pg_fatal("could not open TOC file \"%s\" for output: %m",
169 AH->fSpec);
170 }
171 else
172 {
173 ctx->tarFH = stdout;
174 if (ctx->tarFH == NULL)
175 pg_fatal("could not open TOC file for output: %m");
176 }
177
178 ctx->tarFHpos = 0;
179
180 /*
181 * Make unbuffered since we will dup() it, and the buffers screw each
182 * other
183 */
184 /* setvbuf(ctx->tarFH, NULL, _IONBF, 0); */
185
186 ctx->hasSeek = checkSeek(ctx->tarFH);
187
188 /*
189 * We don't support compression because reading the files back is not
190 * possible since gzdopen uses buffered IO which totally screws file
191 * positioning.
192 */
194 pg_fatal("compression is not supported by tar archive format");
195 }
196 else
197 { /* Read Mode */
198 if (AH->fSpec && strcmp(AH->fSpec, "") != 0)
199 {
200 ctx->tarFH = fopen(AH->fSpec, PG_BINARY_R);
201 if (ctx->tarFH == NULL)
202 pg_fatal("could not open TOC file \"%s\" for input: %m",
203 AH->fSpec);
204 }
205 else
206 {
207 ctx->tarFH = stdin;
208 if (ctx->tarFH == NULL)
209 pg_fatal("could not open TOC file for input: %m");
210 }
211
212 /*
213 * Make unbuffered since we will dup() it, and the buffers screw each
214 * other
215 */
216 /* setvbuf(ctx->tarFH, NULL, _IONBF, 0); */
217
218 ctx->tarFHpos = 0;
219
220 ctx->hasSeek = checkSeek(ctx->tarFH);
221
222 ctx->FH = tarOpen(AH, "toc.dat", 'r');
223 ReadHead(AH);
224 ReadToc(AH);
225 tarClose(AH, ctx->FH); /* Nothing else in the file... */
226 }
227}
@ PG_COMPRESSION_NONE
Definition: compression.h:23
#define pg_malloc0_object(type)
Definition: fe_memutils.h:51
static void _PrintTocData(ArchiveHandle *AH, TocEntry *te)
static void _StartData(ArchiveHandle *AH, TocEntry *te)
static void _PrintExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
static void _ArchiveEntry(ArchiveHandle *AH, TocEntry *te)
static void _CloseArchive(ArchiveHandle *AH)
static void _StartLOs(ArchiveHandle *AH, TocEntry *te)
static void _WriteExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _EndLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static void _EndLOs(ArchiveHandle *AH, TocEntry *te)
static int _WriteByte(ArchiveHandle *AH, const int i)
static void _StartLO(ArchiveHandle *AH, TocEntry *te, Oid oid)
static int _ReadByte(ArchiveHandle *AH)
static void _ReadExtraToc(ArchiveHandle *AH, TocEntry *te)
static void _ReadBuf(ArchiveHandle *AH, void *buf, size_t len)
static TAR_MEMBER * tarOpen(ArchiveHandle *AH, const char *filename, char mode)
static void _EndData(ArchiveHandle *AH, TocEntry *te)
static void _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
static void tarClose(ArchiveHandle *AH, TAR_MEMBER *th)
pg_compress_specification compression_spec
FILE * tarFH
Definition: pg_backup_tar.c:83
pgoff_t filePos
Definition: pg_backup_tar.c:81
pgoff_t tarFHpos
Definition: pg_backup_tar.c:84
TAR_MEMBER * FH
Definition: pg_backup_tar.c:86
int isSpecialScript
Definition: pg_backup_tar.c:87
pg_compress_algorithm algorithm
Definition: compression.h:34

References _ArchiveEntry(), _CloseArchive(), _EndData(), _EndLO(), _EndLOs(), _PrintExtraToc(), _PrintTocData(), _ReadBuf(), _ReadByte(), _ReadExtraToc(), _StartData(), _StartLO(), _StartLOs(), _WriteBuf(), _WriteByte(), _WriteData(), _WriteExtraToc(), archModeWrite, checkSeek(), lclContext::FH, lclContext::filePos, lclContext::hasSeek, lclContext::isSpecialScript, PG_BINARY_R, PG_BINARY_W, PG_COMPRESSION_NONE, pg_fatal, pg_malloc0_object, ReadHead(), ReadToc(), generate_unaccent_rules::stdout, tarClose(), lclContext::tarFH, lclContext::tarFHpos, and tarOpen().

Referenced by _allocAH().

◆ IssueACLPerBlob()

void IssueACLPerBlob ( ArchiveHandle AH,
TocEntry te 
)

Definition at line 597 of file pg_backup_db.c.

598{
599 TocEntry *blobte = getTocEntryByDumpId(AH, te->dependencies[0]);
600 char *buf;
601 char *st;
602 char *st2;
603 char *en;
604 bool inquotes;
605
606 if (!blobte)
607 pg_fatal("could not find entry for ID %d", te->dependencies[0]);
608 Assert(strcmp(blobte->desc, "BLOB METADATA") == 0);
609
610 /* Make a writable copy of the ACL commands string */
611 buf = pg_strdup(te->defn);
612
613 /*
614 * We have to parse out the commands sufficiently to locate the blob OIDs
615 * and find the command-ending semicolons. The commands should not
616 * contain anything hard to parse except for double-quoted role names,
617 * which are easy to ignore. Once we've split apart the first and second
618 * halves of a command, apply IssueCommandPerBlob. (This means the
619 * updates on the blobs are interleaved if there's multiple commands, but
620 * that should cause no trouble.)
621 */
622 inquotes = false;
623 st = en = buf;
624 st2 = NULL;
625 while (*en)
626 {
627 /* Ignore double-quoted material */
628 if (*en == '"')
629 inquotes = !inquotes;
630 if (inquotes)
631 {
632 en++;
633 continue;
634 }
635 /* If we found "LARGE OBJECT", that's the end of the first half */
636 if (strncmp(en, "LARGE OBJECT ", 13) == 0)
637 {
638 /* Terminate the first-half string */
639 en += 13;
640 Assert(isdigit((unsigned char) *en));
641 *en++ = '\0';
642 /* Skip the rest of the blob OID */
643 while (isdigit((unsigned char) *en))
644 en++;
645 /* Second half starts here */
646 Assert(st2 == NULL);
647 st2 = en;
648 }
649 /* If we found semicolon, that's the end of the second half */
650 else if (*en == ';')
651 {
652 /* Terminate the second-half string */
653 *en++ = '\0';
654 Assert(st2 != NULL);
655 /* Issue this command for each blob */
656 IssueCommandPerBlob(AH, blobte, st, st2);
657 /* For neatness, skip whitespace before the next command */
658 while (isspace((unsigned char) *en))
659 en++;
660 /* Reset for new command */
661 st = en;
662 st2 = NULL;
663 }
664 else
665 en++;
666 }
667 pg_free(buf);
668}
void pg_free(void *ptr)
Definition: fe_memutils.c:105
TocEntry * getTocEntryByDumpId(ArchiveHandle *AH, DumpId id)
void IssueCommandPerBlob(ArchiveHandle *AH, TocEntry *te, const char *cmdBegin, const char *cmdEnd)
Definition: pg_backup_db.c:550
static char * buf
Definition: pg_test_fsync.c:72

References Assert, buf, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, getTocEntryByDumpId(), IssueCommandPerBlob(), pg_fatal, pg_free(), and pg_strdup().

Referenced by _printTocEntry().

◆ IssueCommandPerBlob()

void IssueCommandPerBlob ( ArchiveHandle AH,
TocEntry te,
const char *  cmdBegin,
const char *  cmdEnd 
)

Definition at line 550 of file pg_backup_db.c.

552{
553 /* Make a writable copy of the command string */
554 char *buf = pg_strdup(te->defn);
555 RestoreOptions *ropt = AH->public.ropt;
556 char *st;
557 char *en;
558
559 st = buf;
560 while ((en = strchr(st, '\n')) != NULL)
561 {
562 *en++ = '\0';
563 ahprintf(AH, "%s%s%s;\n", cmdBegin, st, cmdEnd);
564
565 /* In --transaction-size mode, count each command as an action */
566 if (ropt && ropt->txn_size > 0)
567 {
568 if (++AH->txnCount >= ropt->txn_size)
569 {
570 if (AH->connection)
571 {
574 }
575 else
576 ahprintf(AH, "COMMIT;\nBEGIN;\n\n");
577 AH->txnCount = 0;
578 }
579 }
580
581 st = en;
582 }
583 ahprintf(AH, "\n");
584 pg_free(buf);
585}
void StartTransaction(Archive *AHX)
Definition: pg_backup_db.c:527
void CommitTransaction(Archive *AHX)
Definition: pg_backup_db.c:535

References ahprintf(), buf, CommitTransaction(), _archiveHandle::connection, _tocEntry::defn, pg_free(), pg_strdup(), _archiveHandle::public, Archive::ropt, StartTransaction(), _restoreOptions::txn_size, and _archiveHandle::txnCount.

Referenced by _printTocEntry(), IssueACLPerBlob(), and RestoreArchive().

◆ isValidTarHeader()

bool isValidTarHeader ( char *  header)

Definition at line 988 of file pg_backup_tar.c.

989{
990 int sum;
991 int chk = tarChecksum(header);
992
993 sum = read_tar_number(&header[TAR_OFFSET_CHECKSUM], 8);
994
995 if (sum != chk)
996 return false;
997
998 /* POSIX tar format */
999 if (memcmp(&header[TAR_OFFSET_MAGIC], "ustar\0", 6) == 0 &&
1000 memcmp(&header[TAR_OFFSET_VERSION], "00", 2) == 0)
1001 return true;
1002 /* GNU tar format */
1003 if (memcmp(&header[TAR_OFFSET_MAGIC], "ustar \0", 8) == 0)
1004 return true;
1005 /* not-quite-POSIX format written by pre-9.3 pg_dump */
1006 if (memcmp(&header[TAR_OFFSET_MAGIC], "ustar00\0", 8) == 0)
1007 return true;
1008
1009 return false;
1010}
uint64 read_tar_number(const char *s, int len)
Definition: tar.c:58
int tarChecksum(char *header)
Definition: tar.c:90
@ TAR_OFFSET_VERSION
Definition: pgtar.h:49
@ TAR_OFFSET_CHECKSUM
Definition: pgtar.h:45
@ TAR_OFFSET_MAGIC
Definition: pgtar.h:48

References read_tar_number(), TAR_OFFSET_CHECKSUM, TAR_OFFSET_MAGIC, TAR_OFFSET_VERSION, and tarChecksum().

Referenced by _discoverArchiveFormat().

◆ on_exit_close_archive()

void on_exit_close_archive ( Archive AHX)

Definition at line 330 of file parallel.c.

331{
332 shutdown_info.AHX = AHX;
334}
static void archive_close_connection(int code, void *arg)
Definition: parallel.c:341
static ShutdownInformation shutdown_info
Definition: parallel.c:154
void on_exit_nicely(on_exit_nicely_callback function, void *arg)

References ShutdownInformation::AHX, archive_close_connection(), on_exit_nicely(), and shutdown_info.

Referenced by main().

◆ parallel_restore()

int parallel_restore ( ArchiveHandle AH,
TocEntry te 
)

Definition at line 4622 of file pg_backup_archiver.c.

4623{
4624 int status;
4625
4626 Assert(AH->connection != NULL);
4627
4628 /* Count only errors associated with this TOC entry */
4629 AH->public.n_errors = 0;
4630
4631 /* Restore the TOC item */
4632 status = restore_toc_entry(AH, te, true);
4633
4634 return status;
4635}
static int restore_toc_entry(ArchiveHandle *AH, TocEntry *te, bool is_parallel)

References Assert, _archiveHandle::connection, Archive::n_errors, _archiveHandle::public, and restore_toc_entry().

Referenced by _WorkerJobRestoreCustom(), and _WorkerJobRestoreDirectory().

◆ ReadHead()

void ReadHead ( ArchiveHandle AH)

Definition at line 3988 of file pg_backup_archiver.c.

3989{
3990 char *errmsg;
3991 char vmaj,
3992 vmin,
3993 vrev;
3994 int fmt;
3995
3996 /*
3997 * If we haven't already read the header, do so.
3998 *
3999 * NB: this code must agree with _discoverArchiveFormat(). Maybe find a
4000 * way to unify the cases?
4001 */
4002 if (!AH->readHeader)
4003 {
4004 char tmpMag[7];
4005
4006 AH->ReadBufPtr(AH, tmpMag, 5);
4007
4008 if (strncmp(tmpMag, "PGDMP", 5) != 0)
4009 pg_fatal("did not find magic string in file header");
4010 }
4011
4012 vmaj = AH->ReadBytePtr(AH);
4013 vmin = AH->ReadBytePtr(AH);
4014
4015 if (vmaj > 1 || (vmaj == 1 && vmin > 0)) /* Version > 1.0 */
4016 vrev = AH->ReadBytePtr(AH);
4017 else
4018 vrev = 0;
4019
4020 AH->version = MAKE_ARCHIVE_VERSION(vmaj, vmin, vrev);
4021
4022 if (AH->version < K_VERS_1_0 || AH->version > K_VERS_MAX)
4023 pg_fatal("unsupported version (%d.%d) in file header",
4024 vmaj, vmin);
4025
4026 AH->intSize = AH->ReadBytePtr(AH);
4027 if (AH->intSize > 32)
4028 pg_fatal("sanity check on integer size (%lu) failed",
4029 (unsigned long) AH->intSize);
4030
4031 if (AH->intSize > sizeof(int))
4032 pg_log_warning("archive was made on a machine with larger integers, some operations might fail");
4033
4034 if (AH->version >= K_VERS_1_7)
4035 AH->offSize = AH->ReadBytePtr(AH);
4036 else
4037 AH->offSize = AH->intSize;
4038
4039 fmt = AH->ReadBytePtr(AH);
4040
4041 if (AH->format != fmt)
4042 pg_fatal("expected format (%d) differs from format found in file (%d)",
4043 AH->format, fmt);
4044
4045 if (AH->version >= K_VERS_1_15)
4047 else if (AH->version >= K_VERS_1_2)
4048 {
4049 /* Guess the compression method based on the level */
4050 if (AH->version < K_VERS_1_4)
4051 AH->compression_spec.level = AH->ReadBytePtr(AH);
4052 else
4053 AH->compression_spec.level = ReadInt(AH);
4054
4055 if (AH->compression_spec.level != 0)
4057 }
4058 else
4060
4062 if (errmsg)
4063 {
4064 pg_log_warning("archive is compressed, but this installation does not support compression (%s) -- no data will be available",
4065 errmsg);
4066 pg_free(errmsg);
4067 }
4068
4069 if (AH->version >= K_VERS_1_4)
4070 {
4071 struct tm crtm;
4072
4073 crtm.tm_sec = ReadInt(AH);
4074 crtm.tm_min = ReadInt(AH);
4075 crtm.tm_hour = ReadInt(AH);
4076 crtm.tm_mday = ReadInt(AH);
4077 crtm.tm_mon = ReadInt(AH);
4078 crtm.tm_year = ReadInt(AH);
4079 crtm.tm_isdst = ReadInt(AH);
4080
4081 /*
4082 * Newer versions of glibc have mktime() report failure if tm_isdst is
4083 * inconsistent with the prevailing timezone, e.g. tm_isdst = 1 when
4084 * TZ=UTC. This is problematic when restoring an archive under a
4085 * different timezone setting. If we get a failure, try again with
4086 * tm_isdst set to -1 ("don't know").
4087 *
4088 * XXX with or without this hack, we reconstruct createDate
4089 * incorrectly when the prevailing timezone is different from
4090 * pg_dump's. Next time we bump the archive version, we should flush
4091 * this representation and store a plain seconds-since-the-Epoch
4092 * timestamp instead.
4093 */
4094 AH->createDate = mktime(&crtm);
4095 if (AH->createDate == (time_t) -1)
4096 {
4097 crtm.tm_isdst = -1;
4098 AH->createDate = mktime(&crtm);
4099 if (AH->createDate == (time_t) -1)
4100 pg_log_warning("invalid creation date in header");
4101 }
4102 }
4103
4104 if (AH->version >= K_VERS_1_4)
4105 {
4106 AH->archdbname = ReadStr(AH);
4107 }
4108
4109 if (AH->version >= K_VERS_1_10)
4110 {
4111 AH->archiveRemoteVersion = ReadStr(AH);
4112 AH->archiveDumpVersion = ReadStr(AH);
4113 }
4114}
char * supports_compression(const pg_compress_specification compression_spec)
Definition: compress_io.c:87
@ PG_COMPRESSION_GZIP
Definition: compression.h:24
int errmsg(const char *fmt,...)
Definition: elog.c:1070
static void const char * fmt
static struct pg_tm tm
Definition: localtime.c:104
char * ReadStr(ArchiveHandle *AH)
int ReadInt(ArchiveHandle *AH)
#define K_VERS_1_15
#define K_VERS_1_10
#define K_VERS_1_2
#define K_VERS_1_4
#define K_VERS_1_0
#define K_VERS_MAX
#define K_VERS_1_7
#define pg_log_warning(...)
Definition: pgfnames.c:24
int tm_sec
Definition: pgtime.h:36

References pg_compress_specification::algorithm, _archiveHandle::archdbname, _archiveHandle::archiveDumpVersion, _archiveHandle::archiveRemoteVersion, _archiveHandle::compression_spec, _archiveHandle::createDate, errmsg(), fmt, _archiveHandle::format, _archiveHandle::intSize, K_VERS_1_0, K_VERS_1_10, K_VERS_1_15, K_VERS_1_2, K_VERS_1_4, K_VERS_1_7, K_VERS_MAX, pg_compress_specification::level, MAKE_ARCHIVE_VERSION, _archiveHandle::offSize, PG_COMPRESSION_GZIP, pg_fatal, pg_free(), pg_log_warning, _archiveHandle::ReadBufPtr, _archiveHandle::ReadBytePtr, _archiveHandle::readHeader, ReadInt(), ReadStr(), supports_compression(), tm, pg_tm::tm_sec, and _archiveHandle::version.

Referenced by InitArchiveFmt_Custom(), InitArchiveFmt_Directory(), and InitArchiveFmt_Tar().

◆ ReadInt()

int ReadInt ( ArchiveHandle AH)

Definition at line 2128 of file pg_backup_archiver.c.

2129{
2130 int res = 0;
2131 int bv,
2132 b;
2133 int sign = 0; /* Default positive */
2134 int bitShift = 0;
2135
2136 if (AH->version > K_VERS_1_0)
2137 /* Read a sign byte */
2138 sign = AH->ReadBytePtr(AH);
2139
2140 for (b = 0; b < AH->intSize; b++)
2141 {
2142 bv = AH->ReadBytePtr(AH) & 0xFF;
2143 if (bv != 0)
2144 res = res + (bv << bitShift);
2145 bitShift += 8;
2146 }
2147
2148 if (sign)
2149 res = -res;
2150
2151 return res;
2152}
char sign
Definition: informix.c:693
int b
Definition: isn.c:69

References b, _archiveHandle::intSize, K_VERS_1_0, _archiveHandle::ReadBytePtr, res, sign, and _archiveHandle::version.

Referenced by _CustomReadFunc(), _LoadLOs(), _readBlockHeader(), _ReadExtraToc(), _skipData(), _skipLOs(), ReadHead(), ReadOffset(), ReadStr(), and ReadToc().

◆ ReadOffset()

int ReadOffset ( ArchiveHandle AH,
pgoff_t o 
)

Definition at line 2033 of file pg_backup_archiver.c.

2034{
2035 int i;
2036 int off;
2037 int offsetFlg;
2038
2039 /* Initialize to zero */
2040 *o = 0;
2041
2042 /* Check for old version */
2043 if (AH->version < K_VERS_1_7)
2044 {
2045 /* Prior versions wrote offsets using WriteInt */
2046 i = ReadInt(AH);
2047 /* -1 means not set */
2048 if (i < 0)
2049 return K_OFFSET_POS_NOT_SET;
2050 else if (i == 0)
2051 return K_OFFSET_NO_DATA;
2052
2053 /* Cast to pgoff_t because it was written as an int. */
2054 *o = (pgoff_t) i;
2055 return K_OFFSET_POS_SET;
2056 }
2057
2058 /*
2059 * Read the flag indicating the state of the data pointer. Check if valid
2060 * and die if not.
2061 *
2062 * This used to be handled by a negative or zero pointer, now we use an
2063 * extra byte specifically for the state.
2064 */
2065 offsetFlg = AH->ReadBytePtr(AH) & 0xFF;
2066
2067 switch (offsetFlg)
2068 {
2070 case K_OFFSET_NO_DATA:
2071 case K_OFFSET_POS_SET:
2072
2073 break;
2074
2075 default:
2076 pg_fatal("unexpected data offset flag %d", offsetFlg);
2077 }
2078
2079 /*
2080 * Read the bytes
2081 */
2082 for (off = 0; off < AH->offSize; off++)
2083 {
2084 if (off < sizeof(pgoff_t))
2085 *o |= ((pgoff_t) (AH->ReadBytePtr(AH))) << (off * 8);
2086 else
2087 {
2088 if (AH->ReadBytePtr(AH) != 0)
2089 pg_fatal("file offset in dump file is too large");
2090 }
2091 }
2092
2093 return offsetFlg;
2094}
int i
Definition: isn.c:72
#define K_OFFSET_NO_DATA
#define K_OFFSET_POS_NOT_SET
#define K_OFFSET_POS_SET

References i, K_OFFSET_NO_DATA, K_OFFSET_POS_NOT_SET, K_OFFSET_POS_SET, K_VERS_1_7, _archiveHandle::offSize, pg_fatal, pgoff_t, _archiveHandle::ReadBytePtr, ReadInt(), and _archiveHandle::version.

Referenced by _ReadExtraToc().

◆ ReadStr()

char * ReadStr ( ArchiveHandle AH)

Definition at line 2174 of file pg_backup_archiver.c.

2175{
2176 char *buf;
2177 int l;
2178
2179 l = ReadInt(AH);
2180 if (l < 0)
2181 buf = NULL;
2182 else
2183 {
2184 buf = (char *) pg_malloc(l + 1);
2185 AH->ReadBufPtr(AH, buf, l);
2186
2187 buf[l] = '\0';
2188 }
2189
2190 return buf;
2191}

References buf, pg_malloc(), _archiveHandle::ReadBufPtr, and ReadInt().

Referenced by _ReadExtraToc(), ReadHead(), and ReadToc().

◆ ReadToc()

void ReadToc ( ArchiveHandle AH)

Definition at line 2634 of file pg_backup_archiver.c.

2635{
2636 int i;
2637 char *tmp;
2638 DumpId *deps;
2639 int depIdx;
2640 int depSize;
2641 TocEntry *te;
2642 bool is_supported;
2643
2644 AH->tocCount = ReadInt(AH);
2645 AH->maxDumpId = 0;
2646
2647 for (i = 0; i < AH->tocCount; i++)
2648 {
2649 te = (TocEntry *) pg_malloc0(sizeof(TocEntry));
2650 te->dumpId = ReadInt(AH);
2651
2652 if (te->dumpId > AH->maxDumpId)
2653 AH->maxDumpId = te->dumpId;
2654
2655 /* Sanity check */
2656 if (te->dumpId <= 0)
2657 pg_fatal("entry ID %d out of range -- perhaps a corrupt TOC",
2658 te->dumpId);
2659
2660 te->hadDumper = ReadInt(AH);
2661
2662 if (AH->version >= K_VERS_1_8)
2663 {
2664 tmp = ReadStr(AH);
2665 sscanf(tmp, "%u", &te->catalogId.tableoid);
2666 free(tmp);
2667 }
2668 else
2670 tmp = ReadStr(AH);
2671 sscanf(tmp, "%u", &te->catalogId.oid);
2672 free(tmp);
2673
2674 te->tag = ReadStr(AH);
2675 te->desc = ReadStr(AH);
2676
2677 if (AH->version >= K_VERS_1_11)
2678 {
2679 te->section = ReadInt(AH);
2680 }
2681 else
2682 {
2683 /*
2684 * Rules for pre-8.4 archives wherein pg_dump hasn't classified
2685 * the entries into sections. This list need not cover entry
2686 * types added later than 8.4.
2687 */
2688 if (strcmp(te->desc, "COMMENT") == 0 ||
2689 strcmp(te->desc, "ACL") == 0 ||
2690 strcmp(te->desc, "ACL LANGUAGE") == 0)
2691 te->section = SECTION_NONE;
2692 else if (strcmp(te->desc, "TABLE DATA") == 0 ||
2693 strcmp(te->desc, "BLOBS") == 0 ||
2694 strcmp(te->desc, "BLOB COMMENTS") == 0)
2695 te->section = SECTION_DATA;
2696 else if (strcmp(te->desc, "CONSTRAINT") == 0 ||
2697 strcmp(te->desc, "CHECK CONSTRAINT") == 0 ||
2698 strcmp(te->desc, "FK CONSTRAINT") == 0 ||
2699 strcmp(te->desc, "INDEX") == 0 ||
2700 strcmp(te->desc, "RULE") == 0 ||
2701 strcmp(te->desc, "TRIGGER") == 0)
2703 else
2705 }
2706
2707 te->defn = ReadStr(AH);
2708 te->dropStmt = ReadStr(AH);
2709
2710 if (AH->version >= K_VERS_1_3)
2711 te->copyStmt = ReadStr(AH);
2712
2713 if (AH->version >= K_VERS_1_6)
2714 te->namespace = ReadStr(AH);
2715
2716 if (AH->version >= K_VERS_1_10)
2717 te->tablespace = ReadStr(AH);
2718
2719 if (AH->version >= K_VERS_1_14)
2720 te->tableam = ReadStr(AH);
2721
2722 if (AH->version >= K_VERS_1_16)
2723 te->relkind = ReadInt(AH);
2724
2725 te->owner = ReadStr(AH);
2726 is_supported = true;
2727 if (AH->version < K_VERS_1_9)
2728 is_supported = false;
2729 else
2730 {
2731 tmp = ReadStr(AH);
2732
2733 if (strcmp(tmp, "true") == 0)
2734 is_supported = false;
2735
2736 free(tmp);
2737 }
2738
2739 if (!is_supported)
2740 pg_log_warning("restoring tables WITH OIDS is not supported anymore");
2741
2742 /* Read TOC entry dependencies */
2743 if (AH->version >= K_VERS_1_5)
2744 {
2745 depSize = 100;
2746 deps = (DumpId *) pg_malloc(sizeof(DumpId) * depSize);
2747 depIdx = 0;
2748 for (;;)
2749 {
2750 tmp = ReadStr(AH);
2751 if (!tmp)
2752 break; /* end of list */
2753 if (depIdx >= depSize)
2754 {
2755 depSize *= 2;
2756 deps = (DumpId *) pg_realloc(deps, sizeof(DumpId) * depSize);
2757 }
2758 sscanf(tmp, "%d", &deps[depIdx]);
2759 free(tmp);
2760 depIdx++;
2761 }
2762
2763 if (depIdx > 0) /* We have a non-null entry */
2764 {
2765 deps = (DumpId *) pg_realloc(deps, sizeof(DumpId) * depIdx);
2766 te->dependencies = deps;
2767 te->nDeps = depIdx;
2768 }
2769 else
2770 {
2771 free(deps);
2772 te->dependencies = NULL;
2773 te->nDeps = 0;
2774 }
2775 }
2776 else
2777 {
2778 te->dependencies = NULL;
2779 te->nDeps = 0;
2780 }
2781 te->dataLength = 0;
2782
2783 if (AH->ReadExtraTocPtr)
2784 AH->ReadExtraTocPtr(AH, te);
2785
2786 pg_log_debug("read TOC entry %d (ID %d) for %s %s",
2787 i, te->dumpId, te->desc, te->tag);
2788
2789 /* link completed entry into TOC circular list */
2790 te->prev = AH->toc->prev;
2791 AH->toc->prev->next = te;
2792 AH->toc->prev = te;
2793 te->next = AH->toc;
2794
2795 /* special processing immediately upon read for some items */
2796 if (strcmp(te->desc, "ENCODING") == 0)
2797 processEncodingEntry(AH, te);
2798 else if (strcmp(te->desc, "STDSTRINGS") == 0)
2799 processStdStringsEntry(AH, te);
2800 else if (strcmp(te->desc, "SEARCHPATH") == 0)
2801 processSearchPathEntry(AH, te);
2802 }
2803}
void * pg_realloc(void *ptr, size_t size)
Definition: fe_memutils.c:65
#define pg_log_debug(...)
Definition: logging.h:133
@ SECTION_NONE
Definition: pg_backup.h:57
@ SECTION_POST_DATA
Definition: pg_backup.h:60
@ SECTION_PRE_DATA
Definition: pg_backup.h:58
@ SECTION_DATA
Definition: pg_backup.h:59
static void processEncodingEntry(ArchiveHandle *AH, TocEntry *te)
static void processSearchPathEntry(ArchiveHandle *AH, TocEntry *te)
static void processStdStringsEntry(ArchiveHandle *AH, TocEntry *te)
#define K_VERS_1_14
#define K_VERS_1_5
#define K_VERS_1_6
#define K_VERS_1_8
#define K_VERS_1_11
#define K_VERS_1_9
#define K_VERS_1_16
#define K_VERS_1_3
#define InvalidOid
Definition: postgres_ext.h:37
Oid tableoid
Definition: pg_backup.h:271

References _tocEntry::catalogId, _tocEntry::copyStmt, _tocEntry::dataLength, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dropStmt, _tocEntry::dumpId, free, _tocEntry::hadDumper, i, InvalidOid, K_VERS_1_10, K_VERS_1_11, K_VERS_1_14, K_VERS_1_16, K_VERS_1_3, K_VERS_1_5, K_VERS_1_6, K_VERS_1_8, K_VERS_1_9, _archiveHandle::maxDumpId, _tocEntry::nDeps, _tocEntry::next, CatalogId::oid, _tocEntry::owner, pg_fatal, pg_log_debug, pg_log_warning, pg_malloc(), pg_malloc0(), pg_realloc(), _tocEntry::prev, processEncodingEntry(), processSearchPathEntry(), processStdStringsEntry(), _archiveHandle::ReadExtraTocPtr, ReadInt(), ReadStr(), _tocEntry::relkind, _tocEntry::section, SECTION_DATA, SECTION_NONE, SECTION_POST_DATA, SECTION_PRE_DATA, _tocEntry::tableam, CatalogId::tableoid, _tocEntry::tablespace, _tocEntry::tag, _archiveHandle::toc, _archiveHandle::tocCount, and _archiveHandle::version.

Referenced by InitArchiveFmt_Custom(), InitArchiveFmt_Directory(), and InitArchiveFmt_Tar().

◆ ReconnectToServer()

void ReconnectToServer ( ArchiveHandle AH,
const char *  dbname 
)

Definition at line 72 of file pg_backup_db.c.

73{
74 PGconn *oldConn = AH->connection;
75 RestoreOptions *ropt = AH->public.ropt;
76
77 /*
78 * Save the dbname, if given, in override_dbname so that it will also
79 * affect any later reconnection attempt.
80 */
81 if (dbname)
83
84 /*
85 * Note: we want to establish the new connection, and in particular update
86 * ArchiveHandle's connCancel, before closing old connection. Otherwise
87 * an ill-timed SIGINT could try to access a dead connection.
88 */
89 AH->connection = NULL; /* dodge error check in ConnectDatabase */
90
91 ConnectDatabase((Archive *) AH, &ropt->cparams, true);
92
93 PQfinish(oldConn);
94}
void PQfinish(PGconn *conn)
Definition: fe-connect.c:5178
void ConnectDatabase(Archive *AHX, const ConnParams *cparams, bool isReconnect)
Definition: pg_backup_db.c:108
char * dbname
Definition: streamutil.c:50
char * override_dbname
Definition: pg_backup.h:92

References ConnectDatabase(), _archiveHandle::connection, _restoreOptions::cparams, dbname, _connParams::override_dbname, pg_strdup(), PQfinish(), _archiveHandle::public, and Archive::ropt.

Referenced by _reconnectToDB().

◆ StartRestoreLO()

void StartRestoreLO ( ArchiveHandle AH,
Oid  oid,
bool  drop 
)

Definition at line 1457 of file pg_backup_archiver.c.

1458{
1459 bool old_lo_style = (AH->version < K_VERS_1_12);
1460 Oid loOid;
1461
1462 AH->loCount++;
1463
1464 /* Initialize the LO Buffer */
1465 if (AH->lo_buf == NULL)
1466 {
1467 /* First time through (in this process) so allocate the buffer */
1468 AH->lo_buf_size = LOBBUFSIZE;
1470 }
1471 AH->lo_buf_used = 0;
1472
1473 pg_log_info("restoring large object with OID %u", oid);
1474
1475 /* With an old archive we must do drop and create logic here */
1476 if (old_lo_style && drop)
1477 DropLOIfExists(AH, oid);
1478
1479 if (AH->connection)
1480 {
1481 if (old_lo_style)
1482 {
1483 loOid = lo_create(AH->connection, oid);
1484 if (loOid == 0 || loOid != oid)
1485 pg_fatal("could not create large object %u: %s",
1486 oid, PQerrorMessage(AH->connection));
1487 }
1488 AH->loFd = lo_open(AH->connection, oid, INV_WRITE);
1489 if (AH->loFd == -1)
1490 pg_fatal("could not open large object %u: %s",
1491 oid, PQerrorMessage(AH->connection));
1492 }
1493 else
1494 {
1495 if (old_lo_style)
1496 ahprintf(AH, "SELECT pg_catalog.lo_open(pg_catalog.lo_create('%u'), %d);\n",
1497 oid, INV_WRITE);
1498 else
1499 ahprintf(AH, "SELECT pg_catalog.lo_open('%u', %d);\n",
1500 oid, INV_WRITE);
1501 }
1502
1503 AH->writingLO = true;
1504}
char * PQerrorMessage(const PGconn *conn)
Definition: fe-connect.c:7507
int lo_open(PGconn *conn, Oid lobjId, int mode)
Definition: fe-lobj.c:57
Oid lo_create(PGconn *conn, Oid lobjId)
Definition: fe-lobj.c:474
#define INV_WRITE
Definition: libpq-fs.h:21
#define LOBBUFSIZE
void DropLOIfExists(ArchiveHandle *AH, Oid oid)
Definition: pg_backup_db.c:671
#define K_VERS_1_12
unsigned int Oid
Definition: postgres_ext.h:32

References ahprintf(), _archiveHandle::connection, DropLOIfExists(), INV_WRITE, K_VERS_1_12, _archiveHandle::lo_buf, _archiveHandle::lo_buf_size, _archiveHandle::lo_buf_used, lo_create(), lo_open(), LOBBUFSIZE, _archiveHandle::loCount, _archiveHandle::loFd, pg_fatal, pg_log_info, pg_malloc(), PQerrorMessage(), _archiveHandle::version, and _archiveHandle::writingLO.

Referenced by _LoadLOs().

◆ StartRestoreLOs()

void StartRestoreLOs ( ArchiveHandle AH)

Definition at line 1410 of file pg_backup_archiver.c.

1411{
1412 RestoreOptions *ropt = AH->public.ropt;
1413
1414 /*
1415 * LOs must be restored within a transaction block, since we need the LO
1416 * handle to stay open while we write it. Establish a transaction unless
1417 * there's one being used globally.
1418 */
1419 if (!(ropt->single_txn || ropt->txn_size > 0))
1420 {
1421 if (AH->connection)
1423 else
1424 ahprintf(AH, "BEGIN;\n\n");
1425 }
1426
1427 AH->loCount = 0;
1428}
static void StartTransaction(void)
Definition: xact.c:2063

References ahprintf(), _archiveHandle::connection, _archiveHandle::loCount, _archiveHandle::public, Archive::ropt, _restoreOptions::single_txn, StartTransaction(), and _restoreOptions::txn_size.

Referenced by _LoadLOs().

◆ TocIDRequired()

int TocIDRequired ( ArchiveHandle AH,
DumpId  id 
)

Definition at line 2005 of file pg_backup_archiver.c.

2006{
2007 TocEntry *te = getTocEntryByDumpId(AH, id);
2008
2009 if (!te)
2010 return 0;
2011
2012 return te->reqs;
2013}

References getTocEntryByDumpId(), and _tocEntry::reqs.

Referenced by _tarPositionTo(), and findDumpableDependencies().

◆ warn_or_exit_horribly()

void warn_or_exit_horribly ( ArchiveHandle AH,
const char *  fmt,
  ... 
)

◆ WriteDataChunks()

void WriteDataChunks ( ArchiveHandle AH,
struct ParallelState pstate 
)

Definition at line 2460 of file pg_backup_archiver.c.

2461{
2462 TocEntry *te;
2463
2464 if (pstate && pstate->numWorkers > 1)
2465 {
2466 /*
2467 * In parallel mode, this code runs in the leader process. We
2468 * construct an array of candidate TEs, then sort it into decreasing
2469 * size order, then dispatch each TE to a data-transfer worker. By
2470 * dumping larger tables first, we avoid getting into a situation
2471 * where we're down to one job and it's big, losing parallelism.
2472 */
2473 TocEntry **tes;
2474 int ntes;
2475
2476 tes = (TocEntry **) pg_malloc(AH->tocCount * sizeof(TocEntry *));
2477 ntes = 0;
2478 for (te = AH->toc->next; te != AH->toc; te = te->next)
2479 {
2480 /* Consider only TEs with dataDumper functions ... */
2481 if (!te->dataDumper)
2482 continue;
2483 /* ... and ignore ones not enabled for dump */
2484 if ((te->reqs & REQ_DATA) == 0)
2485 continue;
2486
2487 tes[ntes++] = te;
2488 }
2489
2490 if (ntes > 1)
2491 qsort(tes, ntes, sizeof(TocEntry *), TocEntrySizeCompareQsort);
2492
2493 for (int i = 0; i < ntes; i++)
2494 DispatchJobForTocEntry(AH, pstate, tes[i], ACT_DUMP,
2495 mark_dump_job_done, NULL);
2496
2497 pg_free(tes);
2498
2499 /* Now wait for workers to finish. */
2500 WaitForWorkers(AH, pstate, WFW_ALL_IDLE);
2501 }
2502 else
2503 {
2504 /* Non-parallel mode: just dump all candidate TEs sequentially. */
2505 for (te = AH->toc->next; te != AH->toc; te = te->next)
2506 {
2507 /* Must have same filter conditions as above */
2508 if (!te->dataDumper)
2509 continue;
2510 if ((te->reqs & REQ_DATA) == 0)
2511 continue;
2512
2514 }
2515 }
2516}
void WaitForWorkers(ArchiveHandle *AH, ParallelState *pstate, WFW_WaitOption mode)
Definition: parallel.c:1453
void DispatchJobForTocEntry(ArchiveHandle *AH, ParallelState *pstate, TocEntry *te, T_Action act, ParallelCompletionPtr callback, void *callback_data)
Definition: parallel.c:1207
@ WFW_ALL_IDLE
Definition: parallel.h:35
void WriteDataChunksForTocEntry(ArchiveHandle *AH, TocEntry *te)
static int TocEntrySizeCompareQsort(const void *p1, const void *p2)
static void mark_dump_job_done(ArchiveHandle *AH, TocEntry *te, int status, void *callback_data)
@ ACT_DUMP
#define REQ_DATA
#define qsort(a, b, c, d)
Definition: port.h:475
int numWorkers
Definition: parallel.h:57

References ACT_DUMP, _tocEntry::dataDumper, DispatchJobForTocEntry(), i, mark_dump_job_done(), _tocEntry::next, ParallelState::numWorkers, pg_free(), pg_malloc(), qsort, REQ_DATA, _tocEntry::reqs, _archiveHandle::toc, _archiveHandle::tocCount, TocEntrySizeCompareQsort(), WaitForWorkers(), WFW_ALL_IDLE, and WriteDataChunksForTocEntry().

Referenced by _CloseArchive().

◆ WriteDataChunksForTocEntry()

void WriteDataChunksForTocEntry ( ArchiveHandle AH,
TocEntry te 
)

Definition at line 2541 of file pg_backup_archiver.c.

2542{
2543 StartDataPtrType startPtr;
2544 EndDataPtrType endPtr;
2545
2546 AH->currToc = te;
2547
2548 if (strcmp(te->desc, "BLOBS") == 0)
2549 {
2550 startPtr = AH->StartLOsPtr;
2551 endPtr = AH->EndLOsPtr;
2552 }
2553 else
2554 {
2555 startPtr = AH->StartDataPtr;
2556 endPtr = AH->EndDataPtr;
2557 }
2558
2559 if (startPtr != NULL)
2560 (*startPtr) (AH, te);
2561
2562 /*
2563 * The user-provided DataDumper routine needs to call AH->WriteData
2564 */
2565 te->dataDumper((Archive *) AH, te->dataDumperArg);
2566
2567 if (endPtr != NULL)
2568 (*endPtr) (AH, te);
2569
2570 AH->currToc = NULL;
2571}
void(* EndDataPtrType)(ArchiveHandle *AH, TocEntry *te)
void(* StartDataPtrType)(ArchiveHandle *AH, TocEntry *te)
struct _tocEntry * currToc

References _archiveHandle::currToc, _tocEntry::dataDumper, _tocEntry::dataDumperArg, _tocEntry::desc, _archiveHandle::EndDataPtr, _archiveHandle::EndLOsPtr, _archiveHandle::StartDataPtr, and _archiveHandle::StartLOsPtr.

Referenced by _WorkerJobDumpDirectory(), and WriteDataChunks().

◆ WriteHead()

void WriteHead ( ArchiveHandle AH)

Definition at line 3962 of file pg_backup_archiver.c.

3963{
3964 struct tm crtm;
3965
3966 AH->WriteBufPtr(AH, "PGDMP", 5); /* Magic code */
3967 AH->WriteBytePtr(AH, ARCHIVE_MAJOR(AH->version));
3968 AH->WriteBytePtr(AH, ARCHIVE_MINOR(AH->version));
3969 AH->WriteBytePtr(AH, ARCHIVE_REV(AH->version));
3970 AH->WriteBytePtr(AH, AH->intSize);
3971 AH->WriteBytePtr(AH, AH->offSize);
3972 AH->WriteBytePtr(AH, AH->format);
3974 crtm = *localtime(&AH->createDate);
3975 WriteInt(AH, crtm.tm_sec);
3976 WriteInt(AH, crtm.tm_min);
3977 WriteInt(AH, crtm.tm_hour);
3978 WriteInt(AH, crtm.tm_mday);
3979 WriteInt(AH, crtm.tm_mon);
3980 WriteInt(AH, crtm.tm_year);
3981 WriteInt(AH, crtm.tm_isdst);
3982 WriteStr(AH, PQdb(AH->connection));
3984 WriteStr(AH, PG_VERSION);
3985}
char * PQdb(const PGconn *conn)
Definition: fe-connect.c:7335
size_t WriteInt(ArchiveHandle *AH, int i)
size_t WriteStr(ArchiveHandle *AH, const char *c)
#define ARCHIVE_MAJOR(version)
#define ARCHIVE_MINOR(version)
#define ARCHIVE_REV(version)
char * remoteVersionStr
Definition: pg_backup.h:223

References pg_compress_specification::algorithm, ARCHIVE_MAJOR, ARCHIVE_MINOR, ARCHIVE_REV, _archiveHandle::compression_spec, _archiveHandle::connection, _archiveHandle::createDate, _archiveHandle::format, _archiveHandle::intSize, _archiveHandle::offSize, PQdb(), _archiveHandle::public, Archive::remoteVersionStr, tm, _archiveHandle::version, _archiveHandle::WriteBufPtr, _archiveHandle::WriteBytePtr, WriteInt(), and WriteStr().

Referenced by _CloseArchive().

◆ WriteInt()

size_t WriteInt ( ArchiveHandle AH,
int  i 
)

Definition at line 2097 of file pg_backup_archiver.c.

2098{
2099 int b;
2100
2101 /*
2102 * This is a bit yucky, but I don't want to make the binary format very
2103 * dependent on representation, and not knowing much about it, I write out
2104 * a sign byte. If you change this, don't forget to change the file
2105 * version #, and modify ReadInt to read the new format AS WELL AS the old
2106 * formats.
2107 */
2108
2109 /* SIGN byte */
2110 if (i < 0)
2111 {
2112 AH->WriteBytePtr(AH, 1);
2113 i = -i;
2114 }
2115 else
2116 AH->WriteBytePtr(AH, 0);
2117
2118 for (b = 0; b < AH->intSize; b++)
2119 {
2120 AH->WriteBytePtr(AH, i & 0xFF);
2121 i >>= 8;
2122 }
2123
2124 return AH->intSize + 1;
2125}

References b, i, _archiveHandle::intSize, and _archiveHandle::WriteBytePtr.

Referenced by _CustomWriteFunc(), _EndData(), _EndLO(), _EndLOs(), _StartData(), _StartLO(), _StartLOs(), WriteHead(), WriteStr(), and WriteToc().

◆ WriteOffset()

size_t WriteOffset ( ArchiveHandle AH,
pgoff_t  o,
int  wasSet 
)

Definition at line 2016 of file pg_backup_archiver.c.

2017{
2018 int off;
2019
2020 /* Save the flag */
2021 AH->WriteBytePtr(AH, wasSet);
2022
2023 /* Write out pgoff_t smallest byte first, prevents endian mismatch */
2024 for (off = 0; off < sizeof(pgoff_t); off++)
2025 {
2026 AH->WriteBytePtr(AH, o & 0xFF);
2027 o >>= 8;
2028 }
2029 return sizeof(pgoff_t) + 1;
2030}

References pgoff_t, and _archiveHandle::WriteBytePtr.

Referenced by _WriteExtraToc().

◆ WriteStr()

size_t WriteStr ( ArchiveHandle AH,
const char *  c 
)

Definition at line 2155 of file pg_backup_archiver.c.

2156{
2157 size_t res;
2158
2159 if (c)
2160 {
2161 int len = strlen(c);
2162
2163 res = WriteInt(AH, len);
2164 AH->WriteBufPtr(AH, c, len);
2165 res += len;
2166 }
2167 else
2168 res = WriteInt(AH, -1);
2169
2170 return res;
2171}
const void size_t len
char * c

References len, res, _archiveHandle::WriteBufPtr, and WriteInt().

Referenced by _WriteExtraToc(), WriteHead(), and WriteToc().

◆ WriteToc()

void WriteToc ( ArchiveHandle AH)

Definition at line 2574 of file pg_backup_archiver.c.

2575{
2576 TocEntry *te;
2577 char workbuf[32];
2578 int tocCount;
2579 int i;
2580
2581 /* count entries that will actually be dumped */
2582 tocCount = 0;
2583 for (te = AH->toc->next; te != AH->toc; te = te->next)
2584 {
2585 if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) != 0)
2586 tocCount++;
2587 }
2588
2589 /* printf("%d TOC Entries to save\n", tocCount); */
2590
2591 WriteInt(AH, tocCount);
2592
2593 for (te = AH->toc->next; te != AH->toc; te = te->next)
2594 {
2595 if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) == 0)
2596 continue;
2597
2598 WriteInt(AH, te->dumpId);
2599 WriteInt(AH, te->dataDumper ? 1 : 0);
2600
2601 /* OID is recorded as a string for historical reasons */
2602 sprintf(workbuf, "%u", te->catalogId.tableoid);
2603 WriteStr(AH, workbuf);
2604 sprintf(workbuf, "%u", te->catalogId.oid);
2605 WriteStr(AH, workbuf);
2606
2607 WriteStr(AH, te->tag);
2608 WriteStr(AH, te->desc);
2609 WriteInt(AH, te->section);
2610 WriteStr(AH, te->defn);
2611 WriteStr(AH, te->dropStmt);
2612 WriteStr(AH, te->copyStmt);
2613 WriteStr(AH, te->namespace);
2614 WriteStr(AH, te->tablespace);
2615 WriteStr(AH, te->tableam);
2616 WriteInt(AH, te->relkind);
2617 WriteStr(AH, te->owner);
2618 WriteStr(AH, "false");
2619
2620 /* Dump list of dependencies */
2621 for (i = 0; i < te->nDeps; i++)
2622 {
2623 sprintf(workbuf, "%d", te->dependencies[i]);
2624 WriteStr(AH, workbuf);
2625 }
2626 WriteStr(AH, NULL); /* Terminate List */
2627
2628 if (AH->WriteExtraTocPtr)
2629 AH->WriteExtraTocPtr(AH, te);
2630 }
2631}
#define REQ_SCHEMA
#define REQ_SPECIAL
#define sprintf
Definition: port.h:241

References _tocEntry::catalogId, _tocEntry::copyStmt, _tocEntry::dataDumper, _tocEntry::defn, _tocEntry::dependencies, _tocEntry::desc, _tocEntry::dropStmt, _tocEntry::dumpId, i, _tocEntry::nDeps, _tocEntry::next, CatalogId::oid, _tocEntry::owner, _tocEntry::relkind, REQ_DATA, REQ_SCHEMA, REQ_SPECIAL, _tocEntry::reqs, _tocEntry::section, sprintf, _tocEntry::tableam, CatalogId::tableoid, _tocEntry::tablespace, _tocEntry::tag, _archiveHandle::toc, _archiveHandle::WriteExtraTocPtr, WriteInt(), and WriteStr().

Referenced by _CloseArchive().