/*
 * 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);
	}
}