int
soo_poll(struct file *fp, int events, struct proc *p)
{
struct socket *so = (struct socket *)fp->f_data;
int revents = 0;
int s = splsoftnet();
if (events & (POLLIN | POLLRDNORM)) {
if (soreadable(so))
revents |= events & (POLLIN | POLLRDNORM);
}
if (events & (POLLOUT | POLLWRNORM)) {
if (sowriteable(so))
revents |= events & (POLLOUT | POLLWRNORM);
}
if (events & (POLLPRI | POLLRDBAND)) {
if (so->so_oobmark || (so->so_state & SS_RCVATMARK))
revents |= events & (POLLPRI | POLLRDBAND);
}
if (revents == 0) {
if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) {
selrecord(p, &so->so_rcv.sb_sel);
so->so_rcv.sb_flags |= SB_SEL;
}
if (events & (POLLOUT | POLLWRNORM)) {
selrecord(p, &so->so_snd.sb_sel);
so->so_snd.sb_flags |= SB_SEL;
}
}
splx(s);
return (revents);
}
static int
sohasdata(struct socket *so, void *arg, int waitflag)
{
if (!soreadable(so))
return (SU_OK);
return (SU_ISCONNECTED);
}
static int
svc_vc_soupcall(struct socket *so, void *arg, int waitflag)
{
SVCXPRT *xprt = (SVCXPRT *) arg;
if (soreadable(xprt->xp_socket))
xprt_active(xprt);
return (SU_OK);
}
/*ARGSUSED*/
static enum xprt_stat
svc_dg_stat(SVCXPRT *xprt)
{
if (soreadable(xprt->xp_socket))
return (XPRT_MOREREQS);
return (XPRT_IDLE);
}
int
soo_select(struct fileproc *fp, int which, void *wql, vfs_context_t ctx)
{
struct socket *so = (struct socket *)fp->f_fglob->fg_data;
int retnum = 0;
proc_t procp;
if (so == NULL || so == (struct socket *)-1)
return (0);
procp = vfs_context_proc(ctx);
#if CONFIG_MACF_SOCKET
if (mac_socket_check_select(vfs_context_ucred(ctx), so, which) != 0)
return (0);
#endif /* CONFIG_MACF_SOCKET */
socket_lock(so, 1);
switch (which) {
case FREAD:
so->so_rcv.sb_flags |= SB_SEL;
if (soreadable(so)) {
retnum = 1;
so->so_rcv.sb_flags &= ~SB_SEL;
goto done;
}
selrecord(procp, &so->so_rcv.sb_sel, wql);
break;
case FWRITE:
so->so_snd.sb_flags |= SB_SEL;
if (sowriteable(so)) {
retnum = 1;
so->so_snd.sb_flags &= ~SB_SEL;
goto done;
}
selrecord(procp, &so->so_snd.sb_sel, wql);
break;
case 0:
so->so_rcv.sb_flags |= SB_SEL;
if (so->so_oobmark || (so->so_state & SS_RCVATMARK)) {
retnum = 1;
so->so_rcv.sb_flags &= ~SB_SEL;
goto done;
}
selrecord(procp, &so->so_rcv.sb_sel, wql);
break;
}
done:
socket_unlock(so, 1);
return (retnum);
}
static void
sohasdata(struct socket *so, void *arg, int events, int waitflag)
{
if (!soreadable(so))
return;
so->so_upcall = NULL;
so->so_rcv.sb_flags &= ~SB_UPCALL;
soisconnected(so);
return;
}
static enum xprt_stat
svc_vc_stat(SVCXPRT *xprt)
{
struct cf_conn *cd;
cd = (struct cf_conn *)(xprt->xp_p1);
if (cd->strm_stat == XPRT_DIED)
return (XPRT_DIED);
if (cd->mreq != NULL && cd->resid == 0 && cd->eor)
return (XPRT_MOREREQS);
if (soreadable(xprt->xp_socket))
return (XPRT_MOREREQS);
return (XPRT_IDLE);
}
void so_wake_poll(struct socket *so, struct sockbuf *sb)
{
/* Read */
if (&so->so_rcv == sb) {
if (soreadable(so)) {
poll_wake(so->fp, (POLLIN | POLLRDNORM));
sb->sb_flags &= ~SB_SEL;
}
}
/* Write */
if (&so->so_snd == sb) {
if (sowriteable(so)) {
poll_wake(so->fp, (POLLOUT | POLLWRNORM));
sb->sb_flags &= ~SB_SEL;
}
}
}
static enum xprt_stat
svc_vc_stat(SVCXPRT *xprt)
{
struct cf_conn *cd;
struct mbuf *m;
size_t n;
cd = (struct cf_conn *)(xprt->xp_p1);
if (cd->strm_stat == XPRT_DIED)
return (XPRT_DIED);
/*
* Return XPRT_MOREREQS if we have buffered data and we are
* mid-record or if we have enough data for a record
* marker. Since this is only a hint, we read mpending and
* resid outside the lock. We do need to take the lock if we
* have to traverse the mbuf chain.
*/
if (cd->mpending) {
if (cd->resid)
return (XPRT_MOREREQS);
n = 0;
sx_xlock(&xprt->xp_lock);
m = cd->mpending;
while (m && n < sizeof(uint32_t)) {
n += m->m_len;
m = m->m_next;
}
sx_xunlock(&xprt->xp_lock);
if (n >= sizeof(uint32_t))
return (XPRT_MOREREQS);
}
if (soreadable(xprt->xp_socket))
return (XPRT_MOREREQS);
return (XPRT_IDLE);
}
static int
bsd_select(struct CYG_FILE_TAG *fp, int which, CYG_ADDRWORD info)
{
register struct socket *so = (struct socket *)fp->f_data;
register int s = splsoftnet();
switch (which) {
case FREAD:
if (soreadable(so)) {
splx(s);
return (1);
}
cyg_selrecord(info, &so->so_rcv.sb_sel);
so->so_rcv.sb_flags |= SB_SEL;
break;
case FWRITE:
if (sowriteable(so)) {
splx(s);
return (1);
}
cyg_selrecord(info, &so->so_snd.sb_sel);
so->so_snd.sb_flags |= SB_SEL;
break;
case 0:
if (so->so_oobmark || (so->so_state & SS_RCVATMARK)) {
splx(s);
return (1);
}
cyg_selrecord(info, &so->so_rcv.sb_sel);
so->so_rcv.sb_flags |= SB_SEL;
break;
}
splx(s);
return ENOERR;
}
static bool_t
svc_vc_recv(SVCXPRT *xprt, struct rpc_msg *msg,
struct sockaddr **addrp, struct mbuf **mp)
{
struct cf_conn *cd = (struct cf_conn *) xprt->xp_p1;
struct uio uio;
struct mbuf *m;
XDR xdrs;
int error, rcvflag;
/*
* Serialise access to the socket and our own record parsing
* state.
*/
sx_xlock(&xprt->xp_lock);
for (;;) {
/*
* If we have an mbuf chain in cd->mpending, try to parse a
* record from it, leaving the result in cd->mreq. If we don't
* have a complete record, leave the partial result in
* cd->mreq and try to read more from the socket.
*/
if (cd->mpending) {
/*
* If cd->resid is non-zero, we have part of the
* record already, otherwise we are expecting a record
* marker.
*/
if (!cd->resid) {
/*
* See if there is enough data buffered to
* make up a record marker. Make sure we can
* handle the case where the record marker is
* split across more than one mbuf.
*/
size_t n = 0;
uint32_t header;
m = cd->mpending;
while (n < sizeof(uint32_t) && m) {
n += m->m_len;
m = m->m_next;
}
if (n < sizeof(uint32_t))
goto readmore;
if (cd->mpending->m_len < sizeof(uint32_t))
cd->mpending = m_pullup(cd->mpending,
sizeof(uint32_t));
memcpy(&header, mtod(cd->mpending, uint32_t *),
sizeof(header));
header = ntohl(header);
cd->eor = (header & 0x80000000) != 0;
cd->resid = header & 0x7fffffff;
m_adj(cd->mpending, sizeof(uint32_t));
}
/*
* Start pulling off mbufs from cd->mpending
* until we either have a complete record or
* we run out of data. We use m_split to pull
* data - it will pull as much as possible and
* split the last mbuf if necessary.
*/
while (cd->mpending && cd->resid) {
m = cd->mpending;
if (cd->mpending->m_next
|| cd->mpending->m_len > cd->resid)
cd->mpending = m_split(cd->mpending,
cd->resid, M_WAIT);
else
cd->mpending = NULL;
if (cd->mreq)
m_last(cd->mreq)->m_next = m;
else
cd->mreq = m;
while (m) {
cd->resid -= m->m_len;
m = m->m_next;
}
}
/*
* If cd->resid is zero now, we have managed to
* receive a record fragment from the stream. Check
* for the end-of-record mark to see if we need more.
*/
if (cd->resid == 0) {
if (!cd->eor)
continue;
/*
* Success - we have a complete record in
* cd->mreq.
*/
xdrmbuf_create(&xdrs, cd->mreq, XDR_DECODE);
cd->mreq = NULL;
sx_xunlock(&xprt->xp_lock);
if (! xdr_callmsg(&xdrs, msg)) {
XDR_DESTROY(&xdrs);
return (FALSE);
}
*addrp = NULL;
*mp = xdrmbuf_getall(&xdrs);
XDR_DESTROY(&xdrs);
return (TRUE);
}
}
readmore:
/*
* The socket upcall calls xprt_active() which will eventually
* cause the server to call us here. We attempt to
* read as much as possible from the socket and put
* the result in cd->mpending. If the read fails,
* we have drained both cd->mpending and the socket so
* we can call xprt_inactive().
*/
uio.uio_resid = 1000000000;
uio.uio_td = curthread;
m = NULL;
rcvflag = MSG_DONTWAIT;
CURVNET_SET(xprt->xp_socket->so_vnet);
error = soreceive(xprt->xp_socket, NULL, &uio, &m, NULL,
&rcvflag);
CURVNET_RESTORE();
if (error == EWOULDBLOCK) {
/*
* We must re-test for readability after
* taking the lock to protect us in the case
* where a new packet arrives on the socket
* after our call to soreceive fails with
* EWOULDBLOCK. The pool lock protects us from
* racing the upcall after our soreadable()
* call returns false.
*/
mtx_lock(&xprt->xp_pool->sp_lock);
if (!soreadable(xprt->xp_socket))
xprt_inactive_locked(xprt);
mtx_unlock(&xprt->xp_pool->sp_lock);
sx_xunlock(&xprt->xp_lock);
return (FALSE);
}
if (error) {
SOCKBUF_LOCK(&xprt->xp_socket->so_rcv);
if (xprt->xp_upcallset) {
xprt->xp_upcallset = 0;
soupcall_clear(xprt->xp_socket, SO_RCV);
}
SOCKBUF_UNLOCK(&xprt->xp_socket->so_rcv);
xprt_inactive(xprt);
cd->strm_stat = XPRT_DIED;
sx_xunlock(&xprt->xp_lock);
return (FALSE);
}
if (!m) {
/*
* EOF - the other end has closed the socket.
*/
xprt_inactive(xprt);
cd->strm_stat = XPRT_DIED;
sx_xunlock(&xprt->xp_lock);
return (FALSE);
}
if (cd->mpending)
m_last(cd->mpending)->m_next = m;
else
cd->mpending = m;
}
static __inline int
soaio_ready(struct socket *so, struct sockbuf *sb)
{
return (sb == &so->so_rcv ? soreadable(so) : sowriteable(so));
}
int
ksocknal_lib_send_iov (ksock_conn_t *conn, ksock_tx_t *tx)
{
#if SOCKNAL_SINGLE_FRAG_TX
struct iovec scratch;
struct iovec *scratchiov = &scratch;
unsigned int niov = 1;
#else
struct iovec *scratchiov = conn->ksnc_scheduler->kss_scratch_iov;
unsigned int niov = tx->tx_niov;
#endif
struct socket *sock = conn->ksnc_sock;
int nob;
int rc;
int i;
struct uio suio = {
.uio_iov = scratchiov,
.uio_iovcnt = niov,
.uio_offset = 0,
.uio_resid = 0, /* This will be valued after a while */
.uio_segflg = UIO_SYSSPACE,
.uio_rw = UIO_WRITE,
.uio_procp = NULL
};
int flags = MSG_DONTWAIT;
CFS_DECL_NET_DATA;
for (nob = i = 0; i < niov; i++) {
scratchiov[i] = tx->tx_iov[i];
nob += scratchiov[i].iov_len;
}
suio.uio_resid = nob;
CFS_NET_IN;
rc = sosend(sock, NULL, &suio, (struct mbuf *)0, (struct mbuf *)0, flags);
CFS_NET_EX;
/* NB there is no return value can indicate how many
* have been sent and how many resid, we have to get
* sent bytes from suio. */
if (rc != 0) {
if (suio.uio_resid != nob &&\
(rc == ERESTART || rc == EINTR || rc == EWOULDBLOCK))
/* We have sent something */
rc = nob - suio.uio_resid;
else if ( rc == EWOULDBLOCK )
/* Actually, EAGAIN and EWOULDBLOCK have same value in OSX */
rc = -EAGAIN;
else
rc = -rc;
} else /* rc == 0 */
rc = nob - suio.uio_resid;
return rc;
}
int
ksocknal_lib_send_kiov (ksock_conn_t *conn, ksock_tx_t *tx)
{
#if SOCKNAL_SINGLE_FRAG_TX || !SOCKNAL_RISK_KMAP_DEADLOCK
struct iovec scratch;
struct iovec *scratchiov = &scratch;
unsigned int niov = 1;
#else
struct iovec *scratchiov = conn->ksnc_scheduler->kss_scratch_iov;
unsigned int niov = tx->tx_nkiov;
#endif
struct socket *sock = conn->ksnc_sock;
lnet_kiov_t *kiov = tx->tx_kiov;
int nob;
int rc;
int i;
struct uio suio = {
.uio_iov = scratchiov,
.uio_iovcnt = niov,
.uio_offset = 0,
.uio_resid = 0, /* It should be valued after a while */
.uio_segflg = UIO_SYSSPACE,
.uio_rw = UIO_WRITE,
.uio_procp = NULL
};
int flags = MSG_DONTWAIT;
CFS_DECL_NET_DATA;
for (nob = i = 0; i < niov; i++) {
scratchiov[i].iov_base = cfs_kmap(kiov[i].kiov_page) +
kiov[i].kiov_offset;
nob += scratchiov[i].iov_len = kiov[i].kiov_len;
}
suio.uio_resid = nob;
CFS_NET_IN;
rc = sosend(sock, NULL, &suio, (struct mbuf *)0, (struct mbuf *)0, flags);
CFS_NET_EX;
for (i = 0; i < niov; i++)
cfs_kunmap(kiov[i].kiov_page);
if (rc != 0) {
if (suio.uio_resid != nob &&\
(rc == ERESTART || rc == EINTR || rc == EWOULDBLOCK))
/* We have sent something */
rc = nob - suio.uio_resid;
else if ( rc == EWOULDBLOCK )
/* EAGAIN and EWOULD BLOCK have same value in OSX */
rc = -EAGAIN;
else
rc = -rc;
} else /* rc == 0 */
rc = nob - suio.uio_resid;
return rc;
}
/*
* liang: Hack of inpcb and tcpcb.
* To get tcpcb of a socket, and call tcp_output
* to send quick ack.
*/
struct ks_tseg_qent{
int foo;
};
struct ks_tcptemp{
int foo;
};
LIST_HEAD(ks_tsegqe_head, ks_tseg_qent);
struct ks_tcpcb {
struct ks_tsegqe_head t_segq;
int t_dupacks;
struct ks_tcptemp *unused;
int t_timer[4];
struct inpcb *t_inpcb;
int t_state;
u_int t_flags;
/*
* There are more fields but we dont need
* ......
*/
};
#define TF_ACKNOW 0x00001
#define TF_DELACK 0x00002
struct ks_inpcb {
LIST_ENTRY(ks_inpcb) inp_hash;
struct in_addr reserved1;
struct in_addr reserved2;
u_short inp_fport;
u_short inp_lport;
LIST_ENTRY(inpcb) inp_list;
caddr_t inp_ppcb;
/*
* There are more fields but we dont need
* ......
*/
};
#define ks_sotoinpcb(so) ((struct ks_inpcb *)(so)->so_pcb)
#define ks_intotcpcb(ip) ((struct ks_tcpcb *)(ip)->inp_ppcb)
#define ks_sototcpcb(so) (intotcpcb(sotoinpcb(so)))
void
ksocknal_lib_eager_ack (ksock_conn_t *conn)
{
struct socket *sock = conn->ksnc_sock;
struct ks_inpcb *inp = ks_sotoinpcb(sock);
struct ks_tcpcb *tp = ks_intotcpcb(inp);
int s;
CFS_DECL_NET_DATA;
extern int tcp_output(register struct ks_tcpcb *tp);
CFS_NET_IN;
s = splnet();
/*
* No TCP_QUICKACK supported in BSD, so I have to call tcp_fasttimo
* to send immediate ACK.
*/
if (tp && tp->t_flags & TF_DELACK){
tp->t_flags &= ~TF_DELACK;
tp->t_flags |= TF_ACKNOW;
(void) tcp_output(tp);
}
splx(s);
CFS_NET_EX;
return;
}
int
ksocknal_lib_recv_iov (ksock_conn_t *conn)
{
#if SOCKNAL_SINGLE_FRAG_RX
struct iovec scratch;
struct iovec *scratchiov = &scratch;
unsigned int niov = 1;
#else
struct iovec *scratchiov = conn->ksnc_scheduler->kss_scratch_iov;
unsigned int niov = conn->ksnc_rx_niov;
#endif
struct iovec *iov = conn->ksnc_rx_iov;
int nob;
int rc;
int i;
struct uio ruio = {
.uio_iov = scratchiov,
.uio_iovcnt = niov,
.uio_offset = 0,
.uio_resid = 0, /* It should be valued after a while */
.uio_segflg = UIO_SYSSPACE,
.uio_rw = UIO_READ,
.uio_procp = NULL
};
int flags = MSG_DONTWAIT;
CFS_DECL_NET_DATA;
for (nob = i = 0; i < niov; i++) {
scratchiov[i] = iov[i];
nob += scratchiov[i].iov_len;
}
LASSERT (nob <= conn->ksnc_rx_nob_wanted);
ruio.uio_resid = nob;
CFS_NET_IN;
rc = soreceive(conn->ksnc_sock, (struct sockaddr **)0, &ruio, (struct mbuf **)0, (struct mbuf **)0, &flags);
CFS_NET_EX;
if (rc){
if (ruio.uio_resid != nob && \
(rc == ERESTART || rc == EINTR || rc == EWOULDBLOCK || rc == EAGAIN))
/* data particially received */
rc = nob - ruio.uio_resid;
else if (rc == EWOULDBLOCK)
/* EAGAIN and EWOULD BLOCK have same value in OSX */
rc = -EAGAIN;
else
rc = -rc;
} else
rc = nob - ruio.uio_resid;
return (rc);
}
int
ksocknal_lib_recv_kiov (ksock_conn_t *conn)
{
#if SOCKNAL_SINGLE_FRAG_RX || !SOCKNAL_RISK_KMAP_DEADLOCK
struct iovec scratch;
struct iovec *scratchiov = &scratch;
unsigned int niov = 1;
#else
struct iovec *scratchiov = conn->ksnc_scheduler->kss_scratch_iov;
unsigned int niov = conn->ksnc_rx_nkiov;
#endif
lnet_kiov_t *kiov = conn->ksnc_rx_kiov;
int nob;
int rc;
int i;
struct uio ruio = {
.uio_iov = scratchiov,
.uio_iovcnt = niov,
.uio_offset = 0,
.uio_resid = 0,
.uio_segflg = UIO_SYSSPACE,
.uio_rw = UIO_READ,
.uio_procp = NULL
};
int flags = MSG_DONTWAIT;
CFS_DECL_NET_DATA;
for (nob = i = 0; i < niov; i++) {
scratchiov[i].iov_base = cfs_kmap(kiov[i].kiov_page) + kiov[i].kiov_offset;
nob += scratchiov[i].iov_len = kiov[i].kiov_len;
}
LASSERT (nob <= conn->ksnc_rx_nob_wanted);
ruio.uio_resid = nob;
CFS_NET_IN;
rc = soreceive(conn->ksnc_sock, (struct sockaddr **)0, &ruio, (struct mbuf **)0, NULL, &flags);
CFS_NET_EX;
for (i = 0; i < niov; i++)
cfs_kunmap(kiov[i].kiov_page);
if (rc){
if (ruio.uio_resid != nob && \
(rc == ERESTART || rc == EINTR || rc == EWOULDBLOCK))
/* data particially received */
rc = nob - ruio.uio_resid;
else if (rc == EWOULDBLOCK)
/* receive blocked, EWOULDBLOCK == EAGAIN */
rc = -EAGAIN;
else
rc = -rc;
} else
rc = nob - ruio.uio_resid;
return (rc);
}
int
ksocknal_lib_get_conn_tunables (ksock_conn_t *conn, int *txmem, int *rxmem, int *nagle)
{
struct socket *sock = conn->ksnc_sock;
int rc;
rc = ksocknal_connsock_addref(conn);
if (rc != 0) {
LASSERT (conn->ksnc_closing);
*txmem = *rxmem = *nagle = 0;
return -ESHUTDOWN;
}
rc = libcfs_sock_getbuf(sock, txmem, rxmem);
if (rc == 0) {
struct sockopt sopt;
int len;
CFS_DECL_NET_DATA;
len = sizeof(*nagle);
bzero(&sopt, sizeof sopt);
sopt.sopt_dir = SOPT_GET;
sopt.sopt_level = IPPROTO_TCP;
sopt.sopt_name = TCP_NODELAY;
sopt.sopt_val = nagle;
sopt.sopt_valsize = len;
CFS_NET_IN;
rc = -sogetopt(sock, &sopt);
CFS_NET_EX;
}
ksocknal_connsock_decref(conn);
if (rc == 0)
*nagle = !*nagle;
else
*txmem = *rxmem = *nagle = 0;
return (rc);
}
int
ksocknal_lib_setup_sock (struct socket *so)
{
struct sockopt sopt;
int rc;
int option;
int keep_idle;
int keep_intvl;
int keep_count;
int do_keepalive;
struct linger linger;
CFS_DECL_NET_DATA;
rc = libcfs_sock_setbuf(so,
*ksocknal_tunables.ksnd_tx_buffer_size,
*ksocknal_tunables.ksnd_rx_buffer_size);
if (rc != 0) {
CERROR ("Can't set buffer tx %d, rx %d buffers: %d\n",
*ksocknal_tunables.ksnd_tx_buffer_size,
*ksocknal_tunables.ksnd_rx_buffer_size, rc);
return (rc);
}
/* Ensure this socket aborts active sends immediately when we close
* it. */
bzero(&sopt, sizeof sopt);
linger.l_onoff = 0;
linger.l_linger = 0;
sopt.sopt_dir = SOPT_SET;
sopt.sopt_level = SOL_SOCKET;
sopt.sopt_name = SO_LINGER;
sopt.sopt_val = &linger;
sopt.sopt_valsize = sizeof(linger);
CFS_NET_IN;
rc = -sosetopt(so, &sopt);
if (rc != 0) {
CERROR ("Can't set SO_LINGER: %d\n", rc);
goto out;
}
if (!*ksocknal_tunables.ksnd_nagle) {
option = 1;
bzero(&sopt, sizeof sopt);
sopt.sopt_dir = SOPT_SET;
sopt.sopt_level = IPPROTO_TCP;
sopt.sopt_name = TCP_NODELAY;
sopt.sopt_val = &option;
sopt.sopt_valsize = sizeof(option);
rc = -sosetopt(so, &sopt);
if (rc != 0) {
CERROR ("Can't disable nagle: %d\n", rc);
goto out;
}
}
/* snapshot tunables */
keep_idle = *ksocknal_tunables.ksnd_keepalive_idle;
keep_count = *ksocknal_tunables.ksnd_keepalive_count;
keep_intvl = *ksocknal_tunables.ksnd_keepalive_intvl;
do_keepalive = (keep_idle > 0 && keep_count > 0 && keep_intvl > 0);
option = (do_keepalive ? 1 : 0);
bzero(&sopt, sizeof sopt);
sopt.sopt_dir = SOPT_SET;
sopt.sopt_level = SOL_SOCKET;
sopt.sopt_name = SO_KEEPALIVE;
sopt.sopt_val = &option;
sopt.sopt_valsize = sizeof(option);
rc = -sosetopt(so, &sopt);
if (rc != 0) {
CERROR ("Can't set SO_KEEPALIVE: %d\n", rc);
goto out;
}
if (!do_keepalive) {
/* no more setting, just return */
rc = 0;
goto out;
}
bzero(&sopt, sizeof sopt);
sopt.sopt_dir = SOPT_SET;
sopt.sopt_level = IPPROTO_TCP;
sopt.sopt_name = TCP_KEEPALIVE;
sopt.sopt_val = &keep_idle;
sopt.sopt_valsize = sizeof(keep_idle);
rc = -sosetopt(so, &sopt);
if (rc != 0) {
CERROR ("Can't set TCP_KEEPALIVE : %d\n", rc);
goto out;
}
out:
CFS_NET_EX;
return (rc);
}
void
ksocknal_lib_push_conn(ksock_conn_t *conn)
{
struct socket *sock;
struct sockopt sopt;
int val = 1;
int rc;
CFS_DECL_NET_DATA;
rc = ksocknal_connsock_addref(conn);
if (rc != 0) /* being shut down */
return;
sock = conn->ksnc_sock;
bzero(&sopt, sizeof sopt);
sopt.sopt_dir = SOPT_SET;
sopt.sopt_level = IPPROTO_TCP;
sopt.sopt_name = TCP_NODELAY;
sopt.sopt_val = &val;
sopt.sopt_valsize = sizeof val;
CFS_NET_IN;
sosetopt(sock, &sopt);
CFS_NET_EX;
ksocknal_connsock_decref(conn);
return;
}
extern void ksocknal_read_callback (ksock_conn_t *conn);
extern void ksocknal_write_callback (ksock_conn_t *conn);
static void
ksocknal_upcall(struct socket *so, caddr_t arg, int waitf)
{
ksock_conn_t *conn = (ksock_conn_t *)arg;
ENTRY;
read_lock (&ksocknal_data.ksnd_global_lock);
if (conn == NULL)
goto out;
if (so->so_rcv.sb_flags & SB_UPCALL) {
extern int soreadable(struct socket *so);
if (conn->ksnc_rx_nob_wanted && soreadable(so))
/* To verify whether the upcall is for receive */
ksocknal_read_callback (conn);
}
/* go foward? */
if (so->so_snd.sb_flags & SB_UPCALL){
extern int sowriteable(struct socket *so);
if (sowriteable(so))
/* socket is writable */
ksocknal_write_callback(conn);
}
out:
read_unlock (&ksocknal_data.ksnd_global_lock);
EXIT;
}
void
ksocknal_lib_save_callback(struct socket *sock, ksock_conn_t *conn)
{
/* No callback need to save in osx */
return;
}
void
ksocknal_lib_set_callback(struct socket *sock, ksock_conn_t *conn)
{
CFS_DECL_NET_DATA;
CFS_NET_IN;
sock->so_upcallarg = (void *)conn;
sock->so_upcall = ksocknal_upcall;
sock->so_snd.sb_timeo = 0;
sock->so_rcv.sb_timeo = cfs_time_seconds(2);
sock->so_rcv.sb_flags |= SB_UPCALL;
sock->so_snd.sb_flags |= SB_UPCALL;
CFS_NET_EX;
return;
}
void
ksocknal_lib_act_callback(struct socket *sock, ksock_conn_t *conn)
{
CFS_DECL_NET_DATA;
CFS_NET_IN;
ksocknal_upcall (sock, (void *)conn, 0);
CFS_NET_EX;
}
static bool_t
svc_dg_recv(SVCXPRT *xprt, struct rpc_msg *msg,
struct sockaddr **addrp, struct mbuf **mp)
{
struct uio uio;
struct sockaddr *raddr;
struct mbuf *mreq;
XDR xdrs;
int error, rcvflag;
/*
* Serialise access to the socket.
*/
sx_xlock(&xprt->xp_lock);
/*
* The socket upcall calls xprt_active() which will eventually
* cause the server to call us here. We attempt to read a
* packet from the socket and process it. If the read fails,
* we have drained all pending requests so we call
* xprt_inactive().
*/
uio.uio_resid = 1000000000;
uio.uio_td = curthread;
mreq = NULL;
rcvflag = MSG_DONTWAIT;
error = soreceive(xprt->xp_socket, &raddr, &uio, &mreq, NULL, &rcvflag);
if (error == EWOULDBLOCK) {
/*
* We must re-test for readability after taking the
* lock to protect us in the case where a new packet
* arrives on the socket after our call to soreceive
* fails with EWOULDBLOCK. The pool lock protects us
* from racing the upcall after our soreadable() call
* returns false.
*/
mtx_lock(&xprt->xp_pool->sp_lock);
if (!soreadable(xprt->xp_socket))
xprt_inactive_locked(xprt);
mtx_unlock(&xprt->xp_pool->sp_lock);
sx_xunlock(&xprt->xp_lock);
return (FALSE);
}
if (error) {
SOCKBUF_LOCK(&xprt->xp_socket->so_rcv);
soupcall_clear(xprt->xp_socket, SO_RCV);
SOCKBUF_UNLOCK(&xprt->xp_socket->so_rcv);
xprt_inactive(xprt);
sx_xunlock(&xprt->xp_lock);
return (FALSE);
}
sx_xunlock(&xprt->xp_lock);
xdrmbuf_create(&xdrs, mreq, XDR_DECODE);
if (! xdr_callmsg(&xdrs, msg)) {
XDR_DESTROY(&xdrs);
return (FALSE);
}
*addrp = raddr;
*mp = xdrmbuf_getall(&xdrs);
XDR_DESTROY(&xdrs);
return (TRUE);
}
static bool_t
svc_vc_recv(SVCXPRT *xprt, struct rpc_msg *msg,
struct sockaddr **addrp, struct mbuf **mp)
{
struct cf_conn *cd = (struct cf_conn *) xprt->xp_p1;
struct uio uio;
struct mbuf *m;
struct socket* so = xprt->xp_socket;
XDR xdrs;
int error, rcvflag;
uint32_t xid_plus_direction[2];
/*
* Serialise access to the socket and our own record parsing
* state.
*/
sx_xlock(&xprt->xp_lock);
for (;;) {
/* If we have no request ready, check pending queue. */
while (cd->mpending &&
(cd->mreq == NULL || cd->resid != 0 || !cd->eor)) {
if (!svc_vc_process_pending(xprt))
break;
}
/* Process and return complete request in cd->mreq. */
if (cd->mreq != NULL && cd->resid == 0 && cd->eor) {
/*
* Now, check for a backchannel reply.
* The XID is in the first uint32_t of the reply
* and the message direction is the second one.
*/
if ((cd->mreq->m_len >= sizeof(xid_plus_direction) ||
m_length(cd->mreq, NULL) >=
sizeof(xid_plus_direction)) &&
xprt->xp_p2 != NULL) {
m_copydata(cd->mreq, 0,
sizeof(xid_plus_direction),
(char *)xid_plus_direction);
xid_plus_direction[0] =
ntohl(xid_plus_direction[0]);
xid_plus_direction[1] =
ntohl(xid_plus_direction[1]);
/* Check message direction. */
if (xid_plus_direction[1] == REPLY) {
clnt_bck_svccall(xprt->xp_p2,
cd->mreq,
xid_plus_direction[0]);
cd->mreq = NULL;
continue;
}
}
xdrmbuf_create(&xdrs, cd->mreq, XDR_DECODE);
cd->mreq = NULL;
/* Check for next request in a pending queue. */
svc_vc_process_pending(xprt);
if (cd->mreq == NULL || cd->resid != 0) {
SOCKBUF_LOCK(&so->so_rcv);
if (!soreadable(so))
xprt_inactive_self(xprt);
SOCKBUF_UNLOCK(&so->so_rcv);
}
sx_xunlock(&xprt->xp_lock);
if (! xdr_callmsg(&xdrs, msg)) {
XDR_DESTROY(&xdrs);
return (FALSE);
}
*addrp = NULL;
*mp = xdrmbuf_getall(&xdrs);
XDR_DESTROY(&xdrs);
return (TRUE);
}
/*
* The socket upcall calls xprt_active() which will eventually
* cause the server to call us here. We attempt to
* read as much as possible from the socket and put
* the result in cd->mpending. If the read fails,
* we have drained both cd->mpending and the socket so
* we can call xprt_inactive().
*/
uio.uio_resid = 1000000000;
uio.uio_td = curthread;
m = NULL;
rcvflag = MSG_DONTWAIT;
error = soreceive(so, NULL, &uio, &m, NULL, &rcvflag);
if (error == EWOULDBLOCK) {
/*
* We must re-test for readability after
* taking the lock to protect us in the case
* where a new packet arrives on the socket
* after our call to soreceive fails with
* EWOULDBLOCK.
*/
SOCKBUF_LOCK(&so->so_rcv);
if (!soreadable(so))
xprt_inactive_self(xprt);
SOCKBUF_UNLOCK(&so->so_rcv);
sx_xunlock(&xprt->xp_lock);
return (FALSE);
}
if (error) {
SOCKBUF_LOCK(&so->so_rcv);
if (xprt->xp_upcallset) {
xprt->xp_upcallset = 0;
soupcall_clear(so, SO_RCV);
}
SOCKBUF_UNLOCK(&so->so_rcv);
xprt_inactive_self(xprt);
cd->strm_stat = XPRT_DIED;
sx_xunlock(&xprt->xp_lock);
return (FALSE);
}
if (!m) {
/*
* EOF - the other end has closed the socket.
*/
xprt_inactive_self(xprt);
cd->strm_stat = XPRT_DIED;
sx_xunlock(&xprt->xp_lock);
return (FALSE);
}
if (cd->mpending)
m_last(cd->mpending)->m_next = m;
else
cd->mpending = m;
}
}
/*
* Open called to set up a new instance of a fifo or
* to find an active instance of a fifo.
*/
static int
fifo_open(void *v)
{
struct vop_open_args /* {
struct vnode *a_vp;
int a_mode;
kauth_cred_t a_cred;
} */ *ap = v;
struct lwp *l = curlwp;
struct vnode *vp;
struct fifoinfo *fip;
struct socket *rso, *wso;
int error;
vp = ap->a_vp;
KASSERT(VOP_ISLOCKED(vp));
if ((fip = vp->v_fifoinfo) == NULL) {
fip = kmem_alloc(sizeof(*fip), KM_SLEEP);
error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0, l, NULL);
if (error != 0) {
kmem_free(fip, sizeof(*fip));
return (error);
}
fip->fi_readsock = rso;
error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0, l, rso);
if (error != 0) {
(void)soclose(rso);
kmem_free(fip, sizeof(*fip));
return (error);
}
fip->fi_writesock = wso;
solock(wso);
if ((error = unp_connect2(wso, rso, PRU_CONNECT2)) != 0) {
sounlock(wso);
(void)soclose(wso);
(void)soclose(rso);
kmem_free(fip, sizeof(*fip));
return (error);
}
fip->fi_readers = 0;
fip->fi_writers = 0;
wso->so_state |= SS_CANTRCVMORE;
rso->so_state |= SS_CANTSENDMORE;
cv_init(&fip->fi_rcv, "fiford");
cv_init(&fip->fi_wcv, "fifowr");
vp->v_fifoinfo = fip;
} else {
wso = fip->fi_writesock;
rso = fip->fi_readsock;
solock(wso);
}
if (ap->a_mode & FREAD) {
if (fip->fi_readers++ == 0) {
wso->so_state &= ~SS_CANTSENDMORE;
cv_broadcast(&fip->fi_wcv);
}
}
if (ap->a_mode & FWRITE) {
if (fip->fi_writers++ == 0) {
rso->so_state &= ~SS_CANTRCVMORE;
cv_broadcast(&fip->fi_rcv);
}
}
if (ap->a_mode & FREAD) {
if (ap->a_mode & O_NONBLOCK) {
} else {
while (!soreadable(rso) && fip->fi_writers == 0) {
VOP_UNLOCK(vp);
error = cv_wait_sig(&fip->fi_rcv,
wso->so_lock);
sounlock(wso);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
if (error)
goto bad;
solock(wso);
}
}
}
if (ap->a_mode & FWRITE) {
if (ap->a_mode & O_NONBLOCK) {
if (fip->fi_readers == 0) {
error = ENXIO;
sounlock(wso);
goto bad;
}
} else {
while (fip->fi_readers == 0) {
VOP_UNLOCK(vp);
error = cv_wait_sig(&fip->fi_wcv,
wso->so_lock);
sounlock(wso);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
if (error)
goto bad;
solock(wso);
}
}
}
sounlock(wso);
return (0);
bad:
VOP_CLOSE(vp, ap->a_mode, ap->a_cred);
return (error);
}