Commit e03c5128 authored by David S. Miller's avatar David S. Miller

Merge branch 'rds-tcp-netns'

Sowmini Varadhan says:

====================
RDS-TCP: Network namespace support

This patch series contains the set of changes to correctly set up
the infra for PF_RDS sockets that use TCP as the transport in multiple
network namespaces.

Patch 1 in the series is the minimal set of changes to allow
a single instance of RDS-TCP to run in any (i.e init_net or other) net
namespace.  The changes in this patch set ensure that the execution of
'modprobe [-r] rds_tcp' sets up the kernel TCP sockets
relative to the current netns, so that RDS applications can send/recv
packets from that netns, and the netns can later be deleted cleanly.

Patch 2 of the series further allows multiple RDS-TCP instances,
one per network namespace. The changes in this patch allows dynamic
creation/tear-down of RDS-TCP client and server sockets  across all
current and future namespaces.

v2 changes from RFC sent out earlier:
    David Ahern comments in patch 1, net_device notifier in patch 2,
    patch 3 broken off and submitted separately.
v3: Cong Wang review comments.
====================
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 1ebd08a7 467fa153
...@@ -185,7 +185,8 @@ int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) ...@@ -185,7 +185,8 @@ int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
ret = 0; ret = 0;
goto out; goto out;
} }
trans = rds_trans_get_preferred(sin->sin_addr.s_addr); trans = rds_trans_get_preferred(sock_net(sock->sk),
sin->sin_addr.s_addr);
if (!trans) { if (!trans) {
ret = -EADDRNOTAVAIL; ret = -EADDRNOTAVAIL;
rds_remove_bound(rs); rds_remove_bound(rs);
......
...@@ -117,7 +117,8 @@ static void rds_conn_reset(struct rds_connection *conn) ...@@ -117,7 +117,8 @@ static void rds_conn_reset(struct rds_connection *conn)
* For now they are not garbage collected once they're created. They * For now they are not garbage collected once they're created. They
* are torn down as the module is removed, if ever. * are torn down as the module is removed, if ever.
*/ */
static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr, static struct rds_connection *__rds_conn_create(struct net *net,
__be32 laddr, __be32 faddr,
struct rds_transport *trans, gfp_t gfp, struct rds_transport *trans, gfp_t gfp,
int is_outgoing) int is_outgoing)
{ {
...@@ -157,6 +158,7 @@ static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr, ...@@ -157,6 +158,7 @@ static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr,
conn->c_faddr = faddr; conn->c_faddr = faddr;
spin_lock_init(&conn->c_lock); spin_lock_init(&conn->c_lock);
conn->c_next_tx_seq = 1; conn->c_next_tx_seq = 1;
rds_conn_net_set(conn, net);
init_waitqueue_head(&conn->c_waitq); init_waitqueue_head(&conn->c_waitq);
INIT_LIST_HEAD(&conn->c_send_queue); INIT_LIST_HEAD(&conn->c_send_queue);
...@@ -174,7 +176,7 @@ static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr, ...@@ -174,7 +176,7 @@ static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr,
* can bind to the destination address then we'd rather the messages * can bind to the destination address then we'd rather the messages
* flow through loopback rather than either transport. * flow through loopback rather than either transport.
*/ */
loop_trans = rds_trans_get_preferred(faddr); loop_trans = rds_trans_get_preferred(net, faddr);
if (loop_trans) { if (loop_trans) {
rds_trans_put(loop_trans); rds_trans_put(loop_trans);
conn->c_loopback = 1; conn->c_loopback = 1;
...@@ -260,17 +262,19 @@ static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr, ...@@ -260,17 +262,19 @@ static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr,
return conn; return conn;
} }
struct rds_connection *rds_conn_create(__be32 laddr, __be32 faddr, struct rds_connection *rds_conn_create(struct net *net,
__be32 laddr, __be32 faddr,
struct rds_transport *trans, gfp_t gfp) struct rds_transport *trans, gfp_t gfp)
{ {
return __rds_conn_create(laddr, faddr, trans, gfp, 0); return __rds_conn_create(net, laddr, faddr, trans, gfp, 0);
} }
EXPORT_SYMBOL_GPL(rds_conn_create); EXPORT_SYMBOL_GPL(rds_conn_create);
struct rds_connection *rds_conn_create_outgoing(__be32 laddr, __be32 faddr, struct rds_connection *rds_conn_create_outgoing(struct net *net,
__be32 laddr, __be32 faddr,
struct rds_transport *trans, gfp_t gfp) struct rds_transport *trans, gfp_t gfp)
{ {
return __rds_conn_create(laddr, faddr, trans, gfp, 1); return __rds_conn_create(net, laddr, faddr, trans, gfp, 1);
} }
EXPORT_SYMBOL_GPL(rds_conn_create_outgoing); EXPORT_SYMBOL_GPL(rds_conn_create_outgoing);
......
...@@ -317,7 +317,7 @@ static void rds_ib_ic_info(struct socket *sock, unsigned int len, ...@@ -317,7 +317,7 @@ static void rds_ib_ic_info(struct socket *sock, unsigned int len,
* allowed to influence which paths have priority. We could call userspace * allowed to influence which paths have priority. We could call userspace
* asserting this policy "routing". * asserting this policy "routing".
*/ */
static int rds_ib_laddr_check(__be32 addr) static int rds_ib_laddr_check(struct net *net, __be32 addr)
{ {
int ret; int ret;
struct rdma_cm_id *cm_id; struct rdma_cm_id *cm_id;
......
...@@ -448,8 +448,9 @@ int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id, ...@@ -448,8 +448,9 @@ int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id,
(unsigned long long)be64_to_cpu(lguid), (unsigned long long)be64_to_cpu(lguid),
(unsigned long long)be64_to_cpu(fguid)); (unsigned long long)be64_to_cpu(fguid));
conn = rds_conn_create(dp->dp_daddr, dp->dp_saddr, &rds_ib_transport, /* RDS/IB is not currently netns aware, thus init_net */
GFP_KERNEL); conn = rds_conn_create(&init_net, dp->dp_daddr, dp->dp_saddr,
&rds_ib_transport, GFP_KERNEL);
if (IS_ERR(conn)) { if (IS_ERR(conn)) {
rdsdebug("rds_conn_create failed (%ld)\n", PTR_ERR(conn)); rdsdebug("rds_conn_create failed (%ld)\n", PTR_ERR(conn));
conn = NULL; conn = NULL;
......
...@@ -218,7 +218,7 @@ static void rds_iw_ic_info(struct socket *sock, unsigned int len, ...@@ -218,7 +218,7 @@ static void rds_iw_ic_info(struct socket *sock, unsigned int len,
* allowed to influence which paths have priority. We could call userspace * allowed to influence which paths have priority. We could call userspace
* asserting this policy "routing". * asserting this policy "routing".
*/ */
static int rds_iw_laddr_check(__be32 addr) static int rds_iw_laddr_check(struct net *net, __be32 addr)
{ {
int ret; int ret;
struct rdma_cm_id *cm_id; struct rdma_cm_id *cm_id;
......
...@@ -398,8 +398,9 @@ int rds_iw_cm_handle_connect(struct rdma_cm_id *cm_id, ...@@ -398,8 +398,9 @@ int rds_iw_cm_handle_connect(struct rdma_cm_id *cm_id,
&dp->dp_saddr, &dp->dp_daddr, &dp->dp_saddr, &dp->dp_daddr,
RDS_PROTOCOL_MAJOR(version), RDS_PROTOCOL_MINOR(version)); RDS_PROTOCOL_MAJOR(version), RDS_PROTOCOL_MINOR(version));
conn = rds_conn_create(dp->dp_daddr, dp->dp_saddr, &rds_iw_transport, /* RDS/IW is not currently netns aware, thus init_net */
GFP_KERNEL); conn = rds_conn_create(&init_net, dp->dp_daddr, dp->dp_saddr,
&rds_iw_transport, GFP_KERNEL);
if (IS_ERR(conn)) { if (IS_ERR(conn)) {
rdsdebug("rds_conn_create failed (%ld)\n", PTR_ERR(conn)); rdsdebug("rds_conn_create failed (%ld)\n", PTR_ERR(conn));
conn = NULL; conn = NULL;
......
...@@ -128,8 +128,21 @@ struct rds_connection { ...@@ -128,8 +128,21 @@ struct rds_connection {
/* Protocol version */ /* Protocol version */
unsigned int c_version; unsigned int c_version;
possible_net_t c_net;
}; };
static inline
struct net *rds_conn_net(struct rds_connection *conn)
{
return read_pnet(&conn->c_net);
}
static inline
void rds_conn_net_set(struct rds_connection *conn, struct net *net)
{
write_pnet(&conn->c_net, net);
}
#define RDS_FLAG_CONG_BITMAP 0x01 #define RDS_FLAG_CONG_BITMAP 0x01
#define RDS_FLAG_ACK_REQUIRED 0x02 #define RDS_FLAG_ACK_REQUIRED 0x02
#define RDS_FLAG_RETRANSMITTED 0x04 #define RDS_FLAG_RETRANSMITTED 0x04
...@@ -417,7 +430,7 @@ struct rds_transport { ...@@ -417,7 +430,7 @@ struct rds_transport {
unsigned int t_prefer_loopback:1; unsigned int t_prefer_loopback:1;
unsigned int t_type; unsigned int t_type;
int (*laddr_check)(__be32 addr); int (*laddr_check)(struct net *net, __be32 addr);
int (*conn_alloc)(struct rds_connection *conn, gfp_t gfp); int (*conn_alloc)(struct rds_connection *conn, gfp_t gfp);
void (*conn_free)(void *data); void (*conn_free)(void *data);
int (*conn_connect)(struct rds_connection *conn); int (*conn_connect)(struct rds_connection *conn);
...@@ -608,9 +621,11 @@ struct rds_message *rds_cong_update_alloc(struct rds_connection *conn); ...@@ -608,9 +621,11 @@ struct rds_message *rds_cong_update_alloc(struct rds_connection *conn);
/* conn.c */ /* conn.c */
int rds_conn_init(void); int rds_conn_init(void);
void rds_conn_exit(void); void rds_conn_exit(void);
struct rds_connection *rds_conn_create(__be32 laddr, __be32 faddr, struct rds_connection *rds_conn_create(struct net *net,
__be32 laddr, __be32 faddr,
struct rds_transport *trans, gfp_t gfp); struct rds_transport *trans, gfp_t gfp);
struct rds_connection *rds_conn_create_outgoing(__be32 laddr, __be32 faddr, struct rds_connection *rds_conn_create_outgoing(struct net *net,
__be32 laddr, __be32 faddr,
struct rds_transport *trans, gfp_t gfp); struct rds_transport *trans, gfp_t gfp);
void rds_conn_shutdown(struct rds_connection *conn); void rds_conn_shutdown(struct rds_connection *conn);
void rds_conn_destroy(struct rds_connection *conn); void rds_conn_destroy(struct rds_connection *conn);
...@@ -795,7 +810,7 @@ void rds_connect_complete(struct rds_connection *conn); ...@@ -795,7 +810,7 @@ void rds_connect_complete(struct rds_connection *conn);
/* transport.c */ /* transport.c */
int rds_trans_register(struct rds_transport *trans); int rds_trans_register(struct rds_transport *trans);
void rds_trans_unregister(struct rds_transport *trans); void rds_trans_unregister(struct rds_transport *trans);
struct rds_transport *rds_trans_get_preferred(__be32 addr); struct rds_transport *rds_trans_get_preferred(struct net *net, __be32 addr);
void rds_trans_put(struct rds_transport *trans); void rds_trans_put(struct rds_transport *trans);
unsigned int rds_trans_stats_info_copy(struct rds_info_iterator *iter, unsigned int rds_trans_stats_info_copy(struct rds_info_iterator *iter,
unsigned int avail); unsigned int avail);
......
...@@ -1023,7 +1023,8 @@ int rds_sendmsg(struct socket *sock, struct msghdr *msg, size_t payload_len) ...@@ -1023,7 +1023,8 @@ int rds_sendmsg(struct socket *sock, struct msghdr *msg, size_t payload_len)
if (rs->rs_conn && rs->rs_conn->c_faddr == daddr) if (rs->rs_conn && rs->rs_conn->c_faddr == daddr)
conn = rs->rs_conn; conn = rs->rs_conn;
else { else {
conn = rds_conn_create_outgoing(rs->rs_bound_addr, daddr, conn = rds_conn_create_outgoing(sock_net(sock->sk),
rs->rs_bound_addr, daddr,
rs->rs_transport, rs->rs_transport,
sock->sk->sk_allocation); sock->sk->sk_allocation);
if (IS_ERR(conn)) { if (IS_ERR(conn)) {
......
...@@ -35,6 +35,9 @@ ...@@ -35,6 +35,9 @@
#include <linux/in.h> #include <linux/in.h>
#include <linux/module.h> #include <linux/module.h>
#include <net/tcp.h> #include <net/tcp.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>
#include <net/tcp.h>
#include "rds.h" #include "rds.h"
#include "tcp.h" #include "tcp.h"
...@@ -189,9 +192,9 @@ static void rds_tcp_tc_info(struct socket *sock, unsigned int len, ...@@ -189,9 +192,9 @@ static void rds_tcp_tc_info(struct socket *sock, unsigned int len,
spin_unlock_irqrestore(&rds_tcp_tc_list_lock, flags); spin_unlock_irqrestore(&rds_tcp_tc_list_lock, flags);
} }
static int rds_tcp_laddr_check(__be32 addr) static int rds_tcp_laddr_check(struct net *net, __be32 addr)
{ {
if (inet_addr_type(&init_net, addr) == RTN_LOCAL) if (inet_addr_type(net, addr) == RTN_LOCAL)
return 0; return 0;
return -EADDRNOTAVAIL; return -EADDRNOTAVAIL;
} }
...@@ -250,16 +253,7 @@ static void rds_tcp_destroy_conns(void) ...@@ -250,16 +253,7 @@ static void rds_tcp_destroy_conns(void)
} }
} }
static void rds_tcp_exit(void) static void rds_tcp_exit(void);
{
rds_info_deregister_func(RDS_INFO_TCP_SOCKETS, rds_tcp_tc_info);
rds_tcp_listen_stop();
rds_tcp_destroy_conns();
rds_trans_unregister(&rds_tcp_transport);
rds_tcp_recv_exit();
kmem_cache_destroy(rds_tcp_conn_slab);
}
module_exit(rds_tcp_exit);
struct rds_transport rds_tcp_transport = { struct rds_transport rds_tcp_transport = {
.laddr_check = rds_tcp_laddr_check, .laddr_check = rds_tcp_laddr_check,
...@@ -281,6 +275,136 @@ struct rds_transport rds_tcp_transport = { ...@@ -281,6 +275,136 @@ struct rds_transport rds_tcp_transport = {
.t_prefer_loopback = 1, .t_prefer_loopback = 1,
}; };
static int rds_tcp_netid;
/* per-network namespace private data for this module */
struct rds_tcp_net {
struct socket *rds_tcp_listen_sock;
struct work_struct rds_tcp_accept_w;
};
static void rds_tcp_accept_worker(struct work_struct *work)
{
struct rds_tcp_net *rtn = container_of(work,
struct rds_tcp_net,
rds_tcp_accept_w);
while (rds_tcp_accept_one(rtn->rds_tcp_listen_sock) == 0)
cond_resched();
}
void rds_tcp_accept_work(struct sock *sk)
{
struct net *net = sock_net(sk);
struct rds_tcp_net *rtn = net_generic(net, rds_tcp_netid);
queue_work(rds_wq, &rtn->rds_tcp_accept_w);
}
static __net_init int rds_tcp_init_net(struct net *net)
{
struct rds_tcp_net *rtn = net_generic(net, rds_tcp_netid);
rtn->rds_tcp_listen_sock = rds_tcp_listen_init(net);
if (!rtn->rds_tcp_listen_sock) {
pr_warn("could not set up listen sock\n");
return -EAFNOSUPPORT;
}
INIT_WORK(&rtn->rds_tcp_accept_w, rds_tcp_accept_worker);
return 0;
}
static void __net_exit rds_tcp_exit_net(struct net *net)
{
struct rds_tcp_net *rtn = net_generic(net, rds_tcp_netid);
/* If rds_tcp_exit_net() is called as a result of netns deletion,
* the rds_tcp_kill_sock() device notifier would already have cleaned
* up the listen socket, thus there is no work to do in this function.
*
* If rds_tcp_exit_net() is called as a result of module unload,
* i.e., due to rds_tcp_exit() -> unregister_pernet_subsys(), then
* we do need to clean up the listen socket here.
*/
if (rtn->rds_tcp_listen_sock) {
rds_tcp_listen_stop(rtn->rds_tcp_listen_sock);
rtn->rds_tcp_listen_sock = NULL;
flush_work(&rtn->rds_tcp_accept_w);
}
}
static struct pernet_operations rds_tcp_net_ops = {
.init = rds_tcp_init_net,
.exit = rds_tcp_exit_net,
.id = &rds_tcp_netid,
.size = sizeof(struct rds_tcp_net),
};
static void rds_tcp_kill_sock(struct net *net)
{
struct rds_tcp_connection *tc, *_tc;
struct sock *sk;
LIST_HEAD(tmp_list);
struct rds_tcp_net *rtn = net_generic(net, rds_tcp_netid);
rds_tcp_listen_stop(rtn->rds_tcp_listen_sock);
rtn->rds_tcp_listen_sock = NULL;
flush_work(&rtn->rds_tcp_accept_w);
spin_lock_irq(&rds_tcp_conn_lock);
list_for_each_entry_safe(tc, _tc, &rds_tcp_conn_list, t_tcp_node) {
struct net *c_net = read_pnet(&tc->conn->c_net);
if (net != c_net || !tc->t_sock)
continue;
list_move_tail(&tc->t_tcp_node, &tmp_list);
}
spin_unlock_irq(&rds_tcp_conn_lock);
list_for_each_entry_safe(tc, _tc, &tmp_list, t_tcp_node) {
sk = tc->t_sock->sk;
sk->sk_prot->disconnect(sk, 0);
tcp_done(sk);
if (tc->conn->c_passive)
rds_conn_destroy(tc->conn->c_passive);
rds_conn_destroy(tc->conn);
}
}
static int rds_tcp_dev_event(struct notifier_block *this,
unsigned long event, void *ptr)
{
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
/* rds-tcp registers as a pernet subys, so the ->exit will only
* get invoked after network acitivity has quiesced. We need to
* clean up all sockets to quiesce network activity, and use
* the unregistration of the per-net loopback device as a trigger
* to start that cleanup.
*/
if (event == NETDEV_UNREGISTER_FINAL &&
dev->ifindex == LOOPBACK_IFINDEX)
rds_tcp_kill_sock(dev_net(dev));
return NOTIFY_DONE;
}
static struct notifier_block rds_tcp_dev_notifier = {
.notifier_call = rds_tcp_dev_event,
.priority = -10, /* must be called after other network notifiers */
};
static void rds_tcp_exit(void)
{
rds_info_deregister_func(RDS_INFO_TCP_SOCKETS, rds_tcp_tc_info);
unregister_pernet_subsys(&rds_tcp_net_ops);
if (unregister_netdevice_notifier(&rds_tcp_dev_notifier))
pr_warn("could not unregister rds_tcp_dev_notifier\n");
rds_tcp_destroy_conns();
rds_trans_unregister(&rds_tcp_transport);
rds_tcp_recv_exit();
kmem_cache_destroy(rds_tcp_conn_slab);
}
module_exit(rds_tcp_exit);
static int rds_tcp_init(void) static int rds_tcp_init(void)
{ {
int ret; int ret;
...@@ -293,6 +417,16 @@ static int rds_tcp_init(void) ...@@ -293,6 +417,16 @@ static int rds_tcp_init(void)
goto out; goto out;
} }
ret = register_netdevice_notifier(&rds_tcp_dev_notifier);
if (ret) {
pr_warn("could not register rds_tcp_dev_notifier\n");
goto out;
}
ret = register_pernet_subsys(&rds_tcp_net_ops);
if (ret)
goto out_slab;
ret = rds_tcp_recv_init(); ret = rds_tcp_recv_init();
if (ret) if (ret)
goto out_slab; goto out_slab;
...@@ -301,19 +435,14 @@ static int rds_tcp_init(void) ...@@ -301,19 +435,14 @@ static int rds_tcp_init(void)
if (ret) if (ret)
goto out_recv; goto out_recv;
ret = rds_tcp_listen_init();
if (ret)
goto out_register;
rds_info_register_func(RDS_INFO_TCP_SOCKETS, rds_tcp_tc_info); rds_info_register_func(RDS_INFO_TCP_SOCKETS, rds_tcp_tc_info);
goto out; goto out;
out_register:
rds_trans_unregister(&rds_tcp_transport);
out_recv: out_recv:
rds_tcp_recv_exit(); rds_tcp_recv_exit();
out_slab: out_slab:
unregister_pernet_subsys(&rds_tcp_net_ops);
kmem_cache_destroy(rds_tcp_conn_slab); kmem_cache_destroy(rds_tcp_conn_slab);
out: out:
return ret; return ret;
......
...@@ -52,6 +52,7 @@ u32 rds_tcp_snd_nxt(struct rds_tcp_connection *tc); ...@@ -52,6 +52,7 @@ u32 rds_tcp_snd_nxt(struct rds_tcp_connection *tc);
u32 rds_tcp_snd_una(struct rds_tcp_connection *tc); u32 rds_tcp_snd_una(struct rds_tcp_connection *tc);
u64 rds_tcp_map_seq(struct rds_tcp_connection *tc, u32 seq); u64 rds_tcp_map_seq(struct rds_tcp_connection *tc, u32 seq);
extern struct rds_transport rds_tcp_transport; extern struct rds_transport rds_tcp_transport;
void rds_tcp_accept_work(struct sock *sk);
/* tcp_connect.c */ /* tcp_connect.c */
int rds_tcp_conn_connect(struct rds_connection *conn); int rds_tcp_conn_connect(struct rds_connection *conn);
...@@ -59,9 +60,11 @@ void rds_tcp_conn_shutdown(struct rds_connection *conn); ...@@ -59,9 +60,11 @@ void rds_tcp_conn_shutdown(struct rds_connection *conn);
void rds_tcp_state_change(struct sock *sk); void rds_tcp_state_change(struct sock *sk);
/* tcp_listen.c */ /* tcp_listen.c */
int rds_tcp_listen_init(void); struct socket *rds_tcp_listen_init(struct net *);
void rds_tcp_listen_stop(void); void rds_tcp_listen_stop(struct socket *);
void rds_tcp_listen_data_ready(struct sock *sk); void rds_tcp_listen_data_ready(struct sock *sk);
int rds_tcp_accept_one(struct socket *sock);
int rds_tcp_keepalive(struct socket *sock);
/* tcp_recv.c */ /* tcp_recv.c */
int rds_tcp_recv_init(void); int rds_tcp_recv_init(void);
......
...@@ -79,7 +79,8 @@ int rds_tcp_conn_connect(struct rds_connection *conn) ...@@ -79,7 +79,8 @@ int rds_tcp_conn_connect(struct rds_connection *conn)
struct sockaddr_in src, dest; struct sockaddr_in src, dest;
int ret; int ret;
ret = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock); ret = sock_create_kern(rds_conn_net(conn), PF_INET,
SOCK_STREAM, IPPROTO_TCP, &sock);
if (ret < 0) if (ret < 0)
goto out; goto out;
...@@ -111,10 +112,12 @@ int rds_tcp_conn_connect(struct rds_connection *conn) ...@@ -111,10 +112,12 @@ int rds_tcp_conn_connect(struct rds_connection *conn)
rdsdebug("connect to address %pI4 returned %d\n", &conn->c_faddr, ret); rdsdebug("connect to address %pI4 returned %d\n", &conn->c_faddr, ret);
if (ret == -EINPROGRESS) if (ret == -EINPROGRESS)
ret = 0; ret = 0;
if (ret == 0) if (ret == 0) {
rds_tcp_keepalive(sock);
sock = NULL; sock = NULL;
else } else {
rds_tcp_restore_callbacks(sock, conn->c_transport_data); rds_tcp_restore_callbacks(sock, conn->c_transport_data);
}
out: out:
if (sock) if (sock)
......
...@@ -38,14 +38,7 @@ ...@@ -38,14 +38,7 @@
#include "rds.h" #include "rds.h"
#include "tcp.h" #include "tcp.h"
/* int rds_tcp_keepalive(struct socket *sock)
* cheesy, but simple..
*/
static void rds_tcp_accept_worker(struct work_struct *work);
static DECLARE_WORK(rds_tcp_listen_work, rds_tcp_accept_worker);
static struct socket *rds_tcp_listen_sock;
static int rds_tcp_keepalive(struct socket *sock)
{ {
/* values below based on xs_udp_default_timeout */ /* values below based on xs_udp_default_timeout */
int keepidle = 5; /* send a probe 'keepidle' secs after last data */ int keepidle = 5; /* send a probe 'keepidle' secs after last data */
...@@ -77,7 +70,7 @@ static int rds_tcp_keepalive(struct socket *sock) ...@@ -77,7 +70,7 @@ static int rds_tcp_keepalive(struct socket *sock)
return ret; return ret;
} }
static int rds_tcp_accept_one(struct socket *sock) int rds_tcp_accept_one(struct socket *sock)
{ {
struct socket *new_sock = NULL; struct socket *new_sock = NULL;
struct rds_connection *conn; struct rds_connection *conn;
...@@ -85,8 +78,9 @@ static int rds_tcp_accept_one(struct socket *sock) ...@@ -85,8 +78,9 @@ static int rds_tcp_accept_one(struct socket *sock)
struct inet_sock *inet; struct inet_sock *inet;
struct rds_tcp_connection *rs_tcp; struct rds_tcp_connection *rs_tcp;
ret = sock_create_lite(sock->sk->sk_family, sock->sk->sk_type, ret = sock_create_kern(sock_net(sock->sk), sock->sk->sk_family,
sock->sk->sk_protocol, &new_sock); sock->sk->sk_type, sock->sk->sk_protocol,
&new_sock);
if (ret) if (ret)
goto out; goto out;
...@@ -108,7 +102,8 @@ static int rds_tcp_accept_one(struct socket *sock) ...@@ -108,7 +102,8 @@ static int rds_tcp_accept_one(struct socket *sock)
&inet->inet_saddr, ntohs(inet->inet_sport), &inet->inet_saddr, ntohs(inet->inet_sport),
&inet->inet_daddr, ntohs(inet->inet_dport)); &inet->inet_daddr, ntohs(inet->inet_dport));
conn = rds_conn_create(inet->inet_saddr, inet->inet_daddr, conn = rds_conn_create(sock_net(sock->sk),
inet->inet_saddr, inet->inet_daddr,
&rds_tcp_transport, GFP_KERNEL); &rds_tcp_transport, GFP_KERNEL);
if (IS_ERR(conn)) { if (IS_ERR(conn)) {
ret = PTR_ERR(conn); ret = PTR_ERR(conn);
...@@ -148,12 +143,6 @@ static int rds_tcp_accept_one(struct socket *sock) ...@@ -148,12 +143,6 @@ static int rds_tcp_accept_one(struct socket *sock)
return ret; return ret;
} }
static void rds_tcp_accept_worker(struct work_struct *work)
{
while (rds_tcp_accept_one(rds_tcp_listen_sock) == 0)
cond_resched();
}
void rds_tcp_listen_data_ready(struct sock *sk) void rds_tcp_listen_data_ready(struct sock *sk)
{ {
void (*ready)(struct sock *sk); void (*ready)(struct sock *sk);
...@@ -174,20 +163,20 @@ void rds_tcp_listen_data_ready(struct sock *sk) ...@@ -174,20 +163,20 @@ void rds_tcp_listen_data_ready(struct sock *sk)
* socket * socket
*/ */
if (sk->sk_state == TCP_LISTEN) if (sk->sk_state == TCP_LISTEN)
queue_work(rds_wq, &rds_tcp_listen_work); rds_tcp_accept_work(sk);
out: out:
read_unlock(&sk->sk_callback_lock); read_unlock(&sk->sk_callback_lock);
ready(sk); ready(sk);
} }
int rds_tcp_listen_init(void) struct socket *rds_tcp_listen_init(struct net *net)
{ {
struct sockaddr_in sin; struct sockaddr_in sin;
struct socket *sock = NULL; struct socket *sock = NULL;
int ret; int ret;
ret = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock); ret = sock_create_kern(net, PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
if (ret < 0) if (ret < 0)
goto out; goto out;
...@@ -211,17 +200,15 @@ int rds_tcp_listen_init(void) ...@@ -211,17 +200,15 @@ int rds_tcp_listen_init(void)
if (ret < 0) if (ret < 0)
goto out; goto out;
rds_tcp_listen_sock = sock; return sock;
sock = NULL;
out: out:
if (sock) if (sock)
sock_release(sock); sock_release(sock);
return ret; return NULL;
} }
void rds_tcp_listen_stop(void) void rds_tcp_listen_stop(struct socket *sock)
{ {
struct socket *sock = rds_tcp_listen_sock;
struct sock *sk; struct sock *sk;
if (!sock) if (!sock)
...@@ -242,5 +229,4 @@ void rds_tcp_listen_stop(void) ...@@ -242,5 +229,4 @@ void rds_tcp_listen_stop(void)
/* wait for accepts to stop and close the socket */ /* wait for accepts to stop and close the socket */
flush_workqueue(rds_wq); flush_workqueue(rds_wq);
sock_release(sock); sock_release(sock);
rds_tcp_listen_sock = NULL;
} }
...@@ -77,7 +77,7 @@ void rds_trans_put(struct rds_transport *trans) ...@@ -77,7 +77,7 @@ void rds_trans_put(struct rds_transport *trans)
module_put(trans->t_owner); module_put(trans->t_owner);
} }
struct rds_transport *rds_trans_get_preferred(__be32 addr) struct rds_transport *rds_trans_get_preferred(struct net *net, __be32 addr)
{ {
struct rds_transport *ret = NULL; struct rds_transport *ret = NULL;
struct rds_transport *trans; struct rds_transport *trans;
...@@ -90,7 +90,7 @@ struct rds_transport *rds_trans_get_preferred(__be32 addr) ...@@ -90,7 +90,7 @@ struct rds_transport *rds_trans_get_preferred(__be32 addr)
for (i = 0; i < RDS_TRANS_COUNT; i++) { for (i = 0; i < RDS_TRANS_COUNT; i++) {
trans = transports[i]; trans = transports[i];
if (trans && (trans->laddr_check(addr) == 0) && if (trans && (trans->laddr_check(net, addr) == 0) &&
(!trans->t_owner || try_module_get(trans->t_owner))) { (!trans->t_owner || try_module_get(trans->t_owner))) {
ret = trans; ret = trans;
break; break;
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment