ncdf4a13/libsrc/posixio.c File Reference

#include <config.h>
#include <assert.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include "ncio.h"
#include "fbits.h"
#include "rnd.h"

Include dependency graph for posixio.c:

Go to the source code of this file.

Classes
struct	ncio_px
struct	ncio_spx
Defines
#define	ENOERR   0
#define	SEEK_SET   0
#define	SEEK_CUR   1
#define	SEEK_END   2
#define	MIN(mm, nn)   (((mm) < (nn)) ? (mm) : (nn))
#define	X_INT_MAX   2147483647
#define	POSIXIO_DEFAULT_PAGESIZE   4096
#define	NCIO_MINBLOCKSIZE   256
#define	NCIO_MAXBLOCKSIZE   268435456
#define	NC_DEFAULT_CREAT_MODE   0666
Typedefs
typedef ncio_px	ncio_px
typedef ncio_spx	ncio_spx
Functions
static size_t	pagesize (void)
static size_t	blksize (int fd)
static int	fgrow (const int fd, const off_t len)
static int	fgrow2 (const int fd, const off_t len)
static int	px_pgout (ncio *const nciop, off_t const offset, const size_t extent, void *const vp, off_t *posp)
static int	px_pgin (ncio *const nciop, off_t const offset, const size_t extent, void *const vp, size_t *nreadp, off_t *posp)
static int	px_rel (ncio_px *const pxp, off_t offset, int rflags)
static int	ncio_px_rel (ncio *const nciop, off_t offset, int rflags)
static int	px_get (ncio *const nciop, ncio_px *const pxp, off_t offset, size_t extent, int rflags, void **const vpp)
static int	ncio_px_get (ncio *const nciop, off_t offset, size_t extent, int rflags, void **const vpp)
static int	px_double_buffer (ncio *const nciop, off_t to, off_t from, size_t nbytes, int rflags)
static int	ncio_px_move (ncio *const nciop, off_t to, off_t from, size_t nbytes, int rflags)
static int	ncio_px_sync (ncio *const nciop)
static void	ncio_px_free (void *const pvt)
static int	ncio_px_init2 (ncio *const nciop, size_t *sizehintp, int isNew)
static void	ncio_px_init (ncio *const nciop)
static int	ncio_spx_rel (ncio *const nciop, off_t offset, int rflags)
static int	ncio_spx_get (ncio *const nciop, off_t offset, size_t extent, int rflags, void **const vpp)
static int	ncio_spx_move (ncio *const nciop, off_t to, off_t from, size_t nbytes, int rflags)
static int	ncio_spx_sync (ncio *const nciop)
static void	ncio_spx_free (void *const pvt)
static int	ncio_spx_init2 (ncio *const nciop, const size_t *const sizehintp)
static void	ncio_spx_init (ncio *const nciop)
static void	ncio_free (ncio *nciop)
static ncio *	ncio_new (const char *path, int ioflags)
int	ncio_create (const char *path, int ioflags, size_t initialsz, off_t igeto, size_t igetsz, size_t *sizehintp, ncio **nciopp, void **const igetvpp)
int	ncio_open (const char *path, int ioflags, off_t igeto, size_t igetsz, size_t *sizehintp, ncio **nciopp, void **const igetvpp)
int	ncio_filesize (ncio *nciop, off_t *filesizep)
int	ncio_pad_length (ncio *nciop, off_t length)
int	ncio_close (ncio *nciop, int doUnlink)

---

Define Documentation

#define ENOERR   0

Definition at line 12 of file posixio.c.

#define MIN (  mm, nn   )     (((mm) < (nn)) ? (mm) : (nn))

