Whamcloud - gitweb
LU-11635 gss: proper gss build for client-only
[fs/lustre-release.git] / 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 }