// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\drivers\locmedia\locmedia.cpp

// 

//

#include "locmedia.h"

#include <d32locd.h>

#include "dmasupport.h"

#include <kernel/cache.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "locmedia_ost.h"

#ifdef __VC32__

#pragma warning(disable: 4127) // disabling warning "conditional expression is constant"

#endif

#include "locmediaTraces.h"

#endif

#if defined(_DEBUG) && defined(__DEMAND_PAGING__)

//#define __DEBUG_DEMAND_PAGING__

#endif

#if 0

#define CHECK_RET(r)	if ((r)==KErrNotSupported && (KDebugNum(KSCRATCH))) {NKern::Lock(); *(TInt*)0xfaece5=0;}

//#define CHECK_RET(r)

#else

#define CHECK_RET(r)

#endif

_LIT(KLddName,"LocDrv");

_LIT(KLitMediaDriverName, "Media.*");

_LIT(KLitLocMedia,"LocMedia");

#define LOCM_FAULT()	Kern::Fault("LOCMEDIA",__LINE__)

const TInt KMaxLocalDriveCapsLength=256;

const TInt KMaxQueryDeviceLength=256;

// The maximum amount of user-data which will be pinned. If a request is longer 

// than this value it will be split up into a number of requests

// This value is a bit arbitrary - it needs to be sufficiently large so that transfer 

// rates don't suffer too much - but it can't be too big or we'd be "stealing" too much 

// memory from the demand paging pool and starving other processes

const TInt KMaxPinData = 256*1024;

// The number of locks available for pinning shared by all the drive threads in the system. 

// If all locks are in use then a single pre-allocated lock is used.

const TInt KDynamicPagingLockCount = 8;

TLocDrv* TheDrives[KMaxLocalDrives];

DMedia* TheMedia[KMaxLocalDrives];

HBuf* DriveNames[KMaxLocalDrives];

TInt UsedMedia=0;

TPasswordStore* ThePasswordStore=NULL;

class DPrimaryMediaBase::DBody : public DBase

	{

public:

	DBody(DPrimaryMediaBase& aPrimaryMediaBase);

public:

	DPrimaryMediaBase& iPrimaryMediaBase;	// ptr to parent

	TInt iPhysDevIndex;

	TInt iRequestCount;

#ifdef __DEMAND_PAGING__

	DMediaPagingDevice* iPagingDevice;

	TInt iPageSizeMsk;			// Mask of page size (e.g. 4096-1 -> 4095)

	TInt iMediaChanges;

#endif

	// This bit mask indicates which local drives the media is attached to

	TUint32 iRegisteredDriveMask;

	// Set to ETrue for media extension drivers

	TBool iMediaExtension;

	// Media change DFCs to allow media change events from attached media

	// to be handled in the context of an extension media's thread

	TDfc iMediaChangeDfc;

	TDfc iMediaPresentDfc;

	};

#ifdef __DEMAND_PAGING__

DMediaPagingDevice* ThePagingDevices[KMaxLocalDrives];

DPrimaryMediaBase* TheRomPagingMedia = NULL;

DPrimaryMediaBase* TheDataPagingMedia = NULL;

TLocDrv* TheDataPagingDrive = NULL;

TBool DataPagingDeviceRegistered = EFalse;

class DPinObjectAllocator;

DPinObjectAllocator* ThePinObjectAllocator = NULL;

// The paging media might share a DfcQ with other non-paging media (e.g. 2 MMC/SD cards sharing the same stack)

// In this case, we need to avoid taking page faults on the non-paging media too, hence the need for these checks:

inline TBool DataPagingDfcQ(DPrimaryMediaBase* aPrimaryMedia)

	{return TheDataPagingMedia && TheDataPagingMedia->iDfcQ == aPrimaryMedia->iDfcQ;}

TBool DataPagingMedia(DPrimaryMediaBase* aPrimaryMedia)

	{

	for (TLocDrv* drv = TheDataPagingDrive; drv; drv = drv->iNextDrive)

		if (drv->iPrimaryMedia == aPrimaryMedia)

			return ETrue;

	return EFalse;

	}

inline TBool RomPagingDfcQ(DPrimaryMediaBase* aPrimaryMedia)

	{return TheRomPagingMedia && TheRomPagingMedia->iDfcQ == aPrimaryMedia->iDfcQ;}

#if defined(_DEBUG)

	#define SETDEBUGFLAG(aBitNum) {Kern::SuperPage().iDebugMask[aBitNum >> 5] |= (1 << (aBitNum & 31));}

	#define CLRDEBUGFLAG(aBitNum) {Kern::SuperPage().iDebugMask[aBitNum >> 5] &= ~(1 << (aBitNum & 31));}

