Normalization with vol_integration (property lists, file drivers,

other misc).

1 files changed, 514 insertions, 464 deletions

diff --git a/src/H5FD.c b/src/H5FD.c
index d74ea31..5585f37 100644
--- a/src/H5FD.c
+++ b/src/H5FD.c
@@ -23,22 +23,22 @@
 /* Module Setup */
 /****************/
 
-#define H5F_FRIEND		/*suppress error about including H5Fpkg	  */
+#define H5F_FRIEND              /* Suppress error about including H5Fpkg */
 #include "H5FDmodule.h"         /* This source code file is part of the H5FD module */
 
 
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5CXprivate.h"        /* API Contexts                         */
-#include "H5Dprivate.h"		/* Datasets				*/
-#include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5Fpkg.h"             /* File access				*/
-#include "H5FDpkg.h"		/* File Drivers				*/
-#include "H5Iprivate.h"		/* IDs			  		*/
-#include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Pprivate.h"		/* Property lists			*/
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5CXprivate.h"        /* API Contexts                             */
+#include "H5Dprivate.h"         /* Datasets                                 */
+#include "H5Eprivate.h"         /* Error handling                           */
+#include "H5Fpkg.h"             /* File access                              */
+#include "H5FDpkg.h"            /* File Drivers                             */
+#include "H5Iprivate.h"         /* IDs                                      */
+#include "H5MMprivate.h"        /* Memory management                        */
+#include "H5Pprivate.h"         /* Property lists                           */
 
 /****************/
 /* Local Macros */
@@ -58,8 +58,8 @@
 /********************/
 /* Local Prototypes */
 /********************/
-static herr_t H5FD_free_cls(H5FD_class_t *cls);
-static int H5FD_query(const H5FD_t *f, unsigned long *flags/*out*/);
+static herr_t H5FD__free_cls(H5FD_class_t *cls);
+static herr_t H5FD__query(const H5FD_t *f, unsigned long *flags/*out*/);
 
 /*********************/
 /* Package Variables */
@@ -94,21 +94,20 @@ static unsigned long H5FD_file_serial_no_g;
 
 /* File driver ID class */
 static const H5I_class_t H5I_VFL_CLS[1] = {{
-    H5I_VFL,			/* ID class value */
-    0,				/* Class flags */
-    0,				/* # of reserved IDs for class */
-    (H5I_free_t)H5FD_free_cls	/* Callback routine for closing objects of this class */
+    H5I_VFL,                    /* ID class value */
+    0,                          /* Class flags */
+    0,                          /* # of reserved IDs for class */
+    (H5I_free_t)H5FD__free_cls  /* Callback routine for closing objects of this class */
 }};
 
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD__init_package
+ * Function:    H5FD__init_package
  *
- * Purpose:	Initialize the virtual file layer.
+ * Purpose:     Initialize the virtual file layer.
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -131,16 +130,17 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_term_package
+ * Function:    H5FD_term_package
+ *
+ * Purpose:     Terminate this interface: free all memory and reset global
+ *              variables to their initial values.  Release all ID groups
+ *              associated with this interface.
  *
- * Purpose:	Terminate this interface: free all memory and reset global
- *		variables to their initial values.  Release all ID groups
- *		associated with this interface.
+ * Return:      Success:    Positive if anything was done that might
+ *                          have affected other interfaces; zero
+ *                          otherwise.
  *
- * Return:	Success:	Positive if anything was done that might
- *				have affected other interfaces; zero
- *				otherwise.
- *		Failure:        Never fails.
+ *              Failure:    Never fails.
  *
  *-------------------------------------------------------------------------
  */
@@ -171,26 +171,24 @@ H5FD_term_package(void)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_free_cls
+ * Function:    H5FD__free_cls
  *
- * Purpose:	Frees a file driver class struct and returns an indication of
- *		success. This function is used as the free callback for the
- *		virtual file layer object identifiers (cf H5FD__init_package).
- *
- * Return:	Success:	Non-negative
+ * Purpose:     Frees a file driver class struct and returns an indication of
+ *              success. This function is used as the free callback for the
+ *              virtual file layer object identifiers (cf H5FD__init_package).
  *
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_free_cls(H5FD_class_t *cls)
+H5FD__free_cls(H5FD_class_t *cls)
 {
     herr_t ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    /* Sanity check */
+    /* Sanity checks */
     HDassert(cls);
 
     /* If the file driver has a terminate callback, call it to give the file
@@ -219,37 +217,37 @@ done:
  *                          library is closed or the driver is
  *                          unregistered.
  *
- *              Failure:    A negative value.
+ *              Failure:    H5I_INVALID_HID
  *
  *-------------------------------------------------------------------------
  */
 hid_t
 H5FDregister(const H5FD_class_t *cls)
 {
-    hid_t		ret_value;
-    H5FD_mem_t		type;
+    H5FD_mem_t      type;
+    hid_t           ret_value = H5I_INVALID_HID;
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE1("i", "*x", cls);
 
     /* Check arguments */
     if(!cls)
-        HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, FAIL, "null class pointer is disallowed")
+        HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, H5I_INVALID_HID, "null class pointer is disallowed")
     if(!cls->open || !cls->close)
-        HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, FAIL, "`open' and/or `close' methods are not defined")
+        HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, H5I_INVALID_HID, "'open' and/or 'close' methods are not defined")
     if(!cls->get_eoa || !cls->set_eoa)
-        HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, FAIL, "`get_eoa' and/or `set_eoa' methods are not defined")
+        HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, H5I_INVALID_HID, "'get_eoa' and/or 'set_eoa' methods are not defined")
     if(!cls->get_eof)
-        HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, FAIL, "`get_eof' method is not defined")
+        HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, H5I_INVALID_HID, "'get_eof' method is not defined")
     if(!cls->read || !cls->write)
-        HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, FAIL, "`read' and/or `write' method is not defined")
+        HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, H5I_INVALID_HID, "'read' and/or 'write' method is not defined")
     for (type = H5FD_MEM_DEFAULT; type < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t,type))
         if(cls->fl_map[type] < H5FD_MEM_NOLIST || cls->fl_map[type] >= H5FD_MEM_NTYPES)
-            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid free-list mapping")
+            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "invalid free-list mapping")
 
     /* Create the new class ID */
     if((ret_value = H5FD_register(cls, sizeof(H5FD_class_t), TRUE)) < 0)
-        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register file driver ID")
+        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, H5I_INVALID_HID, "unable to register file driver ID")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -268,7 +266,7 @@ done:
  *                          library is closed or the driver is
  *                          unregistered.
  *
- *              Failure:    A negative value.
+ *              Failure:    H5I_INVALID_HID
  *
  *-------------------------------------------------------------------------
  */
