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