diff options
Diffstat (limited to 'src/H5FDdirect.c')
| -rw-r--r-- | src/H5FDdirect.c | 954 |
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(©_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(©_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(©_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(©_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 */ - |