Definition at line 42 of file posixio.c. Referenced by fill_NC_var(), getNCvx_char_char(), getNCvx_double_double(), getNCvx_double_float(), getNCvx_double_int(), getNCvx_double_long(), getNCvx_double_schar(), getNCvx_double_short(), getNCvx_double_uchar(), getNCvx_float_double(), getNCvx_float_float(), getNCvx_float_int(), getNCvx_float_long(), getNCvx_float_schar(), getNCvx_float_short(), getNCvx_float_uchar(), getNCvx_int_double(), getNCvx_int_float(), getNCvx_int_int(), getNCvx_int_long(), getNCvx_int_schar(), getNCvx_int_short(), getNCvx_int_uchar(), getNCvx_schar_double(), getNCvx_schar_float(), getNCvx_schar_int(), getNCvx_schar_long(), getNCvx_schar_schar(), getNCvx_schar_short(), getNCvx_schar_uchar(), getNCvx_short_double(), getNCvx_short_float(), getNCvx_short_int(), getNCvx_short_long(), getNCvx_short_schar(), getNCvx_short_short(), getNCvx_short_uchar(), hash_double(), hash_float(), hash_int(), hash_long(), hash_schar(), hash_short(), hash_text(), hash_uchar(), ncio_px_move(), NCxvarcpy(), putNCvx_char_char(), putNCvx_double_double(), putNCvx_double_float(), putNCvx_double_int(), putNCvx_double_long(), putNCvx_double_schar(), putNCvx_double_short(), putNCvx_double_uchar(), putNCvx_float_double(), putNCvx_float_float(), putNCvx_float_int(), putNCvx_float_long(), putNCvx_float_schar(), putNCvx_float_short(), putNCvx_float_uchar(), putNCvx_int_double(), putNCvx_int_float(), putNCvx_int_int(), putNCvx_int_long(), putNCvx_int_schar(), putNCvx_int_short(), putNCvx_int_uchar(), putNCvx_schar_double(), putNCvx_schar_float(), putNCvx_schar_int(), putNCvx_schar_long(), putNCvx_schar_schar(), putNCvx_schar_short(), putNCvx_schar_uchar(), putNCvx_short_double(), putNCvx_short_float(), putNCvx_short_int(), putNCvx_short_long(), putNCvx_short_schar(), putNCvx_short_short(), putNCvx_short_uchar(), v1h_get_NC_attrV(), and v1h_put_NC_attrV().

#define NC_DEFAULT_CREAT_MODE   0666

Definition at line 1398 of file posixio.c. Referenced by ncio_create().

#define NCIO_MAXBLOCKSIZE   268435456

Definition at line 1391 of file posixio.c. Referenced by ncio_create(), and ncio_open().

#define NCIO_MINBLOCKSIZE   256

Definition at line 1390 of file posixio.c.

#define POSIXIO_DEFAULT_PAGESIZE   4096

Definition at line 62 of file posixio.c. Referenced by pagesize().

#define SEEK_CUR   1

Definition at line 26 of file posixio.c. Referenced by fgrow(), fgrow2(), px_pgin(), and px_pgout().

#define SEEK_END   2

Definition at line 27 of file posixio.c.

#define SEEK_SET   0

Definition at line 25 of file posixio.c. Referenced by fgrow(), fgrow2(), px_pgin(), and px_pgout().

#define X_INT_MAX   2147483647

Definition at line 45 of file posixio.c.

---

Typedef Documentation

typedef struct ncio_px ncio_px

typedef struct ncio_spx ncio_spx

---

Function Documentation

static size_t blksize (  int  fd  )  [static]

