Formats the source and updates the gcc warning pragmas

1 files changed, 269 insertions, 418 deletions

diff --git a/src/H5FDmirror.c b/src/H5FDmirror.c
index 9f47806..91b5a12 100644
--- a/src/H5FDmirror.c
+++ b/src/H5FDmirror.c
@@ -17,18 +17,18 @@
 
 #include "H5FDdrvr_module.h" /* This source code file is part of the H5FD driver module */
 
-#include "H5private.h"      /* Generic Functions        */
+#include "H5private.h" /* Generic Functions        */
 
 #ifdef H5_HAVE_MIRROR_VFD
 
-#include "H5Eprivate.h"     /* Error handling           */
-#include "H5Fprivate.h"     /* File access              */
-#include "H5FDprivate.h"    /* File drivers             */
-#include "H5FDmirror.h"     /* "Mirror" definitions     */
-#include "H5FLprivate.h"    /* Free Lists               */
-#include "H5Iprivate.h"     /* IDs                      */
-#include "H5MMprivate.h"    /* Memory management        */
-#include "H5Pprivate.h"     /* Property lists           */
+#include "H5Eprivate.h"  /* Error handling           */
+#include "H5Fprivate.h"  /* File access              */
+#include "H5FDprivate.h" /* File drivers             */
+#include "H5FDmirror.h"  /* "Mirror" definitions     */
+#include "H5FLprivate.h" /* Free Lists               */
+#include "H5Iprivate.h"  /* IDs                      */
+#include "H5MMprivate.h" /* Memory management        */
+#include "H5Pprivate.h"  /* Property lists           */
 
 /* The driver identification number, initialized at runtime */
 static hid_t H5FD_MIRROR_g = 0;
@@ -59,152 +59,144 @@ typedef struct H5FD_mirror_t {
  *                  which can be addressed entirely by the second
  *                  argument of the file seek function.
  */
-#define MAXADDR (((haddr_t)1<<(8*sizeof(HDoff_t)-1))-1)
-#define ADDR_OVERFLOW(A)    (HADDR_UNDEF==(A) || ((A) & ~(haddr_t)MAXADDR))
+#define MAXADDR          (((haddr_t)1 << (8 * sizeof(HDoff_t) - 1)) - 1)
+#define ADDR_OVERFLOW(A) (HADDR_UNDEF == (A) || ((A) & ~(haddr_t)MAXADDR))
 
 #ifndef BSWAP_64
-#define BSWAP_64(X)                                \
-    (uint64_t)(  (((X) & 0x00000000000000FF) << 56) \
-               | (((X) & 0x000000000000FF00) << 40) \
-               | (((X) & 0x0000000000FF0000) << 24) \
-               | (((X) & 0x00000000FF000000) <<  8) \
-               | (((X) & 0x000000FF00000000) >>  8) \
-               | (((X) & 0x0000FF0000000000) >> 24) \
-               | (((X) & 0x00FF000000000000) >> 40) \
-               | (((X) & 0xFF00000000000000) >> 56))
+#define BSWAP_64(X)                                                                                          \
+    (uint64_t)((((X)&0x00000000000000FF) << 56) | (((X)&0x000000000000FF00) << 40) |                         \
+               (((X)&0x0000000000FF0000) << 24) | (((X)&0x00000000FF000000) << 8) |                          \
+               (((X)&0x000000FF00000000) >> 8) | (((X)&0x0000FF0000000000) >> 24) |                          \
+               (((X)&0x00FF000000000000) >> 40) | (((X)&0xFF00000000000000) >> 56))
 #endif /* BSWAP_64 */
 
 /* Debugging flabs for verbose tracing -- nonzero to enable */
-#define MIRROR_DEBUG_OP_CALLS 0
+#define MIRROR_DEBUG_OP_CALLS   0
 #define MIRROR_DEBUG_XMIT_BYTES 0
 
 #if MIRROR_DEBUG_XMIT_BYTES
-#define LOG_XMIT_BYTES(label, buf, len) do {                                  \
-    ssize_t bytes_written = 0;                                                \
-    const unsigned char *b = NULL;                                            \
-                                                                              \
-    HDfprintf(stdout, "%s bytes:\n```\n", (label));                           \
-                                                                              \
-    /* print whole lines */                                                   \
-    while ((len - bytes_written) >= 32) {                                     \
-        b = (const unsigned char *)(buf) + bytes_written;                     \
-        HDfprintf(stdout,                                                     \
-                "%04zX  %02X%02X%02X%02X %02X%02X%02X%02X"                    \
-                      " %02X%02X%02X%02X %02X%02X%02X%02X"                    \
-                      " %02X%02X%02X%02X %02X%02X%02X%02X"                    \
-                      " %02X%02X%02X%02X %02X%02X%02X%02X\n",                 \
-                bytes_written,                                                \
-                b[0], b[1], b[2], b[3],   b[4], b[5], b[6], b[7],             \
-                b[8], b[9], b[10],b[11],  b[12],b[13],b[14],b[15],            \
-                b[16],b[17],b[18],b[19],  b[20],b[21],b[22],b[23],            \
-                b[24],b[25],b[26],b[27],  b[28],b[29],b[30],b[31]);           \
-        bytes_written += 32;                                                  \
-    }                                                                         \
-                                                                              \
-    /* start partial line */                                                  \
-    if (len > bytes_written) {                                                \
-        HDfprintf(stdout, "%04zX ", bytes_written);                           \
-    }                                                                         \
-                                                                              \
-    /* partial line blocks */                                                 \
-    while ((len - bytes_written) >= 4) {                                      \
-        HDfprintf(stdout, " %02X%02X%02X%02X",                                \
-                (buf)[bytes_written],   (buf)[bytes_written+1],               \
-                (buf)[bytes_written+2], (buf)[bytes_written+3]);              \
-        bytes_written += 4;                                                   \
-    }                                                                         \
-                                                                              \
-    /* block separator before partial block */                                \
-    if (len > bytes_written) {                                                \
-        HDfprintf(stdout, " ");                                               \
-    }                                                                         \
-                                                                              \
-    /* partial block individual bytes */                                      \
-    while (len > bytes_written) {                                             \
-        HDfprintf(stdout, "%02X", (buf)[bytes_written++]);                    \
-    }                                                                         \
-                                                                              \
-    /* end partial line */                                                    \
-    HDfprintf(stdout, "\n");                                                  \
-    HDfprintf(stdout, "```\n");                                               \
-    HDfflush(stdout);                                                         \
-} while (0)
+#define LOG_XMIT_BYTES(label, buf, len)                                                                      \
+    do {                                                                                                     \
+        ssize_t              bytes_written = 0;                                                              \
+        const unsigned char *b             = NULL;                                                           \
+                                                                                                             \
+        HDfprintf(stdout, "%s bytes:\n```\n", (label));                                                      \
+                                                                                                             \
+        /* print whole lines */                                                                              \
+        while ((len - bytes_written) >= 32) {                                                                \
+            b = (const unsigned char *)(buf) + bytes_written;                                                \
+            HDfprintf(stdout,                                                                                \
+                      "%04zX  %02X%02X%02X%02X %02X%02X%02X%02X"                                             \
+                      " %02X%02X%02X%02X %02X%02X%02X%02X"                                                   \
+                      " %02X%02X%02X%02X %02X%02X%02X%02X"                                                   \
+                      " %02X%02X%02X%02X %02X%02X%02X%02X\n",                                                \
+                      bytes_written, b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8], b[9], b[10],      \
+                      b[11], b[12], b[13], b[14], b[15], b[16], b[17], b[18], b[19], b[20], b[21], b[22],    \
+                      b[23], b[24], b[25], b[26], b[27], b[28], b[29], b[30], b[31]);                        \
+            bytes_written += 32;                                                                             \
+        }                                                                                                    \
+                                                                                                             \
+        /* start partial line */                                                                             \
+        if (len > bytes_written) {                                                                           \
+            HDfprintf(stdout, "%04zX ", bytes_written);                                                      \
+        }                                                                                                    \
+                                                                                                             \
+        /* partial line blocks */                                                                            \
+        while ((len - bytes_written) >= 4) {                                                                 \
+            HDfprintf(stdout, " %02X%02X%02X%02X", (buf)[bytes_written], (buf)[bytes_written + 1],           \
+                      (buf)[bytes_written + 2], (buf)[bytes_written + 3]);                                   \
+            bytes_written += 4;                                                                              \
+        }                                                                                                    \
+                                                                                                             \
+        /* block separator before partial block */                                                           \
+        if (len > bytes_written) {                                                                           \
+            HDfprintf(stdout, " ");                                                                          \
+        }                                                                                                    \
+                                                                                                             \
+        /* partial block individual bytes */                                                                 \
+        while (len > bytes_written) {                                                                        \
+            HDfprintf(stdout, "%02X", (buf)[bytes_written++]);                                               \
+        }                                                                                                    \
+                                                                                                             \
+        /* end partial line */                                                                               \
+        HDfprintf(stdout, "\n");                                                                             \
+        HDfprintf(stdout, "```\n");                                                                          \
+        HDfflush(stdout);                                                                                    \
+    } while (0)
 #else
 #define LOG_XMIT_BYTES(label, buf, len) /* no-op */
