Mercurial Mercurial > oss > FCL > sf > os > kernelhwsrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
userlibandfileserver/fileserver/sfile/sf_ext.cpp
branchGCC_SURGE
changeset 221 39b39e1a406e
parent 201 43365a9b78a3
child 254 1560c419b176
equal deleted inserted replaced
219:0ff03867bdb6 221:39b39e1a406e 
    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 /**
 
    49 
    50 
    50 Frees resources before destruction of the object.
 
    51 Frees resources before destruction of the object.
 
    51 */
 
    52 */
 
    52 CProxyDrive::~CProxyDrive()
 
    53 CProxyDrive::~CProxyDrive()
 
    53 	{
 
    54 	{
 
    54 	
    55 	delete iBody;
 
    55 	}
 
    56 	}
 
    56 
    57 
    57 
    58 
    58 /**
 
    59 /**
 
    59 An interface with which control commands can be passed to 
    60 An interface with which control commands can be passed to 
   172 	{
 
   173 	{
 
   173 	return(KErrNotSupported);
 
   174 	return(KErrNotSupported);
 
   174 	}	
   175 	}	
   175 
   176 
   176 
   177 
       
   178 TInt CProxyDrive::SetAndOpenLibrary(RLibrary aLibrary)
 
       
   179 	{
 
       
   180 	TInt r = KErrNone;
 
       
   181 	if (iBody)
 
       
   182 		{
 
       
   183 		iBody->iLibrary = aLibrary;
 
       
   184 		r = iBody->iLibrary.Duplicate(RThread(), EOwnerProcess);
 
       
   185 		}
 
       
   186 	return r;
 
       
   187 	}
 
       
   188 
       
   189 /**
 
       
   190 Gets a copy of the Proxy Drive library (previously opened by OpenLibrary()) prior to deleting the proxy drive itself.
 
       
   191 After deleting the proxy drive, RLibrary::Close() should be called on the returned RLibrary object.
 
       
   192 */
 
       
   193 RLibrary CProxyDrive::GetLibrary()
 
       
   194 	{
 
       
   195 	RLibrary lib;
 
       
   196 	if (iBody)
 
       
   197 		{
 
       
   198 		lib = iBody->iLibrary;
 
       
   199 		iBody->iLibrary.SetHandle(NULL);
 
       
   200 		}
 
       
   201 	return lib;
 
       
   202 	}
 
       
   203 
   177 /**
 
   204 /**
 
   178 Constructor.
 
   205 Constructor.
 
   179 */
 
   206 */
 
   180 EXPORT_C CLocDrvMountCB::CLocDrvMountCB() {}
 
   207 EXPORT_C CLocDrvMountCB::CLocDrvMountCB() {}
 
   181 
   208 
   186 Frees assigned Proxy drive before destruction of the object.
 
   213 Frees assigned Proxy drive before destruction of the object.
 
   187 */
 
   214 */
 
   188 EXPORT_C CLocDrvMountCB::~CLocDrvMountCB()
 
   215 EXPORT_C CLocDrvMountCB::~CLocDrvMountCB()
 
   189 	{
 
   216 	{
 
   190 	__PRINT1(_L("CLocDrvMountCB::~CLocDrvMountCB() 0x%x"),this);
 
   217 	__PRINT1(_L("CLocDrvMountCB::~CLocDrvMountCB() 0x%x"),this);
 
   191 	if(iProxyDrive && !LocalDrives::IsProxyDrive(Drive().DriveNumber()) && LocalDrives::IsValidDriveMapping(Drive().DriveNumber()))
 
   218 	if(iProxyDrive && !LocalDrives::IsProxyDrive(Drive().DriveNumber()))
 
   192 		delete(iProxyDrive);
 
   219 		{
 
       
   220 		RLibrary lib = iProxyDrive->GetLibrary();
 
       
   221 		delete iProxyDrive;
 
       
   222 		lib.Close();
 
       
   223 		}
 
   193 	}
 
   224 	}
 
   194 
   225 
   195 
   226 
   196 /**
 
   227 /**
 
   197 Creates and initialises the local drive.
 
   228 Creates and initialises the local drive.
 
   279 */
 
   310 */
 
   280 EXPORT_C void CLocDrvMountCB::DismountedLocalDrive()
 
   311 EXPORT_C void CLocDrvMountCB::DismountedLocalDrive()
 
   281 	{
 
   312 	{
 
   282 	__ASSERT_ALWAYS(iProxyDrive!=NULL,Fault(ELocDrvDismountedLocalDrive));
 
   313 	__ASSERT_ALWAYS(iProxyDrive!=NULL,Fault(ELocDrvDismountedLocalDrive));
 
   283 	iProxyDrive->Dismounted();
 
   314 	iProxyDrive->Dismounted();
 
   284 	iProxyDrive->SetMount(NULL);
 
       
   285 	}
 
   315 	}
 
   286 
   316 
   287 
   317 
   288 /**
 
   318 /**
 
   289 static constructor.
 
   319 static constructor.
 
   295 
   325 
   296 @return pointer to instantiated CLocalProxyDrive object.
 
   326 @return pointer to instantiated CLocalProxyDrive object.
 
   297 */
 
   327 */
 
   298 CLocalProxyDrive* CLocalProxyDrive::New(CMountCB* aMount,TBusLocalDrive& aLocDrv)
 
   328 CLocalProxyDrive* CLocalProxyDrive::New(CMountCB* aMount,TBusLocalDrive& aLocDrv)
 
   299 	{
 
   329 	{
 
   300 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveNew, EF32TraceUidProxyDrive, 
   330 	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);
 
   331 	CLocalProxyDrive* proxyDrive = new CLocalProxyDrive(aMount,aLocDrv);
 
   304 	
   332 	
   305 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveNewRet, EF32TraceUidProxyDrive, proxyDrive);
 
   333 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVENEWRET, "proxyDrive %x", proxyDrive);
 
   306 	return proxyDrive;
 
   334 	return proxyDrive;
 
   307 	}
 
   335 	}
 
   308 
   336 
   309 /**
 
   337 /**
 
   310 Constructor.
 
   338 Constructor.
 
   326 
   354 
   327 @return KErrNone.
 
   355 @return KErrNone.
 
   328 */
 
   356 */
 
   329 TInt CLocalProxyDrive::Initialise()
 
   357 TInt CLocalProxyDrive::Initialise()
 
   330 	{
 
   358 	{
 
   331 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveInitialise, EF32TraceUidProxyDrive, this);
 
   359 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEINITIALISE, "this %x", this);
 
   332 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveInitialiseRet, EF32TraceUidProxyDrive, KErrNone);
 
   360 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEINITIALISERET, "r %d", KErrNone);
 
   333 
       
   334 	return(KErrNone);
 
   361 	return(KErrNone);
 
   335 	}
 
   362 	}
 
   336 
   363 
   337 
   364 
   338 /**
 
   365 /**
 
   342 
   369 
   343 @return KErrNone.
 
   370 @return KErrNone.
 
   344 */
 
   371 */
 
   345 TInt CLocalProxyDrive::Dismounted()
 
   372 TInt CLocalProxyDrive::Dismounted()
 
   346 	{
 
   373 	{
 
   347 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveDismounted, EF32TraceUidProxyDrive, this);
 
   374 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEDISMOUNTED, "this %x", this);
 
   348 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveDismountedRet, EF32TraceUidProxyDrive, KErrNone);
 
   375 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEDISMOUNTEDRET, "r %d", KErrNone);
 
   349 
       
   350 	return(KErrNone);
 
   376 	return(KErrNone);
 
   351 	}
 
   377 	}
 
   352 
   378 
   353 
   379 
   354 /**
 
   380 /**
 
   358 
   384 
   359 @return system wide error code.
 
   385 @return system wide error code.
 
   360 */
 
   386 */
 
   361 TInt CLocalProxyDrive::Enlarge(TInt aLength)
 
   387 TInt CLocalProxyDrive::Enlarge(TInt aLength)
 
   362 	{
 
   388 	{
 
   363 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveEnlarge, EF32TraceUidProxyDrive, this, aLength);
 
   389 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEENLARGE, "this %x aLength %d", (TUint) this, (TUint) aLength);
 
   364 
       
   365 	TInt r = iLocDrv.Enlarge(aLength);
 
   390 	TInt r = iLocDrv.Enlarge(aLength);
 
   366 
   391 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEENLARGERET, "r %d", r);
 
   367 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveEnlargeRet, EF32TraceUidProxyDrive, r);
 
       
   368 	return r;
 
   392 	return r;
 
   369 	}
 
   393 	}
 
   370 
   394 
   371 
   395 
   372 /**
 
   396 /**
 
   380 
   404 
   381 @return system wide error code.
 
   405 @return system wide error code.
 
   382 */
 
   406 */
 
   383 TInt CLocalProxyDrive::ReduceSize(TInt aPos, TInt aLength)
 
   407 TInt CLocalProxyDrive::ReduceSize(TInt aPos, TInt aLength)
 
   384 	{
 
   408 	{
 
   385 	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);
 
   386 
       
   387 	TInt r = iLocDrv.ReduceSize(aPos,aLength);
 
   410 	TInt r = iLocDrv.ReduceSize(aPos,aLength);
 
   388 
   411 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREDUCESIZERET, "r %d", r);
 
   389 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveReduceSizeRet, EF32TraceUidProxyDrive, r);
 
       
   390 	return r;
 
   412 	return r;
 
   391 	}
 
   413 	}
 
   392 
   414 
   393 
   415 
   394 /**
 
   416 /**
 
   404 @return system wide error code.
 
   426 @return system wide error code.
 
   405 */
 
   427 */
 
   406 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)
 
   407 	{
 
   429 	{
 
   408 	TRACETHREADIDH(aThreadHandle);
 
   430 	TRACETHREADIDH(aThreadHandle);
 
   409 	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);
 
   410 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aTrg, threadId, aOffset, aFlags);
 
       
   411 
       
   412 	TInt r = iLocDrv.Read(aPos,aLength,aTrg,aThreadHandle,aOffset,aFlags);
 
   432 	TInt r = iLocDrv.Read(aPos,aLength,aTrg,aThreadHandle,aOffset,aFlags);
 
   413 
   433 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD1RET, "r %d", r);
 
   414 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead1Ret, EF32TraceUidProxyDrive, r);
 
       
   415 	return r;
 
   434 	return r;
 
   416 	}
 
   435 	}
 
   417 
   436 
   418 /**
 
   437 /**
 
   419 Read from the connected drive.
 
   438 Read from the connected drive.
 
   427 @return system wide error code.
 
   446 @return system wide error code.
 
   428 */
 
   447 */
 
   429 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)
 
   430 	{
 
   449 	{
 
   431 	TRACETHREADIDH(aThreadHandle);
 
   450 	TRACETHREADIDH(aThreadHandle);
 
   432 	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);
 
   433 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aTrg, threadId, anOffset);
 
       
   434 
       
   435 	TInt r = iLocDrv.Read(aPos,aLength,aTrg,aThreadHandle,anOffset);
 
   452 	TInt r = iLocDrv.Read(aPos,aLength,aTrg,aThreadHandle,anOffset);
 
   436 
   453 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD2RET, "r %d", r);
 
   437 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead2Ret, EF32TraceUidProxyDrive, r);
 
       
   438 	return r;
 
   454 	return r;
 
   439 	}
 
   455 	}
 
   440 
   456 
   441 /**
 
   457 /**
 
   442 Read from the connected drive.
 
   458 Read from the connected drive.
 
   447 
   463 
   448 @return system wide error code.
 
   464 @return system wide error code.
 
   449 */
 
   465 */
 
   450 TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)
 
   466 TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)
 
   451 	{
 
   467 	{
 
   452 	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);
 
   453 		this, I64LOW(aPos), I64HIGH(aPos), aLength, &aTrg);
 
       
   454 
       
   455 	TInt r = iLocDrv.Read(aPos,aLength,aTrg);
 
   469 	TInt r = iLocDrv.Read(aPos,aLength,aTrg);
 
   456 
   470 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD3RET, "r %d", r);
 
   457 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead3Ret, EF32TraceUidProxyDrive, r);
 
       
   458 	return r;
 
   471 	return r;
 
   459 	}
 
   472 	}
 
   460 
   473 
   461 
   474 
   462 /**
 
   475 /**
 
   472 @return system wide error code.
 
   485 @return system wide error code.
 
   473 */
 
   486 */
 
   474 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)
 
   475 	{
 
   488 	{
 
   476 	TRACETHREADIDH(aThreadHandle);
 
   489 	TRACETHREADIDH(aThreadHandle);
 
   477 	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);
 
   478 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aSrc, threadId, aOffset, aFlags);
 
       
   479 
       
   480 	TInt r = iLocDrv.Write(aPos,aLength,aSrc,aThreadHandle,aOffset,aFlags);
 
   491 	TInt r = iLocDrv.Write(aPos,aLength,aSrc,aThreadHandle,aOffset,aFlags);
 
   481 
   492 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE1RET, "r %d", r);
 
   482 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite1Ret, EF32TraceUidProxyDrive, r);
 
       
   483 
       
   484 	return r;
 
   493 	return r;
 
   485 	}
 
   494 	}
 
   486 
   495 
   487 
   496 
   488 /**
 
   497 /**
 
   497 @return system wide error code.
 
   506 @return system wide error code.
 
   498 */
 
   507 */
 
   499 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)
 
   500 	{
 
   509 	{
 
   501 	TRACETHREADIDH(aThreadHandle);
 
   510 	TRACETHREADIDH(aThreadHandle);
 
   502 	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);
 
   503 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aSrc, threadId, anOffset);
 
       
   504 
       
   505 	TInt r = iLocDrv.Write(aPos,aLength,aSrc,aThreadHandle,anOffset);
 
   512 	TInt r = iLocDrv.Write(aPos,aLength,aSrc,aThreadHandle,anOffset);
 
   506 
   513 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE2RET, "r %d", r);
 
   507 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite2Ret, EF32TraceUidProxyDrive, r);
 
       
   508 	return r;
 
   514 	return r;
 
   509 	}
 
   515 	}
 
   510 
   516 
   511 
   517 
   512 /**
 
   518 /**
 
   517 
   523 
   518 @return system wide error code.
 
   524 @return system wide error code.
 
   519 */
 
   525 */
 
   520 TInt CLocalProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)
 
   526 TInt CLocalProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)
 
   521 	{
 
   527 	{
 
   522 	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);
 
   523 		this, I64LOW(aPos), I64HIGH(aPos), aSrc.Length(), &aSrc);
 
       
   524 
       
   525 	TInt r = iLocDrv.Write(aPos,aSrc);
 
   529 	TInt r = iLocDrv.Write(aPos,aSrc);
 
   526 
   530 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE3RET, "r %d", r);
 
   527 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite3Ret, EF32TraceUidProxyDrive, r);
 
       
   528 	return r;
 
   531 	return r;
 
   529 	}
 
   532 	}
 
   530 	
   533 	
   531 	
   534 	
   532 /**
 
   535 /**
 
   536 
   539 
   537 @return system wide error code
 
   540 @return system wide error code
 
   538 */
 
   541 */
 
   539 TInt CLocalProxyDrive::Caps(TDes8& anInfo)
 
   542 TInt CLocalProxyDrive::Caps(TDes8& anInfo)
 
   540 	{
 
   543 	{
 
   541 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveCaps, EF32TraceUidProxyDrive, this);
 
   544 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVECAPS, "this %x", this);
 
   542 
       
   543 	TInt r = iLocDrv.Caps(anInfo);
 
   545 	TInt r = iLocDrv.Caps(anInfo);
 
   544 
   546 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVECAPSRET, "r %d", r);
 
   545 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveCapsRet, EF32TraceUidProxyDrive, r);
 
       
   546 	return r;
 
   547 	return r;
 
   547 	}
 
   548 	}
 
   548 
   549 
   549 
   550 
   550 /**
 
   551 /**
 
   554 
   555 
   555 @return system wide error code.
 
   556 @return system wide error code.
 
   556 */
 
   557 */
 
   557 TInt CLocalProxyDrive::Format(TFormatInfo& anInfo)
 
   558 TInt CLocalProxyDrive::Format(TFormatInfo& anInfo)
 
   558 	{
 
   559 	{
 
   559 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveFormat1, EF32TraceUidProxyDrive, this);
 
   560 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEFORMAT1, "this %x", this);
 
   560 
       
   561 	TInt r = iLocDrv.Format(anInfo);
 
   561 	TInt r = iLocDrv.Format(anInfo);
 
   562 
   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);
 
   563 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveFormat1Ret, EF32TraceUidProxyDrive, 
       
   564 		r, anInfo.iFormatIsCurrent, anInfo.i512ByteSectorsFormatted, anInfo.iMaxBytesPerFormat);
 
       
   565 	return r;
 
   563 	return r;
 
   566 	}
 
   564 	}
 
   567 
   565 
   568 
   566 
   569 /**
 
   567 /**
 
   574 
   572 
   575 @return system wide error code.
 
   573 @return system wide error code.
 
   576 */
 
   574 */
 
   577 TInt CLocalProxyDrive::Format(TInt64 aPos,TInt aLength)
 
   575 TInt CLocalProxyDrive::Format(TInt64 aPos,TInt aLength)
 
   578 	{
 
   576 	{
 
   579 	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);
 
   580 		this, I64LOW(aPos), I64HIGH(aPos), aLength);
 
       
   581 
       
   582 	TInt r = iLocDrv.Format(aPos,aLength);
 
   578 	TInt r = iLocDrv.Format(aPos,aLength);
 
   583 
   579 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEFORMAT2RET, "r %d", r);
 
   584 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveFormat2Ret, EF32TraceUidProxyDrive, r);
 
       
   585 	return r;
 
   580 	return r;
 
   586 	}
 
   581 	}
 
   587 
   582 
   588 
   583 
   589 /**
 
   584 /**
 
   594 
   589 
   595 @return system wide error code.
 
   590 @return system wide error code.
 
   596 */
 
   591 */
 
   597 TInt CLocalProxyDrive::SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle)
 
   592 TInt CLocalProxyDrive::SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle)
 
   598 	{
 
   593 	{
 
   599 	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);
 
   600 
       
   601 	TInt r = iLocDrv.SetMountInfo(aMountInfo,aMountInfoThreadHandle);
 
   595 	TInt r = iLocDrv.SetMountInfo(aMountInfo,aMountInfoThreadHandle);
 
   602 
   596 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVESETMOUNTINFORET, "r %d", r);
 
   603 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveSetMountInfoRet, EF32TraceUidProxyDrive, r);
 
       
   604 	return r;
 
   597 	return r;
 
   605 	}
 
   598 	}
 
   606 
   599 
   607 
   600 
   608 /**
 
   601 /**
 
   612 
   605 
   613 @return system wide error code.
 
   606 @return system wide error code.
 
   614 */
 
   607 */
 
   615 TInt CLocalProxyDrive::ForceRemount(TUint aFlags)
 
   608 TInt CLocalProxyDrive::ForceRemount(TUint aFlags)
 
   616 	{
 
   609 	{
 
   617 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveForceRemount, EF32TraceUidProxyDrive, this, aFlags);
 
   610 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEFORCEREMOUNT, "this %x aFlags %x", (TUint) this, (TUint) aFlags);
 
   618 
       
   619 	TInt r = iLocDrv.ForceRemount(aFlags);
 
   611 	TInt r = iLocDrv.ForceRemount(aFlags);
 
   620 
   612 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEFORCEREMOUNTRET, "r %d", r);
 
   621 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveForceRemountRet, EF32TraceUidProxyDrive, r);
 
       
   622 	return r;
 
   613 	return r;
 
   623 	}
 
   614 	}
 
   624 
   615 
   625 /**
 
   616 /**
 
   626 An interface with which control commands can be passed to 
   617 An interface with which control commands can be passed to 
   633 
   624 
   634 @return system wide error code.
 
   625 @return system wide error code.
 
   635 */
 
   626 */
 
   636 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)
 
   637 	{
 
   628 	{
 
   638 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveControlIO, EF32TraceUidProxyDrive, this);
 
   629 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVECONTROLIO, "this %x", this);
 
   639 
       
   640 	TInt r = iLocDrv.ControlIO(aCommand,aParam1,aParam2);
 
   630 	TInt r = iLocDrv.ControlIO(aCommand,aParam1,aParam2);
 
   641 
   631 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVECONTROLIORET, "r %d", r);
 
   642 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveControlIORet, EF32TraceUidProxyDrive, r);
 
       
   643 	return r;
 
   632 	return r;
 
   644 	}
 
   633 	}
 
   645 	
   634 	
   646 	
   635 	
   647 /**
 
   636 /**
 
   652 
   641 
   653 @return system wide error code.
 
   642 @return system wide error code.
 
   654 */
 
   643 */
 
   655 TInt CLocalProxyDrive::Unlock(TMediaPassword &aPassword, TBool aStorePassword)
 
   644 TInt CLocalProxyDrive::Unlock(TMediaPassword &aPassword, TBool aStorePassword)
 
   656 	{
 
   645 	{
 
   657 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveUnlock, EF32TraceUidProxyDrive, this, aStorePassword);
 
   646 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEUNLOCK, "this %x aPassword %d", (TUint) this, (TUint) aStorePassword);
 
   658 
       
   659 	TInt r = iLocDrv.Unlock(aPassword,aStorePassword);
 
   647 	TInt r = iLocDrv.Unlock(aPassword,aStorePassword);
 
   660 
   648 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEUNLOCKRET, "r %d", r);
 
   661 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveUnlockRet, EF32TraceUidProxyDrive, r);
 
       
   662 	return r;
 
   649 	return r;
 
   663 	}
 
   650 	}
 
   664 
   651 
   665 
   652 
   666 /**
 
   653 /**
 
   672 
   659 
   673 @return system wide error code.
 
   660 @return system wide error code.
 
   674 */
 
   661 */
 
   675 TInt CLocalProxyDrive::Lock(TMediaPassword &aOldPassword, TMediaPassword &aNewPassword, TBool aStorePassword)
 
   662 TInt CLocalProxyDrive::Lock(TMediaPassword &aOldPassword, TMediaPassword &aNewPassword, TBool aStorePassword)
 
   676 	{
 
   663 	{
 
   677 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveLock, EF32TraceUidProxyDrive, this, aStorePassword);
 
   664 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVELOCK, "this %x aPassword %d", (TUint) this, (TUint) aStorePassword);
 
   678 
       
   679 	TInt r = iLocDrv.SetPassword(aOldPassword,aNewPassword,aStorePassword);
 
   665 	TInt r = iLocDrv.SetPassword(aOldPassword,aNewPassword,aStorePassword);
 
   680 
   666 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVELOCKRET, "r %d", r);
 
   681 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveLockRet, EF32TraceUidProxyDrive, r);
 
       
   682 	return r;
 
   667 	return r;
 
   683 	}
 
   668 	}
 
   684 
   669 
   685 
   670 
   686 /**
 
   671 /**
 
   690 
   675 
   691 @return system wide error code.
 
   676 @return system wide error code.
 
   692 */
 
   677 */
 
   693 TInt CLocalProxyDrive::Clear(TMediaPassword &aPassword)
 
   678 TInt CLocalProxyDrive::Clear(TMediaPassword &aPassword)
 
   694 	{
 
   679 	{
 
   695 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveClear, EF32TraceUidProxyDrive, this);
 
   680 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVECLEAR, "this %x", this);
 
   696 
       
   697 	TInt r = iLocDrv.Clear(aPassword);
 
   681 	TInt r = iLocDrv.Clear(aPassword);
 
   698 
   682 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVECLEARRET, "r %d", r);
 
   699 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveClearRet, EF32TraceUidProxyDrive, r);
 
       
   700 	return r;
 
   683 	return r;
 
   701 	}
 
   684 	}
 
   702 
   685 
   703 /**
 
   686 /**
 
   704 Forcibly unlock a password-enabled drive.
 
   687 Forcibly unlock a password-enabled drive.
 
   705 
   688 
   706 @return system wide error code.
 
   689 @return system wide error code.
 
   707 */
 
   690 */
 
   708 TInt CLocalProxyDrive::ErasePassword()
 
   691 TInt CLocalProxyDrive::ErasePassword()
 
   709 	{
 
   692 	{
 
   710 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveErasePassword, EF32TraceUidProxyDrive, this);
 
   693 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEERASEPASSWORD, "this %x", this);
 
   711 
       
   712 	TInt r = iLocDrv.ErasePassword();
 
   694 	TInt r = iLocDrv.ErasePassword();
 
   713 
   695 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEERASEPASSWORDRET, "r %d", r);
 
   714 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveErasePasswordRet, EF32TraceUidProxyDrive, r);
 
       
   715 	return r;
 
   696 	return r;
 
   716 	}
 
   697 	}
 
   717 
   698 
   718 /**
 
   699 /**
 
   719 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.
 
   720 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.
 
   721 
   702 
   722 @param aPos    The position of the data which is being deleted.
 
   703 @param aPos    The position of the data which is being deleted.
 
   723 @param aLength The length of the data which is being deleted.
 
   704 @param aLength The length of the data which is being deleted.
 
   724 
       
   725 @return System wide error code.
 
   705 @return System wide error code.
 
   726 */
 
   706 */
 
   727 TInt CLocalProxyDrive::DeleteNotify(TInt64 aPos, TInt aLength)
 
   707 TInt CLocalProxyDrive::DeleteNotify(TInt64 aPos, TInt aLength)
 
   728 	{
 
   708 	{
 
   729 	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);
 
   730 		this, I64LOW(aPos), I64HIGH(aPos), aLength);
 
       
   731 
       
   732 	TInt r = iLocDrv.DeleteNotify(aPos, aLength);
 
   710 	TInt r = iLocDrv.DeleteNotify(aPos, aLength);
 
   733 
   711 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEDELETENOTIFYRET, "r %d", r);
 
   734 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveDeleteNotifyRet, EF32TraceUidProxyDrive, r);
 
       
   735 	return r;
 
   712 	return r;
 
   736 	}
 
   713 	}
 
   737 
   714 
   738 
   715 
   739 /**
 
   716 /**
 
   743 
   720 
   744 @return System wide error code.
 
   721 @return System wide error code.
 
   745 */	
   722 */	
   746 TInt CLocalProxyDrive::GetLastErrorInfo(TDes8 &aErrorInfo)
 
   723 TInt CLocalProxyDrive::GetLastErrorInfo(TDes8 &aErrorInfo)
 
   747 	{
 
   724 	{
 
   748 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveGetLastErrorInfo, EF32TraceUidProxyDrive, this);
 
   725 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEGETLASTERRORINFO, "this %x", this);
 
   749 
       
   750 	TInt r = iLocDrv.GetLastErrorInfo(aErrorInfo);
 
   726 	TInt r = iLocDrv.GetLastErrorInfo(aErrorInfo);
 
   751 
   727 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEGETLASTERRORINFORET, "r %d", r);
 
   752 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveGetLastErrorInfoRet, EF32TraceUidProxyDrive, r);
 
       
   753 	return r;
 
   728 	return r;
 
   754 	}
 
   729 	}
 
   755 
   730 
   756 
   731 
   757 TInt CLocalProxyDrive::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
 
   732 TInt CLocalProxyDrive::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
 
   758 	{
 
   733 	{
 
   759 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveGetInterface, EF32TraceUidProxyDrive, 
   734 	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;
 
   735 	TInt r;
 
   763 	switch(aInterfaceId)
 
   736 	switch(aInterfaceId)
 
   764 		{
 
   737 		{
 
   765 		case EGetLocalDrive:
 
   738 		case EGetLocalDrive:
 
   766 			__ASSERT_ALWAYS((CProxyDrive*)aInput==this,Fault(ELocDrvInvalidLocalDrive));
 
   739 			__ASSERT_ALWAYS((CProxyDrive*)aInput==this,Fault(ELocDrvInvalidLocalDrive));
 
   774 			break;
 
   747 			break;
 
   775 
   748 
   776 		default:
 
   749 		default:
 
   777 			r= CProxyDrive::GetInterface(aInterfaceId,aInterface,aInput);
 
   750 			r= CProxyDrive::GetInterface(aInterfaceId,aInterface,aInput);
 
   778 		}
 
   751 		}
 
   779 
   752 	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;
 
   753 	return r;
 
   782 	}
 
   754 	}
 
   783 
   755 
   784 
   756 
   785 
   757 
   812 
   784 
   813 @return system wide error code.
 
   785 @return system wide error code.
 
   814 */
 
   786 */
 
   815 EXPORT_C TInt CBaseExtProxyDrive::Initialise()
 
   787 EXPORT_C TInt CBaseExtProxyDrive::Initialise()
 
   816 	{
 
   788 	{
 
   817 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveInitialise, EF32TraceUidProxyDrive, this);
 
   789 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEINITIALISE, "this %x", this);
 
   818 
       
   819 	TInt r = iProxy->Initialise();
 
   790 	TInt r = iProxy->Initialise();
 
   820 
   791 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEINITIALISERET, "r %d", r);
 
   821 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveInitialiseRet, EF32TraceUidProxyDrive, r);
 
       
   822 	return r;
 
   792 	return r;
 
   823 	}
 
   793 	}
 
   824 
   794 
   825 
   795 
   826 /**
 
   796 /**
 
   828 
   798 
   829 @return KErrNone.
 
   799 @return KErrNone.
 
   830 */
 
   800 */
 
   831 EXPORT_C TInt CBaseExtProxyDrive::Dismounted()
 
   801 EXPORT_C TInt CBaseExtProxyDrive::Dismounted()
 
   832 	{
 
   802 	{
 
   833 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveDismounted, EF32TraceUidProxyDrive, this);
 
   803 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEDISMOUNTED, "this %x", this);
 
   834 
       
   835 	TInt r = iProxy->Dismounted();
 
   804 	TInt r = iProxy->Dismounted();
 
   836 
   805 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEDISMOUNTEDRET, "r %d", r);
 
   837 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveDismountedRet, EF32TraceUidProxyDrive, r);
 
       
   838 	return r;
 
   806 	return r;
 
   839 	}
 
   807 	}
 
   840 
   808 
   841 /**
 
   809 /**
 
   842 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).
 
   845 
   813 
   846 @return system wide error code.
 
   814 @return system wide error code.
 
   847 */
 
   815 */
 
   848 EXPORT_C TInt CBaseExtProxyDrive::Enlarge(TInt aLength)
 
   816 EXPORT_C TInt CBaseExtProxyDrive::Enlarge(TInt aLength)
 
   849 	{
 
   817 	{
 
   850 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveEnlarge, EF32TraceUidProxyDrive, this, aLength);
 
   818 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEENLARGE, "this %x aLength %d", (TUint) this, (TUint) aLength);
 
   851 
       
   852 	TInt r = iProxy->Enlarge(aLength);
 
   819 	TInt r = iProxy->Enlarge(aLength);
 
   853 
   820 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEENLARGERET, "r %d", r);
 
   854 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveEnlargeRet, EF32TraceUidProxyDrive, r);
 
       
   855 	return r;
 
   821 	return r;
 
   856 	}
 
   822 	}
 
   857 
   823 
   858 
   824 
   859 /**
 
   825 /**
 
   867 
   833 
   868 @return system wide error code.
 
   834 @return system wide error code.
 
   869 */
 
   835 */
 
   870 EXPORT_C TInt CBaseExtProxyDrive::ReduceSize(TInt aPos, TInt aLength)
 
   836 EXPORT_C TInt CBaseExtProxyDrive::ReduceSize(TInt aPos, TInt aLength)
 
   871 	{
 
   837 	{
 
   872 	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);
 
   873 
       
   874 	TInt r = iProxy->ReduceSize(aPos,aLength);
 
   839 	TInt r = iProxy->ReduceSize(aPos,aLength);
 
   875 
   840 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEREDUCESIZERET, "r %d", r);
 
   876 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveReduceSizeRet, EF32TraceUidProxyDrive, r);
 
       
   877 	return r;
 
   841 	return r;
 
   878 	}
 
   842 	}
 
   879 
   843 
   880 
   844 
   881 /**
 
   845 /**
 
   891 @return system wide error code.
 
   855 @return system wide error code.
 
   892 */
 
   856 */
 
   893 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)
 
   894 	{
 
   858 	{
 
   895 	TRACETHREADIDH(aThreadHandle);
 
   859 	TRACETHREADIDH(aThreadHandle);
 
   896 	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);
 
   897 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aTrg, threadId, aOffset, aFlags);
 
       
   898 
       
   899 	TInt r = iProxy->Read(aPos,aLength,aTrg,aThreadHandle,aOffset,aFlags);
 
   861 	TInt r = iProxy->Read(aPos,aLength,aTrg,aThreadHandle,aOffset,aFlags);
 
   900 
   862 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEREAD1RET, "r %d", r);
 
   901 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead1Ret, EF32TraceUidProxyDrive, r);
 
       
   902 
       
   903 	return r;
 
   863 	return r;
 
   904 	}
 
   864 	}
 
   905 
   865 
   906 
   866 
   907 /**
 
   867 /**
 
   916 @return system wide error code.
 
   876 @return system wide error code.
 
   917 */
 
   877 */
 
   918 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)
 
   919 	{
 
   879 	{
 
   920 	TRACETHREADIDH(aThreadHandle);
 
   880 	TRACETHREADIDH(aThreadHandle);
 
   921 	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);
 
   922 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aTrg, threadId, anOffset);
 
       
   923 
       
   924 	TInt r = iProxy->Read(aPos,aLength,aTrg,aThreadHandle,anOffset);
 
   882 	TInt r = iProxy->Read(aPos,aLength,aTrg,aThreadHandle,anOffset);
 
   925 
   883 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEREAD2RET, "r %d", r);
 
   926 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead2Ret, EF32TraceUidProxyDrive, r);
 
       
   927 	return r;
 
   884 	return r;
 
   928 	}
 
   885 	}
 
   929 
   886 
   930 
   887 
   931 /**
 
   888 /**
 
   937 
   894 
   938 @return system wide error code.
 
   895 @return system wide error code.
 
   939 */
 
   896 */
 
   940 EXPORT_C TInt CBaseExtProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)
 
   897 EXPORT_C TInt CBaseExtProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)
 
   941 	{
 
   898 	{
 
   942 	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);
 
   943 		this, I64LOW(aPos), I64HIGH(aPos), aLength, &aTrg);
 
   900 		
   944 
       
   945 	TInt r = iProxy->Read(aPos,aLength,aTrg);
 
   901 	TInt r = iProxy->Read(aPos,aLength,aTrg);
 
   946 
   902 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEREAD3RET, "r %d", r);
 
   947 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead3Ret, EF32TraceUidProxyDrive, r);
 
       
   948 	return r;
 
   903 	return r;
 
   949 	}
 
   904 	}
 
   950 
   905 
   951 
   906 
   952 /**
 
   907 /**
 
   962 @return system wide error code.
 
   917 @return system wide error code.
 
   963 */
 
   918 */
 
   964 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)
 
   965 	{
 
   920 	{
 
   966 	TRACETHREADIDH(aThreadHandle);
 
   921 	TRACETHREADIDH(aThreadHandle);
 
   967 	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);
 
   968 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aSrc, threadId, aOffset, aFlags);
 
       
   969 
       
   970 	TInt r = iProxy->Write(aPos,aLength,aSrc,aThreadHandle,aOffset,aFlags);
 
   923 	TInt r = iProxy->Write(aPos,aLength,aSrc,aThreadHandle,aOffset,aFlags);
 
   971 
   924 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEWRITE1RET, "r %d", r);
 
   972 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite1Ret, EF32TraceUidProxyDrive, r);
 
       
   973 	return r;
 
   925 	return r;
 
   974 	}
 
   926 	}
 
   975 
   927 
   976 
   928 
   977 /**
 
   929 /**
 
   986 @return system wide error code.
 
   938 @return system wide error code.
 
   987 */
 
   939 */
 
   988 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)
 
   989 	{
 
   941 	{
 
   990 	TRACETHREADIDH(aThreadHandle);
 
   942 	TRACETHREADIDH(aThreadHandle);
 
   991 	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);
 
   992 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aSrc, threadId, anOffset);
 
       
   993 
       
   994 	TInt r = iProxy->Write(aPos,aLength,aSrc,aThreadHandle,anOffset);
 
   944 	TInt r = iProxy->Write(aPos,aLength,aSrc,aThreadHandle,anOffset);
 
   995 
   945 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEWRITE2RET, "r %d", r);
 
   996 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite2Ret, EF32TraceUidProxyDrive, r);
 
       
   997 	return r;
 
   946 	return r;
 
   998 	}
 
   947 	}
 
   999 
   948 
  1000 
   949 
  1001 /**
 
   950 /**
 
  1006 
   955 
  1007 @return system wide error code.
 
   956 @return system wide error code.
 
  1008 */
 
   957 */
 
  1009 EXPORT_C TInt CBaseExtProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)
 
   958 EXPORT_C TInt CBaseExtProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)
 
  1010 	{
 
   959 	{
 
  1011 	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);
 
  1012 		this, I64LOW(aPos), I64HIGH(aPos), aSrc.Length(), &aSrc);
 
       
  1013 
       
  1014 	TInt r = iProxy->Write(aPos,aSrc);
 
   961 	TInt r = iProxy->Write(aPos,aSrc);
 
  1015 
   962 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEWRITE3RET, "r %d", r);
 
  1016 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite3Ret, EF32TraceUidProxyDrive, r);
 
       
  1017 	return r;
 
   963 	return r;
 
  1018 	}
 
   964 	}
 
  1019 
   965 
  1020 
   966 
  1021 /**
 
   967 /**
 
  1025 
   971 
  1026 @return system wide error code
 
   972 @return system wide error code
 
  1027 */
 
   973 */
 
  1028 EXPORT_C TInt CBaseExtProxyDrive::Caps(TDes8& anInfo)
 
   974 EXPORT_C TInt CBaseExtProxyDrive::Caps(TDes8& anInfo)
 
  1029 	{
 
   975 	{
 
  1030 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveCaps, EF32TraceUidProxyDrive, this);
 
   976 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVECAPS, "this %x", this);
 
  1031 
       
  1032 	TInt r = iProxy->Caps(anInfo);
 
   977 	TInt r = iProxy->Caps(anInfo);
 
  1033 
   978 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVECAPSRET, "r %d", r);
 
  1034 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveCapsRet, EF32TraceUidProxyDrive, r);
 
       
  1035 	return r;
 
   979 	return r;
 
  1036 	}
 
   980 	}
 
  1037 
   981 
  1038 
   982 
  1039 /**
 
   983 /**
 
  1043 
   987 
  1044 @return system wide error code.
 
   988 @return system wide error code.
 
  1045 */
 
   989 */
 
  1046 EXPORT_C TInt CBaseExtProxyDrive::Format(TFormatInfo& anInfo)
 
   990 EXPORT_C TInt CBaseExtProxyDrive::Format(TFormatInfo& anInfo)
 
  1047 	{
 
   991 	{
 
  1048 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveFormat1, EF32TraceUidProxyDrive, this);
 
   992 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEFORMAT1, "this %x", this);
 
  1049 
       
  1050 	TInt r = iProxy->Format(anInfo);
 
   993 	TInt r = iProxy->Format(anInfo);
 
  1051 
   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);
 
  1052 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveFormat1Ret, EF32TraceUidProxyDrive, 
       
  1053 		r, anInfo.iFormatIsCurrent, anInfo.i512ByteSectorsFormatted, anInfo.iMaxBytesPerFormat);
 
       
  1054 	return r;
 
   995 	return r;
 
  1055 	}
 
   996 	}
 
  1056 
   997 
  1057 
   998 
  1058 /**
 
   999 /**
 
  1063 
  1004 
  1064 @return system wide error code.
 
  1005 @return system wide error code.
 
  1065 */
 
  1006 */
 
  1066 EXPORT_C TInt CBaseExtProxyDrive::Format(TInt64 aPos,TInt aLength)
 
  1007 EXPORT_C TInt CBaseExtProxyDrive::Format(TInt64 aPos,TInt aLength)
 
  1067 	{
 
  1008 	{
 
  1068 	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);
 
  1069 		this, I64LOW(aPos), I64HIGH(aPos), aLength);
 
       
  1070 
       
  1071 	TInt r = iProxy->Format(aPos,aLength);
 
  1010 	TInt r = iProxy->Format(aPos,aLength);
 
  1072 
  1011 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEFORMAT2RET, "r %d", r);
 
  1073 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveFormat2Ret, EF32TraceUidProxyDrive, r);
 
       
  1074 	return r;
 
  1012 	return r;
 
  1075 	}
 
  1013 	}
 
  1076 
  1014 
  1077 
  1015 
  1078 /**
 
  1016 /**
 
  1083 
  1021 
  1084 @return system wide error code.
 
  1022 @return system wide error code.
 
  1085 */
 
  1023 */
 
  1086 EXPORT_C TInt CBaseExtProxyDrive::SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle)
 
  1024 EXPORT_C TInt CBaseExtProxyDrive::SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle)
 
  1087 	{
 
  1025 	{
 
  1088 	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);
 
  1089 
       
  1090 	TInt r = iProxy->SetMountInfo(aMountInfo,aMountInfoThreadHandle);
 
  1027 	TInt r = iProxy->SetMountInfo(aMountInfo,aMountInfoThreadHandle);
 
  1091 
  1028 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVESETMOUNTINFORET, "r %d", r);
 
  1092 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveSetMountInfoRet, EF32TraceUidProxyDrive, r);
 
       
  1093 	return r;
 
  1029 	return r;
 
  1094 	}
 
  1030 	}
 
  1095 
  1031 
  1096 
  1032 
  1097 /**
 
  1033 /**
 
  1101 
  1037 
  1102 @return system wide error code.
 
  1038 @return system wide error code.
 
  1103 */
 
  1039 */
 
  1104 EXPORT_C TInt CBaseExtProxyDrive::ForceRemount(TUint aFlags)
 
  1040 EXPORT_C TInt CBaseExtProxyDrive::ForceRemount(TUint aFlags)
 
  1105 	{
 
  1041 	{
 
  1106 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveForceRemount, EF32TraceUidProxyDrive, this, aFlags);
 
  1042 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEFORCEREMOUNT, "this %x aFlags%x", (TUint) this, (TUint) aFlags);
 
  1107 
       
  1108 	TInt r = iProxy->ForceRemount(aFlags);
 
  1043 	TInt r = iProxy->ForceRemount(aFlags);
 
  1109 
  1044 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEFORCEREMOUNTRET, "r %d", r);
 
  1110 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveForceRemountRet, EF32TraceUidProxyDrive, r);
 
       
  1111 	return r;
 
  1045 	return r;
 
  1112 	}
 
  1046 	}
 
  1113 
  1047 
  1114 
  1048 
  1115 /**
 
  1049 /**
 
  1120 
  1054 
  1121 @return system wide error code.
 
  1055 @return system wide error code.
 
  1122 */
 
  1056 */
 
  1123 EXPORT_C TInt CBaseExtProxyDrive::Unlock(TMediaPassword &aPassword, TBool aStorePassword)
 
  1057 EXPORT_C TInt CBaseExtProxyDrive::Unlock(TMediaPassword &aPassword, TBool aStorePassword)
 
  1124 	{
 
  1058 	{
 
  1125 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveUnlock, EF32TraceUidProxyDrive, this, aStorePassword);
 
  1059 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEUNLOCK, "this %x aPassword %d", (TUint) this, (TUint) aStorePassword);
 
  1126 
       
  1127 	TInt r = iProxy->Unlock(aPassword,aStorePassword);
 
  1060 	TInt r = iProxy->Unlock(aPassword,aStorePassword);
 
  1128 
  1061 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEUNLOCKRET, "r %d", r);
 
  1129 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveUnlockRet, EF32TraceUidProxyDrive, r);
 
       
  1130 	return r;
 
  1062 	return r;
 
  1131 	}
 
  1063 	}
 
  1132 
  1064 
  1133 
  1065 
  1134 /**
 
  1066 /**
 
  1140 
  1072 
  1141 @return system wide error code.
 
  1073 @return system wide error code.
 
  1142 */
 
  1074 */
 
  1143 EXPORT_C TInt CBaseExtProxyDrive::Lock(TMediaPassword &aOldPassword, TMediaPassword &aNewPassword, TBool aStorePassword)
 
  1075 EXPORT_C TInt CBaseExtProxyDrive::Lock(TMediaPassword &aOldPassword, TMediaPassword &aNewPassword, TBool aStorePassword)
 
  1144 	{
 
  1076 	{
 
  1145 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveLock, EF32TraceUidProxyDrive, this, aStorePassword);
 
  1077 	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVELOCK, "this %x aPassword %d", (TUint) this, (TUint) aStorePassword);
 
  1146 
       
  1147 	TInt r = iProxy->Lock(aOldPassword,aNewPassword,aStorePassword);
 
  1078 	TInt r = iProxy->Lock(aOldPassword,aNewPassword,aStorePassword);
 
  1148 
  1079 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVELOCKRET, "r %d", r);
 
  1149 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveLockRet, EF32TraceUidProxyDrive, r);
 
       
  1150 	return r;
 
  1080 	return r;
 
  1151 	}
 
  1081 	}
 
  1152 
  1082 
  1153 
  1083 
  1154 /**
 
  1084 /**
 
  1158 
  1088 
  1159 @return system wide error code.
 
  1089 @return system wide error code.
 
  1160 */
 
  1090 */
 
  1161 EXPORT_C TInt CBaseExtProxyDrive::Clear(TMediaPassword &aPassword)
 
  1091 EXPORT_C TInt CBaseExtProxyDrive::Clear(TMediaPassword &aPassword)
 
  1162 	{
 
  1092 	{
 
  1163 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveClear, EF32TraceUidProxyDrive, this);
 
  1093 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVECLEAR, "this %x", this);
 
  1164 
       
  1165 	TInt r = iProxy->Clear(aPassword);
 
  1094 	TInt r = iProxy->Clear(aPassword);
 
  1166 
  1095 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVECLEARRET, "r %d", r);
 
  1167 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveClearRet, EF32TraceUidProxyDrive, r);
 
       
  1168 	return r;
 
  1096 	return r;
 
  1169 	}
 
  1097 	}
 
  1170 
  1098 
  1171 /**
 
  1099 /**
 
  1172 Forcibly unlock a password-enabled proxy drive.
 
  1100 Forcibly unlock a password-enabled proxy drive.
 
  1173 
  1101 
  1174 @return system wide error code.
 
  1102 @return system wide error code.
 
  1175 */
 
  1103 */
 
  1176 EXPORT_C TInt CBaseExtProxyDrive::ErasePassword()
 
  1104 EXPORT_C TInt CBaseExtProxyDrive::ErasePassword()
 
  1177 	{
 
  1105 	{
 
  1178 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveErasePassword, EF32TraceUidProxyDrive, this);
 
  1106 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEERASEPASSWORD, "this %x", this);
 
  1179 
       
  1180 	TInt r = iProxy->ErasePassword();
 
  1107 	TInt r = iProxy->ErasePassword();
 
  1181 
  1108 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEERASEPASSWORDRET, "r %d", r);
 
  1182 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveErasePasswordRet, EF32TraceUidProxyDrive, r);
 
       
  1183 	return r;
 
  1109 	return r;
 
  1184 	}
 
  1110 	}
 
  1185 
  1111 
  1186 /**
 
  1112 /**
 
  1187 An interface with which control commands can be passed to 
  1113 An interface with which control commands can be passed to 
  1194 
  1120 
  1195 @return system wide error code.
 
  1121 @return system wide error code.
 
  1196 */
 
  1122 */
 
  1197 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)
 
  1198 	{
 
  1124 	{
 
  1199 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveControlIO, EF32TraceUidProxyDrive, this);
 
  1125 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVECONTROLIO, "this %x", this);
 
  1200 
       
  1201 	TInt r = iProxy->ControlIO(aMessage,aCommand,aParam1,aParam2);
 
  1126 	TInt r = iProxy->ControlIO(aMessage,aCommand,aParam1,aParam2);
 
  1202 
  1127 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVECONTROLIORET, "r %d", r);
 
  1203 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveControlIORet, EF32TraceUidProxyDrive, r);
 
       
  1204 	return r;
 
  1128 	return r;
 
  1205 	}
 
  1129 	}
 
  1206 
  1130 
  1207 
  1131 
  1208 /**
 
  1132 /**
 
  1214 
  1138 
  1215 @return system wide error code.
 
  1139 @return system wide error code.
 
  1216 */	
  1140 */	
  1217 EXPORT_C TInt CBaseExtProxyDrive::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
 
  1141 EXPORT_C TInt CBaseExtProxyDrive::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
 
  1218 	{
 
  1142 	{
 
  1219 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveGetInterface, EF32TraceUidProxyDrive, 
  1143 	OstTraceExt3(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEGETINTERFACE, "this %x aInterfaceId %d aInput %x", (TUint) this, (TUint) aInterfaceId, (TUint) aInput);
 
  1220 		this, aInterfaceId, aInput);
 
  1144 		
  1221 
       
  1222 	TInt r;
 
  1145 	TInt r;
 
  1223 	if (aInterfaceId==EGetLocalDrive)
 
  1146 	if (aInterfaceId==EGetLocalDrive)
 
  1224 		{
 
  1147 		{
 
  1225 		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
 
  1226 		}
 
  1149 		}
 
  1227 	else	
  1150 	else	
  1228 		r = CProxyDrive::GetInterface(aInterfaceId,aInterface,aInput);
 
  1151 		r = CProxyDrive::GetInterface(aInterfaceId,aInterface,aInput);
 
  1229 
  1152 	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;
 
  1153 	return r;
 
  1232 	}	
  1154 	}	
  1233 
  1155 
  1234 
  1156 
  1235 /**
 
  1157 /**
 
  1239 
  1161 
  1240 @return System wide error code.
 
  1162 @return System wide error code.
 
  1241 */
 
  1163 */
 
  1242 EXPORT_C TInt CBaseExtProxyDrive::GetLastErrorInfo(TDes8 &aErrorInfo)
 
  1164 EXPORT_C TInt CBaseExtProxyDrive::GetLastErrorInfo(TDes8 &aErrorInfo)
 
  1243 	{
 
  1165 	{
 
  1244 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveGetLastErrorInfo, EF32TraceUidProxyDrive, this);
 
  1166 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEGETLASTERRORINFO, "this %x", this);
 
  1245 
       
  1246 	TInt r = iProxy->GetLastErrorInfo(aErrorInfo);
 
  1167 	TInt r = iProxy->GetLastErrorInfo(aErrorInfo);
 
  1247 
  1168 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEGETLASTERRORINFORET, "r %d", r);
 
  1248 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveGetLastErrorInfoRet, EF32TraceUidProxyDrive, r);
 
       
  1249 	return r;
 
  1169 	return r;
 
  1250 	}
 
  1170 	}
 
  1251 
  1171 
  1252 
  1172 
  1253 /**
 
  1173 /**
 
  1259 
  1179 
  1260 @return System wide error code.
 
  1180 @return System wide error code.
 
  1261 */
 
  1181 */
 
  1262 EXPORT_C TInt CBaseExtProxyDrive::DeleteNotify(TInt64 aPos, TInt aLength)
 
  1182 EXPORT_C TInt CBaseExtProxyDrive::DeleteNotify(TInt64 aPos, TInt aLength)
 
  1263     {
 
  1183     {
 
  1264 	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);
 
  1265 		this, I64LOW(aPos), I64HIGH(aPos), aLength);
 
       
  1266 
       
  1267     TInt r = iProxy->DeleteNotify(aPos, aLength);
 
  1185     TInt r = iProxy->DeleteNotify(aPos, aLength);
 
  1268 
  1186 	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECBASEEXTPROXYDRIVEDELETENOTIFYRET, "r %d", r);
 
  1269 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveDeleteNotifyRet, EF32TraceUidProxyDrive, r);
 
       
  1270 	return r;
 
  1187 	return r;
 
  1271     }
 
  1188     }
 
  1272 
  1189 
  1273 
  1190 
  1274 /**
 
  1191 /**
 
  1337 	TDrive& drive=TheDrives[aMount->Drive().DriveNumber()];
 
  1254 	TDrive& drive=TheDrives[aMount->Drive().DriveNumber()];
 
  1338 	if(drive.ExtInfo().iCount==0)
 
  1255 	if(drive.ExtInfo().iCount==0)
 
  1339 		return(aConcreteDrive);
 
  1256 		return(aConcreteDrive);
 
  1340 
  1257 
  1341 	TBool extSupported = drive.FSys().IsExtensionSupported();
 
  1258 	TBool extSupported = drive.FSys().IsExtensionSupported();
 
  1342 	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemIsExtensionSupported, EF32TraceUidProxyDrive, extSupported);
 
  1259 	OstTraceExt2(TRACE_DRIVE, FSYS_ECFILESYSTEMISEXTENSIONSUPPORTED2, "%x r %d", (TUint) &drive.FSys(), (TUint) extSupported);
 
  1343 	if(!extSupported)
 
  1260 	if(!extSupported)
 
  1344 		{
 
  1261 		{
 
  1345 		delete(aConcreteDrive);
 
  1262 		delete(aConcreteDrive);
 
  1346 		User::Leave(KErrAccessDenied);
 
  1263 		User::Leave(KErrAccessDenied);
 
  1347 		}
 
  1264 		}
FCL/sf/os/kernelhwsrv