Definition at line 92 of file posixio.c. References pagesize(). Referenced by ncio_create(), and ncio_open(). { #if defined(HAVE_ST_BLKSIZE) 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 return (size_t) 2 * pagesize(); }

static int fgrow (  const int  fd, const off_t  len )  [static]

Definition at line 113 of file posixio.c. References ENOERR, SEEK_CUR, and SEEK_SET. Referenced by ncio_create(). { struct stat sb; if (fstat(fd, &sb) < 0) return errno; if (len < sb.st_size) return ENOERR; { 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 ENOERR; }

static int fgrow2 (  const int  fd, const off_t  len )  [static]

Definition at line 144 of file posixio.c. References ENOERR, SEEK_CUR, and SEEK_SET. Referenced by ncio_pad_length(). { struct stat sb; if (fstat(fd, &sb) < 0) return errno; if (len <= sb.st_size) return ENOERR; { 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 ENOERR; }

int ncio_close (  ncio *  nciop, int  doUnlink )

Definition at line 1681 of file posixio.c. References ENOERR, ncio::fd, ncio_free(), ncio::path, and ncio::sync. Referenced by nc__create_mp(), nc__open_mp(), nc_abort(), nc_close(), and nc_delete_mp(). { int status = ENOERR; if(nciop == NULL) return EINVAL; status = nciop->sync(nciop); (void) close(nciop->fd); if(doUnlink) (void) unlink(nciop->path); ncio_free(nciop); return status; }

int ncio_create (  const char *  path, int  ioflags, size_t  initialsz, off_t  igeto, size_t  igetsz, size_t *  sizehintp, ncio **  nciopp, void **const   igetvpp )

Definition at line 1417 of file posixio.c. References blksize(), ENOERR, ncio::fd, fgrow(), fIsSet, fSet, ncio::get, ncio::ioflags, M_RNDUP, NC_DEFAULT_CREAT_MODE, NC_NOCLOBBER, NC_SHARE, NC_WRITE, ncio_free(), NCIO_MAXBLOCKSIZE, ncio_new(), ncio_px_init2(), ncio_spx_init2(), and RGN_WRITE. Referenced by nc__create_mp(). { 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_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 || *sizehintp > NCIO_MAXBLOCKSIZE) { /* Use default */ *sizehintp = blksize(fd); } 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 != ENOERR) goto unwind_open; if(initialsz != 0) { status = fgrow(fd, (off_t)initialsz); if(status != ENOERR) goto unwind_open; } if(igetsz != 0) { status = nciop->get(nciop, igeto, igetsz, RGN_WRITE, igetvpp); if(status != ENOERR) goto unwind_open; } *nciopp = nciop; return ENOERR; unwind_open: (void) close(fd); /* ?? unlink */ /*FALLTHRU*/ unwind_new: ncio_free(nciop); return status; }

int ncio_filesize (  ncio *  nciop, off_t *  filesizep )

Definition at line 1630 of file posixio.c. References ENOERR, and ncio::fd. Referenced by nc_close(), and nc_get_NC(). { struct stat sb; assert(nciop != NULL); if (fstat(nciop->fd, &sb) < 0) return errno; *filesizep = sb.st_size; return ENOERR; }

static void ncio_free (  ncio *  nciop  )  [static]

Definition at line 1333 of file posixio.c. References ncio::free, and ncio::pvt. Referenced by ncio_close(), ncio_create(), and ncio_open(). { if(nciop == NULL) return; if(nciop->free != NULL) nciop->free(nciop->pvt); free(nciop); }

static ncio* ncio_new (  const char *  path, int  ioflags )  [static]

Definition at line 1350 of file posixio.c. References ncio::fd, fIsSet, fSet, ncio::ioflags, M_RNDUP, NC_SHARE, ncio_px_init(), ncio_spx_init(), ncio::path, and ncio::pvt. Referenced by ncio_create(), and ncio_open(). { 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; }

int ncio_open (  const char *  path, int  ioflags, off_t  igeto, size_t  igetsz, size_t *  sizehintp, ncio **  nciopp, void **const   igetvpp )

Definition at line 1555 of file posixio.c. References blksize(), ENOERR, ncio::fd, fIsSet, fSet, ncio::get, ncio::ioflags, M_RNDUP, NC_SHARE, NC_WRITE, ncio_free(), NCIO_MAXBLOCKSIZE, ncio_new(), ncio_px_init2(), and ncio_spx_init2(). Referenced by nc__open_mp(), and nc_delete_mp(). { ncio *nciop; int oflags = fIsSet(ioflags, NC_WRITE) ? O_RDWR : O_RDONLY; int fd; int status; if(path == NULL || *path == 0) return EINVAL; nciop = ncio_new(path, ioflags); if(nciop == NULL) return ENOMEM; #ifdef O_BINARY 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 || *sizehintp > NCIO_MAXBLOCKSIZE) { /* Use default */ *sizehintp = blksize(fd); } 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 != ENOERR) goto unwind_open; if(igetsz != 0) { status = nciop->get(nciop, igeto, igetsz, 0, igetvpp); if(status != ENOERR) goto unwind_open; } *nciopp = nciop; return ENOERR; unwind_open: (void) close(fd); /*FALLTHRU*/ unwind_new: ncio_free(nciop); return status; }

int ncio_pad_length (  ncio *  nciop, off_t  length )

Definition at line 1649 of file posixio.c. References ENOERR, ncio::fd, fgrow2(), fIsSet, ncio::ioflags, NC_NOERR, NC_WRITE, and ncio::sync. Referenced by nc_close(). { int status = ENOERR; if(nciop == NULL) return EINVAL; if(!fIsSet(nciop->ioflags, NC_WRITE)) return EPERM; /* attempt to write readonly file */ status = nciop->sync(nciop); if(status != ENOERR) return status; status = fgrow2(nciop->fd, length); if(status != NC_NOERR) return status; return ENOERR; }

static void ncio_px_free (  void *const   pvt  )  [static]

Definition at line 850 of file posixio.c. References ncio_px::bf_base, ncio_px::bf_extent, ncio_px::bf_offset, OFF_NONE, and ncio_px::slave. Referenced by ncio_px_init(). { 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; } }

static int ncio_px_get (  ncio *const   nciop, off_t  offset, size_t  extent, int  rflags, void **const   vpp )  [static]

Definition at line 612 of file posixio.c. References ncio_px::bf_base, ncio_px::bf_extent, ncio_px::bf_offset, fIsSet, ncio::ioflags, NC_WRITE, OFF_NONE, ncio::pvt, px_get(), RGN_WRITE, and ncio_px::slave. Referenced by ncio_px_init(). { 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); }

