fdset.h File Reference

Go to the source code of this file.

Macros
#define	fdset_create()   fdset_create_real(-1)

Typedefs
typedef struct FDSet	FDSet
typedef void	fdset_callback_t(int fd, int revents, void *data)

Functions
FDSet *	fdset_create_real (long timeout)
void	fdset_destroy (FDSet *set)
void	fdset_register (FDSet *set, int fd, int events, fdset_callback_t callback, void *data)
void	fdset_listen (FDSet *set, int fd, int mask, int events)
void	fdset_unregister (FDSet *set, int fd)
void	fdset_set_timeout (FDSet *set, long timeout)

Macro Definition Documentation

fdset_create

#define fdset_create

(

)

fdset_create_real(-1)

Definition at line 80 of file fdset.h.

Typedef Documentation

FDSet

typedef struct FDSet FDSet

Definition at line 61 of file fdset.h.

fdset_callback_t

typedef void fdset_callback_t(int fd, int revents, void *data)

Definition at line 73 of file fdset.h.

Function Documentation

fdset_create_real()

FDSet* fdset_create_real

(

long

timeout

)

Definition at line 368 of file fdset.c.

References error(), fdset_destroy(), gwlist_create, gwthread_create, poller(), and action::timeout.

Referenced by port_add(), and start_client_threads().

{
    FDSet *new;

    new = gw_malloc(sizeof(*new));

    /* Start off with space for one element because we can't malloc 0 bytes
     * and we don't want to worry about these pointers being NULL. */
    new->size = 1;
    new->entries = 0;
    new->pollinfo = gw_malloc(sizeof(new->pollinfo[0]) * new->size);
    new->callbacks = gw_malloc(sizeof(new->callbacks[0]) * new->size);
    new->datafields = gw_malloc(sizeof(new->datafields[0]) * new->size);
    new->times = gw_malloc(sizeof(new->times[0]) * new->size);
    new->timeout = timeout > 0 ? timeout : -1;
    new->scanning = 0;
    new->deleted_entries = 0;

    new->actions = gwlist_create();

    new->poll_thread = gwthread_create(poller, new);
    if (new->poll_thread < 0) {
        error(0, "Could not start internal thread for fdset.");
        fdset_destroy(new);
        return NULL;
    }

    return new;
}

fdset_destroy()

void fdset_destroy

(

FDSet *

set

)

Definition at line 398 of file fdset.c.

References action_create(), action_destroy_item(), action::DESTROY, error(), gwlist_destroy(), gwlist_len(), gwthread_join(), gwthread_self(), submit_action(), and warning().

Referenced by client_shutdown(), fdset_create_real(), handle_action(), port_remove(), and start_client_threads().

{
    if (set == NULL)
        return;

    if (set->poll_thread < 0 || gwthread_self() == set->poll_thread) {
        if (set->entries > 0) {
            warning(0, "Destroying fdset with %d active entries.",
                    set->entries);
        }
        gw_free(set->pollinfo);
        gw_free(set->callbacks);
        gw_free(set->datafields);
        gw_free(set->times);
        if (gwlist_len(set->actions) > 0) {
            error(0, "Destroying fdset with %ld pending actions.",
                  gwlist_len(set->actions));
        }
        gwlist_destroy(set->actions, action_destroy_item);
        gw_free(set);
    } else {
        long thread = set->poll_thread;
        submit_action(set, action_create(DESTROY));
    gwthread_join(thread);
    }
}

fdset_listen()

void fdset_listen	(	FDSet *	set,
		int	fd,
		int	mask,
		int	events
	)

Definition at line 470 of file fdset.c.

References action(), action_create(), action::events, action::fd, find_entry(), gw_assert(), gwthread_self(), action::LISTEN, action::mask, submit_action(), and warning().

Referenced by handle_action(), unlocked_register_pollin(), and unlocked_register_pollout().

