/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Copyright by The HDF Group. * * Copyright by the Board of Trustees of the University of Illinois. * * All rights reserved. * * * * This file is part of HDF5. The full HDF5 copyright notice, including * * terms governing use, modification, and redistribution, is contained in * * the files COPYING and Copyright.html. COPYING can be found at the root * * of the source code distribution tree; Copyright.html can be found at the * * root level of an installed copy of the electronic HDF5 document set and * * is linked from the top-level documents page. It can also be found at * * http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have * * access to either file, you may request a copy from help@hdfgroup.org. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * Programmer: Robb Matzke * Monday, July 26, 1999 * * Purpose: The Virtual File Layer as described in documentation. * This is the greatest common denominator for all types of * storage access whether a file, memory, network, etc. This * layer usually just dispatches the request to an actual * file driver layer. */ /****************/ /* Module Setup */ /****************/ #define H5F_PACKAGE /*suppress error about including H5Fpkg */ #define H5FD_PACKAGE /*suppress error about including H5FDpkg */ /* Interface initialization */ #define H5_INTERFACE_INIT_FUNC H5FD_init_interface /***********/ /* Headers */ /***********/ #include "H5private.h" /* Generic Functions */ #include "H5Dprivate.h" /* Datasets */ #include "H5Eprivate.h" /* Error handling */ #include "H5Fpkg.h" /* File access */ #include "H5FDpkg.h" /* File Drivers */ #include "H5FDcore.h" /* Files stored entirely in memory */ #include "H5FDfamily.h" /* File families */ #include "H5FDlog.h" /* sec2 driver with I/O logging (for debugging) */ #include "H5FDmpi.h" /* MPI-based file drivers */ #include "H5FDmulti.h" /* Usage-partitioned file family */ #include "H5FDsec2.h" /* POSIX unbuffered file I/O */ #include "H5FDstdio.h" /* Standard C buffered I/O */ #ifdef H5_HAVE_WINDOWS #include "H5FDwindows.h" /* Windows buffered I/O */ #endif #include "H5FDdirect.h" /* Direct file I/O */ #include "H5Iprivate.h" /* IDs */ #include "H5MMprivate.h" /* Memory management */ #include "H5Pprivate.h" /* Property lists */ /****************/ /* Local Macros */ /****************/ /* Metadata accumulator controls */ #define H5FD_ACCUM_THROTTLE 8 #define H5FD_ACCUM_THRESHOLD 2048 /******************/ /* Local Typedefs */ /******************/ /********************/ /* Package Typedefs */ /********************/ /********************/ /* Local Prototypes */ /********************/ static herr_t H5FD_pl_copy(void *(*copy_func)(const void *), size_t pl_size, const void *old_pl, void **copied_pl); static herr_t H5FD_pl_close(hid_t driver_id, herr_t (*free_func)(void *), void *pl); static herr_t H5FD_free_cls(H5FD_class_t *cls); /*********************/ /* Package Variables */ /*********************/ /*****************************/ /* Library Private Variables */ /*****************************/ /*******************/ /* Local Variables */ /*******************/ /* * Global count of the number of H5FD_t's handed out. This is used as a * "serial number" for files that are currently open and is used for the * 'fileno' field in H5O_info_t. However, if a VFL driver is not able * to detect whether two files are the same, a file that has been opened * by H5Fopen more than once with that VFL driver will have two different * serial numbers. :-/ * * Also, if a file is opened, the 'fileno' field is retrieved for an * object and the file is closed and re-opened, the 'fileno' value will * be different. */ static unsigned long file_serial_no; /*------------------------------------------------------------------------- * Function: H5FD_init * * Purpose: Initialize the interface from some other package. * * Return: Success: non-negative * Failure: negative * * Programmer: Quincey Koziol * Thursday, January 3, 2007 * *------------------------------------------------------------------------- */ herr_t H5FD_init(void) { herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_init, FAIL) /* FUNC_ENTER() does all the work */ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_init() */ /*------------------------------------------------------------------------- * Function: H5FD_init_interface * * Purpose: Initialize the virtual file layer. * * Return: Success: Non-negative * * Failure: Negative * * Programmer: Robb Matzke * Monday, July 26, 1999 * * Modifications: * *------------------------------------------------------------------------- */ static herr_t H5FD_init_interface(void) { herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5FD_init_interface) if(H5I_register_type(H5I_VFL, (size_t)H5I_VFL_HASHSIZE, 0, (H5I_free_t)H5FD_free_cls)open || !cls->close) HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, FAIL, "`open' and/or `close' methods are not defined") if(!cls->get_eoa || !cls->set_eoa) HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, FAIL, "`get_eoa' and/or `set_eoa' methods are not defined") if(!cls->get_eof) HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, FAIL, "`get_eof' method is not defined") if(!cls->read || !cls->write) HGOTO_ERROR(H5E_ARGS, H5E_UNINITIALIZED, FAIL, "`read' and/or `write' method is not defined") for (type=H5FD_MEM_DEFAULT; typefl_map[type]fl_map[type]>=H5FD_MEM_NTYPES) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid free-list mapping") /* Create the new class ID */ if((ret_value=H5FD_register(cls, sizeof(H5FD_class_t))) < 0) HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register file driver ID") done: FUNC_LEAVE_API(ret_value) } /* end H5FDregister() */ /*------------------------------------------------------------------------- * Function: H5FD_register * * Purpose: Registers a new file driver as a member of the virtual file * driver class. Certain fields of the class struct are * required and that is checked here so it doesn't have to be * checked every time the field is accessed. * * Return: Success: A file driver ID which is good until the * library is closed or the driver is * unregistered. * * Failure: A negative value. * * Programmer: Robb Matzke * Monday, July 26, 1999 * * Modifications: * Broke into public and internal routines & added 'size' * parameter to internal routine, which allows us to create * sub-classes of H5FD_class_t for internal support (see the * MPI drivers, etc.) * Quincey Koziol * January 30, 2004 * *------------------------------------------------------------------------- */ hid_t H5FD_register(const void *_cls, size_t size) { hid_t ret_value; const H5FD_class_t *cls=(const H5FD_class_t *)_cls; H5FD_class_t *saved=NULL; H5FD_mem_t type; FUNC_ENTER_NOAPI(H5FD_register, FAIL) /* Check arguments */ assert(cls); assert(cls->open && cls->close); assert(cls->get_eoa && cls->set_eoa); assert(cls->get_eof); assert(cls->read && cls->write); for (type=H5FD_MEM_DEFAULT; typefl_map[type]>=H5FD_MEM_NOLIST && cls->fl_map[type]cls); if(file->cls->sb_size) ret_value = (file->cls->sb_size)(file); done: FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_sb_encode * * Purpose: Encode driver-specific data into the output arguments. The * NAME is a nine-byte buffer which should get an * eight-character driver name and/or version followed by a null * terminator. The BUF argument is a buffer to receive the * encoded driver-specific data. The size of the BUF array is * the size returned by the H5FD_sb_size() call. * * Return: Success: Non-negative * * Failure: Negative * * Programmer: Robb Matzke * Monday, August 16, 1999 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5FD_sb_encode(H5FD_t *file, char *name/*out*/, uint8_t *buf) { herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_sb_encode, FAIL) assert(file && file->cls); if(file->cls->sb_encode && (file->cls->sb_encode)(file, name/*out*/, buf/*out*/) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver sb_encode request failed") done: FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_sb_decode * * Purpose: Decodes the driver information block. * * Return: Success: Non-negative * * Failure: Negative * * Programmer: Robb Matzke * Monday, August 16, 1999 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5FD_sb_decode(H5FD_t *file, const char *name, const uint8_t *buf) { herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_sb_decode, FAIL) assert(file && file->cls); if(file->cls->sb_decode && (file->cls->sb_decode)(file, name, buf) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver sb_decode request failed") done: FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_pl_copy * * Purpose: Copies the driver-specific part of the a property list. * This is common code, used by both the dataset transfer and * file access property list routines. * * Return: Success: non-negative * * Failure: negative * * Programmer: Quincey Koziol * Thursday, October 23, 2003 * * Modifications: * Pedro Vicente Nunes, Wednesday, July 26, 2006 * added a HGOTO_ERROR call in the case the copy function returns NULL * *------------------------------------------------------------------------- */ static herr_t H5FD_pl_copy(void *(*copy_func)(const void *), size_t pl_size, const void *old_pl, void **copied_pl) { void *new_pl = NULL; /* Copy of property list */ herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5FD_pl_copy) /* Copy old pl, if one exists */ if(old_pl) { /* Allow the driver to copy or do it ourselves */ if(copy_func) { new_pl = (copy_func)(old_pl); if(new_pl==NULL) HGOTO_ERROR(H5E_VFL, H5E_NOSPACE, FAIL, "property list copy failed") } else if(pl_size>0) { if((new_pl = H5MM_malloc(pl_size))==NULL) HGOTO_ERROR(H5E_VFL, H5E_NOSPACE, FAIL, "property list allocation failed") HDmemcpy(new_pl, old_pl, pl_size); } else HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "no way to copy driver property list") } /* end if */ /* Set copied value */ *copied_pl=new_pl; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_pl_copy() */ /*------------------------------------------------------------------------- * Function: H5FD_pl_close * * Purpose: Closes a driver for a property list * This is common code, used by both the dataset transfer and * file access property list routines. * * Return: Success: non-negative * Failure: negative * * Programmer: Quincey Koziol * Thursday, October 23, 2003 * *------------------------------------------------------------------------- */ static herr_t H5FD_pl_close(hid_t driver_id, herr_t (*free_func)(void *), void *pl) { herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5FD_pl_close) /* Allow driver to free or do it ourselves */ if(pl && free_func) { if((free_func)(pl) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver free request failed") } /* end if */ else H5MM_xfree(pl); /* Decrement reference count for driver */ if(H5I_dec_ref(driver_id) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "can't decrement reference count for driver") done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_pl_close() */ /*------------------------------------------------------------------------- * Function: H5FD_fapl_get * * Purpose: Gets the file access property list associated with a file. * Usually the file will copy what it needs from the original * file access property list when the file is created. The * purpose of this function is to create a new file access * property list based on the settings in the file, which may * have been modified from the original file access property * list. * * Return: Success: Pointer to a new file access property list * with all members copied. If the file is * closed then this property list lives on, and * vice versa. * * Failure: NULL, including when the file has no * properties. * * Programmer: Robb Matzke * Friday, August 13, 1999 * * Modifications: * *------------------------------------------------------------------------- */ void * H5FD_fapl_get(H5FD_t *file) { void *ret_value=NULL; FUNC_ENTER_NOAPI(H5FD_fapl_get, NULL) assert(file); if(file->cls->fapl_get) ret_value = (file->cls->fapl_get)(file); done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_fapl_get() */ /*------------------------------------------------------------------------- * Function: H5FD_fapl_open * * Purpose: Mark a driver as used by a file access property list * * Return: Success: non-negative * * Failure: negative * * Programmer: Quincey Koziol * Thursday, October 23, 2003 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5FD_fapl_open(H5P_genplist_t *plist, hid_t driver_id, const void *driver_info) { void *copied_driver_info; /* Temporary VFL driver info */ herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_fapl_open, FAIL) /* Increment the reference count on driver and copy driver info */ if(H5I_inc_ref(driver_id) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTINC, FAIL, "unable to increment ref count on VFL driver") if(H5FD_fapl_copy(driver_id, driver_info, &copied_driver_info) < 0) HGOTO_ERROR (H5E_PLIST, H5E_CANTCOPY, FAIL, "can't copy VFL driver info") /* Set the driver properties for the list */ if(H5P_set(plist, H5F_ACS_FILE_DRV_ID_NAME, &driver_id) < 0) HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set driver ID") if(H5P_set(plist, H5F_ACS_FILE_DRV_INFO_NAME, &copied_driver_info) < 0) HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set driver info") done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_fapl_open() */ /*------------------------------------------------------------------------- * Function: H5FD_fapl_copy * * Purpose: Copies the driver-specific part of the file access property * list. * * Return: Success: non-negative * * Failure: negative * * Programmer: Robb Matzke * Tuesday, August 3, 1999 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5FD_fapl_copy(hid_t driver_id, const void *old_fapl, void **copied_fapl) { H5FD_class_t *driver=NULL; herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_fapl_copy, FAIL) /* Check args */ if(NULL==(driver=H5I_object(driver_id))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a driver ID") /* Copy the file access property list */ if(H5FD_pl_copy(driver->fapl_copy,driver->fapl_size,old_fapl,copied_fapl) < 0) HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "can't copy driver file access property list") done: FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_fapl_close * * Purpose: Closes a driver for a dataset transfer property list * * Return: Success: non-negative * Failure: negative * * Programmer: Robb Matzke * Tuesday, August 3, 1999 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5FD_fapl_close(hid_t driver_id, void *fapl) { H5FD_class_t *driver = NULL; herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_fapl_close, FAIL) /* Check args */ if(driver_id > 0) { if(NULL == (driver = H5I_object(driver_id))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a driver ID") /* Close the driver for the property list */ if(H5FD_pl_close(driver_id, driver->fapl_free, fapl) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver fapl_free request failed") } /* end if */ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_fapl_close() */ /*------------------------------------------------------------------------- * Function: H5FD_dxpl_open * * Purpose: Mark a driver as used by a data transfer property list * * Return: Success: non-negative * * Failure: negative * * Programmer: Quincey Koziol * Thursday, October 23, 2003 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5FD_dxpl_open(H5P_genplist_t *plist, hid_t driver_id, const void *driver_info) { void *copied_driver_info; /* Temporary VFL driver info */ herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_dxpl_open, FAIL) /* Increment the reference count on the driver and copy the driver info */ if(H5I_inc_ref(driver_id) < 0) HGOTO_ERROR (H5E_DATASET, H5E_CANTINC, FAIL, "can't increment VFL driver ID") if(H5FD_dxpl_copy(driver_id, driver_info, &copied_driver_info) < 0) HGOTO_ERROR (H5E_DATASET, H5E_CANTCOPY, FAIL, "can't copy VFL driver") /* Set the driver information for the new property list */ if(H5P_set(plist, H5D_XFER_VFL_ID_NAME, &driver_id) < 0) HGOTO_ERROR (H5E_PLIST, H5E_CANTSET, FAIL, "can't set VFL driver ID") if(H5P_set(plist, H5D_XFER_VFL_INFO_NAME, &copied_driver_info) < 0) HGOTO_ERROR (H5E_PLIST, H5E_CANTSET, FAIL, "can't set VFL driver info") done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_dxpl_open() */ /*------------------------------------------------------------------------- * Function: H5FD_dxpl_copy * * Purpose: Copies the driver-specific part of the data transfer property * list. * * Return: Success: non-negative * * Failure: negative * * Programmer: Robb Matzke * Tuesday, August 3, 1999 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5FD_dxpl_copy(hid_t driver_id, const void *old_dxpl, void **copied_dxpl) { H5FD_class_t *driver=NULL; herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_dxpl_copy, FAIL) /* Check args */ if(NULL==(driver=H5I_object(driver_id))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a driver ID") /* Copy the file access property list */ if(H5FD_pl_copy(driver->dxpl_copy,driver->dxpl_size,old_dxpl,copied_dxpl) < 0) HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "can't copy driver data transfer property list") done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_dxpl_copy() */ /*------------------------------------------------------------------------- * Function: H5FD_dxpl_close * * Purpose: Closes a driver for a dataset transfer property list * * Return: Success: non-negative * Failure: negative * * Programmer: Robb Matzke * Tuesday, August 3, 1999 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5FD_dxpl_close(hid_t driver_id, void *dxpl) { H5FD_class_t *driver=NULL; herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_dxpl_close, FAIL) /* Check args */ if(driver_id>0) { if(NULL==(driver=H5I_object(driver_id))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a driver ID") /* Close the driver for the property list */ if(H5FD_pl_close(driver_id,driver->dxpl_free,dxpl) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver fapl_free request failed") } /* end if */ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_dxpl_close() */ /*------------------------------------------------------------------------- * Function: H5FDopen * * Purpose: Opens a file named NAME for the type(s) of access described * by the bit vector FLAGS according to a file access property * list FAPL_ID (which may be the constant H5P_DEFAULT). The * file should expect to handle format addresses in the range [0, * MAXADDR] (if MAXADDR is the undefined address then the caller * doesn't care about the address range). * * Possible values for the FLAGS bits are: * * H5F_ACC_RDWR: Open the file for read and write access. If * this bit is not set then open the file for * read only access. It is permissible to open a * file for read and write access when only read * access is requested by the library (the * library will never attempt to write to a file * which it opened with only read access). * * H5F_ACC_CREATE: Create the file if it doesn't already exist. * However, see H5F_ACC_EXCL below. * * H5F_ACC_TRUNC: Truncate the file if it already exists. This * is equivalent to deleting the file and then * creating a new empty file. * * H5F_ACC_EXCL: When used with H5F_ACC_CREATE, if the file * already exists then the open should fail. * Note that this is unsupported/broken with * some file drivers (e.g., sec2 across nfs) and * will contain a race condition when used to * perform file locking. * * The MAXADDR is the maximum address which will be requested by * the library during an allocation operation. Usually this is * the same value as the MAXADDR field of the class structure, * but it can be smaller if the driver is being used under some * other driver. * * Note that when the driver `open' callback gets control that * the public part of the file struct (the H5FD_t part) will be * incomplete and will be filled in after that callback returns. * * Return: Success: Pointer to a new file driver struct. * * Failure: NULL * * Programmer: Robb Matzke * Tuesday, July 27, 1999 * * Modifications: * *------------------------------------------------------------------------- */ H5FD_t * H5FDopen(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr) { H5FD_t *ret_value=NULL; FUNC_ENTER_API(H5FDopen, NULL) /* Check arguments */ if(H5P_DEFAULT == fapl_id) fapl_id = H5P_FILE_ACCESS_DEFAULT; else if(TRUE!=H5P_isa_class(fapl_id,H5P_FILE_ACCESS)) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a file access property list") if(NULL==(ret_value=H5FD_open(name, flags, fapl_id, maxaddr))) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, NULL, "unable to open file") done: FUNC_LEAVE_API(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_open * * Purpose: Private version of H5FDopen() * * Return: Success: Pointer to a new file driver struct * * Failure: NULL * * Programmer: Robb Matzke * Wednesday, August 4, 1999 * * Modifications: * * Raymond Lu * Tuesday, Oct 23, 2001 * Changed the file access list to the new generic property * list. * *------------------------------------------------------------------------- */ H5FD_t * H5FD_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr) { H5FD_class_t *driver; H5FD_t *file=NULL; hid_t driver_id = -1; hsize_t meta_block_size=0; hsize_t sdata_block_size=0; H5P_genplist_t *plist; /* Property list pointer */ H5FD_t *ret_value; FUNC_ENTER_NOAPI(H5FD_open, NULL) /* Get file access property list */ if(NULL == (plist = H5I_object(fapl_id))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a file access property list") if(0==maxaddr) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "zero format address range") if(H5P_get(plist, H5F_ACS_FILE_DRV_ID_NAME, &driver_id) < 0) HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get driver ID") /* Get driver info */ if(NULL==(driver=H5I_object(driver_id))) HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, NULL, "invalid driver ID in file access property list") if(NULL==driver->open) HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, NULL, "file driver has no `open' method") /* Dispatch to file driver */ if(HADDR_UNDEF==maxaddr) maxaddr = driver->maxaddr; if(NULL==(file=(driver->open)(name, flags, fapl_id, maxaddr))) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, NULL, "open failed") /* * Fill in public fields. We must increment the reference count on the * driver ID to prevent it from being freed while this file is open. */ file->driver_id = driver_id; if(H5I_inc_ref(file->driver_id) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINC, NULL, "unable to increment ref count on VFL driver") file->cls = driver; file->maxaddr = maxaddr; HDmemset(file->fl, 0, sizeof(file->fl)); if(H5P_get(plist, H5F_ACS_META_BLOCK_SIZE_NAME, &(meta_block_size)) < 0) HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get meta data block size") file->meta_aggr.feature_flag = H5FD_FEAT_AGGREGATE_METADATA; file->meta_aggr.alloc_size = meta_block_size; if(H5P_get(plist, H5F_ACS_SDATA_BLOCK_SIZE_NAME, &(sdata_block_size)) < 0) HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get 'small data' block size") file->sdata_aggr.feature_flag = H5FD_FEAT_AGGREGATE_SMALLDATA; file->sdata_aggr.alloc_size = sdata_block_size; file->accum_loc = HADDR_UNDEF; if(H5P_get(plist, H5F_ACS_ALIGN_THRHD_NAME, &(file->threshold)) < 0) HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get alignment threshold") if(H5P_get(plist, H5F_ACS_ALIGN_NAME, &(file->alignment)) < 0) HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get alignment") /* Retrieve the VFL driver feature flags */ if(H5FD_query(file, &(file->feature_flags)) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, NULL, "unable to query file driver") /* Increment the global serial number & assign it to this H5FD_t object */ if(++file_serial_no==0) { /* (Just error out if we wrap around for now...) */ HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, NULL, "unable to get file serial number") } /* end if */ file->fileno=file_serial_no; /* Set return value */ ret_value=file; done: /* Can't cleanup 'file' information, since we don't know what type it is */ FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FDclose * * Purpose: Closes the file by calling the driver `close' callback, which * should free all driver-private data and free the file struct. * Note that the public part of the file struct (the H5FD_t part) * will be all zero during the driver close callback like during * the `open' callback. * * Return: Success: Non-negative * * Failure: Negative * * Programmer: Robb Matzke * Tuesday, July 27, 1999 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5FDclose(H5FD_t *file) { herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_API(H5FDclose, FAIL) H5TRACE1("e", "*x", file); if(!file || !file->cls) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer") if(H5FD_close(file) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "unable to close file") done: FUNC_LEAVE_API(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_close * * Purpose: Private version of H5FDclose() * * Return: Success: Non-negative * * Failure: Negative * * Programmer: Robb Matzke * Wednesday, August 4, 1999 * * Modifications: * Robb Matzke, 2000-11-10 * Removed a call to set *file to all zero because the struct * has already been freed by the close method. This fixes a write * to freed memory. * * Bill Wendling, 2003-02-17 * Split out the freeing of the freelist from this function * so that the Flexible PHDF5 stuff can call it without * having to call H5FD_close(). *------------------------------------------------------------------------- */ herr_t H5FD_close(H5FD_t *file) { const H5FD_class_t *driver; herr_t ret_value = SUCCEED; FUNC_ENTER_NOAPI(H5FD_close, FAIL) /* check args */ HDassert(file && file->cls); /* Free the freelist */ if(H5FD_free_freelist(file) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTFREE, FAIL, "can't release file space free list") /* Prepare to close file by clearing all public fields */ driver = file->cls; if(H5I_dec_ref(file->driver_id) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "can't close driver ID") /* * Dispatch to the driver for actual close. If the driver fails to * close the file then the file will be in an unusable state. */ HDassert(driver->close); if((driver->close)(file) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "close failed") done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_close() */ /*------------------------------------------------------------------------- * Function: H5FDcmp * * Purpose: Compare the keys of two files using the file driver callback * if the files belong to the same driver, otherwise sort the * files by driver class pointer value. * * Return: Success: A value like strcmp() * * Failure: Must never fail. If both file handles are * invalid then they compare equal. If one file * handle is invalid then it compares less than * the other. If both files belong to the same * driver and the driver doesn't provide a * comparison callback then the file pointers * themselves are compared. * * Programmer: Robb Matzke * Tuesday, July 27, 1999 * * Modifications: * *------------------------------------------------------------------------- */ int H5FDcmp(const H5FD_t *f1, const H5FD_t *f2) { int ret_value; FUNC_ENTER_API(H5FDcmp, -1) /*return value is arbitrary*/ H5TRACE2("Is", "*x*x", f1, f2); ret_value = H5FD_cmp(f1, f2); done: FUNC_LEAVE_API(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_cmp * * Purpose: Private version of H5FDcmp() * * Return: Success: A value like strcmp() * * Failure: Must never fail. * * Programmer: Robb Matzke * Wednesday, August 4, 1999 * * Modifications: * *------------------------------------------------------------------------- */ int H5FD_cmp(const H5FD_t *f1, const H5FD_t *f2) { int ret_value; FUNC_ENTER_NOAPI(H5FD_cmp, -1) /*return value is arbitrary*/ if((!f1 || !f1->cls) && (!f2 || !f2->cls)) HGOTO_DONE(0) if(!f1 || !f1->cls) HGOTO_DONE(-1) if(!f2 || !f2->cls) HGOTO_DONE(1) if(f1->cls < f2->cls) HGOTO_DONE(-1) if(f1->cls > f2->cls) HGOTO_DONE(1) /* Files are same driver; no cmp callback */ if(!f1->cls->cmp) { if(f1f2) HGOTO_DONE(1) HGOTO_DONE(0) } ret_value = (f1->cls->cmp)(f1, f2); done: FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FDquery * * Purpose: Query a VFL driver for its feature flags. (listed in H5FDpublic.h) * * Return: Success: non-negative * * Failure: negative * * Programmer: Quincey Koziol * Friday, August 25, 2000 * * Modifications: * *------------------------------------------------------------------------- */ int H5FDquery(const H5FD_t *f, unsigned long *flags/*out*/) { int ret_value; FUNC_ENTER_API(H5FDquery, FAIL) H5TRACE2("Is", "*xx", f, flags); assert(f); assert(flags); ret_value = H5FD_query(f, flags); done: FUNC_LEAVE_API(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_query * * Purpose: Private version of H5FDquery() * * Return: Success: non-negative * * Failure: negative * * Programmer: Quincey Koziol * Friday, August 25, 2000 * * Modifications: * *------------------------------------------------------------------------- */ int H5FD_query(const H5FD_t *f, unsigned long *flags/*out*/) { int ret_value=0; FUNC_ENTER_NOAPI(H5FD_query, FAIL) assert(f); assert(flags); /* Check for query driver and call it */ if(f->cls->query) ret_value = (f->cls->query)(f, flags); else *flags=0; done: FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FDalloc * * Purpose: Allocates SIZE bytes of memory from the FILE. The memory will * be used according to the allocation class TYPE. First we try * to satisfy the request from one of the free lists, according * to the free list map provided by the driver. The free list * array has one entry for each request type and the value of * that array element can be one of four possibilities: * * It can be the constant H5FD_MEM_DEFAULT (or zero) which * indicates that the identity mapping is used. In other * words, the request type maps to its own free list. * * It can be the request type itself, which has the same * effect as the H5FD_MEM_DEFAULT value above. * * It can be the ID for another request type, which * indicates that the free list for the specified type * should be used instead. * * It can be the constant H5FD_MEM_NOLIST which means that * no free list should be used for this type of request. * * If the request cannot be satisfied from a free list then * either the driver's `alloc' callback is invoked (if one was * supplied) or the end-of-address marker is extended. The * `alloc' callback is always called with the same arguments as * the H5FDalloc(). * * Return: Success: The format address of the new file memory. * * Failure: The undefined address HADDR_UNDEF * * Programmer: Robb Matzke * Tuesday, July 27, 1999 * * Modifications: * *------------------------------------------------------------------------- */ haddr_t H5FDalloc(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, hsize_t size) { haddr_t ret_value = HADDR_UNDEF; FUNC_ENTER_API(H5FDalloc, HADDR_UNDEF) H5TRACE4("a", "*xMtih", file, type, dxpl_id, size); /* Check args */ if(!file || !file->cls) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "invalid file pointer") if(type < H5FD_MEM_DEFAULT || type >= H5FD_MEM_NTYPES) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "invalid request type") if(size == 0) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "zero-size request") if(H5P_DEFAULT == dxpl_id) dxpl_id= H5P_DATASET_XFER_DEFAULT; else if(TRUE != H5P_isa_class(dxpl_id,H5P_DATASET_XFER)) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, HADDR_UNDEF, "not a data transfer property list") /* Do the real work */ if(HADDR_UNDEF == (ret_value = H5FD_alloc(file, type, dxpl_id, size))) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "unable to allocate file memory") done: FUNC_LEAVE_API(ret_value) } /*------------------------------------------------------------------------- * Function: H5FDfree * * Purpose: Frees format addresses starting with ADDR and continuing for * SIZE bytes in the file FILE. The type of space being freed is * specified by TYPE, which is mapped to a free list as * described for the H5FDalloc() function above. If the request * doesn't map to a free list then either the application `free' * callback is invoked (if defined) or the memory is leaked. * * Return: Success: Non-negative * * Failure: Negative * * Programmer: Robb Matzke * Wednesday, July 28, 1999 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5FDfree(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, hsize_t size) { herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_API(H5FDfree, FAIL) H5TRACE5("e", "*xMtiah", file, type, dxpl_id, addr, size); /* Check args */ if(!file || !file->cls) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer") if(type < H5FD_MEM_DEFAULT || type >= H5FD_MEM_NTYPES) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid request type") if(H5P_DEFAULT == dxpl_id) dxpl_id= H5P_DATASET_XFER_DEFAULT; else if(TRUE!=H5P_isa_class(dxpl_id,H5P_DATASET_XFER)) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data transfer property list") /* Do the real work */ if(H5FD_free(file, type, dxpl_id, addr, size) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTFREE, FAIL, "file deallocation request failed") done: FUNC_LEAVE_API(ret_value) } /* end H5FDfree() */ /*------------------------------------------------------------------------- * Function: H5FDrealloc * * Purpose: Changes the size of an allocated chunk of memory, possibly * also changing its location in the file. * * Return: Success: New address of the block of memory, not * necessarily the same as the original address. * * Failure: HADDR_UNDEF * * Programmer: Robb Matzke * Tuesday, August 3, 1999 * * Modifications: * *------------------------------------------------------------------------- */ haddr_t H5FDrealloc(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t old_addr, hsize_t old_size, hsize_t new_size) { haddr_t ret_value = HADDR_UNDEF; FUNC_ENTER_API(H5FDrealloc, HADDR_UNDEF) H5TRACE6("a", "*xMtiahh", file, type, dxpl_id, old_addr, old_size, new_size); /* Check args */ if(H5P_DEFAULT == dxpl_id) dxpl_id = H5P_DATASET_XFER_DEFAULT; else if(TRUE != H5P_isa_class(dxpl_id, H5P_DATASET_XFER)) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, HADDR_UNDEF, "not a data transfer property list") if(HADDR_UNDEF == (ret_value = H5FD_realloc(file, type, dxpl_id, old_addr, old_size, new_size))) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "file reallocation request failed") done: FUNC_LEAVE_API(ret_value) } /* end H5FDrealloc() */ /*------------------------------------------------------------------------- * Function: H5FDget_eoa * * Purpose: Returns the address of the first byte after the last * allocated memory in the file. * * Return: Success: First byte after allocated memory. * * Failure: HADDR_UNDEF * * Programmer: Robb Matzke * Friday, July 30, 1999 * * Modifications: * Raymond Lu * 21 Dec. 2006 * Added the parameter TYPE. It's only used for MULTI driver. * *------------------------------------------------------------------------- */ haddr_t H5FDget_eoa(H5FD_t *file, H5FD_mem_t type) { haddr_t ret_value; FUNC_ENTER_API(H5FDget_eoa, HADDR_UNDEF) H5TRACE2("a", "*xMt", file, type); /* Check args */ if(!file || !file->cls) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "invalid file pointer") if(type= H5FD_MEM_NTYPES) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "invalid file type") /* The real work */ if(HADDR_UNDEF==(ret_value=H5FD_get_eoa(file, type))) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "file get eoa request failed") done: FUNC_LEAVE_API(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_get_eoa * * Purpose: Private version of H5FDget_eoa() * * Return: Success: First byte after allocated memory. * * Failure: HADDR_UNDEF * * Programmer: Robb Matzke * Wednesday, August 4, 1999 * * Modifications: * Raymond Lu * 21 Dec. 2006 * Added the parameter TYPE. It's only used for MULTI driver. * *------------------------------------------------------------------------- */ haddr_t H5FD_get_eoa(const H5FD_t *file, H5FD_mem_t type) { haddr_t ret_value; FUNC_ENTER_NOAPI(H5FD_get_eoa, HADDR_UNDEF) assert(file && file->cls); /* Dispatch to driver */ if(HADDR_UNDEF==(ret_value=(file->cls->get_eoa)(file, type))) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "driver get_eoa request failed") done: FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FDset_eoa * * Purpose: Set the end-of-address marker for the file. The ADDR is the * address of the first byte past the last allocated byte of the * file. This function is called from two places: * * It is called after an existing file is opened in order to * "allocate" enough space to read the superblock and then * to "allocate" the entire hdf5 file based on the contents * of the superblock. * * It is called during file memory allocation if the * allocation request cannot be satisfied from the free list * and the driver didn't supply an allocation callback. * * Return: Success: Non-negative * * Failure: Negative, no side effect * * Programmer: Robb Matzke * Friday, July 30, 1999 * * Modifications: * Raymond Lu * 21 Dec. 2006 * Added the parameter TYPE. It's only used for MULTI driver. * *------------------------------------------------------------------------- */ herr_t H5FDset_eoa(H5FD_t *file, H5FD_mem_t type, haddr_t addr) { herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_API(H5FDset_eoa, FAIL) H5TRACE3("e", "*xMta", file, type, addr); /* Check args */ if(!file || !file->cls) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer") if(type= H5FD_MEM_NTYPES) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file type") if(!H5F_addr_defined(addr) || addr>file->maxaddr) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid end-of-address value") /* The real work */ if(H5FD_set_eoa(file, type, addr) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "file set eoa request failed") done: FUNC_LEAVE_API(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_set_eoa * * Purpose: Private version of H5FDset_eoa() * * Return: Success: Non-negative * * Failure: Negative, no side effect * * Programmer: Robb Matzke * Wednesday, August 4, 1999 * * Modifications: * Raymond Lu * 21 Dec. 2006 * Added the parameter TYPE. It's only used for MULTI driver. * *------------------------------------------------------------------------- */ herr_t H5FD_set_eoa(H5FD_t *file, H5FD_mem_t UNUSED type, haddr_t addr) { herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_set_eoa, FAIL) assert(file && file->cls); assert(H5F_addr_defined(addr) && addr<=file->maxaddr); /* Dispatch to driver */ if((file->cls->set_eoa)(file, type, addr) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver set_eoa request failed") done: FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FDget_eof * * Purpose: Returns the end-of-file address, which is the greater of the * end-of-format address and the actual EOF marker. This * function is called after an existing file is opened in order * for the library to learn the true size of the underlying file * and to determine whether the hdf5 data has been truncated. * * It is also used when a file is first opened to learn whether * the file is empty or not. * * It is permissible for the driver to return the maximum address * for the file size if the file is not empty. * * Return: Success: The EOF address. * * Failure: HADDR_UNDEF * * Programmer: Robb Matzke * Thursday, July 29, 1999 * * Modifications: * *------------------------------------------------------------------------- */ haddr_t H5FDget_eof(H5FD_t *file) { haddr_t ret_value; FUNC_ENTER_API(H5FDget_eof, HADDR_UNDEF) H5TRACE1("a", "*x", file); /* Check arguments */ if(!file || !file->cls) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, HADDR_UNDEF, "invalid file pointer") /* The real work */ if(HADDR_UNDEF==(ret_value=H5FD_get_eof(file))) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "file get eof request failed") done: FUNC_LEAVE_API(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_get_eof * * Purpose: Private version of H5FDget_eof() * * Return: Success: The EOF address. * * Failure: HADDR_UNDEF * * Programmer: Robb Matzke * Wednesday, August 4, 1999 * * Modifications: * *------------------------------------------------------------------------- */ haddr_t H5FD_get_eof(const H5FD_t *file) { haddr_t ret_value; FUNC_ENTER_NOAPI(H5FD_get_eof, HADDR_UNDEF) assert(file && file->cls); /* Dispatch to driver */ if(file->cls->get_eof) { if(HADDR_UNDEF==(ret_value=(file->cls->get_eof)(file))) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "driver get_eof request failed") } else { ret_value = file->maxaddr; } done: FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FDread * * Purpose: Reads SIZE bytes from FILE beginning at address ADDR * according to the data transfer property list DXPL_ID (which may * be the constant H5P_DEFAULT). The result is written into the * buffer BUF. * * Return: Success: Non-negative. The read result is written into * the BUF buffer which should be allocated by * the caller. * * Failure: Negative. The contents of BUF is undefined. * * Programmer: Robb Matzke * Thursday, July 29, 1999 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5FDread(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t size, void *buf/*out*/) { herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_API(H5FDread, FAIL) H5TRACE6("e", "*xMtiazx", file, type, dxpl_id, addr, size, buf); /* Check args */ if(!file || !file->cls) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer") /* Get the default dataset transfer property list if the user didn't provide one */ if(H5P_DEFAULT == dxpl_id) dxpl_id= H5P_DATASET_XFER_DEFAULT; else if(TRUE!=H5P_isa_class(dxpl_id,H5P_DATASET_XFER)) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data transfer property list") if(!buf) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null result buffer") /* Do the real work */ if(H5FD_read(file, type, dxpl_id, addr, size, buf) < 0) HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "file read request failed") done: FUNC_LEAVE_API(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_read * * Purpose: Private version of H5FDread() * * Return: Success: Non-negative * * Failure: Negative * * Programmer: Robb Matzke * Wednesday, August 4, 1999 * * Modifications: * Albert Cheng, 2000-11-21 * Disable the code that does early return when size==0 for * Parallel mode since a collective call would require the process * to continue on with "nothing" to transfer. * *------------------------------------------------------------------------- */ herr_t H5FD_read(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t size, void *buf/*out*/) { herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_read, FAIL) assert(file && file->cls); assert(H5I_GENPROP_LST==H5I_get_type(dxpl_id)); assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER)); assert(buf); #ifndef H5_HAVE_PARALLEL /* Do not return early for Parallel mode since the I/O could be a */ /* collective transfer. */ /* The no-op case */ if(0==size) HGOTO_DONE(SUCCEED) #endif /* H5_HAVE_PARALLEL */ /* Check if this information is in the metadata accumulator */ if((file->feature_flags&H5FD_FEAT_ACCUMULATE_METADATA) && type!=H5FD_MEM_DRAW) { /* Current read overlaps with metadata accumulator */ if(H5F_addr_overlap(addr,size,file->accum_loc,file->accum_size)) { unsigned char *read_buf=(unsigned char *)buf; /* Pointer to the buffer being read in */ size_t amount_read; /* Amount to read at a time */ #ifndef NDEBUG hsize_t tempamount_read; /* Amount to read at a time */ #endif /* NDEBUG */ hsize_t read_off; /* Offset to read from */ /* Double check that we aren't reading raw data */ assert(type!=H5FD_MEM_DRAW); /* Read the part before the metadata accumulator */ if(addraccum_loc) { /* Set the amount to read */ H5_ASSIGN_OVERFLOW(amount_read,file->accum_loc-addr,hsize_t,size_t); /* Dispatch to driver */ if((file->cls->read)(file, type, dxpl_id, addr, amount_read, read_buf) < 0) HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "driver read request failed") /* Adjust the buffer, address & size */ read_buf+=amount_read; addr+=amount_read; size-=amount_read; } /* end if */ /* Copy the part overlapping the metadata accumulator */ if(size>0 && (addr>=file->accum_loc && addr<(file->accum_loc+file->accum_size))) { /* Set the offset to "read" from */ read_off=addr-file->accum_loc; /* Set the amount to "read" */ #ifndef NDEBUG tempamount_read = file->accum_size-read_off; H5_CHECK_OVERFLOW(tempamount_read,hsize_t,size_t); amount_read = MIN(size, (size_t)tempamount_read); #else /* NDEBUG */ amount_read = MIN(size, (size_t)(file->accum_size-read_off)); #endif /* NDEBUG */ /* Copy the data out of the buffer */ HDmemcpy(read_buf,file->meta_accum+read_off,amount_read); /* Adjust the buffer, address & size */ read_buf+=amount_read; addr+=amount_read; size-=amount_read; } /* end if */ /* Read the part after the metadata accumulator */ if(size>0 && addr>=(file->accum_loc+file->accum_size)) { /* Dispatch to driver */ if((file->cls->read)(file, type, dxpl_id, addr, size, read_buf) < 0) HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "driver read request failed") /* Adjust the buffer, address & size */ read_buf+=size; addr+=size; size-=size; } /* end if */ /* Make certain we've read it all */ assert(size==0); } /* end if */ /* Current read doesn't overlap with metadata accumulator, read it into accumulator */ else { /* Only update the metadata accumulator if it is not dirty or if * we are allowed to write the accumulator out during reads (when * it is dirty) */ if(file->feature_flags&H5FD_FEAT_ACCUMULATE_METADATA_READ || !file->accum_dirty) { /* Flush current contents, if dirty */ if(file->accum_dirty) { if((file->cls->write)(file, H5FD_MEM_DEFAULT, dxpl_id, file->accum_loc, file->accum_size, file->meta_accum) < 0) HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "driver write request failed") /* Reset accumulator dirty flag */ file->accum_dirty=FALSE; } /* end if */ /* Cache the new piece of metadata */ /* Check if we need to resize the buffer */ if(size>file->accum_buf_size) { /* Grow the metadata accumulator buffer */ if((file->meta_accum=H5FL_BLK_REALLOC(meta_accum,file->meta_accum,size))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate metadata accumulator buffer") /* Note the new buffer size */ file->accum_buf_size=size; } /* end if */ else { /* Check if we should shrink the accumulator buffer */ if(size<(file->accum_buf_size/H5FD_ACCUM_THROTTLE) && file->accum_buf_size>H5FD_ACCUM_THRESHOLD) { size_t new_size=(file->accum_buf_size/H5FD_ACCUM_THROTTLE); /* New size of accumulator buffer */ /* Shrink the accumulator buffer */ if((file->meta_accum=H5FL_BLK_REALLOC(meta_accum,file->meta_accum,new_size))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate metadata accumulator buffer") /* Note the new buffer size */ file->accum_buf_size=new_size; } /* end if */ } /* end else */ /* Update accumulator information */ file->accum_loc=addr; file->accum_size=size; file->accum_dirty=FALSE; /* Read into accumulator */ if((file->cls->read)(file, H5FD_MEM_DEFAULT, dxpl_id, file->accum_loc, file->accum_size, file->meta_accum) < 0) HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "driver read request failed") /* Copy into buffer */ HDmemcpy(buf,file->meta_accum,size); } /* end if */ else { /* Dispatch to driver */ if((file->cls->read)(file, type, dxpl_id, addr, size, buf) < 0) HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "driver read request failed") } /* end else */ } /* end else */ } /* end if */ else { /* Dispatch to driver */ if((file->cls->read)(file, type, dxpl_id, addr, size, buf) < 0) HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "driver read request failed") } /* end else */ done: FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FDwrite * * Purpose: Writes SIZE bytes to FILE beginning at address ADDR according * to the data transfer property list DXPL_ID (which may be the * constant H5P_DEFAULT). The bytes to be written come from the * buffer BUF. * * Return: Success: Non-negative * * Failure: Negative * * Programmer: Robb Matzke * Thursday, July 29, 1999 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5FDwrite(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t size, const void *buf) { herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_API(H5FDwrite, FAIL) H5TRACE6("e", "*xMtiaz*x", file, type, dxpl_id, addr, size, buf); /* Check args */ if(!file || !file->cls) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer") /* Get the default dataset transfer property list if the user didn't provide one */ if(H5P_DEFAULT == dxpl_id) dxpl_id= H5P_DATASET_XFER_DEFAULT; else if(TRUE!=H5P_isa_class(dxpl_id,H5P_DATASET_XFER)) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data transfer property list") if(!buf) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null buffer") /* The real work */ if(H5FD_write(file, type, dxpl_id, addr, size, buf) < 0) HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "file write request failed") done: FUNC_LEAVE_API(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_write * * Purpose: Private version of H5FDwrite() * * Return: Success: Non-negative * * Failure: Negative * * Programmer: Robb Matzke * Wednesday, August 4, 1999 * * Modifications: * Albert Cheng, 2000-11-21 * Disable the code that does early return when size==0 for * Parallel mode since a collective call would require the process * to continue on with "nothing" to transfer. * *------------------------------------------------------------------------- */ herr_t H5FD_write(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t size, const void *buf) { size_t new_size; /* New size of the accumulator buffer */ size_t old_offset; /* Offset of old data within the accumulator buffer */ herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_write, FAIL) assert(file && file->cls); assert(H5I_GENPROP_LST==H5I_get_type(dxpl_id)); assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER)); assert(buf); #ifndef H5_HAVE_PARALLEL /* Do not return early for Parallel mode since the I/O could be a */ /* collective transfer. */ /* The no-op case */ if(0==size) HGOTO_DONE(SUCCEED) #endif /* H5_HAVE_PARALLEL */ /* Check for accumulating metadata */ if((file->feature_flags&H5FD_FEAT_ACCUMULATE_METADATA) && type!=H5FD_MEM_DRAW) { /* Check if there is already metadata in the accumulator */ if(file->accum_size>0) { /* Check if the piece of metadata being written adjoins or is inside the metadata accumulator */ if((addr>=file->accum_loc && addr<=(file->accum_loc+file->accum_size)) || ((addr+size)>file->accum_loc && (addr+size)<=(file->accum_loc+file->accum_size)) || (addraccum_loc && (addr+size)>=file->accum_loc)) { /* Check if the new metadata adjoins the beginning of the current accumulator */ if((addr+size)==file->accum_loc) { /* Check if we need more buffer space */ if((size+file->accum_size)>file->accum_buf_size) { /* Adjust the buffer size, by doubling it */ file->accum_buf_size = MAX(file->accum_buf_size*2,size+file->accum_size); /* Reallocate the metadata accumulator buffer */ if((file->meta_accum=H5FL_BLK_REALLOC(meta_accum,file->meta_accum,file->accum_buf_size))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate metadata accumulator buffer") #ifdef H5_CLEAR_MEMORY HDmemset(file->meta_accum + file->accum_size, 0, (file->accum_buf_size - (file->accum_size + size))); #endif /* H5_CLEAR_MEMORY */ } /* end if */ /* Move the existing metadata to the proper location */ HDmemmove(file->meta_accum+size,file->meta_accum,file->accum_size); /* Copy the new metadata at the front */ HDmemcpy(file->meta_accum,buf,size); /* Set the new size & location of the metadata accumulator */ file->accum_loc=addr; file->accum_size=file->accum_size+size; /* Mark it as written to */ file->accum_dirty=TRUE; } /* end if */ /* Check if the new metadata adjoins the end of the current accumulator */ else if(addr==(file->accum_loc+file->accum_size)) { /* Check if we need more buffer space */ if((size+file->accum_size)>file->accum_buf_size) { /* Adjust the buffer size, by doubling it */ file->accum_buf_size = MAX(file->accum_buf_size*2,size+file->accum_size); /* Reallocate the metadata accumulator buffer */ if((file->meta_accum=H5FL_BLK_REALLOC(meta_accum,file->meta_accum,file->accum_buf_size))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate metadata accumulator buffer") #ifdef H5_CLEAR_MEMORY HDmemset(file->meta_accum + file->accum_size + size, 0, (file->accum_buf_size - (file->accum_size + size))); #endif /* H5_CLEAR_MEMORY */ } /* end if */ /* Copy the new metadata to the end */ HDmemcpy(file->meta_accum+file->accum_size,buf,size); /* Set the new size of the metadata accumulator */ file->accum_size=file->accum_size+size; /* Mark it as written to */ file->accum_dirty=TRUE; } /* end if */ /* Check if the new metadata is entirely within the current accumulator */ else if(addr>=file->accum_loc && (addr+size)<=(file->accum_loc+file->accum_size)) { /* Copy the new metadata to the proper location within the accumulator */ HDmemcpy(file->meta_accum+(addr-file->accum_loc),buf,size); /* Mark it as written to */ file->accum_dirty=TRUE; } /* end if */ /* Check if the new metadata overlaps the beginning of the current accumulator */ else if(addraccum_loc && (addr+size)<=(file->accum_loc+file->accum_size)) { /* Calculate the new accumulator size, based on the amount of overlap */ H5_ASSIGN_OVERFLOW(new_size,(file->accum_loc-addr)+file->accum_size,hsize_t,size_t); /* Check if we need more buffer space */ if(new_size>file->accum_buf_size) { /* Adjust the buffer size, by doubling it */ file->accum_buf_size = MAX(file->accum_buf_size*2,new_size); /* Reallocate the metadata accumulator buffer */ if((file->meta_accum=H5FL_BLK_REALLOC(meta_accum,file->meta_accum,file->accum_buf_size))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate metadata accumulator buffer") #ifdef H5_CLEAR_MEMORY HDmemset(file->meta_accum + file->accum_size, 0, (file->accum_buf_size - file->accum_size)); #endif /* H5_CLEAR_MEMORY */ } /* end if */ /* Calculate the proper offset of the existing metadata */ H5_ASSIGN_OVERFLOW(old_offset,(addr+size)-file->accum_loc,hsize_t,size_t); /* Move the existing metadata to the proper location */ HDmemmove(file->meta_accum+size,file->meta_accum+old_offset,(file->accum_size-old_offset)); /* Copy the new metadata at the front */ HDmemcpy(file->meta_accum,buf,size); /* Set the new size & location of the metadata accumulator */ file->accum_loc=addr; file->accum_size=new_size; /* Mark it as written to */ file->accum_dirty=TRUE; } /* end if */ /* Check if the new metadata overlaps the end of the current accumulator */ else if(addr>=file->accum_loc && (addr+size)>(file->accum_loc+file->accum_size)) { /* Calculate the new accumulator size, based on the amount of overlap */ H5_ASSIGN_OVERFLOW(new_size,(addr-file->accum_loc)+size,hsize_t,size_t); /* Check if we need more buffer space */ if(new_size>file->accum_buf_size) { /* Adjust the buffer size, by doubling it */ file->accum_buf_size = MAX(file->accum_buf_size*2,new_size); /* Reallocate the metadata accumulator buffer */ if((file->meta_accum=H5FL_BLK_REALLOC(meta_accum,file->meta_accum,file->accum_buf_size))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate metadata accumulator buffer") #ifdef H5_CLEAR_MEMORY HDmemset(file->meta_accum + file->accum_size, 0, (file->accum_buf_size - file->accum_size)); #endif /* H5_CLEAR_MEMORY */ } /* end if */ /* Copy the new metadata to the end */ HDmemcpy(file->meta_accum+(addr-file->accum_loc),buf,size); /* Set the new size & location of the metadata accumulator */ file->accum_size=new_size; /* Mark it as written to */ file->accum_dirty=TRUE; } /* end if */ else { assert(0 && "New metadata overlapped both beginning and end of existing metadata accumulator!"); } /* end else */ } /* end if */ /* New piece of metadata doesn't adjoin or overlap the existing accumulator */ else { /* Write out the existing metadata accumulator, with dispatch to driver */ if(file->accum_dirty) { if((file->cls->write)(file, H5FD_MEM_DEFAULT, dxpl_id, file->accum_loc, file->accum_size, file->meta_accum) < 0) HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "driver write request failed") /* Reset accumulator dirty flag */ file->accum_dirty=FALSE; } /* end if */ /* Cache the new piece of metadata */ /* Check if we need to resize the buffer */ if(size>file->accum_buf_size) { /* Grow the metadata accumulator buffer */ if((file->meta_accum=H5FL_BLK_REALLOC(meta_accum,file->meta_accum,size))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate metadata accumulator buffer") /* Note the new buffer size */ file->accum_buf_size=size; #ifdef H5_CLEAR_MEMORY { size_t clear_size = MAX(file->accum_size, size); HDmemset(file->meta_accum + clear_size, 0, (file->accum_buf_size - clear_size)); } #endif /* H5_CLEAR_MEMORY */ } /* end if */ else { /* Check if we should shrink the accumulator buffer */ if(size<(file->accum_buf_size/H5FD_ACCUM_THROTTLE) && file->accum_buf_size>H5FD_ACCUM_THRESHOLD) { size_t tmp_size=(file->accum_buf_size/H5FD_ACCUM_THROTTLE); /* New size of accumulator buffer */ /* Shrink the accumulator buffer */ if((file->meta_accum=H5FL_BLK_REALLOC(meta_accum,file->meta_accum,tmp_size))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate metadata accumulator buffer") /* Note the new buffer size */ file->accum_buf_size=tmp_size; } /* end if */ } /* end else */ /* Update the metadata accumulator information */ file->accum_loc=addr; file->accum_size=size; file->accum_dirty=TRUE; /* Store the piece of metadata in the accumulator */ HDmemcpy(file->meta_accum,buf,size); } /* end else */ } /* end if */ /* No metadata in the accumulator, grab this piece and keep it */ else { /* Check if we need to reallocate the buffer */ if(size>file->accum_buf_size) { /* Reallocate the metadata accumulator buffer */ if((file->meta_accum=H5FL_BLK_REALLOC(meta_accum,file->meta_accum,size))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate metadata accumulator buffer") /* Note the new buffer size */ file->accum_buf_size=size; } /* end if */ /* Update the metadata accumulator information */ file->accum_loc=addr; file->accum_size=size; file->accum_dirty=TRUE; /* Store the piece of metadata in the accumulator */ HDmemcpy(file->meta_accum,buf,size); } /* end else */ } /* end if */ else { /* Dispatch to driver */ if((file->cls->write)(file, type, dxpl_id, addr, size, buf) < 0) HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "driver write request failed") } /* end else */ done: FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FDflush * * Purpose: Notify driver to flush all cached data. If the driver has no * flush method then nothing happens. * * Return: Success: Non-negative * * Failure: Negative * * Programmer: Robb Matzke * Thursday, July 29, 1999 * * Modifications: * Quincey Koziol, May 20, 2002 * Added 'closing' parameter * *------------------------------------------------------------------------- */ herr_t H5FDflush(H5FD_t *file, hid_t dxpl_id, unsigned closing) { herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_API(H5FDflush, FAIL) H5TRACE3("e", "*xiIu", file, dxpl_id, closing); /* Check args */ if(!file || !file->cls) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file pointer") if(H5P_DEFAULT == dxpl_id) dxpl_id= H5P_DATASET_XFER_DEFAULT; else if(TRUE!=H5P_isa_class(dxpl_id,H5P_DATASET_XFER)) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data transfer property list") /* Do the real work */ if(H5FD_flush(file,dxpl_id,closing) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "file flush request failed") done: FUNC_LEAVE_API(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_flush * * Purpose: Private version of H5FDflush() * * Return: Success: Non-negative * * Failure: Negative * * Programmer: Robb Matzke * Wednesday, August 4, 1999 * * Modifications: * Quincey Koziol, May 20, 2002 * Added 'closing' parameter * *------------------------------------------------------------------------- */ herr_t H5FD_flush(H5FD_t *file, hid_t dxpl_id, unsigned closing) { herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_flush, FAIL) assert(file && file->cls); /* Check if we need to flush out the metadata accumulator */ if((file->feature_flags&H5FD_FEAT_ACCUMULATE_METADATA) && file->accum_dirty && file->accum_size>0) { /* Flush the metadata contents */ /* Not certain if the type and dxpl should be the way they are... -QAK */ if((file->cls->write)(file, H5FD_MEM_DEFAULT, dxpl_id, file->accum_loc, file->accum_size, file->meta_accum) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver write request failed") /* Reset the dirty flag */ file->accum_dirty=FALSE; } /* end if */ if(file->cls->flush && (file->cls->flush)(file,dxpl_id,closing) < 0) HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "driver flush request failed") done: FUNC_LEAVE_NOAPI(ret_value) } /*------------------------------------------------------------------------- * Function: H5FD_get_fileno * * Purpose: Quick and dirty routine to retrieve the file's 'fileno' value * (Mainly added to stop non-file routines from poking about in the * H5FD_t data structure) * * Return: Non-negative on success/Negative on failure * * Programmer: Quincey Koziol * March 27, 2002 * *------------------------------------------------------------------------- */ herr_t H5FD_get_fileno(const H5FD_t *file, unsigned long *filenum) { herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5FD_get_fileno, FAIL) HDassert(file); HDassert(filenum); /* Retrieve the file's serial number */ *filenum = file->fileno; done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_get_fileno() */ /*-------------------------------------------------------------------------- * Function: H5FDget_vfd_handle * * Purpose: Returns a pointer to the file handle of low-level virtual * file driver. * * Return: Non-negative if succeed; negative otherwise. * * Programmer: Raymond Lu * Sep. 16, 2002 * * Modifications: * *-------------------------------------------------------------------------- */ herr_t H5FDget_vfd_handle(H5FD_t *file, hid_t fapl, void **file_handle) { herr_t ret_value; FUNC_ENTER_API(H5FDget_vfd_handle, FAIL) H5TRACE3("e", "*xi**x", file, fapl, file_handle); /* Check arguments */ HDassert(file); HDassert(file_handle); ret_value = H5FD_get_vfd_handle(file, fapl, file_handle); done: FUNC_LEAVE_API(ret_value) } /* end H5FDget_vfd_handle() */ /*-------------------------------------------------------------------------- * Function: H5FD_get_vfd_handle * * Purpose: Retrieve the file handle for file driver. * * Return: Non-negative if succeed; negative if fails. * * Programmer: Raymond Lu * Sep. 16, 2002 * * Modifications: * *-------------------------------------------------------------------------- */ herr_t H5FD_get_vfd_handle(H5FD_t *file, hid_t fapl, void **file_handle) { herr_t ret_value = SUCCEED; FUNC_ENTER_NOAPI(H5FD_get_vfd_handle, FAIL) HDassert(file_handle); if(NULL == file->cls->get_handle) HGOTO_ERROR(H5E_VFL, H5E_UNSUPPORTED, FAIL, "file driver has no `get_vfd_handle' method") if((ret_value = file->cls->get_handle(file, fapl, file_handle)) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "can't get file handle for file driver") done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_get_vfd_handle() */