lnet/lnet/lib-socket.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2015, 2017, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  */
  32 #define DEBUG_SUBSYSTEM S_LNET
  33
  34 #include <linux/if.h>
  35 #include <linux/in.h>
  36 #include <linux/net.h>
  37 #include <net/addrconf.h>
  38 #include <net/ipv6.h>
  39 #include <linux/file.h>
  40 #include <linux/pagemap.h>
  41 /* For sys_open & sys_close */
  42 #include <linux/syscalls.h>
  43 #include <net/sock.h>
  44 #include <linux/inetdevice.h>
  45
  46 #include <libcfs/linux/linux-time.h>
  47 #include <libcfs/linux/linux-net.h>
  48 #include <libcfs/libcfs.h>
  49 #include <lnet/lib-lnet.h>
  50
  51 int
  52 lnet_sock_write(struct socket *sock, void *buffer, int nob, int timeout)
  53 {
  54         int rc;
  55         long jiffies_left = cfs_time_seconds(timeout);
  56         unsigned long then;
  57
  58         LASSERT(nob > 0);
  59         /* Caller may pass a zero timeout if she thinks the socket buffer is
  60          * empty enough to take the whole message immediately */
  61
  62         for (;;) {
  63                 struct kvec  iov = {
  64                         .iov_base = buffer,
  65                         .iov_len  = nob
  66                 };
  67                 struct msghdr msg = {
  68                         .msg_flags      = (timeout == 0) ? MSG_DONTWAIT : 0
  69                 };
  70
  71                 if (timeout != 0) {
  72                         struct sock *sk = sock->sk;
  73
  74                         /* Set send timeout to remaining time */
  75                         lock_sock(sk);
  76                         sk->sk_sndtimeo = jiffies_left;
  77                         release_sock(sk);
  78                 }
  79
  80                 then = jiffies;
  81                 rc = kernel_sendmsg(sock, &msg, &iov, 1, nob);
  82                 jiffies_left -= jiffies - then;
  83
  84                 if (rc == nob)
  85                         return 0;
  86
  87                 if (rc < 0)
  88                         return rc;
  89
  90                 if (rc == 0) {
  91                         CERROR("Unexpected zero rc\n");
  92                         return -ECONNABORTED;
  93                 }
  94
  95                 if (jiffies_left <= 0)
  96                         return -EAGAIN;
  97
  98                 buffer = ((char *)buffer) + rc;
  99                 nob -= rc;
 100         }
 101         return 0;
 102 }
 103 EXPORT_SYMBOL(lnet_sock_write);
 104
 105 int
 106 lnet_sock_read(struct socket *sock, void *buffer, int nob, int timeout)
 107 {
 108         int rc;
 109         long jiffies_left = cfs_time_seconds(timeout);
 110         unsigned long then;
 111
 112         LASSERT(nob > 0);
 113         LASSERT(jiffies_left > 0);
 114
 115         for (;;) {
 116                 struct kvec  iov = {
 117                         .iov_base = buffer,
 118                         .iov_len  = nob
 119                 };
 120                 struct msghdr msg = {
 121                         .msg_flags      = 0
 122                 };
 123                 struct sock *sk = sock->sk;
 124
 125                 /* Set receive timeout to remaining time */
 126                 lock_sock(sk);
 127                 sk->sk_rcvtimeo = jiffies_left;
 128                 release_sock(sk);
 129
 130                 then = jiffies;
 131                 rc = kernel_recvmsg(sock, &msg, &iov, 1, nob, 0);
 132                 jiffies_left -= jiffies - then;
 133
 134                 if (rc < 0)
 135                         return rc;
 136
 137                 if (rc == 0)
 138                         return -ECONNRESET;
 139
 140                 buffer = ((char *)buffer) + rc;
 141                 nob -= rc;
 142
 143                 if (nob == 0)
 144                         return 0;
 145
 146                 if (jiffies_left <= 0)
 147                         return -ETIMEDOUT;
 148         }
 149 }
 150 EXPORT_SYMBOL(lnet_sock_read);
 151
 152 int choose_ipv4_src(__u32 *ret, int interface, __u32 dst_ipaddr, struct net *ns)
 153 {
 154         struct net_device *dev;
 155         struct in_device *in_dev;
 156         int err;
 157         DECLARE_CONST_IN_IFADDR(ifa);
 158
 159         rcu_read_lock();
 160         dev = dev_get_by_index_rcu(ns, interface);
 161         err = -EINVAL;
 162         if (!dev || !(dev->flags & IFF_UP))
 163                 goto out;
 164         in_dev = __in_dev_get_rcu(dev);
 165         if (!in_dev)
 166                 goto out;
 167         err = -ENOENT;
 168         in_dev_for_each_ifa_rcu(ifa, in_dev) {
 169                 if (err ||
 170                     ((dst_ipaddr ^ ntohl(ifa->ifa_local))
 171                      & ntohl(ifa->ifa_mask)) == 0) {
 172                         /* This address at least as good as what we
 173                          * already have
 174                          */
 175                         *ret = ntohl(ifa->ifa_local);
 176                         err = 0;
 177                 }
 178         }
 179         endfor_ifa(in_dev);
 180 out:
 181         rcu_read_unlock();
 182         return err;
 183 }
 184 EXPORT_SYMBOL(choose_ipv4_src);
 185
 186 static struct socket *
 187 lnet_sock_create(int interface, struct sockaddr *remaddr,
 188                  int local_port, struct net *ns)
 189 {
 190         struct socket *sock;
 191         int rc;
 192         int family;
 193
 194         family = AF_INET6;
 195         if (remaddr)
 196                 family = remaddr->sa_family;
 197 #ifdef HAVE_SOCK_CREATE_KERN_USE_NET
 198         rc = sock_create_kern(ns, family, SOCK_STREAM, 0, &sock);
 199 #else
 200         rc = sock_create_kern(family, SOCK_STREAM, 0, &sock);
 201 #endif
 202         if (rc) {
 203                 CERROR("Can't create socket: %d\n", rc);
 204                 return ERR_PTR(rc);
 205         }
 206
 207         sock->sk->sk_reuseport = 1;
 208
 209         if (interface >= 0 || local_port != 0) {
 210                 struct sockaddr_storage locaddr = {};
 211                 struct sockaddr_in *sin = (void *)&locaddr;
 212                 struct sockaddr_in6 *sin6 = (void *)&locaddr;
 213
 214                 switch (family) {
 215                 case AF_INET:
 216                         sin->sin_family = AF_INET;
 217                         sin->sin_addr.s_addr = INADDR_ANY;
 218                         if (interface >= 0 && remaddr) {
 219                                 struct sockaddr_in *rem = (void *)remaddr;
 220                                 __u32 ip;
 221
 222                                 rc = choose_ipv4_src(&ip,
 223                                                      interface,
 224                                                      ntohl(rem->sin_addr.s_addr),
 225                                                      ns);
 226                                 if (rc)
 227                                         goto failed;
 228                                 sin->sin_addr.s_addr = htonl(ip);
 229                         }
 230                         sin->sin_port = htons(local_port);
 231                         break;
 232                 case AF_INET6:
 233                         sin6->sin6_family = AF_INET6;
 234                         sin6->sin6_addr = in6addr_any;
 235                         if (interface >= 0 && remaddr) {
 236                                 struct sockaddr_in6 *rem = (void *)remaddr;
 237
 238                                 ipv6_dev_get_saddr(ns,
 239                                                    dev_get_by_index(ns,
 240                                                                     interface),
 241                                                    &rem->sin6_addr, 0,
 242                                                    &sin6->sin6_addr);
 243                         }
 244                         sin6->sin6_port = htons(local_port);
 245                         break;
 246                 }
 247                 rc = kernel_bind(sock, (struct sockaddr *)&locaddr,
 248                                  sizeof(locaddr));
 249                 if (rc == -EADDRINUSE) {
 250                         CDEBUG(D_NET, "Port %d already in use\n", local_port);
 251                         goto failed;
 252                 }
 253                 if (rc != 0) {
 254                         CERROR("Error trying to bind to port %d: %d\n",
 255                                local_port, rc);
 256                         goto failed;
 257                 }
 258         }
 259         return sock;
 260
 261 failed:
 262         sock_release(sock);
 263         return ERR_PTR(rc);
 264 }
 265
 266 void
 267 lnet_sock_setbuf(struct socket *sock, int txbufsize, int rxbufsize)
 268 {
 269         struct sock *sk = sock->sk;
 270
 271         if (txbufsize != 0) {
 272                 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
 273                 sk->sk_sndbuf = txbufsize;
 274                 sk->sk_write_space(sk);
 275         }
 276
 277         if (rxbufsize != 0) {
 278                 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
 279                 sk->sk_sndbuf = rxbufsize;
 280         }
 281 }
 282 EXPORT_SYMBOL(lnet_sock_setbuf);
 283
 284 int
 285 lnet_sock_getaddr(struct socket *sock, bool remote,
 286                   struct sockaddr_storage *peer)
 287 {
 288         int rc;
 289 #ifndef HAVE_KERN_SOCK_GETNAME_2ARGS
 290         int len = sizeof(*peer);
 291 #endif
 292
 293         if (remote)
 294                 rc = lnet_kernel_getpeername(sock,
 295                                              (struct sockaddr *)peer, &len);
 296         else
 297                 rc = lnet_kernel_getsockname(sock,
 298                                              (struct sockaddr *)peer, &len);
 299         if (rc < 0) {
 300                 CERROR("Error %d getting sock %s IP/port\n",
 301                         rc, remote ? "peer" : "local");
 302                 return rc;
 303         }
 304         if (peer->ss_family == AF_INET6) {
 305                 struct sockaddr_in6 *in6 = (void *)peer;
 306                 struct sockaddr_in *in = (void *)peer;
 307                 short port = in6->sin6_port;
 308
 309                 if (ipv6_addr_v4mapped(&in6->sin6_addr)) {
 310                         /* Pretend it is a v4 socket */
 311                         memset(in, 0, sizeof(*in));
 312                         in->sin_family = AF_INET;
 313                         in->sin_port = port;
 314                         memcpy(&in->sin_addr, &in6->sin6_addr.s6_addr32[3], 4);
 315                 }
 316         }
 317         return 0;
 318 }
 319 EXPORT_SYMBOL(lnet_sock_getaddr);
 320
 321 void lnet_sock_getbuf(struct socket *sock, int *txbufsize, int *rxbufsize)
 322 {
 323         if (txbufsize != NULL)
 324                 *txbufsize = sock->sk->sk_sndbuf;
 325
 326         if (rxbufsize != NULL)
 327                 *rxbufsize = sock->sk->sk_rcvbuf;
 328 }
 329 EXPORT_SYMBOL(lnet_sock_getbuf);
 330
 331 struct socket *
 332 lnet_sock_listen(int local_port, int backlog, struct net *ns)
 333 {
 334         struct socket *sock;
 335         int val = 0;
 336         int rc;
 337
 338         sock = lnet_sock_create(-1, NULL, local_port, ns);
 339         if (IS_ERR(sock)) {
 340                 rc = PTR_ERR(sock);
 341                 if (rc == -EADDRINUSE)
 342                         CERROR("Can't create socket: port %d already in use\n",
 343                                local_port);
 344                 return ERR_PTR(rc);
 345         }
 346
 347         /* Make sure we get both IPv4 and IPv6 connections.
 348          * This is the default, but it can be overridden so
 349          * we force it back.
 350          */
 351         kernel_setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
 352                           (char *) &val, sizeof(val));
 353
 354         rc = kernel_listen(sock, backlog);
 355         if (rc == 0)
 356                 return sock;
 357
 358         CERROR("Can't set listen backlog %d: %d\n", backlog, rc);
 359         sock_release(sock);
 360         return ERR_PTR(rc);
 361 }
 362
 363 struct socket *
 364 lnet_sock_connect(int interface, int local_port,
 365                   struct sockaddr *peeraddr,
 366                   struct net *ns)
 367 {
 368         struct socket *sock;
 369         int rc;
 370
 371         sock = lnet_sock_create(interface, peeraddr, local_port, ns);
 372         if (IS_ERR(sock))
 373                 return sock;
 374
 375         rc = kernel_connect(sock, peeraddr, sizeof(struct sockaddr_in6), 0);
 376         if (rc == 0)
 377                 return sock;
 378
 379         /* EADDRNOTAVAIL probably means we're already connected to the same
 380          * peer/port on the same local port on a differently typed
 381          * connection.  Let our caller retry with a different local
 382          * port... */
 383
 384         CDEBUG_LIMIT(rc == -EADDRNOTAVAIL ? D_NET : D_NETERROR,
 385                      "Error %d connecting %d -> %pISp\n", rc,
 386                      local_port, peeraddr);
 387
 388         sock_release(sock);
 389         return ERR_PTR(rc);
 390 }