dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / lib / libinetutil / common / eh.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stropts.h>        /* INFTIM */

#include <libinetutil.h>
#include "libinetutil_impl.h"

static int      grow_fds(iu_eh_t *, int);

/*
 * signal_to_eh[] is pretty much useless, since the event handler is
 * really a singleton (we pass iu_eh_t *'s around to maintain an
 * abstraction, not to allow multiple event handlers to exist).  we
 * need some way to get back our event handler in post_signal(),
 * and since the signal model is too lame to provide opaque pointers,
 * we have to resort to global variables.
 */

static iu_eh_t *signal_to_eh[NSIG];

/*
 * iu_eh_create(): creates, initializes, and returns an event handler for use
 *
 *   input: void
 *  output: iu_eh_t *: the new event handler
 */

iu_eh_t *
iu_eh_create(void)
{
        iu_eh_t *eh = malloc(sizeof (iu_eh_t));
        int     sig;

        if (eh == NULL)
                return (NULL);

        eh->iueh_pollfds        = NULL;
        eh->iueh_events         = NULL;
        eh->iueh_shutdown       = NULL;
        eh->iueh_num_fds        = 0;
        eh->iueh_stop           = B_FALSE;
        eh->iueh_reason         = 0;
        eh->iueh_shutdown_arg   = NULL;

        (void) sigemptyset(&eh->iueh_sig_regset);
        for (sig = 0; sig < NSIG; sig++) {
                eh->iueh_sig_info[sig].iues_pending = B_FALSE;
                eh->iueh_sig_info[sig].iues_handler = NULL;
                eh->iueh_sig_info[sig].iues_data = NULL;
        }

        return (eh);
}

/*
 * iu_eh_destroy(): destroys an existing event handler
 *
 *   input: iu_eh_t *: the event handler to destroy
 *  output: void
 *   notes: it is assumed all events related to this eh have been unregistered
 *          prior to calling iu_eh_destroy()
 */

void
iu_eh_destroy(iu_eh_t *eh)
{
        int     sig;

        for (sig = 0; sig < NSIG; sig++)
                if (signal_to_eh[sig] == eh)
                        (void) iu_eh_unregister_signal(eh, sig, NULL);

        free(eh->iueh_pollfds);
        free(eh->iueh_events);
        free(eh);
}

/*
 * iu_stop_handling_events(): informs the event handler to stop handling events
 *
 *   input: iu_eh_t *: the event handler to stop.
 *          unsigned int: the (user-defined) reason why
 *          iu_eh_shutdown_t *: the shutdown callback. if it is NULL,
 *                              the event handler will stop right away;
 *                              otherwise, the event handler will not
 *                              stop until the callback returns B_TRUE
 *          void *: data for the shutdown callback. it may be NULL
 *  output: void
 *   notes: the event handler in question must be in iu_handle_events()
 */

void
iu_stop_handling_events(iu_eh_t *eh, unsigned int reason,
    iu_eh_shutdown_t *shutdown, void *arg)
{
        eh->iueh_stop   = B_TRUE;
        eh->iueh_reason = reason;
        eh->iueh_shutdown = shutdown;
        eh->iueh_shutdown_arg = arg;
}

/*
 * grow_fds(): grows the internal file descriptor set used by the event
 *                handler
 *
 *   input: iu_eh_t *: the event handler whose descriptor set needs to be grown
 *          int: the new total number of descriptors needed in the set
 *  output: int: zero on failure, success otherwise
 */

static int
grow_fds(iu_eh_t *eh, int total_fds)
{
        unsigned int    i;
        struct pollfd   *new_pollfds;
        iu_event_node_t *new_events;

        if (total_fds <= eh->iueh_num_fds)
                return (1);

        new_pollfds = reallocarray(eh->iueh_pollfds, total_fds,
            sizeof (struct pollfd));
        if (new_pollfds == NULL)
                return (0);

        eh->iueh_pollfds = new_pollfds;

        new_events = reallocarray(eh->iueh_events, total_fds,
            sizeof (iu_event_node_t));
        if (new_events == NULL) {

                /*
                 * yow.  one realloc failed, but the other succeeded.
                 * we will just leave the descriptor size at the
                 * original size.  if the caller tries again, then the
                 * first realloc() will do nothing since the requested
                 * number of descriptors is already allocated.
                 */

                return (0);
        }

        for (i = eh->iueh_num_fds; i < total_fds; i++)
                eh->iueh_pollfds[i].fd = -1;

        eh->iueh_events  = new_events;
        eh->iueh_num_fds = total_fds;
        return (1);
}

