Clang-format of source files

1 files changed, 471 insertions, 483 deletions

diff --git a/src/H5FDdirect.c b/src/H5FDdirect.c
index 3d514c7..ac7720f 100644
--- a/src/H5FDdirect.c
+++ b/src/H5FDdirect.c
@@ -22,16 +22,15 @@
 
 #include "H5FDdrvr_module.h" /* This source code file is part of the H5FD driver module */
 
-
-#include "H5private.h"      /* Generic Functions        */
-#include "H5Eprivate.h"     /* Error handling           */
-#include "H5Fprivate.h"     /* File access              */
-#include "H5FDprivate.h"    /* File drivers             */
-#include "H5FDdirect.h"     /* Direct file driver       */
-#include "H5FLprivate.h"    /* Free Lists               */
-#include "H5Iprivate.h"     /* IDs                      */
-#include "H5MMprivate.h"    /* Memory management        */
-#include "H5Pprivate.h"     /* Property lists           */
+#include "H5private.h"   /* Generic Functions        */
+#include "H5Eprivate.h"  /* Error handling           */
+#include "H5Fprivate.h"  /* File access              */
+#include "H5FDprivate.h" /* File drivers             */
+#include "H5FDdirect.h"  /* Direct file driver       */
+#include "H5FLprivate.h" /* Free Lists               */
+#include "H5Iprivate.h"  /* IDs                      */
+#include "H5MMprivate.h" /* Memory management        */
+#include "H5Pprivate.h"  /* Property lists           */
 
 #ifdef H5_HAVE_DIRECT
 
@@ -42,16 +41,16 @@ static hid_t H5FD_DIRECT_g = 0;
 static htri_t ignore_disabled_file_locks_s = FAIL;
 
 /* File operations */
-#define OP_UNKNOWN  0
+#define OP_UNKNOWN 0
 #define OP_READ    1
-#define OP_WRITE  2
+#define OP_WRITE   2
 
 /* Driver-specific file access properties */
 typedef struct H5FD_direct_fapl_t {
     size_t  mboundary;  /* Memory boundary for alignment    */
-    size_t  fbsize;    /* File system block size      */
-    size_t  cbsize;    /* Maximal buffer size for copying user data  */
-    hbool_t     must_align;     /* Decides if data alignment is required        */
+    size_t  fbsize;     /* File system block size      */
+    size_t  cbsize;     /* Maximal buffer size for copying user data  */
+    hbool_t must_align; /* Decides if data alignment is required        */
 } H5FD_direct_fapl_t;
 
 /*
@@ -67,21 +66,21 @@ typedef struct H5FD_direct_fapl_t {
  * occurs), and `op' will be set to H5F_OP_UNKNOWN.
  */
 typedef struct H5FD_direct_t {
-    H5FD_t  pub;      /*public stuff, must be first  */
-    int    fd;      /*the unix file      */
-    haddr_t  eoa;      /*end of allocated region  */
-    haddr_t  eof;      /*end of file; current file size*/
-    haddr_t  pos;      /*current file I/O position  */
-    int    op;      /*last operation    */
-    H5FD_direct_fapl_t  fa;    /*file access properties  */
-    hbool_t         ignore_disabled_file_locks;
+    H5FD_t             pub; /*public stuff, must be first  */
+    int                fd;  /*the unix file      */
+    haddr_t            eoa; /*end of allocated region  */
+    haddr_t            eof; /*end of file; current file size*/
+    haddr_t            pos; /*current file I/O position  */
+    int                op;  /*last operation    */
+    H5FD_direct_fapl_t fa;  /*file access properties  */
+    hbool_t            ignore_disabled_file_locks;
 #ifndef H5_HAVE_WIN32_API
     /*
      * On most systems the combination of device and i-node number uniquely
      * identify a file.
      */
-    dev_t  device;      /*file device number    */
-    ino_t  inode;      /*file i-node number    */
+    dev_t device; /*file device number    */
+    ino_t inode;  /*file i-node number    */
 #else
     /*
      * On H5_HAVE_WIN32_API the low-order word of a unique identifier associated with the
@@ -113,34 +112,31 @@ typedef struct H5FD_direct_t {
  *      which can be addressed entirely by the second
  *      argument of the file seek function.
  */
-#define MAXADDR (((haddr_t)1 << (8 * sizeof(HDoff_t) - 1)) - 1)
-#define ADDR_OVERFLOW(A)  (HADDR_UNDEF == (A) || ((A) & ~(haddr_t)MAXADDR))
-#define SIZE_OVERFLOW(Z)  ((Z) & ~(hsize_t)MAXADDR)
-#define REGION_OVERFLOW(A,Z)  (ADDR_OVERFLOW(A) || SIZE_OVERFLOW(Z) ||  \
-                                 HADDR_UNDEF == (A) + (Z) ||            \
-                                 (HDoff_t)((A) + (Z)) < (HDoff_t)(A))
+#define MAXADDR          (((haddr_t)1 << (8 * sizeof(HDoff_t) - 1)) - 1)
+#define ADDR_OVERFLOW(A) (HADDR_UNDEF == (A) || ((A) & ~(haddr_t)MAXADDR))
+#define SIZE_OVERFLOW(Z) ((Z) & ~(hsize_t)MAXADDR)
+#define REGION_OVERFLOW(A, Z)                                                                                \
+    (ADDR_OVERFLOW(A) || SIZE_OVERFLOW(Z) || HADDR_UNDEF == (A) + (Z) || (HDoff_t)((A) + (Z)) < (HDoff_t)(A))
 
 /* Prototypes */
-static herr_t H5FD__direct_term(void);
-static void *H5FD__direct_fapl_get(H5FD_t *file);
-static void *H5FD__direct_fapl_copy(const void *_old_fa);
-static H5FD_t *H5FD__direct_open(const char *name, unsigned flags, hid_t fapl_id,
-            haddr_t maxaddr);
-static herr_t H5FD__direct_close(H5FD_t *_file);
-static int H5FD__direct_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
-static herr_t H5FD__direct_query(const H5FD_t *_f1, unsigned long *flags);
+static herr_t  H5FD__direct_term(void);
+static void *  H5FD__direct_fapl_get(H5FD_t *file);
+static void *  H5FD__direct_fapl_copy(const void *_old_fa);
+static H5FD_t *H5FD__direct_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr);
+static herr_t  H5FD__direct_close(H5FD_t *_file);
+static int     H5FD__direct_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
+static herr_t  H5FD__direct_query(const H5FD_t *_f1, unsigned long *flags);
 static haddr_t H5FD__direct_get_eoa(const H5FD_t *_file, H5FD_mem_t type);
-static herr_t H5FD__direct_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr);
+static herr_t  H5FD__direct_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr);
 static haddr_t H5FD__direct_get_eof(const H5FD_t *_file, H5FD_mem_t type);
