timeline.h File Reference

#include "access/xlogdefs.h"
#include "nodes/pg_list.h"

Include dependency graph for timeline.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	TimeLineHistoryEntry

Functions
List *	readTimeLineHistory (TimeLineID targetTLI)
bool	existsTimeLineHistory (TimeLineID probeTLI)
TimeLineID	findNewestTimeLine (TimeLineID startTLI)
void	writeTimeLineHistory (TimeLineID newTLI, TimeLineID parentTLI, XLogRecPtr switchpoint, char *reason)
void	writeTimeLineHistoryFile (TimeLineID tli, char *content, int size)
void	restoreTimeLineHistoryFiles (TimeLineID begin, TimeLineID end)
bool	tliInHistory (TimeLineID tli, List *expectedTLEs)
TimeLineID	tliOfPointInHistory (XLogRecPtr ptr, List *history)
XLogRecPtr	tliSwitchPoint (TimeLineID tli, List *history, TimeLineID *nextTLI)

Function Documentation

existsTimeLineHistory()

bool existsTimeLineHistory ( TimeLineID  probeTLI )

extern

Definition at line 223 of file timeline.c.

{
    char        path[MAXPGPATH];
    char        histfname[MAXFNAMELEN];
    FILE       *fd;
 
    /* Timeline 1 does not have a history file, so no need to check */
    if (probeTLI == 1)
        return false;
 
    if (ArchiveRecoveryRequested)
    {
        TLHistoryFileName(histfname, probeTLI);
        RestoreArchivedFile(path, histfname, "RECOVERYHISTORY", 0, false);
    }
    else
        TLHistoryFilePath(path, probeTLI);
 
    fd = AllocateFile(path, "r");
    if (fd != NULL)
    {
        FreeFile(fd);
        return true;
    }
    else
    {
        if (errno != ENOENT)
            ereport(FATAL,
                    (errcode_for_file_access(),
                     errmsg("could not open file \"%s\": %m", path)));
        return false;
    }
}

References AllocateFile(), ArchiveRecoveryRequested, ereport, errcode_for_file_access(), errmsg, FATAL, fb(), fd(), FreeFile(), MAXFNAMELEN, MAXPGPATH, RestoreArchivedFile(), TLHistoryFileName(), and TLHistoryFilePath().

Referenced by findNewestTimeLine(), validateRecoveryParameters(), and WalRcvFetchTimeLineHistoryFiles().

findNewestTimeLine()

TimeLineID findNewestTimeLine ( TimeLineID  startTLI )

extern

Definition at line 265 of file timeline.c.

{
    TimeLineID  newestTLI;
    TimeLineID  probeTLI;
 
    /*
     * The algorithm is just to probe for the existence of timeline history
     * files.  XXX is it useful to allow gaps in the sequence?
     */
    newestTLI = startTLI;
 
    for (probeTLI = startTLI + 1;; probeTLI++)
    {
        if (existsTimeLineHistory(probeTLI))
        {
            newestTLI = probeTLI;   /* probeTLI exists */
        }
        else
        {
            /* doesn't exist, assume we're done */
            break;
        }
    }
 
    return newestTLI;
}

References existsTimeLineHistory(), and fb().

Referenced by rescanLatestTimeLine(), StartupXLOG(), and validateRecoveryParameters().

readTimeLineHistory()

List * readTimeLineHistory ( TimeLineID  targetTLI )

extern

Definition at line 77 of file timeline.c.

