Merge branch 'develop' into feature/coding_standardsfeature/coding_standards

1 files changed, 568 insertions, 1103 deletions

diff --git a/src/H5FDhdfs.c b/src/H5FDhdfs.c
index 83d0202..53c63f7 100644
--- a/src/H5FDhdfs.c
+++ b/src/H5FDhdfs.c
@@ -1,15 +1,13 @@
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Read-Only HDFS Virtual File Driver (VFD)                                  *
- * Copyright (c) 2018, The HDF Group.                                        *
- *                                                                           *
+ * Copyright by The HDF Group.                                               *
  * All rights reserved.                                                      *
  *                                                                           *
- * NOTICE:                                                                   *
- * All information contained herein is, and remains, the property of The HDF *
- * Group. The intellectual and technical concepts contained herein are       *
- * proprietary to The HDF Group. Dissemination of this information or        *
- * reproduction of this material is strictly forbidden unless prior written  *
- * permission is obtained from The HDF Group.                                *
+ * This file is part of HDF5.  The full HDF5 copyright notice, including     *
+ * terms governing use, modification, and redistribution, is contained in    *
+ * the COPYING file, which can be found at the root of the source code       *
+ * distribution tree, or in https://www.hdfgroup.org/licenses.               *
+ * If you do not have access to either file, you may request a copy from     *
+ * help@hdfgroup.org.                                                        *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /*
@@ -20,20 +18,23 @@
  *             File System (HDFS).
  */
 
+#ifdef H5_HAVE_LIBHDFS
 /* This source code file is part of the H5FD driver module */
 #include "H5FDdrvr_module.h"
+#endif
 
-#include "H5private.h"      /* Generic Functions        */
-#include "H5Eprivate.h"     /* Error handling           */
-#include "H5FDprivate.h"    /* File drivers             */
-#include "H5FDhdfs.h"       /* hdfs file driver         */
-#include "H5FLprivate.h"    /* Free Lists               */
-#include "H5Iprivate.h"     /* IDs                      */
-#include "H5MMprivate.h"    /* Memory management        */
+#include "H5private.h"   /* Generic Functions        */
+#include "H5Eprivate.h"  /* Error handling           */
+#include "H5FDprivate.h" /* File drivers             */
+#include "H5FDhdfs.h"    /* hdfs file driver         */
+#include "H5FLprivate.h" /* Free Lists               */
+#include "H5Iprivate.h"  /* IDs                      */
+#include "H5MMprivate.h" /* Memory management        */
 
 #ifdef H5_HAVE_LIBHDFS
+
+/* HDFS routines */
 #include "hdfs.h"
-#endif
 
 /* toggle function call prints: 1 turns on */
 #define HDFS_DEBUG 0
@@ -59,35 +60,32 @@ static hid_t H5FD_HDFS_g = 0;
  * 2^(10+(1*16)) = 2^26 = 64MB
  *     Reads of 64MB or greater fall in "overflow" bin[BIN_COUNT]
  */
-#define HDFS_STATS_BASE         2
-#define HDFS_STATS_INTERVAL     1
+#define HDFS_STATS_BASE        2
+#define HDFS_STATS_INTERVAL    1
 #define HDFS_STATS_START_POWER 10
 #define HDFS_STATS_BIN_COUNT   16 /* MUST BE GREATER THAN 0 */
 
-
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * Calculate `BASE ^ (START_POWER + (INTERVAL * bin_i))`
  * Stores result at `(unsigned long long *) out_ptr`.
  * Used in computing boundaries between stats bins.
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  */
-#define HDFS_STATS_POW(bin_i, out_ptr) {                       \
-    unsigned long long donotshadowresult = 1;                  \
-    unsigned           donotshadowindex  = 0;                  \
-    for (donotshadowindex = 0;                                 \
-         donotshadowindex < (((bin_i) * HDFS_STATS_INTERVAL) + \
-                              HDFS_STATS_START_POWER);         \
-         donotshadowindex++)                                   \
-    {                                                          \
-        donotshadowresult *= HDFS_STATS_BASE;                  \
-    }                                                          \
-    *(out_ptr) = donotshadowresult;                            \
-}
+#define HDFS_STATS_POW(bin_i, out_ptr)                                                                       \
+    {                                                                                                        \
+        unsigned long long donotshadowresult = 1;                                                            \
+        unsigned           donotshadowindex  = 0;                                                            \
+        for (donotshadowindex = 0;                                                                           \
+             donotshadowindex < (((bin_i)*HDFS_STATS_INTERVAL) + HDFS_STATS_START_POWER);                    \
+             donotshadowindex++) {                                                                           \
+            donotshadowresult *= HDFS_STATS_BASE;                                                            \
+        }                                                                                                    \
+        *(out_ptr) = donotshadowresult;                                                                      \
+    }
 
 /* array to hold pre-computed boundaries for stats bins */
 static unsigned long long hdfs_stats_boundaries[HDFS_STATS_BIN_COUNT];
 
-
 /***************************************************************************
  *
  * Structure: hdfs_statsbin
@@ -118,8 +116,6 @@ static unsigned long long hdfs_stats_boundaries[HDFS_STATS_BIN_COUNT];
  *
  * Programmer: Jacob Smith
  *
- * Changes: None
- *
  ***************************************************************************/
 typedef struct {
     unsigned long long count;
@@ -130,14 +126,11 @@ typedef struct {
 
 #endif /* HDFS_STATS */
 
-#ifdef H5_HAVE_LIBHDFS
-
 /* "unique" identifier for `hdfs_t` structures.
  * Randomly generated by unweighted dice rolls.
  */
 #define HDFS_HDFST_MAGIC 0x1AD5DE84
 
-
 /***************************************************************************
  *
  * Structure: hdfs_t
@@ -146,9 +139,7 @@ typedef struct {
  *
  *     Contain/retain information associated with a file hosted on Hadoop
  *     Distributed File System (HDFS). Instantiated and populated via
- *     `H5FD_hdfs_handle_open()` and cleaned up via `H5FD_hdfs_handle_close()`.
- *
- *
+ *     `H5FD__hdfs_handle_open()` and cleaned up via `H5FD__hdfs_handle_close()`.
  *
  * `magic` (unisgned long)
  *
@@ -175,207 +166,15 @@ typedef struct {
  * Programmer: Jacob Smith
  *             May 2018
  *
- * Changes: None
- *
  ***************************************************************************
  */
 typedef struct {
-    unsigned long  magic;
-    hdfsFS         filesystem;
-    hdfsFileInfo  *fileinfo;
-    hdfsFile       file;
+    unsigned long magic;
+    hdfsFS        filesystem;
+    hdfsFileInfo *fileinfo;
+    hdfsFile      file;
 } hdfs_t;
 
-
-/*--------------------------------------------------------------------------
- * Function:   H5FD_hdfs_handle_open
- *
- * Purpose:    Create a HDFS file handle, 'opening' the target file.
- *
- * Return:     Success: Pointer to HDFS container/handle of opened file.
- *             Failure: NULL
- *
- * Programmer: Gerd Herber
- *             May 2018
- *
- * Changes:    None.
- *--------------------------------------------------------------------------
- */
-static hdfs_t *
-H5FD_hdfs_handle_open(
-        const char    *path,
-        const char    *namenode_name,
-        const int32_t  namenode_port,
-        const char    *user_name,
-        const char    *kerberos_ticket_cache,
-        const int32_t  stream_buffer_size)
-{
-    struct hdfsBuilder *builder   = NULL;
-    hdfs_t             *handle    = NULL;
-    hdfs_t             *ret_value = NULL;
-
-    FUNC_ENTER_NOAPI_NOINIT
-
-#if HDFS_DEBUG
-    HDfprintf(stdout, "called H5FD_hdfs_handle_open.\n");
-#endif
-
-    if (path == NULL || path[0] == '\0') {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "path cannot be null.\n")
-    }
-    if (namenode_name == NULL /* || namenode_name[0] == '\0' */ ) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "namenode name cannot be null.\n")
-    }
-    if (namenode_port < 0 || namenode_port > 65535) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "namenode port must be non-negative and <= 65535.\n")
-    }
-    if (stream_buffer_size < 0) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "buffer size must non-negative.\n")
-    }
-
-    handle = (hdfs_t *)H5MM_malloc(sizeof(hdfs_t));
-    if (handle == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_CANTALLOC, NULL,
-                    "could not malloc space for handle.\n")
-    }
-
-    handle->magic      = (unsigned long)HDFS_HDFST_MAGIC;
-    handle->filesystem = NULL; /* TODO: not a pointer; NULL may cause bug */
-    handle->fileinfo   = NULL;
-    handle->file       = NULL; /* TODO: not a pointer; NULL may cause bug */
-
-    builder = hdfsNewBuilder();
-    if (!builder) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "(hdfs) failed to create builder")
-    }
-    hdfsBuilderSetNameNode(builder, namenode_name);
-    hdfsBuilderSetNameNodePort(builder, (tPort)namenode_port);
-    if (user_name != NULL && user_name[0] != '\0') {
-        hdfsBuilderSetUserName(builder, user_name);
-    }
-    if (kerberos_ticket_cache != NULL && kerberos_ticket_cache[0] != '\0') {
-        hdfsBuilderSetKerbTicketCachePath(builder, kerberos_ticket_cache);
-    }
-    /* Call to `hdfsBuilderConnect` releases builder, regardless of success. */
-    handle->filesystem = hdfsBuilderConnect(builder);
-    if (!handle->filesystem) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "(hdfs) could not connect to default namenode")
-    }
-    handle->fileinfo = hdfsGetPathInfo(handle->filesystem, path);
-    if (!handle->fileinfo) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "hdfsGetPathInfo failed")
-    }
-    handle->file = hdfsOpenFile(
-            handle->filesystem,
-            path,
-            O_RDONLY,
-            stream_buffer_size,
-            0,
-            0);
-    if (!handle->file) {
-        HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL,
-                    "(hdfs) could not open")
-    }
-
-    ret_value = handle;
-
-done:
-    if (ret_value == NULL && handle != NULL) {
-        /* error; clean up */
-        HDassert(handle->magic == HDFS_HDFST_MAGIC);
-        handle->magic++;
-        if (handle->file != NULL) {
-            if (FAIL == (hdfsCloseFile(handle->filesystem, handle->file))) {
-                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL,
-                            "unable to close hdfs file handle")
-            }
-        }
-        if (handle->fileinfo != NULL) {
-            hdfsFreeFileInfo(handle->fileinfo, 1);
-        }
-        if (handle->filesystem != NULL) {
-            if (FAIL == (hdfsDisconnect(handle->filesystem))) {
-                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL,
-                            "unable to disconnect from hdfs")
-            }
-        }
-        H5MM_xfree(handle);
-    }
-
-    FUNC_LEAVE_NOAPI(ret_value)
-
-} /* H5FD_hdfs_handle_open() */
-
-
-/*--------------------------------------------------------------------------
- * Function:   H5FD_hdfs_handle_close
- *
- * Purpose:    'Close' an HDFS file container/handle, releasing underlying
- *             resources.
- *
- * Return:     Success: `SUCCEED` (0)
- *             Failure: `FAIL` (-1)
- *
- * Programmer: Gerd Herber
- *             May 2018
- *
- * Changes:    None.
- *--------------------------------------------------------------------------
- */
-static herr_t
-H5FD_hdfs_handle_close(hdfs_t *handle)
-{
-    herr_t ret_value = SUCCEED;
-
-    FUNC_ENTER_NOAPI_NOINIT
-
-#if HDFS_DEBUG
-    HDfprintf(stdout, "called H5FD_hdfs_close.\n");
-#endif
-
-    if (handle == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "handle cannot be null.\n")
-    }
-    if (handle->magic != HDFS_HDFST_MAGIC) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "handle has invalid magic.\n")
-    }
-
-    handle->magic++;
-    if (handle->file != NULL) {
-        if (FAIL == (hdfsCloseFile(handle->filesystem, handle->file))) {
-            HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL,
-                        "unable to close hdfs file handle")
-        }
-    }
-    if (handle->fileinfo != NULL) {
-        hdfsFreeFileInfo(handle->fileinfo, 1);
-    }
-    if (handle->filesystem != NULL) {
-        if (FAIL == (hdfsDisconnect(handle->filesystem))) {
-            HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL,
-                        "unable to disconnect hdfs file system")
-        }
-    }
-
-    H5MM_xfree(handle);
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-
-} /* H5FD_hdfs_close() */
-
-#endif /* H5_HAVE_LIBHDFS */
-
-
 /***************************************************************************
  *
  * Structure: H5FD_hdfs_t
@@ -432,20 +231,15 @@ done:
  *
  * Programmer: Jacob Smith
  *
- * Changes: None.
- *
- ***************************************************************************
- */
+ ***************************************************************************/
 typedef struct H5FD_hdfs_t {
-    H5FD_t            pub;
-    H5FD_hdfs_fapl_t  fa;
-    haddr_t           eoa;
-#ifdef H5_HAVE_LIBHDFS
-    hdfs_t           *hdfs_handle;
-#endif
+    H5FD_t           pub;
+    H5FD_hdfs_fapl_t fa;
+    haddr_t          eoa;
+    hdfs_t *         hdfs_handle;
 #if HDFS_STATS
-    hdfs_statsbin     meta[HDFS_STATS_BIN_COUNT + 1];
-    hdfs_statsbin     raw[HDFS_STATS_BIN_COUNT + 1];
+    hdfs_statsbin meta[HDFS_STATS_BIN_COUNT + 1];
+    hdfs_statsbin raw[HDFS_STATS_BIN_COUNT + 1];
 #endif
 } H5FD_hdfs_t;
 
