OpenSolaris_b135/lib/libpkg/common/vfpops.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Module: vfpops.c
* Synopsis: Implements virtual file protocol operations
* Description:
*
* This module implements the "Virtual File protocol" operations. These
* operations are intended to provide very fast access to file data,
* allowing a file to be accessed in very efficient ways with extremely
* low-cpu intensive operations. If possible file data is mapped directly
* into memory allowing the data to be accessed directly. If the data
* cannot be mapped directly into memory, memory will be allocated and
* the file data read directly into memory. If that fails currently the
* file data is not accessible. Other methods of making the file could
* be implemented in the future (e.g. stdio if all else fails).
*
* In general any code that uses stdio to access a file can be changed
* to use the various "vfp" operations to access a file, with a resulting
* increase in performance and decrease in cpu time required to access
* the file contents.
*
* Public Methods:
*
* vfpCheckpointFile - Create new VFP that checkpoints existing VFP
* vfpCheckpointOpen - open file, allocate storage, return pointer to VFP_T
* vfpClose - close file associated with vfp
* vfpDecCurrPtr - decrement current character pointer
* vfpGetBytesRemaining - get number of bytes remaining to read
* vfpGetCurrCharPtr - get pointer to current character
* vfpGetCurrPtrDelta - get number of bytes between current and specified char
* vfpGetFirstCharPtr - get pointer to first character
* vfpGetLastCharPtr - get pointer to last character
* vfpGetModifiedLen - get highest modified byte (length) contained in vfp
* vfpGetPath - get the path associated with the vfp
* vfpGetc - get current character and increment to next
* vfpGetcNoInc - get current character - do not increment
* vfpGets - get a string from the vfp into a fixed size buffer
* vfpIncCurrPtr - increment current character pointer
* vfpIncCurrPtrBy - increment current pointer by specified delta
* vfpOpen - open file on vfp
* vfpPutBytes - put fixed number of bytes to current character and increment
* vfpPutFormat - put format one arg to current character and increment
* vfpPutInteger - put integer to current character and increment
* vfpPutLong - put long to current character and increment
* vfpPutc - put current character and increment to next
* vfpPuts - put string to current character and increment
* vfpRewind - rewind file to first byte
* vfpSeekToEnd - seek to end of file
* vfpSetCurrCharPtr - set pointer to current character
* vfpSetFlags - set flags that affect file access
* vfpSetSize - set size of file (for writing)
* vfpTruncate - truncate file
* vfpWriteToFile - write data contained in vfp to specified file
*/
#include <stdio.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <ctype.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <errno.h>
#include <libintl.h>
#include "pkglib.h"
#include "pkgstrct.h"
#include "pkglocale.h"
/*
* These are internal flags that occupy the high order byte of the VFPFLAGS_T
* flags element of the vfp. These flags may only occupy the high order order
* 16 bits of the 32-bit unsigned vfp "flags" object.
*/
#define _VFP_MMAP 0x00010000 /* mmap used */
#define _VFP_MALLOC 0x00020000 /* malloc used */
#define _VFP_WRITE 0x00040000 /* file opened for write */
#define _VFP_READ 0x00080000 /* file opened for reading */
#define _VFP_MODIFIED 0x00100000 /* contents are marked modified */
/* path name given to "anonymous" (string) vfp */
#define VFP_ANONYMOUS_PATH "<<string>>"
/* minimum size file to mmap (64mb) */
#define MIN_MMAP_SIZE (64*1024)
/*
* *****************************************************************************
* global external (public) functions
* *****************************************************************************
*/
/*
* Name: vfpOpen
* Description: Open file on vfp, allocate storage, return pointer to VFP_T
* that can be used to access/modify file contents.
* Arguments: VFP_T **r_vfp - pointer to pointer to VFP_T
* char *a_path - path of file to open and associate with this VFP.
* - if the path is (char *)NULL then no file is associated
* with this VFP - this is a way to create a fixed length
* string that can be manipulated with the VFP operators.
* Before the VFP can be used "vfpSetSize" must be called
* to set the size of the string buffer.
* char *a_mode - fopen mode to open the file with
* VFPFLAGS_T a_flags - one or more flags to control the operation:
* - VFP_NONE - no special flags
* - VFP_NEEDNOW - file data needed in memory now
* - VFP_SEQUENTIAL - memory will be sequentially accessed
* - VFP_RANDOM - memory will be randomly accessed
* - VFP_NOMMAP - do not use mmap to access file
* - VFP_NOMALLOC - do not use malloc to buffer file
* Returns: int == 0 - operation was successful
* != 0 - operation failed, errno contains reason
* Side Effects: r_vfp -- filled in with a pointer to a newly allocated vfp
* which can be used with the various vfp functions.
* errno -- contains system error number if return is != 0
*/
int
vfpOpen(VFP_T **r_vfp, char *a_path, char *a_mode, VFPFLAGS_T a_flags)
{
FILE *fp = (FILE *)NULL;
VFP_T *vfp;
int lerrno;
struct stat statbuf;
int pagesize = getpagesize();
/* reset return VFP/FILE pointers */
(*r_vfp) = (VFP_T *)NULL;
/* allocate pre-zeroed vfp object */
vfp = (VFP_T *)calloc(sizeof (VFP_T), 1);
if (vfp == (VFP_T *)NULL) {
return (-1);
}
/* create "string" vfp if no path specified */
if (a_path == (char *)NULL) {
/*
* no path specified - no open file associated with vfp
* The vfp is initialized to all zeros - initialize just those
* values that need to be non-zero.
*/
vfp->_vfpFlags = _VFP_MALLOC;
vfp->_vfpPath = strdup(VFP_ANONYMOUS_PATH);
(*r_vfp) = vfp;
return (0);
}
/*
* path specified - associate open file with vfp;
* return an error if no path or mode specified
*/
if (a_mode == (char *)NULL) {
errno = EFAULT; /* Bad address */
(void) free(vfp);
return (-1);
}
/* return an error if an empty path or mode specified */
if ((*a_path == '\0') || (*a_mode == '\0')) {
errno = EINVAL; /* Invalid argument */
(void) free(vfp);
return (-1);
}
/* open the file */
fp = fopen(a_path, a_mode);
if (fp == (FILE *)NULL) {
lerrno = errno;
(void) free(vfp);
errno = lerrno;
return (-1);
}
/* Get the file size */
if (fstat(fileno(fp), &statbuf) != 0) {
lerrno = errno;
(void) fclose(fp);
(void) free(vfp);
errno = lerrno;
return (-1);
}
/*
* Obtain access to existing file contents:
* -> plan a: map contents file into memory
* -> plan b: on failure just read into large buffer
*/
/* attempt to mmap file if mmap is allowed */
vfp->_vfpStart = MAP_FAILED; /* assume map failed if not allowed */
/*
* if file is a regular file, and if mmap allowed,
* and (malloc not forbidden or size is > minumum size to mmap)
*/
if ((S_ISREG(statbuf.st_mode)) && (!(a_flags & VFP_NOMMAP)) &&
((a_flags & VFP_NOMALLOC) || statbuf.st_size > MIN_MMAP_SIZE)) {
char *p;
/* set size to current size of file */
vfp->_vfpMapSize = statbuf.st_size;
/*
* compute proper size for mapping for the file contents;
* add in one extra page so falling off end when file size is
* exactly modulo page size does not cause a page fault to
* guarantee that the end of the file contents will always
* contain a '\0' null character.
*/
vfp->_vfpSize = (statbuf.st_size + pagesize +
(pagesize-(statbuf.st_size % pagesize)));
/*
* mmap allowed: mmap file into memory
* first allocate space on top of which the mapping can be done;
* this way we can guarantee that if the mapping happens to be
* an exact multiple of a page size, that there will be at least
* one byte past the end of the mapping that can be accessed and
* that is guaranteed to be zero.
*/
/* allocate backing space */
p = (char *)memalign(pagesize, vfp->_vfpSize);
if (p == (char *)NULL) {
vfp->_vfpStart = MAP_FAILED;
} else {
/* guarantee first byte after end of data is zero */
p[vfp->_vfpMapSize] = '\0';
/* map file on top of the backing space */
vfp->_vfpStart = mmap(p, vfp->_vfpMapSize, PROT_READ,
MAP_PRIVATE|MAP_FIXED, fileno(fp), (off_t)0);
/* if mmap succeeded set mmap used flag in vfp */
if (vfp->_vfpStart != MAP_FAILED) {
vfp->_vfpFlags |= _VFP_MMAP;
}
}
}
/* if map failed (or not allowed) attempt malloc (if allowed) */
if ((vfp->_vfpStart == MAP_FAILED) && (!(a_flags & VFP_NOMALLOC))) {
/* mmap failed - plan b: read directly into memory */
ssize_t rlen;
/*
* compute proper size for allocating storage for file contents;
* add in one extra page so falling off end when file size is
* exactly modulo page size does not cause a page fault to
* guarantee that the end of the file contents will always
* contain a '\0' null character.
*/
vfp->_vfpSize = statbuf.st_size+pagesize;
/* allocate buffer to hold file data */
vfp->_vfpStart = memalign((size_t)pagesize, vfp->_vfpSize);
if (vfp->_vfpStart == (char *)NULL) {
lerrno = errno;
(void) fclose(fp);
(void) free(vfp);
errno = lerrno;
return (-1);
}
/* read the file into the buffer */
if (statbuf.st_size != 0) {
rlen = read(fileno(fp), vfp->_vfpStart,
statbuf.st_size);
if (rlen != statbuf.st_size) {
lerrno = errno;
if (lerrno == 0) {
lerrno = EIO;
}
(void) free(vfp->_vfpStart);
(void) fclose(fp);
(void) free(vfp);
errno = lerrno;
return (-1);
}
/* assure last byte+1 is null character */
((char *)vfp->_vfpStart)[statbuf.st_size] = '\0';
}
/* set malloc used flag in vfp */
vfp->_vfpFlags |= _VFP_MALLOC;
}
/* if no starting address all read methods failed */
if (vfp->_vfpStart == MAP_FAILED) {
/* no mmap() - no read() - cannot allocate memory */
(void) fclose(fp);
(void) free(vfp);
errno = ENOMEM;
return (-1);
}
/*
* initialize vfp contents
*/
/* _vfpCurr -> next byte to read */
vfp->_vfpCurr = (char *)vfp->_vfpStart;
/* _vfpEnd -> last data byte */
vfp->_vfpEnd = (((char *)vfp->_vfpStart) + statbuf.st_size)-1;
/* _vfpHighWater -> last byte written */
vfp->_vfpHighWater = (char *)vfp->_vfpEnd;
/* _vfpFile -> associated FILE* object */
vfp->_vfpFile = fp;
/* set flags as appropriate */
(void) vfpSetFlags(vfp, a_flags);
/* retain path name */
vfp->_vfpPath = strdup(a_path ? a_path : "");
/* set read/write flags */
if (*a_mode == 'w') {
vfp->_vfpFlags |= _VFP_WRITE;
}
if (*a_mode == 'r') {
vfp->_vfpFlags |= _VFP_READ;
}
/* set return vfp pointer */
(*r_vfp) = vfp;
/* All OK */
return (0);
}
/*
* Name: vfpClose
* Description: Close an open vfp, causing any modified data to be written out
* to the file associated with the vfp.
* Arguments: VFP_T **r_vfp - pointer to pointer to VFP_T returned by vfpOpen
* Returns: int == 0 - operation was successful
* != 0 - operation failed, errno contains reason
* Side Effects: r_vfp is set to (VFP_T)NULL
*/
int
vfpClose(VFP_T **r_vfp)
{
int ret;
int lerrno;
VFP_T *vfp;
/* return error if NULL VFP_T** provided */
if (r_vfp == (VFP_T **)NULL) {
errno = EFAULT;
return (-1);
}
/* localize access to VFP_T */
vfp = *r_vfp;
/* return successful if NULL VFP_T* provided */
if (vfp == (VFP_T *)NULL) {
return (0);
}
/* reset return VFP_T* handle */
*r_vfp = (VFP_T *)NULL;
/*
* if closing a file that is open for writing, commit all data if the
* backing memory is volatile and if there is a file open to write
* the data to.
*/
if (vfp->_vfpFlags & _VFP_WRITE) {
if ((vfp->_vfpFlags & _VFP_MALLOC) &&
(vfp->_vfpFile != (FILE *)NULL)) {
size_t len;
/* determine number of bytes to write */
len = vfpGetModifiedLen(vfp);
/* if modified bytes present commit data to the file */
if (len > 0) {
(void) vfpSafePwrite(fileno(vfp->_vfpFile),
vfp->_vfpStart, len, (off_t)0);
}
}
}
/* deallocate any allocated storage/mappings/etc */
if (vfp->_vfpFlags & _VFP_MALLOC) {
(void) free(vfp->_vfpStart);
} else if (vfp->_vfpFlags & _VFP_MMAP) {
/* unmap the file mapping */
(void) munmap(vfp->_vfpStart, vfp->_vfpMapSize);
/* free the backing allocation */
(void) free(vfp->_vfpStart);
}
/* free up path */
(void) free(vfp->_vfpPath);
/* close the file */
ret = 0;
if (vfp->_vfpFile != (FILE *)NULL) {
ret = fclose(vfp->_vfpFile);
lerrno = errno;
}
/* deallocate the vfp itself */
(void) free(vfp);
/* if the fclose() failed, return error and errno */
if (ret != 0) {
errno = lerrno;
return (-1);
}
return (0);
}
/*
* Name: vfpSetFlags
* Description: Modify operation of VFP according to flags specified
* Arguments: VFP_T *a_vfp - VFP_T pointer associated with file to set flags
* VFPFLAGS_T a_flags - one or more flags to control the operation:
* - VFP_NEEDNOW - file data needed in memory now
* - VFP_SEQUENTIAL - file data sequentially accessed
* - VFP_RANDOM - file data randomly accessed
* Any other flags specified are silently ignored.
* Returns: int == 0 - operation was successful
* != 0 - operation failed, errno contains reason
*/
int
vfpSetFlags(VFP_T *a_vfp, VFPFLAGS_T a_flags)
{
/* return if no vfp specified */
if (a_vfp == (VFP_T *)NULL) {
return (0);
}
/* if file data mapped into memory, apply vm flags */
if ((a_vfp->_vfpSize != 0) && (a_vfp->_vfpFlags & _VFP_MMAP)) {
/* mmap succeeded: properly advise vm system */
if (a_flags & VFP_NEEDNOW) {
/* advise vm system data is needed now */
(void) madvise(a_vfp->_vfpStart, a_vfp->_vfpMapSize,
MADV_WILLNEED);
}
if (a_flags & VFP_SEQUENTIAL) {
/* advise vm system data access is sequential */
(void) madvise(a_vfp->_vfpStart, a_vfp->_vfpSize,
MADV_SEQUENTIAL);
}
if (a_flags & VFP_RANDOM) {
/* advise vm system data access is random */
(void) madvise(a_vfp->_vfpStart, a_vfp->_vfpSize,
MADV_RANDOM);
}
}
return (0);
}
/*
* Name: vfpRewind
* Description: Reset default pointer for next read/write to start of file data
* Arguments: VFP_T *a_vfp - VFP_T pointer associated with file to rewind
* Returns: void
* Operation is always successful
*/
void
vfpRewind(VFP_T *a_vfp)
{
/* return if no vfp specified */
if (a_vfp == (VFP_T *)NULL) {
return;
}
/* set high water mark of last modified data */
if (a_vfp->_vfpCurr > a_vfp->_vfpHighWater) {
a_vfp->_vfpHighWater = a_vfp->_vfpCurr;
}
/* reset next character pointer to start of file data */
a_vfp->_vfpCurr = a_vfp->_vfpStart;
}
/*
* Name: vfpSetSize
* Description: Set size of in-memory image associated with VFP
* Arguments: VFP_T *a_vfp - VFP_T pointer associated with file to set
* size_t a_size - number of bytes to associatge with VFP
* Returns: int == 0 - operation was successful
* != 0 - operation failed, errno contains reason
* Side Effects:
* Currently only a file that is in malloc()ed memory can
* have its in-memory size changed.
* An error is returned If the file is mapped into memory.
* A file cannot be decreased in size - if the specified
* size is less than the current size, the operation is
* successful but no change in file size occurs.
* If no file is associated with the VFP (no "name" was
* given to vfpOpen) the first call to vfpSetSize allocates
* the initial size of the file data - effectively calling
* "malloc" to allocate the initial memory for the file data.
* Once an initial allocation has been made, subsequent calls
* to vfpSetSize are effectively a "realloc" of the existing
* file data.
* All existing file data is preserved.
*/
int
vfpSetSize(VFP_T *a_vfp, size_t a_size)
{
char *np;
size_t curSize;
/* return if no vfp specified */
if (a_vfp == (VFP_T *)NULL) {
return (0);
}
/* if malloc not used don't know how to set size right now */
if (!(a_vfp->_vfpFlags & _VFP_MALLOC)) {
return (-1);
}
/* adjust size to reflect extra page of data maintained */
a_size += getpagesize();
/* if size is not larger than current nothing to do */
if (a_size <= a_vfp->_vfpSize) {
return (0);
}
/* remember new size */
curSize = a_vfp->_vfpSize;
a_vfp->_vfpSize = a_size;
/* allocate/reallocate memory as appropriate */
if (a_vfp->_vfpStart != (char *)NULL) {
np = (char *)realloc(a_vfp->_vfpStart, a_vfp->_vfpSize+1);
if (np == (char *)NULL) {
return (-1);
}
np[curSize-1] = '\0';
} else {
np = (char *)malloc(a_vfp->_vfpSize+1);
if (np == (char *)NULL) {
return (-1);
}
np[0] = '\0';
}
/* make sure last allocated byte is a null */
np[a_vfp->_vfpSize] = '\0';
/*
* adjust all pointers to account for buffer address change
*/
/* _vfpCurr -> next byte to read */
a_vfp->_vfpCurr = (char *)(((ptrdiff_t)a_vfp->_vfpCurr -
(ptrdiff_t)a_vfp->_vfpStart) + np);
/* _vfpHighWater -> last byte written */
a_vfp->_vfpHighWater = (char *)(((ptrdiff_t)a_vfp->_vfpHighWater -
(ptrdiff_t)a_vfp->_vfpStart) + np);
/* _vfpEnd -> last data byte */
a_vfp->_vfpEnd = (np + a_vfp->_vfpSize)-1;
/* _vfpStart -> first data byte */
a_vfp->_vfpStart = np;
return (0);
}
/*
* Name: vfpTruncate
* Description: Truncate data associated with VFP
* Arguments: VFP_T *a_vfp - VFP_T pointer associated with file to truncate
* Returns: void
* Operation is always successful.
* Side Effects:
* In memory data associated with file is believed to be empty.
* Actual memory associated with file is not affected.
* If a file is associated with the VFP, it is truncated.
*/
void
vfpTruncate(VFP_T *a_vfp)
{
/* return if no vfp specified */
if (a_vfp == (VFP_T *)NULL) {
return;
}
/*
* reset all pointers so that no data is associated with file
*/
/* current byte is start of data area */
a_vfp->_vfpCurr = a_vfp->_vfpStart;
/* last byte written is start of data area */
a_vfp->_vfpHighWater = a_vfp->_vfpStart;
/* current character is NULL */
*a_vfp->_vfpCurr = '\0';
/* if file associated with VFP, truncate actual file */
if (a_vfp->_vfpFile != (FILE *)NULL) {
(void) ftruncate(fileno(a_vfp->_vfpFile), 0);
}
}
/*
* Name: vfpWriteToFile
* Description: Write data associated with VFP to specified file
* Arguments: VFP_T *a_vfp - VFP_T pointer associated with file to write
* char *a_path - path of file to write file data to
* Returns: int == 0 - operation was successful
* != 0 - operation failed, errno contains reason
*/
int
vfpWriteToFile(VFP_T *a_vfp, char *a_path)
{
int fd;
int lerrno = 0;
size_t len;
ssize_t result = 0;
/* return if no vfp specified */
if (a_vfp == (VFP_T *)NULL) {
errno = EFAULT;
return (-1);
}
/* on buffer overflow generate error */
if ((a_vfp->_vfpOverflow != 0) || (vfpGetBytesAvailable(a_vfp) < 1)) {
errno = EFBIG;
return (-1);
}
/* open file to write data to */
fd = open(a_path, O_WRONLY|O_CREAT|O_TRUNC, 0644);
if (fd < 0) {
return (-1);
}
/* determine number of bytes to write */
len = vfpGetModifiedLen(a_vfp);
/*
* if there is data associated with the file, write it out;
* if an error occurs, close the file and return failure.
*/
if (len > 0) {
result = vfpSafeWrite(fd, a_vfp->_vfpStart, len);
if (result != len) {
/* error comitting data - return failure */
lerrno = errno;
(void) close(fd);
errno = lerrno;
return (-1);
}
}
/* close the file */
(void) close(fd);
/* data committed to backing store - clear the modified flag */
(void) vfpClearModified(a_vfp);
/* return success */
return (0);
}
/*
* Name: vfpCheckpointFile
* Description: Create new VFP that checkpoints existing VFP, can be used by
* subsequent call to vfpCheckpointOpen to open a file using the
* existing in-memory cache of the contents of the file
* Arguments: VFP_T **r_cpVfp - pointer to pointer to VFP_T to be filled in
* with "checkpointed file" VFP (backing store)
* VFP_T **a_vfp - pointer to pointer to VFP_T returned by vfpOpen
* representing the VFP to checkpoint
* char *a_path - path to file that is the backing store for the
* in-memory data represented by a_vfp - used to verify
* that the data in memory is not out of date with respect
* to the backing store when vfpCheckpointOpen is called
* == (char *)NULL - use path associated with a_vfp
* that is, the backing store file in use
* Returns: int == 0 - operation was successful
* - r_destVfp contains a pointer to a new VFP that
* may be used in a subsequent call to
* vfpCheckpointOpen
* - the VFP referenced by *a_vfp is free()ed and
* must no longer be referenced
* != 0 - operation failed, errno contains reason
* - the VFP referenced by *a_vfp is not affected;
* the caller may continue to use it
* Notes: If the data of a VFP to checkpoint is mmap()ed then this method
* returns failure - only malloc()ed data VFPs can be
* checkpointed.
*/
int
vfpCheckpointFile(VFP_T **r_cpVfp, VFP_T **a_vfp, char *a_path)
{
VFP_T *vfp; /* newly allocated checkpointed VFP */
VFP_T *avfp; /* local -> to a_vfp */
struct stat statbuf; /* stat(2) info for backing store */
/* return error if NULL VFP_T** to checkpoint provided */
if (r_cpVfp == (VFP_T **)NULL) {
errno = EFAULT;
return (-1);
}
/* reset return checkpoint VFP pointer */
(*r_cpVfp) = (VFP_T *)NULL;
/* return error if no VFP to checkpoint specified */
if (a_vfp == (VFP_T **)NULL) {
errno = EFAULT;
return (-1);
}
/* localize reference to a_vfp */
avfp = *a_vfp;
/* return error if no VFP to checkpoint specified */
if (avfp == (VFP_T *)NULL) {
errno = EFAULT;
return (-1);
}
/* on buffer overflow generate error */
if ((avfp->_vfpOverflow != 0) || (vfpGetBytesAvailable(avfp) < 1)) {
errno = EFBIG;
return (-1);
}
/* no checkpointing is possible if the existing VFP is mmap()ed */
if (avfp->_vfpFlags & _VFP_MMAP) {
errno = EIO;
return (-1);
}
/* if no path specified, grab it from the VFP to checkpoint */
if ((a_path == (char *)NULL) || (*a_path == '\0')) {
a_path = avfp->_vfpPath;
}
/* backing store required: if VFP is "string" then this is an error */
if ((a_path == (char *)NULL) ||
strcmp(a_path, VFP_ANONYMOUS_PATH) == 0) {
errno = EINVAL;
return (-1);
}
/* Get the VFP to checkpoint (backing store) file size */
if (stat(a_path, &statbuf) != 0) {
return (-1);
}
/* allocate storage for checkpointed VFP (to return) */
vfp = (VFP_T *)malloc(sizeof (VFP_T));
if (vfp == (VFP_T *)NULL) {
return (-1);
}
/*
* close any file that is on the VFP to checkpoint (backing store);
* subsequent processes can modify the backing store data, and
* then when vfpCheckpointOpen is called, either the in-memory
* cached data will be used (if backing store unmodified) or else
* the in-memory data is released and the backing store is used.
*/
if (avfp->_vfpFile != (FILE *)NULL) {
(void) fclose(avfp->_vfpFile);
avfp->_vfpFile = (FILE *)NULL;
}
/* free any path associated with VFP to checkpoint (backing store) */
if (avfp->_vfpPath != (char *)NULL) {
(void) free(avfp->_vfpPath);
avfp->_vfpPath = (char *)NULL;
}
/* copy contents of VFP to checkpoint to checkpointed VFP */
memcpy(vfp, avfp, sizeof (VFP_T));
/* free contents of VFP to checkpoint */
(void) free(avfp);
/* reset pointer to VFP that has been free'd */
*a_vfp = (VFP_T *)NULL;
/* remember path associated with the checkpointed VFP (backing store) */
vfp->_vfpPath = strdup(a_path);
/* save tokens that identify the backing store for the in-memory data */
vfp->_vfpCkDev = statbuf.st_dev; /* devid holding st_ino inode */
vfp->_vfpCkIno = statbuf.st_ino; /* backing store inode */
vfp->_vfpCkMtime = statbuf.st_mtime; /* last data modification */
vfp->_vfpCkSize = statbuf.st_size; /* backing store size (bytes) */
vfp->_vfpCkStBlocks = statbuf.st_blocks; /* blocks allocated to file */
/* pass checkpointed VFP to caller */
(*r_cpVfp) = vfp;
/* success! */
return (0);
}
/*
* Name: vfpCheckpointOpen
* Description: Open file on vfp, allocate storage, return pointer to VFP_T
* that can be used to access/modify file contents. If a VFP_T to
* a checkpointed VFP is passed in, and the in memory contents of
* the VFP are not out of date with respect to the backing store
* file, use the existing in-memory contents - otherwise, discard
* the in-memory contents and reopen and reread the file.
* Arguments: VFP_T **a_cpVfp - pointer to pointer to VFP_T that represents
* checkpointed VFP to use to open the file IF the contents
* of the backing store are identical to the in-memory data
* VFP_T **r_vfp - pointer to pointer to VFP_T to open file on
* char *a_path - path of file to open and associate with this VFP.
* - if the path is (char *)NULL then no file is associated
* with this VFP - this is a way to create a fixed length
* string that can be manipulated with the VFP operators.
* Before the VFP can be used "vfpSetSize" must be called
* to set the size of the string buffer.
* char *a_mode - fopen mode to open the file with
* VFPFLAGS_T a_flags - one or more flags to control the operation:
* - VFP_NONE - no special flags
* - VFP_NEEDNOW - file data needed in memory now
* - VFP_SEQUENTIAL - memory will be sequentially accessed
* - VFP_RANDOM - memory will be randomly accessed
* - VFP_NOMMAP - do not use mmap to access file
* - VFP_NOMALLOC - do not use malloc to buffer file
* Returns: int == 0 - operation was successful
* != 0 - operation failed, errno contains reason
* Side Effects: r_vfp -- filled in with a pointer to a newly allocated vfp
* which can be used with the various VFP functions.
* a_cpVfp -- contents reset to zero if used to open the file
* errno -- contains system error number if return is != 0
*/
int
vfpCheckpointOpen(VFP_T **a_cpVfp, VFP_T **r_vfp, char *a_path,
char *a_mode, VFPFLAGS_T a_flags)
{
FILE *fp; /* backing store */
VFP_T *cpVfp; /* local -> to a_cpVfp checkpointed VFP */
VFP_T *vfp; /* new VFP open on checkpointed backing store */
struct stat statbuf; /* stat(2) info on backing store */
/*
* if no source VFP, or source VFP empty,
* or no backing store, just open file
*/
if ((a_cpVfp == (VFP_T **)NULL) || (*a_cpVfp == (VFP_T *)NULL) ||
((*a_cpVfp)->_vfpStart == (char *)NULL)) {
(void) vfpClose(a_cpVfp);
return (vfpOpen(r_vfp, a_path, a_mode, a_flags));
}
/* localize access to checkpointed VFP_T (*a_cpVfp) */
cpVfp = *a_cpVfp;
/* if no path specified, grab it from the checkpointed VFP */
if ((a_path == (char *)NULL) || (*a_path == '\0')) {
a_path = cpVfp->_vfpPath;
}
/* return error if no path specified and no path in checkpointed VFP */
if ((a_path == (char *)NULL) && (*a_path == '\0')) {
errno = EINVAL;
return (-1);
}
/* if no backing store path, then just open file */
if (stat(a_path, &statbuf) != 0) {
(void) vfpClose(a_cpVfp);
return (vfpOpen(r_vfp, a_path, a_mode, a_flags));
}
/*
* if backing store tokens do not match checkpointed VFP,
* the backing store has been updated since the VFP was checkpointed;
* release the in-memory data, and open and read the backing store
*/
if ((statbuf.st_size != cpVfp->_vfpCkSize) ||
(statbuf.st_mtime != cpVfp->_vfpCkMtime) ||
(statbuf.st_blocks != cpVfp->_vfpCkStBlocks) ||
(statbuf.st_ino != cpVfp->_vfpCkIno) ||
(statbuf.st_dev != cpVfp->_vfpCkDev)) {
(void) vfpClose(a_cpVfp);
return (vfpOpen(r_vfp, a_path, a_mode, a_flags));
}
/*
* backing store has not been updated since the VFP was checkpointed;
* use the in-memory data without re-reading the backing store; open the
* backing store file (if no file already open on the checkpointed VFP)
* so there is an open file associated with the in-memory data
*/
fp = cpVfp->_vfpFile;
if (fp == (FILE *)NULL) {
fp = fopen(a_path, a_mode);
if (fp == (FILE *)NULL) {
int lerrno;
lerrno = errno;
(void) vfpClose(a_cpVfp);
errno = lerrno;
return (-1);
}
}
/* allocate new VFP object to return as open VFP */
vfp = (VFP_T *)malloc(sizeof (VFP_T));
if (vfp == (VFP_T *)NULL) {
(void) vfpClose(a_cpVfp);
return (vfpOpen(r_vfp, a_path, a_mode, a_flags));
}
/* copy cached checkpointed VFP to new VFP to return */
(void) memcpy(vfp, cpVfp, sizeof (VFP_T));
/*
* initialize VFP to return contents
*/
/* FILE -> file opened on the VFPs backing store */
vfp->_vfpFile = fp;
/* release any existing path associated with the VFP */
if (vfp->_vfpPath != (char *)NULL) {
(void) free(vfp->_vfpPath);
}
/* path associated with the backing store for this VFP */
vfp->_vfpPath = strdup(a_path);
/*
* data pointers associated with in memory copy of backing store
* (such as _vfpHighWater, _vfpEnd, _vfpStart, etc.)
* do not need to be modified because we are using the same backing
* store as was checkpointed in cpVfp that is pointed to by vfp.
*/
/* _vfpCurr -> next byte to read */
vfp->_vfpCurr = (char *)vfp->_vfpStart;
/* free checkpointed VFP as it is now open on "vfp" */
(void) free(cpVfp);
/* reset callers -> checkpointed VFP */
(*a_cpVfp) = (VFP_T *)NULL;
/* set return VFP pointer */
(*r_vfp) = vfp;
/* success! */
return (0);
}
/*
* Name: vfpClearModified
* Description: Clear the "data is modified" indication from the VFP
* Arguments: VFP_T *a_vfp - VFP_T pointer associated with file to clear
* the "data is modified" indication
* Returns: int - previous setting of "data is modified" indication
* == 0 - "data is modified" was NOT previously set
* != 0 - "data is modified" WAS previously set
*/
int
vfpClearModified(VFP_T *a_vfp)
{
VFPFLAGS_T flags;
/* save current flags settings */
flags = a_vfp->_vfpFlags;
/* clear "data is modified" flag */
a_vfp->_vfpFlags &= (~_VFP_MODIFIED);
/* return previous "data is modified" flag setting */
return ((flags & _VFP_MODIFIED) != 0);
}
/*
* Name: vfpSetModified
* Description: Set the "data is modified" indication from the VFP
* Arguments: VFP_T *a_vfp - VFP_T pointer associated with file to set
* the "data is modified" indication
* Returns: int - previous setting of "data is modified" indication
* == 0 - "data is modified" was NOT previously set
* != 0 - "data is modified" WAS previously set
*/
int
vfpSetModified(VFP_T *a_vfp)
{
VFPFLAGS_T flags;
/* save current flags settings */
flags = a_vfp->_vfpFlags;
/* set "data is modified" flag */
a_vfp->_vfpFlags |= _VFP_MODIFIED;
/* return previous "data is modified" flag setting */
return ((flags & _VFP_MODIFIED) != 0);
}
/*
* Name: vfpGetModified
* Description: Get the "data is modified" indication from the VFP
* Arguments: VFP_T *a_vfp - VFP_T pointer associated with file to get
* the "data is modified" indication
* Returns: int - current setting of "data is modified" indication
* == 0 - "data is modified" is NOT set
* != 0 - "data is modified" IS set
*/
int
vfpGetModified(VFP_T *a_vfp)
{
/* return current "data is modified" flag setting */
return ((a_vfp->_vfpFlags & _VFP_MODIFIED) != 0);
}
/*
* Name: vfpSafeWrite
* Description: write data to open file safely
* Arguments: a_fildes - file descriptor to write data to
* a_buf - pointer to buffer containing data to write
* a_nbyte - number of bytes to write to open file
* Returns: int
* < 0 - error, errno set
* >= 0 - success
* NOTE: unlike write(2), vfpSafeWrite() handles partial writes, and will
* ----- restart the write() until all bytes are written, or an error occurs.
*/
ssize_t
vfpSafeWrite(int a_fildes, void *a_buf, size_t a_nbyte)
{
ssize_t r;
size_t bytes = a_nbyte;
for (;;) {
/* write bytes to file */
r = write(a_fildes, a_buf, a_nbyte);
/* return error on failure of write() */
if (r < 0) {
/* EAGAIN: try again */
if (errno == EAGAIN) {
continue;
}
/* EINTR: interrupted - try again */
if (errno == EINTR) {
continue;
}
return (r);
}
/* return total bytes written on success */
if (r >= a_nbyte) {
return (bytes);
}
/* partial write, adjust pointers, call write again */
a_buf = (void *)((ptrdiff_t)a_buf + (ptrdiff_t)r);
a_nbyte -= (size_t)r;
}
}
/*
* Name: vfpSafePwrite
* Description: write data to open file safely
* Arguments: a_fildes - file descriptor to write data to
* a_buf - pointer to buffer containing data to write
* a_nbyte - number of bytes to write to open file
* a_offset - offset into open file to write the first byte to
* Returns: int
* < 0 - error, errno set
* >= 0 - success
* NOTE: unlike pwrite(2), vfpSafePwrite() handles partial writes, and will
* ----- restart the pwrite() until all bytes are written, or an error occurs.
*/
ssize_t
vfpSafePwrite(int a_fildes, void *a_buf, size_t a_nbyte, off_t a_offset)
{
ssize_t r;
size_t bytes = a_nbyte;
for (;;) {
/* write bytes to file */
r = pwrite(a_fildes, a_buf, a_nbyte, a_offset);
/* return error on failure of write() */
if (r < 0) {
/* EAGAIN: try again */
if (errno == EAGAIN) {
continue;
}
/* EINTR: interrupted - try again */
if (errno == EINTR) {
continue;
}
return (r);
}
/* return total bytes written on success */
if (r >= a_nbyte) {
return (bytes);
}
/* partial write, adjust pointers, call write again */
a_buf = (void *)((ptrdiff_t)a_buf + (ptrdiff_t)r);
a_nbyte -= (size_t)r;
a_offset += (off_t)r;
}
}