/*
 * when increasing the file descriptor set size, how much to increase by:
 */

#define EH_FD_SLACK     10

/*
 * iu_register_event(): adds an event to the set managed by an event handler
 *
 *   input: iu_eh_t *: the event handler to add the event to
 *          int: the descriptor on which to listen for events.  must be
 *               a descriptor which has not yet been registered.
 *          short: the events to listen for on that descriptor
 *          iu_eh_callback_t: the callback to execute when the event happens
 *          void *: the argument to pass to the callback function
 *  output: iu_event_id_t: -1 on failure, the new event id otherwise
 */

iu_event_id_t
iu_register_event(iu_eh_t *eh, int fd, short events, iu_eh_callback_t *callback,
    void *arg)
{
        if (eh->iueh_num_fds <= fd)
                if (grow_fds(eh, fd + EH_FD_SLACK) == 0)
                        return (-1);

        /*
         * the current implementation uses the file descriptor itself
         * as the iu_event_id_t, since we know the kernel's gonna be
         * pretty smart about managing file descriptors and we know
         * that they're per-process unique.  however, it does mean
         * that the same descriptor cannot be registered multiple
         * times for different callbacks depending on its events.  if
         * this behavior is desired, either use dup(2) to get a unique
         * descriptor, or demultiplex in the callback function based
         * on `events'.
         */

        if (eh->iueh_pollfds[fd].fd != -1)
                return (-1);

        eh->iueh_pollfds[fd].fd                 = fd;
        eh->iueh_pollfds[fd].events             = events;
        eh->iueh_events[fd].iuen_callback       = callback;
        eh->iueh_events[fd].iuen_arg            = arg;

        return (fd);
}

/*
 * iu_unregister_event(): removes an event from the set managed by an event
 *                        handler
 *
 *   input: iu_eh_t *: the event handler to remove the event from
 *          iu_event_id_t: the event to remove (from iu_register_event())
 *          void **: if non-NULL, will be set to point to the argument passed
 *                   into iu_register_event()
 *  output: int: zero on failure, success otherwise
 */

int
iu_unregister_event(iu_eh_t *eh, iu_event_id_t event_id, void **arg)
{
        if (event_id < 0 || event_id >= eh->iueh_num_fds ||
            eh->iueh_pollfds[event_id].fd == -1)
                return (0);

        /*
         * fringe condition: in case this event was about to be called
         * back in iu_handle_events(), zero revents to prevent it.
         * (having an unregistered event get called back could be
         * disastrous depending on if `arg' is reference counted).
         */

        eh->iueh_pollfds[event_id].revents = 0;
        eh->iueh_pollfds[event_id].fd = -1;
        if (arg != NULL)
                *arg = eh->iueh_events[event_id].iuen_arg;

        return (1);
}

/*
 * iu_handle_events(): begins handling events on an event handler
 *
 *   input: iu_eh_t *: the event handler to begin event handling on
 *          tq_t *: a timer queue of timers to process while handling events
 *                  (see timer_queue.h for details)
 *  output: int: the reason why we stopped, -1 if due to internal failure
 */