@@ -276,34 +274,35 @@ hid_t
 H5FD_register(const void *_cls, size_t size, hbool_t app_ref)
 {
     const H5FD_class_t	*cls = (const H5FD_class_t *)_cls;
-    H5FD_class_t	*saved = NULL;
-    H5FD_mem_t		type;
-    hid_t		ret_value = H5I_INVALID_HID;    /* Return value */
+    H5FD_class_t	    *saved = NULL;
+    H5FD_mem_t		    type;
+    hid_t               ret_value = H5I_INVALID_HID;    /* Return value */
 
-    FUNC_ENTER_NOAPI(FAIL)
+    FUNC_ENTER_NOAPI(H5I_INVALID_HID)
 
-    /* Check arguments */
+    /* Sanity checks */
     HDassert(cls);
     HDassert(cls->open && cls->close);
     HDassert(cls->get_eoa && cls->set_eoa);
     HDassert(cls->get_eof);
     HDassert(cls->read && cls->write);
-    for(type = H5FD_MEM_DEFAULT; type < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t, type))
+    for(type = H5FD_MEM_DEFAULT; type < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t, type)) {
         HDassert(cls->fl_map[type] >= H5FD_MEM_NOLIST && cls->fl_map[type] < H5FD_MEM_NTYPES);
+    }
 
     /* Copy the class structure so the caller can reuse or free it */
     if(NULL == (saved = (H5FD_class_t *)H5MM_malloc(size)))
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for file driver class struct")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, H5I_INVALID_HID, "memory allocation failed for file driver class struct")
     HDmemcpy(saved, cls, size);
 
     /* Create the new class ID */
     if((ret_value = H5I_register(H5I_VFL, saved, app_ref)) < 0)
-        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register file driver ID")
+        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, H5I_INVALID_HID, "unable to register file driver ID")
 
 done:
-    if(ret_value < 0)
+    if(H5I_INVALID_HID == ret_value)
         if(saved)
-            H5MM_xfree(saved);
+            saved = (H5FD_class_t *)H5MM_xfree(saved);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_register() */
@@ -317,9 +316,7 @@ done:
  *              this driver or files which are already opened under this
  *              driver.
  *
- * Return:      Success:    Non-negative
- *
- *              Failure:    Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -333,11 +330,11 @@ H5FDunregister(hid_t driver_id)
 
     /* Check arguments */
     if(NULL == H5I_object_verify(driver_id, H5I_VFL))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file driver")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file driver")
 
     /* The H5FD_class_t struct will be freed by this function */
     if(H5I_dec_app_ref(driver_id) < 0)
-	HGOTO_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "unable to unregister file driver")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "unable to unregister file driver")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -345,19 +342,19 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_get_class
+ * Function:    H5FD_get_class
  *
- * Purpose:	Obtains a pointer to the driver struct containing all the
- *		callback pointers, etc. The PLIST_ID argument can be a file
- *		access property list, a data transfer property list, or a
- *		file driver identifier.
+ * Purpose:     Obtains a pointer to the driver struct containing all the
+ *              callback pointers, etc. The PLIST_ID argument can be a file
+ *              access property list, a data transfer property list, or a
+ *              file driver identifier.
  *
- * Return:	Success:	Ptr to the driver information. The pointer is
- *				only valid as long as the driver remains
- *				registered or some file or property list
- *				exists which references the driver.
+ * Return:      Success:    Ptr to the driver information. The pointer is
+ *                          only valid as long as the driver remains
+ *                          registered or some file or property list
+ *                          exists which references the driver.
  *
- *		Failure:	NULL
+ *              Failure:    NULL
  *
  *-------------------------------------------------------------------------
  */
@@ -369,7 +366,7 @@ H5FD_get_class(hid_t id)
     FUNC_ENTER_NOAPI(NULL)
 
     if(H5I_VFL == H5I_get_type(id))
-	ret_value = (H5FD_class_t *)H5I_object(id);
+        ret_value = (H5FD_class_t *)H5I_object(id);
     else {
         H5P_genplist_t *plist;      /* Property list pointer */
 
@@ -394,29 +391,32 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_sb_size
+ * Function:    H5FD_sb_size
  *
- * Purpose:	Obtains the number of bytes required to store the driver file
- *		access data in the HDF5 superblock.
+ * Purpose:     Obtains the number of bytes required to store the driver file
+ *              access data in the HDF5 superblock.
  *
- * Return:	Success:	Number of bytes required.
+ * Return:      Success:    Number of bytes required. May be zero if the
+ *                          driver has no data to store in the superblock.
  *
- *		Failure:	0 if an error occurs or if the driver has no
- *				data to store in the superblock.
+ *              Failure:    This function cannot indicate errors.
  *
  *-------------------------------------------------------------------------
  */
 hsize_t
 H5FD_sb_size(H5FD_t *file)
 {
-    hsize_t	ret_value=0;
+    hsize_t	ret_value = 0;
 
     FUNC_ENTER_NOAPI(0)
 
-    HDassert(file && file->cls);
+    /* Sanity checks */
+    HDassert(file);
+    HDassert(file->cls);
 
+    /* Dispatch to driver */
     if(file->cls->sb_size)
-	ret_value = (file->cls->sb_size)(file);
+        ret_value = (file->cls->sb_size)(file);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -424,31 +424,33 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_sb_encode
+ * Function:    H5FD_sb_encode
  *
- * Purpose:	Encode driver-specific data into the output arguments. The
- *		NAME is a nine-byte buffer which should get an
- *		eight-character driver name and/or version followed by a null
- *		terminator. The BUF argument is a buffer to receive the
- *		encoded driver-specific data. The size of the BUF array is
- *		the size returned by the H5FD_sb_size() call.
+ * Purpose:     Encode driver-specific data into the output arguments. The
+ *              NAME is a nine-byte buffer which should get an
+ *              eight-character driver name and/or version followed by a null
+ *              terminator. The BUF argument is a buffer to receive the
+ *              encoded driver-specific data. The size of the BUF array is
+ *              the size returned by the H5FD_sb_size() call.
  *
- * Return:	Success:	Non-negative
- *
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5FD_sb_encode(H5FD_t *file, char *name/*out*/, uint8_t *buf)
 {
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    herr_t      ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    HDassert(file && file->cls);
+    /* Sanity checks */
+    HDassert(file);
+    HDassert(file->cls);
+
+    /* Dispatch to driver */
     if(file->cls->sb_encode && (file->cls->sb_encode)(file, name/*out*/, buf/*out*/) < 0)
-	HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver sb_encode request failed")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver sb_encode request failed")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -456,12 +458,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD__sb_decode
+ * Function:    H5FD__sb_decode
  *
- * Purpose:	Decodes the driver information block.
+ * Purpose:     Decodes the driver information block.
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -472,11 +473,13 @@ H5FD__sb_decode(H5FD_t *file, const char *name, const uint8_t *buf)
 
     FUNC_ENTER_STATIC
 
-    HDassert(file && file->cls);
+    /* Sanity checks */
+    HDassert(file);
+    HDassert(file->cls);
 
-    /* Decode driver information */
+    /* Dispatch to driver */
     if(file->cls->sb_decode && (file->cls->sb_decode)(file, name, buf) < 0)
-	HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver sb_decode request failed")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver sb_decode request failed")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -484,12 +487,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_sb_load
+ * Function:    H5FD_sb_load
  *
- * Purpose:	Validate and decode the driver information block.
+ * Purpose:     Validate and decode the driver information block.
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -500,7 +502,9 @@ H5FD_sb_load(H5FD_t *file, const char *name, const uint8_t *buf)
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    HDassert(file && file->cls);
+    /* Sanity checks */
+    HDassert(file);
+    HDassert(file->cls);
 
     /* Check if driver matches driver information saved. Unfortunately, we can't push this
      * function to each specific driver because we're checking if the driver is correct.
@@ -520,37 +524,41 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_fapl_get
+ * Function:    H5FD_fapl_get
+ *
+ * Purpose:     Gets the file access property list associated with a file.
+ *              Usually the file will copy what it needs from the original
+ *              file access property list when the file is created. The
+ *              purpose of this function is to create a new file access
+ *              property list based on the settings in the file, which may
+ *              have been modified from the original file access property
+ *              list.
  *
- * Purpose:	Gets the file access property list associated with a file.
- *		Usually the file will copy what it needs from the original
- *		file access property list when the file is created. The
- *		purpose of this function is to create a new file access
- *		property list based on the settings in the file, which may
- *		have been modified from the original file access property
- *		list.
+ * Return:      Success:    Pointer to a new file access property list
+ *                          with all members copied.  If the file is
+ *                          closed then this property list lives on, and
+ *                          vice versa.
  *
- * Return:	Success:	Pointer to a new file access property list
- *				with all members copied.  If the file is
- *				closed then this property list lives on, and
- *				vice versa.
+ *                          This can be NULL if the file has no properties.
  *
- *		Failure:	NULL, including when the file has no
- *				properties.
+ *              Failure:    This function cannot indicate errors.
  *
  *-------------------------------------------------------------------------
  */
 void *
 H5FD_fapl_get(H5FD_t *file)
 {
-    void	*ret_value=NULL;
+    void	*ret_value = NULL;
 
     FUNC_ENTER_NOAPI(NULL)
 
+    /* Sanity checks */
     HDassert(file);
+    HDassert(file->cls);
 
+    /* Dispatch to driver */
     if(file->cls->fapl_get)
-	ret_value = (file->cls->fapl_get)(file);
+        ret_value = (file->cls->fapl_get)(file);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -558,12 +566,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_fapl_close
+ * Function:    H5FD_fapl_close
  *
- * Purpose:	Closes a driver for a dataset transfer property list
+ * Purpose:     Closes a driver for a dataset transfer property list
  *
- * Return:	Success:	non-negative
- *		Failure:	negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -574,7 +581,6 @@ H5FD_fapl_close(hid_t driver_id, const void *driver_info)
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    /* Check args */
     if(driver_id > 0) {
         H5FD_class_t	*driver;
 
@@ -589,7 +595,7 @@ H5FD_fapl_close(hid_t driver_id, const void *driver_info)
                     HGOTO_ERROR(H5E_VFL, H5E_CANTFREE, FAIL, "driver free request failed")
             } /* end if */
             else
-                H5MM_xfree((void *)driver_info);        /* Casting away const OK -QAK */
+                driver_info = H5MM_xfree((void *)driver_info);        /* Casting away const OK -QAK */
         } /* end if */
     } /* end if */
 
