ksocknal_data_ready(struct sock *sk, int n)
#endif
{
ksock_conn_t *conn;
ENTRY;
/* interleave correctly with closing sockets... */
LASSERT(!in_irq());
read_lock(&ksocknal_data.ksnd_global_lock);
conn = sk->sk_user_data;
if (conn == NULL) { /* raced with ksocknal_terminate_conn */
LASSERT(sk->sk_data_ready != &ksocknal_data_ready);
#ifdef HAVE_SK_DATA_READY_ONE_ARG
sk->sk_data_ready(sk);
#else
sk->sk_data_ready(sk, n);
#endif
} else
ksocknal_read_callback(conn);
read_unlock(&ksocknal_data.ksnd_global_lock);
EXIT;
}
void ksocknal_schedule_callback(struct socket*sock, int mode)
{
ksock_conn_t * conn = (ksock_conn_t *) sock->kstc_conn;
read_lock(&ksocknal_data.ksnd_global_lock);
if (mode) {
ksocknal_write_callback(conn);
} else {
ksocknal_read_callback(conn);
}
read_unlock(&ksocknal_data.ksnd_global_lock);
}
static void
ksocknal_upcall(socket_t so, void *arg, int waitf)
{
ksock_conn_t *conn = (ksock_conn_t *)arg;
ENTRY;
read_lock (&ksocknal_data.ksnd_global_lock);
if (conn == NULL)
goto out;
ksocknal_read_callback (conn);
/* XXX Liang */
ksocknal_write_callback (conn);
out:
read_unlock (&ksocknal_data.ksnd_global_lock);
EXIT;
}
/*
* socket call back in Linux
*/
static void
ksocknal_data_ready (struct sock *sk)
{
ksock_conn_t *conn;
/* interleave correctly with closing sockets... */
LASSERT(!in_irq());
read_lock(&ksocknal_data.ksnd_global_lock);
conn = sk->sk_user_data;
if (conn == NULL) { /* raced with ksocknal_terminate_conn */
LASSERT (sk->sk_data_ready != &ksocknal_data_ready);
sk->sk_data_ready (sk);
} else
ksocknal_read_callback(conn);
read_unlock(&ksocknal_data.ksnd_global_lock);
}
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;
}