projects / reactos.git / blob
? search:


e79ff5f07baccf7bb8bfcd94221495459589244e
[reactos.git] / ntoskrnl / mm / section.c
1 /*
2 * Copyright (C) 1998-2005 ReactOS Team (and the authors from the programmers section)
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 *
18 *
19 * PROJECT: ReactOS kernel
20 * FILE: ntoskrnl/mm/section.c
21 * PURPOSE: Implements section objects
22 *
23 * PROGRAMMERS: Rex Jolliff
24 * David Welch
25 * Eric Kohl
26 * Emanuele Aliberti
27 * Eugene Ingerman
28 * Casper Hornstrup
29 * KJK::Hyperion
30 * Guido de Jong
31 * Ge van Geldorp
32 * Royce Mitchell III
33 * Filip Navara
34 * Aleksey Bragin
35 * Jason Filby
36 * Thomas Weidenmueller
37 * Gunnar Andre' Dalsnes
38 * Mike Nordell
39 * Alex Ionescu
40 * Gregor Anich
41 * Steven Edwards
42 * Herve Poussineau
43 */
44
45 /* INCLUDES *****************************************************************/
46
47 #include <ntoskrnl.h>
48 #include <cache/newcc.h>
49 #include <cache/section/newmm.h>
50 #define NDEBUG
51 #include <debug.h>
52 #include <reactos/exeformat.h>
53
54 #if defined (ALLOC_PRAGMA)
55 #pragma alloc_text(INIT, MmCreatePhysicalMemorySection)
56 #pragma alloc_text(INIT, MmInitSectionImplementation)
57 #endif
58
59 #include "ARM3/miarm.h"
60
61 #undef MmSetPageEntrySectionSegment
62 #define MmSetPageEntrySectionSegment(S,O,E) do { \
63 DPRINT("SetPageEntrySectionSegment(old,%p,%x,%x)\n",(S),(O)->LowPart,E); \
64 _MmSetPageEntrySectionSegment((S),(O),(E),__FILE__,__LINE__); \
65 } while (0)
66
67 extern MMSESSION MmSession;
68
69 NTSTATUS
70 NTAPI
71 MiMapViewInSystemSpace(IN PVOID Section,
72 IN PVOID Session,
73 OUT PVOID *MappedBase,
74 IN OUT PSIZE_T ViewSize);
75
76 NTSTATUS
77 NTAPI
78 MmCreateArm3Section(OUT PVOID *SectionObject,
79 IN ACCESS_MASK DesiredAccess,
80 IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
81 IN PLARGE_INTEGER InputMaximumSize,
82 IN ULONG SectionPageProtection,
83 IN ULONG AllocationAttributes,
84 IN HANDLE FileHandle OPTIONAL,
85 IN PFILE_OBJECT FileObject OPTIONAL);
86
87 NTSTATUS
88 NTAPI
89 MmMapViewOfArm3Section(IN PVOID SectionObject,
90 IN PEPROCESS Process,
91 IN OUT PVOID *BaseAddress,
92 IN ULONG_PTR ZeroBits,
93 IN SIZE_T CommitSize,
94 IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
95 IN OUT PSIZE_T ViewSize,
96 IN SECTION_INHERIT InheritDisposition,
97 IN ULONG AllocationType,
98 IN ULONG Protect);
99
100 //
101 // PeFmtCreateSection depends on the following:
102 //
103 C_ASSERT(EXEFMT_LOAD_HEADER_SIZE >= sizeof(IMAGE_DOS_HEADER));
104 C_ASSERT(sizeof(IMAGE_NT_HEADERS32) <= sizeof(IMAGE_NT_HEADERS64));
105
106 C_ASSERT(TYPE_ALIGNMENT(IMAGE_NT_HEADERS32) == TYPE_ALIGNMENT(IMAGE_NT_HEADERS64));
107 C_ASSERT(RTL_SIZEOF_THROUGH_FIELD(IMAGE_NT_HEADERS32, FileHeader) == RTL_SIZEOF_THROUGH_FIELD(IMAGE_NT_HEADERS64, FileHeader));
108 C_ASSERT(FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader) == FIELD_OFFSET(IMAGE_NT_HEADERS64, OptionalHeader));
109
110 C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, Magic));
111 C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, SectionAlignment));
112 C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, FileAlignment));
113 C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, Subsystem));
114 C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, MinorSubsystemVersion));
115 C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, MajorSubsystemVersion));
116 C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, AddressOfEntryPoint));
117 C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, SizeOfCode));
118 C_ASSERT(PEFMT_FIELDS_EQUAL(IMAGE_OPTIONAL_HEADER32, IMAGE_OPTIONAL_HEADER64, SizeOfHeaders));
119
120 /* TYPES *********************************************************************/
121
122 typedef struct
123 {
124 PROS_SECTION_OBJECT Section;
125 PMM_SECTION_SEGMENT Segment;
126 LARGE_INTEGER Offset;
127 BOOLEAN WasDirty;
128 BOOLEAN Private;
129 PEPROCESS CallingProcess;
130 ULONG_PTR SectionEntry;
131 }
132 MM_SECTION_PAGEOUT_CONTEXT;
133
134 /* GLOBALS *******************************************************************/
135
136 POBJECT_TYPE MmSectionObjectType = NULL;
137
138 ULONG_PTR MmSubsectionBase;
139
140 static ULONG SectionCharacteristicsToProtect[16] =
141 {
142 PAGE_NOACCESS, /* 0 = NONE */
143 PAGE_NOACCESS, /* 1 = SHARED */
144 PAGE_EXECUTE, /* 2 = EXECUTABLE */
145 PAGE_EXECUTE, /* 3 = EXECUTABLE, SHARED */
146 PAGE_READONLY, /* 4 = READABLE */
147 PAGE_READONLY, /* 5 = READABLE, SHARED */
148 PAGE_EXECUTE_READ, /* 6 = READABLE, EXECUTABLE */
149 PAGE_EXECUTE_READ, /* 7 = READABLE, EXECUTABLE, SHARED */
150 /*
151 * FIXME? do we really need the WriteCopy field in segments? can't we use
152 * PAGE_WRITECOPY here?
153 */
154 PAGE_READWRITE, /* 8 = WRITABLE */
155 PAGE_READWRITE, /* 9 = WRITABLE, SHARED */
156 PAGE_EXECUTE_READWRITE, /* 10 = WRITABLE, EXECUTABLE */
157 PAGE_EXECUTE_READWRITE, /* 11 = WRITABLE, EXECUTABLE, SHARED */
158 PAGE_READWRITE, /* 12 = WRITABLE, READABLE */
159 PAGE_READWRITE, /* 13 = WRITABLE, READABLE, SHARED */
160 PAGE_EXECUTE_READWRITE, /* 14 = WRITABLE, READABLE, EXECUTABLE */
161 PAGE_EXECUTE_READWRITE, /* 15 = WRITABLE, READABLE, EXECUTABLE, SHARED */
162 };
163
164 extern ULONG MmMakeFileAccess [];
165 ACCESS_MASK NTAPI MiArm3GetCorrectFileAccessMask(IN ACCESS_MASK SectionPageProtection);
166 static GENERIC_MAPPING MmpSectionMapping =
167 {
168 STANDARD_RIGHTS_READ | SECTION_MAP_READ | SECTION_QUERY,
169 STANDARD_RIGHTS_WRITE | SECTION_MAP_WRITE,
170 STANDARD_RIGHTS_EXECUTE | SECTION_MAP_EXECUTE,
171 SECTION_ALL_ACCESS
172 };
173
174
175 /* FUNCTIONS *****************************************************************/
176
177
178 /*
179 References:
180 [1] Microsoft Corporation, "Microsoft Portable Executable and Common Object
181 File Format Specification", revision 6.0 (February 1999)
182 */
183 NTSTATUS NTAPI PeFmtCreateSection(IN CONST VOID * FileHeader,
184 IN SIZE_T FileHeaderSize,
185 IN PVOID File,
186 OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject,
187 OUT PULONG Flags,
188 IN PEXEFMT_CB_READ_FILE ReadFileCb,
189 IN PEXEFMT_CB_ALLOCATE_SEGMENTS AllocateSegmentsCb)
190 {
191 NTSTATUS nStatus;
192 ULONG cbFileHeaderOffsetSize = 0;
193 ULONG cbSectionHeadersOffset = 0;
194 ULONG cbSectionHeadersSize;
195 ULONG cbSectionHeadersOffsetSize = 0;
196 ULONG cbOptHeaderSize;
197 ULONG cbHeadersSize = 0;
198 ULONG nSectionAlignment;
199 ULONG nFileAlignment;
200 ULONG_PTR ImageBase;
201 const IMAGE_DOS_HEADER * pidhDosHeader;
202 const IMAGE_NT_HEADERS32 * pinhNtHeader;
203 const IMAGE_OPTIONAL_HEADER32 * piohOptHeader;
204 const IMAGE_SECTION_HEADER * pishSectionHeaders;
205 PMM_SECTION_SEGMENT pssSegments;
206 LARGE_INTEGER lnOffset;
207 PVOID pBuffer;
208 SIZE_T nPrevVirtualEndOfSegment = 0;
209 ULONG nFileSizeOfHeaders = 0;
210 ULONG i;
211 ULONG AlignedLength;
212
213 ASSERT(FileHeader);
214 ASSERT(FileHeaderSize > 0);
215 ASSERT(File);
216 ASSERT(ImageSectionObject);
217 ASSERT(ReadFileCb);
218 ASSERT(AllocateSegmentsCb);
219
220 ASSERT(Intsafe_CanOffsetPointer(FileHeader, FileHeaderSize));
221
222 ASSERT(((UINT_PTR)FileHeader % TYPE_ALIGNMENT(IMAGE_DOS_HEADER)) == 0);
223
224 #define DIE(ARGS_) { DPRINT ARGS_; goto l_Return; }
225
226 pBuffer = NULL;
227 pidhDosHeader = FileHeader;
228
229 /* DOS HEADER */
230 nStatus = STATUS_ROS_EXEFMT_UNKNOWN_FORMAT;
231
232 /* image too small to be an MZ executable */
233 if(FileHeaderSize < sizeof(IMAGE_DOS_HEADER))
234 DIE(("Too small to be an MZ executable, size is %lu\n", FileHeaderSize));
235
236 /* no MZ signature */
237 if(pidhDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
238 DIE(("No MZ signature found, e_magic is %hX\n", pidhDosHeader->e_magic));
239
240 /* NT HEADER */
241 nStatus = STATUS_INVALID_IMAGE_PROTECT;
242
243 /* not a Windows executable */
244 if(pidhDosHeader->e_lfanew <= 0)
245 DIE(("Not a Windows executable, e_lfanew is %d\n", pidhDosHeader->e_lfanew));
246
247 if(!Intsafe_AddULong32(&cbFileHeaderOffsetSize, pidhDosHeader->e_lfanew, RTL_SIZEOF_THROUGH_FIELD(IMAGE_NT_HEADERS32, FileHeader)))
248 DIE(("The DOS stub is too large, e_lfanew is %X\n", pidhDosHeader->e_lfanew));
249
250 if(FileHeaderSize < cbFileHeaderOffsetSize)
251 pinhNtHeader = NULL;
252 else
253 {
254 /*
255 * we already know that Intsafe_CanOffsetPointer(FileHeader, FileHeaderSize),
256 * and FileHeaderSize >= cbFileHeaderOffsetSize, so this holds true too
257 */
258 ASSERT(Intsafe_CanOffsetPointer(FileHeader, pidhDosHeader->e_lfanew));
259 pinhNtHeader = (PVOID)((UINT_PTR)FileHeader + pidhDosHeader->e_lfanew);
260 }
261
262 /*
263 * the buffer doesn't contain the NT file header, or the alignment is wrong: we
264 * need to read the header from the file
265 */
266 if(FileHeaderSize < cbFileHeaderOffsetSize ||
267 (UINT_PTR)pinhNtHeader % TYPE_ALIGNMENT(IMAGE_NT_HEADERS32) != 0)
268 {
269 ULONG cbNtHeaderSize;
270 ULONG cbReadSize;
271 PVOID pData;
272
273 l_ReadHeaderFromFile:
274 cbNtHeaderSize = 0;
275 lnOffset.QuadPart = pidhDosHeader->e_lfanew;
276
277 /* read the header from the file */
278 nStatus = ReadFileCb(File, &lnOffset, sizeof(IMAGE_NT_HEADERS64), &pData, &pBuffer, &cbReadSize);
279
280 if(!NT_SUCCESS(nStatus))
281 {
282 NTSTATUS ReturnedStatus = nStatus;
283
284 /* If it attempted to read past the end of the file, it means e_lfanew is invalid */
285 if (ReturnedStatus == STATUS_END_OF_FILE) nStatus = STATUS_INVALID_IMAGE_PROTECT;
286
287 DIE(("ReadFile failed, status %08X\n", ReturnedStatus));
288 }
289
290 ASSERT(pData);
291 ASSERT(pBuffer);
292 ASSERT(cbReadSize > 0);
293
294 nStatus = STATUS_INVALID_IMAGE_FORMAT;
295
296 /* the buffer doesn't contain the file header */
297 if(cbReadSize < RTL_SIZEOF_THROUGH_FIELD(IMAGE_NT_HEADERS32, FileHeader))
298 DIE(("The file doesn't contain the PE file header\n"));
299
300 pinhNtHeader = pData;
301
302 /* object still not aligned: copy it to the beginning of the buffer */
303 if((UINT_PTR)pinhNtHeader % TYPE_ALIGNMENT(IMAGE_NT_HEADERS32) != 0)
304 {
305 ASSERT((UINT_PTR)pBuffer % TYPE_ALIGNMENT(IMAGE_NT_HEADERS32) == 0);
306 RtlMoveMemory(pBuffer, pData, cbReadSize);
307 pinhNtHeader = pBuffer;
308 }
309
310 /* invalid NT header */
311 nStatus = STATUS_INVALID_IMAGE_PROTECT;
312
313 if(pinhNtHeader->Signature != IMAGE_NT_SIGNATURE)
314 DIE(("The file isn't a PE executable, Signature is %X\n", pinhNtHeader->Signature));
315
316 nStatus = STATUS_INVALID_IMAGE_FORMAT;
317
318 if(!Intsafe_AddULong32(&cbNtHeaderSize, pinhNtHeader->FileHeader.SizeOfOptionalHeader, FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader)))
319 DIE(("The full NT header is too large\n"));
320
321 /* the buffer doesn't contain the whole NT header */
322 if(cbReadSize < cbNtHeaderSize)
323 DIE(("The file doesn't contain the full NT header\n"));
324 }
325 else
326 {
327 ULONG cbOptHeaderOffsetSize = 0;
328
329 nStatus = STATUS_INVALID_IMAGE_PROTECT;
330
331 /* don't trust an invalid NT header */
332 if(pinhNtHeader->Signature != IMAGE_NT_SIGNATURE)
333 DIE(("The file isn't a PE executable, Signature is %X\n", pinhNtHeader->Signature));
334
335 if(!Intsafe_AddULong32(&cbOptHeaderOffsetSize, pidhDosHeader->e_lfanew, FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader)))
336 DIE(("The DOS stub is too large, e_lfanew is %X\n", pidhDosHeader->e_lfanew));
337
338 nStatus = STATUS_INVALID_IMAGE_FORMAT;
339
340 if(!Intsafe_AddULong32(&cbOptHeaderOffsetSize, cbOptHeaderOffsetSize, pinhNtHeader->FileHeader.SizeOfOptionalHeader))
341 DIE(("The NT header is too large, SizeOfOptionalHeader is %X\n", pinhNtHeader->FileHeader.SizeOfOptionalHeader));
342
343 /* the buffer doesn't contain the whole NT header: read it from the file */
344 if(cbOptHeaderOffsetSize > FileHeaderSize)
345 goto l_ReadHeaderFromFile;
346 }
347
348 /* read information from the NT header */
349 piohOptHeader = &pinhNtHeader->OptionalHeader;
350 cbOptHeaderSize = pinhNtHeader->FileHeader.SizeOfOptionalHeader;
351
352 nStatus = STATUS_INVALID_IMAGE_FORMAT;
353
354 if(!RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, Magic))
355 DIE(("The optional header doesn't contain the Magic field, SizeOfOptionalHeader is %X\n", cbOptHeaderSize));
356
357 /* ASSUME: RtlZeroMemory(ImageSectionObject, sizeof(*ImageSectionObject)); */
358
359 switch(piohOptHeader->Magic)
360 {
361 case IMAGE_NT_OPTIONAL_HDR32_MAGIC:
362 #ifdef _WIN64
363 case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
364 #endif // _WIN64
365 break;
366
367 default:
368 DIE(("Unrecognized optional header, Magic is %X\n", piohOptHeader->Magic));
369 }
370
371 if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SectionAlignment) &&
372 RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, FileAlignment))
373 {
374 /* See [1], section 3.4.2 */
375 if(piohOptHeader->SectionAlignment < PAGE_SIZE)
376 {
377 if(piohOptHeader->FileAlignment != piohOptHeader->SectionAlignment)
378 DIE(("Sections aren't page-aligned and the file alignment isn't the same\n"));
379 }
380 else if(piohOptHeader->SectionAlignment < piohOptHeader->FileAlignment)
381 DIE(("The section alignment is smaller than the file alignment\n"));
382
383 nSectionAlignment = piohOptHeader->SectionAlignment;
384 nFileAlignment = piohOptHeader->FileAlignment;
385
386 if(!IsPowerOf2(nSectionAlignment) || !IsPowerOf2(nFileAlignment))
387 DIE(("The section alignment (%u) and file alignment (%u) aren't both powers of 2\n", nSectionAlignment, nFileAlignment));
388 }
389 else
390 {
391 nSectionAlignment = PAGE_SIZE;
392 nFileAlignment = PAGE_SIZE;
393 }
394
395 ASSERT(IsPowerOf2(nSectionAlignment));
396 ASSERT(IsPowerOf2(nFileAlignment));
397
398 switch(piohOptHeader->Magic)
399 {
400 /* PE32 */
401 case IMAGE_NT_OPTIONAL_HDR32_MAGIC:
402 {
403 if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, ImageBase))
404 ImageBase = piohOptHeader->ImageBase;
405
406 if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfImage))
407 ImageSectionObject->ImageInformation.ImageFileSize = piohOptHeader->SizeOfImage;
408
409 if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfStackReserve))
410 ImageSectionObject->ImageInformation.MaximumStackSize = piohOptHeader->SizeOfStackReserve;
411
412 if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfStackCommit))
413 ImageSectionObject->ImageInformation.CommittedStackSize = piohOptHeader->SizeOfStackCommit;
414
415 if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, Subsystem))
416 {
417 ImageSectionObject->ImageInformation.SubSystemType = piohOptHeader->Subsystem;
418
419 if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, MinorSubsystemVersion) &&
420 RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, MajorSubsystemVersion))
421 {
422 ImageSectionObject->ImageInformation.SubSystemMinorVersion = piohOptHeader->MinorSubsystemVersion;
423 ImageSectionObject->ImageInformation.SubSystemMajorVersion = piohOptHeader->MajorSubsystemVersion;
424 }
425 }
426
427 if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, AddressOfEntryPoint))
428 {
429 ImageSectionObject->ImageInformation.TransferAddress = (PVOID) (ImageBase +
430 piohOptHeader->AddressOfEntryPoint);
431 }
432
433 if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfCode))
434 ImageSectionObject->ImageInformation.ImageContainsCode = piohOptHeader->SizeOfCode != 0;
435 else
436 ImageSectionObject->ImageInformation.ImageContainsCode = TRUE;
437
438 if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, AddressOfEntryPoint))
439 {
440 if (piohOptHeader->AddressOfEntryPoint == 0)
441 {
442 ImageSectionObject->ImageInformation.ImageContainsCode = FALSE;
443 }
444 }
445
446 if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, LoaderFlags))
447 ImageSectionObject->ImageInformation.LoaderFlags = piohOptHeader->LoaderFlags;
448
449 if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, DllCharacteristics))
450 {
451 ImageSectionObject->ImageInformation.DllCharacteristics = piohOptHeader->DllCharacteristics;
452
453 /*
454 * Since we don't really implement SxS yet and LD doesn't supoprt /ALLOWISOLATION:NO, hard-code
455 * this flag here, which will prevent the loader and other code from doing any .manifest or SxS
456 * magic to any binary.
457 *
458 * This will break applications that depend on SxS when running with real Windows Kernel32/SxS/etc
459 * but honestly that's not tested. It will also break them when running no ReactOS once we implement
460 * the SxS support -- at which point, duh, this should be removed.
461 *
462 * But right now, any app depending on SxS is already broken anyway, so this flag only helps.
463 */
464 ImageSectionObject->ImageInformation.DllCharacteristics |= IMAGE_DLLCHARACTERISTICS_NO_ISOLATION;
465 }
466
467 break;
468 }
469 #ifdef _WIN64
470 /* PE64 */
471 case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
472 {
473 const IMAGE_OPTIONAL_HEADER64 * pioh64OptHeader;
474
475 pioh64OptHeader = (const IMAGE_OPTIONAL_HEADER64 *)piohOptHeader;
476
477 if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, ImageBase))
478 {
479 ImageBase = pioh64OptHeader->ImageBase;
480 if(pioh64OptHeader->ImageBase > MAXULONG_PTR)
481 DIE(("ImageBase exceeds the address space\n"));
482 }
483
484 if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfImage))
485 {
486 if(pioh64OptHeader->SizeOfImage > MAXULONG_PTR)
487 DIE(("SizeOfImage exceeds the address space\n"));
488
489 ImageSectionObject->ImageInformation.ImageFileSize = pioh64OptHeader->SizeOfImage;
490 }
491
492 if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfStackReserve))
493 {
494 if(pioh64OptHeader->SizeOfStackReserve > MAXULONG_PTR)
495 DIE(("SizeOfStackReserve exceeds the address space\n"));
496
497 ImageSectionObject->ImageInformation.MaximumStackSize = (ULONG_PTR) pioh64OptHeader->SizeOfStackReserve;
498 }
499
500 if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfStackCommit))
501 {
502 if(pioh64OptHeader->SizeOfStackCommit > MAXULONG_PTR)
503 DIE(("SizeOfStackCommit exceeds the address space\n"));
504
505 ImageSectionObject->ImageInformation.CommittedStackSize = (ULONG_PTR) pioh64OptHeader->SizeOfStackCommit;
506 }
507
508 if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, Subsystem))
509 {
510 ImageSectionObject->ImageInformation.SubSystemType = pioh64OptHeader->Subsystem;
511
512 if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, MinorSubsystemVersion) &&
513 RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, MajorSubsystemVersion))
514 {
515 ImageSectionObject->ImageInformation.SubSystemMinorVersion = pioh64OptHeader->MinorSubsystemVersion;
516 ImageSectionObject->ImageInformation.SubSystemMajorVersion = pioh64OptHeader->MajorSubsystemVersion;
517 }
518 }
519
520 if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, AddressOfEntryPoint))
521 {
522 ImageSectionObject->ImageInformation.TransferAddress = (PVOID) (ImageBase +
523 pioh64OptHeader->AddressOfEntryPoint);
524 }
525
526 if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfCode))
527 ImageSectionObject->ImageInformation.ImageContainsCode = pioh64OptHeader->SizeOfCode != 0;
528 else
529 ImageSectionObject->ImageInformation.ImageContainsCode = TRUE;
530
531 if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, AddressOfEntryPoint))
532 {
533 if (pioh64OptHeader->AddressOfEntryPoint == 0)
534 {
535 ImageSectionObject->ImageInformation.ImageContainsCode = FALSE;
536 }
537 }
538
539 if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, LoaderFlags))
540 ImageSectionObject->ImageInformation.LoaderFlags = pioh64OptHeader->LoaderFlags;
541
542 if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, DllCharacteristics))
543 ImageSectionObject->ImageInformation.DllCharacteristics = pioh64OptHeader->DllCharacteristics;
544
545 break;
546 }
547 #endif // _WIN64
548 }
549
550 /* [1], section 3.4.2 */
551 if((ULONG_PTR)ImageBase % 0x10000)
552 DIE(("ImageBase is not aligned on a 64KB boundary"));
553
554 ImageSectionObject->ImageInformation.ImageCharacteristics = pinhNtHeader->FileHeader.Characteristics;
555 ImageSectionObject->ImageInformation.Machine = pinhNtHeader->FileHeader.Machine;
556 ImageSectionObject->ImageInformation.GpValue = 0;
557 ImageSectionObject->ImageInformation.ZeroBits = 0;
558 ImageSectionObject->BasedAddress = (PVOID)ImageBase;
559
560 /* SECTION HEADERS */
561 nStatus = STATUS_INVALID_IMAGE_FORMAT;
562
563 /* see [1], section 3.3 */
564 if(pinhNtHeader->FileHeader.NumberOfSections > 96)
565 DIE(("Too many sections, NumberOfSections is %u\n", pinhNtHeader->FileHeader.NumberOfSections));
566
567 /*
568 * the additional segment is for the file's headers. They need to be present for
569 * the benefit of the dynamic loader (to locate exports, defaults for thread
570 * parameters, resources, etc.)
571 */
572 ImageSectionObject->NrSegments = pinhNtHeader->FileHeader.NumberOfSections + 1;
573
574 /* file offset for the section headers */
575 if(!Intsafe_AddULong32(&cbSectionHeadersOffset, pidhDosHeader->e_lfanew, FIELD_OFFSET(IMAGE_NT_HEADERS32, OptionalHeader)))
576 DIE(("Offset overflow\n"));
577
578 if(!Intsafe_AddULong32(&cbSectionHeadersOffset, cbSectionHeadersOffset, pinhNtHeader->FileHeader.SizeOfOptionalHeader))
579 DIE(("Offset overflow\n"));
580
581 /* size of the section headers */
582 ASSERT(Intsafe_CanMulULong32(pinhNtHeader->FileHeader.NumberOfSections, sizeof(IMAGE_SECTION_HEADER)));
583 cbSectionHeadersSize = pinhNtHeader->FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
584
585 if(!Intsafe_AddULong32(&cbSectionHeadersOffsetSize, cbSectionHeadersOffset, cbSectionHeadersSize))
586 DIE(("Section headers too large\n"));
587
588 /* size of the executable's headers */
589 if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfHeaders))
590 {
591 // if(!IsAligned(piohOptHeader->SizeOfHeaders, nFileAlignment))
592 // DIE(("SizeOfHeaders is not aligned\n"));
593
594 if(cbSectionHeadersSize > piohOptHeader->SizeOfHeaders)
595 DIE(("The section headers overflow SizeOfHeaders\n"));
596
597 cbHeadersSize = piohOptHeader->SizeOfHeaders;
598 }
599 else if(!AlignUp(&cbHeadersSize, cbSectionHeadersOffsetSize, nFileAlignment))
600 DIE(("Overflow aligning the size of headers\n"));
601
602 if(pBuffer)
603 {
604 ExFreePool(pBuffer);
605 pBuffer = NULL;
606 }
607 /* WARNING: pinhNtHeader IS NO LONGER USABLE */
608 /* WARNING: piohOptHeader IS NO LONGER USABLE */
609 /* WARNING: pioh64OptHeader IS NO LONGER USABLE */
610
611 if(FileHeaderSize < cbSectionHeadersOffsetSize)
612 pishSectionHeaders = NULL;
613 else
614 {
615 /*
616 * we already know that Intsafe_CanOffsetPointer(FileHeader, FileHeaderSize),
617 * and FileHeaderSize >= cbSectionHeadersOffsetSize, so this holds true too
618 */
619 ASSERT(Intsafe_CanOffsetPointer(FileHeader, cbSectionHeadersOffset));
620 pishSectionHeaders = (PVOID)((UINT_PTR)FileHeader + cbSectionHeadersOffset);
621 }
622
623 /*
624 * the buffer doesn't contain the section headers, or the alignment is wrong:
625 * read the headers from the file
626 */
627 if(FileHeaderSize < cbSectionHeadersOffsetSize ||
628 (UINT_PTR)pishSectionHeaders % TYPE_ALIGNMENT(IMAGE_SECTION_HEADER) != 0)
629 {
630 PVOID pData;
631 ULONG cbReadSize;
632
633 lnOffset.QuadPart = cbSectionHeadersOffset;
634
635 /* read the header from the file */
636 nStatus = ReadFileCb(File, &lnOffset, cbSectionHeadersSize, &pData, &pBuffer, &cbReadSize);
637
638 if(!NT_SUCCESS(nStatus))
639 DIE(("ReadFile failed with status %08X\n", nStatus));
640
641 ASSERT(pData);
642 ASSERT(pBuffer);
643 ASSERT(cbReadSize > 0);
644
645 nStatus = STATUS_INVALID_IMAGE_FORMAT;
646
647 /* the buffer doesn't contain all the section headers */
648 if(cbReadSize < cbSectionHeadersSize)
649 DIE(("The file doesn't contain all of the section headers\n"));
650
651 pishSectionHeaders = pData;
652
653 /* object still not aligned: copy it to the beginning of the buffer */
654 if((UINT_PTR)pishSectionHeaders % TYPE_ALIGNMENT(IMAGE_SECTION_HEADER) != 0)
655 {
656 ASSERT((UINT_PTR)pBuffer % TYPE_ALIGNMENT(IMAGE_SECTION_HEADER) == 0);
657 RtlMoveMemory(pBuffer, pData, cbReadSize);
658 pishSectionHeaders = pBuffer;
659 }
660 }
661
662 /* SEGMENTS */
663 /* allocate the segments */
664 nStatus = STATUS_INSUFFICIENT_RESOURCES;
665 ImageSectionObject->Segments = AllocateSegmentsCb(ImageSectionObject->NrSegments);
666
667 if(ImageSectionObject->Segments == NULL)
668 DIE(("AllocateSegments failed\n"));
669
670 /* initialize the headers segment */
671 pssSegments = ImageSectionObject->Segments;
672
673 // ASSERT(IsAligned(cbHeadersSize, nFileAlignment));
674
675 if(!AlignUp(&nFileSizeOfHeaders, cbHeadersSize, nFileAlignment))
676 DIE(("Cannot align the size of the section headers\n"));
677
678 nPrevVirtualEndOfSegment = ALIGN_UP_BY(cbHeadersSize, nSectionAlignment);
679 if (nPrevVirtualEndOfSegment < cbHeadersSize)
680 DIE(("Cannot align the size of the section headers\n"));
681
682 pssSegments[0].Image.FileOffset = 0;
683 pssSegments[0].Protection = PAGE_READONLY;
684 pssSegments[0].Length.QuadPart = nPrevVirtualEndOfSegment;
685 pssSegments[0].RawLength.QuadPart = nFileSizeOfHeaders;
686 pssSegments[0].Image.VirtualAddress = 0;
687 pssSegments[0].Image.Characteristics = IMAGE_SCN_CNT_INITIALIZED_DATA;
688 pssSegments[0].WriteCopy = TRUE;
689
690 /* skip the headers segment */
691 ++ pssSegments;
692
693 nStatus = STATUS_INVALID_IMAGE_FORMAT;
694
695 /* convert the executable sections into segments. See also [1], section 4 */
696 for(i = 0; i < ImageSectionObject->NrSegments - 1; ++ i)
697 {
698 ULONG nCharacteristics;
699
700 /* validate the alignment */
701 if(!IsAligned(pishSectionHeaders[i].VirtualAddress, nSectionAlignment))
702 DIE(("Image.VirtualAddress[%u] is not aligned\n", i));
703
704 /* sections must be contiguous, ordered by base address and non-overlapping */
705 if(pishSectionHeaders[i].VirtualAddress != nPrevVirtualEndOfSegment)
706 DIE(("Memory gap between section %u and the previous\n", i));
707
708 /* ignore explicit BSS sections */
709 if(pishSectionHeaders[i].SizeOfRawData != 0)
710 {
711 /* validate the alignment */
712 #if 0
713 /* Yes, this should be a multiple of FileAlignment, but there's
714 * stuff out there that isn't. We can cope with that
715 */
716 if(!IsAligned(pishSectionHeaders[i].SizeOfRawData, nFileAlignment))
717 DIE(("SizeOfRawData[%u] is not aligned\n", i));
718 #endif
719
720 // if(!IsAligned(pishSectionHeaders[i].PointerToRawData, nFileAlignment))
721 // DIE(("PointerToRawData[%u] is not aligned\n", i));
722
723 /* conversion */
724 pssSegments[i].Image.FileOffset = pishSectionHeaders[i].PointerToRawData;
725 pssSegments[i].RawLength.QuadPart = pishSectionHeaders[i].SizeOfRawData;
726 }
727 else
728 {
729 ASSERT(pssSegments[i].Image.FileOffset == 0);
730 ASSERT(pssSegments[i].RawLength.QuadPart == 0);
731 }
732
733 ASSERT(Intsafe_CanAddLong64(pssSegments[i].Image.FileOffset, pssSegments[i].RawLength.QuadPart));
734
735 nCharacteristics = pishSectionHeaders[i].Characteristics;
736
737 /* no explicit protection */
738 if((nCharacteristics & (IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE)) == 0)
739 {
740 if(nCharacteristics & IMAGE_SCN_CNT_CODE)
741 nCharacteristics |= IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ;
742
743 if(nCharacteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
744 nCharacteristics |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
745
746 if(nCharacteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
747 nCharacteristics |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
748 }
749
750 /* see table above */
751 pssSegments[i].Protection = SectionCharacteristicsToProtect[nCharacteristics >> 28];
752 pssSegments[i].WriteCopy = !(nCharacteristics & IMAGE_SCN_MEM_SHARED);
753
754 if(pishSectionHeaders[i].Misc.VirtualSize == 0 || pishSectionHeaders[i].Misc.VirtualSize < pishSectionHeaders[i].SizeOfRawData)
755 pssSegments[i].Length.QuadPart = pishSectionHeaders[i].SizeOfRawData;
756 else
757 pssSegments[i].Length.QuadPart = pishSectionHeaders[i].Misc.VirtualSize;
758
759 AlignedLength = ALIGN_UP_BY(pssSegments[i].Length.LowPart, nSectionAlignment);
760 if(AlignedLength < pssSegments[i].Length.LowPart)
761 DIE(("Cannot align the virtual size of section %u\n", i));
762
763 pssSegments[i].Length.LowPart = AlignedLength;
764
765 if(pssSegments[i].Length.QuadPart == 0)
766 DIE(("Virtual size of section %u is null\n", i));
767
768 pssSegments[i].Image.VirtualAddress = pishSectionHeaders[i].VirtualAddress;
769 pssSegments[i].Image.Characteristics = pishSectionHeaders[i].Characteristics;
770
771 /* ensure the memory image is no larger than 4GB */
772 nPrevVirtualEndOfSegment = (ULONG_PTR)(pssSegments[i].Image.VirtualAddress + pssSegments[i].Length.QuadPart);
773 if (nPrevVirtualEndOfSegment < pssSegments[i].Image.VirtualAddress)
774 DIE(("The image is too large\n"));
775 }
776
777 if(nSectionAlignment >= PAGE_SIZE)
778 *Flags |= EXEFMT_LOAD_ASSUME_SEGMENTS_PAGE_ALIGNED;
779
780 /* Success */
781 nStatus = STATUS_SUCCESS;// STATUS_ROS_EXEFMT_LOADED_FORMAT | EXEFMT_LOADED_PE32;
782
783 l_Return:
784 if(pBuffer)
785 ExFreePool(pBuffer);
786
787 return nStatus;
788 }
789
790 /*
791 * FUNCTION: Waits in kernel mode indefinitely for a file object lock.
792 * ARGUMENTS: PFILE_OBJECT to wait for.
793 * RETURNS: Status of the wait.
794 */
795 NTSTATUS
796 MmspWaitForFileLock(PFILE_OBJECT File)
797 {
798 return STATUS_SUCCESS;
799 //return KeWaitForSingleObject(&File->Lock, 0, KernelMode, FALSE, NULL);
800 }
801
802 VOID
803 NTAPI
804 MmFreeSectionSegments(PFILE_OBJECT FileObject)
805 {
806 if (FileObject->SectionObjectPointer->ImageSectionObject != NULL)
807 {
808 PMM_IMAGE_SECTION_OBJECT ImageSectionObject;
809 PMM_SECTION_SEGMENT SectionSegments;
810 ULONG NrSegments;
811 ULONG i;
812
813 ImageSectionObject = (PMM_IMAGE_SECTION_OBJECT)FileObject->SectionObjectPointer->ImageSectionObject;
814 NrSegments = ImageSectionObject->NrSegments;
815 SectionSegments = ImageSectionObject->Segments;
816 for (i = 0; i < NrSegments; i++)
817 {
818 if (SectionSegments[i].ReferenceCount != 0)
819 {
820 DPRINT1("Image segment %lu still referenced (was %lu)\n", i,
821 SectionSegments[i].ReferenceCount);
822 KeBugCheck(MEMORY_MANAGEMENT);
823 }
824 MmFreePageTablesSectionSegment(&SectionSegments[i], NULL);
825 }
826 ExFreePool(ImageSectionObject->Segments);
827 ExFreePool(ImageSectionObject);
828 FileObject->SectionObjectPointer->ImageSectionObject = NULL;
829 }
830 if (FileObject->SectionObjectPointer->DataSectionObject != NULL)
831 {
832 PMM_SECTION_SEGMENT Segment;
833
834 Segment = (PMM_SECTION_SEGMENT)FileObject->SectionObjectPointer->
835 DataSectionObject;
836
837 if (Segment->ReferenceCount != 0)
838 {
839 DPRINT1("Data segment still referenced\n");
840 KeBugCheck(MEMORY_MANAGEMENT);
841 }
842 MmFreePageTablesSectionSegment(Segment, NULL);
843 ExFreePool(Segment);
844 FileObject->SectionObjectPointer->DataSectionObject = NULL;
845 }
846 }
847
848 VOID
849 NTAPI
850 MmSharePageEntrySectionSegment(PMM_SECTION_SEGMENT Segment,
851 PLARGE_INTEGER Offset)
852 {
853 ULONG_PTR Entry;
854
855 Entry = MmGetPageEntrySectionSegment(Segment, Offset);
856 if (Entry == 0)
857 {
858 DPRINT1("Entry == 0 for MmSharePageEntrySectionSegment\n");
859 KeBugCheck(MEMORY_MANAGEMENT);
860 }
861 if (SHARE_COUNT_FROM_SSE(Entry) == MAX_SHARE_COUNT)
862 {
863 DPRINT1("Maximum share count reached\n");
864 KeBugCheck(MEMORY_MANAGEMENT);
865 }
866 if (IS_SWAP_FROM_SSE(Entry))
867 {
868 KeBugCheck(MEMORY_MANAGEMENT);
869 }
870 Entry = MAKE_SSE(PAGE_FROM_SSE(Entry), SHARE_COUNT_FROM_SSE(Entry) + 1);
871 MmSetPageEntrySectionSegment(Segment, Offset, Entry);
872 }
873
874 BOOLEAN
875 NTAPI
876 MmUnsharePageEntrySectionSegment(PROS_SECTION_OBJECT Section,
877 PMM_SECTION_SEGMENT Segment,
878 PLARGE_INTEGER Offset,
879 BOOLEAN Dirty,
880 BOOLEAN PageOut,
881 ULONG_PTR *InEntry)
882 {
883 ULONG_PTR Entry = InEntry ? *InEntry : MmGetPageEntrySectionSegment(Segment, Offset);
884 BOOLEAN IsDirectMapped = FALSE;
885
886 if (Entry == 0)
887 {
888 DPRINT1("Entry == 0 for MmUnsharePageEntrySectionSegment\n");
889 KeBugCheck(MEMORY_MANAGEMENT);
890 }
891 if (SHARE_COUNT_FROM_SSE(Entry) == 0)
892 {
893 DPRINT1("Zero share count for unshare (Seg %p Offset %x Page %x)\n", Segment, Offset->LowPart, PFN_FROM_SSE(Entry));
894 KeBugCheck(MEMORY_MANAGEMENT);
895 }
896 if (IS_SWAP_FROM_SSE(Entry))
897 {
898 KeBugCheck(MEMORY_MANAGEMENT);
899 }
900 Entry = MAKE_SSE(PAGE_FROM_SSE(Entry), SHARE_COUNT_FROM_SSE(Entry) - 1);
901 /*
902 * If we reducing the share count of this entry to zero then set the entry
903 * to zero and tell the cache the page is no longer mapped.
904 */
905 if (SHARE_COUNT_FROM_SSE(Entry) == 0)
906 {
907 PFILE_OBJECT FileObject;
908 SWAPENTRY SavedSwapEntry;
909 PFN_NUMBER Page;
910 #ifndef NEWCC
911 PROS_SHARED_CACHE_MAP SharedCacheMap;
912 BOOLEAN IsImageSection;
913 LARGE_INTEGER FileOffset;
914
915 FileOffset.QuadPart = Offset->QuadPart + Segment->Image.FileOffset;
916 IsImageSection = Section->AllocationAttributes & SEC_IMAGE ? TRUE : FALSE;
917 #endif
918
919 Page = PFN_FROM_SSE(Entry);
920 FileObject = Section->FileObject;
921 if (FileObject != NULL &&
922 !(Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
923 {
924
925 #ifndef NEWCC
926 if ((FileOffset.QuadPart % PAGE_SIZE) == 0 &&
927 (Offset->QuadPart + PAGE_SIZE <= Segment->RawLength.QuadPart || !IsImageSection))
928 {
929 NTSTATUS Status;
930 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
931 IsDirectMapped = TRUE;
932 #ifndef NEWCC
933 Status = CcRosUnmapVacb(SharedCacheMap, FileOffset.QuadPart, Dirty);
934 #else
935 Status = STATUS_SUCCESS;
936 #endif
937 if (!NT_SUCCESS(Status))
938 {
939 DPRINT1("CcRosUnmapVacb failed, status = %x\n", Status);
940 KeBugCheck(MEMORY_MANAGEMENT);
941 }
942 }
943 #endif
944 }
945
946 SavedSwapEntry = MmGetSavedSwapEntryPage(Page);
947 if (SavedSwapEntry == 0)
948 {
949 if (!PageOut &&
950 ((Segment->Flags & MM_PAGEFILE_SEGMENT) ||
951 (Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED)))
952 {
953 /*
954 * FIXME:
955 * Try to page out this page and set the swap entry
956 * within the section segment. There exist no rmap entry
957 * for this page. The pager thread can't page out a
958 * page without a rmap entry.
959 */
960 MmSetPageEntrySectionSegment(Segment, Offset, Entry);
961 if (InEntry) *InEntry = Entry;
962 MiSetPageEvent(NULL, NULL);
963 }
964 else
965 {
966 MmSetPageEntrySectionSegment(Segment, Offset, 0);
967 if (InEntry) *InEntry = 0;
968 MiSetPageEvent(NULL, NULL);
969 if (!IsDirectMapped)
970 {
971 MmReleasePageMemoryConsumer(MC_USER, Page);
972 }
973 }
974 }
975 else
976 {
977 if ((Segment->Flags & MM_PAGEFILE_SEGMENT) ||
978 (Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
979 {
980 if (!PageOut)
981 {
982 if (Dirty)
983 {
984 /*
985 * FIXME:
986 * We hold all locks. Nobody can do something with the current
987 * process and the current segment (also not within an other process).
988 */
989 NTSTATUS Status;
990 Status = MmWriteToSwapPage(SavedSwapEntry, Page);
991 if (!NT_SUCCESS(Status))
992 {
993 DPRINT1("MM: Failed to write to swap page (Status was 0x%.8X)\n", Status);
994 KeBugCheck(MEMORY_MANAGEMENT);
995 }
996 }
997 MmSetPageEntrySectionSegment(Segment, Offset, MAKE_SWAP_SSE(SavedSwapEntry));
998 if (InEntry) *InEntry = MAKE_SWAP_SSE(SavedSwapEntry);
999 MmSetSavedSwapEntryPage(Page, 0);
1000 MiSetPageEvent(NULL, NULL);
1001 }
1002 MmReleasePageMemoryConsumer(MC_USER, Page);
1003 }
1004 else
1005 {
1006 DPRINT1("Found a swapentry for a non private page in an image or data file sgment\n");
1007 KeBugCheck(MEMORY_MANAGEMENT);
1008 }
1009 }
1010 }
1011 else
1012 {
1013 if (InEntry)
1014 *InEntry = Entry;
1015 else
1016 MmSetPageEntrySectionSegment(Segment, Offset, Entry);
1017 }
1018 return(SHARE_COUNT_FROM_SSE(Entry) > 0);
1019 }
1020
1021 BOOLEAN MiIsPageFromCache(PMEMORY_AREA MemoryArea,
1022 LONGLONG SegOffset)
1023 {
1024 #ifndef NEWCC
1025 if (!(MemoryArea->Data.SectionData.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
1026 {
1027 PROS_SHARED_CACHE_MAP SharedCacheMap;
1028 PROS_VACB Vacb;
1029 SharedCacheMap = MemoryArea->Data.SectionData.Section->FileObject->SectionObjectPointer->SharedCacheMap;
1030 Vacb = CcRosLookupVacb(SharedCacheMap, SegOffset + MemoryArea->Data.SectionData.Segment->Image.FileOffset);
1031 if (Vacb)
1032 {
1033 CcRosReleaseVacb(SharedCacheMap, Vacb, Vacb->Valid, FALSE, TRUE);
1034 return TRUE;
1035 }
1036 }
1037 #endif
1038 return FALSE;
1039 }
1040
1041 NTSTATUS
1042 NTAPI
1043 MiCopyFromUserPage(PFN_NUMBER DestPage, const VOID *SrcAddress)
1044 {
1045 PEPROCESS Process;
1046 KIRQL Irql;
1047 PVOID DestAddress;
1048
1049 Process = PsGetCurrentProcess();
1050 DestAddress = MiMapPageInHyperSpace(Process, DestPage, &Irql);
1051 if (DestAddress == NULL)
1052 {
1053 return(STATUS_NO_MEMORY);
1054 }
1055 ASSERT((ULONG_PTR)DestAddress % PAGE_SIZE == 0);
1056 ASSERT((ULONG_PTR)SrcAddress % PAGE_SIZE == 0);
1057 RtlCopyMemory(DestAddress, SrcAddress, PAGE_SIZE);
1058 MiUnmapPageInHyperSpace(Process, DestAddress, Irql);
1059 return(STATUS_SUCCESS);
1060 }
1061
1062 #ifndef NEWCC
1063 NTSTATUS
1064 NTAPI
1065 MiReadPage(PMEMORY_AREA MemoryArea,
1066 LONGLONG SegOffset,
1067 PPFN_NUMBER Page)
1068 /*
1069 * FUNCTION: Read a page for a section backed memory area.
1070 * PARAMETERS:
1071 * MemoryArea - Memory area to read the page for.
1072 * Offset - Offset of the page to read.
1073 * Page - Variable that receives a page contains the read data.
1074 */
1075 {
1076 LONGLONG BaseOffset;
1077 LONGLONG FileOffset;
1078 PVOID BaseAddress;
1079 BOOLEAN UptoDate;
1080 PROS_VACB Vacb;
1081 PFILE_OBJECT FileObject;
1082 NTSTATUS Status;
1083 LONGLONG RawLength;
1084 PROS_SHARED_CACHE_MAP SharedCacheMap;
1085 BOOLEAN IsImageSection;
1086 LONGLONG Length;
1087
1088 FileObject = MemoryArea->Data.SectionData.Section->FileObject;
1089 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1090 RawLength = MemoryArea->Data.SectionData.Segment->RawLength.QuadPart;
1091 FileOffset = SegOffset + MemoryArea->Data.SectionData.Segment->Image.FileOffset;
1092 IsImageSection = MemoryArea->Data.SectionData.Section->AllocationAttributes & SEC_IMAGE ? TRUE : FALSE;
1093
1094 ASSERT(SharedCacheMap);
1095
1096 DPRINT("%S %I64x\n", FileObject->FileName.Buffer, FileOffset);
1097
1098 /*
1099 * If the file system is letting us go directly to the cache and the
1100 * memory area was mapped at an offset in the file which is page aligned
1101 * then get the related VACB.
1102 */
1103 if (((FileOffset % PAGE_SIZE) == 0) &&
1104 ((SegOffset + PAGE_SIZE <= RawLength) || !IsImageSection) &&
1105 !(MemoryArea->Data.SectionData.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
1106 {
1107
1108 /*
1109 * Get the related VACB; we use a lower level interface than
1110 * filesystems do because it is safe for us to use an offset with an
1111 * alignment less than the file system block size.
1112 */
1113 Status = CcRosGetVacb(SharedCacheMap,
1114 FileOffset,
1115 &BaseOffset,
1116 &BaseAddress,
1117 &UptoDate,
1118 &Vacb);
1119 if (!NT_SUCCESS(Status))
1120 {
1121 return(Status);
1122 }
1123 if (!UptoDate)
1124 {
1125 /*
1126 * If the VACB isn't up to date then call the file
1127 * system to read in the data.
1128 */
1129 Status = CcReadVirtualAddress(Vacb);
1130 if (!NT_SUCCESS(Status))
1131 {
1132 CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
1133 return Status;
1134 }
1135 }
1136
1137 /* Probe the page, since it's PDE might not be synced */
1138 (void)*((volatile char*)BaseAddress + FileOffset - BaseOffset);
1139
1140 /*
1141 * Retrieve the page from the view that we actually want.
1142 */
1143 (*Page) = MmGetPhysicalAddress((char*)BaseAddress +
1144 FileOffset - BaseOffset).LowPart >> PAGE_SHIFT;
1145
1146 CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, TRUE);
1147 }
1148 else
1149 {
1150 PEPROCESS Process;
1151 KIRQL Irql;
1152 PVOID PageAddr;
1153 LONGLONG VacbOffset;
1154
1155 /*
1156 * Allocate a page, this is rather complicated by the possibility
1157 * we might have to move other things out of memory
1158 */
1159 MI_SET_USAGE(MI_USAGE_SECTION);
1160 MI_SET_PROCESS2(PsGetCurrentProcess()->ImageFileName);
1161 Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, Page);
1162 if (!NT_SUCCESS(Status))
1163 {
1164 return(Status);
1165 }
1166 Status = CcRosGetVacb(SharedCacheMap,
1167 FileOffset,
1168 &BaseOffset,
1169 &BaseAddress,
1170 &UptoDate,
1171 &Vacb);
1172 if (!NT_SUCCESS(Status))
1173 {
1174 return(Status);
1175 }
1176 if (!UptoDate)
1177 {
1178 /*
1179 * If the VACB isn't up to date then call the file
1180 * system to read in the data.
1181 */
1182 Status = CcReadVirtualAddress(Vacb);
1183 if (!NT_SUCCESS(Status))
1184 {
1185 CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
1186 return Status;
1187 }
1188 }
1189
1190 Process = PsGetCurrentProcess();
1191 PageAddr = MiMapPageInHyperSpace(Process, *Page, &Irql);
1192 VacbOffset = BaseOffset + VACB_MAPPING_GRANULARITY - FileOffset;
1193 Length = RawLength - SegOffset;
1194 if (Length <= VacbOffset && Length <= PAGE_SIZE)
1195 {
1196 memcpy(PageAddr, (char*)BaseAddress + FileOffset - BaseOffset, Length);
1197 }
1198 else if (VacbOffset >= PAGE_SIZE)
1199 {
1200 memcpy(PageAddr, (char*)BaseAddress + FileOffset - BaseOffset, PAGE_SIZE);
1201 }
1202 else
1203 {
1204 memcpy(PageAddr, (char*)BaseAddress + FileOffset - BaseOffset, VacbOffset);
1205 MiUnmapPageInHyperSpace(Process, PageAddr, Irql);
1206 CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
1207 Status = CcRosGetVacb(SharedCacheMap,
1208 FileOffset + VacbOffset,
1209 &BaseOffset,
1210 &BaseAddress,
1211 &UptoDate,
1212 &Vacb);
1213 if (!NT_SUCCESS(Status))
1214 {
1215 return(Status);
1216 }
1217 if (!UptoDate)
1218 {
1219 /*
1220 * If the VACB isn't up to date then call the file
1221 * system to read in the data.
1222 */
1223 Status = CcReadVirtualAddress(Vacb);
1224 if (!NT_SUCCESS(Status))
1225 {
1226 CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
1227 return Status;
1228 }
1229 }
1230 PageAddr = MiMapPageInHyperSpace(Process, *Page, &Irql);
1231 if (Length < PAGE_SIZE)
1232 {
1233 memcpy((char*)PageAddr + VacbOffset, BaseAddress, Length - VacbOffset);
1234 }
1235 else
1236 {
1237 memcpy((char*)PageAddr + VacbOffset, BaseAddress, PAGE_SIZE - VacbOffset);
1238 }
1239 }
1240 MiUnmapPageInHyperSpace(Process, PageAddr, Irql);
1241 CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
1242 }
1243 return(STATUS_SUCCESS);
1244 }
1245 #else
1246 NTSTATUS
1247 NTAPI
1248 MiReadPage(PMEMORY_AREA MemoryArea,
1249 LONGLONG SegOffset,
1250 PPFN_NUMBER Page)
1251 /*
1252 * FUNCTION: Read a page for a section backed memory area.
1253 * PARAMETERS:
1254 * MemoryArea - Memory area to read the page for.
1255 * Offset - Offset of the page to read.
1256 * Page - Variable that receives a page contains the read data.
1257 */
1258 {
1259 MM_REQUIRED_RESOURCES Resources;
1260 NTSTATUS Status;
1261
1262 RtlZeroMemory(&Resources, sizeof(MM_REQUIRED_RESOURCES));
1263
1264 Resources.Context = MemoryArea->Data.SectionData.Section->FileObject;
1265 Resources.FileOffset.QuadPart = SegOffset +
1266 MemoryArea->Data.SectionData.Segment->Image.FileOffset;
1267 Resources.Consumer = MC_USER;
1268 Resources.Amount = PAGE_SIZE;
1269
1270 DPRINT("%S, offset 0x%x, len 0x%x, page 0x%x\n", ((PFILE_OBJECT)Resources.Context)->FileName.Buffer, Resources.FileOffset.LowPart, Resources.Amount, Resources.Page[0]);
1271
1272 Status = MiReadFilePage(MmGetKernelAddressSpace(), MemoryArea, &Resources);
1273 *Page = Resources.Page[0];
1274 return Status;
1275 }
1276 #endif
1277
1278 NTSTATUS
1279 NTAPI
1280 MmNotPresentFaultSectionView(PMMSUPPORT AddressSpace,
1281 MEMORY_AREA* MemoryArea,
1282 PVOID Address,
1283 BOOLEAN Locked)
1284 {
1285 LARGE_INTEGER Offset;
1286 PFN_NUMBER Page;
1287 NTSTATUS Status;
1288 PROS_SECTION_OBJECT Section;
1289 PMM_SECTION_SEGMENT Segment;
1290 ULONG_PTR Entry;
1291 ULONG_PTR Entry1;
1292 ULONG Attributes;
1293 PMM_REGION Region;
1294 BOOLEAN HasSwapEntry;
1295 PVOID PAddress;
1296 PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
1297 SWAPENTRY SwapEntry;
1298
1299 /*
1300 * There is a window between taking the page fault and locking the
1301 * address space when another thread could load the page so we check
1302 * that.
1303 */
1304 if (MmIsPagePresent(Process, Address))
1305 {
1306 return(STATUS_SUCCESS);
1307 }
1308
1309 if (MmIsDisabledPage(Process, Address))
1310 {
1311 return(STATUS_ACCESS_VIOLATION);
1312 }
1313
1314 /*
1315 * Check for the virtual memory area being deleted.
1316 */
1317 if (MemoryArea->DeleteInProgress)
1318 {
1319 return(STATUS_UNSUCCESSFUL);
1320 }
1321
1322 PAddress = MM_ROUND_DOWN(Address, PAGE_SIZE);
1323 Offset.QuadPart = (ULONG_PTR)PAddress - MA_GetStartingAddress(MemoryArea)
1324 + MemoryArea->Data.SectionData.ViewOffset.QuadPart;
1325
1326 Segment = MemoryArea->Data.SectionData.Segment;
1327 Section = MemoryArea->Data.SectionData.Section;
1328 Region = MmFindRegion((PVOID)MA_GetStartingAddress(MemoryArea),
1329 &MemoryArea->Data.SectionData.RegionListHead,
1330 Address, NULL);
1331 ASSERT(Region != NULL);
1332 /*
1333 * Lock the segment
1334 */
1335 MmLockSectionSegment(Segment);
1336 Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
1337 /*
1338 * Check if this page needs to be mapped COW
1339 */
1340 if ((Segment->WriteCopy) &&
1341 (Region->Protect == PAGE_READWRITE ||
1342 Region->Protect == PAGE_EXECUTE_READWRITE))
1343 {
1344 Attributes = Region->Protect == PAGE_READWRITE ? PAGE_READONLY : PAGE_EXECUTE_READ;
1345 }
1346 else
1347 {
1348 Attributes = Region->Protect;
1349 }
1350
1351 /*
1352 * Check if someone else is already handling this fault, if so wait
1353 * for them
1354 */
1355 if (Entry && MM_IS_WAIT_PTE(Entry))
1356 {
1357 MmUnlockSectionSegment(Segment);
1358 MmUnlockAddressSpace(AddressSpace);
1359 MiWaitForPageEvent(NULL, NULL);
1360 MmLockAddressSpace(AddressSpace);
1361 DPRINT("Address 0x%p\n", Address);
1362 return(STATUS_MM_RESTART_OPERATION);
1363 }
1364
1365 HasSwapEntry = MmIsPageSwapEntry(Process, Address);
1366
1367 /* See if we should use a private page */
1368 if ((HasSwapEntry) || (Segment->Image.Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA))
1369 {
1370 SWAPENTRY DummyEntry;
1371
1372 /*
1373 * Is it a wait entry?
1374 */
1375 if (HasSwapEntry)
1376 {
1377 MmGetPageFileMapping(Process, Address, &SwapEntry);
1378
1379 if (SwapEntry == MM_WAIT_ENTRY)
1380 {
1381 MmUnlockSectionSegment(Segment);
1382 MmUnlockAddressSpace(AddressSpace);
1383 MiWaitForPageEvent(NULL, NULL);
1384 MmLockAddressSpace(AddressSpace);
1385 return STATUS_MM_RESTART_OPERATION;
1386 }
1387
1388 /*
1389 * Must be private page we have swapped out.
1390 */
1391
1392 /*
1393 * Sanity check
1394 */
1395 if (Segment->Flags & MM_PAGEFILE_SEGMENT)
1396 {
1397 DPRINT1("Found a swaped out private page in a pagefile section.\n");
1398 KeBugCheck(MEMORY_MANAGEMENT);
1399 }
1400 MmDeletePageFileMapping(Process, Address, &SwapEntry);
1401 }
1402
1403 MmUnlockSectionSegment(Segment);
1404
1405 /* Tell everyone else we are serving the fault. */
1406 MmCreatePageFileMapping(Process, Address, MM_WAIT_ENTRY);
1407
1408 MmUnlockAddressSpace(AddressSpace);
1409 MI_SET_USAGE(MI_USAGE_SECTION);
1410 if (Process) MI_SET_PROCESS2(Process->ImageFileName);
1411 if (!Process) MI_SET_PROCESS2("Kernel Section");
1412 Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
1413 if (!NT_SUCCESS(Status))
1414 {
1415 KeBugCheck(MEMORY_MANAGEMENT);
1416 }
1417
1418 if (HasSwapEntry)
1419 {
1420 Status = MmReadFromSwapPage(SwapEntry, Page);
1421 if (!NT_SUCCESS(Status))
1422 {
1423 DPRINT1("MmReadFromSwapPage failed, status = %x\n", Status);
1424 KeBugCheck(MEMORY_MANAGEMENT);
1425 }
1426 }
1427
1428 MmLockAddressSpace(AddressSpace);
1429 MmDeletePageFileMapping(Process, PAddress, &DummyEntry);
1430 Status = MmCreateVirtualMapping(Process,
1431 PAddress,
1432 Region->Protect,
1433 &Page,
1434 1);
1435 if (!NT_SUCCESS(Status))
1436 {
1437 DPRINT("MmCreateVirtualMapping failed, not out of memory\n");
1438 KeBugCheck(MEMORY_MANAGEMENT);
1439 return(Status);
1440 }
1441
1442 /*
1443 * Store the swap entry for later use.
1444 */
1445 if (HasSwapEntry)
1446 MmSetSavedSwapEntryPage(Page, SwapEntry);
1447
1448 /*
1449 * Add the page to the process's working set
1450 */
1451 MmInsertRmap(Page, Process, Address);
1452 /*
1453 * Finish the operation
1454 */
1455 MiSetPageEvent(Process, Address);
1456 DPRINT("Address 0x%p\n", Address);
1457 return(STATUS_SUCCESS);
1458 }
1459
1460 /*
1461 * Satisfying a page fault on a map of /Device/PhysicalMemory is easy
1462 */
1463 if (Section->AllocationAttributes & SEC_PHYSICALMEMORY)
1464 {
1465 MmUnlockSectionSegment(Segment);
1466 /*
1467 * Just map the desired physical page
1468 */
1469 Page = (PFN_NUMBER)(Offset.QuadPart >> PAGE_SHIFT);
1470 Status = MmCreateVirtualMappingUnsafe(Process,
1471 PAddress,
1472 Region->Protect,
1473 &Page,
1474 1);
1475 if (!NT_SUCCESS(Status))
1476 {
1477 DPRINT("MmCreateVirtualMappingUnsafe failed, not out of memory\n");
1478 KeBugCheck(MEMORY_MANAGEMENT);
1479 return(Status);
1480 }
1481
1482 /*
1483 * Cleanup and release locks
1484 */
1485 MiSetPageEvent(Process, Address);
1486 DPRINT("Address 0x%p\n", Address);
1487 return(STATUS_SUCCESS);
1488 }
1489
1490 /*
1491 * Get the entry corresponding to the offset within the section
1492 */
1493 Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
1494
1495 if (Entry == 0)
1496 {
1497 SWAPENTRY FakeSwapEntry;
1498
1499 /*
1500 * If the entry is zero (and it can't change because we have
1501 * locked the segment) then we need to load the page.
1502 */
1503
1504 /*
1505 * Release all our locks and read in the page from disk
1506 */
1507 MmSetPageEntrySectionSegment(Segment, &Offset, MAKE_SWAP_SSE(MM_WAIT_ENTRY));
1508 MmUnlockSectionSegment(Segment);
1509 MmCreatePageFileMapping(Process, PAddress, MM_WAIT_ENTRY);
1510 MmUnlockAddressSpace(AddressSpace);
1511
1512 if ((Segment->Flags & MM_PAGEFILE_SEGMENT) ||
1513 ((Offset.QuadPart >= (LONGLONG)PAGE_ROUND_UP(Segment->RawLength.QuadPart) &&
1514 (Section->AllocationAttributes & SEC_IMAGE))))
1515 {
1516 MI_SET_USAGE(MI_USAGE_SECTION);
1517 if (Process) MI_SET_PROCESS2(Process->ImageFileName);
1518 if (!Process) MI_SET_PROCESS2("Kernel Section");
1519 Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
1520 if (!NT_SUCCESS(Status))
1521 {
1522 DPRINT1("MmRequestPageMemoryConsumer failed (Status %x)\n", Status);
1523 }
1524
1525 }
1526 else
1527 {
1528 Status = MiReadPage(MemoryArea, Offset.QuadPart, &Page);
1529 if (!NT_SUCCESS(Status))
1530 {
1531 DPRINT1("MiReadPage failed (Status %x)\n", Status);
1532 }
1533 }
1534 if (!NT_SUCCESS(Status))
1535 {
1536 /*
1537 * FIXME: What do we know in this case?
1538 */
1539 /*
1540 * Cleanup and release locks
1541 */
1542 MmLockAddressSpace(AddressSpace);
1543 MiSetPageEvent(Process, Address);
1544 DPRINT("Address 0x%p\n", Address);
1545 return(Status);
1546 }
1547
1548 /* Lock both segment and process address space while we proceed. */
1549 MmLockAddressSpace(AddressSpace);
1550 MmLockSectionSegment(Segment);
1551
1552 MmDeletePageFileMapping(Process, PAddress, &FakeSwapEntry);
1553 DPRINT("CreateVirtualMapping Page %x Process %p PAddress %p Attributes %x\n",
1554 Page, Process, PAddress, Attributes);
1555 Status = MmCreateVirtualMapping(Process,
1556 PAddress,
1557 Attributes,
1558 &Page,
1559 1);
1560 if (!NT_SUCCESS(Status))
1561 {
1562 DPRINT1("Unable to create virtual mapping\n");
1563 KeBugCheck(MEMORY_MANAGEMENT);
1564 }
1565 ASSERT(MmIsPagePresent(Process, PAddress));
1566 MmInsertRmap(Page, Process, Address);
1567
1568 /* Set this section offset has being backed by our new page. */
1569 Entry = MAKE_SSE(Page << PAGE_SHIFT, 1);
1570 MmSetPageEntrySectionSegment(Segment, &Offset, Entry);
1571 MmUnlockSectionSegment(Segment);
1572
1573 MiSetPageEvent(Process, Address);
1574 DPRINT("Address 0x%p\n", Address);
1575 return(STATUS_SUCCESS);
1576 }
1577 else if (IS_SWAP_FROM_SSE(Entry))
1578 {
1579 SWAPENTRY SwapEntry;
1580
1581 SwapEntry = SWAPENTRY_FROM_SSE(Entry);
1582
1583 /* See if a page op is running on this segment. */
1584 if (SwapEntry == MM_WAIT_ENTRY)
1585 {
1586 MmUnlockSectionSegment(Segment);
1587 MmUnlockAddressSpace(AddressSpace);
1588 MiWaitForPageEvent(NULL, NULL);
1589 MmLockAddressSpace(AddressSpace);
1590 return STATUS_MM_RESTART_OPERATION;
1591 }
1592
1593 /*
1594 * Release all our locks and read in the page from disk
1595 */
1596 MmUnlockSectionSegment(Segment);
1597
1598 MmUnlockAddressSpace(AddressSpace);
1599 MI_SET_USAGE(MI_USAGE_SECTION);
1600 if (Process) MI_SET_PROCESS2(Process->ImageFileName);
1601 if (!Process) MI_SET_PROCESS2("Kernel Section");
1602 Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
1603 if (!NT_SUCCESS(Status))
1604 {
1605 KeBugCheck(MEMORY_MANAGEMENT);
1606 }
1607
1608 Status = MmReadFromSwapPage(SwapEntry, Page);
1609 if (!NT_SUCCESS(Status))
1610 {
1611 KeBugCheck(MEMORY_MANAGEMENT);
1612 }
1613
1614 /*
1615 * Relock the address space and segment
1616 */
1617 MmLockAddressSpace(AddressSpace);
1618 MmLockSectionSegment(Segment);
1619
1620 /*
1621 * Check the entry. No one should change the status of a page
1622 * that has a pending page-in.
1623 */
1624 Entry1 = MmGetPageEntrySectionSegment(Segment, &Offset);
1625 if (Entry != Entry1)
1626 {
1627 DPRINT1("Someone changed ppte entry while we slept (%x vs %x)\n", Entry, Entry1);
1628 KeBugCheck(MEMORY_MANAGEMENT);
1629 }
1630
1631 /*
1632 * Save the swap entry.
1633 */
1634 MmSetSavedSwapEntryPage(Page, SwapEntry);
1635
1636 /* Map the page into the process address space */
1637 Status = MmCreateVirtualMapping(Process,
1638 PAddress,
1639 Region->Protect,
1640 &Page,
1641 1);
1642 if (!NT_SUCCESS(Status))
1643 {
1644 DPRINT1("Unable to create virtual mapping\n");
1645 KeBugCheck(MEMORY_MANAGEMENT);
1646 }
1647 MmInsertRmap(Page, Process, Address);
1648
1649 /*
1650 * Mark the offset within the section as having valid, in-memory
1651 * data
1652 */
1653 Entry = MAKE_SSE(Page << PAGE_SHIFT, 1);
1654 MmSetPageEntrySectionSegment(Segment, &Offset, Entry);
1655 MmUnlockSectionSegment(Segment);
1656
1657 MiSetPageEvent(Process, Address);
1658 DPRINT("Address 0x%p\n", Address);
1659 return(STATUS_SUCCESS);
1660 }
1661 else
1662 {
1663 /* We already have a page on this section offset. Map it into the process address space. */
1664 Page = PFN_FROM_SSE(Entry);
1665
1666 Status = MmCreateVirtualMapping(Process,
1667 PAddress,
1668 Attributes,
1669 &Page,
1670 1);
1671 if (!NT_SUCCESS(Status))
1672 {
1673 DPRINT1("Unable to create virtual mapping\n");
1674 KeBugCheck(MEMORY_MANAGEMENT);
1675 }
1676 MmInsertRmap(Page, Process, Address);
1677
1678 /* Take a reference on it */
1679 MmSharePageEntrySectionSegment(Segment, &Offset);
1680 MmUnlockSectionSegment(Segment);
1681
1682 MiSetPageEvent(Process, Address);
1683 DPRINT("Address 0x%p\n", Address);
1684 return(STATUS_SUCCESS);
1685 }
1686 }
1687
1688 NTSTATUS
1689 NTAPI
1690 MmAccessFaultSectionView(PMMSUPPORT AddressSpace,
1691 MEMORY_AREA* MemoryArea,
1692 PVOID Address)
1693 {
1694 PMM_SECTION_SEGMENT Segment;
1695 PROS_SECTION_OBJECT Section;
1696 PFN_NUMBER OldPage;
1697 PFN_NUMBER NewPage;
1698 NTSTATUS Status;
1699 PVOID PAddress;
1700 LARGE_INTEGER Offset;
1701 PMM_REGION Region;
1702 ULONG_PTR Entry;
1703 PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
1704
1705 DPRINT("MmAccessFaultSectionView(%p, %p, %p)\n", AddressSpace, MemoryArea, Address);
1706
1707 /* Make sure we have a page mapping for this address. */
1708 Status = MmNotPresentFaultSectionView(AddressSpace, MemoryArea, Address, TRUE);
1709 if (!NT_SUCCESS(Status))
1710 {
1711 /* This is invalid access ! */
1712 return Status;
1713 }
1714
1715 /*
1716 * Check if the page has already been set readwrite
1717 */
1718 if (MmGetPageProtect(Process, Address) & PAGE_READWRITE)
1719 {
1720 DPRINT("Address 0x%p\n", Address);
1721 return(STATUS_SUCCESS);
1722 }
1723
1724 /*
1725 * Find the offset of the page
1726 */
1727 PAddress = MM_ROUND_DOWN(Address, PAGE_SIZE);
1728 Offset.QuadPart = (ULONG_PTR)PAddress - MA_GetStartingAddress(MemoryArea)
1729 + MemoryArea->Data.SectionData.ViewOffset.QuadPart;
1730
1731 Segment = MemoryArea->Data.SectionData.Segment;
1732 Section = MemoryArea->Data.SectionData.Section;
1733 Region = MmFindRegion((PVOID)MA_GetStartingAddress(MemoryArea),
1734 &MemoryArea->Data.SectionData.RegionListHead,
1735 Address, NULL);
1736 ASSERT(Region != NULL);
1737
1738 /*
1739 * Check if we are doing COW
1740 */
1741 if (!((Segment->WriteCopy) &&
1742 (Region->Protect == PAGE_READWRITE ||
1743 Region->Protect == PAGE_EXECUTE_READWRITE)))
1744 {
1745 DPRINT("Address 0x%p\n", Address);
1746 return(STATUS_ACCESS_VIOLATION);
1747 }
1748
1749 /* Get the page mapping this section offset. */
1750 MmLockSectionSegment(Segment);
1751 Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
1752
1753 /* Get the current page mapping for the process */
1754 ASSERT(MmIsPagePresent(Process, PAddress));
1755 OldPage = MmGetPfnForProcess(Process, PAddress);
1756 ASSERT(OldPage != 0);
1757
1758 if (IS_SWAP_FROM_SSE(Entry) ||
1759 PFN_FROM_SSE(Entry) != OldPage)
1760 {
1761 MmUnlockSectionSegment(Segment);
1762 /* This is a private page. We must only change the page protection. */
1763 MmSetPageProtect(Process, PAddress, Region->Protect);
1764 return(STATUS_SUCCESS);
1765 }
1766
1767 /*
1768 * Allocate a page
1769 */
1770 MI_SET_USAGE(MI_USAGE_SECTION);
1771 if (Process) MI_SET_PROCESS2(Process->ImageFileName);
1772 if (!Process) MI_SET_PROCESS2("Kernel Section");
1773 Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &NewPage);
1774 if (!NT_SUCCESS(Status))
1775 {
1776 KeBugCheck(MEMORY_MANAGEMENT);
1777 }
1778
1779 /*
1780 * Copy the old page
1781 */
1782 NT_VERIFY(NT_SUCCESS(MiCopyFromUserPage(NewPage, PAddress)));
1783
1784 /*
1785 * Unshare the old page.
1786 */
1787 DPRINT("Swapping page (Old %x New %x)\n", OldPage, NewPage);
1788 MmDeleteVirtualMapping(Process, PAddress, NULL, NULL);
1789 MmDeleteRmap(OldPage, Process, PAddress);
1790 MmUnsharePageEntrySectionSegment(Section, Segment, &Offset, FALSE, FALSE, NULL);
1791 MmUnlockSectionSegment(Segment);
1792
1793 /*
1794 * Set the PTE to point to the new page
1795 */
1796 Status = MmCreateVirtualMapping(Process,
1797 PAddress,
1798 Region->Protect,
1799 &NewPage,
1800 1);
1801 if (!NT_SUCCESS(Status))
1802 {
1803 DPRINT1("MmCreateVirtualMapping failed, unable to create virtual mapping, not out of memory\n");
1804 KeBugCheck(MEMORY_MANAGEMENT);
1805 return(Status);
1806 }
1807 MmInsertRmap(NewPage, Process, PAddress);
1808
1809 MiSetPageEvent(Process, Address);
1810 DPRINT("Address 0x%p\n", Address);
1811 return(STATUS_SUCCESS);
1812 }
1813
1814 VOID
1815 MmPageOutDeleteMapping(PVOID Context, PEPROCESS Process, PVOID Address)
1816 {
1817 MM_SECTION_PAGEOUT_CONTEXT* PageOutContext;
1818 BOOLEAN WasDirty;
1819 PFN_NUMBER Page = 0;
1820
1821 PageOutContext = (MM_SECTION_PAGEOUT_CONTEXT*)Context;
1822 if (Process)
1823 {
1824 MmLockAddressSpace(&Process->Vm);
1825 }
1826
1827 MmDeleteVirtualMapping(Process,
1828 Address,
1829 &WasDirty,
1830 &Page);
1831 if (WasDirty)
1832 {
1833 PageOutContext->WasDirty = TRUE;
1834 }
1835 if (!PageOutContext->Private)
1836 {
1837 MmLockSectionSegment(PageOutContext->Segment);
1838 MmUnsharePageEntrySectionSegment((PROS_SECTION_OBJECT)PageOutContext->Section,
1839 PageOutContext->Segment,
1840 &PageOutContext->Offset,
1841 PageOutContext->WasDirty,
1842 TRUE,
1843 &PageOutContext->SectionEntry);
1844 MmUnlockSectionSegment(PageOutContext->Segment);
1845 }
1846 if (Process)
1847 {
1848 MmUnlockAddressSpace(&Process->Vm);
1849 }
1850
1851 if (PageOutContext->Private)
1852 {
1853 MmReleasePageMemoryConsumer(MC_USER, Page);
1854 }
1855 }
1856
1857 NTSTATUS
1858 NTAPI
1859 MmPageOutSectionView(PMMSUPPORT AddressSpace,
1860 MEMORY_AREA* MemoryArea,
1861 PVOID Address, ULONG_PTR Entry)
1862 {
1863 PFN_NUMBER Page;
1864 MM_SECTION_PAGEOUT_CONTEXT Context;
1865 SWAPENTRY SwapEntry;
1866 NTSTATUS Status;
1867 #ifndef NEWCC
1868 ULONGLONG FileOffset;
1869 PFILE_OBJECT FileObject;
1870 PROS_SHARED_CACHE_MAP SharedCacheMap = NULL;
1871 BOOLEAN IsImageSection;
1872 #endif
1873 BOOLEAN DirectMapped;
1874 PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
1875 KIRQL OldIrql;
1876
1877 Address = (PVOID)PAGE_ROUND_DOWN(Address);
1878
1879 /*
1880 * Get the segment and section.
1881 */
1882 Context.Segment = MemoryArea->Data.SectionData.Segment;
1883 Context.Section = MemoryArea->Data.SectionData.Section;
1884 Context.SectionEntry = Entry;
1885 Context.CallingProcess = Process;
1886
1887 Context.Offset.QuadPart = (ULONG_PTR)Address - MA_GetStartingAddress(MemoryArea)
1888 + MemoryArea->Data.SectionData.ViewOffset.QuadPart;
1889
1890 DirectMapped = FALSE;
1891
1892 MmLockSectionSegment(Context.Segment);
1893
1894 #ifndef NEWCC
1895 FileOffset = Context.Offset.QuadPart + Context.Segment->Image.FileOffset;
1896 IsImageSection = Context.Section->AllocationAttributes & SEC_IMAGE ? TRUE : FALSE;
1897 FileObject = Context.Section->FileObject;
1898
1899 if (FileObject != NULL &&
1900 !(Context.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
1901 {
1902 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
1903
1904 /*
1905 * If the file system is letting us go directly to the cache and the
1906 * memory area was mapped at an offset in the file which is page aligned
1907 * then note this is a direct mapped page.
1908 */
1909 if ((FileOffset % PAGE_SIZE) == 0 &&
1910 (Context.Offset.QuadPart + PAGE_SIZE <= Context.Segment->RawLength.QuadPart || !IsImageSection))
1911 {
1912 DirectMapped = TRUE;
1913 }
1914 }
1915 #endif
1916
1917
1918 /*
1919 * This should never happen since mappings of physical memory are never
1920 * placed in the rmap lists.
1921 */
1922 if (Context.Section->AllocationAttributes & SEC_PHYSICALMEMORY)
1923 {
1924 DPRINT1("Trying to page out from physical memory section address 0x%p "
1925 "process %p\n", Address,
1926 Process ? Process->UniqueProcessId : 0);
1927 KeBugCheck(MEMORY_MANAGEMENT);
1928 }
1929
1930 /*
1931 * Get the section segment entry and the physical address.
1932 */
1933 if (!MmIsPagePresent(Process, Address))
1934 {
1935 DPRINT1("Trying to page out not-present page at (%p,0x%p).\n",
1936 Process ? Process->UniqueProcessId : 0, Address);
1937 KeBugCheck(MEMORY_MANAGEMENT);
1938 }
1939 Page = MmGetPfnForProcess(Process, Address);
1940 SwapEntry = MmGetSavedSwapEntryPage(Page);
1941
1942 /*
1943 * Check the reference count to ensure this page can be paged out
1944 */
1945 if (MmGetReferenceCountPage(Page) != 1)
1946 {
1947 DPRINT("Cannot page out locked section page: 0x%lu (RefCount: %lu)\n",
1948 Page, MmGetReferenceCountPage(Page));
1949 MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
1950 MmUnlockSectionSegment(Context.Segment);
1951 return STATUS_UNSUCCESSFUL;
1952 }
1953
1954 /*
1955 * Prepare the context structure for the rmap delete call.
1956 */
1957 MmUnlockSectionSegment(Context.Segment);
1958 Context.WasDirty = FALSE;
1959 if (Context.Segment->Image.Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA ||
1960 IS_SWAP_FROM_SSE(Entry) ||
1961 PFN_FROM_SSE(Entry) != Page)
1962 {
1963 Context.Private = TRUE;
1964 }
1965 else
1966 {
1967 Context.Private = FALSE;
1968 }
1969
1970 /*
1971 * Take an additional reference to the page or the VACB.
1972 */
1973 if (DirectMapped && !Context.Private)
1974 {
1975 if(!MiIsPageFromCache(MemoryArea, Context.Offset.QuadPart))
1976 {
1977 DPRINT1("Direct mapped non private page is not associated with the cache.\n");
1978 KeBugCheck(MEMORY_MANAGEMENT);
1979 }
1980 }
1981 else
1982 {
1983 OldIrql = MiAcquirePfnLock();
1984 MmReferencePage(Page);
1985 MiReleasePfnLock(OldIrql);
1986 }
1987
1988 MmDeleteAllRmaps(Page, (PVOID)&Context, MmPageOutDeleteMapping);
1989
1990 /* Since we passed in a surrogate, we'll get back the page entry
1991 * state in our context. This is intended to make intermediate
1992 * decrements of share count not release the wait entry.
1993 */
1994 Entry = Context.SectionEntry;
1995
1996 /*
1997 * If this wasn't a private page then we should have reduced the entry to
1998 * zero by deleting all the rmaps.
1999 */
2000 if (!Context.Private && Entry != 0)
2001 {
2002 if (!(Context.Segment->Flags & MM_PAGEFILE_SEGMENT) &&
2003 !(Context.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
2004 {
2005 KeBugCheckEx(MEMORY_MANAGEMENT, Entry, (ULONG_PTR)Process, (ULONG_PTR)Address, 0);
2006 }
2007 }
2008
2009 /*
2010 * If the page wasn't dirty then we can just free it as for a readonly page.
2011 * Since we unmapped all the mappings above we know it will not suddenly
2012 * become dirty.
2013 * If the page is from a pagefile section and has no swap entry,
2014 * we can't free the page at this point.
2015 */
2016 SwapEntry = MmGetSavedSwapEntryPage(Page);
2017 if (Context.Segment->Flags & MM_PAGEFILE_SEGMENT)
2018 {
2019 if (Context.Private)
2020 {
2021 DPRINT1("Found a %s private page (address %p) in a pagefile segment.\n",
2022 Context.WasDirty ? "dirty" : "clean", Address);
2023 KeBugCheckEx(MEMORY_MANAGEMENT, SwapEntry, (ULONG_PTR)Process, (ULONG_PTR)Address, 0);
2024 }
2025 if (!Context.WasDirty && SwapEntry != 0)
2026 {
2027 MmSetSavedSwapEntryPage(Page, 0);
2028 MmLockSectionSegment(Context.Segment);
2029 MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, MAKE_SWAP_SSE(SwapEntry));
2030 MmUnlockSectionSegment(Context.Segment);
2031 MmReleasePageMemoryConsumer(MC_USER, Page);
2032 MiSetPageEvent(NULL, NULL);
2033 return(STATUS_SUCCESS);
2034 }
2035 }
2036 else if (Context.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED)
2037 {
2038 if (Context.Private)
2039 {
2040 DPRINT1("Found a %s private page (address %p) in a shared section segment.\n",
2041 Context.WasDirty ? "dirty" : "clean", Address);
2042 KeBugCheckEx(MEMORY_MANAGEMENT, Page, (ULONG_PTR)Process, (ULONG_PTR)Address, 0);
2043 }
2044 if (!Context.WasDirty || SwapEntry != 0)
2045 {
2046 MmSetSavedSwapEntryPage(Page, 0);
2047 if (SwapEntry != 0)
2048 {
2049 MmLockSectionSegment(Context.Segment);
2050 MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, MAKE_SWAP_SSE(SwapEntry));
2051 MmUnlockSectionSegment(Context.Segment);
2052 }
2053 MmReleasePageMemoryConsumer(MC_USER, Page);
2054 MiSetPageEvent(NULL, NULL);
2055 return(STATUS_SUCCESS);
2056 }
2057 }
2058 else if (!Context.Private && DirectMapped)
2059 {
2060 if (SwapEntry != 0)
2061 {
2062 DPRINT1("Found a swapentry for a non private and direct mapped page (address %p)\n",
2063 Address);
2064 KeBugCheckEx(MEMORY_MANAGEMENT, STATUS_UNSUCCESSFUL, SwapEntry, (ULONG_PTR)Process, (ULONG_PTR)Address);
2065 }
2066 #ifndef NEWCC
2067 Status = CcRosUnmapVacb(SharedCacheMap, FileOffset, FALSE);
2068 #else
2069 Status = STATUS_SUCCESS;
2070 #endif
2071 #ifndef NEWCC
2072 if (!NT_SUCCESS(Status))
2073 {
2074 DPRINT1("CcRosUnmapVacb failed, status = %x\n", Status);
2075 KeBugCheckEx(MEMORY_MANAGEMENT, Status, (ULONG_PTR)SharedCacheMap, (ULONG_PTR)FileOffset, (ULONG_PTR)Address);
2076 }
2077 #endif
2078 MiSetPageEvent(NULL, NULL);
2079 return(STATUS_SUCCESS);
2080 }
2081 else if (!Context.WasDirty && !DirectMapped && !Context.Private)
2082 {
2083 if (SwapEntry != 0)
2084 {
2085 DPRINT1("Found a swap entry for a non dirty, non private and not direct mapped page (address %p)\n",
2086 Address);
2087 KeBugCheckEx(MEMORY_MANAGEMENT, SwapEntry, Page, (ULONG_PTR)Process, (ULONG_PTR)Address);
2088 }
2089 MmReleasePageMemoryConsumer(MC_USER, Page);
2090 MiSetPageEvent(NULL, NULL);
2091 return(STATUS_SUCCESS);
2092 }
2093 else if (!Context.WasDirty && Context.Private && SwapEntry != 0)
2094 {
2095 DPRINT("Not dirty and private and not swapped (%p:%p)\n", Process, Address);
2096 MmSetSavedSwapEntryPage(Page, 0);
2097 MmLockAddressSpace(AddressSpace);
2098 Status = MmCreatePageFileMapping(Process,
2099 Address,
2100 SwapEntry);
2101 MmUnlockAddressSpace(AddressSpace);
2102 if (!NT_SUCCESS(Status))
2103 {
2104 DPRINT1("Status %x Swapping out %p:%p\n", Status, Process, Address);
2105 KeBugCheckEx(MEMORY_MANAGEMENT, Status, (ULONG_PTR)Process, (ULONG_PTR)Address, SwapEntry);
2106 }
2107 MmReleasePageMemoryConsumer(MC_USER, Page);
2108 MiSetPageEvent(NULL, NULL);
2109 return(STATUS_SUCCESS);
2110 }
2111
2112 /*
2113 * If necessary, allocate an entry in the paging file for this page
2114 */
2115 if (SwapEntry == 0)
2116 {
2117 SwapEntry = MmAllocSwapPage();
2118 if (SwapEntry == 0)
2119 {
2120 MmShowOutOfSpaceMessagePagingFile();
2121 MmLockAddressSpace(AddressSpace);
2122 /*
2123 * For private pages restore the old mappings.
2124 */
2125 if (Context.Private)
2126 {
2127 Status = MmCreateVirtualMapping(Process,
2128 Address,
2129 MemoryArea->Protect,
2130 &Page,
2131 1);
2132 MmSetDirtyPage(Process, Address);
2133 MmInsertRmap(Page,
2134 Process,
2135 Address);
2136 }
2137 else
2138 {
2139 ULONG_PTR OldEntry;
2140
2141 MmLockSectionSegment(Context.Segment);
2142
2143 /*
2144 * For non-private pages if the page wasn't direct mapped then
2145 * set it back into the section segment entry so we don't loose
2146 * our copy. Otherwise it will be handled by the cache manager.
2147 */
2148 Status = MmCreateVirtualMapping(Process,
2149 Address,
2150 MemoryArea->Protect,
2151 &Page,
2152 1);
2153 MmSetDirtyPage(Process, Address);
2154 MmInsertRmap(Page,
2155 Process,
2156 Address);
2157 // If we got here, the previous entry should have been a wait
2158 Entry = MAKE_SSE(Page << PAGE_SHIFT, 1);
2159 OldEntry = MmGetPageEntrySectionSegment(Context.Segment, &Context.Offset);
2160 ASSERT(OldEntry == 0 || OldEntry == MAKE_SWAP_SSE(MM_WAIT_ENTRY));
2161 MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
2162 MmUnlockSectionSegment(Context.Segment);
2163 }
2164 MmUnlockAddressSpace(AddressSpace);
2165 MiSetPageEvent(NULL, NULL);
2166 return(STATUS_PAGEFILE_QUOTA);
2167 }
2168 }
2169
2170 /*
2171 * Write the page to the pagefile
2172 */
2173 Status = MmWriteToSwapPage(SwapEntry, Page);
2174 if (!NT_SUCCESS(Status))
2175 {
2176 DPRINT1("MM: Failed to write to swap page (Status was 0x%.8X)\n",
2177 Status);
2178 /*
2179 * As above: undo our actions.
2180 * FIXME: Also free the swap page.
2181 */
2182 MmLockAddressSpace(AddressSpace);
2183 if (Context.Private)
2184 {
2185 Status = MmCreateVirtualMapping(Process,
2186 Address,
2187 MemoryArea->Protect,
2188 &Page,
2189 1);
2190 MmSetDirtyPage(Process, Address);
2191 MmInsertRmap(Page,
2192 Process,
2193 Address);
2194 }
2195 else
2196 {
2197 MmLockSectionSegment(Context.Segment);
2198 Status = MmCreateVirtualMapping(Process,
2199 Address,
2200 MemoryArea->Protect,
2201 &Page,
2202 1);
2203 MmSetDirtyPage(Process, Address);
2204 MmInsertRmap(Page,
2205 Process,
2206 Address);
2207 Entry = MAKE_SSE(Page << PAGE_SHIFT, 1);
2208 MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
2209 MmUnlockSectionSegment(Context.Segment);
2210 }
2211 MmUnlockAddressSpace(AddressSpace);
2212 MiSetPageEvent(NULL, NULL);
2213 return(STATUS_UNSUCCESSFUL);
2214 }
2215
2216 /*
2217 * Otherwise we have succeeded.
2218 */
2219 DPRINT("MM: Wrote section page 0x%.8X to swap!\n", Page << PAGE_SHIFT);
2220 MmSetSavedSwapEntryPage(Page, 0);
2221 if (Context.Segment->Flags & MM_PAGEFILE_SEGMENT ||
2222 Context.Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED)
2223 {
2224 MmLockSectionSegment(Context.Segment);
2225 MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, MAKE_SWAP_SSE(SwapEntry));
2226 MmUnlockSectionSegment(Context.Segment);
2227 }
2228 else
2229 {
2230 MmReleasePageMemoryConsumer(MC_USER, Page);
2231 }
2232
2233 if (Context.Private)
2234 {
2235 MmLockAddressSpace(AddressSpace);
2236 MmLockSectionSegment(Context.Segment);
2237 Status = MmCreatePageFileMapping(Process,
2238 Address,
2239 SwapEntry);
2240 /* We had placed a wait entry upon entry ... replace it before leaving */
2241 MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
2242 MmUnlockSectionSegment(Context.Segment);
2243 MmUnlockAddressSpace(AddressSpace);
2244 if (!NT_SUCCESS(Status))
2245 {
2246 DPRINT1("Status %x Creating page file mapping for %p:%p\n", Status, Process, Address);
2247 KeBugCheckEx(MEMORY_MANAGEMENT, Status, (ULONG_PTR)Process, (ULONG_PTR)Address, SwapEntry);
2248 }
2249 }
2250 else
2251 {
2252 MmLockAddressSpace(AddressSpace);
2253 MmLockSectionSegment(Context.Segment);
2254 Entry = MAKE_SWAP_SSE(SwapEntry);
2255 /* We had placed a wait entry upon entry ... replace it before leaving */
2256 MmSetPageEntrySectionSegment(Context.Segment, &Context.Offset, Entry);
2257 MmUnlockSectionSegment(Context.Segment);
2258 MmUnlockAddressSpace(AddressSpace);
2259 }
2260
2261 MiSetPageEvent(NULL, NULL);
2262 return(STATUS_SUCCESS);
2263 }
2264
2265 NTSTATUS
2266 NTAPI
2267 MmWritePageSectionView(PMMSUPPORT AddressSpace,
2268 PMEMORY_AREA MemoryArea,
2269 PVOID Address,
2270 ULONG PageEntry)
2271 {
2272 LARGE_INTEGER Offset;
2273 PROS_SECTION_OBJECT Section;
2274 PMM_SECTION_SEGMENT Segment;
2275 PFN_NUMBER Page;
2276 SWAPENTRY SwapEntry;
2277 ULONG_PTR Entry;
2278 BOOLEAN Private;
2279 NTSTATUS Status;
2280 PFILE_OBJECT FileObject;
2281 #ifndef NEWCC
2282 PROS_SHARED_CACHE_MAP SharedCacheMap = NULL;
2283 #endif
2284 BOOLEAN DirectMapped;
2285 BOOLEAN IsImageSection;
2286 PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
2287
2288 Address = (PVOID)PAGE_ROUND_DOWN(Address);
2289
2290 Offset.QuadPart = (ULONG_PTR)Address - MA_GetStartingAddress(MemoryArea)
2291 + MemoryArea->Data.SectionData.ViewOffset.QuadPart;
2292
2293 /*
2294 * Get the segment and section.
2295 */
2296 Segment = MemoryArea->Data.SectionData.Segment;
2297 Section = MemoryArea->Data.SectionData.Section;
2298 IsImageSection = Section->AllocationAttributes & SEC_IMAGE ? TRUE : FALSE;
2299
2300 FileObject = Section->FileObject;
2301 DirectMapped = FALSE;
2302 if (FileObject != NULL &&
2303 !(Segment->Image.Characteristics & IMAGE_SCN_MEM_SHARED))
2304 {
2305 #ifndef NEWCC
2306 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
2307 #endif
2308
2309 /*
2310 * If the file system is letting us go directly to the cache and the
2311 * memory area was mapped at an offset in the file which is page aligned
2312 * then note this is a direct mapped page.
2313 */
2314 if (((Offset.QuadPart + Segment->Image.FileOffset) % PAGE_SIZE) == 0 &&
2315 (Offset.QuadPart + PAGE_SIZE <= Segment->RawLength.QuadPart || !IsImageSection))
2316 {
2317 DirectMapped = TRUE;
2318 }
2319 }
2320
2321 /*
2322 * This should never happen since mappings of physical memory are never
2323 * placed in the rmap lists.
2324 */
2325 if (Section->AllocationAttributes & SEC_PHYSICALMEMORY)
2326 {
2327 DPRINT1("Trying to write back page from physical memory mapped at %p "
2328 "process %p\n", Address,
2329 Process ? Process->UniqueProcessId : 0);
2330 KeBugCheck(MEMORY_MANAGEMENT);
2331 }
2332
2333 /*
2334 * Get the section segment entry and the physical address.
2335 */
2336 Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
2337 if (!MmIsPagePresent(Process, Address))
2338 {
2339 DPRINT1("Trying to page out not-present page at (%p,0x%p).\n",
2340 Process ? Process->UniqueProcessId : 0, Address);
2341 KeBugCheck(MEMORY_MANAGEMENT);
2342 }
2343 Page = MmGetPfnForProcess(Process, Address);
2344 SwapEntry = MmGetSavedSwapEntryPage(Page);
2345
2346 /*
2347 * Check for a private (COWed) page.
2348 */
2349 if (Segment->Image.Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA ||
2350 IS_SWAP_FROM_SSE(Entry) ||
2351 PFN_FROM_SSE(Entry) != Page)
2352 {
2353 Private = TRUE;
2354 }
2355 else
2356 {
2357 Private = FALSE;
2358 }
2359
2360 /*
2361 * Speculatively set all mappings of the page to clean.
2362 */
2363 MmSetCleanAllRmaps(Page);
2364
2365 /*
2366 * If this page was direct mapped from the cache then the cache manager
2367 * will take care of writing it back to disk.
2368 */
2369 if (DirectMapped && !Private)
2370 {
2371 //LARGE_INTEGER SOffset;
2372 ASSERT(SwapEntry == 0);
2373 //SOffset.QuadPart = Offset.QuadPart + Segment->Image.FileOffset;
2374 #ifndef NEWCC
2375 CcRosMarkDirtyFile(SharedCacheMap, Offset.QuadPart);
2376 #endif
2377 MmLockSectionSegment(Segment);
2378 MmSetPageEntrySectionSegment(Segment, &Offset, PageEntry);
2379 MmUnlockSectionSegment(Segment);
2380 MiSetPageEvent(NULL, NULL);
2381 return(STATUS_SUCCESS);
2382 }
2383
2384 /*
2385 * If necessary, allocate an entry in the paging file for this page
2386 */
2387 if (SwapEntry == 0)
2388 {
2389 SwapEntry = MmAllocSwapPage();
2390 if (SwapEntry == 0)
2391 {
2392 MmSetDirtyAllRmaps(Page);
2393 MiSetPageEvent(NULL, NULL);
2394 return(STATUS_PAGEFILE_QUOTA);
2395 }
2396 MmSetSavedSwapEntryPage(Page, SwapEntry);
2397 }
2398
2399 /*
2400 * Write the page to the pagefile
2401 */
2402 Status = MmWriteToSwapPage(SwapEntry, Page);
2403 if (!NT_SUCCESS(Status))
2404 {
2405 DPRINT1("MM: Failed to write to swap page (Status was 0x%.8X)\n",
2406 Status);
2407 MmSetDirtyAllRmaps(Page);
2408 MiSetPageEvent(NULL, NULL);
2409 return(STATUS_UNSUCCESSFUL);
2410 }
2411
2412 /*
2413 * Otherwise we have succeeded.
2414 */
2415 DPRINT("MM: Wrote section page 0x%.8X to swap!\n", Page << PAGE_SHIFT);
2416 MiSetPageEvent(NULL, NULL);
2417 return(STATUS_SUCCESS);
2418 }
2419
2420 static VOID
2421 MmAlterViewAttributes(PMMSUPPORT AddressSpace,
2422 PVOID BaseAddress,
2423 SIZE_T RegionSize,
2424 ULONG OldType,
2425 ULONG OldProtect,
2426 ULONG NewType,
2427 ULONG NewProtect)
2428 {
2429 PMEMORY_AREA MemoryArea;
2430 PMM_SECTION_SEGMENT Segment;
2431 BOOLEAN DoCOW = FALSE;
2432 ULONG i;
2433 PEPROCESS Process = MmGetAddressSpaceOwner(AddressSpace);
2434
2435 MemoryArea = MmLocateMemoryAreaByAddress(AddressSpace, BaseAddress);
2436 ASSERT(MemoryArea != NULL);
2437 Segment = MemoryArea->Data.SectionData.Segment;
2438 MmLockSectionSegment(Segment);
2439
2440 if ((Segment->WriteCopy) &&
2441 (NewProtect == PAGE_READWRITE || NewProtect == PAGE_EXECUTE_READWRITE))
2442 {
2443 DoCOW = TRUE;
2444 }
2445
2446 if (OldProtect != NewProtect)
2447 {
2448 for (i = 0; i < PAGE_ROUND_UP(RegionSize) / PAGE_SIZE; i++)
2449 {
2450 SWAPENTRY SwapEntry;
2451 PVOID Address = (char*)BaseAddress + (i * PAGE_SIZE);
2452 ULONG Protect = NewProtect;
2453
2454 /* Wait for a wait entry to disappear */
2455 do
2456 {
2457 MmGetPageFileMapping(Process, Address, &SwapEntry);
2458 if (SwapEntry != MM_WAIT_ENTRY)
2459 break;
2460 MiWaitForPageEvent(Process, Address);
2461 }
2462 while (TRUE);
2463
2464 /*
2465 * If we doing COW for this segment then check if the page is
2466 * already private.
2467 */
2468 if (DoCOW && MmIsPagePresent(Process, Address))
2469 {
2470 LARGE_INTEGER Offset;
2471 ULONG_PTR Entry;
2472 PFN_NUMBER Page;
2473
2474 Offset.QuadPart = (ULONG_PTR)Address - MA_GetStartingAddress(MemoryArea)
2475 + MemoryArea->Data.SectionData.ViewOffset.QuadPart;
2476 Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
2477 /*
2478 * An MM_WAIT_ENTRY is ok in this case... It'll just count as
2479 * IS_SWAP_FROM_SSE and we'll do the right thing.
2480 */
2481 Page = MmGetPfnForProcess(Process, Address);
2482
2483 Protect = PAGE_READONLY;
2484 if (Segment->Image.Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA ||
2485 IS_SWAP_FROM_SSE(Entry) ||
2486 PFN_FROM_SSE(Entry) != Page)
2487 {
2488 Protect = NewProtect;
2489 }
2490 }
2491
2492 if (MmIsPagePresent(Process, Address) || MmIsDisabledPage(Process, Address))
2493 {
2494 MmSetPageProtect(Process, Address,
2495 Protect);
2496 }
2497 }
2498 }
2499
2500 MmUnlockSectionSegment(Segment);
2501 }
2502
2503 NTSTATUS
2504 NTAPI
2505 MmProtectSectionView(PMMSUPPORT AddressSpace,
2506 PMEMORY_AREA MemoryArea,
2507 PVOID BaseAddress,
2508 SIZE_T Length,
2509 ULONG Protect,
2510 PULONG OldProtect)
2511 {
2512 PMM_REGION Region;
2513 NTSTATUS Status;
2514 ULONG_PTR MaxLength;
2515
2516 MaxLength = MA_GetEndingAddress(MemoryArea) - (ULONG_PTR)BaseAddress;
2517 if (Length > MaxLength)
2518 Length = (ULONG)MaxLength;
2519
2520 Region = MmFindRegion((PVOID)MA_GetStartingAddress(MemoryArea),
2521 &MemoryArea->Data.SectionData.RegionListHead,
2522 BaseAddress, NULL);
2523 ASSERT(Region != NULL);
2524
2525 if ((MemoryArea->Flags & SEC_NO_CHANGE) &&
2526 Region->Protect != Protect)
2527 {
2528 return STATUS_INVALID_PAGE_PROTECTION;
2529 }
2530
2531 *OldProtect = Region->Protect;
2532 Status = MmAlterRegion(AddressSpace, (PVOID)MA_GetStartingAddress(MemoryArea),
2533 &MemoryArea->Data.SectionData.RegionListHead,
2534 BaseAddress, Length, Region->Type, Protect,
2535 MmAlterViewAttributes);
2536
2537 return(Status);
2538 }
2539
2540 NTSTATUS NTAPI
2541 MmQuerySectionView(PMEMORY_AREA MemoryArea,
2542 PVOID Address,
2543 PMEMORY_BASIC_INFORMATION Info,
2544 PSIZE_T ResultLength)
2545 {
2546 PMM_REGION Region;
2547 PVOID RegionBaseAddress;
2548 PROS_SECTION_OBJECT Section;
2549 PMM_SECTION_SEGMENT Segment;
2550
2551 Region = MmFindRegion((PVOID)MA_GetStartingAddress(MemoryArea),
2552 &MemoryArea->Data.SectionData.RegionListHead,
2553 Address, &RegionBaseAddress);
2554 if (Region == NULL)
2555 {
2556 return STATUS_UNSUCCESSFUL;
2557 }
2558
2559 Section = MemoryArea->Data.SectionData.Section;
2560 if (Section->AllocationAttributes & SEC_IMAGE)
2561 {
2562 Segment = MemoryArea->Data.SectionData.Segment;
2563 Info->AllocationBase = (PUCHAR)MA_GetStartingAddress(MemoryArea) - Segment->Image.VirtualAddress;
2564 Info->Type = MEM_IMAGE;
2565 }
2566 else
2567 {
2568 Info->AllocationBase = (PVOID)MA_GetStartingAddress(MemoryArea);
2569 Info->Type = MEM_MAPPED;
2570 }
2571 Info->BaseAddress = RegionBaseAddress;
2572 Info->AllocationProtect = MemoryArea->Protect;
2573 Info->RegionSize = Region->Length;
2574 Info->State = MEM_COMMIT;
2575 Info->Protect = Region->Protect;
2576
2577 *ResultLength = sizeof(MEMORY_BASIC_INFORMATION);
2578 return(STATUS_SUCCESS);
2579 }
2580
2581 VOID
2582 NTAPI
2583 MmpFreePageFileSegment(PMM_SECTION_SEGMENT Segment)
2584 {
2585 ULONG Length;
2586 LARGE_INTEGER Offset;
2587 ULONG_PTR Entry;
2588 SWAPENTRY SavedSwapEntry;
2589 PFN_NUMBER Page;
2590
2591 Page = 0;
2592
2593 MmLockSectionSegment(Segment);
2594
2595 Length = PAGE_ROUND_UP(Segment->Length.QuadPart);
2596 for (Offset.QuadPart = 0; Offset.QuadPart < Length; Offset.QuadPart += PAGE_SIZE)
2597 {
2598 Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
2599 if (Entry)
2600 {
2601 MmSetPageEntrySectionSegment(Segment, &Offset, 0);
2602 if (IS_SWAP_FROM_SSE(Entry))
2603 {
2604 MmFreeSwapPage(SWAPENTRY_FROM_SSE(Entry));
2605 }
2606 else
2607 {
2608 Page = PFN_FROM_SSE(Entry);
2609 SavedSwapEntry = MmGetSavedSwapEntryPage(Page);
2610 if (SavedSwapEntry != 0)
2611 {
2612 MmSetSavedSwapEntryPage(Page, 0);
2613 MmFreeSwapPage(SavedSwapEntry);
2614 }
2615 MmReleasePageMemoryConsumer(MC_USER, Page);
2616 }
2617 }
2618 }
2619
2620 MmUnlockSectionSegment(Segment);
2621 }
2622
2623 VOID NTAPI
2624 MmpDeleteSection(PVOID ObjectBody)
2625 {
2626 PROS_SECTION_OBJECT Section = (PROS_SECTION_OBJECT)ObjectBody;
2627
2628 /* Check if it's an ARM3, or ReactOS section */
2629 if (!MiIsRosSectionObject(Section))
2630 {
2631 MiDeleteARM3Section(ObjectBody);
2632 return;
2633 }
2634
2635 DPRINT("MmpDeleteSection(ObjectBody %p)\n", ObjectBody);
2636 if (Section->AllocationAttributes & SEC_IMAGE)
2637 {
2638 ULONG i;
2639 ULONG NrSegments;
2640 ULONG RefCount;
2641 PMM_SECTION_SEGMENT SectionSegments;
2642
2643 /*
2644 * NOTE: Section->ImageSection can be NULL for short time
2645 * during the section creating. If we fail for some reason
2646 * until the image section is properly initialized we shouldn't
2647 * process further here.
2648 */
2649 if (Section->ImageSection == NULL)
2650 return;
2651
2652 SectionSegments = Section->ImageSection->Segments;
2653 NrSegments = Section->ImageSection->NrSegments;
2654
2655 for (i = 0; i < NrSegments; i++)
2656 {
2657 if (SectionSegments[i].Image.Characteristics & IMAGE_SCN_MEM_SHARED)
2658 {
2659 MmLockSectionSegment(&SectionSegments[i]);
2660 }
2661 RefCount = InterlockedDecrementUL(&SectionSegments[i].ReferenceCount);
2662 if (SectionSegments[i].Image.Characteristics & IMAGE_SCN_MEM_SHARED)
2663 {
2664 MmUnlockSectionSegment(&SectionSegments[i]);
2665 if (RefCount == 0)
2666 {
2667 MmpFreePageFileSegment(&SectionSegments[i]);
2668 }
2669 }
2670 }
2671 }
2672 #ifdef NEWCC
2673 else if (Section->Segment && Section->Segment->Flags & MM_DATAFILE_SEGMENT)
2674 {
2675 ULONG RefCount = 0;
2676 PMM_SECTION_SEGMENT Segment = Section->Segment;
2677
2678 if (Segment &&
2679 (RefCount = InterlockedDecrementUL(&Segment->ReferenceCount)) == 0)
2680 {
2681 DPRINT("Freeing section segment\n");
2682 Section->Segment = NULL;
2683 MmFinalizeSegment(Segment);
2684 }
2685 else
2686 {
2687 DPRINT("RefCount %d\n", RefCount);
2688 }
2689 }
2690 #endif
2691 else
2692 {
2693 /*
2694 * NOTE: Section->Segment can be NULL for short time
2695 * during the section creating.
2696 */
2697 if (Section->Segment == NULL)
2698 return;
2699
2700 if (Section->Segment->Flags & MM_PAGEFILE_SEGMENT)
2701 {
2702 MmpFreePageFileSegment(Section->Segment);
2703 MmFreePageTablesSectionSegment(Section->Segment, NULL);
2704 ExFreePool(Section->Segment);
2705 Section->Segment = NULL;
2706 }
2707 else
2708 {
2709 (void)InterlockedDecrementUL(&Section->Segment->ReferenceCount);
2710 }
2711 }
2712 if (Section->FileObject != NULL)
2713 {
2714 #ifndef NEWCC
2715 CcRosDereferenceCache(Section->FileObject);
2716 #endif
2717 ObDereferenceObject(Section->FileObject);
2718 Section->FileObject = NULL;
2719 }
2720 }
2721
2722 VOID NTAPI
2723 MmpCloseSection(IN PEPROCESS Process OPTIONAL,
2724 IN PVOID Object,
2725 IN ACCESS_MASK GrantedAccess,
2726 IN ULONG ProcessHandleCount,
2727 IN ULONG SystemHandleCount)
2728 {
2729 DPRINT("MmpCloseSection(OB %p, HC %lu)\n", Object, ProcessHandleCount);
2730 }
2731
2732 NTSTATUS
2733 INIT_FUNCTION
2734 NTAPI
2735 MmCreatePhysicalMemorySection(VOID)
2736 {
2737 PROS_SECTION_OBJECT PhysSection;
2738 NTSTATUS Status;
2739 OBJECT_ATTRIBUTES Obj;
2740 UNICODE_STRING Name = RTL_CONSTANT_STRING(L"\\Device\\PhysicalMemory");
2741 LARGE_INTEGER SectionSize;
2742 HANDLE Handle;
2743
2744 /*
2745 * Create the section mapping physical memory
2746 */
2747 SectionSize.QuadPart = 0xFFFFFFFF;
2748 InitializeObjectAttributes(&Obj,
2749 &Name,
2750 OBJ_PERMANENT | OBJ_KERNEL_EXCLUSIVE,
2751 NULL,
2752 NULL);
2753 Status = MmCreateSection((PVOID)&PhysSection,
2754 SECTION_ALL_ACCESS,
2755 &Obj,
2756 &SectionSize,
2757 PAGE_EXECUTE_READWRITE,
2758 SEC_PHYSICALMEMORY,
2759 NULL,
2760 NULL);
2761 if (!NT_SUCCESS(Status))
2762 {
2763 DPRINT1("Failed to create PhysicalMemory section\n");
2764 KeBugCheck(MEMORY_MANAGEMENT);
2765 }
2766 Status = ObInsertObject(PhysSection,
2767 NULL,
2768 SECTION_ALL_ACCESS,
2769 0,
2770 NULL,
2771 &Handle);
2772 if (!NT_SUCCESS(Status))
2773 {
2774 ObDereferenceObject(PhysSection);
2775 }
2776 ObCloseHandle(Handle, KernelMode);
2777 PhysSection->AllocationAttributes |= SEC_PHYSICALMEMORY;
2778 PhysSection->Segment->Flags &= ~MM_PAGEFILE_SEGMENT;
2779
2780 return(STATUS_SUCCESS);
2781 }
2782
2783 NTSTATUS
2784 INIT_FUNCTION
2785 NTAPI
2786 MmInitSectionImplementation(VOID)
2787 {
2788 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
2789 UNICODE_STRING Name;
2790
2791 DPRINT("Creating Section Object Type\n");
2792
2793 /* Initialize the section based root */
2794 ASSERT(MmSectionBasedRoot.NumberGenericTableElements == 0);
2795 MmSectionBasedRoot.BalancedRoot.u1.Parent = &MmSectionBasedRoot.BalancedRoot;
2796
2797 /* Initialize the Section object type */
2798 RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
2799 RtlInitUnicodeString(&Name, L"Section");
2800 ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
2801 ObjectTypeInitializer.DefaultPagedPoolCharge = sizeof(ROS_SECTION_OBJECT);
2802 ObjectTypeInitializer.PoolType = PagedPool;
2803 ObjectTypeInitializer.UseDefaultObject = TRUE;
2804 ObjectTypeInitializer.GenericMapping = MmpSectionMapping;
2805 ObjectTypeInitializer.DeleteProcedure = MmpDeleteSection;
2806 ObjectTypeInitializer.CloseProcedure = MmpCloseSection;
2807 ObjectTypeInitializer.ValidAccessMask = SECTION_ALL_ACCESS;
2808 ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
2809 ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &MmSectionObjectType);
2810
2811 MmCreatePhysicalMemorySection();
2812
2813 return(STATUS_SUCCESS);
2814 }
2815
2816 NTSTATUS
2817 NTAPI
2818 MmCreatePageFileSection(PROS_SECTION_OBJECT *SectionObject,
2819 ACCESS_MASK DesiredAccess,
2820 POBJECT_ATTRIBUTES ObjectAttributes,
2821 PLARGE_INTEGER UMaximumSize,
2822 ULONG SectionPageProtection,
2823 ULONG AllocationAttributes)
2824 /*
2825 * Create a section which is backed by the pagefile
2826 */
2827 {
2828 LARGE_INTEGER MaximumSize;
2829 PROS_SECTION_OBJECT Section;
2830 PMM_SECTION_SEGMENT Segment;
2831 NTSTATUS Status;
2832
2833 if (UMaximumSize == NULL)
2834 {
2835 DPRINT1("MmCreatePageFileSection: (UMaximumSize == NULL)\n");
2836 return(STATUS_INVALID_PARAMETER);
2837 }
2838 MaximumSize = *UMaximumSize;
2839
2840 /*
2841 * Create the section
2842 */
2843 Status = ObCreateObject(ExGetPreviousMode(),
2844 MmSectionObjectType,
2845 ObjectAttributes,
2846 ExGetPreviousMode(),
2847 NULL,
2848 sizeof(ROS_SECTION_OBJECT),
2849 0,
2850 0,
2851 (PVOID*)(PVOID)&Section);
2852 if (!NT_SUCCESS(Status))
2853 {
2854 DPRINT1("MmCreatePageFileSection: failed to create object (0x%lx)\n", Status);
2855 return(Status);
2856 }
2857
2858 /*
2859 * Initialize it
2860 */
2861 RtlZeroMemory(Section, sizeof(ROS_SECTION_OBJECT));
2862 Section->Type = 'SC';
2863 Section->Size = 'TN';
2864 Section->SectionPageProtection = SectionPageProtection;
2865 Section->AllocationAttributes = AllocationAttributes;
2866 Section->MaximumSize = MaximumSize;
2867 Segment = ExAllocatePoolWithTag(NonPagedPool, sizeof(MM_SECTION_SEGMENT),
2868 TAG_MM_SECTION_SEGMENT);
2869 if (Segment == NULL)
2870 {
2871 ObDereferenceObject(Section);
2872 return(STATUS_NO_MEMORY);
2873 }
2874 RtlZeroMemory(Segment, sizeof(MM_SECTION_SEGMENT));
2875 Section->Segment = Segment;
2876 Segment->ReferenceCount = 1;
2877 ExInitializeFastMutex(&Segment->Lock);
2878 Segment->Image.FileOffset = 0;
2879 Segment->Protection = SectionPageProtection;
2880 Segment->RawLength.QuadPart = MaximumSize.u.LowPart;
2881 Segment->Length.QuadPart = PAGE_ROUND_UP(MaximumSize.u.LowPart);
2882 Segment->Flags = MM_PAGEFILE_SEGMENT;
2883 Segment->WriteCopy = FALSE;
2884 Segment->Image.VirtualAddress = 0;
2885 Segment->Image.Characteristics = 0;
2886 *SectionObject = Section;
2887 MiInitializeSectionPageTable(Segment);
2888 return(STATUS_SUCCESS);
2889 }
2890
2891 NTSTATUS
2892 NTAPI
2893 MmCreateDataFileSection(PROS_SECTION_OBJECT *SectionObject,
2894 ACCESS_MASK DesiredAccess,
2895 POBJECT_ATTRIBUTES ObjectAttributes,
2896 PLARGE_INTEGER UMaximumSize,
2897 ULONG SectionPageProtection,
2898 ULONG AllocationAttributes,
2899 PFILE_OBJECT FileObject)
2900 /*
2901 * Create a section backed by a data file
2902 */
2903 {
2904 PROS_SECTION_OBJECT Section;
2905 NTSTATUS Status;
2906 LARGE_INTEGER MaximumSize;
2907 PMM_SECTION_SEGMENT Segment;
2908 FILE_STANDARD_INFORMATION FileInfo;
2909 ULONG Length;
2910
2911 /*
2912 * Create the section
2913 */
2914 Status = ObCreateObject(ExGetPreviousMode(),
2915 MmSectionObjectType,
2916 ObjectAttributes,
2917 ExGetPreviousMode(),
2918 NULL,
2919 sizeof(ROS_SECTION_OBJECT),
2920 0,
2921 0,
2922 (PVOID*)&Section);
2923 if (!NT_SUCCESS(Status))
2924 {
2925 ObDereferenceObject(FileObject);
2926 return(Status);
2927 }
2928 /*
2929 * Initialize it
2930 */
2931 RtlZeroMemory(Section, sizeof(ROS_SECTION_OBJECT));
2932 Section->Type = 'SC';
2933 Section->Size = 'TN';
2934 Section->SectionPageProtection = SectionPageProtection;
2935 Section->AllocationAttributes = AllocationAttributes;
2936
2937 /*
2938 * FIXME: This is propably not entirely correct. We can't look into
2939 * the standard FCB header because it might not be initialized yet
2940 * (as in case of the EXT2FS driver by Manoj Paul Joseph where the
2941 * standard file information is filled on first request).
2942 */
2943 Status = IoQueryFileInformation(FileObject,
2944 FileStandardInformation,
2945 sizeof(FILE_STANDARD_INFORMATION),
2946 &FileInfo,
2947 &Length);
2948 if (!NT_SUCCESS(Status))
2949 {
2950 ObDereferenceObject(Section);
2951 ObDereferenceObject(FileObject);
2952 return Status;
2953 }
2954
2955 /*
2956 * FIXME: Revise this once a locking order for file size changes is
2957 * decided
2958 */
2959 if ((UMaximumSize != NULL) && (UMaximumSize->QuadPart != 0))
2960 {
2961 MaximumSize = *UMaximumSize;
2962 }
2963 else
2964 {
2965 MaximumSize = FileInfo.EndOfFile;
2966 /* Mapping zero-sized files isn't allowed. */
2967 if (MaximumSize.QuadPart == 0)
2968 {
2969 ObDereferenceObject(Section);
2970 ObDereferenceObject(FileObject);
2971 return STATUS_MAPPED_FILE_SIZE_ZERO;
2972 }
2973 }
2974
2975 if (MaximumSize.QuadPart > FileInfo.EndOfFile.QuadPart)
2976 {
2977 Status = IoSetInformation(FileObject,
2978 FileEndOfFileInformation,
2979 sizeof(LARGE_INTEGER),
2980 &MaximumSize);
2981 if (!NT_SUCCESS(Status))
2982 {
2983 ObDereferenceObject(Section);
2984 ObDereferenceObject(FileObject);
2985 return(STATUS_SECTION_NOT_EXTENDED);
2986 }
2987 }
2988
2989 if (FileObject->SectionObjectPointer == NULL ||
2990 FileObject->SectionObjectPointer->SharedCacheMap == NULL)
2991 {
2992 ObDereferenceObject(Section);
2993 ObDereferenceObject(FileObject);
2994 return STATUS_INVALID_FILE_FOR_SECTION;
2995 }
2996
2997 /*
2998 * Lock the file
2999 */
3000 Status = MmspWaitForFileLock(FileObject);
3001 if (Status != STATUS_SUCCESS)
3002 {
3003 ObDereferenceObject(Section);
3004 ObDereferenceObject(FileObject);
3005 return(Status);
3006 }
3007
3008 /*
3009 * If this file hasn't been mapped as a data file before then allocate a
3010 * section segment to describe the data file mapping
3011 */
3012 if (FileObject->SectionObjectPointer->DataSectionObject == NULL)
3013 {
3014 Segment = ExAllocatePoolWithTag(NonPagedPool, sizeof(MM_SECTION_SEGMENT),
3015 TAG_MM_SECTION_SEGMENT);
3016 if (Segment == NULL)
3017 {
3018 //KeSetEvent((PVOID)&FileObject->Lock, IO_NO_INCREMENT, FALSE);
3019 ObDereferenceObject(Section);
3020 ObDereferenceObject(FileObject);
3021 return(STATUS_NO_MEMORY);
3022 }
3023 Section->Segment = Segment;
3024 Segment->ReferenceCount = 1;
3025 ExInitializeFastMutex(&Segment->Lock);
3026 /*
3027 * Set the lock before assigning the segment to the file object
3028 */
3029 ExAcquireFastMutex(&Segment->Lock);
3030 FileObject->SectionObjectPointer->DataSectionObject = (PVOID)Segment;
3031
3032 Segment->Image.FileOffset = 0;
3033 Segment->Protection = SectionPageProtection;
3034 Segment->Flags = MM_DATAFILE_SEGMENT;
3035 Segment->Image.Characteristics = 0;
3036 Segment->WriteCopy = (SectionPageProtection & (PAGE_WRITECOPY | PAGE_EXECUTE_WRITECOPY));
3037 if (AllocationAttributes & SEC_RESERVE)
3038 {
3039 Segment->Length.QuadPart = Segment->RawLength.QuadPart = 0;
3040 }
3041 else
3042 {
3043 Segment->RawLength.QuadPart = MaximumSize.QuadPart;
3044 Segment->Length.QuadPart = PAGE_ROUND_UP(Segment->RawLength.QuadPart);
3045 }
3046 Segment->Image.VirtualAddress = 0;
3047 Segment->Locked = TRUE;
3048 MiInitializeSectionPageTable(Segment);
3049 }
3050 else
3051 {
3052 /*
3053 * If the file is already mapped as a data file then we may need
3054 * to extend it
3055 */
3056 Segment =
3057 (PMM_SECTION_SEGMENT)FileObject->SectionObjectPointer->
3058 DataSectionObject;
3059 Section->Segment = Segment;
3060 (void)InterlockedIncrementUL(&Segment->ReferenceCount);
3061 MmLockSectionSegment(Segment);
3062
3063 if (MaximumSize.QuadPart > Segment->RawLength.QuadPart &&
3064 !(AllocationAttributes & SEC_RESERVE))
3065 {
3066 Segment->RawLength.QuadPart = MaximumSize.QuadPart;
3067 Segment->Length.QuadPart = PAGE_ROUND_UP(Segment->RawLength.QuadPart);
3068 }
3069 }
3070 MmUnlockSectionSegment(Segment);
3071 Section->FileObject = FileObject;
3072 Section->MaximumSize = MaximumSize;
3073 #ifndef NEWCC
3074 CcRosReferenceCache(FileObject);
3075 #endif
3076 //KeSetEvent((PVOID)&FileObject->Lock, IO_NO_INCREMENT, FALSE);
3077 *SectionObject = Section;
3078 return(STATUS_SUCCESS);
3079 }
3080
3081 /*
3082 TODO: not that great (declaring loaders statically, having to declare all of
3083 them, having to keep them extern, etc.), will fix in the future
3084 */
3085 extern NTSTATUS NTAPI PeFmtCreateSection
3086 (
3087 IN CONST VOID * FileHeader,
3088 IN SIZE_T FileHeaderSize,
3089 IN PVOID File,
3090 OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject,
3091 OUT PULONG Flags,
3092 IN PEXEFMT_CB_READ_FILE ReadFileCb,
3093 IN PEXEFMT_CB_ALLOCATE_SEGMENTS AllocateSegmentsCb
3094 );
3095
3096 extern NTSTATUS NTAPI ElfFmtCreateSection
3097 (
3098 IN CONST VOID * FileHeader,
3099 IN SIZE_T FileHeaderSize,
3100 IN PVOID File,
3101 OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject,
3102 OUT PULONG Flags,
3103 IN PEXEFMT_CB_READ_FILE ReadFileCb,
3104 IN PEXEFMT_CB_ALLOCATE_SEGMENTS AllocateSegmentsCb
3105 );
3106
3107 static PEXEFMT_LOADER ExeFmtpLoaders[] =
3108 {
3109 PeFmtCreateSection,
3110 #ifdef __ELF
3111 ElfFmtCreateSection
3112 #endif
3113 };
3114
3115 static
3116 PMM_SECTION_SEGMENT
3117 NTAPI
3118 ExeFmtpAllocateSegments(IN ULONG NrSegments)
3119 {
3120 SIZE_T SizeOfSegments;
3121 PMM_SECTION_SEGMENT Segments;
3122
3123 /* TODO: check for integer overflow */
3124 SizeOfSegments = sizeof(MM_SECTION_SEGMENT) * NrSegments;
3125
3126 Segments = ExAllocatePoolWithTag(NonPagedPool,
3127 SizeOfSegments,
3128 TAG_MM_SECTION_SEGMENT);
3129
3130 if(Segments)
3131 RtlZeroMemory(Segments, SizeOfSegments);
3132
3133 return Segments;
3134 }
3135
3136 static
3137 NTSTATUS
3138 NTAPI
3139 ExeFmtpReadFile(IN PVOID File,
3140 IN PLARGE_INTEGER Offset,
3141 IN ULONG Length,
3142 OUT PVOID * Data,
3143 OUT PVOID * AllocBase,
3144 OUT PULONG ReadSize)
3145 {
3146 NTSTATUS Status;
3147 LARGE_INTEGER FileOffset;
3148 ULONG AdjustOffset;
3149 ULONG OffsetAdjustment;
3150 ULONG BufferSize;
3151 ULONG UsedSize;
3152 PVOID Buffer;
3153 PFILE_OBJECT FileObject = File;
3154 IO_STATUS_BLOCK Iosb;
3155
3156 ASSERT_IRQL_LESS(DISPATCH_LEVEL);
3157
3158 if(Length == 0)
3159 {
3160 KeBugCheck(MEMORY_MANAGEMENT);
3161 }
3162
3163 FileOffset = *Offset;
3164
3165 /* Negative/special offset: it cannot be used in this context */
3166 if(FileOffset.u.HighPart < 0)
3167 {
3168 KeBugCheck(MEMORY_MANAGEMENT);
3169 }
3170
3171 AdjustOffset = PAGE_ROUND_DOWN(FileOffset.u.LowPart);
3172 OffsetAdjustment = FileOffset.u.LowPart - AdjustOffset;
3173 FileOffset.u.LowPart = AdjustOffset;
3174
3175 BufferSize = Length + OffsetAdjustment;
3176 BufferSize = PAGE_ROUND_UP(BufferSize);
3177
3178 /* Flush data since we're about to perform a non-cached read */
3179 CcFlushCache(FileObject->SectionObjectPointer,
3180 &FileOffset,
3181 BufferSize,
3182 &Iosb);
3183
3184 /*
3185 * It's ok to use paged pool, because this is a temporary buffer only used in
3186 * the loading of executables. The assumption is that MmCreateSection is
3187 * always called at low IRQLs and that these buffers don't survive a brief
3188 * initialization phase
3189 */
3190 Buffer = ExAllocatePoolWithTag(PagedPool,
3191 BufferSize,
3192 'rXmM');
3193 if (!Buffer)
3194 {
3195 return STATUS_INSUFFICIENT_RESOURCES;
3196 }
3197
3198 UsedSize = 0;
3199
3200 Status = MiSimpleRead(FileObject, &FileOffset, Buffer, BufferSize, TRUE, &Iosb);
3201
3202 UsedSize = (ULONG)Iosb.Information;
3203
3204 if(NT_SUCCESS(Status) && UsedSize < OffsetAdjustment)
3205 {
3206 Status = STATUS_IN_PAGE_ERROR;
3207 ASSERT(!NT_SUCCESS(Status));
3208 }
3209
3210 if(NT_SUCCESS(Status))
3211 {
3212 *Data = (PVOID)((ULONG_PTR)Buffer + OffsetAdjustment);
3213 *AllocBase = Buffer;
3214 *ReadSize = UsedSize - OffsetAdjustment;
3215 }
3216 else
3217 {
3218 ExFreePoolWithTag(Buffer, 'rXmM');
3219 }
3220
3221 return Status;
3222 }
3223
3224 #ifdef NASSERT
3225 # define MmspAssertSegmentsSorted(OBJ_) ((void)0)
3226 # define MmspAssertSegmentsNoOverlap(OBJ_) ((void)0)
3227 # define MmspAssertSegmentsPageAligned(OBJ_) ((void)0)
3228 #else
3229 static
3230 VOID
3231 NTAPI
3232 MmspAssertSegmentsSorted(IN PMM_IMAGE_SECTION_OBJECT ImageSectionObject)
3233 {
3234 ULONG i;
3235
3236 for( i = 1; i < ImageSectionObject->NrSegments; ++ i )
3237 {
3238 ASSERT(ImageSectionObject->Segments[i].Image.VirtualAddress >=
3239 ImageSectionObject->Segments[i - 1].Image.VirtualAddress);
3240 }
3241 }
3242
3243 static
3244 VOID
3245 NTAPI
3246 MmspAssertSegmentsNoOverlap(IN PMM_IMAGE_SECTION_OBJECT ImageSectionObject)
3247 {
3248 ULONG i;
3249
3250 MmspAssertSegmentsSorted(ImageSectionObject);
3251
3252 for( i = 0; i < ImageSectionObject->NrSegments; ++ i )
3253 {
3254 ASSERT(ImageSectionObject->Segments[i].Length.QuadPart > 0);
3255
3256 if(i > 0)
3257 {
3258 ASSERT(ImageSectionObject->Segments[i].Image.VirtualAddress >=
3259 (ImageSectionObject->Segments[i - 1].Image.VirtualAddress +
3260 ImageSectionObject->Segments[i - 1].Length.QuadPart));
3261 }
3262 }
3263 }
3264
3265 static
3266 VOID
3267 NTAPI
3268 MmspAssertSegmentsPageAligned(IN PMM_IMAGE_SECTION_OBJECT ImageSectionObject)
3269 {
3270 ULONG i;
3271
3272 for( i = 0; i < ImageSectionObject->NrSegments; ++ i )
3273 {
3274 ASSERT((ImageSectionObject->Segments[i].Image.VirtualAddress % PAGE_SIZE) == 0);
3275 ASSERT((ImageSectionObject->Segments[i].Length.QuadPart % PAGE_SIZE) == 0);
3276 }
3277 }
3278 #endif
3279
3280 static
3281 int
3282 __cdecl
3283 MmspCompareSegments(const void * x,
3284 const void * y)
3285 {
3286 const MM_SECTION_SEGMENT *Segment1 = (const MM_SECTION_SEGMENT *)x;
3287 const MM_SECTION_SEGMENT *Segment2 = (const MM_SECTION_SEGMENT *)y;
3288
3289 return
3290 (Segment1->Image.VirtualAddress - Segment2->Image.VirtualAddress) >>
3291 ((sizeof(ULONG_PTR) - sizeof(int)) * 8);
3292 }
3293
3294 /*
3295 * Ensures an image section's segments are sorted in memory
3296 */
3297 static
3298 VOID
3299 NTAPI
3300 MmspSortSegments(IN OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject,
3301 IN ULONG Flags)
3302 {
3303 if (Flags & EXEFMT_LOAD_ASSUME_SEGMENTS_SORTED)
3304 {
3305 MmspAssertSegmentsSorted(ImageSectionObject);
3306 }
3307 else
3308 {
3309 qsort(ImageSectionObject->Segments,
3310 ImageSectionObject->NrSegments,
3311 sizeof(ImageSectionObject->Segments[0]),
3312 MmspCompareSegments);
3313 }
3314 }
3315
3316
3317 /*
3318 * Ensures an image section's segments don't overlap in memory and don't have
3319 * gaps and don't have a null size. We let them map to overlapping file regions,
3320 * though - that's not necessarily an error
3321 */
3322 static
3323 BOOLEAN
3324 NTAPI
3325 MmspCheckSegmentBounds
3326 (
3327 IN OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject,
3328 IN ULONG Flags
3329 )
3330 {
3331 ULONG i;
3332
3333 if (Flags & EXEFMT_LOAD_ASSUME_SEGMENTS_NO_OVERLAP)
3334 {
3335 MmspAssertSegmentsNoOverlap(ImageSectionObject);
3336 return TRUE;
3337 }
3338
3339 ASSERT(ImageSectionObject->NrSegments >= 1);
3340
3341 for ( i = 0; i < ImageSectionObject->NrSegments; ++ i )
3342 {
3343 if(ImageSectionObject->Segments[i].Length.QuadPart == 0)
3344 {
3345 return FALSE;
3346 }
3347
3348 if(i > 0)
3349 {
3350 /*
3351 * TODO: relax the limitation on gaps. For example, gaps smaller than a
3352 * page could be OK (Windows seems to be OK with them), and larger gaps
3353 * could lead to image sections spanning several discontiguous regions
3354 * (NtMapViewOfSection could then refuse to map them, and they could
3355 * e.g. only be allowed as parameters to NtCreateProcess, like on UNIX)
3356 */
3357 if ((ImageSectionObject->Segments[i - 1].Image.VirtualAddress +
3358 ImageSectionObject->Segments[i - 1].Length.QuadPart) !=
3359 ImageSectionObject->Segments[i].Image.VirtualAddress)
3360 {
3361 return FALSE;
3362 }
3363 }
3364 }
3365
3366 return TRUE;
3367 }
3368
3369 /*
3370 * Merges and pads an image section's segments until they all are page-aligned
3371 * and have a size that is a multiple of the page size
3372 */
3373 static
3374 BOOLEAN
3375 NTAPI
3376 MmspPageAlignSegments
3377 (
3378 IN OUT PMM_IMAGE_SECTION_OBJECT ImageSectionObject,
3379 IN ULONG Flags
3380 )
3381 {
3382 ULONG i;
3383 ULONG LastSegment;
3384 PMM_SECTION_SEGMENT EffectiveSegment;
3385
3386 if (Flags & EXEFMT_LOAD_ASSUME_SEGMENTS_PAGE_ALIGNED)
3387 {
3388 MmspAssertSegmentsPageAligned(ImageSectionObject);
3389 return TRUE;
3390 }
3391
3392 LastSegment = 0;
3393 EffectiveSegment = &ImageSectionObject->Segments[LastSegment];
3394
3395 for ( i = 0; i < ImageSectionObject->NrSegments; ++ i )
3396 {
3397 /*
3398 * The first segment requires special handling
3399 */
3400 if (i == 0)
3401 {
3402 ULONG_PTR VirtualAddress;
3403 ULONG_PTR VirtualOffset;
3404
3405 VirtualAddress = EffectiveSegment->Image.VirtualAddress;
3406
3407 /* Round down the virtual address to the nearest page */
3408 EffectiveSegment->Image.VirtualAddress = PAGE_ROUND_DOWN(VirtualAddress);
3409
3410 /* Round up the virtual size to the nearest page */
3411 EffectiveSegment->Length.QuadPart = PAGE_ROUND_UP(VirtualAddress + EffectiveSegment->Length.QuadPart) -
3412 EffectiveSegment->Image.VirtualAddress;
3413
3414 /* Adjust the raw address and size */
3415 VirtualOffset = VirtualAddress - EffectiveSegment->Image.VirtualAddress;
3416
3417 if (EffectiveSegment->Image.FileOffset < VirtualOffset)
3418 {
3419 return FALSE;
3420 }
3421
3422 /*
3423 * Garbage in, garbage out: unaligned base addresses make the file
3424 * offset point in curious and odd places, but that's what we were
3425 * asked for
3426 */
3427 EffectiveSegment->Image.FileOffset -= VirtualOffset;
3428 EffectiveSegment->RawLength.QuadPart += VirtualOffset;
3429 }
3430 else
3431 {
3432 PMM_SECTION_SEGMENT Segment = &ImageSectionObject->Segments[i];
3433 ULONG_PTR EndOfEffectiveSegment;
3434
3435 EndOfEffectiveSegment = (ULONG_PTR)(EffectiveSegment->Image.VirtualAddress + EffectiveSegment->Length.QuadPart);
3436 ASSERT((EndOfEffectiveSegment % PAGE_SIZE) == 0);
3437
3438 /*
3439 * The current segment begins exactly where the current effective
3440 * segment ended, therefore beginning a new effective segment
3441 */
3442 if (EndOfEffectiveSegment == Segment->Image.VirtualAddress)
3443 {
3444 LastSegment ++;
3445 ASSERT(LastSegment <= i);
3446 ASSERT(LastSegment < ImageSectionObject->NrSegments);
3447
3448 EffectiveSegment = &ImageSectionObject->Segments[LastSegment];
3449
3450 if (LastSegment != i)
3451 {
3452 /*
3453 * Copy the current segment. If necessary, the effective segment
3454 * will be expanded later
3455 */
3456 *EffectiveSegment = *Segment;
3457 }
3458
3459 /*
3460 * Page-align the virtual size. We know for sure the virtual address
3461 * already is
3462 */
3463 ASSERT((EffectiveSegment->Image.VirtualAddress % PAGE_SIZE) == 0);
3464 EffectiveSegment->Length.QuadPart = PAGE_ROUND_UP(EffectiveSegment->Length.QuadPart);
3465 }
3466 /*
3467 * The current segment is still part of the current effective segment:
3468 * extend the effective segment to reflect this
3469 */
3470 else if (EndOfEffectiveSegment > Segment->Image.VirtualAddress)
3471 {
3472 static const ULONG FlagsToProtection[16] =
3473 {
3474 PAGE_NOACCESS,
3475 PAGE_READONLY,
3476 PAGE_READWRITE,
3477 PAGE_READWRITE,
3478 PAGE_EXECUTE_READ,
3479 PAGE_EXECUTE_READ,
3480 PAGE_EXECUTE_READWRITE,
3481 PAGE_EXECUTE_READWRITE,
3482 PAGE_WRITECOPY,
3483 PAGE_WRITECOPY,
3484 PAGE_WRITECOPY,
3485 PAGE_WRITECOPY,
3486 PAGE_EXECUTE_WRITECOPY,
3487 PAGE_EXECUTE_WRITECOPY,
3488 PAGE_EXECUTE_WRITECOPY,
3489 PAGE_EXECUTE_WRITECOPY
3490 };
3491
3492 unsigned ProtectionFlags;
3493
3494 /*
3495 * Extend the file size
3496 */
3497
3498 /* Unaligned segments must be contiguous within the file */
3499 if (Segment->Image.FileOffset != (EffectiveSegment->Image.FileOffset +
3500 EffectiveSegment->RawLength.QuadPart))
3501 {
3502 return FALSE;
3503 }
3504
3505 EffectiveSegment->RawLength.QuadPart += Segment->RawLength.QuadPart;
3506
3507 /*
3508 * Extend the virtual size
3509 */
3510 ASSERT(PAGE_ROUND_UP(Segment->Image.VirtualAddress + Segment->Length.QuadPart) >= EndOfEffectiveSegment);
3511
3512 EffectiveSegment->Length.QuadPart = PAGE_ROUND_UP(Segment->Image.VirtualAddress + Segment->Length.QuadPart) -
3513 EffectiveSegment->Image.VirtualAddress;
3514
3515 /*
3516 * Merge the protection
3517 */
3518 EffectiveSegment->Protection |= Segment->Protection;
3519
3520 /* Clean up redundance */
3521 ProtectionFlags = 0;
3522
3523 if(EffectiveSegment->Protection & PAGE_IS_READABLE)
3524 ProtectionFlags |= 1 << 0;
3525
3526 if(EffectiveSegment->Protection & PAGE_IS_WRITABLE)
3527 ProtectionFlags |= 1 << 1;
3528
3529 if(EffectiveSegment->Protection & PAGE_IS_EXECUTABLE)
3530 ProtectionFlags |= 1 << 2;
3531
3532 if(EffectiveSegment->Protection & PAGE_IS_WRITECOPY)
3533 ProtectionFlags |= 1 << 3;
3534
3535 ASSERT(ProtectionFlags < 16);
3536 EffectiveSegment->Protection = FlagsToProtection[ProtectionFlags];
3537
3538 /* If a segment was required to be shared and cannot, fail */
3539 if(!(Segment->Protection & PAGE_IS_WRITECOPY) &&
3540 EffectiveSegment->Protection & PAGE_IS_WRITECOPY)
3541 {
3542 return FALSE;
3543 }
3544 }
3545 /*
3546 * We assume no holes between segments at this point
3547 */
3548 else
3549 {
3550 KeBugCheck(MEMORY_MANAGEMENT);
3551 }
3552 }
3553 }
3554 ImageSectionObject->NrSegments = LastSegment + 1;
3555
3556 return TRUE;
3557 }
3558
3559 NTSTATUS
3560 ExeFmtpCreateImageSection(PFILE_OBJECT FileObject,
3561 PMM_IMAGE_SECTION_OBJECT ImageSectionObject)
3562 {
3563 LARGE_INTEGER Offset;
3564 PVOID FileHeader;
3565 PVOID FileHeaderBuffer;
3566 ULONG FileHeaderSize;
3567 ULONG Flags;
3568 ULONG OldNrSegments;
3569 NTSTATUS Status;
3570 ULONG i;
3571
3572 /*
3573 * Read the beginning of the file (2 pages). Should be enough to contain
3574 * all (or most) of the headers
3575 */
3576 Offset.QuadPart = 0;
3577
3578 Status = ExeFmtpReadFile (FileObject,
3579 &Offset,
3580 PAGE_SIZE * 2,
3581 &FileHeader,
3582 &FileHeaderBuffer,
3583 &FileHeaderSize);
3584
3585 if (!NT_SUCCESS(Status))
3586 return Status;
3587
3588 if (FileHeaderSize == 0)
3589 {
3590 ExFreePool(FileHeaderBuffer);
3591 return STATUS_UNSUCCESSFUL;
3592 }
3593
3594 /*
3595 * Look for a loader that can handle this executable
3596 */
3597 for (i = 0; i < RTL_NUMBER_OF(ExeFmtpLoaders); ++ i)
3598 {
3599 RtlZeroMemory(ImageSectionObject, sizeof(*ImageSectionObject));
3600 Flags = 0;
3601
3602 Status = ExeFmtpLoaders[i](FileHeader,
3603 FileHeaderSize,
3604 FileObject,
3605 ImageSectionObject,
3606 &Flags,
3607 ExeFmtpReadFile,
3608 ExeFmtpAllocateSegments);
3609
3610 if (!NT_SUCCESS(Status))
3611 {
3612 if (ImageSectionObject->Segments)
3613 {
3614 ExFreePool(ImageSectionObject->Segments);
3615 ImageSectionObject->Segments = NULL;
3616 }
3617 }
3618
3619 if (Status != STATUS_ROS_EXEFMT_UNKNOWN_FORMAT)
3620 break;
3621 }
3622
3623 ExFreePoolWithTag(FileHeaderBuffer, 'rXmM');
3624
3625 /*
3626 * No loader handled the format
3627 */
3628 if (Status == STATUS_ROS_EXEFMT_UNKNOWN_FORMAT)
3629 {
3630 Status = STATUS_INVALID_IMAGE_NOT_MZ;
3631 ASSERT(!NT_SUCCESS(Status));
3632 }
3633
3634 if (!NT_SUCCESS(Status))
3635 return Status;
3636
3637 ASSERT(ImageSectionObject->Segments != NULL);
3638
3639 /*
3640 * Some defaults
3641 */
3642 /* FIXME? are these values platform-dependent? */
3643 if (ImageSectionObject->ImageInformation.MaximumStackSize == 0)
3644 ImageSectionObject->ImageInformation.MaximumStackSize = 0x40000;
3645
3646 if(ImageSectionObject->ImageInformation.CommittedStackSize == 0)
3647 ImageSectionObject->ImageInformation.CommittedStackSize = 0x1000;
3648
3649 if(ImageSectionObject->BasedAddress == NULL)
3650 {
3651 if(ImageSectionObject->ImageInformation.ImageCharacteristics & IMAGE_FILE_DLL)
3652 ImageSectionObject->BasedAddress = (PVOID)0x10000000;
3653 else
3654 ImageSectionObject->BasedAddress = (PVOID)0x00400000;
3655 }
3656
3657 /*
3658 * And now the fun part: fixing the segments
3659 */
3660
3661 /* Sort them by virtual address */
3662 MmspSortSegments(ImageSectionObject, Flags);
3663
3664 /* Ensure they don't overlap in memory */
3665 if (!MmspCheckSegmentBounds(ImageSectionObject, Flags))
3666 return STATUS_INVALID_IMAGE_FORMAT;
3667
3668 /* Ensure they are aligned */
3669 OldNrSegments = ImageSectionObject->NrSegments;
3670
3671 if (!MmspPageAlignSegments(ImageSectionObject, Flags))
3672 return STATUS_INVALID_IMAGE_FORMAT;
3673
3674 /* Trim them if the alignment phase merged some of them */
3675 if (ImageSectionObject->NrSegments < OldNrSegments)
3676 {
3677 PMM_SECTION_SEGMENT Segments;
3678 SIZE_T SizeOfSegments;
3679
3680 SizeOfSegments = sizeof(MM_SECTION_SEGMENT) * ImageSectionObject->NrSegments;
3681
3682 Segments = ExAllocatePoolWithTag(PagedPool,
3683 SizeOfSegments,
3684 TAG_MM_SECTION_SEGMENT);
3685
3686 if (Segments == NULL)
3687 return STATUS_INSUFFICIENT_RESOURCES;
3688
3689 RtlCopyMemory(Segments, ImageSectionObject->Segments, SizeOfSegments);
3690 ExFreePool(ImageSectionObject->Segments);
3691 ImageSectionObject->Segments = Segments;
3692 }
3693
3694 /* And finish their initialization */
3695 for ( i = 0; i < ImageSectionObject->NrSegments; ++ i )
3696 {
3697 ExInitializeFastMutex(&ImageSectionObject->Segments[i].Lock);
3698 ImageSectionObject->Segments[i].ReferenceCount = 1;
3699 MiInitializeSectionPageTable(&ImageSectionObject->Segments[i]);
3700 }
3701
3702 ASSERT(NT_SUCCESS(Status));
3703 return Status;
3704 }
3705
3706 NTSTATUS
3707 MmCreateImageSection(PROS_SECTION_OBJECT *SectionObject,
3708 ACCESS_MASK DesiredAccess,
3709 POBJECT_ATTRIBUTES ObjectAttributes,
3710 PLARGE_INTEGER UMaximumSize,
3711 ULONG SectionPageProtection,
3712 ULONG AllocationAttributes,
3713 PFILE_OBJECT FileObject)
3714 {
3715 PROS_SECTION_OBJECT Section;
3716 NTSTATUS Status;
3717 PMM_SECTION_SEGMENT SectionSegments;
3718 PMM_IMAGE_SECTION_OBJECT ImageSectionObject;
3719 ULONG i;
3720
3721 if (FileObject == NULL)
3722 return STATUS_INVALID_FILE_FOR_SECTION;
3723
3724 #ifndef NEWCC
3725 if (FileObject->SectionObjectPointer->SharedCacheMap == NULL)
3726 {
3727 DPRINT1("Denying section creation due to missing cache initialization\n");
3728 return STATUS_INVALID_FILE_FOR_SECTION;
3729 }
3730 #endif
3731
3732 /*
3733 * Create the section
3734 */
3735 Status = ObCreateObject (ExGetPreviousMode(),
3736 MmSectionObjectType,
3737 ObjectAttributes,
3738 ExGetPreviousMode(),
3739 NULL,
3740 sizeof(ROS_SECTION_OBJECT),
3741 0,
3742 0,
3743 (PVOID*)(PVOID)&Section);
3744 if (!NT_SUCCESS(Status))
3745 {
3746 ObDereferenceObject(FileObject);
3747 return(Status);
3748 }
3749
3750 /*
3751 * Initialize it
3752 */
3753 RtlZeroMemory(Section, sizeof(ROS_SECTION_OBJECT));
3754 Section->Type = 'SC';
3755 Section->Size = 'TN';
3756 Section->SectionPageProtection = SectionPageProtection;
3757 Section->AllocationAttributes = AllocationAttributes;
3758
3759 if (FileObject->SectionObjectPointer->ImageSectionObject == NULL)
3760 {
3761 NTSTATUS StatusExeFmt;
3762
3763 ImageSectionObject = ExAllocatePoolWithTag(PagedPool, sizeof(MM_IMAGE_SECTION_OBJECT), TAG_MM_SECTION_SEGMENT);
3764 if (ImageSectionObject == NULL)
3765 {
3766 ObDereferenceObject(FileObject);
3767 ObDereferenceObject(Section);
3768 return(STATUS_NO_MEMORY);
3769 }
3770
3771 RtlZeroMemory(ImageSectionObject, sizeof(MM_IMAGE_SECTION_OBJECT));
3772
3773 StatusExeFmt = ExeFmtpCreateImageSection(FileObject, ImageSectionObject);
3774
3775 if (!NT_SUCCESS(StatusExeFmt))
3776 {
3777 if(ImageSectionObject->Segments != NULL)
3778 ExFreePool(ImageSectionObject->Segments);
3779
3780 /*
3781 * If image file is empty, then return that the file is invalid for section
3782 */
3783 Status = StatusExeFmt;
3784 if (StatusExeFmt == STATUS_END_OF_FILE)
3785 {
3786 Status = STATUS_INVALID_FILE_FOR_SECTION;
3787 }
3788
3789 ExFreePoolWithTag(ImageSectionObject, TAG_MM_SECTION_SEGMENT);
3790 ObDereferenceObject(Section);
3791 ObDereferenceObject(FileObject);
3792 return(Status);
3793 }
3794
3795 Section->ImageSection = ImageSectionObject;
3796 ASSERT(ImageSectionObject->Segments);
3797
3798 /*
3799 * Lock the file
3800 */
3801 Status = MmspWaitForFileLock(FileObject);
3802 if (!NT_SUCCESS(Status))
3803 {
3804 ExFreePool(ImageSectionObject->Segments);
3805 ExFreePool(ImageSectionObject);
3806 ObDereferenceObject(Section);
3807 ObDereferenceObject(FileObject);
3808 return(Status);
3809 }
3810
3811 if (NULL != InterlockedCompareExchangePointer(&FileObject->SectionObjectPointer->ImageSectionObject,
3812 ImageSectionObject, NULL))
3813 {
3814 /*
3815 * An other thread has initialized the same image in the background
3816 */
3817 ExFreePool(ImageSectionObject->Segments);
3818 ExFreePool(ImageSectionObject);
3819 ImageSectionObject = FileObject->SectionObjectPointer->ImageSectionObject;
3820 Section->ImageSection = ImageSectionObject;
3821 SectionSegments = ImageSectionObject->Segments;
3822
3823 for (i = 0; i < ImageSectionObject->NrSegments; i++)
3824 {
3825 (void)InterlockedIncrementUL(&SectionSegments[i].ReferenceCount);
3826 }
3827 }
3828
3829 Status = StatusExeFmt;
3830 }
3831 else
3832 {
3833 /*
3834 * Lock the file
3835 */
3836 Status = MmspWaitForFileLock(FileObject);
3837 if (Status != STATUS_SUCCESS)
3838 {
3839 ObDereferenceObject(Section);
3840 ObDereferenceObject(FileObject);
3841 return(Status);
3842 }
3843
3844 ImageSectionObject = FileObject->SectionObjectPointer->ImageSectionObject;
3845 Section->ImageSection = ImageSectionObject;
3846 SectionSegments = ImageSectionObject->Segments;
3847
3848 /*
3849 * Otherwise just reference all the section segments
3850 */
3851 for (i = 0; i < ImageSectionObject->NrSegments; i++)
3852 {
3853 (void)InterlockedIncrementUL(&SectionSegments[i].ReferenceCount);
3854 }
3855
3856 Status = STATUS_SUCCESS;
3857 }
3858 Section->FileObject = FileObject;
3859 #ifndef NEWCC
3860 CcRosReferenceCache(FileObject);
3861 #endif
3862 //KeSetEvent((PVOID)&FileObject->Lock, IO_NO_INCREMENT, FALSE);
3863 *SectionObject = Section;
3864 return(Status);
3865 }
3866
3867
3868
3869 static NTSTATUS
3870 MmMapViewOfSegment(PMMSUPPORT AddressSpace,
3871 PROS_SECTION_OBJECT Section,
3872 PMM_SECTION_SEGMENT Segment,
3873 PVOID* BaseAddress,
3874 SIZE_T ViewSize,
3875 ULONG Protect,
3876 ULONG ViewOffset,
3877 ULONG AllocationType)
3878 {
3879 PMEMORY_AREA MArea;
3880 NTSTATUS Status;
3881 ULONG Granularity;
3882
3883 if (Segment->WriteCopy)
3884 {
3885 /* We have to do this because the not present fault
3886 * and access fault handlers depend on the protection
3887 * that should be granted AFTER the COW fault takes
3888 * place to be in Region->Protect. The not present fault
3889 * handler changes this to the correct protection for COW when
3890 * mapping the pages into the process's address space. If a COW
3891 * fault takes place, the access fault handler sets the page protection
3892 * to these values for the newly copied pages
3893 */
3894 if (Protect == PAGE_WRITECOPY)
3895 Protect = PAGE_READWRITE;
3896 else if (Protect == PAGE_EXECUTE_WRITECOPY)
3897 Protect = PAGE_EXECUTE_READWRITE;
3898 }
3899
3900 if (*BaseAddress == NULL)
3901 Granularity = MM_ALLOCATION_GRANULARITY;
3902 else
3903 Granularity = PAGE_SIZE;
3904
3905 #ifdef NEWCC
3906 if (Segment->Flags & MM_DATAFILE_SEGMENT)
3907 {
3908 LARGE_INTEGER FileOffset;
3909 FileOffset.QuadPart = ViewOffset;
3910 ObReferenceObject(Section);
3911 return _MiMapViewOfSegment(AddressSpace, Segment, BaseAddress, ViewSize, Protect, &FileOffset, AllocationType, __FILE__, __LINE__);
3912 }
3913 #endif
3914 Status = MmCreateMemoryArea(AddressSpace,
3915 MEMORY_AREA_SECTION_VIEW,
3916 BaseAddress,
3917 ViewSize,
3918 Protect,
3919 &MArea,
3920 AllocationType,
3921 Granularity);
3922 if (!NT_SUCCESS(Status))
3923 {
3924 DPRINT1("Mapping between 0x%p and 0x%p failed (%X).\n",
3925 (*BaseAddress), (char*)(*BaseAddress) + ViewSize, Status);
3926 return(Status);
3927 }
3928
3929 ObReferenceObject((PVOID)Section);
3930
3931 MArea->Data.SectionData.Segment = Segment;
3932 MArea->Data.SectionData.Section = Section;
3933 MArea->Data.SectionData.ViewOffset.QuadPart = ViewOffset;
3934 if (Section->AllocationAttributes & SEC_IMAGE)
3935 {
3936 MArea->VadNode.u.VadFlags.VadType = VadImageMap;
3937 }
3938
3939 MmInitializeRegion(&MArea->Data.SectionData.RegionListHead,
3940 ViewSize, 0, Protect);
3941
3942 return(STATUS_SUCCESS);
3943 }
3944
3945
3946 static VOID
3947 MmFreeSectionPage(PVOID Context, MEMORY_AREA* MemoryArea, PVOID Address,
3948 PFN_NUMBER Page, SWAPENTRY SwapEntry, BOOLEAN Dirty)
3949 {
3950 ULONG_PTR Entry;
3951 #ifndef NEWCC
3952 PFILE_OBJECT FileObject;
3953 PROS_SHARED_CACHE_MAP SharedCacheMap;
3954 #endif
3955 LARGE_INTEGER Offset;
3956 SWAPENTRY SavedSwapEntry;
3957 PROS_SECTION_OBJECT Section;
3958 PMM_SECTION_SEGMENT Segment;
3959 PMMSUPPORT AddressSpace;
3960 PEPROCESS Process;
3961
3962 AddressSpace = (PMMSUPPORT)Context;
3963 Process = MmGetAddressSpaceOwner(AddressSpace);
3964
3965 Address = (PVOID)PAGE_ROUND_DOWN(Address);
3966
3967 Offset.QuadPart = ((ULONG_PTR)Address - MA_GetStartingAddress(MemoryArea)) +
3968 MemoryArea->Data.SectionData.ViewOffset.QuadPart;
3969
3970 Section = MemoryArea->Data.SectionData.Section;
3971 Segment = MemoryArea->Data.SectionData.Segment;
3972
3973 Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
3974 while (Entry && MM_IS_WAIT_PTE(Entry))
3975 {
3976 MmUnlockSectionSegment(Segment);
3977 MmUnlockAddressSpace(AddressSpace);
3978
3979 MiWaitForPageEvent(NULL, NULL);
3980
3981 MmLockAddressSpace(AddressSpace);
3982 MmLockSectionSegment(Segment);
3983 Entry = MmGetPageEntrySectionSegment(Segment, &Offset);
3984 }
3985
3986 /*
3987 * For a dirty, datafile, non-private page mark it as dirty in the
3988 * cache manager.
3989 */
3990 if (Segment->Flags & MM_DATAFILE_SEGMENT)
3991 {
3992 if (Page == PFN_FROM_SSE(Entry) && Dirty)
3993 {
3994 #ifndef NEWCC
3995 FileObject = MemoryArea->Data.SectionData.Section->FileObject;
3996 SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
3997 CcRosMarkDirtyFile(SharedCacheMap, Offset.QuadPart + Segment->Image.FileOffset);
3998 #endif
3999 ASSERT(SwapEntry == 0);
4000 }
4001 }
4002
4003 if (SwapEntry != 0)
4004 {
4005 /*
4006 * Sanity check
4007 */
4008 if (Segment->Flags & MM_PAGEFILE_SEGMENT)
4009 {
4010 DPRINT1("Found a swap entry for a page in a pagefile section.\n");
4011 KeBugCheck(MEMORY_MANAGEMENT);
4012 }
4013 MmFreeSwapPage(SwapEntry);
4014 }
4015 else if (Page != 0)
4016 {
4017 if (IS_SWAP_FROM_SSE(Entry) ||
4018 Page != PFN_FROM_SSE(Entry))
4019 {
4020 /*
4021 * Sanity check
4022 */
4023 if (Segment->Flags & MM_PAGEFILE_SEGMENT)
4024 {
4025 DPRINT1("Found a private page in a pagefile section.\n");
4026 KeBugCheck(MEMORY_MANAGEMENT);
4027 }
4028 /*
4029 * Just dereference private pages
4030 */
4031 SavedSwapEntry = MmGetSavedSwapEntryPage(Page);
4032 if (SavedSwapEntry != 0)
4033 {
4034 MmFreeSwapPage(SavedSwapEntry);
4035 MmSetSavedSwapEntryPage(Page, 0);
4036 }
4037 MmDeleteRmap(Page, Process, Address);
4038 MmReleasePageMemoryConsumer(MC_USER, Page);
4039 }
4040 else
4041 {
4042 MmDeleteRmap(Page, Process, Address);
4043 MmUnsharePageEntrySectionSegment(Section, Segment, &Offset, Dirty, FALSE, NULL);
4044 }
4045 }
4046 }
4047
4048 static NTSTATUS
4049 MmUnmapViewOfSegment(PMMSUPPORT AddressSpace,
4050 PVOID BaseAddress)
4051 {
4052 NTSTATUS Status;
4053 PMEMORY_AREA MemoryArea;
4054 PROS_SECTION_OBJECT Section;
4055 PMM_SECTION_SEGMENT Segment;
4056 PLIST_ENTRY CurrentEntry;
4057 PMM_REGION CurrentRegion;
4058 PLIST_ENTRY RegionListHead;
4059
4060 MemoryArea = MmLocateMemoryAreaByAddress(AddressSpace,
4061 BaseAddress);
4062 if (MemoryArea == NULL)
4063 {
4064 return(STATUS_UNSUCCESSFUL);
4065 }
4066
4067 Section = MemoryArea->Data.SectionData.Section;
4068 Segment = MemoryArea->Data.SectionData.Segment;
4069
4070 #ifdef NEWCC
4071 if (Segment->Flags & MM_DATAFILE_SEGMENT)
4072 {
4073 MmUnlockAddressSpace(AddressSpace);
4074 Status = MmUnmapViewOfCacheSegment(AddressSpace, BaseAddress);
4075 MmLockAddressSpace(AddressSpace);
4076
4077 return Status;
4078 }
4079 #endif
4080
4081 MemoryArea->DeleteInProgress = TRUE;
4082
4083 MmLockSectionSegment(Segment);
4084
4085 RegionListHead = &MemoryArea->Data.SectionData.RegionListHead;
4086 while (!IsListEmpty(RegionListHead))
4087 {
4088 CurrentEntry = RemoveHeadList(RegionListHead);
4089 CurrentRegion = CONTAINING_RECORD(CurrentEntry, MM_REGION, RegionListEntry);
4090 ExFreePoolWithTag(CurrentRegion, TAG_MM_REGION);
4091 }
4092
4093 if (Section->AllocationAttributes & SEC_PHYSICALMEMORY)
4094 {
4095 Status = MmFreeMemoryArea(AddressSpace,
4096 MemoryArea,
4097 NULL,
4098 NULL);
4099 }
4100 else
4101 {
4102 Status = MmFreeMemoryArea(AddressSpace,
4103 MemoryArea,
4104 MmFreeSectionPage,
4105 AddressSpace);
4106 }
4107 MmUnlockSectionSegment(Segment);
4108 ObDereferenceObject(Section);
4109 return(Status);
4110 }
4111
4112 NTSTATUS
4113 NTAPI
4114 MiRosUnmapViewOfSection(IN PEPROCESS Process,
4115 IN PVOID BaseAddress,
4116 IN BOOLEAN SkipDebuggerNotify)
4117 {
4118 NTSTATUS Status;
4119 PMEMORY_AREA MemoryArea;
4120 PMMSUPPORT AddressSpace;
4121 PROS_SECTION_OBJECT Section;
4122 PVOID ImageBaseAddress = 0;
4123
4124 DPRINT("Opening memory area Process %p BaseAddress %p\n",
4125 Process, BaseAddress);
4126
4127 ASSERT(Process);
4128
4129 AddressSpace = Process ? &Process->Vm : MmGetKernelAddressSpace();
4130
4131 MmLockAddressSpace(AddressSpace);
4132 MemoryArea = MmLocateMemoryAreaByAddress(AddressSpace,
4133 BaseAddress);
4134 if (MemoryArea == NULL ||
4135 ((MemoryArea->Type != MEMORY_AREA_SECTION_VIEW) &&
4136 (MemoryArea->Type != MEMORY_AREA_CACHE)) ||
4137 MemoryArea->DeleteInProgress)
4138 {
4139 if (MemoryArea) ASSERT(MemoryArea->Type != MEMORY_AREA_OWNED_BY_ARM3);
4140 MmUnlockAddressSpace(AddressSpace);
4141 return STATUS_NOT_MAPPED_VIEW;
4142 }
4143
4144 Section = MemoryArea->Data.SectionData.Section;
4145
4146 if ((Section != NULL) && (Section->AllocationAttributes & SEC_IMAGE))
4147 {
4148 ULONG i;
4149 ULONG NrSegments;
4150 PMM_IMAGE_SECTION_OBJECT ImageSectionObject;
4151 PMM_SECTION_SEGMENT SectionSegments;
4152 PMM_SECTION_SEGMENT Segment;
4153
4154 Segment = MemoryArea->Data.SectionData.Segment;
4155 ImageSectionObject = Section->ImageSection;
4156 SectionSegments = ImageSectionObject->Segments;
4157 NrSegments = ImageSectionObject->NrSegments;
4158
4159 MemoryArea->DeleteInProgress = TRUE;
4160
4161 /* Search for the current segment within the section segments
4162 * and calculate the image base address */
4163 for (i = 0; i < NrSegments; i++)
4164 {
4165 if (Segment == &SectionSegments[i])
4166 {
4167 ImageBaseAddress = (char*)BaseAddress - (ULONG_PTR)SectionSegments[i].Image.VirtualAddress;
4168 break;
4169 }
4170 }
4171 if (i >= NrSegments)
4172 {
4173 KeBugCheck(MEMORY_MANAGEMENT);
4174 }
4175
4176 for (i = 0; i < NrSegments; i++)
4177 {
4178 PVOID SBaseAddress = (PVOID)
4179 ((char*)ImageBaseAddress + (ULONG_PTR)SectionSegments[i].Image.VirtualAddress);
4180
4181 Status = MmUnmapViewOfSegment(AddressSpace, SBaseAddress);
4182 if (!NT_SUCCESS(Status))
4183 {
4184 DPRINT1("MmUnmapViewOfSegment failed for %p (Process %p) with %lx\n",
4185 SBaseAddress, Process, Status);
4186 ASSERT(NT_SUCCESS(Status));
4187 }
4188 }
4189 }
4190 else
4191 {
4192 Status = MmUnmapViewOfSegment(AddressSpace, BaseAddress);
4193 if (!NT_SUCCESS(Status))
4194 {
4195 DPRINT1("MmUnmapViewOfSegment failed for %p (Process %p) with %lx\n",
4196 BaseAddress, Process, Status);
4197 ASSERT(NT_SUCCESS(Status));
4198 }
4199 }
4200
4201 MmUnlockAddressSpace(AddressSpace);
4202
4203 /* Notify debugger */
4204 if (ImageBaseAddress && !SkipDebuggerNotify) DbgkUnMapViewOfSection(ImageBaseAddress);
4205
4206 return(STATUS_SUCCESS);
4207 }
4208
4209
4210
4211
4212 /**
4213 * Queries the information of a section object.
4214 *
4215 * @param SectionHandle
4216 * Handle to the section object. It must be opened with SECTION_QUERY
4217 * access.
4218 * @param SectionInformationClass
4219 * Index to a certain information structure. Can be either
4220 * SectionBasicInformation or SectionImageInformation. The latter
4221 * is valid only for sections that were created with the SEC_IMAGE
4222 * flag.
4223 * @param SectionInformation
4224 * Caller supplies storage for resulting information.
4225 * @param Length
4226 * Size of the supplied storage.
4227 * @param ResultLength
4228 * Data written.
4229 *
4230 * @return Status.
4231 *
4232 * @implemented
4233 */
4234 NTSTATUS
4235 NTAPI
4236 NtQuerySection(
4237 _In_ HANDLE SectionHandle,
4238 _In_ SECTION_INFORMATION_CLASS SectionInformationClass,
4239 _Out_ PVOID SectionInformation,
4240 _In_ SIZE_T SectionInformationLength,
4241 _Out_opt_ PSIZE_T ResultLength)
4242 {
4243 PSECTION Section;
4244 KPROCESSOR_MODE PreviousMode;
4245 NTSTATUS Status;
4246 PAGED_CODE();
4247
4248 PreviousMode = ExGetPreviousMode();
4249 if (PreviousMode != KernelMode)
4250 {
4251 _SEH2_TRY
4252 {
4253 ProbeForWrite(SectionInformation,
4254 SectionInformationLength,
4255 __alignof(ULONG));
4256 if (ResultLength != NULL)
4257 {
4258 ProbeForWrite(ResultLength,
4259 sizeof(*ResultLength),
4260 __alignof(SIZE_T));
4261 }
4262 }
4263 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
4264 {
4265 _SEH2_YIELD(return _SEH2_GetExceptionCode());
4266 }
4267 _SEH2_END;
4268 }
4269
4270 if (SectionInformationClass == SectionBasicInformation)
4271 {
4272 if (SectionInformationLength < sizeof(SECTION_BASIC_INFORMATION))
4273 {
4274 return STATUS_INFO_LENGTH_MISMATCH;
4275 }
4276 }
4277 else if (SectionInformationClass == SectionImageInformation)
4278 {
4279 if (SectionInformationLength < sizeof(SECTION_IMAGE_INFORMATION))
4280 {
4281 return STATUS_INFO_LENGTH_MISMATCH;
4282 }
4283 }
4284 else
4285 {
4286 return STATUS_INVALID_INFO_CLASS;
4287 }
4288
4289 Status = ObReferenceObjectByHandle(SectionHandle,
4290 SECTION_QUERY,
4291 MmSectionObjectType,
4292 PreviousMode,
4293 (PVOID*)(PVOID)&Section,
4294 NULL);
4295 if (!NT_SUCCESS(Status))
4296 {
4297 DPRINT1("Failed to reference section: 0x%lx\n", Status);
4298 return Status;
4299 }
4300
4301 if (MiIsRosSectionObject(Section))
4302 {
4303 PROS_SECTION_OBJECT RosSection = (PROS_SECTION_OBJECT)Section;
4304
4305 switch (SectionInformationClass)
4306 {
4307 case SectionBasicInformation:
4308 {
4309 PSECTION_BASIC_INFORMATION Sbi = (PSECTION_BASIC_INFORMATION)SectionInformation;
4310
4311 _SEH2_TRY
4312 {
4313 Sbi->Attributes = RosSection->AllocationAttributes;
4314 if (RosSection->AllocationAttributes & SEC_IMAGE)
4315 {
4316 Sbi->BaseAddress = 0;
4317 Sbi->Size.QuadPart = 0;
4318 }
4319 else
4320 {
4321 Sbi->BaseAddress = (PVOID)RosSection->Segment->Image.VirtualAddress;
4322 Sbi->Size.QuadPart = RosSection->Segment->Length.QuadPart;
4323 }
4324
4325 if (ResultLength != NULL)
4326 {
4327 *ResultLength = sizeof(SECTION_BASIC_INFORMATION);
4328 }
4329 Status = STATUS_SUCCESS;
4330 }
4331 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
4332 {
4333 Status = _SEH2_GetExceptionCode();
4334 }
4335 _SEH2_END;
4336
4337 break;
4338 }
4339
4340 case SectionImageInformation:
4341 {
4342 PSECTION_IMAGE_INFORMATION Sii = (PSECTION_IMAGE_INFORMATION)SectionInformation;
4343
4344 _SEH2_TRY
4345 {
4346 if (RosSection->AllocationAttributes & SEC_IMAGE)
4347 {
4348 PMM_IMAGE_SECTION_OBJECT ImageSectionObject;
4349 ImageSectionObject = RosSection->ImageSection;
4350
4351 *Sii = ImageSectionObject->ImageInformation;
4352 }
4353
4354 if (ResultLength != NULL)
4355 {
4356 *ResultLength = sizeof(SECTION_IMAGE_INFORMATION);
4357 }
4358 Status = STATUS_SUCCESS;
4359 }
4360 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
4361 {
4362 Status = _SEH2_GetExceptionCode();
4363 }
4364 _SEH2_END;
4365
4366 break;
4367 }
4368 }
4369 }
4370 else
4371 {
4372 switch(SectionInformationClass)
4373 {
4374 case SectionBasicInformation:
4375 {
4376 SECTION_BASIC_INFORMATION Sbi;
4377
4378 Sbi.Size = Section->SizeOfSection;
4379 Sbi.BaseAddress = (PVOID)Section->Address.StartingVpn;
4380
4381 Sbi.Attributes = 0;
4382 if (Section->u.Flags.Image)
4383 Sbi.Attributes |= SEC_IMAGE;
4384 if (Section->u.Flags.Commit)
4385 Sbi.Attributes |= SEC_COMMIT;
4386 if (Section->u.Flags.Reserve)
4387 Sbi.Attributes |= SEC_RESERVE;
4388 if (Section->u.Flags.File)
4389 Sbi.Attributes |= SEC_FILE;
4390 if (Section->u.Flags.Image)
4391 Sbi.Attributes |= SEC_IMAGE;
4392
4393 /* FIXME : Complete/test the list of flags passed back from NtCreateSection */
4394
4395 _SEH2_TRY
4396 {
4397 *((SECTION_BASIC_INFORMATION*)SectionInformation) = Sbi;
4398 if (ResultLength)
4399 *ResultLength = sizeof(Sbi);
4400 }
4401 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
4402 {
4403 Status = _SEH2_GetExceptionCode();
4404 }
4405 _SEH2_END;
4406 break;
4407 }
4408 case SectionImageInformation:
4409 {
4410 if (!Section->u.Flags.Image)
4411 {
4412 Status = STATUS_SECTION_NOT_IMAGE;
4413 }
4414 else
4415 {
4416 /* Currently not supported */
4417 ASSERT(FALSE);
4418 }
4419 break;
4420 }
4421 }
4422 }
4423
4424 ObDereferenceObject(Section);
4425
4426 return(Status);
4427 }
4428
4429 /**********************************************************************
4430 * NAME EXPORTED
4431 * MmMapViewOfSection
4432 *
4433 * DESCRIPTION
4434 * Maps a view of a section into the virtual address space of a
4435 * process.
4436 *
4437 * ARGUMENTS
4438 * Section
4439 * Pointer to the section object.
4440 *
4441 * ProcessHandle
4442 * Pointer to the process.
4443 *
4444 * BaseAddress
4445 * Desired base address (or NULL) on entry;
4446 * Actual base address of the view on exit.
4447 *
4448 * ZeroBits
4449 * Number of high order address bits that must be zero.
4450 *
4451 * CommitSize
4452 * Size in bytes of the initially committed section of
4453 * the view.
4454 *
4455 * SectionOffset
4456 * Offset in bytes from the beginning of the section
4457 * to the beginning of the view.
4458 *
4459 * ViewSize
4460 * Desired length of map (or zero to map all) on entry
4461 * Actual length mapped on exit.
4462 *
4463 * InheritDisposition
4464 * Specified how the view is to be shared with
4465 * child processes.
4466 *
4467 * AllocationType
4468 * Type of allocation for the pages.
4469 *
4470 * Protect
4471 * Protection for the committed region of the view.
4472 *
4473 * RETURN VALUE
4474 * Status.
4475 *
4476 * @implemented
4477 */
4478 NTSTATUS NTAPI
4479 MmMapViewOfSection(IN PVOID SectionObject,
4480 IN PEPROCESS Process,
4481 IN OUT PVOID *BaseAddress,
4482 IN ULONG_PTR ZeroBits,
4483 IN SIZE_T CommitSize,
4484 IN OUT PLARGE_INTEGER SectionOffset OPTIONAL,
4485 IN OUT PSIZE_T ViewSize,
4486 IN SECTION_INHERIT InheritDisposition,
4487 IN ULONG AllocationType,
4488 IN ULONG Protect)
4489 {
4490 PROS_SECTION_OBJECT Section;
4491 PMMSUPPORT AddressSpace;
4492 ULONG ViewOffset;
4493 NTSTATUS Status = STATUS_SUCCESS;
4494 BOOLEAN NotAtBase = FALSE;
4495
4496 if (MiIsRosSectionObject(SectionObject) == FALSE)
4497 {
4498 DPRINT("Mapping ARM3 section into %s\n", Process->ImageFileName);
4499 return MmMapViewOfArm3Section(SectionObject,
4500 Process,
4501 BaseAddress,
4502 ZeroBits,
4503 CommitSize,
4504 SectionOffset,
4505 ViewSize,
4506 InheritDisposition,
4507 AllocationType,
4508 Protect);
4509 }
4510
4511 ASSERT(Process);
4512
4513 if (!Protect || Protect & ~PAGE_FLAGS_VALID_FOR_SECTION)
4514 {
4515 return STATUS_INVALID_PAGE_PROTECTION;
4516 }
4517
4518 /* FIXME: We should keep this, but it would break code checking equality */
4519 Protect &= ~PAGE_NOCACHE;
4520
4521 Section = (PROS_SECTION_OBJECT)SectionObject;
4522 AddressSpace = &Process->Vm;
4523
4524 AllocationType |= (Section->AllocationAttributes & SEC_NO_CHANGE);
4525
4526 MmLockAddressSpace(AddressSpace);
4527
4528 if (Section->AllocationAttributes & SEC_IMAGE)
4529 {
4530 ULONG i;
4531 ULONG NrSegments;
4532 ULONG_PTR ImageBase;
4533 SIZE_T ImageSize;
4534 PMM_IMAGE_SECTION_OBJECT ImageSectionObject;
4535 PMM_SECTION_SEGMENT SectionSegments;
4536
4537 ImageSectionObject = Section->ImageSection;
4538 SectionSegments = ImageSectionObject->Segments;
4539 NrSegments = ImageSectionObject->NrSegments;
4540
4541 ImageBase = (ULONG_PTR)*BaseAddress;
4542 if (ImageBase == 0)
4543 {
4544 ImageBase = (ULONG_PTR)ImageSectionObject->BasedAddress;
4545 }
4546
4547 ImageSize = 0;
4548 for (i = 0; i < NrSegments; i++)
4549 {
4550 ULONG_PTR MaxExtent;
4551 MaxExtent = (ULONG_PTR)(SectionSegments[i].Image.VirtualAddress +
4552 SectionSegments[i].Length.QuadPart);
4553 ImageSize = max(ImageSize, MaxExtent);
4554 }
4555
4556 ImageSectionObject->ImageInformation.ImageFileSize = (ULONG)ImageSize;
4557
4558 /* Check for an illegal base address */
4559 if (((ImageBase + ImageSize) > (ULONG_PTR)MmHighestUserAddress) ||
4560 ((ImageBase + ImageSize) < ImageSize))
4561 {
4562 ASSERT(*BaseAddress == NULL);
4563 ImageBase = ALIGN_DOWN_BY((ULONG_PTR)MmHighestUserAddress - ImageSize,
4564 MM_VIRTMEM_GRANULARITY);
4565 NotAtBase = TRUE;
4566 }
4567 else if (ImageBase != ALIGN_DOWN_BY(ImageBase, MM_VIRTMEM_GRANULARITY))
4568 {
4569 ASSERT(*BaseAddress == NULL);
4570 ImageBase = ALIGN_DOWN_BY(ImageBase, MM_VIRTMEM_GRANULARITY);
4571 NotAtBase = TRUE;
4572 }
4573
4574 /* Check there is enough space to map the section at that point. */
4575 if (MmLocateMemoryAreaByRegion(AddressSpace, (PVOID)ImageBase,
4576 PAGE_ROUND_UP(ImageSize)) != NULL)
4577 {
4578 /* Fail if the user requested a fixed base address. */
4579 if ((*BaseAddress) != NULL)
4580 {
4581 MmUnlockAddressSpace(AddressSpace);
4582 return(STATUS_CONFLICTING_ADDRESSES);
4583 }
4584 /* Otherwise find a gap to map the image. */
4585 ImageBase = (ULONG_PTR)MmFindGap(AddressSpace, PAGE_ROUND_UP(ImageSize), MM_VIRTMEM_GRANULARITY, FALSE);
4586 if (ImageBase == 0)
4587 {
4588 MmUnlockAddressSpace(AddressSpace);
4589 return(STATUS_CONFLICTING_ADDRESSES);
4590 }
4591 /* Remember that we loaded image at a different base address */
4592 NotAtBase = TRUE;
4593 }
4594
4595 for (i = 0; i < NrSegments; i++)
4596 {
4597 PVOID SBaseAddress = (PVOID)
4598 ((char*)ImageBase + (ULONG_PTR)SectionSegments[i].Image.VirtualAddress);
4599 MmLockSectionSegment(&SectionSegments[i]);
4600 Status = MmMapViewOfSegment(AddressSpace,
4601 Section,
4602 &SectionSegments[i],
4603 &SBaseAddress,
4604 SectionSegments[i].Length.LowPart,
4605 SectionSegments[i].Protection,
4606 0,
4607 0);
4608 MmUnlockSectionSegment(&SectionSegments[i]);
4609 if (!NT_SUCCESS(Status))
4610 {
4611 MmUnlockAddressSpace(AddressSpace);
4612 return(Status);
4613 }
4614 }
4615
4616 *BaseAddress = (PVOID)ImageBase;
4617 *ViewSize = ImageSize;
4618 }
4619 else
4620 {
4621 /* check for write access */
4622 if ((Protect & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE)) &&
4623 !(Section->SectionPageProtection & (PAGE_READWRITE|PAGE_EXECUTE_READWRITE)))
4624 {
4625 MmUnlockAddressSpace(AddressSpace);
4626 return STATUS_SECTION_PROTECTION;
4627 }
4628 /* check for read access */
4629 if ((Protect & (PAGE_READONLY|PAGE_WRITECOPY|PAGE_EXECUTE_READ|PAGE_EXECUTE_WRITECOPY)) &&
4630 !(Section->SectionPageProtection & (PAGE_READONLY|PAGE_READWRITE|PAGE_WRITECOPY|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY)))
4631 {
4632 MmUnlockAddressSpace(AddressSpace);
4633 return STATUS_SECTION_PROTECTION;
4634 }
4635 /* check for execute access */
4636 if ((Protect & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY)) &&
4637 !(Section->SectionPageProtection & (PAGE_EXECUTE|PAGE_EXECUTE_READ|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY)))
4638 {
4639 MmUnlockAddressSpace(AddressSpace);
4640 return STATUS_SECTION_PROTECTION;
4641 }
4642
4643 if (SectionOffset == NULL)
4644 {
4645 ViewOffset = 0;
4646 }
4647 else
4648 {
4649 ViewOffset = SectionOffset->u.LowPart;
4650 }
4651
4652 if ((ViewOffset % PAGE_SIZE) != 0)
4653 {
4654 MmUnlockAddressSpace(AddressSpace);
4655 return(STATUS_MAPPED_ALIGNMENT);
4656 }
4657
4658 if ((*ViewSize) == 0)
4659 {
4660 (*ViewSize) = Section->MaximumSize.u.LowPart - ViewOffset;
4661 }
4662 else if (((*ViewSize)+ViewOffset) > Section->MaximumSize.u.LowPart)
4663 {
4664 (*ViewSize) = Section->MaximumSize.u.LowPart - ViewOffset;
4665 }
4666
4667 *ViewSize = PAGE_ROUND_UP(*ViewSize);
4668
4669 MmLockSectionSegment(Section->Segment);
4670 Status = MmMapViewOfSegment(AddressSpace,
4671 Section,
4672 Section->Segment,
4673 BaseAddress,
4674 *ViewSize,
4675 Protect,
4676 ViewOffset,
4677 AllocationType & (MEM_TOP_DOWN|SEC_NO_CHANGE));
4678 MmUnlockSectionSegment(Section->Segment);
4679 if (!NT_SUCCESS(Status))
4680 {
4681 MmUnlockAddressSpace(AddressSpace);
4682 return(Status);
4683 }
4684 }
4685
4686 MmUnlockAddressSpace(AddressSpace);
4687 ASSERT(*BaseAddress == ALIGN_DOWN_POINTER_BY(*BaseAddress, MM_VIRTMEM_GRANULARITY));
4688
4689 if (NotAtBase)
4690 Status = STATUS_IMAGE_NOT_AT_BASE;
4691 else
4692 Status = STATUS_SUCCESS;
4693
4694 return Status;
4695 }
4696
4697 /*
4698 * @unimplemented
4699 */
4700 BOOLEAN NTAPI
4701 MmCanFileBeTruncated (IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
4702 IN PLARGE_INTEGER NewFileSize)
4703 {
4704 /* Check whether an ImageSectionObject exists */
4705 if (SectionObjectPointer->ImageSectionObject != NULL)
4706 {
4707 DPRINT1("ERROR: File can't be truncated because it has an image section\n");
4708 return FALSE;
4709 }
4710
4711 if (SectionObjectPointer->DataSectionObject != NULL)
4712 {
4713 PMM_SECTION_SEGMENT Segment;
4714
4715 Segment = (PMM_SECTION_SEGMENT)SectionObjectPointer->
4716 DataSectionObject;
4717
4718 if (Segment->ReferenceCount != 0)
4719 {
4720 #ifdef NEWCC
4721 CC_FILE_SIZES FileSizes;
4722 CcpLock();
4723 if (SectionObjectPointer->SharedCacheMap && (Segment->ReferenceCount > CcpCountCacheSections((PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap)))
4724 {
4725 CcpUnlock();
4726 /* Check size of file */
4727 if (SectionObjectPointer->SharedCacheMap)
4728 {
4729 if (!CcGetFileSizes(Segment->FileObject, &FileSizes))
4730 {
4731 return FALSE;
4732 }
4733
4734 if (NewFileSize->QuadPart <= FileSizes.FileSize.QuadPart)
4735 {
4736 return FALSE;
4737 }
4738 }
4739 }
4740 else
4741 CcpUnlock();
4742 #else
4743 /* Check size of file */
4744 if (SectionObjectPointer->SharedCacheMap)
4745 {
4746 PROS_SHARED_CACHE_MAP SharedCacheMap = SectionObjectPointer->SharedCacheMap;
4747 if (NewFileSize->QuadPart <= SharedCacheMap->FileSize.QuadPart)
4748 {
4749 return FALSE;
4750 }
4751 }
4752 #endif
4753 }
4754 else
4755 {
4756 /* Something must gone wrong
4757 * how can we have a Section but no
4758 * reference? */
4759 DPRINT("ERROR: DataSectionObject without reference!\n");
4760 }
4761 }
4762
4763 DPRINT("FIXME: didn't check for outstanding write probes\n");
4764
4765 return TRUE;
4766 }
4767
4768
4769
4770
4771 /*
4772 * @implemented
4773 */
4774 BOOLEAN NTAPI
4775 MmFlushImageSection (IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
4776 IN MMFLUSH_TYPE FlushType)
4777 {
4778 BOOLEAN Result = TRUE;
4779 #ifdef NEWCC
4780 PMM_SECTION_SEGMENT Segment;
4781 #endif
4782
4783 switch(FlushType)
4784 {
4785 case MmFlushForDelete:
4786 if (SectionObjectPointer->ImageSectionObject ||
4787 SectionObjectPointer->DataSectionObject)
4788 {
4789 return FALSE;
4790 }
4791 #ifndef NEWCC
4792 CcRosRemoveIfClosed(SectionObjectPointer);
4793 #endif
4794 return TRUE;
4795 case MmFlushForWrite:
4796 {
4797 DPRINT("MmFlushImageSection(%d)\n", FlushType);
4798 #ifdef NEWCC
4799 Segment = (PMM_SECTION_SEGMENT)SectionObjectPointer->DataSectionObject;
4800 #endif
4801
4802 if (SectionObjectPointer->ImageSectionObject)
4803 {
4804 DPRINT1("SectionObject has ImageSection\n");
4805 return FALSE;
4806 }
4807
4808 #ifdef NEWCC
4809 CcpLock();
4810 Result = !SectionObjectPointer->SharedCacheMap || (Segment->ReferenceCount == CcpCountCacheSections((PNOCC_CACHE_MAP)SectionObjectPointer->SharedCacheMap));
4811 CcpUnlock();
4812 DPRINT("Result %d\n", Result);
4813 #endif
4814 return Result;
4815 }
4816 }
4817 return FALSE;
4818 }
4819
4820 /*
4821 * @implemented
4822 */
4823 NTSTATUS NTAPI
4824 MmMapViewInSystemSpace (IN PVOID SectionObject,
4825 OUT PVOID * MappedBase,
4826 IN OUT PSIZE_T ViewSize)
4827 {
4828 PROS_SECTION_OBJECT Section;
4829 PMMSUPPORT AddressSpace;
4830 NTSTATUS Status;
4831 PAGED_CODE();
4832
4833 if (MiIsRosSectionObject(SectionObject) == FALSE)
4834 {
4835 return MiMapViewInSystemSpace(SectionObject,
4836 &MmSession,
4837 MappedBase,
4838 ViewSize);
4839 }
4840
4841 DPRINT("MmMapViewInSystemSpace() called\n");
4842
4843 Section = (PROS_SECTION_OBJECT)SectionObject;
4844 AddressSpace = MmGetKernelAddressSpace();
4845
4846 MmLockAddressSpace(AddressSpace);
4847
4848
4849 if ((*ViewSize) == 0)
4850 {
4851 (*ViewSize) = Section->MaximumSize.u.LowPart;
4852 }
4853 else if ((*ViewSize) > Section->MaximumSize.u.LowPart)
4854 {
4855 (*ViewSize) = Section->MaximumSize.u.LowPart;
4856 }
4857
4858 MmLockSectionSegment(Section->Segment);
4859
4860
4861 Status = MmMapViewOfSegment(AddressSpace,
4862 Section,
4863 Section->Segment,
4864 MappedBase,
4865 *ViewSize,
4866 PAGE_READWRITE,
4867 0,
4868 0);
4869
4870 MmUnlockSectionSegment(Section->Segment);
4871 MmUnlockAddressSpace(AddressSpace);
4872
4873 return Status;
4874 }
4875
4876 NTSTATUS
4877 NTAPI
4878 MiRosUnmapViewInSystemSpace(IN PVOID MappedBase)
4879 {
4880 PMMSUPPORT AddressSpace;
4881 NTSTATUS Status;
4882
4883 DPRINT("MmUnmapViewInSystemSpace() called\n");
4884
4885 AddressSpace = MmGetKernelAddressSpace();
4886
4887 MmLockAddressSpace(AddressSpace);
4888
4889 Status = MmUnmapViewOfSegment(AddressSpace, MappedBase);
4890
4891 MmUnlockAddressSpace(AddressSpace);
4892
4893 return Status;
4894 }
4895
4896 /**********************************************************************
4897 * NAME EXPORTED
4898 * MmCreateSection@
4899 *
4900 * DESCRIPTION
4901 * Creates a section object.
4902 *
4903 * ARGUMENTS
4904 * SectionObject (OUT)
4905 * Caller supplied storage for the resulting pointer
4906 * to a SECTION_OBJECT instance;
4907 *
4908 * DesiredAccess
4909 * Specifies the desired access to the section can be a
4910 * combination of:
4911 * STANDARD_RIGHTS_REQUIRED |
4912 * SECTION_QUERY |
4913 * SECTION_MAP_WRITE |
4914 * SECTION_MAP_READ |
4915 * SECTION_MAP_EXECUTE
4916 *
4917 * ObjectAttributes [OPTIONAL]
4918 * Initialized attributes for the object can be used
4919 * to create a named section;
4920 *
4921 * MaximumSize
4922 * Maximizes the size of the memory section. Must be
4923 * non-NULL for a page-file backed section.
4924 * If value specified for a mapped file and the file is
4925 * not large enough, file will be extended.
4926 *
4927 * SectionPageProtection
4928 * Can be a combination of:
4929 * PAGE_READONLY |
4930 * PAGE_READWRITE |
4931 * PAGE_WRITEONLY |
4932 * PAGE_WRITECOPY
4933 *
4934 * AllocationAttributes
4935 * Can be a combination of:
4936 * SEC_IMAGE |
4937 * SEC_RESERVE
4938 *
4939 * FileHandle
4940 * Handle to a file to create a section mapped to a file
4941 * instead of a memory backed section;
4942 *
4943 * File
4944 * Unknown.
4945 *
4946 * RETURN VALUE
4947 * Status.
4948 *
4949 * @implemented
4950 */
4951 NTSTATUS NTAPI
4952 MmCreateSection (OUT PVOID * Section,
4953 IN ACCESS_MASK DesiredAccess,
4954 IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
4955 IN PLARGE_INTEGER MaximumSize,
4956 IN ULONG SectionPageProtection,
4957 IN ULONG AllocationAttributes,
4958 IN HANDLE FileHandle OPTIONAL,
4959 IN PFILE_OBJECT FileObject OPTIONAL)
4960 {
4961 NTSTATUS Status;
4962 ULONG Protection;
4963 PROS_SECTION_OBJECT *SectionObject = (PROS_SECTION_OBJECT *)Section;
4964
4965 /* Check if an ARM3 section is being created instead */
4966 if (!(AllocationAttributes & (SEC_IMAGE | SEC_PHYSICALMEMORY)))
4967 {
4968 if (!(FileObject) && !(FileHandle))
4969 {
4970 return MmCreateArm3Section(Section,
4971 DesiredAccess,
4972 ObjectAttributes,
4973 MaximumSize,
4974 SectionPageProtection,
4975 AllocationAttributes &~ 1,
4976 FileHandle,
4977 FileObject);
4978 }
4979 }
4980
4981 /* Convert section flag to page flag */
4982 if (AllocationAttributes & SEC_NOCACHE) SectionPageProtection |= PAGE_NOCACHE;
4983
4984 /* Check to make sure the protection is correct. Nt* does this already */
4985 Protection = MiMakeProtectionMask(SectionPageProtection);
4986 if (Protection == MM_INVALID_PROTECTION)
4987 {
4988 DPRINT1("Page protection is invalid\n");
4989 return STATUS_INVALID_PAGE_PROTECTION;
4990 }
4991
4992 /* Check if this is going to be a data or image backed file section */
4993 if ((FileHandle) || (FileObject))
4994 {
4995 /* These cannot be mapped with large pages */
4996 if (AllocationAttributes & SEC_LARGE_PAGES)
4997 {
4998 DPRINT1("Large pages cannot be used with an image mapping\n");
4999 return STATUS_INVALID_PARAMETER_6;
5000 }
5001
5002 /* Did the caller pass an object? */
5003 if (FileObject)
5004 {
5005 /* Reference the object directly */
5006 ObReferenceObject(FileObject);
5007 }
5008 else
5009 {
5010 /* Reference the file handle to get the object */
5011 Status = ObReferenceObjectByHandle(FileHandle,
5012 MmMakeFileAccess[Protection],
5013 IoFileObjectType,
5014 ExGetPreviousMode(),
5015 (PVOID*)&FileObject,
5016 NULL);
5017 if (!NT_SUCCESS(Status))
5018 {
5019 DPRINT1("Failed to get a handle to the FO: %lx\n", Status);
5020 return Status;
5021 }
5022 }
5023 }
5024 else
5025 {
5026 /* A handle must be supplied with SEC_IMAGE, as this is the no-handle path */
5027 if (AllocationAttributes & SEC_IMAGE) return STATUS_INVALID_FILE_FOR_SECTION;
5028 }
5029
5030 #ifndef NEWCC // A hack for initializing caching.
5031 // This is needed only in the old case.
5032 if (FileHandle)
5033 {
5034 IO_STATUS_BLOCK Iosb;
5035 NTSTATUS Status;
5036 CHAR Buffer;
5037 LARGE_INTEGER ByteOffset;
5038 ByteOffset.QuadPart = 0;
5039 Status = ZwReadFile(FileHandle,
5040 NULL,
5041 NULL,
5042 NULL,
5043 &Iosb,
5044 &Buffer,
5045 sizeof(Buffer),
5046 &ByteOffset,
5047 NULL);
5048 if (!NT_SUCCESS(Status) && Status != STATUS_END_OF_FILE)
5049 {
5050 DPRINT1("CC failure: %lx\n", Status);
5051 if (FileObject)
5052 ObDereferenceObject(FileObject);
5053 return Status;
5054 }
5055 // Caching is initialized...
5056
5057 // Hack of the hack: actually, it might not be initialized if FSD init on effective right and if file is null-size
5058 // In such case, force cache by initiating a write IRP
5059 if (Status == STATUS_END_OF_FILE && !(AllocationAttributes & SEC_IMAGE) && FileObject != NULL &&
5060 (FileObject->SectionObjectPointer == NULL || FileObject->SectionObjectPointer->SharedCacheMap == NULL))
5061 {
5062 Buffer = 0xdb;
5063 Status = ZwWriteFile(FileHandle,
5064 NULL,
5065 NULL,
5066 NULL,
5067 &Iosb,
5068 &Buffer,
5069 sizeof(Buffer),
5070 &ByteOffset,
5071 NULL);
5072 if (NT_SUCCESS(Status))
5073 {
5074 LARGE_INTEGER Zero;
5075 Zero.QuadPart = 0LL;
5076
5077 Status = IoSetInformation(FileObject,
5078 FileEndOfFileInformation,
5079 sizeof(LARGE_INTEGER),
5080 &Zero);
5081 ASSERT(NT_SUCCESS(Status));
5082 }
5083 }
5084 }
5085 #endif
5086
5087 if (AllocationAttributes & SEC_IMAGE)
5088 {
5089 Status = MmCreateImageSection(SectionObject,
5090 DesiredAccess,
5091 ObjectAttributes,
5092 MaximumSize,
5093 SectionPageProtection,
5094 AllocationAttributes,
5095 FileObject);
5096 }
5097 #ifndef NEWCC
5098 else if (FileHandle != NULL)
5099 {
5100 Status = MmCreateDataFileSection(SectionObject,
5101 DesiredAccess,
5102 ObjectAttributes,
5103 MaximumSize,
5104 SectionPageProtection,
5105 AllocationAttributes,
5106 FileObject);
5107 }
5108 #else
5109 else if (FileHandle != NULL || FileObject != NULL)
5110 {
5111 Status = MmCreateCacheSection(SectionObject,
5112 DesiredAccess,
5113 ObjectAttributes,
5114 MaximumSize,
5115 SectionPageProtection,
5116 AllocationAttributes,
5117 FileObject);
5118 }
5119 #endif
5120 else
5121 {
5122 if ((AllocationAttributes & SEC_PHYSICALMEMORY) == 0)
5123 {
5124 DPRINT1("Invalid path: %lx %p %p\n", AllocationAttributes, FileObject, FileHandle);
5125 }
5126 // ASSERT(AllocationAttributes & SEC_PHYSICALMEMORY);
5127 Status = MmCreatePageFileSection(SectionObject,
5128 DesiredAccess,
5129 ObjectAttributes,
5130 MaximumSize,
5131 SectionPageProtection,
5132 AllocationAttributes);
5133 if (FileObject)
5134 ObDereferenceObject(FileObject);
5135 }
5136
5137 return Status;
5138 }
5139
5140 /* EOF */
A free Windows-compatible Operating System