Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Multipath TCP
0003  *
0004  * Copyright (c) 2021, Red Hat.
0005  */
0006 
0007 #define pr_fmt(fmt) "MPTCP: " fmt
0008 
0009 #include <linux/kernel.h>
0010 #include <linux/module.h>
0011 #include <net/sock.h>
0012 #include <net/protocol.h>
0013 #include <net/tcp.h>
0014 #include <net/mptcp.h>
0015 #include "protocol.h"
0016 
0017 #define MIN_INFO_OPTLEN_SIZE    16
0018 
0019 static struct sock *__mptcp_tcp_fallback(struct mptcp_sock *msk)
0020 {
0021     sock_owned_by_me((const struct sock *)msk);
0022 
0023     if (likely(!__mptcp_check_fallback(msk)))
0024         return NULL;
0025 
0026     return msk->first;
0027 }
0028 
0029 static u32 sockopt_seq_reset(const struct sock *sk)
0030 {
0031     sock_owned_by_me(sk);
0032 
0033     /* Highbits contain state.  Allows to distinguish sockopt_seq
0034      * of listener and established:
0035      * s0 = new_listener()
0036      * sockopt(s0) - seq is 1
0037      * s1 = accept(s0) - s1 inherits seq 1 if listener sk (s0)
0038      * sockopt(s0) - seq increments to 2 on s0
0039      * sockopt(s1) // seq increments to 2 on s1 (different option)
0040      * new ssk completes join, inherits options from s0 // seq 2
0041      * Needs sync from mptcp join logic, but ssk->seq == msk->seq
0042      *
0043      * Set High order bits to sk_state so ssk->seq == msk->seq test
0044      * will fail.
0045      */
0046 
0047     return (u32)sk->sk_state << 24u;
0048 }
0049 
0050 static void sockopt_seq_inc(struct mptcp_sock *msk)
0051 {
0052     u32 seq = (msk->setsockopt_seq + 1) & 0x00ffffff;
0053 
0054     msk->setsockopt_seq = sockopt_seq_reset((struct sock *)msk) + seq;
0055 }
0056 
0057 static int mptcp_get_int_option(struct mptcp_sock *msk, sockptr_t optval,
0058                 unsigned int optlen, int *val)
0059 {
0060     if (optlen < sizeof(int))
0061         return -EINVAL;
0062 
0063     if (copy_from_sockptr(val, optval, sizeof(*val)))
0064         return -EFAULT;
0065 
0066     return 0;
0067 }
0068 
0069 static void mptcp_sol_socket_sync_intval(struct mptcp_sock *msk, int optname, int val)
0070 {
0071     struct mptcp_subflow_context *subflow;
0072     struct sock *sk = (struct sock *)msk;
0073 
0074     lock_sock(sk);
0075     sockopt_seq_inc(msk);
0076 
0077     mptcp_for_each_subflow(msk, subflow) {
0078         struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
0079         bool slow = lock_sock_fast(ssk);
0080 
0081         switch (optname) {
0082         case SO_DEBUG:
0083             sock_valbool_flag(ssk, SOCK_DBG, !!val);
0084             break;
0085         case SO_KEEPALIVE:
0086             if (ssk->sk_prot->keepalive)
0087                 ssk->sk_prot->keepalive(ssk, !!val);
0088             sock_valbool_flag(ssk, SOCK_KEEPOPEN, !!val);
0089             break;
0090         case SO_PRIORITY:
0091             ssk->sk_priority = val;
0092             break;
0093         case SO_SNDBUF:
0094         case SO_SNDBUFFORCE:
0095             ssk->sk_userlocks |= SOCK_SNDBUF_LOCK;
0096             WRITE_ONCE(ssk->sk_sndbuf, sk->sk_sndbuf);
0097             break;
0098         case SO_RCVBUF:
0099         case SO_RCVBUFFORCE:
0100             ssk->sk_userlocks |= SOCK_RCVBUF_LOCK;
0101             WRITE_ONCE(ssk->sk_rcvbuf, sk->sk_rcvbuf);
0102             break;
0103         case SO_MARK:
0104             if (READ_ONCE(ssk->sk_mark) != sk->sk_mark) {
0105                 ssk->sk_mark = sk->sk_mark;
0106                 sk_dst_reset(ssk);
0107             }
0108             break;
0109         case SO_INCOMING_CPU:
0110             WRITE_ONCE(ssk->sk_incoming_cpu, val);
0111             break;
0112         }
0113 
0114         subflow->setsockopt_seq = msk->setsockopt_seq;
0115         unlock_sock_fast(ssk, slow);
0116     }
0117 
0118     release_sock(sk);
0119 }
0120 
0121 static int mptcp_sol_socket_intval(struct mptcp_sock *msk, int optname, int val)
0122 {
0123     sockptr_t optval = KERNEL_SOCKPTR(&val);
0124     struct sock *sk = (struct sock *)msk;
0125     int ret;
0126 
0127     ret = sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname,
0128                   optval, sizeof(val));
0129     if (ret)
0130         return ret;
0131 
0132     mptcp_sol_socket_sync_intval(msk, optname, val);
0133     return 0;
0134 }
0135 
0136 static void mptcp_so_incoming_cpu(struct mptcp_sock *msk, int val)
0137 {
0138     struct sock *sk = (struct sock *)msk;
0139 
0140     WRITE_ONCE(sk->sk_incoming_cpu, val);
0141 
0142     mptcp_sol_socket_sync_intval(msk, SO_INCOMING_CPU, val);
0143 }
0144 
0145 static int mptcp_setsockopt_sol_socket_tstamp(struct mptcp_sock *msk, int optname, int val)
0146 {
0147     sockptr_t optval = KERNEL_SOCKPTR(&val);
0148     struct mptcp_subflow_context *subflow;
0149     struct sock *sk = (struct sock *)msk;
0150     int ret;
0151 
0152     ret = sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname,
0153                   optval, sizeof(val));
0154     if (ret)
0155         return ret;
0156 
0157     lock_sock(sk);
0158     mptcp_for_each_subflow(msk, subflow) {
0159         struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
0160         bool slow = lock_sock_fast(ssk);
0161 
0162         sock_set_timestamp(sk, optname, !!val);
0163         unlock_sock_fast(ssk, slow);
0164     }
0165 
0166     release_sock(sk);
0167     return 0;
0168 }
0169 
0170 static int mptcp_setsockopt_sol_socket_int(struct mptcp_sock *msk, int optname,
0171                        sockptr_t optval,
0172                        unsigned int optlen)
0173 {
0174     int val, ret;
0175 
0176     ret = mptcp_get_int_option(msk, optval, optlen, &val);
0177     if (ret)
0178         return ret;
0179 
0180     switch (optname) {
0181     case SO_KEEPALIVE:
0182         mptcp_sol_socket_sync_intval(msk, optname, val);
0183         return 0;
0184     case SO_DEBUG:
0185     case SO_MARK:
0186     case SO_PRIORITY:
0187     case SO_SNDBUF:
0188     case SO_SNDBUFFORCE:
0189     case SO_RCVBUF:
0190     case SO_RCVBUFFORCE:
0191         return mptcp_sol_socket_intval(msk, optname, val);
0192     case SO_INCOMING_CPU:
0193         mptcp_so_incoming_cpu(msk, val);
0194         return 0;
0195     case SO_TIMESTAMP_OLD:
0196     case SO_TIMESTAMP_NEW:
0197     case SO_TIMESTAMPNS_OLD:
0198     case SO_TIMESTAMPNS_NEW:
0199         return mptcp_setsockopt_sol_socket_tstamp(msk, optname, val);
0200     }
0201 
0202     return -ENOPROTOOPT;
0203 }
0204 
0205 static int mptcp_setsockopt_sol_socket_timestamping(struct mptcp_sock *msk,
0206                             int optname,
0207                             sockptr_t optval,
0208                             unsigned int optlen)
0209 {
0210     struct mptcp_subflow_context *subflow;
0211     struct sock *sk = (struct sock *)msk;
0212     struct so_timestamping timestamping;
0213     int ret;
0214 
0215     if (optlen == sizeof(timestamping)) {
0216         if (copy_from_sockptr(&timestamping, optval,
0217                       sizeof(timestamping)))
0218             return -EFAULT;
0219     } else if (optlen == sizeof(int)) {
0220         memset(&timestamping, 0, sizeof(timestamping));
0221 
0222         if (copy_from_sockptr(&timestamping.flags, optval, sizeof(int)))
0223             return -EFAULT;
0224     } else {
0225         return -EINVAL;
0226     }
0227 
0228     ret = sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname,
0229                   KERNEL_SOCKPTR(&timestamping),
0230                   sizeof(timestamping));
0231     if (ret)
0232         return ret;
0233 
0234     lock_sock(sk);
0235 
0236     mptcp_for_each_subflow(msk, subflow) {
0237         struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
0238         bool slow = lock_sock_fast(ssk);
0239 
0240         sock_set_timestamping(sk, optname, timestamping);
0241         unlock_sock_fast(ssk, slow);
0242     }
0243 
0244     release_sock(sk);
0245 
0246     return 0;
0247 }
0248 
0249 static int mptcp_setsockopt_sol_socket_linger(struct mptcp_sock *msk, sockptr_t optval,
0250                           unsigned int optlen)
0251 {
0252     struct mptcp_subflow_context *subflow;
0253     struct sock *sk = (struct sock *)msk;
0254     struct linger ling;
0255     sockptr_t kopt;
0256     int ret;
0257 
0258     if (optlen < sizeof(ling))
0259         return -EINVAL;
0260 
0261     if (copy_from_sockptr(&ling, optval, sizeof(ling)))
0262         return -EFAULT;
0263 
0264     kopt = KERNEL_SOCKPTR(&ling);
0265     ret = sock_setsockopt(sk->sk_socket, SOL_SOCKET, SO_LINGER, kopt, sizeof(ling));
0266     if (ret)
0267         return ret;
0268 
0269     lock_sock(sk);
0270     sockopt_seq_inc(msk);
0271     mptcp_for_each_subflow(msk, subflow) {
0272         struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
0273         bool slow = lock_sock_fast(ssk);
0274 
0275         if (!ling.l_onoff) {
0276             sock_reset_flag(ssk, SOCK_LINGER);
0277         } else {
0278             ssk->sk_lingertime = sk->sk_lingertime;
0279             sock_set_flag(ssk, SOCK_LINGER);
0280         }
0281 
0282         subflow->setsockopt_seq = msk->setsockopt_seq;
0283         unlock_sock_fast(ssk, slow);
0284     }
0285 
0286     release_sock(sk);
0287     return 0;
0288 }
0289 
0290 static int mptcp_setsockopt_sol_socket(struct mptcp_sock *msk, int optname,
0291                        sockptr_t optval, unsigned int optlen)
0292 {
0293     struct sock *sk = (struct sock *)msk;
0294     struct socket *ssock;
0295     int ret;
0296 
0297     switch (optname) {
0298     case SO_REUSEPORT:
0299     case SO_REUSEADDR:
0300     case SO_BINDTODEVICE:
0301     case SO_BINDTOIFINDEX:
0302         lock_sock(sk);
0303         ssock = __mptcp_nmpc_socket(msk);
0304         if (!ssock) {
0305             release_sock(sk);
0306             return -EINVAL;
0307         }
0308 
0309         ret = sock_setsockopt(ssock, SOL_SOCKET, optname, optval, optlen);
0310         if (ret == 0) {
0311             if (optname == SO_REUSEPORT)
0312                 sk->sk_reuseport = ssock->sk->sk_reuseport;
0313             else if (optname == SO_REUSEADDR)
0314                 sk->sk_reuse = ssock->sk->sk_reuse;
0315             else if (optname == SO_BINDTODEVICE)
0316                 sk->sk_bound_dev_if = ssock->sk->sk_bound_dev_if;
0317             else if (optname == SO_BINDTOIFINDEX)
0318                 sk->sk_bound_dev_if = ssock->sk->sk_bound_dev_if;
0319         }
0320         release_sock(sk);
0321         return ret;
0322     case SO_KEEPALIVE:
0323     case SO_PRIORITY:
0324     case SO_SNDBUF:
0325     case SO_SNDBUFFORCE:
0326     case SO_RCVBUF:
0327     case SO_RCVBUFFORCE:
0328     case SO_MARK:
0329     case SO_INCOMING_CPU:
0330     case SO_DEBUG:
0331     case SO_TIMESTAMP_OLD:
0332     case SO_TIMESTAMP_NEW:
0333     case SO_TIMESTAMPNS_OLD:
0334     case SO_TIMESTAMPNS_NEW:
0335         return mptcp_setsockopt_sol_socket_int(msk, optname, optval,
0336                                optlen);
0337     case SO_TIMESTAMPING_OLD:
0338     case SO_TIMESTAMPING_NEW:
0339         return mptcp_setsockopt_sol_socket_timestamping(msk, optname,
0340                                 optval, optlen);
0341     case SO_LINGER:
0342         return mptcp_setsockopt_sol_socket_linger(msk, optval, optlen);
0343     case SO_RCVLOWAT:
0344     case SO_RCVTIMEO_OLD:
0345     case SO_RCVTIMEO_NEW:
0346     case SO_SNDTIMEO_OLD:
0347     case SO_SNDTIMEO_NEW:
0348     case SO_BUSY_POLL:
0349     case SO_PREFER_BUSY_POLL:
0350     case SO_BUSY_POLL_BUDGET:
0351         /* No need to copy: only relevant for msk */
0352         return sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname, optval, optlen);
0353     case SO_NO_CHECK:
0354     case SO_DONTROUTE:
0355     case SO_BROADCAST:
0356     case SO_BSDCOMPAT:
0357     case SO_PASSCRED:
0358     case SO_PASSSEC:
0359     case SO_RXQ_OVFL:
0360     case SO_WIFI_STATUS:
0361     case SO_NOFCS:
0362     case SO_SELECT_ERR_QUEUE:
0363         return 0;
0364     }
0365 
0366     /* SO_OOBINLINE is not supported, let's avoid the related mess
0367      * SO_ATTACH_FILTER, SO_ATTACH_BPF, SO_ATTACH_REUSEPORT_CBPF,
0368      * SO_DETACH_REUSEPORT_BPF, SO_DETACH_FILTER, SO_LOCK_FILTER,
0369      * we must be careful with subflows
0370      *
0371      * SO_ATTACH_REUSEPORT_EBPF is not supported, at it checks
0372      * explicitly the sk_protocol field
0373      *
0374      * SO_PEEK_OFF is unsupported, as it is for plain TCP
0375      * SO_MAX_PACING_RATE is unsupported, we must be careful with subflows
0376      * SO_CNX_ADVICE is currently unsupported, could possibly be relevant,
0377      * but likely needs careful design
0378      *
0379      * SO_ZEROCOPY is currently unsupported, TODO in sndmsg
0380      * SO_TXTIME is currently unsupported
0381      */
0382 
0383     return -EOPNOTSUPP;
0384 }
0385 
0386 static int mptcp_setsockopt_v6(struct mptcp_sock *msk, int optname,
0387                    sockptr_t optval, unsigned int optlen)
0388 {
0389     struct sock *sk = (struct sock *)msk;
0390     int ret = -EOPNOTSUPP;
0391     struct socket *ssock;
0392 
0393     switch (optname) {
0394     case IPV6_V6ONLY:
0395     case IPV6_TRANSPARENT:
0396     case IPV6_FREEBIND:
0397         lock_sock(sk);
0398         ssock = __mptcp_nmpc_socket(msk);
0399         if (!ssock) {
0400             release_sock(sk);
0401             return -EINVAL;
0402         }
0403 
0404         ret = tcp_setsockopt(ssock->sk, SOL_IPV6, optname, optval, optlen);
0405         if (ret != 0) {
0406             release_sock(sk);
0407             return ret;
0408         }
0409 
0410         sockopt_seq_inc(msk);
0411 
0412         switch (optname) {
0413         case IPV6_V6ONLY:
0414             sk->sk_ipv6only = ssock->sk->sk_ipv6only;
0415             break;
0416         case IPV6_TRANSPARENT:
0417             inet_sk(sk)->transparent = inet_sk(ssock->sk)->transparent;
0418             break;
0419         case IPV6_FREEBIND:
0420             inet_sk(sk)->freebind = inet_sk(ssock->sk)->freebind;
0421             break;
0422         }
0423 
0424         release_sock(sk);
0425         break;
0426     }
0427 
0428     return ret;
0429 }
0430 
0431 static bool mptcp_supported_sockopt(int level, int optname)
0432 {
0433     if (level == SOL_IP) {
0434         switch (optname) {
0435         /* should work fine */
0436         case IP_FREEBIND:
0437         case IP_TRANSPARENT:
0438 
0439         /* the following are control cmsg related */
0440         case IP_PKTINFO:
0441         case IP_RECVTTL:
0442         case IP_RECVTOS:
0443         case IP_RECVOPTS:
0444         case IP_RETOPTS:
0445         case IP_PASSSEC:
0446         case IP_RECVORIGDSTADDR:
0447         case IP_CHECKSUM:
0448         case IP_RECVFRAGSIZE:
0449 
0450         /* common stuff that need some love */
0451         case IP_TOS:
0452         case IP_TTL:
0453         case IP_BIND_ADDRESS_NO_PORT:
0454         case IP_MTU_DISCOVER:
0455         case IP_RECVERR:
0456 
0457         /* possibly less common may deserve some love */
0458         case IP_MINTTL:
0459 
0460         /* the following is apparently a no-op for plain TCP */
0461         case IP_RECVERR_RFC4884:
0462             return true;
0463         }
0464 
0465         /* IP_OPTIONS is not supported, needs subflow care */
0466         /* IP_HDRINCL, IP_NODEFRAG are not supported, RAW specific */
0467         /* IP_MULTICAST_TTL, IP_MULTICAST_LOOP, IP_UNICAST_IF,
0468          * IP_ADD_MEMBERSHIP, IP_ADD_SOURCE_MEMBERSHIP, IP_DROP_MEMBERSHIP,
0469          * IP_DROP_SOURCE_MEMBERSHIP, IP_BLOCK_SOURCE, IP_UNBLOCK_SOURCE,
0470          * MCAST_JOIN_GROUP, MCAST_LEAVE_GROUP MCAST_JOIN_SOURCE_GROUP,
0471          * MCAST_LEAVE_SOURCE_GROUP, MCAST_BLOCK_SOURCE, MCAST_UNBLOCK_SOURCE,
0472          * MCAST_MSFILTER, IP_MULTICAST_ALL are not supported, better not deal
0473          * with mcast stuff
0474          */
0475         /* IP_IPSEC_POLICY, IP_XFRM_POLICY are nut supported, unrelated here */
0476         return false;
0477     }
0478     if (level == SOL_IPV6) {
0479         switch (optname) {
0480         case IPV6_V6ONLY:
0481 
0482         /* the following are control cmsg related */
0483         case IPV6_RECVPKTINFO:
0484         case IPV6_2292PKTINFO:
0485         case IPV6_RECVHOPLIMIT:
0486         case IPV6_2292HOPLIMIT:
0487         case IPV6_RECVRTHDR:
0488         case IPV6_2292RTHDR:
0489         case IPV6_RECVHOPOPTS:
0490         case IPV6_2292HOPOPTS:
0491         case IPV6_RECVDSTOPTS:
0492         case IPV6_2292DSTOPTS:
0493         case IPV6_RECVTCLASS:
0494         case IPV6_FLOWINFO:
0495         case IPV6_RECVPATHMTU:
0496         case IPV6_RECVORIGDSTADDR:
0497         case IPV6_RECVFRAGSIZE:
0498 
0499         /* the following ones need some love but are quite common */
0500         case IPV6_TCLASS:
0501         case IPV6_TRANSPARENT:
0502         case IPV6_FREEBIND:
0503         case IPV6_PKTINFO:
0504         case IPV6_2292PKTOPTIONS:
0505         case IPV6_UNICAST_HOPS:
0506         case IPV6_MTU_DISCOVER:
0507         case IPV6_MTU:
0508         case IPV6_RECVERR:
0509         case IPV6_FLOWINFO_SEND:
0510         case IPV6_FLOWLABEL_MGR:
0511         case IPV6_MINHOPCOUNT:
0512         case IPV6_DONTFRAG:
0513         case IPV6_AUTOFLOWLABEL:
0514 
0515         /* the following one is a no-op for plain TCP */
0516         case IPV6_RECVERR_RFC4884:
0517             return true;
0518         }
0519 
0520         /* IPV6_HOPOPTS, IPV6_RTHDRDSTOPTS, IPV6_RTHDR, IPV6_DSTOPTS are
0521          * not supported
0522          */
0523         /* IPV6_MULTICAST_HOPS, IPV6_MULTICAST_LOOP, IPV6_UNICAST_IF,
0524          * IPV6_MULTICAST_IF, IPV6_ADDRFORM,
0525          * IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP, IPV6_JOIN_ANYCAST,
0526          * IPV6_LEAVE_ANYCAST, IPV6_MULTICAST_ALL, MCAST_JOIN_GROUP, MCAST_LEAVE_GROUP,
0527          * MCAST_JOIN_SOURCE_GROUP, MCAST_LEAVE_SOURCE_GROUP,
0528          * MCAST_BLOCK_SOURCE, MCAST_UNBLOCK_SOURCE, MCAST_MSFILTER
0529          * are not supported better not deal with mcast
0530          */
0531         /* IPV6_ROUTER_ALERT, IPV6_ROUTER_ALERT_ISOLATE are not supported, since are evil */
0532 
0533         /* IPV6_IPSEC_POLICY, IPV6_XFRM_POLICY are not supported */
0534         /* IPV6_ADDR_PREFERENCES is not supported, we must be careful with subflows */
0535         return false;
0536     }
0537     if (level == SOL_TCP) {
0538         switch (optname) {
0539         /* the following are no-op or should work just fine */
0540         case TCP_THIN_DUPACK:
0541         case TCP_DEFER_ACCEPT:
0542 
0543         /* the following need some love */
0544         case TCP_MAXSEG:
0545         case TCP_NODELAY:
0546         case TCP_THIN_LINEAR_TIMEOUTS:
0547         case TCP_CONGESTION:
0548         case TCP_CORK:
0549         case TCP_KEEPIDLE:
0550         case TCP_KEEPINTVL:
0551         case TCP_KEEPCNT:
0552         case TCP_SYNCNT:
0553         case TCP_SAVE_SYN:
0554         case TCP_LINGER2:
0555         case TCP_WINDOW_CLAMP:
0556         case TCP_QUICKACK:
0557         case TCP_USER_TIMEOUT:
0558         case TCP_TIMESTAMP:
0559         case TCP_NOTSENT_LOWAT:
0560         case TCP_TX_DELAY:
0561         case TCP_INQ:
0562             return true;
0563         }
0564 
0565         /* TCP_MD5SIG, TCP_MD5SIG_EXT are not supported, MD5 is not compatible with MPTCP */
0566 
0567         /* TCP_REPAIR, TCP_REPAIR_QUEUE, TCP_QUEUE_SEQ, TCP_REPAIR_OPTIONS,
0568          * TCP_REPAIR_WINDOW are not supported, better avoid this mess
0569          */
0570         /* TCP_FASTOPEN_KEY, TCP_FASTOPEN TCP_FASTOPEN_CONNECT, TCP_FASTOPEN_NO_COOKIE,
0571          * are not supported fastopen is currently unsupported
0572          */
0573     }
0574     return false;
0575 }
0576 
0577 static int mptcp_setsockopt_sol_tcp_congestion(struct mptcp_sock *msk, sockptr_t optval,
0578                            unsigned int optlen)
0579 {
0580     struct mptcp_subflow_context *subflow;
0581     struct sock *sk = (struct sock *)msk;
0582     char name[TCP_CA_NAME_MAX];
0583     bool cap_net_admin;
0584     int ret;
0585 
0586     if (optlen < 1)
0587         return -EINVAL;
0588 
0589     ret = strncpy_from_sockptr(name, optval,
0590                    min_t(long, TCP_CA_NAME_MAX - 1, optlen));
0591     if (ret < 0)
0592         return -EFAULT;
0593 
0594     name[ret] = 0;
0595 
0596     cap_net_admin = ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN);
0597 
0598     ret = 0;
0599     lock_sock(sk);
0600     sockopt_seq_inc(msk);
0601     mptcp_for_each_subflow(msk, subflow) {
0602         struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
0603         int err;
0604 
0605         lock_sock(ssk);
0606         err = tcp_set_congestion_control(ssk, name, true, cap_net_admin);
0607         if (err < 0 && ret == 0)
0608             ret = err;
0609         subflow->setsockopt_seq = msk->setsockopt_seq;
0610         release_sock(ssk);
0611     }
0612 
0613     if (ret == 0)
0614         strcpy(msk->ca_name, name);
0615 
0616     release_sock(sk);
0617     return ret;
0618 }
0619 
0620 static int mptcp_setsockopt_sol_tcp_cork(struct mptcp_sock *msk, sockptr_t optval,
0621                      unsigned int optlen)
0622 {
0623     struct mptcp_subflow_context *subflow;
0624     struct sock *sk = (struct sock *)msk;
0625     int val;
0626 
0627     if (optlen < sizeof(int))
0628         return -EINVAL;
0629 
0630     if (copy_from_sockptr(&val, optval, sizeof(val)))
0631         return -EFAULT;
0632 
0633     lock_sock(sk);
0634     sockopt_seq_inc(msk);
0635     msk->cork = !!val;
0636     mptcp_for_each_subflow(msk, subflow) {
0637         struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
0638 
0639         lock_sock(ssk);
0640         __tcp_sock_set_cork(ssk, !!val);
0641         release_sock(ssk);
0642     }
0643     if (!val)
0644         mptcp_check_and_set_pending(sk);
0645     release_sock(sk);
0646 
0647     return 0;
0648 }
0649 
0650 static int mptcp_setsockopt_sol_tcp_nodelay(struct mptcp_sock *msk, sockptr_t optval,
0651                         unsigned int optlen)
0652 {
0653     struct mptcp_subflow_context *subflow;
0654     struct sock *sk = (struct sock *)msk;
0655     int val;
0656 
0657     if (optlen < sizeof(int))
0658         return -EINVAL;
0659 
0660     if (copy_from_sockptr(&val, optval, sizeof(val)))
0661         return -EFAULT;
0662 
0663     lock_sock(sk);
0664     sockopt_seq_inc(msk);
0665     msk->nodelay = !!val;
0666     mptcp_for_each_subflow(msk, subflow) {
0667         struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
0668 
0669         lock_sock(ssk);
0670         __tcp_sock_set_nodelay(ssk, !!val);
0671         release_sock(ssk);
0672     }
0673     if (val)
0674         mptcp_check_and_set_pending(sk);
0675     release_sock(sk);
0676 
0677     return 0;
0678 }
0679 
0680 static int mptcp_setsockopt_sol_ip_set_transparent(struct mptcp_sock *msk, int optname,
0681                            sockptr_t optval, unsigned int optlen)
0682 {
0683     struct sock *sk = (struct sock *)msk;
0684     struct inet_sock *issk;
0685     struct socket *ssock;
0686     int err;
0687 
0688     err = ip_setsockopt(sk, SOL_IP, optname, optval, optlen);
0689     if (err != 0)
0690         return err;
0691 
0692     lock_sock(sk);
0693 
0694     ssock = __mptcp_nmpc_socket(msk);
0695     if (!ssock) {
0696         release_sock(sk);
0697         return -EINVAL;
0698     }
0699 
0700     issk = inet_sk(ssock->sk);
0701 
0702     switch (optname) {
0703     case IP_FREEBIND:
0704         issk->freebind = inet_sk(sk)->freebind;
0705         break;
0706     case IP_TRANSPARENT:
0707         issk->transparent = inet_sk(sk)->transparent;
0708         break;
0709     default:
0710         release_sock(sk);
0711         WARN_ON_ONCE(1);
0712         return -EOPNOTSUPP;
0713     }
0714 
0715     sockopt_seq_inc(msk);
0716     release_sock(sk);
0717     return 0;
0718 }
0719 
0720 static int mptcp_setsockopt_v4_set_tos(struct mptcp_sock *msk, int optname,
0721                        sockptr_t optval, unsigned int optlen)
0722 {
0723     struct mptcp_subflow_context *subflow;
0724     struct sock *sk = (struct sock *)msk;
0725     int err, val;
0726 
0727     err = ip_setsockopt(sk, SOL_IP, optname, optval, optlen);
0728 
0729     if (err != 0)
0730         return err;
0731 
0732     lock_sock(sk);
0733     sockopt_seq_inc(msk);
0734     val = inet_sk(sk)->tos;
0735     mptcp_for_each_subflow(msk, subflow) {
0736         struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
0737 
0738         __ip_sock_set_tos(ssk, val);
0739     }
0740     release_sock(sk);
0741 
0742     return err;
0743 }
0744 
0745 static int mptcp_setsockopt_v4(struct mptcp_sock *msk, int optname,
0746                    sockptr_t optval, unsigned int optlen)
0747 {
0748     switch (optname) {
0749     case IP_FREEBIND:
0750     case IP_TRANSPARENT:
0751         return mptcp_setsockopt_sol_ip_set_transparent(msk, optname, optval, optlen);
0752     case IP_TOS:
0753         return mptcp_setsockopt_v4_set_tos(msk, optname, optval, optlen);
0754     }
0755 
0756     return -EOPNOTSUPP;
0757 }
0758 
0759 static int mptcp_setsockopt_sol_tcp_defer(struct mptcp_sock *msk, sockptr_t optval,
0760                       unsigned int optlen)
0761 {
0762     struct socket *listener;
0763 
0764     listener = __mptcp_nmpc_socket(msk);
0765     if (!listener)
0766         return 0; /* TCP_DEFER_ACCEPT does not fail */
0767 
0768     return tcp_setsockopt(listener->sk, SOL_TCP, TCP_DEFER_ACCEPT, optval, optlen);
0769 }
0770 
0771 static int mptcp_setsockopt_sol_tcp(struct mptcp_sock *msk, int optname,
0772                     sockptr_t optval, unsigned int optlen)
0773 {
0774     struct sock *sk = (void *)msk;
0775     int ret, val;
0776 
0777     switch (optname) {
0778     case TCP_INQ:
0779         ret = mptcp_get_int_option(msk, optval, optlen, &val);
0780         if (ret)
0781             return ret;
0782         if (val < 0 || val > 1)
0783             return -EINVAL;
0784 
0785         lock_sock(sk);
0786         msk->recvmsg_inq = !!val;
0787         release_sock(sk);
0788         return 0;
0789     case TCP_ULP:
0790         return -EOPNOTSUPP;
0791     case TCP_CONGESTION:
0792         return mptcp_setsockopt_sol_tcp_congestion(msk, optval, optlen);
0793     case TCP_CORK:
0794         return mptcp_setsockopt_sol_tcp_cork(msk, optval, optlen);
0795     case TCP_NODELAY:
0796         return mptcp_setsockopt_sol_tcp_nodelay(msk, optval, optlen);
0797     case TCP_DEFER_ACCEPT:
0798         return mptcp_setsockopt_sol_tcp_defer(msk, optval, optlen);
0799     }
0800 
0801     return -EOPNOTSUPP;
0802 }
0803 
0804 int mptcp_setsockopt(struct sock *sk, int level, int optname,
0805              sockptr_t optval, unsigned int optlen)
0806 {
0807     struct mptcp_sock *msk = mptcp_sk(sk);
0808     struct sock *ssk;
0809 
0810     pr_debug("msk=%p", msk);
0811 
0812     if (level == SOL_SOCKET)
0813         return mptcp_setsockopt_sol_socket(msk, optname, optval, optlen);
0814 
0815     if (!mptcp_supported_sockopt(level, optname))
0816         return -ENOPROTOOPT;
0817 
0818     /* @@ the meaning of setsockopt() when the socket is connected and
0819      * there are multiple subflows is not yet defined. It is up to the
0820      * MPTCP-level socket to configure the subflows until the subflow
0821      * is in TCP fallback, when TCP socket options are passed through
0822      * to the one remaining subflow.
0823      */
0824     lock_sock(sk);
0825     ssk = __mptcp_tcp_fallback(msk);
0826     release_sock(sk);
0827     if (ssk)
0828         return tcp_setsockopt(ssk, level, optname, optval, optlen);
0829 
0830     if (level == SOL_IP)
0831         return mptcp_setsockopt_v4(msk, optname, optval, optlen);
0832 
0833     if (level == SOL_IPV6)
0834         return mptcp_setsockopt_v6(msk, optname, optval, optlen);
0835 
0836     if (level == SOL_TCP)
0837         return mptcp_setsockopt_sol_tcp(msk, optname, optval, optlen);
0838 
0839     return -EOPNOTSUPP;
0840 }
0841 
0842 static int mptcp_getsockopt_first_sf_only(struct mptcp_sock *msk, int level, int optname,
0843                       char __user *optval, int __user *optlen)
0844 {
0845     struct sock *sk = (struct sock *)msk;
0846     struct socket *ssock;
0847     int ret = -EINVAL;
0848     struct sock *ssk;
0849 
0850     lock_sock(sk);
0851     ssk = msk->first;
0852     if (ssk) {
0853         ret = tcp_getsockopt(ssk, level, optname, optval, optlen);
0854         goto out;
0855     }
0856 
0857     ssock = __mptcp_nmpc_socket(msk);
0858     if (!ssock)
0859         goto out;
0860 
0861     ret = tcp_getsockopt(ssock->sk, level, optname, optval, optlen);
0862 
0863 out:
0864     release_sock(sk);
0865     return ret;
0866 }
0867 
0868 void mptcp_diag_fill_info(struct mptcp_sock *msk, struct mptcp_info *info)
0869 {
0870     u32 flags = 0;
0871     u8 val;
0872 
0873     memset(info, 0, sizeof(*info));
0874 
0875     info->mptcpi_subflows = READ_ONCE(msk->pm.subflows);
0876     info->mptcpi_add_addr_signal = READ_ONCE(msk->pm.add_addr_signaled);
0877     info->mptcpi_add_addr_accepted = READ_ONCE(msk->pm.add_addr_accepted);
0878     info->mptcpi_local_addr_used = READ_ONCE(msk->pm.local_addr_used);
0879     info->mptcpi_subflows_max = mptcp_pm_get_subflows_max(msk);
0880     val = mptcp_pm_get_add_addr_signal_max(msk);
0881     info->mptcpi_add_addr_signal_max = val;
0882     val = mptcp_pm_get_add_addr_accept_max(msk);
0883     info->mptcpi_add_addr_accepted_max = val;
0884     info->mptcpi_local_addr_max = mptcp_pm_get_local_addr_max(msk);
0885     if (test_bit(MPTCP_FALLBACK_DONE, &msk->flags))
0886         flags |= MPTCP_INFO_FLAG_FALLBACK;
0887     if (READ_ONCE(msk->can_ack))
0888         flags |= MPTCP_INFO_FLAG_REMOTE_KEY_RECEIVED;
0889     info->mptcpi_flags = flags;
0890     info->mptcpi_token = READ_ONCE(msk->token);
0891     info->mptcpi_write_seq = READ_ONCE(msk->write_seq);
0892     info->mptcpi_snd_una = READ_ONCE(msk->snd_una);
0893     info->mptcpi_rcv_nxt = READ_ONCE(msk->ack_seq);
0894     info->mptcpi_csum_enabled = READ_ONCE(msk->csum_enabled);
0895 }
0896 EXPORT_SYMBOL_GPL(mptcp_diag_fill_info);
0897 
0898 static int mptcp_getsockopt_info(struct mptcp_sock *msk, char __user *optval, int __user *optlen)
0899 {
0900     struct mptcp_info m_info;
0901     int len;
0902 
0903     if (get_user(len, optlen))
0904         return -EFAULT;
0905 
0906     len = min_t(unsigned int, len, sizeof(struct mptcp_info));
0907 
0908     mptcp_diag_fill_info(msk, &m_info);
0909 
0910     if (put_user(len, optlen))
0911         return -EFAULT;
0912 
0913     if (copy_to_user(optval, &m_info, len))
0914         return -EFAULT;
0915 
0916     return 0;
0917 }
0918 
0919 static int mptcp_put_subflow_data(struct mptcp_subflow_data *sfd,
0920                   char __user *optval,
0921                   u32 copied,
0922                   int __user *optlen)
0923 {
0924     u32 copylen = min_t(u32, sfd->size_subflow_data, sizeof(*sfd));
0925 
0926     if (copied)
0927         copied += sfd->size_subflow_data;
0928     else
0929         copied = copylen;
0930 
0931     if (put_user(copied, optlen))
0932         return -EFAULT;
0933 
0934     if (copy_to_user(optval, sfd, copylen))
0935         return -EFAULT;
0936 
0937     return 0;
0938 }
0939 
0940 static int mptcp_get_subflow_data(struct mptcp_subflow_data *sfd,
0941                   char __user *optval, int __user *optlen)
0942 {
0943     int len, copylen;
0944 
0945     if (get_user(len, optlen))
0946         return -EFAULT;
0947 
0948     /* if mptcp_subflow_data size is changed, need to adjust
0949      * this function to deal with programs using old version.
0950      */
0951     BUILD_BUG_ON(sizeof(*sfd) != MIN_INFO_OPTLEN_SIZE);
0952 
0953     if (len < MIN_INFO_OPTLEN_SIZE)
0954         return -EINVAL;
0955 
0956     memset(sfd, 0, sizeof(*sfd));
0957 
0958     copylen = min_t(unsigned int, len, sizeof(*sfd));
0959     if (copy_from_user(sfd, optval, copylen))
0960         return -EFAULT;
0961 
0962     /* size_subflow_data is u32, but len is signed */
0963     if (sfd->size_subflow_data > INT_MAX ||
0964         sfd->size_user > INT_MAX)
0965         return -EINVAL;
0966 
0967     if (sfd->size_subflow_data < MIN_INFO_OPTLEN_SIZE ||
0968         sfd->size_subflow_data > len)
0969         return -EINVAL;
0970 
0971     if (sfd->num_subflows || sfd->size_kernel)
0972         return -EINVAL;
0973 
0974     return len - sfd->size_subflow_data;
0975 }
0976 
0977 static int mptcp_getsockopt_tcpinfo(struct mptcp_sock *msk, char __user *optval,
0978                     int __user *optlen)
0979 {
0980     struct mptcp_subflow_context *subflow;
0981     struct sock *sk = &msk->sk.icsk_inet.sk;
0982     unsigned int sfcount = 0, copied = 0;
0983     struct mptcp_subflow_data sfd;
0984     char __user *infoptr;
0985     int len;
0986 
0987     len = mptcp_get_subflow_data(&sfd, optval, optlen);
0988     if (len < 0)
0989         return len;
0990 
0991     sfd.size_kernel = sizeof(struct tcp_info);
0992     sfd.size_user = min_t(unsigned int, sfd.size_user,
0993                   sizeof(struct tcp_info));
0994 
0995     infoptr = optval + sfd.size_subflow_data;
0996 
0997     lock_sock(sk);
0998 
0999     mptcp_for_each_subflow(msk, subflow) {
1000         struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
1001 
1002         ++sfcount;
1003 
1004         if (len && len >= sfd.size_user) {
1005             struct tcp_info info;
1006 
1007             tcp_get_info(ssk, &info);
1008 
1009             if (copy_to_user(infoptr, &info, sfd.size_user)) {
1010                 release_sock(sk);
1011                 return -EFAULT;
1012             }
1013 
1014             infoptr += sfd.size_user;
1015             copied += sfd.size_user;
1016             len -= sfd.size_user;
1017         }
1018     }
1019 
1020     release_sock(sk);
1021 
1022     sfd.num_subflows = sfcount;
1023 
1024     if (mptcp_put_subflow_data(&sfd, optval, copied, optlen))
1025         return -EFAULT;
1026 
1027     return 0;
1028 }
1029 
1030 static void mptcp_get_sub_addrs(const struct sock *sk, struct mptcp_subflow_addrs *a)
1031 {
1032     struct inet_sock *inet = inet_sk(sk);
1033 
1034     memset(a, 0, sizeof(*a));
1035 
1036     if (sk->sk_family == AF_INET) {
1037         a->sin_local.sin_family = AF_INET;
1038         a->sin_local.sin_port = inet->inet_sport;
1039         a->sin_local.sin_addr.s_addr = inet->inet_rcv_saddr;
1040 
1041         if (!a->sin_local.sin_addr.s_addr)
1042             a->sin_local.sin_addr.s_addr = inet->inet_saddr;
1043 
1044         a->sin_remote.sin_family = AF_INET;
1045         a->sin_remote.sin_port = inet->inet_dport;
1046         a->sin_remote.sin_addr.s_addr = inet->inet_daddr;
1047 #if IS_ENABLED(CONFIG_IPV6)
1048     } else if (sk->sk_family == AF_INET6) {
1049         const struct ipv6_pinfo *np = inet6_sk(sk);
1050 
1051         if (WARN_ON_ONCE(!np))
1052             return;
1053 
1054         a->sin6_local.sin6_family = AF_INET6;
1055         a->sin6_local.sin6_port = inet->inet_sport;
1056 
1057         if (ipv6_addr_any(&sk->sk_v6_rcv_saddr))
1058             a->sin6_local.sin6_addr = np->saddr;
1059         else
1060             a->sin6_local.sin6_addr = sk->sk_v6_rcv_saddr;
1061 
1062         a->sin6_remote.sin6_family = AF_INET6;
1063         a->sin6_remote.sin6_port = inet->inet_dport;
1064         a->sin6_remote.sin6_addr = sk->sk_v6_daddr;
1065 #endif
1066     }
1067 }
1068 
1069 static int mptcp_getsockopt_subflow_addrs(struct mptcp_sock *msk, char __user *optval,
1070                       int __user *optlen)
1071 {
1072     struct sock *sk = &msk->sk.icsk_inet.sk;
1073     struct mptcp_subflow_context *subflow;
1074     unsigned int sfcount = 0, copied = 0;
1075     struct mptcp_subflow_data sfd;
1076     char __user *addrptr;
1077     int len;
1078 
1079     len = mptcp_get_subflow_data(&sfd, optval, optlen);
1080     if (len < 0)
1081         return len;
1082 
1083     sfd.size_kernel = sizeof(struct mptcp_subflow_addrs);
1084     sfd.size_user = min_t(unsigned int, sfd.size_user,
1085                   sizeof(struct mptcp_subflow_addrs));
1086 
1087     addrptr = optval + sfd.size_subflow_data;
1088 
1089     lock_sock(sk);
1090 
1091     mptcp_for_each_subflow(msk, subflow) {
1092         struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
1093 
1094         ++sfcount;
1095 
1096         if (len && len >= sfd.size_user) {
1097             struct mptcp_subflow_addrs a;
1098 
1099             mptcp_get_sub_addrs(ssk, &a);
1100 
1101             if (copy_to_user(addrptr, &a, sfd.size_user)) {
1102                 release_sock(sk);
1103                 return -EFAULT;
1104             }
1105 
1106             addrptr += sfd.size_user;
1107             copied += sfd.size_user;
1108             len -= sfd.size_user;
1109         }
1110     }
1111 
1112     release_sock(sk);
1113 
1114     sfd.num_subflows = sfcount;
1115 
1116     if (mptcp_put_subflow_data(&sfd, optval, copied, optlen))
1117         return -EFAULT;
1118 
1119     return 0;
1120 }
1121 
1122 static int mptcp_put_int_option(struct mptcp_sock *msk, char __user *optval,
1123                 int __user *optlen, int val)
1124 {
1125     int len;
1126 
1127     if (get_user(len, optlen))
1128         return -EFAULT;
1129     if (len < 0)
1130         return -EINVAL;
1131 
1132     if (len < sizeof(int) && len > 0 && val >= 0 && val <= 255) {
1133         unsigned char ucval = (unsigned char)val;
1134 
1135         len = 1;
1136         if (put_user(len, optlen))
1137             return -EFAULT;
1138         if (copy_to_user(optval, &ucval, 1))
1139             return -EFAULT;
1140     } else {
1141         len = min_t(unsigned int, len, sizeof(int));
1142         if (put_user(len, optlen))
1143             return -EFAULT;
1144         if (copy_to_user(optval, &val, len))
1145             return -EFAULT;
1146     }
1147 
1148     return 0;
1149 }
1150 
1151 static int mptcp_getsockopt_sol_tcp(struct mptcp_sock *msk, int optname,
1152                     char __user *optval, int __user *optlen)
1153 {
1154     switch (optname) {
1155     case TCP_ULP:
1156     case TCP_CONGESTION:
1157     case TCP_INFO:
1158     case TCP_CC_INFO:
1159     case TCP_DEFER_ACCEPT:
1160         return mptcp_getsockopt_first_sf_only(msk, SOL_TCP, optname,
1161                               optval, optlen);
1162     case TCP_INQ:
1163         return mptcp_put_int_option(msk, optval, optlen, msk->recvmsg_inq);
1164     case TCP_CORK:
1165         return mptcp_put_int_option(msk, optval, optlen, msk->cork);
1166     case TCP_NODELAY:
1167         return mptcp_put_int_option(msk, optval, optlen, msk->nodelay);
1168     }
1169     return -EOPNOTSUPP;
1170 }
1171 
1172 static int mptcp_getsockopt_v4(struct mptcp_sock *msk, int optname,
1173                    char __user *optval, int __user *optlen)
1174 {
1175     struct sock *sk = (void *)msk;
1176 
1177     switch (optname) {
1178     case IP_TOS:
1179         return mptcp_put_int_option(msk, optval, optlen, inet_sk(sk)->tos);
1180     }
1181 
1182     return -EOPNOTSUPP;
1183 }
1184 
1185 static int mptcp_getsockopt_sol_mptcp(struct mptcp_sock *msk, int optname,
1186                       char __user *optval, int __user *optlen)
1187 {
1188     switch (optname) {
1189     case MPTCP_INFO:
1190         return mptcp_getsockopt_info(msk, optval, optlen);
1191     case MPTCP_TCPINFO:
1192         return mptcp_getsockopt_tcpinfo(msk, optval, optlen);
1193     case MPTCP_SUBFLOW_ADDRS:
1194         return mptcp_getsockopt_subflow_addrs(msk, optval, optlen);
1195     }
1196 
1197     return -EOPNOTSUPP;
1198 }
1199 
1200 int mptcp_getsockopt(struct sock *sk, int level, int optname,
1201              char __user *optval, int __user *option)
1202 {
1203     struct mptcp_sock *msk = mptcp_sk(sk);
1204     struct sock *ssk;
1205 
1206     pr_debug("msk=%p", msk);
1207 
1208     /* @@ the meaning of setsockopt() when the socket is connected and
1209      * there are multiple subflows is not yet defined. It is up to the
1210      * MPTCP-level socket to configure the subflows until the subflow
1211      * is in TCP fallback, when socket options are passed through
1212      * to the one remaining subflow.
1213      */
1214     lock_sock(sk);
1215     ssk = __mptcp_tcp_fallback(msk);
1216     release_sock(sk);
1217     if (ssk)
1218         return tcp_getsockopt(ssk, level, optname, optval, option);
1219 
1220     if (level == SOL_IP)
1221         return mptcp_getsockopt_v4(msk, optname, optval, option);
1222     if (level == SOL_TCP)
1223         return mptcp_getsockopt_sol_tcp(msk, optname, optval, option);
1224     if (level == SOL_MPTCP)
1225         return mptcp_getsockopt_sol_mptcp(msk, optname, optval, option);
1226     return -EOPNOTSUPP;
1227 }
1228 
1229 static void sync_socket_options(struct mptcp_sock *msk, struct sock *ssk)
1230 {
1231     static const unsigned int tx_rx_locks = SOCK_RCVBUF_LOCK | SOCK_SNDBUF_LOCK;
1232     struct sock *sk = (struct sock *)msk;
1233 
1234     if (ssk->sk_prot->keepalive) {
1235         if (sock_flag(sk, SOCK_KEEPOPEN))
1236             ssk->sk_prot->keepalive(ssk, 1);
1237         else
1238             ssk->sk_prot->keepalive(ssk, 0);
1239     }
1240 
1241     ssk->sk_priority = sk->sk_priority;
1242     ssk->sk_bound_dev_if = sk->sk_bound_dev_if;
1243     ssk->sk_incoming_cpu = sk->sk_incoming_cpu;
1244     __ip_sock_set_tos(ssk, inet_sk(sk)->tos);
1245 
1246     if (sk->sk_userlocks & tx_rx_locks) {
1247         ssk->sk_userlocks |= sk->sk_userlocks & tx_rx_locks;
1248         if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
1249             WRITE_ONCE(ssk->sk_sndbuf, sk->sk_sndbuf);
1250         if (sk->sk_userlocks & SOCK_RCVBUF_LOCK)
1251             WRITE_ONCE(ssk->sk_rcvbuf, sk->sk_rcvbuf);
1252     }
1253 
1254     if (sock_flag(sk, SOCK_LINGER)) {
1255         ssk->sk_lingertime = sk->sk_lingertime;
1256         sock_set_flag(ssk, SOCK_LINGER);
1257     } else {
1258         sock_reset_flag(ssk, SOCK_LINGER);
1259     }
1260 
1261     if (sk->sk_mark != ssk->sk_mark) {
1262         ssk->sk_mark = sk->sk_mark;
1263         sk_dst_reset(ssk);
1264     }
1265 
1266     sock_valbool_flag(ssk, SOCK_DBG, sock_flag(sk, SOCK_DBG));
1267 
1268     if (inet_csk(sk)->icsk_ca_ops != inet_csk(ssk)->icsk_ca_ops)
1269         tcp_set_congestion_control(ssk, msk->ca_name, false, true);
1270     __tcp_sock_set_cork(ssk, !!msk->cork);
1271     __tcp_sock_set_nodelay(ssk, !!msk->nodelay);
1272 
1273     inet_sk(ssk)->transparent = inet_sk(sk)->transparent;
1274     inet_sk(ssk)->freebind = inet_sk(sk)->freebind;
1275 }
1276 
1277 static void __mptcp_sockopt_sync(struct mptcp_sock *msk, struct sock *ssk)
1278 {
1279     bool slow = lock_sock_fast(ssk);
1280 
1281     sync_socket_options(msk, ssk);
1282 
1283     unlock_sock_fast(ssk, slow);
1284 }
1285 
1286 void mptcp_sockopt_sync(struct mptcp_sock *msk, struct sock *ssk)
1287 {
1288     struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
1289 
1290     msk_owned_by_me(msk);
1291 
1292     if (READ_ONCE(subflow->setsockopt_seq) != msk->setsockopt_seq) {
1293         __mptcp_sockopt_sync(msk, ssk);
1294 
1295         subflow->setsockopt_seq = msk->setsockopt_seq;
1296     }
1297 }
1298 
1299 void mptcp_sockopt_sync_locked(struct mptcp_sock *msk, struct sock *ssk)
1300 {
1301     struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
1302 
1303     msk_owned_by_me(msk);
1304 
1305     if (READ_ONCE(subflow->setsockopt_seq) != msk->setsockopt_seq) {
1306         sync_socket_options(msk, ssk);
1307 
1308         subflow->setsockopt_seq = msk->setsockopt_seq;
1309     }
1310 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!