{
    List       *result;
    char        path[MAXPGPATH];
    char        histfname[MAXFNAMELEN];
    FILE       *fd;
    TimeLineHistoryEntry *entry;
    TimeLineID  lasttli = 0;
    XLogRecPtr  prevend;
    bool        fromArchive = false;
 
    /* Timeline 1 does not have a history file, so no need to check */
    if (targetTLI == 1)
    {
        entry = palloc_object(TimeLineHistoryEntry);
        entry->tli = targetTLI;
        entry->begin = entry->end = InvalidXLogRecPtr;
        return list_make1(entry);
    }
 
    if (ArchiveRecoveryRequested)
    {
        TLHistoryFileName(histfname, targetTLI);
        fromArchive =
            RestoreArchivedFile(path, histfname, "RECOVERYHISTORY", 0, false);
    }
    else
        TLHistoryFilePath(path, targetTLI);
 
    fd = AllocateFile(path, "r");
    if (fd == NULL)
    {
        if (errno != ENOENT)
            ereport(FATAL,
                    (errcode_for_file_access(),
                     errmsg("could not open file \"%s\": %m", path)));
        /* Not there, so assume no parents */
        entry = palloc_object(TimeLineHistoryEntry);
        entry->tli = targetTLI;
        entry->begin = entry->end = InvalidXLogRecPtr;
        return list_make1(entry);
    }
 
    result = NIL;
 
    /*
     * Parse the file...
     */
    prevend = InvalidXLogRecPtr;
    for (;;)
    {
        char        fline[MAXPGPATH];
        char       *res;
        char       *ptr;
        TimeLineID  tli;
        uint32      switchpoint_hi;
        uint32      switchpoint_lo;
        int         nfields;
 
        pgstat_report_wait_start(WAIT_EVENT_TIMELINE_HISTORY_READ);
        res = fgets(fline, sizeof(fline), fd);
        pgstat_report_wait_end();
        if (res == NULL)
        {
            if (ferror(fd))
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not read file \"%s\": %m", path)));
 
            break;
        }
 
        /* skip leading whitespace and check for # comment */
        for (ptr = fline; *ptr; ptr++)
        {
            if (!isspace((unsigned char) *ptr))
                break;
        }
        if (*ptr == '\0' || *ptr == '#')
            continue;
 
        nfields = sscanf(fline, "%u\t%X/%08X", &tli, &switchpoint_hi, &switchpoint_lo);
 
        if (nfields < 1)
        {
            /* expect a numeric timeline ID as first field of line */
            ereport(FATAL,
                    (errmsg("syntax error in history file: %s", fline),
                     errhint("Expected a numeric timeline ID.")));
        }
        if (nfields != 3)
            ereport(FATAL,
                    (errmsg("syntax error in history file: %s", fline),
                     errhint("Expected a write-ahead log switchpoint location.")));
 
        if (result && tli <= lasttli)
            ereport(FATAL,
                    (errmsg("invalid data in history file: %s", fline),
                     errhint("Timeline IDs must be in increasing sequence.")));
 
        lasttli = tli;
 
        entry = palloc_object(TimeLineHistoryEntry);
        entry->tli = tli;
        entry->begin = prevend;
        entry->end = ((uint64) (switchpoint_hi)) << 32 | (uint64) switchpoint_lo;
        prevend = entry->end;
 
        /* Build list with newest item first */
        result = lcons(entry, result);
 
        /* we ignore the remainder of each line */
    }
 
    FreeFile(fd);
 
    if (result && targetTLI <= lasttli)
        ereport(FATAL,
                (errmsg("invalid data in history file \"%s\"", path),
                 errhint("Timeline IDs must be less than child timeline's ID.")));
 
    /*
     * Create one more entry for the "tip" of the timeline, which has no entry
     * in the history file.
     */
    entry = palloc_object(TimeLineHistoryEntry);
    entry->tli = targetTLI;
    entry->begin = prevend;
    entry->end = InvalidXLogRecPtr;
 
    result = lcons(entry, result);
 
    /*
     * If the history file was fetched from archive, save it in pg_wal for
     * future reference.
     */
    if (fromArchive)
        KeepFileRestoredFromArchive(path, histfname);
 
    return result;
}

References AllocateFile(), ArchiveRecoveryRequested, TimeLineHistoryEntry::begin, TimeLineHistoryEntry::end, ereport, errcode_for_file_access(), errhint(), errmsg, ERROR, FATAL, fb(), fd(), FreeFile(), InvalidXLogRecPtr, KeepFileRestoredFromArchive(), lcons(), list_make1, MAXFNAMELEN, MAXPGPATH, NIL, palloc_object, pgstat_report_wait_end(), pgstat_report_wait_start(), RestoreArchivedFile(), TLHistoryFileName(), TLHistoryFilePath(), and TimeLineHistoryEntry::tli.

Referenced by AddWALInfoToBackupManifest(), GetOldestUnsummarizedLSN(), PrepareForIncrementalBackup(), ReadReplicationSlot(), rescanLatestTimeLine(), StartReplication(), summarizer_read_local_xlog_page(), WaitForWALToBecomeAvailable(), WalSummarizerMain(), XLogFileReadAnyTLI(), XLogReadDetermineTimeline(), and XLogSendPhysical().

restoreTimeLineHistoryFiles()

void restoreTimeLineHistoryFiles ( TimeLineID  begin, TimeLineID  end  )

extern

Definition at line 51 of file timeline.c.

{
    char        path[MAXPGPATH];
    char        histfname[MAXFNAMELEN];
    TimeLineID  tli;
 
    for (tli = begin; tli < end; tli++)
    {
        if (tli == 1)
            continue;
 
        TLHistoryFileName(histfname, tli);
        if (RestoreArchivedFile(path, histfname, "RECOVERYHISTORY", 0, false))
            KeepFileRestoredFromArchive(path, histfname);
    }
}

References fb(), KeepFileRestoredFromArchive(), MAXFNAMELEN, MAXPGPATH, RestoreArchivedFile(), and TLHistoryFileName().

Referenced by rescanLatestTimeLine(), and StartupXLOG().

tliInHistory()

bool tliInHistory ( TimeLineID  tli, List *  expectedTLEs  )

extern

Definition at line 527 of file timeline.c.

{
    ListCell   *cell;
 
    foreach(cell, expectedTLEs)
    {
        if (((TimeLineHistoryEntry *) lfirst(cell))->tli == tli)
            return true;
    }
 
    return false;
}

References expectedTLEs, and lfirst.

Referenced by checkTimeLineSwitch(), and ReadRecord().

tliOfPointInHistory()

TimeLineID tliOfPointInHistory ( XLogRecPtr  ptr, List *  history  )

extern

Definition at line 545 of file timeline.c.

{
    ListCell   *cell;
 
    foreach(cell, history)
    {
        TimeLineHistoryEntry *tle = (TimeLineHistoryEntry *) lfirst(cell);
 
        if ((!XLogRecPtrIsValid(tle->begin) || tle->begin <= ptr) &&
            (!XLogRecPtrIsValid(tle->end) || ptr < tle->end))
        {
            /* found it */
            return tle->tli;
        }
    }
 
    /* shouldn't happen. */
    elog(ERROR, "timeline history was not contiguous");
    return 0;                   /* keep compiler quiet */
}

References elog, ERROR, fb(), lfirst, TimeLineHistoryEntry::tli, and XLogRecPtrIsValid.

Referenced by InitWalRecovery(), ReadReplicationSlot(), WaitForWALToBecomeAvailable(), and XLogReadDetermineTimeline().

tliSwitchPoint()

XLogRecPtr tliSwitchPoint ( TimeLineID  tli, List *  history, TimeLineID *  nextTLI  )

extern

Definition at line 573 of file timeline.c.

{
    ListCell   *cell;
 
    if (nextTLI)
        *nextTLI = 0;
    foreach(cell, history)
    {
        TimeLineHistoryEntry *tle = (TimeLineHistoryEntry *) lfirst(cell);
 
        if (tle->tli == tli)
            return tle->end;
        if (nextTLI)
            *nextTLI = tle->tli;
    }
 
    ereport(ERROR,
            (errmsg("requested timeline %u is not in this server's history",
                    tli)));
    return InvalidXLogRecPtr;   /* keep compiler quiet */
}