@@ -459,107 +253,76 @@ typedef struct H5FD_hdfs_t {
  *                  Only included if HDFS code should compile.
  *
  */
-#define MAXADDR (((haddr_t)1<<(8*sizeof(HDoff_t)-1))-1)
-#ifdef H5_HAVE_LIBHDFS
-#define ADDR_OVERFLOW(A)    (HADDR_UNDEF==(A) || ((A) & ~(haddr_t)MAXADDR))
-#endif /* H5_HAVE_LIBHDFS */
+#define MAXADDR          (((haddr_t)1 << (8 * sizeof(HDoff_t) - 1)) - 1)
+#define ADDR_OVERFLOW(A) (HADDR_UNDEF == (A) || ((A) & ~(haddr_t)MAXADDR))
 
 /* Prototypes */
-static herr_t  H5FD_hdfs_term(void);
-static void   *H5FD_hdfs_fapl_get(H5FD_t *_file);
-static void   *H5FD_hdfs_fapl_copy(const void *_old_fa);
-static herr_t  H5FD_hdfs_fapl_free(void *_fa);
-static H5FD_t *H5FD_hdfs_open(const char *name, unsigned flags, hid_t fapl_id,
-                              haddr_t maxaddr);
-static herr_t  H5FD_hdfs_close(H5FD_t *_file);
-static int     H5FD_hdfs_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
-static herr_t  H5FD_hdfs_query(const H5FD_t *_f1, unsigned long *flags);
-static haddr_t H5FD_hdfs_get_eoa(const H5FD_t *_file, H5FD_mem_t type);
-static herr_t  H5FD_hdfs_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr);
-static haddr_t H5FD_hdfs_get_eof(const H5FD_t *_file, H5FD_mem_t type);
-static herr_t  H5FD_hdfs_get_handle(H5FD_t *_file, hid_t fapl,
-                                    void** file_handle);
-static herr_t  H5FD_hdfs_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id,
-                               haddr_t addr, size_t size, void *buf);
-static herr_t  H5FD_hdfs_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_hdfs_truncate(H5FD_t *_file, hid_t dxpl_id,
-                                  hbool_t closing);
-static herr_t  H5FD_hdfs_lock(H5FD_t *_file, hbool_t rw);
-static herr_t  H5FD_hdfs_unlock(H5FD_t *_file);
-static herr_t  H5FD_hdfs_validate_config(const H5FD_hdfs_fapl_t * fa);
+static herr_t  H5FD__hdfs_term(void);
+static void *  H5FD__hdfs_fapl_get(H5FD_t *_file);
+static void *  H5FD__hdfs_fapl_copy(const void *_old_fa);
+static herr_t  H5FD__hdfs_fapl_free(void *_fa);
+static H5FD_t *H5FD__hdfs_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr);
+static herr_t  H5FD__hdfs_close(H5FD_t *_file);
+static int     H5FD__hdfs_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
+static herr_t  H5FD__hdfs_query(const H5FD_t *_f1, unsigned long *flags);
+static haddr_t H5FD__hdfs_get_eoa(const H5FD_t *_file, H5FD_mem_t type);
+static herr_t  H5FD__hdfs_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr);
+static haddr_t H5FD__hdfs_get_eof(const H5FD_t *_file, H5FD_mem_t type);
+static herr_t  H5FD__hdfs_get_handle(H5FD_t *_file, hid_t fapl, void **file_handle);
+static herr_t  H5FD__hdfs_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size,
+                               void *buf);
+static herr_t  H5FD__hdfs_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__hdfs_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
+
+static herr_t H5FD__hdfs_validate_config(const H5FD_hdfs_fapl_t *fa);
 
 static const H5FD_class_t H5FD_hdfs_g = {
-    "hdfs",                     /* name                 */
-    MAXADDR,                    /* maxaddr              */
-    H5F_CLOSE_WEAK,             /* fc_degree            */
-    H5FD_hdfs_term,             /* terminate            */
-    NULL,                       /* sb_size              */
-    NULL,                       /* sb_encode            */
-    NULL,                       /* sb_decode            */
-    sizeof(H5FD_hdfs_fapl_t),   /* fapl_size            */
-    H5FD_hdfs_fapl_get,         /* fapl_get             */
-    H5FD_hdfs_fapl_copy,        /* fapl_copy            */
-    H5FD_hdfs_fapl_free,        /* fapl_free            */
-    0,                          /* dxpl_size            */
-    NULL,                       /* dxpl_copy            */
-    NULL,                       /* dxpl_free            */
-    H5FD_hdfs_open,             /* open                 */
-    H5FD_hdfs_close,            /* close                */
-    H5FD_hdfs_cmp,              /* cmp                  */
-    H5FD_hdfs_query,            /* query                */
-    NULL,                       /* get_type_map         */
-    NULL,                       /* alloc                */
-    NULL,                       /* free                 */
-    H5FD_hdfs_get_eoa,          /* get_eoa              */
-    H5FD_hdfs_set_eoa,          /* set_eoa              */
-    H5FD_hdfs_get_eof,          /* get_eof              */
-    H5FD_hdfs_get_handle,       /* get_handle           */
-    H5FD_hdfs_read,             /* read                 */
-    H5FD_hdfs_write,            /* write                */
-    NULL,                       /* flush                */
-    H5FD_hdfs_truncate,         /* truncate             */
-    H5FD_hdfs_lock,             /* lock                 */
-    H5FD_hdfs_unlock,           /* unlock               */
-    H5FD_FLMAP_DICHOTOMY        /* fl_map               */
+    H5FD_CLASS_VERSION,       /* struct version       */
+    H5FD_HDFS_VALUE,          /* value                */
+    "hdfs",                   /* name                 */
+    MAXADDR,                  /* maxaddr              */
+    H5F_CLOSE_WEAK,           /* fc_degree            */
+    H5FD__hdfs_term,          /* terminate            */
+    NULL,                     /* sb_size              */
+    NULL,                     /* sb_encode            */
+    NULL,                     /* sb_decode            */
+    sizeof(H5FD_hdfs_fapl_t), /* fapl_size            */
+    H5FD__hdfs_fapl_get,      /* fapl_get             */
+    H5FD__hdfs_fapl_copy,     /* fapl_copy            */
+    H5FD__hdfs_fapl_free,     /* fapl_free            */
+    0,                        /* dxpl_size            */
+    NULL,                     /* dxpl_copy            */
+    NULL,                     /* dxpl_free            */
+    H5FD__hdfs_open,          /* open                 */
+    H5FD__hdfs_close,         /* close                */
+    H5FD__hdfs_cmp,           /* cmp                  */
+    H5FD__hdfs_query,         /* query                */
+    NULL,                     /* get_type_map         */
+    NULL,                     /* alloc                */
+    NULL,                     /* free                 */
+    H5FD__hdfs_get_eoa,       /* get_eoa              */
+    H5FD__hdfs_set_eoa,       /* set_eoa              */
+    H5FD__hdfs_get_eof,       /* get_eof              */
+    H5FD__hdfs_get_handle,    /* get_handle           */
+    H5FD__hdfs_read,          /* read                 */
+    H5FD__hdfs_write,         /* write                */
+    NULL,                     /* read_vector          */
+    NULL,                     /* write_vector         */
+    NULL,                     /* read_selection       */
+    NULL,                     /* write_selection      */
+    NULL,                     /* flush                */
+    H5FD__hdfs_truncate,      /* truncate             */
+    NULL,                     /* lock                 */
+    NULL,                     /* unlock               */
+    NULL,                     /* del                  */
+    NULL,                     /* ctl                  */
+    H5FD_FLMAP_DICHOTOMY      /* fl_map               */
 };
 
