mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-02-11 16:01:00 +08:00
Code Issues Packages Projects Releases Wiki Activity
9adacb54a6
hdf5/src/H5Fmount.c
Dana Robinson f3900f2f61
Remove useless headers (#4145) 
Removes unnecessary headers from C library source files.
2024-03-15 08:49:59 -07:00

628 lines
23 KiB
C
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* 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 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. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#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 "H5Gprivate.h" /* Groups */
#include "H5MMprivate.h" /* Memory management */
#include "H5Pprivate.h" /* Property lists */
/* PRIVATE PROTOTYPES */
static void H5F__mount_count_ids_recurse(H5F_t *f, unsigned *nopen_files, unsigned *nopen_objs);
/*-------------------------------------------------------------------------
* Function: H5F__close_mounts
*
* Purpose: Close all mounts for a given file
*
* Return: Non-negative on success/Negative on failure
*
*-------------------------------------------------------------------------
*/
herr_t
H5F__close_mounts(H5F_t *f)
{
unsigned u; /* Local index */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_PACKAGE
assert(f);
/* Unmount all child files. Loop backwards to avoid having to adjust u when
* a file is unmounted. Note that we rely on unsigned u "wrapping around"
* to terminate the loop.
*/
for (u = f->shared->mtab.nmounts - 1; u < f->shared->mtab.nmounts; u--) {
/* Only unmount children mounted to this top level file structure */
if (f->shared->mtab.child[u].file->parent == f) {
/* Detach the child file from the parent file */
f->shared->mtab.child[u].file->parent = NULL;
/* Close the internal group maintaining the mount point */
if (H5G_close(f->shared->mtab.child[u].group) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEOBJ, FAIL, "can't close child group");
/* Close the child file */
if (H5F_try_close(f->shared->mtab.child[u].file, NULL) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't close child file");
/* Eliminate the mount point from the table */
memmove(f->shared->mtab.child + u, f->shared->mtab.child + u + 1,
(f->shared->mtab.nmounts - u - 1) * sizeof(f->shared->mtab.child[0]));
f->shared->mtab.nmounts--;
f->nmounts--;
}
}
assert(f->nmounts == 0);
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F__close_mounts() */
/*-------------------------------------------------------------------------
* Function: H5F_mount
*
* Purpose: Mount file CHILD onto the group specified by LOC and NAME,
* using mount properties in PLIST. CHILD must not already be
* mouted and must not be a mount ancestor of the mount-point.
*
* Return: Non-negative on success/Negative on failure
*
*-------------------------------------------------------------------------
*/
herr_t
H5F_mount(const H5G_loc_t *loc, const char *name, H5F_t *child, hid_t H5_ATTR_UNUSED plist_id)
{
H5G_t *mount_point = NULL; /*mount point group */
H5F_t *ancestor = NULL; /*ancestor files */
H5F_t *parent = NULL; /*file containing mount point */
unsigned lt, rt, md; /*binary search indices */
int cmp; /*binary search comparison value*/
H5G_loc_t mp_loc; /* entry of mount point to be opened */
H5G_name_t mp_path; /* Mount point group hier. path */
H5O_loc_t mp_oloc; /* Mount point object location */
H5G_loc_t root_loc; /* Group location of root of file to mount */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
assert(loc);
assert(name && *name);
assert(child);
assert(true == H5P_isa_class(plist_id, H5P_FILE_MOUNT));
/* Set up group location to fill in */
mp_loc.oloc = &mp_oloc;
mp_loc.path = &mp_path;
H5G_loc_reset(&mp_loc);
/*
* Check that the child isn't mounted, that the mount point exists, that
* the mount point wasn't reached via external link, that
* the parent & child files have the same file close degree, and
* that the mount wouldn't introduce a cycle in the mount tree.
*/
if (child->parent)
HGOTO_ERROR(H5E_FILE, H5E_MOUNT, FAIL, "file is already mounted");
if (H5G_loc_find(loc, name, &mp_loc) < 0)
HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "group not found");
/* If the mount location is holding its file open, that file will close
* and remove the mount as soon as we exit this function. Prevent the
* user from doing this.
*/
if (mp_loc.oloc->holding_file != false)
HGOTO_ERROR(H5E_FILE, H5E_MOUNT, FAIL, "mount path cannot contain links to external files");
/* Open the mount point group */
if (NULL == (mount_point = H5G_open(&mp_loc)))
HGOTO_ERROR(H5E_FILE, H5E_MOUNT, FAIL, "mount point not found");
/* Check if the proposed mount point group is already a mount point */
if (H5G_MOUNTED(mount_point))
HGOTO_ERROR(H5E_FILE, H5E_MOUNT, FAIL, "mount point is already in use");
/* Retrieve information from the mount point group */
/* (Some of which we had before but was reset in mp_loc when the group
* "took over" the group location - QAK)
*/
parent = H5G_fileof(mount_point);
assert(parent);
mp_loc.oloc = H5G_oloc(mount_point);
assert(mp_loc.oloc);
mp_loc.path = H5G_nameof(mount_point);
assert(mp_loc.path);
for (ancestor = parent; ancestor; ancestor = ancestor->parent)
if (ancestor->shared == child->shared)
HGOTO_ERROR(H5E_FILE, H5E_MOUNT, FAIL, "mount would introduce a cycle");
/* Make certain that the parent & child files have the same "file close degree" */
if (parent->shared->fc_degree != child->shared->fc_degree)
HGOTO_ERROR(H5E_FILE, H5E_MOUNT, FAIL, "mounted file has different file close degree than parent");
/*
* Use a binary search to locate the position that the child should be
* inserted into the parent mount table. At the end of this paragraph
* `md' will be the index where the child should be inserted.
*/
lt = md = 0;
rt = parent->shared->mtab.nmounts;
cmp = -1;
while (lt < rt && cmp) {
H5O_loc_t *oloc; /*temporary symbol table entry */
md = (lt + rt) / 2;
oloc = H5G_oloc(parent->shared->mtab.child[md].group);
cmp = H5_addr_cmp(mp_loc.oloc->addr, oloc->addr);
if (cmp < 0)
rt = md;
else if (cmp > 0)
lt = md + 1;
}
if (cmp > 0)
md++;
if (!cmp)
HGOTO_ERROR(H5E_FILE, H5E_MOUNT, FAIL, "mount point is already in use");
/* Make room in the table */
if (parent->shared->mtab.nmounts >= parent->shared->mtab.nalloc) {
unsigned n = MAX(16, 2 * parent->shared->mtab.nalloc);
H5F_mount_t *x = (H5F_mount_t *)H5MM_realloc(parent->shared->mtab.child,
n * sizeof(parent->shared->mtab.child[0]));
if (!x)
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for mount table");
parent->shared->mtab.child = x;
parent->shared->mtab.nalloc = n;
}
/* Insert into table */
memmove(parent->shared->mtab.child + md + 1, parent->shared->mtab.child + md,
(parent->shared->mtab.nmounts - md) * sizeof(parent->shared->mtab.child[0]));
parent->shared->mtab.nmounts++;
parent->nmounts++;
parent->shared->mtab.child[md].group = mount_point;
parent->shared->mtab.child[md].file = child;
child->parent = parent;
/* Set the group's mountpoint flag */
if (H5G_mount(parent->shared->mtab.child[md].group) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEOBJ, FAIL, "unable to set group mounted flag");
/* Get the group location for the root group in the file to unmount */
if (NULL == (root_loc.oloc = H5G_oloc(child->shared->root_grp)))
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to get object location for root group");
if (NULL == (root_loc.path = H5G_nameof(child->shared->root_grp)))
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to get path for root group");
/* Search the open IDs and replace names for mount operation */
/* We pass H5G_UNKNOWN as object type; search all IDs */
if (H5G_name_replace(NULL, H5G_NAME_MOUNT, mp_loc.oloc->file, mp_loc.path->full_path_r,
root_loc.oloc->file, root_loc.path->full_path_r) < 0)
HGOTO_ERROR(H5E_FILE, H5E_MOUNT, FAIL, "unable to replace name");
done:
if (ret_value < 0) {
if (mount_point) {
if (H5G_close(mount_point) < 0)
HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEOBJ, FAIL, "unable to close mounted group");
}
else {
if (H5G_loc_free(&mp_loc) < 0)
HDONE_ERROR(H5E_SYM, H5E_CANTRELEASE, FAIL, "unable to free mount location");
}
}
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F_mount() */
/*-------------------------------------------------------------------------
* Function: H5F_unmount
*
* Purpose: Unmount the child which is mounted at the group specified by
* LOC and NAME or fail if nothing is mounted there. Neither
* file is closed.
*
* Because the mount point is specified by name and opened as a
* group, the H5G_namei() will resolve it to the root of the
* mounted file, not the group where the file is mounted.
*
* Return: Non-negative on success/Negative on failure
*
*-------------------------------------------------------------------------
*/
herr_t
H5F_unmount(const H5G_loc_t *loc, const char *name)
{
H5G_t *child_group = NULL; /* Child's group in parent mtab */
H5F_t *child = NULL; /*mounted file */
H5F_t *parent = NULL; /*file where mounted */
H5O_loc_t *mnt_oloc; /* symbol table entry for root of mounted file */
H5G_name_t mp_path; /* Mount point group hier. path */
H5O_loc_t mp_oloc; /* Mount point object location */
H5G_loc_t mp_loc; /* entry used to open mount point*/
bool mp_loc_setup = false; /* Whether mount point location is set up */
H5G_loc_t root_loc; /* Group location of root of file to unmount */
int child_idx; /* Index of child in parent's mtab */
herr_t ret_value = SUCCEED; /*return value */
FUNC_ENTER_NOAPI(FAIL)
assert(loc);
assert(name && *name);
/* Set up mount point location to fill in */
mp_loc.oloc = &mp_oloc;
mp_loc.path = &mp_path;
H5G_loc_reset(&mp_loc);
/*
* Get the mount point, or more precisely the root of the mounted file.
* If we get the root group and the file has a parent in the mount tree,
* then we must have found the mount point.
*/
if (H5G_loc_find(loc, name, &mp_loc /*out*/) < 0)
HGOTO_ERROR(H5E_FILE, H5E_NOTFOUND, FAIL, "group not found");
mp_loc_setup = true;
child = mp_loc.oloc->file;
mnt_oloc = H5G_oloc(child->shared->root_grp);
child_idx = -1;
if (child->parent && H5_addr_eq(mp_oloc.addr, mnt_oloc->addr)) {
unsigned u; /*counters */
/*
* We've been given the root group of the child. We do a reverse
* lookup in the parent's mount table to find the correct entry.
*/
parent = child->parent;
for (u = 0; u < parent->shared->mtab.nmounts; u++) {
if (parent->shared->mtab.child[u].file->shared == child->shared) {
/* Found the correct index */
child_idx = (int)u;
break;
}
}
}
else {
unsigned lt, rt, md = 0; /*binary search indices */
int cmp; /*binary search comparison value*/
/* We've been given the mount point in the parent. We use a binary
* search in the parent to locate the mounted file, if any.
*/
parent = child; /*we guessed wrong*/
lt = 0;
rt = parent->shared->mtab.nmounts;
cmp = -1;
while (lt < rt && cmp) {
md = (lt + rt) / 2;
mnt_oloc = H5G_oloc(parent->shared->mtab.child[md].group);
cmp = H5_addr_cmp(mp_oloc.addr, mnt_oloc->addr);
if (cmp < 0)
rt = md;
else
lt = md + 1;
}
if (cmp)
HGOTO_ERROR(H5E_FILE, H5E_MOUNT, FAIL, "not a mount point");
/* Found the correct index, set the info about the child */
child_idx = (int)md;
H5G_loc_free(&mp_loc);
mp_loc_setup = false;
mp_loc.oloc = mnt_oloc;
mp_loc.path = H5G_nameof(parent->shared->mtab.child[md].group);
child = parent->shared->mtab.child[child_idx].file;
/* Set the parent to be the actual parent of the discovered child.
* Could be different due to the shared mount table. */
parent = child->parent;
} /* end else */
assert(child_idx >= 0);
/* Save the information about the child from the mount table */
child_group = parent->shared->mtab.child[child_idx].group;
/* Get the group location for the root group in the file to unmount */
if (NULL == (root_loc.oloc = H5G_oloc(child->shared->root_grp)))
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to get object location for root group");
if (NULL == (root_loc.path = H5G_nameof(child->shared->root_grp)))
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to get path for root group");
/* Search the open IDs replace names to reflect unmount operation */
if (H5G_name_replace(NULL, H5G_NAME_UNMOUNT, mp_loc.oloc->file, mp_loc.path->full_path_r,
root_loc.oloc->file, root_loc.path->full_path_r) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "unable to replace name");
/* Eliminate the mount point from the table */
memmove(parent->shared->mtab.child + (unsigned)child_idx,
(parent->shared->mtab.child + (unsigned)child_idx) + 1,
((parent->shared->mtab.nmounts - (unsigned)child_idx) - 1) *
sizeof(parent->shared->mtab.child[0]));
parent->shared->mtab.nmounts -= 1;
parent->nmounts -= 1;
/* Unmount the child file from the parent file */
if (H5G_unmount(child_group) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "unable to reset group mounted flag");
if (H5G_close(child_group) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEOBJ, FAIL, "unable to close unmounted group");
/* Detach child file from parent & see if it should close */
child->parent = NULL;
if (H5F_try_close(child, NULL) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "unable to close unmounted file");
done:
/* Free the mount point location's information, if it's been set up */
if (mp_loc_setup)
H5G_loc_free(&mp_loc);
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F_unmount() */
/*-------------------------------------------------------------------------
* Function: H5F_is_mount
*
* Purpose: Check if a file is mounted within another file.
*
* Return: Success: true/false
* Failure: (can't happen)
*
*-------------------------------------------------------------------------
*/
bool
H5F_is_mount(const H5F_t *file)
{
bool ret_value = false; /* Return value */
FUNC_ENTER_NOAPI_NOINIT_NOERR
assert(file);
if (file->parent != NULL)
ret_value = true;
else
ret_value = false;
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F_is_mount() */
/*-------------------------------------------------------------------------
* Function: H5F__mount_count_ids_recurse
*
* Purpose: Helper routine for counting number of open IDs in mount
* hierarchy.
*
* Return: void
*
*-------------------------------------------------------------------------
*/
static void
H5F__mount_count_ids_recurse(H5F_t *f, unsigned *nopen_files, unsigned *nopen_objs)
{
unsigned u; /* Local index value */
FUNC_ENTER_PACKAGE_NOERR
/* Sanity check */
assert(f);
assert(nopen_files);
assert(nopen_objs);
/* If this file is still open, increment number of file IDs open */
if (H5F_ID_EXISTS(f))
*nopen_files += 1;
/* Increment number of open objects in file
* (Reduced by number of mounted files, we'll add back in the mount point's
* groups later, if they are open)
*/
*nopen_objs += (f->nopen_objs - f->nmounts);
/* Iterate over files mounted in this file and add in their open ID counts also */
for (u = 0; u < f->shared->mtab.nmounts; u++) {
/* Only recurse on children mounted to this top level file structure */
if (f->shared->mtab.child[u].file->parent == f) {
/* Increment the open object count if the mount point group has an open ID */
if (H5G_get_shared_count(f->shared->mtab.child[u].group) > 1)
*nopen_objs += 1;
H5F__mount_count_ids_recurse(f->shared->mtab.child[u].file, nopen_files, nopen_objs);
}
}
FUNC_LEAVE_NOAPI_VOID
} /* end H5F__mount_count_ids_recurse() */
/*-------------------------------------------------------------------------
* Function: H5F__mount_count_ids
*
* Purpose: Count the number of open file & object IDs in a mount hierarchy
*
* Return: SUCCEED/FAIL
*
*-------------------------------------------------------------------------
*/
herr_t
H5F__mount_count_ids(H5F_t *f, unsigned *nopen_files, unsigned *nopen_objs)
{
FUNC_ENTER_PACKAGE_NOERR
/* Sanity check */
assert(f);
assert(nopen_files);
assert(nopen_objs);
/* Find the top file in the mounting hierarchy */
while (f->parent)
f = f->parent;
/* Count open IDs in the hierarchy */
H5F__mount_count_ids_recurse(f, nopen_files, nopen_objs);
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5F__mount_count_ids() */
/*-------------------------------------------------------------------------
* Function: H5F__flush_mounts_recurse
*
* Purpose: Flush a mount hierarchy, recursively
*
* Return: SUCCEED/FAIL
*
*-------------------------------------------------------------------------
*/
static herr_t
H5F__flush_mounts_recurse(H5F_t *f)
{
unsigned nerrors = 0; /* Errors from recursive flushes */
unsigned u; /* Index variable */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_PACKAGE
/* Sanity check */
assert(f);
/* Flush all child files, not stopping for errors */
for (u = 0; u < f->shared->mtab.nmounts; u++)
if (H5F__flush_mounts_recurse(f->shared->mtab.child[u].file) < 0)
nerrors++;
/* Call the "real" flush routine, for this file */
if (H5F__flush(f) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "unable to flush file's cached information");
/* Check flush errors for children - errors are already on the stack */
if (nerrors)
HGOTO_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "unable to flush file's child mounts");
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F__flush_mounts_recurse() */
/*-------------------------------------------------------------------------
* Function: H5F_flush_mounts
*
* Purpose: Flush a mount hierarchy
*
* Return: SUCCEED/FAIL
*
*-------------------------------------------------------------------------
*/
herr_t
H5F_flush_mounts(H5F_t *f)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
/* Sanity check */
assert(f);
/* Find the top file in the mount hierarchy */
while (f->parent)
f = f->parent;
/* Flush the mounted file hierarchy */
if (H5F__flush_mounts_recurse(f) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "unable to flush mounted file hierarchy");
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F_flush_mounts() */
/*-------------------------------------------------------------------------
* Function: H5F_traverse_mount
*
* Purpose: If LNK is a mount point then copy the entry for the root
* group of the mounted file into LNK.
*
* Return: Non-negative on success/Negative on failure
*
*-------------------------------------------------------------------------
*/
herr_t
H5F_traverse_mount(H5O_loc_t *oloc /*in,out*/)
{
H5F_t *parent = oloc->file, /* File of object */
*child = NULL; /* Child file */
unsigned lt, rt, md = 0; /* Binary search indices */
int cmp;
H5O_loc_t *mnt_oloc = NULL; /* Object location for mount points */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
/* Sanity check */
assert(oloc);
/*
* The loop is necessary because we might have file1 mounted at the root
* of file2, which is mounted somewhere in file3.
*/
do {
/*
* Use a binary search to find the potential mount point in the mount
* table for the parent
*/
lt = 0;
rt = parent->shared->mtab.nmounts;
cmp = -1;
while (lt < rt && cmp) {
md = (lt + rt) / 2;
mnt_oloc = H5G_oloc(parent->shared->mtab.child[md].group);
cmp = H5_addr_cmp(oloc->addr, mnt_oloc->addr);
if (cmp < 0)
rt = md;
else
lt = md + 1;
}
/* Copy root info over to ENT */
if (0 == cmp) {
/* Get the child file */
child = parent->shared->mtab.child[md].file;
/* Get the location for the root group in the child's file */
mnt_oloc = H5G_oloc(child->shared->root_grp);
/* Release the mount point */
if (H5O_loc_free(oloc) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTFREE, FAIL, "unable to free object location");
/* Copy the entry for the root group */
if (H5O_loc_copy_deep(oloc, mnt_oloc) < 0)
HGOTO_ERROR(H5E_FILE, H5E_CANTCOPY, FAIL, "unable to copy object location");
/* In case the shared root group info points to a different file handle
* than the child, modify oloc */
oloc->file = child;
/* Switch to child's file */
parent = child;
} /* end if */
} while (!cmp);
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F_traverse_mount() */
Reference in New Issue View Git Blame Copy Permalink