reinit.h File Reference

#include "common/relpath.h"

Include dependency graph for reinit.h:

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

Go to the source code of this file.

Macros
#define	UNLOGGED_RELATION_CLEANUP   0x0001
#define	UNLOGGED_RELATION_INIT   0x0002

Functions
void	ResetUnloggedRelations (int op)
bool	parse_filename_for_nontemp_relation (const char *name, RelFileNumber *relnumber, ForkNumber *fork, unsigned *segno)

Macro Definition Documentation

UNLOGGED_RELATION_CLEANUP

#define UNLOGGED_RELATION_CLEANUP   0x0001

Definition at line 27 of file reinit.h.

UNLOGGED_RELATION_INIT

#define UNLOGGED_RELATION_INIT   0x0002

Definition at line 28 of file reinit.h.

Function Documentation

parse_filename_for_nontemp_relation()

bool parse_filename_for_nontemp_relation	(	const char *	name,
		RelFileNumber *	relnumber,
		ForkNumber *	fork,
		unsigned *	segno
	)

Definition at line 380 of file reinit.c.

{
    unsigned long n,
                s;
    ForkNumber  f;
    char       *endp;
 
    *relnumber = InvalidRelFileNumber;
    *fork = InvalidForkNumber;
    *segno = 0;
 
    /*
     * Relation filenames should begin with a digit that is not a zero. By
     * rejecting cases involving leading zeroes, the caller can assume that
     * there's only one possible string of characters that could have produced
     * any given value for *relnumber.
     *
     * (To be clear, we don't expect files with names like 0017.3 to exist at
     * all -- but if 0017.3 does exist, it's a non-relation file, not part of
     * the main fork for relfilenode 17.)
     */
    if (name[0] < '1' || name[0] > '9')
        return false;
 
    /*
     * Parse the leading digit string. If the value is out of range, we
     * conclude that this isn't a relation file at all.
     */
    errno = 0;
    n = strtoul(name, &endp, 10);
    if (errno || name == endp || n <= 0 || n > PG_UINT32_MAX)
        return false;
    name = endp;
 
    /* Check for a fork name. */
    if (*name != '_')
        f = MAIN_FORKNUM;
    else
    {
        int         forkchar;
 
        forkchar = forkname_chars(name + 1, &f);
        if (forkchar <= 0)
            return false;
        name += forkchar + 1;
    }
 
    /* Check for a segment number. */
    if (*name != '.')
        s = 0;
    else
    {
        /* Reject leading zeroes, just like we do for RelFileNumber. */
        if (name[1] < '1' || name[1] > '9')
            return false;
 
        errno = 0;
        s = strtoul(name + 1, &endp, 10);
        if (errno || name + 1 == endp || s <= 0 || s > PG_UINT32_MAX)
            return false;
        name = endp;
    }
 
    /* Now we should be at the end. */
    if (*name != '\0')
        return false;
 
    /* Set out parameters and return. */
    *relnumber = (RelFileNumber) n;
    *fork = f;
    *segno = (unsigned) s;
    return true;
}

References forkname_chars(), InvalidForkNumber, InvalidRelFileNumber, MAIN_FORKNUM, name, and PG_UINT32_MAX.

Referenced by ResetUnloggedRelationsInDbspaceDir(), and sendDir().

ResetUnloggedRelations()

void ResetUnloggedRelations

(

int

op

)

Definition at line 47 of file reinit.c.

{
    char        temp_path[MAXPGPATH + sizeof(PG_TBLSPC_DIR) + sizeof(TABLESPACE_VERSION_DIRECTORY)];
    DIR        *spc_dir;
    struct dirent *spc_de;
    MemoryContext tmpctx,
                oldctx;
 
    /* Log it. */
    elog(DEBUG1, "resetting unlogged relations: cleanup %d init %d",
         (op & UNLOGGED_RELATION_CLEANUP) != 0,
         (op & UNLOGGED_RELATION_INIT) != 0);
 
    /*
     * Just to be sure we don't leak any memory, let's create a temporary
     * memory context for this operation.
     */
    tmpctx = AllocSetContextCreate(CurrentMemoryContext,
                                   "ResetUnloggedRelations",
                                   ALLOCSET_DEFAULT_SIZES);
    oldctx = MemoryContextSwitchTo(tmpctx);
 
    /* Prepare to report progress resetting unlogged relations. */
    begin_startup_progress_phase();
 
    /*
     * First process unlogged files in pg_default ($PGDATA/base)
     */
    ResetUnloggedRelationsInTablespaceDir("base", op);
 
    /*
     * Cycle through directories for all non-default tablespaces.
     */
    spc_dir = AllocateDir(PG_TBLSPC_DIR);
 
    while ((spc_de = ReadDir(spc_dir, PG_TBLSPC_DIR)) != NULL)
    {
        if (strcmp(spc_de->d_name, ".") == 0 ||
            strcmp(spc_de->d_name, "..") == 0)
            continue;
 
        snprintf(temp_path, sizeof(temp_path), "%s/%s/%s",
                 PG_TBLSPC_DIR, spc_de->d_name, TABLESPACE_VERSION_DIRECTORY);
        ResetUnloggedRelationsInTablespaceDir(temp_path, op);
    }
 
    FreeDir(spc_dir);
 
    /*
     * Restore memory context.
     */
    MemoryContextSwitchTo(oldctx);
    MemoryContextDelete(tmpctx);
}

References AllocateDir(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, begin_startup_progress_phase(), CurrentMemoryContext, dirent::d_name, DEBUG1, elog, FreeDir(), MAXPGPATH, MemoryContextDelete(), MemoryContextSwitchTo(), PG_TBLSPC_DIR, ReadDir(), ResetUnloggedRelationsInTablespaceDir(), snprintf, TABLESPACE_VERSION_DIRECTORY, UNLOGGED_RELATION_CLEANUP, and UNLOGGED_RELATION_INIT.

Referenced by StartupXLOG().