summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorDana Robinson <43805+derobins@users.noreply.github.com>2022-08-02 19:54:40 (GMT)
committerGitHub <noreply@github.com>2022-08-02 19:54:40 (GMT)
commitfcf41b3cd60df51af9be529e379a9dd6c488d088 (patch)
treee486d5f8254a33b978c34069b9810ce171ba7c2c /src
parentea13de1bb0aba8a97c75f10343dc4c792193b215 (diff)
downloadhdf5-fcf41b3cd60df51af9be529e379a9dd6c488d088.zip
hdf5-fcf41b3cd60df51af9be529e379a9dd6c488d088.tar.gz
hdf5-fcf41b3cd60df51af9be529e379a9dd6c488d088.tar.bz2
Onion VFD (#1953)
* Onion VFD feature * Fixes onion VFD errors with non-sec2 backing store VFDs * Disables the onion VFD tests w/ ph5diff * Disables non-sec2 VFDs as onion VFD backing stores * Committing clang-format changes * Formatted source * Typo * Adds onion VFD tools tests to CMake * Fixes for v16 API compatibility * Memset structs to avoid bad frees on errors * H5Dwrite() calls now use H5T_NATIVE_INT as the memory type vs LE * Properly decodes checksums on BE machines * Be more careful about uint64_t to haddr_t/hsize_t conversions * Another fix for BE data comparison * Removed double underscores from onion constants * Replace hard-coded onion header string w/ constant * Fixes cleanup paths in H5FD__onion_ingest_history() * Fixed use of size_t revision numbers * Fix h5dump revision count format string Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
Diffstat (limited to 'src')
-rw-r--r--src/CMakeLists.txt9
-rw-r--r--src/H5FDonion.c1762
-rw-r--r--src/H5FDonion.h200
-rw-r--r--src/H5FDonion_header.c231
-rw-r--r--src/H5FDonion_header.h56
-rw-r--r--src/H5FDonion_history.c305
-rw-r--r--src/H5FDonion_history.h63
-rw-r--r--src/H5FDonion_index.c935
-rw-r--r--src/H5FDonion_index.h150
-rw-r--r--src/H5FDonion_priv.h28
-rw-r--r--src/H5FDpublic.h1
-rw-r--r--src/H5private.h3
-rw-r--r--src/H5trace.c3
-rw-r--r--src/Makefile.am12
-rw-r--r--src/hdf5.h1
15 files changed, 3754 insertions, 5 deletions
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 3b98874..a835ebd 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -240,6 +240,10 @@ set (H5FD_SOURCES
${HDF5_SRC_DIR}/H5FDmpi.c
${HDF5_SRC_DIR}/H5FDmpio.c
${HDF5_SRC_DIR}/H5FDmulti.c
+ ${HDF5_SRC_DIR}/H5FDonion.c
+ ${HDF5_SRC_DIR}/H5FDonion_header.c
+ ${HDF5_SRC_DIR}/H5FDonion_history.c
+ ${HDF5_SRC_DIR}/H5FDonion_index.c
${HDF5_SRC_DIR}/H5FDperform.c
${HDF5_SRC_DIR}/H5FDros3.c
${HDF5_SRC_DIR}/H5FDs3comms.c
@@ -262,6 +266,7 @@ set (H5FD_HDRS
${HDF5_SRC_DIR}/H5FDmpi.h
${HDF5_SRC_DIR}/H5FDmpio.h
${HDF5_SRC_DIR}/H5FDmulti.h
+ ${HDF5_SRC_DIR}/H5FDonion.h
${HDF5_SRC_DIR}/H5FDpublic.h
${HDF5_SRC_DIR}/H5FDros3.h
${HDF5_SRC_DIR}/H5FDs3comms.h
@@ -902,6 +907,10 @@ set (H5_PRIVATE_HEADERS
${HDF5_SRC_DIR}/H5FAprivate.h
${HDF5_SRC_DIR}/H5FDmirror_priv.h
+ ${HDF5_SRC_DIR}/H5FDonion_header.h
+ ${HDF5_SRC_DIR}/H5FDonion_history.h
+ ${HDF5_SRC_DIR}/H5FDonion_index.h
+ ${HDF5_SRC_DIR}/H5FDonion_priv.h
${HDF5_SRC_DIR}/H5FDpkg.h
${HDF5_SRC_DIR}/H5FDprivate.h
diff --git a/src/H5FDonion.c b/src/H5FDonion.c
new file mode 100644
index 0000000..23ea624
--- /dev/null
+++ b/src/H5FDonion.c
@@ -0,0 +1,1762 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group. *
+ * All rights reserved. *
+ * *
+ * This file is part of HDF5. The full HDF5 copyright notice, including *
+ * terms governing use, modification, and redistribution, is contained in *
+ * the COPYING file, which can be found at the root of the source code *
+ * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. *
+ * If you do not have access to either file, you may request a copy from *
+ * help@hdfgroup.org. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Onion Virtual File Driver (VFD)
+ *
+ * Purpose: Provide in-file provenance and revision/version control.
+ */
+
+/* This source code file is part of the H5FD driver module */
+#include "H5FDdrvr_module.h"
+
+#include "H5private.h" /* Generic Functions */
+#include "H5Eprivate.h" /* Error handling */
+#include "H5Fprivate.h" /* Files */
+#include "H5FDprivate.h" /* File drivers */
+#include "H5FDonion.h" /* Onion file driver */
+#include "H5FDonion_priv.h" /* Onion file driver internals */
+#include "H5FDsec2.h" /* Sec2 file driver */
+#include "H5FLprivate.h" /* Free Lists */
+#include "H5Iprivate.h" /* IDs */
+#include "H5MMprivate.h" /* Memory management */
+
+/* The driver identification number, initialized at runtime */
+static hid_t H5FD_ONION_g = 0;
+
+/******************************************************************************
+ *
+ * Structure: H5FD_onion_t
+ *
+ * Purpose: Store information required to manage an onionized file.
+ * This structure is created when such a file is "opened" and
+ * discarded when it is "closed".
+ *
+ * pu
+ *
+ * Instance of H5FD_t which contains fields common to all VFDs.
+ * It must be the first item in this structure, since at higher levels,
+ * this structure will be treated as an instance of H5FD_t.
+ *
+ * fa
+ *
+ * Instance of `H5FD_onion_fapl_info_t` containing the configuration data
+ * needed to "open" the HDF5 file.
+ *
+ * original_file
+ *
+ * VFD handle for the original HDF5 file.
+ *
+ * onion_file
+ *
+ * VFD handle for the onion file.
+ * NULL if not set to use the single, separate storage target.
+ *
+ * recovery_file
+ *
+ * VFD handle for the history recovery file. This file is a backup of
+ * the existing history when an existing onion file is opened in RW mode.
+ *
+ * recovery_file_name
+ *
+ * String allocated and populated on file-open in write mode and freed on
+ * file-close, stores the path/name of the 'recovery' file. The file
+ * created at this location is to be removed upon successful file-close
+ * from write mode.
+ *
+ * is_open_rw
+ *
+ * Remember whether the file was opened in a read-write mode.
+ *
+ * align_history_on_pages
+ *
+ * Remember whether onion-writes must be aligned to page boundaries.
+ *
+ * header
+ *
+ * In-memory copy of the onion history data header.
+ *
+ * history
+ *
+ * In-memory copy of the onion history.
+ *
+ * curr_rev_record
+ *
+ * Record for the currently open revision.
+ *
+ * rev_index
+ *
+ * Index for maintaining modified pages (RW mode only).
+ * Pointer is NULL when the file is not opened in write mode.
+ * Pointer is allocated on open and must be freed on close.
+ * Contents must be merged with the revision record's archival index prior
+ * to commitment of history to backing store.
+ *
+ * onion_eof
+ *
+ * Last byte in the onion file.
+ *
+ * origin_eof
+ *
+ * Size of the original HDF5 file.
+ *
+ * logical_eoa
+ *
+ * Address of first byte past addressed space in the logical 'file'
+ * presented by this VFD.
+ *
+ * logical_eof
+ *
+ * Address of first byte past last byte in the logical 'file' presented
+ * by this VFD.
+ * Must be copied into the revision record on close to write onion data.
+ *
+ ******************************************************************************
+ */
+typedef struct H5FD_onion_t {
+ H5FD_t pub;
+ H5FD_onion_fapl_info_t fa;
+ hbool_t is_open_rw;
+ hbool_t align_history_on_pages;
+
+ /* Onion-related files */
+ H5FD_t *original_file;
+ H5FD_t *onion_file;
+ H5FD_t *recovery_file;
+ char *recovery_file_name;
+
+ /* Onion data structures */
+ H5FD_onion_header_t header;
+ H5FD_onion_history_t history;
+ H5FD_onion_revision_record_t curr_rev_record;
+ H5FD_onion_revision_index_t *rev_index;
+
+ /* End of addresses and files */
+ haddr_t onion_eof;
+ haddr_t origin_eof;
+ haddr_t logical_eoa;
+ haddr_t logical_eof;
+} H5FD_onion_t;
+
+H5FL_DEFINE_STATIC(H5FD_onion_t);
+
+#define MAXADDR (((haddr_t)1 << (8 * sizeof(HDoff_t) - 1)) - 1)
+
+#define H5FD_CTL_GET_NUM_REVISIONS 20001
+
+/* Prototypes */
+static herr_t H5FD__onion_close(H5FD_t *);
+static haddr_t H5FD__onion_get_eoa(const H5FD_t *, H5FD_mem_t);
+static haddr_t H5FD__onion_get_eof(const H5FD_t *, H5FD_mem_t);
+static H5FD_t *H5FD__onion_open(const char *, unsigned int, hid_t, haddr_t);
+static herr_t H5FD__onion_read(H5FD_t *, H5FD_mem_t, hid_t, haddr_t, size_t, void *);
+static herr_t H5FD__onion_set_eoa(H5FD_t *, H5FD_mem_t, haddr_t);
+static herr_t H5FD__onion_term(void);
+static herr_t H5FD__onion_write(H5FD_t *, H5FD_mem_t, hid_t, haddr_t, size_t, const void *);
+
+static herr_t H5FD__onion_open_rw(H5FD_onion_t *, unsigned int, haddr_t, bool new_open);
+static herr_t H5FD__onion_sb_encode(H5FD_t *_file, char *name /*out*/, unsigned char *buf /*out*/);
+static herr_t H5FD__onion_sb_decode(H5FD_t *_file, const char *name, const unsigned char *buf);
+static hsize_t H5FD__onion_sb_size(H5FD_t *_file);
+static herr_t H5FD__onion_ctl(H5FD_t *_file, uint64_t op_code, uint64_t flags,
+ const void H5_ATTR_UNUSED *input, void H5_ATTR_UNUSED **output);
+static herr_t H5FD__get_onion_revision_count(H5FD_t *file, uint64_t *revision_count);
+
+/* Temporary */
+H5_DLL herr_t H5FD__onion_write_final_history(H5FD_onion_t *file);
+
+static const H5FD_class_t H5FD_onion_g = {
+ H5FD_CLASS_VERSION, /* struct version */
+ H5FD_ONION_VALUE, /* value */
+ "onion", /* name */
+ MAXADDR, /* maxaddr */
+ H5F_CLOSE_WEAK, /* fc_degree */
+ H5FD__onion_term, /* terminate */
+ H5FD__onion_sb_size, /* sb_size */
+ H5FD__onion_sb_encode, /* sb_encode */
+ H5FD__onion_sb_decode, /* sb_decode */
+ sizeof(H5FD_onion_fapl_info_t), /* fapl_size */
+ NULL, /* fapl_get */
+ NULL, /* fapl_copy */
+ NULL, /* fapl_free */
+ 0, /* dxpl_size */
+ NULL, /* dxpl_copy */
+ NULL, /* dxpl_free */
+ H5FD__onion_open, /* open */
+ H5FD__onion_close, /* close */
+ NULL, /* cmp */
+ NULL, /* query */
+ NULL, /* get_type_map */
+ NULL, /* alloc */
+ NULL, /* free */
+ H5FD__onion_get_eoa, /* get_eoa */
+ H5FD__onion_set_eoa, /* set_eoa */
+ H5FD__onion_get_eof, /* get_eof */
+ NULL, /* get_handle */
+ H5FD__onion_read, /* read */
+ H5FD__onion_write, /* write */
+ NULL, /* read_vector */
+ NULL, /* write_vector */
+ NULL, /* read_selection */
+ NULL, /* write_selection */
+ NULL, /* flush */
+ NULL, /* truncate */
+ NULL, /* lock */
+ NULL, /* unlock */
+ NULL, /* del */
+ H5FD__onion_ctl, /* ctl */
+ H5FD_FLMAP_DICHOTOMY /* fl_map */
+};
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD_onion_init
+ *
+ * Purpose: Initialize this driver by registering the driver with the
+ * library.
+ *
+ * Return: Success: The driver ID for the onion driver.
+ * Failure: Negative
+ *-----------------------------------------------------------------------------
+ */
+hid_t
+H5FD_onion_init(void)
+{
+ hid_t ret_value = H5I_INVALID_HID;
+
+ FUNC_ENTER_NOAPI_NOERR
+
+ if (H5I_VFL != H5I_get_type(H5FD_ONION_g))
+ H5FD_ONION_g = H5FD_register(&H5FD_onion_g, sizeof(H5FD_class_t), FALSE);
+
+ /* Set return value */
+ ret_value = H5FD_ONION_g;
+
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FD_onion_init() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_term
+ *
+ * Purpose: Shut down the Onion VFD.
+ *
+ * Returns: SUCCEED (Can't fail)
+ *-----------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__onion_term(void)
+{
+ FUNC_ENTER_PACKAGE_NOERR
+
+ /* Reset VFL ID */
+ H5FD_ONION_g = 0;
+
+ FUNC_LEAVE_NOAPI(SUCCEED);
+
+} /* end H5FD__onion_term() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5Pget_fapl_onion
+ *
+ * Purpose: Copy the Onion configuration information from the FAPL at
+ * `fapl_id` to the destination pointer `fa_out`.
+ *
+ * Return: Success: Non-negative value (SUCCEED).
+ * Failure: Negative value (FAIL).
+ *-----------------------------------------------------------------------------
+ */
+herr_t
+H5Pget_fapl_onion(hid_t fapl_id, H5FD_onion_fapl_info_t *fa_out)
+{
+ const H5FD_onion_fapl_info_t *info_ptr = NULL;
+ H5P_genplist_t *plist = NULL;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_API(FAIL)
+ H5TRACE2("e", "i*!", fapl_id, fa_out);
+
+ if (NULL == fa_out)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "NULL info-out pointer")
+
+ if (NULL == (plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Not a valid FAPL ID")
+
+ if (H5FD_ONION != H5P_peek_driver(plist))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Incorrect VFL driver")
+
+ if (NULL == (info_ptr = (const H5FD_onion_fapl_info_t *)H5P_peek_driver_info(plist)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bad VFL driver info")
+
+ HDmemcpy(fa_out, info_ptr, sizeof(H5FD_onion_fapl_info_t));
+
+done:
+ FUNC_LEAVE_API(ret_value)
+
+} /* end H5Pget_fapl_onion() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5Pset_fapl_onion
+ *
+ * Purpose Set the file access property list at `fapl_id` to use the
+ * Onion virtual file driver with the given configuration.
+ * The info structure may be modified or deleted after this call,
+ * as its contents are copied into the FAPL.
+ *
+ * Return: Success: Non-negative value (SUCCEED).
+ * Failure: Negative value (FAIL).
+ *-----------------------------------------------------------------------------
+ */
+herr_t
+H5Pset_fapl_onion(hid_t fapl_id, const H5FD_onion_fapl_info_t *fa)
+{
+ H5P_genplist_t *fapl = NULL;
+ H5P_genplist_t *backing_fapl = NULL;
+ hid_t backing_vfd_id = H5I_INVALID_HID;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_API(FAIL)
+ H5TRACE2("e", "i*!", fapl_id, fa);
+
+ if (NULL == (fapl = H5P_object_verify(fapl_id, H5P_FILE_ACCESS)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Not a valid FAPL ID");
+ if (NULL == fa)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "NULL info pointer");
+ if (H5FD_ONION_FAPL_INFO_VERSION_CURR != fa->version)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid info version");
+ if (!POWER_OF_TWO(fa->page_size))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid info page size");
+ if (fa->page_size < 1)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid info page size");
+
+ if (H5P_DEFAULT == fa->backing_fapl_id) {
+ if (NULL == (backing_fapl = H5P_object_verify(H5P_FILE_ACCESS_DEFAULT, H5P_FILE_ACCESS)))
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid backing fapl id");
+ }
+ else {
+ if (NULL == (backing_fapl = H5P_object_verify(fa->backing_fapl_id, H5P_FILE_ACCESS)))
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid backing fapl id");
+ }
+
+ /* The only backing fapl that is currently supported is sec2 */
+ if ((backing_vfd_id = H5P_peek_driver(backing_fapl)) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "Can't get VFD from fapl");
+ if (backing_vfd_id != H5FD_SEC2)
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "Onion VFD only supports sec2 backing store");
+
+ if (H5P_set_driver(fapl, H5FD_ONION, (const void *)fa, NULL) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTSET, FAIL, "Can't set the onion VFD");
+
+done:
+ FUNC_LEAVE_API(ret_value)
+} /* end H5Pset_fapl_onion() */
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD__onion_sb_size
+ *
+ * Purpose: Returns the size of the private information to be stored in
+ * the superblock.
+ *
+ * Return: Success: The super block driver data size
+ * Failure: never fails
+ *-------------------------------------------------------------------------
+ */
+static hsize_t
+H5FD__onion_sb_size(H5FD_t *_file)
+{
+ H5FD_onion_t *file = (H5FD_onion_t *)_file;
+ hsize_t ret_value = 0;
+
+ FUNC_ENTER_PACKAGE_NOERR
+
+ /* Sanity check */
+ HDassert(file);
+ HDassert(file->original_file);
+
+ if (file->original_file)
+ ret_value = H5FD_sb_size(file->original_file);
+
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FD__onion_sb_size */
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD__onion_sb_encode
+ *
+ * Purpose: Encodes the superblock information for this driver
+ *
+ * Return: SUCCEED/FAIL
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__onion_sb_encode(H5FD_t *_file, char *name /*out*/, unsigned char *buf /*out*/)
+{
+ H5FD_onion_t *file = (H5FD_onion_t *)_file;
+ herr_t ret_value = SUCCEED; /* Return value */
+
+ FUNC_ENTER_PACKAGE
+
+ /* Sanity check */
+ HDassert(file);
+ HDassert(file->original_file);
+
+ if (file->original_file && H5FD_sb_encode(file->original_file, name, buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTENCODE, FAIL, "unable to encode the superblock in R/W file")
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FD__onion_sb_encode */
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD__onion_sb_decode
+ *
+ * Purpose: Decodes the superblock information for this driver
+ *
+ * Return: SUCCEED/FAIL
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__onion_sb_decode(H5FD_t *_file, const char *name, const unsigned char *buf)
+{
+ H5FD_onion_t *file = (H5FD_onion_t *)_file;
+ herr_t ret_value = SUCCEED; /* Return value */
+
+ FUNC_ENTER_PACKAGE
+
+ /* Sanity check */
+ HDassert(file);
+ HDassert(file->original_file);
+
+ if (H5FD_sb_load(file->original_file, name, buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTDECODE, FAIL, "unable to decode the superblock in R/W file")
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FD__onion_sb_decode */
+
+/*-----------------------------------------------------------------------------
+ * Write in-memory revision record to appropriate backing file.
+ * Update information in other in-memory components.
+ *-----------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__onion_commit_new_revision_record(H5FD_onion_t *file)
+{
+ uint32_t checksum = 0; /* required */
+ size_t size = 0;
+ haddr_t phys_addr = 0; /* offset in history file to record start */
+ unsigned char *buf = NULL;
+ herr_t ret_value = SUCCEED;
+ H5FD_onion_revision_record_t *rec = &file->curr_rev_record;
+ H5FD_onion_history_t *history = &file->history;
+ H5FD_onion_record_loc_t *new_list = NULL;
+
+ time_t rawtime;
+ struct tm *info;
+
+ FUNC_ENTER_PACKAGE
+
+ HDtime(&rawtime);
+ info = HDgmtime(&rawtime);
+ HDstrftime(rec->time_of_creation, sizeof(rec->time_of_creation), "%Y%m%dT%H%M%SZ", info);
+
+ rec->logical_eof = file->logical_eof;
+
+ if ((TRUE == file->is_open_rw) && (H5FD__onion_merge_revision_index_into_archival_index(
+ file->rev_index, &file->curr_rev_record.archival_index) < 0))
+ HGOTO_ERROR(H5E_VFL, H5E_INTERNAL, FAIL, "unable to update index to write")
+
+ if (NULL == (buf = H5MM_malloc(H5FD_ONION_ENCODED_SIZE_REVISION_RECORD + (size_t)rec->comment_size +
+ (H5FD_ONION_ENCODED_SIZE_INDEX_ENTRY * rec->archival_index.n_entries))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't allocate buffer for encoded revision record")
+
+ if (0 == (size = H5FD__onion_revision_record_encode(rec, buf, &checksum)))
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "problem encoding revision record")
+
+ phys_addr = file->onion_eof;
+ if (H5FD_set_eoa(file->onion_file, H5FD_MEM_DRAW, phys_addr + size) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTSET, FAIL, "can't modify EOA for new revision record")
+ if (H5FD_write(file->onion_file, H5FD_MEM_DRAW, phys_addr, size, buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "can't write new revision record")
+
+ file->onion_eof = phys_addr + size;
+ if (TRUE == file->align_history_on_pages)
+ file->onion_eof = (file->onion_eof + (file->header.page_size - 1)) & (~(file->header.page_size - 1));
+
+ /* Update history info to accommodate new revision */
+
+ if (history->n_revisions == 0) {
+ unsigned char *ptr = buf; /* re-use buffer space to compute checksum */
+
+ HDassert(history->record_locs == NULL);
+ history->n_revisions = 1;
+ if (NULL == (history->record_locs = H5MM_calloc(sizeof(H5FD_onion_record_loc_t))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't allocate temporary record pointer list")
+
+ history->record_locs[0].phys_addr = phys_addr;
+ history->record_locs[0].record_size = size;
+ UINT64ENCODE(ptr, phys_addr);
+ UINT64ENCODE(ptr, size);
+ history->record_locs[0].checksum = H5_checksum_fletcher32(buf, (size_t)(ptr - buf));
+ /* TODO: size-reset belongs where? */
+ file->header.history_size += H5FD_ONION_ENCODED_SIZE_RECORD_POINTER;
+ } /* end if no extant revisions in history */
+ else {
+ unsigned char *ptr = buf; /* re-use buffer space to compute checksum */
+
+ HDassert(history->record_locs != NULL);
+
+ if (NULL == (new_list = H5MM_calloc((history->n_revisions + 1) * sizeof(H5FD_onion_record_loc_t))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "unable to resize record pointer list")
+ HDmemcpy(new_list, history->record_locs, sizeof(H5FD_onion_record_loc_t) * history->n_revisions);
+ H5MM_xfree(history->record_locs);
+ history->record_locs = new_list;
+ new_list = NULL;
+ history->record_locs[history->n_revisions].phys_addr = phys_addr;
+ history->record_locs[history->n_revisions].record_size = size;
+ UINT64ENCODE(ptr, phys_addr);
+ UINT64ENCODE(ptr, size);
+ history->record_locs[history->n_revisions].checksum =
+ H5_checksum_fletcher32(buf, (size_t)(ptr - buf));
+
+ file->header.history_size += H5FD_ONION_ENCODED_SIZE_RECORD_POINTER;
+ history->n_revisions += 1;
+ } /* end if one or more revisions present in history */
+
+ file->header.history_addr = file->onion_eof;
+
+done:
+ H5MM_xfree(buf);
+ H5MM_xfree(new_list);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_commit_new_revision_record() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_close
+ *
+ * Purpose: Close an onionized file
+ *
+ * Return: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__onion_close(H5FD_t *_file)
+{
+ H5FD_onion_t *file = (H5FD_onion_t *)_file;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE
+
+ HDassert(file);
+
+ if (H5FD_ONION_STORE_TARGET_ONION == file->fa.store_target) {
+
+ HDassert(file->onion_file);
+
+ if (file->is_open_rw) {
+
+ HDassert(file->recovery_file);
+
+ if (H5FD__onion_commit_new_revision_record(file) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "Can't write revision record to backing store")
+
+ if (H5FD__onion_write_final_history(file) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "Can't write history to backing store")
+
+ /* Unset write-lock flag and write header */
+ if (file->is_open_rw)
+ file->header.flags &= (uint32_t)~H5FD_ONION_HEADER_FLAG_WRITE_LOCK;
+ if (H5FD__onion_write_header(&(file->header), file->onion_file) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "Can't write updated header to backing store")
+ }
+ }
+ else if (H5FD_ONION_STORE_TARGET_H5 == file->fa.store_target)
+ HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "hdf5 store-target not supported")
+ else
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid history target")
+
+done:
+
+ /* Destroy things as best we can, even if there were earlier errors */
+ if (file->original_file)
+ if (H5FD_close(file->original_file) < 0)
+ HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't close backing canon file")
+ if (file->onion_file)
+ if (H5FD_close(file->onion_file) < 0)
+ HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't close backing onion file")
+ if (file->recovery_file) {
+ if (H5FD_close(file->recovery_file) < 0)
+ HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't close backing recovery file")
+ /* TODO: Use the VFD's del callback instead of remove (this requires
+ * storing a copy of the fapl that was used to open it)
+ */
+ HDremove(file->recovery_file_name);
+ }
+ if (file->rev_index)
+ if (H5FD__onion_revision_index_destroy(file->rev_index) < 0)
+ HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't close revision index")
+
+ H5MM_xfree(file->recovery_file_name);
+ H5MM_xfree(file->history.record_locs);
+ H5MM_xfree(file->curr_rev_record.comment);
+ H5MM_xfree(file->curr_rev_record.archival_index.list);
+
+ file = H5FL_FREE(H5FD_onion_t, file);
+
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FD__onion_close() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_get_eoa
+ *
+ * Purpose: Get end-of-address address.
+ *
+ * Return: Address of first byte past the addressed space
+ *-----------------------------------------------------------------------------
+ */
+static haddr_t
+H5FD__onion_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
+{
+ const H5FD_onion_t *file = (const H5FD_onion_t *)_file;
+
+ FUNC_ENTER_PACKAGE_NOERR;
+
+ FUNC_LEAVE_NOAPI(file->logical_eoa)
+} /* end H5FD__onion_get_eoa() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_get_eof
+ *
+ * Purpose: Get end-of-file address.
+ *
+ * Return: Address of first byte past the file-end.
+ *-----------------------------------------------------------------------------
+ */
+static haddr_t
+H5FD__onion_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
+{
+ const H5FD_onion_t *file = (const H5FD_onion_t *)_file;
+
+ FUNC_ENTER_PACKAGE_NOERR;
+
+ FUNC_LEAVE_NOAPI(file->logical_eof)
+} /* end H5FD__onion_get_eof() */
+
+/*-----------------------------------------------------------------------------
+ * Sanitize the backing FAPL ID
+ *-----------------------------------------------------------------------------
+ */
+static inline hid_t
+H5FD__onion_get_legit_fapl_id(hid_t fapl_id)
+{
+ if (H5P_DEFAULT == fapl_id)
+ return H5P_FILE_ACCESS_DEFAULT;
+ else if (TRUE == H5P_isa_class(fapl_id, H5P_FILE_ACCESS))
+ return fapl_id;
+ else
+ return H5I_INVALID_HID;
+}
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD_onion_create_truncate_onion
+ *
+ * Purpose: Create/truncate HDF5 and onion data for a fresh file
+ *
+ * Special open operation required to instantiate the canonical file and
+ * history simultaneously. If successful, the required backing files are
+ * craeated and given initial population on the backing store, and the Onion
+ * virtual file handle is set; open effects a write-mode open.
+ *
+ * Cannot create 'template' history and proceed with normal write-mode open,
+ * as this would in effect create an empty first revision, making the history
+ * unintuitive. (create file -> initialize and commit empty first revision
+ * (revision 0); any data written to file during the 'create' open, as seen by
+ * the user, would be in the second revision (revision 1).)
+ *
+ * Return: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__onion_create_truncate_onion(H5FD_onion_t *file, const char *filename, const char *name_onion,
+ const char *recovery_file_nameery, unsigned int flags, haddr_t maxaddr)
+{
+ hid_t backing_fapl_id = H5I_INVALID_HID;
+ H5FD_onion_header_t *hdr = NULL;
+ H5FD_onion_history_t *history = NULL;
+ H5FD_onion_revision_record_t *rec = NULL;
+ unsigned char *buf = NULL;
+ size_t size = 0;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE;
+
+ HDassert(file != NULL);
+
+ hdr = &file->header;
+ history = &file->history;
+ rec = &file->curr_rev_record;
+
+ hdr->flags = H5FD_ONION_HEADER_FLAG_WRITE_LOCK;
+ if (H5FD_ONION_FAPL_INFO_CREATE_FLAG_ENABLE_DIVERGENT_HISTORY & file->fa.creation_flags)
+ hdr->flags |= H5FD_ONION_HEADER_FLAG_DIVERGENT_HISTORY;
+ if (H5FD_ONION_FAPL_INFO_CREATE_FLAG_ENABLE_PAGE_ALIGNMENT & file->fa.creation_flags)
+ hdr->flags |= H5FD_ONION_HEADER_FLAG_PAGE_ALIGNMENT;
+
+ hdr->origin_eof = 0;
+
+ backing_fapl_id = H5FD__onion_get_legit_fapl_id(file->fa.backing_fapl_id);
+ if (H5I_INVALID_HID == backing_fapl_id)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid backing FAPL ID")
+
+ /* Create backing files for onion history */
+
+ if (NULL == (file->original_file = H5FD_open(filename, flags, backing_fapl_id, maxaddr)))
+ HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "cannot open the backing file")
+
+ if (NULL == (file->onion_file = H5FD_open(name_onion, flags, backing_fapl_id, maxaddr)))
+ HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "cannot open the backing onion file")
+
+ if (NULL == (file->recovery_file = H5FD_open(recovery_file_nameery, flags, backing_fapl_id, maxaddr)))
+ HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "cannot open the backing file")
+
+ /* Write "empty" .h5 file contents (signature ONIONEOF) */
+
+ if (H5FD_set_eoa(file->original_file, H5FD_MEM_DRAW, 8) < 0)
+ HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "can't extend EOA")
+ if (H5FD_write(file->original_file, H5FD_MEM_DRAW, 0, 8, "ONIONEOF") < 0)
+ HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, "cannot write header to the backing h5 file")
+
+ /* Write nascent history (with no revisions) to "recovery" */
+
+ if (NULL == (buf = H5MM_malloc(H5FD_ONION_ENCODED_SIZE_HISTORY)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't allocate buffer")
+ size = H5FD__onion_history_encode(history, buf, &history->checksum);
+ if (H5FD_ONION_ENCODED_SIZE_HISTORY != size)
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "can't encode history")
+ if (H5FD_set_eoa(file->recovery_file, H5FD_MEM_DRAW, size) < 0)
+ HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "can't extend EOA")
+ if (H5FD_write(file->recovery_file, H5FD_MEM_DRAW, 0, size, buf) < 0)
+ HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, "cannot write history to the backing recovery file")
+ hdr->history_size = size; /* record for later use */
+ H5MM_xfree(buf);
+ buf = NULL;
+
+ /* Write history header with "no" history.
+ * Size of the "recovery" history recorded for later use on close.
+ */
+
+ if (NULL == (buf = H5MM_malloc(H5FD_ONION_ENCODED_SIZE_HEADER)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't allocate buffer")
+ size = H5FD__onion_header_encode(hdr, buf, &hdr->checksum);
+ if (H5FD_ONION_ENCODED_SIZE_HEADER != size)
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "can't encode history header")
+ if (H5FD_set_eoa(file->onion_file, H5FD_MEM_DRAW, size) < 0)
+ HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "can't extend EOA")
+ if (H5FD_write(file->onion_file, H5FD_MEM_DRAW, 0, size, buf) < 0)
+ HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, "cannot write header to the backing onion file")
+ file->onion_eof = (haddr_t)size;
+ if (TRUE == file->align_history_on_pages)
+ file->onion_eof = (file->onion_eof + (hdr->page_size - 1)) & (~(hdr->page_size - 1));
+
+ rec->archival_index.list = NULL;
+
+ if (NULL == (file->rev_index = H5FD__onion_revision_index_init(file->fa.page_size)))
+ HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "can't initialize revision index")
+
+done:
+ H5MM_xfree(buf);
+
+ if (FAIL == ret_value)
+ HDremove(recovery_file_nameery); /* destroy new temp file, if 'twas created */
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_create_truncate_onion() */
+
+static herr_t
+H5FD__onion_remove_unused_symbols(char *s)
+{
+ char *d = s;
+
+ FUNC_ENTER_PACKAGE_NOERR;
+
+ do {
+ while (*d == '{' || *d == '}' || *d == ' ') {
+ ++d;
+ }
+ } while ((*s++ = *d++));
+
+ FUNC_LEAVE_NOAPI(SUCCEED);
+}
+
+static herr_t
+H5FD__onion_parse_config_str(const char *config_str, H5FD_onion_fapl_info_t *fa)
+{
+ char *config_str_copy = NULL;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE;
+
+ if (!HDstrcmp(config_str, ""))
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "configure string can't be empty")
+
+ /* Initialize to the default values */
+ fa->version = H5FD_ONION_FAPL_INFO_VERSION_CURR;
+ fa->backing_fapl_id = H5P_DEFAULT;
+ fa->page_size = 4;
+ fa->store_target = H5FD_ONION_STORE_TARGET_ONION;
+ fa->revision_num = H5FD_ONION_FAPL_INFO_REVISION_ID_LATEST;
+ fa->force_write_open = 0;
+ fa->creation_flags = 0;
+ HDstrcpy(fa->comment, "initial comment");
+
+ /* If a single integer is passed in as a string, it's a shortcut for the tools
+ * (h5repack, h5diff, h5dump). Otherwise, the string should have curly brackets,
+ * e.g. {revision_num: 2; page_size: 4;}
+ */
+ if (config_str[0] != '{')
+ fa->revision_num = (uint64_t)HDstrtoull(config_str, NULL, 10);
+ else {
+ char *token1 = NULL, *token2 = NULL;
+
+ /* Duplicate the configure string since strtok will mess with it */
+ if (NULL == (config_str_copy = H5MM_strdup(config_str)))
+ HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "can't duplicate configure string")
+
+ /* Remove the curly brackets and space from the configure string */
+ H5FD__onion_remove_unused_symbols(config_str_copy);
+
+ /* The configure string can't be empty after removing the curly brackets */
+ if (!HDstrcmp(config_str_copy, ""))
+ HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "configure string can't be empty")
+
+ token1 = HDstrtok(config_str_copy, ":");
+ token2 = HDstrtok(NULL, ";");
+
+ do {
+ if (token1 && token2) {
+ if (!HDstrcmp(token1, "version")) {
+ if (!HDstrcmp(token2, "H5FD_ONION_FAPL_INFO_VERSION_CURR"))
+ fa->version = H5FD_ONION_FAPL_INFO_VERSION_CURR;
+ }
+ else if (!HDstrcmp(token1, "backing_fapl_id")) {
+ if (!HDstrcmp(token2, "H5P_DEFAULT"))
+ fa->backing_fapl_id = H5P_DEFAULT;
+ else if (!strcmp(token2, "H5I_INVALID_HID"))
+ fa->backing_fapl_id = H5I_INVALID_HID;
+ else
+ fa->backing_fapl_id = HDstrtoll(token2, NULL, 10);
+ }
+ else if (!HDstrcmp(token1, "page_size")) {
+ fa->page_size = (uint32_t)HDstrtoul(token2, NULL, 10);
+ }
+ else if (!HDstrcmp(token1, "revision_num")) {
+ if (!HDstrcmp(token2, "H5FD_ONION_FAPL_INFO_REVISION_ID_LATEST"))
+ fa->revision_num = H5FD_ONION_FAPL_INFO_REVISION_ID_LATEST;
+ else
+ fa->revision_num = (uint64_t)HDstrtoull(token2, NULL, 10);
+ }
+ else if (!HDstrcmp(token1, "force_write_open")) {
+ fa->force_write_open = (uint8_t)HDstrtoul(token2, NULL, 10);
+ }
+ else if (!HDstrcmp(token1, "creation_flags")) {
+ fa->creation_flags = (uint8_t)HDstrtoul(token2, NULL, 10);
+ }
+ else if (!HDstrcmp(token1, "comment")) {
+ HDstrcpy(fa->comment, token2);
+ }
+ else
+ HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "unknown token in the configure string: %s",
+ token1)
+ }
+
+ token1 = HDstrtok(NULL, ":");
+ token2 = HDstrtok(NULL, ";");
+ } while (token1);
+ }
+
+ if (H5P_DEFAULT == fa->backing_fapl_id || H5I_INVALID_HID == fa->backing_fapl_id) {
+ H5P_genclass_t *pclass; /* Property list class to modify */
+
+ if (NULL == (pclass = (H5P_genclass_t *)H5I_object_verify(H5P_FILE_ACCESS, H5I_GENPROP_CLS)))
+ HGOTO_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a property list class");
+
+ /* Create the new property list */
+ if ((fa->backing_fapl_id = H5P_create_id(pclass, TRUE)) < 0)
+ HGOTO_ERROR(H5E_PLIST, H5E_CANTCREATE, FAIL, "unable to create property list");
+ }
+
+done:
+ H5MM_free(config_str_copy);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+}
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_open
+ *
+ * Purpose: Open an onionized file
+ *
+ * Return: Success: A pointer to a new file data structure
+ * Failure: NULL
+ *-----------------------------------------------------------------------------
+ */
+static H5FD_t *
+H5FD__onion_open(const char *filename, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
+{
+ H5P_genplist_t *plist = NULL;
+ H5FD_onion_t *file = NULL;
+ const H5FD_onion_fapl_info_t *fa = NULL;
+ H5FD_onion_fapl_info_t *new_fa = NULL;
+ const char *config_str = NULL;
+ hid_t backing_fapl_id = H5I_INVALID_HID;
+ char *name_onion = NULL;
+ char *recovery_file_nameery = NULL;
+ bool new_open = false;
+ haddr_t canon_eof = 0;
+ H5FD_t *ret_value = NULL;
+
+ FUNC_ENTER_PACKAGE
+
+ /* Check arguments */
+ if (!filename || !*filename)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid file name")
+ if (0 == maxaddr || HADDR_UNDEF == maxaddr)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "bogus maxaddr")
+ HDassert(H5P_DEFAULT != fapl_id);
+ if (NULL == (plist = (H5P_genplist_t *)H5I_object(fapl_id)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a file access property list")
+
+ /* This VFD can be invoked by either H5Pset_fapl_onion() or
+ * H5Pset_driver_by_name(). When invoked by the former, there will be
+ * driver info to peek at.
+ */
+ fa = (const H5FD_onion_fapl_info_t *)H5P_peek_driver_info(plist);
+
+ if (NULL == fa) {
+ if (NULL == (config_str = H5P_peek_driver_config_str(plist)))
+ HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, NULL, "missing VFL driver configure string")
+
+ /* Allocate a new onion fapl info struct and fill it from the
+ * configuration string
+ */
+ if (NULL == (new_fa = H5MM_calloc(sizeof(H5FD_onion_fapl_info_t))))
+ HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "can't allocate memory for onion fapl info struct")
+ if (H5FD__onion_parse_config_str(config_str, new_fa) < 0)
+ HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, NULL, "failed to parse configure string")
+
+ fa = new_fa;
+ }
+
+ /* Check for unsupported target values */
+ if (H5FD_ONION_STORE_TARGET_H5 == fa->store_target)
+ HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, NULL, "same-file storage not implemented")
+ else if (H5FD_ONION_STORE_TARGET_ONION != fa->store_target)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid store target")
+
+ /* Allocate space for the file struct */
+ if (NULL == (file = H5FL_CALLOC(H5FD_onion_t)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, NULL, "unable to allocate file struct")
+
+ /* Allocate space for onion VFD file names */
+ if (NULL == (name_onion = H5MM_malloc(sizeof(char) * (HDstrlen(filename) + 7))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, NULL, "unable to allocate onion name string")
+ HDsnprintf(name_onion, HDstrlen(filename) + 7, "%s.onion", filename);
+
+ if (NULL == (recovery_file_nameery = H5MM_malloc(sizeof(char) * (HDstrlen(name_onion) + 10))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, NULL, "unable to allocate recovery name string")
+ HDsnprintf(recovery_file_nameery, HDstrlen(name_onion) + 10, "%s.recovery", name_onion);
+ file->recovery_file_name = recovery_file_nameery;
+
+ if (NULL == (file->recovery_file_name = H5MM_malloc(sizeof(char) * (HDstrlen(name_onion) + 10))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, NULL, "unable to allocate recovery name string")
+ HDsnprintf(file->recovery_file_name, HDstrlen(name_onion) + 10, "%s.recovery", name_onion);
+
+ /* Translate H5P_DEFAULT to a a real fapl ID, if necessary */
+ backing_fapl_id = H5FD__onion_get_legit_fapl_id(file->fa.backing_fapl_id);
+ if (H5I_INVALID_HID == backing_fapl_id)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid backing FAPL ID");
+
+ /* Initialize file structure fields */
+
+ HDmemcpy(&(file->fa), fa, sizeof(H5FD_onion_fapl_info_t));
+
+ file->header.version = H5FD_ONION_HEADER_VERSION_CURR;
+ file->header.page_size = file->fa.page_size; /* guarded on FAPL-set */
+
+ file->history.version = H5FD_ONION_HISTORY_VERSION_CURR;
+
+ file->curr_rev_record.version = H5FD_ONION_REVISION_RECORD_VERSION_CURR;
+ file->curr_rev_record.archival_index.version = H5FD_ONION_ARCHIVAL_INDEX_VERSION_CURR;
+
+ /* Check that the page size is a power of two */
+ if ((fa->page_size == 0) || ((fa->page_size & (fa->page_size - 1)) != 0))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "page size is not a power of two")
+
+ /* Assign the page size */
+ double log2_page_size = HDlog2((double)(fa->page_size));
+ file->curr_rev_record.archival_index.page_size_log2 = (uint32_t)log2_page_size;
+
+ /* Proceed with open. */
+
+ if ((H5F_ACC_CREAT | H5F_ACC_TRUNC) & flags) {
+
+ /* Create a new onion file from scratch */
+
+ /* Set flags */
+ if (fa->creation_flags & H5FD_ONION_FAPL_INFO_CREATE_FLAG_ENABLE_PAGE_ALIGNMENT) {
+ file->header.flags |= H5FD_ONION_HEADER_FLAG_PAGE_ALIGNMENT;
+ file->align_history_on_pages = TRUE;
+ }
+
+ /* Truncate and create everything as necessary */
+ if (H5FD__onion_create_truncate_onion(file, filename, name_onion, file->recovery_file_name, flags,
+ maxaddr) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTCREATE, NULL, "unable to create/truncate onionized files")
+ file->is_open_rw = TRUE;
+ }
+ else {
+
+ /* Opening an existing onion file */
+
+ /* Open the existing file using the specified fapl */
+ if (NULL == (file->original_file = H5FD_open(filename, flags, backing_fapl_id, maxaddr)))
+ HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL, "unable to open canonical file (does not exist?)")
+
+ /* Try to open any existing onion file */
+ H5E_BEGIN_TRY
+ {
+ file->onion_file = H5FD_open(name_onion, flags, backing_fapl_id, maxaddr);
+ }
+ H5E_END_TRY;
+
+ /* If that didn't work, create a new onion file */
+ /* TODO: Move to a new function */
+ if (NULL == file->onion_file) {
+ if (H5F_ACC_RDWR & flags) {
+ H5FD_onion_header_t *hdr = NULL;
+ H5FD_onion_history_t *history = NULL;
+ H5FD_onion_revision_record_t *rec = NULL;
+ unsigned char *head_buf = NULL;
+ unsigned char *hist_buf = NULL;
+ size_t size = 0;
+ size_t saved_size = 0;
+
+ HDassert(file != NULL);
+
+ hdr = &file->header;
+ history = &file->history;
+ rec = &file->curr_rev_record;
+
+ new_open = true;
+
+ if (H5FD_ONION_FAPL_INFO_CREATE_FLAG_ENABLE_DIVERGENT_HISTORY & file->fa.creation_flags)
+ hdr->flags |= H5FD_ONION_HEADER_FLAG_DIVERGENT_HISTORY;
+ if (H5FD_ONION_FAPL_INFO_CREATE_FLAG_ENABLE_PAGE_ALIGNMENT & file->fa.creation_flags) {
+ hdr->flags |= H5FD_ONION_HEADER_FLAG_PAGE_ALIGNMENT;
+ file->align_history_on_pages = TRUE;
+ }
+
+ if (HADDR_UNDEF == (canon_eof = H5FD_get_eof(file->original_file, H5FD_MEM_DEFAULT))) {
+ HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, NULL, "cannot get size of canonical file")
+ }
+ if (H5FD_set_eoa(file->original_file, H5FD_MEM_DRAW, canon_eof) < 0)
+ HGOTO_ERROR(H5E_FILE, H5E_CANTSET, NULL, "can't extend EOA")
+ hdr->origin_eof = canon_eof;
+ file->logical_eof = canon_eof;
+
+ backing_fapl_id = H5FD__onion_get_legit_fapl_id(file->fa.backing_fapl_id);
+
+ if (H5I_INVALID_HID == backing_fapl_id)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid backing FAPL ID")
+
+ /* Create backing files for onion history */
+
+ if ((file->onion_file = H5FD_open(name_onion, (H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC),
+ backing_fapl_id, maxaddr)) == NULL) {
+ HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "cannot open the backing onion file")
+ }
+
+ /* Write history header with "no" history */
+ hdr->history_size = H5FD_ONION_ENCODED_SIZE_HISTORY; /* record for later use */
+ hdr->history_addr =
+ H5FD_ONION_ENCODED_SIZE_HEADER + 1; /* TODO: comment these 2 or do some other way */
+ head_buf = H5MM_malloc(H5FD_ONION_ENCODED_SIZE_HEADER);
+ if (NULL == head_buf)
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, NULL, "can't allocate buffer")
+ size = H5FD__onion_header_encode(hdr, head_buf, &hdr->checksum);
+ if (H5FD_ONION_ENCODED_SIZE_HEADER != size)
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, NULL, "can't encode history header")
+
+ hist_buf = H5MM_malloc(H5FD_ONION_ENCODED_SIZE_HISTORY);
+ if (NULL == hist_buf)
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, NULL, "can't allocate buffer")
+ saved_size = size;
+ history->n_revisions = 0;
+ size = H5FD__onion_history_encode(history, hist_buf, &history->checksum);
+ file->header.history_size = size; /* record for later use */
+ if (H5FD_ONION_ENCODED_SIZE_HISTORY != size) {
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, NULL, "can't encode history")
+ }
+ if (H5FD_set_eoa(file->onion_file, H5FD_MEM_DRAW, saved_size + size + 1) < 0)
+ HGOTO_ERROR(H5E_FILE, H5E_CANTSET, NULL, "can't extend EOA")
+
+ if (H5FD_write(file->onion_file, H5FD_MEM_DRAW, 0, saved_size, head_buf) < 0) {
+ HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, NULL,
+ "cannot write header to the backing onion file")
+ }
+
+ file->onion_eof = (haddr_t)saved_size;
+ if (TRUE == file->align_history_on_pages)
+ file->onion_eof = (file->onion_eof + (hdr->page_size - 1)) & (~(hdr->page_size - 1));
+
+ rec->archival_index.list = NULL;
+
+ file->header.history_addr = file->onion_eof;
+
+ /* Write nascent history (with no revisions) to the backing onion file */
+ if (H5FD_write(file->onion_file, H5FD_MEM_DRAW, saved_size + 1, size, hist_buf) < 0) {
+ HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, NULL,
+ "cannot write history to the backing onion file")
+ }
+
+ file->header.history_size = size; /* record for later use */
+
+ H5MM_xfree(head_buf);
+ H5MM_xfree(hist_buf);
+ }
+ else {
+ HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL, "unable to open onion file (does not exist?).")
+ }
+ }
+
+ if (HADDR_UNDEF == (canon_eof = H5FD_get_eof(file->original_file, H5FD_MEM_DEFAULT))) {
+ HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, NULL, "cannot get size of canonical file")
+ }
+ if (H5FD_set_eoa(file->original_file, H5FD_MEM_DRAW, canon_eof) < 0)
+ HGOTO_ERROR(H5E_FILE, H5E_CANTSET, NULL, "can't extend EOA")
+
+ /* Get the history header from the onion file */
+ if (H5FD__onion_ingest_header(&file->header, file->onion_file, 0) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTDECODE, NULL, "can't get history header from backing store")
+ file->align_history_on_pages =
+ (file->header.flags & H5FD_ONION_HEADER_FLAG_PAGE_ALIGNMENT) ? TRUE : FALSE;
+
+ if (H5FD_ONION_HEADER_FLAG_WRITE_LOCK & file->header.flags) {
+ /* Opening a file twice in write mode is an error */
+ HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, NULL, "Can't open file already opened in write-mode")
+ }
+ else {
+ /* Read in the history from the onion file */
+ if (H5FD__onion_ingest_history(&file->history, file->onion_file, file->header.history_addr,
+ file->header.history_size) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTDECODE, NULL, "can't get history from backing store")
+
+ /* Sanity check on revision ID */
+ if (fa->revision_num > file->history.n_revisions &&
+ fa->revision_num != H5FD_ONION_FAPL_INFO_REVISION_ID_LATEST)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "target revision ID out of range")
+
+ if (fa->revision_num == 0) {
+ file->curr_rev_record.logical_eof = canon_eof;
+ }
+ else if (file->history.n_revisions > 0 &&
+ H5FD__onion_ingest_revision_record(
+ &file->curr_rev_record, file->onion_file, &file->history,
+ MIN(fa->revision_num - 1, (file->history.n_revisions - 1))) < 0) {
+ HGOTO_ERROR(H5E_VFL, H5E_CANTDECODE, NULL, "can't get revision record from backing store")
+ }
+
+ if (H5F_ACC_RDWR & flags)
+ if (H5FD__onion_open_rw(file, flags, maxaddr, new_open) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL, "can't write-open write-locked file")
+ }
+
+ } /* End if opening existing file */
+
+ /* Copy comment from FAPL info, if one is given */
+ if ((H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC) & flags) {
+ if (fa->comment) {
+ /* Free the old comment */
+ file->curr_rev_record.comment = H5MM_xfree(file->curr_rev_record.comment);
+
+ /* TODO: Lengths of strings should be size_t */
+ file->curr_rev_record.comment_size = (uint32_t)HDstrlen(fa->comment) + 1;
+
+ if (NULL == (file->curr_rev_record.comment = H5MM_xstrdup(fa->comment)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, NULL, "unable to allocate comment string")
+ }
+ }
+ file->origin_eof = file->header.origin_eof;
+ file->logical_eof = MAX(file->curr_rev_record.logical_eof, file->logical_eof);
+ file->logical_eoa = 0;
+
+ file->onion_eof = H5FD_get_eoa(file->onion_file, H5FD_MEM_DRAW);
+ if (TRUE == file->align_history_on_pages)
+ file->onion_eof = (file->onion_eof + (file->header.page_size - 1)) & (~(file->header.page_size - 1));
+
+ ret_value = (H5FD_t *)file;
+
+done:
+ H5MM_xfree(name_onion);
+ H5MM_xfree(recovery_file_nameery);
+
+ if (config_str && new_fa)
+ if (fa && fa->backing_fapl_id)
+ if (H5I_GENPROP_LST == H5I_get_type(fa->backing_fapl_id))
+ H5I_dec_app_ref(fa->backing_fapl_id);
+
+ if ((NULL == ret_value) && file) {
+
+ if (file->original_file)
+ if (H5FD_close(file->original_file) < 0)
+ HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, NULL, "can't destroy backing canon")
+ if (file->onion_file)
+ if (H5FD_close(file->onion_file) < 0)
+ HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, NULL, "can't destroy backing onion")
+ if (file->recovery_file)
+ if (H5FD_close(file->recovery_file) < 0)
+ HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, NULL, "can't destroy backing recov")
+
+ if (file->rev_index)
+ if (H5FD__onion_revision_index_destroy(file->rev_index) < 0)
+ HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, NULL, "can't destroy revision index")
+
+ H5MM_xfree(file->history.record_locs);
+
+ H5MM_xfree(file->recovery_file_name);
+ H5MM_xfree(file->curr_rev_record.comment);
+
+ H5FL_FREE(H5FD_onion_t, file);
+ }
+
+ H5MM_xfree(new_fa);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_open() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_open_rw
+ *
+ * Purpose: Complete onion file-open, handling process for write mode.
+ *
+ * Creates recovery file if one does not exist.
+ * Initializes 'live' revision index.
+ * Force write-open is not yet supported (recovery provision) TODO
+ * Establishes write-lock in history header (sets lock flag).
+ *
+ * Return: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__onion_open_rw(H5FD_onion_t *file, unsigned int flags, haddr_t maxaddr, bool new_open)
+{
+ unsigned char *buf = NULL;
+ size_t size = 0;
+ uint32_t checksum = 0;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE;
+
+ /* Guard against simultaneous write-open.
+ * TODO: support recovery open with force-write-open flag in FAPL info.
+ */
+
+ if (file->header.flags & H5FD_ONION_HEADER_FLAG_WRITE_LOCK)
+ HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "can't write-open write-locked file")
+
+ /* Copy history to recovery file */
+
+ if (NULL ==
+ (file->recovery_file = H5FD_open(file->recovery_file_name, (flags | H5F_ACC_CREAT | H5F_ACC_TRUNC),
+ file->fa.backing_fapl_id, maxaddr)))
+ HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, FAIL, "unable to create recovery file")
+
+ if (0 == (size = H5FD__onion_write_history(&file->history, file->recovery_file, 0, 0)))
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "can't write history to recovery file")
+ if (size != file->header.history_size)
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "written history differed from expected size")
+
+ /* Set write-lock flag in onion header */
+
+ if (NULL == (buf = H5MM_malloc(H5FD_ONION_ENCODED_SIZE_HEADER)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't allocate space for encoded buffer")
+
+ file->header.flags |= H5FD_ONION_HEADER_FLAG_WRITE_LOCK;
+
+ if (0 == (size = H5FD__onion_header_encode(&file->header, buf, &checksum)))
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "problem encoding history header")
+
+ if (H5FD_write(file->onion_file, H5FD_MEM_DRAW, 0, size, buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "can't write updated history header")
+
+ /* Prepare revision index and finalize write-mode open */
+
+ if (NULL == (file->rev_index = H5FD__onion_revision_index_init(file->fa.page_size)))
+ HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "can't initialize revision index")
+ file->curr_rev_record.parent_revision_num = file->curr_rev_record.revision_num;
+ if (!new_open)
+ file->curr_rev_record.revision_num += 1;
+ file->is_open_rw = TRUE;
+
+done:
+ if (FAIL == ret_value) {
+ if (file->recovery_file != NULL) {
+ if (H5FD_close(file->recovery_file) < 0)
+ HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "can't close recovery file")
+ file->recovery_file = NULL;
+ }
+
+ if (file->rev_index != NULL) {
+ if (H5FD__onion_revision_index_destroy(file->rev_index) < 0)
+ HDONE_ERROR(H5E_VFL, H5E_CANTRELEASE, FAIL, "can't destroy revision index")
+ file->rev_index = NULL;
+ }
+ }
+
+ H5MM_xfree(buf);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_open_rw() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_read
+ *
+ * Purpose: Read bytes from an onionized file
+ *
+ * Return: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__onion_read(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t offset, size_t len,
+ void *_buf_out)
+{
+ H5FD_onion_t *file = (H5FD_onion_t *)_file;
+ uint64_t page_0 = 0;
+ size_t n_pages = 0;
+ uint32_t page_size = 0;
+ uint32_t page_size_log2 = 0;
+ size_t bytes_to_read = len;
+ unsigned char *buf_out = (unsigned char *)_buf_out;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE
+
+ HDassert(file != NULL);
+ HDassert(buf_out != NULL);
+
+ if ((uint64_t)(offset + len) > file->logical_eoa)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Read extends beyond addressed space")
+
+ if (0 == len)
+ goto done;
+
+ page_size = file->header.page_size;
+ page_size_log2 = file->curr_rev_record.archival_index.page_size_log2;
+ page_0 = offset >> page_size_log2;
+ n_pages = (len + page_size - 1) >> page_size_log2;
+
+ /* Read, page-by-page */
+ for (size_t i = 0; i < n_pages; i++) {
+ const H5FD_onion_index_entry_t *entry_out = NULL;
+ haddr_t page_gap_head = 0; /* start of page to start of buffer */
+ haddr_t page_gap_tail = 0; /* end of buffer to end of page */
+ size_t page_readsize = 0;
+ uint64_t page_i = page_0 + i;
+
+ if (0 == i) {
+ page_gap_head = offset & (((uint32_t)1 << page_size_log2) - 1);
+ /* Check if we need to add an additional page to make up for the page_gap_head */
+ if (page_gap_head > 0 &&
+ (page_gap_head + (bytes_to_read % page_size) > page_size || bytes_to_read % page_size == 0)) {
+ n_pages++;
+ }
+ }
+
+ if (n_pages - 1 == i)
+ page_gap_tail = page_size - bytes_to_read - page_gap_head;
+
+ page_readsize = (size_t)page_size - page_gap_head - page_gap_tail;
+
+ if (TRUE == file->is_open_rw && file->fa.revision_num != 0 &&
+ H5FD__onion_revision_index_find(file->rev_index, page_i, &entry_out)) {
+ /* Page exists in 'live' revision index */
+ if (H5FD_read(file->onion_file, H5FD_MEM_DRAW, entry_out->phys_addr + page_gap_head,
+ page_readsize, buf_out) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "can't get working file data")
+ }
+ else if (file->fa.revision_num != 0 &&
+ H5FD__onion_archival_index_find(&file->curr_rev_record.archival_index, page_i, &entry_out)) {
+ /* Page exists in archival index */
+ if (H5FD_read(file->onion_file, H5FD_MEM_DRAW, entry_out->phys_addr + page_gap_head,
+ page_readsize, buf_out) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "can't get previously-amended file data")
+ }
+ else {
+ /* Page does not exist in either index */
+
+ /* Casts prevent truncation */
+ haddr_t addr_start = (haddr_t)page_i * (haddr_t)page_size + (haddr_t)page_gap_head;
+ haddr_t overlap_size = (addr_start > file->origin_eof) ? 0 : file->origin_eof - addr_start;
+ haddr_t read_size = MIN(overlap_size, page_readsize);
+
+ /* Get all original bytes in page range */
+ if ((read_size > 0) && H5FD_read(file->original_file, type, addr_start, read_size, buf_out) < 0) {
+ HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "can't get original file data")
+ }
+
+ /* Fill with 0s any gaps after end of original bytes
+ * and before end of page.
+ */
+ for (size_t j = read_size; j < page_readsize; j++)
+ buf_out[j] = 0;
+ }
+
+ buf_out += page_readsize;
+ bytes_to_read -= page_readsize;
+ } /* end for each page in range */
+
+ HDassert(0 == bytes_to_read);
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_read() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_set_eoa
+ *
+ * Purpose: Set end-of-address marker of the logical file.
+ *
+ * Return: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__onion_set_eoa(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr)
+{
+ H5FD_onion_t *file = (H5FD_onion_t *)_file;
+
+ FUNC_ENTER_PACKAGE_NOERR;
+
+ file->logical_eoa = addr;
+
+ FUNC_LEAVE_NOAPI(SUCCEED);
+} /* end H5FD__onion_set_eoa() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_write
+ *
+ * Purpose: Write bytes to an onionized file
+ *
+ * Return: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__onion_write(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t offset, size_t len,
+ const void *_buf)
+{
+ H5FD_onion_t *file = (H5FD_onion_t *)_file;
+ uint64_t page_0 = 0;
+ size_t n_pages = 0;
+ unsigned char *page_buf = NULL;
+ uint32_t page_size = 0;
+ uint32_t page_size_log2 = 0;
+ size_t bytes_to_write = len;
+ const unsigned char *buf = (const unsigned char *)_buf;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE
+
+ HDassert(file != NULL);
+ HDassert(buf != NULL);
+ HDassert(file->rev_index != NULL);
+ HDassert((uint64_t)(offset + len) <= file->logical_eoa);
+
+ if (FALSE == file->is_open_rw)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Write not allowed if file not opened in write mode")
+
+ if (0 == len)
+ goto done;
+
+ page_size = file->header.page_size;
+ page_size_log2 = file->curr_rev_record.archival_index.page_size_log2;
+ page_0 = offset >> page_size_log2;
+ n_pages = (len + page_size - 1) >> page_size_log2;
+
+ if (NULL == (page_buf = H5MM_calloc(page_size * sizeof(unsigned char))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "cannot allocate temporary buffer")
+
+ /* Write, page-by-page */
+ for (size_t i = 0; i < n_pages; i++) {
+ const unsigned char *write_buf = buf;
+ H5FD_onion_index_entry_t new_entry;
+ const H5FD_onion_index_entry_t *entry_out = NULL;
+ haddr_t page_gap_head = 0; /* start of page to start of buffer */
+ haddr_t page_gap_tail = 0; /* end of buffer to end of page */
+ size_t page_n_used = 0; /* nbytes from buffer for this page-write */
+ uint64_t page_i = page_0 + i;
+
+ if (0 == i) {
+ page_gap_head = offset & (((uint32_t)1 << page_size_log2) - 1);
+ /* If we have a page_gap_head and the number of bytes to write is
+ * evenly divisible by the page size we need to add an additional
+ * page to make up for the page_gap_head
+ */
+ if (page_gap_head > 0 && (page_gap_head + (bytes_to_write % page_size) > page_size ||
+ bytes_to_write % page_size == 0)) {
+ n_pages++;
+ }
+ }
+ if (n_pages - 1 == i)
+ page_gap_tail = page_size - bytes_to_write - page_gap_head;
+ page_n_used = page_size - page_gap_head - page_gap_tail;
+
+ /* Modify page in revision index, if present */
+ if (H5FD__onion_revision_index_find(file->rev_index, page_i, &entry_out)) {
+ if (page_gap_head | page_gap_tail) {
+ /* Copy existing page verbatim. */
+ if (H5FD_read(file->onion_file, H5FD_MEM_DRAW, entry_out->phys_addr, page_size, page_buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "can't get working file data")
+ /* Overlay delta from input buffer onto page buffer. */
+ HDmemcpy(page_buf + page_gap_head, buf, page_n_used);
+ write_buf = page_buf;
+ } /* end if partial page */
+
+ if (H5FD_write(file->onion_file, H5FD_MEM_DRAW, entry_out->phys_addr, page_size, write_buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "write amended page data to backing file")
+
+ buf += page_n_used; /* overflow never touched */
+ bytes_to_write -= page_n_used;
+
+ continue;
+ } /* end if page exists in 'live' revision index */
+
+ if (page_gap_head || page_gap_tail) {
+ /* Fill gaps with existing data or zeroes. */
+ if (H5FD__onion_archival_index_find(&file->curr_rev_record.archival_index, page_i, &entry_out)) {
+ /* Page exists in archival index */
+
+ /* Copy existing page verbatim */
+ if (H5FD_read(file->onion_file, H5FD_MEM_DRAW, entry_out->phys_addr, page_size, page_buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "can't get previously-amended data")
+ }
+ else {
+ haddr_t addr_start = (haddr_t)(page_i * page_size);
+ haddr_t overlap_size = (addr_start > file->origin_eof) ? 0 : file->origin_eof - addr_start;
+ haddr_t read_size = MIN(overlap_size, page_size);
+
+ /* Get all original bytes in page range */
+ if ((read_size > 0) &&
+ H5FD_read(file->original_file, type, addr_start, read_size, page_buf) < 0) {
+ HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "can't get original file data")
+ }
+
+ /* Fill with 0s any gaps after end of original bytes
+ * or start of page and before start of new data.
+ */
+ for (size_t j = read_size; j < page_gap_head; j++)
+ page_buf[j] = 0;
+
+ /* Fill with 0s any gaps after end of original bytes
+ * or end of new data and before end of page.
+ */
+ for (size_t j = MAX(read_size, page_size - page_gap_tail); j < page_size; j++)
+ page_buf[j] = 0;
+ } /* end if page exists in neither index */
+
+ /* Copy input buffer to temporary page buffer */
+ HDassert((page_size - page_gap_head) >= page_n_used);
+ HDmemcpy(page_buf + page_gap_head, buf, page_n_used);
+ write_buf = page_buf;
+
+ } /* end if data range does not span entire page */
+
+ new_entry.logical_page = page_i;
+ new_entry.phys_addr = file->onion_eof;
+
+ if (H5FD_set_eoa(file->onion_file, H5FD_MEM_DRAW, file->onion_eof + page_size) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTSET, FAIL, "can't modify EOA for new page amendment")
+
+ if (H5FD_write(file->onion_file, H5FD_MEM_DRAW, file->onion_eof, page_size, write_buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "write amended page data to backing file")
+
+ if (H5FD__onion_revision_index_insert(file->rev_index, &new_entry) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTINSERT, FAIL, "can't insert new index entry into revision index")
+
+ file->onion_eof += page_size;
+ buf += page_n_used; /* possible overflow never touched */
+ bytes_to_write -= page_n_used;
+
+ } /* end for each page to write */
+
+ HDassert(0 == bytes_to_write);
+
+ file->logical_eof = MAX(file->logical_eof, (offset + len));
+
+done:
+ H5MM_xfree(page_buf);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_write() */
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD__onion_ctl
+ *
+ * Purpose: Onion VFD version of the ctl callback.
+ *
+ * The desired operation is specified by the op_code
+ * parameter.
+ *
+ * The flags parameter controls management of op_codes that
+ * are unknown to the callback
+ *
+ * The input and output parameters allow op_code specific
+ * input and output
+ *
+ * Return: SUCCEED/FAIL
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__onion_ctl(H5FD_t *_file, uint64_t op_code, uint64_t flags, const void H5_ATTR_UNUSED *input,
+ void **output)
+{
+ H5FD_onion_t *file = (H5FD_onion_t *)_file;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE
+
+ /* Sanity checks */
+ HDassert(file);
+
+ switch (op_code) {
+ case H5FD_CTL_GET_NUM_REVISIONS:
+ if (!output || !*output)
+ HGOTO_ERROR(H5E_VFL, H5E_FCNTL, FAIL, "the output parameter is null")
+
+ **((uint64_t **)output) = file->history.n_revisions;
+ break;
+ /* Unknown op code */
+ default:
+ if (flags & H5FD_CTL_FAIL_IF_UNKNOWN_FLAG)
+ HGOTO_ERROR(H5E_VFL, H5E_FCNTL, FAIL, "unknown op_code and fail if unknown flag is set")
+ break;
+ }
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FD__onion_ctl() */
+
+/*-------------------------------------------------------------------------
+ * Function: H5FDget_onion_revision_count
+ *
+ * Purpose: Get the number of revisions in an onion file
+ *
+ * Return: SUCCEED/FAIL
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5FDonion_get_revision_count(const char *filename, hid_t fapl_id, uint64_t *revision_count /*out*/)
+{
+ H5P_genplist_t *plist = NULL;
+ H5FD_t *file = NULL;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_API(FAIL)
+ H5TRACE3("e", "*six", filename, fapl_id, revision_count);
+
+ /* Check args */
+ if (!filename || !HDstrcmp(filename, ""))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "not a valid file name")
+ if (!revision_count)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "revision count can't be null")
+
+ /* Make sure using the correct driver */
+ if (NULL == (plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "not a valid FAPL ID")
+ if (H5FD_ONION != H5P_peek_driver(plist))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "not a Onion VFL driver")
+
+ /* Open the file with the driver */
+ if (NULL == (file = H5FD_open(filename, H5F_ACC_RDONLY, fapl_id, HADDR_UNDEF)))
+ HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, FAIL, "unable to open file with onion driver")
+
+ /* Call the private function */
+ if (H5FD__get_onion_revision_count(file, revision_count) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "failed to get the number of revisions")
+
+done:
+ /* Close H5FD_t structure pointer */
+ if (file && H5FD_close(file) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close file")
+
+ FUNC_LEAVE_API(ret_value)
+}
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD__get_onion_revision_count
+ *
+ * Purpose: Private version of H5FDget_onion_revision_count()
+ *
+ * Return: SUCCEED/FAIL
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__get_onion_revision_count(H5FD_t *file, uint64_t *revision_count)
+{
+ uint64_t op_code;
+ uint64_t flags;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE
+
+ HDassert(file);
+ HDassert(revision_count);
+
+ op_code = H5FD_CTL_GET_NUM_REVISIONS;
+ flags = H5FD_CTL_FAIL_IF_UNKNOWN_FLAG;
+
+ /* Get the number of revisions via the ctl callback */
+ if (H5FD_ctl(file, op_code, flags, NULL, (void **)&revision_count) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_FCNTL, FAIL, "VFD ctl request failed")
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
+}
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_write_final_history
+ *
+ * Purpose: Write final history to appropriate backing file on file close
+ *
+ * Return: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+herr_t
+H5FD__onion_write_final_history(H5FD_onion_t *file)
+{
+ size_t size = 0;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE;
+
+ /* TODO: history EOF may not be correct (under what circumstances?) */
+ if (0 == (size = H5FD__onion_write_history(&(file->history), file->onion_file, file->onion_eof,
+ file->onion_eof)))
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "can't write final history")
+
+ if (size != file->header.history_size)
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "written history differed from expected size")
+
+ /* Is last write operation to history file; no need to extend to page
+ * boundary if set to page-align.
+ */
+ file->onion_eof += size;
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_write_final_history() */
diff --git a/src/H5FDonion.h b/src/H5FDonion.h
new file mode 100644
index 0000000..04fd2ff
--- /dev/null
+++ b/src/H5FDonion.h
@@ -0,0 +1,200 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group. *
+ * All rights reserved. *
+ * *
+ * This file is part of HDF5. The full HDF5 copyright notice, including *
+ * terms governing use, modification, and redistribution, is contained in *
+ * the COPYING file, which can be found at the root of the source code *
+ * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. *
+ * If you do not have access to either file, you may request a copy from *
+ * help@hdfgroup.org. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Onion Virtual File Driver (VFD)
+ *
+ * Purpose: The public header file for the Onion VFD.
+ */
+#ifndef H5FDonion_H
+#define H5FDonion_H
+
+#define H5FD_ONION (H5FDperform_init(H5FD_onion_init))
+#define H5FD_ONION_VALUE H5_VFD_ONION
+
+/* Current version of the fapl info struct */
+#define H5FD_ONION_FAPL_INFO_VERSION_CURR 1
+
+/* Flag to open a file that has a locked header (after crashes, for example) */
+#define H5FD_ONION_FAPL_INFO_FLAG_FORCE_OPEN 1
+
+/* Flag to enable opening older revisions in write mode, creating a tree */
+#define H5FD_ONION_FAPL_INFO_CREATE_FLAG_ENABLE_DIVERGENT_HISTORY 0x1
+
+/* Flag to require page alignment of onion revision data */
+#define H5FD_ONION_FAPL_INFO_CREATE_FLAG_ENABLE_PAGE_ALIGNMENT 0x2
+
+/* Max length of a comment */
+#define H5FD_ONION_FAPL_INFO_COMMENT_MAX_LEN 255
+
+/* Indicates that you want the latest revision
+ * TODO: Does this work?
+ */
+#define H5FD_ONION_FAPL_INFO_REVISION_ID_LATEST UINT64_MAX
+
+typedef enum H5FD_onion_target_file_constant_t {
+ H5FD_ONION_STORE_TARGET_H5, /* Onion history as part of HDF5 file */
+ H5FD_ONION_STORE_TARGET_ONION, /* Separate, single "onion" file */
+} H5FD_onion_target_file_constant_t;
+
+/*-----------------------------------------------------------------------------
+ * Structure H5FD_onion_fapl_info_t
+ *
+ * Purpose: Encapsulate info for the Onion driver FAPL entry.
+ *
+ * version: Future-proofing identifier. Informs struct membership.
+ * Must equal H5FD_ONION_FAPL_VERSION_CURR to be considered valid.
+ *
+ * backing_fapl_id:
+ * Backing or 'child' FAPL ID to handle I/O with the
+ * underlying backing store. If the onion data is stored as a
+ * separate file, it must use the same backing driver as the
+ * original file.
+ *
+ * page_size: Size of the amended data pages. If opening an existing file,
+ * must equal the existing page size or zero. If creating a new
+ * file or an initial revision of an existing file, must be a
+ * power of 2.
+ *
+ * store_target:
+ * Enumerated/defined value identifying where the history data is
+ * stored, either in the same file (appended to HDF5 data) or a
+ * separate file. Other options may be added in later versions.
+ *
+ * + H5FD_ONION_FAPL_STORE_MODE_SEPARATE_SINGLE (1)
+ * Onion history is stored in a single, separate "onion
+ * file". Shares filename and path as hdf5 file (if any),
+ * with only a different filename extension.
+ *
+ * revision_num: Which revision to open. Must be 0 (the original file) or the
+ * revision number of an existing revision.
+ * Revision ID -1 is reserved to open the most recently-created
+ * revision in history.
+ *
+ * force_write_open:
+ * Flag to ignore the write-lock flag in the onion data
+ * and attempt to open the file write-only anyway.
+ * This may be relevant if, for example, the library crashed
+ * while the file was open in write mode and the write-lock
+ * flag was not cleared.
+ * Must equal H5FD_ONION_FAPL_FLAG_FORCE_OPEN to enable.
+ *
+ * creation_flags:
+ * Flag used only when instantiating an Onion file.
+ * If the relevant bit is set to a nonzero value, its feature
+ * will be enabled.
+ *
+ * + H5FD_ONION_FAPL_CREATE_FLAG_ENABLE_DIVERGENT_HISTORY
+ * (1, bit 1)
+ * User will be allowed to open arbitrary revisions
+ * in write mode.
+ * If disabled (0), only the most recent revision may be
+ * opened for amendment.
+ *
+ * + H5FD_ONION_FAPL_CREATE_FLAG_ENABLE_PAGE_ALIGNMENT (2, bit 2)
+ * Onion history metadata will align to page_size.
+ * Partial pages of unused space will occur in the file,
+ * but may improve read performance from the backing store
+ * on some systems.
+ * If disabled (0), padding will not be inserted to align
+ * to page boundaries.
+ *
+ * + <Remaining bits reserved>
+ *
+ * comment: User-supplied NULL-terminated comment for a revision to be
+ * written.
+ * Cannot be longer than H5FD_ONION_FAPL_COMMENT_MAX_LEN.
+ * Ignored if part of a FAPL used to open in read mode.
+ *
+ * The comment for a revision may be modified prior to committing
+ * to the revision (closing the file and writing the record)
+ * with a call to H5FDfctl().
+ * This H5FDfctl overwrite may be used to exceed constraints of
+ * maximum string length and the NULL-terminator requirement.
+ *
+ *-----------------------------------------------------------------------------
+ */
+typedef struct H5FD_onion_fapl_info_t {
+ uint8_t version;
+ hid_t backing_fapl_id;
+ uint32_t page_size;
+ H5FD_onion_target_file_constant_t store_target;
+ uint64_t revision_num;
+ uint8_t force_write_open;
+ uint8_t creation_flags;
+ char comment[H5FD_ONION_FAPL_INFO_COMMENT_MAX_LEN + 1];
+} H5FD_onion_fapl_info_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+H5_DLL hid_t H5FD_onion_init(void);
+
+/**
+ * --------------------------------------------------------------------------
+ * \ingroup H5P
+ *
+ * \brief get the onion info from the file access property list
+ *
+ * \param[in] fapl_id The ID of the file access property list
+ * \param[out] fa_out The pointer to the structure H5FD_onion_fapl_info_t
+ *
+ * \return \herr_t
+ *
+ * \details H5Pget_fapl_onion() retrieves the structure H5FD_onion_fapl_info_t
+ * from the file access property list that is set for the onion VFD
+ * driver.
+ */
+H5_DLL herr_t H5Pget_fapl_onion(hid_t fapl_id, H5FD_onion_fapl_info_t *fa_out);
+
+/**
+ * --------------------------------------------------------------------------
+ * \ingroup H5P
+ *
+ * \brief set the onion info for the file access property list
+ *
+ * \param[in] fapl_id The ID of the file access property list
+ * \param[in] fa The pointer to the structure H5FD_onion_fapl_info_t
+ *
+ * \return \herr_t
+ *
+ * \details H5Pset_fapl_onion() sets the structure H5FD_onion_fapl_info_t
+ * for the file access property list that is set for the onion VFD
+ * driver.
+ */
+H5_DLL herr_t H5Pset_fapl_onion(hid_t fapl_id, const H5FD_onion_fapl_info_t *fa);
+
+/**
+ * --------------------------------------------------------------------------
+ * \ingroup H5FD
+ *
+ * \brief get the number of revisions
+ *
+ * \param[in] filename The name of the onion file
+ * \param[in] fapl_id The ID of the file access property list
+ * \param[out] revision_count The number of revisions
+ *
+ * \return \herr_t
+ *
+ * \details H5FDonion_get_revision_count() returns the number of revisions
+ * for an onion file. It takes the file name and file access property
+ * list that is set for the onion VFD driver.
+ *
+ */
+H5_DLL herr_t H5FDonion_get_revision_count(const char *filename, hid_t fapl_id, uint64_t *revision_count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* H5FDonion_H */
diff --git a/src/H5FDonion_header.c b/src/H5FDonion_header.c
new file mode 100644
index 0000000..a1d6c28
--- /dev/null
+++ b/src/H5FDonion_header.c
@@ -0,0 +1,231 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group. *
+ * All rights reserved. *
+ * *
+ * This file is part of HDF5. The full HDF5 copyright notice, including *
+ * terms governing use, modification, and redistribution, is contained in *
+ * the COPYING file, which can be found at the root of the source code *
+ * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. *
+ * If you do not have access to either file, you may request a copy from *
+ * help@hdfgroup.org. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Onion Virtual File Driver (VFD)
+ *
+ * Purpose: Code for the onion file's header
+ */
+
+/* This source code file is part of the H5FD driver module */
+#include "H5FDdrvr_module.h"
+
+#include "H5private.h" /* Generic Functions */
+#include "H5Eprivate.h" /* Error handling */
+#include "H5FDprivate.h" /* File drivers */
+#include "H5FDonion.h" /* Onion file driver */
+#include "H5FDonion_priv.h" /* Onion file driver internals */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD_ingest_header
+ *
+ * Purpose: Read and decode the history header information from `raw_file`
+ * at `addr`, and store the decoded information in the structure
+ * at `hdr_out`.
+ *
+ * Return: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+herr_t
+H5FD__onion_ingest_header(H5FD_onion_header_t *hdr_out, H5FD_t *raw_file, haddr_t addr)
+{
+ unsigned char *buf = NULL;
+ herr_t ret_value = SUCCEED;
+ haddr_t size = (haddr_t)H5FD_ONION_ENCODED_SIZE_HEADER;
+ uint32_t sum = 0;
+
+ FUNC_ENTER_PACKAGE;
+
+ if (H5FD_get_eof(raw_file, H5FD_MEM_DRAW) < (addr + size))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "header indicates history beyond EOF")
+
+ if (NULL == (buf = H5MM_malloc(sizeof(char) * size)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't allocate buffer space")
+
+ if (H5FD_set_eoa(raw_file, H5FD_MEM_DRAW, (addr + size)) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTSET, FAIL, "can't modify EOA")
+
+ if (H5FD_read(raw_file, H5FD_MEM_DRAW, addr, size, buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "can't read history header from file")
+
+ if (H5FD__onion_header_decode(buf, hdr_out) == 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTDECODE, FAIL, "can't decode history header")
+
+ sum = H5_checksum_fletcher32(buf, size - 4);
+ if (hdr_out->checksum != sum)
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "checksum mismatch between buffer and stored")
+
+done:
+ H5MM_xfree(buf);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_ingest_header() */
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD__onion_write_header
+ *
+ * Purpose: Write in-memory history header to appropriate backing file.
+ * Overwrites existing header data.
+ *
+ * Return: SUCCEED/FAIL
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5FD__onion_write_header(H5FD_onion_header_t *header, H5FD_t *file)
+{
+ uint32_t sum = 0; /* Not used, but required by the encoder */
+ uint64_t size = 0;
+ unsigned char *buf = NULL;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE;
+
+ if (NULL == (buf = H5MM_malloc(H5FD_ONION_ENCODED_SIZE_HEADER)))
+ HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "can't allocate buffer for updated history header")
+
+ if (0 == (size = H5FD__onion_header_encode(header, buf, &sum)))
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "problem encoding updated history header")
+
+ if (H5FD_write(file, H5FD_MEM_DRAW, 0, (haddr_t)size, buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "can't write updated history header")
+
+done:
+ H5MM_xfree(buf);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_write_header()*/
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_header_decode
+ *
+ * Purpose: Attempt to read a buffer and store it as a history-header
+ * structure.
+ *
+ * Implementation must correspond with
+ * H5FD__onion_header_encode().
+ *
+ * Return: Success: Number of bytes read from buffer
+ * Failure: 0
+ *-----------------------------------------------------------------------------
+ */
+size_t
+H5FD__onion_header_decode(unsigned char *buf, H5FD_onion_header_t *header)
+{
+ uint32_t ui32 = 0;
+ uint32_t sum = 0;
+ uint64_t ui64 = 0;
+ uint8_t *ui8p = NULL;
+ unsigned char *ptr = NULL;
+ size_t ret_value = 0;
+
+ FUNC_ENTER_PACKAGE;
+
+ HDassert(buf != NULL);
+ HDassert(header != NULL);
+ HDassert(H5FD_ONION_HEADER_VERSION_CURR == header->version);
+
+ if (HDstrncmp((const char *)buf, H5FD_ONION_HEADER_SIGNATURE, 4))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "invalid header signature")
+
+ if (buf[4] != H5FD_ONION_HEADER_VERSION_CURR)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "invalid header version")
+
+ ptr = buf + 5;
+ ui32 = 0;
+ HDmemcpy(&ui32, ptr, 3);
+ ui8p = (uint8_t *)&ui32;
+ UINT32DECODE(ui8p, header->flags);
+ ptr += 3;
+
+ HDmemcpy(&ui32, ptr, 4);
+ ui8p = (uint8_t *)&ui32;
+ UINT32DECODE(ui8p, header->page_size);
+ ptr += 4;
+
+ HDmemcpy(&ui64, ptr, 8);
+ ui8p = (uint8_t *)&ui64;
+ UINT32DECODE(ui8p, header->origin_eof);
+ ptr += 8;
+
+ HDmemcpy(&ui64, ptr, 8);
+ ui8p = (uint8_t *)&ui64;
+ UINT32DECODE(ui8p, header->history_addr);
+ ptr += 8;
+
+ HDmemcpy(&ui64, ptr, 8);
+ ui8p = (uint8_t *)&ui64;
+ UINT32DECODE(ui8p, header->history_size);
+ ptr += 8;
+
+ sum = H5_checksum_fletcher32(buf, (size_t)(ptr - buf));
+
+ HDmemcpy(&ui32, ptr, 4);
+ ui8p = (uint8_t *)&ui32;
+ UINT32DECODE(ui8p, header->checksum);
+ ptr += 4;
+
+ if (sum != header->checksum)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "checksum mismatch")
+
+ ret_value = (size_t)(ptr - buf);
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_header_decode() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_header_encode
+ *
+ * Purpose: Write history-header structure to the given buffer.
+ * All multi-byte elements are stored in little-endian word order.
+ *
+ * Implementation must correspond with
+ * H5FD__onion_header_decode().
+ *
+ * The destination buffer must be sufficiently large to hold the
+ * encoded contents (H5FD_ONION_ENCODED_SIZE_HEADER).
+ *
+ * Return: Number of bytes written to buffer.
+ * The checksum of the generated buffer contents (excluding the
+ * checksum itself) is stored in the pointer `checksum`).
+ *-----------------------------------------------------------------------------
+ */
+size_t
+H5FD__onion_header_encode(H5FD_onion_header_t *header, unsigned char *buf, uint32_t *checksum /*out*/)
+{
+ unsigned char *ptr = buf;
+ size_t ret_value = 0;
+
+ FUNC_ENTER_PACKAGE_NOERR;
+
+ HDassert(buf != NULL);
+ HDassert(checksum != NULL);
+ HDassert(header != NULL);
+ HDassert(H5FD_ONION_HEADER_VERSION_CURR == header->version);
+ HDassert(0 == (header->flags & 0xFF000000)); /* max three bits long */
+
+ HDmemcpy(ptr, H5FD_ONION_HEADER_SIGNATURE, 4);
+ ptr += 4;
+ HDmemcpy(ptr, (unsigned char *)&header->version, 1);
+ ptr += 1;
+ UINT32ENCODE(ptr, header->flags);
+ ptr -= 1; /* truncate to three bytes */
+ UINT32ENCODE(ptr, header->page_size);
+ UINT64ENCODE(ptr, header->origin_eof);
+ UINT64ENCODE(ptr, header->history_addr);
+ UINT64ENCODE(ptr, header->history_size);
+ *checksum = H5_checksum_fletcher32(buf, (size_t)(ptr - buf));
+ UINT32ENCODE(ptr, *checksum);
+ ret_value = (size_t)(ptr - buf);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_header_encode() */
diff --git a/src/H5FDonion_header.h b/src/H5FDonion_header.h
new file mode 100644
index 0000000..cb3941b
--- /dev/null
+++ b/src/H5FDonion_header.h
@@ -0,0 +1,56 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group. *
+ * All rights reserved. *
+ * *
+ * This file is part of HDF5. The full HDF5 copyright notice, including *
+ * terms governing use, modification, and redistribution, is contained in *
+ * the COPYING file, which can be found at the root of the source code *
+ * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. *
+ * If you do not have access to either file, you may request a copy from *
+ * help@hdfgroup.org. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Onion Virtual File Driver (VFD)
+ *
+ * Purpose: Interface for the onion file's header
+ */
+
+#ifndef H5FDonion_header_H
+#define H5FDonion_header_H
+
+/* Number of bytes to encode fixed-size components */
+#define H5FD_ONION_ENCODED_SIZE_HEADER 40
+
+/* Flags must align exactly one per bit, up to 24 bits */
+#define H5FD_ONION_HEADER_FLAG_WRITE_LOCK 0x1
+#define H5FD_ONION_HEADER_FLAG_DIVERGENT_HISTORY 0x2
+#define H5FD_ONION_HEADER_FLAG_PAGE_ALIGNMENT 0x4
+#define H5FD_ONION_HEADER_SIGNATURE "OHDH"
+#define H5FD_ONION_HEADER_VERSION_CURR 1
+
+/* In-memory representation of the on-store onion history file header.
+ */
+typedef struct H5FD_onion_header_t {
+ uint8_t version;
+ uint32_t flags; /* At most three bytes used! */
+ uint32_t page_size;
+ uint64_t origin_eof; /* Size of the 'original' canonical file */
+ uint64_t history_addr;
+ uint64_t history_size;
+ uint32_t checksum;
+} H5FD_onion_header_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+H5_DLL herr_t H5FD__onion_ingest_header(H5FD_onion_header_t *hdr_out, H5FD_t *raw_file, haddr_t addr);
+H5_DLL herr_t H5FD__onion_write_header(H5FD_onion_header_t *header, H5FD_t *file);
+H5_DLL size_t H5FD__onion_header_decode(unsigned char *buf, H5FD_onion_header_t *header);
+H5_DLL size_t H5FD__onion_header_encode(H5FD_onion_header_t *header, unsigned char *buf, uint32_t *checksum);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* H5FDonion_header_H */
diff --git a/src/H5FDonion_history.c b/src/H5FDonion_history.c
new file mode 100644
index 0000000..501a1f7
--- /dev/null
+++ b/src/H5FDonion_history.c
@@ -0,0 +1,305 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group. *
+ * All rights reserved. *
+ * *
+ * This file is part of HDF5. The full HDF5 copyright notice, including *
+ * terms governing use, modification, and redistribution, is contained in *
+ * the COPYING file, which can be found at the root of the source code *
+ * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. *
+ * If you do not have access to either file, you may request a copy from *
+ * help@hdfgroup.org. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Onion Virtual File Driver (VFD)
+ *
+ * Purpose: Code for the onion file's history
+ */
+
+/* This source code file is part of the H5FD driver module */
+#include "H5FDdrvr_module.h"
+
+#include "H5private.h" /* Generic Functions */
+#include "H5Eprivate.h" /* Error handling */
+#include "H5FDprivate.h" /* File drivers */
+#include "H5FDonion.h" /* Onion file driver */
+#include "H5FDonion_priv.h" /* Onion file driver internals */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_write_history
+ *
+ * Purpose: Read and decode the history information from `raw_file` at
+ * `addr` .. `addr + size` (taken from history header), and store
+ * the decoded information in the structure at `history_out`.
+ *
+ * Returns: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+herr_t
+H5FD__onion_ingest_history(H5FD_onion_history_t *history_out, H5FD_t *raw_file, haddr_t addr, haddr_t size)
+{
+ unsigned char *buf = NULL;
+ uint32_t sum = 0;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE;
+
+ HDassert(history_out);
+ HDassert(raw_file);
+
+ /* Set early so we can clean up properly on errors */
+ history_out->record_locs = NULL;
+
+ if (H5FD_get_eof(raw_file, H5FD_MEM_DRAW) < (addr + size))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "header indicates history beyond EOF");
+
+ if (NULL == (buf = H5MM_malloc(sizeof(char) * size)))
+ HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "can't allocate buffer space");
+
+ if (H5FD_set_eoa(raw_file, H5FD_MEM_DRAW, (addr + size)) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTSET, FAIL, "can't modify EOA");
+
+ if (H5FD_read(raw_file, H5FD_MEM_DRAW, addr, size, buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "can't read history from file");
+
+ if (H5FD__onion_history_decode(buf, history_out) != size)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTDECODE, FAIL, "can't decode history (initial)");
+
+ sum = H5_checksum_fletcher32(buf, size - 4);
+ if (history_out->checksum != sum)
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "checksum mismatch between buffer and stored");
+
+ if (history_out->n_revisions > 0)
+ if (NULL == (history_out->record_locs =
+ H5MM_calloc(history_out->n_revisions * sizeof(H5FD_onion_record_loc_t))))
+ HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "can't allocate record pointer list");
+
+ if (H5FD__onion_history_decode(buf, history_out) != size)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTDECODE, FAIL, "can't decode history (final)");
+
+done:
+ H5MM_xfree(buf);
+ if (ret_value < 0)
+ H5MM_xfree(history_out->record_locs);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_ingest_history() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_write_history
+ *
+ * Purpose: Encode and write history to file at the given address.
+ *
+ * Returns: Success: Number of bytes written to destination file (always non-zero)
+ * Failure: 0
+ *-----------------------------------------------------------------------------
+ */
+uint64_t
+H5FD__onion_write_history(H5FD_onion_history_t *history, H5FD_t *file, haddr_t off_start,
+ haddr_t filesize_curr)
+{
+ uint32_t _sum = 0; /* Required by the API call but unused here */
+ uint64_t size = 0;
+ unsigned char *buf = NULL;
+ uint64_t ret_value = 0;
+
+ FUNC_ENTER_PACKAGE;
+
+ if (NULL == (buf = H5MM_malloc(H5FD_ONION_ENCODED_SIZE_HISTORY +
+ (H5FD_ONION_ENCODED_SIZE_RECORD_POINTER * history->n_revisions))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, 0, "can't allocate buffer for updated history")
+
+ if (0 == (size = H5FD__onion_history_encode(history, buf, &_sum)))
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, 0, "problem encoding updated history")
+
+ if ((size + off_start > filesize_curr) && (H5FD_set_eoa(file, H5FD_MEM_DRAW, off_start + size) < 0))
+ HGOTO_ERROR(H5E_VFL, H5E_CANTSET, 0, "can't modify EOA for updated history")
+
+ if (H5FD_write(file, H5FD_MEM_DRAW, off_start, size, buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, 0, "can't write history as intended")
+
+ ret_value = size;
+
+done:
+ H5MM_xfree(buf);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_write_history() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_history_decode
+ *
+ * Purpose: Attempt to read a buffer and store it as a history
+ * structure.
+ *
+ * Implementation must correspond with
+ * H5FD__onion_history_encode().
+ *
+ * MUST BE CALLED TWICE:
+ * On the first call, n_records in the destination structure must
+ * be zero, and record_locs be NULL.
+ *
+ * If the buffer is well-formed, the destination structure is
+ * tentatively populated with fixed-size values, and the number of
+ * bytes read are returned.
+ *
+ * Prior to the second call, the user must allocate space for
+ * record_locs to hold n_records record-pointer structs.
+ *
+ * Then the decode operation is called a second time, and all
+ * components will be populated (and again number of bytes read is
+ * returned).
+ *
+ * Return: Success: Number of bytes read from buffer
+ * Failure: 0
+ *-----------------------------------------------------------------------------
+ */
+size_t
+H5FD__onion_history_decode(unsigned char *buf, H5FD_onion_history_t *history)
+{
+ uint32_t ui32 = 0;
+ uint32_t sum = 0;
+ uint64_t ui64 = 0;
+ uint64_t n_revisions = 0;
+ uint8_t *ui8p = NULL;
+ unsigned char *ptr = NULL;
+ size_t ret_value = 0;
+
+ FUNC_ENTER_PACKAGE;
+
+ HDassert(buf != NULL);
+ HDassert(history != NULL);
+ HDassert(H5FD_ONION_HISTORY_VERSION_CURR == history->version);
+
+ if (HDstrncmp((const char *)buf, H5FD_ONION_HISTORY_SIGNATURE, 4))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "invalid signature")
+
+ if (H5FD_ONION_HISTORY_VERSION_CURR != buf[4])
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "invalid version")
+
+ ptr = buf + 8;
+
+ HDmemcpy(&ui64, ptr, 8);
+ ui8p = (uint8_t *)&ui64;
+ UINT64DECODE(ui8p, n_revisions);
+ ptr += 8;
+
+ if (0 == history->n_revisions) {
+ history->n_revisions = n_revisions;
+ ptr += H5FD_ONION_ENCODED_SIZE_RECORD_POINTER * n_revisions;
+ }
+ else {
+ if (history->n_revisions != n_revisions)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0,
+ "history argument suggests different revision count than encoded buffer")
+ if (NULL == history->record_locs)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "list is NULL -- cannot populate")
+
+ for (uint64_t i = 0; i < n_revisions; i++) {
+ H5FD_onion_record_loc_t *rloc = &history->record_locs[i];
+
+ /* Decode into appropriately sized types, then do a checked
+ * assignment to the struct value. We don't have access to
+ * the H5F_t struct for this file, so we can't use the
+ * offset/length macros in H5Fprivate.h.
+ */
+ uint64_t record_size;
+ uint64_t phys_addr;
+
+ HDmemcpy(&ui64, ptr, 8);
+ ui8p = (uint8_t *)&ui64;
+ UINT64DECODE(ui8p, phys_addr);
+ H5_CHECKED_ASSIGN(rloc->phys_addr, haddr_t, phys_addr, uint64_t);
+ ptr += 8;
+
+ HDmemcpy(&ui64, ptr, 8);
+ ui8p = (uint8_t *)&ui64;
+ UINT64DECODE(ui8p, record_size);
+ H5_CHECKED_ASSIGN(rloc->record_size, hsize_t, record_size, uint64_t);
+ ptr += 8;
+
+ HDmemcpy(&ui32, ptr, 4);
+ ui8p = (uint8_t *)&ui32;
+ UINT32DECODE(ui8p, rloc->checksum);
+ ptr += 4;
+ }
+ }
+
+ sum = H5_checksum_fletcher32(buf, (size_t)(ptr - buf));
+
+ HDmemcpy(&ui32, ptr, 4);
+ ui8p = (uint8_t *)&ui32;
+ UINT32DECODE(ui8p, history->checksum);
+ ptr += 4;
+
+ if (sum != history->checksum)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "checksum mismatch")
+
+ ret_value = (size_t)(ptr - buf);
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_history_decode() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_history_encode
+ *
+ * Purpose: Write history structure to the given buffer.
+ * All multi-byte elements are stored in little-endian word order.
+ *
+ * Implementation must correspond with
+ * H5FD__onion_history_decode().
+ *
+ * The destination buffer must be sufficiently large to hold the
+ * encoded contents.
+ * (Hint: `sizeof(history struct) +
+ * sizeof(record-pointer-struct) * n_records)` guarantees
+ * ample/excess space.)
+ *
+ * Return: Number of bytes written to buffer.
+ * The checksum of the generated buffer contents (excluding the
+ * checksum itself) is stored in the pointer `checksum`).
+ *-----------------------------------------------------------------------------
+ */
+size_t
+H5FD__onion_history_encode(H5FD_onion_history_t *history, unsigned char *buf, uint32_t *checksum)
+{
+ unsigned char *ptr = buf;
+ size_t vers_u32 = (uint32_t)history->version; /* pad out unused bytes */
+
+ FUNC_ENTER_PACKAGE_NOERR;
+
+ HDassert(history != NULL);
+ HDassert(H5FD_ONION_HISTORY_VERSION_CURR == history->version);
+ HDassert(buf != NULL);
+ HDassert(checksum != NULL);
+
+ HDmemcpy(ptr, H5FD_ONION_HISTORY_SIGNATURE, 4);
+ ptr += 4;
+ UINT32ENCODE(ptr, vers_u32);
+ UINT64ENCODE(ptr, history->n_revisions);
+ if (history->n_revisions > 0) {
+ HDassert(history->record_locs != NULL);
+ for (uint64_t i = 0; i < history->n_revisions; i++) {
+ H5FD_onion_record_loc_t *rloc = &history->record_locs[i];
+
+ /* Do a checked assignment from the struct value into appropriately
+ * sized types. We don't have access to the H5F_t struct for this
+ * file, so we can't use the offset/length macros in H5Fprivate.h.
+ */
+ uint64_t phys_addr;
+ uint64_t record_size;
+
+ H5_CHECKED_ASSIGN(phys_addr, uint64_t, rloc->phys_addr, haddr_t);
+ H5_CHECKED_ASSIGN(record_size, uint64_t, rloc->record_size, hsize_t);
+
+ UINT64ENCODE(ptr, phys_addr);
+ UINT64ENCODE(ptr, record_size);
+ UINT32ENCODE(ptr, rloc->checksum);
+ }
+ }
+ *checksum = H5_checksum_fletcher32(buf, (size_t)(ptr - buf));
+ UINT32ENCODE(ptr, *checksum);
+
+ FUNC_LEAVE_NOAPI((size_t)(ptr - buf));
+} /* end H5FD__onion_history_encode() */
diff --git a/src/H5FDonion_history.h b/src/H5FDonion_history.h
new file mode 100644
index 0000000..bf27e6a
--- /dev/null
+++ b/src/H5FDonion_history.h
@@ -0,0 +1,63 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group. *
+ * All rights reserved. *
+ * *
+ * This file is part of HDF5. The full HDF5 copyright notice, including *
+ * terms governing use, modification, and redistribution, is contained in *
+ * the COPYING file, which can be found at the root of the source code *
+ * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. *
+ * If you do not have access to either file, you may request a copy from *
+ * help@hdfgroup.org. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Onion Virtual File Driver (VFD)
+ *
+ * Purpose: Interface for the onion file's history
+ */
+
+#ifndef H5FDonion_history_H
+#define H5FDonion_history_H
+
+/* Number of bytes to encode fixed-size components */
+#define H5FD_ONION_ENCODED_SIZE_HISTORY 20
+
+#define H5FD_ONION_HISTORY_SIGNATURE "OWHS"
+#define H5FD_ONION_HISTORY_VERSION_CURR 1
+
+/* In-memory representation of the on-store revision record.
+ * Used in the history.
+ */
+typedef struct H5FD_onion_record_loc_t {
+ haddr_t phys_addr;
+ hsize_t record_size;
+ uint32_t checksum;
+} H5FD_onion_record_loc_t;
+
+/* In-memory representation of the on-store history record/summary.
+ */
+typedef struct H5FD_onion_history_t {
+ uint8_t version;
+ uint64_t n_revisions;
+ H5FD_onion_record_loc_t *record_locs;
+ uint32_t checksum;
+} H5FD_onion_history_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+H5_DLL herr_t H5FD__onion_ingest_history(H5FD_onion_history_t *history_out, H5FD_t *raw_file, haddr_t addr,
+ haddr_t size);
+
+H5_DLL uint64_t H5FD__onion_write_history(H5FD_onion_history_t *history, H5FD_t *file, haddr_t off_start,
+ haddr_t filesize_curr);
+
+H5_DLL size_t H5FD__onion_history_decode(unsigned char *buf, H5FD_onion_history_t *history);
+H5_DLL size_t H5FD__onion_history_encode(H5FD_onion_history_t *history, unsigned char *buf,
+ uint32_t *checksum);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* H5FDonion_history_H */
diff --git a/src/H5FDonion_index.c b/src/H5FDonion_index.c
new file mode 100644
index 0000000..90eaf0e
--- /dev/null
+++ b/src/H5FDonion_index.c
@@ -0,0 +1,935 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group. *
+ * All rights reserved. *
+ * *
+ * This file is part of HDF5. The full HDF5 copyright notice, including *
+ * terms governing use, modification, and redistribution, is contained in *
+ * the COPYING file, which can be found at the root of the source code *
+ * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. *
+ * If you do not have access to either file, you may request a copy from *
+ * help@hdfgroup.org. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Onion Virtual File Driver (VFD)
+ *
+ * Purpose: Code for the archival and revision indexes
+ */
+
+/* This source code file is part of the H5FD driver module */
+#include "H5FDdrvr_module.h"
+
+#include "H5private.h" /* Generic Functions */
+#include "H5Eprivate.h" /* Error handling */
+#include "H5FDprivate.h" /* File drivers */
+#include "H5FDonion.h" /* Onion file driver */
+#include "H5FDonion_priv.h" /* Onion file driver internals */
+
+/* 2^n for uint64_t types -- H5_EXP2 unsafe past 32 bits */
+#define U64_EXP2(n) ((uint64_t)1 << (n))
+
+static int H5FD__onion_archival_index_list_sort_cmp(const void *, const void *);
+static herr_t H5FD__onion_revision_index_resize(H5FD_onion_revision_index_t *rix);
+
+/*-----------------------------------------------------------------------------
+ * Read and decode the revision_record information from `raw_file` at
+ * `addr` .. `addr + size` (taken from history), and store the decoded
+ * information in the structure at `r_out`.
+ *-----------------------------------------------------------------------------
+ */
+herr_t
+H5FD__onion_ingest_revision_record(H5FD_onion_revision_record_t *r_out, H5FD_t *raw_file,
+ const H5FD_onion_history_t *history, uint64_t revision_num)
+{
+ unsigned char *buf = NULL;
+ herr_t ret_value = SUCCEED;
+ uint64_t n = 0;
+ uint64_t high = 0;
+ uint64_t low = 0;
+ uint64_t range = 0;
+ uint32_t sum = 0;
+ haddr_t addr = 0;
+ size_t size = 0;
+
+ FUNC_ENTER_PACKAGE;
+
+ HDassert(r_out);
+ HDassert(raw_file);
+ HDassert(history);
+ HDassert(history->record_locs);
+ HDassert(history->n_revisions > 0);
+
+ high = history->n_revisions - 1;
+ range = high;
+ addr = history->record_locs[high].phys_addr;
+ size = history->record_locs[high].record_size;
+
+ /* Initialize r_out
+ *
+ * TODO: This function should completely initialize r_out. Relying on
+ * other code to some of the work while we just paste over parts
+ * of the struct here is completely bananas.
+ */
+ r_out->comment = H5MM_xfree(r_out->comment);
+ r_out->archival_index.list = H5MM_xfree(r_out->archival_index.list);
+
+ if (H5FD_get_eof(raw_file, H5FD_MEM_DRAW) < (addr + size))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "at least one record extends beyond EOF")
+
+ /* recovery-open may have EOA below revision record */
+ if ((H5FD_get_eoa(raw_file, H5FD_MEM_DRAW) < (addr + size)) &&
+ (H5FD_set_eoa(raw_file, H5FD_MEM_DRAW, (addr + size)) < 0)) {
+ HGOTO_ERROR(H5E_VFL, H5E_CANTSET, FAIL, "can't modify EOA");
+ }
+
+ /* Perform binary search on records to find target revision by ID.
+ * As IDs are added sequentially, they are guaranteed to be sorted.
+ */
+ while (range > 0) {
+ n = (range / 2) + low;
+ addr = history->record_locs[n].phys_addr;
+ size = history->record_locs[n].record_size;
+
+ if (NULL == (buf = H5MM_malloc(sizeof(char) * size)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't allocate buffer space")
+
+ if (H5FD_read(raw_file, H5FD_MEM_DRAW, addr, size, buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "can't read revision record from file")
+
+ if (H5FD__onion_revision_record_decode(buf, r_out) != size)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTDECODE, FAIL, "can't decode revision record (initial)")
+
+ sum = H5_checksum_fletcher32(buf, size - 4);
+ if (r_out->checksum != sum)
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "checksum mismatch between buffer and stored")
+
+ if (revision_num == r_out->revision_num)
+ break;
+
+ H5MM_xfree(buf);
+ buf = NULL;
+
+ r_out->archival_index.n_entries = 0;
+ r_out->comment_size = 0;
+
+ if (r_out->revision_num < revision_num)
+ low = (n == high) ? high : n + 1;
+ else
+ high = (n == low) ? low : n - 1;
+ range = high - low;
+ } /* end while 'non-leaf' binary search */
+
+ if (range == 0) {
+ n = low;
+ addr = history->record_locs[n].phys_addr;
+ size = history->record_locs[n].record_size;
+
+ if (NULL == (buf = H5MM_malloc(sizeof(char) * size)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't allocate buffer space")
+
+ if (H5FD_read(raw_file, H5FD_MEM_DRAW, addr, size, buf) < 0)
+ HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "can't read revision record from file")
+
+ if (H5FD__onion_revision_record_decode(buf, r_out) != size)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTDECODE, FAIL, "can't decode revision record (initial)")
+
+ sum = H5_checksum_fletcher32(buf, size - 4);
+ if (r_out->checksum != sum)
+ HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "checksum mismatch between buffer and stored")
+
+ if (revision_num != r_out->revision_num)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL,
+ "could not find target revision!") /* TODO: corrupted? */
+ } /* end if revision ID at 'leaf' in binary search */
+
+ if (r_out->comment_size > 0)
+ if (NULL == (r_out->comment = H5MM_malloc(sizeof(char) * r_out->comment_size)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't allocate comment space")
+
+ if (r_out->archival_index.n_entries > 0)
+ if (NULL == (r_out->archival_index.list =
+ H5MM_calloc(r_out->archival_index.n_entries * sizeof(H5FD_onion_index_entry_t))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't allocate index entry list")
+
+ if (H5FD__onion_revision_record_decode(buf, r_out) != size)
+ HGOTO_ERROR(H5E_VFL, H5E_CANTDECODE, FAIL, "can't decode revision record (final)")
+
+done:
+ H5MM_xfree(buf);
+ if (ret_value == FAIL) {
+ H5MM_xfree(r_out->comment);
+ H5MM_xfree(r_out->archival_index.list);
+ }
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_ingest_revision_record() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_archival_index_is_valid
+ *
+ * Purpose: Determine whether an archival index structure is valid.
+ *
+ * + Verify page size (power of two).
+ * + Verify list exists.
+ * + Verify list contents:
+ * + Sorted by increasing logical address (no duplicates)
+ * + Logical addresses are multiples of page size.
+ *
+ * Return: TRUE/FALSE
+ *-----------------------------------------------------------------------------
+ */
+hbool_t
+H5FD__onion_archival_index_is_valid(const H5FD_onion_archival_index_t *aix)
+{
+ hbool_t ret_value = TRUE;
+
+ FUNC_ENTER_PACKAGE_NOERR;
+
+ HDassert(aix);
+
+ if (H5FD_ONION_ARCHIVAL_INDEX_VERSION_CURR != aix->version)
+ HGOTO_DONE(FALSE)
+ if (NULL == aix->list)
+ HGOTO_DONE(FALSE)
+
+ /* Ensure list is sorted on logical_page field */
+ if (aix->n_entries > 1)
+ for (uint64_t i = 1; i < aix->n_entries - 1; i++)
+ if (aix->list[i + 1].logical_page <= aix->list[i].logical_page)
+ HGOTO_DONE(FALSE)
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_archival_index_is_valid() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_archival_index_find
+ *
+ * Purpose: Retrieve the archival index entry by logical page ID.
+ *
+ * The archival index pointer must point to a valid index entry.
+ * The entry out pointer-pointer cannot be null.
+ *
+ * Return: Success: Positive value (1) -- entry found.
+ * Entry out pointer-pointer is set to point to entry.
+ * Failure: Zero (0) -- entry not found.
+ * Entry out pointer-pointer is unmodified.
+ *-----------------------------------------------------------------------------
+ */
+int
+H5FD__onion_archival_index_find(const H5FD_onion_archival_index_t *aix, uint64_t logical_page,
+ const H5FD_onion_index_entry_t **entry_out)
+{
+ uint64_t low = 0;
+ uint64_t high = 0;
+ uint64_t n = 0;
+ uint64_t range = 0;
+ H5FD_onion_index_entry_t *x = NULL;
+ int ret_value = 0;
+
+ FUNC_ENTER_PACKAGE_NOERR;
+
+ HDassert(aix);
+ HDassert(H5FD_ONION_ARCHIVAL_INDEX_VERSION_CURR == aix->version);
+ HDassert(entry_out);
+ if (aix->n_entries != 0)
+ HDassert(aix->list);
+
+ high = aix->n_entries - 1;
+ range = high;
+
+ /* Trivial cases */
+ if (aix->n_entries == 0 || logical_page > aix->list[high].logical_page ||
+ logical_page < aix->list[0].logical_page)
+ HGOTO_DONE(0)
+
+ /*
+ * Binary search on sorted list
+ */
+
+ /* Winnow down to first of found or one element */
+ while (range > 0) {
+ HDassert(high < aix->n_entries);
+ n = low + (range / 2);
+ x = &(aix->list[n]);
+ if (x->logical_page == logical_page) {
+ *entry_out = x; /* element found at fence */
+ ret_value = 1;
+ goto done;
+ }
+ else if (x->logical_page < logical_page) {
+ low = (n == high) ? high : n + 1;
+ }
+ else {
+ high = (n == low) ? low : n - 1;
+ }
+ range = high - low;
+ }
+
+ HDassert(high == low); /* one element */
+
+ /* n == low/high check because we may have tested it already above */
+ if ((n != low || n != high) && (aix->list[low].logical_page == logical_page)) {
+ *entry_out = &aix->list[low];
+ ret_value = 1;
+ }
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_archival_index_find() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_revision_index_destroy
+ *
+ * Purpose: Release all resources of a revision index.
+ *
+ * Return: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+herr_t
+H5FD__onion_revision_index_destroy(H5FD_onion_revision_index_t *rix)
+{
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE_NOERR;
+
+ HDassert(rix);
+ HDassert(H5FD_ONION_REVISION_INDEX_VERSION_CURR == rix->version);
+
+ for (size_t i = 0; 0 < rix->_hash_table_n_keys_populated && i < rix->_hash_table_size; i++) {
+ H5FD_onion_revision_index_hash_chain_node_t *next = NULL;
+ H5FD_onion_revision_index_hash_chain_node_t *node = rix->_hash_table[i];
+
+ if (node != NULL)
+ rix->_hash_table_n_keys_populated -= 1;
+
+ while (node != NULL) {
+ HDassert(H5FD_ONION_REVISION_INDEX_HASH_CHAIN_NODE_VERSION_CURR == node->version);
+
+ next = node->next;
+ H5MM_xfree(node);
+ node = next;
+ }
+ }
+ H5MM_xfree(rix->_hash_table);
+ H5MM_xfree(rix);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_revision_index_destroy() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_revision_index_init
+ *
+ * Purpose: Initialize a revision index structure with a default starting
+ * size. A new structure is allocated and populated with initial
+ * values.
+ *
+ * Return: Success: Pointer to newly-allocated structure
+ * Failure: NULL
+ *-----------------------------------------------------------------------------
+ */
+H5FD_onion_revision_index_t *
+H5FD__onion_revision_index_init(uint32_t page_size)
+{
+ uint64_t table_size = U64_EXP2(H5FD_ONION_REVISION_INDEX_STARTING_SIZE_LOG2);
+ H5FD_onion_revision_index_t *rix = NULL;
+ H5FD_onion_revision_index_t *ret_value = NULL;
+
+ FUNC_ENTER_PACKAGE;
+
+ HDassert(0 != page_size);
+ HDassert(POWER_OF_TWO(page_size));
+
+ if (NULL == (rix = H5MM_calloc(sizeof(H5FD_onion_revision_index_t))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, NULL, "cannot allocate index")
+
+ if (NULL ==
+ (rix->_hash_table = H5MM_calloc(table_size * sizeof(H5FD_onion_revision_index_hash_chain_node_t *))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, NULL, "cannot allocate hash table")
+
+ rix->version = H5FD_ONION_REVISION_INDEX_VERSION_CURR;
+ rix->n_entries = 0;
+ /* Compute and store log2(page_size) */
+ for (rix->page_size_log2 = 0; (((uint32_t)1 << rix->page_size_log2) & page_size) == 0;
+ rix->page_size_log2++)
+ ;
+ rix->_hash_table_size = table_size;
+ rix->_hash_table_size_log2 = H5FD_ONION_REVISION_INDEX_STARTING_SIZE_LOG2;
+ rix->_hash_table_n_keys_populated = 0;
+
+ ret_value = rix;
+
+done:
+ if (NULL == ret_value)
+ H5MM_xfree(rix);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_revision_index_init() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_revision_index_resize()
+ *
+ * Purpose: Replace the hash table in the revision index.
+ *
+ * Doubles the available number of keys, re-hashes table contents,
+ * and updates relevant components in the index structure.
+ *
+ * Fails if unable to allocate space for larger hash table.
+ *
+ * Return: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__onion_revision_index_resize(H5FD_onion_revision_index_t *rix)
+{
+ H5FD_onion_revision_index_hash_chain_node_t **new_table = NULL;
+
+ uint64_t new_size_log2 = rix->_hash_table_size_log2 + 1;
+ uint64_t new_size = U64_EXP2(new_size_log2);
+ uint64_t new_n_keys_populated = 0;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE;
+
+ HDassert(rix);
+ HDassert(H5FD_ONION_REVISION_INDEX_VERSION_CURR == rix->version);
+ HDassert(rix->_hash_table);
+
+ if (NULL == (new_table = H5MM_calloc(new_size * sizeof(H5FD_onion_revision_index_hash_chain_node_t *))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "cannot allocate new hash table")
+
+ for (uint64_t i = 0; i < rix->_hash_table_size; i++) {
+ while (rix->_hash_table[i] != NULL) {
+ H5FD_onion_revision_index_hash_chain_node_t *node = NULL;
+ uint64_t key = 0;
+
+ /* Pop entry off of bucket stack and re-hash */
+ node = rix->_hash_table[i];
+ rix->_hash_table[i] = node->next;
+ node->next = NULL;
+ key = node->entry_data.logical_page & (new_size - 1);
+
+ if (NULL == new_table[key]) {
+ new_table[key] = node;
+ new_n_keys_populated++;
+ }
+ else {
+ node->next = new_table[i];
+ new_table[i] = node;
+ }
+ }
+ }
+
+ H5MM_xfree(rix->_hash_table);
+ rix->_hash_table_size = new_size;
+ rix->_hash_table_size_log2 = new_size_log2;
+ rix->_hash_table_n_keys_populated = new_n_keys_populated;
+ rix->_hash_table = new_table;
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_revision_index_resize() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_revision_index_insert()
+ *
+ * Purpose: Add an entry to the revision index, or update an existing
+ * entry. Must be used to update entries as well as add --
+ * checksum value will change.
+ *
+ * Entry data is copied into separate memory region; user pointer
+ * can be safley re-used or discarded after operation.
+ *
+ * Return: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+herr_t
+H5FD__onion_revision_index_insert(H5FD_onion_revision_index_t *rix, const H5FD_onion_index_entry_t *entry)
+{
+ uint64_t key = 0;
+ H5FD_onion_revision_index_hash_chain_node_t *node = NULL;
+ H5FD_onion_revision_index_hash_chain_node_t **append_dest = NULL;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE;
+
+ HDassert(rix);
+ HDassert(H5FD_ONION_REVISION_INDEX_VERSION_CURR == rix->version);
+ HDassert(entry);
+
+ /* Resize and re-hash table if necessary */
+ if (rix->n_entries >= (rix->_hash_table_size * 2) ||
+ rix->_hash_table_n_keys_populated >= (rix->_hash_table_size / 2)) {
+ if (H5FD__onion_revision_index_resize(rix) < 0)
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NONE_MINOR, FAIL, "unable to resize and hash table")
+ }
+
+ key = entry->logical_page & (rix->_hash_table_size - 1);
+ HDassert(key < rix->_hash_table_size);
+
+ if (NULL == rix->_hash_table[key]) {
+ /* Key maps to empty bucket */
+
+ append_dest = &rix->_hash_table[key];
+ rix->_hash_table_n_keys_populated++;
+ }
+ else {
+ /* Key maps to populated bucket */
+
+ for (node = rix->_hash_table[key]; node != NULL; node = node->next) {
+ append_dest = &node->next; /* look for bucket tail */
+ if (entry->logical_page == node->entry_data.logical_page) {
+ if (entry->phys_addr != node->entry_data.phys_addr) {
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "physical address mismatch");
+ }
+ HDmemcpy(&node->entry_data, entry, sizeof(H5FD_onion_index_entry_t));
+ append_dest = NULL; /* Node updated, do not append */
+ break;
+ }
+ }
+ }
+
+ /* Add new entry to bucket chain */
+ if (append_dest != NULL) {
+ if (NULL == (node = H5MM_malloc(sizeof(H5FD_onion_revision_index_hash_chain_node_t))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "cannot allocate new ash chain node")
+ node->version = H5FD_ONION_REVISION_INDEX_HASH_CHAIN_NODE_VERSION_CURR;
+ node->next = NULL;
+ HDmemcpy(&node->entry_data, entry, sizeof(H5FD_onion_index_entry_t));
+ *append_dest = node;
+ rix->n_entries++;
+ }
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_revision_index_insert() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_revision_index_find()
+ *
+ *
+ * Purpose: Get pointer to revision index entry with the given page number,
+ * if it exists in the index.
+ *
+ * Return: Success: Positive value (1) -- entry found.
+ * Entry out pointer-pointer is set to point to entry.
+ * Failure: Zero (0) -- entry not found.
+ * Entry out pointer-pointer is unmodified.
+ *-----------------------------------------------------------------------------
+ */
+int
+H5FD__onion_revision_index_find(const H5FD_onion_revision_index_t *rix, uint64_t logical_page,
+ const H5FD_onion_index_entry_t **entry_out)
+{
+ uint64_t key = 0;
+ int ret_value = 0;
+
+ FUNC_ENTER_PACKAGE_NOERR;
+
+ HDassert(rix);
+ HDassert(H5FD_ONION_REVISION_INDEX_VERSION_CURR == rix->version);
+ HDassert(rix->_hash_table);
+ HDassert(entry_out);
+
+ key = logical_page & (rix->_hash_table_size - 1);
+ HDassert(key < rix->_hash_table_size);
+
+ if (rix->_hash_table[key] != NULL) {
+ H5FD_onion_revision_index_hash_chain_node_t *node = NULL;
+
+ for (node = rix->_hash_table[key]; node != NULL; node = node->next) {
+ if (logical_page == node->entry_data.logical_page) {
+ *entry_out = &node->entry_data;
+ ret_value = 1;
+ break;
+ }
+ }
+ }
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_revision_index_find() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_revision_record_decode
+ *
+ * Purpose: Attempt to read a buffer and store it as a revision record
+ * structure.
+ *
+ * Implementation must correspond with
+ * H5FD__onion_revision_record_encode().
+ *
+ * MUST BE CALLED TWICE:
+ * On the first call, n_entries and comment_size in the
+ * destination structure must all all be zero, and their
+ * respective variable-length components (index_entry_list,
+ * comment) must all be NULL.
+ *
+ * If the buffer is well-formed, the destination structure is
+ * tentatively populated with fixed-size values, and the number of
+ * bytes read are returned.
+ *
+ * Prior to the second call, the user must allocate space for the
+ * variable-length components, in accordance with the associated
+ * indicators (array of index-entry structures for
+ * index_entry_list, of size n_entries; character arrays for
+ * comment, allocated with the *_size number of bytes -- space
+ * for NULL-terminator is included in _size).
+ *
+ * Then the decode operation is called a second time, and all
+ * components will be populated (and again number of bytes read is
+ * returned).
+ *
+ * Return: Success: Number of bytes read from buffer
+ * Failure: 0
+ *-----------------------------------------------------------------------------
+ */
+size_t
+H5FD__onion_revision_record_decode(unsigned char *buf, H5FD_onion_revision_record_t *record)
+{
+ uint32_t ui32 = 0;
+ uint32_t page_size = 0;
+ uint32_t sum = 0;
+ uint64_t ui64 = 0;
+ uint64_t n_entries = 0;
+ uint32_t comment_size = 0;
+ uint8_t *ui8p = NULL;
+ unsigned char *ptr = NULL;
+ size_t ret_value = 0;
+
+ FUNC_ENTER_PACKAGE;
+
+ HDassert(buf != NULL);
+ HDassert(record != NULL);
+ HDassert(H5FD_ONION_REVISION_RECORD_VERSION_CURR == record->version);
+ HDassert(H5FD_ONION_ARCHIVAL_INDEX_VERSION_CURR == record->archival_index.version);
+
+ if (HDstrncmp((const char *)buf, H5FD_ONION_REVISION_RECORD_SIGNATURE, 4))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "invalid signature")
+
+ if (H5FD_ONION_REVISION_RECORD_VERSION_CURR != buf[4])
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "invalid record version")
+
+ ptr = buf + 8;
+
+ HDmemcpy(&ui64, ptr, 8);
+ ui8p = (uint8_t *)&ui64;
+ UINT64DECODE(ui8p, record->revision_num);
+ ptr += 8;
+
+ HDmemcpy(&ui64, ptr, 8);
+ ui8p = (uint8_t *)&ui64;
+ UINT64DECODE(ui8p, record->parent_revision_num);
+ ptr += 8;
+
+ HDmemcpy(record->time_of_creation, ptr, 16);
+ ptr += 16;
+
+ HDmemcpy(&ui64, ptr, 8);
+ ui8p = (uint8_t *)&ui64;
+ UINT64DECODE(ui8p, record->logical_eof);
+ ptr += 8;
+
+ HDmemcpy(&ui32, ptr, 4);
+ ui8p = (uint8_t *)&ui32;
+ UINT32DECODE(ui8p, page_size);
+ ptr += 4;
+
+ if (page_size == 0)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "page size is zero")
+ if (!POWER_OF_TWO(page_size))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "page size not power of two")
+
+ for (record->archival_index.page_size_log2 = 0;
+ (((uint32_t)1 << record->archival_index.page_size_log2) & page_size) == 0;
+ record->archival_index.page_size_log2++)
+ ;
+
+ HDmemcpy(&ui64, ptr, 8);
+ ui8p = (uint8_t *)&ui64;
+ UINT64DECODE(ui8p, n_entries);
+ ptr += 8;
+
+ HDmemcpy(&ui32, ptr, 4);
+ ui8p = (uint8_t *)&ui32;
+ UINT32DECODE(ui8p, comment_size);
+ ptr += 4;
+
+ if (record->archival_index.n_entries == 0) {
+ record->archival_index.n_entries = n_entries;
+ ptr += H5FD_ONION_ENCODED_SIZE_INDEX_ENTRY * n_entries;
+ }
+ else if (n_entries != record->archival_index.n_entries) {
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "n_entries in archival index does not match decoded")
+ }
+ else {
+ H5FD_onion_index_entry_t *entry = NULL;
+
+ if (record->archival_index.list == NULL)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "no archival index entry list")
+
+ for (size_t i = 0; i < n_entries; i++) {
+ entry = &record->archival_index.list[i];
+
+ HDmemcpy(&ui64, ptr, 8);
+ ui8p = (uint8_t *)&ui64;
+ UINT64DECODE(ui8p, entry->logical_page);
+ ptr += 8;
+
+ /* logical_page actually encoded as address; check and convert */
+ if (entry->logical_page & (page_size - 1))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "logical address does not align with page size")
+
+ entry->logical_page = entry->logical_page >> record->archival_index.page_size_log2;
+
+ HDmemcpy(&ui64, ptr, 8);
+ ui8p = (uint8_t *)&ui64;
+ UINT64DECODE(ui8p, entry->phys_addr);
+ ptr += 8;
+
+ HDmemcpy(&ui32, ptr, 4);
+ ui8p = (uint8_t *)&ui32;
+ UINT32DECODE(ui8p, sum);
+ ptr += 4;
+
+ ui32 = H5_checksum_fletcher32((ptr - 20), 16);
+ if (ui32 != sum)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "index entry checksum mismatch")
+ }
+ }
+
+ if (record->comment_size == 0) {
+ if (record->comment != NULL)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "comment pointer prematurely allocated")
+ record->comment_size = comment_size;
+ }
+ else {
+ if (record->comment == NULL)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "no comment pointer")
+ HDmemcpy(record->comment, ptr, comment_size);
+ }
+ ptr += comment_size;
+
+ sum = H5_checksum_fletcher32(buf, (size_t)(ptr - buf));
+
+ HDmemcpy(&ui32, ptr, 4);
+ ui8p = (uint8_t *)&ui32;
+ UINT32DECODE(ui8p, record->checksum);
+ ptr += 4;
+
+ if (sum != record->checksum)
+ HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "checksum mismatch")
+
+ ret_value = (size_t)(ptr - buf);
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_revision_record_decode() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_revision_record_encode
+ *
+ * Purpose: Write revision-record structure to the given buffer.
+ * All multi-byte elements are stored in little-endian word order.
+ *
+ * Implementation must correspond with
+ * H5FD__onion_revision_record_decode().
+ *
+ * The destination buffer must be sufficiently large to hold the
+ * encoded contents.
+ * (Hint: `sizeof(revision-record-struct) + comment-size +
+ * sizeof(index-entry-struct) * n_entries)`
+ * guarantees ample/excess space.)
+ *
+ * Return: Number of bytes written to buffer.
+ * The checksum of the generated buffer contents (excluding the
+ * checksum itself) is stored in the pointer `checksum`).
+ *-----------------------------------------------------------------------------
+ */
+size_t
+H5FD__onion_revision_record_encode(H5FD_onion_revision_record_t *record, unsigned char *buf,
+ uint32_t *checksum)
+{
+ unsigned char *ptr = buf; /* original pointer */
+ uint32_t vers_u32 = (uint32_t)record->version; /* pad out unused bytes */
+ uint32_t page_size = 0;
+
+ FUNC_ENTER_PACKAGE_NOERR;
+
+ HDassert(checksum != NULL);
+ HDassert(buf != NULL);
+ HDassert(record != NULL);
+ HDassert(vers_u32 < 0x100);
+ HDassert(H5FD_ONION_REVISION_RECORD_VERSION_CURR == record->version);
+ HDassert(H5FD_ONION_ARCHIVAL_INDEX_VERSION_CURR == record->archival_index.version);
+
+ page_size = (uint32_t)(1 << record->archival_index.page_size_log2);
+
+ HDmemcpy(ptr, H5FD_ONION_REVISION_RECORD_SIGNATURE, 4);
+ ptr += 4;
+ UINT32ENCODE(ptr, vers_u32);
+ UINT64ENCODE(ptr, record->revision_num);
+ UINT64ENCODE(ptr, record->parent_revision_num);
+ HDmemcpy(ptr, record->time_of_creation, 16);
+ ptr += 16;
+ UINT64ENCODE(ptr, record->logical_eof);
+ UINT32ENCODE(ptr, page_size);
+ UINT64ENCODE(ptr, record->archival_index.n_entries);
+ UINT32ENCODE(ptr, record->comment_size);
+
+ if (record->archival_index.n_entries > 0) {
+ uint64_t page_size_log2 = record->archival_index.page_size_log2;
+
+ HDassert(record->archival_index.list != NULL);
+ for (uint64_t i = 0; i < record->archival_index.n_entries; i++) {
+ uint32_t sum = 0;
+ H5FD_onion_index_entry_t *entry = NULL;
+ uint64_t logi_addr = 0;
+
+ entry = &record->archival_index.list[i];
+ logi_addr = entry->logical_page << page_size_log2;
+
+ UINT64ENCODE(ptr, logi_addr);
+ UINT64ENCODE(ptr, entry->phys_addr);
+ sum = H5_checksum_fletcher32((ptr - 16), 16);
+ UINT32ENCODE(ptr, sum);
+ }
+ }
+
+ if (record->comment_size > 0) {
+ HDassert(record->comment != NULL && *record->comment != '\0');
+ HDmemcpy(ptr, record->comment, record->comment_size);
+ ptr += record->comment_size;
+ }
+
+ *checksum = H5_checksum_fletcher32(buf, (size_t)(ptr - buf));
+ UINT32ENCODE(ptr, *checksum);
+
+ FUNC_LEAVE_NOAPI((size_t)(ptr - buf));
+} /* end H5FD__onion_revision_record_encode() */
+
+/*-----------------------------------------------------------------------------
+ * Callback for comparisons in sorting archival index entries by logical_page.
+ *-----------------------------------------------------------------------------
+ */
+static int
+H5FD__onion_archival_index_list_sort_cmp(const void *_a, const void *_b)
+{
+ const H5FD_onion_index_entry_t *a = (const H5FD_onion_index_entry_t *)_a;
+ const H5FD_onion_index_entry_t *b = (const H5FD_onion_index_entry_t *)_b;
+
+ if (a->logical_page < b->logical_page)
+ return -1;
+ else if (a->logical_page > b->logical_page)
+ return 1;
+ return 0;
+} /* end H5FD__onion_archival_index_list_sort_cmp() */
+
+/*-----------------------------------------------------------------------------
+ * Function: H5FD__onion_merge_revision_index_into_archival_index
+ *
+ * Purpose: Merge index entries from revision index into archival index.
+ *
+ * If successful, the archival index is expanded 'behind the
+ * scenes' and new entries from the revision index are inserted.
+ * The archival index remains sorted in ascending order of logical
+ * address.
+ *
+ * The conversion to archival index changes logical pages in
+ * revision index entries to their logical addresses in-file.
+ *
+ * Return: SUCCEED/FAIL
+ *-----------------------------------------------------------------------------
+ */
+herr_t
+H5FD__onion_merge_revision_index_into_archival_index(const H5FD_onion_revision_index_t *rix,
+ H5FD_onion_archival_index_t *aix)
+{
+ uint64_t n_kept = 0;
+ H5FD_onion_index_entry_t *kept_list = NULL;
+ H5FD_onion_archival_index_t new_aix = {
+ H5FD_ONION_ARCHIVAL_INDEX_VERSION_CURR, 0, /* page_size_log2 tbd */
+ 0, /* n_entries */
+ NULL, /* list pointer (allocated later) */
+ };
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_PACKAGE;
+
+ HDassert(rix);
+ HDassert(aix);
+ HDassert(H5FD_ONION_REVISION_INDEX_VERSION_CURR == rix->version);
+ HDassert(H5FD_ONION_ARCHIVAL_INDEX_VERSION_CURR == aix->version);
+ HDassert(aix->page_size_log2 == rix->page_size_log2);
+
+ /* If the revision index is empty there is nothing to archive */
+ if (rix->n_entries == 0)
+ goto done;
+
+ /* Add all revision index entries to new archival list */
+ new_aix.page_size_log2 = aix->page_size_log2;
+
+ if (NULL == (new_aix.list = H5MM_calloc(rix->n_entries * sizeof(H5FD_onion_index_entry_t))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "unable to allocate new archival index list")
+
+ for (uint64_t i = 0; i < rix->_hash_table_size; i++) {
+ const H5FD_onion_revision_index_hash_chain_node_t *node = NULL;
+
+ for (node = rix->_hash_table[i]; node != NULL; node = node->next) {
+ HDmemcpy(&new_aix.list[new_aix.n_entries], &node->entry_data, sizeof(H5FD_onion_index_entry_t));
+ new_aix.n_entries++;
+ }
+ }
+
+ /* Sort the new archival list */
+ HDqsort(new_aix.list, new_aix.n_entries, sizeof(H5FD_onion_index_entry_t),
+ H5FD__onion_archival_index_list_sort_cmp);
+
+ /* Add the old archival index entries to a 'kept' list containing the
+ * old archival list entries that are not also included in the revision
+ * list.
+ *
+ * Note that kept_list will be NULL if there are no entries in the passed-in
+ * archival list.
+ */
+ if (aix->n_entries > 0)
+ if (NULL == (kept_list = H5MM_calloc(aix->n_entries * sizeof(H5FD_onion_index_entry_t))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "unable to allocate larger archival index list")
+
+ for (uint64_t i = 0; i < aix->n_entries; i++) {
+ const H5FD_onion_index_entry_t *entry = NULL;
+
+ /* Add only if page not already added from revision index */
+ if (H5FD__onion_archival_index_find(&new_aix, aix->list[i].logical_page, &entry) == 0) {
+ HDmemcpy(&kept_list[n_kept], &aix->list[i], sizeof(H5FD_onion_index_entry_t));
+ n_kept++;
+ }
+ }
+
+ /* Destroy the old archival list and replace with a list big enough to hold
+ * the revision list entries and the kept list entries
+ */
+ H5MM_xfree(aix->list);
+ if (NULL == (aix->list = H5MM_calloc((new_aix.n_entries + n_kept) * sizeof(H5FD_onion_index_entry_t))))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "unable to allocate exact-size archival index list")
+
+ /* Copy (new) revision list entries to replacement list */
+ HDmemcpy(aix->list, new_aix.list, sizeof(H5FD_onion_index_entry_t) * new_aix.n_entries);
+ aix->n_entries = new_aix.n_entries;
+
+ /* Copy (old) kept archival list entries to replacement list */
+ if (n_kept > 0) {
+ HDmemcpy(&aix->list[aix->n_entries], kept_list, sizeof(H5FD_onion_index_entry_t) * n_kept);
+ aix->n_entries += n_kept;
+ }
+
+ /* Sort this list */
+ HDqsort(aix->list, aix->n_entries, sizeof(H5FD_onion_index_entry_t),
+ H5FD__onion_archival_index_list_sort_cmp);
+
+done:
+ /* Free the temporary lists */
+ H5MM_xfree(kept_list);
+ H5MM_xfree(new_aix.list);
+
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5FD__onion_merge_revision_index_into_archival_index() */
diff --git a/src/H5FDonion_index.h b/src/H5FDonion_index.h
new file mode 100644
index 0000000..16e461b
--- /dev/null
+++ b/src/H5FDonion_index.h
@@ -0,0 +1,150 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group. *
+ * All rights reserved. *
+ * *
+ * This file is part of HDF5. The full HDF5 copyright notice, including *
+ * terms governing use, modification, and redistribution, is contained in *
+ * the COPYING file, which can be found at the root of the source code *
+ * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. *
+ * If you do not have access to either file, you may request a copy from *
+ * help@hdfgroup.org. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef H5FDonion_index_H
+#define H5FDonion_index_H
+
+#define H5FD_ONION_ARCHIVAL_INDEX_VERSION_CURR 1
+
+/* Number of bytes to encode fixed-size components */
+#define H5FD_ONION_ENCODED_SIZE_INDEX_ENTRY 20
+#define H5FD_ONION_ENCODED_SIZE_RECORD_POINTER 20
+#define H5FD_ONION_ENCODED_SIZE_REVISION_RECORD 68
+
+#define H5FD_ONION_REVISION_INDEX_HASH_CHAIN_NODE_VERSION_CURR 1
+#define H5FD_ONION_REVISION_INDEX_STARTING_SIZE_LOG2 10 /* 2^n slots */
+#define H5FD_ONION_REVISION_INDEX_VERSION_CURR 1
+
+#define H5FD_ONION_REVISION_RECORD_SIGNATURE "ORRS"
+#define H5FD_ONION_REVISION_RECORD_VERSION_CURR 1
+
+/*
+ * Onion Virtual File Driver (VFD)
+ *
+ * Purpose: Interface for the archival and revision indexes
+ */
+
+/*-----------------------------------------------------------------------------
+ *
+ * Structure H5FD__onion_index_entry
+ *
+ * Purpose: Map a page in the logical file to a 'physical address' in the
+ * onion file.
+ *
+ * logical_page:
+ *
+ * Page 'id' in the logical file.
+ *
+ * phys_addr:
+ *
+ * Address/offset of start of page in the onion file.
+ *
+ *-----------------------------------------------------------------------------
+ */
+typedef struct H5FD_onion_index_entry_t {
+ uint64_t logical_page;
+ haddr_t phys_addr;
+} H5FD_onion_index_entry_t;
+
+/*-----------------------------------------------------------------------------
+ *
+ * Structure H5FD__onion_archival_index
+ *
+ * Purpose: Encapsulate archival index and associated data.
+ * Convenience structure with sanity-checking components.
+ *
+ * version: Future-proofing identifier. Informs struct membership.
+ * Must equal H5FD_ONION_ARCHIVAL_INDEX_VERSION_CURR to be
+ * considered valid.
+ *
+ * page_size: Interval to which the `logical_page` component of each list
+ * entry must align.
+ * Value is taken from the onion history data; must not change
+ * following onionization or file or creation of onion file.
+ *
+ * n_entries: Number of entries in the list.
+ *
+ * list: Pointer to array of archival index entries.
+ * Cannot be NULL.
+ * Entries must be sorted by `logical_page_id` in ascending order.
+ *
+ *-----------------------------------------------------------------------------
+ */
+typedef struct H5FD_onion_archival_index_t {
+ uint8_t version;
+ uint32_t page_size_log2;
+ uint64_t n_entries;
+ H5FD_onion_index_entry_t *list;
+} H5FD_onion_archival_index_t;
+
+/* data structure for storing index entries at a hash key collision */
+/* version 1 implements a singly-linked list */
+typedef struct H5FD_onion_revision_index_hash_chain_node_t H5FD_onion_revision_index_hash_chain_node_t;
+struct H5FD_onion_revision_index_hash_chain_node_t {
+ uint8_t version;
+ H5FD_onion_index_entry_t entry_data;
+ H5FD_onion_revision_index_hash_chain_node_t *next;
+};
+
+typedef struct H5FD_onion_revision_index_t {
+ uint8_t version;
+ uint32_t page_size_log2;
+ uint64_t n_entries; /* count of all entries in table */
+ uint64_t _hash_table_size; /* 'slots' in hash table */
+ uint64_t _hash_table_size_log2; /* 2^(n) -> 'slots' in hash table */
+ uint64_t _hash_table_n_keys_populated; /* count of slots not NULL */
+ H5FD_onion_revision_index_hash_chain_node_t **_hash_table;
+} H5FD_onion_revision_index_t;
+
+/* In-memory representation of the on-store revision record.
+ */
+typedef struct H5FD_onion_revision_record_t {
+ uint8_t version;
+ uint64_t revision_num;
+ uint64_t parent_revision_num;
+ char time_of_creation[16];
+ uint64_t logical_eof;
+ H5FD_onion_archival_index_t archival_index;
+ uint32_t comment_size;
+ char *comment;
+ uint32_t checksum;
+} H5FD_onion_revision_record_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+H5_DLL herr_t H5FD__onion_ingest_revision_record(H5FD_onion_revision_record_t *r_out, H5FD_t *raw_file,
+ const H5FD_onion_history_t *history, uint64_t revision_num);
+
+H5_DLL hbool_t H5FD__onion_archival_index_is_valid(const H5FD_onion_archival_index_t *);
+H5_DLL int H5FD__onion_archival_index_find(const H5FD_onion_archival_index_t *, uint64_t,
+ const H5FD_onion_index_entry_t **);
+
+H5_DLL H5FD_onion_revision_index_t *H5FD__onion_revision_index_init(uint32_t page_size);
+H5_DLL herr_t H5FD__onion_revision_index_destroy(H5FD_onion_revision_index_t *);
+H5_DLL herr_t H5FD__onion_revision_index_insert(H5FD_onion_revision_index_t *,
+ const H5FD_onion_index_entry_t *);
+H5_DLL int H5FD__onion_revision_index_find(const H5FD_onion_revision_index_t *, uint64_t,
+ const H5FD_onion_index_entry_t **);
+
+H5_DLL herr_t H5FD__onion_merge_revision_index_into_archival_index(const H5FD_onion_revision_index_t *,
+ H5FD_onion_archival_index_t *);
+
+H5_DLL size_t H5FD__onion_revision_record_decode(unsigned char *buf, H5FD_onion_revision_record_t *record);
+H5_DLL size_t H5FD__onion_revision_record_encode(H5FD_onion_revision_record_t *record, unsigned char *buf,
+ uint32_t *checksum);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* H5FDonion_index_H */
diff --git a/src/H5FDonion_priv.h b/src/H5FDonion_priv.h
new file mode 100644
index 0000000..031c132
--- /dev/null
+++ b/src/H5FDonion_priv.h
@@ -0,0 +1,28 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group. *
+ * All rights reserved. *
+ * *
+ * This file is part of HDF5. The full HDF5 copyright notice, including *
+ * terms governing use, modification, and redistribution, is contained in *
+ * the COPYING file, which can be found at the root of the source code *
+ * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. *
+ * If you do not have access to either file, you may request a copy from *
+ * help@hdfgroup.org. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Onion Virtual File Driver (VFD) Internals.
+ *
+ * Purpose: The private header file for the Onion VFD.
+ * Contains definitions and declarations used internallay and by
+ * tests.
+ */
+
+#ifndef H5FDonion_priv_H
+#define H5FDonion_priv_H
+
+#include "H5FDonion_header.h"
+#include "H5FDonion_history.h"
+#include "H5FDonion_index.h"
+
+#endif /* H5FDonion_priv_H */
diff --git a/src/H5FDpublic.h b/src/H5FDpublic.h
index eb3d4cf..51527a0 100644
--- a/src/H5FDpublic.h
+++ b/src/H5FDpublic.h
@@ -46,6 +46,7 @@
#define H5_VFD_ROS3 ((H5FD_class_value_t)(11))
#define H5_VFD_SUBFILING ((H5FD_class_value_t)(12))
#define H5_VFD_IOC ((H5FD_class_value_t)(13))
+#define H5_VFD_ONION ((H5FD_class_value_t)(14))
/* VFD IDs below this value are reserved for library use. */
#define H5_VFD_RESERVED 256
diff --git a/src/H5private.h b/src/H5private.h
index b3b8e97..f9e7aff 100644
--- a/src/H5private.h
+++ b/src/H5private.h
@@ -1068,6 +1068,9 @@ H5_DLL H5_ATTR_CONST int Nflock(int fd, int operation);
#ifndef HDlog
#define HDlog(X) log(X)
#endif
+#ifndef HDlog2
+#define HDlog2(X) log2(X)
+#endif
#ifndef HDlog10
#define HDlog10(X) log10(X)
#endif
diff --git a/src/H5trace.c b/src/H5trace.c
index 8df2984..2b714fb 100644
--- a/src/H5trace.c
+++ b/src/H5trace.c
@@ -1098,6 +1098,9 @@ H5_trace_args(H5RS_str_t *rs, const char *type, va_list ap)
H5RS_acat(rs, "H5_VFD_ROS3");
break;
#endif
+ case H5_VFD_ONION:
+ H5RS_acat(rs, "H5_VFD_ONION");
+ break;
default:
H5RS_asprintf_cat(rs, "%ld", (long)class_val);
break;
diff --git a/src/Makefile.am b/src/Makefile.am
index 0dbb175..a84fb02 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -61,8 +61,9 @@ libhdf5_la_SOURCES= H5.c H5checksum.c H5dbg.c H5lib_settings.c H5system.c \
H5Fsuper.c H5Fsuper_cache.c H5Ftest.c \
H5FA.c H5FAcache.c H5FAdbg.c H5FAdblock.c H5FAdblkpage.c H5FAhdr.c \
H5FAint.c H5FAstat.c H5FAtest.c \
- H5FD.c H5FDcore.c H5FDfamily.c H5FDint.c H5FDlog.c \
- H5FDmulti.c H5FDperform.c H5FDsec2.c H5FDspace.c \
+ H5FD.c H5FDcore.c H5FDfamily.c H5FDint.c H5FDlog.c H5FDmulti.c \
+ H5FDonion.c H5FDonion_header.c H5FDonion_history.c H5FDonion_index.c \
+ H5FDperform.c H5FDsec2.c H5FDspace.c \
H5FDsplitter.c H5FDstdio.c H5FDtest.c \
H5FL.c H5FO.c H5FS.c H5FScache.c H5FSdbg.c H5FSint.c H5FSsection.c \
H5FSstat.c H5FStest.c \
@@ -154,9 +155,10 @@ include_HEADERS = hdf5.h H5api_adpt.h H5overflow.h H5pubconf.h H5public.h H5vers
H5Cpublic.h H5Dpublic.h \
H5Epubgen.h H5Epublic.h H5ESpublic.h H5Fpublic.h \
H5FDpublic.h H5FDcore.h H5FDdirect.h H5FDfamily.h H5FDhdfs.h \
- H5FDlog.h H5FDmirror.h H5FDmpi.h H5FDmpio.h H5FDmulti.h H5FDros3.h \
- H5FDsec2.h H5FDsplitter.h \
- H5FDstdio.h H5FDwindows.h H5FDsubfiling/H5FDsubfiling.h H5FDsubfiling/H5FDioc.h \
+ H5FDlog.h H5FDmirror.h H5FDmpi.h H5FDmpio.h H5FDmulti.h \
+ H5FDonion.h H5FDros3.h H5FDsec2.h H5FDsplitter.h \
+ H5FDstdio.h H5FDsubfiling/H5FDsubfiling.h H5FDsubfiling/H5FDioc.h \
+ H5FDwindows.h \
H5Gpublic.h H5Ipublic.h H5Lpublic.h \
H5Mpublic.h H5MMpublic.h H5Opublic.h H5Ppublic.h \
H5PLextern.h H5PLpublic.h \
diff --git a/src/hdf5.h b/src/hdf5.h
index 8176e83..e219c4d 100644
--- a/src/hdf5.h
+++ b/src/hdf5.h
@@ -64,6 +64,7 @@
#include "H5FDmirror.h" /* Mirror VFD and IPC definitions */
#include "H5FDmpi.h" /* MPI-based file drivers */
#include "H5FDmulti.h" /* Usage-partitioned file family */
+#include "H5FDonion.h" /* Onion file I/O */
#include "H5FDros3.h" /* R/O S3 "file" I/O */
#include "H5FDsec2.h" /* POSIX unbuffered file I/O */
#include "H5FDsplitter.h" /* Twin-channel (R/W & R/O) I/O passthrough */
generated by cgit v0.12 at 2024-12-25 17:39:12 (GMT)