You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5279 lines
156 KiB
5279 lines
156 KiB
/*++
|
|
|
|
Copyright (c) 1990 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
hiber.c
|
|
|
|
Abstract:
|
|
|
|
Author:
|
|
|
|
Ken Reneris (kenr) 13-April-1997
|
|
|
|
Revision History:
|
|
|
|
Elliot Shmukler (t-ellios) 8/7/1998 Added Hiber file compression
|
|
Andrew Kadatch (akadatch)
|
|
Added Xpress file compression
|
|
Added DMA-based IO
|
|
|
|
--*/
|
|
|
|
|
|
#include "pop.h"
|
|
#include "stdio.h" // for sprintf
|
|
#include "inbv.h"
|
|
#include "xpress.h" // XPRESS declarations
|
|
|
|
// size of buffer to store compressed data
|
|
#define POP_COMPRESSED_PAGE_SET_SIZE (((XPRESS_MAX_SIZE + 2 * XPRESS_HEADER_SIZE + PAGE_SIZE - 1) >> PAGE_SHIFT) + 1)
|
|
|
|
// Structure used to allocate memory for hand-crafted MDL
|
|
typedef struct _DUMP_MDL {
|
|
MDL BaseMdl;
|
|
PFN_NUMBER PfnArray[POP_MAX_MDL_SIZE + 1];
|
|
} DUMP_MDL[1];
|
|
|
|
typedef struct _COMPRESSION_BLOCK {
|
|
UCHAR Buffer[XPRESS_MAX_SIZE], *Ptr;
|
|
} COMPRESSION_BLOCK, *PCOMPRESSION_BLOCK;
|
|
|
|
|
|
// Data structures for DMA-based IO
|
|
typedef struct
|
|
{
|
|
PUCHAR Beg; // ptr to the beginning of entire
|
|
PUCHAR End; // ptr to the end of memory block
|
|
|
|
PUCHAR Ptr; // ptr to beginning of region
|
|
LONG Size; // size of region after ptr
|
|
LONG SizeOvl; // size of overlapping piece starting from beginning of buffer
|
|
} IOREGION;
|
|
|
|
|
|
#define IOREGION_BUFF_PAGES 64 /* 256 KB */
|
|
#define IOREGION_BUFF_SIZE (IOREGION_BUFF_PAGES << PAGE_SHIFT)
|
|
|
|
typedef struct {
|
|
PLARGE_INTEGER FirstMcb;
|
|
PLARGE_INTEGER Mcb;
|
|
ULONGLONG Base;
|
|
} POP_MCB_CONTEXT, *PPOP_MCB_CONTEXT;
|
|
|
|
#define HIBER_WRITE_PAGES_LOCALS_LIST(X)\
|
|
X (ULONGLONG, FileBase); \
|
|
X (ULONGLONG, PhysBase); \
|
|
X (ULONG_PTR, Length); \
|
|
X (ULONGLONG, McbOffset); \
|
|
X (LARGE_INTEGER, IoLocation); \
|
|
X (PHYSICAL_ADDRESS, pa); \
|
|
X (PPOP_MCB_CONTEXT, CMcb); \
|
|
X (PVOID, PageVa); \
|
|
X (PMDL, Mdl); \
|
|
X (PPFN_NUMBER, MdlPage); \
|
|
X (PFN_NUMBER, NoPages); \
|
|
X (PFN_NUMBER, FilePage); \
|
|
X (ULONG, IoLength); \
|
|
X (ULONG, i); \
|
|
X (NTSTATUS, Status);
|
|
|
|
typedef struct
|
|
{
|
|
DUMP_MDL DumpMdl;
|
|
#define X(type,name) type name
|
|
HIBER_WRITE_PAGES_LOCALS_LIST (X)
|
|
#undef X
|
|
} HIBER_WRITE_PAGES_LOCALS;
|
|
|
|
typedef struct {
|
|
IOREGION Free, Used, Busy;
|
|
PFN_NUMBER FilePage[IOREGION_BUFF_PAGES];
|
|
PVOID DumpLocalData;
|
|
ULONG UseDma;
|
|
ULONG DmaInitialized;
|
|
|
|
struct {
|
|
PUCHAR Ptr;
|
|
ULONG Bytes;
|
|
} Chk;
|
|
|
|
HIBER_WRITE_PAGES_LOCALS HiberWritePagesLocals;
|
|
} DMA_IOREGIONS;
|
|
|
|
#define DmaIoPtr ((DMA_IOREGIONS *)(HiberContext->DmaIO))
|
|
|
|
// May we use DMA IO?
|
|
#define HIBER_USE_DMA(HiberContext) \
|
|
(DmaIoPtr != NULL && \
|
|
DmaIoPtr->UseDma && \
|
|
HiberContext->DumpStack->Init.WritePendingRoutine != NULL)
|
|
|
|
#define HbCopy(_hibercontext_,_dest_,_src_,_len_) { \
|
|
ULONGLONG _starttime_; \
|
|
\
|
|
(_hibercontext_)->PerfInfo.BytesCopied += (ULONG)(_len_); \
|
|
_starttime_ = HIBER_GET_TICK_COUNT(NULL); \
|
|
RtlCopyMemory((_dest_),(_src_),(_len_)); \
|
|
(_hibercontext_)->PerfInfo.CopyTicks += \
|
|
HIBER_GET_TICK_COUNT(NULL) - _starttime_; \
|
|
}
|
|
|
|
|
|
#ifdef HIBER_DEBUG
|
|
#define DBGOUT(x) DbgPrint x
|
|
#else
|
|
#define DBGOUT(x)
|
|
#endif
|
|
|
|
//
|
|
// The performance counter on x86 doesn't work very well during hibernate
|
|
// because interrupts are turned off and we don't get the rollovers. So use
|
|
// RDTSC instead.
|
|
//
|
|
#if !defined(i386)
|
|
#define HIBER_GET_TICK_COUNT(_x_) KeQueryPerformanceCounter(_x_).QuadPart
|
|
#else
|
|
__inline
|
|
LONGLONG
|
|
HIBER_GET_TICK_COUNT(
|
|
OUT PLARGE_INTEGER Frequency OPTIONAL
|
|
)
|
|
{
|
|
if (ARGUMENT_PRESENT(Frequency)) {
|
|
Frequency->QuadPart = (ULONGLONG)KeGetCurrentPrcb()->MHz * 1000000;
|
|
}
|
|
_asm _emit 0x0f
|
|
_asm _emit 0x31
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
extern LARGE_INTEGER KdTimerDifference;
|
|
extern UNICODE_STRING IoArcBootDeviceName;
|
|
extern PUCHAR IoLoaderArcBootDeviceName;
|
|
extern UNICODE_STRING IoArcHalDeviceName;
|
|
extern POBJECT_TYPE IoFileObjectType;
|
|
extern ULONG MmAvailablePages;
|
|
extern PFN_NUMBER MmHighestPhysicalPage;
|
|
extern ULONG MmHiberPages;
|
|
extern ULONG MmZeroPageFile;
|
|
|
|
KPROCESSOR_STATE PoWakeState;
|
|
|
|
//
|
|
// Define the size of the I/Os used to zero the hiber file
|
|
//
|
|
#define POP_ZERO_CHUNK_SIZE (64 * 1024)
|
|
|
|
VOID
|
|
RtlpGetStackLimits (
|
|
OUT PULONG_PTR LowLimit,
|
|
OUT PULONG_PTR HighLimit
|
|
);
|
|
|
|
NTSTATUS
|
|
PopCreateHiberFile (
|
|
IN PPOP_HIBER_FILE HiberFile,
|
|
IN PWCHAR NameString,
|
|
IN PLARGE_INTEGER FileSize,
|
|
IN BOOLEAN DebugHiberFile
|
|
);
|
|
|
|
PSECURITY_DESCRIPTOR
|
|
PopCreateHiberFileSecurityDescriptor(
|
|
VOID
|
|
);
|
|
|
|
NTSTATUS
|
|
PopCreateHiberLinkFile (
|
|
IN PPOP_HIBER_CONTEXT HiberContext
|
|
);
|
|
|
|
VOID
|
|
PopClearHiberFileSignature (
|
|
IN BOOLEAN GetStats
|
|
);
|
|
|
|
VOID
|
|
PopPreserveRange(
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PFN_NUMBER StartPage,
|
|
IN PFN_NUMBER PageCount,
|
|
IN ULONG Tag
|
|
);
|
|
|
|
VOID
|
|
PopCloneRange(
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PFN_NUMBER StartPage,
|
|
IN PFN_NUMBER PageCount,
|
|
IN ULONG Tag
|
|
);
|
|
|
|
VOID
|
|
PopDiscardRange(
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PFN_NUMBER StartPage,
|
|
IN PFN_NUMBER PageCount,
|
|
IN ULONG Tag
|
|
);
|
|
|
|
VOID
|
|
PopSetRange (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN ULONG Flags,
|
|
IN PFN_NUMBER StartPage,
|
|
IN PFN_NUMBER PageCount,
|
|
IN ULONG Tag
|
|
);
|
|
|
|
ULONG
|
|
PopSimpleRangeCheck (
|
|
IN PPOP_MEMORY_RANGE Range
|
|
);
|
|
|
|
VOID
|
|
PopCreateDumpMdl (
|
|
IN PMDL Mdl,
|
|
IN PFN_NUMBER StartPage,
|
|
IN PFN_NUMBER EndPage
|
|
);
|
|
|
|
PVOID
|
|
PopAllocatePages (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PFN_NUMBER NoPages
|
|
);
|
|
|
|
VOID
|
|
PopWriteHiberPages (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PVOID Page,
|
|
IN PFN_NUMBER NoPages,
|
|
IN PFN_NUMBER FilePage,
|
|
IN HIBER_WRITE_PAGES_LOCALS *Locals
|
|
);
|
|
|
|
NTSTATUS
|
|
PopWriteHiberImage (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PPO_MEMORY_IMAGE MemImage,
|
|
IN PPOP_HIBER_FILE HiberFile
|
|
);
|
|
|
|
VOID
|
|
PopUpdateHiberComplete (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN ULONG Percent
|
|
);
|
|
|
|
VOID
|
|
PopReturnMemoryForHibernate (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN BOOLEAN Unmap,
|
|
IN OUT PMDL *MdlList
|
|
);
|
|
|
|
VOID
|
|
PopAddPagesToCompressedPageSet(
|
|
IN BOOLEAN AllowDataBuffering,
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN OUT PULONG_PTR CompressedBufferOffset,
|
|
IN PVOID StartVa,
|
|
IN PFN_NUMBER NumPages,
|
|
IN OUT PPFN_NUMBER SetFilePage
|
|
);
|
|
|
|
VOID
|
|
PopEndCompressedPageSet(
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN OUT PULONG_PTR CompressedBufferOffset,
|
|
IN OUT PPFN_NUMBER SetFilePage
|
|
);
|
|
|
|
UCHAR
|
|
PopGetHiberFlags(
|
|
VOID
|
|
);
|
|
|
|
PMDL
|
|
PopSplitMdl(
|
|
IN PMDL Original,
|
|
IN ULONG SplitPages
|
|
);
|
|
|
|
VOID
|
|
PopZeroHiberFile(
|
|
IN HANDLE FileHandle,
|
|
IN PFILE_OBJECT FileObject
|
|
);
|
|
|
|
PVOID
|
|
PopAllocateOwnMemory(
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN ULONG Bytes,
|
|
IN ULONG Tag
|
|
);
|
|
|
|
PVOID
|
|
XPRESS_CALL
|
|
PopAllocateHiberContextCallback(
|
|
PVOID context,
|
|
int CompressionWorkspaceSize
|
|
);
|
|
|
|
VOID
|
|
PopIORegionMove (
|
|
IN IOREGION *To, // ptr to region descriptor to put bytes to
|
|
IN IOREGION *From, // ptr to region descriptor to get bytes from
|
|
IN LONG Bytes // # of bytes to add to the end of region
|
|
);
|
|
|
|
BOOLEAN
|
|
PopIOResume (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN BOOLEAN Complete
|
|
);
|
|
|
|
VOID
|
|
XPRESS_CALL
|
|
PopIOCallback (
|
|
PVOID Context,
|
|
int Compressed
|
|
);
|
|
|
|
VOID
|
|
PopIOWrite (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PUCHAR Ptr,
|
|
IN LONG Bytes,
|
|
IN PFN_NUMBER FilePage
|
|
);
|
|
|
|
VOID
|
|
PopHiberPoolInit (
|
|
PPOP_HIBER_CONTEXT HiberContext,
|
|
PVOID Memory,
|
|
ULONG Size
|
|
);
|
|
|
|
BOOLEAN
|
|
PopHiberPoolCheckFree(
|
|
PVOID HiberPoolPtr,
|
|
PVOID BlockPtr
|
|
);
|
|
|
|
PVOID
|
|
PopHiberPoolAllocFree (
|
|
IN POOL_TYPE PoolType,
|
|
IN SIZE_T NumberOfBytes,
|
|
IN ULONG Tag,
|
|
PVOID MemoryPtr
|
|
);
|
|
|
|
VOID
|
|
PopDumpStatistics(
|
|
IN PPO_HIBER_PERF PerfInfo
|
|
);
|
|
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE, PopEnableHiberFile)
|
|
#pragma alloc_text(PAGE, PopCreateHiberFile)
|
|
#pragma alloc_text(PAGE, PopClearHiberFileSignature)
|
|
#pragma alloc_text(PAGE, PopAllocateHiberContext)
|
|
#pragma alloc_text(PAGE, PopCreateHiberLinkFile)
|
|
#pragma alloc_text(PAGE, PopGetHiberFlags)
|
|
#pragma alloc_text(PAGE, PopZeroHiberFile)
|
|
#pragma alloc_text(PAGE, PopAllocateHiberContextCallback)
|
|
#pragma alloc_text(PAGELK, PoSetHiberRange)
|
|
#pragma alloc_text(PAGELK, PopGatherMemoryForHibernate)
|
|
#pragma alloc_text(PAGELK, PopCloneStack)
|
|
#pragma alloc_text(PAGELK, PopPreserveRange)
|
|
#pragma alloc_text(PAGELK, PopCloneRange)
|
|
#pragma alloc_text(PAGELK, PopDiscardRange)
|
|
#pragma alloc_text(PAGELK, PopAllocatePages)
|
|
#pragma alloc_text(PAGELK, PopBuildMemoryImageHeader)
|
|
#pragma alloc_text(PAGELK, PopSaveHiberContext)
|
|
#pragma alloc_text(PAGELK, PopWriteHiberImage)
|
|
#pragma alloc_text(PAGELK, PopHiberComplete)
|
|
#pragma alloc_text(PAGELK, PopSimpleRangeCheck)
|
|
#pragma alloc_text(PAGELK, PopCreateDumpMdl)
|
|
#pragma alloc_text(PAGELK, PopWriteHiberPages)
|
|
#pragma alloc_text(PAGELK, PopUpdateHiberComplete)
|
|
#pragma alloc_text(PAGELK, PopFreeHiberContext)
|
|
#pragma alloc_text(PAGELK, PopReturnMemoryForHibernate)
|
|
#pragma alloc_text(PAGELK, PopAddPagesToCompressedPageSet)
|
|
#pragma alloc_text(PAGELK, PopEndCompressedPageSet)
|
|
#pragma alloc_text(PAGELK, PopAllocateOwnMemory)
|
|
#pragma alloc_text(PAGELK, PopIORegionMove)
|
|
#pragma alloc_text(PAGELK, PopIOResume)
|
|
#pragma alloc_text(PAGELK, PopIOCallback)
|
|
#pragma alloc_text(PAGELK, PopIOWrite)
|
|
#pragma alloc_text(PAGELK, PopHiberPoolInit)
|
|
#pragma alloc_text(PAGELK, PopHiberPoolCheckFree)
|
|
#pragma alloc_text(PAGELK, PopHiberPoolAllocFree)
|
|
#pragma alloc_text(PAGELK, PopDumpStatistics)
|
|
#ifdef HIBER_DEBUG
|
|
#pragma alloc_text(PAGELK, PopHiberPoolVfy)
|
|
#endif
|
|
|
|
#endif
|
|
|
|
NTSTATUS
|
|
PopEnableHiberFile (
|
|
IN BOOLEAN Enable
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function commits or decommits the storage required to hold the
|
|
hibernation image on the boot volume.
|
|
|
|
N.B. The power policy lock must be held
|
|
|
|
Arguments:
|
|
|
|
Enable - TRUE if hibernation file is to be reserved; otherwise, false
|
|
|
|
Return Value:
|
|
|
|
Status
|
|
|
|
--*/
|
|
{
|
|
PDUMP_STACK_CONTEXT DumpStack;
|
|
NTSTATUS Status;
|
|
LARGE_INTEGER FileSize;
|
|
ULONG i;
|
|
PFN_NUMBER NoPages;
|
|
|
|
//
|
|
// If this is a disable handle it
|
|
//
|
|
|
|
if (!Enable) {
|
|
if (!PopHiberFile.FileObject) {
|
|
Status = STATUS_SUCCESS;
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Disable hiber file
|
|
//
|
|
if (MmZeroPageFile) {
|
|
PopZeroHiberFile(PopHiberFile.FileHandle, PopHiberFile.FileObject);
|
|
}
|
|
|
|
ObDereferenceObject (PopHiberFile.FileObject);
|
|
ZwClose (PopHiberFile.FileHandle);
|
|
ExFreePool (PopHiberFile.PagedMcb);
|
|
RtlZeroMemory (&PopHiberFile, sizeof(PopHiberFile));
|
|
|
|
if (PopHiberFileDebug.FileObject) {
|
|
|
|
if (MmZeroPageFile) {
|
|
PopZeroHiberFile(PopHiberFileDebug.FileHandle,PopHiberFileDebug.FileObject );
|
|
}
|
|
ObDereferenceObject (PopHiberFileDebug.FileObject);
|
|
ZwClose (PopHiberFileDebug.FileHandle);
|
|
RtlZeroMemory (&PopHiberFileDebug, sizeof(PopHiberFileDebug));
|
|
}
|
|
|
|
//
|
|
// Disable hiberfile allocation
|
|
//
|
|
|
|
PopCapabilities.HiberFilePresent = FALSE;
|
|
PopHeuristics.HiberFileEnabled = FALSE;
|
|
PopHeuristics.Dirty = TRUE;
|
|
|
|
//
|
|
// remove any logging records related to hibernation.
|
|
//
|
|
PopRemoveReasonRecordByReasonCode(SPSD_REASON_HIBERSTACK);
|
|
PopRemoveReasonRecordByReasonCode(SPSD_REASON_HIBERFILE);
|
|
|
|
//
|
|
// recompute the policies and make the proper notification
|
|
//
|
|
Status = PopResetCurrentPolicies ();
|
|
PopSetNotificationWork (PO_NOTIFY_CAPABILITIES);
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Enable hiber file
|
|
//
|
|
|
|
if (PopHiberFile.FileObject) {
|
|
Status = STATUS_SUCCESS;
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// If the hal hasn't registered an S4 handler, then it's not possible
|
|
//
|
|
|
|
if (!PopCapabilities.SystemS4) {
|
|
Status = STATUS_NOT_SUPPORTED;
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Compute the size required for a hibernation file
|
|
//
|
|
|
|
NoPages = 0;
|
|
for (i=0; i < MmPhysicalMemoryBlock->NumberOfRuns; i++) {
|
|
NoPages += MmPhysicalMemoryBlock->Run[i].PageCount;
|
|
}
|
|
|
|
FileSize.QuadPart = (ULONGLONG) NoPages << PAGE_SHIFT;
|
|
|
|
//
|
|
// If we've never verified that the dumpstack loads do so now
|
|
// before we allocate a huge file on the boot disk
|
|
//
|
|
|
|
if (!PopHeuristics.GetDumpStackVerified) {
|
|
Status = IoGetDumpStack ((PWCHAR)PopDumpStackPrefix,
|
|
&DumpStack,
|
|
DeviceUsageTypeHibernation,
|
|
(POP_IGNORE_UNSUPPORTED_DRIVERS & PopSimulate));
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
//
|
|
// try to remember that we can't do S4 because of this.
|
|
//
|
|
PSYSTEM_POWER_STATE_DISABLE_REASON pReason;
|
|
NTSTATUS LogStatus;
|
|
|
|
//
|
|
// alloc and initialize the entry, then insert it.
|
|
//
|
|
pReason = ExAllocatePoolWithTag(
|
|
PagedPool,
|
|
sizeof(SYSTEM_POWER_STATE_DISABLE_REASON),
|
|
POP_COMMON_BUFFER_TAG);
|
|
if (pReason) {
|
|
RtlZeroMemory(pReason,sizeof(SYSTEM_POWER_STATE_DISABLE_REASON));
|
|
pReason->AffectedState[PowerStateSleeping4] = TRUE;
|
|
pReason->PowerReasonCode = SPSD_REASON_HIBERSTACK;
|
|
|
|
LogStatus = PopInsertLoggingEntry(pReason);
|
|
if (LogStatus != STATUS_SUCCESS) {
|
|
ExFreePool(pReason);
|
|
}
|
|
|
|
}
|
|
|
|
goto Done;
|
|
}
|
|
IoFreeDumpStack (DumpStack);
|
|
PopHeuristics.GetDumpStackVerified = TRUE;
|
|
}
|
|
|
|
//
|
|
// Create the hiberfile file
|
|
//
|
|
|
|
Status = PopCreateHiberFile (&PopHiberFile, (PWCHAR)PopHiberFileName, &FileSize, FALSE);
|
|
if (!NT_SUCCESS(Status)) {
|
|
//
|
|
// try to remember that we can't do S4 because of this.
|
|
//
|
|
PSYSTEM_POWER_STATE_DISABLE_REASON pReason;
|
|
NTSTATUS LogStatus;
|
|
|
|
//
|
|
// alloc and initialize the entry, then insert it.
|
|
//
|
|
pReason = ExAllocatePoolWithTag(
|
|
PagedPool,
|
|
sizeof(SYSTEM_POWER_STATE_DISABLE_REASON)+sizeof(Status),
|
|
POP_COMMON_BUFFER_TAG);
|
|
if (pReason) {
|
|
RtlZeroMemory(pReason,sizeof(SYSTEM_POWER_STATE_DISABLE_REASON));
|
|
pReason->AffectedState[PowerStateSleeping4] = TRUE;
|
|
pReason->PowerReasonCode = SPSD_REASON_HIBERFILE;
|
|
pReason->PowerReasonLength = sizeof(Status);
|
|
RtlCopyMemory(
|
|
(PCHAR)((PCHAR)pReason+sizeof(SYSTEM_POWER_STATE_DISABLE_REASON)),
|
|
&Status,
|
|
sizeof(Status));
|
|
|
|
LogStatus = PopInsertLoggingEntry(pReason);
|
|
if (LogStatus != STATUS_SUCCESS) {
|
|
ExFreePool(pReason);
|
|
}
|
|
|
|
}
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Create the debug hiberfile file
|
|
//
|
|
|
|
if (PopSimulate & POP_DEBUG_HIBER_FILE) {
|
|
PopCreateHiberFile (&PopHiberFileDebug, (PWCHAR)PopDebugHiberFileName, &FileSize, TRUE);
|
|
}
|
|
|
|
//
|
|
// Success
|
|
//
|
|
|
|
PopCapabilities.HiberFilePresent = TRUE;
|
|
if (!PopHeuristics.HiberFileEnabled) {
|
|
PopHeuristics.HiberFileEnabled = TRUE;
|
|
PopHeuristics.Dirty = TRUE;
|
|
}
|
|
|
|
PopClearHiberFileSignature (FALSE);
|
|
|
|
Done:
|
|
PopSaveHeuristics ();
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PopCreateHiberFile (
|
|
IN PPOP_HIBER_FILE HiberFile,
|
|
IN PWCHAR NameString,
|
|
IN PLARGE_INTEGER FileSize,
|
|
IN BOOLEAN DebugHiberFile
|
|
)
|
|
{
|
|
UNICODE_STRING BaseName;
|
|
UNICODE_STRING HiberFileName;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
FILE_END_OF_FILE_INFORMATION Eof;
|
|
NTSTATUS Status;
|
|
IO_STATUS_BLOCK IoStatus;
|
|
HANDLE FileHandle = NULL;
|
|
LONGLONG McbFileSize;
|
|
PFILE_OBJECT File = NULL;
|
|
PDEVICE_OBJECT DeviceObject;
|
|
PLARGE_INTEGER mcb;
|
|
ULONG i;
|
|
PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
|
|
|
|
HiberFileName.Buffer = NULL;
|
|
mcb = NULL;
|
|
|
|
RtlInitUnicodeString (&BaseName, NameString);
|
|
|
|
HiberFileName.Length = 0;
|
|
HiberFileName.MaximumLength = IoArcBootDeviceName.Length + BaseName.Length;
|
|
HiberFileName.Buffer = ExAllocatePoolWithTag (PagedPool|POOL_COLD_ALLOCATION,
|
|
HiberFileName.MaximumLength,
|
|
POP_HIBR_TAG);
|
|
|
|
if (!HiberFileName.Buffer) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto Done;
|
|
}
|
|
|
|
RtlAppendUnicodeStringToString(&HiberFileName, &IoArcBootDeviceName);
|
|
RtlAppendUnicodeStringToString(&HiberFileName, &BaseName);
|
|
|
|
//
|
|
// create security descriptor
|
|
//
|
|
SecurityDescriptor = PopCreateHiberFileSecurityDescriptor();
|
|
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&HiberFileName,
|
|
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
|
|
NULL,
|
|
SecurityDescriptor);
|
|
|
|
//
|
|
// Whack any existing file to avoid someone's attempt
|
|
// at file-squatting.
|
|
//
|
|
Status = ZwDeleteFile( &ObjectAttributes );
|
|
|
|
if( !NT_SUCCESS(Status) && (Status != STATUS_OBJECT_NAME_NOT_FOUND) ) {
|
|
|
|
//
|
|
// Could be a directory or a stubborn file...
|
|
// Open the file, fix attributes, then try the delete
|
|
// again.
|
|
//
|
|
|
|
HANDLE Handle;
|
|
PFILE_OBJECT FileObject;
|
|
OBJECT_HANDLE_INFORMATION HandleInfo;
|
|
FILE_BASIC_INFORMATION BasicInfo;
|
|
FILE_DISPOSITION_INFORMATION Disposition;
|
|
|
|
Status = ZwOpenFile( &Handle,
|
|
(ACCESS_MASK)(DELETE | FILE_WRITE_ATTRIBUTES),
|
|
&ObjectAttributes,
|
|
&IoStatus,
|
|
FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
FILE_OPEN_FOR_BACKUP_INTENT | FILE_OPEN_REPARSE_POINT );
|
|
if( NT_SUCCESS(Status) ) {
|
|
|
|
Status = ObReferenceObjectByHandle(
|
|
Handle,
|
|
(ACCESS_MASK)DELETE,
|
|
IoFileObjectType,
|
|
ExGetPreviousMode(),
|
|
&FileObject,
|
|
&HandleInfo
|
|
);
|
|
|
|
if( NT_SUCCESS(Status) ) {
|
|
|
|
|
|
//
|
|
// Reset attributes.
|
|
//
|
|
RtlZeroMemory( &BasicInfo, sizeof( FILE_BASIC_INFORMATION ) );
|
|
BasicInfo.FileAttributes = FILE_ATTRIBUTE_NORMAL;
|
|
IoSetInformation( FileObject,
|
|
FileBasicInformation,
|
|
sizeof(BasicInfo),
|
|
&BasicInfo);
|
|
|
|
|
|
//
|
|
// Setup for delete.
|
|
//
|
|
Disposition.DeleteFile = TRUE;
|
|
IoSetInformation( FileObject,
|
|
FileDispositionInformation,
|
|
sizeof(Disposition),
|
|
&Disposition);
|
|
|
|
|
|
ObDereferenceObject(FileObject);
|
|
}
|
|
|
|
// Close the handle, which should delete the file/directory.
|
|
ZwClose( Handle );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
Status = IoCreateFile(
|
|
&FileHandle,
|
|
FILE_READ_DATA | FILE_WRITE_DATA | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&IoStatus,
|
|
FileSize,
|
|
FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,
|
|
0L,
|
|
FILE_SUPERSEDE,
|
|
FILE_WRITE_THROUGH | FILE_NO_INTERMEDIATE_BUFFERING | FILE_NO_COMPRESSION | FILE_DELETE_ON_CLOSE,
|
|
(PVOID) NULL,
|
|
0L,
|
|
CreateFileTypeNone,
|
|
(PVOID) NULL,
|
|
IO_OPEN_PAGING_FILE | IO_NO_PARAMETER_CHECKING
|
|
);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
PoPrint (PO_HIBERNATE, ("PopCreateHiberFile: failed to create file %x\n", Status));
|
|
goto Done;
|
|
}
|
|
|
|
Status = ObReferenceObjectByHandle (FileHandle,
|
|
FILE_READ_DATA | FILE_WRITE_DATA,
|
|
IoFileObjectType,
|
|
KernelMode,
|
|
(PVOID *)&File,
|
|
NULL);
|
|
if (!NT_SUCCESS(Status)) {
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Set the size
|
|
//
|
|
|
|
Eof.EndOfFile.QuadPart = FileSize->QuadPart;
|
|
Status = ZwSetInformationFile (
|
|
FileHandle,
|
|
&IoStatus,
|
|
&Eof,
|
|
sizeof(Eof),
|
|
FileEndOfFileInformation
|
|
);
|
|
if (Status == STATUS_PENDING) {
|
|
Status = KeWaitForSingleObject(
|
|
&File->Event,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL
|
|
);
|
|
|
|
Status = IoStatus.Status;
|
|
}
|
|
|
|
if (!NT_SUCCESS(Status) || !NT_SUCCESS(IoStatus.Status)) {
|
|
PoPrint (PO_HIBERNATE, ("PopCreateHiberFile: failed to set eof %x %x\n",
|
|
Status, IoStatus.Status
|
|
));
|
|
goto Done;
|
|
}
|
|
|
|
|
|
//
|
|
// Hibernation file needs to be on the boot partition
|
|
//
|
|
|
|
DeviceObject = File->DeviceObject;
|
|
if (!(DeviceObject->Flags & DO_SYSTEM_BOOT_PARTITION)) {
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Get the hiber file's layout
|
|
//
|
|
|
|
Status = ZwFsControlFile (
|
|
FileHandle,
|
|
(HANDLE) NULL,
|
|
(PIO_APC_ROUTINE) NULL,
|
|
(PVOID) NULL,
|
|
&IoStatus,
|
|
FSCTL_QUERY_RETRIEVAL_POINTERS,
|
|
FileSize,
|
|
sizeof (LARGE_INTEGER),
|
|
&mcb,
|
|
sizeof (PVOID)
|
|
);
|
|
|
|
if (Status == STATUS_PENDING) {
|
|
Status = KeWaitForSingleObject(
|
|
&File->Event,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL
|
|
);
|
|
|
|
Status = IoStatus.Status;
|
|
}
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// We have a hibernation file. Determine the number of mcbs, and perform
|
|
// a simply sanity check on them.
|
|
//
|
|
|
|
McbFileSize = 0;
|
|
for (i=0; mcb[i].QuadPart; i += 2) {
|
|
McbFileSize += mcb[i].QuadPart;
|
|
if (mcb[i+1].HighPart < 0) {
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
if (McbFileSize < FileSize->QuadPart) {
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
goto Done;
|
|
}
|
|
|
|
HiberFile->NonPagedMcb = mcb;
|
|
HiberFile->McbSize = (i+2) * sizeof(LARGE_INTEGER);
|
|
HiberFile->PagedMcb = ExAllocatePoolWithTag (PagedPool|POOL_COLD_ALLOCATION,
|
|
HiberFile->McbSize,
|
|
POP_HIBR_TAG);
|
|
|
|
if (!HiberFile->PagedMcb) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto Done;
|
|
}
|
|
|
|
memcpy (HiberFile->PagedMcb, mcb, HiberFile->McbSize);
|
|
HiberFile->FileHandle = FileHandle;
|
|
HiberFile->FileObject = File;
|
|
HiberFile->FilePages = (PFN_NUMBER) (FileSize->QuadPart >> PAGE_SHIFT);
|
|
HiberFile->McbCheck = PoSimpleCheck (0, HiberFile->PagedMcb, HiberFile->McbSize);
|
|
|
|
Done:
|
|
if (!NT_SUCCESS(Status)) {
|
|
if (FileHandle != NULL) {
|
|
ZwClose (FileHandle);
|
|
}
|
|
if (File != NULL) {
|
|
ObDereferenceObject(File);
|
|
}
|
|
}
|
|
|
|
if (SecurityDescriptor) {
|
|
ExFreePool(SecurityDescriptor);
|
|
}
|
|
|
|
if (HiberFileName.Buffer) {
|
|
ExFreePool (HiberFileName.Buffer);
|
|
}
|
|
|
|
if (mcb && !DebugHiberFile) {
|
|
HiberFile->NonPagedMcb = NULL;
|
|
ExFreePool (mcb);
|
|
}
|
|
|
|
|
|
//
|
|
// If no error, then hiber file being present change one way or another -
|
|
// recompute the policies and make the proper notification
|
|
//
|
|
|
|
if (NT_SUCCESS(Status)) {
|
|
PopResetCurrentPolicies ();
|
|
PopSetNotificationWork (PO_NOTIFY_CAPABILITIES);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PopCreateHiberLinkFile (
|
|
IN PPOP_HIBER_CONTEXT HiberContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function creates a file on the loader partition which supplies
|
|
the loader with the location of the hibernation context file
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
UNICODE_STRING BaseName;
|
|
UNICODE_STRING HiberFileName;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
NTSTATUS Status;
|
|
IO_STATUS_BLOCK IoStatus;
|
|
LARGE_INTEGER FileSize;
|
|
LARGE_INTEGER ByteOffset;
|
|
PPO_IMAGE_LINK LinkImage;
|
|
PUCHAR Buffer;
|
|
ULONG Length;
|
|
HANDLE FileHandle=NULL;
|
|
|
|
Buffer = NULL;
|
|
|
|
RtlInitUnicodeString (&BaseName, PopHiberFileName);
|
|
|
|
//
|
|
// Allocate working space
|
|
//
|
|
|
|
Length = IoArcHalDeviceName.Length + BaseName.Length;
|
|
if (Length < IoArcBootDeviceName.Length + sizeof(PO_IMAGE_LINK)) {
|
|
Length = IoArcBootDeviceName.Length + sizeof(PO_IMAGE_LINK);
|
|
}
|
|
|
|
Buffer = ExAllocatePoolWithTag (PagedPool, Length, POP_HIBR_TAG);
|
|
if (!Buffer) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto Done;
|
|
}
|
|
|
|
LinkImage = (PPO_IMAGE_LINK) Buffer;
|
|
HiberFileName.Buffer = (PWCHAR) Buffer;
|
|
HiberFileName.MaximumLength = (USHORT) Length;
|
|
|
|
//
|
|
// Open hiberfil.sys on loader partition
|
|
//
|
|
|
|
HiberFileName.Length = 0;
|
|
RtlAppendUnicodeStringToString(&HiberFileName, &IoArcHalDeviceName);
|
|
RtlAppendUnicodeStringToString(&HiberFileName, &BaseName);
|
|
|
|
InitializeObjectAttributes(
|
|
&ObjectAttributes,
|
|
&HiberFileName,
|
|
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
FileSize.QuadPart = 0;
|
|
Status = IoCreateFile (
|
|
&FileHandle,
|
|
FILE_READ_DATA | FILE_WRITE_DATA | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&IoStatus,
|
|
&FileSize,
|
|
FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM,
|
|
0,
|
|
FILE_SUPERSEDE,
|
|
FILE_SYNCHRONOUS_IO_NONALERT | FILE_NO_COMPRESSION | FILE_DELETE_ON_CLOSE,
|
|
(PVOID) NULL,
|
|
0L,
|
|
CreateFileTypeNone,
|
|
(PVOID) NULL,
|
|
0
|
|
);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
|
|
if (Status != STATUS_SHARING_VIOLATION && Status != STATUS_ACCESS_DENIED) {
|
|
PoPrint (PO_HIBERNATE, ("PopCreateHiberLinkFile: failed to create file %x\n", Status));
|
|
}
|
|
|
|
//
|
|
// Having a link file is nice, but it's not a requirement
|
|
//
|
|
|
|
Status = STATUS_SUCCESS;
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Write the partition name to link to
|
|
//
|
|
|
|
LinkImage->Signature = PO_IMAGE_SIGNATURE_LINK;
|
|
Length = (ULONG) (strlen ((PCHAR)IoLoaderArcBootDeviceName) + 1);
|
|
memcpy (LinkImage->Name, IoLoaderArcBootDeviceName, Length);
|
|
|
|
ByteOffset.QuadPart = 0;
|
|
Status = ZwWriteFile (
|
|
FileHandle,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&IoStatus,
|
|
LinkImage,
|
|
FIELD_OFFSET (PO_IMAGE_LINK, Name) + Length,
|
|
&ByteOffset,
|
|
NULL
|
|
);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Link file needs to make it to the disk
|
|
//
|
|
|
|
ZwFlushBuffersFile (FileHandle, &IoStatus);
|
|
|
|
//
|
|
// Success, keep the file around
|
|
//
|
|
|
|
HiberContext->LinkFile = TRUE;
|
|
HiberContext->LinkFileHandle = FileHandle;
|
|
|
|
Done:
|
|
if (Buffer) {
|
|
ExFreePool (Buffer);
|
|
}
|
|
|
|
if ((!NT_SUCCESS(Status)) &&
|
|
(FileHandle != NULL)) {
|
|
ZwClose (FileHandle);
|
|
}
|
|
return Status;
|
|
}
|
|
|
|
|
|
VOID
|
|
PopClearHiberFileSignature (
|
|
IN BOOLEAN GetStats
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function sets the signature in the hibernation image to be 0,
|
|
which indicates no context is contained in the image.
|
|
|
|
N.B. The power policy lock must be held
|
|
|
|
Arguments:
|
|
|
|
GetStats - if TRUE indicates performance statistics should be read
|
|
out of the hiberfile and written into the registry
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
IO_STATUS_BLOCK IoStatus;
|
|
PUCHAR Buffer;
|
|
LARGE_INTEGER ByteOffset;
|
|
KEVENT Event;
|
|
PMDL Mdl;
|
|
|
|
if (PopHiberFile.FileObject) {
|
|
Buffer = ExAllocatePoolWithTag (NonPagedPool, PAGE_SIZE, POP_HIBR_TAG);
|
|
if (Buffer == NULL) {
|
|
return;
|
|
}
|
|
|
|
KeInitializeEvent(&Event, NotificationEvent, FALSE);
|
|
RtlZeroMemory (Buffer, PAGE_SIZE);
|
|
ByteOffset.QuadPart = 0;
|
|
|
|
Mdl = MmCreateMdl (NULL, Buffer, PAGE_SIZE);
|
|
PoAssert( PO_ERROR, Mdl );
|
|
if( !Mdl ) {
|
|
// 'Event' hasn't been set so no cleanup needed.
|
|
return;
|
|
}
|
|
MmBuildMdlForNonPagedPool (Mdl);
|
|
|
|
if (GetStats) {
|
|
Status = IoPageRead(PopHiberFile.FileObject,
|
|
Mdl,
|
|
&ByteOffset,
|
|
&Event,
|
|
&IoStatus);
|
|
PoAssert( PO_ERROR, NT_SUCCESS(Status) );
|
|
|
|
if (NT_SUCCESS(Status)) {
|
|
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
|
|
if (NT_SUCCESS(IoStatus.Status)) {
|
|
UNICODE_STRING UnicodeString;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
HANDLE Handle;
|
|
ULONG Data;
|
|
PPO_MEMORY_IMAGE MemImage = (PPO_MEMORY_IMAGE)Buffer;
|
|
|
|
RtlInitUnicodeString(&UnicodeString,
|
|
L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Session Manager\\Power");
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&UnicodeString,
|
|
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
|
|
NULL,
|
|
NULL);
|
|
Status = ZwOpenKey(&Handle,
|
|
KEY_READ | KEY_WRITE,
|
|
&ObjectAttributes);
|
|
PoAssert( PO_ERROR, NT_SUCCESS(Status) );
|
|
|
|
if (NT_SUCCESS(Status)) {
|
|
RtlInitUnicodeString(&UnicodeString, L"HiberElapsedTime");
|
|
Data = MemImage->PerfInfo.ElapsedTime;
|
|
Status = ZwSetValueKey(Handle,
|
|
&UnicodeString,
|
|
0,
|
|
REG_DWORD,
|
|
&Data,
|
|
sizeof(Data));
|
|
PoAssert( PO_ERROR, NT_SUCCESS(Status) );
|
|
|
|
RtlInitUnicodeString(&UnicodeString, L"HiberIoTime");
|
|
Data = MemImage->PerfInfo.IoTime;
|
|
Status = ZwSetValueKey(Handle,
|
|
&UnicodeString,
|
|
0,
|
|
REG_DWORD,
|
|
&Data,
|
|
sizeof(Data));
|
|
PoAssert( PO_ERROR, NT_SUCCESS(Status) );
|
|
|
|
RtlInitUnicodeString(&UnicodeString, L"HiberCopyTime");
|
|
Data = MemImage->PerfInfo.CopyTime;
|
|
Status = ZwSetValueKey(Handle,
|
|
&UnicodeString,
|
|
0,
|
|
REG_DWORD,
|
|
&Data,
|
|
sizeof(Data));
|
|
PoAssert( PO_ERROR, NT_SUCCESS(Status) );
|
|
|
|
RtlInitUnicodeString(&UnicodeString, L"HiberCopyBytes");
|
|
Data = MemImage->PerfInfo.BytesCopied;
|
|
Status = ZwSetValueKey(Handle,
|
|
&UnicodeString,
|
|
0,
|
|
REG_DWORD,
|
|
&Data,
|
|
sizeof(Data));
|
|
PoAssert( PO_ERROR, NT_SUCCESS(Status) );
|
|
|
|
RtlInitUnicodeString(&UnicodeString, L"HiberPagesWritten");
|
|
Data = MemImage->PerfInfo.PagesWritten;
|
|
Status = ZwSetValueKey(Handle,
|
|
&UnicodeString,
|
|
0,
|
|
REG_DWORD,
|
|
&Data,
|
|
sizeof(Data));
|
|
PoAssert( PO_ERROR, NT_SUCCESS(Status) );
|
|
|
|
RtlInitUnicodeString(&UnicodeString, L"HiberPagesProcessed");
|
|
Data = MemImage->PerfInfo.PagesProcessed;
|
|
Status = ZwSetValueKey(Handle,
|
|
&UnicodeString,
|
|
0,
|
|
REG_DWORD,
|
|
&Data,
|
|
sizeof(Data));
|
|
PoAssert( PO_ERROR, NT_SUCCESS(Status) );
|
|
|
|
RtlInitUnicodeString(&UnicodeString, L"HiberDumpCount");
|
|
Data = MemImage->PerfInfo.DumpCount;
|
|
Status = ZwSetValueKey(Handle,
|
|
&UnicodeString,
|
|
0,
|
|
REG_DWORD,
|
|
&Data,
|
|
sizeof(Data));
|
|
PoAssert( PO_ERROR, NT_SUCCESS(Status) );
|
|
|
|
RtlInitUnicodeString(&UnicodeString, L"HiberFileRuns");
|
|
Data = MemImage->PerfInfo.FileRuns;
|
|
Status = ZwSetValueKey(Handle,
|
|
&UnicodeString,
|
|
0,
|
|
REG_DWORD,
|
|
&Data,
|
|
sizeof(Data));
|
|
PoAssert( PO_ERROR, NT_SUCCESS(Status) );
|
|
|
|
ZwClose(Handle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
RtlZeroMemory (Buffer, PAGE_SIZE);
|
|
KeClearEvent(&Event);
|
|
|
|
IoSynchronousPageWrite (
|
|
PopHiberFile.FileObject,
|
|
Mdl,
|
|
&ByteOffset,
|
|
&Event,
|
|
&IoStatus
|
|
);
|
|
|
|
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
|
|
ExFreePool (Mdl);
|
|
ExFreePool (Buffer);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
PopZeroHiberFile(
|
|
IN HANDLE FileHandle,
|
|
IN PFILE_OBJECT FileObject
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Zeroes out a hibernation file completely. This is to prevent
|
|
any leakage of data out of the hiberfile once it has been
|
|
deleted.
|
|
|
|
Arguments:
|
|
|
|
FileHandle - Supplies the file handle to be zeroed.
|
|
|
|
FileObject - Supplies the file object to be zeroed.
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
FILE_STANDARD_INFORMATION FileInfo;
|
|
LARGE_INTEGER Offset;
|
|
ULONGLONG Remaining;
|
|
ULONG Size;
|
|
PVOID Zeroes;
|
|
NTSTATUS Status;
|
|
PMDL Mdl;
|
|
KEVENT Event;
|
|
|
|
PAGED_CODE();
|
|
|
|
KeInitializeEvent(&Event, NotificationEvent, FALSE);
|
|
|
|
//
|
|
// Get the size of the file to be zeroed
|
|
//
|
|
Status = ZwQueryInformationFile(FileHandle,
|
|
&IoStatusBlock,
|
|
&FileInfo,
|
|
sizeof(FileInfo),
|
|
FileStandardInformation);
|
|
if (NT_SUCCESS(Status)) {
|
|
|
|
//
|
|
// Allocate a bunch of memory to use as zeroes
|
|
//
|
|
Zeroes = ExAllocatePoolWithTag(NonPagedPool,
|
|
POP_ZERO_CHUNK_SIZE,
|
|
'rZoP');
|
|
if (Zeroes) {
|
|
RtlZeroMemory(Zeroes, POP_ZERO_CHUNK_SIZE);
|
|
Mdl = MmCreateMdl(NULL, Zeroes, POP_ZERO_CHUNK_SIZE);
|
|
if (Mdl) {
|
|
|
|
MmBuildMdlForNonPagedPool (Mdl);
|
|
Offset.QuadPart = 0;
|
|
Remaining = FileInfo.AllocationSize.QuadPart;
|
|
Size = POP_ZERO_CHUNK_SIZE;
|
|
while (Remaining) {
|
|
if (Remaining < POP_ZERO_CHUNK_SIZE) {
|
|
Size = (ULONG)Remaining;
|
|
Mdl = MmCreateMdl(Mdl, Zeroes, Size);
|
|
MmBuildMdlForNonPagedPool(Mdl);
|
|
}
|
|
|
|
KeClearEvent(&Event);
|
|
Status = IoSynchronousPageWrite(FileObject,
|
|
Mdl,
|
|
&Offset,
|
|
&Event,
|
|
&IoStatusBlock);
|
|
if (NT_SUCCESS(Status)) {
|
|
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
|
|
Status = IoStatusBlock.Status;
|
|
}
|
|
if (!NT_SUCCESS(Status)) {
|
|
PoPrint (PO_HIBERNATE | PO_ERROR,
|
|
("PopZeroHiberFile: Write of size %lx at offset %I64x failed %08lx\n",
|
|
Size,
|
|
Offset.QuadPart,
|
|
Status));
|
|
}
|
|
|
|
Offset.QuadPart += Size;
|
|
Remaining -= Size;
|
|
}
|
|
|
|
ExFreePool (Mdl);
|
|
}
|
|
ExFreePool(Zeroes);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
PVOID
|
|
XPRESS_CALL
|
|
PopAllocateHiberContextCallback(
|
|
PVOID context,
|
|
int CompressionWorkspaceSize
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called by XpressEncodeCreate to allocate XpressEncodeStream.
|
|
|
|
Arguments:
|
|
|
|
context - HiberContext
|
|
CompressionWorkspaceSize - size of block to allocate
|
|
|
|
Return Value:
|
|
|
|
Pointer to allocated memory or NULL if no enough memory
|
|
|
|
--*/
|
|
{
|
|
// Allocate the memory required for the engine's workspace
|
|
return PopAllocateOwnMemory (context, CompressionWorkspaceSize, 'Xprs');
|
|
}
|
|
|
|
PVOID
|
|
PopAllocateOwnMemory(
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN ULONG Bytes,
|
|
IN ULONG Tag
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called to allocate memory that will not be hibernated
|
|
|
|
Arguments:
|
|
|
|
HiberContext - Pointer to POP_HIBER_CONTEXT structure
|
|
Bytes - size of memory block in bytes that
|
|
may be not aligned on page boundary
|
|
|
|
Return Value:
|
|
|
|
Address of memory block or NULL if failed (status will be set in this case)
|
|
|
|
--*/
|
|
{
|
|
PVOID Ptr;
|
|
ULONG Pages;
|
|
|
|
// Get # of full pages
|
|
Pages = (Bytes + (PAGE_SIZE-1)) >> PAGE_SHIFT;
|
|
|
|
// Allocate memory
|
|
Ptr = PopAllocatePages (HiberContext, Pages);
|
|
|
|
// Check for error
|
|
if (Ptr == NULL) {
|
|
HiberContext->Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
} else {
|
|
// Do not hibernate this memory
|
|
PoSetHiberRange (HiberContext,
|
|
PO_MEM_DISCARD,
|
|
Ptr,
|
|
Pages << PAGE_SHIFT,
|
|
Tag);
|
|
}
|
|
|
|
return(Ptr);
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
PopAllocateHiberContext (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called to allocate an initial hibernation context structure.
|
|
|
|
N.B. The power policy lock must be held
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
Status
|
|
|
|
--*/
|
|
{
|
|
PPOP_HIBER_CONTEXT HiberContext;
|
|
ULONG i;
|
|
PDUMP_INITIALIZATION_CONTEXT DumpInit = NULL;
|
|
PFN_NUMBER NoPages;
|
|
PFN_NUMBER Length;
|
|
PLIST_ENTRY Link;
|
|
PPOP_MEMORY_RANGE Range;
|
|
NTSTATUS Status;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Allocate space to hold the hiber context
|
|
//
|
|
|
|
Status = STATUS_SUCCESS;
|
|
HiberContext = PopAction.HiberContext;
|
|
if (!HiberContext) {
|
|
HiberContext = ExAllocatePoolWithTag (NonPagedPool,
|
|
sizeof (POP_HIBER_CONTEXT),
|
|
POP_HMAP_TAG);
|
|
if (!HiberContext) {
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
RtlZeroMemory (HiberContext, sizeof(*HiberContext));
|
|
PopAction.HiberContext = HiberContext;
|
|
|
|
InitializeListHead (&HiberContext->ClonedRanges);
|
|
KeInitializeSpinLock (&HiberContext->Lock);
|
|
}
|
|
|
|
//
|
|
// Determine what type of hiber context for this operation
|
|
// is needed
|
|
//
|
|
|
|
if (PopAction.SystemState == PowerSystemHibernate) {
|
|
|
|
//
|
|
// For a hibernate operation, the context is written
|
|
// to the hibernation file, pages need to be set aside
|
|
// for the loaders use, and any pages not needed to
|
|
// be written to the hibernation file should also be
|
|
// set aside
|
|
//
|
|
|
|
HiberContext->WriteToFile = TRUE;
|
|
HiberContext->ReserveLoaderMemory = TRUE;
|
|
HiberContext->ReserveFreeMemory = TRUE;
|
|
HiberContext->VerifyOnWake = FALSE;
|
|
|
|
} else if (PopSimulate & POP_CRC_MEMORY) {
|
|
|
|
//
|
|
// We want to checksum all of RAM during this sleep
|
|
// operation. We don't want to reserve any pages for
|
|
// anything else since the goal here is to likely look
|
|
// for somesort of corruption of failure.
|
|
//
|
|
|
|
HiberContext->WriteToFile = FALSE;
|
|
HiberContext->ReserveLoaderMemory = FALSE;
|
|
HiberContext->ReserveFreeMemory = FALSE;
|
|
HiberContext->VerifyOnWake = TRUE;
|
|
|
|
} else {
|
|
|
|
//
|
|
// A hiber context is not needed for this sleep
|
|
//
|
|
|
|
PopFreeHiberContext (TRUE);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// If there's an error in the current context, then we're done
|
|
//
|
|
|
|
if (!NT_SUCCESS(HiberContext->Status)) {
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// If writting to hibernation file, get a dump driver stack
|
|
//
|
|
|
|
if (HiberContext->WriteToFile) {
|
|
|
|
//
|
|
// Get a dump stack
|
|
//
|
|
|
|
if (!HiberContext->DumpStack) {
|
|
if (!PopHiberFile.FileObject) {
|
|
Status = STATUS_NO_SUCH_FILE;
|
|
goto Done;
|
|
}
|
|
|
|
Status = IoGetDumpStack ((PWCHAR)PopDumpStackPrefix,
|
|
&HiberContext->DumpStack,
|
|
DeviceUsageTypeHibernation,
|
|
(POP_IGNORE_UNSUPPORTED_DRIVERS & PopSimulate));
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
goto Done;
|
|
}
|
|
|
|
DumpInit = &HiberContext->DumpStack->Init;
|
|
|
|
//
|
|
// N.B. For further performance improvements it may be possible
|
|
// to set DumpInit->StallRoutine to a custom routine
|
|
// in order to do some processing while the dump driver
|
|
// is waiting pointlessly before performing some hardware
|
|
// related action (such as ISR calls).
|
|
//
|
|
|
|
|
|
}
|
|
|
|
//
|
|
// Create a link file for the loader to locate the hibernation file
|
|
//
|
|
|
|
Status = PopCreateHiberLinkFile (HiberContext);
|
|
if (!NT_SUCCESS(Status)) {
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Get any hibernation flags that must be visible to the osloader
|
|
//
|
|
HiberContext->HiberFlags = PopGetHiberFlags();
|
|
}
|
|
|
|
//
|
|
// Build a map of memory
|
|
//
|
|
|
|
if (HiberContext->MemoryMap.Buffer == NULL) {
|
|
PULONG BitmapBuffer;
|
|
ULONG PageCount;
|
|
|
|
//
|
|
// Initialize a bitmap describing all of physical memory.
|
|
// For now this bitmap covers from 0-MmHighestPhysicalPage.
|
|
// To support sparse memory maps more efficiently, we could break
|
|
// this up into a bitmap for each memory block run. Probably
|
|
// not a big deal, a single bitmap costs us 4K per 128MB on x86.
|
|
//
|
|
// Note that CLEAR bits in the bitmap represent what to write out.
|
|
// This is because of the way the bitmap interfaces are defined.
|
|
//
|
|
PageCount = (ULONG)((MmHighestPhysicalPage + 32) & ~31L);
|
|
|
|
PERFINFO_HIBER_ADJUST_PAGECOUNT_FOR_BBTBUFFER(&PageCount);
|
|
|
|
BitmapBuffer = ExAllocatePoolWithTag(NonPagedPool, PageCount/8, POP_HMAP_TAG);
|
|
if (BitmapBuffer == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto Done;
|
|
}
|
|
|
|
RtlInitializeBitMap(&HiberContext->MemoryMap, BitmapBuffer, PageCount);
|
|
RtlSetAllBits(&HiberContext->MemoryMap);
|
|
|
|
for (i=0; i < MmPhysicalMemoryBlock->NumberOfRuns; i++) {
|
|
PopPreserveRange(HiberContext,
|
|
MmPhysicalMemoryBlock->Run[i].BasePage,
|
|
MmPhysicalMemoryBlock->Run[i].PageCount,
|
|
POP_MEM_TAG);
|
|
}
|
|
|
|
PERFINFO_HIBER_HANDLE_BBTBUFFER_RANGE(HiberContext);
|
|
|
|
//
|
|
// Handle kernel debugger's section
|
|
//
|
|
|
|
if (!KdPitchDebugger) {
|
|
PoSetHiberRange (HiberContext,
|
|
PO_MEM_CLONE,
|
|
(PVOID) &KdTimerDifference,
|
|
0,
|
|
POP_DEBUGGER_TAG);
|
|
}
|
|
|
|
//
|
|
// Get Mm hibernation ranges and info
|
|
//
|
|
|
|
MmHibernateInformation (HiberContext,
|
|
&HiberContext->HiberVa,
|
|
&HiberContext->HiberPte);
|
|
|
|
//
|
|
// Get hal hibernation ranges
|
|
//
|
|
|
|
HalLocateHiberRanges (HiberContext);
|
|
|
|
//
|
|
// Get the dump drivers stack hibernation ranges
|
|
//
|
|
|
|
if (HiberContext->DumpStack) {
|
|
IoGetDumpHiberRanges (HiberContext, HiberContext->DumpStack);
|
|
}
|
|
|
|
//
|
|
// Allocate pages for cloning
|
|
//
|
|
|
|
NoPages = 0;
|
|
Link = HiberContext->ClonedRanges.Flink;
|
|
while (Link != &HiberContext->ClonedRanges) {
|
|
Range = CONTAINING_RECORD (Link, POP_MEMORY_RANGE, Link);
|
|
Link = Link->Flink;
|
|
NoPages += Range->EndPage - Range->StartPage;
|
|
}
|
|
|
|
//
|
|
// Add more for ranges which are expected to appear later
|
|
//
|
|
|
|
NoPages += 40 + ((KERNEL_LARGE_STACK_SIZE >> PAGE_SHIFT) + 2) * KeNumberProcessors;
|
|
Length = NoPages << PAGE_SHIFT;
|
|
|
|
//
|
|
// Allocate pages to hold clones
|
|
//
|
|
|
|
PopGatherMemoryForHibernate (HiberContext, NoPages, &HiberContext->Spares, TRUE);
|
|
|
|
//
|
|
// Slurp one page for doing non-aligned IOs
|
|
//
|
|
|
|
HiberContext->IoPage = PopAllocatePages (HiberContext, 1);
|
|
}
|
|
|
|
if (!NT_SUCCESS(HiberContext->Status)) {
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// If the context will be written to disk, then we will
|
|
// want to use compression.
|
|
//
|
|
|
|
if(HiberContext->WriteToFile) {
|
|
|
|
// Initialize XPRESS compression engine
|
|
|
|
HiberContext->CompressionWorkspace =
|
|
(PVOID) XpressEncodeCreate (XPRESS_MAX_SIZE,
|
|
(PVOID)HiberContext,
|
|
PopAllocateHiberContextCallback,
|
|
0);
|
|
|
|
if(!HiberContext->CompressionWorkspace) {
|
|
// Not enough memory -- failure
|
|
HiberContext->Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Allocate a buffer to use for compression
|
|
//
|
|
// N.B. This is actually the space alloted for a compressed page set fragment
|
|
// (a collection
|
|
// of compressed buffers that will be written out together in an optimal fashion).
|
|
//
|
|
// We add 2 pages to this fragment size in order to
|
|
// allow the compression of any given page
|
|
// (and thus the addition of its compressed buffers to the fragment) to overrun the
|
|
// compression buffer without causing any great havoc.
|
|
//
|
|
// See PopAddPagesToCompressedPageSet and PopEndCompressedPageSet for details.
|
|
//
|
|
|
|
HiberContext->CompressedWriteBuffer =
|
|
PopAllocateOwnMemory(HiberContext, (POP_COMPRESSED_PAGE_SET_SIZE + 2) << PAGE_SHIFT, 'Wbfr');
|
|
if(!HiberContext->CompressedWriteBuffer) {
|
|
goto Done;
|
|
}
|
|
|
|
// Allocate space for compressed data
|
|
HiberContext->CompressionBlock =
|
|
PopAllocateOwnMemory (HiberContext, sizeof (COMPRESSION_BLOCK), 'Cblk');
|
|
if(!HiberContext->CompressionBlock)
|
|
goto Done;
|
|
|
|
// Set first output pointer
|
|
((PCOMPRESSION_BLOCK) HiberContext->CompressionBlock)->Ptr =
|
|
((PCOMPRESSION_BLOCK) HiberContext->CompressionBlock)->Buffer;
|
|
|
|
// Allocate delayed IO buffer
|
|
HiberContext->DmaIO = NULL;
|
|
|
|
{
|
|
PUCHAR Ptr;
|
|
ULONG Size = (sizeof (DmaIoPtr[0]) + IO_DUMP_WRITE_DATA_SIZE + (PAGE_SIZE-1)) & ~(PAGE_SIZE-1);
|
|
|
|
Ptr = PopAllocateOwnMemory (HiberContext, Size + IOREGION_BUFF_SIZE , 'IObk');
|
|
if (Ptr != NULL) {
|
|
// Memory layout:
|
|
// 1. DumpLocalData (temp data for WritePendingRouting preserved between Start/Resume/Finish calls)
|
|
// 2. DmaIoPtr itself
|
|
// 3. Buffers themselves
|
|
|
|
RtlZeroMemory (Ptr, Size); // Clean IO and DumpLocalData
|
|
HiberContext->DmaIO = (DMA_IOREGIONS *) (Ptr + IO_DUMP_WRITE_DATA_SIZE);
|
|
|
|
DmaIoPtr->DumpLocalData = Ptr;
|
|
Ptr += Size;
|
|
|
|
DmaIoPtr->Free.Beg =
|
|
DmaIoPtr->Free.Ptr =
|
|
DmaIoPtr->Used.Ptr =
|
|
DmaIoPtr->Busy.Ptr =
|
|
DmaIoPtr->Used.Beg =
|
|
DmaIoPtr->Busy.Beg = Ptr;
|
|
|
|
DmaIoPtr->Free.End =
|
|
DmaIoPtr->Used.End =
|
|
DmaIoPtr->Busy.End = Ptr + IOREGION_BUFF_SIZE;
|
|
|
|
DmaIoPtr->Free.Size = IOREGION_BUFF_SIZE;
|
|
|
|
DmaIoPtr->DmaInitialized = FALSE;
|
|
DmaIoPtr->UseDma = TRUE;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// If the context is going to be written to disk, then
|
|
// get the map of the hibernation file
|
|
//
|
|
|
|
if (HiberContext->WriteToFile && !PopHiberFile.NonPagedMcb) {
|
|
|
|
//
|
|
// Since this writes to the physical sectors of the disk
|
|
// verify the check on the MCB array before doing it
|
|
//
|
|
|
|
if (PopHiberFile.McbCheck != PoSimpleCheck (0, PopHiberFile.PagedMcb, PopHiberFile.McbSize)) {
|
|
Status = STATUS_INTERNAL_ERROR;
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Move the MCB array to nonpaged pool
|
|
//
|
|
|
|
PopHiberFile.NonPagedMcb = ExAllocatePoolWithTag (NonPagedPool,
|
|
PopHiberFile.McbSize,
|
|
POP_HIBR_TAG);
|
|
|
|
if (!PopHiberFile.NonPagedMcb) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto Done;
|
|
}
|
|
|
|
memcpy (PopHiberFile.NonPagedMcb, PopHiberFile.PagedMcb, PopHiberFile.McbSize);
|
|
|
|
//
|
|
// Dump driver stack needs an 8 page memory block
|
|
//
|
|
|
|
DumpInit->MemoryBlock = PopAllocateOwnMemory (HiberContext,
|
|
IO_DUMP_MEMORY_BLOCK_PAGES << PAGE_SHIFT,
|
|
'memD');
|
|
if (!DumpInit->MemoryBlock) {
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Remove common buffer pages from save area
|
|
//
|
|
|
|
if (DumpInit->CommonBufferSize & (PAGE_SIZE-1)) {
|
|
PopInternalAddToDumpFile( DumpInit, sizeof(DUMP_INITIALIZATION_CONTEXT), NULL, NULL, NULL, NULL );
|
|
PopInternalAddToDumpFile( HiberContext, sizeof(POP_HIBER_CONTEXT), NULL, NULL, NULL, NULL );
|
|
KeBugCheckEx( INTERNAL_POWER_ERROR,
|
|
0x102,
|
|
POP_HIBER,
|
|
(ULONG_PTR)DumpInit,
|
|
(ULONG_PTR)HiberContext );
|
|
}
|
|
|
|
for (i=0; i < 2; i++) {
|
|
if (DumpInit->CommonBuffer[i]) {
|
|
PoSetHiberRange (HiberContext,
|
|
PO_MEM_DISCARD,
|
|
DumpInit->CommonBuffer[i],
|
|
DumpInit->CommonBufferSize,
|
|
POP_COMMON_BUFFER_TAG);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// From here on, no new pages are added to the map.
|
|
//
|
|
|
|
if (HiberContext->ReserveLoaderMemory && !HiberContext->LoaderMdl) {
|
|
|
|
//
|
|
// Have Mm remove enough pages from memory to allow the
|
|
// loader space when reloading the image, and remove them
|
|
// from the hiber context memory map.
|
|
//
|
|
|
|
PopGatherMemoryForHibernate (
|
|
HiberContext,
|
|
MmHiberPages,
|
|
&HiberContext->LoaderMdl,
|
|
TRUE
|
|
);
|
|
}
|
|
|
|
Done:
|
|
if (!NT_SUCCESS(Status) && NT_SUCCESS(HiberContext->Status)) {
|
|
HiberContext->Status = Status;
|
|
}
|
|
|
|
if (!NT_SUCCESS(HiberContext->Status)) {
|
|
PopFreeHiberContext (FALSE);
|
|
}
|
|
return HiberContext->Status;
|
|
}
|
|
|
|
VOID
|
|
PopFreeHiberContext (
|
|
IN BOOLEAN FreeAll
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Releases all resources allocated in the hiber context
|
|
|
|
N.B. The power policy lock must be held
|
|
|
|
Arguments:
|
|
|
|
ContextBlock - If TRUE, the hiber context structure is
|
|
freed as well
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PPOP_HIBER_CONTEXT HiberContext;
|
|
PPOP_MEMORY_RANGE Range;
|
|
|
|
HiberContext = PopAction.HiberContext;
|
|
if (!HiberContext) {
|
|
return ;
|
|
}
|
|
|
|
//
|
|
// Return pages gathered from mm
|
|
//
|
|
|
|
PopReturnMemoryForHibernate (HiberContext, FALSE, &HiberContext->LoaderMdl);
|
|
PopReturnMemoryForHibernate (HiberContext, TRUE, &HiberContext->Clones);
|
|
PopReturnMemoryForHibernate (HiberContext, FALSE, &HiberContext->Spares);
|
|
|
|
//
|
|
// Free the cloned range list elements
|
|
//
|
|
|
|
while (!IsListEmpty(&HiberContext->ClonedRanges)) {
|
|
Range = CONTAINING_RECORD (HiberContext->ClonedRanges.Flink, POP_MEMORY_RANGE, Link);
|
|
RemoveEntryList (&Range->Link);
|
|
ExFreePool (Range);
|
|
}
|
|
|
|
if (HiberContext->MemoryMap.Buffer) {
|
|
ExFreePool(HiberContext->MemoryMap.Buffer);
|
|
HiberContext->MemoryMap.Buffer = NULL;
|
|
}
|
|
|
|
//
|
|
// Free hiber file Mcb info
|
|
//
|
|
|
|
if (PopHiberFile.NonPagedMcb) {
|
|
ExFreePool (PopHiberFile.NonPagedMcb);
|
|
PopHiberFile.NonPagedMcb = NULL;
|
|
}
|
|
|
|
//
|
|
// If this is a total free, free the header
|
|
//
|
|
|
|
if (FreeAll) {
|
|
//
|
|
// Free resources used by dump driver
|
|
//
|
|
|
|
if (HiberContext->DumpStack) {
|
|
IoFreeDumpStack (HiberContext->DumpStack);
|
|
}
|
|
|
|
//
|
|
// If there's a link file, remove it
|
|
//
|
|
|
|
if (HiberContext->LinkFile) {
|
|
ZwClose(HiberContext->LinkFileHandle);
|
|
}
|
|
|
|
//
|
|
// Sanity check all gathered pages have been returned to Mm
|
|
//
|
|
|
|
if (HiberContext->PagesOut) {
|
|
PopInternalAddToDumpFile( HiberContext, sizeof(POP_HIBER_CONTEXT), NULL, NULL, NULL, NULL );
|
|
KeBugCheckEx( INTERNAL_POWER_ERROR,
|
|
0x103,
|
|
POP_HIBER,
|
|
(ULONG_PTR)HiberContext,
|
|
0 );
|
|
|
|
}
|
|
|
|
//
|
|
// If this is a wake, clear the signature in the image
|
|
//
|
|
|
|
if (HiberContext->Status == STATUS_WAKE_SYSTEM) {
|
|
if (PopSimulate & POP_ENABLE_HIBER_PERF) {
|
|
PopClearHiberFileSignature(TRUE);
|
|
} else {
|
|
PopClearHiberFileSignature(FALSE);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Free hiber context structure itself
|
|
//
|
|
|
|
PopAction.HiberContext = NULL;
|
|
ExFreePool (HiberContext);
|
|
}
|
|
}
|
|
|
|
ULONG
|
|
PopGatherMemoryForHibernate (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PFN_NUMBER NoPages,
|
|
IN PMDL *MdlList,
|
|
IN BOOLEAN Wait
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gathers NoPages from the system for hibernation work. The
|
|
gathered pages are put onto the supplied list.
|
|
|
|
Arguments:
|
|
|
|
HiberContext - The hiber context structure
|
|
|
|
NoPages - Number of pages to gather
|
|
|
|
MdlList - Head of Mdl list to enqueue the allocated pages
|
|
|
|
Wait - TRUE if caller can wait for the pages.
|
|
|
|
Return Value:
|
|
|
|
On failure FALSE and if Wait was set the HiberContext error is
|
|
set; otheriwse, TRUE
|
|
|
|
|
|
--*/
|
|
{
|
|
ULONG Result;
|
|
PPFN_NUMBER PhysPage;
|
|
ULONG i;
|
|
ULONG_PTR Length;
|
|
PMDL Mdl;
|
|
ULONG PageCount;
|
|
|
|
Result = 0;
|
|
Length = NoPages << PAGE_SHIFT;
|
|
Mdl = ExAllocatePoolWithTag (NonPagedPool,
|
|
MmSizeOfMdl (NULL, Length),
|
|
POP_HMAP_TAG);
|
|
|
|
if (Mdl) {
|
|
//
|
|
// Call Mm to gather some pages, and keep track of how many
|
|
// we have out
|
|
//
|
|
|
|
MmInitializeMdl(Mdl, NULL, Length);
|
|
|
|
//
|
|
// Set these here just in case MmGatherMemoryForHibernate
|
|
// wants to customize the flags.
|
|
//
|
|
Mdl->MdlFlags |= MDL_MAPPING_CAN_FAIL;
|
|
Mdl->MdlFlags |= MDL_PAGES_LOCKED;
|
|
Result = MmGatherMemoryForHibernate (Mdl, Wait);
|
|
|
|
}
|
|
|
|
if (Result) {
|
|
|
|
HiberContext->PagesOut += NoPages;
|
|
PhysPage = MmGetMdlPfnArray( Mdl );
|
|
for (i=0; i < NoPages; i += PageCount) {
|
|
|
|
//
|
|
// Combine contiguous pages into a single call
|
|
// to PopDiscardRange.
|
|
//
|
|
for (PageCount = 1; (i+PageCount) < NoPages; PageCount++) {
|
|
if (PhysPage[i+PageCount-1]+1 != PhysPage[i+PageCount]) {
|
|
break;
|
|
}
|
|
}
|
|
PopDiscardRange(HiberContext, PhysPage[i], PageCount, 'htaG');
|
|
}
|
|
|
|
Mdl->Next = *MdlList;
|
|
*MdlList = Mdl;
|
|
|
|
} else {
|
|
|
|
if (Mdl) {
|
|
ExFreePool (Mdl);
|
|
}
|
|
|
|
if (Wait && NT_SUCCESS(HiberContext->Status)) {
|
|
HiberContext->Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
|
|
VOID
|
|
PopReturnMemoryForHibernate (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN BOOLEAN Unmap,
|
|
IN OUT PMDL *MdlList
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Returns pages allocated from PopGatherMemoryForHibernate to
|
|
the system.
|
|
|
|
Arguments:
|
|
|
|
HiberContext - The hiber context structure
|
|
|
|
MdlList - Head of Mdl list of pages to free
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
PMDL Mdl;
|
|
|
|
while (*MdlList) {
|
|
Mdl = *MdlList;
|
|
*MdlList = Mdl->Next;
|
|
|
|
HiberContext->PagesOut -= Mdl->ByteCount >> PAGE_SHIFT;
|
|
if (Unmap) {
|
|
MmUnmapLockedPages (Mdl->MappedSystemVa, Mdl);
|
|
}
|
|
|
|
MmReturnMemoryForHibernate (Mdl);
|
|
ExFreePool (Mdl);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
PoSetHiberRange (
|
|
IN PVOID Map,
|
|
IN ULONG Flags,
|
|
IN PVOID StartVa,
|
|
IN ULONG_PTR Length,
|
|
IN ULONG Tag
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets the virtual range to the type supplied. If the length of
|
|
the range is zero, the entire section for the address specified
|
|
is set.
|
|
|
|
Ranges are expanded to their page boundries. (E.g., starting
|
|
addresses are rounded down, and ending addresses are rounded up)
|
|
|
|
|
|
Arguments:
|
|
|
|
HiberContext - The map to set the range in
|
|
|
|
Type - Type field for the range
|
|
|
|
Start - The starting address for the range in question
|
|
|
|
Length - The length of the range, or 0 to include an entire section
|
|
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
On failure, faulure status is updated in the HiberContext structure.
|
|
|
|
--*/
|
|
{
|
|
ULONG_PTR Start;
|
|
PFN_NUMBER StartPage;
|
|
PFN_NUMBER EndPage;
|
|
PFN_NUMBER FirstPage, PhysPage;
|
|
PFN_NUMBER RunLen;
|
|
PHYSICAL_ADDRESS PhysAddr;
|
|
NTSTATUS Status;
|
|
PPOP_HIBER_CONTEXT HiberContext;
|
|
ULONG SectionLength;
|
|
|
|
|
|
HiberContext = Map;
|
|
|
|
//
|
|
// If no length, include the entire section which the datum resides in
|
|
//
|
|
|
|
if (Length == 0) {
|
|
Status = MmGetSectionRange (StartVa, &StartVa, &SectionLength);
|
|
if (!NT_SUCCESS(Status)) {
|
|
PoPrint (PO_HIBERNATE, ("PoSetHiberRange: Section for %08x not found - skipped\n", StartVa));
|
|
PopInternalError (POP_HIBER);
|
|
}
|
|
Length = SectionLength;
|
|
}
|
|
|
|
//
|
|
// Turn PO_MEM_CL_OR_NCHK into just PO_MEM_CLONE
|
|
//
|
|
if (Flags & PO_MEM_CL_OR_NCHK) {
|
|
Flags &= ~PO_MEM_CL_OR_NCHK;
|
|
Flags |= PO_MEM_CLONE;
|
|
}
|
|
|
|
Start = (ULONG_PTR) StartVa;
|
|
if (Flags & PO_MEM_PAGE_ADDRESS) {
|
|
|
|
//
|
|
// Caller passed a physical page range
|
|
//
|
|
|
|
Flags &= ~PO_MEM_PAGE_ADDRESS;
|
|
PopSetRange (HiberContext,
|
|
Flags,
|
|
(PFN_NUMBER)Start,
|
|
(PFN_NUMBER)Length,
|
|
Tag);
|
|
|
|
} else {
|
|
|
|
//
|
|
// Round to page boundries
|
|
//
|
|
|
|
StartPage = (PFN_NUMBER)(Start >> PAGE_SHIFT);
|
|
EndPage = (PFN_NUMBER)((Start + Length + (PAGE_SIZE-1) & ~(PAGE_SIZE-1)) >> PAGE_SHIFT);
|
|
|
|
//
|
|
// Set all pages in the range
|
|
//
|
|
|
|
while (StartPage < EndPage) {
|
|
PhysAddr = MmGetPhysicalAddress((PVOID) (StartPage << PAGE_SHIFT));
|
|
FirstPage = (PFN_NUMBER) (PhysAddr.QuadPart >> PAGE_SHIFT);
|
|
|
|
//
|
|
// For how long the run is
|
|
//
|
|
|
|
for (RunLen=1; StartPage + RunLen < EndPage; RunLen += 1) {
|
|
PhysAddr = MmGetPhysicalAddress ((PVOID) ((StartPage + RunLen) << PAGE_SHIFT) );
|
|
PhysPage = (PFN_NUMBER) (PhysAddr.QuadPart >> PAGE_SHIFT);
|
|
if (FirstPage+RunLen != PhysPage) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set this run
|
|
//
|
|
|
|
PopSetRange (HiberContext, Flags, FirstPage, RunLen, Tag);
|
|
StartPage += RunLen;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
PopCloneStack (
|
|
IN PPOP_HIBER_CONTEXT HiberContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets the current stack in the memory map to be a cloned range
|
|
|
|
Arguments:
|
|
|
|
HiberContext - The map to set the range in
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
On failure, faulure status is updated in the HiberContext structure.
|
|
|
|
--*/
|
|
{
|
|
PKTHREAD Thread;
|
|
KIRQL OldIrql;
|
|
ULONG_PTR LowLimit;
|
|
ULONG_PTR HighLimit;
|
|
|
|
KeAcquireSpinLock (&HiberContext->Lock, &OldIrql);
|
|
|
|
//
|
|
// Add local stack to clone or disable check list
|
|
//
|
|
RtlpGetStackLimits(&LowLimit, &HighLimit);
|
|
|
|
Thread = KeGetCurrentThread();
|
|
PoSetHiberRange (HiberContext,
|
|
PO_MEM_CLONE,
|
|
(PVOID)LowLimit,
|
|
HighLimit - LowLimit,
|
|
POP_STACK_TAG);
|
|
|
|
//
|
|
// Put local processors PCR & PRCB in clone list
|
|
//
|
|
|
|
PoSetHiberRange (HiberContext,
|
|
PO_MEM_CLONE,
|
|
(PVOID) KeGetPcr(),
|
|
sizeof (KPCR),
|
|
POP_PCR_TAG );
|
|
|
|
PoSetHiberRange (HiberContext,
|
|
PO_MEM_CLONE,
|
|
KeGetCurrentPrcb(),
|
|
sizeof (KPRCB),
|
|
POP_PCRB_TAG );
|
|
|
|
KeReleaseSpinLock (&HiberContext->Lock, OldIrql);
|
|
}
|
|
|
|
|
|
VOID
|
|
PopPreserveRange(
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PFN_NUMBER StartPage,
|
|
IN PFN_NUMBER PageCount,
|
|
IN ULONG Tag
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Adds a physical memory range to the list of ranges to be preserved.
|
|
|
|
Arguments:
|
|
|
|
HiberContext - Supplies the hibernation context
|
|
|
|
StartPage - Supplies the beginning of the range
|
|
|
|
PageCount - Supplies the length of the range
|
|
|
|
Tag - supplies a tag to be used.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
//
|
|
// If this range is outside the area covered by our bitmap, then we
|
|
// will just clone it instead.
|
|
//
|
|
if (StartPage + PageCount > HiberContext->MemoryMap.SizeOfBitMap) {
|
|
PoPrint (PO_HIBERNATE,
|
|
("PopPreserveRange: range %08lx, length %lx is outside bitmap of size %lx\n",
|
|
StartPage,
|
|
PageCount,
|
|
HiberContext->MemoryMap.SizeOfBitMap));
|
|
PopCloneRange(HiberContext, StartPage, PageCount, Tag);
|
|
return;
|
|
}
|
|
|
|
PoPrint(PO_HIBERNATE,
|
|
("PopPreserveRange - setting page %08lx - %08lx, Tag %.4s\n",
|
|
StartPage,
|
|
StartPage + PageCount,
|
|
&Tag));
|
|
RtlClearBits(&HiberContext->MemoryMap, (ULONG)StartPage, (ULONG)PageCount);
|
|
}
|
|
|
|
|
|
VOID
|
|
PopDiscardRange(
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PFN_NUMBER StartPage,
|
|
IN PFN_NUMBER PageCount,
|
|
IN ULONG Tag
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Removes a physical memory range from the list of ranges to be preserved.
|
|
|
|
Arguments:
|
|
|
|
HiberContext - Supplies the hibernation context
|
|
|
|
StartPage - Supplies the beginning of the range
|
|
|
|
PageCount - Supplies the length of the range
|
|
|
|
Tag - supplies a tag to be used.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PFN_NUMBER sp;
|
|
PFN_NUMBER count;
|
|
|
|
#if !DBG
|
|
UNREFERENCED_PARAMETER (Tag);
|
|
#endif
|
|
|
|
//
|
|
// If this range is outside the area covered by our bitmap, then
|
|
// it's not going to get written anyway.
|
|
//
|
|
if (StartPage <= HiberContext->MemoryMap.SizeOfBitMap) {
|
|
sp = StartPage;
|
|
count = PageCount;
|
|
if (sp + count > HiberContext->MemoryMap.SizeOfBitMap) {
|
|
//
|
|
// trim PageCount
|
|
//
|
|
count = HiberContext->MemoryMap.SizeOfBitMap - sp;
|
|
}
|
|
|
|
PoPrint(PO_HIBERNATE,
|
|
("PopDiscardRange - removing page %08lx - %08lx, Tag %.4s\n",
|
|
StartPage,
|
|
StartPage + PageCount,
|
|
&Tag));
|
|
RtlSetBits(&HiberContext->MemoryMap, (ULONG)sp, (ULONG)count);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
PopCloneRange(
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PFN_NUMBER StartPage,
|
|
IN PFN_NUMBER PageCount,
|
|
IN ULONG Tag
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Adds a physical memory range from the list of ranges to be cloned.
|
|
This means removing it from the list to be written and adding
|
|
an entry in the clone list.
|
|
|
|
Arguments:
|
|
|
|
HiberContext - Supplies the hibernation context
|
|
|
|
StartPage - Supplies the beginning of the range
|
|
|
|
PageCount - Supplies the length of the range
|
|
|
|
Tag - supplies a tag to be used.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY Link;
|
|
PPOP_MEMORY_RANGE Range;
|
|
PFN_NUMBER EndPage;
|
|
|
|
PoPrint(PO_HIBERNATE,
|
|
("PopCloneRange - cloning page %08lx - %08lx, Tag %.4s\n",
|
|
StartPage,
|
|
StartPage + PageCount,
|
|
&Tag));
|
|
PopDiscardRange(HiberContext, StartPage, PageCount, Tag);
|
|
|
|
EndPage = StartPage + PageCount;
|
|
|
|
//
|
|
// Go through the range list. If we find an adjacent range, coalesce.
|
|
// Otherwise, insert a new range entry in sorted order.
|
|
//
|
|
Link = HiberContext->ClonedRanges.Flink;
|
|
while (Link != &HiberContext->ClonedRanges) {
|
|
Range = CONTAINING_RECORD (Link, POP_MEMORY_RANGE, Link);
|
|
|
|
//
|
|
// Check for an overlapping or adjacent range.
|
|
//
|
|
if (((StartPage >= Range->StartPage) && (StartPage <= Range->EndPage)) ||
|
|
((EndPage >= Range->StartPage) && (EndPage <= Range->EndPage)) ||
|
|
((StartPage <= Range->StartPage) && (EndPage >= Range->EndPage))) {
|
|
|
|
PoPrint(PO_HIBERNATE,
|
|
("PopCloneRange - coalescing range %lx - %lx (%.4s) with range %lx - %lx\n",
|
|
StartPage,
|
|
EndPage,
|
|
&Tag,
|
|
Range->StartPage,
|
|
Range->EndPage));
|
|
|
|
//
|
|
// Coalesce this range.
|
|
//
|
|
if (StartPage < Range->StartPage) {
|
|
Range->StartPage = StartPage;
|
|
}
|
|
if (EndPage > Range->EndPage) {
|
|
Range->EndPage = EndPage;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (Range->StartPage >= StartPage) {
|
|
//
|
|
// We have found a range greater than the current one. Insert the new range
|
|
// in this position.
|
|
//
|
|
break;
|
|
}
|
|
|
|
Link = Link->Flink;
|
|
}
|
|
|
|
//
|
|
// An adjacent range was not found. Allocate a new entry and insert
|
|
// it in front of the Link entry.
|
|
//
|
|
Range = ExAllocatePoolWithTag (NonPagedPool,
|
|
sizeof (POP_MEMORY_RANGE),
|
|
POP_HMAP_TAG);
|
|
if (!Range) {
|
|
if (NT_SUCCESS(HiberContext->Status)) {
|
|
HiberContext->Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
return ;
|
|
}
|
|
Range->Tag = Tag;
|
|
Range->StartPage = StartPage;
|
|
Range->EndPage = EndPage;
|
|
InsertTailList(Link, &Range->Link);
|
|
|
|
++HiberContext->ClonedRangeCount;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
ULONG
|
|
PopGetRangeCount(
|
|
IN PPOP_HIBER_CONTEXT HiberContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Counts the number of ranges to be written out. This includes
|
|
the number of cloned ranges on the cloned range list and the
|
|
number of runs in the memory map.
|
|
|
|
Arguments:
|
|
|
|
HiberContext - Supplies the hibernation context.
|
|
|
|
Return Value:
|
|
|
|
Number of ranges to be written out.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG RunCount=0;
|
|
ULONG NextPage=0;
|
|
ULONG Length;
|
|
|
|
while (NextPage < HiberContext->MemoryMap.SizeOfBitMap) {
|
|
Length = RtlFindNextForwardRunClear(&HiberContext->MemoryMap,
|
|
NextPage,
|
|
&NextPage);
|
|
NextPage += Length;
|
|
++RunCount;
|
|
}
|
|
|
|
return(RunCount + HiberContext->ClonedRangeCount);
|
|
}
|
|
|
|
VOID
|
|
PopSetRange (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN ULONG Flags,
|
|
IN PFN_NUMBER StartPage,
|
|
IN PFN_NUMBER PageCount,
|
|
IN ULONG Tag
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets the specified physical range in the memory map
|
|
|
|
Arguments:
|
|
|
|
HiberContext - The map to set the range in
|
|
|
|
Type - Type to set the range too
|
|
|
|
StartPage - The first page of the range
|
|
|
|
PageCount - The length of the range in pages
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
On failure, faulure status is updated in the HiberContext structure.
|
|
|
|
--*/
|
|
{
|
|
PoPrint (PO_HIBERNATE,
|
|
("PopSetRange: Ty %04x Sp %08x Len %08x %.4s\n",
|
|
Flags,
|
|
StartPage,
|
|
PageCount,
|
|
&Tag));
|
|
|
|
if (HiberContext->MapFrozen) {
|
|
PopInternalAddToDumpFile( HiberContext, sizeof(POP_HIBER_CONTEXT), NULL, NULL, NULL, NULL );
|
|
KeBugCheckEx( INTERNAL_POWER_ERROR,
|
|
0x104,
|
|
POP_HIBER,
|
|
(ULONG_PTR)HiberContext,
|
|
0 );
|
|
}
|
|
//
|
|
// Make sure flags which should have been cleared by now aren't still set.
|
|
//
|
|
ASSERT(!(Flags & (PO_MEM_PAGE_ADDRESS | PO_MEM_CL_OR_NCHK)));
|
|
|
|
if (Flags & PO_MEM_DISCARD) {
|
|
PopDiscardRange(HiberContext, StartPage, PageCount, Tag);
|
|
} else if (Flags & PO_MEM_CLONE) {
|
|
PopCloneRange(HiberContext, StartPage, PageCount, Tag);
|
|
} else if (Flags & PO_MEM_PRESERVE) {
|
|
PopPreserveRange(HiberContext, StartPage, PageCount, Tag);
|
|
} else {
|
|
ASSERT(FALSE);
|
|
PopInternalAddToDumpFile( HiberContext, sizeof(POP_HIBER_CONTEXT), NULL, NULL, NULL, NULL );
|
|
KeBugCheckEx( INTERNAL_POWER_ERROR,
|
|
0x105,
|
|
POP_HIBER,
|
|
(ULONG_PTR)HiberContext,
|
|
0 );
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
PopResetRangeEnum(
|
|
IN PPOP_HIBER_CONTEXT HiberContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Resets the range enumerator to start at the first range.
|
|
|
|
Arguments:
|
|
|
|
HiberContext - Supplies the hibernation context
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
HiberContext->NextCloneRange = HiberContext->ClonedRanges.Flink;
|
|
HiberContext->NextPreserve = 0;
|
|
}
|
|
|
|
|
|
VOID
|
|
PopGetNextRange(
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
OUT PPFN_NUMBER StartPage,
|
|
OUT PPFN_NUMBER EndPage,
|
|
OUT PVOID *CloneVa
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enumerates the next range to be written to the hibernation file
|
|
|
|
Arguments:
|
|
|
|
HiberContext - Supplies the hibernation context.
|
|
|
|
StartPage - Returns the starting physical page to be written.
|
|
|
|
EndPage - Returns the ending physical page (non-inclusive) to be written
|
|
|
|
CloneVa - If the range is to be cloned, returns the cloned virtual address
|
|
If the range is not cloned, returns NULL
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
|
|
{
|
|
PPOP_MEMORY_RANGE Range;
|
|
ULONG Length;
|
|
ULONG StartIndex;
|
|
|
|
if (HiberContext->NextCloneRange != &HiberContext->ClonedRanges) {
|
|
//
|
|
// Return the next cloned range
|
|
//
|
|
Range = CONTAINING_RECORD(HiberContext->NextCloneRange, POP_MEMORY_RANGE, Link);
|
|
HiberContext->NextCloneRange = HiberContext->NextCloneRange->Flink;
|
|
|
|
*StartPage = Range->StartPage;
|
|
*EndPage = Range->EndPage;
|
|
*CloneVa = Range->CloneVa;
|
|
|
|
ASSERT(Range->CloneVa != NULL);
|
|
|
|
} else {
|
|
|
|
//
|
|
// We have enumerated all the clone ranges, return the next preserved range
|
|
//
|
|
Length = RtlFindNextForwardRunClear(&HiberContext->MemoryMap,
|
|
(ULONG)HiberContext->NextPreserve,
|
|
&StartIndex);
|
|
*StartPage = StartIndex;
|
|
*EndPage = *StartPage + Length;
|
|
HiberContext->NextPreserve = *EndPage;
|
|
*CloneVa = NULL;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
PVOID
|
|
PopAllocatePages (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PFN_NUMBER NoPages
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Allocates memory pages from system with virtual mappings.
|
|
Pages are kept on a list and are automatically freed by
|
|
PopFreeHiberContext.
|
|
|
|
Arguments:
|
|
|
|
NoPages - No of pages to allocate
|
|
|
|
Flags - Flags for the returned pages in the physical memory map
|
|
|
|
|
|
Return Value:
|
|
|
|
Virtual address of the requested pages
|
|
|
|
--*/
|
|
{
|
|
PUCHAR Buffer=NULL;
|
|
PMDL Mdl;
|
|
ULONG SpareCount;
|
|
|
|
PoPrint( PO_NOTIFY, ("PopAllocatePages: Enter, requesting %d pages.\r\n", NoPages));
|
|
|
|
//
|
|
// In the future, we should add code here that checks to see if the requested
|
|
// NoPages is bigger than POP_FREE_ALLOCATE_SIZE. We've created a whole
|
|
// bunch of MDLs that are all of size POP_FREE_ALLOCATE_SIZE. If the user
|
|
// is requesting something bigger, we'll never find an MDL in the spare
|
|
// list that's suitable, thus fail the hibernation.
|
|
//
|
|
// In this case, we could go grovel our Spares, looking for MDLs that
|
|
// are sitting right next to each other (i.e. describing consecutive
|
|
// memory), then combine the MDLs into one bigger MDL. If that's
|
|
// big enough, us it, If not, start scanning again.
|
|
//
|
|
|
|
for (; ;) {
|
|
//
|
|
// If page is available in mapped clone page list, get it
|
|
//
|
|
|
|
if (NoPages <= HiberContext->NoClones) {
|
|
|
|
Buffer = HiberContext->NextClone;
|
|
HiberContext->NoClones -= NoPages;
|
|
HiberContext->NextClone += NoPages << PAGE_SHIFT;
|
|
PoPrint( PO_NOTIFY, (" Take this allocation out of the HiberContext clones list (0x%x pages left there).\r\n", HiberContext->NoClones));
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Need more virtual address space
|
|
//
|
|
|
|
if (HiberContext->Spares) {
|
|
|
|
|
|
//
|
|
// Turn spares into virtually mapped pages. Try to limit the
|
|
// number of pages being mapped so we don't run out of PTEs
|
|
// on large memory machines.
|
|
//
|
|
// If they want more than PO_MAX_MAPPED_CLONES, tough.
|
|
// If they want less than PO_MAX_MAPPED_CLONES, only give
|
|
// them what they're asking for.
|
|
//
|
|
if ((NoPages << PAGE_SHIFT) >= PO_MAX_MAPPED_CLONES) {
|
|
SpareCount = PO_MAX_MAPPED_CLONES;
|
|
} else {
|
|
SpareCount = (ULONG) (NoPages << PAGE_SHIFT);
|
|
}
|
|
|
|
Mdl = HiberContext->Spares;
|
|
|
|
PoPrint( PO_NOTIFY, (" See if we can use one of the Spare MDLs.\r\n"));
|
|
PoPrint( PO_NOTIFY, (" I think we need 0x%x byes\r\n", SpareCount));
|
|
PoPrint( PO_NOTIFY, (" Spare MDL byteCount: 0x%x\r\n", Mdl->ByteCount));
|
|
|
|
if (Mdl->ByteCount > SpareCount) {
|
|
|
|
//
|
|
// Split out a smaller MDL from the spare since it is larger
|
|
// than we really need.
|
|
//
|
|
|
|
Mdl = PopSplitMdl(Mdl, SpareCount >> PAGE_SHIFT);
|
|
if (Mdl == NULL) {
|
|
PoPrint( PO_NOTIFY, (" We split the Spare MDL and failed!!!\r\n"));
|
|
break;
|
|
}
|
|
|
|
PoPrint( PO_NOTIFY, (" We split the Spare MDL.\r\n"));
|
|
|
|
} else {
|
|
|
|
//
|
|
// Map the entire spare MDL
|
|
//
|
|
HiberContext->Spares = Mdl->Next;
|
|
PoPrint( PO_NOTIFY, (" Use the entire Spare MDL.\r\n"));
|
|
|
|
}
|
|
Mdl->MdlFlags |= MDL_MAPPING_CAN_FAIL;
|
|
Mdl->MdlFlags |= MDL_PAGES_LOCKED;
|
|
|
|
PoPrint( PO_NOTIFY, (" Mdl->ByteCount: 0x%x\r\n", Mdl->ByteCount));
|
|
|
|
HiberContext->NextClone = MmMapLockedPages (Mdl, KernelMode);
|
|
if (HiberContext->NextClone == NULL) {
|
|
|
|
|
|
PoPrint( PO_NOTIFY, (" MmMapLockedPages FAILED!!!\r\n"));
|
|
//
|
|
// Put the MDL back on the spare list so it gets cleaned up
|
|
// correctly by PopFreeHiberContext.
|
|
//
|
|
Mdl->Next = HiberContext->Spares;
|
|
HiberContext->Spares = Mdl;
|
|
break;
|
|
}
|
|
HiberContext->NoClones = Mdl->ByteCount >> PAGE_SHIFT;
|
|
Mdl->Next = HiberContext->Clones;
|
|
HiberContext->Clones = Mdl;
|
|
|
|
} else {
|
|
|
|
ULONG result;
|
|
|
|
//
|
|
// No spares, allocate more
|
|
//
|
|
PoPrint(PO_NOTIFY, ("PopAllocatePages: No Spare MDLs left. Go allocate more.") );
|
|
result = PopGatherMemoryForHibernate (HiberContext,
|
|
NoPages*2,
|
|
&HiberContext->Spares,
|
|
TRUE);
|
|
|
|
if (!result) {
|
|
PoAssert(PO_ERROR, FALSE && ("PopAllocatePages: PopGatherMemoryForHibernate failed!! We're about to fail hibernation") );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If there's a failure, mark it now
|
|
//
|
|
|
|
if (!Buffer && NT_SUCCESS(HiberContext->Status)) {
|
|
HiberContext->Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
PoPrint( PO_NOTIFY, ("PopAllocatePages: Exit (0x%x)\r\n", PtrToUlong(Buffer)));
|
|
|
|
return Buffer;
|
|
}
|
|
|
|
|
|
ULONG
|
|
PopSimpleRangeCheck (
|
|
PPOP_MEMORY_RANGE Range
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Computes a checksum for the supplied range
|
|
|
|
Arguments:
|
|
|
|
Range - The range to compute the checksum for
|
|
|
|
Return Value:
|
|
|
|
The checksum value
|
|
|
|
--*/
|
|
{
|
|
PFN_NUMBER sp, ep;
|
|
ULONG Check;
|
|
DUMP_MDL DumpMdl;
|
|
PMDL Mdl;
|
|
|
|
sp = Range->StartPage;
|
|
ep = Range->EndPage;
|
|
Mdl = (PMDL) DumpMdl;
|
|
|
|
if (Range->CloneVa) {
|
|
return PoSimpleCheck (0, Range->CloneVa, (ep-sp) << PAGE_SHIFT);
|
|
}
|
|
|
|
Check = 0;
|
|
while (sp < ep) {
|
|
PopCreateDumpMdl (Mdl, sp, ep);
|
|
Check = PoSimpleCheck (Check, Mdl->MappedSystemVa, Mdl->ByteCount);
|
|
sp += Mdl->ByteCount >> PAGE_SHIFT;
|
|
}
|
|
|
|
return Check;
|
|
}
|
|
|
|
VOID
|
|
PopCreateDumpMdl (
|
|
IN OUT PMDL Mdl,
|
|
IN PFN_NUMBER StartPage,
|
|
IN PFN_NUMBER EndPage
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Builds a dump MDl for the supplied starting address for
|
|
as many pages as can be mapped, or until EndPage is hit.
|
|
|
|
Arguments:
|
|
|
|
StartPage - The first page to map
|
|
|
|
EndPage - The ending page
|
|
|
|
Return Value:
|
|
|
|
Mdl
|
|
|
|
--*/
|
|
{
|
|
PFN_NUMBER Pages;
|
|
PPFN_NUMBER PhysPage;
|
|
|
|
// mapping better make sense
|
|
if (StartPage >= EndPage) {
|
|
PopInternalError (POP_HIBER);
|
|
}
|
|
|
|
Pages = EndPage - StartPage;
|
|
if (Pages > POP_MAX_MDL_SIZE) {
|
|
Pages = POP_MAX_MDL_SIZE;
|
|
}
|
|
|
|
MmInitializeMdl(Mdl, NULL, (Pages << PAGE_SHIFT));
|
|
|
|
PhysPage = MmGetMdlPfnArray( Mdl );
|
|
while (Pages) {
|
|
*PhysPage++ = StartPage++;
|
|
Pages -= 1;
|
|
}
|
|
|
|
MmMapMemoryDumpMdl (Mdl);
|
|
Mdl->MdlFlags |= MDL_MAPPED_TO_SYSTEM_VA;
|
|
|
|
// byte count must be a multiple of page size
|
|
if (Mdl->ByteCount & (PAGE_SIZE-1)) {
|
|
PopInternalAddToDumpFile( Mdl, sizeof(MDL), NULL, NULL, NULL, NULL );
|
|
KeBugCheckEx( INTERNAL_POWER_ERROR,
|
|
0x106,
|
|
POP_HIBER,
|
|
(ULONG_PTR)Mdl,
|
|
0 );
|
|
}
|
|
}
|
|
|
|
VOID
|
|
PopHiberComplete (
|
|
IN NTSTATUS Status,
|
|
IN PPOP_HIBER_CONTEXT HiberContext
|
|
)
|
|
{
|
|
//
|
|
// If the return from the hal is STATUS_DEVICE_DOES_NOT_EXIST, then
|
|
// the hal doesn't know how to power off the machine.
|
|
//
|
|
|
|
if (Status == STATUS_DEVICE_DOES_NOT_EXIST) {
|
|
|
|
if (InbvIsBootDriverInstalled()) {
|
|
|
|
// Display system shut down screen
|
|
|
|
PUCHAR Bitmap1, Bitmap2;
|
|
|
|
Bitmap1 = InbvGetResourceAddress(3); // shutdown bitmap
|
|
Bitmap2 = InbvGetResourceAddress(5); // logo bitmap
|
|
|
|
InbvSolidColorFill(190,279,468,294,0);
|
|
if (Bitmap1 && Bitmap2) {
|
|
InbvBitBlt(Bitmap1, 215, 282);
|
|
InbvBitBlt(Bitmap2, 217, 111);
|
|
}
|
|
|
|
} else {
|
|
InbvDisplayString ((PUCHAR)"State saved, power off the system\n");
|
|
}
|
|
|
|
// If reseting, set the flag and return
|
|
if (PopSimulate & POP_RESET_ON_HIBER) {
|
|
HiberContext->Reset = TRUE;
|
|
return ;
|
|
}
|
|
|
|
// done... wait for power off
|
|
for (; ;) ;
|
|
}
|
|
|
|
//
|
|
// If the image is complete or the sleep completed without error,
|
|
// then the checksums are valid
|
|
//
|
|
|
|
if ((NT_SUCCESS(Status) ||
|
|
HiberContext->MemoryImage->Signature == PO_IMAGE_SIGNATURE) &&
|
|
HiberContext->VerifyOnWake) {
|
|
|
|
}
|
|
|
|
//
|
|
// Release the dump PTEs
|
|
//
|
|
|
|
MmReleaseDumpAddresses (POP_MAX_MDL_SIZE);
|
|
|
|
//
|
|
// Hiber no longer in process
|
|
//
|
|
|
|
PoHiberInProgress = FALSE;
|
|
HiberContext->Status = Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PopBuildMemoryImageHeader (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN SYSTEM_POWER_STATE SystemState
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Converts the memory map range list to a memory image structure
|
|
with a range list array. This is done to build the initial image
|
|
of the header to be written into the hibernation file, and to get
|
|
the header into one chunk of pool which is not in any other
|
|
listed range list
|
|
|
|
Arguments:
|
|
|
|
HiberContext -
|
|
|
|
SystemState -
|
|
|
|
Return Value:
|
|
|
|
Status
|
|
|
|
--*/
|
|
{
|
|
PPOP_MEMORY_RANGE Range;
|
|
PPO_MEMORY_IMAGE MemImage;
|
|
PLIST_ENTRY Link;
|
|
PFN_NUMBER Length;
|
|
PFN_NUMBER StartPage;
|
|
ULONG StartIndex;
|
|
ULONG Index;
|
|
PPO_MEMORY_RANGE_ARRAY Table;
|
|
ULONG TablePages;
|
|
ULONG NeededPages;
|
|
ULONG NoPages, i;
|
|
|
|
UNREFERENCED_PARAMETER (SystemState);
|
|
|
|
//
|
|
// Allocate memory image structure
|
|
//
|
|
|
|
MemImage = PopAllocatePages (HiberContext, 1);
|
|
if (!MemImage) {
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
PoSetHiberRange (HiberContext,
|
|
PO_MEM_CLONE,
|
|
MemImage,
|
|
sizeof(*MemImage),
|
|
POP_MEMIMAGE_TAG);
|
|
|
|
RtlZeroMemory(MemImage, PAGE_SIZE);
|
|
HiberContext->MemoryImage = MemImage;
|
|
MemImage->PageSize = PAGE_SIZE;
|
|
MemImage->LengthSelf = sizeof(*MemImage);
|
|
MemImage->PageSelf = (PFN_NUMBER) MmGetPhysicalAddress(MemImage).QuadPart >> PAGE_SHIFT;
|
|
KeQuerySystemTime (&MemImage->SystemTime);
|
|
MemImage->InterruptTime = KeQueryInterruptTime();
|
|
MemImage->HiberVa = HiberContext->HiberVa;
|
|
MemImage->HiberPte = HiberContext->HiberPte;
|
|
MemImage->NoHiberPtes = POP_MAX_MDL_SIZE;
|
|
MemImage->FeatureFlags = KeFeatureBits;
|
|
MemImage->ImageType = KeProcessorArchitecture;
|
|
MemImage->HiberFlags = HiberContext->HiberFlags;
|
|
if (HiberContext->LoaderMdl) {
|
|
MemImage->NoFreePages = HiberContext->LoaderMdl->ByteCount >> PAGE_SHIFT;
|
|
}
|
|
|
|
//
|
|
// Allocate storage for clones
|
|
//
|
|
|
|
Link = HiberContext->ClonedRanges.Flink;
|
|
while (Link != &HiberContext->ClonedRanges) {
|
|
Range = CONTAINING_RECORD (Link, POP_MEMORY_RANGE, Link);
|
|
Link = Link->Flink;
|
|
|
|
//
|
|
// Allocate space to make a copy of this clone
|
|
//
|
|
|
|
Length = Range->EndPage - Range->StartPage;
|
|
Range->CloneVa = PopAllocatePages(HiberContext, Length);
|
|
if (!Range->CloneVa) {
|
|
PoPrint (PO_HIBERNATE, ("PopBuildImage: Could not allocate clone for %08x - %08x\n",
|
|
Range->StartPage,
|
|
Range->EndPage));
|
|
return(STATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
}
|
|
|
|
//
|
|
// We need to build the restoration map of the pages which need to
|
|
// be saved. These table pages can't be checksum in the normal
|
|
// way as they hold the checksums for the rest of memory, so they
|
|
// are allocated as ranges with no checksum and then checksums
|
|
// are explicitly added in each page. However, allocating these
|
|
// pages may change the memory map, so we need to loop until we've
|
|
// got enough storage for the restoration tables allocated in the
|
|
// memory map to contain the tables, etc..
|
|
//
|
|
|
|
TablePages = 0;
|
|
|
|
for (; ;) {
|
|
//
|
|
// Compute table pages needed, if we have enough allocated
|
|
// then freeze the memory map and build them
|
|
//
|
|
|
|
NoPages = (PopGetRangeCount(HiberContext) + PO_ENTRIES_PER_PAGE - 1) / PO_ENTRIES_PER_PAGE;
|
|
if (NoPages <= TablePages) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Allocate more table pages
|
|
//
|
|
NeededPages = NoPages - TablePages;
|
|
Table = PopAllocatePages(HiberContext, NeededPages);
|
|
if (!Table) {
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
for (i=0; i<NeededPages; i++) {
|
|
Table[0].Link.EntryCount = 0;
|
|
Table[0].Link.NextTable = 0;
|
|
Table[0].Link.CheckSum = 1;
|
|
Table[0].Link.Next = HiberContext->TableHead;
|
|
HiberContext->TableHead = Table;
|
|
Table = (PPO_MEMORY_RANGE_ARRAY)((ULONG_PTR)Table + PAGE_SIZE);
|
|
}
|
|
TablePages += NeededPages;
|
|
}
|
|
|
|
//
|
|
// Freeze the memory map
|
|
//
|
|
|
|
HiberContext->MapFrozen = TRUE;
|
|
|
|
//
|
|
// Fill in the ranges on the table pages
|
|
//
|
|
|
|
Table = HiberContext->TableHead;
|
|
Index = 0;
|
|
|
|
//
|
|
// Add the cloned ranges first.
|
|
//
|
|
Link = HiberContext->ClonedRanges.Flink;
|
|
while (Link != &HiberContext->ClonedRanges) {
|
|
Range = CONTAINING_RECORD (Link, POP_MEMORY_RANGE, Link);
|
|
Link = Link->Flink;
|
|
|
|
PoPrint (PO_HIBER_MAP, ("PopSave: Cloned Table %08x - %08x\n",
|
|
Range->StartPage,
|
|
Range->EndPage));
|
|
|
|
Index += 1;
|
|
if (Index >= PO_MAX_RANGE_ARRAY) {
|
|
//
|
|
// Table is full, next
|
|
//
|
|
|
|
Table[0].Link.EntryCount = PO_MAX_RANGE_ARRAY-1;
|
|
Table = Table[0].Link.Next;
|
|
if (!Table) {
|
|
PopInternalError (POP_HIBER);
|
|
}
|
|
Index = 1;
|
|
}
|
|
|
|
Table[Index].Range.PageNo = 0;
|
|
Table[Index].Range.StartPage = Range->StartPage;
|
|
Table[Index].Range.EndPage = Range->EndPage;
|
|
Table[Index].Range.CheckSum = 0;
|
|
}
|
|
|
|
//
|
|
// Now add the ranges to be preserved
|
|
//
|
|
Length = RtlFindFirstRunClear(&HiberContext->MemoryMap, &StartIndex);
|
|
StartPage = StartIndex;
|
|
while (StartPage < HiberContext->MemoryMap.SizeOfBitMap) {
|
|
Index += 1;
|
|
if (Index >= PO_MAX_RANGE_ARRAY) {
|
|
//
|
|
// Table is full, next
|
|
//
|
|
|
|
Table[0].Link.EntryCount = PO_MAX_RANGE_ARRAY-1;
|
|
Table = Table[0].Link.Next;
|
|
if (!Table) {
|
|
PopInternalError (POP_HIBER);
|
|
}
|
|
Index = 1;
|
|
}
|
|
|
|
Table[Index].Range.PageNo = 0;
|
|
Table[Index].Range.StartPage = StartPage;
|
|
Table[Index].Range.EndPage = StartPage + Length;
|
|
Table[Index].Range.CheckSum = 0;
|
|
|
|
//
|
|
// Handle the corner case where the last run exactly matches
|
|
// the end of the bitmap.
|
|
//
|
|
if (StartPage + Length == HiberContext->MemoryMap.SizeOfBitMap) {
|
|
break;
|
|
}
|
|
|
|
Length = RtlFindNextForwardRunClear(&HiberContext->MemoryMap,
|
|
(ULONG)(StartPage + Length),
|
|
&StartIndex);
|
|
StartPage = StartIndex;
|
|
}
|
|
|
|
Table[0].Link.EntryCount = Index;
|
|
return HiberContext->Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
PopSaveHiberContext (
|
|
IN PPOP_HIBER_CONTEXT HiberContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called at HIGH_LEVEL just before the sleep operation to
|
|
make a snap shot of the system memory as defined by
|
|
the memory image array. Cloning and applying
|
|
checksum of the necessary pages occurs here.
|
|
|
|
Arguments:
|
|
|
|
HiberContext - The memory map
|
|
|
|
Return Value:
|
|
|
|
Status
|
|
|
|
--*/
|
|
{
|
|
POP_MCB_CONTEXT CurrentMcb;
|
|
PPO_MEMORY_IMAGE MemImage;
|
|
PPOP_MEMORY_RANGE Range;
|
|
PPO_MEMORY_RANGE_ARRAY Table;
|
|
ULONG Index;
|
|
PFN_NUMBER sp, ep;
|
|
DUMP_MDL DumpMdl;
|
|
PMDL Mdl;
|
|
PUCHAR cp;
|
|
PLIST_ENTRY Link;
|
|
PFN_NUMBER PageNo;
|
|
PFN_NUMBER Pages;
|
|
NTSTATUS Status;
|
|
PPFN_NUMBER TablePage;
|
|
ULONGLONG StartCount;
|
|
|
|
|
|
//
|
|
// Hal had better have interrupts disabled here
|
|
//
|
|
|
|
if (KeDisableInterrupts() != FALSE) {
|
|
PopInternalError (POP_HIBER);
|
|
}
|
|
|
|
MemImage = HiberContext->MemoryImage;
|
|
HiberContext->CurrentMcb = &CurrentMcb;
|
|
|
|
//
|
|
// Get the current state of the processor
|
|
//
|
|
|
|
RtlZeroMemory(&PoWakeState, sizeof(KPROCESSOR_STATE));
|
|
KeSaveStateForHibernate(&PoWakeState);
|
|
HiberContext->WakeState = &PoWakeState;
|
|
|
|
//
|
|
// If there's something already in the memory image signature then
|
|
// the system is now waking up.
|
|
//
|
|
|
|
if (MemImage->Signature) {
|
|
|
|
#ifndef HIBERNATE_PRESERVE_BPS
|
|
//
|
|
// If the debugger was active, reset it
|
|
//
|
|
|
|
if (KdDebuggerEnabled && !KdPitchDebugger) {
|
|
KdDebuggerEnabled = FALSE;
|
|
KdInitSystem (0, NULL);
|
|
}
|
|
#endif // HIBERNATE_PRESERVE_BPS
|
|
|
|
//
|
|
// Loader feature to breakin to the debugger when someone
|
|
// presses the space bar while coming back from hibernate
|
|
//
|
|
|
|
if (KdDebuggerEnabled) {
|
|
|
|
if (MemImage->Signature == PO_IMAGE_SIGNATURE_BREAK)
|
|
{
|
|
DbgBreakPoint();
|
|
}
|
|
//
|
|
// Notify the debugger we are coming back from hibernate
|
|
//
|
|
|
|
}
|
|
|
|
return STATUS_WAKE_SYSTEM;
|
|
}
|
|
|
|
//
|
|
// Set a non-zero value in the signature for the next time
|
|
//
|
|
|
|
MemImage->Signature += 1;
|
|
|
|
//
|
|
// Initialize hibernation driver stack
|
|
//
|
|
// N.B. We must reset the display and do any INT10 here. Otherwise
|
|
// the realmode stack in the HAL will get used to do the callback
|
|
// later and that memory will be modified.
|
|
//
|
|
|
|
if (HiberContext->WriteToFile) {
|
|
|
|
if (InbvIsBootDriverInstalled()) {
|
|
|
|
PUCHAR Bitmap1, Bitmap2;
|
|
|
|
Bitmap1 = InbvGetResourceAddress(2); // hibernation bitmap
|
|
Bitmap2 = InbvGetResourceAddress(5); // logo bitmap
|
|
|
|
InbvEnableDisplayString(TRUE);
|
|
InbvAcquireDisplayOwnership();
|
|
InbvResetDisplay(); // required to reset display
|
|
InbvSolidColorFill(0,0,639,479,0);
|
|
|
|
if (Bitmap1 && Bitmap2) {
|
|
InbvBitBlt(Bitmap1, 190, 279);
|
|
InbvBitBlt(Bitmap2, 217, 111);
|
|
}
|
|
|
|
InbvSetProgressBarSubset(0, 100);
|
|
InbvSetProgressBarCoordinates(303,282);
|
|
} else {
|
|
InbvResetDisplay(); // required to reset display
|
|
}
|
|
|
|
StartCount = HIBER_GET_TICK_COUNT(NULL);
|
|
Status = IoInitializeDumpStack (HiberContext->DumpStack, NULL);
|
|
HiberContext->PerfInfo.InitTicks += HIBER_GET_TICK_COUNT(NULL) - StartCount;
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
PoPrint (PO_HIBERNATE, ("PopSave: dump driver initialization failed %08x\n", Status));
|
|
return Status;
|
|
}
|
|
}
|
|
|
|
PERFINFO_HIBER_PAUSE_LOGGING();
|
|
|
|
// **************************************
|
|
// FROM HERE OUT NO MEMORY CAN BE EDITED
|
|
// **************************************
|
|
PoHiberInProgress = TRUE;
|
|
|
|
//
|
|
// From here out no memory can be edited until the system wakes up, unless
|
|
// that memory has been explicitly accounted for. The list of memory which
|
|
// is allowed to be edited is:
|
|
//
|
|
// - the local stack on each processor
|
|
// - the kernel debuggers global data
|
|
// - the page containing the 16 PTEs used by MM for MmMapMemoryDumpMdl
|
|
// - the restoration table pages
|
|
// - the page containing the MemImage structure
|
|
// - the page containing IoPage
|
|
//
|
|
|
|
|
|
//
|
|
// Clone required pages
|
|
// (note the MemImage srtucture present at system wake will
|
|
// be the one cloned here)
|
|
//
|
|
|
|
Link = HiberContext->ClonedRanges.Flink;
|
|
while (Link != &HiberContext->ClonedRanges) {
|
|
Range = CONTAINING_RECORD (Link, POP_MEMORY_RANGE, Link);
|
|
Link = Link->Flink;
|
|
|
|
ASSERT(Range->CloneVa);
|
|
cp = Range->CloneVa;
|
|
sp = Range->StartPage;
|
|
ep = Range->EndPage;
|
|
Mdl = (PMDL) DumpMdl;
|
|
|
|
while (sp < ep) {
|
|
PopCreateDumpMdl (Mdl, sp, ep);
|
|
memcpy (cp, Mdl->MappedSystemVa, Mdl->ByteCount);
|
|
cp += Mdl->ByteCount;
|
|
sp += Mdl->ByteCount >> PAGE_SHIFT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Assign page numbers to ranges
|
|
//
|
|
// N.B. We do this here to basically prove that it can be done
|
|
// and to gather some statistics. With the addition of compression,
|
|
// the PageNo field of the Table entries is only applicable to the
|
|
// table pages since uncertain compression ratios do not allow us to
|
|
// predict where each memory range will be written.
|
|
//
|
|
|
|
TablePage = &MemImage->FirstTablePage;
|
|
Table = HiberContext->TableHead;
|
|
PageNo = PO_FIRST_RANGE_TABLE_PAGE;
|
|
while (Table) {
|
|
*TablePage = PageNo;
|
|
PageNo += 1;
|
|
|
|
for (Index=1; Index <= Table[0].Link.EntryCount; Index++) {
|
|
Table[Index].Range.PageNo = PageNo;
|
|
Pages = Table[Index].Range.EndPage - Table[Index].Range.StartPage;
|
|
PageNo += Pages;
|
|
MemImage->TotalPages += Pages;
|
|
}
|
|
|
|
TablePage = &Table[0].Link.NextTable;
|
|
Table = Table[0].Link.Next;
|
|
}
|
|
MemImage->LastFilePage = PageNo;
|
|
|
|
PoPrint (PO_HIBERNATE, ("PopSave: NoFree pages %08x\n", MemImage->NoFreePages));
|
|
PoPrint (PO_HIBERNATE, ("PopSave: Memory pages %08x (%dMB)\n", MemImage->TotalPages, MemImage->TotalPages/(PAGE_SIZE/16)));
|
|
PoPrint (PO_HIBERNATE, ("PopSave: File pages %08x (%dMB)\n", MemImage->LastFilePage, MemImage->LastFilePage/(PAGE_SIZE/16)));
|
|
PoPrint (PO_HIBERNATE, ("PopSave: HiberPte %08x for %x\n", MemImage->HiberVa, MemImage->NoHiberPtes));
|
|
|
|
//
|
|
// File should be large enough, but check
|
|
//
|
|
|
|
if (HiberContext->WriteToFile && PageNo > PopHiberFile.FilePages) {
|
|
PoPrint (PO_HIBERNATE, ("PopSave: File too small - need %x\n", PageNo));
|
|
return STATUS_DISK_FULL;
|
|
}
|
|
|
|
//
|
|
// Write the hiberfile image
|
|
//
|
|
|
|
Status = PopWriteHiberImage (HiberContext, MemImage, &PopHiberFile);
|
|
|
|
PERFINFO_HIBER_DUMP_PERF_BUFFER();
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// If debugging, do it again into a second image
|
|
//
|
|
|
|
if (PopSimulate & POP_DEBUG_HIBER_FILE) {
|
|
Status = PopWriteHiberImage (HiberContext, MemImage, &PopHiberFileDebug);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
PopWriteHiberImage (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PPO_MEMORY_IMAGE MemImage,
|
|
IN PPOP_HIBER_FILE HiberFile
|
|
)
|
|
{
|
|
PPOP_MCB_CONTEXT CMcb;
|
|
PPO_MEMORY_RANGE_ARRAY Table;
|
|
ULONG Index;
|
|
PFN_NUMBER sp, ep;
|
|
DUMP_MDL DumpMdl;
|
|
PMDL Mdl;
|
|
PUCHAR cp;
|
|
PFN_NUMBER PageNo;
|
|
PFN_NUMBER Pages;
|
|
PVOID IoPage;
|
|
PPFN_NUMBER TablePage;
|
|
ULONG LastPercent;
|
|
ULONG i;
|
|
ULONG temp;
|
|
ULONG_PTR CompressedWriteOffset = 0;
|
|
PVOID CloneVa;
|
|
ULONG PoWakeCheck;
|
|
|
|
LONGLONG EndCount;
|
|
LARGE_INTEGER TickFrequency;
|
|
|
|
HiberContext->PerfInfo.StartCount = HIBER_GET_TICK_COUNT(&TickFrequency);
|
|
|
|
//
|
|
// Set the sector locations for the proper file
|
|
//
|
|
|
|
CMcb = (PPOP_MCB_CONTEXT) HiberContext->CurrentMcb;
|
|
CMcb->FirstMcb = HiberFile->NonPagedMcb;
|
|
CMcb->Mcb = HiberFile->NonPagedMcb;
|
|
CMcb->Base = 0;
|
|
IoPage = HiberContext->IoPage;
|
|
|
|
//
|
|
// Write the free page map page
|
|
//
|
|
|
|
RtlZeroMemory (IoPage, PAGE_SIZE);
|
|
if (HiberContext->LoaderMdl) {
|
|
//
|
|
// The hibernation file has one page to hold the free page map.
|
|
// If MmHiberPages is more pages than would fit, it's not possible
|
|
// to pass enough free pages to guarantee being able to reload the
|
|
// hibernation image, so don't hibernate.
|
|
//
|
|
|
|
if (MmHiberPages > PAGE_SIZE / sizeof (ULONG)) {
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
|
|
MemImage->NoFreePages = HiberContext->LoaderMdl->ByteCount >> PAGE_SHIFT;
|
|
//
|
|
// Hibernate only if the number of free pages on the MDL is more than
|
|
// the required MmHiberPages.
|
|
//
|
|
|
|
if (MemImage->NoFreePages >= MmHiberPages) {
|
|
cp = (PUCHAR) MmGetMdlPfnArray( HiberContext->LoaderMdl );
|
|
|
|
#if defined(_AMD64_)
|
|
|
|
//
|
|
// These pages are reserved for loader use. They must live
|
|
// under 4GB space. It is safe to assume the pfns of these
|
|
// pages are of 32-bit values and only save their low dwords.
|
|
//
|
|
|
|
for (i = 0; i < MmHiberPages; i++) {
|
|
*((PULONG)IoPage + i) = *(PLONG)((PPFN_NUMBER)cp + i);
|
|
}
|
|
#else
|
|
memcpy (IoPage, cp, MmHiberPages * sizeof(PFN_NUMBER));
|
|
#endif
|
|
MemImage->NoFreePages = MmHiberPages;
|
|
} else {
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
} else {
|
|
|
|
//
|
|
// If there are no free pages available to pass to the loader, don't
|
|
// hibernate.
|
|
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
|
|
MemImage->FreeMapCheck = PoSimpleCheck(0, IoPage, PAGE_SIZE);
|
|
PopWriteHiberPages (HiberContext, IoPage, 1, PO_FREE_MAP_PAGE, NULL);
|
|
|
|
//
|
|
// Write the processors saved context
|
|
//
|
|
|
|
RtlZeroMemory (IoPage, PAGE_SIZE);
|
|
memcpy (IoPage, HiberContext->WakeState, sizeof(KPROCESSOR_STATE));
|
|
PoWakeCheck =
|
|
MemImage->WakeCheck = PoSimpleCheck(0, IoPage, sizeof(KPROCESSOR_STATE));
|
|
PopWriteHiberPages (HiberContext, IoPage, 1, PO_PROCESSOR_CONTEXT_PAGE, NULL);
|
|
temp = PoSimpleCheck(0, IoPage, sizeof(KPROCESSOR_STATE));
|
|
if (MemImage->WakeCheck != temp) {
|
|
DbgPrint("Checksum for context page changed from %lx to %lx\n",
|
|
MemImage->WakeCheck, temp);
|
|
KeBugCheckEx(INTERNAL_POWER_ERROR, 3, MemImage->WakeCheck, temp, __LINE__);
|
|
}
|
|
temp = PoSimpleCheck(0, IoPage, PAGE_SIZE);
|
|
if (MemImage->WakeCheck != temp) {
|
|
DbgPrint("Checksum for partial context page %lx doesn't match full %lx\n",
|
|
MemImage->WakeCheck, temp);
|
|
KeBugCheckEx(INTERNAL_POWER_ERROR, 4, MemImage->WakeCheck, temp, __LINE__);
|
|
}
|
|
|
|
//
|
|
// Before computing checksums, remove all breakpoints so they are not
|
|
// written in the saved image
|
|
//
|
|
#ifndef HIBERNATE_PRESERVE_BPS
|
|
if (KdDebuggerEnabled &&
|
|
!KdPitchDebugger &&
|
|
!(PopSimulate & POP_IGNORE_HIBER_SYMBOL_UNLOAD)) {
|
|
|
|
KdDeleteAllBreakpoints();
|
|
}
|
|
#endif // HIBERNATE_PRESERVE_BPS
|
|
|
|
//
|
|
// Run each range, put its checksum in the restoration table
|
|
// and write each range to the file
|
|
//
|
|
|
|
Table = HiberContext->TableHead;
|
|
LastPercent = 100;
|
|
|
|
HiberContext->PerfInfo.PagesProcessed = 0;
|
|
|
|
TablePage = &MemImage->FirstTablePage;
|
|
PageNo = PO_FIRST_RANGE_TABLE_PAGE;
|
|
PopResetRangeEnum(HiberContext);
|
|
|
|
while (Table) {
|
|
|
|
// Keep track of where the page tables have been written
|
|
|
|
*TablePage = PageNo;
|
|
PageNo++;
|
|
|
|
for (Index=1; Index <= Table[0].Link.EntryCount; Index++) {
|
|
PopIOResume (HiberContext, FALSE);
|
|
|
|
PopGetNextRange(HiberContext, &sp, &ep, &CloneVa);
|
|
|
|
if ((Table[Index].Range.StartPage != sp) ||
|
|
(Table[Index].Range.EndPage != ep)) {
|
|
|
|
PoPrint(PO_ERROR,("PopWriteHiberImage: Table entry %p [%lx-%lx] does not match next range [%lx-%lx]\n",
|
|
Table+Index,
|
|
Table[Index].Range.StartPage,
|
|
Table[Index].Range.EndPage,
|
|
sp,
|
|
ep));
|
|
PopInternalAddToDumpFile( HiberContext, sizeof(POP_HIBER_CONTEXT), NULL, NULL, NULL, NULL );
|
|
PopInternalAddToDumpFile( Table, PAGE_SIZE, NULL, NULL, NULL, NULL );
|
|
KeBugCheckEx( INTERNAL_POWER_ERROR,
|
|
0x107,
|
|
POP_HIBER,
|
|
(ULONG_PTR)HiberContext,
|
|
(ULONG_PTR)Table );
|
|
}
|
|
|
|
Table[Index].Range.PageNo = PageNo;
|
|
|
|
//
|
|
// Write the data to hiber file
|
|
//
|
|
|
|
if (CloneVa) {
|
|
|
|
//
|
|
// Use the cloned data which is already mapped
|
|
//
|
|
|
|
Pages = ep - sp;
|
|
|
|
// Compute the cloned range's Checksum
|
|
|
|
Table[Index].Range.CheckSum = 0;
|
|
|
|
// Add the pages to the compressed page set
|
|
// (effectively writing them out)
|
|
|
|
PopAddPagesToCompressedPageSet(TRUE,
|
|
HiberContext,
|
|
&CompressedWriteOffset,
|
|
CloneVa,
|
|
Pages,
|
|
&PageNo);
|
|
HiberContext->PerfInfo.PagesProcessed += (ULONG)Pages;
|
|
|
|
// Update the progress bar
|
|
|
|
i = (ULONG)((HiberContext->PerfInfo.PagesProcessed * 100) / MemImage->TotalPages);
|
|
|
|
if (i != LastPercent) {
|
|
LastPercent = i;
|
|
PopUpdateHiberComplete(HiberContext, LastPercent);
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// Map a chunk and write it, loop until done
|
|
//
|
|
Mdl = (PMDL) DumpMdl;
|
|
|
|
// Initialize Check Sum
|
|
|
|
Table[Index].Range.CheckSum = 0;
|
|
|
|
while (sp < ep) {
|
|
PopCreateDumpMdl (Mdl, sp, ep);
|
|
|
|
Pages = Mdl->ByteCount >> PAGE_SHIFT;
|
|
|
|
// Add pages to compressed page set
|
|
// (effectively writing them out)
|
|
|
|
PopAddPagesToCompressedPageSet(TRUE,
|
|
HiberContext,
|
|
&CompressedWriteOffset,
|
|
Mdl->MappedSystemVa,
|
|
Pages,
|
|
&PageNo);
|
|
sp += Pages;
|
|
HiberContext->PerfInfo.PagesProcessed += (ULONG)Pages;
|
|
|
|
// Update the progress bar
|
|
|
|
i = (ULONG)((HiberContext->PerfInfo.PagesProcessed * 100) / MemImage->TotalPages);
|
|
if (i != LastPercent) {
|
|
LastPercent = i;
|
|
PopUpdateHiberComplete(HiberContext, LastPercent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Terminate the compressed page set, since the next page
|
|
// (a table page) is uncompressed.
|
|
|
|
PopEndCompressedPageSet(HiberContext, &CompressedWriteOffset, &PageNo);
|
|
|
|
TablePage = &Table[0].Link.NextTable;
|
|
Table = Table[0].Link.Next;
|
|
}
|
|
|
|
|
|
//
|
|
// Now that the range checksums have been added to the
|
|
// restoration tables they are now complete. Compute their
|
|
// checksums and write them into the file
|
|
//
|
|
|
|
Table = HiberContext->TableHead;
|
|
PageNo = PO_FIRST_RANGE_TABLE_PAGE;
|
|
while (Table) {
|
|
Table[0].Link.CheckSum = 0;
|
|
PopWriteHiberPages (HiberContext, Table, 1, PageNo, NULL);
|
|
|
|
PageNo = Table[0].Link.NextTable;
|
|
Table = Table[0].Link.Next;
|
|
}
|
|
|
|
//
|
|
// File is complete write a valid header
|
|
//
|
|
|
|
if (MemImage->WakeCheck != PoWakeCheck) {
|
|
DbgPrint("MemImage->WakeCheck %lx doesn't make PoWakeCheck %lx\n",
|
|
MemImage->WakeCheck,
|
|
PoWakeCheck);
|
|
//
|
|
// subcode 5 is used in other places. So it's much harder to diagnose this
|
|
// bugcheck. Cut our losses here and start using subcode 0x109.
|
|
//
|
|
// KeBugCheckEx( INTERNAL_POWER_ERROR, 5, MemImage->WakeCheck, PoWakeCheck, __LINE__);
|
|
KeBugCheckEx( INTERNAL_POWER_ERROR,
|
|
0x109,
|
|
POP_HIBER,
|
|
MemImage->WakeCheck,
|
|
PoWakeCheck );
|
|
}
|
|
|
|
//
|
|
// Fill in perf information so we can read it after hibernation
|
|
//
|
|
EndCount = HIBER_GET_TICK_COUNT(&TickFrequency);
|
|
HiberContext->PerfInfo.ElapsedTime = (ULONG)((EndCount - HiberContext->PerfInfo.StartCount)*1000 / TickFrequency.QuadPart);
|
|
HiberContext->PerfInfo.IoTime = (ULONG)(HiberContext->PerfInfo.IoTicks*1000 / TickFrequency.QuadPart);
|
|
HiberContext->PerfInfo.CopyTime = (ULONG)(HiberContext->PerfInfo.CopyTicks*1000 / TickFrequency.QuadPart);
|
|
HiberContext->PerfInfo.InitTime = (ULONG)(HiberContext->PerfInfo.InitTicks*1000 / TickFrequency.QuadPart);
|
|
HiberContext->PerfInfo.FileRuns = PopHiberFile.McbSize / sizeof(LARGE_INTEGER) - 1;
|
|
|
|
MemImage->Signature = PO_IMAGE_SIGNATURE;
|
|
MemImage->PerfInfo = HiberContext->PerfInfo;
|
|
MemImage->CheckSum = PoSimpleCheck(0, MemImage, sizeof(*MemImage));
|
|
PopWriteHiberPages (HiberContext, MemImage, 1, PO_IMAGE_HEADER_PAGE, NULL);
|
|
|
|
//
|
|
// Image completely written flush the controller
|
|
//
|
|
PoPrint (PO_ERROR, ("PopWriteHiberImage: About to actually flush the controller\r\n"));
|
|
if (HiberContext->WriteToFile) {
|
|
while (NT_SUCCESS (HiberContext->Status) &&
|
|
(DmaIoPtr != NULL) &&
|
|
((DmaIoPtr->Busy.Size != 0) || (DmaIoPtr->Used.Size != 0))) {
|
|
PopIOResume (HiberContext, TRUE);
|
|
}
|
|
|
|
HiberContext->DumpStack->Init.FinishRoutine();
|
|
}
|
|
|
|
PoPrint (PO_ERROR, ("PopWriteHiberImage: Back from flushing the controller. Status (0x%x)\r\n", HiberContext->Status));
|
|
|
|
if (PopSimulate & POP_ENABLE_HIBER_PERF) {
|
|
PopDumpStatistics(&HiberContext->PerfInfo);
|
|
}
|
|
|
|
//
|
|
// Failed to write the hiberfile.
|
|
//
|
|
if (!NT_SUCCESS(HiberContext->Status)) {
|
|
#if DBG
|
|
PoPrint (PO_ERROR, ("PopWriteHiberImage: Error occured writing the hiberfile. (%x)\n", HiberContext->Status));
|
|
PopInternalAddToDumpFile( HiberContext, sizeof(POP_HIBER_CONTEXT), NULL, NULL, NULL, NULL );
|
|
KeBugCheckEx( INTERNAL_POWER_ERROR,
|
|
0x10A,
|
|
POP_HIBER,
|
|
(ULONG_PTR)HiberContext,
|
|
HiberContext->Status );
|
|
#else
|
|
return( HiberContext->Status );
|
|
#endif
|
|
}
|
|
|
|
//
|
|
// Before sleeping, if the check memory bit is set verify the
|
|
// dump process didn't edit any memory pages
|
|
//
|
|
|
|
if (PopSimulate & POP_TEST_CRC_MEMORY) {
|
|
if (!(PopSimulate & POP_DEBUG_HIBER_FILE) ||
|
|
(HiberFile == &PopHiberFileDebug)) {
|
|
}
|
|
}
|
|
|
|
//
|
|
// Tell the debugger we are hibernating
|
|
//
|
|
|
|
if (!(PopSimulate & POP_IGNORE_HIBER_SYMBOL_UNLOAD)) {
|
|
|
|
KD_SYMBOLS_INFO SymbolInfo = {0};
|
|
SymbolInfo.BaseOfDll = (PVOID)KD_HIBERNATE;
|
|
|
|
DebugService2(NULL, &SymbolInfo, BREAKPOINT_UNLOAD_SYMBOLS);
|
|
}
|
|
|
|
//
|
|
// If we want to perform a reset instead of a power down, return an
|
|
// error so we don't power down
|
|
//
|
|
|
|
if (PopSimulate & POP_RESET_ON_HIBER) {
|
|
return STATUS_DEVICE_DOES_NOT_EXIST;
|
|
}
|
|
|
|
//
|
|
// Success, continue with power off operation
|
|
//
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
PopDumpStatistics(
|
|
IN PPO_HIBER_PERF PerfInfo
|
|
)
|
|
{
|
|
LONGLONG EndCount;
|
|
LARGE_INTEGER TickFrequency;
|
|
|
|
EndCount = HIBER_GET_TICK_COUNT(&TickFrequency);
|
|
PerfInfo->ElapsedTime = (ULONG)((EndCount - PerfInfo->StartCount)*1000 / TickFrequency.QuadPart);
|
|
PerfInfo->IoTime = (ULONG)(PerfInfo->IoTicks*1000 / TickFrequency.QuadPart);
|
|
PerfInfo->CopyTime = (ULONG)(PerfInfo->CopyTicks*1000 / TickFrequency.QuadPart);
|
|
PerfInfo->InitTime = (ULONG)(PerfInfo->InitTicks*1000 / TickFrequency.QuadPart);
|
|
PerfInfo->FileRuns = PopHiberFile.McbSize / sizeof(LARGE_INTEGER) - 1;
|
|
DbgPrint("HIBER: %lu Pages written in %lu Dumps (%lu runs).\n",
|
|
PerfInfo->PagesWritten,
|
|
PerfInfo->DumpCount,
|
|
PerfInfo->FileRuns);
|
|
DbgPrint("HIBER: %lu Pages processed (%d %% compression)\n",
|
|
PerfInfo->PagesProcessed,
|
|
PerfInfo->PagesWritten*100/PerfInfo->PagesProcessed);
|
|
DbgPrint("HIBER: Elapsed time %3d.%03d seconds\n",
|
|
PerfInfo->ElapsedTime / 1000,
|
|
PerfInfo->ElapsedTime % 1000);
|
|
DbgPrint("HIBER: I/O time %3d.%03d seconds (%2d%%) %d MB/sec\n",
|
|
PerfInfo->IoTime / 1000,
|
|
PerfInfo->IoTime % 1000,
|
|
PerfInfo->ElapsedTime ? PerfInfo->IoTime*100/PerfInfo->ElapsedTime : 0,
|
|
(PerfInfo->IoTime/100000) ? (PerfInfo->PagesWritten/(1024*1024/PAGE_SIZE)) / (PerfInfo->IoTime / 100000) : 0);
|
|
DbgPrint("HIBER: Init time %3d.%03d seconds (%2d%%)\n",
|
|
PerfInfo->InitTime / 1000,
|
|
PerfInfo->InitTime % 1000,
|
|
PerfInfo->ElapsedTime ? PerfInfo->InitTime*100/PerfInfo->ElapsedTime : 0);
|
|
DbgPrint("HIBER: Copy time %3d.%03d seconds (%2d%%) %d Bytes\n",
|
|
PerfInfo->CopyTime / 1000,
|
|
PerfInfo->CopyTime % 1000,
|
|
PerfInfo->ElapsedTime ? PerfInfo->CopyTime*100/PerfInfo->ElapsedTime : 0,
|
|
PerfInfo->BytesCopied );
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
PopUpdateHiberComplete (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN ULONG Percent
|
|
)
|
|
{
|
|
CHAR Buffer[200];
|
|
|
|
if (InbvIsBootDriverInstalled()) {
|
|
|
|
InbvUpdateProgressBar(Percent + 1);
|
|
|
|
} else {
|
|
|
|
sprintf (Buffer, "PopSave: %d%%\r", Percent);
|
|
PoPrint (PO_HIBER_MAP, ("%s", Buffer));
|
|
if (HiberContext->WriteToFile) {
|
|
InbvDisplayString ((PUCHAR) Buffer);
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
if ((Percent > 0) &&
|
|
((Percent % 10) == 0) &&
|
|
(PopSimulate & POP_ENABLE_HIBER_PERF)) {
|
|
DbgPrint("HIBER: %d %% done\n",Percent);
|
|
PopDumpStatistics(&HiberContext->PerfInfo);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
VOID
|
|
PopEndCompressedPageSet(
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN OUT PULONG_PTR CompressedBufferOffset,
|
|
IN OUT PPFN_NUMBER SetFilePage
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Terminates a compressed page set, flushing whatever remains in the compression
|
|
buffer to the Hiber file. A termination of a compressed page set allows uncompressed
|
|
pages to the be written out to the Hiber file.
|
|
|
|
See PopAddPagesToCompressedPageSet for more information on compressed page sets.
|
|
|
|
Arguments:
|
|
|
|
HiberContext - The Hiber Context.
|
|
|
|
CompressedBufferOffset - Similar to same parameter in PopAddPagesToCompressedPageSet.
|
|
|
|
Should be the CompressedBufferOffset value received
|
|
from the last call to PopAddPagesToCompressedPageSet.
|
|
Will be reset to 0 after this call in preparation
|
|
for the beginning of a new compressed page set.
|
|
|
|
SetFilePage - Similar to same parameter in PopAddPagsToCompressedPageSet.
|
|
|
|
Should be the SetFilePAge value received from the last
|
|
call to PopAddPagesToCompressedPageSet. Will be reset
|
|
to the next available file page after the end of this
|
|
compressed page set.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PFN_NUMBER Pages;
|
|
PCOMPRESSION_BLOCK Block = HiberContext->CompressionBlock;
|
|
|
|
// is there are any blocked data?
|
|
if (Block->Ptr != Block->Buffer) {
|
|
// yes, flush the block
|
|
PopAddPagesToCompressedPageSet (FALSE, // no buffering -- compress now
|
|
HiberContext,
|
|
CompressedBufferOffset,
|
|
Block->Buffer,
|
|
(PFN_NUMBER) ((Block->Ptr - Block->Buffer) >> PAGE_SHIFT),
|
|
SetFilePage);
|
|
|
|
// reset block to empty
|
|
Block->Ptr = Block->Buffer;
|
|
}
|
|
|
|
|
|
// Figure out how many pages remain in the compression buffer. Don't
|
|
// use BYTES_TO_PAGES because that will truncate to ULONG.
|
|
|
|
Pages = (PFN_NUMBER) ((*CompressedBufferOffset + (PAGE_SIZE-1)) >> PAGE_SHIFT);
|
|
|
|
if (Pages > 0) {
|
|
|
|
// Write the remaining pages out
|
|
|
|
PopWriteHiberPages(HiberContext,
|
|
(PVOID)HiberContext->CompressedWriteBuffer,
|
|
Pages,
|
|
*SetFilePage,
|
|
NULL);
|
|
|
|
// Reflect our usage of the hiber file
|
|
|
|
*SetFilePage = *SetFilePage + Pages;
|
|
}
|
|
|
|
*CompressedBufferOffset = 0;
|
|
}
|
|
|
|
VOID
|
|
PopAddPagesToCompressedPageSet(
|
|
IN BOOLEAN AllowDataBuffering,
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN OUT PULONG_PTR CompressedBufferOffset,
|
|
IN PVOID StartVa,
|
|
IN PFN_NUMBER NumPages,
|
|
IN OUT PPFN_NUMBER SetFilePage
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is the central call needed to write out memory pages
|
|
in a compressed fashion.
|
|
|
|
This routine takes a continuous range of mapped pages and adds
|
|
them to a compressed page set. A compressed page set is merely
|
|
a stream of compressed buffers written out contiguously within
|
|
the Hiber file. Such a contiguous layout maximizes the benefit
|
|
gained from compression by writing compressed output into
|
|
the smallest possible space.
|
|
|
|
In order to accomplish such a layout, this routine continually
|
|
compresses pages and adds them to the compression buffer pointed to
|
|
by the Hiber context. Once a certain point in that buffer is reached,
|
|
it is written out to the Hiber file and the buffer is reset to the
|
|
beginning. Each write-out of the compression buffer is placed
|
|
right after the end of the last compression buffer written.
|
|
|
|
Because of the buffering used in this algorithm, compressed buffers
|
|
may remain in the compression buffer even after the last needed
|
|
call to PopAddPagesToCompressedPageSet. In order to fully flush
|
|
the buffer, PopEndCompressedPageSet must be called.
|
|
|
|
Note that in order to write any uncompressed pages to the Hiber
|
|
file, the compressed page set needs to be terminated with
|
|
PopEndCompressedPageSet. After a compressed page set is terminated,
|
|
a new set can be initiated with a call to PopAddPagesToCompressedPageSet.
|
|
|
|
N.B. A chunk of a compressed page set that has been committed to the
|
|
Hiber file in one write operation is called a compressed page set fragment
|
|
in other places within this file.
|
|
|
|
Arguments:
|
|
|
|
AllowDataBuffering - If true input pages will be buffered, otherwise
|
|
- compressed and [possibly] written immediately
|
|
|
|
HiberContext - The Hiber context
|
|
|
|
CompressedBufferOffset - An offset into the Hiber context's compression buffer
|
|
where the addition of the next compressed buffer will
|
|
occurr.
|
|
|
|
This offset should be set to 0 at the beginning of
|
|
every compressed page set. After every call,
|
|
to PopAddPagesToCompressedPageSet this offset
|
|
will be modified to reflect the current usage of
|
|
the compression buffer.
|
|
|
|
StartVa - The starting virtual address of the pages to
|
|
add to the compressed page set.
|
|
|
|
NumPages - The number of pages to add to the compressed page set.
|
|
|
|
SetFilePage - A pointer to first page in the Hiber file that will receive
|
|
the next write-out of the compression buffer.
|
|
|
|
This page should be set to the first available Hiber file
|
|
page when the compressed page set is begun. The page will
|
|
be reset to reflect the current usage of the Hiber file
|
|
by the compressed page set after each call to
|
|
PopAddPagesToCompressedPageSet.
|
|
|
|
Return Value:
|
|
|
|
NONE.
|
|
|
|
--*/
|
|
{
|
|
ULONG_PTR BufferOffset = *CompressedBufferOffset;
|
|
PUCHAR Page = (PUCHAR)StartVa;
|
|
PFN_NUMBER i;
|
|
ULONG CompressedSize;
|
|
PFN_NUMBER NumberOfPagesToCompress;
|
|
ULONG MaxCompressedSize;
|
|
ULONG AlignedCompressedSize;
|
|
PUCHAR CompressedBuffer;
|
|
|
|
if (AllowDataBuffering) {
|
|
PCOMPRESSION_BLOCK Block = HiberContext->CompressionBlock;
|
|
|
|
// Yes, try to buffer output
|
|
if (Block->Ptr != Block->Buffer) {
|
|
// Find # of free pages left in block
|
|
NumberOfPagesToCompress = (PFN_NUMBER)
|
|
((Block->Buffer + sizeof (Block->Buffer) - Block->Ptr) >> PAGE_SHIFT);
|
|
|
|
// If it's exceed available truncate
|
|
if (NumberOfPagesToCompress > NumPages) {
|
|
NumberOfPagesToCompress = NumPages;
|
|
}
|
|
|
|
// Any free space left?
|
|
if (NumberOfPagesToCompress != 0) {
|
|
HbCopy(HiberContext, Block->Ptr, Page, NumberOfPagesToCompress << PAGE_SHIFT);
|
|
NumPages -= NumberOfPagesToCompress;
|
|
Page += NumberOfPagesToCompress << PAGE_SHIFT;
|
|
Block->Ptr += NumberOfPagesToCompress << PAGE_SHIFT;
|
|
}
|
|
|
|
// Is block full?
|
|
if (Block->Ptr == Block->Buffer + sizeof (Block->Buffer)) {
|
|
// Yes, flush the block
|
|
PopAddPagesToCompressedPageSet (FALSE, // no buffering
|
|
HiberContext,
|
|
CompressedBufferOffset,
|
|
Block->Buffer,
|
|
(PFN_NUMBER) ((Block->Ptr - Block->Buffer) >> PAGE_SHIFT),
|
|
SetFilePage);
|
|
|
|
// Reset block to empty
|
|
Block->Ptr = Block->Buffer;
|
|
}
|
|
}
|
|
|
|
NumberOfPagesToCompress = sizeof (Block->Buffer) >> PAGE_SHIFT;
|
|
|
|
// While too much to compress -- compress from original location
|
|
while (NumPages >= NumberOfPagesToCompress) {
|
|
// Write pages
|
|
PopAddPagesToCompressedPageSet (FALSE, // no buffering
|
|
HiberContext,
|
|
CompressedBufferOffset,
|
|
Page,
|
|
NumberOfPagesToCompress,
|
|
SetFilePage);
|
|
|
|
// adjust pointer and counter
|
|
Page += NumberOfPagesToCompress << PAGE_SHIFT;
|
|
NumPages -= NumberOfPagesToCompress;
|
|
}
|
|
|
|
// If anything left save it in block
|
|
// N.B.: either NumPages == 0 or there is enough space in Block
|
|
if (NumPages != 0) {
|
|
HbCopy (HiberContext, Block->Ptr, Page, NumPages << PAGE_SHIFT);
|
|
Block->Ptr += NumPages << PAGE_SHIFT;
|
|
}
|
|
|
|
// done
|
|
return;
|
|
}
|
|
|
|
// First make sure values of constants match our assumptions
|
|
|
|
#if XPRESS_HEADER_SIZE < XPRESS_HEADER_STRING_SIZE + 8
|
|
#error -- XPRESS_HEADER_SIZE shall be at least (XPRESS_HEADER_STRING_SIZE + 8)
|
|
#endif
|
|
|
|
#if XPRESS_MAX_SIZE < PAGE_SIZE || XPRESS_MAX_SIZE % PAGE_SIZE != 0
|
|
#error -- XPRESS_MAX_SIZE shall be multiple of PAGE_SIZE
|
|
#endif
|
|
|
|
#if (XPRESS_ALIGNMENT & (XPRESS_ALIGNMENT - 1)) != 0
|
|
#error -- XPRESS_ALIGNMENT shall be power of 2
|
|
#endif
|
|
|
|
#if XPRESS_HEADER_SIZE % XPRESS_ALIGNMENT != 0
|
|
#error -- XPRESS_HEADER_SIZE shall be multiple of XPRESS_ALIGNMENT
|
|
#endif
|
|
|
|
// make sure that compressed buffer and its header will fit into output buffer
|
|
#if XPRESS_MAX_SIZE + XPRESS_HEADER + PAGE_SIZE - 1 > (POP_COMPRESSED_PAGE_SET_SIZE << PAGE_SHIFT)
|
|
#error -- POP_COMPRESSED_PAGE_SET_SIZE is too small
|
|
#endif
|
|
|
|
// Real compression starts here
|
|
|
|
// Loop through all the pages ...
|
|
for (i = 0; i < NumPages; i += NumberOfPagesToCompress) {
|
|
|
|
NumberOfPagesToCompress = XPRESS_MAX_PAGES;
|
|
if (NumberOfPagesToCompress > NumPages - i) {
|
|
NumberOfPagesToCompress = NumPages - i;
|
|
}
|
|
|
|
// If compressed data occupies more than 87.5% = 7/8 of original store data as is
|
|
MaxCompressedSize = ((ULONG)NumberOfPagesToCompress * 7) * (PAGE_SIZE / 8);
|
|
|
|
|
|
// Is the buffer use beyond the write-out threshold?
|
|
|
|
//
|
|
// N.B. The buffer must extend sufficiently beyond the threshold
|
|
// the allow the last compression operation (that one that writes
|
|
// beyond the threshold) to always succeed.
|
|
//
|
|
|
|
if (BufferOffset + (NumberOfPagesToCompress << PAGE_SHIFT) + XPRESS_HEADER_SIZE > (POP_COMPRESSED_PAGE_SET_SIZE << PAGE_SHIFT)) {
|
|
// Write out the compression buffer bytes below the threshold
|
|
|
|
PopWriteHiberPages(HiberContext,
|
|
(PVOID)HiberContext->CompressedWriteBuffer,
|
|
BufferOffset >> PAGE_SHIFT,
|
|
*SetFilePage,
|
|
NULL);
|
|
|
|
// We have used some pages in the Hiber file with the above write,
|
|
// indicate that our next Hiber file page will be beyond those used pages.
|
|
|
|
*SetFilePage = *SetFilePage + (BufferOffset >> PAGE_SHIFT);
|
|
|
|
// Move buffer bytes that are above the write-out threshold to the
|
|
// beginning of the buffer
|
|
|
|
if (BufferOffset & (PAGE_SIZE - 1)) {
|
|
HbCopy(HiberContext,
|
|
HiberContext->CompressedWriteBuffer,
|
|
HiberContext->CompressedWriteBuffer + (BufferOffset & ~(PAGE_SIZE - 1)),
|
|
(ULONG)BufferOffset & (PAGE_SIZE - 1));
|
|
}
|
|
|
|
// Reset the buffer offset back to the beginning of the buffer but right
|
|
// after any above-threshold buffer bytes that we will move to the beginning
|
|
// of the buffer
|
|
|
|
BufferOffset &= PAGE_SIZE - 1;
|
|
}
|
|
|
|
|
|
// Remember output position
|
|
|
|
CompressedBuffer = HiberContext->CompressedWriteBuffer + BufferOffset;
|
|
|
|
// Clear the header
|
|
RtlZeroMemory (CompressedBuffer, XPRESS_HEADER_SIZE);
|
|
|
|
|
|
// Compress pages into the compression buffer
|
|
|
|
if (HIBER_USE_DMA (HiberContext)) {
|
|
// Try to resume IO calling callback each 8192 bytes
|
|
CompressedSize = XpressEncode ((XpressEncodeStream) (HiberContext->CompressionWorkspace),
|
|
CompressedBuffer + XPRESS_HEADER_SIZE,
|
|
MaxCompressedSize,
|
|
(PVOID) Page,
|
|
(ULONG)NumberOfPagesToCompress << PAGE_SHIFT,
|
|
PopIOCallback,
|
|
HiberContext,
|
|
8192);
|
|
} else {
|
|
// No need for callbacks -- compress everything at once
|
|
CompressedSize = XpressEncode ((XpressEncodeStream) (HiberContext->CompressionWorkspace),
|
|
CompressedBuffer + XPRESS_HEADER_SIZE,
|
|
MaxCompressedSize,
|
|
(PVOID) Page,
|
|
(ULONG)NumberOfPagesToCompress << PAGE_SHIFT,
|
|
NULL,
|
|
NULL,
|
|
0);
|
|
}
|
|
|
|
// If compression failed copy data as is original
|
|
|
|
if (CompressedSize >= MaxCompressedSize) {
|
|
CompressedSize = (ULONG)NumberOfPagesToCompress << PAGE_SHIFT;
|
|
HbCopy (HiberContext,
|
|
CompressedBuffer + XPRESS_HEADER_SIZE,
|
|
(PVOID) Page,
|
|
CompressedSize);
|
|
}
|
|
|
|
//
|
|
// Fill the header
|
|
//
|
|
|
|
|
|
// Magic bytes (LZNT1 block cannot start from 0x81,0x81)
|
|
RtlCopyMemory (CompressedBuffer, XPRESS_HEADER_STRING, XPRESS_HEADER_STRING_SIZE);
|
|
|
|
|
|
// Size of original and compressed data
|
|
{
|
|
ULONG dw = ((CompressedSize - 1) << 10) + ((ULONG)NumberOfPagesToCompress - 1);
|
|
|
|
#if XPRESS_MAX_SIZE > (1 << 22)
|
|
#error -- XPRESS_MAX_SIZE shall not exceed 4 MB
|
|
#endif
|
|
|
|
CompressedBuffer[XPRESS_HEADER_STRING_SIZE] = (UCHAR) dw;
|
|
CompressedBuffer[XPRESS_HEADER_STRING_SIZE+1] = (UCHAR) (dw >> 8);
|
|
CompressedBuffer[XPRESS_HEADER_STRING_SIZE+2] = (UCHAR) (dw >> 16);
|
|
CompressedBuffer[XPRESS_HEADER_STRING_SIZE+3] = (UCHAR) (dw >> 24);
|
|
}
|
|
|
|
// Align compressed data on 8-byte boundary
|
|
AlignedCompressedSize = (CompressedSize + (XPRESS_ALIGNMENT - 1)) & ~(XPRESS_ALIGNMENT - 1);
|
|
if (CompressedSize != AlignedCompressedSize) {
|
|
// Fill up data with zeroes until aligned
|
|
RtlZeroMemory (CompressedBuffer + XPRESS_HEADER_SIZE + CompressedSize, AlignedCompressedSize - CompressedSize);
|
|
}
|
|
|
|
// Indicate our new usage of the buffer
|
|
|
|
BufferOffset += AlignedCompressedSize + XPRESS_HEADER_SIZE;
|
|
|
|
// Move on to the virtual address of the next page
|
|
|
|
Page += NumberOfPagesToCompress << PAGE_SHIFT;
|
|
}
|
|
|
|
*CompressedBufferOffset = BufferOffset;
|
|
}
|
|
|
|
|
|
VOID
|
|
PopIORegionMove (
|
|
IN IOREGION *To, // ptr to region descriptor to put bytes to
|
|
IN IOREGION *From, // ptr to region descriptor to get bytes from
|
|
IN LONG Bytes // # of bytes to move from the beginning of one region to the end of another
|
|
)
|
|
{
|
|
ASSERT((Bytes & (PAGE_SIZE-1)) == 0);
|
|
|
|
if (To->Size != To->End - To->Ptr) {
|
|
ASSERT (To->Ptr + To->Size == From->Ptr);
|
|
To->Size += Bytes;
|
|
ASSERT (To->Size <= To->End - To->Ptr);
|
|
} else {
|
|
ASSERT (To->Beg + To->SizeOvl == From->Ptr);
|
|
To->SizeOvl += Bytes;
|
|
ASSERT (To->Size + To->SizeOvl <= To->End - To->Beg);
|
|
}
|
|
|
|
ASSERT (Bytes <= From->Size && From->Size <= From->End - From->Ptr);
|
|
From->Size -= Bytes;
|
|
From->Ptr += Bytes;
|
|
if (From->Ptr == From->End) {
|
|
ASSERT (From->Size == 0);
|
|
From->Ptr = From->Beg;
|
|
From->Size = From->SizeOvl;
|
|
From->SizeOvl = 0;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
XPRESS_CALL
|
|
PopIOCallback (
|
|
PVOID Context,
|
|
int compressed
|
|
)
|
|
{
|
|
PPOP_HIBER_CONTEXT HiberContext = Context;
|
|
|
|
UNREFERENCED_PARAMETER (compressed);
|
|
|
|
if (HiberContext == NULL || DmaIoPtr == NULL) {
|
|
return;
|
|
}
|
|
|
|
if (DmaIoPtr->Busy.Size == 0 && DmaIoPtr->Used.Size == 0)
|
|
return;
|
|
|
|
PopIOResume (Context, FALSE);
|
|
}
|
|
|
|
BOOLEAN PopIOResume (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN BOOLEAN Complete
|
|
)
|
|
{
|
|
NTSTATUS status;
|
|
|
|
// If there were error don't even bother
|
|
if (!NT_SUCCESS(HiberContext->Status)) {
|
|
return(FALSE);
|
|
}
|
|
|
|
if (DmaIoPtr == NULL) {
|
|
return(TRUE);
|
|
}
|
|
|
|
// if delayed operation then resume or complete it
|
|
while (DmaIoPtr->Busy.Size != 0) {
|
|
|
|
status = HiberContext->DumpStack->Init.WritePendingRoutine (Complete?IO_DUMP_WRITE_FINISH:IO_DUMP_WRITE_RESUME,
|
|
NULL,
|
|
NULL,
|
|
DmaIoPtr->DumpLocalData);
|
|
|
|
if (status == STATUS_PENDING) {
|
|
// Pending IO; shall never happen if Complete
|
|
ASSERT (!Complete);
|
|
return(TRUE);
|
|
}
|
|
|
|
// If there were error then don't care
|
|
if (!NT_SUCCESS (status)) {
|
|
HiberContext->Status = status;
|
|
return(FALSE);
|
|
}
|
|
|
|
// Now, resume PopWriteHiberPages
|
|
PopWriteHiberPages (HiberContext,
|
|
NULL,
|
|
0,
|
|
0,
|
|
&DmaIoPtr->HiberWritePagesLocals);
|
|
if (!NT_SUCCESS (HiberContext->Status)) {
|
|
return(FALSE);
|
|
}
|
|
|
|
// If pending IO completed and we had to wait -- do not start new one
|
|
if (DmaIoPtr->Busy.Size == 0 && Complete) {
|
|
return(TRUE);
|
|
}
|
|
|
|
// If not completed and do no wait -- return
|
|
if (DmaIoPtr->Busy.Size != 0 && !Complete) {
|
|
return(TRUE);
|
|
}
|
|
}
|
|
|
|
while (DmaIoPtr->Used.Size >= PAGE_SIZE) {
|
|
ULONG_PTR i, j;
|
|
ULONG_PTR NoPages;
|
|
ULONG_PTR Length;
|
|
PUCHAR PageVa;
|
|
PFN_NUMBER FilePage;
|
|
|
|
// Obtain size of region waiting for IO
|
|
PageVa = DmaIoPtr->Used.Ptr;
|
|
NoPages = (Length = DmaIoPtr->Used.Size) >> PAGE_SHIFT;
|
|
// Make sure all pages should be contiguous
|
|
i = DmaIoPtr->Used.Ptr - DmaIoPtr->Used.Beg;
|
|
ASSERT (((i | Length) & (PAGE_SIZE-1)) == 0);
|
|
i >>= PAGE_SHIFT;
|
|
|
|
// Starting file offset (in pages)
|
|
FilePage = DmaIoPtr->FilePage[i];
|
|
|
|
// Increase counter while contiguous and used
|
|
if (HIBER_USE_DMA (HiberContext)) {
|
|
// If DMA is allowed write page-by-page
|
|
j = 1;
|
|
} else {
|
|
// Write as many pages as possible
|
|
j = 0;
|
|
do {
|
|
++j;
|
|
} while ((j != NoPages) &&
|
|
(DmaIoPtr->FilePage[i + j] == FilePage + j));
|
|
}
|
|
|
|
// Re-evaluate # of pages and length of block
|
|
Length = (NoPages = j) << PAGE_SHIFT;
|
|
|
|
// Start IO
|
|
PopWriteHiberPages (HiberContext, PageVa, NoPages, FilePage, &DmaIoPtr->HiberWritePagesLocals);
|
|
if (!NT_SUCCESS (HiberContext->Status)) {
|
|
return(FALSE);
|
|
}
|
|
|
|
// If pending then return immediately (even if need to complete)
|
|
if (DmaIoPtr->Busy.Size != 0) {
|
|
return(TRUE);
|
|
}
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
VOID
|
|
PopIOWrite (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PUCHAR Ptr,
|
|
IN LONG Bytes,
|
|
IN PFN_NUMBER FilePage
|
|
)
|
|
{
|
|
LONG i, Size;
|
|
|
|
// Do not bother if don't writing and/or was an error
|
|
if (!HiberContext->WriteToFile || !NT_SUCCESS(HiberContext->Status)) {
|
|
return;
|
|
}
|
|
|
|
ASSERT ((Bytes & (PAGE_SIZE-1)) == 0);
|
|
|
|
while (Bytes > 0) {
|
|
// Complete or Resume IO
|
|
do {
|
|
if (!PopIOResume (HiberContext, (BOOLEAN) (DmaIoPtr->Free.Size == 0))) {
|
|
return;
|
|
}
|
|
} while (DmaIoPtr->Free.Size == 0);
|
|
|
|
// Find how much can we write
|
|
Size = DmaIoPtr->Free.Size;
|
|
ASSERT ((Size & (PAGE_SIZE-1)) == 0);
|
|
if (Size > Bytes) {
|
|
Size = Bytes;
|
|
}
|
|
ASSERT (Size != 0);
|
|
// Copy and adjust pointers
|
|
|
|
HbCopy (HiberContext, DmaIoPtr->Free.Ptr, Ptr, Size);
|
|
|
|
Ptr += Size;
|
|
Bytes -= Size;
|
|
|
|
// Remember current page # index
|
|
i = (ULONG)(DmaIoPtr->Free.Ptr - DmaIoPtr->Free.Beg);
|
|
ASSERT ((i & (PAGE_SIZE-1)) == 0);
|
|
i >>= PAGE_SHIFT;
|
|
|
|
// Mark free memory as used
|
|
PopIORegionMove (&DmaIoPtr->Used, &DmaIoPtr->Free, Size);
|
|
|
|
// Remember FilePage for newly used pages
|
|
do {
|
|
DmaIoPtr->FilePage[i] = FilePage;
|
|
++i;
|
|
++FilePage;
|
|
} while ((Size -= PAGE_SIZE) != 0);
|
|
}
|
|
|
|
// Resume IO
|
|
PopIOResume (HiberContext, FALSE);
|
|
}
|
|
|
|
|
|
VOID
|
|
PopWriteHiberPages (
|
|
IN PPOP_HIBER_CONTEXT HiberContext,
|
|
IN PVOID ArgPageVa,
|
|
IN PFN_NUMBER ArgNoPages,
|
|
IN PFN_NUMBER ArgFilePage,
|
|
IN HIBER_WRITE_PAGES_LOCALS *Locals
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Routine to write pages into the hibernation file.
|
|
Caller must map pages to virtual addresses.
|
|
|
|
Arguments:
|
|
|
|
HiberContext - The hibernation context structure
|
|
|
|
PageVa - Virtual address of the first page to write
|
|
|
|
NoPage - Number of consective pages to write
|
|
|
|
FilePage - Page address in hiber file to write this
|
|
run of pages.
|
|
|
|
PendingIOStatus - If NULL then pass IO request to PopIOWrite,
|
|
otherwise it's call from PopIOResume for delayed
|
|
IO; used to return # of bytes written and pending
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
DUMP_MDL DumpMdl;
|
|
#define X(type,name) type name
|
|
HIBER_WRITE_PAGES_LOCALS_LIST (X)
|
|
#undef X
|
|
ULONGLONG StartCount, EndCount;
|
|
|
|
PhysBase = 0;
|
|
pa.QuadPart = 0;
|
|
|
|
//
|
|
// Copy arguments to local variables
|
|
//
|
|
PageVa = ArgPageVa;
|
|
NoPages = ArgNoPages;
|
|
FilePage = ArgFilePage;
|
|
|
|
//
|
|
// Allow debugger to break in when we are hibernating.
|
|
//
|
|
|
|
KdCheckForDebugBreak ();
|
|
|
|
//
|
|
// If a file isn't being written, then ignore
|
|
//
|
|
|
|
if (!HiberContext->WriteToFile) {
|
|
return ;
|
|
}
|
|
|
|
//
|
|
// If there's been some sort of error, don't bother
|
|
// writing anymore
|
|
//
|
|
|
|
if (!NT_SUCCESS(HiberContext->Status)) {
|
|
return ;
|
|
}
|
|
|
|
Mdl = (PMDL) DumpMdl;
|
|
if (Locals != NULL) {
|
|
// If we have async IO make sure that hand-made MDL will be
|
|
// stored in safe place preserved between resume calls
|
|
Mdl = (PMDL) Locals->DumpMdl;
|
|
|
|
if (DmaIoPtr->Busy.Size != 0) {
|
|
// There was pending IO -- resume execution from the point we stopped
|
|
#define X(type,name) name = Locals->name;
|
|
HIBER_WRITE_PAGES_LOCALS_LIST (X)
|
|
#undef X
|
|
goto ResumeIO;
|
|
}
|
|
|
|
// Mark current region as busy
|
|
ASSERT (PageVa == DmaIoPtr->Used.Ptr);
|
|
PopIORegionMove (&DmaIoPtr->Busy, &DmaIoPtr->Used, (ULONG)NoPages << PAGE_SHIFT);
|
|
} else if (HiberContext->DumpStack->Init.WritePendingRoutine != 0 &&
|
|
DmaIoPtr != NULL &&
|
|
DmaIoPtr->DumpLocalData != NULL) {
|
|
if (!DmaIoPtr->DmaInitialized) {
|
|
ULONGLONG xStartCount = HIBER_GET_TICK_COUNT(NULL);
|
|
Status = HiberContext->DumpStack->Init.WritePendingRoutine (IO_DUMP_WRITE_INIT,
|
|
NULL,
|
|
NULL,
|
|
DmaIoPtr->DumpLocalData);
|
|
HiberContext->PerfInfo.InitTicks += HIBER_GET_TICK_COUNT(NULL) - xStartCount;
|
|
if (Status != STATUS_SUCCESS) {
|
|
DmaIoPtr->UseDma = FALSE;
|
|
}
|
|
DmaIoPtr->DmaInitialized = TRUE;
|
|
DmaIoPtr->HiberWritePagesLocals.Status = STATUS_SUCCESS;
|
|
}
|
|
|
|
PopIOWrite (HiberContext, PageVa, (ULONG)NoPages << PAGE_SHIFT, FilePage);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Page count must be below 4GB byte length
|
|
//
|
|
|
|
if (NoPages > ((((ULONG_PTR) -1) << PAGE_SHIFT) >> PAGE_SHIFT)) {
|
|
PopInternalError (POP_HIBER);
|
|
}
|
|
|
|
//
|
|
// Loop while there's data to be written
|
|
//
|
|
|
|
CMcb = (PPOP_MCB_CONTEXT) HiberContext->CurrentMcb;
|
|
MdlPage = MmGetMdlPfnArray( Mdl );
|
|
|
|
FileBase = (ULONGLONG) FilePage << PAGE_SHIFT;
|
|
Length = NoPages << PAGE_SHIFT;
|
|
|
|
while (Length != 0) {
|
|
|
|
//
|
|
// If this IO is outside the current Mcb locate the
|
|
// proper Mcb
|
|
//
|
|
|
|
if (FileBase < CMcb->Base || FileBase >= CMcb->Base + CMcb->Mcb[0].QuadPart) {
|
|
|
|
//
|
|
// If io is before this mcb, search from the begining
|
|
//
|
|
|
|
if (FileBase < CMcb->Base) {
|
|
CMcb->Mcb = CMcb->FirstMcb;
|
|
CMcb->Base = 0;
|
|
}
|
|
|
|
//
|
|
// Find the Mcb which covers the start of the io and
|
|
// make it the current mcb
|
|
//
|
|
|
|
while (FileBase >= CMcb->Base + CMcb->Mcb[0].QuadPart) {
|
|
CMcb->Base += CMcb->Mcb[0].QuadPart;
|
|
CMcb->Mcb += 2;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Determine physical IoLocation and IoLength to write.
|
|
//
|
|
|
|
McbOffset = FileBase - CMcb->Base;
|
|
IoLocation.QuadPart = CMcb->Mcb[1].QuadPart + McbOffset;
|
|
|
|
//
|
|
// If the IoLength is beyond the Mcb, limit it to the Mcb
|
|
//
|
|
|
|
if (McbOffset + Length > (ULONGLONG) CMcb->Mcb[0].QuadPart) {
|
|
IoLength = (ULONG) (CMcb->Mcb[0].QuadPart - McbOffset);
|
|
} else {
|
|
IoLength = (ULONG) Length;
|
|
}
|
|
|
|
//
|
|
// If the IoLength is more pages then the largest Mdl size
|
|
// then shrink it
|
|
//
|
|
|
|
NoPages = ADDRESS_AND_SIZE_TO_SPAN_PAGES (PageVa, IoLength);
|
|
if (NoPages > IO_DUMP_MAX_MDL_PAGES) {
|
|
IoLength -= (ULONG)((NoPages - IO_DUMP_MAX_MDL_PAGES) << PAGE_SHIFT);
|
|
NoPages = IO_DUMP_MAX_MDL_PAGES;
|
|
}
|
|
|
|
//
|
|
// Debugging only
|
|
// Make sure that we may handle non-page aligned IO
|
|
// (simulate fragmented hiberfil.sys)
|
|
//
|
|
// if (IoLength > 512) IoLength = 512;
|
|
//
|
|
|
|
if (HIBER_USE_DMA (HiberContext)) {
|
|
ULONG Size;
|
|
|
|
// Do not write accross page boundaries
|
|
// to avoid memory allocation that HAL may do;
|
|
// Because of MCB's partial IOs may be smaller than one page
|
|
|
|
Size = PAGE_SIZE - (ULONG)((ULONG_PTR)PageVa & (PAGE_SIZE - 1));
|
|
if (IoLength > Size) {
|
|
IoLength = Size;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Build the Mdl for the Io
|
|
//
|
|
|
|
MmInitializeMdl(Mdl, PageVa, IoLength);
|
|
Mdl->MappedSystemVa = PageVa;
|
|
Mdl->MdlFlags |= MDL_MAPPED_TO_SYSTEM_VA;
|
|
for (i=0; i < NoPages; i++) {
|
|
pa = MmGetPhysicalAddress((PVOID) (((ULONG_PTR)PageVa) + (i << PAGE_SHIFT)));
|
|
MdlPage[i] = (PFN_NUMBER) (pa.QuadPart >> PAGE_SHIFT);
|
|
}
|
|
|
|
//
|
|
// Write the data
|
|
//
|
|
|
|
StartCount = HIBER_GET_TICK_COUNT(NULL);
|
|
|
|
if (Locals != NULL && HIBER_USE_DMA (HiberContext)) {
|
|
Status = HiberContext->DumpStack->Init.WritePendingRoutine (IO_DUMP_WRITE_START,
|
|
&IoLocation,
|
|
Mdl,
|
|
DmaIoPtr->DumpLocalData);
|
|
|
|
if (Status != STATUS_PENDING && !NT_SUCCESS (Status)) {
|
|
DBGOUT (("WriteDMA returned bad status 0x%x -- will use PIO\n", Status));
|
|
DmaIoPtr->UseDma = FALSE;
|
|
goto RetryWithPIO;
|
|
}
|
|
} else {
|
|
RetryWithPIO:
|
|
Status = HiberContext->DumpStack->Init.WriteRoutine (&IoLocation, Mdl);
|
|
}
|
|
|
|
EndCount = HIBER_GET_TICK_COUNT(NULL);
|
|
HiberContext->PerfInfo.IoTicks += EndCount - StartCount;
|
|
|
|
//
|
|
// Keep track of the number of pages written, and dump device calls
|
|
// made for performance metric reasons
|
|
//
|
|
|
|
HiberContext->PerfInfo.PagesWritten += (ULONG)NoPages;
|
|
HiberContext->PerfInfo.DumpCount += 1;
|
|
|
|
//
|
|
// Io complete or will be complete
|
|
//
|
|
|
|
Length -= IoLength;
|
|
FileBase += IoLength;
|
|
PageVa = (PVOID) (((PUCHAR) PageVa) + IoLength);
|
|
|
|
// Check status
|
|
if (Locals != NULL) {
|
|
if (Status == STATUS_PENDING) {
|
|
#define X(type,name) Locals->name = name
|
|
HIBER_WRITE_PAGES_LOCALS_LIST (X)
|
|
#undef X
|
|
return;
|
|
ResumeIO:
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
}
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
HiberContext->Status = Status;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (Locals != NULL) {
|
|
// Completed IO request -- mark region as free
|
|
ASSERT (PageVa == DmaIoPtr->Busy.Ptr + DmaIoPtr->Busy.Size);
|
|
PopIORegionMove (&DmaIoPtr->Free, &DmaIoPtr->Busy, DmaIoPtr->Busy.Size);
|
|
}
|
|
}
|
|
|
|
|
|
UCHAR
|
|
PopGetHiberFlags(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Determines any hibernation flags which need to be written
|
|
into the hiber image and made visible to the osloader at
|
|
resume time
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
UCHAR containing hibernation flags. Currently defined flags:
|
|
PO_HIBER_APM_RECONNECT
|
|
|
|
--*/
|
|
|
|
{
|
|
UCHAR Flags=0;
|
|
#if defined(i386)
|
|
PULONG ApmActive;
|
|
NTSTATUS Status;
|
|
UCHAR ValueBuff[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG)];
|
|
PKEY_VALUE_PARTIAL_INFORMATION ValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuff;
|
|
ULONG ResultLength;
|
|
HANDLE ApmActiveKey;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
UNICODE_STRING Name;
|
|
#endif
|
|
|
|
PAGED_CODE();
|
|
|
|
#if defined(i386)
|
|
//
|
|
// Open the APM active key to determine if APM is running.
|
|
//
|
|
RtlInitUnicodeString(&Name, PopApmActiveFlag);
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&Name,
|
|
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
|
|
NULL,
|
|
NULL);
|
|
Status = ZwOpenKey(&ApmActiveKey,
|
|
KEY_READ,
|
|
&ObjectAttributes);
|
|
if (NT_SUCCESS(Status)) {
|
|
|
|
//
|
|
// Query the Active value. A value of 1 indicates that APM is running.
|
|
//
|
|
RtlInitUnicodeString(&Name, PopApmFlag);
|
|
Status = ZwQueryValueKey(ApmActiveKey,
|
|
&Name,
|
|
KeyValuePartialInformation,
|
|
ValueInfo,
|
|
sizeof(ValueBuff),
|
|
&ResultLength);
|
|
ZwClose(ApmActiveKey);
|
|
if (NT_SUCCESS(Status) && (ValueInfo->Type == REG_DWORD)) {
|
|
ApmActive = (PULONG)&ValueInfo->Data;
|
|
if (*ApmActive == 1) {
|
|
Flags |= PO_HIBER_APM_RECONNECT;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(i386) || defined(_AMD64_)
|
|
|
|
//
|
|
// Remember if no-execute is enabled
|
|
//
|
|
|
|
if (MmPaeMask & 0x8000000000000000UI64) {
|
|
Flags |= PO_HIBER_NO_EXECUTE;
|
|
}
|
|
|
|
#endif
|
|
|
|
return(Flags);
|
|
}
|
|
|
|
|
|
PMDL
|
|
PopSplitMdl(
|
|
IN PMDL Original,
|
|
IN ULONG SplitPages
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Splits a new MDL of length SplitPages out from the original MDL.
|
|
This is needed so that when we have an enormous MDL of spare pages
|
|
we do not have to map the whole thing, just the part we need.
|
|
|
|
Arguments:
|
|
|
|
Original - supplies the original MDL. The length of this MDL will
|
|
be decreated by SplitPages
|
|
|
|
SplitPages - supplies the length (in pages) of the new MDL.
|
|
|
|
Return Value:
|
|
|
|
pointer to newly allocated MDL
|
|
NULL if a new MDL could not be allocated
|
|
|
|
--*/
|
|
|
|
{
|
|
PMDL NewMdl;
|
|
ULONG Length;
|
|
PPFN_NUMBER SourcePages;
|
|
PPFN_NUMBER DestPages;
|
|
|
|
Length = SplitPages << PAGE_SHIFT;
|
|
|
|
NewMdl = ExAllocatePoolWithTag(NonPagedPool,
|
|
MmSizeOfMdl(NULL, Length),
|
|
POP_HMAP_TAG);
|
|
if (NewMdl == NULL) {
|
|
return(NULL);
|
|
}
|
|
MmInitializeMdl(NewMdl, NULL, Length);
|
|
DestPages = (PPFN_NUMBER)(NewMdl + 1);
|
|
SourcePages = (PPFN_NUMBER)(Original + 1) + BYTES_TO_PAGES(Original->ByteCount) - SplitPages;
|
|
RtlCopyMemory(DestPages, SourcePages, SplitPages * sizeof(PFN_NUMBER));
|
|
Original->ByteCount = Original->ByteCount - Length;
|
|
|
|
return(NewMdl);
|
|
}
|
|
|
|
|
|
PSECURITY_DESCRIPTOR
|
|
PopCreateHiberFileSecurityDescriptor(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine allocates and initializes the default security descriptor
|
|
for the hiber file.
|
|
|
|
The caller is responsible for freeing the allocated security descriptor
|
|
when he is done with it.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
Pointer to an initialized security descriptor if successful.
|
|
|
|
A null pointer otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status;
|
|
PSECURITY_DESCRIPTOR SecurityDescriptor=NULL;
|
|
PACL Acl=NULL;
|
|
PACL AclCopy=NULL;
|
|
PSID WorldSid=NULL;
|
|
SID_IDENTIFIER_AUTHORITY WorldAuthority = SECURITY_WORLD_SID_AUTHORITY;
|
|
ULONG AceLength;
|
|
ULONG AclLength;
|
|
PACE_HEADER AceHeader;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Allocate and initialize the SIDs we will need.
|
|
//
|
|
WorldSid = ExAllocatePoolWithTag(PagedPool, RtlLengthRequiredSid(1), POP_HIBR_TAG);
|
|
if (WorldSid == NULL) {
|
|
goto Done;
|
|
}
|
|
|
|
if ((!NT_SUCCESS(RtlInitializeSid(WorldSid, &WorldAuthority, 1)))) {
|
|
goto Done;
|
|
}
|
|
|
|
*(RtlSubAuthoritySid(WorldSid, 0)) = SECURITY_WORLD_RID;
|
|
|
|
ASSERT(RtlValidSid(WorldSid));
|
|
|
|
//
|
|
// Compute the size of the ACE list
|
|
//
|
|
AceLength = (SeLengthSid(WorldSid) -
|
|
sizeof(ULONG) +
|
|
sizeof(ACCESS_ALLOWED_ACE));
|
|
//
|
|
// Allocate and initialize the ACL
|
|
//
|
|
AclLength = AceLength + sizeof(ACL);
|
|
Acl = ExAllocatePoolWithTag(PagedPool, AclLength, POP_HIBR_TAG);
|
|
if (Acl == NULL) {
|
|
DbgPrint("PopCreateHiberFileSecurityDescriptor: couldn't allocate ACL\n");
|
|
goto Done;
|
|
}
|
|
|
|
Status = RtlCreateAcl(Acl, AclLength, ACL_REVISION);
|
|
if (!NT_SUCCESS(Status)) {
|
|
DbgPrint("PopCreateHiberFileSecurityDescriptor: couldn't initialize ACL\n");
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Now add the ACEs to the ACL
|
|
//
|
|
Status = RtlAddAccessAllowedAce(Acl,
|
|
ACL_REVISION,
|
|
DELETE,
|
|
WorldSid);
|
|
if (!NT_SUCCESS(Status)) {
|
|
DbgPrint("PopCreateHiberFileSecurityDescriptor: RtlAddAce failed status %08lx\n", Status);
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Make the ACEs inheritable
|
|
//
|
|
Status = RtlGetAce(Acl,0,&AceHeader);
|
|
ASSERT(NT_SUCCESS(Status));
|
|
AceHeader->AceFlags |= CONTAINER_INHERIT_ACE;
|
|
|
|
//
|
|
// We are finally ready to allocate and initialize the security descriptor
|
|
// Allocate enough space to hold both the security descriptor and the
|
|
// ACL. This allows us to free the whole thing at once when we are
|
|
// done with it.
|
|
//
|
|
SecurityDescriptor = ExAllocatePoolWithTag(
|
|
PagedPool,
|
|
sizeof(SECURITY_DESCRIPTOR) + AclLength,
|
|
POP_HIBR_TAG
|
|
);
|
|
|
|
if (SecurityDescriptor == NULL) {
|
|
DbgPrint("PopCreateHiberFileSecurityDescriptor: Couldn't allocate Sec. Desc.\n");
|
|
goto Done;
|
|
}
|
|
|
|
AclCopy = (PACL)((PISECURITY_DESCRIPTOR)SecurityDescriptor+1);
|
|
RtlCopyMemory(AclCopy, Acl, AclLength);
|
|
|
|
Status = RtlCreateSecurityDescriptor( SecurityDescriptor,
|
|
SECURITY_DESCRIPTOR_REVISION );
|
|
if (!NT_SUCCESS(Status)) {
|
|
DbgPrint("PopCreateHiberFileSecurityDescriptor: CreateSecDesc failed %08lx\n",Status);
|
|
ExFreePool(SecurityDescriptor);
|
|
goto Done;
|
|
}
|
|
|
|
Status = RtlSetDaclSecurityDescriptor( SecurityDescriptor,
|
|
TRUE,
|
|
AclCopy,
|
|
FALSE );
|
|
if (!NT_SUCCESS(Status)) {
|
|
DbgPrint("PopCreateHiberFileSecurityDescriptor: SetDacl failed %08lx\n",Status);
|
|
ExFreePool(SecurityDescriptor);
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// free any allocations we made
|
|
//
|
|
Done:
|
|
if (WorldSid!=NULL) {
|
|
ExFreePool(WorldSid);
|
|
}
|
|
if (Acl!=NULL) {
|
|
ExFreePool(Acl);
|
|
}
|
|
|
|
return(SecurityDescriptor);
|
|
}
|