-#ifdef H5_HAVE_LIBHDFS
 /* Declare a free list to manage the H5FD_hdfs_t struct */
 H5FL_DEFINE_STATIC(H5FD_hdfs_t);
-#endif /* H5_HAVE_LIBHDFS */
-
-
-/*-------------------------------------------------------------------------
- * Function:    H5FD__init_package
- *
- * Purpose:     Initializes any interface-specific data or routines.
- *
- * Return:      Non-negative on success/Negative on failure
- *
- * Changes:     Rename as appropriate for hdfs vfd.
- *              Jacob Smith 2018
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5FD__init_package(void)
-{
-    herr_t ret_value = SUCCEED;
 
-    FUNC_ENTER_STATIC
-
-    if (H5FD_hdfs_init() < 0) {
-        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL,
-                    "unable to initialize hdfs VFD")
-    }
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-
-} /* H5FD__init_package() */
-
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_hdfs_init
  *
@@ -569,37 +332,33 @@ done:
  * Return:      Success:    The driver ID for the hdfs driver.
  *              Failure:    Negative
  *
- * Programmer:  Robb Matzke
- *              Thursday, July 29, 1999
- *
- * Changes:     Rename as appropriate for hdfs vfd.
- *              Jacob Smith 2018
+ * Programmer:  Jacob Smith, 2018
  *
  *-------------------------------------------------------------------------
  */
 hid_t
 H5FD_hdfs_init(void)
 {
-    hid_t ret_value = H5I_INVALID_HID; /* Return value */
+    hid_t ret_value = H5I_INVALID_HID;
+#if HDFS_STATS
+    unsigned int bin_i;
+#endif
 
-    FUNC_ENTER_NOAPI(FAIL)
+    FUNC_ENTER_NOAPI(H5I_INVALID_HID)
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_init() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif
 
-    if (H5I_VFL != H5I_get_type(H5FD_HDFS_g)) {
-        H5FD_HDFS_g = H5FD_register(
-                &H5FD_hdfs_g,
-                sizeof(H5FD_class_t),
-                FALSE);
-    }
+    if (H5I_VFL != H5I_get_type(H5FD_HDFS_g))
+        H5FD_HDFS_g = H5FD_register(&H5FD_hdfs_g, sizeof(H5FD_class_t), FALSE);
 
 #if HDFS_STATS
     /* pre-compute statsbin boundaries
      */
-    for (unsigned bin_i = 0; bin_i < HDFS_STATS_BIN_COUNT; bin_i++) {
+    for (bin_i = 0; bin_i < HDFS_STATS_BIN_COUNT; bin_i++) {
         unsigned long long value = 0;
+
         HDFS_STATS_POW(bin_i, &value)
         hdfs_stats_boundaries[bin_i] = value;
     }
@@ -609,12 +368,10 @@ H5FD_hdfs_init(void)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-
 } /* end H5FD_hdfs_init() */
 
-
 /*---------------------------------------------------------------------------
- * Function:    H5FD_hdfs_term
+ * Function:    H5FD__hdfs_term
  *
  * Purpose:     Shut down the VFD
  *
@@ -623,131 +380,239 @@ done:
  * Programmer:  Quincey Koziol
  *              Friday, Jan 30, 2004
  *
- * Changes:     Rename as appropriate for hdfs vfd.
- *              Jacob Smith 2018
- *
  *---------------------------------------------------------------------------
  */
 static herr_t
-H5FD_hdfs_term(void)
+H5FD__hdfs_term(void)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_term() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif
 
     /* Reset VFL ID */
     H5FD_HDFS_g = 0;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5FD_hdfs_term() */
+} /* end H5FD__hdfs_term() */
 
-
-/*-------------------------------------------------------------------------
- * Function:    H5Pset_fapl_hdfs
- *
- * Purpose:     Modify the file access property list to use the H5FD_HDFS
- *              driver defined in this source file.  All driver specfic
- *              properties are passed in as a pointer to a suitably
- *              initialized instance of H5FD_hdfs_fapl_t
+/*--------------------------------------------------------------------------
+ * Function:   H5FD__hdfs_handle_open
  *
- * Return:      SUCCEED/FAIL
+ * Purpose:    Create a HDFS file handle, 'opening' the target file.
  *
- * Programmer:  John Mainzer
- *              9/10/17
+ * Return:     Success: Pointer to HDFS container/handle of opened file.
+ *             Failure: NULL
  *
- * Changes:     Rename as appropriate for hdfs vfd.
- *              Jacob Smith 2018
+ * Programmer: Gerd Herber
+ *             May 2018
  *
- *-------------------------------------------------------------------------
+ *--------------------------------------------------------------------------
  */
-herr_t
-H5Pset_fapl_hdfs(hid_t             fapl_id,
-                 H5FD_hdfs_fapl_t *fa)
+static hdfs_t *
+H5FD__hdfs_handle_open(const char *path, const char *namenode_name, const int32_t namenode_port,
+                       const char *user_name, const char *kerberos_ticket_cache,
+                       const int32_t stream_buffer_size)
 {
-    H5P_genplist_t *plist     = NULL; /* Property list pointer */
-    herr_t          ret_value = FAIL;
-
-    FUNC_ENTER_API(FAIL)
-    H5TRACE2("e", "i*x", fapl_id, fa);
+    struct hdfsBuilder *builder   = NULL;
+    hdfs_t *            handle    = NULL;
+    hdfs_t *            ret_value = NULL;
 
-    HDassert(fa != NULL);
+    FUNC_ENTER_PACKAGE
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5Pset_fapl_hdfs() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif
 
-    plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS);
-    if (plist == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, \
-                    "not a file access property list")
-    }
+    if (path == NULL || path[0] == '\0')
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "path cannot be null")
+    if (namenode_name == NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "namenode name cannot be null")
+    if (namenode_port < 0 || namenode_port > 65535)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "namenode port must be non-negative and <= 65535")
+    if (stream_buffer_size < 0)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "buffer size must non-negative")
 
-    if (FAIL == H5FD_hdfs_validate_config(fa)) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "invalid hdfs config")
-    }
+    handle = (hdfs_t *)H5MM_malloc(sizeof(hdfs_t));
+    if (handle == NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_CANTALLOC, NULL, "could not malloc space for handle")
+
+    handle->magic      = (unsigned long)HDFS_HDFST_MAGIC;
+    handle->filesystem = NULL; /* TODO: not a pointer; NULL may cause bug */
+    handle->fileinfo   = NULL;
+    handle->file       = NULL; /* TODO: not a pointer; NULL may cause bug */
+
+    builder = hdfsNewBuilder();
+    if (!builder)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "(hdfs) failed to create builder")
+    hdfsBuilderSetNameNode(builder, namenode_name);
+    hdfsBuilderSetNameNodePort(builder, (tPort)namenode_port);
+    if (user_name != NULL && user_name[0] != '\0')
+        hdfsBuilderSetUserName(builder, user_name);
+    if (kerberos_ticket_cache != NULL && kerberos_ticket_cache[0] != '\0')
+        hdfsBuilderSetKerbTicketCachePath(builder, kerberos_ticket_cache);
 
-    ret_value = H5P_set_driver(plist, H5FD_HDFS, (void *)fa);
+    /* Call to `hdfsBuilderConnect` releases builder, regardless of success. */
+    handle->filesystem = hdfsBuilderConnect(builder);
+    if (!handle->filesystem)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "(hdfs) could not connect to default namenode")
+    handle->fileinfo = hdfsGetPathInfo(handle->filesystem, path);
+    if (!handle->fileinfo)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "hdfsGetPathInfo failed")
+    handle->file = hdfsOpenFile(handle->filesystem, path, O_RDONLY, stream_buffer_size, 0, 0);
+    if (!handle->file)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL, "(hdfs) could not open")
+
+    ret_value = handle;
 
 done:
-    FUNC_LEAVE_API(ret_value)
+    if (ret_value == NULL && handle != NULL) {
+        /* error; clean up */
+        HDassert(handle->magic == HDFS_HDFST_MAGIC);
+        handle->magic++;
+        if (handle->file != NULL)
+            if (FAIL == (hdfsCloseFile(handle->filesystem, handle->file)))
+                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to close hdfs file handle")
+        if (handle->fileinfo != NULL)
+            hdfsFreeFileInfo(handle->fileinfo, 1);
+        if (handle->filesystem != NULL)
+            if (FAIL == (hdfsDisconnect(handle->filesystem)))
+                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to disconnect from hdfs")
+        H5MM_xfree(handle);
+    }
 
-} /* H5Pset_fapl_hdfs() */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FD__hdfs_handle_open() */
+
+/*--------------------------------------------------------------------------
+ * Function:   H5FD__hdfs_handle_close
+ *
+ * Purpose:    'Close' an HDFS file container/handle, releasing underlying
+ *             resources.
+ *
+ * Return:     Success: `SUCCEED` (0)
+ *             Failure: `FAIL` (-1)
+ *
+ * Programmer: Gerd Herber
+ *             May 2018
+ *
+ *--------------------------------------------------------------------------
+ */
+static herr_t
+H5FD__hdfs_handle_close(hdfs_t *handle)
+{
+    herr_t ret_value = SUCCEED;
+
+    FUNC_ENTER_PACKAGE
+
+#if HDFS_DEBUG
+    HDfprintf(stdout, "called %s.\n", __func__);
+#endif
+
+    if (handle == NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "handle cannot be null")
+    if (handle->magic != HDFS_HDFST_MAGIC)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "handle has invalid magic")
+
+    handle->magic++;
+    if (handle->file != NULL)
+        if (FAIL == (hdfsCloseFile(handle->filesystem, handle->file)))
+            HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close hdfs file handle")
+    if (handle->fileinfo != NULL)
+        hdfsFreeFileInfo(handle->fileinfo, 1);
+    if (handle->filesystem != NULL)
+        if (FAIL == (hdfsDisconnect(handle->filesystem)))
+            HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to disconnect hdfs file system")
+
+    H5MM_xfree(handle);
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FD__hdfs_handle_close() */
 