{
    int entry;

    gw_assert(set != NULL);

    if (gwthread_self() != set->poll_thread) {
        struct action *action;

        action = action_create(LISTEN);
        action->fd = fd;
    action->mask = mask;
        action->events = events;
        submit_action(set, action);
        return;
    }

    entry = find_entry(set, fd);   
    if (entry < 0) {
        warning(0, "fdset_listen called on unregistered fd %d.", fd);
        return;
    }

    /* Copy the bits from events specified by the mask, and preserve the
     * bits not specified by the mask. */
    set->pollinfo[entry].events =
    (set->pollinfo[entry].events & ~mask) | (events & mask);

    /* If poller is currently scanning the array, then change the
     * revents field so that the callback function will not be called
     * for events we should no longer listen for.  The idea is the
     * same as for the events field, except that we only turn bits off. */
    if (set->scanning) {
        set->pollinfo[entry].revents =
            set->pollinfo[entry].revents & (events | ~mask);
    }
    
    time(&set->times[entry]);
}

fdset_register()

void fdset_register	(	FDSet *	set,
		int	fd,
		int	events,
		fdset_callback_t	callback,
		void *	data
	)

Definition at line 425 of file fdset.c.

References action(), action_create(), action::callback, action::data, action::events, action::fd, gw_assert(), gwthread_self(), action::REGISTER, and submit_action_nosync().

Referenced by conn_register_real(), and handle_action().

{
    int new;

    gw_assert(set != NULL);

    if (gwthread_self() != set->poll_thread) {
        struct action *action;

        action = action_create(REGISTER);
        action->fd = fd;
        action->events = events;
        action->callback = callback;
        action->data = data;
    submit_action_nosync(set, action);
        return;
    }

    gw_assert(set->entries <= set->size);

    if (set->entries >= set->size) {
        int newsize = set->entries + 1;
        set->pollinfo = gw_realloc(set->pollinfo,
                                   sizeof(set->pollinfo[0]) * newsize);
        set->callbacks = gw_realloc(set->callbacks,
                                   sizeof(set->callbacks[0]) * newsize);
        set->datafields = gw_realloc(set->datafields,
                                   sizeof(set->datafields[0]) * newsize);
        set->times = gw_realloc(set->times, sizeof(set->times[0]) * newsize);
        set->size = newsize;
    }

    /* We don't check set->scanning.  Adding new entries is not harmful
     * because their revents fields are 0. */

    new = set->entries++;
    set->pollinfo[new].fd = fd;
    set->pollinfo[new].events = events;
    set->pollinfo[new].revents = 0;
    set->callbacks[new] = callback;
    set->datafields[new] = data;
    time(&set->times[new]);
}

fdset_set_timeout()

void fdset_set_timeout	(	FDSet *	set,
		long	timeout
	)

Set timeout in seconds for this FDSet.

Definition at line 547 of file fdset.c.

References action(), action_create(), gw_assert(), gwthread_self(), action::SET_TIMEOUT, submit_action(), and action::timeout.

Referenced by http_set_client_timeout(), and port_set_timeout().

{
    gw_assert(set != NULL);

    if (gwthread_self() != set->poll_thread) {
        struct action *action;

        action = action_create(SET_TIMEOUT);
        action->timeout = timeout;
        submit_action(set, action);
        return;
    }
    set->timeout = timeout;
}

fdset_unregister()

void fdset_unregister	(	FDSet *	set,
		int	fd
	)

Definition at line 510 of file fdset.c.

References action(), action_create(), action::fd, find_entry(), gw_assert(), gwthread_self(), remove_entry(), submit_action(), action::UNREGISTER, and warning().

Referenced by conn_destroy(), conn_unregister(), and handle_action().

{
    int entry;

    gw_assert(set != NULL);

    if (gwthread_self() != set->poll_thread) {
        struct action *action;

        action = action_create(UNREGISTER);
        action->fd = fd;
        submit_action(set, action);
        return;
    }

    /* Remove the entry from the pollinfo array */

    entry = find_entry(set, fd);
    if (entry < 0) {
        warning(0, "fdset_listen called on unregistered fd %d.", fd);
        return;
    }

    if (entry == set->entries - 1) {
        /* It's the last entry.  We can safely remove it even while
         * the array is being scanned, because the scan checks set->entries. */
        set->entries--;
    } else if (set->scanning) {
        /* We can't remove entries because the array is being
         * scanned.  Mark it as deleted.  */
        set->pollinfo[entry].fd = -1;
        set->deleted_entries++;
    } else {
        remove_entry(set, entry);
    }
}