-static herr_t  H5FD__direct_get_handle(H5FD_t *_file, hid_t fapl, void** file_handle);
-static herr_t H5FD__direct_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr,
-           size_t size, void *buf);
-static herr_t H5FD__direct_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__direct_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
-static herr_t H5FD__direct_lock(H5FD_t *_file, hbool_t rw);
-static herr_t H5FD__direct_unlock(H5FD_t *_file);
-
+static herr_t  H5FD__direct_get_handle(H5FD_t *_file, hid_t fapl, void **file_handle);
+static herr_t  H5FD__direct_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr, size_t size,
+                                 void *buf);
+static herr_t  H5FD__direct_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__direct_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
+static herr_t  H5FD__direct_lock(H5FD_t *_file, hbool_t rw);
+static herr_t  H5FD__direct_unlock(H5FD_t *_file);
 
 static const H5FD_class_t H5FD_direct_g = {
     "direct",                   /* name                 */
@@ -174,13 +170,12 @@ static const H5FD_class_t H5FD_direct_g = {
     H5FD__direct_truncate,      /* truncate             */
     H5FD__direct_lock,          /* lock                 */
     H5FD__direct_unlock,        /* unlock               */
-    H5FD_FLMAP_DICHOTOMY       	/* fl_map               */
+    H5FD_FLMAP_DICHOTOMY        /* fl_map               */
 };
 
 /* Declare a free list to manage the H5FD_direct_t struct */
 H5FL_DEFINE_STATIC(H5FD_direct_t);
 
-
 /*--------------------------------------------------------------------------
 NAME
    H5FD__init_package -- Initialize interface-specific information
@@ -196,28 +191,27 @@ DESCRIPTION
 static herr_t
 H5FD__init_package(void)
 {
-    char    *lock_env_var   = NULL;     /* Environment variable pointer */
-    herr_t ret_value = SUCCEED;
+    char * lock_env_var = NULL; /* Environment variable pointer */
+    herr_t ret_value    = SUCCEED;
 
     FUNC_ENTER_STATIC
 
     /* Check the use disabled file locks environment variable */
     lock_env_var = HDgetenv("HDF5_USE_FILE_LOCKING");
-    if(lock_env_var && !HDstrcmp(lock_env_var, "BEST_EFFORT"))
-        ignore_disabled_file_locks_s = TRUE;    /* Override: Ignore disabled locks */
-    else if(lock_env_var && (!HDstrcmp(lock_env_var, "TRUE") || !HDstrcmp(lock_env_var, "1")))
-        ignore_disabled_file_locks_s = FALSE;   /* Override: Don't ignore disabled locks */
+    if (lock_env_var && !HDstrcmp(lock_env_var, "BEST_EFFORT"))
+        ignore_disabled_file_locks_s = TRUE; /* Override: Ignore disabled locks */
+    else if (lock_env_var && (!HDstrcmp(lock_env_var, "TRUE") || !HDstrcmp(lock_env_var, "1")))
+        ignore_disabled_file_locks_s = FALSE; /* Override: Don't ignore disabled locks */
     else
-        ignore_disabled_file_locks_s = FAIL;    /* Environment variable not set, or not set correctly */
+        ignore_disabled_file_locks_s = FAIL; /* Environment variable not set, or not set correctly */
 
-    if(H5FD_direct_init() < 0)
+    if (H5FD_direct_init() < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "unable to initialize direct VFD")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5FD__init_package() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD_direct_init
  *
@@ -235,12 +229,12 @@ done:
 hid_t
 H5FD_direct_init(void)
 {
-    hid_t ret_value = H5I_INVALID_HID;        /* Return value */
+    hid_t ret_value = H5I_INVALID_HID; /* Return value */
 
     FUNC_ENTER_NOAPI(H5I_INVALID_HID)
 
     if (H5I_VFL != H5I_get_type(H5FD_DIRECT_g))
-        H5FD_DIRECT_g = H5FD_register(&H5FD_direct_g,sizeof(H5FD_class_t),FALSE);
+        H5FD_DIRECT_g = H5FD_register(&H5FD_direct_g, sizeof(H5FD_class_t), FALSE);
 
     /* Set return value */
     ret_value = H5FD_DIRECT_g;
@@ -249,7 +243,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_direct_init() */
 
-
 /*---------------------------------------------------------------------------
  * Function:  H5FD__direct_term
  *
@@ -268,12 +261,11 @@ H5FD__direct_term(void)
     FUNC_ENTER_STATIC_NOERR
 
     /* Reset VFL ID */
-    H5FD_DIRECT_g=0;
+    H5FD_DIRECT_g = 0;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5FD__direct_term() */
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5Pset_fapl_direct
  *
@@ -291,26 +283,26 @@ H5FD__direct_term(void)
 herr_t
 H5Pset_fapl_direct(hid_t fapl_id, size_t boundary, size_t block_size, size_t cbuf_size)
 {
-    H5P_genplist_t      *plist;      /* Property list pointer */
-    H5FD_direct_fapl_t  fa;
-    herr_t     ret_value;
+    H5P_genplist_t *   plist; /* Property list pointer */
+    H5FD_direct_fapl_t fa;
+    herr_t             ret_value;
 
     FUNC_ENTER_API(FAIL)
     H5TRACE4("e", "izzz", fapl_id, boundary, block_size, cbuf_size);
 
-    if(NULL == (plist = H5P_object_verify(fapl_id,H5P_FILE_ACCESS)))
+    if (NULL == (plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list")
 
     HDmemset(&fa, 0, sizeof(H5FD_direct_fapl_t));
-    if(boundary != 0)
+    if (boundary != 0)
         fa.mboundary = boundary;
     else
         fa.mboundary = MBOUNDARY_DEF;
-    if(block_size != 0)
+    if (block_size != 0)
         fa.fbsize = block_size;
     else
         fa.fbsize = FBSIZE_DEF;
-    if(cbuf_size != 0)
+    if (cbuf_size != 0)
         fa.cbsize = cbuf_size;
     else
         fa.cbsize = CBSIZE_DEF;
@@ -319,7 +311,7 @@ H5Pset_fapl_direct(hid_t fapl_id, size_t boundary, size_t block_size, size_t cbu
     fa.must_align = TRUE;
 
     /* Copy buffer size must be a multiple of file block size */
-    if(fa.cbsize % fa.fbsize != 0)
+    if (fa.cbsize % fa.fbsize != 0)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "copy buffer size must be a multiple of block size")
 
     ret_value = H5P_set_driver(plist, H5FD_DIRECT, &fa);
@@ -328,7 +320,6 @@ done:
     FUNC_LEAVE_API(ret_value)
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5Pget_fapl_direct
  *
@@ -345,25 +336,25 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Pget_fapl_direct(hid_t fapl_id, size_t *boundary/*out*/, size_t *block_size/*out*/,
-    size_t *cbuf_size/*out*/)
+H5Pget_fapl_direct(hid_t fapl_id, size_t *boundary /*out*/, size_t *block_size /*out*/,
+                   size_t *cbuf_size /*out*/)
 {
-    H5P_genplist_t *plist;      /* Property list pointer */
-    const H5FD_direct_fapl_t  *fa;
-    herr_t      ret_value = SUCCEED;       /* Return value */
+    H5P_genplist_t *          plist; /* Property list pointer */
+    const H5FD_direct_fapl_t *fa;
+    herr_t                    ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE4("e", "ixxx", fapl_id, boundary, block_size, cbuf_size);
 
-    if(NULL == (plist = H5P_object_verify(fapl_id,H5P_FILE_ACCESS)))
+    if (NULL == (plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access list")
-    if(H5FD_DIRECT != H5P_peek_driver(plist))
+    if (H5FD_DIRECT != H5P_peek_driver(plist))
         HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "incorrect VFL driver")
-    if(NULL == (fa = H5P_peek_driver_info(plist)))
+    if (NULL == (fa = H5P_peek_driver_info(plist)))
         HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "bad VFL driver info")
-    if(boundary)
+    if (boundary)
         *boundary = fa->mboundary;
-    if(block_size)
+    if (block_size)
         *block_size = fa->fbsize;
     if (cbuf_size)
         *cbuf_size = fa->cbsize;
@@ -372,7 +363,6 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Pget_fapl_direct() */
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5FD__direct_fapl_get
  *
@@ -393,19 +383,18 @@ done:
 static void *
 H5FD__direct_fapl_get(H5FD_t *_file)
 {
-    H5FD_direct_t  *file = (H5FD_direct_t*)_file;
-    void *ret_value;    /* Return value */
+    H5FD_direct_t *file = (H5FD_direct_t *)_file;
+    void *         ret_value; /* Return value */
 
     FUNC_ENTER_STATIC
 
     /* Set return value */
-    ret_value= H5FD__direct_fapl_copy(&(file->fa));
+    ret_value = H5FD__direct_fapl_copy(&(file->fa));
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD__direct_fapl_get() */
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5FD__direct_fapl_copy
  *
@@ -423,8 +412,8 @@ done:
 static void *
 H5FD__direct_fapl_copy(const void *_old_fa)
 {
-    const H5FD_direct_fapl_t *old_fa = (const H5FD_direct_fapl_t*)_old_fa;
-    H5FD_direct_fapl_t *new_fa = H5MM_calloc(sizeof(H5FD_direct_fapl_t));
+    const H5FD_direct_fapl_t *old_fa = (const H5FD_direct_fapl_t *)_old_fa;
+    H5FD_direct_fapl_t *      new_fa = H5MM_calloc(sizeof(H5FD_direct_fapl_t));
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -436,7 +425,6 @@ H5FD__direct_fapl_copy(const void *_old_fa)
     FUNC_LEAVE_NOAPI(new_fa)
 } /* end H5FD__direct_fapl_copy() */
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5FD__direct_open
  *
@@ -456,62 +444,65 @@ H5FD__direct_fapl_copy(const void *_old_fa)
 static H5FD_t *
 H5FD__direct_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
 {
-    int      o_flags;
-    int      fd=(-1);
-    H5FD_direct_t  *file=NULL;
-    H5FD_direct_fapl_t  *fa;
+    int                 o_flags;
+    int                 fd   = (-1);
+    H5FD_direct_t *     file = NULL;
+    H5FD_direct_fapl_t *fa;
 #ifdef H5_HAVE_WIN32_API
-    HFILE     filehandle;
+    HFILE                              filehandle;
     struct _BY_HANDLE_FILE_INFORMATION fileinfo;
 #endif
-    h5_stat_t    sb;
-    H5P_genplist_t   *plist;      /* Property list */
-    void                 *buf1, *buf2;
-    H5FD_t    *ret_value = NULL;
+    h5_stat_t       sb;
+    H5P_genplist_t *plist; /* Property list */
+    void *          buf1, *buf2;
+    H5FD_t *        ret_value = NULL;
 
     FUNC_ENTER_STATIC
 
     /* Sanity check on file offsets */
-    HDassert(sizeof(HDoff_t)>=sizeof(size_t));
+    HDassert(sizeof(HDoff_t) >= sizeof(size_t));
 
     /* Check arguments */
     if (!name || !*name)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid file name")
-    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))
         HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, NULL, "bogus maxaddr")
 
     /* Build the open flags */
     o_flags = (H5F_ACC_RDWR & flags) ? O_RDWR : O_RDONLY;
-    if (H5F_ACC_TRUNC & flags) o_flags |= O_TRUNC;
-    if (H5F_ACC_CREAT & flags) o_flags |= O_CREAT;
-    if (H5F_ACC_EXCL & flags) o_flags |= O_EXCL;
+    if (H5F_ACC_TRUNC & flags)
+        o_flags |= O_TRUNC;
+    if (H5F_ACC_CREAT & flags)
+        o_flags |= O_CREAT;
+    if (H5F_ACC_EXCL & flags)
+        o_flags |= O_EXCL;
 
     /* Flag for Direct I/O */
     o_flags |= O_DIRECT;
 
     /* Open the file */
-    if ((fd = HDopen(name, o_flags, H5_POSIX_CREATE_MODE_RW))<0)
+    if ((fd = HDopen(name, o_flags, H5_POSIX_CREATE_MODE_RW)) < 0)
         HSYS_GOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "unable to open file")
 
-    if (HDfstat(fd, &sb)<0)
+    if (HDfstat(fd, &sb) < 0)
         HSYS_GOTO_ERROR(H5E_FILE, H5E_BADFILE, NULL, "unable to fstat file")
 
     /* Create the new file struct */
-    if (NULL==(file=H5FL_CALLOC(H5FD_direct_t)))
+    if (NULL == (file = H5FL_CALLOC(H5FD_direct_t)))
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "unable to allocate file struct")
 
     /* Get the driver specific information */
-    if(NULL == (plist = H5P_object_verify(fapl_id,H5P_FILE_ACCESS)))
+    if (NULL == (plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a file access property list")
-    if(NULL == (fa = (H5FD_direct_fapl_t *)H5P_peek_driver_info(plist)))
+    if (NULL == (fa = (H5FD_direct_fapl_t *)H5P_peek_driver_info(plist)))
         HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, NULL, "bad VFL driver info")
 
     file->fd = fd;
     H5_CHECKED_ASSIGN(file->eof, haddr_t, sb.st_size, h5_stat_size_t);
     file->pos = HADDR_UNDEF;
-    file->op = OP_UNKNOWN;
+    file->op  = OP_UNKNOWN;
 #ifdef H5_HAVE_WIN32_API
     filehandle = _get_osfhandle(fd);
     (void)GetFileInformationByHandle((HANDLE)filehandle, &fileinfo);
@@ -519,19 +510,19 @@ H5FD__direct_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxad
     file->fileindexlo = fileinfo.nFileIndexLow;
 #else
     file->device = sb.st_dev;
-    file->inode = sb.st_ino;
+    file->inode  = sb.st_ino;
 #endif /*H5_HAVE_WIN32_API*/
     file->fa.mboundary = fa->mboundary;
-    file->fa.fbsize = fa->fbsize;
-    file->fa.cbsize = fa->cbsize;
+    file->fa.fbsize    = fa->fbsize;
+    file->fa.cbsize    = fa->cbsize;
 
     /* Check the file locking flags in the fapl */
-    if(ignore_disabled_file_locks_s != FAIL)
+    if (ignore_disabled_file_locks_s != FAIL)
         /* The environment variable was set, so use that preferentially */
         file->ignore_disabled_file_locks = ignore_disabled_file_locks_s;
     else {
         /* Use the value in the property list */
-        if(H5P_get(plist, H5F_ACS_IGNORE_DISABLED_FILE_LOCKS_NAME, &file->ignore_disabled_file_locks) < 0)
+        if (H5P_get(plist, H5F_ACS_IGNORE_DISABLED_FILE_LOCKS_NAME, &file->ignore_disabled_file_locks) < 0)
             HGOTO_ERROR(H5E_VFL, H5E_CANTGET, NULL, "can't get ignore disabled file locks property")
     }
 
@@ -543,56 +534,59 @@ H5FD__direct_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxad
      *       HDposix_memalign.
      */
     buf1 = HDmalloc(sizeof(int));
-    if(HDposix_memalign(&buf2, file->fa.mboundary, file->fa.fbsize) != 0)
+    if (HDposix_memalign(&buf2, file->fa.mboundary, file->fa.fbsize) != 0)
         HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, NULL, "HDposix_memalign failed")
 
-    if(o_flags & O_CREAT) {
-        if(HDwrite(file->fd, buf1, sizeof(int))<0) {
-            if(HDwrite(file->fd, buf2, file->fa.fbsize)<0)
+    if (o_flags & O_CREAT) {
+        if (HDwrite(file->fd, buf1, sizeof(int)) < 0) {
+            if (HDwrite(file->fd, buf2, file->fa.fbsize) < 0)
                 HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, NULL, "file system may not support Direct I/O")
             else
                 file->fa.must_align = TRUE;
-        } else {
+        }
+        else {
             file->fa.must_align = FALSE;
             HDftruncate(file->fd, (HDoff_t)0);
         }
-    } else {
-        if(HDread(file->fd, buf1, sizeof(int))<0) {
-            if(HDread(file->fd, buf2, file->fa.fbsize)<0)
+    }
+    else {
+        if (HDread(file->fd, buf1, sizeof(int)) < 0) {
+            if (HDread(file->fd, buf2, file->fa.fbsize) < 0)
                 HGOTO_ERROR(H5E_FILE, H5E_READERROR, NULL, "file system may not support Direct I/O")
             else
                 file->fa.must_align = TRUE;
-        } else {
-            if(o_flags & O_RDWR) {
-                if(HDlseek(file->fd, (HDoff_t)0, SEEK_SET) < 0)
+        }
+        else {
+            if (o_flags & O_RDWR) {
+                if (HDlseek(file->fd, (HDoff_t)0, SEEK_SET) < 0)
                     HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, NULL, "unable to seek to proper position")
-                if(HDwrite(file->fd, buf1, sizeof(int))<0)
+                if (HDwrite(file->fd, buf1, sizeof(int)) < 0)
                     file->fa.must_align = TRUE;
                 else
                     file->fa.must_align = FALSE;
-            } else
+            }
+            else
                 file->fa.must_align = FALSE;
         }
     }
 
-    if(buf1)
+    if (buf1)
         HDfree(buf1);
-    if(buf2)
+    if (buf2)
         HDfree(buf2);
 
     /* Set return value */
-    ret_value=(H5FD_t*)file;
+    ret_value = (H5FD_t *)file;
 
 done:
-    if(ret_value==NULL) {
-        if(fd>=0)
+    if (ret_value == NULL) {
+        if (fd >= 0)
             HDclose(fd);
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5FD__direct_close
  *
@@ -610,21 +604,20 @@ done:
 static herr_t
 H5FD__direct_close(H5FD_t *_file)
 {
-    H5FD_direct_t  *file = (H5FD_direct_t*)_file;
-    herr_t        ret_value=SUCCEED;       /* Return value */
+    H5FD_direct_t *file      = (H5FD_direct_t *)_file;
+    herr_t         ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
-    if (HDclose(file->fd)<0)
+    if (HDclose(file->fd) < 0)
         HSYS_GOTO_ERROR(H5E_IO, H5E_CANTCLOSEFILE, FAIL, "unable to close file")
 
-    H5FL_FREE(H5FD_direct_t,file);
+    H5FL_FREE(H5FD_direct_t, file);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5FD__direct_cmp
  *
@@ -644,34 +637,44 @@ done:
 static int
 H5FD__direct_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
 {
-    const H5FD_direct_t  *f1 = (const H5FD_direct_t*)_f1;
-    const H5FD_direct_t  *f2 = (const H5FD_direct_t*)_f2;
-    int ret_value=0;
+    const H5FD_direct_t *f1        = (const H5FD_direct_t *)_f1;
+    const H5FD_direct_t *f2        = (const H5FD_direct_t *)_f2;
+    int                  ret_value = 0;
 
     FUNC_ENTER_STATIC_NOERR
 
 #ifdef H5_HAVE_WIN32_API
-    if (f1->fileindexhi < f2->fileindexhi) HGOTO_DONE(-1)
-    if (f1->fileindexhi > f2->fileindexhi) HGOTO_DONE(1)
+    if (f1->fileindexhi < f2->fileindexhi)
+        HGOTO_DONE(-1)
+    if (f1->fileindexhi > f2->fileindexhi)
+        HGOTO_DONE(1)
 
-    if (f1->fileindexlo < f2->fileindexlo) HGOTO_DONE(-1)
-    if (f1->fileindexlo > f2->fileindexlo) HGOTO_DONE(1)
+    if (f1->fileindexlo < f2->fileindexlo)
+        HGOTO_DONE(-1)
+    if (f1->fileindexlo > f2->fileindexlo)
+        HGOTO_DONE(1)
 
 #else
 #ifdef H5_DEV_T_IS_SCALAR
-    if (f1->device < f2->device) HGOTO_DONE(-1)
-    if (f1->device > f2->device) HGOTO_DONE(1)
-#else /* H5_DEV_T_IS_SCALAR */
+    if (f1->device < f2->device)
+        HGOTO_DONE(-1)
+    if (f1->device > f2->device)
+        HGOTO_DONE(1)
+#else  /* H5_DEV_T_IS_SCALAR */
     /* If dev_t isn't a scalar value on this system, just use memcmp to
      * determine if the values are the same or not.  The actual return value
      * shouldn't really matter...
      */
-    if(HDmemcmp(&(f1->device),&(f2->device),sizeof(dev_t))<0) HGOTO_DONE(-1)
-    if(HDmemcmp(&(f1->device),&(f2->device),sizeof(dev_t))>0) HGOTO_DONE(1)
+    if (HDmemcmp(&(f1->device), &(f2->device), sizeof(dev_t)) < 0)
+        HGOTO_DONE(-1)
+    if (HDmemcmp(&(f1->device), &(f2->device), sizeof(dev_t)) > 0)
+        HGOTO_DONE(1)
 #endif /* H5_DEV_T_IS_SCALAR */
 
-    if (f1->inode < f2->inode) HGOTO_DONE(-1)
-    if (f1->inode > f2->inode) HGOTO_DONE(1)
+    if (f1->inode < f2->inode)
+        HGOTO_DONE(-1)
+    if (f1->inode > f2->inode)
+        HGOTO_DONE(1)
 
 #endif
 
@@ -679,7 +682,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5FD__direct_query
  *
@@ -696,24 +698,24 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD__direct_query(const H5FD_t H5_ATTR_UNUSED * _f, unsigned long *flags /* out */)
+H5FD__direct_query(const H5FD_t H5_ATTR_UNUSED *_f, unsigned long *flags /* out */)
 {
     FUNC_ENTER_STATIC_NOERR
 
     /* Set the VFL feature flags that this driver supports */
-    if(flags) {
+    if (flags) {
         *flags = 0;
-        *flags |= H5FD_FEAT_AGGREGATE_METADATA;     /* OK to aggregate metadata allocations                             */
-        *flags |= H5FD_FEAT_ACCUMULATE_METADATA;    /* OK to accumulate metadata for faster writes                      */
-        *flags |= H5FD_FEAT_DATA_SIEVE;             /* OK to perform data sieving for faster raw data reads & writes    */
-        *flags |= H5FD_FEAT_AGGREGATE_SMALLDATA;    /* OK to aggregate "small" raw data allocations                     */
-        *flags |= H5FD_FEAT_DEFAULT_VFD_COMPATIBLE; /* VFD creates a file which can be opened with the default VFD      */
+        *flags |= H5FD_FEAT_AGGREGATE_METADATA;  /* OK to aggregate metadata allocations  */
+        *flags |= H5FD_FEAT_ACCUMULATE_METADATA; /* OK to accumulate metadata for faster writes */
+        *flags |= H5FD_FEAT_DATA_SIEVE; /* OK to perform data sieving for faster raw data reads & writes    */
+        *flags |= H5FD_FEAT_AGGREGATE_SMALLDATA;    /* OK to aggregate "small" raw data allocations    */
+        *flags |= H5FD_FEAT_DEFAULT_VFD_COMPATIBLE; /* VFD creates a file which can be opened with the default
+                                                       VFD      */
     }
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5FD__direct_get_eoa
  *
@@ -733,14 +735,13 @@ H5FD__direct_query(const H5FD_t H5_ATTR_UNUSED * _f, unsigned long *flags /* out
 static haddr_t
 H5FD__direct_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
-    const H5FD_direct_t  *file = (const H5FD_direct_t*)_file;
+    const H5FD_direct_t *file = (const H5FD_direct_t *)_file;
 
     FUNC_ENTER_STATIC_NOERR
 
     FUNC_LEAVE_NOAPI(file->eoa)
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5FD__direct_set_eoa
  *
@@ -760,7 +761,7 @@ H5FD__direct_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 static herr_t
 H5FD__direct_set_eoa(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr)
 {
-    H5FD_direct_t  *file = (H5FD_direct_t*)_file;
+    H5FD_direct_t *file = (H5FD_direct_t *)_file;
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -769,7 +770,6 @@ H5FD__direct_set_eoa(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr
     FUNC_LEAVE_NOAPI(SUCCEED)
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5FD__direct_get_eof
  *
@@ -791,14 +791,13 @@ H5FD__direct_set_eoa(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr
 static haddr_t
 H5FD__direct_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
-    const H5FD_direct_t  *file = (const H5FD_direct_t*)_file;
+    const H5FD_direct_t *file = (const H5FD_direct_t *)_file;
 
     FUNC_ENTER_STATIC
 
     FUNC_LEAVE_NOAPI(file->eof)
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:       H5FD_diect_get_handle
  *
@@ -812,14 +811,14 @@ H5FD__direct_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD__direct_get_handle(H5FD_t *_file, hid_t H5_ATTR_UNUSED fapl, void** file_handle)
+H5FD__direct_get_handle(H5FD_t *_file, hid_t H5_ATTR_UNUSED fapl, void **file_handle)
 {
-    H5FD_direct_t       *file = (H5FD_direct_t *)_file;
-    herr_t              ret_value = SUCCEED;
+    H5FD_direct_t *file      = (H5FD_direct_t *)_file;
+    herr_t         ret_value = SUCCEED;
 
     FUNC_ENTER_STATIC
 
-    if(!file_handle)
+    if (!file_handle)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file handle not valid")
     *file_handle = &(file->fd);
 
@@ -827,7 +826,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5FD__direct_read
  *
@@ -847,20 +845,20 @@ done:
  */
 static herr_t
 H5FD__direct_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/*out*/)
+                  size_t size, void *buf /*out*/)
 {
-    H5FD_direct_t  *file = (H5FD_direct_t*)_file;
-    ssize_t    nbytes;
-    hbool_t    _must_align = TRUE;
-    herr_t        ret_value=SUCCEED;       /* Return value */
-    size_t    alloc_size;
-    void    *copy_buf = NULL, *p2;
-    size_t    _boundary;
-    size_t    _fbsize;
-    size_t    _cbsize;
-    haddr_t    read_size;              /* Size to read into copy buffer */
-    size_t    copy_size = size;       /* Size remaining to read when using copy buffer */
-    size_t              copy_offset;            /* Offset into copy buffer of the requested data */
+    H5FD_direct_t *file = (H5FD_direct_t *)_file;
+    ssize_t        nbytes;
+    hbool_t        _must_align = TRUE;
+    herr_t         ret_value   = SUCCEED; /* Return value */
+    size_t         alloc_size;
+    void *         copy_buf = NULL, *p2;
+    size_t         _boundary;
+    size_t         _fbsize;
+    size_t         _cbsize;
+    haddr_t        read_size;        /* Size to read into copy buffer */
+    size_t         copy_size = size; /* Size remaining to read when using copy buffer */
+    size_t         copy_offset;      /* Offset into copy buffer of the requested data */
 
     FUNC_ENTER_STATIC
 
@@ -868,7 +866,7 @@ H5FD__direct_read(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_U
     HDassert(buf);
 
     /* Check for overflow conditions */
-    if (HADDR_UNDEF==addr)
+    if (HADDR_UNDEF == addr)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined")
     if (REGION_OVERFLOW(addr, size))
         HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow")
@@ -882,136 +880,133 @@ H5FD__direct_read(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_U
      * copy buffer size.
      */
     _boundary = file->fa.mboundary;
-    _fbsize = file->fa.fbsize;
-    _cbsize = file->fa.cbsize;
+    _fbsize   = file->fa.fbsize;
+    _cbsize   = file->fa.cbsize;
 
     /* if the data is aligned or the system doesn't require data to be aligned,
      * read it directly from the file.  If not, read a bigger
      * and aligned data first, then copy the data into memory buffer.
      */
-    if(!_must_align || ((addr%_fbsize==0) && (size%_fbsize==0) && ((size_t)buf%_boundary==0))) {
-      /* Seek to the correct location */
-      if ((addr!=file->pos || OP_READ!=file->op) &&
-        HDlseek(file->fd, (HDoff_t)addr, SEEK_SET)<0)
-    HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
-       /* Read the aligned data in file first, being careful of interrupted
-       * system calls and partial results. */
-      while (size>0) {
-    do {
-        nbytes = HDread(file->fd, buf, size);
-    } while (-1==nbytes && EINTR==errno);
-    if (-1==nbytes) /* error */
-        HSYS_GOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "file read failed")
-    if (0==nbytes) {
-        /* end of file but not end of format address space */
-        HDmemset(buf, 0, size);
-        break;
+    if (!_must_align || ((addr % _fbsize == 0) && (size % _fbsize == 0) && ((size_t)buf % _boundary == 0))) {
+        /* Seek to the correct location */
+        if ((addr != file->pos || OP_READ != file->op) && HDlseek(file->fd, (HDoff_t)addr, SEEK_SET) < 0)
+            HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
+        /* Read the aligned data in file first, being careful of interrupted
+         * system calls and partial results. */
+        while (size > 0) {
+            do {
+                nbytes = HDread(file->fd, buf, size);
+            } while (-1 == nbytes && EINTR == errno);
+            if (-1 == nbytes) /* error */
+                HSYS_GOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "file read failed")
+            if (0 == nbytes) {
+                /* end of file but not end of format address space */
+                HDmemset(buf, 0, size);
+                break;
+            }
+            HDassert(nbytes >= 0);
+            HDassert((size_t)nbytes <= size);
+            H5_CHECK_OVERFLOW(nbytes, ssize_t, size_t);
+            size -= (size_t)nbytes;
+            H5_CHECK_OVERFLOW(nbytes, ssize_t, haddr_t);
+            addr += (haddr_t)nbytes;
+            buf = (char *)buf + nbytes;
+        }
     }
-    HDassert(nbytes>=0);
-    HDassert((size_t)nbytes<=size);
-    H5_CHECK_OVERFLOW(nbytes,ssize_t,size_t);
-    size -= (size_t)nbytes;
-    H5_CHECK_OVERFLOW(nbytes,ssize_t,haddr_t);
-    addr += (haddr_t)nbytes;
-    buf = (char*)buf + nbytes;
-      }
-    } else {
-            /* Calculate where we will begin copying from the copy buffer */
-            copy_offset = (size_t)(addr % _fbsize);
-
-      /* allocate memory needed for the Direct IO option up to the maximal
-       * copy buffer size. Make a bigger buffer for aligned I/O if size is
-       * smaller than maximal copy buffer. */
-      alloc_size = ((copy_offset + size - 1) / _fbsize + 1) * _fbsize;
-      if(alloc_size > _cbsize)
-        alloc_size = _cbsize;
-      HDassert(!(alloc_size % _fbsize));
-      if (HDposix_memalign(&copy_buf, _boundary, alloc_size) != 0)
-    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "HDposix_memalign failed")
-
-            /* look for the aligned position for reading the data */
-            HDassert(!(((addr / _fbsize) * _fbsize) % _fbsize));
-            if(HDlseek(file->fd, (HDoff_t)((addr / _fbsize) * _fbsize),
-                    SEEK_SET) < 0)
-                HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
-
-      /*
-       * Read the aligned data in file into aligned buffer first, then copy the data
-       * into the final buffer.  If the data size is bigger than maximal copy buffer
-       * size, do the reading by segment (the outer while loop).  If not, do one step
-       * reading.
-       */
-      do {
-         /* Read the aligned data in file first.  Not able to handle interrupted
-     * system calls and partial results like sec2 driver does because the
-     * data may no longer be aligned. It's especially true when the data in
-     * file is smaller than ALLOC_SIZE. */
-        HDmemset(copy_buf, 0, alloc_size);
-
-                /* Calculate how much data we have to read in this iteration
-                 * (including unused parts of blocks) */
-                if((copy_size + copy_offset) < alloc_size)
-                    read_size = ((copy_size + copy_offset - 1) / _fbsize + 1)
-                            * _fbsize;
-                else
-                    read_size = alloc_size;
+    else {
+        /* Calculate where we will begin copying from the copy buffer */
+        copy_offset = (size_t)(addr % _fbsize);
+
+        /* allocate memory needed for the Direct IO option up to the maximal
+         * copy buffer size. Make a bigger buffer for aligned I/O if size is
+         * smaller than maximal copy buffer. */
+        alloc_size = ((copy_offset + size - 1) / _fbsize + 1) * _fbsize;
+        if (alloc_size > _cbsize)
+            alloc_size = _cbsize;
+        HDassert(!(alloc_size % _fbsize));
+        if (HDposix_memalign(&copy_buf, _boundary, alloc_size) != 0)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "HDposix_memalign failed")
+
+        /* look for the aligned position for reading the data */
+        HDassert(!(((addr / _fbsize) * _fbsize) % _fbsize));
+        if (HDlseek(file->fd, (HDoff_t)((addr / _fbsize) * _fbsize), SEEK_SET) < 0)
+            HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
 
-                HDassert(!(read_size % _fbsize));
+        /*
+         * Read the aligned data in file into aligned buffer first, then copy the data
+         * into the final buffer.  If the data size is bigger than maximal copy buffer
+         * size, do the reading by segment (the outer while loop).  If not, do one step
+         * reading.
+         */
         do {
-        nbytes = HDread(file->fd, copy_buf, read_size);
-        } while(-1==nbytes && EINTR==errno);
-
-        if (-1==nbytes) /* error */
-        HSYS_GOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "file read failed")
-
-        /* Copy the needed data from the copy buffer to the output
-         * buffer, and update copy_size.  If the copy buffer does not
-                 * contain the rest of the data, just copy what's in the copy
-                 * buffer and also update read_addr and copy_offset to read the
-                 * next section of data. */
-        p2 = (unsigned char*)copy_buf + copy_offset;
-        if((copy_size + copy_offset) <= alloc_size) {
-            H5MM_memcpy(buf, p2, copy_size);
-            buf = (unsigned char *)buf + copy_size;
-            copy_size = 0;
-                } /* end if */
-                else {
-                    H5MM_memcpy(buf, p2, alloc_size - copy_offset);
-                    buf = (unsigned char*)buf + alloc_size - copy_offset;
-                    copy_size -= alloc_size - copy_offset;
-                    copy_offset = 0;
-                } /* end else */
-      } while (copy_size > 0);
-
-      /*Final step: update address*/
-      addr = (haddr_t)(((addr + size - 1) / _fbsize + 1) * _fbsize);
-
-      if(copy_buf) {
-                /* Free with HDfree since it came from posix_memalign */
-                HDfree(copy_buf);
-                copy_buf = NULL;
+            /* Read the aligned data in file first.  Not able to handle interrupted
+             * system calls and partial results like sec2 driver does because the
+             * data may no longer be aligned. It's especially true when the data in
+             * file is smaller than ALLOC_SIZE. */
+            HDmemset(copy_buf, 0, alloc_size);
+
+            /* Calculate how much data we have to read in this iteration
+             * (including unused parts of blocks) */
+            if ((copy_size + copy_offset) < alloc_size)
+                read_size = ((copy_size + copy_offset - 1) / _fbsize + 1) * _fbsize;
+            else
+                read_size = alloc_size;
+
+            HDassert(!(read_size % _fbsize));
+            do {
+                nbytes = HDread(file->fd, copy_buf, read_size);
+            } while (-1 == nbytes && EINTR == errno);
+
+            if (-1 == nbytes) /* error */
+                HSYS_GOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "file read failed")
+
+            /* Copy the needed data from the copy buffer to the output
+             * buffer, and update copy_size.  If the copy buffer does not
+             * contain the rest of the data, just copy what's in the copy
+             * buffer and also update read_addr and copy_offset to read the
+             * next section of data. */
+            p2 = (unsigned char *)copy_buf + copy_offset;
+            if ((copy_size + copy_offset) <= alloc_size) {
+                H5MM_memcpy(buf, p2, copy_size);
+                buf       = (unsigned char *)buf + copy_size;
+                copy_size = 0;
             } /* end if */
+            else {
+                H5MM_memcpy(buf, p2, alloc_size - copy_offset);
+                buf = (unsigned char *)buf + alloc_size - copy_offset;
+                copy_size -= alloc_size - copy_offset;
+                copy_offset = 0;
+            } /* end else */
+        } while (copy_size > 0);
+
+        /*Final step: update address*/
+        addr = (haddr_t)(((addr + size - 1) / _fbsize + 1) * _fbsize);
+
+        if (copy_buf) {
+            /* Free with HDfree since it came from posix_memalign */
+            HDfree(copy_buf);
+            copy_buf = NULL;
+        } /* end if */
     }
 
     /* Update current position */
     file->pos = addr;
-    file->op = OP_READ;
+    file->op  = OP_READ;
 
 done:
-    if(ret_value<0) {
+    if (ret_value < 0) {
         /* Free with HDfree since it came from posix_memalign */
-        if(copy_buf)
+        if (copy_buf)
             HDfree(copy_buf);
 
         /* Reset last file I/O information */
         file->pos = HADDR_UNDEF;
-        file->op = OP_UNKNOWN;
+        file->op  = OP_UNKNOWN;
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5FD__direct_write
  *
@@ -1030,23 +1025,23 @@ done:
  */
 static herr_t
 H5FD__direct_write(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr,
-    size_t size, const void *buf)
+                   size_t size, const void *buf)
 {
-    H5FD_direct_t  *file = (H5FD_direct_t*)_file;
-    ssize_t    nbytes;
-    hbool_t    _must_align = TRUE;
-    herr_t        ret_value=SUCCEED;       /* Return value */
-    size_t    alloc_size;
-    void    *copy_buf = NULL, *p1;
-    const void    *p3;
-    size_t    _boundary;
-    size_t    _fbsize;
-    size_t    _cbsize;
-    haddr_t             write_addr;             /* Address to write copy buffer */
-    haddr_t             write_size;             /* Size to write from copy buffer */
-    haddr_t             read_size;              /* Size to read into copy buffer */
-    size_t              copy_size = size;       /* Size remaining to write when using copy buffer */
-    size_t              copy_offset;            /* Offset into copy buffer of the data to write */
+    H5FD_direct_t *file = (H5FD_direct_t *)_file;
+    ssize_t        nbytes;
+    hbool_t        _must_align = TRUE;
+    herr_t         ret_value   = SUCCEED; /* Return value */
+    size_t         alloc_size;
+    void *         copy_buf = NULL, *p1;
+    const void *   p3;
+    size_t         _boundary;
+    size_t         _fbsize;
+    size_t         _cbsize;
+    haddr_t        write_addr;       /* Address to write copy buffer */
+    haddr_t        write_size;       /* Size to write from copy buffer */
+    haddr_t        read_size;        /* Size to read into copy buffer */
+    size_t         copy_size = size; /* Size remaining to write when using copy buffer */
+    size_t         copy_offset;      /* Offset into copy buffer of the data to write */
 
     FUNC_ENTER_STATIC
 
@@ -1054,7 +1049,7 @@ H5FD__direct_write(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_
     HDassert(buf);
 
     /* Check for overflow conditions */
-    if (HADDR_UNDEF==addr)
+    if (HADDR_UNDEF == addr)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined")
     if (REGION_OVERFLOW(addr, size))
         HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow")
@@ -1068,183 +1063,179 @@ H5FD__direct_write(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, hid_t H5_ATTR_
      * copy buffer size.
      */
     _boundary = file->fa.mboundary;
-    _fbsize = file->fa.fbsize;
-    _cbsize = file->fa.cbsize;
+    _fbsize   = file->fa.fbsize;
+    _cbsize   = file->fa.cbsize;
 
     /* if the data is aligned or the system doesn't require data to be aligned,
      * write it directly to the file.  If not, read a bigger and aligned data
      * first, update buffer with user data, then write the data out.
      */
-    if(!_must_align || ((addr%_fbsize==0) && (size%_fbsize==0) && ((size_t)buf%_boundary==0))) {
-      /* Seek to the correct location */
-      if ((addr!=file->pos || OP_WRITE!=file->op) &&
-        HDlseek(file->fd, (HDoff_t)addr, SEEK_SET)<0)
-    HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
-
-      while (size>0) {
-    do {
-        nbytes = HDwrite(file->fd, buf, size);
-    } while (-1==nbytes && EINTR==errno);
-    if (-1==nbytes) /* error */
-        HSYS_GOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "file write failed")
-    HDassert(nbytes>0);
-    HDassert((size_t)nbytes<=size);
-    H5_CHECK_OVERFLOW(nbytes,ssize_t,size_t);
-    size -= (size_t)nbytes;
-    H5_CHECK_OVERFLOW(nbytes,ssize_t,haddr_t);
-    addr += (haddr_t)nbytes;
-    buf = (const char*)buf + nbytes;
-      }
-    } else {
-            /* Calculate where we will begin reading from (on disk) and where we
-             * will begin copying from the copy buffer */
-            write_addr = (addr / _fbsize) * _fbsize;
-            copy_offset = (size_t)(addr % _fbsize);
-
-      /* allocate memory needed for the Direct IO option up to the maximal
-       * copy buffer size. Make a bigger buffer for aligned I/O if size is
-       * smaller than maximal copy buffer.
-       */
-      alloc_size = ((copy_offset + size - 1) / _fbsize + 1) * _fbsize;
-            if(alloc_size > _cbsize)
-                alloc_size = _cbsize;
-            HDassert(!(alloc_size % _fbsize));
-
-      if (HDposix_memalign(&copy_buf, _boundary, alloc_size) != 0)
-    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "HDposix_memalign failed")
-
-            /* look for the right position for reading or writing the data */
-            if(HDlseek(file->fd, (HDoff_t)write_addr, SEEK_SET) < 0)
-                HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
-
-      p3 = buf;
-      do {
-                /* Calculate how much data we have to write in this iteration
-                 * (including unused parts of blocks) */
-                if((copy_size + copy_offset) < alloc_size)
-                    write_size = ((copy_size + copy_offset - 1) / _fbsize + 1)
-                            * _fbsize;
-                else
-                    write_size = alloc_size;
-
-        /*
-          * Read the aligned data first if the aligned region doesn't fall
-         * entirely in the range to be written.  Not able to handle interrupted
-     * system calls and partial results like sec2 driver does because the
-     * data may no longer be aligned. It's especially true when the data in
-     * file is smaller than ALLOC_SIZE.  Only read the entire section if
-                 * both ends are misaligned, otherwise only read the block on the
-                 * misaligned end.
+    if (!_must_align || ((addr % _fbsize == 0) && (size % _fbsize == 0) && ((size_t)buf % _boundary == 0))) {
+        /* Seek to the correct location */
+        if ((addr != file->pos || OP_WRITE != file->op) && HDlseek(file->fd, (HDoff_t)addr, SEEK_SET) < 0)
+            HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
+
+        while (size > 0) {
+            do {
+                nbytes = HDwrite(file->fd, buf, size);
+            } while (-1 == nbytes && EINTR == errno);
+            if (-1 == nbytes) /* error */
+                HSYS_GOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "file write failed")
+            HDassert(nbytes > 0);
+            HDassert((size_t)nbytes <= size);
+            H5_CHECK_OVERFLOW(nbytes, ssize_t, size_t);
+            size -= (size_t)nbytes;
+            H5_CHECK_OVERFLOW(nbytes, ssize_t, haddr_t);
+            addr += (haddr_t)nbytes;
+            buf = (const char *)buf + nbytes;
+        }
+    }
+    else {
+        /* Calculate where we will begin reading from (on disk) and where we
+         * will begin copying from the copy buffer */
+        write_addr  = (addr / _fbsize) * _fbsize;
+        copy_offset = (size_t)(addr % _fbsize);
+
+        /* allocate memory needed for the Direct IO option up to the maximal
+         * copy buffer size. Make a bigger buffer for aligned I/O if size is
+         * smaller than maximal copy buffer.
          */
-        HDmemset(copy_buf, 0, _fbsize);
-
-                if(copy_offset > 0) {
-                    if((write_addr + write_size) > (addr + size)) {
-                        HDassert((write_addr + write_size) - (addr + size) < _fbsize);
-                        read_size = write_size;
-                        p1 = copy_buf;
-                    } /* end if */
-                    else {
-                        read_size = _fbsize;
-                        p1 = copy_buf;
-                    } /* end else */
-                } /* end if */
-                else if((write_addr + write_size) > (addr + size)) {
-                    HDassert((write_addr + write_size) - (addr + size) < _fbsize);
-                    read_size = _fbsize;
-                    p1 = (unsigned char *)copy_buf + write_size - _fbsize;
-
-                    /* Seek to the last block, for reading */
-                    HDassert(!((write_addr + write_size - _fbsize) % _fbsize));
-                    if(HDlseek(file->fd,
-                            (HDoff_t)(write_addr + write_size - _fbsize),
-                            SEEK_SET) < 0)
-                        HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
-                } /* end if */
-                else
-                    p1 = NULL;
+        alloc_size = ((copy_offset + size - 1) / _fbsize + 1) * _fbsize;
+        if (alloc_size > _cbsize)
+            alloc_size = _cbsize;
+        HDassert(!(alloc_size % _fbsize));
 
-                if(p1) {
-                    HDassert(!(read_size % _fbsize));
-                    do {
-                        nbytes = HDread(file->fd, p1, read_size);
-                    } while (-1==nbytes && EINTR==errno);
+        if (HDposix_memalign(&copy_buf, _boundary, alloc_size) != 0)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "HDposix_memalign failed")
 
-                    if (-1==nbytes) /* error */
-                        HSYS_GOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "file read failed")
-                } /* end if */
+        /* look for the right position for reading or writing the data */
+        if (HDlseek(file->fd, (HDoff_t)write_addr, SEEK_SET) < 0)
+            HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
 
-        /* look for the right position and append or copy the data to be written to
-          * the aligned buffer.
-               * Consider all possible situations here: file address is not aligned on
-               * file block size; the end of data address is not aligned; the end of data
-               * address is aligned; data size is smaller or bigger than maximal copy size.
-         */
-        p1 = (unsigned char *)copy_buf + copy_offset;
-        if((copy_size + copy_offset) <= alloc_size) {
-                    H5MM_memcpy(p1, p3, copy_size);
-                    copy_size = 0;
+        p3 = buf;
+        do {
+            /* Calculate how much data we have to write in this iteration
+             * (including unused parts of blocks) */
+            if ((copy_size + copy_offset) < alloc_size)
+                write_size = ((copy_size + copy_offset - 1) / _fbsize + 1) * _fbsize;
+            else
+                write_size = alloc_size;
+
+            /*
+             * Read the aligned data first if the aligned region doesn't fall
+             * entirely in the range to be written.  Not able to handle interrupted
+             * system calls and partial results like sec2 driver does because the
+             * data may no longer be aligned. It's especially true when the data in
+             * file is smaller than ALLOC_SIZE.  Only read the entire section if
+             * both ends are misaligned, otherwise only read the block on the
+             * misaligned end.
+             */
+            HDmemset(copy_buf, 0, _fbsize);
+
+            if (copy_offset > 0) {
+                if ((write_addr + write_size) > (addr + size)) {
+                    HDassert((write_addr + write_size) - (addr + size) < _fbsize);
+                    read_size = write_size;
+                    p1        = copy_buf;
                 } /* end if */
                 else {
-                    H5MM_memcpy(p1, p3, alloc_size - copy_offset);
-                    p3 = (const unsigned char *)p3 + (alloc_size - copy_offset);
-                    copy_size -= alloc_size - copy_offset;
-                    copy_offset = 0;
+                    read_size = _fbsize;
+                    p1        = copy_buf;
                 } /* end else */
+            }     /* end if */
+            else if ((write_addr + write_size) > (addr + size)) {
+                HDassert((write_addr + write_size) - (addr + size) < _fbsize);
+                read_size = _fbsize;
+                p1        = (unsigned char *)copy_buf + write_size - _fbsize;
+
+                /* Seek to the last block, for reading */
+                HDassert(!((write_addr + write_size - _fbsize) % _fbsize));
+                if (HDlseek(file->fd, (HDoff_t)(write_addr + write_size - _fbsize), SEEK_SET) < 0)
+                    HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
+            } /* end if */
+            else
+                p1 = NULL;
 
-        /*look for the aligned position for writing the data*/
-        HDassert(!(write_addr % _fbsize));
-        if(HDlseek(file->fd, (HDoff_t)write_addr, SEEK_SET) < 0)
-        HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
+            if (p1) {
+                HDassert(!(read_size % _fbsize));
+                do {
+                    nbytes = HDread(file->fd, p1, read_size);
+                } while (-1 == nbytes && EINTR == errno);
 
-        /*
-          * Write the data. It doesn't truncate the extra data introduced by
-     * alignment because that step is done in H5FD_direct_flush.
-         */
-        HDassert(!(write_size % _fbsize));
-    do {
-        nbytes = HDwrite(file->fd, copy_buf, write_size);
-    } while (-1==nbytes && EINTR==errno);
-
-    if (-1==nbytes) /* error */
-        HSYS_GOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "file write failed")
-
-              /* update the write address */
-              write_addr += write_size;
-  } while (copy_size > 0);
-
-  /*Update the address and size*/
-  addr = write_addr;
-  buf = (const char*)buf + size;
-
-  if(copy_buf) {
-    /* Free with HDfree since it came from posix_memalign */
-      HDfree(copy_buf);
-      copy_buf = NULL;
+                if (-1 == nbytes) /* error */
+                    HSYS_GOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "file read failed")
+            } /* end if */
+
+            /* look for the right position and append or copy the data to be written to
+             * the aligned buffer.
+             * Consider all possible situations here: file address is not aligned on
+             * file block size; the end of data address is not aligned; the end of data
+             * address is aligned; data size is smaller or bigger than maximal copy size.
+             */
+            p1 = (unsigned char *)copy_buf + copy_offset;
+            if ((copy_size + copy_offset) <= alloc_size) {
+                H5MM_memcpy(p1, p3, copy_size);
+                copy_size = 0;
+            } /* end if */
+            else {
+                H5MM_memcpy(p1, p3, alloc_size - copy_offset);
+                p3 = (const unsigned char *)p3 + (alloc_size - copy_offset);
+                copy_size -= alloc_size - copy_offset;
+                copy_offset = 0;
+            } /* end else */
+
+            /*look for the aligned position for writing the data*/
+            HDassert(!(write_addr % _fbsize));
+            if (HDlseek(file->fd, (HDoff_t)write_addr, SEEK_SET) < 0)
+                HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
+
+            /*
+             * Write the data. It doesn't truncate the extra data introduced by
+             * alignment because that step is done in H5FD_direct_flush.
+             */
+            HDassert(!(write_size % _fbsize));
+            do {
+                nbytes = HDwrite(file->fd, copy_buf, write_size);
+            } while (-1 == nbytes && EINTR == errno);
+
+            if (-1 == nbytes) /* error */
+                HSYS_GOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "file write failed")
+
+            /* update the write address */
+            write_addr += write_size;
+        } while (copy_size > 0);
+
+        /*Update the address and size*/
+        addr = write_addr;
+        buf  = (const char *)buf + size;
+
+        if (copy_buf) {
+            /* Free with HDfree since it came from posix_memalign */
+            HDfree(copy_buf);
+            copy_buf = NULL;
         } /* end if */
     }
 
     /* Update current position and eof */
     file->pos = addr;
-    file->op = OP_WRITE;
-    if (file->pos>file->eof)
+    file->op  = OP_WRITE;
+    if (file->pos > file->eof)
         file->eof = file->pos;
 
 done:
-    if(ret_value<0) {
+    if (ret_value < 0) {
         /* Free with HDfree since it came from posix_memalign */
-        if(copy_buf)
+        if (copy_buf)
             HDfree(copy_buf);
 
         /* Reset last file I/O information */
         file->pos = HADDR_UNDEF;
-        file->op = OP_UNKNOWN;
+        file->op  = OP_UNKNOWN;
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
 }
 
-
 /*-------------------------------------------------------------------------
  * Function:  H5FD__direct_truncate
  *
@@ -1263,18 +1254,18 @@ done:
 static herr_t
 H5FD__direct_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_ATTR_UNUSED closing)
 {
-    H5FD_direct_t  *file = (H5FD_direct_t*)_file;
-    herr_t        ret_value = SUCCEED;       /* Return value */
+    H5FD_direct_t *file      = (H5FD_direct_t *)_file;
+    herr_t         ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
 
     HDassert(file);
 
     /* Extend the file to make sure it's large enough */
-    if (file->eoa!=file->eof) {
+    if (file->eoa != file->eof) {
 #ifdef H5_HAVE_WIN32_API
-        HFILE filehandle;   /* Windows file handle */
-        LARGE_INTEGER li;   /* 64-bit integer for SetFilePointer() call */
+        HFILE         filehandle; /* Windows file handle */
+        LARGE_INTEGER li;         /* 64-bit integer for SetFilePointer() call */
 
         /* Map the posix file handle to a Windows file handle */
         filehandle = _get_osfhandle(file->fd);
@@ -1282,11 +1273,11 @@ H5FD__direct_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_AT
         /* Translate 64-bit integers into form Windows wants */
         /* [This algorithm is from the Windows documentation for SetFilePointer()] */
         li.QuadPart = (LONGLONG)file->eoa;
-        (void)SetFilePointer((HANDLE)filehandle,li.LowPart,&li.HighPart,FILE_BEGIN);
-        if(SetEndOfFile((HANDLE)filehandle)==0)
+        (void)SetFilePointer((HANDLE)filehandle, li.LowPart, &li.HighPart, FILE_BEGIN);
+        if (SetEndOfFile((HANDLE)filehandle) == 0)
             HGOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to extend file properly")
-#else /* H5_HAVE_WIN32_API */
-        if (-1==HDftruncate(file->fd, (HDoff_t)file->eoa))
+#else  /* H5_HAVE_WIN32_API */
+        if (-1 == HDftruncate(file->fd, (HDoff_t)file->eoa))
             HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to extend file properly")
 #endif /* H5_HAVE_WIN32_API */
 
@@ -1295,13 +1286,13 @@ H5FD__direct_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_AT
 
         /* Reset last file I/O information */
         file->pos = HADDR_UNDEF;
-        file->op = OP_UNKNOWN;
+        file->op  = OP_UNKNOWN;
     }
-    else if (file->fa.must_align){
-  /*Even though eof is equal to eoa, file is still truncated because Direct I/O
-   *write introduces some extra data for alignment.
-   */
-        if (-1==HDftruncate(file->fd, (HDoff_t)file->eof))
+    else if (file->fa.must_align) {
+        /*Even though eof is equal to eoa, file is still truncated because Direct I/O
+         *write introduces some extra data for alignment.
+         */
+        if (-1 == HDftruncate(file->fd, (HDoff_t)file->eof))
             HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to extend file properly")
     }
 
@@ -1309,7 +1300,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD__direct_truncate() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD__direct_lock
  *
@@ -1327,9 +1317,9 @@ done:
 static herr_t
 H5FD__direct_lock(H5FD_t *_file, hbool_t rw)
 {
-    H5FD_direct_t *file = (H5FD_direct_t*)_file;    /* VFD file struct      */
-    int lock_flags;                                 /* file locking flags   */
-    herr_t ret_value = SUCCEED;                     /* Return value         */
+    H5FD_direct_t *file = (H5FD_direct_t *)_file; /* VFD file struct      */
+    int            lock_flags;                    /* file locking flags   */
+    herr_t         ret_value = SUCCEED;           /* Return value         */
 
     FUNC_ENTER_STATIC
 
@@ -1339,8 +1329,8 @@ H5FD__direct_lock(H5FD_t *_file, hbool_t rw)
     lock_flags = rw ? LOCK_EX : LOCK_SH;
 
     /* Place a non-blocking lock on the file */
-    if(HDflock(file->fd, lock_flags | LOCK_NB) < 0) {
-        if(file->ignore_disabled_file_locks && ENOSYS == errno) {
+    if (HDflock(file->fd, lock_flags | LOCK_NB) < 0) {
+        if (file->ignore_disabled_file_locks && ENOSYS == errno) {
             /* When errno is set to ENOSYS, the file system does not support
              * locking, so ignore it.
              */
@@ -1354,7 +1344,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD__direct_lock() */
 
-
 /*-------------------------------------------------------------------------
  * Function:    H5FD__direct_unlock
  *
@@ -1369,15 +1358,15 @@ done:
 static herr_t
 H5FD__direct_unlock(H5FD_t *_file)
 {
-    H5FD_direct_t  *file = (H5FD_direct_t*)_file;	/* VFD file struct */
-    herr_t ret_value = SUCCEED;                 	/* Return value */
+    H5FD_direct_t *file      = (H5FD_direct_t *)_file; /* VFD file struct */
+    herr_t         ret_value = SUCCEED;                /* Return value */
 
     FUNC_ENTER_STATIC
 
     HDassert(file);
 
-    if(HDflock(file->fd, LOCK_UN) < 0) {
-        if(file->ignore_disabled_file_locks && ENOSYS == errno) {
+    if (HDflock(file->fd, LOCK_UN) < 0) {
+        if (file->ignore_disabled_file_locks && ENOSYS == errno) {
             /* When errno is set to ENOSYS, the file system does not support
              * locking, so ignore it.
              */
@@ -1392,4 +1381,3 @@ done:
 } /* end H5FD__direct_unlock() */
 
 #endif /* H5_HAVE_DIRECT */
-