slru_io.c File Reference

#include "postgres_fe.h"
#include <fcntl.h>
#include "common/fe_memutils.h"
#include "common/file_perm.h"
#include "common/file_utils.h"
#include "pg_upgrade.h"
#include "port/pg_iovec.h"
#include "slru_io.h"

Include dependency graph for slru_io.c:

Go to the source code of this file.

Functions
static SlruSegState *	AllocSlruSegState (const char *dir)
static char *	SlruFileName (SlruSegState *state, int64 segno)
static void	SlruFlush (SlruSegState *state)
SlruSegState *	AllocSlruRead (const char *dir, bool long_segment_names)
char *	SlruReadSwitchPageSlow (SlruSegState *state, uint64 pageno)
void	FreeSlruRead (SlruSegState *state)
SlruSegState *	AllocSlruWrite (const char *dir, bool long_segment_names)
char *	SlruWriteSwitchPageSlow (SlruSegState *state, uint64 pageno)
void	FreeSlruWrite (SlruSegState *state)

Function Documentation

AllocSlruRead()

SlruSegState * AllocSlruRead	(	const char *	dir,
		bool	long_segment_names
	)

Definition at line 62 of file slru_io.c.

{
    SlruSegState *state = AllocSlruSegState(dir);
 
    state->writing = false;
    state->long_segment_names = long_segment_names;
 
    return state;
}

References AllocSlruSegState().

Referenced by AllocOldMultiXactRead().

AllocSlruSegState()

static SlruSegState * AllocSlruSegState ( const char *  dir )

static

Definition at line 27 of file slru_io.c.

{
    SlruSegState *state = pg_malloc(sizeof(*state));
 
    state->dir = pstrdup(dir);
    state->fn = NULL;
    state->fd = -1;
    state->segno = -1;
    state->pageno = 0;
 
    /* state->writing and state->long_segment_names must be set by caller! */
 
    return state;
}

References pg_malloc(), and pstrdup().

Referenced by AllocSlruRead(), and AllocSlruWrite().

AllocSlruWrite()

SlruSegState * AllocSlruWrite	(	const char *	dir,
		bool	long_segment_names
	)

Definition at line 166 of file slru_io.c.

{
    SlruSegState *state = AllocSlruSegState(dir);
 
    state->writing = true;
    state->long_segment_names = long_segment_names;
 
    return state;
}

References AllocSlruSegState().

Referenced by rewrite_multixacts().

FreeSlruRead()

void FreeSlruRead

(

SlruSegState *

state

)

Definition at line 153 of file slru_io.c.

{
    Assert(!state->writing);    /* read only mode */
 
    if (state->fd != -1)
        close(state->fd);
    pg_free(state);
}

References Assert(), close, and pg_free().

Referenced by FreeOldMultiXactReader().

FreeSlruWrite()

void FreeSlruWrite

(

SlruSegState *

state

)

Definition at line 260 of file slru_io.c.

{
    Assert(state->writing);
 
    SlruFlush(state);
 
    if (state->fd != -1)
        close(state->fd);
    pg_free(state);
}

References Assert(), close, pg_free(), and SlruFlush().

Referenced by rewrite_multixacts().

SlruFileName()

static char * SlruFileName ( SlruSegState *  state, int64  segno  )

static

Definition at line 44 of file slru_io.c.

{
    if (state->long_segment_names)
    {
        Assert(segno >= 0 && segno <= INT64CONST(0xFFFFFFFFFFFFFFF));
        return psprintf("%s/%015" PRIX64, state->dir, segno);
    }
    else
    {
        Assert(segno >= 0 && segno <= INT64CONST(0xFFFFFF));
        return psprintf("%s/%04X", state->dir, (unsigned int) segno);
    }
}

References Assert(), INT64CONST, and psprintf().

Referenced by SlruReadSwitchPageSlow(), and SlruWriteSwitchPageSlow().

SlruFlush()

static void SlruFlush ( SlruSegState *  state )

static

Definition at line 239 of file slru_io.c.

{
    struct iovec iovec = {
        .iov_base = &state->buf,
        .iov_len = BLCKSZ,
    };
    off_t       offset;
 
    if (state->segno == -1)
        return;
 
    offset = (state->pageno % SLRU_PAGES_PER_SEGMENT) * BLCKSZ;
 
    if (pg_pwritev_with_retry(state->fd, &iovec, 1, offset) < 0)
        pg_fatal("could not write file \"%s\": %m", state->fn);
}

