Symaptic: os/kernelhwsrv/userlibandfileserver/fileserver/sfile/sf

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

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // f32\sfile\sf_debug.cpp

    15 //

    16 //

    18 #include "sf_std.h"

    19 #include <f32dbg.h>

    20 #include "f32image.h"

    21 #include <F32plugin.h>

    22 #include "sf_file_cache.h"

    25 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)

    27 //

    28 // ONLY INCLUDED IN DEBUG BUILDS

    29 //

    31 void PrintHeapSize(const TDesC& aMessage)

    32 //

    33 // Display the total memory available

    34 //

    35 	{

    37 	TInt biggest;

    38 	TInt heapSize = User::Allocator().Available(biggest);

    39 	RDebug::Print(_L("%S size=0x%x largest cell=0x%x"),&aMessage,heapSize,biggest);

    40 	}

    42 static void SetAllocFailure(const RMessage2* aMessage)

    43 //

    44 // Set alloc failure after allocCount allocations

    45 //

    46 	{

    48 	UserHeapAllocFailCount=aMessage->Int1();

    49 	KernHeapAllocFailCount=UserHeapAllocFailCount;

    50 	if (UserHeapAllocFailCount>=0)

    51 		{

    52 		__UHEAP_FAILNEXT(UserHeapAllocFailCount);

    53 		__KHEAP_FAILNEXT(KernHeapAllocFailCount);

    54 		}

    55 	else

    56 		{

    57 		__UHEAP_RESET;

    58 		__KHEAP_RESET;

    59 		}

    60 	}

    62 TInt FsDebugFunction(CFsRequest* aRequest)

    63 //

    64 // SetAllocFailure - Set alloc failure after allocCount allocations

    65 // SetErrorCondition - Set simulated error failure

    66 // SetDebugRegister - Trigger tracing output

    67 // DebugNotify - Request notification of a file server event - .FSY specific

    68 //

    69 	{

    71 	TInt r=KErrNone;

    72 	const RMessage2* message=&(aRequest->Message());

    73 	switch (message->Int0())

    74 		{

    75 	case EFsSetAllocFailure:

    76 		SetAllocFailure(message);

    77 		break;

    78 	case EFsSetErrorCondition:

    79 		ErrorCondition=message->Int1();

    80 		ErrorCount=message->Int2();

    81 		break;

    82 	case EFsSetDebugRegister:

    83 		DebugReg=message->Int1();

    84 		break;

    85 	case EFsDebugNotify:

    86 		{

    87 		TUint notifyType=(aRequest->Message().Int2())&KDebugNotifyMask;

    88 		if (notifyType)

    89 			{

    90 			CDebugChangeInfo* info=new CDebugChangeInfo;

    91 			if(!info)

    92 				return(KErrNoMemory);

    93 			const RMessage2& m=aRequest->Message();

    94 			info->Initialise(notifyType,(TRequestStatus*)m.Ptr3(),m,aRequest->Session());

    95 			r=FsNotify::AddDebug(info);

    96 			if(r!=KErrNone)

    97 				delete(info);

    98 			else

    99 				aRequest->SetCompleted(EFalse);

   100 			}

   101 		else

   102 			r=KErrArgument;

   103 		break;

   104 		}

   105 	default:

   106 		break;

   107 		};

   108 	return(r);

   109 	}

   111 TBool SimulateError(const RMessage2* aMessage)

   112 //

   113 // Return an error message if ErrorCount<=0

   114 //

   115 	{

   116 	TInt function = aMessage->Function() & KIpcFunctionMask;

   118 	if (ErrorCondition!=KErrNone &&

   119 		(

   120 		function!=EFsDebugFunction || aMessage->Int0()!=EFsSetErrorCondition) &&

   121 		function!=EFsNotifyChangeCancel &&

   122 		function!=EFsNotifyChangeCancelEx &&

   123 		function!=EFsNotifyDiskSpaceCancel &&

   124 		function!=EFsFormatSubClose &&

   125 		function!=EFsDirSubClose  &&

   126 		function!=EFsFileSubClose &&

   127 		function!=EFsRawSubClose &&

   128 		function!=EFsUnclamp &&

   130         //-- this operation must not fail. It can only fail if the client's thread has died.

   131         //-- in this case whole session will be cleaned up.

   132 		function!=EFsFileAdopt

   133         )

   134 		{

   135 		if (ErrorCount<=0)

   136 			return(ETrue);

   137 		ErrorCount--;

   138 		}

   139 	return(EFalse);

   140 	}

   143 TPtrC GetFunctionName(TInt aFunction)

   144 //

   145 // Print number of alloc fails to complete a given function

   146 //

   147 	{

   149 	switch (aFunction)

   150 		{

   151 	case EFsDebugFunction: return _L("EFsDebugFunction");

   152 	case EFsAddFileSystem: return _L("EFsAddFileSystem");

   153 	case EFsRemoveFileSystem: return _L("EFsRemoveFileSystem");

   154 	case EFsMountFileSystem: return _L("EFsMountFileSystem");

   155 	case EFsNotifyChange: return _L("EFsNotifyChange");

   156 	case EFsNotifyChangeCancel: return _L("EFsNotifyChangeCancel");

   157 	case EFsDriveList: return _L("EFsDriveList");

   158 	case EFsDrive: return _L("EFsDrive");

   159 	case EFsVolume: return _L("EFsVolume");

   160 	case EFsSetVolume: return _L("EFsSetVolume");

   161 	case EFsSubst: return _L("EFsSubst");

   162 	case EFsSetSubst: return _L("EFsSetSubst");

   163 	case EFsRealName: return _L("EFsRealName");

   164 	case EFsDefaultPath: return _L("EFsDefaultPath");

   165 	case EFsSetDefaultPath: return _L("EFsSetDefaultPath");

   166 	case EFsSessionPath: return _L("EFsSessionPath");

   167 	case EFsSetSessionPath: return _L("EFsSetSessionPath");

   168 	case EFsMkDir: return _L("EFsMkDir");

   169 	case EFsRmDir: return _L("EFsRmDir");

   170 	case EFsParse: return _L("EFsParse");

   171 	case EFsDelete: return _L("EFsDelete");

   172 	case EFsRename: return _L("EFsRename");

   173 	case EFsReplace: return _L("EFsReplace");

   174 	case EFsEntry: return _L("EFsEntry");

   175 	case EFsSetEntry: return _L("EFsSetEntry");

   176 	case EFsGetDriveName: return _L("EFsGetDriveName");

   177 	case EFsSetDriveName: return _L("EFsSetDriveName");

   178 	case EFsFormatSubClose: return _L("EFsFormatSubClose");

   179 	case EFsDirSubClose: return _L("EFsDirSubClose");

   180 	case EFsFileSubClose: return _L("EFsFileSubClose");

   181 	case EFsRawSubClose: return _L("EFsRawSubClose");

   182 	case EFsFileOpen: return _L("EFsFileOpen");

   183 	case EFsFileCreate: return _L("EFsFileCreate");

   184 	case EFsFileReplace: return _L("EFsFileReplace");

   185 	case EFsFileTemp: return _L("EFsFileTemp");

   186 	case EFsFileRead: return _L("EFsFileRead");

   187 	case EFsFileWrite: return _L("EFsFileWrite");

   188 	case EFsFileLock: return _L("EFsFileLock");

   189 	case EFsFileUnLock: return _L("EFsFileUnLock");

   190 	case EFsFileSeek: return _L("EFsFileSeek");

   191 	case EFsFileFlush: return _L("EFsFileFlush");

   192 	case EFsFileSize: return _L("EFsFileSize");

   193 	case EFsFileSetSize: return _L("EFsFileSetSize");

   194 	case EFsFileAtt: return _L("EFsFileAtt");

   195 	case EFsFileSetAtt: return _L("EFsFileSetAtt");

   196 	case EFsFileModified: return _L("EFsFileModified");

   197 	case EFsFileSetModified: return _L("EFsFileSetModified");

   198 	case EFsFileSet: return _L("EFsFileSet");

   199 	case EFsFileChangeMode: return _L("EFsFileChangeMode");

   200 	case EFsFileRename: return _L("EFsFileRename");

   201 	case EFsDirOpen: return _L("EFsDirOpen");

   202 	case EFsDirReadOne: return _L("EFsDirReadOne");

   203 	case EFsDirReadPacked: return _L("EFsDirReadPacked");

   204 	case EFsFormatOpen: return _L("EFsFormatOpen");

   205 	case EFsFormatNext: return _L("EFsFormatNext");

   206 	case EFsRawDiskOpen: return _L("EFsRawDiskOpen");

   207 	case EFsRawDiskRead: return _L("EFsRawDiskRead");

   208 	case EFsRawDiskWrite: return _L("EFsRawDiskWrite");

   209 	case EFsResourceCountMarkStart: return _L("EFsResourceCountMarkStart");

   210 	case EFsResourceCountMarkEnd: return _L("EFsResourceCountMarkEnd");

   211 	case EFsResourceCount: return _L("EFsResourceCount");

   212 	case EFsCheckDisk: return _L("EFsCheckDisk");

   213 	case EFsGetShortName: return _L("EFsGetShortName");

   214 	case EFsGetLongName: return _L("EFsGetLongName");

   215 	case EFsIsFileOpen: return _L("EFsIsFileOpen");

   216 	case EFsListOpenFiles: return _L("EFsListOpenFiles");

   217 	case EFsSetNotifyUser: return _L("EFsSetNotifyUser");

   218 	case EFsIsFileInRom: return _L("EFsIsFileInRom");

   219 	case EFsGetNotifyUser: return _L("EFsGetNotifyUser");

   220 	case EFsIsValidName: return _L("EFsIsValidName");

   221 	case EFsReadFileSection: return _L("EFsReadFileSection");

   222 	case EFsNotifyChangeEx: return _L("EFsNotifyChangeEx");

   223 	case EFsNotifyChangeCancelEx: return _L("EFsNotifyChangeCancelEx");

   224 	case EFsDismountFileSystem: return _L("EFsDismountFileSystem");

   225 	case EFsFileSystemName: return _L("EFsFileSystemName");

   226 	case EFsScanDrive: return _L("EFsScanDrive");

   227 	case EFsControlIo: return _L("EFsControlIo");

   228 	case EFsLockDrive: return _L("EFsLockDrive");

   229 	case EFsUnlockDrive: return _L("EFsUnlockDrive");

   230 	case EFsClearPassword: return _L("EFsClearPassword");

   231 	case EFsNotifyDiskSpace: return _L("EFsNotifyDiskSpace");

   232 	case EFsNotifyDiskSpaceCancel: return _L("EFsNotifyDiskSpaceCancel");

   233 	case EFsMountFileSystemScan: return _L("EFsMountFileSystemScan");

   234 	case EFsSessionToPrivate: return _L("EFsSessionToPrivate");

   235 	case EFsPrivatePath: return _L("EFsPrivatePath");

   236 	case EFsCreatePrivatePath: return _L("EFsCreatePrivatePath");

   237 	case EFsFileDrive: return _L("EFsFileDrive");

   238 	case EFsRemountDrive: return _L("EFsRemountDrive");

   239 	case EFsAddExtension: return _L("EFsAddExtension");

   240 	case EFsMountExtension: return _L("EFsMountExtension");

   241 	case EFsDismountExtension: return _L("EFsDismountExtension");

   242 	case EFsRemoveExtension: return _L("EFsRemoveExtension");

   243 	case EFsExtensionName: return _L("EFsExtensionName");

   244 	case EFsStartupInitComplete: return _L("EFsStartupInitComplete");

   245 	case EFsSetLocalDriveMapping: return _L("EFsSetLocalDriveMapping");

   246 	case EFsFileDuplicate: return _L("EFsFileDuplicate");

   247 	case EFsFileAdopt: return _L("EFsFileAdopt");

   248 	case EFsFinaliseDrive: return _L("EFsFinaliseDrive");

   249 	case EFsSwapFileSystem: return _L("EFsSwapFileSystem");

   250 	case EFsErasePassword: return _L("EFsErasePassword");

   251 	case EFsReserveDriveSpace: return _L("EFsReserveDriveSpace");

   252 	case EFsGetReserveAccess: return _L("EFsGetReserveAccess");

   253 	case EFsReleaseReserveAccess: return _L("EFsReleaseReserveAccess");

   254 	case EFsFileName: return _L("EFsFileName");

   255     case EFsGetMediaSerialNumber: return _L("EFsGetMediaSerialNumber");

   256 	case EFsFileFullName: return _L("EFsFileFullName");

   257 	case EFsAddPlugin: return _L("EFsAddPlugin");

   258 	case EFsRemovePlugin: return _L("EFsRemovePlugin");

   259 	case EFsMountPlugin: return _L("EFsMountPlugin");

   260 	case EFsDismountPlugin: return _L("EFsDismountPlugin");

   261 	case EFsPluginName: return _L("EFsPluginName");

   262 	case EFsPluginOpen: return _L("EFsPluginOpen");

   263 	case EFsPluginSubClose: return _L("EFsPluginSubClose");

   264 	case EFsPluginDoRequest: return _L("EFsPluginDoRequest");

   265 	case EFsPluginDoControl: return _L("EFsPluginDoControl");

   266 	case EFsPluginDoCancel: return _L("EFsPluginDoCancel");

   267 	case EFsNotifyDismount: return _L("EFsNotifyDismount");

   268 	case EFsNotifyDismountCancel: return _L("EFsNotifyDismountCancel");

   269 	case EFsAllowDismount: return _L("EFsAllowDismount");

   270 	case EFsSetStartupConfiguration: return _L("EFsSetStartupConfiguration");

   271 	case EFsFileReadCancel: return _L("EFsFileReadCancel");

   272 	case EFsAddCompositeMount: return _L("EFsAddCompositeMount");

   273 	case EFsSetSessionFlags: return _L("EFsSetSessionFlags");

   274 	case EFsSetSystemDrive: return _L("EFsSetSystemDrive");

   275 	case EFsBlockMap: return _L("EFsBlockMap");

   276 	case EFsUnclamp: return _L("EFsUnclamp");

   277 	case EFsFileClamp: return _L("EFsFileClamp");

   278 	case EFsQueryVolumeInfoExt: return _L("EFsQueryVolumeInfoExt");

   279 	case EFsInitialisePropertiesFile: return _L("EFsInitialisePropertiesFile");

   280 	case EFsFileWriteDirty: return _L("EFsFileWriteDirty");

   281 	case EFsSynchroniseDriveThread: return _L("EFsSynchroniseDriveThread");

   282 	case EFsAddProxyDrive: return _L("EFsAddProxyDrive");

   283 	case EFsRemoveProxyDrive: return _L("EFsRemoveProxyDrive");

   284 	case EFsMountProxyDrive: return _L("EFsMountProxyDrive");

   285 	case EFsDismountProxyDrive:  return _L("EFsDismountProxyDrive");

   286 	case EFsNotificationAdd : return _L("EFsNotificationAdd");

   287 	case EFsNotificationBuffer : return _L("EFsNotificationBuffer");

   288 	case EFsNotificationCancel : return _L("EFsNotificationCancel");

   289 	case EFsNotificationOpen : return _L("EFsNotificationOpen");

   290 	case EFsNotificationRemove : return _L("EFsNotificationRemove");

   291 	case EFsNotificationRequest : return _L("EFsNotificationRequest");

   292 	case EFsNotificationSubClose : return _L("EFsNotificationSubClose");

   293 	case EFsLoadCodePage: return _L("EFsLoadCodePage");

   294 	default:

   295 		return _L("Error unknown function");

   296 		}

   297 	}

   300 void PrintStartUpReason(TMachineStartupType aReason)

   301 //

   302 // Print the reason the machine is booting up

   303 //

   304 	{

   306 	TBuf<64> nameBuf;

   307 	switch (aReason)

   308 		{

   309 	case EStartupCold: nameBuf=_L("EStartupCold"); break;

   310 	case EStartupColdReset: nameBuf=_L("EStartupColdReset"); break;

   311 	case EStartupNewOs: nameBuf=_L("EStartupNewOs"); break;

   312 	case EStartupPowerFail: nameBuf=_L("StartupPowerFail"); break;

   313 	case EStartupWarmReset: nameBuf=_L("EStartupWarmReset"); break;

   314 	case EStartupKernelFault: nameBuf=_L("EStartupKernelFault"); break;

   315 	case EStartupSafeReset: nameBuf=_L("EStartupSafeReset"); break;

   316 	default:

   317 		nameBuf=_L("Error unknown startup type");

   318 		}

   319 	__PRINT1(_L("Machine startup - %S"),&nameBuf);

   320 	};

   322 LOCAL_C void AllocPrint(TInt aFunction)

   323 //

   324 // Print number of alloc fails to complete a given function

   325 //

   326 	{

   327 	if (UserHeapAllocFailCount || KernHeapAllocFailCount)

   328 		{

   329 		TPtrC funcName=GetFunctionName(aFunction);

   330 			{

   331 			__PRINTALLOC(_L("Function %S UserAllocs %d KernAllocs %d"),&funcName,UserHeapAllocFailCount,KernHeapAllocFailCount);

   332 			}

   333 		}

   334 	}

   336 void SimulateAllocFailure(TInt aFunctionReturnValue,TInt aFunction)

   337 //

   338 // Simulate alloc failure

   339 //

   340 	{

   343 	if (UserHeapAllocFailCount>=0 && (aFunctionReturnValue==KErrDiskFull || aFunctionReturnValue==KErrNoMemory))

   344 		{

   345 		if (KernHeapAllocFailCount<20)

   346 			{

   347 			__KHEAP_FAILNEXT(++KernHeapAllocFailCount);

   348 			__UHEAP_FAILNEXT(UserHeapAllocFailCount);

   349 			}

   350 		else

   351 			{

   352 			KernHeapAllocFailCount=0;

   353 			__UHEAP_FAILNEXT(++UserHeapAllocFailCount);

   354 			__KHEAP_FAILNEXT(KernHeapAllocFailCount);

   355 			}

   356 		if (UserHeapAllocFailCount<100)

   357 			return;

   358 		}

   359 	if (UserHeapAllocFailCount>=0)

   360 		{

   361 		AllocPrint(aFunction);

   362 		UserHeapAllocFailCount=0;

   363 		KernHeapAllocFailCount=0;

   364 		__UHEAP_FAILNEXT(UserHeapAllocFailCount);

   365 		__KHEAP_FAILNEXT(KernHeapAllocFailCount);

   366 		}

   367 	}

   369 #else

   370 TInt FsDebugFunction(CFsRequest* /*aRequest*/)

   371 //

   372 // Not in the release build

   373 //

   374 	{

   375 	return KErrNotSupported;

   376 	}

   377 #endif

   379 TInt TFsDebugFunc::DoRequestL(CFsRequest* aRequest)

   380 //

   381 // Not in the release build

   382 //

   383 	{

   384 	return FsDebugFunction(aRequest);

   385 	}

   387 TInt TFsDebugFunc::Initialise(CFsRequest* /*aRequest*/)

   388 //

   389 // Not in the release build

   390 //

   391 	{

   392 	return KErrNone;

   393 	}

   395 TInt TFsControlIo::DoRequestL(CFsRequest* aRequest)

   396 //

   397 // General purpose test interface - .FSY specific.

   398 // Not in the release build

   399 //

   400 	{

   401 	TInt command=aRequest->Message().Int1();

   402 	TAny* param1=(TAny*)aRequest->Message().Ptr2();

   403 	TAny* param2=(TAny*)aRequest->Message().Ptr3();

   406 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)

   407 	switch(command)

   408 		{	//These are non-drive commands

   409 		case KControlIoGetCorruptLogRecord:

   410 			{

   411 			// number of the log record to be retrieved (1-based)

   412 			TInt logRecNum=(TInt)param2;

   413 			TFsDebugCorruptLogRecordBuf logBuf;

   414 			TInt r=TCorruptLogRec::GetLogRecord(logBuf,logRecNum);

   415 			if(r!=KErrNone)

   416 				return r;

   417 			r=aRequest->Write(2,logBuf,0);

   418 			return r;

   419 			}

   420 		case KControlIoGetNumberOfCorruptLogRecords:

   421 			{

   422 			TPtrC8 ptrHits((TUint8*)&gNumberOfCorruptHits,sizeof(gNumberOfCorruptHits));

   423 			TInt r=aRequest->Write(2,ptrHits,0);

   425 			return r;

   426 			}

   427 		case KControlIoGetCorruptListFile:

   428 			{

   429 			// Get name of file that contains the filenames nominated as "corrupt"

   430 			TBuf8<KMaxFileName> fileName8;

   431 			if(gCorruptFileNamesListFile)

   432 				{

   433 				fileName8.Copy(*gCorruptFileNamesListFile);

   434 				}

   435 			else

   436 				{

   437 				fileName8.SetLength(0);

   438 				}

   439 			TInt r=aRequest->Write(2,fileName8,0);

   440 			return r;

   441 			}

   442 		case KControlIoCorruptLogRecordReset:

   443 			{

   444 			TCorruptLogRec::DestroyList();

   445 			TCorruptNameRec::ResetListConsumed();

   446 			return KErrNone;

   447 			}

   448 		case KControlIoCacheCount:

   449 			{

   450 			TIOCacheValues cacheValues;

   451 			cacheValues.iCloseCount= RequestAllocator::CloseCount();

   452 			cacheValues.iFreeCount= RequestAllocator::FreeCount();

   453 			cacheValues.iAllocated=	RequestAllocator::AllocatedCount();

   454 			cacheValues.iTotalCount= RequestAllocator::TotalCount();

   455 			TPckgBuf<TIOCacheValues> pkgBuf(cacheValues);

   457 			// ensure we only write what the client buffer can hold -

   458 			// this allows TIOCacheValues to increase in size without breaking BC

   459 			pkgBuf.SetLength(Min(pkgBuf.MaxLength(), aRequest->Message().GetDesMaxLengthL(2)));

   461 			TInt r=aRequest->Write(2,pkgBuf);

   462 			return r;

   463 			}

   464 		case KControlIoGetLocalDriveNumber:

   465 			{

   466 			return DriveNumberToLocalDriveNumber(aRequest->Drive()->DriveNumber());

   467 			}

   468 		case KControlIoCancelDeferredDismount:

   469 			{

   470 			// Cancel and clear deferred dismount information

   471 			aRequest->Drive()->ClearDeferredDismount();

   472 			return KErrNone;

   473 			}

   474 		case KControlIoFileCacheStats:

   475 			{

   476 			CCacheManager* manager = CCacheManagerFactory::CacheManager();

   477 			if (manager == NULL)

   478 				return KErrNotSupported;

   480 			TFileCacheStats& stats = manager->Stats();

   482 			TPckgBuf<TFileCacheStats> pkgBuf(stats);

   483 			TInt r=aRequest->Write(2,pkgBuf);

   484 			return r;

   485 			}

   486 		case KControlIoFileCacheConfig:

   487 			{

   488 			TInt driveNumber = aRequest->Drive()->DriveNumber();

   490 			TFileCacheSettings::TFileCacheConfig* driveConfig = NULL;

   491 			TInt r = TFileCacheSettings::GetFileCacheConfig(driveNumber, driveConfig);

   492 			if (( r != KErrNone) || (driveConfig == NULL))

   493 				return KErrNotSupported;

   495 			TFileCacheConfig config;

   496 			config.iDrive = driveConfig->iDrive;

   497 			config.iFlags = driveConfig->iFlags;

   498 			config.iFileCacheReadAsync = driveConfig->iFileCacheReadAsync;

   499 			config.iFairSchedulingLen = driveConfig->iFairSchedulingLen;

   500 			config.iCacheSize = driveConfig->iCacheSize;

   501 			config.iMaxReadAheadLen = driveConfig->iMaxReadAheadLen;

   502 			config.iClosedFileKeepAliveTime = driveConfig->iClosedFileKeepAliveTime;

   503 			config.iDirtyDataFlushTime = driveConfig->iDirtyDataFlushTime;

   505 			TPckgBuf<TFileCacheConfig> pkgBuf(config);

   506 			r=aRequest->Write(2,pkgBuf);

   507 			return r;

   508 			}

   509 		case KControlIoFileCacheFlagsWrite:

   510 			{

   511 			TInt drive = aRequest->Message().Int0();

   513 			TPckgBuf<TFileCacheFlags> driveFlagsPkg;

   514 			TFileCacheFlags& driveFlags = driveFlagsPkg();

   516 			TInt r = aRequest->Read(2, driveFlagsPkg);

   517 			if (r != KErrNone)

   518 				return r;

   520 			__CACHE_PRINT2(_L("CACHE: TFileCacheFlags %x on drive %d"), driveFlags, drive);

   521 			TFileCacheSettings::SetFlags(drive, driveFlags);

   523 			return r;

   524 			}

   525 		case KControlIoFlushClosedFiles:

   526 			{

   527 			TClosedFileUtils::Remove();

   528 			return KErrNone;

   529 			}

   530 		case KControlIoSimulateLockFailureMode:

   531 			{

   532 			TPckgBuf<TBool> enabledPkg;

   533 			TInt r = aRequest->Read(2, enabledPkg);

   534 			if (r != KErrNone)

   535 				return r;

   537 			CCacheManager* manager = CCacheManagerFactory::CacheManager();

   538 			if (manager == NULL)

   539 				return KErrNotSupported;

   540 			manager->SimulateLockFailureMode(enabledPkg());

   541 			return KErrNone;

   542 			}

   543 		case KControlIoSimulateFileCacheWriteFailure:

   544 			{

   545 			CCacheManager* manager = CCacheManagerFactory::CacheManager();

   546 			if (manager == NULL)

   547 				return KErrNotSupported;

   548 			manager->SimulateWriteFailure();

   549 			return KErrNone;

   550 			}

   551 		case KControlIoFileCacheDump:

   552 			{

   553 			CCacheManager* manager = CCacheManagerFactory::CacheManager();

   554 			if (manager == NULL)

   555 				return KErrNotSupported;

   556 			manager->DumpCache();

   557 			return KErrNone;

   558 			}

   559 		case KControlIoAllocateMaxSegments:

   560 			{

   561 			TPckgBuf<TBool> enabledPkg;

   562 			TInt r = aRequest->Read(2, enabledPkg);

   563 			if (r != KErrNone)

   564 				return r;

   566 			CCacheManager* manager = CCacheManagerFactory::CacheManager();

   567 			if (manager == NULL)

   568 				return KErrNotSupported;

   569 			manager->AllocateMaxSegments(enabledPkg());

   570 			return KErrNone;

   571 			}

   572 		case KControlIoDisableFatUtilityFunctions:

   573 			{

   574 			EnableFatUtilityFunctions = EFalse;

   575 			return KErrNone;

   576 			}

   577 		case KControlIoEnableFatUtilityFunctions:

   578 			{

   579 			EnableFatUtilityFunctions = ETrue;

   580 			return KErrNone;

   581 			}

   582 		}

   583 #endif

   585 	return(aRequest->Drive()->ControlIO(aRequest->Message(),command,param1,param2));

   586 	}

   588 TInt TFsControlIo::Initialise(CFsRequest* aRequest)

   589 //

   590 // General purpose test interface - .FSY specific.

   591 // Not in the release build

   592 //

   593 	{

   594 	TInt driveNumber=aRequest->Message().Int0();

   595 	if(driveNumber<0||driveNumber>=KMaxDrives)

   596 		return(KErrArgument);

   597 	ValidateDriveDoSubst(driveNumber,aRequest);

   598 	return KErrNone;

   599 	}

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200 (2012-06-15)
changeset 0	bde4ae8d615e
permissions	-rw-r--r--