-
 /*-------------------------------------------------------------------------
- * Function:    H5FD_hdfs_validate_config()
+ * Function:    H5FD__hdfs_validate_config()
  *
  * Purpose:     Test to see if the supplied instance of H5FD_hdfs_fapl_t
- *              contains internally consistant data.  Return SUCCEED if so,
+ *              contains internally consistent data.  Return SUCCEED if so,
  *              and FAIL otherwise.
  *
- *              Note the difference between internally consistant and
+ *              Note the difference between internally consistent and
  *              correct.  As we will have to try to access the target
  *              object to determine whether the supplied data is correct,
- *              we will settle for internal consistancy at this point
+ *              we will settle for internal consistency at this point
  *
  * Return:      SUCCEED if instance of H5FD_hdfs_fapl_t contains internally
- *              consistant data, FAIL otherwise.
+ *              consistent data, FAIL otherwise.
  *
  * Programmer:  Jacob Smith
  *              9/10/17
  *
- * Changes:     None.
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_hdfs_validate_config(const H5FD_hdfs_fapl_t * fa)
+H5FD__hdfs_validate_config(const H5FD_hdfs_fapl_t *fa)
 {
     herr_t ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
     HDassert(fa != NULL);
 
-    if ( fa->version != H5FD__CURR_HDFS_FAPL_T_VERSION ) {
-         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                     "Unknown H5FD_hdfs_fapl_t version");
-    }
-
-    if ( fa->namenode_port > 65535 ) {
-         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                     "Invalid namenode port number");
-    }
-    if ( fa->namenode_port < 0 ) {
-         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                     "Invalid namenode port number");
-    }
+    if (fa->version != H5FD__CURR_HDFS_FAPL_T_VERSION)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Unknown H5FD_hdfs_fapl_t version");
+    if (fa->namenode_port > 65535)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Invalid namenode port number");
+    if (fa->namenode_port < 0)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Invalid namenode port number");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FD__hdfs_validate_config() */
+
+/*-------------------------------------------------------------------------
+ * Function:    H5Pset_fapl_hdfs
+ *
+ * Purpose:     Modify the file access property list to use the H5FD_HDFS
+ *              driver defined in this source file.  All driver specific
+ *              properties are passed in as a pointer to a suitably
+ *              initialized instance of H5FD_hdfs_fapl_t
+ *
+ * Return:      SUCCEED/FAIL
+ *
+ * Programmer:  John Mainzer
+ *              9/10/17
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Pset_fapl_hdfs(hid_t fapl_id, H5FD_hdfs_fapl_t *fa)
+{
+    H5P_genplist_t *plist     = NULL; /* Property list pointer */
+    herr_t          ret_value = FAIL;
 
-} /* H5FD_hdfs_validate_config() */
+    FUNC_ENTER_API(FAIL)
+    H5TRACE2("e", "i*#", fapl_id, fa);
+
+    HDassert(fa != NULL);
+
+#if HDFS_DEBUG
+    HDfprintf(stdout, "called %s.\n", __func__);
+#endif
+
+    plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS);
+    if (plist == NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list")
+    if (FAIL == H5FD__hdfs_validate_config(fa))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid hdfs config")
+
+    ret_value = H5P_set_driver(plist, H5FD_HDFS, (void *)fa, NULL);
+
+done:
+    FUNC_LEAVE_API(ret_value)
+} /* H5Pset_fapl_hdfs() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5Pget_fapl_hdfs
  *
@@ -761,56 +626,44 @@ done:
  * Programmer:  John Mainzer
  *              9/10/17
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Pget_fapl_hdfs(hid_t             fapl_id,
-                 H5FD_hdfs_fapl_t *fa_out)
+H5Pget_fapl_hdfs(hid_t fapl_id, H5FD_hdfs_fapl_t *fa_dst /*out*/)
 {
-    const H5FD_hdfs_fapl_t *fa        = NULL;
-    H5P_genplist_t         *plist     = NULL;
+    const H5FD_hdfs_fapl_t *fa_src    = NULL;
+    H5P_genplist_t *        plist     = NULL;
     herr_t                  ret_value = SUCCEED;
 
     FUNC_ENTER_API(FAIL)
-    H5TRACE2("e", "i*x", fapl_id, fa_out);
+    H5TRACE2("e", "ix", fapl_id, fa_dst);
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5Pget_fapl_hdfs() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif
 
-    if (fa_out == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "fa_out is NULL")
-    }
+    if (fa_dst == NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "fa_dst ptr is NULL")
     plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS);
-    if (plist == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
-                    "not a file access list")
-    }
-    if (H5FD_HDFS != H5P_peek_driver(plist)) {
-        HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL,
-                    "incorrect VFL driver")
-    }
+    if (plist == NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access list")
 
-    fa = (const H5FD_hdfs_fapl_t *)H5P_peek_driver_info(plist);
-    if (fa == NULL) {
-        HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL,
-                    "bad VFL driver info")
-    }
+    if (H5FD_HDFS != H5P_peek_driver(plist))
+        HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "incorrect VFL driver")
+
+    fa_src = (const H5FD_hdfs_fapl_t *)H5P_peek_driver_info(plist);
+    if (fa_src == NULL)
+        HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "bad VFL driver info")
 
     /* Copy the hdfs fapl data out */
-    HDmemcpy(fa_out, fa, sizeof(H5FD_hdfs_fapl_t));
+    H5MM_memcpy(fa_dst, fa_src, sizeof(H5FD_hdfs_fapl_t));
 
 done:
     FUNC_LEAVE_API(ret_value)
-
 } /* H5Pget_fapl_hdfs() */
 
-
 /*-------------------------------------------------------------------------
- * Function:    H5FD_hdfs_fapl_get
+ * Function:    H5FD__hdfs_fapl_get
  *
  * Purpose:     Gets a file access property list which could be used to
  *              create an identical file.
@@ -822,42 +675,35 @@ done:
  * Programmer:  John Mainzer
  *              9/8/17
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static void *
-H5FD_hdfs_fapl_get(H5FD_t *_file)
+H5FD__hdfs_fapl_get(H5FD_t *_file)
 {
-    H5FD_hdfs_t      *file      = (H5FD_hdfs_t*)_file;
+    H5FD_hdfs_t *     file      = (H5FD_hdfs_t *)_file;
     H5FD_hdfs_fapl_t *fa        = NULL;
-    void             *ret_value = NULL;
+    void *            ret_value = NULL;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
     fa = (H5FD_hdfs_fapl_t *)H5MM_calloc(sizeof(H5FD_hdfs_fapl_t));
-    if (fa == NULL) {
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
-                    "memory allocation failed")
-    }
+    if (fa == NULL)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "memory allocation failed")
 
     /* Copy the fields of the structure */
-    HDmemcpy(fa, &(file->fa), sizeof(H5FD_hdfs_fapl_t));
+    H5MM_memcpy(fa, &(file->fa), sizeof(H5FD_hdfs_fapl_t));
 
     ret_value = fa;
 
 done:
-    if (ret_value == NULL && fa != NULL) {
+    if (ret_value == NULL && fa != NULL)
         H5MM_xfree(fa); /* clean up on error */
-    }
 
     FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FD__hdfs_fapl_get() */
 
-} /* H5FD_hdfs_fapl_get() */
-
-
 /*-------------------------------------------------------------------------
- * Function:    H5FD_hdfs_fapl_copy
+ * Function:    H5FD__hdfs_fapl_copy
  *
  * Purpose:     Copies the hdfs-specific file access properties.
  *
@@ -868,40 +714,33 @@ done:
  * Programmer:  John Mainzer
  *              9/8/17
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static void *
-H5FD_hdfs_fapl_copy(const void *_old_fa)
+H5FD__hdfs_fapl_copy(const void *_old_fa)
 {
-    const H5FD_hdfs_fapl_t *old_fa    = (const H5FD_hdfs_fapl_t*)_old_fa;
-    H5FD_hdfs_fapl_t       *new_fa    = NULL;
-    void                   *ret_value = NULL;
+    const H5FD_hdfs_fapl_t *old_fa    = (const H5FD_hdfs_fapl_t *)_old_fa;
+    H5FD_hdfs_fapl_t *      new_fa    = NULL;
+    void *                  ret_value = NULL;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
     new_fa = (H5FD_hdfs_fapl_t *)H5MM_malloc(sizeof(H5FD_hdfs_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_hdfs_fapl_t));
+    H5MM_memcpy(new_fa, old_fa, sizeof(H5FD_hdfs_fapl_t));
     ret_value = new_fa;
 
 done:
-    if (ret_value == NULL && new_fa != NULL) {
+    if (ret_value == NULL && new_fa != NULL)
         H5MM_xfree(new_fa); /* clean up on error */
-    }
 
     FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FD__hdfs_fapl_copy() */
 
-} /* H5FD_hdfs_fapl_copy() */
-
-
 /*-------------------------------------------------------------------------
- * Function:    H5FD_hdfs_fapl_free
+ * Function:    H5FD__hdfs_fapl_free
  *
  * Purpose:     Frees the hdfs-specific file access properties.
  *
@@ -910,30 +749,26 @@ done:
  * Programmer:  John Mainzer
  *              9/8/17
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_hdfs_fapl_free(void *_fa)
+H5FD__hdfs_fapl_free(void *_fa)
 {
-    H5FD_hdfs_fapl_t *fa = (H5FD_hdfs_fapl_t*)_fa;
+    H5FD_hdfs_fapl_t *fa = (H5FD_hdfs_fapl_t *)_fa;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
     HDassert(fa != NULL); /* sanity check */
 
     H5MM_xfree(fa);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-
-} /* H5FD_hdfs_fapl_free() */
+} /* H5FD__hdfs_fapl_free() */
 
 #if HDFS_STATS
-
 /*----------------------------------------------------------------------------
  *
- * Function: hdfs_reset_stats()
+ * Function: hdfs__reset_stats()
  *
  * Purpose:
  *
@@ -950,32 +785,28 @@ H5FD_hdfs_fapl_free(void *_fa)
  * Programmer: Jacob Smith
  *             2017-12-08
  *
- * Changes: None.
- *
  *----------------------------------------------------------------------------
  */
 static herr_t