References TimeLineHistoryEntry::end, ereport, errmsg, ERROR, fb(), InvalidXLogRecPtr, and lfirst.

Referenced by InitWalRecovery(), StartReplication(), summarizer_read_local_xlog_page(), WalSummarizerMain(), XLogReadDetermineTimeline(), and XLogSendPhysical().

writeTimeLineHistory()

void writeTimeLineHistory ( TimeLineID  newTLI, TimeLineID  parentTLI, XLogRecPtr  switchpoint, char *  reason  )

extern

Definition at line 305 of file timeline.c.

{
    char        path[MAXPGPATH];
    char        tmppath[MAXPGPATH];
    char        histfname[MAXFNAMELEN];
    char        buffer[BLCKSZ];
    int         srcfd;
    int         fd;
    int         nbytes;
 
    Assert(newTLI > parentTLI); /* else bad selection of newTLI */
 
    /*
     * Write into a temp file name.
     */
    snprintf(tmppath, MAXPGPATH, XLOGDIR "/xlogtemp.%d", (int) getpid());
 
    unlink(tmppath);
 
    /* do not use get_sync_bit() here --- want to fsync only at end of fill */
    fd = OpenTransientFile(tmppath, O_RDWR | O_CREAT | O_EXCL);
    if (fd < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not create file \"%s\": %m", tmppath)));
 
    /*
     * If a history file exists for the parent, copy it verbatim
     */
    if (ArchiveRecoveryRequested)
    {
        TLHistoryFileName(histfname, parentTLI);
        RestoreArchivedFile(path, histfname, "RECOVERYHISTORY", 0, false);
    }
    else
        TLHistoryFilePath(path, parentTLI);
 
    srcfd = OpenTransientFile(path, O_RDONLY);
    if (srcfd < 0)
    {
        if (errno != ENOENT)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not open file \"%s\": %m", path)));
        /* Not there, so assume parent has no parents */
    }
    else
    {
        for (;;)
        {
            errno = 0;
            pgstat_report_wait_start(WAIT_EVENT_TIMELINE_HISTORY_READ);
            nbytes = (int) read(srcfd, buffer, sizeof(buffer));
            pgstat_report_wait_end();
            if (nbytes < 0 || errno != 0)
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not read file \"%s\": %m", path)));
            if (nbytes == 0)
                break;
            errno = 0;
            pgstat_report_wait_start(WAIT_EVENT_TIMELINE_HISTORY_WRITE);
            if ((int) write(fd, buffer, nbytes) != nbytes)
            {
                int         save_errno = errno;
 
                /*
                 * If we fail to make the file, delete it to release disk
                 * space
                 */
                unlink(tmppath);
 
                /*
                 * if write didn't set errno, assume problem is no disk space
                 */
                errno = save_errno ? save_errno : ENOSPC;
 
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not write to file \"%s\": %m", tmppath)));
            }
            pgstat_report_wait_end();
        }
 
        if (CloseTransientFile(srcfd) != 0)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not close file \"%s\": %m", path)));
    }
 
    /*
     * Append one line with the details of this timeline split.
     *
     * If we did have a parent file, insert an extra newline just in case the
     * parent file failed to end with one.
     */
    snprintf(buffer, sizeof(buffer),
             "%s%u\t%X/%08X\t%s\n",
             (srcfd < 0) ? "" : "\n",
             parentTLI,
             LSN_FORMAT_ARGS(switchpoint),
             reason);
 
    nbytes = strlen(buffer);
    errno = 0;
    pgstat_report_wait_start(WAIT_EVENT_TIMELINE_HISTORY_WRITE);
    if ((int) write(fd, buffer, nbytes) != nbytes)
    {
        int         save_errno = errno;
 
        /*
         * If we fail to make the file, delete it to release disk space
         */
        unlink(tmppath);
        /* if write didn't set errno, assume problem is no disk space */
        errno = save_errno ? save_errno : ENOSPC;
 
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not write to file \"%s\": %m", tmppath)));
    }
    pgstat_report_wait_end();
 
    pgstat_report_wait_start(WAIT_EVENT_TIMELINE_HISTORY_SYNC);
    if (pg_fsync(fd) != 0)
        ereport(data_sync_elevel(ERROR),
                (errcode_for_file_access(),
                 errmsg("could not fsync file \"%s\": %m", tmppath)));
    pgstat_report_wait_end();
 
    if (CloseTransientFile(fd) != 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not close file \"%s\": %m", tmppath)));
 
    /*
     * Now move the completed history file into place with its final name.
     */
    TLHistoryFilePath(path, newTLI);
    Assert(access(path, F_OK) != 0 && errno == ENOENT);
    durable_rename(tmppath, path, ERROR);
 
    /* The history file can be archived immediately. */
    if (XLogArchivingActive())
    {
        TLHistoryFileName(histfname, newTLI);
        XLogArchiveNotify(histfname);
    }
}

