mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-04-06 17:20:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r1788] Converted all the VFL drivers except for the stdio and multi drivers back into

Browse Source 
the "internal" HDF5 coding standard.
This commit is contained in:
Quincey Koziol 1999-10-22 19:36:04 -05:00
parent 69fc209302
commit 1953487e12
8 changed files with 1157 additions and 666 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/H5Epublic.h
View File

@ -66,7 +66,7 @@
/* And goto a label after pushing error onto stack */
#define H5Epush_goto(func,maj,min,str,label) { \
H5Epush(__FILE__,func,__LINE__,maj,min,str); \
goto (label); \
goto label; \
}
/*
@ -172,6 +172,9 @@ typedef enum H5E_minor_t {
H5E_LINK, /*link count failure */
H5E_SLINK, /*symbolic link error */
/* Datatype conversion errors */
H5E_CANTCONVERT, /*Can't convert datatypes */
/* Parallel errors */
H5E_MPI /*some MPI function failed */
} H5E_minor_t;

215
src/H5FDcore.c
View File

@ -9,10 +9,12 @@
* only the HDF5 public API. This driver is useful for fast
* access to small, temporary hdf5 files.
*/
#include <H5private.h>
#include <H5Fprivate.h>
#include <H5FDcore.h>
#include <H5Pprivate.h>
#include <H5private.h> /*library functions */
#include <H5Eprivate.h> /*error handling */
#include <H5Fprivate.h> /*files */
#include <H5FDcore.h> /* Core file driver */
#include <H5MMprivate.h> /* Memory allocation */
#include <H5Pprivate.h> /*property lists */
#undef MAX
#define MAX(X,Y) ((X)>(Y)?(X):(Y))
@ -112,6 +114,11 @@ static const H5FD_class_t H5FD_core_g = {
H5FD_FLMAP_SINGLE, /*fl_map */
};
/* Interface initialization */
#define PABLO_MASK H5FD_core_mask
#define INTERFACE_INIT H5FD_core_init
static intn interface_initialize_g = 0;
/*-------------------------------------------------------------------------
* Function: H5FD_core_init
@ -133,10 +140,12 @@ static const H5FD_class_t H5FD_core_g = {
hid_t
H5FD_core_init(void)
{
if (H5I_VFL!=H5Iget_type(H5FD_CORE_g)) {
H5FD_CORE_g = H5FDregister(&H5FD_core_g);
}
return H5FD_CORE_g;
FUNC_ENTER(H5FD_core_init, FAIL);
if (H5I_VFL!=H5Iget_type(H5FD_CORE_g))
H5FD_CORE_g = H5FDregister(&H5FD_core_g);
FUNC_LEAVE(H5FD_CORE_g);
}
@ -162,13 +171,20 @@ H5FD_core_init(void)
herr_t
H5Pset_fapl_core(hid_t fapl_id, size_t increment, hbool_t backing_store)
{
herr_t ret_value=FAIL;
H5FD_core_fapl_t fa;
FUNC_ENTER(H5FD_set_fapl_core, FAIL);
/* NO TRACE */
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a fapl");
fa.increment = increment;
fa.backing_store = backing_store;
return H5Pset_driver(fapl_id, H5FD_CORE, &fa);
ret_value= H5Pset_driver(fapl_id, H5FD_CORE, &fa);
FUNC_LEAVE(ret_value);
}
@ -195,15 +211,20 @@ H5Pget_fapl_core(hid_t fapl_id, size_t *increment/*out*/,
{
H5FD_core_fapl_t *fa;
FUNC_ENTER(H5Pget_fapl_core, FAIL);
/* NO TRACE */
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
if (H5FD_CORE!=H5Pget_driver(fapl_id)) return -1;
if (NULL==(fa=H5Pget_driver_info(fapl_id))) return -1;
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a fapl");
if (H5FD_CORE!=H5Pget_driver(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "incorrect VFL driver");
if (NULL==(fa=H5Pget_driver_info(fapl_id)))
HRETURN_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "bad VFL driver info");
if (increment) *increment = fa->increment;
if (backing_store) *backing_store = fa->backing_store;
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -227,11 +248,17 @@ static void *
H5FD_core_fapl_get(H5FD_t *_file)
{
H5FD_core_t *file = (H5FD_core_t*)_file;
H5FD_core_fapl_t *fa = calloc(1, sizeof(H5FD_core_fapl_t));
H5FD_core_fapl_t *fa = NULL;
FUNC_ENTER(H5FD_core_fapl_get, NULL);
if (NULL==(fa=H5MM_calloc(sizeof(H5FD_core_fapl_t))))
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
fa->increment = file->increment;
fa->backing_store = (file->fd>=0);
return fa;
FUNC_LEAVE(fa);
}
@ -261,24 +288,28 @@ H5FD_core_open(const char *name, unsigned UNUSED flags, hid_t fapl_id,
H5FD_core_t *file=NULL;
H5FD_core_fapl_t *fa=NULL;
int fd=-1;
FUNC_ENTER(H5FD_init_interface, NULL);
/* Check arguments */
if (0==maxaddr || HADDR_UNDEF==maxaddr) return NULL;
if (ADDR_OVERFLOW(maxaddr)) return NULL;
if (0==maxaddr || HADDR_UNDEF==maxaddr)
HRETURN_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "bogus maxaddr");
if (ADDR_OVERFLOW(maxaddr))
HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, NULL, "maxaddr overflow");
if (H5P_DEFAULT!=fapl_id) fa = H5Pget_driver_info(fapl_id);
/* Open backing store */
if (fa && fa->backing_store && name &&
(fd=open(name, O_CREAT|O_TRUNC|O_RDWR, 0666))<0) {
return NULL;
(fd=open(name, O_CREAT|O_TRUNC|O_RDWR, 0666))<0) {
HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "can't open backing store");
}
/* Create the new file struct */
file = calloc(1, sizeof(H5FD_core_t));
if (NULL==(file=H5MM_calloc(sizeof(H5FD_core_t))))
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate file struct");
file->fd = fd;
if (name && *name) {
file->name = malloc(strlen(name)+1);
strcpy(file->name, name);
file->name = HDstrdup(name);
}
/*
@ -289,7 +320,7 @@ H5FD_core_open(const char *name, unsigned UNUSED flags, hid_t fapl_id,
file->increment = (fa && fa->increment>0) ?
fa->increment : H5FD_CORE_INCREMENT;
return (H5FD_t*)file;
FUNC_LEAVE((H5FD_t*)file);
}
@ -315,22 +346,28 @@ H5FD_core_flush(H5FD_t *_file)
{
H5FD_core_t *file = (H5FD_core_t*)_file;
FUNC_ENTER(H5FD_core_flush, FAIL);
/* Write to backing store */
if (file->dirty && file->fd>=0) {
haddr_t size = file->eof;
unsigned char *ptr = file->mem;
if (0!=lseek(file->fd, 0, SEEK_SET)) return -1;
haddr_t size = file->eof;
unsigned char *ptr = file->mem;
while (size) {
ssize_t n = write(file->fd, ptr, size);
if (n<0 && EINTR==errno) continue;
if (n<0) return -1;
ptr += (size_t)n;
size -= (size_t)n;
}
file->dirty = FALSE;
if (0!=lseek(file->fd, 0, SEEK_SET))
HRETURN_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "error seeking in backing store");
while (size) {
ssize_t n = write(file->fd, ptr, size);
if (n<0 && EINTR==errno) continue;
if (n<0)
HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "error writing backing store");
ptr += (size_t)n;
size -= (size_t)n;
}
file->dirty = FALSE;
}
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -357,15 +394,18 @@ H5FD_core_close(H5FD_t *_file)
{
H5FD_core_t *file = (H5FD_core_t*)_file;
FUNC_ENTER(H5FD_core_close, FAIL);
/* Flush */
if (H5FD_core_flush(_file)<0) return -1;
if (H5FD_core_flush(_file)<0)
HRETURN_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "can't flush file");
/* Release resources */
if (file->fd>=0) close(file->fd);
if (file->name) free(file->name);
if (file->mem) free(file->mem);
if (file->name) H5MM_xfree(file->name);
if (file->mem) H5MM_xfree(file->mem);
memset(file, 0, sizeof(H5FD_core_t));
return 0;
FUNC_LEAVE(0);
}
@ -395,16 +435,22 @@ H5FD_core_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
const H5FD_core_t *f1 = (const H5FD_core_t*)_f1;
const H5FD_core_t *f2 = (const H5FD_core_t*)_f2;
FUNC_ENTER(H5FD_core_cmp, FAIL);
if (NULL==f1->name && NULL==f2->name) {
if (f1<f2) return -1;
if (f1>f2) return 1;
return 0;
if (f1<f2)
HRETURN(-1);
if (f1>f2)
HRETURN(1);
HRETURN(0);
}
if (NULL==f1->name) return -1;
if (NULL==f2->name) return 1;
if (NULL==f1->name)
HRETURN(-1);
if (NULL==f2->name)
HRETURN(1);
return strcmp(f1->name, f2->name);
FUNC_LEAVE(HDstrcmp(f1->name, f2->name));
}
@ -430,7 +476,10 @@ static haddr_t
H5FD_core_get_eoa(H5FD_t *_file)
{
H5FD_core_t *file = (H5FD_core_t*)_file;
return file->eoa;
FUNC_ENTER(H5FD_core_get_eoa, HADDR_UNDEF);
FUNC_LEAVE(file->eoa);
}
@ -456,9 +505,14 @@ static herr_t
H5FD_core_set_eoa(H5FD_t *_file, haddr_t addr)
{
H5FD_core_t *file = (H5FD_core_t*)_file;
if (ADDR_OVERFLOW(addr)) return -1;
FUNC_ENTER(H5FD_core_set_eoa, FAIL);
if (ADDR_OVERFLOW(addr))
HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "address overflow");
file->eoa = addr;
return 0;
FUNC_LEAVE(0);
}
@ -486,7 +540,10 @@ static haddr_t
H5FD_core_get_eof(H5FD_t *_file)
{
H5FD_core_t *file = (H5FD_core_t*)_file;
return MAX(file->eof, file->eoa);
FUNC_ENTER(H5FD_core_get_eof, HADDR_UNDEF);
FUNC_LEAVE(MAX(file->eof, file->eoa));
}
@ -516,28 +573,33 @@ H5FD_core_read(H5FD_t *_file, hid_t UNUSED dxpl_id, haddr_t addr,
H5FD_core_t *file = (H5FD_core_t*)_file;
ssize_t nbytes;
FUNC_ENTER(H5FD_core_read, FAIL);
assert(file && file->pub.cls);
assert(buf);
/* Check for overflow conditions */
if (HADDR_UNDEF==addr) return -1;
if (REGION_OVERFLOW(addr, size)) return -1;
if (addr+size>file->eoa) return -1;
if (HADDR_UNDEF==addr)
HRETURN_ERROR(H5E_IO, H5E_OVERFLOW, FAIL, "file address overflowed");
if (REGION_OVERFLOW(addr, size))
HRETURN_ERROR(H5E_IO, H5E_OVERFLOW, FAIL, "file address overflowed");
if (addr+size>file->eoa)
HRETURN_ERROR(H5E_IO, H5E_OVERFLOW, FAIL, "file address overflowed");
/* Read the part which is before the EOF marker */
if (addr<file->eof) {
nbytes = MIN(size, file->eof-addr);
memcpy(buf, file->mem+addr, nbytes);
size -= nbytes;
addr += nbytes;
buf = (char*)buf + nbytes;
nbytes = MIN(size, file->eof-addr);
memcpy(buf, file->mem+addr, nbytes);
size -= nbytes;
addr += nbytes;
buf = (char*)buf + nbytes;
}
/* Read zeros for the part which is after the EOF markers */
if (size>0) {
memset(buf, 0, size);
}
return 0;
if (size>0)
memset(buf, 0, size);
FUNC_LEAVE(SUCCEED);
}
@ -565,12 +627,16 @@ H5FD_core_write(H5FD_t *_file, hid_t UNUSED dxpl_id, haddr_t addr,
{
H5FD_core_t *file = (H5FD_core_t*)_file;
FUNC_ENTER(H5FD_core_write, FAIL);
assert(file && file->pub.cls);
assert(buf);
/* Check for overflow conditions */
if (REGION_OVERFLOW(addr, size)) return -1;
if (addr+size>file->eoa) return -1;
if (REGION_OVERFLOW(addr, size))
HRETURN_ERROR(H5E_IO, H5E_OVERFLOW, FAIL, "file address overflowed");
if (addr+size>file->eoa)
HRETURN_ERROR(H5E_IO, H5E_OVERFLOW, FAIL, "file address overflowed");
/*
* Allocate more memory if necessary, careful of overflow. Also, if the
@ -579,18 +645,21 @@ H5FD_core_write(H5FD_t *_file, hid_t UNUSED dxpl_id, haddr_t addr,
* the first argument is null.
*/
if (addr+size>file->eof) {
unsigned char *x;
size_t new_eof = file->increment * ((addr+size)/file->increment);
if ((addr+size) % file->increment) new_eof += file->increment;
if (NULL==file->mem) x = malloc(new_eof);
else x = realloc(file->mem, new_eof);
if (!x) return -1;
file->mem = x;
file->eof = new_eof;
unsigned char *x;
size_t new_eof = file->increment * ((addr+size)/file->increment);
if ((addr+size) % file->increment) new_eof += file->increment;
if (NULL==file->mem) x = H5MM_malloc(new_eof);
else x = H5MM_realloc(file->mem, new_eof);
if (!x)
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate memory block");
file->mem = x;
file->eof = new_eof;
}
/* Write from BUF to memory */
memcpy(file->mem+addr, buf, size);
file->dirty = TRUE;
return 0;
FUNC_LEAVE(SUCCEED);
}

404
src/H5FDfamily.c
View File

@ -21,9 +21,13 @@
* implement holes, like nfs).
*
*/
#include <assert.h>
#include <hdf5.h>
#include <stdlib.h>
#include <H5private.h> /*library functions */
#include <H5Eprivate.h> /*error handling */
#include <H5Fprivate.h> /*files */
#include <H5FDfamily.h> /* Family file driver */
#include <H5MMprivate.h> /* Memory allocation */
#include <H5Pprivate.h> /*property lists */
#undef MAX
#define MAX(X,Y) ((X)>(Y)?(X):(Y))
@ -104,6 +108,11 @@ static const H5FD_class_t H5FD_family_g = {
H5FD_FLMAP_SINGLE, /*fl_map */
};
/* Interface initialization */
#define PABLO_MASK H5FD_family_mask
#define INTERFACE_INIT H5FD_family_init
static intn interface_initialize_g = 0;
/*-------------------------------------------------------------------------
* Function: H5FD_family_init
@ -125,10 +134,12 @@ static const H5FD_class_t H5FD_family_g = {
hid_t
H5FD_family_init(void)
{
if (H5I_VFL!=H5Iget_type(H5FD_FAMILY_g)) {
H5FD_FAMILY_g = H5FDregister(&H5FD_family_g);
}
return H5FD_FAMILY_g;
FUNC_ENTER(H5FD_family_init, FAIL);
if (H5I_VFL!=H5Iget_type(H5FD_FAMILY_g))
H5FD_FAMILY_g = H5FDregister(&H5FD_family_g);
FUNC_LEAVE(H5FD_FAMILY_g);
}
@ -155,14 +166,18 @@ H5FD_family_init(void)
herr_t
H5Pset_fapl_family(hid_t fapl_id, hsize_t memb_size, hid_t memb_fapl_id)
{
herr_t ret_value=FAIL;
H5FD_family_fapl_t fa;
/*NO TRACE*/
FUNC_ENTER(H5FD_set_fapl_family, FAIL);
/* Check arguments */
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a fapl");
if (H5P_DEFAULT!=memb_fapl_id &&
H5P_FILE_ACCESS!=H5Pget_class(memb_fapl_id)) return -1;
H5P_FILE_ACCESS!=H5Pget_class(memb_fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a fapl");
/*
* Initialize driver specific information. No need to copy it into the FA
@ -170,7 +185,10 @@ H5Pset_fapl_family(hid_t fapl_id, hsize_t memb_size, hid_t memb_fapl_id)
*/
fa.memb_size = memb_size;
fa.memb_fapl_id = memb_fapl_id;
return H5Pset_driver(fapl_id, H5FD_FAMILY, &fa);
ret_value= H5Pset_driver(fapl_id, H5FD_FAMILY, &fa);
FUNC_LEAVE(ret_value);
}
@ -198,13 +216,18 @@ H5Pget_fapl_family(hid_t fapl_id, hsize_t *memb_size/*out*/,
H5FD_family_fapl_t *fa;
/*NO TRACE*/
FUNC_ENTER(H5Pget_fapl_family, FAIL);
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
if (H5FD_FAMILY!=H5Pget_driver(fapl_id)) return -1;
if (NULL==(fa=H5Pget_driver_info(fapl_id))) return -1;
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a fapl");
if (H5FD_FAMILY!=H5Pget_driver(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "incorrect VFL driver");
if (NULL==(fa=H5Pget_driver_info(fapl_id)))
HRETURN_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "bad VFL driver info");
if (memb_size) *memb_size = fa->memb_size;
if (memb_fapl_id) *memb_fapl_id = H5Pcopy(fa->memb_fapl_id);
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -229,11 +252,17 @@ static void *
H5FD_family_fapl_get(H5FD_t *_file)
{
H5FD_family_t *file = (H5FD_family_t*)_file;
H5FD_family_fapl_t *fa = calloc(1, sizeof(H5FD_family_fapl_t*));
H5FD_family_fapl_t *fa = NULL;
FUNC_ENTER(H5FD_family_fapl_get, NULL);
if (NULL==(fa=H5MM_calloc(sizeof(H5FD_family_fapl_t))))
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
fa->memb_size = file->memb_size;
fa->memb_fapl_id = H5Pcopy(file->memb_fapl_id);
return fa;
FUNC_LEAVE(fa);
}
@ -257,12 +286,17 @@ static void *
H5FD_family_fapl_copy(const void *_old_fa)
{
const H5FD_family_fapl_t *old_fa = (const H5FD_family_fapl_t*)_old_fa;
H5FD_family_fapl_t *new_fa = malloc(sizeof(H5FD_family_fapl_t));
assert(new_fa);
H5FD_family_fapl_t *new_fa = NULL;
FUNC_ENTER(H5FD_family_fapl_copy, NULL);
if (NULL==(new_fa=H5MM_malloc(sizeof(H5FD_family_fapl_t))))
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
memcpy(new_fa, old_fa, sizeof(H5FD_family_fapl_t));
new_fa->memb_fapl_id = H5Pcopy(old_fa->memb_fapl_id);
return new_fa;
FUNC_LEAVE(new_fa);
}
@ -286,9 +320,13 @@ static herr_t
H5FD_family_fapl_free(void *_fa)
{
H5FD_family_fapl_t *fa = (H5FD_family_fapl_t*)_fa;
FUNC_ENTER(H5FD_family_fapl_free, FAIL);
H5Pclose(fa->memb_fapl_id);
free(fa);
return 0;
H5MM_xfree(fa);
FUNC_LEAVE(SUCCEED);
}
@ -312,12 +350,17 @@ static void *
H5FD_family_dxpl_copy(const void *_old_dx)
{
const H5FD_family_dxpl_t *old_dx = (const H5FD_family_dxpl_t*)_old_dx;
H5FD_family_dxpl_t *new_dx = malloc(sizeof(H5FD_family_dxpl_t));
assert(new_dx);
H5FD_family_dxpl_t *new_dx = NULL;
FUNC_ENTER(H5FD_family_dxpl_copy, NULL);
if (NULL==(new_dx=H5MM_malloc(sizeof(H5FD_family_dxpl_t))))
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
memcpy(new_dx, old_dx, sizeof(H5FD_family_dxpl_t));
new_dx->memb_dxpl_id = H5Pcopy(old_dx->memb_dxpl_id);
return new_dx;
FUNC_LEAVE(new_dx);
}
@ -341,9 +384,13 @@ static herr_t
H5FD_family_dxpl_free(void *_dx)
{
H5FD_family_dxpl_t *dx = (H5FD_family_dxpl_t*)_dx;
FUNC_ENTER(H5FD_family_dxpl_free, FAIL);
H5Pclose(dx->memb_dxpl_id);
free(dx);
return 0;
H5MM_xfree(dx);
FUNC_LEAVE(SUCCEED);
}
@ -370,63 +417,72 @@ H5FD_family_open(const char *name, unsigned flags, hid_t fapl_id,
haddr_t maxaddr)
{
H5FD_family_t *file=NULL;
H5FD_t *ret_value=NULL;
char memb_name[4096], temp[4096];
hsize_t eof;
unsigned t_flags = flags & ~H5F_ACC_CREAT;
FUNC_ENTER(H5FD_family_open, NULL);
/* Check arguments */
if (!name || !*name) return NULL;
if (0==maxaddr || HADDR_UNDEF==maxaddr) return NULL;
if (!name || !*name)
HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid file name");
if (0==maxaddr || HADDR_UNDEF==maxaddr)
HRETURN_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "bogus maxaddr");
/* Initialize file from file access properties */
if (NULL==(file=calloc(1, sizeof(H5FD_family_t)))) return NULL;
if (NULL==(file=H5MM_calloc(sizeof(H5FD_family_t))))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate file struct");
if (H5P_DEFAULT==fapl_id) {
file->memb_fapl_id = H5P_DEFAULT;
file->memb_size = 1024*1024*1024; /*1GB*/
file->memb_fapl_id = H5P_DEFAULT;
file->memb_size = 1024*1024*1024; /*1GB*/
} else {
H5FD_family_fapl_t *fa = H5Pget_driver_info(fapl_id);
file->memb_fapl_id = H5Pcopy(fa->memb_fapl_id);
file->memb_size = fa->memb_size;
H5FD_family_fapl_t *fa = H5Pget_driver_info(fapl_id);
file->memb_fapl_id = H5Pcopy(fa->memb_fapl_id);
file->memb_size = fa->memb_size;
}
file->name = malloc(strlen(name)+1);
strcpy(file->name, name);
file->name = H5MM_strdup(name);
file->flags = flags;
/* Check that names are unique */
sprintf(memb_name, name, 0);
sprintf(temp, name, 1);
if (!strcmp(memb_name, temp)) return NULL;
if (!strcmp(memb_name, temp))
HGOTO_ERROR(H5E_FILE, H5E_FILEEXISTS, NULL, "file names not unique");
/* Open all the family members */
while (1) {
sprintf(memb_name, name, file->nmembs);
sprintf(memb_name, name, file->nmembs);
/* Enlarge member array */
if (file->nmembs>=file->amembs) {
int n = MAX(64, 2*file->amembs);
H5FD_t **x = realloc(file->memb, n*sizeof(H5FD_t*));
if (!x) goto error;
file->amembs = n;
file->memb = x;
}
/*
* Attempt to open file. If the first file cannot be opened then fail;
* otherwise an open failure means that we've reached the last member.
* Allow H5F_ACC_CREAT only on the first family member.
*/
H5E_BEGIN_TRY {
file->memb[file->nmembs] = H5FDopen(memb_name,
0==file->nmembs?flags:t_flags,
file->memb_fapl_id,
HADDR_UNDEF);
} H5E_END_TRY;
if (!file->memb[file->nmembs]) {
if (0==file->nmembs) goto error;
H5Eclear();
break;
}
file->nmembs++;
/* Enlarge member array */
if (file->nmembs>=file->amembs) {
int n = MAX(64, 2*file->amembs);
H5FD_t **x = H5MM_realloc(file->memb, n*sizeof(H5FD_t*));
if (!x)
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't reallocate members");
file->amembs = n;
file->memb = x;
}
/*
* Attempt to open file. If the first file cannot be opened then fail;
* otherwise an open failure means that we've reached the last member.
* Allow H5F_ACC_CREAT only on the first family member.
*/
H5E_BEGIN_TRY {
file->memb[file->nmembs] = H5FDopen(memb_name,
0==file->nmembs?flags:t_flags,
file->memb_fapl_id,
HADDR_UNDEF);
} H5E_END_TRY;
if (!file->memb[file->nmembs]) {
if (0==file->nmembs)
HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "can't open member file");
H5Eclear();
break;
}
file->nmembs++;
}
/*
@ -436,21 +492,24 @@ H5FD_family_open(const char *name, unsigned flags, hid_t fapl_id,
*/
if ((eof=H5FDget_eof(file->memb[0]))) file->memb_size = eof;
return (H5FD_t*)file;
ret_value=(H5FD_t *)file;
error:
done:
/* Cleanup and fail */
if (file) {
int i;
for (i=0; i<file->nmembs; i++) {
if (file->memb[i]) H5FDclose(file->memb[i]);
}
if (file->memb) free(file->memb);
H5Pclose(file->memb_fapl_id);
if (file->name) free(file->name);
free(file);
if (ret_value==NULL && file!=NULL) {
int i;
for (i=0; i<file->nmembs; i++)
if (file->memb[i])
H5FDclose(file->memb[i]);
if (file->memb)
H5MM_xfree(file->memb);
H5Pclose(file->memb_fapl_id);
if (file->name)
H5MM_xfree(file->name);
H5MM_xfree(file);
}
return NULL;
FUNC_LEAVE(ret_value);
}
@ -478,24 +537,30 @@ H5FD_family_close(H5FD_t *_file)
H5FD_family_t *file = (H5FD_family_t*)_file;
int i, nerrors=0;
FUNC_ENTER(H5FD_family_close, FAIL);
/* Close as many members as possible */
for (i=0; i<file->nmembs; i++) {
if (file->memb[i]) {
if (H5FDclose(file->memb[i])<0) {
nerrors++;
} else {
file->memb[i] = NULL;
}
}
if (file->memb[i]) {
if (H5FDclose(file->memb[i])<0) {
nerrors++;
} else {
file->memb[i] = NULL;
}
}
}
if (nerrors) return -1;
if (nerrors)
HRETURN_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't close member files");
/* Clean up other stuff */
H5Pclose(file->memb_fapl_id);
free(file->memb);
free(file->name);
free(file);
return 0;
if (file->memb)
H5MM_xfree(file->memb);
if (file->name)
H5MM_xfree(file->name);
H5MM_xfree(file);
FUNC_LEAVE(SUCCEED);
}
@ -522,12 +587,16 @@ H5FD_family_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
{
const H5FD_family_t *f1 = (const H5FD_family_t*)_f1;
const H5FD_family_t *f2 = (const H5FD_family_t*)_f2;
int ret_value=(-2);
FUNC_ENTER(H5FD_family_cmp, -2);
assert(f1->nmembs>=1 && f1->memb[0]);
assert(f2->nmembs>=1 && f2->memb[0]);
ret_value= H5FDcmp(f1->memb[0], f2->memb[0]);
return H5FDcmp(f1->memb[0], f2->memb[0]);
FUNC_LEAVE(ret_value);
}
@ -553,7 +622,10 @@ static haddr_t
H5FD_family_get_eoa(H5FD_t *_file)
{
H5FD_family_t *file = (H5FD_family_t*)_file;
return file->eoa;
FUNC_ENTER(H5FD_family_get_eoa, HADDR_UNDEF);
FUNC_LEAVE(file->eoa);
}
@ -581,41 +653,45 @@ H5FD_family_set_eoa(H5FD_t *_file, haddr_t eoa)
int i;
char memb_name[4096];
FUNC_ENTER(H5FD_family_set_eoa, FAIL);
for (i=0; addr || i<file->nmembs; i++) {
/* Enlarge member array */
if (i>=file->amembs) {
int n = MAX(64, 2*file->amembs);
H5FD_t **x = realloc(file->memb, n*sizeof(H5FD_t*));
if (!x) return -1;
file->amembs = n;
file->memb = x;
file->nmembs = i;
}
/* Enlarge member array */
if (i>=file->amembs) {
int n = MAX(64, 2*file->amembs);
H5FD_t **x = H5MM_realloc(file->memb, n*sizeof(H5FD_t*));
if (!x)
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate memory block");
file->amembs = n;
file->memb = x;
file->nmembs = i;
}
/* Create another file if necessary */
if (i>=file->nmembs || !file->memb[i]) {
file->nmembs = MAX(file->nmembs, i+1);
sprintf(memb_name, file->name, i);
H5E_BEGIN_TRY {
file->memb[i] = H5FDopen(memb_name, file->flags|H5F_ACC_CREAT,
file->memb_fapl_id, file->memb_size);
} H5E_END_TRY;
if (NULL==file->memb[i]) return -1;
}
/* Set the EOA marker for the member */
if (addr>file->memb_size) {
H5FDset_eoa(file->memb[i], file->memb_size);
addr -= file->memb_size;
} else {
H5FDset_eoa(file->memb[i], addr);
addr = 0;
}
/* Create another file if necessary */
if (i>=file->nmembs || !file->memb[i]) {
file->nmembs = MAX(file->nmembs, i+1);
sprintf(memb_name, file->name, i);
H5E_BEGIN_TRY {
file->memb[i] = H5FDopen(memb_name, file->flags|H5F_ACC_CREAT,
file->memb_fapl_id, file->memb_size);
} H5E_END_TRY;
if (NULL==file->memb[i])
HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "can't open member file");
}
/* Set the EOA marker for the member */
if (addr>file->memb_size) {
H5FDset_eoa(file->memb[i], file->memb_size);
addr -= file->memb_size;
} else {
H5FDset_eoa(file->memb[i], addr);
addr = 0;
}
}
file->eoa = eoa;
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -645,14 +721,18 @@ H5FD_family_get_eof(H5FD_t *_file)
haddr_t eof=0;
int i;
FUNC_ENTER(H5FD_family_get_eof, HADDR_UNDEF);
/*
* Find the last member that has a non-zero EOF and break out of the loop
* with `i' equal to that member. If all members have zero EOF then exit
* loop with i==0.
*/
for (i=file->nmembs-1; i>=0; --i) {
if ((eof=H5FDget_eof(file->memb[i]))) break;
if (0==i) break;
if ((eof=H5FDget_eof(file->memb[i])))
break;
if (0==i)
break;
}
/*
@ -660,7 +740,8 @@ H5FD_family_get_eof(H5FD_t *_file)
* size of the i'th member.
*/
eof += i*file->memb_size;
return MAX(eof, file->eoa);
FUNC_LEAVE(MAX(eof, file->eoa));
}
@ -694,34 +775,36 @@ H5FD_family_read(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
haddr_t sub;
hsize_t req;
FUNC_ENTER(H5FD_family_read, FAIL);
/*
* Get the member data transfer property list. If the transfer property
* list does not belong to this driver then assume defaults
*/
if (H5P_DEFAULT!=dxpl_id && H5FD_FAMILY==H5Pget_driver(dxpl_id)) {
H5FD_family_dxpl_t *dx = H5Pget_driver_info(dxpl_id);
assert(H5P_DATA_XFER==H5Pget_class(dxpl_id));
assert(dx);
memb_dxpl_id = dx->memb_dxpl_id;
H5FD_family_dxpl_t *dx = H5Pget_driver_info(dxpl_id);
assert(H5P_DATA_XFER==H5Pget_class(dxpl_id));
assert(dx);
memb_dxpl_id = dx->memb_dxpl_id;
}
/* Read from each member */
while (size>0) {
i = addr / file->memb_size;
sub = addr % file->memb_size;
req = MIN(size, file->memb_size-sub);
assert(i<file->nmembs);
i = addr / file->memb_size;
sub = addr % file->memb_size;
req = MIN(size, file->memb_size-sub);
assert(i<file->nmembs);
if (H5FDread(file->memb[i], memb_dxpl_id, sub, req, buf)<0) {
return -1;
}
if (H5FDread(file->memb[i], memb_dxpl_id, sub, req, buf)<0)
HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL, "member file read failed");
addr += req;
buf += req;
size -= req;
addr += req;
buf += req;
size -= req;
}
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -754,34 +837,36 @@ H5FD_family_write(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
haddr_t sub;
hsize_t req;
FUNC_ENTER(H5FD_family_write, FAIL);
/*
* Get the member data transfer property list. If the transfer property
* list does not belong to this driver then assume defaults.
*/
if (H5P_DEFAULT!=dxpl_id && H5FD_FAMILY==H5Pget_driver(dxpl_id)) {
H5FD_family_dxpl_t *dx = H5Pget_driver_info(dxpl_id);
assert(H5P_DATA_XFER==H5Pget_class(dxpl_id));
assert(dx);
memb_dxpl_id = dx->memb_dxpl_id;
H5FD_family_dxpl_t *dx = H5Pget_driver_info(dxpl_id);
assert(H5P_DATA_XFER==H5Pget_class(dxpl_id));
assert(dx);
memb_dxpl_id = dx->memb_dxpl_id;
}
/* Write to each member */
while (size>0) {
i = addr / file->memb_size;
sub = addr % file->memb_size;
req = MIN(size, file->memb_size-sub);
assert(i<file->nmembs);
i = addr / file->memb_size;
sub = addr % file->memb_size;
req = MIN(size, file->memb_size-sub);
assert(i<file->nmembs);
if (H5FDwrite(file->memb[i], memb_dxpl_id, sub, req, buf)<0) {
return -1;
}
if (H5FDwrite(file->memb[i], memb_dxpl_id, sub, req, buf)<0)
HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "member file write failed");
addr += req;
buf += req;
size -= req;
addr += req;
buf += req;
size -= req;
}
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -807,11 +892,14 @@ H5FD_family_flush(H5FD_t *_file)
H5FD_family_t *file = (H5FD_family_t*)_file;
int i, nerrors=0;
for (i=0; i<file->nmembs; i++) {
if (file->memb[i] && H5FDflush(file->memb[i])<0) {
nerrors++;
}
}
FUNC_ENTER(H5FD_family_flush, FAIL);
return nerrors?-1:0;
for (i=0; i<file->nmembs; i++)
if (file->memb[i] && H5FDflush(file->memb[i])<0)
nerrors++;
if (nerrors)
HRETURN_ERROR(H5E_IO, H5E_BADVALUE, FAIL, "can't flush member files");
FUNC_LEAVE(SUCCEED);
}