-hdfs_reset_stats(H5FD_hdfs_t *file)
+hdfs__reset_stats(H5FD_hdfs_t *file)
 {
     unsigned i         = 0;
     herr_t   ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
 #if HDFS_DEBUG
-    HDprintf("hdfs_reset_stats() called\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif
 
-    if (file == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "file was null")
-    }
+    if (file == NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file was null")
 
     for (i = 0; i <= HDFS_STATS_BIN_COUNT; i++) {
-        file->raw[i].bytes  = 0;
-        file->raw[i].count  = 0;
-        file->raw[i].min    = (unsigned long long)HDFS_STATS_STARTING_MIN;
-        file->raw[i].max    = 0;
+        file->raw[i].bytes = 0;
+        file->raw[i].count = 0;
+        file->raw[i].min   = (unsigned long long)HDFS_STATS_STARTING_MIN;
+        file->raw[i].max   = 0;
 
         file->meta[i].bytes = 0;
         file->meta[i].count = 0;
@@ -986,13 +817,12 @@ hdfs_reset_stats(H5FD_hdfs_t *file)
 done:
     FUNC_LEAVE_NOAPI(ret_value);
 
-} /* hdfs_reset_stats */
+} /* hdfs__reset_stats */
 #endif /* HDFS_STATS */
 
-
 /*-------------------------------------------------------------------------
  *
- * Function: H5FD_hdfs_open()
+ * Function: H5FD__hdfs_open()
  *
  * Purpose:
  *
@@ -1011,137 +841,77 @@ done:
  * Programmer: Jacob Smith
  *             2017-11-02
  *
- * Changes: None.
- *
  *-------------------------------------------------------------------------
  */
-#ifdef H5_HAVE_LIBHDFS
 static H5FD_t *
-H5FD_hdfs_open(
-        const char *path,
-        unsigned    flags,
-        hid_t       fapl_id,
-        haddr_t     maxaddr)
+H5FD__hdfs_open(const char *path, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
 {
-    H5FD_t           *ret_value = NULL;
-    H5FD_hdfs_t      *file      = NULL;
-    hdfs_t           *handle    = NULL;
-    H5FD_hdfs_fapl_t  fa;
+    H5FD_t *         ret_value = NULL;
+    H5FD_hdfs_t *    file      = NULL;
+    hdfs_t *         handle    = NULL;
+    H5FD_hdfs_fapl_t fa;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_open() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif /* HDFS_DEBUG */
 
     /* Sanity check on file offsets */
     HDcompile_assert(sizeof(HDoff_t) >= sizeof(size_t));
 
     /* Check arguments */
-    if (!path || !*path) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "invalid file name")
-    }
-    if (0 == maxaddr || HADDR_UNDEF == maxaddr) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL,
-                    "bogus maxaddr")
-    }
-    if (ADDR_OVERFLOW(maxaddr)) {
-        HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, NULL,
-                    "bogus maxaddr")
-    }
-    if (flags != H5F_ACC_RDONLY) {
-        HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, NULL,
-                    "only Read-Only access allowed")
-    }
-    if (fapl_id == H5P_DEFAULT || fapl_id == H5P_FILE_ACCESS_DEFAULT) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "fapl cannot be H5P_DEFAULT")
-    }
-    if (FAIL == H5Pget_fapl_hdfs(fapl_id, &fa)) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL,
-                    "can't get property list")
-    }
-
-    handle = H5FD_hdfs_handle_open(
-            path,
-            fa.namenode_name,
-            fa.namenode_port,
-            fa.user_name,
-            fa.kerberos_ticket_cache,
-            fa.stream_buffer_size);
-
-    if (handle == NULL) {
-        HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL,
-                    "could not open")
-    }
+    if (!path || !*path)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid file name")
+    if (0 == maxaddr || HADDR_UNDEF == maxaddr)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "bogus maxaddr")
+    if (ADDR_OVERFLOW(maxaddr))
+        HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, NULL, "bogus maxaddr")
+    if (flags != H5F_ACC_RDONLY)
+        HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, NULL, "only Read-Only access allowed")
+    if (fapl_id == H5P_DEFAULT || fapl_id == H5P_FILE_ACCESS_DEFAULT)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "fapl cannot be H5P_DEFAULT")
+    if (FAIL == H5Pget_fapl_hdfs(fapl_id, &fa))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "can't get property list")
+
+    handle = H5FD__hdfs_handle_open(path, fa.namenode_name, fa.namenode_port, fa.user_name,
+                                    fa.kerberos_ticket_cache, fa.stream_buffer_size);
+    if (handle == NULL)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL, "could not open")
 
     HDassert(handle->magic == HDFS_HDFST_MAGIC);
 
-    /* create new file struct
-     */
+    /* Create new file struct */
     file = H5FL_CALLOC(H5FD_hdfs_t);
-    if (file == NULL) {
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
-                    "unable to allocate file struct")
-    }
+    if (file == NULL)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "unable to allocate file struct")
     file->hdfs_handle = handle;
-    HDmemcpy(&(file->fa), &fa, sizeof(H5FD_hdfs_fapl_t));
+    H5MM_memcpy(&(file->fa), &fa, sizeof(H5FD_hdfs_fapl_t));
 
 #if HDFS_STATS
-    if (FAIL == hdfs_reset_stats(file)) {
-        HGOTO_ERROR(H5E_INTERNAL, H5E_UNINITIALIZED, NULL,
-                    "unable to reset file statistics")
-    }
+    if (FAIL == hdfs__reset_stats(file))
+        HGOTO_ERROR(H5E_INTERNAL, H5E_UNINITIALIZED, NULL, "unable to reset file statistics")
 #endif /* HDFS_STATS */
 
-    ret_value = (H5FD_t*)file;
+    ret_value = (H5FD_t *)file;
 
 done:
     if (ret_value == NULL) {
-        if (handle != NULL) {
-            if (FAIL == H5FD_hdfs_handle_close(handle)) {
-                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL,
-                            "unable to close HDFS file handle")
-            }
-        }
-        if (file != NULL) {
+        if (handle != NULL)
+            if (FAIL == H5FD__hdfs_handle_close(handle))
+                HDONE_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, NULL, "unable to close HDFS file handle")
+        if (file != NULL)
             file = H5FL_FREE(H5FD_hdfs_t, file);
-        }
     } /* end if null return value (error) */
 
     FUNC_LEAVE_NOAPI(ret_value)
-
-} /* H5FD_hdfs_open() */
-
-#else /* H5_HAVE_LIBHDFS not defined */
-
-static H5FD_t *
-H5FD_hdfs_open(
-        const char H5_ATTR_UNUSED *path,
-        unsigned   H5_ATTR_UNUSED  flags,
-        hid_t      H5_ATTR_UNUSED  fapl_id,
-        haddr_t    H5_ATTR_UNUSED  maxaddr)
-{
-    H5FD_t           *ret_value = NULL;
-
-    FUNC_ENTER_NOAPI_NOINIT
-
-    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, NULL,
-                "Illegal open of unsupported virtual file (hdfs)");
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-
-} /* H5FD_hdfs_open() */
-
-#endif /* H5_HAVE_LIBHDFS */
+} /* H5FD__hdfs_open() */
 
 #if HDFS_STATS
-
+
 /*----------------------------------------------------------------------------
  *
- * Function: hdfs_fprint_stats()
+ * Function: hdfs__fprint_stats()
  *
  * Purpose:
  *
@@ -1191,50 +961,38 @@ done:
  *
  * Programmer: Jacob Smith
  *
- * Changes: None.
- *
  *----------------------------------------------------------------------------
  */
 static herr_t
