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 #ifdef TEST_CLIENT_THREAD

    29 RTest test(_L("T_SHBUF_CLIENT"));

    30 #else

    31 RTest test(_L("T_SHBUF_OWN"));

    32 #endif

    33 

    34 RShPool P1; // User-side pool

    35 RShPool P2; // Kernel-side pool

    36 

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

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

    39 

    40 const TInt* PtrBufSize;

    41 

    42 RShBufTestChannel Ldd;

    43 

    44 _LIT(KTestSlave, "SLAVE");

    45 _LIT(KTestLowSpaceSemaphore, "LowSpaceSemaphore");

    46 

    47 enum TTestSlave

    48 	{

    49 	ETestSlaveError,

    50 	ETestSlaveNoDeallocation,

    51 	};

    52 

    53 enum TTestPoolType

    54 	{

    55 	ETestNonPageAligned,

    56 	ETestPageAligned,

    57 	ETestPageAlignedGrowing,

    58 	};

    59 

    60 TInt Log2(TInt aNum)

    61 	{

    62 	TInt res = -1;

    63 	while(aNum)

    64 		{

    65 		res++;

    66 		aNum >>= 1;

    67 		}

    68 	return res;

    69 	}

    70 

    71 TInt RoundUp(TInt aNum, TInt aAlignmentLog2)

    72 	{

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

    74 		{

    75 		return aNum;

    76 		}

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

    78 	}

    79 

    80 void LoadDeviceDrivers()

    81 	{

    82 	TInt r;

    83 	#ifdef TEST_CLIENT_THREAD

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

    85 	if (r != KErrAlreadyExists)

    86 		{

    87 		test_KErrNone(r);

    88 		}

    89 	#else

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

    91 	if (r != KErrAlreadyExists)

    92 		{

    93 		test_KErrNone(r);

    94 		}

    95 	#endif

    96 	}

    97 

    98 void FreeDeviceDrivers()

    99 	{

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

   101 	test_KErrNone(r);

   102 	r = User::FreeLogicalDevice(KTestShBufOwn);

   103 	test_KErrNone(r);

   104 	}

   105 

   106 void FillShBuf(RShBuf& aBuffer, TUint8 aValue)

   107 	{

   108 	TUint size = aBuffer.Size();

   109 	TUint8* base = aBuffer.Ptr();

   110 	test(size!=0);

   111 	test(base!=0);

   112 	memset(base,aValue,size);

   113 	}

   114 

   115 TBool CheckFillShBuf(RShBuf& aBuffer, TUint8 aValue)

   116 	{

   117 	TUint size = aBuffer.Size();

   118 	TUint8* base = aBuffer.Ptr();

   119 	test(size!=0);

   120 	test(base!=0);

   121 	TUint8* ptr = base;

   122 	TUint8* end = ptr+size;

   123 	while(ptr<end)

   124 		{

   125 		TUint8 b = *ptr++;

   126 		if(b!=aValue)

   127 			{

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

   129 			return EFalse;

   130 			}

   131 		}

   132 	return ETrue;

   133 	}

   134 

   135 TBool CheckNotFillShBuf(RShBuf& aBuffer, TUint8 aValue)

   136 	{

   137 	TUint size = aBuffer.Size();

   138 	TUint8* base = aBuffer.Ptr();

   139 	test(size!=0);

   140 	test(base!=0);

   141 	TUint8* ptr = base;

   142 	TUint8* end = ptr+size;

   143 	while(ptr<end)

   144 		{

   145 		TUint8 b = *ptr++;

   146 		if(b==aValue)

   147 			{

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

   149 			return EFalse;

   150 			}

   151 		}

   152 	return ETrue;

   153 	}

   154 

   155 /*

   156 @SYMTestCaseID				1

   157 @SYMTestCaseDesc			Create pool from user-side

   158 @SYMREQ						REQ11423

   159 @SYMTestActions

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

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

   162 @SYMTestExpectedResults

   163 	All OK.

   164 @SYMTestPriority			Critical

   165 */

   166 

   167 void CreateUserPool(TTestPoolType aPoolType)

   168 	{

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

   170 	TInt r;

   171 	TInt pagesize;

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

   173 	test_KErrNone(r);

   174 

   175 	switch (aPoolType)

   176 		{

   177 		case ETestNonPageAligned:

   178 		// Non-page-aligned pool

   179 			{

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

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

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

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

   184 			test_KErrNone(r);

   185 

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

   187 			test_Equal(KErrNotSupported, r);

   188 

   189 			TShPoolInfo poolinfotokernel;

   190 			poolinfotokernel.iBufSize = *PtrBufSize;

   191 			poolinfotokernel.iInitialBufs = KTestPoolSizeInBufs;

   192 			poolinfotokernel.iMaxBufs = KTestPoolSizeInBufs;

   193 			poolinfotokernel.iGrowTriggerRatio = 0;

   194 			poolinfotokernel.iGrowByRatio = 0;

   195 			poolinfotokernel.iShrinkHysteresisRatio = 0;

   196 			poolinfotokernel.iAlignment = 8;

   197 			poolinfotokernel.iFlags = EShPoolNonPageAlignedBuffer;

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

   199 			test_KErrNone(r);

   200 

   201 			TShPoolInfo poolinfo;

   202 			P1.GetInfo(poolinfo);

   203 			test_Equal(*PtrBufSize, poolinfo.iBufSize);

   204 			test_Equal(KTestPoolSizeInBufs, poolinfo.iInitialBufs);

   205 			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

   206 			test_Equal(0, poolinfo.iGrowTriggerRatio);

   207 			test_Equal(0, poolinfo.iGrowByRatio);

   208 			test_Equal(0, poolinfo.iShrinkHysteresisRatio);

   209 			test_Equal(8, poolinfo.iAlignment);

   210 			test(poolinfo.iFlags & EShPoolNonPageAlignedBuffer);

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

   212 			break;

   213 			}

   214 		case ETestPageAligned:

   215 		// Page-aligned pool

   216 			{

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

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

   219 

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

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

   222 			test_KErrNone(r);

   223 

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

   225 			test_KErrNone(r);

   226 

   227 			TShPoolInfo poolinfo;

   228 			P1.GetInfo(poolinfo);

   229 			test_Equal(*PtrBufSize, poolinfo.iBufSize);

   230 			test_Equal(KTestPoolSizeInBufs, poolinfo.iInitialBufs);

   231 			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

   232 			test_Equal(0, poolinfo.iGrowTriggerRatio);

   233 			test_Equal(0, poolinfo.iGrowByRatio);

   234 			test_Equal(0, poolinfo.iShrinkHysteresisRatio);

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

   236 			test(poolinfo.iFlags & EShPoolPageAlignedBuffer);

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

   238 

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

   240 			test_KErrNone(r);

   241 			break;

   242 			}

   243 		case ETestPageAlignedGrowing:

   244 		// Page-aligned growing pool

   245 			{

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

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

   248 

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

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

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

   252 			test_KErrNone(r);

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

   254 			test_KErrNone(r);

   255 

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

   257 			test_KErrNone(r);

   258 

   259 			TShPoolInfo poolinfo;

   260 			P1.GetInfo(poolinfo);

   261 			test_Equal(*PtrBufSize, poolinfo.iBufSize);

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

   263 			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

   264 			test_Equal(25, poolinfo.iGrowTriggerRatio);

   265 			test_Equal(26, poolinfo.iGrowByRatio);

   266 			test_Equal(25600, poolinfo.iShrinkHysteresisRatio);

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

   268 			test(poolinfo.iFlags & EShPoolPageAlignedBuffer);

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

   270 

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

   272 			test_KErrNone(r);

   273 			break;

   274 			}

   275 		default:

   276 			test(EFalse);

   277 		}

   278 	}

   279 

   280 /*

   281 @SYMTestCaseID				2

   282 @SYMTestCaseDesc			Create pool from kernel-side

   283 @SYMREQ						REQ11423

   284 @SYMTestActions

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

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

   287 @SYMTestExpectedResults

   288 	1. Ok.

   289 	2. Ok.

   290 @SYMTestPriority			Critical

   291 */

   292 

   293 void CreateKernelPool(TTestPoolType aPoolType)

   294 	{

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

   296 	TInt r;

   297 	TInt pagesize;

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

   299 	test_KErrNone(r);

   300 	TInt handle;

   301 

   302 	switch (aPoolType)

   303 		{

   304 		case ETestNonPageAligned:

   305 		// Non-page-aligned pool

   306 			{

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

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

   309 

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

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

   312 			test_KErrNone(r);

   313 			P2.SetHandle(handle);

   314 

   315 			TShPoolInfo poolinfo;

   316 			P2.GetInfo(poolinfo);

   317 			test_Equal(*PtrBufSize, poolinfo.iBufSize);

   318 			test_Equal(KTestPoolSizeInBufs, poolinfo.iInitialBufs);

   319 			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

   320 			test_Equal(0, poolinfo.iGrowTriggerRatio);

   321 			test_Equal(0, poolinfo.iGrowByRatio);

   322 			test_Equal(0, poolinfo.iShrinkHysteresisRatio);

   323 			test_Equal(8, poolinfo.iAlignment);

   324 			test(poolinfo.iFlags & EShPoolNonPageAlignedBuffer);

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

   326 			break;

   327 			}

   328 		case ETestPageAligned:

   329 		// Page-aligned pool

   330 			{

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

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

   333 

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

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

   336 			test_KErrNone(r);

   337 			P2.SetHandle(handle);

   338 

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

   340 			test_KErrNone(r);

   341 

   342 			TShPoolInfo poolinfo;

   343 			P2.GetInfo(poolinfo);

   344 			test_Equal(*PtrBufSize, poolinfo.iBufSize);

   345 			test_Equal(KTestPoolSizeInBufs, poolinfo.iInitialBufs);

   346 			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

   347 			test_Equal(0, poolinfo.iGrowTriggerRatio);

   348 			test_Equal(0, poolinfo.iGrowByRatio);

   349 			test_Equal(0, poolinfo.iShrinkHysteresisRatio);

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

   351 			test(poolinfo.iFlags & EShPoolPageAlignedBuffer);

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

   353 			break;

   354 			}

   355 		case ETestPageAlignedGrowing:

   356 		// Page-aligned pool growing

   357 			{

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

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

   360 

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

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

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

   364 			test_KErrNone(r);

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

   366 			test_KErrNone(r);

   367 			P2.SetHandle(handle);

   368 

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

   370 			test_KErrNone(r);

   371 

   372 			TShPoolInfo poolinfo;

   373 			P2.GetInfo(poolinfo);

   374 			test_Equal(*PtrBufSize, poolinfo.iBufSize);

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

   376 			test_Equal(KTestPoolSizeInBufs, poolinfo.iMaxBufs);

   377 			test_Equal(25, poolinfo.iGrowTriggerRatio);

   378 			test_Equal(26, poolinfo.iGrowByRatio);

   379 			test_Equal(25600, poolinfo.iShrinkHysteresisRatio);

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

   381 			test(poolinfo.iFlags & EShPoolPageAlignedBuffer);

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

   383 			break;

   384 			}

   385 		default:

   386 			test(EFalse);

   387 		}

   388 	}

   389 

   390 /*

   391 @SYMTestCaseID				20

   392 @SYMTestCaseDesc			Close pool from kernel-side

   393 @SYMREQ						REQ11423

   394 @SYMTestActions

   395 	1. Device Driver closes P2.

   396 	2. Test Thread closes P2.

   397 @SYMTestExpectedResults

   398 	1. OK and Access Count is now 1.

   399 	2. OK

   400 @SYMTestPriority			Critical

   401 */

   402 

   403 void CloseKernelPool()

   404 	{

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

   406 	TInt r;

   407 

   408 	r = Ldd.CloseKernelPool();

   409 	test_KErrNone(r);

   410 

   411 	P2.Close();

   412 

   413 	// wait for memory to be freed

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

   415 	test_KErrNone(r);

   416 

   417 	}

   418 

   419 /*

   420 @SYMTestCaseID				21

   421 @SYMTestCaseDesc			Close pool from user-side

   422 @SYMREQ						REQ11423

   423 @SYMTestActions

   424 	1. Test Thread closes P1.

   425 	2. Device Driver closes P1.

   426 @SYMTestExpectedResults

   427 	1. OK and Access Count is now 1.

   428 	2. OK.

   429 @SYMTestPriority			Critical

   430 */

   431 

   432 void CloseUserPool()

   433 	{

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

   435 	TInt r;

   436 

   437 	P1.Close();

   438 

   439 	r = Ldd.CloseUserPool();

   440 	test_KErrNone(r);

   441 

   442 	// wait for memory to be freed

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

   444 	test_KErrNone(r);

   445 	}

   446 

   447 /*

   448 @SYMTestCaseID				3

   449 @SYMTestCaseDesc			Buffer allocation from user-side

   450 @SYMREQ						REQ11423

   451 @SYMTestActions

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

   453 	2. Test Thread passes buffer to Device Driver.

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

   455 	4. Device Driver releases buffer.

   456 	5. Test Thread releases buffer.

   457 @SYMTestExpectedResults

   458 	1. Ok.

   459 	2. Ok.

   460 	3. Ok.

   461 	4. Ok.

   462 	5. Ok. Buffer de-allocated.

   463 @SYMTestPriority			Critical

   464 */

   465 

   466 void AllocateUserBuffer()

   467 	{

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

   469 	TInt r;

   470 	RShBuf buf;

   471 

   472 	// Allocate buffer on POOL 1

   473 	__KHEAP_MARK;

   474 	r = buf.Alloc(P1);

   475 	test_KErrNone(r);

   476 	__KHEAP_CHECK(0);

   477 

   478 	TInt i;

   479 	TShPoolInfo poolinfo1;

   480 	P1.GetInfo(poolinfo1);

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

   482 

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

   484 		{

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

   486 		}

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

   488 

   489 	test_KErrNone(r);

   490 

   491 	TBuf8<64> tmp;

   492 

   493 	P1.GetInfo(poolinfo1);

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

   495 

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

   497 		{

   498 		tmp.Fill(i);

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

   500 		r = tmp.Compare(ptrc);

   501 		test_Equal(0, r);

   502 		}

   503 	buf.Close();

   504 	__KHEAP_MARKEND;

   505 

   506 	// Allocate buffer on POOL 2

   507 	__KHEAP_MARK;

   508 	r = buf.Alloc(P2);

   509 	test_KErrNone(r);

   510 	__KHEAP_CHECK(0);

   511 

   512 	TShPoolInfo poolinfo2;

   513 	P2.GetInfo(poolinfo2);

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

   515 

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

   517 		{

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

   519 		}

   520 

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

   522 	test_KErrNone(r);

   523 

   524 	P2.GetInfo(poolinfo2);

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

   526 

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

   528 		{

   529 		tmp.Fill(i);

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

   531 		test_Equal(0, r);

   532 		}

   533 	buf.Close();

   534 	__KHEAP_MARKEND;

   535 	}

   536 

   537 /*

   538 @SYMTestCaseID				4

   539 @SYMTestCaseDesc			Buffer allocation from kernel-side

   540 @SYMREQ						REQ11423

   541 @SYMTestActions

   542 	1. Device Driver creates a buffer on P2.

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

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

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

   546 @SYMTestExpectedResults

   547 	1. Ok.

   548 	2. Ok.

   549 	3. Ok.

   550 	4. Ok. Buffer de-allocated.

   551 @SYMTestPriority			Critical

   552 */

   553 

   554 void AllocateKernelBuffer()

   555 	{

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

   557 	TInt r;

   558 	TInt handle;

   559 	RShBuf kbuf0, kbuf1;

   560 

   561 	// Allocate buffer on POOL 1

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

   563 	test_KErrNone(r);

   564 	kbuf0.SetHandle(handle);

   565 

   566 	TInt i;

   567 	TShPoolInfo poolinfo1;

   568 	P1.GetInfo(poolinfo1);

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

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

   571 		{

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

   573 

   574 		test_Equal(0, r);

   575 		}

   576 	kbuf0.Close();

   577 

   578 	// Allocate buffer on POOL 2

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

   580 	test_KErrNone(r);

   581 	kbuf1.SetHandle(handle);

   582 

   583 	TShPoolInfo poolinfo2;

   584 	P2.GetInfo(poolinfo2);

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

   586 

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

   588 		{

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

   590 

   591 		test_Equal(0, r);

   592 		}

   593 	kbuf1.Close();

   594 	}

   595 

   596 

   597 /*

   598 @SYMTestCaseID				X1

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

   600 @SYMREQ						REQ11423

   601 @SYMTestActions

   602 	Allocate as many buffers on a pool as possible.

   603 	Free them all and re-allocate them again.

   604 	Free them all.

   605 @SYMTestExpectedResults

   606 	Ok.

   607 @SYMTestPriority			High

   608 */

   609 

   610 void AllocateUserMax(RShPool& aPool)

   611 	{

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

   613 	TInt r;

   614 

   615 	TShPoolInfo poolinfo;

   616 	aPool.GetInfo(poolinfo);

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

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

   619 

   620 	RArray<RShBuf> bufarray;

   621 	do

   622 		{

   623 		RShBuf buf;

   624 		r = buf.Alloc(aPool);

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

   626 			{

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

   628 			

   629 			User::After(1000000);

   630 			r = buf.Alloc(aPool);

   631 			}

   632 		if (!r)

   633 			{

   634 			r = bufarray.Append(buf);

   635 			test_KErrNone(r);

   636 			FillShBuf(buf,0x99);

   637 			}

   638 		}

   639 	while (r == KErrNone);

   640 	test_Equal(KErrNoMemory, r);

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

   642 

   643 	TInt n = bufarray.Count();

   644 	while (n)

   645 		{

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

   647 		}

   648 

   649 	User::After(500000);

   650 

   651 	// Do it once more

   652 	n = 0;

   653 	while (n<bufarray.Count())

   654 		{

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

   656 		if (r==KErrNoMemory)

   657 			{

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

   659 			User::After(1000000);

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

   661 			}

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

   663 		if(aligned)

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

   665 		++n;

   666 		}

   667 

   668 	RShBuf extrabuf;

   669 	r = extrabuf.Alloc(aPool);

   670 	test_Equal(KErrNoMemory, r);

   671 

   672 	while (n)

   673 		{

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

   675 		}

   676 

   677 	bufarray.Close();

   678 	}

   679 

   680 void AllocateKernelMax()

   681 	{

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

   683 	TInt r;

   684 	TInt allocated;

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

   686 	test_KErrNone(r);

   687 	test_Equal(KTestPoolSizeInBufs, allocated);

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

   689 	test_KErrNone(r);

   690 	test_Equal(KTestPoolSizeInBufs, allocated);

   691 	}

   692 

   693 

   694 /*

   695 @SYMTestCaseID				11

   696 @SYMTestCaseDesc			Buffer alignment (kernel/user)

   697 @SYMREQ						REQ11423

   698 @SYMTestActions

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

   700 	   requirements:

   701 	2. Test Thread allocates buffers on all pools.

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

   703 @SYMTestExpectedResults

   704 	1. Ok.

   705 	2. Buffers are aligned to the desired boundary.

   706 	3. Ok.

   707 @SYMTestPriority			High

   708 */

   709 

   710 void BufferAlignmentUser()

   711 	{

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

   713 	TInt pagesize;

   714 	TInt r;

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

   716 	test_KErrNone(r);

   717 

   718 	// Non page aligned buffers

   719 	TInt i;

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

   721 		{

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

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

   724 		RShPool pool;

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

   726 		test_KErrNone(r);

   727 

   728 		TInt j;

   729 		RShBuf buf[20];

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

   731 			{

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

   733 			test_KErrNone(r);

   734 			}

   735 

   736 		TInt alignment = i;

   737 		if (alignment < KTestMinimumAlignmentLog2)

   738 			{

   739 			alignment = KTestMinimumAlignmentLog2;

   740 			}

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

   742 			{

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

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

   745 			}

   746 

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

   748 			{

   749 			buf[j].Close();

   750 			}

   751 		pool.Close();

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

   753 		User::After(100000);

   754 		}

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

   756 

   757 	// Page aligned buffers

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

   759 	RShPool pool;

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

   761 	test_KErrNone(r);

   762 

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

   764 	test_KErrNone(r);

   765 

   766 	TInt j;

   767 	RShBuf buf[20];

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

   769 		{

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

   771 		test_KErrNone(r);

   772 		}

   773 

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

   775 		{

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

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

   778 		}

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

   780 		{

   781 		buf[j].Close();

   782 		}

   783 	pool.Close();

   784 	}

   785 

   786 void BufferAlignmentKernel()

   787 	{

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

   789 	TInt r;

   790 

   791 	TInt pagesize;

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

   793 	test_KErrNone(r);

   794 

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

   796 		{

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

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

   799 		test_KErrNone(r);

   800 		// delay to allow the management dfc to run

   801 		User::After(100000);

   802 		}

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

   804 	}

   805 

   806 /*

   807 @SYMTestCaseID				6

   808 @SYMTestCaseDesc			Create pool at specific physical address

   809 @SYMREQ						REQ11423

   810 @SYMTestActions

   811 	1. Device Driver allocates memory chunk.

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

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

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

   815 @SYMTestExpectedResults

   816 	1. Ok.

   817 	2. Ok.

   818 	3. Ok.

   819 	4. Ok

   820 @SYMTestPriority			High

   821 */

   822 

   823 void CreateKernelPoolPhysAddr()

   824 	{

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

   826 	TInt r;

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

   828 	r = Ldd.CreatePoolPhysAddrCont(*PtrBufSize);

   829 	test_KErrNone(r);

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

   831 	r = Ldd.CreatePoolPhysAddrNonCont(*PtrBufSize);

   832 	test_KErrNone(r);

   833 	test.End();

   834 	}

   835 

   836 /*

   837 @SYMTestCaseID				14

   838 @SYMTestCaseDesc			Buffer separation and overwrites

   839 @SYMREQ						REQ11423

   840 @SYMTestActions

   841 	1. Test Thread creates two pools:

   842 		- A pool with no guard pages.

   843 		- A pool with guard pages.

   844 	2. Allocate two buffers on each pool.

   845 	3. Test Thread creates Secondary Thread.

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

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

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

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

   850 	6. Free buffers and close pools.

   851 @SYMTestExpectedResults

   852 	1. Ok.

   853 	2. Ok.

   854 	3. Ok.

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

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

   857 	   have to be restarted).

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

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

   860 	6. Ok.

   861 @SYMTestPriority			High

   862 */

   863 

   864 TInt ThreadGuardPagesRead(TAny* aArg)

   865 	{

   866 	TUint8* ptr = (TUint8*) aArg;

   867 	if (ptr == NULL)

   868 		{

   869 		return KErrArgument;

   870 		}

   871 	TInt bufsize = *PtrBufSize;

   872 	TInt i;

   873 	TUint8 val = '$';

   874 	TBool isok = ETrue;

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

   876 		{

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

   878 			{

   879 			isok = EFalse;

   880 			}

   881 		}

   882 	if (!isok)

   883 		{

   884 		return KErrUnknown;

   885 		}

   886 	return KErrNone;

   887 	}

   888 

   889 TInt ThreadGuardPagesWrite(TAny* aArg)

   890 	{

   891 	TUint8* ptr = (TUint8*) aArg;

   892 	if (ptr == NULL)

   893 		{

   894 		return KErrArgument;

   895 		}

   896 	TInt bufsize = *PtrBufSize;

   897 	TInt i;

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

   899 		{

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

   901 		}

   902 	return KErrNone;

   903 	}

   904 

   905 void GuardPages()

   906 	{

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

   908 	TInt pagesize;

   909 	TInt r;

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

   911 	test_KErrNone(r);

   912 

   913 	// Create pools

   914 	RShPool pool1;

   915 	RShPool pool2;

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

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

   918 	test_KErrNone(r);

   919 

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

   921 	test_KErrNone(r);

   922 

   923 	r = inf.SetGuardPages();

   924 	test_KErrNone(r);

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

   926 	test_KErrNone(r);

   927 

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

   929 	test_KErrNone(r);

   930 

   931 	// Allocate buffers

   932 	RShBuf bufs1[KTestPoolSizeInBufs];

   933 	RShBuf bufs2[KTestPoolSizeInBufs];

   934 	TInt i;

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

   936 		{

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

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

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

   940 		ptr.Fill('$');

   941 		}

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

   943 		{

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

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

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

   947 		ptr.Fill('$');

   948 		}

   949 

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

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

   952 		{

   953 		TBuf<40> threadname;

   954 		RThread thread;

   955 		TRequestStatus rs;

   956 

   957 		// 1. Simple read within buffer

   958 		// Pool 1

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

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

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

   962 		test_KErrNone(r);

   963 		thread.Logon(rs);

   964 		thread.Resume();

   965 		User::WaitForRequest(rs);

   966 		test_KErrNone(rs.Int());

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

   968 		test_KErrNone(thread.ExitReason());

   969 		thread.Close();

   970 		// Pool 2

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

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

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

   974 		test_KErrNone(r);

   975 		thread.Logon(rs);

   976 		thread.Resume();

   977 		User::WaitForRequest(rs);

   978 		test_KErrNone(rs.Int());

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

   980 		test_KErrNone(thread.ExitReason());

   981 		thread.Close();

   982 

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

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

   985 		if (*PtrBufSize % pagesize)

   986 			{

   987 			// Pool 1

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

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

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

   991 			test_KErrNone(r);

   992 			thread.Logon(rs);

   993 			thread.Resume();

   994 			User::WaitForRequest(rs);

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

   996 				{

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

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

   999 				}

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

  1001 			thread.Close();

  1002 			// Pool 2

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

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

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

  1006 			test_KErrNone(r);

  1007 			thread.Logon(rs);

  1008 			thread.Resume();

  1009 			User::WaitForRequest(rs);

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

  1011 				{

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

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

  1014 				}

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

  1016 			thread.Close();

  1017 			}

  1018 

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

  1020 		// our buffer.

  1021 		TInt offset;

  1022 		if (*PtrBufSize % pagesize)

  1023 			{

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

  1025 			}

  1026 		else

  1027 			{

  1028 			offset = 1;

  1029 			}

  1030 		// Pool 1

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

  1032 			{

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

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

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

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

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

  1038 			test_KErrNone(r);

  1039 			thread.Logon(rs);

  1040 			thread.Resume();

  1041 			User::WaitForRequest(rs);

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

  1043 				{

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

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

  1046 				}

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

  1048 			thread.Close();

  1049 			}

  1050 		// Pool 2

  1051 		TBool jit = User::JustInTime();

  1052 		User::SetJustInTime(EFalse);

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

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

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

  1056 		test_KErrNone(r);

  1057 		thread.Logon(rs);

  1058 		thread.Resume();

  1059 		User::WaitForRequest(rs);

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

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

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

  1063 		thread.Close();

  1064 		User::SetJustInTime(jit);

  1065 		}

  1066 

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

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

  1069 		{

  1070 		TBuf<40> threadname;

  1071 		RThread thread;

  1072 		TRequestStatus rs;

  1073 

  1074 		// 1. Simple write within buffer

  1075 		// Pool 1

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

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

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

  1079 		test_KErrNone(r);

  1080 		thread.Logon(rs);

  1081 		thread.Resume();

  1082 		User::WaitForRequest(rs);

  1083 		test_KErrNone(rs.Int());

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

  1085 		test_KErrNone(thread.ExitReason());

  1086 		thread.Close();

  1087 		// Pool 2

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

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

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

  1091 		test_KErrNone(r);

  1092 		thread.Logon(rs);

  1093 		thread.Resume();

  1094 		User::WaitForRequest(rs);

  1095 		test_KErrNone(rs.Int());

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

  1097 		test_KErrNone(thread.ExitReason());

  1098 		thread.Close();

  1099 

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

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

  1102 		if (*PtrBufSize % pagesize)

  1103 			{

  1104 			// Pool 1

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

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

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

  1108 			test_KErrNone(r);

  1109 			thread.Logon(rs);

  1110 			thread.Resume();

  1111 			User::WaitForRequest(rs);

  1112 			test_KErrNone(rs.Int());

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

  1114 			test_KErrNone(thread.ExitReason());

  1115 			thread.Close();

  1116 			// Pool 2

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

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

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

  1120 			test_KErrNone(r);

  1121 			thread.Logon(rs);

  1122 			thread.Resume();

  1123 			User::WaitForRequest(rs);

  1124 			test_KErrNone(rs.Int());

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

  1126 			test_KErrNone(thread.ExitReason());

  1127 			thread.Close();

  1128 			}

  1129 

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

  1131 		// end of our buffer.

  1132 		TInt offset;

  1133 		if (*PtrBufSize % pagesize)

  1134 			{

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