<varlistentry>

<term><option>--save-fullpage=<replaceable>save_path</replaceable></option></term>

<listitem>

<para>

Save full page images found in the WAL records to the

<replaceable>save_path</replaceable> directory. The images saved

are subject to the same filtering and limiting criteria as the

records displayed.

</para>

<para>

The full page images are saved with the following file name format:

<literal><replaceable>LSN</replaceable>.<replaceable>RELTABLESPACE</replaceable>.<replaceable>DATOID</replaceable>.<replaceable>RELNODE</replaceable>.<replaceable>BLKNO</replaceable><replaceable>FORK</replaceable></literal>

The file names are composed of the following parts:

<informaltable>

<tgroup cols="2">

<thead>

<row>

<entry>Component</entry>

<entry>Description</entry>

</row>

</thead>

<tbody>

<row>

<entry>LSN</entry>

<entry>The <acronym>LSN</acronym> of the record with this image,

formatted as two 8-character hexadecimal numbers

<literal>%08X-%08X</literal></entry>

</row>

<row>

<entry>RELTABLESPACE</entry>

<entry>tablespace OID of the block</entry>

</row>

<row>

<entry>DATOID</entry>

<entry>database OID of the block</entry>

</row>

<row>

<entry>RELNODE</entry>

<entry>filenode of the block</entry>

</row>

<row>

<entry>BLKNO</entry>

<entry>block number of the block</entry>

</row>

<row>

<entry>FORK</entry>

<entry>

The name of the fork the full page image came from, as of

<literal>_main</literal>, <literal>_fsm</literal>,

<literal>_vm</literal>, or <literal>_init</literal>.

</entry>

</row>

</tbody>

</tgroup>

</informaltable>

</para>

</listitem>

</varlistentry>

't/002_save_fullpage.pl',

#include "common/file_perm.h"

#include "common/file_utils.h"

#include "common/relpath.h"

#include "storage/bufpage.h"

/* save options */

char *save_fullpage_path;

static void

create_fullpage_directory(char *path)

{

int ret;

switch ((ret = pg_check_dir(path)))

{

case 0:

/* Does not exist, so create it */

if (pg_mkdir_p(path, pg_dir_create_mode) < 0)

pg_fatal("could not create directory \"%s\": %m", path);

break;

case 1:

/* Present and empty, so do nothing */

break;

case 2:

case 3:

case 4:

/* Exists and not empty */

pg_fatal("directory \"%s\" exists but is not empty", path);

break;

default:

/* Trouble accessing directory */

pg_fatal("could not access directory \"%s\": %m", path);

}

}

static void

XLogRecordSaveFPWs(XLogReaderState *record, const char *savepath)

{

int block_id;

for (block_id = 0; block_id <= XLogRecMaxBlockId(record); block_id++)

{

PGAlignedBlock buf;

Page page;

char filename[MAXPGPATH];

char forkname[FORKNAMECHARS + 2]; /* _ + terminating zero */

FILE *file;

BlockNumber blk;

RelFileLocator rnode;

ForkNumber fork;

if (!XLogRecHasBlockRef(record, block_id))

continue;

if (!XLogRecHasBlockImage(record, block_id))

continue;

page = (Page) buf.data;

/* Full page exists, so let's save it */

if (!RestoreBlockImage(record, block_id, page))

pg_fatal("%s", record->errormsg_buf);

(void) XLogRecGetBlockTagExtended(record, block_id,

&rnode, &fork, &blk, NULL);

if (fork >= 0 && fork <= MAX_FORKNUM)

sprintf(forkname, "_%s", forkNames[fork]);

else

pg_fatal("invalid fork number: %u", fork);

snprintf(filename, MAXPGPATH, "%s/%08X-%08X.%u.%u.%u.%u%s", savepath,

LSN_FORMAT_ARGS(record->ReadRecPtr),

rnode.spcOid, rnode.dbOid, rnode.relNumber, blk, forkname);

file = fopen(filename, PG_BINARY_W);

if (!file)

pg_fatal("could not open file \"%s\": %m", filename);

if (fwrite(page, BLCKSZ, 1, file) != 1)

pg_fatal("could not write file \"%s\": %m", filename);

if (fclose(file) != 0)

pg_fatal("could not write file \"%s\": %m", filename);

}

}

printf(_(" --save-fullpage=PATH\n"

" save full page images\n"));

{"save-fullpage", required_argument, NULL, 1},

config.save_fullpage_path = NULL;

case 1:

config.save_fullpage_path = pg_strdup(optarg);

break;

if (config.save_fullpage_path != NULL)

create_fullpage_directory(config.save_fullpage_path);

/* save full pages if requested */

if (config.save_fullpage_path != NULL)

XLogRecordSaveFPWs(xlogreader_state, config.save_fullpage_path);

use strict;

use warnings;

use File::Basename;

use PostgreSQL::Test::Cluster;

use PostgreSQL::Test::RecursiveCopy;

use PostgreSQL::Test::Utils;

use Test::More;

my ($blocksize, $walfile_name);

sub get_block_lsn

{

my $path = shift;

my $blocksize = shift;

my $block;

open my $fh, '<', $path or die "couldn't open file: $path\n";

die "could not read block\n"

if $blocksize != read($fh, $block, $blocksize);

my ($lsn_hi, $lsn_lo) = unpack('LL', $block);

$lsn_hi = sprintf('%08X', $lsn_hi);

$lsn_lo = sprintf('%08X', $lsn_lo);

return ($lsn_hi, $lsn_lo);

}

my $node = PostgreSQL::Test::Cluster->new('main');

$node->init;

$node->append_conf(

'postgresql.conf', q{

});

$node->start;

$node->safe_psql(

'postgres',

"SELECT 'init' FROM pg_create_physical_replication_slot('regress_pg_waldump_slot', true, false);

");

($walfile_name, $blocksize) = split '\|' => $node->safe_psql('postgres',

"SELECT pg_walfile_name(pg_switch_wal()), current_setting('block_size')");

my $relation = $node->safe_psql(

'postgres',

q{SELECT format(

);

my $walfile = $node->data_dir . '/pg_wal/' . $walfile_name;

my $tmp_folder = PostgreSQL::Test::Utils::tempdir;

ok(-f $walfile, "Got a WAL file");

$node->command_ok(

[

'pg_waldump', '--quiet',

'--save-fullpage', "$tmp_folder/raw",

'--relation', $relation,

$walfile

]);

my $file_re =

qr/^([0-9A-F]{8})-([0-9A-F]{8})[.][0-9]+[.][0-9]+[.][0-9]+[.][0-9]+(?:_vm|_init|_fsm|_main)?$/;

my $file_count = 0;

for my $fullpath (glob "$tmp_folder/raw/*")

{

my $file = File::Basename::basename($fullpath);

like($file, $file_re, "verify filename format for file $file");

$file_count++;

my ($hi_lsn_fn, $lo_lsn_fn) = ($file =~ $file_re);

my ($hi_lsn_bk, $lo_lsn_bk) = get_block_lsn($fullpath, $blocksize);

# The LSN on the block comes before the file's LSN.

ok( $hi_lsn_fn . $lo_lsn_fn gt $hi_lsn_bk . $lo_lsn_bk,

'LSN stored in the file precedes the one stored in the block');

}

ok($file_count > 0, 'verify that at least one block has been saved');

done_testing();