References ArchiveRecoveryRequested, Assert, CloseTransientFile(), data_sync_elevel(), durable_rename(), ereport, errcode_for_file_access(), errmsg, ERROR, fb(), fd(), LSN_FORMAT_ARGS, MAXFNAMELEN, MAXPGPATH, OpenTransientFile(), pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), read, RestoreArchivedFile(), snprintf, TLHistoryFileName(), TLHistoryFilePath(), write, XLogArchiveNotify(), XLogArchivingActive, and XLOGDIR.

Referenced by StartupXLOG().

writeTimeLineHistoryFile()

void writeTimeLineHistoryFile ( TimeLineID  tli, char *  content, int  size  )

extern

Definition at line 464 of file timeline.c.

{
    char        path[MAXPGPATH];
    char        tmppath[MAXPGPATH];
    int         fd;
 
    /*
     * Write into a temp file name.
     */
    snprintf(tmppath, MAXPGPATH, XLOGDIR "/xlogtemp.%d", (int) getpid());
 
    unlink(tmppath);
 
    /* do not use get_sync_bit() here --- want to fsync only at end of fill */
    fd = OpenTransientFile(tmppath, O_RDWR | O_CREAT | O_EXCL);
    if (fd < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not create file \"%s\": %m", tmppath)));
 
    errno = 0;
    pgstat_report_wait_start(WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE);
    if ((int) write(fd, content, size) != size)
    {
        int         save_errno = errno;
 
        /*
         * If we fail to make the file, delete it to release disk space
         */
        unlink(tmppath);
        /* if write didn't set errno, assume problem is no disk space */
        errno = save_errno ? save_errno : ENOSPC;
 
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not write to file \"%s\": %m", tmppath)));
    }
    pgstat_report_wait_end();
 
    pgstat_report_wait_start(WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC);
    if (pg_fsync(fd) != 0)
        ereport(data_sync_elevel(ERROR),
                (errcode_for_file_access(),
                 errmsg("could not fsync file \"%s\": %m", tmppath)));
    pgstat_report_wait_end();
 
    if (CloseTransientFile(fd) != 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not close file \"%s\": %m", tmppath)));
 
    /*
     * Now move the completed history file into place with its final name,
     * replacing any existing file with the same name.
     */
    TLHistoryFilePath(path, tli);
    durable_rename(tmppath, path, ERROR);
}

References CloseTransientFile(), data_sync_elevel(), durable_rename(), ereport, errcode_for_file_access(), errmsg, ERROR, fb(), fd(), MAXPGPATH, OpenTransientFile(), pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), snprintf, TLHistoryFilePath(), write, and XLOGDIR.

Referenced by WalRcvFetchTimeLineHistoryFiles().