-#endif /* MIRROR_DEBUG_XMIT_BYTE */
+#endif                                  /* MIRROR_DEBUG_XMIT_BYTE */
 
 #if MIRROR_DEBUG_OP_CALLS
-#define LOG_OP_CALL(name) do {         \
-    HDprintf("called %s()\n", (name)); \
-    fflush(stdout);                    \
-} while (0)
+#define LOG_OP_CALL(name)                                                                                    \
+    do {                                                                                                     \
+        HDprintf("called %s()\n", (name));                                                                   \
+        fflush(stdout);                                                                                      \
+    } while (0)
 #else
 #define LOG_OP_CALL(name) /* no-op */
-#endif /* MIRROR_DEBUG_OP_CALLS */
+#endif                    /* MIRROR_DEBUG_OP_CALLS */
 
 /* Prototypes */
-static herr_t H5FD_mirror_term(void);
-static void *H5FD_mirror_fapl_get(H5FD_t *_file);
-static void *H5FD_mirror_fapl_copy(const void *_old_fa);
-static herr_t H5FD_mirror_fapl_free(void *_fa);
+static herr_t  H5FD_mirror_term(void);
+static void *  H5FD_mirror_fapl_get(H5FD_t *_file);
+static void *  H5FD_mirror_fapl_copy(const void *_old_fa);
+static herr_t  H5FD_mirror_fapl_free(void *_fa);
 static haddr_t H5FD_mirror_get_eoa(const H5FD_t *_file, H5FD_mem_t type);
-static herr_t H5FD_mirror_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr);
+static herr_t  H5FD_mirror_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr);
 static haddr_t H5FD_mirror_get_eof(const H5FD_t *_file, H5FD_mem_t type);
-static H5FD_t *H5FD_mirror_open(const char *name, unsigned flags, \
-        hid_t fapl_id, haddr_t maxaddr);
-static herr_t H5FD_mirror_close(H5FD_t *_file);
-static herr_t H5FD_mirror_query(const H5FD_t *_file, unsigned long *flags);
-static herr_t H5FD_mirror_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_mirror_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id,
-        haddr_t addr, size_t size, void *buf);
-static herr_t H5FD_mirror_truncate(H5FD_t *_file, hid_t dxpl_id, \
-        hbool_t closing);
-static herr_t H5FD_mirror_lock(H5FD_t *_file, hbool_t rw);
-static herr_t H5FD_mirror_unlock(H5FD_t *_file);
+static H5FD_t *H5FD_mirror_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr);
+static herr_t  H5FD_mirror_close(H5FD_t *_file);
+static herr_t  H5FD_mirror_query(const H5FD_t *_file, unsigned long *flags);
+static herr_t  H5FD_mirror_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_mirror_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size,
+                                void *buf);
+static herr_t  H5FD_mirror_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
+static herr_t  H5FD_mirror_lock(H5FD_t *_file, hbool_t rw);
+static herr_t  H5FD_mirror_unlock(H5FD_t *_file);
 
 static herr_t H5FD__mirror_verify_reply(H5FD_mirror_t *file);
 
 static const H5FD_class_t H5FD_mirror_g = {
-    "mirror",                   /* name                 */
-    MAXADDR,                    /* maxaddr              */
-    H5F_CLOSE_WEAK,             /* fc_degree            */
-    H5FD_mirror_term,           /* terminate            */
-    NULL,                       /* sb_size              */
-    NULL,                       /* sb_encode            */
-    NULL,                       /* sb_decode            */
-    0,                          /* fapl_size            */
-    H5FD_mirror_fapl_get,       /* fapl_get             */
-    H5FD_mirror_fapl_copy,      /* fapl_copy            */
-    H5FD_mirror_fapl_free,      /* fapl_free            */
-    0,                          /* dxpl_size            */
-    NULL,                       /* dxpl_copy            */
-    NULL,                       /* dxpl_free            */
-    H5FD_mirror_open,           /* open                 */
-    H5FD_mirror_close,          /* close                */
-    NULL,                       /* cmp                  */
-    H5FD_mirror_query,          /* query                */
-    NULL,                       /* get_type_map         */
-    NULL,                       /* alloc                */
-    NULL,                       /* free                 */
-    H5FD_mirror_get_eoa,        /* get_eoa              */
-    H5FD_mirror_set_eoa,        /* set_eoa              */
-    H5FD_mirror_get_eof,        /* get_eof              */
-    NULL,                       /* get_handle           */
-    H5FD_mirror_read,           /* read                 */
-    H5FD_mirror_write,          /* write                */
-    NULL,                       /* flush                */
-    H5FD_mirror_truncate,       /* truncate             */
-    H5FD_mirror_lock,           /* lock                 */
-    H5FD_mirror_unlock,         /* unlock               */
-    NULL,                       /* dedup                */
-    H5FD_FLMAP_DICHOTOMY        /* fl_map               */
+    "mirror",              /* name                 */
+    MAXADDR,               /* maxaddr              */
+    H5F_CLOSE_WEAK,        /* fc_degree            */
+    H5FD_mirror_term,      /* terminate            */
+    NULL,                  /* sb_size              */
+    NULL,                  /* sb_encode            */
+    NULL,                  /* sb_decode            */
+    0,                     /* fapl_size            */
+    H5FD_mirror_fapl_get,  /* fapl_get             */
+    H5FD_mirror_fapl_copy, /* fapl_copy            */
+    H5FD_mirror_fapl_free, /* fapl_free            */
+    0,                     /* dxpl_size            */
+    NULL,                  /* dxpl_copy            */
+    NULL,                  /* dxpl_free            */
+    H5FD_mirror_open,      /* open                 */
+    H5FD_mirror_close,     /* close                */
+    NULL,                  /* cmp                  */
+    H5FD_mirror_query,     /* query                */
+    NULL,                  /* get_type_map         */
+    NULL,                  /* alloc                */
+    NULL,                  /* free                 */
+    H5FD_mirror_get_eoa,   /* get_eoa              */
+    H5FD_mirror_set_eoa,   /* set_eoa              */
+    H5FD_mirror_get_eof,   /* get_eof              */
+    NULL,                  /* get_handle           */
+    H5FD_mirror_read,      /* read                 */
+    H5FD_mirror_write,     /* write                */
+    NULL,                  /* flush                */
+    H5FD_mirror_truncate,  /* truncate             */
+    H5FD_mirror_lock,      /* lock                 */
+    H5FD_mirror_unlock,    /* unlock               */
+    NULL,                  /* dedup                */
+    H5FD_FLMAP_DICHOTOMY   /* fl_map               */
 };
 
 /* Declare a free list to manage the H5FD_mirror_t struct */
 H5FL_DEFINE_STATIC(H5FD_mirror_t);
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD__init_package
  *
@@ -223,15 +215,13 @@ H5FD__init_package(void)
     LOG_OP_CALL("H5FD__init_package");
 
     if (H5FD_mirror_init() < 0) {
-        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL,
-                    "unable to initialize mirror VFD");
+        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "unable to initialize mirror VFD");
     }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD__init_package() */
 
-
 /* -------------------------------------------------------------------------
  * Function:    H5FD_mirror_init
  *
@@ -252,8 +242,7 @@ H5FD_mirror_init(void)
     LOG_OP_CALL("H5FD_mirror_init");
 
     if (H5I_VFL != H5I_get_type(H5FD_MIRROR_g)) {
-        H5FD_MIRROR_g = H5FD_register(&H5FD_mirror_g, sizeof(H5FD_class_t),
-                FALSE);
+        H5FD_MIRROR_g = H5FD_register(&H5FD_mirror_g, sizeof(H5FD_class_t), FALSE);
     }
 
     ret_value = H5FD_MIRROR_g;
@@ -262,7 +251,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_mirror_init() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_term
  *
@@ -284,7 +272,6 @@ H5FD_mirror_term(void)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5FD_mirror_term() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD__mirror_xmit_decode_uint16
  *
@@ -309,7 +296,6 @@ H5FD__mirror_xmit_decode_uint16(uint16_t *out, const unsigned char *_buf)
     return 2; /* number of bytes eaten */
 } /* end H5FD__mirror_xmit_decode_uint16() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD__mirror_xmit_decode_uint32
  *
@@ -334,8 +320,6 @@ H5FD__mirror_xmit_decode_uint32(uint32_t *out, const unsigned char *_buf)
     return 4; /* number of bytes eaten */
 } /* end H5FD__mirror_xmit_decode_uint32() */
 