-hdfs_fprint_stats(
-        FILE              *stream,
-        const H5FD_hdfs_t *file)
+hdfs__fprint_stats(FILE *stream, const H5FD_hdfs_t *file)
 {
     herr_t             ret_value    = SUCCEED;
-    parsed_url_t      *purl         = NULL;
+    parsed_url_t *     purl         = NULL;
     unsigned           i            = 0;
     unsigned long      count_meta   = 0;
     unsigned long      count_raw    = 0;
     double             average_meta = 0.0;
     double             average_raw  = 0.0;
-    unsigned long long min_meta  = (unsigned long long)HDFS_STATS_STARTING_MIN;
-    unsigned long long min_raw   = (unsigned long long)HDFS_STATS_STARTING_MIN;
+    unsigned long long min_meta     = (unsigned long long)HDFS_STATS_STARTING_MIN;
+    unsigned long long min_raw      = (unsigned long long)HDFS_STATS_STARTING_MIN;
     unsigned long long max_meta     = 0;
     unsigned long long max_raw      = 0;
     unsigned long long bytes_raw    = 0;
     unsigned long long bytes_meta   = 0;
     double             re_dub       = 0.0; /* re-usable double variable */
     unsigned           suffix_i     = 0;
-    const char         suffixes[]   = { ' ', 'K', 'M', 'G', 'T', 'P' };
+    const char         suffixes[]   = {' ', 'K', 'M', 'G', 'T', 'P'};
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
-    if (stream == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "file stream cannot be null" )
-    }
-    if (file == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "file cannot be null")
-    }
-    if (file->hdfs_handle == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "hdfs handle cannot be null")
-    }
-    if (file->hdfs_handle->magic != HDFS_HDFST_MAGIC) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "hdfs handle has invalid magic")
-    }
+    if (stream == NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file stream cannot be null")
+    if (file == NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file cannot be null")
+    if (file->hdfs_handle == NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hdfs handle cannot be null")
+    if (file->hdfs_handle->magic != HDFS_HDFST_MAGIC)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hdfs handle has invalid magic")
 
     /*******************
      * AGGREGATE STATS *
@@ -1244,35 +1002,36 @@ hdfs_fprint_stats(
         const hdfs_statsbin *r = &file->raw[i];
         const hdfs_statsbin *m = &file->meta[i];
 
-        if (m->min < min_meta)  { min_meta = m->min; }
-        if (r->min < min_raw)   { min_raw  = r->min; }
-        if (m->max > max_meta)  { max_meta = m->max; }
-        if (r->max > max_raw)   { max_raw  = r->max; }
+        if (m->min < min_meta)
+            min_meta = m->min;
+        if (r->min < min_raw)
+            min_raw = r->min;
+        if (m->max > max_meta)
+            max_meta = m->max;
+        if (r->max > max_raw)
+            max_raw = r->max;
 
-        count_raw  += r->count;
+        count_raw += r->count;
         count_meta += m->count;
-        bytes_raw  += r->bytes;
+        bytes_raw += r->bytes;
         bytes_meta += m->bytes;
     }
-    if (count_raw  > 0) {
-        average_raw  = (double)bytes_raw / (double)count_raw;
-    }
-    if (count_meta > 0) {
+    if (count_raw > 0)
+        average_raw = (double)bytes_raw / (double)count_raw;
+    if (count_meta > 0)
         average_meta = (double)bytes_meta / (double)count_meta;
-    }
 
     /******************
      * PRINT OVERVIEW *
      ******************/
 
-    HDfprintf(stream, "TOTAL READS: %llu  (%llu meta, %llu raw)\n",
-              count_raw + count_meta, count_meta, count_raw);
-    HDfprintf(stream, "TOTAL BYTES: %llu  (%llu meta, %llu raw)\n",
-              bytes_raw + bytes_meta, bytes_meta, bytes_raw);
+    HDfprintf(stream, "TOTAL READS: %llu  (%llu meta, %llu raw)\n", count_raw + count_meta, count_meta,
+              count_raw);
+    HDfprintf(stream, "TOTAL BYTES: %llu  (%llu meta, %llu raw)\n", bytes_raw + bytes_meta, bytes_meta,
+              bytes_raw);
 
-    if (count_raw + count_meta == 0) {
+    if (count_raw + count_meta == 0)
         goto done;
-    }
 
     /*************************
      * PRINT AGGREGATE STATS *
@@ -1280,55 +1039,49 @@ hdfs_fprint_stats(
 
     HDfprintf(stream, "SIZES     meta      raw\n");
     HDfprintf(stream, "  min ");
-    if (count_meta == 0) {
+    if (count_meta == 0)
         HDfprintf(stream, "   0.000  ");
-    } else {
+    else {
         re_dub = (double)min_meta;
-        for (suffix_i = 0; re_dub >= 1024.0; suffix_i++) {
+        for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
             re_dub /= 1024.0;
-        }
         HDassert(suffix_i < sizeof(suffixes));
         HDfprintf(stream, "%8.3lf%c ", re_dub, suffixes[suffix_i]);
     }
 
-    if (count_raw == 0) {
+    if (count_raw == 0)
         HDfprintf(stream, "   0.000 \n");
-    } else {
+    else {
         re_dub = (double)min_raw;
-        for (suffix_i = 0; re_dub >= 1024.0; suffix_i++) {
+        for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
             re_dub /= 1024.0;
-        }
         HDassert(suffix_i < sizeof(suffixes));
         HDfprintf(stream, "%8.3lf%c\n", re_dub, suffixes[suffix_i]);
     }
 
     HDfprintf(stream, "  avg ");
     re_dub = (double)average_meta;
-    for (suffix_i = 0; re_dub >= 1024.0; suffix_i++) {
+    for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
         re_dub /= 1024.0;
-    }
     HDassert(suffix_i < sizeof(suffixes));
     HDfprintf(stream, "%8.3lf%c ", re_dub, suffixes[suffix_i]);
 
     re_dub = (double)average_raw;
-    for (suffix_i = 0; re_dub >= 1024.0; suffix_i++) {
+    for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
         re_dub /= 1024.0;
-    }
     HDassert(suffix_i < sizeof(suffixes));
     HDfprintf(stream, "%8.3lf%c\n", re_dub, suffixes[suffix_i]);
 
     HDfprintf(stream, "  max ");
     re_dub = (double)max_meta;
-    for (suffix_i = 0; re_dub >= 1024.0; suffix_i++) {
+    for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
         re_dub /= 1024.0;
-    }
     HDassert(suffix_i < sizeof(suffixes));
     HDfprintf(stream, "%8.3lf%c ", re_dub, suffixes[suffix_i]);
 
     re_dub = (double)max_raw;
-    for (suffix_i = 0; re_dub >= 1024.0; suffix_i++) {
+    for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
         re_dub /= 1024.0;
-    }
     HDassert(suffix_i < sizeof(suffixes));
     HDfprintf(stream, "%8.3lf%c\n", re_dub, suffixes[suffix_i]);
 
@@ -1336,10 +1089,8 @@ hdfs_fprint_stats(
      * PRINT INDIVIDUAL BIN STATS *
      ******************************/
 
-    HDfprintf(stream,
-        "BINS             # of reads      total bytes         average size\n");
-    HDfprintf(stream,
-        "    up-to      meta     raw     meta      raw       meta      raw\n");
+    HDfprintf(stream, "BINS             # of reads      total bytes         average size\n");
+    HDfprintf(stream, "    up-to      meta     raw     meta      raw       meta      raw\n");
 
     for (i = 0; i <= HDFS_STATS_BIN_COUNT; i++) {
         const hdfs_statsbin *m;
@@ -1356,79 +1107,68 @@ hdfs_fprint_stats(
 
         m = &file->meta[i];
         r = &file->raw[i];
-        if (r->count == 0 && m->count == 0) {
+        if (r->count == 0 && m->count == 0)
             continue;
-        }
 
         range_end = hdfs_stats_boundaries[i];
 
         if (i == HDFS_STATS_BIN_COUNT) {
-            range_end = hdfs_stats_boundaries[i-1];
+            range_end = hdfs_stats_boundaries[i - 1];
             HDfprintf(stream, ">");
-        } else {
-            HDfprintf(stream, " ");
         }
+        else
+            HDfprintf(stream, " ");
 
         bm_val = (double)m->bytes;
-        for (suffix_i = 0; bm_val >= 1024.0; suffix_i++) {
+        for (suffix_i = 0; bm_val >= 1024.0; suffix_i++)
             bm_val /= 1024.0;
-        }
         HDassert(suffix_i < sizeof(suffixes));
         bm_suffix = suffixes[suffix_i];
 
         br_val = (double)r->bytes;
-        for (suffix_i = 0; br_val >= 1024.0; suffix_i++) {
+        for (suffix_i = 0; br_val >= 1024.0; suffix_i++)
             br_val /= 1024.0;
-        }
         HDassert(suffix_i < sizeof(suffixes));
         br_suffix = suffixes[suffix_i];
 
-        if (m->count > 0) {
+        if (m->count > 0)
             am_val = (double)(m->bytes) / (double)(m->count);
-        }
-        for (suffix_i = 0; am_val >= 1024.0; suffix_i++) {
+        for (suffix_i = 0; am_val >= 1024.0; suffix_i++)
             am_val /= 1024.0;
-        }
         HDassert(suffix_i < sizeof(suffixes));
         am_suffix = suffixes[suffix_i];
 
-        if (r->count > 0) {
+        if (r->count > 0)
             ar_val = (double)(r->bytes) / (double)(r->count);
-        }
-        for (suffix_i = 0; ar_val >= 1024.0; suffix_i++) {
+        for (suffix_i = 0; ar_val >= 1024.0; suffix_i++)
             ar_val /= 1024.0;
-        }
         HDassert(suffix_i < sizeof(suffixes));
         ar_suffix = suffixes[suffix_i];
 
         re_dub = (double)range_end;
-        for (suffix_i = 0; re_dub >= 1024.0; suffix_i++) {
+        for (suffix_i = 0; re_dub >= 1024.0; suffix_i++)
             re_dub /= 1024.0;
-        }
         HDassert(suffix_i < sizeof(suffixes));
 
-        HDfprintf(
-                stream,
-                " %8.3f%c %7d %7d %8.3f%c %8.3f%c %8.3f%c %8.3f%c\n",
-                re_dub, suffixes[suffix_i], /* bin ceiling      */
-                m->count,                   /* metadata reads   */
-                r->count,                   /* rawdata reads    */
-                bm_val, bm_suffix,          /* metadata bytes   */
-                br_val, br_suffix,          /* rawdata bytes    */
-                am_val, am_suffix,          /* metadata average */
-                ar_val, ar_suffix);         /* rawdata average  */
-        fflush(stream);
+        HDfprintf(stream, " %8.3f%c %7d %7d %8.3f%c %8.3f%c %8.3f%c %8.3f%c\n", re_dub,
+                  suffixes[suffix_i], /* bin ceiling      */
+                  m->count,           /* metadata reads   */
+                  r->count,           /* rawdata reads    */
+                  bm_val, bm_suffix,  /* metadata bytes   */
+                  br_val, br_suffix,  /* rawdata bytes    */
+                  am_val, am_suffix,  /* metadata average */
+                  ar_val, ar_suffix); /* rawdata average  */
+        HDfflush(stream);
     }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
-} /* hdfs_fprint_stats */
+} /* hdfs__fprint_stats */
 #endif /* HDFS_STATS */
 
-
 /*-------------------------------------------------------------------------
  *
- * Function: H5FD_hdfs_close()
+ * Function: H5FD__hdfs_close()
  *
  * Purpose:
  *
@@ -1441,77 +1181,46 @@ done:
  * Programmer: Jacob Smith
  *             2017-11-02
  *
- * Changes: None.
- *
  *-------------------------------------------------------------------------
  */
-#ifdef H5_HAVE_LIBHDFS
-
 static herr_t
-H5FD_hdfs_close(H5FD_t *_file)
+H5FD__hdfs_close(H5FD_t *_file)
 {
-    herr_t       ret_value = SUCCEED;
     H5FD_hdfs_t *file      = (H5FD_hdfs_t *)_file;
+    herr_t       ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_close() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif
 
-    /* Sanity checks
-     */
+    /* Sanity checks */
     HDassert(file != NULL);
     HDassert(file->hdfs_handle != NULL);
     HDassert(file->hdfs_handle->magic == HDFS_HDFST_MAGIC);
 
-    /* Close the underlying request handle
-     */
-    if (file->hdfs_handle != NULL) {
-        if (FAIL == H5FD_hdfs_handle_close(file->hdfs_handle)) {
-            HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL,
-                        "unable to close HDFS file handle")
-        }
-    }
+    /* Close the underlying request handle */
+    if (file->hdfs_handle != NULL)
+        if (FAIL == H5FD__hdfs_handle_close(file->hdfs_handle))
+            HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close HDFS file handle")
 
 #if HDFS_STATS
     /* TODO: mechanism to re-target stats printout */
-    if (FAIL == hdfs_fprint_stats(stdout, file)) {
-        HGOTO_ERROR(H5E_INTERNAL, H5E_ERROR, FAIL,
-                    "problem while writing file statistics")
-    }
+    if (FAIL == hdfs__fprint_stats(stdout, file))
+        HGOTO_ERROR(H5E_INTERNAL, H5E_ERROR, FAIL, "problem while writing file statistics")
 #endif /* HDFS_STATS */
 
-    /* Release the file info
-     */
+    /* Release the file info */
     file = H5FL_FREE(H5FD_hdfs_t, file);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_hdfs_close() */
-
-#else /* H5_HAVE_LIBHDFS not defined */
+} /* end H5FD__hdfs_close() */
 
-static herr_t
-H5FD_hdfs_close(H5FD_t H5_ATTR_UNUSED *_file)
-{
-    herr_t       ret_value = SUCCEED;
-
-    FUNC_ENTER_NOAPI_NOINIT
-
-    HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL,
-                "Illegal close of unsupported Virtual File (hdfs)")
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_hdfs_close() */
-
-#endif /* H5_HAVE_LIBHDFS */
-
-
 /*-------------------------------------------------------------------------
  *
- * Function: H5FD_hdfs_cmp()
+ * Function: H5FD__hdfs_cmp()
  *
  * Purpose:
  *
@@ -1519,36 +1228,27 @@ done:
  *     field-by-field.
  *
  * Return:
- *     + Equivalent:      0
- *     + Not Equivalent: -1
+ *      Equivalent:      0
+ *      Not Equivalent: -1
  *
  * Programmer: Gerd Herber
  *             May 2018
  *
- * Changes:
- *
- *     + Replace `if (ret_value == 0)` chain with `HGOTO_DONE` jumps.
- *         Jacob Smith 17 May 2018
- *
  *-------------------------------------------------------------------------
  */
-#ifdef H5_HAVE_LIBHDFS
-
 static int
-H5FD_hdfs_cmp(
-        const H5FD_t *_f1,
-        const H5FD_t *_f2)
+H5FD__hdfs_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
 {
     int                ret_value = 0;
     const H5FD_hdfs_t *f1        = (const H5FD_hdfs_t *)_f1;
     const H5FD_hdfs_t *f2        = (const H5FD_hdfs_t *)_f2;
-    hdfsFileInfo      *finfo1    = NULL;
-    hdfsFileInfo      *finfo2    = NULL;
+    hdfsFileInfo *     finfo1    = NULL;
+    hdfsFileInfo *     finfo2    = NULL;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_cmp() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif /* HDFS_DEBUG */
 
     HDassert(f1->hdfs_handle != NULL);
@@ -1561,40 +1261,43 @@ H5FD_hdfs_cmp(
     HDassert(finfo1 != NULL);
     HDassert(finfo2 != NULL);
 
-    if (finfo1->mKind        != finfo2->mKind)        { HGOTO_DONE(-1); }
-    if (finfo1->mName        != finfo2->mName)        { HGOTO_DONE(-1); }
-    if (finfo1->mLastMod     != finfo2->mLastMod)     { HGOTO_DONE(-1); }
-    if (finfo1->mSize        != finfo2->mSize)        { HGOTO_DONE(-1); }
-    if (finfo1->mReplication != finfo2->mReplication) { HGOTO_DONE(-1); }
-    if (finfo1->mBlockSize   != finfo2->mBlockSize)   { HGOTO_DONE(-1); }
-    if (strcmp(finfo1->mOwner, finfo2->mOwner))       { HGOTO_DONE(-1); }
-    if (strcmp(finfo1->mGroup, finfo2->mGroup))       { HGOTO_DONE(-1); }
-    if (finfo1->mPermissions != finfo2->mPermissions) { HGOTO_DONE(-1); }
-    if (finfo1->mLastAccess  != finfo2->mLastAccess)  { HGOTO_DONE(-1); }
+    if (finfo1->mKind != finfo2->mKind) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mName != finfo2->mName) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mLastMod != finfo2->mLastMod) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mSize != finfo2->mSize) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mReplication != finfo2->mReplication) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mBlockSize != finfo2->mBlockSize) {
+        HGOTO_DONE(-1);
+    }
+    if (HDstrcmp(finfo1->mOwner, finfo2->mOwner)) {
+        HGOTO_DONE(-1);
+    }
+    if (HDstrcmp(finfo1->mGroup, finfo2->mGroup)) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mPermissions != finfo2->mPermissions) {
+        HGOTO_DONE(-1);
+    }
+    if (finfo1->mLastAccess != finfo2->mLastAccess) {
+        HGOTO_DONE(-1);
+    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5FD_hdfs_cmp() */
-
-#else /* H5_HAVE_LIBHDFS not defined */
-
-static int
-H5FD_hdfs_cmp(
-        const H5FD_t H5_ATTR_UNUSED *_f1,
-        const H5FD_t H5_ATTR_UNUSED *_f2)
-{
-    int                ret_value = 0;
-
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
-
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* H5FD_hdfs_cmp() */
-
-#endif /* H5_HAVE_LIBHDFS */
+} /* H5FD__hdfs_cmp() */
 
-
 /*-------------------------------------------------------------------------
- * Function:    H5FD_hdfs_query
+ * Function:    H5FD__hdfs_query
  *
  * Purpose:     Set the flags that this VFL driver is capable of supporting.
  *              (listed in H5FDpublic.h)
@@ -1613,14 +1316,12 @@ H5FD_hdfs_cmp(
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_hdfs_query(
-        const H5FD_t  H5_ATTR_UNUSED *_file,
-        unsigned long                *flags) /* out variable */
+H5FD__hdfs_query(const H5FD_t H5_ATTR_UNUSED *_file, unsigned long *flags)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_query() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif
 
     if (flags) {
@@ -1629,12 +1330,11 @@ H5FD_hdfs_query(
     }
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* H5FD_hdfs_query() */
+} /* H5FD__hdfs_query() */
 
-
 /*-------------------------------------------------------------------------
  *
- * Function: H5FD_hdfs_get_eoa()
+ * Function: H5FD__hdfs_get_eoa()
  *
  * Purpose:
  *
@@ -1649,50 +1349,25 @@ H5FD_hdfs_query(
  * Programmer: Jacob Smith
  *             2017-11-02
  *
- * Changes: None.
- *
  *-------------------------------------------------------------------------
  */
-#ifdef H5_HAVE_LIBHDFS
-
 static haddr_t
-H5FD_hdfs_get_eoa(
-        const H5FD_t                *_file,
-        H5FD_mem_t   H5_ATTR_UNUSED  type)
+H5FD__hdfs_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
     const H5FD_hdfs_t *file = (const H5FD_hdfs_t *)_file;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_get_eoa() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif
 
     FUNC_LEAVE_NOAPI(file->eoa)
-} /* end H5FD_hdfs_get_eoa() */
-
-#else /* H5_HAVE_LIBHDFS not defined */
+} /* end H5FD__hdfs_get_eoa() */
 
