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 )

extern

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;
    JsonManifestParseContext context;
    manifest_data *result;
    size_t      total_size;
    const size_t 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_object(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;
 
    total_size = statbuf.st_size;
 
    /*
     * Parse the file, in chunks if necessary.
     */
    if (total_size <= chunk_size)
    {
        ssize_t     rc;
 
        buffer = pg_malloc(total_size);
        rc = read(fd, buffer, total_size);
        if (rc != total_size)
        {
            if (rc < 0)
                pg_fatal("could not read file \"%s\": %m", pathname);
            else
                pg_fatal("could not read file \"%s\": read %zd of %zu",
                         pathname, rc, total_size);
        }
 
        /* Close the manifest file. */
        close(fd);
 
        /* Parse the manifest. */
        json_parse_manifest(&context, buffer, total_size);
    }
    else
    {
        size_t      bytes_left = total_size;
        JsonManifestParseIncrementalState *inc_state;
 
        inc_state = json_parse_manifest_incremental_init(&context);
 
        buffer = pg_malloc(chunk_size + 1);
 
        while (bytes_left > 0)
        {
            ssize_t     rc;
            size_t      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 %zu of %zu",
                             pathname,
                             total_size + rc - bytes_left,
                             total_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. */
    pg_free(buffer);
    return result;
}

References close, combinebackup_per_file_cb(), combinebackup_per_wal_range_cb(), combinebackup_system_identifier_cb(), combinebackup_version_cb(), JsonManifestParseContext::error_cb, ESTIMATED_BYTES_PER_MANIFEST_LINE, fb(), fd(), fstat, json_parse_manifest(), json_parse_manifest_incremental_chunk(), json_parse_manifest_incremental_init(), json_parse_manifest_incremental_shutdown(), Max, MAXPGPATH, Min, JsonManifestParseContext::per_file_cb, JsonManifestParseContext::per_wal_range_cb, PG_BINARY, pg_fatal, pg_free(), pg_log_warning, pg_malloc(), pg_malloc0_object, PG_UINT32_MAX, JsonManifestParseContext::private_data, read, READ_CHUNK_SIZE, report_manifest_error(), result, snprintf, JsonManifestParseContext::system_identifier_cb, total_size, and JsonManifestParseContext::version_cb.

Referenced by load_backup_manifests().

load_backup_manifests()

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

extern

Definition at line 83 of file load_manifest.c.

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

References fb(), i, load_backup_manifest(), pg_malloc_array, and result.

Referenced by main().