ntoskrnl/mm/arm/page.c

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * LICENSE:         BSD - See COPYING.ARM in the top level directory
   4  * FILE:            ntoskrnl/mm/arm/page.c
   5  * PURPOSE:         Old-school Page Management
   6  * PROGRAMMERS:     ReactOS Portable Systems Group
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #include <ntoskrnl.h>
  12 #define NDEBUG
  13 #include <debug.h>
  14
  15 #line 15 "ARM³::ARMPAGE"
  16 #define MODULE_INVOLVED_IN_ARM3
  17 #include "../ARM3/miarm.h"
  18
  19 /* GLOBALS ********************************************************************/
  20
  21 const
  22 ULONG
  23 MmProtectToPteMask[32] =
  24 {
  25     //
  26     // These are the base MM_ protection flags
  27     //
  28     0,
  29     PTE_READONLY            | PTE_ENABLE_CACHE,
  30     PTE_EXECUTE             | PTE_ENABLE_CACHE,
  31     PTE_EXECUTE_READ        | PTE_ENABLE_CACHE,
  32     PTE_READWRITE           | PTE_ENABLE_CACHE,
  33     PTE_WRITECOPY           | PTE_ENABLE_CACHE,
  34     PTE_EXECUTE_READWRITE   | PTE_ENABLE_CACHE,
  35     PTE_EXECUTE_WRITECOPY   | PTE_ENABLE_CACHE,
  36     //
  37     // These OR in the MM_NOCACHE flag
  38     //
  39     0,
  40     PTE_READONLY            | PTE_DISABLE_CACHE,
  41     PTE_EXECUTE             | PTE_DISABLE_CACHE,
  42     PTE_EXECUTE_READ        | PTE_DISABLE_CACHE,
  43     PTE_READWRITE           | PTE_DISABLE_CACHE,
  44     PTE_WRITECOPY           | PTE_DISABLE_CACHE,
  45     PTE_EXECUTE_READWRITE   | PTE_DISABLE_CACHE,
  46     PTE_EXECUTE_WRITECOPY   | PTE_DISABLE_CACHE,
  47     //
  48     // These OR in the MM_DECOMMIT flag, which doesn't seem supported on x86/64/ARM
  49     //
  50     0,
  51     PTE_READONLY            | PTE_ENABLE_CACHE,
  52     PTE_EXECUTE             | PTE_ENABLE_CACHE,
  53     PTE_EXECUTE_READ        | PTE_ENABLE_CACHE,
  54     PTE_READWRITE           | PTE_ENABLE_CACHE,
  55     PTE_WRITECOPY           | PTE_ENABLE_CACHE,
  56     PTE_EXECUTE_READWRITE   | PTE_ENABLE_CACHE,
  57     PTE_EXECUTE_WRITECOPY   | PTE_ENABLE_CACHE,
  58     //
  59     // These OR in the MM_NOACCESS flag, which seems to enable WriteCombining?
  60     //
  61     0,
  62     PTE_READONLY            | PTE_WRITECOMBINED_CACHE,
  63     PTE_EXECUTE             | PTE_WRITECOMBINED_CACHE,
  64     PTE_EXECUTE_READ        | PTE_WRITECOMBINED_CACHE,
  65     PTE_READWRITE           | PTE_WRITECOMBINED_CACHE,
  66     PTE_WRITECOPY           | PTE_WRITECOMBINED_CACHE,
  67     PTE_EXECUTE_READWRITE   | PTE_WRITECOMBINED_CACHE,
  68     PTE_EXECUTE_WRITECOPY   | PTE_WRITECOMBINED_CACHE,
  69 };
  70
  71 const
  72 ULONG MmProtectToValue[32] =
  73 {
  74     PAGE_NOACCESS,
  75     PAGE_READONLY,
  76     PAGE_EXECUTE,
  77     PAGE_EXECUTE_READ,
  78     PAGE_READWRITE,
  79     PAGE_WRITECOPY,
  80     PAGE_EXECUTE_READWRITE,
  81     PAGE_EXECUTE_WRITECOPY,
  82     PAGE_NOACCESS,
  83     PAGE_NOCACHE | PAGE_READONLY,
  84     PAGE_NOCACHE | PAGE_EXECUTE,
  85     PAGE_NOCACHE | PAGE_EXECUTE_READ,
  86     PAGE_NOCACHE | PAGE_READWRITE,
  87     PAGE_NOCACHE | PAGE_WRITECOPY,
  88     PAGE_NOCACHE | PAGE_EXECUTE_READWRITE,
  89     PAGE_NOCACHE | PAGE_EXECUTE_WRITECOPY,
  90     PAGE_NOACCESS,
  91     PAGE_GUARD | PAGE_READONLY,
  92     PAGE_GUARD | PAGE_EXECUTE,
  93     PAGE_GUARD | PAGE_EXECUTE_READ,
  94     PAGE_GUARD | PAGE_READWRITE,
  95     PAGE_GUARD | PAGE_WRITECOPY,
  96     PAGE_GUARD | PAGE_EXECUTE_READWRITE,
  97     PAGE_GUARD | PAGE_EXECUTE_WRITECOPY,
  98     PAGE_NOACCESS,
  99     PAGE_WRITECOMBINE | PAGE_READONLY,
 100     PAGE_WRITECOMBINE | PAGE_EXECUTE,
 101     PAGE_WRITECOMBINE | PAGE_EXECUTE_READ,
 102     PAGE_WRITECOMBINE | PAGE_READWRITE,
 103     PAGE_WRITECOMBINE | PAGE_WRITECOPY,
 104     PAGE_WRITECOMBINE | PAGE_EXECUTE_READWRITE,
 105     PAGE_WRITECOMBINE | PAGE_EXECUTE_WRITECOPY
 106 };
 107
 108 ULONG MmGlobalKernelPageDirectory[4096];
 109
 110 /* Template PTE and PDE for a kernel page */
 111 MMPDE ValidKernelPde = {.u.Hard.Valid = 1};
 112 MMPTE ValidKernelPte = {.u.Hard.Valid = 1, .u.Hard.Sbo = 1};
 113
 114 /* Template PDE for a demand-zero page */
 115 MMPDE DemandZeroPde  = {.u.Long = (MM_READWRITE << MM_PTE_SOFTWARE_PROTECTION_BITS)};
 116 MMPTE DemandZeroPte  = {.u.Long = (MM_READWRITE << MM_PTE_SOFTWARE_PROTECTION_BITS)};
 117
 118 /* Template PTE for prototype page */
 119 MMPTE PrototypePte = {.u.Long = (MM_READWRITE << MM_PTE_SOFTWARE_PROTECTION_BITS) | PTE_PROTOTYPE | (MI_PTE_LOOKUP_NEEDED << PAGE_SHIFT)};
 120
 121 /* PRIVATE FUNCTIONS **********************************************************/
 122
 123 VOID
 124 NTAPI
 125 MiFlushTlb(IN PMMPTE PointerPte,
 126            IN PVOID Address)
 127 {
 128     UNIMPLEMENTED;
 129     while (TRUE);
 130 }
 131
 132 BOOLEAN
 133 NTAPI
 134 MmCreateProcessAddressSpace(IN ULONG MinWs,
 135                             IN PEPROCESS Process,
 136                             IN PULONG DirectoryTableBase)
 137 {
 138     UNIMPLEMENTED;
 139     while (TRUE);
 140     return FALSE;
 141 }
 142
 143 VOID
 144 NTAPI
 145 MmUpdatePageDir(IN PEPROCESS Process,
 146                 IN PVOID Address,
 147                 IN ULONG Size)
 148 {
 149     /* Nothing to do */
 150     return;
 151 }
 152
 153 PULONG
 154 NTAPI
 155 MmGetPageDirectory(VOID)
 156 {
 157     /* Return the TTB */
 158     return (PULONG)KeArmTranslationTableRegisterGet().AsUlong;
 159 }
 160
 161 VOID
 162 NTAPI
 163 MmDisableVirtualMapping(IN PEPROCESS Process,
 164                         IN PVOID Address,
 165                         OUT PBOOLEAN WasDirty,
 166                         OUT PPFN_NUMBER Page)
 167 {
 168     UNIMPLEMENTED;
 169     while (TRUE);
 170 }
 171
 172 VOID
 173 NTAPI
 174 MmEnableVirtualMapping(IN PEPROCESS Process,
 175                        IN PVOID Address)
 176 {
 177     UNIMPLEMENTED;
 178     while (TRUE);
 179 }
 180
 181 NTSTATUS
 182 NTAPI
 183 MmCreateVirtualMappingUnsafe(IN PEPROCESS Process,
 184                              IN PVOID Address,
 185                              IN ULONG Protection,
 186                              IN PPFN_NUMBER Pages,
 187                              IN ULONG PageCount)
 188 {
 189     UNIMPLEMENTED;
 190     while (TRUE);
 191     return STATUS_SUCCESS;
 192 }
 193
 194 NTSTATUS
 195 NTAPI
 196 MmCreateVirtualMapping(IN PEPROCESS Process,
 197                        IN PVOID Address,
 198                        IN ULONG Protection,
 199                        IN PPFN_NUMBER Pages,
 200                        IN ULONG PageCount)
 201 {
 202     UNIMPLEMENTED;
 203     while (TRUE);
 204     return STATUS_SUCCESS;
 205 }
 206
 207 VOID
 208 NTAPI
 209 MmRawDeleteVirtualMapping(IN PVOID Address)
 210 {
 211     UNIMPLEMENTED;
 212     while (TRUE);
 213 }
 214
 215 VOID
 216 NTAPI
 217 MmDeleteVirtualMapping(IN PEPROCESS Process,
 218                        IN PVOID Address,
 219                        IN BOOLEAN FreePage,
 220                        OUT PBOOLEAN WasDirty,
 221                        OUT PPFN_NUMBER Page)
 222 {
 223     UNIMPLEMENTED;
 224     while (TRUE);
 225 }
 226
 227 VOID
 228 NTAPI
 229 MmDeletePageFileMapping(IN PEPROCESS Process,
 230                         IN PVOID Address,
 231                         IN SWAPENTRY *SwapEntry)
 232 {
 233     UNIMPLEMENTED;
 234     while (TRUE);
 235 }
 236
 237 NTSTATUS
 238 NTAPI
 239 MmCreatePageFileMapping(IN PEPROCESS Process,
 240                         IN PVOID Address,
 241                         IN SWAPENTRY SwapEntry)
 242 {
 243     UNIMPLEMENTED;
 244     while (TRUE);
 245     return 0;
 246 }
 247
 248 PFN_NUMBER
 249 NTAPI
 250 MmGetPfnForProcess(IN PEPROCESS Process,
 251                    IN PVOID Address)
 252 {
 253     UNIMPLEMENTED;
 254     while (TRUE);
 255     return 0;
 256 }
 257
 258 BOOLEAN
 259 NTAPI
 260 MmIsDirtyPage(IN PEPROCESS Process,
 261               IN PVOID Address)
 262 {
 263     UNIMPLEMENTED;
 264     while (TRUE);
 265     return 0;
 266 }
 267
 268 VOID
 269 NTAPI
 270 MmSetCleanPage(IN PEPROCESS Process,
 271                IN PVOID Address)
 272 {
 273     UNIMPLEMENTED;
 274     while (TRUE);
 275 }
 276
 277 VOID
 278 NTAPI
 279 MmSetDirtyPage(IN PEPROCESS Process,
 280                IN PVOID Address)
 281 {
 282     UNIMPLEMENTED;
 283     while (TRUE);
 284 }
 285
 286 BOOLEAN
 287 NTAPI
 288 MmIsPagePresent(IN PEPROCESS Process,
 289                 IN PVOID Address)
 290 {
 291     UNIMPLEMENTED;
 292     while (TRUE);
 293     return FALSE;
 294 }
 295
 296 BOOLEAN
 297 NTAPI
 298 MmIsPageSwapEntry(IN PEPROCESS Process,
 299                   IN PVOID Address)
 300 {
 301     UNIMPLEMENTED;
 302     while (TRUE);
 303     return FALSE;
 304 }
 305
 306 ULONG
 307 NTAPI
 308 MmGetPageProtect(IN PEPROCESS Process,
 309                  IN PVOID Address)
 310 {
 311     /* We don't enforce any protection on the pages -- they are all RWX */
 312     return PAGE_READWRITE;
 313 }
 314
 315 VOID
 316 NTAPI
 317 MmSetPageProtect(IN PEPROCESS Process,
 318                  IN PVOID Address,
 319                  IN ULONG Protection)
 320 {
 321     /* We don't enforce any protection on the pages -- they are all RWX */
 322     return;
 323 }
 324
 325 VOID
 326 NTAPI
 327 MmInitGlobalKernelPageDirectory(VOID)
 328 {
 329     ULONG i;
 330     PULONG CurrentPageDirectory = (PULONG)PDE_BASE;
 331
 332
 333     /* Loop the 2GB of address space which belong to the kernel */
 334     for (i = MiGetPdeOffset(MmSystemRangeStart); i < 2048; i++)
 335     {
 336         /* Check if we have an entry for this already */
 337         if ((i != MiGetPdeOffset(PTE_BASE)) &&
 338             (i != MiGetPdeOffset(HYPER_SPACE)) &&
 339             (!MmGlobalKernelPageDirectory[i]) &&
 340             (CurrentPageDirectory[i]))
 341         {
 342             /* We don't, link it in our global page directory */
 343             MmGlobalKernelPageDirectory[i] = CurrentPageDirectory[i];
 344         }
 345     }
 346 }
 347
 348 /* PUBLIC FUNCTIONS ***********************************************************/
 349
 350 /*
 351  * @implemented
 352  */
 353 PHYSICAL_ADDRESS
 354 NTAPI
 355 MmGetPhysicalAddress(IN PVOID Address)
 356 {
 357     PHYSICAL_ADDRESS PhysicalAddress;
 358     PhysicalAddress.QuadPart = 0;
 359
 360     UNIMPLEMENTED;
 361     while (TRUE);
 362
 363     return PhysicalAddress;
 364 }