-static haddr_t
-H5FD_hdfs_get_eoa(
-        const H5FD_t H5_ATTR_UNUSED *_file,
-        H5FD_mem_t   H5_ATTR_UNUSED  type)
-{
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
-
-#if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_get_eoa() called.\n");
-#endif
-
-    FUNC_LEAVE_NOAPI(0)
-} /* end H5FD_hdfs_get_eoa() */
-
-#endif /* H5_HAVE_LIBHDFS */
-
-
 /*-------------------------------------------------------------------------
  *
- * Function: H5FD_hdfs_set_eoa()
+ * Function: H5FD__hdfs_set_eoa()
  *
  * Purpose:
  *
@@ -1705,54 +1380,27 @@ H5FD_hdfs_get_eoa(
  * Programmer: Jacob Smith
  *             2017-11-03
  *
- * Changes: None.
- *
  *-------------------------------------------------------------------------
  */
-#ifdef H5_HAVE_LIBHDFS
-
 static herr_t
-H5FD_hdfs_set_eoa(
-        H5FD_t                    *_file,
-        H5FD_mem_t H5_ATTR_UNUSED  type,
-        haddr_t                    addr)
+H5FD__hdfs_set_eoa(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr)
 {
     H5FD_hdfs_t *file = (H5FD_hdfs_t *)_file;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_set_eoa() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif
 
     file->eoa = addr;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* H5FD_hdfs_set_eoa() */
-
-#else /* H5_HAVE_LIBHDFS not defined */
-
-static herr_t
-H5FD_hdfs_set_eoa(
-        H5FD_t     H5_ATTR_UNUSED *_file,
-        H5FD_mem_t H5_ATTR_UNUSED  type,
-        haddr_t    H5_ATTR_UNUSED  addr)
-{
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
-
-#if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_set_eoa() called.\n");
-#endif
-
-    FUNC_LEAVE_NOAPI(FAIL)
-} /* H5FD_hdfs_set_eoa() */
-
-#endif /* H5_HAVE_LIBHDFS */
+} /* H5FD__hdfs_set_eoa() */
 
-
 /*-------------------------------------------------------------------------
  *
- * Function: H5FD_hdfs_get_eof()
+ * Function: H5FD__hdfs_get_eof()
  *
  * Purpose:
  *
@@ -1768,49 +1416,26 @@ H5FD_hdfs_set_eoa(
  *
  *-------------------------------------------------------------------------
  */
-#ifdef H5_HAVE_LIBHDFS
-
 static haddr_t
-H5FD_hdfs_get_eof(
-        const H5FD_t                *_file,
-        H5FD_mem_t   H5_ATTR_UNUSED  type)
+H5FD__hdfs_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
     const H5FD_hdfs_t *file = (const H5FD_hdfs_t *)_file;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_get_eof() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif
 
     HDassert(file->hdfs_handle != NULL);
     HDassert(file->hdfs_handle->magic == HDFS_HDFST_MAGIC);
 
-    FUNC_LEAVE_NOAPI((size_t) file->hdfs_handle->fileinfo->mSize)
-} /* end H5FD_hdfs_get_eof() */
-
-#else /* H5_HAVE_LIBHDFS not defined */
-
-static haddr_t
-H5FD_hdfs_get_eof(
-        const H5FD_t H5_ATTR_UNUSED *_file,
-        H5FD_mem_t   H5_ATTR_UNUSED  type)
-{
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
-
-#if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_get_eof() called.\n");
-#endif
+    FUNC_LEAVE_NOAPI((size_t)file->hdfs_handle->fileinfo->mSize)
+} /* end H5FD__hdfs_get_eof() */
 
-    FUNC_LEAVE_NOAPI((size_t)0)
-} /* end H5FD_hdfs_get_eof() */
-
-#endif /* H5_HAVE_LIBHDFS */
-
-
 /*-------------------------------------------------------------------------
  *
- * Function: H5FD_hdfs_get_handle()
+ * Function: H5FD__hdfs_get_handle()
  *
  * Purpose:
  *
@@ -1823,67 +1448,32 @@ H5FD_hdfs_get_eof(
  * Programmer: Jacob Smith
  *             2017-11-02
  *
- * Changes: None.
- *
  *-------------------------------------------------------------------------
  */
