Ros-diffs January 2010

ros-diffs@reactos.org

26 participants
522 discussions

[ros-arm-bringup] 44904: - Bring back old paged pool allocator and use it for paged pool, until ARM3 pool issues are solved. - Should fix recent regressions.

by ros-arm-bringup＠svn.reactos.org

Author: ros-arm-bringup Date: Sun Jan 3 06:24:30 2010 New Revision: 44904 URL: http://svn.reactos.org/svn/reactos?rev=44904&view=rev Log: - Bring back old paged pool allocator and use it for paged pool, until ARM3 pool issues are solved. - Should fix recent regressions. Added: trunk/reactos/ntoskrnl/mm/ppool.c (with props) Modified: trunk/reactos/ntoskrnl/mm/ARM3/expool.c trunk/reactos/ntoskrnl/mm/mminit.c trunk/reactos/ntoskrnl/ntoskrnl-generic.rbuild Modified: trunk/reactos/ntoskrnl/mm/ARM3/expool.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/mm/ARM3/expool.c?… ============================================================================== --- trunk/reactos/ntoskrnl/mm/ARM3/expool.c [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/mm/ARM3/expool.c [iso-8859-1] Sun Jan 3 06:24:30 2010 @@ -192,6 +192,11 @@ PPOOL_HEADER Entry, NextEntry, FragmentEntry; KIRQL OldIrql; ULONG BlockSize, i; + + // + // Check for paged pool + // + if (PoolType == PagedPool) return ExAllocatePagedPoolWithTag(PagedPool, NumberOfBytes, Tag); // // Some sanity checks @@ -480,6 +485,19 @@ POOL_TYPE PoolType; PPOOL_DESCRIPTOR PoolDesc; BOOLEAN Combined = FALSE; + + // + // Check for paged pool + // + if ((P >= MmPagedPoolBase) && + (P <= (PVOID)((ULONG_PTR)MmPagedPoolBase + MmPagedPoolSize))) + { + // + // Use old allocator + // + ExFreePagedPool(P); + return; + } // // Quickly deal with big page allocations Modified: trunk/reactos/ntoskrnl/mm/mminit.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/mm/mminit.c?rev=4… ============================================================================== --- trunk/reactos/ntoskrnl/mm/mminit.c [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/mm/mminit.c [iso-8859-1] Sun Jan 3 06:24:30 2010 @@ -199,6 +199,21 @@ ASSERT(Status == STATUS_SUCCESS); // + // And now, ReactOS paged pool + // + BaseAddress = MmPagedPoolBase; + Status = MmCreateMemoryArea(MmGetKernelAddressSpace(), + MEMORY_AREA_PAGED_POOL | MEMORY_AREA_STATIC, + &BaseAddress, + MmPagedPoolSize, + PAGE_READWRITE, + &MArea, + TRUE, + 0, + BoundaryAddressMultiple); + ASSERT(Status == STATUS_SUCCESS); + + // // Next, the KPCR // BaseAddress = (PVOID)PCR; @@ -272,6 +287,10 @@ MmSystemRangeStart, (ULONG_PTR)MmSystemRangeStart + MmBootImageSize, "Boot Loaded Image"); + DPRINT1(" 0x%p - 0x%p\t%s\n", + MmPagedPoolBase, + (ULONG_PTR)MmPagedPoolBase + MmPagedPoolSize, + "Paged Pool"); DPRINT1(" 0x%p - 0x%p\t%s\n", MmPfnDatabase, (ULONG_PTR)MmPfnDatabase + (MxPfnAllocation << PAGE_SHIFT), @@ -370,13 +389,21 @@ // MiDbgReadyForPhysical = TRUE; #endif - + + /* Put the paged pool after the loaded modules */ + MmPagedPoolBase = (PVOID)PAGE_ROUND_UP((ULONG_PTR)MmSystemRangeStart + + MmBootImageSize); + MmPagedPoolSize = MM_PAGED_POOL_SIZE; + /* Intialize system memory areas */ MiInitSystemMemoryAreas(); - + /* Dump the address space */ MiDbgDumpAddressSpace(); - + + /* Initialize paged pool */ + MmInitializePagedPool(); + /* Initialize working sets */ MmInitializeMemoryConsumer(MC_USER, MmTrimUserMemory); Added: trunk/reactos/ntoskrnl/mm/ppool.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/mm/ppool.c?rev=44… ============================================================================== --- trunk/reactos/ntoskrnl/mm/ppool.c (added) +++ trunk/reactos/ntoskrnl/mm/ppool.c [iso-8859-1] Sun Jan 3 06:24:30 2010 @@ -1,0 +1,1023 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * FILE: ntoskrnl/mm/ppool.c + * PURPOSE: Implements the paged pool + * + * PROGRAMMERS: David Welch (welch(a)mcmail.com) + * Royce Mitchell III + */ + +/* INCLUDES *****************************************************************/ + +#include <ntoskrnl.h> +#define NDEBUG +#include <debug.h> + +#if defined (ALLOC_PRAGMA) +#pragma alloc_text(INIT, MmInitializePagedPool) +#endif + +#undef ASSERT +#define ASSERT(x) if (!(x)) {DbgPrint("Assertion "#x" failed at %s:%d\n", __FILE__,__LINE__); DbgBreakPoint(); } + +// enable "magic" +//#define R_MAGIC +#define R_MUTEX FAST_MUTEX +#define R_ACQUIRE_MUTEX(pool) /*DPRINT1("Acquiring PPool Mutex\n");*/ ExAcquireFastMutex(&pool->Mutex) +#define R_RELEASE_MUTEX(pool) /*DPRINT1("Releasing PPool Mutex\n");*/ ExReleaseFastMutex(&pool->Mutex) +#define R_PRINT_ADDRESS(addr) KeRosPrintAddress(addr) +#define R_PANIC() KeBugCheck(MEMORY_MANAGEMENT) +#define R_DEBUG DbgPrint + +#ifdef _ARM_ +#define R_GET_STACK_FRAMES(ptr,cnt) +#else +#define R_GET_STACK_FRAMES(ptr,cnt) RtlWalkFrameChain((PVOID*)ptr,cnt, 0) +#endif + +/* GLOBALS ********************************************************************/ + +typedef unsigned long rulong; + +#define R_IS_POOL_PTR(pool,ptr) (((void*)(ULONG_PTR)(ptr) >= pool->UserBase) && ((ULONG_PTR)(ptr) < ((ULONG_PTR)pool->UserBase + pool->UserSize))) +#define R_ASSERT_PTR(pool,ptr) ASSERT( R_IS_POOL_PTR(pool,ptr) ) +#define R_ASSERT_SIZE(pool,sz) ASSERT( sz > (sizeof(R_USED)+2*R_RZ) && sz >= sizeof(R_FREE) && sz < pool->UserSize ) + +#ifndef R_ROUND_UP +#define R_ROUND_UP(x,s) ((PVOID)(((ULONG_PTR)(x)+(s)-1) & ~((ULONG_PTR)(s)-1))) +#endif//R_ROUND_UP + +#ifndef R_ROUND_DOWN +#define R_ROUND_DOWN(x,s) ((PVOID)(((ULONG_PTR)(x)) & ~((ULONG_PTR)(s)-1))) +#endif//R_ROUND_DOWN + +#ifndef R_QUEMIN +// R_QUEMIN is the minimum number of entries to keep in a que +#define R_QUEMIN 0 +#endif//R_QUEMIN + +#ifndef R_QUECOUNT +// 16, 32, 64, 128, 256, 512 +#define R_QUECOUNT 6 +#endif//R_QUECOUNT + +#ifndef R_RZ +// R_RZ is the redzone size +#define R_RZ 4 +#endif//R_RZ + +#ifndef R_RZ_LOVALUE +#define R_RZ_LOVALUE 0x87 +#endif//R_RZ_LOVALUE + +#ifndef R_RZ_HIVALUE +#define R_RZ_HIVALUE 0xA5 +#endif//R_RZ_HIVALUE + +#ifndef R_STACK +// R_STACK is the number of stack entries to store in blocks for debug purposes +#define R_STACK 6 +#else // R_STACK +#if R_STACK > 0 && R_STACK < 6 +/* Increase the frame depth to get a reasonable back trace */ +#undef R_STACK +#define R_STACK 6 +#endif // R_STACK > 0 && R_STACK < 6 +#endif//R_STACK + +#ifndef R_TAG +// R_TAG do we keep track of tags on a per-memory block basis? +#define R_TAG 0 +#endif//R_TAG + +#ifdef R_MAGIC +# ifndef R_FREE_MAGIC +# define R_FREE_MAGIC (rulong)(('F'<<0) + ('r'<<8) + ('E'<<16) + ('e'<<24)) +# endif//R_FREE_MAGIC +# ifndef R_USED_MAGIC +# define R_USED_MAGIC (rulong)(('u'<<0) + ('S'<<8) + ('e'<<16) + ('D'<<24)) +# endif//R_USED_MAGIC +#endif//R_MAGIC + +// **IMPORTANT NOTE** Magic, PrevSize, Size and Status must be at same offset +// in both the R_FREE and R_USED structures + +typedef struct _R_FREE +{ +#ifdef R_MAGIC + rulong FreeMagic; +#endif//R_MAGIC + rulong PrevSize : 30; + rulong Status : 2; + rulong Size; +#if R_STACK + ULONG_PTR LastOwnerStack[R_STACK]; +#endif//R_STACK + struct _R_FREE* NextFree; + struct _R_FREE* PrevFree; +} +R_FREE, *PR_FREE; + +typedef struct _R_USED +{ +#ifdef R_MAGIC + rulong UsedMagic; +#endif//R_MAGIC + rulong PrevSize : 30; + rulong Status : 2; + rulong Size; +#if R_STACK + ULONG_PTR LastOwnerStack[R_STACK]; +#endif//R_STACK + struct _R_USED* NextUsed; +#if R_RZ + rulong UserSize; // how many bytes the user actually asked for... +#endif//R_RZ + rulong Tag; +} +R_USED, *PR_USED; + +typedef struct _R_QUE +{ + rulong Count; + PR_USED First, Last; +} +R_QUE, *PR_QUE; + +typedef struct _R_POOL +{ + void* PoolBase; + rulong PoolSize; + void* UserBase; + rulong UserSize; + rulong Alignments[3]; + PR_FREE FirstFree, LastFree; + R_QUE Que[R_QUECOUNT][3]; + R_MUTEX Mutex; +} +R_POOL, *PR_POOL; + +PVOID MmPagedPoolBase; +ULONG MmPagedPoolSize; +ULONG MmTotalPagedPoolQuota = 0; // TODO FIXME commented out until we use it +static PR_POOL MmPagedPool = NULL; + +/* FUNCTIONS*******************************************************************/ + +#if !R_STACK +#define RiPrintLastOwner(Block) +#else +static void +RiPrintLastOwner ( PR_USED Block ) +{ + int i; + for ( i = 0; i < R_STACK; i++ ) + { + if ( Block->LastOwnerStack[i] != 0xDEADBEEF ) + { + R_DEBUG(" "); + //if (!R_PRINT_ADDRESS ((PVOID)Block->LastOwnerStack[i]) ) + { + R_DEBUG("<%X>", Block->LastOwnerStack[i] ); + } + } + } +} +#endif//R_STACK + +static int +RQueWhich ( rulong size ) +{ + rulong que, quesize; + for ( que=0, quesize=16; que < R_QUECOUNT; que++, quesize<<=1 ) + { + if ( quesize >= size ) + { + return que; + } + } + return -1; +} + +static void +RQueInit ( PR_QUE que ) +{ + que->Count = 0; + que->First = NULL; + que->Last = NULL; +} + +static void +RQueAdd ( PR_QUE que, PR_USED Item ) +{ + ASSERT(Item); + Item->Status = 2; + Item->NextUsed = NULL; + ++que->Count; + if ( !que->Last ) + { + que->First = que->Last = Item; + return; + } + ASSERT(!que->Last->NextUsed); + que->Last->NextUsed = Item; + que->Last = Item; +} + +static PR_USED +RQueRemove ( PR_QUE que ) +{ + PR_USED Item; +#if R_QUEMIN + if ( que->count < R_QUEMIN ) + return NULL; +#endif + if ( !que->First ) + return NULL; + Item = que->First; + que->First = Item->NextUsed; + if ( !--que->Count ) + { + ASSERT ( !que->First ); + que->Last = NULL; + } + Item->Status = 0; + return Item; +} + +static void +RPoolAddFree ( PR_POOL pool, PR_FREE Item ) +{ + ASSERT(pool); + ASSERT(Item); + if ( !pool->FirstFree ) + { + pool->FirstFree = pool->LastFree = Item; + Item->NextFree = NULL; + } + else + { + pool->FirstFree->PrevFree = Item; + Item->NextFree = pool->FirstFree; + pool->FirstFree = Item; + } + Item->PrevFree = NULL; +} + +static void +RPoolRemoveFree ( PR_POOL pool, PR_FREE Item ) +{ + ASSERT(pool); + ASSERT(Item); + if ( Item->NextFree ) + Item->NextFree->PrevFree = Item->PrevFree; + else + { + ASSERT ( pool->LastFree == Item ); + pool->LastFree = Item->PrevFree; + } + if ( Item->PrevFree ) + Item->PrevFree->NextFree = Item->NextFree; + else + { + ASSERT ( pool->FirstFree == Item ); + pool->FirstFree = Item->NextFree; + } +#if DBG + Item->NextFree = Item->PrevFree = (PR_FREE)(ULONG_PTR)0xDEADBEEF; +#endif//DBG +} + +#if !R_STACK +#define RFreeFillStack(free) +#define RUsedFillStack(used) +#else +static void +RFreeFillStack ( PR_FREE free ) +{ + int i; + ULONG stack[R_STACK+3]; // need to skip 3 known levels of stack trace + memset ( stack, 0xCD, sizeof(stack) ); + R_GET_STACK_FRAMES ( stack, R_STACK+3 ); + for ( i = 0; i < R_STACK; i++ ) + free->LastOwnerStack[i] = stack[i+3]; +} + +static void +RUsedFillStack ( PR_USED used ) +{ + int i; + ULONG stack[R_STACK+2]; // need to skip 2 known levels of stack trace + memset ( stack, 0xCD, sizeof(stack) ); + R_GET_STACK_FRAMES ( stack, R_STACK+2 ); + for ( i = 0; i < R_STACK; i++ ) + used->LastOwnerStack[i] = stack[i+2]; +} +#endif + +static PR_FREE +RFreeInit ( void* memory ) +{ + PR_FREE block = (PR_FREE)memory; +#if R_FREEMAGIC + block->FreeMagic = R_FREE_MAGIC; +#endif//R_FREEMAGIC + block->Status = 0; + RFreeFillStack ( block ); +#if DBG + block->PrevFree = block->NextFree = (PR_FREE)(ULONG_PTR)0xDEADBEEF; +#endif//DBG + return block; +} + +PR_POOL +RPoolInit ( void* PoolBase, rulong PoolSize, int align1, int align2, int align3 ) +{ + int align, que; + PR_POOL pool = (PR_POOL)PoolBase; + + pool->PoolBase = PoolBase; + pool->PoolSize = PoolSize; + pool->UserBase = (char*)pool->PoolBase + sizeof(R_POOL); + pool->UserSize = PoolSize - sizeof(R_POOL); + pool->Alignments[0] = align1; + pool->Alignments[1] = align2; + pool->Alignments[2] = align3; + pool->FirstFree = pool->LastFree = NULL; + + RPoolAddFree ( pool, + RFreeInit ( pool->UserBase )); + + pool->FirstFree->PrevSize = 0; + pool->FirstFree->Size = pool->UserSize; + + for ( que = 0; que < R_QUECOUNT; que++ ) + { + for ( align = 0; align < 3; align++ ) + { + RQueInit ( &pool->Que[que][align] ); + } + } + return pool; +} + +#if R_RZ +static const char* +RFormatTag ( rulong Tag, char* buf ) +{ + int i; + *(rulong*)&buf[0] = Tag; + buf[4] = 0; + for ( i = 0; i < 4; i++ ) + { + if ( !buf[i] ) + buf[i] = ' '; + } + return buf; +} +#endif + +#if !R_RZ +#define RUsedRedZoneCheck(pUsed,Addr,file,line, printzone) +#else//R_RZ +static void +RiBadBlock ( PR_USED pUsed, char* Addr, const char* violation, const char* file, int line, int printzone ) +{ + char tag[5]; + unsigned int i; + + R_DEBUG("%s(%i): %s detected for paged pool address 0x%x\n", + file, line, violation, Addr ); + +#ifdef R_MAGIC + R_DEBUG ( "UsedMagic 0x%x, ", pUsed->UsedMagic ); +#endif//R_MAGIC + R_DEBUG ( "Tag %s(%X), Size %i, UserSize %i", + RFormatTag(pUsed->Tag,tag), + pUsed->Tag, + pUsed->Size, + pUsed->UserSize ); + + if ( printzone ) + { + unsigned char* HiZone = (unsigned char*)Addr + pUsed->UserSize; + unsigned char* LoZone = (unsigned char*)Addr - R_RZ; // this is to simplify indexing below... + R_DEBUG ( ", LoZone " ); + for ( i = 0; i < R_RZ; i++ ) + R_DEBUG ( "%02x", LoZone[i] ); + R_DEBUG ( ", HiZone " ); + for ( i = 0; i < R_RZ; i++ ) + R_DEBUG ( "%02x", HiZone[i] ); + } + R_DEBUG ( "\n" ); + + R_DEBUG ( "First few Stack Frames:" ); + RiPrintLastOwner ( pUsed ); + R_DEBUG ( "\n" ); + + R_DEBUG ( "Contents of Block:\n" ); + for ( i = 0; i < 8*16 && i < pUsed->UserSize; i += 16 ) + { + int j; + R_DEBUG ( "%04X ", i ); + for ( j = 0; j < 16; j++ ) + { + if ( i+j < pUsed->UserSize ) + { + R_DEBUG ( "%02X ", (unsigned)(unsigned char)Addr[i+j] ); + } + else + { + R_DEBUG ( " " ); + } + } + R_DEBUG(" "); + for ( j = 0; j < 16; j++ ) + { + if ( i+j < pUsed->UserSize ) + { + char c = Addr[i+j]; + if ( c < 0x20 || c > 0x7E ) + c = '.'; + R_DEBUG ( "%c", c ); + } + else + { + R_DEBUG ( " " ); + } + } + R_DEBUG("\n"); + } + R_PANIC(); +} +static void +RUsedRedZoneCheck ( PR_POOL pool, PR_USED pUsed, char* Addr, const char* file, int line ) +{ + int i; + unsigned char *LoZone, *HiZone; + int bLow = 1; + int bHigh = 1; + + ASSERT ( Addr >= (char*)pool->UserBase && Addr < ((char*)pool->UserBase + pool->UserSize - 16) ); +#ifdef R_MAGIC + if ( pUsed->UsedMagic == R_FREE_MAGIC ) + { + pUsed->UserSize = 0; // just to keep from confusion, MmpBadBlock() doesn't return... + RiBadBlock ( pUsed, Addr, "double-free", file, line, 0 ); + } + if ( pUsed->UsedMagic != R_USED_MAGIC ) + { + RiBadBlock ( pUsed, Addr, "bad magic", file, line, 0 ); + } +#endif//R_MAGIC + switch ( pUsed->Status ) + { + case 0: // freed into main pool + case 2: // in ques + RiBadBlock ( pUsed, Addr, "double-free", file, line, 0 ); + // no need for break here - RiBadBlock doesn't return + case 1: // allocated - this is okay + break; + default: + RiBadBlock ( pUsed, Addr, "corrupt status", file, line, 0 ); + } + if ( pUsed->Status != 1 ) + { + RiBadBlock ( pUsed, Addr, "double-free", file, line, 0 ); + } + if ( pUsed->Size > pool->PoolSize || pUsed->Size == 0 ) + { + RiBadBlock ( pUsed, Addr, "invalid size", file, line, 0 ); + } + if ( pUsed->UserSize > pool->PoolSize || pUsed->UserSize == 0 ) + { + RiBadBlock ( pUsed, Addr, "invalid user size", file, line, 0 ); + } + HiZone = (unsigned char*)Addr + pUsed->UserSize; + LoZone = (unsigned char*)Addr - R_RZ; // this is to simplify indexing below... + for ( i = 0; i < R_RZ && bLow && bHigh; i++ ) + { + bLow = bLow && ( LoZone[i] == R_RZ_LOVALUE ); + bHigh = bHigh && ( HiZone[i] == R_RZ_HIVALUE ); + } + if ( !bLow || !bHigh ) + { + const char* violation = "High and Low-side redzone overwrite"; + if ( bHigh ) // high is okay, so it was just low failed + violation = "Low-side redzone overwrite"; + else if ( bLow ) // low side is okay, so it was just high failed + violation = "High-side redzone overwrite"; + RiBadBlock ( pUsed, Addr, violation, file, line, 1 ); + } +} +#endif//R_RZ + +PR_FREE +RPreviousBlock ( PR_FREE Block ) +{ + if ( Block->PrevSize > 0 ) + return (PR_FREE)( (char*)Block - Block->PrevSize ); + return NULL; +} + +PR_FREE +RNextBlock ( PR_POOL pool, PR_FREE Block ) +{ + PR_FREE NextBlock = (PR_FREE)( (char*)Block + Block->Size ); + if ( (char*)NextBlock >= (char*)pool->UserBase + pool->UserSize ) + NextBlock = NULL; + return NextBlock; +} + +static __inline void* +RHdrToBody ( void* blk ) +/* + * FUNCTION: Translate a block header address to the corresponding block + * address (internal) + */ +{ + return ( (void *) ((char*)blk + sizeof(R_USED) + R_RZ) ); +} + +static __inline PR_USED +RBodyToHdr ( void* addr ) +{ + return (PR_USED) + ( ((char*)addr) - sizeof(R_USED) - R_RZ ); +} + +static int +RiInFreeChain ( PR_POOL pool, PR_FREE Block ) +{ + PR_FREE Free; + Free = pool->FirstFree; + if ( Free == Block ) + return 1; + while ( Free != Block ) + { + Free = Free->NextFree; + if ( !Free ) + return 0; + } + return 1; +} + +static void +RPoolRedZoneCheck ( PR_POOL pool, const char* file, int line ) +{ + { + PR_USED Block = (PR_USED)pool->UserBase; + PR_USED NextBlock; + + for ( ;; ) + { + switch ( Block->Status ) + { + case 0: // block is in chain + ASSERT ( RiInFreeChain ( pool, (PR_FREE)Block ) ); + break; + case 1: // block is allocated + RUsedRedZoneCheck ( pool, Block, RHdrToBody(Block), file, line ); + break; + case 2: // block is in que + // nothing to verify here yet + break; + default: + ASSERT ( !"invalid status in memory block found in pool!" ); + } + NextBlock = (PR_USED)RNextBlock(pool,(PR_FREE)Block); + if ( !NextBlock ) + break; + ASSERT ( NextBlock->PrevSize == Block->Size ); + Block = NextBlock; + } + } + { + // now let's step through the list of free pointers and verify + // each one can be found by size-jumping... + PR_FREE Free = (PR_FREE)pool->FirstFree; + while ( Free ) + { + PR_FREE NextFree = (PR_FREE)pool->UserBase; + if ( Free != NextFree ) + { + while ( NextFree != Free ) + { + NextFree = RNextBlock ( pool, NextFree ); + ASSERT(NextFree); + } + } + Free = Free->NextFree; + } + } +} + +static void +RSetSize ( PR_POOL pool, PR_FREE Block, rulong NewSize, PR_FREE NextBlock ) +{ + R_ASSERT_PTR(pool,Block); + ASSERT ( NewSize < pool->UserSize ); + ASSERT ( NewSize >= sizeof(R_FREE) ); + Block->Size = NewSize; + if ( !NextBlock ) + NextBlock = RNextBlock ( pool, Block ); + if ( NextBlock ) + NextBlock->PrevSize = NewSize; +} + +static PR_FREE +RFreeSplit ( PR_POOL pool, PR_FREE Block, rulong NewSize ) +{ + PR_FREE NewBlock = (PR_FREE)((char*)Block + NewSize); + RSetSize ( pool, NewBlock, Block->Size - NewSize, NULL ); + RSetSize ( pool, Block, NewSize, NewBlock ); + RFreeInit ( NewBlock ); + RPoolAddFree ( pool, NewBlock ); + return NewBlock; +} + +static void +RFreeMerge ( PR_POOL pool, PR_FREE First, PR_FREE Second ) +{ + ASSERT ( RPreviousBlock(Second) == First ); + ASSERT ( First->Size == Second->PrevSize ); + RPoolRemoveFree ( pool, Second ); + RSetSize ( pool, First, First->Size + Second->Size, NULL ); +} + +static void +RPoolReclaim ( PR_POOL pool, PR_FREE FreeBlock ) +{ + PR_FREE NextBlock, PreviousBlock; + + RFreeInit ( FreeBlock ); + RPoolAddFree ( pool, FreeBlock ); + + // TODO FIXME - don't merge and always insert freed blocks at the end for debugging purposes... + + /* + * If the next block is immediately adjacent to the newly freed one then + * merge them. + * PLEASE DO NOT WIPE OUT 'MAGIC' OR 'LASTOWNER' DATA FOR MERGED FREE BLOCKS + */ + NextBlock = RNextBlock ( pool, FreeBlock ); + if ( NextBlock != NULL && !NextBlock->Status ) + { + RFreeMerge ( pool, FreeBlock, NextBlock ); + } + + /* + * If the previous block is adjacent to the newly freed one then + * merge them. + * PLEASE DO NOT WIPE OUT 'MAGIC' OR 'LASTOWNER' DATA FOR MERGED FREE BLOCKS + */ + PreviousBlock = RPreviousBlock ( FreeBlock ); + if ( PreviousBlock != NULL && !PreviousBlock->Status ) + { + RFreeMerge ( pool, PreviousBlock, FreeBlock ); + } +} + +static void +RiUsedInit ( PR_USED Block, rulong Tag ) +{ + Block->Status = 1; + RUsedFillStack ( Block ); +#ifdef R_MAGIC + Block->UsedMagic = R_USED_MAGIC; +#endif//R_MAGIC + //ASSERT_SIZE ( Block->Size ); + + // now add the block to the used block list +#if DBG + Block->NextUsed = (PR_USED)(ULONG_PTR)0xDEADBEEF; +#endif//R_USED_LIST + + Block->Tag = Tag; +} + +#if !R_RZ +#define RiUsedInitRedZone(Block,UserSize) +#else//R_RZ +static void +RiUsedInitRedZone ( PR_USED Block, rulong UserSize ) +{ + // write out buffer-overrun detection bytes + char* Addr = (char*)RHdrToBody(Block); + Block->UserSize = UserSize; + memset ( Addr - R_RZ, R_RZ_LOVALUE, R_RZ ); + memset ( Addr + Block->UserSize, R_RZ_HIVALUE, R_RZ ); +#if DBG + memset ( Addr, 0xCD, UserSize ); +#endif//DBG +} +#endif//R_RZ + +static void* +RPoolAlloc ( PR_POOL pool, rulong NumberOfBytes, rulong Tag, rulong align ) +{ + PR_USED NewBlock; + PR_FREE BestBlock, + NextBlock, + PreviousBlock, + BestPreviousBlock, + CurrentBlock; + void* BestAlignedAddr; + int que, + queBytes = NumberOfBytes; + rulong BlockSize, + Alignment; + int que_reclaimed = 0; + + ASSERT ( pool ); + ASSERT ( align < 3 ); + + R_ACQUIRE_MUTEX(pool); + + if ( !NumberOfBytes ) + { + R_DEBUG("0 bytes requested - initiating pool verification\n"); + RPoolRedZoneCheck ( pool, __FILE__, __LINE__ ); + R_RELEASE_MUTEX(pool); + return NULL; + } + if ( NumberOfBytes > pool->PoolSize ) + { + if ( R_IS_POOL_PTR(pool,NumberOfBytes) ) + { + R_DEBUG("red zone verification requested for block 0x%X\n", NumberOfBytes ); + RUsedRedZoneCheck(pool,RBodyToHdr((void*)(ULONG_PTR)NumberOfBytes), (char*)(ULONG_PTR)NumberOfBytes, __FILE__, __LINE__ ); + R_RELEASE_MUTEX(pool); + return NULL; + } + R_DEBUG("Invalid allocation request: %i bytes\n", NumberOfBytes ); + R_RELEASE_MUTEX(pool); + return NULL; + } + + que = RQueWhich ( NumberOfBytes ); + if ( que >= 0 ) + { + if ( (NewBlock = RQueRemove ( &pool->Que[que][align] )) ) + { + RiUsedInit ( NewBlock, Tag ); + RiUsedInitRedZone ( NewBlock, NumberOfBytes ); + R_RELEASE_MUTEX(pool); + return RHdrToBody(NewBlock); + } + queBytes = 16 << que; + } + + /* + * Calculate the total number of bytes we will need. + */ + BlockSize = queBytes + sizeof(R_USED) + 2*R_RZ; + if (BlockSize < sizeof(R_FREE)) + { + /* At least we need the size of the free block header. */ + BlockSize = sizeof(R_FREE); + } + +try_again: + /* + * Find the best-fitting block. + */ + BestBlock = NULL; + Alignment = pool->Alignments[align]; + PreviousBlock = NULL; + BestPreviousBlock = NULL, + CurrentBlock = pool->FirstFree; + BestAlignedAddr = NULL; + + while ( CurrentBlock != NULL ) + { + PVOID Addr = RHdrToBody(CurrentBlock); + PVOID CurrentBlockEnd = (char*)CurrentBlock + CurrentBlock->Size; + /* calculate last size-aligned address available within this block */ + PVOID AlignedAddr = R_ROUND_DOWN((char*)CurrentBlockEnd-queBytes-R_RZ, Alignment); + ASSERT ( (char*)AlignedAddr+queBytes+R_RZ <= (char*)CurrentBlockEnd ); + + /* special case, this address is already size-aligned, and the right size */ + if ( Addr == AlignedAddr ) + { + BestAlignedAddr = AlignedAddr; + BestPreviousBlock = PreviousBlock; + BestBlock = CurrentBlock; + break; + } + // if we carve out a size-aligned block... is it still past the end of this + // block's free header? + else if ( (char*)RBodyToHdr(AlignedAddr) + >= (char*)CurrentBlock+sizeof(R_FREE) ) + { + /* + * there's enough room to allocate our size-aligned memory out + * of this block, see if it's a better choice than any previous + * finds + */ + if ( BestBlock == NULL + || BestBlock->Size > CurrentBlock->Size ) + { + BestAlignedAddr = AlignedAddr; + BestPreviousBlock = PreviousBlock; + BestBlock = CurrentBlock; + } + } + + PreviousBlock = CurrentBlock; + CurrentBlock = CurrentBlock->NextFree; + } + + /* + * We didn't find anything suitable at all. + */ + if (BestBlock == NULL) + { + if ( !que_reclaimed ) + { + // reclaim que + int i, j; + for ( i = 0; i < R_QUECOUNT; i++ ) + { + for ( j = 0; j < 3; j++ ) + { + while ( (BestBlock = (PR_FREE)RQueRemove ( &pool->Que[i][j] )) ) + { + RPoolReclaim ( pool, BestBlock ); + } + } + } + + que_reclaimed = 1; + goto try_again; + } + DPRINT1("Trying to allocate %lu bytes from paged pool - nothing suitable found, returning NULL\n", + queBytes ); + R_RELEASE_MUTEX(pool); + return NULL; + } + /* + * we found a best block. If Addr isn't already aligned, we've pre-qualified that + * there's room at the beginning of the block for a free block... + */ + { + void* Addr = RHdrToBody(BestBlock); + if ( BestAlignedAddr != Addr ) + { + PR_FREE NewFreeBlock = RFreeSplit ( + pool, + BestBlock, + (char*)RBodyToHdr(BestAlignedAddr) - (char*)BestBlock ); + ASSERT ( BestAlignedAddr > Addr ); + + //DPRINT ( "breaking off preceding bytes into their own block...\n" ); + /*DPRINT ( "NewFreeBlock 0x%x Size %lu (Old Block's new size %lu) NextFree 0x%x\n", + NewFreeBlock, NewFreeBlock->Size, BestBlock->Size, BestBlock->NextFree );*/ + + /* we want the following code to use our size-aligned block */ + BestPreviousBlock = BestBlock; + BestBlock = NewFreeBlock; + + //VerifyPagedPool(); + } + } + /* + * Is there enough space to create a second block from the unused portion. + */ + if ( (BestBlock->Size - BlockSize) > sizeof(R_FREE) ) + { + /*DPRINT("BestBlock 0x%x Size 0x%x BlockSize 0x%x NewSize 0x%x\n", + BestBlock, BestBlock->Size, BlockSize, NewSize );*/ + + /* + * Create the new free block. + */ + NextBlock = RFreeSplit ( pool, BestBlock, BlockSize ); + //ASSERT_SIZE ( NextBlock->Size ); + } + /* + * Remove the selected block from the list of free blocks. + */ + //DPRINT ( "Removing selected block from free block list\n" ); + RPoolRemoveFree ( pool, BestBlock ); + /* + * Create the new used block header. + */ + NewBlock = (PR_USED)BestBlock; + RiUsedInit ( NewBlock, Tag ); + + /* RtlZeroMemory(RHdrToBody(NewBlock), NumberOfBytes);*/ + + RiUsedInitRedZone ( NewBlock, NumberOfBytes ); + R_RELEASE_MUTEX(pool); + + return RHdrToBody(NewBlock); +} + +static void +RPoolFree ( PR_POOL pool, void* Addr ) +{ + PR_USED UsedBlock; + rulong UsedSize; + PR_FREE FreeBlock; + rulong UserSize; + int que; + + ASSERT(pool); + if ( !Addr ) + { + R_DEBUG("Attempt to free NULL ptr, initiating Red Zone Check\n" ); + R_ACQUIRE_MUTEX(pool); + RPoolRedZoneCheck ( pool, __FILE__, __LINE__ ); + R_RELEASE_MUTEX(pool); + return; + } + R_ASSERT_PTR(pool,Addr); + + UsedBlock = RBodyToHdr(Addr); + UsedSize = UsedBlock->Size; + FreeBlock = (PR_FREE)UsedBlock; +#if R_RZ + UserSize = UsedBlock->UserSize; +#else + UserSize = UsedSize - sizeof(R_USED) - 2*R_RZ; +#endif//R_RZ + + RUsedRedZoneCheck ( pool, UsedBlock, Addr, __FILE__, __LINE__ ); + +#if R_RZ + memset ( Addr, 0xCD, UsedBlock->UserSize ); +#endif + + que = RQueWhich ( UserSize ); + if ( que >= 0 ) + { + int queBytes = 16 << que; + ASSERT( (rulong)queBytes >= UserSize ); + if ( que >= 0 ) + { + int align = 0; + if ( R_ROUND_UP(Addr,pool->Alignments[2]) == Addr ) + align = 2; + else if ( R_ROUND_UP(Addr,pool->Alignments[1]) == Addr ) + align = 1; + R_ACQUIRE_MUTEX(pool); + RQueAdd ( &pool->Que[que][align], UsedBlock ); + R_RELEASE_MUTEX(pool); + return; + } + } + + R_ACQUIRE_MUTEX(pool); + RPoolReclaim ( pool, FreeBlock ); + R_RELEASE_MUTEX(pool); +} + +VOID +INIT_FUNCTION +NTAPI +MmInitializePagedPool(VOID) +{ + /* + * We are still at a high IRQL level at this point so explicitly commit + * the first page of the paged pool before writing the first block header. + */ + MmCommitPagedPoolAddress ( (PVOID)MmPagedPoolBase, FALSE ); + + MmPagedPool = RPoolInit ( MmPagedPoolBase, + MmPagedPoolSize, + MM_POOL_ALIGNMENT, + MM_CACHE_LINE_SIZE, + PAGE_SIZE ); + + ExInitializeFastMutex(&MmPagedPool->Mutex); +} + +PVOID NTAPI +ExAllocatePagedPoolWithTag (IN POOL_TYPE PoolType, + IN ULONG NumberOfBytes, + IN ULONG Tag) +{ + int align; + + if ( NumberOfBytes >= PAGE_SIZE ) + align = 2; + else if ( PoolType & CACHE_ALIGNED_POOL_MASK ) + align = 1; + else + align = 0; + + ASSERT_IRQL_LESS_OR_EQUAL(APC_LEVEL); + + return RPoolAlloc ( MmPagedPool, NumberOfBytes, Tag, align ); +} + +VOID NTAPI +ExFreePagedPool(IN PVOID Block) +{ + ASSERT_IRQL_LESS_OR_EQUAL(APC_LEVEL); + RPoolFree ( MmPagedPool, Block ); +} + +/* EOF */ Propchange: trunk/reactos/ntoskrnl/mm/ppool.c ------------------------------------------------------------------------------ svn:eol-style = native Modified: trunk/reactos/ntoskrnl/ntoskrnl-generic.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/ntoskrnl-generic.… ============================================================================== --- trunk/reactos/ntoskrnl/ntoskrnl-generic.rbuild [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/ntoskrnl-generic.rbuild [iso-8859-1] Sun Jan 3 06:24:30 2010 @@ -414,6 +414,7 @@ <file>pagefile.c</file> <file>pageop.c</file> <file>pe.c</file> + <file>ppool.c</file> <file>procsup.c</file> <file>region.c</file> <file>rmap.c</file>

