Formats the source and updates the gcc warning pragmas

1 files changed, 311 insertions, 392 deletions

diff --git a/src/H5FDvfd_swmr.c b/src/H5FDvfd_swmr.c
index 405bcd7..90c06b6 100644
--- a/src/H5FDvfd_swmr.c
+++ b/src/H5FDvfd_swmr.c
@@ -17,126 +17,120 @@
 
 #include "H5FDdrvr_module.h" /* This source code file is part of the H5FD driver module */
 
-
-#include "H5Eprivate.h"     /* Error handling           */
-#include "H5Fprivate.h"     /* File access              */
-#include "H5FDprivate.h"    /* File drivers             */
-#include "H5FDvfd_swmr.h"   /* VFD SWMR file driver     */
-#include "H5FLprivate.h"    /* Free Lists               */
-#include "H5Iprivate.h"     /* IDs                      */
-#include "H5MMprivate.h"    /* Memory management        */
-#include "H5Pprivate.h"     /* Property lists           */
-#include "H5retry_private.h"/* Retry loops.		*/
+#include "H5Eprivate.h"      /* Error handling           */
+#include "H5Fprivate.h"      /* File access              */
+#include "H5FDprivate.h"     /* File drivers             */
+#include "H5FDvfd_swmr.h"    /* VFD SWMR file driver     */
+#include "H5FLprivate.h"     /* Free Lists               */
+#include "H5Iprivate.h"      /* IDs                      */
+#include "H5MMprivate.h"     /* Memory management        */
+#include "H5Pprivate.h"      /* Property lists           */
+#include "H5retry_private.h" /* Retry loops.		*/
 
 /* The driver identification number, initialized at runtime */
 static hid_t H5FD_VFD_SWMR_g = 0;
 
 typedef struct H5FD_vfd_swmr_t {
-    H5FD_t pub;                                 /* public stuff, must be      */
-                                                /* first                      */
+    H5FD_t pub; /* public stuff, must be      */
+                /* first                      */
 
     /* HDF5 file */
-    char hdf5_filename[H5FD_MAX_FILENAME_LEN];  /* Name of the HDF5 file from */
-                                                /* open                       */
-    H5FD_t *hdf5_file_lf;                       /* Driver info for the HDF5   */
-                                                /* file                       */
+    char hdf5_filename[H5FD_MAX_FILENAME_LEN]; /* Name of the HDF5 file from */
+                                               /* open                       */
+    H5FD_t *hdf5_file_lf;                      /* Driver info for the HDF5   */
+                                               /* file                       */
 
     /* Metadata file */
-    int md_fd;                                  /* File descriptor for the    */
-                                                /* metadata file              */
-    uint32_t md_pages_reserved;                 /* # of pages reserved at the */
-                                                /* head of the metadata file  */
-    char md_file_path[H5FD_MAX_FILENAME_LEN];   /* Name of the metadate file  */
-    H5FD_vfd_swmr_md_header md_header;          /* Metadata file header       */
-    H5FD_vfd_swmr_md_index md_index;            /* Metadata file index        */
-
-    uint64_t *api_elapsed_ticks;            /* Histogram of ticks elapsed
-                                             * inside the API (reader only).
-                                             * api_elapsed_ticks[elapsed] is
-                                             * the number of times `elapsed`
-                                             * ticks passed in an API call
-                                             * during the program lifetime.
-                                             */
-    uint32_t api_elapsed_nbuckets;          /* Number of histogram buckets. */
-
-    hbool_t pb_configured;                      /* boolean flag set to TRUE   */
-                                                /* when the page buffer is    */
-                                                /* and to FALSE otherwise.    */
-                                                /* Used for sanity checking.  */
+    int md_fd;                                                   /* File descriptor for the    */
+                                                                 /* metadata file              */
+    uint32_t md_pages_reserved;                                  /* # of pages reserved at the */
+                                                                 /* head of the metadata file  */
+    char                    md_file_path[H5FD_MAX_FILENAME_LEN]; /* Name of the metadate file  */
+    H5FD_vfd_swmr_md_header md_header;                           /* Metadata file header       */
+    H5FD_vfd_swmr_md_index  md_index;                            /* Metadata file index        */
+
+    uint64_t *api_elapsed_ticks;   /* Histogram of ticks elapsed
+                                    * inside the API (reader only).
+                                    * api_elapsed_ticks[elapsed] is
+                                    * the number of times `elapsed`
+                                    * ticks passed in an API call
+                                    * during the program lifetime.
+                                    */
+    uint32_t api_elapsed_nbuckets; /* Number of histogram buckets. */
+
+    hbool_t pb_configured; /* boolean flag set to TRUE   */
+                           /* when the page buffer is    */
+                           /* and to FALSE otherwise.    */
+                           /* Used for sanity checking.  */
     H5F_vfd_swmr_config_t config;
-    hbool_t writer;                         /* True iff configured to write.
-                                             * All methods on a write-mode
-                                             * SWMR VFD instance are passed
-                                             * to the lower VFD instance.
-                                             */
+    hbool_t               writer; /* True iff configured to write.
+                                   * All methods on a write-mode
+                                   * SWMR VFD instance are passed
+                                   * to the lower VFD instance.
+                                   */
 } H5FD_vfd_swmr_t;
 
-#define MAXADDR (((haddr_t)1<<(8*sizeof(HDoff_t)-1))-1)
+#define MAXADDR (((haddr_t)1 << (8 * sizeof(HDoff_t) - 1)) - 1)
 
 /* Prototypes */
-static herr_t H5FD_vfd_swmr_term(void);
-static H5FD_t *H5FD_vfd_swmr_open(const char *name, unsigned flags,
-    hid_t fapl_id, haddr_t maxaddr);
-static herr_t H5FD_vfd_swmr_close(H5FD_t *_file);
-static int H5FD_vfd_swmr_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
+static herr_t  H5FD_vfd_swmr_term(void);
+static H5FD_t *H5FD_vfd_swmr_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr);
+static herr_t  H5FD_vfd_swmr_close(H5FD_t *_file);
+static int     H5FD_vfd_swmr_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
 static H5FD_t *H5FD_vfd_swmr_dedup(H5FD_t *, H5FD_t *, hid_t);
-static herr_t H5FD_vfd_swmr_query(const H5FD_t *_f1, unsigned long *flags);
+static herr_t  H5FD_vfd_swmr_query(const H5FD_t *_f1, unsigned long *flags);
 static haddr_t H5FD_vfd_swmr_get_eoa(const H5FD_t *_file, H5FD_mem_t type);
-static herr_t H5FD_vfd_swmr_set_eoa(H5FD_t *_file, H5FD_mem_t type,
-    haddr_t addr);
+static herr_t  H5FD_vfd_swmr_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr);
 static haddr_t H5FD_vfd_swmr_get_eof(const H5FD_t *_file, H5FD_mem_t type);
-static herr_t  H5FD_vfd_swmr_get_handle(H5FD_t *_file, hid_t fapl,
-    void** file_handle);
-static herr_t H5FD_vfd_swmr_read(H5FD_t *_file, H5FD_mem_t type,
-    hid_t fapl_id, haddr_t addr, size_t size, void *buf);
-static herr_t H5FD_vfd_swmr_write(H5FD_t *_file, H5FD_mem_t type,
-    hid_t fapl_id, haddr_t addr, size_t size, const void *buf);
-static herr_t H5FD_vfd_swmr_truncate(H5FD_t *_file, hid_t dxpl_id,
-    hbool_t closing);
-static herr_t H5FD_vfd_swmr_lock(H5FD_t *_file, hbool_t rw);
-static herr_t H5FD_vfd_swmr_unlock(H5FD_t *_file);
+static herr_t  H5FD_vfd_swmr_get_handle(H5FD_t *_file, hid_t fapl, void **file_handle);
+static herr_t  H5FD_vfd_swmr_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size,
+                                  void *buf);
+static herr_t  H5FD_vfd_swmr_write(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size,
+                                   const void *buf);
+static herr_t  H5FD_vfd_swmr_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
+static herr_t  H5FD_vfd_swmr_lock(H5FD_t *_file, hbool_t rw);
+static herr_t  H5FD_vfd_swmr_unlock(H5FD_t *_file);
 
 /* VFD SWMR */