#else

	#define SETDEBUGFLAG(aBitNum)

	#define CLRDEBUGFLAG(aBitNum)

#endif

/* 

DPinObjectAllocator

Internal class which contains :

	(1) a queue of pre-allocated TVirtualPinObject's; 

	(2) a single pre-allocated DFragmentationPagingLock object: 

		this may be used if there are no TVirtualPinObject's available or if Kern::PinVirtualMemory() fails

@internalTechnology

*/

NONSHARABLE_CLASS(DPinObjectAllocator) : public DBase

	{

public:

	/*

	SVirtualPinContainer

	Internal class encapsulating a TVirtualPinObject.

	Contains a SDblQueLink so that it may form part of a SDblQue

	*/

	typedef struct

		{

		TVirtualPinObject* iObject;

		SDblQueLink iLink;

		} SVirtualPinContainer;

public:

	inline DPinObjectAllocator() {};

	~DPinObjectAllocator();

	TInt Construct(TInt aObjectCount, TUint aNumPages);

	SVirtualPinContainer* AcquirePinObject();

	void ReleasePinObject(SVirtualPinContainer* aVirtualPinObject);

	inline DFragmentationPagingLock& PreAllocatedDataLock() {return *iPreAllocatedDataLock;}

private:

	// array of SVirtualPinContainer's

	SVirtualPinContainer* iVirtualPinContainers;

	TInt iObjectCount;

	// queues containing SVirtualPinContainer's

	SDblQue iFreeQ;

	// pre-allocated (small) buffers for locking client data should Kern::PinVirtualMemory() fail

	DFragmentationPagingLock* iPreAllocatedDataLock;

	// A mutex to protect access to the pinning objects.

	NFastMutex iLock;

public:

	TUint iFragmentGranularity;

	};

DPinObjectAllocator::~DPinObjectAllocator()

	{

	OstTraceFunctionEntry1( DPINOBJECTALLOCATOR_DPINOBJECTALLOCATOR_ENTRY, this );

	if (iPreAllocatedDataLock)

		{

		iPreAllocatedDataLock->Cleanup();

		delete iPreAllocatedDataLock;

		}

	for (TInt n=0; iVirtualPinContainers!= NULL && n<iObjectCount; n++)

		{

		SVirtualPinContainer& virtualPinContainer = iVirtualPinContainers[n];

		if (virtualPinContainer.iObject)

			Kern::DestroyVirtualPinObject(virtualPinContainer.iObject);

		}

	delete [] iVirtualPinContainers;

	OstTraceFunctionExit1( DPINOBJECTALLOCATOR_DPINOBJECTALLOCATOR_EXIT, this );

	}

TInt DPinObjectAllocator::Construct(TInt aObjectCount, TUint aNumPages)

	{

	OstTraceFunctionEntryExt( DPINOBJECTALLOCATOR_CONSTRUCT_ENTRY, this );

	TInt pageSize = Kern::RoundToPageSize(1);

	iFragmentGranularity = pageSize * aNumPages;

	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Fragmentation granularity set to 0x%x", iFragmentGranularity));

	OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPINOBJECTALLOCATOR_CONSTRUCT, "Fragmentation granularity=0x%x", iFragmentGranularity);

	// construct the paging lock containing pre-allocated buffers

	iPreAllocatedDataLock = new DFragmentationPagingLock();

	if(!iPreAllocatedDataLock)

	    {

		OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT1, this, KErrNoMemory );

		return KErrNoMemory;

	    }

	TInt r = iPreAllocatedDataLock->Construct(aNumPages);

	if (r != KErrNone)

	    {

		OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT2, this, r );

		return r;

	    }

	iVirtualPinContainers = new SVirtualPinContainer[aObjectCount];

	if (iVirtualPinContainers == NULL)

	    {

		OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT3, this, KErrNoMemory );

		return KErrNoMemory;

	    }

	memclr(iVirtualPinContainers, sizeof(SVirtualPinContainer) * aObjectCount);

	iObjectCount = aObjectCount;

	// construct the queue of dynamic paging locks

	for (TInt n=0; n<aObjectCount; n++)

		{

		SVirtualPinContainer& pinContainer = iVirtualPinContainers[n];

		TInt r = Kern::CreateVirtualPinObject(pinContainer.iObject);

		if (r != KErrNone)

		    {

			OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT4, this, KErrNoMemory );

			return KErrNoMemory;

		    }

		iFreeQ.Add(&pinContainer.iLink);

		}

	OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT5, this, KErrNone );

	return KErrNone;

	}

/** 

returns a SVirtualPinContainer object or NULL if NULL available

*/

