3.3 windows,ReactOS系统中页面的换出----1

关注

原创 2024-11-03 20:53:49 1.2k 阅读 AI 写同款· GEO 优化 ›

[YIUI付费插件] 超级循环列表yiuisuperscroll 本文介绍基于YIUI框架实现循环列表（LoopListView2）的完整流程：在Scroll Rect上挂载LoopListView2并配置预制体，为Item添加Click同步事件；通过ServerListPanelComponent与ServerInfoItemComponent配合，使用YIUISuperScrollListRenderer和YIUISuperScrollListOnClick实现数据渲染与点击响应，支持动态刷新列表、选中状态管理及服务器信息绑定，高效构建可交互的滚动列表界面。阅读详情

系列文章目录

3.3 页面的换出

在前一节中我们看到，如果有映射的页面已经被倒换到磁盘上即倒换文件中，那么对这个页面的访问就会引起一次缺页异常，而相应的异常处理程序就会从磁盘上把这个页面倒换进来。这自然就会产生一个问题:这个页面是在什么时候又是怎样跑到磁盘上去的呢?当然，页面(的内容)不会自己跑到磁盘上，而得有个行为主体将其倒出到磁盘上，这个行为主体就是内核线程MiBalancerThread() .

MiBalancerThread()


VOID STDCALL
MiBalancerThread(PVOID Unused)
{
   PVOID WaitObjects[2];
 ....

   WaitObjects[0] = &MiBalancerEvent;//通过Event唤醒
   WaitObjects[1] = &MiBalancerTimer;//通过定时器唤醒

   while (1)
   {
      Status = KeWaitForMultipleObjects(2,
                                        WaitObjects,
                                        WaitAny,
                                        Executive,
                                        KernelMode,
                                        FALSE,
                                        NULL,
                                        NULL);

      if (Status == STATUS_SUCCESS)
      {//因为事件而被（某个线程）唤醒
         /* MiBalancerEvent */
         CHECKPOINT;
         while (MmStats.NrFreePages < MiMinimumAvailablePages + 5)
         {//循环，知道有一个数量的空闲物理页面
            for (i = 0; i < MC_MAXIMUM; i++)
            {
               if (MiMemoryConsumers[i].Trim != NULL)
               {//调用内存消费者的修剪函数
                  NrFreedPages = 0;
                  Status = MiMemoryConsumers[i].Trim(MiMinimumPagesPerRun, 0, &NrFreedPages);
                  if (!NT_SUCCESS(Status))
                  {
                     KEBUGCHECK(0);
                  }
               }
            }
         }
         InterlockedExchange(&MiBalancerWork, 0);
         CHECKPOINT;
      }
      else if (Status == STATUS_SUCCESS + 1)
      {
         /* MiBalancerTimer *///因超时而被唤醒
         ShouldRun = MmStats.NrFreePages < MiMinimumAvailablePages + 5 ? TRUE : FALSE;
         for (i = 0; i < MC_MAXIMUM; i++)//对于所有的内存消费者
         {
            if (MiMemoryConsumers[i].Trim != NULL)
            {
               NrPagesUsed = MiMemoryConsumers[i].PagesUsed;
               if (NrPagesUsed > MiMemoryConsumers[i].PagesTarget || ShouldRun)
               {//本消费者占用页面数已超过配额，或总库存已降到危险点
                  if (NrPagesUsed > MiMemoryConsumers[i].PagesTarget)
                  {
                     Target = max (NrPagesUsed - MiMemoryConsumers[i].PagesTarget,
                                   MiMinimumPagesPerRun);
                  }
                  else
                  {
                     Target = MiMinimumPagesPerRun;//每次至少修剪的数量
                  }
                  NrFreedPages = 0;
                  //执行本消费者的修剪函数
                  Status = MiMemoryConsumers[i].Trim(Target, 0, &NrFreedPages);
                  if (!NT_SUCCESS(Status))
                  {
                     KEBUGCHECK(0);
                  }
               }
            }
         }
      }
      else
      {//因其他原因被唤醒，不应发生
         DPRINT1("KeWaitForMultipleObjects failed, status = %x\n", Status);
         KEBUGCHECK(0);
      }
   }
}

这个线程平时都在睡眠，但是周期性地通过事件MiBalancerTimer 被定时器唤醒。此外，这个线程也可以通过事件 MiBalancerEvent 被唤醒，这发生在需要分配物理页面却发现库存不足的时候每当这个线程被唤醒的时候，它就借助若干个内存“消费者(Consumer)”的“修剪函数”对内存加以“修剪(Trim)”。所谓修剪，就是把一些判断为暂时不会被访问的页面(的内容)倒换出去，腾出所占据的物理页面另行分配，

如前所述，所谓内存“消费者”并不是指实际占用着物理页面的进程，而是指各种不同的用途例如用户空间的页面映射，内核中的可倒换物理页面池、不可倒换物理页面池，磁盘上扇区内容的高速缓存等。内核中有个结构数组MiMemoryConsumers[]，其中的每个元素都代表一个“消费者”其下标可以是:

#define MC_CACHE                            (0)
#define MC_USER                             (1)
#define MC_PPOOL                            (2)
#define MC_NPPOOL                           (3)
#define MC_MAXIMUM                          (4)

显然,每一种用途即“消费者”都应该提供自己的修剪函数:但是目前ReactOS只为MC_CACHE和MC_USER提供了修剪函数。换言之，另两种用途的页面是不让修剪的。其中用户空间页面所映射物理页面的修剪函数为MmTrimUserMemory()。

MmTrimUserMemory（）

[MiBalancerThread()>MmTrimUserMemory()]

/* FUNCTIONS *****************************************************************/

NTSTATUS
MmTrimUserMemory(ULONG Target, ULONG Priority, PULONG NrFreedPages)
{
   PFN_TYPE CurrentPage;
   PFN_TYPE NextPage;
   NTSTATUS Status;

   (*NrFreedPages) = 0;

   CurrentPage = MmGetLRUFirstUserPage();//运用LRU算法找到第一个可以倒出的页面
   while (CurrentPage != 0 && Target > 0)
   {
      NextPage = MmGetLRUNextUserPage(CurrentPage);//下一个可以倒出的页面//倒出物理页面 CurrentPage


      Status = MmPageOutPhysicalAddress(CurrentPage);
      if (NT_SUCCESS(Status))
      {
         DPRINT("Succeeded\n");
         Target--;
         (*NrFreedPages)++;
      }
      else if (Status == STATUS_PAGEFILE_QUOTA)//已超过倒换文件的容量配额

      {
         MmSetLRULastPage(CurrentPage);//下次再来
      }

      CurrentPage = NextPage;
   }
   return(STATUS_SUCCESS);
}

参数Target是要求修剪的页面数量,NrFreedPages用来返回实际修剪的数量,另一个参数Priority实际上没有被用到。
修剪的对象是“最近最少被用到”的页面，相应的算法为LRU。与MiMemoryConsumers[]平行,内核中还有个队列头数组 UsedPageListHeads[]，也是以 MC_USER 等为下标，凡是被分配用于某个消费者的物理页面，其数据结构都按LRU的次序挂在其队列中。LRU是一种常用的算法，我们就不深入到这里面去了。
找到修剪对象的物理页面号之后，就通过MmPageOutPhysicalAddressO)将其倒换出去。

MmPageOutVirtualMemory（）

[MiBalancerThread()> MmTrimUserMemory() > MmPageOutPhysicalAddress()>MmPageOutVirtualMemory()]


NTSTATUS
NTAPI
MmPageOutVirtualMemory(PMADDRESS_SPACE AddressSpace,
                       PMEMORY_AREA MemoryArea,
                       PVOID Address,
                       PMM_PAGEOP PageOp)
{
   PFN_TYPE Page;
   BOOLEAN WasDirty;
   SWAPENTRY SwapEntry;
   NTSTATUS Status;

   DPRINT("MmPageOutVirtualMemory(Address 0x%.8X) PID %d\n",
          Address, AddressSpace->Process->UniqueProcessId);

   /*
    * Check for paging out from a deleted virtual memory area.
    */
   if (MemoryArea->DeleteInProgress)
   {
      PageOp->Status = STATUS_UNSUCCESSFUL;
      KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
      MmReleasePageOp(PageOp);
      return(STATUS_UNSUCCESSFUL);
   }

   /*
    * Disable the virtual mapping.//关断目标页面的映射
    */
   MmDisableVirtualMapping(AddressSpace->Process, Address,
                           &WasDirty, &Page);

   if (Page == 0)
   {
      KEBUGCHECK(0);
   }

   /*
    * Paging out non-dirty data is easy.
    */
   if (!WasDirty)
   {//页面是干净的，物理页面空白或其内容与倒换文件中的对应页面完全相同
      MmLockAddressSpace(AddressSpace);
      MmDeleteVirtualMapping(AddressSpace->Process, Address, FALSE, NULL, NULL);
      MmDeleteAllRmaps(Page, NULL, NULL);
      if ((SwapEntry = MmGetSavedSwapEntryPage(Page)) != 0)
      {
         MmCreatePageFileMapping(AddressSpace->Process, Address, SwapEntry);
         MmSetSavedSwapEntryPage(Page, 0);
      }
      MmUnlockAddressSpace(AddressSpace);
      MmReleasePageMemoryConsumer(MC_USER, Page);
      PageOp->Status = STATUS_SUCCESS;
      KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
      MmReleasePageOp(PageOp);
      return(STATUS_SUCCESS);
   }

   /*
    * If necessary, allocate an entry in the paging file for this page
    */
   SwapEntry = MmGetSavedSwapEntryPage(Page);
   if (SwapEntry == 0)
   {
      SwapEntry = MmAllocSwapPage();
      if (SwapEntry == 0)
      {
         MmShowOutOfSpaceMessagePagingFile();
         MmEnableVirtualMapping(AddressSpace->Process, Address);
         PageOp->Status = STATUS_UNSUCCESSFUL;
         KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
         MmReleasePageOp(PageOp);
         return(STATUS_PAGEFILE_QUOTA);
      }
   }

   /*
    * Write the page to the pagefile
    */
   Status = MmWriteToSwapPage(SwapEntry, Page);
   if (!NT_SUCCESS(Status))
   {
      DPRINT1("MM: Failed to write to swap page (Status was 0x%.8X)\n",
              Status);
      MmEnableVirtualMapping(AddressSpace->Process, Address);
      PageOp->Status = STATUS_UNSUCCESSFUL;
      KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
      MmReleasePageOp(PageOp);
      return(STATUS_UNSUCCESSFUL);
   }

   /*
    * Otherwise we have succeeded, free the page
    */
   DPRINT("MM: Swapped out virtual memory page 0x%.8X!\n", Page << PAGE_SHIFT);
   MmLockAddressSpace(AddressSpace);
   MmDeleteVirtualMapping(AddressSpace->Process, Address, FALSE, NULL, NULL);
   MmCreatePageFileMapping(AddressSpace->Process, Address, SwapEntry);
   MmUnlockAddressSpace(AddressSpace);
   MmDeleteAllRmaps(Page, NULL, NULL);
   MmSetSavedSwapEntryPage(Page, 0);
   MmReleasePageMemoryConsumer(MC_USER, Page);
   PageOp->Status = STATUS_SUCCESS;
   KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
   MmReleasePageOp(PageOp);
   return(STATUS_SUCCESS);
}

