/*
NAME
HDc2fstr -- convert a C string into a Fortran string IN PLACE
USAGE
intn HDc2fstr(str, len)
char * str; IN: string to convert
intn len; IN: length of Fortran string
RETURNS
SUCCEED
DESCRIPTION
Change a C string (NULL terminated) into a Fortran string.
Basically, all that is done is that the NULL is ripped out
and the string is padded with spaces
---------------------------------------------------------------------------*/
intn
HDc2fstr(char *str, intn len)
{
int i;
i=(int)HDstrlen(str);
for (; i < len; i++)
str[i] = ' ';
return SUCCEED;
} /* HDc2fstr */
/*-------------------------------------------------------------------------
* Function: h5_cleanup
*
* Purpose: Cleanup temporary test files.
* base_name contains the list of test file names.
* The file access property list is also closed.
*
* Return: Non-zero if cleanup actions were performed; zero otherwise.
*
* Programmer: Albert Cheng
* May 28, 1998
*
* Modifications:
* Albert Cheng, 2000-09-09
* Added the explicite base_name argument to replace the
* global variable FILENAME.
*
*-------------------------------------------------------------------------
*/
int
h5_cleanup(const char *base_name[], hid_t fapl)
{
char filename[1024];
char temp[2048];
int i, j;
int retval=0;
hid_t driver;
if (GetTestCleanup()){
for (i = 0; base_name[i]; i++) {
if (h5_fixname(base_name[i], fapl, filename, sizeof(filename)) == NULL)
continue;
driver = H5Pget_driver(fapl);
if (driver == H5FD_FAMILY) {
for (j = 0; /*void*/; j++) {
HDsnprintf(temp, sizeof temp, filename, j);
if (HDaccess(temp, F_OK) < 0)
break;
HDremove(temp);
}
} else if (driver == H5FD_CORE) {
hbool_t backing; /* Whether the core file has backing store */
H5Pget_fapl_core(fapl,NULL,&backing);
/* If the file was stored to disk with bacing store, remove it */
if(backing)
HDremove(filename);
} else if (driver == H5FD_MULTI) {
H5FD_mem_t mt;
assert(HDstrlen(multi_letters)==H5FD_MEM_NTYPES);
for (mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t,mt)) {
HDsnprintf(temp, sizeof temp, "%s-%c.h5",
filename, multi_letters[mt]);
HDremove(temp); /*don't care if it fails*/
}
} else {
HDremove(filename);
}
}
retval = 1;
}
H5Pclose(fapl);
return retval;
}
/*
* Setup a test function and add it to the list of tests.
* It must have no parameters and returns void.
* TheName--short test name.
* If the name starts with '-', do not run it by default.
* TheCall--the test routine.
* Cleanup--the cleanup routine for the test.
* TheDescr--Long description of the test.
* Parameters--pointer to extra parameters. Use NULL if none used.
* Since only the pointer is copied, the contents should not change.
* Return: Void
* exit EXIT_FAILURE if error is encountered.
*/
void
AddTest(const char *TheName, void (*TheCall) (void), void (*Cleanup) (void), const char *TheDescr, const void *Parameters)
{
/* Sanity checking */
if (Index >= MAXNUMOFTESTS) {
printf("Too many tests added, increase MAXNUMOFTESTS(%d).\n",
MAXNUMOFTESTS);
exit(EXIT_FAILURE);
} /* end if */
if (HDstrlen(TheDescr) >= MAXTESTDESC) {
printf("Test description too long, increase MAXTESTDESC(%d).\n",
MAXTESTDESC);
exit(EXIT_FAILURE);
} /* end if */
if (HDstrlen(TheName) >= MAXTESTNAME) {
printf("Test name too long, increase MAXTESTNAME(%d).\n",
MAXTESTNAME);
exit(EXIT_FAILURE);
} /* end if */
/* Set up test function */
HDstrcpy(Test[Index].Description, TheDescr);
if (*TheName != '-'){
HDstrcpy(Test[Index].Name, TheName);
Test[Index].SkipFlag = 0;
}
else { /* skip test by default */
HDstrcpy(Test[Index].Name, TheName+1);
Test[Index].SkipFlag = 1;
}
Test[Index].Call = TheCall;
Test[Index].Cleanup = Cleanup;
Test[Index].NumErrors = -1;
Test[Index].Parameters = Parameters;
/* Increment test count */
Index++;
}
/*
* test_vl_string
* Tests variable-length string datatype with UTF-8 strings.
*/
void test_vl_string(hid_t fid, const char *string)
{
hid_t type_id, space_id, dset_id;
hsize_t dims = 1;
hsize_t size; /* Number of bytes used */
char *read_buf[1];
herr_t ret;
/* Create dataspace for datasets */
space_id = H5Screate_simple(RANK, &dims, NULL);
CHECK(space_id, FAIL, "H5Screate_simple");
/* Create a datatype to refer to */
type_id = H5Tcopy(H5T_C_S1);
CHECK(type_id, FAIL, "H5Tcopy");
ret = H5Tset_size(type_id, H5T_VARIABLE);
CHECK(ret, FAIL, "H5Tset_size");
/* Create a dataset */
dset_id = H5Dcreate2(fid, VL_DSET1_NAME, type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
CHECK(dset_id, FAIL, "H5Dcreate2");
/* Write dataset to disk */
ret = H5Dwrite(dset_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, &string);
CHECK(ret, FAIL, "H5Dwrite");
/* Make certain the correct amount of memory will be used */
ret = H5Dvlen_get_buf_size(dset_id, type_id, space_id, &size);
CHECK(ret, FAIL, "H5Dvlen_get_buf_size");
VERIFY(size, (hsize_t)HDstrlen(string) + 1, "H5Dvlen_get_buf_size");
/* Read dataset from disk */
ret = H5Dread(dset_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, read_buf);
CHECK(ret, FAIL, "H5Dread");
/* Compare data read in */
VERIFY(HDstrcmp(string, read_buf[0]), 0, "strcmp");
/* Reclaim the read VL data */
ret = H5Dvlen_reclaim(type_id, space_id, H5P_DEFAULT, read_buf);
CHECK(ret, FAIL, "H5Dvlen_reclaim");
/* Close all */
ret = H5Dclose(dset_id);
CHECK(ret, FAIL, "H5Dclose");
ret = H5Tclose(type_id);
CHECK(ret, FAIL, "H5Tclose");
ret = H5Sclose(space_id);
CHECK(ret, FAIL, "H5Sclose");
}
/*--------------------------------------------------------------------------
NAME
H5O_attr_size
PURPOSE
Return the raw message size in bytes
USAGE
size_t H5O_attr_size(f, mesg)
H5F_t *f; IN: pointer to the HDF5 file struct
const void *mesg; IN: Pointer to the source attribute struct
RETURNS
Size of message on success, 0 on failure
DESCRIPTION
This function returns the size of the raw attribute message on
success. (Not counting the message type or size fields, only the data
portion of the message). It doesn't take into account alignment.
*
* Modified:
* Robb Matzke, 17 Jul 1998
* Added padding between message parts for alignment.
--------------------------------------------------------------------------*/
static size_t
H5O_attr_size(const H5F_t UNUSED *f, const void *_mesg)
{
const H5A_t *attr = (const H5A_t *)_mesg;
size_t name_len;
unsigned version; /* Attribute version */
hbool_t type_shared; /* Flag to indicate that a shared datatype is used for this attribute */
size_t ret_value = 0;
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_attr_size);
assert(attr);
name_len = HDstrlen(attr->name)+1;
/* Check whether datatype is shared */
if(H5T_committed(attr->dt))
type_shared = TRUE;
else
type_shared = FALSE;
/* Check which version to write out */
if(type_shared)
version = H5O_ATTR_VERSION_NEW; /* Write out new version if shared datatype */
else
version = H5O_ATTR_VERSION;
if(version < H5O_ATTR_VERSION_NEW)
ret_value = 1 + /*version */
1 + /*reserved */
2 + /*name size inc. null */
2 + /*type size */
2 + /*space size */
H5O_ALIGN(name_len) + /*attribute name */
H5O_ALIGN(attr->dt_size) + /*data type */
H5O_ALIGN(attr->ds_size) + /*data space */
attr->data_size; /*the data itself */
else
ret_value = 1 + /*version */
1 + /*flags */
2 + /*name size inc. null */
2 + /*type size */
2 + /*space size */
name_len + /*attribute name */
attr->dt_size + /*data type */
attr->ds_size + /*data space */
attr->data_size; /*the data itself */
FUNC_LEAVE_NOAPI(ret_value);
}
/*--------------------------------------------------------------------------
* Function: H5L_build_name
*
* Purpose: Prepend PREFIX to FILE_NAME and store in FULL_NAME
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Vailin Choi, April 2, 2008
*
* Modification: Raymond Lu, 14 Jan. 2009
* Added support for OpenVMS pathname
--------------------------------------------------------------------------*/
static herr_t
H5L_build_name(char *prefix, char *file_name, char **full_name/*out*/)
{
size_t prefix_len; /* length of prefix */
size_t fname_len; /* Length of external link file name */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
prefix_len = HDstrlen(prefix);
fname_len = HDstrlen(file_name);
/* Allocate a buffer to hold the filename + prefix + possibly the delimiter + terminating null byte */
if(NULL == (*full_name = (char *)H5MM_malloc(prefix_len + fname_len + 2)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate filename buffer")
/* Compose the full file name */
HDsnprintf(*full_name, (prefix_len + fname_len + 2), "%s%s%s", prefix,
(H5_CHECK_DELIMITER(prefix[prefix_len - 1]) ? "" : H5_DIR_SEPS), file_name);
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5L_build_name() */
/****************************************************************
**
** test_refstr_own(): Test basic H5RS (ref-counted strings) code.
** Tests transferring ownership of dynamically allocated strings
** to ref-counted strings.
**
****************************************************************/
static void
test_refstr_own(void)
{
H5RS_str_t *rs; /* Ref-counted string created */
char *s; /* Pointer to string to transfer */
const char *t; /* Temporary pointers to string */
int cmp; /* Comparison value */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(5, ("Testing Transferring Ref-Counted Strings\n"));
/* Initialize buffer */
s = (char *)H5FL_BLK_MALLOC(str_buf,HDstrlen("foo") + 1);
CHECK(s, NULL, "H5FL_BLK_MALLOC");
HDstrcpy(s, "foo");
/* Transfer ownership of dynamically allocated string to ref-counted string */
rs=H5RS_own(s);
CHECK(rs, NULL, "H5RS_own");
/* Get pointer to raw string in ref-counted string */
t=H5RS_get_str(rs);
CHECK(t, NULL, "H5RS_get_str");
VERIFY(t, s, "transferring");
cmp=HDstrcmp(s,t);
VERIFY(cmp, 0, "HDstrcmp");
/* Increment reference count (should NOT duplicate string) */
ret=H5RS_incr(rs);
CHECK(ret, FAIL, "H5RS_incr");
/* Change the buffer initially wrapped */
*s='F';
/* Get pointer to raw string in ref-counted string */
t=H5RS_get_str(rs);
CHECK(t, NULL, "H5RS_get_str");
VERIFY(t, s, "transferring");
cmp=HDstrcmp(t,s);
VERIFY(cmp, 0, "HDstrcmp");
/* Decrement reference count for string */
ret=H5RS_decr(rs);
CHECK(ret, FAIL, "H5RS_decr");
ret=H5RS_decr(rs);
CHECK(ret, FAIL, "H5RS_decr");
} /* end test_refstr_own() */
/*------------------------------------------------------------------------- * Function: H5MM_strdup * * Purpose: Duplicates a string. If the string to be duplicated is the * null pointer, then return null. If the string to be duplicated * is the empty string then return a new empty string. * * Return: Success: Ptr to a new string (or null if no string). * * Failure: abort() * * Programmer: Robb Matzke * [email protected] * Jul 10 1997 * * Modifications: * *------------------------------------------------------------------------- */ char * H5MM_strdup(const char *s) { char *ret_value; FUNC_ENTER_NOAPI(H5MM_strdup, NULL) if(!s) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "null string") if(NULL == (ret_value = (char *)H5MM_malloc(HDstrlen(s) + 1))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") HDstrcpy(ret_value, s); done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5MM_strdup() */
/*------------------------------------------------------------------------- * Function: H5O_name_size * * Purpose: Returns the size of the raw message in bytes not * counting the message typ or size fields, but only the data * fields. This function doesn't take into account * alignment. * * Return: Success: Message data size in bytes w/o alignment. * * Failure: Negative * * Programmer: Robb Matzke * [email protected] * Aug 12 1997 * * Modifications: * *------------------------------------------------------------------------- */ static size_t H5O_name_size(const H5F_t H5_ATTR_UNUSED *f, hbool_t H5_ATTR_UNUSED disable_shared, const void *_mesg) { const H5O_name_t *mesg = (const H5O_name_t *) _mesg; size_t ret_value; FUNC_ENTER_NOAPI_NOINIT_NOERR /* check args */ HDassert(f); HDassert(mesg); ret_value = mesg->s ? HDstrlen(mesg->s) + 1 : 0; FUNC_LEAVE_NOAPI(ret_value) }
/*------------------------------------------------------------------------- * Function: H5MM_xstrdup * * Purpose: Duplicates a string. If the string to be duplicated is the * null pointer, then return null. If the string to be duplicated * is the empty string then return a new empty string. * * Return: Success: Ptr to a new string (or null if no string). * * Failure: abort() * * Programmer: Robb Matzke * [email protected] * Jul 10 1997 * *------------------------------------------------------------------------- */ char * H5MM_xstrdup(const char *s) { char *ret_value = NULL; /* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5MM_xstrdup) if(s) { ret_value = (char *)H5MM_malloc(HDstrlen(s) + 1); HDassert(ret_value); HDstrcpy(ret_value, s); } /* end if */ FUNC_LEAVE_NOAPI(ret_value) } /* end H5MM_xstrdup() */
/*------------------------------------------------------------------------- * Function: diff_basename * * Purpose: Returns a pointer to the last component absolute name * * Programmer: Pedro Vicente, [email protected] * * Date: May 9, 2003 * *------------------------------------------------------------------------- */ const char* diff_basename(const char *name) { size_t i; if (name==NULL) return NULL; /* Find the end of the base name */ i = HDstrlen(name); while (i>0 && '/'==name[i-1]) --i; /* Skip backward over base name */ while (i>0 && '/'!=name[i-1]) --i; return(name+i); }
/*------------------------------------------------------------------------- * Function: H5MM_xstrdup * * Purpose: Duplicates a string. If the string to be duplicated is the * null pointer, then return null. If the string to be duplicated * is the empty string then return a new empty string. * * Return: Success: Ptr to a new string (or null if no string). * * Failure: abort() * * Programmer: Robb Matzke * [email protected] * Jul 10 1997 * * Modifications: * *------------------------------------------------------------------------- */ char * H5MM_xstrdup(const char *s) { char *ret_value=NULL; /* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5MM_xstrdup); if (s) { ret_value = H5MM_malloc(HDstrlen(s) + 1); assert (ret_value); HDstrcpy(ret_value, s); } /* end if */ #ifdef LATER done: #endif /* LATER */ FUNC_LEAVE_NOAPI(ret_value); }
int
getTmpName(char **pname)
{
int length;
static int count = 0;
char s[32];
(void) sprintf(s, "%she%d.%d", TDIR, (int)getpid(), count);
count++;
length = (int)HDstrlen(s);
if (length <= 0)
return FAIL;
*pname = (char *) HDmalloc(length + 1);
HDstrcpy(*pname, s);
return length;
}
/*-------------------------------------------------------------------------
* Function: generate_symbols
*
* Purpose: Initializes the global dataset infomration arrays.
*
* Parameters: N/A
*
* Return: Success: 0
* Failure: Can't fail
*
*-------------------------------------------------------------------------
*/
int
generate_symbols(void)
{
unsigned u, v; /* Local index variables */
for(u = 0; u < NLEVELS; u++) {
symbol_info[u] = (symbol_info_t *)HDmalloc(symbol_count[u] * sizeof(symbol_info_t));
for(v = 0; v < symbol_count[u]; v++) {
char name_buf[64];
generate_name(name_buf, u, v);
symbol_info[u][v].name = (char *)HDmalloc(HDstrlen(name_buf) + 1);
HDstrcpy(symbol_info[u][v].name, name_buf);
symbol_info[u][v].dsid = -1;
symbol_info[u][v].nrecords = 0;
} /* end for */
} /* end for */
return 0;
} /* end generate_symbols() */
/*-------------------------------------------------------------------------
* Function: H5_bandwidth
*
* Purpose: Prints the bandwidth (bytes per second) in a field 10
* characters wide widh four digits of precision like this:
*
* NaN If <=0 seconds
* 1234. TB/s
* 123.4 TB/s
* 12.34 GB/s
* 1.234 MB/s
* 4.000 kB/s
* 1.000 B/s
* 0.000 B/s If NBYTES==0
* 1.2345e-10 For bandwidth less than 1
* 6.7893e+94 For exceptionally large values
* 6.678e+106 For really big values
*
* Return: void
*
* Programmer: Robb Matzke
* Wednesday, August 5, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
H5_bandwidth(char *buf/*out*/, double nbytes, double nseconds)
{
double bw;
if (nseconds<=0.0) {
HDstrcpy(buf, " NaN");
} else {
bw = nbytes/nseconds;
if (fabs(bw) < 0.0000000001) {
/* That is == 0.0, but direct comparison between floats is bad */
HDstrcpy(buf, "0.000 B/s");
} else if (bw<1.0) {
sprintf(buf, "%10.4e", bw);
} else if (bw<1024.0) {
sprintf(buf, "%05.4f", bw);
HDstrcpy(buf+5, " B/s");
} else if (bw<1024.0*1024.0) {
sprintf(buf, "%05.4f", bw/1024.0);
HDstrcpy(buf+5, " kB/s");
} else if (bw<1024.0*1024.0*1024.0) {
sprintf(buf, "%05.4f", bw/(1024.0*1024.0));
HDstrcpy(buf+5, " MB/s");
} else if (bw<1024.0*1024.0*1024.0*1024.0) {
sprintf(buf, "%05.4f",
bw/(1024.0*1024.0*1024.0));
HDstrcpy(buf+5, " GB/s");
} else if (bw<1024.0*1024.0*1024.0*1024.0*1024.0) {
sprintf(buf, "%05.4f",
bw/(1024.0*1024.0*1024.0*1024.0));
HDstrcpy(buf+5, " TB/s");
} else {
sprintf(buf, "%10.4e", bw);
if (HDstrlen(buf)>10) {
sprintf(buf, "%10.3e", bw);
}
}
}
} /* end H5_bandwidth() */
/*-------------------------------------------------------------------------
* Function: H5O_pline_decode
*
* Purpose: Decodes a filter pipeline message.
*
* Return: Success: Ptr to the native message.
* Failure: NULL
*
* Programmer: Robb Matzke
* Wednesday, April 15, 1998
*
*-------------------------------------------------------------------------
*/
static void *
H5O_pline_decode(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, H5O_t H5_ATTR_UNUSED *open_oh,
unsigned H5_ATTR_UNUSED mesg_flags, unsigned H5_ATTR_UNUSED *ioflags, const uint8_t *p)
{
H5O_pline_t *pline = NULL; /* Pipeline message */
H5Z_filter_info_t *filter; /* Filter to decode */
size_t name_length; /* Length of filter name */
size_t i; /* Local index variable */
void *ret_value = NULL; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/* check args */
HDassert(p);
/* Allocate space for I/O pipeline message */
if(NULL == (pline = H5FL_CALLOC(H5O_pline_t)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
/* Version */
pline->version = *p++;
if(pline->version < H5O_PLINE_VERSION_1 || pline->version > H5O_PLINE_VERSION_LATEST)
HGOTO_ERROR(H5E_PLINE, H5E_CANTLOAD, NULL, "bad version number for filter pipeline message")
/* Number of filters */
pline->nused = *p++;
if(pline->nused > H5Z_MAX_NFILTERS)
HGOTO_ERROR(H5E_PLINE, H5E_CANTLOAD, NULL, "filter pipeline message has too many filters")
/* Reserved */
if(pline->version == H5O_PLINE_VERSION_1)
p += 6;
/* Allocate array for filters */
pline->nalloc = pline->nused;
if(NULL == (pline->filter = (H5Z_filter_info_t *)H5MM_calloc(pline->nalloc * sizeof(pline->filter[0]))))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
/* Decode filters */
for(i = 0, filter = &pline->filter[0]; i < pline->nused; i++, filter++) {
/* Filter ID */
UINT16DECODE(p, filter->id);
/* Length of filter name */
if(pline->version > H5O_PLINE_VERSION_1 && filter->id < H5Z_FILTER_RESERVED)
name_length = 0;
else {
UINT16DECODE(p, name_length);
if(pline->version == H5O_PLINE_VERSION_1 && name_length % 8)
HGOTO_ERROR(H5E_PLINE, H5E_CANTLOAD, NULL, "filter name length is not a multiple of eight")
} /* end if */
/* Filter flags */
UINT16DECODE(p, filter->flags);
/* Number of filter parameters ("client data elements") */
UINT16DECODE(p, filter->cd_nelmts);
/* Filter name, if there is one */
if(name_length) {
size_t actual_name_length; /* Actual length of name */
/* Determine actual name length (without padding, but with null terminator) */
actual_name_length = HDstrlen((const char *)p) + 1;
HDassert(actual_name_length <= name_length);
/* Allocate space for the filter name, or use the internal buffer */
if(actual_name_length > H5Z_COMMON_NAME_LEN) {
filter->name = (char *)H5MM_malloc(actual_name_length);
if(NULL == filter->name)
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for filter name")
} /* end if */
else
filter->name = filter->_name;
HDstrncpy(filter->name, (const char *)p, actual_name_length);
p += name_length;
} /* end if */
/*-------------------------------------------------------------------------
* Function: h5_get_file_size
*
* Purpose: Get the current size of a file (in bytes)
*
* Return: Success: Size of file in bytes
* Failure: -1
*
* Programmer: Quincey Koziol
* Saturday, March 22, 2003
*
*-------------------------------------------------------------------------
*/
h5_stat_size_t
h5_get_file_size(const char *filename, hid_t fapl)
{
char temp[2048]; /* Temporary buffer for file names */
h5_stat_t sb; /* Structure for querying file info */
int j = 0;
if(fapl == H5P_DEFAULT) {
/* Get the file's statistics */
if(0 == HDstat(filename, &sb))
return((h5_stat_size_t)sb.st_size);
} /* end if */
else {
hid_t driver; /* VFD used for file */
/* Get the driver used when creating the file */
if((driver = H5Pget_driver(fapl)) < 0)
return(-1);
/* Check for simple cases */
if(driver == H5FD_SEC2 || driver == H5FD_STDIO || driver == H5FD_CORE ||
#ifdef H5_HAVE_PARALLEL
driver == H5FD_MPIO ||
#endif /* H5_HAVE_PARALLEL */
#ifdef H5_HAVE_WINDOWS
driver == H5FD_WINDOWS ||
#endif /* H5_HAVE_WINDOWS */
#ifdef H5_HAVE_DIRECT
driver == H5FD_DIRECT ||
#endif /* H5_HAVE_DIRECT */
driver == H5FD_LOG) {
/* Get the file's statistics */
if(0 == HDstat(filename, &sb))
return((h5_stat_size_t)sb.st_size);
} /* end if */
else if(driver == H5FD_MULTI) {
H5FD_mem_t mt;
h5_stat_size_t tot_size = 0;
HDassert(HDstrlen(multi_letters) == H5FD_MEM_NTYPES);
for(mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t, mt)) {
/* Create the filename to query */
HDsnprintf(temp, sizeof temp, "%s-%c.h5", filename, multi_letters[mt]);
/* Check for existence of file */
if(0 == HDaccess(temp, F_OK)) {
/* Get the file's statistics */
if(0 != HDstat(temp, &sb))
return(-1);
/* Add to total size */
tot_size += (h5_stat_size_t)sb.st_size;
} /* end if */
} /* end for */
/* Return total size */
return(tot_size);
} /* end if */
else if(driver == H5FD_FAMILY) {
h5_stat_size_t tot_size = 0;
/* Try all filenames possible, until we find one that's missing */
for(j = 0; /*void*/; j++) {
/* Create the filename to query */
HDsnprintf(temp, sizeof temp, filename, j);
/* Check for existence of file */
if(HDaccess(temp, F_OK) < 0)
break;
/* Get the file's statistics */
if(0 != HDstat(temp, &sb))
return(-1);
/* Add to total size */
tot_size += (h5_stat_size_t)sb.st_size;
} /* end for */
/* Return total size */
return(tot_size);
} /* end if */
else {
HDassert(0 && "Unknown VFD!");
} /* end else */
} /* end else */
return(-1);
} /* end get_file_size() */
/*
* Function: h5_set_info_object
* Purpose: Process environment variables setting to set up MPI Info
* object.
* Return: 0 if all is fine; otherwise non-zero.
* Programmer: Albert Cheng, 2002/05/21.
* Modifications:
* Bill Wendling, 2002/05/31
* Modified so that the HDF5_MPI_INFO environment variable can
* be a semicolon separated list of "key=value" pairings. Most
* of the code is to remove any whitespaces which might be
* surrounding the "key=value" pairs.
*/
int
h5_set_info_object(void)
{
char *envp; /* environment pointer */
int ret_value=0;
/* handle any MPI INFO hints via $HDF5_MPI_INFO */
if ((envp = getenv("HDF5_MPI_INFO")) != NULL){
char *next, *valp;
valp = envp = next = HDstrdup(envp);
if (!valp) return 0;
/* create an INFO object if not created yet */
if (h5_io_info_g == MPI_INFO_NULL)
MPI_Info_create(&h5_io_info_g);
do {
size_t len;
char *key_val, *endp, *namep;
if (*valp == ';')
valp++;
/* copy key/value pair into temporary buffer */
len = strcspn(valp, ";");
next = &valp[len];
key_val = (char *)HDcalloc(1, len + 1);
/* increment the next pointer past the terminating semicolon */
if (*next == ';')
++next;
namep = HDstrncpy(key_val, valp, len);
/* pass up any beginning whitespaces */
while (*namep && (*namep == ' ' || *namep == '\t'))
namep++;
if (!*namep) continue; /* was all white space, so move to next k/v pair */
/* eat up any ending white spaces */
endp = &namep[HDstrlen(namep) - 1];
while (endp && (*endp == ' ' || *endp == '\t'))
*endp-- = '\0';
/* find the '=' */
valp = HDstrchr(namep, '=');
if (valp != NULL) { /* it's a valid key/value pairing */
char *tmp_val = valp + 1;
/* change '=' to \0, move valp down one */
*valp-- = '\0';
/* eat up ending whitespace on the "key" part */
while (*valp == ' ' || *valp == '\t')
*valp-- = '\0';
valp = tmp_val;
/* eat up beginning whitespace on the "value" part */
while (*valp == ' ' || *valp == '\t')
*valp++ = '\0';
/* actually set the darned thing */
if (MPI_SUCCESS != MPI_Info_set(h5_io_info_g, namep, valp)) {
printf("MPI_Info_set failed\n");
ret_value = -1;
}
}
valp = next;
HDfree(key_val);
} while (next && *next);
HDfree(envp);
}
return ret_value;
}
/*-------------------------------------------------------------------------
* Function: h5_fileaccess
*
* Purpose: Returns a file access template which is the default template
* but with a file driver set according to the constant or
* environment variable HDF5_DRIVER
*
* Return: Success: A file access property list
*
* Failure: -1
*
* Programmer: Robb Matzke
* Thursday, November 19, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
hid_t
h5_fileaccess(void)
{
const char *val = NULL;
const char *name;
char s[1024];
hid_t fapl = -1;
/* First use the environment variable, then the constant */
val = HDgetenv("HDF5_DRIVER");
#ifdef HDF5_DRIVER
if (!val)
val = HDF5_DRIVER;
#endif
if ((fapl=H5Pcreate(H5P_FILE_ACCESS))<0)
return -1;
if (!val || !*val)
return fapl; /*use default*/
HDstrncpy(s, val, sizeof s);
s[sizeof(s)-1] = '\0';
if (NULL==(name=HDstrtok(s, " \t\n\r"))) return fapl;
if (!HDstrcmp(name, "sec2")) {
/* Unix read() and write() system calls */
if (H5Pset_fapl_sec2(fapl)<0) return -1;
} else if (!HDstrcmp(name, "stdio")) {
/* Standard C fread() and fwrite() system calls */
if (H5Pset_fapl_stdio(fapl)<0) return -1;
} else if (!HDstrcmp(name, "core")) {
/* In-memory driver settings (backing store on, 1 MB increment) */
if (H5Pset_fapl_core(fapl, (size_t)1, TRUE)<0) return -1;
} else if (!HDstrcmp(name, "core_paged")) {
/* In-memory driver with write tracking and paging on */
if (H5Pset_fapl_core(fapl, (size_t)1, TRUE)<0) return -1;
if (H5Pset_core_write_tracking(fapl, TRUE, (size_t)4096)<0) return -1;
} else if (!HDstrcmp(name, "split")) {
/* Split meta data and raw data each using default driver */
if (H5Pset_fapl_split(fapl,
"-m.h5", H5P_DEFAULT,
"-r.h5", H5P_DEFAULT)<0)
return -1;
} else if (!HDstrcmp(name, "multi")) {
/* Multi-file driver, general case of the split driver */
H5FD_mem_t memb_map[H5FD_MEM_NTYPES];
hid_t memb_fapl[H5FD_MEM_NTYPES];
const char *memb_name[H5FD_MEM_NTYPES];
char sv[H5FD_MEM_NTYPES][1024];
haddr_t memb_addr[H5FD_MEM_NTYPES];
H5FD_mem_t mt;
HDmemset(memb_map, 0, sizeof memb_map);
HDmemset(memb_fapl, 0, sizeof memb_fapl);
HDmemset(memb_name, 0, sizeof memb_name);
HDmemset(memb_addr, 0, sizeof memb_addr);
HDassert(HDstrlen(multi_letters)==H5FD_MEM_NTYPES);
for(mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t, mt)) {
memb_fapl[mt] = H5P_DEFAULT;
sprintf(sv[mt], "%%s-%c.h5", multi_letters[mt]);
memb_name[mt] = sv[mt];
memb_addr[mt] = (haddr_t)MAX(mt - 1, 0) * (HADDR_MAX / 10);
} /* end for */
if (H5Pset_fapl_multi(fapl, memb_map, memb_fapl, memb_name,
memb_addr, FALSE)<0) {
return -1;
}
} else if (!HDstrcmp(name, "family")) {
hsize_t fam_size = 100*1024*1024; /*100 MB*/
/* Family of files, each 1MB and using the default driver */
if ((val=HDstrtok(NULL, " \t\n\r")))
fam_size = (hsize_t)(HDstrtod(val, NULL) * 1024*1024);
if (H5Pset_fapl_family(fapl, fam_size, H5P_DEFAULT)<0)
return -1;
} else if (!HDstrcmp(name, "log")) {
unsigned log_flags = H5FD_LOG_LOC_IO | H5FD_LOG_ALLOC;
/* Log file access */
if ((val = HDstrtok(NULL, " \t\n\r")))
log_flags = (unsigned)HDstrtol(val, NULL, 0);
if (H5Pset_fapl_log(fapl, NULL, log_flags, (size_t)0) < 0)
return -1;
} else if (!HDstrcmp(name, "direct")) {
#ifdef H5_HAVE_DIRECT
/* Linux direct read() and write() system calls. Set memory boundary, file block size,
* and copy buffer size to the default values. */
if (H5Pset_fapl_direct(fapl, 1024, 4096, 8*4096)<0)
return -1;
#endif
} else if(!HDstrcmp(name, "latest")) {
/* use the latest format */
if(H5Pset_libver_bounds(fapl, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
return -1;
} else {
/* Unknown driver */
return -1;
}
return fapl;
}
/*-------------------------------------------------------------------------
* Function: h5_fixname
*
* Purpose: Create a file name from a file base name like `test' and
* return it through the FULLNAME (at most SIZE characters
* counting the null terminator). The full name is created by
* prepending the contents of HDF5_PREFIX (separated from the
* base name by a slash) and appending a file extension based on
* the driver supplied, resulting in something like
* `ufs:/u/matzke/test.h5'.
*
* Return: Success: The FULLNAME pointer.
*
* Failure: NULL if BASENAME or FULLNAME is the null
* pointer or if FULLNAME isn't large enough for
* the result.
*
* Programmer: Robb Matzke
* Thursday, November 19, 1998
*
*-------------------------------------------------------------------------
*/
char *
h5_fixname(const char *base_name, hid_t fapl, char *fullname, size_t size)
{
const char *prefix = NULL;
const char *suffix = ".h5"; /* suffix has default */
char *ptr, last = '\0';
size_t i, j;
hid_t driver = -1;
int isppdriver = 0; /* if the driver is MPI parallel */
if (!base_name || !fullname || size < 1)
return NULL;
HDmemset(fullname, 0, size);
/* figure out the suffix */
if(H5P_DEFAULT != fapl) {
if((driver = H5Pget_driver(fapl)) < 0)
return NULL;
if(H5FD_FAMILY == driver)
suffix = "%05d.h5";
else if (H5FD_MULTI == driver)
suffix = NULL;
}
/* Must first check fapl is not H5P_DEFAULT (-1) because H5FD_XXX
* could be of value -1 if it is not defined.
*/
isppdriver = H5P_DEFAULT != fapl && (H5FD_MPIO==driver);
/* Check HDF5_NOCLEANUP environment setting.
* (The #ifdef is needed to prevent compile failure in case MPI is not
* configured.)
*/
if(isppdriver) {
#ifdef H5_HAVE_PARALLEL
if(getenv_all(MPI_COMM_WORLD, 0, "HDF5_NOCLEANUP"))
SetTestNoCleanup();
#endif /* H5_HAVE_PARALLEL */
} else {
if(HDgetenv("HDF5_NOCLEANUP"))
SetTestNoCleanup();
}
/* Check what prefix to use for test files. Process HDF5_PARAPREFIX and
* HDF5_PREFIX.
* Use different ones depending on parallel or serial driver used.
* (The #ifdef is needed to prevent compile failure in case MPI is not
* configured.)
*/
if(isppdriver) {
#ifdef H5_HAVE_PARALLEL
/*
* For parallel:
* First use command line option, then the environment
* variable, then try the constant
*/
static int explained = 0;
prefix = (paraprefix ? paraprefix : getenv_all(MPI_COMM_WORLD, 0, "HDF5_PARAPREFIX"));
if (!prefix && !explained) {
/* print hint by process 0 once. */
int mpi_rank;
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
if (mpi_rank == 0)
printf("*** Hint ***\n"
"You can use environment variable HDF5_PARAPREFIX to "
"run parallel test files in a\n"
"different directory or to add file type prefix. E.g.,\n"
" HDF5_PARAPREFIX=pfs:/PFS/user/me\n"
" export HDF5_PARAPREFIX\n"
"*** End of Hint ***\n");
explained = TRUE;
#ifdef HDF5_PARAPREFIX
prefix = HDF5_PARAPREFIX;
#endif /* HDF5_PARAPREFIX */
}
#endif /* H5_HAVE_PARALLEL */
} else {
/*
* For serial:
* First use the environment variable, then try the constant
*/
prefix = HDgetenv("HDF5_PREFIX");
#ifdef HDF5_PREFIX
if (!prefix)
prefix = HDF5_PREFIX;
#endif /* HDF5_PREFIX */
}
/* Prepend the prefix value to the base name */
if (prefix && *prefix) {
if (isppdriver) {
/* This is a parallel system */
char *subdir;
if (!HDstrcmp(prefix, HDF5_PARAPREFIX)) {
/*
* If the prefix specifies the HDF5_PARAPREFIX directory, then
* default to using the "/tmp/$USER" or "/tmp/$LOGIN"
* directory instead.
*/
char *user, *login;
user = HDgetenv("USER");
login = HDgetenv("LOGIN");
subdir = (user ? user : login);
if (subdir) {
for (i = 0; i < size && prefix[i]; i++)
fullname[i] = prefix[i];
fullname[i++] = '/';
for (j = 0; i < size && subdir[j]; ++i, ++j)
fullname[i] = subdir[j];
}
}
if (!fullname[0]) {
/* We didn't append the prefix yet */
HDstrncpy(fullname, prefix, size);
fullname[size -1] = '\0';
}
if (HDstrlen(fullname) + HDstrlen(base_name) + 1 < size) {
/*
* Append the base_name with a slash first. Multiple
* slashes are handled below.
*/
h5_stat_t buf;
if (HDstat(fullname, &buf) < 0)
/* The directory doesn't exist just yet */
if (HDmkdir(fullname, (mode_t)0755) < 0 && errno != EEXIST)
/*
* We couldn't make the "/tmp/${USER,LOGIN}"
* subdirectory. Default to PREFIX's original
* prefix value.
*/
HDstrcpy(fullname, prefix);
HDstrcat(fullname, "/");
HDstrcat(fullname, base_name);
} else {
/* Buffer is too small */
return NULL;
}
} else {
if (HDsnprintf(fullname, size, "%s/%s", prefix, base_name) == (int)size)
/* Buffer is too small */
return NULL;
}
} else if (HDstrlen(base_name) >= size) {
/* Buffer is too small */
return NULL;
} else {
HDstrcpy(fullname, base_name);
}
/* Append a suffix */
if (suffix) {
if (HDstrlen(fullname) + HDstrlen(suffix) >= size)
return NULL;
HDstrcat(fullname, suffix);
}
/* Remove any double slashes in the filename */
for (ptr = fullname, i = j = 0; ptr && i < size; i++, ptr++) {
if (*ptr != '/' || last != '/')
fullname[j++] = *ptr;
last = *ptr;
}
return fullname;
}
/*
* test_strpad
* Tests string padding for a UTF-8 string.
* Converts strings to shorter and then longer strings.
* Borrows heavily from dtypes.c, but is more complicated because
* the string is randomly generated.
*/
void test_strpad(hid_t UNUSED fid, const char *string)
{
/* buf is used to hold the data that H5Tconvert operates on. */
char buf[LONG_BUF_SIZE];
/* cmpbuf holds the output that H5Tconvert should produce,
* to compare against the actual output. */
char cmpbuf[LONG_BUF_SIZE];
/* new_string is a slightly modified version of the UTF-8
* string to make the tests run more smoothly. */
char new_string[MAX_STRING_LENGTH + 2];
size_t length; /* Length of new_string in bytes */
size_t small_len; /* Size of the small datatype */
size_t big_len; /* Size of the larger datatype */
hid_t src_type, dst_type;
herr_t ret;
/* The following tests are simpler if the UTF-8 string contains
* the right number of bytes (even or odd, depending on the test).
* We create a 'new_string' whose length is convenient by prepending
* an 'x' to 'string' when necessary. */
length = HDstrlen(string);
if(length % 2 != 1)
{
HDstrcpy(new_string, "x");
HDstrcat(new_string, string);
length++;
} else {
HDstrcpy(new_string, string);
}
/* Convert a null-terminated string to a shorter and longer null
* terminated string. */
/* Create a src_type that holds the UTF-8 string and its final NULL */
big_len = length + 1; /* +1 byte for final NULL */
HDassert((2*big_len)<=sizeof(cmpbuf));
src_type = mkstr(big_len, H5T_STR_NULLTERM);
CHECK(src_type, FAIL, "mkstr");
/* Create a dst_type that holds half of the UTF-8 string and a final
* NULL */
small_len = (length + 1) / 2;
dst_type = mkstr(small_len, H5T_STR_NULLTERM);
CHECK(dst_type, FAIL, "mkstr");
/* Fill the buffer with two copies of the UTF-8 string, each with a
* terminating NULL. It will look like "abcdefg\0abcdefg\0". */
strncpy(buf, new_string, big_len);
strncpy(&buf[big_len], new_string, big_len);
ret = H5Tconvert(src_type, dst_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* After conversion, the buffer should look like
* "abc\0abc\0abcdefg\0". Note that this is just what the bytes look
* like; UTF-8 characters may well have been truncated.
* To check that the conversion worked properly, we'll build this
* string manually. */
HDstrncpy(cmpbuf, new_string, small_len - 1);
cmpbuf[small_len - 1] = '\0';
HDstrncpy(&cmpbuf[small_len], new_string, small_len -1);
cmpbuf[2 * small_len - 1] = '\0';
HDstrcpy(&cmpbuf[2 * small_len], new_string);
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
/* Now convert from smaller datatype to bigger datatype. This should
* leave our buffer looking like: "abc\0\0\0\0\0abc\0\0\0\0\0" */
ret = H5Tconvert(dst_type, src_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* First fill the buffer with NULLs */
HDmemset(cmpbuf, '\0', (size_t)LONG_BUF_SIZE);
/* Copy in the characters */
HDstrncpy(cmpbuf, new_string, small_len -1);
HDstrncpy(&cmpbuf[big_len], new_string, small_len -1);
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
ret = H5Tclose(src_type);
CHECK(ret, FAIL, "H5Tclose");
ret = H5Tclose(dst_type);
CHECK(ret, FAIL, "H5Tclose");
/* Now test null padding. Null-padded strings do *not* need
* terminating NULLs, so the sizes of the datatypes are slightly
* different and we want a string with an even number of characters. */
length = HDstrlen(string);
if(length % 2 != 0)
{
HDstrcpy(new_string, "x");
HDstrcat(new_string, string);
length++;
} else {
HDstrcpy(new_string, string);
}
/* Create a src_type that holds the UTF-8 string */
big_len = length;
HDassert((2*big_len)<=sizeof(cmpbuf));
src_type = mkstr(big_len, H5T_STR_NULLPAD);
CHECK(src_type, FAIL, "mkstr");
/* Create a dst_type that holds half of the UTF-8 string */
small_len = length / 2;
dst_type = mkstr(small_len, H5T_STR_NULLPAD);
CHECK(dst_type, FAIL, "mkstr");
/* Fill the buffer with two copies of the UTF-8 string.
* It will look like "abcdefghabcdefgh". */
strncpy(buf, new_string, big_len);
strncpy(&buf[big_len], new_string, big_len);
ret = H5Tconvert(src_type, dst_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* After conversion, the buffer should look like
* "abcdabcdabcdefgh". Note that this is just what the bytes look
* like; UTF-8 characters may well have been truncated.
* To check that the conversion worked properly, we'll build this
* string manually. */
HDstrncpy(cmpbuf, new_string, small_len);
HDstrncpy(&cmpbuf[small_len], new_string, small_len);
HDstrncpy(&cmpbuf[2 * small_len], new_string, big_len);
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
/* Now convert from smaller datatype to bigger datatype. This should
* leave our buffer looking like: "abcd\0\0\0\0abcd\0\0\0\0" */
ret = H5Tconvert(dst_type, src_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* First fill the buffer with NULLs */
HDmemset(cmpbuf, '\0', (size_t)LONG_BUF_SIZE);
/* Copy in the characters */
HDstrncpy(cmpbuf, new_string, small_len);
HDstrncpy(&cmpbuf[big_len], new_string, small_len);
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
ret = H5Tclose(src_type);
CHECK(ret, FAIL, "H5Tclose");
ret = H5Tclose(dst_type);
CHECK(ret, FAIL, "H5Tclose");
/* Test space padding. This is very similar to null-padding; we can
use the same values of length, small_len, and big_len. */
src_type = mkstr(big_len, H5T_STR_SPACEPAD);
CHECK(src_type, FAIL, "mkstr");
dst_type = mkstr(small_len, H5T_STR_SPACEPAD);
CHECK(src_type, FAIL, "mkstr");
/* Fill the buffer with two copies of the UTF-8 string.
* It will look like "abcdefghabcdefgh". */
HDstrcpy(buf, new_string);
HDstrcpy(&buf[big_len], new_string);
ret = H5Tconvert(src_type, dst_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* After conversion, the buffer should look like
* "abcdabcdabcdefgh". Note that this is just what the bytes look
* like; UTF-8 characters may have been truncated.
* To check that the conversion worked properly, we'll build this
* string manually. */
HDstrncpy(cmpbuf, new_string, small_len);
HDstrncpy(&cmpbuf[small_len], new_string, small_len);
HDstrncpy(&cmpbuf[2 * small_len], new_string, big_len);
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
/* Now convert from smaller datatype to bigger datatype. This should
* leave our buffer looking like: "abcd abcd " */
ret = H5Tconvert(dst_type, src_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* First fill the buffer with spaces */
HDmemset(cmpbuf, ' ', (size_t)LONG_BUF_SIZE);
/* Copy in the characters */
HDstrncpy(cmpbuf, new_string, small_len);
HDstrncpy(&cmpbuf[big_len], new_string, small_len);
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
ret = H5Tclose(src_type);
CHECK(ret, FAIL, "H5Tclose");
ret = H5Tclose(dst_type);
CHECK(ret, FAIL, "H5Tclose");
}
/*------------------------------------------------------------------------- * Function: traverse_cb * * Purpose: Iterator callback for traversing objects in file * * Programmer: Quincey Koziol, [email protected] * * Date: September 1, 2007 * *------------------------------------------------------------------------- */ static herr_t traverse_cb(hid_t loc_id, const char *path, const H5L_info_t *linfo, void *_udata) { trav_ud_traverse_t *udata = (trav_ud_traverse_t *)_udata; /* User data */ char *new_name = NULL; const char *full_name; const char *already_visited = NULL; /* Whether the link/object was already visited */ /* Create the full path name for the link */ if(udata->is_absolute) { size_t base_len = HDstrlen(udata->base_grp_name); size_t add_slash = base_len ? ((udata->base_grp_name)[base_len-1] != '/') : 1; if(NULL == (new_name = (char*)HDmalloc(base_len + add_slash + HDstrlen(path) + 1))) return(H5_ITER_ERROR); HDstrcpy(new_name, udata->base_grp_name); if (add_slash) new_name[base_len] = '/'; HDstrcpy(new_name + base_len + add_slash, path); full_name = new_name; } /* end if */ else full_name = path; /* Perform the correct action for different types of links */ if(linfo->type == H5L_TYPE_HARD) { H5O_info_t oinfo; /* Get information about the object */ if(H5Oget_info_by_name(loc_id, path, &oinfo, H5P_DEFAULT) < 0) { if(new_name) HDfree(new_name); return(H5_ITER_ERROR); } /* If the object has multiple links, add it to the list of addresses * already visited, if it isn't there already */ if(oinfo.rc > 1) if(NULL == (already_visited = trav_addr_visited(udata->seen, oinfo.addr))) trav_addr_add(udata->seen, oinfo.addr, full_name); /* Make 'visit object' callback */ if(udata->visitor->visit_obj) if((*udata->visitor->visit_obj)(full_name, &oinfo, already_visited, udata->visitor->udata) < 0) { if(new_name) HDfree(new_name); return(H5_ITER_ERROR); } } /* end if */ else { /* Make 'visit link' callback */ if(udata->visitor->visit_lnk) if((*udata->visitor->visit_lnk)(full_name, linfo, udata->visitor->udata) < 0) { if(new_name) HDfree(new_name); return(H5_ITER_ERROR); } } /* end else */ if(new_name) HDfree(new_name); return(H5_ITER_CONT); } /* end traverse_cb() */
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: H5O_mtime_decode() test.
*
* Return: Success:
*
* Failure:
*
* Programmer: Robb Matzke
* Thursday, July 30, 1998
*
* Modifications:
* Added checks for old and new modification time messages
* in pre-created datafiles (generated with gen_old_mtime.c and
* gen_new_mtime.c).
* Quincey Koziol
* Friday, January 3, 2003
*
*-------------------------------------------------------------------------
*/
int
main(void)
{
hid_t fapl, file, space, dset;
hsize_t size[1] = {2};
time_t now;
struct tm *tm;
H5O_info_t oi1, oi2;
signed char buf1[32], buf2[32];
char filename[1024];
h5_reset();
fapl = h5_fileaccess();
TESTING("modification time messages");
/* Create the file, create a dataset, then close the file */
h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
TEST_ERROR;
if((space = H5Screate_simple(1, size, NULL)) < 0) TEST_ERROR;
if((dset = H5Dcreate2(file, "dset", H5T_NATIVE_SCHAR, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
TEST_ERROR;
now = HDtime(NULL);
if(H5Dclose(dset) < 0) TEST_ERROR;
if(H5Sclose(space) < 0) TEST_ERROR;
if(H5Fclose(file) < 0) TEST_ERROR;
/*
* Open the file and get the modification time. We'll test the
* H5Oget_info() arguments too: being able to stat something without
* knowing its name.
*/
h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
if((file = H5Fopen(filename, H5F_ACC_RDONLY, fapl)) < 0) TEST_ERROR;
if(H5Oget_info_by_name(file, "dset", &oi1, H5P_DEFAULT) < 0) TEST_ERROR;
if((dset = H5Dopen2(file, "dset", H5P_DEFAULT)) < 0) TEST_ERROR;
if(H5Oget_info(dset, &oi2) < 0) TEST_ERROR;
if(H5Dclose(dset) < 0) TEST_ERROR;
if(H5Fclose(file) < 0) TEST_ERROR;
/* Compare addresses & times from the two ways of calling H5Oget_info() */
if(oi1.addr != oi2.addr || oi1.mtime != oi2.mtime) {
H5_FAILED();
puts(" Calling H5Oget_info() with the dataset ID returned");
puts(" different values than calling it with a file and dataset");
puts(" name.");
goto error;
}
/* Compare times -- they must be within 60 seconds of one another */
if(0 == oi1.mtime) {
SKIPPED();
puts(" The modification time could not be decoded on this OS.");
puts(" Modification times will be mantained in the file but");
puts(" cannot be queried on this system. See H5O_mtime_decode().");
return 0;
} else if(HDfabs(HDdifftime(now, oi1.mtime)) > 60.0) {
H5_FAILED();
tm = HDlocaltime(&(oi1.mtime));
HDstrftime((char*)buf1, sizeof buf1, "%Y-%m-%d %H:%M:%S", tm);
tm = HDlocaltime(&now);
HDstrftime((char*)buf2, sizeof buf2, "%Y-%m-%d %H:%M:%S", tm);
printf(" got: %s\n ans: %s\n", buf1, buf2);
goto error;
}
PASSED();
/* Check opening existing file with old-style modification time information
* and make certain that the time is correct
*/
TESTING("accessing old modification time messages");
{
char testfile[512]="";
char *srcdir = HDgetenv("srcdir");
if(srcdir && ((HDstrlen(srcdir) + strlen(TESTFILE1) + 1) < sizeof(testfile))){
HDstrcpy(testfile, srcdir);
HDstrcat(testfile, "/");
}
HDstrcat(testfile, TESTFILE1);
file = H5Fopen(testfile, H5F_ACC_RDONLY, H5P_DEFAULT);
if(file >= 0){
if(H5Oget_info_by_name(file, "/Dataset1", &oi1, H5P_DEFAULT) < 0)
TEST_ERROR;
if(oi1.mtime != MTIME1) {
H5_FAILED();
/* If this fails, examine H5Omtime.c. Modification time is very
* system dependant (e.g., on Windows DST must be hardcoded). */
puts(" Old modification time incorrect");
goto error;
}
if(H5Fclose(file) < 0) TEST_ERROR;
}
else {
H5_FAILED();
printf("***cannot open the pre-created old modification test file (%s)\n",
testfile);
goto error;
} /* end else */
}
PASSED();
/* Check opening existing file with new-style modification time information
* and make certain that the time is correct
*/
TESTING("accessing new modification time messages");
{
char testfile[512]="";
char *srcdir = HDgetenv("srcdir");
if(srcdir && ((HDstrlen(srcdir) + strlen(TESTFILE2) + 1) < sizeof(testfile))){
HDstrcpy(testfile, srcdir);
HDstrcat(testfile, "/");
}
HDstrcat(testfile, TESTFILE2);
file = H5Fopen(testfile, H5F_ACC_RDONLY, H5P_DEFAULT);
if(file >= 0){
if(H5Oget_info_by_name(file, "/Dataset1", &oi2, H5P_DEFAULT) < 0)
TEST_ERROR;
if(oi2.mtime != MTIME2) {
H5_FAILED();
puts(" Modification time incorrect.");
goto error;
}
if(H5Fclose(file) < 0) TEST_ERROR;
}
else {
H5_FAILED();
printf("***cannot open the pre-created old modification test file (%s)\n",
testfile);
goto error;
} /* end else */
}
PASSED();
/* All looks good */
puts("All modification time tests passed.");
h5_cleanup(FILENAME, fapl);
return 0;
/* Something broke */
error:
return 1;
}
/*--------------------------------------------------------------------------
NAME
H5O_attr_encode
PURPOSE
Encode a simple attribute message
USAGE
herr_t H5O_attr_encode(f, raw_size, p, mesg)
H5F_t *f; IN: pointer to the HDF5 file struct
const uint8 *p; IN: the raw information buffer
const void *mesg; IN: Pointer to the simple datatype struct
RETURNS
Non-negative on success/Negative on failure
DESCRIPTION
This function encodes the native memory form of the attribute
message in the "raw" disk form.
*
* Modifications:
* Robb Matzke, 17 Jul 1998
* Added padding for alignment.
*
* Robb Matzke, 20 Jul 1998
* Added a version number at the beginning.
*
* Raymond Lu, 8 April 2004
* For data space, changed the operation on H5S_simple_t to
* H5S_extent_t
*
--------------------------------------------------------------------------*/
static herr_t
H5O_attr_encode(H5F_t *f, uint8_t *p, const void *mesg)
{
const H5A_t *attr = (const H5A_t *) mesg;
size_t name_len; /* Attribute name length */
unsigned version; /* Attribute version */
hbool_t type_shared; /* Flag to indicate that a shared datatype is used for this attribute */
herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5O_attr_encode);
/* check args */
assert(f);
assert(p);
assert(attr);
/* Check whether datatype is shared */
if(H5T_committed(attr->dt))
type_shared = TRUE;
else
type_shared = FALSE;
/* Check which version to write out */
if(type_shared)
version = H5O_ATTR_VERSION_NEW; /* Write out new version if shared datatype */
else
version = H5O_ATTR_VERSION;
/* Encode Version */
*p++ = version;
/* Set attribute flags if version >1 */
if(version>H5O_ATTR_VERSION)
*p++ = (type_shared ? H5O_ATTR_FLAG_TYPE_SHARED : 0 ); /* Set flags for attribute */
else
*p++ = 0; /* Reserved, for version <2 */
/*
* Encode the lengths of the various parts of the attribute message. The
* encoded lengths are exact but we pad each part except the data to be a
* multiple of eight bytes (in the first version).
*/
name_len = HDstrlen(attr->name)+1;
UINT16ENCODE(p, name_len);
UINT16ENCODE(p, attr->dt_size);
UINT16ENCODE(p, attr->ds_size);
/*
* Write the name including null terminator padded to the correct number
* of bytes.
*/
HDmemcpy(p, attr->name, name_len);
HDmemset(p+name_len, 0, H5O_ALIGN(name_len)-name_len);
if(version < H5O_ATTR_VERSION_NEW)
p += H5O_ALIGN(name_len);
else
p += name_len;
/* encode the attribute datatype */
if(type_shared) {
H5O_shared_t sh_mesg;
/* Reset shared message information */
HDmemset(&sh_mesg,0,sizeof(H5O_shared_t));
/* Get shared message information from datatype */
if ((H5O_MSG_DTYPE->get_share)(f, attr->dt, &sh_mesg/*out*/)<0)
HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL, "can't encode shared attribute datatype");
/* Encode shared message information for datatype */
if((H5O_MSG_SHARED->encode)(f,p,&sh_mesg)<0)
HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL, "can't encode shared attribute datatype");
} /* end if */
else {
/* Encode datatype information */
if((H5O_MSG_DTYPE->encode)(f,p,attr->dt)<0)
HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL, "can't encode attribute datatype");
} /* end else */
if(version < H5O_ATTR_VERSION_NEW) {
HDmemset(p+attr->dt_size, 0, H5O_ALIGN(attr->dt_size)-attr->dt_size);
p += H5O_ALIGN(attr->dt_size);
} /* end if */
else
p += attr->dt_size;
/* encode the attribute dataspace */
if((H5O_MSG_SDSPACE->encode)(f,p,&(attr->ds->extent))<0)
HGOTO_ERROR(H5E_ATTR, H5E_CANTENCODE, FAIL, "can't encode attribute dataspace");
if(version < H5O_ATTR_VERSION_NEW) {
HDmemset(p+attr->ds_size, 0, H5O_ALIGN(attr->ds_size)-attr->ds_size);
p += H5O_ALIGN(attr->ds_size);
} /* end if */
else
p += attr->ds_size;
/* Store attribute data */
if(attr->data)
HDmemcpy(p,attr->data,attr->data_size);
else
HDmemset(p,0,attr->data_size);
done:
FUNC_LEAVE_NOAPI(ret_value);
}
/*-------------------------------------------------------------------------
* Function: H5L_extern_traverse
*
* Purpose: Default traversal function for external links. This can
* be overridden using H5Lregister().
*
* Given a filename and path packed into the link udata,
* attempts to open an object within an external file.
* If the H5L_ELINK_PREFIX_NAME property is set in the
* link access property list, appends that prefix to the
* filename being opened.
*
* Return: ID of the opened object on success/Negative on failure
*
* Programmer: James Laird
* Monday, July 10, 2006
* Modifications:
* Vailin Choi, April 2, 2008
* Add handling to search for the target file
* See description in RM: H5Lcreate_external
*
* Vailin Choi; Sept. 12th, 2008; bug #1247
* Retrieve the file access property list identifer that is set
* for link access property via H5Pget_elink_fapl().
* If the return value is H5P_DEFAULT, the parent's file access
* property is used to H5F_open() the target file;
* Otherwise, the file access property retrieved from H5Pget_elink_fapl()
* is used to H5F_open() the target file.
*
* Vailin Choi; Nov 2010
* Free memory pointed to by tmp_env_prefix for HDF5_EXT_PREFIX case.
*
*-------------------------------------------------------------------------
*/
static hid_t
H5L_extern_traverse(const char H5_ATTR_UNUSED *link_name, hid_t cur_group,
const void *_udata, size_t H5_ATTR_UNUSED udata_size, hid_t lapl_id)
{
H5P_genplist_t *plist; /* Property list pointer */
char *my_prefix; /* Library's copy of the prefix */
H5G_loc_t root_loc; /* Location of root group in external file */
H5G_loc_t loc; /* Location of object */
H5F_t *ext_file = NULL; /* File struct for external file */
const uint8_t *p = (const uint8_t *)_udata; /* Pointer into external link buffer */
const char *file_name; /* Name of file containing external link's object */
char *full_name = NULL; /* File name with prefix */
const char *obj_name; /* Name external link's object */
size_t fname_len; /* Length of external link file name */
unsigned intent; /* File access permissions */
H5L_elink_cb_t cb_info; /* Callback info struct */
hid_t fapl_id = -1; /* File access property list for external link's file */
hid_t ext_obj = -1; /* ID for external link's object */
char *parent_group_name = NULL;/* Temporary pointer to group name */
char local_group_name[H5L_EXT_TRAVERSE_BUF_SIZE]; /* Local buffer to hold group name */
char *temp_file_name = NULL; /* Temporary pointer to file name */
size_t temp_file_name_len; /* Length of temporary file name */
char *actual_file_name = NULL; /* Parent file's actual name */
H5P_genplist_t *fa_plist; /* File access property list pointer */
H5F_close_degree_t fc_degree = H5F_CLOSE_WEAK; /* File close degree for target file */
hid_t ret_value; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
/* Sanity checks */
HDassert(p);
/* Check external link version & flags */
if(((*p >> 4) & 0x0F) > H5L_EXT_VERSION)
HGOTO_ERROR(H5E_LINK, H5E_CANTDECODE, FAIL, "bad version number for external link")
if((*p & 0x0F) & ~H5L_EXT_FLAGS_ALL)
HGOTO_ERROR(H5E_LINK, H5E_CANTDECODE, FAIL, "bad flags for external link")
p++;
/* Gather some information from the external link's user data */
file_name = (const char *)p;
fname_len = HDstrlen(file_name);
obj_name = (const char *)p + fname_len + 1;
/* Get the plist structure */
if(NULL == (plist = H5P_object_verify(lapl_id, H5P_LINK_ACCESS)))
HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't find object for ID")
/* Get the fapl_id set for lapl_id if any */
if(H5P_get(plist, H5L_ACS_ELINK_FAPL_NAME, &fapl_id) < 0)
HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get fapl for links")
/* Get the location for the group holding the external link */
if(H5G_loc(cur_group, &loc) < 0)
HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "can't get object location")
/* get the access flags set for lapl_id if any */
if(H5P_get(plist, H5L_ACS_ELINK_FLAGS_NAME, &intent) < 0)
HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get elink file access flags")
/* get the file access mode flags for the parent file, if they were not set
* on lapl_id */
if(intent == H5F_ACC_DEFAULT)
intent = H5F_INTENT(loc.oloc->file);
if((fapl_id == H5P_DEFAULT) && ((fapl_id = H5F_get_access_plist(loc.oloc->file, FALSE)) < 0))
HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "can't get parent's file access property list")
/* Get callback_info */
if(H5P_get(plist, H5L_ACS_ELINK_CB_NAME, &cb_info)<0)
HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get elink callback info")
/* Get file access property list */
if(NULL == (fa_plist = H5P_object_verify(fapl_id, H5P_FILE_ACCESS)))
HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't find object for ID")
/* Make callback if it exists */
if(cb_info.func) {
const char *parent_file_name; /* Parent file name */
ssize_t group_name_len; /* Length of parent group name */
/* Get parent file name */
parent_file_name = H5F_OPEN_NAME(loc.oloc->file);
/* Query length of parent group name */
if((group_name_len = H5G_get_name(&loc, NULL, (size_t) 0, NULL, lapl_id, H5AC_ind_dxpl_id)) < 0)
HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "unable to retrieve length of group name")
/* Account for null terminator */
group_name_len++;
/* Check if we need to allocate larger buffer */
if((size_t)group_name_len > sizeof(local_group_name)) {
if(NULL == (parent_group_name = (char *)H5MM_malloc((size_t)group_name_len)))
HGOTO_ERROR(H5E_LINK, H5E_CANTALLOC, FAIL, "can't allocate buffer to hold group name, group_name_len = %Zu", group_name_len)
} /* end if */
else
parent_group_name = local_group_name;
/* Get parent group name */
if(H5G_get_name(&loc, parent_group_name, (size_t) group_name_len, NULL, lapl_id, H5AC_ind_dxpl_id) < 0)
HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "unable to retrieve group name")
/* Make callback */
if((cb_info.func)(parent_file_name, parent_group_name, file_name, obj_name, &intent, fapl_id, cb_info.user_data) < 0)
HGOTO_ERROR(H5E_LINK, H5E_CALLBACK, FAIL, "traversal operator failed")
/* Check access flags */
if((intent & H5F_ACC_TRUNC) || (intent & H5F_ACC_EXCL))
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid file open flags")
} /* end if */
int
main (int argc, const char *argv[])
{
hid_t fid_src = -1;
hid_t fid_dst = -1;
unsigned flag = 0;
unsigned verbose = 0;
unsigned parents = 0;
hid_t ocpl_id = (-1); /* Object copy property list */
hid_t lcpl_id = (-1); /* Link creation property list */
int opt;
int li_ret;
h5tool_link_info_t linkinfo;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* initialize h5tools lib */
h5tools_init();
/* init linkinfo struct */
HDmemset(&linkinfo, 0, sizeof(h5tool_link_info_t));
/* Check for no command line parameters */
if(argc == 1)
{
usage();
leave(EXIT_FAILURE);
} /* end if */
/* parse command line options */
while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF)
{
switch ((char)opt)
{
case 'd':
oname_dst = HDstrdup(opt_arg);
break;
case 'f':
/* validate flag */
if (parse_flag(opt_arg,&flag)<0)
{
usage();
leave(EXIT_FAILURE);
}
str_flag = HDstrdup(opt_arg);
break;
case 'h':
usage();
leave(EXIT_SUCCESS);
break;
case 'i':
fname_src = HDstrdup(opt_arg);
break;
case 'o':
fname_dst = HDstrdup(opt_arg);
break;
case 'p':
parents = 1;
break;
case 's':
oname_src = HDstrdup(opt_arg);
break;
case 'V':
print_version(h5tools_getprogname());
leave(EXIT_SUCCESS);
break;
case 'v':
verbose = 1;
break;
default:
usage();
leave(EXIT_FAILURE);
}
} /* end of while */
/*-------------------------------------------------------------------------
* check for missing file/object names
*-------------------------------------------------------------------------*/
if (fname_src==NULL)
{
error_msg("Input file name missing\n");
usage();
leave(EXIT_FAILURE);
}
if (fname_dst==NULL)
{
error_msg("Output file name missing\n");
usage();
leave(EXIT_FAILURE);
}
if (oname_src==NULL)
{
error_msg("Source object name missing\n");
usage();
leave(EXIT_FAILURE);
}
if (oname_dst==NULL)
{
error_msg("Destination object name missing\n");
usage();
leave(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* open output file
*-------------------------------------------------------------------------*/
/* Attempt to open an existing HDF5 file first. Need to open the dst file
before the src file just in case that the dst and src are the same file
*/
fid_dst = h5tools_fopen(fname_dst, H5F_ACC_RDWR, H5P_DEFAULT, NULL, NULL, 0);
/*-------------------------------------------------------------------------
* open input file
*-------------------------------------------------------------------------*/
fid_src = h5tools_fopen(fname_src, H5F_ACC_RDONLY, H5P_DEFAULT, NULL, NULL, 0);
/*-------------------------------------------------------------------------
* test for error in opening input file
*-------------------------------------------------------------------------*/
if (fid_src==-1)
{
error_msg("Could not open input file <%s>...Exiting\n", fname_src);
leave(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* create an output file when failed to open it
*-------------------------------------------------------------------------*/
/* If we couldn't open an existing file, try creating file */
/* (use "EXCL" instead of "TRUNC", so we don't blow away existing non-HDF5 file) */
if(fid_dst < 0)
fid_dst = H5Fcreate(fname_dst, H5F_ACC_EXCL, H5P_DEFAULT, H5P_DEFAULT);
/*-------------------------------------------------------------------------
* test for error in opening output file
*-------------------------------------------------------------------------*/
if (fid_dst==-1)
{
error_msg("Could not open output file <%s>...Exiting\n", fname_dst);
leave(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* print some info
*-------------------------------------------------------------------------*/
if (verbose)
{
printf("Copying file <%s> and object <%s> to file <%s> and object <%s>\n",
fname_src, oname_src, fname_dst, oname_dst);
if (flag) {
HDassert(str_flag);
printf("Using %s flag\n", str_flag);
}
}
/*-------------------------------------------------------------------------
* create property lists for copy
*-------------------------------------------------------------------------*/
/* create property to pass copy options */
if ( (ocpl_id = H5Pcreate(H5P_OBJECT_COPY)) < 0)
goto error;
/* set options for object copy */
if (flag)
{
if ( H5Pset_copy_object(ocpl_id, flag) < 0)
goto error;
}
/* Create link creation property list */
if((lcpl_id = H5Pcreate(H5P_LINK_CREATE)) < 0) {
error_msg("Could not create link creation property list\n");
goto error;
} /* end if */
/* Check for creating intermediate groups */
if(parents) {
/* Set the intermediate group creation property */
if(H5Pset_create_intermediate_group(lcpl_id, 1) < 0) {
error_msg("Could not set property for creating parent groups\n");
goto error;
} /* end if */
/* Display some output if requested */
if(verbose)
printf("%s: Creating parent groups\n", h5tools_getprogname());
} /* end if */
else /* error, if parent groups doesn't already exist in destination file */
{
size_t i, len;
len = HDstrlen(oname_dst);
/* check if all the parents groups exist. skip root group */
for (i = 1; i < len; i++)
{
if ('/'==oname_dst[i])
{
char *str_ptr;
str_ptr = (char *)HDcalloc(i + 1, sizeof(char));
HDstrncpy(str_ptr, oname_dst, i);
str_ptr[i]='\0';
if (H5Lexists(fid_dst, str_ptr, H5P_DEFAULT) <= 0)
{
error_msg("group <%s> doesn't exist. Use -p to create parent groups.\n", str_ptr);
HDfree(str_ptr);
goto error;
}
HDfree(str_ptr);
}
}
}
/*-------------------------------------------------------------------------
* do the copy
*-------------------------------------------------------------------------*/
if(verbose)
linkinfo.opt.msg_mode = 1;
li_ret = H5tools_get_symlink_info(fid_src, oname_src, &linkinfo, 1);
if (li_ret == 0) /* dangling link */
{
if(H5Lcopy(fid_src, oname_src,
fid_dst, oname_dst,
H5P_DEFAULT, H5P_DEFAULT) < 0)
goto error;
}
else /* valid link */
{
if (H5Ocopy(fid_src, /* Source file or group identifier */
oname_src, /* Name of the source object to be copied */
fid_dst, /* Destination file or group identifier */
oname_dst, /* Name of the destination object */
ocpl_id, /* Object copy property list */
lcpl_id)<0) /* Link creation property list */
goto error;
}
/* free link info path */
if (linkinfo.trg_path)
HDfree(linkinfo.trg_path);
/* close propertis */
if(H5Pclose(ocpl_id)<0)
goto error;
if(H5Pclose(lcpl_id)<0)
goto error;
/* close files */
if (H5Fclose(fid_src)<0)
goto error;
if (H5Fclose(fid_dst)<0)
goto error;
leave(EXIT_SUCCESS);
error:
printf("Error in copy...Exiting\n");
/* free link info path */
if (linkinfo.trg_path)
HDfree(linkinfo.trg_path);
H5E_BEGIN_TRY {
H5Pclose(ocpl_id);
H5Pclose(lcpl_id);
H5Fclose(fid_src);
H5Fclose(fid_dst);
} H5E_END_TRY;
leave(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* Function: H5C_apply_candidate_list
*
* Purpose: Apply the supplied candidate list.
*
* We used to do this by simply having each process write
* every mpi_size-th entry in the candidate list, starting
* at index mpi_rank, and mark all the others clean.
*
* However, this can cause unnecessary contention in a file
* system by increasing the number of processes writing to
* adjacent locations in the HDF5 file.
*
* To attempt to minimize this, we now arange matters such
* that each process writes n adjacent entries in the
* candidate list, and marks all others clean. We must do
* this in such a fashion as to guarantee that each entry
* on the candidate list is written by exactly one process,
* and marked clean by all others.
*
* To do this, first construct a table mapping mpi_rank
* to the index of the first entry in the candidate list to
* be written by the process of that mpi_rank, and then use
* the table to control which entries are written and which
* are marked as clean as a function of the mpi_rank.
*
* Note that the table must be identical on all processes, as
* all see the same candidate list, mpi_size, and mpi_rank --
* the inputs used to construct the table.
*
* We construct the table as follows. Let:
*
* n = num_candidates / mpi_size;
*
* m = num_candidates % mpi_size;
*
* Now allocate an array of integers of length mpi_size + 1,
* and call this array candidate_assignment_table.
*
* Conceptually, if the number of candidates is a multiple
* of the mpi_size, we simply pass through the candidate list
* and assign n entries to each process to flush, with the
* index of the first entry to flush in the location in
* the candidate_assignment_table indicated by the mpi_rank
* of the process.
*
* In the more common case in which the candidate list isn't
* isn't a multiple of the mpi_size, we pretend it is, and
* give num_candidates % mpi_size processes one extra entry
* each to make things work out.
*
* Once the table is constructed, we determine the first and
* last entry this process is to flush as follows:
*
* first_entry_to_flush = candidate_assignment_table[mpi_rank]
*
* last_entry_to_flush =
* candidate_assignment_table[mpi_rank + 1] - 1;
*
* With these values determined, we simply scan through the
* candidate list, marking all entries in the range
* [first_entry_to_flush, last_entry_to_flush] for flush,
* and all others to be cleaned.
*
* Finally, we scan the LRU from tail to head, flushing
* or marking clean the candidate entries as indicated.
* If necessary, we scan the pinned list as well.
*
* Note that this function will fail if any protected or
* clean entries appear on the candidate list.
*
* This function is used in managing sync points, and
* shouldn't be used elsewhere.
*
* Return: Success: SUCCEED
*
* Failure: FAIL
*
* Programmer: John Mainzer
* 3/17/10
*
* Changes: Ported code to detect next entry status changes as the
* the result of a flush from the serial code in the scan of
* the LRU. Also added code to detect and adapt to the
* removal from the cache of the next entry in the scan of
* the LRU.
*
* Note that at present, all of these changes should not
* be required as the operations on entries as they are
* flushed that can cause these condiditions are not premitted
* in the parallel case. However, Quincey indicates that
* this may change, and thus has requested the modification.
*
* Note the assert(FALSE) in the if statement whose body
* restarts the scan of the LRU. As the body of the if
* statement should be unreachable, it should never be
* triggered until the constraints on the parallel case
* are relaxed. Please remove the assertion at that time.
*
* Also added warning on the Pinned Entry List scan, as it
* is potentially subject to the same issue. As there is
* no cognate of this scan in the serial code, I don't have
* a fix to port to it.
*
* JRM -- 4/10/19
*
*-------------------------------------------------------------------------
*/
herr_t
H5C_apply_candidate_list(H5F_t * f,
hid_t dxpl_id,
H5C_t * cache_ptr,
int num_candidates,
haddr_t * candidates_list_ptr,
int mpi_rank,
int mpi_size)
{
hbool_t restart_scan;
hbool_t prev_is_dirty;
int i;
int m;
int n;
int first_entry_to_flush;
int last_entry_to_flush;
int entries_to_clear = 0;
int entries_to_flush = 0;
int entries_to_flush_or_clear_last = 0;
int entries_to_flush_collectively = 0;
int entries_cleared = 0;
int entries_flushed = 0;
int entries_delayed = 0;
int entries_flushed_or_cleared_last = 0;
int entries_flushed_collectively = 0;
int entries_examined = 0;
int initial_list_len;
int * candidate_assignment_table = NULL;
haddr_t addr;
H5C_cache_entry_t * clear_ptr = NULL;
H5C_cache_entry_t * next_ptr = NULL;
H5C_cache_entry_t * entry_ptr = NULL;
H5C_cache_entry_t * flush_ptr = NULL;
H5C_cache_entry_t * delayed_ptr = NULL;
#if H5C_DO_SANITY_CHECKS
haddr_t last_addr;
#endif /* H5C_DO_SANITY_CHECKS */
#if H5C_APPLY_CANDIDATE_LIST__DEBUG
char tbl_buf[1024];
#endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
HDassert( cache_ptr != NULL );
HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
HDassert( num_candidates > 0 );
HDassert( num_candidates <= cache_ptr->slist_len );
HDassert( candidates_list_ptr != NULL );
HDassert( 0 <= mpi_rank );
HDassert( mpi_rank < mpi_size );
#if H5C_APPLY_CANDIDATE_LIST__DEBUG
HDfprintf(stdout, "%s:%d: setting up candidate assignment table.\n",
FUNC, mpi_rank);
for ( i = 0; i < 1024; i++ ) tbl_buf[i] = '\0';
sprintf(&(tbl_buf[0]), "candidate list = ");
for ( i = 0; i < num_candidates; i++ )
{
sprintf(&(tbl_buf[HDstrlen(tbl_buf)]), " 0x%llx",
(long long)(*(candidates_list_ptr + i)));
}
sprintf(&(tbl_buf[HDstrlen(tbl_buf)]), "\n");
HDfprintf(stdout, "%s", tbl_buf);
#endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */
n = num_candidates / mpi_size;
m = num_candidates % mpi_size;
HDassert(n >= 0);
if(NULL == (candidate_assignment_table = (int *)H5MM_malloc(sizeof(int) * (size_t)(mpi_size + 1))))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for candidate assignment table")
candidate_assignment_table[0] = 0;
candidate_assignment_table[mpi_size] = num_candidates;
if(m == 0) { /* mpi_size is an even divisor of num_candidates */
HDassert(n > 0);
for(i = 1; i < mpi_size; i++)
candidate_assignment_table[i] = candidate_assignment_table[i - 1] + n;
} /* end if */
else {
for(i = 1; i <= m; i++)
candidate_assignment_table[i] = candidate_assignment_table[i - 1] + n + 1;
if(num_candidates < mpi_size) {
for(i = m + 1; i < mpi_size; i++)
candidate_assignment_table[i] = num_candidates;
} /* end if */
else {
for(i = m + 1; i < mpi_size; i++)
candidate_assignment_table[i] = candidate_assignment_table[i - 1] + n;
} /* end else */
} /* end else */
HDassert((candidate_assignment_table[mpi_size - 1] + n) == num_candidates);
#if H5C_DO_SANITY_CHECKS
/* verify that the candidate assignment table has the expected form */
for ( i = 1; i < mpi_size - 1; i++ )
{
int a, b;
a = candidate_assignment_table[i] - candidate_assignment_table[i - 1];
b = candidate_assignment_table[i + 1] - candidate_assignment_table[i];
HDassert( n + 1 >= a );
HDassert( a >= b );
HDassert( b >= n );
}
#endif /* H5C_DO_SANITY_CHECKS */
first_entry_to_flush = candidate_assignment_table[mpi_rank];
last_entry_to_flush = candidate_assignment_table[mpi_rank + 1] - 1;
#if H5C_APPLY_CANDIDATE_LIST__DEBUG
for ( i = 0; i < 1024; i++ )
tbl_buf[i] = '\0';
sprintf(&(tbl_buf[0]), "candidate assignment table = ");
for(i = 0; i <= mpi_size; i++)
sprintf(&(tbl_buf[HDstrlen(tbl_buf)]), " %d", candidate_assignment_table[i]);
sprintf(&(tbl_buf[HDstrlen(tbl_buf)]), "\n");
HDfprintf(stdout, "%s", tbl_buf);
HDfprintf(stdout, "%s:%d: flush entries [%d, %d].\n",
FUNC, mpi_rank, first_entry_to_flush, last_entry_to_flush);
HDfprintf(stdout, "%s:%d: marking entries.\n", FUNC, mpi_rank);
#endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */
for(i = 0; i < num_candidates; i++) {
addr = candidates_list_ptr[i];
HDassert( H5F_addr_defined(addr) );
#if H5C_DO_SANITY_CHECKS
if ( i > 0 ) {
if ( last_addr == addr ) {
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Duplicate entry in cleaned list.\n")
} else if ( last_addr > addr ) {
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "candidate list not sorted.\n")
}
}
last_addr = addr;
#endif /* H5C_DO_SANITY_CHECKS */
H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL)
if(entry_ptr == NULL) {
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Listed candidate entry not in cache?!?!?.")
} else if(!entry_ptr->is_dirty) {
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Listed entry not dirty?!?!?.")
} else if ( entry_ptr->is_protected ) {
/* For now at least, we can't deal with protected entries.
* If we encounter one, scream and die. If it becomes an
* issue, we should be able to work around this.
*/
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Listed entry is protected?!?!?.")
} else {
/* determine whether the entry is to be cleared or flushed,
* and mark it accordingly. We will scan the protected and
* pinned list shortly, and clear or flush according to these
* markings.
*/
if((i >= first_entry_to_flush) && (i <= last_entry_to_flush)) {
entries_to_flush++;
entry_ptr->flush_immediately = TRUE;
} /* end if */
else {
entries_to_clear++;
entry_ptr->clear_on_unprotect = TRUE;
} /* end else */
} /* end else */
} /* end for */
#if H5C_APPLY_CANDIDATE_LIST__DEBUG
HDfprintf(stdout, "%s:%d: num candidates/to clear/to flush = %d/%d/%d.\n",
FUNC, mpi_rank, (int)num_candidates, (int)entries_to_clear,
(int)entries_to_flush);
#endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */
/* We have now marked all the entries on the candidate list for
* either flush or clear -- now scan the LRU and the pinned list
* for these entries and do the deed.
*
* Note that we are doing things in this round about manner so as
* to preserve the order of the LRU list to the best of our ability.
* If we don't do this, my experiments indicate that we will have a
* noticably poorer hit ratio as a result.
*/
#if H5C_APPLY_CANDIDATE_LIST__DEBUG
HDfprintf(stdout, "%s:%d: scanning LRU list. len = %d.\n", FUNC, mpi_rank,
(int)(cache_ptr->LRU_list_len));
#endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */
/* ===================================================================== *
* Now scan the LRU and PEL lists, flushing or clearing entries as
* needed.
*
* The flush_me_last and flush_me_collectively flags may dictate how or
* when some entries can be flushed, and should be addressed here.
* However, in their initial implementation, these flags only apply to the
* superblock, so there's only a relatively small change to this function
* to account for this one case where they come into play. If these flags
* are ever expanded upon, this function and the following flushing steps
* should be reworked to account for additional cases.
* ===================================================================== */
HDassert(entries_to_flush >= 0);
restart_scan = FALSE;
entries_examined = 0;
initial_list_len = cache_ptr->LRU_list_len;
entry_ptr = cache_ptr->LRU_tail_ptr;
/* Examine each entry in the LRU list */
while ( ( entry_ptr != NULL )
&&
( entries_examined <= (entries_to_flush + 1) * initial_list_len )
&&
( (entries_cleared + entries_flushed) < num_candidates ) ) {
if ( entry_ptr->prev != NULL )
prev_is_dirty = entry_ptr->prev->is_dirty;
/* If this process needs to clear this entry. */
if(entry_ptr->clear_on_unprotect) {
HDassert(entry_ptr->is_dirty);
next_ptr = entry_ptr->next;
entry_ptr->clear_on_unprotect = FALSE;
clear_ptr = entry_ptr;
entry_ptr = entry_ptr->prev;
entries_cleared++;
#if ( H5C_APPLY_CANDIDATE_LIST__DEBUG > 1 )
HDfprintf(stdout, "%s:%d: clearing 0x%llx.\n", FUNC, mpi_rank,
(long long)clear_ptr->addr);
#endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */
/* No need to check for the next entry in the scan being
* removed from the cache, as this call to H5C__flush_single_entry()
* will not call either the pre_serialize or serialize callbacks.
*/
if(H5C__flush_single_entry(f, dxpl_id, clear_ptr, H5C__FLUSH_CLEAR_ONLY_FLAG | H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG, NULL) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't clear entry.")
} /* end if */
/* Else, if this process needs to flush this entry. */
else if (entry_ptr->flush_immediately) {
/*-------------------------------------------------------------------------
* Function: getenv_all
*
* Purpose: Used to get the environment that the root MPI task has.
* name specifies which environment variable to look for
* val is the string to which the value of that environment
* variable will be copied.
*
* NOTE: The pointer returned by this function is only
* valid until the next call to getenv_all and the data
* stored there must be copied somewhere else before any
* further calls to getenv_all take place.
*
* Return: pointer to a string containing the value of the environment variable
* NULL if the varialbe doesn't exist in task 'root's environment.
*
* Programmer: Leon Arber
* 4/4/05
*
* Modifications:
* Use original getenv if MPI is not initialized. This happens
* one uses the PHDF5 library to build a serial nature code.
* Albert 2006/04/07
*
*-------------------------------------------------------------------------
*/
char *
getenv_all(MPI_Comm comm, int root, const char* name)
{
int mpi_size, mpi_rank, mpi_initialized;
int len;
static char* env = NULL;
assert(name);
MPI_Initialized(&mpi_initialized);
if(!mpi_initialized) {
/* use original getenv */
if(env)
HDfree(env);
env = HDgetenv(name);
} /* end if */
else {
MPI_Comm_rank(comm, &mpi_rank);
MPI_Comm_size(comm, &mpi_size);
assert(root < mpi_size);
/* The root task does the getenv call
* and sends the result to the other tasks */
if(mpi_rank == root) {
env = HDgetenv(name);
if(env) {
len = (int)HDstrlen(env);
MPI_Bcast(&len, 1, MPI_INT, root, comm);
MPI_Bcast(env, len, MPI_CHAR, root, comm);
}
else {
/* len -1 indicates that the variable was not in the environment */
len = -1;
MPI_Bcast(&len, 1, MPI_INT, root, comm);
}
}
else {
MPI_Bcast(&len, 1, MPI_INT, root, comm);
if(len >= 0) {
if(env == NULL)
env = (char*) HDmalloc((size_t)len+1);
else if(HDstrlen(env) < (size_t)len)
env = (char*) HDrealloc(env, (size_t)len+1);
MPI_Bcast(env, len, MPI_CHAR, root, comm);
env[len] = '\0';
}
else {
if(env)
HDfree(env);
env = NULL;
}
}
}
#ifndef NDEBUG
MPI_Barrier(comm);
#endif
return env;
}
/*------------------------------------------------------------------------- * Function: H5G_namei * * Purpose: Translates a name to a symbol table entry. * * If the specified name can be fully resolved, then this * function returns the symbol table entry for the named object * through the OBJ_ENT argument. The symbol table entry for the * group containing the named object is returned through the * GRP_ENT argument if it is non-null. However, if the name * refers to the root object then the GRP_ENT will be * initialized with an undefined object header address. The * REST argument, if present, will point to the null terminator * of NAME. * * If the specified name cannot be fully resolved, then OBJ_ENT * is initialized with the undefined object header address. The * REST argument will point into the NAME argument to the start * of the component that could not be located. The GRP_ENT will * contain the entry for the symbol table that was being * searched at the time of the failure and will have an * undefined object header address if the search failed at the * root object. For instance, if NAME is `/foo/bar/baz' and the * root directory exists and contains an entry for `foo', and * foo is a group that contains an entry for bar, but bar is not * a group, then the results will be that REST points to `baz', * OBJ_ENT has an undefined object header address, and GRP_ENT * is the symbol table entry for `bar' in `/foo'. * * Every file has a root group whose name is `/'. Components of * a name are separated from one another by one or more slashes * (/). Slashes at the end of a name are ignored. If the name * begins with a slash then the search begins at the root group * of the file containing LOC_ENT. Otherwise it begins at * LOC_ENT. The component `.' is a no-op, but `..' is not * understood by this function (unless it appears as an entry in * the symbol table). * * Symbolic links are followed automatically, but if TARGET * includes the H5G_TARGET_SLINK bit and the last component of * the name is a symbolic link then that link is not followed. * The *NLINKS value is decremented each time a link is followed * and link traversal fails if the value would become negative. * If NLINKS is the null pointer then a default value is used. * * Mounted files are handled by calling H5F_mountpoint() after * each step of the translation. If the input argument to that * function is a mount point then the argument shall be replaced * with information about the root group of the mounted file. * But if TARGET includes the H5G_TARGET_MOUNT bit and the last * component of the name is a mount point then H5F_mountpoint() * is not called and information about the mount point itself is * returned. * * Errors: * * Return: Success: Non-negative if name can be fully resolved. * See above for values of REST, GRP_ENT, and * OBJ_ENT. NLINKS has been decremented for * each symbolic link that was followed. * * Failure: Negative if the name could not be fully * resolved. See above for values of REST, * GRP_ENT, and OBJ_ENT. * * Programmer: Robb Matzke * [email protected] * Aug 11 1997 * * Modifications: * Robb Matzke, 2002-03-28 * The component name buffer on the stack has been replaced by * a dynamically allocated buffer on the heap in order to * remove limitations on the length of a name component. * There are two reasons that the buffer pointer is global: * (1) We want to be able to reuse the buffer without * allocating and freeing it each time this function is * called. * (2) We need to be able to free it from H5G_term_interface() * when the library terminates. * * Pedro Vicente, <*****@*****.**> 22 Aug 2002 * Modified to deep copies of symbol table entries * Added `id to name' support. * * Quincey Koziol, 2003-01-06 * Added "action" and "ent" parameters to allow different actions when * working on the last component of a name. (Specifically, this allows * inserting an entry into a group, instead of trying to look it up) * *------------------------------------------------------------------------- */ herr_t H5G_namei(const H5G_entry_t *loc_ent, const char *name, const char **rest/*out*/, H5G_entry_t *grp_ent/*out*/, H5G_entry_t *obj_ent/*out*/, unsigned target, int *nlinks/*out*/, H5G_namei_act_t action, H5G_entry_t *ent, hid_t dxpl_id) { H5G_entry_t _grp_ent; /*entry for current group */ H5G_entry_t _obj_ent; /*entry found */ size_t nchars; /*component name length */ int _nlinks = H5G_NLINKS; const char *s = NULL; unsigned null_obj; /* Flag to indicate this function was called with obj_ent set to NULL */ unsigned null_grp; /* Flag to indicate this function was called with grp_ent set to NULL */ unsigned obj_copy = 0; /* Flag to indicate that the object entry is copied */ unsigned group_copy = 0; /* Flag to indicate that the group entry is copied */ unsigned last_comp = 0; /* Flag to indicate that a component is the last component in the name */ unsigned did_insert = 0; /* Flag to indicate that H5G_stab_insert was called */ herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5G_namei); /* Set up "out" parameters */ if (rest) *rest = name; if (!grp_ent) { grp_ent = &_grp_ent; null_grp = 1; } /* end if */ else null_grp = 0; if (!obj_ent) { obj_ent = &_obj_ent; null_obj = 1; } /* end if */ else null_obj = 0; if (!nlinks) nlinks = &_nlinks; /* Check args */ if (!name || !*name) HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "no name given"); if (!loc_ent) HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "no current working group"); /* * Where does the searching start? For absolute names it starts at the * root of the file; for relative names it starts at CWG. */ /* Check if we need to get the root group's entry */ if('/' == *name) { H5G_t *tmp_grp; /* Temporary pointer to root group of file */ /* Look up root group for starting location */ tmp_grp = H5G_rootof(loc_ent->file); HDassert(tmp_grp); /* Set the location entry to the root group's entry*/ loc_ent = &(tmp_grp->ent); } /* end if */ /* Deep copy of the symbol table entry (duplicates strings) */ if(H5G_ent_copy(obj_ent, loc_ent, H5_COPY_DEEP) < 0) HGOTO_ERROR(H5E_DATATYPE, H5E_CANTOPENOBJ, FAIL, "unable to copy entry") obj_copy = 1; H5G_ent_reset(grp_ent); /* Check for needing a larger buffer for the individual path name components */ if((HDstrlen(name) + 1) > H5G_comp_alloc_g) { char *new_comp; /* New component buffer */ size_t new_alloc; /* New component buffer size */ new_alloc = MAX3(1024, (2 * H5G_comp_alloc_g), (HDstrlen(name) + 1)); if(NULL == (new_comp = H5MM_realloc(H5G_comp_g, new_alloc))) HGOTO_ERROR(H5E_SYM, H5E_NOSPACE, FAIL, "unable to allocate component buffer") H5G_comp_g = new_comp; H5G_comp_alloc_g = new_alloc; } /* end if */ /* traverse the name */ while ((name = H5G_component(name, &nchars)) && *name) { /* Update the "rest of name" pointer */ if(rest) *rest = name; /* * Copy the component name into a null-terminated buffer so * we can pass it down to the other symbol table functions. */ HDmemcpy(H5G_comp_g, name, nchars); H5G_comp_g[nchars] = '\0'; /* * The special name `.' is a no-op. */ if ('.' == H5G_comp_g[0] && !H5G_comp_g[1]) { name += nchars; continue; } /* end if */ /* * Advance to the next component of the name. */ /* If we've already copied a new entry into the group entry, * it needs to be freed before overwriting it with another entry */ if(group_copy) H5G_name_free(grp_ent); /* Transfer "ownership" of the entry's information to the group entry */ H5G_ent_copy(grp_ent, obj_ent, H5_COPY_SHALLOW); H5G_ent_reset(obj_ent); /* Set flag that we've copied a new entry into the group entry */ group_copy = 1; /* Check if this is the last component of the name */ if(!((s=H5G_component(name+nchars, NULL)) && *s)) last_comp=1; switch(action) { case H5G_NAMEI_TRAVERSE: if (H5G_stab_find(grp_ent, H5G_comp_g, obj_ent/*out*/, dxpl_id )<0) { /* * Component was not found in the current symbol table, possibly * because GRP_ENT isn't a symbol table. */ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "component not found"); } break; case H5G_NAMEI_INSERT: if(!last_comp) { if (H5G_stab_find(grp_ent, H5G_comp_g, obj_ent/*out*/, dxpl_id )<0) { /* * Component was not found in the current symbol table, possibly * because GRP_ENT isn't a symbol table. */ HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "component not found"); } } /* end if */ else { did_insert = 1; if(H5G_stab_insert(grp_ent, H5G_comp_g, ent, TRUE, dxpl_id) < 0) HGOTO_ERROR(H5E_SYM, H5E_CANTINSERT, FAIL, "unable to insert name") HGOTO_DONE(SUCCEED); } /* end else */ break; } /* end switch */ /* * If we found a symbolic link then we should follow it. But if this * is the last component of the name and the H5G_TARGET_SLINK bit of * TARGET is set then we don't follow it. */ if(H5G_CACHED_SLINK==obj_ent->type && (0==(target & H5G_TARGET_SLINK) || !last_comp)) { if ((*nlinks)-- <= 0) HGOTO_ERROR (H5E_SYM, H5E_SLINK, FAIL, "too many links"); if (H5G_traverse_slink (grp_ent, obj_ent, nlinks, dxpl_id)<0) HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "symbolic link traversal failed"); } /* * Resolve mount points to the mounted group. Do not do this step if * the H5G_TARGET_MOUNT bit of TARGET is set and this is the last * component of the name. */ if (0==(target & H5G_TARGET_MOUNT) || !last_comp) H5F_mountpoint(obj_ent/*in,out*/); /* next component */ name += nchars; } /* end while */ /* Update the "rest of name" pointer */ if (rest) *rest = name; /*final null */ /* If this was an insert, make sure that the insert function was actually * called (this catches no-op names like "." and "/") */ if(action == H5G_NAMEI_INSERT && !did_insert) HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "group already exists"); done: /* If we started with a NULL obj_ent, free the entry information */ if(null_obj || (ret_value < 0 && obj_copy)) H5G_name_free(obj_ent); /* If we started with a NULL grp_ent and we copied something into it, free the entry information */ if(null_grp && group_copy) H5G_name_free(grp_ent); FUNC_LEAVE_NOAPI(ret_value); }
/*-------------------------------------------------------------------------
* Function: h5tools_str_sprint
*
* Purpose: Renders the value pointed to by VP of type TYPE into variable
* length string STR.
*
* Return: A pointer to memory containing the result or NULL on error.
*
* Programmer: Robb Matzke
* Thursday, July 23, 1998
*
* Modifications:
* Robb Matzke, 1999-04-26
* Made this function safe from overflow problems by allowing it
* to reallocate the output string.
*
* Robb Matzke, 1999-06-04
* Added support for object references. The new `container'
* argument is the dataset where the reference came from.
*
* Robb Matzke, 1999-06-07
* Added support for printing raw data. If info->raw is non-zero
* then data is printed in hexadecimal format.
*
* Robb Matzke, 2003-01-10
* Binary output format is dd:dd:... instead of 0xdddd... so it
* doesn't look like a hexadecimal integer, and thus users will
* be less likely to complain that HDF5 didn't properly byte
* swap their data during type conversion.
*
* Robb Matzke, LLNL, 2003-06-05
* If TYPE is a variable length string then the pointer to
* the value to pring (VP) is a pointer to a `char*'.
*
* PVN, 28 March 2006
* added H5T_NATIVE_LDOUBLE case
*-------------------------------------------------------------------------
*/
char *
h5tools_str_sprint(h5tools_str_t *str, const h5tool_format_t *info, hid_t container,
hid_t type, void *vp, h5tools_context_t *ctx)
{
size_t n, offset, size=0, nelmts, start;
char *name;
unsigned char *ucp_vp = (unsigned char *)vp;
char *cp_vp = (char *)vp;
hid_t memb, obj, region;
unsigned nmembs;
static char fmt_llong[8], fmt_ullong[8];
H5T_str_t pad;
/*
* some tempvars to store the value before we append it to the string to
* get rid of the memory alignment problem
*/
unsigned long long tempullong;
long long templlong;
unsigned long tempulong;
long templong;
unsigned int tempuint;
int tempint;
/* Build default formats for long long types */
if (!fmt_llong[0]) {
sprintf(fmt_llong, "%%%sd", H5_PRINTF_LL_WIDTH);
sprintf(fmt_ullong, "%%%su", H5_PRINTF_LL_WIDTH);
}
/* Append value depending on data type */
start = h5tools_str_len(str);
if (info->raw) {
size_t i;
n = H5Tget_size(type);
if (1 == n) {
h5tools_str_append(str, OPT(info->fmt_raw, "0x%02x"), ucp_vp[0]);
}
else {
for (i = 0; i < n; i++) {
if (i)
h5tools_str_append(str, ":");
h5tools_str_append(str, OPT(info->fmt_raw, "%02x"), ucp_vp[i]);
}
}
}
else if (H5Tequal(type, H5T_NATIVE_FLOAT)) {
float tempfloat;
HDmemcpy(&tempfloat, vp, sizeof(float));
h5tools_str_append(str, OPT(info->fmt_float, "%g"), tempfloat);
}
else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) {
double tempdouble;
HDmemcpy(&tempdouble, vp, sizeof(double));
h5tools_str_append(str, OPT(info->fmt_double, "%g"), tempdouble);
#if H5_SIZEOF_LONG_DOUBLE !=0
}
else if (H5Tequal(type, H5T_NATIVE_LDOUBLE)) {
long double templdouble;
HDmemcpy(&templdouble, vp, sizeof(long double));
h5tools_str_append(str, "%Lf", templdouble);
#endif
}
else if (info->ascii && (H5Tequal(type, H5T_NATIVE_SCHAR) ||
H5Tequal(type, H5T_NATIVE_UCHAR))) {
h5tools_print_char(str, info, (char) (*ucp_vp));
}
else if (H5T_STRING == H5Tget_class(type)) {
unsigned int i;
char quote = '\0';
char *s;
quote = '\0';
if (H5Tis_variable_str(type)) {
/* cp_vp is the pointer into the struct where a `char*' is stored. So we have
* to dereference the pointer to get the `char*' to pass to HDstrlen(). */
s = *(char**) cp_vp;
if (s != NULL)
size = HDstrlen(s);
}
else {
s = cp_vp;
size = H5Tget_size(type);
}
pad = H5Tget_strpad(type);
/* Check for NULL pointer for string */
if (s == NULL) {
h5tools_str_append(str, "NULL");
}
else {
for (i = 0; i < size && (s[i] || pad != H5T_STR_NULLTERM); i++) {
int j = 1;
/*
* Count how many times the next character repeats. If the
* threshold is zero then that means it can repeat any number
* of times.
*/
if (info->str_repeat > 0)
while (i + j < size && s[i] == s[i + j])
j++;
/*
* Print the opening quote. If the repeat count is high enough to
* warrant printing the number of repeats instead of enumerating
* the characters, then make sure the character to be repeated is
* in it's own quote.
*/
if (info->str_repeat > 0 && j > info->str_repeat) {
if (quote)
h5tools_str_append(str, "%c", quote);
quote = '\'';
h5tools_str_append(str, "%s%c", i ? " " : "", quote);
}
else if (!quote) {
quote = '"';
h5tools_str_append(str, "%s%c", i ? " " : "", quote);
}
/* Print the character */
h5tools_print_char(str, info, s[i]);
/* Print the repeat count */
if (info->str_repeat && j > info->str_repeat) {
#ifdef REPEAT_VERBOSE
h5tools_str_append(str, "%c repeats %d times", quote, j - 1);
#else
h5tools_str_append(str, "%c*%d", quote, j - 1);
#endif /* REPEAT_VERBOSE */
quote = '\0';
i += j - 1;
}
}
if (quote)
h5tools_str_append(str, "%c", quote);
if (i == 0)
/*empty string*/
h5tools_str_append(str, "\"\"");
} /* end else */
}
else if (H5Tequal(type, H5T_NATIVE_INT)) {
HDmemcpy(&tempint, vp, sizeof(int));
#ifdef H5_HAVE_H5DUMP_PACKED_BITS
if(packed_bits_num)
tempint = (tempint >> packed_data_offset) & packed_data_mask;
#endif
h5tools_str_append(str, OPT(info->fmt_int, "%d"), tempint);
}
else if (H5Tequal(type, H5T_NATIVE_UINT)) {