Whamcloud - gitweb
LU-10391 lnet: allow creation of IPv6 socket.
[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 <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/libcfs.h>
48 #include <lnet/lib-lnet.h>
49
50 int
51 lnet_sock_write(struct socket *sock, void *buffer, int nob, int timeout)
52 {
53         int rc;
54         long jiffies_left = cfs_time_seconds(timeout);
55         unsigned long then;
56
57         LASSERT(nob > 0);
58         /* Caller may pass a zero timeout if she thinks the socket buffer is
59          * empty enough to take the whole message immediately */
60
61         for (;;) {
62                 struct kvec  iov = {
63                         .iov_base = buffer,
64                         .iov_len  = nob
65                 };
66                 struct msghdr msg = {
67                         .msg_flags      = (timeout == 0) ? MSG_DONTWAIT : 0
68                 };
69
70                 if (timeout != 0) {
71                         struct sock *sk = sock->sk;
72
73                         /* Set send timeout to remaining time */
74                         lock_sock(sk);
75                         sk->sk_sndtimeo = jiffies_left;
76                         release_sock(sk);
77                 }
78
79                 then = jiffies;
80                 rc = kernel_sendmsg(sock, &msg, &iov, 1, nob);
81                 jiffies_left -= jiffies - then;
82
83                 if (rc == nob)
84                         return 0;
85
86                 if (rc < 0)
87                         return rc;
88
89                 if (rc == 0) {
90                         CERROR("Unexpected zero rc\n");
91                         return -ECONNABORTED;
92                 }
93
94                 if (jiffies_left <= 0)
95                         return -EAGAIN;
96
97                 buffer = ((char *)buffer) + rc;
98                 nob -= rc;
99         }
100         return 0;
101 }
102 EXPORT_SYMBOL(lnet_sock_write);
103
104 int
105 lnet_sock_read(struct socket *sock, void *buffer, int nob, int timeout)
106 {
107         int rc;
108         long jiffies_left = cfs_time_seconds(timeout);
109         unsigned long then;
110
111         LASSERT(nob > 0);
112         LASSERT(jiffies_left > 0);
113
114         for (;;) {
115                 struct kvec  iov = {
116                         .iov_base = buffer,
117                         .iov_len  = nob
118                 };
119                 struct msghdr msg = {
120                         .msg_flags      = 0
121                 };
122                 struct sock *sk = sock->sk;
123
124                 /* Set receive timeout to remaining time */
125                 lock_sock(sk);
126                 sk->sk_rcvtimeo = jiffies_left;
127                 release_sock(sk);
128
129                 then = jiffies;
130                 rc = kernel_recvmsg(sock, &msg, &iov, 1, nob, 0);
131                 jiffies_left -= jiffies - then;
132
133                 if (rc < 0)
134                         return rc;
135
136                 if (rc == 0)
137                         return -ECONNRESET;
138
139                 buffer = ((char *)buffer) + rc;
140                 nob -= rc;
141
142                 if (nob == 0)
143                         return 0;
144
145                 if (jiffies_left <= 0)
146                         return -ETIMEDOUT;
147         }
148 }
149 EXPORT_SYMBOL(lnet_sock_read);
150
151 int choose_ipv4_src(__u32 *ret, int interface, __u32 dst_ipaddr, struct net *ns)
152 {
153         struct net_device *dev;
154         struct in_device *in_dev;
155         int err;
156         DECLARE_CONST_IN_IFADDR(ifa);
157
158         rcu_read_lock();
159         dev = dev_get_by_index_rcu(ns, interface);
160         err = -EINVAL;
161         if (!dev || !(dev->flags & IFF_UP))
162                 goto out;
163         in_dev = __in_dev_get_rcu(dev);
164         if (!in_dev)
165                 goto out;
166         err = -ENOENT;
167         in_dev_for_each_ifa_rcu(ifa, in_dev) {
168                 if (err ||
169                     ((dst_ipaddr ^ ntohl(ifa->ifa_local))
170                      & ntohl(ifa->ifa_mask)) == 0) {
171                         /* This address at least as good as what we
172                          * already have
173                          */
174                         *ret = ntohl(ifa->ifa_local);
175                         err = 0;
176                 }
177         }
178         endfor_ifa(in_dev);
179 out:
180         rcu_read_unlock();
181         return err;
182 }
183 EXPORT_SYMBOL(choose_ipv4_src);
184
185 static struct socket *
186 lnet_sock_create(int interface, struct sockaddr *remaddr,
187                  int local_port, struct net *ns)
188 {
189         struct socket *sock;
190         int rc;
191         int option;
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         option = 1;
208         rc = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
209                                (char *)&option, sizeof(option));
210         if (rc) {
211                 CERROR("Can't set SO_REUSEADDR for socket: %d\n", rc);
212                 goto failed;
213         }
214
215         if (interface >= 0 || local_port != 0) {
216                 struct sockaddr_storage locaddr = {};
217                 struct sockaddr_in *sin = (void *)&locaddr;
218                 struct sockaddr_in6 *sin6 = (void *)&locaddr;
219
220                 switch (family) {
221                 case AF_INET:
222                         sin->sin_family = AF_INET;
223                         sin->sin_addr.s_addr = INADDR_ANY;
224                         if (interface >= 0 && remaddr) {
225                                 struct sockaddr_in *rem = (void *)remaddr;
226                                 __u32 ip;
227
228                                 rc = choose_ipv4_src(&ip,
229                                                      interface,
230                                                      ntohl(rem->sin_addr.s_addr),
231                                                      ns);
232                                 if (rc)
233                                         goto failed;
234                                 sin->sin_addr.s_addr = htonl(ip);
235                         }
236                         sin->sin_port = htons(local_port);
237                         break;
238                 case AF_INET6:
239                         sin6->sin6_family = AF_INET6;
240                         sin6->sin6_addr = in6addr_any;
241                         if (interface >= 0 && remaddr) {
242                                 struct sockaddr_in6 *rem = (void *)remaddr;
243
244                                 ipv6_dev_get_saddr(ns,
245                                                    dev_get_by_index(ns,
246                                                                     interface),
247                                                    &rem->sin6_addr, 0,
248                                                    &sin6->sin6_addr);
249                         }
250                         sin6->sin6_port = htons(local_port);
251                         break;
252                 }
253                 rc = kernel_bind(sock, (struct sockaddr *)&locaddr,
254                                  sizeof(locaddr));
255                 if (rc == -EADDRINUSE) {
256                         CDEBUG(D_NET, "Port %d already in use\n", local_port);
257                         goto failed;
258                 }
259                 if (rc != 0) {
260                         CERROR("Error trying to bind to port %d: %d\n",
261                                local_port, rc);
262                         goto failed;
263                 }
264         }
265         return sock;
266
267 failed:
268         sock_release(sock);
269         return ERR_PTR(rc);
270 }
271
272 int
273 lnet_sock_setbuf(struct socket *sock, int txbufsize, int rxbufsize)
274 {
275         int                 option;
276         int                 rc;
277
278         if (txbufsize != 0) {
279                 option = txbufsize;
280                 rc = kernel_setsockopt(sock, SOL_SOCKET, SO_SNDBUF,
281                                        (char *)&option, sizeof(option));
282                 if (rc != 0) {
283                         CERROR("Can't set send buffer %d: %d\n",
284                                 option, rc);
285                         return rc;
286                 }
287         }
288
289         if (rxbufsize != 0) {
290                 option = rxbufsize;
291                 rc = kernel_setsockopt(sock, SOL_SOCKET, SO_RCVBUF,
292                                        (char *)&option, sizeof(option));
293                 if (rc != 0) {
294                         CERROR("Can't set receive buffer %d: %d\n",
295                                 option, rc);
296                         return rc;
297                 }
298         }
299         return 0;
300 }
301 EXPORT_SYMBOL(lnet_sock_setbuf);
302
303 int
304 lnet_sock_getaddr(struct socket *sock, bool remote,
305                   struct sockaddr_storage *peer)
306 {
307         int rc;
308 #ifndef HAVE_KERN_SOCK_GETNAME_2ARGS
309         int len = sizeof(*peer);
310 #endif
311
312         if (remote)
313                 rc = lnet_kernel_getpeername(sock,
314                                              (struct sockaddr *)peer, &len);
315         else
316                 rc = lnet_kernel_getsockname(sock,
317                                              (struct sockaddr *)peer, &len);
318         if (rc < 0) {
319                 CERROR("Error %d getting sock %s IP/port\n",
320                         rc, remote ? "peer" : "local");
321                 return rc;
322         }
323         if (peer->ss_family == AF_INET6) {
324                 struct sockaddr_in6 *in6 = (void *)peer;
325                 struct sockaddr_in *in = (void *)peer;
326                 short port = in6->sin6_port;
327
328                 if (ipv6_addr_v4mapped(&in6->sin6_addr)) {
329                         /* Pretend it is a v4 socket */
330                         memset(in, 0, sizeof(*in));
331                         in->sin_family = AF_INET;
332                         in->sin_port = port;
333                         memcpy(&in->sin_addr, &in6->sin6_addr.s6_addr32[3], 4);
334                 }
335         }
336         return 0;
337 }
338 EXPORT_SYMBOL(lnet_sock_getaddr);
339
340 int
341 lnet_sock_getbuf(struct socket *sock, int *txbufsize, int *rxbufsize)
342 {
343         if (txbufsize != NULL)
344                 *txbufsize = sock->sk->sk_sndbuf;
345
346         if (rxbufsize != NULL)
347                 *rxbufsize = sock->sk->sk_rcvbuf;
348
349         return 0;
350 }
351 EXPORT_SYMBOL(lnet_sock_getbuf);
352
353 struct socket *
354 lnet_sock_listen(int local_port, int backlog, struct net *ns)
355 {
356         struct socket *sock;
357         int val = 0;
358         int rc;
359
360         sock = lnet_sock_create(-1, NULL, local_port, ns);
361         if (IS_ERR(sock)) {
362                 rc = PTR_ERR(sock);
363                 if (rc == -EADDRINUSE)
364                         CERROR("Can't create socket: port %d already in use\n",
365                                local_port);
366                 return ERR_PTR(rc);
367         }
368
369         /* Make sure we get both IPv4 and IPv6 connections.
370          * This is the default, but it can be overridden so
371          * we force it back.
372          */
373         kernel_setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
374                           (char *) &val, sizeof(val));
375
376         rc = kernel_listen(sock, backlog);
377         if (rc == 0)
378                 return sock;
379
380         CERROR("Can't set listen backlog %d: %d\n", backlog, rc);
381         sock_release(sock);
382         return ERR_PTR(rc);
383 }
384
385 struct socket *
386 lnet_sock_connect(int interface, int local_port,
387                   struct sockaddr *peeraddr,
388                   struct net *ns)
389 {
390         struct socket *sock;
391         int rc;
392
393         sock = lnet_sock_create(interface, peeraddr, local_port, ns);
394         if (IS_ERR(sock))
395                 return sock;
396
397         rc = kernel_connect(sock, peeraddr, sizeof(struct sockaddr_in), 0);
398         if (rc == 0)
399                 return sock;
400
401         /* EADDRNOTAVAIL probably means we're already connected to the same
402          * peer/port on the same local port on a differently typed
403          * connection.  Let our caller retry with a different local
404          * port... */
405
406         CDEBUG_LIMIT(rc == -EADDRNOTAVAIL ? D_NET : D_NETERROR,
407                      "Error %d connecting %d -> %pISp\n", rc,
408                      local_port, peeraddr);
409
410         sock_release(sock);
411         return ERR_PTR(rc);
412 }