Clean up private / package / static namespace issues (function naming, which

header file, FUNC_ENTER / LEAVE, etc).  Removed remaining personal email
addresses from library source code (still needs cleaned from other directories).
Misc. warning, style, and whitespace cleanup.

1 files changed, 447 insertions, 431 deletions

diff --git a/src/H5FDmirror.c b/src/H5FDmirror.c
index ef035c1..6bee4a7 100644
--- a/src/H5FDmirror.c
+++ b/src/H5FDmirror.c
@@ -25,6 +25,7 @@
 #include "H5Fprivate.h"     /* File access              */
 #include "H5FDprivate.h"    /* File drivers             */
 #include "H5FDmirror.h"     /* "Mirror" definitions     */
+#include "H5FDmirror_priv.h"    /* Private header for the mirror VFD */
 #include "H5FLprivate.h"    /* Free Lists               */
 #include "H5Iprivate.h"     /* IDs                      */
 #include "H5MMprivate.h"    /* Memory management        */
@@ -136,32 +137,32 @@ typedef struct H5FD_mirror_t {
 #if MIRROR_DEBUG_OP_CALLS
 #define LOG_OP_CALL(name) do {         \
     HDprintf("called %s()\n", (name)); \
-    fflush(stdout);                    \
+    HDfflush(stdout);                  \
 } while (0)
 #else
 #define LOG_OP_CALL(name) /* no-op */
 #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 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 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, \
+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 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, \
+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,
+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, \
+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_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);
 
@@ -169,40 +170,46 @@ static const H5FD_class_t H5FD_mirror_g = {
     "mirror",                   /* name                 */
     MAXADDR,                    /* maxaddr              */
     H5F_CLOSE_WEAK,             /* fc_degree            */
-    H5FD_mirror_term,           /* terminate            */
+    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            */
+    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                */
+    H5FD__mirror_open,          /* open                 */
+    H5FD__mirror_close,         /* close                */
     NULL,                       /* cmp                  */
-    H5FD_mirror_query,          /* query                */
+    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              */
+    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                */
+    H5FD__mirror_read,          /* read                 */
+    H5FD__mirror_write,         /* write                */
     NULL,                       /* flush                */
-    H5FD_mirror_truncate,       /* truncate             */
-    H5FD_mirror_lock,           /* lock                 */
-    H5FD_mirror_unlock,         /* unlock               */
+    H5FD__mirror_truncate,      /* truncate             */
+    H5FD__mirror_lock,          /* lock                 */
+    H5FD__mirror_unlock,        /* unlock               */
     H5FD_FLMAP_DICHOTOMY        /* fl_map               */
 };
 
+/* Declare a free list to manage the transmission buffers */
+H5FL_BLK_DEFINE_STATIC(xmit);
+
 /* Declare a free list to manage the H5FD_mirror_t struct */
 H5FL_DEFINE_STATIC(H5FD_mirror_t);
 
+/* Declare a free list to manage the H5FD_mirror_xmit_open_t struct */
+H5FL_DEFINE_STATIC(H5FD_mirror_xmit_open_t);
+
 
 /*-------------------------------------------------------------------------
  * Function:    H5FD__init_package
@@ -219,12 +226,10 @@ H5FD__init_package(void)
 
     FUNC_ENTER_STATIC
 
-    LOG_OP_CALL("H5FD__init_package");
+    LOG_OP_CALL(FUNC);
 
-    if (H5FD_mirror_init() < 0) {
-        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL,
-                    "unable to initialize mirror VFD");
-    }
+    if(H5FD_mirror_init() < 0)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "unable to initialize mirror VFD");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -248,12 +253,10 @@ H5FD_mirror_init(void)
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    LOG_OP_CALL("H5FD_mirror_init");
+    LOG_OP_CALL(FUNC);
 
-    if (H5I_VFL != H5I_get_type(H5FD_MIRROR_g)) {
-        H5FD_MIRROR_g = H5FD_register(&H5FD_mirror_g, sizeof(H5FD_class_t),
-                FALSE);
-    }
+    if(H5I_VFL != H5I_get_type(H5FD_MIRROR_g))
+        H5FD_MIRROR_g = H5FD_register(&H5FD_mirror_g, sizeof(H5FD_class_t), FALSE);
 
     ret_value = H5FD_MIRROR_g;
 
@@ -263,7 +266,7 @@ done:
 
 
 /* ---------------------------------------------------------------------------
- * Function:    H5FD_mirror_term
+ * Function:    H5FD__mirror_term
  *
  * Purpose:     Shut down the VFD
  *
@@ -271,17 +274,17 @@ done:
  * ---------------------------------------------------------------------------
  */
 static herr_t
-H5FD_mirror_term(void)
+H5FD__mirror_term(void)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Reset VFL ID */
     H5FD_MIRROR_g = 0;
 
-    LOG_OP_CALL("H5FD_mirror_term");
+    LOG_OP_CALL(FUNC);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5FD_mirror_term() */
+} /* end H5FD__mirror_term() */
 
 
 /* ---------------------------------------------------------------------------
@@ -301,10 +304,14 @@ size_t
 H5FD__mirror_xmit_decode_uint16(uint16_t *out, const unsigned char *_buf)
 {
     uint16_t n = 0;
-    LOG_OP_CALL("H5FD__mirror_xmit_decode_uint16");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(_buf && out);
+
     HDmemcpy(&n, _buf, sizeof(n));
     *out = (uint16_t)HDntohs(n);
+
     return 2; /* number of bytes eaten */
 } /* end H5FD__mirror_xmit_decode_uint16() */
 
@@ -326,14 +333,17 @@ size_t
 H5FD__mirror_xmit_decode_uint32(uint32_t *out, const unsigned char *_buf)
 {
     uint32_t n = 0;
-    LOG_OP_CALL("H5FD__mirror_xmit_decode_uint32");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(_buf && out);
+
     HDmemcpy(&n, _buf, sizeof(n));
     *out = (uint32_t)HDntohl(n);
+
     return 4; /* number of bytes eaten */
 } /* end H5FD__mirror_xmit_decode_uint32() */
 