References pg_fatal, pg_pwritev_with_retry(), and SLRU_PAGES_PER_SEGMENT.

Referenced by FreeSlruWrite(), and SlruWriteSwitchPageSlow().

SlruReadSwitchPageSlow()

char * SlruReadSwitchPageSlow	(	SlruSegState *	state,
		uint64	pageno
	)

Definition at line 85 of file slru_io.c.

{
    int64       segno;
    off_t       offset;
    ssize_t     bytes_read;
 
    Assert(!state->writing);    /* read only mode */
 
    if (state->segno != -1 && pageno == state->pageno)
        return state->buf.data;
 
    /* If the new page is on a different SLRU segment, open the new segment */
    segno = pageno / SLRU_PAGES_PER_SEGMENT;
    if (segno != state->segno)
    {
        if (state->segno != -1)
        {
            close(state->fd);
            state->fd = -1;
 
            pg_free(state->fn);
            state->fn = NULL;
 
            state->segno = -1;
        }
 
        state->fn = SlruFileName(state, segno);
        if ((state->fd = open(state->fn, O_RDONLY | PG_BINARY, 0)) < 0)
            pg_fatal("could not open file \"%s\": %m", state->fn);
        state->segno = segno;
    }
 
    offset = (pageno % SLRU_PAGES_PER_SEGMENT) * BLCKSZ;
    bytes_read = 0;
    while (bytes_read < BLCKSZ)
    {
        ssize_t     rc;
 
        rc = pg_pread(state->fd,
                      &state->buf.data + bytes_read,
                      BLCKSZ - bytes_read,
                      offset);
        if (rc < 0)
        {
            if (errno == EINTR)
                continue;
            pg_fatal("could not read file \"%s\": %m", state->fn);
        }
        if (rc == 0)
        {
            /* unexpected EOF */
            pg_log(PG_WARNING, "unexpected EOF reading file \"%s\" at offset %u, reading as zeros",
                   state->fn, (unsigned int) offset);
            memset(&state->buf.data + bytes_read, 0, BLCKSZ - bytes_read);
            break;
        }
        bytes_read += rc;
        offset += rc;
    }
    state->pageno = pageno;
 
    return state->buf.data;
}

References Assert(), close, EINTR, PG_BINARY, pg_fatal, pg_free(), pg_log(), pg_pread, PG_WARNING, SLRU_PAGES_PER_SEGMENT, and SlruFileName().

Referenced by SlruReadSwitchPage().

SlruWriteSwitchPageSlow()

char * SlruWriteSwitchPageSlow	(	SlruSegState *	state,
		uint64	pageno
	)

Definition at line 187 of file slru_io.c.

{
    int64       segno;
    off_t       offset;
 
    Assert(state->writing);
 
    if (state->segno != -1 && pageno == state->pageno)
        return state->buf.data;
 
    segno = pageno / SLRU_PAGES_PER_SEGMENT;
    offset = (pageno % SLRU_PAGES_PER_SEGMENT) * BLCKSZ;
 
    SlruFlush(state);
    memset(state->buf.data, 0, BLCKSZ);
 
    if (segno != state->segno)
    {
        if (state->segno != -1)
        {
            close(state->fd);
            state->fd = -1;
 
            pg_free(state->fn);
            state->fn = NULL;
 
            state->segno = -1;
        }
 
        /* Create the segment */
        state->fn = SlruFileName(state, segno);
        if ((state->fd = open(state->fn, O_RDWR | O_CREAT | O_EXCL | PG_BINARY,
                              pg_file_create_mode)) < 0)
        {
            pg_fatal("could not create file \"%s\": %m", state->fn);
        }
 
        state->segno = segno;
 
        if (offset > 0)
        {
            if (pg_pwrite_zeros(state->fd, offset, 0) < 0)
                pg_fatal("could not write file \"%s\": %m", state->fn);
        }
    }
 
    state->pageno = pageno;
 
    return state->buf.data;
}

References Assert(), close, PG_BINARY, pg_fatal, pg_file_create_mode, pg_free(), pg_pwrite_zeros(), SLRU_PAGES_PER_SEGMENT, SlruFileName(), and SlruFlush().

Referenced by SlruWriteSwitchPage().