port/gen/event_port.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include "lint.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/port_impl.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/systm.h>
#include <libc.h>

/*
 * The second argument of _portfs(PORT_CREATE, 0,,,) represents the version
 * number of the event ports framework. The version number is required to
 * identify possible changes/extensions of the port_event_t structure. If an
 * extension is required the port_create() function will be mapped to a second
 * library create function like port_create_v1(PORT_CREATE, VERSION,,,)
 * VERSION will be a number > 0.
 * As long as such an extension is not required the second argument will be
 * set to 0 and no check will be done in the kernel interface.
 */
int
port_create()
{
    rval_t  r;
    r.r_vals = _portfs(PORT_CREATE | PORT_SYS_NOPORT, 0, 0, 0, 0, 0);
    return (r.r_val1);
}

int
port_associate(int port, int source, uintptr_t object, int events, void *user)
{
    rval_t  r;
    r.r_vals = _portfs(PORT_ASSOCIATE, port, source, object, events,
        (uintptr_t)user);
    return (r.r_val1);
}


int
port_get(int port, port_event_t *pe, struct timespec *to)
{
    rval_t  r;
    if (to)
        r.r_vals = _portfs(PORT_GET, port, (uintptr_t)pe, to->tv_sec,
            to->tv_nsec, (uintptr_t)to);
    else
        r.r_vals = _portfs(PORT_GET, port, (uintptr_t)pe, 0, 0, NULL);
    return (r.r_val1);
}

int
port_getn(int port, port_event_t list[], uint_t max, uint_t *nget,
    struct timespec *timeout)
{
    rval_t  r;
    if (nget == NULL) {
        errno = EINVAL;
        return (-1);
    }
    r.r_vals = _portfs(PORT_GETN, port, (uintptr_t)list, max, *nget,
        (uintptr_t)timeout);
    if (r.r_val1 == -1) {
        /* global error, errno is already set */
        return (-1);
    }
    *nget = r.r_val1;
    if (r.r_val2 == ETIME) {
        errno = ETIME;
        return (-1);
    }
    return (r.r_val2);
}

int
port_dissociate(int port, int source, uintptr_t object)
{
    rval_t  r;
    r.r_vals = _portfs(PORT_DISSOCIATE, port, source, object, 0, 0);
    return (r.r_val1);
}

int
port_send(int port, int events, void *user)
{
    rval_t  r;
    r.r_vals = _portfs(PORT_SEND, port, events, (uintptr_t)user, NULL,
        NULL);
    return (r.r_val1);
}

/*
 * _port_dispatch() will block if there are not resources available to
 * satisfy the request.
 */

int
_port_dispatch(int port, int flags, int source, int events, uintptr_t object,
    void *user)
{
    rval_t  r;
    if (flags & PORT_SHARE_EVENT)
        r.r_vals = _portfs(PORT_DISPATCH, port, source, events, object,
            (uintptr_t)user);
    else
        r.r_vals = _portfs(PORT_DISPATCH | PORT_SYS_NOSHARE, port,
            source, events, object, (uintptr_t)user);
    return (r.r_val1);
}

int
port_sendn(int ports[], int errors[], uint_t nent, int events, void *user)
{
    rval_t  r;
    uint_t  offset;
    uint_t  lnent;
    uint_t  nevents;
    if (nent <= PORT_MAX_LIST) {
        r.r_vals = _portfs(PORT_SENDN | PORT_SYS_NOPORT,
            (uintptr_t)ports, (uintptr_t)errors, nent, events,
            (uintptr_t)user);
        return (r.r_val1);
    }

    /* use chunks of max PORT_MAX_LIST elements per syscall */
    nevents = 0;
    for (offset = 0; offset < nent; ) {
        lnent = nent - offset;
        if (nent - offset > PORT_MAX_LIST)
            lnent = PORT_MAX_LIST;
        else
            lnent = nent - offset;
        r.r_vals = _portfs(PORT_SENDN | PORT_SYS_NOPORT,
            (uintptr_t)&ports[offset], (uintptr_t)&errors[offset],
            lnent, events, (uintptr_t)user);
        if (r.r_val2 == -1) {
            /* global error, return last no of events submitted */
            if (nevents)
                return (nevents);
            return (-1);
        }
        nevents += r.r_val1;
        offset += lnent;
    }
    /* list submitted */
    return (nevents);
}

int
port_alert(int port, int flags, int events, void *user)
{
    rval_t  r;
    r.r_vals = _portfs(PORT_ALERT, port, flags, events, (uintptr_t)user,
        NULL);
    return (r.r_val1);
}