-
 
 /* ---------------------------------------------------------------------------
  * Function:    is_host_little_endian
@@ -357,12 +367,11 @@ is_host_little_endian(void)
         uint8_t  u8[4];
     } echeck;
     echeck.u32 = 0xA1B2C3D4;
-    if (echeck.u8[0] == 0xD4) {
+
+    if(echeck.u8[0] == 0xD4)
         return TRUE;
-    }
-    else {
+    else
         return FALSE;
-    }
 } /* end is_host_little_endian() */
 
 
@@ -385,15 +394,17 @@ size_t
 H5FD__mirror_xmit_decode_uint64(uint64_t *out, const unsigned char *_buf)
 {
     uint64_t n = 0;
-    LOG_OP_CALL("H5FD__mirror_xmit_decode_uint64");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(_buf && out);
+
     HDmemcpy(&n, _buf, sizeof(n));
-    if (TRUE == is_host_little_endian()) {
+    if(TRUE == is_host_little_endian())
         *out = BSWAP_64(n);
-    }
-    else {
+    else
         *out = n;
-    }
+
     return 8;
 } /* end H5FD__mirror_xmit_decode_uint64() */
 
@@ -412,9 +423,12 @@ H5FD__mirror_xmit_decode_uint64(uint64_t *out, const unsigned char *_buf)
 size_t
 H5FD__mirror_xmit_decode_uint8(uint8_t *out, const unsigned char *_buf)
 {
-    LOG_OP_CALL("H5FD__mirror_xmit_decode_uint8");
+    LOG_OP_CALL(__func__);
+
     HDassert(_buf && out);
+
     HDmemcpy(out, _buf, sizeof(uint8_t));
+
     return 1; /* number of bytes eaten */
 } /* end H5FD__mirror_xmit_decode_uint8() */
 
@@ -435,10 +449,14 @@ size_t
 H5FD__mirror_xmit_encode_uint16(unsigned char *_dest, uint16_t v)
 {
     uint16_t n = 0;
-    LOG_OP_CALL("H5FD__mirror_xmit_encode_uint16");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(_dest);
+
     n = (uint16_t)HDhtons(v);
     HDmemcpy(_dest, &n, sizeof(n));
+
     return 2;
 } /* end H5FD__mirror_xmit_encode_uint16() */
 
@@ -459,10 +477,14 @@ size_t
 H5FD__mirror_xmit_encode_uint32(unsigned char *_dest, uint32_t v)
 {
     uint32_t n = 0;
-    LOG_OP_CALL("H5FD__mirror_xmit_encode_uint32");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(_dest);
+
     n = (uint32_t)HDhtonl(v);
     HDmemcpy(_dest, &n, sizeof(n));
+
     return 4;
 } /* end H5FD__mirror_xmit_encode_uint32() */
 
@@ -483,12 +505,15 @@ size_t
 H5FD__mirror_xmit_encode_uint64(unsigned char *_dest, uint64_t v)
 {
     uint64_t n = v;
-    LOG_OP_CALL("H5FD__mirror_xmit_decode_uint64");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(_dest);
-    if (TRUE == is_host_little_endian()) {
+
+    if(TRUE == is_host_little_endian())
         n = BSWAP_64(v);
-    }
     HDmemcpy(_dest, &n, sizeof(n));
+
     return 8;
 } /* H5FD__mirror_xmit_encode_uint64() */
 
@@ -509,9 +534,12 @@ H5FD__mirror_xmit_encode_uint64(unsigned char *_dest, uint64_t v)
 size_t
 H5FD__mirror_xmit_encode_uint8(unsigned char *dest, uint8_t v)
 {
-    LOG_OP_CALL("H5FD__mirror_xmit_encode_uint8");
+    LOG_OP_CALL(__func__);
+
     HDassert(dest);
+
     HDmemcpy(dest, &v, sizeof(v));
+
     return 1;
 } /* end H5FD__mirror_xmit_encode_uint8() */
 
@@ -540,8 +568,11 @@ 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");
+
+    LOG_OP_CALL(__func__);
+
     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),
@@ -550,6 +581,7 @@ H5FD_mirror_xmit_decode_header(H5FD_mirror_xmit_t  *out,
             &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() */
 
@@ -578,11 +610,15 @@ 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");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(out && buf);
+
     n_eaten += H5FD_mirror_xmit_decode_header(&(out->pub), buf);
     n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->rw), &buf[n_eaten]);
     HDassert(n_eaten == H5FD_MIRROR_XMIT_LOCK_SIZE);
+
     return n_eaten;
 } /* end H5FD_mirror_xmit_decode_lock() */
 
@@ -612,8 +648,11 @@ 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");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(out && buf);
+
     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]);
@@ -622,8 +661,9 @@ H5FD_mirror_xmit_decode_open(H5FD_mirror_xmit_open_t *out,
     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 */
+            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() */
 
@@ -653,15 +693,19 @@ 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");
+
+    LOG_OP_CALL(__func__);
+
     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 */
+            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() */
 
@@ -690,12 +734,16 @@ 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");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(out && buf);
+
     n_eaten += H5FD_mirror_xmit_decode_header(&(out->pub), buf);
     n_eaten += H5FD__mirror_xmit_decode_uint8(&(out->type), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->eoa_addr), &buf[n_eaten]);
     HDassert(n_eaten == H5FD_MIRROR_XMIT_EOA_SIZE);
+
     return n_eaten;
 } /* end H5FD_mirror_xmit_decode_set_eoa() */
 
@@ -724,13 +772,17 @@ 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");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(out && buf);
+
     n_eaten += H5FD_mirror_xmit_decode_header(&(out->pub), buf);
     n_eaten += H5FD__mirror_xmit_decode_uint8(&(out->type), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->offset), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->size), &buf[n_eaten]);
     HDassert(n_eaten == H5FD_MIRROR_XMIT_WRITE_SIZE);
