如何保存一个进程的内存现场?

Question

如何保存一个进程的内存现场?----需要用的时候再读回到内存.

Answer 1

这个好像比较困难，不知道你的具体应用是什么。为什么要保护现场呢？其实，Windows本身就提供了一定的这方面的功能。windows的物理不够使用时，就使用页面技术将一些页面保存到硬盘上，当需要的时候再调出来。而且，Windows认为，每一个进程具有自己的4G空间（当然是虚拟的），进程之间互不干涉。从而不知道你这么做具体的目的是什么。

Answer 2

保存是可以的，但是读回来是不可能的，因为你的进程所使用的内存可能已经被别的进程所占用，2000/XP/NT都有保护模式，无法读回来，可以考虑共享内存机制，如CreateFileMapping等，MSDN中有一例，你可看一下：#include <windows.h>
#include <stdio.h>#define MEMORY_REQUESTED 1024*1024 // request a megabyteBOOL
LoggedSetLockPagesPrivilege ( HANDLE hProcess,
                              BOOL bEnable);void _cdecl main()
{
  BOOL bResult;                 // generic Boolean value
  ULONG_PTR NumberOfPages,      // number of pages to request
    NumberOfPagesInitial;       // initial number of pages requested
  ULONG_PTR *aPFNs;             // page info; holds opaque data
  PVOID lpMemReserved;          // AWE window
  SYSTEM_INFO sSysInfo;         // useful system information
  int PFNArraySize;             // memory to request for PFN array  GetSystemInfo(&sSysInfo);     // populate the system information structure  printf ("This computer has a page size of %d.\n", sSysInfo.dwPageSize);  // Calculate the number of pages of memory to request.  NumberOfPages = MEMORY_REQUESTED/sSysInfo.dwPageSize;
  printf ("Requesting %d pages of memory.\n", NumberOfPages);  // Calculate the size of the user PFN array.  PFNArraySize = NumberOfPages * sizeof (ULONG_PTR);  printf ("Requesting a PFN array of %d bytes.\n", PFNArraySize);  aPFNs = (ULONG_PTR *) HeapAlloc (GetProcessHeap (), 0, PFNArraySize);  if (aPFNs == NULL) {
    printf ("Failed to allocate on heap.\n");
    return;
  }  // Enable the privilege.  if( ! LoggedSetLockPagesPrivilege( GetCurrentProcess(), TRUE ) ) {
    return;
  }  // Allocate the physical memory.  NumberOfPagesInitial = NumberOfPages;
  bResult = AllocateUserPhysicalPages( GetCurrentProcess(),
                                       &NumberOfPages,
                                       aPFNs );
    
  if( bResult != TRUE ) 
  {
    printf("Cannot allocate physical pages, error %u.\n", GetLastError() );
    return;
  }  if( NumberOfPagesInitial != NumberOfPages ) 
  {
    printf("Allocated only %p pages.\n", NumberOfPages );
    return;
  }  // Reserve the virtual memory.
    
  lpMemReserved = VirtualAlloc( NULL,
                                MEMORY_REQUESTED,
                                MEM_RESERVE | MEM_PHYSICAL,
                                PAGE_READWRITE );  if( lpMemReserved == NULL ) 
  {
    printf("Cannot reserve memory.\n");
    return;
  }  // Map the physical memory into the window.
    
  bResult = MapUserPhysicalPages( lpMemReserved,
                                  NumberOfPages,
                                  aPFNs );  if( bResult != TRUE ) 
  {
    printf("MapUserPhysicalPages failed to map, error %u.\n", GetLastError() );
    return;
  }  // unmap
    
  bResult = MapUserPhysicalPages( lpMemReserved,
                                  NumberOfPages,
                                  NULL );  if( bResult != TRUE ) 
  {
    printf("MapUserPhysicalPages failed to unmap, error %u.\n", GetLastError() );
    return;
  }  // Free the physical pages.  bResult = FreeUserPhysicalPages( GetCurrentProcess(),
                                   &NumberOfPages,
                                   aPFNs );  if( bResult != TRUE ) 
  {
    printf("Cannot free physical pages, error %u.\n", GetLastError() );
    return;
  }  // Free virtual memory.  bResult = VirtualFree( lpMemReserved,
                         0,
                         MEM_RELEASE );
}/*****************************************************************
   LoggedSetLockPagesPrivilege: a function to obtain, if possible, or
   release the privilege of locking physical pages.   Inputs:       HANDLE hProcess: Handle for the process for which the
       privilege is needed       BOOL bEnable: Enable (TRUE) or disable?   Return value: TRUE indicates success, FALSE failure.*****************************************************************/
BOOL
LoggedSetLockPagesPrivilege ( HANDLE hProcess,
                              BOOL bEnable)
{
  struct {
    DWORD Count;
    LUID_AND_ATTRIBUTES Privilege [1];
  } Info;  HANDLE Token;
  BOOL Result;  // Open the token.  Result = OpenProcessToken ( hProcess,
                              TOKEN_ADJUST_PRIVILEGES,
                              & Token);  if( Result != TRUE ) {
    printf( "Cannot open process token.\n" );
    return FALSE;
  }  // Enable or disable?  Info.Count = 1;
  if( bEnable ) 
  {
    Info.Privilege[0].Attributes = SE_PRIVILEGE_ENABLED;
  } 
  else 
  {
    Info.Privilege[0].Attributes = 0;
  }  // Get the LUID.  Result = LookupPrivilegeValue ( NULL,
                                  SE_LOCK_MEMORY_NAME,
                                  &(Info.Privilege[0].Luid));  if( Result != TRUE ) 
  {
    printf( "Cannot get privilege value for %s.\n", SE_LOCK_MEMORY_NAME );
    return FALSE;
  }  // Adjust the privilege.  Result = AdjustTokenPrivileges ( Token, FALSE,
                                   (PTOKEN_PRIVILEGES) &Info,
                                   NULL, NULL, NULL);  // Check the result.  if( Result != TRUE ) 
  {
    printf ("Cannot adjust token privileges, error %u.\n", GetLastError() );
    return FALSE;
  } 
  else 
  {
    if( GetLastError() != ERROR_SUCCESS ) 
    {
      printf ("Cannot enable SE_LOCK_MEMORY privilege, please check the local policy.\n");
      return FALSE;
    }
  }  CloseHandle( Token );  return TRUE;
}