bool
IOUSBNub::USBCompareProperty( OSDictionary * matching, const OSSymbol * key )
{
// We return success iff we match the key in the dictionary with the key in
// the property table.
//
OSObject *value;
bool matches = false;
OSObject *myProperty = NULL;
value = matching->getObject( key );
if ( value)
{
myProperty = copyProperty(key);
if (myProperty)
{
matches = value->isEqualTo( myProperty);
myProperty->release();
}
}
else
matches = false;
return matches;
}
OSObject * FileNVRAM::getProperty(const OSSymbol *aKey) const
{
OSObject* value = IOService::getProperty(aKey);
if (value)
{
OSSerialize *s = OSSerialize::withCapacity(1000);
if (value->serialize(s))
{
LOG(INFO, "getProperty(%s) = %s called\n", aKey->getCStringNoCopy(), s->text());
}
else
{
LOG(INFO, "getProperty(%s) = %p called\n", aKey->getCStringNoCopy(), value);
}
s->release();
}
else
{
// Ignore BSD Name for now in logs, it pollutes
if (!aKey->isEqualTo("BSD Name"))
{
LOG(INFO, "getProperty(%s) = %p called\n", aKey->getCStringNoCopy(), (void*)NULL);
}
}
return value;
}
//---------------------------------------------------------------------------
// Compare the properties in the supplied table to this object's properties.
bool CompareProperty( IOService * owner, OSDictionary * matching, const char * key, SInt32 * score, SInt32 increment)
{
// We return success if we match the key in the dictionary with the key in
// the property table, or if the prop isn't present
//
OSObject * value;
OSObject * property;
bool matches = true;
value = matching->getObject( key );
if( value)
{
property = owner->copyProperty( key );
if ( property )
{
matches = value->isEqualTo( property );
if (matches && score)
*score += increment;
property->release();
}
else
matches = false;
}
return matches;
}
IOACPIPlatformDevice * ACPIBacklightPanel::getChildWithBacklightMethods(IOACPIPlatformDevice * GPUdevice)
{
DbgLog("%s::%s()\n", this->getName(),__FUNCTION__);
OSIterator * iter = NULL;
OSObject * entry;
iter = GPUdevice->getChildIterator(gIOACPIPlane);
if (iter)
{
while ( true )
{
entry = iter->getNextObject();
if (NULL == entry)
break;
if (entry->metaCast("IOACPIPlatformDevice"))
{
IOACPIPlatformDevice * device = (IOACPIPlatformDevice *) entry;
if (hasBacklightMethods(device))
{
IOLog("ACPIBacklight: Found Backlight Device: %s\n", device->getName());
return device;
}
}
else {
DbgLog("%s: getChildWithBacklightMethods() Cast Error\n", this->getName());
}
} //end while
iter->release();
DbgLog("%s: getChildWithBacklightMethods() iterator end\n", this->getName());
}
return NULL;
}
IOMapper * IOMapper::copyMapperForDevice(IOService * device)
{
OSObject * obj;
IOMapper * mapper;
OSDictionary * matching;
obj = device->copyProperty("iommu-parent");
if (!obj)
return (NULL);
if ((mapper = OSDynamicCast(IOMapper, obj)))
return (mapper);
matching = IOService::propertyMatching(gIOMapperIDKey, obj);
if (matching)
{
mapper = OSDynamicCast(IOMapper, IOService::waitForMatchingService(matching));
matching->release();
}
if (mapper)
device->setProperty("iommu-parent", mapper);
else
obj->release();
return (mapper);
}
kern_return_t pmem_iokit_enumerate_pci(pmem_pci_callback_t callback,
void *ctx) {
kern_return_t error = KERN_FAILURE;
OSObject *obj = nullptr;
OSDictionary *search = nullptr;
OSIterator *iter = nullptr;
IOPCIDevice *dev = nullptr;
IODeviceMemory *mem = nullptr;
IOItemCount mem_count = 0;
int cmp;
search = IOService::serviceMatching("IOPCIDevice");
iter = IOService::getMatchingServices(search);
if (!iter) {
pmem_error("Couldn't find any PCI devices.");
goto bail;
}
while ((obj = iter->getNextObject())) {
cmp = strncmp("IOPCIDevice",
obj->getMetaClass()->getClassName(),
strlen("IOPCIDevice"));
if (cmp != 0) {
// I haven't seen the above return anything other than
// PCI devices, but Apple's documentation is sparse (which
// is a nice word for what it is) and doesn't actually
// say anything about what's guaranteed to be returned.
// I'd just as well rather not chance it.
pmem_warn("Expected IOPCIDevice but got %s - skipping.",
obj->getMetaClass()->getClassName());
continue;
}
dev = (IOPCIDevice *)obj;
mem_count = dev->getDeviceMemoryCount();
pmem_debug("Found PCI device %s", dev->getName());
for (unsigned idx = 0; idx < mem_count; ++idx) {
pmem_debug("Memory segment %d found.", idx);
mem = dev->getDeviceMemoryWithIndex(idx);
pmem_signal_t signal = callback(dev, mem, idx, ctx);
if (signal == pmem_Stop) {
error = KERN_FAILURE;
goto bail;
}
}
}
error = KERN_SUCCESS;
bail:
if (iter) {
iter->release();
}
if (search) {
search->release();
}
return error;
}
void iokit_post_constructor_init(void)
{
IORegistryEntry * root;
OSObject * obj;
root = IORegistryEntry::initialize();
assert( root );
IOService::initialize();
IOCatalogue::initialize();
IOStatistics::initialize();
OSKext::initialize();
IOUserClient::initialize();
IOMemoryDescriptor::initialize();
IORootParent::initialize();
// Initializes IOPMinformeeList class-wide shared lock
IOPMinformeeList::getSharedRecursiveLock();
obj = OSString::withCString( version );
assert( obj );
if( obj ) {
root->setProperty( kIOKitBuildVersionKey, obj );
obj->release();
}
obj = IOKitDiagnostics::diagnostics();
if( obj ) {
root->setProperty( kIOKitDiagnosticsKey, obj );
obj->release();
}
}
/******************************************************************************
* ACPIDebug::PrintTraces
******************************************************************************/
void ACPIDebug::PrintTraces()
{
for (;;)
{
// see if there are any trace items in the RING
UInt32 count = 0;
if (kIOReturnSuccess != m_pDevice->evaluateInteger("COUN", &count))
{
IOLog("ACPIDebug: evaluateObject of COUN method failed\n");
break;
}
if (!count)
break;
// gather the next item from RING and print it
OSObject* debug;
if (kIOReturnSuccess == m_pDevice->evaluateObject("FTCH", &debug) &&
NULL != debug)
{
static char buf[2048];
// got a valid object, format and print it...
FormatDebugString(debug, buf, sizeof(buf)/sizeof(buf[0]));
IOLog("ACPIDebug: %s\n", buf);
debug->release();
}
}
}
bool IOHIDEventSystemUserClient::
initWithTask(task_t owningTask, void * /* security_id */, UInt32 /* type */)
{
bool result = false;
OSObject* entitlement = copyClientEntitlement(owningTask, kIOHIDSystemUserAccessServiceEntitlement);
if (entitlement) {
result = (entitlement == kOSBooleanTrue);
entitlement->release();
}
if (!result) {
proc_t process;
process = (proc_t)get_bsdtask_info(owningTask);
char name[255];
bzero(name, sizeof(name));
proc_name(proc_pid(process), name, sizeof(name));
HIDLogError("%s is not entitled", name);
goto exit;
}
result = super::init();
require_action(result, exit, HIDLogError("failed"));
exit:
return result;
}
bool IOFireWireMagicMatchingNub::matchPropertyTable( OSDictionary * table )
{
OSObject *clientClass;
clientClass = table->getObject("IOClass");
if(!clientClass)
return false;
return clientClass->isEqualTo( getProperty( "IODesiredChild" ) );
}
IOReturn
IOI2CDevice::newUserClient(
task_t owningTask,
void *securityID,
UInt32 type,
OSDictionary *properties,
IOUserClient **handler)
{
IOUserClient *client;
OSObject *temp;
DLOG("%s::newUserClient\n", getName());
if (type != kIOI2CUserClientType)
return super::newUserClient(owningTask,securityID,type,properties,handler);
if (IOUserClient::clientHasPrivilege(securityID, "root") != kIOReturnSuccess)
{
ERRLOG("%s::newUserClient: Can't create user client, not privileged\n", getName());
return kIOReturnNotPrivileged;
}
temp = OSMetaClass::allocClassWithName("IOI2CUserClient");
if (!temp)
return kIOReturnNoMemory;
if (OSDynamicCast(IOUserClient, temp))
client = (IOUserClient *) temp;
else
{
temp->release();
return kIOReturnUnsupported;
}
if ( !client->initWithTask(owningTask, securityID, type, properties) )
{
client->release();
return kIOReturnBadArgument;
}
if ( !client->attach(this) )
{
client->release();
return kIOReturnUnsupported;
}
if ( !client->start(this) )
{
client->detach(this);
client->release();
return kIOReturnUnsupported;
}
*handler = client;
return kIOReturnSuccess;
}
IOMapper * IOMapper::copyMapperForDeviceWithIndex(IOService * device, unsigned int index)
{
OSData *data;
OSObject * obj;
IOMapper * mapper = NULL;
OSDictionary * matching;
obj = device->copyProperty("iommu-parent");
if (!obj) return (NULL);
if ((mapper = OSDynamicCast(IOMapper, obj))) goto found;
if ((data = OSDynamicCast(OSData, obj)))
{
if (index >= data->getLength() / sizeof(UInt32)) goto done;
data = OSData::withBytesNoCopy((UInt32 *)data->getBytesNoCopy() + index, sizeof(UInt32));
if (!data) goto done;
matching = IOService::propertyMatching(gIOMapperIDKey, data);
data->release();
}
else
matching = IOService::propertyMatching(gIOMapperIDKey, obj);
if (matching)
{
mapper = OSDynamicCast(IOMapper, IOService::waitForMatchingService(matching));
matching->release();
}
done:
if (obj) obj->release();
found:
if (mapper)
{
if (!mapper->fAllocName)
{
char name[MACH_ZONE_NAME_MAX_LEN];
char kmodname[KMOD_MAX_NAME];
vm_tag_t tag;
uint32_t kmodid;
tag = IOMemoryTag(kernel_map);
if (!(kmodid = vm_tag_get_kext(tag, &kmodname[0], KMOD_MAX_NAME)))
{
snprintf(kmodname, sizeof(kmodname), "%d", tag);
}
snprintf(name, sizeof(name), "%s.DMA.%s", kmodname, device->getName());
mapper->fAllocName = kern_allocation_name_allocate(name, 16);
}
}
return (mapper);
}
bool CompareDeviceUsage( IOService * owner, OSDictionary * matching, SInt32 * score, SInt32 increment)
{
// We return success if we match the key in the dictionary with the key in
// the property table, or if the prop isn't present
//
OSObject * usage;
OSObject * usagePage;
OSArray * functions;
OSDictionary * pair;
bool matches = true;
int count;
usage = matching->getObject( kIOHIDDeviceUsageKey );
usagePage = matching->getObject( kIOHIDDeviceUsagePageKey );
functions = OSDynamicCast(OSArray, owner->copyProperty( kIOHIDDeviceUsagePairsKey ));
if ( functions )
{
if ( usagePage || usage )
{
count = functions->getCount();
for (int i=0; i<count; i++)
{
if ( !(pair = (OSDictionary *)functions->getObject(i)) )
continue;
if ( !usagePage ||
!(matches = usagePage->isEqualTo(pair->getObject(kIOHIDDeviceUsagePageKey))) )
continue;
if ( score && !usage )
{
*score += increment / 2;
break;
}
if ( !usage ||
!(matches = usage->isEqualTo(pair->getObject(kIOHIDDeviceUsageKey))) )
continue;
if ( score )
*score += increment;
break;
}
}
functions->release();
} else {
matches = false;
}
return matches;
}
void SessionObjectTests::testDestroyObjectFails()
{
// Create test object instance
SessionObject testObject(NULL, 1, 1);
CPPUNIT_ASSERT(testObject.isValid());
OSObject* testIF = (OSObject*) &testObject;
CPPUNIT_ASSERT(!testIF->destroyObject());
}
OSObject * FileNVRAM::copyProperty(const char *aKey) const
{
OSObject* prop = getProperty(aKey);
if (prop)
{
prop->retain();
}
return prop;
}
void USBInterfaceShim::setInterface(IOService* interface)
{
OSObject* prev = m_pInterface;
m_pInterface = OSDynamicCast(IOUSBInterface, interface);
if (m_pInterface)
m_pInterface->retain();
if (prev)
prev->release();
}
void USBDeviceShim::setDevice(IOService* provider)
{
OSObject* prev = m_pDevice;
m_pDevice = OSDynamicCast(IOUSBDevice, provider);
if (m_pDevice)
m_pDevice->retain();
if (prev)
prev->release();
}
bool FakeSMC::start(IOService *provider)
{
if (!super::start(provider))
return false;
int arg_value = 1;
// Check if we have SMC already
if (OSDictionary *matching = serviceMatching("IOACPIPlatformDevice")) {
if (OSIterator *iterator = getMatchingServices(matching)) {
OSString *smcNameProperty = OSString::withCString("APP0001");
while (IOService *service = (IOService*)iterator->getNextObject()) {
OSObject *serviceNameProperty = service->getProperty("name");
if (serviceNameProperty && serviceNameProperty->isEqualTo(smcNameProperty)) {
HWSensorsFatalLog("SMC device detected, will not create another one");
return false;
}
}
OSSafeRelease(iterator);
}
OSSafeRelease(matching);
}
if (!smcDevice->initAndStart(provider, this)) {
HWSensorsInfoLog("failed to initialize SMC device");
return false;
}
registerService();
// Load keys from NVRAM
if (PE_parse_boot_argn("-fakesmc-use-nvram", &arg_value, sizeof(arg_value))) {
if (UInt32 count = smcDevice->loadKeysFromNVRAM())
HWSensorsInfoLog("%d key%s loaded from NVRAM", count, count == 1 ? "" : "s");
else
HWSensorsInfoLog("NVRAM will be used to store system written keys...");
}
return true;
}
OSDictionary*
IOFireWireUserClientIniter::dictionaryDeepCopy(
OSDictionary* srcDictionary)
{
//IOLog( "IOFireWireUserClientIniter<0x%08lx>::dictionaryDeepCopy - srcDictionary = 0x%08lx\n", this, srcDictionary );
OSDictionary* result = NULL;
OSObject* srcObject = NULL;
OSCollectionIterator* srcIterator = NULL;
OSSymbol* keyObject = NULL;
result = OSDictionary::withCapacity(srcDictionary->getCount());
if (result)
{
srcIterator = OSCollectionIterator::withCollection(srcDictionary);
if (srcIterator)
{
while ( (keyObject = OSDynamicCast(OSSymbol, srcIterator->getNextObject())) )
{
srcObject = srcDictionary->getObject(keyObject);
if (OSDynamicCast(OSDictionary, srcObject))
{
srcObject = dictionaryDeepCopy((OSDictionary*)srcObject);
result->setObject(keyObject, srcObject);
// copyDictionaryProperty creates a new dictionary, so we should release
// it after we add it to our dictionary
srcObject->release();
}
else
{
result->setObject(keyObject, srcObject);
}
}
srcIterator->release();
}
}
//IOLog( "IOFireWireUserClientIniter<0x%08lx>::dictionaryDeepCopy - return\n", this );
return result;
}
OSArray * ACPIBacklightPanel::queryACPISupportedBrightnessLevels()
{
DbgLog("%s::%s()\n", this->getName(),__FUNCTION__);
OSObject * ret;
backLightDevice->evaluateObject("_BCL", &ret);
OSArray * data = OSDynamicCast(OSArray, ret);
if (data)
{
DbgLog("%s: %s _BCL %d\n", this->getName(), backLightDevice->getName(), data->getCount() );
return data;
}
else
{
DbgLog("%s: Cast Error _BCL is %s\n", this->getName(), ret ? ret->getMetaClass()->getClassName() : "ret=NULL");
}
OSSafeRelease(ret);
return NULL;
}
bool NullEthernet::initMACfromACPI()
{
bool result = false;
OSObject *ret = NULL;
IOACPIPlatformDevice* pACPI = OSDynamicCast(IOACPIPlatformDevice, m_pProvider);
if (NULL != pACPI && kIOReturnSuccess == pACPI->evaluateObject("MAC", &ret) && NULL != ret)
{
// get MAC address from DSDT if provided...
OSData* pData = OSDynamicCast(OSData, ret);
if (pData && pData->getLength() == kIOEthernetAddressSize)
{
bcopy(pData->getBytesNoCopy(), m_rgMacAddr, kIOEthernetAddressSize);
AlwaysLog("Using MAC address from DSDT: %02x:%02x:%02x:%02x:%02x:%02x\n", m_rgMacAddr[0], m_rgMacAddr[1], m_rgMacAddr[2], m_rgMacAddr[3], m_rgMacAddr[4], m_rgMacAddr[5]);
result = true;
}
ret->release();
}
return result;
}
// Received an update of a specific value
void WirelessHIDDevice::receivedUpdate(unsigned char type, unsigned char *data)
{
switch (type)
{
case 0x13: // Battery level
battery = data[0];
{
OSObject *prop = OSNumber::withNumber(battery, 8);
if (prop != NULL)
{
setProperty(kIOWirelessBatteryLevel, prop);
prop->release();
}
}
break;
default:
break;
}
}
static bool
getPCSPortMapping(
IORegistryEntry * root,
UInt32 portNum,
UInt8 * enableOffset,
UInt8 * enableMask,
UInt8 * presenceOffset,
UInt8 * presenceMask )
{
OSObject * prop;
OSData * data;
const PCSPortMap * portMap = gDefaultPortMap;
if (!root || (portNum > kSerialATAPort3) ||
root->getProperty( kSerialATAKey ) != kOSBooleanTrue)
return false;
prop = root->copyProperty( kPCSPortMapKey );
data = OSDynamicCast(OSData, prop);
if (data && (data->getLength() == sizeof(gDefaultPortMap)))
{
portMap = (const PCSPortMap *) data->getBytesNoCopy();
}
if (enableOffset)
*enableOffset = portMap[portNum].enableOffset;
if (enableMask)
*enableMask = portMap[portNum].enableMask;
if (presenceOffset)
*presenceOffset = portMap[portNum].presenceOffset;
if (presenceMask)
*presenceMask = portMap[portNum].presenceMask;
if (prop) prop->release();
return true;
}
OSReturn NoSleepExtension::readNVRAM(UInt8 *value)
{
#ifdef DEBUG
IOLog("%s[%p]::%s(%p)\n", getName(), this, __FUNCTION__, value);
#endif
OSReturn ret = kOSReturnError;
IORegistryEntry *entry = IORegistryEntry::fromPath( "/options", gIODTPlane );
if ( entry )
{
OSObject *rawValue = entry->getProperty(IORegistrySleepSuppressionMode);
if(rawValue != NULL) {
#ifdef DEBUG
IOLog("%s: rawValueClassName: %s\n", getName(), rawValue->getMetaClass()->getClassName());
#endif
OSData *data = OSDynamicCast(OSData, rawValue);
if(data->getLength() == 1) {
*value = ((UInt8 *)data->getBytesNoCopy())[0];
ret = kOSReturnSuccess;
#ifdef DEBUG
IOLog("%s: reading nvram, value: 0x%02x\n", getName(), (*value));
#endif
}
#ifdef DEBUG
else {
IOLog("%s: read error: data->Len %s 1\n", getName(),
(data->getLength() == 1)?"==":"!=");
}
#endif
}
entry->release();
}
return ret;
}
void testDictionary()
{
bool res = true;
void *spaceCheck, *spaceCheck2, *spaceCheck3;
OSObject *cache[numStrCache];
OSString *str;
const OSSymbol *symCache[numStrCache], *sym;
OSDictionary *dict1, *dict2;
int i, numSymbols, count1, count2;
// Do first test without memory leak tests to initialise the metaclass
dict1 = OSDictionary::withCapacity(1);
TEST_ASSERT('D', "0a", dict1);
if (dict1)
dict1->release();
// Grow the symbol pool to maximum
for (i = 0; i < numStrCache; i++)
symCache[i] = OSSymbol::withCStringNoCopy(strCache[i]);
for (i = 0; i < numStrCache; i++)
symCache[i]->release();
// Create and destroy a dictionary
spaceCheck = checkPointSpace();
dict1 = OSDictionary::withCapacity(1);
TEST_ASSERT('D', "1a", dict1);
if (dict1) {
TEST_ASSERT('D', "1b", !dict1->getCount());
TEST_ASSERT('D', "1c", 1 == dict1->getCapacity());
TEST_ASSERT('D', "1d", 1 == dict1->getCapacityIncrement());
TEST_ASSERT('D', "1e", 4 == dict1->setCapacityIncrement(4));
TEST_ASSERT('D', "1f", 4 == dict1->getCapacityIncrement());
TEST_ASSERT('D', "1g", 8 == dict1->ensureCapacity(5));
spaceCheck2 = checkPointSpace();
sym = OSSymbol::withCStringNoCopy(strCache[0]);
spaceCheck3 = checkPointSpace();
TEST_ASSERT('D', "1h", dict1->setObject((OSObject *) sym, sym));
TEST_ASSERT('D', "1i", (OSObject *) sym == dict1->getObject(sym));
sym->release();
TEST_ASSERT('D', "1i", 2 == sym->getRetainCount());
res = res && checkSpace("(D)1j", spaceCheck3, 0);
TEST_ASSERT('D', "1k", 1 == dict1->getCount());
dict1->flushCollection();
TEST_ASSERT('D', "1l", !dict1->getCount());
res = res && checkSpace("(D)1m", spaceCheck2, 0);
dict1->release();
}
res = res && checkSpace("(D)1", spaceCheck, 0);
// Check the creation of a sizable OSDictionary from an array of IOObjects
// Also check indexing into the array.
spaceCheck = checkPointSpace();
for (i = 0, numSymbols = 0; i < numStrCache; i++) {
sym = OSSymbol::withCStringNoCopy(strCache[i]);
if (1 == sym->getRetainCount())
symCache[numSymbols++] = sym;
else
sym->release();
}
dict1 = OSDictionary::withObjects(
(OSObject **) symCache, symCache, numSymbols, numSymbols);
TEST_ASSERT('D', "2a", dict1);
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++)
count1 += (symCache[i]->getRetainCount() == 3);
TEST_ASSERT('D', "2b", count1 == numSymbols);
if (dict1) {
TEST_ASSERT('D', "2c", numSymbols == (int) dict1->getCount());
TEST_ASSERT('D', "2d", numSymbols == (int) dict1->getCapacity());
TEST_ASSERT('D', "2e",
numSymbols == (int) dict1->getCapacityIncrement());
for (i = dict1->getCount(); --i >= 0; ) {
str = (OSString *) dict1->getObject(symCache[i]);
if (str != (OSString *) symCache[i]) {
verPrintf(("testDictionary(D) test 2f%d failed\n", i));
res = false;
}
}
dict1->release();
}
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
count1 += (symCache[i]->getRetainCount() == 1);
symCache[i]->release();
}
TEST_ASSERT('D', "2g", count1 == numSymbols);
res = res && checkSpace("(D)2", spaceCheck, 0);
// Check the creation of a sizable Dictionary from an array of IOStrings
// Also check searching dictionary use OSString for a key.
spaceCheck = checkPointSpace();
for (i = 0, numSymbols = 0; i < numStrCache; i++) {
sym = OSSymbol::withCStringNoCopy(strCache[i]);
if (1 == sym->getRetainCount()) {
cache[numSymbols] = OSString::withCStringNoCopy(strCache[i]);
symCache[numSymbols] = sym;
numSymbols++;
}
else
sym->release();
}
dict1 = OSDictionary::withObjects((OSObject **) symCache,
(OSString **) cache,
numSymbols, numSymbols);
TEST_ASSERT('D', "3a", dict1);
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
count1 += (symCache[i]->getRetainCount() == 3);
count2 += (cache[i]->getRetainCount() == 1);
}
TEST_ASSERT('D', "3b", count1 == numSymbols);
TEST_ASSERT('D', "3c", count2 == numSymbols);
if (dict1) {
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
str = (OSString *) cache[i];
count1 += (symCache[i] == (const OSSymbol *) dict1->getObject(str));
count2 += (symCache[i]->getRetainCount() == 3);
}
TEST_ASSERT('D', "3d", count1 == numSymbols);
TEST_ASSERT('D', "3e", count2 == numSymbols);
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
const char *cStr = ((OSString *) cache[i])->getCStringNoCopy();
count1 += (symCache[i] == (const OSSymbol *) dict1->getObject(cStr));
count2 += (symCache[i]->getRetainCount() == 3);
}
TEST_ASSERT('D', "3f", count1 == numSymbols);
TEST_ASSERT('D', "3g", count2 == numSymbols);
dict1->release();
}
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
count1 += (symCache[i]->getRetainCount() == 1);
count2 += (cache[i]->getRetainCount() == 1);
symCache[i]->release();
cache[i]->release();
}
TEST_ASSERT('D', "3h", count1 == numSymbols);
res = res && checkSpace("(D)3", spaceCheck, 0);
// Check the creation of a small dictionary then grow it one item at a time
// Create a new dictionary from the old dictionary.
// Finally remove each item permanently.
spaceCheck = checkPointSpace();
for (i = 0, numSymbols = 0; i < numStrCache; i++) {
sym = OSSymbol::withCStringNoCopy(strCache[i]);
if (1 == sym->getRetainCount()) {
cache[numSymbols] = OSString::withCStringNoCopy(strCache[i]);
symCache[numSymbols] = sym;
numSymbols++;
}
else
sym->release();
}
dict2 = 0;
dict1 = OSDictionary::withCapacity(1);
TEST_ASSERT('D', "4a", dict1);
if (dict1) {
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
sym = symCache[i];
count1 += ((OSObject *) sym == dict1->setObject((OSObject *) sym,
sym->getCStringNoCopy()));
count2 += (sym->getRetainCount() == 3);
}
TEST_ASSERT('D', "4b", numSymbols == (int) dict1->getCount());
TEST_ASSERT('D', "4c", numSymbols == count1);
TEST_ASSERT('D', "4d", numSymbols == count2);
dict2 = OSDictionary::withDictionary(dict1, numSymbols-1);
TEST_ASSERT('D', "4b", !dict2);
dict2 = OSDictionary::withDictionary(dict1, numSymbols);
}
TEST_ASSERT('D', "4e", dict2);
if (dict2) {
dict1->release();
dict1 = 0;
TEST_ASSERT('D', "4f", numSymbols == (int) dict2->getCount());
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
OSObject *replacedObject;
sym = symCache[i];
str = (OSString *) cache[i];
replacedObject = dict2->setObject(str, str);
count1 += ((OSString *) sym == replacedObject);
replacedObject->release();
count2 += (sym->getRetainCount() == 2);
str->release();
}
TEST_ASSERT('D', "4g", numSymbols == count1);
TEST_ASSERT('D', "4h", numSymbols == count2);
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
sym = symCache[i];
str = (OSString *) cache[i];
count1 += (str == dict2->__takeObject(sym));
str->release();
count2 += (sym->getRetainCount() == 1);
sym->release();
}
TEST_ASSERT('D', "4i", numSymbols == count1);
TEST_ASSERT('D', "4j", numSymbols == count2);
TEST_ASSERT('D', "4k", !dict2->getCount());
dict2->release();
dict2 = 0;
}
else if (dict1)
dict1->release();
res = res && checkSpace("(D)4", spaceCheck, 0);
if (res)
verPrintf(("testDictionary: All OSDictionary Tests passed\n"));
else
logPrintf(("testDictionary: Some OSDictionary Tests failed\n"));
}
IOReturn
com_evoluent_driver_VerticalMouse::StartFinalProcessing()
{
OSNumber *curResPtr, *resPrefPtr;
UInt32 curResInt, resPrefInt;
IOFixed curRes, resPref;
IOReturn err = kIOReturnSuccess;
OSBoolean * boolObj;
OSObject * propertyObj = NULL;
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing", this);
_switchBackOnRestart = FALSE;
propertyObj = copyProperty("SwitchTo800DPI");
boolObj = OSDynamicCast( OSBoolean, propertyObj );
if ( boolObj && boolObj->isTrue() )
{
// USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - found switchTo800DPI resolution property", this);
_switchTo800dpiFlag = true;
}
if (propertyObj)
propertyObj->release();
propertyObj = copyProperty("SwitchTo2000FPS");
boolObj = OSDynamicCast( OSBoolean, propertyObj );
if ( boolObj && boolObj->isTrue() )
{
// USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - found switchTo2000fps resolution property", this);
_switchTo2000fpsFlag = true;
}
if (propertyObj)
propertyObj->release();
if ( _switchTo2000fpsFlag )
{
IOUSBDevRequest devReq;
// Write the 2000 FPS value to the mouse
//
devReq.bmRequestType = 0x40;
devReq.bRequest = 0x01;
devReq.wValue = 0x05AC;
devReq.wIndex = 0xd810;
devReq.wLength = 0x0000;
devReq.pData = NULL;
err = _device->DeviceRequest(&devReq, 5000, 0);
if (err)
{
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - sending 1st part of FPS change received error 0x%x", this, err);
}
else
{
devReq.bmRequestType = 0x40;
devReq.bRequest = 0x01;
devReq.wValue = 0x05AC;
devReq.wIndex = 0xdc11;
devReq.wLength = 0x0000;
devReq.pData = NULL;
err = _device->DeviceRequest(&devReq, 5000, 0);
if (err)
{
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - sending 2nd part of FPS change received error 0x%x", this, err);
}
}
#if FORMOUSETESTING
UInt8 hi,lo;
UInt16 fps;
// Read back the value:
//
devReq.bmRequestType = 0xc0;
devReq.bRequest = 0x01;
devReq.wValue = 0x05AC;
devReq.wIndex = 0x0011;
devReq.wLength = 1;
devReq.pData = &hi;
err = _device->DeviceRequest(&devReq, 5000, 0);
if (err)
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - error reading hi byte: 0x%x", this, err);
devReq.bmRequestType = 0xc0;
devReq.bRequest = 0x01;
devReq.wValue = 0x05AC;
devReq.wIndex = 0x0010;
devReq.wLength = 1;
devReq.pData = &lo;
err = _device->DeviceRequest(&devReq, 5000, 0);
if (err)
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - read reading lo byte: 0x%x", this, err);
fps = hi;
fps = (fps << 8) | lo;
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - read : 0x%x", this, fps );
#endif
err = super::StartFinalProcessing();
if (err)
{
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - super returned error 0x%x", this, err);
}
}
if ( _switchTo800dpiFlag )
{
propertyObj = copyProperty(kIOHIDPointerResolutionKey);
curResPtr = OSDynamicCast( OSNumber, propertyObj );
if (curResPtr)
{
curResInt = curResPtr->unsigned32BitValue();
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - found current resolution property - value 0x%lx", this, curResInt);
}
else
{
curResInt = kDefaultFixedResolution;
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - no current property found - using default 0x%lx", this, curResInt);
}
if (propertyObj)
propertyObj->release();
propertyObj = copyProperty(("xResolutionPref"));
resPrefPtr = OSDynamicCast( OSNumber, propertyObj );
if (resPrefPtr)
resPrefInt = resPrefPtr->unsigned32BitValue();
else
{
resPrefInt = kDefaultFixedResolution * 2;
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - no preference property found - using default 0x%lx", this, resPrefInt);
}
if (propertyObj)
propertyObj->release();
resPref = (IOFixed) resPrefInt;
curRes = (IOFixed) curResInt;
if (resPref != curRes)
{
if (switchTo800dpi)
{
IOUSBDevRequest devReq;
devReq.bmRequestType = 0x40;
devReq.bRequest = 0x01;
devReq.wValue = 0x05AC;
devReq.wIndex = 0x0452;
devReq.wLength = 0x0000;
devReq.pData = NULL;
err = _device->DeviceRequest(&devReq, 5000, 0);
if (err)
{
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - error (%x) setting resolution", this, err);
}
else
{
// with this mouse, we do NOT want to start reading on the interrupt pipe, nor do
// we want to call super::start. We just want to wait for the device to get terminated
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - waiting for click mouse termination", this);
}
}
}
else
{
// If we are already at the correct resolution for OSX, OK. But what if we are going
// back to OS 9? On restart, switch back to boot setup. Power Manager will tell us
// when we are going to restart.
//
_switchBackOnRestart = TRUE;
err = super::StartFinalProcessing();
if (err)
{
USBLog(1, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - error (%p) from super::StartFinalProcessing", this, (void*)err);
}
}
}
return err;
}
bool FakeSMC::start(IOService *provider)
{
if (!super::start(provider))
return false;
if (!(keyStore = OSDynamicCast(FakeSMCKeyStore, waitForMatchingService(serviceMatching(kFakeSMCKeyStoreService), kFakeSMCDefaultWaitTimeout)))) {
HWSensorsInfoLog("still waiting for FakeSMCKeyStore...");
return false;
// HWSensorsDebugLog("creating FakeSMCKeyStore");
//
// if (!(keyStore = new FakeSMCKeyStore)) {
// HWSensorsInfoLog("failed to create FakeSMCKeyStore");
// return false;
// }
//
// HWSensorsDebugLog("initializing FakeSMCKeyStore");
//
// if (keyStore->initAndStart(this, configuration)) {
// keyStore->setProperty("IOUserClientClass", "FakeSMCKeyStoreUserClient");
// }
// else {
// keyStore->release();
// HWSensorsFatalLog("failed to initialize FakeSMCKeyStore device");
// return false;
// }
}
// if (IOService *resources = waitForMatchingService(serviceMatching("IOResources"), 0))
// this->attach(resources);
OSDictionary *configuration = OSDynamicCast(OSDictionary, getProperty("Configuration"));
// Load preconfigured keys
HWSensorsDebugLog("loading keys...");
if (!configuration) {
HWSensorsFatalLog("no configuration node found!");
return false;
}
if (UInt32 count = keyStore->addKeysFromDictionary(OSDynamicCast(OSDictionary, configuration->getObject("Keys")))) {
HWSensorsInfoLog("%d preconfigured key%s added", count, count == 1 ? "" : "s");
}
else {
HWSensorsWarningLog("no preconfigured keys found");
}
// Load wellknown type names
HWSensorsDebugLog("loading types...");
keyStore->addWellKnownTypesFromDictionary(OSDynamicCast(OSDictionary, configuration->getObject("Types")));
// Set Clover platform keys
if (OSDictionary *dictionary = OSDynamicCast(OSDictionary, configuration->getObject("Clover"))) {
UInt32 count = 0;
if (IORegistryEntry* cloverPlatformNode = fromPath("/efi/platform", gIODTPlane)) {
if (OSIterator *iterator = OSCollectionIterator::withCollection(dictionary)) {
while (OSString *name = OSDynamicCast(OSString, iterator->getNextObject())) {
if (OSData *data = OSDynamicCast(OSData, cloverPlatformNode->getProperty(name))) {
if (OSArray *items = OSDynamicCast(OSArray, dictionary->getObject(name))) {
OSString *key = OSDynamicCast(OSString, items->getObject(0));
OSString *type = OSDynamicCast(OSString, items->getObject(1));
if (keyStore->addKeyWithValue(key->getCStringNoCopy(), type->getCStringNoCopy(), data->getLength(), data->getBytesNoCopy()))
count++;
}
}
}
OSSafeRelease(iterator);
}
}
if (count)
HWSensorsInfoLog("%d key%s exported by Clover EFI", count, count == 1 ? "" : "s");
}
// Check if we have SMC already
bool smcDeviceFound = false;
if (OSDictionary *matching = serviceMatching("IOACPIPlatformDevice")) {
if (OSIterator *iterator = getMatchingServices(matching)) {
OSString *smcNameProperty = OSString::withCString("APP0001");
while (IOService *service = (IOService*)iterator->getNextObject()) {
OSObject *serviceNameProperty = service->getProperty("name");
if (serviceNameProperty && serviceNameProperty->isEqualTo(smcNameProperty)) {
smcDeviceFound = true;
}
}
OSSafeRelease(iterator);
}
OSSafeRelease(matching);
}
if (!smcDeviceFound) {
if (!(smcDevice = new FakeSMCDevice)) {
HWSensorsInfoLog("failed to create SMC device");
return false;
}
IOService *platformExpert = waitForMatchingService(serviceMatching("IOACPIPlatformExpert"), kFakeSMCDefaultWaitTimeout);
if (!smcDevice->initAndStart(platformExpert, this)) {
HWSensorsFatalLog("failed to initialize SMC device");
return false;
}
}
else {
HWSensorsInfoLog("found physical SMC device, will not create virtual one. Providing only basic plugins functionality");
}
int arg_value = 1;
// Load keys from NVRAM
if (PE_parse_boot_argn("-fakesmc-use-nvram", &arg_value, sizeof(arg_value))) {
if (UInt32 count = keyStore->loadKeysFromNVRAM())
HWSensorsInfoLog("%d key%s loaded from NVRAM", count, count == 1 ? "" : "s");
else
HWSensorsInfoLog("NVRAM will be used to store system written keys...");
}
registerService();
return true;
}
void StartIOKit( void * p1, void * p2, void * p3, void * p4 )
{
IOPlatformExpertDevice * rootNub;
int debugFlags;
IORegistryEntry * root;
OSObject * obj;
extern const char * gIOKernelKmods;
OSString * errorString = NULL; // must release
OSDictionary * fakeKmods; // must release
OSCollectionIterator * kmodIter; // must release
OSString * kmodName; // don't release
IOLog( iokit_version );
if( PE_parse_boot_arg( "io", &debugFlags ))
gIOKitDebug = debugFlags;
// Check for the log synchronous bit set in io
if (gIOKitDebug & kIOLogSynchronous)
debug_mode = true;
//
// Have to start IOKit environment before we attempt to start
// the C++ runtime environment. At some stage we have to clean up
// the initialisation path so that OS C++ can initialise independantly
// of iokit basic service initialisation, or better we have IOLib stuff
// initialise as basic OS services.
//
IOLibInit();
OSlibkernInit();
/*****
* Declare the fake kmod_info structs for built-in components
* that must be tracked as independent units for dependencies.
*/
fakeKmods = OSDynamicCast(OSDictionary,
OSUnserialize(gIOKernelKmods, &errorString));
if (!fakeKmods) {
if (errorString) {
panic("Kernel kmod list syntax error: %s\n",
errorString->getCStringNoCopy());
errorString->release();
} else {
panic("Error loading kernel kmod list.\n");
}
}
kmodIter = OSCollectionIterator::withCollection(fakeKmods);
if (!kmodIter) {
panic("Can't declare in-kernel kmods.\n");
}
while ((kmodName = OSDynamicCast(OSString, kmodIter->getNextObject()))) {
OSString * kmodVersion = OSDynamicCast(OSString,
fakeKmods->getObject(kmodName));
if (!kmodVersion) {
panic("Can't declare in-kernel kmod; \"%s\" has "
"an invalid version.\n",
kmodName->getCStringNoCopy());
}
if (KERN_SUCCESS != kmod_create_fake(kmodName->getCStringNoCopy(),
kmodVersion->getCStringNoCopy())) {
panic("Failure declaring in-kernel kmod \"%s\".\n",
kmodName->getCStringNoCopy());
}
}
kmodIter->release();
fakeKmods->release();
root = IORegistryEntry::initialize();
assert( root );
IOService::initialize();
IOCatalogue::initialize();
IOUserClient::initialize();
IOMemoryDescriptor::initialize();
obj = OSString::withCString( iokit_version );
assert( obj );
if( obj ) {
root->setProperty( kIOKitBuildVersionKey, obj );
obj->release();
}
obj = IOKitDiagnostics::diagnostics();
if( obj ) {
root->setProperty( kIOKitDiagnosticsKey, obj );
obj->release();
}
rootNub = new IOPlatformExpertDevice;
if( rootNub && rootNub->initWithArgs( p1, p2, p3, p4)) {
rootNub->attach( 0 );
/* Enter into the catalogue the drivers
* provided by BootX.
*/
gIOCatalogue->recordStartupExtensions();
rootNub->registerService();
}
}
OSObject *
OSUnserializeBinary(const char *buffer, size_t bufferSize, OSString **errorString)
{
OSObject ** objsArray;
uint32_t objsCapacity;
enum { objsCapacityMax = 16*1024*1024 };
uint32_t objsIdx;
OSObject ** stackArray;
uint32_t stackCapacity;
enum { stackCapacityMax = 64 };
uint32_t stackIdx;
OSObject * result;
OSObject * parent;
OSDictionary * dict;
OSArray * array;
OSSet * set;
OSDictionary * newDict;
OSArray * newArray;
OSSet * newSet;
OSObject * o;
OSSymbol * sym;
OSString * str;
size_t bufferPos;
const uint32_t * next;
uint32_t key, len, wordLen;
bool end, newCollect, isRef;
unsigned long long value;
bool ok;
if (errorString) *errorString = 0;
if (bufferSize < sizeof(kOSSerializeBinarySignature)) return (NULL);
if (0 != strcmp(kOSSerializeBinarySignature, buffer)) return (NULL);
if (3 & ((uintptr_t) buffer)) return (NULL);
bufferPos = sizeof(kOSSerializeBinarySignature);
next = (typeof(next)) (((uintptr_t) buffer) + bufferPos);
DEBG("---------OSUnserializeBinary(%p)\n", buffer);
objsArray = stackArray = NULL;
objsIdx = objsCapacity = 0;
stackIdx = stackCapacity = 0;
result = 0;
parent = 0;
dict = 0;
array = 0;
set = 0;
sym = 0;
ok = true;
while (ok)
{
bufferPos += sizeof(*next);
if (!(ok = (bufferPos <= bufferSize))) break;
key = *next++;
len = (key & kOSSerializeDataMask);
wordLen = (len + 3) >> 2;
end = (0 != (kOSSerializeEndCollecton & key));
DEBG("key 0x%08x: 0x%04x, %d\n", key, len, end);
newCollect = isRef = false;
o = 0; newDict = 0; newArray = 0; newSet = 0;
switch (kOSSerializeTypeMask & key)
{
case kOSSerializeDictionary:
o = newDict = OSDictionary::withCapacity(len);
newCollect = (len != 0);
break;
case kOSSerializeArray:
o = newArray = OSArray::withCapacity(len);
newCollect = (len != 0);
break;
case kOSSerializeSet:
o = newSet = OSSet::withCapacity(len);
newCollect = (len != 0);
break;
case kOSSerializeObject:
if (len >= objsIdx) break;
o = objsArray[len];
isRef = true;
break;
case kOSSerializeNumber:
bufferPos += sizeof(long long);
if (bufferPos > bufferSize) break;
if ((len != 32) && (len != 64) && (len != 16) && (len != 8)) break;
value = next[1];
value <<= 32;
value |= next[0];
o = OSNumber::withNumber(value, len);
next += 2;
break;
case kOSSerializeSymbol:
bufferPos += (wordLen * sizeof(uint32_t));
if (bufferPos > bufferSize) break;
if (len < 2) break;
if (0 != ((const char *)next)[len-1]) break;
o = (OSObject *) OSSymbol::withCString((const char *) next);
next += wordLen;
break;
case kOSSerializeString:
bufferPos += (wordLen * sizeof(uint32_t));
if (bufferPos > bufferSize) break;
o = OSString::withStringOfLength((const char *) next, len);
next += wordLen;
break;
case kOSSerializeData:
bufferPos += (wordLen * sizeof(uint32_t));
if (bufferPos > bufferSize) break;
o = OSData::withBytes(next, len);
next += wordLen;
break;
case kOSSerializeBoolean:
o = (len ? kOSBooleanTrue : kOSBooleanFalse);
break;
default:
break;
}
if (!(ok = (o != 0))) break;
if (!isRef)
{
setAtIndex(objs, objsIdx, o);
if (!ok)
{
o->release();
break;
}
objsIdx++;
}
if (dict)
{
if (!sym) sym = (OSSymbol *) o;
else
{
str = sym;
sym = OSDynamicCast(OSSymbol, sym);
if (!sym && (str = OSDynamicCast(OSString, str)))
{
sym = const_cast<OSSymbol *>(OSSymbol::withString(str));
ok = (sym != 0);
if (!ok) break;
}
DEBG("%s = %s\n", sym->getCStringNoCopy(), o->getMetaClass()->getClassName());
if (o != dict) ok = dict->setObject(sym, o);
if (sym && (sym != str)) sym->release();
sym = 0;
}
}
else if (array) ok = array->setObject(o);
else if (set) ok = set->setObject(o);
else if (result) ok = false;
else
{
assert(!parent);
result = o;
}
if (!ok) break;
if (end) parent = 0;
if (newCollect)
{
stackIdx++;
setAtIndex(stack, stackIdx, parent);
if (!ok) break;
DEBG("++stack[%d] %p\n", stackIdx, parent);
parent = o;
dict = newDict;
array = newArray;
set = newSet;
end = false;
}
if (end)
{
while (stackIdx)
{
parent = stackArray[stackIdx];
DEBG("--stack[%d] %p\n", stackIdx, parent);
stackIdx--;
if (parent) break;
}
if (!parent) break;
set = 0;
dict = 0;
array = 0;
if (!(dict = OSDynamicCast(OSDictionary, parent)))
{
if (!(array = OSDynamicCast(OSArray, parent))) ok = (0 != (set = OSDynamicCast(OSSet, parent)));
}
}
}
DEBG("ret %p\n", result);
if (!ok) result = 0;
if (objsCapacity)
{
for (len = (result != 0); len < objsIdx; len++) objsArray[len]->release();
kfree(objsArray, objsCapacity * sizeof(*objsArray));
}
if (stackCapacity) kfree(stackArray, stackCapacity * sizeof(*stackArray));
return (result);
}
void FileNVRAM::timeoutOccurred(OSObject *target, IOTimerEventSource* timer)
{
static int retryCount;
if (target)
{
FileNVRAM* self = OSDynamicCast(FileNVRAM, target);
if (self)
{
uint64_t timeout = 20000; // 20ms
// Check to see if BSD has been published, if so sync();
OSDictionary * dict = 0;
IOService * match = 0;
boolean_t found = false;
do
{
dict = IOService::resourceMatching("IOBSD");
if (dict)
{
if (IOService::waitForMatchingService(dict, timeout))
{
found = true;
}
}
} while (false);
OSSafeReleaseNULL(dict);
OSSafeReleaseNULL(match);
if (found)
{
UInt8 mLoggingLevel = self->mLoggingLevel;
LOG(NOTICE, "BSD found, syncing\n");
// TODO: Read /Extra/NVRAM/nvram.plist and populate the device tree.
char* buffer;
uint64_t len;
if (self->read_buffer(&buffer, &len, self->mCtx))
{
retryCount++;
LOG(ERROR, "Unable to read in nvram data at %s\n", self->mFilePath->getCStringNoCopy());
// TODO: Check if / is mounted, and if not, try again until it is.
if (retryCount < 100)
{
timer->setTimeoutMS(100);
}
else
{
self->mSafeToSync = true;
self->registerNVRAM();
}
}
else
{
self->mSafeToSync = false;
timer->cancelTimeout();
self->getWorkLoop()->removeEventSource(timer);
timer->release();
self->mTimer = NULL;
if (len > strlen(NVRAM_FILE_HEADER) + strlen(NVRAM_FILE_FOOTER) + 1)
{
char* xml = buffer + strlen(NVRAM_FILE_HEADER);
size_t xmllen = (size_t)len - strlen(NVRAM_FILE_HEADER) - strlen(NVRAM_FILE_FOOTER);
xml[xmllen-1] = 0;
OSString *errmsg = 0;
OSObject* nvram = OSUnserializeXML(xml, &errmsg);
if (nvram)
{
OSDictionary* data = OSDynamicCast(OSDictionary, nvram);
//if(data) self->setPropertyTable(data);
if (data)
{
self->copyUnserialzedData(NULL, data);
}
nvram->release();
}
}
IOFree(buffer, (size_t)len);
self->mSafeToSync = true;
self->registerNVRAM();
//self->sync();
}
}
else
{
timer->setTimeoutMS(50);
}
}
else
{
//printf("Self is not of type FileNVRAM.\n");
}
}
}