-
-
 /* ---------------------------------------------------------------------------
  * Function:    is_host_little_endian
  *
@@ -366,7 +350,6 @@ is_host_little_endian(void)
     }
 } /* end is_host_little_endian() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD__mirror_xmit_decode_uint64
  *
@@ -398,7 +381,6 @@ H5FD__mirror_xmit_decode_uint64(uint64_t *out, const unsigned char *_buf)
     return 8;
 } /* end H5FD__mirror_xmit_decode_uint64() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD__mirror_xmit_decode_uint8
  *
@@ -419,7 +401,6 @@ H5FD__mirror_xmit_decode_uint8(uint8_t *out, const unsigned char *_buf)
     return 1; /* number of bytes eaten */
 } /* end H5FD__mirror_xmit_decode_uint8() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD__mirror_xmit_encode_uint16
  *
@@ -443,7 +424,6 @@ H5FD__mirror_xmit_encode_uint16(unsigned char *_dest, uint16_t v)
     return 2;
 } /* end H5FD__mirror_xmit_encode_uint16() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD__mirror_xmit_encode_uint32
  *
@@ -467,7 +447,6 @@ H5FD__mirror_xmit_encode_uint32(unsigned char *_dest, uint32_t v)
     return 4;
 } /* end H5FD__mirror_xmit_encode_uint32() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD__mirror_xmit_encode_uint64
  *
@@ -493,7 +472,6 @@ H5FD__mirror_xmit_encode_uint64(unsigned char *_dest, uint64_t v)
     return 8;
 } /* H5FD__mirror_xmit_encode_uint64() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD__mirror_xmit_encode_uint8
  *
@@ -516,7 +494,6 @@ H5FD__mirror_xmit_encode_uint8(unsigned char *dest, uint8_t v)
     return 1;
 } /* end H5FD__mirror_xmit_encode_uint8() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_decode_header
  *
@@ -537,24 +514,20 @@ H5FD__mirror_xmit_encode_uint8(unsigned char *dest, uint8_t v)
  * ---------------------------------------------------------------------------
  */
 size_t
-H5FD_mirror_xmit_decode_header(H5FD_mirror_xmit_t  *out,
-                               const unsigned char *buf)
+H5FD_mirror_xmit_decode_header(H5FD_mirror_xmit_t *out, const unsigned char *buf)
 {
     size_t n_eaten = 0;
     LOG_OP_CALL("H5FD_mirror_xmit_decode_header");
     HDassert(out && buf);
     n_eaten += H5FD__mirror_xmit_decode_uint32(&(out->magic), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint8(&(out->version), &buf[n_eaten]);
-    n_eaten += H5FD__mirror_xmit_decode_uint32(&(out->session_token),
-            &buf[n_eaten]);
-    n_eaten += H5FD__mirror_xmit_decode_uint32(&(out->xmit_count),
-            &buf[n_eaten]);
+    n_eaten += H5FD__mirror_xmit_decode_uint32(&(out->session_token), &buf[n_eaten]);
+    n_eaten += H5FD__mirror_xmit_decode_uint32(&(out->xmit_count), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint8(&(out->op), &buf[n_eaten]);
     HDassert(n_eaten == H5FD_MIRROR_XMIT_HEADER_SIZE);
     return n_eaten;
 } /* end H5FD_mirror_xmit_decode_header() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_decode_lock
  *
@@ -575,8 +548,7 @@ H5FD_mirror_xmit_decode_header(H5FD_mirror_xmit_t  *out,
  * ---------------------------------------------------------------------------
  */
 size_t
-H5FD_mirror_xmit_decode_lock(H5FD_mirror_xmit_lock_t *out,
-                             const unsigned char     *buf)
+H5FD_mirror_xmit_decode_lock(H5FD_mirror_xmit_lock_t *out, const unsigned char *buf)
 {
     size_t n_eaten = 0;
     LOG_OP_CALL("H5FD_mirror_xmit_decode_lock");
@@ -587,7 +559,6 @@ H5FD_mirror_xmit_decode_lock(H5FD_mirror_xmit_lock_t *out,
     return n_eaten;
 } /* end H5FD_mirror_xmit_decode_lock() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_decode_open
  *
@@ -609,8 +580,7 @@ H5FD_mirror_xmit_decode_lock(H5FD_mirror_xmit_lock_t *out,
  * ---------------------------------------------------------------------------
  */
 size_t
-H5FD_mirror_xmit_decode_open(H5FD_mirror_xmit_open_t *out,
-                             const unsigned char     *buf)
+H5FD_mirror_xmit_decode_open(H5FD_mirror_xmit_open_t *out, const unsigned char *buf)
 {
     size_t n_eaten = 0;
     LOG_OP_CALL("H5FD_mirror_xmit_decode_open");
@@ -618,17 +588,13 @@ H5FD_mirror_xmit_decode_open(H5FD_mirror_xmit_open_t *out,
     n_eaten += H5FD_mirror_xmit_decode_header(&(out->pub), buf);
     n_eaten += H5FD__mirror_xmit_decode_uint32(&(out->flags), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->maxaddr), &buf[n_eaten]);
-    n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->size_t_blob),
-            &buf[n_eaten]);
-    HDassert((H5FD_MIRROR_XMIT_OPEN_SIZE - H5FD_MIRROR_XMIT_FILEPATH_MAX)
-             == n_eaten);
-    HDstrncpy(out->filename, (const char *)&buf[n_eaten],
-            H5FD_MIRROR_XMIT_FILEPATH_MAX-1);
-    out->filename[H5FD_MIRROR_XMIT_FILEPATH_MAX-1] = 0; /* force final NULL */
+    n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->size_t_blob), &buf[n_eaten]);
+    HDassert((H5FD_MIRROR_XMIT_OPEN_SIZE - H5FD_MIRROR_XMIT_FILEPATH_MAX) == n_eaten);
+    HDstrncpy(out->filename, (const char *)&buf[n_eaten], H5FD_MIRROR_XMIT_FILEPATH_MAX - 1);
+    out->filename[H5FD_MIRROR_XMIT_FILEPATH_MAX - 1] = 0; /* force final NULL */
     return H5FD_MIRROR_XMIT_OPEN_SIZE;
 } /* end H5FD_mirror_xmit_decode_open() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_decode_reply
  *
@@ -650,23 +616,19 @@ H5FD_mirror_xmit_decode_open(H5FD_mirror_xmit_open_t *out,
  * ---------------------------------------------------------------------------
  */
 size_t
-H5FD_mirror_xmit_decode_reply(H5FD_mirror_xmit_reply_t *out,
-                              const unsigned char      *buf)
+H5FD_mirror_xmit_decode_reply(H5FD_mirror_xmit_reply_t *out, const unsigned char *buf)
 {
     size_t n_eaten = 0;
     LOG_OP_CALL("H5FD_mirror_xmit_decode_reply");
     HDassert(out && buf);
     n_eaten += H5FD_mirror_xmit_decode_header(&(out->pub), buf);
     n_eaten += H5FD__mirror_xmit_decode_uint32(&(out->status), &buf[n_eaten]);
-    HDassert((H5FD_MIRROR_XMIT_REPLY_SIZE - H5FD_MIRROR_STATUS_MESSAGE_MAX)
-             == n_eaten);
-    HDstrncpy(out->message, (const char *)&buf[n_eaten],
-            H5FD_MIRROR_STATUS_MESSAGE_MAX-1);
-    out->message[H5FD_MIRROR_STATUS_MESSAGE_MAX-1] = 0; /* force NULL term */
+    HDassert((H5FD_MIRROR_XMIT_REPLY_SIZE - H5FD_MIRROR_STATUS_MESSAGE_MAX) == n_eaten);
+    HDstrncpy(out->message, (const char *)&buf[n_eaten], H5FD_MIRROR_STATUS_MESSAGE_MAX - 1);
+    out->message[H5FD_MIRROR_STATUS_MESSAGE_MAX - 1] = 0; /* force NULL term */
     return H5FD_MIRROR_XMIT_REPLY_SIZE;
 } /* end H5FD_mirror_xmit_decode_reply() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_decode_set_eoa
  *
@@ -687,8 +649,7 @@ H5FD_mirror_xmit_decode_reply(H5FD_mirror_xmit_reply_t *out,
  * ---------------------------------------------------------------------------
  */
 size_t