static void ncio_px_init (  ncio *const   nciop  )  [static]

Definition at line 935 of file posixio.c. References ncio_px::bf_base, ncio_px::bf_extent, ncio_px::bf_offset, ncio_px::bf_refcount, ncio_px::bf_rflags, ncio_px::blksz, ncio::free, ncio::get, ncio::move, ncio_px_free(), ncio_px_get(), ncio_px_move(), ncio_px_rel(), ncio_px_sync(), OFF_NONE, ncio_px::pos, ncio::pvt, ncio::rel, ncio_px::slave, and ncio::sync. Referenced by ncio_new(). { 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_freefunc **)&nciop->free) = ncio_px_free; /* 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; }

static int ncio_px_init2 (  ncio *const   nciop, size_t *  sizehintp, int  isNew )  [static]

Definition at line 899 of file posixio.c. References ncio_px::bf_base, ncio_px::bf_cnt, ncio_px::bf_extent, ncio_px::bf_offset, ncio_px::blksz, ENOERR, ncio::fd, ncio_px::pos, and ncio::pvt. Referenced by ncio_create(), and ncio_open(). { 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 ENOERR; }

static int ncio_px_move (  ncio *const   nciop, off_t  to, off_t  from, size_t  nbytes, int  rflags )  [static]

Definition at line 713 of file posixio.c. References ncio_px::blksz, ENOERR, fIsSet, ncio::ioflags, MIN, NC_WRITE, ncio::pvt, px_double_buffer(), px_get(), px_rel(), RGN_MODIFIED, RGN_NOLOCK, and RGN_WRITE. Referenced by ncio_px_init(). { ncio_px *const pxp = (ncio_px *)nciop->pvt; int status = ENOERR; off_t lower; off_t upper; char *base; size_t diff; size_t extent; if(to == from) return ENOERR; /* 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 != ENOERR) 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 != ENOERR) return status; remaining -= loopextent; if(remaining == 0) break; /* normal loop exit */ to += loopextent; from += loopextent; } } return ENOERR; } #if INSTRUMENT fprintf(stderr, "\tncio_px_move small\n"); #endif status = px_get(nciop, pxp, lower, extent, RGN_WRITE|rflags, (void **)&base); if(status != ENOERR) 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; }

static int ncio_px_rel (  ncio *const   nciop, off_t  offset, int  rflags )  [static]

Definition at line 339 of file posixio.c. References fIsSet, ncio::ioflags, NC_WRITE, ncio::pvt, px_rel(), and RGN_MODIFIED. Referenced by ncio_px_init(). { 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); }

static int ncio_px_sync (  ncio *const   nciop  )  [static]

Definition at line 820 of file posixio.c. References ncio_px::bf_base, ncio_px::bf_cnt, ncio_px::bf_offset, ncio_px::bf_refcount, ncio_px::bf_rflags, ENOERR, fIsSet, OFF_NONE, ncio_px::pos, ncio::pvt, px_pgout(), RGN_MODIFIED, and RGN_WRITE. Referenced by ncio_px_init(). { ncio_px *const pxp = (ncio_px *)nciop->pvt; int status = ENOERR; 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 != ENOERR) 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; }