14 years, 10 months

[ros-arm-bringup] 44903: - Fix some pool calculations. - Check for some untested pool calculations. - Handle paging-in the page tables when needed. - Setup paging colors based on L2 cache size/associativity. - Setup system PTE size earlier.

by ros-arm-bringup＠svn.reactos.org

Author: ros-arm-bringup Date: Sun Jan 3 06:10:09 2010 New Revision: 44903 URL: http://svn.reactos.org/svn/reactos?rev=44903&view=rev Log: - Fix some pool calculations. - Check for some untested pool calculations. - Handle paging-in the page tables when needed. - Setup paging colors based on L2 cache size/associativity. - Setup system PTE size earlier. Modified: trunk/reactos/ntoskrnl/mm/ARM3/i386/init.c trunk/reactos/ntoskrnl/mm/ARM3/miarm.h trunk/reactos/ntoskrnl/mm/ARM3/pagfault.c Modified: trunk/reactos/ntoskrnl/mm/ARM3/i386/init.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/mm/ARM3/i386/init… ============================================================================== --- trunk/reactos/ntoskrnl/mm/ARM3/i386/init.c [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/mm/ARM3/i386/init.c [iso-8859-1] Sun Jan 3 06:10:09 2010 @@ -152,6 +152,14 @@ PMMPTE MmSystemPagePtes; // +// The system cache starts right after hyperspace. The first few pages are for +// keeping track of the system working set list. +// +// This should be 0xC0C00000 -- the cache itself starts at 0xC1000000 +// +PMMWSL MmSystemCacheWorkingSetList = MI_SYSTEM_CACHE_WS_START; + +// // Windows NT seems to choose between 7000, 11000 and 50000 // On systems with more than 32MB, this number is then doubled, and further // aligned up to a PDE boundary (4MB). @@ -222,6 +230,22 @@ PVOID MmSystemCacheStart; PVOID MmSystemCacheEnd; MMSUPPORT MmSystemCacheWs; + +// +// This is where hyperspace ends (followed by the system cache working set) +// +PVOID MmHyperSpaceEnd; + +// +// Page coloring algorithm data +// +ULONG MmSecondaryColors; +ULONG MmSecondaryColorMask; + +// +// Actual (registry-configurable) size of a GUI thread's stack +// +ULONG MmLargeStackSize; /* PRIVATE FUNCTIONS **********************************************************/ @@ -276,6 +300,48 @@ MxFreeDescriptor->BasePage += PageCount; MxFreeDescriptor->PageCount -= PageCount; return Pfn; +} + +PFN_NUMBER +NTAPI +MiPagesInLoaderBlock(IN PLOADER_PARAMETER_BLOCK LoaderBlock, + IN PBOOLEAN IncludeType) +{ + PLIST_ENTRY NextEntry; + PFN_NUMBER PageCount = 0; + PMEMORY_ALLOCATION_DESCRIPTOR MdBlock; + + // + // Now loop through the descriptors + // + NextEntry = LoaderBlock->MemoryDescriptorListHead.Flink; + while (NextEntry != &LoaderBlock->MemoryDescriptorListHead) + { + // + // Grab each one, and check if it's one we should include + // + MdBlock = CONTAINING_RECORD(NextEntry, + MEMORY_ALLOCATION_DESCRIPTOR, + ListEntry); + if ((MdBlock->MemoryType < LoaderMaximum) && + (IncludeType[MdBlock->MemoryType])) + { + // + // Add this to our running total + // + PageCount += MdBlock->PageCount; + } + + // + // Try the next descriptor + // + NextEntry = MdBlock->ListEntry.Flink; + } + + // + // Return the total + // + return PageCount; } PPHYSICAL_MEMORY_DESCRIPTOR @@ -606,17 +672,26 @@ PLIST_ENTRY NextEntry; PMEMORY_ALLOCATION_DESCRIPTOR MdBlock; ULONG FreePages = 0; - PFN_NUMBER PageFrameIndex; + PFN_NUMBER PageFrameIndex, PoolPages; PMMPTE StartPde, EndPde, PointerPte, LastPte; MMPTE TempPde = HyperTemplatePte, TempPte = HyperTemplatePte; PVOID NonPagedPoolExpansionVa; - ULONG OldCount; + ULONG OldCount, i, L2Associativity; BOOLEAN IncludeType[LoaderMaximum]; - ULONG i; PVOID Bitmap; PPHYSICAL_MEMORY_RUN Run; PFN_NUMBER FreePage, FreePageCount, PagesLeft, BasePage, PageCount; + // + // Instantiate memory that we don't consider RAM/usable + // We use the same exclusions that Windows does, in order to try to be + // compatible with WinLDR-style booting + // + for (i = 0; i < LoaderMaximum; i++) IncludeType[i] = TRUE; + IncludeType[LoaderBad] = FALSE; + IncludeType[LoaderFirmwarePermanent] = FALSE; + IncludeType[LoaderSpecialMemory] = FALSE; + IncludeType[LoaderBBTMemory] = FALSE; if (Phase == 0) { // @@ -698,7 +773,61 @@ // MiSystemViewStart = (PVOID)((ULONG_PTR)MmSessionBase - MmSystemViewSize); - + + // + // Count physical pages on the system + // + PageCount = MiPagesInLoaderBlock(LoaderBlock, IncludeType); + + // + // Check if this is a machine with less than 19MB of RAM + // + if (PageCount < MI_MIN_PAGES_FOR_SYSPTE_TUNING) + { + // + // Use the very minimum of system PTEs + // + MmNumberOfSystemPtes = 7000; + } + else + { + // + // Use the default, but check if we have more than 32MB of RAM + // + MmNumberOfSystemPtes = 11000; + if (PageCount > MI_MIN_PAGES_FOR_SYSPTE_BOOST) + { + // + // Double the amount of system PTEs + // + MmNumberOfSystemPtes <<= 1; + } + } + + DPRINT("System PTE count has been tuned to %d (%d bytes)\n", + MmNumberOfSystemPtes, MmNumberOfSystemPtes * PAGE_SIZE); + + // + // + // Start of Architecture Specific Initialization Code + // + // + + // + // The large kernel stack is cutomizable, but use default value for now + // + MmLargeStackSize = KERNEL_LARGE_STACK_SIZE; + + // + // Setup template + // + HyperTemplatePte.u.Long = 0; + HyperTemplatePte.u.Hard.Valid = 1; + HyperTemplatePte.u.Hard.Write = 1; + HyperTemplatePte.u.Hard.Dirty = 1; + HyperTemplatePte.u.Hard.Accessed = 1; + if (Ke386GlobalPagesEnabled) HyperTemplatePte.u.Hard.Global = 1; + // // Set CR3 for the system process // @@ -784,9 +913,13 @@ // // For now, it is // - FreePages = MdBlock->PageCount; MxFreeDescriptor = MdBlock; } + + // + // More free pages + // + FreePages += MdBlock->PageCount; } } @@ -803,34 +936,6 @@ MxOldFreeDescriptor = *MxFreeDescriptor; // - // Check if this is a machine with less than 19MB of RAM - // - if (MmNumberOfPhysicalPages < MI_MIN_PAGES_FOR_SYSPTE_TUNING) - { - // - // Use the very minimum of system PTEs - // - MmNumberOfSystemPtes = 7000; - } - else - { - // - // Use the default, but check if we have more than 32MB of RAM - // - MmNumberOfSystemPtes = 11000; - if (MmNumberOfPhysicalPages > MI_MIN_PAGES_FOR_SYSPTE_BOOST) - { - // - // Double the amount of system PTEs - // - MmNumberOfSystemPtes <<= 1; - } - } - - DPRINT("System PTE count has been tuned to %d (%d bytes)\n", - MmNumberOfSystemPtes, MmNumberOfSystemPtes * PAGE_SIZE); - - // // Check if this is a machine with less than 256MB of RAM, and no overide // if ((MmNumberOfPhysicalPages <= MI_MIN_PAGES_FOR_NONPAGED_POOL_TUNING) && @@ -841,6 +946,11 @@ // MmSizeOfNonPagedPoolInBytes = 2 * 1024 * 1024; } + + // + // Hyperspace ends here + // + MmHyperSpaceEnd = (PVOID)((ULONG_PTR)MmSystemCacheWorkingSetList - 1); // // Check if the user gave a ridicuously large nonpaged pool RAM size @@ -900,26 +1010,86 @@ if (!MmMaximumNonPagedPoolInBytes) { // - // Start with the default (1MB) and add 400 KB for each MB above 4 + // Start with the default (1MB) // MmMaximumNonPagedPoolInBytes = MmDefaultMaximumNonPagedPool; - MmMaximumNonPagedPoolInBytes += (MmNumberOfPhysicalPages - 1024) / - 256 * MmMaxAdditionNonPagedPoolPerMb; - } + + // + // Add space for PFN database + // + MmMaximumNonPagedPoolInBytes += (ULONG) + PAGE_ALIGN((MmHighestPhysicalPage + 1) * sizeof(MMPFN)); + + // + // Add 400KB for each MB above 4 + // + MmMaximumNonPagedPoolInBytes += (FreePages - 1024) / 256 * + MmMaxAdditionNonPagedPoolPerMb; + } + + // + // Make sure there's at least 16 pages + the PFN available for expansion + // + PoolPages = MmSizeOfNonPagedPoolInBytes + (PAGE_SIZE * 16) + + ((ULONG)PAGE_ALIGN(MmHighestPhysicalPage + 1) * + sizeof(MMPFN)); + if (MmMaximumNonPagedPoolInBytes < PoolPages) + { + // + // Set it to the minimum value for the maximum (yuck!) + // + MmMaximumNonPagedPoolInBytes = PoolPages; + } + + // + // Systems with 2GB of kernel address space get double the size + // + PoolPages = MI_MAX_NONPAGED_POOL_SIZE * 2; // // Don't let the maximum go too high // + if (MmMaximumNonPagedPoolInBytes > PoolPages) + { + // + // Set it to the upper limit + // + MmMaximumNonPagedPoolInBytes = PoolPages; + } + + // + // Check if this is a system with > 128MB of non paged pool + // if (MmMaximumNonPagedPoolInBytes > MI_MAX_NONPAGED_POOL_SIZE) { // - // Set it to the upper limit - // - MmMaximumNonPagedPoolInBytes = MI_MAX_NONPAGED_POOL_SIZE; - } - - // - // Calculate the number of bytes, and then convert to pages + // FIXME: Unsure about additional checks needed + // + DPRINT1("Untested path\n"); + } + + // + // Get L2 cache information + // + L2Associativity = KeGetPcr()->SecondLevelCacheAssociativity; + MmSecondaryColors = KeGetPcr()->SecondLevelCacheSize; + if (L2Associativity) MmSecondaryColors /= L2Associativity; + + // + // Compute final color mask and count + // + MmSecondaryColors >>= PAGE_SHIFT; + if (!MmSecondaryColors) MmSecondaryColors = 1; + MmSecondaryColorMask = MmSecondaryColors - 1; + + // + // Store it + // + KeGetCurrentPrcb()->SecondaryColorMask = MmSecondaryColorMask; + + // + // Calculate the number of bytes for the PFN database + // and then convert to pages // MxPfnAllocation = (MmHighestPhysicalPage + 1) * sizeof(MMPFN); MxPfnAllocation >>= PAGE_SHIFT; @@ -973,6 +1143,19 @@ PAGE_SHIFT; MmNumberOfSystemPtes--; ASSERT(MmNumberOfSystemPtes > 1000); + } + + // + // Check if we are in a situation where the size of the paged pool + // is so large that it overflows into nonpaged pool + // + if (MmSizeOfPagedPoolInBytes > + ((ULONG_PTR)MmNonPagedSystemStart - (ULONG_PTR)MmPagedPoolStart)) + { + // + // We need some recalculations here + // + DPRINT1("Paged pool is too big!\n"); } // @@ -1295,18 +1478,7 @@ MiSyncARM3WithROS(MmNonPagedSystemStart, (PVOID)((ULONG_PTR)MmNonPagedPoolEnd - 1)); MiSyncARM3WithROS(MmPfnDatabase, (PVOID)((ULONG_PTR)MmNonPagedPoolStart + MmSizeOfNonPagedPoolInBytes - 1)); MiSyncARM3WithROS((PVOID)HYPER_SPACE, (PVOID)(HYPER_SPACE + PAGE_SIZE - 1)); - - // - // Instantiate memory that we don't consider RAM/usable - // We use the same exclusions that Windows does, in order to try to be - // compatible with WinLDR-style booting - // - for (i = 0; i < LoaderMaximum; i++) IncludeType[i] = TRUE; - IncludeType[LoaderBad] = FALSE; - IncludeType[LoaderFirmwarePermanent] = FALSE; - IncludeType[LoaderSpecialMemory] = FALSE; - IncludeType[LoaderBBTMemory] = FALSE; - + // // Build the physical memory block // Modified: trunk/reactos/ntoskrnl/mm/ARM3/miarm.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/mm/ARM3/miarm.h?r… ============================================================================== --- trunk/reactos/ntoskrnl/mm/ARM3/miarm.h [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/mm/ARM3/miarm.h [iso-8859-1] Sun Jan 3 06:10:09 2010 @@ -26,6 +26,7 @@ #define MI_SYSTEM_VIEW_SIZE (16 * 1024 * 1024) +#define MI_SYSTEM_CACHE_WS_START (PVOID)0xC0C00000 #define MI_PAGED_POOL_START (PVOID)0xE1000000 #define MI_NONPAGED_POOL_END (PVOID)0xFFBE0000 #define MI_DEBUG_MAPPING (PVOID)0xFFBFF000 @@ -166,6 +167,7 @@ extern SIZE_T MmAllocatedNonPagedPool; extern ULONG_PTR MmSubsectionBase; extern ULONG MmSpecialPoolTag; +extern PVOID MmHyperSpaceEnd; NTSTATUS NTAPI Modified: trunk/reactos/ntoskrnl/mm/ARM3/pagfault.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/mm/ARM3/pagfault.… ============================================================================== --- trunk/reactos/ntoskrnl/mm/ARM3/pagfault.c [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/mm/ARM3/pagfault.c [iso-8859-1] Sun Jan 3 06:10:09 2010 @@ -140,8 +140,8 @@ KIRQL OldIrql; NTSTATUS Status; DPRINT("ARM3 Page Fault Dispatcher for address: %p in process: %p\n", - Address, - Process); + Address, + Process); // // Make sure APCs are off and we're not at dispatch @@ -297,14 +297,27 @@ // // Check for a fault on the page table or hyperspace itself - // FIXME: Use MmHyperSpaceEnd - // - if ((Address >= (PVOID)PTE_BASE) && (Address <= (PVOID)0xC0800000)) + // + if ((Address >= (PVOID)PTE_BASE) && (Address <= MmHyperSpaceEnd)) { // // This might happen...not sure yet // DPRINT1("FAULT ON PAGE TABLES!\n"); + + // + // Map in the page table + // + if (MiCheckPdeForPagedPool(Address) == STATUS_WAIT_1) + { + DPRINT1("PAGE TABLES FAULTED IN!\n"); + return STATUS_SUCCESS; + } + + // + // Otherwise the page table doesn't actually exist + // + DPRINT1("FAILING\n"); return STATUS_ACCESS_VIOLATION; }