需要倒换出去的页面可能是“干净”的，也可能是“脏”的。

所谓干净的页面，是指自从上一次建立通向这个物理页面的映射以来从未对其进行过写操作的面，具体有两种可能:

1,这是个刚被分配并建立映射但从未被写过的空白页面。这样的页面在倒换文件中尚无对应的倒换页面，也不需要有，因为以后需要时可以重新分配一个空白页面。所以只要删除其映射，并通过 MmDeleteAlRmaps()使其与所属的进程脱钩，最后释放这个物理页面就可以了

2,这是个从倒换文件换入的页面，但是换入之后从未被写过。这样的页面在倒换文件中已经有了对应的倒换页面，但是不需要改变倒换页面的内容。对于这样的页面，一方面要删除其映射，另一方面要使相应的页面映射表项指向倒换文件中的页面。凡是有了倒换页面的物理页面，其PHYSICAL PAGE结构中的SavedSwapEntry字段就指向这个倒换页面，现在一方面将该字段的内容转移到相应的页面映射表项中(并将其PAPRESENT标志位清0)，另一方面通过 MmSetSavedSwapEntryPage()将这个字段清 0。然后再释放这个物理页面。

倒换页面是由“倒换页面项”SWAPENTRY描述的，这是个32位无符号整数，实际上是倒换文件号与文件内页面号的组合

所谓脏的页面，则是指自从上一次建立通向这个物理页面的映射以来已经对其进行过写操作的面，具体又有两种可能:

1,这本是个刚被分配并建立映射的空白页面，但是现在已经不再空白。这样的页面在倒换文件中尚无对应的倒换页面，但是需要有。所以通过MmAllocSwapPageO)分配一个倒换页面这个函数返回一个SWAPENTRY，说明是哪一个倒换文件中的哪一个页面。然后通过MmWriteToSwapPage()将页面的内容写入倒换文件,再将相应的页面映射表项改成指向倒换页面(并将其 PA_PRESENT标志位清0)，最后释放该物理页面。

2,这是个从倒换文件换入的页面，但是换入之后已经被写过。这样的页面在倒换文件中已经有了对应的倒换页面，但需要改变其内容。所以也由MmWriteToSwapPageO)将页面的内容写入倒换文件，再将相应的页面映射表项改成指向倒换页面(并将其PA_PRESENT标志位清 0)，最后释放该物理页面。

至于 MmWriteToSwapPage()，则已经属于文件操作的范畴，这里就不深入下去了。最后再概括一下倒换页面与物理内存页
面和页面映射表项PTE之间的关系:
1,如果(虚存)页面的内容在物理页面中，则相应的PTE指向该物理内存页面，而物理内存页面的 PHYSICAL_PAGE结构中的SavedSwapEntry 字段指向作为后备的倒换页面。
2,如果(虚存)页面的内容不在物理页面中，则相应的PTE直接指向倒换页面。

收录于