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 // f32test\scndrv\t_tscan32.cpp

    15 // 

    16 //

    17 

    18 #include <f32file.h>

    19 #include <e32test.h>

    20 

    21 #include "t_server.h"

    22 

    23 #include "fat_utils.h"

    24 using namespace Fat_Test_Utils;

    25 

    26 /*

    27 Series of tests to check that the combination of a ruggedised fat file

    28 system and scandisk prevents the file system from becoming corrupt in the

    29 event of a power failure. CheckDisk is used to test that directory

    30 structure is not corrupt. This test is only suitable with a drive that uses

    31 the fat file system but not the internal ram drive (due to the indirection)

    32 table. Only works with debug builds due to RFs::ControlIo only debug function

    33 */

    34 

    35 GLDEF_D TFileName StartupExeName=_L(""); // initialised at run time

    36 

    37 #ifdef _DEBUG

    38 GLREF_D RTest test;

    39 GLDEF_D TInt TheFunctionNumber;

    40 GLDEF_D TInt TheOpNumber;

    41 GLDEF_D TInt TheFailCount;

    42 GLDEF_D TBool IsReset;

    43 GLDEF_D TFileName TestExeName=_L("?:\\T_SCANDR.EXE"); //Renaming it to fit in one root dir entry.

    44 GLDEF_D TFileName LogFileName=_L("?:\\T_SCANDR.LOG"); //Renaming it to fit in one root dir entry.

    45 

    46 const TInt KControlIoWriteFailOn=0;		// commands to pass into RFs::ControlIo

    47 const TInt KControlIoWriteFailOff=1;

    48 const TInt KMaxFatEntries  = 2048;

    49 const TInt KDirAttrReadOnly  = 0x01;

    50 const TInt KDirAttrHidden    = 0x02;

    51 const TInt KDirAttrSystem    = 0x04;

    52 const TInt KDirAttrVolumeId  = 0x08;

    53 const TInt KDirAttrDirectory = 0x10;

    54 const TInt KDirAttrArchive   = 0x20;

    55 const TInt KDirAttrLongName  = KDirAttrReadOnly | KDirAttrHidden | KDirAttrSystem | KDirAttrVolumeId;

    56 const TInt KDirAttrLongMask  = KDirAttrLongName | KDirAttrDirectory | KDirAttrArchive;

    57 const TInt KDirLastLongEntry = 0x40;

    58 

    59 GLDEF_D TInt WriteFailValue;

    60 

    61 LOCAL_C TFatBootSector BootSector;	

    62 LOCAL_D RRawDisk TheRawDisk;

    63 

    64 static TFatType gDiskType = EInvalid;

    65 

    66 LOCAL_D TInt gTotalSectors;

    67 LOCAL_D TInt gBytesPerCluster;

    68 LOCAL_D TInt gRootDirSectors;

    69 LOCAL_D TInt gRootDirEntries;

    70 LOCAL_D TInt gRootDirStart;

    71 LOCAL_D TInt gRootSector;

    72 LOCAL_D TInt gFatStartBytes;

    73 LOCAL_D TInt gFatTestEntries;

    74 LOCAL_D TInt gFatSizeSectors;

    75 LOCAL_D TInt gFirstDataSector;

    76 LOCAL_D TInt gDataStartBytes;

    77 LOCAL_D TInt gClusterCount;

    78 

    79 LOCAL_D HBufC8* gFatBuf  = NULL;

    80 LOCAL_D TInt    gFatAddr = -1;

    81 

    82 enum TFatChain {EChainStd,EChainAlternate,EChainBackwards,EChainForwards};

    83 

    84 LOCAL_C TBool IsInternalRam()

    85 //

    86 // Returns true if the selected drive is variable size (i.e. RAM drive)

    87 //

    88 	{

    89 	TVolumeInfo v;

    90 	TInt r=TheFs.Volume(v,gSessionPath[0]-'A');

    91 	test(r==KErrNone);

    92 	return(v.iDrive.iMediaAtt&KMediaAttVariableSize);

    93 	}

    94 

    95 LOCAL_C void WriteLogFile()

    96 //

    97 // Writes state of test to end of LogFileName

    98 //

    99 	{

   100 	test.Printf(_L("Writelogfile()\n"));

   101 	RFile log;

   102 	TInt r=log.Open(TheFs,LogFileName,EFileShareExclusive|EFileWrite);

   103 	if(r!=KErrNone)

   104 		test.Printf(_L("error=%d\n"),r);

   105 	test(r==KErrNone);

   106 	TInt size;

   107 	r=log.Size(size);

   108 	test(r==KErrNone);

   109 	TBuf8<16> buf;

   110 	buf.SetLength(4);

   111 	buf[0]=(TUint8)TheFunctionNumber;

   112 	buf[1]=(TUint8)TheOpNumber;

   113 	buf[2]=(TUint8)TheFailCount;

   114 	buf[3]='\n';

   115 	r=log.Write(size,buf,buf.Length());

   116 	test(r==KErrNone);

   117 	test.Printf(_L("Written func=%d,op=%d,fail=%d\n"),TheFunctionNumber,TheOpNumber,TheFailCount);

   118 	log.Close();

   119 	}

   120 

   121 LOCAL_C TInt SetWriteFailOn(TInt aFailCount)

   122 //

   123 // Sets write to metadata to fail on aFailCount with WriteFailValue

   124 //

   125 	{

   126 	TInt16 args[2];

   127 	TPtr8 des((TUint8*)args,4,4);

   128 	args[0]=(TUint16)aFailCount;

   129 	args[1]=(TUint16)WriteFailValue;

   130 	TInt r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOn,des);

   131 	return(r);

   132 	}

   133 

   134 GLDEF_C void ReadLogFile()

   135 //

   136 // Reads state of test from end of LogFileName and sets global variables

   137 //

   138 	{

   139 	test.Next(_L("ReadLogFile"));

   140 	RFile log;

   141 	TInt r=log.Open(TheFs,LogFileName,EFileShareExclusive);

   142 	if(r!=KErrNone)

   143 		test.Printf(_L("error in ReadLogFile()=%d\n"),r);

   144 	test(r==KErrNone);

   145 	test(r==KErrNone);

   146 	TInt fileSize;

   147 	r=log.Size(fileSize);

   148 	if(fileSize==0)

   149 		{

   150 		TheFunctionNumber=0;

   151 		TheOpNumber=0;

   152 		TheFailCount=0;

   153 		}

   154 	else

   155 		{

   156 		TBuf8<4> buf;

   157 		r=log.Read(fileSize-4,buf,4);

   158 		TheFunctionNumber=buf[0];

   159 		TheOpNumber=buf[1];

   160 		TheFailCount=buf[2];

   161 		}

   162 	log.Close();

   163 	test.Printf(_L("func=%d,op=%d,fail=%d\n"),TheFunctionNumber,TheOpNumber,TheFailCount);

   164 	}

   165 

   166 LOCAL_C TUint32 MaxClusters()

   167 	//

   168 	// Return the number of data clusters on the disk

   169 	//

   170 	{

   171 	TUint32 totSec = (BootSector.TotalSectors() ? BootSector.TotalSectors() : BootSector.HugeSectors());

   172 	TUint32 numSec = totSec - gFirstDataSector;

   173 	return numSec / BootSector.SectorsPerCluster();

   174 	}

   175 

   176 LOCAL_C TInt ClusterToByte(TInt aCluster)

   177 	//

   178 	// converts cluster number to byte offset on disk

   179 	//

   180 	{

   181 	TInt sector = (aCluster - 2) * gBytesPerCluster + gFirstDataSector * BootSector.BytesPerSector();

   182 	return sector;

   183 	}

   184 

   185 /**

   186     Fill media with zeroes from aStartPos to aEndPos

   187 */

   188 static void DoZeroFillMedia(TInt64 aStartPos, TInt64 aEndPos, RRawDisk& aWriter)

   189 {

   190     test(aStartPos >=0 && aEndPos >=0 && aStartPos < aEndPos);

   191     

   192     if(aStartPos == aEndPos)

   193         return;

   194 

   195     RBuf8 buf;

   196     TInt  nRes;  

   197 

   198     const TUint32 KBufSz=65536*2; //-- buffer with zeroes

   199     

   200     nRes = buf.CreateMax(KBufSz);

   201     test(nRes == KErrNone);

   202 

   203     buf.FillZ();

   204 

   205     TUint32 rem = (TUint32)(aEndPos - aStartPos);

   206     while(rem)

   207     {

   208         const TUint32 bytesToWrite=Min(rem, KBufSz);

   209     

   210         TPtrC8 ptr(buf.Ptr(), bytesToWrite);

   211         nRes = aWriter.Write(aStartPos, ptr);

   212         test(nRes == KErrNone || nRes == KErrDiskFull);

   213 

   214         aStartPos+=bytesToWrite;

   215         rem-=bytesToWrite;

   216     }

   217 

   218 

   219     buf.Close();

   220 }

   221 

   222 //

   223 // Clear the disk data area to a known value which won't be confused with

   224 // directory entries etc.

   225 //

   226 LOCAL_C void ClearDiskData()

   227 	{

   228 

   229 	TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');

   230 	test(r==KErrNone);

   231 

   232 	TUint32 startPos = gDataStartBytes;

   233 	if (gDiskType == EFat32)

   234 		startPos += gBytesPerCluster;

   235 

   236     const TUint32 endPos = startPos + gFatTestEntries*gBytesPerCluster;

   237 

   238     test.Printf(_L("ClearDiskData() from pos:%u to pos:%u\n"), startPos, endPos);

   239 

   240     DoZeroFillMedia(startPos, endPos, TheRawDisk);

   241 

   242 	TheRawDisk.Close();

   243 	}

   244 

   245 LOCAL_C TInt PosInBytes(TInt aFatIndex)

   246 //

   247 // Return number of bytes into the FAT

   248 //

   249 	{

   250 	TInt fatPosInBytes = -1;

   251 	switch (gDiskType)

   252 		{

   253 		case EFat32:

   254 			fatPosInBytes=aFatIndex<<2;

   255 			break;

   256 		case EFat16:

   257 			fatPosInBytes=aFatIndex<<1;

   258 			break;

   259 		case EFat12:

   260 			fatPosInBytes=(aFatIndex*3>>1);

   261 			break;

   262 		default:

   263 			test(0);

   264 		}

   265 	return(fatPosInBytes);

   266 	}

   267 

   268 static void DoReadBootSector()

   269 	{

   270 	

   271     TInt nRes = ReadBootSector(TheFs, CurrentDrive(), KBootSectorNum<<KDefaultSectorLog2, BootSector);

   272     test(nRes == KErrNone);

   273 

   274     if(!BootSector.IsValid())

   275         {

   276         test.Printf(_L("Wrong bootsector! Dump:\n"));

   277         BootSector.PrintDebugInfo();

   278         test(0);

   279         }

   280 	// Calculate derived variables (fixed for a particular disk format)

   281 	gBytesPerCluster   = BootSector.BytesPerSector() * BootSector.SectorsPerCluster();

   282 	gRootDirSectors    = ((BootSector.RootDirEntries() * KSizeOfFatDirEntry + BootSector.BytesPerSector() - 1) / BootSector.BytesPerSector());

   283 	gFatStartBytes     = BootSector.ReservedSectors() * BootSector.BytesPerSector();

   284 	gFatSizeSectors    = (BootSector.FatSectors() ? BootSector.FatSectors() : BootSector.FatSectors32());

   285 	gRootSector        = BootSector.ReservedSectors() + BootSector.NumberOfFats() * gFatSizeSectors;

   286 	gRootDirStart      = gRootSector * BootSector.BytesPerSector();

   287 	gFirstDataSector   = gRootSector + gRootDirSectors;

   288 

   289 	gFatTestEntries = MaxClusters();

   290 	if (gFatTestEntries > KMaxFatEntries)

   291 		gFatTestEntries = KMaxFatEntries;

   292 

   293 	if (BootSector.RootDirEntries() == 0)

   294 		{

   295 		test.Printf(_L("**** Is Fat32\n"));

   296 		gDiskType = EFat32;

   297 		gRootDirEntries = BootSector.RootDirEntries();

   298 		}

   299 	else if (BootSector.FatType() == EFat16)

   300 		{

   301 		test.Printf(_L("**** Is Fat16\n"));

   302 		gDiskType = EFat16;

   303 		gRootDirEntries = BootSector.RootDirEntries();

   304 		}

   305 	else

   306 		{

   307 		test.Printf(_L("**** Is Fat12\n"));

   308 		gDiskType = EFat12;

   309 		gRootDirEntries = gBytesPerCluster * 1 / KSizeOfFatDirEntry;

   310 		}

   311 	gTotalSectors   = (BootSector.TotalSectors() ? BootSector.TotalSectors() : BootSector.HugeSectors());

   312 	gClusterCount   = (gTotalSectors - gFirstDataSector) / BootSector.SectorsPerCluster();

   313 	gDataStartBytes = gFirstDataSector * BootSector.BytesPerSector();

   314 	}

   315 

   316 GLDEF_C TUint32 GetFatEntry(TUint32 aIndex, const TUint8* aFat=NULL)

   317 //

   318 // Read a single FAT entry from disk or FAT copy and return it

   319 //

   320 	{

   321 

   322 

   323 	if (!gFatBuf)

   324 		{

   325 		gFatBuf=HBufC8::New(gBytesPerCluster);

   326 		test(gFatBuf!=NULL);

   327 		gFatAddr = -1;

   328 		}

   329 

   330 	const TUint8* ptr;

   331 

   332 	if (aFat)

   333 		{

   334 		ptr = (TUint8*)aFat + PosInBytes(aIndex);

   335 		}

   336 	else

   337 		{

   338 		TInt pos = PosInBytes(aIndex) + gFatStartBytes;

   339 		if (gFatAddr < 0 || pos < gFatAddr || pos >= gFatAddr + gBytesPerCluster)

   340 			{

   341 			TPtr8 ptr=gFatBuf->Des();

   342 		TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');

   343 			test(r==KErrNone);

   344 			r=TheRawDisk.Read(pos, ptr);

   345 			test(r==KErrNone);

   346 			TheRawDisk.Close();

   347 			gFatAddr = pos;

   348 			}

   349 		ptr = gFatBuf->Ptr() + pos-gFatAddr;

   350 		}

   351 

   352 	TUint32 val = 0;

   353 	switch (gDiskType)

   354 		{

   355 		case EFat32:

   356 			val = *(TUint32*)ptr;

   357 			break;

   358 		case EFat16:

   359 			val = *(TUint16*)ptr;

   360 			break;

   361 		case EFat12:

   362 			val = *(TUint16*)ptr;

   363 			if (aIndex & 1)

   364 				val >>= 4;

   365 			val &= 0xFFF;

   366 			break;

   367 		default:

   368 			test(0);

   369 		}

   370 	return val;

   371 	}

   372 

   373 GLDEF_C void DumpBootSector()

   374 //

   375 // Display (in log) TFatBootSector structure

   376 //

   377 	{

   378 	RDebug::Print(_L("iBytesPerSector    = %8d"), BootSector.BytesPerSector());

   379 	RDebug::Print(_L("iSectorsPerCluster = %8d"), BootSector.SectorsPerCluster());

   380 	RDebug::Print(_L("iReservedSectors   = %8d"), BootSector.ReservedSectors());

   381 	RDebug::Print(_L("iNumberOfFats      = %8d"), BootSector.NumberOfFats());

   382 	RDebug::Print(_L("iRootDirEntries    = %8d"), BootSector.RootDirEntries());

   383 	RDebug::Print(_L("iTotalSectors      = %8d"), BootSector.TotalSectors());

   384 	RDebug::Print(_L("iMediaDescriptor   = %8d"), BootSector.MediaDescriptor());

   385 	RDebug::Print(_L("iFatSectors        = %8d"), BootSector.FatSectors());

   386 	RDebug::Print(_L("iSectorsPerTrack   = %8d"), BootSector.SectorsPerTrack());

   387 	RDebug::Print(_L("iNumberOfHeads     = %8d"), BootSector.NumberOfHeads());

   388 	RDebug::Print(_L("iHiddenSectors     = %8d"), BootSector.HiddenSectors());

   389 	RDebug::Print(_L("iHugeSectors       = %8d"), BootSector.HugeSectors());

   390 

   391 	//New for FAT32

   392 

   393 	if(BootSector.RootDirEntries() == 0)	//indicates we have FAT32 volume

   394 		{

   395 		RDebug::Print(_L("FatSectors32      = %8d"), BootSector.FatSectors32());

   396 		RDebug::Print(_L("FATFlags          = %8d"), BootSector.FATFlags());

   397 		RDebug::Print(_L("VersionNumber     = %8d"), BootSector.VersionNumber());

   398 		RDebug::Print(_L("RootClusterNum    = %8d (0x%08X)"), BootSector.RootClusterNum(), gRootDirStart);

   399 		RDebug::Print(_L("FSInfoSectorNum   = %8d (0x%08X)"), BootSector.FSInfoSectorNum(), BootSector.FSInfoSectorNum() * BootSector.BytesPerSector());

   400 		RDebug::Print(_L("BkBootRecSector   = %8d (0x%08X)"), BootSector.BkBootRecSector(), BootSector.BkBootRecSector() * BootSector.BytesPerSector());

   401 		}

   402 	TInt fatEntries = gFatSizeSectors*BootSector.BytesPerSector();

   403 	switch (gDiskType)

   404 		{

   405 		case EFat32:

   406 			fatEntries /= 4;

   407 			break;

   408 		case EFat16:

   409 			fatEntries /= 2;

   410 			break;

   411 		case EFat12:

   412 			fatEntries *= 3;

   413 			fatEntries /= 2;

   414 			break;

   415 		default:

   416 			test(0);

   417 		}

   418 	RDebug::Print(_L("ClusterCount      = %8d (%d bytes)"), gClusterCount, gClusterCount*gBytesPerCluster);

   419 	RDebug::Print(_L("FatEntries        = %8d (%d sectors)"), fatEntries, gFatSizeSectors);

   420 	RDebug::Print(_L("RootSector        = %8d (0x%08X)"), gRootSector, gRootDirStart);

   421 	RDebug::Print(_L("FirstDataSector   = %8d (0x%08X)"), gFirstDataSector, gDataStartBytes);

   422 	}

   423 

   424 GLDEF_C void DumpFat(const TUint8* aFat=NULL)

   425 // 

   426 // Dump to the log all those FAT entries which are non-zero

   427 //

   428 	{

   429 	TInt32 max = MaxClusters();

   430 	if (max > KMaxFatEntries)

   431 		max = KMaxFatEntries;

   432 	RDebug::Print(_L("---------------- DUMP OF FAT ---------------"));

   433 	for (TInt32 i = 0; i < max; i++)

   434 		{

   435 		TInt32 val = GetFatEntry(i, aFat);

   436 		TInt32 msk = 0x0FFFFFFF;

   437 		switch (gDiskType)

   438 			{

   439 			case EFat32:

   440 				msk = 0x0FFFFFFF;

   441 				break;

   442 			case EFat16:

   443 				msk = 0xFFFF;

   444 				break;

   445 			case EFat12:

   446 				msk = 0x0FFF;

   447 				break;

   448 			default:

   449 				test(0);

   450 			}

   451 		if ((val & msk) == (0x0FFFFFFF & msk))

   452 			RDebug::Print(_L("    %8d -> EOC"), i);

   453 		else if ((val & msk) == (0x0FFFFFF8 & msk))

   454 			RDebug::Print(_L("    %8d -> Media"), i);

   455 		else if ((val & msk) == (0x0FFFFFF7 & msk))

   456 			RDebug::Print(_L("    %8d -> BAD"), i);

   457 		else if (val > max)

   458 			RDebug::Print(_L("    %8d -> 0x%08X"), i, val);

   459 		else if (val != 0)

   460 			RDebug::Print(_L("    %8d -> %d"), i, val);

   461 		}

   462 	RDebug::Print(_L("--------------------------------------------"));

   463 	}

   464 

   465 GLDEF_C TDes* DirAttributes(TInt aAttrib)

   466 // 

   467 // Return a pointer to a local buffer containing the attribute letters.

   468 //

   469 	{

   470 	LOCAL_D TBuf<6> str(_L("------"));

   471 	LOCAL_D char*   atr = "RHSVDA";

   472 	for (TInt i = 0; i < 6; i++)

   473 		if ((aAttrib >> i) & 1)

   474 			str[i] = atr[i];

   475 	return &str;

   476 	}

   477 

   478 GLDEF_C TBool IsValidDirChar(TUint8 aChar, TUint8 aMin=0x20)

   479 //

   480 // Test whether a character is valid as part of a short filename, aMin is to

   481 // distinguish between first character (which can't be space) and later ones

   482 // which can include space but nothing less.  Note that E5 is a valid character

   483 // in any position, even though it means 'erased' in the first character.

   484 //

   485 	{

   486 	const TUint8* inval = (TUint8*)"\x22\x2A\x2B\x2C\x2E\x2F\x3A\x3B\x3C\x3D\x3E\x3F\x5B\x5C\x5D\x7C";

   487 	if (aChar < aMin)

   488 		return EFalse;

   489 	for (const TUint8* p = inval; *p; p++)

   490 		if (aChar == *p)

   491 			return EFalse;

   492 	return ETrue;

   493 	}

   494 

   495 GLDEF_C TBool IsValidDirEntry(TFatDirEntry* aDir)

   496 // 

   497 // Test whether buffer is a valid normal directory entry

   498 //

   499 	{

   500 	// top two bits of attributes must be zero

   501 	if (aDir->iData[11] & 0xC0)

   502 		return EFalse;

   503 	// first character must be 0x05 or greater than space

   504 	if (!IsValidDirChar(aDir->iData[0], 0x21) && aDir->iData[0] != 0x05)

   505 		return EFalse;

   506 	// other characters in name must be not less than space

   507 	for (TInt i = 1; i < 11; i++)

   508 		if (!IsValidDirChar(aDir->iData[i]))

   509 			return EFalse;

   510 	return ETrue;

   511 	}

   512 

   513 GLDEF_C void GetLongNamePart(TDes16& aName, const TUint8* aEntry, TInt aPos, TInt aOffset, TInt aLength)

   514 // 

   515 // Extract part of a long name entry into the name buffer.

   516 //

   517 // @param aName   buffer to put name

   518 // @param aEntry  directory entry raw data

   519 // @param aPos    character in buffer to start name segment

   520 // @param aOffset offset in directory entry of the segment

   521 // @param aLength number of characters in the segment

   522 // 

   523 	{

   524 	for (TInt i = 0; i < aLength; i++)

   525 		{

   526 		TInt at = i * 2 + aOffset;

   527 		TInt ch = aEntry[at] + aEntry[at+1] * 256;

   528 		aName[aPos++] = TText(ch);

   529 		}

   530 	}

   531 

   532 GLDEF_C void ExtractNameString(TDes16& aName, const TUint8* aEntry)

   533 //

   534 // Extract a long name part from a directory entry, truncate it at the first

   535 // NUL (0) character and put quotes round it.

   536 //

   537 	{

   538 	aName.SetLength(15);

   539 	TInt len = aName.Length() - 1;

   540 	TText qu = '\'';

   541 	aName[0] = qu;

   542 	GetLongNamePart(aName, aEntry,  1,  1, 5);

   543 	GetLongNamePart(aName, aEntry,  6, 14, 6);

   544 	GetLongNamePart(aName, aEntry, 12, 28, 2);

   545 	TInt i;

   546 	for (i = 0; i < len; i++)

   547 		if (aName[i] == 0)

   548 			break;

   549 	aName[i++] = qu;

   550 	aName.SetLength(i);

   551 	}

   552 

   553 GLDEF_C TBool DumpDirEntry(TInt aNum, const TUint8* aEntry)

   554 // 

   555 // Dump a single directory entry to the log.  Return false if it was end of

   556 // directory or an invalid entry (and don't display it).

   557 // 

   558 	{

   559 	TFatDirEntry* d = (TFatDirEntry*)aEntry;

   560 	if (d->IsErased())

   561 		{

   562 		// RDebug::Print(_L("%5d: ERASED"), aNum);

   563 		}

   564 	else if (d->IsEndOfDirectory())

   565 		return EFalse;

   566 	else if ((d->Attributes() & KDirAttrLongMask) == KDirAttrLongName)

   567 		{

   568 		TBuf16<15> name;

   569 		ExtractNameString(name, aEntry);

   570 		TInt ord = aEntry[0];

   571 		if (ord & KDirLastLongEntry)

   572 			RDebug::Print(_L("%5d: %-15S #%-2d LAST"), aNum, &name, ord & ~KDirLastLongEntry);

   573 		else

   574 			RDebug::Print(_L("%5d: %-15S #%-2d"), aNum, &name, ord & ~KDirLastLongEntry);

   575 		}

   576 	else if (!IsValidDirEntry(d))

   577 		return EFalse;

   578 	else

   579 		{

   580 		TBuf<11> name;

   581 		name.Copy(d->Name());

   582 		RDebug::Print(_L("%5d: '%S'  %S  cluster %d"),

   583 					  aNum, &name, DirAttributes(d->Attributes()), d->StartCluster());

   584 		}

   585 	return ETrue;

   586 	}

   587 

   588 GLDEF_C void DumpDirCluster(const TUint8* aData, TInt aCluster=0)

   589 //

   590 // Dump directory entries until end of cluster or invalid/end entry found.

   591 //

   592 	{

   593 	if (aCluster > 2)

   594 		aData += (aCluster-2) * gBytesPerCluster;

   595 	for (TInt i = 0; i < gBytesPerCluster; i += KSizeOfFatDirEntry)

   596 		{

   597 		if (DumpDirEntry(i/KSizeOfFatDirEntry, aData))

   598 			aData += KSizeOfFatDirEntry;

   599 		else

   600 			break;

   601 		}

   602 	}

   603 

   604 GLDEF_C void DumpData(const TUint8* aFat, TInt aStart, TInt aEnd)

   605 //

   606 // Dump clusters from disk (allows dumping of clusters not in our buffers).

   607 // Only look at clusters marked as 'used' in the FAT.  Note that if aFat is

   608 // NULL the FAT entries will also be read from disk (slower but allows for ones

   609 // outside our copy in memory).

   610 //

   611 	{

   612 	if (aStart > gFatTestEntries)

   613 		return;

   614 	RDebug::Print(_L("--------------- DATA AREA ------------------"));

   615 	if (aEnd > gFatTestEntries)

   616 		aEnd = gFatTestEntries;

   617 	for (TInt cluster = aStart; cluster < aEnd; cluster++)

   618 		{

   619 		if (GetFatEntry(cluster, aFat) != 0)

   620 			{

   621 			HBufC8* buf=HBufC8::New(gBytesPerCluster);

   622 			test(buf!=NULL);

   623 			TPtr8 ptr=buf->Des();

   624 			TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');

   625 			test(r==KErrNone);

   626 			r=TheRawDisk.Read(ClusterToByte(cluster), ptr);

   627 			test(r==KErrNone);

   628 			TheRawDisk.Close();

   629 			RDebug::Print(_L("Cluster %d @ 0x%08X:"), cluster, ClusterToByte(cluster));

   630 			DumpDirCluster(ptr.Ptr());

   631 			delete buf;

   632 			}

   633 		}

   634 	RDebug::Print(_L("--------------------------------------------"));

   635 	}

   636 

   637 GLDEF_C void DumpHex(const TUint8* aData, TInt aLen)

   638 //

   639 // Dump a block of memory to the log in hex.

   640 //

   641 	{

   642 	for (TInt base = 0; base < aLen; base += 16)

   643 		{

   644 		TBuf<16*3> buf;

   645 		TInt off;

   646 		for (off = base; off < aLen && off < base + 16; off++)

   647 			{

   648 			buf.Append(TText(' '));

   649 			buf.AppendNumFixedWidth(aData[off], EHex, 2);

   650 			}

   651 		RDebug::Print(_L("%04X: %S"), off, &buf);

   652 		}

   653 	}

   654 

   655 static void QuickFormat()

   656     {

   657         /*

   658         TFatFormatParam fmt;

   659         fmt.iFatType = EFat32;

   660         fmt.iSecPerCluster =1;

   661         FormatFatDrive(TheFs, CurrentDrive(), ETrue, &fmt);

   662         */

   663         FormatFatDrive(TheFs, CurrentDrive(), ETrue);

   664     }

   665 

   666 

   667 LOCAL_C void MakeVeryLongName(TFileName& aLong)

   668 //

   669 // appends a very long file name to aLong

   670 //

   671 	{

   672 	// create a name to take up 18 vfat entries - (1 sector + 2 entries)

   673 	for(TInt i=0;i<234;++i)

   674 		{

   675 		TInt c='a'+i%26;

   676 		aLong.Append(c);

   677 		}

   678 	}

   679 

   680 LOCAL_C void MakeEntryName(TFileName& aName,TInt aLength)

   681 //

   682 // Appends aLength characters to aName

   683 //

   684 	{

   685 	for(TInt i=0;i<aLength;++i)

   686 		{

   687 		TInt c='A'+i%26;

   688 		aName.Append(c);

   689 		}

   690 	}

   691 

   692 LOCAL_C void FillUpRootDir(TInt aFree=0)

   693 //

   694 // Fill up root directory

   695 //

   696 	{

   697 	TInt maxRootEntries = gRootDirEntries -aFree;

   698 	TFileName dir=_L("\\??\\");

   699 	TInt count=0;

   700 	TInt entriesSoFar;

   701 	if(IsReset)

   702 		entriesSoFar=2+2+2+2; // \\t_scn32dr3.exe + \\sys + \\t_scn32dr3.log + \\f32-tst

   703 	else

   704 		entriesSoFar=0;

   705 	TInt r;

   706 	while(entriesSoFar<maxRootEntries)

   707 		{

   708 		dir[1]=TUint16(count/26+'a');

   709 		dir[2]=TUint16(count%26+'a');

   710 		r=TheFs.MkDir(dir);

   711 		test(r==KErrNone);

   712 		entriesSoFar+=2;

   713 		++count;

   714 		}

   715 	}

   716 

   717 LOCAL_C void UnFillUpRootDir(TInt aFree=0)

   718 //

   719 // Reverse changes from FillUpRootDir()

   720 //

   721 	{

   722 	TFileName dir=_L("\\??\\");

   723 	TInt entriesSoFar=gRootDirEntries -aFree;

   724 	TInt count=0;

   725 	TInt r;

   726 	TInt existing;

   727 	if(IsReset)

   728 		existing=2+2+2+2; // \\t_scn32dr3.exe + \\sys + \\t_scn32dr3.log + \\f32-tst

   729 	else

   730 		existing=0;

   731 	while(entriesSoFar>existing)

   732 		{

   733 		dir[1]=TUint16(count/26+'a');

   734 		dir[2]=TUint16(count%26+'a');

   735 		r=TheFs.RmDir(dir);

   736 		test(r==KErrNone);

   737 		entriesSoFar-=2;

   738 		++count;

   739 		}

   740 	}

   741 

   742 void InitialiseWriteBuffer(TDes8& buf)

   743 //

   744 //

   745 //

   746 	{

   747 	for(TInt i=0;i<buf.Length();++i)

   748 		buf[i]=(TUint8)('a'+i%26);

   749 	}

   750 

   751 LOCAL_C TBool EntryExists(const TDesC& aName)	

   752 //

   753 // Returns ETrue if aName is found

   754 //

   755 	{

   756 	TEntry entry;

   757 	TInt r=TheFs.Entry(aName,entry);

   758 	test(r==KErrNone||r==KErrNotFound);

   759 	return(r==KErrNone?(TBool)ETrue:(TBool)EFalse);

   760 	}

   761 

   762 LOCAL_C TInt EntriesPerFatSector()

   763 //

   764 // Returns number of entries in one fat table sector

   765 //

   766 	{

   767 	switch (gDiskType)

   768 		{

   769 		case EFat32:

   770 			return(BootSector.BytesPerSector()/4);

   771 		case EFat16:

   772 			return(BootSector.BytesPerSector()/2);

   773 		case EFat12:

   774 			return(BootSector.BytesPerSector()*2/3);

   775 		default:

   776 			test(0);

   777 		}

   778 	return -1;

   779 	}

   780 

   781 LOCAL_C TBool OneEntryExists(const TDesC& aOldName,const TDesC& aNewName)

   782 //

   783 // Returns ETrue if only one of two entries exists

   784 //

   785 	{

   786 	TBool oldExists=EntryExists(aOldName);

   787 	TBool newExists=EntryExists(aNewName);

   788 	return((!oldExists&&newExists)||(oldExists&&!newExists));

   789 	}

   790 

   791 LOCAL_C void GetEntryDetails(const TDesC& aName,TEntry& aEntry)

   792 //

   793 // returns entry details for the entry with aName

   794 //

   795 	{

   796 	TInt r=TheFs.Entry(aName,aEntry);

   797 	test(r==KErrNone);

   798 	}

   799 

   800 LOCAL_C TBool IsSameEntryDetails(TEntry aOldEntry,TEntry aNewEntry)

   801 //

   802 // 

   803 //

   804 	{

   805 	return(aOldEntry.iAtt==aNewEntry.iAtt&&aOldEntry.iSize==aNewEntry.iSize&&aOldEntry.iModified==aNewEntry.iModified);

   806 	}

   807 

   808 LOCAL_C void CreateAlternate(const TDesC& aNameOne,const TDesC& aNameTwo)

   809 //

   810 // Creates altenate entries which take up one sector of fat table.

   811 // By subsequently deleting  one of these entries a new entry can be made 

   812 // with cluster chain that is not contiguous.

   813 //

   814 	{

   815 	TInt entries=EntriesPerFatSector();

   816 	RFile file1,file2;

   817 	TInt size1,size2;

   818 	size1=size2=0;

   819 	TInt r=file1.Create(TheFs,aNameOne,EFileShareAny);

   820 	test(r==KErrNone);

   821 	r=file2.Create(TheFs,aNameTwo,EFileShareAny);

   822 	test(r==KErrNone);

   823 	// one entry for file1 for every 40 entries for file2

   824 	// if file 1 subseqently deleted then 7 entries available

   825 	// in that fat sector - ~3.5kb file size - for fat16

   826 	TInt ratio=40;

   827 	TBool first=ETrue;

   828 	while(entries>0)

   829 		{

   830 		if(first)

   831 			{

   832 			size1+=gBytesPerCluster;

   833 			r=file1.SetSize(size1);

   834 			test(r==KErrNone);

   835 			first=EFalse;

   836 			--entries;

   837 			}

   838 		else

   839 			{

   840 			size2+=gBytesPerCluster*ratio;

   841 			r=file1.SetSize(size1);

   842 			test(r==KErrNone);

   843 			first=ETrue;

   844 			entries-=ratio;

   845 			}

   846 		}

   847 	file1.Close();

   848 	file2.Close();

   849 	}

   850 

   851 LOCAL_C TInt ThrottleDirEntries(TInt aDirEntries)

   852 	{

   853 	// throttle the number of entries needed, since for large cluster

   854 	// sizes, this can take forever (eg 2GB card -> a cluster size of 32K

   855 	// -> 1024 entries per cluster

   856 	const TInt KMaxDirEntries = 2048;

   857 	if (aDirEntries > KMaxDirEntries)

   858 		{

   859 		RDebug::Print(_L("Reducing directory entries from %d to %d"), 

   860 			aDirEntries, KMaxDirEntries);

   861 		aDirEntries = KMaxDirEntries;

   862 		}

   863 	return aDirEntries;

   864 	}

   865 

   866 

   867 LOCAL_C void CleanDirectory(const TDesC& aName,TInt aClusters)

   868 //

   869 // Removes entries in the directory

   870 //

   871 	{

   872 	if (aClusters < 1)

   873 		return;

   874 	TInt entriesPerCluster=gBytesPerCluster/32;

   875 	TInt entriesNeeded = entriesPerCluster * aClusters;

   876 

   877 	entriesNeeded = ThrottleDirEntries(entriesNeeded);

   878 

   879 	TInt maxFileNameLen = 250 - aName.Length();

   880 	TInt nameEntries = 1 + (maxFileNameLen+12) / 13;

   881 	TInt namesNeeded = (entriesNeeded + nameEntries-1) / nameEntries;

   882 	TInt entry = 0;

   883 	for(TInt i = 0; i < namesNeeded; ++i)

   884 		{

   885 		if (entriesNeeded - entry < nameEntries)

   886 			maxFileNameLen = (entriesNeeded - entry - 1) * 13;

   887 		TFileName fn;

   888 		fn.AppendNum(entry);

   889 		fn.Append('_');

   890 		while (fn.Length() < maxFileNameLen)

   891 			fn.Append('0');

   892 		TFileName fullName(aName);

   893 		fullName.Append(fn);

   894 		TInt r = TheFs.Delete(fullName);

   895 		test(r == KErrNone);

   896 		entry += 1 + (fn.Length() + 12) / 13;

   897 		}

   898 	RDebug::Print(_L("CleanDirectory(%S, %d)"), &aName, aClusters);

   899 	}

   900 

   901 LOCAL_C void ExpandDirectory(const TDesC& aName,TInt aClusters)

   902 //

   903 // Expands the directory by aClusters

   904 //

   905 	{

   906 	if (aClusters < 1)

   907 		return;

   908 	TInt entriesPerCluster=gBytesPerCluster/32;

   909 	TInt entriesNeeded = entriesPerCluster * aClusters;

   910 

   911 	entriesNeeded = ThrottleDirEntries(entriesNeeded);

   912 

   913 	TInt maxFileNameLen = 250 - aName.Length();

   914 	TInt nameEntries = 1 + (maxFileNameLen+12) / 13;

   915 	TInt namesNeeded = (entriesNeeded + nameEntries-1) / nameEntries;

   916 	TInt entry = 0;

   917 	for(TInt i = 0; i < namesNeeded; ++i)

   918 		{

   919 		if (entriesNeeded - entry < nameEntries)

   920 			maxFileNameLen = (entriesNeeded - entry - 1) * 13;

   921 		TFileName fn;

   922 		fn.AppendNum(entry);

   923 		fn.Append('_');

   924 		while (fn.Length() < maxFileNameLen)

   925 			fn.Append('0');

   926 		TFileName fullName(aName);

   927 		fullName.Append(fn);

   928 		RFile file;

   929 		TInt r = file.Create(TheFs,fullName,EFileShareAny);

   930 		test(r == KErrNone);

   931 		file.Close();

   932 		entry += 1 + (fn.Length() + 12) / 13;

   933 		}

   934 	// to leave a directory expanded by aClusters but with no additional entries

   935 	RDebug::Print(_L("ExpandDirectory(%S, %d)"), &aName, aClusters);

   936 	CleanDirectory(aName,aClusters);

   937 	}

   938 

   939 LOCAL_C TInt DeleteAlternateEntry(const TDesC& aName,TBool aIsDir)

   940 //

   941 // Deletes entry aName and corresponding entries created for EChainAlternate

   942 //

   943 	{

   944 	TInt r=TheFs.Delete(_L("\\fat\\file2"));

   945 	test(r==KErrNone||KErrNotFound);

   946 	if(aIsDir)

   947 		return(TheFs.RmDir(aName));

   948 	else

   949 		return(TheFs.Delete(aName));

   950 	}

   951 

   952 LOCAL_C TInt CreateAlternateEntry(const TDesC& aName,TBool aIsDir,TInt aSize)

   953 //

   954 // Creates entry with aName where cluster chain grows forward but not contiguously.

   955 // Assumes that no holes in fat clusters.

   956 //

   957 	{

   958 	TInt r=DeleteAlternateEntry(aName,aIsDir);

   959 	test(r==KErrNone||r==KErrNotFound);

   960 	RFile file;

   961 	if(aIsDir)

   962 		{

   963 		r=TheFs.MkDir(aName);

   964 		if(r!=KErrNone)

   965 			return(r);

   966 		}

   967 	else

   968 		{

   969 		r=file.Create(TheFs,aName,EFileShareAny);

   970 		if(r!=KErrNone)

   971 			return(r);

   972 		r=file.SetSize(1); //ensure file allocated a start cluster

   973 		test(r==KErrNone);

   974 		}

   975 	CreateAlternate(_L("\\fat\\file1"),_L("\\fat\\file2"));

   976 	r=TheFs.Delete(_L("\\fat\\file1"));

   977 	test(r==KErrNone);

   978 	if(aIsDir)

   979 		ExpandDirectory(aName,aSize);

   980 	else

   981 		{

   982 		r=file.SetSize(aSize);

   983 		test(r==KErrNone);

   984 		file.Close();

   985 		}

   986 	return(KErrNone);

   987 	}

   988 

   989 LOCAL_C TInt DeleteForwardEntry(const TDesC& aName,TBool aIsDir)

   990 //

   991 // Deletes entry with aName and corresponding entries created for EChainForward

   992 //

   993 	{

   994 	TInt r=TheFs.Delete(_L("\\fat\\file2"));

   995 	test(r==KErrNone||r==KErrNotFound);

   996 	r=TheFs.Delete(_L("\\fat\\file4"));

   997 	test(r==KErrNone||r==KErrNotFound);

   998 	r=TheFs.Delete(_L("\\fat\\file5"));

   999 	test(r==KErrNone||r==KErrNotFound);

  1000 	if(aIsDir)

  1001 		r=TheFs.RmDir(aName);

  1002 	else

  1003 		r=TheFs.Delete(aName);

  1004 	return r;

  1005 	}

  1006 	

  1007 LOCAL_C TInt CreateForwardEntry(const TDesC& aName,TBool aIsDir,TInt aSize)

  1008 //

  1009 // Creates an entry whose cluster chain first goes forward (upto 3.5kb for fat16 file)

  1010 // and then backwards

  1011 //	

  1012 	{

  1013 	TInt r=DeleteForwardEntry(aName,aIsDir);

  1014 	test(r==KErrNone||r==KErrNotFound);

  1015 	RFile file1,file2,entry;

  1016 	r=file1.Create(TheFs,_L("\\fat\\file1"),EFileShareAny);

  1017 	test(r==KErrNone);

  1018 	r=file1.SetSize(EntriesPerFatSector()*gBytesPerCluster);

  1019 	test(r==KErrNone);

  1020 	r=file2.Create(TheFs,_L("\\fat\\file2"),EFileShareAny);

  1021 	test(r==KErrNone);

  1022 	r=file2.SetSize(EntriesPerFatSector()*gBytesPerCluster);

  1023 	test(r==KErrNone);

  1024 	if(aIsDir)

  1025 		{

  1026 		r=TheFs.MkDir(aName);

  1027 		if(r!=KErrNone)

  1028 			return(r);

  1029 		}

  1030 	else

  1031 		{

  1032 		r=entry.Create(TheFs,aName,EFileShareAny);

  1033 		if(r!=KErrNone)

  1034 			return(r);

  1035 		r=entry.SetSize(1);	// ensure entry has start cluster allocated

  1036 		test(r==KErrNone);

  1037 		}

  1038 	CreateAlternate(_L("\\fat\\file3"),_L("\\fat\\file4"));

  1039 	RFile file5;

  1040 	r=file5.Create(TheFs,_L("\\fat\\file5"),EFileShareAny);

  1041 	test(r==KErrNone);

  1042 	r=file5.SetSize(EntriesPerFatSector()*gBytesPerCluster*2);

  1043 	test(r==KErrNone);

  1044 	file1.Close();

  1045 	file2.Close();

  1046 	file5.Close();

  1047 	r=TheFs.Delete(_L("\\fat\\file1"));

  1048 	test(r==KErrNone);

  1049 	r=TheFs.Delete(_L("\\fat\\file3"));

  1050 	test(r==KErrNone);

  1051 	if(aIsDir)

  1052 		ExpandDirectory(aName,aSize);

  1053 	else

  1054 		{

  1055 		r=entry.SetSize(aSize);

  1056 		test(r==KErrNone);

  1057 		entry.Close();

  1058 		}

  1059 	return(KErrNone);

  1060 	}

  1061 

  1062 LOCAL_C TInt DeleteBackwardEntry(const TDesC& aName,TBool aIsDir)

  1063 //

  1064 // Deletes entry with aName and corresponding entries created for EChainBackwards

  1065 //

  1066 	{

  1067 	TInt r=TheFs.Delete(_L("\\fat\\file2"));

  1068 	test(r==KErrNone||r==KErrNotFound);

  1069 	r=TheFs.Delete(_L("\\fat\\file3"));

  1070 	test(r==KErrNone||r==KErrNotFound);

  1071 	if(aIsDir)

  1072 		r=TheFs.RmDir(aName);

  1073 	else

  1074 		r=TheFs.Delete(aName);

  1075 	return r;

  1076 	}

  1077 

  1078 LOCAL_C TInt CreateBackwardEntry(const TDesC& aName,TBool aIsDir,TInt aSize)

  1079 //

  1080 // Creates an entry whose fat cluster chain first goes backwards(upto 3.5kb for fat16 file)

  1081 // and then forwards

  1082 //

  1083 	{

  1084 	TInt r=DeleteBackwardEntry(aName,aIsDir);

  1085 	test(r==KErrNone||r==KErrNotFound);

  1086 	CreateAlternate(_L("\\fat\\file1"),_L("\\fat\\file2"));

  1087 	RFile entry;

  1088 	if(aIsDir)

  1089 		{

  1090 		r=TheFs.MkDir(aName);

  1091 		if(r!=KErrNone)

  1092 			return(r);

  1093 		}

  1094 	else

  1095 		{

  1096 		r=entry.Create(TheFs,aName,EFileShareAny);

  1097 		if(r!=KErrNone)

  1098 			return(r);

  1099 		r=entry.SetSize(1);

  1100 		test(r==KErrNone);

  1101 		}

  1102 	RFile file3;

  1103 	r=file3.Create(TheFs,_L("\\fat\\file3"),EFileShareAny);

  1104 	test(r==KErrNone);

  1105 	r=file3.SetSize(EntriesPerFatSector()*gBytesPerCluster);

  1106 	test(r==KErrNone);

  1107 	r=TheFs.Delete(_L("\\fat\\file1"));

  1108 	test(r==KErrNone);

  1109 	file3.Close();

  1110 	if(aIsDir)

  1111 		ExpandDirectory(aName,aSize);

  1112 	else

  1113 		{

  1114 		r=entry.SetSize(aSize);

  1115 		test(r==KErrNone);

  1116 		entry.Close();

  1117 		}

  1118 	return(KErrNone);	

  1119 	}

  1120 

  1121 LOCAL_C TInt DeleteStdEntry(const TDesC& aName,TBool aIsDir)

  1122 //

  1123 // Deletes entry with aName

  1124 //

  1125 	{

  1126 	if(aIsDir)

  1127 		return(TheFs.RmDir(aName));

  1128 	else

  1129 		return(TheFs.Delete(aName));

  1130 	}

  1131 

  1132 LOCAL_C TInt CreateStdEntry(const TDesC& aName,TBool aIsDir,TInt aSize)

  1133 //

  1134 // Creates entry with aName where the cluster chain grows contiguously