-static htri_t H5FD__vfd_swmr_header_deserialize(H5FD_vfd_swmr_t *,
-    H5FD_vfd_swmr_md_header *);
-static htri_t H5FD__vfd_swmr_index_deserialize(const H5FD_vfd_swmr_t *file,
-    H5FD_vfd_swmr_md_index *md_index, const H5FD_vfd_swmr_md_header *md_header);
+static htri_t H5FD__vfd_swmr_header_deserialize(H5FD_vfd_swmr_t *, H5FD_vfd_swmr_md_header *);
+static htri_t H5FD__vfd_swmr_index_deserialize(const H5FD_vfd_swmr_t *file, H5FD_vfd_swmr_md_index *md_index,
+                                               const H5FD_vfd_swmr_md_header *md_header);
 static herr_t H5FD__vfd_swmr_load_hdr_and_idx(H5FD_vfd_swmr_t *, hbool_t);
 
 static const H5FD_class_t H5FD_vfd_swmr_g = {
-    "vfd_swmr",                 /* name                 */
-    MAXADDR,                    /* maxaddr              */
-    H5F_CLOSE_WEAK,             /* fc_degree            */
-    H5FD_vfd_swmr_term,         /* terminate            */
-    NULL,                       /* sb_size              */
-    NULL,                       /* sb_encode            */
-    NULL,                       /* sb_decode            */
-    0,                          /* fapl_size            */
-    NULL,                       /* fapl_get             */
-    NULL,                       /* fapl_copy            */
-    NULL,                       /* fapl_free            */
-    0,                          /* dxpl_size            */
-    NULL,                       /* dxpl_copy            */
-    NULL,                       /* dxpl_free            */
-    H5FD_vfd_swmr_open,         /* open                 */
-    H5FD_vfd_swmr_close,        /* close                */
-    H5FD_vfd_swmr_cmp,          /* cmp                  */
-    H5FD_vfd_swmr_query,        /* query                */
-    NULL,                       /* get_type_map         */
-    NULL,                       /* alloc                */
-    NULL,                       /* free                 */
-    H5FD_vfd_swmr_get_eoa,      /* get_eoa              */
-    H5FD_vfd_swmr_set_eoa,      /* set_eoa              */
-    H5FD_vfd_swmr_get_eof,      /* get_eof              */
-    H5FD_vfd_swmr_get_handle,   /* get_handle           */
-    H5FD_vfd_swmr_read,         /* read                 */
-    H5FD_vfd_swmr_write,        /* write                */
-    NULL,                       /* flush                */
-    H5FD_vfd_swmr_truncate,     /* truncate             */
-    H5FD_vfd_swmr_lock,         /* lock                 */
-    H5FD_vfd_swmr_unlock,       /* unlock               */
-    H5FD_vfd_swmr_dedup,        /* dedup               */
-    H5FD_FLMAP_DICHOTOMY        /* fl_map               */
+    "vfd_swmr",               /* name                 */
+    MAXADDR,                  /* maxaddr              */
+    H5F_CLOSE_WEAK,           /* fc_degree            */
+    H5FD_vfd_swmr_term,       /* terminate            */
+    NULL,                     /* sb_size              */
+    NULL,                     /* sb_encode            */
+    NULL,                     /* sb_decode            */
+    0,                        /* fapl_size            */
+    NULL,                     /* fapl_get             */
+    NULL,                     /* fapl_copy            */
+    NULL,                     /* fapl_free            */
+    0,                        /* dxpl_size            */
+    NULL,                     /* dxpl_copy            */
+    NULL,                     /* dxpl_free            */
+    H5FD_vfd_swmr_open,       /* open                 */
+    H5FD_vfd_swmr_close,      /* close                */
+    H5FD_vfd_swmr_cmp,        /* cmp                  */
+    H5FD_vfd_swmr_query,      /* query                */
+    NULL,                     /* get_type_map         */
+    NULL,                     /* alloc                */
+    NULL,                     /* free                 */
+    H5FD_vfd_swmr_get_eoa,    /* get_eoa              */
+    H5FD_vfd_swmr_set_eoa,    /* set_eoa              */
+    H5FD_vfd_swmr_get_eof,    /* get_eof              */
+    H5FD_vfd_swmr_get_handle, /* get_handle           */
+    H5FD_vfd_swmr_read,       /* read                 */
+    H5FD_vfd_swmr_write,      /* write                */
+    NULL,                     /* flush                */
+    H5FD_vfd_swmr_truncate,   /* truncate             */
+    H5FD_vfd_swmr_lock,       /* lock                 */
+    H5FD_vfd_swmr_unlock,     /* unlock               */
+    H5FD_vfd_swmr_dedup,      /* dedup               */
+    H5FD_FLMAP_DICHOTOMY      /* fl_map               */
 };
 
 /* Declare a free list to manage the H5FD_vfd_swmr_t struct */
@@ -145,7 +139,6 @@ H5FL_DEFINE_STATIC(H5FD_vfd_swmr_t);
 /* Declare a free list to manage the H5FD_vfd_swmr_idx_entry_t sequence information */
 H5FL_SEQ_DEFINE(H5FD_vfd_swmr_idx_entry_t);
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD__init_package
  *
@@ -163,14 +156,13 @@ H5FD__init_package(void)
 
     FUNC_ENTER_STATIC
 
-    if(H5FD_vfd_swmr_init() < 0)
+    if (H5FD_vfd_swmr_init() < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "unable to initialize swmr VFD")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD__init_package() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_init
  *
