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 <linux/file.h>
  38 #include <linux/pagemap.h>
  39 /* For sys_open & sys_close */
  40 #include <linux/syscalls.h>
  41 #include <net/sock.h>
  42
  43 #include <libcfs/libcfs.h>
  44 #include <lnet/lib-lnet.h>
  45
  46 static int
  47 lnet_sock_ioctl(int cmd, unsigned long arg)
  48 {
  49         struct socket *sock;
  50         int rc;
  51
  52 #ifdef HAVE_SOCK_CREATE_KERN_USE_NET
  53         rc = sock_create_kern(&init_net, PF_INET, SOCK_STREAM, 0, &sock);
  54 #else
  55         rc = sock_create_kern(PF_INET, SOCK_STREAM, 0, &sock);
  56 #endif
  57         if (rc != 0) {
  58                 CERROR("Can't create socket: %d\n", rc);
  59                 return rc;
  60         }
  61
  62         if (cmd == SIOCGIFFLAGS) {
  63                 /* This cmd is used only to get IFF_UP flag */
  64                 struct ifreq *ifr = (struct ifreq *) arg;
  65                 struct net_device *dev;
  66
  67                 dev = dev_get_by_name(sock_net(sock->sk), ifr->ifr_name);
  68                 if (dev) {
  69                         ifr->ifr_flags = dev->flags;
  70                         dev_put(dev);
  71                         rc = 0;
  72                 } else {
  73                         rc = -ENODEV;
  74                 }
  75         } else {
  76                 rc = kernel_sock_ioctl(sock, cmd, arg);
  77         }
  78         sock_release(sock);
  79
  80         return rc;
  81 }
  82
  83 int
  84 lnet_ipif_query(char *name, int *up, __u32 *ip, __u32 *mask)
  85 {
  86         struct ifreq    ifr;
  87         int             nob;
  88         int             rc;
  89         __u32           val;
  90
  91         nob = strnlen(name, IFNAMSIZ);
  92         if (nob == IFNAMSIZ) {
  93                 CERROR("Interface name %s too long\n", name);
  94                 return -EINVAL;
  95         }
  96
  97         CLASSERT(sizeof(ifr.ifr_name) >= IFNAMSIZ);
  98
  99         if (strlen(name) > sizeof(ifr.ifr_name)-1)
 100                 return -E2BIG;
 101         strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
 102
 103         rc = lnet_sock_ioctl(SIOCGIFFLAGS, (unsigned long)&ifr);
 104         if (rc != 0) {
 105                 CERROR("Can't get flags for interface %s\n", name);
 106                 return rc;
 107         }
 108
 109         if ((ifr.ifr_flags & IFF_UP) == 0) {
 110                 CDEBUG(D_NET, "Interface %s down\n", name);
 111                 *up = 0;
 112                 *ip = *mask = 0;
 113                 return 0;
 114         }
 115         *up = 1;
 116
 117         if (strlen(name) > sizeof(ifr.ifr_name)-1)
 118                 return -E2BIG;
 119         strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
 120
 121         ifr.ifr_addr.sa_family = AF_INET;
 122         rc = lnet_sock_ioctl(SIOCGIFADDR, (unsigned long)&ifr);
 123
 124         if (rc != 0) {
 125                 CERROR("Can't get IP address for interface %s\n", name);
 126                 return rc;
 127         }
 128
 129         val = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr;
 130         *ip = ntohl(val);
 131
 132         if (strlen(name) > sizeof(ifr.ifr_name)-1)
 133                 return -E2BIG;
 134         strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
 135
 136         ifr.ifr_addr.sa_family = AF_INET;
 137         rc = lnet_sock_ioctl(SIOCGIFNETMASK, (unsigned long)&ifr);
 138         if (rc != 0) {
 139                 CERROR("Can't get netmask for interface %s\n", name);
 140                 return rc;
 141         }
 142
 143         val = ((struct sockaddr_in *)&ifr.ifr_netmask)->sin_addr.s_addr;
 144         *mask = ntohl(val);
 145
 146         return 0;
 147 }
 148 EXPORT_SYMBOL(lnet_ipif_query);
 149
 150 void
 151 lnet_ipif_free_enumeration(char **names, int n)
 152 {
 153         int     i;
 154
 155         LASSERT(n > 0);
 156
 157         for (i = 0; i < n && names[i] != NULL; i++)
 158                 LIBCFS_FREE(names[i], IFNAMSIZ);
 159
 160         LIBCFS_FREE(names, n * sizeof(*names));
 161 }
 162 EXPORT_SYMBOL(lnet_ipif_free_enumeration);
 163
 164 int
 165 lnet_ipif_enumerate(char ***namesp)
 166 {
 167         /* Allocate and fill in 'names', returning # interfaces/error */
 168         struct net_device *dev;
 169         struct socket *sock;
 170         char **names;
 171         int toobig;
 172         int nalloc;
 173         int nfound;
 174         int rc;
 175         int nob;
 176         int i;
 177
 178         nalloc = 16;    /* first guess at max interfaces */
 179         toobig = 0;
 180         nfound = 0;
 181
 182 #ifdef HAVE_SOCK_CREATE_KERN_USE_NET
 183         rc = sock_create_kern(&init_net, PF_INET, SOCK_STREAM, 0, &sock);
 184 #else
 185         rc = sock_create_kern(PF_INET, SOCK_STREAM, 0, &sock);
 186 #endif
 187         if (rc) {
 188                 CERROR("Can't create socket: %d\n", rc);
 189                 return rc;
 190         }
 191
 192         for_each_netdev(sock_net(sock->sk), dev)
 193                 nfound++;
 194
 195         if (nfound == 0)
 196                 goto out_release_sock;
 197
 198         LIBCFS_ALLOC(names, nfound * sizeof(*names));
 199         if (names == NULL) {
 200                 rc = -ENOMEM;
 201                 goto out_release_sock;
 202         }
 203
 204         i = 0;
 205         for_each_netdev(sock_net(sock->sk), dev) {
 206                 nob = strnlen(dev->name, IFNAMSIZ);
 207                 if (nob == IFNAMSIZ) {
 208                         /* no space for terminating NULL */
 209                         CERROR("interface name %.*s too long (%d max)\n",
 210                                nob, dev->name, IFNAMSIZ);
 211                         rc = -ENAMETOOLONG;
 212                         goto out_free_names;
 213                 }
 214
 215                 LIBCFS_ALLOC(names[i], IFNAMSIZ);
 216                 if (!names[i]) {
 217                         rc = -ENOMEM;
 218                         goto out_free_names;
 219                 }
 220
 221                 memcpy(names[i], dev->name, nob);
 222                 names[i][nob] = 0;
 223                 i++;
 224         }
 225
 226         *namesp = names;
 227         rc = i;
 228
 229 out_free_names:
 230         if (rc < 0)
 231                 lnet_ipif_free_enumeration(names, nfound);
 232 out_release_sock:
 233         sock_release(sock);
 234         return rc;
 235 }
 236 EXPORT_SYMBOL(lnet_ipif_enumerate);
 237
 238 int
 239 lnet_sock_write(struct socket *sock, void *buffer, int nob, int timeout)
 240 {
 241         int             rc;
 242         long            jiffies_left = timeout * msecs_to_jiffies(MSEC_PER_SEC);
 243         unsigned long   then;
 244         struct timeval  tv;
 245
 246         LASSERT(nob > 0);
 247         /* Caller may pass a zero timeout if she thinks the socket buffer is
 248          * empty enough to take the whole message immediately */
 249
 250         for (;;) {
 251                 struct kvec  iov = {
 252                         .iov_base = buffer,
 253                         .iov_len  = nob
 254                 };
 255                 struct msghdr msg = {
 256                         .msg_flags      = (timeout == 0) ? MSG_DONTWAIT : 0
 257                 };
 258
 259                 if (timeout != 0) {
 260                         /* Set send timeout to remaining time */
 261                         tv = (struct timeval) {
 262                                 .tv_sec = jiffies_left /
 263                                           msecs_to_jiffies(MSEC_PER_SEC),
 264                                 .tv_usec = ((jiffies_left %
 265                                              msecs_to_jiffies(MSEC_PER_SEC)) *
 266                                              USEC_PER_SEC) /
 267                                              msecs_to_jiffies(MSEC_PER_SEC)
 268                         };
 269
 270                         rc = kernel_setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO,
 271                                                (char *)&tv, sizeof(tv));
 272                         if (rc != 0) {
 273                                 CERROR("Can't set socket send timeout "
 274                                        "%ld.%06d: %d\n",
 275                                        (long)tv.tv_sec, (int)tv.tv_usec, rc);
 276                                 return rc;
 277                         }
 278                 }
 279
 280                 then = jiffies;
 281                 rc = kernel_sendmsg(sock, &msg, &iov, 1, nob);
 282                 jiffies_left -= jiffies - then;
 283
 284                 if (rc == nob)
 285                         return 0;
 286
 287                 if (rc < 0)
 288                         return rc;
 289
 290                 if (rc == 0) {
 291                         CERROR("Unexpected zero rc\n");
 292                         return -ECONNABORTED;
 293                 }
 294
 295                 if (jiffies_left <= 0)
 296                         return -EAGAIN;
 297
 298                 buffer = ((char *)buffer) + rc;
 299                 nob -= rc;
 300         }
 301         return 0;
 302 }
 303 EXPORT_SYMBOL(lnet_sock_write);
 304
 305 int
 306 lnet_sock_read(struct socket *sock, void *buffer, int nob, int timeout)
 307 {
 308         int             rc;
 309         long            jiffies_left = timeout * msecs_to_jiffies(MSEC_PER_SEC);
 310         unsigned long   then;
 311         struct timeval  tv;
 312
 313         LASSERT(nob > 0);
 314         LASSERT(jiffies_left > 0);
 315
 316         for (;;) {
 317                 struct kvec  iov = {
 318                         .iov_base = buffer,
 319                         .iov_len  = nob
 320                 };
 321                 struct msghdr msg = {
 322                         .msg_flags      = 0
 323                 };
 324
 325                 /* Set receive timeout to remaining time */
 326                 tv = (struct timeval) {
 327                         .tv_sec = jiffies_left / msecs_to_jiffies(MSEC_PER_SEC),
 328                         .tv_usec = ((jiffies_left %
 329                                         msecs_to_jiffies(MSEC_PER_SEC)) *
 330                                         USEC_PER_SEC) /
 331                                         msecs_to_jiffies(MSEC_PER_SEC)
 332                 };
 333                 rc = kernel_setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,
 334                                        (char *)&tv, sizeof(tv));
 335                 if (rc != 0) {
 336                         CERROR("Can't set socket recv timeout %ld.%06d: %d\n",
 337                                (long)tv.tv_sec, (int)tv.tv_usec, rc);
 338                         return rc;
 339                 }
 340
 341                 then = jiffies;
 342                 rc = kernel_recvmsg(sock, &msg, &iov, 1, nob, 0);
 343                 jiffies_left -= jiffies - then;
 344
 345                 if (rc < 0)
 346                         return rc;
 347
 348                 if (rc == 0)
 349                         return -ECONNRESET;
 350
 351                 buffer = ((char *)buffer) + rc;
 352                 nob -= rc;
 353
 354                 if (nob == 0)
 355                         return 0;
 356
 357                 if (jiffies_left <= 0)
 358                         return -ETIMEDOUT;
 359         }
 360 }
 361 EXPORT_SYMBOL(lnet_sock_read);
 362
 363 static int
 364 lnet_sock_create(struct socket **sockp, int *fatal,
 365                  __u32 local_ip, int local_port)
 366 {
 367         struct sockaddr_in  locaddr;
 368         struct socket      *sock;
 369         int                 rc;
 370         int                 option;
 371
 372         /* All errors are fatal except bind failure if the port is in use */
 373         *fatal = 1;
 374
 375 #ifdef HAVE_SOCK_CREATE_KERN_USE_NET
 376         rc = sock_create_kern(&init_net, PF_INET, SOCK_STREAM, 0, &sock);
 377 #else
 378         rc = sock_create_kern(PF_INET, SOCK_STREAM, 0, &sock);
 379 #endif
 380         *sockp = sock;
 381         if (rc != 0) {
 382                 CERROR("Can't create socket: %d\n", rc);
 383                 return rc;
 384         }
 385
 386         option = 1;
 387         rc = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
 388                                (char *)&option, sizeof(option));
 389         if (rc != 0) {
 390                 CERROR("Can't set SO_REUSEADDR for socket: %d\n", rc);
 391                 goto failed;
 392         }
 393
 394         if (local_ip != 0 || local_port != 0) {
 395                 memset(&locaddr, 0, sizeof(locaddr));
 396                 locaddr.sin_family = AF_INET;
 397                 locaddr.sin_port = htons(local_port);
 398                 locaddr.sin_addr.s_addr = (local_ip == 0) ?
 399                                           INADDR_ANY : htonl(local_ip);
 400
 401                 rc = kernel_bind(sock, (struct sockaddr *)&locaddr,
 402                                  sizeof(locaddr));
 403                 if (rc == -EADDRINUSE) {
 404                         CDEBUG(D_NET, "Port %d already in use\n", local_port);
 405                         *fatal = 0;
 406                         goto failed;
 407                 }
 408                 if (rc != 0) {
 409                         CERROR("Error trying to bind to port %d: %d\n",
 410                                local_port, rc);
 411                         goto failed;
 412                 }
 413         }
 414         return 0;
 415
 416 failed:
 417         sock_release(sock);
 418         return rc;
 419 }
 420
 421 int
 422 lnet_sock_setbuf(struct socket *sock, int txbufsize, int rxbufsize)
 423 {
 424         int                 option;
 425         int                 rc;
 426
 427         if (txbufsize != 0) {
 428                 option = txbufsize;
 429                 rc = kernel_setsockopt(sock, SOL_SOCKET, SO_SNDBUF,
 430                                        (char *)&option, sizeof(option));
 431                 if (rc != 0) {
 432                         CERROR("Can't set send buffer %d: %d\n",
 433                                 option, rc);
 434                         return rc;
 435                 }
 436         }
 437
 438         if (rxbufsize != 0) {
 439                 option = rxbufsize;
 440                 rc = kernel_setsockopt(sock, SOL_SOCKET, SO_RCVBUF,
 441                                        (char *)&option, sizeof(option));
 442                 if (rc != 0) {
 443                         CERROR("Can't set receive buffer %d: %d\n",
 444                                 option, rc);
 445                         return rc;
 446                 }
 447         }
 448         return 0;
 449 }
 450 EXPORT_SYMBOL(lnet_sock_setbuf);
 451
 452 int
 453 lnet_sock_getaddr(struct socket *sock, bool remote, __u32 *ip, int *port)
 454 {
 455         struct sockaddr_in sin;
 456         int                len = sizeof(sin);
 457         int                rc;
 458
 459         if (remote)
 460                 rc = kernel_getpeername(sock, (struct sockaddr *)&sin, &len);
 461         else
 462                 rc = kernel_getsockname(sock, (struct sockaddr *)&sin, &len);
 463         if (rc != 0) {
 464                 CERROR("Error %d getting sock %s IP/port\n",
 465                         rc, remote ? "peer" : "local");
 466                 return rc;
 467         }
 468
 469         if (ip != NULL)
 470                 *ip = ntohl(sin.sin_addr.s_addr);
 471
 472         if (port != NULL)
 473                 *port = ntohs(sin.sin_port);
 474
 475         return 0;
 476 }
 477 EXPORT_SYMBOL(lnet_sock_getaddr);
 478
 479 int
 480 lnet_sock_getbuf(struct socket *sock, int *txbufsize, int *rxbufsize)
 481 {
 482         if (txbufsize != NULL)
 483                 *txbufsize = sock->sk->sk_sndbuf;
 484
 485         if (rxbufsize != NULL)
 486                 *rxbufsize = sock->sk->sk_rcvbuf;
 487
 488         return 0;
 489 }
 490 EXPORT_SYMBOL(lnet_sock_getbuf);
 491
 492 int
 493 lnet_sock_listen(struct socket **sockp,
 494                    __u32 local_ip, int local_port, int backlog)
 495 {
 496         int      fatal;
 497         int      rc;
 498
 499         rc = lnet_sock_create(sockp, &fatal, local_ip, local_port);
 500         if (rc != 0) {
 501                 if (!fatal)
 502                         CERROR("Can't create socket: port %d already in use\n",
 503                                local_port);
 504                 return rc;
 505         }
 506
 507         rc = kernel_listen(*sockp, backlog);
 508         if (rc == 0)
 509                 return 0;
 510
 511         CERROR("Can't set listen backlog %d: %d\n", backlog, rc);
 512         sock_release(*sockp);
 513         return rc;
 514 }
 515
 516 #ifndef HAVE_SK_SLEEP
 517 static inline wait_queue_head_t *sk_sleep(struct sock *sk)
 518 {
 519         return sk->sk_sleep;
 520 }
 521 #endif
 522
 523 int
 524 lnet_sock_accept(struct socket **newsockp, struct socket *sock)
 525 {
 526         wait_queue_entry_t wait;
 527         struct socket *newsock;
 528         int            rc;
 529
 530         /* XXX this should add a ref to sock->ops->owner, if
 531          * TCP could be a module */
 532         rc = sock_create_lite(PF_PACKET, sock->type, IPPROTO_TCP, &newsock);
 533         if (rc) {
 534                 CERROR("Can't allocate socket\n");
 535                 return rc;
 536         }
 537
 538         newsock->ops = sock->ops;
 539
 540 #ifdef HAVE_KERN_SOCK_ACCEPT_FLAG_ARG
 541         rc = sock->ops->accept(sock, newsock, O_NONBLOCK, false);
 542 #else
 543         rc = sock->ops->accept(sock, newsock, O_NONBLOCK);
 544 #endif
 545         if (rc == -EAGAIN) {
 546                 /* Nothing ready, so wait for activity */
 547                 init_waitqueue_entry(&wait, current);
 548                 add_wait_queue(sk_sleep(sock->sk), &wait);
 549                 set_current_state(TASK_INTERRUPTIBLE);
 550                 schedule();
 551                 remove_wait_queue(sk_sleep(sock->sk), &wait);
 552 #ifdef HAVE_KERN_SOCK_ACCEPT_FLAG_ARG
 553                 rc = sock->ops->accept(sock, newsock, O_NONBLOCK, false);
 554 #else
 555                 rc = sock->ops->accept(sock, newsock, O_NONBLOCK);
 556 #endif
 557         }
 558
 559         if (rc != 0)
 560                 goto failed;
 561
 562         *newsockp = newsock;
 563         return 0;
 564
 565 failed:
 566         sock_release(newsock);
 567         return rc;
 568 }
 569
 570 int
 571 lnet_sock_connect(struct socket **sockp, int *fatal,
 572                   __u32 local_ip, int local_port,
 573                   __u32 peer_ip, int peer_port)
 574 {
 575         struct sockaddr_in  srvaddr;
 576         int                 rc;
 577
 578         rc = lnet_sock_create(sockp, fatal, local_ip, local_port);
 579         if (rc != 0)
 580                 return rc;
 581
 582         memset(&srvaddr, 0, sizeof(srvaddr));
 583         srvaddr.sin_family = AF_INET;
 584         srvaddr.sin_port = htons(peer_port);
 585         srvaddr.sin_addr.s_addr = htonl(peer_ip);
 586
 587         rc = kernel_connect(*sockp, (struct sockaddr *)&srvaddr,
 588                             sizeof(srvaddr), 0);
 589         if (rc == 0)
 590                 return 0;
 591
 592         /* EADDRNOTAVAIL probably means we're already connected to the same
 593          * peer/port on the same local port on a differently typed
 594          * connection.  Let our caller retry with a different local
 595          * port... */
 596         *fatal = !(rc == -EADDRNOTAVAIL);
 597
 598         CDEBUG_LIMIT(*fatal ? D_NETERROR : D_NET,
 599                "Error %d connecting %pI4h/%d -> %pI4h/%d\n", rc,
 600                &local_ip, local_port, &peer_ip, peer_port);
 601
 602         sock_release(*sockp);
 603         return rc;
 604 }