+
     return n_eaten;
 } /* end H5FD_mirror_xmit_decode_write() */
 
@@ -754,14 +806,18 @@ 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");
+
+    LOG_OP_CALL(__func__);
+
     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);
     HDassert(n_writ == H5FD_MIRROR_XMIT_HEADER_SIZE);
+
     return n_writ;
 } /* end H5FD_mirror_xmit_encode_header() */
 
@@ -784,12 +840,16 @@ 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");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(dest && x);
+
     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() */
 
@@ -813,13 +873,14 @@ 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");
+
+    LOG_OP_CALL(__func__);
+
     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;
-    }
-    n_writ = 0;
+    HDmemset(dest, 0, H5FD_MIRROR_XMIT_OPEN_SIZE);
+
     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);
@@ -827,8 +888,8 @@ H5FD_mirror_xmit_encode_open(unsigned char                 *dest,
     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);
+    HDstrncpy((char *)&dest[n_writ], x->filename, H5FD_MIRROR_XMIT_FILEPATH_MAX);
+
     return H5FD_MIRROR_XMIT_OPEN_SIZE;
 } /* end H5FD_mirror_xmit_encode_open() */
 
@@ -853,20 +914,21 @@ 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");
+
+    LOG_OP_CALL(__func__);
+
     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;
-    }
-    n_writ = 0;
+    HDmemset(dest, 0, H5FD_MIRROR_XMIT_REPLY_SIZE);
+
     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);
+    HDstrncpy((char *)&dest[n_writ], x->message, H5FD_MIRROR_STATUS_MESSAGE_MAX);
+
     return H5FD_MIRROR_XMIT_REPLY_SIZE;
 } /* end H5FD_mirror_xmit_encode_reply() */
 
@@ -890,13 +952,17 @@ 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");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(dest && x);
+
     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() */
 
@@ -920,14 +986,18 @@ 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");
+
+    LOG_OP_CALL(__func__);
+
     HDassert(dest && x);
+
     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);
     HDassert(n_writ == H5FD_MIRROR_XMIT_WRITE_SIZE);
+
     return n_writ;
 } /* end H5FD_mirror_xmit_encode_write() */
 
@@ -942,16 +1012,16 @@ H5FD_mirror_xmit_encode_write(unsigned char                  *dest,
  * Return:      TRUE if valid; else FALSE.
  * ---------------------------------------------------------------------------
  */
-hbool_t
+H5_ATTR_PURE hbool_t
 H5FD_mirror_xmit_is_close(const H5FD_mirror_xmit_t *xmit)
 {
-    LOG_OP_CALL("H5FD_mirror_xmit_is_close");
+    LOG_OP_CALL(__func__);
+
     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() */
 
@@ -966,16 +1036,16 @@ H5FD_mirror_xmit_is_close(const H5FD_mirror_xmit_t *xmit)
  * Return:      TRUE if valid; else FALSE.
  * ---------------------------------------------------------------------------
  */
-hbool_t
+H5_ATTR_PURE hbool_t
 H5FD_mirror_xmit_is_lock(const H5FD_mirror_xmit_lock_t *xmit)
 {
-    LOG_OP_CALL("H5FD_mirror_xmit_is_lock");
+    LOG_OP_CALL(__func__);
+
     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() */
 
@@ -990,16 +1060,17 @@ H5FD_mirror_xmit_is_lock(const H5FD_mirror_xmit_lock_t *xmit)
  * Return:      TRUE if valid; else FALSE.
  * ---------------------------------------------------------------------------
  */
-hbool_t
+H5_ATTR_PURE hbool_t
 H5FD_mirror_xmit_is_open(const H5FD_mirror_xmit_open_t *xmit)
 {
-    LOG_OP_CALL("H5FD_mirror_xmit_is_open");
+    LOG_OP_CALL(__func__);
+
     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() */
 
@@ -1014,16 +1085,16 @@ H5FD_mirror_xmit_is_open(const H5FD_mirror_xmit_open_t *xmit)
  * Return:      TRUE if valid; else FALSE.
  * ---------------------------------------------------------------------------
  */
-hbool_t
+H5_ATTR_PURE hbool_t
 H5FD_mirror_xmit_is_set_eoa(const H5FD_mirror_xmit_eoa_t *xmit)
 {
-    LOG_OP_CALL("H5FD_mirror_xmit_is_set_eoa");
+    LOG_OP_CALL(__func__);
+
     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() */
 
@@ -1038,16 +1109,16 @@ H5FD_mirror_xmit_is_set_eoa(const H5FD_mirror_xmit_eoa_t *xmit)
  * Return:      TRUE if valid; else FALSE.
  * ---------------------------------------------------------------------------
  */
-hbool_t
+H5_ATTR_PURE hbool_t
 H5FD_mirror_xmit_is_reply(const H5FD_mirror_xmit_reply_t *xmit)
 {
-    LOG_OP_CALL("H5FD_mirror_xmit_is_reply");
+    LOG_OP_CALL(__func__);
+
     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() */
 
@@ -1062,16 +1133,16 @@ H5FD_mirror_xmit_is_reply(const H5FD_mirror_xmit_reply_t *xmit)
  * Return:      TRUE if valid; else FALSE.
  * ---------------------------------------------------------------------------
  */
-hbool_t
+H5_ATTR_PURE hbool_t
 H5FD_mirror_xmit_is_write(const H5FD_mirror_xmit_write_t *xmit)
 {
-    LOG_OP_CALL("H5FD_mirror_xmit_is_write");
+    LOG_OP_CALL(__func__);
+
     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() */
 
@@ -1086,16 +1157,16 @@ H5FD_mirror_xmit_is_write(const H5FD_mirror_xmit_write_t *xmit)
  * Return:      TRUE if valid; else FALSE.
  * ---------------------------------------------------------------------------
  */
-hbool_t
+H5_ATTR_PURE hbool_t
 H5FD_mirror_xmit_is_xmit(const H5FD_mirror_xmit_t *xmit)
 {
-    LOG_OP_CALL("H5FD_mirror_xmit_is_xmit");
+    LOG_OP_CALL(__func__);
+
     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() */
 
@@ -1111,60 +1182,55 @@ H5FD_mirror_xmit_is_xmit(const H5FD_mirror_xmit_t *xmit)
  * Return:      SUCCEED if ok, else FAIL.
  * ----------------------------------------------------------------------------
  */
-herr_t
+static herr_t
 H5FD__mirror_verify_reply(H5FD_mirror_t *file)
 {
-    char                                xmit_buf[H5FD_MIRROR_XMIT_REPLY_SIZE];
+    unsigned char                      *xmit_buf = NULL;
     struct H5FD_mirror_xmit_reply_t     reply;
     ssize_t                             read_ret = 0;
     herr_t                              ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT;
+    FUNC_ENTER_STATIC
 
-    LOG_OP_CALL("H5FD__mirror_verify_reply");
+    LOG_OP_CALL(FUNC);
 
     HDassert(file && file->sock_fd);
 
+    xmit_buf = H5FL_BLK_MALLOC(xmit, H5FD_MIRROR_XMIT_BUFFER_MAX);
+    if(NULL == xmit_buf)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "unable to allocate xmit buffer");
+
     read_ret = HDread(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_REPLY_SIZE);
-    if (read_ret < 0) {
+    if(read_ret < 0)
         HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "unable to read reply");
-    }
-    if (read_ret != H5FD_MIRROR_XMIT_REPLY_SIZE) {
+    if(read_ret != H5FD_MIRROR_XMIT_REPLY_SIZE)
         HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "unexpected read size");
-    }
 
     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, xmit_buf) != H5FD_MIRROR_XMIT_REPLY_SIZE)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "unable to decode reply xmit");
-    }
 
-    if (H5FD_mirror_xmit_is_reply(&reply) != TRUE) {
+    if(H5FD_mirror_xmit_is_reply(&reply) != TRUE)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "xmit op code was not REPLY");
-    }
 
-    if (reply.pub.session_token != file->xmit.session_token) {
+    if(reply.pub.session_token != file->xmit.session_token)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "wrong session");
-    }
-
-    if (reply.pub.xmit_count != (file->xmit_i)++) {
+    if(reply.pub.xmit_count != (file->xmit_i)++)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "xmit out of sync");
-    }
-
-    if (reply.status != H5FD_MIRROR_STATUS_OK) {
-        HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL,
-                    "%s", (const char *)(reply.message));
-    }
+    if(reply.status != H5FD_MIRROR_STATUS_OK)
+        HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "%s", (const char *)(reply.message));
 
 done:
+    if(xmit_buf)
+        xmit_buf = H5FL_BLK_FREE(xmit, xmit_buf);
+
     FUNC_LEAVE_NOAPI(ret_value);
 } /* end H5FD__mirror_verify_reply() */
 
 
 /* -------------------------------------------------------------------------
- * Function:    H5FD_mirror_fapl_get
+ * Function:    H5FD__mirror_fapl_get
  *
  * Purpose:     Get the file access propety list which could be used to create
  *              an identical file.
@@ -1174,37 +1240,35 @@ done:
  * -------------------------------------------------------------------------
  */
 static void *
-H5FD_mirror_fapl_get(H5FD_t *_file)
+H5FD__mirror_fapl_get(H5FD_t *_file)
 {
     H5FD_mirror_t      *file      = (H5FD_mirror_t *)_file;
     H5FD_mirror_fapl_t *fa        = NULL;
     void               *ret_value = NULL;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    LOG_OP_CALL("H5FD_mirror_fapl_get");
+    LOG_OP_CALL(FUNC);
 
     fa = (H5FD_mirror_fapl_t *)H5MM_calloc(sizeof(H5FD_mirror_fapl_t));
-    if (NULL == fa) {
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "calloc failed");
-    }
+    if(NULL == fa)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "calloc failed");
 
     HDmemcpy(fa, &(file->fa), sizeof(H5FD_mirror_fapl_t));
 
     ret_value = fa;
 
 done:
-    if (ret_value == NULL) {
-        if (fa != NULL) {
+    if(ret_value == NULL)
+        if(fa != NULL)
             H5MM_xfree(fa);
-        }
-    }
+
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_mirror_fapl_get() */
+} /* end H5FD__mirror_fapl_get() */
 
 
 /* -------------------------------------------------------------------------
- * Function:    H5FD_mirror_fapl_copy
+ * Function:    H5FD__mirror_fapl_copy
  *
  * Purpose:     Copies the mirror vfd-specific file access properties.
  *
@@ -1213,37 +1277,34 @@ done:
  * -------------------------------------------------------------------------
  */
 static void *
-H5FD_mirror_fapl_copy(const void *_old_fa)
+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;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    LOG_OP_CALL("H5FD_mirror_fapl_copy");
+    LOG_OP_CALL(FUNC);
 
     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");
-    }
+    if(new_fa == NULL)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "memory allocation failed");
 
     HDmemcpy(new_fa, old_fa, sizeof(H5FD_mirror_fapl_t));
     ret_value = new_fa;
 
 done:
-    if (ret_value == NULL) {
-        if (new_fa != NULL) {
+    if(ret_value == NULL)
+        if(new_fa != NULL)
             H5MM_xfree(new_fa);
-        }
-    }
+
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_mirror_fapl_copy() */
+} /* end H5FD__mirror_fapl_copy() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_mirror_fapl_free
+ * Function:    H5FD__mirror_fapl_free
  *
  * Purpose:     Frees the mirror VFD-specific file access properties.
  *
@@ -1251,13 +1312,13 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_mirror_fapl_free(void *_fa)
+H5FD__mirror_fapl_free(void *_fa)
 {
     H5FD_mirror_fapl_t *fa = (H5FD_mirror_fapl_t*)_fa;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
-    LOG_OP_CALL("H5FD_mirror_fapl_free");
+    LOG_OP_CALL(FUNC);
 
     /* sanity check */
     HDassert(fa != NULL);
