static int
_gcdpoll_watch_add(AvahiWatch *w, AvahiWatchEvent a_events)
{
dispatch_source_t sr = NULL;
dispatch_source_t sw = NULL;
if ((a_events & AVAHI_WATCH_IN) && !w->w_read)
{
sr = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, w->fd, 0, mdns_sq);
if (!sr)
return -1;
dispatch_set_context(sr, w);
dispatch_source_set_event_handler_f(sr, gcdpollcb_watch_read);
}
if ((a_events & AVAHI_WATCH_OUT) && !w->w_write)
{
sw = dispatch_source_create(DISPATCH_SOURCE_TYPE_WRITE, w->fd, 0, mdns_sq);
if (!sw)
{
if (sr)
{
dispatch_source_cancel(sr);
dispatch_release(sr);
}
return -1;
}
dispatch_set_context(sw, w);
dispatch_source_set_event_handler_f(sw, gcdpollcb_watch_write);
}
if (sr)
{
w->w_read = sr;
dispatch_resume(sr);
}
if (sw)
{
w->w_write = sw;
dispatch_resume(sw);
}
return 0;
}
int
main(int argc, char* argv[])
{
// interval is 1/10th of a second
uint64_t interval = NSEC_PER_SEC / 10;
// for 25 seconds
struct timeval now_tv;
struct timespec now_ts;
interval_d = (double)interval / (double)NSEC_PER_SEC;
target = (unsigned int)(25 / interval_d);
test_start("Timer drift test");
timeBeginPeriod(1);
timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
test_ptr_notnull("DISPATCH_SOURCE_TYPE_TIMER", timer);
dispatch_source_set_event_handler_f(timer, timer_handler);
gettimeofday(&now_tv, NULL);
now_ts.tv_sec = now_tv.tv_sec;
now_ts.tv_nsec = now_tv.tv_usec * NSEC_PER_USEC;
dispatch_source_set_timer(timer, dispatch_walltime(&now_ts, interval), interval, 0);
dispatch_resume(as_do(timer));
dispatch_main();
return 0;
}
void WorkQueue::registerMachPortEventHandler(mach_port_t machPort, MachPortEventType eventType, const Function<void()>& function)
{
ASSERT(machPort != MACH_PORT_NULL);
dispatch_source_type_t sourceType = 0;
switch (eventType) {
case MachPortDataAvailable:
sourceType = DISPATCH_SOURCE_TYPE_MACH_RECV;
break;
case MachPortDeadNameNotification:
sourceType = DISPATCH_SOURCE_TYPE_MACH_SEND;
break;
}
dispatch_source_t dispatchSource = dispatch_source_create(sourceType, machPort, 0, m_dispatchQueue);
EventSource* eventSource = new EventSource(eventType, dispatchSource, function);
dispatch_set_context(dispatchSource, eventSource);
dispatch_source_set_event_handler_f(dispatchSource, &EventSource::eventHandler);
dispatch_source_set_cancel_handler_f(dispatchSource, &EventSource::cancelHandler);
dispatch_set_finalizer_f(dispatchSource, &EventSource::finalizeHandler);
// Add the source to our set of sources.
{
MutexLocker locker(m_eventSourcesMutex);
ASSERT(!m_eventSources.contains(machPort));
m_eventSources.set(machPort, eventSource);
// And start it!
dispatch_resume(dispatchSource);
}
}
static void do_test(void)
{
size_t i;
char buf[1000];
count_down = COUNT;
start = dispatch_time(0,0);
for (i = 0; i < COUNT; i++) {
#ifdef WIN32
_snprintf(buf, sizeof(buf), "com.example.starfish-node#%ld", i);
#else
snprintf(buf, sizeof(buf), "com.example.starfish-node#%ld", (long int)i);
#endif
queues[i] = dispatch_queue_create(buf, NULL);
dispatch_suspend(queues[i]);
}
for (i = 0; i < COUNT; i++) {
dispatch_async_f(queues[i], queues[i], start_node);
}
for (i = 0; i < COUNT; i++) {
dispatch_resume(queues[i]);
}
}
/* Called when a new client connects */
BOOL mf_peer_init(freerdp_peer* client)
{
client->ContextSize = sizeof(mfPeerContext);
client->ContextNew = (psPeerContextNew) mf_peer_context_new;
client->ContextFree = (psPeerContextFree) mf_peer_context_free;
if (!freerdp_peer_context_new(client))
return FALSE;
info_event_queue = mf_event_queue_new();
info_queue = dispatch_queue_create("FreeRDP.update.timer", DISPATCH_QUEUE_SERIAL);
info_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, info_queue);
if(info_timer)
{
//DEBUG_WARN( "created timer\n");
dispatch_source_set_timer(info_timer, DISPATCH_TIME_NOW, 42ull * NSEC_PER_MSEC, 100ull * NSEC_PER_MSEC);
dispatch_source_set_event_handler(info_timer, ^{
//DEBUG_WARN( "dispatch\n");
mfEvent* event = mf_event_new(MF_EVENT_TYPE_FRAME_TICK);
mf_event_push(info_event_queue, (mfEvent*) event);}
);
dispatch_resume(info_timer);
}
static void do_test(void)
{
size_t i;
char buf[1000];
dispatch_group_t g = dispatch_group_create();
for (i = 0; i < QUEUES; i++) {
#ifdef WIN32
_snprintf(buf, sizeof(buf), "com.example.memoryload-node#%ld", i);
#else
snprintf(buf, sizeof(buf), "com.example.memoryload-node#%ld", (long int)i);
#endif
queues[i] = dispatch_queue_create(buf, NULL);
dispatch_suspend(queues[i]);
}
for (i = 0; i < QUEUES; i++) {
dispatch_group_async_f(g, queues[i], g, start_node);
}
dispatch_group_notify_f(g, dispatch_get_main_queue(), NULL, collect);
for (i = 0; i < QUEUES; i++) {
dispatch_resume(queues[i]);
dispatch_release(queues[i]);
}
}
void WebProcess::platformInitializeWebProcess(const WebProcessCreationParameters& parameters, CoreIPC::MessageDecoder&)
{
m_networkAccessManager = new QtNetworkAccessManager(this);
ASSERT(!parameters.cookieStorageDirectory.isEmpty() && !parameters.cookieStorageDirectory.isNull());
WebCore::SharedCookieJarQt* jar = WebCore::SharedCookieJarQt::create(parameters.cookieStorageDirectory);
m_networkAccessManager->setCookieJar(jar);
// Do not let QNetworkAccessManager delete the jar.
jar->setParent(0);
ASSERT(!parameters.diskCacheDirectory.isEmpty() && !parameters.diskCacheDirectory.isNull());
QNetworkDiskCache* diskCache = new QNetworkDiskCache();
diskCache->setCacheDirectory(parameters.diskCacheDirectory);
// The m_networkAccessManager takes ownership of the diskCache object upon the following call.
m_networkAccessManager->setCache(diskCache);
#if defined(Q_OS_MACX)
pid_t ppid = getppid();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_PROC, ppid, DISPATCH_PROC_EXIT, queue);
if (source) {
dispatch_source_set_event_handler_f(source, parentProcessDiedCallback);
dispatch_resume(source);
}
#endif
WebCore::RuntimeEnabledFeatures::setSpeechInputEnabled(false);
// We'll only install the Qt builtin bundle if we don't have one given by the UI process.
// Currently only WTR provides its own bundle.
if (parameters.injectedBundlePath.isEmpty()) {
m_injectedBundle = InjectedBundle::create(String());
m_injectedBundle->setSandboxExtension(SandboxExtension::create(parameters.injectedBundlePathExtensionHandle));
QtBuiltinBundle::shared().initialize(toAPI(m_injectedBundle.get()));
}
}
static void closeSocketClient(SocketClientRef client)
{
dispatch_resume(client->source);
dispatch_source_cancel(client->source);
dispatch_release(client->source);
close(client->fd);
free(client);
}
DispatchSource createSourceTimer(void * ctx, dispatch_function_t handler)
{
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0,
DISPATCH_TARGET_QUEUE_DEFAULT);
dispatch_set_context(source, ctx);
dispatch_source_set_event_handler_f(source, handler);
dispatch_resume(source);
return DispatchSource(source);
}
DispatchSource createSourceSignal(int sig, void * ctx, dispatch_function_t handler)
{
signal(sig, SIG_IGN);
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, sig, 0,
DISPATCH_TARGET_QUEUE_DEFAULT);
dispatch_set_context(source, ctx);
dispatch_source_set_event_handler_f(source, handler);
dispatch_resume(source);
return DispatchSource(source);
}
static VALUE
rb_dispatch_resume(VALUE self, SEL sel)
{
rb_dispatch_obj_t *dobj = RDispatch(self);
OSSpinLockLock(&_suspensionLock);
if (dobj->suspension_count > 0) {
dobj->suspension_count--;
dispatch_resume(dobj->obj);
}
OSSpinLockUnlock(&_suspensionLock);
return Qnil;
}
void IOHIDEventSystemStatistics::scheduleWithDispatchQueue(dispatch_queue_t queue)
{
_dispatch_queue = queue;
if ( _dispatch_queue ) {
_pending_source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0));
dispatch_set_context(_pending_source, this);
dispatch_source_set_event_handler_f(_pending_source, IOHIDEventSystemStatistics::handlePendingStats);
dispatch_resume(_pending_source);
notify_register_dispatch( "com.apple.iokit.hid.displayStatus", &_displayToken,_dispatch_queue, ^(__unused int token){
notify_get_state(_displayToken, &_displayState);
});
}
static void
rb_source_finalize(void *rcv, SEL sel)
{
rb_source_t *src = RSource(rcv);
if (src->source != NULL) {
OSSpinLockLock(&_suspensionLock);
while (src->suspension_count > 0) {
src->suspension_count--;
dispatch_resume(src->source);
}
dispatch_release(src->source);
OSSpinLockUnlock(&_suspensionLock);
}
if (rb_source_finalize_super != NULL) {
((void(*)(void *, SEL))rb_source_finalize_super)(rcv, sel);
}
}
void
test_fin(void *cxt)
{
fprintf(stderr, "Called back every %llu us on average\n",
(delay/count)/NSEC_PER_USEC);
test_long_less_than("Frequency", 1, ceil((double)delay/(count*interval)));
int i;
for (i = 0; i < N; i++) {
dispatch_source_cancel(t[i]);
dispatch_release(t[i]);
}
dispatch_resume(q);
dispatch_release(q);
dispatch_release(g);
test_ptr("finalizer ran", cxt, cxt);
test_stop();
}
static int
_gcdpoll_timeout_add(AvahiTimeout *t, const struct timeval *tv)
{
struct timeval e_tv;
struct timeval now;
int64_t nsecs;
int ret;
ret = gettimeofday(&now, NULL);
if (ret != 0)
return -1;
if (!t->timer)
{
t->timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, mdns_sq);
if (!t->timer)
return -1;
dispatch_set_context(t->timer, t);
dispatch_source_set_event_handler_f(t->timer, gcdpollcb_timer);
}
else
dispatch_suspend(t->timer);
if ((tv->tv_sec == 0) && (tv->tv_usec == 0))
{
dispatch_source_set_timer(t->timer,
DISPATCH_TIME_NOW,
DISPATCH_TIME_FOREVER /* one-shot */, 0);
}
else
{
timersub(tv, &now, &e_tv);
nsecs = e_tv.tv_sec * NSEC_PER_SEC + e_tv.tv_usec * 1000;
dispatch_source_set_timer(t->timer,
dispatch_time(DISPATCH_TIME_NOW, nsecs),
DISPATCH_TIME_FOREVER /* one-shot */, 0);
}
dispatch_resume(t->timer);
return 0;
}
void
test_short_timer(void)
{
// Add a large number of timers with suspended target queue in front of
// the timer being measured <rdar://problem/7401353>
g = dispatch_group_create();
q = dispatch_queue_create("q", NULL);
int i;
for (i = 0; i < N; i++) {
t[i] = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, q);
dispatch_source_set_timer(t[i], DISPATCH_TIME_NOW, interval, 0);
dispatch_group_enter(g);
dispatch_source_set_registration_handler(t[i], ^{
dispatch_suspend(t[i]);
dispatch_group_leave(g);
});
dispatch_resume(t[i]);
}
int main(int argc, const char *argv[]) {
done = dispatch_semaphore_create(0);
dispatch_queue_t queue =
dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_source_t source =
dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, SIGHUP, 0, queue);
global = 42;
dispatch_source_set_registration_handler_f(source, handler);
dispatch_resume(source);
dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);
return 0;
}
int
main(void)
{
dispatch_queue_t main_q;
test_start("Dispatch Update Timer");
main_q = dispatch_get_main_queue();
test_ptr("dispatch_get_main_queue", main_q, dispatch_get_current_queue());
timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, main_q);
dispatch_source_set_timer(timer, 1000000000ull, 0, 0);
dispatch_source_set_cancel_handler_f(timer, cancel_handler);
dispatch_source_set_event_handler_f(timer, event_handler);
test_ptr_notnull("dispatch_source_timer_create", timer);
gettimeofday(&start_time, NULL);
dispatch_resume(as_do(timer));
dispatch_main();
}
static void
rb_queue_finalize(void *rcv, SEL sel)
{
rb_queue_t *queue = RQueue(rcv);
if (queue->queue != NULL)
{
OSSpinLockLock(&_suspensionLock);
while (queue->suspension_count > 0) {
queue->suspension_count--;
dispatch_resume(queue->queue);
}
if (queue->should_release_queue) {
dispatch_release(queue->queue);
queue->should_release_queue = 0;
}
OSSpinLockUnlock(&_suspensionLock);
}
if (rb_queue_finalize_super != NULL) {
((void(*)(void *, SEL))rb_queue_finalize_super)(rcv, sel);
}
}
/* Called when a new client connects */
void mf_peer_init(freerdp_peer* client)
{
client->context_size = sizeof(mfPeerContext);
client->ContextNew = (psPeerContextNew) mf_peer_context_new;
client->ContextFree = (psPeerContextFree) mf_peer_context_free;
freerdp_peer_context_new(client);
info_event_queue = mf_event_queue_new();
info_queue = dispatch_queue_create("testing.101", DISPATCH_QUEUE_SERIAL);
info_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, info_queue);
if(info_timer)
{
//printf("created timer\n");
dispatch_source_set_timer(info_timer, DISPATCH_TIME_NOW, 42ull * NSEC_PER_MSEC, 100ull * NSEC_PER_MSEC);
dispatch_source_set_event_handler(info_timer, ^{
//printf("dispatch\n");
mfEvent* event = mf_event_new(MF_EVENT_TYPE_FRAME_TICK);
mf_event_push(info_event_queue, (mfEvent*) event);}
);
dispatch_resume(info_timer);
}
void object::resume()
{
dispatch_resume( native() );
}
static void
prime(void)
{
struct ifaddrs *ifap = NULL;
struct ifaddrs *scan;
int sock = -1;
SCLog(_verbose, LOG_DEBUG, CFSTR("prime() called"));
cache_open();
sock = dgram_socket(AF_INET);
if (sock == -1) {
SCLog(TRUE, LOG_ERR, CFSTR("could not get interface list, socket() failed: %s"), strerror(errno));
goto done;
}
if (getifaddrs(&ifap) == -1) {
SCLog(TRUE,
LOG_ERR,
CFSTR("could not get interface info, getifaddrs() failed: %s"),
strerror(errno));
goto done;
}
/* update list of interfaces & link status */
for (scan = ifap; scan != NULL; scan = scan->ifa_next) {
if (scan->ifa_addr == NULL
|| scan->ifa_addr->sa_family != AF_LINK) {
continue;
}
/* get the per-interface link/media information */
link_add(scan->ifa_name);
}
/*
* update IPv4 network addresses already assigned to
* the interfaces.
*/
ipv4_interface_update(ifap, NULL);
/*
* update IPv6 network addresses already assigned to
* the interfaces.
*/
interface_update_ipv6(ifap, NULL);
freeifaddrs(ifap);
done:
if (sock != -1)
close(sock);
cache_write(store);
cache_close();
network_changed = TRUE;
post_network_changed();
/* start handling kernel events */
dispatch_resume(S_kev_source);
return;
}
static void mode_changed()
{
switch (mmkd_mode) {
/*
* merge mode enabled: create event tap, cancel idle timer (if any)
*/
case 1: {
if (idle_timer) {
dispatch_source_cancel(idle_timer);
dispatch_release(idle_timer);
idle_timer = NULL;
}
if (!event_tap) {
/*
* reset ktab
*/
struct key_kind *i;
for (i=ktab; i->kk_name; i++)
i->kk_num_pressed = 0;
/*
* become root (this is neccessary in order to create event tap)
*/
seteuid(0);
/*
* based on alterkeys.c http://osxbook.com and http://dotdotcomorg.net
*/
CGEventMask event_mask;
CFRunLoopSourceRef run_loop_source;
// Create an event tap. We are interested in key presses.
event_mask = ((1 << kCGEventKeyDown) | (1 << kCGEventKeyUp) | (1<<kCGEventFlagsChanged));
event_tap = CGEventTapCreate(kCGSessionEventTap, kCGHeadInsertEventTap, 0,
event_mask, my_cg_event_callback, NULL);
/*
* revert to self
*/
seteuid(getuid());
if (!event_tap) {
fprintf(stderr, "failed to create event tap\n");
return;
}
// Create a run loop source.
run_loop_source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, event_tap, 0);
// Add to the current run loop.
CFRunLoopAddSource(CFRunLoopGetMain(), run_loop_source,
kCFRunLoopCommonModes);
// Enable the event tap.
CGEventTapEnable(event_tap, true);
}
return;
}
/*
* merge mode disabled: remove event tap (if any), setup idle timer
*/
case 0: {
if (event_tap) {
CFMachPortInvalidate(event_tap);
CFRelease(event_tap);
event_tap = NULL;
}
if (!idle_timer) {
idle_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER,
0, 0, dispatch_get_main_queue());
if (!idle_timer) {
fprintf(stderr, "out of memory\n");
return;
}
dispatch_source_set_event_handler(idle_timer, ^{
CFRunLoopStop(CFRunLoopGetMain());
});
dispatch_source_set_timer(idle_timer,
dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC*5LL),
-1, NSEC_PER_SEC*1LL);
dispatch_resume(idle_timer);
}
return;
}