14 years, 10 months

[jimtabor] 44902: [Win32k] - Patch by Dan Kegel: Fix minor read buffer overrun in CombineRgn. http://bugs.winehq.org/show_bug.cgi?id=20851 - When locking and unlocking regions, use probe to check attribute space first before read or write access.

by jimtabor＠svn.reactos.org

Author: jimtabor Date: Sun Jan 3 01:05:15 2010 New Revision: 44902 URL: http://svn.reactos.org/svn/reactos?rev=44902&view=rev Log: [Win32k] - Patch by Dan Kegel: Fix minor read buffer overrun in CombineRgn. http://bugs.winehq.org/show_bug.cgi?id=20851 - When locking and unlocking regions, use probe to check attribute space first before read or write access. Modified: trunk/reactos/subsystems/win32/win32k/objects/gdiobj.c trunk/reactos/subsystems/win32/win32k/objects/region.c Modified: trunk/reactos/subsystems/win32/win32k/objects/gdiobj.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/win32k/ob… ============================================================================== --- trunk/reactos/subsystems/win32/win32k/objects/gdiobj.c [iso-8859-1] (original) +++ trunk/reactos/subsystems/win32/win32k/objects/gdiobj.c [iso-8859-1] Sun Jan 3 01:05:15 2010 @@ -750,7 +750,12 @@ { return TRUE; } - if (pAttr) FreeObjectAttr(pAttr); + if (pAttr) + { + KeEnterCriticalRegion(); + FreeObjectAttr(pAttr); + KeLeaveCriticalRegion(); + } break; case GDI_OBJECT_TYPE_DC: Modified: trunk/reactos/subsystems/win32/win32k/objects/region.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/subsystems/win32/win32k/ob… ============================================================================== --- trunk/reactos/subsystems/win32/win32k/objects/region.c [iso-8859-1] (original) +++ trunk/reactos/subsystems/win32/win32k/objects/region.c [iso-8859-1] Sun Jan 3 01:05:15 2010 @@ -1650,7 +1650,8 @@ pNextRect++; } r1++; - left = r1->left; + if (r1 != r1End) + left = r1->left; } } @@ -2062,9 +2063,11 @@ } } + KeEnterCriticalRegion(); Index = GDI_HANDLE_GET_INDEX(hReg); Entry = &GdiHandleTable->Entries[Index]; Entry->UserData = AllocateObjectAttr(); + KeLeaveCriticalRegion(); EMPTY_REGION(pReg); pReg->rdh.dwSize = sizeof(RGNDATAHEADER); @@ -2081,22 +2084,26 @@ INT Index; PGDI_TABLE_ENTRY Entry; PROSRGNDATA pRgn; - PRGN_ATTR pRgn_Attr; + PRGN_ATTR pRgn_Attr; pRgn = REGION_LockRgn(hRgn); if (pRgn) { + KeEnterCriticalRegion(); Index = GDI_HANDLE_GET_INDEX(hRgn); Entry = &GdiHandleTable->Entries[Index]; - pRgn_Attr = Entry->UserData; + KeLeaveCriticalRegion(); if (pRgn_Attr) { _SEH2_TRY { - if ( pRgn_Attr->AttrFlags & (ATTR_RGN_VALID|ATTR_RGN_DIRTY) ) + ProbeForWrite(pRgn_Attr, sizeof(RGN_ATTR), 1); + + if ( !(pRgn_Attr->AttrFlags & ATTR_CACHED) && + pRgn_Attr->AttrFlags & (ATTR_RGN_VALID|ATTR_RGN_DIRTY) ) { switch (pRgn_Attr->Flags) { @@ -2142,15 +2149,18 @@ if (pRgn) { + KeEnterCriticalRegion(); Index = GDI_HANDLE_GET_INDEX(pRgn->BaseObject.hHmgr); Entry = &GdiHandleTable->Entries[Index]; - pRgn_Attr = Entry->UserData; - - _SEH2_TRY + KeLeaveCriticalRegion(); + + if ( pRgn_Attr ) { - if ( pRgn_Attr ) - { + _SEH2_TRY + { + ProbeForWrite(pRgn_Attr, sizeof(RGN_ATTR), 1); + if ( pRgn_Attr->AttrFlags & ATTR_RGN_VALID ) { pRgn_Attr->Flags = REGION_Complexity( pRgn ); @@ -2160,11 +2170,11 @@ pRgn_Attr->Rect.bottom = pRgn->rdh.rcBound.bottom; } } + _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + } + _SEH2_END; } - _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) - { - } - _SEH2_END; } REGION_UnlockRgn(pRgn); }

14 years, 10 months

[janderwald] 44901: [WDMAUD.DRV] - Partly revert 44873

by janderwald＠svn.reactos.org

Author: janderwald Date: Sat Jan 2 23:04:35 2010 New Revision: 44901 URL: http://svn.reactos.org/svn/reactos?rev=44901&view=rev Log: [WDMAUD.DRV] - Partly revert 44873 Modified: trunk/reactos/dll/win32/wdmaud.drv/wdmaud.rbuild Modified: trunk/reactos/dll/win32/wdmaud.drv/wdmaud.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/wdmaud.drv/wdmau… ============================================================================== --- trunk/reactos/dll/win32/wdmaud.drv/wdmaud.rbuild [iso-8859-1] (original) +++ trunk/reactos/dll/win32/wdmaud.drv/wdmaud.rbuild [iso-8859-1] Sat Jan 2 23:04:35 2010 @@ -5,7 +5,7 @@ <include base="wdmaud_kernel">.</include> <include base="mmixer">.</include> <include base="libsamplerate">.</include> - <define name="USE_MMIXER_LIB">1</define> +   <library>mmebuddy</library> <library>ntdll</library>

14 years, 10 months

[dgorbachev] 44900: Silence old GCC warning.

by dgorbachev＠svn.reactos.org

