Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
NT4/private/sdktools/vctools/cvpack/bufio.c
Microsoft ce47f986d8 First commit
2020-09-30 17:12:29 +02:00

3215 lines
63 KiB
C
Raw Permalink Blame History

/*++
Copyright (C) 1989 Microsoft Corporation
Module Name:
bufio.c
Abstract:
Functions which are common to the COFF Linker/Librarian/Dumper.
Author:
Brent Mills (BrentM) 17-Aug-1992
Azeem Khan (AzeemK) 09-Jun-1992
Revision History:
21-Oct-1992 BrentM added a while on GrowMapTable calls, fixed a bug
for JimSa in FileChSize()
20-Oct-1992 BrentM added FileChSize() to the fileio api
11-Oct-1992 BrentM writes of 0 bytes don't do anything, files opened
with read, write and !create are now handled
05-Oct-1992 BrentM added STATIC #define for profiling
05-Oct-1992 BrentM don't round off in GrowMapTable(), now links c++ p1
05-Oct-1992 BrentM marked buffers BUF_Dirty on writes spanning >1 buffers
02-Oct-1992 BrentM BufferedSeek() adds the offset on SEEK_END
01-Oct-1992 BrentM mapped i/o option for reads if on NT
30-Sep-1992 BrentM encapsalated BUF_Random setting in if !FI_Write
28-Sep-1992 BrentM better summary on DB_BUFVERBOSE
27-Sep-1992 BrentM dump logical file descriptor for i/o logging
25-Sep-1992 BrentM made the current buffer of cached file handles
available for reallocation
23-Sep-1992 BrentM added read buffering and logical file handle caching
10-Sep-1992 BrentM added [f]open/[f]close logging
09-Sep-1992 BrentM added read logging and added separate db switches
04-Sep-1992 BrentM removed pragmas to turn off compiler optimizations
03-Sep-1992 BrentM put diagnostics under ifdefs and DBEXECs
20-Aug-1992 BrentM fixed bogus assert
19-Aug-1992 BrentM increased max .exe size to 7000000, links XL nondebug
03-Aug-1992 BrentM file mapped buffering
29-Jul-1992 BrentM split from shared.c
--*/
#include "compact.h"
// Get Rid of Debug logging, this requires too much external support
#define DBEXEC(flg, expr)
#define DBEXEC_REL(flg, expr)
#define RemoveConvertTempFiles()
void ErrorExit(unsigned, const char *, const char *);
#define Error(a, b, c) ErrorExit(a, b, c)
#define OutOfMemory() ErrorExit(ERR_NOMEM, NULL, NULL)
void FreePv(void *pv)
{
free(pv);
}
void *PvAllocZ(size_t cb)
{
void *pv = calloc(1, cb);
if (pv == NULL) {
OutOfMemory();
}
return(pv);
}
void *PvRealloc(void *pv, size_t cb)
{
void *pvNew = realloc(pv, cb);
if (pvNew == NULL) {
OutOfMemory();
}
return(pvNew);
}
char *SzDup(const char *sz)
{
char *szNew = _strdup(sz);
if (szNew == NULL) {
OutOfMemory();
}
return(szNew);
}
// function static define
#define STATIC static
extern BOOL fCtrlCSignal;
#define MAX_WRITEABLE_FILES 16
static PFI pfiCloseOnBadExit[MAX_WRITEABLE_FILES];
// value in buffer map table signifying something
// has previously been to this range
#define pbufPreviousWrite ((PBUF) 0x1)
// default size of writeable files
#define cbDefaultFileSize (4096L * 1024L) // 4Meg
/* buffered i/o routines */
STATIC INT BufferedOpen(PFI, INT, INT, BOOL);
STATIC INT BufferedCloseHard(PFI);
STATIC LONG BufferedSeek(PFI, LONG, INT);
STATIC DWORD BufferedWrite(PFI, const void *, DWORD);
STATIC DWORD BufferedRead(PFI, PVOID, DWORD);
STATIC INT BufferedChSize (PFI, LONG);
/* mapped i/o routines */
INT MappedOpen(PFI, LONG, BOOL);
INT MappedCloseHard(PFI);
LONG MappedSeek(PFI, LONG, INT);
STATIC DWORD MappedWrite(PFI, const void *, DWORD);
STATIC DWORD MappedRead(PFI, PVOID, DWORD);
BOOL ExtendMapView(PFI pfi, DWORD ibNeeded);
BOOL FMapPfi(PFI pfi);
STATIC INT MappedChSize(PFI, LONG);
/* logical file descriptor manipulators */
STATIC PFI LookupCachedFiles(const char *, INT, INT, BOOL *);
STATIC PFI PfiClosedCached(const char *);
STATIC PFI PfiNew(VOID);
STATIC PFI PfiAlloc(VOID);
STATIC VOID TransitionPFI(PFI, PPFI, PPFI, PPFI, PPFI, BOOL);
STATIC VOID GrowMapTable(PFI);
STATIC VOID CloseSoft(PFI);
/* buffer manipulators */
STATIC BOOL FDeactivateBuf(PBUF);
STATIC BOOL FActivateBuf(PFI, PBUF);
STATIC PBUF PbufNew(VOID);
STATIC PBUF PbufAlloc(PFI, LONG);
STATIC PBUF PbufLRU(VOID);
STATIC VOID MoveToHeadLRU(PBUF);
STATIC VOID SlidePbufCur(PFI);
STATIC VOID FlushBuffer(PBUF);
STATIC VOID ReadpbufCur(PFI);
/* debug routines */
#if DBG
STATIC BOOL FBufListCheck(VOID);
STATIC BOOL FNoDupBuf(PBUF);
STATIC BOOL FPfiInList(PFI, PFI);
STATIC BOOL FPfiCheck(VOID);
#endif // DBG
/* buffer containers */
static PBUF pbufLRUHead = NULL; // LRU buffer chain head (MRU)
static PBUF pbufLRUTail = NULL; // LRU buffer chain tail (LRU)
static PBUF pbufFree = NULL; // free file buffers
static PBUF pbufActive = NULL; // active file buffers
/* statistics */
static LONG crereads = 0L; // number of buffer re-reads
static LONG cfiTot = 0L; // total number of logical file descriptors
static LONG cfiCacheClosed = 0L;// current size of closed/cached pool
static LONG cfiCacheClosedMax = 0L; // maximum size of closed/cached pool
static LONG cbufTot = 0L; // total number of buffers
static DWORD cfiInSystem; // # of FI's chosen
static DWORD cfiCacheableInSystem; // # of FI's chosen
/* logical file descriptor containers */
static PFI pfiFree = NULL; // free logical file handles
static PFI pfiOpen = NULL; // active logical file handles
static PFI pfiClosedHead = NULL;// head of list of closed file handles
static PFI pfiClosedTail = NULL;// tail of list of closed file handles
PFI *rgpfi; // map of cached file handles
/* error handlers */
static BOOL fMappedIO = 0;
/* State transitions for logical file descriptors. */
/* There are 3 states, open, closed/cached, and free. */
/* The following macros are atomic state transitions. It is likely */
/* cheaper to change states with inline linked list code, however */
/* it becomes difficult to track file handles and the probability of */
/* loosing them increases. */
#define TR_Free_To_Open(pfi) { \
DBEXEC(DB_BUFVERBOSE, DBPRINT(" - pfi = 0x%p free to open (%s)\n", \
(pfi), (pfi)->szFileName)); \
TransitionPFI((pfi), &pfiFree, NULL, &pfiOpen, NULL, 0); }
#define TR_Open_To_Free(pfi) { \
DBEXEC(DB_BUFVERBOSE, DBPRINT(" - pfi = 0x%p open to free (%s)\n", \
(pfi), (pfi)->szFileName)); \
TransitionPFI((pfi), &pfiOpen, NULL, &pfiFree, NULL, 0); }
#define TR_Open_To_Cache(pfi) { \
cfiCacheClosed++; \
DBEXEC(DB_BUFVERBOSE, DBPRINT(" - pfi = 0x%p open to cached (%s)\n", \
(pfi), (pfi)->szFileName)); \
TransitionPFI((pfi), &pfiOpen, NULL, &pfiClosedHead, &pfiClosedTail, 1); }
#define TR_Cache_To_Open(pfi) { \
cfiCacheClosed--; \
DBEXEC(DB_BUFVERBOSE, DBPRINT(" - pfi = 0x%p cached to open (%s)\n", \
(pfi), (pfi)->szFileName)); \
TransitionPFI((pfi), &pfiClosedHead, &pfiClosedTail, &pfiOpen, NULL, 0); }
#define TR_Cache_To_Free(pfi) { \
cfiCacheClosed--; \
DBEXEC(DB_BUFVERBOSE, DBPRINT(" - pfi = 0x%p cached to open (%s)\n", \
(pfi), (pfi)->szFileName)); \
TransitionPFI((pfi), &pfiClosedHead, &pfiClosedTail, &pfiFree, NULL, 0); }
VOID
FileInit (
LONG cbuf,
USHORT cfiForSystem_NT,
USHORT cfiCacheClosedT_NT,
USHORT cfiForSystem_TNT,
USHORT cfiCacheClosedT_TNT,
BOOL fTryMapped)
/*++
Routine Description:
Initialize the buffered i/o package.
Arguments:
cbuf - number of buffers to allocate to package
cfiForSystem - number of logical file handles for system
cfiCacheClosedT - size of logical file handle cache
fTryMapped - if !0 attempte mapped i/o, otherwise use buffered i/o
Return Value:
None.
--*/
{
HINSTANCE hLib;
LONG ibuf;
PBUF pbuf;
PFI pfi;
LONG ifi;
LONG cfiForSystem, cfiCacheClosedT;
int i;
if (fTryMapped) {
// First check for TNT specifically. This is so we can also
// reduce the count of open file handles, for TNT only.
hLib = GetModuleHandle("kernel32.dll");
if (hLib != 0 && GetProcAddress(hLib, "IsTNT") != 0) {
fTryMapped = FALSE;
}
}
DBEXEC(DB_BUFVERBOSE, DBPRINT(fTryMapped ?
"Using NT I/O parameters (file mapping)\n" :
"Using TNT I/O parameters (no mapping, fewer handles)\n"));
cfiForSystem = fTryMapped ? cfiForSystem_NT : cfiForSystem_TNT;
cfiCacheClosedT = fTryMapped ? cfiCacheClosedT_NT : cfiCacheClosedT_TNT;
cfiInSystem = cfiForSystem; // store in global (for statistics)
cfiCacheableInSystem = cfiCacheClosedT;
// set the total buffers for the system
cbufTot = cbuf;
// allocate buffers and add them to the free list
for (ibuf = 0; ibuf < cbuf; ibuf++) {
pbuf = PbufNew();
if (!pbufFree) {
pbufFree = pbuf;
} else {
pbuf->pbufNext = pbufFree;
pbufFree = pbuf;
}
}
// allocate logical file handle map
rgpfi = (PFI *) PvAllocZ(cfiForSystem * sizeof(PFI));
// allocate buffered file handles
for (ifi = 0; ifi < cfiForSystem; ifi++) {
pfi = PfiNew();
pfi->ifi = ifi;
if (!pfiFree) {
pfiFree = pfi;
} else {
pfi->pfiNext = pfiFree;
pfiFree = pfi;
}
rgpfi[ifi] = pfi;
}
// set the maximum cache size
cfiCacheClosedMax = cfiCacheClosedT;
// set the mapped i/o flag
fMappedIO = fTryMapped;
DBEXEC_REL(DB_NO_FILE_MAP, fMappedIO = FALSE);
// initialize the CloseOnBadExit array
for (i = 1; i < MAX_WRITEABLE_FILES; i++) {
pfiCloseOnBadExit[i] = NULL;
}
#if DBG
assert(FPfiCheck());
#endif
}
STATIC PFI
PfiNew(
VOID)
/*++
Routine Description:
Create a new logical file handle.
Arguments:
None.
Return Value:
None.
--*/
{
PFI pfi;
pfi = (PFI) PvAllocZ(sizeof(FI));
cfiTot++;
return(pfi);
}
STATIC VOID
GrowMapTable(
PFI pfi)
/*++
Routine Description:
Grow a the file buffer map table and set *pl to the new size. This
routine assumes pfi->cbMap % cbIOBuf == 0.
Arguments:
pfi - logical file descriptor
Return Value:
None.
--*/
{
LONG cbufNew;
LONG cbufOld;
// get the old buffer table size
cbufOld = pfi->cbMap / cbIOBuf;
// double the size of the old table
cbufNew = cbufOld << 1;
assert(cbufNew > cbufOld);
// grow the table
pfi->rgpbuf = (PPBUF) PvRealloc(pfi->rgpbuf, cbufNew * sizeof(PBUF));
// zero the enties
memset(&(pfi->rgpbuf[cbufOld]), '\0', sizeof(PBUF) * (cbufNew - cbufOld));
// set the new size
pfi->cbMap = cbufNew * cbIOBuf;
}
STATIC PFI
PfiAlloc(
VOID)
/*++
Routine Description:
Allocate a logical file descriptor.
Arguments:
None.
Return Value:
None.
--*/
{
PFI pfi;
if (!pfiFree) {
// no free logical file descriptors, hard close
pfi = pfiClosedHead;
TR_Cache_To_Free(pfi);
BufferedCloseHard(pfi);
}
pfi = pfiFree;
assert(pfi);
TR_Free_To_Open(pfi);
return(pfi);
}
STATIC PFI
PfiClosedCached (
const char *szFileName)
/*++
Routine Description:
Check for a cached pfi in the closed chain.
Arguments:
szFileName - file name to find a cached pfi for
Return Value:
pointer to a logical file descriptor if found, NULL otherwise
--*/
{
PFI pfiLast = pfiClosedHead;
PFI pfi = pfiClosedHead;
assert(szFileName);
// loop through the closed chain loooking for the file
while (pfi) {
if (!strcmp(pfi->szFileName, szFileName)) {
// found file, move from closed list to open list
TR_Cache_To_Open(pfi);
assert(pfi->flags & FI_Closed);
pfi->flags &= ~FI_Closed;
return (pfi);
}
pfiLast = pfi;
pfi = pfi->pfiNext;
}
return (NULL);
}
INT
FileChSize (
INT fd,
LONG cbSizeNew)
/*++
Routine Description:
Change the file size.
Arguments:
fd - file descriptor
cbSizeNew - new size of file
Return Value:
0 on success, -1 otherwise
--*/
{
assert(rgpfi[fd]);
assert(rgpfi[fd]->flags & FI_Write);
#if 0
if (fCtrlCSignal) {
BadExitCleanup();
}
#endif
if (cbSizeNew == rgpfi[fd]->cbSoFar) {
// no change in size
return 0;
}
if (rgpfi[fd]->flags & FI_Mapped) {
return(MappedChSize(rgpfi[fd], cbSizeNew));
}
return(BufferedChSize(rgpfi[fd], cbSizeNew));
}
STATIC INT
MappedChSize (
PFI pfi,
LONG cbSizeNew)
/*++
Routine Description:
Change the file size. Same as _chsize() in the crt. This only operates
on buffered files, the code will assert on mapped files.
Arguments:
fd - file descriptor
cbSizeNew - new size of file
Return Value:
0 on success, -1 otherwise
--*/
{
BOOL f = TRUE;
assert(pfi->flags & FI_Mapped);
if (cbSizeNew > pfi->cbMapView) {
// Grow file
if (!ExtendMapView(pfi, cbSizeNew)) {
Error(ERR_NOSPACE, NULL, NULL);
}
} else {
// Shrink file
if (pfi->ibCur > cbSizeNew) {
pfi->ibCur = cbSizeNew;
}
}
pfi->cbSoFar = cbSizeNew;
return(0);
}
STATIC INT
BufferedChSize (
PFI pfi,
LONG cbSizeNew)
/*++
Routine Description:
Change the file size. Same as _chsize() in the crt. This only operates
on buffered files, the code will assert on mapped files.
Arguments:
pfi - logical file descriptor
cbSizeNew - new size of file
Return Value:
0 on success, -1 otherwise
--*/
{
PBUF pbuf;
LONG ibuf;
LONG cbuf;
#if DBG
BOOL f;
#endif // DBG
assert(!(pfi->flags & FI_Mapped));
if (cbSizeNew > pfi->cbSoFar) {
// grow file
while (pfi->cbMap <= cbSizeNew) {
GrowMapTable(pfi);
}
assert(cbSizeNew <= pfi->cbMap);
} else {
// shrink file
cbuf = pfi->cbMap >> cshiftBuf;
// make sure pfi->cbMap is cbIOBuf aligned
assert((cbuf * cbIOBuf) == pfi->cbMap);
for(ibuf = cbSizeNew >> cshiftBuf; ibuf < cbuf; ibuf++) {
pbuf = pfi->rgpbuf[ibuf];
if (pbuf != NULL && pbuf != pbufPreviousWrite) {
assert(pbuf->flags & BUF_Active);
#if DBG
f =
#endif // DBG
FDeactivateBuf(pbuf);
assert(f);
}
}
}
pfi->cb = cbSizeNew;
pfi->cbSoFar = cbSizeNew;
return (_chsize(pfi->fd, cbSizeNew));
}
STATIC PFI
LookupCachedFiles (
const char *szFileName,
INT flags,
INT mode,
BOOL *pfNewPfi
)
/*++
Routine Description:
Looks up the cached list for the file
Arguments:
szFileName - A pointer to a file name.
flags - open flags
mode - open mode
pfNewPfi - TRUE if new pfi had to be allocated
Return Value:
PFI
--*/
{
PFI pfi;
// get a file handle
if (!(pfi = PfiClosedCached(szFileName))) {
pfi = PfiAlloc();
*pfNewPfi = 1;
pfi->szFileName = SzDup(szFileName);
pfi->flags = 0;
pfi->cbSoFar = 0;
pfi->hFile = NULL;
pfi->pvMapView = NULL;
pfi->cbMapView = 0;
pfi->ibCur = 0;
pfi->MapAddr = 0;
// set read flags
if ((flags & 0x000f) == O_RDONLY ||
flags & O_RDWR) {
pfi->flags |= FI_Read;
}
// set write flags
if (flags & O_WRONLY ||
flags & O_RDWR) {
pfi->flags |= FI_Write;
}
// set the create flag
if (flags & O_CREAT) {
pfi->flags |= FI_Create;
}
}
assert(pfi);
return(pfi);
}
INT
FileOpen (
const char *szFileName,
INT flags,
INT mode
)
/*++
Routine Description:
Opens a file. Prints an error if can't open file. Do rudementary
file handle caching.
Arguments:
szFileName - A pointer to a file name.
flags - open flags
mode - open mode
Return Value:
Physical file descriptor.
--*/
{
BOOL fNewPfi = 0;
PFI pfi;
INT i = -1;
#if 0
if (fCtrlCSignal) {
BadExitCleanup();
}
#endif
pfi = LookupCachedFiles(szFileName, flags, mode, &fNewPfi);
assert(pfi);
if (fMappedIO) {
i = MappedOpen(pfi, flags, fNewPfi);
}
if (i == -1) {
BufferedOpen(pfi, flags, mode, fNewPfi);
}
return (pfi->ifi);
}
DWORD
RoundUp (
DWORD cb,
DWORD cbHigh
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
if (cb < cbHigh) {
return cbHigh;
}
return RoundUp(cb, (cbHigh << 1));
}
INT
FileOpenMapped (
const char *szFileName,
INT flags,
INT mode,
DWORD *pMapAddr,
DWORD *pcb
)
/*++
Routine Description:
Opens and maps a file to a specific address.
Arguments:
szFileName - name of file.
flags - open flags
mode - open mode
pMapAddr - address to map the file to. On return has actual address.
pcb - pointer to file size. On return has free space.
Return Value:
file handle.
--*/
{
BOOL fNewPfi = 0;
PFI pfi;
INT i = -1;
#if 0
if (fCtrlCSignal) {
BadExitCleanup();
}
#endif
// got to have mapped i/o
if (!fMappedIO) {
return i;
}
// lookup the cache first
pfi = LookupCachedFiles(szFileName, flags, mode, &fNewPfi);
assert(pfi);
pfi->MapAddr = *pMapAddr;
pfi->cbSoFar = *pcb;
// set the file size
if (flags & O_CREAT) {
// 256K is starting size of map (bufio.h)
pfi->cbMapView = cbInitialILKMapSize;
} else {
// Round up to 256K/512K/...etc for an open
pfi->cbMapView = RoundUp(pfi->cbSoFar, cbInitialILKMapSize);
}
// Open the file
i = MappedOpen(pfi, flags, fNewPfi);
if (i == -1) {
// failed to map to specified address;
// insuffcient disk space OR couldn't allocate map at req. addr.
TR_Open_To_Free(pfi);
if (!_access(pfi->szFileName, 0)) {
_unlink(pfi->szFileName);
}
FreePv(pfi->szFileName);
return i;
}
*pcb = (flags & O_CREAT) ? pfi->cbMapView : pfi->cbMapView - pfi->cbSoFar;
*pMapAddr = (DWORD)pfi->pvMapView;
return (pfi->ifi);
}
STATIC INT
BufferedOpen (
PFI pfi,
INT flags,
INT mode,
BOOL fNewPfi)
/*++
Routine Description:
Opens a file. Prints an error if can't open file. Do rudementary
file handle caching.
Arguments:
pfi - logical file descriptor
flags - open flags
mode - open mode
Return Value:
Logical file descriptor.
--*/
{
struct _stat statFile;
LONG cbuf;
LONG ibuf;
assert(pfi);
// if no cached logical file handle
if (fNewPfi) {
// open the file
if ((pfi->fd = _sopen(pfi->szFileName, flags,
((flags & (_O_RDWR|_O_WRONLY)) ? _SH_DENYRW : _SH_DENYWR), mode)) == -1)
{
PFI pfiTmp;
if (pfi == pfiOpen) {
pfiOpen = pfi->pfiNext;
cfiTot--;
}
else
for (pfiTmp = pfiOpen; pfiTmp; pfiTmp = pfiTmp->pfiNext) {
if (pfiTmp->pfiNext == pfi) {
pfiTmp->pfiNext = pfi->pfiNext;
cfiTot--;
break;
}
}
Error(ERR_EXEOPEN, pfi->szFileName, NULL);
}
// we don't support O_APPEND
assert(!(flags & O_APPEND));
pfi->cbSoFar = 0L;
// get size of file, or set to default
// note this is !FI_Write because an opened .exe is readable, but
// its size is not defined yet
if (!(pfi->flags & FI_Write) ||
((pfi->flags & (FI_Read | FI_Write)) &&
!(pfi->flags & FI_Create))) {
if (_stat(pfi->szFileName, &statFile) == -1) {
Error(ERR_EXEOPEN, pfi->szFileName, NULL);
}
// Test for files of size 0 (mapped open will fall through in this case)
if (!statFile.st_size) {
// UNDONE: Why allocate before calling Error?
pfi->rgpbuf = (PPBUF) PvAllocZ(sizeof(PBUF));
Error(ERR_INVALIDEXE, NULL, NULL);
}
pfi->cb = statFile.st_size;
pfi->cbSoFar = statFile.st_size;
} else {
pfi->cb = cbDefaultFileSize;
}
cbuf = (pfi->cb + cbIOBuf) / cbIOBuf;
pfi->cbMap = cbuf * cbIOBuf;
// allocate file buffer map table
pfi->rgpbuf = (PPBUF) PvAllocZ(cbuf * sizeof(PBUF));
// blast previous writes into buffer map table if required
if ((pfi->flags & (FI_Read | FI_Write)) & !(pfi->flags & FI_Create)) {
for (ibuf = 0; ibuf < cbuf; ibuf++) {
pfi->rgpbuf[ibuf] = pbufPreviousWrite;
}
}
}
BufferedSeek(pfi, 0L, SEEK_SET);
assert(rgpfi[pfi->ifi]->ifi == rgpfi[pfi->ifi]->pbufCur->ifi);
return (0);
}
INT
FileClose (
INT fd,
BOOL fUnCache)
/*++
Routine Description:
Closes a file. Prints an error if can't close file.
Arguments:
pfi - logical file descriptor
fUnCache - hard close the file
Return Value:
Same as close();
--*/
{
PFI pfi;
INT i;
pfi = rgpfi[fd];
assert(pfi);
assert(!(pfi->flags & FI_Closed));
#if 0
if (fCtrlCSignal) {
BadExitCleanup();
}
#endif
// either close the file hard if specified or if writable or
// virtually close the file and cache the logical and physical handle
if (fUnCache || (pfi->flags & FI_Write)) {
TR_Open_To_Free(pfi);
if (pfi->flags & FI_Mapped) {
i = MappedCloseHard(pfi);
} else {
i = BufferedCloseHard(pfi);
}
} else {
TR_Open_To_Cache(pfi);
CloseSoft(pfi);
i = 0;
}
return (i);
}
STATIC INT
BufferedCloseHard (
PFI pfi)
/*++
Routine Description:
Close logical and physical file handles for a file. Does not manipulate
PFI pools.
Arguments:
pfi - logical file descriptor
Return Value:
Same as close();
--*/
{
PBUF pbufN;
PBUF pbuf;
INT i;
#if DBG
BOOL f;
#endif // DBG
assert(pfi);
// delete active buffers from file
pbuf = pbufActive;
while (pbuf) {
assert(pbuf->flags & BUF_Active);
pbufN = pbuf->pbufNext;
if (pbuf->ifi == pfi->ifi) {
if (pbuf == pfi->pbufCur) {
pfi->pbufCur->flags &= ~BUF_Current;
}
#if DBG
f =
#endif //DBG
FDeactivateBuf(pbuf);
assert(f);
}
pbuf = pbufN;
}
// close the physical handle
if ((i = _close(pfi->fd)) == -1) {
Error(ERR_NOSPACE, NULL, NULL);
}
assert(pfi->szFileName);
FreePv(pfi->szFileName);
assert(pfi->rgpbuf);
FreePv(pfi->rgpbuf);
// return the result of the low level close
return (i);
}
STATIC VOID
CloseSoft (
PFI pfi)
/*++
Routine Description:
Close a logical file handle and cache it.
Arguments:
pfi - logical file descriptor
Return Value:
Same as close();
--*/
{
PFI pfiToFree;
assert(pfi);
assert(!(pfi->flags & FI_Closed));
// set logical file descriptor to closed
pfi->flags |= FI_Closed;
if (!(pfi->flags & FI_Mapped)) {
// set the current pbuf to not current and remove it from the
// logical file descriptor, this is safe since when the file
// is re-opened (logically) there is an immediate seek to offset
// 0 which can potentially reactivate or reallocate the buffer,
// this also frees up the buffer to be reallocated if need be
assert(pfi->pbufCur);
assert(pfi->pbufCur->flags & BUF_Current);
pfi->pbufCur->flags &= ~BUF_Current;
pfi->pbufCur = NULL;
}
// if cache is full, toss the last guy out
if (cfiCacheClosed == cfiCacheClosedMax) {
pfiToFree = pfiClosedHead;
assert(pfiToFree);
assert(pfiToFree);
TR_Cache_To_Free(pfiToFree);
(pfiToFree->flags & FI_Mapped) ?
MappedCloseHard(pfiToFree) :
BufferedCloseHard(pfiToFree);
}
}
VOID
FileCloseAll (
VOID
)
/*++
Routine Description:
Closes all cached handles.
Arguments:
None.
Return Value:
None.
--*/
{
PFI pfiT;
PFI pfi;
#if DBG
assert(FPfiCheck());
#endif
// hard close all open files
pfi = pfiOpen;
while (pfi) {
// move open PFI to free PFI pool
assert(!(pfi->flags & FI_Closed));
pfiT = pfi->pfiNext;
TR_Open_To_Free(pfi);
(pfi->flags & FI_Mapped) ?
MappedCloseHard(pfi) :
BufferedCloseHard(pfi);
pfi = pfiT;
}
// hard close all closed/cached files
pfi = pfiClosedHead;
while (pfi) {
assert(pfi->flags & FI_Closed);
pfiT = pfi->pfiNext;
// move closed/cached PFI to free PFI pool
TR_Cache_To_Free(pfi);
(pfi->flags & FI_Mapped) ?
MappedCloseHard(pfi) :
BufferedCloseHard(pfi);
pfi = pfiT;
}
DBEXEC(DB_BUFVERBOSE, DBPRINT("Buffer summary\n"));
DBEXEC(DB_BUFVERBOSE, DBPRINT("--------------\n"));
DBEXEC(DB_BUFVERBOSE, DBPRINT("# file handles = %d\n", cfiInSystem));
DBEXEC(DB_BUFVERBOSE, DBPRINT("# cacheable file handles = %d\n",
cfiCacheableInSystem));
DBEXEC(DB_BUFVERBOSE, DBPRINT("size of buffers = %d\n", cbIOBuf));
DBEXEC(DB_BUFVERBOSE, DBPRINT("buffer re-reads = %d\n", crereads));
#if DBG
assert(FPfiCheck());
#endif
}
STATIC VOID
FlushBuffer (
PBUF pbuf)
/*++
Routine Description:
Flush a buffer.
Arguments:
pbuf - buffer to flush
Return Value:
None.
--*/
{
LONG cb;
PFI pfi;
assert(pbuf);
// get the buffered file descriptor
pfi = rgpfi[pbuf->ifi];
assert(pfi);
if (pbuf->flags & BUF_Dirty) {
// calculate how much to flush
cb = pbuf->ibLast - pbuf->ibStart;
DBEXEC(DB_IO_FLUSH,
Trans_LOG(LOG_FlushBuffer, pfi->fd, pbuf->ibCur, cb, 0, NULL));
// seek to buffers beginning
if (_lseek(pfi->fd, pbuf->ibStart, SEEK_SET) == -1L) {
Error(ERR_NOSPACE, NULL, NULL);
}
// flush buffer
if (_write(pfi->fd, pbuf->rgbBuf, cb) != cb) {
Error(ERR_NOSPACE, NULL, NULL);
}
// set the buffer to written to
pfi->rgpbuf[pbuf->ibStart >> cshiftBuf] = pbufPreviousWrite;
// set file size so far
if ((pfi->flags & FI_Write) &&
(pbuf->ibLast > pfi->cbSoFar)) {
pfi->cbSoFar = pbuf->ibLast;
}
} else {
// remove the buffer from the buffer map table
if (pbuf->flags & BUF_PreviousWrite) {
pfi->rgpbuf[pbuf->ibStart >> cshiftBuf] = pbufPreviousWrite;
} else {
pfi->rgpbuf[pbuf->ibStart >> cshiftBuf] = NULL;
}
}
#if DBG
assert(FBufListCheck());
#endif
}
STATIC LONG
BufferedSeek (
PFI pfi,
LONG ib,
INT origin
)
/*++
Routine Description:
Seeks a file that is buffered. Prints an error if can't seek file.
Arguments:
pfi - buffered file descriptor
ib - Number of bytes to seek.
origin - SEEK_SET, SEEK_CUR, or SEEK_END.
Return Value:
Same as lseek().
--*/
{
LONG ibFile;
PBUF pbuf;
assert(pfi);
#if DBG
assert(FBufListCheck());
#endif
DBEXEC(DB_IO_SEEK,
Trans_LOG(LOG_BufSeek, pfi->ifi, ib, 0, origin, NULL));
// calculate SEEK_SET offset
switch (origin) {
case SEEK_SET: // already non-relative offset
ibFile = ib;
break;
case SEEK_CUR: // relative offset
assert(pfi->pbufCur);
// base off of current buffer
ibFile = pfi->pbufCur->ibCur + ib;
break;
default:
case SEEK_END:
ibFile = pfi->cbSoFar + ib;
break;
}
// check if we need to grow the buffer map table
while (ibFile >= pfi->cbMap) {
GrowMapTable(pfi);
}
// get buffer entry
assert(ibFile <= pfi->cbMap);
pbuf = pfi->rgpbuf[ibFile >> cshiftBuf];
// set current buffer to no buffer
if (pfi->pbufCur) {
assert(pfi->pbufCur->flags & BUF_Current);
pfi->pbufCur->flags &= ~BUF_Current;
pfi->pbufCur = NULL;
}
if ((DWORD) pbuf <= 1) {
// no buffer or previously buffered, attempt to allocate a buffer
pfi->pbufCur = PbufAlloc(pfi, ibFile);
assert(!(pfi->pbufCur->flags & BUF_Current));
pfi->pbufCur->flags |= BUF_Current;
assert(pfi->pbufCur);
assert(pfi->ifi == pfi->pbufCur->ifi);
}
// if the file has been previously written to at this range
// then read in buffer
if (pbuf == pbufPreviousWrite) {
ReadpbufCur(pfi);
crereads++;
DBEXEC(DB_BUFVERBOSE,
DBPRINT("re-read @%0x\n", pfi->pbufCur->ibStart));
// set the buffer to previously written out
pfi->pbufCur->flags |= BUF_PreviousWrite;
}
// found an entry in the buffer map table
if ((DWORD) pbuf > 1) {
pfi->pbufCur = pbuf;
assert(!(pbuf->flags & BUF_Current));
pfi->pbufCur->flags |= BUF_Current;
}
// set offset in buffer
assert(ibFile >= pfi->pbufCur->ibStart);
pfi->pbufCur->ibCur = ibFile;
pfi->pbufCur->pbCur = pfi->pbufCur->rgbBuf +
(ibFile - pfi->pbufCur->ibStart);
// update highest valid buffer access on writes
if ((pfi->flags & FI_Write) &&
(pfi->pbufCur->ibCur > pfi->pbufCur->ibLast)) {
pfi->pbufCur->ibLast = pfi->pbufCur->ibCur;
}
assert((ibFile - pfi->pbufCur->ibStart) < cbIOBuf);
assert(pfi->ifi == pfi->pbufCur->ifi);
#if DBG
assert(FBufListCheck());
#endif
// update LRU list
MoveToHeadLRU(pfi->pbufCur);
#if DBG
assert(FBufListCheck());
#endif
return (ibFile);
}
LONG
FileSeek (
INT fd,
LONG ib,
INT origin
)
/*++
Routine Description:
Seeks a file. Prints an error if can't seek file.
Arguments:
fd - fd in which file was open.
ib - Number of bytes to seek.
origin - SEEK_SET, SEEK_CUR, or SEEK_END.
Return Value:
Same as lseek().
--*/
{
#if 0
if (fCtrlCSignal) {
BadExitCleanup();
}
#endif
if (rgpfi[fd]->flags & FI_Mapped) {
return (MappedSeek(rgpfi[fd], ib, origin));
}
return(BufferedSeek(rgpfi[fd], ib, origin));
}
LONG
FileLength (
INT fd
)
/*++
Routine Description:
Returns a file's length in bytes.
Arguments:
fd - handle in which file was open.
Return Value:
Number of bytes in file.
--*/
{
LONG cbFile;
LONG ibHere;
#if 0
if (fCtrlCSignal) {
BadExitCleanup();
}
#endif
// save current file pointer
ibHere = FileSeek(fd, 0L, SEEK_CUR);
// seek to the end of the file
cbFile = FileSeek(fd, 0L, SEEK_END);
// if where we are now is not the end of the file,
// set us back to where we were originally
if (cbFile != ibHere) {
FileSeek(fd, ibHere, SEEK_SET);
}
// return the size
return(cbFile);
}
STATIC DWORD
BufferedRead (
PFI pfi,
PVOID pvBuf,
DWORD cb)
/*++
Routine Description:
Read file which is buffered.
Arguments:
pvBuf - buffer to read into
cb - number of bytes to read
Return Value:
number of bytes read
--*/
{
LONG cbLeft;
LONG cbRead;
PVOID pvT = pvBuf;
assert(pfi);
assert(pfi->flags & FI_Read);
assert(pvBuf);
assert(pfi->pbufCur);
DBEXEC(DB_IO_READ,
Trans_LOG(LOG_BufRead, pfi->ifi, pfi->pbufCur->ibCur, cb, 0, NULL));
// check for reading past end of file
if ((pfi->pbufCur->ibCur + cb) > (DWORD)pfi->cbMap) {
cb = pfi->cb - pfi->pbufCur->ibCur;
}
// perform the read
for(cbLeft = cb;
cbLeft;
cbLeft -= cbRead, pvBuf = (PVOID) ((PCHAR) pvBuf + cbRead)) {
assert(pfi->ifi == pfi->pbufCur->ifi);
// check if buffer is random, if so read in the buffer
if (pfi->pbufCur->flags & BUF_Random) {
ReadpbufCur(pfi);
}
// bytes to read is the minimum of the total bytes to read or the
// bytes in the buffer
cbRead = min(cbLeft, pfi->pbufCur->ibEnd - pfi->pbufCur->ibCur);
// These asserts are not valid for os/2 (segment will change to ???)
assert((LONG) (pfi->pbufCur->pbCur) <
(LONG) ((LONG) (pfi->pbufCur->rgbBuf) + (LONG) (cbIOBuf)));
assert((LONG) pvBuf < (LONG) ((LONG) pvT + (LONG) cb));
assert((cbRead <= pfi->pbufCur->ibLast - pfi->pbufCur->ibStart) ||
(pfi->pbufCur->flags & BUF_PreviousWrite) ||
(pfi->pbufCur->flags & BUF_Active));
assert((DWORD) cbRead <= cb);
memcpy(pvBuf, pfi->pbufCur->pbCur, (DWORD) cbRead);
// adjust buffer pointers
pfi->pbufCur->ibCur += cbRead;
pfi->pbufCur->pbCur += cbRead;
if (pfi->pbufCur->ibCur == pfi->pbufCur->ibEnd) {
SlidePbufCur(pfi);
}
}
#if DBG
assert(FBufListCheck());
#endif
return (cb);
}
DWORD
FileRead (
INT fd,
PVOID pvBuf,
DWORD cb)
/*++
Routine Description:
Reads a file. Prints an error if can't read file.
Arguments:
fd - fd in which file was open.
pvBuf - Location to receive bytes.
cb - Number of bytes to read into Buffer.
Return Value:
Same as read().
--*/
{
#if 0
if (fCtrlCSignal) {
BadExitCleanup();
}
#endif
if (rgpfi[fd]->flags & FI_Mapped) {
return (MappedRead(rgpfi[fd], pvBuf, cb));
}
return(BufferedRead(rgpfi[fd], pvBuf, cb));
}
DWORD
FileTell (
INT fd
)
/*++
Routine Description:
Give position of file pointer.
Arguments:
fd - file handle
Return Value:
position of file pointer
--*/
{
#if 0
if (fCtrlCSignal) {
BadExitCleanup();
}
#endif
if (rgpfi[fd]->flags & FI_Mapped) {
return (rgpfi[fd]->ibCur);
} else {
assert(rgpfi[fd]);
assert(rgpfi[fd]->pbufCur);
return (rgpfi[fd]->pbufCur->ibCur);
}
}
STATIC DWORD
BufferedWrite (
PFI pfi,
const void *pvBuf,
DWORD cb)
/*++
Routine Description:
Write to a buffer if possible, otherwise write to low io.
Arguments:
pvBuf - buffer for bytes to write
cb - count of bytes
Return Value:
number of bytes written
--*/
{
const void *pvT;
LONG cbLeft;
LONG cbWrite;
assert(pfi);
assert(pfi->flags & FI_Write);
assert(pfi->pbufCur);
assert(pfi->ifi == pfi->pbufCur->ifi);
assert(pvBuf);
// writes of zero bytes don't do anything
if (!cb) {
return (cb);
}
// check if we need to grow the buffer map table
while ((pfi->pbufCur->ibCur + (LONG) cb) >= pfi->cbMap) {
GrowMapTable(pfi);
}
DBEXEC(DB_IO_WRITE,
Trans_LOG(LOG_BufWrite, pfi->ifi, pfi->pbufCur->ibCur, cb, 0, NULL));
pvT = pvBuf;
// mark the buffer as dirty
pfi->pbufCur->flags |= BUF_Dirty;
// perform the write
for(cbLeft = cb;
cbLeft;
cbLeft -= cbWrite, pvBuf = (PVOID) ((PCHAR) pvBuf + cbWrite)) {
assert(pfi->ifi == pfi->pbufCur->ifi);
// bytes to write is the minimum of the bytes to write or the
// bytes that fit in the buffer
cbWrite = min(cbLeft, pfi->pbufCur->ibEnd - pfi->pbufCur->ibCur);
assert((LONG) (pfi->pbufCur->pbCur) <
(LONG) ((LONG) (pfi->pbufCur->rgbBuf) + (LONG) (cbIOBuf)));
assert((LONG) pvBuf < (LONG) ((LONG) pvT + (LONG) cb));
assert((DWORD) cbWrite <= cb);
memcpy(pfi->pbufCur->pbCur, pvBuf, (DWORD) cbWrite);
// adjust buffer pointers
pfi->pbufCur->ibCur += cbWrite;
pfi->pbufCur->pbCur += cbWrite;
// update highest valid buffer write
if (pfi->pbufCur->ibCur > pfi->pbufCur->ibLast) {
pfi->pbufCur->ibLast = pfi->pbufCur->ibCur;
}
if (pfi->pbufCur->ibCur == pfi->pbufCur->ibEnd) {
SlidePbufCur(pfi);
}
if (cbLeft) {
pfi->pbufCur->flags |= BUF_Dirty;
}
}
#if DBG
assert(FBufListCheck());
#endif
return (cb);
}
STATIC VOID
ReadpbufCur(
PFI pfi)
/*++
Routine Description:
Read in a buffer from disk.
Arguments:
None.
Return Value:
None.
--*/
{
LONG cbReRead;
LONG ibSeek;
LONG cbRead;
assert(pfi);
assert(pfi->pbufCur);
assert(pfi->pbufCur->ibStart <= pfi->cbSoFar);
assert(pfi->ifi == pfi->pbufCur->ifi);
// seek to buffer region on disk
if ((ibSeek = (LONG)_lseek(pfi->fd,
pfi->pbufCur->ibStart, SEEK_SET)) == -1L) {
Error(ERR_INVALIDEXE, NULL, NULL);
}
assert(ibSeek == pfi->pbufCur->ibStart);
// calculate bytes to read
cbReRead = min(cbIOBuf, pfi->cbSoFar - pfi->pbufCur->ibStart);
assert((pfi->pbufCur->ibStart + cbReRead) <= pfi->cbSoFar);
// read in buffer
if ((cbRead = _read(pfi->fd, pfi->pbufCur->rgbBuf,
(DWORD) cbReRead)) != cbReRead) {
Error(ERR_INVALIDEXE, NULL, NULL);
}
// set the buffer to not containing random bits
pfi->pbufCur->flags &= ~BUF_Random;
}
STATIC VOID
SlidePbufCur(
PFI pfi)
/*++
Routine Description:
Slide down the current buffer in a file one region. Write the contents
of the buffer to disk if the buffer was written to and the file was
opened as writeable. Read the contents of the buffer from disk if the
file was readable.
Arguments:
pfi - file descriptor of file to slide current buffer in
Return Value:
None.
--*/
{
PBUF pbuf;
LONG ibuf;
PPBUF rgpbuf;
#if DBG
BOOL f;
#endif // DBG
assert(pfi);
assert(pfi->pbufCur);
assert(pfi->rgpbuf);
assert(pfi->ifi == pfi->pbufCur->ifi);
DBEXEC(
DB_BUFVERBOSE,
DBPRINT(" - slide pbuf = 0x%p from 0x%8lX to 0x%8lX in %s\n",
pfi->pbufCur, pfi->pbufCur->ibStart,
pfi->pbufCur->ibStart + 0x1000, pfi->szFileName));
// get buffer table entry
ibuf = pfi->pbufCur->ibStart >> cshiftBuf;
assert(((ibuf + 1) * cbIOBuf) < (pfi->cbMap));
// get the buffer table
rgpbuf = pfi->rgpbuf;
assert(rgpbuf[ibuf]);
pbuf = rgpbuf[ibuf + 1];
if ((pbuf == NULL) || (pbuf == pbufPreviousWrite)) {
// flush the current buffer, if the buffer is not dirty
// FlushBuffer will not write anything
FlushBuffer(pfi->pbufCur);
// move the buffer along in the buffer table
rgpbuf[ibuf + 1] = pfi->pbufCur;
// set the buffers new range
pfi->pbufCur->ibStart += cbIOBuf;
pfi->pbufCur->ibEnd += cbIOBuf;
pfi->pbufCur->ibLast = pfi->pbufCur->ibStart;
// set the buffer to containing random bits
// HELP: this might have to be done for !FI_Write only
if (!(pfi->flags & FI_Write)) {
pfi->pbufCur->flags |= BUF_Random;
}
// if the file has been previously written to at this range
// then read in buffer
if (pbuf == pbufPreviousWrite) {
ReadpbufCur(pfi);
crereads++;
DBEXEC(DB_BUFVERBOSE,
DBPRINT("re-read @%0x\n", pfi->pbufCur->ibStart));
// set the buffer to previously written out
pfi->pbufCur->flags |= BUF_PreviousWrite;
}
} else {
// we ran into an existing buffer, deactivate the current
// buffer, this causes the buffer to be flushed and updates
// the buffer table
assert(pfi->pbufCur->flags & BUF_Current);
pfi->pbufCur->flags &= ~BUF_Current;
#if DBG
f =
#endif //DBG
FDeactivateBuf(pfi->pbufCur);
assert(f);
// set the current buffer to the one we ran into,
// this assumes there will be no more writes to the
// previous file offset in this buffer
assert(((ibuf + 1) * cbIOBuf) <= pfi->cbMap);
pfi->pbufCur = rgpbuf[ibuf + 1];
assert(!(pfi->pbufCur->flags & BUF_Current));
pfi->pbufCur->flags |= BUF_Current;
}
// set the current offsets to the beginning of the buffer
pfi->pbufCur->ibCur = pfi->pbufCur->ibStart;
pfi->pbufCur->pbCur = pfi->pbufCur->rgbBuf;
assert(pfi->ifi == pfi->pbufCur->ifi);
}
DWORD
FileWrite (
INT fd,
void *pvBuf,
DWORD cb)
/*++
Routine Description:
Write a file. Prints an error if can't write file.
Arguments:
fd - file handle
pvBuf - location to receive bytes
cb - number of bytes to write from pvBuf
Return Value:
Same as write().
--*/
{
#if 0
if (fCtrlCSignal) {
BadExitCleanup();
}
#endif
if (rgpfi[fd]->flags & FI_Mapped) {
return (MappedWrite(rgpfi[fd], pvBuf, cb));
}
return(BufferedWrite(rgpfi[fd], pvBuf, cb));
}
STATIC VOID
MoveToHeadLRU(
PBUF pbuf
)
/*++
Routine Description:
Move a buffer to the head of the LRU chain.
Arguments:
pbuf - buffer to move to the head of the LRU chain
Return Value:
None.
--*/
{
BOOL fActive = 0;
PBUF pbufT;
assert(pbuf);
for (pbufT = pbufLRUHead;
pbufT && (pbufT != pbuf);
pbufT = pbufT->pbufLRURight);
// delete old links if the buffer is active
if (pbufT) {
assert(pbuf->flags & BUF_Active);
if (pbuf->pbufLRULeft) {
// left entry is not head
pbuf->pbufLRULeft->pbufLRURight = pbuf->pbufLRURight;
} else {
// left entry is head
pbufLRUHead = pbuf->pbufLRURight;
}
if (pbuf->pbufLRURight) {
// right entry is not tail
pbuf->pbufLRURight->pbufLRULeft = pbuf->pbufLRULeft;
} else {
// right entry is tail
pbufLRUTail = pbuf->pbufLRULeft;
}
}
// set the new LRU links
if ((!pbufLRUHead) && (!pbufLRUTail)) {
// add to empty list case
pbufLRUHead = pbuf;
pbufLRUTail = pbuf;
pbuf->pbufLRURight = NULL;
pbuf->pbufLRULeft = NULL;
} else {
// add to non-empty list
pbuf->pbufLRURight = pbufLRUHead;
pbuf->pbufLRULeft = NULL;
pbufLRUHead->pbufLRULeft = pbuf;
pbufLRUHead = pbuf;
}
}
STATIC PBUF
PbufLRU(
VOID)
/*++
Routine Description:
Return the LRU seeked buffer which isn't any PFI's current buffer.
Arguments:
None.
Return Value:
Pointer a buffer.
--*/
{
PBUF pbuf;
assert(pbufLRUHead);
assert(pbufLRUTail);
// find the buffer
pbuf = pbufLRUTail;
while (pbuf) {
if (!(pbuf->flags & BUF_Current)) {
break;
} else {
pbuf = pbuf->pbufLRULeft;
}
}
assert(pbuf);
if (pbuf == pbufLRUTail) {
pbufLRUTail = pbuf->pbufLRULeft;
} else {
pbuf->pbufLRURight->pbufLRULeft = pbuf->pbufLRULeft;
}
if (pbuf == pbufLRUHead) {
pbufLRUHead = pbuf->pbufLRURight;
} else {
pbuf->pbufLRULeft->pbufLRURight = pbuf->pbufLRURight;
}
pbuf->pbufLRURight = NULL;
pbuf->pbufLRULeft = NULL;
return (pbuf);
}
STATIC BOOL
FActivateBuf(
PFI pfi,
PBUF pbuf
)
/*++
Routine Description:
Activate a buffer by removing the first buffer from the free list,
inserting it to the active list and setting its status to active.
Arguments:
pfi - file descriptor to bind buffer to
pbuf - buffer to activate
Return Value:
!0 on success, 0 otherwise
--*/
{
assert(pbuf);
assert(!(pbuf->flags & BUF_Active));
assert(pbuf->ifi = -1);
assert(!(pbuf->flags & BUF_Dirty));
// if no free bufferes, cannot activate a buffer
if (!pbufFree) {
return 0;
}
// removed buffer from free list
assert(pbuf == pbufFree);
pbufFree = pbuf->pbufNext;
// bind buffer to physical file handle
pbuf->ifi = pfi->ifi;
// make sure there isn't an active buffer on this range
#if DBG
assert(FNoDupBuf(pbuf));
#endif
// insert buffer into active list
pbuf->pbufNext = pbufActive;
pbufActive = pbuf;
assert(pbufActive);
// activate the buffer
pbuf->flags |= BUF_Active;
assert(
pfi->rgpbuf[pbuf->ibStart >> cshiftBuf] == NULL ||
pfi->rgpbuf[pbuf->ibStart >> cshiftBuf] == pbufPreviousWrite);
assert(pbuf->ibStart <= pfi->cbMap);
pfi->rgpbuf[pbuf->ibStart >> cshiftBuf] = pbuf;
DBEXEC(DB_BUFVERBOSE,
DBPRINT(" - activated pbuf = 0x%p at offset %8lX on file %s\n",
pbuf, pbuf->ibStart, pfi->szFileName));
// success
return 1;
}
STATIC BOOL
FDeactivateBuf(
PBUF pbuf
)
/*++
Routine Description:
Deactivate a buffer by flushing it, setting the buffer status to inactive,
deleting the buffer from the active list and adding the buffer to the
free list.
Arguments:
pbuf - buffer to deactivate
Return Value:
!0 on success, 0 otherwise
--*/
{
PBUF pbufT;
PBUF pbufLast;
assert(pbuf);
assert(pbuf->flags & BUF_Active);
assert(pbuf->ifi != -1);
assert(pbufActive);
assert(rgpfi[pbuf->ifi]);
assert(rgpfi[pbuf->ifi]->rgpbuf);
assert(rgpfi[pbuf->ifi]->rgpbuf[pbuf->ibStart >> cshiftBuf]);
assert(!(pbuf->flags & BUF_Current));
FlushBuffer(pbuf);
DBEXEC(DB_BUFVERBOSE,
DBPRINT(" - deactivated pbuf = 0x%p at offset %8lX on file %s\n",
pbuf, pbuf->ibStart, rgpfi[pbuf->ifi]->szFileName));
// make the buffer inactive
pbuf->flags = 0;
pbuf->ifi = -1;
// removed buffer from active list
if (pbufActive == pbuf) {
pbufActive = pbufActive->pbufNext;
} else {
pbufLast = pbufActive;
for (pbufT = pbufActive->pbufNext; pbufT; pbufT = pbufT->pbufNext) {
assert(pbufT);
if (pbuf == pbufT) {
pbufLast->pbufNext = pbufT->pbufNext;
break;
}
pbufLast = pbufT;
}
}
// add the buffer to the free list
pbuf->pbufNext = pbufFree;
pbufFree = pbuf;
// success
return 1;
}
STATIC PBUF
PbufNew(
VOID)
/*++
Routine Description:
Create a new buffer. Print an error if we run out of memory.
Arguments:
None.
Return Value:
pointer to a buffer
--*/
{
PBUF pbuf;
// allocate the buffer structure
pbuf = (PBUF) PvAllocZ(sizeof(BUF));
pbuf->ifi = -1;
assert(pbuf);
return (pbuf);
}
STATIC PBUF
PbufAlloc(
PFI pfi,
LONG ib)
/*++
Routine Description:
Allocate a new buffer. Print an error if we run out of memory.
Arguments:
pfi - file descriptor to bind buffer to
ib - file offset to map buffer to
Return Value:
pointer to a buffer
--*/
{
PBUF pbuf;
#if DBG
BOOL f;
#endif //DBG
assert(FBufListCheck());
// get a buffer from the free list
pbuf = pbufFree;
// if no free buffers
if (!pbuf) {
// get LRU seeked buffer
pbuf = PbufLRU();
// this assumes more > 0 buffers in the system
assert(pbuf);
// deactivate buffer
#if DBG
f =
#endif // DBG
FDeactivateBuf(pbuf);
assert(f);
}
assert(pbuf);
// set the buffer range
pbuf->ibStart = (ib / cbIOBuf) * cbIOBuf;
pbuf->ibEnd = pbuf->ibStart + cbIOBuf;
pbuf->ibCur = ib;
pbuf->ibLast = pbuf->ibStart;
assert((ib >= pbuf->ibStart) && (ib <= pbuf->ibEnd));
pbuf->pbCur = (BYTE *) ((LONG) pbuf->rgbBuf + (ib - pbuf->ibStart));
// if file is writable, clear the buffer
if (pfi->flags & FI_Write) {
memset(pbuf->rgbBuf, '\0', cbIOBuf);
}
// if file is readable, set the random contents flag
if (!(pfi->flags & FI_Write)) {
pbuf->flags |= BUF_Random;
}
// activate buffer
#if DBG
f =
#endif // DBG
FActivateBuf(pfi, pbuf);
assert(f);
assert(FBufListCheck());
// return the buffer
return (pbuf);
}
STATIC VOID
TransitionPFI(
PFI pfi,
PPFI ppfiFromHead,
PPFI ppfiFromTail,
PPFI ppfiToHead,
PPFI ppfiToTail,
BOOL fAddToTail)
/*++
Routine Description:
Move a logical file descriptor from one pool to another.
Arguments:
pfi - logical file descriptor to move
ppfiFromHead - head of pool to remove pfi from
ppfiFromTail - tail of pool to remove pfi from, update if ppfiFromTail
ppfiToHead - head of pool to put pfi in
ppfiToTail - tail of pool to put pfi in, update if ppfiToTail
fAddToTail - add pfi to tail of ppfiTo
Return Value:
!0 on success, 0 otherwise
--*/
{
PFI pfiT; // current
PFI pfiL; // last
assert(pfi);
assert(ppfiFromHead);
assert(ppfiToHead);
#if DBG
assert(FPfiInList(pfi, *ppfiFromHead));
assert(!FPfiInList(pfi, *ppfiToHead));
#endif // DBG
// remove pfi from ppfiFromHead
if (pfi == *ppfiFromHead) {
// pfi is the first element
*ppfiFromHead = (*ppfiFromHead)->pfiNext;
if (ppfiFromTail && ((*ppfiFromTail) == pfi)) {
*ppfiFromTail = NULL;
}
} else {
pfiL = *ppfiFromHead;
for (pfiT = (*ppfiFromHead)->pfiNext; pfiT; pfiT = pfiT->pfiNext) {
if (pfi == pfiT) {
pfiL->pfiNext = pfiT->pfiNext;
break;
} else {
pfiL = pfiT;
}
}
if (ppfiFromTail && ((*ppfiFromTail) == pfi)) {
*ppfiFromTail = pfiL;
}
}
// add pfi to ppfiTo
if (!(*ppfiToHead)) {
// list is empty
*ppfiToHead = pfi;
pfi->pfiNext = NULL;
if (ppfiToTail) {
assert(!(*ppfiToTail));
*ppfiToTail = pfi;
}
} else {
if (fAddToTail) {
// add pfi to tail
assert(ppfiToTail);
pfi->pfiNext = NULL;
(*ppfiToTail)->pfiNext = pfi;
*ppfiToTail = pfi;
} else {
pfi->pfiNext = *ppfiToHead;
*ppfiToHead = pfi;
}
}
}
#if DBG
STATIC BOOL
FBufListCheck(
VOID)
/*++
Routine Description:
Check the active, free and LRU list for errors. This is a debug routine.
Arguments:
None.
Return Value:
None.
--*/
{
PBUF pbuf;
LONG cbuf;
// ensure the correct number of buffers in the lists
for(cbuf = 0, pbuf = pbufFree;
pbuf && cbuf < cbufTot;
pbuf = pbuf->pbufNext) {
cbuf++;
}
for(pbuf = pbufActive;
pbuf && cbuf < cbufTot;
pbuf = pbuf->pbufNext) {
cbuf++;
}
if (cbuf != cbufTot) {
return (0);
}
// walk down the LRU list counting members, walk back and see
// if we get to the same place
for(cbuf = 0, pbuf = pbufLRUHead;
pbuf && cbuf < cbufTot;
pbuf = pbuf->pbufLRURight) {
cbuf++;
}
for(pbuf = pbufLRUTail;
pbuf && cbuf > 0;
pbuf = pbuf->pbufLRULeft) {
cbuf--;
}
if (cbuf == 0) {
return (1);
} else {
return (0);
}
}
#endif // DBG
#if DBG
STATIC BOOL
FNoDupBuf(
PBUF pbuf)
/*++
Routine Description:
Scan the active list to see if pbuf's range is covered by another buffer.
Arguments:
pbuf - buffer to check for duplicates ranges of
Return Value:
!0 if no duplicates, 0 if duplicates
--*/
{
PBUF pbufT;
assert(pbuf);
for (pbufT = pbufActive; pbufT; pbufT = pbufT->pbufNext) {
assert(pbufT);
if ((pbuf->ifi == pbufT->ifi) &&
(pbuf->ibStart == pbufT->ibStart)) {
return 0;
}
}
return 1;
}
#endif // DBG
#if DBG
STATIC BOOL
FPfiInList(
PFI pfi,
PFI pfiList)
/*++
Routine Description:
Check if pfi is in pfiList.
Arguments:
pfi - logical file descriptor to check for
pfiList - list to look for logical file descriptor in
Return Value:
!0 if found, 0 if not found
--*/
{
PFI pfiT;
LONG ifi = 0;
for (pfiT = pfiList, ifi = 0; pfiT; pfiT = pfiT->pfiNext, ifi++) {
if (pfiT == pfi) {
return (1);
}
if (ifi > cfiTot) {
assert(0);
return (0);
}
}
return (0);
}
#endif // DBG
#if DBG
STATIC BOOL
FPfiCheck(
VOID)
/*++
Routine Description:
Check the pfi lists.
Arguments:
None.
Return Value:
!0 if found, 0 if not found
--*/
{
LONG ifi = 0;
PFI pfi;
pfi = pfiFree;
while (pfi) {
ifi++;
if (ifi > cfiTot) {
return (0);
}
pfi = pfi->pfiNext;
}
pfi = pfiOpen;
while (pfi) {
ifi++;
if (ifi > cfiTot) {
return (0);
}
if (!(pfi->flags & FI_Mapped) && pfi->pbufCur != NULL) {
if (pfi->ifi != pfi->pbufCur->ifi) {
return (0);
}
}
pfi = pfi->pfiNext;
}
pfi = pfiClosedHead;
while (pfi) {
ifi++;
if (ifi > cfiTot) {
return (0);
}
if (!(pfi->flags & FI_Mapped) && pfi->pbufCur != NULL) {
if (pfi->ifi != pfi->pbufCur->ifi) {
return (0);
}
}
pfi = pfi->pfiNext;
}
if (cfiTot == ifi) {
return (1);
} else {
return (0);
}
}
#endif // DBG
INT
MappedOpen(
PFI pfi,
LONG flags,
BOOL fNewPfi)
/*++
Routine Description:
NT mapped i/o open.
Arguments:
pfi - logical file descriptor
flags - flags to open file with
fNewPfi - !0 if pfi is new
Return Value:
0 on success, !0 otherwise
--*/
{
BOOL fWriteable, fCreate;
int i;
DWORD dwSize;
if (fNewPfi) {
// open the file through win32
fWriteable = flags & (O_WRONLY | O_RDWR);
fCreate = flags & O_CREAT;
if (fWriteable) {
for (i = 0; i < MAX_WRITEABLE_FILES; i++) {
if (pfiCloseOnBadExit[i] == NULL) {
pfiCloseOnBadExit[i] = pfi;
break;
}
}
pfi->hFile = CreateFile(pfi->szFileName,
GENERIC_READ | GENERIC_WRITE, // access
0, // share
NULL, // security
fCreate ? CREATE_ALWAYS : OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
} else {
assert(!fCreate); // no read-only create
pfi->hFile = CreateFile(pfi->szFileName,
GENERIC_READ, // access
FILE_SHARE_READ, // share
NULL, // security
OPEN_EXISTING,
0,
NULL);
}
// abort on error
if (pfi->hFile == INVALID_HANDLE_VALUE) {
pfi->hFile = NULL;
return (-1);
}
if (!fCreate) {
dwSize = GetFileSize(pfi->hFile, NULL);
if (dwSize == 0xFFFFFFFF) {
Error(ERR_INVALIDEXE, NULL, NULL);
}
}
if (fWriteable) {
pfi->cbSoFar = fCreate ? 0 : dwSize;
if (!pfi->cbMapView) { // set in the case of FileOpenMapped()
pfi->cbMapView = max(cbMapViewDefault, pfi->cbSoFar);
}
} else {
pfi->cbMapView = pfi->cbSoFar = dwSize;
}
if (!FMapPfi(pfi)) {
return -1;
}
pfi->flags |= FI_Mapped;
} else {
MappedSeek(pfi, 0, SEEK_SET);
}
return 0;
}
LONG
MappedSeek(
PFI pfi,
LONG ib,
INT origin)
/*++
Routine Description:
NT mapped i/o seek.
Arguments:
pfi - logical file descriptor
if - offset
origin - type of seek
Return Value:
offset seek to
--*/
{
switch (origin) {
#if DBG
default:
assert(0);
break;
#endif
case SEEK_CUR:
assert((pfi->ibCur + ib) >= 0 );
pfi->ibCur += ib;
break;
case SEEK_END:
assert(pfi->cbSoFar + ib >= 0);
pfi->ibCur = pfi->cbSoFar + ib;
break;
case SEEK_SET:
assert(ib >= 0 );
pfi->ibCur = ib;
break;
}
if (pfi->ibCur > pfi->cbMapView) {
if (!ExtendMapView(pfi, pfi->ibCur)) {
if (pfi->MapAddr == 0) {
Error(ERR_NOSPACE, NULL, NULL);
}
return(-1);
}
}
DBEXEC(DB_IO_SEEK,
Trans_LOG(LOG_MapSeek, pfi->ifi, ib, 0, origin, NULL));
return(pfi->ibCur);
}
STATIC DWORD
MappedRead(
PFI pfi,
PVOID pv,
DWORD cb)
/*++
Routine Description:
NT mapped i/o read.
Arguments:
pfi - logical file descriptor
pv - buffer to read into
cb - bytes to read
Return Value:
bytes read
--*/
{
PVOID pvT;
assert(pfi);
assert(pv);
DBEXEC(DB_IO_READ,
Trans_LOG(LOG_MapRead, pfi->ifi, pfi->ibCur, cb, 0, NULL));
// extend map view only for writeable files
if ((pfi->ibCur + (LONG) cb) > pfi->cbMapView) {
if (pfi->flags & FI_Write) {
if (!ExtendMapView(pfi, pfi->ibCur + (LONG) cb)) {
Error(ERR_NOSPACE, NULL, NULL);
}
} else {
return(0);
}
}
pvT = (PVOID) ((DWORD) (pfi->pvMapView) + (DWORD) (pfi->ibCur));
memcpy(pv, pvT, cb);
pfi->ibCur += cb;
return(cb);
}
/*++
Routine Description:
NT mapped i/o tell.
Arguments:
pfi - logical file descriptor
Return Value:
file offset
--*/
STATIC DWORD
MappedWrite(
PFI pfi,
const void *pv,
DWORD cb)
{
PVOID pvT;
assert(pfi);
DBEXEC(DB_IO_WRITE,
Trans_LOG(LOG_MapWrite, pfi->ifi, pfi->ibCur, cb, 0, NULL));
if ((pfi->ibCur + (LONG) cb) > pfi->cbMapView) {
if (!ExtendMapView(pfi, pfi->ibCur + cb)) {
Error(ERR_NOSPACE, NULL, NULL);
}
}
pvT = (PVOID) ((DWORD) (pfi->pvMapView) + (DWORD) (pfi->ibCur));
if ((pfi->ibCur + (LONG) cb) > pfi->cbSoFar) {
pfi->cbSoFar = pfi->ibCur + (LONG) cb;
}
memcpy(pvT, pv, cb);
pfi->ibCur += cb;
return (cb);
}
INT
MappedCloseHard (
PFI pfi)
/*++
Routine Description:
NT mapped i/o hard close.
Arguments:
pfi - logical file descriptor
Return Value:
file offset
--*/
{
INT i, retval;
assert(pfi);
assert(pfi->flags & FI_Mapped);
#if 1
// UNDONE: UnmapViewOfFile is very expensive on NT. It forces a
// UNDONE: synchronous flush of the dirty pages to disk. By not
// UNDONE: calling the API, the data is written by the lazy writer.
UnmapViewOfFile(pfi->pvMapView);
#endif
if (pfi->flags & FI_Write) {
// If writeable, set the end of file pointer to the last place we
// wrote. This prevents the file from being created with the full
// size of the mapping.
SetFilePointer(pfi->hFile, pfi->cbSoFar, NULL, FILE_BEGIN);
SetEndOfFile(pfi->hFile);
}
retval = CloseHandle(pfi->hFile);
for (i = 0; i < MAX_WRITEABLE_FILES; i++) {
if (pfi == pfiCloseOnBadExit[i])
pfiCloseOnBadExit[i] = NULL;
}
FreePv(pfi->szFileName);
return (retval);
}
BOOL
ExtendMapView(PFI pfi, DWORD ibNeeded)
// Makes the memory-map bigger for a mapped file. This only makes sense
// for writeable files, not readable files.
{
#if 1
{
#else
if (pfi->MapAddr != 0) {
#endif
// UNDONE: UnmapViewOfFile is very expensive on NT. It forces a
// UNDONE: synchronous flush of the dirty pages to disk. By not
// UNDONE: calling the API, the data is written by the lazy writer.
// Free the existing map.
UnmapViewOfFile(pfi->pvMapView);
}
// Set the new size (it must grow by at least a factor of 2).
pfi->cbMapView = max((LONG) ibNeeded, pfi->cbMapView * 2);
if (!FMapPfi(pfi)) {
return FALSE;
}
return TRUE;
}
BOOL
FMapPfi(PFI pfi)
{
HANDLE hMap;
if (pfi->flags & FI_Write) {
// Extend file to size specified. This works around a problem in
// NT 3.10 where the cache isn't flushed to disk properly.
SetFilePointer(pfi->hFile, pfi->cbMapView, NULL, FILE_BEGIN);
SetEndOfFile(pfi->hFile);
}
hMap = CreateFileMapping(pfi->hFile,
NULL,
(pfi->flags & FI_Write)
? PAGE_READWRITE
: PAGE_READONLY,
0,
pfi->cbMapView,
NULL);
if (hMap == NULL) {
CloseHandle(pfi->hFile);
pfi->hFile = NULL;
return FALSE;
}
pfi->pvMapView = MapViewOfFileEx(hMap,
(pfi->flags & FI_Write)
? FILE_MAP_ALL_ACCESS
: FILE_MAP_READ,
0,
0,
0,
(LPVOID) pfi->MapAddr);
// The handle to the mapping object isn't needed any more
CloseHandle(hMap);
if (!pfi->pvMapView) {
CloseHandle(pfi->hFile);
pfi->hFile = NULL;
return FALSE;
}
return TRUE;
}
VOID
BadExitCleanup(VOID)
// Warning ... may be called asynchronously by the control-C handler thread.
{
int i;
for (i = 0; i < MAX_WRITEABLE_FILES; i++) {
if (pfiCloseOnBadExit[i] != NULL) {
UnmapViewOfFile(pfiCloseOnBadExit[i]->pvMapView);
if (pfiCloseOnBadExit[i]->flags & FI_Write) {
// Set end of file to 0, this speeds up the close
SetFilePointer(pfiCloseOnBadExit[i]->hFile, 0, NULL, FILE_BEGIN);
SetEndOfFile(pfiCloseOnBadExit[i]->hFile);
}
CloseHandle(pfiCloseOnBadExit[i]->hFile);
DeleteFile(pfiCloseOnBadExit[i]->szFileName);
}
}
RemoveConvertTempFiles();
ExitProcess(1);
}
// PbMappedRegion: if possible, returns a pointer to a memory-mapped region
// of an open file. If the file is writeable, its size is extended to
// the end of the region if necessary.
//
// Returns NULL if mapping is not available.
//
// The "current position" in the file is not changed.
//
// Caveats:
// * caller must handle NULL return value
// * return value is invalidated by subsequent operations on the same
// file handle.
BYTE *
PbMappedRegion(INT fd, DWORD ibStart, DWORD cb)
{
PFI pfi;
pfi = rgpfi[fd];
if (!(pfi->flags & FI_Mapped)) {
return NULL;
}
DBEXEC(DB_IO_WRITE,
Trans_LOG(LOG_MapWrite, pfi->ifi, pfi->ibCur, cb, 0, NULL));
if (ibStart + cb > (DWORD)pfi->cbMapView) {
if (!ExtendMapView(pfi, ibStart + cb)) {
Error(ERR_NOSPACE, NULL, NULL);
}
}
if ((ibStart + cb) > (DWORD) pfi->cbSoFar) {
pfi->cbSoFar = ibStart + cb;
}
return (PUCHAR)pfi->pvMapView + ibStart;
}
VOID
FileSetSize (
INT fd
)
/*++
Routine Description:
This API is used in conjunction with Malloc() to set the
current size of file since the writes don't go through
the file API.
Arguments:
fd - hanlde to file
Return Value:
None
--*/
{
// file better be mapped
assert(rgpfi[fd]->flags & FI_Mapped);
// update cbSoFar
rgpfi[fd]->cbSoFar = rgpfi[fd]->ibCur;
}
VOID
FileCloseMap (
INT fd
)
/*++
Routine Description:
Closes the map and file without writing out anything.
Arguments:
fd - hanlde to file
Return Value:
None
--*/
{
#if 0
if (fCtrlCSignal) {
BadExitCleanup();
}
#endif
// file must be a mapped file
assert(rgpfi[fd]->flags & FI_Mapped);
// set the size to zero
rgpfi[fd]->cbSoFar = 0;
// remove pfi from open list
TR_Open_To_Free(rgpfi[fd]);
// close the map & file
MappedCloseHard(rgpfi[fd]);
}
Reference in New Issue View Git Blame Copy Permalink