@@ -188,11 +180,11 @@ done:
 hid_t
 H5FD_vfd_swmr_init(void)
 {
-    hid_t ret_value = H5I_INVALID_HID;          /* Return value */
+    hid_t ret_value = H5I_INVALID_HID; /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    if(H5I_VFL != H5I_get_type(H5FD_VFD_SWMR_g))
+    if (H5I_VFL != H5I_get_type(H5FD_VFD_SWMR_g))
         H5FD_VFD_SWMR_g = H5FD_register(&H5FD_vfd_swmr_g, sizeof(H5FD_class_t), FALSE);
 
     /* Set return value */
@@ -202,7 +194,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_vfd_swmr_init() */
 
-
 /*---------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_term
  *
@@ -226,7 +217,6 @@ H5FD_vfd_swmr_term(void)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5FD_vfd_swmr_term() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5Pset_fapl_vfd_swmr (Not yet)
  *
@@ -240,13 +230,13 @@ H5FD_vfd_swmr_term(void)
 herr_t
 H5Pset_fapl_vfd_swmr(hid_t fapl_id)
 {
-    H5P_genplist_t *plist;      /* Property list pointer */
-    herr_t ret_value;
+    H5P_genplist_t *plist; /* Property list pointer */
+    herr_t          ret_value;
 
     FUNC_ENTER_API(FAIL)
     H5TRACE1("e", "i", fapl_id);
 
-    if(NULL == (plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS)))
+    if (NULL == (plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list")
 
     ret_value = H5P_set_driver(plist, H5FD_VFD_SWMR, NULL);
@@ -263,47 +253,41 @@ static herr_t
 H5FD__swmr_reader_open(H5FD_vfd_swmr_t *file)
 {
     h5_retry_t retry;
-    hbool_t do_try;                         /* more tries remain */
-    herr_t      ret_value = SUCCEED;
+    hbool_t    do_try; /* more tries remain */
+    herr_t     ret_value = SUCCEED;
     FUNC_ENTER_STATIC
 
     file->api_elapsed_nbuckets = file->config.max_lag + 1;
 
-    file->api_elapsed_ticks =
-        H5MM_calloc(file->api_elapsed_nbuckets * sizeof(*file->api_elapsed_ticks));
+    file->api_elapsed_ticks = H5MM_calloc(file->api_elapsed_nbuckets * sizeof(*file->api_elapsed_ticks));
 
     if (file->api_elapsed_ticks == NULL) {
-        HGOTO_ERROR(H5E_FILE, H5E_CANTALLOC, FAIL,
-            "could not allocate API elapsed ticks");
+        HGOTO_ERROR(H5E_FILE, H5E_CANTALLOC, FAIL, "could not allocate API elapsed ticks");
     }
 
     /* Retry on opening the metadata file */
-    for (do_try = h5_retry_init(&retry, H5FD_VFD_SWMR_MD_FILE_RETRY_MAX,
-                                 H5_RETRY_DEFAULT_MINIVAL,
-                                 H5_RETRY_DEFAULT_MAXIVAL);
-         do_try;
-         do_try = h5_retry_next(&retry)) {
-        if((file->md_fd = HDopen(file->md_file_path, O_RDONLY)) >= 0)
+    for (do_try         = h5_retry_init(&retry, H5FD_VFD_SWMR_MD_FILE_RETRY_MAX, H5_RETRY_DEFAULT_MINIVAL,
+                                H5_RETRY_DEFAULT_MAXIVAL);
+         do_try; do_try = h5_retry_next(&retry)) {
+        if ((file->md_fd = HDopen(file->md_file_path, O_RDONLY)) >= 0)
             break;
     }
 
     /* Exhaust all retries for opening the md file */
-    if(!do_try)
+    if (!do_try)
         HGOTO_ERROR(H5E_VFL, H5E_OPENERROR, FAIL,
-                   "unable to open the metadata file after all retry attempts");
+                    "unable to open the metadata file after all retry attempts");
 
     /* Retry on loading and decoding the header and index in the
      *  metadata file
      */
-    if(H5FD__vfd_swmr_load_hdr_and_idx(file, TRUE) < 0)
-        HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL,
-                    "unable to load/decode the md file header/index");
+    if (H5FD__vfd_swmr_load_hdr_and_idx(file, TRUE) < 0)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "unable to load/decode the md file header/index");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_open
  *
@@ -317,21 +301,19 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5FD_t *
-H5FD_vfd_swmr_open(const char *name, unsigned flags, hid_t fapl_id,
-    haddr_t maxaddr)
+H5FD_vfd_swmr_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
 {
-    H5FD_vfd_swmr_t *file = NULL;
-    size_t page_buf_size;
-    H5P_genplist_t *plist;
+    H5FD_vfd_swmr_t *      file = NULL;
+    size_t                 page_buf_size;
+    H5P_genplist_t *       plist;
     H5F_vfd_swmr_config_t *vfd_swmr_config;
-    H5FD_t *ret_value  = NULL;               /* Return value     */
+    H5FD_t *               ret_value = NULL; /* Return value     */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Get file access property list */
-    if(NULL == (plist = (H5P_genplist_t *)H5I_object(fapl_id))) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL,
-                    "not a file access property list");
+    if (NULL == (plist = (H5P_genplist_t *)H5I_object(fapl_id))) {
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a file access property list");
     }
 
     if (H5P_get(plist, H5F_ACS_PAGE_BUFFER_SIZE_NAME, &page_buf_size) < 0)
@@ -342,26 +324,23 @@ H5FD_vfd_swmr_open(const char *name, unsigned flags, hid_t fapl_id,
      * and return an error.
      */
     if (page_buf_size == 0) {
-        HGOTO_ERROR(H5E_FILE, H5E_CANTGET, NULL,
-            "page buffering must be enabled");
+        HGOTO_ERROR(H5E_FILE, H5E_CANTGET, NULL, "page buffering must be enabled");
     }
 
     /* Create the new driver struct */
-    if(NULL == (file = H5FL_CALLOC(H5FD_vfd_swmr_t))) {
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
-                    "unable to allocate file struct");
+    if (NULL == (file = H5FL_CALLOC(H5FD_vfd_swmr_t))) {
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "unable to allocate file struct");
     }
 
     vfd_swmr_config = &file->config;
 
     /* Get VFD SWMR configuration */
-    if(H5P_get(plist, H5F_ACS_VFD_SWMR_CONFIG_NAME, vfd_swmr_config) < 0) {
-        HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL,
-                    "can't get VFD SWMR config info");
+    if (H5P_get(plist, H5F_ACS_VFD_SWMR_CONFIG_NAME, vfd_swmr_config) < 0) {
+        HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get VFD SWMR config info");
     }
 
-    file->md_fd = -1;
-    file->hdf5_file_lf = NULL;
+    file->md_fd             = -1;
+    file->hdf5_file_lf      = NULL;
     file->md_pages_reserved = vfd_swmr_config->md_pages_reserved;
 
     /* Retain a copy of the name used to open the HDF5 file */
@@ -369,21 +348,18 @@ H5FD_vfd_swmr_open(const char *name, unsigned flags, hid_t fapl_id,
     file->hdf5_filename[sizeof(file->hdf5_filename) - 1] = '\0';
 
     /* Retain a copy of the metadata file name */
-    HDstrncpy(file->md_file_path, vfd_swmr_config->md_file_path,
-              sizeof(file->md_file_path));
+    HDstrncpy(file->md_file_path, vfd_swmr_config->md_file_path, sizeof(file->md_file_path));
     file->md_file_path[sizeof(file->md_file_path) - 1] = '\0';
 
     file->writer = vfd_swmr_config->writer;
 
     /* Ensure that this is the reader */
     if (!vfd_swmr_config->writer && H5FD__swmr_reader_open(file) < 0) {
-        HGOTO_ERROR(H5E_VFL, H5E_OPENERROR, NULL,
-                   "perform reader-specific opening steps failed");
+        HGOTO_ERROR(H5E_VFL, H5E_OPENERROR, NULL, "perform reader-specific opening steps failed");
     }
 
     /* Hard-wired to open the underlying HDF5 file with SEC2 */
-    if((file->hdf5_file_lf = H5FD_open(name, flags, H5P_FILE_ACCESS_DEFAULT,
-                                       maxaddr)) == NULL)
+    if ((file->hdf5_file_lf = H5FD_open(name, flags, H5P_FILE_ACCESS_DEFAULT, maxaddr)) == NULL)
         HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL, "can't set driver info");
 
     file->hdf5_file_lf->exc_owner = &file->pub;
@@ -404,9 +380,9 @@ H5FD_vfd_swmr_open(const char *name, unsigned flags, hid_t fapl_id,
 
 done:
     /* Handle closing if error */
-    if(NULL == ret_value && file) {
+    if (NULL == ret_value && file) {
 
-        if(H5FD_vfd_swmr_close(&file->pub) < 0)
+        if (H5FD_vfd_swmr_close(&file->pub) < 0)
 
             HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "error from closing")
 
@@ -428,19 +404,16 @@ swmr_reader_close(H5FD_vfd_swmr_t *file)
         H5MM_xfree(file->api_elapsed_ticks);
 
     /* Close the metadata file */
-    if(file->md_fd >= 0 && HDclose(file->md_fd) < 0) {
+    if (file->md_fd >= 0 && HDclose(file->md_fd) < 0) {
         /* Push error, but keep going */
-        HERROR(H5E_FILE, H5E_CANTCLOSEFILE,
-            "unable to close the metadata file");
+        HERROR(H5E_FILE, H5E_CANTCLOSEFILE, "unable to close the metadata file");
     }
 
     /* Free the index entries */
-    if(file->md_index.num_entries && file->md_index.entries)
-        file->md_index.entries = H5FL_SEQ_FREE(H5FD_vfd_swmr_idx_entry_t,
-                                               file->md_index.entries);
+    if (file->md_index.num_entries && file->md_index.entries)
+        file->md_index.entries = H5FL_SEQ_FREE(H5FD_vfd_swmr_idx_entry_t, file->md_index.entries);
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_close
  *
@@ -457,8 +430,8 @@ swmr_reader_close(H5FD_vfd_swmr_t *file)
 static herr_t
 H5FD_vfd_swmr_close(H5FD_t *_file)
 {
-    H5FD_vfd_swmr_t *file = (H5FD_vfd_swmr_t *)_file;
-    herr_t      ret_value = SUCCEED;                /* Return value */
+    H5FD_vfd_swmr_t *file      = (H5FD_vfd_swmr_t *)_file;
+    herr_t           ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -470,9 +443,8 @@ H5FD_vfd_swmr_close(H5FD_t *_file)
 
         /* Close the underlying file */
         if (H5FD_close(file->hdf5_file_lf) < 0)
-             /* Push error, but keep going */
-            HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, \
-                        "unable to close the HDF5 file")
+            /* Push error, but keep going */
+            HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "unable to close the HDF5 file")
     }
 
     if (!file->writer)
@@ -485,7 +457,6 @@ H5FD_vfd_swmr_close(H5FD_t *_file)
 
 } /* end H5FD_vfd_swmr_close() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_cmp
  *
@@ -501,9 +472,9 @@ H5FD_vfd_swmr_close(H5FD_t *_file)
 static int
 H5FD_vfd_swmr_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
 {
-    const H5FD_vfd_swmr_t   *f1 = (const H5FD_vfd_swmr_t *)_f1;
-    const H5FD_vfd_swmr_t   *f2 = (const H5FD_vfd_swmr_t *)_f2;
-    int ret_value = 0;
+    const H5FD_vfd_swmr_t *f1        = (const H5FD_vfd_swmr_t *)_f1;
+    const H5FD_vfd_swmr_t *f2        = (const H5FD_vfd_swmr_t *)_f2;
+    int                    ret_value = 0;
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -552,10 +523,10 @@ H5FD_vfd_swmr_dedup(H5FD_t *_self, H5FD_t *_other, hid_t fapl)
     HDassert(_self->driver_id == H5FD_VFD_SWMR_g);
 
     if (_self->cls == _other->cls) {
-        H5FD_vfd_swmr_t *other = (H5FD_vfd_swmr_t *)_other;
-        H5P_genplist_t *plist;
+        H5FD_vfd_swmr_t *      other = (H5FD_vfd_swmr_t *)_other;
+        H5P_genplist_t *       plist;
         H5F_vfd_swmr_config_t *config;
-        hbool_t equal_configs;
+        hbool_t                equal_configs;
 
         if (H5FD_cmp(self->hdf5_file_lf, other->hdf5_file_lf) != 0)
             return _other;
@@ -581,8 +552,8 @@ H5FD_vfd_swmr_dedup(H5FD_t *_self, H5FD_t *_other, hid_t fapl)
             return NULL;
         }
         if (H5P_get(plist, H5F_ACS_VFD_SWMR_CONFIG_NAME, config) < 0) {
-           HERROR(H5E_PLIST, H5E_CANTGET, "cannot get VFD SWMR config");
-           return NULL;
+            HERROR(H5E_PLIST, H5E_CANTGET, "cannot get VFD SWMR config");
+            return NULL;
         }
 
         equal_configs = HDmemcmp(&self->config, config, sizeof(*config)) == 0;
@@ -594,14 +565,15 @@ H5FD_vfd_swmr_dedup(H5FD_t *_self, H5FD_t *_other, hid_t fapl)
 
         HERROR(H5E_PLIST, H5E_CANTGET, "inconsistent VFD SWMR config");
         return NULL;
-    } else if (H5FD_cmp(self->hdf5_file_lf, _other) == 0) {
+    }
+    else if (H5FD_cmp(self->hdf5_file_lf, _other) == 0) {
         return (fapl == H5P_FILE_ACCESS_ANY_VFD) ? _self : NULL;
-    } else {
+    }
+    else {
         return _other;
     }
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_query
  *
@@ -618,32 +590,32 @@ H5FD_vfd_swmr_query(const H5FD_t H5_ATTR_UNUSED *_file, unsigned long *flags /*
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* Set the VFL feature flags that this driver supports */
-    if(flags) {
+    if (flags) {
         *flags = 0;
-        *flags |= H5FD_FEAT_AGGREGATE_METADATA;     /* OK to aggregate      */
-                                                    /* metadata allocations */
+        *flags |= H5FD_FEAT_AGGREGATE_METADATA; /* OK to aggregate      */
+                                                /* metadata allocations */
 
-        *flags |= H5FD_FEAT_ACCUMULATE_METADATA;    /* OK to accumulate     */
-                                                    /* metadata for faster  */
-                                                    /* writes               */
+        *flags |= H5FD_FEAT_ACCUMULATE_METADATA; /* OK to accumulate     */
+                                                 /* metadata for faster  */
+                                                 /* writes               */
 
-        *flags |= H5FD_FEAT_DATA_SIEVE;             /* OK to perform data   */
-                                                    /* sieving for faster   */
-                                                    /* raw data reads &     */
-                                                    /* writes               */
+        *flags |= H5FD_FEAT_DATA_SIEVE; /* OK to perform data   */
+                                        /* sieving for faster   */
+                                        /* raw data reads &     */
+                                        /* writes               */
 
-        *flags |= H5FD_FEAT_AGGREGATE_SMALLDATA;    /* OK to aggregate      */
-                                                    /* "small" raw data     */
-                                                    /* allocations          */
+        *flags |= H5FD_FEAT_AGGREGATE_SMALLDATA; /* OK to aggregate      */
+                                                 /* "small" raw data     */
+                                                 /* allocations          */
 
-        *flags |= H5FD_FEAT_POSIX_COMPAT_HANDLE;    /* get_handle callback  */
-                                                    /* returns a POSIX file */
-                                                    /* descriptor           */
+        *flags |= H5FD_FEAT_POSIX_COMPAT_HANDLE; /* get_handle callback  */
+                                                 /* returns a POSIX file */
+                                                 /* descriptor           */
 
-        *flags |= H5FD_FEAT_SUPPORTS_SWMR_IO;       /* VFD supports the     */
-                                                    /* single-writer/       */
-                                                    /* multiple-readers     */
-                                                    /* (SWMR) pattern       */
+        *flags |= H5FD_FEAT_SUPPORTS_SWMR_IO; /* VFD supports the     */
+                                              /* single-writer/       */
+                                              /* multiple-readers     */
+                                              /* (SWMR) pattern       */
 
         *flags |= H5FD_FEAT_DEFAULT_VFD_COMPATIBLE; /* VFD creates a file   */
                                                     /* which can be opened  */
@@ -654,7 +626,6 @@ H5FD_vfd_swmr_query(const H5FD_t H5_ATTR_UNUSED *_file, unsigned long *flags /*
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5FD_vfd_swmr_query() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_get_eoa
  *
@@ -669,21 +640,19 @@ H5FD_vfd_swmr_query(const H5FD_t H5_ATTR_UNUSED *_file, unsigned long *flags /*
 static haddr_t
 H5FD_vfd_swmr_get_eoa(const H5FD_t *_file, H5FD_mem_t type)
 {
-    const H5FD_vfd_swmr_t	*file = (const H5FD_vfd_swmr_t *)_file;
-    haddr_t ret_value = HADDR_UNDEF;
+    const H5FD_vfd_swmr_t *file      = (const H5FD_vfd_swmr_t *)_file;
+    haddr_t                ret_value = HADDR_UNDEF;
 
     FUNC_ENTER_NOAPI_NOINIT
 
-    if((ret_value = H5FD_get_eoa(file->hdf5_file_lf, type)) == HADDR_UNDEF)
+    if ((ret_value = H5FD_get_eoa(file->hdf5_file_lf, type)) == HADDR_UNDEF)
 
-        HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, HADDR_UNDEF, \
-                    "unable to get HDF5 file eoa")
+        HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, HADDR_UNDEF, "unable to get HDF5 file eoa")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_vfd_swmr_get_eoa() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_set_eoa
  *
@@ -699,12 +668,12 @@ done:
 static herr_t
 H5FD_vfd_swmr_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr)
 {
-    H5FD_vfd_swmr_t	*file = (H5FD_vfd_swmr_t *)_file;
-    herr_t ret_value = SUCCEED;
+    H5FD_vfd_swmr_t *file      = (H5FD_vfd_swmr_t *)_file;
+    herr_t           ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT
 
-    if(H5FD_set_eoa(file->hdf5_file_lf, type, addr) < 0)
+    if (H5FD_set_eoa(file->hdf5_file_lf, type, addr) < 0)
 
         HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "unable to set HDF5 file eoa")
 
@@ -712,7 +681,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_vfd_swmr_set_eoa() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_get_eof
  *
@@ -728,22 +696,20 @@ done:
 static haddr_t
 H5FD_vfd_swmr_get_eof(const H5FD_t *_file, H5FD_mem_t type)
 {
-    const H5FD_vfd_swmr_t   *file = (const H5FD_vfd_swmr_t *)_file;
-    haddr_t ret_value = HADDR_UNDEF;
+    const H5FD_vfd_swmr_t *file      = (const H5FD_vfd_swmr_t *)_file;
+    haddr_t                ret_value = HADDR_UNDEF;
 
     FUNC_ENTER_NOAPI_NOINIT
 
     /* LATER: need to determine the metadata file or underlying HDF5 file ? */
-    if((ret_value = H5FD_get_eof(file->hdf5_file_lf, type)) == HADDR_UNDEF)
+    if ((ret_value = H5FD_get_eof(file->hdf5_file_lf, type)) == HADDR_UNDEF)
 
-        HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, HADDR_UNDEF, \
-                    "unable to set file eoa")
+        HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, HADDR_UNDEF, "unable to set file eoa")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_vfd_swmr_get_eof() */
 
-
 /*-------------------------------------------------------------------------
  * Function:       H5FD_vfd_swmr_get_handle
  *
@@ -756,27 +722,24 @@ done:
 static herr_t
 H5FD_vfd_swmr_get_handle(H5FD_t *_file, hid_t fapl, void **file_handle)
 {
-    H5FD_vfd_swmr_t     *file = (H5FD_vfd_swmr_t *)_file;
-    herr_t              ret_value = SUCCEED;
+    H5FD_vfd_swmr_t *file      = (H5FD_vfd_swmr_t *)_file;
+    herr_t           ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT
 
-    if(!file_handle)
+    if (!file_handle)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file handle not valid")
 
     /* LATER? H5P_get(plist, H5F_ACS_SWMR_FILE_NAME, &type) */
 
-    if((ret_value = H5FD_get_vfd_handle(file->hdf5_file_lf,
-                                        fapl, file_handle)) < 0)
+    if ((ret_value = H5FD_get_vfd_handle(file->hdf5_file_lf, fapl, file_handle)) < 0)
 
-        HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, \
-                    "unable to get handle for HDF5 file")
+        HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "unable to get handle for HDF5 file")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_vfd_swmr_get_handle() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_read
  *
