pg_waldump.c File Reference

#include "postgres.h"
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#include "access/transam.h"
#include "access/xlog_internal.h"
#include "access/xlogreader.h"
#include "access/xlogrecord.h"
#include "common/fe_memutils.h"
#include "common/logging.h"
#include "getopt_long.h"
#include "rmgrdesc.h"

Include dependency graph for pg_waldump.c:

Go to the source code of this file.

Data Structures
struct	XLogDumpPrivate
struct	XLogDumpConfig
struct	Stats
struct	XLogDumpStats

Macros
#define	FRONTEND   1
#define	MAX_XLINFO_TYPES   16
#define	fatal_error(...)   do { pg_log_fatal(__VA_ARGS__); exit(EXIT_FAILURE); } while(0)

Typedefs
typedef struct XLogDumpPrivate	XLogDumpPrivate
typedef struct XLogDumpConfig	XLogDumpConfig
typedef struct Stats	Stats
typedef struct XLogDumpStats	XLogDumpStats

Functions
static void	print_rmgr_list (void)
static bool	verify_directory (const char *directory)
static void	split_path (const char *path, char **dir, char **fname)
static int	open_file_in_directory (const char *directory, const char *fname)
static bool	search_directory (const char *directory, const char *fname)
static char *	identify_target_directory (char *directory, char *fname)
static int	WALDumpOpenSegment (XLogSegNo nextSegNo, WALSegmentContext *segcxt, TimeLineID *tli_p)
static int	WALDumpReadPage (XLogReaderState *state, XLogRecPtr targetPagePtr, int reqLen, XLogRecPtr targetPtr, char *readBuff)
static void	XLogDumpRecordLen (XLogReaderState *record, uint32 *rec_len, uint32 *fpi_len)
static void	XLogDumpCountRecord (XLogDumpConfig *config, XLogDumpStats *stats, XLogReaderState *record)
static void	XLogDumpDisplayRecord (XLogDumpConfig *config, XLogReaderState *record)
static void	XLogDumpStatsRow (const char *name, uint64 n, uint64 total_count, uint64 rec_len, uint64 total_rec_len, uint64 fpi_len, uint64 total_fpi_len, uint64 tot_len, uint64 total_len)
static void	XLogDumpDisplayStats (XLogDumpConfig *config, XLogDumpStats *stats)
static void	usage (void)
int	main (int argc, char **argv)

Variables
static const char *	progname
static int	WalSegSz

Macro Definition Documentation

fatal_error

#define fatal_error

(

...

)

do { pg_log_fatal(__VA_ARGS__); exit(EXIT_FAILURE); } while(0)

Definition at line 72 of file pg_waldump.c.

Referenced by identify_target_directory(), main(), open_file_in_directory(), search_directory(), WALDumpOpenSegment(), and WALDumpReadPage().

FRONTEND

#define FRONTEND   1

Definition at line 12 of file pg_waldump.c.

MAX_XLINFO_TYPES

#define MAX_XLINFO_TYPES   16

Definition at line 63 of file pg_waldump.c.

Referenced by XLogDumpDisplayStats().

Typedef Documentation

Stats

typedef struct Stats Stats

XLogDumpConfig

typedef struct XLogDumpConfig XLogDumpConfig

XLogDumpPrivate

typedef struct XLogDumpPrivate XLogDumpPrivate

XLogDumpStats

typedef struct XLogDumpStats XLogDumpStats

Function Documentation

identify_target_directory()

static char* identify_target_directory ( char *  directory, char *  fname  )

static

Definition at line 237 of file pg_waldump.c.

References datadir, fatal_error, MAXPGPATH, pg_strdup(), search_directory(), snprintf, and XLOGDIR.

Referenced by main().

