1 // Copyright (c) 1998-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\estart\estart.cpp

    15 // Generic startup code run by the fileserver on boot

    16 // 

    17 //

    18 

    19 #include <e32std.h>

    20 #include <e32std_private.h>

    21 #include <e32def_private.h>

    22 #include <hal.h>

    23 #include <f32file.h>

    24 #include <f32file_private.h>

    25 #include <f32fsys.h>

    26 #ifndef SYMBIAN_EXCLUDE_ESTART_DOMAIN_MANAGER

    27 #include <domainmanager.h>

    28 #endif

    29 #include <e32uid.h>

    30 #include <e32property.h>

    31 

    32 //#ifndef _DEBUG

    33 //	#define _DEBUG

    34 //#endif

    35 //#define TRACING_ON

    36 

    37 #include "estart.h"

    38 #include <u32exec.h>

    39 

    40 //-- define this macro in order to have system start time measurement (SYSSTATEMGR.EXE process life time)

    41 //#define SYMBIAN_ESTART_OUTPUT_BOOT_TIME

    42 

    43 

    44 TInt LoadCodePageDll();

    45 /** Maximum Codepage Dll name length. */

    46 const TInt KMaxCodepageDllName=16;

    47 

    48 

    49 #ifdef _DEBUG

    50 TBool DebugTraceEnabled()

    51 	{

    52 #ifdef TRACING_ON

    53 	return ETrue;

    54 #else

    55 	return UserSvr::DebugMask() & 2;

    56 #endif

    57 	}

    58 #endif

    59 

    60 _LIT(KEStartPanicCatagory, "ESTART");

    61 

    62 enum TEStartPanic

    63     {

    64     ELitNoDM = 1,                           // No Domain Manager

    65     ELitDMInitFail,                         // Domain Manager init fail

    66     ELitHALFail,                            // HAL init fail

    67     ELitConnectFsFail1,                     // Connect fs 1 fail

    68     ELitInitLocalPwStoreFail,               // Init PwStore fail

    69     ELitLocaleInitialisationFail,           // Initialisation of locale properties failed

    70     ELitFSInitDriveInfoFail,                // FS Init DriveInfo fail

    71     ELitCreateTrapHandlerFail,              // Create trap handler fail

    72     ELitLoadSysLddsFail,                    // Load sys ldds fail

    73     ELitLocalDriveMappingFail,              // Local drive mapping fail

    74     ELitDriveMappingFileFail,               // Drive mapping file not found

    75     ELitSwapMappingFailArrayInconsistent,   // Swap mappings fail - array inconsistent

    76     ELitFsSwapMappingFail,                  // Swap mappings fail - Fs request failed

    77     EPropertyError,                         // RProperty return error

    78     ECompMountFsFail,                       // Failed comp fs mount

    79     EFsNameFail,                            // File system name on Z: failed

    80     ELitNoWS,                               // No WSERV

    81     EStartupModeFail,                       // Get startup mode failed

    82     ESysAgentFail,                          // Fail to launch system agent

    83     ESetSystemDriveFail                     // Fail to set System Drive

    84     };

    85 

    86 inline void Panic(TEStartPanic aPanic, TInt aReason)

    87     {

    88     TBuf<10> panic(KEStartPanicCatagory);

    89     panic.AppendFormat(_L("_%d"), aPanic);

    90     User::Panic(panic, aReason);

    91     }

    92 

    93 _LIT(KRofs,"erofs.fsy");

    94 _LIT(KCompfs,"ecomp.fsy");

    95 _LIT(KEcomp,"ECOMP");

    96 _LIT(KServerPathSysBin, "0:\\Sys\\Bin\\");

    97 _LIT(KSystemAgentName, "z:\\sys\\bin\\SysAgt2Svr.exe");

    98 _LIT(KLitLocaleData,"?:\\System\\Data\\LOCALE.D");

    99 _LIT(KLocaleDllNameBase, "ELOCL");

   100 _LIT(KLocalDriveMappingFile,"Z:\\SYS\\DATA\\ESTART.TXT");

   101 _LIT(KWindowServerRootName1,"EWSRV.EXE");

   102 _LIT(KSystemStarterName, "z:\\sys\\bin\\SYSSTART.EXE");

   103 _LIT(KSystemStateManager, "z:\\sys\\bin\\SYSSTATEMGR.EXE");

   104 

   105 //const TInt KPatchLddUidValue=0x100000cc;	// patch ldds should specify this as their third uid

   106 

   107 GLDEF_D TBool gMountRofsAlone=ETrue;

   108 GLDEF_D TBool gMountComposite=EFalse;

   109 

   110 enum TCompositeMountSate

   111 	{

   112 	ENoMounts,

   113 	EHasMounts,

   114 	ESwapped

   115 	};

   116 	

   117 LOCAL_D TCompositeMountSate gCompositeMountState=ENoMounts;

   118 

   119 #if !defined(AUTODETECT_DISABLE)

   120 LOCAL_D TInt gNCompositeMounts=0;

   121 #endif

   122 

   123 #if defined(__EPOC32__) && defined(__X86__)

   124 LOCAL_D TInt gNFloppies=0;

   125 #endif		

   126 

   127 /**

   128 ASCII text file reader constructor

   129 */

   130 TText8FileReader::TText8FileReader()

   131 	{

   132 	

   133 	iBufPos=-1;

   134 	iFileDataBuf=NULL;

   135 	iFileSize=0;	

   136 	}

   137 

   138 /**

   139 ASCII text file reader desctructor

   140 */

   141 TText8FileReader::~TText8FileReader()

   142 	{

   143 	

   144 	delete[] iFileDataBuf;

   145 	}	

   146 

   147 /**	

   148 Supply an ASCII text file for the file reader. 

   149 This function reads the entire contents of this file into a buffer, converting to

   150 unicode / folding each character. Subsequent parsing of the file data is all done from this

   151 buffer.

   152 @param aFile The file to be read. Must already be opened for read access in EFileStreamText mode.  

   153 @return	KErrNone if no error.

   154 */

   155 TInt TText8FileReader::Set(RFile& aFile)

   156 	{

   157 	

   158 	iFile=aFile;

   159 	iBuf.Zero();

   160 	iBufPos=0;

   161 	

   162 	// Read the size of the file

   163 	TInt r=iFile.Size(iFileSize);

   164 	if (r!=KErrNone || !iFileSize)

   165 		return(KErrGeneral);

   166 	

   167 	// Allocate a buffer to read in the file

   168 	iFileDataBuf=new TText[iFileSize+1];	// +1 in case need to NULL terminate the end of the last string

   169 	if (iFileDataBuf==NULL)

   170 		return(KErrNoMemory);

   171 

   172 	// Read the entire contents of the file into the buffer

   173 	TPtr fdata(NULL,0);	

   174 	TInt pos=0;

   175 	r=iFile.Seek(ESeekStart,pos);

   176 	while (pos<iFileSize)

   177 		{

   178 		if ((r=iFile.Read(iBuf))!=KErrNone)

   179 			return(r);

   180 		fdata.Set((iFileDataBuf+pos),0,iBuf.Length());	

   181 		fdata.Copy(iBuf);

   182 		fdata.Fold();

   183 		pos+=iBuf.Length();	

   184 		}

   185 	return(KErrNone);	

   186 	}

   187 	

   188 /**

   189 Return the next record from the text file.

   190 @param aPtr A TPtr which is setup with the address and length of the next record, referencing

   191 the data in the reader's buffer.

   192 @return	KErrNone if a record is successfully loaded into the buffer, KErrEof if the end of the

   193 file is encountered, KErrGeneral if a file hasn't been set.

   194 */

   195 TInt TText8FileReader::Read(TPtr& aPtr)

   196 	{

   197 	

   198 	// Check that Set() has been called.

   199 	if (iBufPos<0)

   200 		return(KErrGeneral);

   201 		

   202 	// Check if we have run into the end of the file	

   203 	TInt bufRemainder=(iFileSize-iBufPos);

   204 	if (!bufRemainder)

   205 		return(KErrEof);

   206 		

   207 	// Setup the descriptor passed with the next record - don't include the record terminator

   208 	// The line terminators are CR + LF for DOS

   209 	// whereas only LF for Unix line endings

   210 	aPtr.Set((iFileDataBuf+iBufPos),bufRemainder,bufRemainder);

   211 	TInt len=aPtr.Locate('\n');

   212 	if (len != KErrNotFound)

   213 		{

   214 		iBufPos += len;

   215 		// Check for DOS line ending to support both DOS and Unix formats

   216 		if ((len != 0) && (iFileDataBuf[iBufPos-1] == '\r'))

   217 			{

   218 			len--;

   219 			}

   220 		aPtr.SetLength(len);

   221 		}

   222 	else

   223 		iBufPos=iFileSize;

   224 	

   225 	// Point iBufPos to the next non-empty line

   226 	while (iBufPos<iFileSize && (iFileDataBuf[iBufPos]=='\n' || iFileDataBuf[iBufPos]=='\r'))

   227 		iBufPos++;

   228 	return(KErrNone);

   229 	}

   230 

   231 const TInt DefaultLocalDrives[KMaxLocalDrives]=

   232 			{

   233 			EDriveC,               	//0

   234 			EDriveD,                //1

   235 			EDriveE,                //2

   236 			EDriveF,                //3

   237 			EDriveG,                //4

   238 			EDriveH,                //5

   239 			EDriveI,                //6

   240 			EDriveJ,                //7

   241 			EDriveK,				//8

   242 			EDriveL,				//9

   243 			EDriveM,				//10

   244 			EDriveN,				//11

   245 			EDriveO,				//12

   246 			EDriveP,				//13

   247 			EDriveQ,				//14

   248 			EDriveR					//15 

   249 			};

   250 /**

   251 Return the default drive letter for the specified local drive.

   252 To alter the default mapping scheme on auto-configuration, override this function.

   253 

   254 @param aLocalDrive The number of the local drive (0-15).

   255 

   256 @return	The default drive number associated with this local drive.

   257 */			

   258 TInt TFSStartup::DefaultLocalDrive(TInt aLocalDrive)

   259 	{

   260 	

   261 	return(DefaultLocalDrives[aLocalDrive]);

   262 	}

   263 	

   264 //typedef TInt TLocalDriveList[KMaxLocalDrives];

   265 /**

   266 Write the local drive mapping data to the file server. If there is no potential of a drive swap then also commit it.

   267 Once committed, the setting cannot be changed.

   268 

   269 @panic ESTART_10 Error_Code; If unable to set local drive mapping in the file server.

   270 				 Error_Code is the error code returned by RFs::SetLocalDriveMapping()	

   271 

   272 */

   273 void TFSStartup::SetFServLocalDriveMapping()

   274 	{

   275 	

   276 	DEBUGPRINT("SetFServLocalDriveMapping");

   277 	TLocalDriveMappingInfoBuf mBuf;

   278 	TLocalDriveMappingInfo& ldmi=mBuf();

   279 	Mem::Copy(&ldmi.iDriveMapping[0],&iLocalDriveList[0],(KMaxLocalDrives*sizeof(TInt)));

   280 	

   281 	// Can't set the mapping yet - if there is the potential of a drive swap .

   282 	ldmi.iOperation = (iDriveSwapCount) ? TLocalDriveMappingInfo::EWriteMappingsNoSet : TLocalDriveMappingInfo::EWriteMappingsAndSet;

   283 	

   284 	TInt r=iFs.SetLocalDriveMapping(mBuf);

   285     __ASSERT_ALWAYS(r==KErrNone,Panic(ELitLocalDriveMappingFail, r));

   286 	}

   287 

   288 /**

   289 Swap and commit the file server's local drive mapping data. Change the local drive mapping info already set with the file server.

   290 

   291 @param  aFirstDrive		First Drive number to be swapped.

   292 @param  aSecondDrive	Second Drive number to be swapped.

   293 

   294 @panic  ESTART_13 Error_Code; if unable to set the local drive mapping to file server.

   295 				  Error_Code is the error code returned by RFs::SetLocalDriveMapping()	

   296 */

   297 void TFSStartup::SwapFServLocalDriveMapping(TInt aFirstDrive,TInt aSecondDrive)

   298 	{

   299 	

   300 	DEBUGPRINT("SwapFServLocalDriveMapping");

   301 	TLocalDriveMappingInfoBuf mBuf;

   302 	TLocalDriveMappingInfo& ldmi=mBuf();

   303 	ldmi.iDriveMapping[0]=aFirstDrive;

   304 	ldmi.iDriveMapping[1]=aSecondDrive;

   305 	ldmi.iOperation=TLocalDriveMappingInfo::ESwapIntMappingAndSet;

   306 	TInt r=iFs.SetLocalDriveMapping(mBuf);

   307 	__ASSERT_ALWAYS(r==KErrNone,Panic(ELitFsSwapMappingFail,r));

   308 	}

   309 	

   310 

   311 

   312 // Warning - File format changes must be replicated in EikSrv.

   313 struct TLocData

   314 	{

   315 	TLocale iLocale;

   316 	TCurrencySymbol iCurrency;

   317 	};

   318 

   319 /**

   320 Attempt to open the locale data file from system drive. If found, read the 

   321 locale and currency symbol data from this file and transfer it to 'the system'.

   322 

   323 @return KErrNone if successful.

   324 */

   325 TInt TFSStartup::LoadLocale()

   326 	{

   327 	// Append the language index to the standard locale filename.

   328 	TFileName filename(KLitLocaleData);

   329 	filename[0] = (TUint8) RFs::GetSystemDriveChar();

   330 	TInt lang;

   331 	if (HAL::Get(HAL::ELanguageIndex,lang) == KErrNone)

   332 		{

   333 		filename.AppendNumFixedWidth(lang,EDecimal,2);

   334 		HAL::Set(HAL::ELocaleLoaded, lang);

   335 		}

   336 

   337 	// Attempt to open the file, read/set the data. 

   338 	RFile file;

   339 	if (file.Open(iFs,filename,EFileRead) == KErrNone)

   340 		{

   341 		TPckgBuf<TLocData> data;

   342 		if( file.Read(data) == KErrNone && data.Size()==sizeof(TLocData))

   343 			{

   344 			data().iLocale.Set();

   345 			TInt offset = data().iLocale.UniversalTimeOffset().Int();

   346 			if (data().iLocale.QueryHomeHasDaylightSavingOn())

   347 				offset += 3600;

   348 			User::SetUTCOffset(offset);

   349 			User::SetCurrencySymbol(data().iCurrency);

   350 			}

   351 		file.Close();

   352 		}

   353 	return(KErrNone);	

   354 	}

   355 

   356 

   357 /**

   358 Load the Locale DLL

   359 @return KErrNone if successful.

   360 	    KErrNotFound if locale DLL not found.

   361 		Or other system wide error code.

   362 */

   363 TInt LoadLocaleDll()

   364     {

   365     TBuf<16> localeDllName;

   366 

   367     TInt languageIndex;

   368     TInt error=HAL::Get(HALData::ELanguageIndex,languageIndex);

   369     if (error!=KErrNone)

   370         error = KErrNotFound;

   371     else

   372         {

   373         TBuf<6> extension; // Dot plus five digit locale

   374         _LIT(KExtension,".%u");

   375         extension.Format(KExtension, languageIndex);

   376         if (extension.Length()<3) // Padd ".1" to ".01" for compatibility.

   377             {

   378             _LIT(KPadding,"0");

   379             extension.Insert(1,KPadding);

   380             }

   381         localeDllName=KLocaleDllNameBase;

   382         localeDllName.Append(extension);

   383 		error = UserSvr::ChangeLocale(localeDllName);

   384         }

   385     if (error==KErrNotFound)

   386         {

   387 		// Try default locale

   388         _LIT(KLocaleDllNameExtension, ".LOC");

   389         localeDllName=KLocaleDllNameBase;

   390         localeDllName.Append(KLocaleDllNameExtension);

   391 		error = UserSvr::ChangeLocale(localeDllName);

   392         }

   393     if (error == KErrNone)

   394         TLocale().Set();

   395 	return error;

   396     }

   397 

   398 /**

   399 Initialise the HAL.

   400 Search for a saved HAL file - containing a series of saved HAL attributes. 

   401 If found, initialise each attribute saved.

   402 

   403 @return KErrNone if successful; KErrGeneral if the exe panicked.

   404 */

   405 TInt TFSStartup::InitialiseHAL()

   406 	{

   407 	RProcess process;

   408 	TInt result = process.Create(_L("HALSettings.exe"), _L("INITIALISE"));

   409 	if(result != KErrNone)

   410 		return result;

   411 	TRequestStatus status;

   412 	process.Logon(status);

   413 	if (status != KRequestPending)

   414 		process.Kill(0);	// abort 

   415 	else

   416 		process.Resume();	// logon OK

   417 	User::WaitForRequest(status);

   418 

   419 	// Special case to ensure the nonsecure clock offset set function gets called

   420 	TInt nsc_offset = 0;

   421 	result = HAL::Get(HAL::ETimeNonSecureOffset,nsc_offset);

   422 	if (result == KErrNone) 

   423 		{

   424 		HAL::Set(HAL::ETimeNonSecureOffset,nsc_offset); // this will only succeed when hal.dat is missing and the function wasnt called by halsettings.exe

   425 		}

   426 

   427 	

   428 	// we can't use the 'exit reason' if the exe panicked as this

   429 	// is the panic 'reason' and may be '0' which cannot be distinguished

   430 	// from KErrNone

   431 	result = process.ExitType() == EExitPanic ? KErrGeneral : status.Int();

   432 	process.Close();

   433 	return result;

   434 	}

   435 

   436 /**

   437 Create and resume a server. Start without specifying a path. 

   438 If this fails, then systematically try to start it from 

   439 each valid drive in turn (Y: - A:, then Z:). 

   440 The second phase is to handle the sitation where a version 

   441 of the executable is found on a drive early in the search order

   442 (e.g. C:) - that fails to load. Rather than failing the load 

   443 on the 1st error, this function keeps going through all the valid drives.

   444 

   445 @param aDrives		The drive list, to determine which are valid.

   446 @param aRootName	The root name of the executable.

   447 

   448 @return	ETrue if the server was eventually created successfully, EFalse if not.

   449 */

   450 TBool TFSStartup::CreateServer(const TDriveList& aDrives, const TDesC& aRootName)

   451 	{

   452 	RProcess ws;

   453 	TInt r=ws.Create(aRootName, KNullDesC);

   454 	if (r!=KErrNone)

   455 		{

   456 		TFileName name;

   457 		name = KServerPathSysBin();

   458 		name+=aRootName;

   459 		TInt i=EDriveZ;

   460 		FOREVER

   461 			{

   462 			i= (i==0) ? EDriveZ : i-1;

   463 			if (aDrives[i]!=KDriveAbsent) // Got a valid drive

   464 				{

   465 				name[0]=(TText)('A'+i); // Set the drive letter

   466 				r=ws.Create(name,KNullDesC);

   467 				if (r==KErrNone)

   468 					break;

   469 				}

   470 			if (i==EDriveZ)

   471 				return EFalse;

   472 			}

   473 		}

   474 	ws.Resume();

   475 	ws.Close();

   476 	return ETrue;

   477 	}

   478 

   479 #ifdef AUTO_PROFILE

   480 _LIT(KProfilerName,"profiler.exe");

   481 _LIT(KProfilerCmd,"start");

   482 /**

   483 Start the profiler

   484 */

   485 void TFSStartup::StartProfiler()

   486 	{

   487 	RProcess p;

   488 	TInt r=p.Create(KProfilerName,KProfilerCmd);

   489 	if (r==KErrNone)

   490 		{

   491 		p.Resume();

   492 		p.Close();

   493 		}

   494 	}

   495 #endif

   496 

   497 #if !defined(AUTODETECT_DISABLE)

   498 /**

   499 FSY detection function for the local FSY (assumed to be FAT). This will return success for MMC,

   500 ATA, Floppy and IRAM devices that are FAT formatted. Will also return success for any drive

   501 (other than those designated for CD ROMs) which isn't ready - assuming these to be removable FAT

   502 formatted devices. For floppy devices detected on the X86 build, we need to change the drive

   503 mapping so that these are mounted on drives A: or B:.

   504 */

   505 GLDEF_C TInt DetectELocal(RLocalDrive ld, TInt cr, TLocalDriveCapsV2& caps)

   506 	{

   507 	(void)ld;

   508 	(void)cr;

   509 	TInt socknum;

   510 	if (cr==KErrNotReady && caps.iType != EMediaCdRom)

   511 		{

   512 #if defined(__EPOC32__) && defined(__X86__)

   513 		// For FDD iEraseBlockSize top 16 bits is sectors per track

   514 		if (caps.iType==EMediaFloppy && (caps.iEraseBlockSize>>16))

   515 			{

   516 pc_floppy:

   517 			if (gNFloppies < 2)

   518 				{

   519 				// Change the default mapping to A: or B:

   520 				TInt ret = gNFloppies ? EDriveB : EDriveA;

   521 				++gNFloppies;

   522 				return KFsDetectMappingChangeReturnOffset + ret;

   523 				}

   524 			return KErrNone;

   525 			}

   526 #endif

   527 		return KErrNone;	// Removable and not ready - assume fat

   528 		}

   529 	if(cr == KErrCorrupt && ld.IsRemovable(socknum)) // Removable and media corrupt - assume fat

   530 		{

   531 		return KErrNone;

   532 		}

   533 	if (caps.iType!=EMediaFloppy && caps.iType!=EMediaHardDisk)

   534 		return KErrGeneral;

   535 	if (cr==KErrNone && (PartitionIsFAT32(caps.iPartitionType) || PartitionIsFAT(caps.iPartitionType)) )

   536 		{

   537 #if defined(__EPOC32__) && defined(__X86__)

   538 		if (cr!=KErrNotSupported && caps.iType==EMediaFloppy && (caps.iEraseBlockSize>>16))

   539 			goto pc_floppy;

   540 #endif		

   541 		return KErrNone;

   542 		}

   543 	return KErrGeneral;

   544 	}

   545 	

   546 /**

   547 FSY detection function for the local FSY (assumed to be FAT) running over internal RAM. This will

   548 return success for any drive containing RAM media which reports a FAT16 partition type.

   549 */	

   550 GLDEF_C TInt DetectIRam(RLocalDrive ld, TInt cr, TLocalDriveCapsV2& caps)

   551 	{

   552 	(void)ld;

   553 	(void)cr;

   554 	if (caps.iType==EMediaRam && caps.iPartitionType==KPartitionTypeFAT16)

   555 		return KErrNone;

   556 	return KErrGeneral;

   557 	}	

   558 	

   559 /**

   560 FSY detection function for the local FSY (assumed to be FAT) running over a NAND FTL. This will

   561 return success for any drive containing NAND media which reports a FAT16 partition type.

   562 */	

   563 GLDEF_C TInt DetectFtl(RLocalDrive ld, TInt cr, TLocalDriveCapsV2& caps)

   564 	{

   565 	(void)ld;

   566 	(void)cr;

   567 	if (caps.iType==EMediaNANDFlash && caps.iPartitionType==KPartitionTypeFAT16)

   568 		return KErrNone;

   569 	return KErrGeneral;

   570 	}

   571 		

   572 /**

   573 FSY detection function for the ROFS FSY. This will return success for any drive containing NAND

   574 media which reports a ROFS partition type as long as the ROFS FSY is present - but not the Composite FSY   

   575 */

   576 GLDEF_C TInt DetectRofs(RLocalDrive ld, TInt cr, TLocalDriveCapsV2& caps)

   577 	{

   578 	(void)ld;

   579 	(void)cr;

   580 	if ((caps.iType==EMediaNANDFlash) && caps.iPartitionType==KPartitionTypeRofs && gMountRofsAlone)

   581 		return KErrNone;

   582 	return KErrGeneral;

   583 	}

   584 

   585 /**

   586 FSY detection function for the Composite FSY. This will return success for the 1st drive containing NAND

   587 media which reports a ROFS partition type as long as both the ROFS and Composite FSYs are present. We

   588 change the DRIVE mapping so that this is mounted on drive Z:. Any subsequent ROFS partitions detected

   589 can be mounted as ROFS.

   590 */

   591 GLDEF_C TInt DetectComposite(RLocalDrive ld, TInt cr, TLocalDriveCapsV2& caps)

   592 	{

   593 	(void)ld;

   594 	(void)cr;

   595 	if ((caps.iType==EMediaNANDFlash) && caps.iPartitionType==KPartitionTypeRofs && gMountComposite)

   596 		{

   597 		if (!gNCompositeMounts)

   598 			{

   599 			gNCompositeMounts++;

   600 			gMountRofsAlone=ETrue;		// Any further ROFS drives found can be mounted as such

   601 			return(KFsDetectMappingChangeReturnOffset+EDriveZ);

   602 			}

   603 		}	

   604 	return KErrGeneral;

   605 	}

   606 	

   607 /**

   608 FSY detection function for the LFFS FSY. This will return success for any drive containing NOR

   609 media which reports an LFFS partition type.   

   610 */

   611 GLDEF_C TInt DetectEneaLFFS(RLocalDrive ld, TInt cr, TLocalDriveCapsV2& caps)

   612 	{

   613 	(void)ld;

   614 	(void)cr;

   615 	if (caps.iType==EMediaFlash && caps.iPartitionType==KPartitionTypeEneaLFFS)

   616 		return KErrNone;

   617 	return KErrGeneral;

   618 	}

   619 

   620 /**

   621 FSY detection function for the ISO 9660 FSY (X86 only). This will return success for CD ROM

   622 devices.   

   623 */

   624 GLDEF_C TInt DetectIso9660(RLocalDrive ld, TInt cr, TLocalDriveCapsV2& caps)

   625 	{

   626 	(void)ld;

   627 	(void)cr;

   628 	if (caps.iType == EMediaCdRom)

   629 		return KErrNone;

   630 	return KErrGeneral;

   631 	}

   632 

   633 /**

   634 FSY detection function for the NTFS FSY (X86 only). This will return success for any drive

   635 containing a hard disk device which reports an NTFS partition type.   

   636 */

   637 GLDEF_C TInt DetectNtfs(RLocalDrive ld, TInt cr, TLocalDriveCapsV2& caps)

   638 	{

   639 	(void)ld;

   640 	(void)cr;

   641 	if (caps.iType==EMediaHardDisk && PartitionIsNTFS(caps.iPartitionType))

   642 		return KErrNone;

   643 	return KErrGeneral;

   644 	}

   645 #endif	

   646 

   647 /**

   648 Format a drive.

   649 

   650 @param aDrive The number of the drive to be formatted (0-25).

   651 

   652 @return	KErrNone if no error otherwise one of the other system wide error codes.

   653 */

   654 TInt TFSStartup::FormatDrive(TInt aDrive)

   655 	{

   656 	TBuf<2> driveName(_S("A:"));

   657 	driveName[0] = (TText)(aDrive+'A');

   658 	RFormat format;

   659 	TInt count;

   660 	TInt d = format.Open(iFs, driveName, EHighDensity, count);

   661 	DEBUGPRINT2("FormatOpen %S -> %d", &driveName, d);

   662 	if(d!=KErrNone)

   663 		return d;

   664     ShowFormatProgress(count, aDrive);

   665 #ifdef _DEBUG

   666 	TInt lastCount = -1;

   667 #endif

   668     while (d==KErrNone && count)

   669 		{

   670 #ifdef _DEBUG

   671 		if (lastCount != count)

   672 			DEBUGPRINT1("Format count %d", count);

   673 		lastCount = count;

   674 #endif

   675 		d=format.Next(count);

   676         ShowFormatProgress(count, aDrive);

   677 		}

   678 	format.Close();

   679 	DEBUGPRINT1("Format complete %d", d);

   680 	return d;

   681 	}

   682 

   683 /**

   684 Set System Drive if defined either in ESTART.TXT or in HALData::ESystemDrive

   685 */

   686 void TFSStartup::SetSystemDrive()

   687 	{

   688 	DEBUGPRINT("TFSStartup::SetSystemDrive");

   689 	for(TInt i=0; i<iMapCount; i++)

   690 		{

   691 		if(iDriveMappingInfo[i].iFsInfo.iFlags&FS_SYSTEM_DRIVE)

   692 			{

   693 			TInt err = iFs.SetSystemDrive((TDriveNumber)iDriveMappingInfo[i].iDriveNumber);

   694 			DEBUGPRINT3("SetSystemDrive from FILE [%d], %d, err:%d", i, iDriveMappingInfo[i].iDriveNumber, err);

   695 			__ASSERT_ALWAYS(err==KErrNone, Panic(ESetSystemDriveFail, err));

   696 			}

   697 		}

   698 		

   699 	TInt drive = KErrNotFound;

   700 	TInt err = HAL::Get(HAL::ESystemDrive, drive);

   701 	if(err == KErrNone && drive >= EDriveA && drive <= EDriveZ)

   702 		{

   703 		err = iFs.SetSystemDrive((TDriveNumber)drive);

   704 		DEBUGPRINT2("SetSystemDrive from HAL %d, err:%d", drive, err);

   705 		__ASSERT_ALWAYS(err==KErrNone || err==KErrAlreadyExists, Panic(ESetSystemDriveFail, err));

   706 		}

   707 	}

   708 

   709 

   710 /**

   711 Parse the flags field of a drive mapping record that has been read from the drive mapping file.

   712 The flags field text is expected to contain one or more flags, each delimited with a "," char. 

   713 Override this function to support custom drive configuation flags.

   714 

   715 @param aFlagDesc	Non-modifiable descriptor holding the flags record text to be parsed.

   716 @param aFlagVar		An integer to hold the returned flag settings.

   717 @param aSpare		An integer to hold any additional info returned. 

   718 

   719 @return	Always returns KErrNone (but derived version may not).

   720 */

   721 TInt TFSStartup::ParseMappingFileFlags(const TPtrC& aFlagDesc,TUint32& aFlagVar,TInt& aSpare)

   722 	{

   723 

   724 	TInt r=KErrNone;

   725 	TInt pos=0;

   726 	TInt len;

   727 	TPtrC ptr;

   728 	TBool endOfFlagDesc=EFalse; 

   729 	aFlagVar=0;

   730 	while (!endOfFlagDesc && r==KErrNone) 

   731 		{

   732 		ptr.Set(aFlagDesc.Mid(pos));

   733 		len=ptr.Locate(',');

   734 		if (len==KErrNotFound)

   735 			endOfFlagDesc=ETrue;

   736 		else

   737 			{	

   738 			ptr.Set(ptr.Left(len));

   739 			pos+=(len+1);

   740 			} 

   741 		if (ptr.MatchF(_L("FS_FORMAT_ALWAYS"))!=KErrNotFound)

   742 			aFlagVar|=FS_FORMAT_ALWAYS;

   743 		else if (ptr.MatchF(_L("FS_FORMAT_COLD"))!=KErrNotFound)

   744 			aFlagVar|=FS_FORMAT_COLD;		

   745 		else if (ptr.MatchF(_L("FS_FORMAT_CORRUPT"))!=KErrNotFound)

   746 			aFlagVar|=FS_FORMAT_CORRUPT;		

   747 		else if (ptr.MatchF(_L("FS_DISMNT_CORRUPT"))!=KErrNotFound)

   748 			aFlagVar|=FS_DISMNT_CORRUPT;

   749 		else if (ptr.MatchF(_L("FS_SWAP_CORRUPT*"))!=KErrNotFound)

   750 			{

   751 			len=ptr.Locate('-');

   752 			if (iFs.CharToDrive(ptr[len+1],aSpare)==KErrNone && iDriveSwapCount==0) // We only allow one swap

   753 				{

   754 				aFlagVar|=FS_SWAP_CORRUPT;

   755 				iDriveSwapCount++;

   756 				}

   757 			}

   758 		else if (ptr.MatchF(_L("FS_SYNC_DRIVE"))!=KErrNotFound)

   759 			aFlagVar|=FS_SYNC_DRIVE;

   760 		else if (ptr.MatchF(_L("FS_SCANDRIVE"))!=KErrNotFound)

   761 			aFlagVar|=FS_SCANDRIVE;	

   762 		else if (ptr.MatchF(_L("FS_COMPOSITE"))!=KErrNotFound)

   763 			aFlagVar|=FS_COMPOSITE;

   764 		else if (ptr.MatchF(_L("FS_NO_MOUNT"))!=KErrNotFound)

   765 			aFlagVar|=FS_NO_MOUNT;	

   766 		else if (ptr.MatchF(_L("FS_ALLOW_REM_ACC"))!=KErrNotFound)

   767 			aFlagVar|=FS_ALLOW_REM_ACC;

   768 		else if (ptr.MatchF(_L("FS_NOT_RUGGED")) != KErrNotFound)

   769 			aFlagVar |= FS_NOT_RUGGED;

   770 		else if (ptr.MatchF(_L("FS_SYSTEM_DRIVE")) != KErrNotFound)

   771 			aFlagVar |= FS_SYSTEM_DRIVE;

   772 		else	

   773 			r=ParseCustomMountFlags(&ptr,aFlagVar,aSpare);

   774 		}

   775 	return(r);

   776 	}

   777 

   778 /**

   779 Parse for custom mount flags - default implementation.

   780 In either the auto-configuration scheme or the drive mapping file scheme, 

   781 to add support for additional mount flags, this function needs to be override.

   782 

   783 @param aFlagPtr		The flag text.

   784 @param aFlags		An integer to hold the returned mount flag settings

   785 @param aSpare		An integer to hold any additional info returned.

   786 

   787 @return	KErrNone if no error.

   788 */ 

   789 TInt TFSStartup::ParseCustomMountFlags(TPtrC* /*aFlagPtr*/,TUint32& /*aFlags*/,TInt& /*aSpare*/)

   790 	{

   791 	

   792 	return(KErrNone);

   793 	}

   794 		

   795 /**

   796 Process any custom mount flags - default implementation.

   797 In either the auto-configuration scheme or the drive mapping file scheme, 

   798 to add support for additional mount flags, this function needs to be override.

   799 

   800 @param aMountRet	The value returned when attempting to mount the drive.

   801 @param aFlags		The mount flags.

   802 @param aSpare		An integer containing any additional info associated with the flags.

   803 @param aDrive		The drive number.

   804 

   805 @return	KErrNone if no error.

   806 */

   807 TInt TFSStartup::HandleCustomMountFlags(TInt& /*aMountRet*/,TInt& /*aFlags*/,TInt& /*aSpare*/,TInt /*aDrive*/)

   808 	{

   809 

   810 	return(KErrNone);

   811 	}

   812 

   813 /**

   814 Process the local drive field of a drive mapping record

   815 

   816 @param aDriveDesc The comma seperated local drives

   817 @param aDrives An array of drive numbers (return reference)

   818 @param aCount The number of local drives found.

   819 

   820 @return	KErrNone if no error, otherwise a System-wide error code.

   821 */

   822 TInt TFSStartup::ParseMappingFileLocalDrive(const TPtrC& aDriveDesc,TUint32 (&aDrives)[KMaxLocalDrives],TInt& aCount)

   823 	{

   824 

   825 	TInt len;

   826 	TInt pos=0;

   827 	TPtrC ptr;

   828 	TBool endOfDriveDesc=EFalse; 

   829 	TInt err = KErrNone;

   830 	aCount=0;

   831 	while (!endOfDriveDesc) 

   832 		{

   833 		ptr.Set(aDriveDesc.Mid(pos));

   834 		len=ptr.Locate(',');

   835 		if (len==KErrNotFound)

   836 			endOfDriveDesc=ETrue;

   837 		else

   838 			{	

   839 			ptr.Set(ptr.Left(len));

   840 			pos+=(len+1);

   841 			} 

   842 		// Get numeric value

   843 		TLex lex;

   844 		lex.Assign(ptr);

   845 		lex.SkipSpace();

   846 		TUint32 locDrvNum;

   847 		if (lex.BoundedVal(locDrvNum,EDecimal,(KMaxLocalDrives-1))!=KErrNone)

   848 	        return(KErrArgument);

   849 		// Store

   850 		if(aCount >= KMaxLocalDrives)

   851 			return KErrOverflow;

   852 		aDrives[aCount]=locDrvNum;

   853 		++aCount;

   854 		}

   855 	return err;

   856 	}

   857 

   858 

   859 /**

   860 Parse a drive mapping record that has been read from the drive mapping file.

   861 

   862 @param aTextLine	Modifiable ptr descriptor holding the mapping record text 

   863 					to be parsed. Note that this function will null-terminate 

   864 					any FSY or extension names it detects. This will generally

   865 					result in the over-writing of the field separator or end of 

   866 					record delimitor but consideration is required where a 

   867 					mapping file ends with such a string.

   868 @param anInfo		A stucture to hold the returned mapping settings, 

   869 					FSY/ext name string pointers and mounting flags.

   870 

   871 @return	KErrNone if record is successfully parsed and 'anInfo' contains 

   872 		mapping info to be applied. 

   873 		KErrNotFound if the record is a comment line. 

   874 		KErrArgument if the syntax of record is incorrect.

   875 */

   876 TInt TFSStartup::ParseMappingRecord(TPtr& aTextLine,SLocalDriveMappingInfo& anInfo)

   877 	{

   878 	TPtrC token;

   879 	TLex lex(aTextLine);

   880 	

   881 	TInt driveNumber = KDriveInvalid;

   882 	TUint32 localDriveNums[KMaxLocalDrives];

   883 	const TText* fsyName = NULL;

   884 	const TText* objName = NULL;

   885 	const TText* extName = NULL;

   886 	TUint32 flags = 0;

   887 	TInt spare = 0;

   888 	

   889 	// Get all of the above Attributes.

   890 

   891 	

   892 	token.Set(lex.NextToken());

   893 	if (token.Length() <= 1 || token[0]=='#')				// Blank line or comment line

   894 		return(KErrNotFound);

   895 		

   896 	// Drive number		

   897 	if (token[1]!=':' || iFs.CharToDrive(token[0],driveNumber)!=KErrNone)

   898 		return(KErrArgument);

   899 

   900 	// Local drive number(s)

   901 	lex.SkipSpace();

   902 	token.Set(lex.NextToken());

   903 	TInt localDriveCount = 0;

   904 	TInt err = ParseMappingFileLocalDrive(token,localDriveNums,localDriveCount);

   905 	if(err != KErrNone)

   906 		{

   907 		return err;

   908 		}

   909 	if(localDriveCount==0)

   910 		{

   911 		return KErrArgument;

   912 		}

   913 				

   914 	TInt tokLen;

   915 	TPtr fileName(NULL,0);

   916 	TBool endOfRecord = EFalse;

   917 	

   918 	// .FSY file name

   919 	token.Set(lex.NextToken());

   920 	if (!endOfRecord && (token.Length()==0 || token[0]=='#'))

   921 		endOfRecord = ETrue;

   922 	else

   923 		{

   924 		if (token[0]!='0')

   925 			{

   926 			tokLen=token.Length();

   927 			fileName.Set((TUint16*)token.Ptr(),tokLen,tokLen+1);

   928 			token.Set(lex.NextToken());

   929 			fsyName=fileName.PtrZ();

   930 			}

   931 		else

   932 			{

   933 			token.Set(lex.NextToken());

   934 			}

   935 		}

   936 		

   937 	// Object name of .FSY

   938 	if (!endOfRecord && (token.Length()==0 || token[0]=='#'))

   939 		{

   940 		endOfRecord = ETrue;

   941 		}

   942 	else // Get FSY

   943 		{

   944 		if (token[0]!='0')

   945 			{

   946 			tokLen=token.Length();

   947 			fileName.Set((TUint16*)token.Ptr(),tokLen,tokLen+1);

   948 			token.Set(lex.NextToken());

   949 			objName=fileName.PtrZ();

   950 			}

   951 		else

   952 			{

   953 			token.Set(lex.NextToken());

   954 			}

   955 		}

   956 		

   957 	// Extension name

   958 	if (!endOfRecord && (token.Length()==0 || token[0]=='#'))

   959 		{

   960 		endOfRecord = ETrue;

   961 		}

   962 	else // Get extension

   963 		{

   964 		if (token[0]!='0')

   965 			{

   966 			tokLen=token.Length();

   967 			fileName.Set((TUint16*)token.Ptr(),tokLen,tokLen+1);

   968 			token.Set(lex.NextToken());

   969 			extName=fileName.PtrZ();

   970 			}

   971 		else

   972 			{

   973 			token.Set(lex.NextToken());

   974 			}

   975 		}

   976 

   977 	// Flags

   978 	if (!endOfRecord && (token.Length()==0 || token[0]=='#'))

   979 		{

   980 		endOfRecord = ETrue;

   981 		}

   982 	else // Get Flags

   983 		{

   984 		if (token[0]!='0')

   985 			{

   986 			TInt r=ParseMappingFileFlags(token,flags,spare);

   987 			if(r!=KErrNone)

   988 				return r;

   989 			}

   990 		}

   991 

   992 	//

   993 	// For every local drive

   994 	//

   995 	SLocalDriveMappingInfo* mappingInfo = &anInfo;

   996 	for(TInt i = 0; i<localDriveCount; i++)

   997 		{

   998 		if(iMapCount >= KMaxLocalDrives)

   999 			return KErrOverflow;

  1000 		Mem::FillZ(mappingInfo,sizeof(SLocalDriveMappingInfo));

  1001 		

  1002 		mappingInfo->iDriveNumber = driveNumber;

  1003 		mappingInfo->iLocalDriveNumber = localDriveNums[i];

  1004 		mappingInfo->iFsInfo.iExtName = extName;

  1005 		mappingInfo->iFsInfo.iFsyName = fsyName;

  1006 		mappingInfo->iFsInfo.iObjName = objName;

  1007 		mappingInfo->iSpare = spare;

  1008 		mappingInfo->iFsInfo.iFlags = flags;

  1009 		

  1010 		// If there was more than 1 local drive number (multi-slot device)

  1011 		// then increase iMapCount so that the mappingInfo doesn't get

  1012 		// clobbered next time this function is called.

  1013 		if(i>=1 && ((TInt)localDriveNums[i])!=KDriveInvalid)

  1014 			{

  1015 			iMapCount++;

  1016 			DEBUGPRINT2("Alternative Entry found for registered ldrive:%d -> %c:",localDriveNums[i],(mappingInfo->iDriveNumber+'A'));

  1017 			}

  1018 		mappingInfo++;

  1019 		}

  1020 	return KErrNone;	

  1021 	}

  1022 	

  1023 /**

  1024 This is only called if a mapping configuration has specified "FS_SWAP_CORRUPT". 

  1025 If it is necessary to implement the drive swap then it is required that 

  1026 the entry for the second drive involved in the swap (ie the one specified 

  1027 in "FS_SWAP_CORRUPT-<drv>") occurs later in the mapping array than the one 

  1028 specifying the swap. This functions checks whether the ordering is OK and 

  1029 swaps the entries for the two drives if necessary. 

  1030 

  1031 @param aTotalEntries The total number of valid entries in the mapping array. 

  1032 */	

  1033 void TFSStartup::CheckAndReOrderArrayForSwapping(TInt aTotalEntries)

  1034 	{

  1035 	

  1036 	// Find the swapper - and determine its entry number

  1037 	TInt i;

  1038 	for (i=0;i<aTotalEntries;i++)

  1039 		{

  1040 		if (iDriveMappingInfo[i].iFsInfo.iFlags & FS_SWAP_CORRUPT)

  1041 			break;

  1042 		}	

  1043 	if (i==aTotalEntries)

  1044 		return;

  1045 	TInt swapperEntryNo=i;

  1046 	TInt swappeeDrvNo=iDriveMappingInfo[i].iSpare;

  1047 	

  1048 	// Now find the swappee and determine its entry number 

  1049 	for (i=0;i<aTotalEntries;i++)

  1050 		{

  1051 		if (iDriveMappingInfo[i].iDriveNumber == swappeeDrvNo)

  1052 			break;

  1053 		}

  1054 	if (i==aTotalEntries)

  1055 		return;	

  1056 	TInt swappeeEntryNo=i;

  1057 	

  1058 	// If swappee comes before swapper then we need to switch then around

  1059 	if (swapperEntryNo>swappeeEntryNo)

  1060 		{

  1061 		SLocalDriveMappingInfo tmp;

  1062 		tmp=iDriveMappingInfo[swapperEntryNo];

  1063 		iDriveMappingInfo[swapperEntryNo]=iDriveMappingInfo[swappeeEntryNo];

  1064 		iDriveMappingInfo[swappeeEntryNo]=tmp;

  1065 		}			

  1066 	}	

  1067 

  1068 /**

  1069 Swap the local drive mappings of two entries in the mapping array. Also, update the local drive mapping previously

  1070 written to the file server.

  1071 

  1072 @param aCurrentEntry	The position in the mapping array of the next mapping to be applied. 

  1073 						This coincides with the drive which has 'requested' the swap. 

  1074 						(The other mapping involved in the swap is guarenteed to be later 

  1075 						in the list and therefore not yet applied).

  1076 @param aTotalEntries	The total number of valid entries in the mapping array. 

  1077 

  1078 @panic  ESTART_12 0; If swap mapping file array is inconsistent.

  1079 */

  1080 void TFSStartup::SwapDriveMappings(TInt aCurrentEntry,TInt aTotalEntries)

  1081 	{

  1082 	DEBUGPRINT1("TFSStartup::SwapDriveMappings - Index %d",aCurrentEntry);

  1083 	TInt firstDrive=iDriveMappingInfo[aCurrentEntry].iDriveNumber;

  1084 	TInt secondDrive=iDriveMappingInfo[aCurrentEntry].iSpare;

  1085 	

  1086 	// Find the entry for the other mapping that we need to swap with

  1087 	TInt secondEntry;

  1088 	for (secondEntry=aCurrentEntry ; secondEntry<aTotalEntries ; secondEntry++)

  1089 		{	

  1090 		if (iDriveMappingInfo[secondEntry].iDriveNumber==secondDrive)

  1091 			break;

  1092 		}

  1093 	if (secondEntry==aTotalEntries)

  1094 		Panic(ELitSwapMappingFailArrayInconsistent,0);

  1095 	

  1096 	// Swap the entries over in the list of mappings still to be applied

  1097 	iDriveMappingInfo[aCurrentEntry].iDriveNumber=secondDrive;

  1098 	iDriveMappingInfo[secondEntry].iDriveNumber=firstDrive;

  1099 	

  1100 	// If second drive is replacing one that is corrupt then we always want to mount it

  1101 	iDriveMappingInfo[secondEntry].iFsInfo.iFlags&=~FS_NO_MOUNT; 	

  1102 	

  1103 	// Change the local drive mapping info already set with the file server

  1104 	SwapFServLocalDriveMapping(firstDrive,secondDrive);

  1105 	iDriveSwapCount=0;		// Swap now handled and the FS local drive mapping is set

  1106 	}

  1107 

  1108 /** 

  1109 Return the filename of the drive mapping file. If it is required to vary 

  1110 the local drive mapping for a given platform, depending on a particular platform 

  1111 specific setting (e.g. state of a switch or jumper setting, detection of 

  1112 a particular h/w feature etc) then it is still possible to use the map file scheme. 

  1113 In this situation, the ROM can be built with more than one mapping file. 

  1114 A custom version of ESTART should then override this virtual function to detect 

  1115 the current setting and return the name of the appropriate map file.

  1116 

  1117 @return	A non-modifiable ptr descriptor containing the path and filename of the mapping file.

  1118 */ 

  1119 TPtrC TFSStartup::LocalDriveMappingFileName()

  1120 	{

  1121 	

  1122 	return(KLocalDriveMappingFile());

  1123 	}

  1124 

  1125 /**

  1126 Open the drive mapping file, and process each mapping record it contains. 

  1127 For each record, this involves updating the local drive list, adding the FSY and 

  1128 any extension specified and then mounting these on the drive in question - 

  1129 processing any mounting flags in the process. The local drive mapping is also 

  1130 written to the File Server.

  1131 

  1132 Calls InitCompositeFileSystem but carries on should this fail. 

  1133 

  1134 @return	KErrNone if no error.

  1135 */