Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-02-24 09:25:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

Represent page-in operations by descriptors

Browse source 
svn path=/trunk/; revision=1682
This commit is contained in:
David Welch 2001-03-13 16:25:55 +00:00
parent c20f2479b6
commit 47ea39add9
18 changed files with 854 additions and 943 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
reactos/apps/tests/vmtest/vmtest.c
View file

@ -51,3 +51,4 @@ int main()
printf("VirtualAlloc failed 5\n"); printf("VirtualAlloc failed 5\n");
} }
} }

21
reactos/drivers/fs/vfat/create.c
View file

@ -1,4 +1,4 @@
/* $Id: create.c,v 1.21 2001/03/07 08:57:09 dwelch Exp $ /* $Id: create.c,v 1.22 2001/03/13 16:25:55 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -19,7 +19,14 @@
#include "vfat.h" #include "vfat.h"
/* FUNCTIONS ****************************************************************/ /* GLOBALS *******************************************************************/
#define TAG(A, B, C, D) (ULONG)(((A)<<0) + ((B)<<8) + ((C)<<16) + ((D)<<24))
#define TAG_FCB TAG('V', 'F', 'C', 'B')
#define TAG_CCB TAG('V', 'C', 'C', 'B')
/* FUNCTIONS *****************************************************************/
BOOLEAN BOOLEAN
IsLastEntry (PVOID Block, ULONG Offset) IsLastEntry (PVOID Block, ULONG Offset)
@ -448,7 +455,8 @@ VfatOpenFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
Fcb->RefCount++; Fcb->RefCount++;
KeReleaseSpinLock (&DeviceExt->FcbListLock, oldIrql); KeReleaseSpinLock (&DeviceExt->FcbListLock, oldIrql);
FileObject->FsContext = (PVOID)&Fcb->RFCB; FileObject->FsContext = (PVOID)&Fcb->RFCB;
newCCB = ExAllocatePool (NonPagedPool, sizeof (VFATCCB)); newCCB =
ExAllocatePoolWithTag (NonPagedPool, sizeof (VFATCCB), TAG_CCB);
memset (newCCB, 0, sizeof (VFATCCB)); memset (newCCB, 0, sizeof (VFATCCB));
FileObject->Flags = FileObject->Flags | FileObject->Flags = FileObject->Flags |
FO_FCB_IS_VALID | FO_DIRECT_CACHE_PAGING_READ; FO_FCB_IS_VALID | FO_DIRECT_CACHE_PAGING_READ;
@ -471,7 +479,7 @@ VfatOpenFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
string = FileName; string = FileName;
ParentFcb = NULL; ParentFcb = NULL;
Fcb = ExAllocatePool (NonPagedPool, sizeof (VFATFCB)); Fcb = ExAllocatePoolWithTag (NonPagedPool, sizeof (VFATFCB), TAG_FCB);
memset (Fcb, 0, sizeof (VFATFCB)); memset (Fcb, 0, sizeof (VFATFCB));
Fcb->ObjectName = &Fcb->PathName[1]; Fcb->ObjectName = &Fcb->PathName[1];
Fcb->PathName[0]='\\'; Fcb->PathName[0]='\\';
@ -532,7 +540,8 @@ VfatOpenFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
if (ParentFcb == NULL) if (ParentFcb == NULL)
{ {
CHECKPOINT; CHECKPOINT;
Fcb = ExAllocatePool (NonPagedPool, sizeof (VFATFCB)); Fcb = ExAllocatePoolWithTag (NonPagedPool, sizeof (VFATFCB),
TAG_FCB);
memset (Fcb, 0, sizeof (VFATFCB)); memset (Fcb, 0, sizeof (VFATFCB));
Fcb->ObjectName = &Fcb->PathName[1]; Fcb->ObjectName = &Fcb->PathName[1];
Fcb->PathName[0] = '\\'; Fcb->PathName[0] = '\\';
@ -594,7 +603,7 @@ VfatOpenFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
memset(FileObject->SectionObjectPointers, 0, memset(FileObject->SectionObjectPointers, 0,
sizeof(SECTION_OBJECT_POINTERS)); sizeof(SECTION_OBJECT_POINTERS));
FileObject->FsContext = (PVOID)&ParentFcb->RFCB; FileObject->FsContext = (PVOID)&ParentFcb->RFCB;
newCCB = ExAllocatePool (NonPagedPool, sizeof (VFATCCB)); newCCB = ExAllocatePoolWithTag (NonPagedPool, sizeof (VFATCCB), TAG_CCB);
memset (newCCB, 0, sizeof (VFATCCB)); memset (newCCB, 0, sizeof (VFATCCB));
FileObject->FsContext2 = newCCB; FileObject->FsContext2 = newCCB;
newCCB->pFcb = ParentFcb; newCCB->pFcb = ParentFcb;

37
reactos/lib/kernel32/process/proc.c
View file

@ -1,4 +1,4 @@
/* $Id: proc.c,v 1.38 2001/02/10 22:01:50 ea Exp $ /* $Id: proc.c,v 1.39 2001/03/13 16:25:51 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -35,44 +35,29 @@ WaitForInputIdleType lpfnGlobalRegisterWaitForInputIdle;
LPSTARTUPINFO lpLocalStartupInfo = NULL; LPSTARTUPINFO lpLocalStartupInfo = NULL;
VOID VOID STDCALL
STDCALL RegisterWaitForInputIdle (WaitForInputIdleType lpfnRegisterWaitForInputIdle);
RegisterWaitForInputIdle (
WaitForInputIdleType lpfnRegisterWaitForInputIdle
);
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
WINBOOL WINBOOL STDCALL
STDCALL GetProcessId (HANDLE hProcess, LPDWORD lpProcessId);
GetProcessId (
HANDLE hProcess,
LPDWORD lpProcessId
);
WINBOOL STDCALL
GetProcessTimes (HANDLE hProcess,
WINBOOL
STDCALL
GetProcessTimes (
HANDLE hProcess,
LPFILETIME lpCreationTime, LPFILETIME lpCreationTime,
LPFILETIME lpExitTime, LPFILETIME lpExitTime,
LPFILETIME lpKernelTime, LPFILETIME lpKernelTime,
LPFILETIME lpUserTime LPFILETIME lpUserTime)
)
{ {
NTSTATUS Status; NTSTATUS Status;
KERNEL_USER_TIMES Kut; KERNEL_USER_TIMES Kut;
Status = NtQueryInformationProcess ( Status = NtQueryInformationProcess (hProcess,
hProcess,
ProcessTimes, ProcessTimes,
& Kut, &Kut,
sizeof Kut, sizeof(Kut),
NULL NULL
); );
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))

20
reactos/lib/kernel32/thread/tls.c
View file

@ -1,4 +1,4 @@
/* $Id: tls.c,v 1.6 2000/11/19 16:01:29 ekohl Exp $ /* $Id: tls.c,v 1.7 2001/03/13 16:25:52 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -24,14 +24,13 @@
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
DWORD STDCALL TlsAlloc(VOID) DWORD STDCALL
TlsAlloc(VOID)
{ {
ULONG Index; ULONG Index;
RtlAcquirePebLock(); RtlAcquirePebLock();
Index = RtlFindClearBitsAndSet (NtCurrentPeb()->TlsBitmap, Index = RtlFindClearBitsAndSet (NtCurrentPeb()->TlsBitmap, 1, 0);
1,
0);
if (Index == (ULONG)-1) if (Index == (ULONG)-1)
{ {
SetLastErrorByStatus(STATUS_NO_MEMORY); SetLastErrorByStatus(STATUS_NO_MEMORY);
@ -42,10 +41,11 @@ DWORD STDCALL TlsAlloc(VOID)
} }
RtlReleasePebLock(); RtlReleasePebLock();
return Index; return(Index);
} }
WINBOOL STDCALL TlsFree(DWORD dwTlsIndex) WINBOOL STDCALL
TlsFree(DWORD dwTlsIndex)
{ {
if (dwTlsIndex >= TLS_MINIMUM_AVAILABLE) if (dwTlsIndex >= TLS_MINIMUM_AVAILABLE)
{ {
@ -73,7 +73,8 @@ WINBOOL STDCALL TlsFree(DWORD dwTlsIndex)
return(TRUE); return(TRUE);
} }
LPVOID STDCALL TlsGetValue(DWORD dwTlsIndex) LPVOID STDCALL
TlsGetValue(DWORD dwTlsIndex)
{ {
if (dwTlsIndex >= TLS_MINIMUM_AVAILABLE) if (dwTlsIndex >= TLS_MINIMUM_AVAILABLE)
{ {
@ -83,7 +84,8 @@ LPVOID STDCALL TlsGetValue(DWORD dwTlsIndex)
return(NtCurrentTeb()->TlsSlots[dwTlsIndex]); return(NtCurrentTeb()->TlsSlots[dwTlsIndex]);
} }
WINBOOL STDCALL TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue) WINBOOL STDCALL
TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue)
{ {
if (dwTlsIndex >= TLS_MINIMUM_AVAILABLE) if (dwTlsIndex >= TLS_MINIMUM_AVAILABLE)
{ {

8
reactos/lib/ntdll/rtl/thread.c
View file

@ -239,12 +239,8 @@ RtlInitializeContext(HANDLE ProcessHandle,
} }
NTSTATUS NTSTATUS STDCALL
STDCALL RtlFreeUserThreadStack (HANDLE ProcessHandle, HANDLE ThreadHandle)
RtlFreeUserThreadStack (
HANDLE ProcessHandle,
HANDLE ThreadHandle
)
{ {
THREAD_BASIC_INFORMATION ThreadInfo; THREAD_BASIC_INFORMATION ThreadInfo;
NTSTATUS Status; NTSTATUS Status;

4
reactos/ntoskrnl/cc/view.c
View file

@ -1,6 +1,6 @@
/* /*
* ReactOS kernel * ReactOS kernel
* Copyright (C) 1998, 1999, 2000, 2001 David Welch <welch@cwcom.net> * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/* $Id: view.c,v 1.18 2001/03/09 14:40:27 dwelch Exp $ /* $Id: view.c,v 1.19 2001/03/13 16:25:52 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel

4
reactos/ntoskrnl/cm/registry.c
View file

@ -1,4 +1,4 @@
/* $Id: registry.c,v 1.54 2001/02/10 22:51:08 dwelch Exp $ /* $Id: registry.c,v 1.55 2001/03/13 16:25:53 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -15,6 +15,7 @@
#include <internal/ob.h> #include <internal/ob.h>
#include <limits.h> #include <limits.h>
#include <string.h> #include <string.h>
#include <internal/pool.h>
#define NDEBUG #define NDEBUG
#include <internal/debug.h> #include <internal/debug.h>
@ -301,7 +302,6 @@ static NTSTATUS
CmiAddFree(PREGISTRY_FILE RegistryFile, CmiAddFree(PREGISTRY_FILE RegistryFile,
PFREE_SUB_BLOCK FreeBlock,BLOCK_OFFSET FreeOffset); PFREE_SUB_BLOCK FreeBlock,BLOCK_OFFSET FreeOffset);
/* --------------------------------------------- Public Interface */ /* --------------------------------------------- Public Interface */
VOID VOID

18
reactos/ntoskrnl/include/internal/mm.h
View file

@ -34,12 +34,6 @@ typedef ULONG SWAPENTRY;
#define NR_SECTION_PAGE_TABLES (1024) #define NR_SECTION_PAGE_TABLES (1024)
#define NR_SECTION_PAGE_ENTRIES (1024) #define NR_SECTION_PAGE_ENTRIES (1024)
#define SPE_PAGEIN_PENDING (0x1)
#define SPE_MPW_PENDING (0x2)
#define SPE_PAGEOUT_PENDING (0x4)
#define SPE_DIRTY (0x8)
#define SPE_IN_PAGEFILE (0x10)
/* /*
* Flags for section objects * Flags for section objects
*/ */
@ -398,7 +392,9 @@ typedef struct _MM_PAGEOP
BOOLEAN Abandoned; BOOLEAN Abandoned;
/* The memory area to be affected by the operation. */ /* The memory area to be affected by the operation. */
PMEMORY_AREA MArea; PMEMORY_AREA MArea;
ULONG Hash;
struct _MM_PAGEOP* Next; struct _MM_PAGEOP* Next;
struct _ETHREAD* Thread;
/* /*
* These fields are used to identify the operation if it is against a * These fields are used to identify the operation if it is against a
* virtual memory area. * virtual memory area.
@ -413,6 +409,13 @@ typedef struct _MM_PAGEOP
ULONG Offset; ULONG Offset;
} MM_PAGEOP, *PMM_PAGEOP; } MM_PAGEOP, *PMM_PAGEOP;
VOID
MmReleasePageOp(PMM_PAGEOP PageOp);
PMM_PAGEOP
MmGetPageOp(PMEMORY_AREA MArea, ULONG Pid, PVOID Address,
PMM_SECTION_SEGMENT Segment, ULONG Offset);
VOID VOID
MiDebugDumpNonPagedPool(BOOLEAN NewOnly); MiDebugDumpNonPagedPool(BOOLEAN NewOnly);
VOID VOID
@ -430,4 +433,7 @@ typedef struct _MM_IMAGE_SECTION_OBJECT
MM_SECTION_SEGMENT Segments[0]; MM_SECTION_SEGMENT Segments[0];
} MM_IMAGE_SECTION_OBJECT, *PMM_IMAGE_SECTION_OBJECT; } MM_IMAGE_SECTION_OBJECT, *PMM_IMAGE_SECTION_OBJECT;
VOID
MmFreeVirtualMemory(struct _EPROCESS* Process, PMEMORY_AREA MemoryArea);
#endif #endif

12
reactos/ntoskrnl/ke/ldt.c
View file

@ -16,11 +16,13 @@
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
NTSTATUS STDCALL
NtSetLdtEntries(HANDLE Thread, ULONG FirstEntry, PULONG Entries)
NTSTATUS STDCALL NtSetLdtEntries(HANDLE Thread,
ULONG FirstEntry,
PULONG Entries)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }

33
reactos/ntoskrnl/lpc/close.c
View file

@ -1,4 +1,4 @@
/* $Id: close.c,v 1.3 2000/12/10 23:42:00 dwelch Exp $ /* $Id: close.c,v 1.4 2001/03/13 16:25:54 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -33,21 +33,18 @@
* *
*/ */
VOID VOID
NiClosePort (PVOID ObjectBody, NiClosePort (PVOID ObjectBody, ULONG HandleCount)
ULONG HandleCount)
{ {
PEPORT Port = (PEPORT) ObjectBody; PEPORT Port = (PEPORT)ObjectBody;
LPC_MESSAGE Message; LPC_MESSAGE Message;
// DPRINT1("NiClosePort(ObjectBody %x, HandleCount %d) RefCount %d\n", /*
// ObjectBody, HandleCount, ObGetReferenceCount(Port)); * If the client has just closed its handle then tell the server what
* happened and disconnect this port.
if ((HandleCount == 0) && */
(Port->State == EPORT_CONNECTED_CLIENT) && if (HandleCount == 0 && Port->State == EPORT_CONNECTED_CLIENT &&
(ObGetReferenceCount(Port) == 2)) ObGetReferenceCount(Port) == 2)
{ {
// DPRINT1("All handles closed to client port\n");
Message.MessageSize = sizeof(LPC_MESSAGE); Message.MessageSize = sizeof(LPC_MESSAGE);
Message.DataSize = 0; Message.DataSize = 0;
@ -63,12 +60,14 @@ NiClosePort (PVOID ObjectBody,
Port->OtherPort->State = EPORT_DISCONNECTED; Port->OtherPort->State = EPORT_DISCONNECTED;
ObDereferenceObject (Port); ObDereferenceObject (Port);
} }
if ((HandleCount == 0) &&
(Port->State == EPORT_CONNECTED_SERVER) &&
(ObGetReferenceCount(Port) == 2))
{
// DPRINT("All handles closed to server\n");
/*
* If the server has closed all of its handles then disconnect the port,
* don't actually notify the client until it attempts an operation.
*/
if (HandleCount == 0 && Port->State == EPORT_CONNECTED_SERVER &&
ObGetReferenceCount(Port) == 2)
{
Port->OtherPort->OtherPort = NULL; Port->OtherPort->OtherPort = NULL;
Port->OtherPort->State = EPORT_DISCONNECTED; Port->OtherPort->State = EPORT_DISCONNECTED;
ObDereferenceObject(Port->OtherPort); ObDereferenceObject(Port->OtherPort);

64
reactos/ntoskrnl/mm/freelist.c
View file

@ -32,7 +32,6 @@ typedef struct _PHYSICAL_PAGE
ULONG Flags; ULONG Flags;
LIST_ENTRY ListEntry; LIST_ENTRY ListEntry;
ULONG ReferenceCount; ULONG ReferenceCount;
KEVENT Event;
SWAPENTRY SavedSwapEntry; SWAPENTRY SavedSwapEntry;
ULONG LockCount; ULONG LockCount;
ULONG MapCount; ULONG MapCount;
@ -187,9 +186,6 @@ PVOID MmInitializePageList(PVOID FirstPhysKernelAddress,
{ {
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE; MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE;
MmPageArray[i].ReferenceCount = 0; MmPageArray[i].ReferenceCount = 0;
KeInitializeEvent(&MmPageArray[i].Event,
NotificationEvent,
FALSE);
InsertTailList(&FreePageListHead, InsertTailList(&FreePageListHead,
&MmPageArray[i].ListEntry); &MmPageArray[i].ListEntry);
} }
@ -199,9 +195,6 @@ PVOID MmInitializePageList(PVOID FirstPhysKernelAddress,
{ {
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_USED; MmPageArray[i].Flags = MM_PHYSICAL_PAGE_USED;
MmPageArray[i].ReferenceCount = 1; MmPageArray[i].ReferenceCount = 1;
KeInitializeEvent(&MmPageArray[i].Event,
NotificationEvent,
FALSE);
InsertTailList(&UsedPageListHead, InsertTailList(&UsedPageListHead,
&MmPageArray[i].ListEntry); &MmPageArray[i].ListEntry);
} }
@ -210,9 +203,6 @@ PVOID MmInitializePageList(PVOID FirstPhysKernelAddress,
{ {
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE; MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE;
MmPageArray[i].ReferenceCount = 0; MmPageArray[i].ReferenceCount = 0;
KeInitializeEvent(&MmPageArray[i].Event,
NotificationEvent,
FALSE);
InsertTailList(&FreePageListHead, InsertTailList(&FreePageListHead,
&MmPageArray[i].ListEntry); &MmPageArray[i].ListEntry);
} }
@ -221,9 +211,6 @@ PVOID MmInitializePageList(PVOID FirstPhysKernelAddress,
{ {
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_BIOS; MmPageArray[i].Flags = MM_PHYSICAL_PAGE_BIOS;
MmPageArray[i].ReferenceCount = 1; MmPageArray[i].ReferenceCount = 1;
KeInitializeEvent(&MmPageArray[i].Event,
NotificationEvent,
FALSE);
InsertTailList(&BiosPageListHead, InsertTailList(&BiosPageListHead,
&MmPageArray[i].ListEntry); &MmPageArray[i].ListEntry);
} }
@ -235,9 +222,6 @@ PVOID MmInitializePageList(PVOID FirstPhysKernelAddress,
{ {
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE; MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE;
MmPageArray[i].ReferenceCount = 0; MmPageArray[i].ReferenceCount = 0;
KeInitializeEvent(&MmPageArray[i].Event,
NotificationEvent,
FALSE);
InsertTailList(&FreePageListHead, InsertTailList(&FreePageListHead,
&MmPageArray[i].ListEntry); &MmPageArray[i].ListEntry);
} }
@ -246,9 +230,6 @@ PVOID MmInitializePageList(PVOID FirstPhysKernelAddress,
{ {
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_BIOS; MmPageArray[i].Flags = MM_PHYSICAL_PAGE_BIOS;
MmPageArray[i].ReferenceCount = 1; MmPageArray[i].ReferenceCount = 1;
KeInitializeEvent(&MmPageArray[i].Event,
NotificationEvent,
FALSE);
InsertTailList(&BiosPageListHead, InsertTailList(&BiosPageListHead,
&MmPageArray[i].ListEntry); &MmPageArray[i].ListEntry);
} }
@ -257,9 +238,6 @@ PVOID MmInitializePageList(PVOID FirstPhysKernelAddress,
{ {
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE; MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE;
MmPageArray[i].ReferenceCount = 0; MmPageArray[i].ReferenceCount = 0;
KeInitializeEvent(&MmPageArray[i].Event,
NotificationEvent,
FALSE);
InsertTailList(&FreePageListHead, InsertTailList(&FreePageListHead,
&MmPageArray[i].ListEntry); &MmPageArray[i].ListEntry);
} }
@ -269,9 +247,6 @@ PVOID MmInitializePageList(PVOID FirstPhysKernelAddress,
{ {
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_USED; MmPageArray[i].Flags = MM_PHYSICAL_PAGE_USED;
MmPageArray[i].ReferenceCount = 1; MmPageArray[i].ReferenceCount = 1;
KeInitializeEvent(&MmPageArray[i].Event,
NotificationEvent,
FALSE);
InsertTailList(&UsedPageListHead, InsertTailList(&UsedPageListHead,
&MmPageArray[i].ListEntry); &MmPageArray[i].ListEntry);
} }
@ -282,9 +257,6 @@ PVOID MmInitializePageList(PVOID FirstPhysKernelAddress,
{ {
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE; MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE;
MmPageArray[i].ReferenceCount = 0; MmPageArray[i].ReferenceCount = 0;
KeInitializeEvent(&MmPageArray[i].Event,
NotificationEvent,
FALSE);
InsertTailList(&FreePageListHead, InsertTailList(&FreePageListHead,
&MmPageArray[i].ListEntry); &MmPageArray[i].ListEntry);
} }
@ -638,39 +610,3 @@ MmAllocPageMaybeSwap(SWAPENTRY SavedSwapEntry)
return(Page); return(Page);
} }
NTSTATUS
MmWaitForPage(PVOID PhysicalAddress)
{
NTSTATUS Status;
ULONG Start;
Start = (ULONG)PhysicalAddress / PAGESIZE;
Status = KeWaitForSingleObject(&MmPageArray[Start].Event,
UserRequest,
KernelMode,
FALSE,
NULL);
return(Status);
}
VOID
MmClearWaitPage(PVOID PhysicalAddress)
{
ULONG Start;
Start = (ULONG)PhysicalAddress / PAGESIZE;
KeClearEvent(&MmPageArray[Start].Event);
}
VOID
MmSetWaitPage(PVOID PhysicalAddress)
{
ULONG Start;
Start = (ULONG)PhysicalAddress / PAGESIZE;
KeSetEvent(&MmPageArray[Start].Event,
IO_DISK_INCREMENT,
FALSE);
}

15
reactos/ntoskrnl/mm/mdl.c
View file

@ -1,4 +1,4 @@
/* $Id: mdl.c,v 1.29 2001/02/14 02:53:53 dwelch Exp $ /* $Id: mdl.c,v 1.30 2001/03/13 16:25:54 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -15,13 +15,19 @@
#include <internal/mm.h> #include <internal/mm.h>
#include <internal/mmhal.h> #include <internal/mmhal.h>
#include <internal/ps.h> #include <internal/ps.h>
#include <internal/pool.h>
#define NDEBUG #define NDEBUG
#include <internal/debug.h> #include <internal/debug.h>
/* FUNCTIONS ***************************************************************/ /* GLOBALS *******************************************************************/
PVOID MmGetMdlPageAddress(PMDL Mdl, PVOID Offset) #define TAG_MDL TAG('M', 'M', 'D', 'L')
/* FUNCTIONS *****************************************************************/
PVOID
MmGetMdlPageAddress(PMDL Mdl, PVOID Offset)
{ {
PULONG MdlPages; PULONG MdlPages;
@ -318,7 +324,8 @@ PMDL STDCALL MmCreateMdl (PMDL MemoryDescriptorList,
ULONG Size; ULONG Size;
Size = MmSizeOfMdl(Base,Length); Size = MmSizeOfMdl(Base,Length);
MemoryDescriptorList = (PMDL)ExAllocatePool(NonPagedPool,Size); MemoryDescriptorList =
(PMDL)ExAllocatePoolWithTag(NonPagedPool, Size, TAG_MDL);
if (MemoryDescriptorList == NULL) if (MemoryDescriptorList == NULL)
{ {
return(NULL); return(NULL);

41
reactos/ntoskrnl/mm/mm.c
View file

@ -1,4 +1,22 @@
/* $Id: mm.c,v 1.44 2001/03/08 22:06:01 dwelch Exp $ /*
* ReactOS kernel
* Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: mm.c,v 1.45 2001/03/13 16:25:54 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top directory * COPYRIGHT: See COPYING in the top directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -32,20 +50,6 @@ extern PVOID MmSharedDataPagePhysicalAddress;
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
VOID STATIC
MmFreeVirtualMemoryPage(PVOID Context, PVOID Address, ULONG PhysicalAddr)
{
PEPROCESS Process = (PEPROCESS)Context;
if (PhysicalAddr != 0)
{
DPRINT("Freeing page at 0x%x (pa 0x%x)\n",
Address, PhysicalAddr);
MmRemovePageFromWorkingSet(Process, Address);
MmDereferencePage((PVOID)PhysicalAddr);
}
}
NTSTATUS MmReleaseMemoryArea(PEPROCESS Process, PMEMORY_AREA Marea) NTSTATUS MmReleaseMemoryArea(PEPROCESS Process, PMEMORY_AREA Marea)
{ {
NTSTATUS Status; NTSTATUS Status;
@ -65,12 +69,7 @@ NTSTATUS MmReleaseMemoryArea(PEPROCESS Process, PMEMORY_AREA Marea)
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
case MEMORY_AREA_VIRTUAL_MEMORY: case MEMORY_AREA_VIRTUAL_MEMORY:
Status = MmFreeMemoryArea(&Process->AddressSpace, MmFreeVirtualMemory(Process, Marea);
Marea->BaseAddress,
0,
MmFreeVirtualMemoryPage,
(PVOID)Process);
assert(Status == STATUS_SUCCESS);
break; break;
case MEMORY_AREA_SHARED_DATA: case MEMORY_AREA_SHARED_DATA:

70
reactos/ntoskrnl/mm/pageop.c
View file

@ -1,4 +1,4 @@
/* $Id: pageop.c,v 1.2 2001/03/07 16:48:44 dwelch Exp $ /* $Id: pageop.c,v 1.3 2001/03/13 16:25:54 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -14,6 +14,7 @@
#include <internal/ps.h> #include <internal/ps.h>
#include <internal/mm.h> #include <internal/mm.h>
#include <internal/mmhal.h> #include <internal/mmhal.h>
#include <internal/pool.h>
#define NDEBUG #define NDEBUG
#include <internal/debug.h> #include <internal/debug.h>
@ -31,10 +32,12 @@ PMM_PAGEOP MmPageOpHashTable[PAGEOP_HASH_TABLE_SIZE];
VOID VOID
MmReleasePageOp(PMM_PAGEOP PageOp) MmReleasePageOp(PMM_PAGEOP PageOp)
/*
* FUNCTION: Release a reference to a page operation descriptor
*/
{ {
ULONG h;
KIRQL oldIrql; KIRQL oldIrql;
PMM_PAGEOP PPageOp; PMM_PAGEOP PrevPageOp;
PageOp->ReferenceCount--; PageOp->ReferenceCount--;
if (PageOp->ReferenceCount > 0) if (PageOp->ReferenceCount > 0)
@ -42,38 +45,26 @@ MmReleasePageOp(PMM_PAGEOP PageOp)
return; return;
} }
/*
* Calcuate the hash value for pageop structure
*/
if (MArea->Type == MEMORY_AREA_SECTION_VIEW_COMMIT)
{
h = (((ULONG)Segment) | Offset) % PAGEOP_HASH_TABLE_SIZE;
}
else
{
h = (((ULONG)Pid) | (ULONG)Address) % PAGEOP_HASH_TABLE_SIZE;
}
KeAcquireSpinLock(&MmPageOpHashTableLock, &oldIrql); KeAcquireSpinLock(&MmPageOpHashTableLock, &oldIrql);
PPageOp = MmPageOpHashTable[h]; PrevPageOp = MmPageOpHashTable[PageOp->Hash];
if (PPageOp == PageOp) if (PrevPageOp == PageOp)
{ {
MmPageOpHashTable[h] = PageOp->Next; MmPageOpHashTable[PageOp->Hash] = PageOp->Next;
KeReleaseSpinLock(&MmPageOpHashTableLock, oldIrql); KeReleaseSpinLock(&MmPageOpHashTableLock, oldIrql);
ExFreePool(PageOp); ExFreePool(PageOp);
return; return;
} }
PPageOp = PPageOp->Next; PrevPageOp = PrevPageOp->Next;
while (PPageOp != NULL) while (PrevPageOp != NULL)
{ {
if (PPageOp == PageOp) if (PrevPageOp == PageOp)
{ {
PPageOp->Next = PageOp->Next; PrevPageOp->Next = PageOp->Next;
KeReleaseSpinLock(&MmPageOpHashTableLock, oldIrql); KeReleaseSpinLock(&MmPageOpHashTableLock, oldIrql);
ExFreePool(PageOp); ExFreePool(PageOp);
return; return;
} }
PPageOp = PPageOp->Next; PrevPageOp = PrevPageOp->Next;
} }
KeReleaseSpinLock(&MmPageOpHashTableLock, oldIrql); KeReleaseSpinLock(&MmPageOpHashTableLock, oldIrql);
KeBugCheck(0); KeBugCheck(0);
@ -82,8 +73,13 @@ MmReleasePageOp(PMM_PAGEOP PageOp)
PMM_PAGEOP PMM_PAGEOP
MmGetPageOp(PMEMORY_AREA MArea, ULONG Pid, PVOID Address, MmGetPageOp(PMEMORY_AREA MArea, ULONG Pid, PVOID Address,
PMM_SECTION_SEGMENT Segment, ULONG Offset) PMM_SECTION_SEGMENT Segment, ULONG Offset)
/*
* FUNCTION: Get a page operation descriptor corresponding to
* the memory area and either the segment, offset pair or the
* pid, address pair.
*/
{ {
ULONG h; ULONG Hash;
KIRQL oldIrql; KIRQL oldIrql;
PMM_PAGEOP PageOp; PMM_PAGEOP PageOp;
@ -92,19 +88,20 @@ MmGetPageOp(PMEMORY_AREA MArea, ULONG Pid, PVOID Address,
*/ */
if (MArea->Type == MEMORY_AREA_SECTION_VIEW_COMMIT) if (MArea->Type == MEMORY_AREA_SECTION_VIEW_COMMIT)
{ {
h = (((ULONG)Segment) | Offset) % PAGEOP_HASH_TABLE_SIZE; Hash = (((ULONG)Segment) | (((ULONG)Offset) / PAGESIZE));
} }
else else
{ {
h = (((ULONG)Pid) | (ULONG)Address) % PAGEOP_HASH_TABLE_SIZE; Hash = (((ULONG)Pid) | (((ULONG)Address) / PAGESIZE));
} }
Hash = Hash % PAGEOP_HASH_TABLE_SIZE;
KeAcquireSpinLock(&MmPageOpHashTableLock, &oldIrql); KeAcquireSpinLock(&MmPageOpHashTableLock, &oldIrql);
/* /*
* Check for an existing pageop structure * Check for an existing pageop structure
*/ */
PageOp = MmPageOpHashTable[h]; PageOp = MmPageOpHashTable[Hash];
while (PageOp != NULL) while (PageOp != NULL)
{ {
if (MArea->Type == MEMORY_AREA_SECTION_VIEW_COMMIT) if (MArea->Type == MEMORY_AREA_SECTION_VIEW_COMMIT)
@ -148,7 +145,7 @@ MmGetPageOp(PMEMORY_AREA MArea, ULONG Pid, PVOID Address,
return(NULL); return(NULL);
} }
if (MArea->Type == MEMORY_AREA_SECTION_VIEW_COMMIT) if (MArea->Type != MEMORY_AREA_SECTION_VIEW_COMMIT)
{ {
PageOp->Pid = Pid; PageOp->Pid = Pid;
PageOp->Address = Address; PageOp->Address = Address;
@ -159,9 +156,22 @@ MmGetPageOp(PMEMORY_AREA MArea, ULONG Pid, PVOID Address,
PageOp->Offset = Offset; PageOp->Offset = Offset;
} }
PageOp->ReferenceCount = 1; PageOp->ReferenceCount = 1;
PageOp->Next = MmPageOpHashTable[h]; PageOp->Next = MmPageOpHashTable[Hash];
MmPageOpHashTable[h] = PageOp; PageOp->Hash = Hash;
PageOp->Thread = PsGetCurrentThread();
PageOp->Abandoned = FALSE;
PageOp->Status = STATUS_PENDING;
KeInitializeEvent(&PageOp->CompletionEvent, NotificationEvent, FALSE);
MmPageOpHashTable[Hash] = PageOp;
KeReleaseSpinLock(&MmPageOpHashTableLock, oldIrql); KeReleaseSpinLock(&MmPageOpHashTableLock, oldIrql);
return(PageOp); return(PageOp);
} }

322
reactos/ntoskrnl/mm/section.c
View file

@ -1,4 +1,4 @@
/* $Id: section.c,v 1.50 2001/03/09 14:40:28 dwelch Exp $ /* $Id: section.c,v 1.51 2001/03/13 16:25:54 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -184,123 +184,6 @@ MmGetPageEntrySectionSegment(PMM_SECTION_SEGMENT Segment,
return(Entry); return(Entry);
} }
NTSTATUS
MmWaitForPendingOperationSection(PMADDRESS_SPACE AddressSpace,
PMEMORY_AREA MemoryArea,
PVOID Address,
PSECTION_OBJECT Section,
PMM_SECTION_SEGMENT Segment,
LARGE_INTEGER Offset,
ULONG Entry,
ULONG Attributes,
BOOLEAN Locked)
{
PVOID Page;
NTSTATUS Status;
/*
* If a page-in on that section offset is pending that wait for
* it to finish.
*/
do
{
/*
* Release all our locks and wait for the pending operation
* to complete
*/
MmUnlockSectionSegment(Segment);
MmUnlockSection(Section);
MmUnlockAddressSpace(AddressSpace);
/*
* FIXME: What if the event is set and cleared after we
* unlock the section but before we wait.
*/
Status = MmWaitForPage((PVOID)(Entry & (~SPE_PAGEIN_PENDING)));
if (!NT_SUCCESS(Status))
{
/*
* FIXME: What do we do in this case? Maybe the thread
* has terminated.
*/
DbgPrint("Failed to wait for page\n");
KeBugCheck(0);
return(STATUS_UNSUCCESSFUL);
}
/*
* Relock the address space, section and segment
*/
MmLockAddressSpace(AddressSpace);
MmLockSection(Section);
MmLockSectionSegment(Segment);
/*
* Get the entry for the section offset. If the entry is still
* pending that means another thread is already trying the
* page-in again so we have to wait again.
*/
Entry = MmGetPageEntrySectionSegment(Segment, Offset.u.LowPart);
} while (Entry & SPE_PAGEIN_PENDING);
/*
* Setting the entry to null means the read failing.
* FIXME: We should retry it (unless that filesystem has gone
* entirely e.g. the network died).
*/
if (Entry == 0)
{
DbgPrint("Entry set to null while we slept\n");
KeBugCheck(0);
}
/*
* Maybe the thread did the page-in took the fault on the
* same address-space/address as we did. If so we can just
* return success.
*/
if (MmIsPagePresent(NULL, Address))
{
if (Locked)
{
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address));
}
MmUnlockSectionSegment(Segment);
MmUnlockSection(Section);
return(STATUS_SUCCESS);
}
/*
* Get a reference to the page containing the data for the page.
*/
Page = (PVOID)Entry;
MmReferencePage(Page);
/*
* When we reach here, we have the address space, section and segment locked
* and have a reference to a page containing valid data for the
* section offset. Set the page and return success.
*/
Status = MmCreateVirtualMapping(PsGetCurrentProcess(),
Address,
Attributes,
(ULONG)Page);
if (!NT_SUCCESS(Status))
{
DbgPrint("Unable to create virtual mapping\n");
KeBugCheck(0);
}
if (Locked)
{
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address));
}
MmUnlockSectionSegment(Segment);
MmUnlockSection(Section);
return(STATUS_SUCCESS);
}
NTSTATUS NTSTATUS
MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace, MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
MEMORY_AREA* MemoryArea, MEMORY_AREA* MemoryArea,
@ -318,10 +201,7 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
ULONG Entry; ULONG Entry;
ULONG Entry1; ULONG Entry1;
ULONG Attributes; ULONG Attributes;
PMM_PAGEOP PageOp;
DPRINT("MmSectionHandleFault(MemoryArea %x, Address %x)\n",
MemoryArea,Address);
/* /*
* There is a window between taking the page fault and locking the * There is a window between taking the page fault and locking the
@ -330,7 +210,6 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
*/ */
if (MmIsPagePresent(NULL, Address)) if (MmIsPagePresent(NULL, Address))
{ {
DbgPrint("Page is already present\n");
if (Locked) if (Locked)
{ {
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address)); MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address));
@ -350,6 +229,84 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
MmLockSection(Section); MmLockSection(Section);
MmLockSectionSegment(Segment); MmLockSectionSegment(Segment);
/*
* Get or create a page operation descriptor
*/
PageOp = MmGetPageOp(MemoryArea, 0, 0, Segment, Offset.u.LowPart);
if (PageOp == NULL)
{
DPRINT1("MmGetPageOp failed\n");
KeBugCheck(0);
}
/*
* Check if someone else is already handling this fault, if so wait
* for them
*/
if (PageOp->Thread != PsGetCurrentThread())
{
MmUnlockSectionSegment(Segment);
MmUnlockSection(Section);
MmUnlockAddressSpace(AddressSpace);
Status = KeWaitForSingleObject(&PageOp->CompletionEvent,
0,
KernelMode,
FALSE,
NULL);
/*
* Check for various strange conditions
*/
if (Status != STATUS_SUCCESS)
{
DPRINT1("Failed to wait for page op\n");
KeBugCheck(0);
}
if (PageOp->Status == STATUS_PENDING)
{
DPRINT1("Woke for page op before completion\n");
KeBugCheck(0);
}
/*
* If the thread handling this fault has failed then we don't retry
*/
if (!NT_SUCCESS(PageOp->Status))
{
return(Status);
}
MmLockAddressSpace(AddressSpace);
MmLockSection(Section);
MmLockSectionSegment(Segment);
/*
* If the completed fault was for another address space then set the
* page in this one.
*/
if (!MmIsPagePresent(NULL, Address))
{
Entry = MmGetPageEntrySectionSegment(Segment, Offset.u.LowPart);
Page = (PVOID)(Entry & 0xFFFFF000);
MmReferencePage(Page);
Status = MmCreateVirtualMapping(PsGetCurrentProcess(),
Address,
Attributes,
(ULONG)Page);
if (!NT_SUCCESS(Status))
{
DbgPrint("Unable to create virtual mapping\n");
KeBugCheck(0);
}
}
if (Locked)
{
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address));
}
MmUnlockSectionSegment(Segment);
MmUnlockSection(Section);
MmReleasePageOp(PageOp);
return(STATUS_SUCCESS);
}
/* /*
* Satisfying a page fault on a map of /Device/PhysicalMemory is easy * Satisfying a page fault on a map of /Device/PhysicalMemory is easy
*/ */
@ -366,6 +323,13 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
{ {
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address)); MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address));
} }
/*
* Cleanup and release locks
*/
PageOp->Status = STATUS_SUCCESS;
KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
MmReleasePageOp(PageOp);
MmUnlockSectionSegment(Segment); MmUnlockSectionSegment(Segment);
MmUnlockSection(Section); MmUnlockSection(Section);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
@ -384,11 +348,6 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
MmUnlockAddressSpace(AddressSpace); MmUnlockAddressSpace(AddressSpace);
MmWaitForFreePages(); MmWaitForFreePages();
MmLockAddressSpace(AddressSpace); MmLockAddressSpace(AddressSpace);
if (MmIsPagePresent(NULL, Address))
{
MmUnlockAddressSpace(AddressSpace);
return(STATUS_SUCCESS);
}
MmLockSection(Section); MmLockSection(Section);
MmLockSectionSegment(Segment); MmLockSectionSegment(Segment);
Page = MmAllocPage(0); Page = MmAllocPage(0);
@ -401,10 +360,21 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
{ {
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address)); MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address));
} }
/*
* Cleanup and release locks
*/
PageOp->Status = STATUS_SUCCESS;
KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
MmReleasePageOp(PageOp);
MmUnlockSectionSegment(Segment); MmUnlockSectionSegment(Segment);
MmUnlockSection(Section); MmUnlockSection(Section);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
/*
* Check if this page needs to be mapped COW
*/
if (Segment->Characteristics & IMAGE_SECTION_CHAR_DATA) if (Segment->Characteristics & IMAGE_SECTION_CHAR_DATA)
{ {
Attributes = PAGE_READONLY; Attributes = PAGE_READONLY;
@ -419,8 +389,6 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
*/ */
Entry = MmGetPageEntrySectionSegment(Segment, Offset.u.LowPart); Entry = MmGetPageEntrySectionSegment(Segment, Offset.u.LowPart);
DPRINT("Entry %x\n", Entry);
if (Entry == 0) if (Entry == 0)
{ {
/* /*
@ -440,55 +408,8 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
MmUnlockAddressSpace(AddressSpace); MmUnlockAddressSpace(AddressSpace);
MmWaitForFreePages(); MmWaitForFreePages();
MmLockAddressSpace(AddressSpace); MmLockAddressSpace(AddressSpace);
if (MmIsPagePresent(NULL, Address))
{
MmUnlockAddressSpace(AddressSpace);
return(STATUS_SUCCESS);
}
MmLockSection(Section); MmLockSection(Section);
MmLockSectionSegment(Segment); MmLockSectionSegment(Segment);
/*
* Check if page fault handling has already been started on
* this offset by another thread
*/
Entry1 = MmGetPageEntrySectionSegment(Segment, Offset.u.LowPart);
if (Entry1 & SPE_PAGEIN_PENDING)
{
return(MmWaitForPendingOperationSection(AddressSpace,
MemoryArea,
Address,
Section,
Segment,
Offset,
Entry1,
Attributes,
Locked));
}
else if (Entry1 != 0)
{
Page = (PVOID)Entry;
MmReferencePage(Page);
Status = MmCreateVirtualMapping(PsGetCurrentProcess(),
Address,
Attributes,
(ULONG)Page);
if (!NT_SUCCESS(Status))
{
DbgPrint("Unable to create virtual mapping\n");
KeBugCheck(0);
}
if (Locked)
{
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL,
Address));
}
MmUnlockSectionSegment(Segment);
MmUnlockSection(Section);
return(STATUS_SUCCESS);
}
Page = MmAllocPage(0); Page = MmAllocPage(0);
} }
@ -498,26 +419,12 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
Mdl = MmCreateMdl(NULL, NULL, PAGESIZE); Mdl = MmCreateMdl(NULL, NULL, PAGESIZE);
MmBuildMdlFromPages(Mdl, (PULONG)&Page); MmBuildMdlFromPages(Mdl, (PULONG)&Page);
/*
* Clear the wait state (Since we are holding the only reference to
* page this is safe)
*/
MmClearWaitPage(Page);
/*
* Notify any other threads that fault on the same section offset
* that a page-in is pending.
*/
Entry = ((ULONG)Page) | SPE_PAGEIN_PENDING;
MmSetPageEntrySectionSegment(Segment, Offset.u.LowPart, Entry);
/* /*
* Release all our locks and read in the page from disk * Release all our locks and read in the page from disk
*/ */
MmUnlockSectionSegment(Segment); MmUnlockSectionSegment(Segment);
MmUnlockSection(Section); MmUnlockSection(Section);
MmUnlockAddressSpace(AddressSpace); MmUnlockAddressSpace(AddressSpace);
DPRINT("Reading file offset %x\n", Offset.QuadPart);
Status = IoPageRead(MemoryArea->Data.SectionData.Section->FileObject, Status = IoPageRead(MemoryArea->Data.SectionData.Section->FileObject,
Mdl, Mdl,
&Offset, &Offset,
@ -529,6 +436,13 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
* FIXME: What do we know in this case? * FIXME: What do we know in this case?
*/ */
DPRINT("IoPageRead failed (Status %x)\n", Status); DPRINT("IoPageRead failed (Status %x)\n", Status);
/*
* Cleanup and release locks
*/
PageOp->Status = Status;
KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
MmReleasePageOp(PageOp);
MmLockAddressSpace(AddressSpace); MmLockAddressSpace(AddressSpace);
return(Status); return(Status);
} }
@ -558,12 +472,6 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
Entry = (ULONG)Page; Entry = (ULONG)Page;
MmSetPageEntrySectionSegment(Segment, Offset.QuadPart, Entry); MmSetPageEntrySectionSegment(Segment, Offset.QuadPart, Entry);
/*
* Set the event associated with the page so other threads that
* may be waiting know that valid data is now in-memory.
*/
MmSetWaitPage(Page);
Status = MmCreateVirtualMapping(PsGetCurrentProcess(), Status = MmCreateVirtualMapping(PsGetCurrentProcess(),
Address, Address,
Attributes, Attributes,
@ -577,23 +485,13 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
{ {
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address)); MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address));
} }
PageOp->Status = STATUS_SUCCESS;
KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
MmReleasePageOp(PageOp);
MmUnlockSectionSegment(Segment); MmUnlockSectionSegment(Segment);
MmUnlockSection(Section); MmUnlockSection(Section);
DPRINT("MmNotPresentFaultSectionView succeeded\n"); DPRINT("MmNotPresentFaultSectionView succeeded\n");
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
}
else if (Entry & SPE_PAGEIN_PENDING)
{
return(MmWaitForPendingOperationSection(AddressSpace,
MemoryArea,
Address,
Section,
Segment,
Offset,
Entry,
Attributes,
Locked));
} }
else else
{ {
@ -618,9 +516,11 @@ MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
{ {
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address)); MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address));
} }
PageOp->Status = STATUS_SUCCESS;
KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
MmReleasePageOp(PageOp);
MmUnlockSectionSegment(Segment); MmUnlockSectionSegment(Segment);
MmUnlockSection(Section); MmUnlockSection(Section);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
} }