219
src/H5FDgass.c
View File

@ -8,16 +8,13 @@
* Purpose: This is the GASS I/O driver.
*
*/
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <hdf5.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>
#include <H5private.h> /*library functions */
#include <H5Eprivate.h> /*error handling */
#include <H5Fprivate.h> /*files */
#include <H5FDgass.h> /* Core file driver */
#include <H5MMprivate.h> /* Memory allocation */
#include <H5Pprivate.h> /*property lists */
/* Packages needed by this file.*/
#include <H5Eprivate.h>
#undef MAX
#define MAX(X,Y) ((X)>(Y)?(X):(Y))
@ -144,7 +141,12 @@ static const H5FD_class_t H5FD_gass_g = {
H5FD_FLMAP_SINGLE, /*fl_map */
};
/* Interface initialization */
#define PABLO_MASK H5FD_gass_mask
#define INTERFACE_INIT H5FD_gass_init
static intn interface_initialize_g = 0;
/*-------------------------------------------------------------------------
* Function: H5FD_gass_init
*
@ -165,13 +167,15 @@ static const H5FD_class_t H5FD_gass_g = {
hid_t
H5FD_gass_init(void)
{
if (!H5FD_GASS_g) {
H5FD_GASS_g = H5FDregister(&H5FD_gass_g);
}
FUNC_ENTER(H5FD_gass_init, FAIL);
if (!H5FD_GASS_g)
H5FD_GASS_g = H5FDregister(&H5FD_gass_g);
globus_module_activate (GLOBUS_COMMON_MODULE);
globus_module_activate (GLOBUS_GASS_FILE_MODULE);
return H5FD_GASS_g;
FUNC_LEAVE(H5FD_GASS_g);
}
@ -203,19 +207,25 @@ H5FD_gass_init(void)
herr_t
H5Pset_fapl_gass(hid_t fapl_id, GASS_Info info)
{
herr_t ret_value=FAIL;
H5FD_gass_fapl_t fa;
/*NO TRACE*/
FUNC_ENTER(H5FD_set_fapl_gass, FAIL);
/* Check arguments */
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a fapl");
#ifdef LATER
#warning "We need to verify that INFO contain sensible information."
#endif
/* Initialize driver specific properties */
fa.info = info;
return H5Pset_driver(fapl_id, H5FD_GASS, &fa);
ret_value= H5Pset_driver(fapl_id, H5FD_GASS, &fa);
FUNC_LEAVE(ret_value);
}
@ -247,13 +257,19 @@ H5Pget_fapl_gass(hid_t fapl_id, GASS_Info *info/*out*/)
H5FD_gass_fapl_t *fa;
/*NO TRACE*/
FUNC_ENTER(H5Pget_fapl_gass, FAIL);
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
if (H5FD_GASS!=H5Pget_driver(fapl_id)) return -1;
if (NULL==(fa=H5Pget_driver_info(fapl_id))) return -1;
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a fapl");
if (H5FD_GASS!=H5Pget_driver(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "incorrect VFL driver");
if (NULL==(fa=H5Pget_driver_info(fapl_id)))
HRETURN_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "bad VFL driver info");
if (info) *info = fa->info;
return 0;
if (info)
*info = fa->info;
FUNC_LEAVE(SUCCEED);
}
@ -289,28 +305,33 @@ H5FD_gass_open(const char *name, unsigned flags, hid_t fapl_id,
H5FD_gass_t *file=NULL;
const H5FD_gass_fapl_t *fa=NULL;
H5FD_gass_fapl_t _fa;
char *filename = (char *) malloc(80 * sizeof(char));
char *filename = (char *) H5MM_malloc(80 * sizeof(char));
FUNC_ENTER(H5FD_gass_open, NULL);
/* fprintf(stdout, "Entering H5FD_gass_open name=%s flags=0x%x\n", name, flags); */
/* Check arguments */
if (!name || !*name)
HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid file name");
if (0==maxaddr || HADDR_UNDEF==maxaddr)
HRETURN_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "bogus maxaddr");
if (ADDR_OVERFLOW(maxaddr))
HRETURN_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "bogus maxaddr");
strcpy (filename, name);
/* Obtain a pointer to gass-specific file access properties */
if (H5P_DEFAULT==fapl_id || H5FD_GASS!=H5Pget_driver(fapl_id)) {
GASS_INFO_NULL (_fa.info);
/* _fa.info = GASS_INFO_NULL; */
/* _fa.info = {0,0}; */ /*default*/
fa = &_fa;
GASS_INFO_NULL (_fa.info);
/* _fa.info = GASS_INFO_NULL; */
/* _fa.info = {0,0}; */ /*default*/
fa = &_fa;
} else {
fa = H5Pget_driver_info(fapl_id);
assert(fa);
fa = H5Pget_driver_info(fapl_id);
assert(fa);
}
/* Check arguments */
if (!name || !*name) return NULL;
if (0==maxaddr || HADDR_UNDEF==maxaddr) return NULL;
if (ADDR_OVERFLOW(maxaddr)) return NULL;
/* When I come down here, the possible flag values and the correct
responses are given here :-
@ -333,62 +354,48 @@ H5FD_gass_open(const char *name, unsigned flags, hid_t fapl_id,
/* fprintf (stderr, "flags=0x%x\n", flags); */
if ((flags & H5F_ACC_CREAT) && (flags & H5F_ACC_RDWR) && (flags & H5F_ACC_EXCL)) {
if ((fd = globus_gass_open (filename, O_RDWR|O_TRUNC)) < 0) {
/* HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, FAIL, "open failed"); */
fprintf (stderr, "Can't open file. \n");
return NULL;
}
if ((fd = globus_gass_open (filename, O_RDWR|O_TRUNC)) < 0)
HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, FAIL, "open failed");
}
else if ((flags & H5F_ACC_CREAT) && (flags & H5F_ACC_RDWR) && (flags & H5F_ACC_TRUNC)) {
if ((fd = globus_gass_open (filename, O_RDWR|O_TRUNC)) < 0) {
/* HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, NULL, "open failed"); */
fprintf (stderr, "Can't open file. \n");
return NULL;
}
if ((fd = globus_gass_open (filename, O_RDWR|O_TRUNC)) < 0)
HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, NULL, "open failed");
}
else if ((flags & H5F_ACC_RDWR) && (flags & H5F_ACC_TRUNC)) {
if ((fd = globus_gass_open (filename, O_RDWR|O_TRUNC)) < 0) {
/* HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, NULL, "open failed"); */
fprintf (stderr, "Can't open file. \n");
return NULL;
}
if ((fd = globus_gass_open (filename, O_RDWR|O_TRUNC)) < 0)
HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, NULL, "open failed");
}
else if (flags & H5F_ACC_RDWR) {
printf ("I'm here in H5FDgass_open going to call globus_gass_open with O_RDWR. \n");
printf ("Name of URL =%s \n", filename);
if ((fd = globus_gass_open (filename, O_RDWR)) < 0) {
/* HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, NULL, "open failed"); */
fprintf (stderr, "Can't open file. \n");
return NULL;
}
if ((fd = globus_gass_open (filename, O_RDWR)) < 0)
HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, NULL, "open failed");
}
else { /* This is case where H5F_ACC_RDWR is not set */
if ((fd = globus_gass_open (filename, O_RDONLY)) < 0) {
/* HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, NULL, "open failed");*/
fprintf (stderr, "Can't open file. \n");
return NULL;
}
if ((fd = globus_gass_open (filename, O_RDONLY)) < 0)
HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, NULL, "open failed");
}
if (fstat(fd, &sb)<0) {
close(fd);
return NULL;
close(fd);
HRETURN_ERROR(H5E_IO, H5E_BADFILE, NULL, "fstat failed");
}
/* Create the new file struct */
file = calloc(1, sizeof(H5FD_gass_t));
if (NULL==(file=H5MM_calloc(sizeof(H5FD_gass_t))))
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate file struct");
file->fd = fd;
file->eof = sb.st_size;
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
file->info = fa->info;
return (H5FD_t*)file;
FUNC_LEAVE((H5FD_t*)file);
}
/*-------------------------------------------------------------------------
@ -410,20 +417,19 @@ H5FD_gass_open(const char *name, unsigned flags, hid_t fapl_id,
static herr_t
H5FD_gass_close (H5FD_t *_file)
{
int gasserr;
H5FD_gass_t *file = (H5FD_gass_t *)_file;
H5FD_gass_t *file = (H5FD_gass_t *)_file;
if (file == NULL) {
/* HRETURN_ERROR(H5E_IO, H5E_CANTCLOSEFILE, NULL, "close failed"); */
fprintf (stderr, "Can't close file. \n");
return -1;
}
FUNC_ENTER(H5FD_gass_close, FAIL);
if (file == NULL)
HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file handle");
gasserr = globus_gass_close (file->fd);
if (gasserr == -1)
fprintf (stderr, "GASS close failed. \n");
if (globus_gass_close (file->fd) < 0)
HRETURN_ERROR(H5E_IO, H5E_CANTCLOSEFILE, FAIL, "can't close GASS file");
return gasserr;
H5MM_xfree(file);
FUNC_LEAVE(SUCCEED);
}
@ -449,7 +455,10 @@ static haddr_t
H5FD_gass_get_eoa(H5FD_t *_file)
{
H5FD_gass_t *file = (H5FD_gass_t *)_file;
return file->eoa;
FUNC_ENTER(H5FD_gass_get_eoa, HADDR_UNDEF);
FUNC_LEAVE(file->eoa);
}
@ -473,8 +482,12 @@ static herr_t
H5FD_gass_set_eoa(H5FD_t *_file, haddr_t addr)
{
H5FD_gass_t *file = (H5FD_gass_t *)_file;
FUNC_ENTER(H5FD_gass_set_eoa, FAIL);
file->eoa = addr;
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -502,7 +515,10 @@ static haddr_t
H5FD_gass_get_eof(H5FD_t *_file)
{
H5FD_gass_t *file = (H5FD_gass_t*)_file;
return MAX(file->eof, file->eoa);
FUNC_ENTER(H5FD_gass_get_eof, HADDR_UNDEF);
FUNC_LEAVE(MAX(file->eof, file->eoa));
}
/*-------------------------------------------------------------------------
@ -530,20 +546,25 @@ H5FD_gass_read(H5FD_t *_file, hid_t dxpl_id/*unused*/, haddr_t addr,
H5FD_gass_t *file = (H5FD_gass_t*)_file;
ssize_t nbytes;
FUNC_ENTER(H5FD_gass_read, FAIL);
assert(file && file->pub.cls);
assert(buf);
/* Check for overflow conditions */
if (HADDR_UNDEF==addr) return -1;
if (REGION_OVERFLOW(addr, size)) return -1;
if (addr+size>file->eoa) return -1;
if (HADDR_UNDEF==addr)
HRETURN_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "addr undefined");
if (REGION_OVERFLOW(addr, size))
HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr too large");
if (addr+size>file->eoa)
HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr too large");
/* Seek to the correct location */
if ((addr!=file->pos || OP_READ!=file->op) &&
file_seek(file->fd, (file_offset_t)addr, SEEK_SET)<0) {
file_seek(file->fd, (file_offset_t)addr, SEEK_SET)<0) {
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
return -1;
HRETURN_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "gass file seek failed");
}
/*
@ -551,13 +572,15 @@ H5FD_gass_read(H5FD_t *_file, hid_t dxpl_id/*unused*/, haddr_t addr,
* and the end of the file.
*/
while (size>0) {
do nbytes = read(file->fd, buf, size);
do
nbytes = read(file->fd, buf, size);
while (-1==nbytes && EINTR==errno);
if (-1==nbytes) {
/* error */
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
return -1;
HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL, "gass file read failed");
}
if (0==nbytes) {
/* end of file but not end of format address space */
@ -574,7 +597,7 @@ do nbytes = read(file->fd, buf, size);
/* Update current position */
file->pos = addr;
file->op = OP_READ;
return 0;
FUNC_LEAVE(SUCCEED);
}
/*-------------------------------------------------------------------------
@ -601,20 +624,25 @@ H5FD_gass_write(H5FD_t *_file, hid_t dxpl_id/*unused*/, haddr_t addr,
H5FD_gass_t *file = (H5FD_gass_t*)_file;
ssize_t nbytes;
FUNC_ENTER(H5FD_gass_write, FAIL);
assert(file && file->pub.cls);
assert(buf);
/* Check for overflow conditions */
if (HADDR_UNDEF==addr) return -1;
if (REGION_OVERFLOW(addr, size)) return -1;
if (addr+size>file->eoa) return -1;
if (HADDR_UNDEF==addr)
HRETURN_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "addr undefined");
if (REGION_OVERFLOW(addr, size))
HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr too large");
if (addr+size>file->eoa)
HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr too large");
/* Seek to the correct location */
if ((addr!=file->pos || OP_WRITE!=file->op) &&
file_seek(file->fd, (file_offset_t)addr, SEEK_SET)<0) {
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
return -1;
HRETURN_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "gass file seek failed");
}
/*
@ -622,13 +650,15 @@ H5FD_gass_write(H5FD_t *_file, hid_t dxpl_id/*unused*/, haddr_t addr,
* results
*/
while (size>0) {
do nbytes = write(file->fd, buf, size);
do
nbytes = write(file->fd, buf, size);
while (-1==nbytes && EINTR==errno);
if (-1==nbytes) {
if (-1==nbytes) {
/* error */
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
return -1;
HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "gass file write failed");
}
assert(nbytes>0);
assert((hsize_t)nbytes<=size);
@ -640,9 +670,10 @@ if (-1==nbytes) {
/* Update current position and eof */
file->pos = addr;
file->op = OP_WRITE;
if (file->pos>file->eof) file->eof = file->pos;
if (file->pos>file->eof)
file->eof = file->pos;
return 0;
FUNC_LEAVE(SUCCEED);
}
#endif
#endif /* HAVE_GASS */

441
src/H5FDmpio.c
View File

@ -20,9 +20,12 @@
* bytes read is always equal to the number requested. This
* kluge is activated by #ifdef MPI_KLUGE0202.
*/
#include <assert.h>
#include <hdf5.h>
#include <stdlib.h>
#include <H5private.h> /*library functions */
#include <H5Eprivate.h> /*error handling */
#include <H5Fprivate.h> /*files */
#include <H5FDmpio.h> /* MPI I/O file driver */
#include <H5MMprivate.h> /* Memory allocation */
#include <H5Pprivate.h> /*property lists */
/*
* The driver identification number, initialized at runtime if HAVE_PARALLEL
@ -143,6 +146,11 @@ hbool_t H5_mpi_1_metawrite_g = TRUE;
hbool_t H5_mpi_1_metawrite_g = FALSE;
#endif
/* Interface initialization */
#define PABLO_MASK H5FD_mpio_mask
#define INTERFACE_INIT H5FD_mpio_init
static intn interface_initialize_g = 0;
/*-------------------------------------------------------------------------
* Function: H5FD_mpio_init
@ -164,10 +172,12 @@ hbool_t H5_mpi_1_metawrite_g = FALSE;
hid_t
H5FD_mpio_init(void)
{
if (H5I_VFL!=H5Iget_type(H5FD_MPIO_g)) {
H5FD_MPIO_g = H5FDregister(&H5FD_mpio_g);
}
return H5FD_MPIO_g;
FUNC_ENTER(H5FD_mpio_init, FAIL);
if (H5I_VFL!=H5Iget_type(H5FD_MPIO_g))
H5FD_MPIO_g = H5FDregister(&H5FD_mpio_g);
FUNC_LEAVE(H5FD_MPIO_g);
}
@ -222,12 +232,15 @@ H5FD_mpio_init(void)
herr_t
H5Pset_fapl_mpio(hid_t fapl_id, MPI_Comm comm, MPI_Info info)
{
herr_t ret_value=FAIL;
H5FD_mpio_fapl_t fa;
/*NO TRACE*/
FUNC_ENTER(H5FD_set_fapl_mpio, FAIL);
/* Check arguments */
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a fapl");
#ifdef LATER
#warning "We need to verify that COMM and INFO contain sensible information."
#endif
@ -235,7 +248,10 @@ H5Pset_fapl_mpio(hid_t fapl_id, MPI_Comm comm, MPI_Info info)
/* Initialize driver specific properties */
fa.comm = comm;
fa.info = info;
return H5Pset_driver(fapl_id, H5FD_MPIO, &fa);
ret_value= H5Pset_driver(fapl_id, H5FD_MPIO, &fa);
FUNC_LEAVE(ret_value);
}
@ -273,14 +289,19 @@ H5Pget_fapl_mpio(hid_t fapl_id, MPI_Comm *comm/*out*/, MPI_Info *info/*out*/)
H5FD_mpio_fapl_t *fa;
/*NO TRACE*/
FUNC_ENTER(H5Pget_fapl_mpio, FAIL);
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
if (H5FD_MPIO!=H5Pget_driver(fapl_id)) return -1;
if (NULL==(fa=H5Pget_driver_info(fapl_id))) return -1;
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a fapl");
if (H5FD_MPIO!=H5Pget_driver(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "incorrect VFL driver");
if (NULL==(fa=H5Pget_driver_info(fapl_id)))
HRETURN_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "bad VFL driver info");
if (comm) *comm = fa->comm;
if (info) *info = fa->info;
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -313,18 +334,25 @@ H5Pget_fapl_mpio(hid_t fapl_id, MPI_Comm *comm/*out*/, MPI_Info *info/*out*/)
herr_t
H5Pset_dxpl_mpio(hid_t dxpl_id, H5FD_mpio_xfer_t xfer_mode)
{
herr_t ret_value=FAIL;
H5FD_mpio_dxpl_t dx;
/*NO TRACE*/
FUNC_ENTER(H5Pset_dxpl_mpio, FAIL);
/* Check arguments */
if (H5P_DATA_XFER!=H5Pget_class(dxpl_id)) return -1;
if (H5P_DATA_XFER!=H5Pget_class(dxpl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a dxpl");
if (H5FD_MPIO_INDEPENDENT!=xfer_mode &&
H5FD_MPIO_COLLECTIVE!=xfer_mode) return -1;
H5FD_MPIO_COLLECTIVE!=xfer_mode) return -1;
HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "incorrect xfer_mode");
/* Initialize driver-specific properties */
dx.xfer_mode = xfer_mode;
return H5Pset_driver(dxpl_id, H5FD_MPIO, &dx);
ret_value= H5Pset_driver(dxpl_id, H5FD_MPIO, &dx);
FUNC_LEAVE(ret_value);
}
@ -354,13 +382,19 @@ H5Pget_dxpl_mpio(hid_t dxpl_id, H5FD_mpio_xfer_t *xfer_mode/*out*/)
H5FD_mpio_dxpl_t *dx;
/*NO TRACE*/
if (H5P_DATA_XFER!=H5Pget_class(dxpl_id)) return -1;
if (H5FD_MPIO!=H5Pget_driver(dxpl_id)) return -1;
if (NULL==(dx=H5Pget_driver_info(dxpl_id))) return -1;
FUNC_ENTER(H5Pget_dxpl_mpio, FAIL);
if (xfer_mode) *xfer_mode = dx->xfer_mode;
return 0;
if (H5P_DATA_XFER!=H5Pget_class(dxpl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a dxpl");
if (H5FD_MPIO!=H5Pget_driver(dxpl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "incorrect VFL driver");
if (NULL==(dx=H5Pget_driver_info(dxpl_id)))
HRETURN_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "bad VFL driver info");
if (xfer_mode)
*xfer_mode = dx->xfer_mode;
FUNC_LEAVE(SUCCEED);
}
@ -385,6 +419,8 @@ H5FD_mpio_tas_allsame(H5FD_t *_file, hbool_t newval)
H5FD_mpio_t *file = (H5FD_mpio_t*)_file;
hbool_t oldval;
FUNC_ENTER(H5FD_mpio_tas_allsame, FAIL);
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'t'])
fprintf(stdout, "Entering H5FD_mpio_tas_allsame, newval=%d\n", newval);
@ -399,7 +435,7 @@ H5FD_mpio_tas_allsame(H5FD_t *_file, hbool_t newval)
fprintf(stdout, "Leaving H5FD_mpio_tas_allsame, oldval=%d\n", oldval);
#endif
return oldval;
FUNC_LEAVE(oldval);
}
@ -423,7 +459,10 @@ MPI_Comm
H5FD_mpio_communicator(H5FD_t *_file)
{
H5FD_mpio_t *file = (H5FD_mpio_t*)_file;
return file->comm;
FUNC_ENTER(H5FD_mpio_communicator, NULL);
FUNC_LEAVE(file->comm);
}
@ -453,11 +492,14 @@ H5FD_mpio_setup(H5FD_t *_file, MPI_Datatype btype, MPI_Datatype ftype,
{
H5FD_mpio_t *file = (H5FD_mpio_t*)_file;
FUNC_ENTER(H5FD_mpio_setup, FAIL);
file->btype = btype;
file->ftype = ftype;
file->disp = disp;
file->use_types = use_types;
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -493,20 +535,21 @@ H5FD_mpio_wait_for_left_neighbor(H5FD_t *_file)
H5FD_mpio_t *file = (H5FD_mpio_t*)_file;
MPI_Comm comm = file->comm;
char msgbuf[1];
int myid, mpi_err;
int myid;
MPI_Status rcvstat;
mpi_err = MPI_Comm_rank(comm, &myid);
if (MPI_SUCCESS!=mpi_err) return -1;
FUNC_ENTER(H5FD_mpio_wait_for_left_neighbor, FAIL);
if (MPI_SUCCESS!= MPI_Comm_rank(comm, &myid))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_Comm_rank failed");
/* p0 has no left neighbor; all other procs wait for msg */
if (myid != 0) {
mpi_err = MPI_Recv( &msgbuf, 1, MPI_CHAR, myid-1, MPI_ANY_TAG, comm,
&rcvstat );
if (MPI_SUCCESS!=mpi_err) return -1;
if (MPI_SUCCESS!= MPI_Recv( &msgbuf, 1, MPI_CHAR, myid-1, MPI_ANY_TAG, comm, &rcvstat ))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_Recv failed");
}
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -542,17 +585,19 @@ H5FD_mpio_signal_right_neighbor(H5FD_t *_file)
H5FD_mpio_t *file = (H5FD_mpio_t*)_file;
MPI_Comm comm = file->comm;
char msgbuf[1];
int myid, numprocs, mpi_err;
int myid, numprocs;
mpi_err = MPI_Comm_size( comm, &numprocs );
if (MPI_SUCCESS!=mpi_err) return -1;
mpi_err = MPI_Comm_rank( comm, &myid );
if (MPI_SUCCESS!=mpi_err) return -1;
FUNC_ENTER(H5FD_mpio_signal_right_neighbor, FAIL);
if (MPI_SUCCESS!= MPI_Comm_size( comm, &numprocs ))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_Comm_size failed");
if (MPI_SUCCESS!= MPI_Comm_rank( comm, &myid ))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_Comm_rank failed");
if (myid != (numprocs-1)) {
mpi_err = MPI_Send(&msgbuf, 0/*empty msg*/, MPI_CHAR, myid+1, 0, comm);
if (MPI_SUCCESS!=mpi_err) return -1;
if (MPI_SUCCESS!= MPI_Send(&msgbuf, 0/*empty msg*/, MPI_CHAR, myid+1, 0, comm))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_Send failed");
}
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -578,12 +623,18 @@ static void *
H5FD_mpio_fapl_get(H5FD_t *_file)
{
H5FD_mpio_t *file = (H5FD_mpio_t*)_file;
H5FD_mpio_fapl_t *fa = calloc(1, sizeof(H5FD_mpio_fapl_t));
H5FD_mpio_fapl_t *fa = NULL;
FUNC_ENTER(H5FD_mpio_fapl_get, NULL);
if (NULL==(fa=H5MM_calloc(sizeof(H5FD_mpio_fapl_t))))
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
/* These should both be copied. --rpm, 1999-08-13 */
fa->comm = file->comm;
fa->info = file->info;
return fa;
FUNC_LEAVE(fa);
}
@ -636,6 +687,8 @@ H5FD_mpio_open(const char *name, unsigned flags, hid_t fapl_id,
const H5FD_mpio_fapl_t *fa=NULL;
H5FD_mpio_fapl_t _fa;
FUNC_ENTER(H5FD_mpio_open, NULL);
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'t']) {
fprintf(stdout, "Entering H5FD_mpio_open(name=\"%s\", flags=0x%x, "
@ -645,19 +698,21 @@ H5FD_mpio_open(const char *name, unsigned flags, hid_t fapl_id,
/* Obtain a pointer to mpio-specific file access properties */
if (H5P_DEFAULT==fapl_id || H5FD_MPIO!=H5Pget_driver(fapl_id)) {
_fa.comm = MPI_COMM_SELF; /*default*/
_fa.info = MPI_INFO_NULL; /*default*/
fa = &_fa;
_fa.comm = MPI_COMM_SELF; /*default*/
_fa.info = MPI_INFO_NULL; /*default*/
fa = &_fa;
} else {
fa = H5Pget_driver_info(fapl_id);
assert(fa);
fa = H5Pget_driver_info(fapl_id);
assert(fa);
}
/* convert HDF5 flags to MPI-IO flags */
/* some combinations are illegal; let MPI-IO figure it out */
mpi_amode = (flags&H5F_ACC_RDWR) ? MPI_MODE_RDWR : MPI_MODE_RDONLY;
if (flags&H5F_ACC_CREAT) mpi_amode |= MPI_MODE_CREATE;
if (flags&H5F_ACC_EXCL) mpi_amode |= MPI_MODE_EXCL;
if (flags&H5F_ACC_CREAT)
mpi_amode |= MPI_MODE_CREATE;
if (flags&H5F_ACC_EXCL)
mpi_amode |= MPI_MODE_EXCL;
#ifdef H5FDmpio_DEBUG
{
@ -692,27 +747,26 @@ H5FD_mpio_open(const char *name, unsigned flags, hid_t fapl_id,
#endif
/*OKAY: CAST DISCARDS CONST*/
mpierr = MPI_File_open(fa->comm, (char*)name, mpi_amode, fa->info, &fh);
if (MPI_SUCCESS != mpierr) return NULL;
if (MPI_SUCCESS != MPI_File_open(fa->comm, (char*)name, mpi_amode, fa->info, &fh))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, NULL, "MPI_File_open failed");
/* truncate the file, if requested */
if (flags & H5F_ACC_TRUNC) {
mpierr = MPI_File_set_size(fh, (MPI_Offset)0);
if (MPI_SUCCESS != mpierr) {
MPI_File_close(&fh);
return NULL;
}
if (MPI_SUCCESS != MPI_File_set_size(fh, (MPI_Offset)0)) {
MPI_File_close(&fh);
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, NULL, "MPI_File_set_size failed");
}
/* Don't let any proc return until all have truncated the file. */
mpierr = MPI_Barrier(fa->comm);
if (MPI_SUCCESS!=mpierr) {
MPI_File_close(&fh);
return NULL;
}
/* Don't let any proc return until all have truncated the file. */
if (MPI_SUCCESS!= MPI_Barrier(fa->comm)) {
MPI_File_close(&fh);
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, NULL, "MPI_Barrier failed");
}
}
/* Build the return value and initialize it */
if (NULL==(file=calloc(1, sizeof(H5FD_mpio_t)))) return NULL;
if (NULL==(file=H5MM_calloc(sizeof(H5FD_mpio_t))))
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
file->f = fh;
file->comm = fa->comm;
file->info = fa->info;
@ -720,11 +774,10 @@ H5FD_mpio_open(const char *name, unsigned flags, hid_t fapl_id,
file->ftype = MPI_DATATYPE_NULL;
/* Get current file size */
mpierr = MPI_File_get_size(fh, &size);
if (MPI_SUCCESS != mpierr) {
free(file);
MPI_File_close(&fh);
return NULL;
if (MPI_SUCCESS != MPI_File_get_size(fh, &size)) {
H5MM_xfree(file);
MPI_File_close(&fh);
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, NULL, "MPI_File_get_size failed");
}
file->eof = MPIOff_to_haddr(size);
@ -734,7 +787,7 @@ H5FD_mpio_open(const char *name, unsigned flags, hid_t fapl_id,
}
#endif
return (H5FD_t*)file;
FUNC_LEAVE((H5FD_t*)file);
}
@ -762,7 +815,8 @@ static herr_t
H5FD_mpio_close(H5FD_t *_file)
{
H5FD_mpio_t *file = (H5FD_mpio_t*)_file;
int mpierr;
FUNC_ENTER(H5FD_mpio_close, FAIL);
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'t'])
@ -770,15 +824,18 @@ H5FD_mpio_close(H5FD_t *_file)
#endif
/* MPI_File_close sets argument to MPI_FILE_NULL */
mpierr = MPI_File_close(&(file->f)/*in,out*/);
if (MPI_SUCCESS != mpierr) return -1;
if (MPI_SUCCESS != MPI_File_close(&(file->f)/*in,out*/))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_File_close failed");
/* Clean up other stuff */
H5MM_xfree(file);
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'t'])
fprintf(stdout, "Leaving H5FD_mpio_close\n");
#endif
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -804,7 +861,10 @@ static haddr_t
H5FD_mpio_get_eoa(H5FD_t *_file)
{
H5FD_mpio_t *file = (H5FD_mpio_t*)_file;
return file->eoa;
FUNC_ENTER(H5FD_mpio_get_eoa, HADDR_UNDEF);
FUNC_LEAVE(file->eoa);
}
@ -830,8 +890,12 @@ static herr_t
H5FD_mpio_set_eoa(H5FD_t *_file, haddr_t addr)
{
H5FD_mpio_t *file = (H5FD_mpio_t*)_file;
FUNC_ENTER(H5FD_mpio_set_eoa, FAIL);
file->eoa = addr;
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -864,7 +928,10 @@ static haddr_t
H5FD_mpio_get_eof(H5FD_t *_file)
{
H5FD_mpio_t *file = (H5FD_mpio_t*)_file;
return file->eof;
FUNC_ENTER(H5FD_mpio_get_eof, HADDR_UNDEF);
FUNC_LEAVE(file->eof);
}
@ -928,15 +995,19 @@ H5FD_mpio_read(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
int mpierr, size_i, bytes_read, n;
int use_types_this_time, used_types_last_time;
FUNC_ENTER(H5FD_mpio_read, FAIL);
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'t'])
fprintf(stdout, "Entering H5FD_mpio_read\n" );
#endif
/* some numeric conversions */
if (haddr_to_MPIOff(addr, &mpi_off/*out*/)<0) return -1;
if (haddr_to_MPIOff(addr, &mpi_off/*out*/)<0)
HRETURN_ERROR(H5E_INTERNAL, H5E_BADRANGE, FAIL, "can't convert from haddr to MPI off");
size_i = (int)size;
if ((size_t)size_i != size) return -1;
if ((size_t)size_i != size)
HRETURN_ERROR(H5E_INTERNAL, H5E_BADRANGE, FAIL, "can't convert from size to size_i");
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'r'])
@ -946,11 +1017,11 @@ H5FD_mpio_read(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
/* Obtain the data transfer properties */
if (H5P_DEFAULT==dxpl_id || H5FD_MPIO!=H5Pget_driver(dxpl_id)) {
_dx.xfer_mode = H5FD_MPIO_INDEPENDENT; /*the default*/
dx = &_dx;
_dx.xfer_mode = H5FD_MPIO_INDEPENDENT; /*the default*/
dx = &_dx;
} else {
dx = H5Pget_driver_info(dxpl_id);
assert(dx);
dx = H5Pget_driver_info(dxpl_id);
assert(dx);
}
/*
@ -961,18 +1032,19 @@ H5FD_mpio_read(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
*/
use_types_this_time = file->use_types;
if (use_types_this_time) {
/* prepare for a full-blown xfer using btype, ftype, and disp */
buf_type = file->btype;
file_type = file->ftype;
if (haddr_to_MPIOff(file->disp, &mpi_disp)<0) return -1;
/* prepare for a full-blown xfer using btype, ftype, and disp */
buf_type = file->btype;
file_type = file->ftype;
if (haddr_to_MPIOff(file->disp, &mpi_disp)<0)
HRETURN_ERROR(H5E_INTERNAL, H5E_BADRANGE, FAIL, "can't convert from haddr to MPI off");
} else {
/*
* Prepare for a simple xfer of a contiguous block of bytes. The
* btype, ftype, and disp fields are not used.
*/
buf_type = MPI_BYTE;
file_type = MPI_BYTE;
mpi_disp = 0; /* mpi_off is sufficient */
/*
* Prepare for a simple xfer of a contiguous block of bytes. The
* btype, ftype, and disp fields are not used.
*/
buf_type = MPI_BYTE;
file_type = MPI_BYTE;
mpi_disp = 0; /* mpi_off is sufficient */
}
/*
@ -981,11 +1053,10 @@ H5FD_mpio_read(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
*/
used_types_last_time = file->old_use_types;
if (used_types_last_time || /* change to new ftype or MPI_BYTE */
use_types_this_time) { /* almost certainly a different ftype */
/*OKAY: CAST DISCARDS CONST QUALIFIER*/
mpierr = MPI_File_set_view(file->f, mpi_disp, MPI_BYTE, file_type,
(char*)"native", file->info);
if (MPI_SUCCESS != mpierr) return -1;
use_types_this_time) { /* almost certainly a different ftype */
/*OKAY: CAST DISCARDS CONST QUALIFIER*/
if (MPI_SUCCESS != MPI_File_set_view(file->f, mpi_disp, MPI_BYTE, file_type, (char*)"native", file->info))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_File_set_view failed");
}
/*
@ -997,25 +1068,22 @@ H5FD_mpio_read(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
file->use_types = 0;
/* Read the data. */
assert(H5FD_MPIO_INDEPENDENT==dx->xfer_mode ||
H5FD_MPIO_COLLECTIVE==dx->xfer_mode);
assert(H5FD_MPIO_INDEPENDENT==dx->xfer_mode || H5FD_MPIO_COLLECTIVE==dx->xfer_mode);
if (H5FD_MPIO_INDEPENDENT==dx->xfer_mode) {
mpierr = MPI_File_read_at(file->f, mpi_off, buf, size_i, buf_type,
&mpi_stat);
if (MPI_SUCCESS!=mpierr) return -1;
if (MPI_SUCCESS!= MPI_File_read_at(file->f, mpi_off, buf, size_i, buf_type, &mpi_stat))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_File_read_at failed");
} else {
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'t'])
fprintf(stdout, "H5FD_mpio_read: using MPIO collective mode\n");
#endif
mpierr = MPI_File_read_at_all(file->f, mpi_off, buf, size_i, buf_type,
&mpi_stat );
if (MPI_SUCCESS!=mpierr) return -1;
if (MPI_SUCCESS!= MPI_File_read_at_all(file->f, mpi_off, buf, size_i, buf_type, &mpi_stat ))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_File_read_at_all failed");
}
/* How many bytes were actually read? */
mpierr = MPI_Get_count(&mpi_stat, MPI_BYTE, &bytes_read);
if (MPI_SUCCESS != mpierr) return -1;
if (MPI_SUCCESS != MPI_Get_count(&mpi_stat, MPI_BYTE, &bytes_read))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_Get_count failed");
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'c'])
fprintf(stdout,
@ -1030,22 +1098,23 @@ H5FD_mpio_read(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
*/
bytes_read = size_i;
#endif
if (bytes_read<0 || bytes_read>size_i) return -1;
if (bytes_read<0 || bytes_read>size_i)
HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL, "file read failed");
/*
* This gives us zeroes beyond end of physical MPI file. What about
* reading past logical end of HDF5 file???
*/
if ((n=(size_i-bytes_read)) > 0) {
if (use_types_this_time) {
/*
* INCOMPLETE rky 1998-09-18
* Haven't implemented reading zeros beyond EOF. What to do???
*/
return -1;
} else {
memset((char*)buf+bytes_read, 0, (size_t)n);
}
if (use_types_this_time) {
/*
* INCOMPLETE rky 1998-09-18
* Haven't implemented reading zeros beyond EOF. What to do???
*/
HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL, "eof file read failed");
} else {
memset((char*)buf+bytes_read, 0, (size_t)n);
}
}
#ifdef NO
@ -1058,7 +1127,7 @@ H5FD_mpio_read(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
fprintf(stdout, "Leaving H5FD_mpio_read\n" );
#endif
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -1151,6 +1220,9 @@ H5FD_mpio_write(H5FD_t *_file, hid_t dxpl_id/*unused*/, haddr_t addr,
int mpi_rank;
int use_types_this_time, used_types_last_time;
hbool_t allsame;
herr_t ret_value=FAIL;
FUNC_ENTER(H5FD_mpio_write, FAIL);
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'t'])
@ -1158,10 +1230,13 @@ H5FD_mpio_write(H5FD_t *_file, hid_t dxpl_id/*unused*/, haddr_t addr,
#endif
/* some numeric conversions */
if (haddr_to_MPIOff(addr, &mpi_off)<0) return -1;
if (haddr_to_MPIOff(file->disp, &mpi_disp)<0) return -1;
if (haddr_to_MPIOff(addr, &mpi_off)<0)
HRETURN_ERROR(H5E_INTERNAL, H5E_BADRANGE, FAIL, "can't convert from haddr to MPI off");
if (haddr_to_MPIOff(file->disp, &mpi_disp)<0)
HRETURN_ERROR(H5E_INTERNAL, H5E_BADRANGE, FAIL, "can't convert from haddr to MPI off");
size_i = (int)size;
if ((size_t)size_i != size) return -1;
if ((size_t)size_i != size)
HRETURN_ERROR(H5E_INTERNAL, H5E_BADRANGE, FAIL, "can't convert from size to size_i");
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'w'])
@ -1172,25 +1247,25 @@ H5FD_mpio_write(H5FD_t *_file, hid_t dxpl_id/*unused*/, haddr_t addr,
/* Only p0 will do the actual write if all procs in comm write same data */
allsame = H5FD_mpio_tas_allsame(_file, FALSE);
if (allsame && H5_mpi_1_metawrite_g) {
mpierr = MPI_Comm_rank(file->comm, &mpi_rank);
if (mpierr != MPI_SUCCESS) return -1;
if (mpi_rank != 0) {
if (MPI_SUCCESS != MPI_Comm_rank(file->comm, &mpi_rank))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_Comm_rank failed");
if (mpi_rank != 0) {
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'w']) {
fprintf(stdout, " in H5FD_mpio_write (write omitted)\n" );
}
if (H5FD_mpio_Debug[(int)'w']) {
fprintf(stdout, " in H5FD_mpio_write (write omitted)\n" );
}
#endif
goto done; /* skip the actual write */
}
HGOTO_DONE(SUCCEED) /* skip the actual write */
}
}
/* Obtain the data transfer properties */
if (H5P_DEFAULT==dxpl_id || H5FD_MPIO!=H5Pget_driver(dxpl_id)) {
_dx.xfer_mode = H5FD_MPIO_INDEPENDENT; /*the default*/
dx = &_dx;
_dx.xfer_mode = H5FD_MPIO_INDEPENDENT; /*the default*/
dx = &_dx;
} else {
dx = H5Pget_driver_info(dxpl_id);
assert(dx);
dx = H5Pget_driver_info(dxpl_id);
assert(dx);
}
/*
@ -1201,18 +1276,19 @@ H5FD_mpio_write(H5FD_t *_file, hid_t dxpl_id/*unused*/, haddr_t addr,
*/
use_types_this_time = file->use_types;
if (use_types_this_time) {
/* prepare for a full-blown xfer using btype, ftype, and disp */
buf_type = file->btype;
file_type = file->ftype;
if (haddr_to_MPIOff(file->disp, &mpi_disp)<0) return -1;
/* prepare for a full-blown xfer using btype, ftype, and disp */
buf_type = file->btype;
file_type = file->ftype;
if (haddr_to_MPIOff(file->disp, &mpi_disp)<0)
HRETURN_ERROR(H5E_INTERNAL, H5E_BADRANGE, FAIL, "can't convert from haddr to MPI off");
} else {
/*
* Prepare for a simple xfer of a contiguous block of bytes.
* The btype, ftype, and disp fields are not used.
*/
buf_type = MPI_BYTE;
file_type = MPI_BYTE;
mpi_disp = 0; /* mpi_off is sufficient */
/*
* Prepare for a simple xfer of a contiguous block of bytes.
* The btype, ftype, and disp fields are not used.
*/
buf_type = MPI_BYTE;
file_type = MPI_BYTE;
mpi_disp = 0; /* mpi_off is sufficient */
}
/*
@ -1221,11 +1297,10 @@ H5FD_mpio_write(H5FD_t *_file, hid_t dxpl_id/*unused*/, haddr_t addr,
*/
used_types_last_time = file->old_use_types;
if (used_types_last_time || /* change to new ftype or MPI_BYTE */
use_types_this_time) { /* almost certainly a different ftype */
/*OKAY: CAST DISCARDS CONST QUALIFIER*/
mpierr = MPI_File_set_view(file->f, mpi_disp, MPI_BYTE, file_type,
(char*)"native", file->info);
if (MPI_SUCCESS != mpierr) return -1;
use_types_this_time) { /* almost certainly a different ftype */
/*OKAY: CAST DISCARDS CONST QUALIFIER*/
if (MPI_SUCCESS != MPI_File_set_view(file->f, mpi_disp, MPI_BYTE, file_type, (char*)"native", file->info))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_File_set_view failed");
}
/*
@ -1237,26 +1312,24 @@ H5FD_mpio_write(H5FD_t *_file, hid_t dxpl_id/*unused*/, haddr_t addr,
file->use_types = 0;
/* Write the data. */
assert(H5FD_MPIO_INDEPENDENT==dx->xfer_mode ||
H5FD_MPIO_COLLECTIVE==dx->xfer_mode);
assert(H5FD_MPIO_INDEPENDENT==dx->xfer_mode || H5FD_MPIO_COLLECTIVE==dx->xfer_mode);
if (H5FD_MPIO_INDEPENDENT==dx->xfer_mode) {
/*OKAY: CAST DISCARDS CONST QUALIFIER*/
mpierr = MPI_File_write_at(file->f, mpi_off, (void*)buf, size_i,
buf_type, &mpi_stat);
/*OKAY: CAST DISCARDS CONST QUALIFIER*/
if (MPI_SUCCESS != MPI_File_write_at(file->f, mpi_off, (void*)buf, size_i, buf_type, &mpi_stat))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_File_write_at failed");
} else {
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'t'])
fprintf(stdout, "H5FD_mpio_write: using MPIO collective mode\n");
if (H5FD_mpio_Debug[(int)'t'])
fprintf(stdout, "H5FD_mpio_write: using MPIO collective mode\n");
#endif
/*OKAY: CAST DISCARDS CONST QUALIFIER*/
mpierr = MPI_File_write_at_all(file->f, mpi_off, (void*)buf, size_i,
buf_type, &mpi_stat);
/*OKAY: CAST DISCARDS CONST QUALIFIER*/
if (MPI_SUCCESS != MPI_File_write_at_all(file->f, mpi_off, (void*)buf, size_i, buf_type, &mpi_stat))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_File_write_at_all failed");
}
if (MPI_SUCCESS != mpierr) return -1;
/* How many bytes were actually written? */
mpierr = MPI_Get_count(&mpi_stat, MPI_BYTE, &bytes_written);
if (MPI_SUCCESS!=mpierr) return -1;
if (MPI_SUCCESS!= MPI_Get_count(&mpi_stat, MPI_BYTE, &bytes_written))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_Get_count failed");
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'c'])
fprintf(stdout,
@ -1271,17 +1344,18 @@ H5FD_mpio_write(H5FD_t *_file, hid_t dxpl_id/*unused*/, haddr_t addr,
*/
bytes_written = size_i;
#endif
if (bytes_written<0 || bytes_written>size_i) return -1;
if (bytes_written<0 || bytes_written>size_i)
HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL, "file write failed");
/* Forget the EOF value (see H5FD_mpio_get_eof()) --rpm 1999-08-06 */
file->eof = HADDR_UNDEF;
done:
done:
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'t'])
fprintf(stdout, "Leaving H5FD_mpio_write\n" );
#endif
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -1311,20 +1385,22 @@ H5FD_mpio_flush(H5FD_t *_file)
H5FD_mpio_t *file = (H5FD_mpio_t*)_file;
int mpierr;
FUNC_ENTER(H5FD_family_flush, FAIL);
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'t'])
fprintf(stdout, "Entering H5FD_mpio_flush\n" );
#endif
mpierr = MPI_File_sync(file->f);
if (MPI_SUCCESS != mpierr) return -1;
if (MPI_SUCCESS != MPI_File_sync(file->f))
HRETURN_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "MPI_File_sync failed");
#ifdef H5FDmpio_DEBUG
if (H5FD_mpio_Debug[(int)'t'])
fprintf(stdout, "Leaving H5FD_mpio_flush\n" );
#endif
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -1353,8 +1429,16 @@ H5FD_mpio_flush(H5FD_t *_file)
static haddr_t
MPIOff_to_haddr(MPI_Offset mpi_off)
{
if (mpi_off != (MPI_Offset)(haddr_t)mpi_off) return HADDR_UNDEF;
return (haddr_t)mpi_off;
hadd_t ret_value=HADDR_UNDEF;
FUNC_ENTER(MPIOff_to_haddr, HADDR_UNDEF);
if (mpi_off != (MPI_Offset)(haddr_t)mpi_off)
ret_value=HADDR_UNDEF;
else
ret_value=(haddr_t)mpi_off;
FUNC_LEAVE(ret_value);
}
@ -1386,8 +1470,17 @@ MPIOff_to_haddr(MPI_Offset mpi_off)
static herr_t
haddr_to_MPIOff(haddr_t addr, MPI_Offset *mpi_off/*out*/)
{
if (mpi_off) *mpi_off = (MPI_Offset)addr;
if (addr != (haddr_t)(MPI_Offset)addr) return -1;
return 0;
herr_t ret_value=FAIL;
FUNC_ENTER(haddr_to_MPIOff, FAIL);
if (mpi_off)
*mpi_off = (MPI_Offset)addr;
if (addr != (haddr_t)(MPI_Offset)addr)
ret_value=FAIL;
else
ret_value=SUCCEED;
FUNC_LEAVE(ret_value);
}
#endif /*HAVE_PARALLEL*/