@@ -813,19 +776,18 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_vfd_swmr_read(H5FD_t *_file, H5FD_mem_t type,
-    hid_t H5_ATTR_UNUSED dxpl_id,
-    const haddr_t addr, size_t size, void * const buf /*out*/)
+H5FD_vfd_swmr_read(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, const haddr_t addr,
+                   size_t size, void *const buf /*out*/)
 {
-    const size_t init_size = size;
-    haddr_t target_page;
-    haddr_t page_offset;
-    H5FD_vfd_swmr_t *file = (H5FD_vfd_swmr_t *)_file;
+    const size_t               init_size = size;
+    haddr_t                    target_page;
+    haddr_t                    page_offset;
+    H5FD_vfd_swmr_t *          file = (H5FD_vfd_swmr_t *)_file;
     H5FD_vfd_swmr_idx_entry_t *index, *entry;
-    uint32_t num_entries = 0;
-    uint32_t fs_page_size;
-    herr_t ret_value = SUCCEED;
-    char *p = buf;
+    uint32_t                   num_entries = 0;
+    uint32_t                   fs_page_size;
+    herr_t                     ret_value = SUCCEED;
+    char *                     p         = buf;
 
     if (file->writer)
         return H5FD_read(file->hdf5_file_lf, type, addr, size, buf);
@@ -842,14 +804,12 @@ H5FD_vfd_swmr_read(H5FD_t *_file, H5FD_mem_t type,
     /* Try finding the addr from the index */
     target_page = addr / fs_page_size;
 
-    entry = vfd_swmr_pageno_to_mdf_idx_entry(index, num_entries, target_page,
-        FALSE);
+    entry = vfd_swmr_pageno_to_mdf_idx_entry(index, num_entries, target_page, FALSE);
 
     if (entry == NULL) {
-         /* Cannot find addr in index, read from the underlying hdf5 file */
-        if(H5FD_read(file->hdf5_file_lf, type, addr, size, buf) < 0) {
-            HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, \
-                        "file read request failed");
+        /* Cannot find addr in index, read from the underlying hdf5 file */
+        if (H5FD_read(file->hdf5_file_lf, type, addr, size, buf) < 0) {
+            HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "file read request failed");
         }
         HGOTO_DONE(SUCCEED);
     }
@@ -859,29 +819,26 @@ H5FD_vfd_swmr_read(H5FD_t *_file, H5FD_mem_t type,
 
     page_offset = addr - (target_page * fs_page_size);
 
-    HDassert( ( page_offset == 0 ) ||
-              ( ( ! file->pb_configured ) &&
-                ( page_offset + size <= fs_page_size ) ) );
+    HDassert((page_offset == 0) || ((!file->pb_configured) && (page_offset + size <= fs_page_size)));
 
     HDassert(entry->hdf5_page_offset * fs_page_size <= addr);
     HDassert(addr < (entry->hdf5_page_offset + 1) * fs_page_size);
     HDassert(page_offset + init_size <= entry->length);
 
-    if(HDlseek(file->md_fd, (HDoff_t)
-               ((entry->md_file_page_offset * fs_page_size)
-                + page_offset), SEEK_SET) < 0)
+    if (HDlseek(file->md_fd, (HDoff_t)((entry->md_file_page_offset * fs_page_size) + page_offset), SEEK_SET) <
+        0)
         HGOTO_ERROR(H5E_VFL, H5E_SEEKERROR, FAIL, "unable to seek in metadata file")
 
     /* Coding borrowed from sec2 read */
-    while(size > 0) {
+    while (size > 0) {
 
-        h5_posix_io_t     bytes_in;     /* # of bytes to read */
-        h5_posix_io_ret_t bytes_read;   /* # of bytes actually read */
+        h5_posix_io_t     bytes_in;   /* # of bytes to read */
+        h5_posix_io_ret_t bytes_read; /* # of bytes actually read */
 
         /* Trying to read more bytes than the return type can handle is
          * undefined behavior in POSIX.
          */
-        if(size > H5_POSIX_MAX_IO_BYTES)
+        if (size > H5_POSIX_MAX_IO_BYTES)
             bytes_in = MIN(H5_POSIX_MAX_IO_BYTES, size);
         else
             bytes_in = (h5_posix_io_t)size;
@@ -890,8 +847,9 @@ H5FD_vfd_swmr_read(H5FD_t *_file, H5FD_mem_t type,
             bytes_read = HDread(file->md_fd, p, bytes_in);
         } while (-1 == bytes_read && EINTR == errno);
 
-        if(-1 == bytes_read)
-            HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "error reading the page/multi-page entry from the md file")
+        if (-1 == bytes_read)
+            HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL,
+                        "error reading the page/multi-page entry from the md file")
 
         HDassert(0 <= bytes_read && (size_t)bytes_read <= size);
 
@@ -909,24 +867,22 @@ H5FD_vfd_swmr_read(H5FD_t *_file, H5FD_mem_t type,
      * is John's hack to allow the library to find the superblock
      * signature.
      */
-    if (file->pb_configured && entry->length == init_size
-            && H5_checksum_metadata(buf, entry->length, 0) != entry->chksum) {
+    if (file->pb_configured && entry->length == init_size &&
+        H5_checksum_metadata(buf, entry->length, 0) != entry->chksum) {
         H5FD_vfd_swmr_md_header tmp_header;
 
         if (H5FD__vfd_swmr_header_deserialize(file, &tmp_header) != TRUE) {
             HGOTO_ERROR(H5E_VFL, H5E_CANTLOAD, FAIL,
-                "checksum error in shadow file entry; could not load header");
+                        "checksum error in shadow file entry; could not load header");
         }
 
-        HGOTO_ERROR(H5E_VFL, H5E_CANTLOAD, FAIL,
-            "checksum error in shadow file entry");
+        HGOTO_ERROR(H5E_VFL, H5E_CANTLOAD, FAIL, "checksum error in shadow file entry");
     }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_vfd_swmr_read() */
 
-
 /*
  * Function:    H5FD_vfd_swmr_write
  *
@@ -937,10 +893,10 @@ done:
  * Return:      SUCCEED/FAIL
  */
 static herr_t
-H5FD_vfd_swmr_write(H5FD_t *_file, H5FD_mem_t type,
-    hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr, size_t size, const void *buf)
+H5FD_vfd_swmr_write(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr, size_t size,
+                    const void *buf)
 {
-    H5FD_vfd_swmr_t     *file       = (H5FD_vfd_swmr_t *)_file;
+    H5FD_vfd_swmr_t *file = (H5FD_vfd_swmr_t *)_file;
 
     /* This routine should only be called if the VFD instance is opened
      * for writing.
@@ -950,7 +906,6 @@ H5FD_vfd_swmr_write(H5FD_t *_file, H5FD_mem_t type,
     return H5FD_write(file->hdf5_file_lf, type, addr, size, buf);
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_truncate
  *
@@ -962,8 +917,7 @@ H5FD_vfd_swmr_write(H5FD_t *_file, H5FD_mem_t type,
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_vfd_swmr_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id,
-   hbool_t closing)
+H5FD_vfd_swmr_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t closing)
 {
     H5FD_vfd_swmr_t *file = (H5FD_vfd_swmr_t *)_file; /* VFD SWMR file struct */
 
@@ -975,7 +929,6 @@ H5FD_vfd_swmr_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id,
     return H5FD_truncate(file->hdf5_file_lf, closing);
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_lock
  *
@@ -988,23 +941,21 @@ H5FD_vfd_swmr_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id,
 static herr_t
 H5FD_vfd_swmr_lock(H5FD_t *_file, hbool_t rw)
 {
-    H5FD_vfd_swmr_t *file = (H5FD_vfd_swmr_t *)_file; /* VFD SWMR file struct */
-    herr_t ret_value = SUCCEED;     /* Return value  */
+    H5FD_vfd_swmr_t *file      = (H5FD_vfd_swmr_t *)_file; /* VFD SWMR file struct */
+    herr_t           ret_value = SUCCEED;                  /* Return value  */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     HDassert(file);
 
-    if(H5FD_lock(file->hdf5_file_lf, rw) < 0)
+    if (H5FD_lock(file->hdf5_file_lf, rw) < 0)
 
-         HGOTO_ERROR(H5E_IO, H5E_CANTLOCK, FAIL, \
-                     "unable to lock the HDF5 file")
+        HGOTO_ERROR(H5E_IO, H5E_CANTLOCK, FAIL, "unable to lock the HDF5 file")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_vfd_swmr_lock() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_unlock
  *
@@ -1017,17 +968,16 @@ done:
 static herr_t
 H5FD_vfd_swmr_unlock(H5FD_t *_file)
 {
-    H5FD_vfd_swmr_t *file = (H5FD_vfd_swmr_t *)_file; /* VFD SWMR file struct */
-    herr_t ret_value = SUCCEED;                       /* Return value */
+    H5FD_vfd_swmr_t *file      = (H5FD_vfd_swmr_t *)_file; /* VFD SWMR file struct */
+    herr_t           ret_value = SUCCEED;                  /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     HDassert(file);
 
-    if(H5FD_unlock(file->hdf5_file_lf) < 0)
+    if (H5FD_unlock(file->hdf5_file_lf) < 0)
 
-        HGOTO_ERROR(H5E_IO, H5E_CANTUNLOCK, FAIL, \
-                    "unable to unlock the HDF5 file")
+        HGOTO_ERROR(H5E_IO, H5E_CANTUNLOCK, FAIL, "unable to unlock the HDF5 file")
 
 done:
 
@@ -1035,7 +985,6 @@ done:
 
 } /* end H5FD_vfd_swmr_unlock() */
 
-
 /*
  * Function:    H5FD__vfd_swmr_load_hdr_and_idx()
  *
@@ -1084,21 +1033,20 @@ done:
 static herr_t
 H5FD__vfd_swmr_load_hdr_and_idx(H5FD_vfd_swmr_t *file, hbool_t open)
 {
-    hbool_t do_try;
-    h5_retry_t retry;
-    H5FD_vfd_swmr_md_header md_header;      /* Metadata file header, take 1 */
-    H5FD_vfd_swmr_md_header md_header_two;  /* Metadata file header, take 2 */
-    H5FD_vfd_swmr_md_index md_index;     /* Metadata file index           */
-    herr_t ret_value  = SUCCEED;         /* Return value                  */
-    htri_t rc;
-    static uint64_t last_index_offset = 0;
+    hbool_t                 do_try;
+    h5_retry_t              retry;
+    H5FD_vfd_swmr_md_header md_header;           /* Metadata file header, take 1 */
+    H5FD_vfd_swmr_md_header md_header_two;       /* Metadata file header, take 2 */
+    H5FD_vfd_swmr_md_index  md_index;            /* Metadata file index           */
+    herr_t                  ret_value = SUCCEED; /* Return value                  */
+    htri_t                  rc;
+    static uint64_t         last_index_offset = 0;
 
     FUNC_ENTER_STATIC
 
-    for (do_try = h5_retry_init(&retry, H5FD_VFD_SWMR_MD_LOAD_RETRY_MAX,
-                      H5_RETRY_ONE_SECOND / 10, H5_RETRY_ONE_SECOND);
-         do_try;
-         do_try = h5_retry_next(&retry)) {
+    for (do_try         = h5_retry_init(&retry, H5FD_VFD_SWMR_MD_LOAD_RETRY_MAX, H5_RETRY_ONE_SECOND / 10,
+                                H5_RETRY_ONE_SECOND);
+         do_try; do_try = h5_retry_next(&retry)) {
 
         /* Load and decode the header.  Go around again on a temporary
          * failure (FALSE).  Bail on an irrecoverable failure (FAIL).
@@ -1123,10 +1071,10 @@ H5FD__vfd_swmr_load_hdr_and_idx(H5FD_vfd_swmr_t *file, hbool_t open)
              * get out.
              */
             HGOTO_DONE(SUCCEED);
-        } else if (md_header.tick_num < file->md_header.tick_num) {
+        }
+        else if (md_header.tick_num < file->md_header.tick_num) {
             /* The tick number must not move backward. */
-            HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL,
-                "tick number in header moved backwards");
+            HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "tick number in header moved backwards");
         }
 
         HDassert(md_header.tick_num > file->md_header.tick_num || open);
@@ -1147,8 +1095,7 @@ H5FD__vfd_swmr_load_hdr_and_idx(H5FD_vfd_swmr_t *file, hbool_t open)
          * then we should have a consistent picture of the index.
          */
         if (md_header.tick_num == md_index.tick_num &&
-            (rc = H5FD__vfd_swmr_header_deserialize(file,
-                &md_header_two)) == TRUE &&
+            (rc = H5FD__vfd_swmr_header_deserialize(file, &md_header_two)) == TRUE &&
             md_header.tick_num == md_header_two.tick_num &&
             md_header.index_length == md_header_two.index_length &&
             md_header.index_offset == md_header_two.index_offset)
@@ -1157,14 +1104,12 @@ H5FD__vfd_swmr_load_hdr_and_idx(H5FD_vfd_swmr_t *file, hbool_t open)
         if (md_index.entries != NULL) {
 
             HDassert(md_index.num_entries);
-            md_index.entries = (H5FD_vfd_swmr_idx_entry_t *)
-                               H5FL_SEQ_FREE(H5FD_vfd_swmr_idx_entry_t,
-                                             md_index.entries);
+            md_index.entries =
+                (H5FD_vfd_swmr_idx_entry_t *)H5FL_SEQ_FREE(H5FD_vfd_swmr_idx_entry_t, md_index.entries);
         }
 
         if (rc == FAIL) {
-            HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL,
-                "could not re-read header");
+            HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "could not re-read header");
         }
     }
 
@@ -1172,8 +1117,8 @@ H5FD__vfd_swmr_load_hdr_and_idx(H5FD_vfd_swmr_t *file, hbool_t open)
      * and index
      */
     if (!do_try) {
-        HGOTO_ERROR(H5E_VFL, H5E_CANTLOAD, FAIL, \
-                "error in loading/decoding the metadata file header and index")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTLOAD, FAIL,
+                    "error in loading/decoding the metadata file header and index")
     }
 
     /* Free VFD local entries */