@@ -599,59 +605,59 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDopen
+ * Function:    H5FDopen
  *
- * Purpose:	Opens a file named NAME for the type(s) of access described
- *		by the bit vector FLAGS according to a file access property
- *		list FAPL_ID (which may be the constant H5P_DEFAULT). The
- *		file should expect to handle format addresses in the range [0,
- *		MAXADDR] (if MAXADDR is the undefined address then the caller
- *		doesn't care about the address range).
+ * Purpose:     Opens a file named NAME for the type(s) of access described
+ *              by the bit vector FLAGS according to a file access property
+ *              list FAPL_ID (which may be the constant H5P_DEFAULT). The
+ *              file should expect to handle format addresses in the range [0,
+ *              MAXADDR] (if MAXADDR is the undefined address then the caller
+ *              doesn't care about the address range).
  *
- * 		Possible values for the FLAGS bits are:
+ *              Possible values for the FLAGS bits are:
  *
- *		H5F_ACC_RDWR:	Open the file for read and write access. If
- *				this bit is not set then open the file for
- *				read only access. It is permissible to open a
- *				file for read and write access when only read
- *				access is requested by the library (the
- *				library will never attempt to write to a file
- *				which it opened with only read access).
+ *              H5F_ACC_RDWR:   Open the file for read and write access. If
+ *                              this bit is not set then open the file for
+ *                              read only access. It is permissible to open a
+ *                              file for read and write access when only read
+ *                              access is requested by the library (the
+ *                              library will never attempt to write to a file
+ *                              which it opened with only read access).
  *
- *		H5F_ACC_CREATE:	Create the file if it doesn't already exist.
- *				However, see H5F_ACC_EXCL below.
+ *              H5F_ACC_CREATE: Create the file if it doesn't already exist.
+ *                              However, see H5F_ACC_EXCL below.
  *
- *		H5F_ACC_TRUNC:	Truncate the file if it already exists. This
- *				is equivalent to deleting the file and then
- *				creating a new empty file.
+ *              H5F_ACC_TRUNC:  Truncate the file if it already exists. This
+ *                              is equivalent to deleting the file and then
+ *                              creating a new empty file.
  *
- *		H5F_ACC_EXCL:	When used with H5F_ACC_CREATE, if the file
- *				already exists then the open should fail.
- *				Note that this is unsupported/broken with
- *				some file drivers (e.g., sec2 across nfs) and
- *				will contain a race condition when used to
- *				perform file locking.
+ *              H5F_ACC_EXCL:   When used with H5F_ACC_CREATE, if the file
+ *                              already exists then the open should fail.
+ *                              Note that this is unsupported/broken with
+ *                              some file drivers (e.g., sec2 across nfs) and
+ *                              will contain a race condition when used to
+ *                              perform file locking.
  *
- *		The MAXADDR is the maximum address which will be requested by
- *		the library during an allocation operation. Usually this is
- *		the same value as the MAXADDR field of the class structure,
- *		but it can be smaller if the driver is being used under some
- *		other driver.
+ *              The MAXADDR is the maximum address which will be requested by
+ *              the library during an allocation operation. Usually this is
+ *              the same value as the MAXADDR field of the class structure,
+ *              but it can be smaller if the driver is being used under some
+ *              other driver.
  *
- *		Note that when the driver `open' callback gets control that
- *		the public part of the file struct (the H5FD_t part) will be
- *		incomplete and will be filled in after that callback returns.
+ *              Note that when the driver 'open' callback gets control that
+ *              the public part of the file struct (the H5FD_t part) will be
+ *              incomplete and will be filled in after that callback returns.
  *
- * Return:	Success:	Pointer to a new file driver struct.
+ * Return:      Success:    Pointer to a new file driver struct.
  *
- *		Failure:	NULL
+ *              Failure:    NULL
  *
  *-------------------------------------------------------------------------
  */
 H5FD_t *
 H5FDopen(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
 {
-    H5FD_t	*ret_value=NULL;
+    H5FD_t	*ret_value = NULL;
 
     FUNC_ENTER_API(NULL)
     H5TRACE4("*x", "*sIuia", name, flags, fapl_id, maxaddr);
@@ -660,11 +666,12 @@ H5FDopen(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
     if(H5P_DEFAULT == fapl_id)
         fapl_id = H5P_FILE_ACCESS_DEFAULT;
     else
-        if(TRUE!=H5P_isa_class(fapl_id,H5P_FILE_ACCESS))
+        if(TRUE != H5P_isa_class(fapl_id,H5P_FILE_ACCESS))
             HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a file access property list")
 
-    if(NULL==(ret_value=H5FD_open(name, flags, fapl_id, maxaddr)))
-	HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, NULL, "unable to open file")
+    /* Call private function */
+    if(NULL == (ret_value = H5FD_open(name, flags, fapl_id, maxaddr)))
+        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, NULL, "unable to open file")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -672,13 +679,13 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_open
+ * Function:    H5FD_open
  *
- * Purpose:	Private version of H5FDopen()
+ * Purpose:     Private version of H5FDopen()
  *
- * Return:	Success:	Pointer to a new file driver struct
+ * Return:      Success:    Pointer to a new file driver struct
  *
- *		Failure:	NULL
+ *              Failure:    NULL
  *
  *-------------------------------------------------------------------------
  */
@@ -695,9 +702,9 @@ H5FD_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
 
     FUNC_ENTER_NOAPI(NULL)
 
-    /* Sanity check */
+    /* Sanity checks */
     if(0 == maxaddr)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "zero format address range")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "zero format address range")
 
     /* Get file access property list */
     if(NULL == (plist = (H5P_genplist_t *)H5I_object(fapl_id)))
@@ -709,9 +716,9 @@ H5FD_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
 
     /* Get driver info */
     if(NULL == (driver = (H5FD_class_t *)H5I_object(driver_prop.driver_id)))
-	HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, NULL, "invalid driver ID in file access property list")
+        HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, NULL, "invalid driver ID in file access property list")
     if(NULL == driver->open)
-	HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, NULL, "file driver has no `open' method")
+        HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, NULL, "file driver has no `open' method")
 
     /* Query driver flag */
     if(H5FD_driver_query(driver, &driver_flags) < 0)
@@ -731,13 +738,12 @@ H5FD_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
     if(HADDR_UNDEF == maxaddr)
         maxaddr = driver->maxaddr;
     if(NULL == (file = (driver->open)(name, flags, fapl_id, maxaddr)))
-	HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, NULL, "open failed")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, NULL, "open failed")
 
     /* Set the file access flags */
     file->access_flags = flags;
 
