Symaptic: os/persistentdata/persistentstorage/sql/SRC/Server/SqlSrvDriveSpace.cpp@260cb5ec6c19

     1 // Copyright (c) 2004-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Reserving/Accessing/Releasing drive space - CSqlDriveSpace and RSqlDriveSpaceCol classes implementations

    15 //

    16 //

    18 #include "SqlSrvDriveSpace.h"

    19 #include "SqlAssert.h"

    20 #include "OstTraceDefinitions.h"

    21 #ifdef OST_TRACE_COMPILER_IN_USE

    22 #include "SqlSrvDriveSpaceTraces.h"

    23 #endif

    24 #include "SqlTraceDef.h"

    26 /**

    27 The amount of the disk space, which will be reserved at the moment of creation of

    28 each CDriveSpace object.

    29 It should be enough for the most of "delete" transactions, if they do not require a rollback transaction

    30 file, bigger than KReservedDiskSpace bytes.

    32 Note: this is the max possible amount, which can be reserved per file session.

    33       Look for KMaxSessionDriveReserved constant value.

    35 @internalComponent

    36 */

    37 const TInt KReservedDiskSpace = 64 * 1024;

    39 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    40 ////////////////////////////////    CSqlDriveSpace class    //////////////////////////////////////////////////////

    41 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    43 /**

    44 Standard phase-one factory method for creation of CSqlDriveSpace objects.

    46 @param aFs File session instance

    47 @param aDrive Drive number

    49 @return A pointer to the created CSqlDriveSpace object.

    51 @leave KErrNoMemory,  Out of memory condition has occured;

    52 	   RFs::ReserveDriveSpace() return values.

    54 @panic SqlDb 4 In _DEBUG mode if aDrive is invalid

    56 @see RFs::ReserveDriveSpace()

    57 */

    58 CSqlDriveSpace* CSqlDriveSpace::NewLC(RFs& aFs, TDriveNumber aDrive)

    59     {

    60 	SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, CSQLDRIVESPACE_NEWLC_ENTRY, "Entry;0;CSqlDriveSpace::NewLC;aFs.Handle()=0x%X;aDrive=%d", (TUint)aFs.Handle(), (TInt)aDrive));

    61 	__ASSERT_DEBUG(aDrive >= EDriveA && aDrive <= EDriveZ, __SQLPANIC2(ESqlPanicBadArgument));

    62     CSqlDriveSpace* self = new (ELeave) CSqlDriveSpace(aFs, aDrive);

    63     CleanupStack::PushL(self);

    64     self->ConstructL();

    65 	SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, CSQLDRIVESPACE_NEWLC_EXIT, "Exit;0x%X;CSqlDriveSpace::NewLC", (TUint)self));

    66     return self;

    67     }

    69 /**

    70 Frees the reserved disk space.

    71 */

    72 CSqlDriveSpace::~CSqlDriveSpace()

    73     {

    74 	SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLDRIVESPACE_CSQLDRIVESPACE2, "0x%X;CSqlDriveSpace::~CSqlDriveSpace;iDrive=%d;iGetAccessRefCnt=%d", (TUint)this, (TInt)iDrive, iGetAccessRefCnt));

    75 	SQLDRIVESPACE_INVARIANT();

    76 	(void)iFs.ReleaseReserveAccess(static_cast <TInt> (iDrive));

    77 	(void)iFs.ReserveDriveSpace(static_cast <TInt> (iDrive), 0);

    78     }

    80 /**

    81 Gives an access to the already reserved drive space. The method uses RFs::GetReserveAccess()

    82 for that. RFs::GetReserveAccess() will be called only once, when iGetAccessRefCnt is 0 -

    83 this is a shared file session instance.

    85 @leave RFs::GetReserveAccess() return values

    87 @see RFs::GetReserveAccess()

    89 @panic SqlDb 12 In _DEBUG mode if iGetAccessRefCnt < 0

    90 */

    91 void CSqlDriveSpace::GetAccessL()

    92 	{

    93 	SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLDRIVESPACE_GETACCESSL_ENTRY, "Entry;0x%X;CSqlDriveSpace::GetAccessL;iDrive=%d;iGetAccessRefCnt=%d", (TUint)this, (TInt)iDrive, iGetAccessRefCnt));

    94 	SQLDRIVESPACE_INVARIANT();

    95 	//Gets an access only once, there is only one RFs session instance.

    96 	if(iGetAccessRefCnt == 0)

    97 		{

    98 		__SQLLEAVE_IF_ERROR(iFs.GetReserveAccess(static_cast <TInt> (iDrive)));

    99 		}

   100 	++iGetAccessRefCnt;

   101 	SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLDRIVESPACE_GETACCESSL_EXIT, "Exit;0x%X;CSqlDriveSpace::GetAccessL;iDrive=%d;iGetAccessRefCnt=%d", (TUint)this, (TInt)iDrive, iGetAccessRefCnt));

   102 	SQLDRIVESPACE_INVARIANT();

   103 	}

   105 /**

   106 Revokes access to the reserved drive space.

   108 The method calls RFs::ReleaseReserveAccess() only when iGetAccessRefCnt value reaches 0.

   110 @see RFs::ReleaseReserveAccess()

   112 @panic SqlDb 12 In _DEBUG mode if iGetAccessRefCnt < 0

   113 */

   114 void CSqlDriveSpace::ReleaseAccess()

   115 	{

   116 	SQL_TRACE_INTERNALS(OstTraceExt3(TRACE_INTERNALS, CSQLDRIVESPACE_RELEASEACCESS, "0x%X;CSqlDriveSpace::ReleaseAccess;iDrive=%d;iGetAccessRefCnt=%d", (TUint)this, (TInt)iDrive, iGetAccessRefCnt));

   117 	SQLDRIVESPACE_INVARIANT();

   118     if(iGetAccessRefCnt == 0)

   119         {

   120         return;

   121         }

   122 	if(--iGetAccessRefCnt == 0)

   123 		{

   124         //I can't see any reason to bother the caller with errors, when the access to the

   125         //reserved space is revoked.

   126 		(void)iFs.ReleaseReserveAccess(static_cast <TInt> (iDrive));

   127 		}

   128 	SQLDRIVESPACE_INVARIANT();

   129 	}

   131 /**

   132 @param aFs File session instance

   133 @param aDrive Drive number

   135 @panic SqlDb 4 In _DEBUG mode if aDrive is invalid

   136 */

   137 CSqlDriveSpace::CSqlDriveSpace(RFs& aFs, TDriveNumber aDrive) :

   138 	iFs(aFs),

   139 	iDrive(aDrive)

   140 	{

   141 	__ASSERT_DEBUG(aDrive >= EDriveA && aDrive <= EDriveZ, __SQLPANIC(ESqlPanicBadArgument));

   142 	}

   144 /**

   145 Standard phase-two construction method for creation of CSqlDriveSpace objects.

   147 It will reserve a predefined amount of a disk space, enough for the most of the

   148 "delete" transactions, used by the applications.

   150 @leave RFs::ReserveDriveSpace() return values

   152 @see RFs::ReserveDriveSpace()

   153 */

   154 void CSqlDriveSpace::ConstructL()

   155     {

   156 	__SQLLEAVE_IF_ERROR(iFs.ReserveDriveSpace(static_cast <TInt> (iDrive), KReservedDiskSpace));

   157 	SQLDRIVESPACE_INVARIANT();

   158     }

   160 #ifdef _DEBUG

   161 /**

   162 CSqlDriveSpace invariant.

   163 */

   164 void CSqlDriveSpace::Invariant() const

   165 	{

   166 	__ASSERT_DEBUG(iDrive >= EDriveA && iDrive <= EDriveZ, __SQLPANIC(ESqlPanicInternalError));

   167 	__ASSERT_DEBUG(iGetAccessRefCnt >= 0, __SQLPANIC(ESqlPanicMisuse));

   168 	}

   169 #endif//_DEBUG

   171 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   172 ////////////////////////////////    RSqlDriveSpaceCol class    ///////////////////////////////////////////////////

   173 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   175 RSqlDriveSpaceCol::RSqlDriveSpaceCol() :

   176 	iFs(NULL)

   177 	{

   178 	}

   180 /**

   181 @param aFs A reference to file session instance

   182 */

   183 void RSqlDriveSpaceCol::Create(RFs& aFs)

   184 	{

   185 	iFs = &aFs;

   186 	SQLDRIVESPACECOL_INVARIANT();

   187 	}

   189 /**

   190 The method releases all the resources used by RSqlDriveSpaceCol object, including and

   191 reserved drive spaces on all drives in the collection.

   192 */

   193 void RSqlDriveSpaceCol::ResetAndDestroy()

   194 	{

   195 	//Forced release of the reserved space

   196 	for(TInt i=iDriveSpaceCol.Count()-1;i>=0;--i)

   197 		{

   198 		delete iDriveSpaceCol[i];

   199 		}

   200 	iDriveSpaceCol.Close();

   201 	iFs = NULL;

   202 	}

   204 /**

   205 Searches the collection for a CSqlDriveSpace object holding information about the reserved space on aDrive drive.

   207 @param aDrive Drive number.

   209 @return A pointer to the CSqlDriveSpace object, which handles drive space reservation requests

   210         for aDriveNo drive. If there is no such object, the method returns NULL.

   212 @panic SqlDb 4 In _DEBUG mode if aDrive is invalid

   213 */

   214 CSqlDriveSpace* RSqlDriveSpaceCol::Find(TDriveNumber aDrive)

   215     {

   216 	__ASSERT_DEBUG(aDrive >= EDriveA && aDrive <= EDriveZ, __SQLPANIC(ESqlPanicBadArgument));

   217 	SQLDRIVESPACECOL_INVARIANT();

   218     for(TInt index=iDriveSpaceCol.Count()-1;index>=0;--index)

   219         {

   220         if(iDriveSpaceCol[index]->Drive() == aDrive)

   221             {

   222             return iDriveSpaceCol[index];

   223             }

   224         }

   225 	SQLDRIVESPACECOL_INVARIANT();

   226     return NULL;

   227     }

   229 /**

   230 The method creates a new CSqlDriveSpace object, adds it to the collection and returns a pointer to it.

   232 @param aDrive Drive number.

   234 @return A pointer to the created CDriveSpace object, which handles drive space

   235         reservation requests for aDriveNo drive.

   237 @leave System-wide error codes, including KErrNoMemory.

   239 @panic SqlDb 4, In _DEBUG mode if aDrive is invalid.

   240 @panic SqlDb 12, In _DEBUG mode if a CDriveSpace object already exists for aDrive.

   241 */

   242 CSqlDriveSpace* RSqlDriveSpaceCol::AddL(TDriveNumber aDrive)

   243 	{

   244 	__ASSERT_DEBUG(aDrive >= EDriveA && aDrive <= EDriveZ, __SQLPANIC(ESqlPanicBadArgument));

   245     __ASSERT_DEBUG(!Find(aDrive), __SQLPANIC(ESqlPanicMisuse));

   246 	SQLDRIVESPACECOL_INVARIANT();

   247     CSqlDriveSpace* drvSpace = CSqlDriveSpace::NewLC(*iFs, aDrive);

   248     __SQLLEAVE_IF_ERROR(iDriveSpaceCol.Append(drvSpace));

   249     CleanupStack::Pop(drvSpace);

   250 	SQLDRIVESPACECOL_INVARIANT();

   251     return drvSpace;

   252 	}

   254 #ifdef _DEBUG

   255 /**

   256 RSqlDriveSpaceCol invariant.

   257 */

   258 void RSqlDriveSpaceCol::Invariant() const

   259 	{

   260 	__ASSERT_DEBUG(iFs != NULL, __SQLPANIC(ESqlPanicInternalError));

   261     for(TInt index=iDriveSpaceCol.Count()-1;index>=0;--index)

   262     	{

   263 		iDriveSpaceCol[index]->Invariant();

   264     	}

   265 	}

   266 #endif//_DEBUG

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--