static void ncio_spx_free (  void *const   pvt  )  [static]

Definition at line 1254 of file posixio.c. References ncio_spx::bf_base, ncio_spx::bf_cnt, ncio_spx::bf_extent, ncio_spx::bf_offset, and OFF_NONE. Referenced by ncio_spx_init(). { 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; } }

static int ncio_spx_get (  ncio *const   nciop, off_t  offset, size_t  extent, int  rflags, void **const   vpp )  [static]

Definition at line 1035 of file posixio.c. References ncio_spx::bf_base, ncio_spx::bf_cnt, ncio_spx::bf_extent, ncio_spx::bf_offset, ENOERR, fIsSet, ncio::ioflags, NC_WRITE, ncio_spx::pos, ncio::pvt, px_pgin(), RGN_WRITE, X_ALIGN, and X_INT_MAX. Referenced by ncio_spx_init(), and ncio_spx_move(). { ncio_spx *const pxp = (ncio_spx *)nciop->pvt; int status = ENOERR; #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); 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 != ENOERR) 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 ENOERR; }

static void ncio_spx_init (  ncio *const   nciop  )  [static]

Definition at line 1307 of file posixio.c. References ncio_spx::bf_base, ncio_spx::bf_cnt, ncio_spx::bf_extent, ncio_spx::bf_offset, ncio::free, ncio::get, ncio::move, ncio_spx_free(), ncio_spx_get(), ncio_spx_move(), ncio_spx_rel(), ncio_spx_sync(), OFF_NONE, ncio_spx::pos, ncio::pvt, ncio::rel, and ncio::sync. Referenced by ncio_new(). { 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 */ *((ncio_freefunc **)&nciop->free) = ncio_spx_free; /* cast away const */ pxp->pos = -1; pxp->bf_offset = OFF_NONE; pxp->bf_extent = 0; pxp->bf_cnt = 0; pxp->bf_base = NULL; }

static int ncio_spx_init2 (  ncio *const   nciop, const size_t *const   sizehintp )  [static]

Definition at line 1280 of file posixio.c. References ncio_spx::bf_base, ncio_spx::bf_extent, ENOERR, ncio::fd, and ncio::pvt. Referenced by ncio_create(), and ncio_open(). { 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 ENOERR; }

static int ncio_spx_move (  ncio *const   nciop, off_t  to, off_t  from, size_t  nbytes, int  rflags )  [static]

Definition at line 1195 of file posixio.c. References ENOERR, ncio_spx_get(), ncio_spx_rel(), RGN_MODIFIED, RGN_NOLOCK, and RGN_WRITE. Referenced by ncio_spx_init(). { int status = ENOERR; off_t lower = from; off_t upper = to; char *base; size_t diff = (size_t)(upper - lower); size_t extent = diff + nbytes; rflags &= RGN_NOLOCK; /* filter unwanted flags */ if(to == from) return ENOERR; /* 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 != ENOERR) 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; }

static int ncio_spx_rel (  ncio *const   nciop, off_t  offset, int  rflags )  [static]

Definition at line 989 of file posixio.c. References ncio_spx::bf_base, ncio_spx::bf_cnt, ncio_spx::bf_extent, ncio_spx::bf_offset, ENOERR, fIsSet, ncio::ioflags, NC_WRITE, OFF_NONE, ncio_spx::pos, ncio::pvt, px_pgout(), RGN_MODIFIED, and X_ALIGN. Referenced by ncio_spx_init(), and ncio_spx_move(). { ncio_spx *const pxp = (ncio_spx *)nciop->pvt; int status = ENOERR; 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; }

static int ncio_spx_sync (  ncio *const   nciop  )  [static]

Definition at line 1247 of file posixio.c. References ENOERR. Referenced by ncio_spx_init(). { /* NOOP */ return ENOERR; }

static size_t pagesize (  void   )  [static]

Definition at line 68 of file posixio.c. References POSIXIO_DEFAULT_PAGESIZE. Referenced by blksize(). { /* Hmm, aren't standards great? */ #if defined(_SC_PAGE_SIZE) && !defined(_SC_PAGESIZE) #define _SC_PAGESIZE _SC_PAGE_SIZE #endif #ifdef _SC_PAGESIZE { const long pgsz = sysconf(_SC_PAGESIZE); if(pgsz > 0) return (size_t) pgsz; /* else, silent in the face of error */ } #elif defined(HAVE_GETPAGESIZE) return (size_t) getpagesize(); #endif return (size_t) POSIXIO_DEFAULT_PAGESIZE; }

static int px_double_buffer (  ncio *const   nciop, off_t  to, off_t  from, size_t  nbytes, int  rflags )  [static]

Definition at line 641 of file posixio.c. References ncio_px::bf_base, ncio_px::bf_cnt, ncio_px::bf_extent, ncio_px::bf_offset, ncio_px::bf_refcount, ncio_px::bf_rflags, ncio_px::blksz, ENOERR, ncio_px::pos, ncio::pvt, px_get(), px_rel(), RGN_MODIFIED, RGN_WRITE, and ncio_px::slave. Referenced by ncio_px_move(). { ncio_px *const pxp = (ncio_px *)nciop->pvt; int status = ENOERR; 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 != ENOERR) 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 != ENOERR) 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; }

