path: root/src/H5Fcore.c

/*
 * Copyright (C) 1997 NCSA
 *		      All rights reserved.
 *
 * Programmer: Robb Matzke <matzke@llnl.gov>
 *	       Wednesday, October 22, 1997
 *
 * Purpose:    This file implements an in-core temporary file.	It's intended
 *	       for storing small temporary files such as wrappers generated
 *	       on the fly.
 *
 * Note:       This is mostly an exercise to help clean up parts of the H5F
 *	       package since this driver is quite different than the other
 *	       low level drivers we have so far.
 *
 */
#include <H5private.h>
#include <H5Eprivate.h>
#include <H5Fprivate.h>
#include <H5MMprivate.h>

#define H5F_CORE_DEV	0xffff	/*pseudo dev for core until we fix things */

#define PABLO_MASK	H5F_core
static hbool_t		interface_initialize_g = FALSE;
#define INTERFACE_INIT NULL

static hbool_t H5F_core_access(const char *name,
			       const H5F_access_t *access_parms, int mode,
			       H5F_search_t *key/*out*/);
static H5F_low_t *H5F_core_open(const char *name,
				const H5F_access_t *access_parms, uintn flags,
				H5F_search_t *key/*out*/);
static herr_t H5F_core_close(H5F_low_t *lf, const H5F_access_t *access_parms);
static herr_t H5F_core_read(H5F_low_t *lf, const H5F_access_t *access_parms,
			    const haddr_t *addr, size_t size, uint8 *buf);
static herr_t H5F_core_write(H5F_low_t *lf, const H5F_access_t *access_parms,
			     const haddr_t *addr, size_t size,
			     const uint8 *buf);

const H5F_low_class_t	H5F_LOW_CORE_g[1] = {{
    H5F_core_access,	    /* access method			    */
    H5F_core_open,	    /* open method			    */
    H5F_core_close,	    /* close method			    */
    H5F_core_read,	    /* read method			    */
    H5F_core_write,	    /* write method			    */
    NULL,		    /* flush method			    */
    NULL,		    /* extend method			    */
}};


/*-------------------------------------------------------------------------
 * Function:	H5F_core_access
 *
 * Purpose:	Determines if the specified file already exists.  This driver
 *		doesn't use names, so every call to H5F_core_open() would
 *		create a new file.  Therefore, this function always returns
 *		false and KEY is never initialized.
 *
 * Return:	Success:	FALSE
 *
 *		Failure:	FAIL
 *
 * Programmer:	Robb Matzke
 *		Friday, October 24, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static hbool_t
H5F_core_access(const char __unused__*name,
		const H5F_access_t __unused__ *access_parms,
		int __unused__ mode, H5F_search_t __unused__ *key/*out*/)
{
    FUNC_ENTER(H5F_core_access, FAIL);
    FUNC_LEAVE(FALSE);
}


/*-------------------------------------------------------------------------
 * Function:	H5F_core_open
 *
 * Purpose:	Opens a temporary file which will exist only in memory.	 The
 *		NAME argument is unused.  The FLAGS are a bit field with
 *		the possible values defined in H5F_low_open().
 *
 * Errors:
 *		IO	  CANTOPENFILE	Must creat file with write access. 
 *
 * Return:	Success:	Low-level file pointer
 *
 *		Failure:	NULL
 *
 * Programmer:	Robb Matzke
 *		Wednesday, October 22, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static H5F_low_t *
H5F_core_open(const char __unused__ *name,
	      const H5F_access_t __unused__ *access_parms,
	      uintn flags, H5F_search_t *key/*out*/)
{
    H5F_low_t		   *lf = NULL;
    static ino_t	    ino = 0;

    FUNC_ENTER(H5F_core_open, NULL);

    if (0 == (flags & H5F_ACC_RDWR) || 0 == (flags & H5F_ACC_CREAT)) {
	HRETURN_ERROR(H5E_IO, H5E_CANTOPENFILE, NULL,
		      "must creat file with write access");
    }
    
    lf = H5MM_xcalloc(1, sizeof(H5F_low_t));
    lf->u.core.mem = NULL;
    lf->u.core.alloc = 0;
    lf->u.core.size = 0;
    H5F_addr_reset(&(lf->eof));

    if (key) {
	key->dev = H5F_CORE_DEV;
	key->ino = ino++;
    }
    
    FUNC_LEAVE(lf);
}


