TCP option 30 is allocated for MPTCP by the IANA. Signed-off-by: Mat Martineau <mathew.j.martineau(a)linux.intel.com&gt; --- include/net/tcp.h | 1 + 1 file changed, 1 insertion(+) diff --git a/include/net/tcp.h b/include/net/tcp.h index 9c9b3768b350..c474f5478f76 100644 --- a/include/net/tcp.h +++ b/include/net/tcp.h @@ -182,6 +182,7 @@ void tcp_time_wait(struct sock *sk, int state, int timeo); #define TCPOPT_SACK 5 /* SACK Block */ #define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */ #define TCPOPT_MD5SIG 19 /* MD5 Signature (RFC2385) */ +#define TCPOPT_MPTCP 30 /* Multipath TCP (RFC6824) */ #define TCPOPT_FASTOPEN 34 /* Fast open (RFC7413) */ #define TCPOPT_EXP 254 /* Experimental */ /* Magic number to be after the option value for sharing TCP -- 2.16.3

From: Peter Krystad <peter.krystad(a)intel.com&gt; Implements the infrastructure for MPTCP sockets. MPTCP sockets open one in-kernel TCP socket per subflow. These subflow sockets are only managed by the MPTCP socket that owns them and are not visible from userspace. This commit allows a userspace program to open an MPTCP socket with: sock = socket(AF_INET, SOCK_STREAM, IPPROTO_MPTCP); The resulting socket is simply a wrapper around a single regular TCP socket, without any of the MPTCP protocol implemented over the wire. Signed-off-by: Mat Martineau <mathew.j.martineau(a)linux.intel.com&gt; --- include/net/mptcp.h | 31 ++++++++++++ net/Kconfig | 1 + net/Makefile | 1 + net/mptcp/Kconfig | 10 ++++ net/mptcp/Makefile | 3 ++ net/mptcp/protocol.c | 138 +++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 184 insertions(+) create mode 100644 include/net/mptcp.h create mode 100644 net/mptcp/Kconfig create mode 100644 net/mptcp/Makefile create mode 100644 net/mptcp/protocol.c diff --git a/include/net/mptcp.h b/include/net/mptcp.h new file mode 100644 index 000000000000..d66dbff5aa73 --- /dev/null +++ b/include/net/mptcp.h @@ -0,0 +1,31 @@ +/* + * Multipath TCP + * + * Copyright (c) 2017, Intel Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + */ + +#ifndef __NET_MPTCP_H +#define __NET_MPTCP_H + +/* MPTCP connection sock */ +struct mptcp_sock { + /* inet_connection_sock must be the first member */ + struct inet_connection_sock sk; + struct socket *subflow; +}; + +static inline struct mptcp_sock *mptcp_sk(const struct sock *sk) +{ + return (struct mptcp_sock *)sk; +} + +#endif /* __NET_MPTCP_H */ diff --git a/net/Kconfig b/net/Kconfig index 0428f12c25c2..d70128ec6560 100644 --- a/net/Kconfig +++ b/net/Kconfig @@ -88,6 +88,7 @@ if INET source "net/ipv4/Kconfig" source "net/ipv6/Kconfig" source "net/netlabel/Kconfig" +source "net/mptcp/Kconfig" endif # if INET diff --git a/net/Makefile b/net/Makefile index a6147c61b174..39caa65ef64a 100644 --- a/net/Makefile +++ b/net/Makefile @@ -85,3 +85,4 @@ obj-y += l3mdev/ endif obj-$(CONFIG_QRTR) += qrtr/ obj-$(CONFIG_NET_NCSI) += ncsi/ +obj-$(CONFIG_MPTCP) += mptcp/ diff --git a/net/mptcp/Kconfig b/net/mptcp/Kconfig new file mode 100644 index 000000000000..8e48190e5fed --- /dev/null +++ b/net/mptcp/Kconfig @@ -0,0 +1,10 @@ + +config MPTCP + bool "Multipath TCP" + depends on INET + ---help--- + Multipath TCP (MPTCP) connections send and receive data over multiple + subflows in order to utilize multiple network paths. Each subflow + uses the TCP protocol, and TCP options carry header information for + MPTCP. + diff --git a/net/mptcp/Makefile b/net/mptcp/Makefile new file mode 100644 index 000000000000..5624e7d51d48 --- /dev/null +++ b/net/mptcp/Makefile @@ -0,0 +1,3 @@ +obj-$(CONFIG_MPTCP) += mptcp.o + +mptcp-y := protocol.o diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c new file mode 100644 index 000000000000..393d214fe531 --- /dev/null +++ b/net/mptcp/protocol.c @@ -0,0 +1,138 @@ +/* + * Multipath TCP + * + * Copyright (c) 2017, Intel Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + */ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/netdevice.h> +#include <net/sock.h> +#include <net/inet_common.h> +#include <net/inet_hashtables.h> +#include <net/protocol.h> +#include <net/mptcp.h> + +static int mptcp_connect(struct sock *sk, struct sockaddr *saddr, int len) +{ + struct mptcp_sock *msk = mptcp_sk(sk); + int err; + + saddr->sa_family = AF_INET; + + pr_debug("msk=%p, subflow=%p", msk, msk->subflow->sk); + + err = kernel_connect(msk->subflow, saddr, len, 0); + + sk->sk_state = TCP_ESTABLISHED; + + return err; +} + +static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len) +{ + struct mptcp_sock *msk = mptcp_sk(sk); + struct socket *subflow = msk->subflow; + + pr_debug("subflow=%p", subflow->sk); + + return sock_sendmsg(subflow, msg); +} + +static int mptcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, + int nonblock, int flags, int *addr_len) +{ + struct mptcp_sock *msk = mptcp_sk(sk); + struct socket *subflow = msk->subflow; + + pr_debug("subflow=%p", subflow->sk); + + return sock_recvmsg(subflow, msg, flags); +} + +static int mptcp_init_sock(struct sock *sk) +{ + struct mptcp_sock *msk = mptcp_sk(sk); + struct socket *sf; + int err; + + pr_debug("msk=%p", msk); + + err = sock_create_kern(&init_net, PF_INET, SOCK_STREAM, IPPROTO_TCP, + &sf); + if (!err) { + pr_debug("subflow=%p", sf->sk); + msk->subflow = sf; + } + + return err; +} + +static void mptcp_close(struct sock *sk, long timeout) +{ + struct mptcp_sock *msk = mptcp_sk(sk); + + if (msk->subflow) { + pr_debug("subflow=%p", msk->subflow->sk); + sock_release(msk->subflow); + } +} + +static struct proto mptcp_prot = { + .name = "MPTCP", + .owner = THIS_MODULE, + .init = mptcp_init_sock, + .close = mptcp_close, + .accept = inet_csk_accept, + .connect = mptcp_connect, + .shutdown = tcp_shutdown, + .sendmsg = mptcp_sendmsg, + .recvmsg = mptcp_recvmsg, + .hash = inet_hash, + .unhash = inet_unhash, + .get_port = inet_csk_get_port, + .obj_size = sizeof(struct mptcp_sock), + .no_autobind = 1, +}; + +static struct inet_protosw mptcp_protosw = { + .type = SOCK_STREAM, + .protocol = IPPROTO_MPTCP, + .prot = &mptcp_prot, + .ops = &inet_stream_ops, +}; + +static int __init mptcp_init(void) +{ + int err; + + err = proto_register(&mptcp_prot, 1); + if (err) + return err; + + inet_register_protosw(&mptcp_protosw); + + return 0; +} + +static void __exit mptcp_exit(void) +{ + inet_unregister_protosw(&mptcp_protosw); + proto_unregister(&mptcp_prot); +} + +module_init(mptcp_init); +module_exit(mptcp_exit); + +MODULE_LICENSE("GPL"); +MODULE_ALIAS_NET_PF_PROTO(PF_INET, IPPROTO_MPTCP); +MODULE_ALIAS_NET_PF_PROTO(PF_INET6, IPPROTO_MPTCP); -- 2.16.3