DPinObjectAllocator::SVirtualPinContainer* DPinObjectAllocator::AcquirePinObject()

	{

	OstTraceFunctionEntry1( DPINOBJECTALLOCATOR_ACQUIREPINOBJECT_ENTRY, this );

	SVirtualPinContainer* pinContainer = NULL;

	NKern::FMWait(&iLock);

	if (!iFreeQ.IsEmpty())

		{

		SDblQueLink* link = iFreeQ.First();

		pinContainer = _LOFF(link, SVirtualPinContainer, iLink);

		link->Deque();

		}

	NKern::FMSignal(&iLock);

	OstTraceFunctionExit1( DPINOBJECTALLOCATOR_ACQUIREPINOBJECT_EXIT, this );

	return pinContainer;

	}

/** 

returns a SVirtualPinContainer object to the pool

*/

void DPinObjectAllocator::ReleasePinObject(SVirtualPinContainer* aPinContainer)

	{

	OstTraceFunctionEntry1( DPINOBJECTALLOCATOR_RELEASEPINOBJECT_ENTRY, this );

	NKern::FMWait(&iLock);

	iFreeQ.Add(&aPinContainer->iLink);

	NKern::FMSignal(&iLock);

	OstTraceFunctionExit1( DPINOBJECTALLOCATOR_RELEASEPINOBJECT_EXIT, this );

	}

#endif	// __DEMAND_PAGING__

/* 

TDriveIterator

Internal class which supports iterating through all local drives (TLocDrv's)

If there are media extensions present, then this will iterate through all attached drives.

@internalTechnology

*/

class TDriveIterator

	{

public:

	TDriveIterator();

	TLocDrv* NextDrive();

	inline TInt Index()

		{return iIndex;}

	static TLocDrv* GetDrive(TInt aDriveNum, DPrimaryMediaBase* aPrimaryMedia);

	static TLocDrv* GetPhysicalDrive(TLocDrv* aDrv);

#if defined(__DEMAND_PAGING__) && defined(__DEMAND_PAGING_BENCHMARKS__)

	static DMediaPagingDevice* PagingDevice(TInt aDriveNum, DPagingDevice::TType aType);

#endif

private:

	TInt iIndex;

	TLocDrv* iDrive;

	};

TDriveIterator::TDriveIterator() :

	iIndex(0), iDrive(NULL)

	{

	}

TLocDrv* TDriveIterator::NextDrive()

	{

	if (iDrive)	// i.e. if not first time

		{

		if (iDrive->iNextDrive)

			{

			iDrive = iDrive->iNextDrive;

			return iDrive;

			}

		iIndex++;

		}

	for (iDrive = NULL; iIndex < KMaxLocalDrives; iIndex++)

		{

		iDrive = TheDrives[iIndex];

		if (iDrive)

			break;

		}

	return iDrive;

	}

/*

Returns the first TLocDrv in the chain of attached drives which matches DPrimaryMediaBase

*/

TLocDrv* TDriveIterator::GetDrive(TInt aDriveNum, DPrimaryMediaBase* aPrimaryMedia)

	{

	TLocDrv* drive = TheDrives[aDriveNum];

	while (drive && drive->iPrimaryMedia != aPrimaryMedia)

		{

		drive = drive->iNextDrive ? drive->iNextDrive : NULL;

		}

	return drive;

	}

/*

Returns the last TLocDrv in the chain of attached drives - 

i.e. the TLocDrv attached to physical media rather than a TLocDrv corresponding to a media extension 

*/

TLocDrv* TDriveIterator::GetPhysicalDrive(TLocDrv* aDrv)

	{

	__ASSERT_DEBUG(aDrv, LOCM_FAULT());

	while (aDrv->iNextDrive)

		aDrv = aDrv->iNextDrive;

	return aDrv;

	}

#if defined(__DEMAND_PAGING__) && defined(__DEMAND_PAGING_BENCHMARKS__)

DMediaPagingDevice* TDriveIterator::PagingDevice(TInt aDriveNum, DPagingDevice::TType aType)

	{

	TLocDrv* drive = TheDrives[aDriveNum];

	DMediaPagingDevice* pagingDevice = drive ? drive->iPrimaryMedia->iBody->iPagingDevice : NULL;

	while (drive && (pagingDevice == NULL || (pagingDevice->iType & aType) == 0))

		{

		drive = drive->iNextDrive ? drive->iNextDrive : NULL;

		pagingDevice = drive ? drive->iPrimaryMedia->iBody->iPagingDevice : NULL;

		}

	return pagingDevice;

	}

#endif

/********************************************

 * Local drive device base class

 ********************************************/

DECLARE_EXTENSION_LDD()

	{

	return new DLocalDriveFactory;

	}

DLocalDriveFactory::DLocalDriveFactory()

//

// Constructor

//

	{

	OstTraceFunctionEntry1( DLOCALDRIVEFACTORY_DLOCALDRIVEFACTORY_ENTRY, this );

	iParseMask=KDeviceAllowUnit|KDeviceAllowInfo;

	iUnitsMask=~(0xffffffff<<KMaxLocalDrives);

	iVersion=TVersion(KLocalDriveMajorVersion,KLocalDriveMinorVersion,KLocalDriveBuildVersion);

	OstTraceFunctionExit1( DLOCALDRIVEFACTORY_DLOCALDRIVEFACTORY_EXIT, this );

	}

TInt DLocalDriveFactory::Install()

//

// Install the device driver.

//

	{

	return SetName(&KLddName);

	}

void DLocalDriveFactory::GetCaps(TDes8& /*aDes*/) const

//

// Return the Comm capabilities.

//

	{

//	TCapsLocalDriveV01 b;

//	b.version=iVersion;

//	aDes.FillZ(aDes.MaxLength());

//	aDes.Copy((TUint8 *)&b,Min(aDes.MaxLength(),sizeof(b)));

	}

TInt DLocalDriveFactory::Create(DLogicalChannelBase*& aChannel)

//

// Create a channel on the device.

//

	{

	OstTraceFunctionEntry1( DLOCALDRIVEFACTORY_CREATE_ENTRY, this );

	aChannel=new DLocalDrive;

	return aChannel?KErrNone:KErrNoMemory;

	}

/********************************************

 * Local drive interface class

 ********************************************/

DLocalDrive::DLocalDrive() :

	iMediaChangeObserver(MediaChangeCallback, this, TCallBackLink::EDLocalDriveObject)

	{

//	iLink.iNext=NULL;

	}

DLocalDrive::~DLocalDrive()

	{

	OstTraceFunctionEntry1( DLOCALDRIVE_DLOCALDRIVE_ENTRY, this );

	if (iDrive)

		{

		__KTRACE_OPT(KLOCDRV,Kern::Printf(">DLocalDrive::DoClose D:%d, M:%08x",iDrive->iDriveNumber,iDrive->iMedia));

		iDrive->Disconnect(this);

		__KTRACE_OPT(KLOCDRV,Kern::Printf("<DLocalDrive::DoClose D:%d, M:%08x",iDrive->iDriveNumber,iDrive->iMedia));

		}

	DThread* pC=NULL;

	NKern::LockSystem();

	if (iCleanup.iThread)

		{

		pC=iCleanup.iThread;

		iCleanup.Remove();

		iCleanup.iThread=NULL;

		}

	NKern::UnlockSystem();

	if (pC)	// original client may already have terminated

		{

		if (iNotifyChangeRequest)

			Kern::QueueRequestComplete(pC,iNotifyChangeRequest,KErrCancel);

		pC->Close(NULL);	// balances Open() in DoCreate

		}

	if (iNotifyChangeRequest)

		Kern::DestroyClientRequest(iNotifyChangeRequest);

	OstTraceFunctionExit1( DLOCALDRIVE_DLOCALDRIVE_EXIT, this );

	}

TInt DLocalDrive::DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer)

	{

    OstTraceFunctionEntry1( DLOCALDRIVE_DOCREATE_ENTRY, this );

	if(!Kern::CurrentThreadHasCapability(ECapabilityTCB,__PLATSEC_DIAGNOSTIC_STRING("Checked by ELOCD.LDD (Local Media Driver)")))

	    {

		OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT1, this, KErrPermissionDenied );

		return KErrPermissionDenied;

	    }

	if (!Kern::QueryVersionSupported(TVersion(KLocalDriveMajorVersion,KLocalDriveMinorVersion,KLocalDriveBuildVersion),aVer))

	    {

		OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT2, this, KErrNotSupported );

		return KErrNotSupported;

	    }

	NKern::ThreadEnterCS();

	TInt r = Kern::CreateClientDataRequest(iNotifyChangeRequest);

	NKern::ThreadLeaveCS();

	if (r != KErrNone)

	    {

		OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT3, this, r );

		return r;

	    }

	DThread& t=Kern::CurrentThread();

	NKern::LockSystem();

	t.AddCleanup(&iCleanup);

	NKern::UnlockSystem();

	t.Open();

	iNotifyChangeRequest->SetDestPtr((TBool*) anInfo);

	iDrive=TheDrives[aUnit];

	if (!iDrive)

	    {

		OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT4, this, KErrNotSupported );