summaryrefslogtreecommitdiffstats
path: root/src/H5FDlog.c
diff options
context:
space:
mode:
authorQuincey Koziol <koziol@hdfgroup.org>2000-05-08 23:09:59 (GMT)
committerQuincey Koziol <koziol@hdfgroup.org>2000-05-08 23:09:59 (GMT)
commit5c354908b92a67ada5205303300b0e90d20bfffc (patch)
treee812984eeb3ba721eef3a95f71ef01fe5d816da3 /src/H5FDlog.c
parent04152995a9dbeed0bb4def400456bf3a9118d9aa (diff)
downloadhdf5-5c354908b92a67ada5205303300b0e90d20bfffc.zip
hdf5-5c354908b92a67ada5205303300b0e90d20bfffc.tar.gz
hdf5-5c354908b92a67ada5205303300b0e90d20bfffc.tar.bz2
[svn-r2223] Added logging version of sec2 file driver. This is _reallly_ useful for
tracking the actual I/O locations and space used in a file during an application.
Diffstat (limited to 'src/H5FDlog.c')
-rw-r--r--src/H5FDlog.c963
1 files changed, 963 insertions, 0 deletions
diff --git a/src/H5FDlog.c b/src/H5FDlog.c
new file mode 100644
index 0000000..6736402
--- /dev/null
+++ b/src/H5FDlog.c
@@ -0,0 +1,963 @@
+/*
+ * Copyright © 2000 NCSA
+ * All rights reserved.
+ *
+ * Programmer: Quincey Koziol <koziol@ncsa.uiuc.edu>
+ * Monday, April 17, 2000
+ *
+ * Purpose: The POSIX unbuffered file driver using only the HDF5 public
+ * API and with a few optimizations: the lseek() call is made
+ * only when the current file position is unknown or needs to be
+ * changed based on previous I/O through this driver (don't mix
+ * I/O from this driver with I/O from other parts of the
+ * application to the same file).
+ * With custom modifications...
+ */
+
+#include <H5private.h> /*library functions */
+#include <H5Eprivate.h> /*error handling */
+#include <H5Fprivate.h> /*files */
+#include <H5FDlog.h> /* logging file driver */
+#include <H5MMprivate.h> /* Memory allocation */
+#include <H5Pprivate.h> /*property lists */
+
+#ifdef MAX
+#undef MAX
+#define MAX(X,Y) ((X)>(Y)?(X):(Y))
+#endif /* MAX */
+
+/* The driver identification number, initialized at runtime */
+static hid_t H5FD_QAK_g = 0;
+
+/* File operations */
+#define OP_UNKNOWN 0
+#define OP_READ 1
+#define OP_WRITE 2
+
+/* Driver-specific file access properties */
+typedef struct H5FD_log_fapl_t {
+ const char *logfile; /* Log file name */
+ intn verbosity; /* Verbosity of logging information */
+} H5FD_log_fapl_t;
+
+/* Define strings for the different file memory types */
+static const char *flavors[]={ /* These are defined in H5FDpublic.h */
+ "H5FD_MEM_DEFAULT",
+ "H5FD_MEM_SUPER",
+ "H5FD_MEM_BTREE",
+ "H5FD_MEM_DRAW",
+ "H5FD_MEM_GHEAP",
+ "H5FD_MEM_LHEAP",
+ "H5FD_MEM_OHDR",
+};
+
+/*
+ * The description of a file belonging to this driver. The `eoa' and `eof'
+ * determine the amount of hdf5 address space in use and the high-water mark
+ * of the file (the current size of the underlying Unix file). The `pos'
+ * value is used to eliminate file position updates when they would be a
+ * no-op. Unfortunately we've found systems that use separate file position
+ * indicators for reading and writing so the lseek can only be eliminated if
+ * the current operation is the same as the previous operation. When opening
+ * a file the `eof' will be set to the current file size, `eoa' will be set
+ * to zero, `pos' will be set to H5F_ADDR_UNDEF (as it is when an error
+ * occurs), and `op' will be set to H5F_OP_UNKNOWN.
+ */
+typedef struct H5FD_log_t {
+ H5FD_t pub; /*public stuff, must be first */
+ int fd; /*the unix file */
+ haddr_t eoa; /*end of allocated region */
+ haddr_t eof; /*end of file; current file size*/
+ haddr_t pos; /*current file I/O position */
+ int op; /*last operation */
+ unsigned char *nread; /* Number of reads from a file location */
+ unsigned char *nwrite; /* Number of write to a file location */
+ unsigned char *flavor; /* Flaver of information written to file location */
+ size_t iosize; /* Size of I/O information buffers */
+ FILE *logfp; /* Log file pointer */
+ H5FD_log_fapl_t fa; /*driver-specific file access properties*/
+#ifndef WIN32
+ /*
+ * On most systems the combination of device and i-node number uniquely
+ * identify a file.
+ */
+ dev_t device; /*file device number */
+ ino_t inode; /*file i-node number */
+#else
+ /*
+ * On WIN32 the low-order word of a unique identifier associated with the
+ * file and the volume serial number uniquely identify a file. This number
+ * (which, both? -rpm) may change when the system is restarted or when the
+ * file is opened. After a process opens a file, the identifier is
+ * constant until the file is closed. An application can use this
+ * identifier and the volume serial number to determine whether two
+ * handles refer to the same file.
+ */
+ int fileindexlo;
+ int fileindexhi;
+#endif
+} H5FD_log_t;
+
+/*
+ * This driver supports systems that have the lseek64() function by defining
+ * some macros here so we don't have to have conditional compilations later
+ * throughout the code.
+ *
+ * file_offset_t: The datatype for file offsets, the second argument of
+ * the lseek() or lseek64() call.
+ *
+ * file_seek: The function which adjusts the current file position,
+ * either lseek() or lseek64().
+ */
+#ifdef HAVE_LSEEK64
+# define file_offset_t off64_t
+# define file_seek lseek64
+#else
+# define file_offset_t off_t
+# define file_seek lseek
+#endif
+
+/*
+ * These macros check for overflow of various quantities. These macros
+ * assume that file_offset_t is signed and haddr_t and size_t are unsigned.
+ *
+ * ADDR_OVERFLOW: Checks whether a file address of type `haddr_t'
+ * is too large to be represented by the second argument
+ * of the file seek function.
+ *
+ * SIZE_OVERFLOW: Checks whether a buffer size of type `hsize_t' is too
+ * large to be represented by the `size_t' type.
+ *
+ * REGION_OVERFLOW: Checks whether an address and size pair describe data
+ * which can be addressed entirely by the second
+ * argument of the file seek function.
+ */
+#define MAXADDR (((haddr_t)1<<(8*sizeof(file_offset_t)-1))-1)
+#define ADDR_OVERFLOW(A) (HADDR_UNDEF==(A) || \
+ ((A) & ~(haddr_t)MAXADDR))
+#define SIZE_OVERFLOW(Z) ((Z) & ~(hsize_t)MAXADDR)
+#define REGION_OVERFLOW(A,Z) (ADDR_OVERFLOW(A) || SIZE_OVERFLOW(Z) || \
+ sizeof(file_offset_t)<sizeof(size_t) || \
+ HADDR_UNDEF==(A)+(Z) || \
+ (file_offset_t)((A)+(Z))<(file_offset_t)(A))
+
+/* Prototypes */
+static void *H5FD_log_fapl_get(H5FD_t *file);
+static void *H5FD_log_fapl_copy(const void *_old_fa);
+static herr_t H5FD_log_fapl_free(void *_fa);
+static H5FD_t *H5FD_log_open(const char *name, unsigned flags, hid_t fapl_id,
+ haddr_t maxaddr);
+static herr_t H5FD_log_close(H5FD_t *_file);
+static int H5FD_log_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
+static haddr_t H5FD_log_alloc(H5FD_t *_file, H5FD_mem_t type, hsize_t size);
+static haddr_t H5FD_log_get_eoa(H5FD_t *_file);
+static herr_t H5FD_log_set_eoa(H5FD_t *_file, haddr_t addr);
+static haddr_t H5FD_log_get_eof(H5FD_t *_file);
+static herr_t H5FD_log_read(H5FD_t *_file, hid_t fapl_id, haddr_t addr,
+ hsize_t size, void *buf);
+static herr_t H5FD_log_write(H5FD_t *_file, hid_t fapl_id, haddr_t addr,
+ hsize_t size, const void *buf);
+static herr_t H5FD_log_flush(H5FD_t *_file);
+
+/*
+ * The free list map which causes each request type to use no free lists
+ */
+#define H5FD_FLMAP_NOLIST { \
+ H5FD_MEM_NOLIST, /*default*/ \
+ H5FD_MEM_NOLIST, /*super*/ \
+ H5FD_MEM_NOLIST, /*btree*/ \
+ H5FD_MEM_NOLIST, /*draw*/ \
+ H5FD_MEM_NOLIST, /*gheap*/ \
+ H5FD_MEM_NOLIST, /*lheap*/ \
+ H5FD_MEM_NOLIST /*ohdr*/ \
+}
+
+static const H5FD_class_t H5FD_log_g = {
+ "log", /*name */
+ MAXADDR, /*maxaddr */
+ NULL, /*sb_size */
+ NULL, /*sb_encode */
+ NULL, /*sb_decode */
+ sizeof(char *), /*fapl_size */
+ H5FD_log_fapl_get, /*fapl_get */
+ H5FD_log_fapl_copy, /*fapl_copy */
+ H5FD_log_fapl_free, /*fapl_free */
+ 0, /*dxpl_size */
+ NULL, /*dxpl_copy */
+ NULL, /*dxpl_free */
+ H5FD_log_open, /*open */
+ H5FD_log_close, /*close */
+ H5FD_log_cmp, /*cmp */
+ H5FD_log_alloc, /*alloc */
+ NULL, /*free */
+ H5FD_log_get_eoa, /*get_eoa */
+ H5FD_log_set_eoa, /*set_eoa */
+ H5FD_log_get_eof, /*get_eof */
+ H5FD_log_read, /*read */
+ H5FD_log_write, /*write */
+ H5FD_log_flush, /*flush */
+ H5FD_FLMAP_NOLIST, /*fl_map */
+};
+
+/* Interface initialization */
+#define PABLO_MASK H5FD_log_mask
+#define INTERFACE_INIT H5FD_log_init
+static intn interface_initialize_g = 0;
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_init
+ *
+ * Purpose: Initialize this driver by registering the driver with the
+ * library.
+ *
+ * Return: Success: The driver ID for the log driver.
+ *
+ * Failure: Negative.
+ *
+ * Programmer: Robb Matzke
+ * Thursday, July 29, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+H5FD_log_init(void)
+{
+ FUNC_ENTER(H5FD_log_init, FAIL);
+
+ if (H5I_VFL!=H5Iget_type(H5FD_QAK_g))
+ H5FD_QAK_g = H5FDregister(&H5FD_log_g);
+
+ FUNC_LEAVE(H5FD_QAK_g);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5Pset_fapl_log
+ *
+ * Purpose: Modify the file access property list to use the H5FD_QAK
+ * driver defined in this source file. There are no driver
+ * specific properties.
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Robb Matzke
+ * Thursday, February 19, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Pset_fapl_log(hid_t fapl_id, const char *logfile, int verbosity)
+{
+ H5FD_log_fapl_t fa; /* File access property list information */
+ herr_t ret_value=FAIL;
+
+ FUNC_ENTER(H5FD_set_fapl_log, FAIL);
+ H5TRACE1("e","i",fapl_id);
+
+ if (H5P_FILE_ACCESS!=H5Pget_class(fapl_id))
+ HRETURN_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a fapl");
+
+ fa.logfile=logfile;
+ fa.verbosity=verbosity;
+ ret_value= H5Pset_driver(fapl_id, H5FD_QAK, &fa);
+
+ FUNC_LEAVE(ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_fapl_get
+ *
+ * Purpose: Returns a file access property list which indicates how the
+ * specified file is being accessed. The return list could be
+ * used to access another file the same way.
+ *
+ * Return: Success: Ptr to new file access property list with all
+ * members copied from the file struct.
+ *
+ * Failure: NULL
+ *
+ * Programmer: Quincey Koziol
+ * Thursday, April 20, 2000
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void *
+H5FD_log_fapl_get(H5FD_t *_file)
+{
+ H5FD_log_t *file = (H5FD_log_t*)_file;
+
+ FUNC_ENTER(H5FD_log_fapl_get, NULL);
+
+ FUNC_LEAVE(H5FD_log_fapl_copy(&(file->fa)));
+} /* end H5FD_log_fapl_get() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_fapl_copy
+ *
+ * Purpose: Copies the log-specific file access properties.
+ *
+ * Return: Success: Ptr to a new property list
+ *
+ * Failure: NULL
+ *
+ * Programmer: Quincey Koziol
+ * Thursday, April 20, 2000
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void *
+H5FD_log_fapl_copy(const void *_old_fa)
+{
+ const H5FD_log_fapl_t *old_fa = (const H5FD_log_fapl_t*)_old_fa;
+ H5FD_log_fapl_t *new_fa = H5MM_malloc(sizeof(H5FD_log_fapl_t));
+
+ FUNC_ENTER(H5FD_log_fapl_copy, NULL);
+
+ assert(new_fa);
+
+ /* Copy the general information */
+ HDmemcpy(new_fa, old_fa, sizeof(H5FD_log_fapl_t));
+
+ /* Deep copy the log file name */
+ if(old_fa->logfile!=NULL)
+ if (NULL==(new_fa->logfile=HDstrdup(old_fa->logfile)))
+ HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
+ "unable to allocate log file name");
+
+ FUNC_LEAVE(new_fa);
+} /* end H5FD_log_fapl_copy() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_fapl_free
+ *
+ * Purpose: Frees the log-specific file access properties.
+ *
+ * Return: Success: 0
+ *
+ * Failure: -1
+ *
+ * Programmer: Quincey Koziol
+ * Thursday, April 20, 2000
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_log_fapl_free(void *_fa)
+{
+ H5FD_log_fapl_t *fa = (H5FD_log_fapl_t*)_fa;
+
+ FUNC_ENTER(H5FD_log_fapl_free, FAIL);
+
+ /* Free the fapl information */
+ if(fa->logfile)
+ H5MM_xfree((void *)fa->logfile);
+ H5MM_xfree(fa);
+
+ FUNC_LEAVE(SUCCEED);
+} /* end H5FD_log_fapl_free() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_open
+ *
+ * Purpose: Create and/or opens a Unix file as an HDF5 file.
+ *
+ * Return: Success: A pointer to a new file data structure. The
+ * public fields will be initialized by the
+ * caller, which is always H5FD_open().
+ *
+ * Failure: NULL
+ *
+ * Programmer: Robb Matzke
+ * Thursday, July 29, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static H5FD_t *
+H5FD_log_open(const char *name, unsigned flags, hid_t fapl_id,
+ haddr_t maxaddr)
+{
+ unsigned o_flags;
+ int fd;
+ struct stat sb;
+ H5FD_log_t *file=NULL;
+ H5FD_log_fapl_t *fa; /* File access property list information */
+#ifdef WIN32
+ HFILE filehandle;
+ struct _BY_HANDLE_FILE_INFORMATION fileinfo;
+ int results;
+#endif
+
+ FUNC_ENTER(H5FD_log_open, NULL);
+
+ /* Check arguments */
+ if (!name || !*name)
+ HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid file name");
+ if (0==maxaddr || HADDR_UNDEF==maxaddr)
+ HRETURN_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "bogus maxaddr");
+ if (ADDR_OVERFLOW(maxaddr))
+ HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, NULL, "bogus maxaddr");
+
+ /* Build the open flags */
+ o_flags = (H5F_ACC_RDWR & flags) ? O_RDWR : O_RDONLY;
+ if (H5F_ACC_TRUNC & flags) o_flags |= O_TRUNC;
+ if (H5F_ACC_CREAT & flags) o_flags |= O_CREAT;
+ if (H5F_ACC_EXCL & flags) o_flags |= O_EXCL;
+
+ /* Open the file */
+ if ((fd=HDopen(name, o_flags, 0666))<0)
+ HRETURN_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "unable to open file");
+ if (fstat(fd, &sb)<0) {
+ close(fd);
+ HRETURN_ERROR(H5E_FILE, H5E_BADFILE, NULL, "unable to fstat file");
+ }
+
+ /* Create the new file struct */
+ if (NULL==(file=H5MM_calloc(sizeof(H5FD_log_t))))
+ HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL,
+ "unable to allocate file struct");
+
+ /* Get the driver specific information */
+ fa = H5Pget_driver_info(fapl_id);
+
+ file->fd = fd;
+ file->eof = sb.st_size;
+ file->pos = HADDR_UNDEF;
+ file->op = OP_UNKNOWN;
+#ifdef WIN32
+ filehandle = _get_osfhandle(fd);
+ results = GetFileInformationByHandle(filehandle, &fileinfo);
+ file->fileindexhi = fileinfo.nFileIndexHigh;
+ file->fileindexlo = fileinfo.nFileIndexLow;
+#else
+ file->device = sb.st_dev;
+ file->inode = sb.st_ino;
+#endif
+
+ /* Get the verbosity of the logging */
+ file->fa.verbosity=fa->verbosity;
+
+ /* Check if we are doing any logging at all */
+ if(file->fa.verbosity>=0) {
+ file->iosize=3000000; /* Default size for now */
+ file->nread=H5MM_calloc(file->iosize);
+ file->nwrite=H5MM_calloc(file->iosize);
+ file->flavor=H5MM_calloc(file->iosize);
+ if(fa->logfile)
+ file->logfp=fopen(fa->logfile,"w");
+ else
+ file->logfp=stderr;
+ } /* end if */
+
+ FUNC_LEAVE((H5FD_t*)file);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_close
+ *
+ * Purpose: Closes a Unix file.
+ *
+ * Return: Success: 0
+ *
+ * Failure: -1, file not closed.
+ *
+ * Programmer: Robb Matzke
+ * Thursday, July 29, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_log_close(H5FD_t *_file)
+{
+ H5FD_log_t *file = (H5FD_log_t*)_file;
+
+ FUNC_ENTER(H5FD_log_close, FAIL);
+
+ if (H5FD_log_flush(_file)<0)
+ HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to flush file");
+ if (close(file->fd)<0)
+ HRETURN_ERROR(H5E_IO, H5E_CANTCLOSEFILE, FAIL, "unable to close file");
+
+ /* Dump I/O information */
+ if(file->fa.verbosity>=0) {
+ haddr_t addr;
+ haddr_t last_addr;
+ unsigned char last_val;
+
+ /* Dump the write I/O information */
+ HDfprintf(file->logfp,"Dumping write I/O information:\n");
+ last_val=file->nwrite[0];
+ last_addr=0;
+ addr=1;
+ while(addr<file->eoa) {
+ if(file->nwrite[addr]!=last_val) {
+ HDfprintf(file->logfp,"\tAddr %10a-%10a (%10lu bytes) written to %3d times\n",last_addr,(addr-1),(unsigned long)(addr-last_addr),(int)last_val);
+ last_val=file->nwrite[addr];
+ last_addr=addr;
+ } /* end if */
+ addr++;
+ } /* end while */
+ HDfprintf(file->logfp,"\tAddr %10a-%10a (%10lu bytes) written to %3d times\n",last_addr,(addr-1),(unsigned long)(addr-last_addr),(int)last_val);
+
+ /* Dump the read I/O information */
+ HDfprintf(file->logfp,"Dumping read I/O information:\n");
+ last_val=file->nread[0];
+ last_addr=0;
+ addr=1;
+ while(addr<file->eoa) {
+ if(file->nread[addr]!=last_val) {
+ HDfprintf(file->logfp,"\tAddr %10a-%10a (%10lu bytes) read from %3d times\n",last_addr,(addr-1),(unsigned long)(addr-last_addr),(int)last_val);
+ last_val=file->nread[addr];
+ last_addr=addr;
+ } /* end if */
+ addr++;
+ } /* end while */
+ HDfprintf(file->logfp,"\tAddr %10a-%10a (%10lu bytes) read from %3d times\n",last_addr,(addr-1),(unsigned long)(addr-last_addr),(int)last_val);
+
+ /* Dump the I/O flavor information */
+ HDfprintf(file->logfp,"Dumping I/O flavor information:\n");
+ last_val=file->flavor[0];
+ last_addr=0;
+ addr=1;
+ while(addr<file->eoa) {
+ if(file->flavor[addr]!=last_val) {
+ HDfprintf(file->logfp,"\tAddr %10a-%10a (%10lu bytes) flavor is %s\n",last_addr,(addr-1),(unsigned long)(addr-last_addr),flavors[last_val]);
+ last_val=file->flavor[addr];
+ last_addr=addr;
+ } /* end if */
+ addr++;
+ } /* end while */
+ HDfprintf(file->logfp,"\tAddr %10a-%10a (%10lu bytes) flavor is %s\n",last_addr,(addr-1),(unsigned long)(addr-last_addr),flavors[last_val]);
+
+ /* Free the logging information */
+ file->nwrite=H5MM_xfree(file->nwrite);
+ file->nread=H5MM_xfree(file->nread);
+ file->flavor=H5MM_xfree(file->flavor);
+ if(file->logfp!=stderr)
+ fclose(file->logfp);
+ } /* end if */
+
+ H5MM_xfree(file);
+
+ FUNC_LEAVE(SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_cmp
+ *
+ * Purpose: Compares two files belonging to this driver using an
+ * arbitrary (but consistent) ordering.
+ *
+ * Return: Success: A value like strcmp()
+ *
+ * Failure: never fails (arguments were checked by the
+ * caller).
+ *
+ * Programmer: Robb Matzke
+ * Thursday, July 29, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+H5FD_log_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
+{
+ const H5FD_log_t *f1 = (const H5FD_log_t*)_f1;
+ const H5FD_log_t *f2 = (const H5FD_log_t*)_f2;
+ int ret_value=0;
+
+ FUNC_ENTER(H5FD_log_cmp, -2);
+
+#ifdef WIN32
+ if (f1->fileindexhi < f2->fileindexhi) ret_value= -1;
+ if (f1->fileindexhi > f2->fileindexhi) ret_value= 1;
+
+ if (f1->fileindexlo < f2->fileindexlo) ret_value= -1;
+ if (f1->fileindexlo > f2->fileindexlo) ret_value= 1;
+
+#else
+ if (f1->device < f2->device) ret_value= -1;
+ if (f1->device > f2->device) ret_value= 1;
+
+ if (f1->inode < f2->inode) ret_value= -1;
+ if (f1->inode > f2->inode) ret_value= 1;
+#endif
+
+ FUNC_LEAVE(ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_alloc
+ *
+ * Purpose: Allocate file memory.
+ *
+ * Return: Success: Address of new memory
+ *
+ * Failure: HADDR_UNDEF
+ *
+ * Programmer: Quincey Koziol
+ * Monday, April 17, 2000
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static haddr_t
+H5FD_log_alloc(H5FD_t *_file, H5FD_mem_t type, hsize_t size)
+{
+ H5FD_log_t *file = (H5FD_log_t*)_file;
+ haddr_t addr;
+
+ FUNC_ENTER(H5FD_log_alloc, HADDR_UNDEF);
+
+ addr = file->eoa;
+ file->eoa += size;
+
+ /* Retain the (first) flavor of the information written to the file */
+ if(file->fa.verbosity>=0) {
+ assert(addr<file->iosize);
+ HDmemset(&file->flavor[addr],type,size);
+
+ if(file->fa.verbosity>1)
+ HDfprintf(file->logfp,"%10a-%10a (%10lu bytes) Allocated, flavor=%s\n",addr,addr+size-1,(unsigned long)size,flavors[file->flavor[addr]]);
+ } /* end if */
+
+ FUNC_LEAVE(addr);
+} /* H5FD_log_alloc() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_get_eoa
+ *
+ * Purpose: Gets the end-of-address marker for the file. The EOA marker
+ * is the first address past the last byte allocated in the
+ * format address space.
+ *
+ * Return: Success: The end-of-address marker.
+ *
+ * Failure: HADDR_UNDEF
+ *
+ * Programmer: Robb Matzke
+ * Monday, August 2, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static haddr_t
+H5FD_log_get_eoa(H5FD_t *_file)
+{
+ H5FD_log_t *file = (H5FD_log_t*)_file;
+
+ FUNC_ENTER(H5FD_log_get_eoa, HADDR_UNDEF);
+
+ FUNC_LEAVE(file->eoa);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_set_eoa
+ *
+ * Purpose: Set the end-of-address marker for the file. This function is
+ * called shortly after an existing HDF5 file is opened in order
+ * to tell the driver where the end of the HDF5 data is located.
+ *
+ * Return: Success: 0
+ *
+ * Failure: -1
+ *
+ * Programmer: Robb Matzke
+ * Thursday, July 29, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_log_set_eoa(H5FD_t *_file, haddr_t addr)
+{
+ H5FD_log_t *file = (H5FD_log_t*)_file;
+
+ FUNC_ENTER(H5FD_log_set_eoa, FAIL);
+
+ file->eoa = addr;
+
+ FUNC_LEAVE(SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_get_eof
+ *
+ * Purpose: Returns the end-of-file marker, which is the greater of
+ * either the Unix end-of-file or the HDF5 end-of-address
+ * markers.
+ *
+ * Return: Success: End of file address, the first address past
+ * the end of the "file", either the Unix file
+ * or the HDF5 file.
+ *
+ * Failure: HADDR_UNDEF
+ *
+ * Programmer: Robb Matzke
+ * Thursday, July 29, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static haddr_t
+H5FD_log_get_eof(H5FD_t *_file)
+{
+ H5FD_log_t *file = (H5FD_log_t*)_file;
+
+ FUNC_ENTER(H5FD_get_get_eof, HADDR_UNDEF);
+
+ FUNC_LEAVE(MAX(file->eof, file->eoa));
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_read
+ *
+ * Purpose: Reads SIZE bytes of data from FILE beginning at address ADDR
+ * into buffer BUF according to data transfer properties in
+ * DXPL_ID.
+ *
+ * Return: Success: Zero. Result is stored in caller-supplied
+ * buffer BUF.
+ *
+ * Failure: -1, Contents of buffer BUF are undefined.
+ *
+ * Programmer: Robb Matzke
+ * Thursday, July 29, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_log_read(H5FD_t *_file, hid_t UNUSED dxpl_id, haddr_t addr,
+ hsize_t size, void *buf/*out*/)
+{
+ H5FD_log_t *file = (H5FD_log_t*)_file;
+ ssize_t nbytes;
+
+ FUNC_ENTER(H5FD_log_read, FAIL);
+
+ assert(file && file->pub.cls);
+ assert(buf);
+
+ /* Check for overflow conditions */
+ if (HADDR_UNDEF==addr)
+ HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined");
+ if (REGION_OVERFLOW(addr, size))
+ HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow");
+ if (addr+size>file->eoa)
+ HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow");
+
+ /* Log the I/O information about the read */
+ if(file->fa.verbosity>=0) {
+ hsize_t tmp_size=size;
+ haddr_t tmp_addr=addr;
+
+ assert((addr+size)<file->iosize);
+ while(tmp_size-->0)
+ file->nread[tmp_addr++]++;
+
+ if(file->fa.verbosity>0)
+ HDfprintf(file->logfp,"%10a-%10a (%10lu bytes) Read, flavor=%s\n",addr,addr+size-1,(unsigned long)size,flavors[file->flavor[addr]]);
+ }
+
+ /* Seek to the correct location */
+ if ((addr!=file->pos || OP_READ!=file->op) &&
+ file_seek(file->fd, (file_offset_t)addr, SEEK_SET)<0) {
+ file->pos = HADDR_UNDEF;
+ file->op = OP_UNKNOWN;
+ HRETURN_ERROR(H5E_IO, H5E_SEEKERROR, FAIL,
+ "unable to seek to proper position");
+ }
+
+ /*
+ * Read data, being careful of interrupted system calls, partial results,
+ * and the end of the file.
+ */
+ while (size>0) {
+ do
+ nbytes = read(file->fd, buf, size);
+ while (-1==nbytes && EINTR==errno);
+ if (-1==nbytes) {
+ /* error */
+ file->pos = HADDR_UNDEF;
+ file->op = OP_UNKNOWN;
+ HRETURN_ERROR(H5E_IO, H5E_READERROR, FAIL, "file read failed");
+ }
+ if (0==nbytes) {
+ /* end of file but not end of format address space */
+ memset(buf, 0, size);
+ size = 0;
+ }
+ assert(nbytes>=0);
+ assert((hsize_t)nbytes<=size);
+ size -= (hsize_t)nbytes;
+ addr += (haddr_t)nbytes;
+ buf = (char*)buf + nbytes;
+ }
+
+ /* Update current position */
+ file->pos = addr;
+ file->op = OP_READ;
+ FUNC_LEAVE(SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_write
+ *
+ * Purpose: Writes SIZE bytes of data to FILE beginning at address ADDR
+ * from buffer BUF according to data transfer properties in
+ * DXPL_ID.
+ *
+ * Return: Success: Zero
+ *
+ * Failure: -1
+ *
+ * Programmer: Robb Matzke
+ * Thursday, July 29, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_log_write(H5FD_t *_file, hid_t UNUSED dxpl_id, haddr_t addr,
+ hsize_t size, const void *buf)
+{
+ H5FD_log_t *file = (H5FD_log_t*)_file;
+ ssize_t nbytes;
+
+ FUNC_ENTER(H5FD_log_write, FAIL);
+
+ assert(file && file->pub.cls);
+ assert(buf);
+
+ /* Check for overflow conditions */
+ if (HADDR_UNDEF==addr)
+ HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined");
+ if (REGION_OVERFLOW(addr, size))
+ HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow");
+ if (addr+size>file->eoa)
+ HRETURN_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow");
+
+ /* Log the I/O information about the write */
+ if(file->fa.verbosity>=0) {
+ hsize_t tmp_size=size;
+ haddr_t tmp_addr=addr;
+
+ assert((addr+size)<file->iosize);
+ while(tmp_size-->0)
+ file->nwrite[tmp_addr++]++;
+
+ if(file->fa.verbosity>0)
+ HDfprintf(file->logfp,"%10a-%10a (%10lu bytes) Written, flavor=%s\n",addr,addr+size-1,(unsigned long)size,flavors[file->flavor[addr]]);
+ }
+
+ /* Seek to the correct location */
+ if ((addr!=file->pos || OP_WRITE!=file->op) &&
+ file_seek(file->fd, (file_offset_t)addr, SEEK_SET)<0) {
+ file->pos = HADDR_UNDEF;
+ file->op = OP_UNKNOWN;
+ HRETURN_ERROR(H5E_IO, H5E_SEEKERROR, FAIL,
+ "unable to seek to proper position");
+ }
+
+ /*
+ * Write the data, being careful of interrupted system calls and partial
+ * results
+ */
+ while (size>0) {
+ do
+ nbytes = write(file->fd, buf, size);
+ while (-1==nbytes && EINTR==errno);
+ if (-1==nbytes) {
+ /* error */
+ file->pos = HADDR_UNDEF;
+ file->op = OP_UNKNOWN;
+ HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "file write failed");
+ }
+ assert(nbytes>0);
+ assert((hsize_t)nbytes<=size);
+ size -= (hsize_t)nbytes;
+ addr += (haddr_t)nbytes;
+ buf = (const char*)buf + nbytes;
+ }
+
+ /* Update current position and eof */
+ file->pos = addr;
+ file->op = OP_WRITE;
+ if (file->pos>file->eof)
+ file->eof = file->pos;
+
+ FUNC_LEAVE(SUCCEED);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5FD_log_flush
+ *
+ * Purpose: Makes sure that the true file size is the same (or larger)
+ * than the end-of-address.
+ *
+ * Return: Success: Non-negative
+ *
+ * Failure: Negative
+ *
+ * Programmer: Robb Matzke
+ * Wednesday, August 4, 1999
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FD_log_flush(H5FD_t *_file)
+{
+ H5FD_log_t *file = (H5FD_log_t*)_file;
+
+ FUNC_ENTER(H5FD_log_seek, FAIL);
+
+ if (file->eoa>file->eof) {
+ if (-1==file_seek(file->fd, (file_offset_t)(file->eoa-1), SEEK_SET))
+ HRETURN_ERROR(H5E_IO, H5E_SEEKERROR, FAIL,
+ "unable to seek to proper position");
+ if (write(file->fd, "", 1)!=1)
+ HRETURN_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "file write failed");
+ file->eof = file->eoa;
+ file->pos = file->eoa;
+ file->op = OP_WRITE;
+ }
+
+ FUNC_LEAVE(SUCCEED);
+}