Author: dgorbachev Date: Sat Jan 2 21:49:59 2010 New Revision: 44900 URL: http://svn.reactos.org/svn/reactos?rev=44900&view=rev Log: Silence old GCC warning. Modified: trunk/reactos/ntoskrnl/mm/ARM3/procsup.c Modified: trunk/reactos/ntoskrnl/mm/ARM3/procsup.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/mm/ARM3/procsup.c… ============================================================================== --- trunk/reactos/ntoskrnl/mm/ARM3/procsup.c [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/mm/ARM3/procsup.c [iso-8859-1] Sat Jan 2 21:49:59 2010 @@ -168,7 +168,7 @@ } // Bug #4835 - InterlockedExchangeAddUL(&MiMemoryConsumers[MC_NPPOOL].PagesUsed, StackPages); + (VOID)InterlockedExchangeAddUL(&MiMemoryConsumers[MC_NPPOOL].PagesUsed, StackPages); // // Release the PFN lock

14 years, 10 months

[dgorbachev] 44899: Compensate for continuous memory usage decrease (bug #4835).

by dgorbachev＠svn.reactos.org

Author: dgorbachev Date: Sat Jan 2 21:41:04 2010 New Revision: 44899 URL: http://svn.reactos.org/svn/reactos?rev=44899&view=rev Log: Compensate for continuous memory usage decrease (bug #4835). Modified: trunk/reactos/ntoskrnl/mm/ARM3/procsup.c Modified: trunk/reactos/ntoskrnl/mm/ARM3/procsup.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/mm/ARM3/procsup.c… ============================================================================== --- trunk/reactos/ntoskrnl/mm/ARM3/procsup.c [iso-8859-1] (original) +++ trunk/reactos/ntoskrnl/mm/ARM3/procsup.c [iso-8859-1] Sat Jan 2 21:41:04 2010 @@ -166,7 +166,10 @@ // *PointerPte = TempPte; } - + + // Bug #4835 + InterlockedExchangeAddUL(&MiMemoryConsumers[MC_NPPOOL].PagesUsed, StackPages); + // // Release the PFN lock //

14 years, 10 months

[gschneider] 44898: [MSAFD] Only free if memory was allocated, fixes build

by gschneider＠svn.reactos.org

Author: gschneider Date: Sat Jan 2 21:26:36 2010 New Revision: 44898 URL: http://svn.reactos.org/svn/reactos?rev=44898&view=rev Log: [MSAFD] Only free if memory was allocated, fixes build Modified: trunk/reactos/dll/win32/msafd/misc/sndrcv.c Modified: trunk/reactos/dll/win32/msafd/misc/sndrcv.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msafd/misc/sndrc… ============================================================================== --- trunk/reactos/dll/win32/msafd/misc/sndrcv.c [iso-8859-1] (original) +++ trunk/reactos/dll/win32/msafd/misc/sndrcv.c [iso-8859-1] Sat Jan 2 21:26:36 2010 @@ -516,7 +516,7 @@ PVOID APCFunction; HANDLE Event = NULL; PTRANSPORT_ADDRESS RemoteAddress; - PSOCKADDR BindAddress; + PSOCKADDR BindAddress = NULL; INT BindAddressLength; HANDLE SockEvent; PSOCKET_INFORMATION Socket; @@ -546,7 +546,10 @@ RemoteAddress = HeapAlloc(GlobalHeap, 0, 0x6 + SocketAddressLength); if (!RemoteAddress) { - HeapFree(GlobalHeap, 0, BindAddress); + if (BindAddress != NULL) + { + HeapFree(GlobalHeap, 0, BindAddress); + } return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL); } @@ -557,7 +560,10 @@ if (!NT_SUCCESS(Status)) { HeapFree(GlobalHeap, 0, RemoteAddress); - HeapFree(GlobalHeap, 0, BindAddress); + if (BindAddress != NULL) + { + HeapFree(GlobalHeap, 0, BindAddress); + } return SOCKET_ERROR; } @@ -626,7 +632,10 @@ NtClose(SockEvent); HeapFree(GlobalHeap, 0, RemoteAddress); - HeapFree(GlobalHeap, 0, BindAddress); + if (BindAddress != NULL) + { + HeapFree(GlobalHeap, 0, BindAddress); + } if (Status == STATUS_PENDING) return WSA_IO_PENDING;

14 years, 10 months

[dgorbachev] 44897: Change base addresses of devenum.dll, inetcomm.dll, mshtml.dll.

by dgorbachev＠svn.reactos.org

Author: dgorbachev Date: Sat Jan 2 21:09:28 2010 New Revision: 44897 URL: http://svn.reactos.org/svn/reactos?rev=44897&view=rev Log: Change base addresses of devenum.dll, inetcomm.dll, mshtml.dll. Modified: trunk/reactos/baseaddress.rbuild Modified: trunk/reactos/baseaddress.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/baseaddress.rbuild?rev=448… ============================================================================== --- trunk/reactos/baseaddress.rbuild [iso-8859-1] (original) +++ trunk/reactos/baseaddress.rbuild [iso-8859-1] Sat Jan 2 21:09:28 2010 @@ -7,7 +7,7 @@ <property name="BASEADDRESS_CRYPTDLG" value="0x209c0000" /> <property name="BASEADDRESS_COMCAT" value="0x20a50000" /> <property name="BASEADDRESS_WINDOWSCODECS" value="0x26c40000" /> - <property name="BASEADDRESS_DEVENUM" value="0x35680000" /> + <property name="BASEADDRESS_DEVENUM" value="0x35670000" /> <property name="BASEADDRESS_RSABASE" value="0x35700000" /> <property name="BASEADDRESS_RSAENH" value="0x35780000" /> <property name="BASEADDRESS_URL" value="0x42ea0000" /> @@ -181,7 +181,7 @@ <property name="BASEADDRESS_CRYPTNET" value="0x75e60000" /> <property name="BASEADDRESS_RPCRT4" value="0x76000000" /> <property name="BASEADDRESS_SHLWAPI" value="0x76100000" /> - <property name="BASEADDRESS_INETCOMM" value="0x76150000" /> + <property name="BASEADDRESS_INETCOMM" value="0x76140000" /> <property name="BASEADDRESS_COMCTL32" value="0x76160000" /> <property name="BASEADDRESS_COMDLG32" value="0x76210000" /> <property name="BASEADDRESS_WINSTA" value="0x762f0000" /> @@ -196,7 +196,7 @@ <property name="BASEADDRESS_MIDIMAP" value="0x76600000" /> <property name="BASEADDRESS_WAVEMAP" value="0x76610000" /> <property name="BASEADDRESS_MPR" value="0x76620000" /> - <property name="BASEADDRESS_MSHTML" value="0x76660000" /> + <property name="BASEADDRESS_MSHTML" value="0x76650000" /> <property name="BASEADDRESS_ODBC32" value="0x76660000" /> <property name="BASEADDRESS_SETUPAPI" value="0x76660000" /> <property name="BASEADDRESS_CRYPTDLL" value="0x76740000" />

14 years, 10 months

[dgorbachev] 44896: Fix buffer overflow in WSPSendTo(), bug #5070.

by dgorbachev＠svn.reactos.org

Author: dgorbachev Date: Sat Jan 2 21:09:16 2010 New Revision: 44896 URL: http://svn.reactos.org/svn/reactos?rev=44896&view=rev Log: Fix buffer overflow in WSPSendTo(), bug #5070. Modified: trunk/reactos/dll/win32/msafd/misc/sndrcv.c Modified: trunk/reactos/dll/win32/msafd/misc/sndrcv.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/msafd/misc/sndrc… ============================================================================== --- trunk/reactos/dll/win32/msafd/misc/sndrcv.c [iso-8859-1] (original) +++ trunk/reactos/dll/win32/msafd/misc/sndrcv.c [iso-8859-1] Sat Jan 2 21:09:16 2010 @@ -516,21 +516,13 @@ PVOID APCFunction; HANDLE Event = NULL; PTRANSPORT_ADDRESS RemoteAddress; - UCHAR TdiBuffer[0x16]; PSOCKADDR BindAddress; INT BindAddressLength; HANDLE SockEvent; PSOCKET_INFORMATION Socket; - - /* Get the Socket Structure associate to this Socket*/ + /* Get the Socket Structure associate to this Socket */ Socket = GetSocketStructure(Handle); - - Status = NtCreateEvent( &SockEvent, GENERIC_READ | GENERIC_WRITE, - NULL, 1, FALSE ); - - if( !NT_SUCCESS(Status) ) - return -1; /* Bind us First */ if (Socket->SharedData.State == SocketOpen) @@ -540,19 +532,36 @@ BindAddress = HeapAlloc(GlobalHeap, 0, BindAddressLength); if (!BindAddress) { - MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL ); + MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL); return INVALID_SOCKET; } - Socket->HelperData->WSHGetWildcardSockaddr (Socket->HelperContext, - BindAddress, - &BindAddressLength); - + + Socket->HelperData->WSHGetWildcardSockaddr(Socket->HelperContext, + BindAddress, + &BindAddressLength); /* Bind it */ WSPBind(Handle, BindAddress, BindAddressLength, NULL); } + RemoteAddress = HeapAlloc(GlobalHeap, 0, 0x6 + SocketAddressLength); + if (!RemoteAddress) + { + HeapFree(GlobalHeap, 0, BindAddress); + return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL); + } + + Status = NtCreateEvent(&SockEvent, + GENERIC_READ | GENERIC_WRITE, + NULL, 1, FALSE); + + if (!NT_SUCCESS(Status)) + { + HeapFree(GlobalHeap, 0, RemoteAddress); + HeapFree(GlobalHeap, 0, BindAddress); + return SOCKET_ERROR; + } + /* Set up Address in TDI Format */ - RemoteAddress = (PTRANSPORT_ADDRESS)TdiBuffer; RemoteAddress->TAAddressCount = 1; RemoteAddress->Address[0].AddressLength = SocketAddressLength - sizeof(SocketAddress->sa_family); RtlCopyMemory(&RemoteAddress->Address[0].AddressType, SocketAddress, SocketAddressLength); @@ -585,7 +594,8 @@ else { /* Using Overlapped Structure and a Completition Routine, so use an APC */ - APCFunction = NULL; // should be a private io completition function inside us + /* Should be a private io completition function inside us */ + APCFunction = NULL; APCContext = lpCompletionRoutine; SendInfo.AfdFlags |= AFD_SKIP_FIO; } @@ -596,34 +606,37 @@ /* Send IOCTL */ Status = NtDeviceIoControlFile((HANDLE)Handle, - Event ? Event : SockEvent, - APCFunction, - APCContext, - IOSB, - IOCTL_AFD_SEND_DATAGRAM, - &SendInfo, - sizeof(SendInfo), - NULL, - 0); + Event ? Event : SockEvent, + APCFunction, + APCContext, + IOSB, + IOCTL_AFD_SEND_DATAGRAM, + &SendInfo, + sizeof(SendInfo), + NULL, + 0); /* Wait for completition of not overlapped */ if (Status == STATUS_PENDING && lpOverlapped == NULL) { - WaitForSingleObject(SockEvent, INFINITE); // BUGBUG, shouldn wait infintely for send... + /* BUGBUG, shouldn't wait infintely for send... */ + WaitForSingleObject(SockEvent, INFINITE); Status = IOSB->Status; } - NtClose( SockEvent ); + NtClose(SockEvent); + HeapFree(GlobalHeap, 0, RemoteAddress); + HeapFree(GlobalHeap, 0, BindAddress); if (Status == STATUS_PENDING) return WSA_IO_PENDING; - /* Re-enable Async Event */ SockReenableAsyncSelectEvent(Socket, FD_WRITE); - return MsafdReturnWithErrno ( Status, lpErrno, IOSB->Information, lpNumberOfBytesSent ); + return MsafdReturnWithErrno(Status, lpErrno, IOSB->Information, lpNumberOfBytesSent); } + INT WSPAPI WSPRecvDisconnect(IN SOCKET s,

14 years, 10 months

[tkreuzer] 44895: [KE] Add a comment to Kii386SpinOnSpinLock that it might be called from HAL with interrupts disabled

by tkreuzer＠svn.reactos.org

Author: tkreuzer Date: Sat Jan 2 21:07:14 2010 New Revision: 44895 URL: http://svn.reactos.org/svn/reactos?rev=44895&view=rev Log: [KE] Add a comment to Kii386SpinOnSpinLock that it might be called from HAL with interrupts disabled Modified: branches/ros-amd64-bringup/reactos/ntoskrnl/ke/spinlock.c Modified: branches/ros-amd64-bringup/reactos/ntoskrnl/ke/spinlock.c URL: http://svn.reactos.org/svn/reactos/branches/ros-amd64-bringup/reactos/ntosk… ============================================================================== --- branches/ros-amd64-bringup/reactos/ntoskrnl/ke/spinlock.c [iso-8859-1] (original) +++ branches/ros-amd64-bringup/reactos/ntoskrnl/ke/spinlock.c [iso-8859-1] Sat Jan 2 21:07:14 2010 @@ -467,6 +467,8 @@ while (*(volatile KSPIN_LOCK *)SpinLock & 1) { // FIXME: Check for timeout + // Warning: this function might be called from HAL with interrupts + // disabled. /* Yield and keep looping */ YieldProcessor();

14 years, 10 months

← Newer
1
...
44
45
46
47
48
49
50
...
53
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs January 2010