From: Peter Krystad <peter.krystad(a)intel.com&gt; IANA protocol numbers fit in a single byte, however the protocol field of struct inet_protosw is an unsigned short so defining IPPROTO_SUBFLOW as a 16-bit value greater than 0xFF with the same LSB as IPPROTO_TCP is convenient for registering a unique protocol with inet_register_protosw() that still transmits packets with IPPROTO_TCP as the protocol number. Signed-off-by: Peter Krystad <peter.krystad(a)intel.com&gt; --- include/uapi/linux/in.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/uapi/linux/in.h b/include/uapi/linux/in.h index f65975c801e5..6986aecd0f46 100644 --- a/include/uapi/linux/in.h +++ b/include/uapi/linux/in.h @@ -78,6 +78,8 @@ enum { #define IPPROTO_MPLS IPPROTO_MPLS IPPROTO_RAW = 255, /* Raw IP packets */ #define IPPROTO_RAW IPPROTO_RAW + IPPROTO_SUBFLOW = 262, /* Multipath TCP (IPPROTO_TCP | 0x100) */ +#define IPPROTO_SUBFLOW IPPROTO_SUBFLOW IPPROTO_MAX }; #endif -- 2.16.3

From: Peter Krystad <peter.krystad(a)intel.com&gt; Override the bind() and connect() methods of the MPTCP socket so they may act on the subflow socket and use the .sk_rx_dst_set() handler in the subflow proto to capture when the responding SYN-ACK is received. Signed-off-by: Peter Krystad <peter.krystad(a)intel.com&gt; --- include/net/mptcp.h | 46 +++++++++++- net/mptcp/Makefile | 2 +- net/mptcp/protocol.c | 151 ++++++++++++++++++++++++++++++++++++---- net/mptcp/subflow.c | 192 +++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 376 insertions(+), 15 deletions(-) create mode 100644 net/mptcp/subflow.c diff --git a/include/net/mptcp.h b/include/net/mptcp.h index 6b4ae84ddf38..981d782cab9a 100644 --- a/include/net/mptcp.h +++ b/include/net/mptcp.h @@ -37,7 +37,10 @@ struct mptcp_sock { /* inet_connection_sock must be the first member */ struct inet_connection_sock sk; - struct socket *subflow; + u64 local_key; + u64 remote_key; + struct socket *connection_list; /* @@ needs to be a list */ + struct socket *subflow; /* outgoing connect, listener or !mp_capable */ }; static inline struct mptcp_sock *mptcp_sk(const struct sock *sk) @@ -45,6 +48,42 @@ static inline struct mptcp_sock *mptcp_sk(const struct sock *sk) return (struct mptcp_sock *)sk; } +/* MPTCP subflow sock structure */ +struct subflow_sock { + /* tcp_sock must be the first member */ + struct tcp_sock sk; + u64 local_key; + u64 remote_key; + bool request_mptcp; // send MP_CAPABLE + bool checksum; + bool version; + bool mp_capable; // remote is MPTCP capable + bool fourth_ack; // send initial DSS + struct sock *conn; // parent mptcp_sock +}; + +static inline struct subflow_sock *subflow_sk(const struct sock *sk) +{ + return (struct subflow_sock *)sk; +} + +struct subflow_request_sock { + struct tcp_request_sock sk; + u8 mp_capable : 1, + mp_join : 1, + checksum : 1, + backup : 1, + version : 4; + u64 local_key; + u64 remote_key; +}; + +static inline +struct subflow_request_sock *subflow_rsk(const struct request_sock *rsk) +{ + return (struct subflow_request_sock *)rsk; +} + #ifdef CONFIG_MPTCP void mptcp_parse_option(const unsigned char *ptr, int opsize, @@ -53,6 +92,11 @@ unsigned int mptcp_syn_options(struct sock *sk, u64 *local_key); unsigned int mptcp_synack_options(struct request_sock *req, u64 *local_key, u64 *remote_key); +void mptcp_finish_connect(struct sock *sk, int mp_capable); + +int mptcp_subflow_init(void); +void mptcp_subflow_exit(void); + void mptcp_get_options(const struct sk_buff *skb, struct tcp_options_received *options); diff --git a/net/mptcp/Makefile b/net/mptcp/Makefile index 2bd18e3b9fda..3f0e7163fe80 100644 --- a/net/mptcp/Makefile +++ b/net/mptcp/Makefile @@ -1,3 +1,3 @@ obj-$(CONFIG_MPTCP) += mptcp.o -mptcp-y := protocol.o options.o +mptcp-y := protocol.o subflow.o options.o diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c index 393d214fe531..368854740333 100644 --- a/net/mptcp/protocol.c +++ b/net/mptcp/protocol.c @@ -20,11 +20,13 @@ #include <net/inet_common.h> #include <net/inet_hashtables.h> #include <net/protocol.h> +#include <net/tcp.h> #include <net/mptcp.h> static int mptcp_connect(struct sock *sk, struct sockaddr *saddr, int len) { struct mptcp_sock *msk = mptcp_sk(sk); + struct subflow_sock *subflow = subflow_sk(msk->subflow->sk); int err; saddr->sa_family = AF_INET; @@ -32,18 +34,28 @@ static int mptcp_connect(struct sock *sk, struct sockaddr *saddr, int len) pr_debug("msk=%p, subflow=%p", msk, msk->subflow->sk); err = kernel_connect(msk->subflow, saddr, len, 0); - - sk->sk_state = TCP_ESTABLISHED; - + pr_debug("mp_capable=%d", subflow->mp_capable); + if (!err) { + msk->remote_key = subflow->remote_key; + msk->local_key = subflow->local_key; + msk->connection_list = msk->subflow; + msk->subflow = NULL; + } return err; } static int mptcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len) { struct mptcp_sock *msk = mptcp_sk(sk); - struct socket *subflow = msk->subflow; + struct socket *subflow; - pr_debug("subflow=%p", subflow->sk); + if (msk->connection_list) { + subflow = msk->connection_list; + pr_debug("conn_list->subflow=%p", subflow->sk); + } else { + subflow = msk->subflow; + pr_debug("subflow=%p", subflow->sk); + } return sock_sendmsg(subflow, msg); } @@ -52,9 +64,15 @@ static int mptcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock, int flags, int *addr_len) { struct mptcp_sock *msk = mptcp_sk(sk); - struct socket *subflow = msk->subflow; + struct socket *subflow; - pr_debug("subflow=%p", subflow->sk); + if (msk->connection_list) { + subflow = msk->connection_list; + pr_debug("conn_list->subflow=%p", subflow->sk); + } else { + subflow = msk->subflow; + pr_debug("subflow=%p", subflow->sk); + } return sock_recvmsg(subflow, msg, flags); } @@ -67,11 +85,19 @@ static int mptcp_init_sock(struct sock *sk) pr_debug("msk=%p", msk); - err = sock_create_kern(&init_net, PF_INET, SOCK_STREAM, IPPROTO_TCP, + err = sock_create_kern(&init_net, PF_INET, SOCK_STREAM, IPPROTO_SUBFLOW, &sf); if (!err) { - pr_debug("subflow=%p", sf->sk); + struct subflow_sock *subflow = subflow_sk(sf->sk); + + pr_debug("subflow=%p", subflow); + msk->local_key = 1234567887654321; // @@ fixed for now msk->subflow = sf; + subflow->conn = sk; + subflow->request_mptcp = 1; // @@ if MPTCP enabled + subflow->checksum = 1; // @@ if checksum enabled + subflow->version = 0; + subflow->local_key = msk->local_key; } return err; @@ -85,6 +111,60 @@ static void mptcp_close(struct sock *sk, long timeout) pr_debug("subflow=%p", msk->subflow->sk); sock_release(msk->subflow); } + + if (msk->connection_list) { + pr_debug("conn_list->subflow=%p", msk->connection_list->sk); + sock_release(msk->connection_list); + } +} + +static int mptcp_get_port(struct sock *sk, unsigned short snum) +{ + struct mptcp_sock *msk = mptcp_sk(sk); + struct sock *subflow = msk->subflow->sk; + + pr_debug("msk=%p, subflow=%p", sk, subflow); + + return inet_csk_get_port(subflow, snum); +} + +int mptcp_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) +{ + struct mptcp_sock *msk = mptcp_sk(sock->sk); + struct socket *subflow = msk->subflow; + + pr_debug("msk=%p, subflow=%p", msk, subflow->sk); + + return inet_bind(subflow, uaddr, addr_len); +} + +void mptcp_finish_connect(struct sock *sk, int mp_capable) +{ + struct mptcp_sock *msk = mptcp_sk(sk); + struct subflow_sock *subflow = subflow_sk(msk->subflow->sk); + + pr_debug("msk=%p", msk); + + if (mp_capable) { + msk->remote_key = subflow->remote_key; + msk->local_key = subflow->local_key; + msk->connection_list = msk->subflow; + msk->subflow = NULL; + } + sk->sk_state = TCP_ESTABLISHED; +} + +int mptcp_stream_connect(struct socket *sock, struct sockaddr *uaddr, + int addr_len, int flags) +{ + struct mptcp_sock *msk = mptcp_sk(sock->sk); + int err; + + pr_debug("msk=%p, subflow=%p", msk, msk->subflow->sk); + + err = inet_stream_connect(msk->subflow, uaddr, addr_len, flags); + + return err; } static struct proto mptcp_prot = { @@ -99,35 +179,80 @@ static struct proto mptcp_prot = { .recvmsg = mptcp_recvmsg, .hash = inet_hash, .unhash = inet_unhash, - .get_port = inet_csk_get_port, + .get_port = mptcp_get_port, .obj_size = sizeof(struct mptcp_sock), .no_autobind = 1, }; +const struct proto_ops mptcp_stream_ops = { + .family = PF_INET, + .owner = THIS_MODULE, + .release = inet_release, + .bind = mptcp_bind, + .connect = mptcp_stream_connect, + .socketpair = sock_no_socketpair, + .accept = inet_accept, + .getname = inet_getname, + .poll = tcp_poll, + .ioctl = inet_ioctl, + .listen = inet_listen, + .shutdown = inet_shutdown, + .setsockopt = sock_common_setsockopt, + .getsockopt = sock_common_getsockopt, + .sendmsg = inet_sendmsg, + .recvmsg = inet_recvmsg, + .mmap = sock_no_mmap, + .sendpage = inet_sendpage, + .splice_read = tcp_splice_read, + .read_sock = tcp_read_sock, + .peek_len = tcp_peek_len, +#ifdef CONFIG_COMPAT + .compat_setsockopt = compat_sock_common_setsockopt, + .compat_getsockopt = compat_sock_common_getsockopt, + .compat_ioctl = inet_compat_ioctl, +#endif +}; + static struct inet_protosw mptcp_protosw = { .type = SOCK_STREAM, .protocol = IPPROTO_MPTCP, .prot = &mptcp_prot, - .ops = &inet_stream_ops, + .ops = &mptcp_stream_ops, + .flags = INET_PROTOSW_ICSK, }; static int __init mptcp_init(void) { int err; - err = proto_register(&mptcp_prot, 1); + mptcp_prot.h.hashinfo = tcp_prot.h.hashinfo; + + err = mptcp_subflow_init(); if (err) - return err; + goto subflow_failed; + + err = proto_register(&mptcp_prot, 1); + if (err) { + goto proto_failed; + } inet_register_protosw(&mptcp_protosw); return 0; + +proto_failed: + mptcp_subflow_exit(); + +subflow_failed: + return err; } static void __exit mptcp_exit(void) { inet_unregister_protosw(&mptcp_protosw); proto_unregister(&mptcp_prot); + + mptcp_subflow_exit(); } module_init(mptcp_init); diff --git a/net/mptcp/subflow.c b/net/mptcp/subflow.c new file mode 100644 index 000000000000..5e5fdcb3175f --- /dev/null +++ b/net/mptcp/subflow.c @@ -0,0 +1,192 @@ +/* + * Multipath TCP + * + * Copyright (c) 2017, Intel Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + */ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/netdevice.h> +#include <net/sock.h> +#include <net/inet_common.h> +#include <net/inet_hashtables.h> +#include <net/protocol.h> +#include <net/tcp.h> +#include <net/mptcp.h> + +static int subflow_connect(struct sock *sk, struct sockaddr *saddr, int len) +{ + struct subflow_sock *subflow = subflow_sk(sk); + + saddr->sa_family = AF_INET; // @@ presume IPv4 for now + + pr_debug("subflow=%p", subflow); + + return tcp_v4_connect(sk, saddr, len); +} + +static int subflow_sendmsg(struct sock *sk, struct msghdr *msg, size_t len) +{ + struct subflow_sock *subflow = subflow_sk(sk); + + pr_debug("subflow=%p", subflow); + + return tcp_sendmsg(sk, msg, len); +} + +static int subflow_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, + int nonblock, int flags, int *addr_len) +{ + struct subflow_sock *subflow = subflow_sk(sk); + + pr_debug("subflow=%p", subflow); + + return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len); +} + +static void subflow_finish_connect(struct sock *sk, const struct sk_buff *skb) +{ + struct subflow_sock *subflow = subflow_sk(sk); + + inet_sk_rx_dst_set(sk, skb); + + pr_debug("subflow=%p", subflow); + + if (subflow->conn) { + pr_debug("remote_key=%llu", subflow->remote_key); + mptcp_finish_connect(subflow->conn, subflow->mp_capable); + subflow->conn = NULL; + } +} + +const struct inet_connection_sock_af_ops subflow_specific = { + .queue_xmit = ip_queue_xmit, + .send_check = tcp_v4_send_check, + .rebuild_header = inet_sk_rebuild_header, + .sk_rx_dst_set = subflow_finish_connect, + .conn_request = tcp_v4_conn_request, + .syn_recv_sock = tcp_v4_syn_recv_sock, + .net_header_len = sizeof(struct iphdr), + .setsockopt = ip_setsockopt, + .getsockopt = ip_getsockopt, + .addr2sockaddr = inet_csk_addr2sockaddr, + .sockaddr_len = sizeof(struct sockaddr_in), +#ifdef CONFIG_COMPAT + .compat_setsockopt = compat_ip_setsockopt, + .compat_getsockopt = compat_ip_getsockopt, +#endif + .mtu_reduced = tcp_v4_mtu_reduced, +}; + +static int subflow_init_sock(struct sock *sk) +{ + struct subflow_sock *subflow = subflow_sk(sk); + struct tcp_sock *tsk = tcp_sk(sk); + struct inet_connection_sock *icsk = inet_csk(sk); + int err; + + pr_debug("subflow=%p", subflow); + + err = tcp_v4_init_sock(sk); + if (!err) { // @@ AND mptcp is enabled + tsk->is_mptcp = 1; + icsk->icsk_af_ops = &subflow_specific; + } + + return err; +} + +static void subflow_close(struct sock *sk, long timeout) +{ + pr_debug("subflow=%p", sk); + + tcp_close(sk, timeout); +} + +static void subflow_destroy(struct sock *sk) +{ + pr_debug("subflow=%p", sk); + + tcp_v4_destroy_sock(sk); +} + +static struct proto subflow_prot = { + .name = "SUBFLOW", + .owner = THIS_MODULE, + .close = subflow_close, + .connect = subflow_connect, + .disconnect = tcp_disconnect, + .accept = inet_csk_accept, + .ioctl = tcp_ioctl, + .init = subflow_init_sock, + .destroy = subflow_destroy, + .shutdown = tcp_shutdown, + .keepalive = tcp_set_keepalive, + .recvmsg = subflow_recvmsg, + .sendmsg = subflow_sendmsg, + .sendpage = tcp_sendpage, + .backlog_rcv = tcp_v4_do_rcv, + .release_cb = tcp_release_cb, + .hash = inet_hash, + .unhash = inet_unhash, + .get_port = inet_csk_get_port, + .enter_memory_pressure = tcp_enter_memory_pressure, + .stream_memory_free = tcp_stream_memory_free, + .sockets_allocated = &tcp_sockets_allocated, + .orphan_count = &tcp_orphan_count, + .memory_allocated = &tcp_memory_allocated, + .memory_pressure = &tcp_memory_pressure, + .sysctl_mem = sysctl_tcp_mem, + .sysctl_wmem_offset = offsetof(struct net, ipv4.sysctl_tcp_wmem), + .sysctl_rmem_offset = offsetof(struct net, ipv4.sysctl_tcp_rmem), + .max_header = MAX_TCP_HEADER, + .obj_size = sizeof(struct subflow_sock), + .slab_flags = SLAB_TYPESAFE_BY_RCU, + + .no_autobind = true, +}; + +static struct inet_protosw subflow_protosw = { + .type = SOCK_STREAM, + .protocol = IPPROTO_SUBFLOW, + .prot = &subflow_prot, + .ops = &inet_stream_ops, + .flags = INET_PROTOSW_ICSK, +}; + +int mptcp_subflow_init(void) +{ + int err = -ENOMEM; + + /* TODO: Register path manager callbacks. */ + + subflow_prot.twsk_prot = tcp_prot.twsk_prot; + subflow_prot.h.hashinfo = tcp_prot.h.hashinfo; + err = proto_register(&subflow_prot, 1); + if (err) + goto fail; + + inet_register_protosw(&subflow_protosw); + + return 0; + +fail: + return err; +} + +void mptcp_subflow_exit(void) +{ + inet_unregister_protosw(&subflow_protosw); + proto_unregister(&subflow_prot); +} + +MODULE_LICENSE("GPL"); -- 2.16.3

From: Peter Krystad <peter.krystad(a)intel.com&gt; Generate the local keys, IDSN, and token when creating a new socket. Introduce the token tree to track all tokens in use using a radix tree with the MPTCP token itself as the index. Signed-off-by: Peter Krystad <peter.krystad(a)intel.com&gt; --- include/net/mptcp.h | 25 ++++++ net/mptcp/Makefile | 2 +- net/mptcp/crypto.c | 213 +++++++++++++++++++++++++++++++++++++++++++++++++ net/mptcp/protocol.c | 21 ++++- net/mptcp/subflow.c | 30 ++++++- net/mptcp/token.c | 221 +++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 508 insertions(+), 4 deletions(-) create mode 100644 net/mptcp/crypto.c create mode 100644 net/mptcp/token.c diff --git a/include/net/mptcp.h b/include/net/mptcp.h index 981d782cab9a..06bf49844c86 100644 --- a/include/net/mptcp.h +++ b/include/net/mptcp.h @@ -39,6 +39,7 @@ struct mptcp_sock { struct inet_connection_sock sk; u64 local_key; u64 remote_key; + u32 token; struct socket *connection_list; /* @@ needs to be a list */ struct socket *subflow; /* outgoing connect, listener or !mp_capable */ }; @@ -54,6 +55,7 @@ struct subflow_sock { struct tcp_sock sk; u64 local_key; u64 remote_key; + u32 token; bool request_mptcp; // send MP_CAPABLE bool checksum; bool version; @@ -76,6 +78,7 @@ struct subflow_request_sock { version : 4; u64 local_key; u64 remote_key; + u32 token; }; static inline @@ -102,6 +105,28 @@ void mptcp_get_options(const struct sk_buff *skb, extern const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops; +void token_init(void); +void token_new_request(struct request_sock *req, const struct sk_buff *skb); +void token_destroy_request(u32 token); +void token_new_connect(struct sock *sk); +void token_new_accept(struct sock *sk); +void token_destroy(u32 token); + +void crypto_init(void); +u32 crypto_v4_get_nonce(__be32 saddr, __be32 daddr, + __be16 sport, __be16 dport); +u64 crypto_v4_get_key(__be32 saddr, __be32 daddr, + __be16 sport, __be16 dport); +u64 crypto_v6_get_key(const struct in6_addr *saddr, + const struct in6_addr *daddr, + __be16 sport, __be16 dport); +u32 crypto_v6_get_nonce(const struct in6_addr *saddr, + const struct in6_addr *daddr, + __be16 sport, __be16 dport); +void crypto_key_sha1(u64 key, u32 *token, u64 *idsn); +void crypto_hmac_sha1(const u8 *key_1, const u8 *key_2, u32 *hash_out, + int arg_num, ...); + #else static inline void mptcp_parse_option(const unsigned char *ptr, int opsize, diff --git a/net/mptcp/Makefile b/net/mptcp/Makefile index 3f0e7163fe80..eaf59dc38b00 100644 --- a/net/mptcp/Makefile +++ b/net/mptcp/Makefile @@ -1,3 +1,3 @@ obj-$(CONFIG_MPTCP) += mptcp.o -mptcp-y := protocol.o subflow.o options.o +mptcp-y := protocol.o subflow.o options.o token.o crypto.o diff --git a/net/mptcp/crypto.c b/net/mptcp/crypto.c new file mode 100644 index 000000000000..0ba35449c4a0 --- /dev/null +++ b/net/mptcp/crypto.c @@ -0,0 +1,213 @@ +/* + * Multipath TCP cryptographic functions + * Copyright (c) 2017, Intel Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * Note: This code is based on mptcp_ctrl.c, mptcp_ipv4.c, and + * mptcp_ipv6 from multipath-tcp.org, authored by: + * + * Sébastien Barré <sebastien.barre(a)uclouvain.be&gt; + * Christoph Paasch <christoph.paasch(a)uclouvain.be&gt; + * Jaakko Korkeaniemi <jaakko.korkeaniemi(a)aalto.fi&gt; + * Gregory Detal <gregory.detal(a)uclouvain.be&gt; + * Fabien Duchêne <fabien.duchene(a)uclouvain.be&gt; + * Andreas Seelinger <Andreas.Seelinger(a)rwth-aachen.de&gt; + * Lavkesh Lahngir <lavkesh51(a)gmail.com&gt; + * Andreas Ripke <ripke(a)neclab.eu&gt; + * Vlad Dogaru <vlad.dogaru(a)intel.com&gt; + * Octavian Purdila <octavian.purdila(a)intel.com&gt; + * John Ronan <jronan(a)tssg.org&gt; + * Catalin Nicutar <catalin.nicutar(a)gmail.com&gt; + * Brandon Heller <brandonh(a)stanford.edu&gt; + */ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/netdevice.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/cryptohash.h> +#include <linux/random.h> +#include <linux/siphash.h> + +static siphash_key_t crypto_key_secret __read_mostly; +static hsiphash_key_t crypto_nonce_secret __read_mostly; +static u32 crypto_seed; + +u32 crypto_v4_get_nonce(__be32 saddr, __be32 daddr, __be16 sport, __be16 dport) +{ + return hsiphash_4u32((__force u32)saddr, (__force u32)daddr, + (__force u32)sport << 16 | (__force u32)dport, + crypto_seed++, &crypto_nonce_secret); +} + +u64 crypto_v4_get_key(__be32 saddr, __be32 daddr, __be16 sport, __be16 dport) +{ + pr_debug("src=%x:%d, dst=%x:%d", saddr, sport, daddr, dport); + return siphash_4u32((__force u32)saddr, (__force u32)daddr, + (__force u32)sport << 16 | (__force u32)dport, + crypto_seed++, &crypto_key_secret); +} + +u32 crypto_v6_get_nonce(const struct in6_addr *saddr, + const struct in6_addr *daddr, + __be16 sport, __be16 dport) +{ + const struct { + struct in6_addr saddr; + struct in6_addr daddr; + u32 seed; + __be16 sport; + __be16 dport; + } __aligned(SIPHASH_ALIGNMENT) combined = { + .saddr = *saddr, + .daddr = *daddr, + .seed = crypto_seed++, + .sport = sport, + .dport = dport, + }; + + return hsiphash(&combined, offsetofend(typeof(combined), dport), + &crypto_nonce_secret); +} + +u64 crypto_v6_get_key(const struct in6_addr *saddr, + const struct in6_addr *daddr, + __be16 sport, __be16 dport) +{ + const struct { + struct in6_addr saddr; + struct in6_addr daddr; + u32 seed; + __be16 sport; + __be16 dport; + } __aligned(SIPHASH_ALIGNMENT) combined = { + .saddr = *saddr, + .daddr = *daddr, + .seed = crypto_seed++, + .sport = sport, + .dport = dport, + }; + + return siphash(&combined, offsetofend(typeof(combined), dport), + &crypto_key_secret); +} + +void crypto_key_sha1(u64 key, u32 *token, u64 *idsn) +{ + u32 workspace[SHA_WORKSPACE_WORDS]; + u32 mptcp_hashed_key[SHA_DIGEST_WORDS]; + u8 input[64]; + int i; + + memset(workspace, 0, sizeof(workspace)); + + /* Initialize input with appropriate padding */ + memset(&input[9], 0, sizeof(input) - 10); /* -10, because the last byte + * is explicitly set too + */ + memcpy(input, &key, sizeof(key)); /* Copy key to the msg beginning */ + input[8] = 0x80; /* Padding: First bit after message = 1 */ + input[63] = 0x40; /* Padding: Length of the message = 64 bits */ + + sha_init(mptcp_hashed_key); + sha_transform(mptcp_hashed_key, input, workspace); + + for (i = 0; i < 5; i++) + mptcp_hashed_key[i] = cpu_to_be32(mptcp_hashed_key[i]); + + if (token) + *token = mptcp_hashed_key[0]; + if (idsn) + *idsn = *((u64 *)&mptcp_hashed_key[3]); +} + +void crypto_hmac_sha1(const u8 *key_1, const u8 *key_2, u32 *hash_out, + int arg_num, ...) +{ + u32 workspace[SHA_WORKSPACE_WORDS]; + u8 input[128]; /* 2 512-bit blocks */ + int i; + int index; + int length; + u8 *msg; + va_list list; + + memset(workspace, 0, sizeof(workspace)); + + /* Generate key xored with ipad */ + memset(input, 0x36, 64); + for (i = 0; i < 8; i++) + input[i] ^= key_1[i]; + for (i = 0; i < 8; i++) + input[i + 8] ^= key_2[i]; + + va_start(list, arg_num); + index = 64; + for (i = 0; i < arg_num; i++) { + length = va_arg(list, int); + msg = va_arg(list, u8 *); + WARN_ON(index + length > 125); /* Message is too long */ + memcpy(&input[index], msg, length); + index += length; + } + va_end(list); + + input[index] = 0x80; /* Padding: First bit after message = 1 */ + memset(&input[index + 1], 0, (126 - index)); + + /* Padding: Length of the message = 512 + message length (bits) */ + input[126] = 0x02; + input[127] = ((index - 64) * 8); /* Message length (bits) */ + + sha_init(hash_out); + sha_transform(hash_out, input, workspace); + memset(workspace, 0, sizeof(workspace)); + + sha_transform(hash_out, &input[64], workspace); + memset(workspace, 0, sizeof(workspace)); + + for (i = 0; i < 5; i++) + hash_out[i] = cpu_to_be32(hash_out[i]); + + /* Prepare second part of hmac */ + memset(input, 0x5C, 64); + for (i = 0; i < 8; i++) + input[i] ^= key_1[i]; + for (i = 0; i < 8; i++) + input[i + 8] ^= key_2[i]; + + memcpy(&input[64], hash_out, 20); + input[84] = 0x80; + memset(&input[85], 0, 41); + + /* Padding: Length of the message = 512 + 160 bits */ + input[126] = 0x02; + input[127] = 0xA0; + + sha_init(hash_out); + sha_transform(hash_out, input, workspace); + memset(workspace, 0, sizeof(workspace)); + + sha_transform(hash_out, &input[64], workspace); + + for (i = 0; i < 5; i++) + hash_out[i] = cpu_to_be32(hash_out[i]); +} + +void crypto_init(void) +{ + get_random_bytes((void *)&crypto_key_secret, + sizeof(crypto_key_secret)); + get_random_bytes((void *)&crypto_nonce_secret, + sizeof(crypto_nonce_secret)); + crypto_seed = 0; +} diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c index d401c197caf3..373e89cf8eda 100644 --- a/net/mptcp/protocol.c +++ b/net/mptcp/protocol.c @@ -38,6 +38,8 @@ static int mptcp_connect(struct sock *sk, struct sockaddr *saddr, int len) if (!err) { msk->remote_key = subflow->remote_key; msk->local_key = subflow->local_key; + msk->token = subflow->token; + pr_debug("token=%u", subflow->token); msk->connection_list = msk->subflow; msk->subflow = NULL; } @@ -91,13 +93,11 @@ static int mptcp_init_sock(struct sock *sk) struct subflow_sock *subflow = subflow_sk(sf->sk); pr_debug("subflow=%p", subflow); - msk->local_key = 1234567887654321; // @@ fixed for now msk->subflow = sf; subflow->conn = sk; subflow->request_mptcp = 1; // @@ if MPTCP enabled subflow->checksum = 1; // @@ if checksum enabled subflow->version = 0; - subflow->local_key = msk->local_key; } return err; @@ -148,6 +148,8 @@ static struct sock *mptcp_accept(struct sock *sk, int flags, int *err, if (subflow->mp_capable) { msk->remote_key = subflow->remote_key; msk->local_key = subflow->local_key; + msk->token = subflow->token; + pr_debug("token=%u", msk->token); msk->connection_list = new_sock; } else { msk->subflow = new_sock; @@ -156,6 +158,15 @@ static struct sock *mptcp_accept(struct sock *sk, int flags, int *err, return mp->sk; } +static void mptcp_destroy(struct sock *sk) +{ + struct mptcp_sock *msk = mptcp_sk(sk); + + pr_debug("msk=%p, subflow=%p", sk, msk->subflow->sk); + + token_destroy(msk->token); +} + static int mptcp_get_port(struct sock *sk, unsigned short snum) { struct mptcp_sock *msk = mptcp_sk(sk); @@ -186,6 +197,8 @@ void mptcp_finish_connect(struct sock *sk, int mp_capable) if (mp_capable) { msk->remote_key = subflow->remote_key; msk->local_key = subflow->local_key; + msk->token = subflow->token; + pr_debug("token=%u", msk->token); msk->connection_list = msk->subflow; msk->subflow = NULL; } @@ -223,6 +236,7 @@ static struct proto mptcp_prot = { .accept = mptcp_accept, .connect = mptcp_connect, .shutdown = tcp_shutdown, + .destroy = mptcp_destroy, .sendmsg = mptcp_sendmsg, .recvmsg = mptcp_recvmsg, .hash = inet_hash, @@ -275,6 +289,9 @@ static int __init mptcp_init(void) mptcp_prot.h.hashinfo = tcp_prot.h.hashinfo; + token_init(); + crypto_init(); + err = mptcp_subflow_init(); if (err) goto subflow_failed; diff --git a/net/mptcp/subflow.c b/net/mptcp/subflow.c index 89fcc3b746eb..9f417f3ed188 100644 --- a/net/mptcp/subflow.c +++ b/net/mptcp/subflow.c @@ -53,6 +53,28 @@ static int subflow_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len); } +static int subflow_rebuild_header(struct sock *sk) +{ + struct subflow_sock *subflow = subflow_sk(sk); + + if (subflow->request_mptcp && !subflow->token) { + pr_debug("subflow=%p", sk); + token_new_connect(sk); + } + + return inet_sk_rebuild_header(sk); +} + +static void subflow_req_destructor(struct request_sock *req) +{ + struct subflow_request_sock *subflow_req = subflow_rsk(req); + + pr_debug("subflow_req=%p", subflow_req); + + token_destroy_request(subflow_req->token); + tcp_request_sock_ops.destructor(req); +} + static void subflow_v4_init_req(struct request_sock *req, const struct sock *sk_listener, struct sk_buff *skb) @@ -82,6 +104,8 @@ static void subflow_v4_init_req(struct request_sock *req, listener->checksum) subflow_req->checksum = 1; subflow_req->remote_key = rx_opt.mptcp.sndr_key; + pr_debug("remote_key=%llu", subflow_req->remote_key); + token_new_request(req, skb); } else { subflow_req->mp_capable = 0; } @@ -147,6 +171,9 @@ static struct sock *subflow_syn_recv_sock(const struct sock *sk, subflow->fourth_ack = 1; subflow->remote_key = subflow_req->remote_key; subflow->local_key = subflow_req->local_key; + subflow->token = subflow_req->token; + pr_debug("token=%u", subflow->token); + token_new_accept(child); } else { subflow->mp_capable = 0; } @@ -158,7 +185,7 @@ static struct sock *subflow_syn_recv_sock(const struct sock *sk, const struct inet_connection_sock_af_ops subflow_specific = { .queue_xmit = ip_queue_xmit, .send_check = tcp_v4_send_check, - .rebuild_header = inet_sk_rebuild_header, + .rebuild_header = subflow_rebuild_header, .sk_rx_dst_set = subflow_finish_connect, .conn_request = subflow_conn_request, .syn_recv_sock = subflow_syn_recv_sock, @@ -273,6 +300,7 @@ int mptcp_subflow_init(void) subflow_request_sock_ops = tcp_request_sock_ops; subflow_request_sock_ops.obj_size = sizeof(struct subflow_request_sock), + subflow_request_sock_ops.destructor = subflow_req_destructor; subflow_request_sock_ipv4_ops = tcp_request_sock_ipv4_ops; subflow_request_sock_ipv4_ops.init_req = subflow_v4_init_req; diff --git a/net/mptcp/token.c b/net/mptcp/token.c new file mode 100644 index 000000000000..241cc0eb5729 --- /dev/null +++ b/net/mptcp/token.c @@ -0,0 +1,221 @@ +/* + * Multipath TCP token management + * Copyright (c) 2017, Intel Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * Note: This code is based on mptcp_ctrl.c from multipath-tcp.org, + * authored by: + * + * Sébastien Barré <sebastien.barre(a)uclouvain.be&gt; + * Christoph Paasch <christoph.paasch(a)uclouvain.be&gt; + * Jaakko Korkeaniemi <jaakko.korkeaniemi(a)aalto.fi&gt; + * Gregory Detal <gregory.detal(a)uclouvain.be&gt; + * Fabien Duchêne <fabien.duchene(a)uclouvain.be&gt; + * Andreas Seelinger <Andreas.Seelinger(a)rwth-aachen.de&gt; + * Lavkesh Lahngir <lavkesh51(a)gmail.com&gt; + * Andreas Ripke <ripke(a)neclab.eu&gt; + * Vlad Dogaru <vlad.dogaru(a)intel.com&gt; + * Octavian Purdila <octavian.purdila(a)intel.com&gt; + * John Ronan <jronan(a)tssg.org&gt; + * Catalin Nicutar <catalin.nicutar(a)gmail.com&gt; + * Brandon Heller <brandonh(a)stanford.edu&gt; + */ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/radix-tree.h> +#include <net/sock.h> +#include <net/inet_common.h> +#include <net/protocol.h> +#include <net/tcp.h> +#include <net/mptcp.h> + +static struct radix_tree_root token_tree; +static struct radix_tree_root token_req_tree; +static spinlock_t token_tree_lock; +static int token_used; + +static bool find_req_token(u32 token) +{ + void *used; + + pr_debug("token=%u", token); + used = radix_tree_lookup(&token_req_tree, token); + return (used == &token_used); +} + +static bool find_token(u32 token) +{ + void *used; + + pr_debug("token=%u", token); + used = radix_tree_lookup(&token_tree, token); + return (used == &token_used); +} + +static void new_req_token(struct request_sock *req, + const struct sk_buff *skb) +{ + const struct inet_request_sock *ireq = inet_rsk(req); + struct subflow_request_sock *subflow_req = subflow_rsk(req); + u64 local_key; + + if (skb->protocol == htons(ETH_P_IP)) { + local_key = crypto_v4_get_key(ip_hdr(skb)->saddr, + ip_hdr(skb)->daddr, + htons(ireq->ir_num), + ireq->ir_rmt_port); +#if IS_ENABLED(CONFIG_IPV6) + } else { + local_key = crypto_v6_get_key(&ipv6_hdr(skb)->saddr, + &ipv6_hdr(skb)->daddr, + htons(ireq->ir_num), + ireq->ir_rmt_port); +#endif + } + pr_debug("local_key=%llu:%llx", local_key, local_key); + subflow_req->local_key = local_key; + crypto_key_sha1(subflow_req->local_key, &subflow_req->token, NULL); + pr_debug("token=%u", subflow_req->token); +} + +static void new_token(const struct sock *sk) +{ + struct subflow_sock *subflow = subflow_sk(sk); + const struct inet_sock *isk = inet_sk(sk); + + if (sk->sk_family == AF_INET) { + subflow->local_key = crypto_v4_get_key(isk->inet_saddr, + isk->inet_daddr, + isk->inet_sport, + isk->inet_dport); +#if IS_ENABLED(CONFIG_IPV6) + } else { + subflow->local_key = crypto_v6_get_key(&inet6_sk(sk)->saddr, + &sk->sk_v6_daddr, + isk->inet_sport, + isk->inet_dport); +#endif + } + pr_debug("local_key=%llu:%llx", subflow->local_key, subflow->local_key); + crypto_key_sha1(subflow->local_key, &subflow->token, NULL); + pr_debug("token=%u", subflow->token); +} + +static int insert_req_token(u32 token) +{ + void *used = &token_used; + + pr_debug("token=%u", token); + return radix_tree_insert(&token_req_tree, token, used); +} + +static int insert_token(u32 token) +{ + void *used = &token_used; + + pr_debug("token=%u", token); + return radix_tree_insert(&token_tree, token, used); +} + +static void destroy_req_token(u32 token) +{ + void *cur; + + pr_debug("token=%u", token); + cur = radix_tree_delete(&token_req_tree, token); + if (!cur) + pr_warn("token NOT FOUND!"); +} + +static void destroy_token(u32 token) +{ + void *cur; + + pr_debug("token=%u", token); + cur = radix_tree_delete(&token_tree, token); + if (!cur) + pr_warn("token NOT FOUND!"); +} + +/* create new local key, idsn, and token for subflow_request */ +void token_new_request(struct request_sock *req, + const struct sk_buff *skb) +{ + struct subflow_request_sock *subflow_req = subflow_rsk(req); + + pr_debug("subflow_req=%p", req); + rcu_read_lock_bh(); + spin_lock_bh(&token_tree_lock); + do { + new_req_token(req, skb); + } while (find_req_token(subflow_req->token) || + find_token(subflow_req->token)); + insert_req_token(subflow_req->token); + spin_unlock_bh(&token_tree_lock); + rcu_read_unlock_bh(); +} + +/* create new local key, idsn, and token for subflow */ +void token_new_connect(struct sock *sk) +{ + struct subflow_sock *subflow = subflow_sk(sk); + + pr_debug("subflow=%p", sk); + + rcu_read_lock_bh(); + spin_lock_bh(&token_tree_lock); + do { + new_token(sk); + } while (find_req_token(subflow->token) || + find_token(subflow->token)); + insert_token(subflow->token); + spin_unlock_bh(&token_tree_lock); + rcu_read_unlock_bh(); +} + +void token_new_accept(struct sock *sk) +{ + struct subflow_sock *subflow = subflow_sk(sk); + + pr_debug("subflow=%p", sk); + + rcu_read_lock_bh(); + spin_lock_bh(&token_tree_lock); + insert_token(subflow->token); + spin_unlock_bh(&token_tree_lock); + rcu_read_unlock_bh(); +} + +void token_destroy_request(u32 token) +{ + rcu_read_lock_bh(); + spin_lock_bh(&token_tree_lock); + destroy_req_token(token); + spin_unlock_bh(&token_tree_lock); + rcu_read_unlock_bh(); +} + +void token_destroy(u32 token) +{ + rcu_read_lock_bh(); + spin_lock_bh(&token_tree_lock); + destroy_token(token); + spin_unlock_bh(&token_tree_lock); + rcu_read_unlock_bh(); +} + +void token_init(void) +{ + INIT_RADIX_TREE(&token_tree, GFP_ATOMIC); + INIT_RADIX_TREE(&token_req_tree, GFP_ATOMIC); + spin_lock_init(&token_tree_lock); +} -- 2.16.3

From: Peter Krystad <peter.krystad(a)intel.com&gt; Signed-off-by: Peter Krystad <peter.krystad(a)intel.com&gt; --- net/mptcp/protocol.c | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c index bf35d86a20ff..63cf5ead52f2 100644 --- a/net/mptcp/protocol.c +++ b/net/mptcp/protocol.c @@ -244,6 +244,26 @@ int mptcp_listen(struct socket *sock, int backlog) return inet_listen(subflow, backlog); } +int mptcp_stream_shutdown(struct socket *sock, int how) +{ + struct mptcp_sock *msk = mptcp_sk(sock->sk); + int ret = 0; + + pr_debug("sk=%p, how=%d", msk, how); + + if (msk->subflow) { + pr_debug("subflow=%p", msk->subflow->sk); + ret = kernel_sock_shutdown(msk->subflow, how); + } + if (msk->connection_list) { + pr_debug("conn_list->subflow=%p", msk->connection_list->sk); + ret = kernel_sock_shutdown(msk->connection_list, how); + } + inet_shutdown(sock, how); + + return ret; +} + static struct proto mptcp_prot = { .name = "MPTCP", .owner = THIS_MODULE, @@ -274,7 +294,7 @@ const struct proto_ops mptcp_stream_ops = { .poll = tcp_poll, .ioctl = inet_ioctl, .listen = mptcp_listen, - .shutdown = inet_shutdown, + .shutdown = mptcp_stream_shutdown, .setsockopt = sock_common_setsockopt, .getsockopt = sock_common_getsockopt, .sendmsg = inet_sendmsg, -- 2.16.3

The sk_buff control buffer is of limited size, and cannot be enlarged without significant impact on systemwide memory use. However, additional per-packet state is needed for some protocols, like Multipath TCP. An optional shared control buffer placed after the normal struct skb_shared_info can accomodate the necessary state without imposing extra memory usage or code changes on normal struct sk_buff users. __alloc_skb will now place a skb_shared_info_ext structure at skb->end when given the SKB_ALLOC_SHINFO_EXT flag. Most users of struct sk_buff continue to use the skb_shinfo() macro to access shared info. skb_shinfo(skb)->is_ext is set if the extended structure is available, and cleared if it is not. pskb_expand_head will preserve the shared control buffer if it is present. Signed-off-by: Mat Martineau <mathew.j.martineau(a)linux.intel.com&gt; --- include/linux/skbuff.h | 24 ++++++++++++++++++++++- net/core/skbuff.c | 53 ++++++++++++++++++++++++++++++++++++++------------ 2 files changed, 64 insertions(+), 13 deletions(-) diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h index 47082f54ec1f..aba3d4bf0cec 100644 --- a/include/linux/skbuff.h +++ b/include/linux/skbuff.h @@ -491,7 +491,8 @@ int skb_zerocopy_iter_stream(struct sock *sk, struct sk_buff *skb, * the end of the header data, ie. at skb->end. */ struct skb_shared_info { - __u8 __unused; + __u8 is_ext:1, + __unused:7; __u8 meta_len; __u8 nr_frags; __u8 tx_flags; @@ -531,6 +532,24 @@ struct skb_shared_info { #define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1) +/* This is an extended version of skb_shared_info, also invariant across + * clones and living at the end of the header data. + */ +struct skb_shared_info_ext { + /* skb_shared_info must be the first member */ + struct skb_shared_info shinfo; + + /* This is the shared control buffer. It is similar to sk_buff's + * control buffer, but is shared across clones. It must not be + * modified when multiple sk_buffs are referencing this structure. + */ + char shcb[48]; +}; + +#define SKB_SHINFO_EXT_OVERHEAD \ + (SKB_DATA_ALIGN(sizeof(struct skb_shared_info_ext)) - \ + SKB_DATA_ALIGN(sizeof(struct skb_shared_info))) + enum { SKB_FCLONE_UNAVAILABLE, /* skb has no fclone (from head_cache) */ SKB_FCLONE_ORIG, /* orig skb (from fclone_cache) */ @@ -857,6 +876,7 @@ struct sk_buff { #define SKB_ALLOC_FCLONE 0x01 #define SKB_ALLOC_RX 0x02 #define SKB_ALLOC_NAPI 0x04 +#define SKB_ALLOC_SHINFO_EXT 0x08 /* Returns true if the skb was allocated from PFMEMALLOC reserves */ static inline bool skb_pfmemalloc(const struct sk_buff *skb) @@ -1277,6 +1297,8 @@ static inline unsigned int skb_end_offset(const struct sk_buff *skb) /* Internal */ #define skb_shinfo(SKB) ((struct skb_shared_info *)(skb_end_pointer(SKB))) +#define skb_shinfo_ext(SKB) \ + ((struct skb_shared_info_ext *)(skb_end_pointer(SKB))) static inline struct skb_shared_hwtstamps *skb_hwtstamps(struct sk_buff *skb) { diff --git a/net/core/skbuff.c b/net/core/skbuff.c index b5c75d4fcf37..8b72dd9583f1 100644 --- a/net/core/skbuff.c +++ b/net/core/skbuff.c @@ -165,6 +165,8 @@ static void *__kmalloc_reserve(size_t size, gfp_t flags, int node, * instead of head cache and allocate a cloned (child) skb. * If SKB_ALLOC_RX is set, __GFP_MEMALLOC will be used for * allocations in case the data is required for writeback + * If SKB_ALLOC_SHINFO_EXT is set, the skb will be allocated + * with an extended shared info struct. * @node: numa node to allocate memory on * * Allocate a new &sk_buff. The returned buffer has no headroom and a @@ -178,9 +180,9 @@ struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask, int flags, int node) { struct kmem_cache *cache; - struct skb_shared_info *shinfo; struct sk_buff *skb; u8 *data; + unsigned int shinfo_size; bool pfmemalloc; cache = (flags & SKB_ALLOC_FCLONE) @@ -198,18 +200,22 @@ struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask, /* We do our best to align skb_shared_info on a separate cache * line. It usually works because kmalloc(X > SMP_CACHE_BYTES) gives * aligned memory blocks, unless SLUB/SLAB debug is enabled. - * Both skb->head and skb_shared_info are cache line aligned. + * Both skb->head and skb_shared_info (or skb_shared_info_ext) are + * cache line aligned. */ size = SKB_DATA_ALIGN(size); - size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info)); - data = kmalloc_reserve(size, gfp_mask, node, &pfmemalloc); + if (flags & SKB_ALLOC_SHINFO_EXT) + shinfo_size = SKB_DATA_ALIGN(sizeof(struct skb_shared_info_ext)); + else + shinfo_size = SKB_DATA_ALIGN(sizeof(struct skb_shared_info)); + data = kmalloc_reserve(size + shinfo_size, gfp_mask, node, &pfmemalloc); if (!data) goto nodata; /* kmalloc(size) might give us more room than requested. * Put skb_shared_info exactly at the end of allocated zone, * to allow max possible filling before reallocation. */ - size = SKB_WITH_OVERHEAD(ksize(data)); + size = ksize(data) - shinfo_size; prefetchw(data + size); /* @@ -219,7 +225,10 @@ struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask, */ memset(skb, 0, offsetof(struct sk_buff, tail)); /* Account for allocated memory : skb + skb->head */ - skb->truesize = SKB_TRUESIZE(size); + if (flags & SKB_ALLOC_SHINFO_EXT) + skb->truesize = SKB_TRUESIZE(size) + SKB_SHINFO_EXT_OVERHEAD; + else + skb->truesize = SKB_TRUESIZE(size); skb->pfmemalloc = pfmemalloc; refcount_set(&skb->users, 1); skb->head = data; @@ -230,9 +239,19 @@ struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask, skb->transport_header = (typeof(skb->transport_header))~0U; /* make sure we initialize shinfo sequentially */ - shinfo = skb_shinfo(skb); - memset(shinfo, 0, offsetof(struct skb_shared_info, dataref)); - atomic_set(&shinfo->dataref, 1); + if (flags & SKB_ALLOC_SHINFO_EXT) { + struct skb_shared_info_ext *shinfo_ext = skb_shinfo_ext(skb); + shinfo_ext->shinfo.is_ext = 1; + memset(&shinfo_ext->shinfo.meta_len, 0, + offsetof(struct skb_shared_info, dataref) - + offsetof(struct skb_shared_info, meta_len)); + atomic_set(&shinfo_ext->shinfo.dataref, 1); + memset(&shinfo_ext->shcb, 0, sizeof(shinfo_ext->shcb)); + } else { + struct skb_shared_info *shinfo = skb_shinfo(skb); + memset(shinfo, 0, offsetof(struct skb_shared_info, dataref)); + atomic_set(&shinfo->dataref, 1); + } if (flags & SKB_ALLOC_FCLONE) { struct sk_buff_fclones *fclones; @@ -1445,6 +1464,7 @@ int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail, { int i, osize = skb_end_offset(skb); int size = osize + nhead + ntail; + int shinfo_size; long off; u8 *data; @@ -1456,11 +1476,14 @@ int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail, if (skb_pfmemalloc(skb)) gfp_mask |= __GFP_MEMALLOC; - data = kmalloc_reserve(size + SKB_DATA_ALIGN(sizeof(struct skb_shared_info)), - gfp_mask, NUMA_NO_NODE, NULL); + if (skb_shinfo(skb)->is_ext) + shinfo_size = SKB_DATA_ALIGN(sizeof(struct skb_shared_info_ext)); + else + shinfo_size = SKB_DATA_ALIGN(sizeof(struct skb_shared_info)); + data = kmalloc_reserve(size + shinfo_size, gfp_mask, NUMA_NO_NODE, NULL); if (!data) goto nodata; - size = SKB_WITH_OVERHEAD(ksize(data)); + size = ksize(data) - shinfo_size; /* Copy only real data... and, alas, header. This should be * optimized for the cases when header is void. @@ -1470,6 +1493,12 @@ int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail, memcpy((struct skb_shared_info *)(data + size), skb_shinfo(skb), offsetof(struct skb_shared_info, frags[skb_shinfo(skb)->nr_frags])); + if (skb_shinfo(skb)->is_ext) { + int offset = offsetof(struct skb_shared_info_ext, shcb); + memcpy((struct skb_shared_info_ext *)(data + size + offset), + &skb_shinfo_ext(skb)->shcb, + sizeof(skb_shinfo_ext(skb)->shcb)); + } /* * if shinfo is shared we must drop the old head gracefully, but if it -- 2.16.3

crypto_key_sha1() was reordering bytes in words that were discarded, and the initial data sequence number (IDSN) was returned in a way that required additional byte swapping. Now only the token is returned with its bytes swapped, and the IDSN is returned in host order so it is ready for comparison and addition. Signed-off-by: Mat Martineau <mathew.j.martineau(a)linux.intel.com&gt; --- net/mptcp/crypto.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/net/mptcp/crypto.c b/net/mptcp/crypto.c index 0ba35449c4a0..8f575974dfce 100644 --- a/net/mptcp/crypto.c +++ b/net/mptcp/crypto.c @@ -106,7 +106,6 @@ void crypto_key_sha1(u64 key, u32 *token, u64 *idsn) u32 workspace[SHA_WORKSPACE_WORDS]; u32 mptcp_hashed_key[SHA_DIGEST_WORDS]; u8 input[64]; - int i; memset(workspace, 0, sizeof(workspace)); @@ -121,13 +120,10 @@ void crypto_key_sha1(u64 key, u32 *token, u64 *idsn) sha_init(mptcp_hashed_key); sha_transform(mptcp_hashed_key, input, workspace); - for (i = 0; i < 5; i++) - mptcp_hashed_key[i] = cpu_to_be32(mptcp_hashed_key[i]); - if (token) - *token = mptcp_hashed_key[0]; + *token = htonl(mptcp_hashed_key[0]); if (idsn) - *idsn = *((u64 *)&mptcp_hashed_key[3]); + *idsn = ((u64)mptcp_hashed_key[3] << 32) + mptcp_hashed_key[4]; } void crypto_hmac_sha1(const u8 *key_1, const u8 *key_2, u32 *hash_out, -- 2.16.3