-    /*
-     * Fill in public fields. We must increment the reference count on the
+    /* Fill in public fields. We must increment the reference count on the
      * driver ID to prevent it from being freed while this file is open.
      */
     file->driver_id = driver_prop.driver_id;
@@ -751,7 +757,7 @@ H5FD_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
         HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get alignment")
 
     /* Retrieve the VFL driver feature flags */
-    if(H5FD_query(file, &(file->feature_flags)) < 0)
+    if(H5FD__query(file, &(file->feature_flags)) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, NULL, "unable to query file driver")
 
     /* Increment the global serial number & assign it to this H5FD_t object */
@@ -775,32 +781,35 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDclose
+ * Function:    H5FDclose
  *
- * Purpose:     Closes the file by calling the driver `close' callback, which
- *		should free all driver-private data and free the file struct.
- *		Note that the public part of the file struct (the H5FD_t part)
- *		will be all zero during the driver close callback like during
- *		the `open' callback.
+ * Purpose:     Closes the file by calling the driver 'close' callback, which
+ *              should free all driver-private data and free the file struct.
+ *              Note that the public part of the file struct (the H5FD_t part)
+ *              will be all zero during the driver close callback like during
+ *              the 'open' callback.
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5FDclose(H5FD_t *file)
 {
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    herr_t      ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE1("e", "*x", file);
 
-    if(!file || !file->cls)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer")
+    /* Check arguments */
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL")
 
+    /* Call private function */
     if(H5FD_close(file) < 0)
-	HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close file")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close file")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -808,12 +817,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_close
+ * Function:    H5FD_close
  *
- * Purpose:	Private version of H5FDclose()
+ * Purpose:     Private version of H5FDclose()
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -825,16 +833,16 @@ H5FD_close(H5FD_t *file)
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    /* check args */
-    HDassert(file && file->cls);
+    /* Sanity checks */
+    HDassert(file);
+    HDassert(file->cls);
 
     /* Prepare to close file by clearing all public fields */
     driver = file->cls;
     if(H5I_dec_ref(file->driver_id) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "can't close driver ID")
 
-    /*
-     * Dispatch to the driver for actual close. If the driver fails to
+    /* Dispatch to the driver for actual close. If the driver fails to
      * close the file then the file will be in an unusable state.
      */
     HDassert(driver->close);
@@ -847,47 +855,48 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDcmp
+ * Function:    H5FDcmp
  *
- * Purpose:	Compare the keys of two files using the file driver callback
- *		if the files belong to the same driver, otherwise sort the
- *		files by driver class pointer value.
+ * Purpose:     Compare the keys of two files using the file driver callback
+ *              if the files belong to the same driver, otherwise sort the
+ *              files by driver class pointer value.
  *
- * Return:	Success:	A value like strcmp()
+ * Return:      Success:    A value like strcmp()
  *
- *		Failure:	Must never fail. If both file handles are
- *				invalid then they compare equal. If one file
- *				handle is invalid then it compares less than
- *				the other.  If both files belong to the same
- *				driver and the driver doesn't provide a
- *				comparison callback then the file pointers
- *				themselves are compared.
+ *              Failure:    Must never fail. If both file handles are
+ *                          invalid then they compare equal. If one file
+ *                          handle is invalid then it compares less than
+ *                          the other.  If both files belong to the same
+ *                          driver and the driver doesn't provide a
+ *                          comparison callback then the file pointers
+ *                          themselves are compared.
  *
  *-------------------------------------------------------------------------
  */
 int
 H5FDcmp(const H5FD_t *f1, const H5FD_t *f2)
 {
-    int	ret_value;
+    int	ret_value = -1;
 
-    FUNC_ENTER_API(-1) /*return value is arbitrary*/
+    FUNC_ENTER_API(-1) /* return value is arbitrary */
     H5TRACE2("Is", "*x*x", f1, f2);
 
+    /* Call private function */
     ret_value = H5FD_cmp(f1, f2);
 
 done:
     FUNC_LEAVE_API(ret_value)
-}
+} /* end H5FDcmp() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_cmp
+ * Function:    H5FD_cmp
  *
- * Purpose:	Private version of H5FDcmp()
+ * Purpose:     Private version of H5FDcmp()
  *
- * Return:	Success:	A value like strcmp()
+ * Return:      Success:    A value like strcmp()
  *
- *		Failure:	Must never fail.
+ *              Failure:    Must never fail.
  *
  *-------------------------------------------------------------------------
  */
@@ -896,7 +905,7 @@ H5FD_cmp(const H5FD_t *f1, const H5FD_t *f2)
 {
     int	ret_value = -1;         /* Return value */
 
-    FUNC_ENTER_NOAPI(-1) /*return value is arbitrary*/
+    FUNC_ENTER_NOAPI(-1) /* return value is arbitrary */
 
     if((!f1 || !f1->cls) && (!f2 || !f2->cls))
         HGOTO_DONE(0)
@@ -911,43 +920,50 @@ H5FD_cmp(const H5FD_t *f1, const H5FD_t *f2)
 
     /* Files are same driver; no cmp callback */
     if(!f1->cls->cmp) {
-	if(f1<f2)
+        if(f1 < f2)
             HGOTO_DONE(-1)
-	if(f1>f2)
+        if(f1 > f2)
             HGOTO_DONE(1)
-	HGOTO_DONE(0)
+        HGOTO_DONE(0)
     }
 
+    /* Dispatch to driver */
     ret_value = (f1->cls->cmp)(f1, f2);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-}
+} /* end H5FD_cmp() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDquery
- *
- * Purpose:	Query a VFL driver for its feature flags. (listed in H5FDpublic.h)
+ * Function:    H5FDquery
  *
- * Return:	Success:    non-negative
+ * Purpose:     Query a VFL driver for its feature flags. (listed in H5FDpublic.h)
  *
- *		Failure:	negative
+ * Return:      Success:    0
+ *              Failure:    -1
  *
  *-------------------------------------------------------------------------
  */
 int
-H5FDquery(const H5FD_t *f, unsigned long *flags/*out*/)
+H5FDquery(const H5FD_t *file, unsigned long *flags/*out*/)
 {
-    int	ret_value;
+    int	ret_value = 0;
 
-    FUNC_ENTER_API(FAIL)
-    H5TRACE2("Is", "*xx", f, flags);
+    FUNC_ENTER_API((-1))
+    H5TRACE2("Is", "*xx", file, flags);
 
-    HDassert(f);
-    HDassert(flags);
+    /* Check arguments */
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, (-1), "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, (-1), "file class pointer cannot be NULL")
+    if(!flags)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, (-1), "flags parameter cannot be NULL")
 
-    ret_value = H5FD_query(f, flags);
+    /* Call private function */
+    if(H5FD__query(file, flags) < 0)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTGET, (-1), "unable to query feature flags")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -955,69 +971,72 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_query
- *
- * Purpose:	Private version of H5FDquery()
+ * Function:    H5FD_query
  *
- * Return:	Success:    non-negative
+ * Purpose:     Private version of H5FDquery()
  *
- *		Failure:	negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
-static int
-H5FD_query(const H5FD_t *f, unsigned long *flags/*out*/)
+static herr_t
+H5FD__query(const H5FD_t *file, unsigned long *flags/*out*/)
 {
-    int	ret_value = 0;          /* Return value */
+    herr_t  ret_value = SUCCEED;        /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC
 
-    HDassert(f);
+    /* Sanity checks */
+    HDassert(file);
+    HDassert(file->cls);
     HDassert(flags);
 
-    /* Check for query driver and call it */
-    if(f->cls->query)
-        ret_value = (f->cls->query)(f, flags);
+    /* Dispatch to driver (if available) */
+    if(file->cls->query) {
+        if((file->cls->query)(file, flags) < 0)
+            HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "unable to query feature flags")
+    }
     else
         *flags=0;
 
+done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FD_query() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDalloc
+ * Function:    H5FDalloc
  *
- * Purpose:	Allocates SIZE bytes of memory from the FILE. The memory will
- *		be used according to the allocation class TYPE. First we try
- *		to satisfy the request from one of the free lists, according
- *		to the free list map provided by the driver. The free list
- *		array has one entry for each request type and the value of
- *		that array element can be one of four possibilities:
+ * Purpose:     Allocates SIZE bytes of memory from the FILE. The memory will
+ *              be used according to the allocation class TYPE. First we try
+ *              to satisfy the request from one of the free lists, according
+ *              to the free list map provided by the driver. The free list
+ *              array has one entry for each request type and the value of
+ *              that array element can be one of four possibilities:
  *
- *		      It can be the constant H5FD_MEM_DEFAULT (or zero) which
- *		      indicates that the identity mapping is used. In other
- *		      words, the request type maps to its own free list.
+ *              It can be the constant H5FD_MEM_DEFAULT (or zero) which
+ *              indicates that the identity mapping is used. In other
+ *              words, the request type maps to its own free list.
  *
- *		      It can be the request type itself, which has the same
- *		      effect as the H5FD_MEM_DEFAULT value above.
+ *              It can be the request type itself, which has the same
+ *              effect as the H5FD_MEM_DEFAULT value above.
  *
- *		      It can be the ID for another request type, which
- *		      indicates that the free list for the specified type
- *		      should be used instead.
+ *              It can be the ID for another request type, which
+ *              indicates that the free list for the specified type
+ *              should be used instead.
  *
- *		      It can be the constant H5FD_MEM_NOLIST which means that
- *		      no free list should be used for this type of request.
+ *              It can be the constant H5FD_MEM_NOLIST which means that
+ *              no free list should be used for this type of request.
  *
- *		If the request cannot be satisfied from a free list then
- *		either the driver's `alloc' callback is invoked (if one was
- *		supplied) or the end-of-address marker is extended. The
- *		`alloc' callback is always called with the same arguments as
- * 		the H5FDalloc().
+ *              If the request cannot be satisfied from a free list then
+ *              either the driver's 'alloc' callback is invoked (if one was
+ *              supplied) or the end-of-address marker is extended. The
+ *              'alloc' callback is always called with the same arguments as
+ *              the H5FDalloc().
  *
- * Return:	Success:	The format address of the new file memory.
+ * Return:      Success:    The format address of the new file memory.
  *
- *		Failure:	The undefined address HADDR_UNDEF
+ *              Failure:    The undefined address HADDR_UNDEF
  *
  *-------------------------------------------------------------------------
  */
@@ -1029,13 +1048,15 @@ H5FDalloc(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, hsize_t size)
     FUNC_ENTER_API(HADDR_UNDEF)
     H5TRACE4("a", "*xMtih", file, type, dxpl_id, size);
 
-    /* Check args */
-    if(!file || !file->cls)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "invalid file pointer")
+    /* Check arguments */
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "file class pointer cannot be NULL")
     if(type < H5FD_MEM_DEFAULT || type >= H5FD_MEM_NTYPES)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "invalid request type")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "invalid request type")
     if(size == 0)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "zero-size request")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "zero-size request")
     if(H5P_DEFAULT == dxpl_id)
         dxpl_id = H5P_DATASET_XFER_DEFAULT;
     else
@@ -1045,9 +1066,9 @@ H5FDalloc(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, hsize_t size)
     /* Set DXPL for operation */
     H5CX_set_dxpl(dxpl_id);
 
-    /* Do the real work */
+    /* Call private function */
     if(HADDR_UNDEF == (ret_value = H5FD__alloc_real(file, type, size, NULL, NULL)))
-	HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "unable to allocate file memory")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "unable to allocate file memory")
 
     /* (Note compensating for base address subtraction in internal routine) */
     ret_value += file->base_addr;
@@ -1058,32 +1079,32 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDfree
+ * Function:    H5FDfree
  *
- * Purpose:	Frees format addresses starting with ADDR and continuing for
- *		SIZE bytes in the file FILE. The type of space being freed is
- *		specified by TYPE, which is mapped to a free list as
- *		described for the H5FDalloc() function above.  If the request
- *		doesn't map to a free list then either the application `free'
- *		callback is invoked (if defined) or the memory is leaked.
- *
- * Return:	Success:	Non-negative
+ * Purpose:     Frees format addresses starting with ADDR and continuing for
+ *              SIZE bytes in the file FILE. The type of space being freed is
+ *              specified by TYPE, which is mapped to a free list as
+ *              described for the H5FDalloc() function above.  If the request
+ *              doesn't map to a free list then either the application 'free'
+ *              callback is invoked (if defined) or the memory is leaked.
  *
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5FDfree(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, hsize_t size)
 {
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    herr_t      ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE5("e", "*xMtiah", file, type, dxpl_id, addr, size);
 
-    /* Check args */
-    if(!file || !file->cls)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer")
+    /* Check arguments */
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL")
     if(type < H5FD_MEM_DEFAULT || type >= H5FD_MEM_NTYPES)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid request type")
     if(H5P_DEFAULT == dxpl_id)
@@ -1095,9 +1116,9 @@ H5FDfree(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, hsize_t siz
     /* Set DXPL for operation */
     H5CX_set_dxpl(dxpl_id);
 
-    /* Do the real work */
+    /* Call private function */
     /* (Note compensating for base address addition in internal routine) */
-    if(H5FD_free_real(file, type, addr - file->base_addr, size) < 0)
+    if(H5FD__free_real(file, type, addr - file->base_addr, size) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTFREE, FAIL, "file deallocation request failed")
 
 done:
@@ -1124,13 +1145,15 @@ H5FDget_eoa(H5FD_t *file, H5FD_mem_t type)
     FUNC_ENTER_API(HADDR_UNDEF)
     H5TRACE2("a", "*xMt", file, type);
 
-    /* Check args */
-    if(!file || !file->cls)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "invalid file pointer")
+    /* Check arguments */
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "file class pointer cannot be NULL")
     if(type < H5FD_MEM_DEFAULT || type >= H5FD_MEM_NTYPES)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "invalid file type")
 
