socknotify.c revision a5eb7107f06a6e23e8e77e8d3a84c1ff90a73ac6
/*
* 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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
*/
/*
* Copyright (c) 2014, Joyent, Inc. All rights reserved.
*/
#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/stropts.h>
#include <sys/socketvar.h>
#include <sys/ksocket.h>
#include <io/ksocket/ksocket_impl.h>
#include <fs/sockfs/sockcommon.h>
#include <fs/sockfs/sodirect.h>
#include <fs/sockfs/sockfilter_impl.h>
/*
* There can only be a single thread waiting for data (enforced by
* so_lock_read()), whereas for write there might be multiple threads
* waiting for transmit buffers. So therefore we use cv_broadcast for
* write and cv_signal for read.
*/
#define SO_WAKEUP_READER(so) { \
if ((so)->so_rcv_wakeup) { \
(so)->so_rcv_wakeup = B_FALSE; \
cv_signal(&(so)->so_rcv_cv); \
} \
}
#define SO_WAKEUP_WRITER(so) { \
if ((so)->so_snd_wakeup) { \
(so)->so_snd_wakeup = B_FALSE; \
cv_broadcast(&(so)->so_snd_cv); \
} \
}
static int i_so_notify_last_rx(struct sonode *, int *, int *);
static int i_so_notify_last_tx(struct sonode *, int *, int *);
/*
* The notification functions must be called with so_lock held,
* and they will all *drop* so_lock before returning.
*/
/*
* Wake up anyone waiting for the connection to be established.
*/
void
so_notify_connected(struct sonode *so)
{
ASSERT(MUTEX_HELD(&so->so_lock));
if (IS_KERNEL_SOCKET(so)) {
KSOCKET_CALLBACK(so, connected, 0);
mutex_exit(&so->so_lock);
} else {
socket_sendsig(so, SOCKETSIG_WRITE);
mutex_exit(&so->so_lock);
pollwakeup(&so->so_poll_list, POLLOUT);
}
sof_sonode_notify_filters(so, SOF_EV_CONNECTED, 0);
ASSERT(MUTEX_NOT_HELD(&so->so_lock));
}
/*
* The socket is disconnecting, so no more data can be sent. Wake up
* anyone that is waiting to send data.
*/
void
so_notify_disconnecting(struct sonode *so)
{
int pollev = 0;
int sigev = 0;
ASSERT(MUTEX_HELD(&so->so_lock));
(void) i_so_notify_last_tx(so, &pollev, &sigev);
if (IS_KERNEL_SOCKET(so)) {
KSOCKET_CALLBACK(so, cantsendmore, 0);
mutex_exit(&so->so_lock);
} else {
if (sigev != 0)
socket_sendsig(so, sigev);
mutex_exit(&so->so_lock);
if (pollev != 0)
pollwakeup(&so->so_poll_list, pollev);
}
sof_sonode_notify_filters(so, SOF_EV_CANTSENDMORE, 0);
ASSERT(MUTEX_NOT_HELD(&so->so_lock));
}
/*
* The socket is disconnected, so not more data can be sent or received.
* Wake up anyone that is waiting to send or receive data.
*/
void
so_notify_disconnected(struct sonode *so, boolean_t connfailed, int error)
{
int pollev = 0;
int sigev = 0;
ASSERT(MUTEX_HELD(&so->so_lock));
(void) i_so_notify_last_tx(so, &pollev, &sigev);
(void) i_so_notify_last_rx(so, &pollev, &sigev);
if (IS_KERNEL_SOCKET(so)) {
if (connfailed) {
KSOCKET_CALLBACK(so, disconnected, error);
} else {
KSOCKET_CALLBACK(so, connectfailed, error);
}
mutex_exit(&so->so_lock);
} else {
if (sigev != 0)
socket_sendsig(so, sigev);
mutex_exit(&so->so_lock);
/*
* If we're here because the socket has become disconnected,
* we explicitly set POLLHUP. At the same time, we also clear
* POLLOUT, as POLLOUT and POLLHUP are defined to be mutually
* exclusive with respect to one another.
*/
if (!connfailed)
pollev = (pollev | POLLHUP) & ~POLLOUT;
if (pollev != 0)
pollwakeup(&so->so_poll_list, pollev);
}
sof_sonode_notify_filters(so, (connfailed) ? SOF_EV_CONNECTFAILED :
SOF_EV_DISCONNECTED, error);
ASSERT(MUTEX_NOT_HELD(&so->so_lock));
}
/*
* The socket is writeable. Wake up anyone waiting to send data.
*/
void
so_notify_writable(struct sonode *so)
{
ASSERT(MUTEX_HELD(&so->so_lock));
SO_WAKEUP_WRITER(so);
if (IS_KERNEL_SOCKET(so)) {
KSOCKET_CALLBACK(so, cansend, 0);
mutex_exit(&so->so_lock);
} else {
socket_sendsig(so, SOCKETSIG_WRITE);
mutex_exit(&so->so_lock);
pollwakeup(&so->so_poll_list, POLLOUT);
}
ASSERT(MUTEX_NOT_HELD(&so->so_lock));
/* filters can start injecting data */
if (so->so_filter_active > 0)
sof_sonode_notify_filters(so, SOF_EV_INJECT_DATA_OUT_OK, 0);
}
/*
* Data is available, so wake up anyone waiting for data.
*/
void
so_notify_data(struct sonode *so, size_t qlen)
{
ASSERT(MUTEX_HELD(&so->so_lock));
SO_WAKEUP_READER(so);
if (IS_KERNEL_SOCKET(so)) {
KSOCKET_CALLBACK(so, newdata, qlen);
mutex_exit(&so->so_lock);
} else {
socket_sendsig(so, SOCKETSIG_READ);
if (so->so_pollev & (SO_POLLEV_IN|SO_POLLEV_ALWAYS)) {
so->so_pollev &= ~SO_POLLEV_IN;
mutex_exit(&so->so_lock);
pollwakeup(&so->so_poll_list, POLLIN|POLLRDNORM);
} else {
mutex_exit(&so->so_lock);
}
}
ASSERT(MUTEX_NOT_HELD(&so->so_lock));
}
/*
* Transient error. Wake up anyone waiting to send or receive data.
*/
void
so_notify_error(struct sonode *so)
{
ASSERT(MUTEX_HELD(&so->so_lock));
SO_WAKEUP_WRITER(so);
SO_WAKEUP_READER(so);
if (IS_KERNEL_SOCKET(so)) {
KSOCKET_CALLBACK(so, error, 0);
mutex_exit(&so->so_lock);
} else {
socket_sendsig(so, SOCKETSIG_WRITE|SOCKETSIG_READ);
so->so_pollev &= ~SO_POLLEV_IN;
mutex_exit(&so->so_lock);
pollwakeup(&so->so_poll_list, POLLOUT|POLLIN|POLLRDNORM);
}
ASSERT(MUTEX_NOT_HELD(&so->so_lock));
}
/*
* Out-of-band data is incoming, notify any interested parties.
*/
void
so_notify_oobsig(struct sonode *so)
{
socket_sendsig(so, SOCKETSIG_URG);
mutex_exit(&so->so_lock);
pollwakeup(&so->so_poll_list, POLLRDBAND);
}
/*
* Received out-of-band data. If the OOB data is delivered inline, then
* in addition of regular OOB notification, anyone waiting for normal
* data is also notified.
*/
void
so_notify_oobdata(struct sonode *so, boolean_t oob_inline)
{
ASSERT(MUTEX_HELD(&so->so_lock));
if (so->so_direct != NULL)
SOD_UIOAFINI(so->so_direct);
SO_WAKEUP_READER(so);
if (IS_KERNEL_SOCKET(so)) {
KSOCKET_CALLBACK(so, oobdata, 0);
mutex_exit(&so->so_lock);
} else {
if (oob_inline) {
socket_sendsig(so, SOCKETSIG_READ);
so->so_pollev &= ~SO_POLLEV_IN;
mutex_exit(&so->so_lock);
pollwakeup(&so->so_poll_list,
POLLRDBAND|POLLIN|POLLRDNORM);
} else {
mutex_exit(&so->so_lock);
pollwakeup(&so->so_poll_list, POLLRDBAND);
}
}
ASSERT(MUTEX_NOT_HELD(&so->so_lock));
}
/*
* End-of-file has been reach, so peer will send no new data. Wake up
* anyone that is waiting for data.
*/
void
so_notify_eof(struct sonode *so)
{
int pollev = 0;
int sigev = 0;
ASSERT(MUTEX_HELD(&so->so_lock));
(void) i_so_notify_last_rx(so, &pollev, &sigev);
if (IS_KERNEL_SOCKET(so)) {
KSOCKET_CALLBACK(so, cantrecvmore, 0);
mutex_exit(&so->so_lock);
} else {
if (sigev != 0)
socket_sendsig(so, sigev);
mutex_exit(&so->so_lock);
if (pollev != 0)
pollwakeup(&so->so_poll_list, pollev);
}
sof_sonode_notify_filters(so, SOF_EV_CANTRECVMORE, 0);
ASSERT(MUTEX_NOT_HELD(&so->so_lock));
}
/*
* Wake up anyone waiting for a new connection.
*/
void
so_notify_newconn(struct sonode *so)
{
ASSERT(MUTEX_HELD(&so->so_lock));
if (IS_KERNEL_SOCKET(so)) {
KSOCKET_CALLBACK(so, newconn, 0);
mutex_exit(&so->so_lock);
} else {
socket_sendsig(so, SOCKETSIG_READ);
if (so->so_pollev & (SO_POLLEV_IN|SO_POLLEV_ALWAYS)) {
so->so_pollev &= ~SO_POLLEV_IN;
mutex_exit(&so->so_lock);
pollwakeup(&so->so_poll_list, POLLIN|POLLRDNORM);
} else {
mutex_exit(&so->so_lock);
}
}
ASSERT(MUTEX_NOT_HELD(&so->so_lock));
}
/*
* User initated shutdown/close, wake anyone that is trying to do
* an operation that is no longer possible.
*/
void
so_notify_shutdown(struct sonode *so)
{
int pollev = 0;
int sigev = 0;
ASSERT(MUTEX_HELD(&so->so_lock));
ASSERT(so->so_state & (SS_CANTSENDMORE|SS_CANTRCVMORE));
if (so->so_state & SS_CANTSENDMORE)
(void) i_so_notify_last_tx(so, &pollev, &sigev);
if (so->so_state & SS_CANTRCVMORE)
(void) i_so_notify_last_rx(so, &pollev, &sigev);
if (sigev != 0)
socket_sendsig(so, sigev);
mutex_exit(&so->so_lock);
if (pollev != 0)
pollwakeup(&so->so_poll_list, pollev);
ASSERT(MUTEX_NOT_HELD(&so->so_lock));
}
/*
* No more data will be coming in, and this will be the last notification
* made.
*/
static int
i_so_notify_last_rx(struct sonode *so, int *pollev, int *sigev)
{
if (!(so->so_state & SS_SENTLASTREADSIG)) {
SOCKET_TIMER_CANCEL(so);
SO_WAKEUP_READER(so);
so->so_state |= SS_SENTLASTREADSIG;
so->so_pollev &= ~SO_POLLEV_IN;
*pollev |= POLLIN|POLLRDNORM|POLLRDHUP;
*sigev |= SOCKETSIG_READ;
return (1);
} else {
return (0);
}
}
/*
* The socket is un-writeable. Make one last notification.
*/
static int
i_so_notify_last_tx(struct sonode *so, int *pollev, int *sigev)
{
if (!(so->so_state & SS_SENTLASTWRITESIG)) {
SO_WAKEUP_WRITER(so);
so->so_state |= SS_SENTLASTWRITESIG;
*pollev |= POLLOUT;
*sigev |= SOCKETSIG_WRITE;
return (1);
} else {
return (0);
}
}