1 // Copyright (c) 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 // e32test/mmu/t_shbuf.cpp

    15 //

    16 

    17 #define __E32TEST_EXTENSION__

    18 

    19 #include <e32test.h>

    20 #include <hal.h>

    21 #include <e32svr.h>

    22 #include <u32hal.h>

    23 #include "d_shbuf.h"

    24 #include <e32shbuf.h>

    25 #include <e32def.h>

    26 #include <e32def_private.h>

    27 

    28 RTest test(_L("T_SHBUF"));

    29 

    30 RShPool P1; // User-side pool

    31 RShPool P2; // Kernel-side pool

    32 

    33 const TInt KTestPoolSizeInBytes = 1 << 20; // 1MB

    34 const TInt BufferSize[] = {128, 853, 4096, 5051, 131072, 1, 0}; // Last element must be 0

    35 

    36 const TInt* PtrBufSize;

    37 

    38 RShBufTestChannel Ldd;

    39 

    40 _LIT(KTestSlave, "SLAVE");

    41 _LIT(KTestLowSpaceSemaphore, "LowSpaceSemaphore");

    42 

    43 enum TTestSlave

    44 	{

    45 	ETestSlaveError,

    46 	ETestSlaveNoDeallocation,

    47 	};

    48 

    49 enum TTestPoolType

    50 	{

    51 	ETestNonPageAligned,

    52 	ETestPageAligned,

    53 	ETestPageAlignedGrowing,

    54 	};

    55 

    56 TInt Log2(TInt aNum)

    57 	{

    58 	TInt res = -1;

    59 	while(aNum)

    60 		{

    61 		res++;

    62 		aNum >>= 1;

    63 		}

    64 	return res;

    65 	}

    66 

    67 TInt RoundUp(TInt aNum, TInt aAlignmentLog2)

    68 	{

    69 	if (aNum % (1 << aAlignmentLog2) == 0)

    70 		{

    71 		return aNum;

    72 		}

    73 	return (aNum & ~((1 << aAlignmentLog2) - 1)) + (1 << aAlignmentLog2);

    74 	}

    75 

    76 void LoadDeviceDrivers()

    77 	{

    78 	TInt r;

    79 	#ifdef TEST_CLIENT_THREAD

    80 	r= User::LoadLogicalDevice(_L("D_SHBUF_CLIENT.LDD"));

    81 	if (r != KErrAlreadyExists)

    82 		{

    83 		test_KErrNone(r);

    84 		}

    85 	#else

    86 	r = User::LoadLogicalDevice(_L("D_SHBUF_OWN.LDD"));

    87 	if (r != KErrAlreadyExists)

    88 		{

    89 		test_KErrNone(r);

    90 		}

    91 	#endif

    92 	}

    93 

    94 void FreeDeviceDrivers()

    95 	{

    96 	TInt r = User::FreeLogicalDevice(KTestShBufClient);

    97 	test_KErrNone(r);

    98 	r = User::FreeLogicalDevice(KTestShBufOwn);

    99 	test_KErrNone(r);

   100 	}

   101 

   102 void FillShBuf(RShBuf& aBuffer, TUint8 aValue)

   103 	{

   104 	TUint size = aBuffer.Size();

   105 	TUint8* base = aBuffer.Ptr();

   106 	test(size!=0);

   107 	test(base!=0);

   108 	memset(base,aValue,size);

   109 	}

   110 

   111 TBool CheckFillShBuf(RShBuf& aBuffer, TUint8 aValue)

   112 	{

   113 	TUint size = aBuffer.Size();

   114 	TUint8* base = aBuffer.Ptr();

   115 	test(size!=0);

   116 	test(base!=0);

   117 	TUint8* ptr = base;

   118 	TUint8* end = ptr+size;

   119 	while(ptr<end)

   120 		{

   121 		TUint8 b = *ptr++;

   122 		if(b!=aValue)

   123 			{

   124 			RDebug::Printf("CheckFillShBuf failed at offset 0x%x, expected 0x%02x but got 0x%02x ",ptr-base-1,aValue,b);

   125 			return EFalse;

   126 			}

   127 		}

   128 	return ETrue;

   129 	}

   130 

   131 TBool CheckNotFillShBuf(RShBuf& aBuffer, TUint8 aValue)

   132 	{

   133 	TUint size = aBuffer.Size();

   134 	TUint8* base = aBuffer.Ptr();

   135 	test(size!=0);

   136 	test(base!=0);

   137 	TUint8* ptr = base;

   138 	TUint8* end = ptr+size;

   139 	while(ptr<end)

   140 		{

   141 		TUint8 b = *ptr++;

   142 		if(b==aValue)

   143 			{

   144 			RDebug::Printf("CheckNotFillShBuf failed at offset 0x%x, expected not 0x%02x",ptr-base-1,aValue);

   145 			return EFalse;

   146 			}

   147 		}

   148 	return ETrue;

   149 	}

   150 

   151 /*

   152 @SYMTestCaseID				1

   153 @SYMTestCaseDesc			Create pool from user-side

   154 @SYMREQ						REQ11423

   155 @SYMTestActions

   156 	1. Test Thread creates a pool (P1) and passes handle to device driver.

   157 	2. Device driver opens pool and checks its attributes.

   158 @SYMTestExpectedResults

   159 	All OK.

   160 @SYMTestPriority			Critical

   161 */

   162 

   163 void CreateUserPool(TTestPoolType aPoolType)

   164 	{

   165 	test.Next(_L("Create user-side pool"));

   166 	TInt r;

   167 	TInt pagesize;

   168 	r = HAL::Get(HAL::EMemoryPageSize, pagesize);

   169 	test_KErrNone(r);

   170 

   171 	switch (aPoolType)

   172 		{

   173 		case ETestNonPageAligned:

   174 		// Non-page-aligned pool

   175 			{

   176 			test.Printf(_L("Non-page-aligned\n"));

   177 			test_Equal(0, P1.Handle());

   178 			TShPoolCreateInfo inf(TShPoolCreateInfo::ENonPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs, 8);

   179 			r = P1.Create(inf,KDefaultPoolHandleFlags);

   180 			test_KErrNone(r);

   181 

   182 			r = P1.SetBufferWindow(-1, ETrue);

   183 			test_Equal(KErrNotSupported, r);

   184 

   185 			TShPoolInfo poolinfotokernel;

   186 			poolinfotokernel.iBufSize = *PtrBufSize;

   187 			poolinfotokernel.iInitialBufs = KTestPoolSizeInBufs;

   188 			poolinfotokernel.iMaxBufs = KTestPoolSizeInBufs;

   189 			poolinfotokernel.iGrowTriggerRatio = 0;

   190 			poolinfotokernel.iGrowByRatio = 0;

   191 			poolinfotokernel.iShrinkHysteresisRatio = 0;

   192 			poolinfotokernel.iAlignment = 8;

   193 			poolinfotokernel.iFlags = EShPoolNonPageAlignedBuffer;

   194 			r = Ldd.OpenUserPool(P1.Handle(), poolinfotokernel);

   195 			test_KErrNone(r);

   196 

   197 			TShPoolInfo poolinfo;

   198 			P1.GetInfo(poolinfo);

   199 			test_Equal(*PtrBufSize, poolinfo.iBufSize);

   200 			test_Equal(KTestPoolSizeInBufs, poolinfo.iInitialBufs);

   201 			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

   202 			test_Equal(0, poolinfo.iGrowTriggerRatio);

   203 			test_Equal(0, poolinfo.iGrowByRatio);

   204 			test_Equal(0, poolinfo.iShrinkHysteresisRatio);

   205 			test_Equal(8, poolinfo.iAlignment);

   206 			test(poolinfo.iFlags & EShPoolNonPageAlignedBuffer);

   207 			test(!(poolinfo.iFlags & EShPoolPageAlignedBuffer));

   208 			break;

   209 			}

   210 		case ETestPageAligned:

   211 		// Page-aligned pool

   212 			{

   213 			test.Printf(_L("Page-aligned\n"));

   214 			test_Equal(0, P1.Handle());

   215 

   216 			TShPoolCreateInfo inf(TShPoolCreateInfo::EPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs);

   217 			r = P1.Create(inf,KDefaultPoolHandleFlags);

   218 			test_KErrNone(r);

   219 

   220 			r = P1.SetBufferWindow(-1, ETrue);

   221 			test_KErrNone(r);

   222 

   223 			TShPoolInfo poolinfo;

   224 			P1.GetInfo(poolinfo);

   225 			test_Equal(*PtrBufSize, poolinfo.iBufSize);

   226 			test_Equal(KTestPoolSizeInBufs, poolinfo.iInitialBufs);

   227 			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

   228 			test_Equal(0, poolinfo.iGrowTriggerRatio);

   229 			test_Equal(0, poolinfo.iGrowByRatio);

   230 			test_Equal(0, poolinfo.iShrinkHysteresisRatio);

   231 			test_Equal(Log2(pagesize), poolinfo.iAlignment);

   232 			test(poolinfo.iFlags & EShPoolPageAlignedBuffer);

   233 			test(!(poolinfo.iFlags & EShPoolNonPageAlignedBuffer));

   234 

   235 			r = Ldd.OpenUserPool(P1.Handle(), poolinfo);

   236 			test_KErrNone(r);

   237 			break;

   238 			}

   239 		case ETestPageAlignedGrowing:

   240 		// Page-aligned growing pool

   241 			{

   242 			test.Printf(_L("Page-aligned growing\n"));

   243 			test_Equal(0, P1.Handle());

   244 

   245 			TShPoolCreateInfo inf(TShPoolCreateInfo::EPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs / 2);

   246 			// Set shrink hysteresis high so pool can't shrink

   247 			r = inf.SetSizingAttributes(KTestPoolSizeInBufs, 25, 26, 25600);

   248 			test_KErrNone(r);

   249 			r = P1.Create(inf,KDefaultPoolHandleFlags);

   250 			test_KErrNone(r);

   251 

   252 			r = P1.SetBufferWindow(-1, ETrue);

   253 			test_KErrNone(r);

   254 

   255 			TShPoolInfo poolinfo;

   256 			P1.GetInfo(poolinfo);

   257 			test_Equal(*PtrBufSize, poolinfo.iBufSize);

   258 			test_Equal(KTestPoolSizeInBufs / 2, poolinfo.iInitialBufs);

   259 			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

   260 			test_Equal(25, poolinfo.iGrowTriggerRatio);

   261 			test_Equal(26, poolinfo.iGrowByRatio);

   262 			test_Equal(25600, poolinfo.iShrinkHysteresisRatio);

   263 			test_Equal(Log2(pagesize), poolinfo.iAlignment);

   264 			test(poolinfo.iFlags & EShPoolPageAlignedBuffer);

   265 			test(!(poolinfo.iFlags & EShPoolNonPageAlignedBuffer));

   266 

   267 			r = Ldd.OpenUserPool(P1.Handle(), poolinfo);

   268 			test_KErrNone(r);

   269 			break;

   270 			}

   271 		default:

   272 			test(EFalse);

   273 		}

   274 	}

   275 

   276 /*

   277 @SYMTestCaseID				2

   278 @SYMTestCaseDesc			Create pool from kernel-side

   279 @SYMREQ						REQ11423

   280 @SYMTestActions

   281 	1. Device Driver creates a pool (P2) and passes handle to this thread.

   282 	2. Test Thread opens pool and checks its attributes.

   283 @SYMTestExpectedResults

   284 	1. Ok.

   285 	2. Ok.

   286 @SYMTestPriority			Critical

   287 */

   288 

   289 void CreateKernelPool(TTestPoolType aPoolType)

   290 	{

   291 	test.Next(_L("Create kernel-side pool"));

   292 	TInt r;

   293 	TInt pagesize;

   294 	r = HAL::Get(HAL::EMemoryPageSize, pagesize);

   295 	test_KErrNone(r);

   296 	TInt handle;

   297 

   298 	switch (aPoolType)

   299 		{

   300 		case ETestNonPageAligned:

   301 		// Non-page-aligned pool

   302 			{

   303 			test.Printf(_L("Non-page-aligned\n"));

   304 			test_Equal(0, P2.Handle());

   305 

   306 			TShPoolCreateInfo inf(TShPoolCreateInfo::ENonPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs, 8);

   307 			r = Ldd.OpenKernelPool(inf, handle);

   308 			test_KErrNone(r);

   309 			P2.SetHandle(handle);

   310 

   311 			TShPoolInfo poolinfo;

   312 			P2.GetInfo(poolinfo);

   313 			test_Equal(*PtrBufSize, poolinfo.iBufSize);

   314 			test_Equal(KTestPoolSizeInBufs, poolinfo.iInitialBufs);

   315 			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

   316 			test_Equal(0, poolinfo.iGrowTriggerRatio);

   317 			test_Equal(0, poolinfo.iGrowByRatio);

   318 			test_Equal(0, poolinfo.iShrinkHysteresisRatio);

   319 			test_Equal(8, poolinfo.iAlignment);

   320 			test(poolinfo.iFlags & EShPoolNonPageAlignedBuffer);

   321 			test(!(poolinfo.iFlags & EShPoolPageAlignedBuffer));

   322 			break;

   323 			}

   324 		case ETestPageAligned:

   325 		// Page-aligned pool

   326 			{

   327 			test.Printf(_L("Page-aligned\n"));

   328 			test_Equal(0, P2.Handle());

   329 

   330 			TShPoolCreateInfo inf(TShPoolCreateInfo::EPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs);

   331 			r = Ldd.OpenKernelPool(inf, handle);

   332 			test_KErrNone(r);

   333 			P2.SetHandle(handle);

   334 

   335 			r = P2.SetBufferWindow(-1, ETrue);

   336 			test_KErrNone(r);

   337 

   338 			TShPoolInfo poolinfo;

   339 			P2.GetInfo(poolinfo);

   340 			test_Equal(*PtrBufSize, poolinfo.iBufSize);

   341 			test_Equal(KTestPoolSizeInBufs, poolinfo.iInitialBufs);

   342 			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

   343 			test_Equal(0, poolinfo.iGrowTriggerRatio);

   344 			test_Equal(0, poolinfo.iGrowByRatio);

   345 			test_Equal(0, poolinfo.iShrinkHysteresisRatio);

   346 			test_Equal(Log2(pagesize), poolinfo.iAlignment);

   347 			test(poolinfo.iFlags & EShPoolPageAlignedBuffer);

   348 			test(!(poolinfo.iFlags & EShPoolNonPageAlignedBuffer));

   349 			break;

   350 			}

   351 		case ETestPageAlignedGrowing:

   352 		// Page-aligned pool growing

   353 			{

   354 			test.Printf(_L("Page-aligned growing\n"));

   355 			test_Equal(0, P2.Handle());

   356 

   357 			TShPoolCreateInfo inf(TShPoolCreateInfo::EPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs / 2);

   358 			// Set shrink hysteresis high so pool can't shrink

   359 			r = inf.SetSizingAttributes(KTestPoolSizeInBufs, 25, 26, 25600);

   360 			test_KErrNone(r);

   361 			r = Ldd.OpenKernelPool(inf, handle);

   362 			test_KErrNone(r);

   363 			P2.SetHandle(handle);

   364 

   365 			r = P2.SetBufferWindow(-1, ETrue);

   366 			test_KErrNone(r);

   367 

   368 			TShPoolInfo poolinfo;

   369 			P2.GetInfo(poolinfo);

   370 			test_Equal(*PtrBufSize, poolinfo.iBufSize);

   371 			test_Equal(KTestPoolSizeInBufs / 2, poolinfo.iInitialBufs);

   372 			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

   373 			test_Equal(25, poolinfo.iGrowTriggerRatio);

   374 			test_Equal(26, poolinfo.iGrowByRatio);

   375 			test_Equal(25600, poolinfo.iShrinkHysteresisRatio);

   376 			test_Equal(Log2(pagesize), poolinfo.iAlignment);

   377 			test(poolinfo.iFlags & EShPoolPageAlignedBuffer);

   378 			test(!(poolinfo.iFlags & EShPoolNonPageAlignedBuffer));

   379 			break;

   380 			}

   381 		default:

   382 			test(EFalse);

   383 		}

   384 	}

   385 

   386 /*

   387 @SYMTestCaseID				20

   388 @SYMTestCaseDesc			Close pool from kernel-side

   389 @SYMREQ						REQ11423

   390 @SYMTestActions

   391 	1. Device Driver closes P2.

   392 	2. Test Thread closes P2.

   393 @SYMTestExpectedResults

   394 	1. OK and Access Count is now 1.

   395 	2. OK

   396 @SYMTestPriority			Critical

   397 */

   398 

   399 void CloseKernelPool()

   400 	{

   401 	test.Next(_L("Close kernel-side pool"));

   402 	TInt r;

   403 

   404 	r = Ldd.CloseKernelPool();

   405 	test_KErrNone(r);

   406 

   407 	P2.Close();

   408 

   409 	// wait for memory to be freed

   410 	r = UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, (TAny*)5000, 0);

   411 	test_KErrNone(r);

   412 

   413 	}

   414 

   415 /*

   416 @SYMTestCaseID				21

   417 @SYMTestCaseDesc			Close pool from user-side

   418 @SYMREQ						REQ11423

   419 @SYMTestActions

   420 	1. Test Thread closes P1.

   421 	2. Device Driver closes P1.

   422 @SYMTestExpectedResults

   423 	1. OK and Access Count is now 1.

   424 	2. OK.

   425 @SYMTestPriority			Critical

   426 */

   427 

   428 void CloseUserPool()

   429 	{

   430 	test.Next(_L("Close user-side pool"));

   431 	TInt r;

   432 

   433 	P1.Close();

   434 

   435 	r = Ldd.CloseUserPool();

   436 	test_KErrNone(r);

   437 

   438 	// wait for memory to be freed

   439 	r = UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, (TAny*)5000, 0);

   440 	test_KErrNone(r);

   441 	}

   442 

   443 /*

   444 @SYMTestCaseID				3

   445 @SYMTestCaseDesc			Buffer allocation from user-side

   446 @SYMREQ						REQ11423

   447 @SYMTestActions

   448 	1. Test Thread creates a shared buffer on P1.

   449 	2. Test Thread passes buffer to Device Driver.

   450 	3. Device Driver obtains buffer and manipulates its contents.

   451 	4. Device Driver releases buffer.

   452 	5. Test Thread releases buffer.

   453 @SYMTestExpectedResults

   454 	1. Ok.

   455 	2. Ok.

   456 	3. Ok.

   457 	4. Ok.

   458 	5. Ok. Buffer de-allocated.

   459 @SYMTestPriority			Critical

   460 */

   461 

   462 void AllocateUserBuffer()

   463 	{

   464 	test.Next(_L("Allocate user-side buffer"));

   465 	TInt r;

   466 	RShBuf buf;

   467 

   468 	// Allocate buffer on POOL 1

   469 	__KHEAP_MARK;

   470 	r = buf.Alloc(P1);

   471 	test_KErrNone(r);

   472 	__KHEAP_CHECK(0);

   473 

   474 	TInt i;

   475 	TShPoolInfo poolinfo1;

   476 	P1.GetInfo(poolinfo1);

   477 	TInt blocks = poolinfo1.iBufSize / KTestData1().Length();

   478 

   479 	for (i = 0; i < blocks; i++)

   480 		{

   481 		TPtr8(buf.Ptr() + (i * KTestData1().Length()), KTestData1().Length(),KTestData1().Length()).Copy(KTestData1());

   482 		}

   483 	r = Ldd.ManipulateUserBuffer(buf.Handle());

   484 

   485 	test_KErrNone(r);

   486 

   487 	TBuf8<64> tmp;

   488 

   489 	P1.GetInfo(poolinfo1);

   490 	blocks = poolinfo1.iBufSize / tmp.MaxSize();

   491 

   492 	for (i = 0 ; i < blocks; i++)

   493 		{

   494 		tmp.Fill(i);

   495 		TPtrC8 ptrc(buf.Ptr() + (i * tmp.Length()), tmp.Length());

   496 		r = tmp.Compare(ptrc);

   497 		test_Equal(0, r);

   498 		}

   499 	buf.Close();

   500 	__KHEAP_MARKEND;

   501 

   502 	// Allocate buffer on POOL 2

   503 	__KHEAP_MARK;

   504 	r = buf.Alloc(P2);

   505 	test_KErrNone(r);

   506 	__KHEAP_CHECK(0);

   507 

   508 	TShPoolInfo poolinfo2;

   509 	P2.GetInfo(poolinfo2);

   510 	blocks = poolinfo2.iBufSize / KTestData1().Length(); // PC REMOVE

   511 

   512 	for (i = 0; i < blocks; i++)

   513 		{

   514 		TPtr8(buf.Ptr() + (i * KTestData1().Length()), KTestData1().Length(),KTestData1().Length()).Copy(KTestData1());

   515 		}

   516 

   517 	r = Ldd.ManipulateUserBuffer(buf.Handle());

   518 	test_KErrNone(r);

   519 

   520 	P2.GetInfo(poolinfo2);

   521 	blocks = poolinfo2.iBufSize / tmp.MaxSize(); // PC REMOVE

   522 

   523 	for (i = 0 ; i < blocks; i++)

   524 		{

   525 		tmp.Fill(i);

   526 		r = tmp.Compare(TPtr8(buf.Ptr() + (i * tmp.Length()), tmp.Length(), tmp.Length()));

   527 		test_Equal(0, r);

   528 		}

   529 	buf.Close();

   530 	__KHEAP_MARKEND;

   531 	}

   532 

   533 /*

   534 @SYMTestCaseID				4

   535 @SYMTestCaseDesc			Buffer allocation from kernel-side

   536 @SYMREQ						REQ11423

   537 @SYMTestActions

   538 	1. Device Driver creates a buffer on P2.

   539 	2. Device Driver manipulates buffer and passes it to Test Thread.

   540 	3. Test Thread manipulates buffer and send it back to Device Driver.

   541 	4. Device Driver check buffer's contents and releases it.

   542 @SYMTestExpectedResults

   543 	1. Ok.

   544 	2. Ok.

   545 	3. Ok.

   546 	4. Ok. Buffer de-allocated.

   547 @SYMTestPriority			Critical

   548 */

   549 

   550 void AllocateKernelBuffer()

   551 	{

   552 	test.Next(_L("Allocate kernel-side buffer"));

   553 	TInt r;

   554 	TInt handle;

   555 	RShBuf kbuf0, kbuf1;

   556 

   557 	// Allocate buffer on POOL 1

   558 	r = Ldd.AllocateKernelBuffer(0, handle);

   559 	test_KErrNone(r);

   560 	kbuf0.SetHandle(handle);

   561 

   562 	TInt i;

   563 	TShPoolInfo poolinfo1;

   564 	P1.GetInfo(poolinfo1);

   565 	TInt blocks = poolinfo1.iBufSize / KTestData2().Length();

   566 	for (i = 0; i < blocks; i++)

   567 		{

   568 		r = KTestData2().Compare(TPtr8(kbuf0.Ptr() + (i * KTestData2().Length()), KTestData2().Length(), KTestData2().Length()));

   569 

   570 		test_Equal(0, r);

   571 		}

   572 	kbuf0.Close();

   573 

   574 	// Allocate buffer on POOL 2

   575 	r = Ldd.AllocateKernelBuffer(1, handle);

   576 	test_KErrNone(r);

   577 	kbuf1.SetHandle(handle);

   578 

   579 	TShPoolInfo poolinfo2;

   580 	P2.GetInfo(poolinfo2);

   581 	blocks = poolinfo2.iBufSize / KTestData2().Length();

   582 

   583 	for (i = 0; i < blocks; i++)

   584 		{

   585 		r = KTestData2().Compare(TPtr8(kbuf1.Ptr() + (i * KTestData2().Length()), KTestData2().Length(), KTestData2().Length()));

   586 

   587 		test_Equal(0, r);

   588 		}

   589 	kbuf1.Close();

   590 	}

   591 

   592 

   593 /*

   594 @SYMTestCaseID				X1

   595 @SYMTestCaseDesc			Allocate maximum number of buffers in a pool (user/kernel)

   596 @SYMREQ						REQ11423

   597 @SYMTestActions

   598 	Allocate as many buffers on a pool as possible.

   599 	Free them all and re-allocate them again.

   600 	Free them all.

   601 @SYMTestExpectedResults

   602 	Ok.

   603 @SYMTestPriority			High

   604 */

   605 

   606 void AllocateUserMax(RShPool& aPool)

   607 	{

   608 	test.Next(_L("Exhaust pool memory from user-side"));

   609 	TInt r;

   610 

   611 	TShPoolInfo poolinfo;

   612 	aPool.GetInfo(poolinfo);

   613 	TBool aligned = (poolinfo.iFlags & EShPoolPageAlignedBuffer);

   614 	RDebug::Printf("aligned=%d",aligned);

   615 

   616 	RArray<RShBuf> bufarray;

   617 	do

   618 		{

   619 		RShBuf buf;

   620 		r = buf.Alloc(aPool);

   621 		if (r==KErrNoMemory && KTestPoolSizeInBufs>bufarray.Count())

   622 			{

   623 			// try again after a delay, to allow for background resource allocation

   624 			

   625 			User::After(1000000);

   626 			r = buf.Alloc(aPool);

   627 			}

   628 		if (!r)

   629 			{

   630 			r = bufarray.Append(buf);

   631 			test_KErrNone(r);

   632 			FillShBuf(buf,0x99);

   633 			}

   634 		}

   635 	while (r == KErrNone);

   636 	test_Equal(KErrNoMemory, r);

   637 	test_Compare(KTestPoolSizeInBufs, <=, bufarray.Count());

   638 

   639 	TInt n = bufarray.Count();

   640 	while (n)

   641 		{

   642 		bufarray[--n].Close();

   643 		}

   644 

   645 	User::After(500000);

   646 

   647 	// Do it once more

   648 	n = 0;

   649 	while (n<bufarray.Count())

   650 		{

   651 		r = bufarray[n].Alloc(aPool);

   652 		if (r==KErrNoMemory)

   653 			{

   654 			// try again after a delay, to allow for background resource allocation

   655 			User::After(1000000);

   656 			r = bufarray[n].Alloc(aPool);

   657 			}

   658 		test_Assert(r == KErrNone, test.Printf(_L("n=%d r=%d\n"), n, r));

   659 		if(aligned)

   660 			test(CheckNotFillShBuf(bufarray[n],0x99));

   661 		++n;

   662 		}

   663 

   664 	RShBuf extrabuf;

   665 	r = extrabuf.Alloc(aPool);

   666 	test_Equal(KErrNoMemory, r);

   667 

   668 	while (n)

   669 		{

   670 		bufarray[--n].Close();

   671 		}

   672 

   673 	bufarray.Close();

   674 	}

   675 

   676 void AllocateKernelMax()

   677 	{

   678 	test.Next(_L("Exhaust pool memory from kernel-side"));

   679 	TInt r;

   680 	TInt allocated;

   681 	r = Ldd.AllocateMax(0, allocated); // P1

   682 	test_KErrNone(r);

   683 	test_Equal(KTestPoolSizeInBufs, allocated);

   684 	r = Ldd.AllocateMax(1, allocated); // P2

   685 	test_KErrNone(r);

   686 	test_Equal(KTestPoolSizeInBufs, allocated);

   687 	}

   688 

   689 

   690 /*

   691 @SYMTestCaseID				11

   692 @SYMTestCaseDesc			Buffer alignment (kernel/user)

   693 @SYMREQ						REQ11423

   694 @SYMTestActions

   695 	1. Test Thread creates several pools with different buffer alignment

   696 	   requirements:

   697 	2. Test Thread allocates buffers on all pools.

   698 	3. Test Thread frees all buffers and close pools.

   699 @SYMTestExpectedResults

   700 	1. Ok.

   701 	2. Buffers are aligned to the desired boundary.

   702 	3. Ok.

   703 @SYMTestPriority			High

   704 */

   705 

   706 void BufferAlignmentUser()

   707 	{

   708 	test.Next(_L("Buffer alignment (User)"));

   709 	TInt pagesize;

   710 	TInt r;

   711 	r = HAL::Get(HAL::EMemoryPageSize, pagesize);

   712 	test_KErrNone(r);

   713 

   714 	// Non page aligned buffers

   715 	TInt i;

   716 	for (i = 0; i <= Log2(pagesize); i++)

   717 		{

   718 		test.Printf(_L("."));

   719 		TShPoolCreateInfo inf(TShPoolCreateInfo::ENonPageAlignedBuffer, *PtrBufSize, 20, i); // TODO: Change minbufs back to 8 when the pool growing code works

   720 		RShPool pool;

   721 		r = pool.Create(inf,KDefaultPoolHandleFlags);

   722 		test_KErrNone(r);

   723 

   724 		TInt j;

   725 		RShBuf buf[20];

   726 		for (j = 0; j < 20; j++)

   727 			{

   728 			r = buf[j].Alloc(pool);

   729 			test_KErrNone(r);

   730 			}

   731 

   732 		TInt alignment = i;

   733 		if (alignment < KTestMinimumAlignmentLog2)

   734 			{

   735 			alignment = KTestMinimumAlignmentLog2;

   736 			}

   737 		for (j = 0; j < 20; j++)

   738 			{

   739 			test_Assert(!((TUint32) buf[j].Ptr() & ((1 << alignment) - 1)),

   740 				test.Printf(_L("Pool%d buf[%d].Base() == 0x%08x"), i, j, buf[j].Ptr()));

   741 			}

   742 

   743 		for (j = 0; j < 20; j++)

   744 			{

   745 			buf[j].Close();

   746 			}

   747 		pool.Close();

   748 		// delay to allow the management dfc to run and close pool

   749 		User::After(100000);

   750 		}

   751 	test.Printf(_L("\n"));

   752 

   753 	// Page aligned buffers

   754 	TShPoolCreateInfo inf(TShPoolCreateInfo::EPageAlignedBuffer, *PtrBufSize, 20); // TODO: Change minbufs back to 8 when the pool growing code works

   755 	RShPool pool;

   756 	r = pool.Create(inf,KDefaultPoolHandleFlags);

   757 	test_KErrNone(r);

   758 

   759 	r = pool.SetBufferWindow(-1, ETrue);

   760 	test_KErrNone(r);

   761 

   762 	TInt j;

   763 	RShBuf buf[20];

   764 	for (j = 0; j < 20; j++)

   765 		{

   766 		r = buf[j].Alloc(pool);

   767 		test_KErrNone(r);

   768 		}

   769 

   770 	for (j = 0; j < 20; j++)

   771 		{

   772 		test_Assert(!((TUint32) buf[j].Ptr() & (pagesize - 1)),

   773 					test.Printf(_L("buf[%d].Base() == 0x%08x"), j, buf[j].Ptr()));

   774 		}

   775 	for (j = 0; j < 20; j++)

   776 		{

   777 		buf[j].Close();

   778 		}

   779 	pool.Close();

   780 	}

   781 

   782 void BufferAlignmentKernel()

   783 	{

   784 	test.Next(_L("Buffer alignment (Kernel)"));

   785 	TInt r;

   786 

   787 	TInt pagesize;

   788 	r = HAL::Get(HAL::EMemoryPageSize, pagesize);

   789 	test_KErrNone(r);

   790 

   791 	for (TInt i = 0; i < Log2(pagesize); i++)

   792 		{

   793 		test.Printf(_L("."));

   794 		r = Ldd.BufferAlignmentKernel(*PtrBufSize, i);

   795 		test_KErrNone(r);

   796 		// delay to allow the management dfc to run

   797 		User::After(100000);

   798 		}

   799 	test.Printf(_L("\n"));

   800 	}

   801 

   802 /*

   803 @SYMTestCaseID				6

   804 @SYMTestCaseDesc			Create pool at specific physical address

   805 @SYMREQ						REQ11423

   806 @SYMTestActions

   807 	1. Device Driver allocates memory chunk.

   808 	2. Device Driver requests physical address of this memory chunk.

   809 	3. Device Driver creates pool at physical address of the memory chunk.

   810 	3. Device Driver allocate buffers on pool, free them and close pool.

   811 @SYMTestExpectedResults

   812 	1. Ok.

   813 	2. Ok.

   814 	3. Ok.

   815 	4. Ok

   816 @SYMTestPriority			High

   817 */

   818 

   819 void CreateKernelPoolPhysAddr()

   820 	{

   821 	test.Next(_L("Create pool at specific physical address"));

   822 	TInt r;

   823 	test.Start(_L("Contiguous physical memory"));

   824 	r = Ldd.CreatePoolPhysAddrCont(*PtrBufSize);

   825 	test_KErrNone(r);

   826 	test.Next(_L("Discontiguous physical memory"));

   827 	r = Ldd.CreatePoolPhysAddrNonCont(*PtrBufSize);

   828 	test_KErrNone(r);

   829 	test.End();

   830 	}

   831 

   832 /*

   833 @SYMTestCaseID				14

   834 @SYMTestCaseDesc			Buffer separation and overwrites

   835 @SYMREQ						REQ11423

   836 @SYMTestActions

   837 	1. Test Thread creates two pools:

   838 		- A pool with no guard pages.

   839 		- A pool with guard pages.

   840 	2. Allocate two buffers on each pool.

   841 	3. Test Thread creates Secondary Thread.

   842 	4. Secondary Thread starts reading contents of the first buffer and keep

   843 	   reading beyond its limits (using a pointer, not a descriptor).

   844 	5. Secondary Thread starts writing on the first buffer and keep writing beyond

   845 	   its limits (using a pointer, not a descriptor).

   846 	6. Free buffers and close pools.

   847 @SYMTestExpectedResults

   848 	1. Ok.

   849 	2. Ok.

   850 	3. Ok.

   851 	4. Secondary Thread panics when it attempts to read the guard page, if there

   852 	   is one. Otherwise, it moves on to the second buffer. (Secondary Thread will

   853 	   have to be restarted).

   854 	5. Secondary Thread panics when it attempts to write on the guard page if

   855 	   there is one. Otherwise, it carries on writing on to the second buffer.

   856 	6. Ok.

   857 @SYMTestPriority			High

   858 */

   859 

   860 TInt ThreadGuardPagesRead(TAny* aArg)

   861 	{

   862 	TUint8* ptr = (TUint8*) aArg;

   863 	if (ptr == NULL)

   864 		{

   865 		return KErrArgument;

   866 		}

   867 	TInt bufsize = *PtrBufSize;

   868 	TInt i;

   869 	TUint8 val = '$';

   870 	TBool isok = ETrue;

   871 	for (i = 0; i < bufsize; i++)

   872 		{

   873 		if (*(ptr + i) != val)

   874 			{

   875 			isok = EFalse;

   876 			}

   877 		}

   878 	if (!isok)

   879 		{

   880 		return KErrUnknown;

   881 		}

   882 	return KErrNone;

   883 	}

   884 

   885 TInt ThreadGuardPagesWrite(TAny* aArg)

   886 	{

   887 	TUint8* ptr = (TUint8*) aArg;

   888 	if (ptr == NULL)

   889 		{

   890 		return KErrArgument;

   891 		}

   892 	TInt bufsize = *PtrBufSize;

   893 	TInt i;

   894 	for (i = 0; i < bufsize; i++)

   895 		{

   896 		*(ptr + i) = '#';

   897 		}

   898 	return KErrNone;

   899 	}

   900 

   901 void GuardPages()

   902 	{

   903 	test.Next(_L("Guard pages"));

   904 	TInt pagesize;

   905 	TInt r;

   906 	r = HAL::Get(HAL::EMemoryPageSize, pagesize);

   907 	test_KErrNone(r);

   908 

   909 	// Create pools

   910 	RShPool pool1;

   911 	RShPool pool2;

   912 	TShPoolCreateInfo inf(TShPoolCreateInfo::EPageAlignedBuffer, *PtrBufSize, KTestPoolSizeInBufs);

   913 	r = pool1.Create(inf,KDefaultPoolHandleFlags);

   914 	test_KErrNone(r);

   915 

   916 	r = pool1.SetBufferWindow(-1, ETrue);

   917 	test_KErrNone(r);

   918 

   919 	r = inf.SetGuardPages();

   920 	test_KErrNone(r);

   921 	r = pool2.Create(inf,KDefaultPoolHandleFlags);

   922 	test_KErrNone(r);

   923 

   924 	r = pool2.SetBufferWindow(-1, ETrue);

   925 	test_KErrNone(r);

   926 

   927 	// Allocate buffers

   928 	RShBuf bufs1[KTestPoolSizeInBufs];

   929 	RShBuf bufs2[KTestPoolSizeInBufs];

   930 	TInt i;

   931 	for (i = 0; i < KTestPoolSizeInBufs; i++)

   932 		{

   933 		r = bufs1[i].Alloc(pool1);

   934 		test_Assert(r == KErrNone, test.Printf(_L("Pool1: i=%d r=%d\n"), i, r));

   935 		TPtr8 ptr(bufs1[i].Ptr(), bufs1[i].Size(),bufs1[i].Size());

   936 		ptr.Fill('$');

   937 		}

   938 	for (i = 0; i < KTestPoolSizeInBufs; i++)

   939 		{

   940 		r = bufs2[i].Alloc(pool2);

   941 		test_Assert(r == KErrNone, test.Printf(_L("Pool2: i=%d r=%d\n"), i, r));

   942 		TPtr8 ptr(bufs2[i].Ptr(), bufs1[i].Size(),bufs1[i].Size());

   943 		ptr.Fill('$');

   944 		}

   945 

   946 	_LIT(KTestThreadRead, "GuardPagesReadTS%dP%dB%d");

   947 	for (i = 0; i < KTestPoolSizeInBufs - 1; i++)

   948 		{

   949 		TBuf<40> threadname;

   950 		RThread thread;

   951 		TRequestStatus rs;

   952 

   953 		// 1. Simple read within buffer

   954 		// Pool 1

   955 		threadname.Format(KTestThreadRead, 1, 1, i);

   956 		r = thread.Create(threadname, ThreadGuardPagesRead, KDefaultStackSize, KMinHeapSize, KMinHeapSize,

   957 			(TAny*) bufs1[i].Ptr());

   958 		test_KErrNone(r);

   959 		thread.Logon(rs);

   960 		thread.Resume();

   961 		User::WaitForRequest(rs);

   962 		test_KErrNone(rs.Int());

   963 		test_Equal(EExitKill, thread.ExitType());

   964 		test_KErrNone(thread.ExitReason());

   965 		thread.Close();

   966 		// Pool 2

   967 		threadname.Format(KTestThreadRead, 1, 2, i);

   968 		r = thread.Create(threadname, ThreadGuardPagesRead, KDefaultStackSize, KMinHeapSize, KMinHeapSize,

   969 			(TAny*) bufs2[i].Ptr());

   970 		test_KErrNone(r);

   971 		thread.Logon(rs);

   972 		thread.Resume();

   973 		User::WaitForRequest(rs);

   974 		test_KErrNone(rs.Int());

   975 		test_Equal(EExitKill, thread.ExitType());

   976 		test_KErrNone(thread.ExitReason());

   977 		thread.Close();

   978 

   979 		// 2. If the buffer size is not a multiple of the MMU page size, it should be

   980 		// possible to read after the buffer end until the page boundary

   981 		if (*PtrBufSize % pagesize)

   982 			{

   983 			// Pool 1

   984 			threadname.Format(KTestThreadRead, 2, 1, i);

   985 			r = thread.Create(threadname, ThreadGuardPagesRead, KDefaultStackSize, KMinHeapSize, KMinHeapSize,

   986 				(TAny*) (bufs1[i].Ptr() + pagesize - *PtrBufSize % pagesize));

   987 			test_KErrNone(r);

   988 			thread.Logon(rs);

   989 			thread.Resume();

   990 			User::WaitForRequest(rs);

   991 			if (rs.Int() != KErrNone)

   992 				{

   993 				test_Equal(KErrUnknown, rs.Int());

   994 				test_Equal(KErrUnknown, thread.ExitReason());

   995 				}

   996 			test_Equal(EExitKill, thread.ExitType());

   997 			thread.Close();

   998 			// Pool 2

   999 			threadname.Format(KTestThreadRead, 2, 2, i);

  1000 			r = thread.Create(threadname, ThreadGuardPagesRead, KDefaultStackSize, KMinHeapSize, KMinHeapSize,

  1001 				(TAny*) (bufs2[i].Ptr() + pagesize - *PtrBufSize % pagesize));

  1002 			test_KErrNone(r);

  1003 			thread.Logon(rs);

  1004 			thread.Resume();

  1005 			User::WaitForRequest(rs);

  1006 			if (rs.Int() != KErrNone)

  1007 				{

  1008 				test_Equal(KErrUnknown, rs.Int());

  1009 				test_Equal(KErrUnknown, thread.ExitReason());

  1010 				}

  1011 			test_Equal(EExitKill, thread.ExitType());

  1012 			thread.Close();

  1013 			}

  1014 

  1015 		// 3. Now we attempt to read the first byte on the next page after the end of

  1016 		// our buffer.

  1017 		TInt offset;

  1018 		if (*PtrBufSize % pagesize)

  1019 			{

  1020 			offset = pagesize - *PtrBufSize % pagesize + 1;

  1021 			}

  1022 		else

  1023 			{

  1024 			offset = 1;

  1025 			}

  1026 		// Pool 1

  1027 		if (bufs1[i + 1].Ptr() == bufs1[i].Ptr() + RoundUp(*PtrBufSize, Log2(pagesize)))

  1028 			{

  1029 			// Only perform this test if the next buffer comes immediately next to this

  1030 			// one. This is not necessarily the case on the Flexible Memory Model.

  1031 			threadname.Format(KTestThreadRead, 3, 1, i);

  1032 			r = thread.Create(threadname, ThreadGuardPagesRead, KDefaultStackSize, KMinHeapSize, KMinHeapSize,

  1033 				(TAny*) (bufs1[i].Ptr() + offset));

  1034 			test_KErrNone(r);

  1035 			thread.Logon(rs);

  1036 			thread.Resume();

  1037 			User::WaitForRequest(rs);

  1038 			if (rs.Int() != KErrNone) // No guard page, so it should be fine

  1039 				{

  1040 				test_Equal(KErrUnknown, rs.Int());

  1041 				test_Equal(KErrUnknown, thread.ExitReason());

  1042 				}

  1043 			test_Equal(EExitKill, thread.ExitType());

  1044 			thread.Close();

  1045 			}

  1046 		// Pool 2

  1047 		TBool jit = User::JustInTime();

  1048 		User::SetJustInTime(EFalse);

  1049 		threadname.Format(KTestThreadRead, 3, 2, i);

  1050 		r = thread.Create(threadname, ThreadGuardPagesRead, KDefaultStackSize, KMinHeapSize, KMinHeapSize,

  1051 			(TAny*) (bufs2[i].Ptr() + offset));

  1052 		test_KErrNone(r);

  1053 		thread.Logon(rs);

  1054 		thread.Resume();

  1055 		User::WaitForRequest(rs);

  1056 		test_Equal(3, rs.Int());

  1057 		test_Equal(EExitPanic, thread.ExitType());

  1058 		test_Equal(3, thread.ExitReason()); // KERN-EXEC 3

  1059 		thread.Close();

  1060 		User::SetJustInTime(jit);

  1061 		}

  1062 

  1063 	_LIT(KTestThreadWrite, "GuardPagesWriteTS%dP%dB%d");

  1064 	for (i = 0; i < KTestPoolSizeInBufs - 1; i++)

  1065 		{

  1066 		TBuf<40> threadname;

  1067 		RThread thread;

  1068 		TRequestStatus rs;

  1069 

  1070 		// 1. Simple write within buffer

  1071 		// Pool 1

  1072 		threadname.Format(KTestThreadWrite, 1, 1, i);

  1073 		r = thread.Create(threadname, ThreadGuardPagesWrite, KDefaultStackSize, KMinHeapSize, KMinHeapSize,

  1074 			(TAny*) bufs1[i].Ptr());

  1075 		test_KErrNone(r);

  1076 		thread.Logon(rs);

  1077 		thread.Resume();

  1078 		User::WaitForRequest(rs);

  1079 		test_KErrNone(rs.Int());

  1080 		test_Equal(EExitKill, thread.ExitType());

  1081 		test_KErrNone(thread.ExitReason());

  1082 		thread.Close();

  1083 		// Pool 2

  1084 		threadname.Format(KTestThreadWrite, 1, 2, i);

  1085 		r = thread.Create(threadname, ThreadGuardPagesWrite, KDefaultStackSize, KMinHeapSize, KMinHeapSize,

  1086 			(TAny*) bufs2[i].Ptr());

  1087 		test_KErrNone(r);

  1088 		thread.Logon(rs);

  1089 		thread.Resume();

  1090 		User::WaitForRequest(rs);

  1091 		test_KErrNone(rs.Int());

  1092 		test_Equal(EExitKill, thread.ExitType());

  1093 		test_KErrNone(thread.ExitReason());

  1094 		thread.Close();

  1095 

  1096 		// 2. If the buffer size is not a multiple of the MMU page size, it should be

  1097 		// possible to write after the buffer end until the page boundary

  1098 		if (*PtrBufSize % pagesize)

  1099 			{

  1100 			// Pool 1

  1101 			threadname.Format(KTestThreadWrite, 2, 1, i);

  1102 			r = thread.Create(threadname, ThreadGuardPagesWrite, KDefaultStackSize, KMinHeapSize, KMinHeapSize,

  1103 				(TAny*) (bufs1[i].Ptr() + pagesize - *PtrBufSize % pagesize));

  1104 			test_KErrNone(r);

  1105 			thread.Logon(rs);

  1106 			thread.Resume();

  1107 			User::WaitForRequest(rs);

  1108 			test_KErrNone(rs.Int());

  1109 			test_Equal(EExitKill, thread.ExitType());

  1110 			test_KErrNone(thread.ExitReason());

  1111 			thread.Close();

  1112 			// Pool 2

  1113 			threadname.Format(KTestThreadWrite, 2, 2, i);

  1114 			r = thread.Create(threadname, ThreadGuardPagesWrite, KDefaultStackSize, KMinHeapSize, KMinHeapSize,

  1115 				(TAny*) (bufs2[i].Ptr() + pagesize - *PtrBufSize % pagesize));

  1116 			test_KErrNone(r);

  1117 			thread.Logon(rs);

  1118 			thread.Resume();

  1119 			User::WaitForRequest(rs);

  1120 			test_KErrNone(rs.Int());

  1121 			test_Equal(EExitKill, thread.ExitType());

  1122 			test_KErrNone(thread.ExitReason());

  1123 			thread.Close();

  1124 			}

  1125 

  1126 		// 3. Now we attempt to write on the first byte on the next page after the

  1127 		// end of our buffer.

  1128 		TInt offset;

  1129 		if (*PtrBufSize % pagesize)

  1130 			{

  1131 			offset = pagesize - *PtrBufSize % pagesize + 1;

  1132 			}

  1133 		else

  1134 			{