Lines Matching defs:vars
218 static IOReturn IOHibernateDone(IOHibernateVars * vars);
385 IOHibernatePollerProbe(IOPolledFileIOVars * vars, IOService * target)
391 for (idx = vars->pollers->getCount() - 1; idx >= 0; idx--)
393 poller = (IOPolledInterface *) vars->pollers->getObject(idx);
406 IOHibernatePollerOpen(IOPolledFileIOVars * vars, uint32_t state, IOMemoryDescriptor * md)
412 for (idx = vars->pollers->getCount() - 1; idx >= 0; idx--)
414 poller = (IOPolledInterface *) vars->pollers->getObject(idx);
427 IOHibernatePollerClose(IOPolledFileIOVars * vars, uint32_t state)
434 (poller = (IOPolledInterface *) vars->pollers->getObject(idx));
451 IOPolledFileIOVars * vars = (IOPolledFileIOVars *) parameter;
453 vars->ioStatus = status;
457 IOHibernatePollerIO(IOPolledFileIOVars * vars,
468 completion.parameter = vars;
470 vars->ioStatus = -1;
472 poller = (IOPolledInterface *) vars->pollers->getObject(0);
473 err = poller->startIO(operation, bufferOffset, deviceOffset + vars->block0, length, completion);
481 IOHibernatePollerIODone(IOPolledFileIOVars * vars, bool abortable)
487 while (-1 == vars->ioStatus)
490 (poller = (IOPolledInterface *) vars->pollers->getObject(idx));
514 err = vars->ioStatus;
529 IOHibernateVars * vars = &gIOHibernateVars;
531 if (!vars->fileVars || !vars->fileVars->pollers)
535 (poller = (IOPolledInterface *) vars->fileVars->pollers->getObject(idx));
613 IOPolledFileIOVars * vars;
626 vars = IONew(IOPolledFileIOVars, 1);
627 if (!vars) return (kIOReturnNoMemory);
628 bzero(vars, sizeof(*vars));
636 vars->io = false;
637 vars->buffer = (uint8_t *) ioBuffer->getBytesNoCopy();
638 vars->bufferHalf = 0;
639 vars->bufferOffset = 0;
640 vars->bufferSize = ioBuffer->getLength() >> 1;
646 vars->fileRef = kern_open_file_for_direct_io(filename,
655 &vars->block0,
657 &vars->flags);
667 if (!vars->fileRef) err = kIOReturnNoSpace;
677 vars->flags ^= kIOHibernateOptionSSD;
680 vars->block0, maxiobytes, kIOHibernateOptionSSD & vars->flags);
687 vars->fileSize = ctx.size;
688 if (maxiobytes < vars->bufferSize)
689 vars->bufferSize = maxiobytes;
691 vars->extentMap = (IOPolledFileExtent *) extentsData->getBytesNoCopy();
738 vars->pollers = OSArray::withCapacity(4);
739 if (!vars->pollers)
742 vars->blockSize = 512;
752 vars->pollers->flushCollection();
756 vars->pollers->setObject(poller);
758 vars->blockSize = num->unsigned32BitValue();
765 major(hibernate_image_dev), minor(hibernate_image_dev), (long)vars->blockSize, vars->pollers->getCount());
766 if (vars->pollers->getCount() < kIOHibernateMinPollersNeeded)
769 err = IOHibernatePollerProbe(vars, (IOService *) part);
773 err = IOHibernatePollerOpen(vars, kIOPolledPreflightState, ioBuffer);
777 *fileVars = vars;
792 vars->extentMap[0].start, keyUUID->getCStringNoCopy());
794 snprintf(str2, sizeof(str2), "%qx", vars->extentMap[0].start);
808 snprintf(str2, sizeof(str2), ",%qx", vars->extentMap[0].start);
828 if (vars->fileRef)
830 kern_close_file_for_direct_io(vars->fileRef, 0, 0, 0, 0, 0);
831 vars->fileRef = NULL;
842 IOPolledFileClose( IOPolledFileIOVars * vars )
844 if (vars->pollers)
846 IOHibernatePollerClose(vars, kIOPolledPostflightState);
847 vars->pollers->release();
850 bzero(vars, sizeof(IOPolledFileIOVars));
856 IOPolledFileSeek(IOPolledFileIOVars * vars, uint64_t position)
860 extentMap = vars->extentMap;
862 vars->position = position;
870 vars->currentExtent = extentMap;
871 vars->extentRemaining = extentMap->length - position;
872 vars->extentPosition = vars->position - position;
874 if (vars->bufferSize <= vars->extentRemaining)
875 vars->bufferLimit = vars->bufferSize;
877 vars->bufferLimit = vars->extentRemaining;
883 IOPolledFileWrite(IOPolledFileIOVars * vars,
896 size = vars->position & (vars->blockSize - 1);
898 size = vars->blockSize - size;
901 bytes = vars->buffer + vars->bufferOffset;
904 copy = vars->bufferLimit - vars->bufferOffset;
912 bcopy(bytes, vars->buffer + vars->bufferHalf + vars->bufferOffset, copy);
916 bzero(vars->buffer + vars->bufferHalf + vars->bufferOffset, copy);
919 vars->bufferOffset += copy;
920 vars->position += copy;
922 if (flush && vars->bufferOffset)
924 uint64_t offset = (vars->position - vars->bufferOffset
925 - vars->extentPosition + vars->currentExtent->start);
926 uint32_t length = (vars->bufferOffset);
929 if (cryptvars && vars->encryptStart
930 && (vars->position > vars->encryptStart)
931 && ((vars->position - length) < vars->encryptEnd))
936 encryptLen = vars->position - vars->encryptStart;
940 if (vars->position > vars->encryptEnd)
941 encryptLen -= (vars->position - vars->encryptEnd);
946 aes_encrypt_cbc(vars->buffer + vars->bufferHalf + encryptStart,
949 vars->buffer + vars->bufferHalf + encryptStart,
953 ADD_ABSOLUTETIME(&vars->cryptTime, &endTime);
954 SUB_ABSOLUTETIME(&vars->cryptTime, &startTime);
955 vars->cryptBytes += encryptLen;
958 bcopy(vars->buffer + vars->bufferHalf + encryptStart + encryptLen - AES_BLOCK_SIZE,
964 if (vars->io)
966 err = IOHibernatePollerIODone(vars, true);
971 if (vars->position & (vars->blockSize - 1)) HIBLOG("misaligned file pos %qx\n", vars->position);
972 //if (length != vars->bufferSize) HIBLOG("short write of %qx ends@ %qx\n", length, offset + length);
974 err = IOHibernatePollerIO(vars, kIOPolledWrite, vars->bufferHalf, offset, length);
977 vars->io = true;
979 vars->extentRemaining -= vars->bufferOffset;
980 if (!vars->extentRemaining)
982 vars->currentExtent++;
983 vars->extentRemaining = vars->currentExtent->length;
984 vars->extentPosition = vars->position;
985 if (!vars->extentRemaining)
992 vars->bufferHalf = vars->bufferHalf ? 0 : vars->bufferSize;
993 vars->bufferOffset = 0;
994 if (vars->bufferSize <= vars->extentRemaining)
995 vars->bufferLimit = vars->bufferSize;
997 vars->bufferLimit = vars->extentRemaining;
1008 IOPolledFileRead(IOPolledFileIOVars * vars,
1019 copy = vars->bufferLimit - vars->bufferOffset;
1025 bcopy(vars->buffer + vars->bufferHalf + vars->bufferOffset, bytes, copy);
1029 vars->bufferOffset += copy;
1030 // vars->position += copy;
1032 if ((vars->bufferOffset == vars->bufferLimit) && (vars->position < vars->readEnd))
1034 if (vars->io)
1036 err = IOHibernatePollerIODone(vars, false);
1043 if (vars->position & (vars->blockSize - 1)) HIBLOG("misaligned file pos %qx\n", vars->position);
1045 vars->position += vars->lastRead;
1046 vars->extentRemaining -= vars->lastRead;
1047 vars->bufferLimit = vars->lastRead;
1049 if (!vars->extentRemaining)
1051 vars->currentExtent++;
1052 vars->extentRemaining = vars->currentExtent->length;
1053 vars->extentPosition = vars->position;
1054 if (!vars->extentRemaining)
1062 uint64_t lastReadLength = vars->lastRead;
1063 uint64_t offset = (vars->position
1064 - vars->extentPosition + vars->currentExtent->start);
1065 if (vars->extentRemaining <= vars->bufferSize)
1066 length = vars->extentRemaining;
1068 length = vars->bufferSize;
1069 if ((length + vars->position) > vars->readEnd)
1070 length = vars->readEnd - vars->position;
1072 vars->lastRead = length;
1075 //if (length != vars->bufferSize) HIBLOG("short read of %qx ends@ %qx\n", length, offset + length);
1076 err = IOHibernatePollerIO(vars, kIOPolledRead, vars->bufferHalf, offset, length);
1079 vars->io = true;
1082 vars->bufferHalf = vars->bufferHalf ? 0 : vars->bufferSize;
1083 vars->bufferOffset = 0;
1093 bcopy(vars->buffer + vars->bufferHalf + lastReadLength - AES_BLOCK_SIZE,
1099 aes_decrypt_cbc(vars->buffer + vars->bufferHalf,
1102 vars->buffer + vars->bufferHalf,
1106 ADD_ABSOLUTETIME(&vars->cryptTime, &endTime);
1107 SUB_ABSOLUTETIME(&vars->cryptTime, &startTime);
1108 vars->cryptBytes += lastReadLength;
1129 IOHibernateVars * vars;
1162 vars = IONew(IOHibernateVars, 1);
1163 if (!vars) return (kIOReturnNoMemory);
1164 bzero(vars, sizeof(*vars));
1171 IODelete(vars, IOHibernateVars, 1);
1179 vars->srcBuffer = IOBufferMemoryDescriptor::withOptions(kIODirectionOutIn,
1181 vars->ioBuffer = IOBufferMemoryDescriptor::withOptions(kIODirectionOutIn,
1184 vars->handoffBuffer = IOBufferMemoryDescriptor::withOptions(kIODirectionOutIn,
1187 if (!vars->srcBuffer || !vars->ioBuffer || !vars->handoffBuffer)
1195 if ((num = OSDynamicCast(OSNumber, obj))) vars->fileMinSize = num->unsigned64BitValue();
1200 if ((num = OSDynamicCast(OSNumber, obj))) vars->fileMaxSize = num->unsigned64BitValue();
1218 &vars->page_list, &vars->page_list_wired, &vars->page_list_pal);
1226 if (vars->fileMinSize || (kIOHibernateModeFileResize & gIOHibernateMode))
1228 hibernate_page_list_setall(vars->page_list,
1229 vars->page_list_wired,
1230 vars->page_list_pal,
1240 + vars->page_list->list_size
1245 setFileSize, vars->fileMinSize);
1248 && (setFileSize < vars->fileMinSize))
1250 setFileSize = vars->fileMinSize;
1256 err = IOPolledFileOpen(gIOHibernateFilename, setFileSize, vars->ioBuffer,
1257 &vars->fileVars, &vars->fileExtents, &data,
1258 &vars->volumeCryptKey[0]);
1265 dsSSD = ((0 != (kIOHibernateOptionSSD & vars->fileVars->flags))
1274 if (!uuid_is_null(vars->volumeCryptKey) &&
1278 smcVars[0] = sizeof(vars->volumeCryptKey);
1295 if (encryptedswap || !uuid_is_null(vars->volumeCryptKey))
1300 vars->videoAllocSize = kVideoMapSize;
1301 if (KERN_SUCCESS != kmem_alloc_pageable(kernel_map, &vars->videoMapping, vars->videoAllocSize))
1302 vars->videoMapping = 0;
1306 for (uint32_t i = 0; i < sizeof(vars->wiredCryptKey); i++)
1307 vars->wiredCryptKey[i] = random();
1308 for (uint32_t i = 0; i < sizeof(vars->cryptKey); i++)
1309 vars->cryptKey[i] = random();
1349 bcopy(&vars->wiredCryptKey[0], &rtcVars.wiredCryptKey[0], sizeof(rtcVars.wiredCryptKey));
1387 gIOOptionsEntry->setProperty(sym, data); /* intentional insecure backup of rtc boot vars */
1445 data = OSData::withBytes(&vars->wiredCryptKey[0], sizeof(vars->wiredCryptKey));
1483 if (!vars->haveFastBoot)
1488 &vars->saveBootAudioVolume, sizeof(vars->saveBootAudioVolume))))
1491 newVolume = vars->saveBootAudioVolume & 0xf8;
1507 gIOHibernateVars = *vars;
1508 gFileVars = *vars->fileVars;
1517 if (vars->fileVars && vars->fileVars->fileRef) kern_close_file_for_direct_io(vars->fileVars->fileRef, 0, 0, 0, 0, 0);
1518 IOHibernateDone(vars);
1523 if (vars->fileVars) IODelete(vars->fileVars, IOPolledFileIOVars, 1);
1524 IODelete(vars, IOHibernateVars, 1);
1670 IOHibernateVars * vars = &gIOHibernateVars;
1683 vars->previewBuffer = OSDynamicCast(IOMemoryDescriptor, obj);
1684 if (obj && !vars->previewBuffer)
1687 vars->consoleMapping = NULL;
1688 if (vars->previewBuffer && (kIOReturnSuccess != vars->previewBuffer->prepare()))
1690 vars->previewBuffer->release();
1691 vars->previewBuffer = 0;
1695 && vars->previewBuffer
1715 vars->consoleMapping = (uint8_t *) consoleInfo.v_baseAddr;
1718 vars->consoleMapping, graphicsInfo->depth,
1720 if (vars->consoleMapping)
1721 ProgressInit(graphicsInfo, vars->consoleMapping,
1782 IOHibernateDone(IOHibernateVars * vars)
1784 hibernate_teardown(vars->page_list, vars->page_list_wired, vars->page_list_pal);
1786 if (vars->videoMapping)
1788 if (vars->videoMapSize)
1790 IOUnmapPages(kernel_map, vars->videoMapping, vars->videoMapSize);
1791 if (vars->videoAllocSize)
1793 kmem_free(kernel_map, trunc_page(vars->videoMapping), vars->videoAllocSize);
1796 if (vars->previewBuffer)
1798 vars->previewBuffer->release();
1799 vars->previewBuffer = 0;
1825 if (vars->fileVars)
1827 IOPolledFileClose(vars->fileVars);
1863 if (vars->srcBuffer)
1864 vars->srcBuffer->release();
1865 if (vars->ioBuffer)
1866 vars->ioBuffer->release();
1868 if (vars->handoffBuffer)
1874 for (handoff = (IOHibernateHandoff *) vars->handoffBuffer->getBytesNoCopy();
1909 vars->handoffBuffer->release();
1911 if (vars->fileExtents)
1912 vars->fileExtents->release();
1914 bzero(vars, sizeof(*vars));
2032 IOHibernateVars * vars = &gIOHibernateVars;
2034 IOReturn err = IOPolledFileWrite(vars->fileVars, (const uint8_t *)buffer, size, local_cryptvars);
2048 IOHibernateVars * vars = &gIOHibernateVars;
2086 if (!vars->fileVars || !vars->fileVars->pollers || !vars->fileExtents)
2109 aes_encrypt_key(vars->cryptKey,
2112 aes_decrypt_key(vars->cryptKey,
2118 for (pageCount = 0; pageCount < sizeof(vars->wiredCryptKey); pageCount++)
2119 vars->wiredCryptKey[pageCount] ^= vars->volumeCryptKey[pageCount];
2120 bzero(&vars->volumeCryptKey[0], sizeof(vars->volumeCryptKey));
2121 aes_encrypt_key(vars->wiredCryptKey,
2126 bzero(&vars->wiredCryptKey[0], sizeof(vars->wiredCryptKey));
2127 bzero(&vars->cryptKey[0], sizeof(vars->cryptKey));
2135 hibernate_page_list_setall(vars->page_list,
2136 vars->page_list_wired,
2137 vars->page_list_pal,
2143 fileExtents = (IOPolledFileExtent *) vars->fileExtents->getBytesNoCopy();
2146 count = vars->fileExtents->getLength() / sizeof(IOPolledFileExtent);
2168 IOPolledFileSeek(vars->fileVars, sizeof(IOHibernateImageHeader));
2172 err = IOHibernatePollerOpen(vars->fileVars, kIOPolledBeforeSleepState, vars->ioBuffer);
2180 count = vars->fileExtents->getLength();
2184 err = IOPolledFileWrite(vars->fileVars,
2200 (phys64 = vars->handoffBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
2235 err = IOPolledFileWrite(vars->fileVars, src, count, cryptvars);
2239 err = IOPolledFileWrite(vars->fileVars,
2249 err = IOPolledFileWrite(vars->fileVars, src, count, cryptvars);
2254 vars->fileVars->encryptStart = (vars->fileVars->position & ~(AES_BLOCK_SIZE - 1));
2255 vars->fileVars->encryptEnd = UINT64_MAX;
2256 HIBLOG("encryptStart %qx\n", vars->fileVars->encryptStart);
2260 if (vars->previewBuffer)
2266 phys64 = vars->previewBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone);
2269 err = IOPolledFileWrite(vars->fileVars,
2281 src = (uint8_t *) vars->previewBuffer->getPhysicalSegment(0, NULL, _kIOMemorySourceSegment);
2285 count = vars->previewBuffer->getLength();
2292 phys64 = vars->previewBuffer->getPhysicalSegment(page, NULL, kIOMemoryMapperNone);
2295 err = IOPolledFileWrite(vars->fileVars, src, count, cryptvars);
2303 (phys64 = vars->ioBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
2306 hibernate_set_page_state(vars->page_list, vars->page_list_wired,
2313 (phys64 = vars->srcBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
2316 hibernate_set_page_state(vars->page_list, vars->page_list_wired,
2324 bitmap_size = vars->page_list_wired->list_size;
2325 src = (uint8_t *) vars->page_list_wired;
2326 err = IOPolledFileWrite(vars->fileVars, src, bitmap_size, cryptvars);
2333 hibernate_page_list_set_volatile(vars->page_list, vars->page_list_wired, &pageCount);
2338 hibernate_set_page_state(vars->page_list, vars->page_list_wired,
2343 if (vars->previewBuffer) for (count = 0;
2344 (phys64 = vars->previewBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
2347 hibernate_set_page_state(vars->page_list, vars->page_list_wired,
2354 (phys64 = vars->handoffBuffer->getPhysicalSegment(count, &segLen, kIOMemoryMapperNone));
2357 hibernate_set_page_state(vars->page_list, vars->page_list_wired,
2365 src = (uint8_t *) vars->srcBuffer->getBytesNoCopy();
2372 pageCount, vars->fileVars->position);
2389 vars->fileVars->encryptStart = (vars->fileVars->position & ~(((uint64_t)AES_BLOCK_SIZE) - 1));
2390 vars->fileVars->encryptEnd = UINT64_MAX;
2391 HIBLOG("encryptStart %qx\n", vars->fileVars->encryptStart);
2400 ? vars->page_list_wired : vars->page_list,
2433 err = IOPolledFileWrite(vars->fileVars,
2442 err = IOMemoryDescriptorWriteFromPhysical(vars->srcBuffer, 0, ptoa_64(page), page_size);
2479 err = IOPolledFileWrite(vars->fileVars, (const uint8_t *) &tag, sizeof(tag), cryptvars);
2483 err = IOPolledFileWrite(vars->fileVars, data, (pageCompressedSize + 3) & ~3, cryptvars);
2492 if (vars->consoleMapping && (0 == (1023 & pagesDone)))
2497 ProgressUpdate(gIOHibernateGraphicsInfo, vars->consoleMapping, lastBlob, blob);
2524 vars->fileVars->encryptEnd = ((vars->fileVars->position + 511) & ~511ULL);
2525 HIBLOG("encryptEnd %qx\n", vars->fileVars->encryptEnd);
2531 err = IOPolledFileWrite(vars->fileVars, 0, 0, cryptvars);
2538 // err = IOPolledFileWrite(vars->fileVars, 0, 0x60000000, cryptvars);
2541 header->encryptStart = vars->fileVars->encryptStart;
2542 header->encryptEnd = vars->fileVars->encryptEnd;
2543 image1Size = vars->fileVars->position;
2553 header->imageSize = vars->fileVars->position;
2566 count = vars->fileExtents->getLength();
2576 header->deviceBase = vars->fileVars->block0;
2578 IOPolledFileSeek(vars->fileVars, 0);
2579 err = IOPolledFileWrite(vars->fileVars,
2584 err = IOPolledFileWrite(vars->fileVars, 0, 0, cryptvars);
2587 err = IOHibernatePollerIODone(vars->fileVars, true);
2609 absolutetime_to_nanoseconds(vars->fileVars->cryptTime, &nsec);
2611 vars->fileVars->cryptBytes,
2613 nsec ? (((vars->fileVars->cryptBytes * 1000000000ULL) / 1024 / 1024) / nsec) : 0);
2616 header->imageSize, (header->imageSize * 100) / vars->fileVars->fileSize,
2624 if (vars->fileVars->io)
2625 (void) IOHibernatePollerIODone(vars->fileVars, false);
2628 IOHibernatePollerClose(vars->fileVars, kIOPolledBeforeSleepState);
2630 if (vars->consoleMapping)
2632 vars->consoleMapping, 0, kIOHibernateProgressCount);
2686 IOHibernateVars * vars = &gIOHibernateVars;
2688 if (!vars->fileVars || !vars->fileVars->pollers || !vars->fileExtents)
2709 hibernate_page_list_discard(vars->page_list);
2720 for (handoff = (IOHibernateHandoff *) vars->handoffBuffer->getBytesNoCopy();
2771 if (vars->videoMapping && gIOHibernateGraphicsInfo->physicalAddress)
2773 vars->videoMapSize = round_page(gIOHibernateGraphicsInfo->height
2776 vars->videoMapping, gIOHibernateGraphicsInfo->physicalAddress,
2777 vars->videoMapSize, kIOMapInhibitCache );
2780 if (vars->videoMapSize)
2782 (uint8_t *) vars->videoMapping, 0, kIOHibernateProgressCount);
2784 uint8_t * src = (uint8_t *) vars->srcBuffer->getBytesNoCopy();
2792 err = IOHibernatePollerOpen(vars->fileVars, kIOPolledAfterSleepState, 0);
2795 IOPolledFileSeek(vars->fileVars, gIOHibernateCurrentHeader->image1Size);
2798 vars->fileVars->io = false;
2799 vars->fileVars->bufferHalf = 0;
2800 vars->fileVars->bufferLimit = 0;
2801 vars->fileVars->lastRead = 0;
2802 vars->fileVars->readEnd = gIOHibernateCurrentHeader->imageSize;
2803 vars->fileVars->bufferOffset = vars->fileVars->bufferLimit;
2804 vars->fileVars->cryptBytes = 0;
2805 AbsoluteTime_to_scalar(&vars->fileVars->cryptTime) = 0;
2807 err = IOPolledFileRead(vars->fileVars, 0, 0, cryptvars);
2808 vars->fileVars->bufferOffset = vars->fileVars->bufferLimit;
2823 err = IOPolledFileRead(vars->fileVars, src, 8, cryptvars);
2837 err = IOPolledFileRead(vars->fileVars, (uint8_t *) &tag, 4, cryptvars);
2855 err = IOPolledFileRead(vars->fileVars, src, (compressedSize + 3) & ~3, cryptvars);
2876 err = IOMemoryDescriptorReadToPhysical(vars->srcBuffer, decoOffset, ptoa_64(ppnum), page_size);
2911 if (vars->fileVars->io)
2912 (void) IOHibernatePollerIODone(vars->fileVars, false);
2914 err = IOHibernatePollerClose(vars->fileVars, kIOPolledAfterSleepState);
2935 absolutetime_to_nanoseconds(vars->fileVars->cryptTime, &nsec);
2937 vars->fileVars->cryptBytes,
2939 nsec ? (((vars->fileVars->cryptBytes * 1000000000ULL) / 1024 / 1024) / nsec) : 0);