/*------------------------------------------------------------------------- * Function: main * * Purpose: h5repack main program * * Return: Success: EXIT_SUCCESS(0) * * Failure: EXIT_FAILURE(1) * * Programmer: Pedro Vicente, [email protected] * * Date: May 9, 2003 * * Comments: * *------------------------------------------------------------------------- */ int main(int argc, const char **argv) { pack_opt_t options; /*the global options */ int ret=-1; h5tools_setprogname(PROGRAMNAME); h5tools_setstatus(EXIT_SUCCESS); /* Initialize h5tools lib */ h5tools_init(); /* initialize options */ h5repack_init(&options,0); parse_command_line(argc, argv, &options); /* get file names if they were not yet got */ if ( has_i_o == 0 ) { if ( argv[ opt_ind ] != NULL && argv[ opt_ind + 1 ] != NULL ) { infile = argv[ opt_ind ]; outfile = argv[ opt_ind + 1 ]; if ( HDstrcmp( infile, outfile ) == 0 ) { error_msg("file names cannot be the same\n"); usage(h5tools_getprogname()); HDexit(EXIT_FAILURE); } } else { error_msg("file names missing\n"); usage(h5tools_getprogname()); HDexit(EXIT_FAILURE); } } /* pack it */ ret=h5repack(infile,outfile,&options); /* free tables */ h5repack_end(&options); if (ret==-1) return 1; else return 0; }
/*-------------------------------------------------------------------------
* Function: insert_libhdf5_settings
*
* Purpose: insert the contents of libhdf5.settings into a file
* represented by flibinfo.
* Make it an empty string if H5_HAVE_EMBEDDED_LIBINFO is not
* defined, i.e., not enabled.
*
* Return: void
*-------------------------------------------------------------------------
*/
static void
insert_libhdf5_settings(FILE *flibinfo)
{
#ifdef H5_HAVE_EMBEDDED_LIBINFO
FILE *fsettings; /* for files libhdf5.settings */
int inchar;
int bol = 0; /* indicates the beginning of a new line */
if(NULL == (fsettings = HDfopen(LIBSETTINGSFNAME, "r"))) {
HDperror(LIBSETTINGSFNAME);
HDexit(EXIT_FAILURE);
} /* end if */
/* print variable definition and the string */
/* Do not use const else AIX strings does not show it. */
fprintf(flibinfo, "char H5libhdf5_settings[]=\n");
bol++;
while(EOF != (inchar = HDgetc(fsettings))) {
if(bol) {
/* Start a new line */
fprintf(flibinfo, "\t\"");
bol = 0;
} /* end if */
if(inchar == '\n') {
/* end of a line */
fprintf(flibinfo, "\\n\"\n");
bol++;
} /* end if */
else
HDputc(inchar, flibinfo);
} /* end while */
if(HDfeof(fsettings)) {
/* wrap up */
if(!bol)
/* EOF found without a new line */
fprintf(flibinfo, "\\n\"\n");
fprintf(flibinfo, ";\n\n");
} /* end if */
else {
fprintf(stderr, "Read errors encountered with %s\n", LIBSETTINGSFNAME);
HDexit(EXIT_FAILURE);
} /* end else */
if(0 != HDfclose(fsettings)) {
HDperror(LIBSETTINGSFNAME);
HDexit(EXIT_FAILURE);
} /* end if */
#else
/* print variable definition and an empty string */
/* Do not use const else AIX strings does not show it. */
fprintf(flibinfo, "char H5libhdf5_settings[]=\"\";\n");
#endif
} /* insert_libhdf5_settings() */
int main(void)
{
char filename[1024];
unsigned nerrors = 0;
h5_reset();
TESTING("reading data created on OpenVMS");
h5_fixname(FILENAME[0], H5P_DEFAULT, filename, sizeof filename);
nerrors += read_data(filename);
TESTING("reading data created on Linux");
h5_fixname(FILENAME[1], H5P_DEFAULT, filename, sizeof filename);
nerrors += read_data(filename);
TESTING("reading data created on Solaris");
h5_fixname(FILENAME[2], H5P_DEFAULT, filename, sizeof filename);
nerrors += read_data(filename);
if (nerrors) {
printf("***** %u FAILURE%s! *****\n",
nerrors, 1==nerrors?"":"S");
HDexit(1);
}
printf("All data type tests passed.\n");
return 0;
}
/*------------------------------------------------------------------------- * Function: get_H5FA_class * * Purpose: Determine the fixed array class from the buffer read in. * Extensible arrays are debugged through the array subclass. * The subclass identifier is two bytes after the signature. * * Return: Non-NULL on success/NULL on failure * * Programmer: Quincey Koziol * [email protected] * Sep 11 2008 * *------------------------------------------------------------------------- */ static const H5FA_class_t * get_H5FA_class(const uint8_t *sig) { H5FA_cls_id_t clsid = (H5FA_cls_id_t)sig[H5_SIZEOF_MAGIC + 1]; const H5FA_class_t *cls; switch(clsid) { case H5FA_CLS_TEST_ID: cls = H5FA_CLS_TEST; break; case H5FA_CLS_CHUNK_ID: cls = H5FA_CLS_CHUNK; break; case H5FA_CLS_FILT_CHUNK_ID: cls = H5FA_CLS_FILT_CHUNK; break; case H5FA_NUM_CLS_ID: default: HDfprintf(stderr, "Unknown fixed array class %u\n", (unsigned)(clsid)); HDexit(4); } /* end switch */ return(cls); } /* end get_H5FA_class() */
/*-------------------------------------------------------------------------
* Function: indentation
*
* Purpose: Print spaces for indentation
*
* Return: void
*
* Programmer: Ruey-Hsia Li
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
indentation(int x)
{
if (x < h5tools_nCols) {
while (x-- > 0)
HDfprintf(rawoutstream, " ");
}
else {
HDfprintf(rawerrorstream, "error: the indentation exceeds the number of cols.\n");
HDexit(1);
}
}
/*
* Function: error
* Purpose: Display error message and exit.
* Programmer: Bill Wendling, 05. June 2002
* Modifications:
*/
static void
error(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
HDfprintf(stderr, "%s: error: ", prog);
HDvfprintf(stderr, fmt, ap);
HDfprintf(stderr, "\n");
va_end(ap);
HDexit(EXIT_FAILURE);
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Main entry point.
*
* Return: Success: exit(0)
*
* Failure: exit(1)
*
* Programmer: Albert Cheng
* 2010/4/1
*
*-------------------------------------------------------------------------
*/
int
main(void)
{
print_header();
/* Generate embedded library information variable definition */
make_libinfo();
print_footer();
HDexit(0);
}
/*-------------------------------------------------------------------------
* Function: leave
*
* Purpose: Shutdown and call exit()
*
* Return: Does not return
*
*-------------------------------------------------------------------------
*/
static void
leave(int ret)
{
if (ub_file)
HDfree (ub_file);
if (input_file)
HDfree (input_file);
if (output_file)
HDfree (output_file);
h5tools_close();
HDexit(ret);
}
/*-------------------------------------------------------------------------
* Function: leave
*
* Purpose: Shutdown MPI and/or HDF5 and call exit()
*
* Return: Does not return
*
* Programmer: Quincey Koziol, 2/13/2007
*
*-------------------------------------------------------------------------
*/
static void
leave(int ret)
{
size_t curr_group;
if (params.fname)
HDfree (params.fname);
if (params.ngroups) {
for(curr_group = 0; curr_group < params.ngroups; curr_group++)
HDfree (params.groups[curr_group]);
HDfree (params.groups);
}
h5tools_close();
HDexit(ret);
} /* end leave() */
/*-------------------------------------------------------------------------
* Function: leave
*
* Purpose: Shutdown MPI & HDF5 and call exit()
*
* Return: Does not return
*
* Programmer: Quincey Koziol
* Saturday, 31. January 2004
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
leave(int ret)
{
if (fname_src)
HDfree(fname_src);
if (fname_dst)
HDfree(fname_dst);
if (oname_dst)
HDfree(oname_dst);
if (oname_src)
HDfree(oname_src);
if (str_flag)
HDfree(str_flag);
h5tools_close();
HDexit(ret);
}
static void
usage(void)
{
printf("\n");
printf("Usage error!\n");
printf("\n");
printf("Usage: swmr_sparse_reader [-q] [-s <# of seconds to wait for writer>]\n");
printf(" [-n <# of reads between reopens>] <# of records>\n");
printf("\n");
printf("Defaults to verbose (no '-q' given), 1 second wait ('-s 1') and 1 read\n");
printf("between reopens ('-r 1')\n");
printf("\n");
printf("Note that the # of records *must* be the same as that supplied to\n");
printf("swmr_sparse_writer\n");
printf("\n");
HDexit(1);
} /* end usage() */
static void
usage(void)
{
printf("\n");
printf("Usage error!\n");
printf("\n");
printf("Usage: swmr_sparse_writer [-q] [-f <# of records to write between\n");
printf(" flushing file contents>] <# of records>\n");
printf("\n");
printf("<# of records to write between flushing file contents> should be 0\n");
printf("(for no flushing) or between 1 and (<# of records> - 1)\n");
printf("\n");
printf("Defaults to verbose (no '-q' given) and flushing every 1000 records\n");
printf("('-f 1000')\n");
printf("\n");
HDexit(1);
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Main entry point.
*
* Return: Success: EXIT_SUCCESS
*-------------------------------------------------------------------------
*/
int
main(int argc, char *argv[])
{
char *fname = NULL;
FILE *f; /* temporary holding place for the stream pointer
* so that rawoutstream is changed only when succeeded
*/
if(argc > 1)
fname = argv[1];
/* First check if filename is string "NULL" */
if(fname != NULL) {
/* binary output */
if((f = HDfopen(fname, "w")) != NULL)
rawoutstream = f;
}
if(!rawoutstream)
rawoutstream = stdout;
print_header();
/* Generate embedded library information variable definition */
make_libinfo();
print_footer();
if(rawoutstream && rawoutstream != stdout) {
if(HDfclose(rawoutstream))
fprintf(stderr, "closing rawoutstream");
else
rawoutstream = NULL;
}
HDexit(EXIT_SUCCESS);
}
/* Handler for SIGABRT - catch the abort signal supposedly from check_version()
* and exit(6). Would have used 134 is the return code in Unix systems
* but some systems (e.g., poe in AIX interprets exit(134) the same as
* if the process has really been interrupted by the abort signal and prints
* extra messages that confuse test script that is looking for matching output.
* This handles the abort signal instead letting it interrupt the OS because
* some systems may produce extra messages and/or produce core dump.
* This tries to eliminate those side effects.
*/
void
abort_intercept (int UNUSED sig)
{
HDexit(6);
}
/*------------------------------------------------------------------------- * Function: parse_layout * * Purpose: read layout info * * Return: a list of names, the number of names and its chunking info for * chunked. NULL, on error * the layout type can be: * CHUNK, to apply chunking layout * CONTI, to apply continuous layout * COMPA, to apply compact layout * * Example: * "AA,B,CDE:CHUNK=10X10" * * Programmer: Pedro Vicente, [email protected] * * Date: December 30, 2003 * *------------------------------------------------------------------------- */ obj_list_t* parse_layout(const char *str, int *n_objs, pack_info_t *pack, /* info about layout needed */ pack_opt_t *options) { obj_list_t* obj_list=NULL; unsigned i; char c; size_t len=HDstrlen(str); int j, n, k, end_obj=-1, c_index; char sobj[MAX_NC_NAME]; char sdim[10]; char slayout[10]; HDmemset(sdim, '\0', sizeof(sdim)); HDmemset(sobj, '\0', sizeof(sobj)); HDmemset(slayout, '\0', sizeof(slayout)); /* check for the end of object list and number of objects */ for ( i=0, n=0; i<len; i++) { c = str[i]; if ( c==':' ) { end_obj=i; } if ( c==',' ) { n++; } } if (end_obj==-1) { /* missing : chunk all */ options->all_layout=1; } n++; obj_list = (obj_list_t*) HDmalloc(n*sizeof(obj_list_t)); if (obj_list==NULL) { error_msg("could not allocate object list\n"); return NULL; } *n_objs=n; /* get object list */ for ( j=0, k=0, n=0; j<end_obj; j++,k++) { c = str[j]; sobj[k]=c; if ( c==',' || j==end_obj-1) { if ( c==',') sobj[k]='\0'; else sobj[k+1]='\0'; HDstrcpy(obj_list[n].obj,sobj); HDmemset(sobj,0,sizeof(sobj)); n++; k=-1; } } /* nothing after : */ if (end_obj+1==(int)len) { if (obj_list) HDfree(obj_list); error_msg("in parse layout, no characters after : in <%s>\n",str); HDexit(EXIT_FAILURE); } /* get layout info */ for ( j=end_obj+1, n=0; n<=5; j++,n++) { if (n==5) { slayout[n]='\0'; /*cut string */ if (HDstrcmp(slayout,"COMPA")==0) pack->layout=H5D_COMPACT; else if (HDstrcmp(slayout,"CONTI")==0) pack->layout=H5D_CONTIGUOUS; else if (HDstrcmp(slayout,"CHUNK")==0) pack->layout=H5D_CHUNKED; else { error_msg("in parse layout, not a valid layout in <%s>\n",str); HDexit(EXIT_FAILURE); } } else { c = str[j]; slayout[n]=c; } } /* j */ if ( pack->layout==H5D_CHUNKED ) { /*------------------------------------------------------------------------- * get chunk info *------------------------------------------------------------------------- */ k=0; if (j>(int)len) { if (obj_list) HDfree(obj_list); error_msg("in parse layout, <%s> Chunk dimensions missing\n",str); HDexit(EXIT_FAILURE); } for ( i=j, c_index=0; i<len; i++) { c = str[i]; sdim[k]=c; k++; /*increment sdim index */ if (!isdigit(c) && c!='x' && c!='N' && c!='O' && c!='N' && c!='E' ){ if (obj_list) HDfree(obj_list); error_msg("in parse layout, <%s> Not a valid character in <%s>\n", sdim,str); HDexit(EXIT_FAILURE); } if ( c=='x' || i==len-1) { if ( c=='x') { sdim[k-1]='\0'; k=0; pack->chunk.chunk_lengths[c_index]=atoi(sdim); if (pack->chunk.chunk_lengths[c_index]==0) { if (obj_list) HDfree(obj_list); error_msg("in parse layout, <%s> conversion to number in <%s>\n", sdim,str); HDexit(EXIT_FAILURE); } c_index++; } else if (i==len-1) { /*no more parameters */ sdim[k]='\0'; k=0; if (HDstrcmp(sdim,"NONE")==0) { pack->chunk.rank=-2; } else { pack->chunk.chunk_lengths[c_index]=atoi(sdim); if (pack->chunk.chunk_lengths[c_index]==0){ if (obj_list) HDfree(obj_list); error_msg("in parse layout, <%s> conversion to number in <%s>\n", sdim,str); HDexit(EXIT_FAILURE); } pack->chunk.rank=c_index+1; } } /*if */ } /*if c=='x' || i==len-1 */ } /*i*/ } /*H5D_CHUNKED*/ return obj_list; }
/*-------------------------------------------------------------------------
* Function: copy_some_to_file
*
* Purpose: Copy part of the input file to output.
* infid: fd of file to read
* outfid: fd of file to write
* startin: offset of where to read from infid
* startout: offset of where to write to outfid
* limit: bytes to read/write
*
* If limit is < 0, the entire input file is copied.
*
* Note: this routine can be used to copy within
* the same file, i.e., infid and outfid can be the
* same file.
*
* Return: Success: last byte written in the output.
* Failure: Exits program with EXIT_FAILURE value.
*
*-------------------------------------------------------------------------
*/
hsize_t
copy_some_to_file(int infid, int outfid, hsize_t startin, hsize_t startout,
ssize_t limit)
{
char buf[1024];
h5_stat_t sbuf;
int res;
ssize_t tot = 0;
ssize_t howmuch = 0;
ssize_t nchars = -1;
ssize_t to;
ssize_t from;
ssize_t toend;
ssize_t fromend;
if(startin > startout) {
/* this case is prohibited */
error_msg("copy_some_to_file: panic: startin > startout?\n");
exit (EXIT_FAILURE);
} /* end if */
if(limit < 0) {
res = HDfstat(infid, &sbuf);
if(res < 0) {
error_msg("Can't stat file \n");
HDexit(EXIT_FAILURE);
} /* end if */
howmuch = (ssize_t)sbuf.st_size;
} else {
howmuch = limit;
} /* end if */
if(0 == howmuch)
return 0;
toend = (ssize_t) startout + howmuch;
fromend = (ssize_t) startin + howmuch;
if (howmuch > 512) {
to = toend - 512;
from = fromend - 512;
} else {
to = toend - howmuch;
from = fromend - howmuch;
} /* end if */
while (howmuch > 0) {
HDlseek(outfid, (off_t) to, SEEK_SET);
HDlseek(infid, (off_t) from, SEEK_SET);
if (howmuch > 512) {
nchars = HDread(infid, buf, (unsigned) 512);
} else {
nchars = HDread(infid, buf, (unsigned)howmuch);
} /* end if */
if (nchars <= 0) {
error_msg("Read error \n");
HDexit(EXIT_FAILURE);
} /* end if */
if(HDwrite (outfid, buf, (unsigned) nchars) < 0) {
error_msg("Write error \n");
HDexit(EXIT_FAILURE);
}
tot += nchars;
howmuch -= nchars;
if(howmuch > 512) {
to -= nchars;
from -= nchars;
} else {
to -= howmuch;
from -= howmuch;
} /* end if */
} /* end while */
return (hsize_t)tot + (hsize_t)startout;
} /* end copy_some_to_file() */
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Split an hdf5 file
*
* Return: Success:
*
* Failure:
*
* Programmer: Robb Matzke
* Wednesday, May 13, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main (int argc, char *argv[])
{
const char *prog_name; /*program name */
size_t blk_size=1024; /*size of each I/O block */
char *buf=NULL; /*I/O block buffer */
size_t n, i; /*counters */
ssize_t nio; /*I/O return value */
int argno=1; /*program argument number */
int src, dst=-1; /*source & destination files */
int need_seek=FALSE; /*destination needs to seek? */
int need_write; /*data needs to be written? */
h5_stat_t sb; /*temporary file stat buffer */
int verbose=FALSE; /*display file names? */
const char *src_gen_name; /*general source name */
char *src_name=NULL; /*source member name */
int src_is_family; /*is source name a family name? */
int src_membno=0; /*source member number */
const char *dst_gen_name; /*general destination name */
char *dst_name=NULL; /*destination member name */
int dst_is_family; /*is dst name a family name? */
int dst_membno=0; /*destination member number */
off_t left_overs=0; /*amount of zeros left over */
off_t src_offset=0; /*offset in source member */
off_t dst_offset=0; /*offset in destination member */
off_t src_size; /*source logical member size */
off_t src_act_size; /*source actual member size */
off_t dst_size=1 GB; /*destination logical memb size */
hid_t fapl; /*file access property list */
hid_t file;
hsize_t hdsize; /*destination logical memb size */
hbool_t family_to_sec2=FALSE; /*change family to sec2 driver? */
/*
* Get the program name from argv[0]. Use only the last component.
*/
if ((prog_name=strrchr (argv[0], '/'))) prog_name++;
else prog_name = argv[0];
/*
* Parse switches.
*/
while (argno<argc && '-'==argv[argno][0]) {
if (!strcmp (argv[argno], "-v")) {
verbose = TRUE;
argno++;
} else if (!strcmp(argv[argno], "-V")) {
printf("This is %s version %u.%u release %u\n",
prog_name, H5_VERS_MAJOR, H5_VERS_MINOR, H5_VERS_RELEASE);
exit(EXIT_SUCCESS);
} else if (!strcmp (argv[argno], "-family_to_sec2")) {
family_to_sec2 = TRUE;
argno++;
} else if ('b'==argv[argno][1]) {
blk_size = (size_t)get_size (prog_name, &argno, argc, argv);
} else if ('m'==argv[argno][1]) {
dst_size = get_size (prog_name, &argno, argc, argv);
} else {
usage (prog_name);
} /* end if */
} /* end while */
/* allocate names */
if(NULL == (src_name = (char *)HDcalloc((size_t)NAMELEN, sizeof(char))))
exit(EXIT_FAILURE);
if(NULL == (dst_name = (char *)HDcalloc((size_t)NAMELEN, sizeof(char))))
exit(EXIT_FAILURE);
/*
* Get the name for the source file and open the first member. The size
* of the first member determines the logical size of all the members.
*/
if (argno>=argc) usage (prog_name);
src_gen_name = argv[argno++];
sprintf (src_name, src_gen_name, src_membno);
src_is_family = strcmp (src_name, src_gen_name);
if ((src = HDopen(src_name, O_RDONLY)) < 0) {
HDperror(src_name);
HDexit(EXIT_FAILURE);
}
if (HDfstat(src, &sb)<0) {
perror ("fstat");
exit (EXIT_FAILURE);
}
src_size = src_act_size = sb.st_size;
if (verbose) fprintf (stderr, "< %s\n", src_name);
/*
* Get the name for the destination file and open the first member.
*/
if (argno>=argc) usage (prog_name);
dst_gen_name = argv[argno++];
sprintf (dst_name, dst_gen_name, dst_membno);
dst_is_family = strcmp (dst_name, dst_gen_name);
if ((dst = HDopen(dst_name, O_RDWR|O_CREAT|O_TRUNC, H5_POSIX_CREATE_MODE_RW)) < 0) {
HDperror(dst_name);
HDexit(EXIT_FAILURE);
}
if (verbose) fprintf (stderr, "> %s\n", dst_name);
/* No more arguments */
if (argno<argc) usage (prog_name);
/* Now the real work, split the file */
buf = (char *)HDmalloc(blk_size);
while (src_offset<src_size) {
/* Read a block. The amount to read is the minimum of:
* 1. The I/O block size
* 2. What's left to write in the destination member
* 3. Left over zeros or what's left in the source member.
*/
n = blk_size;
if (dst_is_family) n = (size_t)MIN((off_t)n, dst_size-dst_offset);
if (left_overs) {
n = (size_t)MIN ((off_t)n, left_overs);
left_overs = left_overs - (off_t)n;
need_write = FALSE;
} else if (src_offset<src_act_size) {
n = (size_t)MIN ((off_t)n, src_act_size-src_offset);
if ((nio=HDread (src, buf, n))<0) {
perror ("read");
exit (EXIT_FAILURE);
} else if ((size_t)nio!=n) {
fprintf (stderr, "%s: short read\n", src_name);
exit (EXIT_FAILURE);
}
for (i=0; i<n; i++) {
if (buf[i]) break;
}
need_write = (i<n);
} else {
n = 0;
left_overs = src_size - src_act_size;
need_write = FALSE;
}
/*
* If the block contains non-zero data then write it to the
* destination, otherwise just remember that we'll have to do a seek
* later in the destination when we finally get non-zero data.
*/
if (need_write) {
if (need_seek && HDlseek (dst, dst_offset, SEEK_SET)<0) {
perror ("HDlseek");
exit (EXIT_FAILURE);
}
if ((nio=HDwrite (dst, buf, n))<0) {
perror ("write");
exit (EXIT_FAILURE);
} else if ((size_t)nio!=n) {
fprintf (stderr, "%s: short write\n", dst_name);
exit (EXIT_FAILURE);
}
need_seek = FALSE;
} else {
need_seek = TRUE;
}
/*
* Update the source offset and open the next source family member if
* necessary. The source stream ends at the first member which
* cannot be opened because it doesn't exist. At the end of the
* source stream, update the destination offset and break out of the
* loop. The destination offset must be updated so we can fix
* trailing holes.
*/
src_offset = src_offset + (off_t)n;
if (src_offset==src_act_size) {
HDclose (src);
if (!src_is_family) {
dst_offset = dst_offset + (off_t)n;
break;
}
sprintf (src_name, src_gen_name, ++src_membno);
if ((src = HDopen(src_name, O_RDONLY)) < 0 && ENOENT == errno) {
dst_offset = dst_offset + (off_t)n;
break;
} else if (src<0) {
perror (src_name);
exit (EXIT_FAILURE);
}
if (HDfstat (src, &sb)<0) {
perror ("fstat");
exit (EXIT_FAILURE);
}
src_act_size = sb.st_size;
if (src_act_size>src_size) {
fprintf (stderr, "%s: member truncated to %lu bytes\n",
src_name, (unsigned long)src_size);
}
src_offset = 0;
if (verbose) fprintf (stderr, "< %s\n", src_name);
}
/*
* Update the destination offset, opening a new member if one will be
* needed. The first member is extended to the logical member size
* but other members might be smaller if they end with a hole.
*/
dst_offset = dst_offset + (off_t)n;
if (dst_is_family && dst_offset==dst_size) {
if (0==dst_membno) {
if (HDlseek (dst, dst_size-1, SEEK_SET)<0) {
perror ("HDHDlseek");
exit (EXIT_FAILURE);
}
if (HDread (dst, buf, 1)<0) {
perror ("read");
exit (EXIT_FAILURE);
}
if (HDlseek (dst, dst_size-1, SEEK_SET)<0) {
perror ("HDlseek");
exit (EXIT_FAILURE);
}
if (HDwrite (dst, buf, 1)<0) {
perror ("write");
exit (EXIT_FAILURE);
}
}
HDclose (dst);
sprintf (dst_name, dst_gen_name, ++dst_membno);
if ((dst = HDopen(dst_name, O_RDWR|O_CREAT|O_TRUNC, H5_POSIX_CREATE_MODE_RW)) < 0) {
HDperror(dst_name);
HDexit(EXIT_FAILURE);
}
dst_offset = 0;
need_seek = FALSE;
if (verbose) fprintf (stderr, "> %s\n", dst_name);
}
}
/*
* Make sure the last family member is the right size and then close it.
* The last member can't end with a hole or hdf5 will think that the
* family has been truncated.
*/
if (need_seek) {
if (HDlseek (dst, dst_offset-1, SEEK_SET)<0) {
perror ("HDlseek");
exit (EXIT_FAILURE);
}
if (HDread (dst, buf, 1)<0) {
perror ("read");
exit (EXIT_FAILURE);
}
if (HDlseek (dst, dst_offset-1, SEEK_SET)<0) {
perror ("HDlseek");
exit (EXIT_FAILURE);
}
if (HDwrite (dst, buf, 1)<0) {
perror ("write");
exit (EXIT_FAILURE);
}
}
HDclose (dst);
/* Modify family driver information saved in superblock through private property.
* These private properties are for this tool only. */
if ((fapl=H5Pcreate(H5P_FILE_ACCESS))<0) {
perror ("H5Pcreate");
exit (EXIT_FAILURE);
}
if(family_to_sec2) {
/* The user wants to change file driver from family to sec2. Open the file
* with sec2 driver. This property signals the library to ignore the family
* driver information saved in the superblock. */
if(H5Pset(fapl, H5F_ACS_FAMILY_TO_SEC2_NAME, &family_to_sec2) < 0) {
perror ("H5Pset");
exit (EXIT_FAILURE);
}
} else {
/* Modify family size saved in superblock through private property. It signals
* library to save the new member size(specified in command line) in superblock.
* This private property is for this tool only. */
if(H5Pset_fapl_family(fapl, H5F_FAMILY_DEFAULT, H5P_DEFAULT) < 0) {
perror ("H5Pset_fapl_family");
exit (EXIT_FAILURE);
}
/* Set the property of the new member size as hsize_t */
hdsize = (hsize_t)dst_size;
if(H5Pset(fapl, H5F_ACS_FAMILY_NEWSIZE_NAME, &hdsize) < 0) {
perror ("H5Pset");
exit (EXIT_FAILURE);
}
}
/* If the new file is a family file, try to open file for "read and write" to
* flush metadata. Flushing metadata will update the superblock to the new
* member size. If the original file is a family file and the new file is a sec2
* file, the property FAMILY_TO_SEC2 will signal the library to switch to sec2
* driver when the new file is opened. If the original file is a sec2 file and the
* new file can only be a sec2 file, reopen the new file should fail. There's
* nothing to do in this case. */
H5E_BEGIN_TRY {
file=H5Fopen(dst_gen_name, H5F_ACC_RDWR, fapl);
} H5E_END_TRY;
if(file>=0) {
if(H5Fclose(file)<0) {
perror ("H5Fclose");
exit (EXIT_FAILURE);
} /* end if */
} /* end if */
if(H5Pclose(fapl)<0) {
perror ("H5Pclose");
exit (EXIT_FAILURE);
} /* end if */
/* Free resources and return */
HDfree(src_name);
HDfree(dst_name);
HDfree(buf);
return EXIT_SUCCESS;
} /* end main */
int main(int argc, const char *argv[])
{
long nrecords = 0; /* # of records to read */
int poll_time = 1; /* # of seconds to sleep when waiting for writer */
int reopen_count = 1; /* # of reads between reopens */
unsigned verbose = 1; /* Whether to emit some informational messages */
unsigned u; /* Local index variables */
/* Parse command line options */
if(argc < 2)
usage();
if(argc > 1) {
u = 1;
while(u < (unsigned)argc) {
if(argv[u][0] == '-') {
switch(argv[u][1]) {
/* # of reads between reopens */
case 'n':
reopen_count = HDatoi(argv[u + 1]);
if(reopen_count < 0)
usage();
u += 2;
break;
/* Be quiet */
case 'q':
verbose = 0;
u++;
break;
/* # of seconds between polling */
case 's':
poll_time = HDatoi(argv[u + 1]);
if(poll_time < 0)
usage();
u += 2;
break;
default:
usage();
break;
} /* end switch */
} /* end if */
else {
/* Get the number of records to read */
nrecords = HDatol(argv[u]);
if(nrecords <= 0)
usage();
u++;
} /* end else */
} /* end while */
} /* end if */
/* Emit informational message */
if(verbose) {
HDfprintf(stderr, "Parameters:\n");
HDfprintf(stderr, "\t# of seconds between polling = %d\n", poll_time);
HDfprintf(stderr, "\t# of reads between reopens = %d\n", reopen_count);
HDfprintf(stderr, "\t# of records to read = %ld\n", nrecords);
} /* end if */
/* Emit informational message */
if(verbose)
HDfprintf(stderr, "Generating symbol names\n");
/* Generate dataset names */
if(generate_symbols() < 0) {
HDfprintf(stderr, "Error generating symbol names!\n");
HDexit(1);
} /* end if */
/* Create datatype for creating datasets */
if((symbol_tid = create_symbol_datatype()) < 0)
return -1;
/* Reading records from datasets */
if(read_records(FILENAME, verbose, (unsigned long) nrecords, (unsigned)poll_time, (unsigned)reopen_count) < 0) {
HDfprintf(stderr, "Error reading records from datasets!\n");
HDexit(1);
} /* end if */
/* Emit informational message */
if(verbose)
HDfprintf(stderr, "Releasing symbols\n");
/* Clean up the symbols */
if(shutdown_symbols() < 0) {
HDfprintf(stderr, "Error releasing symbols!\n");
HDexit(1);
} /* end if */
/* Emit informational message */
if(verbose)
HDfprintf(stderr, "Closing objects\n");
/* Close objects created */
if(H5Tclose(symbol_tid) < 0) {
HDfprintf(stderr, "Error closing symbol datatype!\n");
HDexit(1);
} /* end if */
return 0;
}
/*----------------------------------------------------------------------------
* Name: h5_exit_c
* Purpose: Call 'exit()' to terminate application. Be careful not to
* overflow the exit value range since UNIX supports a very
* small range such as 1 byte. Therefore, exit(256) may end
* up as exit(0).
* Inputs: status - status for exit() to return
* Returns: none
* Programmer: Quincey Koziol
* Tuesday, December 14, 2004
* Modifications:
*---------------------------------------------------------------------------*/
void
nh5_exit_c(int_f *status)
{
HDexit((int)*status);
} /* h5_exit_c */
int main(int argc, const char *argv[])
{
hid_t fid; /* File ID for file opened */
long nrecords = 0; /* # of records to append */
long flush_count = 1000; /* # of records to write between flushing file */
unsigned verbose = 1; /* Whether to emit some informational messages */
unsigned u; /* Local index variable */
/* Parse command line options */
if(argc < 2)
usage();
if(argc > 1) {
u = 1;
while(u < (unsigned)argc) {
if(argv[u][0] == '-') {
switch(argv[u][1]) {
/* # of records to write between flushing file */
case 'f':
flush_count = HDatol(argv[u + 1]);
if(flush_count < 0)
usage();
u += 2;
break;
/* Be quiet */
case 'q':
verbose = 0;
u++;
break;
default:
usage();
break;
} /* end switch */
} /* end if */
else {
/* Get the number of records to append */
nrecords = HDatol(argv[u]);
if(nrecords <= 0)
usage();
u++;
} /* end else */
} /* end while */
} /* end if */
if(nrecords <= 0)
usage();
if(flush_count >= nrecords)
usage();
/* Emit informational message */
if(verbose) {
HDfprintf(stderr, "Parameters:\n");
HDfprintf(stderr, "\t# of records between flushes = %ld\n", flush_count);
HDfprintf(stderr, "\t# of records to write = %ld\n", nrecords);
} /* end if */
/* Emit informational message */
if(verbose)
HDfprintf(stderr, "Generating symbol names\n");
/* Generate dataset names */
if(generate_symbols() < 0)
return -1;
/* Emit informational message */
if(verbose)
HDfprintf(stderr, "Opening skeleton file: %s\n", FILENAME);
/* Open file skeleton */
if((fid = open_skeleton(FILENAME, verbose)) < 0) {
HDfprintf(stderr, "Error opening skeleton file!\n");
HDexit(1);
} /* end if */
/* Send a message to indicate "H5Fopen" is complete--releasing the file lock */
h5_send_message(WRITER_MESSAGE);
/* Emit informational message */
if(verbose)
HDfprintf(stderr, "Adding records\n");
/* Append records to datasets */
if(add_records(fid, verbose, (unsigned long)nrecords, (unsigned long)flush_count) < 0) {
HDfprintf(stderr, "Error appending records to datasets!\n");
HDexit(1);
} /* end if */
/* Emit informational message */
if(verbose)
HDfprintf(stderr, "Releasing symbols\n");
/* Clean up the symbols */
if(shutdown_symbols() < 0) {
HDfprintf(stderr, "Error releasing symbols!\n");
HDexit(1);
} /* end if */
/* Emit informational message */
if(verbose)
HDfprintf(stderr, "Closing objects\n");
/* Close objects opened */
if(H5Fclose(fid) < 0) {
HDfprintf(stderr, "Error closing file!\n");
HDexit(1);
} /* end if */
return 0;
}
static
void parse_command_line(int argc, const char **argv, pack_opt_t* options)
{
int opt;
/* parse command line options */
while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF)
{
switch ((char)opt)
{
/* -i for backward compability */
case 'i':
infile = opt_arg;
has_i_o = 1;
break;
/* -o for backward compability */
case 'o':
outfile = opt_arg;
has_i_o = 1;
break;
case 'h':
usage(h5tools_getprogname());
HDexit(EXIT_SUCCESS);
case 'V':
print_version(h5tools_getprogname());
HDexit(EXIT_SUCCESS);
case 'v':
options->verbose = 1;
break;
case 'f':
/* parse the -f filter option */
if (h5repack_addfilter( opt_arg, options)<0)
{
error_msg("in parsing filter\n");
HDexit(EXIT_FAILURE);
}
break;
case 'l':
/* parse the -l layout option */
if (h5repack_addlayout( opt_arg, options)<0)
{
error_msg("in parsing layout\n");
HDexit(EXIT_FAILURE);
}
break;
case 'm':
options->min_comp = HDatoi( opt_arg );
if ((int)options->min_comp<=0)
{
error_msg("invalid minimum compress size <%s>\n", opt_arg );
HDexit(EXIT_FAILURE);
}
break;
case 'e':
read_info( opt_arg, options);
break;
case 'n':
options->use_native = 1;
break;
case 'L':
options->latest = 1;
break;
case 'c':
options->grp_compact = HDatoi( opt_arg );
if (options->grp_compact>0)
options->latest = 1; /* must use latest format */
break;
case 'd':
options->grp_indexed = HDatoi( opt_arg );
if (options->grp_indexed>0)
options->latest = 1; /* must use latest format */
break;
case 's':
{
int idx = 0;
int ssize = 0;
char *msgPtr = HDstrchr( opt_arg, ':');
options->latest = 1; /* must use latest format */
if (msgPtr == NULL)
{
ssize = HDatoi( opt_arg );
for (idx=0; idx<5; idx++)
options->msg_size[idx] = ssize;
}
else
{
char msgType[10];
HDstrcpy(msgType, msgPtr+1);
msgPtr[0] = '\0';
ssize = HDatoi( opt_arg );
if (HDstrncmp(msgType, "dspace",6) == 0) {
options->msg_size[0] = ssize;
}
else if (HDstrncmp(msgType, "dtype", 5) == 0) {
options->msg_size[1] = ssize;
}
else if (HDstrncmp(msgType, "fill", 4) == 0) {
options->msg_size[2] = ssize;
}
else if (HDstrncmp(msgType, "pline", 5) == 0) {
options->msg_size[3] = ssize;
}
else if (HDstrncmp(msgType, "attr", 4) == 0) {
options->msg_size[4] = ssize;
}
}
}
break;
case 'u':
options->ublock_filename = opt_arg;
break;
case 'b':
options->ublock_size = (hsize_t)HDatol( opt_arg );
break;
case 'M':
options->meta_block_size = (hsize_t)HDatol( opt_arg );
break;
case 't':
options->threshold = (hsize_t)HDatol( opt_arg );
break;
case 'a':
options->alignment = HDatol( opt_arg );
if ( options->alignment < 1 )
{
error_msg("invalid alignment size\n", opt_arg );
HDexit(EXIT_FAILURE);
}
break;
default:
break;
} /* switch */
} /* while */
if ( has_i_o == 0 )
{
/* check for file names to be processed */
if (argc <= opt_ind || argv[ opt_ind + 1 ] == NULL)
{
error_msg("missing file names\n");
usage(h5tools_getprogname());
HDexit(EXIT_FAILURE);
}
}
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Tests the plugin module (H5PL)
*
* Return: EXIT_SUCCESS/EXIT_FAILURE
*
*-------------------------------------------------------------------------
*/
int
main(void)
{
char filename[FILENAME_BUF_SIZE];
hid_t fid = -1;
hid_t old_ff_fapl_id = -1;
hid_t new_ff_fapl_id = -1;
unsigned new_format;
int nerrors = 0;
/*******************************************************************/
/* ENSURE THAT WRITING TO DATASETS AND CREATING GROUPS WORKS */
/*******************************************************************/
/* Test with old & new format groups */
for (new_format = FALSE; new_format <= TRUE; new_format++) {
hid_t my_fapl_id;
/* Testing setup */
h5_reset();
/* Get a VFD-dependent filename */
if ((old_ff_fapl_id = h5_fileaccess()) < 0)
TEST_ERROR;
/* Turn off the chunk cache, so all the chunks are immediately written to disk */
if (disable_chunk_cache(old_ff_fapl_id) < 0)
TEST_ERROR;
/* Fix up the filename for the VFD */
h5_fixname(FILENAME[0], old_ff_fapl_id, filename, sizeof(filename));
/* Set the FAPL for the type of format */
if (new_format) {
HDputs("\nTesting with new file format:");
/* Copy the file access property list and set the latest file format on it */
if ((new_ff_fapl_id = H5Pcopy(old_ff_fapl_id)) < 0)
TEST_ERROR;
if (H5Pset_libver_bounds(new_ff_fapl_id, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
TEST_ERROR;
my_fapl_id = new_ff_fapl_id;
}
else {
HDputs("Testing with old file format:");
my_fapl_id = old_ff_fapl_id;
}
/* Create the file for this test */
if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl_id)) < 0)
TEST_ERROR;
/* Test creating datasets and writing to them using plugin filters */
nerrors += (test_dataset_write_with_filters(fid) < 0 ? 1 : 0);
/* Test creating groups using dynamically-loaded plugin filters */
nerrors += (test_creating_groups_using_plugins(fid) < 0 ? 1 : 0);
if (H5Fclose(fid) < 0)
TEST_ERROR;
/* Close FAPLs */
if (H5Pclose(old_ff_fapl_id) < 0)
TEST_ERROR;
if (new_format) {
if (H5Pclose(new_ff_fapl_id) < 0)
TEST_ERROR;
}
/* Restore the default error handler (set in h5_reset()) */
h5_restore_err();
/*******************************************************************/
/* ENSURE THAT READING FROM DATASETS AND OPENING GROUPS WORKS */
/*******************************************************************/
HDputs("\nTesting reading data with with dynamic plugin filters:");
/* Close the library so that all loaded plugin libraries are unloaded */
h5_reset();
if ((old_ff_fapl_id = h5_fileaccess()) < 0)
TEST_ERROR;
/* Set the FAPL for the type of format */
if (new_format) {
/* Copy the file access property list and set the latest file format on it */
if ((new_ff_fapl_id = H5Pcopy(old_ff_fapl_id)) < 0)
TEST_ERROR;
if (H5Pset_libver_bounds(new_ff_fapl_id, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
TEST_ERROR;
my_fapl_id = new_ff_fapl_id;
}
else
my_fapl_id = old_ff_fapl_id;
/* Reopen the file for testing data reading */
if ((fid = H5Fopen(filename, H5F_ACC_RDONLY, my_fapl_id)) < 0)
TEST_ERROR;
/* Read the data with filters */
nerrors += (test_dataset_read_with_filters(fid) < 0 ? 1 : 0);
/* Test creating groups using dynamically-loaded plugin filters */
nerrors += (test_opening_groups_using_plugins(fid) < 0 ? 1 : 0);
/* Close FAPLs */
if (H5Pclose(old_ff_fapl_id) < 0)
TEST_ERROR;
if (new_format) {
if (H5Pclose(new_ff_fapl_id) < 0)
TEST_ERROR;
}
/* Restore the default error handler (set in h5_reset()) */
h5_restore_err();
/*******************************************************************/
/* ENSURE THAT DISABLING FILTER PLUGINS VIA THE FILTER FLAGS WORKS */
/*******************************************************************/
/* Close the library so that all loaded plugin libraries are unloaded */
h5_reset();
if ((old_ff_fapl_id = h5_fileaccess()) < 0)
TEST_ERROR;
/* Set the FAPL for the type of format */
if (new_format) {
/* Copy the file access property list and set the latest file format on it */
if ((new_ff_fapl_id = H5Pcopy(old_ff_fapl_id)) < 0)
TEST_ERROR;
if (H5Pset_libver_bounds(new_ff_fapl_id, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
TEST_ERROR;
my_fapl_id = new_ff_fapl_id;
}
else
my_fapl_id = old_ff_fapl_id;
/* Reopen the file for testing data reading */
if ((fid = H5Fopen(filename, H5F_ACC_RDONLY, my_fapl_id)) < 0)
TEST_ERROR;
/* When filters are disabled, make sure we can't read data from a
* dataset that requires a filter plugin.
*/
nerrors += (test_no_read_when_plugins_disabled(fid) < 0 ? 1 : 0);
if (H5Fclose(fid) < 0)
TEST_ERROR;
/*********************/
/* CLEAN UP */
/*********************/
/* Close FAPLs */
if (new_format) {
if (H5Pclose(new_ff_fapl_id) < 0)
TEST_ERROR;
}
else {
/* Restore the default error handler (set in h5_reset()) */
h5_restore_err();
if (H5Pclose(old_ff_fapl_id) < 0)
TEST_ERROR;
}
/* Free up saved arrays */
free_2D_array(&orig_deflate_g);
free_2D_array(&orig_dynlib1_g);
free_2D_array(&orig_dynlib2_g);
free_2D_array(&orig_dynlib4_g);
} /* end for */
h5_cleanup(FILENAME, old_ff_fapl_id);
/************************************/
/* TEST THE FILTER PLUGIN API CALLS */
/************************************/
/* Test the APIs for access to the filter plugin path table */
nerrors += (test_path_api_calls() < 0 ? 1 : 0);
if (nerrors)
TEST_ERROR;
HDprintf("All plugin tests passed.\n");
HDexit(EXIT_SUCCESS);
error:
H5E_BEGIN_TRY {
H5Fclose(fid);
H5Pclose(old_ff_fapl_id);
H5Pclose(new_ff_fapl_id);
} H5E_END_TRY
/* Free up saved arrays (NULLs okay) */
free_2D_array(&orig_deflate_g);
free_2D_array(&orig_dynlib1_g);
free_2D_array(&orig_dynlib2_g);
free_2D_array(&orig_dynlib4_g);
nerrors = MAX(1, nerrors);
HDprintf("***** %d PLUGIN TEST%s FAILED! *****\n", nerrors, 1 == nerrors ? "" : "S");
HDexit(EXIT_FAILURE);
} /* end main() */
obj_list_t* parse_filter(const char *str,
int *n_objs,
filter_info_t *filt,
pack_opt_t *options,
int *is_glb)
{
unsigned i, u;
char c;
size_t len=HDstrlen(str);
int j, m, n, k, l, end_obj=-1, no_param=0;
char sobj[MAX_NC_NAME];
char scomp[10];
char stype[5];
char smask[3];
obj_list_t* obj_list=NULL;
unsigned pixels_per_block;
/* initialize compression info */
HDmemset(filt,0,sizeof(filter_info_t));
*is_glb = 0;
/* check for the end of object list and number of objects */
for ( i = 0, n = 0; i < len; i++)
{
c = str[i];
if ( c==':' )
{
end_obj=i;
}
if ( c==',' )
{
n++;
}
}
if (end_obj==-1) /* missing : */
{
/* apply to all objects */
options->all_filter=1;
*is_glb = 1;
}
n++;
obj_list = (obj_list_t*) HDmalloc(n*sizeof(obj_list_t));
if (obj_list==NULL)
{
error_msg("could not allocate object list\n");
return NULL;
}
*n_objs=n;
/* get object list */
for ( j = 0, k = 0, n = 0; j < end_obj; j++, k++)
{
c = str[j];
sobj[k] = c;
if ( c==',' || j==end_obj-1)
{
if ( c==',') sobj[k]='\0'; else sobj[k+1]='\0';
HDstrcpy(obj_list[n].obj,sobj);
HDmemset(sobj,0,sizeof(sobj));
n++;
k=-1;
}
}
/* nothing after : */
if (end_obj+1==(int)len)
{
if (obj_list) HDfree(obj_list);
error_msg("input Error: Invalid compression type in <%s>\n",str);
HDexit(EXIT_FAILURE);
}
/* get filter additional parameters */
m=0;
for ( i=end_obj+1, k=0, j=0; i<len; i++,k++)
{
c = str[i];
scomp[k]=c;
if ( c=='=' || i==len-1)
{
if ( c=='=') /*one more parameter */
{
scomp[k]='\0'; /*cut space */
/*-------------------------------------------------------------------------
* H5Z_FILTER_SZIP
* szip has the format SZIP=<pixels per block,coding>
* pixels per block is a even number in 2-32 and coding method is 'EC' or 'NN'
* example SZIP=8,NN
*-------------------------------------------------------------------------
*/
if (HDstrcmp(scomp,"SZIP")==0)
{
l=-1; /* mask index check */
for ( m=0,u=i+1; u<len; u++,m++)
{
if (str[u]==',')
{
stype[m]='\0'; /* end digit of szip */
l=0; /* start EC or NN search */
u++; /* skip ',' */
}
c = str[u];
if (!isdigit(c) && l==-1){
if (obj_list) HDfree(obj_list);
error_msg("compression parameter not digit in <%s>\n",str);
HDexit(EXIT_FAILURE);
}
if (l==-1)
stype[m]=c;
else
{
smask[l]=c;
l++;
if (l==2)
{
smask[l]='\0';
i=len-1; /* end */
(*n_objs)--; /* we counted an extra ',' */
if (HDstrcmp(smask,"NN")==0)
filt->cd_values[j++]=H5_SZIP_NN_OPTION_MASK;
else if (HDstrcmp(smask,"EC")==0)
filt->cd_values[j++]=H5_SZIP_EC_OPTION_MASK;
else
{
error_msg("szip mask must be 'NN' or 'EC' \n");
HDexit(EXIT_FAILURE);
}
}
}
} /* u */
} /*if */
/*-------------------------------------------------------------------------
* H5Z_FILTER_SCALEOFFSET
* scaleoffset has the format SOFF=<scale_factor,scale_type>
* scale_type can be
* integer datatype, H5Z_SO_INT (IN)
* float datatype using D-scaling method, H5Z_SO_FLOAT_DSCALE (DS)
* float datatype using E-scaling method, H5Z_SO_FLOAT_ESCALE (ES) , not yet implemented
* for integer datatypes, scale_factor denotes Minimum Bits
* for float datatypes, scale_factor denotes decimal scale factor
* examples
* SOFF=31,IN
* SOFF=3,DF
*-------------------------------------------------------------------------
*/
else if (HDstrcmp(scomp,"SOFF")==0)
{
l=-1; /* mask index check */
for ( m=0,u=i+1; u<len; u++,m++)
{
if (str[u]==',')
{
stype[m]='\0'; /* end digit */
l=0; /* start 'IN' , 'DS', or 'ES' search */
u++; /* skip ',' */
}
c = str[u];
if (!isdigit(c) && l==-1){
if (obj_list) HDfree(obj_list);
error_msg("compression parameter is not a digit in <%s>\n",str);
HDexit(EXIT_FAILURE);
}
if (l==-1)
stype[m]=c;
else
{
smask[l]=c;
l++;
if (l==2)
{
smask[l]='\0';
i=len-1; /* end */
(*n_objs)--; /* we counted an extra ',' */
if (HDstrcmp(smask,"IN")==0)
filt->cd_values[j++]=H5Z_SO_INT;
else if (HDstrcmp(smask,"DS")==H5Z_SO_FLOAT_DSCALE)
filt->cd_values[j++]=H5Z_SO_FLOAT_DSCALE;
else
{
error_msg("scale type must be 'IN' or 'DS' \n");
HDexit(EXIT_FAILURE);
}
}
}
} /* u */
} /*if */
/*-------------------------------------------------------------------------
* all other filters
*-------------------------------------------------------------------------
*/
else
{
/* here we could have 1 or 2 digits */
for ( m=0,u=i+1; u<len; u++,m++)
{
c = str[u];
if (!isdigit(c)){
if (obj_list) HDfree(obj_list);
error_msg("compression parameter is not a digit in <%s>\n",str);
HDexit(EXIT_FAILURE);
}
stype[m]=c;
} /* u */
stype[m]='\0';
} /*if */
filt->cd_values[j++]=atoi(stype);
i+=m; /* jump */
}
else if (i==len-1)
{ /*no more parameters */
scomp[k+1]='\0';
no_param=1;
}
/*-------------------------------------------------------------------------
* translate from string to filter symbol
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
* H5Z_FILTER_NONE
*-------------------------------------------------------------------------
*/
if (HDstrcmp(scomp,"NONE")==0)
{
filt->filtn=H5Z_FILTER_NONE;
filt->cd_nelmts = 0;
}
/*-------------------------------------------------------------------------
* H5Z_FILTER_DEFLATE
*-------------------------------------------------------------------------
*/
else if (HDstrcmp(scomp,"GZIP")==0)
{
filt->filtn=H5Z_FILTER_DEFLATE;
filt->cd_nelmts = 1;
if (no_param)
{ /*no more parameters, GZIP must have parameter */
if (obj_list) HDfree(obj_list);
error_msg("missing compression parameter in <%s>\n",str);
HDexit(EXIT_FAILURE);
}
}
/*-------------------------------------------------------------------------
* H5Z_FILTER_SZIP
*-------------------------------------------------------------------------
*/
else if (HDstrcmp(scomp,"SZIP")==0)
{
filt->filtn=H5Z_FILTER_SZIP;
filt->cd_nelmts = 2;
if (no_param)
{ /*no more parameters, SZIP must have parameter */
if (obj_list) HDfree(obj_list);
error_msg("missing compression parameter in <%s>\n",str);
HDexit(EXIT_FAILURE);
}
}
/*-------------------------------------------------------------------------
* H5Z_FILTER_SHUFFLE
*-------------------------------------------------------------------------
*/
else if (HDstrcmp(scomp,"SHUF")==0)
{
filt->filtn=H5Z_FILTER_SHUFFLE;
filt->cd_nelmts = 0;
if (m>0)
{ /*shuffle does not have parameter */
if (obj_list) HDfree(obj_list);
error_msg("extra parameter in SHUF <%s>\n",str);
HDexit(EXIT_FAILURE);
}
}
/*-------------------------------------------------------------------------
* H5Z_FILTER_FLETCHER32
*-------------------------------------------------------------------------
*/
else if (HDstrcmp(scomp,"FLET")==0)
{
filt->filtn=H5Z_FILTER_FLETCHER32;
filt->cd_nelmts = 0;
if (m>0)
{ /*shuffle does not have parameter */
if (obj_list) HDfree(obj_list);
error_msg("extra parameter in FLET <%s>\n",str);
HDexit(EXIT_FAILURE);
}
}
/*-------------------------------------------------------------------------
* H5Z_FILTER_NBIT
*-------------------------------------------------------------------------
*/
else if (HDstrcmp(scomp,"NBIT")==0)
{
filt->filtn=H5Z_FILTER_NBIT;
filt->cd_nelmts = 0;
if (m>0)
{ /*nbit does not have parameter */
if (obj_list) HDfree(obj_list);
error_msg("extra parameter in NBIT <%s>\n",str);
HDexit(EXIT_FAILURE);
}
}
/*-------------------------------------------------------------------------
* H5Z_FILTER_SCALEOFFSET
*-------------------------------------------------------------------------
*/
else if (HDstrcmp(scomp,"SOFF")==0)
{
filt->filtn=H5Z_FILTER_SCALEOFFSET;
filt->cd_nelmts = 2;
if (no_param)
{ /*no more parameters, SOFF must have parameter */
if (obj_list) HDfree(obj_list);
error_msg("missing compression parameter in <%s>\n",str);
HDexit(EXIT_FAILURE);
}
}
else {
if (obj_list) HDfree(obj_list);
error_msg("invalid filter type in <%s>\n",str);
HDexit(EXIT_FAILURE);
}
}
} /*i*/
/*-------------------------------------------------------------------------
* check valid parameters
*-------------------------------------------------------------------------
*/
switch (filt->filtn)
{
/*-------------------------------------------------------------------------
* H5Z_FILTER_DEFLATE
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_DEFLATE:
if (filt->cd_values[0]>9 )
{
if (obj_list) HDfree(obj_list);
error_msg("invalid compression parameter in <%s>\n",str);
HDexit(EXIT_FAILURE);
}
break;
/*-------------------------------------------------------------------------
* H5Z_FILTER_SZIP
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_SZIP:
pixels_per_block=filt->cd_values[0];
if ((pixels_per_block%2)==1)
{
if (obj_list) HDfree(obj_list);
error_msg("pixels_per_block is not even in <%s>\n",str);
HDexit(EXIT_FAILURE);
}
if (pixels_per_block>H5_SZIP_MAX_PIXELS_PER_BLOCK)
{
if (obj_list) HDfree(obj_list);
error_msg("pixels_per_block is too large in <%s>\n",str);
HDexit(EXIT_FAILURE);
}
if ( (HDstrcmp(smask,"NN")!=0) && (HDstrcmp(smask,"EC")!=0) )
{
if (obj_list) HDfree(obj_list);
error_msg("szip mask must be 'NN' or 'EC' \n");
HDexit(EXIT_FAILURE);
}
break;
default:
break;
};
return obj_list;
}
/*------------------------------------------------------------------------- * Function: main * * Usage: debug FILENAME [OFFSET] * * Return: Success: exit (0) * * Failure: exit (non-zero) * * Programmer: Robb Matzke * [email protected] * Jul 18 1997 * *------------------------------------------------------------------------- */ int main(int argc, char *argv[]) { hid_t fid, fapl, dxpl; H5F_t *f; haddr_t addr = 0, extra = 0, extra2 = 0, extra3 = 0, extra4 = 0; uint8_t sig[H5F_SIGNATURE_LEN]; size_t u; H5E_auto2_t func; void *edata; herr_t status = SUCCEED; if(argc == 1) { HDfprintf(stderr, "Usage: %s filename [signature-addr [extra]]\n", argv[0]); HDexit(1); } /* end if */ /* Initialize the library */ if(H5open() < 0) { HDfprintf(stderr, "cannot initialize the library\n"); HDexit(1); } /* end if */ /* Disable error reporting */ H5Eget_auto2(H5E_DEFAULT, &func, &edata); H5Eset_auto2(H5E_DEFAULT, NULL, NULL); /* * Open the file and get the file descriptor. */ dxpl = H5AC_ind_read_dxpl_id; if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) { HDfprintf(stderr, "cannot create file access property list\n"); HDexit(1); } /* end if */ if(HDstrchr(argv[1], '%')) if(H5Pset_fapl_family (fapl, (hsize_t)0, H5P_DEFAULT) < 0) { fprintf(stderr, "cannot set file access property list\n"); HDexit(1); } if((fid = H5Fopen(argv[1], H5F_ACC_RDONLY, fapl)) < 0) { HDfprintf(stderr, "cannot open file\n"); HDexit(1); } /* end if */ if(NULL == (f = (H5F_t *)H5I_object(fid))) { HDfprintf(stderr, "cannot obtain H5F_t pointer\n"); HDexit(2); } /* end if */ /* Ignore metadata tags while using h5debug */ if(H5AC_ignore_tags(f) < 0) { HDfprintf(stderr, "cannot ignore metadata tags\n"); HDexit(1); } /* * Parse command arguments. */ if(argc > 2) addr = (haddr_t)HDstrtoll(argv[2], NULL, 0); if(argc > 3) extra = (haddr_t)HDstrtoll(argv[3], NULL, 0); if(argc > 4) extra2 = (haddr_t)HDstrtoll(argv[4], NULL, 0); if(argc > 5) extra3 = (haddr_t)HDstrtoll(argv[5], NULL, 0); if(argc > 6) extra4 = (haddr_t)HDstrtoll(argv[6], NULL, 0); /* * Read the signature at the specified file position. */ HDfprintf(stdout, "Reading signature at address %a (rel)\n", addr); if(H5F_block_read(f, H5FD_MEM_SUPER, addr, sizeof(sig), dxpl, sig) < 0) { HDfprintf(stderr, "cannot read signature\n"); HDexit(3); } if(!HDmemcmp(sig, H5F_SIGNATURE, (size_t)H5F_SIGNATURE_LEN)) { /* * Debug the file's super block. */ status = H5F_debug(f, stdout, 0, VCOL); } else if(!HDmemcmp(sig, H5HL_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a local heap. */ status = H5HL_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL); } else if(!HDmemcmp (sig, H5HG_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a global heap collection. */ status = H5HG_debug (f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL); } else if(!HDmemcmp(sig, H5G_NODE_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a symbol table node. */ /* Check for extra parameters */ if(extra == 0) { HDfprintf(stderr, "\nWarning: Providing the group's local heap address will give more information\n"); HDfprintf(stderr, "Symbol table node usage:\n"); HDfprintf(stderr, "\th5debug <filename> <Symbol table node address> <address of local heap>\n\n"); } /* end if */ status = H5G_node_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, extra); } else if(!HDmemcmp(sig, H5B_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a B-tree. B-trees are debugged through the B-tree * subclass. The subclass identifier is the byte immediately * after the B-tree signature. */ H5B_subid_t subtype = (H5B_subid_t)sig[H5_SIZEOF_MAGIC]; unsigned ndims; uint32_t dim[H5O_LAYOUT_NDIMS]; switch(subtype) { case H5B_SNODE_ID: /* Check for extra parameters */ if(extra == 0) { HDfprintf(stderr, "\nWarning: Providing the group's local heap address will give more information\n"); HDfprintf(stderr, "B-tree symbol table node usage:\n"); HDfprintf(stderr, "\th5debug <filename> <B-tree node address> <address of local heap>\n\n"); HDexit(4); } /* end if */ status = H5G_node_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, extra); break; case H5B_CHUNK_ID: /* Check for extra parameters */ if(extra == 0) { HDfprintf(stderr, "ERROR: Need number of dimensions of chunk in order to dump chunk B-tree node\n"); HDfprintf(stderr, "B-tree chunked storage node usage:\n"); HDfprintf(stderr, "\th5debug <filename> <B-tree node address> <# of dimensions> <slowest chunk dim>...<fastest chunk dim>\n"); HDexit(4); } /* end if */ /* Build array of chunk dimensions */ ndims = (unsigned)extra; dim[0] = (uint32_t)extra2; if(ndims > 1) dim[1] = (uint32_t)extra3; if(ndims > 2) dim[2] = (uint32_t)extra4; /* Check for dimension error */ if(ndims > 3) { HDfprintf(stderr, "ERROR: Only 3 dimensions support currently (fix h5debug)\n"); HDfprintf(stderr, "B-tree chunked storage node usage:\n"); HDfprintf(stderr, "\th5debug <filename> <B-tree node address> <# of dimensions> <slowest chunk dim>...<fastest chunk dim>\n"); HDexit(4); } /* end for */ for(u = 0; u < ndims; u++) if(0 == dim[u]) { HDfprintf(stderr, "ERROR: Chunk dimensions should be >0\n"); HDfprintf(stderr, "B-tree chunked storage node usage:\n"); HDfprintf(stderr, "\th5debug <filename> <B-tree node address> <# of dimensions> <slowest chunk dim>...<fastest chunk dim>\n"); HDexit(4); } /* end if */ /* Set the last dimension (the element size) to zero */ dim[ndims] = 0; status = H5D_btree_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, ndims, dim); break; case H5B_NUM_BTREE_ID: default: HDfprintf(stderr, "Unknown v1 B-tree subtype %u\n", (unsigned)(subtype)); HDexit(4); } } else if(!HDmemcmp(sig, H5B2_HDR_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a v2 B-tree header. */ const H5B2_class_t *cls = get_H5B2_class(sig); HDassert(cls); if((cls == H5D_BT2 || cls == H5D_BT2_FILT) && extra == 0) { HDfprintf(stderr, "ERROR: Need v2 B-tree header address and object header address containing the layout message in order to dump header\n"); HDfprintf(stderr, "v2 B-tree hdr usage:\n"); HDfprintf(stderr, "\th5debug <filename> <v2 B-tree header address> <object header address>\n"); HDexit(4); } /* end if */ status = H5B2__hdr_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, cls, (haddr_t)extra); } else if(!HDmemcmp(sig, H5B2_INT_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a v2 B-tree internal node. */ const H5B2_class_t *cls = get_H5B2_class(sig); HDassert(cls); /* Check for enough valid parameters */ if((cls == H5D_BT2 || cls == H5D_BT2_FILT) && (extra == 0 || extra2 == 0 || extra3 == 0 || extra4 == 0)) { fprintf(stderr, "ERROR: Need v2 B-tree header address, the node's number of records, depth, and object header address containing the layout message in order to dump internal node\n"); fprintf(stderr, "NOTE: Leaf nodes are depth 0, the internal nodes above them are depth 1, etc.\n"); fprintf(stderr, "v2 B-tree internal node usage:\n"); fprintf(stderr, "\th5debug <filename> <internal node address> <v2 B-tree header address> <number of records> <depth> <object header address>\n"); HDexit(4); } else if(extra == 0 || extra2 == 0 || extra3 == 0) { HDfprintf(stderr, "ERROR: Need v2 B-tree header address and the node's number of records and depth in order to dump internal node\n"); HDfprintf(stderr, "NOTE: Leaf nodes are depth 0, the internal nodes above them are depth 1, etc.\n"); HDfprintf(stderr, "v2 B-tree internal node usage:\n"); HDfprintf(stderr, "\th5debug <filename> <internal node address> <v2 B-tree header address> <number of records> <depth>\n"); HDexit(4); } /* end if */ status = H5B2__int_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, cls, extra, (unsigned)extra2, (unsigned)extra3, (haddr_t)extra4); } else if(!HDmemcmp(sig, H5B2_LEAF_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a v2 B-tree leaf node. */ const H5B2_class_t *cls = get_H5B2_class(sig); HDassert(cls); /* Check for enough valid parameters */ if((cls == H5D_BT2 || cls == H5D_BT2_FILT) && (extra == 0 || extra2 == 0 || extra3 == 0 )) { fprintf(stderr, "ERROR: Need v2 B-tree header address, number of records, and object header address containing the layout message in order to dump leaf node\n"); fprintf(stderr, "v2 B-tree leaf node usage:\n"); fprintf(stderr, "\th5debug <filename> <leaf node address> <v2 B-tree header address> <number of records> <object header address>\n"); HDexit(4); } else if(extra == 0 || extra2 == 0) { HDfprintf(stderr, "ERROR: Need v2 B-tree header address and number of records in order to dump leaf node\n"); HDfprintf(stderr, "v2 B-tree leaf node usage:\n"); HDfprintf(stderr, "\th5debug <filename> <leaf node address> <v2 B-tree header address> <number of records>\n"); HDexit(4); } /* end if */ status = H5B2__leaf_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, cls, extra, (unsigned)extra2, (haddr_t)extra3); } else if(!HDmemcmp(sig, H5HF_HDR_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a fractal heap header. */ status = H5HF_hdr_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL); } else if(!HDmemcmp(sig, H5HF_DBLOCK_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a fractal heap direct block. */ /* Check for enough valid parameters */ if(extra == 0 || extra2 == 0) { HDfprintf(stderr, "ERROR: Need fractal heap header address and size of direct block in order to dump direct block\n"); HDfprintf(stderr, "Fractal heap direct block usage:\n"); HDfprintf(stderr, "\th5debug <filename> <direct block address> <heap header address> <size of direct block>\n"); HDexit(4); } /* end if */ status = H5HF_dblock_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, extra, (size_t)extra2); } else if(!HDmemcmp(sig, H5HF_IBLOCK_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a fractal heap indirect block. */ /* Check for enough valid parameters */ if(extra == 0 || extra2 == 0) { HDfprintf(stderr, "ERROR: Need fractal heap header address and number of rows in order to dump indirect block\n"); HDfprintf(stderr, "Fractal heap indirect block usage:\n"); HDfprintf(stderr, "\th5debug <filename> <indirect block address> <heap header address> <number of rows>\n"); HDexit(4); } /* end if */ status = H5HF_iblock_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, extra, (unsigned)extra2); } else if(!HDmemcmp(sig, H5FS_HDR_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a free space header. */ status = H5FS_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL); } else if(!HDmemcmp(sig, H5FS_SINFO_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug free space serialized sections. */ /* Check for enough valid parameters */ if(extra == 0 || extra2 == 0) { HDfprintf(stderr, "ERROR: Need free space header address and client address in order to dump serialized sections\n"); HDfprintf(stderr, "Free space serialized sections usage:\n"); HDfprintf(stderr, "\th5debug <filename> <serialized sections address> <free space header address> <client address>\n"); HDexit(4); } /* end if */ status = H5FS_sects_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, extra, extra2); } else if(!HDmemcmp(sig, H5SM_TABLE_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug shared message master table. */ status = H5SM_table_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, (unsigned) UFAIL, (unsigned) UFAIL); } else if(!HDmemcmp(sig, H5SM_LIST_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug shared message list index. */ /* Check for enough valid parameters */ if(extra == 0) { HDfprintf(stderr, "ERROR: Need shared message header address in order to shared message list\n"); HDfprintf(stderr, "Shared message list usage:\n"); HDfprintf(stderr, "\th5debug <filename> <shared message list address> <shared message header address>\n"); HDexit(4); } /* end if */ status = H5SM_list_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, (haddr_t)extra); } else if(!HDmemcmp(sig, H5EA_HDR_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug an extensible aray header. */ const H5EA_class_t *cls = get_H5EA_class(sig); HDassert(cls); /* Check for enough valid parameters */ if(extra == 0) { HDfprintf(stderr, "ERROR: Need object header address containing the layout message in order to dump header\n"); HDfprintf(stderr, "Extensible array header block usage:\n"); HDfprintf(stderr, "\th5debug <filename> <Extensible Array header address> <object header address>\n"); HDexit(4); } /* end if */ status = H5EA__hdr_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, cls, extra); } else if(!HDmemcmp(sig, H5EA_IBLOCK_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug an extensible aray index block. */ const H5EA_class_t *cls = get_H5EA_class(sig); HDassert(cls); /* Check for enough valid parameters */ if(extra == 0 || extra2 == 0) { HDfprintf(stderr, "ERROR: Need extensible array header address and object header address containing the layout message in order to dump index block\n"); HDfprintf(stderr, "Extensible array index block usage:\n"); HDfprintf(stderr, "\th5debug <filename> <index block address> <array header address> <object header address\n"); HDexit(4); } /* end if */ status = H5EA__iblock_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, cls, extra, extra2); } else if(!HDmemcmp(sig, H5EA_SBLOCK_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug an extensible aray super block. */ const H5EA_class_t *cls = get_H5EA_class(sig); HDassert(cls); /* Check for enough valid parameters */ if(extra == 0 || extra2 == 0 || extra3 == 0) { HDfprintf(stderr, "ERROR: Need extensible array header address, super block index and object header address containing the layout message in order to dump super block\n"); HDfprintf(stderr, "Extensible array super block usage:\n"); HDfprintf(stderr, "\th5debug <filename> <super block address> <array header address> <super block index> <object header address>\n"); HDexit(4); } /* end if */ status = H5EA__sblock_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, cls, extra, (unsigned)extra2, extra3); } else if(!HDmemcmp(sig, H5EA_DBLOCK_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug an extensible aray data block. */ const H5EA_class_t *cls = get_H5EA_class(sig); HDassert(cls); /* Check for enough valid parameters */ if(extra == 0 || extra2 == 0 || extra3 == 0) { HDfprintf(stderr, "ERROR: Need extensible array header address, # of elements in data block and object header address containing the layout message in order to dump data block\n"); HDfprintf(stderr, "Extensible array data block usage:\n"); HDfprintf(stderr, "\th5debug <filename> <data block address> <array header address> <# of elements in data block> <object header address\n"); HDexit(4); } /* end if */ status = H5EA__dblock_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, cls, extra, (size_t)extra2, extra3); } else if(!HDmemcmp(sig, H5FA_HDR_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a fixed array header. */ const H5FA_class_t *cls = get_H5FA_class(sig); HDassert(cls); /* Check for enough valid parameters */ if(extra == 0) { HDfprintf(stderr, "ERROR: Need object header address containing the layout message in order to dump header\n"); HDfprintf(stderr, "Fixed array header block usage:\n"); HDfprintf(stderr, "\th5debug <filename> <Fixed Array header address> <object header address>\n"); HDexit(4); } /* end if */ status = H5FA__hdr_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, cls, extra); } else if(!HDmemcmp(sig, H5FA_DBLOCK_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug a fixed array data block. */ const H5FA_class_t *cls = get_H5FA_class(sig); HDassert(cls); /* Check for enough valid parameters */ if(extra == 0 || extra2 == 0) { HDfprintf(stderr, "ERROR: Need fixed array header address and object header address containing the layout message in order to dump data block\n"); HDfprintf(stderr, "fixed array data block usage:\n"); HDfprintf(stderr, "\th5debug <filename> <data block address> <array header address> <object header address>\n"); HDexit(4); } /* end if */ status = H5FA__dblock_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL, cls, extra, extra2); } else if(!HDmemcmp(sig, H5O_HDR_MAGIC, (size_t)H5_SIZEOF_MAGIC)) { /* * Debug v2 object header (which have signatures). */ status = H5O_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL); } else if(sig[0] == H5O_VERSION_1) { /* * This could be a v1 object header. Since they don't have a signature * it's a somewhat "ify" detection. */ status = H5O_debug(f, H5AC_ind_read_dxpl_id, addr, stdout, 0, VCOL); } else { /* * Got some other unrecognized signature. */ printf("%-*s ", VCOL, "Signature:"); for (u = 0; u < sizeof(sig); u++) { if (sig[u] > ' ' && sig[u] <= '~' && '\\' != sig[u]) HDputchar(sig[u]); else if ('\\' == sig[u]) { HDputchar('\\'); HDputchar('\\'); } else printf("\\%03o", sig[u]); } HDputchar('\n'); HDfprintf(stderr, "unknown signature\n"); HDexit(4); } /* end else */ /* Check for an error when dumping information */ if(status < 0) { HDfprintf(stderr, "An error occurred!\n"); H5Eprint2(H5E_DEFAULT, stderr); HDexit(5); } /* end if */ H5Pclose(fapl); H5Fclose(fid); H5Eset_auto2(H5E_DEFAULT, func, edata); return 0; } /* main() */
/*------------------------------------------------------------------------- * Function: get_H5B2_class * * Purpose: Determine the v2 B-tree class from the buffer read in. * B-trees are debugged through the B-tree subclass. The subclass * identifier is two bytes after the B-tree signature. * * Return: Non-NULL on success/NULL on failure * * Programmer: Quincey Koziol * [email protected] * Sep 11 2008 * *------------------------------------------------------------------------- */ static const H5B2_class_t * get_H5B2_class(const uint8_t *sig) { H5B2_subid_t subtype = (H5B2_subid_t)sig[H5_SIZEOF_MAGIC + 1]; const H5B2_class_t *cls; switch(subtype) { case H5B2_TEST_ID: cls = H5B2_TEST; break; case H5B2_FHEAP_HUGE_INDIR_ID: cls = H5HF_HUGE_BT2_INDIR; break; case H5B2_FHEAP_HUGE_FILT_INDIR_ID: cls = H5HF_HUGE_BT2_FILT_INDIR; break; case H5B2_FHEAP_HUGE_DIR_ID: cls = H5HF_HUGE_BT2_DIR; break; case H5B2_FHEAP_HUGE_FILT_DIR_ID: cls = H5HF_HUGE_BT2_FILT_DIR; break; case H5B2_GRP_DENSE_NAME_ID: cls = H5G_BT2_NAME; break; case H5B2_GRP_DENSE_CORDER_ID: cls = H5G_BT2_CORDER; break; case H5B2_SOHM_INDEX_ID: cls = H5SM_INDEX; break; case H5B2_ATTR_DENSE_NAME_ID: cls = H5A_BT2_NAME; break; case H5B2_ATTR_DENSE_CORDER_ID: cls = H5A_BT2_CORDER; break; case H5B2_CDSET_ID: cls = H5D_BT2; break; case H5B2_CDSET_FILT_ID: cls = H5D_BT2_FILT; break; case H5B2_TEST2_ID: cls = H5B2_TEST2; break; case H5B2_NUM_BTREE_ID: default: HDfprintf(stderr, "Unknown v2 B-tree subtype %u\n", (unsigned)(subtype)); HDexit(4); } /* end switch */ return(cls); } /* end get_H5B2_class() */
/*-------------------------------------------------------------------------
* Function: leave
*
* Purpose: Shutdown MPI & HDF5 and call exit()
*
* Return: Does not return
*
* Programmer: Quincey Koziol
* Saturday, 31. January 2004
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void leave(int ret) {
h5tools_close();
HDexit(ret);
}
/* Handler for SIGABRT - catch the abort signal supposedly from check_version()
* and exit(6). Would have used 134 is the return code in Unix systems
* but some systems (e.g., poe in AIX interprets exit(134) the same as
* if the process has really been interrupted by the abort signal and prints
* extra messages that confuse test script that is looking for matching output.
* This handles the abort signal instead letting it interrupt the OS because
* some systems may produce extra messages and/or produce core dump.
* This tries to eliminate those side effects.
*/
void
abort_intercept (int H5_ATTR_UNUSED sig)
{
HDexit(6);
}
/*-------------------------------------------------------------------------
* Function: options_add_layout
*
* Purpose: add a layout option to the option list
*
* Return: 0, ok, -1, fail
*
*-------------------------------------------------------------------------
*/
int
options_add_layout(obj_list_t *obj_list, unsigned n_objs, pack_info_t *pack,
pack_opttbl_t *table)
{
unsigned i, j, I;
unsigned added = 0;
hbool_t found = FALSE;
/* increase the size of the collection by N_OBJS if necessary */
if (table->nelems + n_objs >= table->size)
if (aux_inctable(table, n_objs) < 0)
return -1;
/* search if this object is already in the table; "path" is the key */
if (table->nelems > 0) {
/* go tru the supplied list of names */
for (j = 0; j < n_objs; j++) {
/* linear table search */
for (i = 0; i < table->nelems; i++) {
/*already on the table */
if (HDstrcmp(obj_list[j].obj,table->objs[i].path) == 0) {
/* already chunk info inserted for this one; exit */
if (table->objs[i].chunk.rank > 0) {
error_msg("chunk information already inserted for <%s>\n", obj_list[j].obj);
HDexit(EXIT_FAILURE);
}
/* insert the layout info */
else {
aux_tblinsert_layout(table, i, pack);
found = TRUE;
break;
}
} /* if */
} /* i */
if (!found) {
/* keep the grow in a temp var */
I = table->nelems + added;
added++;
HDstrcpy(table->objs[I].path, obj_list[j].obj);
aux_tblinsert_layout(table, I, pack);
}
/* cases where we have an already inserted name but there is a new name also
example:
-f dset1:GZIP=1 -l dset1,dset2:CHUNK=20x20
dset1 is already inserted, but dset2 must also be
*/
else
if(found && HDstrcmp(obj_list[j].obj,table->objs[i].path) != 0) {
/* keep the grow in a temp var */
I = table->nelems + added;
added++;
HDstrcpy(table->objs[I].path, obj_list[j].obj);
aux_tblinsert_layout(table, I, pack);
}
} /* j */
}
/* first time insertion */
else {
/* go tru the supplied list of names */
for (j = 0; j < n_objs; j++) {
I = table->nelems + added;
added++;
HDstrcpy(table->objs[I].path, obj_list[j].obj);
aux_tblinsert_layout(table, I, pack);
}
}
table->nelems += added;
return 0;
}
static
void read_info(const char *filename,
pack_opt_t *options)
{
char stype[10];
char comp_info[1024];
FILE *fp;
char c;
int i, rc=1;
char *srcdir = getenv("srcdir"); /* the source directory */
char data_file[512]=""; /* buffer to hold name of existing file */
/* compose the name of the file to open, using the srcdir, if appropriate */
if (srcdir){
HDstrcpy(data_file,srcdir);
HDstrcat(data_file,"/");
}
HDstrcat(data_file,filename);
if ((fp = HDfopen(data_file, "r")) == (FILE *)NULL) {
error_msg("cannot open options file %s\n", filename);
HDexit(EXIT_FAILURE);
}
/* cycle until end of file reached */
while( 1 )
{
rc=fscanf(fp, "%s", stype);
if (rc==-1)
break;
/*-------------------------------------------------------------------------
* filter
*-------------------------------------------------------------------------
*/
if (HDstrcmp(stype,"-f") == 0) {
/* find begining of info */
i=0; c='0';
while( c!=' ' )
{
fscanf(fp, "%c", &c);
if (HDfeof(fp)) break;
}
c='0';
/* go until end */
while( c!=' ' )
{
fscanf(fp, "%c", &c);
comp_info[i]=c;
i++;
if (HDfeof(fp)) break;
if (c==10 /*eol*/) break;
}
comp_info[i-1]='\0'; /*cut the last " */
if (h5repack_addfilter(comp_info,options)==-1){
error_msg("could not add compression option\n");
HDexit(EXIT_FAILURE);
}
}
/*-------------------------------------------------------------------------
* layout
*-------------------------------------------------------------------------
*/
else if (HDstrcmp(stype,"-l") == 0) {
/* find begining of info */
i=0; c='0';
while( c!=' ' )
{
fscanf(fp, "%c", &c);
if (HDfeof(fp)) break;
}
c='0';
/* go until end */
while( c!=' ' )
{
fscanf(fp, "%c", &c);
comp_info[i]=c;
i++;
if (HDfeof(fp)) break;
if (c==10 /*eol*/) break;
}
comp_info[i-1]='\0'; /*cut the last " */
if (h5repack_addlayout(comp_info,options)==-1){
error_msg("could not add chunck option\n");
HDexit(EXIT_FAILURE);
}
}
/*-------------------------------------------------------------------------
* not valid
*-------------------------------------------------------------------------
*/
else {
error_msg("bad file format for %s", filename);
HDexit(EXIT_FAILURE);
}
}
HDfclose(fp);
return;
}