-H5FD_mirror_xmit_decode_set_eoa(H5FD_mirror_xmit_eoa_t *out,
-                                const unsigned char    *buf)
+H5FD_mirror_xmit_decode_set_eoa(H5FD_mirror_xmit_eoa_t *out, const unsigned char *buf)
 {
     size_t n_eaten = 0;
     LOG_OP_CALL("H5FD_mirror_xmit_decode_set_eoa");
@@ -700,7 +661,6 @@ H5FD_mirror_xmit_decode_set_eoa(H5FD_mirror_xmit_eoa_t *out,
     return n_eaten;
 } /* end H5FD_mirror_xmit_decode_set_eoa() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_decode_write
  *
@@ -721,8 +681,7 @@ H5FD_mirror_xmit_decode_set_eoa(H5FD_mirror_xmit_eoa_t *out,
  * ---------------------------------------------------------------------------
  */
 size_t
-H5FD_mirror_xmit_decode_write(H5FD_mirror_xmit_write_t *out,
-                              const unsigned char      *buf)
+H5FD_mirror_xmit_decode_write(H5FD_mirror_xmit_write_t *out, const unsigned char *buf)
 {
     size_t n_eaten = 0;
     LOG_OP_CALL("H5FD_mirror_xmit_decode_write");
@@ -735,7 +694,6 @@ H5FD_mirror_xmit_decode_write(H5FD_mirror_xmit_write_t *out,
     return n_eaten;
 } /* end H5FD_mirror_xmit_decode_write() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_encode_header
  *
@@ -751,22 +709,20 @@ H5FD_mirror_xmit_decode_write(H5FD_mirror_xmit_write_t *out,
  * ---------------------------------------------------------------------------
  */
 size_t
-H5FD_mirror_xmit_encode_header(unsigned char            *dest,
-                               const H5FD_mirror_xmit_t *x)
+H5FD_mirror_xmit_encode_header(unsigned char *dest, const H5FD_mirror_xmit_t *x)
 {
     size_t n_writ = 0;
     LOG_OP_CALL("H5FD_mirror_xmit_encode_header");
     HDassert(dest && x);
-    n_writ += H5FD__mirror_xmit_encode_uint32((dest+n_writ), x->magic);
-    n_writ += H5FD__mirror_xmit_encode_uint8((dest+n_writ), x->version);
-    n_writ += H5FD__mirror_xmit_encode_uint32((dest+n_writ), x->session_token);
-    n_writ += H5FD__mirror_xmit_encode_uint32((dest+n_writ), x->xmit_count);
-    n_writ += H5FD__mirror_xmit_encode_uint8((dest+n_writ), x->op);
+    n_writ += H5FD__mirror_xmit_encode_uint32((dest + n_writ), x->magic);
+    n_writ += H5FD__mirror_xmit_encode_uint8((dest + n_writ), x->version);
+    n_writ += H5FD__mirror_xmit_encode_uint32((dest + n_writ), x->session_token);
+    n_writ += H5FD__mirror_xmit_encode_uint32((dest + n_writ), x->xmit_count);
+    n_writ += H5FD__mirror_xmit_encode_uint8((dest + n_writ), x->op);
     HDassert(n_writ == H5FD_MIRROR_XMIT_HEADER_SIZE);
     return n_writ;
 } /* end H5FD_mirror_xmit_encode_header() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_encode_lock
  *
@@ -781,20 +737,17 @@ H5FD_mirror_xmit_encode_header(unsigned char            *dest,
  * ---------------------------------------------------------------------------
  */
 size_t
-H5FD_mirror_xmit_encode_lock(unsigned char *dest,
-                             const H5FD_mirror_xmit_lock_t *x)
+H5FD_mirror_xmit_encode_lock(unsigned char *dest, const H5FD_mirror_xmit_lock_t *x)
 {
     size_t n_writ = 0;
     LOG_OP_CALL("H5FD_mirror_xmit_encode_lock");
     HDassert(dest && x);
-    n_writ += H5FD_mirror_xmit_encode_header(dest,
-            (const H5FD_mirror_xmit_t *)&(x->pub));
+    n_writ += H5FD_mirror_xmit_encode_header(dest, (const H5FD_mirror_xmit_t *)&(x->pub));
     n_writ += H5FD__mirror_xmit_encode_uint64(&dest[n_writ], x->rw);
     HDassert(n_writ == H5FD_MIRROR_XMIT_LOCK_SIZE);
     return n_writ;
 } /* end H5FD_mirror_xmit_encode_lock() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_encode_open
  *
@@ -810,30 +763,25 @@ H5FD_mirror_xmit_encode_lock(unsigned char *dest,
  * ---------------------------------------------------------------------------
  */
 size_t
-H5FD_mirror_xmit_encode_open(unsigned char                 *dest,
-                             const H5FD_mirror_xmit_open_t *x)
+H5FD_mirror_xmit_encode_open(unsigned char *dest, const H5FD_mirror_xmit_open_t *x)
 {
     size_t n_writ = 0;
     LOG_OP_CALL("H5FD_mirror_xmit_encode_open");
     HDassert(dest && x);
     /* clear entire structure, but especially its filepath string area */
     for (n_writ = 0; n_writ < H5FD_MIRROR_XMIT_OPEN_SIZE; n_writ++) {
-        *(dest+n_writ) = 0;
+        *(dest + n_writ) = 0;
     }
     n_writ = 0;
-    n_writ += H5FD_mirror_xmit_encode_header(dest,
-            (const H5FD_mirror_xmit_t *)&(x->pub));
+    n_writ += H5FD_mirror_xmit_encode_header(dest, (const H5FD_mirror_xmit_t *)&(x->pub));
     n_writ += H5FD__mirror_xmit_encode_uint32(&dest[n_writ], x->flags);
     n_writ += H5FD__mirror_xmit_encode_uint64(&dest[n_writ], x->maxaddr);
     n_writ += H5FD__mirror_xmit_encode_uint64(&dest[n_writ], x->size_t_blob);
-    HDassert((H5FD_MIRROR_XMIT_OPEN_SIZE - H5FD_MIRROR_XMIT_FILEPATH_MAX)
-             == n_writ);
-    HDstrncpy((char *)&dest[n_writ], x->filename,
-            H5FD_MIRROR_XMIT_FILEPATH_MAX);
+    HDassert((H5FD_MIRROR_XMIT_OPEN_SIZE - H5FD_MIRROR_XMIT_FILEPATH_MAX) == n_writ);
+    HDstrncpy((char *)&dest[n_writ], x->filename, H5FD_MIRROR_XMIT_FILEPATH_MAX);
     return H5FD_MIRROR_XMIT_OPEN_SIZE;
 } /* end H5FD_mirror_xmit_encode_open() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_encode_reply
  *
@@ -850,28 +798,23 @@ H5FD_mirror_xmit_encode_open(unsigned char                 *dest,
  * ---------------------------------------------------------------------------
  */
 size_t
-H5FD_mirror_xmit_encode_reply(unsigned char                  *dest,
-                              const H5FD_mirror_xmit_reply_t *x)
+H5FD_mirror_xmit_encode_reply(unsigned char *dest, const H5FD_mirror_xmit_reply_t *x)
 {
     size_t n_writ = 0;
     LOG_OP_CALL("H5FD_mirror_xmit_encode_reply");
     HDassert(dest && x);
     /* clear entire structure, but especially its message string area */
     for (n_writ = 0; n_writ < H5FD_MIRROR_XMIT_REPLY_SIZE; n_writ++) {
-        *(dest+n_writ) = 0;
+        *(dest + n_writ) = 0;
     }
     n_writ = 0;
-    n_writ += H5FD_mirror_xmit_encode_header(dest,
-            (const H5FD_mirror_xmit_t *)&(x->pub));
+    n_writ += H5FD_mirror_xmit_encode_header(dest, (const H5FD_mirror_xmit_t *)&(x->pub));
     n_writ += H5FD__mirror_xmit_encode_uint32(&dest[n_writ], x->status);
-    HDassert((H5FD_MIRROR_XMIT_REPLY_SIZE - H5FD_MIRROR_STATUS_MESSAGE_MAX)
-             == n_writ);
-    HDstrncpy((char *)&dest[n_writ], x->message,
-            H5FD_MIRROR_STATUS_MESSAGE_MAX);
+    HDassert((H5FD_MIRROR_XMIT_REPLY_SIZE - H5FD_MIRROR_STATUS_MESSAGE_MAX) == n_writ);
+    HDstrncpy((char *)&dest[n_writ], x->message, H5FD_MIRROR_STATUS_MESSAGE_MAX);
     return H5FD_MIRROR_XMIT_REPLY_SIZE;
 } /* end H5FD_mirror_xmit_encode_reply() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_encode_set_eoa
  *
@@ -887,21 +830,18 @@ H5FD_mirror_xmit_encode_reply(unsigned char                  *dest,
  * ---------------------------------------------------------------------------
  */
 size_t
-H5FD_mirror_xmit_encode_set_eoa(unsigned char                *dest,
-                                const H5FD_mirror_xmit_eoa_t *x)
+H5FD_mirror_xmit_encode_set_eoa(unsigned char *dest, const H5FD_mirror_xmit_eoa_t *x)
 {
     size_t n_writ = 0;
     LOG_OP_CALL("H5FD_mirror_xmit_encode_set_eoa");
     HDassert(dest && x);
-    n_writ += H5FD_mirror_xmit_encode_header(dest,
-            (const H5FD_mirror_xmit_t *)&(x->pub));
+    n_writ += H5FD_mirror_xmit_encode_header(dest, (const H5FD_mirror_xmit_t *)&(x->pub));
     n_writ += H5FD__mirror_xmit_encode_uint8(&dest[n_writ], x->type);
     n_writ += H5FD__mirror_xmit_encode_uint64(&dest[n_writ], x->eoa_addr);
     HDassert(n_writ == H5FD_MIRROR_XMIT_EOA_SIZE);
     return n_writ;
 } /* end H5FD_mirror_xmit_encode_set_eoa() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_encode_write
  *
@@ -917,14 +857,12 @@ H5FD_mirror_xmit_encode_set_eoa(unsigned char                *dest,
  * ---------------------------------------------------------------------------
  */
 size_t
-H5FD_mirror_xmit_encode_write(unsigned char                  *dest,
-                              const H5FD_mirror_xmit_write_t *x)
+H5FD_mirror_xmit_encode_write(unsigned char *dest, const H5FD_mirror_xmit_write_t *x)
 {
     size_t n_writ = 0;
     LOG_OP_CALL("H5FD_mirror_xmit_encode_write");
     HDassert(dest && x);
-    n_writ += H5FD_mirror_xmit_encode_header(dest,
-            (const H5FD_mirror_xmit_t *)&(x->pub));
+    n_writ += H5FD_mirror_xmit_encode_header(dest, (const H5FD_mirror_xmit_t *)&(x->pub));
     n_writ += H5FD__mirror_xmit_encode_uint8(&dest[n_writ], x->type);
     n_writ += H5FD__mirror_xmit_encode_uint64(&dest[n_writ], x->offset);
     n_writ += H5FD__mirror_xmit_encode_uint64(&dest[n_writ], x->size);
@@ -932,7 +870,6 @@ H5FD_mirror_xmit_encode_write(unsigned char                  *dest,
     return n_writ;
 } /* end H5FD_mirror_xmit_encode_write() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_is_close
  *
@@ -948,15 +885,12 @@ H5FD_mirror_xmit_is_close(const H5FD_mirror_xmit_t *xmit)
 {
     LOG_OP_CALL("H5FD_mirror_xmit_is_close");
     HDassert(xmit);
-    if ( (TRUE == H5FD_mirror_xmit_is_xmit(xmit)) &&
-         (H5FD_MIRROR_OP_CLOSE == xmit->op) )
-    {
+    if ((TRUE == H5FD_mirror_xmit_is_xmit(xmit)) && (H5FD_MIRROR_OP_CLOSE == xmit->op)) {
         return TRUE;
     }
     return FALSE;
 } /* end H5FD_mirror_xmit_is_close() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_is_lock
  *
@@ -972,15 +906,12 @@ H5FD_mirror_xmit_is_lock(const H5FD_mirror_xmit_lock_t *xmit)
 {
     LOG_OP_CALL("H5FD_mirror_xmit_is_lock");
     HDassert(xmit);
-    if ( (TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) &&
-         (H5FD_MIRROR_OP_LOCK == xmit->pub.op) )
-    {
+    if ((TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) && (H5FD_MIRROR_OP_LOCK == xmit->pub.op)) {
         return TRUE;
     }
     return FALSE;
 } /* end H5FD_mirror_xmit_is_lock() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_is_open
  *
@@ -996,15 +927,12 @@ H5FD_mirror_xmit_is_open(const H5FD_mirror_xmit_open_t *xmit)
 {
     LOG_OP_CALL("H5FD_mirror_xmit_is_open");
     HDassert(xmit);
-    if ( (TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) &&
-         (H5FD_MIRROR_OP_OPEN == xmit->pub.op) )
-    {
+    if ((TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) && (H5FD_MIRROR_OP_OPEN == xmit->pub.op)) {
         return TRUE;
     }
     return FALSE;
 } /* end H5FD_mirror_xmit_is_open() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_is_eoa
  *
@@ -1020,15 +948,12 @@ H5FD_mirror_xmit_is_set_eoa(const H5FD_mirror_xmit_eoa_t *xmit)
 {
     LOG_OP_CALL("H5FD_mirror_xmit_is_set_eoa");
     HDassert(xmit);
-    if ( (TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) &&
-         (H5FD_MIRROR_OP_SET_EOA == xmit->pub.op) )
-    {
+    if ((TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) && (H5FD_MIRROR_OP_SET_EOA == xmit->pub.op)) {
         return TRUE;
     }
     return FALSE;
 } /* end H5FD_mirror_xmit_is_eoa() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_is_reply
  *
@@ -1044,15 +969,12 @@ H5FD_mirror_xmit_is_reply(const H5FD_mirror_xmit_reply_t *xmit)
 {
     LOG_OP_CALL("H5FD_mirror_xmit_is_reply");
     HDassert(xmit);
-    if ( (TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) &&
-         (H5FD_MIRROR_OP_REPLY == xmit->pub.op) )
-    {
+    if ((TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) && (H5FD_MIRROR_OP_REPLY == xmit->pub.op)) {
         return TRUE;
     }
     return FALSE;
 } /* end H5FD_mirror_xmit_is_reply() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_is_write
  *
@@ -1068,15 +990,12 @@ H5FD_mirror_xmit_is_write(const H5FD_mirror_xmit_write_t *xmit)
 {
     LOG_OP_CALL("H5FD_mirror_xmit_is_write");
     HDassert(xmit);
-    if ( (TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) &&
-         (H5FD_MIRROR_OP_WRITE == xmit->pub.op) )
-    {
+    if ((TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) && (H5FD_MIRROR_OP_WRITE == xmit->pub.op)) {
         return TRUE;
     }
     return FALSE;
 } /* end H5FD_mirror_xmit_is_write() */
 
-
 /* ---------------------------------------------------------------------------
  * Function:    H5FD_mirror_xmit_is_xmit
  *
@@ -1092,15 +1011,12 @@ H5FD_mirror_xmit_is_xmit(const H5FD_mirror_xmit_t *xmit)
 {
     LOG_OP_CALL("H5FD_mirror_xmit_is_xmit");
     HDassert(xmit);
-    if ( (H5FD_MIRROR_XMIT_MAGIC != xmit->magic) ||
-         (H5FD_MIRROR_XMIT_CURR_VERSION != xmit->version) )
-    {
+    if ((H5FD_MIRROR_XMIT_MAGIC != xmit->magic) || (H5FD_MIRROR_XMIT_CURR_VERSION != xmit->version)) {
         return FALSE;
     }
     return TRUE;
 } /* end H5FD_mirror_xmit_is_xmit() */
 
-
 /* ----------------------------------------------------------------------------
  * Function:    H5FD__mirror_verify_reply
  *
@@ -1115,10 +1031,10 @@ H5FD_mirror_xmit_is_xmit(const H5FD_mirror_xmit_t *xmit)
 herr_t
 H5FD__mirror_verify_reply(H5FD_mirror_t *file)
 {
-    char                                xmit_buf[H5FD_MIRROR_XMIT_REPLY_SIZE];
-    struct H5FD_mirror_xmit_reply_t     reply;
-    ssize_t                             read_ret = 0;
-    herr_t                              ret_value = SUCCEED;
+    char                            xmit_buf[H5FD_MIRROR_XMIT_REPLY_SIZE];
+    struct H5FD_mirror_xmit_reply_t reply;
+    ssize_t                         read_ret  = 0;
+    herr_t                          ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT;
 
@@ -1136,9 +1052,8 @@ H5FD__mirror_verify_reply(H5FD_mirror_t *file)
 
     LOG_XMIT_BYTES("reply", xmit_buf, read_ret);
 
-    if (H5FD_mirror_xmit_decode_reply(&reply, (const unsigned char *)xmit_buf)
-        != H5FD_MIRROR_XMIT_REPLY_SIZE)
-    {
+    if (H5FD_mirror_xmit_decode_reply(&reply, (const unsigned char *)xmit_buf) !=
+        H5FD_MIRROR_XMIT_REPLY_SIZE) {
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "unable to decode reply xmit");
     }
 
@@ -1155,15 +1070,13 @@ H5FD__mirror_verify_reply(H5FD_mirror_t *file)
     }
 
     if (reply.status != H5FD_MIRROR_STATUS_OK) {
-        HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL,
-                    "%s", (const char *)(reply.message));
+        HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "%s", (const char *)(reply.message));
     }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
 } /* end H5FD__mirror_verify_reply() */
 
-
 /* -------------------------------------------------------------------------
  * Function:    H5FD_mirror_fapl_get
  *
@@ -1177,9 +1090,9 @@ done:
 static void *
 H5FD_mirror_fapl_get(H5FD_t *_file)
 {
-    H5FD_mirror_t      *file      = (H5FD_mirror_t *)_file;
+    H5FD_mirror_t *     file      = (H5FD_mirror_t *)_file;
     H5FD_mirror_fapl_t *fa        = NULL;
-    void               *ret_value = NULL;
+    void *              ret_value = NULL;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -1203,7 +1116,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_mirror_fapl_get() */
 
-
 /* -------------------------------------------------------------------------
  * Function:    H5FD_mirror_fapl_copy
  *
@@ -1217,8 +1129,8 @@ static void *
 H5FD_mirror_fapl_copy(const void *_old_fa)
 {
     const H5FD_mirror_fapl_t *old_fa    = (const H5FD_mirror_fapl_t *)_old_fa;
-    H5FD_mirror_fapl_t       *new_fa    = NULL;
-    void                     *ret_value = NULL;
+    H5FD_mirror_fapl_t *      new_fa    = NULL;
+    void *                    ret_value = NULL;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -1226,8 +1138,7 @@ H5FD_mirror_fapl_copy(const void *_old_fa)
 
     new_fa = (H5FD_mirror_fapl_t *)H5MM_malloc(sizeof(H5FD_mirror_fapl_t));
     if (new_fa == NULL) {
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
-                    "memory allocation failed");
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
     }
 
     HDmemcpy(new_fa, old_fa, sizeof(H5FD_mirror_fapl_t));
@@ -1242,7 +1153,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_mirror_fapl_copy() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_mirror_fapl_free
  *
@@ -1254,7 +1164,7 @@ done:
 static herr_t
 H5FD_mirror_fapl_free(void *_fa)
 {
-    H5FD_mirror_fapl_t *fa = (H5FD_mirror_fapl_t*)_fa;
+    H5FD_mirror_fapl_t *fa = (H5FD_mirror_fapl_t *)_fa;
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -1270,7 +1180,6 @@ H5FD_mirror_fapl_free(void *_fa)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5FD_mirror_fapl_free() */
 
-
 /* -------------------------------------------------------------------------
  * Function:    H5Pget_fapl_mirror
  *
@@ -1284,7 +1193,7 @@ herr_t
 H5Pget_fapl_mirror(hid_t fapl_id, H5FD_mirror_fapl_t *fa_out)
 {
     const H5FD_mirror_fapl_t *fa        = NULL;
-    H5P_genplist_t           *plist     = NULL;
+    H5P_genplist_t *          plist     = NULL;
     herr_t                    ret_value = SUCCEED;
 
     FUNC_ENTER_API(FAIL)
@@ -1298,8 +1207,7 @@ H5Pget_fapl_mirror(hid_t fapl_id, H5FD_mirror_fapl_t *fa_out)
 
     plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS);
     if (NULL == plist) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
-                    "not a file access property list");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list");
     }
 
     if (H5P_peek_driver(plist) != H5FD_MIRROR) {
@@ -1319,7 +1227,6 @@ done:
     FUNC_LEAVE_API(ret_value);
 } /* end H5Pget_fapl_mirror() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5Pset_fapl_mirror
  *
@@ -1332,8 +1239,8 @@ done:
 herr_t
 H5Pset_fapl_mirror(hid_t fapl_id, H5FD_mirror_fapl_t *fa)
 {
-    H5P_genplist_t *plist = NULL;
-    herr_t ret_value = FAIL;
+    H5P_genplist_t *plist     = NULL;
+    herr_t          ret_value = FAIL;
 
     FUNC_ENTER_API(FAIL)
     H5TRACE2("e", "i*x", fapl_id, fa);
@@ -1342,8 +1249,7 @@ H5Pset_fapl_mirror(hid_t fapl_id, H5FD_mirror_fapl_t *fa)
 
     plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS);
     if (NULL == plist) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
-                    "not a file access property list");
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list");
     }
     if (NULL == fa) {
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null fapl_t pointer");
@@ -1361,7 +1267,6 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Pset_fapl_mirror() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_mirror_open
  *
@@ -1377,22 +1282,19 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5FD_t *
-H5FD_mirror_open(const char *name,
-                 unsigned    flags,
-                 hid_t       fapl_id,
-                 haddr_t     maxaddr)
+H5FD_mirror_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
 {
 #define MIRR_OPEN_MAXBUF 16 /* local symbol to give meaning to magic number  */
                             /* #defined because it is needed at compile time */
                             /* Large enough to hold a port number string     */
-    int                      live_socket = -1;
-    struct sockaddr_in       target_addr;
-    socklen_t                addr_size;
-    char                     xmit_buf[H5FD_MIRROR_XMIT_OPEN_SIZE];
-    H5FD_mirror_fapl_t       fa;
-    H5FD_mirror_t           *file      = NULL;
-    H5FD_mirror_xmit_open_t  open_xmit;
-    H5FD_t                  *ret_value = NULL;
+    int                     live_socket = -1;
+    struct sockaddr_in      target_addr;
+    socklen_t               addr_size;
+    char                    xmit_buf[H5FD_MIRROR_XMIT_OPEN_SIZE];
+    H5FD_mirror_fapl_t      fa;
+    H5FD_mirror_t *         file = NULL;
+    H5FD_mirror_xmit_open_t open_xmit;
+    H5FD_t *                ret_value = NULL;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -1436,16 +1338,14 @@ H5FD_mirror_open(const char *name,
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "can't create socket");
     }
 
-    target_addr.sin_family = AF_INET;
-    target_addr.sin_port = HDhtons((uint16_t)fa.handshake_port);
+    target_addr.sin_family      = AF_INET;
+    target_addr.sin_port        = HDhtons((uint16_t)fa.handshake_port);
     target_addr.sin_addr.s_addr = HDinet_addr(fa.remote_ip);
     HDmemset(target_addr.sin_zero, '\0', sizeof target_addr.sin_zero);
 
     addr_size = sizeof(target_addr);
-    if (HDconnect(live_socket, (struct sockaddr *)&target_addr, addr_size) < 0)
-    {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "can't connect to remote server");
+    if (HDconnect(live_socket, (struct sockaddr *)&target_addr, addr_size) < 0) {
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "can't connect to remote server");
     }
 
     /* ------------- */
@@ -1454,30 +1354,28 @@ H5FD_mirror_open(const char *name,
 
     file = (H5FD_mirror_t *)H5FL_CALLOC(H5FD_mirror_t);
     if (NULL == file) {
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
-                    "unable to allocate file struct");
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "unable to allocate file struct");
     }
 
     file->sock_fd = live_socket;
