ReactOS  0.4.15-dev-1367-g07cc0b5
session.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS Kernel
3  * LICENSE: BSD - See COPYING.ARM in the top level directory
4  * FILE: ntoskrnl/mm/ARM3/session.c
5  * PURPOSE: Session support routines
6  * PROGRAMMERS: ReactOS Portable Systems Group
7  * Timo Kreuzer (timo.kreuzer@reactos.org)
8  */
9 
10 /* INCLUDES *******************************************************************/
11 
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <debug.h>
15 
16 #define MODULE_INVOLVED_IN_ARM3
17 #include <mm/ARM3/miarm.h>
18 
19 /* GLOBALS ********************************************************************/
20 
28 
31 
34 
35 
36 /* PRIVATE FUNCTIONS **********************************************************/
37 
38 VOID
39 NTAPI
41 {
42  /* Initialize the list heads */
45 }
46 
47 BOOLEAN
48 NTAPI
50 {
51  /* Check if it is in range */
53 }
54 
55 LCID
56 NTAPI
58 {
60  PAGED_CODE();
61 
62  //
63  // Get the current process
64  //
66 
67  //
68  // Check if it's NOT the Session Leader
69  //
70  if (!Process->Vm.Flags.SessionLeader)
71  {
72  //
73  // Make sure it has a valid Session
74  //
75  if (Process->Session)
76  {
77  //
78  // Get the Locale ID
79  //
80  return ((PMM_SESSION_SPACE)Process->Session)->LocaleId;
81  }
82  }
83 
84  //
85  // Not a session leader, return the default
86  //
88 }
89 
91 VOID
92 NTAPI
93 MmSetSessionLocaleId(
95 {
97  PAGED_CODE();
98 
99  /* Get the current process and check if it is in a session */
101  if ((CurrentProcess->Vm.Flags.SessionLeader == 0) &&
102  (CurrentProcess->Session != NULL))
103  {
104  /* Set the session locale Id */
105  ((PMM_SESSION_SPACE)CurrentProcess->Session)->LocaleId = LocaleId;
106  }
107  else
108  {
109  /* Set the default locale */
111  }
112 }
113 
114 
115 VOID
116 NTAPI
118 {
119  ULONG Size, BitmapSize;
120  PFN_NUMBER TotalPages;
121 
122  /* Setup the total number of data pages needed for the structure */
123  TotalPages = MI_SESSION_DATA_PAGES_MAXIMUM;
126  TotalPages -= MiSessionDataPages;
127 
128  /* Setup the number of pages needed for session pool tags */
132  ASSERT(MiSessionTagPages <= TotalPages);
134 
135  /* Total pages needed for a session (FIXME: Probably different on PAE/x64) */
137 
138  /* Initialize the lock */
140 
141  /* Allocate the bitmap */
143  BitmapSize = ((Size + 31) / 32) * sizeof(ULONG);
145  sizeof(RTL_BITMAP) + BitmapSize,
146  TAG_MM);
147  if (MiSessionIdBitmap)
148  {
149  /* Free all the bits */
151  (PVOID)(MiSessionIdBitmap + 1),
152  Size);
154  }
155  else
156  {
157  /* Die if we couldn't allocate the bitmap */
158  KeBugCheckEx(INSTALL_MORE_MEMORY,
162  0x200);
163  }
164 }
165 
166 VOID
167 NTAPI
169 {
170  KIRQL OldIrql;
171 
172  /* Set the flag while under the expansion lock */
174  Process->Vm.Flags.SessionLeader = TRUE;
176 }
177 
178 ULONG
179 NTAPI
181 {
182  PMM_SESSION_SPACE SessionGlobal;
183 
184  /* The session leader is always session zero */
185  if (Process->Vm.Flags.SessionLeader == 1) return 0;
186 
187  /* Otherwise, get the session global, and read the session ID from it */
188  SessionGlobal = (PMM_SESSION_SPACE)Process->Session;
189  if (!SessionGlobal) return 0;
190  return SessionGlobal->SessionId;
191 }
192 
193 ULONG
194 NTAPI
196 {
197  PMM_SESSION_SPACE SessionGlobal;
198 
199  /* The session leader is always session zero */
200  if (Process->Vm.Flags.SessionLeader == 1) return 0;
201 
202  /* Otherwise, get the session global, and read the session ID from it */
203  SessionGlobal = (PMM_SESSION_SPACE)Process->Session;
204  if (!SessionGlobal) return -1;
205  return SessionGlobal->SessionId;
206 }
207 
208 VOID
209 NTAPI
211 {
212  ULONG i, SessionId;
213  PMMPTE PointerPte;
215  PMMPFN Pfn1;
216  KIRQL OldIrql;
217 
218  /* Is there more than just this reference? If so, bail out */
219  if (InterlockedDecrement(&SessionGlobal->ProcessReferenceToSession)) return;
220 
221  /* Get the session ID */
222  SessionId = SessionGlobal->SessionId;
223  DPRINT1("Last process in session %lu going down!!!\n", SessionId);
224 
225  /* Free the session page tables */
226 #ifndef _M_AMD64
227  ExFreePoolWithTag(SessionGlobal->PageTables, 'tHmM');
228 #endif
229  ASSERT(!MI_IS_PHYSICAL_ADDRESS(SessionGlobal));
230 
231  /* Capture the data page PFNs */
232  PointerPte = MiAddressToPte(SessionGlobal);
233  for (i = 0; i < MiSessionDataPages; i++)
234  {
235  PageFrameIndex[i] = PFN_FROM_PTE(PointerPte + i);
236  }
237 
238  /* Release them */
240 
241  /* Mark them as deleted */
242  for (i = 0; i < MiSessionDataPages; i++)
243  {
244  Pfn1 = MI_PFN_ELEMENT(PageFrameIndex[i]);
245  MI_SET_PFN_DELETED(Pfn1);
246  }
247 
248  /* Loop every data page and drop a reference count */
250  for (i = 0; i < MiSessionDataPages; i++)
251  {
252  /* Sanity check that the page is correct, then decrement it */
253  Pfn1 = MI_PFN_ELEMENT(PageFrameIndex[i]);
254  ASSERT(Pfn1->u2.ShareCount == 1);
255  ASSERT(Pfn1->u3.e2.ReferenceCount == 1);
256  MiDecrementShareCount(Pfn1, PageFrameIndex[i]);
257  }
258 
259  /* Done playing with pages, release the lock */
261 
262  /* Decrement the number of data pages */
264 
265  /* Free this session ID from the session bitmap */
270 }
271 
272 VOID
273 NTAPI
275 {
276  PMM_SESSION_SPACE SessionGlobal;
277  KIRQL OldIrql;
278 
279  /* Get the pointer to the global session address */
280  SessionGlobal = MmSessionSpace->GlobalVirtualAddress;
281 
282  /* Acquire the expansion lock */
284 
285  /* Set delete pending flag, so that processes can no longer attach to this
286  session and the last process that detaches sets the AttachEvent */
287  ASSERT(SessionGlobal->u.Flags.DeletePending == 0);
288  SessionGlobal->u.Flags.DeletePending = 1;
289 
290  /* Check if we have any attached processes */
291  if (SessionGlobal->AttachCount)
292  {
293  /* Initialize the event (it's not in use yet!) */
295 
296  /* Release the expansion lock for the wait */
298 
299  /* Wait for the event to be set due to the last process detach */
300  KeWaitForSingleObject(&SessionGlobal->AttachEvent, WrVirtualMemory, 0, 0, 0);
301 
302  /* Reacquire the expansion lock */
304 
305  /* Makes sure we still have the delete flag and no attached processes */
308  }
309 
310  /* Check if the session is in the workingset expansion list */
311  if (SessionGlobal->Vm.WorkingSetExpansionLinks.Flink != NULL)
312  {
313  /* Remove the session from the list and zero the list entry */
315  SessionGlobal->Vm.WorkingSetExpansionLinks.Flink = 0;
316  }
317 
318  /* Check if the session is in the workingset list */
319  if (SessionGlobal->WsListEntry.Flink)
320  {
321  /* Remove the session from the list and zero the list entry */
322  RemoveEntryList(&SessionGlobal->WsListEntry);
323  SessionGlobal->WsListEntry.Flink = NULL;
324  }
325 
326  /* Release the expansion lock */
328 
329  /* Check for a win32k unload routine */
330  if (SessionGlobal->Win32KDriverUnload)
331  {
332  /* Call it */
333  SessionGlobal->Win32KDriverUnload(NULL);
334  }
335 }
336 
337 
338 VOID
339 NTAPI
341 {
342  PMM_SESSION_SPACE SessionGlobal;
344  ULONG ReferenceCount, SessionId;
345 
346  /* Sanity checks */
347  ASSERT(PsGetCurrentProcess()->ProcessInSession ||
348  ((MmSessionSpace->u.Flags.Initialized == 0) &&
349  (PsGetCurrentProcess()->Vm.Flags.SessionLeader == 1) &&
350  (MmSessionSpace->ReferenceCount == 1)));
351 
352  /* The session bit must be set */
355 
356  /* Get the current process */
358 
359  /* Decrement the process count */
361 
362  /* Decrement the reference count and check if was the last reference */
364  if (ReferenceCount == 0)
365  {
366  /* No more references left, kill the session completely */
368  }
369 
370  /* Check if tis is the session leader or the last process in the session */
371  if ((Process->Vm.Flags.SessionLeader) || (ReferenceCount == 0))
372  {
373  /* Get the global session address before we kill the session mapping */
374  SessionGlobal = MmSessionSpace->GlobalVirtualAddress;
375 
376  /* Delete all session PDEs and flush the TB */
378  BYTES_TO_PAGES(MmSessionSize) * sizeof(MMPDE));
380 
381  /* Is this the session leader? */
382  if (Process->Vm.Flags.SessionLeader)
383  {
384  /* Clean up the references here. */
385  ASSERT(Process->Session == NULL);
387  }
388  }
389 
390  /* Reset the current process' session flag */
392 }
393 
394 VOID
395 NTAPI
397 {
399  KIRQL OldIrql;
400 
401  /* If the process isn't already in a session, or if it's the leader... */
402  if (!(CurrentProcess->Flags & PSF_PROCESS_IN_SESSION_BIT) ||
403  (CurrentProcess->Vm.Flags.SessionLeader))
404  {
405  /* Then there's nothing to do */
406  return;
407  }
408 
409  /* Sanity check */
411 
412  /* Acquire the expansion lock while touching the session */
414 
415  /* Remove the process from the list */
416  RemoveEntryList(&CurrentProcess->SessionProcessLinks);
417 
418  /* Release the lock again */
420 
421  /* Dereference the session */
423 }
424 
425 VOID
426 NTAPI
428 {
429  PMM_SESSION_SPACE SessionGlobal;
430  KIRQL OldIrql;
431 
432  /* The current process must already be in a session */
434 
435  /* Sanity check */
437 
438  /* Get the global session */
439  SessionGlobal = MmSessionSpace->GlobalVirtualAddress;
440 
441  /* Increment counters */
442  InterlockedIncrement((PLONG)&SessionGlobal->ReferenceCount);
445 
446  /* Set the session pointer */
447  ASSERT(NewProcess->Session == NULL);
448  NewProcess->Session = SessionGlobal;
449 
450  /* Acquire the expansion lock while touching the session */
452 
453  /* Insert it into the process list */
454  InsertTailList(&SessionGlobal->ProcessList, &NewProcess->SessionProcessLinks);
455 
456  /* Release the lock again */
458 
459  /* Set the flag */
461 }
462 
463 NTSTATUS
464 NTAPI
466 {
467  KIRQL OldIrql;
468  PMMPTE PointerPte;
469  PMMPDE PointerPde;
470  MMPTE TempPte;
471  MMPDE TempPde;
472  ULONG Color, Index;
473  PFN_NUMBER PageFrameIndex;
474  PMM_SESSION_SPACE SessionGlobal;
475  BOOLEAN AllocatedPageTable;
476  PMMWSL WorkingSetList;
477 
478  /* Get pointers to session global and the session working set list */
479  SessionGlobal = MmSessionSpace->GlobalVirtualAddress;
480  WorkingSetList = (PMMWSL)MiSessionSpaceWs;
481 
482  /* Fill out the two pointers */
483  MmSessionSpace->Vm.VmWorkingSetList = WorkingSetList;
484  MmSessionSpace->Wsle = (PMMWSLE)WorkingSetList->UsedPageTableEntries;
485 
486  /* Get the PDE for the working set, and check if it's already allocated */
487  PointerPde = MiAddressToPde(WorkingSetList);
488  if (PointerPde->u.Hard.Valid == 1)
489  {
490  /* Nope, we'll have to do it */
491 #ifndef _M_ARM
492  ASSERT(PointerPde->u.Hard.Global == 0);
493 #endif
494  AllocatedPageTable = FALSE;
495  }
496  else
497  {
498  /* Yep, that makes our job easier */
499  AllocatedPageTable = TRUE;
500  }
501 
502  /* Get the PTE for the working set */
503  PointerPte = MiAddressToPte(WorkingSetList);
504 
505  /* Initialize the working set lock, and lock the PFN database */
506  ExInitializePushLock(&SessionGlobal->Vm.WorkingSetMutex);
507  //MmLockPageableSectionByHandle(ExPageLockHandle);
509 
510  /* Check if we need a page table */
511  if (AllocatedPageTable != FALSE)
512  {
513  /* Get a zeroed colored zero page */
516  PageFrameIndex = MiRemoveZeroPageSafe(Color);
517  if (!PageFrameIndex)
518  {
519  /* No zero pages, grab a free one */
520  PageFrameIndex = MiRemoveAnyPage(Color);
521 
522  /* Zero it outside the PFN lock */
524  MiZeroPhysicalPage(PageFrameIndex);
526  }
527 
528  /* Write a valid PDE for it */
530  TempPde.u.Hard.PageFrameNumber = PageFrameIndex;
531  MI_WRITE_VALID_PDE(PointerPde, TempPde);
532 
533  /* Add this into the list */
534  Index = ((ULONG_PTR)WorkingSetList - (ULONG_PTR)MmSessionBase) >> 22;
535 #ifndef _M_AMD64
537 #endif
538  /* Initialize the page directory page, and now zero the working set list itself */
539  MiInitializePfnForOtherProcess(PageFrameIndex,
540  PointerPde,
542  KeZeroPages(PointerPte, PAGE_SIZE);
543  }
544 
545  /* Get a zeroed colored zero page */
548  PageFrameIndex = MiRemoveZeroPageSafe(Color);
549  if (!PageFrameIndex)
550  {
551  /* No zero pages, grab a free one */
552  PageFrameIndex = MiRemoveAnyPage(Color);
553 
554  /* Zero it outside the PFN lock */
556  MiZeroPhysicalPage(PageFrameIndex);
558  }
559 
560  /* Write a valid PTE for it */
563  TempPte.u.Hard.PageFrameNumber = PageFrameIndex;
564 
565  /* Initialize the working set list page */
566  MiInitializePfnAndMakePteValid(PageFrameIndex, PointerPte, TempPte);
567 
568  /* Now we can release the PFN database lock */
570 
571  /* Fill out the working set structure */
575  WorkingSetList->LastEntry = 20;
576  WorkingSetList->HashTable = NULL;
577  WorkingSetList->HashTableSize = 0;
578  WorkingSetList->Wsle = MmSessionSpace->Wsle;
579 
580  /* Acquire the expansion lock while touching the session */
582 
583  /* Handle list insertions */
584  ASSERT(SessionGlobal->WsListEntry.Flink == NULL);
585  ASSERT(SessionGlobal->WsListEntry.Blink == NULL);
586  InsertTailList(&MiSessionWsList, &SessionGlobal->WsListEntry);
587 
588  ASSERT(SessionGlobal->Vm.WorkingSetExpansionLinks.Flink == NULL);
589  ASSERT(SessionGlobal->Vm.WorkingSetExpansionLinks.Blink == NULL);
591  &SessionGlobal->Vm.WorkingSetExpansionLinks);
592 
593  /* Release the lock again */
595 
596  /* All done, return */
597  //MmUnlockPageableImageSection(ExPageLockHandle);
598  return STATUS_SUCCESS;
599 }
600 
601 NTSTATUS
602 NTAPI
604 {
606  ULONG NewFlags, Flags, i, Color;
607 #if (_MI_PAGING_LEVELS < 3)
608  ULONG Size;
609 #endif // (_MI_PAGING_LEVELS < 3)
610  PMMPDE PageTables = NULL;
611  KIRQL OldIrql;
612  PMMPTE PointerPte, SessionPte;
613  PMMPDE PointerPde;
614  PMM_SESSION_SPACE SessionGlobal;
615  MMPTE TempPte;
616  MMPDE TempPde;
618  BOOLEAN Result;
619  PFN_NUMBER SessionPageDirIndex;
622 
623  /* This should not exist yet */
625 
626  /* Loop so we can set the session-is-creating flag */
627  Flags = Process->Flags;
628  while (TRUE)
629  {
630  /* Check if it's already set */
632  {
633  /* Bail out */
634  DPRINT1("Lost session race\n");
636  }
637 
638  /* Now try to set it */
639  NewFlags = InterlockedCompareExchange((PLONG)&Process->Flags,
641  Flags);
642  if (NewFlags == Flags) break;
643 
644  /* It changed, try again */
645  Flags = NewFlags;
646  }
647 
648  /* Now we should own the flag */
650 
651 #if (_MI_PAGING_LEVELS < 3)
652  /*
653  * Session space covers everything from 0xA0000000 to 0xC0000000.
654  * Allocate enough page tables to describe the entire region
655  */
656  Size = (0x20000000 / PDE_MAPPED_VA) * sizeof(MMPTE);
657  PageTables = ExAllocatePoolWithTag(NonPagedPool, Size, 'tHmM');
658  ASSERT(PageTables != NULL);
659  RtlZeroMemory(PageTables, Size);
660 #endif // (_MI_PAGING_LEVELS < 3)
661 
662  /* Lock the session ID creation mutex */
664 
665  /* Allocate a new Session ID */
667  if (*SessionId == 0xFFFFFFFF)
668  {
669  /* We ran out of session IDs, we should expand */
670  DPRINT1("Too many sessions created. Expansion not yet supported\n");
671 #if (_MI_PAGING_LEVELS < 3)
672  ExFreePoolWithTag(PageTables, 'tHmM');
673 #endif // (_MI_PAGING_LEVELS < 3)
674  return STATUS_NO_MEMORY;
675  }
676 
677  /* Unlock the session ID creation mutex */
679 
680  /* Reserve the global PTEs */
682  ASSERT(SessionPte != NULL);
683 
684  /* Acquire the PFN lock while we set everything up */
686 
687  /* Loop the global PTEs */
689  for (i = 0; i < MiSessionDataPages; i++)
690  {
691  /* Get a zeroed colored zero page */
694  DataPage[i] = MiRemoveZeroPageSafe(Color);
695  if (!DataPage[i])
696  {
697  /* No zero pages, grab a free one */
698  DataPage[i] = MiRemoveAnyPage(Color);
699 
700  /* Zero it outside the PFN lock */
702  MiZeroPhysicalPage(DataPage[i]);
704  }
705 
706  /* Fill the PTE out */
707  TempPte.u.Hard.PageFrameNumber = DataPage[i];
708  MI_WRITE_VALID_PTE(SessionPte + i, TempPte);
709  }
710 
711  /* Set the pointer to global space */
712  SessionGlobal = MiPteToAddress(SessionPte);
713 
714  /* Get a zeroed colored zero page */
717  SessionPageDirIndex = MiRemoveZeroPageSafe(Color);
718  if (!SessionPageDirIndex)
719  {
720  /* No zero pages, grab a free one */
721  SessionPageDirIndex = MiRemoveAnyPage(Color);
722 
723  /* Zero it outside the PFN lock */
725  MiZeroPhysicalPage(SessionPageDirIndex);
727  }
728 
729  /* Fill the PTE out */
731  TempPde.u.Hard.PageFrameNumber = SessionPageDirIndex;
732 
733  /* Setup, allocate, fill out the MmSessionSpace PTE */
734  PointerPde = MiAddressToPde(MmSessionSpace);
735  ASSERT(PointerPde->u.Long == 0);
736  MI_WRITE_VALID_PDE(PointerPde, TempPde);
737  MiInitializePfnForOtherProcess(SessionPageDirIndex,
738  PointerPde,
739  SessionPageDirIndex);
740  ASSERT(MI_PFN_ELEMENT(SessionPageDirIndex)->u1.WsIndex == 0);
741 
742  /* Loop all the local PTEs for it */
744  PointerPte = MiAddressToPte(MmSessionSpace);
745  for (i = 0; i < MiSessionDataPages; i++)
746  {
747  /* And fill them out */
748  TempPte.u.Hard.PageFrameNumber = DataPage[i];
749  MiInitializePfnAndMakePteValid(DataPage[i], PointerPte + i, TempPte);
750  ASSERT(MI_PFN_ELEMENT(DataPage[i])->u1.WsIndex == 0);
751  }
752 
753  /* Finally loop all of the session pool tag pages */
754  for (i = 0; i < MiSessionTagPages; i++)
755  {
756  /* Grab a zeroed colored page */
759  TagPage[i] = MiRemoveZeroPageSafe(Color);
760  if (!TagPage[i])
761  {
762  /* No zero pages, grab a free one */
763  TagPage[i] = MiRemoveAnyPage(Color);
764 
765  /* Zero it outside the PFN lock */
767  MiZeroPhysicalPage(TagPage[i]);
769  }
770 
771  /* Fill the PTE out */
772  TempPte.u.Hard.PageFrameNumber = TagPage[i];
774  PointerPte + MiSessionDataPages + i,
775  TempPte);
776  }
777 
778  /* PTEs have been setup, release the PFN lock */
780 
781  /* Fill out the session space structure now */
782  MmSessionSpace->GlobalVirtualAddress = SessionGlobal;
788  MmSessionSpace->SessionPageDirectoryIndex = SessionPageDirIndex;
792 #ifndef _M_AMD64
793  MmSessionSpace->PageTables = PageTables;
794  MmSessionSpace->PageTables[PointerPde - MiAddressToPde(MmSessionBase)] = *PointerPde;
795 #endif
797 
798  DPRINT1("Session %lu is ready to go: 0x%p 0x%p, %lx 0x%p\n",
799  *SessionId, MmSessionSpace, SessionGlobal, SessionPageDirIndex, PageTables);
800 
801  /* Initialize session pool */
802  //Status = MiInitializeSessionPool();
805 
806  /* Initialize system space */
807  Result = MiInitializeSystemSpaceMap(&SessionGlobal->Session);
808  ASSERT(Result == TRUE);
809 
810  /* Initialize the process list, make sure the workign set list is empty */
811  ASSERT(SessionGlobal->WsListEntry.Flink == NULL);
812  ASSERT(SessionGlobal->WsListEntry.Blink == NULL);
813  InitializeListHead(&SessionGlobal->ProcessList);
814 
815  /* We're done, clear the flag */
818 
819  /* Insert the process into the session */
820  ASSERT(Process->Session == NULL);
821  ASSERT(SessionGlobal->ProcessReferenceToSession == 0);
822  SessionGlobal->ProcessReferenceToSession = 1;
823 
824  /* We're done */
826  return STATUS_SUCCESS;
827 }
828 
829 NTSTATUS
830 NTAPI
832 {
834  ULONG SessionLeaderExists;
836 
837  /* Fail if the process is already in a session */
838  if (Process->Flags & PSF_PROCESS_IN_SESSION_BIT)
839  {
840  DPRINT1("Process already in session\n");
842  }
843 
844  /* Check if the process is already the session leader */
845  if (!Process->Vm.Flags.SessionLeader)
846  {
847  /* Atomically set it as the leader */
848  SessionLeaderExists = InterlockedCompareExchange(&MiSessionLeaderExists, 1, 0);
849  if (SessionLeaderExists)
850  {
851  DPRINT1("Session leader race\n");
853  }
854 
855  /* Do the work required to upgrade him */
857  }
858 
859  /* Create the session */
862  if (!NT_SUCCESS(Status))
863  {
865  return Status;
866  }
867 
868  /* Set up the session working set */
870  if (!NT_SUCCESS(Status))
871  {
872  /* Fail */
873  //MiDereferenceSession();
874  ASSERT(FALSE);
876  return Status;
877  }
878 
879  /* All done */
881 
882  /* Set and assert the flags, and return */
886  return Status;
887 }
888 
889 NTSTATUS
890 NTAPI
892 {
894 
895  /* Process must be in a session */
896  if (!(Process->Flags & PSF_PROCESS_IN_SESSION_BIT))
897  {
898  DPRINT1("Not in a session!\n");
900  }
901 
902  /* It must be the session leader */
903  if (!Process->Vm.Flags.SessionLeader)
904  {
905  DPRINT1("Not a session leader!\n");
907  }
908 
909  /* Remove one reference count */
911  /* FIXME: Do it */
913 
914  /* All done */
915  return STATUS_SUCCESS;
916 }
917 
919 NTSTATUS
920 NTAPI
921 MmAttachSession(
922  _Inout_ PVOID SessionEntry,
924 {
925  PEPROCESS EntryProcess;
926  PMM_SESSION_SPACE EntrySession, CurrentSession;
928  KIRQL OldIrql;
929 
930  /* The parameter is the actual process! */
931  EntryProcess = SessionEntry;
932  ASSERT(EntryProcess != NULL);
933 
934  /* Sanity checks */
936  ASSERT(EntryProcess->Vm.Flags.SessionLeader == 0);
937 
938  /* Get the session from the process that was passed in */
939  EntrySession = EntryProcess->Session;
940  ASSERT(EntrySession != NULL);
941 
942  /* Get the current process and it's session */
944  CurrentSession = CurrentProcess->Session;
945 
946  /* Acquire the expansion lock while touching the session */
948 
949  /* Check if the session is about to be deleted */
950  if (EntrySession->u.Flags.DeletePending)
951  {
952  /* We cannot attach to it, so unlock and fail */
955  }
956 
957  /* Count the number of attaches */
958  EntrySession->AttachCount++;
959 
960  /* we can release the lock again */
962 
963  /* Check if we are not the session leader and we are in a session */
964  if (!CurrentProcess->Vm.Flags.SessionLeader && (CurrentSession != NULL))
965  {
966  /* Are we already in the right session? */
967  if (CurrentSession == EntrySession)
968  {
969  /* We are, so "attach" to the current process */
970  EntryProcess = CurrentProcess;
971  }
972  else
973  {
974  /* We are not, the session id should better not match! */
975  ASSERT(CurrentSession->SessionId != EntrySession->SessionId);
976  }
977  }
978 
979  /* Now attach to the process that we have */
980  KeStackAttachProcess(&EntryProcess->Pcb, ApcState);
981 
982  /* Success! */
983  return STATUS_SUCCESS;
984 }
985 
987 VOID
988 NTAPI
989 MmDetachSession(
990  _Inout_ PVOID SessionEntry,
992 {
993  PEPROCESS EntryProcess;
994  PMM_SESSION_SPACE EntrySession;
995  KIRQL OldIrql;
996  BOOLEAN DeletePending;
997 
998  /* The parameter is the actual process! */
999  EntryProcess = SessionEntry;
1000  ASSERT(EntryProcess != NULL);
1001 
1002  /* Sanity checks */
1004  ASSERT(EntryProcess->Vm.Flags.SessionLeader == 0);
1005 
1006  /* Get the session from the process that was passed in */
1007  EntrySession = EntryProcess->Session;
1008  ASSERT(EntrySession != NULL);
1009 
1010  /* Acquire the expansion lock while touching the session */
1012 
1013  /* Make sure we have at least one attach and decrement the count */
1014  ASSERT(EntrySession->AttachCount >= 1);
1015  EntrySession->AttachCount--;
1016 
1017  /* Remember if a delete is pending and we were the last one attached */
1018  DeletePending = EntrySession->u.Flags.DeletePending &&
1019  (EntrySession->AttachCount == 0);
1020 
1021  /* Release the lock again */
1023 
1024  /* Detach from the process */
1026 
1027  /* Check if we need to set the attach event */
1028  if (DeletePending)
1029  KeSetEvent(&EntrySession->AttachEvent, IO_NO_INCREMENT, FALSE);
1030 }
1031 
1032 VOID
1033 NTAPI
1035  _Inout_ PVOID SessionEntry)
1036 {
1037  PEPROCESS EntryProcess;
1038 
1039  /* The parameter is the actual process! */
1040  EntryProcess = SessionEntry;
1041  ASSERT(EntryProcess != NULL);
1042 
1043  /* Sanity checks */
1045  ASSERT(EntryProcess->Vm.Flags.SessionLeader == 0);
1046  ASSERT(EntryProcess->Session != NULL);
1047 
1048  /* Get rid of the reference we took */
1049  ObDereferenceObject(EntryProcess);
1050 }
1051 
1052 PVOID
1053 NTAPI
1056 {
1057  PLIST_ENTRY ListEntry;
1058  PMM_SESSION_SPACE Session;
1060  KIRQL OldIrql;
1061 
1062  /* Acquire the expansion lock while touching the session */
1064 
1065  /* Loop all entries in the session ws list */
1066  ListEntry = MiSessionWsList.Flink;
1067  while (ListEntry != &MiSessionWsList)
1068  {
1069  Session = CONTAINING_RECORD(ListEntry, MM_SESSION_SPACE, WsListEntry);
1070  ListEntry = ListEntry->Flink;
1071 
1072  /* Check if this is the session we are looking for */
1073  if (Session->SessionId == SessionId)
1074  {
1075  /* Check if we also have a process in the process list */
1076  if (!IsListEmpty(&Session->ProcessList))
1077  {
1079  EPROCESS,
1080  SessionProcessLinks);
1081 
1082  /* Reference the process */
1084  break;
1085  }
1086  }
1087  }
1088 
1089  /* Release the lock again */
1091 
1092  return Process;
1093 }
PFN_NUMBER MiSessionTagSizePages
Definition: session.c:22
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
VOID NTAPI MiDereferenceSessionFinal(VOID)
Definition: session.c:274
MMSUPPORT Vm
Definition: miarm.h:506
union _MM_SESSION_SPACE::@1814 u
ULONG SessionId
Definition: miarm.h:483
LIST_ENTRY ProcessList
Definition: miarm.h:484
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define IN
Definition: typedefs.h:39
#define PspClearProcessFlag(Process, Flag)
Definition: ps_x.h:35
SIZE_T NonPageablePages
Definition: miarm.h:487
#define MI_SESSION_TAG_PAGES_MAXIMUM
Definition: miarm.h:254
LONG ReferenceCount
Definition: miarm.h:477
#define MiAddressToPde(x)
Definition: mmx86.c:20
FORCEINLINE KIRQL MiAcquireExpansionLock(VOID)
Definition: miarm.h:1386
ULONG MmSessionSize
Definition: init.c:34
USHORT UsedPageTableEntries[768]
Definition: mmtypes.h:879
#define PSF_SESSION_CREATION_UNDERWAY_BIT
Definition: pstypes.h:278
VOID FASTCALL KeAcquireGuardedMutex(IN PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:42
PMMPDE PageTables
Definition: miarm.h:513
KSPIN_LOCK MmExpansionLock
Definition: session.c:32
LONG ProcessReferenceToSession
Definition: miarm.h:500
#define TRUE
Definition: types.h:120
PMMPTE NTAPI MiReserveSystemPtes(IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:246
union _MMPTE::@2312 u
#define MI_IS_SESSION_ADDRESS(Address)
Definition: miarm.h:167
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
ULONG SessionId
Definition: dllmain.c:28
PMMWSL VmWorkingSetList
Definition: mmtypes.h:926
PFN_NUMBER MiSessionCreateCharge
Definition: session.c:23
LONG NTSTATUS
Definition: precomp.h:26
NTSYSAPI void WINAPI RtlInitializeBitMap(PRTL_BITMAP, PULONG, ULONG)
VOID NTAPI MiSessionAddProcess(IN PEPROCESS NewProcess)
Definition: session.c:427
PMM_SESSION_SPACE MmSessionSpace
Definition: session.c:21
#define MI_GET_NEXT_COLOR()
Definition: miarm.h:238
LCID NTAPI MmGetSessionLocaleId(VOID)
Definition: session.c:57
LCID PsDefaultSystemLocaleId
Definition: locale.c:20
HARDWARE_PDE_ARMV6 TempPde
Definition: winldr.c:78
FORCEINLINE KIRQL MiAcquirePfnLock(VOID)
Definition: mm.h:900
#define InterlockedCompareExchange
Definition: interlocked.h:104
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
PFN_NUMBER MmLowestPhysicalPage
Definition: meminit.c:30
BOOLEAN NTAPI MmIsSessionAddress(IN PVOID Address)
Definition: session.c:49
ULONG SessionLeader
Definition: mmtypes.h:890
#define RtlCheckBit(BMH, BP)
Definition: rtlfuncs.h:3154
VOID NTAPI MiInitializePfnForOtherProcess(IN PFN_NUMBER PageFrameIndex, IN PVOID PteAddress, IN PFN_NUMBER PteFrame)
Definition: pfnlist.c:1280
PVOID MiSessionSpaceWs
Definition: mminit.c:130
KGUARDED_MUTEX MiSessionIdMutex
Definition: session.c:24
DWORD LCID
Definition: nls.h:13
VOID NTAPI MiZeroPhysicalPage(IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:122
ULONG MinimumWorkingSetSize
Definition: mmtypes.h:924
GLdouble u1
Definition: glext.h:8308
#define PSF_PROCESS_IN_SESSION_BIT
Definition: pstypes.h:280
#define InsertTailList(ListHead, Entry)
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
LCID PsDefaultThreadLocaleId
Definition: locale.c:25
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
LIST_ENTRY MmWorkingSetExpansionHead
Definition: session.c:30
VOID NTAPI MiSessionRemoveProcess(VOID)
Definition: session.c:396
ULONG64 Global
Definition: mmtypes.h:166
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
ULONG NTAPI MmGetSessionId(IN PEPROCESS Process)
Definition: session.c:180
FORCEINLINE VOID MiReleasePfnLock(_In_ KIRQL OldIrql)
Definition: mm.h:907
NTSTATUS NTAPI MmSessionDelete(IN ULONG SessionId)
Definition: session.c:891
struct Color Color
PFN_NUMBER MiSessionTagPages
Definition: session.c:22
LONG MmSessionDataPages
Definition: session.c:25
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define STATUS_ALREADY_COMMITTED
Definition: ntstatus.h:270
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define MI_MAKE_DIRTY_PAGE(x)
Definition: mm.h:98
PDRIVER_UNLOAD Win32KDriverUnload
Definition: miarm.h:508
PVOID MmSessionBase
Definition: init.c:33
VOID NTAPI MiSessionLeader(IN PEPROCESS Process)
Definition: session.c:168
#define MiAddressToPte(x)
Definition: mmx86.c:19
ULONG PFN_NUMBER
Definition: ke.h:8
volatile LONG MiSessionLeaderExists
Definition: session.c:27
LIST_ENTRY WsListEntry
Definition: miarm.h:501
#define TAG_MM
Definition: tag.h:136
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define FALSE
Definition: types.h:117
FORCEINLINE VOID MI_WRITE_VALID_PTE(IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: miarm.h:942
VOID NTAPI KeStackAttachProcess(IN PKPROCESS Process, OUT PRKAPC_STATE ApcState)
Definition: procobj.c:701
ULONG_PTR ShareCount
Definition: mm.h:328
long LONG
Definition: pedump.c:60
ULONG SessionSpace
Definition: mmtypes.h:888
_IRQL_requires_max_(APC_LEVEL)
Definition: session.c:90
#define RtlInterlockedClearBits(Flags, Flag)
Definition: rtlfuncs.h:3442
NTSTATUS NTAPI MiSessionInitializeWorkingSetList(VOID)
Definition: session.c:465
#define PsGetCurrentProcess
Definition: psfuncs.h:17
FORCEINLINE PFN_NUMBER MiRemoveZeroPageSafe(IN ULONG Color)
Definition: miarm.h:2297
unsigned char BOOLEAN
PETHREAD MiExpansionLockOwner
Definition: session.c:33
static WCHAR Address[46]
Definition: ping.c:68
VOID NTAPI MiInitializeSessionIds(VOID)
Definition: session.c:117
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
#define _Out_
Definition: no_sal2.h:160
NTSYSAPI ULONG WINAPI RtlFindClearBitsAndSet(PRTL_BITMAP, ULONG, ULONG)
#define ExInitializePushLock
Definition: ex.h:987
VOID NTAPI MiDecrementShareCount(IN PMMPFN Pfn1, IN PFN_NUMBER PageFrameIndex)
Definition: pfnlist.c:1133
FORCEINLINE VOID MI_WRITE_VALID_PDE(IN PMMPDE PointerPde, IN MMPDE TempPde)
Definition: miarm.h:1001
#define MI_SET_USAGE(x)
Definition: mm.h:259
VOID NTAPI MiReleaseSystemPtes(IN PMMPTE StartingPte, IN ULONG NumberOfPtes, IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType)
Definition: syspte.c:275
NTSTATUS NTAPI MiSessionCreateInternal(OUT PULONG SessionId)
Definition: session.c:603
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
VOID NTAPI KeFlushEntireTb(IN BOOLEAN Invalid, IN BOOLEAN AllProcessors)
Definition: cpu.c:416
ULONG LongFlags
Definition: miarm.h:480
PVOID Session
Definition: pstypes.h:1267
struct _MMPFN::@1786::@1792 e2
union _MMPFN::@1785 u2
Status
Definition: gdiplustypes.h:24
#define STATUS_UNABLE_TO_FREE_VM
Definition: ntstatus.h:263
ULONG PageFrameNumber
Definition: mmtypes.h:74
MMSUPPORT_FLAGS Flags
Definition: mmtypes.h:916
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
EX_PUSH_LOCK WorkingSetMutex
Definition: mmtypes.h:944
VOID NTAPI MiDereferenceSession(VOID)
Definition: session.c:340
MM_SESSION_SPACE_FLAGS Flags
Definition: miarm.h:481
struct _MM_SESSION_SPACE * GlobalVirtualAddress
Definition: miarm.h:476
ULONG CurrentProcess
Definition: shell.c:125
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
LIST_ENTRY WorkingSetExpansionLinks
Definition: mmtypes.h:908
VOID FASTCALL KeZeroPages(IN PVOID Address, IN ULONG Size)
Definition: stubs.c:91
#define ASSERT(a)
Definition: mode.c:45
if(!(yy_init))
Definition: macro.lex.yy.c:714
SIZE_T CommittedPages
Definition: miarm.h:488
PRTL_BITMAP MiSessionIdBitmap
Definition: session.c:26
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
_In_ WDFCOLLECTION _In_ ULONG Index
MMSESSION Session
Definition: miarm.h:503
BOOLEAN NTAPI MiInitializeSystemSpaceMap(IN PMMSESSION InputSession OPTIONAL)
Definition: section.c:240
MMPTE ValidKernelPteLocal
Definition: init.c:33
ULONG64 Valid
Definition: mmtypes.h:150
PFN_NUMBER MiSessionDataPages
Definition: session.c:22
#define STATUS_PROCESS_IS_TERMINATING
Definition: ntstatus.h:502
#define ObDereferenceObject
Definition: obfuncs.h:203
#define MI_SESSION_DATA_PAGES_MAXIMUM
Definition: miarm.h:253
VOID NTAPI RtlClearBit(_In_ PRTL_BITMAP BitMapHeader, _In_ BITMAP_INDEX BitNumber)
Definition: bitmap.c:294
HARDWARE_PTE_ARMV6 TempPte
Definition: winldr.c:76
#define _Inout_
Definition: no_sal2.h:162
MMPTE ValidKernelPte
Definition: init.c:29
BOOLEAN NTAPI MmIsAddressValid(IN PVOID VirtualAddress)
Definition: mmsup.c:174
struct _MMWSL * PMMWSL
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
_Must_inspect_result_ _In_ PWDFDEVICE_INIT _In_ PCUNICODE_STRING _In_ PCUNICODE_STRING _In_ LCID LocaleId
Definition: wdfpdo.h:430
#define BYTES_TO_PAGES(Size)
FORCEINLINE PMMPFN MI_PFN_ELEMENT(IN PFN_NUMBER Pfn)
Definition: miarm.h:1429
PMMWSLE Wsle
Definition: mmtypes.h:869
#define InterlockedDecrement
Definition: armddk.h:52
PMMWSLE_HASH HashTable
Definition: mmtypes.h:872
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:790
#define MI_INITIAL_SESSION_IDS
Definition: miarm.h:208
#define KeEnterCriticalRegion()
Definition: ke_x.h:83
Definition: mm.h:311
#define PAGE_SIZE
Definition: env_spec_w32.h:49
Definition: typedefs.h:119
KPROCESS Pcb
Definition: pstypes.h:1204
PVOID NTAPI MmGetSessionById(_In_ ULONG SessionId)
Definition: session.c:1054
LIST_ENTRY ImageList
Definition: miarm.h:495
LIST_ENTRY MiSessionWsList
Definition: session.c:29
MMPTE ValidKernelPdeLocal
Definition: init.c:32
MMSUPPORT Vm
Definition: pstypes.h:1298
ULONG_PTR Long
Definition: mmtypes.h:215
#define _In_
Definition: no_sal2.h:158
PFN_NUMBER NTAPI MiRemoveAnyPage(IN ULONG Color)
Definition: pfnlist.c:475
VOID NTAPI MiReleaseProcessReferenceToSessionDataPage(IN PMM_SESSION_SPACE SessionGlobal)
Definition: session.c:210
MMPTE_HARDWARE Hard
Definition: mmtypes.h:217
#define MI_SET_PFN_DELETED(x)
Definition: miarm.h:190
PFN_COUNT MmNumberOfPhysicalPages
Definition: init.c:48
KEVENT AttachEvent
Definition: miarm.h:498
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31
#define KeLeaveCriticalRegion()
Definition: ke_x.h:114
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define InterlockedIncrement
Definition: armddk.h:53
ULONG NTAPI MmGetSessionIdEx(IN PEPROCESS Process)
Definition: session.c:195
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define ROUND_TO_PAGES(Size)
ULONG HashTableSize
Definition: mmtypes.h:873
VOID NTAPI KeUnstackDetachProcess(IN PRKAPC_STATE ApcState)
Definition: procobj.c:753
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
PMMWSLE Wsle
Definition: miarm.h:507
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
_Out_ PKAPC_STATE ApcState
Definition: mm.h:1484
LONG ResidentProcessCount
Definition: miarm.h:493
unsigned int * PULONG
Definition: retypes.h:1
#define NULL
Definition: types.h:112
FORCEINLINE VOID MiReleaseExpansionLock(KIRQL OldIrql)
Definition: miarm.h:1399
NTSYSAPI void WINAPI RtlClearAllBits(PRTL_BITMAP)
VOID FASTCALL KeReleaseGuardedMutex(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:53
#define DPRINT1
Definition: precomp.h:8
ULONG WsIndex
Definition: mm.h:316
union _MMPFN::@1786 u3
struct _MM_SESSION_SPACE * PMM_SESSION_SPACE
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
#define OUT
Definition: typedefs.h:40
#define ObReferenceObject
Definition: obfuncs.h:204
#define PspSetProcessFlag(Process, Flag)
Definition: ps_x.h:33
VOID NTAPI MiInitializePfnAndMakePteValid(IN PFN_NUMBER PageFrameIndex, IN PMMPTE PointerPte, IN MMPTE TempPte)
Definition: pfnlist.c:1036
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:581
#define PDE_MAPPED_VA
Definition: mm.h:39
#define STATUS_INVALID_SYSTEM_SERVICE
Definition: ntstatus.h:265
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
NTSTATUS NTAPI MmSessionCreate(OUT PULONG SessionId)
Definition: session.c:831
#define ULONG_PTR
Definition: config.h:101
VOID NTAPI MiInitializeSessionWsSupport(VOID)
Definition: session.c:40
ULONG AttachCount
Definition: miarm.h:497
PFN_NUMBER MmHighestPhysicalPage
Definition: meminit.c:31
#define STATUS_SUCCESS
Definition: shellext.h:65
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
FORCEINLINE PVOID MiPteToAddress(PMMPTE PointerPte)
Definition: mm.h:201
ULONG MaximumWorkingSetSize
Definition: mmtypes.h:925
FORCEINLINE BOOLEAN MI_IS_PHYSICAL_ADDRESS(IN PVOID Address)
Definition: miarm.h:928
PFN_NUMBER MiSessionBigPoolPages
Definition: session.c:23
signed int * PLONG
Definition: retypes.h:5
ULONG LastEntry
Definition: mmtypes.h:867
VOID NTAPI MmQuitNextSession(_Inout_ PVOID SessionEntry)
Definition: session.c:1034
#define APC_LEVEL
Definition: env_spec_w32.h:695
#define PFN_FROM_PTE(v)
Definition: mm.h:92
VOID NTAPI KeBugCheckEx(_In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4)
Definition: rtlcompat.c:108
* PKAPC_STATE
Definition: ketypes.h:1279
struct _MMWSLE * PMMWSLE
ULONG PageFrameNumber
Definition: mmtypes.h:109
PFN_NUMBER SessionPageDirectoryIndex
Definition: miarm.h:486
#define PAGED_CODE()