int
iu_handle_events(iu_eh_t *eh, iu_tq_t *tq)
{
        int             n_lit, timeout, sig, saved_errno;
        unsigned int    i;
        sigset_t        oset;

        eh->iueh_stop = B_FALSE;
        do {
                timeout = tq ? iu_earliest_timer(tq) : INFTIM;

                /*
                 * we only unblock registered signals around poll(); this
                 * way other parts of the code don't have to worry about
                 * restarting "non-restartable" system calls and so forth.
                 */

                (void) sigprocmask(SIG_UNBLOCK, &eh->iueh_sig_regset, &oset);
                n_lit = poll(eh->iueh_pollfds, eh->iueh_num_fds, timeout);
                saved_errno = errno;
                (void) sigprocmask(SIG_SETMASK, &oset, NULL);

                switch (n_lit) {

                case -1:
                        if (saved_errno != EINTR)
                                return (-1);

                        for (sig = 0; sig < NSIG; sig++) {
                                if (eh->iueh_sig_info[sig].iues_pending) {
                                        eh->iueh_sig_info[sig].iues_pending =
                                            B_FALSE;
                                        eh->iueh_sig_info[sig].iues_handler(eh,
                                            sig,
                                            eh->iueh_sig_info[sig].iues_data);
                                }
                        }

                        if (eh->iueh_shutdown != NULL)
                                break;

                        continue;

                case  0:
                        /*
                         * timeout occurred.  we must have a valid tq pointer
                         * since that's the only way a timeout can happen.
                         */

                        (void) iu_expire_timers(tq);
                        continue;

                default:
                        break;
                }

                /* file descriptors are lit; call 'em back */

                for (i = 0; i < eh->iueh_num_fds && n_lit > 0; i++) {

                        if (eh->iueh_pollfds[i].revents == 0)
                                continue;

                        n_lit--;

                        /*
                         * turn off any descriptors that have gone
                         * bad.  shouldn't happen, but...
                         */

                        if (eh->iueh_pollfds[i].revents & (POLLNVAL|POLLERR)) {
                                /* TODO: issue a warning here - but how? */
                                (void) iu_unregister_event(eh, i, NULL);
                                continue;
                        }

                        eh->iueh_events[i].iuen_callback(eh, i,
                            eh->iueh_pollfds[i].revents, i,
                            eh->iueh_events[i].iuen_arg);
                }

        } while (eh->iueh_stop == B_FALSE || (eh->iueh_shutdown != NULL &&
            eh->iueh_shutdown(eh, eh->iueh_shutdown_arg) == B_FALSE));

        return (eh->iueh_reason);
}

/*
 * post_signal(): posts a signal for later consumption in iu_handle_events()
 *
 *   input: int: the signal that's been received
 *  output: void
 */

static void
post_signal(int sig)
{
        if (signal_to_eh[sig] != NULL)
                signal_to_eh[sig]->iueh_sig_info[sig].iues_pending = B_TRUE;
}

/*
 * iu_eh_register_signal(): registers a signal handler with an event handler
 *
 *   input: iu_eh_t *: the event handler to register the signal handler with
 *          int: the signal to register
 *          iu_eh_sighandler_t *: the signal handler to call back
 *          void *: the argument to pass to the signal handler function
 *   output: int: zero on failure, success otherwise
 */

int
iu_eh_register_signal(iu_eh_t *eh, int sig, iu_eh_sighandler_t *handler,
    void *data)
{
        struct sigaction        act;

        if (sig < 0 || sig >= NSIG || signal_to_eh[sig] != NULL)
                return (0);

        act.sa_flags = 0;
        act.sa_handler = &post_signal;
        (void) sigemptyset(&act.sa_mask);
        (void) sigaddset(&act.sa_mask, sig); /* used for sigprocmask() */

        if (sigaction(sig, &act, NULL) == -1)
                return (0);

        (void) sigprocmask(SIG_BLOCK, &act.sa_mask, NULL);

        eh->iueh_sig_info[sig].iues_data = data;
        eh->iueh_sig_info[sig].iues_handler = handler;
        signal_to_eh[sig] = eh;

        (void) sigaddset(&eh->iueh_sig_regset, sig);
        return (0);
}

/*
 * iu_eh_unregister_signal(): unregisters a signal handler from an event handler
 *
 *   input: iu_eh_t *: the event handler to unregister the signal handler from
 *          int: the signal to unregister
 *          void **: if non-NULL, will be set to point to the argument passed
 *                   into iu_eh_register_signal()
 *  output: int: zero on failure, success otherwise
 */

int
iu_eh_unregister_signal(iu_eh_t *eh, int sig, void **datap)
{
        sigset_t        set;

        if (sig < 0 || sig >= NSIG || signal_to_eh[sig] != eh)
                return (0);

        if (signal(sig, SIG_DFL) == SIG_ERR)
                return (0);

        if (datap != NULL)
                *datap = eh->iueh_sig_info[sig].iues_data;

        (void) sigemptyset(&set);
        (void) sigaddset(&set, sig);
        (void) sigprocmask(SIG_UNBLOCK, &set, NULL);

        eh->iueh_sig_info[sig].iues_data = NULL;
        eh->iueh_sig_info[sig].iues_handler = NULL;
        eh->iueh_sig_info[sig].iues_pending = B_FALSE;
        signal_to_eh[sig] = NULL;

        (void) sigdelset(&eh->iueh_sig_regset, sig);
        return (1);
}