-    /* The real work */
+    /* Call private function */
     if(HADDR_UNDEF == (ret_value = H5FD_get_eoa(file, type)))
         HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "file get eoa request failed")
 
@@ -1171,15 +1194,17 @@ H5FDset_eoa(H5FD_t *file, H5FD_mem_t type, haddr_t addr)
     FUNC_ENTER_API(FAIL)
     H5TRACE3("e", "*xMta", file, type, addr);
 
-    /* Check args */
-    if(!file || !file->cls)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer")
+    /* Check arguments */
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL")
     if(type < H5FD_MEM_DEFAULT || type >= H5FD_MEM_NTYPES)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file type")
     if(!H5F_addr_defined(addr) || addr > file->maxaddr)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid end-of-address value")
 
-    /* The real work */
+    /* Call private function */
     /* (Note compensating for base address addition in internal routine) */
     if(H5FD_set_eoa(file, type, addr - file->base_addr) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "file set eoa request failed")
@@ -1190,23 +1215,23 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDget_eof
+ * Function:    H5FDget_eof
  *
- * Purpose:	Returns the end-of-file address, which is the greater of the
- *		end-of-format address and the actual EOF marker. This
- *		function is called after an existing file is opened in order
- *		for the library to learn the true size of the underlying file
- *		and to determine whether the hdf5 data has been truncated.
+ * Purpose:     Returns the end-of-file address, which is the greater of the
+ *              end-of-format address and the actual EOF marker. This
+ *              function is called after an existing file is opened in order
+ *              for the library to learn the true size of the underlying file
+ *              and to determine whether the hdf5 data has been truncated.
  *
- *		It is also used when a file is first opened to learn whether
- *		the file is empty or not.
+ *              It is also used when a file is first opened to learn whether
+ *              the file is empty or not.
  *
- * 		It is permissible for the driver to return the maximum address
- *		for the file size if the file is not empty.
+ *              It is permissible for the driver to return the maximum address
+ *              for the file size if the file is not empty.
  *
- * Return:	Success:	The EOF address.
+ * Return:      Success:    The EOF address.
  *
- *		Failure:	HADDR_UNDEF
+ *              Failure:    HADDR_UNDEF
  *
  *-------------------------------------------------------------------------
  */
@@ -1219,10 +1244,12 @@ H5FDget_eof(H5FD_t *file, H5FD_mem_t type)
     H5TRACE2("a", "*xMt", file, type);
 
     /* Check arguments */
-    if(!file || !file->cls)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "invalid file pointer")
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "file class pointer cannot be NULL")
 
-    /* The real work */
+    /* Call private function */
     if(HADDR_UNDEF == (ret_value = H5FD_get_eof(file, type)))
         HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "file get eof request failed")
 
@@ -1235,12 +1262,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_get_maxaddr
+ * Function:    H5FD_get_maxaddr
  *
- * Purpose:	Private version of H5FDget_eof()
+ * Purpose:     Private version of H5FDget_eof()
  *
- * Return:	Success:	The maximum address allowed in the file.
- *		Failure:	HADDR_UNDEF
+ * Return:      Success:    The maximum address allowed in the file.
+ *              Failure:    HADDR_UNDEF
  *
  *-------------------------------------------------------------------------
  */
@@ -1251,6 +1278,7 @@ H5FD_get_maxaddr(const H5FD_t *file)
 
     FUNC_ENTER_NOAPI(HADDR_UNDEF)
 
+    /* Sanity checks */
     HDassert(file);
 
     /* Set return value */
@@ -1262,12 +1290,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_get_feature_flags
+ * Function:    H5FD_get_feature_flags
  *
- * Purpose:	Retrieve the feature flags for the VFD
+ * Purpose:     Retrieve the feature flags for the VFD
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -1276,6 +1303,7 @@ H5FD_get_feature_flags(const H5FD_t *file, unsigned long *feature_flags)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
+    /* Sanity checks */
     HDassert(file);
     HDassert(feature_flags);
 
@@ -1287,12 +1315,11 @@ H5FD_get_feature_flags(const H5FD_t *file, unsigned long *feature_flags)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_set_feature_flags
+ * Function:    H5FD_set_feature_flags
  *
- * Purpose:	Set the feature flags for the VFD
+ * Purpose:     Set the feature flags for the VFD
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -1301,6 +1328,7 @@ H5FD_set_feature_flags(H5FD_t *file, unsigned long feature_flags)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
+    /* Sanity checks */
     HDassert(file);
 
     /* Set the file's feature flags */
@@ -1311,12 +1339,11 @@ H5FD_set_feature_flags(H5FD_t *file, unsigned long feature_flags)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_get_fs_type_map
+ * Function:    H5FD_get_fs_type_map
  *
- * Purpose:	Retrieve the free space type mapping for the VFD
+ * Purpose:     Retrieve the free space type mapping for the VFD
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -1327,8 +1354,9 @@ H5FD_get_fs_type_map(const H5FD_t *file, H5FD_mem_t *type_map)
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    /* Sanity check */
-    HDassert(file && file->cls);
+    /* Sanity checks */
+    HDassert(file);
+    HDassert(file->cls);
     HDassert(type_map);
 
     /* Check for VFD class providing a type map retrieval rouine */
@@ -1347,18 +1375,19 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDread
+ * Function:    H5FDread
  *
- * Purpose:	Reads SIZE bytes from FILE beginning at address ADDR
- *		according to the data transfer property list DXPL_ID (which may
- *		be the constant H5P_DEFAULT). The result is written into the
- *		buffer BUF.
+ * Purpose:     Reads SIZE bytes from FILE beginning at address ADDR
+ *              according to the data transfer property list DXPL_ID (which may
+ *              be the constant H5P_DEFAULT). The result is written into the
+ *              buffer BUF.
  *
- * Return:	Success:	Non-negative. The read result is written into
- *				the BUF buffer which should be allocated by
- *				the caller.
+ * Return:      Success:    SUCCEED
+ *                          The read result is written into the BUF buffer
+ *                          which should be allocated by the caller.
  *
- *		Failure:	Negative. The contents of BUF is undefined.
+ *              Failure:	FAIL
+ *                          The contents of BUF are undefined.
  *
  *-------------------------------------------------------------------------
  */
@@ -1366,14 +1395,18 @@ herr_t
 H5FDread(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t size,
 	 void *buf/*out*/)
 {
-    herr_t      ret_value = SUCCEED;    /* Return value */
+    herr_t          ret_value = SUCCEED;    /* Return value             */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE6("e", "*xMtiazx", file, type, dxpl_id, addr, size, buf);
 
-    /* Check args */
-    if(!file || !file->cls)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer")
+    /* Check arguments */
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL")
+    if(!buf)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "result buffer parameter can't be NULL")
 
     /* Get the default dataset transfer property list if the user didn't provide one */
     if(H5P_DEFAULT == dxpl_id)
