Git conversion: Make reactos the root directory, move rosapps, rostests, wallpapers into modules, and delete rossubsys.

ntoskrnl/cache/section/reqtools.c

@@ -0,0 +1,283 @@
+/*
+ * Copyright (C) 1998-2005 ReactOS Team (and the authors from the programmers section)
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *
+ * PROJECT:         ReactOS kernel
+ * FILE:            ntoskrnl/cache/section/reqtools.c
+ * PURPOSE:         Implements section objects
+ *
+ * PROGRAMMERS:     Rex Jolliff
+ *                  David Welch
+ *                  Eric Kohl
+ *                  Emanuele Aliberti
+ *                  Eugene Ingerman
+ *                  Casper Hornstrup
+ *                  KJK::Hyperion
+ *                  Guido de Jong
+ *                  Ge van Geldorp
+ *                  Royce Mitchell III
+ *                  Filip Navara
+ *                  Aleksey Bragin
+ *                  Jason Filby
+ *                  Thomas Weidenmueller
+ *                  Gunnar Andre' Dalsnes
+ *                  Mike Nordell
+ *                  Alex Ionescu
+ *                  Gregor Anich
+ *                  Steven Edwards
+ *                  Herve Poussineau
+ */
+
+/*
+  This file contains functions used by fault.c to do blocking resource
+  acquisition.  To call one of these functions, fill out your
+  MM_REQUIRED_RESOURCES with a pointer to the desired function and configure
+  the other members as below.
+ */
+
+/* INCLUDES *****************************************************************/
+
+#include <ntoskrnl.h>
+#include "newmm.h"
+#define NDEBUG
+#include <debug.h>
+
+#define DPRINTC DPRINT
+
+VOID
+NTAPI
+MmBuildMdlFromPages(PMDL Mdl, PPFN_NUMBER Pages);
+
+/*
+
+Blocking function to acquire zeroed pages from the balancer.
+
+Upon entry:
+
+Required->Amount: Number of pages to acquire
+Required->Consumer: consumer to charge the page to
+
+Upon return:
+
+Required->Pages[0..Amount]: Allocated pages.
+
+The function fails unless all requested pages can be allocated.
+
+ */
+NTSTATUS
+NTAPI
+MiGetOnePage(PMMSUPPORT AddressSpace,
+             PMEMORY_AREA MemoryArea,
+             PMM_REQUIRED_RESOURCES Required)
+{
+    ULONG i;
+    NTSTATUS Status = STATUS_SUCCESS;
+
+    for (i = 0; i < Required->Amount; i++)
+    {
+        DPRINTC("MiGetOnePage(%s:%d)\n", Required->File, Required->Line);
+        Status = MmRequestPageMemoryConsumer(Required->Consumer,
+                                             TRUE,
+                                             &Required->Page[i]);
+        if (!NT_SUCCESS(Status))
+        {
+            while (i > 0)
+            {
+                MmReleasePageMemoryConsumer(Required->Consumer,
+                                            Required->Page[i-1]);
+                i--;
+            }
+            return Status;
+        }
+    }
+
+    return Status;
+}
+
+/*
+
+Blocking function to read (part of) a page from a file.
+
+Upon entry:
+
+Required->Context: a FILE_OBJECT to read
+Required->Consumer: consumer to charge the page to
+Required->FileOffset: Offset to read at
+Required->Amount: Number of bytes to read (0 -> 4096)
+
+Upon return:
+
+Required->Page[Required->Offset]: The allocated and read in page
+
+The indicated page is filled to Required->Amount with file data and zeroed
+afterward.
+
+ */
+
+NTSTATUS
+NTAPI
+MiReadFilePage(PMMSUPPORT AddressSpace,
+               PMEMORY_AREA MemoryArea,
+               PMM_REQUIRED_RESOURCES RequiredResources)
+{
+    PFILE_OBJECT FileObject = RequiredResources->Context;
+    PPFN_NUMBER Page = &RequiredResources->Page[RequiredResources->Offset];
+    PLARGE_INTEGER FileOffset = &RequiredResources->FileOffset;
+    NTSTATUS Status;
+    PVOID PageBuf = NULL;
+    KEVENT Event;
+    IO_STATUS_BLOCK IOSB;
+    UCHAR MdlBase[sizeof(MDL) + sizeof(ULONG)];
+    PMDL Mdl = (PMDL)MdlBase;
+    KIRQL OldIrql;
+
+    DPRINTC("Pulling page %I64x from %wZ to %Ix\n",
+            FileOffset->QuadPart,
+            &FileObject->FileName,
+            *Page);
+
+    Status = MmRequestPageMemoryConsumer(RequiredResources->Consumer,
+                                         TRUE,
+                                         Page);
+
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("Status: %x\n", Status);
+        return Status;
+    }
+
+    MmInitializeMdl(Mdl, NULL, PAGE_SIZE);
+    MmBuildMdlFromPages(Mdl, Page);
+    Mdl->MdlFlags |= MDL_PAGES_LOCKED;
+
+    KeInitializeEvent(&Event, NotificationEvent, FALSE);
+    Status = IoPageRead(FileObject, Mdl, FileOffset, &Event, &IOSB);
+    if (Status == STATUS_PENDING)
+    {
+        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+        Status = IOSB.Status;
+    }
+    if (Mdl->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA)
+    {
+        MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
+    }
+
+    PageBuf = MiMapPageInHyperSpace(PsGetCurrentProcess(), *Page, &OldIrql);
+    if (!PageBuf)
+    {
+        MmReleasePageMemoryConsumer(RequiredResources->Consumer, *Page);
+        return STATUS_NO_MEMORY;
+    }
+
+    RtlZeroMemory((PCHAR)PageBuf+RequiredResources->Amount,
+                  PAGE_SIZE-RequiredResources->Amount);
+
+    MiUnmapPageInHyperSpace(PsGetCurrentProcess(), PageBuf, OldIrql);
+
+    DPRINT("Read Status %x (Page %x)\n", Status, *Page);
+
+    if (!NT_SUCCESS(Status))
+    {
+        MmReleasePageMemoryConsumer(RequiredResources->Consumer, *Page);
+        DPRINT("Status: %x\n", Status);
+        return Status;
+    }
+
+    return STATUS_SUCCESS;
+}
+
+/*
+
+Blocking function to read a swap page into a memory page.
+
+Upon entry:
+
+Required->Consumer: consumer to charge the page to
+Required->SwapEntry: swap entry to use
+
+Upon return:
+
+Required->Page[Required->Offset]: Populated page
+
+*/
+
+NTSTATUS
+NTAPI
+MiSwapInPage(PMMSUPPORT AddressSpace,
+             PMEMORY_AREA MemoryArea,
+             PMM_REQUIRED_RESOURCES Resources)
+{
+    NTSTATUS Status;
+
+    Status = MmRequestPageMemoryConsumer(Resources->Consumer,
+                                         TRUE,
+                                         &Resources->Page[Resources->Offset]);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("MmRequestPageMemoryConsumer failed, status = %x\n", Status);
+        return Status;
+    }
+
+    Status = MmReadFromSwapPage(Resources->SwapEntry,
+                                Resources->Page[Resources->Offset]);
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT1("MmReadFromSwapPage failed, status = %x\n", Status);
+        return Status;
+    }
+
+    MmSetSavedSwapEntryPage(Resources->Page[Resources->Offset],
+                            Resources->SwapEntry);
+
+    DPRINT1("MiSwapInPage(%x,%x)\n",
+            Resources->Page[Resources->Offset],
+            Resources->SwapEntry);
+
+    return Status;
+}
+
+/*
+
+A way to write a page without a lock acquired using the same blocking mechanism
+as resource acquisition.
+
+Upon entry:
+
+Required->Page[Required->Offset]: Page to write
+Required->Context: FILE_OBJECT to write to
+Required->FileOffset: offset to write at
+
+This always does a paging write with whole page size.  Note that paging IO
+doesn't change the valid data length of a file.
+
+*/
+
+NTSTATUS
+NTAPI
+MiWriteFilePage(PMMSUPPORT AddressSpace,
+                PMEMORY_AREA MemoryArea,
+                PMM_REQUIRED_RESOURCES Required)
+{
+    DPRINT1("MiWriteFilePage(%x,%x)\n",
+            Required->Page[Required->Offset],
+            Required->FileOffset.LowPart);
+
+    return MiWriteBackPage(Required->Context,
+                           &Required->FileOffset,
+                           PAGE_SIZE,
+                           Required->Page[Required->Offset]);
+}