Lines Matching defs:vars
224 static IOReturn IOHibernateDone(IOHibernateVars * vars);
388 IOHibernatePollerProbe(IOPolledFileIOVars * vars, IOService * target)
394 for (idx = vars->pollers->getCount() - 1; idx >= 0; idx--)
396 poller = (IOPolledInterface *) vars->pollers->getObject(idx);
409 IOHibernatePollerOpen(IOPolledFileIOVars * vars, uint32_t state, IOMemoryDescriptor * md)
415 for (idx = vars->pollers->getCount() - 1; idx >= 0; idx--)
417 poller = (IOPolledInterface *) vars->pollers->getObject(idx);
430 IOHibernatePollerClose(IOPolledFileIOVars * vars, uint32_t state)
437 (poller = (IOPolledInterface *) vars->pollers->getObject(idx));
454 IOPolledFileIOVars * vars = (IOPolledFileIOVars *) parameter;
456 vars->ioStatus = status;
460 IOHibernatePollerIO(IOPolledFileIOVars * vars,
471 completion.parameter = vars;
473 vars->ioStatus = -1;
475 poller = (IOPolledInterface *) vars->pollers->getObject(0);
476 err = poller->startIO(operation, bufferOffset, deviceOffset + vars->block0, length, completion);
484 IOHibernatePollerIODone(IOPolledFileIOVars * vars, bool abortable)
490 while (-1 == vars->ioStatus)
493 (poller = (IOPolledInterface *) vars->pollers->getObject(idx));
517 err = vars->ioStatus;
532 IOHibernateVars * vars = &gIOHibernateVars;
534 if (!vars->fileVars || !vars->fileVars->pollers)
538 (poller = (IOPolledInterface *) vars->fileVars->pollers->getObject(idx));
618 IOPolledFileIOVars * vars;
631 vars = IONew(IOPolledFileIOVars, 1);
632 if (!vars) return (kIOReturnNoMemory);
633 bzero(vars, sizeof(*vars));
637 vars->io = false;
638 vars->buffer = (uint8_t *) ioBuffer->getBytesNoCopy();
639 vars->bufferHalf = 0;
640 vars->bufferOffset = 0;
641 vars->bufferSize = ioBuffer->getLength() >> 1;
647 vars->fileRef = kern_open_file_for_direct_io(filename,
656 &vars->block0,
658 &vars->flags);
668 if (!vars->fileRef) err = kIOReturnNoSpace;
678 vars->flags ^= kIOHibernateOptionSSD;
681 vars->block0, maxiobytes, kIOHibernateOptionSSD & vars->flags);
688 vars->fileSize = ctx.size;
689 if (maxiobytes < vars->bufferSize) vars->bufferSize = maxiobytes;
691 vars->extentMap = (IOPolledFileExtent *) extentsData->getBytesNoCopy();
744 vars->pollers = OSArray::withCapacity(4);
745 if (!vars->pollers)
751 vars->blockSize = 512;
761 vars->pollers->flushCollection();
765 vars->pollers->setObject(poller);
769 && !vars->pollers->getCount()) break;
772 vars->blockSize = num->unsigned32BitValue();
778 if (vars->blockSize < 4096) vars->blockSize = 4096;
781 major(hibernate_image_dev), minor(hibernate_image_dev), (long)vars->blockSize,
782 vars->pollers->getCount());
784 if (!vars->pollers->getCount())
789 if (vars->blockSize < sizeof(IOHibernateImageHeader))
795 err = IOHibernatePollerProbe(vars, (IOService *) part);
798 err = IOHibernatePollerOpen(vars, kIOPolledPreflightState, ioBuffer);
801 vars->media = part;
809 *fileVars = vars;
824 vars->extentMap[0].start, keyUUID->getCStringNoCopy());
826 snprintf(str2, sizeof(str2), "%qx", vars->extentMap[0].start);
840 snprintf(str2, sizeof(str2), ",%qx", vars->extentMap[0].start);
860 if (vars->fileRef)
862 kern_close_file_for_direct_io(vars->fileRef, 0, 0, 0, 0, 0);
863 vars->fileRef = NULL;
874 IOPolledFileClose( IOPolledFileIOVars * vars )
876 if (vars->pollers)
878 IOHibernatePollerClose(vars, kIOPolledPostflightState);
879 vars->pollers->release();
882 bzero(vars, sizeof(IOPolledFileIOVars));
888 IOPolledFileSeek(IOPolledFileIOVars * vars, uint64_t position)
892 extentMap = vars->extentMap;
894 vars->position = position;
902 vars->currentExtent = extentMap;
903 vars->extentRemaining = extentMap->length - position;
904 vars->extentPosition = vars->position - position;
906 if (vars->bufferSize <= vars->extentRemaining)
907 vars->bufferLimit = vars->bufferSize;
909 vars->bufferLimit = vars->extentRemaining;
915 IOPolledFileWrite(IOPolledFileIOVars * vars,
928 size = vars->position & (vars->blockSize - 1);
930 size = vars->blockSize - size;
933 bytes = vars->buffer + vars->bufferOffset;
936 copy = vars->bufferLimit - vars->bufferOffset;
944 bcopy(bytes, vars->buffer + vars->bufferHalf + vars->bufferOffset, copy);
948 bzero(vars->buffer + vars->bufferHalf + vars->bufferOffset, copy);
951 vars->bufferOffset += copy;
952 vars->position += copy;
954 if (flush && vars->bufferOffset)
956 uint64_t offset = (vars->position - vars->bufferOffset
957 - vars->extentPosition + vars->currentExtent->start);
958 uint32_t length = (vars->bufferOffset);
961 if (cryptvars && vars->encryptStart
962 && (vars->position > vars->encryptStart)
963 && ((vars->position - length) < vars->encryptEnd))
968 encryptLen = vars->position - vars->encryptStart;
972 if (vars->position > vars->encryptEnd)
973 encryptLen -= (vars->position - vars->encryptEnd);
978 aes_encrypt_cbc(vars->buffer + vars->bufferHalf + encryptStart,
981 vars->buffer + vars->bufferHalf + encryptStart,
985 ADD_ABSOLUTETIME(&vars->cryptTime, &endTime);
986 SUB_ABSOLUTETIME(&vars->cryptTime, &startTime);
987 vars->cryptBytes += encryptLen;
990 bcopy(vars->buffer + vars->bufferHalf + encryptStart + encryptLen - AES_BLOCK_SIZE,
996 if (vars->io)
998 err = IOHibernatePollerIODone(vars, true);
1003 if (vars->position & (vars->blockSize - 1)) HIBLOG("misaligned file pos %qx\n", vars->position);
1004 //if (length != vars->bufferSize) HIBLOG("short write of %qx ends@ %qx\n", length, offset + length);
1006 err = IOHibernatePollerIO(vars, kIOPolledWrite, vars->bufferHalf, offset, length);
1009 vars->io = true;
1011 vars->extentRemaining -= vars->bufferOffset;
1012 if (!vars->extentRemaining)
1014 vars->currentExtent++;
1015 vars->extentRemaining = vars->currentExtent->length;
1016 vars->extentPosition = vars->position;
1017 if (!vars->extentRemaining)
1024 vars->bufferHalf = vars->bufferHalf ? 0 : vars->bufferSize;
1025 vars->bufferOffset = 0;
1026 if (vars->bufferSize <= vars->extentRemaining)
1027 vars->bufferLimit = vars->bufferSize;
1029 vars->bufferLimit = vars->extentRemaining;
1040 IOPolledFileRead(IOPolledFileIOVars * vars,
1051 copy = vars->bufferLimit - vars->bufferOffset;
1057 bcopy(vars->buffer + vars->bufferHalf + vars->bufferOffset, bytes, copy);
1061 vars->bufferOffset += copy;
1062 // vars->position += copy;
1064 if ((vars->bufferOffset == vars->bufferLimit) && (vars->position < vars->readEnd))
1066 if (vars->io)
1068 err = IOHibernatePollerIODone(vars, false);
1075 if (vars->position & (vars->blockSize - 1)) HIBLOG("misaligned file pos %qx\n", vars->position);
1077 vars->position += vars->lastRead;
1078 vars->extentRemaining -= vars->lastRead;
1079 vars->bufferLimit = vars->lastRead;
1081 if (!vars->extentRemaining)
1083 vars->currentExtent++;
1084 vars->extentRemaining = vars->currentExtent->length;
1085 vars->extentPosition = vars->position;
1086 if (!vars->extentRemaining)
1094 uint64_t lastReadLength = vars->lastRead;
1095 uint64_t offset = (vars->position
1096 - vars->extentPosition + vars->currentExtent->start);
1097 if (vars->extentRemaining <= vars->bufferSize)
1098 length = vars->extentRemaining;
1100 length = vars->bufferSize;
1101 if ((length + vars->position) > vars->readEnd)
1102 length = vars->readEnd - vars->position;
1104 vars->lastRead = length;
1107 //if (length != vars->bufferSize) HIBLOG("short read of %qx ends@ %qx\n", length, offset + length);
1108 err = IOHibernatePollerIO(vars, kIOPolledRead, vars->bufferHalf, offset, length);
1111 vars->io = true;
1114 vars->bufferHalf = vars->bufferHalf ? 0 : vars->bufferSize;
1115 vars->bufferOffset = 0;
1125 bcopy(vars->buffer + vars->bufferHalf + lastReadLength - AES_BLOCK_SIZE,
1131 aes_decrypt_cbc(vars->buffer + vars->bufferHalf,
1134 vars->buffer + vars->bufferHalf,
1138 ADD_ABSOLUTETIME(&vars->cryptTime, &endTime);
1139 SUB_ABSOLUTETIME(&vars->cryptTime, &startTime);
1140 vars->cryptBytes += lastReadLength;
1161 IOHibernateVars * vars;
1194 vars = IONew(IOHibernateVars, 1);
1195 if (!vars) return (kIOReturnNoMemory);
1196 bzero(vars, sizeof(*vars));
1203 IODelete(vars, IOHibernateVars, 1);
1211 vars->srcBuffer = IOBufferMemoryDescriptor::withOptions(kIODirectionOutIn,
1213 vars->ioBuffer = IOBufferMemoryDescriptor::withOptions(kIODirectionOutIn,
1216 vars->handoffBuffer = IOBufferMemoryDescriptor::withOptions(kIODirectionOutIn,
1219 if (!vars->srcBuffer || !vars->ioBuffer || !vars->handoffBuffer)
1227 if ((num = OSDynamicCast(OSNumber, obj))) vars->fileMinSize = num->unsigned64BitValue();
1232 if ((num = OSDynamicCast(OSNumber, obj))) vars->fileMaxSize = num->unsigned64BitValue();
1247 err = hibernate_alloc_page_lists(&vars->page_list,
1248 &vars->page_list_wired,
1249 &vars->page_list_pal);
1253 if (vars->fileMinSize || (kIOHibernateModeFileResize & gIOHibernateMode))
1255 hibernate_page_list_setall(vars->page_list,
1256 vars->page_list_wired,
1257 vars->page_list_pal,
1268 + vars->page_list->list_size
1275 setFileSize, vars->fileMinSize);
1278 && (setFileSize < vars->fileMinSize))
1280 setFileSize = vars->fileMinSize;
1286 err = IOPolledFileOpen(gIOHibernateFilename, setFileSize, vars->ioBuffer,
1287 &vars->fileVars, &vars->fileExtents, &data,
1288 &vars->volumeCryptKey[0]);
1300 vars->page_list, vars->page_list_wired, vars->page_list_pal);
1306 dsSSD = ((0 != (kIOHibernateOptionSSD & vars->fileVars->flags))
1315 if (!uuid_is_null(vars->volumeCryptKey) &&
1319 smcVars[0] = sizeof(vars->volumeCryptKey);
1336 if (encryptedswap || !uuid_is_null(vars->volumeCryptKey))
1341 vars->videoAllocSize = kVideoMapSize;
1342 if (KERN_SUCCESS != kmem_alloc_pageable(kernel_map, &vars->videoMapping, vars->videoAllocSize))
1343 vars->videoMapping = 0;
1347 for (uint32_t i = 0; i < sizeof(vars->wiredCryptKey); i++)
1348 vars->wiredCryptKey[i] = random();
1349 for (uint32_t i = 0; i < sizeof(vars->cryptKey); i++)
1350 vars->cryptKey[i] = random();
1390 bcopy(&vars->wiredCryptKey[0], &rtcVars.wiredCryptKey[0], sizeof(rtcVars.wiredCryptKey));
1428 gIOOptionsEntry->setProperty(sym, data); /* intentional insecure backup of rtc boot vars */
1486 data = OSData::withBytes(&vars->wiredCryptKey[0], sizeof(vars->wiredCryptKey));
1524 if (!vars->haveFastBoot)
1529 &vars->saveBootAudioVolume, sizeof(vars->saveBootAudioVolume))))
1532 newVolume = vars->saveBootAudioVolume & 0xf8;
1548 gIOHibernateVars = *vars;
1549 gFileVars = *vars->fileVars;
1558 if (vars->fileVars && vars->fileVars->fileRef) kern_close_file_for_direct_io(vars->fileVars->fileRef, 0, 0, 0, 0, 0);
1559 IOHibernateDone(vars);
1564 if (vars->fileVars) IODelete(vars->fileVars, IOPolledFileIOVars, 1);
1565 IODelete(vars, IOHibernateVars, 1);
1711 IOHibernateVars * vars = &gIOHibernateVars;
1724 vars->previewBuffer = OSDynamicCast(IOMemoryDescriptor, obj);
1725 if (obj && !vars->previewBuffer)
1728 vars->consoleMapping = NULL;
1729 if (vars->previewBuffer && (kIOReturnSuccess != vars->previewBuffer->prepare()))
1731 vars->previewBuffer->release();
1732 vars->previewBuffer = 0;
1736 && vars->previewBuffer
1756 vars->consoleMapping = (uint8_t *) consoleInfo.v_baseAddr;
1759 vars->consoleMapping, graphicsInfo->depth,
1761 if (vars->consoleMapping)
1762 ProgressInit(graphicsInfo, vars->consoleMapping,
1823 IOHibernateDone(IOHibernateVars * vars)
1827 hibernate_teardown(vars->page_list, vars->page_list_wired, vars->page_list_pal);
1829 if (vars->videoMapping)
1831 if (vars->videoMapSize)
1833 IOUnmapPages(kernel_map, vars->videoMapping, vars->videoMapSize);
1834 if (vars->videoAllocSize)
1836 kmem_free(kernel_map, trunc_page(vars->videoMapping), vars->videoAllocSize);
1839 if (vars->previewBuffer)
1841 vars->previewBuffer->release();
1842 vars->previewBuffer = 0;
1867 if (vars->fileVars)
1869 if ((next = vars->fileVars->media)) do
1875 IOPolledFileClose(vars->fileVars);
1911 if (vars->srcBuffer)
1912 vars->srcBuffer->release();
1913 if (vars->ioBuffer)
1914 vars->ioBuffer->release();
1916 if (vars->handoffBuffer)
1922 for (handoff = (IOHibernateHandoff *) vars->handoffBuffer->getBytesNoCopy();
1957 vars->handoffBuffer->release();
1959 if (vars->fileExtents)
1960 vars->fileExtents->release();
1962 bzero(vars, sizeof(*vars));
2101 IOHibernateVars *vars = (IOHibernateVars *)vars_arg;
2103 hibernate_set_page_state(vars->page_list, vars->page_list_wired, atop_64(addr), 1, kIOHibernatePageStateFree);
2106 hibernate_page_bitset(vars->page_list_pal, TRUE, atop_64(addr));
2114 IOHibernateVars * vars = &gIOHibernateVars;
2116 IOReturn err = IOPolledFileWrite(vars->fileVars, (const uint8_t *)buffer, size, local_cryptvars);
2130 IOHibernateVars * vars = &gIOHibernateVars;
2178 if (!vars->fileVars || !vars->fileVars->pollers || !vars->fileExtents)
2201 aes_encrypt_key(vars->cryptKey,
2204 aes_decrypt_key(vars->cryptKey,
2210 for (pageCount = 0; pageCount < sizeof(vars->wiredCryptKey); pageCount++)
2211 vars->wiredCryptKey[pageCount] ^= vars->volumeCryptKey[pageCount];
2212 bzero(&vars->volumeCryptKey[0], sizeof(vars->volumeCryptKey));
2213 aes_encrypt_key(vars->wiredCryptKey,
2218 bzero(&vars->wiredCryptKey[0], sizeof(vars->wiredCryptKey));
2219 bzero(&vars->cryptKey[0], sizeof(vars->cryptKey));
2227 hibernate_page_list_setall(vars->page_list,
2228 vars->page_list_wired,
2229 vars->page_list_pal,
2238 fileExtents = (IOPolledFileExtent *) vars->fileExtents->getBytesNoCopy();
2241 count = vars->fileExtents->getLength() / sizeof(IOPolledFileExtent);
2263 IOPolledFileSeek(vars->fileVars, vars->fileVars->blockSize);
2267 err = IOHibernatePollerOpen(vars->fileVars, kIOPolledBeforeSleepState, vars->ioBuffer);
2275 count = vars->fileExtents->getLength();
2279 err = IOPolledFileWrite(vars->fileVars,
2295 (phys64 = vars->handoffBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
2330 err = IOPolledFileWrite(vars->fileVars, src, count, cryptvars);
2334 err = IOPolledFileWrite(vars->fileVars,
2344 err = IOPolledFileWrite(vars->fileVars, src, count, cryptvars);
2351 vars->fileVars->encryptStart = (vars->fileVars->position & ~(AES_BLOCK_SIZE - 1));
2352 vars->fileVars->encryptEnd = UINT64_MAX;
2353 HIBLOG("encryptStart %qx\n", vars->fileVars->encryptStart);
2358 if (vars->previewBuffer)
2364 phys64 = vars->previewBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone);
2367 err = IOPolledFileWrite(vars->fileVars,
2379 src = (uint8_t *) vars->previewBuffer->getPhysicalSegment(0, NULL, _kIOMemorySourceSegment);
2383 count = vars->previewBuffer->getLength();
2390 phys64 = vars->previewBuffer->getPhysicalSegment(page, NULL, kIOMemoryMapperNone);
2393 err = IOPolledFileWrite(vars->fileVars, src, count, cryptvars);
2401 (phys64 = vars->ioBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
2404 hibernate_set_page_state(vars->page_list, vars->page_list_wired,
2411 (phys64 = vars->srcBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
2414 hibernate_set_page_state(vars->page_list, vars->page_list_wired,
2422 bitmap_size = vars->page_list_wired->list_size;
2423 src = (uint8_t *) vars->page_list_wired;
2424 err = IOPolledFileWrite(vars->fileVars, src, bitmap_size, cryptvars);
2431 hibernate_page_list_set_volatile(vars->page_list, vars->page_list_wired, &pageCount);
2436 hibernate_set_page_state(vars->page_list, vars->page_list_wired,
2441 if (vars->previewBuffer) for (count = 0;
2442 (phys64 = vars->previewBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
2445 hibernate_set_page_state(vars->page_list, vars->page_list_wired,
2452 (phys64 = vars->handoffBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
2455 hibernate_set_page_state(vars->page_list, vars->page_list_wired,
2463 src = (uint8_t *) vars->srcBuffer->getBytesNoCopy();
2469 zerosCompressed = vars->handoffBuffer->getBytesNoCopy();
2480 pageCount, vars->fileVars->position);
2499 vars->fileVars->encryptStart = (vars->fileVars->position & ~(((uint64_t)AES_BLOCK_SIZE) - 1));
2500 vars->fileVars->encryptEnd = UINT64_MAX;
2501 HIBLOG("encryptStart %qx\n", vars->fileVars->encryptStart);
2511 ? vars->page_list_wired : vars->page_list,
2544 err = IOPolledFileWrite(vars->fileVars,
2553 err = IOMemoryDescriptorWriteFromPhysical(vars->srcBuffer, 0, ptoa_64(page), page_size);
2595 err = IOPolledFileWrite(vars->fileVars, (const uint8_t *) &tag, sizeof(tag), cryptvars);
2599 err = IOPolledFileWrite(vars->fileVars, data, (pageCompressedSize + 3) & ~3, cryptvars);
2607 if (vars->consoleMapping && (0 == (1023 & pagesDone)))
2612 ProgressUpdate(gIOHibernateGraphicsInfo, vars->consoleMapping, lastBlob, blob);
2637 if ((kEncrypt & pageType) && vars->fileVars->encryptStart)
2639 vars->fileVars->encryptEnd = ((vars->fileVars->position + 511) & ~511ULL);
2640 HIBLOG("encryptEnd %qx\n", vars->fileVars->encryptEnd);
2646 err = IOPolledFileWrite(vars->fileVars, 0, 0, cryptvars);
2653 // err = IOPolledFileWrite(vars->fileVars, 0, 0x60000000, cryptvars);
2656 header->encryptStart = vars->fileVars->encryptStart;
2657 header->encryptEnd = vars->fileVars->encryptEnd;
2658 image1Size = vars->fileVars->position;
2675 header->imageSize = vars->fileVars->position;
2688 count = vars->fileExtents->getLength();
2698 header->deviceBase = vars->fileVars->block0;
2699 header->deviceBlockSize = vars->fileVars->blockSize;
2701 IOPolledFileSeek(vars->fileVars, 0);
2702 err = IOPolledFileWrite(vars->fileVars,
2707 err = IOPolledFileWrite(vars->fileVars, 0, 0, cryptvars);
2710 err = IOHibernatePollerIODone(vars->fileVars, true);
2731 absolutetime_to_nanoseconds(vars->fileVars->cryptTime, &nsec);
2733 vars->fileVars->cryptBytes,
2735 nsec ? (((vars->fileVars->cryptBytes * 1000000000ULL) / 1024 / 1024) / nsec) : 0);
2738 header->imageSize, (header->imageSize * 100) / vars->fileVars->fileSize,
2746 if (vars->fileVars->io)
2747 (void) IOHibernatePollerIODone(vars->fileVars, false);
2750 IOHibernatePollerClose(vars->fileVars, kIOPolledBeforeSleepState);
2752 if (vars->consoleMapping)
2754 vars->consoleMapping, 0, kIOHibernateProgressCount);
2809 IOHibernateVars * vars = &gIOHibernateVars;
2812 if (!vars->fileVars || !vars->fileVars->pollers || !vars->fileExtents)
2862 hibernate_page_list_discard(vars->page_list);
2874 for (handoff = (IOHibernateHandoff *) vars->handoffBuffer->getBytesNoCopy();
2936 if (vars->videoMapping && gIOHibernateGraphicsInfo->physicalAddress)
2938 vars->videoMapSize = round_page(gIOHibernateGraphicsInfo->height
2940 if (vars->videoMapSize > vars->videoAllocSize) vars->videoMapSize = 0;
2944 vars->videoMapping, gIOHibernateGraphicsInfo->physicalAddress,
2945 vars->videoMapSize, kIOMapInhibitCache );
2949 if (vars->videoMapSize)
2951 (uint8_t *) vars->videoMapping, 0, kIOHibernateProgressCount);
2953 uint8_t * src = (uint8_t *) vars->srcBuffer->getBytesNoCopy();
2963 err = IOHibernatePollerOpen(vars->fileVars, kIOPolledAfterSleepState, 0);
2970 IOPolledFileSeek(vars->fileVars, gIOHibernateCurrentHeader->image1Size);
2973 vars->fileVars->io = false;
2974 vars->fileVars->bufferHalf = 0;
2975 vars->fileVars->bufferLimit = 0;
2976 vars->fileVars->lastRead = 0;
2977 vars->fileVars->readEnd = gIOHibernateCurrentHeader->imageSize;
2978 vars->fileVars->bufferOffset = vars->fileVars->bufferLimit;
2979 vars->fileVars->cryptBytes = 0;
2980 AbsoluteTime_to_scalar(&vars->fileVars->cryptTime) = 0;
2982 err = IOPolledFileRead(vars->fileVars, 0, 0, cryptvars);
2983 vars->fileVars->bufferOffset = vars->fileVars->bufferLimit;
2998 err = IOPolledFileRead(vars->fileVars, src, 8, cryptvars);
3012 err = IOPolledFileRead(vars->fileVars, (uint8_t *) &tag, 4, cryptvars);
3026 err = IOPolledFileRead(vars->fileVars, src, (compressedSize + 3) & ~3, cryptvars);
3041 err = IOMemoryDescriptorReadToPhysical(vars->srcBuffer, decoOffset, ptoa_64(ppnum), page_size);
3077 if (vars->fileVars->io)
3078 (void) IOHibernatePollerIODone(vars->fileVars, false);
3082 err = IOHibernatePollerClose(vars->fileVars, kIOPolledAfterSleepState);
3110 absolutetime_to_nanoseconds(vars->fileVars->cryptTime, &nsec);
3112 vars->fileVars->cryptBytes,
3114 nsec ? (((vars->fileVars->cryptBytes * 1000000000ULL) / 1024 / 1024) / nsec) : 0);