120
reactos/ntoskrnl/mm/virtual.c
View file

@ -1,4 +1,4 @@
/* $Id: virtual.c,v 1.41 2001/03/08 22:06:02 dwelch Exp $ /* $Id: virtual.c,v 1.42 2001/03/13 16:25:54 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top directory * COPYRIGHT: See COPYING in the top directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -222,6 +222,21 @@ MmNotPresentFaultVirtualMemory(PMADDRESS_SPACE AddressSpace,
NTSTATUS Status; NTSTATUS Status;
PMM_SEGMENT Segment; PMM_SEGMENT Segment;
PVOID CurrentAddress; PVOID CurrentAddress;
PMM_PAGEOP PageOp;
/*
* There is a window between taking the page fault and locking the
* address space when another thread could load the page so we check
* that.
*/
if (MmIsPagePresent(NULL, Address))
{
if (Locked)
{
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address));
}
return(STATUS_SUCCESS);
}
/* /*
* Get the segment corresponding to the virtual address * Get the segment corresponding to the virtual address
@ -236,12 +251,55 @@ MmNotPresentFaultVirtualMemory(PMADDRESS_SPACE AddressSpace,
return(STATUS_UNSUCCESSFUL); return(STATUS_UNSUCCESSFUL);
} }
if (MmIsPagePresent(NULL, Address)) /*
* Get or create a page operation
*/
PageOp = MmGetPageOp(MemoryArea, (ULONG)PsGetCurrentProcessId(),
(PVOID)PAGE_ROUND_DOWN(Address), NULL, 0);
if (PageOp == NULL)
{ {
DPRINT1("MmGetPageOp failed");
KeBugCheck(0);
}
/*
* Check if someone else is already handling this fault, if so wait
* for them
*/
if (PageOp->Thread != PsGetCurrentThread())
{
MmUnlockAddressSpace(AddressSpace);
Status = KeWaitForSingleObject(&PageOp->CompletionEvent,
0,
KernelMode,
FALSE,
NULL);
/*
* Check for various strange conditions
*/
if (Status != STATUS_SUCCESS)
{
DPRINT1("Failed to wait for page op\n");
KeBugCheck(0);
}
if (PageOp->Status == STATUS_PENDING)
{
DPRINT1("Woke for page op before completion\n");
KeBugCheck(0);
}
/*
* If the thread handling this fault has failed then we don't retry
*/
if (!NT_SUCCESS(PageOp->Status))
{
return(Status);
}
MmLockAddressSpace(AddressSpace);
if (Locked) if (Locked)
{ {
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address)); MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address));
} }
MmReleasePageOp(PageOp);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
@ -254,15 +312,6 @@ MmNotPresentFaultVirtualMemory(PMADDRESS_SPACE AddressSpace,
MmUnlockAddressSpace(AddressSpace); MmUnlockAddressSpace(AddressSpace);
MmWaitForFreePages(); MmWaitForFreePages();
MmLockAddressSpace(AddressSpace); MmLockAddressSpace(AddressSpace);
if (MmIsPagePresent(NULL, Address))
{
if (Locked)
{
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL,
Address));
}
return(STATUS_SUCCESS);
}
Page = MmAllocPage(0); Page = MmAllocPage(0);
} }
@ -285,16 +334,6 @@ MmNotPresentFaultVirtualMemory(PMADDRESS_SPACE AddressSpace,
MmUnlockAddressSpace(AddressSpace); MmUnlockAddressSpace(AddressSpace);
MmWaitForFreePages(); MmWaitForFreePages();
MmLockAddressSpace(AddressSpace); MmLockAddressSpace(AddressSpace);
if (MmIsPagePresent(NULL, Address))
{
if (Locked)
{
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL,
Address));
}
MmDereferencePage(Page);
return(STATUS_SUCCESS);
}
Status = MmCreateVirtualMapping(PsGetCurrentProcess(), Status = MmCreateVirtualMapping(PsGetCurrentProcess(),
Address, Address,
MemoryArea->Attributes, MemoryArea->Attributes,
@ -302,16 +341,22 @@ MmNotPresentFaultVirtualMemory(PMADDRESS_SPACE AddressSpace,
} }
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
DPRINT1("MmCreateVirtualMapping failed, not out of memory\n");
KeBugCheck(0);
return(Status); return(Status);
} }
else
{ /*
* Finish the operation
*/
if (Locked) if (Locked)
{ {
MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address)); MmLockPage((PVOID)MmGetPhysicalAddressForProcess(NULL, Address));
} }
PageOp->Status = STATUS_SUCCESS;
KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
MmReleasePageOp(PageOp);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
}
} }
VOID STATIC VOID STATIC
@ -960,6 +1005,27 @@ MmFreeVirtualMemoryPage(PVOID Context, PVOID Address, ULONG PhysicalAddr)
} }
} }
VOID
MmFreeVirtualMemory(PEPROCESS Process, PMEMORY_AREA MemoryArea)
{
PLIST_ENTRY current_entry;
PMM_SEGMENT current;
current_entry = MemoryArea->Data.VirtualMemoryData.SegmentListHead.Flink;
while (current_entry != &MemoryArea->Data.VirtualMemoryData.SegmentListHead)
{
current = CONTAINING_RECORD(current_entry, MM_SEGMENT, SegmentListEntry);
current_entry = current_entry->Flink;
ExFreePool(current);
}
MmFreeMemoryArea(&Process->AddressSpace,
MemoryArea->BaseAddress,
0,
MmFreeVirtualMemoryPage,
(PVOID)Process);
}
NTSTATUS STDCALL NTSTATUS STDCALL
NtFreeVirtualMemory(IN HANDLE ProcessHandle, NtFreeVirtualMemory(IN HANDLE ProcessHandle,
IN PVOID* PBaseAddress, IN PVOID* PBaseAddress,
@ -1034,11 +1100,7 @@ NtFreeVirtualMemory(IN HANDLE ProcessHandle,
} }
#endif #endif
MmFreeMemoryArea(&Process->AddressSpace, MmFreeVirtualMemory(Process, MemoryArea);
BaseAddress,
0,
MmFreeVirtualMemoryPage,
(PVOID)Process);
MmUnlockAddressSpace(AddressSpace); MmUnlockAddressSpace(AddressSpace);
ObDereferenceObject(Process); ObDereferenceObject(Process);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);

