userlibandfileserver/fileserver/sfile/sf_ext.cpp
branchRCL_3
changeset 43 c1f20ce4abcf
parent 41 0ffb4e86fcc9
child 44 3e88ff8f41d5
equal deleted inserted replaced
42:a179b74831c9 43:c1f20ce4abcf
    13 // Description:
    13 // Description:
    14 // f32\sfile\sf_ext.cpp
    14 // f32\sfile\sf_ext.cpp
    15 // 
    15 // 
    16 //
    16 //
    17 
    17 
    18 
       
    19 #include "sf_std.h"
    18 #include "sf_std.h"
    20 
    19 #ifdef OST_TRACE_COMPILER_IN_USE
       
    20 #include "sf_extTraces.h"
       
    21 #endif
    21 typedef CProxyDriveFactory*(*TExtensionNew)();
    22 typedef CProxyDriveFactory*(*TExtensionNew)();
    22 typedef CExtProxyDriveFactory*(*TProxyDriveNew)();
    23 typedef CExtProxyDriveFactory*(*TProxyDriveNew)();
    23 
    24 
    24 
    25 
    25 /**
    26 /**
   324 
   325 
   325 @return pointer to instantiated CLocalProxyDrive object.
   326 @return pointer to instantiated CLocalProxyDrive object.
   326 */
   327 */
   327 CLocalProxyDrive* CLocalProxyDrive::New(CMountCB* aMount,TBusLocalDrive& aLocDrv)
   328 CLocalProxyDrive* CLocalProxyDrive::New(CMountCB* aMount,TBusLocalDrive& aLocDrv)
   328 	{
   329 	{
   329 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveNew, EF32TraceUidProxyDrive, 
   330 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVENEW, "aMount %x drive %d", (TUint) aMount, (TUint) aMount->DriveNumber());
   330 		aMount, aMount->DriveNumber());
       
   331 
       
   332 	CLocalProxyDrive* proxyDrive = new CLocalProxyDrive(aMount,aLocDrv);
   331 	CLocalProxyDrive* proxyDrive = new CLocalProxyDrive(aMount,aLocDrv);
   333 	
   332 	
   334 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveNewRet, EF32TraceUidProxyDrive, proxyDrive);
   333 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVENEWRET, "proxyDrive %x", proxyDrive);
   335 	return proxyDrive;
   334 	return proxyDrive;
   336 	}
   335 	}
   337 
   336 
   338 /**
   337 /**
   339 Constructor.
   338 Constructor.
   355 
   354 
   356 @return KErrNone.
   355 @return KErrNone.
   357 */
   356 */
   358 TInt CLocalProxyDrive::Initialise()
   357 TInt CLocalProxyDrive::Initialise()
   359 	{
   358 	{
   360 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveInitialise, EF32TraceUidProxyDrive, this);
   359 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEINITIALISE, "this %x", this);
   361 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveInitialiseRet, EF32TraceUidProxyDrive, KErrNone);
   360 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEINITIALISERET, "r %d", KErrNone);
   362 
       
   363 	return(KErrNone);
   361 	return(KErrNone);
   364 	}
   362 	}
   365 
   363 
   366 
   364 
   367 /**
   365 /**
   371 
   369 
   372 @return KErrNone.
   370 @return KErrNone.
   373 */
   371 */
   374 TInt CLocalProxyDrive::Dismounted()
   372 TInt CLocalProxyDrive::Dismounted()
   375 	{
   373 	{
   376 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveDismounted, EF32TraceUidProxyDrive, this);
   374 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEDISMOUNTED, "this %x", this);
   377 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveDismountedRet, EF32TraceUidProxyDrive, KErrNone);
   375 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEDISMOUNTEDRET, "r %d", KErrNone);
   378 
       
   379 	return(KErrNone);
   376 	return(KErrNone);
   380 	}
   377 	}
   381 
   378 
   382 
   379 
   383 /**
   380 /**
   387 
   384 
   388 @return system wide error code.
   385 @return system wide error code.
   389 */
   386 */
   390 TInt CLocalProxyDrive::Enlarge(TInt aLength)
   387 TInt CLocalProxyDrive::Enlarge(TInt aLength)
   391 	{
   388 	{
   392 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveEnlarge, EF32TraceUidProxyDrive, this, aLength);
   389 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEENLARGE, "this %x aLength %d", (TUint) this, (TUint) aLength);
   393 
       
   394 	TInt r = iLocDrv.Enlarge(aLength);
   390 	TInt r = iLocDrv.Enlarge(aLength);
   395 
   391 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEENLARGERET, "r %d", r);
   396 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveEnlargeRet, EF32TraceUidProxyDrive, r);
       
   397 	return r;
   392 	return r;
   398 	}
   393 	}
   399 
   394 
   400 
   395 
   401 /**
   396 /**
   409 
   404 
   410 @return system wide error code.
   405 @return system wide error code.
   411 */
   406 */
   412 TInt CLocalProxyDrive::ReduceSize(TInt aPos, TInt aLength)
   407 TInt CLocalProxyDrive::ReduceSize(TInt aPos, TInt aLength)
   413 	{
   408 	{
   414 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveReduceSize, EF32TraceUidProxyDrive, this, aPos, aLength);
   409 	OstTraceExt3(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREDUCESIZE, "this %x aPos %x aLength %d", (TUint) this, (TUint) aPos, (TUint) aLength);
   415 
       
   416 	TInt r = iLocDrv.ReduceSize(aPos,aLength);
   410 	TInt r = iLocDrv.ReduceSize(aPos,aLength);
   417 
   411 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREDUCESIZERET, "r %d", r);
   418 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveReduceSizeRet, EF32TraceUidProxyDrive, r);
       
   419 	return r;
   412 	return r;
   420 	}
   413 	}
   421 
   414 
   422 
   415 
   423 /**
   416 /**
   433 @return system wide error code.
   426 @return system wide error code.
   434 */
   427 */
   435 TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt aOffset, TInt aFlags)
   428 TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt aOffset, TInt aFlags)
   436 	{
   429 	{
   437 	TRACETHREADIDH(aThreadHandle);
   430 	TRACETHREADIDH(aThreadHandle);
   438 	TRACE8(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead1, EF32TraceUidProxyDrive, 
   431 	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD1, "this %x clientThreadId %x aPos %x:%x aLength %d", (TUint) this, (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength);
   439 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aTrg, threadId, aOffset, aFlags);
       
   440 
       
   441 	TInt r = iLocDrv.Read(aPos,aLength,aTrg,aThreadHandle,aOffset,aFlags);
   432 	TInt r = iLocDrv.Read(aPos,aLength,aTrg,aThreadHandle,aOffset,aFlags);
   442 
   433 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD1RET, "r %d", r);
   443 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead1Ret, EF32TraceUidProxyDrive, r);
       
   444 	return r;
   434 	return r;
   445 	}
   435 	}
   446 
   436 
   447 /**
   437 /**
   448 Read from the connected drive.
   438 Read from the connected drive.
   456 @return system wide error code.
   446 @return system wide error code.
   457 */
   447 */
   458 TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt anOffset)
   448 TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt anOffset)
   459 	{
   449 	{
   460 	TRACETHREADIDH(aThreadHandle);
   450 	TRACETHREADIDH(aThreadHandle);
   461 	TRACE7(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead2, EF32TraceUidProxyDrive, 
   451 	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD2, "this %x clientThreadId %x aPos %x:%x aLength %d", (TUint) this, (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength);
   462 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aTrg, threadId, anOffset);
       
   463 
       
   464 	TInt r = iLocDrv.Read(aPos,aLength,aTrg,aThreadHandle,anOffset);
   452 	TInt r = iLocDrv.Read(aPos,aLength,aTrg,aThreadHandle,anOffset);
   465 
   453 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD2RET, "r %d", r);
   466 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead2Ret, EF32TraceUidProxyDrive, r);
       
   467 	return r;
   454 	return r;
   468 	}
   455 	}
   469 
   456 
   470 /**
   457 /**
   471 Read from the connected drive.
   458 Read from the connected drive.
   476 
   463 
   477 @return system wide error code.
   464 @return system wide error code.
   478 */
   465 */
   479 TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)
   466 TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)
   480 	{
   467 	{
   481 	TRACE5(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead3, EF32TraceUidProxyDrive, 
   468 	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD3, "this %x aPos %x:%x aLength %d aTrg %x", (TUint) this, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength, (TUint) &aTrg);
   482 		this, I64LOW(aPos), I64HIGH(aPos), aLength, &aTrg);
       
   483 
       
   484 	TInt r = iLocDrv.Read(aPos,aLength,aTrg);
   469 	TInt r = iLocDrv.Read(aPos,aLength,aTrg);
   485 
   470 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD3RET, "r %d", r);
   486 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead3Ret, EF32TraceUidProxyDrive, r);
       
   487 	return r;
   471 	return r;
   488 	}
   472 	}
   489 
   473 
   490 
   474 
   491 /**
   475 /**
   501 @return system wide error code.
   485 @return system wide error code.
   502 */
   486 */
   503 TInt CLocalProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt aOffset,TInt aFlags)
   487 TInt CLocalProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt aOffset,TInt aFlags)
   504 	{
   488 	{
   505 	TRACETHREADIDH(aThreadHandle);
   489 	TRACETHREADIDH(aThreadHandle);
   506 	TRACE8(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite1, EF32TraceUidProxyDrive, 
   490 	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE1, "this %x clientThreadId %x aPos %x:%x aLength %d", (TUint) this, (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength);
   507 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aSrc, threadId, aOffset, aFlags);
       
   508 
       
   509 	TInt r = iLocDrv.Write(aPos,aLength,aSrc,aThreadHandle,aOffset,aFlags);
   491 	TInt r = iLocDrv.Write(aPos,aLength,aSrc,aThreadHandle,aOffset,aFlags);
   510 
   492 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE1RET, "r %d", r);
   511 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite1Ret, EF32TraceUidProxyDrive, r);
       
   512 
       
   513 	return r;
   493 	return r;
   514 	}
   494 	}
   515 
   495 
   516 
   496 
   517 /**
   497 /**
   526 @return system wide error code.
   506 @return system wide error code.
   527 */
   507 */
   528 TInt CLocalProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt anOffset)
   508 TInt CLocalProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt anOffset)
   529 	{
   509 	{
   530 	TRACETHREADIDH(aThreadHandle);
   510 	TRACETHREADIDH(aThreadHandle);
   531 	TRACE7(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite2, EF32TraceUidProxyDrive, 
   511 	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE2, "this %x clientThreadId %x aPos %x:%x aLength %d", (TUint) this, (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength);
   532 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aSrc, threadId, anOffset);
       
   533 
       
   534 	TInt r = iLocDrv.Write(aPos,aLength,aSrc,aThreadHandle,anOffset);
   512 	TInt r = iLocDrv.Write(aPos,aLength,aSrc,aThreadHandle,anOffset);
   535 
   513 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE2RET, "r %d", r);
   536 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite2Ret, EF32TraceUidProxyDrive, r);
       
   537 	return r;
   514 	return r;
   538 	}
   515 	}
   539 
   516 
   540 
   517 
   541 /**
   518 /**
   546 
   523 
   547 @return system wide error code.
   524 @return system wide error code.
   548 */
   525 */
   549 TInt CLocalProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)
   526 TInt CLocalProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)
   550 	{
   527 	{
   551 	TRACE5(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite3, EF32TraceUidProxyDrive, 
   528 	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE3, "this %x aPos %x:%x aLength %d aSrc %x", (TUint) this, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aSrc.Length(), (TUint) &aSrc);
   552 		this, I64LOW(aPos), I64HIGH(aPos), aSrc.Length(), &aSrc);
       
   553 
       
   554 	TInt r = iLocDrv.Write(aPos,aSrc);
   529 	TInt r = iLocDrv.Write(aPos,aSrc);
   555 
   530 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE3RET, "r %d", r);
   556 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite3Ret, EF32TraceUidProxyDrive, r);
       
   557 	return r;
   531 	return r;
   558 	}
   532 	}
   559 	
   533 	
   560 	
   534 	
   561 /**
   535 /**
   565 
   539 
   566 @return system wide error code
   540 @return system wide error code
   567 */
   541 */
   568 TInt CLocalProxyDrive::Caps(TDes8& anInfo)
   542 TInt CLocalProxyDrive::Caps(TDes8& anInfo)
   569 	{
   543 	{
   570 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveCaps, EF32TraceUidProxyDrive, this);
   544 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVECAPS, "this %x", this);
   571 
       
   572 	TInt r = iLocDrv.Caps(anInfo);
   545 	TInt r = iLocDrv.Caps(anInfo);
   573 
   546 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVECAPSRET, "r %d", r);
   574 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveCapsRet, EF32TraceUidProxyDrive, r);
       
   575 	return r;
   547 	return r;
   576 	}
   548 	}
   577 
   549 
   578 
   550 
   579 /**
   551 /**
   583 
   555 
   584 @return system wide error code.
   556 @return system wide error code.
   585 */
   557 */
   586 TInt CLocalProxyDrive::Format(TFormatInfo& anInfo)
   558 TInt CLocalProxyDrive::Format(TFormatInfo& anInfo)
   587 	{
   559 	{
   588 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveFormat1, EF32TraceUidProxyDrive, this);
   560 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEFORMAT1, "this %x", this);
   589 
       
   590 	TInt r = iLocDrv.Format(anInfo);
   561 	TInt r = iLocDrv.Format(anInfo);
   591 
   562 	OstTraceExt4(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEFORMAT1RET, "r %d iFormatIsCurrent %d i512ByteSectorsFormatted %d iMaxBytesPerFormat %d", (TUint) r, (TUint) anInfo.iFormatIsCurrent, (TUint) anInfo.i512ByteSectorsFormatted, (TUint) anInfo.iMaxBytesPerFormat);
   592 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveFormat1Ret, EF32TraceUidProxyDrive, 
       
   593 		r, anInfo.iFormatIsCurrent, anInfo.i512ByteSectorsFormatted, anInfo.iMaxBytesPerFormat);
       
   594 	return r;
   563 	return r;
   595 	}
   564 	}
   596 
   565 
   597 
   566 
   598 /**
   567 /**
   603 
   572 
   604 @return system wide error code.
   573 @return system wide error code.
   605 */
   574 */
   606 TInt CLocalProxyDrive::Format(TInt64 aPos,TInt aLength)
   575 TInt CLocalProxyDrive::Format(TInt64 aPos,TInt aLength)
   607 	{
   576 	{
   608 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveFormat2, EF32TraceUidProxyDrive, 
   577 	OstTraceExt4(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEFORMAT2, "this %x aPos %x:%x aLength %d", (TUint) this, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), (TUint) aLength);
   609 		this, I64LOW(aPos), I64HIGH(aPos), aLength);
       
   610 
       
   611 	TInt r = iLocDrv.Format(aPos,aLength);
   578 	TInt r = iLocDrv.Format(aPos,aLength);
   612 
   579 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEFORMAT2RET, "r %d", r);
   613 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveFormat2Ret, EF32TraceUidProxyDrive, r);
       
   614 	return r;
   580 	return r;
   615 	}
   581 	}
   616 
   582 
   617 
   583 
   618 /**
   584 /**
   623 
   589 
   624 @return system wide error code.
   590 @return system wide error code.
   625 */
   591 */
   626 TInt CLocalProxyDrive::SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle)
   592 TInt CLocalProxyDrive::SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle)
   627 	{
   593 	{
   628 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveSetMountInfo, EF32TraceUidProxyDrive, this, aMountInfo, aMountInfoThreadHandle);
   594 	OstTraceExt3(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVESETMOUNTINFO, "this %x aMountInfo %x aMountInfoThreadHandle %d", (TUint) this, (TUint) aMountInfo, (TUint) aMountInfoThreadHandle);
   629 
       
   630 	TInt r = iLocDrv.SetMountInfo(aMountInfo,aMountInfoThreadHandle);
   595 	TInt r = iLocDrv.SetMountInfo(aMountInfo,aMountInfoThreadHandle);
   631 
   596 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVESETMOUNTINFORET, "r %d", r);
   632 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveSetMountInfoRet, EF32TraceUidProxyDrive, r);
       
   633 	return r;
   597 	return r;
   634 	}
   598 	}
   635 
   599 
   636 
   600 
   637 /**
   601 /**
   641 
   605 
   642 @return system wide error code.
   606 @return system wide error code.
   643 */
   607 */
   644 TInt CLocalProxyDrive::ForceRemount(TUint aFlags)
   608 TInt CLocalProxyDrive::ForceRemount(TUint aFlags)
   645 	{
   609 	{
   646 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveForceRemount, EF32TraceUidProxyDrive, this, aFlags);
   610 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEFORCEREMOUNT, "this %x aFlags %x", (TUint) this, (TUint) aFlags);
   647 
       
   648 	TInt r = iLocDrv.ForceRemount(aFlags);
   611 	TInt r = iLocDrv.ForceRemount(aFlags);
   649 
   612 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEFORCEREMOUNTRET, "r %d", r);
   650 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveForceRemountRet, EF32TraceUidProxyDrive, r);
       
   651 	return r;
   613 	return r;
   652 	}
   614 	}
   653 
   615 
   654 /**
   616 /**
   655 An interface with which control commands can be passed to 
   617 An interface with which control commands can be passed to 
   662 
   624 
   663 @return system wide error code.
   625 @return system wide error code.
   664 */
   626 */
   665 TInt CLocalProxyDrive::ControlIO(const RMessagePtr2& /*aMessage*/,TInt aCommand,TAny* aParam1,TAny* aParam2)
   627 TInt CLocalProxyDrive::ControlIO(const RMessagePtr2& /*aMessage*/,TInt aCommand,TAny* aParam1,TAny* aParam2)
   666 	{
   628 	{
   667 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveControlIO, EF32TraceUidProxyDrive, this);
   629 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVECONTROLIO, "this %x", this);
   668 
       
   669 	TInt r = iLocDrv.ControlIO(aCommand,aParam1,aParam2);
   630 	TInt r = iLocDrv.ControlIO(aCommand,aParam1,aParam2);
   670 
   631 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVECONTROLIORET, "r %d", r);
   671 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveControlIORet, EF32TraceUidProxyDrive, r);
       
   672 	return r;
   632 	return r;
   673 	}
   633 	}
   674 	
   634 	
   675 	
   635 	
   676 /**
   636 /**
   681 
   641 
   682 @return system wide error code.
   642 @return system wide error code.
   683 */
   643 */
   684 TInt CLocalProxyDrive::Unlock(TMediaPassword &aPassword, TBool aStorePassword)
   644 TInt CLocalProxyDrive::Unlock(TMediaPassword &aPassword, TBool aStorePassword)
   685 	{
   645 	{
   686 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveUnlock, EF32TraceUidProxyDrive, this, aStorePassword);
   646 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEUNLOCK, "this %x aPassword %d", (TUint) this, (TUint) aStorePassword);
   687 
       
   688 	TInt r = iLocDrv.Unlock(aPassword,aStorePassword);
   647 	TInt r = iLocDrv.Unlock(aPassword,aStorePassword);
   689 
   648 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEUNLOCKRET, "r %d", r);
   690 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveUnlockRet, EF32TraceUidProxyDrive, r);
       
   691 	return r;
   649 	return r;
   692 	}
   650 	}
   693 
   651 
   694 
   652 
   695 /**
   653 /**
   701 
   659 
   702 @return system wide error code.
   660 @return system wide error code.
   703 */
   661 */
   704 TInt CLocalProxyDrive::Lock(TMediaPassword &aOldPassword, TMediaPassword &aNewPassword, TBool aStorePassword)
   662 TInt CLocalProxyDrive::Lock(TMediaPassword &aOldPassword, TMediaPassword &aNewPassword, TBool aStorePassword)
   705 	{
   663 	{
   706 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveLock, EF32TraceUidProxyDrive, this, aStorePassword);
   664 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVELOCK, "this %x aPassword %d", (TUint) this, (TUint) aStorePassword);
   707 
       
   708 	TInt r = iLocDrv.SetPassword(aOldPassword,aNewPassword,aStorePassword);
   665 	TInt r = iLocDrv.SetPassword(aOldPassword,aNewPassword,aStorePassword);
   709 
   666 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVELOCKRET, "r %d", r);
   710 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveLockRet, EF32TraceUidProxyDrive, r);
       
   711 	return r;
   667 	return r;
   712 	}
   668 	}
   713 
   669 
   714 
   670 
   715 /**
   671 /**
   719 
   675 
   720 @return system wide error code.
   676 @return system wide error code.
   721 */
   677 */
   722 TInt CLocalProxyDrive::Clear(TMediaPassword &aPassword)
   678 TInt CLocalProxyDrive::Clear(TMediaPassword &aPassword)
   723 	{
   679 	{
   724 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveClear, EF32TraceUidProxyDrive, this);
   680 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVECLEAR, "this %x", this);
   725 
       
   726 	TInt r = iLocDrv.Clear(aPassword);
   681 	TInt r = iLocDrv.Clear(aPassword);
   727 
   682 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVECLEARRET, "r %d", r);
   728 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveClearRet, EF32TraceUidProxyDrive, r);
       
   729 	return r;
   683 	return r;
   730 	}
   684 	}
   731 
   685 
   732 /**
   686 /**
   733 Forcibly unlock a password-enabled drive.
   687 Forcibly unlock a password-enabled drive.
   734 
   688 
   735 @return system wide error code.
   689 @return system wide error code.
   736 */
   690 */
   737 TInt CLocalProxyDrive::ErasePassword()
   691 TInt CLocalProxyDrive::ErasePassword()
   738 	{
   692 	{
   739 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveErasePassword, EF32TraceUidProxyDrive, this);
   693 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEERASEPASSWORD, "this %x", this);
   740 
       
   741 	TInt r = iLocDrv.ErasePassword();
   694 	TInt r = iLocDrv.ErasePassword();
   742 
   695 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEERASEPASSWORDRET, "r %d", r);
   743 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveErasePasswordRet, EF32TraceUidProxyDrive, r);
       
   744 	return r;
   696 	return r;
   745 	}
   697 	}
   746 
   698 
   747 /**
   699 /**
   748 Notify the media driver that an area of the partition has been deleted.
   700 Notify the media driver that an area of the partition has been deleted.
   749 Used by some media drivers (e.g. NAND flash) for garbage collection.
   701 Used by some media drivers (e.g. NAND flash) for garbage collection.
   750 
   702 
   751 @param aPos    The position of the data which is being deleted.
   703 @param aPos    The position of the data which is being deleted.
   752 @param aLength The length of the data which is being deleted.
   704 @param aLength The length of the data which is being deleted.
   753 
       
   754 @return System wide error code.
   705 @return System wide error code.
   755 */
   706 */
   756 TInt CLocalProxyDrive::DeleteNotify(TInt64 aPos, TInt aLength)
   707 TInt CLocalProxyDrive::DeleteNotify(TInt64 aPos, TInt aLength)
   757 	{
   708 	{
   758 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveDeleteNotify, EF32TraceUidProxyDrive, 
   709 	OstTraceExt4(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEDELETENOTIFY, "this %x aPos %x:%x aLength %d", (TUint) this, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), (TUint) aLength);
   759 		this, I64LOW(aPos), I64HIGH(aPos), aLength);
       
   760 
       
   761 	TInt r = iLocDrv.DeleteNotify(aPos, aLength);
   710 	TInt r = iLocDrv.DeleteNotify(aPos, aLength);
   762 
   711 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEDELETENOTIFYRET, "r %d", r);
   763 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveDeleteNotifyRet, EF32TraceUidProxyDrive, r);
       
   764 	return r;
   712 	return r;
   765 	}
   713 	}
   766 
   714 
   767 
   715 
   768 /**
   716 /**
   772 
   720 
   773 @return System wide error code.
   721 @return System wide error code.
   774 */	
   722 */	
   775 TInt CLocalProxyDrive::GetLastErrorInfo(TDes8 &aErrorInfo)
   723 TInt CLocalProxyDrive::GetLastErrorInfo(TDes8 &aErrorInfo)
   776 	{
   724 	{
   777 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveGetLastErrorInfo, EF32TraceUidProxyDrive, this);
   725 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEGETLASTERRORINFO, "this %x", this);
   778 
       
   779 	TInt r = iLocDrv.GetLastErrorInfo(aErrorInfo);
   726 	TInt r = iLocDrv.GetLastErrorInfo(aErrorInfo);
   780 
   727 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEGETLASTERRORINFORET, "r %d", r);
   781 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveGetLastErrorInfoRet, EF32TraceUidProxyDrive, r);
       
   782 	return r;
   728 	return r;
   783 	}
   729 	}
   784 
   730 
   785 
   731 
   786 TInt CLocalProxyDrive::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
   732 TInt CLocalProxyDrive::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
   787 	{
   733 	{
   788 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveGetInterface, EF32TraceUidProxyDrive, 
   734 	OstTraceExt3(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEGETINTERFACE, "this %x aInterfaceId %d aInput %x", (TUint) this, (TUint) aInterfaceId, (TUint) aInput);
   789 		this, aInterfaceId, aInput);
       
   790 
       
   791 	TInt r;
   735 	TInt r;
   792 	switch(aInterfaceId)
   736 	switch(aInterfaceId)
   793 		{
   737 		{
   794 		case EGetLocalDrive:
   738 		case EGetLocalDrive:
   795 			__ASSERT_ALWAYS((CProxyDrive*)aInput==this,Fault(ELocDrvInvalidLocalDrive));
   739 			__ASSERT_ALWAYS((CProxyDrive*)aInput==this,Fault(ELocDrvInvalidLocalDrive));
   803 			break;
   747 			break;
   804 
   748 
   805 		default:
   749 		default:
   806 			r= CProxyDrive::GetInterface(aInterfaceId,aInterface,aInput);
   750 			r= CProxyDrive::GetInterface(aInterfaceId,aInterface,aInput);
   807 		}
   751 		}
   808 
   752 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEGETINTERFACERET, "r %d aInterface %x", (TUint) r, (TUint) aInterface);
   809 	TRACERET2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveGetInterfaceRet, EF32TraceUidProxyDrive, r, aInterface);
       
   810 	return r;
   753 	return r;
   811 	}
   754 	}
   812 
   755 
   813 
   756 
   814 
   757 
   841 
   784 
   842 @return system wide error code.
   785 @return system wide error code.
   843 */
   786 */
   844 EXPORT_C TInt CBaseExtProxyDrive::Initialise()
   787 EXPORT_C TInt CBaseExtProxyDrive::Initialise()
   845 	{
   788 	{
   846 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveInitialise, EF32TraceUidProxyDrive, this);
   789 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEINITIALISE, "this %x", this);
   847 
       
   848 	TInt r = iProxy->Initialise();
   790 	TInt r = iProxy->Initialise();
   849 
   791 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEINITIALISERET, "r %d", r);
   850 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveInitialiseRet, EF32TraceUidProxyDrive, r);
       
   851 	return r;
   792 	return r;
   852 	}
   793 	}
   853 
   794 
   854 
   795 
   855 /**
   796 /**
   857 
   798 
   858 @return KErrNone.
   799 @return KErrNone.
   859 */
   800 */
   860 EXPORT_C TInt CBaseExtProxyDrive::Dismounted()
   801 EXPORT_C TInt CBaseExtProxyDrive::Dismounted()
   861 	{
   802 	{
   862 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveDismounted, EF32TraceUidProxyDrive, this);
   803 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEDISMOUNTED, "this %x", this);
   863 
       
   864 	TInt r = iProxy->Dismounted();
   804 	TInt r = iProxy->Dismounted();
   865 
   805 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEDISMOUNTEDRET, "r %d", r);
   866 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveDismountedRet, EF32TraceUidProxyDrive, r);
       
   867 	return r;
   806 	return r;
   868 	}
   807 	}
   869 
   808 
   870 /**
   809 /**
   871 Increase the size of the proxy drive by the specified length (in bytes).
   810 Increase the size of the proxy drive by the specified length (in bytes).
   874 
   813 
   875 @return system wide error code.
   814 @return system wide error code.
   876 */
   815 */
   877 EXPORT_C TInt CBaseExtProxyDrive::Enlarge(TInt aLength)
   816 EXPORT_C TInt CBaseExtProxyDrive::Enlarge(TInt aLength)
   878 	{
   817 	{
   879 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveEnlarge, EF32TraceUidProxyDrive, this, aLength);
   818 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEENLARGE, "this %x aLength %d", (TUint) this, (TUint) aLength);
   880 
       
   881 	TInt r = iProxy->Enlarge(aLength);
   819 	TInt r = iProxy->Enlarge(aLength);
   882 
   820 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEENLARGERET, "r %d", r);
   883 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveEnlargeRet, EF32TraceUidProxyDrive, r);
       
   884 	return r;
   821 	return r;
   885 	}
   822 	}
   886 
   823 
   887 
   824 
   888 /**
   825 /**
   896 
   833 
   897 @return system wide error code.
   834 @return system wide error code.
   898 */
   835 */
   899 EXPORT_C TInt CBaseExtProxyDrive::ReduceSize(TInt aPos, TInt aLength)
   836 EXPORT_C TInt CBaseExtProxyDrive::ReduceSize(TInt aPos, TInt aLength)
   900 	{
   837 	{
   901 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveReduceSize, EF32TraceUidProxyDrive, this, aPos, aLength);
   838 	OstTraceExt3(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEREDUCESIZE, "this %x aPos %x aLength %d", (TUint) this, (TUint) aPos, (TUint) aLength);
   902 
       
   903 	TInt r = iProxy->ReduceSize(aPos,aLength);
   839 	TInt r = iProxy->ReduceSize(aPos,aLength);
   904 
   840 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEREDUCESIZERET, "r %d", r);
   905 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveReduceSizeRet, EF32TraceUidProxyDrive, r);
       
   906 	return r;
   841 	return r;
   907 	}
   842 	}
   908 
   843 
   909 
   844 
   910 /**
   845 /**
   920 @return system wide error code.
   855 @return system wide error code.
   921 */
   856 */
   922 EXPORT_C TInt CBaseExtProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt aOffset,TInt aFlags)
   857 EXPORT_C TInt CBaseExtProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt aOffset,TInt aFlags)
   923 	{
   858 	{
   924 	TRACETHREADIDH(aThreadHandle);
   859 	TRACETHREADIDH(aThreadHandle);
   925 	TRACE8(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead1, EF32TraceUidProxyDrive, 
   860 	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEREAD1, "this %x clientThreadId %x aPos %x:%x aLength %d", (TUint) this, (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength);
   926 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aTrg, threadId, aOffset, aFlags);
       
   927 
       
   928 	TInt r = iProxy->Read(aPos,aLength,aTrg,aThreadHandle,aOffset,aFlags);
   861 	TInt r = iProxy->Read(aPos,aLength,aTrg,aThreadHandle,aOffset,aFlags);
   929 
   862 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEREAD1RET, "r %d", r);
   930 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead1Ret, EF32TraceUidProxyDrive, r);
       
   931 
       
   932 	return r;
   863 	return r;
   933 	}
   864 	}
   934 
   865 
   935 
   866 
   936 /**
   867 /**
   945 @return system wide error code.
   876 @return system wide error code.
   946 */
   877 */
   947 EXPORT_C TInt CBaseExtProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt anOffset)
   878 EXPORT_C TInt CBaseExtProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt anOffset)
   948 	{
   879 	{
   949 	TRACETHREADIDH(aThreadHandle);
   880 	TRACETHREADIDH(aThreadHandle);
   950 	TRACE7(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead2, EF32TraceUidProxyDrive, 
   881 	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEREAD2, "this %x clientThreadId %x aPos %x:%x aLength %d", (TUint) this, (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength);
   951 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aTrg, threadId, anOffset);
       
   952 
       
   953 	TInt r = iProxy->Read(aPos,aLength,aTrg,aThreadHandle,anOffset);
   882 	TInt r = iProxy->Read(aPos,aLength,aTrg,aThreadHandle,anOffset);
   954 
   883 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEREAD2RET, "r %d", r);
   955 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead2Ret, EF32TraceUidProxyDrive, r);
       
   956 	return r;
   884 	return r;
   957 	}
   885 	}
   958 
   886 
   959 
   887 
   960 /**
   888 /**
   966 
   894 
   967 @return system wide error code.
   895 @return system wide error code.
   968 */
   896 */
   969 EXPORT_C TInt CBaseExtProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)
   897 EXPORT_C TInt CBaseExtProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)
   970 	{
   898 	{
   971 	TRACE5(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead3, EF32TraceUidProxyDrive, 
   899 	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEREAD3, "this %x aPos %x:%x aLength %d aTrg %x", (TUint) this, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength, (TUint) &aTrg);
   972 		this, I64LOW(aPos), I64HIGH(aPos), aLength, &aTrg);
   900 		
   973 
       
   974 	TInt r = iProxy->Read(aPos,aLength,aTrg);
   901 	TInt r = iProxy->Read(aPos,aLength,aTrg);
   975 
   902 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEREAD3RET, "r %d", r);
   976 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead3Ret, EF32TraceUidProxyDrive, r);
       
   977 	return r;
   903 	return r;
   978 	}
   904 	}
   979 
   905 
   980 
   906 
   981 /**
   907 /**
   991 @return system wide error code.
   917 @return system wide error code.
   992 */
   918 */
   993 EXPORT_C TInt CBaseExtProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt aOffset,TInt aFlags)
   919 EXPORT_C TInt CBaseExtProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt aOffset,TInt aFlags)
   994 	{
   920 	{
   995 	TRACETHREADIDH(aThreadHandle);
   921 	TRACETHREADIDH(aThreadHandle);
   996 	TRACE8(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite1, EF32TraceUidProxyDrive, 
   922 	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEWRITE1, "this %x clientThreadId %x aPos %x:%x aLength %d", (TUint) this, (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength);
   997 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aSrc, threadId, aOffset, aFlags);
       
   998 
       
   999 	TInt r = iProxy->Write(aPos,aLength,aSrc,aThreadHandle,aOffset,aFlags);
   923 	TInt r = iProxy->Write(aPos,aLength,aSrc,aThreadHandle,aOffset,aFlags);
  1000 
   924 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEWRITE1RET, "r %d", r);
  1001 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite1Ret, EF32TraceUidProxyDrive, r);
       
  1002 	return r;
   925 	return r;
  1003 	}
   926 	}
  1004 
   927 
  1005 
   928 
  1006 /**
   929 /**
  1015 @return system wide error code.
   938 @return system wide error code.
  1016 */
   939 */
  1017 EXPORT_C TInt CBaseExtProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt anOffset)
   940 EXPORT_C TInt CBaseExtProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt anOffset)
  1018 	{
   941 	{
  1019 	TRACETHREADIDH(aThreadHandle);
   942 	TRACETHREADIDH(aThreadHandle);
  1020 	TRACE7(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite2, EF32TraceUidProxyDrive, 
   943 	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEWRITE2, "this %x clientThreadId %x aPos %x:%x aLength %d", (TUint) this, (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength);
  1021 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aSrc, threadId, anOffset);
       
  1022 
       
  1023 	TInt r = iProxy->Write(aPos,aLength,aSrc,aThreadHandle,anOffset);
   944 	TInt r = iProxy->Write(aPos,aLength,aSrc,aThreadHandle,anOffset);
  1024 
   945 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEWRITE2RET, "r %d", r);
  1025 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite2Ret, EF32TraceUidProxyDrive, r);
       
  1026 	return r;
   946 	return r;
  1027 	}
   947 	}
  1028 
   948 
  1029 
   949 
  1030 /**
   950 /**
  1035 
   955 
  1036 @return system wide error code.
   956 @return system wide error code.
  1037 */
   957 */
  1038 EXPORT_C TInt CBaseExtProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)
   958 EXPORT_C TInt CBaseExtProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)
  1039 	{
   959 	{
  1040 	TRACE5(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite3, EF32TraceUidProxyDrive, 
   960 	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEWRITE3, "this %x aPos %x:%x aLength %d aSrc %x", (TUint) this, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aSrc.Length(), (TUint) &aSrc);
  1041 		this, I64LOW(aPos), I64HIGH(aPos), aSrc.Length(), &aSrc);
       
  1042 
       
  1043 	TInt r = iProxy->Write(aPos,aSrc);
   961 	TInt r = iProxy->Write(aPos,aSrc);
  1044 
   962 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEWRITE3RET, "r %d", r);
  1045 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite3Ret, EF32TraceUidProxyDrive, r);
       
  1046 	return r;
   963 	return r;
  1047 	}
   964 	}
  1048 
   965 
  1049 
   966 
  1050 /**
   967 /**
  1054 
   971 
  1055 @return system wide error code
   972 @return system wide error code
  1056 */
   973 */
  1057 EXPORT_C TInt CBaseExtProxyDrive::Caps(TDes8& anInfo)
   974 EXPORT_C TInt CBaseExtProxyDrive::Caps(TDes8& anInfo)
  1058 	{
   975 	{
  1059 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveCaps, EF32TraceUidProxyDrive, this);
   976 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVECAPS, "this %x", this);
  1060 
       
  1061 	TInt r = iProxy->Caps(anInfo);
   977 	TInt r = iProxy->Caps(anInfo);
  1062 
   978 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVECAPSRET, "r %d", r);
  1063 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveCapsRet, EF32TraceUidProxyDrive, r);
       
  1064 	return r;
   979 	return r;
  1065 	}
   980 	}
  1066 
   981 
  1067 
   982 
  1068 /**
   983 /**
  1072 
   987 
  1073 @return system wide error code.
   988 @return system wide error code.
  1074 */
   989 */
  1075 EXPORT_C TInt CBaseExtProxyDrive::Format(TFormatInfo& anInfo)
   990 EXPORT_C TInt CBaseExtProxyDrive::Format(TFormatInfo& anInfo)
  1076 	{
   991 	{
  1077 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveFormat1, EF32TraceUidProxyDrive, this);
   992 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEFORMAT1, "this %x", this);
  1078 
       
  1079 	TInt r = iProxy->Format(anInfo);
   993 	TInt r = iProxy->Format(anInfo);
  1080 
   994 	OstTraceExt4(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEFORMAT1RET, "r %d iFormatIsCurrent %d i512ByteSectorsFormatted %d iMaxBytesPerFormat %d", (TUint) r, (TUint) anInfo.iFormatIsCurrent, (TUint) anInfo.i512ByteSectorsFormatted, (TUint) anInfo.iMaxBytesPerFormat);
  1081 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveFormat1Ret, EF32TraceUidProxyDrive, 
       
  1082 		r, anInfo.iFormatIsCurrent, anInfo.i512ByteSectorsFormatted, anInfo.iMaxBytesPerFormat);
       
  1083 	return r;
   995 	return r;
  1084 	}
   996 	}
  1085 
   997 
  1086 
   998 
  1087 /**
   999 /**
  1092 
  1004 
  1093 @return system wide error code.
  1005 @return system wide error code.
  1094 */
  1006 */
  1095 EXPORT_C TInt CBaseExtProxyDrive::Format(TInt64 aPos,TInt aLength)
  1007 EXPORT_C TInt CBaseExtProxyDrive::Format(TInt64 aPos,TInt aLength)
  1096 	{
  1008 	{
  1097 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveFormat2, EF32TraceUidProxyDrive, 
  1009 	OstTraceExt4(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEFORMAT2, "this %x aPos %x:%x aLength %d", (TUint) this, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), (TUint) aLength);
  1098 		this, I64LOW(aPos), I64HIGH(aPos), aLength);
       
  1099 
       
  1100 	TInt r = iProxy->Format(aPos,aLength);
  1010 	TInt r = iProxy->Format(aPos,aLength);
  1101 
  1011 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEFORMAT2RET, "r %d", r);
  1102 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveFormat2Ret, EF32TraceUidProxyDrive, r);
       
  1103 	return r;
  1012 	return r;
  1104 	}
  1013 	}
  1105 
  1014 
  1106 
  1015 
  1107 /**
  1016 /**
  1112 
  1021 
  1113 @return system wide error code.
  1022 @return system wide error code.
  1114 */
  1023 */
  1115 EXPORT_C TInt CBaseExtProxyDrive::SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle)
  1024 EXPORT_C TInt CBaseExtProxyDrive::SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle)
  1116 	{
  1025 	{
  1117 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveSetMountInfo, EF32TraceUidProxyDrive, this, aMountInfo, aMountInfoThreadHandle);
  1026 	OstTraceExt3(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVESETMOUNTINFO, "this %x aMountInfo %x aMountInfoThreadHandle %x", (TUint) this, (TUint) aMountInfo, (TUint) aMountInfoThreadHandle);
  1118 
       
  1119 	TInt r = iProxy->SetMountInfo(aMountInfo,aMountInfoThreadHandle);
  1027 	TInt r = iProxy->SetMountInfo(aMountInfo,aMountInfoThreadHandle);
  1120 
  1028 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVESETMOUNTINFORET, "r %d", r);
  1121 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveSetMountInfoRet, EF32TraceUidProxyDrive, r);
       
  1122 	return r;
  1029 	return r;
  1123 	}
  1030 	}
  1124 
  1031 
  1125 
  1032 
  1126 /**
  1033 /**
  1130 
  1037 
  1131 @return system wide error code.
  1038 @return system wide error code.
  1132 */
  1039 */
  1133 EXPORT_C TInt CBaseExtProxyDrive::ForceRemount(TUint aFlags)
  1040 EXPORT_C TInt CBaseExtProxyDrive::ForceRemount(TUint aFlags)
  1134 	{
  1041 	{
  1135 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveForceRemount, EF32TraceUidProxyDrive, this, aFlags);
  1042 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEFORCEREMOUNT, "this %x aFlags%x", (TUint) this, (TUint) aFlags);
  1136 
       
  1137 	TInt r = iProxy->ForceRemount(aFlags);
  1043 	TInt r = iProxy->ForceRemount(aFlags);
  1138 
  1044 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEFORCEREMOUNTRET, "r %d", r);
  1139 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveForceRemountRet, EF32TraceUidProxyDrive, r);
       
  1140 	return r;
  1045 	return r;
  1141 	}
  1046 	}
  1142 
  1047 
  1143 
  1048 
  1144 /**
  1049 /**
  1149 
  1054 
  1150 @return system wide error code.
  1055 @return system wide error code.
  1151 */
  1056 */
  1152 EXPORT_C TInt CBaseExtProxyDrive::Unlock(TMediaPassword &aPassword, TBool aStorePassword)
  1057 EXPORT_C TInt CBaseExtProxyDrive::Unlock(TMediaPassword &aPassword, TBool aStorePassword)
  1153 	{
  1058 	{
  1154 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveUnlock, EF32TraceUidProxyDrive, this, aStorePassword);
  1059 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEUNLOCK, "this %x aPassword %d", (TUint) this, (TUint) aStorePassword);
  1155 
       
  1156 	TInt r = iProxy->Unlock(aPassword,aStorePassword);
  1060 	TInt r = iProxy->Unlock(aPassword,aStorePassword);
  1157 
  1061 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEUNLOCKRET, "r %d", r);
  1158 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveUnlockRet, EF32TraceUidProxyDrive, r);
       
  1159 	return r;
  1062 	return r;
  1160 	}
  1063 	}
  1161 
  1064 
  1162 
  1065 
  1163 /**
  1066 /**
  1169 
  1072 
  1170 @return system wide error code.
  1073 @return system wide error code.
  1171 */
  1074 */
  1172 EXPORT_C TInt CBaseExtProxyDrive::Lock(TMediaPassword &aOldPassword, TMediaPassword &aNewPassword, TBool aStorePassword)
  1075 EXPORT_C TInt CBaseExtProxyDrive::Lock(TMediaPassword &aOldPassword, TMediaPassword &aNewPassword, TBool aStorePassword)
  1173 	{
  1076 	{
  1174 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveLock, EF32TraceUidProxyDrive, this, aStorePassword);
  1077 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVELOCK, "this %x aPassword %d", (TUint) this, (TUint) aStorePassword);
  1175 
       
  1176 	TInt r = iProxy->Lock(aOldPassword,aNewPassword,aStorePassword);
  1078 	TInt r = iProxy->Lock(aOldPassword,aNewPassword,aStorePassword);
  1177 
  1079 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVELOCKRET, "r %d", r);
  1178 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveLockRet, EF32TraceUidProxyDrive, r);
       
  1179 	return r;
  1080 	return r;
  1180 	}
  1081 	}
  1181 
  1082 
  1182 
  1083 
  1183 /**
  1084 /**
  1187 
  1088 
  1188 @return system wide error code.
  1089 @return system wide error code.
  1189 */
  1090 */
  1190 EXPORT_C TInt CBaseExtProxyDrive::Clear(TMediaPassword &aPassword)
  1091 EXPORT_C TInt CBaseExtProxyDrive::Clear(TMediaPassword &aPassword)
  1191 	{
  1092 	{
  1192 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveClear, EF32TraceUidProxyDrive, this);
  1093 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVECLEAR, "this %x", this);
  1193 
       
  1194 	TInt r = iProxy->Clear(aPassword);
  1094 	TInt r = iProxy->Clear(aPassword);
  1195 
  1095 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVECLEARRET, "r %d", r);
  1196 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveClearRet, EF32TraceUidProxyDrive, r);
       
  1197 	return r;
  1096 	return r;
  1198 	}
  1097 	}
  1199 
  1098 
  1200 /**
  1099 /**
  1201 Forcibly unlock a password-enabled proxy drive.
  1100 Forcibly unlock a password-enabled proxy drive.
  1202 
  1101 
  1203 @return system wide error code.
  1102 @return system wide error code.
  1204 */
  1103 */
  1205 EXPORT_C TInt CBaseExtProxyDrive::ErasePassword()
  1104 EXPORT_C TInt CBaseExtProxyDrive::ErasePassword()
  1206 	{
  1105 	{
  1207 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveErasePassword, EF32TraceUidProxyDrive, this);
  1106 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEERASEPASSWORD, "this %x", this);
  1208 
       
  1209 	TInt r = iProxy->ErasePassword();
  1107 	TInt r = iProxy->ErasePassword();
  1210 
  1108 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEERASEPASSWORDRET, "r %d", r);
  1211 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveErasePasswordRet, EF32TraceUidProxyDrive, r);
       
  1212 	return r;
  1109 	return r;
  1213 	}
  1110 	}
  1214 
  1111 
  1215 /**
  1112 /**
  1216 An interface with which control commands can be passed to 
  1113 An interface with which control commands can be passed to 
  1223 
  1120 
  1224 @return system wide error code.
  1121 @return system wide error code.
  1225 */
  1122 */
  1226 EXPORT_C TInt CBaseExtProxyDrive::ControlIO(const RMessagePtr2& aMessage,TInt aCommand,TAny* aParam1,TAny* aParam2)
  1123 EXPORT_C TInt CBaseExtProxyDrive::ControlIO(const RMessagePtr2& aMessage,TInt aCommand,TAny* aParam1,TAny* aParam2)
  1227 	{
  1124 	{
  1228 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveControlIO, EF32TraceUidProxyDrive, this);
  1125 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVECONTROLIO, "this %x", this);
  1229 
       
  1230 	TInt r = iProxy->ControlIO(aMessage,aCommand,aParam1,aParam2);
  1126 	TInt r = iProxy->ControlIO(aMessage,aCommand,aParam1,aParam2);
  1231 
  1127 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVECONTROLIORET, "r %d", r);
  1232 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveControlIORet, EF32TraceUidProxyDrive, r);
       
  1233 	return r;
  1128 	return r;
  1234 	}
  1129 	}
  1235 
  1130 
  1236 
  1131 
  1237 /**
  1132 /**
  1243 
  1138 
  1244 @return system wide error code.
  1139 @return system wide error code.
  1245 */	
  1140 */	
  1246 EXPORT_C TInt CBaseExtProxyDrive::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
  1141 EXPORT_C TInt CBaseExtProxyDrive::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
  1247 	{
  1142 	{
  1248 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveGetInterface, EF32TraceUidProxyDrive, 
  1143 	OstTraceExt3(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEGETINTERFACE, "this %x aInterfaceId %d aInput %x", (TUint) this, (TUint) aInterfaceId, (TUint) aInput);
  1249 		this, aInterfaceId, aInput);
  1144 		
  1250 
       
  1251 	TInt r;
  1145 	TInt r;
  1252 	if (aInterfaceId==EGetLocalDrive)
  1146 	if (aInterfaceId==EGetLocalDrive)
  1253 		{
  1147 		{
  1254 		r = iProxy->GetLocalDrive((TBusLocalDrive*&)aInterface);		// iProxy is of type CLocalProxyDrive, so OK to reenter
  1148 		r = iProxy->GetLocalDrive((TBusLocalDrive*&)aInterface);		// iProxy is of type CLocalProxyDrive, so OK to reenter
  1255 		}
  1149 		}
  1256 	else	
  1150 	else	
  1257 		r = CProxyDrive::GetInterface(aInterfaceId,aInterface,aInput);
  1151 		r = CProxyDrive::GetInterface(aInterfaceId,aInterface,aInput);
  1258 
  1152 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEGETINTERFACERET, "r %d aInterface %x", (TUint) r, (TUint) aInterface);
  1259 	TRACERET2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveGetInterfaceRet, EF32TraceUidProxyDrive, r, aInterface);
       
  1260 	return r;
  1153 	return r;
  1261 	}	
  1154 	}	
  1262 
  1155 
  1263 
  1156 
  1264 /**
  1157 /**
  1268 
  1161 
  1269 @return System wide error code.
  1162 @return System wide error code.
  1270 */
  1163 */
  1271 EXPORT_C TInt CBaseExtProxyDrive::GetLastErrorInfo(TDes8 &aErrorInfo)
  1164 EXPORT_C TInt CBaseExtProxyDrive::GetLastErrorInfo(TDes8 &aErrorInfo)
  1272 	{
  1165 	{
  1273 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveGetLastErrorInfo, EF32TraceUidProxyDrive, this);
  1166 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEGETLASTERRORINFO, "this %x", this);
  1274 
       
  1275 	TInt r = iProxy->GetLastErrorInfo(aErrorInfo);
  1167 	TInt r = iProxy->GetLastErrorInfo(aErrorInfo);
  1276 
  1168 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEGETLASTERRORINFORET, "r %d", r);
  1277 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveGetLastErrorInfoRet, EF32TraceUidProxyDrive, r);
       
  1278 	return r;
  1169 	return r;
  1279 	}
  1170 	}
  1280 
  1171 
  1281 
  1172 
  1282 /**
  1173 /**
  1288 
  1179 
  1289 @return System wide error code.
  1180 @return System wide error code.
  1290 */
  1181 */
  1291 EXPORT_C TInt CBaseExtProxyDrive::DeleteNotify(TInt64 aPos, TInt aLength)
  1182 EXPORT_C TInt CBaseExtProxyDrive::DeleteNotify(TInt64 aPos, TInt aLength)
  1292     {
  1183     {
  1293 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveDeleteNotify, EF32TraceUidProxyDrive, 
  1184 	OstTraceExt4(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEDELETENOTIFY, "this %x aPos %x:%x aLength %d", (TUint) this, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), (TUint) aLength);
  1294 		this, I64LOW(aPos), I64HIGH(aPos), aLength);
       
  1295 
       
  1296     TInt r = iProxy->DeleteNotify(aPos, aLength);
  1185     TInt r = iProxy->DeleteNotify(aPos, aLength);
  1297 
  1186 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEDELETENOTIFYRET, "r %d", r);
  1298 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveDeleteNotifyRet, EF32TraceUidProxyDrive, r);
       
  1299 	return r;
  1187 	return r;
  1300     }
  1188     }
  1301 
  1189 
  1302 
  1190 
  1303 /**
  1191 /**
  1366 	TDrive& drive=TheDrives[aMount->Drive().DriveNumber()];
  1254 	TDrive& drive=TheDrives[aMount->Drive().DriveNumber()];
  1367 	if(drive.ExtInfo().iCount==0)
  1255 	if(drive.ExtInfo().iCount==0)
  1368 		return(aConcreteDrive);
  1256 		return(aConcreteDrive);
  1369 
  1257 
  1370 	TBool extSupported = drive.FSys().IsExtensionSupported();
  1258 	TBool extSupported = drive.FSys().IsExtensionSupported();
  1371 	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemIsExtensionSupported, EF32TraceUidProxyDrive, extSupported);
  1259 	OstTraceExt2(TRACE_DRIVE, FSYS_ECFILESYSTEMISEXTENSIONSUPPORTED2, "%x r %d", (TUint) &drive.FSys(), (TUint) extSupported);
  1372 	if(!extSupported)
  1260 	if(!extSupported)
  1373 		{
  1261 		{
  1374 		delete(aConcreteDrive);
  1262 		delete(aConcreteDrive);
  1375 		User::Leave(KErrAccessDenied);
  1263 		User::Leave(KErrAccessDenied);
  1376 		}
  1264 		}