-    file->xmit_i = 0;
+    file->xmit_i  = 0;
 
-    file->xmit.magic = H5FD_MIRROR_XMIT_MAGIC;
-    file->xmit.version = H5FD_MIRROR_XMIT_CURR_VERSION;
-    file->xmit.xmit_count = file->xmit_i++;
+    file->xmit.magic         = H5FD_MIRROR_XMIT_MAGIC;
+    file->xmit.version       = H5FD_MIRROR_XMIT_CURR_VERSION;
+    file->xmit.xmit_count    = file->xmit_i++;
     file->xmit.session_token = (uint32_t)(0x01020304 ^ file->sock_fd); /* TODO: hashing? */
     /* int --> uint32_t may truncate on some systems... shouldn't matter? */
 
-    file->xmit.op = H5FD_MIRROR_OP_OPEN;
-    open_xmit.pub = file->xmit;
-    open_xmit.flags = (uint32_t)flags;
-    open_xmit.maxaddr = (uint64_t)maxaddr;
+    file->xmit.op         = H5FD_MIRROR_OP_OPEN;
+    open_xmit.pub         = file->xmit;
+    open_xmit.flags       = (uint32_t)flags;
+    open_xmit.maxaddr     = (uint64_t)maxaddr;
     open_xmit.size_t_blob = (uint64_t)((size_t)(-1));
