27 changed files with 151 additions and 2838 deletions
File diff suppressed because it is too large
Load Diff
@ -1,518 +0,0 @@ |
|||||||
/*==LICENSE==*
|
|
||||||
|
|
||||||
CyanWorlds.com Engine - MMOG client, server and tools |
|
||||||
Copyright (C) 2011 Cyan Worlds, Inc. |
|
||||||
|
|
||||||
This program is free software: you can redistribute it and/or modify |
|
||||||
it under the terms of the GNU General Public License as published by |
|
||||||
the Free Software Foundation, either version 3 of the License, or |
|
||||||
(at your option) any later version. |
|
||||||
|
|
||||||
This program is distributed in the hope that it will be useful, |
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||||||
GNU General Public License for more details. |
|
||||||
|
|
||||||
You should have received a copy of the GNU General Public License |
|
||||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
|
|
||||||
Additional permissions under GNU GPL version 3 section 7 |
|
||||||
|
|
||||||
If you modify this Program, or any covered work, by linking or |
|
||||||
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
||||||
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
||||||
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
||||||
(or a modified version of those libraries), |
|
||||||
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
||||||
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
||||||
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
||||||
licensors of this Program grant you additional |
|
||||||
permission to convey the resulting work. Corresponding Source for a |
|
||||||
non-source form of such a combination shall include the source code for |
|
||||||
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
||||||
work. |
|
||||||
|
|
||||||
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
|
||||||
or by snail mail at: |
|
||||||
Cyan Worlds, Inc. |
|
||||||
14617 N Newport Hwy |
|
||||||
Mead, WA 99021 |
|
||||||
|
|
||||||
*==LICENSE==*/ |
|
||||||
/*****************************************************************************
|
|
||||||
* |
|
||||||
* $/Plasma20/Sources/Plasma/NucleusLib/pnAsyncCoreExe/Private/W9x/pnAceW9xFile.cpp |
|
||||||
*
|
|
||||||
***/ |
|
||||||
|
|
||||||
#include "../../Pch.h" |
|
||||||
#pragma hdrstop |
|
||||||
|
|
||||||
#include "pnAceW9xInt.h" |
|
||||||
|
|
||||||
|
|
||||||
namespace W9x { |
|
||||||
|
|
||||||
|
|
||||||
/****************************************************************************
|
|
||||||
* |
|
||||||
* FileOp |
|
||||||
* |
|
||||||
***/ |
|
||||||
|
|
||||||
struct FileOp { |
|
||||||
EAsyncNotifyFile code; |
|
||||||
bool notify; |
|
||||||
union { |
|
||||||
AsyncNotifyFileFlush flush; |
|
||||||
AsyncNotifyFileRead read; |
|
||||||
AsyncNotifyFileSequence sequence; |
|
||||||
AsyncNotifyFileWrite write; |
|
||||||
} data; |
|
||||||
}; |
|
||||||
|
|
||||||
|
|
||||||
/****************************************************************************
|
|
||||||
* |
|
||||||
* CFile |
|
||||||
* |
|
||||||
***/ |
|
||||||
|
|
||||||
class CFile : public CThreadDispObject { |
|
||||||
private: |
|
||||||
CCritSect m_critSect; |
|
||||||
HANDLE m_handle; |
|
||||||
FAsyncNotifyFileProc m_notifyProc; |
|
||||||
void * m_userState; |
|
||||||
|
|
||||||
protected: |
|
||||||
void Complete (void * op, CCritSect * critSect, AsyncId asyncId); |
|
||||||
void Delete (void * op); |
|
||||||
|
|
||||||
public: |
|
||||||
CFile ( |
|
||||||
HANDLE handle, |
|
||||||
FAsyncNotifyFileProc notifyProc, |
|
||||||
void * userState |
|
||||||
); |
|
||||||
~CFile (); |
|
||||||
|
|
||||||
void Read ( |
|
||||||
uint64_t offset, |
|
||||||
void * buffer, |
|
||||||
unsigned bytes |
|
||||||
); |
|
||||||
|
|
||||||
void SetLastWriteTime (uint64_t lastWriteTime); |
|
||||||
|
|
||||||
void Truncate (uint64_t size); |
|
||||||
|
|
||||||
void Write ( |
|
||||||
uint64_t offset, |
|
||||||
const void * buffer, |
|
||||||
unsigned bytes |
|
||||||
); |
|
||||||
|
|
||||||
bool Seek (uint64_t offset, EFileSeekFrom from); |
|
||||||
}; |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
CFile::CFile ( |
|
||||||
HANDLE handle, |
|
||||||
FAsyncNotifyFileProc notifyProc, |
|
||||||
void * userState |
|
||||||
) : |
|
||||||
m_handle(handle), |
|
||||||
m_notifyProc(notifyProc), |
|
||||||
m_userState(userState) |
|
||||||
{ |
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
CFile::~CFile () { |
|
||||||
CloseHandle(m_handle); |
|
||||||
m_handle = INVALID_HANDLE_VALUE; |
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
void CFile::Complete (void * op, CCritSect * critSect, AsyncId asyncId) { |
|
||||||
FileOp * fileOp = (FileOp *)op; |
|
||||||
|
|
||||||
// Enter our local critical section and leave the global one
|
|
||||||
m_critSect.Enter(); |
|
||||||
critSect->Leave(); |
|
||||||
|
|
||||||
// Complete the operation
|
|
||||||
switch (fileOp->code) { |
|
||||||
|
|
||||||
case kNotifyFileFlush: { |
|
||||||
if (fileOp->data.flush.truncateSize != kAsyncFileDontTruncate) |
|
||||||
Truncate(fileOp->data.flush.truncateSize); |
|
||||||
BOOL result = FlushFileBuffers(m_handle); |
|
||||||
fileOp->data.flush.error = result ? kFileSuccess : AsyncGetLastFileError(); |
|
||||||
} |
|
||||||
break; |
|
||||||
|
|
||||||
case kNotifyFileRead: |
|
||||||
Read( |
|
||||||
fileOp->data.read.offset, |
|
||||||
fileOp->data.read.buffer, |
|
||||||
fileOp->data.read.bytes |
|
||||||
); |
|
||||||
break; |
|
||||||
|
|
||||||
case kNotifyFileWrite: |
|
||||||
Write( |
|
||||||
fileOp->data.write.offset, |
|
||||||
fileOp->data.write.buffer, |
|
||||||
fileOp->data.write.bytes |
|
||||||
); |
|
||||||
break; |
|
||||||
|
|
||||||
} |
|
||||||
|
|
||||||
// Leave our local critical section
|
|
||||||
m_critSect.Leave(); |
|
||||||
|
|
||||||
// Dispatch a completion notification
|
|
||||||
if (fileOp->notify) { |
|
||||||
fileOp->data.flush.asyncId = asyncId; |
|
||||||
m_notifyProc( |
|
||||||
(AsyncFile)this,
|
|
||||||
fileOp->code, |
|
||||||
&fileOp->data.flush, |
|
||||||
&m_userState |
|
||||||
); |
|
||||||
} |
|
||||||
|
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
void CFile::Delete (void * op) { |
|
||||||
FileOp * fileOp = (FileOp *)op; |
|
||||||
delete fileOp; |
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
void CFile::Read ( |
|
||||||
uint64_t offset, |
|
||||||
void * buffer, |
|
||||||
unsigned bytes |
|
||||||
) { |
|
||||||
|
|
||||||
// Seek to the start of the read
|
|
||||||
Seek(offset, kFileSeekFromBegin); |
|
||||||
|
|
||||||
// Perform the read
|
|
||||||
DWORD bytesRead; |
|
||||||
BOOL result = ReadFile( |
|
||||||
m_handle, |
|
||||||
buffer, |
|
||||||
bytes, |
|
||||||
&bytesRead, |
|
||||||
nil // overlapped
|
|
||||||
); |
|
||||||
|
|
||||||
// Handle errors
|
|
||||||
if (bytesRead != bytes) |
|
||||||
memset((uint8_t *)buffer + bytesRead, 0, bytes - bytesRead); |
|
||||||
if ( (!result && (GetLastError() != ERROR_IO_PENDING)) || |
|
||||||
(bytesRead != bytes) ) |
|
||||||
LogMsg(kLogFatal, "failed: ReadFile"); |
|
||||||
|
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
bool CFile::Seek (uint64_t offset, EFileSeekFrom from) { |
|
||||||
COMPILER_ASSERT(kFileSeekFromBegin == FILE_BEGIN); |
|
||||||
COMPILER_ASSERT(kFileSeekFromCurrent == FILE_CURRENT); |
|
||||||
COMPILER_ASSERT(kFileSeekFromEnd == FILE_END); |
|
||||||
|
|
||||||
LONG low = (LONG)(offset % 0x100000000ul); |
|
||||||
LONG high = (LONG)(offset / 0x100000000ul); |
|
||||||
uint32_t result = SetFilePointer(m_handle, low, &high, from); |
|
||||||
if ((result == (uint32_t)-1) && (GetLastError() != NO_ERROR)) { |
|
||||||
LogMsg(kLogFatal, "failed: SetFilePointer"); |
|
||||||
return false; |
|
||||||
} |
|
||||||
else |
|
||||||
return true; |
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
void CFile::SetLastWriteTime (uint64_t lastWriteTime) { |
|
||||||
COMPILER_ASSERT(sizeof(lastWriteTime) == sizeof(FILETIME)); |
|
||||||
SetFileTime(m_handle, nil, nil, (const FILETIME *)&lastWriteTime); |
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
void CFile::Truncate (uint64_t size) { |
|
||||||
ASSERT(size != kAsyncFileDontTruncate); |
|
||||||
|
|
||||||
if (Seek(size, kFileSeekFromBegin) && !SetEndOfFile(m_handle))
|
|
||||||
LogMsg(kLogFatal, "failed: SetEndOfFile"); |
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
void CFile::Write ( |
|
||||||
uint64_t offset, |
|
||||||
const void * buffer, |
|
||||||
unsigned bytes |
|
||||||
) { |
|
||||||
|
|
||||||
// Seek to the start of the write
|
|
||||||
Seek(offset, kFileSeekFromBegin); |
|
||||||
|
|
||||||
// Perform the write
|
|
||||||
DWORD bytesWritten; |
|
||||||
BOOL result = WriteFile( |
|
||||||
m_handle, |
|
||||||
buffer, |
|
||||||
bytes, |
|
||||||
&bytesWritten, |
|
||||||
nil // overlapped
|
|
||||||
); |
|
||||||
|
|
||||||
// Handle errors
|
|
||||||
if ( (!result && (GetLastError() != ERROR_IO_PENDING)) || |
|
||||||
(bytesWritten != bytes) ) { |
|
||||||
LogMsg(kLogFatal, "failed: WriteFile"); |
|
||||||
if (!result && (GetLastError() == ERROR_DISK_FULL)) { |
|
||||||
MessageBox(nil, "Disk full!", "Error", MB_ICONSTOP | MB_SYSTEMMODAL); |
|
||||||
// DebugDisableLeakChecking();
|
|
||||||
ExitProcess(1); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
/****************************************************************************
|
|
||||||
* |
|
||||||
* Exported functions |
|
||||||
* |
|
||||||
***/ |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
void W9xFileClose ( |
|
||||||
AsyncFile file,
|
|
||||||
uint64_t truncateSize |
|
||||||
) { |
|
||||||
|
|
||||||
// Dereference the object
|
|
||||||
CFile * object = (CFile *)file; |
|
||||||
|
|
||||||
// If requested, truncate the file
|
|
||||||
if (truncateSize != kAsyncFileDontTruncate) |
|
||||||
object->Truncate(truncateSize);
|
|
||||||
|
|
||||||
// Close the file object
|
|
||||||
object->Close(); |
|
||||||
|
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
AsyncId W9xFileCreateSequence ( |
|
||||||
AsyncFile file,
|
|
||||||
bool notify,
|
|
||||||
void * param |
|
||||||
) { |
|
||||||
|
|
||||||
// Dereference the object
|
|
||||||
CFile * object = (CFile *)file; |
|
||||||
|
|
||||||
// Queue an operation
|
|
||||||
FileOp * op = new FileOp; |
|
||||||
op->code = kNotifyFileSequence; |
|
||||||
op->notify = notify; |
|
||||||
op->data.flush.param = param; |
|
||||||
return object->Queue(op); |
|
||||||
|
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
AsyncId W9xFileFlushBuffers ( |
|
||||||
AsyncFile file,
|
|
||||||
uint64_t truncateSize, |
|
||||||
bool notify, |
|
||||||
void * param |
|
||||||
) { |
|
||||||
|
|
||||||
// Dereference the object
|
|
||||||
CFile * object = (CFile *)file; |
|
||||||
|
|
||||||
// Queue an operation
|
|
||||||
FileOp * op = new FileOp; |
|
||||||
op->code = kNotifyFileFlush; |
|
||||||
op->notify = notify; |
|
||||||
op->data.flush.param = param; |
|
||||||
op->data.flush.truncateSize = truncateSize; |
|
||||||
// op->data.flush.error filled in upon completion
|
|
||||||
return object->Queue(op); |
|
||||||
|
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
AsyncFile W9xFileOpen ( |
|
||||||
const wchar_t fullPath[], |
|
||||||
FAsyncNotifyFileProc notifyProc, |
|
||||||
EFileError * error, |
|
||||||
unsigned desiredAccess, |
|
||||||
unsigned openMode, |
|
||||||
unsigned shareModeFlags, |
|
||||||
void * userState, |
|
||||||
uint64_t * fileSize, |
|
||||||
uint64_t * fileLastWriteTime |
|
||||||
) { |
|
||||||
HANDLE fileHandle = CreateFileW( |
|
||||||
fullPath, |
|
||||||
desiredAccess, |
|
||||||
shareModeFlags, |
|
||||||
nil, // plSecurityAttributes
|
|
||||||
openMode, |
|
||||||
0, // attributeFlags
|
|
||||||
nil // hTemplateFile
|
|
||||||
); |
|
||||||
*error = AsyncGetLastFileError(); |
|
||||||
|
|
||||||
if (INVALID_HANDLE_VALUE == fileHandle) |
|
||||||
return nil; |
|
||||||
|
|
||||||
// don't allow users to open devices like "LPT1", etc.
|
|
||||||
if (GetFileType(fileHandle) != FILE_TYPE_DISK) { |
|
||||||
LogMsg(kLogFatal, "failed: !FILE_TYPE_DISK"); |
|
||||||
*error = kFileErrorFileNotFound; |
|
||||||
CloseHandle(fileHandle); |
|
||||||
return nil; |
|
||||||
} |
|
||||||
|
|
||||||
// Get the file size
|
|
||||||
DWORD sizeHi, sizeLo = GetFileSize(fileHandle, &sizeHi); |
|
||||||
if ((sizeLo == (DWORD) -1) && (NO_ERROR != GetLastError())) { |
|
||||||
*error = AsyncGetLastFileError(); |
|
||||||
LogMsg(kLogFatal, "failed: GetFileSize"); |
|
||||||
CloseHandle(fileHandle); |
|
||||||
return nil; |
|
||||||
} |
|
||||||
const uint64_t size = ((uint64_t) sizeHi << (uint64_t) 32) | (uint64_t) sizeLo; |
|
||||||
|
|
||||||
uint64_t lastWriteTime; |
|
||||||
ASSERT(sizeof(lastWriteTime) >= sizeof(FILETIME)); |
|
||||||
GetFileTime(fileHandle, nil, nil, (FILETIME *) &lastWriteTime); |
|
||||||
|
|
||||||
// Create a file object
|
|
||||||
CFile * object = new CFile( |
|
||||||
fileHandle, |
|
||||||
notifyProc, |
|
||||||
userState |
|
||||||
); |
|
||||||
|
|
||||||
// return out parameters
|
|
||||||
if (fileSize) |
|
||||||
*fileSize = size; |
|
||||||
if (fileLastWriteTime) |
|
||||||
*fileLastWriteTime = lastWriteTime; |
|
||||||
return (AsyncFile)object; |
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
AsyncId W9xFileRead ( |
|
||||||
AsyncFile file, |
|
||||||
uint64_t offset, |
|
||||||
void * buffer, |
|
||||||
unsigned bytes, |
|
||||||
unsigned flags, |
|
||||||
void * param |
|
||||||
) { |
|
||||||
|
|
||||||
// Dereference the object
|
|
||||||
CFile * object = (CFile *)file; |
|
||||||
|
|
||||||
// Perform synchronous operations immediately
|
|
||||||
if (flags & kAsyncFileRwSync) { |
|
||||||
object->Read(offset, buffer, bytes); |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
// Queue asynchronous operations
|
|
||||||
else { |
|
||||||
FileOp * op = new FileOp; |
|
||||||
op->code = kNotifyFileRead; |
|
||||||
op->notify = (flags & kAsyncFileRwNotify) != 0; |
|
||||||
op->data.read.param = param; |
|
||||||
op->data.read.offset = offset; |
|
||||||
op->data.read.buffer = (uint8_t *)buffer; |
|
||||||
op->data.read.bytes = bytes; |
|
||||||
return object->Queue(op); |
|
||||||
} |
|
||||||
|
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
void W9xFileSetLastWriteTime ( |
|
||||||
AsyncFile file,
|
|
||||||
uint64_t lastWriteTime |
|
||||||
) { |
|
||||||
|
|
||||||
// Dereference the object
|
|
||||||
CFile * object = (CFile *)file; |
|
||||||
|
|
||||||
// Set the file time
|
|
||||||
object->SetLastWriteTime(lastWriteTime); |
|
||||||
|
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
uint64_t W9xFileGetLastWriteTime ( |
|
||||||
const wchar_t fileName[] |
|
||||||
) { |
|
||||||
WIN32_FILE_ATTRIBUTE_DATA info; |
|
||||||
bool f = GetFileAttributesExW(fileName, GetFileExInfoStandard, &info); |
|
||||||
return f ? *((uint64_t *) &info.ftLastWriteTime) : 0; |
|
||||||
} |
|
||||||
|
|
||||||
//===========================================================================
|
|
||||||
AsyncId W9xFileWrite ( |
|
||||||
AsyncFile file, |
|
||||||
uint64_t offset, |
|
||||||
const void * buffer, |
|
||||||
unsigned bytes, |
|
||||||
unsigned flags, |
|
||||||
void * param |
|
||||||
) { |
|
||||||
|
|
||||||
// Dereference the object
|
|
||||||
CFile * object = (CFile *)file; |
|
||||||
|
|
||||||
// Perform synchronous operations immediately
|
|
||||||
if (flags & kAsyncFileRwSync) { |
|
||||||
object->Write(offset, buffer, bytes); |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
// Queue asynchronous operations
|
|
||||||
else { |
|
||||||
FileOp * op = new FileOp; |
|
||||||
op->code = kNotifyFileWrite; |
|
||||||
op->notify = (flags & kAsyncFileRwNotify) != 0; |
|
||||||
op->data.write.param = param; |
|
||||||
op->data.write.offset = offset; |
|
||||||
op->data.write.buffer = (uint8_t *)buffer; |
|
||||||
op->data.write.bytes = bytes; |
|
||||||
return object->Queue(op); |
|
||||||
} |
|
||||||
|
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
bool W9xFileSeek ( |
|
||||||
AsyncFile file, |
|
||||||
uint64_t distance, |
|
||||||
EFileSeekFrom from |
|
||||||
) { |
|
||||||
CFile * object = (CFile *)file; |
|
||||||
return object->Seek(distance, from); |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
} // namespace W9x
|
|
||||||
@ -1,478 +0,0 @@ |
|||||||
/*==LICENSE==*
|
|
||||||
|
|
||||||
CyanWorlds.com Engine - MMOG client, server and tools |
|
||||||
Copyright (C) 2011 Cyan Worlds, Inc. |
|
||||||
|
|
||||||
This program is free software: you can redistribute it and/or modify |
|
||||||
it under the terms of the GNU General Public License as published by |
|
||||||
the Free Software Foundation, either version 3 of the License, or |
|
||||||
(at your option) any later version. |
|
||||||
|
|
||||||
This program is distributed in the hope that it will be useful, |
|
||||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||||||
GNU General Public License for more details. |
|
||||||
|
|
||||||
You should have received a copy of the GNU General Public License |
|
||||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
|
|
||||||
Additional permissions under GNU GPL version 3 section 7 |
|
||||||
|
|
||||||
If you modify this Program, or any covered work, by linking or |
|
||||||
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
||||||
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
||||||
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
||||||
(or a modified version of those libraries), |
|
||||||
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
||||||
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
||||||
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
||||||
licensors of this Program grant you additional |
|
||||||
permission to convey the resulting work. Corresponding Source for a |
|
||||||
non-source form of such a combination shall include the source code for |
|
||||||
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
||||||
work. |
|
||||||
|
|
||||||
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
|
||||||
or by snail mail at: |
|
||||||
Cyan Worlds, Inc. |
|
||||||
14617 N Newport Hwy |
|
||||||
Mead, WA 99021 |
|
||||||
|
|
||||||
*==LICENSE==*/ |
|
||||||
/*****************************************************************************
|
|
||||||
* |
|
||||||
* $/Plasma20/Sources/Plasma/NucleusLib/pnAsyncCoreExe/pnAceLog.cpp |
|
||||||
*
|
|
||||||
***/ |
|
||||||
|
|
||||||
#include "Pch.h" |
|
||||||
#pragma hdrstop |
|
||||||
|
|
||||||
#if defined(PLASMA_EXTERNAL_RELEASE) |
|
||||||
// If this is an external build then don't write log files
|
|
||||||
#define ACELOG_NO_LOG_FILES |
|
||||||
#endif |
|
||||||
|
|
||||||
|
|
||||||
namespace AsyncLog { |
|
||||||
|
|
||||||
/****************************************************************************
|
|
||||||
* |
|
||||||
* Private |
|
||||||
* |
|
||||||
***/ |
|
||||||
|
|
||||||
static const unsigned kLogFlushMs = 10 * 1000; |
|
||||||
|
|
||||||
enum ELogType { |
|
||||||
#ifdef SERVER |
|
||||||
kLogTypeDebug, |
|
||||||
kLogTypePerf, |
|
||||||
kLogTypeError, |
|
||||||
#else |
|
||||||
kLogTypeDebug, |
|
||||||
#endif |
|
||||||
kNumLogTypes |
|
||||||
}; |
|
||||||
|
|
||||||
static bool s_breakOnErrors; |
|
||||||
static wchar_t s_directory[MAX_PATH]; |
|
||||||
static CCritSect s_logCrit[kNumLogTypes]; |
|
||||||
static char * s_logBuf[kNumLogTypes]; |
|
||||||
static unsigned s_logPos[kNumLogTypes]; |
|
||||||
static uint64_t s_logWritePos[kNumLogTypes]; |
|
||||||
static TimeDesc s_logTime[kNumLogTypes]; |
|
||||||
static unsigned s_logWriteMs[kNumLogTypes]; |
|
||||||
static AsyncFile s_logFile[kNumLogTypes]; |
|
||||||
static long s_opsPending; |
|
||||||
static bool s_running; |
|
||||||
static AsyncTimer * s_timer; |
|
||||||
|
|
||||||
static unsigned s_logSize[kNumLogTypes] = { |
|
||||||
#ifdef SERVER |
|
||||||
64 * 1024, |
|
||||||
64 * 1024, |
|
||||||
8 * 1024, |
|
||||||
#else |
|
||||||
64 * 1024, |
|
||||||
#endif |
|
||||||
}; |
|
||||||
|
|
||||||
static const wchar_t * s_logNameFmt[kNumLogTypes] = { |
|
||||||
#ifdef SERVER |
|
||||||
L"Dbg%02u%02u%02u.log", |
|
||||||
L"Inf%02u%02u%02u.log", |
|
||||||
L"Err%02u%02u%02u.log", |
|
||||||
#else |
|
||||||
L"%s%02u%02u%02u.log", |
|
||||||
#endif |
|
||||||
}; |
|
||||||
|
|
||||||
static ELogType s_logSeverityToType[kNumLogSeverity] = { |
|
||||||
#ifdef SERVER |
|
||||||
kLogTypeDebug, // kLogDebug
|
|
||||||
kLogTypePerf, // kLogPerf
|
|
||||||
kLogTypeError, // kLogError
|
|
||||||
kLogTypeError, // kLogFatal
|
|
||||||
#else |
|
||||||
kLogTypeDebug, // kLogDebug
|
|
||||||
kLogTypeDebug, // kLogPerf
|
|
||||||
kLogTypeDebug, // kLogError
|
|
||||||
kLogTypeDebug, // kLogFatal
|
|
||||||
#endif |
|
||||||
}; |
|
||||||
|
|
||||||
static char * s_logSeverityToText[kNumLogSeverity] = { |
|
||||||
"Debug", |
|
||||||
"Info", |
|
||||||
"Error", |
|
||||||
"Fatal", |
|
||||||
}; |
|
||||||
|
|
||||||
|
|
||||||
/****************************************************************************
|
|
||||||
* |
|
||||||
* Local functions |
|
||||||
* |
|
||||||
***/ |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
static void LogFileNotifyProc ( |
|
||||||
AsyncFile file, |
|
||||||
EAsyncNotifyFile code, |
|
||||||
AsyncNotifyFile * notify, |
|
||||||
void ** userState |
|
||||||
) { |
|
||||||
switch (code) { |
|
||||||
case kNotifyFileWrite: |
|
||||||
free(notify->param); |
|
||||||
AtomicAdd(&s_opsPending, -1); |
|
||||||
break; |
|
||||||
|
|
||||||
case kNotifyFileFlush: |
|
||||||
AsyncFileClose(file, kAsyncFileDontTruncate); |
|
||||||
AtomicAdd(&s_opsPending, -1); |
|
||||||
break; |
|
||||||
|
|
||||||
DEFAULT_FATAL(code); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
static void AllocLogBuffer_CS (unsigned index) { |
|
||||||
ASSERT(!s_logBuf[index]); |
|
||||||
s_logBuf[index] = (char *)malloc(s_logSize[index]); |
|
||||||
s_logPos[index] = 0; |
|
||||||
|
|
||||||
if (!s_logBuf[index]) |
|
||||||
ErrorAssert(__LINE__, __FILE__, "Out of memory"); |
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
static void FreeLogBuffer_CS (unsigned index) { |
|
||||||
if (s_logBuf[index]) { |
|
||||||
free(s_logBuf[index]); |
|
||||||
s_logBuf[index] = nil; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
static void GetLogFilename ( |
|
||||||
unsigned index, |
|
||||||
TimeDesc timeDesc, |
|
||||||
wchar_t * filename, |
|
||||||
unsigned chars |
|
||||||
) { |
|
||||||
StrPrintf( |
|
||||||
filename, |
|
||||||
chars, |
|
||||||
s_logNameFmt[index], |
|
||||||
#ifndef SERVER |
|
||||||
ProductShortName(), |
|
||||||
#endif |
|
||||||
timeDesc.year % 100, |
|
||||||
timeDesc.month, |
|
||||||
timeDesc.day |
|
||||||
); |
|
||||||
PathAddFilename(filename, s_directory, filename, chars); |
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
static bool OpenLogFile_CS (unsigned index) { |
|
||||||
if (s_logFile[index] != nil) |
|
||||||
return true; |
|
||||||
|
|
||||||
// Build filename
|
|
||||||
wchar_t filename[MAX_PATH]; |
|
||||||
GetLogFilename( |
|
||||||
index, |
|
||||||
s_logTime[index], |
|
||||||
filename, |
|
||||||
arrsize(filename) |
|
||||||
); |
|
||||||
|
|
||||||
// Open file
|
|
||||||
uint64_t fileTime; |
|
||||||
EFileError fileError; |
|
||||||
bool fileExist = PathDoesFileExist(filename); |
|
||||||
s_logFile[index] = AsyncFileOpen( |
|
||||||
filename, |
|
||||||
LogFileNotifyProc, |
|
||||||
&fileError, |
|
||||||
kAsyncFileWriteAccess, |
|
||||||
kAsyncFileModeOpenAlways, |
|
||||||
kAsyncFileShareRead, |
|
||||||
nil, // userState
|
|
||||||
&s_logWritePos[index], |
|
||||||
&fileTime |
|
||||||
); |
|
||||||
|
|
||||||
if (s_logFile[index] == nil) |
|
||||||
return false; |
|
||||||
|
|
||||||
TimeGetDesc(fileTime, &s_logTime[index]); |
|
||||||
s_logWriteMs[index] = TimeGetMs(); |
|
||||||
|
|
||||||
// Seek to end of file
|
|
||||||
AsyncFileSeek(s_logFile[index], s_logWritePos[index], kFileSeekFromBegin); |
|
||||||
|
|
||||||
// If this is a new file, write uint8_t Order Mark
|
|
||||||
if (!fileExist) { |
|
||||||
static const char s_bom[] = "\xEF\xBB\xBF"; |
|
||||||
AsyncFileWrite( |
|
||||||
s_logFile[index], |
|
||||||
s_logWritePos[index], |
|
||||||
s_bom, |
|
||||||
arrsize(s_bom)- 1, |
|
||||||
kAsyncFileRwSync, // perform blocking write
|
|
||||||
nil // param
|
|
||||||
); |
|
||||||
s_logWritePos[index] += arrsize(s_bom) - 1; |
|
||||||
} |
|
||||||
|
|
||||||
// Write a sentinel in case there are multiple runs in one day
|
|
||||||
static const char s_logOpened[] = "Log Opened\r\n"; |
|
||||||
AsyncFileWrite( |
|
||||||
s_logFile[index], |
|
||||||
s_logWritePos[index], |
|
||||||
s_logOpened, |
|
||||||
arrsize(s_logOpened)- 1, |
|
||||||
kAsyncFileRwSync, // perform blocking write
|
|
||||||
nil |
|
||||||
); |
|
||||||
s_logWritePos[index] += arrsize(s_logOpened) - 1; |
|
||||||
|
|
||||||
return true; |
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
static void WriteLogFile_CS (unsigned index, bool close) { |
|
||||||
unsigned flags = kAsyncFileRwSync; // kAsyncFileRwNotify
|
|
||||||
if (s_logPos[index]) { |
|
||||||
if (OpenLogFile_CS(index)) { |
|
||||||
AsyncFileWrite( |
|
||||||
s_logFile[index], |
|
||||||
s_logWritePos[index], |
|
||||||
s_logBuf[index], |
|
||||||
s_logPos[index], |
|
||||||
flags, |
|
||||||
s_logBuf[index] |
|
||||||
); |
|
||||||
if (flags == kAsyncFileRwSync) |
|
||||||
delete s_logBuf[index]; |
|
||||||
else |
|
||||||
AtomicAdd(&s_opsPending, 1); |
|
||||||
s_logWritePos[index] += s_logPos[index]; |
|
||||||
s_logWriteMs[index] = TimeGetMs(); |
|
||||||
s_logBuf[index] = nil; |
|
||||||
s_logPos[index] = 0; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if (close && s_logFile[index]) { |
|
||||||
if (flags == kAsyncFileRwNotify) { |
|
||||||
AtomicAdd(&s_opsPending, 1); |
|
||||||
AsyncFileFlushBuffers( |
|
||||||
s_logFile[index], |
|
||||||
kAsyncFileDontTruncate, |
|
||||||
true, |
|
||||||
nil |
|
||||||
); |
|
||||||
} |
|
||||||
else { |
|
||||||
AsyncFileClose( |
|
||||||
s_logFile[index], |
|
||||||
kAsyncFileDontTruncate |
|
||||||
); |
|
||||||
} |
|
||||||
s_logFile[index] = nil; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
static void FlushLogFile_CS ( |
|
||||||
unsigned index, |
|
||||||
TimeDesc timeDesc |
|
||||||
) { |
|
||||||
bool close = !s_running || (s_logTime[index].day != timeDesc.day); |
|
||||||
WriteLogFile_CS(index, close); |
|
||||||
if (close) |
|
||||||
s_logTime[index] = timeDesc; |
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
static unsigned FlushLogsTimerCallback (void *) { |
|
||||||
AsyncLogFlush(); |
|
||||||
return kAsyncTimeInfinite; |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
} using namespace AsyncLog; |
|
||||||
|
|
||||||
|
|
||||||
/****************************************************************************
|
|
||||||
* |
|
||||||
* Exported functions |
|
||||||
* |
|
||||||
***/ |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
void AsyncLogInitialize ( |
|
||||||
const wchar_t logDirName[], |
|
||||||
bool breakOnErrors |
|
||||||
) { |
|
||||||
s_running = true; |
|
||||||
|
|
||||||
// Save options
|
|
||||||
s_breakOnErrors = breakOnErrors; |
|
||||||
|
|
||||||
// Build log directory name
|
|
||||||
#ifdef SERVER |
|
||||||
PathGetProgramDirectory(s_directory, arrsize(s_directory)); |
|
||||||
#else |
|
||||||
PathGetUserDirectory(s_directory, arrsize(s_directory)); |
|
||||||
#endif |
|
||||||
PathAddFilename(s_directory, s_directory, logDirName, arrsize(s_directory)); |
|
||||||
|
|
||||||
#ifndef ACELOG_NO_LOG_FILES |
|
||||||
// Create log directory
|
|
||||||
if (kPathCreateDirSuccess != PathCreateDirectory(s_directory, 0)) |
|
||||||
PathRemoveFilename(s_directory, s_directory, arrsize(s_directory)); |
|
||||||
|
|
||||||
// Allocate log buffers
|
|
||||||
for (unsigned index = 0; index < kNumLogTypes; ++index) { |
|
||||||
s_logCrit[index].Enter(); |
|
||||||
AllocLogBuffer_CS(index); |
|
||||||
s_logCrit[index].Leave(); |
|
||||||
} |
|
||||||
|
|
||||||
AsyncTimerCreate(&s_timer, FlushLogsTimerCallback, kAsyncTimeInfinite, nil); |
|
||||||
#endif // ndef ACELOG_NO_LOG_FILES
|
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
void AsyncLogDestroy () { |
|
||||||
s_running = false; |
|
||||||
|
|
||||||
#ifndef ACELOG_NO_LOG_FILES |
|
||||||
AsyncTimerDelete(s_timer, kAsyncTimerDestroyWaitComplete); |
|
||||||
|
|
||||||
for (unsigned index = 0; index < kNumLogTypes; ++index) { |
|
||||||
s_logCrit[index].Enter(); |
|
||||||
{ |
|
||||||
WriteLogFile_CS(index, true); |
|
||||||
FreeLogBuffer_CS(index); |
|
||||||
} |
|
||||||
s_logCrit[index].Leave(); |
|
||||||
} |
|
||||||
while (s_opsPending) |
|
||||||
AsyncSleep(10); |
|
||||||
#endif // ndef ACELOG_NO_LOG_FILES
|
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
void AsyncLogFlush () { |
|
||||||
#ifndef ACELOG_NO_LOG_FILES |
|
||||||
TimeDesc timeDesc; |
|
||||||
TimeGetDesc(TimeGetTime(), &timeDesc); |
|
||||||
|
|
||||||
for (unsigned index = 0; index < kNumLogTypes; ++index) { |
|
||||||
s_logCrit[index].Enter(); |
|
||||||
FlushLogFile_CS(index, timeDesc); |
|
||||||
s_logCrit[index].Leave(); |
|
||||||
} |
|
||||||
#endif // ndef ACELOG_NO_LOG_FILES
|
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
void LogBreakOnErrors (bool breakOnErrors) { |
|
||||||
s_breakOnErrors = breakOnErrors; |
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
void AsyncLogWriteMsg ( |
|
||||||
const wchar_t facility[], |
|
||||||
ELogSeverity severity, |
|
||||||
const wchar_t msg[] |
|
||||||
) { |
|
||||||
if (!s_running) |
|
||||||
return; |
|
||||||
|
|
||||||
#ifndef ACELOG_NO_LOG_FILES |
|
||||||
TimeDesc timeDesc; |
|
||||||
TimeGetDesc(TimeGetTime(), &timeDesc); |
|
||||||
|
|
||||||
char buffer[2048]; |
|
||||||
const unsigned chars = StrPrintf( |
|
||||||
buffer, |
|
||||||
arrsize(buffer), |
|
||||||
"%02u/%02u/%02u % 2u:%02u:%02u [%S] %s %S\r\n", |
|
||||||
timeDesc.month, |
|
||||||
timeDesc.day, |
|
||||||
timeDesc.year % 100, |
|
||||||
timeDesc.hour, |
|
||||||
timeDesc.minute, |
|
||||||
timeDesc.second, |
|
||||||
facility, |
|
||||||
s_logSeverityToText[severity], |
|
||||||
msg |
|
||||||
); |
|
||||||
|
|
||||||
unsigned index = s_logSeverityToType[severity]; |
|
||||||
s_logCrit[index].Enter(); |
|
||||||
{ |
|
||||||
// If day changed then write and flush file
|
|
||||||
if (s_logTime[index].day != timeDesc.day) |
|
||||||
FlushLogFile_CS(index, timeDesc); |
|
||||||
// Otherwise if the buffer is full then write to file
|
|
||||||
else if (s_logPos[index] + chars > s_logSize[index]) |
|
||||||
WriteLogFile_CS(index, false); |
|
||||||
|
|
||||||
// Allocate log buffer if necessary
|
|
||||||
if (!s_logBuf[index]) |
|
||||||
AllocLogBuffer_CS(index); |
|
||||||
|
|
||||||
// Add new data to the log buffer
|
|
||||||
memcpy(s_logBuf[index] + s_logPos[index], buffer, chars); |
|
||||||
s_logPos[index] += chars; |
|
||||||
|
|
||||||
// Write, flush and close file immediately if this is a fatal error
|
|
||||||
if (severity == kLogFatal) |
|
||||||
WriteLogFile_CS(index, true); |
|
||||||
|
|
||||||
// Drop to debugger if this is an error msg and that option was specified
|
|
||||||
if (s_breakOnErrors && severity >= kLogError) |
|
||||||
DebugBreakIfDebuggerPresent(); |
|
||||||
} |
|
||||||
s_logCrit[index].Leave(); |
|
||||||
|
|
||||||
// Queue flush
|
|
||||||
AsyncTimerUpdate(s_timer, kLogFlushMs, kAsyncTimerUpdateSetPriorityHigher); |
|
||||||
#endif // ndef ACELOG_NO_LOG_FILES
|
|
||||||
} |
|
||||||
|
|
||||||
//============================================================================
|
|
||||||
void AsyncLogGetDirectory (wchar_t * dest, unsigned destChars) { |
|
||||||
ASSERT(dest); |
|
||||||
StrCopy(dest, s_directory, destChars); |
|
||||||
} |
|
||||||
Loading…
Reference in new issue