uloop.h File Reference

#include <sys/time.h>
#include <sys/types.h>
#include <stdbool.h>
#include <stdint.h>
#include <signal.h>
#include "list.h"

Go to the source code of this file.

Data Structures
struct	uloop_fd
struct	uloop_timeout
struct	uloop_process
struct	uloop_interval
struct	uloop_signal

Macros
#define	USE_EPOLL
#define	ULOOP_READ   (1 << 0)
#define	ULOOP_WRITE   (1 << 1)
#define	ULOOP_EDGE_TRIGGER   (1 << 2)
#define	ULOOP_BLOCKING   (1 << 3)
#define	ULOOP_EVENT_MASK   (ULOOP_READ | ULOOP_WRITE)
#define	ULOOP_EVENT_BUFFERED   (1 << 4)
#define	ULOOP_ERROR_CB   (1 << 6)

Typedefs
typedef void(*	uloop_fd_handler) (struct uloop_fd *u, unsigned int events)
typedef void(*	uloop_timeout_handler) (struct uloop_timeout *t)
typedef void(*	uloop_process_handler) (struct uloop_process *c, int ret)
typedef void(*	uloop_interval_handler) (struct uloop_interval *t)
typedef void(*	uloop_signal_handler) (struct uloop_signal *s)

Functions
int	uloop_fd_add (struct uloop_fd *sock, unsigned int flags)
int	uloop_fd_delete (struct uloop_fd *sock)
int	uloop_get_next_timeout (void)
int	uloop_timeout_add (struct uloop_timeout *timeout)
int	uloop_timeout_set (struct uloop_timeout *timeout, int msecs)
int	uloop_timeout_cancel (struct uloop_timeout *timeout)
int	uloop_timeout_remaining (struct uloop_timeout *timeout) __attribute__((deprecated("use uloop_timeout_remaining64")))
int64_t	uloop_timeout_remaining64 (struct uloop_timeout *timeout)
int	uloop_process_add (struct uloop_process *p)
int	uloop_process_delete (struct uloop_process *p)
int	uloop_interval_set (struct uloop_interval *timer, unsigned int msecs)
int	uloop_interval_cancel (struct uloop_interval *timer)
int64_t	uloop_interval_remaining (struct uloop_interval *timer)
int	uloop_signal_add (struct uloop_signal *s)
int	uloop_signal_delete (struct uloop_signal *s)
bool	uloop_cancelling (void)
static void	uloop_end (void)
int	uloop_init (void)
int	uloop_run_timeout (int timeout)
static int	uloop_run (void)
void	uloop_done (void)

Variables
bool	uloop_cancelled
bool	uloop_handle_sigchld
uloop_fd_handler	uloop_fd_set_cb

Macro Definition Documentation

ULOOP_BLOCKING

#define ULOOP_BLOCKING   (1 << 3)

Definition at line 50 of file uloop.h.

ULOOP_EDGE_TRIGGER

#define ULOOP_EDGE_TRIGGER   (1 << 2)

Definition at line 49 of file uloop.h.

ULOOP_ERROR_CB

#define ULOOP_ERROR_CB   (1 << 6)

Definition at line 60 of file uloop.h.

ULOOP_EVENT_BUFFERED

#define ULOOP_EVENT_BUFFERED   (1 << 4)

Definition at line 55 of file uloop.h.

ULOOP_EVENT_MASK

#define ULOOP_EVENT_MASK   (ULOOP_READ | ULOOP_WRITE)

Definition at line 52 of file uloop.h.

ULOOP_READ

#define ULOOP_READ   (1 << 0)

Definition at line 47 of file uloop.h.

ULOOP_WRITE

#define ULOOP_WRITE   (1 << 1)

Definition at line 48 of file uloop.h.

USE_EPOLL

#define USE_EPOLL

Definition at line 30 of file uloop.h.

Typedef Documentation

uloop_fd_handler

typedef void(* uloop_fd_handler) (struct uloop_fd *u, unsigned int events)

Definition at line 41 of file uloop.h.

uloop_interval_handler

typedef void(* uloop_interval_handler) (struct uloop_interval *t)

Definition at line 44 of file uloop.h.

uloop_process_handler

typedef void(* uloop_process_handler) (struct uloop_process *c, int ret)

Definition at line 43 of file uloop.h.

uloop_signal_handler

typedef void(* uloop_signal_handler) (struct uloop_signal *s)

Definition at line 45 of file uloop.h.

uloop_timeout_handler

typedef void(* uloop_timeout_handler) (struct uloop_timeout *t)

Definition at line 42 of file uloop.h.

Function Documentation

uloop_cancelling()