-    HDsnprintf(open_xmit.filename, H5FD_MIRROR_XMIT_FILEPATH_MAX-1, "%s", name);
+    HDsnprintf(open_xmit.filename, H5FD_MIRROR_XMIT_FILEPATH_MAX - 1, "%s", name);
 
     if (H5FD_mirror_xmit_encode_open((unsigned char *)xmit_buf,
-            (const H5FD_mirror_xmit_open_t *)&open_xmit)
-        != H5FD_MIRROR_XMIT_OPEN_SIZE)
-    {
+                                     (const H5FD_mirror_xmit_open_t *)&open_xmit) !=
+        H5FD_MIRROR_XMIT_OPEN_SIZE) {
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, NULL, "unable to encode open");
     }
 
@@ -1499,15 +1397,13 @@ done:
             file = H5FL_FREE(H5FD_mirror_t, file);
         }
         if (live_socket >= 0 && HDclose(live_socket) < 0) {
-            HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL,
-                        "can't close socket");
+            HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "can't close socket");
         }
     }
     FUNC_LEAVE_NOAPI(ret_value)
 #undef MIRR_OPEN_MAXBUF
 } /* end H5FD_mirror_open() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_mirror_close
  *
@@ -1528,8 +1424,8 @@ H5FD_mirror_close(H5FD_t *_file)
 {
     H5FD_mirror_t *file = (H5FD_mirror_t *)_file;
     unsigned char  xmit_buf[H5FD_MIRROR_XMIT_HEADER_SIZE];
-    int xmit_encoded = 0; /* monitor point of failure */
-    herr_t         ret_value = SUCCEED;
+    int            xmit_encoded = 0; /* monitor point of failure */
+    herr_t         ret_value    = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -1540,12 +1436,10 @@ H5FD_mirror_close(H5FD_t *_file)
     HDassert(file->sock_fd >= 0);
 
     file->xmit.xmit_count = (file->xmit_i)++;