@@ -1267,7 +1328,7 @@ H5FD_mirror_fapl_free(void *_fa)
     H5MM_xfree(fa);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5FD_mirror_fapl_free() */
+} /* end H5FD__mirror_fapl_free() */
 
 
 /* -------------------------------------------------------------------------
@@ -1289,26 +1350,20 @@ H5Pget_fapl_mirror(hid_t fapl_id, H5FD_mirror_fapl_t *fa_out)
     FUNC_ENTER_API(FAIL)
     H5TRACE2("e", "i*x", fapl_id, fa_out);
 
-    LOG_OP_CALL("H5Pget_fapl_mirror");
+    LOG_OP_CALL(FUNC);
 
-    if (NULL == fa_out) {
+    if(NULL == fa_out)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "fa_out is NULL");
-    }
 
     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");
-    }
-
-    if (H5P_peek_driver(plist) != H5FD_MIRROR) {
+    if(NULL == plist)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list");
+    if(H5P_peek_driver(plist) != H5FD_MIRROR)
         HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "incorrect VFL driver");
-    }
 
     fa = (const H5FD_mirror_fapl_t *)H5P_peek_driver_info(plist);
-    if (NULL == fa) {
+    if(NULL == fa)
         HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "bad VFL driver info");
-    }
 
     HDassert(fa->magic == H5FD_MIRROR_FAPL_MAGIC); /* sanity check */
 
@@ -1337,22 +1392,17 @@ H5Pset_fapl_mirror(hid_t fapl_id, H5FD_mirror_fapl_t *fa)
     FUNC_ENTER_API(FAIL)
     H5TRACE2("e", "i*x", fapl_id, fa);
 
-    LOG_OP_CALL("H5Pset_fapl_mirror");
+    LOG_OP_CALL(FUNC);
 
     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");
-    }
-    if (NULL == fa) {
+    if(NULL == plist)
+        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");
-    }
-    if (H5FD_MIRROR_FAPL_MAGIC != fa->magic) {
+    if(H5FD_MIRROR_FAPL_MAGIC != fa->magic)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid fapl_t magic");
-    }
-    if (H5FD_MIRROR_CURR_FAPL_T_VERSION != fa->version) {
+    if(H5FD_MIRROR_CURR_FAPL_T_VERSION != fa->version)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unknown fapl_t version");
-    }
 
     ret_value = H5P_set_driver(plist, H5FD_MIRROR, (const void *)fa);
 
@@ -1362,7 +1412,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_mirror_open
+ * Function:    H5FD__mirror_open
  *
  * Purpose:     Create and/or opens a file as an HDF5 file.
  *
@@ -1376,64 +1426,51 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5FD_t *
-H5FD_mirror_open(const char *name,
+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];
+    unsigned char           *xmit_buf = NULL;
     H5FD_mirror_fapl_t       fa;
     H5FD_mirror_t           *file      = NULL;
-    H5FD_mirror_xmit_open_t  open_xmit;
+    H5FD_mirror_xmit_open_t *open_xmit = NULL;
     H5FD_t                  *ret_value = NULL;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    LOG_OP_CALL("H5FD_mirror_open");
+    LOG_OP_CALL(FUNC);
 
     /* --------------- */
     /* Check arguments */
     /* --------------- */
 
-    if (!name || !*name) {
+    if(!name || !*name)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid file name");
-    }
-    if (HDstrlen(name) >= H5FD_MIRROR_XMIT_FILEPATH_MAX) {
+    if(HDstrlen(name) >= H5FD_MIRROR_XMIT_FILEPATH_MAX)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "filename is too long");
-    }
-    if (0 == maxaddr || HADDR_UNDEF == maxaddr) {
+    if(0 == maxaddr || HADDR_UNDEF == maxaddr)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "bogus maxaddr");
-    }
-    if (ADDR_OVERFLOW(maxaddr)) {
+    if(ADDR_OVERFLOW(maxaddr))
         HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, NULL, "bogus maxaddr");
-    }
 
-    if (H5Pget_fapl_mirror(fapl_id, &fa) == FAIL) {
+    if(H5Pget_fapl_mirror(fapl_id, &fa) == FAIL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "can't get config info");
-    }
-
-    if (H5FD_MIRROR_FAPL_MAGIC != fa.magic) {
+    if(H5FD_MIRROR_FAPL_MAGIC != fa.magic)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid fapl magic");
-    }
-
-    if (H5FD_MIRROR_CURR_FAPL_T_VERSION != fa.version) {
+    if(H5FD_MIRROR_CURR_FAPL_T_VERSION != fa.version)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid fapl version");
-    }
 
     /* --------------------- */
     /* Handshake with remote */
     /* --------------------- */
 
     live_socket = HDsocket(AF_INET, SOCK_STREAM, 0);
-    if (live_socket < 0) {
+    if(live_socket < 0)
         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);
@@ -1441,21 +1478,16 @@ H5FD_mirror_open(const char *name,
     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");
 
     /* ------------- */
     /* Open the file */
     /* ------------- */
 
     file = (H5FD_mirror_t *)H5FL_CALLOC(H5FD_mirror_t);
-    if (NULL == file) {
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
-                    "unable to allocate file struct");
-    }
+    if(NULL == file)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "unable to allocate file struct");
 
     file->sock_fd = live_socket;
     file->xmit_i = 0;
@@ -1466,49 +1498,53 @@ H5FD_mirror_open(const char *name,
     file->xmit.session_token = (uint32_t)(0x01020304 ^ file->sock_fd); /* TODO: hashing? */
     /* int --> uint32_t may truncate on some systems... shouldn't matter? */
 
+    open_xmit = (H5FD_mirror_xmit_open_t *)H5FL_CALLOC(H5FD_mirror_xmit_open_t);
+    if(NULL == open_xmit)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "unable to allocate open_xmit struct");
+
     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);
