/*
- * Copyright (c) 2004-2006 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2004-2008 Apple Computer, Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
static IODTNVRAM * gIOOptionsEntry;
static IORegistryEntry * gIOChosenEntry;
-#ifdef __i386__
+#if defined(__i386__) || defined(__x86_64__)
static const OSSymbol * gIOCreateEFIDevicePathSymbol;
#endif
addr64_t dstAddr64;
IOByteCount dstLen;
- dstAddr64 = md->getPhysicalSegment64(offset, &dstLen);
+ dstAddr64 = md->getPhysicalSegment(offset, &dstLen, kIOMemoryMapperNone);
if (!dstAddr64)
break;
addr64_t srcAddr64;
IOByteCount dstLen;
- srcAddr64 = md->getPhysicalSegment64(offset, &dstLen);
+ srcAddr64 = md->getPhysicalSegment(offset, &dstLen, kIOMemoryMapperNone);
if (!srcAddr64)
break;
err = kIOReturnNoSpace;
break;
}
+ gIOHibernateFileRef = vars->fileRef;
HIBLOG("Opened file %s, size %qd, partition base 0x%qx, maxio %qx\n", filename, ctx.size,
vars->block0, maxiobytes);
if (ctx.size < 1*1024*1024) // check against image size estimate!
&& child->isParent(next, gIOServicePlane, true));
HIBLOG("hibernate image major %d, minor %d, blocksize %ld, pollers %d\n",
- major, minor, vars->blockSize, vars->pollers->getCount());
+ major, minor, (long)vars->blockSize, vars->pollers->getCount());
if (vars->pollers->getCount() < kIOHibernateMinPollersNeeded)
continue;
{
char str2[24];
-#if __i386__
+#if defined(__i386__) || defined(__x86_64__)
if (!gIOCreateEFIDevicePathSymbol)
gIOCreateEFIDevicePathSymbol = OSSymbol::withCString("CreateEFIDevicePath");
{
HIBLOG("error 0x%x opening hibernation file\n", err);
if (vars->fileRef)
+ {
kern_close_file_for_direct_io(vars->fileRef);
+ gIOHibernateFileRef = vars->fileRef = NULL;
+ }
}
if (part)
vars->pollers->release();
}
- gIOHibernateFileRef = vars->fileRef;
-
bzero(vars, sizeof(IOPolledFileIOVars));
return (kIOReturnSuccess);
}
}
- if (vars->extentRemaining <= vars->bufferSize)
- vars->lastRead = vars->extentRemaining;
- else
- vars->lastRead = vars->bufferSize;
-
+ uint64_t length;
+ uint64_t lastReadLength = vars->lastRead;
uint64_t offset = (vars->position
- vars->extentPosition + vars->currentExtent->start);
- uint64_t length = (vars->lastRead);
+ if (vars->extentRemaining <= vars->bufferSize)
+ length = vars->extentRemaining;
+ else
+ length = vars->bufferSize;
+ vars->lastRead = length;
//if (length != vars->bufferSize) HIBLOG("short read of %qx ends@ %qx\n", length, offset + length);
uint8_t thisVector[AES_BLOCK_SIZE];
// save initial vector for following decrypts
bcopy(&cryptvars->aes_iv[0], &thisVector[0], AES_BLOCK_SIZE);
- bcopy(vars->buffer + vars->bufferHalf + vars->lastRead - AES_BLOCK_SIZE,
+ bcopy(vars->buffer + vars->bufferHalf + lastReadLength - AES_BLOCK_SIZE,
&cryptvars->aes_iv[0], AES_BLOCK_SIZE);
// decrypt the buffer
aes_decrypt_cbc(vars->buffer + vars->bufferHalf,
&thisVector[0],
- vars->lastRead / AES_BLOCK_SIZE,
+ lastReadLength / AES_BLOCK_SIZE,
vars->buffer + vars->bufferHalf,
&cryptvars->ctx.decrypt);
}
-#endif CRYPTO
+#endif /* CRYPTO */
}
}
while (size);
gIOHibernateState = kIOHibernateStateInactive;
+ gIOHibernateDebugFlags = 0;
+ if (kIOLogHibernate & gIOKitDebug)
+ gIOHibernateDebugFlags |= kIOHibernateDebugRestoreLogs;
+
/* The invocation of IOPMSleepSystemWithOptions() may override
* existing hibernation settings.
*/
}
bzero(gIOHibernateCurrentHeader, sizeof(IOHibernateImageHeader));
+ gIOHibernateCurrentHeader->debugFlags = gIOHibernateDebugFlags;
boolean_t encryptedswap;
err = hibernate_setup(gIOHibernateCurrentHeader,
}
data->release();
-#ifdef __ppc__
+#if defined(__ppc__)
size_t len;
char valueString[16];
{
vars->haveFastBoot = true;
- len = sprintf(valueString, "0x%lx", *((UInt32 *)data->getBytesNoCopy()));
+ len = snprintf(valueString, sizeof(valueString), "0x%lx", *((UInt32 *)data->getBytesNoCopy()));
data = OSData::withBytes(valueString, len + 1);
sym = OSSymbol::withCStringNoCopy(kIOHibernateMemorySignatureEnvKey);
if (sym && data)
gIOHibernateCurrentHeader->machineSignature = *((UInt32 *)data->getBytesNoCopy());
}
#endif /* __ppc__ */
-#ifdef __i386__
+#if defined(__i386__) || defined(__x86_64__)
struct AppleRTCHibernateVars
{
uint8_t signature[4];
if (data)
gIOHibernateCurrentHeader->machineSignature = *((UInt32 *)data->getBytesNoCopy());
}
-#else /* !__i386__ */
+#else /* !i386 && !x86_64 */
if (kIOHibernateModeEncrypt & gIOHibernateMode)
{
data = OSData::withBytes(&vars->wiredCryptKey[0], sizeof(vars->wiredCryptKey));
&newVolume, sizeof(newVolume));
}
}
-#endif /* !__i386__ */
+#endif /* !i386 && !x86_64 */
}
// --
IOService::getPMRootDomain()->getProperty(kIOHibernatePreviewActiveKey))))
{
UInt32 flags = *((UInt32 *)data->getBytesNoCopy());
- HIBPRINT("kIOHibernatePreviewActiveKey %08lx\n", flags);
+ HIBPRINT("kIOHibernatePreviewActiveKey %08lx\n", (long)flags);
IOService::getPMRootDomain()->removeProperty(kIOHibernatePreviewActiveKey);
IOUnmapPages(kernel_map, vars->videoMapping, vars->videoMapSize);
if (vars->videoAllocSize)
// dealloc range
- kmem_free(kernel_map, trunc_page_32(vars->videoMapping), vars->videoAllocSize);
+ kmem_free(kernel_map, trunc_page(vars->videoMapping), vars->videoAllocSize);
}
if (vars->previewBuffer)
}
#endif
-#ifdef __i386__
+#if defined(__i386__) || defined(__x86_64__)
IOService::getPMRootDomain()->removeProperty(kIOHibernateRTCVariablesKey);
/*
const OSSymbol * sym = OSSymbol::withCStringNoCopy(kIOHibernateRTCVariablesKey);
if (sym) {
- gIOOptionsEntry->removeProperty(sym);
+ if (gIOOptionsEntry->getProperty(sym)) {
+ gIOOptionsEntry->removeProperty(sym);
+ gIOOptionsEntry->sync();
+ }
sym->release();
}
}
AbsoluteTime_to_scalar(&decoTime) = 0;
clock_get_uptime(&allTime);
+ IOService::getPMRootDomain()->pmStatsRecordEvent(
+ kIOPMStatsHibernateImageWrite | kIOPMStatsEventStartFlag, allTime);
do
{
break;
}
+ uintptr_t hibernateBase;
+ uintptr_t hibernateEnd;
+
+#if defined(__i386__) || defined(__x86_64__)
+ hibernateBase = sectINITPTB;
+#else
+ hibernateBase = sectHIBB;
+#endif
+
+ hibernateEnd = (sectHIBB + sectSizeHIB);
// copy out restore1 code
- page = atop_32(sectHIBB);
- count = atop_32(round_page(sectHIBB + sectSizeHIB)) - page;
+ page = atop_32(hibernateBase);
+ count = atop_32(round_page(hibernateEnd)) - page;
header->restore1CodePage = page;
header->restore1PageCount = count;
- header->restore1CodeOffset = ((uint32_t) &hibernate_machine_entrypoint) - sectHIBB;
- header->restore1StackOffset = ((uint32_t) &gIOHibernateRestoreStackEnd[0]) - 64 - sectHIBB;
+ header->restore1CodeOffset = ((uintptr_t) &hibernate_machine_entrypoint) - hibernateBase;
+ header->restore1StackOffset = ((uintptr_t) &gIOHibernateRestoreStackEnd[0]) - 64 - hibernateBase;
// sum __HIB sect, with zeros for the stack
- src = (uint8_t *) trunc_page(sectHIBB);
+ src = (uint8_t *) trunc_page(hibernateBase);
for (page = 0; page < count; page++)
{
if ((src < &gIOHibernateRestoreStack[0]) || (src >= &gIOHibernateRestoreStackEnd[0]))
// write the __HIB sect, with zeros for the stack
- src = (uint8_t *) trunc_page(sectHIBB);
- count = ((uint32_t) &gIOHibernateRestoreStack[0]) - trunc_page(sectHIBB);
+ src = (uint8_t *) trunc_page(hibernateBase);
+ count = ((uintptr_t) &gIOHibernateRestoreStack[0]) - trunc_page(hibernateBase);
if (count)
{
err = IOPolledFileWrite(vars->fileVars, src, count, cryptvars);
if (kIOReturnSuccess != err)
break;
src = &gIOHibernateRestoreStackEnd[0];
- count = round_page(sectHIBB + sectSizeHIB) - ((uint32_t) src);
+ count = round_page(hibernateEnd) - ((uintptr_t) src);
if (count)
{
err = IOPolledFileWrite(vars->fileVars, src, count, cryptvars);
count = 0;
do
{
- phys64 = vars->previewBuffer->getPhysicalSegment64(count, &segLen);
+ phys64 = vars->previewBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone);
pageAndCount[0] = atop_64(phys64);
pageAndCount[1] = atop_32(segLen);
err = IOPolledFileWrite(vars->fileVars,
if (kIOReturnSuccess != err)
break;
- src = (uint8_t *) vars->previewBuffer->getSourceSegment(0, NULL);
+ src = (uint8_t *) vars->previewBuffer->getPhysicalSegment(0, NULL, _kIOMemorySourceSegment);
count = vars->previewBuffer->getLength();
header->previewPageListSize = ppnum;
// mark areas for no save
for (count = 0;
- (phys64 = vars->ioBuffer->getPhysicalSegment64(count, &segLen));
+ (phys64 = vars->ioBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
count += segLen)
{
hibernate_set_page_state(vars->page_list, vars->page_list_wired,
}
for (count = 0;
- (phys64 = vars->srcBuffer->getPhysicalSegment64(count, &segLen));
+ (phys64 = vars->srcBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
count += segLen)
{
hibernate_set_page_state(vars->page_list, vars->page_list_wired,
hibernate_page_list_set_volatile(vars->page_list, vars->page_list_wired, &pageCount);
- page = atop_32(sectHIBB);
- count = atop_32(round_page(sectHIBB + sectSizeHIB)) - page;
+ page = atop_32(hibernateBase);
+ count = atop_32(round_page(hibernateEnd)) - page;
hibernate_set_page_state(vars->page_list, vars->page_list_wired,
page, count,
kIOHibernatePageStateFree);
pageCount -= count;
if (vars->previewBuffer) for (count = 0;
- (phys64 = vars->previewBuffer->getPhysicalSegment64(count, &segLen));
+ (phys64 = vars->previewBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
count += segLen)
{
hibernate_set_page_state(vars->page_list, vars->page_list_wired,
err = IOMemoryDescriptorWriteFromPhysical(vars->srcBuffer, 0, ptoa_64(ppnum), page_size);
if (err)
{
- HIBLOG("IOMemoryDescriptorWriteFromPhysical %d [%d] %x\n", __LINE__, ppnum, err);
+ HIBLOG("IOMemoryDescriptorWriteFromPhysical %d [%ld] %x\n", __LINE__, (long)ppnum, err);
break;
}
while (false);
clock_get_uptime(&endTime);
+
+ IOService::getPMRootDomain()->pmStatsRecordEvent(
+ kIOPMStatsHibernateImageWrite | kIOPMStatsEventStopFlag, endTime);
+
SUB_ABSOLUTETIME(&endTime, &allTime);
absolutetime_to_nanoseconds(endTime, &nsec);
HIBLOG("all time: %qd ms, ",
uncompressedSize ? ((int) ((compressedSize * 100ULL) / uncompressedSize)) : 0,
sum1, sum2);
+ if (vars->fileVars->io)
+ (void) IOHibernatePollerIODone(vars->fileVars, false);
+
if (pollerOpen)
IOHibernatePollerClose(vars->fileVars, kIOPolledBeforeSleepState);
uint32_t tag;
vm_offset_t ppnum, compressedSize;
- IOPolledFileRead(vars->fileVars, src, 8, cryptvars);
+ err = IOPolledFileRead(vars->fileVars, src, 8, cryptvars);
+ if (kIOReturnSuccess != err)
+ break;
ppnum = header[0];
count = header[1];
for (page = 0; page < count; page++)
{
- IOPolledFileRead(vars->fileVars, (uint8_t *) &tag, 4, cryptvars);
+ err = IOPolledFileRead(vars->fileVars, (uint8_t *) &tag, 4, cryptvars);
+ if (kIOReturnSuccess != err)
+ break;
compressedSize = kIOHibernateTagLength & tag;
+ if (kIOHibernateTagSignature != (tag & ~kIOHibernateTagLength))
+ {
+ err = kIOReturnIPCError;
+ break;
+ }
+
if (!compressedSize)
{
ppnum++;
continue;
}
- IOPolledFileRead(vars->fileVars, src, (compressedSize + 3) & ~3, cryptvars);
-
- if (compressedSize != page_size)
+ err = IOPolledFileRead(vars->fileVars, src, (compressedSize + 3) & ~3, cryptvars);
+ if (kIOReturnSuccess != err)
+ break;
+
+ if (compressedSize < page_size)
{
decoOffset = page_size;
WKdm_decompress((WK_word*) src, (WK_word*) (src + decoOffset), PAGE_SIZE_IN_WORDS);
err = IOMemoryDescriptorReadToPhysical(vars->srcBuffer, decoOffset, ptoa_64(ppnum), page_size);
if (err)
- HIBLOG("IOMemoryDescriptorReadToPhysical [%d] %x\n", ppnum, err);
+ {
+ HIBLOG("IOMemoryDescriptorReadToPhysical [%ld] %x\n", (long)ppnum, err);
+ break;
+ }
ppnum++;
pagesDone++;
}
while (true);
+ if (kIOReturnSuccess != err)
+ panic("Hibernate restore error %x", err);
+
gIOHibernateCurrentHeader->actualImage2Sum = sum;
if (vars->fileVars->io)
(uint8_t *) vars->videoMapping, 0, kIOHibernateProgressCount);
clock_get_uptime(&endTime);
+
+ IOService::getPMRootDomain()->pmStatsRecordEvent(
+ kIOPMStatsHibernateImageRead | kIOPMStatsEventStartFlag, allTime);
+ IOService::getPMRootDomain()->pmStatsRecordEvent(
+ kIOPMStatsHibernateImageRead | kIOPMStatsEventStopFlag, endTime);
+
SUB_ABSOLUTETIME(&endTime, &allTime);
absolutetime_to_nanoseconds(endTime, &nsec);
projects / apple / xnu.git / blobdiff