@@ -1381,16 +1414,14 @@ H5FDread(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t size
     else
         if(TRUE != H5P_isa_class(dxpl_id, H5P_DATASET_XFER))
             HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data transfer property list")
-    if(!buf)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null result buffer")
 
     /* Set DXPL for operation */
     H5CX_set_dxpl(dxpl_id);
 
-    /* Do the real work */
+    /* Call private function */
     /* (Note compensating for base address addition in internal routine) */
     if(H5FD_read(file, type, addr - file->base_addr, size, buf) < 0)
-	HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "file read request failed")
+        HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "file read request failed")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -1398,16 +1429,14 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDwrite
+ * Function:    H5FDwrite
  *
- * Purpose:	Writes SIZE bytes to FILE beginning at address ADDR according
- *		to the data transfer property list DXPL_ID (which may be the
- *		constant H5P_DEFAULT). The bytes to be written come from the
- *		buffer BUF.
- *
- * Return:	Success:	Non-negative
+ * Purpose:     Writes SIZE bytes to FILE beginning at address ADDR according
+ *              to the data transfer property list DXPL_ID (which may be the
+ *              constant H5P_DEFAULT). The bytes to be written come from the
+ *              buffer BUF.
  *
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -1415,30 +1444,33 @@ herr_t
 H5FDwrite(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t size,
 	  const void *buf)
 {
-    herr_t      ret_value = SUCCEED;    /* Return value */
+    herr_t          ret_value = SUCCEED;    /* Return value             */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE6("e", "*xMtiaz*x", file, type, dxpl_id, addr, size, buf);
 
-    /* Check args */
-    if(!file || !file->cls)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer")
+    /* Check arguments */
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL")
+    if(!buf)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "result buffer parameter can't be NULL")
+
     /* Get the default dataset transfer property list if the user didn't provide one */
     if(H5P_DEFAULT == dxpl_id)
         dxpl_id = H5P_DATASET_XFER_DEFAULT;
     else
         if(TRUE != H5P_isa_class(dxpl_id, H5P_DATASET_XFER))
             HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data transfer property list")
-    if(!buf)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null buffer")
 
     /* Set DXPL for operation */
     H5CX_set_dxpl(dxpl_id);
 
-    /* The real work */
+    /* Call private function */
     /* (Note compensating for base address addition in internal routine) */
     if(H5FD_write(file, type, addr - file->base_addr, size, buf) < 0)
-	HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "file write request failed")
+        HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "file write request failed")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -1446,17 +1478,12 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDflush
- *
- * Purpose:	Notify driver to flush all cached data.  If the driver has no
- *		flush method then nothing happens.
- *
- * Return:	Success:	Non-negative
+ * Function:    H5FDflush
  *
- *		Failure:	Negative
+ * Purpose:     Notify driver to flush all cached data.  If the driver has no
+ *              flush method then nothing happens.
  *
- * Programmer:	Robb Matzke
- *              Thursday, July 29, 1999
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -1468,9 +1495,12 @@ H5FDflush(H5FD_t *file, hid_t dxpl_id, hbool_t closing)
     FUNC_ENTER_API(FAIL)
     H5TRACE3("e", "*xib", file, dxpl_id, closing);
 
-    /* Check args */
-    if(!file || !file->cls)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer")
+    /* Check arguments */
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL")
+
     if(H5P_DEFAULT == dxpl_id)
         dxpl_id = H5P_DATASET_XFER_DEFAULT;
     else
@@ -1480,9 +1510,9 @@ H5FDflush(H5FD_t *file, hid_t dxpl_id, hbool_t closing)
     /* Set DXPL for operation */
     H5CX_set_dxpl(dxpl_id);
 
-    /* Do the real work */
+    /* Call private function */
     if(H5FD_flush(file, closing) < 0)
-	HGOTO_ERROR(H5E_VFL, H5E_CANTFLUSH, FAIL, "file flush request failed")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTFLUSH, FAIL, "file flush request failed")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -1490,12 +1520,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_flush
+ * Function:    H5FD_flush
  *
- * Purpose:	Private version of H5FDflush()
+ * Purpose:     Private version of H5FDflush()
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -1507,8 +1536,10 @@ H5FD_flush(H5FD_t *file, hbool_t closing)
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity checks */
-    HDassert(file && file->cls);
+    HDassert(file);
+    HDassert(file->cls);
 
+    /* Dispatch to driver */
     if(file->cls->flush && (file->cls->flush)(file, H5CX_get_dxpl(), closing) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver flush request failed")
 
@@ -1518,12 +1549,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDtruncate
+ * Function:    H5FDtruncate
  *
- * Purpose:	Notify driver to truncate the file back to the allocated size.
+ * Purpose:     Notify driver to truncate the file back to the allocated size.
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -1535,9 +1565,11 @@ H5FDtruncate(H5FD_t *file, hid_t dxpl_id, hbool_t closing)
     FUNC_ENTER_API(FAIL)
     H5TRACE3("e", "*xib", file, dxpl_id, closing);
 
-    /* Check args */
-    if(!file || !file->cls)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer")
+    /* Check arguments */
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL")
     if(H5P_DEFAULT == dxpl_id)
         dxpl_id = H5P_DATASET_XFER_DEFAULT;
     else
@@ -1547,9 +1579,9 @@ H5FDtruncate(H5FD_t *file, hid_t dxpl_id, hbool_t closing)
     /* Set DXPL for operation */
     H5CX_set_dxpl(dxpl_id);
 
-    /* Do the real work */
+    /* Call private function */
     if(H5FD_truncate(file, closing) < 0)
-	HGOTO_ERROR(H5E_VFL, H5E_CANTUPDATE, FAIL, "file flush request failed")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTUPDATE, FAIL, "file flush request failed")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -1559,22 +1591,22 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5FD_truncate
  *
- * Purpose:	Private version of H5FDtruncate()
+ * Purpose:     Private version of H5FDtruncate()
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5FD_truncate(H5FD_t *file, hbool_t closing)
 {
-    herr_t ret_value = SUCCEED; /* Return value */
+    herr_t      ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity checks */
-    HDassert(file && file->cls);
+    HDassert(file);
+    HDassert(file->cls);
 
     /* Dispatch to driver */
     if(file->cls->truncate && (file->cls->truncate)(file, H5CX_get_dxpl(), closing) < 0)
@@ -1586,12 +1618,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDlock
+ * Function:    H5FDlock
  *
- * Purpose:	Set a file lock
+ * Purpose:     Set a file lock
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -1603,13 +1634,15 @@ H5FDlock(H5FD_t *file, hbool_t rw)
     FUNC_ENTER_API(FAIL)
     H5TRACE2("e", "*xb", file, rw);
 
-    /* Check args */
-    if(!file || !file->cls)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer")
+    /* Check arguments */
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL")
 
-    /* The real work */
+    /* Call private function */
     if(H5FD_lock(file, rw) < 0)
-	HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "file lock request failed")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "file lock request failed")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -1618,12 +1651,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_lock
+ * Function:    H5FD_lock
  *