@@ -1181,22 +1126,21 @@ H5FD__vfd_swmr_load_hdr_and_idx(H5FD_vfd_swmr_t *file, hbool_t open)
 
         HDassert(file->md_index.num_entries);
 
-        file->md_index.entries = (H5FD_vfd_swmr_idx_entry_t *)
-             H5FL_SEQ_FREE(H5FD_vfd_swmr_idx_entry_t, file->md_index.entries);
+        file->md_index.entries =
+            (H5FD_vfd_swmr_idx_entry_t *)H5FL_SEQ_FREE(H5FD_vfd_swmr_idx_entry_t, file->md_index.entries);
     }
 
     /* Copy header and index to VFD */
-    file->md_header = md_header;
-    file->md_index = md_index;
+    file->md_header  = md_header;
+    file->md_index   = md_index;
     md_index.entries = NULL;
 
 done:
 
     FUNC_LEAVE_NOAPI(ret_value)
 
-}  /* H5FD__vfd_swmr_load_hdr_and_idx() */
+} /* H5FD__vfd_swmr_load_hdr_and_idx() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD__vfd_swmr_header_deserialize()
  *
@@ -1213,23 +1157,21 @@ done:
  *-------------------------------------------------------------------------
  */
 static htri_t
-H5FD__vfd_swmr_header_deserialize(H5FD_vfd_swmr_t *file,
-    H5FD_vfd_swmr_md_header *md_header)
+H5FD__vfd_swmr_header_deserialize(H5FD_vfd_swmr_t *file, H5FD_vfd_swmr_md_header *md_header)
 {
-    uint8_t image[H5FD_MD_HEADER_SIZE];     /* Buffer for element data */
-    uint32_t stored_chksum;                 /* Stored metadata checksum */
-    uint32_t computed_chksum;               /* Computed metadata checksum */
+    uint8_t  image[H5FD_MD_HEADER_SIZE]; /* Buffer for element data */
+    uint32_t stored_chksum;              /* Stored metadata checksum */
+    uint32_t computed_chksum;            /* Computed metadata checksum */
     uint8_t *p;
-    htri_t ret_value = FAIL;
+    htri_t   ret_value = FAIL;
     uint64_t index_length;
-    ssize_t nread;
+    ssize_t  nread;
 
     FUNC_ENTER_STATIC
 
     /* Set file pointer to the beginning the file */
     if (HDlseek(file->md_fd, H5FD_MD_HEADER_OFF, SEEK_SET) < 0) {
-        HGOTO_ERROR(H5E_VFL, H5E_SEEKERROR, FAIL, \
-                    "unable to seek in metadata file");
+        HGOTO_ERROR(H5E_VFL, H5E_SEEKERROR, FAIL, "unable to seek in metadata file");
     }
 
     /* Read the header */
@@ -1243,8 +1185,7 @@ H5FD__vfd_swmr_header_deserialize(H5FD_vfd_swmr_t *file,
      * so bail out.
      */
     if (nread == -1) {
-        HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL,
-                    "error in reading the shadow header");
+        HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "error in reading the shadow header");
     }
 
     if ((uint64_t)nread < H5FD_MD_HEADER_SIZE)