-    file->xmit.op = H5FD_MIRROR_OP_CLOSE;
+    file->xmit.op         = H5FD_MIRROR_OP_CLOSE;
 
-    if (H5FD_mirror_xmit_encode_header(xmit_buf,
-            (const H5FD_mirror_xmit_t *)&(file->xmit))
-        != H5FD_MIRROR_XMIT_HEADER_SIZE)
-    {
+    if (H5FD_mirror_xmit_encode_header(xmit_buf, (const H5FD_mirror_xmit_t *)&(file->xmit)) !=
+        H5FD_MIRROR_XMIT_HEADER_SIZE) {
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to encode close");
     }
     xmit_encoded = 1;
@@ -1572,36 +1466,30 @@ done:
              * any reply at all.
              */
             if (HDwrite(file->sock_fd, "GOODBYE", HDstrlen("GOODBYE")) < 0) {
-                HDONE_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                            "unable to transmit close");
+                HDONE_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to transmit close");
                 if (HDclose(file->sock_fd) < 0) {
-                    HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL,
-                                "can't close socket");
+                    HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "can't close socket");
                 }
                 file->sock_fd = -1; /* invalidate for later */
-            } /* end if problem writing goodbye; go down hard */
-            else
-            if (HDshutdown(file->sock_fd, SHUT_WR) < 0) {
-                HDONE_ERROR(H5E_VFL, H5E_BADVALUE, FAIL,
-                            "can't shutdown socket write: %s",
+            }                       /* end if problem writing goodbye; go down hard */
+            else if (HDshutdown(file->sock_fd, SHUT_WR) < 0) {
+                HDONE_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "can't shutdown socket write: %s",
                             HDstrerror(errno));
             } /* end else-if problem shutting down socket */
-        } /* end if xmit encode failed */
+        }     /* end if xmit encode failed */
 
         if (file->sock_fd >= 0) {
             if (HDclose(file->sock_fd) < 0) {
-                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL,
-                            "can't close socket");
+                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "can't close socket");
             }
         } /* end if socket not closed by going down hard */
-    } /* end if error */
+    }     /* end if error */
 
     file = H5FL_FREE(H5FD_mirror_t, file); /* always release resources */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_mirror_close() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_mirror_query
  *
@@ -1626,20 +1514,14 @@ H5FD_mirror_query(const H5FD_t H5_ATTR_UNUSED *_file, unsigned long *flags)
      * -- JOS 2020-01-13
      */
     if (flags) {
-        *flags = 0                                      \
-               | H5FD_FEAT_AGGREGATE_METADATA           \
-               | H5FD_FEAT_ACCUMULATE_METADATA          \
-               | H5FD_FEAT_DATA_SIEVE                   \
-               | H5FD_FEAT_AGGREGATE_SMALLDATA          \
-               | H5FD_FEAT_POSIX_COMPAT_HANDLE          \
-               | H5FD_FEAT_SUPPORTS_SWMR_IO             \
-               | H5FD_FEAT_DEFAULT_VFD_COMPATIBLE;
+        *flags = 0 | H5FD_FEAT_AGGREGATE_METADATA | H5FD_FEAT_ACCUMULATE_METADATA | H5FD_FEAT_DATA_SIEVE |
+                 H5FD_FEAT_AGGREGATE_SMALLDATA | H5FD_FEAT_POSIX_COMPAT_HANDLE | H5FD_FEAT_SUPPORTS_SWMR_IO |
+                 H5FD_FEAT_DEFAULT_VFD_COMPATIBLE;
     }
 
     FUNC_LEAVE_NOAPI(SUCCEED);
 } /* end H5FD_mirror_query() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_mirror_get_eoa
  *
@@ -1666,7 +1548,6 @@ H5FD_mirror_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
     FUNC_LEAVE_NOAPI(file->eoa)
 } /* end H5FD_mirror_get_eoa() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_mirror_set_eoa
  *
@@ -1680,10 +1561,10 @@ H5FD_mirror_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 static herr_t
 H5FD_mirror_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr)
 {
-    H5FD_mirror_xmit_eoa_t      xmit_eoa;
-    unsigned char       xmit_buf[H5FD_MIRROR_XMIT_EOA_SIZE];
-    H5FD_mirror_t      *file      = (H5FD_mirror_t *)_file;
-    herr_t              ret_value = SUCCEED;
+    H5FD_mirror_xmit_eoa_t xmit_eoa;
+    unsigned char          xmit_buf[H5FD_MIRROR_XMIT_EOA_SIZE];
+    H5FD_mirror_t *        file      = (H5FD_mirror_t *)_file;
+    herr_t                 ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -1694,24 +1575,21 @@ H5FD_mirror_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr)
     file->eoa = addr; /* local copy */
 
     file->xmit.xmit_count = (file->xmit_i)++;
-    file->xmit.op = H5FD_MIRROR_OP_SET_EOA;
+    file->xmit.op         = H5FD_MIRROR_OP_SET_EOA;
 
-    xmit_eoa.pub = file->xmit;
-    xmit_eoa.type = (uint8_t)type;
+    xmit_eoa.pub      = file->xmit;
+    xmit_eoa.type     = (uint8_t)type;
     xmit_eoa.eoa_addr = (uint64_t)addr;
 
