static int bsd_getsockopt( cyg_file *fp, int level, int optname,
void *optval, socklen_t *optlen)
{
struct mbuf *m = NULL;
socklen_t valsize = 0;
int error;
if( optval != NULL && optlen != NULL )
valsize = *optlen;
error = sogetopt((struct socket *)fp->f_data, level, optname, &m);
if( error == ENOERR && valsize != 0 && m != NULL)
{
if (valsize > m->m_len)
valsize = m->m_len;
error = copyout(mtod(m, caddr_t), optval, valsize);
if( error == ENOERR )
*optlen = valsize;
}
if (m != NULL)
(void) m_free(m);
return (error);
}
static int set_tcpinfo(struct iwch_ep *ep)
{
struct tcp_info ti;
struct sockopt sopt;
int err;
sopt.sopt_dir = SOPT_GET;
sopt.sopt_level = IPPROTO_TCP;
sopt.sopt_name = TCP_INFO;
sopt.sopt_val = (caddr_t)&ti;
sopt.sopt_valsize = sizeof ti;
sopt.sopt_td = NULL;
err = sogetopt(ep->com.so, &sopt);
if (err) {
printf("%s can't get tcpinfo\n", __FUNCTION__);
return -err;
}
if (!(ti.tcpi_options & TCPI_OPT_TOE)) {
printf("%s connection NOT OFFLOADED!\n", __FUNCTION__);
return -EINVAL;
}
ep->snd_seq = ti.tcpi_snd_nxt;
ep->rcv_seq = ti.tcpi_rcv_nxt;
ep->emss = ti.tcpi_snd_mss - sizeof(struct tcpiphdr);
ep->hwtid = TOEPCB(ep->com.so)->tp_tid; /* XXX */
if (ti.tcpi_options & TCPI_OPT_TIMESTAMPS)
ep->emss -= 12;
if (ep->emss < 128)
ep->emss = 128;
return 0;
}
int
t_getsockopt(long s,
int level,
int name,
void * arg,
int arglen)
{
struct socket * so;
int err;
so = LONG2SO(s);
SOC_CHECK(so);
USE_ARG(level);
USE_ARG(arglen);
LOCK_NET_RESOURCE (NET_RESID);
INET_TRACE (INETM_SOCKET,
("INET: getsockopt: name %x val %x valsize %d\n",
name, val));
/* is it a level IP_OPTIONS call? */
if (level != IP_OPTIONS)
{
if ((err = sogetopt (so, name, arg)) != 0)
{
so->so_error = err;
UNLOCK_NET_RESOURCE (NET_RESID);
return SOCKET_ERROR;
}
}
else
{
/* level 1 options are for the IP packet level.
* the info is carried in the socket CB, then put
* into the PACKET.
*/
if (name == IP_TTL_OPT)
{
if (!so->so_optsPack) *(int *)arg = IP_TTL;
else *(int *)arg = (int)so->so_optsPack->ip_ttl;
}
else if (name == IP_TOS)
{
if (!so->so_optsPack) *(int *)arg = IP_TOS_DEFVAL;
else *(int *)arg = (int)so->so_optsPack->ip_tos;
}
else
{
UNLOCK_NET_RESOURCE (NET_RESID);
return SOCKET_ERROR;
}
}
so->so_error = 0;
UNLOCK_NET_RESOURCE (NET_RESID);
return 0;
}
int
sys_getsockopt(struct lwp *l, const struct sys_getsockopt_args *uap,
register_t *retval)
{
/* {
syscallarg(int) s;
syscallarg(int) level;
syscallarg(int) name;
syscallarg(void *) val;
syscallarg(unsigned int *) avalsize;
} */
struct sockopt sopt;
struct socket *so;
file_t *fp;
unsigned int valsize, len;
int error;
if (SCARG(uap, val) != NULL) {
error = copyin(SCARG(uap, avalsize), &valsize, sizeof(valsize));
if (error)
return error;
} else
valsize = 0;
if ((error = fd_getsock1(SCARG(uap, s), &so, &fp)) != 0)
return (error);
sockopt_init(&sopt, SCARG(uap, level), SCARG(uap, name), 0);
if (fp->f_flag & FNOSIGPIPE)
so->so_options |= SO_NOSIGPIPE;
else
so->so_options &= ~SO_NOSIGPIPE;
error = sogetopt(so, &sopt);
if (error)
goto out;
if (valsize > 0) {
len = min(valsize, sopt.sopt_size);
error = copyout(sopt.sopt_data, SCARG(uap, val), len);
if (error)
goto out;
error = copyout(&len, SCARG(uap, avalsize), sizeof(len));
if (error)
goto out;
}
out:
sockopt_destroy(&sopt);
fd_putfile(SCARG(uap, s));
return error;
}
int
getsockopt (int s, int level, int name, void *aval, int *avalsize)
{
struct socket *so;
struct mbuf *m = NULL, *m0;
char *val = aval;
int i, op, valsize;
int error;
rtems_bsdnet_semaphore_obtain ();
if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
rtems_bsdnet_semaphore_release ();
return -1;
}
if (val)
valsize = *avalsize;
else
valsize = 0;
if (((error = sogetopt(so, level, name, &m)) == 0) && val && valsize && m) {
op = 0;
while (m && op < valsize) {
i = valsize - op;
if (i > m->m_len)
i = m->m_len;
memcpy (val, mtod(m, caddr_t), i);
op += i;
val += i;
m0 = m;
MFREE (m0, m);
}
*avalsize = op;
}
if (m != NULL)
(void) m_free(m);
if (error) {
errno = error;
rtems_bsdnet_semaphore_release ();
return -1;
}
rtems_bsdnet_semaphore_release ();
return 0;
}
/* ARGSUSED */
int
sys_getsockopt(struct proc *p, void *v, register_t *retval)
{
struct sys_getsockopt_args /* {
syscallarg(int) s;
syscallarg(int) level;
syscallarg(int) name;
syscallarg(void *) val;
syscallarg(socklen_t *) avalsize;
} */ *uap = v;
struct file *fp;
struct mbuf *m = NULL;
socklen_t valsize;
int error;
if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0)
return (error);
if (SCARG(uap, val)) {
error = copyin(SCARG(uap, avalsize),
&valsize, sizeof (valsize));
if (error)
goto out;
} else
valsize = 0;
if ((error = sogetopt(fp->f_data, SCARG(uap, level),
SCARG(uap, name), &m)) == 0 && SCARG(uap, val) && valsize &&
m != NULL) {
if (valsize > m->m_len)
valsize = m->m_len;
error = copyout(mtod(m, caddr_t), SCARG(uap, val), valsize);
if (error == 0)
error = copyout(&valsize,
SCARG(uap, avalsize), sizeof (valsize));
}
out:
FRELE(fp, p);
if (m != NULL)
(void)m_free(m);
return (error);
}
static int
bsd_getsockopt(cyg_file *fp, int level, int optname,
void *optval, socklen_t *optlen)
{
socklen_t valsize = 0;
int error;
struct sockopt opt;
if( optval != NULL && optlen != NULL)
valsize = *optlen;
opt.sopt_dir = SOPT_GET;
opt.sopt_level = level;
opt.sopt_name = optname;
opt.sopt_val = optval;
opt.sopt_valsize = valsize;
opt.sopt_p = 0;
error = sogetopt((struct socket *)fp->f_data, &opt);
if (error == 0) {
*optlen = opt.sopt_valsize;
}
return (error);
}
/*
* XXX Liang: timeout for write is not supported yet.
*/
int
libcfs_sock_write (struct socket *sock, void *buffer, int nob, int timeout)
{
int rc;
CFS_DECL_NET_DATA;
while (nob > 0) {
struct iovec iov = {
.iov_base = buffer,
.iov_len = nob
};
struct uio suio = {
.uio_iov = &iov,
.uio_iovcnt = 1,
.uio_offset = 0,
.uio_resid = nob,
.uio_segflg = UIO_SYSSPACE,
.uio_rw = UIO_WRITE,
.uio_procp = NULL
};
CFS_NET_IN;
rc = sosend(sock, NULL, &suio, (struct mbuf *)0, (struct mbuf *)0, 0);
CFS_NET_EX;
if (rc != 0) {
if ( suio.uio_resid != nob && ( rc == ERESTART || rc == EINTR ||\
rc == EWOULDBLOCK))
rc = 0;
if ( rc != 0 )
return -rc;
rc = nob - suio.uio_resid;
buffer = ((char *)buffer) + rc;
nob = suio.uio_resid;
continue;
}
break;
}
return (0);
}
/*
* XXX Liang: timeout for read is not supported yet.
*/
int
libcfs_sock_read (struct socket *sock, void *buffer, int nob, int timeout)
{
int rc;
CFS_DECL_NET_DATA;
while (nob > 0) {
struct iovec iov = {
.iov_base = buffer,
.iov_len = nob
};
struct uio ruio = {
.uio_iov = &iov,
.uio_iovcnt = 1,
.uio_offset = 0,
.uio_resid = nob,
.uio_segflg = UIO_SYSSPACE,
.uio_rw = UIO_READ,
.uio_procp = NULL
};
CFS_NET_IN;
rc = soreceive(sock, (struct sockaddr **)0, &ruio, (struct mbuf **)0, (struct mbuf **)0, (int *)0);
CFS_NET_EX;
if (rc != 0) {
if ( ruio.uio_resid != nob && ( rc == ERESTART || rc == EINTR ||\
rc == EWOULDBLOCK))
rc = 0;
if (rc != 0)
return -rc;
rc = nob - ruio.uio_resid;
buffer = ((char *)buffer) + rc;
nob = ruio.uio_resid;
continue;
}
break;
}
return (0);
}
int
libcfs_sock_setbuf (struct socket *sock, int txbufsize, int rxbufsize)
{
struct sockopt sopt;
int rc = 0;
int option;
CFS_DECL_NET_DATA;
bzero(&sopt, sizeof sopt);
sopt.sopt_dir = SOPT_SET;
sopt.sopt_level = SOL_SOCKET;
sopt.sopt_val = &option;
sopt.sopt_valsize = sizeof(option);
if (txbufsize != 0) {
option = txbufsize;
if (option > KSOCK_MAX_BUF)
option = KSOCK_MAX_BUF;
sopt.sopt_name = SO_SNDBUF;
CFS_NET_IN;
rc = sosetopt(sock, &sopt);
CFS_NET_EX;
if (rc != 0) {
CERROR ("Can't set send buffer %d: %d\n",
option, rc);
return -rc;
}
}
if (rxbufsize != 0) {
option = rxbufsize;
sopt.sopt_name = SO_RCVBUF;
CFS_NET_IN;
rc = sosetopt(sock, &sopt);
CFS_NET_EX;
if (rc != 0) {
CERROR ("Can't set receive buffer %d: %d\n",
option, rc);
return -rc;
}
}
return 0;
}
int
libcfs_sock_getaddr (struct socket *sock, int remote, __u32 *ip, int *port)
{
struct sockaddr_in *sin;
struct sockaddr *sa = NULL;
int rc;
CFS_DECL_NET_DATA;
if (remote != 0) {
CFS_NET_IN;
rc = sock->so_proto->pr_usrreqs->pru_peeraddr(sock, &sa);
CFS_NET_EX;
if (rc != 0) {
if (sa) FREE(sa, M_SONAME);
CERROR ("Error %d getting sock peer IP\n", rc);
return -rc;
}
} else {
CFS_NET_IN;
rc = sock->so_proto->pr_usrreqs->pru_sockaddr(sock, &sa);
CFS_NET_EX;
if (rc != 0) {
if (sa) FREE(sa, M_SONAME);
CERROR ("Error %d getting sock local IP\n", rc);
return -rc;
}
}
if (sa != NULL) {
sin = (struct sockaddr_in *)sa;
if (ip != NULL)
*ip = ntohl (sin->sin_addr.s_addr);
if (port != NULL)
*port = ntohs (sin->sin_port);
if (sa)
FREE(sa, M_SONAME);
}
return 0;
}
int
libcfs_sock_getbuf (struct socket *sock, int *txbufsize, int *rxbufsize)
{
struct sockopt sopt;
int rc;
CFS_DECL_NET_DATA;
bzero(&sopt, sizeof sopt);
sopt.sopt_dir = SOPT_GET;
sopt.sopt_level = SOL_SOCKET;
if (txbufsize != NULL) {
sopt.sopt_val = txbufsize;
sopt.sopt_valsize = sizeof(*txbufsize);
sopt.sopt_name = SO_SNDBUF;
CFS_NET_IN;
rc = sogetopt(sock, &sopt);
CFS_NET_EX;
if (rc != 0) {
CERROR ("Can't get send buffer size: %d\n", rc);
return -rc;
}
}
if (rxbufsize != NULL) {
sopt.sopt_val = rxbufsize;
sopt.sopt_valsize = sizeof(*rxbufsize);
sopt.sopt_name = SO_RCVBUF;
CFS_NET_IN;
rc = sogetopt(sock, &sopt);
CFS_NET_EX;
if (rc != 0) {
CERROR ("Can't get receive buffer size: %d\n", rc);
return -rc;
}
}
return 0;
}
int
libcfs_sock_connect (struct socket **sockp, int *fatal,
__u32 local_ip, int local_port,
__u32 peer_ip, int peer_port)
{
struct sockaddr_in srvaddr;
struct socket *so;
int s;
int rc;
CFS_DECL_FUNNEL_DATA;
rc = libcfs_sock_create(sockp, fatal, local_ip, local_port);
if (rc != 0)
return rc;
so = *sockp;
bzero(&srvaddr, sizeof(srvaddr));
srvaddr.sin_len = sizeof(struct sockaddr_in);
srvaddr.sin_family = AF_INET;
srvaddr.sin_port = htons (peer_port);
srvaddr.sin_addr.s_addr = htonl (peer_ip);
CFS_NET_IN;
rc = soconnect(so, (struct sockaddr *)&srvaddr);
if (rc != 0) {
CFS_NET_EX;
if (rc != EADDRNOTAVAIL && rc != EADDRINUSE)
CDEBUG(D_NETERROR,
"Error %d connecting %u.%u.%u.%u/%d -> %u.%u.%u.%u/%d\n", rc,
HIPQUAD(local_ip), local_port, HIPQUAD(peer_ip), peer_port);
goto out;
}
s = splnet();
while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
CDEBUG(D_NET, "ksocknal sleep for waiting auto_connect.\n");
(void) tsleep((caddr_t)&so->so_timeo, PSOCK, "ksocknal_conn", hz);
}
if ((rc = so->so_error) != 0) {
so->so_error = 0;
splx(s);
CFS_NET_EX;
CDEBUG(D_NETERROR,
"Error %d connecting %u.%u.%u.%u/%d -> %u.%u.%u.%u/%d\n", rc,
HIPQUAD(local_ip), local_port, HIPQUAD(peer_ip), peer_port);
goto out;
}
LASSERT(so->so_state & SS_ISCONNECTED);
splx(s);
CFS_NET_EX;
if (sockp)
*sockp = so;
return (0);
out:
CFS_NET_IN;
soshutdown(so, 2);
soclose(so);
CFS_NET_EX;
return (-rc);
}
void
libcfs_sock_release (struct socket *sock)
{
CFS_DECL_FUNNEL_DATA;
CFS_NET_IN;
soshutdown(sock, 0);
CFS_NET_EX;
}
/*
* Receive a control message
*/
static int
ng_ksocket_rcvmsg(node_p node, item_p item, hook_p lasthook)
{
struct thread *td = curthread; /* XXX broken */
const priv_p priv = NG_NODE_PRIVATE(node);
struct socket *const so = priv->so;
struct ng_mesg *resp = NULL;
int error = 0;
struct ng_mesg *msg;
ng_ID_t raddr;
NGI_GET_MSG(item, msg);
switch (msg->header.typecookie) {
case NGM_KSOCKET_COOKIE:
switch (msg->header.cmd) {
case NGM_KSOCKET_BIND:
{
struct sockaddr *const sa
= (struct sockaddr *)msg->data;
/* Sanity check */
if (msg->header.arglen < SADATA_OFFSET
|| msg->header.arglen < sa->sa_len)
ERROUT(EINVAL);
if (so == NULL)
ERROUT(ENXIO);
/* Bind */
error = sobind(so, sa, td);
break;
}
case NGM_KSOCKET_LISTEN:
{
/* Sanity check */
if (msg->header.arglen != sizeof(int32_t))
ERROUT(EINVAL);
if (so == NULL)
ERROUT(ENXIO);
/* Listen */
error = solisten(so, *((int32_t *)msg->data), td);
break;
}
case NGM_KSOCKET_ACCEPT:
{
/* Sanity check */
if (msg->header.arglen != 0)
ERROUT(EINVAL);
if (so == NULL)
ERROUT(ENXIO);
/* Make sure the socket is capable of accepting */
if (!(so->so_options & SO_ACCEPTCONN))
ERROUT(EINVAL);
if (priv->flags & KSF_ACCEPTING)
ERROUT(EALREADY);
error = ng_ksocket_check_accept(priv);
if (error != 0 && error != EWOULDBLOCK)
ERROUT(error);
/*
* If a connection is already complete, take it.
* Otherwise let the upcall function deal with
* the connection when it comes in.
*/
priv->response_token = msg->header.token;
raddr = priv->response_addr = NGI_RETADDR(item);
if (error == 0) {
ng_ksocket_finish_accept(priv);
} else
priv->flags |= KSF_ACCEPTING;
break;
}
case NGM_KSOCKET_CONNECT:
{
struct sockaddr *const sa
= (struct sockaddr *)msg->data;
/* Sanity check */
if (msg->header.arglen < SADATA_OFFSET
|| msg->header.arglen < sa->sa_len)
ERROUT(EINVAL);
if (so == NULL)
ERROUT(ENXIO);
/* Do connect */
if ((so->so_state & SS_ISCONNECTING) != 0)
ERROUT(EALREADY);
if ((error = soconnect(so, sa, td)) != 0) {
soclrstate(so, SS_ISCONNECTING);
ERROUT(error);
}
if ((so->so_state & SS_ISCONNECTING) != 0) {
/* We will notify the sender when we connect */
priv->response_token = msg->header.token;
raddr = priv->response_addr = NGI_RETADDR(item);
priv->flags |= KSF_CONNECTING;
ERROUT(EINPROGRESS);
}
break;
}
case NGM_KSOCKET_GETNAME:
case NGM_KSOCKET_GETPEERNAME:
{
int (*func)(struct socket *so, struct sockaddr **nam);
struct sockaddr *sa = NULL;
int len;
/* Sanity check */
if (msg->header.arglen != 0)
ERROUT(EINVAL);
if (so == NULL)
ERROUT(ENXIO);
/* Get function */
if (msg->header.cmd == NGM_KSOCKET_GETPEERNAME) {
if ((so->so_state
& (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0)
ERROUT(ENOTCONN);
func = so->so_proto->pr_usrreqs->pru_peeraddr;
} else
func = so->so_proto->pr_usrreqs->pru_sockaddr;
/* Get local or peer address */
if ((error = (*func)(so, &sa)) != 0)
goto bail;
len = (sa == NULL) ? 0 : sa->sa_len;
/* Send it back in a response */
NG_MKRESPONSE(resp, msg, len, M_WAITOK | M_NULLOK);
if (resp == NULL) {
error = ENOMEM;
goto bail;
}
bcopy(sa, resp->data, len);
bail:
/* Cleanup */
if (sa != NULL)
kfree(sa, M_SONAME);
break;
}
case NGM_KSOCKET_GETOPT:
{
struct ng_ksocket_sockopt *ksopt =
(struct ng_ksocket_sockopt *)msg->data;
struct sockopt sopt;
/* Sanity check */
if (msg->header.arglen != sizeof(*ksopt))
ERROUT(EINVAL);
if (so == NULL)
ERROUT(ENXIO);
/* Get response with room for option value */
NG_MKRESPONSE(resp, msg, sizeof(*ksopt)
+ NG_KSOCKET_MAX_OPTLEN, M_WAITOK | M_NULLOK);
if (resp == NULL)
ERROUT(ENOMEM);
/* Get socket option, and put value in the response */
sopt.sopt_dir = SOPT_GET;
sopt.sopt_level = ksopt->level;
sopt.sopt_name = ksopt->name;
sopt.sopt_td = NULL;
sopt.sopt_valsize = NG_KSOCKET_MAX_OPTLEN;
ksopt = (struct ng_ksocket_sockopt *)resp->data;
sopt.sopt_val = ksopt->value;
if ((error = sogetopt(so, &sopt)) != 0) {
NG_FREE_MSG(resp);
break;
}
/* Set actual value length */
resp->header.arglen = sizeof(*ksopt)
+ sopt.sopt_valsize;
break;
}
case NGM_KSOCKET_SETOPT:
{
struct ng_ksocket_sockopt *const ksopt =
(struct ng_ksocket_sockopt *)msg->data;
const int valsize = msg->header.arglen - sizeof(*ksopt);
struct sockopt sopt;
/* Sanity check */
if (valsize < 0)
ERROUT(EINVAL);
if (so == NULL)
ERROUT(ENXIO);
/* Set socket option */
sopt.sopt_dir = SOPT_SET;
sopt.sopt_level = ksopt->level;
sopt.sopt_name = ksopt->name;
sopt.sopt_val = ksopt->value;
sopt.sopt_valsize = valsize;
sopt.sopt_td = NULL;
error = sosetopt(so, &sopt);
break;
}
default:
error = EINVAL;
break;
}
break;
default:
error = EINVAL;
break;
}
done:
NG_RESPOND_MSG(error, node, item, resp);
NG_FREE_MSG(msg);
return (error);
}
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;
}