iokit/Kernel/IONVRAM.cpp

   1 /*
   2  * Copyright (c) 1998-2006 Apple Computer, Inc. All rights reserved.
   3  * Copyright (c) 2007-2012 Apple Inc. All rights reserved.
   4  *
   5  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   6  *
   7  * This file contains Original Code and/or Modifications of Original Code
   8  * as defined in and that are subject to the Apple Public Source License
   9  * Version 2.0 (the 'License'). You may not use this file except in
  10  * compliance with the License. The rights granted to you under the License
  11  * may not be used to create, or enable the creation or redistribution of,
  12  * unlawful or unlicensed copies of an Apple operating system, or to
  13  * circumvent, violate, or enable the circumvention or violation of, any
  14  * terms of an Apple operating system software license agreement.
  15  *
  16  * Please obtain a copy of the License at
  17  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  18  *
  19  * The Original Code and all software distributed under the License are
  20  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  21  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  22  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  24  * Please see the License for the specific language governing rights and
  25  * limitations under the License.
  26  *
  27  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  28  */
  29
  30 #include <IOKit/IOLib.h>
  31 #include <IOKit/IONVRAM.h>
  32 #include <IOKit/IOPlatformExpert.h>
  33 #include <IOKit/IOUserClient.h>
  34 #include <IOKit/IOKitKeys.h>
  35 #include <kern/debug.h>
  36 #include <pexpert/pexpert.h>
  37
  38 #define super IOService
  39
  40 #define kIONVRAMPrivilege       kIOClientPrivilegeAdministrator
  41 //#define kIONVRAMPrivilege     kIOClientPrivilegeLocalUser
  42
  43 OSDefineMetaClassAndStructors(IODTNVRAM, IOService);
  44
  45 bool IODTNVRAM::init(IORegistryEntry *old, const IORegistryPlane *plane)
  46 {
  47   OSDictionary *dict;
  48
  49   if (!super::init(old, plane)) return false;
  50
  51   dict =  OSDictionary::withCapacity(1);
  52   if (dict == 0) return false;
  53   setPropertyTable(dict);
  54
  55   _nvramImage = IONew(UInt8, kIODTNVRAMImageSize);
  56   if (_nvramImage == 0) return false;
  57
  58   _nvramPartitionOffsets = OSDictionary::withCapacity(1);
  59   if (_nvramPartitionOffsets == 0) return false;
  60
  61   _nvramPartitionLengths = OSDictionary::withCapacity(1);
  62   if (_nvramPartitionLengths == 0) return false;
  63
  64   _registryPropertiesKey = OSSymbol::withCStringNoCopy("aapl,pci");
  65   if (_registryPropertiesKey == 0) return false;
  66
  67   // <rdar://problem/9529235> race condition possible between
  68   // IODTNVRAM and IONVRAMController (restore loses boot-args)
  69   initProxyData();
  70
  71   return true;
  72 }
  73
  74 void IODTNVRAM::initProxyData(void)
  75 {
  76   IORegistryEntry *entry;
  77   const char *key = "nvram-proxy-data";
  78   OSObject *prop;
  79   OSData *data;
  80   const void *bytes;
  81
  82   entry = IORegistryEntry::fromPath("/chosen", gIODTPlane);
  83   if (entry != 0) {
  84     prop = entry->getProperty(key);
  85     if (prop != 0) {
  86       data = OSDynamicCast(OSData, prop);
  87       if (data != 0) {
  88         bytes = data->getBytesNoCopy();
  89         if (bytes != 0) {
  90           bcopy(bytes, _nvramImage, data->getLength());
  91           initNVRAMImage();
  92           _isProxied = true;
  93         }
  94       }
  95     }
  96     entry->removeProperty(key);
  97     entry->release();
  98   }
  99 }
 100
 101 void IODTNVRAM::registerNVRAMController(IONVRAMController *nvram)
 102 {
 103   if (_nvramController != 0) return;
 104
 105   _nvramController = nvram;
 106
 107   // <rdar://problem/9529235> race condition possible between
 108   // IODTNVRAM and IONVRAMController (restore loses boot-args)
 109   if (!_isProxied) {
 110     _nvramController->read(0, _nvramImage, kIODTNVRAMImageSize);
 111     initNVRAMImage();
 112   }
 113 }
 114
 115 void IODTNVRAM::initNVRAMImage(void)
 116 {
 117   char   partitionID[18];
 118   UInt32 partitionOffset, partitionLength;
 119   UInt32 freePartitionOffset, freePartitionSize;
 120   UInt32 currentLength, currentOffset = 0;
 121   OSNumber *partitionOffsetNumber, *partitionLengthNumber;
 122
 123   // Find the offsets for the OF, XPRAM, NameRegistry and PanicInfo partitions.
 124   _ofPartitionOffset = 0xFFFFFFFF;
 125   _piPartitionOffset = 0xFFFFFFFF;
 126   freePartitionOffset = 0xFFFFFFFF;
 127   freePartitionSize = 0;
 128
 129   // Look through the partitions to find the OF, MacOS partitions.
 130   while (currentOffset < kIODTNVRAMImageSize) {
 131     currentLength = ((UInt16 *)(_nvramImage + currentOffset))[1] * 16;
 132
 133     partitionOffset = currentOffset + 16;
 134     partitionLength = currentLength - 16;
 135
 136     if (strncmp((const char *)_nvramImage + currentOffset + 4,
 137                 kIODTNVRAMOFPartitionName, 12) == 0) {
 138       _ofPartitionOffset = partitionOffset;
 139       _ofPartitionSize = partitionLength;
 140     } else if (strncmp((const char *)_nvramImage + currentOffset + 4,
 141                        kIODTNVRAMXPRAMPartitionName, 12) == 0) {
 142     } else if (strncmp((const char *)_nvramImage + currentOffset + 4,
 143                        kIODTNVRAMPanicInfoPartitonName, 12) == 0) {
 144       _piPartitionOffset = partitionOffset;
 145       _piPartitionSize = partitionLength;
 146     } else if (strncmp((const char *)_nvramImage + currentOffset + 4,
 147                        kIODTNVRAMFreePartitionName, 12) == 0) {
 148       freePartitionOffset = currentOffset;
 149       freePartitionSize = currentLength;
 150     } else {
 151       // Construct the partition ID from the signature and name.
 152       snprintf(partitionID, sizeof(partitionID), "0x%02x,",
 153               *(UInt8 *)(_nvramImage + currentOffset));
 154       strncpy(partitionID + 5,
 155               (const char *)(_nvramImage + currentOffset + 4), 12);
 156       partitionID[17] = '\0';
 157
 158       partitionOffsetNumber = OSNumber::withNumber(partitionOffset, 32);
 159       partitionLengthNumber = OSNumber::withNumber(partitionLength, 32);
 160
 161       // Save the partition offset and length
 162       _nvramPartitionOffsets->setObject(partitionID, partitionOffsetNumber);
 163       _nvramPartitionLengths->setObject(partitionID, partitionLengthNumber);
 164
 165       partitionOffsetNumber->release();
 166       partitionLengthNumber->release();
 167     }
 168     currentOffset += currentLength;
 169   }
 170
 171   if (_ofPartitionOffset != 0xFFFFFFFF)
 172     _ofImage    = _nvramImage + _ofPartitionOffset;
 173
 174   if (_piPartitionOffset == 0xFFFFFFFF) {
 175     if (freePartitionSize > 0x20) {
 176       // Set the signature to 0xa1.
 177       _nvramImage[freePartitionOffset] = 0xa1;
 178       // Set the checksum to 0.
 179       _nvramImage[freePartitionOffset + 1] = 0;
 180       // Set the name for the Panic Info partition.
 181       strncpy((char *)(_nvramImage + freePartitionOffset + 4),
 182               kIODTNVRAMPanicInfoPartitonName, 12);
 183
 184       // Calculate the partition offset and size.
 185       _piPartitionOffset = freePartitionOffset + 0x10;
 186       _piPartitionSize = 0x800;
 187       if (_piPartitionSize + 0x20 > freePartitionSize)
 188         _piPartitionSize = freePartitionSize - 0x20;
 189
 190       _piImage = _nvramImage + _piPartitionOffset;
 191
 192       // Zero the new partition.
 193       bzero(_piImage, _piPartitionSize);
 194
 195       // Set the partition size.
 196       *(UInt16 *)(_nvramImage + freePartitionOffset + 2) =
 197         (_piPartitionSize / 0x10) + 1;
 198
 199       // Set the partition checksum.
 200       _nvramImage[freePartitionOffset + 1] =
 201         calculatePartitionChecksum(_nvramImage + freePartitionOffset);
 202
 203       // Calculate the free partition offset and size.
 204       freePartitionOffset += _piPartitionSize + 0x10;
 205       freePartitionSize -= _piPartitionSize + 0x10;
 206
 207       // Set the signature to 0x7f.
 208       _nvramImage[freePartitionOffset] = 0x7f;
 209       // Set the checksum to 0.
 210       _nvramImage[freePartitionOffset + 1] = 0;
 211       // Set the name for the free partition.
 212       strncpy((char *)(_nvramImage + freePartitionOffset + 4),
 213               kIODTNVRAMFreePartitionName, 12);
 214       // Set the partition size.
 215       *(UInt16 *)(_nvramImage + freePartitionOffset + 2) =
 216         freePartitionSize / 0x10;
 217       // Set the partition checksum.
 218       _nvramImage[freePartitionOffset + 1] =
 219         calculatePartitionChecksum(_nvramImage + freePartitionOffset);
 220
 221       // Set the nvram image as dirty.
 222       _nvramImageDirty = true;
 223     }
 224   } else {
 225     _piImage = _nvramImage + _piPartitionOffset;
 226   }
 227
 228   _lastDeviceSync = 0;
 229   _freshInterval = TRUE;                // we will allow sync() even before the first 15 minutes have passed.
 230
 231   initOFVariables();
 232 }
 233
 234 void IODTNVRAM::sync(void)
 235 {
 236   if (!_nvramImageDirty && !_ofImageDirty) return;
 237
 238   // Don't try to sync OF Variables if the system has already paniced.
 239   if (!_systemPaniced) syncOFVariables();
 240
 241   // Don't try to perform controller operations if none has been registered.
 242   if (_nvramController == 0) return;
 243
 244   _nvramController->write(0, _nvramImage, kIODTNVRAMImageSize);
 245   _nvramController->sync();
 246
 247   _nvramImageDirty = false;
 248 }
 249
 250 bool IODTNVRAM::serializeProperties(OSSerialize *s) const
 251 {
 252   bool                 result, hasPrivilege;
 253   UInt32               variablePerm;
 254   const OSSymbol       *key;
 255   OSDictionary         *dict;
 256   OSCollectionIterator *iter = 0;
 257
 258   // Verify permissions.
 259   hasPrivilege = (kIOReturnSuccess == IOUserClient::clientHasPrivilege(current_task(), kIONVRAMPrivilege));
 260
 261   if (_ofDict == 0) {
 262     /* No nvram. Return an empty dictionary. */
 263     dict = OSDictionary::withCapacity(1);
 264     if (dict == 0) return false;
 265   } else {
 266     IOLockLock(_ofLock);
 267     dict = OSDictionary::withDictionary(_ofDict);
 268     IOLockUnlock(_ofLock);
 269     if (dict == 0) return false;
 270
 271     /* Copy properties with client privilege. */
 272     iter = OSCollectionIterator::withCollection(dict);
 273     if (iter == 0) {
 274       dict->release();
 275       return false;
 276     }
 277     while (1) {
 278       key = OSDynamicCast(OSSymbol, iter->getNextObject());
 279       if (key == 0) break;
 280
 281       variablePerm = getOFVariablePerm(key);
 282       if ((hasPrivilege || (variablePerm != kOFVariablePermRootOnly)) &&
 283           ( ! (variablePerm == kOFVariablePermKernelOnly && current_task() != kernel_task) )) {}
 284       else dict->removeObject(key);
 285     }
 286   }
 287
 288   result = dict->serialize(s);
 289
 290   dict->release();
 291   if (iter != 0) iter->release();
 292
 293   return result;
 294 }
 295
 296 OSObject *IODTNVRAM::copyProperty(const OSSymbol *aKey) const
 297 {
 298   IOReturn result;
 299   UInt32   variablePerm;
 300   OSObject *theObject;
 301
 302   if (_ofDict == 0) return 0;
 303
 304   // Verify permissions.
 305   variablePerm = getOFVariablePerm(aKey);
 306   result = IOUserClient::clientHasPrivilege(current_task(), kIONVRAMPrivilege);
 307   if (result != kIOReturnSuccess) {
 308     if (variablePerm == kOFVariablePermRootOnly) return 0;
 309   }
 310   if (variablePerm == kOFVariablePermKernelOnly && current_task() != kernel_task) return 0;
 311
 312   IOLockLock(_ofLock);
 313   theObject = _ofDict->getObject(aKey);
 314   if (theObject) theObject->retain();
 315   IOLockUnlock(_ofLock);
 316
 317   return theObject;
 318 }
 319
 320 OSObject *IODTNVRAM::copyProperty(const char *aKey) const
 321 {
 322   const OSSymbol *keySymbol;
 323   OSObject *theObject = 0;
 324
 325   keySymbol = OSSymbol::withCString(aKey);
 326   if (keySymbol != 0) {
 327     theObject = copyProperty(keySymbol);
 328     keySymbol->release();
 329   }
 330
 331   return theObject;
 332 }
 333
 334 OSObject *IODTNVRAM::getProperty(const OSSymbol *aKey) const
 335 {
 336   OSObject *theObject;
 337
 338   theObject = copyProperty(aKey);
 339   if (theObject) theObject->release();
 340
 341   return theObject;
 342 }
 343
 344 OSObject *IODTNVRAM::getProperty(const char *aKey) const
 345 {
 346   OSObject *theObject;
 347
 348   theObject = copyProperty(aKey);
 349   if (theObject) theObject->release();
 350
 351   return theObject;
 352 }
 353
 354 bool IODTNVRAM::setProperty(const OSSymbol *aKey, OSObject *anObject)
 355 {
 356   bool     result;
 357   UInt32   propType, propPerm;
 358   OSString *tmpString;
 359   OSObject *propObject = 0;
 360
 361   if (_ofDict == 0) return false;
 362
 363   // Verify permissions.
 364   propPerm = getOFVariablePerm(aKey);
 365   result = IOUserClient::clientHasPrivilege(current_task(), kIONVRAMPrivilege);
 366   if (result != kIOReturnSuccess) {
 367     if (propPerm != kOFVariablePermUserWrite) return false;
 368   }
 369   if (propPerm == kOFVariablePermKernelOnly && current_task() != kernel_task) return 0;
 370
 371   // Don't allow change of 'aapl,panic-info'.
 372   if (aKey->isEqualTo(kIODTNVRAMPanicInfoKey)) return false;
 373
 374   // Make sure the object is of the correct type.
 375   propType = getOFVariableType(aKey);
 376   switch (propType) {
 377   case kOFVariableTypeBoolean :
 378     propObject = OSDynamicCast(OSBoolean, anObject);
 379     break;
 380
 381   case kOFVariableTypeNumber :
 382     propObject = OSDynamicCast(OSNumber, anObject);
 383     break;
 384
 385   case kOFVariableTypeString :
 386     propObject = OSDynamicCast(OSString, anObject);
 387     break;
 388
 389   case kOFVariableTypeData :
 390     propObject = OSDynamicCast(OSData, anObject);
 391     if (propObject == 0) {
 392       tmpString = OSDynamicCast(OSString, anObject);
 393       if (tmpString != 0) {
 394         propObject = OSData::withBytes(tmpString->getCStringNoCopy(),
 395                                        tmpString->getLength());
 396       }
 397     }
 398     break;
 399   }
 400
 401   if (propObject == 0) return false;
 402
 403   IOLockLock(_ofLock);
 404   result = _ofDict->setObject(aKey, propObject);
 405   IOLockUnlock(_ofLock);
 406
 407   if (result) {
 408     _ofImageDirty = true;
 409   }
 410
 411   return result;
 412 }
 413
 414 void IODTNVRAM::removeProperty(const OSSymbol *aKey)
 415 {
 416   bool     result;
 417   UInt32   propPerm;
 418
 419   if (_ofDict == 0) return;
 420
 421   // Verify permissions.
 422   propPerm = getOFVariablePerm(aKey);
 423   result = IOUserClient::clientHasPrivilege(current_task(), kIOClientPrivilegeAdministrator);
 424   if (result != kIOReturnSuccess) {
 425     if (propPerm != kOFVariablePermUserWrite) return;
 426   }
 427   if (propPerm == kOFVariablePermKernelOnly && current_task() != kernel_task) return;
 428
 429   // Don't allow change of 'aapl,panic-info'.
 430   if (aKey->isEqualTo(kIODTNVRAMPanicInfoKey)) return;
 431
 432   // If the object exists, remove it from the dictionary.
 433
 434   IOLockLock(_ofLock);
 435   result = _ofDict->getObject(aKey) != 0;
 436   if (result) {
 437     _ofDict->removeObject(aKey);
 438     _ofImageDirty = true;
 439   }
 440   IOLockUnlock(_ofLock);
 441 }
 442
 443 IOReturn IODTNVRAM::setProperties(OSObject *properties)
 444 {
 445   bool                 result = true;
 446   OSObject             *object;
 447   const OSSymbol       *key;
 448   const OSString       *tmpStr;
 449   OSDictionary         *dict;
 450   OSCollectionIterator *iter;
 451
 452   dict = OSDynamicCast(OSDictionary, properties);
 453   if (dict == 0) return kIOReturnBadArgument;
 454
 455   iter = OSCollectionIterator::withCollection(dict);
 456   if (iter == 0) return kIOReturnBadArgument;
 457
 458   while (result) {
 459     key = OSDynamicCast(OSSymbol, iter->getNextObject());
 460     if (key == 0) break;
 461
 462     object = dict->getObject(key);
 463     if (object == 0) continue;
 464
 465     if (key->isEqualTo(kIONVRAMDeletePropertyKey)) {
 466                 tmpStr = OSDynamicCast(OSString, object);
 467                 if (tmpStr != 0) {
 468                         key = OSSymbol::withString(tmpStr);
 469                         removeProperty(key);
 470                         key->release();
 471                         result = true;
 472                 } else {
 473                         result = false;
 474                 }
 475     } else if(key->isEqualTo(kIONVRAMSyncNowPropertyKey)) {
 476                 tmpStr = OSDynamicCast(OSString, object);
 477                 if (tmpStr != 0) {
 478
 479                         result = true; // We are not going to gaurantee sync, this is best effort
 480
 481                         if(safeToSync())
 482                                 sync();
 483
 484                 } else {
 485                         result = false;
 486                 }
 487         }
 488         else {
 489                 result = setProperty(key, object);
 490     }
 491
 492   }
 493
 494   iter->release();
 495
 496   if (result) return kIOReturnSuccess;
 497   else return kIOReturnError;
 498 }
 499
 500 IOReturn IODTNVRAM::readXPRAM(IOByteCount offset, UInt8 *buffer,
 501                               IOByteCount length)
 502 {
 503   return kIOReturnUnsupported;
 504 }
 505
 506 IOReturn IODTNVRAM::writeXPRAM(IOByteCount offset, UInt8 *buffer,
 507                                IOByteCount length)
 508 {
 509   return kIOReturnUnsupported;
 510 }
 511
 512 IOReturn IODTNVRAM::readNVRAMProperty(IORegistryEntry *entry,
 513                                       const OSSymbol **name,
 514                                       OSData **value)
 515 {
 516   IOReturn err;
 517
 518   err = readNVRAMPropertyType1(entry, name, value);
 519
 520   return err;
 521 }
 522
 523 IOReturn IODTNVRAM::writeNVRAMProperty(IORegistryEntry *entry,
 524                                        const OSSymbol *name,
 525                                        OSData *value)
 526 {
 527   IOReturn err;
 528
 529   err = writeNVRAMPropertyType1(entry, name, value);
 530
 531   return err;
 532 }
 533
 534 OSDictionary *IODTNVRAM::getNVRAMPartitions(void)
 535 {
 536   return _nvramPartitionLengths;
 537 }
 538
 539 IOReturn IODTNVRAM::readNVRAMPartition(const OSSymbol *partitionID,
 540                                        IOByteCount offset, UInt8 *buffer,
 541                                        IOByteCount length)
 542 {
 543   OSNumber *partitionOffsetNumber, *partitionLengthNumber;
 544   UInt32   partitionOffset, partitionLength;
 545
 546   partitionOffsetNumber =
 547     (OSNumber *)_nvramPartitionOffsets->getObject(partitionID);
 548   partitionLengthNumber =
 549     (OSNumber *)_nvramPartitionLengths->getObject(partitionID);
 550
 551   if ((partitionOffsetNumber == 0) || (partitionLengthNumber == 0))
 552     return kIOReturnNotFound;
 553
 554   partitionOffset = partitionOffsetNumber->unsigned32BitValue();
 555   partitionLength = partitionLengthNumber->unsigned32BitValue();
 556
 557   if ((buffer == 0) || (length == 0) ||
 558       (offset + length > partitionLength))
 559     return kIOReturnBadArgument;
 560
 561   bcopy(_nvramImage + partitionOffset + offset, buffer, length);
 562
 563   return kIOReturnSuccess;
 564 }
 565
 566 IOReturn IODTNVRAM::writeNVRAMPartition(const OSSymbol *partitionID,
 567                                         IOByteCount offset, UInt8 *buffer,
 568                                         IOByteCount length)
 569 {
 570   OSNumber *partitionOffsetNumber, *partitionLengthNumber;
 571   UInt32   partitionOffset, partitionLength;
 572
 573   partitionOffsetNumber =
 574     (OSNumber *)_nvramPartitionOffsets->getObject(partitionID);
 575   partitionLengthNumber =
 576     (OSNumber *)_nvramPartitionLengths->getObject(partitionID);
 577
 578   if ((partitionOffsetNumber == 0) || (partitionLengthNumber == 0))
 579     return kIOReturnNotFound;
 580
 581   partitionOffset = partitionOffsetNumber->unsigned32BitValue();
 582   partitionLength = partitionLengthNumber->unsigned32BitValue();
 583
 584   if ((buffer == 0) || (length == 0) ||
 585       (offset + length > partitionLength))
 586     return kIOReturnBadArgument;
 587
 588   bcopy(buffer, _nvramImage + partitionOffset + offset, length);
 589
 590   _nvramImageDirty = true;
 591
 592   return kIOReturnSuccess;
 593 }
 594
 595 IOByteCount IODTNVRAM::savePanicInfo(UInt8 *buffer, IOByteCount length)
 596 {
 597   if ((_piImage == 0) || (length <= 0)) return 0;
 598
 599   if (length > (_piPartitionSize - 4))
 600     length = _piPartitionSize - 4;
 601
 602   // Save the Panic Info.
 603   bcopy(buffer, _piImage + 4, length);
 604
 605   // Save the Panic Info length.
 606   *(UInt32 *)_piImage = length;
 607
 608   _nvramImageDirty = true;
 609   /*
 610    * This prevents OF variables from being committed if the system has panicked
 611    */
 612   _systemPaniced = true;
 613   /* The call to sync() forces the NVRAM controller to write the panic info
 614    * partition to NVRAM.
 615    */
 616   sync();
 617
 618   return length;
 619 }
 620
 621 // Private methods
 622
 623 UInt8 IODTNVRAM::calculatePartitionChecksum(UInt8 *partitionHeader)
 624 {
 625   UInt8 cnt, isum, csum = 0;
 626
 627   for (cnt = 0; cnt < 0x10; cnt++) {
 628     isum = csum + partitionHeader[cnt];
 629     if (isum < csum) isum++;
 630     csum = isum;
 631   }
 632
 633   return csum;
 634 }
 635
 636 IOReturn IODTNVRAM::initOFVariables(void)
 637 {
 638   UInt32            cnt;
 639   UInt8             *propName, *propData;
 640   UInt32            propNameLength, propDataLength;
 641   const OSSymbol    *propSymbol;
 642   OSObject          *propObject;
 643
 644   if (_ofImage == 0) return kIOReturnNotReady;
 645
 646   _ofDict = OSDictionary::withCapacity(1);
 647   _ofLock = IOLockAlloc();
 648   if (!_ofDict || !_ofLock) return kIOReturnNoMemory;
 649
 650   cnt = 0;
 651   while (cnt < _ofPartitionSize) {
 652     // Break if there is no name.
 653     if (_ofImage[cnt] == '\0') break;
 654
 655     // Find the length of the name.
 656     propName = _ofImage + cnt;
 657     for (propNameLength = 0; (cnt + propNameLength) < _ofPartitionSize;
 658          propNameLength++) {
 659       if (_ofImage[cnt + propNameLength] == '=') break;
 660     }
 661
 662     // Break if the name goes past the end of the partition.
 663     if ((cnt + propNameLength) >= _ofPartitionSize) break;
 664     cnt += propNameLength + 1;
 665
 666     propData = _ofImage + cnt;
 667     for (propDataLength = 0; (cnt + propDataLength) < _ofPartitionSize;
 668          propDataLength++) {
 669       if (_ofImage[cnt + propDataLength] == '\0') break;
 670     }
 671
 672     // Break if the data goes past the end of the partition.
 673     if ((cnt + propDataLength) >= _ofPartitionSize) break;
 674     cnt += propDataLength + 1;
 675
 676     if (convertPropToObject(propName, propNameLength,
 677                             propData, propDataLength,
 678                             &propSymbol, &propObject)) {
 679       _ofDict->setObject(propSymbol, propObject);
 680       propSymbol->release();
 681       propObject->release();
 682     }
 683   }
 684
 685   // Create the boot-args property if it is not in the dictionary.
 686   if (_ofDict->getObject("boot-args") == 0) {
 687     propObject = OSString::withCStringNoCopy("");
 688     if (propObject != 0) {
 689       _ofDict->setObject("boot-args", propObject);
 690       propObject->release();
 691     }
 692   }
 693
 694   // Create the 'aapl,panic-info' property if needed.
 695   if (_piImage != 0) {
 696     propDataLength = *(UInt32 *)_piImage;
 697     if ((propDataLength != 0) && (propDataLength <= (_piPartitionSize - 4))) {
 698       propObject = OSData::withBytes(_piImage + 4, propDataLength);
 699       _ofDict->setObject(kIODTNVRAMPanicInfoKey, propObject);
 700       propObject->release();
 701
 702       // Clear the length from _piImage and mark dirty.
 703       *(UInt32 *)_piImage = 0;
 704       _nvramImageDirty = true;
 705     }
 706   }
 707
 708   return kIOReturnSuccess;
 709 }
 710
 711 IOReturn IODTNVRAM::syncOFVariables(void)
 712 {
 713   bool                 ok;
 714   UInt32               length, maxLength;
 715   UInt8                *buffer, *tmpBuffer;
 716   const OSSymbol       *tmpSymbol;
 717   OSObject             *tmpObject;
 718   OSCollectionIterator *iter;
 719
 720   if ((_ofImage == 0) || (_ofDict == 0)) return kIOReturnNotReady;
 721
 722   if (!_ofImageDirty) return kIOReturnSuccess;
 723
 724   buffer = tmpBuffer = IONew(UInt8, _ofPartitionSize);
 725   if (buffer == 0) return kIOReturnNoMemory;
 726   bzero(buffer, _ofPartitionSize);
 727
 728   ok = true;
 729   maxLength = _ofPartitionSize;
 730
 731   IOLockLock(_ofLock);
 732   iter = OSCollectionIterator::withCollection(_ofDict);
 733   if (iter == 0) ok = false;
 734
 735   while (ok) {
 736     tmpSymbol = OSDynamicCast(OSSymbol, iter->getNextObject());
 737     if (tmpSymbol == 0) break;
 738
 739     // Don't save 'aapl,panic-info'.
 740     if (tmpSymbol->isEqualTo(kIODTNVRAMPanicInfoKey)) continue;
 741
 742     tmpObject = _ofDict->getObject(tmpSymbol);
 743
 744     length = maxLength;
 745     ok = convertObjectToProp(tmpBuffer, &length, tmpSymbol, tmpObject);
 746     if (ok) {
 747       tmpBuffer += length;
 748       maxLength -= length;
 749     }
 750   }
 751   iter->release();
 752   IOLockUnlock(_ofLock);
 753
 754   if (ok) {
 755     bcopy(buffer, _ofImage, _ofPartitionSize);
 756   }
 757
 758   IODelete(buffer, UInt8, _ofPartitionSize);
 759
 760   if (!ok) return kIOReturnBadArgument;
 761
 762   _ofImageDirty = false;
 763   _nvramImageDirty = true;
 764
 765   return kIOReturnSuccess;
 766 }
 767
 768 struct OFVariable {
 769   const char *variableName;
 770   UInt32     variableType;
 771   UInt32     variablePerm;
 772   SInt32     variableOffset;
 773 };
 774 typedef struct OFVariable OFVariable;
 775
 776 enum {
 777   kOWVariableOffsetNumber = 8,
 778   kOWVariableOffsetString = 17
 779 };
 780
 781 OFVariable gOFVariables[] = {
 782   {"little-endian?", kOFVariableTypeBoolean, kOFVariablePermUserRead, 0},
 783   {"real-mode?", kOFVariableTypeBoolean, kOFVariablePermUserRead, 1},
 784   {"auto-boot?", kOFVariableTypeBoolean, kOFVariablePermUserRead, 2},
 785   {"diag-switch?", kOFVariableTypeBoolean, kOFVariablePermUserRead, 3},
 786   {"fcode-debug?", kOFVariableTypeBoolean, kOFVariablePermUserRead, 4},
 787   {"oem-banner?", kOFVariableTypeBoolean, kOFVariablePermUserRead, 5},
 788   {"oem-logo?", kOFVariableTypeBoolean, kOFVariablePermUserRead, 6},
 789   {"use-nvramrc?", kOFVariableTypeBoolean, kOFVariablePermUserRead, 7},
 790   {"use-generic?", kOFVariableTypeBoolean, kOFVariablePermUserRead, -1},
 791   {"default-mac-address?", kOFVariableTypeBoolean, kOFVariablePermUserRead,-1},
 792   {"real-base", kOFVariableTypeNumber, kOFVariablePermUserRead, 8},
 793   {"real-size", kOFVariableTypeNumber, kOFVariablePermUserRead, 9},
 794   {"virt-base", kOFVariableTypeNumber, kOFVariablePermUserRead, 10},
 795   {"virt-size", kOFVariableTypeNumber, kOFVariablePermUserRead, 11},
 796   {"load-base", kOFVariableTypeNumber, kOFVariablePermUserRead, 12},
 797   {"pci-probe-list", kOFVariableTypeNumber, kOFVariablePermUserRead, 13},
 798   {"pci-probe-mask", kOFVariableTypeNumber, kOFVariablePermUserRead, -1},
 799   {"screen-#columns", kOFVariableTypeNumber, kOFVariablePermUserRead, 14},
 800   {"screen-#rows", kOFVariableTypeNumber, kOFVariablePermUserRead, 15},
 801   {"selftest-#megs", kOFVariableTypeNumber, kOFVariablePermUserRead, 16},
 802   {"boot-device", kOFVariableTypeString, kOFVariablePermUserRead, 17},
 803   {"boot-file", kOFVariableTypeString, kOFVariablePermUserRead, 18},
 804   {"boot-screen", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 805   {"console-screen", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 806   {"diag-device", kOFVariableTypeString, kOFVariablePermUserRead, 19},
 807   {"diag-file", kOFVariableTypeString, kOFVariablePermUserRead, 20},
 808   {"input-device", kOFVariableTypeString, kOFVariablePermUserRead, 21},
 809   {"output-device", kOFVariableTypeString, kOFVariablePermUserRead, 22},
 810   {"input-device-1", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 811   {"output-device-1", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 812   {"mouse-device", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 813   {"oem-banner", kOFVariableTypeString, kOFVariablePermUserRead, 23},
 814   {"oem-logo", kOFVariableTypeString, kOFVariablePermUserRead, 24},
 815   {"nvramrc", kOFVariableTypeString, kOFVariablePermUserRead, 25},
 816   {"boot-command", kOFVariableTypeString, kOFVariablePermUserRead, 26},
 817   {"default-client-ip", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 818   {"default-server-ip", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 819   {"default-gateway-ip", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 820   {"default-subnet-mask", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 821   {"default-router-ip", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 822   {"boot-script", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 823   {"boot-args", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 824   {"aapl,pci", kOFVariableTypeData, kOFVariablePermRootOnly, -1},
 825   {"security-mode", kOFVariableTypeString, kOFVariablePermUserRead, -1},
 826   {"security-password", kOFVariableTypeData, kOFVariablePermRootOnly, -1},
 827   {"boot-image", kOFVariableTypeData, kOFVariablePermUserWrite, -1},
 828   {"com.apple.System.fp-state", kOFVariableTypeData, kOFVariablePermKernelOnly, -1},
 829   {0, kOFVariableTypeData, kOFVariablePermUserRead, -1}
 830 };
 831
 832 UInt32 IODTNVRAM::getOFVariableType(const OSSymbol *propSymbol) const
 833 {
 834   OFVariable *ofVar;
 835
 836   ofVar = gOFVariables;
 837   while (1) {
 838     if ((ofVar->variableName == 0) ||
 839         propSymbol->isEqualTo(ofVar->variableName)) break;
 840     ofVar++;
 841   }
 842
 843   return ofVar->variableType;
 844 }
 845
 846 UInt32 IODTNVRAM::getOFVariablePerm(const OSSymbol *propSymbol) const
 847 {
 848   OFVariable *ofVar;
 849
 850   ofVar = gOFVariables;
 851   while (1) {
 852     if ((ofVar->variableName == 0) ||
 853         propSymbol->isEqualTo(ofVar->variableName)) break;
 854     ofVar++;
 855   }
 856
 857   return ofVar->variablePerm;
 858 }
 859
 860 bool IODTNVRAM::getOWVariableInfo(UInt32 variableNumber, const OSSymbol **propSymbol,
 861                                   UInt32 *propType, UInt32 *propOffset)
 862 {
 863   OFVariable *ofVar;
 864
 865   ofVar = gOFVariables;
 866   while (1) {
 867     if (ofVar->variableName == 0) return false;
 868
 869     if (ofVar->variableOffset == (SInt32) variableNumber) break;
 870
 871     ofVar++;
 872   }
 873
 874   *propSymbol = OSSymbol::withCStringNoCopy(ofVar->variableName);
 875   *propType = ofVar->variableType;
 876
 877   switch (*propType) {
 878   case kOFVariableTypeBoolean :
 879     *propOffset = 1 << (31 - variableNumber);
 880     break;
 881
 882   case kOFVariableTypeNumber :
 883     *propOffset = variableNumber - kOWVariableOffsetNumber;
 884     break;
 885
 886   case kOFVariableTypeString :
 887     *propOffset = variableNumber - kOWVariableOffsetString;
 888     break;
 889   }
 890
 891   return true;
 892 }
 893
 894 bool IODTNVRAM::convertPropToObject(UInt8 *propName, UInt32 propNameLength,
 895                                     UInt8 *propData, UInt32 propDataLength,
 896                                     const OSSymbol **propSymbol,
 897                                     OSObject **propObject)
 898 {
 899   UInt32         propType;
 900   const OSSymbol *tmpSymbol;
 901   OSObject       *tmpObject;
 902   OSNumber       *tmpNumber;
 903   OSString       *tmpString;
 904
 905   // Create the symbol.
 906   propName[propNameLength] = '\0';
 907   tmpSymbol = OSSymbol::withCString((const char *)propName);
 908   propName[propNameLength] = '=';
 909   if (tmpSymbol == 0) {
 910     return false;
 911   }
 912
 913   propType = getOFVariableType(tmpSymbol);
 914
 915   // Create the object.
 916   tmpObject = 0;
 917   switch (propType) {
 918   case kOFVariableTypeBoolean :
 919     if (!strncmp("true", (const char *)propData, propDataLength)) {
 920       tmpObject = kOSBooleanTrue;
 921     } else if (!strncmp("false", (const char *)propData, propDataLength)) {
 922       tmpObject = kOSBooleanFalse;
 923     }
 924     break;
 925
 926   case kOFVariableTypeNumber :
 927     tmpNumber = OSNumber::withNumber(strtol((const char *)propData, 0, 0), 32);
 928     if (tmpNumber != 0) tmpObject = tmpNumber;
 929     break;
 930
 931   case kOFVariableTypeString :
 932     tmpString = OSString::withCString((const char *)propData);
 933     if (tmpString != 0) tmpObject = tmpString;
 934     break;
 935
 936   case kOFVariableTypeData :
 937     tmpObject = unescapeBytesToData(propData, propDataLength);
 938     break;
 939   }
 940
 941   if (tmpObject == 0) {
 942     tmpSymbol->release();
 943     return false;
 944   }
 945
 946   *propSymbol = tmpSymbol;
 947   *propObject = tmpObject;
 948
 949   return true;
 950 }
 951
 952 bool IODTNVRAM::convertObjectToProp(UInt8 *buffer, UInt32 *length,
 953                                     const OSSymbol *propSymbol, OSObject *propObject)
 954 {
 955   const UInt8    *propName;
 956   UInt32         propNameLength, propDataLength;
 957   UInt32         propType, tmpValue;
 958   OSBoolean      *tmpBoolean = 0;
 959   OSNumber       *tmpNumber = 0;
 960   OSString       *tmpString = 0;
 961   OSData         *tmpData = 0;
 962
 963   propName = (const UInt8 *)propSymbol->getCStringNoCopy();
 964   propNameLength = propSymbol->getLength();
 965   propType = getOFVariableType(propSymbol);
 966
 967   // Get the size of the data.
 968   propDataLength = 0xFFFFFFFF;
 969   switch (propType) {
 970   case kOFVariableTypeBoolean :
 971     tmpBoolean = OSDynamicCast(OSBoolean, propObject);
 972     if (tmpBoolean != 0) propDataLength = 5;
 973     break;
 974
 975   case kOFVariableTypeNumber :
 976     tmpNumber = OSDynamicCast(OSNumber, propObject);
 977     if (tmpNumber != 0) propDataLength = 10;
 978     break;
 979
 980   case kOFVariableTypeString :
 981     tmpString = OSDynamicCast(OSString, propObject);
 982     if (tmpString != 0) propDataLength = tmpString->getLength();
 983     break;
 984
 985   case kOFVariableTypeData :
 986     tmpData = OSDynamicCast(OSData, propObject);
 987     if (tmpData != 0) {
 988       tmpData = escapeDataToData(tmpData);
 989       propDataLength = tmpData->getLength();
 990     }
 991     break;
 992   }
 993
 994   // Make sure the propertySize is known and will fit.
 995   if (propDataLength == 0xFFFFFFFF) return false;
 996   if ((propNameLength + propDataLength + 2) > *length) return false;
 997
 998   // Copy the property name equal sign.
 999   buffer += snprintf((char *)buffer, *length, "%s=", propName);
1000
1001   switch (propType) {
1002   case kOFVariableTypeBoolean :
1003     if (tmpBoolean->getValue()) {
1004       strlcpy((char *)buffer, "true", *length - propNameLength);
1005     } else {
1006       strlcpy((char *)buffer, "false", *length - propNameLength);
1007     }
1008     break;
1009
1010   case kOFVariableTypeNumber :
1011     tmpValue = tmpNumber->unsigned32BitValue();
1012     if (tmpValue == 0xFFFFFFFF) {
1013       strlcpy((char *)buffer, "-1", *length - propNameLength);
1014     } else if (tmpValue < 1000) {
1015       snprintf((char *)buffer, *length - propNameLength, "%d", (uint32_t)tmpValue);
1016     } else {
1017       snprintf((char *)buffer, *length - propNameLength, "0x%x", (uint32_t)tmpValue);
1018     }
1019     break;
1020
1021   case kOFVariableTypeString :
1022     strlcpy((char *)buffer, tmpString->getCStringNoCopy(), *length - propNameLength);
1023     break;
1024
1025   case kOFVariableTypeData :
1026     bcopy(tmpData->getBytesNoCopy(), buffer, propDataLength);
1027     tmpData->release();
1028     break;
1029   }
1030
1031   propDataLength = strlen((const char *)buffer);
1032
1033   *length = propNameLength + propDataLength + 2;
1034
1035   return true;
1036 }
1037
1038
1039 UInt16 IODTNVRAM::generateOWChecksum(UInt8 *buffer)
1040 {
1041   UInt32 cnt, checksum = 0;
1042   UInt16 *tmpBuffer = (UInt16 *)buffer;
1043
1044   for (cnt = 0; cnt < _ofPartitionSize / 2; cnt++)
1045     checksum += tmpBuffer[cnt];
1046
1047   return checksum % 0x0000FFFF;
1048 }
1049
1050 bool IODTNVRAM::validateOWChecksum(UInt8 *buffer)
1051 {
1052   UInt32 cnt, checksum, sum = 0;
1053   UInt16 *tmpBuffer = (UInt16 *)buffer;
1054
1055   for (cnt = 0; cnt < _ofPartitionSize / 2; cnt++)
1056     sum += tmpBuffer[cnt];
1057
1058   checksum = (sum >> 16) + (sum & 0x0000FFFF);
1059   if (checksum == 0x10000) checksum--;
1060   checksum = (checksum ^ 0x0000FFFF) & 0x0000FFFF;
1061
1062   return checksum == 0;
1063 }
1064
1065 void IODTNVRAM::updateOWBootArgs(const OSSymbol *key, OSObject *value)
1066 {
1067   bool        wasBootArgs, bootr = false;
1068   UInt32      cnt;
1069   OSString    *tmpString, *bootCommand, *bootArgs = 0;
1070   const UInt8 *bootCommandData, *bootArgsData;
1071   UInt8       *tmpData;
1072   UInt32      bootCommandDataLength, bootArgsDataLength, tmpDataLength;
1073
1074   tmpString = OSDynamicCast(OSString, value);
1075   if (tmpString == 0) return;
1076
1077   if (key->isEqualTo("boot-command")) {
1078     wasBootArgs = false;
1079     bootCommand = tmpString;
1080   } else if (key->isEqualTo("boot-args")) {
1081     wasBootArgs = true;
1082     bootArgs = tmpString;
1083     bootCommand = OSDynamicCast(OSString, _ofDict->getObject("boot-command"));
1084     if (bootCommand == 0) return;
1085   } else return;
1086
1087   bootCommandData = (const UInt8 *)bootCommand->getCStringNoCopy();
1088   bootCommandDataLength = bootCommand->getLength();
1089
1090   if (bootCommandData == 0) return;
1091
1092   for (cnt = 0; cnt < bootCommandDataLength; cnt++) {
1093     if ((bootCommandData[cnt] == 'b') &&
1094         !strncmp("bootr", (const char *)bootCommandData + cnt, 5)) {
1095       cnt += 5;
1096       while (bootCommandData[cnt] == ' ') cnt++;
1097       bootr = true;
1098       break;
1099     }
1100   }
1101   if (!bootr) {
1102     _ofDict->removeObject("boot-args");
1103     return;
1104   }
1105
1106   if (wasBootArgs) {
1107     bootArgsData = (const UInt8 *)bootArgs->getCStringNoCopy();
1108     bootArgsDataLength = bootArgs->getLength();
1109     if (bootArgsData == 0) return;
1110
1111     tmpDataLength = cnt + bootArgsDataLength;
1112     tmpData = IONew(UInt8, tmpDataLength + 1);
1113     if (tmpData == 0) return;
1114
1115     cnt -= strlcpy((char *)tmpData, (const char *)bootCommandData, cnt);
1116     strlcat((char *)tmpData, (const char *)bootArgsData, cnt);
1117
1118     bootCommand = OSString::withCString((const char *)tmpData);
1119     if (bootCommand != 0) {
1120       _ofDict->setObject("boot-command", bootCommand);
1121       bootCommand->release();
1122     }
1123
1124     IODelete(tmpData, UInt8, tmpDataLength + 1);
1125   } else {
1126     bootArgs = OSString::withCString((const char *)(bootCommandData + cnt));
1127     if (bootArgs != 0) {
1128       _ofDict->setObject("boot-args", bootArgs);
1129       bootArgs->release();
1130     }
1131   }
1132 }
1133
1134 bool IODTNVRAM::searchNVRAMProperty(IONVRAMDescriptor *hdr, UInt32 *where)
1135 {
1136   return false;
1137 }
1138
1139 IOReturn IODTNVRAM::readNVRAMPropertyType0(IORegistryEntry *entry,
1140                                            const OSSymbol **name,
1141                                            OSData **value)
1142 {
1143   return kIOReturnUnsupported;
1144 }
1145
1146
1147 IOReturn IODTNVRAM::writeNVRAMPropertyType0(IORegistryEntry *entry,
1148                                             const OSSymbol *name,
1149                                             OSData *value)
1150 {
1151   return kIOReturnUnsupported;
1152 }
1153
1154
1155 OSData *IODTNVRAM::unescapeBytesToData(const UInt8 *bytes, UInt32 length)
1156 {
1157   OSData *data = 0;
1158   UInt32 totalLength = 0;
1159   UInt32 cnt, cnt2;
1160   UInt8  byte;
1161   bool   ok;
1162
1163   // Calculate the actual length of the data.
1164   ok = true;
1165   totalLength = 0;
1166   for (cnt = 0; cnt < length;) {
1167     byte = bytes[cnt++];
1168     if (byte == 0xFF) {
1169       byte = bytes[cnt++];
1170       if (byte == 0x00) {
1171         ok = false;
1172         break;
1173       }
1174       cnt2 = byte & 0x7F;
1175     } else
1176       cnt2 = 1;
1177     totalLength += cnt2;
1178   }
1179
1180   if (ok) {
1181     // Create an empty OSData of the correct size.
1182     data = OSData::withCapacity(totalLength);
1183     if (data != 0) {
1184       for (cnt = 0; cnt < length;) {
1185         byte = bytes[cnt++];
1186         if (byte == 0xFF) {
1187           byte = bytes[cnt++];
1188           cnt2 = byte & 0x7F;
1189           byte = (byte & 0x80) ? 0xFF : 0x00;
1190         } else
1191           cnt2 = 1;
1192         data->appendByte(byte, cnt2);
1193       }
1194     }
1195   }
1196
1197   return data;
1198 }
1199
1200 OSData * IODTNVRAM::escapeDataToData(OSData * value)
1201 {
1202   OSData *       result;
1203   const UInt8 *  startPtr;
1204   const UInt8 *  endPtr;
1205   const UInt8 *  wherePtr;
1206   UInt8          byte;
1207   bool           ok = true;
1208
1209   wherePtr = (const UInt8 *) value->getBytesNoCopy();
1210   endPtr = wherePtr + value->getLength();
1211
1212   result = OSData::withCapacity(endPtr - wherePtr);
1213   if (!result)
1214     return result;
1215
1216   while (wherePtr < endPtr) {
1217     startPtr = wherePtr;
1218     byte = *wherePtr++;
1219     if ((byte == 0x00) || (byte == 0xFF)) {
1220       for (;
1221             ((wherePtr - startPtr) < 0x80) && (wherePtr < endPtr) && (byte == *wherePtr);
1222             wherePtr++) {}
1223       ok &= result->appendByte(0xff, 1);
1224       byte = (byte & 0x80) | (wherePtr - startPtr);
1225     }
1226     ok &= result->appendByte(byte, 1);
1227   }
1228   ok &= result->appendByte(0, 1);
1229
1230   if (!ok) {
1231     result->release();
1232     result = 0;
1233   }
1234
1235   return result;
1236 }
1237
1238 static bool IsApplePropertyName(const char * propName)
1239 {
1240   char c;
1241   while ((c = *propName++)) {
1242     if ((c >= 'A') && (c <= 'Z'))
1243       break;
1244   }
1245
1246   return (c == 0);
1247 }
1248
1249 IOReturn IODTNVRAM::readNVRAMPropertyType1(IORegistryEntry *entry,
1250                                            const OSSymbol **name,
1251                                            OSData **value)
1252 {
1253   IOReturn    err = kIOReturnNoResources;
1254   OSData      *data;
1255   const UInt8 *startPtr;
1256   const UInt8 *endPtr;
1257   const UInt8 *wherePtr;
1258   const UInt8 *nvPath = 0;
1259   const char  *nvName = 0;
1260   const char  *resultName = 0;
1261   const UInt8 *resultValue = 0;
1262   UInt32       resultValueLen = 0;
1263   UInt8       byte;
1264
1265   if (_ofDict == 0) return err;
1266
1267   IOLockLock(_ofLock);
1268   data = OSDynamicCast(OSData, _ofDict->getObject(_registryPropertiesKey));
1269   IOLockUnlock(_ofLock);
1270
1271   if (data == 0) return err;
1272
1273   startPtr = (const UInt8 *) data->getBytesNoCopy();
1274   endPtr = startPtr + data->getLength();
1275
1276   wherePtr = startPtr;
1277   while (wherePtr < endPtr) {
1278     byte = *(wherePtr++);
1279     if (byte)
1280       continue;
1281
1282     if (nvPath == 0)
1283       nvPath = startPtr;
1284     else if (nvName == 0)
1285       nvName = (const char *) startPtr;
1286     else {
1287       IORegistryEntry * compareEntry = IORegistryEntry::fromPath((const char *) nvPath, gIODTPlane);
1288       if (compareEntry)
1289         compareEntry->release();
1290       if (entry == compareEntry) {
1291         bool appleProp = IsApplePropertyName(nvName);
1292         if (!appleProp || !resultName) {
1293           resultName     = nvName;
1294           resultValue    = startPtr;
1295           resultValueLen = wherePtr - startPtr - 1;
1296         }
1297         if (!appleProp)
1298           break;
1299       }
1300       nvPath = 0;
1301       nvName = 0;
1302     }
1303     startPtr = wherePtr;
1304   }
1305   if (resultName) {
1306     *name = OSSymbol::withCString(resultName);
1307     *value = unescapeBytesToData(resultValue, resultValueLen);
1308     if ((*name != 0) && (*value != 0))
1309       err = kIOReturnSuccess;
1310     else
1311       err = kIOReturnNoMemory;
1312   }
1313   return err;
1314 }
1315
1316 IOReturn IODTNVRAM::writeNVRAMPropertyType1(IORegistryEntry *entry,
1317                                             const OSSymbol *propName,
1318                                             OSData *value)
1319 {
1320   OSData       *oldData;
1321   OSData       *data = 0;
1322   const UInt8  *startPtr;
1323   const UInt8  *propStart;
1324   const UInt8  *endPtr;
1325   const UInt8  *wherePtr;
1326   const UInt8  *nvPath = 0;
1327   const char   *nvName = 0;
1328   const char * comp;
1329   const char * name;
1330   UInt8        byte;
1331   bool         ok = true;
1332   bool         settingAppleProp;
1333
1334   if (_ofDict == 0) return kIOReturnNoResources;
1335
1336   settingAppleProp = IsApplePropertyName(propName->getCStringNoCopy());
1337
1338   // copy over existing properties for other entries
1339
1340   IOLockLock(_ofLock);
1341
1342   oldData = OSDynamicCast(OSData, _ofDict->getObject(_registryPropertiesKey));
1343   if (oldData) {
1344     startPtr = (const UInt8 *) oldData->getBytesNoCopy();
1345     endPtr = startPtr + oldData->getLength();
1346
1347     propStart = startPtr;
1348     wherePtr = startPtr;
1349     while (wherePtr < endPtr) {
1350       byte = *(wherePtr++);
1351       if (byte)
1352         continue;
1353       if (nvPath == 0)
1354         nvPath = startPtr;
1355       else if (nvName == 0)
1356         nvName = (const char *) startPtr;
1357       else {
1358         IORegistryEntry * compareEntry = IORegistryEntry::fromPath((const char *) nvPath, gIODTPlane);
1359         if (compareEntry)
1360           compareEntry->release();
1361         if (entry == compareEntry) {
1362           if ((settingAppleProp && propName->isEqualTo(nvName))
1363            || (!settingAppleProp && !IsApplePropertyName(nvName))) {
1364              // delete old property (nvPath -> wherePtr)
1365              data = OSData::withBytes(propStart, nvPath - propStart);
1366              if (data)
1367                ok &= data->appendBytes(wherePtr, endPtr - wherePtr);
1368              break;
1369           }
1370         }
1371         nvPath = 0;
1372         nvName = 0;
1373       }
1374
1375       startPtr = wherePtr;
1376     }
1377   }
1378
1379   // make the new property
1380
1381   if (!data) {
1382     if (oldData)
1383       data = OSData::withData(oldData);
1384     else
1385       data = OSData::withCapacity(16);
1386     if (!data) ok = false;
1387   }
1388
1389   if (ok && value && value->getLength()) do {
1390     // get entries in path
1391     OSArray *array = OSArray::withCapacity(5);
1392     if (!array) {
1393       ok = false;
1394       break;
1395     }
1396     do
1397       array->setObject(entry);
1398     while ((entry = entry->getParentEntry(gIODTPlane)));
1399
1400     // append path
1401     for (int i = array->getCount() - 3;
1402          (entry = (IORegistryEntry *) array->getObject(i));
1403          i--) {
1404
1405       name = entry->getName(gIODTPlane);
1406       comp = entry->getLocation(gIODTPlane);
1407       if (comp) ok &= data->appendBytes("/@", 2);
1408       else {
1409         if (!name) continue;
1410         ok &= data->appendByte('/', 1);
1411         comp = name;
1412       }
1413       ok &= data->appendBytes(comp, strlen(comp));
1414     }
1415     ok &= data->appendByte(0, 1);
1416     array->release();
1417
1418     // append prop name
1419     ok &= data->appendBytes(propName->getCStringNoCopy(), propName->getLength() + 1);
1420
1421     // append escaped data
1422     oldData = escapeDataToData(value);
1423     ok &= (oldData != 0);
1424     if (ok) ok &= data->appendBytes(oldData);
1425
1426   } while (false);
1427
1428   if (ok) {
1429     ok = _ofDict->setObject(_registryPropertiesKey, data);
1430     if (ok) _ofImageDirty = true;
1431   }
1432
1433   IOLockUnlock(_ofLock);
1434   if (data) data->release();
1435
1436   return ok ? kIOReturnSuccess : kIOReturnNoMemory;
1437 }
1438
1439 bool IODTNVRAM::safeToSync(void)
1440 {
1441     AbsoluteTime delta;
1442     UInt64       delta_ns;
1443     SInt32       delta_secs;
1444
1445         // delta interval went by
1446         clock_get_uptime(&delta);
1447
1448     // Figure it in seconds.
1449     absolutetime_to_nanoseconds(delta, &delta_ns);
1450     delta_secs = (SInt32)(delta_ns / NSEC_PER_SEC);
1451
1452         if ((delta_secs > (_lastDeviceSync + MIN_SYNC_NOW_INTERVAL)) || _freshInterval)
1453         {
1454                 _lastDeviceSync = delta_secs;
1455                 _freshInterval = FALSE;
1456                 return TRUE;
1457         }
1458
1459         return FALSE;
1460 }