4
reactos/ntoskrnl/nt/ntsem.c
View file

@ -1,4 +1,4 @@
/* $Id: ntsem.c,v 1.10 2001/03/07 16:48:44 dwelch Exp $ /* $Id: ntsem.c,v 1.11 2001/03/13 16:25:55 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -16,6 +16,7 @@
#include <internal/ob.h> #include <internal/ob.h>
#include <ntos/synch.h> #include <ntos/synch.h>
#include <internal/pool.h> #include <internal/pool.h>
#include <internal/ps.h>
#define NDEBUG #define NDEBUG
#include <internal/debug.h> #include <internal/debug.h>
@ -87,7 +88,6 @@ NtCreateSemaphore(OUT PHANDLE SemaphoreHandle,
{ {
PKSEMAPHORE Semaphore; PKSEMAPHORE Semaphore;
DPRINT("NtCreateSemaphore()\n");
Semaphore = ObCreateObject(SemaphoreHandle, Semaphore = ObCreateObject(SemaphoreHandle,
DesiredAccess, DesiredAccess,
ObjectAttributes, ObjectAttributes,

139
reactos/ntoskrnl/rtl/unicode.c
View file

@ -1,4 +1,4 @@
/* $Id: unicode.c,v 1.17 2001/02/25 12:51:43 chorns Exp $ /* $Id: unicode.c,v 1.18 2001/03/13 16:25:55 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -13,15 +13,20 @@
//#include <internal/nls.h> //#include <internal/nls.h>
#include <ctype.h> #include <ctype.h>
#include <ntos/minmax.h> #include <ntos/minmax.h>
#include <internal/pool.h>
#define NDEBUG #define NDEBUG
#include <internal/debug.h> #include <internal/debug.h>
/* GLOBALS *******************************************************************/
#define TAG_USTR TAG('U', 'S', 'T', 'R')
#define TAG_ASTR TAG('A', 'S', 'T', 'R')
#define TAG_OSTR TAG('O', 'S', 'T', 'R')
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
WCHAR WCHAR STDCALL
STDCALL
RtlAnsiCharToUnicodeChar(CHAR AnsiChar) RtlAnsiCharToUnicodeChar(CHAR AnsiChar)
{ {
ULONG Size; ULONG Size;
@ -79,8 +84,9 @@ RtlAnsiStringToUnicodeString (
{ {
DestinationString->MaximumLength = Length + sizeof(WCHAR); DestinationString->MaximumLength = Length + sizeof(WCHAR);
DestinationString->Buffer = DestinationString->Buffer =
ExAllocatePool (NonPagedPool, ExAllocatePoolWithTag (NonPagedPool,
DestinationString->MaximumLength); DestinationString->MaximumLength,
TAG_USTR);
if (DestinationString->Buffer == NULL) if (DestinationString->Buffer == NULL)
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
@ -444,8 +450,9 @@ RtlCreateUnicodeString (
Length = (wcslen (Source) + 1) * sizeof(WCHAR); Length = (wcslen (Source) + 1) * sizeof(WCHAR);
Destination->Buffer = ExAllocatePool (NonPagedPool, Destination->Buffer = ExAllocatePoolWithTag (NonPagedPool,
Length); Length,
TAG_USTR);
if (Destination->Buffer == NULL) if (Destination->Buffer == NULL)
return FALSE; return FALSE;
@ -481,13 +488,10 @@ RtlCreateUnicodeStringFromAsciiz (
} }
NTSTATUS NTSTATUS STDCALL
STDCALL RtlDowncaseUnicodeString (IN OUT PUNICODE_STRING DestinationString,
RtlDowncaseUnicodeString (
IN OUT PUNICODE_STRING DestinationString,
IN PUNICODE_STRING SourceString, IN PUNICODE_STRING SourceString,
IN BOOLEAN AllocateDestinationString IN BOOLEAN AllocateDestinationString)
)
{ {
ULONG i; ULONG i;
PWCHAR Src, Dest; PWCHAR Src, Dest;
@ -495,8 +499,10 @@ RtlDowncaseUnicodeString (
if (AllocateDestinationString == TRUE) if (AllocateDestinationString == TRUE)
{ {
DestinationString->MaximumLength = SourceString->Length + sizeof(WCHAR); DestinationString->MaximumLength = SourceString->Length + sizeof(WCHAR);
DestinationString->Buffer = ExAllocatePool (NonPagedPool, DestinationString->Buffer =
SourceString->Length + sizeof(WCHAR)); ExAllocatePoolWithTag (NonPagedPool,
SourceString->Length + sizeof(WCHAR),
TAG_USTR);
if (DestinationString->Buffer == NULL) if (DestinationString->Buffer == NULL)
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
@ -829,13 +835,10 @@ RtlIntegerToUnicodeString (
} }
NTSTATUS NTSTATUS STDCALL
STDCALL RtlOemStringToCountedUnicodeString (IN OUT PUNICODE_STRING DestinationString,
RtlOemStringToCountedUnicodeString (
IN OUT PUNICODE_STRING DestinationString,
IN POEM_STRING SourceString, IN POEM_STRING SourceString,
IN BOOLEAN AllocateDestinationString IN BOOLEAN AllocateDestinationString)
)
{ {
NTSTATUS Status; NTSTATUS Status;
ULONG Length; ULONG Length;
@ -852,8 +855,9 @@ RtlOemStringToCountedUnicodeString (
{ {
DestinationString->MaximumLength = Length + sizeof(WCHAR); DestinationString->MaximumLength = Length + sizeof(WCHAR);
DestinationString->Buffer = DestinationString->Buffer =
ExAllocatePool (NonPagedPool, ExAllocatePoolWithTag (NonPagedPool,
DestinationString->MaximumLength); DestinationString->MaximumLength,
TAG_USTR);
if (DestinationString->Buffer == NULL) if (DestinationString->Buffer == NULL)
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
@ -902,13 +906,10 @@ RtlOemStringToUnicodeSize (
} }
NTSTATUS NTSTATUS STDCALL
STDCALL RtlOemStringToUnicodeString (IN OUT PUNICODE_STRING DestinationString,
RtlOemStringToUnicodeString (
IN OUT PUNICODE_STRING DestinationString,
IN POEM_STRING SourceString, IN POEM_STRING SourceString,
IN BOOLEAN AllocateDestinationString IN BOOLEAN AllocateDestinationString)
)
{ {
NTSTATUS Status; NTSTATUS Status;
ULONG Length; ULONG Length;
@ -925,8 +926,9 @@ RtlOemStringToUnicodeString (
{ {
DestinationString->MaximumLength = Length + sizeof(WCHAR); DestinationString->MaximumLength = Length + sizeof(WCHAR);
DestinationString->Buffer = DestinationString->Buffer =
ExAllocatePool (NonPagedPool, ExAllocatePoolWithTag (NonPagedPool,
DestinationString->MaximumLength); DestinationString->MaximumLength,
TAG_USTR);
if (DestinationString->Buffer == NULL) if (DestinationString->Buffer == NULL)
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
@ -1061,11 +1063,9 @@ RtlUnicodeStringToAnsiSize(IN PUNICODE_STRING UnicodeString)
NTSTATUS NTSTATUS
STDCALL STDCALL
RtlUnicodeStringToAnsiString ( RtlUnicodeStringToAnsiString (IN OUT PANSI_STRING DestinationString,
IN OUT PANSI_STRING DestinationString,
IN PUNICODE_STRING SourceString, IN PUNICODE_STRING SourceString,
IN BOOLEAN AllocateDestinationString IN BOOLEAN AllocateDestinationString)
)
{ {
NTSTATUS Status; NTSTATUS Status;
ULONG Length; ULONG Length;
@ -1079,8 +1079,9 @@ RtlUnicodeStringToAnsiString (
{ {
DestinationString->MaximumLength = Length + sizeof(CHAR); DestinationString->MaximumLength = Length + sizeof(CHAR);
DestinationString->Buffer = DestinationString->Buffer =
ExAllocatePool (NonPagedPool, ExAllocatePoolWithTag (NonPagedPool,
DestinationString->MaximumLength); DestinationString->MaximumLength,
TAG_ASTR);
if (DestinationString->Buffer == NULL) if (DestinationString->Buffer == NULL)
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
@ -1114,11 +1115,9 @@ RtlUnicodeStringToAnsiString (
NTSTATUS NTSTATUS
STDCALL STDCALL
RtlUnicodeStringToCountedOemString ( RtlUnicodeStringToCountedOemString (IN OUT POEM_STRING DestinationString,
IN OUT POEM_STRING DestinationString,
IN PUNICODE_STRING SourceString, IN PUNICODE_STRING SourceString,
IN BOOLEAN AllocateDestinationString IN BOOLEAN AllocateDestinationString)
)
{ {
NTSTATUS Status; NTSTATUS Status;
ULONG Length; ULONG Length;
@ -1136,8 +1135,9 @@ RtlUnicodeStringToCountedOemString (
if (AllocateDestinationString) if (AllocateDestinationString)
{ {
DestinationString->Buffer = ExAllocatePool (NonPagedPool, DestinationString->Buffer = ExAllocatePoolWithTag (NonPagedPool,
Length); Length,
TAG_ASTR);
if (DestinationString->Buffer == NULL) if (DestinationString->Buffer == NULL)
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
@ -1282,13 +1282,10 @@ RtlUnicodeStringToOemSize (
} }
NTSTATUS NTSTATUS STDCALL
STDCALL RtlUnicodeStringToOemString (IN OUT POEM_STRING DestinationString,
RtlUnicodeStringToOemString (
IN OUT POEM_STRING DestinationString,
IN PUNICODE_STRING SourceString, IN PUNICODE_STRING SourceString,
IN BOOLEAN AllocateDestinationString IN BOOLEAN AllocateDestinationString)
)
{ {
NTSTATUS Status; NTSTATUS Status;
ULONG Length; ULONG Length;
@ -1302,8 +1299,9 @@ RtlUnicodeStringToOemString (
{ {
DestinationString->MaximumLength = Length + sizeof(CHAR); DestinationString->MaximumLength = Length + sizeof(CHAR);
DestinationString->Buffer = DestinationString->Buffer =
ExAllocatePool (NonPagedPool, ExAllocatePoolWithTag (NonPagedPool,
DestinationString->MaximumLength); DestinationString->MaximumLength,
TAG_OSTR);
if (DestinationString->Buffer == NULL) if (DestinationString->Buffer == NULL)
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
@ -1353,13 +1351,10 @@ RtlUpcaseUnicodeChar (
} }
NTSTATUS NTSTATUS STDCALL
STDCALL RtlUpcaseUnicodeString (IN OUT PUNICODE_STRING DestinationString,
RtlUpcaseUnicodeString (
IN OUT PUNICODE_STRING DestinationString,
IN PUNICODE_STRING SourceString, IN PUNICODE_STRING SourceString,
IN BOOLEAN AllocateDestinationString IN BOOLEAN AllocateDestinationString)
)
{ {
ULONG i; ULONG i;
PWCHAR Src, Dest; PWCHAR Src, Dest;
@ -1367,8 +1362,10 @@ RtlUpcaseUnicodeString (
if (AllocateDestinationString == TRUE) if (AllocateDestinationString == TRUE)
{ {
DestinationString->MaximumLength = SourceString->Length + sizeof(WCHAR); DestinationString->MaximumLength = SourceString->Length + sizeof(WCHAR);
DestinationString->Buffer = ExAllocatePool (NonPagedPool, DestinationString->Buffer =
SourceString->Length + sizeof(WCHAR)); ExAllocatePoolWithTag (NonPagedPool,
SourceString->Length + sizeof(WCHAR),
TAG_USTR);
if (DestinationString->Buffer == NULL) if (DestinationString->Buffer == NULL)
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
@ -1412,8 +1409,10 @@ RtlUpcaseUnicodeStringToAnsiString (
if (AllocateDestinationString == TRUE) if (AllocateDestinationString == TRUE)
{ {
DestinationString->MaximumLength = Length + sizeof(CHAR); DestinationString->MaximumLength = Length + sizeof(CHAR);
DestinationString->Buffer = ExAllocatePool (NonPagedPool, DestinationString->Buffer =
DestinationString->MaximumLength); ExAllocatePoolWithTag (NonPagedPool,
DestinationString->MaximumLength,
TAG_ASTR);
if (DestinationString->Buffer == NULL) if (DestinationString->Buffer == NULL)
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
@ -1445,13 +1444,10 @@ RtlUpcaseUnicodeStringToAnsiString (
} }
NTSTATUS NTSTATUS STDCALL
STDCALL RtlUpcaseUnicodeStringToCountedOemString (IN OUT POEM_STRING DestinationString,
RtlUpcaseUnicodeStringToCountedOemString (
IN OUT POEM_STRING DestinationString,
IN PUNICODE_STRING SourceString, IN PUNICODE_STRING SourceString,
IN BOOLEAN AllocateDestinationString IN BOOLEAN AllocateDestinationString)
)
{ {
NTSTATUS Status; NTSTATUS Status;
ULONG Length; ULONG Length;
@ -1469,8 +1465,9 @@ RtlUpcaseUnicodeStringToCountedOemString (
if (AllocateDestinationString == TRUE) if (AllocateDestinationString == TRUE)
{ {
DestinationString->Buffer = ExAllocatePool (NonPagedPool, DestinationString->Buffer = ExAllocatePoolWithTag (NonPagedPool,
Length); Length,
TAG_OSTR);
if (DestinationString->Buffer == NULL) if (DestinationString->Buffer == NULL)
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
@ -1528,8 +1525,8 @@ RtlUpcaseUnicodeStringToOemString (
if (AllocateDestinationString == TRUE) if (AllocateDestinationString == TRUE)
{ {
DestinationString->MaximumLength = Length + sizeof(CHAR); DestinationString->MaximumLength = Length + sizeof(CHAR);
DestinationString->Buffer = ExAllocatePool (NonPagedPool, DestinationString->Buffer = ExAllocatePoolWithTag (NonPagedPool,
DestinationString->MaximumLength); DestinationString->MaximumLength, TAG_OSTR);
if (DestinationString->Buffer == NULL) if (DestinationString->Buffer == NULL)
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }