--- a/persistentstorage/sql/OsLayer/os_symbian.cpp Tue Jul 06 16:18:30 2010 +0300
+++ b/persistentstorage/sql/OsLayer/os_symbian.cpp Wed Aug 18 11:30:17 2010 +0300
@@ -40,49 +40,23 @@
#include "SqliteSymbian.h"
#include "FileBuf64.h"
#include <e32math.h>
-#include "UTraceSql.h"
#ifdef _SQLPROFILER
#include <hal.h>
#include "../INC/SqlResourceProfiler.h"
#endif
+#include "SqliteUtil.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "os_symbianTraces.h"
+#endif
+#include "SqliteTraceDef.h"
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
-Panic category - used by asserts in this file (the OS porting layer).
-
-@see TPanicCodes
-
-@internalComponent
-*/
-_LIT(KPanicCategory, "Sqlite");
-
-/**
-Panic codes - used by asserts in this file (the OS porting layer).
-
-@see KPanicCategory
-
-@internalComponent
-*/
-enum TPanicCodes
- {
- EPanicNullOsLayerDataPtr = 1,
- EPanicInvalidWAmount = 2,
- EPanicOffset64bit = 3,
- EPanicInvalidOpType =11,
- EPanicInvalidFhStr =12,
- EPanicInvalidFhData =13,
- EPanicInvalidArg =14,
- EPanicInvalidRAmount =15,
- EPanicOsLayerDataExists =16,
- EPanicInvalidDrive =17,
- EPanicInvalidSectorSize =18,
- EPanicInternalError =19,
- EPanicNullDbFilePtr =20,
- EPanicFastCounterFreq =21
- };
+//The SQLite temp files willl be created in this subdir
+_LIT(KTempFileDir, "temp");
//Bit-mask constant. If xOpen()'s "aFlag" parameter contains one of these bits set, then the the file top be
//opened or created is a journal file.
@@ -485,7 +459,7 @@
{
TInt ticksPerSec = 0;
TInt err = HAL::Get(HAL::EFastCounterFrequency, ticksPerSec);
- __ASSERT_ALWAYS(err == KErrNone, User::Panic(KPanicCategory, EPanicFastCounterFreq));
+ __ASSERT_ALWAYS(err == KErrNone, __SQLITEPANIC2(ESqliteOsPanicFastCounterFreq));
return ticksPerSec;
}
@@ -679,6 +653,47 @@
#endif//_SQLPROFILER
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+Os2SqliteErr() is called at the end of many of the interface functions of the OS porting layer (wherever it is appropriate -
+TFileIo and TVfs interfaces). The purpose of this function is to identify the "out of memory" and "disk is full" errors
+reported by the used Symbian OS APIs (aOsErr parameter) and report them to SQLite as SQLITE_FULL and SQLITE_NOMEM errors.
+The KErrEof error (TFileIo::Read() can return KErrEof) is reported to SQLite as SQLITE_IOERR_SHORT_READ. The rest of failures
+are reported as the error specified in aDefaultErr parameter.
+
+@param aOsErr Symbian OS error
+@param aDefaultErr The default SQLite error that should be used if the aOsErr parameter is not one of:
+ KErrNone, KErrEof, KErrNoMemory, KErrDiskFull
+@return SQLITE_OK, The OS porting layer function call has completed successfully,
+ SQLITE_IOERR_SHORT_READ, The amount of the data read is less than the requested amount,
+ SQLITE_IOERR_NOMEM, Out of memory,
+ SQLITE_FULL, The disk is full,
+ aDefaultErr, The rest of failures will be reported as aDefaultErr.
+*/
+static TInt Os2SqliteErr(TInt aOsErr, TInt aDefaultErr)
+ {
+ switch(aOsErr)
+ {
+ case KErrNone:
+ return SQLITE_OK;
+ case KErrEof:
+ return SQLITE_IOERR_SHORT_READ;
+ case KErrNoMemory:
+ return SQLITE_IOERR_NOMEM;
+ case KErrDiskFull:
+ return SQLITE_FULL;
+ default:
+#ifdef _DEBUG
+ RDebug::Print(_L("SQLite OS porting layer, Os2SqliteErr(), err=%d\n"), aOsErr);
+ SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, OS2SQLITEERR, "OS;0;Os2SqliteErr;aOsErr=%d", aOsErr));
+#endif
+ break;
+ }
+ return aDefaultErr;
+ }
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////// COsLayerData class declaration //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -720,7 +735,6 @@
public:
RFs iFs; //File session instance.
TFileName iSysPrivDir;//"<system drive>:\" + process's private data path. Initialized in sqlite3SymbianFsOpen().
- //Used for storing sqlite temporary files.
TInt64 iSeed;
private:
@@ -767,12 +781,13 @@
{
inline TDbFile();
RFileBuf64 iFileBuf;
- HBufC* iFullName; //Used for the "delete file" operation (RFile64::FullName() makes an IPC call!)
TInt iLockType; //File lock type
TBool iReadOnly; //True if the file is read-only
TInt iSectorSize; //Media sector-size
TInt iDeviceCharacteristics;
TSqlFreePageCallback iFreePageCallback;
+ TBool iIsFileCreated; //If the file to be created is a temp file,
+ //it will not be created until the data is to be written to.
#ifdef _SQLPROFILER
TBool iIsJournal;
#endif
@@ -814,6 +829,8 @@
static int FileControl(sqlite3_file* aDbFile, int aOp, void* aArg);
static int SectorSize(sqlite3_file* aDbFile);
static int DeviceCharacteristics(sqlite3_file* aDbFile);
+private:
+ static TInt DoCreateTempFile(TDbFile& aDbFile);
};
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -842,12 +859,12 @@
static int Sleep(sqlite3_vfs* aVfs, int aMicrosec);
static int CurrentTime(sqlite3_vfs* aVfs, double* aNow);
static int GetLastError(sqlite3_vfs *sVfs, int aBufLen, char* aBuf);
+ static TInt DoGetDeviceCharacteristicsAndSectorSize(TDbFile& aDbFile, TInt& aRecReadBufSize);
private:
static TInt DoOpenFromHandle(TDbFile& aDbFile, const RMessage2& aMsg, TBool aReadOnly);
static inline TInt DoGetVolumeIoParamInfo(RFs& aFs, TInt aDriveNo, TVolumeIOParamInfo& aVolumeInfo);
static TInt DoGetDeviceCharacteristics(const TDriveInfo& aDriveInfo, const TVolumeIOParamInfo& aVolumeInfo);
static TInt DoGetSectorSize(const TDriveInfo& aDriveInfo, const TVolumeIOParamInfo& aVolumeInfo);
- static TInt DoGetDeviceCharacteristicsAndSectorSize(TDbFile& aDbFile, TInt& aRecReadBufSize);
static TInt DoFileSizeCorruptionCheck(TDbFile& aDbFile, const TDesC& aFname, TInt aFmode);
};
@@ -952,12 +969,14 @@
*/
/* static */ TInt COsLayerData::Create()
{
- __ASSERT_DEBUG(!COsLayerData::iOsLayerData, User::Panic(KPanicCategory, EPanicOsLayerDataExists));
+ SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_CREATE_ENTRY, "OS-Entry;0;COsLayerData::Create"));
+ __ASSERT_DEBUG(!COsLayerData::iOsLayerData, __SQLITEPANIC2(ESqliteOsPanicOsLayerDataExists));
if(!COsLayerData::iOsLayerData)
{
COsLayerData::iOsLayerData = new COsLayerData;
if(!COsLayerData::iOsLayerData)
{
+ SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_CREATE_EXIT1, "OS-Exit;0;COsLayerData::Create;err=KErrNoMemory"));
return KErrNoMemory;
}
TInt err = COsLayerData::iOsLayerData->DoCreate();
@@ -965,9 +984,11 @@
{
delete COsLayerData::iOsLayerData;
COsLayerData::iOsLayerData = NULL;
+ SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, COSLAYERDATA_CREATE_EXIT2, "OS-Exit;0;COsLayerData::Create;err=%d", err));
return err;
}
}
+ SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_CREATE_EXIT3, "OS-Exit;0;COsLayerData::Create;err=KErrNone"));
return KErrNone;
}
@@ -978,6 +999,7 @@
{
delete COsLayerData::iOsLayerData;
COsLayerData::iOsLayerData = NULL;
+ SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, COSLAYERDATA_DESTROY, "OS;0;COsLayerData::Destroy"));
}
/**
@@ -987,7 +1009,7 @@
*/
/* static */ inline COsLayerData& COsLayerData::Instance()
{
- __ASSERT_DEBUG(COsLayerData::iOsLayerData != NULL, User::Panic(KPanicCategory, EPanicNullOsLayerDataPtr));
+ __ASSERT_DEBUG(COsLayerData::iOsLayerData != NULL, __SQLITEPANIC2(ESqliteOsPanicNullOsLayerDataPtr));
return *COsLayerData::iOsLayerData;
}
@@ -1061,7 +1083,7 @@
*/
inline void COsLayerData::RetrieveAndResetFhData(const RMessage2*& aMsg, TBool& aReadOnly)
{
- __ASSERT_DEBUG(iMessage != NULL, User::Panic(KPanicCategory, EPanicInvalidFhData));
+ __ASSERT_DEBUG(iMessage != NULL, __SQLITEPANIC(ESqliteOsPanicInvalidFhData));
aMsg = iMessage;
aReadOnly = iReadOnly;
iMessage = NULL;
@@ -1087,6 +1109,7 @@
*/
inline COsLayerData::~COsLayerData()
{
+ SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, COSLAYERDATA_COSLAYERDATA2, "OS;0;COsLayerData::~COsLayerData;iFs.Handle()=0x%X", (TUint)iFs.Handle()));
__FS_CALL(EFsOpFsClose, 0);
iFs.Close();
}
@@ -1136,6 +1159,14 @@
TParse parse;
(void)parse.Set(driveName, &privateDir, 0);//this call can't fail
iSysPrivDir.Copy(parse.DriveAndPath());
+ //Create the temp files directory
+ (void)parse.AddDir(KTempFileDir);//this call can't fail
+ err = iFs.MkDir(parse.DriveAndPath());
+ if(err != KErrNone && err != KErrAlreadyExists)
+ {
+ return err;
+ }
+ SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, COSLAYERDATA_DOCREATE, "OS;0;COsLayerData::DoCreate;iFs.Handle()=0x%X;sysDrive=%d;iSysPrivDir=%S", (TUint)iFs.Handle(), sysDrive, __SQLITEPRNSTR(iSysPrivDir)));
return KErrNone;
}
@@ -1185,6 +1216,7 @@
osErr = sqliteErr == SQLITE_NOMEM ? KErrNoMemory : KErrGeneral;
COsLayerData::Destroy();
}
+ SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, SQLITE3SYMBIANLIBINIT, "OS;0;sqlite3SymbianLibInit;osErr=%d", osErr));
return osErr;
}
@@ -1204,6 +1236,7 @@
{
(void)sqlite3_shutdown();
COsLayerData::Destroy();
+ SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, SQLITE3SYMBIANLIBFINALIZE, "OS;0;sqlite3SymbianLibFinalize"));
}
/**
@@ -1240,7 +1273,7 @@
{
wchar_t* dest = reinterpret_cast <wchar_t*> (const_cast <TUint16*> (aFileNameDestBuf.Ptr()));
TInt len = mbstowcs(dest, aFileName, aFileNameDestBuf.MaxLength());
- __ASSERT_DEBUG(len >= 0, User::Panic(KPanicCategory, EPanicInternalError));
+ __ASSERT_DEBUG(len >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
//If len == aFileNameDestBuf.MaxLength(), then the output buffer is too small.
if(len < aFileNameDestBuf.MaxLength())
{
@@ -1269,7 +1302,7 @@
char* dest = reinterpret_cast <char*> (const_cast <TUint8*> (aFileNameDestBuf.Ptr()));
const wchar_t* src = reinterpret_cast <const wchar_t*> (aFileName.Ptr());
TInt len = wcstombs(dest, src, aFileNameDestBuf.MaxLength());
- __ASSERT_DEBUG(len >= 0, User::Panic(KPanicCategory, EPanicInternalError));
+ __ASSERT_DEBUG(len >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
//If len == aFileNameDestBuf.MaxLength(), then the output buffer is too small.
if(len < aFileNameDestBuf.MaxLength())
{
@@ -1411,7 +1444,7 @@
static void FhExtractAndStore(TDes& aDbFileName)
{
TInt fhStartPos = aDbFileName.Locate(TChar(KFhSeparator));
- __ASSERT_DEBUG(fhStartPos == KFhMarkPos, User::Panic(KPanicCategory, EPanicInvalidFhStr));
+ __ASSERT_DEBUG(fhStartPos == KFhMarkPos, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr));
//If this file name string contains file handles
if(fhStartPos == KFhMarkPos)
{
@@ -1419,12 +1452,12 @@
TLex lex(aDbFileName.Mid(fhStartPos + KFhMsgAddrPos, KFhMsgAddrLen));
TUint32 addr;
TInt err = lex.Val(addr, EHex);
- __ASSERT_DEBUG(err == KErrNone, User::Panic(KPanicCategory, EPanicInvalidFhStr));
+ __ASSERT_DEBUG(err == KErrNone, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr));
if(err == KErrNone)
{
//Cast the address to RMessage2 pointer.
const RMessage2* msg = reinterpret_cast <const RMessage2*> (addr);
- __ASSERT_DEBUG(msg != NULL, User::Panic(KPanicCategory, EPanicInvalidFhStr));
+ __ASSERT_DEBUG(msg != NULL, __SQLITEPANIC2(ESqliteOsPanicInvalidFhStr));
if(msg)
{
//Store the data from aDbFileName in the single COsLayerData instance.
@@ -1446,16 +1479,17 @@
*/
inline TDbFile::TDbFile() :
iFileBuf(KFileBufSize),
- iFullName(0),
iLockType(SQLITE_LOCK_NONE),
iReadOnly(EFalse),
iSectorSize(0),
- iDeviceCharacteristics(-1)
+ iDeviceCharacteristics(-1),
+ iIsFileCreated(ETrue)
{
#ifdef _SQLPROFILER
iIsJournal = EFalse;
#endif
pMethods = 0;
+ SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TDBFILE_TDBFILE, "OS;0x%X;TDbFile::TDbFile", (TUint)this));
}
/**
@@ -1476,7 +1510,7 @@
*/
static inline TDbFile& DbFile(sqlite3_file* aDbFile)
{
- __ASSERT_DEBUG(aDbFile != 0, User::Panic(KPanicCategory, EPanicNullDbFilePtr));
+ __ASSERT_DEBUG(aDbFile != 0, __SQLITEPANIC2(ESqliteOsPanicNullDbFilePtr));
return *(static_cast <TDbFile*> (aDbFile));
}
@@ -1488,7 +1522,6 @@
SQLite OS porting layer API.
Closes the file referred by aDbFile parameter.
-If aDbFile.iFullName data member is not NULL, then the file will be deleted.
@param aDbFile A pointer to a TDbFile instance, than contains the file handle to be closed.
@@ -1498,19 +1531,12 @@
*/
/* static */ int TFileIo::Close(sqlite3_file* aDbFile)
{
- SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
+ SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TFILEIO_CLOSE1, "OS;0x%X;TFileIo::Close", (TUint)&dbFile));
__OS_CALL(EOsFileClose, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsFileClose], ::OsCallProfile(dbFile.iIsJournal, EOsFileClose), 0, 0, aDbFile, 0);
__FS_CALL(EFsOpFileClose, 0);
dbFile.iFileBuf.Close();
- if(dbFile.iFullName)
- {//"iFullName" will not be NULL only when TVfs::Open() is called with SQLITE_OPEN_DELETEONCLOSE flag.
- //That means - SQlite expects the file to be deleted after the file close operation.
- __FS_CALL(EFsOpFileDelete, 0);
- (void)COsLayerData::Instance().iFs.Delete(*dbFile.iFullName);
- delete dbFile.iFullName;
- }
return SQLITE_OK;
}
@@ -1538,41 +1564,63 @@
*/
/* static */ int TFileIo::Read(sqlite3_file* aDbFile, void* aBuf, int aAmt, sqlite3_int64 aOffset)
{
- SQLUTRACE_PROFILER(aDbFile);
- SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileRead, aAmt, aOffset));
TDbFile& dbFile = ::DbFile(aDbFile);
+ SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_READ_ENTRY, "OS-Entry;0x%X;TFileIo::Read;aAmt=%d;aOffset=%lld", (TUint)&dbFile, aAmt, aOffset));
__OS_CALL(EOsFileRead, 0, 0);
__COUNTER_INCR(TheSqlSrvProfilerFileRead);
__OSTIME_COUNTER(TheOsCallTicks[EOsFileRead], ::OsCallProfile(dbFile.iIsJournal, EOsFileRead), aOffset, aAmt, aDbFile, 0);
TPtr8 ptr((TUint8*)aBuf, 0, aAmt);
TInt err = dbFile.iFileBuf.Read(aOffset, ptr);
TInt cnt = ptr.Length();
- TInt sqliteErr = SQLITE_IOERR_READ;
- switch(err)
+ TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_READ);
+ if(cnt != aAmt && (sqliteErr == SQLITE_OK || sqliteErr == SQLITE_IOERR_SHORT_READ))
{
- case KErrNone:
- sqliteErr = SQLITE_OK;
- if(cnt != aAmt)
- {
- Mem::FillZ(static_cast <TUint8*> (aBuf) + cnt, aAmt - cnt);
- sqliteErr = SQLITE_IOERR_SHORT_READ;
- err = KErrEof;
- }
- break;
- case KErrEof:
- Mem::FillZ(static_cast <TUint8*> (aBuf) + cnt, aAmt - cnt);
- sqliteErr = SQLITE_IOERR_SHORT_READ;
- break;
- case KErrNoMemory:
- sqliteErr = SQLITE_IOERR_NOMEM;
- break;
- default:
- break;
+ Mem::FillZ(static_cast <TUint8*> (aBuf) + cnt, aAmt - cnt);
+ err = KErrEof;
+ sqliteErr = SQLITE_IOERR_SHORT_READ;
}
COsLayerData::Instance().SetOsErrorCode(err);
+ SQLITE_TRACE_OS(OstTraceExt4(TRACE_INTERNALS, TFILEIO_READ_EXIT, "OS-Exit;0x%X;TFileIo::Read;cnt=%d;err=%d;sqliteErr=%d", (TUint)&dbFile, cnt, err, sqliteErr));
return sqliteErr;
}
+//Creates a temporary file in "\temp" subdirectory of osLayerData.iSysPrivDir directory.
+//If the function fails, the temp file will be closed and deleted,
+//the related Symbian OS error will be returned to the caller.
+/* static */TInt TFileIo::DoCreateTempFile(TDbFile& aDbFile)
+ {
+ COsLayerData& osLayerData = COsLayerData::Instance();
+ //TParse2 is used in order to avoid the need of another TFileName stack based variable
+ class TParse2 : public TParse
+ {
+ public:
+ inline TFileName& FileName()
+ {
+ return static_cast <TFileName&> (NameBuf());
+ }
+ };
+ TParse2 parse;
+ (void)parse.Set(osLayerData.iSysPrivDir, 0, 0);//this call can't fail
+ (void)parse.AddDir(KTempFileDir);//this call can't fail
+ __FS_CALL(EFsOpFileCreateTemp, 0);
+ TInt err = aDbFile.iFileBuf.Temp(osLayerData.iFs, parse.FullName(), parse.FileName(), EFileRead|EFileWrite|EDeleteOnClose);
+ if(err == KErrNone)
+ {
+ TInt recReadBufSize = -1;
+ err = TVfs::DoGetDeviceCharacteristicsAndSectorSize(aDbFile, recReadBufSize);
+ if(err != KErrNone)
+ {
+ aDbFile.iFileBuf.Close();//With EDeleteOnClose flag set, the file will be deleted
+ }
+ else
+ {
+ (void)aDbFile.iFileBuf.SetReadAheadSize(aDbFile.iSectorSize, recReadBufSize);
+ aDbFile.iIsFileCreated = ETrue;
+ }
+ }
+ return err;
+ }
+
/**
SQLite OS porting layer API.
@@ -1583,6 +1631,8 @@
(TDbFile::iFreePageCallback) and the free pages count is above the defined value,
then the callback will be called.
+If the file to be written to is a temp file, which is not created yet, then the file will be created.
+
@param aDbFile A pointer to a TDbFile instance, that contains the file handle to be written to.
@param aData The data to be written to the file. The buffer size must be at least aAmt bytes.
@param aAmt The amount of data to be written to the file.
@@ -1601,13 +1651,22 @@
*/
/* static */ int TFileIo::Write(sqlite3_file* aDbFile, const void* aData, int aAmt, sqlite3_int64 aOffset)
{
- SQLUTRACE_PROFILER(aDbFile);
- SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileWrite, aAmt, aOffset));
TDbFile& dbFile = ::DbFile(aDbFile);
+ SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_WRITE_ENTRY, "OS-Entry;0x%X;TFileIo::Write;aAmt=%d;aOffset=%lld", (TUint)&dbFile, aAmt, aOffset));
__OS_CALL(EOsFileWrite, 0, 0);
__COUNTER_INCR(TheSqlSrvProfilerFileWrite);
__OSTIME_COUNTER(TheOsCallTicks[EOsFileWrite], ::OsCallProfile(dbFile.iIsJournal, EOsFileWrite), aOffset, aAmt, aDbFile, 0);
- TInt err = KErrAccessDenied;
+ TInt err = KErrNone;
+ if(!dbFile.iIsFileCreated)
+ {//Create a temp file if it has not been created.
+ err = TFileIo::DoCreateTempFile(dbFile);
+ }
+ if(err != KErrNone)
+ {
+ COsLayerData::Instance().SetOsErrorCode(err);
+ return ::Os2SqliteErr(err, SQLITE_FULL);
+ }
+ err = KErrAccessDenied;
if(!dbFile.iReadOnly)
{
TPtrC8 ptr((const TUint8*)aData, aAmt);
@@ -1630,7 +1689,9 @@
dbFile.iFreePageCallback.CheckAndCallback(freePageCount);
}
- return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_FULL);
+ TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_FULL);
+ SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_WRITE_EXIT, "OS-Exit;0x%X;TFileIo::Write;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));
+ return sqliteErr;
}
/**
@@ -1655,9 +1716,8 @@
*/
/* static */ int TFileIo::Truncate(sqlite3_file* aDbFile, sqlite3_int64 aLength)
{
- SQLUTRACE_PROFILER(aDbFile);
- SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileTruncate, aLength));
TDbFile& dbFile = ::DbFile(aDbFile);
+ SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_TRUNCATE_ENTRY, "OS-Entry;0x%X;TFileIo::Truncate;aLength=%lld", (TUint)&dbFile, aLength));
__OS_CALL(EOsFileTruncate, 0, 0);
__COUNTER_INCR(TheSqlSrvProfilerFileSetSize);
__OSTIME_COUNTER(TheOsCallTicks[EOsFileTruncate], ::OsCallProfile(dbFile.iIsJournal, EOsFileTruncate), aLength, 0, aDbFile, 0);
@@ -1669,7 +1729,9 @@
__FS_CALL(EFsOpFileSetSize, 0);
TInt err = dbFile.iFileBuf.SetSize(aLength);
COsLayerData::Instance().SetOsErrorCode(err);
- return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR);
+ TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR);
+ SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_TRUNCATE_EXIT, "OS-Exit;0x%X;TFileIo::Truncate;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));
+ return sqliteErr;
}
/**
@@ -1692,8 +1754,8 @@
*/
/* static */int TFileIo::Sync(sqlite3_file* aDbFile, int /* aFlags */)
{
- SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
+ SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TFILEIO_SYNC_ENTRY, "OS-Entry;0x%X;TFileIo::Sync", (TUint)&dbFile));
__OS_CALL(EOsFileSync, 0, 0);
__COUNTER_INCR(TheSqlSrvProfilerFileSync);
__OSTIME_COUNTER(TheOsCallTicks[EOsFileSync], ::OsCallProfile(dbFile.iIsJournal, EOsFileSync), 0, 0, aDbFile, 0);
@@ -1705,7 +1767,9 @@
__FS_CALL(EFsOpFileSync, 0);
TInt err = dbFile.iFileBuf.Flush();
COsLayerData::Instance().SetOsErrorCode(err);
- return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR);
+ TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR);
+ SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_SYNC_EXIT, "OS-Exit;0x%X;TFileIo::Sync;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));
+ return sqliteErr;
}
/**
@@ -1728,18 +1792,16 @@
*/
/* static */ int TFileIo::FileSize(sqlite3_file* aDbFile, sqlite3_int64* aSize)
{
- SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
+ SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TFILEIO_FILESIZE_ENTRY, "OS-Entry;0x%X;TFileIo::FileSize", (TUint)&dbFile));
__OS_CALL(EOsFileFileSize, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsFileFileSize], ::OsCallProfile(dbFile.iIsJournal, EOsFileFileSize), 0, 0, aDbFile, 0);
__FS_CALL(EFsOpFileSize, 0);
TInt err = dbFile.iFileBuf.Size(*aSize);
COsLayerData::Instance().SetOsErrorCode(err);
- if(err == KErrNone)
- {
- return SQLITE_OK;
- }
- return err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR;
+ TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR);
+ SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_FILESIZE_EXIT, "OS-Exit;0x%X;TFileIo::FileSize;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));
+ return sqliteErr;
}
/**
@@ -1762,7 +1824,6 @@
*/
/* static */ int TFileIo::Lock(sqlite3_file* aDbFile, int aLockType)
{
- SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
__OS_CALL(EOsFileLock, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsFileLock], ::OsCallProfile(dbFile.iIsJournal, EOsFileLock), aLockType, 0, aDbFile, 0);
@@ -1795,7 +1856,6 @@
*/
/* static */ int TFileIo::Unlock(sqlite3_file* aDbFile, int aLockType)
{
- SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
__OS_CALL(EOsFileUnlock, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsFileUnlock], ::OsCallProfile(dbFile.iIsJournal, EOsFileUnlock), aLockType, 0, aDbFile, 0);
@@ -1824,7 +1884,6 @@
*/
/* static */ int TFileIo::CheckReservedLock(sqlite3_file* aDbFile, int *aResOut)
{
- SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
__OS_CALL(EOsFileCheckReservedLock, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsFileCheckReservedLock], ::OsCallProfile(dbFile.iIsJournal, EOsFileCheckReservedLock), 0, 0, aDbFile, 0);
@@ -1859,9 +1918,8 @@
*/
/* static */ int TFileIo::FileControl(sqlite3_file* aDbFile, int aOp, void* aArg)
{
- SQLUTRACE_PROFILER(aDbFile);
- SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileFileCtr, aOp));
TDbFile& dbFile = ::DbFile(aDbFile);
+ SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TFILEIO_FILECONTROL_ENTRY, "OS-Entry;0x%X;TFileIo::FileControl;aOp=%d", (TUint)&dbFile, aOp));
__OS_CALL(EOsFileFileControl, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsFileFileControl], ::OsCallProfile(dbFile.iIsJournal, EOsFileFileControl), aOp, 0, aDbFile, 0);
TInt err = KErrNone;
@@ -1889,7 +1947,9 @@
break;
}
COsLayerData::Instance().SetOsErrorCode(err);
- return err == KErrNone ? SQLITE_OK : SQLITE_ERROR;
+ TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_ERROR);
+ SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TFILEIO_FILECONTROL_EXIT, "OS-Exit;0x%X;TFileIo::FileControl;err=%d;sqliteErr=%d", (TUint)&dbFile, err, sqliteErr));
+ return sqliteErr;
}
/**
@@ -1911,11 +1971,10 @@
*/
/* static */ int TFileIo::SectorSize(sqlite3_file* aDbFile)
{
- SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
__OS_CALL(EOsFileSectorSize, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsFileSectorSize], ::OsCallProfile(dbFile.iIsJournal, EOsFileSectorSize), 0, 0, aDbFile, 0);
- __ASSERT_DEBUG(dbFile.iSectorSize > 0, User::Panic(KPanicCategory, EPanicInternalError));
+ __ASSERT_DEBUG(dbFile.iSectorSize > 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
if(dbFile.iSectorSize > 0)
{
return dbFile.iSectorSize;
@@ -1942,11 +2001,10 @@
*/
/* static */ int TFileIo::DeviceCharacteristics(sqlite3_file* aDbFile)
{
- SQLUTRACE_PROFILER(aDbFile);
TDbFile& dbFile = ::DbFile(aDbFile);
__OS_CALL(EOsFileDeviceCharacteristics, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsFileDeviceCharacteristics], ::OsCallProfile(dbFile.iIsJournal, EOsFileDeviceCharacteristics), 0, 0, aDbFile, 0);
- __ASSERT_DEBUG(dbFile.iDeviceCharacteristics >= 0, User::Panic(KPanicCategory, EPanicInternalError));
+ __ASSERT_DEBUG(dbFile.iDeviceCharacteristics >= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
if(dbFile.iDeviceCharacteristics >= 0)
{
return dbFile.iDeviceCharacteristics;
@@ -2003,7 +2061,9 @@
/* static */ inline TInt TVfs::DoGetVolumeIoParamInfo(RFs& aFs, TInt aDriveNo, TVolumeIOParamInfo& aVolumeInfo)
{
__FS_CALL(EFsOpFsVolumeIoParam, 0);
- return aFs.VolumeIOParam(aDriveNo, aVolumeInfo);
+ TInt err = aFs.VolumeIOParam(aDriveNo, aVolumeInfo);
+ SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_DOGETVOLUMEIOPARAMINFO, "OS;0;TVfs::DoGetVolumeIoParamInfo;aDriveNo=%d;err=%d", aDriveNo, err));
+ return err;
}
/**
@@ -2091,7 +2151,7 @@
sectorSize = aVolumeInfo.iBlockSize;
}
}
- __ASSERT_DEBUG(sectorSize > 0 && (sectorSize & (sectorSize - 1)) == 0, User::Panic(KPanicCategory, EPanicInternalError));
+ __ASSERT_DEBUG(sectorSize > 0 && (sectorSize & (sectorSize - 1)) == 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
return sectorSize;
}
@@ -2120,8 +2180,8 @@
*/
/* static */ TInt TVfs::DoGetDeviceCharacteristicsAndSectorSize(TDbFile& aDbFile, TInt& aRecReadBufSize)
{
- __ASSERT_DEBUG(aDbFile.iDeviceCharacteristics < 0, User::Panic(KPanicCategory, EPanicInternalError));
- __ASSERT_DEBUG(aDbFile.iSectorSize <= 0, User::Panic(KPanicCategory, EPanicInternalError));
+ __ASSERT_DEBUG(aDbFile.iDeviceCharacteristics < 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
+ __ASSERT_DEBUG(aDbFile.iSectorSize <= 0, __SQLITEPANIC2(ESqliteOsPanicInternalError));
TInt driveNo;
TDriveInfo driveInfo;
__FS_CALL(EFsOpFileDrive, 0);
@@ -2139,6 +2199,7 @@
aDbFile.iDeviceCharacteristics = TVfs::DoGetDeviceCharacteristics(driveInfo, volumeInfo);
aDbFile.iSectorSize = TVfs::DoGetSectorSize(driveInfo, volumeInfo);
aRecReadBufSize = volumeInfo.iRecReadBufSize;
+ SQLITE_TRACE_OS(OstTraceExt5(TRACE_INTERNALS, TVFS_DOGETGETDEVICECHARACTERISTICSANDSECTORSIZE, "OS;0x%X;TVfs::DoGetDeviceCharacteristicsAndSectorSize;driveNo=%d;sectorSize=%d;devCharact=0x%X;readBufSize=%d", (TUint)&aDbFile, driveNo, aDbFile.iSectorSize, (TUint)aDbFile.iDeviceCharacteristics, volumeInfo.iRecReadBufSize));
return KErrNone;
}
@@ -2194,8 +2255,10 @@
COsLayerData& osLayerData = COsLayerData::Instance();
aDbFile.iFileBuf.Close();
- (void) osLayerData.iFs.Delete(aFname);
+ __SQLITETRACE_OSEXPR(TInt err2 =) osLayerData.iFs.Delete(aFname);
+ SQLITE_TRACE_OS(OstTraceExt4(TRACE_INTERNALS, TVFS_DOFILESIZECORRUPTIONCHECK1, "OS;0x%X;TVfs::DoFileSizeCorruptionCheck;size=%lld;err=%d;deleteErr=%d", (TUint)&aDbFile, size, err, err2));
err = aDbFile.iFileBuf.Create(osLayerData.iFs, aFname, aFmode);
+ SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_DOFILESIZECORRUPTIONCHECK2, "OS;0x%X;TVfs::DoFileSizeCorruptionCheck;createErr=%d", (TUint)&aDbFile, err));
}
return err;
}
@@ -2234,30 +2297,32 @@
*/
/* static */ int TVfs::Open(sqlite3_vfs* aVfs, const char* aFileName, sqlite3_file* aDbFile, int aFlags, int* aOutFlags)
{
- SQLUTRACE_PROFILER(aVfs);
__OS_CALL(EOsVfsOpen, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsVfsOpen], ::OsCallProfile(EFalse, EOsVfsOpen), 0, 0, aDbFile, aFileName);
COsLayerData& osLayerData = COsLayerData::Instance();
- TFileName fname;
- if(aFileName && !::ConvertToUnicode(aFileName, fname))
- {
- osLayerData.SetOsErrorCode(KErrBadName);
- return SQLITE_CANTOPEN;
- }
- SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileOpen, aDbFile, &fname));
new (aDbFile) TDbFile;
TDbFile& dbFile = ::DbFile(aDbFile);
- TFhStrType fhStrType = aFileName ? ::FhStringProps(aFileName) : ENotFhStr;
- if(aFileName && (aFlags & SQLITE_OPEN_DELETEONCLOSE))
+ if(!aFileName)
+ {
+ //It is to create and open a temp file if aFileName is NULL. In this case,
+ //we will defer the file creation util it is needed.
+ dbFile.pMethods = &TheFileIoApi;
+ dbFile.iIsFileCreated = EFalse;
+ if(aOutFlags)
+ {
+ *aOutFlags = SQLITE_OPEN_READWRITE;
+ }
+ osLayerData.SetOsErrorCode(KErrNone);
+ return SQLITE_OK;
+ }
+ TFileName fname;
+ if(!::ConvertToUnicode(aFileName, fname))
{
- dbFile.iFullName = fname.Alloc();
- if(!dbFile.iFullName)
- {
- osLayerData.SetOsErrorCode(KErrNoMemory);
- return SQLITE_IOERR_NOMEM;
- }
- }
- TInt recReadBufSize = -1;
+ osLayerData.SetOsErrorCode(KErrBadName);
+ return SQLITE_CANTOPEN;
+ }
+ SQLITE_TRACE_OS(OstTraceExt3(TRACE_INTERNALS, TVFS_OPEN_ENTRY, "OS-Entry;0x%X;TVfs::Open;fname=%S;aFlags=0x%X", (TUint)&aDbFile, __SQLITEPRNSTR(fname), (TUint)aFlags));
+ TFhStrType fhStrType = aFileName ? ::FhStringProps(aFileName) : ENotFhStr;
TInt err = KErrNone;
if(fhStrType == EFhMainDbStr)
{//Main db file, open from handle
@@ -2281,52 +2346,41 @@
{
fmode |= EFileShareExclusive;
}
- if(!aFileName)
+ if(aFlags & SQLITE_OPEN_DELETEONCLOSE)
+ {
+ fmode |= EDeleteOnClose;
+ }
+ err = KErrAccessDenied;
+ TInt prevErr = KErrNone;
+ if(aFlags & SQLITE_OPEN_CREATE)
{
- __FS_CALL(EFsOpFileCreateTemp, 0);
- err = dbFile.iFileBuf.Temp(osLayerData.iFs, osLayerData.iSysPrivDir, fname, fmode);
- if(err == KErrNone)
+ __FS_CALL(EFsOpFileCreate, 0);
+ prevErr = err = dbFile.iFileBuf.Create(osLayerData.iFs, fname, fmode);
+ }
+ if(err != KErrNone && err != KErrNoMemory && err != KErrDiskFull)
+ {
+ __FS_CALL(EFsOpFileOpen, 0);
+ err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
+
+ if(err == KErrNone && (aFlags & KJournalFileTypeBitMask))
{
- dbFile.iFullName = fname.Alloc();
- if(!dbFile.iFullName)
- {
- err = KErrNoMemory;
- }
+ err = TVfs::DoFileSizeCorruptionCheck(dbFile, fname, fmode);
}
}
- else
+ if((err != KErrNone && err != KErrNoMemory && err != KErrDiskFull) && (aFlags & SQLITE_OPEN_READWRITE))
+ {
+ aFlags &= ~SQLITE_OPEN_READWRITE;
+ aFlags |= SQLITE_OPEN_READONLY;
+ fmode &= ~EFileWrite;
+ __FS_CALL(EFsOpFileOpen, 0);
+ err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
+ }
+ if(err != KErrNone && prevErr == KErrAccessDenied)
{
err = KErrAccessDenied;
- TInt prevErr = KErrNone;
- if(aFlags & SQLITE_OPEN_CREATE)
- {
- __FS_CALL(EFsOpFileCreate, 0);
- prevErr = err = dbFile.iFileBuf.Create(osLayerData.iFs, fname, fmode);
- }
- if(err != KErrNone && err != KErrNoMemory && err != KErrDiskFull)
- {
- __FS_CALL(EFsOpFileOpen, 0);
- err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
-
- if(err == KErrNone && (aFlags & KJournalFileTypeBitMask))
- {
- err = TVfs::DoFileSizeCorruptionCheck(dbFile, fname, fmode);
- }
- }
- if((err != KErrNone && err != KErrNoMemory && err != KErrDiskFull) && (aFlags & SQLITE_OPEN_READWRITE))
- {
- aFlags &= ~SQLITE_OPEN_READWRITE;
- aFlags |= SQLITE_OPEN_READONLY;
- fmode &= ~EFileWrite;
- __FS_CALL(EFsOpFileOpen, 0);
- err = dbFile.iFileBuf.Open(osLayerData.iFs, fname, fmode);
- }
- if(err != KErrNone && prevErr == KErrAccessDenied)
- {
- err = KErrAccessDenied;
- }
}
}
+ TInt recReadBufSize = -1;
if(err == KErrNone)
{
err = TVfs::DoGetDeviceCharacteristicsAndSectorSize(dbFile, recReadBufSize);
@@ -2336,13 +2390,6 @@
{
__FS_CALL(EFsOpFileClose, 0);
dbFile.iFileBuf.Close();
- delete dbFile.iFullName;
- dbFile.iFullName = NULL;
- if(!aFileName && fname.Length() > 0)
- {//temporary file, the error is not KErrNone. Then delete the file (after a successfull
- //temporary file creation there could be a failed memory allocation)
- (void)osLayerData.iFs.Delete(fname);
- }
}
else
{
@@ -2360,7 +2407,9 @@
#ifdef _SQLPROFILER
dbFile.iIsJournal = aFlags & KJournalFileTypeBitMask;
#endif
- return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_CANTOPEN);
+ TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_CANTOPEN);
+ SQLITE_TRACE_OS(OstTraceExt4(TRACE_INTERNALS, TVFS_OPEN_EXIT, "OS-Exit;0x%X;TVfs::Open;outFlags=0x%X;err=%d;sqliteErr=%d", (TUint)&aDbFile, aOutFlags ? (TUint)*aOutFlags : 0, err, sqliteErr));
+ return sqliteErr;
}
/**
@@ -2383,7 +2432,6 @@
*/
/* static */ int TVfs::Delete(sqlite3_vfs* aVfs, const char* aFileName, int /*aSyncDir*/)
{
- SQLUTRACE_PROFILER(aVfs);
__OS_CALL(EOsVfsDelete, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsVfsDelete], ::OsCallProfile(EFalse, EOsVfsDelete), 0, 0, 0, aFileName);
COsLayerData& osLayerData = COsLayerData::Instance();
@@ -2391,13 +2439,15 @@
if(!::ConvertToUnicode(aFileName, fname))
{
osLayerData.SetOsErrorCode(KErrBadName);
+ SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_DELETE1, "OS;0;TVfs::Delete;err=KErrBadName"));
return SQLITE_ERROR;
}
- SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileName, &fname));
+ SQLITE_TRACE_OS(OstTraceExt1(TRACE_INTERNALS, TVFS_DELETE_ENTRY, "OS-Entry;0;TVfs::Delete;fname=%S", __SQLITEPRNSTR(fname)));
TFhStrType fhStrType = FhStringProps(aFileName);
if(fhStrType == EFhMainDbStr)
{//Deleting files not in your own private data cage - not allowed!
osLayerData.SetOsErrorCode(KErrPermissionDenied);
+ SQLITE_TRACE_OS(OstTraceExt1(TRACE_INTERNALS, TVFS_DELETE2, "OS;0;TVfs::Delete;err=KErrPermissionDenied;fname=%S", __SQLITEPRNSTR(fname)));
return SQLITE_ERROR;
}
if(fhStrType == EFhStr)
@@ -2407,7 +2457,9 @@
__FS_CALL(EFsOpFileDelete, 0);
TInt err = osLayerData.iFs.Delete(fname);
osLayerData.SetOsErrorCode(err);
- return err == KErrNone ? SQLITE_OK : (err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR_DELETE);
+ TInt sqliteErr = ::Os2SqliteErr(err, SQLITE_IOERR_DELETE);
+ SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_DELETE_EXIT, "OS-Exit;0;TVfs::Delete;err=%d;sqliteErr=%d", err, sqliteErr));
+ return sqliteErr;
}
/**
@@ -2431,7 +2483,6 @@
*/
/* static */ int TVfs::Access(sqlite3_vfs* aVfs, const char* aFileName, int aFlags, int* aResOut)
{
- SQLUTRACE_PROFILER(aVfs);
__OS_CALL(EOsVfsAccess, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsVfsAccess], ::OsCallProfile(EFalse, EOsVfsAccess), aFlags, 0, 0, aFileName);
COsLayerData& osLayerData = COsLayerData::Instance();
@@ -2439,9 +2490,10 @@
if(!::ConvertToUnicode(aFileName, fname))
{
osLayerData.SetOsErrorCode(KErrGeneral);
+ SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_ACCESS1, "OS;0;TVfs::Access;err=KErrGeneral"));
return SQLITE_IOERR_ACCESS;
}
- SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileName, &fname));
+ SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_ACCESS_ENTRY, "OS-Entry;0;TVfs::Access;fname=%S;aFlags=0x%X", __SQLITEPRNSTR(fname), (TUint)aFlags));
TFhStrType fhStrType = ::FhStringProps(aFileName);
if(fhStrType == EFhStr)
{
@@ -2454,11 +2506,13 @@
{
osLayerData.SetOsErrorCode(KErrNone);
*aResOut = 0;
+ SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_ACCESS_EXIT1, "OS-Exit;0;TVfs::Access;Exists-NoFound"));
return SQLITE_OK;
}
if(err != KErrNone)
{
osLayerData.SetOsErrorCode(err);
+ SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TVFS_ACCESS_EXIT2, "OS-Exit;0;TVfs::Access;err=%d", err));
return err == KErrNoMemory ? SQLITE_IOERR_NOMEM : SQLITE_IOERR_ACCESS;
}
*aResOut = 0;
@@ -2477,6 +2531,7 @@
break;
}
osLayerData.SetOsErrorCode(KErrNone);
+ SQLITE_TRACE_OS(OstTrace1(TRACE_INTERNALS, TVFS_ACCESS_EXIT3, "OS-Exit;0;TVfs::Access;aResOut=%d", *aResOut));
return SQLITE_OK;
}
@@ -2508,7 +2563,6 @@
*/
/* static */ int TVfs::FullPathName(sqlite3_vfs* aVfs, const char* aRelative, int aBufLen, char* aBuf)
{
- SQLUTRACE_PROFILER(aVfs);
__OS_CALL(EOsVfsFullPathName, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsVfsFullPathName], ::OsCallProfile(EFalse, EOsVfsFullPathName), aBufLen, 0, 0, aRelative);
COsLayerData& osLayerData = COsLayerData::Instance();
@@ -2517,9 +2571,10 @@
TBuf<KMaxFileName + 1> fname;
if(!::ConvertToUnicode(aRelative, fname))
{
+ SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME1, "OS;0;TVfs::FullPathName;err=SQLITE_ERROR"));
return SQLITE_ERROR;
}
- SYMBIAN_TRACE_SQL_EVENTS_ONLY(UTF::Printf(UTF::TTraceContext(UTF::EInternals), KFileName, &fname));
+ SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TVFS_FULLPATHNAME_ENTRY, "OS-Entry;0;TVfs::FullPathName;fname=%S;aBufLen=%d", __SQLITEPRNSTR(fname), aBufLen));
//Zero-terminate the converted file name
fname.Append(TChar(0));
TParse parse;
@@ -2538,8 +2593,10 @@
if(!::ConvertFromUnicode(parse.FullName(), dest8))
{//Zero the stored fh data, because it has been initialized by the FhExtractAndStore(fname) call (couple of lines above)
osLayerData.StoreFhData(NULL, EFalse);
+ SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME_EXIT1, "OS-Exit;0;TVfs::FullPathName;err=SQLITE_ERROR"));
return SQLITE_ERROR;
}
+ SQLITE_TRACE_OS(OstTrace0(TRACE_INTERNALS, TVFS_FULLPATHNAME_EXIT2, "OS-Exit;0;TVfs::FullPathName;err=SQLITE_OK"));
return SQLITE_OK;
}
@@ -2555,7 +2612,6 @@
*/
/* static */ int TVfs::Randomness(sqlite3_vfs* aVfs, int aBufLen, char* aBuf)
{
- SQLUTRACE_PROFILER(aVfs);
__OS_CALL(EOsVfsRandomness, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsVfsRandomness], ::OsCallProfile(EFalse, EOsVfsRandomness), aBufLen, 0, 0, 0);
COsLayerData& osLayerData = COsLayerData::Instance();
@@ -2579,7 +2635,6 @@
*/
/* static */ int TVfs::Sleep(sqlite3_vfs* aVfs, int aMicrosec)
{
- SQLUTRACE_PROFILER(aVfs);
__OS_CALL(EOsVfsSleep, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsVfsSleep], ::OsCallProfile(EFalse, EOsVfsSleep), aMicrosec, 0, 0, 0);
User::AfterHighRes(TTimeIntervalMicroSeconds32(aMicrosec));
@@ -2599,7 +2654,6 @@
*/
/* static */ int TVfs::CurrentTime(sqlite3_vfs* aVfs, double* aNow)
{
- SQLUTRACE_PROFILER(aVfs);
__OS_CALL(EOsVfsCurrentTime, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsVfsCurrentTime], ::OsCallProfile(EFalse, EOsVfsCurrentTime), 0, 0, 0, 0);
TTime now;
@@ -2635,7 +2689,6 @@
*/
/* static */int TVfs::GetLastError(sqlite3_vfs* aVfs, int /*aBufLen*/, char* /*aBuf*/)
{
- SQLUTRACE_PROFILER(aVfs);
__OS_CALL(EOsVfsGetLastError, 0, 0);
__OSTIME_COUNTER(TheOsCallTicks[EOsVfsGetLastError], ::OsCallProfile(EFalse, EOsVfsGetLastError), 0, 0, 0, 0);
return 0;