{
    char        fpath[MAXPGPATH];

    if (directory != NULL)
    {
        if (search_directory(directory, fname))
            return pg_strdup(directory);

        /* directory / XLOGDIR */
        snprintf(fpath, MAXPGPATH, "%s/%s", directory, XLOGDIR);
        if (search_directory(fpath, fname))
            return pg_strdup(fpath);
    }
    else
    {
        const char *datadir;

        /* current directory */
        if (search_directory(".", fname))
            return pg_strdup(".");
        /* XLOGDIR */
        if (search_directory(XLOGDIR, fname))
            return pg_strdup(XLOGDIR);

        datadir = getenv("PGDATA");
        /* $PGDATA / XLOGDIR */
        if (datadir != NULL)
        {
            snprintf(fpath, MAXPGPATH, "%s/%s", datadir, XLOGDIR);
            if (search_directory(fpath, fname))
                return pg_strdup(fpath);
        }
    }

    /* could not locate WAL file */
    if (fname)
        fatal_error("could not locate WAL file \"%s\"", fname);
    else
        fatal_error("could not find any WAL file");

    return NULL;                /* not reached */
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 737 of file pg_waldump.c.

References _, XLogDumpConfig::already_displayed_records, XLogDumpConfig::bkp_details, close, directory, XLogDumpPrivate::endptr, EXIT_FAILURE, EXIT_SUCCESS, fatal_error, fd(), XLogDumpConfig::filter_by_rmgr, XLogDumpConfig::filter_by_xid, XLogDumpConfig::filter_by_xid_enabled, XLogDumpConfig::follow, fprintf, get_progname(), getopt_long(), i, identify_target_directory(), InvalidTransactionId, InvalidXLogRecPtr, ngettext, no_argument, open_file_in_directory(), optarg, optind, optional_argument, pg_log_error, pg_logging_init(), pg_strcasecmp(), pg_strdup(), PG_TEXTDOMAIN, pg_usleep(), print_rmgr_list(), printf, progname, XLogReaderState::ReadRecPtr, required_argument, RM_MAX_ID, RmgrDescTable, set_pglocale_pgservice(), split_path(), XLogDumpPrivate::startptr, XLogDumpConfig::stats, XLogDumpConfig::stats_per_record, XLogDumpConfig::stop_after_records, XLogDumpPrivate::timeline, usage(), verify_directory(), WALDumpReadPage(), WalSegSz, XLogRecord::xl_rmid, XLogRecord::xl_xid, XLByteInSeg, XLogDumpCountRecord(), XLogDumpDisplayRecord(), XLogDumpDisplayStats(), XLogFromFileName, XLogReaderAllocate(), XLogReaderFree(), XLogReadRecord(), XLogRecPtrIsInvalid, XLogSegmentOffset, and XLogSegNoOffsetToRecPtr.

{
    uint32      xlogid;
    uint32      xrecoff;
    XLogReaderState *xlogreader_state;
    XLogDumpPrivate private;
    XLogDumpConfig config;
    XLogDumpStats stats;
    XLogRecord *record;
    XLogRecPtr  first_record;
    char       *waldir = NULL;
    char       *errormsg;

    static struct option long_options[] = {
        {"bkp-details", no_argument, NULL, 'b'},
        {"end", required_argument, NULL, 'e'},
        {"follow", no_argument, NULL, 'f'},
        {"help", no_argument, NULL, '?'},
        {"limit", required_argument, NULL, 'n'},
        {"path", required_argument, NULL, 'p'},
        {"rmgr", required_argument, NULL, 'r'},
        {"start", required_argument, NULL, 's'},
        {"timeline", required_argument, NULL, 't'},
        {"xid", required_argument, NULL, 'x'},
        {"version", no_argument, NULL, 'V'},
        {"stats", optional_argument, NULL, 'z'},
        {NULL, 0, NULL, 0}
    };

    int         option;
    int         optindex = 0;

    pg_logging_init(argv[0]);
    set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_waldump"));
    progname = get_progname(argv[0]);

    if (argc > 1)
    {
        if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
        {
            usage();
            exit(0);
        }
        if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
        {
            puts("pg_waldump (PostgreSQL) " PG_VERSION);
            exit(0);
        }
    }

    memset(&private, 0, sizeof(XLogDumpPrivate));
    memset(&config, 0, sizeof(XLogDumpConfig));
    memset(&stats, 0, sizeof(XLogDumpStats));

    private.timeline = 1;
    private.startptr = InvalidXLogRecPtr;
    private.endptr = InvalidXLogRecPtr;
    private.endptr_reached = false;

    config.bkp_details = false;
    config.stop_after_records = -1;
    config.already_displayed_records = 0;
    config.follow = false;
    config.filter_by_rmgr = -1;
    config.filter_by_xid = InvalidTransactionId;
    config.filter_by_xid_enabled = false;
    config.stats = false;
    config.stats_per_record = false;

    if (argc <= 1)
    {
        pg_log_error("no arguments specified");
        goto bad_argument;
    }

    while ((option = getopt_long(argc, argv, "be:fn:p:r:s:t:x:z",
                                 long_options, &optindex)) != -1)
    {
        switch (option)
        {
            case 'b':
                config.bkp_details = true;
                break;
            case 'e':
                if (sscanf(optarg, "%X/%X", &xlogid, &xrecoff) != 2)
                {
                    pg_log_error("could not parse end WAL location \"%s\"",
                                 optarg);
                    goto bad_argument;
                }
                private.endptr = (uint64) xlogid << 32 | xrecoff;
                break;
            case 'f':
                config.follow = true;
                break;
            case 'n':
                if (sscanf(optarg, "%d", &config.stop_after_records) != 1)
                {
                    pg_log_error("could not parse limit \"%s\"", optarg);
                    goto bad_argument;
                }
                break;
            case 'p':
                waldir = pg_strdup(optarg);
                break;
            case 'r':
                {
                    int         i;

                    if (pg_strcasecmp(optarg, "list") == 0)
                    {
                        print_rmgr_list();
                        exit(EXIT_SUCCESS);
                    }

                    for (i = 0; i <= RM_MAX_ID; i++)
                    {
                        if (pg_strcasecmp(optarg, RmgrDescTable[i].rm_name) == 0)
                        {
                            config.filter_by_rmgr = i;
                            break;
                        }
                    }

                    if (config.filter_by_rmgr == -1)
                    {
                        pg_log_error("resource manager \"%s\" does not exist",
                                     optarg);
                        goto bad_argument;
                    }
                }
                break;
            case 's':
                if (sscanf(optarg, "%X/%X", &xlogid, &xrecoff) != 2)
                {
                    pg_log_error("could not parse start WAL location \"%s\"",
                                 optarg);
                    goto bad_argument;
                }
                else
                    private.startptr = (uint64) xlogid << 32 | xrecoff;
                break;
            case 't':
                if (sscanf(optarg, "%d", &private.timeline) != 1)
                {
                    pg_log_error("could not parse timeline \"%s\"", optarg);
                    goto bad_argument;
                }
                break;
            case 'x':
                if (sscanf(optarg, "%u", &config.filter_by_xid) != 1)
                {
                    pg_log_error("could not parse \"%s\" as a transaction ID",
                                 optarg);
                    goto bad_argument;
                }
                config.filter_by_xid_enabled = true;
                break;
            case 'z':
                config.stats = true;
                config.stats_per_record = false;
                if (optarg)
                {
                    if (strcmp(optarg, "record") == 0)
                        config.stats_per_record = true;
                    else if (strcmp(optarg, "rmgr") != 0)
                    {
                        pg_log_error("unrecognized argument to --stats: %s",
                                     optarg);
                        goto bad_argument;
                    }
                }
                break;
            default:
                goto bad_argument;
        }
    }

    if ((optind + 2) < argc)
    {
        pg_log_error("too many command-line arguments (first is \"%s\")",
                     argv[optind + 2]);
        goto bad_argument;
    }

    if (waldir != NULL)
    {
        /* validate path points to directory */
        if (!verify_directory(waldir))
        {
            pg_log_error("could not open directory \"%s\": %m", waldir);
            goto bad_argument;
        }
    }

    /* parse files as start/end boundaries, extract path if not specified */
    if (optind < argc)
    {
        char       *directory = NULL;
        char       *fname = NULL;
        int         fd;
        XLogSegNo   segno;

        split_path(argv[optind], &directory, &fname);

        if (waldir == NULL && directory != NULL)
        {
            waldir = directory;

            if (!verify_directory(waldir))
                fatal_error("could not open directory \"%s\": %m", waldir);
        }

        waldir = identify_target_directory(waldir, fname);
        fd = open_file_in_directory(waldir, fname);
        if (fd < 0)
            fatal_error("could not open file \"%s\"", fname);
        close(fd);

        /* parse position from file */
        XLogFromFileName(fname, &private.timeline, &segno, WalSegSz);

        if (XLogRecPtrIsInvalid(private.startptr))
            XLogSegNoOffsetToRecPtr(segno, 0, WalSegSz, private.startptr);
        else if (!XLByteInSeg(private.startptr, segno, WalSegSz))
        {
            pg_log_error("start WAL location %X/%X is not inside file \"%s\"",
                         (uint32) (private.startptr >> 32),
                         (uint32) private.startptr,
                         fname);
            goto bad_argument;
        }

        /* no second file specified, set end position */
        if (!(optind + 1 < argc) && XLogRecPtrIsInvalid(private.endptr))
            XLogSegNoOffsetToRecPtr(segno + 1, 0, WalSegSz, private.endptr);

        /* parse ENDSEG if passed */
        if (optind + 1 < argc)
        {
            XLogSegNo   endsegno;

            /* ignore directory, already have that */
            split_path(argv[optind + 1], &directory, &fname);

            fd = open_file_in_directory(waldir, fname);
            if (fd < 0)
                fatal_error("could not open file \"%s\"", fname);
            close(fd);

            /* parse position from file */
            XLogFromFileName(fname, &private.timeline, &endsegno, WalSegSz);

            if (endsegno < segno)
                fatal_error("ENDSEG %s is before STARTSEG %s",
                            argv[optind + 1], argv[optind]);

            if (XLogRecPtrIsInvalid(private.endptr))
                XLogSegNoOffsetToRecPtr(endsegno + 1, 0, WalSegSz,
                                        private.endptr);

            /* set segno to endsegno for check of --end */
            segno = endsegno;
        }


        if (!XLByteInSeg(private.endptr, segno, WalSegSz) &&
            private.endptr != (segno + 1) * WalSegSz)
        {
            pg_log_error("end WAL location %X/%X is not inside file \"%s\"",
                         (uint32) (private.endptr >> 32),
                         (uint32) private.endptr,
                         argv[argc - 1]);
            goto bad_argument;
        }
    }
    else
        waldir = identify_target_directory(waldir, NULL);

    /* we don't know what to print */
    if (XLogRecPtrIsInvalid(private.startptr))
    {
        pg_log_error("no start WAL location given");
        goto bad_argument;
    }

    /* done with argument parsing, do the actual work */

    /* we have everything we need, start reading */
    xlogreader_state = XLogReaderAllocate(WalSegSz, waldir, WALDumpReadPage,
                                          &private);
    if (!xlogreader_state)
        fatal_error("out of memory");

    /* first find a valid recptr to start from */
    first_record = XLogFindNextRecord(xlogreader_state, private.startptr);

    if (first_record == InvalidXLogRecPtr)
        fatal_error("could not find a valid record after %X/%X",
                    (uint32) (private.startptr >> 32),
                    (uint32) private.startptr);

    /*
     * Display a message that we're skipping data if `from` wasn't a pointer
     * to the start of a record and also wasn't a pointer to the beginning of
     * a segment (e.g. we were used in file mode).
     */
    if (first_record != private.startptr &&
        XLogSegmentOffset(private.startptr, WalSegSz) != 0)
        printf(ngettext("first record is after %X/%X, at %X/%X, skipping over %u byte\n",
                        "first record is after %X/%X, at %X/%X, skipping over %u bytes\n",
                        (first_record - private.startptr)),
               (uint32) (private.startptr >> 32), (uint32) private.startptr,
               (uint32) (first_record >> 32), (uint32) first_record,
               (uint32) (first_record - private.startptr));

    for (;;)
    {
        /* try to read the next record */
        record = XLogReadRecord(xlogreader_state, &errormsg);
        if (!record)
        {
            if (!config.follow || private.endptr_reached)
                break;
            else
            {
                pg_usleep(1000000L);    /* 1 second */
                continue;
            }
        }

        /* apply all specified filters */
        if (config.filter_by_rmgr != -1 &&
            config.filter_by_rmgr != record->xl_rmid)
            continue;

        if (config.filter_by_xid_enabled &&
            config.filter_by_xid != record->xl_xid)
            continue;

        /* process the record */
        if (config.stats == true)
            XLogDumpCountRecord(&config, &stats, xlogreader_state);
        else
            XLogDumpDisplayRecord(&config, xlogreader_state);

        /* check whether we printed enough */
        config.already_displayed_records++;
        if (config.stop_after_records > 0 &&
            config.already_displayed_records >= config.stop_after_records)
            break;
    }

    if (config.stats == true)
        XLogDumpDisplayStats(&config, &stats);

    if (errormsg)
        fatal_error("error in WAL record at %X/%X: %s",
                    (uint32) (xlogreader_state->ReadRecPtr >> 32),
                    (uint32) xlogreader_state->ReadRecPtr,
                    errormsg);

    XLogReaderFree(xlogreader_state);

    return EXIT_SUCCESS;

bad_argument:
    fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
    return EXIT_FAILURE;
}

open_file_in_directory()

static int open_file_in_directory ( const char *  directory, const char *  fname  )

static

Definition at line 134 of file pg_waldump.c.

References Assert, fatal_error, fd(), MAXPGPATH, PG_BINARY, and snprintf.

Referenced by main(), search_directory(), and WALDumpOpenSegment().

{
    int         fd = -1;
    char        fpath[MAXPGPATH];

    Assert(directory != NULL);

    snprintf(fpath, MAXPGPATH, "%s/%s", directory, fname);
    fd = open(fpath, O_RDONLY | PG_BINARY, 0);

    if (fd < 0 && errno != ENOENT)
        fatal_error("could not open file \"%s\": %m", fname);
    return fd;
}

print_rmgr_list()

static void print_rmgr_list ( void  )

static

Definition at line 75 of file pg_waldump.c.

References i, printf, RM_MAX_ID, and RmgrDescTable.

Referenced by main().

{
    int         i;

    for (i = 0; i <= RM_MAX_ID; i++)
    {
        printf("%s\n", RmgrDescTable[i].rm_name);
    }
}

search_directory()

static bool search_directory ( const char *  directory, const char *  fname  )

static

Definition at line 156 of file pg_waldump.c.

References buf, close, closedir(), dirent::d_name, PGAlignedXLogBlock::data, fatal_error, fd(), IsValidWalSegSize, IsXLogFileName, ngettext, open_file_in_directory(), opendir(), read, readdir(), WalSegSz, and XLogLongPageHeaderData::xlp_seg_size.

Referenced by identify_target_directory().

{
    int         fd = -1;
    DIR        *xldir;

    /* open file if valid filename is provided */
    if (fname != NULL)
        fd = open_file_in_directory(directory, fname);

    /*
     * A valid file name is not passed, so search the complete directory.  If
     * we find any file whose name is a valid WAL file name then try to open
     * it.  If we cannot open it, bail out.
     */
    else if ((xldir = opendir(directory)) != NULL)
    {
        struct dirent *xlde;

        while ((xlde = readdir(xldir)) != NULL)
        {
            if (IsXLogFileName(xlde->d_name))
            {
                fd = open_file_in_directory(directory, xlde->d_name);
                fname = xlde->d_name;
                break;
            }
        }

        closedir(xldir);
    }

    /* set WalSegSz if file is successfully opened */
    if (fd >= 0)
    {
        PGAlignedXLogBlock buf;
        int         r;

        r = read(fd, buf.data, XLOG_BLCKSZ);
        if (r == XLOG_BLCKSZ)
        {
            XLogLongPageHeader longhdr = (XLogLongPageHeader) buf.data;

            WalSegSz = longhdr->xlp_seg_size;

            if (!IsValidWalSegSize(WalSegSz))
                fatal_error(ngettext("WAL segment size must be a power of two between 1 MB and 1 GB, but the WAL file \"%s\" header specifies %d byte",
                                     "WAL segment size must be a power of two between 1 MB and 1 GB, but the WAL file \"%s\" header specifies %d bytes",
                                     WalSegSz),
                            fname, WalSegSz);
        }
        else
        {
            if (errno != 0)
                fatal_error("could not read file \"%s\": %m",
                            fname);
            else
                fatal_error("could not read file \"%s\": read %d of %zu",
                            fname, r, (Size) XLOG_BLCKSZ);
        }
        close(fd);
        return true;
    }

    return false;
}

split_path()

static void split_path ( const char *  path, char **  dir, char **  fname  )

static

Definition at line 107 of file pg_waldump.c.

References pg_strdup(), and pnstrdup().

Referenced by main().

{
    char       *sep;

    /* split filepath into directory & filename */
    sep = strrchr(path, '/');

    /* directory path */
    if (sep != NULL)
    {
        *dir = pnstrdup(path, sep - path);
        *fname = pg_strdup(sep + 1);
    }
    /* local directory */
    else
    {
        *dir = NULL;
        *fname = pg_strdup(path);
    }
}

usage()

static void usage ( void  )

static

Definition at line 709 of file pg_waldump.c.

References _, printf, and progname.

Referenced by main().

{
    printf(_("%s decodes and displays PostgreSQL write-ahead logs for debugging.\n\n"),
           progname);
    printf(_("Usage:\n"));
    printf(_("  %s [OPTION]... [STARTSEG [ENDSEG]]\n"), progname);
    printf(_("\nOptions:\n"));
    printf(_("  -b, --bkp-details      output detailed information about backup blocks\n"));
    printf(_("  -e, --end=RECPTR       stop reading at WAL location RECPTR\n"));
    printf(_("  -f, --follow           keep retrying after reaching end of WAL\n"));
    printf(_("  -n, --limit=N          number of records to display\n"));
    printf(_("  -p, --path=PATH        directory in which to find log segment files or a\n"
             "                         directory with a ./pg_wal that contains such files\n"
             "                         (default: current directory, ./pg_wal, $PGDATA/pg_wal)\n"));
    printf(_("  -r, --rmgr=RMGR        only show records generated by resource manager RMGR;\n"
             "                         use --rmgr=list to list valid resource manager names\n"));
    printf(_("  -s, --start=RECPTR     start reading at WAL location RECPTR\n"));
    printf(_("  -t, --timeline=TLI     timeline from which to read log records\n"
             "                         (default: 1 or the value used in STARTSEG)\n"));
    printf(_("  -V, --version          output version information, then exit\n"));
    printf(_("  -x, --xid=XID          only show records with transaction ID XID\n"));
    printf(_("  -z, --stats[=record]   show statistics instead of records\n"
             "                         (optionally, show per-record statistics)\n"));
    printf(_("  -?, --help             show this help, then exit\n"));
    printf(_("\nReport bugs to <pgsql-bugs@lists.postgresql.org>.\n"));
}

verify_directory()

static bool verify_directory ( const char *  directory )

static

Definition at line 90 of file pg_waldump.c.

References closedir(), and opendir().

Referenced by main().

{
    DIR        *dir = opendir(directory);

    if (dir == NULL)
        return false;
    closedir(dir);
    return true;
}

WALDumpOpenSegment()

static int WALDumpOpenSegment ( XLogSegNo  nextSegNo, WALSegmentContext *  segcxt, TimeLineID *  tli_p  )

static

Definition at line 283 of file pg_waldump.c.

References fatal_error, fd(), MAXPGPATH, open_file_in_directory(), pg_usleep(), WALSegmentContext::ws_dir, WALSegmentContext::ws_segsize, and XLogFileName.

Referenced by WALDumpReadPage().

{
    TimeLineID  tli = *tli_p;
    char        fname[MAXPGPATH];
    int         fd;
    int         tries;

    XLogFileName(fname, tli, nextSegNo, segcxt->ws_segsize);

    /*
     * In follow mode there is a short period of time after the server has
     * written the end of the previous file before the new file is available.
     * So we loop for 5 seconds looking for the file to appear before giving
     * up.
     */
    for (tries = 0; tries < 10; tries++)
    {
        fd = open_file_in_directory(segcxt->ws_dir, fname);
        if (fd >= 0)
            return fd;
        if (errno == ENOENT)
        {
            int         save_errno = errno;

            /* File not there yet, try again */
            pg_usleep(500 * 1000);

            errno = save_errno;
            continue;
        }
        /* Any other error, fall through and fail */
        break;
    }

    fatal_error("could not find file \"%s\": %m", fname);
    return -1;                  /* keep compiler quiet */
}

WALDumpReadPage()

static int WALDumpReadPage ( XLogReaderState *  state, XLogRecPtr  targetPagePtr, int  reqLen, XLogRecPtr  targetPtr, char *  readBuff  )

static

Definition at line 326 of file pg_waldump.c.

References XLogDumpPrivate::endptr, fatal_error, InvalidXLogRecPtr, MAXPGPATH, XLogReaderState::private_data, XLogReaderState::seg, XLogReaderState::segcxt, WALDumpOpenSegment(), WALRead(), WALReadError::wre_errno, WALReadError::wre_off, WALReadError::wre_read, WALReadError::wre_req, WALReadError::wre_seg, WALOpenSegment::ws_segno, WALSegmentContext::ws_segsize, WALOpenSegment::ws_tli, and XLogFileName.

Referenced by main().

{
    XLogDumpPrivate *private = state->private_data;
    int         count = XLOG_BLCKSZ;
    WALReadError errinfo;

    if (private->endptr != InvalidXLogRecPtr)
    {
        if (targetPagePtr + XLOG_BLCKSZ <= private->endptr)
            count = XLOG_BLCKSZ;
        else if (targetPagePtr + reqLen <= private->endptr)
            count = private->endptr - targetPagePtr;
        else
        {
            private->endptr_reached = true;
            return -1;
        }
    }

    if (!WALRead(readBuff, targetPagePtr, count, private->timeline,
                 &state->seg, &state->segcxt, WALDumpOpenSegment, &errinfo))
    {
        WALOpenSegment *seg = &errinfo.wre_seg;
        char        fname[MAXPGPATH];

        XLogFileName(fname, seg->ws_tli, seg->ws_segno,
                     state->segcxt.ws_segsize);

        if (errinfo.wre_errno != 0)
        {
            errno = errinfo.wre_errno;
            fatal_error("could not read from file %s, offset %u: %m",
                        fname, errinfo.wre_off);
        }
        else
            fatal_error("could not read from file %s, offset %u: read %d of %zu",
                        fname, errinfo.wre_off, errinfo.wre_read,
                        (Size) errinfo.wre_req);
    }

    return count;
}

XLogDumpCountRecord()

static void XLogDumpCountRecord ( XLogDumpConfig *  config, XLogDumpStats *  stats, XLogReaderState *  record  )

static

Definition at line 403 of file pg_waldump.c.

References Stats::count, XLogDumpStats::count, Stats::fpi_len, Stats::rec_len, XLogDumpStats::record_stats, XLogDumpStats::rmgr_stats, XLogDumpRecordLen(), XLogRecGetInfo, and XLogRecGetRmid.

Referenced by main().

{
    RmgrId      rmid;
    uint8       recid;
    uint32      rec_len;
    uint32      fpi_len;

    stats->count++;

    rmid = XLogRecGetRmid(record);

    XLogDumpRecordLen(record, &rec_len, &fpi_len);

    /* Update per-rmgr statistics */

    stats->rmgr_stats[rmid].count++;
    stats->rmgr_stats[rmid].rec_len += rec_len;
    stats->rmgr_stats[rmid].fpi_len += fpi_len;

    /*
     * Update per-record statistics, where the record is identified by a
     * combination of the RmgrId and the four bits of the xl_info field that
     * are the rmgr's domain (resulting in sixteen possible entries per
     * RmgrId).
     */

    recid = XLogRecGetInfo(record) >> 4;

    stats->record_stats[rmid][recid].count++;
    stats->record_stats[rmid][recid].rec_len += rec_len;
    stats->record_stats[rmid][recid].fpi_len += fpi_len;
}

XLogDumpDisplayRecord()

static void XLogDumpDisplayRecord ( XLogDumpConfig *  config, XLogReaderState *  record  )

static

Definition at line 441 of file pg_waldump.c.

References DecodedBkpBlock::bimg_info, DecodedBkpBlock::bimg_len, XLogDumpConfig::bkp_details, BKPIMAGE_IS_COMPRESSED, XLogReaderState::blocks, StringInfoData::data, RelFileNode::dbNode, forkNames, DecodedBkpBlock::hole_length, DecodedBkpBlock::hole_offset, initStringInfo(), MAIN_FORKNUM, XLogReaderState::max_block_id, pfree(), printf, XLogReaderState::ReadRecPtr, RelFileNode::relNode, RmgrDescData::rm_desc, RmgrDescData::rm_identify, RmgrDescData::rm_name, RmgrDescTable, RelFileNode::spcNode, XLogDumpRecordLen(), XLogRecBlockImageApply, XLogRecGetBlockTag(), XLogRecGetInfo, XLogRecGetPrev, XLogRecGetRmid, XLogRecGetTotalLen, XLogRecGetXid, XLogRecHasBlockImage, XLogRecHasBlockRef, and XLR_INFO_MASK.

Referenced by main().

{
    const char *id;
    const RmgrDescData *desc = &RmgrDescTable[XLogRecGetRmid(record)];
    uint32      rec_len;
    uint32      fpi_len;
    RelFileNode rnode;
    ForkNumber  forknum;
    BlockNumber blk;
    int         block_id;
    uint8       info = XLogRecGetInfo(record);
    XLogRecPtr  xl_prev = XLogRecGetPrev(record);
    StringInfoData s;

    XLogDumpRecordLen(record, &rec_len, &fpi_len);

    printf("rmgr: %-11s len (rec/tot): %6u/%6u, tx: %10u, lsn: %X/%08X, prev %X/%08X, ",
           desc->rm_name,
           rec_len, XLogRecGetTotalLen(record),
           XLogRecGetXid(record),
           (uint32) (record->ReadRecPtr >> 32), (uint32) record->ReadRecPtr,
           (uint32) (xl_prev >> 32), (uint32) xl_prev);

    id = desc->rm_identify(info);
    if (id == NULL)
        printf("desc: UNKNOWN (%x) ", info & ~XLR_INFO_MASK);
    else
        printf("desc: %s ", id);

    initStringInfo(&s);
    desc->rm_desc(&s, record);
    printf("%s", s.data);
    pfree(s.data);

    if (!config->bkp_details)
    {
        /* print block references (short format) */
        for (block_id = 0; block_id <= record->max_block_id; block_id++)
        {
            if (!XLogRecHasBlockRef(record, block_id))
                continue;

            XLogRecGetBlockTag(record, block_id, &rnode, &forknum, &blk);
            if (forknum != MAIN_FORKNUM)
                printf(", blkref #%u: rel %u/%u/%u fork %s blk %u",
                       block_id,
                       rnode.spcNode, rnode.dbNode, rnode.relNode,
                       forkNames[forknum],
                       blk);
            else
                printf(", blkref #%u: rel %u/%u/%u blk %u",
                       block_id,
                       rnode.spcNode, rnode.dbNode, rnode.relNode,
                       blk);
            if (XLogRecHasBlockImage(record, block_id))
            {
                if (XLogRecBlockImageApply(record, block_id))
                    printf(" FPW");
                else
                    printf(" FPW for WAL verification");
            }
        }
        putchar('\n');
    }
    else
    {
        /* print block references (detailed format) */
        putchar('\n');
        for (block_id = 0; block_id <= record->max_block_id; block_id++)
        {
            if (!XLogRecHasBlockRef(record, block_id))
                continue;

            XLogRecGetBlockTag(record, block_id, &rnode, &forknum, &blk);
            printf("\tblkref #%u: rel %u/%u/%u fork %s blk %u",
                   block_id,
                   rnode.spcNode, rnode.dbNode, rnode.relNode,
                   forkNames[forknum],
                   blk);
            if (XLogRecHasBlockImage(record, block_id))
            {
                if (record->blocks[block_id].bimg_info &
                    BKPIMAGE_IS_COMPRESSED)
                {
                    printf(" (FPW%s); hole: offset: %u, length: %u, "
                           "compression saved: %u",
                           XLogRecBlockImageApply(record, block_id) ?
                           "" : " for WAL verification",
                           record->blocks[block_id].hole_offset,
                           record->blocks[block_id].hole_length,
                           BLCKSZ -
                           record->blocks[block_id].hole_length -
                           record->blocks[block_id].bimg_len);
                }
                else
                {
                    printf(" (FPW%s); hole: offset: %u, length: %u",
                           XLogRecBlockImageApply(record, block_id) ?
                           "" : " for WAL verification",
                           record->blocks[block_id].hole_offset,
                           record->blocks[block_id].hole_length);
                }
            }
            putchar('\n');
        }
    }
}

XLogDumpDisplayStats()

static void XLogDumpDisplayStats ( XLogDumpConfig *  config, XLogDumpStats *  stats  )

static

Definition at line 594 of file pg_waldump.c.

References Stats::count, XLogDumpStats::count, Stats::fpi_len, MAX_XLINFO_TYPES, printf, psprintf(), Stats::rec_len, XLogDumpStats::record_stats, RmgrDescData::rm_identify, RmgrDescData::rm_name, RM_NEXT_ID, XLogDumpStats::rmgr_stats, RmgrDescTable, XLogDumpConfig::stats_per_record, and XLogDumpStatsRow().

Referenced by main().

{
    int         ri,
                rj;
    uint64      total_count = 0;
    uint64      total_rec_len = 0;
    uint64      total_fpi_len = 0;
    uint64      total_len = 0;
    double      rec_len_pct,
                fpi_len_pct;

    /* ---
     * Make a first pass to calculate column totals:
     * count(*),
     * sum(xl_len+SizeOfXLogRecord),
     * sum(xl_tot_len-xl_len-SizeOfXLogRecord), and
     * sum(xl_tot_len).
     * These are used to calculate percentages for each record type.
     * ---
     */

    for (ri = 0; ri < RM_NEXT_ID; ri++)
    {
        total_count += stats->rmgr_stats[ri].count;
        total_rec_len += stats->rmgr_stats[ri].rec_len;
        total_fpi_len += stats->rmgr_stats[ri].fpi_len;
    }
    total_len = total_rec_len + total_fpi_len;

    /*
     * 27 is strlen("Transaction/COMMIT_PREPARED"), 20 is strlen(2^64), 8 is
     * strlen("(100.00%)")
     */

    printf("%-27s %20s %8s %20s %8s %20s %8s %20s %8s\n"
           "%-27s %20s %8s %20s %8s %20s %8s %20s %8s\n",
           "Type", "N", "(%)", "Record size", "(%)", "FPI size", "(%)", "Combined size", "(%)",
           "----", "-", "---", "-----------", "---", "--------", "---", "-------------", "---");

    for (ri = 0; ri < RM_NEXT_ID; ri++)
    {
        uint64      count,
                    rec_len,
                    fpi_len,
                    tot_len;
        const RmgrDescData *desc = &RmgrDescTable[ri];

        if (!config->stats_per_record)
        {
            count = stats->rmgr_stats[ri].count;
            rec_len = stats->rmgr_stats[ri].rec_len;
            fpi_len = stats->rmgr_stats[ri].fpi_len;
            tot_len = rec_len + fpi_len;

            XLogDumpStatsRow(desc->rm_name,
                             count, total_count, rec_len, total_rec_len,
                             fpi_len, total_fpi_len, tot_len, total_len);
        }
        else
        {
            for (rj = 0; rj < MAX_XLINFO_TYPES; rj++)
            {
                const char *id;

                count = stats->record_stats[ri][rj].count;
                rec_len = stats->record_stats[ri][rj].rec_len;
                fpi_len = stats->record_stats[ri][rj].fpi_len;
                tot_len = rec_len + fpi_len;

                /* Skip undefined combinations and ones that didn't occur */
                if (count == 0)
                    continue;

                /* the upper four bits in xl_info are the rmgr's */
                id = desc->rm_identify(rj << 4);
                if (id == NULL)
                    id = psprintf("UNKNOWN (%x)", rj << 4);

                XLogDumpStatsRow(psprintf("%s/%s", desc->rm_name, id),
                                 count, total_count, rec_len, total_rec_len,
                                 fpi_len, total_fpi_len, tot_len, total_len);
            }
        }
    }

    printf("%-27s %20s %8s %20s %8s %20s %8s %20s\n",
           "", "--------", "", "--------", "", "--------", "", "--------");

    /*
     * The percentages in earlier rows were calculated against the column
     * total, but the ones that follow are against the row total. Note that
     * these are displayed with a % symbol to differentiate them from the
     * earlier ones, and are thus up to 9 characters long.
     */

    rec_len_pct = 0;
    if (total_len != 0)
        rec_len_pct = 100 * (double) total_rec_len / total_len;

    fpi_len_pct = 0;
    if (total_len != 0)
        fpi_len_pct = 100 * (double) total_fpi_len / total_len;

    printf("%-27s "
           "%20" INT64_MODIFIER "u %-9s"
           "%20" INT64_MODIFIER "u %-9s"
           "%20" INT64_MODIFIER "u %-9s"
           "%20" INT64_MODIFIER "u %-6s\n",
           "Total", stats->count, "",
           total_rec_len, psprintf("[%.02f%%]", rec_len_pct),
           total_fpi_len, psprintf("[%.02f%%]", fpi_len_pct),
           total_len, "[100%]");
}

XLogDumpRecordLen()

static void XLogDumpRecordLen ( XLogReaderState *  record, uint32 *  rec_len, uint32 *  fpi_len  )

static

Definition at line 374 of file pg_waldump.c.

References DecodedBkpBlock::bimg_len, XLogReaderState::blocks, XLogReaderState::max_block_id, XLogRecGetTotalLen, and XLogRecHasBlockImage.

Referenced by XLogDumpCountRecord(), and XLogDumpDisplayRecord().

{
    int         block_id;

    /*
     * Calculate the amount of FPI data in the record.
     *
     * XXX: We peek into xlogreader's private decoded backup blocks for the
     * bimg_len indicating the length of FPI data. It doesn't seem worth it to
     * add an accessor macro for this.
     */
    *fpi_len = 0;
    for (block_id = 0; block_id <= record->max_block_id; block_id++)
    {
        if (XLogRecHasBlockImage(record, block_id))
            *fpi_len += record->blocks[block_id].bimg_len;
    }

    /*
     * Calculate the length of the record as the total length - the length of
     * all the block images.
     */
    *rec_len = XLogRecGetTotalLen(record) - *fpi_len;
}

XLogDumpStatsRow()

static void XLogDumpStatsRow ( const char *  name, uint64  n, uint64  total_count, uint64  rec_len, uint64  total_rec_len, uint64  fpi_len, uint64  total_fpi_len, uint64  tot_len, uint64  total_len  )

static

Definition at line 553 of file pg_waldump.c.

References printf.

Referenced by XLogDumpDisplayStats().

{
    double      n_pct,
                rec_len_pct,
                fpi_len_pct,
                tot_len_pct;

    n_pct = 0;
    if (total_count != 0)
        n_pct = 100 * (double) n / total_count;

    rec_len_pct = 0;
    if (total_rec_len != 0)
        rec_len_pct = 100 * (double) rec_len / total_rec_len;

    fpi_len_pct = 0;
    if (total_fpi_len != 0)
        fpi_len_pct = 100 * (double) fpi_len / total_fpi_len;

    tot_len_pct = 0;
    if (total_len != 0)
        tot_len_pct = 100 * (double) tot_len / total_len;

    printf("%-27s "
           "%20" INT64_MODIFIER "u (%6.02f) "
           "%20" INT64_MODIFIER "u (%6.02f) "
           "%20" INT64_MODIFIER "u (%6.02f) "
           "%20" INT64_MODIFIER "u (%6.02f)\n",
           name, n, n_pct, rec_len, rec_len_pct, fpi_len, fpi_len_pct,
           tot_len, tot_len_pct);
}

Variable Documentation

progname

const char* progname

static

Definition at line 28 of file pg_waldump.c.

Referenced by main(), and usage().

WalSegSz

int WalSegSz

static

Definition at line 30 of file pg_waldump.c.

Referenced by main(), and search_directory().