netcdf-c/libsrc/posixio.c
2018-12-06 14:34:40 -07:00

1909 lines
44 KiB
C

/*
* Copyright 2018, University Corporation for Atmospheric Research
* See netcdf/COPYRIGHT file for copying and redistribution conditions.
*/
/* $Id: posixio.c,v 1.89 2010/05/22 21:59:08 dmh Exp $ */
/* For MinGW Build */
#if HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
/* Windows platforms, including MinGW, Cygwin, Visual Studio */
#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#include <winbase.h>
#include <io.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifndef NC_NOERR
#define NC_NOERR 0
#endif
#ifndef SEEK_SET
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
#endif
#include "ncio.h"
#include "fbits.h"
#include "rnd.h"
/* #define INSTRUMENT 1 */
#if INSTRUMENT /* debugging */
#undef NDEBUG
#include <stdio.h>
#include "instr.h"
#endif
#undef MIN /* system may define MIN somewhere and complain */
#define MIN(mm,nn) (((mm) < (nn)) ? (mm) : (nn))
#if !defined(NDEBUG) && !defined(X_INT_MAX)
#define X_INT_MAX 2147483647
#endif
#if 0 /* !defined(NDEBUG) && !defined(X_ALIGN) */
#define X_ALIGN 4
#else
#undef X_ALIGN
#endif
/* These are needed on mingw to get a dll to compile. They really
* should be provided in sys/stats.h, but what the heck. Let's not be
* too picky! */
#ifndef S_IRGRP
#define S_IRGRP 0000040
#endif
#ifndef S_IROTH
#define S_IROTH 0000004
#endif
#ifndef S_IWGRP
#define S_IWGRP 0000020
#endif
#ifndef S_IWOTH
#define S_IWOTH 0000002
#endif
/*Forward*/
static int ncio_px_filesize(ncio *nciop, off_t *filesizep);
static int ncio_px_pad_length(ncio *nciop, off_t length);
static int ncio_px_close(ncio *nciop, int doUnlink);
static int ncio_spx_close(ncio *nciop, int doUnlink);
/*
* Define the following for debugging.
*/
/* #define ALWAYS_NC_SHARE 1 */
/* Begin OS */
#ifndef POSIXIO_DEFAULT_PAGESIZE
#define POSIXIO_DEFAULT_PAGESIZE 4096
#endif
/*! Cross-platform file length.
*
* Some versions of Visual Studio are throwing errno 132
* when fstat is used on large files. This function is
* an attempt to get around that.
*
* @par fd File Descriptor.
* @return -1 on error, length of file (in bytes) otherwise.
*/
static off_t nc_get_filelen(const int fd) {
off_t flen;
#ifdef HAVE_FILE_LENGTH_I64
__int64 file_len = 0;
if ((file_len = _filelengthi64(fd)) < 0) {
return file_len;
}
flen = (off_t)file_len;
#else
int res = 0;
struct stat sb;
if((res = fstat(fd,&sb)) <0)
return res;
flen = sb.st_size;
#endif
return flen;
}
/*
* What is the system pagesize?
*/
static size_t
pagesize(void)
{
size_t pgsz;
#if defined(_WIN32) || defined(_WIN64)
SYSTEM_INFO info;
#endif
/* Hmm, aren't standards great? */
#if defined(_SC_PAGE_SIZE) && !defined(_SC_PAGESIZE)
#define _SC_PAGESIZE _SC_PAGE_SIZE
#endif
/* For MinGW Builds */
#if defined(_WIN32) || defined(_WIN64)
GetSystemInfo(&info);
pgsz = (size_t)info.dwPageSize;
#elif defined(_SC_PAGESIZE)
pgsz = (size_t)sysconf(_SC_PAGESIZE);
#elif defined(HAVE_GETPAGESIZE)
pgsz = (size_t) getpagesize();
#endif
if(pgsz > 0)
return (size_t) pgsz;
return (size_t)POSIXIO_DEFAULT_PAGESIZE;
}
/*
* What is the preferred I/O block size?
*/
static size_t
blksize(int fd)
{
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
#ifdef HAVE_SYS_STAT_H
struct stat sb;
if (fstat(fd, &sb) > -1)
{
if(sb.st_blksize >= 8192)
return (size_t) sb.st_blksize;
return 8192;
}
/* else, silent in the face of error */
#endif
#endif
return (size_t) 2 * pagesize();
}
/*
* Sortof like ftruncate, except won't make the
* file shorter.
*/
static int
fgrow(const int fd, const off_t len)
{
struct stat sb;
if (fstat(fd, &sb) < 0)
return errno;
if (len < sb.st_size)
return NC_NOERR;
{
const long dumb = 0;
/* we don't use ftruncate() due to problem with FAT32 file systems */
/* cache current position */
const off_t pos = lseek(fd, 0, SEEK_CUR);
if(pos < 0)
return errno;
if (lseek(fd, len-sizeof(dumb), SEEK_SET) < 0)
return errno;
if(write(fd, &dumb, sizeof(dumb)) < 0)
return errno;
if (lseek(fd, pos, SEEK_SET) < 0)
return errno;
}
return NC_NOERR;
}
/*
* Sortof like ftruncate, except won't make the file shorter. Differs
* from fgrow by only writing one byte at designated seek position, if
* needed.
*/
static int
fgrow2(const int fd, const off_t len)
{
/* There is a problem with fstat on Windows based systems
which manifests (so far) when Config RELEASE is built.
Use _filelengthi64 isntead.
See https://github.com/Unidata/netcdf-c/issues/188
*/
off_t file_len = nc_get_filelen(fd);
if(file_len < 0) return errno;
if(len <= file_len)
return NC_NOERR;
{
const char dumb = 0;
/* we don't use ftruncate() due to problem with FAT32 file systems */
/* cache current position */
const off_t pos = lseek(fd, 0, SEEK_CUR);
if(pos < 0)
return errno;
if (lseek(fd, len-1, SEEK_SET) < 0)
return errno;
if(write(fd, &dumb, sizeof(dumb)) < 0)
return errno;
if (lseek(fd, pos, SEEK_SET) < 0)
return errno;
}
return NC_NOERR;
}
/* End OS */
/* Begin px */
/* The px_ functions are for posix systems, when NC_SHARE is not in
effect. */
/* Write out a "page" of data to the file. The size of the page
(i.e. the extent) varies.
nciop - pointer to the file metadata.
offset - where in the file should this page be written.
extent - how many bytes should be written.
vp - pointer to the data to write.
posp - pointer to current position in file, updated after write.
*/
static int
px_pgout(ncio *const nciop,
off_t const offset, const size_t extent,
void *const vp, off_t *posp)
{
ssize_t partial;
size_t nextent;
char *nvp;
#ifdef X_ALIGN
assert(offset % X_ALIGN == 0);
#endif
assert(*posp == OFF_NONE || *posp == lseek(nciop->fd, 0, SEEK_CUR));
if(*posp != offset)
{
if(lseek(nciop->fd, offset, SEEK_SET) != offset)
{
return errno;
}
*posp = offset;
}
/* Old write, didn't handle partial writes correctly */
/* if(write(nciop->fd, vp, extent) != (ssize_t) extent) */
/* { */
/* return errno; */
/* } */
nextent = extent;
nvp = vp;
while((partial = write(nciop->fd, nvp, nextent)) != -1) {
if(partial == nextent)
break;
nvp += partial;
nextent -= partial;
}
if(partial == -1)
return errno;
*posp += extent;
return NC_NOERR;
}
/*! Read in a page of data.
@param[in] nciop A pointer to the ncio struct for this file.
@param[in] offset The byte offset in file where read starts.
@param[in] extent The size of the page that will be read.
@param[in] vp A pointer to where the data will end up.
@param[in,out] nreadp Returned number of bytes actually read (may be less than extent).
@param[in,out] posp The pointer to current position in file, updated after read.
@return Return 0 on success, otherwise an error code.
*/
static int
px_pgin(ncio *const nciop,
off_t const offset, const size_t extent,
void *const vp, size_t *nreadp, off_t *posp)
{
int status;
ssize_t nread;
#ifdef X_ALIGN
assert(offset % X_ALIGN == 0);
assert(extent % X_ALIGN == 0);
#endif
/* *posp == OFF_NONE (-1) on first call. This
is problematic because lseek also returns -1
on error. Use errno instead. */
if(*posp != OFF_NONE && *posp != lseek(nciop->fd, 0, SEEK_CUR)) {
if(errno) {
status = errno;
printf("Error %d: %s\n",errno,strerror(errno));
return status;
}
}
if(*posp != offset)
{
if(lseek(nciop->fd, offset, SEEK_SET) != offset)
{
status = errno;
return status;
}
*posp = offset;
}
errno = 0;
/* Handle the case where the read is interrupted
by a signal (see NCF-337,
http://pubs.opengroup.org/onlinepubs/009695399/functions/read.html)
When this happens, nread will (should) be the bytes read, and
errno will be set to EINTR. On older systems nread might be -1.
If this is the case, there's not a whole lot we can do about it
as we can't compute any offsets, so we will attempt to read again.
This *feels* like it could lead to an infinite loop, but it shouldn't
unless the read is being constantly interrupted by a signal, and is
on an older system which returns -1 instead of bytexs read.
The case where it's a short read is already handled by the function
(according to the comment below, at least). */
do {
nread = read(nciop->fd,vp,extent);
} while (nread == -1 && errno == EINTR);
if(nread != (ssize_t)extent) {
status = errno;
if( nread == -1 || (status != EINTR && status != NC_NOERR))
return status;
/* else it's okay we read less than asked for */
(void) memset((char *)vp + nread, 0, (ssize_t)extent - nread);
}
*nreadp = nread;
*posp += nread;
return NC_NOERR;
}
/* This struct is for POSIX systems, with NC_SHARE not in effect. If
NC_SHARE is used, see ncio_spx.
blksz - block size for reads and writes to file.
pos - current read/write position in file.
bf_offset - file offset corresponding to start of memory buffer
bf_extent - number of bytes in I/O request
bf_cnt - number of bytes available in buffer
bf_base - pointer to beginning of buffer.
bf_rflags - buffer region flags (defined in ncio.h) tell the lock
status, read/write permissions, and modification status of regions
of data in the buffer.
bf_refcount - buffer reference count.
slave - used in moves.
*/
typedef struct ncio_px {
size_t blksz;
off_t pos;
/* buffer */
off_t bf_offset;
size_t bf_extent;
size_t bf_cnt;
void *bf_base;
int bf_rflags;
int bf_refcount;
/* chain for double buffering in px_move */
struct ncio_px *slave;
} ncio_px;
/*ARGSUSED*/
/* This function indicates the file region starting at offset may be
released.
This is for POSIX, without NC_SHARE. If called with RGN_MODIFIED
flag, sets the modified flag in pxp->bf_rflags and decrements the
reference count.
pxp - pointer to posix non-share ncio_px struct.
offset - file offset for beginning of to region to be
released.
rflags - only RGN_MODIFIED is relevant to this function, others ignored
*/
static int
px_rel(ncio_px *const pxp, off_t offset, int rflags)
{
assert(pxp->bf_offset <= offset
&& offset < pxp->bf_offset + (off_t) pxp->bf_extent);
assert(pIf(fIsSet(rflags, RGN_MODIFIED),
fIsSet(pxp->bf_rflags, RGN_WRITE)));
if(fIsSet(rflags, RGN_MODIFIED))
{
fSet(pxp->bf_rflags, RGN_MODIFIED);
}
pxp->bf_refcount--;
return NC_NOERR;
}
/* This function indicates the file region starting at offset may be
released. Each read or write to the file is bracketed by a call to
the "get" region function and a call to the "rel" region function.
If you only read from the memory region, release it with a flag of
0, if you modify the region, release it with a flag of
RGN_MODIFIED.
For POSIX system, without NC_SHARE, this becomes the rel function
pointed to by the ncio rel function pointer. It mearly checks for
file write permission, then calls px_rel to do everything.
nciop - pointer to ncio struct.
offset - num bytes from beginning of buffer to region to be
released.
rflags - only RGN_MODIFIED is relevant to this function, others ignored
*/
static int
ncio_px_rel(ncio *const nciop, off_t offset, int rflags)
{
ncio_px *const pxp = (ncio_px *)nciop->pvt;
if(fIsSet(rflags, RGN_MODIFIED) && !fIsSet(nciop->ioflags, NC_WRITE))
return EPERM; /* attempt to write readonly file */
return px_rel(pxp, offset, rflags);
}
/* POSIX get. This will "make a region available." Since we're using
buffered IO, this means that if needed, we'll fetch a new page from
the file, otherwise, just return a pointer to what's in memory
already.
nciop - pointer to ncio struct, containing file info.
pxp - pointer to ncio_px struct, which contains special metadate
for posix files without NC_SHARE.
offset - start byte of region to get.
extent - how many bytes to read.
rflags - One of the RGN_* flags defined in ncio.h.
vpp - pointer to pointer that will receive data.
NOTES:
* For blkoffset round offset down to the nearest pxp->blksz. This
provides the offset (in bytes) to the beginning of the block that
holds the current offset.
* diff tells how far into the current block we are.
* For blkextent round up to the number of bytes at the beginning of
the next block, after the one that holds our current position, plus
whatever extra (i.e. the extent) that we are about to grab.
* The blkextent can't be more than twice the pxp->blksz. That's
because the pxp->blksize is the sizehint, and in ncio_px_init2 the
buffer (pointed to by pxp->bf-base) is allocated with 2 *
*sizehintp. This is checked (unnecessarily) more than once in
asserts.
* If this is called on a newly opened file, pxp->bf_offset will be
OFF_NONE and we'll jump to label pgin to immediately read in a
page.
*/
static int
px_get(ncio *const nciop, ncio_px *const pxp,
off_t offset, size_t extent,
int rflags,
void **const vpp)
{
int status = NC_NOERR;
const off_t blkoffset = _RNDDOWN(offset, (off_t)pxp->blksz);
off_t diff = (size_t)(offset - blkoffset);
off_t blkextent = _RNDUP(diff + extent, pxp->blksz);
assert(extent != 0);
assert(extent < X_INT_MAX); /* sanity check */
assert(offset >= 0); /* sanity check */
if(2 * pxp->blksz < blkextent)
return E2BIG; /* TODO: temporary kludge */
if(pxp->bf_offset == OFF_NONE)
{
/* Uninitialized */
if(pxp->bf_base == NULL)
{
assert(pxp->bf_extent == 0);
assert(blkextent <= 2 * pxp->blksz);
pxp->bf_base = malloc(2 * pxp->blksz);
if(pxp->bf_base == NULL)
return ENOMEM;
}
goto pgin;
}
/* else */
assert(blkextent <= 2 * pxp->blksz);
if(blkoffset == pxp->bf_offset)
{
/* hit */
if(blkextent > pxp->bf_extent)
{
/* page in upper */
void *const middle =
(void *)((char *)pxp->bf_base + pxp->blksz);
assert(pxp->bf_extent == pxp->blksz);
status = px_pgin(nciop,
pxp->bf_offset + (off_t)pxp->blksz,
pxp->blksz,
middle,
&pxp->bf_cnt,
&pxp->pos);
if(status != NC_NOERR)
return status;
pxp->bf_extent = 2 * pxp->blksz;
pxp->bf_cnt += pxp->blksz;
}
goto done;
}
/* else */
if(pxp->bf_extent > pxp->blksz
&& blkoffset == pxp->bf_offset + (off_t)pxp->blksz)
{
/* hit in upper half */
if(blkextent == pxp->blksz)
{
/* all in upper half, no fault needed */
diff += pxp->blksz;
goto done;
}
/* else */
if(pxp->bf_cnt > pxp->blksz)
{
/* data in upper half */
void *const middle =
(void *)((char *)pxp->bf_base + pxp->blksz);
assert(pxp->bf_extent == 2 * pxp->blksz);
if(fIsSet(pxp->bf_rflags, RGN_MODIFIED))
{
/* page out lower half */
assert(pxp->bf_refcount <= 0);
status = px_pgout(nciop,
pxp->bf_offset,
pxp->blksz,
pxp->bf_base,
&pxp->pos);
if(status != NC_NOERR)
return status;
}
pxp->bf_cnt -= pxp->blksz;
/* copy upper half into lower half */
(void) memcpy(pxp->bf_base, middle, pxp->bf_cnt);
}
else /* added to fix nofill bug */
{
assert(pxp->bf_extent == 2 * pxp->blksz);
/* still have to page out lower half, if modified */
if(fIsSet(pxp->bf_rflags, RGN_MODIFIED))
{
assert(pxp->bf_refcount <= 0);
status = px_pgout(nciop,
pxp->bf_offset,
pxp->blksz,
pxp->bf_base,
&pxp->pos);
if(status != NC_NOERR)
return status;
}
}
pxp->bf_offset = blkoffset;
/* pxp->bf_extent = pxp->blksz; */
assert(blkextent == 2 * pxp->blksz);
{
/* page in upper */
void *const middle =
(void *)((char *)pxp->bf_base + pxp->blksz);
status = px_pgin(nciop,
pxp->bf_offset + (off_t)pxp->blksz,
pxp->blksz,
middle,
&pxp->bf_cnt,
&pxp->pos);
if(status != NC_NOERR)
return status;
pxp->bf_extent = 2 * pxp->blksz;
pxp->bf_cnt += pxp->blksz;
}
goto done;
}
/* else */
if(blkoffset == pxp->bf_offset - (off_t)pxp->blksz)
{
/* wants the page below */
void *const middle =
(void *)((char *)pxp->bf_base + pxp->blksz);
size_t upper_cnt = 0;
if(pxp->bf_cnt > pxp->blksz)
{
/* data in upper half */
assert(pxp->bf_extent == 2 * pxp->blksz);
if(fIsSet(pxp->bf_rflags, RGN_MODIFIED))
{
/* page out upper half */
assert(pxp->bf_refcount <= 0);
status = px_pgout(nciop,
pxp->bf_offset + (off_t)pxp->blksz,
pxp->bf_cnt - pxp->blksz,
middle,
&pxp->pos);
if(status != NC_NOERR)
return status;
}
pxp->bf_cnt = pxp->blksz;
pxp->bf_extent = pxp->blksz;
}
if(pxp->bf_cnt > 0)
{
/* copy lower half into upper half */
(void) memcpy(middle, pxp->bf_base, pxp->blksz);
upper_cnt = pxp->bf_cnt;
}
/* read page below into lower half */
status = px_pgin(nciop,
blkoffset,
pxp->blksz,
pxp->bf_base,
&pxp->bf_cnt,
&pxp->pos);
if(status != NC_NOERR)
return status;
pxp->bf_offset = blkoffset;
if(upper_cnt != 0)
{
pxp->bf_extent = 2 * pxp->blksz;
pxp->bf_cnt = pxp->blksz + upper_cnt;
}
else
{
pxp->bf_extent = pxp->blksz;
}
goto done;
}
/* else */
/* no overlap */
if(fIsSet(pxp->bf_rflags, RGN_MODIFIED))
{
assert(pxp->bf_refcount <= 0);
status = px_pgout(nciop,
pxp->bf_offset,
pxp->bf_cnt,
pxp->bf_base,
&pxp->pos);
if(status != NC_NOERR)
return status;
pxp->bf_rflags = 0;
}
pgin:
status = px_pgin(nciop,
blkoffset,
blkextent,
pxp->bf_base,
&pxp->bf_cnt,
&pxp->pos);
if(status != NC_NOERR)
return status;
pxp->bf_offset = blkoffset;
pxp->bf_extent = blkextent;
done:
extent += diff;
if(pxp->bf_cnt < extent)
pxp->bf_cnt = extent;
assert(pxp->bf_cnt <= pxp->bf_extent);
pxp->bf_rflags |= rflags;
pxp->bf_refcount++;
*vpp = (void *)((signed char*)pxp->bf_base + diff);
return NC_NOERR;
}
/* Request that the region (offset, extent) be made available through
*vpp.
This function converts a file region specified by an offset and
extent to a memory pointer. The region may be locked until the
corresponding call to rel().
For POSIX systems, without NC_SHARE. This function gets a page of
size extent?
This is a wrapper for the function px_get, which does all the heavy
lifting.
nciop - pointer to ncio struct for this file.
offset - offset (from beginning of file?) to the data we want to
read.
extent - the number of bytes to read from the file.
rflags - One of the RGN_* flags defined in ncio.h.
vpp - handle to point at data when it's been read.
*/
static int
ncio_px_get(ncio *const nciop,
off_t offset, size_t extent,
int rflags,
void **const vpp)
{
ncio_px *const pxp = (ncio_px *)nciop->pvt;
if(fIsSet(rflags, RGN_WRITE) && !fIsSet(nciop->ioflags, NC_WRITE))
return EPERM; /* attempt to write readonly file */
/* reclaim space used in move */
if(pxp->slave != NULL)
{
if(pxp->slave->bf_base != NULL)
{
free(pxp->slave->bf_base);
pxp->slave->bf_base = NULL;
pxp->slave->bf_extent = 0;
pxp->slave->bf_offset = OFF_NONE;
}
free(pxp->slave);
pxp->slave = NULL;
}
return px_get(nciop, pxp, offset, extent, rflags, vpp);
}
/* ARGSUSED */
static int
px_double_buffer(ncio *const nciop, off_t to, off_t from,
size_t nbytes, int rflags)
{
ncio_px *const pxp = (ncio_px *)nciop->pvt;
int status = NC_NOERR;
void *src;
void *dest;
#if INSTRUMENT
fprintf(stderr, "\tdouble_buffr %ld %ld %ld\n",
(long)to, (long)from, (long)nbytes);
#endif
status = px_get(nciop, pxp, to, nbytes, RGN_WRITE,
&dest);
if(status != NC_NOERR)
return status;
if(pxp->slave == NULL)
{
pxp->slave = (ncio_px *) malloc(sizeof(ncio_px));
if(pxp->slave == NULL)
return ENOMEM;
pxp->slave->blksz = pxp->blksz;
/* pos done below */
pxp->slave->bf_offset = pxp->bf_offset;
pxp->slave->bf_extent = pxp->bf_extent;
pxp->slave->bf_cnt = pxp->bf_cnt;
pxp->slave->bf_base = malloc(2 * pxp->blksz);
if(pxp->slave->bf_base == NULL)
return ENOMEM;
(void) memcpy(pxp->slave->bf_base, pxp->bf_base,
pxp->bf_extent);
pxp->slave->bf_rflags = 0;
pxp->slave->bf_refcount = 0;
pxp->slave->slave = NULL;
}
pxp->slave->pos = pxp->pos;
status = px_get(nciop, pxp->slave, from, nbytes, 0,
&src);
if(status != NC_NOERR)
return status;
if(pxp->pos != pxp->slave->pos)
{
/* position changed, sync */
pxp->pos = pxp->slave->pos;
}
(void) memcpy(dest, src, nbytes);
(void)px_rel(pxp->slave, from, 0);
(void)px_rel(pxp, to, RGN_MODIFIED);
return status;
}
/* Like memmove(), safely move possibly overlapping data.
Copy one region to another without making anything available to
higher layers. May be just implemented in terms of get() and rel(),
or may be tricky to be efficient. Only used in by nc_enddef()
after redefinition.
nciop - pointer to ncio struct with file info.
to - src for move?
from - dest for move?
nbytes - number of bytes to move.
rflags - One of the RGN_* flags defined in ncio.h. The only
reasonable flag value is RGN_NOLOCK.
*/
static int
ncio_px_move(ncio *const nciop, off_t to, off_t from,
size_t nbytes, int rflags)
{
ncio_px *const pxp = (ncio_px *)nciop->pvt;
int status = NC_NOERR;
off_t lower;
off_t upper;
char *base;
size_t diff;
size_t extent;
if(to == from)
return NC_NOERR; /* NOOP */
if(fIsSet(rflags, RGN_WRITE) && !fIsSet(nciop->ioflags, NC_WRITE))
return EPERM; /* attempt to write readonly file */
rflags &= RGN_NOLOCK; /* filter unwanted flags */
if(to > from)
{
/* growing */
lower = from;
upper = to;
}
else
{
/* shrinking */
lower = to;
upper = from;
}
diff = (size_t)(upper - lower);
extent = diff + nbytes;
#if INSTRUMENT
fprintf(stderr, "ncio_px_move %ld %ld %ld %ld %ld\n",
(long)to, (long)from, (long)nbytes, (long)lower, (long)extent);
#endif
if(extent > pxp->blksz)
{
size_t remaining = nbytes;
if(to > from)
{
off_t frm = from + nbytes;
off_t toh = to + nbytes;
for(;;)
{
size_t loopextent = MIN(remaining, pxp->blksz);
frm -= loopextent;
toh -= loopextent;
status = px_double_buffer(nciop, toh, frm,
loopextent, rflags) ;
if(status != NC_NOERR)
return status;
remaining -= loopextent;
if(remaining == 0)
break; /* normal loop exit */
}
}
else
{
for(;;)
{
size_t loopextent = MIN(remaining, pxp->blksz);
status = px_double_buffer(nciop, to, from,
loopextent, rflags) ;
if(status != NC_NOERR)
return status;
remaining -= loopextent;
if(remaining == 0)
break; /* normal loop exit */
to += loopextent;
from += loopextent;
}
}
return NC_NOERR;
}
#if INSTRUMENT
fprintf(stderr, "\tncio_px_move small\n");
#endif
status = px_get(nciop, pxp, lower, extent, RGN_WRITE|rflags,
(void **)&base);
if(status != NC_NOERR)
return status;
if(to > from)
(void) memmove(base + diff, base, nbytes);
else
(void) memmove(base, base + diff, nbytes);
(void) px_rel(pxp, lower, RGN_MODIFIED);
return status;
}
/* Flush any buffers to disk. May be a no-op on if I/O is unbuffered.
This function is used when NC_SHARE is NOT used.
*/
static int
ncio_px_sync(ncio *const nciop)
{
ncio_px *const pxp = (ncio_px *)nciop->pvt;
int status = NC_NOERR;
if(fIsSet(pxp->bf_rflags, RGN_MODIFIED))
{
assert(pxp->bf_refcount <= 0);
status = px_pgout(nciop, pxp->bf_offset,
pxp->bf_cnt,
pxp->bf_base, &pxp->pos);
if(status != NC_NOERR)
return status;
pxp->bf_rflags = 0;
}
else if (!fIsSet(pxp->bf_rflags, RGN_WRITE))
{
/*
* The dataset is readonly. Invalidate the buffers so
* that the next ncio_px_get() will actually read data.
*/
pxp->bf_offset = OFF_NONE;
pxp->bf_cnt = 0;
}
return status;
}
/* Internal function called at close to
free up anything hanging off pvt.
*/
static void
ncio_px_freepvt(void *const pvt)
{
ncio_px *const pxp = (ncio_px *)pvt;
if(pxp == NULL)
return;
if(pxp->slave != NULL)
{
if(pxp->slave->bf_base != NULL)
{
free(pxp->slave->bf_base);
pxp->slave->bf_base = NULL;
pxp->slave->bf_extent = 0;
pxp->slave->bf_offset = OFF_NONE;
}
free(pxp->slave);
pxp->slave = NULL;
}
if(pxp->bf_base != NULL)
{
free(pxp->bf_base);
pxp->bf_base = NULL;
pxp->bf_extent = 0;
pxp->bf_offset = OFF_NONE;
}
}
/* This is the second half of the ncio initialization. This is called
after the file has actually been opened.
The most important thing that happens is the allocation of a block
of memory at pxp->bf_base. This is going to be twice the size of
the chunksizehint (rounded up to the nearest sizeof(double)) passed
in from nc__create or nc__open. The rounded chunksizehint (passed
in here in sizehintp) is going to be stored as pxp->blksize.
According to our "contract" we are not allowed to ask for an extent
larger than this chunksize/sizehint/blksize from the ncio get
function.
nciop - pointer to the ncio struct
sizehintp - pointer to a size hint that will be rounded up and
passed back to the caller.
isNew - true if this is being called from ncio_create for a new
file.
*/
static int
ncio_px_init2(ncio *const nciop, size_t *sizehintp, int isNew)
{
ncio_px *const pxp = (ncio_px *)nciop->pvt;
const size_t bufsz = 2 * *sizehintp;
assert(nciop->fd >= 0);
pxp->blksz = *sizehintp;
assert(pxp->bf_base == NULL);
/* this is separate allocation because it may grow */
pxp->bf_base = malloc(bufsz);
if(pxp->bf_base == NULL)
return ENOMEM;
/* else */
pxp->bf_cnt = 0;
if(isNew)
{
/* save a read */
pxp->pos = 0;
pxp->bf_offset = 0;
pxp->bf_extent = bufsz;
(void) memset(pxp->bf_base, 0, pxp->bf_extent);
}
return NC_NOERR;
}
/* This is the first of a two-part initialization of the ncio struct.
Here the rel, get, move, sync, and free function pointers are set
to their POSIX non-NC_SHARE functions (ncio_px_*).
The ncio_px struct is also partially initialized.
*/
static void
ncio_px_init(ncio *const nciop)
{
ncio_px *const pxp = (ncio_px *)nciop->pvt;
*((ncio_relfunc **)&nciop->rel) = ncio_px_rel; /* cast away const */
*((ncio_getfunc **)&nciop->get) = ncio_px_get; /* cast away const */
*((ncio_movefunc **)&nciop->move) = ncio_px_move; /* cast away const */
*((ncio_syncfunc **)&nciop->sync) = ncio_px_sync; /* cast away const */
*((ncio_filesizefunc **)&nciop->filesize) = ncio_px_filesize; /* cast away const */
*((ncio_pad_lengthfunc **)&nciop->pad_length) = ncio_px_pad_length; /* cast away const */
*((ncio_closefunc **)&nciop->close) = ncio_px_close; /* cast away const */
pxp->blksz = 0;
pxp->pos = -1;
pxp->bf_offset = OFF_NONE;
pxp->bf_extent = 0;
pxp->bf_rflags = 0;
pxp->bf_refcount = 0;
pxp->bf_base = NULL;
pxp->slave = NULL;
}
/* Begin spx */
/* This is the struct that gets hung of ncio->pvt(?) when the NC_SHARE
flag is used.
*/
typedef struct ncio_spx {
off_t pos;
/* buffer */
off_t bf_offset;
size_t bf_extent;
size_t bf_cnt;
void *bf_base;
} ncio_spx;
/*ARGSUSED*/
/* This function releases the region specified by offset.
For POSIX system, with NC_SHARE, this becomes the rel function
pointed to by the ncio rel function pointer. It mearly checks for
file write permission, then calls px_rel to do everything.
nciop - pointer to ncio struct.
offset - beginning of region.
rflags - One of the RGN_* flags defined in ncio.h. If set to
RGN_MODIFIED it means that the data in this region were modified,
and it needs to be written out to the disk immediately (since we
are not buffering with NC_SHARE on).
*/
static int
ncio_spx_rel(ncio *const nciop, off_t offset, int rflags)
{
ncio_spx *const pxp = (ncio_spx *)nciop->pvt;
int status = NC_NOERR;
assert(pxp->bf_offset <= offset);
assert(pxp->bf_cnt != 0);
assert(pxp->bf_cnt <= pxp->bf_extent);
#ifdef X_ALIGN
assert(offset < pxp->bf_offset + X_ALIGN);
assert(pxp->bf_cnt % X_ALIGN == 0 );
#endif
if(fIsSet(rflags, RGN_MODIFIED))
{
if(!fIsSet(nciop->ioflags, NC_WRITE))
return EPERM; /* attempt to write readonly file */
status = px_pgout(nciop, pxp->bf_offset,
pxp->bf_cnt,
pxp->bf_base, &pxp->pos);
/* if error, invalidate buffer anyway */
}
pxp->bf_offset = OFF_NONE;
pxp->bf_cnt = 0;
return status;
}
/* Request that the region (offset, extent) be made available through
*vpp.
This function converts a file region specified by an offset and
extent to a memory pointer. The region may be locked until the
corresponding call to rel().
For POSIX systems, with NC_SHARE.
nciop - pointer to ncio struct for this file.
offset - offset (from beginning of file?) to the data we want to
read.
extent - the number of bytes we want.
rflags - One of the RGN_* flags defined in ncio.h. May be RGN_NOLOCK.
vpp - handle to point at data when it's been read.
*/
static int
ncio_spx_get(ncio *const nciop,
off_t offset, size_t extent,
int rflags,
void **const vpp)
{
ncio_spx *const pxp = (ncio_spx *)nciop->pvt;
int status = NC_NOERR;
#ifdef X_ALIGN
size_t rem;
#endif
if(fIsSet(rflags, RGN_WRITE) && !fIsSet(nciop->ioflags, NC_WRITE))
return EPERM; /* attempt to write readonly file */
assert(extent != 0);
assert(extent < X_INT_MAX); /* sanity check */
assert(pxp->bf_cnt == 0);
#ifdef X_ALIGN
rem = (size_t)(offset % X_ALIGN);
if(rem != 0)
{
offset -= rem;
extent += rem;
}
{
const size_t rndup = extent % X_ALIGN;
if(rndup != 0)
extent += X_ALIGN - rndup;
}
assert(offset % X_ALIGN == 0);
assert(extent % X_ALIGN == 0);
#endif
if(pxp->bf_extent < extent)
{
if(pxp->bf_base != NULL)
{
free(pxp->bf_base);
pxp->bf_base = NULL;
pxp->bf_extent = 0;
}
assert(pxp->bf_extent == 0);
pxp->bf_base = malloc(extent+1);
if(pxp->bf_base == NULL)
return ENOMEM;
pxp->bf_extent = extent;
}
status = px_pgin(nciop, offset,
extent,
pxp->bf_base,
&pxp->bf_cnt, &pxp->pos);
if(status != NC_NOERR)
return status;
pxp->bf_offset = offset;
if(pxp->bf_cnt < extent)
pxp->bf_cnt = extent;
#ifdef X_ALIGN
*vpp = (char *)pxp->bf_base + rem;
#else
*vpp = pxp->bf_base;
#endif
return NC_NOERR;
}
#if 0
/*ARGSUSED*/
static int
strategy(ncio *const nciop, off_t to, off_t offset,
size_t extent, int rflags)
{
static ncio_spx pxp[1];
int status = NC_NOERR;
#ifdef X_ALIGN
size_t rem;
#endif
assert(extent != 0);
assert(extent < X_INT_MAX); /* sanity check */
#if INSTRUMENT
fprintf(stderr, "strategy %ld at %ld to %ld\n",
(long)extent, (long)offset, (long)to);
#endif
#ifdef X_ALIGN
rem = (size_t)(offset % X_ALIGN);
if(rem != 0)
{
offset -= rem;
extent += rem;
}
{
const size_t rndup = extent % X_ALIGN;
if(rndup != 0)
extent += X_ALIGN - rndup;
}
assert(offset % X_ALIGN == 0);
assert(extent % X_ALIGN == 0);
#endif
if(pxp->bf_extent < extent)
{
if(pxp->bf_base != NULL)
{
free(pxp->bf_base);
pxp->bf_base = NULL;
pxp->bf_extent = 0;
}
assert(pxp->bf_extent == 0);
pxp->bf_base = malloc(extent);
if(pxp->bf_base == NULL)
return ENOMEM;
pxp->bf_extent = extent;
}
status = px_pgin(nciop, offset,
extent,
pxp->bf_base,
&pxp->bf_cnt, &pxp->pos);
if(status != NC_NOERR)
return status;
pxp->bf_offset = to; /* TODO: XALIGN */
if(pxp->bf_cnt < extent)
pxp->bf_cnt = extent;
status = px_pgout(nciop, pxp->bf_offset,
pxp->bf_cnt,
pxp->bf_base, &pxp->pos);
/* if error, invalidate buffer anyway */
pxp->bf_offset = OFF_NONE;
pxp->bf_cnt = 0;
return status;
}
#endif
/* Copy one region to another without making anything available to
higher layers. May be just implemented in terms of get() and rel(),
or may be tricky to be efficient. Only used in by nc_enddef()
after redefinition.
nciop - pointer to ncio struct for this file.
to - dest for move?
from - src for move?
nbytes - number of bytes to move.
rflags - One of the RGN_* flags defined in ncio.h.
*/
static int
ncio_spx_move(ncio *const nciop, off_t to, off_t from,
size_t nbytes, int rflags)
{
int status = NC_NOERR;
off_t lower = from;
off_t upper = to;
char *base;
size_t diff;
size_t extent;
rflags &= RGN_NOLOCK; /* filter unwanted flags */
if(to == from)
return NC_NOERR; /* NOOP */
if(to > from)
{
/* growing */
lower = from;
upper = to;
}
else
{
/* shrinking */
lower = to;
upper = from;
}
diff = (size_t)(upper - lower);
extent = diff + nbytes;
status = ncio_spx_get(nciop, lower, extent, RGN_WRITE|rflags,
(void **)&base);
if(status != NC_NOERR)
return status;
if(to > from)
(void) memmove(base + diff, base, nbytes);
else
(void) memmove(base, base + diff, nbytes);
(void) ncio_spx_rel(nciop, lower, RGN_MODIFIED);
return status;
}
/*ARGSUSED*/
/* Flush any buffers to disk. May be a no-op on if I/O is unbuffered.
*/
static int
ncio_spx_sync(ncio *const nciop)
{
/* NOOP */
return NC_NOERR;
}
static void
ncio_spx_freepvt(void *const pvt)
{
ncio_spx *const pxp = (ncio_spx *)pvt;
if(pxp == NULL)
return;
if(pxp->bf_base != NULL)
{
free(pxp->bf_base);
pxp->bf_base = NULL;
pxp->bf_offset = OFF_NONE;
pxp->bf_extent = 0;
pxp->bf_cnt = 0;
}
}
/* This does the second half of the ncio_spx struct initialization for
POSIX systems, with NC_SHARE on.
nciop - pointer to ncio struct for this file. File has been opened.
sizehintp - pointer to a size which will be rounded up to the
nearest 8-byt boundary and then used as the max size "chunk" (or
page) to read from the file.
*/
static int
ncio_spx_init2(ncio *const nciop, const size_t *const sizehintp)
{
ncio_spx *const pxp = (ncio_spx *)nciop->pvt;
assert(nciop->fd >= 0);
pxp->bf_extent = *sizehintp;
assert(pxp->bf_base == NULL);
/* this is separate allocation because it may grow */
pxp->bf_base = malloc(pxp->bf_extent);
if(pxp->bf_base == NULL)
{
pxp->bf_extent = 0;
return ENOMEM;
}
/* else */
return NC_NOERR;
}
/* First half of init for ncio_spx struct, setting the rel, get, move,
snyc, and free function pointers to the NC_SHARE versions of these
functions (i.e. the ncio_spx_* functions).
*/
static void
ncio_spx_init(ncio *const nciop)
{
ncio_spx *const pxp = (ncio_spx *)nciop->pvt;
*((ncio_relfunc **)&nciop->rel) = ncio_spx_rel; /* cast away const */
*((ncio_getfunc **)&nciop->get) = ncio_spx_get; /* cast away const */
*((ncio_movefunc **)&nciop->move) = ncio_spx_move; /* cast away const */
*((ncio_syncfunc **)&nciop->sync) = ncio_spx_sync; /* cast away const */
/* shared with _px_ */
*((ncio_filesizefunc **)&nciop->filesize) = ncio_px_filesize; /* cast away const */
*((ncio_pad_lengthfunc **)&nciop->pad_length) = ncio_px_pad_length; /* cast away const */
*((ncio_closefunc **)&nciop->close) = ncio_spx_close; /* cast away const */
pxp->pos = -1;
pxp->bf_offset = OFF_NONE;
pxp->bf_extent = 0;
pxp->bf_cnt = 0;
pxp->bf_base = NULL;
}
/* */
/* This will call whatever free function is attached to the free
function pointer in ncio. It's called from ncio_close, and from
ncio_open and ncio_create when an error occurs that the file
metadata must be freed.
*/
static void
ncio_px_free(ncio *nciop)
{
if(nciop == NULL)
return;
if(nciop->pvt != NULL)
ncio_px_freepvt(nciop->pvt);
free(nciop);
}
static void
ncio_spx_free(ncio *nciop)
{
if(nciop == NULL)
return;
if(nciop->pvt != NULL)
ncio_spx_freepvt(nciop->pvt);
free(nciop);
}
/* Create a new ncio struct to hold info about the file. This will
create and init the ncio_px or ncio_spx struct (the latter if
NC_SHARE is used.)
*/
static ncio *
ncio_px_new(const char *path, int ioflags)
{
size_t sz_ncio = M_RNDUP(sizeof(ncio));
size_t sz_path = M_RNDUP(strlen(path) +1);
size_t sz_ncio_pvt;
ncio *nciop;
#if ALWAYS_NC_SHARE /* DEBUG */
fSet(ioflags, NC_SHARE);
#endif
if(fIsSet(ioflags, NC_SHARE))
sz_ncio_pvt = sizeof(ncio_spx);
else
sz_ncio_pvt = sizeof(ncio_px);
nciop = (ncio *) malloc(sz_ncio + sz_path + sz_ncio_pvt);
if(nciop == NULL)
return NULL;
nciop->ioflags = ioflags;
*((int *)&nciop->fd) = -1; /* cast away const */
nciop->path = (char *) ((char *)nciop + sz_ncio);
(void) strcpy((char *)nciop->path, path); /* cast away const */
/* cast away const */
*((void **)&nciop->pvt) = (void *)(nciop->path + sz_path);
if(fIsSet(ioflags, NC_SHARE))
ncio_spx_init(nciop);
else
ncio_px_init(nciop);
return nciop;
}
/* Public below this point */
#ifndef NCIO_MINBLOCKSIZE
#define NCIO_MINBLOCKSIZE 256
#endif
#ifndef NCIO_MAXBLOCKSIZE
#define NCIO_MAXBLOCKSIZE 268435456 /* sanity check, about X_SIZE_T_MAX/8 */
#endif
#ifdef S_IRUSR
#define NC_DEFAULT_CREAT_MODE \
(S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH) /* 0666 */
#else
#define NC_DEFAULT_CREAT_MODE 0666
#endif
/* Create a file, and the ncio struct to go with it. This function is
only called from nc__create_mp.
path - path of file to create.
ioflags - flags from nc_create
initialsz - From the netcdf man page: "The argument
Iinitialsize sets the initial size of the file at creation time."
igeto -
igetsz -
sizehintp - this eventually goes into pxp->blksz and is the size of
a page of data for buffered reads and writes.
nciopp - pointer to a pointer that will get location of newly
created and inited ncio struct.
igetvpp - pointer to pointer which will get the location of ?
*/
int
posixio_create(const char *path, int ioflags,
size_t initialsz,
off_t igeto, size_t igetsz, size_t *sizehintp,
void* parameters,
ncio **nciopp, void **const igetvpp)
{
ncio *nciop;
int oflags = (O_RDWR|O_CREAT);
int fd;
int status;
if(initialsz < (size_t)igeto + igetsz)
initialsz = (size_t)igeto + igetsz;
fSet(ioflags, NC_WRITE);
if(path == NULL || *path == 0)
return EINVAL;
nciop = ncio_px_new(path, ioflags);
if(nciop == NULL)
return ENOMEM;
if(fIsSet(ioflags, NC_NOCLOBBER))
fSet(oflags, O_EXCL);
else
fSet(oflags, O_TRUNC);
#ifdef O_BINARY
fSet(oflags, O_BINARY);
#endif
#ifdef vms
fd = open(path, oflags, NC_DEFAULT_CREAT_MODE, "ctx=stm");
#else
/* Should we mess with the mode based on NC_SHARE ?? */
fd = open(path, oflags, NC_DEFAULT_CREAT_MODE);
#endif
#if 0
(void) fprintf(stderr, "ncio_create(): path=\"%s\"\n", path);
(void) fprintf(stderr, "ncio_create(): oflags=0x%x\n", oflags);
#endif
if(fd < 0)
{
status = errno;
goto unwind_new;
}
*((int *)&nciop->fd) = fd; /* cast away const */
if(*sizehintp < NCIO_MINBLOCKSIZE)
{
/* Use default */
*sizehintp = blksize(fd);
}
else if(*sizehintp >= NCIO_MAXBLOCKSIZE)
{
/* Use maximum allowed value */
*sizehintp = NCIO_MAXBLOCKSIZE;
}
else
{
*sizehintp = M_RNDUP(*sizehintp);
}
if(fIsSet(nciop->ioflags, NC_SHARE))
status = ncio_spx_init2(nciop, sizehintp);
else
status = ncio_px_init2(nciop, sizehintp, 1);
if(status != NC_NOERR)
goto unwind_open;
if(initialsz != 0)
{
status = fgrow(fd, (off_t)initialsz);
if(status != NC_NOERR)
goto unwind_open;
}
if(igetsz != 0)
{
status = nciop->get(nciop,
igeto, igetsz,
RGN_WRITE,
igetvpp);
if(status != NC_NOERR)
goto unwind_open;
}
*nciopp = nciop;
return NC_NOERR;
unwind_open:
(void) close(fd);
/* ?? unlink */
/*FALLTHRU*/
unwind_new:
ncio_close(nciop,!fIsSet(ioflags, NC_NOCLOBBER));
return status;
}
/* This function opens the data file. It is only called from nc.c,
from nc__open_mp and nc_delete_mp.
path - path of data file.
ioflags - flags passed into nc_open.
igeto - looks like this function can do an initial page get, and
igeto is going to be the offset for that. But it appears to be
unused
igetsz - the size in bytes of initial page get (a.k.a. extent). Not
ever used in the library.
sizehintp - pointer to sizehint parameter from nc__open or
nc__create. This is used to set pxp->blksz.
Here's what the man page has to say:
"The argument referenced by chunksize controls a space versus time
tradeoff, memory allocated in the netcdf library versus number of
system calls.
Because of internal requirements, the value may not be set to
exactly the value requested. The actual value chosen is returned by reference.
Using the value NC_SIZEHINT_DEFAULT causes the library to choose a
default. How the system choses the default depends on the
system. On many systems, the "preferred I/O block size" is
available from the stat() system call, struct stat member
st_blksize. If this is available it is used. Lacking that, twice
the system pagesize is used. Lacking a call to discover the system
pagesize, we just set default chunksize to 8192.
The chunksize is a property of a given open netcdf descriptor ncid,
it is not a persistent property of the netcdf dataset."
nciopp - pointer to pointer that will get address of newly created
and inited ncio struct.
igetvpp - handle to pass back pointer to data from initial page
read, if this were ever used, which it isn't.
*/
int
posixio_open(const char *path,
int ioflags,
off_t igeto, size_t igetsz, size_t *sizehintp,
void* parameters,
ncio **nciopp, void **const igetvpp)
{
ncio *nciop;
int oflags = fIsSet(ioflags, NC_WRITE) ? O_RDWR : O_RDONLY;
int fd = -1;
int status = 0;
if(path == NULL || *path == 0)
return EINVAL;
nciop = ncio_px_new(path, ioflags);
if(nciop == NULL)
return ENOMEM;
#ifdef O_BINARY
/*#if _MSC_VER*/
fSet(oflags, O_BINARY);
#endif
#ifdef vms
fd = open(path, oflags, 0, "ctx=stm");
#else
fd = open(path, oflags, 0);
#endif
if(fd < 0)
{
status = errno;
goto unwind_new;
}
*((int *)&nciop->fd) = fd; /* cast away const */
if(*sizehintp < NCIO_MINBLOCKSIZE)
{
/* Use default */
*sizehintp = blksize(fd);
}
else if(*sizehintp >= NCIO_MAXBLOCKSIZE)
{
/* Use maximum allowed value */
*sizehintp = NCIO_MAXBLOCKSIZE;
}
else
{
*sizehintp = M_RNDUP(*sizehintp);
}
if(fIsSet(nciop->ioflags, NC_SHARE))
status = ncio_spx_init2(nciop, sizehintp);
else
status = ncio_px_init2(nciop, sizehintp, 0);
if(status != NC_NOERR)
goto unwind_open;
if(igetsz != 0)
{
status = nciop->get(nciop,
igeto, igetsz,
0,
igetvpp);
if(status != NC_NOERR)
goto unwind_open;
}
*nciopp = nciop;
return NC_NOERR;
unwind_open:
(void) close(fd); /* assert fd >= 0 */
/*FALLTHRU*/
unwind_new:
ncio_close(nciop,0);
return status;
}
/*
* Get file size in bytes.
*/
static int
ncio_px_filesize(ncio *nciop, off_t *filesizep)
{
/* There is a problem with fstat on Windows based systems
which manifests (so far) when Config RELEASE is built.
Use _filelengthi64 isntead. */
#ifdef HAVE_FILE_LENGTH_I64
__int64 file_len = 0;
if( (file_len = _filelengthi64(nciop->fd)) < 0) {
return errno;
}
*filesizep = file_len;
#else
struct stat sb;
assert(nciop != NULL);
if (fstat(nciop->fd, &sb) < 0)
return errno;
*filesizep = sb.st_size;
#endif
return NC_NOERR;
}
/*
* Sync any changes to disk, then truncate or extend file so its size
* is length. This is only intended to be called before close, if the
* file is open for writing and the actual size does not match the
* calculated size, perhaps as the result of having been previously
* written in NOFILL mode.
*/
static int
ncio_px_pad_length(ncio *nciop, off_t length)
{
int status = NC_NOERR;
if(nciop == NULL)
return EINVAL;
if(!fIsSet(nciop->ioflags, NC_WRITE))
return EPERM; /* attempt to write readonly file */
status = nciop->sync(nciop);
if(status != NC_NOERR)
return status;
status = fgrow2(nciop->fd, length);
if(status != NC_NOERR)
return status;
return NC_NOERR;
}
/* Write out any dirty buffers to disk and
ensure that next read will get data from disk.
Sync any changes, then close the open file associated with the ncio
struct, and free its memory.
nciop - pointer to ncio to close.
doUnlink - if true, unlink file
*/
static int
ncio_px_close(ncio *nciop, int doUnlink)
{
int status = NC_NOERR;
if(nciop == NULL)
return EINVAL;
if(nciop->fd > 0) {
status = nciop->sync(nciop);
(void) close(nciop->fd);
}
if(doUnlink)
(void) unlink(nciop->path);
ncio_px_free(nciop);
return status;
}
static int
ncio_spx_close(ncio *nciop, int doUnlink)
{
int status = NC_NOERR;
if(nciop == NULL)
return EINVAL;
if(nciop->fd > 0) {
status = nciop->sync(nciop);
(void) close(nciop->fd);
}
if(doUnlink)
(void) unlink(nciop->path);
ncio_spx_free(nciop);
return status;
}