void PrintOmxEvent(vlc_object_t *p_this, OMX_EVENTTYPE event, OMX_U32 data_1, OMX_U32 data_2, OMX_PTR event_data) { switch (event) { case OMX_EventCmdComplete: switch ((OMX_STATETYPE)data_1) { case OMX_CommandStateSet: msg_Dbg( p_this, "OmxEventHandler (%s, %s, %s)", EventToString(event), CommandToString(data_1), StateToString(data_2) ); break; default: msg_Dbg( p_this, "OmxEventHandler (%s, %s, %u)", EventToString(event), CommandToString(data_1), (unsigned int)data_2 ); break; } break; case OMX_EventError: msg_Dbg( p_this, "OmxEventHandler (%s, %s, %u, %s)", EventToString(event), ErrorToString((OMX_ERRORTYPE)data_1), (unsigned int)data_2, (const char *)event_data); break; default: msg_Dbg( p_this, "OmxEventHandler (%s, %u, %u)", EventToString(event), (unsigned int)data_1, (unsigned int)data_2 ); break; } }
void Channel::handleEvents() { LOG_INFO << "handle event " << sockfd_ << " events " << EventToString(r_events_); if ( (r_events_ & EPOLLRDHUP ) && (r_events_ & EPOLLIN) ) { LOG_INFO << "handle close" ; if (closeCallBack_) { closeCallBack_(); return; } } if ( r_events_ & EPOLLIN ) { LOG_INFO << "handle read" ; if (readCallBack_) { readCallBack_(); return; } } if (r_events_ & EPOLLOUT ) { LOG_INFO << "handle write" ; if (writeCallBack_) writeCallBack_(); } if (r_events_ & EPOLLERR) { LOG_INFO << "handle error" ; if (errorCallBack_) errorCallBack_(); } };
/*----------------------------------------------------------------------------*/ inline int AddEpollEvent(struct mtcp_epoll *ep, int queue_type, socket_map_t socket, uint32_t event) { struct event_queue *eq; int index; if (!ep || !socket || !event) return -1; ep->stat.issued++; if (socket->events & event) { return 0; } if (queue_type == MTCP_EVENT_QUEUE) { eq = ep->mtcp_queue; } else if (queue_type == USR_EVENT_QUEUE) { eq = ep->usr_queue; pthread_mutex_lock(&ep->epoll_lock); } else if (queue_type == USR_SHADOW_EVENT_QUEUE) { eq = ep->usr_shadow_queue; } else { TRACE_ERROR("Non-existing event queue type!\n"); return -1; } if (eq->num_events >= eq->size) { TRACE_ERROR("Exceeded epoll event queue! num_events: %d, size: %d\n", eq->num_events, eq->size); if (queue_type == USR_EVENT_QUEUE) pthread_mutex_unlock(&ep->epoll_lock); return -1; } index = eq->end++; socket->events |= event; eq->events[index].sockid = socket->id; eq->events[index].ev.events = event; eq->events[index].ev.data = socket->ep_data; if (eq->end >= eq->size) { eq->end = 0; } eq->num_events++; #if 0 TRACE_EPOLL("Socket %d New event: %s, start: %u, end: %u, num: %u\n", ep->events[index].sockid, EventToString(ep->events[index].ev.events), ep->start, ep->end, ep->num_events); #endif if (queue_type == USR_EVENT_QUEUE) pthread_mutex_unlock(&ep->epoll_lock); ep->stat.registered++; return 0; }
/*----------------------------------------------------------------------------*/ int mtcp_epoll_wait(mctx_t mctx, int epid, struct mtcp_epoll_event *events, int maxevents, int timeout) { mtcp_manager_t mtcp; struct mtcp_epoll *ep; struct event_queue *eq; struct event_queue *eq_shadow; socket_map_t event_socket; int validity; int i, cnt, ret; int num_events; mtcp = GetMTCPManager(mctx); if (!mtcp) { return -1; } if (epid < 0 || epid >= CONFIG.max_concurrency) { TRACE_API("Epoll id %d out of range.\n", epid); errno = EBADF; return -1; } if (mtcp->smap[epid].socktype == MTCP_SOCK_UNUSED) { errno = EBADF; return -1; } if (mtcp->smap[epid].socktype != MTCP_SOCK_EPOLL) { errno = EINVAL; return -1; } ep = mtcp->smap[epid].ep; if (!ep || !events || maxevents <= 0) { errno = EINVAL; return -1; } ep->stat.calls++; #if SPIN_BEFORE_SLEEP int spin = 0; while (ep->num_events == 0 && spin < SPIN_THRESH) { spin++; } #endif /* SPIN_BEFORE_SLEEP */ if (pthread_mutex_lock(&ep->epoll_lock)) { if (errno == EDEADLK) perror("mtcp_epoll_wait: epoll_lock blocked\n"); assert(0); } wait: eq = ep->usr_queue; eq_shadow = ep->usr_shadow_queue; /* wait until event occurs */ while (eq->num_events == 0 && eq_shadow->num_events == 0 && timeout != 0) { #if INTR_SLEEPING_MTCP /* signal to mtcp thread if it is sleeping */ if (mtcp->wakeup_flag && mtcp->is_sleeping) { pthread_kill(mtcp->ctx->thread, SIGUSR1); } #endif ep->stat.waits++; ep->waiting = TRUE; if (timeout > 0) { struct timespec deadline; clock_gettime(CLOCK_REALTIME, &deadline); if (timeout > 1000) { int sec; sec = timeout / 1000; deadline.tv_sec += sec; timeout -= sec * 1000; } if (deadline.tv_nsec >= 1000000000) { deadline.tv_sec++; deadline.tv_nsec -= 1000000000; } //deadline.tv_sec = mtcp->cur_tv.tv_sec; //deadline.tv_nsec = (mtcp->cur_tv.tv_usec + timeout * 1000) * 1000; ret = pthread_cond_timedwait(&ep->epoll_cond, &ep->epoll_lock, &deadline); if (ret && ret != ETIMEDOUT) { /* errno set by pthread_cond_timedwait() */ pthread_mutex_unlock(&ep->epoll_lock); TRACE_ERROR("pthread_cond_timedwait failed. ret: %d, error: %s\n", ret, strerror(errno)); return -1; } timeout = 0; } else if (timeout < 0) { ret = pthread_cond_wait(&ep->epoll_cond, &ep->epoll_lock); if (ret) { /* errno set by pthread_cond_wait() */ pthread_mutex_unlock(&ep->epoll_lock); TRACE_ERROR("pthread_cond_wait failed. ret: %d, error: %s\n", ret, strerror(errno)); return -1; } } ep->waiting = FALSE; if (mtcp->ctx->done || mtcp->ctx->exit || mtcp->ctx->interrupt) { mtcp->ctx->interrupt = FALSE; //ret = pthread_cond_signal(&ep->epoll_cond); pthread_mutex_unlock(&ep->epoll_lock); errno = EINTR; return -1; } } /* fetch events from the user event queue */ cnt = 0; num_events = eq->num_events; for (i = 0; i < num_events && cnt < maxevents; i++) { event_socket = &mtcp->smap[eq->events[eq->start].sockid]; validity = TRUE; if (event_socket->socktype == MTCP_SOCK_UNUSED) validity = FALSE; if (!(event_socket->epoll & eq->events[eq->start].ev.events)) validity = FALSE; if (!(event_socket->events & eq->events[eq->start].ev.events)) validity = FALSE; if (validity) { events[cnt++] = eq->events[eq->start].ev; assert(eq->events[eq->start].sockid >= 0); TRACE_EPOLL("Socket %d: Handled event. event: %s, " "start: %u, end: %u, num: %u\n", event_socket->id, EventToString(eq->events[eq->start].ev.events), eq->start, eq->end, eq->num_events); ep->stat.handled++; } else { TRACE_EPOLL("Socket %d: event %s invalidated.\n", eq->events[eq->start].sockid, EventToString(eq->events[eq->start].ev.events)); ep->stat.invalidated++; } event_socket->events &= (~eq->events[eq->start].ev.events); eq->start++; eq->num_events--; if (eq->start >= eq->size) { eq->start = 0; } } /* fetch eventes from user shadow event queue */ eq = ep->usr_shadow_queue; num_events = eq->num_events; for (i = 0; i < num_events && cnt < maxevents; i++) { event_socket = &mtcp->smap[eq->events[eq->start].sockid]; validity = TRUE; if (event_socket->socktype == MTCP_SOCK_UNUSED) validity = FALSE; if (!(event_socket->epoll & eq->events[eq->start].ev.events)) validity = FALSE; if (!(event_socket->events & eq->events[eq->start].ev.events)) validity = FALSE; if (validity) { events[cnt++] = eq->events[eq->start].ev; assert(eq->events[eq->start].sockid >= 0); TRACE_EPOLL("Socket %d: Handled event. event: %s, " "start: %u, end: %u, num: %u\n", event_socket->id, EventToString(eq->events[eq->start].ev.events), eq->start, eq->end, eq->num_events); ep->stat.handled++; } else { TRACE_EPOLL("Socket %d: event %s invalidated.\n", eq->events[eq->start].sockid, EventToString(eq->events[eq->start].ev.events)); ep->stat.invalidated++; } event_socket->events &= (~eq->events[eq->start].ev.events); eq->start++; eq->num_events--; if (eq->start >= eq->size) { eq->start = 0; } } if (cnt == 0 && timeout != 0) goto wait; pthread_mutex_unlock(&ep->epoll_lock); return cnt; }