/*-------------------------------------------------------------------------
 * Function:	H5F_core_close
 *
 * Purpose:	Closes a file.
 *
 * Errors:
 *
 * Return:	Success:	SUCCEED
 *
 *		Failure:	FAIL
 *
 * Programmer:	Robb Matzke
 *		Wednesday, October 22, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5F_core_close(H5F_low_t *lf, const H5F_access_t __unused__ *access_parms)
{
    FUNC_ENTER(H5F_core_close, FAIL);

    lf->u.core.mem = H5MM_xfree(lf->u.core.mem);
    lf->u.core.size = 0;
    lf->u.core.alloc = 0;

    FUNC_LEAVE(SUCCEED);
}


/*-------------------------------------------------------------------------
 * Function:	H5F_core_read
 *
 * Purpose:	Reads SIZE bytes beginning at address ADDR in file LF and
 *		places them in buffer BUF.  Reading past the logical or
 *		physical end of the file returns zeros instead of failing.
 *
 * Errors:
 *
 * Return:	Success:	SUCCEED
 *
 *		Failure:	FAIL
 *
 * Programmer:	Robb Matzke
 *		Wednesday, October 22, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5F_core_read(H5F_low_t *lf, const H5F_access_t __unused__ *access_parms,
	      const haddr_t *addr, size_t size, uint8 *buf)
{
    size_t		n;
    size_t		eof;

    FUNC_ENTER(H5F_core_read, FAIL);

    assert(lf);
    assert(addr && H5F_addr_defined(addr));
    assert(buf);

    eof = MIN(lf->eof.offset, lf->u.core.size);

    if (addr->offset >= eof) {
	HDmemset(buf, 0, size);
    } else {
	n = MIN(size, eof-addr->offset);
	HDmemcpy(buf, lf->u.core.mem + addr->offset, n);
	HDmemset(buf+n, 0, size-n);
    }

    FUNC_LEAVE(SUCCEED);
}


/*-------------------------------------------------------------------------
 * Function:	H5F_core_write
 *
 * Purpose:	Writes SIZE bytes from the beginning of BUF into file LF at
 *		file address ADDR.  The file is extended as necessary to
 *		accommodate the new data.
 *
 * Errors:
 *
 * Return:	Success:	SUCCEED
 *
 *		Failure:	FAIL
 *
 * Programmer:	Robb Matzke
 *		Wednesday, October 22, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5F_core_write(H5F_low_t *lf, const H5F_access_t *access_parms,
	       const haddr_t *addr, size_t size, const uint8 *buf)
{
    size_t		need_more;
    size_t		increment = 1;
    

    FUNC_ENTER(H5F_core_write, FAIL);

    assert(lf);
    assert(addr && H5F_addr_defined(addr));
    assert(buf);
    assert (!access_parms || H5F_LOW_CORE==access_parms->driver);

    /*
     * Allocate more space.  We always allocate a multiple of the increment
     * size, which is either defined in the file access property list or
     * which defaults to one.
     */
    if (addr->offset + size > lf->u.core.alloc) {
	if (access_parms) increment = access_parms->u.core.increment;
	need_more = addr->offset+size - lf->u.core.alloc;
	need_more = increment*((need_more+increment-1)/increment);

	lf->u.core.alloc = lf->u.core.alloc + need_more;
	lf->u.core.mem = H5MM_xrealloc(lf->u.core.mem, lf->u.core.alloc);
    }
    
    /* Move the physical EOF marker */
    if (addr->offset + size > lf->u.core.size) {
	lf->u.core.size = addr->offset + size;
    }
    
    /* Copy data */
    HDmemcpy(lf->u.core.mem+addr->offset, buf, size);

    FUNC_LEAVE(SUCCEED);
}