summaryrefslogtreecommitdiffstats
path: root/src/H5FDdirect.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/H5FDdirect.c')
-rw-r--r--src/H5FDdirect.c954
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 */
-