static int px_get (  ncio *const   nciop, ncio_px *const   pxp, off_t  offset, size_t  extent, int  rflags, void **const   vpp )  [static]

Definition at line 385 of file posixio.c. References _RNDDOWN, _RNDUP, ncio_px::bf_base, ncio_px::bf_cnt, ncio_px::bf_extent, ncio_px::bf_offset, ncio_px::bf_refcount, ncio_px::bf_rflags, ncio_px::blksz, ENOERR, fIsSet, OFF_NONE, ncio_px::pos, px_pgin(), px_pgout(), RGN_MODIFIED, and X_INT_MAX. Referenced by ncio_px_get(), ncio_px_move(), and px_double_buffer(). { int status = ENOERR; const off_t blkoffset = _RNDDOWN(offset, (off_t)pxp->blksz); size_t diff = (size_t)(offset - blkoffset); size_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 != ENOERR) 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 != ENOERR) return status; } pxp->bf_cnt -= pxp->blksz; /* copy upper half into lower half */ (void) memcpy(pxp->bf_base, middle, pxp->bf_cnt); } 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 != ENOERR) 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 != ENOERR) 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 != ENOERR) 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 != ENOERR) return status; pxp->bf_rflags = 0; } pgin: status = px_pgin(nciop, blkoffset, blkextent, pxp->bf_base, &pxp->bf_cnt, &pxp->pos); if(status != ENOERR) 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 = (char *)pxp->bf_base + diff; return ENOERR; }

static int px_pgin (  ncio *const   nciop, off_t const   offset, const size_t  extent, void *const   vp, size_t *  nreadp, off_t *  posp )  [static]

Definition at line 220 of file posixio.c. References ENOERR, ncio::fd, OFF_NONE, SEEK_CUR, SEEK_SET, and X_ALIGN. Referenced by ncio_spx_get(), and px_get(). { int status; ssize_t nread; #ifdef X_ALIGN assert(offset % X_ALIGN == 0); assert(extent % 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) { status = errno; return status; } *posp = offset; } errno = 0; nread = read(nciop->fd, vp, extent); if(nread != (ssize_t) extent) { status = errno; if(nread == -1 || status != ENOERR) 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 ENOERR; }

static int px_pgout (  ncio *const   nciop, off_t const   offset, const size_t  extent, void *const   vp, off_t *  posp )  [static]

Definition at line 183 of file posixio.c. References ENOERR, ncio::fd, OFF_NONE, SEEK_CUR, SEEK_SET, and X_ALIGN. Referenced by ncio_px_sync(), ncio_spx_rel(), and px_get(). { #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; } if(write(nciop->fd, vp, extent) != (ssize_t) extent) { return errno; } *posp += extent; return ENOERR; }

static int px_rel (  ncio_px *const   pxp, off_t  offset, int  rflags )  [static]

Definition at line 306 of file posixio.c. References ncio_px::bf_extent, ncio_px::bf_offset, ncio_px::bf_refcount, ncio_px::bf_rflags, ENOERR, fIsSet, fSet, pIf, RGN_MODIFIED, and RGN_WRITE. Referenced by ncio_px_move(), ncio_px_rel(), and px_double_buffer(). { 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 ENOERR; }

---