- * Purpose:	Private version of H5FDlock()
+ * Purpose:     Private version of H5FDlock()
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -1634,8 +1666,11 @@ H5FD_lock(H5FD_t *file, hbool_t rw)
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    HDassert(file && file->cls);
+    /* Sanity checks */
+    HDassert(file);
+    HDassert(file->cls);
 
+    /* Dispatch to driver */
     if(file->cls->lock && (file->cls->lock)(file, rw) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTUPDATE, FAIL, "driver lock request failed")
 
@@ -1645,12 +1680,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FDunlock
+ * Function:    H5FDunlock
  *
- * Purpose:	Remove a file lock
+ * Purpose:     Remove a file lock
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -1662,13 +1696,15 @@ H5FDunlock(H5FD_t *file)
     FUNC_ENTER_API(FAIL)
     H5TRACE1("e", "*x", file);
 
-    /* Check args */
-    if(!file || !file->cls)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer")
+    /* Check arguments */
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL")
 
-    /* The real work */
+    /* Call private function */
     if(H5FD_unlock(file) < 0)
-	HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "file unlock request failed")
+        HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "file unlock request failed")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -1676,12 +1712,11 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_unlock
+ * Function:    H5FD_unlock
  *
- * Purpose:	Private version of H5FDunlock()
+ * Purpose:     Private version of H5FDunlock()
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -1692,8 +1727,11 @@ H5FD_unlock(H5FD_t *file)
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    HDassert(file && file->cls);
+    /* Sanity checks */
+    HDassert(file);
+    HDassert(file->cls);
 
+    /* Dispatch to driver */
     if(file->cls->unlock && (file->cls->unlock)(file) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTUPDATE, FAIL, "driver unlock request failed")
 
@@ -1703,13 +1741,13 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FD_get_fileno
+ * Function:    H5FD_get_fileno
  *
- * Purpose:	Quick and dirty routine to retrieve the file's 'fileno' value
- *          (Mainly added to stop non-file routines from poking about in the
- *          H5FD_t data structure)
+ * Purpose:     Quick and dirty routine to retrieve the file's 'fileno' value
+ *              (Mainly added to stop non-file routines from poking about in the
+ *              H5FD_t data structure)
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -1718,6 +1756,7 @@ H5FD_get_fileno(const H5FD_t *file, unsigned long *filenum)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
+    /* Sanity checks */
     HDassert(file);
     HDassert(filenum);
 
@@ -1734,28 +1773,36 @@ H5FD_get_fileno(const H5FD_t *file, unsigned long *filenum)
  * Purpose:     Returns a pointer to the file handle of low-level virtual
  *              file driver.
  *
- * Return:      Non-negative if succeed; negative otherwise.
- *
- * Programmer:  Raymond Lu
- *              Sep. 16, 2002
+ * Return:      SUCCEED/FAIL
  *
  *--------------------------------------------------------------------------
  */
 herr_t
-H5FDget_vfd_handle(H5FD_t *file, hid_t fapl, void **file_handle)
+H5FDget_vfd_handle(H5FD_t *file, hid_t fapl_id, void **file_handle)
 {
-    herr_t              ret_value;
+    herr_t ret_value = SUCCEED;
 
     FUNC_ENTER_API(FAIL)
-    H5TRACE3("e", "*xi**x", file, fapl, file_handle);
+    H5TRACE3("e", "*xi**x", file, fapl_id, file_handle);
 
     /* Check arguments */
-    HDassert(file);
-    HDassert(file_handle);
-
-    ret_value = H5FD_get_vfd_handle(file, fapl, file_handle);
+    if(!file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL")
+    if(!file->cls)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL")
+    if(FALSE == H5P_isa_class(fapl_id, H5P_FILE_ACCESS))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "fapl_id parameter is not a file access property list")
+    if(!file_handle)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file handle parameter cannot be NULL")
+
+    /* Call private function */
+    if(H5FD_get_vfd_handle(file, fapl_id, file_handle) < 0)
+        HGOTO_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "can't get file handle for file driver")
 
 done:
+    if(FAIL == ret_value)
+        *file_handle = NULL;
+
     FUNC_LEAVE_API(ret_value)
 } /* end H5FDget_vfd_handle() */
 
@@ -1763,29 +1810,28 @@ done:
 /*--------------------------------------------------------------------------
  * Function:    H5FD_get_vfd_handle
  *
- * Purpose:     Retrieve the file handle for file driver.
+ * Purpose:     Private version of H5FDget_vfd_handle()
  *
- * Return:      Non-negative if succeed; negative if fails.
- *
- * Programmer:  Raymond Lu
- *              Sep. 16, 2002
+ * Return:      SUCCEED/FAIL
  *
  *--------------------------------------------------------------------------
  */
 herr_t
-H5FD_get_vfd_handle(H5FD_t *file, hid_t fapl, void **file_handle)
+H5FD_get_vfd_handle(H5FD_t *file, hid_t fapl_id, void **file_handle)
 {
     herr_t ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    /* Sanity check */
+    /* Sanity checks */
     HDassert(file);
+    HDassert(file->cls);
     HDassert(file_handle);
 
+    /* Dispatch to driver */
     if(NULL == file->cls->get_handle)
-	HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "file driver has no `get_vfd_handle' method")
-    if((file->cls->get_handle)(file, fapl, file_handle) < 0)
+        HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "file driver has no `get_vfd_handle' method")
+    if((file->cls->get_handle)(file, fapl_id, file_handle) < 0)
         HGOTO_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "can't get file handle for file driver")
 
 done:
@@ -1798,7 +1844,7 @@ done:
  *
  * Purpose:     Set the base address for the file
  *
- * Return:      Non-negative if succeed; negative if fails.
+ * Return:      SUCCEED (Can't fail)
  *
  *--------------------------------------------------------------------------
  */
@@ -1807,6 +1853,7 @@ H5FD_set_base_addr(H5FD_t *file, haddr_t base_addr)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
+    /* Sanity checks */
     HDassert(file);
     HDassert(H5F_addr_defined(base_addr));
 
@@ -1822,8 +1869,8 @@ H5FD_set_base_addr(H5FD_t *file, haddr_t base_addr)
  *
  * Purpose:     Get the base address for the file
  *
- * Return:	Success:	The absolute base address of the file
- *		Failure:	The undefined address (HADDR_UNDEF)
+ * Return:      Success:    The absolute base address of the file
+ *                          (Can't fail)
  *
  *--------------------------------------------------------------------------
  */
@@ -1832,6 +1879,7 @@ H5FD_get_base_addr(const H5FD_t *file)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
+    /* Sanity checks */
     HDassert(file);
 
     /* Return the file's base address */
@@ -1844,7 +1892,7 @@ H5FD_get_base_addr(const H5FD_t *file)
  *
  * Purpose:     Set "paged_aggr" for the file.
  *
- * Return:      Non-negative if succeed; negative if fails.
+ * Return:      SUCCEED (Can't fail)
  *
  *--------------------------------------------------------------------------
  */
@@ -1853,6 +1901,7 @@ H5FD_set_paged_aggr(H5FD_t *file, hbool_t paged)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
+    /* Sanity checks */
     HDassert(file);
 
     /* Indicate whether paged aggregation for handling file space is enabled or not */
@@ -1883,6 +1932,7 @@ H5FDdriver_query(hid_t driver_id, unsigned long *flags/*out*/)
     FUNC_ENTER_API(FAIL)
     H5TRACE2("e", "ix", driver_id, flags);
 
+    /* Check arguments */
     if(NULL == flags)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "flags parameter cannot be NULL")