-
-    if (H5FD_mirror_xmit_encode_open((unsigned char *)xmit_buf,
-            (const H5FD_mirror_xmit_open_t *)&open_xmit)
-        != H5FD_MIRROR_XMIT_OPEN_SIZE)
-    {
+    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);
+
+    xmit_buf = H5FL_BLK_MALLOC(xmit, H5FD_MIRROR_XMIT_BUFFER_MAX);
+    if(NULL == xmit_buf)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "unable to allocate xmit buffer");
+
+    if(H5FD_mirror_xmit_encode_open(xmit_buf, open_xmit) != H5FD_MIRROR_XMIT_OPEN_SIZE)
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, NULL, "unable to encode open");
-    }
 
     LOG_XMIT_BYTES("open", xmit_buf, H5FD_MIRROR_XMIT_OPEN_SIZE);
 
-    if (HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_OPEN_SIZE) < 0) {
+    if(HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_OPEN_SIZE) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, NULL, "unable to transmit open");
-    }
 
-    if (H5FD__mirror_verify_reply(file) == FAIL) {
+    if(H5FD__mirror_verify_reply(file) == FAIL)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, NULL, "invalid reply");
-    }
 
     ret_value = (H5FD_t *)file;
 
 done:
-    if (NULL == ret_value) {
-        if (file) {
+    if(NULL == ret_value) {
+        if(file)
             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");
-        }
+        if(live_socket >= 0 && HDclose(live_socket) < 0)
+            HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "can't close socket");
     }
+
+    if(open_xmit)
+        open_xmit = H5FL_FREE(H5FD_mirror_xmit_open_t, open_xmit);
+    if(xmit_buf)
+        xmit_buf = H5FL_BLK_FREE(xmit, xmit_buf);
+
     FUNC_LEAVE_NOAPI(ret_value)
-#undef MIRR_OPEN_MAXBUF
-} /* end H5FD_mirror_open() */
+} /* end H5FD__mirror_open() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_mirror_close
+ * Function:    H5FD__mirror_close
  *
  * Purpose:     Closes the HDF5 file.
  *
@@ -1523,16 +1559,16 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_mirror_close(H5FD_t *_file)
+H5FD__mirror_close(H5FD_t *_file)
 {
     H5FD_mirror_t *file = (H5FD_mirror_t *)_file;
-    unsigned char  xmit_buf[H5FD_MIRROR_XMIT_HEADER_SIZE];
+    unsigned char *xmit_buf = NULL;
     int xmit_encoded = 0; /* monitor point of failure */
     herr_t         ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    LOG_OP_CALL("H5FD_mirror_close");
+    LOG_OP_CALL(FUNC);
 
     /* Sanity check */
     HDassert(file);
@@ -1541,68 +1577,59 @@ H5FD_mirror_close(H5FD_t *_file)
     file->xmit.xmit_count = (file->xmit_i)++;
     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)
-    {
+    xmit_buf = H5FL_BLK_MALLOC(xmit, H5FD_MIRROR_XMIT_BUFFER_MAX);
+    if(NULL == xmit_buf)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "unable to allocate xmit buffer");
+
+    if(H5FD_mirror_xmit_encode_header(xmit_buf, &(file->xmit)) != H5FD_MIRROR_XMIT_HEADER_SIZE)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to encode close");
-    }
     xmit_encoded = 1;
 
     LOG_XMIT_BYTES("close", xmit_buf, H5FD_MIRROR_XMIT_HEADER_SIZE);
 
-    if (HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_HEADER_SIZE) < 0) {
+    if(HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_HEADER_SIZE) < 0)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to transmit close");
-    }
 
-    if (H5FD__mirror_verify_reply(file) == FAIL) {
+    if(H5FD__mirror_verify_reply(file) == FAIL)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid reply");
-    }
 
-    if (HDclose(file->sock_fd) < 0) {
+    if(HDclose(file->sock_fd) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "can't close socket");
-    }
 
 done:
-    if (ret_value == FAIL) {
-        if (xmit_encoded == 0) {
+    if(ret_value == FAIL) {
+        if(xmit_encoded == 0) {
             /* Encode failed; send GOODBYE to force writer halt.
              * We can ignore any response from the writer, if we receive
              * any reply at all.
              */
-            if (HDwrite(file->sock_fd, "GOODBYE", HDstrlen("GOODBYE")) < 0) {
-                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");
-                }
+            if(HDwrite(file->sock_fd, "GOODBYE", HDstrlen("GOODBYE")) < 0) {
+                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");
                 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",
-                            HDstrerror(errno));
-            } /* end else-if problem shutting down socket */
+            if(HDshutdown(file->sock_fd, SHUT_WR) < 0)
+                HDONE_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "can't shutdown socket write: %s", HDstrerror(errno));
         } /* 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");
-            }
-        } /* end if socket not closed by going down hard */
+        if(file->sock_fd >= 0)
+            if(HDclose(file->sock_fd) < 0)
+                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "can't close socket");
     } /* end if error */
 
     file = H5FL_FREE(H5FD_mirror_t, file); /* always release resources */
 
+    if(xmit_buf)
+        xmit_buf = H5FL_BLK_FREE(xmit, xmit_buf);
+
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_mirror_close() */
+} /* end H5FD__mirror_close() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_mirror_query
+ * Function:    H5FD__mirror_query
  *
  * Purpose:     Get the driver feature flags implemented by the driver.
  *
@@ -1610,11 +1637,11 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_mirror_query(const H5FD_t H5_ATTR_UNUSED *_file, unsigned long *flags)
+H5FD__mirror_query(const H5FD_t H5_ATTR_UNUSED *_file, unsigned long *flags)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR;
+    FUNC_ENTER_STATIC_NOERR;
 
-    LOG_OP_CALL("H5FD_mirror_query");
+    LOG_OP_CALL(FUNC);
 
     /* Notice: the Mirror VFD Writer currently uses only the Sec2 driver as
      * the underying driver -- as such, the Mirror VFD implementation copies
@@ -1624,23 +1651,21 @@ H5FD_mirror_query(const H5FD_t H5_ATTR_UNUSED *_file, unsigned long *flags)
      * is never included.
      * -- JOS 2020-01-13
      */