@@ -1255,8 +1196,7 @@ H5FD__vfd_swmr_header_deserialize(H5FD_vfd_swmr_t *file,
         HGOTO_DONE(FALSE);
 
     /* Verify stored and computed checksums are equal */
-    H5F_get_checksums(image, H5FD_MD_HEADER_SIZE, &stored_chksum,
-                      &computed_chksum);
+    H5F_get_checksums(image, H5FD_MD_HEADER_SIZE, &stored_chksum, &computed_chksum);
 
     if (stored_chksum != computed_chksum)
         HGOTO_DONE(FALSE);
@@ -1269,8 +1209,7 @@ H5FD__vfd_swmr_header_deserialize(H5FD_vfd_swmr_t *file,
     UINT64DECODE(p, md_header->tick_num);
     UINT64DECODE(p, md_header->index_offset);
     if ((index_length = uint64_decode(&p)) > SIZE_MAX) {
-        HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL,
-                     "index is too large to hold in core");
+        HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "index is too large to hold in core");
     }
 
     md_header->index_length = (size_t)index_length;
@@ -1281,7 +1220,7 @@ H5FD__vfd_swmr_header_deserialize(H5FD_vfd_swmr_t *file,
     /* Sanity check */
     HDassert((size_t)(p - image) <= H5FD_MD_HEADER_SIZE);
 
-#if 0 /* JRM */
+#if 0  /* JRM */
     HDfprintf(stderr,
         "---read header ps/tick/idx_off/idx_len = %d / %lld / %lld / %lld\n",
              md_header->fs_page_size, md_header->tick_num,
@@ -1296,8 +1235,6 @@ done:
 
 } /* H5FD__vfd_swmr_header_deserialize() */
 
-
-
 /*
  * Function:    H5FD__vfd_swmr_index_deserialize()
  *
@@ -1315,29 +1252,28 @@ done:
  *
  */
 static htri_t
-H5FD__vfd_swmr_index_deserialize(const H5FD_vfd_swmr_t *file,
-    H5FD_vfd_swmr_md_index *md_index, const H5FD_vfd_swmr_md_header *md_header)
+H5FD__vfd_swmr_index_deserialize(const H5FD_vfd_swmr_t *file, H5FD_vfd_swmr_md_index *md_index,
+                                 const H5FD_vfd_swmr_md_header *md_header)
 {
-    uint8_t *image;                 /* Buffer */
-    uint8_t *p = NULL;              /* Pointer to buffer */
-    uint32_t stored_chksum;         /* Stored metadata checksum value */
-    uint32_t computed_chksum;       /* Computed metadata checksum value */
-    unsigned i;                     /* Local index variable */
-    htri_t ret_value = TRUE;
-    ssize_t nread;
+    uint8_t *image;           /* Buffer */
+    uint8_t *p = NULL;        /* Pointer to buffer */
+    uint32_t stored_chksum;   /* Stored metadata checksum value */
+    uint32_t computed_chksum; /* Computed metadata checksum value */
+    unsigned i;               /* Local index variable */
+    htri_t   ret_value = TRUE;
+    ssize_t  nread;
 
     FUNC_ENTER_STATIC
 
     /* Allocate buffer for reading index */
     if (NULL == (image = H5MM_malloc(md_header->index_length))) {
         HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL,
-                   "memory allocation failed for index's on disk image buffer");
+                    "memory allocation failed for index's on disk image buffer");
     }
 
     /* We may seek past EOF.  That's ok, the read(2) will catch that. */
