OSDN Git Service

clk: at91: fix masterck name
[uclinux-h8/linux.git] / net / rds / bind.c
1 /*
2  * Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  *
32  */
33 #include <linux/kernel.h>
34 #include <net/sock.h>
35 #include <linux/in.h>
36 #include <linux/ipv6.h>
37 #include <linux/if_arp.h>
38 #include <linux/jhash.h>
39 #include <linux/ratelimit.h>
40 #include "rds.h"
41
42 static struct rhashtable bind_hash_table;
43
44 static const struct rhashtable_params ht_parms = {
45         .nelem_hint = 768,
46         .key_len = RDS_BOUND_KEY_LEN,
47         .key_offset = offsetof(struct rds_sock, rs_bound_key),
48         .head_offset = offsetof(struct rds_sock, rs_bound_node),
49         .max_size = 16384,
50         .min_size = 1024,
51 };
52
53 /* Create a key for the bind hash table manipulation.  Port is in network byte
54  * order.
55  */
56 static inline void __rds_create_bind_key(u8 *key, const struct in6_addr *addr,
57                                          __be16 port, __u32 scope_id)
58 {
59         memcpy(key, addr, sizeof(*addr));
60         key += sizeof(*addr);
61         memcpy(key, &port, sizeof(port));
62         key += sizeof(port);
63         memcpy(key, &scope_id, sizeof(scope_id));
64 }
65
66 /*
67  * Return the rds_sock bound at the given local address.
68  *
69  * The rx path can race with rds_release.  We notice if rds_release() has
70  * marked this socket and don't return a rs ref to the rx path.
71  */
72 struct rds_sock *rds_find_bound(const struct in6_addr *addr, __be16 port,
73                                 __u32 scope_id)
74 {
75         u8 key[RDS_BOUND_KEY_LEN];
76         struct rds_sock *rs;
77
78         __rds_create_bind_key(key, addr, port, scope_id);
79         rcu_read_lock();
80         rs = rhashtable_lookup(&bind_hash_table, key, ht_parms);
81         if (rs && !sock_flag(rds_rs_to_sk(rs), SOCK_DEAD))
82                 rds_sock_addref(rs);
83         else
84                 rs = NULL;
85         rcu_read_unlock();
86
87         rdsdebug("returning rs %p for %pI6c:%u\n", rs, addr,
88                  ntohs(port));
89
90         return rs;
91 }
92
93 /* returns -ve errno or +ve port */
94 static int rds_add_bound(struct rds_sock *rs, const struct in6_addr *addr,
95                          __be16 *port, __u32 scope_id)
96 {
97         int ret = -EADDRINUSE;
98         u16 rover, last;
99         u8 key[RDS_BOUND_KEY_LEN];
100
101         if (*port != 0) {
102                 rover = be16_to_cpu(*port);
103                 if (rover == RDS_FLAG_PROBE_PORT)
104                         return -EINVAL;
105                 last = rover;
106         } else {
107                 rover = max_t(u16, prandom_u32(), 2);
108                 last = rover - 1;
109         }
110
111         do {
112                 if (rover == 0)
113                         rover++;
114
115                 if (rover == RDS_FLAG_PROBE_PORT)
116                         continue;
117                 __rds_create_bind_key(key, addr, cpu_to_be16(rover),
118                                       scope_id);
119                 if (rhashtable_lookup_fast(&bind_hash_table, key, ht_parms))
120                         continue;
121
122                 memcpy(rs->rs_bound_key, key, sizeof(rs->rs_bound_key));
123                 rs->rs_bound_addr = *addr;
124                 net_get_random_once(&rs->rs_hash_initval,
125                                     sizeof(rs->rs_hash_initval));
126                 rs->rs_bound_port = cpu_to_be16(rover);
127                 rs->rs_bound_node.next = NULL;
128                 rds_sock_addref(rs);
129                 if (!rhashtable_insert_fast(&bind_hash_table,
130                                             &rs->rs_bound_node, ht_parms)) {
131                         *port = rs->rs_bound_port;
132                         rs->rs_bound_scope_id = scope_id;
133                         ret = 0;
134                         rdsdebug("rs %p binding to %pI6c:%d\n",
135                                  rs, addr, (int)ntohs(*port));
136                         break;
137                 } else {
138                         rs->rs_bound_addr = in6addr_any;
139                         rds_sock_put(rs);
140                         ret = -ENOMEM;
141                         break;
142                 }
143         } while (rover++ != last);
144
145         return ret;
146 }
147
148 void rds_remove_bound(struct rds_sock *rs)
149 {
150
151         if (ipv6_addr_any(&rs->rs_bound_addr))
152                 return;
153
154         rdsdebug("rs %p unbinding from %pI6c:%d\n",
155                  rs, &rs->rs_bound_addr,
156                  ntohs(rs->rs_bound_port));
157
158         rhashtable_remove_fast(&bind_hash_table, &rs->rs_bound_node, ht_parms);
159         rds_sock_put(rs);
160         rs->rs_bound_addr = in6addr_any;
161 }
162
163 int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
164 {
165         struct sock *sk = sock->sk;
166         struct rds_sock *rs = rds_sk_to_rs(sk);
167         struct in6_addr v6addr, *binding_addr;
168         struct rds_transport *trans;
169         __u32 scope_id = 0;
170         int ret = 0;
171         __be16 port;
172
173         /* We allow an RDS socket to be bound to either IPv4 or IPv6
174          * address.
175          */
176         if (uaddr->sa_family == AF_INET) {
177                 struct sockaddr_in *sin = (struct sockaddr_in *)uaddr;
178
179                 if (addr_len < sizeof(struct sockaddr_in) ||
180                     sin->sin_addr.s_addr == htonl(INADDR_ANY) ||
181                     sin->sin_addr.s_addr == htonl(INADDR_BROADCAST) ||
182                     IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
183                         return -EINVAL;
184                 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &v6addr);
185                 binding_addr = &v6addr;
186                 port = sin->sin_port;
187 #if IS_ENABLED(CONFIG_IPV6)
188         } else if (uaddr->sa_family == AF_INET6) {
189                 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)uaddr;
190                 int addr_type;
191
192                 if (addr_len < sizeof(struct sockaddr_in6))
193                         return -EINVAL;
194                 addr_type = ipv6_addr_type(&sin6->sin6_addr);
195                 if (!(addr_type & IPV6_ADDR_UNICAST)) {
196                         __be32 addr4;
197
198                         if (!(addr_type & IPV6_ADDR_MAPPED))
199                                 return -EINVAL;
200
201                         /* It is a mapped address.  Need to do some sanity
202                          * checks.
203                          */
204                         addr4 = sin6->sin6_addr.s6_addr32[3];
205                         if (addr4 == htonl(INADDR_ANY) ||
206                             addr4 == htonl(INADDR_BROADCAST) ||
207                             IN_MULTICAST(ntohl(addr4)))
208                                 return -EINVAL;
209                 }
210                 /* The scope ID must be specified for link local address. */
211                 if (addr_type & IPV6_ADDR_LINKLOCAL) {
212                         if (sin6->sin6_scope_id == 0)
213                                 return -EINVAL;
214                         scope_id = sin6->sin6_scope_id;
215                 }
216                 binding_addr = &sin6->sin6_addr;
217                 port = sin6->sin6_port;
218 #endif
219         } else {
220                 return -EINVAL;
221         }
222         lock_sock(sk);
223
224         /* RDS socket does not allow re-binding. */
225         if (!ipv6_addr_any(&rs->rs_bound_addr)) {
226                 ret = -EINVAL;
227                 goto out;
228         }
229         /* Socket is connected.  The binding address should have the same
230          * scope ID as the connected address, except the case when one is
231          * non-link local address (scope_id is 0).
232          */
233         if (!ipv6_addr_any(&rs->rs_conn_addr) && scope_id &&
234             rs->rs_bound_scope_id &&
235             scope_id != rs->rs_bound_scope_id) {
236                 ret = -EINVAL;
237                 goto out;
238         }
239
240         sock_set_flag(sk, SOCK_RCU_FREE);
241         ret = rds_add_bound(rs, binding_addr, &port, scope_id);
242         if (ret)
243                 goto out;
244
245         if (rs->rs_transport) { /* previously bound */
246                 trans = rs->rs_transport;
247                 if (trans->laddr_check(sock_net(sock->sk),
248                                        binding_addr, scope_id) != 0) {
249                         ret = -ENOPROTOOPT;
250                         rds_remove_bound(rs);
251                 } else {
252                         ret = 0;
253                 }
254                 goto out;
255         }
256         trans = rds_trans_get_preferred(sock_net(sock->sk), binding_addr,
257                                         scope_id);
258         if (!trans) {
259                 ret = -EADDRNOTAVAIL;
260                 rds_remove_bound(rs);
261                 pr_info_ratelimited("RDS: %s could not find a transport for %pI6c, load rds_tcp or rds_rdma?\n",
262                                     __func__, binding_addr);
263                 goto out;
264         }
265
266         rs->rs_transport = trans;
267         ret = 0;
268
269 out:
270         release_sock(sk);
271         return ret;
272 }
273
274 void rds_bind_lock_destroy(void)
275 {
276         rhashtable_destroy(&bind_hash_table);
277 }
278
279 int rds_bind_lock_init(void)
280 {
281         return rhashtable_init(&bind_hash_table, &ht_parms);
282 }