-    if (flags) {
-        *flags = 0                                      \
-               | H5FD_FEAT_AGGREGATE_METADATA           \
+    if(flags)
+        *flags = 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() */
+} /* end H5FD__mirror_query() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_mirror_get_eoa
+ * Function:    H5FD__mirror_get_eoa
  *
  * Purpose:     Gets the end-of-address marker for the file. The EOA marker
  *              is the first address past the last byte allocated in the
@@ -1652,22 +1677,22 @@ H5FD_mirror_query(const H5FD_t H5_ATTR_UNUSED *_file, unsigned long *flags)
  *-------------------------------------------------------------------------
  */
 static haddr_t
-H5FD_mirror_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
+H5FD__mirror_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
     const H5FD_mirror_t *file = (const H5FD_mirror_t *)_file;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
-    LOG_OP_CALL("H5FD_mirror_get_eoa");
+    LOG_OP_CALL(FUNC);
 
     HDassert(file);
 
     FUNC_LEAVE_NOAPI(file->eoa)
-} /* end H5FD_mirror_get_eoa() */
+} /* end H5FD__mirror_get_eoa() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_mirror_set_eoa
+ * Function:    H5FD__mirror_set_eoa
  *
  * Purpose:     Set the end-of-address marker for the file. This function is
  *              called shortly after an existing HDF5 file is opened in order
@@ -1677,16 +1702,16 @@ 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_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];
+    unsigned char      *xmit_buf  = NULL;
     H5FD_mirror_t      *file      = (H5FD_mirror_t *)_file;
     herr_t              ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    LOG_OP_CALL("H5FD_mirror_set_eoa");
+    LOG_OP_CALL(FUNC);
 
     HDassert(file);
 
@@ -1699,31 +1724,31 @@ H5FD_mirror_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr)
     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)
-    {
+    xmit_buf = H5FL_BLK_MALLOC(xmit, H5FD_MIRROR_XMIT_BUFFER_MAX);
+    if(NULL == xmit_buf)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "unable to allocate xmit buffer");
+
+    if(H5FD_mirror_xmit_encode_set_eoa(xmit_buf, &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");
-    }
+    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");
 
-    if (H5FD__mirror_verify_reply(file) == FAIL) {
+    if(H5FD__mirror_verify_reply(file) == FAIL)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid reply");
-    }
 
 done:
+    if(xmit_buf)
+        xmit_buf = H5FL_BLK_FREE(xmit, xmit_buf);
+
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_mirror_set_eoa() */
+} /* end H5FD__mirror_set_eoa() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_mirror_get_eof
+ * Function:    H5FD__mirror_get_eof
  *
  * Purpose:     Returns the end-of-file marker, which is the greater of
  *              either the filesystem end-of-file or the HDF5 end-of-address
@@ -1736,49 +1761,43 @@ done:
  *-------------------------------------------------------------------------
  */
 static haddr_t
-H5FD_mirror_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
+H5FD__mirror_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
     const H5FD_mirror_t *file = (const H5FD_mirror_t *)_file;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
-    LOG_OP_CALL("H5FD_mirror_get_eof");
+    LOG_OP_CALL(FUNC);
 
     HDassert(file);
 
     FUNC_LEAVE_NOAPI(file->eof)
-} /* end H5FD_mirror_get_eof() */
+} /* end H5FD__mirror_get_eof() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_mirror_read
+ * Function:    H5FD__mirror_read
  *
- * Purpose:     Required to register the driver.
- *              If called, MUST fail.
+ * Purpose:     Required to register the driver, but if called, MUST fail.
  *
  * Return:      FAIL
  *-------------------------------------------------------------------------
  */
 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;
+    FUNC_ENTER_STATIC_NOERR
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    LOG_OP_CALL(FUNC);
 
-    LOG_OP_CALL("H5FD_mirror_read");
-
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_mirror_read() */
+    FUNC_LEAVE_NOAPI(FAIL)
+} /* end H5FD__mirror_read() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_mirror_write
+ * Function:    H5FD__mirror_write
  *
  * Purpose:     Writes SIZE bytes of data to FILE beginning at address ADDR
  *              from buffer BUF according to data transfer properties in
@@ -1795,21 +1814,17 @@ 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];
+    unsigned char              *xmit_buf = NULL;
     H5FD_mirror_t              *file        = (H5FD_mirror_t *)_file;
     herr_t                      ret_value   = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    LOG_OP_CALL("H5FD_mirror_write");
+    LOG_OP_CALL(FUNC);
 
     HDassert(file);
     HDassert(buf);
@@ -1822,43 +1837,41 @@ H5FD_mirror_write(H5FD_t               *_file,
     xmit_write.offset = (uint64_t)addr;
     xmit_write.type = (uint8_t)type;
 
+    xmit_buf = H5FL_BLK_MALLOC(xmit, H5FD_MIRROR_XMIT_BUFFER_MAX);
+    if(NULL == xmit_buf)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "unable to allocate xmit buffer");
 
     /* 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, &xmit_write) != H5FD_MIRROR_XMIT_WRITE_SIZE)
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to encode write");
-    }
 
     LOG_XMIT_BYTES("write", xmit_buf, H5FD_MIRROR_XMIT_WRITE_SIZE);
 
-    if (HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_WRITE_SIZE) < 0) {
+    if(HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_WRITE_SIZE) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to transmit write");
-    }
 
     /* Check that our write xmission was received */
-    if (H5FD__mirror_verify_reply(file) == FAIL) {
+    if(H5FD__mirror_verify_reply(file) == FAIL)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid reply");
-    }
 
     /* Send the data to be written */