-    if (HDlseek(file->md_fd, (HDoff_t)md_header->index_offset, SEEK_SET) < 0){
-        HGOTO_ERROR(H5E_VFL, H5E_SEEKERROR, FAIL,
-                    "unable to seek in metadata file");
+    if (HDlseek(file->md_fd, (HDoff_t)md_header->index_offset, SEEK_SET) < 0) {
+        HGOTO_ERROR(H5E_VFL, H5E_SEEKERROR, FAIL, "unable to seek in metadata file");
     }
 
     nread = HDread(file->md_fd, image, md_header->index_length);
@@ -1350,8 +1286,7 @@ H5FD__vfd_swmr_index_deserialize(const H5FD_vfd_swmr_t *file,
      * so bail out.
      */
     if (nread == -1) {
-        HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL,
-                    "error in reading the header in metadata file");
+        HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "error in reading the header in metadata file");
     }
 
     /* Try again if the read was not full.
@@ -1391,8 +1326,7 @@ H5FD__vfd_swmr_index_deserialize(const H5FD_vfd_swmr_t *file,
         HGOTO_DONE(FALSE);
 
     /* Verify stored and computed checksums are equal */
-    H5F_get_checksums(image, md_header->index_length, &stored_chksum,
-                      &computed_chksum);
+    H5F_get_checksums(image, md_header->index_length, &stored_chksum, &computed_chksum);
 
     if (stored_chksum != computed_chksum)
         HGOTO_DONE(FALSE);
