APR_DECLARE(apr_status_t) apr_pollset_remove(apr_pollset_t *pollset, const apr_pollfd_t *descriptor) { apr_os_sock_t fd; pfd_elem_t *ep; apr_status_t rv = APR_SUCCESS; int res; pollset_lock_rings(); if (descriptor->desc_type == APR_POLL_SOCKET) { fd = descriptor->desc.s->socketdes; } else { fd = descriptor->desc.f->filedes; } res = port_dissociate(pollset->port_fd, PORT_SOURCE_FD, fd); if (res < 0) { rv = APR_NOTFOUND; } if (!APR_RING_EMPTY(&(pollset->query_ring), pfd_elem_t, link)) { for (ep = APR_RING_FIRST(&(pollset->query_ring)); ep != APR_RING_SENTINEL(&(pollset->query_ring), pfd_elem_t, link); ep = APR_RING_NEXT(ep, link)) { if (descriptor->desc.s == ep->pfd.desc.s) { APR_RING_REMOVE(ep, link); APR_RING_INSERT_TAIL(&(pollset->dead_ring), ep, pfd_elem_t, link); break; } } } if (!APR_RING_EMPTY(&(pollset->add_ring), pfd_elem_t, link)) { for (ep = APR_RING_FIRST(&(pollset->add_ring)); ep != APR_RING_SENTINEL(&(pollset->add_ring), pfd_elem_t, link); ep = APR_RING_NEXT(ep, link)) { if (descriptor->desc.s == ep->pfd.desc.s) { APR_RING_REMOVE(ep, link); APR_RING_INSERT_TAIL(&(pollset->dead_ring), ep, pfd_elem_t, link); break; } } } pollset_unlock_rings(); return rv; }
/* * NOTE: This function is not thread safe by itself. Caller should hold the lock */ static apr_thread_pool_task_t *task_new(apr_thread_pool_t * me, apr_thread_start_t func, void *param, apr_byte_t priority, void *owner, apr_time_t time) { apr_thread_pool_task_t *t; if (APR_RING_EMPTY(me->recycled_tasks, apr_thread_pool_task, link)) { t = apr_pcalloc(me->pool, sizeof(*t)); if (NULL == t) { return NULL; } } else { t = APR_RING_FIRST(me->recycled_tasks); APR_RING_REMOVE(t, link); } APR_RING_ELEM_INIT(t, link); t->func = func; t->param = param; t->owner = owner; if (time > 0) { t->dispatch.time = apr_time_now() + time; } else { t->dispatch.priority = priority; } return t; }
static apr_status_t mmap_cleanup(void *themmap) { apr_mmap_t *mm = themmap; apr_mmap_t *next = APR_RING_NEXT(mm,link); int rv = 0; /* we no longer refer to the mmaped region */ APR_RING_REMOVE(mm,link); APR_RING_NEXT(mm,link) = NULL; APR_RING_PREV(mm,link) = NULL; if (next != mm) { /* more references exist, so we're done */ return APR_SUCCESS; } #ifdef BEOS rv = delete_area(mm->area); #else rv = munmap(mm->mm, mm->size); #endif mm->mm = (void *)-1; if (rv == 0) { return APR_SUCCESS; } return errno; }
static apr_status_t remove_tasks(apr_thread_pool_t *me, void *owner) { apr_thread_pool_task_t *t_loc; apr_thread_pool_task_t *next; int seg; t_loc = APR_RING_FIRST(me->tasks); while (t_loc != APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link)) { next = APR_RING_NEXT(t_loc, link); if (t_loc->owner == owner) { --me->task_cnt; seg = TASK_PRIORITY_SEG(t_loc); if (t_loc == me->task_idx[seg]) { me->task_idx[seg] = APR_RING_NEXT(t_loc, link); if (me->task_idx[seg] == APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link) || TASK_PRIORITY_SEG(me->task_idx[seg]) != seg) { me->task_idx[seg] = NULL; } } APR_RING_REMOVE(t_loc, link); } t_loc = next; } return APR_SUCCESS; }
/** Close connection */ static apt_bool_t rtsp_server_connection_close(rtsp_server_t *server, rtsp_server_connection_t *rtsp_connection) { apr_size_t remaining_sessions = 0; if(!rtsp_connection || !rtsp_connection->sock) { return FALSE; } apt_log(RTSP_LOG_MARK,APT_PRIO_INFO,"Close RTSP Connection %s",rtsp_connection->id); apt_poller_task_descriptor_remove(server->task,&rtsp_connection->sock_pfd); apr_socket_close(rtsp_connection->sock); rtsp_connection->sock = NULL; APR_RING_REMOVE(rtsp_connection,link); remaining_sessions = apr_hash_count(rtsp_connection->session_table); if(remaining_sessions) { rtsp_server_session_t *session; void *val; apr_hash_index_t *it; apt_log(RTSP_LOG_MARK,APT_PRIO_NOTICE,"Terminate Remaining RTSP Sessions [%"APR_SIZE_T_FMT"]", remaining_sessions); it = apr_hash_first(rtsp_connection->pool,rtsp_connection->session_table); for(; it; it = apr_hash_next(it)) { apr_hash_this(it,NULL,NULL,&val); session = val; if(session && session->terminating == FALSE) { rtsp_server_session_terminate_request(server,session); } } } else { rtsp_server_connection_destroy(rtsp_connection); } return TRUE; }
/** * Grab a resource from the front of the resource list. * Assumes: that the reslist is locked. */ static apr_res_t *pop_resource(apr_reslist_t *reslist) { apr_res_t *res; res = APR_RING_FIRST(&reslist->avail_list); APR_RING_REMOVE(res, link); reslist->nidle--; return res; }
static void end_gen(mpm_gen_info_t *gi) { ap_log_error(APLOG_MARK, APLOG_TRACE4, 0, ap_server_conf, "end of generation %d", gi->gen); ap_run_end_generation(ap_server_conf, gi->gen); APR_RING_REMOVE(gi, link); APR_RING_INSERT_HEAD(unused_geninfo, gi, mpm_gen_info_t, link); }
static apr_status_t do_wait(apr_thread_cond_t *cond, apr_thread_mutex_t *mutex, apr_interval_time_t timeout) { struct waiter_t *wait; thread_id cth = find_thread(NULL); apr_status_t rv; int flags = B_RELATIVE_TIMEOUT; /* We must be the owner of the mutex or we can't do this... */ if (mutex->owner != cth) { /* What should we return??? */ return APR_EINVAL; } acquire_sem(cond->lock); wait = APR_RING_FIRST(&cond->flist); if (wait) APR_RING_REMOVE(wait, link); else wait = make_waiter(cond->pool); APR_RING_INSERT_TAIL(&cond->alist, wait, waiter_t, link); cond->condlock = mutex; release_sem(cond->lock); apr_thread_mutex_unlock(cond->condlock); if (timeout == 0) flags = 0; rv = acquire_sem_etc(wait->sem, 1, flags, timeout); apr_thread_mutex_lock(cond->condlock); if (rv != B_OK) { if (rv == B_TIMED_OUT) return APR_TIMEUP; return rv; } acquire_sem(cond->lock); APR_RING_REMOVE(wait, link); APR_RING_INSERT_TAIL(&cond->flist, wait, waiter_t, link); release_sem(cond->lock); return APR_SUCCESS; }
APT_DECLARE(apt_list_elem_t*) apt_list_elem_remove(apt_obj_list_t *list, apt_list_elem_t *elem) { apt_list_elem_t *next_elem = APR_RING_NEXT(elem,link); APR_RING_REMOVE(elem,link); if(next_elem == APR_RING_SENTINEL(&list->head,apt_list_elem_t,link)) { next_elem = NULL; } return next_elem; }
static APR_INLINE mpf_chunk_t* mpf_buffer_chunk_read(mpf_buffer_t *buffer) { mpf_chunk_t *chunk = NULL; if(!APR_RING_EMPTY(&buffer->head,mpf_chunk_t,link)) { chunk = APR_RING_FIRST(&buffer->head); APR_RING_REMOVE(chunk,link); } return chunk; }
MPF_DECLARE(void) mpf_context_factory_destroy(mpf_context_factory_t *factory) { mpf_context_t *context; while(!APR_RING_EMPTY(&factory->head, mpf_context_t, link)) { context = APR_RING_FIRST(&factory->head); mpf_context_destroy(context); APR_RING_REMOVE(context, link); } }
/* Destroy RTSP connection */ static apt_bool_t rtsp_client_connection_destroy(rtsp_client_connection_t *rtsp_connection) { rtsp_client_t *client = rtsp_connection->client; APR_RING_REMOVE(rtsp_connection,link); rtsp_client_connection_close(client,rtsp_connection); apt_log(RTSP_LOG_MARK,APT_PRIO_NOTICE,"Destroy RTSP Connection %s",rtsp_connection->id); apr_pool_destroy(rtsp_connection->pool); return TRUE; }
APT_DECLARE(void*) apt_list_pop_front(apt_obj_list_t *list) { apt_list_elem_t *elem; if(APR_RING_EMPTY(&list->head,apt_list_elem_t,link)) { return NULL; } elem = APR_RING_FIRST(&list->head); APR_RING_REMOVE(elem,link); return elem->obj; }
/** * Retrieves the next available socket from the queue. If there are no * sockets available, it will block until one becomes available. * Once retrieved, the socket is placed into the address specified by * 'sd'. */ apr_status_t ap_queue_pop_something(fd_queue_t * queue, apr_socket_t ** sd, event_conn_state_t ** ecs, apr_pool_t ** p, timer_event_t ** te_out) { fd_queue_elem_t *elem; apr_status_t rv; if ((rv = apr_thread_mutex_lock(queue->one_big_mutex)) != APR_SUCCESS) { return rv; } /* Keep waiting until we wake up and find that the queue is not empty. */ if (ap_queue_empty(queue)) { if (!queue->terminated) { apr_thread_cond_wait(queue->not_empty, queue->one_big_mutex); } /* If we wake up and it's still empty, then we were interrupted */ if (ap_queue_empty(queue)) { rv = apr_thread_mutex_unlock(queue->one_big_mutex); if (rv != APR_SUCCESS) { return rv; } if (queue->terminated) { return APR_EOF; /* no more elements ever again */ } else { return APR_EINTR; } } } *te_out = NULL; if (!APR_RING_EMPTY(&queue->timers, timer_event_t, link)) { *te_out = APR_RING_FIRST(&queue->timers); APR_RING_REMOVE(*te_out, link); } else { elem = &queue->data[queue->out]; queue->out++; if (queue->out >= queue->bounds) queue->out -= queue->bounds; queue->nelts--; *sd = elem->sd; *ecs = elem->ecs; *p = elem->p; #ifdef AP_DEBUG elem->sd = NULL; elem->p = NULL; #endif /* AP_DEBUG */ } rv = apr_thread_mutex_unlock(queue->one_big_mutex); return rv; }
static apr_status_t impl_pollset_add(apr_pollset_t *pollset, const apr_pollfd_t *descriptor) { apr_os_sock_t fd; pfd_elem_t *elem; apr_status_t rv = APR_SUCCESS; pollset_lock_rings(); if (!APR_RING_EMPTY(&(pollset->p->free_ring), pfd_elem_t, link)) { elem = APR_RING_FIRST(&(pollset->p->free_ring)); APR_RING_REMOVE(elem, link); } else { elem = (pfd_elem_t *) apr_palloc(pollset->pool, sizeof(pfd_elem_t)); APR_RING_ELEM_INIT(elem, link); } elem->pfd = *descriptor; if (descriptor->desc_type == APR_POLL_SOCKET) { fd = descriptor->desc.s->socketdes; } else { fd = descriptor->desc.f->filedes; } if (descriptor->reqevents & APR_POLLIN) { EV_SET(&pollset->p->kevent, fd, EVFILT_READ, EV_ADD, 0, 0, elem); if (kevent(pollset->p->kqueue_fd, &pollset->p->kevent, 1, NULL, 0, NULL) == -1) { rv = apr_get_netos_error(); } } if (descriptor->reqevents & APR_POLLOUT && rv == APR_SUCCESS) { EV_SET(&pollset->p->kevent, fd, EVFILT_WRITE, EV_ADD, 0, 0, elem); if (kevent(pollset->p->kqueue_fd, &pollset->p->kevent, 1, NULL, 0, NULL) == -1) { rv = apr_get_netos_error(); } } if (rv == APR_SUCCESS) { APR_RING_INSERT_TAIL(&(pollset->p->query_ring), elem, pfd_elem_t, link); } else { APR_RING_INSERT_TAIL(&(pollset->p->free_ring), elem, pfd_elem_t, link); } pollset_unlock_rings(); return rv; }
/** * Get an empty resource container from the free list. */ static apr_res_t *get_container(apr_reslist_t *reslist) { apr_res_t *res; assert(!APR_RING_EMPTY(&reslist->free_list, apr_res_t, link)); res = APR_RING_FIRST(&reslist->free_list); APR_RING_REMOVE(res, link); return res; }
/** * Get an resource container from the free list or create a new one. */ static apr_res_t *get_container(apr_reslist_t *reslist) { apr_res_t *res; if (!APR_RING_EMPTY(&reslist->free_list, apr_res_t, link)) { res = APR_RING_FIRST(&reslist->free_list); APR_RING_REMOVE(res, link); } else res = apr_pcalloc(reslist->pool, sizeof(*res)); return res; }
static apt_bool_t apt_timer_remove(apt_timer_queue_t *timer_queue, apt_timer_t *timer) { /* remove node (timer) from the list */ APR_RING_REMOVE(timer,link); timer->scheduled_time = 0; if(APR_RING_EMPTY(&timer_queue->head, apt_timer_t, link)) { /* reset elapsed time if no timers set */ timer_queue->elapsed_time = 0; } return TRUE; }
static apr_status_t impl_pollset_remove(apr_pollset_t *pollset, const apr_pollfd_t *descriptor) { pfd_elem_t *ep; apr_status_t rv = APR_SUCCESS; #ifdef HAVE_MTCP struct mtcp_epoll_event ev = {0}; #else struct epoll_event ev = {0}; /* ignored, but must be passed with * kernel < 2.6.9 */ #endif int ret = -1; if (descriptor->desc_type == APR_POLL_SOCKET) { #ifdef HAVE_MTCP int cpu = sched_getcpu(); ret = mtcp_epoll_ctl(g_mctx[cpu], pollset->p->epoll_fd, EPOLL_CTL_DEL, descriptor->desc.s->socketdes, &ev); #else ret = epoll_ctl(pollset->p->epoll_fd, EPOLL_CTL_DEL, descriptor->desc.s->socketdes, &ev); #endif } else { ret = epoll_ctl(pollset->p->epoll_fd, EPOLL_CTL_DEL, descriptor->desc.f->filedes, &ev); } if (ret < 0) { rv = APR_NOTFOUND; } if (!(pollset->flags & APR_POLLSET_NOCOPY)) { pollset_lock_rings(); for (ep = APR_RING_FIRST(&(pollset->p->query_ring)); ep != APR_RING_SENTINEL(&(pollset->p->query_ring), pfd_elem_t, link); ep = APR_RING_NEXT(ep, link)) { if (descriptor->desc.s == ep->pfd.desc.s) { APR_RING_REMOVE(ep, link); APR_RING_INSERT_TAIL(&(pollset->p->dead_ring), ep, pfd_elem_t, link); break; } } pollset_unlock_rings(); } return rv; }
/* * NOTE: This function is not thread safe by itself. Caller should hold the lock */ static apr_thread_pool_task_t *pop_task(apr_thread_pool_t * me) { apr_thread_pool_task_t *task = NULL; int seg; /* check for scheduled tasks */ if (me->scheduled_task_cnt > 0) { task = APR_RING_FIRST(me->scheduled_tasks); assert(task != NULL); assert(task != APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task, link)); /* if it's time */ if (task->dispatch.time <= apr_time_now()) { --me->scheduled_task_cnt; APR_RING_REMOVE(task, link); return task; } } /* check for normal tasks if we're not returning a scheduled task */ if (me->task_cnt == 0) { return NULL; } task = APR_RING_FIRST(me->tasks); assert(task != NULL); assert(task != APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link)); --me->task_cnt; seg = TASK_PRIORITY_SEG(task); if (task == me->task_idx[seg]) { me->task_idx[seg] = APR_RING_NEXT(task, link); if (me->task_idx[seg] == APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link) || TASK_PRIORITY_SEG(me->task_idx[seg]) != seg) { me->task_idx[seg] = NULL; } } APR_RING_REMOVE(task, link); return task; }
static apr_status_t impl_pollset_add(apr_pollset_t *pollset, const apr_pollfd_t *descriptor) { apr_os_sock_t fd; pfd_elem_t *elem; int res; apr_status_t rv = APR_SUCCESS; pollset_lock_rings(); if (!APR_RING_EMPTY(&(pollset->p->free_ring), pfd_elem_t, link)) { elem = APR_RING_FIRST(&(pollset->p->free_ring)); APR_RING_REMOVE(elem, link); } else { elem = (pfd_elem_t *) apr_palloc(pollset->pool, sizeof(pfd_elem_t)); APR_RING_ELEM_INIT(elem, link); elem->on_query_ring = 0; } elem->pfd = *descriptor; if (descriptor->desc_type == APR_POLL_SOCKET) { fd = descriptor->desc.s->socketdes; } else { fd = descriptor->desc.f->filedes; } /* If another thread is polling, notify the kernel immediately; otherwise, * wait until the next call to apr_pollset_poll(). */ if (apr_atomic_read32(&pollset->p->waiting)) { res = port_associate(pollset->p->port_fd, PORT_SOURCE_FD, fd, get_event(descriptor->reqevents), (void *)elem); if (res < 0) { rv = apr_get_netos_error(); APR_RING_INSERT_TAIL(&(pollset->p->free_ring), elem, pfd_elem_t, link); } else { elem->on_query_ring = 1; APR_RING_INSERT_TAIL(&(pollset->p->query_ring), elem, pfd_elem_t, link); } } else { APR_RING_INSERT_TAIL(&(pollset->p->add_ring), elem, pfd_elem_t, link); } pollset_unlock_rings(); return rv; }
static apr_status_t impl_pollset_add(apr_pollset_t *pollset, const apr_pollfd_t *descriptor) { struct epoll_event ev = {0}; int ret = -1; pfd_elem_t *elem = NULL; apr_status_t rv = APR_SUCCESS; ev.events = get_epoll_event(descriptor->reqevents); if (pollset->flags & APR_POLLSET_NOCOPY) { ev.data.ptr = (void *)descriptor; } else { pollset_lock_rings(); if (!APR_RING_EMPTY(&(pollset->p->free_ring), pfd_elem_t, link)) { elem = APR_RING_FIRST(&(pollset->p->free_ring)); APR_RING_REMOVE(elem, link); } else { elem = (pfd_elem_t *) apr_palloc(pollset->pool, sizeof(pfd_elem_t)); APR_RING_ELEM_INIT(elem, link); } elem->pfd = *descriptor; ev.data.ptr = elem; } if (descriptor->desc_type == APR_POLL_SOCKET) { ret = epoll_ctl(pollset->p->epoll_fd, EPOLL_CTL_ADD, descriptor->desc.s->socketdes, &ev); } else { ret = epoll_ctl(pollset->p->epoll_fd, EPOLL_CTL_ADD, descriptor->desc.f->filedes, &ev); } if (0 != ret) { rv = apr_get_netos_error(); } if (!(pollset->flags & APR_POLLSET_NOCOPY)) { if (rv != APR_SUCCESS) { APR_RING_INSERT_TAIL(&(pollset->p->free_ring), elem, pfd_elem_t, link); } else { APR_RING_INSERT_TAIL(&(pollset->p->query_ring), elem, pfd_elem_t, link); } pollset_unlock_rings(); } return rv; }
static apr_status_t impl_pollset_remove(apr_pollset_t *pollset, const apr_pollfd_t *descriptor) { pfd_elem_t *ep; apr_status_t rv; apr_os_sock_t fd; pollset_lock_rings(); if (descriptor->desc_type == APR_POLL_SOCKET) { fd = descriptor->desc.s->socketdes; } else { fd = descriptor->desc.f->filedes; } rv = APR_NOTFOUND; /* unless at least one of the specified conditions is */ if (descriptor->reqevents & APR_POLLIN) { EV_SET(&pollset->p->kevent, fd, EVFILT_READ, EV_DELETE, 0, 0, NULL); if (kevent(pollset->p->kqueue_fd, &pollset->p->kevent, 1, NULL, 0, NULL) != -1) { rv = APR_SUCCESS; } } if (descriptor->reqevents & APR_POLLOUT) { EV_SET(&pollset->p->kevent, fd, EVFILT_WRITE, EV_DELETE, 0, 0, NULL); if (kevent(pollset->p->kqueue_fd, &pollset->p->kevent, 1, NULL, 0, NULL) != -1) { rv = APR_SUCCESS; } } for (ep = APR_RING_FIRST(&(pollset->p->query_ring)); ep != APR_RING_SENTINEL(&(pollset->p->query_ring), pfd_elem_t, link); ep = APR_RING_NEXT(ep, link)) { if (descriptor->desc.s == ep->pfd.desc.s) { APR_RING_REMOVE(ep, link); APR_RING_INSERT_TAIL(&(pollset->p->dead_ring), ep, pfd_elem_t, link); break; } } pollset_unlock_rings(); return rv; }
static apt_bool_t mrcp_client_agent_connection_remove(mrcp_connection_agent_t *agent, mrcp_connection_t *connection) { /* remove from the list */ APR_RING_REMOVE(connection,link); if(connection->sock) { apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Close TCP/MRCPv2 Connection %s",connection->id); apt_poller_task_descriptor_remove(agent->task,&connection->sock_pfd); apr_socket_close(connection->sock); connection->sock = NULL; } return TRUE; }
APR_DECLARE(apr_status_t) apr_thread_cond_broadcast(apr_thread_cond_t *cond) { struct waiter_t *wake; acquire_sem(cond->lock); while (! APR_RING_EMPTY(&cond->alist, waiter_t, link)) { wake = APR_RING_FIRST(&cond->alist); APR_RING_REMOVE(wake, link); release_sem(wake->sem); APR_RING_INSERT_TAIL(&cond->flist, wake, waiter_t, link); } release_sem(cond->lock); return APR_SUCCESS; }
MPF_DECLARE(apt_bool_t) mpf_context_termination_subtract(mpf_context_t *context, mpf_termination_t *termination) { header_item_t *header_item1; header_item_t *header_item2; matrix_item_t *item; apr_size_t j,k; apr_size_t i = termination->slot; if(i >= context->capacity) { return FALSE; } header_item1 = &context->header[i]; if(header_item1->termination != termination) { return FALSE; } apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Subtract Termination"); for(j=0,k=0; j<context->capacity && k<context->count; j++) { header_item2 = &context->header[j]; if(!header_item2->termination) { continue; } k++; item = &context->matrix[i][j]; if(item->on) { item->on = 0; header_item1->tx_count--; header_item2->rx_count--; } item = &context->matrix[j][i]; if(item->on) { item->on = 0; header_item2->tx_count--; header_item1->rx_count--; } } header_item1->termination = NULL; termination->slot = (apr_size_t)-1; context->count--; if(!context->count) { apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Remove Context"); APR_RING_REMOVE(context,link); } return TRUE; }
/** Kill timer */ MPF_DECLARE(apt_bool_t) mpf_timer_kill(mpf_timer_t *timer) { if(!timer->scheduled_time) { return FALSE; } apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Kill Timer 0x%x [%lu]",timer,timer->scheduled_time); /* remove node (timer) from the list */ APR_RING_REMOVE(timer,link); timer->scheduled_time = 0; if(APR_RING_EMPTY(&timer->manager->head, mpf_timer_t, link)) { /* reset elapsed time if no timers set */ timer->manager->elapsed_time = 0; } return TRUE; }
APR_DECLARE(apr_status_t) apr_pollset_add(apr_pollset_t *pollset, const apr_pollfd_t *descriptor) { apr_os_sock_t fd; pfd_elem_t *elem; int res; apr_status_t rv = APR_SUCCESS; pollset_lock_rings(); if (!APR_RING_EMPTY(&(pollset->free_ring), pfd_elem_t, link)) { elem = APR_RING_FIRST(&(pollset->free_ring)); APR_RING_REMOVE(elem, link); } else { elem = (pfd_elem_t *) apr_palloc(pollset->pool, sizeof(pfd_elem_t)); APR_RING_ELEM_INIT(elem, link); } elem->pfd = *descriptor; if (descriptor->desc_type == APR_POLL_SOCKET) { fd = descriptor->desc.s->socketdes; } else { fd = descriptor->desc.f->filedes; } res = port_associate(pollset->port_fd, PORT_SOURCE_FD, fd, get_event(descriptor->reqevents), (void *)elem); if (res < 0) { rv = APR_ENOMEM; APR_RING_INSERT_TAIL(&(pollset->free_ring), elem, pfd_elem_t, link); } else { pollset->nelts++; APR_RING_INSERT_TAIL(&(pollset->query_ring), elem, pfd_elem_t, link); } pollset_unlock_rings(); return rv; }
static apr_status_t remove_scheduled_tasks(apr_thread_pool_t *me, void *owner) { apr_thread_pool_task_t *t_loc; apr_thread_pool_task_t *next; t_loc = APR_RING_FIRST(me->scheduled_tasks); while (t_loc != APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task, link)) { next = APR_RING_NEXT(t_loc, link); /* if this is the owner remove it */ if (t_loc->owner == owner) { --me->scheduled_task_cnt; APR_RING_REMOVE(t_loc, link); } t_loc = next; } return APR_SUCCESS; }
/** Kill timer */ APT_DECLARE(apt_bool_t) apt_timer_kill(apt_timer_t *timer) { apt_timer_queue_t *queue = timer->queue; if(!timer->scheduled_time) { return FALSE; } #ifdef APT_TIMER_DEBUG apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Kill Timer 0x%x [%u]",timer,timer->scheduled_time); #endif /* remove node (timer) from the list */ APR_RING_REMOVE(timer,link); timer->scheduled_time = 0; if(APR_RING_EMPTY(&queue->head, apt_timer_t, link)) { /* reset elapsed time if no timers set */ queue->elapsed_time = 0; } return TRUE; }