-    if (H5FD_mirror_xmit_encode_set_eoa(xmit_buf,
-            (const H5FD_mirror_xmit_eoa_t *)&xmit_eoa)
-        != H5FD_MIRROR_XMIT_EOA_SIZE)
-    {
+    if (H5FD_mirror_xmit_encode_set_eoa(xmit_buf, (const H5FD_mirror_xmit_eoa_t *)&xmit_eoa) !=
+        H5FD_MIRROR_XMIT_EOA_SIZE) {
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to encode set-eoa");
     }
 
     LOG_XMIT_BYTES("set-eoa", xmit_buf, H5FD_MIRROR_XMIT_EOA_SIZE);
 
     if (HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_EOA_SIZE) < 0) {
-        HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL,
-                    "unable to transmit set-eoa");
+        HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to transmit set-eoa");
     }
 
     if (H5FD__mirror_verify_reply(file) == FAIL) {
@@ -1722,7 +1600,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_mirror_set_eoa() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_mirror_get_eof
  *
@@ -1750,7 +1627,6 @@ H5FD_mirror_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
     FUNC_LEAVE_NOAPI(file->eof)
 } /* end H5FD_mirror_get_eof() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_mirror_read
  *
@@ -1761,12 +1637,8 @@ H5FD_mirror_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_mirror_read(H5FD_t     H5_ATTR_UNUSED *_file,
-                 H5FD_mem_t H5_ATTR_UNUSED  type,
-                 hid_t      H5_ATTR_UNUSED  fapl_id,
-                 haddr_t    H5_ATTR_UNUSED  addr,
-                 size_t     H5_ATTR_UNUSED  size,
-                 void       H5_ATTR_UNUSED *buf)
+H5FD_mirror_read(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED fapl_id,
+                 haddr_t H5_ATTR_UNUSED addr, size_t H5_ATTR_UNUSED size, void H5_ATTR_UNUSED *buf)
 {
     herr_t ret_value = FAIL;
 
@@ -1777,7 +1649,6 @@ H5FD_mirror_read(H5FD_t     H5_ATTR_UNUSED *_file,
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_mirror_read() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_mirror_write
  *
@@ -1796,17 +1667,13 @@ H5FD_mirror_read(H5FD_t     H5_ATTR_UNUSED *_file,
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_mirror_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_mirror_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_mirror_xmit_write_t    xmit_write;
-    unsigned char               xmit_buf[H5FD_MIRROR_XMIT_WRITE_SIZE];
-    H5FD_mirror_t              *file        = (H5FD_mirror_t *)_file;
-    herr_t                      ret_value   = SUCCEED;
+    H5FD_mirror_xmit_write_t xmit_write;
+    unsigned char            xmit_buf[H5FD_MIRROR_XMIT_WRITE_SIZE];
+    H5FD_mirror_t *          file      = (H5FD_mirror_t *)_file;
+    herr_t                   ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -1816,19 +1683,16 @@ H5FD_mirror_write(H5FD_t               *_file,
     HDassert(buf);
 
     file->xmit.xmit_count = (file->xmit_i)++;
-    file->xmit.op = H5FD_MIRROR_OP_WRITE;
+    file->xmit.op         = H5FD_MIRROR_OP_WRITE;
 
-    xmit_write.pub = file->xmit;
-    xmit_write.size = (uint64_t)size;
+    xmit_write.pub    = file->xmit;
+    xmit_write.size   = (uint64_t)size;
     xmit_write.offset = (uint64_t)addr;
-    xmit_write.type = (uint8_t)type;
-
+    xmit_write.type   = (uint8_t)type;
 
     /* Notify Writer of incoming data to write. */
-    if (H5FD_mirror_xmit_encode_write(xmit_buf,
-            (const H5FD_mirror_xmit_write_t *)&xmit_write)
-        != H5FD_MIRROR_XMIT_WRITE_SIZE)
-    {
+    if (H5FD_mirror_xmit_encode_write(xmit_buf, (const H5FD_mirror_xmit_write_t *)&xmit_write) !=
+        H5FD_MIRROR_XMIT_WRITE_SIZE) {
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to encode write");
     }
 
@@ -1857,7 +1721,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_mirror_write() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_mirror_truncate
  *
@@ -1868,32 +1731,27 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_mirror_truncate(H5FD_t                 *_file,
-                     hid_t   H5_ATTR_UNUSED  dxpl_id,
-                     hbool_t H5_ATTR_UNUSED  closing)
+H5FD_mirror_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_ATTR_UNUSED closing)
 {
-    unsigned char       xmit_buf[H5FD_MIRROR_XMIT_HEADER_SIZE];
-    H5FD_mirror_t      *file = (H5FD_mirror_t *)_file;
-    herr_t      ret_value = SUCCEED;
+    unsigned char  xmit_buf[H5FD_MIRROR_XMIT_HEADER_SIZE];
+    H5FD_mirror_t *file      = (H5FD_mirror_t *)_file;
+    herr_t         ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT
 
     LOG_OP_CALL("H5FD_mirror_truncate");
 
     file->xmit.xmit_count = (file->xmit_i)++;
-    file->xmit.op = H5FD_MIRROR_OP_TRUNCATE;
+    file->xmit.op         = H5FD_MIRROR_OP_TRUNCATE;
 
-    if (H5FD_mirror_xmit_encode_header(xmit_buf, &(file->xmit))
-        != H5FD_MIRROR_XMIT_HEADER_SIZE)
-    {
+    if (H5FD_mirror_xmit_encode_header(xmit_buf, &(file->xmit)) != H5FD_MIRROR_XMIT_HEADER_SIZE) {
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to encode truncate");
     }
 
     LOG_XMIT_BYTES("truncate", xmit_buf, H5FD_MIRROR_XMIT_HEADER_SIZE);
 
     if (HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_HEADER_SIZE) < 0) {
-        HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL,
-                    "unable to transmit truncate");
+        HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to transmit truncate");
     }
 
     if (H5FD__mirror_verify_reply(file) == FAIL) {
@@ -1904,7 +1762,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_mirror_truncate() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_mirror_lock
  *
@@ -1920,24 +1777,22 @@ static herr_t
 H5FD_mirror_lock(H5FD_t *_file, hbool_t rw)
 {
     H5FD_mirror_xmit_lock_t xmit_lock;
-    unsigned char       xmit_buf[H5FD_MIRROR_XMIT_LOCK_SIZE];
-    H5FD_mirror_t      *file = (H5FD_mirror_t *)_file;
-    herr_t ret_value = SUCCEED;
+    unsigned char           xmit_buf[H5FD_MIRROR_XMIT_LOCK_SIZE];
+    H5FD_mirror_t *         file      = (H5FD_mirror_t *)_file;
+    herr_t                  ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT;
 
     LOG_OP_CALL("H5FD_mirror_lock");
 
     file->xmit.xmit_count = (file->xmit_i)++;
-    file->xmit.op = H5FD_MIRROR_OP_LOCK;
+    file->xmit.op         = H5FD_MIRROR_OP_LOCK;
 
     xmit_lock.pub = file->xmit;
-    xmit_lock.rw = (uint64_t)rw;
+    xmit_lock.rw  = (uint64_t)rw;
 
-    if (H5FD_mirror_xmit_encode_lock(xmit_buf,
-            (const H5FD_mirror_xmit_lock_t *)&xmit_lock)
-        != H5FD_MIRROR_XMIT_LOCK_SIZE)
-    {
+    if (H5FD_mirror_xmit_encode_lock(xmit_buf, (const H5FD_mirror_xmit_lock_t *)&xmit_lock) !=
+        H5FD_MIRROR_XMIT_LOCK_SIZE) {
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to encode lock");
     }
 
@@ -1955,7 +1810,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value);
 } /* end H5FD_mirror_lock */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_mirror_unlock
  *
@@ -1967,20 +1821,18 @@ done:
 static herr_t
 H5FD_mirror_unlock(H5FD_t *_file)
 {
-    unsigned char       xmit_buf[H5FD_MIRROR_XMIT_HEADER_SIZE];
-    H5FD_mirror_t      *file = (H5FD_mirror_t *)_file;
-    herr_t ret_value = SUCCEED;
+    unsigned char  xmit_buf[H5FD_MIRROR_XMIT_HEADER_SIZE];
+    H5FD_mirror_t *file      = (H5FD_mirror_t *)_file;
+    herr_t         ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT;
 
     LOG_OP_CALL("H5FD_mirror_unlock");
 
     file->xmit.xmit_count = (file->xmit_i)++;
-    file->xmit.op = H5FD_MIRROR_OP_UNLOCK;
+    file->xmit.op         = H5FD_MIRROR_OP_UNLOCK;
 
-    if (H5FD_mirror_xmit_encode_header(xmit_buf, &(file->xmit))
-        != H5FD_MIRROR_XMIT_HEADER_SIZE)
-    {
+    if (H5FD_mirror_xmit_encode_header(xmit_buf, &(file->xmit)) != H5FD_MIRROR_XMIT_HEADER_SIZE) {
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to encode unlock");
     }
 
@@ -1999,4 +1851,3 @@ done:
 } /* end H5FD_mirror_unlock */
 
 #endif /* H5_HAVE_MIRROR_VFD */
-