diff options
Diffstat (limited to 'src/H5Fefc.c')
| -rw-r--r-- | src/H5Fefc.c | 497 |
1 files changed, 270 insertions, 227 deletions
diff --git a/src/H5Fefc.c b/src/H5Fefc.c index 9916002..ea48054 100644 --- a/src/H5Fefc.c +++ b/src/H5Fefc.c @@ -1,23 +1,20 @@ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 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. * + * the COPYING file, which can be found at the root of the source code * + * distribution tree, or in https://www.hdfgroup.org/licenses. * + * If you do not have access to either file, you may request a copy from * + * help@hdfgroup.org. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /*------------------------------------------------------------------------- * * Created: H5Defc.c * December 13, 2010 - * Neil Fortner <nfortne2@hdfgroup.org> + * Neil Fortner * * Purpose: External file caching routines - implements a * cache of external files to minimize the number of @@ -26,59 +23,60 @@ *------------------------------------------------------------------------- */ -#define H5F_PACKAGE /*suppress error about including H5Fpkg */ - +#include "H5Fmodule.h" /* This source code file is part of the H5F module */ /* Packages needed by this file... */ -#include "H5private.h" /* Generic Functions */ -#include "H5Eprivate.h" /* Error handling */ -#include "H5Fpkg.h" /* File access */ -#include "H5MMprivate.h" /* Memory management */ -#include "H5Pprivate.h" /* Property lists */ +#include "H5private.h" /* Generic Functions */ +#include "H5CXprivate.h" /* API Contexts */ +#include "H5Eprivate.h" /* Error handling */ +#include "H5Fpkg.h" /* File access */ +#include "H5Iprivate.h" /* IDs */ +#include "H5MMprivate.h" /* Memory management */ +#include "H5Pprivate.h" /* Property lists */ /* Special values for the "tag" field below */ -#define H5F_EFC_TAG_DEFAULT -1 -#define H5F_EFC_TAG_LOCK -2 -#define H5F_EFC_TAG_CLOSE -3 -#define H5F_EFC_TAG_DONTCLOSE -4 +#define H5F_EFC_TAG_DEFAULT (-1) +#define H5F_EFC_TAG_LOCK (-2) +#define H5F_EFC_TAG_CLOSE (-3) +#define H5F_EFC_TAG_DONTCLOSE (-4) /* Structure for each entry in a file's external file cache */ typedef struct H5F_efc_ent_t { - char *name; /* Name of the file */ - H5F_t *file; /* File object */ - struct H5F_efc_ent_t *LRU_next; /* Next item in LRU list */ - struct H5F_efc_ent_t *LRU_prev; /* Previous item in LRU list */ - unsigned nopen; /* Number of times this file is currently opened by an EFC client */ + char *name; /* Name of the file */ + H5F_t *file; /* File object */ + struct H5F_efc_ent_t *LRU_next; /* Next item in LRU list */ + struct H5F_efc_ent_t *LRU_prev; /* Previous item in LRU list */ + unsigned nopen; /* Number of times this file is currently opened by an EFC client */ } H5F_efc_ent_t; /* Structure for a shared file struct's external file cache */ struct H5F_efc_t { - H5SL_t *slist; /* Skip list of cached external files */ - H5F_efc_ent_t *LRU_head; /* Head of LRU list. This is the least recently used file */ - H5F_efc_ent_t *LRU_tail; /* Tail of LRU list. This is the most recently used file */ - unsigned nfiles; /* Size of the external file cache */ - unsigned max_nfiles; /* Maximum size of the external file cache */ - unsigned nrefs; /* Number of times this file appears in another file's EFC */ - int tag; /* Temporary variable used by H5F_efc_try_close() */ - H5F_file_t *tmp_next; /* Next file in temporary list used by H5F_efc_try_close() */ + H5SL_t *slist; /* Skip list of cached external files */ + H5F_efc_ent_t *LRU_head; /* Head of LRU list. This is the least recently used file */ + H5F_efc_ent_t *LRU_tail; /* Tail of LRU list. This is the most recently used file */ + unsigned nfiles; /* Size of the external file cache */ + unsigned max_nfiles; /* Maximum size of the external file cache */ + unsigned nrefs; /* Number of times this file appears in another file's EFC */ + int tag; /* Temporary variable used by H5F__efc_try_close() */ + H5F_shared_t *tmp_next; /* Next file in temporary list used by H5F__efc_try_close() */ }; /* Private prototypes */ -static herr_t H5F_efc_remove_ent(H5F_efc_t *efc, H5F_efc_ent_t *ent); -static void H5F_efc_try_close_tag1(H5F_file_t *sf, H5F_file_t **tail); -static void H5F_efc_try_close_tag2(H5F_file_t *sf, H5F_file_t **tail); +static herr_t H5F__efc_release_real(H5F_efc_t *efc); +static herr_t H5F__efc_remove_ent(H5F_efc_t *efc, H5F_efc_ent_t *ent); +static void H5F__efc_try_close_tag1(H5F_shared_t *sf, H5F_shared_t **tail); +static void H5F__efc_try_close_tag2(H5F_shared_t *sf, H5F_shared_t **tail); /* Free lists */ H5FL_DEFINE_STATIC(H5F_efc_ent_t); H5FL_DEFINE_STATIC(H5F_efc_t); - /*------------------------------------------------------------------------- - * Function: H5F_efc_create + * Function: H5F__efc_create * * Purpose: Allocate and initialize a new external file cache object, * which can the be used to cache open external files. - * the object must be freed with H5F_efc_destroy. + * the object must be freed with H5F__efc_destroy. * * Return: Pointer to new external file cache object on success * NULL on failure @@ -89,18 +87,18 @@ H5FL_DEFINE_STATIC(H5F_efc_t); *------------------------------------------------------------------------- */ H5F_efc_t * -H5F_efc_create(unsigned max_nfiles) +H5F__efc_create(unsigned max_nfiles) { - H5F_efc_t *efc = NULL; /* EFC object */ - H5F_efc_t *ret_value; /* Return value */ + H5F_efc_t *efc = NULL; /* EFC object */ + H5F_efc_t *ret_value = NULL; /* Return value */ - FUNC_ENTER_NOAPI(NULL) + FUNC_ENTER_PACKAGE /* Sanity checks */ HDassert(max_nfiles > 0); /* Allocate EFC struct */ - if(NULL == (efc = H5FL_CALLOC(H5F_efc_t))) + if (NULL == (efc = H5FL_CALLOC(H5F_efc_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* Initialize maximum number of files */ @@ -113,15 +111,14 @@ H5F_efc_create(unsigned max_nfiles) ret_value = efc; done: - if(ret_value == NULL && efc) + if (ret_value == NULL && efc) efc = H5FL_FREE(H5F_efc_t, efc); FUNC_LEAVE_NOAPI(ret_value) -} /* end H5F_efc_create() */ +} /* end H5F__efc_create() */ - /*------------------------------------------------------------------------- - * Function: H5F_efc_open + * Function: H5F__efc_open * * Purpose: Opens a file using the external file cache. The target * file is added to the external file cache of the parent @@ -140,32 +137,48 @@ done: *------------------------------------------------------------------------- */ H5F_t * -H5F_efc_open(H5F_t *parent, const char *name, unsigned flags, hid_t fcpl_id, - hid_t fapl_id, hid_t dxpl_id) +H5F__efc_open(H5F_t *parent, const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id) { - H5F_efc_t *efc = NULL; /* External file cache for parent file */ - H5F_efc_ent_t *ent = NULL; /* Entry for target file in efc */ - hbool_t open_file = FALSE; /* Whether ent->file needs to be closed in case of error */ - H5F_t *ret_value = NULL; /* Return value */ + H5F_efc_t *efc = NULL; /* External file cache for parent file */ + H5F_efc_ent_t *ent = NULL; /* Entry for target file in efc */ + hbool_t open_file = FALSE; /* Whether ent->file needs to be closed in case of error */ + H5P_genplist_t *plist; /* Property list pointer for FAPL */ + H5VL_connector_prop_t connector_prop; /* Property for VOL connector ID & info */ + H5F_t *ret_value = NULL; /* Return value */ - FUNC_ENTER_NOAPI_NOINIT + FUNC_ENTER_PACKAGE /* Sanity checks */ HDassert(parent); HDassert(parent->shared); HDassert(name); + /* Get the VOL info from the fapl */ + if (NULL == (plist = (H5P_genplist_t *)H5I_object(fapl_id))) + HGOTO_ERROR(H5E_FILE, H5E_BADTYPE, NULL, "not a file access property list") + if (H5P_peek(plist, H5F_ACS_VOL_CONN_NAME, &connector_prop) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTGET, NULL, "can't get VOL connector info") + + /* Stash a copy of the "top-level" connector property, before any pass-through + * connectors modify or unwrap it. + */ + if (H5CX_set_vol_connector_prop(&connector_prop) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTSET, NULL, "can't set VOL connector info in API context") + /* Get external file cache */ efc = parent->shared->efc; /* Check if the EFC exists. If it does not, just call H5F_open(). We * support this so clients do not have to make 2 different calls depending * on the state of the efc. */ - if(!efc) { - if(NULL == (ret_value = H5F_open(name, flags, fcpl_id, fapl_id, - dxpl_id))) + if (!efc) { + if (NULL == (ret_value = H5F_open(name, flags, fcpl_id, fapl_id))) HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "can't open file") + /* Make file post open call */ + if (H5F__post_open(ret_value) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, NULL, "can't finish opening file") + /* Increment the number of open objects to prevent the file from being * closed out from under us - "simulate" having an open file id. Note * that this behaviour replaces the calls to H5F_incr_nopen_objs() and @@ -177,31 +190,31 @@ H5F_efc_open(H5F_t *parent, const char *name, unsigned flags, hid_t fcpl_id, /* Search the skip list for name if the skip list exists, create the skip * list otherwise */ - if(efc->slist) { - if(efc->nfiles > 0) + if (efc->slist) { + if (efc->nfiles > 0) ent = (H5F_efc_ent_t *)H5SL_search(efc->slist, name); } /* end if */ else { HDassert(efc->nfiles == 0); - if(NULL == (efc->slist = H5SL_create(H5SL_TYPE_STR, NULL))) + if (NULL == (efc->slist = H5SL_create(H5SL_TYPE_STR, NULL))) HGOTO_ERROR(H5E_FILE, H5E_CANTCREATE, NULL, "can't create skip list") } /* end else */ /* If we found the file update the LRU list and return the cached file, * otherwise open the file and cache it */ - if(ent) { + if (ent) { HDassert(efc->LRU_head); HDassert(efc->LRU_tail); /* Move ent to the head of the LRU list, if it is not already there */ - if(ent->LRU_prev) { + if (ent->LRU_prev) { HDassert(efc->LRU_head != ent); /* Remove from current position. Note that once we touch the LRU * list we cannot revert to the previous state. Make sure there can * be no errors between when we first touch the LRU list and when * the cache is in a consistent state! */ - if(ent->LRU_next) + if (ent->LRU_next) ent->LRU_next->LRU_prev = ent->LRU_prev; else { HDassert(efc->LRU_tail == ent); @@ -210,10 +223,10 @@ H5F_efc_open(H5F_t *parent, const char *name, unsigned flags, hid_t fcpl_id, ent->LRU_prev->LRU_next = ent->LRU_next; /* Add to head of LRU list */ - ent->LRU_next = efc->LRU_head; + ent->LRU_next = efc->LRU_head; ent->LRU_next->LRU_prev = ent; - ent->LRU_prev = NULL; - efc->LRU_head = ent; + ent->LRU_prev = NULL; + efc->LRU_head = ent; } /* end if */ /* Mark the file as open */ @@ -221,24 +234,28 @@ H5F_efc_open(H5F_t *parent, const char *name, unsigned flags, hid_t fcpl_id, } /* end if */ else { /* Check if we need to evict something */ - if(efc->nfiles == efc->max_nfiles) { + if (efc->nfiles == efc->max_nfiles) { /* Search for an unopened file from the tail */ - for(ent = efc->LRU_tail; ent && ent->nopen; ent = ent->LRU_prev); + for (ent = efc->LRU_tail; ent && ent->nopen; ent = ent->LRU_prev) + ; /* Evict the file if found, otherwise just open the target file and * do not add it to cache */ - if(ent) { - if(H5F_efc_remove_ent(efc, ent) < 0) + if (ent) { + if (H5F__efc_remove_ent(efc, ent) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTREMOVE, NULL, "can't remove entry from external file cache") /* Do not free ent, we will recycle it below */ } /* end if */ else { /* Cannot cache file, just open file and return */ - if(NULL == (ret_value = H5F_open(name, flags, fcpl_id, fapl_id, - dxpl_id))) + if (NULL == (ret_value = H5F_open(name, flags, fcpl_id, fapl_id))) HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "can't open file") + /* Make file post open call */ + if (H5F__post_open(ret_value) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, NULL, "can't finish opening file") + /* Increment the number of open objects to prevent the file from * being closed out from under us - "simulate" having an open * file id */ @@ -246,38 +263,41 @@ H5F_efc_open(H5F_t *parent, const char *name, unsigned flags, hid_t fcpl_id, HGOTO_DONE(ret_value) } /* end else */ - } /* end if */ + } /* end if */ else /* Allocate new entry */ - if(NULL == (ent = H5FL_MALLOC(H5F_efc_ent_t))) + if (NULL == (ent = H5FL_MALLOC(H5F_efc_ent_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* Build new entry */ - if(NULL == (ent->name = H5MM_strdup(name))) + if (NULL == (ent->name = H5MM_strdup(name))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* Open the file */ - if(NULL == (ent->file = H5F_open(name, flags, fcpl_id, fapl_id, - dxpl_id))) + if (NULL == (ent->file = H5F_open(name, flags, fcpl_id, fapl_id))) HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "can't open file") open_file = TRUE; + /* Make file post open call */ + if (H5F__post_open(ent->file) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, NULL, "can't finish opening file") + /* Increment the number of open objects to prevent the file from being * closed out from under us - "simulate" having an open file id */ ent->file->nopen_objs++; /* Add the file to the cache */ /* Skip list */ - if(H5SL_insert(efc->slist, ent, ent->name) < 0) + if (H5SL_insert(efc->slist, ent, ent->name) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTINSERT, NULL, "can't insert entry into skip list") /* Add to head of LRU list and update tail if necessary */ ent->LRU_next = efc->LRU_head; - if(ent->LRU_next) + if (ent->LRU_next) ent->LRU_next->LRU_prev = ent; ent->LRU_prev = NULL; efc->LRU_head = ent; - if(!efc->LRU_tail) { + if (!efc->LRU_tail) { HDassert(!ent->LRU_next); efc->LRU_tail = ent; } /* end if */ @@ -287,7 +307,7 @@ H5F_efc_open(H5F_t *parent, const char *name, unsigned flags, hid_t fcpl_id, /* Update nfiles and nrefs */ efc->nfiles++; - if(ent->file->shared->efc) + if (ent->file->shared->efc) ent->file->shared->efc->nrefs++; } /* end else */ @@ -300,21 +320,20 @@ H5F_efc_open(H5F_t *parent, const char *name, unsigned flags, hid_t fcpl_id, ret_value = ent->file; done: - if(!ret_value) - if(ent) { - if(open_file) { + if (!ret_value) + if (ent) { + if (open_file) { ent->file->nopen_objs--; - if(H5F_try_close(ent->file) < 0) + if (H5F_try_close(ent->file, NULL) < 0) HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "can't close external file") } /* end if */ ent->name = (char *)H5MM_xfree(ent->name); - ent = H5FL_FREE(H5F_efc_ent_t, ent); + ent = H5FL_FREE(H5F_efc_ent_t, ent); } /* end if */ FUNC_LEAVE_NOAPI(ret_value) -} /* end H5F_efc_open() */ +} /* end H5F__efc_open() */ - /*------------------------------------------------------------------------- * Function: H5F_efc_close * @@ -333,9 +352,9 @@ done: herr_t H5F_efc_close(H5F_t *parent, H5F_t *file) { - H5F_efc_t *efc = NULL; /* External file cache for parent file */ - H5F_efc_ent_t *ent = NULL; /* Entry for target file in efc */ - herr_t ret_value = SUCCEED; /* Return value */ + H5F_efc_t *efc = NULL; /* External file cache for parent file */ + H5F_efc_ent_t *ent = NULL; /* Entry for target file in efc */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT @@ -351,9 +370,9 @@ H5F_efc_close(H5F_t *parent, H5F_t *file) /* Check if the EFC exists. If it does not, just call H5F_try_close(). We * support this so clients do not have to make 2 different calls depending * on the state of the efc. */ - if(!efc) { + if (!efc) { file->nopen_objs--; - if(H5F_try_close(file) < 0) + if (H5F_try_close(file, NULL) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't close external file") HGOTO_DONE(SUCCEED) @@ -364,10 +383,11 @@ H5F_efc_close(H5F_t *parent, H5F_t *file) * the head. In the unlikely case that the file is not found, just call * H5F_try_close(). This could happen if the EFC was full of open files * when the file was opened. */ - for(ent = efc->LRU_head; ent && ent->file != file; ent = ent->LRU_next); - if(!ent) { + for (ent = efc->LRU_head; ent && ent->file != file; ent = ent->LRU_next) + ; + if (!ent) { file->nopen_objs--; - if(H5F_try_close(file) < 0) + if (H5F_try_close(file, NULL) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't close external file") } /* end if */ else @@ -378,9 +398,8 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5F_efc_close() */ - /*------------------------------------------------------------------------- - * Function: H5F_efc_max_nfiles + * Function: H5F__efc_max_nfiles * * Purpose: Returns the maximum number of files in the provided * external file cache. @@ -393,19 +412,18 @@ done: *------------------------------------------------------------------------- */ unsigned -H5F_efc_max_nfiles(H5F_efc_t *efc) +H5F__efc_max_nfiles(H5F_efc_t *efc) { - FUNC_ENTER_NOAPI_NOINIT_NOERR + FUNC_ENTER_PACKAGE_NOERR HDassert(efc); HDassert(efc->max_nfiles > 0); FUNC_LEAVE_NOAPI(efc->max_nfiles) -} /* end H5F_efc_max_nfiles */ +} /* end H5F__efc_max_nfiles */ - /*------------------------------------------------------------------------- - * Function: H5F_efc_release + * Function: H5F__efc_release_real * * Purpose: Releases the external file cache, potentially closing any * cached files unless they are held open from somewhere @@ -419,38 +437,37 @@ H5F_efc_max_nfiles(H5F_efc_t *efc) * *------------------------------------------------------------------------- */ -herr_t -H5F_efc_release(H5F_efc_t *efc) +static herr_t +H5F__efc_release_real(H5F_efc_t *efc) { - H5F_efc_ent_t *ent = NULL; /* EFC entry */ - H5F_efc_ent_t *prev_ent = NULL; /* Previous EFC entry */ - herr_t ret_value = SUCCEED; /* Return value */ + H5F_efc_ent_t *ent = NULL; /* EFC entry */ + H5F_efc_ent_t *prev_ent = NULL; /* Previous EFC entry */ + herr_t ret_value = SUCCEED; /* Return value */ - FUNC_ENTER_NOAPI_NOINIT + FUNC_ENTER_PACKAGE /* Sanity checks */ HDassert(efc); - /* Lock the EFC to prevent manipulation of the EFC wile we are releasing it. + /* Lock the EFC to prevent manipulation of the EFC while we are releasing it. * The EFC should never be locked when we enter this function because that * would require a cycle, a cycle would necessarily invoke - * H5F_efc_try_close(), and that function checks the status of the lock + * H5F__efc_try_close(), and that function checks the status of the lock * before calling this one. */ - HDassert((efc->tag == H5F_EFC_TAG_DEFAULT) - || (efc->tag == H5F_EFC_TAG_CLOSE)); + HDassert((efc->tag == H5F_EFC_TAG_DEFAULT) || (efc->tag == H5F_EFC_TAG_CLOSE)); efc->tag = H5F_EFC_TAG_LOCK; /* Walk down the LRU list, releasing any files that are not opened by an EFC * client */ ent = efc->LRU_head; - while(ent) - if(!ent->nopen) { - if(H5F_efc_remove_ent(efc, ent) < 0) + while (ent) + if (!ent->nopen) { + if (H5F__efc_remove_ent(efc, ent) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTREMOVE, FAIL, "can't remove entry from external file cache") /* Free the entry and move to next entry in LRU list */ prev_ent = ent; - ent = ent->LRU_next; + ent = ent->LRU_next; prev_ent = H5FL_FREE(H5F_efc_ent_t, prev_ent); } /* end if */ else @@ -463,11 +480,43 @@ H5F_efc_release(H5F_efc_t *efc) done: FUNC_LEAVE_NOAPI(ret_value); +} /* end H5F__efc_release_real() */ + +/*------------------------------------------------------------------------- + * Function: H5F__efc_release + * + * Purpose: Releases the external file cache, potentially closing any + * cached files unless they are held open from somewhere + * else (or are currently opened by a client). + * + * Return: Non-negative on success + * Negative on failure + * + * Programmer: Quincey Koziol + * Sunday, February 18, 2018 + * + *------------------------------------------------------------------------- + */ +herr_t +H5F__efc_release(H5F_efc_t *efc) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_PACKAGE + + /* Sanity checks */ + HDassert(efc); + + /* Call 'real' routine */ + if (H5F__efc_release_real(efc) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't remove entry from external file cache") + +done: + FUNC_LEAVE_NOAPI(ret_value) } /* end H5F_efc_release() */ - /*------------------------------------------------------------------------- - * Function: H5F_efc_destroy + * Function: H5F__efc_destroy * * Purpose: Frees an external file cache object, releasing it first * if necessary. If it cannot be fully released, for example @@ -482,22 +531,22 @@ done: *------------------------------------------------------------------------- */ herr_t -H5F_efc_destroy(H5F_efc_t *efc) +H5F__efc_destroy(H5F_efc_t *efc) { - herr_t ret_value = SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ - FUNC_ENTER_NOAPI_NOINIT + FUNC_ENTER_PACKAGE /* Sanity checks */ HDassert(efc); - if(efc->nfiles > 0) { + if (efc->nfiles > 0) { /* Release (clear) the efc */ - if(H5F_efc_release(efc) < 0) + if (H5F__efc_release_real(efc) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release external file cache") /* If there are still cached files, return an error */ - if(efc->nfiles > 0) + if (efc->nfiles > 0) HGOTO_ERROR(H5E_FILE, H5E_CANTFREE, FAIL, "can't destroy EFC after incomplete release") } /* end if */ @@ -506,8 +555,8 @@ H5F_efc_destroy(H5F_efc_t *efc) HDassert(efc->LRU_tail == NULL); /* Close skip list */ - if(efc->slist) - if(H5SL_close(efc->slist) < 0) + if (efc->slist) + if (H5SL_close(efc->slist) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTFREE, FAIL, "can't close skip list") /* Free EFC object */ @@ -515,11 +564,10 @@ H5F_efc_destroy(H5F_efc_t *efc) done: FUNC_LEAVE_NOAPI(ret_value); -} /* end H5F_efc_destroy() */ +} /* end H5F__efc_destroy() */ - /*------------------------------------------------------------------------- - * Function: H5F_efc_remove_ent + * Function: H5F__efc_remove_ent * * Purpose: Removes the specified entry from the specified EFC, * closing the file if requested. Does not free the entry. @@ -533,11 +581,11 @@ done: *------------------------------------------------------------------------- */ static herr_t -H5F_efc_remove_ent(H5F_efc_t *efc, H5F_efc_ent_t *ent) +H5F__efc_remove_ent(H5F_efc_t *efc, H5F_efc_ent_t *ent) { - herr_t ret_value = SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ - FUNC_ENTER_NOAPI_NOINIT + FUNC_ENTER_PACKAGE /* Sanity checks */ HDassert(efc); @@ -545,17 +593,17 @@ H5F_efc_remove_ent(H5F_efc_t *efc, H5F_efc_ent_t *ent) HDassert(ent); /* Remove from skip list */ - if(ent != H5SL_remove(efc->slist, ent->name)) + if (ent != H5SL_remove(efc->slist, ent->name)) HGOTO_ERROR(H5E_FILE, H5E_CANTDELETE, FAIL, "can't delete entry from skip list") /* Remove from LRU list */ - if(ent->LRU_next) + if (ent->LRU_next) ent->LRU_next->LRU_prev = ent->LRU_prev; else { HDassert(efc->LRU_tail == ent); efc->LRU_tail = ent->LRU_prev; } /* end else */ - if(ent->LRU_prev) + if (ent->LRU_prev) ent->LRU_prev->LRU_next = ent->LRU_next; else { HDassert(efc->LRU_head == ent); @@ -564,7 +612,7 @@ H5F_efc_remove_ent(H5F_efc_t *efc, H5F_efc_ent_t *ent) /* Update nfiles and nrefs */ efc->nfiles--; - if(ent->file->shared->efc) + if (ent->file->shared->efc) ent->file->shared->efc->nrefs--; /* Free the name */ @@ -575,17 +623,16 @@ H5F_efc_remove_ent(H5F_efc_t *efc, H5F_efc_ent_t *ent) * However we must still manipulate the nopen_objs field to prevent the file * from being closed out from under us. */ ent->file->nopen_objs--; - if(H5F_try_close(ent->file) < 0) + if (H5F_try_close(ent->file, NULL) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't close external file") ent->file = NULL; done: FUNC_LEAVE_NOAPI(ret_value) -} /* end H5F_efc_remove_ent() */ +} /* end H5F__efc_remove_ent() */ - /*------------------------------------------------------------------------- - * Function: H5F_efc_try_close_tag1 + * Function: H5F__efc_try_close_tag1 * * Purpose: Recursively traverse the EFC tree, keeping a temporary * reference count on each file that assumes all reachable @@ -599,12 +646,12 @@ done: *------------------------------------------------------------------------- */ static void -H5F_efc_try_close_tag1(H5F_file_t *sf, H5F_file_t **tail) +H5F__efc_try_close_tag1(H5F_shared_t *sf, H5F_shared_t **tail) { - H5F_efc_ent_t *ent = NULL; /* EFC entry */ - H5F_file_t *esf; /* Convenience pointer to ent->file->shared */ + H5F_efc_ent_t *ent = NULL; /* EFC entry */ + H5F_shared_t *esf; /* Convenience pointer to ent->file->shared */ - FUNC_ENTER_NOAPI_NOINIT_NOERR + FUNC_ENTER_PACKAGE_NOERR /* Sanity checks */ HDassert(sf); @@ -615,17 +662,17 @@ H5F_efc_try_close_tag1(H5F_file_t *sf, H5F_file_t **tail) HDassert(*tail); /* Recurse into this file's cached files */ - for(ent = sf->efc->LRU_head; ent; ent = ent->LRU_next) { + for (ent = sf->efc->LRU_head; ent; ent = ent->LRU_next) { esf = ent->file->shared; - if(esf->efc) { + if (esf->efc) { /* If tag were 0, that would mean there are more actual references * than are counted by nrefs */ HDassert(esf->efc->tag != 0); /* If tag has been set, we have already visited this file so just * decrement tag and continue */ - if(esf->efc->tag > 0) + if (esf->efc->tag > 0) esf->efc->tag--; /* If there are references that are not from an EFC, it will never * be possible to close the file. Just continue. Also continue if @@ -633,8 +680,8 @@ H5F_efc_try_close_tag1(H5F_file_t *sf, H5F_file_t **tail) * that the reference counts will never match for the root file, but * that's ok because the root file will always have a tag and enter * the branch above. */ - else if((esf->nrefs == esf->efc->nrefs) - && (esf->efc->tag != H5F_EFC_TAG_LOCK) && !(ent->nopen)) { + else if ((esf->nrefs == esf->efc->nrefs) && (esf->efc->tag != H5F_EFC_TAG_LOCK) && + !(ent->nopen)) { /* If we get here, this file's "tmp_next" pointer must be NULL */ HDassert(esf->efc->tmp_next == NULL); @@ -642,24 +689,23 @@ H5F_efc_try_close_tag1(H5F_file_t *sf, H5F_file_t **tail) /* If nrefs > 1, Add this file to the list of files with nrefs > * 1 and initialize tag to the number of references (except this * one) */ - if(esf->nrefs > 1) { + if (esf->nrefs > 1) { (*tail)->efc->tmp_next = esf; - *tail = esf; - esf->efc->tag = (int)esf->nrefs - 1; + *tail = esf; + esf->efc->tag = (int)esf->nrefs - 1; } /* end if */ /* Recurse into the entry */ - H5F_efc_try_close_tag1(ent->file->shared, tail); + H5F__efc_try_close_tag1(ent->file->shared, tail); } /* end if */ - } /* end if */ - } /* end for */ + } /* end if */ + } /* end for */ FUNC_LEAVE_NOAPI_VOID -} /* end H5F_efc_try_close_tag1() */ +} /* end H5F__efc_try_close_tag1() */ - /*------------------------------------------------------------------------- - * Function: H5F_efc_try_close_tag2 + * Function: H5F__efc_try_close_tag2 * * Purpose: Recuresively mark all files reachable through this one as * uncloseable, and add newly uncloseable files to the tail @@ -673,19 +719,19 @@ H5F_efc_try_close_tag1(H5F_file_t *sf, H5F_file_t **tail) *------------------------------------------------------------------------- */ static void -H5F_efc_try_close_tag2(H5F_file_t *sf, H5F_file_t **tail) +H5F__efc_try_close_tag2(H5F_shared_t *sf, H5F_shared_t **tail) { - H5F_efc_ent_t *ent = NULL; /* EFC entry */ - H5F_file_t *esf; /* Convenience pointer to ent->file->shared */ + H5F_efc_ent_t *ent = NULL; /* EFC entry */ + H5F_shared_t *esf; /* Convenience pointer to ent->file->shared */ - FUNC_ENTER_NOAPI_NOINIT_NOERR + FUNC_ENTER_PACKAGE_NOERR /* Sanity checks */ HDassert(sf); HDassert(sf->efc); /* Recurse into this file's cached files */ - for(ent = sf->efc->LRU_head; ent; ent = ent->LRU_next) { + for (ent = sf->efc->LRU_head; ent; ent = ent->LRU_next) { esf = ent->file->shared; /* Only recurse if the file is tagged CLOSE or DEFAULT. If it is tagged @@ -696,41 +742,38 @@ H5F_efc_try_close_tag2(H5F_file_t *sf, H5F_file_t **tail) * make sure we do not go off into somewhere cb1 didn't touch. The * root file should never be tagged DEFAULT here, so the reference check * is still appropriate. */ - if((esf->efc) && ((esf->efc->tag == H5F_EFC_TAG_CLOSE) - || ((esf->efc->tag == H5F_EFC_TAG_DEFAULT) - && (esf->nrefs == esf->efc->nrefs) && !(ent->nopen)))) { + if ((esf->efc) && + ((esf->efc->tag == H5F_EFC_TAG_CLOSE) || + ((esf->efc->tag == H5F_EFC_TAG_DEFAULT) && (esf->nrefs == esf->efc->nrefs) && !(ent->nopen)))) { /* tag should always be CLOSE is nrefs > 1 or DEFAULT if nrefs == 1 * here */ - HDassert(((esf->nrefs > 1) - && ((esf->efc->tag == H5F_EFC_TAG_CLOSE))) - || ((esf->nrefs == 1) - && (esf->efc->tag == H5F_EFC_TAG_DEFAULT))); + HDassert(((esf->nrefs > 1) && ((esf->efc->tag == H5F_EFC_TAG_CLOSE))) || + ((esf->nrefs == 1) && (esf->efc->tag == H5F_EFC_TAG_DEFAULT))); /* If tag is set to DONTCLOSE, we have already visited this file * *or* it will be the start point of another iteration so just * continue */ - if(esf->efc->tag != H5F_EFC_TAG_DONTCLOSE) { + if (esf->efc->tag != H5F_EFC_TAG_DONTCLOSE) { /* If tag is CLOSE, set to DONTCLOSE and add to the list of * uncloseable files. */ - if(esf->efc->tag == H5F_EFC_TAG_CLOSE) { - esf->efc->tag = H5F_EFC_TAG_DONTCLOSE; - esf->efc->tmp_next = NULL; + if (esf->efc->tag == H5F_EFC_TAG_CLOSE) { + esf->efc->tag = H5F_EFC_TAG_DONTCLOSE; + esf->efc->tmp_next = NULL; (*tail)->efc->tmp_next = esf; - *tail = esf; + *tail = esf; } /* end if */ /* Recurse into the entry */ - H5F_efc_try_close_tag2(esf, tail); + H5F__efc_try_close_tag2(esf, tail); } /* end if */ - } /* end if */ - } /* end for */ + } /* end if */ + } /* end for */ FUNC_LEAVE_NOAPI_VOID -} /* end H5F_efc_try_close_tag2() */ +} /* end H5F__efc_try_close_tag2() */ - /*------------------------------------------------------------------------- - * Function: H5F_efc_try_close + * Function: H5F__efc_try_close * * Purpose: Attempts to close the provided (shared) file by checking * to see if the releasing the EFC would cause its reference @@ -746,7 +789,7 @@ H5F_efc_try_close_tag2(H5F_file_t *sf, H5F_file_t **tail) * "callback" for the final pass (the one where the files are * actually closed). The code for the callback case is at * the top of this function; luckily it only consists of a - * (possible) call to H5F_efc_release(). + * (possible) call to H5F__efc_release_real(). * * The algorithm basically consists of 3 passes over the EFC * tree. The first pass assumes that every reachable file is @@ -762,8 +805,8 @@ H5F_efc_try_close_tag2(H5F_file_t *sf, H5F_file_t **tail) * closeable only because the first pass assumed that an * uncloseable file would be closed. * - * The final pass exploits the H5F_efc_release()-> - * H5F_efc_remove_ent()->H5F_try_close()->H5F_efc_try_close() + * The final pass exploits the H5F__efc_release_real()-> + * H5F__efc_remove_ent()->H5F_try_close()->H5F__efc_try_close() * calling chain to recursively close the tree, but only the * files that are still marked as closeable. All files * marked as closeable have their EFCs released, and will @@ -780,16 +823,18 @@ H5F_efc_try_close_tag2(H5F_file_t *sf, H5F_file_t **tail) *------------------------------------------------------------------------- */ herr_t -H5F_efc_try_close(H5F_t *f) +H5F__efc_try_close(H5F_t *f) { - H5F_file_t *tail; /* Tail of linked list of found files. Head will be f->shared. */ - H5F_file_t *uncloseable_head = NULL; /* Head of linked list of files found to be uncloseable by the first pass */ - H5F_file_t *uncloseable_tail = NULL; /* Tail of linked list of files found to be uncloseable by the first pass */ - H5F_file_t *sf; /* Temporary file pointer */ - H5F_file_t *next; /* Temporary file pointer */ - herr_t ret_value = SUCCEED; /* Return value */ + H5F_shared_t *tail; /* Tail of linked list of found files. Head will be f->shared. */ + H5F_shared_t *uncloseable_head = + NULL; /* Head of linked list of files found to be uncloseable by the first pass */ + H5F_shared_t *uncloseable_tail = + NULL; /* Tail of linked list of files found to be uncloseable by the first pass */ + H5F_shared_t *sf; /* Temporary file pointer */ + H5F_shared_t *next; /* Temporary file pointer */ + herr_t ret_value = SUCCEED; /* Return value */ - FUNC_ENTER_NOAPI_NOINIT + FUNC_ENTER_PACKAGE /* Sanity checks */ HDassert(f); @@ -799,12 +844,12 @@ H5F_efc_try_close(H5F_t *f) HDassert(f->shared->nrefs > 1); HDassert(f->shared->efc->tag < 0); - if(f->shared->efc->tag == H5F_EFC_TAG_CLOSE) { + if (f->shared->efc->tag == H5F_EFC_TAG_CLOSE) { /* We must have reentered this function, and we should close this file. * In actuality, we just release the EFC, the recursion should * eventually reduce this file's reference count to 1 (though possibly - * not from this call to H5F_efc_release()). */ - if(H5F_efc_release(f->shared->efc) < 0) + * not from this call to H5F__efc_release_real()). */ + if (H5F__efc_release_real(f->shared->efc) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release external file cache") /* If we marked the file as closeable, there must be no open files in @@ -821,8 +866,8 @@ H5F_efc_try_close(H5F_t *f) /* Conditions where we should not do anything and just return immediately */ /* If there are references that are not from an EFC or f, it will never * be possible to close the file. Just return. Note that this holds true - * for the case that this file is being closed through H5F_efc_release() - * because that function (through H5F_efc_remove_ent()) decrements the EFC + * for the case that this file is being closed through H5F__efc_release_real() + * because that function (through H5F__efc_remove_ent()) decrements the EFC * reference count before it calls H5F_try_close(). This may occur if this * function is reentered. */ /* If the tag is H5F_EFC_TAG_DONTCLOSE, then we have definitely reentered @@ -830,15 +875,14 @@ H5F_efc_try_close(H5F_t *f) * not close/release it */ /* If nfiles is 0, then there is nothing to do. Just return. This may also * occur on reentry (for example if this file was previously released). */ - if((f->shared->nrefs != f->shared->efc->nrefs + 1) - || (f->shared->efc->tag == H5F_EFC_TAG_DONTCLOSE) - || (f->shared->efc->nfiles == 0)) + if ((f->shared->nrefs != f->shared->efc->nrefs + 1) || (f->shared->efc->tag == H5F_EFC_TAG_DONTCLOSE) || + (f->shared->efc->nfiles == 0)) /* We must have reentered this function, and we should not close this * file. Just return. */ HGOTO_DONE(SUCCEED) /* If the file EFC were locked, that should always mean that there exists - * a reference to this file that is not in an EFC (it may have just been + * a reference to this file that is not in an EFC (it may have just been * removed from an EFC), and should have been caught by the above check */ /* If we get here then we must be beginning a new run. Make sure that the * temporary variables in f->shared->efc are at the default value */ @@ -856,17 +900,17 @@ H5F_efc_try_close(H5F_t *f) * field to keep track of final reference count for each file (including * this one). Keep list of files with starting reference count > 1 (head is * f->shared). */ - H5F_efc_try_close_tag1(f->shared, &tail); + H5F__efc_try_close_tag1(f->shared, &tail); /* Check if f->shared->efc->tag dropped to 0. If it did not, * we cannot close anything. Just reset temporary values and return. */ - if(f->shared->efc->tag > 0) { + if (f->shared->efc->tag > 0) { sf = f->shared; - while(sf) { - next = sf->efc->tmp_next; - sf->efc->tag = H5F_EFC_TAG_DEFAULT; + while (sf) { + next = sf->efc->tmp_next; + sf->efc->tag = H5F_EFC_TAG_DEFAULT; sf->efc->tmp_next = NULL; - sf = next; + sf = next; } /* end while */ HGOTO_DONE(SUCCEED) } /* end if */ @@ -874,19 +918,19 @@ H5F_efc_try_close(H5F_t *f) /* Run through the linked list , separating into two lists, one with tag == * 0 and one with tag > 0. Mark them as either H5F_EFC_TAG_CLOSE or * H5F_EFC_TAG_DONTCLOSE as appropriate. */ - sf = f->shared; + sf = f->shared; tail = NULL; - while(sf) { + while (sf) { HDassert(sf->efc->tag >= 0); next = sf->efc->tmp_next; - if(sf->efc->tag > 0) { + if (sf->efc->tag > 0) { /* Remove from main list */ HDassert(tail); tail->efc->tmp_next = sf->efc->tmp_next; - sf->efc->tmp_next = NULL; + sf->efc->tmp_next = NULL; /* Add to uncloseable list */ - if(!uncloseable_head) + if (!uncloseable_head) uncloseable_head = sf; else uncloseable_tail->efc->tmp_next = sf; @@ -897,7 +941,7 @@ H5F_efc_try_close(H5F_t *f) } /* end if */ else { sf->efc->tag = H5F_EFC_TAG_CLOSE; - tail = sf; + tail = sf; } /* end else */ sf = next; } /* end while */ @@ -910,20 +954,20 @@ H5F_efc_try_close(H5F_t *f) * so we know when to stop. We do not need to keep track of the closeable * list any more. */ sf = uncloseable_head; - if(sf) { + if (sf) { tail = uncloseable_tail; HDassert(tail); - while(sf != tail->efc->tmp_next) { - H5F_efc_try_close_tag2(sf, &uncloseable_tail); + while (sf != tail->efc->tmp_next) { + H5F__efc_try_close_tag2(sf, &uncloseable_tail); sf = sf->efc->tmp_next; } /* end while */ - } /* end if */ + } /* end if */ /* If the root file's tag is still H5F_EFC_TAG_CLOSE, release its EFC. This * should start the recursive release that should close all closeable files. * Also, see the top of this function. */ - if(f->shared->efc->tag == H5F_EFC_TAG_CLOSE) { - if(H5F_efc_release(f->shared->efc) < 0) + if (f->shared->efc->tag == H5F_EFC_TAG_CLOSE) { + if (H5F__efc_release_real(f->shared->efc) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release external file cache") /* Make sure the file's reference count is now 1 and will be closed by @@ -933,18 +977,17 @@ H5F_efc_try_close(H5F_t *f) /* Clean up uncloseable files (reset tag and tmp_next). All closeable files * should have been closed, and therefore do not need to be cleaned up. */ - if(uncloseable_head) { + if (uncloseable_head) { sf = uncloseable_head; - while(sf) { + while (sf) { next = sf->efc->tmp_next; HDassert(sf->efc->tag == H5F_EFC_TAG_DONTCLOSE); - sf->efc->tag = H5F_EFC_TAG_DEFAULT; + sf->efc->tag = H5F_EFC_TAG_DEFAULT; sf->efc->tmp_next = NULL; - sf = next; + sf = next; } /* end while */ - } /* end if */ + } /* end if */ done: FUNC_LEAVE_NOAPI(ret_value) -} /* end H5F_efc_try_close() */ - +} /* end H5F__efc_try_close() */ |