@@ -1406,13 +1340,11 @@ H5FD__vfd_swmr_index_deserialize(const H5FD_vfd_swmr_t *file,
     UINT32DECODE(p, md_index->num_entries);
 
     /* Read index entries */
-    if(md_index->num_entries) {
+    if (md_index->num_entries) {
         /* Allocate memory for index entries */
-        md_index->entries = H5FL_SEQ_CALLOC(H5FD_vfd_swmr_idx_entry_t,
-                                    md_index->num_entries);
+        md_index->entries = H5FL_SEQ_CALLOC(H5FD_vfd_swmr_idx_entry_t, md_index->num_entries);
         if (NULL == md_index->entries) {
-            HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL,
-                "memory allocation failed for index entries");
+            HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "memory allocation failed for index entries");
         }
 
         /* Decode index entries */
@@ -1421,23 +1353,23 @@ H5FD__vfd_swmr_index_deserialize(const H5FD_vfd_swmr_t *file,
             UINT32DECODE(p, md_index->entries[i].md_file_page_offset);
             UINT32DECODE(p, md_index->entries[i].length);
             UINT32DECODE(p, md_index->entries[i].chksum);
-         }
-     } else
+        }
+    }
+    else
         md_index->entries = NULL;
 
-     /* Checksum is already valid */
-     UINT32DECODE(p, stored_chksum);
+    /* Checksum is already valid */
+    UINT32DECODE(p, stored_chksum);
 
-     /* Sanity check */
-     HDassert((size_t)(p - image) <= md_header->index_length);
+    /* Sanity check */
+    HDassert((size_t)(p - image) <= md_header->index_length);
 
-#if 0 /* JRM */
+#if 0  /* JRM */
     HDfprintf(stderr,
              " ---- read index tick/num_entries = %lld / %d \n",
              md_index->tick_num, md_index->num_entries);
 #endif /* JRM */
 
-
 done:
     if (image != NULL)
         image = H5MM_xfree(image);
@@ -1446,15 +1378,13 @@ done:
 
         HDassert(md_index->num_entries != 0);
 
-        md_index->entries =
-            H5FL_SEQ_FREE(H5FD_vfd_swmr_idx_entry_t, md_index->entries);
+        md_index->entries = H5FL_SEQ_FREE(H5FD_vfd_swmr_idx_entry_t, md_index->entries);
     }
 
     FUNC_LEAVE_NOAPI(ret_value)
 
 } /* H5FD__vfd_swmr_index_deserialize() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_get_tick_and_idx()
  *
@@ -1478,50 +1408,44 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5FD_vfd_swmr_get_tick_and_idx(H5FD_t *_file, hbool_t reload_hdr_and_index,
-    uint64_t *tick_ptr, uint32_t *num_entries_ptr,
-    H5FD_vfd_swmr_idx_entry_t index[])
+H5FD_vfd_swmr_get_tick_and_idx(H5FD_t *_file, hbool_t reload_hdr_and_index, uint64_t *tick_ptr,
+                               uint32_t *num_entries_ptr, H5FD_vfd_swmr_idx_entry_t index[])
 {
-    H5FD_vfd_swmr_t *file = (H5FD_vfd_swmr_t *)_file; /* VFD SWMR file struct */
-    herr_t ret_value = SUCCEED;                       /* Return value  */
+    H5FD_vfd_swmr_t *file      = (H5FD_vfd_swmr_t *)_file; /* VFD SWMR file struct */
+    herr_t           ret_value = SUCCEED;                  /* Return value  */
 
     HDassert(index == NULL || num_entries_ptr != NULL);
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Load and decode the header and index as indicated */
-    if (reload_hdr_and_index &&
-        H5FD__vfd_swmr_load_hdr_and_idx(file, FALSE) < 0) {
-            HGOTO_ERROR(H5E_VFL, H5E_CANTLOAD, FAIL,
-                "unable to load/decode md header and index")
+    if (reload_hdr_and_index && H5FD__vfd_swmr_load_hdr_and_idx(file, FALSE) < 0) {
+        HGOTO_ERROR(H5E_VFL, H5E_CANTLOAD, FAIL, "unable to load/decode md header and index")
     }
 
     /* Return tick_num */
-    if(tick_ptr != NULL)
+    if (tick_ptr != NULL)
         *tick_ptr = file->md_header.tick_num;
 
     if (index != NULL) {
 
         if (*num_entries_ptr < file->md_index.num_entries) {
-            HGOTO_ERROR(H5E_VFL, H5E_CANTLOAD, FAIL,
-                "not enough space to copy index");
+            HGOTO_ERROR(H5E_VFL, H5E_CANTLOAD, FAIL, "not enough space to copy index");
         }
 
         HDmemcpy(index, file->md_index.entries,
-                 (file->md_index.num_entries *
-                  sizeof(file->md_index.entries[0])));
+                 (file->md_index.num_entries * sizeof(file->md_index.entries[0])));
     }
 
-    if(num_entries_ptr != NULL)
+    if (num_entries_ptr != NULL)
         *num_entries_ptr = file->md_index.num_entries;
 
 done:
 
     FUNC_LEAVE_NOAPI(ret_value)
 
-}  /* H5FD_vfd_swmr_get_tick_and_idx() */
+} /* H5FD_vfd_swmr_get_tick_and_idx() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_dump_status
  *
@@ -1536,43 +1460,38 @@ done:
 void
 H5FD_vfd_swmr_dump_status(H5FD_t *_file, uint64_t page)
 {
-    hbool_t in_index = FALSE;
-    int i = 0;
-    uint32_t num_entries;
+    hbool_t                    in_index = FALSE;
+    int                        i        = 0;
+    uint32_t                   num_entries;
     H5FD_vfd_swmr_idx_entry_t *index;
-    H5FD_vfd_swmr_t *file = (H5FD_vfd_swmr_t *)_file; /* VFD SWMR file struct */
+    H5FD_vfd_swmr_t *          file = (H5FD_vfd_swmr_t *)_file; /* VFD SWMR file struct */
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     HDassert(file);
 
-    index        = file->md_index.entries;
-    num_entries  = file->md_index.num_entries;
+    index       = file->md_index.entries;
+    num_entries = file->md_index.num_entries;
 
-    while ( ( ! in_index ) && ( i < (int)num_entries ) ) {
+    while ((!in_index) && (i < (int)num_entries)) {
 
-        if ( index[i].hdf5_page_offset == page ) {
+        if (index[i].hdf5_page_offset == page) {
 
             in_index = TRUE;
         }
 
-        HDassert( ( i == 0 ) ||
-                  ( index[i-1].hdf5_page_offset < index[i].hdf5_page_offset ) );
+        HDassert((i == 0) || (index[i - 1].hdf5_page_offset < index[i].hdf5_page_offset));
 
         i++;
     }
 
-    HDfprintf(stderr,
-              "fd: tick = %" PRIu64 ", index_len = %" PRIu32 ", page %" PRIu64
-              " in index = %s.\n",
-              file->md_index.tick_num, num_entries, page,
-              in_index ? "true" : "false");
+    HDfprintf(stderr, "fd: tick = %" PRIu64 ", index_len = %" PRIu32 ", page %" PRIu64 " in index = %s.\n",
+              file->md_index.tick_num, num_entries, page, in_index ? "true" : "false");
 
     FUNC_LEAVE_NOAPI_VOID
 
-}  /* H5FD_vfd_swmr_dump_status() */
+} /* H5FD_vfd_swmr_dump_status() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_vfd_swmr_set_pb_configured
  *
@@ -1606,7 +1525,7 @@ H5FD_vfd_swmr_set_pb_configured(H5FD_t *_file)
 
     FUNC_LEAVE_NOAPI_VOID
 
-}  /* H5FD_vfd_swmr_set_pb_configured() */
+} /* H5FD_vfd_swmr_set_pb_configured() */
 
 /* In the histogram of ticks spent in API calls, increase the bucket
  * for `elapsed` ticks by one.