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; }
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); }
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; }
//--------------------------------------------------------------------------- // 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; }
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); }
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(); }
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; }
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; }
static void createNubs(IOService *provider) { const char nameID[2][8] = {"@0,name", "@1,name"}; const char name[11] = "Aty,Radeon"; const char typeID[2][15] = {"@0,device_type", "@1,device_type"}; const char type[] = "display"; OSObject *tempObj; int i; if (provider->getProperty(kIONDRVIgnoreKey)) return; provider->setProperty(kIONDRVIgnoreKey, kOSBooleanTrue); //prevent IONDRVFramebuffer from match LOG("createNubs\n"); if (!provider->getProperty("@0,name") && !provider->getProperty("@1,name")) { for (i = 0;i < 2;i++) { // Debug tempObj = OSData::withBytes(name, 11); provider->setProperty(nameID[i], tempObj); tempObj->release(); tempObj = OSData::withBytes(type, 8); provider->setProperty(typeID[i], tempObj); tempObj->release(); } } // have to move below part from IONDRVFramebuffer to make it work IORegistryIterator * iter; IORegistryEntry * next; IOService * newNub; OSArray * toDo = 0; bool firstLevel; OSData * data; if (provider->getProperty("@0,name")) { OSDictionary * dict; OSCollectionIterator * keys; const OSSymbol * key; char buffer[80]; const char * keyChrs; size_t len; char c; dict = provider->dictionaryWithProperties(); keys = OSCollectionIterator::withCollection(dict); if (dict) dict->release(); if (keys) { while ((key = OSDynamicCast(OSSymbol, keys->getNextObject()))) { keyChrs = key->getCStringNoCopy(); if ('@' != keyChrs[0]) continue; len = 0; do { c = keyChrs[len]; if (!c || (c == ',')) break; buffer[len] = c; len++; } while (len < (sizeof(buffer) - 1)); if (!c) continue; buffer[len] = 0; keyChrs += len + 1; next = provider->childFromPath(buffer, gIODTPlane); if (!next) { next = new IOService; if (next && !next->init()) { next->release(); next = 0; } if (!next) continue; next->setLocation(&buffer[1]); if (!next->attachToParent(provider, gIODTPlane)) continue; } OSObject * obj = dict->getObject(key); next->setProperty(keyChrs, dict->getObject(key)); if (!strcmp(keyChrs, "name")) { OSData * data = OSDynamicCast(OSData, obj); if (data) next->setName((const char *) data->getBytesNoCopy()); } next->release(); provider->removeProperty(key); } keys->release(); } } iter = IORegistryIterator::iterateOver( provider, gIODTPlane, 0 ); toDo = OSArray::withCapacity(2); if (iter && toDo) { bool haveDoneLibInit = false; UInt32 index = 0; do { while ((next = (IORegistryEntry *) iter->getNextObject())) { firstLevel = (provider == next->getParentEntry(gIODTPlane)); if (firstLevel) { data = OSDynamicCast( OSData, next->getProperty("device_type")); if (!data || (0 != strcmp("display", (char *) data->getBytesNoCopy()))) continue; if (!haveDoneLibInit) { haveDoneLibInit = (kIOReturnSuccess == _IONDRVLibrariesInitialize(provider)); if (!haveDoneLibInit) continue; } next->setProperty( kIOFBDependentIDKey, (uintptr_t) provider, 64 ); next->setProperty( kIOFBDependentIndexKey, index, 32 ); next->setProperty( kIONDRVIgnoreKey, kOSBooleanTrue ); index++; } toDo->setObject( next ); iter->enterEntry(); } } while (iter->exitEntry()); } if (iter) iter->release(); if (toDo) { OSObject * obj; OSArray * deviceMemory; obj = provider->copyProperty(gIODeviceMemoryKey); deviceMemory = OSDynamicCast(OSArray, obj); for (unsigned int i = 0; (next = (IORegistryEntry *) toDo->getObject(i)); i++) { newNub = new IONDRVDevice; if (!newNub) continue; if (!newNub->init(next, gIODTPlane)) { newNub->free(); newNub = 0; continue; } if (deviceMemory) newNub->setDeviceMemory(deviceMemory); newNub->attach(provider); newNub->registerService(kIOServiceSynchronous); } if (obj) obj->release(); toDo->release(); } }
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; }
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"); } } }
bool IOEthernetInterface::init(IONetworkController * controller) { OSObject * obj; _reserved = IONew( ExpansionData, 1 ); if( _reserved == 0 ) return false; memset(_reserved, 0, sizeof(ExpansionData)); if ( super::init(controller) == false ) return false; // initialize enet specific fields. setInterfaceType(IFT_ETHER); setMaxTransferUnit( ETHERMTU ); setMediaAddressLength( ETHER_ADDR_LEN ); setMediaHeaderLength( ETHER_HDR_LEN ); setFlags( IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS, IFF_RUNNING | IFF_MULTICAST ); // Add an IONetworkData with room to hold an IOEthernetStats structure. // This class does not reference the data object created, and no harm // is done if the data object is released or replaced. IONetworkData * data = IONetworkData::withInternalBuffer( kIOEthernetStatsKey, sizeof(IOEthernetStats)); if (data) { addNetworkData(data); data->release(); } _inputEventThreadCall = thread_call_allocate( handleEthernetInputEvent, this ); if (!_inputEventThreadCall) return false; // Create and initialize the filter dictionaries. _requiredFilters = OSDictionary::withCapacity(2); _activeFilters = OSDictionary::withCapacity(2); if ( (_requiredFilters == 0) || (_activeFilters == 0) ) return false; obj = controller->copyProperty(kIOPacketFilters); if (obj && ((_supportedFilters = OSDynamicCast(OSDictionary, obj)) == 0)) obj->release(); if (!_supportedFilters) return false; // Cache the bit mask of wake filters supported by the driver. // This value will not change. _supportedWakeFilters = GET_SUPPORTED_FILTERS( gIOEthernetWakeOnLANFilterGroup ); // Retain the Disabled WOL filters OSNumber. // Its value will be updated live for link and WOL changed events. obj = _supportedFilters->getObject( gIOEthernetDisabledWakeOnLANFilterGroup ); _disabledWakeFilters = OSDynamicCast(OSNumber, obj); if (_disabledWakeFilters) _disabledWakeFilters->retain(); // Controller's Unicast (directed) and Broadcast filters should always // be enabled. Those bits should never be cleared. if ( !SET_REQUIRED_FILTERS( gIONetworkFilterGroup, kIOPacketFilterUnicast | kIOPacketFilterBroadcast ) || !SET_REQUIRED_FILTERS( gIOEthernetWakeOnLANFilterGroup, 0 ) || !SET_ACTIVE_FILTERS( gIONetworkFilterGroup, 0 ) || !SET_ACTIVE_FILTERS( gIOEthernetWakeOnLANFilterGroup, 0 ) ) { return false; } _publishedFeatureID = 0; // Publish filter dictionaries to property table. setProperty( kIORequiredPacketFilters, _requiredFilters ); setProperty( kIOActivePacketFilters, _activeFilters ); return true; }
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 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(); } }