227
src/H5FDmulti.c
View File

@ -203,6 +203,9 @@ my_strdup(const char *s)
hid_t
H5FD_multi_init(void)
{
/* Clear the error stack */
H5Eclear();
if (H5I_VFL!=H5Iget_type(H5FD_MULTI_g)) {
H5FD_MULTI_g = H5FDregister(&H5FD_multi_g);
}
@ -240,6 +243,9 @@ H5Pset_fapl_split(hid_t fapl, const char *meta_ext, hid_t meta_plist_id,
/*NO TRACE*/
/* Clear the error stack */
H5Eclear();
/* Initialize */
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
memb_map[mt] = (H5FD_MEM_DRAW==mt?mt:H5FD_MEM_SUPER);
@ -358,11 +364,16 @@ H5Pset_fapl_multi(hid_t fapl_id, const H5FD_mem_t *memb_map,
const char *_memb_name_ptrs[H5FD_MEM_NTYPES];
haddr_t _memb_addr[H5FD_MEM_NTYPES];
static const char *letters = "Xsbrglo";
static const char *func="H5FDset_fapl_multi"; /* Function Name for error reporting */
/*NO TRACE*/
/* Clear the error stack */
H5Eclear();
/* Check arguments and supply default values */
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
H5Epush_ret(func, H5E_PLIST, H5E_BADVALUE, "not a file access property list", -1);
if (!memb_map) {
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
_memb_map[mt] = H5FD_MEM_DEFAULT;
@ -393,18 +404,20 @@ H5Pset_fapl_multi(hid_t fapl_id, const H5FD_mem_t *memb_map,
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
/* Map usage type */
mmt = memb_map[mt];
if (mmt<0 || mmt>=H5FD_MEM_NTYPES) return -1;
if (mmt<0 || mmt>=H5FD_MEM_NTYPES)
H5Epush_ret(func, H5E_INTERNAL, H5E_BADRANGE, "file resource type out of range", -1);
if (H5FD_MEM_DEFAULT==mmt) mmt = mt;
/*
* All members of MEMB_FAPL must be either defaults or actual file
* access property lists.
*/
if (H5P_DEFAULT!=memb_fapl[mmt] &&
H5P_FILE_ACCESS!=H5Pget_class(memb_fapl[mmt])) return -1;
if (H5P_DEFAULT!=memb_fapl[mmt] && H5P_FILE_ACCESS!=H5Pget_class(memb_fapl[mmt]))
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "file resource type incorrect", -1);
/* All names must be defined */
if (!memb_name[mmt] || !memb_name[mmt][0]) return -1;
if (!memb_name[mmt] || !memb_name[mmt][0])
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "file resource type not set", -1);
}
/*
@ -445,15 +458,22 @@ H5Pget_fapl_multi(hid_t fapl_id, H5FD_mem_t *memb_map/*out*/,
{
H5FD_multi_fapl_t *fa;
H5FD_mem_t mt;
static const char *func="H5FDget_fapl_multi"; /* Function Name for error reporting */
/*NO TRACE*/
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
if (H5FD_MULTI!=H5Pget_driver(fapl_id)) return -1;
if (NULL==(fa=H5Pget_driver_info(fapl_id))) return -1;
/* Clear the error stack */
H5Eclear();
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
H5Epush_ret(func, H5E_PLIST, H5E_BADTYPE, "not a file access property list", -1);
if (H5FD_MULTI!=H5Pget_driver(fapl_id))
H5Epush_ret(func, H5E_PLIST, H5E_BADVALUE, "incorrect VFL driver", -1);
if (NULL==(fa=H5Pget_driver_info(fapl_id)))
H5Epush_ret(func, H5E_PLIST, H5E_BADVALUE, "bad VFL driver info", -1);
if (memb_map) {
memcpy(memb_map, fa->memb_map, H5FD_MEM_NTYPES*sizeof(H5FD_mem_t));
memcpy(memb_map, fa->memb_map, H5FD_MEM_NTYPES*sizeof(H5FD_mem_t));
}
if (memb_fapl) {
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
@ -509,15 +529,22 @@ H5Pset_dxpl_multi(hid_t dxpl_id, const hid_t *memb_dxpl)
{
H5FD_multi_dxpl_t dx;
H5FD_mem_t mt;
static const char *func="H5FDset_dxpl_multi"; /* Function Name for error reporting */
/*NO TRACE*/
/* Clear the error stack */
H5Eclear();
/* Check arguments */
if (H5P_DATA_XFER!=H5Pget_class(dxpl_id)) return -1;
if (!memb_dxpl) return -1;
if (H5P_DATA_XFER!=H5Pget_class(dxpl_id))
H5Epush_ret(func, H5E_PLIST, H5E_BADTYPE, "not a data transfer property list", -1);
if (!memb_dxpl)
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "invalid pointer", -1);
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
if (H5P_DEFAULT!=memb_dxpl[mt] &&
H5P_DATA_XFER!=H5Pget_class(memb_dxpl[mt])) return -1;
H5P_DATA_XFER!=H5Pget_class(memb_dxpl[mt]))
H5Epush_ret(func, H5E_PLIST, H5E_BADTYPE, "not a data transfer property list", -1);
}
/* Initialize the data transfer property list */
@ -548,12 +575,19 @@ H5Pget_dxpl_multi(hid_t dxpl_id, hid_t *memb_dxpl/*out*/)
{
H5FD_multi_dxpl_t *dx;
H5FD_mem_t mt;
static const char *func="H5FDget_dxpl_multi"; /* Function Name for error reporting */
/*NO TRACE*/
if (H5P_FILE_ACCESS!=H5Pget_class(dxpl_id)) return -1;
if (H5FD_MULTI!=H5Pget_driver(dxpl_id)) return -1;
if (NULL==(dx=H5Pget_driver_info(dxpl_id))) return -1;
/* Clear the error stack */
H5Eclear();
if (H5P_FILE_ACCESS!=H5Pget_class(dxpl_id))
H5Epush_ret(func, H5E_PLIST, H5E_BADTYPE, "not a file access property list", -1);
if (H5FD_MULTI!=H5Pget_driver(dxpl_id))
H5Epush_ret(func, H5E_PLIST, H5E_BADVALUE, "incorrect VFL driver", -1);
if (NULL==(dx=H5Pget_driver_info(dxpl_id)))
H5Epush_ret(func, H5E_PLIST, H5E_BADVALUE, "bad VFL driver info", -1);
if (memb_dxpl) {
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
@ -593,6 +627,9 @@ H5FD_multi_sb_size(H5FD_t *_file)
int nseen = 0;
hsize_t nbytes = 8; /*size of header*/
/* Clear the error stack */
H5Eclear();
/* How many unique files? */
UNIQUE_MEMBERS(file->fa.memb_map, mt) {
nseen++;
@ -646,6 +683,10 @@ H5FD_multi_sb_encode(H5FD_t *_file, char *name/*out*/,
int nseen;
size_t i;
H5FD_mem_t m;
static const char *func="H5FD_multi_sb_encode"; /* Function Name for error reporting */
/* Clear the error stack */
H5Eclear();
/* Name and version number */
strcpy(name, "NCSAmulti");
@ -676,7 +717,7 @@ H5FD_multi_sb_encode(H5FD_t *_file, char *name/*out*/,
} END_MEMBERS;
if (H5Tconvert(H5T_NATIVE_HADDR, H5T_STD_U64LE, nseen, buf+8, NULL,
H5P_DEFAULT)<0) {
return -1;
H5Epush_ret(func, H5E_DATATYPE, H5E_CANTCONVERT, "can't convert superblock info", -1);
}
/* Encode all name templates */
@ -727,9 +768,14 @@ H5FD_multi_sb_decode(H5FD_t *_file, const char *name, const unsigned char *buf)
haddr_t memb_addr[H5FD_MEM_NTYPES];
haddr_t memb_eoa[H5FD_MEM_NTYPES];
haddr_t *ap;
static const char *func="H5FD_multi_sb_decode"; /* Function Name for error reporting */
/* Clear the error stack */
H5Eclear();
/* Make sure the name/version number is correct */
if (strcmp(name, "NCSAmult")) return -1;
if (strcmp(name, "NCSAmult"))
H5Epush_ret(func, H5E_FILE, H5E_BADVALUE, "invalid multi superblock", -1);
/* Set default values */
ALL_MEMBERS(mt) {
@ -756,7 +802,8 @@ H5FD_multi_sb_decode(H5FD_t *_file, const char *name, const unsigned char *buf)
memcpy(x, buf, nseen*2*8);
buf += nseen*2*8;
if (H5Tconvert(H5T_STD_U64LE, H5T_NATIVE_HADDR, nseen*2, x, NULL,
H5P_DEFAULT)<0) return -1;
H5P_DEFAULT)<0)
H5Epush_ret(func, H5E_DATATYPE, H5E_CANTCONVERT, "can't convert superblock info", -1);
ap = (haddr_t*)x;
UNIQUE_MEMBERS(map, mt) {
memb_addr[_unmapped] = *ap++;
@ -823,10 +870,12 @@ H5FD_multi_sb_decode(H5FD_t *_file, const char *name, const unsigned char *buf)
file->fa.memb_name[mt] = my_strdup(memb_name[mt]);
}
} END_MEMBERS;
if (compute_next(file)<0) return -1;
if (compute_next(file)<0)
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "compute_next() failed", -1);
/* Open all necessary files */
if (open_members(file)<0) return -1;
if (open_members(file)<0)
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "open_members() failed", -1);
/* Set the EOA marker for all open files */
UNIQUE_MEMBERS(file->fa.memb_map, mt) {
@ -863,6 +912,9 @@ H5FD_multi_fapl_get(H5FD_t *_file)
{
H5FD_multi_t *file = (H5FD_multi_t*)_file;
/* Clear the error stack */
H5Eclear();
return H5FD_multi_fapl_copy(&(file->fa));
}
@ -890,9 +942,13 @@ H5FD_multi_fapl_copy(const void *_old_fa)
H5FD_multi_fapl_t *new_fa = malloc(sizeof(H5FD_multi_fapl_t));
H5FD_mem_t mt;
int nerrors = 0;
static const char *func="H5FD_multi_fapl_copy"; /* Function Name for error reporting */
assert(new_fa);
/* Clear the error stack */
H5Eclear();
memcpy(new_fa, old_fa, sizeof(H5FD_multi_fapl_t));
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
if (old_fa->memb_fapl[mt]>=0) {
@ -907,12 +963,12 @@ H5FD_multi_fapl_copy(const void *_old_fa)
}
if (nerrors) {
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
if (new_fa->memb_fapl[mt]>=0) H5Pclose(new_fa->memb_fapl[mt]);
if (new_fa->memb_name[mt]) free(new_fa->memb_name[mt]);
}
free(new_fa);
return NULL;
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
if (new_fa->memb_fapl[mt]>=0) H5Pclose(new_fa->memb_fapl[mt]);
if (new_fa->memb_name[mt]) free(new_fa->memb_name[mt]);
}
free(new_fa);
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "invalid freespace objects", NULL);
}
return new_fa;
}
@ -940,6 +996,9 @@ H5FD_multi_fapl_free(void *_fa)
H5FD_multi_fapl_t *fa = (H5FD_multi_fapl_t*)_fa;
H5FD_mem_t mt;
/* Clear the error stack */
H5Eclear();
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
if (fa->memb_fapl[mt]>=0) H5Pclose(fa->memb_fapl[mt]);
if (fa->memb_name[mt]) free(fa->memb_name[mt]);
@ -972,9 +1031,13 @@ H5FD_multi_dxpl_copy(const void *_old_dx)
H5FD_multi_dxpl_t *new_dx = malloc(sizeof(H5FD_multi_dxpl_t));
H5FD_mem_t mt;
int nerrors = 0;
static const char *func="H5FD_multi_dxpl_copy"; /* Function Name for error reporting */
assert(new_dx);
/* Clear the error stack */
H5Eclear();
memcpy(new_dx, old_dx, sizeof(H5FD_multi_dxpl_t));
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
if (old_dx->memb_dxpl[mt]>=0) {
@ -984,11 +1047,10 @@ H5FD_multi_dxpl_copy(const void *_old_dx)
}
if (nerrors) {
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
H5Pclose(new_dx->memb_dxpl[mt]);
}
free(new_dx);
return NULL;
for (mt=0; mt<H5FD_MEM_NTYPES; mt++)
H5Pclose(new_dx->memb_dxpl[mt]);
free(new_dx);
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "invalid freespace objects", NULL);
}
return new_dx;
}
@ -1016,9 +1078,12 @@ H5FD_multi_dxpl_free(void *_dx)
H5FD_multi_dxpl_t *dx = (H5FD_multi_dxpl_t*)_dx;
H5FD_mem_t mt;
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
if (dx->memb_dxpl[mt]>=0) H5Pclose(dx->memb_dxpl[mt]);
}
/* Clear the error stack */
H5Eclear();
for (mt=0; mt<H5FD_MEM_NTYPES; mt++)
if (dx->memb_dxpl[mt]>=0)
H5Pclose(dx->memb_dxpl[mt]);
free(dx);
return 0;
}
@ -1050,19 +1115,26 @@ H5FD_multi_open(const char *name, unsigned flags, hid_t fapl_id,
hid_t close_fapl=-1;
H5FD_multi_fapl_t *fa;
H5FD_mem_t m;
static const char *func="H5FD_multi_open"; /* Function Name for error reporting */
/* Clear the error stack */
H5Eclear();
/* Check arguments */
if (!name || !*name) return NULL;
if (0==maxaddr || HADDR_UNDEF==maxaddr) return NULL;
if (!name || !*name)
H5Epush_ret(func, H5E_ARGS, H5E_BADVALUE, "invalid file name", NULL);
if (0==maxaddr || HADDR_UNDEF==maxaddr)
H5Epush_ret(func, H5E_ARGS, H5E_BADRANGE, "bogus maxaddr", NULL);
/*
* Initialize the file from the file access properties, using default
* values if necessary.
*/
if (NULL==(file=calloc(1, sizeof(H5FD_multi_t)))) return NULL;
if (NULL==(file=calloc(1, sizeof(H5FD_multi_t))))
H5Epush_ret(func, H5E_RESOURCE, H5E_NOSPACE, "memory allocation failed", NULL);
if (H5P_DEFAULT==fapl_id || H5FD_MULTI!=H5Pget_driver(fapl_id)) {
close_fapl = fapl_id = H5Pcreate(H5P_FILE_ACCESS);
H5Pset_fapl_multi(fapl_id, NULL, NULL, NULL, NULL, TRUE);
close_fapl = fapl_id = H5Pcreate(H5P_FILE_ACCESS);
H5Pset_fapl_multi(fapl_id, NULL, NULL, NULL, NULL, TRUE);
}
fa = H5Pget_driver_info(fapl_id);
assert(fa);
@ -1083,20 +1155,23 @@ H5FD_multi_open(const char *name, unsigned flags, hid_t fapl_id,
file->fa.relax = fa->relax;
file->flags = flags;
file->name = my_strdup(name);
if (close_fapl>=0) H5Pclose(close_fapl);
if (close_fapl>=0)
H5Pclose(close_fapl);
/* Compute derived properties and open member files */
if (compute_next(file)<0) goto error;
if (open_members(file)<0) goto error;
if (compute_next(file)<0)
H5Epush_goto(func, H5E_INTERNAL, H5E_BADVALUE, "compute_next() failed", error);
if (open_members(file)<0)
H5Epush_goto(func, H5E_INTERNAL, H5E_BADVALUE, "open_members() failed", error);
/* We must have opened at least the superblock file */
if (H5FD_MEM_DEFAULT==(m=file->fa.memb_map[H5FD_MEM_SUPER])) {
m = H5FD_MEM_SUPER;
m = H5FD_MEM_SUPER;
}
if (NULL==file->memb[m]) goto error;
return (H5FD_t*)file;
error:
error:
/* Cleanup and fail */
if (file) {
ALL_MEMBERS(mt) {
@ -1134,9 +1209,14 @@ H5FD_multi_close(H5FD_t *_file)
{
H5FD_multi_t *file = (H5FD_multi_t*)_file;
int nerrors=0;
static const char *func="H5FD_multi_close"; /* Function Name for error reporting */
/* Clear the error stack */
H5Eclear();
/* Flush our own data */
if (H5FD_multi_flush(_file)<0) nerrors++;
if (H5FD_multi_flush(_file)<0)
nerrors++;
/* Close as many members as possible */
ALL_MEMBERS(mt) {
@ -1158,7 +1238,8 @@ H5FD_multi_close(H5FD_t *_file)
}
}
} END_MEMBERS;
if (nerrors) return -1;
if (nerrors)
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "error closing member files", -1);
/* Clean up other stuff */
ALL_MEMBERS(mt) {
@ -1200,6 +1281,9 @@ H5FD_multi_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
H5FD_mem_t mt;
int cmp=0;
/* Clear the error stack */
H5Eclear();
for (mt=0; mt<H5FD_MEM_NTYPES; mt++) {
if (f1->memb[mt] && f2->memb[mt]) break;
if (!cmp) {
@ -1236,6 +1320,10 @@ static haddr_t
H5FD_multi_get_eoa(H5FD_t *_file)
{
H5FD_multi_t *file = (H5FD_multi_t*)_file;
/* Clear the error stack */
H5Eclear();
return file->eoa;
}
@ -1265,6 +1353,10 @@ H5FD_multi_set_eoa(H5FD_t *_file, haddr_t eoa)
H5FD_multi_t *file = (H5FD_multi_t*)_file;
H5FD_mem_t mt, mmt;
herr_t status;
static const char *func="H5FD_multi_set_eoa"; /* Function Name for error reporting */
/* Clear the error stack */
H5Eclear();
/* Find the subfile in which the new EOA value falls */
for (mt=1; mt<H5FD_MEM_NTYPES; mt++) {
@ -1283,7 +1375,8 @@ H5FD_multi_set_eoa(H5FD_t *_file, haddr_t eoa)
H5E_BEGIN_TRY {
status = H5FDset_eoa(file->memb[mmt], eoa-file->fa.memb_addr[mmt]);
} H5E_END_TRY;
if (status<0) return -1;
if (status<0)
H5Epush_ret(func, H5E_FILE, H5E_BADVALUE, "member H5FDset_eoa failed", -1);
}
/* Save new eoa for return later */
@ -1316,13 +1409,18 @@ H5FD_multi_get_eof(H5FD_t *_file)
{
H5FD_multi_t *file = (H5FD_multi_t*)_file;
haddr_t eof=0, tmp;
static const char *func="H5FD_multi_eof"; /* Function Name for error reporting */
/* Clear the error stack */
H5Eclear();
UNIQUE_MEMBERS(file->fa.memb_map, mt) {
if (file->memb[mt]) {
H5E_BEGIN_TRY {
tmp = H5FDget_eof(file->memb[mt]);
} H5E_END_TRY;
if (HADDR_UNDEF==tmp) return HADDR_UNDEF;
if (HADDR_UNDEF==tmp)
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "member file has unknown eof", HADDR_UNDEF);
if (tmp>0) tmp += file->fa.memb_addr[mt];
} else if (file->fa.relax) {
@ -1334,7 +1432,7 @@ H5FD_multi_get_eof(H5FD_t *_file)
assert(HADDR_UNDEF!=tmp);
} else {
return HADDR_UNDEF;
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "bad eof", HADDR_UNDEF);
}
if (tmp>eof) eof = tmp;
@ -1366,12 +1464,13 @@ H5FD_multi_alloc(H5FD_t *_file, H5FD_mem_t type, hsize_t size)
H5FD_multi_t *file = (H5FD_multi_t*)_file;
H5FD_mem_t mmt;
haddr_t addr;
static const char *func="H5FD_multi_alloc"; /* Function Name for error reporting */
mmt = file->fa.memb_map[type];
if (H5FD_MEM_DEFAULT==mmt) mmt = type;
if (HADDR_UNDEF==(addr=H5FDalloc(file->memb[mmt], type, size))) {
return HADDR_UNDEF;
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "member file can't alloc", HADDR_UNDEF);
}
addr += file->fa.memb_addr[mmt];
if (addr+size>file->eoa) file->eoa = addr+size;
@ -1401,6 +1500,9 @@ H5FD_multi_free(H5FD_t *_file, H5FD_mem_t type, haddr_t addr, hsize_t size)
H5FD_multi_t *file = (H5FD_multi_t*)_file;
H5FD_mem_t mmt;
/* Clear the error stack */
H5Eclear();
mmt = file->fa.memb_map[type];
if (H5FD_MEM_DEFAULT==mmt) mmt = type;
@ -1438,6 +1540,9 @@ H5FD_multi_read(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
H5FD_mem_t mt, mmt, hi=H5FD_MEM_DEFAULT;
haddr_t start_addr=0;
/* Clear the error stack */
H5Eclear();
/* Get the data transfer properties */
if (H5P_DEFAULT!=dxpl_id && H5FD_MULTI==H5Pget_driver(dxpl_id)) {
dx = H5Pget_driver_info(dxpl_id);
@ -1490,6 +1595,9 @@ H5FD_multi_write(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
H5FD_mem_t mt, mmt, hi=H5FD_MEM_DEFAULT;
haddr_t start_addr=0;
/* Clear the error stack */
H5Eclear();
/* Get the data transfer properties */
if (H5P_DEFAULT!=dxpl_id && H5FD_MULTI==H5Pget_driver(dxpl_id)) {
dx = H5Pget_driver_info(dxpl_id);
@ -1537,6 +1645,7 @@ H5FD_multi_flush(H5FD_t *_file)
H5FD_multi_t *file = (H5FD_multi_t*)_file;
H5FD_mem_t mt;
int nerrors=0;
static const char *func="H5FD_multi_flush"; /* Function Name for error reporting */
#if 0
H5FD_mem_t mmt;
@ -1570,6 +1679,9 @@ H5FD_multi_flush(H5FD_t *_file)
}
#endif
/* Clear the error stack */
H5Eclear();
/* Flush each file */
for (mt=1; mt<H5FD_MEM_NTYPES; mt++) {
if (file->memb[mt]) {
@ -1578,8 +1690,10 @@ H5FD_multi_flush(H5FD_t *_file)
} H5E_END_TRY;
}
}
if (nerrors)
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "error flushing member files", -1);
return nerrors ? -1 : 0;
return 0;
}
@ -1603,6 +1717,9 @@ H5FD_multi_flush(H5FD_t *_file)
static int
compute_next(H5FD_multi_t *file)
{
/* Clear the error stack */
H5Eclear();
ALL_MEMBERS(mt) {
file->memb_next[mt] = HADDR_UNDEF;
} END_MEMBERS;
@ -1645,7 +1762,11 @@ open_members(H5FD_multi_t *file)
{
char tmp[1024];
int nerrors=0;
static const char *func="(H5FD_multi)open_members"; /* Function Name for error reporting */
/* Clear the error stack */
H5Eclear();
UNIQUE_MEMBERS(file->fa.memb_map, mt) {
if (file->memb[mt]) continue; /*already open*/
assert(file->fa.memb_name[mt]);
@ -1673,6 +1794,8 @@ open_members(H5FD_multi_t *file)
}
}
} END_MEMBERS;
if (nerrors)
H5Epush_ret(func, H5E_INTERNAL, H5E_BADVALUE, "error opening member files", -1);
return nerrors?-1:0;
return 0;
}

253
src/H5FDsec2.c
View File

@ -12,21 +12,12 @@
* I/O from this driver with I/O from other parts of the
* application to the same file).
*/
#include <H5private.h>
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <hdf5.h>
#include <stdlib.h>
#include <sys/stat.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef WIN32
#include <windows.h>
#endif
#include <H5private.h> /*library functions */
#include <H5Eprivate.h> /*error handling */
#include <H5Fprivate.h> /*files */
#include <H5FDsec2.h> /* Sec2 file driver */
#include <H5MMprivate.h> /* Memory allocation */
#include <H5Pprivate.h> /*property lists */
#ifdef MAX
#undef MAX
@ -166,6 +157,11 @@ static const H5FD_class_t H5FD_sec2_g = {
H5FD_FLMAP_SINGLE, /*fl_map */
};
/* Interface initialization */
#define PABLO_MASK H5FD_sec2_mask
#define INTERFACE_INIT H5FD_sec2_init
static intn interface_initialize_g = 0;
/*-------------------------------------------------------------------------
* Function: H5FD_sec2_init
@ -187,10 +183,12 @@ static const H5FD_class_t H5FD_sec2_g = {
hid_t
H5FD_sec2_init(void)
{
if (H5I_VFL!=H5Iget_type(H5FD_SEC2_g)) {
H5FD_SEC2_g = H5FDregister(&H5FD_sec2_g);
}
return H5FD_SEC2_g;
FUNC_ENTER(H5FD_sec2_init, FAIL);
if (H5I_VFL!=H5Iget_type(H5FD_SEC2_g))
H5FD_SEC2_g = H5FDregister(&H5FD_sec2_g);
FUNC_LEAVE(H5FD_SEC2_g);
}
@ -213,9 +211,17 @@ H5FD_sec2_init(void)
herr_t
H5Pset_fapl_sec2(hid_t fapl_id)
{
herr_t ret_value=FAIL;
/*NO TRACE*/
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id)) return -1;
return H5Pset_driver(fapl_id, H5FD_SEC2, NULL);
FUNC_ENTER(H5FD_set_fapl_sec2, FAIL);
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a fapl");
ret_value= H5Pset_driver(fapl_id, H5FD_SEC2, NULL);
FUNC_LEAVE(ret_value);
}
@ -251,26 +257,33 @@ H5FD_sec2_open(const char *name, unsigned flags, hid_t UNUSED fapl_id,
int results;
#endif
FUNC_ENTER(H5FD_sec2_open, NULL);
/* Check arguments */
if (!name || !*name) return NULL;
if (0==maxaddr || HADDR_UNDEF==maxaddr) return NULL;
if (ADDR_OVERFLOW(maxaddr)) return NULL;
if (!name || !*name)
HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid file name");
if (0==maxaddr || HADDR_UNDEF==maxaddr)
HRETURN_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "bogus maxaddr");
if (ADDR_OVERFLOW(maxaddr))
HRETURN_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;
/* Open the file */
if ((fd=HDopen(name, o_flags, 0666))<0) return NULL;
/* Open the file */
if ((fd=HDopen(name, o_flags, 0666))<0)
HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "can't open file");
if (fstat(fd, &sb)<0) {
close(fd);
return NULL;
close(fd);
HRETURN_ERROR(H5E_FILE, H5E_BADFILE, NULL, "can't fstat file");
}
/* Create the new file struct */
file = calloc(1, sizeof(H5FD_sec2_t));
if (NULL==(file=H5MM_calloc(sizeof(H5FD_sec2_t))))
HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate file struct");
file->fd = fd;
file->eof = sb.st_size;
file->pos = HADDR_UNDEF;
@ -284,7 +297,7 @@ H5FD_sec2_open(const char *name, unsigned flags, hid_t UNUSED fapl_id,
file->device = sb.st_dev;
file->inode = sb.st_ino;
#endif
return (H5FD_t*)file;
FUNC_LEAVE((H5FD_t*)file);
}
@ -309,10 +322,16 @@ H5FD_sec2_close(H5FD_t *_file)
{
H5FD_sec2_t *file = (H5FD_sec2_t*)_file;
if (H5FD_sec2_flush(_file)<0) return -1;
if (close(file->fd)<0) return -1;
free(file);
return 0;
FUNC_ENTER(H5FD_sec2_close, FAIL);
if (H5FD_sec2_flush(_file)<0)
HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "can't flush file");
if (close(file->fd)<0)
HRETURN_ERROR(H5E_IO, H5E_CANTCLOSEFILE, FAIL, "can't close file");
H5MM_xfree(file);
FUNC_LEAVE(SUCCEED);
}
@ -339,21 +358,26 @@ H5FD_sec2_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
{
const H5FD_sec2_t *f1 = (const H5FD_sec2_t*)_f1;
const H5FD_sec2_t *f2 = (const H5FD_sec2_t*)_f2;
#ifdef WIN32
if (f1->fileindexhi < f2->fileindexhi) return -1;
if (f1->fileindexhi > f2->fileindexhi) return 1;
int ret_value=0;
if (f1->fileindexlo < f2->fileindexlo) return -1;
if (f1->fileindexlo > f2->fileindexlo) return 1;
FUNC_ENTER(H5FD_sec2_cmp, -2);
#ifdef WIN32
if (f1->fileindexhi < f2->fileindexhi) ret_value= -1;
if (f1->fileindexhi > f2->fileindexhi) ret_value= 1;
if (f1->fileindexlo < f2->fileindexlo) ret_value= -1;
if (f1->fileindexlo > f2->fileindexlo) ret_value= 1;
#else
if (f1->device < f2->device) return -1;
if (f1->device > f2->device) return 1;
if (f1->device < f2->device) ret_value= -1;
if (f1->device > f2->device) ret_value= 1;
if (f1->inode < f2->inode) return -1;
if (f1->inode > f2->inode) return 1;
if (f1->inode < f2->inode) ret_value= -1;
if (f1->inode > f2->inode) ret_value= 1;
#endif
return 0;
FUNC_LEAVE(ret_value);
}
@ -379,7 +403,10 @@ static haddr_t
H5FD_sec2_get_eoa(H5FD_t *_file)
{
H5FD_sec2_t *file = (H5FD_sec2_t*)_file;
return file->eoa;
FUNC_ENTER(H5FD_sec2_get_eoa, HADDR_UNDEF);
FUNC_LEAVE(file->eoa);
}
@ -405,8 +432,12 @@ static herr_t
H5FD_sec2_set_eoa(H5FD_t *_file, haddr_t addr)
{
H5FD_sec2_t *file = (H5FD_sec2_t*)_file;
FUNC_ENTER(H5FD_sec2_set_eoa, FAIL);
file->eoa = addr;
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -434,7 +465,10 @@ static haddr_t
H5FD_sec2_get_eof(H5FD_t *_file)
{
H5FD_sec2_t *file = (H5FD_sec2_t*)_file;
return MAX(file->eof, file->eoa);
FUNC_ENTER(H5FD_get_get_eof, HADDR_UNDEF);
FUNC_LEAVE(MAX(file->eof, file->eoa));
}
@ -464,20 +498,25 @@ H5FD_sec2_read(H5FD_t *_file, hid_t UNUSED dxpl_id, haddr_t addr,
H5FD_sec2_t *file = (H5FD_sec2_t*)_file;
ssize_t nbytes;
FUNC_ENTER(H5FD_sec2_read, FAIL);
assert(file && file->pub.cls);
assert(buf);
/* Check for overflow conditions */
if (HADDR_UNDEF==addr) return -1;
if (REGION_OVERFLOW(addr, size)) return -1;
if (addr+size>file->eoa) return -1;
if (HADDR_UNDEF==addr)
HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined");
if (REGION_OVERFLOW(addr, size))
HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow");
if (addr+size>file->eoa)
HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow");
/* Seek to the correct location */
if ((addr!=file->pos || OP_READ!=file->op) &&
file_seek(file->fd, (file_offset_t)addr, SEEK_SET)<0) {
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
return -1;
file_seek(file->fd, (file_offset_t)addr, SEEK_SET)<0) {
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
HRETURN_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "can't seek to proper position");
}
/*
@ -485,30 +524,31 @@ H5FD_sec2_read(H5FD_t *_file, hid_t UNUSED dxpl_id, haddr_t addr,
* and the end of the file.
*/
while (size>0) {
do nbytes = read(file->fd, buf, size);
while (-1==nbytes && EINTR==errno);
if (-1==nbytes) {
/* error */
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
return -1;
}
if (0==nbytes) {
/* end of file but not end of format address space */
memset(buf, 0, size);
size = 0;
}
assert(nbytes>=0);
assert((hsize_t)nbytes<=size);
size -= (hsize_t)nbytes;
addr += (haddr_t)nbytes;
buf = (char*)buf + nbytes;
do
nbytes = read(file->fd, buf, size);
while (-1==nbytes && EINTR==errno);
if (-1==nbytes) {
/* error */
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL, "file read failed");
}
if (0==nbytes) {
/* end of file but not end of format address space */
memset(buf, 0, size);
size = 0;
}
assert(nbytes>=0);
assert((hsize_t)nbytes<=size);
size -= (hsize_t)nbytes;
addr += (haddr_t)nbytes;
buf = (char*)buf + nbytes;
}
/* Update current position */
file->pos = addr;
file->op = OP_READ;
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -537,20 +577,25 @@ H5FD_sec2_write(H5FD_t *_file, hid_t UNUSED dxpl_id, haddr_t addr,
H5FD_sec2_t *file = (H5FD_sec2_t*)_file;
ssize_t nbytes;
FUNC_ENTER(H5FD_sec2_write, FAIL);
assert(file && file->pub.cls);
assert(buf);
/* Check for overflow conditions */
if (HADDR_UNDEF==addr) return -1;
if (REGION_OVERFLOW(addr, size)) return -1;
if (addr+size>file->eoa) return -1;
if (HADDR_UNDEF==addr)
HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined");
if (REGION_OVERFLOW(addr, size))
HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow");
if (addr+size>file->eoa)
HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow");
/* Seek to the correct location */
if ((addr!=file->pos || OP_WRITE!=file->op) &&
file_seek(file->fd, (file_offset_t)addr, SEEK_SET)<0) {
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
return -1;
file_seek(file->fd, (file_offset_t)addr, SEEK_SET)<0) {
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
HRETURN_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "can't seek to proper position");
}
/*
@ -558,27 +603,29 @@ H5FD_sec2_write(H5FD_t *_file, hid_t UNUSED dxpl_id, haddr_t addr,
* results
*/
while (size>0) {
do nbytes = write(file->fd, buf, size);
while (-1==nbytes && EINTR==errno);
if (-1==nbytes) {
/* error */
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
return -1;
}
assert(nbytes>0);
assert((hsize_t)nbytes<=size);
size -= (hsize_t)nbytes;
addr += (haddr_t)nbytes;
buf = (const char*)buf + nbytes;
do
nbytes = write(file->fd, buf, size);
while (-1==nbytes && EINTR==errno);
if (-1==nbytes) {
/* error */
file->pos = HADDR_UNDEF;
file->op = OP_UNKNOWN;
HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "file write failed");
}
assert(nbytes>0);
assert((hsize_t)nbytes<=size);
size -= (hsize_t)nbytes;
addr += (haddr_t)nbytes;
buf = (const char*)buf + nbytes;
}
/* Update current position and eof */
file->pos = addr;
file->op = OP_WRITE;
if (file->pos>file->eof) file->eof = file->pos;
if (file->pos>file->eof)
file->eof = file->pos;
return 0;
FUNC_LEAVE(SUCCEED);
}
@ -604,13 +651,17 @@ H5FD_sec2_flush(H5FD_t *_file)
{
H5FD_sec2_t *file = (H5FD_sec2_t*)_file;
FUNC_ENTER(H5FD_sec2_seek, FAIL);
if (file->eoa>file->eof) {
if (-1==file_seek(file->fd, file->eoa-1, SEEK_SET)) return -1;
if (write(file->fd, "", 1)!=1) return -1;
file->eof = file->eoa;
file->pos = file->eoa;
file->op = OP_WRITE;
if (-1==file_seek(file->fd, file->eoa-1, SEEK_SET))
HRETURN_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "can't seek to proper position");
if (write(file->fd, "", 1)!=1)
HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "file write failed");
file->eof = file->eoa;
file->pos = file->eoa;
file->op = OP_WRITE;
}
return 0;
FUNC_LEAVE(SUCCEED);
}

