/*++ 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 ); 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; // // recompute the policies and make the proper notification // PopResetCurrentPolicies (); PopSetNotificationWork (PO_NOTIFY_CAPABILITIES); Status = STATUS_SUCCESS; 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)) { goto Done; } IoFreeDumpStack (DumpStack); PopHeuristics.GetDumpStackVerified = TRUE; } // // Create the hiberfile file // Status = PopCreateHiberFile (&PopHiberFile, (PWCHAR)PopHiberFileName, &FileSize, FALSE); if (!NT_SUCCESS(Status)) { 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; PUCHAR Bitmap; LARGE_INTEGER ByteOffset; KEVENT Event; PMDL Mdl; 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); InitializeObjectAttributes(&ObjectAttributes, &HiberFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL); 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_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 (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 = strlen (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); MmBuildMdlForNonPagedPool (Mdl); if (GetStats) { Status = IoPageRead(PopHiberFile.FileObject, Mdl, &ByteOffset, &Event, &IoStatus); 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); if (NT_SUCCESS(Status)) { RtlInitUnicodeString(&UnicodeString, L"HiberElapsedTime"); Data = MemImage->PerfInfo.ElapsedTime; ZwSetValueKey(Handle, &UnicodeString, 0, REG_DWORD, &Data, sizeof(Data)); RtlInitUnicodeString(&UnicodeString, L"HiberIoTime"); Data = MemImage->PerfInfo.IoTime; ZwSetValueKey(Handle, &UnicodeString, 0, REG_DWORD, &Data, sizeof(Data)); RtlInitUnicodeString(&UnicodeString, L"HiberCopyTime"); Data = MemImage->PerfInfo.CopyTime; ZwSetValueKey(Handle, &UnicodeString, 0, REG_DWORD, &Data, sizeof(Data)); RtlInitUnicodeString(&UnicodeString, L"HiberCopyBytes"); Data = MemImage->PerfInfo.BytesCopied; ZwSetValueKey(Handle, &UnicodeString, 0, REG_DWORD, &Data, sizeof(Data)); RtlInitUnicodeString(&UnicodeString, L"HiberPagesWritten"); Data = MemImage->PerfInfo.PagesWritten; ZwSetValueKey(Handle, &UnicodeString, 0, REG_DWORD, &Data, sizeof(Data)); RtlInitUnicodeString(&UnicodeString, L"HiberPagesProcessed"); Data = MemImage->PerfInfo.PagesProcessed; ZwSetValueKey(Handle, &UnicodeString, 0, REG_DWORD, &Data, sizeof(Data)); RtlInitUnicodeString(&UnicodeString, L"HiberDumpCount"); Data = MemImage->PerfInfo.DumpCount; ZwSetValueKey(Handle, &UnicodeString, 0, REG_DWORD, &Data, sizeof(Data)); RtlInitUnicodeString(&UnicodeString, L"HiberFileRuns"); Data = MemImage->PerfInfo.FileRuns; ZwSetValueKey(Handle, &UnicodeString, 0, REG_DWORD, &Data, sizeof(Data)); 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, j, k; PLIST_ENTRY NextEntry; PDUMP_INITIALIZATION_CONTEXT DumpInit; PFN_NUMBER NoPages; PFN_NUMBER Length; PLIST_ENTRY Link; PPOP_MEMORY_RANGE Range; ULONG result; PHYSICAL_ADDRESS pa; NTSTATUS Status; PVOID p1; PULONG BitmapBuffer; // Compression Related ULONG CompressionWorkspaceSize, Unused; 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 DmaIoPtr = 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 DmaIoPtr = (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; PLIST_ENTRY Link; PMDL Mdl; 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); 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; ULONG NewFlags; 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 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 result; ULONG SpareCount; 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; 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 ((NoPages << PAGE_SHIFT) > PO_MAX_MAPPED_CLONES) { SpareCount = (ULONG) (NoPages << PAGE_SHIFT); } else { SpareCount = PO_MAX_MAPPED_CLONES; } Mdl = HiberContext->Spares; 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) { break; } } else { // // Map the entire spare MDL // HiberContext->Spares = Mdl->Next; } Mdl->MdlFlags |= MDL_MAPPING_CAN_FAIL; HiberContext->NextClone = MmMapLockedPages (Mdl, KernelMode); if (HiberContext->NextClone == NULL) { // // 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 { // // No spares, allocate more // result = PopGatherMemoryForHibernate (HiberContext, NoPages*2, &HiberContext->Spares, TRUE); if (!result) { break; } } } // // If there's a failure, mark it now // if (!Buffer && NT_SUCCESS(HiberContext->Status)) { HiberContext->Status = STATUS_INSUFFICIENT_RESOURCES; } 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 --*/ { PHYSICAL_ADDRESS PhysAddr; PFN_NUMBER sp, ep, PageLen; 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 ("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; PMDL Mdl; PPO_MEMORY_RANGE_ARRAY Table; ULONG TablePages; ULONG NeededPages; ULONG NoPages, i; ULONG result; // // 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; iTableHead; 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; ULONG i; ULONGLONG StartCount; // Compression related ULONG CompressedSize; // // 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) { // // If the debugger was active, reset it // if (KdDebuggerEnabled && !KdPitchDebugger) { KdDebuggerEnabled = FALSE; KdInitSystem (0, NULL); } // // 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; PPOP_MEMORY_RANGE Range; 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; NTSTATUS Status; 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 ); memcpy (IoPage, cp, MmHiberPages * sizeof(PFN_NUMBER)); 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 // if (KdDebuggerEnabled && !KdPitchDebugger && !(PopSimulate & POP_IGNORE_HIBER_SYMBOL_UNLOAD)) { KdDeleteAllBreakpoints(); } // // 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); KeBugCheckEx(INTERNAL_POWER_ERROR, 5, MemImage->WakeCheck, PoWakeCheck, __LINE__); } // // 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 // 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(); } if (PopSimulate & POP_ENABLE_HIBER_PERF) { PopDumpStatistics(&HiberContext->PerfInfo); } // // Failed to write the hiberfile. // if ( !NT_SUCCESS(HiberContext->Status) || (PopSimulate & POP_FORCE_HIBERNATE_FAILURE) ) { #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, 0x108, POP_HIBER, (ULONG_PTR)HiberContext, 0 ); #else return( (NT_SUCCESS(HiberContext->Status) && (PopSimulate & POP_FORCE_HIBERNATE_FAILURE)) ? STATUS_UNSUCCESSFUL : (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 ) { UCHAR Buffer[200]; if (InbvIsBootDriverInstalled()) { InbvUpdateProgressBar(Percent + 1); } else { sprintf (Buffer, "PopSave: %d%%\r", Percent); PoPrint (PO_HIBER_MAP, ("%s", Buffer)); if (HiberContext->WriteToFile) { InbvDisplayString (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; 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; ULONGLONG StartCount; // 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; // // 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 StartCount = 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) - StartCount; 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; HANDLE ApmActiveKey; OBJECT_ATTRIBUTES ObjectAttributes; UNICODE_STRING Name; NTSTATUS Status; PULONG ApmActive; UCHAR ValueBuff[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG)]; ULONG ResultLength; PKEY_VALUE_PARTIAL_INFORMATION ValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuff; 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 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 -= (SplitPages << PAGE_SIZE); return(NewMdl); }