load_manifest.h File Reference

#include "access/xlogdefs.h"
#include "common/checksum_helper.h"
#include "lib/simplehash.h"

Include dependency graph for load_manifest.h:

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

Go to the source code of this file.

Data Structures
struct	manifest_file
struct	manifest_wal_range
struct	manifest_data

Macros
#define	SH_PREFIX   manifest_files
#define	SH_ELEMENT_TYPE   manifest_file
#define	SH_KEY_TYPE   const char *
#define	SH_SCOPE   extern
#define	SH_RAW_ALLOCATOR   pg_malloc0
#define	SH_DECLARE

Typedefs
typedef struct manifest_file	manifest_file
typedef struct manifest_wal_range	manifest_wal_range
typedef struct manifest_data	manifest_data

Functions
manifest_data *	load_backup_manifest (char *backup_directory)
manifest_data **	load_backup_manifests (int n_backups, char **backup_directories)

Macro Definition Documentation

SH_DECLARE

#define SH_DECLARE

Definition at line 37 of file load_manifest.h.

SH_ELEMENT_TYPE

#define SH_ELEMENT_TYPE   manifest_file

Definition at line 33 of file load_manifest.h.

SH_KEY_TYPE

#define SH_KEY_TYPE   const char *

Definition at line 34 of file load_manifest.h.

SH_PREFIX

#define SH_PREFIX   manifest_files

Definition at line 32 of file load_manifest.h.

SH_RAW_ALLOCATOR

#define SH_RAW_ALLOCATOR   pg_malloc0

Definition at line 36 of file load_manifest.h.

SH_SCOPE

#define SH_SCOPE   extern

Definition at line 35 of file load_manifest.h.

Typedef Documentation

manifest_data

typedef struct manifest_data manifest_data

manifest_file

typedef struct manifest_file manifest_file

manifest_wal_range

typedef struct manifest_wal_range manifest_wal_range

Function Documentation

load_backup_manifest()

manifest_data* load_backup_manifest

(

char *

backup_directory

)

Definition at line 105 of file load_manifest.c.

{
    char        pathname[MAXPGPATH];
    int         fd;
    struct stat statbuf;
    off_t       estimate;
    uint32      initial_size;
    manifest_files_hash *ht;
    char       *buffer;
    int         rc;
    JsonManifestParseContext context;
    manifest_data *result;
    int         chunk_size = READ_CHUNK_SIZE;
 
    /* Open the manifest file. */
    snprintf(pathname, MAXPGPATH, "%s/backup_manifest", backup_directory);
    if ((fd = open(pathname, O_RDONLY | PG_BINARY, 0)) < 0)
    {
        if (errno == ENOENT)
        {
            pg_log_warning("file \"%s\" does not exist", pathname);
            return NULL;
        }
        pg_fatal("could not open file \"%s\": %m", pathname);
    }
 
    /* Figure out how big the manifest is. */
    if (fstat(fd, &statbuf) != 0)
        pg_fatal("could not stat file \"%s\": %m", pathname);
 
    /* Guess how large to make the hash table based on the manifest size. */
    estimate = statbuf.st_size / ESTIMATED_BYTES_PER_MANIFEST_LINE;
    initial_size = Min(PG_UINT32_MAX, Max(estimate, 256));
 
    /* Create the hash table. */
    ht = manifest_files_create(initial_size, NULL);
 
    result = pg_malloc0(sizeof(manifest_data));
    result->files = ht;
    context.private_data = result;
    context.version_cb = combinebackup_version_cb;
    context.system_identifier_cb = combinebackup_system_identifier_cb;
    context.per_file_cb = combinebackup_per_file_cb;
    context.per_wal_range_cb = combinebackup_per_wal_range_cb;
    context.error_cb = report_manifest_error;
 
    /*
     * Parse the file, in chunks if necessary.
     */
    if (statbuf.st_size <= chunk_size)
    {
        buffer = pg_malloc(statbuf.st_size);
        rc = read(fd, buffer, statbuf.st_size);
        if (rc != statbuf.st_size)
        {
            if (rc < 0)
                pg_fatal("could not read file \"%s\": %m", pathname);
            else
                pg_fatal("could not read file \"%s\": read %d of %lld",
                         pathname, rc, (long long int) statbuf.st_size);
        }
 
        /* Close the manifest file. */
        close(fd);
 
        /* Parse the manifest. */
        json_parse_manifest(&context, buffer, statbuf.st_size);
    }
    else
    {
        int         bytes_left = statbuf.st_size;
        JsonManifestParseIncrementalState *inc_state;
 
        inc_state = json_parse_manifest_incremental_init(&context);
 
        buffer = pg_malloc(chunk_size + 1);
 
        while (bytes_left > 0)
        {
            int         bytes_to_read = chunk_size;
 
            /*
             * Make sure that the last chunk is sufficiently large. (i.e. at
             * least half the chunk size) so that it will contain fully the
             * piece at the end with the checksum.
             */
            if (bytes_left < chunk_size)
                bytes_to_read = bytes_left;
            else if (bytes_left < 2 * chunk_size)
                bytes_to_read = bytes_left / 2;
            rc = read(fd, buffer, bytes_to_read);
            if (rc != bytes_to_read)
            {
                if (rc < 0)
                    pg_fatal("could not read file \"%s\": %m", pathname);
                else
                    pg_fatal("could not read file \"%s\": read %lld of %lld",
                             pathname,
                             (long long int) (statbuf.st_size + rc - bytes_left),
                             (long long int) statbuf.st_size);
            }
            bytes_left -= rc;
            json_parse_manifest_incremental_chunk(inc_state, buffer, rc, bytes_left == 0);
        }
 
        /* Release the incremental state memory */
        json_parse_manifest_incremental_shutdown(inc_state);
 
        close(fd);
    }
 
    /* All done. */
    pfree(buffer);
    return result;
}

References close, combinebackup_per_file_cb(), combinebackup_per_wal_range_cb(), combinebackup_system_identifier_cb(), combinebackup_version_cb(), context, ESTIMATED_BYTES_PER_MANIFEST_LINE, fd(), manifest_data::files, fstat, json_parse_manifest(), json_parse_manifest_incremental_chunk(), json_parse_manifest_incremental_init(), json_parse_manifest_incremental_shutdown(), Max, MAXPGPATH, Min, pfree(), PG_BINARY, pg_fatal, pg_log_warning, pg_malloc(), pg_malloc0(), PG_UINT32_MAX, read, READ_CHUNK_SIZE, report_manifest_error(), snprintf, and stat::st_size.

Referenced by load_backup_manifests().

load_backup_manifests()

manifest_data** load_backup_manifests	(	int	n_backups,
		char **	backup_directories
	)

Definition at line 83 of file load_manifest.c.

{
    manifest_data **result;
    int         i;
 
    result = pg_malloc(sizeof(manifest_data *) * n_backups);
    for (i = 0; i < n_backups; ++i)
        result[i] = load_backup_manifest(backup_directories[i]);
 
    return result;
}

References i, load_backup_manifest(), and pg_malloc().

Referenced by main().