59
src/H5FDstdio.c
View File

@ -163,6 +163,9 @@ static const H5FD_class_t H5FD_stdio_g = {
hid_t
H5FD_stdio_init(void)
{
/* Clear the error stack */
H5Eclear();
if (H5I_VFL!=H5Iget_type(H5FD_STDIO_g))
H5FD_STDIO_g = H5FDregister(&H5FD_stdio_g);
return(H5FD_STDIO_g);
@ -189,8 +192,13 @@ H5FD_stdio_init(void)
herr_t
H5Pset_fapl_stdio(hid_t fapl_id)
{
static const char *func="H5FDset_fapl_stdio"; /* Function Name for error reporting */
/* Clear the error stack */
H5Eclear();
if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
return -1;
H5Epush_ret(func, H5E_PLIST, H5E_BADTYPE, "not a file access property list", -1);
return(H5Pset_driver(fapl_id, H5FD_STDIO, NULL));
}
@ -243,23 +251,26 @@ H5FD_stdio_open( const char *name, unsigned flags, hid_t fapl_id,
/* Shut compiler up */
fapl_id=fapl_id;
/* Clear the error stack */
H5Eclear();
/* Check arguments */
if (!name || !*name) return NULL;
if (0==maxaddr || HADDR_UNDEF==maxaddr) return NULL;
if (ADDR_OVERFLOW(maxaddr)) return NULL;
if (!name || !*name)
H5Epush_ret(func, H5E_ARGS, H5E_BADVALUE, "invalid file name", NULL);
if (0==maxaddr || HADDR_UNDEF==maxaddr)
H5Epush_ret(func, H5E_ARGS, H5E_BADRANGE, "bogus maxaddr", NULL);
if (ADDR_OVERFLOW(maxaddr))
H5Epush_ret(func, H5E_ARGS, H5E_OVERFLOW, "maxaddr too large", NULL);
if (access(name, F_OK) < 0) {
if ((flags & H5F_ACC_CREAT) && (flags & H5F_ACC_RDWR)) {
f = fopen(name, "wb+");
write_access=1; /* Note the write access */
} else {
H5Epush_ret(func, H5E_IO, H5E_CANTOPENFILE,
"file doesn't exist and CREAT wasn't specified", NULL);
H5Epush_ret(func, H5E_IO, H5E_CANTOPENFILE, "file doesn't exist and CREAT wasn't specified", NULL);
}
} else if ((flags & H5F_ACC_CREAT) && (flags & H5F_ACC_EXCL)) {
H5Epush_ret(func, H5E_IO, H5E_FILEEXISTS,
"file exists but CREAT and EXCL were specified", NULL);
H5Epush_ret(func, H5E_IO, H5E_FILEEXISTS, "file exists but CREAT and EXCL were specified", NULL);
} else if (flags & H5F_ACC_RDWR) {
if (flags & H5F_ACC_TRUNC)
f = fopen(name, "wb+");
@ -273,10 +284,8 @@ H5FD_stdio_open( const char *name, unsigned flags, hid_t fapl_id,
H5Epush_ret(func, H5E_IO, H5E_CANTOPENFILE, "fopen failed", NULL);
/* Build the return value */
if (NULL==(file = calloc(1,sizeof(H5FD_stdio_t)))) {
H5Epush_ret(func, H5E_RESOURCE, H5E_NOSPACE,
"memory allocation failed", NULL);
}
if (NULL==(file = calloc(1,sizeof(H5FD_stdio_t))))
H5Epush_ret(func, H5E_RESOURCE, H5E_NOSPACE, "memory allocation failed", NULL);
file->fp = f;
file->op = H5FD_STDIO_OP_SEEK;
file->pos = HADDR_UNDEF;
@ -329,6 +338,9 @@ H5FD_stdio_close(H5FD_t *_file)
H5FD_stdio_t *file = (H5FD_stdio_t*)_file;
static const char *func="H5FD_stdio_close"; /* Function Name for error reporting */
/* Clear the error stack */
H5Eclear();
if (H5FD_stdio_flush(_file)<0)
H5Epush_ret(func, H5E_IO, H5E_WRITEERROR, "flush failed", -1);
if (fclose(file->fp) < 0)
@ -365,6 +377,9 @@ H5FD_stdio_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
const H5FD_stdio_t *f1 = (const H5FD_stdio_t*)_f1;
const H5FD_stdio_t *f2 = (const H5FD_stdio_t*)_f2;
/* Clear the error stack */
H5Eclear();
#ifdef WIN32
if (f1->fileindexhi < f2->fileindexhi) return -1;
if (f1->fileindexhi > f2->fileindexhi) return 1;
@ -407,6 +422,9 @@ H5FD_stdio_get_eoa(H5FD_t *_file)
{
H5FD_stdio_t *file = (H5FD_stdio_t*)_file;
/* Clear the error stack */
H5Eclear();
return(file->eoa);
}
@ -435,6 +453,9 @@ H5FD_stdio_set_eoa(H5FD_t *_file, haddr_t addr)
{
H5FD_stdio_t *file = (H5FD_stdio_t*)_file;
/* Clear the error stack */
H5Eclear();
file->eoa = addr;
return(0);
@ -467,6 +488,9 @@ H5FD_stdio_get_eof(H5FD_t *_file)
{
H5FD_stdio_t *file = (H5FD_stdio_t*)_file;
/* Clear the error stack */
H5Eclear();
return(MAX(file->eof, file->eoa));
}
@ -506,6 +530,9 @@ H5FD_stdio_read(H5FD_t *_file, hid_t dxpl_id, haddr_t addr, hsize_t size,
/* Shut compiler up */
dxpl_id=dxpl_id;
/* Clear the error stack */
H5Eclear();
/* Check for overflow */
if (HADDR_UNDEF==addr)
H5Epush_ret (func, H5E_IO, H5E_OVERFLOW, "file address overflowed", -1);
@ -600,6 +627,9 @@ H5FD_stdio_write(H5FD_t *_file, hid_t dxpl_id, haddr_t addr,
/* Shut compiler up */
dxpl_id=dxpl_id;
/* Clear the error stack */
H5Eclear();
/* Check for overflow conditions */
if (HADDR_UNDEF==addr)
H5Epush_ret (func, H5E_IO, H5E_OVERFLOW, "file address overflowed", -1);
@ -671,6 +701,9 @@ H5FD_stdio_flush(H5FD_t *_file)
H5FD_stdio_t *file = (H5FD_stdio_t*)_file;
static const char *func="H5FD_stdio_flush"; /* Function Name for error reporting */
/* Clear the error stack */
H5Eclear();
/* Only try to flush the file if we have write access */
if(file->write_access) {
/* Makes sure that the true file size is the same (or larger) than the end-of-address. */