-    if (HDwrite(file->sock_fd, buf, size) < 0) {
+    if(HDwrite(file->sock_fd, buf, size) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to transmit data");
-    }
 
     /* Writer should reply that it got the data and is still okay/ready */
-    if (H5FD__mirror_verify_reply(file) == FAIL) {
+    if(H5FD__mirror_verify_reply(file) == FAIL)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid reply");
-    }
 
 done:
+    if(xmit_buf)
+        xmit_buf = H5FL_BLK_FREE(xmit, xmit_buf);
+
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_mirror_write() */
+} /* end H5FD__mirror_write() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_mirror_truncate
+ * Function:    H5FD__mirror_truncate
  *
  * Purpose:     Makes sure that the true file size is the same (or larger)
  *              than the end-of-address.
@@ -1867,45 +1880,45 @@ 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];
+    unsigned char      *xmit_buf = NULL;
     H5FD_mirror_t      *file = (H5FD_mirror_t *)_file;
     herr_t      ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    LOG_OP_CALL("H5FD_mirror_truncate");
+    LOG_OP_CALL(FUNC);
 
     file->xmit.xmit_count = (file->xmit_i)++;
     file->xmit.op = H5FD_MIRROR_OP_TRUNCATE;
 
-    if (H5FD_mirror_xmit_encode_header(xmit_buf, &(file->xmit))
-        != H5FD_MIRROR_XMIT_HEADER_SIZE)
-    {
+    xmit_buf = H5FL_BLK_MALLOC(xmit, H5FD_MIRROR_XMIT_BUFFER_MAX);
+    if(NULL == xmit_buf)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "unable to allocate xmit buffer");
+
+    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");
-    }
+    if(HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_HEADER_SIZE) < 0)
+        HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to transmit truncate");
 
-    if (H5FD__mirror_verify_reply(file) == FAIL) {
+    if(H5FD__mirror_verify_reply(file) == FAIL)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid reply");
-    }
 
 done:
+    if(xmit_buf)
+        xmit_buf = H5FL_BLK_FREE(xmit, xmit_buf);
+
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_mirror_truncate() */
+} /* end H5FD__mirror_truncate() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_mirror_lock
+ * Function:    H5FD__mirror_lock
  *
  * Purpose:     To place an advisory lock on a file.
  *              The lock type to apply depends on the parameter "rw":
@@ -1916,16 +1929,16 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_mirror_lock(H5FD_t *_file, hbool_t rw)
+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];
+    unsigned char      *xmit_buf = NULL;
     H5FD_mirror_t      *file = (H5FD_mirror_t *)_file;
     herr_t ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT;
+    FUNC_ENTER_STATIC
 
-    LOG_OP_CALL("H5FD_mirror_lock");
+    LOG_OP_CALL(FUNC);
 
     file->xmit.xmit_count = (file->xmit_i)++;
     file->xmit.op = H5FD_MIRROR_OP_LOCK;
@@ -1933,30 +1946,31 @@ H5FD_mirror_lock(H5FD_t *_file, hbool_t rw)
     xmit_lock.pub = file->xmit;
     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)
-    {
+    xmit_buf = H5FL_BLK_MALLOC(xmit, H5FD_MIRROR_XMIT_BUFFER_MAX);
+    if(NULL == xmit_buf)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "unable to allocate xmit buffer");
+
+    if(H5FD_mirror_xmit_encode_lock(xmit_buf, &xmit_lock) != H5FD_MIRROR_XMIT_LOCK_SIZE)
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to encode lock");
-    }
 
     LOG_XMIT_BYTES("lock", xmit_buf, H5FD_MIRROR_XMIT_LOCK_SIZE);
 
-    if (HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_LOCK_SIZE) < 0) {
+    if(HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_LOCK_SIZE) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to transmit lock");
-    }
 
-    if (H5FD__mirror_verify_reply(file) == FAIL) {
+    if(H5FD__mirror_verify_reply(file) == FAIL)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid reply");
-    }
 
 done:
+    if(xmit_buf)
+        xmit_buf = H5FL_BLK_FREE(xmit, xmit_buf);
+
     FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5FD_mirror_lock */
+} /* end H5FD__mirror_lock */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_mirror_unlock
+ * Function:    H5FD__mirror_unlock
  *
  * Purpose:     Remove the existing lock on the file.
  *
@@ -1964,38 +1978,40 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_mirror_unlock(H5FD_t *_file)
+H5FD__mirror_unlock(H5FD_t *_file)
 {
-    unsigned char       xmit_buf[H5FD_MIRROR_XMIT_HEADER_SIZE];
+    unsigned char      *xmit_buf = NULL;
     H5FD_mirror_t      *file = (H5FD_mirror_t *)_file;
     herr_t ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT;
+    FUNC_ENTER_STATIC
 
-    LOG_OP_CALL("H5FD_mirror_unlock");
+    LOG_OP_CALL(FUNC);
 
     file->xmit.xmit_count = (file->xmit_i)++;
     file->xmit.op = H5FD_MIRROR_OP_UNLOCK;
 
-    if (H5FD_mirror_xmit_encode_header(xmit_buf, &(file->xmit))
-        != H5FD_MIRROR_XMIT_HEADER_SIZE)
-    {
+    xmit_buf = H5FL_BLK_MALLOC(xmit, H5FD_MIRROR_XMIT_BUFFER_MAX);
+    if(NULL == xmit_buf)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "unable to allocate xmit buffer");
+
+    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");
-    }
 
     LOG_XMIT_BYTES("unlock", xmit_buf, H5FD_MIRROR_XMIT_HEADER_SIZE);
 
-    if (HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_HEADER_SIZE) < 0) {
+    if(HDwrite(file->sock_fd, xmit_buf, H5FD_MIRROR_XMIT_HEADER_SIZE) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "unable to transmit unlock");
-    }
 
-    if (H5FD__mirror_verify_reply(file) == FAIL) {
+    if(H5FD__mirror_verify_reply(file) == FAIL)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid reply");
-    }
 
 done:
+    if(xmit_buf)
+        xmit_buf = H5FL_BLK_FREE(xmit, xmit_buf);
+
     FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5FD_mirror_unlock */
+} /* end H5FD__mirror_unlock */
 
 #endif /* H5_HAVE_MIRROR_VFD */