bool uloop_cancelling

(

void

)

Definition at line 653 of file uloop.c.

{
        return uloop_run_depth > 0 && uloop_cancelled;
}

uloop_done()

void uloop_done

(

void

)

Definition at line 686 of file uloop.c.

{
        uloop_setup_signals(false);
 
        if (poll_fd >= 0) {
                close(poll_fd);
                poll_fd = -1;
        }
 
        if (waker_pipe >= 0) {
                uloop_fd_delete(&waker_fd);
                close(waker_pipe);
                close(waker_fd.fd);
                waker_pipe = -1;
        }
 
        uloop_clear_timeouts();
        uloop_clear_processes();
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_end()

static void uloop_end ( void  )

inlinestatic

Definition at line 140 of file uloop.h.

{
        uloop_cancelled = true;
}

Here is the caller graph for this function:

uloop_fd_add()

int uloop_fd_add	(	struct uloop_fd *	sock,
		unsigned int	flags
	)

Definition at line 235 of file uloop.c.

{
        unsigned int fl;
        int ret;
 
        if (!(flags & (ULOOP_READ | ULOOP_WRITE)))
                return uloop_fd_delete(sock);
 
        if (!sock->registered && !(flags & ULOOP_BLOCKING)) {
                fl = fcntl(sock->fd, F_GETFL, 0);
                fl |= O_NONBLOCK;
                fcntl(sock->fd, F_SETFL, fl);
        }
 
        ret = register_poll(sock, flags);
        if (ret < 0)
                goto out;
 
        if (uloop_fd_set_cb)
                uloop_fd_set_cb(sock, flags);
 
        sock->flags = flags;
        sock->registered = true;
        sock->eof = false;
        sock->error = false;
 
out:
        return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_fd_delete()

int uloop_fd_delete

(

struct uloop_fd *

sock

)

Definition at line 265 of file uloop.c.

{
        int ret;
        int i;
 
        for (i = 0; i < cur_nfds; i++) {
                if (cur_fds[cur_fd + i].fd != fd)
                        continue;
 
                cur_fds[cur_fd + i].fd = NULL;
        }
 
        if (!fd->registered)
                return 0;
 
        if (uloop_fd_set_cb)
                uloop_fd_set_cb(fd, 0);
 
        fd->registered = false;
        uloop_fd_stack_event(fd, -1);
        ret = __uloop_fd_delete(fd);
        fd->flags = 0;
 
        return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_get_next_timeout()

int uloop_get_next_timeout

(

void

)

Definition at line 595 of file uloop.c.

{
        struct uloop_timeout *timeout;
        struct timeval tv;
        int64_t diff;
 
        if (list_empty(&timeouts))
                return -1;
 
        uloop_gettime(&tv);
 
        timeout = list_first_entry(&timeouts, struct uloop_timeout, list);
        diff = tv_diff(&timeout->time, &tv);
        if (diff < 0)
                return 0;
        if (diff > INT_MAX)
                return INT_MAX;
 
        return diff;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_init()

int uloop_init

(

void

)

Definition at line 150 of file uloop.c.

{
        if (uloop_init_pollfd() < 0)
                return -1;
 
        if (waker_init() < 0) {
                uloop_done();
                return -1;
        }
 
        uloop_setup_signals(true);
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_interval_cancel()

int uloop_interval_cancel

(

struct uloop_interval *

timer

)

Definition at line 458 of file uloop.c.

{
        return timer_remove(timer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_interval_remaining()

int64_t uloop_interval_remaining

(

struct uloop_interval *

timer

)

Definition at line 463 of file uloop.c.

{
        return timer_next(timer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_interval_set()

int uloop_interval_set	(	struct uloop_interval *	timer,
		unsigned int	msecs
	)

Definition at line 453 of file uloop.c.

{
        return timer_register(timer, msecs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_process_add()

int uloop_process_add

(

struct uloop_process *

p

)

Definition at line 391 of file uloop.c.

{
        struct uloop_process *tmp;
        struct list_head *h = &processes;
 
        if (p->pending)
                return -1;
 
        list_for_each_entry(tmp, &processes, list) {
                if (tmp->pid > p->pid) {
                        h = &tmp->list;
                        break;
                }
        }
 
        list_add_tail(&p->list, h);
        p->pending = true;
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_process_delete()

int uloop_process_delete

(

struct uloop_process *

p

)

Definition at line 412 of file uloop.c.

{
        if (!p->pending)
                return -1;
 
        list_del(&p->list);
        p->pending = false;
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_run()

static int uloop_run ( void  )

inlinestatic

Definition at line 147 of file uloop.h.

{
        return uloop_run_timeout(-1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_run_timeout()

int uloop_run_timeout

(

int

timeout

)

Definition at line 658 of file uloop.c.

{
        int next_time = 0;
 
        uloop_run_depth++;
 
        uloop_status = 0;
        uloop_cancelled = false;
        do {
                uloop_process_timeouts();
 
                if (do_sigchld)
                        uloop_handle_processes();
 
                if (uloop_cancelled)
                        break;
 
                next_time = uloop_get_next_timeout();
                if (timeout >= 0 && (next_time < 0 || timeout < next_time))
                                next_time = timeout;
                uloop_run_events(next_time);
        } while (!uloop_cancelled && timeout < 0);
 
        --uloop_run_depth;
 
        return uloop_status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_signal_add()

int uloop_signal_add

(

struct uloop_signal *

s

)

Definition at line 550 of file uloop.c.

{
        struct list_head *h = &signals;
        struct uloop_signal *tmp;
        struct sigaction sa;
 
        if (s->pending)
                return -1;
 
        list_for_each_entry(tmp, &signals, list) {
                if (tmp->signo > s->signo) {
                        h = &tmp->list;
                        break;
                }
        }
 
        list_add_tail(&s->list, h);
        s->pending = true;
 
        sigaction(s->signo, NULL, &s->orig);
 
        if (s->orig.sa_handler != uloop_signal_wake) {
                sa.sa_handler = uloop_signal_wake;
                sa.sa_flags = 0;
                sigemptyset(&sa.sa_mask);
                sigaction(s->signo, &sa, NULL);
        }
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_signal_delete()

int uloop_signal_delete

(

struct uloop_signal *

s

)

Definition at line 581 of file uloop.c.

{
        if (!s->pending)
                return -1;
 
        list_del(&s->list);
        s->pending = false;
 
        if (s->orig.sa_handler != uloop_signal_wake)
                sigaction(s->signo, &s->orig, NULL);
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_timeout_add()

int uloop_timeout_add

(

struct uloop_timeout *

timeout

)

Definition at line 298 of file uloop.c.

{
        struct uloop_timeout *tmp;
        struct list_head *h = &timeouts;
 
        if (timeout->pending)
                return -1;
 
        list_for_each_entry(tmp, &timeouts, list) {
                if (tv_diff(&tmp->time, &timeout->time) > 0) {
                        h = &tmp->list;
                        break;
                }
        }
 
        list_add_tail(&timeout->list, h);
        timeout->pending = true;
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_timeout_cancel()

int uloop_timeout_cancel

(

struct uloop_timeout *

timeout

)

Definition at line 348 of file uloop.c.

{
        if (!timeout->pending)
                return -1;
 
        list_del(&timeout->list);
        timeout->pending = false;
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_timeout_remaining()

int uloop_timeout_remaining

(

struct uloop_timeout *

timeout

)

Definition at line 359 of file uloop.c.

{
        int64_t td;
        struct timeval now;
 
        if (!timeout->pending)
                return -1;
 
        uloop_gettime(&now);
 
        td = tv_diff(&timeout->time, &now);
 
        if (td > INT_MAX)
                return INT_MAX;
        else if (td < INT_MIN)
                return INT_MIN;
        else
                return (int)td;
}

Here is the call graph for this function:

uloop_timeout_remaining64()

int64_t uloop_timeout_remaining64

(

struct uloop_timeout *

timeout

)

Definition at line 379 of file uloop.c.

{
        struct timeval now;
 
        if (!timeout->pending)
                return -1;
 
        uloop_gettime(&now);
 
        return tv_diff(&timeout->time, &now);
}

Here is the call graph for this function:

Here is the caller graph for this function:

uloop_timeout_set()

int uloop_timeout_set	(	struct uloop_timeout *	timeout,
		int	msecs
	)

Definition at line 328 of file uloop.c.

{
        struct timeval *time = &timeout->time;
 
        if (timeout->pending)
                uloop_timeout_cancel(timeout);
 
        uloop_gettime(time);
 
        time->tv_sec += msecs / 1000;
        time->tv_usec += (msecs % 1000) * 1000;
 
        if (time->tv_usec > 1000000) {
                time->tv_sec++;
                time->tv_usec -= 1000000;
        }
 
        return uloop_timeout_add(timeout);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

uloop_cancelled

bool uloop_cancelled

extern

Definition at line 63 of file uloop.c.

uloop_fd_set_cb

uloop_fd_handler uloop_fd_set_cb

extern

Definition at line 72 of file uloop.c.

uloop_handle_sigchld

bool uloop_handle_sigchld

extern

Definition at line 64 of file uloop.c.