int AoEProperties::configure_matching(void)
{
// debugVerbose("AoEProperties::configure_matching\n");
// Obtain ports for notifications (this will be used for all service matching notifications)
kern_return_t kresult;
mach_port_t MasterPort;
kresult = IOMasterPort(MACH_PORT_NULL, &MasterPort);
if ( kresult )
{
debugError("Could not get masterport. Error=%d\n", kresult);
return false;
}
ms_NotificationPort = IONotificationPortCreate(MasterPort);
ms_IOKitNotificationRunLoopSource = IONotificationPortGetRunLoopSource(ms_NotificationPort);
CFRunLoopAddSource(CFRunLoopGetCurrent(), ms_IOKitNotificationRunLoopSource, kCFRunLoopDefaultMode);
// SetUp Notification for matching to our device
CFMutableDictionaryRef MatchingDict = IOServiceMatching(AOE_KEXT_NAME_Q);
IOServiceAddMatchingNotification(ms_NotificationPort,
kIOMatchedNotification,
MatchingDict,
AoEProperties::matched_callback,
this,
&ms_MatchIt);
// Call the callback immediately to check if our iterator already contains our device (ie. the device is already loaded)
matched_callback(this, ms_MatchIt);
return m_fMatched ? 0 : -1;
}
TorcUSBPrivOSX::TorcUSBPrivOSX(TorcUSB *Parent)
: QObject(Parent),
m_usbRef(NULL),
m_usbNotifyPort(NULL),
m_iterator(0),
m_notificationsLock(new QMutex())
{
if (!gAdminRunLoop)
{
LOG(VB_GENERAL, LOG_ERR, "OS X callback run loop not present - aborting");
return;
}
CFMutableDictionaryRef match = IOServiceMatching(kIOUSBDeviceClassName);
m_usbNotifyPort = IONotificationPortCreate(kIOMasterPortDefault);
m_usbRef = IONotificationPortGetRunLoopSource(m_usbNotifyPort);
CFRunLoopAddSource(gAdminRunLoop, m_usbRef, kCFRunLoopCommonModes);
IOReturn ok = IOServiceAddMatchingNotification(m_usbNotifyPort, kIOFirstMatchNotification, match,
(IOServiceMatchingCallback)DeviceAddedCallback,
this, &m_iterator);
if (kIOReturnSuccess == ok)
DeviceAddedCallback(this, m_iterator);
else
LOG(VB_GENERAL, LOG_ERR, "Failed to register for attachment notifications");
}
int usbmain(){
int vendor = V_CORSAIR;
int products[] = { P_K65, P_K70, P_K70_NRGB, P_K95, P_K95_NRGB/*, P_M65*/ };
// Tell IOService which type of devices we want (IOHIDDevices matching the supported vendor/products)
CFMutableDictionaryRef match = IOServiceMatching(kIOHIDDeviceKey);
CFNumberRef cfvendor = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &vendor);
CFDictionarySetValue(match, CFSTR(kIOHIDVendorIDKey), cfvendor);
CFRelease(cfvendor);
CFMutableArrayRef cfproducts = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
for(uint i = 0; i < sizeof(products) / sizeof(int); i++){
int product = products[i];
CFNumberRef cfproduct = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &product);
CFArrayAppendValue(cfproducts, cfproduct);
CFRelease(cfproduct);
}
CFDictionarySetValue(match, CFSTR(kIOHIDProductIDArrayKey), cfproducts);
CFRelease(cfproducts);
notify = IONotificationPortCreate(kIOMasterPortDefault);
CFRunLoopAddSource(mainloop = CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notify), kCFRunLoopDefaultMode);
io_iterator_t iterator;
IOReturn res = IOServiceAddMatchingNotification(notify, kIOMatchedNotification, match, iterate_devices, 0, &iterator);
if(res != kIOReturnSuccess){
ckb_fatal("Failed to list devices: %x\n", res);
return -1;
}
// Iterate existing devices
iterate_devices(0, iterator);
// Enter loop to scan/connect new devices
CFRunLoopRun();
return 0;
}
void IOKitEventPublisher::stop() {
if (run_loop_ == nullptr) {
// If there is no run loop then the publisher thread has not started.
return;
}
// Stop the run loop.
WriteLock lock(mutex_);
CFRunLoopStop(run_loop_);
// Stop the run loop before operating on containers.
// Destroy the IOPort.
if (port_ != nullptr) {
auto source = IONotificationPortGetRunLoopSource(port_);
if (CFRunLoopContainsSource(run_loop_, source, kCFRunLoopDefaultMode)) {
CFRunLoopRemoveSource(run_loop_, source, kCFRunLoopDefaultMode);
}
// And destroy the port.
IONotificationPortDestroy(port_);
port_ = nullptr;
}
// Clear all devices and their notifications.
for (const auto& device : devices_) {
IOObjectRelease(device->notification);
}
devices_.clear();
}
void mac_sleep_stop()
{
if (root_port)
{
// remove the sleep notification port from the application runloop
CFRunLoopRemoveSource(CFRunLoopGetCurrent(),
IONotificationPortGetRunLoopSource(notifyPortRef),
kCFRunLoopCommonModes);
// deregister for system sleep notifications
IODeregisterForSystemPower(¬ifierObject);
// IORegisterForSystemPower implicitly opens the Root Power Domain IOService
// so we close it here
IOServiceClose(root_port);
// destroy the notification port allocated by IORegisterForSystemPower
IONotificationPortDestroy(notifyPortRef);
// reset object members
root_port = 0;
notifyPortRef = NULL;
notifierObject = 0;
}
}
void CCocoaPowerSyscall::DeleteOSPowerCallBacks(void)
{
#if !defined(TARGET_DARWIN_IOS)
CCocoaAutoPool autopool;
// we no longer want sleep/wake notifications
// remove the sleep notification port from the application runloop
CFRunLoopRemoveSource( CFRunLoopGetCurrent(),
IONotificationPortGetRunLoopSource(m_notify_port), kCFRunLoopDefaultMode );
// deregister for system sleep notifications
IODeregisterForSystemPower(&m_notifier_object);
// IORegisterForSystemPower implicitly opens the Root Power Domain IOService
// so we close it here
IOServiceClose(m_root_port);
// destroy the notification port allocated by IORegisterForSystemPower
IONotificationPortDestroy(m_notify_port);
// we no longer want power source change notifications
if (m_HasBattery)
{
if (m_power_source)
{
CFRunLoopRemoveSource( CFRunLoopGetCurrent(), m_power_source, kCFRunLoopDefaultMode );
CFRelease(m_power_source);
}
}
#endif
}
void XNotificationPort::addInterestNotification(XReceiver &receiver, io_service_t service,
const io_name_t interestType)
{
io_iterator_t iterator;
mach_port_t pp = NotificationPort::port();
// MachPlusPlus::Port(pp).dump(0);
secdebug("iokit", "XNotificationPort::addInterest - type: %s [port: %p (0x%08X), service: 0x%08X]",
interestType, mPortRef, pp, service); // IOServiceMatched
#if 1
CFRunLoopSourceRef notificationRunLoopSource = IONotificationPortGetRunLoopSource(mPortRef);
CFRunLoopSourceRef classRunLoopSource = NotificationPort::source();
// IONotificationPortRef r_notify_port = IONotificationPortCreate(0);
kern_return_t kr = ::IOServiceAddInterestNotification(mPortRef, //,r_notify_port
service, interestType, ioDeviceNotification, &receiver, &iterator);
const char *msgstr = mach_error_string(kr);
const char *msgtyp = mach_error_type(kr);
if (msgstr && msgtyp)
secdebug("iokit", " msg: %s, typ: %s", msgstr, msgtyp);
// Error::check(kr);
// if(r_notify_port) IOObjectRelease((io_object_t)r_notify_port);
#else
Error::check(::IOServiceAddInterestNotification(mPortRef,
service, interestType, ioDeviceNotification, &receiver, &iterator));
#endif
}
/* Cleanup of the open ports */
void PortsCleanup()
{
CFRunLoopRemoveSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notifyPortRef), kCFRunLoopCommonModes); /* Remove the notification port from the runloop */
IODeregisterForSystemPower(¬ifierObject); /* Deregister from power notifications */
IOServiceClose(root_power_port); /* Close the Root Power Domain IOService port */
IONotificationPortDestroy(notifyPortRef); /* Destroy the notification port */
}
static Boolean InitIOKit() {
Boolean success = TRUE;
write_log(LOG_NOTICE, "Creating IOKit notification port.");
ioKitNotificationPort = IONotificationPortCreate(kIOMasterPortDefault);
if(ioKitNotificationPort == NULL) {
write_log(LOG_ERR, "Couldn't create IOKit notification port!");
success = FALSE;
goto EXIT;
}
write_log(LOG_NOTICE, "Creating IOKit RunLoop source.");
ioRunLoopSource = IONotificationPortGetRunLoopSource(ioKitNotificationPort);
if(ioRunLoopSource == NULL) {
write_log(LOG_ERR, "Couldn't create IOKit RunLoop source!");
success = FALSE;
goto EXIT;
}
CFRunLoopAddSource(CFRunLoopGetCurrent(), ioRunLoopSource,
kCFRunLoopDefaultMode);
EXIT:
return success;
}
static void cbWork(uv_work_t *req) {
// We have this check in case we `Stop` before this thread starts,
// otherwise the process will hang
if(!isRunning) {
return;
}
uv_signal_start(&int_signal, cbTerminate, SIGINT);
uv_signal_start(&term_signal, cbTerminate, SIGTERM);
runLoopSource = IONotificationPortGetRunLoopSource(gNotifyPort);
gRunLoop = CFRunLoopGetCurrent();
CFRunLoopAddSource(gRunLoop, runLoopSource, kCFRunLoopDefaultMode);
// Creating `gRunLoop` can take some cycles so we also need this second
// `isRunning` check here because it happens at a future time
if(isRunning) {
// Start the run loop. Now we'll receive notifications.
CFRunLoopRun();
}
// The `CFRunLoopRun` is a blocking call so we also need this second
// `isRunning` check here because it happens at a future time
if(isRunning) {
// We should never get here while running
fprintf(stderr, "Unexpectedly back from CFRunLoopRun()!\n");
}
}
int main(int argc, char** argv)
{
//
// From https://developer.apple.com/library/mac/qa/qa1340/_index.html
// I have basically no idea how this works :)
//
// notification port allocated by IORegisterForSystemPower
IONotificationPortRef notifyPortRef;
// notifier object, used to deregister later
io_object_t notifierObject;
// this parameter is passed to the callback
void* refCon;
// register to receive system sleep notifications
root_port = IORegisterForSystemPower(refCon, ¬ifyPortRef, SleepCallBack, ¬ifierObject);
if (root_port == 0) {
printf("IORegisterForSystemPower failed\n");
return 1;
}
// add the notification port to the application runloop
CFRunLoopAddSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notifyPortRef), kCFRunLoopCommonModes);
/* Start the run loop to receive sleep notifications. Don't call CFRunLoopRun if this code
is running on the main thread of a Cocoa or Carbon application. Cocoa and Carbon
manage the main thread's run loop for you as part of their event handling
mechanisms.
*/
CFRunLoopRun();
//Not reached, CFRunLoopRun doesn't return in this case.
return 0;
}
void CCocoaPowerSyscall::CreateOSPowerCallBacks(void)
{
#if !defined(TARGET_DARWIN_IOS)
CCocoaAutoPool autopool;
// we want sleep/wake notifications, register to receive system power notifications
m_root_port = IORegisterForSystemPower(this, &m_notify_port, OSPowerCallBack, &m_notifier_object);
if (m_root_port)
{
// add the notification port to the application runloop
CFRunLoopAddSource(CFRunLoopGetCurrent(),
IONotificationPortGetRunLoopSource(m_notify_port), kCFRunLoopDefaultMode);
}
else
{
CLog::Log(LOGERROR, "%s - IORegisterForSystemPower failed", __FUNCTION__);
}
// if we have a battery, we want power source change notifications (on AC, on Battery, etc)
if (m_HasBattery)
{
m_power_source = IOPSNotificationCreateRunLoopSource(OSPowerSourceCallBack, this);
if (m_power_source)
CFRunLoopAddSource(CFRunLoopGetCurrent(), m_power_source, kCFRunLoopDefaultMode);
else
CLog::Log(LOGERROR, "%s - IOPSNotificationCreateRunLoopSource failed", __FUNCTION__);
}
#endif
}
static int
InitUSB()
{
CFMutableDictionaryRef matchingDict;
CFRunLoopSourceRef runLoopSource;
SInt32 vendor, if_subclass, if_protocol;
unsigned i;
//* To set up asynchronous notifications, create a notification port and
//* add its run loop event source to the program's run loop
notificationPort = IONotificationPortCreate(kIOMasterPortDefault);
runLoopSource = IONotificationPortGetRunLoopSource(notificationPort);
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopDefaultMode);
memset(notificationIterators, 0, sizeof(notificationIterators));
//* loop through all supported vendors
for (i = 0; i < vendorIdCount; i++) {
//* Create our matching dictionary to find the Android device's
//* adb interface
//* IOServiceAddMatchingNotification consumes the reference, so we do
//* not need to release this
matchingDict = IOServiceMatching(kIOUSBInterfaceClassName);
if (!matchingDict) {
DBG("ERR: Couldn't create USB matching dictionary.\n");
return -1;
}
//* Match based on vendor id, interface subclass and protocol
vendor = vendorIds[i];
if_subclass = ADB_SUBCLASS;
if_protocol = ADB_PROTOCOL;
CFDictionarySetValue(matchingDict, CFSTR(kUSBVendorID),
CFNumberCreate(kCFAllocatorDefault,
kCFNumberSInt32Type, &vendor));
CFDictionarySetValue(matchingDict, CFSTR(kUSBInterfaceSubClass),
CFNumberCreate(kCFAllocatorDefault,
kCFNumberSInt32Type, &if_subclass));
CFDictionarySetValue(matchingDict, CFSTR(kUSBInterfaceProtocol),
CFNumberCreate(kCFAllocatorDefault,
kCFNumberSInt32Type, &if_protocol));
IOServiceAddMatchingNotification(
notificationPort,
kIOFirstMatchNotification,
matchingDict,
AndroidInterfaceAdded,
NULL,
¬ificationIterators[i]);
//* Iterate over set of matching interfaces to access already-present
//* devices and to arm the notification
AndroidInterfaceAdded(NULL, notificationIterators[i]);
}
return 0;
}
int
main(void)
{
CFMutableDictionaryRef match;
IONotificationPortRef notifyPort;
CFRunLoopSourceRef notificationRunLoopSource;
io_iterator_t notificationIn, notificationOut;
// Create a matching dictionary for all IOMedia objects.
if (!(match = IOServiceMatching("IOMedia"))) {
fprintf(stderr, "*** failed to create matching dictionary.\n");
exit(1);
}
// Create a notification object for receiving I/O Kit notifications.
notifyPort = IONotificationPortCreate(kIOMasterPortDefault);
// Get a CFRunLoopSource that we will use to listen for notifications.
notificationRunLoopSource = IONotificationPortGetRunLoopSource(notifyPort);
// Add the CFRunLoopSource to the default mode of our current run loop.
CFRunLoopAddSource(CFRunLoopGetCurrent(), notificationRunLoopSource,
kCFRunLoopDefaultMode);
// One reference of the matching dictionary will be consumed when we install
// a notification request. Since we need to install two such requests (one
// for ejectable media coming in and another for it going out), we need
// to increment the reference count on our matching dictionary.
CFRetain(match);
// Install notification request for matching objects coming in.
// Note that this will also look up already existing objects.
IOServiceAddMatchingNotification(
notifyPort, // notification port reference
kIOMatchedNotification, // notification type
match, // matching dictionary
matchingCallback, // this is called when notification fires
NULL, // reference constant
¬ificationIn); // iterator handle
// Install notification request for matching objects going out.
IOServiceAddMatchingNotification(
notifyPort,
kIOTerminatedNotification,
match,
matchingCallback,
NULL,
¬ificationOut);
// Invoke callbacks explicitly to empty the iterators/arm the notifications.
matchingCallback(0, notificationIn);
matchingCallback(0, notificationOut);
CFRunLoopRun(); // run
exit(0);
}
/*! Deregisters the daemon with the kernel to no longer receive power events. */
void iSCSIDDeregisterForPowerEvents()
{
CFRunLoopRemoveSource(CFRunLoopGetCurrent(),
IONotificationPortGetRunLoopSource(powerNotifyPortRef),
kCFRunLoopDefaultMode);
IODeregisterForSystemPower(&powerNotifier);
IOServiceClose(powerPlaneRoot);
IONotificationPortDestroy(powerNotifyPortRef);
}
void InitUPSNotifications()
{
CFMutableDictionaryRef matchingDict;
CFMutableDictionaryRef propertyDict;
kern_return_t kr;
// Create a notification port and add its run loop event source to our run loop
// This is how async notifications get set up.
//
gNotifyPort = IONotificationPortCreate(kIOMasterPortDefault);
CFRunLoopAddSource( CFRunLoopGetCurrent(),
IONotificationPortGetRunLoopSource(gNotifyPort),
kCFRunLoopDefaultMode);
// Create the IOKit notifications that we need
//
matchingDict = IOServiceMatching(kIOServiceClass);
if (!matchingDict)
return;
propertyDict = CFDictionaryCreateMutable(kCFAllocatorDefault,
0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (!propertyDict)
{
CFRelease(matchingDict);
return;
}
// We are only interested in devices that have kIOUPSDeviceKey property set
CFDictionarySetValue(propertyDict, CFSTR(kIOUPSDeviceKey), kCFBooleanTrue);
CFDictionarySetValue(matchingDict, CFSTR(kIOPropertyMatchKey), propertyDict);
CFRelease(propertyDict);
// Now set up a notification to be called when a device is first matched by I/O Kit.
// Note that this will not catch any devices that were already plugged in so we take
// care of those later.
kr = IOServiceAddMatchingNotification(gNotifyPort, // notifyPort
kIOFirstMatchNotification, // notificationType
matchingDict, // matching
UPSDeviceAdded, // callback
NULL, // refCon
&gAddedIter // notification
);
if ( kr != kIOReturnSuccess )
return;
UPSDeviceAdded( NULL, gAddedIter );
}
bool mac_sleep_start()
{
if (!root_port)
{
root_port = IORegisterForSystemPower(this, ¬ifyPortRef, callback_static, ¬ifierObject);
if (!root_port)
return false;
CFRunLoopAddSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notifyPortRef), kCFRunLoopCommonModes);
}
return true;
}
bool HIDDevice::setupDevicePluggedInNotification()
{
// Setup notification when devices are plugged in.
RepluggedNotificationPort = IONotificationPortCreate(kIOMasterPortDefault);
CFRunLoopSourceRef notificationRunLoopSource =
IONotificationPortGetRunLoopSource(RepluggedNotificationPort);
CFRunLoopAddSource(HIDManager->getRunLoop(),
notificationRunLoopSource,
kCFRunLoopDefaultMode);
CFMutableDictionaryRef matchingDict = IOServiceMatching(kIOUSBDeviceClassName);
// Have to specify vendorId and productId. Doesn't seem to accept additional
// things like serial number.
SInt32 vendorId = DevDesc.VendorId;
CFNumberRef numberRef = CFNumberCreate(kCFAllocatorDefault,
kCFNumberSInt32Type,
&vendorId);
CFDictionarySetValue(matchingDict, CFSTR(kUSBVendorID), numberRef);
CFRelease(numberRef);
SInt32 deviceProductId = DevDesc.ProductId;
numberRef = CFNumberCreate(kCFAllocatorDefault,
kCFNumberSInt32Type,
&deviceProductId);
CFDictionarySetValue(matchingDict, CFSTR(kUSBProductID), numberRef);
CFRelease(numberRef);
kern_return_t result =
IOServiceAddMatchingNotification(RepluggedNotificationPort,
kIOMatchedNotification,
matchingDict,
staticDeviceAddedCallback,
this,
&RepluggedNotification);
if (result != KERN_SUCCESS)
{
CFRelease(RepluggedNotificationPort);
RepluggedNotificationPort = 0;
return false;
}
// Iterate through to arm.
while (IOIteratorNext(RepluggedNotification))
{
}
return true;
}
// m_LoopRef needs to be set before this is called
void InputHandler_MacOSX_HID::StartDevices()
{
int n = 0;
ASSERT( m_LoopRef );
FOREACH( HIDDevice *, m_vDevices, i )
(*i)->StartQueue( m_LoopRef, InputHandler_MacOSX_HID::QueueCallback, this, n++ );
CFRunLoopSourceRef runLoopSource = IONotificationPortGetRunLoopSource( m_NotifyPort );
CFRunLoopAddSource( m_LoopRef, runLoopSource, kCFRunLoopDefaultMode );
}
void
COSXScreen::watchSystemPowerThread(void*)
{
io_object_t notifier;
IONotificationPortRef notificationPortRef;
CFRunLoopSourceRef runloopSourceRef = 0;
m_pmRunloop = CFRunLoopGetCurrent();
// install system power change callback
m_pmRootPort = IORegisterForSystemPower(this, ¬ificationPortRef,
powerChangeCallback, ¬ifier);
if (m_pmRootPort == 0) {
LOG((CLOG_WARN "IORegisterForSystemPower failed"));
}
else {
runloopSourceRef =
IONotificationPortGetRunLoopSource(notificationPortRef);
CFRunLoopAddSource(m_pmRunloop, runloopSourceRef,
kCFRunLoopCommonModes);
}
// thread is ready
{
CLock lock(m_pmMutex);
*m_pmThreadReady = true;
m_pmThreadReady->signal();
}
// if we were unable to initialize then exit. we must do this after
// setting m_pmThreadReady to true otherwise the parent thread will
// block waiting for it.
if (m_pmRootPort == 0) {
return;
}
// start the run loop
LOG((CLOG_DEBUG "started watchSystemPowerThread"));
CFRunLoopRun();
// cleanup
if (notificationPortRef) {
CFRunLoopRemoveSource(m_pmRunloop,
runloopSourceRef, kCFRunLoopDefaultMode);
CFRunLoopSourceInvalidate(runloopSourceRef);
CFRelease(runloopSourceRef);
}
CLock lock(m_pmMutex);
IODeregisterForSystemPower(¬ifier);
m_pmRootPort = 0;
LOG((CLOG_DEBUG "stopped watchSystemPowerThread"));
}
int main( int argc, char **argv ) {
IONotificationPortRef notifyPortRef;
io_object_t notifierObject;
void* refCon;
root_port = IORegisterForSystemPower( refCon, ¬ifyPortRef, MySleepCallBack, ¬ifierObject );
if ( root_port == 0 ) {
printf("IORegisterForSystemPower failed\n");
return 1;
}
CFRunLoopAddSource( CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notifyPortRef), kCFRunLoopCommonModes );
CFRunLoopRun();
return (0);
}
MacSystemWatch::MacSystemWatch()
{
// Initialize sleep callback
IONotificationPortRef notify;
io_object_t anIterator;
root_port = IORegisterForSystemPower(this, ¬ify, sleepCallBack, &anIterator);
if (!root_port) {
printf("IORegisterForSystemPower failed\n");
}
else {
CFRunLoopAddSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notify), kCFRunLoopCommonModes);
}
}
void SystemEventsManager::stopLoop(bool forceStop) {
if (systemEventLoopRunning && (forceStop || allEventsDisabled())) {
CFRunLoopRemoveSource(CFRunLoopGetCurrent(),
IONotificationPortGetRunLoopSource(notifyPortRef),
kCFRunLoopCommonModes);
IODeregisterForSystemPower(¬ifierObject);
IOServiceClose(rootPort);
IONotificationPortDestroy(notifyPortRef);
CFRunLoopStop(CFRunLoopGetCurrent());
systemEventLoopRunning = false;
}
}
static void initializePowerNotifications (void)
{
static io_connect_t rootPort; /* used by powerCallback() via context pointer */
IONotificationPortRef notificationPort;
io_object_t notifier;
rootPort = IORegisterForSystemPower(&rootPort, ¬ificationPort, powerCallback, ¬ifier);
if (! rootPort) {
message (LOG_ERR, "IORegisterForSystemPower failed\n");
exit (1);
}
CFRunLoopAddSource (CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notificationPort), kCFRunLoopDefaultMode);
}
void IOKitEventPublisher::restart() {
static std::vector<const std::string*> device_classes = {
&kIOUSBDeviceClassName_,
&kIOPCIDeviceClassName_,
&kIOPlatformExpertDeviceClassName_,
&kIOACPIPlatformDeviceClassName_,
&kIOPlatformDeviceClassname_,
};
if (run_loop_ == nullptr) {
return;
}
// Remove any existing stream.
stop();
{
WriteLock lock(mutex_);
port_ = IONotificationPortCreate(kIOMasterPortDefault);
// Get a run loop source from the created IOKit notification port.
auto run_loop_source = IONotificationPortGetRunLoopSource(port_);
CFRunLoopAddSource(run_loop_, run_loop_source, kCFRunLoopDefaultMode);
}
publisher_started_ = false;
for (const auto& class_name : device_classes) {
// Service matching is USB for now, must find a way to get more!
// Can provide a "IOPCIDevice" here too.
auto matches = IOServiceMatching(class_name->c_str());
// Register attach/detaches (could use kIOPublishNotification).
// Notification types are defined in IOKitKeys.
IOReturn result = kIOReturnSuccess + 1;
{
WriteLock lock(mutex_);
result = IOServiceAddMatchingNotification(
port_,
kIOFirstMatchNotification,
matches,
(IOServiceMatchingCallback)deviceAttach,
this,
&iterator_);
}
if (result == kIOReturnSuccess) {
deviceAttach(this, iterator_);
}
}
publisher_started_ = true;
}
/*! Registers the daemon with the kernel to receive power events
* (e.g., sleep/wake notifications).
* @return true if the daemon was successfully registered. */
bool iSCSIDRegisterForPowerEvents()
{
powerPlaneRoot = IORegisterForSystemPower(NULL,
&powerNotifyPortRef,
iSCSIDHandlePowerEvent,
&powerNotifier);
if(powerPlaneRoot == 0)
return false;
CFRunLoopAddSource(CFRunLoopGetMain(),
IONotificationPortGetRunLoopSource(powerNotifyPortRef),
kCFRunLoopDefaultMode);
return true;
}
HostPowerServiceDarwin::~HostPowerServiceDarwin()
{
/* Jump out of the run loop. */
CFRunLoopStop(mRunLoop);
/* Remove the sleep notification port from the application runloop. */
CFRunLoopRemoveSource(CFRunLoopGetCurrent(),
IONotificationPortGetRunLoopSource(mNotifyPort),
kCFRunLoopCommonModes);
/* Deregister for system sleep notifications. */
IODeregisterForSystemPower(&mNotifierObject);
/* IORegisterForSystemPower implicitly opens the Root Power Domain
* IOService so we close it here. */
IOServiceClose(mRootPort);
/* Destroy the notification port allocated by IORegisterForSystemPower */
IONotificationPortDestroy(mNotifyPort);
}
void *RunLoop(void * arg)
{
runLoopSource = IONotificationPortGetRunLoopSource(gNotifyPort);
gRunLoop = CFRunLoopGetCurrent();
CFRunLoopAddSource(gRunLoop, runLoopSource, kCFRunLoopDefaultMode);
// Start the run loop. Now we'll receive notifications.
CFRunLoopRun();
// We should never get here
fprintf(stderr, "Unexpectedly back from CFRunLoopRun()!\n");
return NULL;
}
void SystemEventsManager::runLoop() {
void* refCon = nullptr;
rootPort = IORegisterForSystemPower(refCon,
¬ifyPortRef,
systemEventCallback,
¬ifierObject);
if (rootPort != 0)
{
systemEventLoopRunning = true;
CFRunLoopAddSource(CFRunLoopGetCurrent(),
IONotificationPortGetRunLoopSource(notifyPortRef),
kCFRunLoopCommonModes);
CFRunLoopRun();
}
}
static PyObject *pypowerobserver_run(PyPowerObserver *self,
PyObject *args,
PyObject *kwargs)
{
if (!PyArg_ParseTuple(args, ":run"))
return NULL;
self->runLoop = CFRunLoopGetCurrent();
CFRunLoopAddSource (self->runLoop, IONotificationPortGetRunLoopSource(self->notificationPort), kCFRunLoopDefaultMode);
Py_BEGIN_ALLOW_THREADS
CFRunLoopRun();
Py_END_ALLOW_THREADS
Py_INCREF(Py_None);
return Py_None;
}