-#ifdef H5_HAVE_LIBHDFS
-
 static herr_t
-H5FD_hdfs_get_handle(
-        H5FD_t                 *_file,
-        hid_t  H5_ATTR_UNUSED   fapl,
-        void                  **file_handle)
+H5FD__hdfs_get_handle(H5FD_t *_file, hid_t H5_ATTR_UNUSED fapl, void **file_handle)
 {
-    herr_t       ret_value = SUCCEED;
     H5FD_hdfs_t *file      = (H5FD_hdfs_t *)_file;
+    herr_t       ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_get_handle() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif /* HDFS_DEBUG */
 
-    if (!file_handle) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
-                    "file handle not valid")
-    }
+    if (!file_handle)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file handle not valid")
 
     *file_handle = file->hdfs_handle;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_hdfs_get_handle() */
-
-#else /* H5_HAVE_LIBHDFS not defined */
+} /* end H5FD__hdfs_get_handle() */
 
-static herr_t
-H5FD_hdfs_get_handle(
-        H5FD_t H5_ATTR_UNUSED  *_file,
-        hid_t  H5_ATTR_UNUSED   fapl,
-        void   H5_ATTR_UNUSED **file_handle)
-{
-    herr_t       ret_value = SUCCEED;
-
-    FUNC_ENTER_NOAPI_NOINIT
-
-#if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_get_handle() called.\n");
-#endif /* HDFS_DEBUG */
-
-    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL,
-                "Illegal get-handle of unsupported virtual file (hdfs)");
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_hdfs_get_handle() */
-
-#endif /* H5_HAVE_LIBHDFS */
-
-
 /*-------------------------------------------------------------------------
  *
- * Function: H5FD_hdfs_read()
+ * Function: H5FD__hdfs_read()
  *
  * Purpose:
  *
@@ -1901,34 +1491,25 @@ done:
  * Programmer: Jacob Smith
  *             2017-11-??
  *
- * Changes: None.
- *
  *-------------------------------------------------------------------------
  */
-#ifdef H5_HAVE_LIBHDFS
-
 static herr_t
-H5FD_hdfs_read(
-        H5FD_t                    *_file,
-        H5FD_mem_t H5_ATTR_UNUSED  type,
-        hid_t      H5_ATTR_UNUSED  dxpl_id,
-        haddr_t                    addr, /* start offset   */
-        size_t                     size, /* length of read */
-        void                      *buf)  /* out            */
+H5FD__hdfs_read(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr,
+                size_t size, void *buf)
 {
-    herr_t       ret_value = SUCCEED;
     H5FD_hdfs_t *file      = (H5FD_hdfs_t *)_file;
     size_t       filesize  = 0;
+    herr_t       ret_value = SUCCEED;
 #if HDFS_STATS
     /* working variables for storing stats */
     hdfs_statsbin *bin   = NULL;
     unsigned       bin_i = 0;
 #endif /* HDFS_STATS */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_read() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif /* HDFS_DEBUG */
 
     HDassert(file != NULL);
@@ -1936,46 +1517,33 @@ H5FD_hdfs_read(
     HDassert(file->hdfs_handle->magic == HDFS_HDFST_MAGIC);
     HDassert(buf != NULL);
 
-    filesize = (size_t) file->hdfs_handle->fileinfo->mSize;
+    filesize = (size_t)file->hdfs_handle->fileinfo->mSize;
 
-    if ((addr > filesize) || ((addr + size) > filesize)) {
-        HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL,
-                    "range exceeds file address")
-    }
+    if ((addr > filesize) || ((addr + size) > filesize))
+        HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "range exceeds file address")
 
-    if (FAIL == hdfsPread(
-            file->hdfs_handle->filesystem,
-            file->hdfs_handle->file,
-            (tOffset)addr,
-            buf,
-            (tSize)size))
-    {
-        HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL,
-                    "unable to execute read")
-    }
+    if (FAIL ==
+        hdfsPread(file->hdfs_handle->filesystem, file->hdfs_handle->file, (tOffset)addr, buf, (tSize)size))
+        HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "unable to execute read")
 
 #if HDFS_STATS
 
-    /* Find which "bin" this read fits in. Can be "overflow" bin.
-     */
-    for (bin_i = 0; bin_i < HDFS_STATS_BIN_COUNT; bin_i++) {
-        if ((unsigned long long)size < hdfs_stats_boundaries[bin_i]) {
+    /* Find which "bin" this read fits in. Can be "overflow" bin. */
+    for (bin_i = 0; bin_i < HDFS_STATS_BIN_COUNT; bin_i++)
+        if ((unsigned long long)size < hdfs_stats_boundaries[bin_i])
             break;
-        }
-    }
-    bin = (type == H5FD_MEM_DRAW)
-        ? &file->raw[bin_i]
-        : &file->meta[bin_i];
+    bin = (type == H5FD_MEM_DRAW) ? &file->raw[bin_i] : &file->meta[bin_i];
 
-    /* Store collected stats in appropriate bin
-     */
+    /* Store collected stats in appropriate bin */
     if (bin->count == 0) {
         bin->min = size;
         bin->max = size;
     }
     else {
-        if (size < bin->min) { bin->min = size; }
-        if (size > bin->max) { bin->max = size; }
+        if (size < bin->min)
+            bin->min = size;
+        if (size > bin->max)
+            bin->max = size;
     }
     bin->count++;
     bin->bytes += (unsigned long long)size;
@@ -1984,40 +1552,11 @@ H5FD_hdfs_read(
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_hdfs_read() */
-
-#else /* H5_HAVE_LIBHDFS not defined */
-
-static herr_t
-H5FD_hdfs_read(
-        H5FD_t     H5_ATTR_UNUSED *_file,
-        H5FD_mem_t H5_ATTR_UNUSED  type,
-        hid_t      H5_ATTR_UNUSED  dxpl_id,
-        haddr_t    H5_ATTR_UNUSED  addr,
-        size_t     H5_ATTR_UNUSED  size,
-        void       H5_ATTR_UNUSED *buf)
-{
-    herr_t       ret_value = SUCCEED;
-
-    FUNC_ENTER_NOAPI_NOINIT
-
-#if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_read() called.\n");
-#endif /* HDFS_DEBUG */
+} /* end H5FD__hdfs_read() */
 
-    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL,
-                "Illegal get-handle of unsupported virtual file (hdfs)");
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_hdfs_read() */
-
-#endif /* H5_HAVE_LIBHDFS */
-
-
 /*-------------------------------------------------------------------------
  *
- * Function: H5FD_hdfs_write()
+ * Function: H5FD__hdfs_write()
  *
  * Purpose:
  *
@@ -2031,38 +1570,29 @@ done:
  * Programmer: Jacob Smith
  *             2017-10-23
  *
- * Changes: None.
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_hdfs_write(
-        H5FD_t     H5_ATTR_UNUSED *_file,
-        H5FD_mem_t H5_ATTR_UNUSED  type,
-        hid_t      H5_ATTR_UNUSED  dxpl_id,
-        haddr_t    H5_ATTR_UNUSED  addr,
-        size_t     H5_ATTR_UNUSED  size,
-        const void H5_ATTR_UNUSED *buf)
+H5FD__hdfs_write(H5FD_t H5_ATTR_UNUSED *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED dxpl_id,
+                 haddr_t H5_ATTR_UNUSED addr, size_t H5_ATTR_UNUSED size, const void H5_ATTR_UNUSED *buf)
 {
     herr_t ret_value = FAIL;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_write() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif
 
-    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL,
-                "cannot write to read-only file.")
+    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "cannot write to read-only file")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5FD_hdfs_write() */
+} /* H5FD__hdfs_write() */
 
-
 /*-------------------------------------------------------------------------
  *
- * Function: H5FD_hdfs_truncate()
+ * Function: H5FD__hdfs_truncate()
  *
  * Purpose:
  *
@@ -2078,89 +1608,24 @@ done:
  * Programmer: Jacob Smith
  *             2017-10-23
  *
- * Changes: None.
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_hdfs_truncate(
-        H5FD_t  H5_ATTR_UNUSED *_file,
-        hid_t   H5_ATTR_UNUSED  dxpl_id,
-        hbool_t H5_ATTR_UNUSED  closing)
+H5FD__hdfs_truncate(H5FD_t H5_ATTR_UNUSED *_file, hid_t H5_ATTR_UNUSED dxpl_id,
+                    hbool_t H5_ATTR_UNUSED closing)
 {
     herr_t ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
 #if HDFS_DEBUG
-    HDfprintf(stdout, "H5FD_hdfs_truncate() called.\n");
+    HDfprintf(stdout, "called %s.\n", __func__);
 #endif
 
-    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL,
-                "cannot truncate read-only file.")
+    HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "cannot truncate read-only file")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_hdfs_truncate() */
-
-
-/*-------------------------------------------------------------------------
- *
- * Function: H5FD_hdfs_lock()
- *
- * Purpose:
- *
- *     Place an advisory lock on a file.
- *     No effect on Read-Only S3 file.
- *
- *     Suggestion: remove lock/unlock from class
- *               > would result in error at H5FD_[un]lock() (H5FD.c)
- *
- * Return:
- *
- *     SUCCEED (No-op always succeeds)
- *
- * Programmer: Jacob Smith
- *             2017-11-03
- *
- * Changes: None.
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5FD_hdfs_lock(
-        H5FD_t  H5_ATTR_UNUSED *_file,
-        hbool_t H5_ATTR_UNUSED  rw)
-{
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
-    FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5FD_hdfs_lock() */
-
-
-/*-------------------------------------------------------------------------
- *
- * Function: H5FD_hdfs_unlock()
- *
- * Purpose:
- *
- *     Remove the existing lock on the file.
- *     No effect on Read-Only S3 file.
- *
- * Return:
- *
- *     SUCCEED (No-op always succeeds)
- *
- * Programmer: Jacob Smith
- *             2017-11-03
- *
- * Changes: None.
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5FD_hdfs_unlock(H5FD_t H5_ATTR_UNUSED *_file)
-{
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
-    FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5FD_hdfs_unlock() */
+} /* end H5FD__hdfs_truncate() */
 
+#endif /* H5_HAVE_LIBHDFS */