1 /* 2 * Copyright (c) 2006 Oracle. 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/if_arp.h> 37 #include <linux/jhash.h> 38 #include <linux/ratelimit.h> 39 #include "rds.h" 40 41 #define BIND_HASH_SIZE 1024 42 static struct hlist_head bind_hash_table[BIND_HASH_SIZE]; 43 static DEFINE_SPINLOCK(rds_bind_lock); 44 45 static struct hlist_head *hash_to_bucket(__be32 addr, __be16 port) 46 { 47 return bind_hash_table + (jhash_2words((u32)addr, (u32)port, 0) & 48 (BIND_HASH_SIZE - 1)); 49 } 50 51 static struct rds_sock *rds_bind_lookup(__be32 addr, __be16 port, 52 struct rds_sock *insert) 53 { 54 struct rds_sock *rs; 55 struct hlist_node *node; 56 struct hlist_head *head = hash_to_bucket(addr, port); 57 u64 cmp; 58 u64 needle = ((u64)be32_to_cpu(addr) << 32) | be16_to_cpu(port); 59 60 rcu_read_lock(); 61 hlist_for_each_entry_rcu(rs, node, head, rs_bound_node) { 62 cmp = ((u64)be32_to_cpu(rs->rs_bound_addr) << 32) | 63 be16_to_cpu(rs->rs_bound_port); 64 65 if (cmp == needle) { 66 rcu_read_unlock(); 67 return rs; 68 } 69 } 70 rcu_read_unlock(); 71 72 if (insert) { 73 /* 74 * make sure our addr and port are set before 75 * we are added to the list, other people 76 * in rcu will find us as soon as the 77 * hlist_add_head_rcu is done 78 */ 79 insert->rs_bound_addr = addr; 80 insert->rs_bound_port = port; 81 rds_sock_addref(insert); 82 83 hlist_add_head_rcu(&insert->rs_bound_node, head); 84 } 85 return NULL; 86 } 87 88 /* 89 * Return the rds_sock bound at the given local address. 90 * 91 * The rx path can race with rds_release. We notice if rds_release() has 92 * marked this socket and don't return a rs ref to the rx path. 93 */ 94 struct rds_sock *rds_find_bound(__be32 addr, __be16 port) 95 { 96 struct rds_sock *rs; 97 98 rs = rds_bind_lookup(addr, port, NULL); 99 100 if (rs && !sock_flag(rds_rs_to_sk(rs), SOCK_DEAD)) 101 rds_sock_addref(rs); 102 else 103 rs = NULL; 104 105 rdsdebug("returning rs %p for %pI4:%u\n", rs, &addr, 106 ntohs(port)); 107 return rs; 108 } 109 110 /* returns -ve errno or +ve port */ 111 static int rds_add_bound(struct rds_sock *rs, __be32 addr, __be16 *port) 112 { 113 unsigned long flags; 114 int ret = -EADDRINUSE; 115 u16 rover, last; 116 117 if (*port != 0) { 118 rover = be16_to_cpu(*port); 119 last = rover; 120 } else { 121 rover = max_t(u16, net_random(), 2); 122 last = rover - 1; 123 } 124 125 spin_lock_irqsave(&rds_bind_lock, flags); 126 127 do { 128 if (rover == 0) 129 rover++; 130 if (!rds_bind_lookup(addr, cpu_to_be16(rover), rs)) { 131 *port = rs->rs_bound_port; 132 ret = 0; 133 rdsdebug("rs %p binding to %pI4:%d\n", 134 rs, &addr, (int)ntohs(*port)); 135 break; 136 } 137 } while (rover++ != last); 138 139 spin_unlock_irqrestore(&rds_bind_lock, flags); 140 141 return ret; 142 } 143 144 void rds_remove_bound(struct rds_sock *rs) 145 { 146 unsigned long flags; 147 148 spin_lock_irqsave(&rds_bind_lock, flags); 149 150 if (rs->rs_bound_addr) { 151 rdsdebug("rs %p unbinding from %pI4:%d\n", 152 rs, &rs->rs_bound_addr, 153 ntohs(rs->rs_bound_port)); 154 155 hlist_del_init_rcu(&rs->rs_bound_node); 156 rds_sock_put(rs); 157 rs->rs_bound_addr = 0; 158 } 159 160 spin_unlock_irqrestore(&rds_bind_lock, flags); 161 } 162 163 int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 164 { 165 struct sock *sk = sock->sk; 166 struct sockaddr_in *sin = (struct sockaddr_in *)uaddr; 167 struct rds_sock *rs = rds_sk_to_rs(sk); 168 struct rds_transport *trans; 169 int ret = 0; 170 171 lock_sock(sk); 172 173 if (addr_len != sizeof(struct sockaddr_in) || 174 sin->sin_family != AF_INET || 175 rs->rs_bound_addr || 176 sin->sin_addr.s_addr == htonl(INADDR_ANY)) { 177 ret = -EINVAL; 178 goto out; 179 } 180 181 ret = rds_add_bound(rs, sin->sin_addr.s_addr, &sin->sin_port); 182 if (ret) 183 goto out; 184 185 trans = rds_trans_get_preferred(sin->sin_addr.s_addr); 186 if (!trans) { 187 ret = -EADDRNOTAVAIL; 188 rds_remove_bound(rs); 189 printk_ratelimited(KERN_INFO "RDS: rds_bind() could not find a transport, " 190 "load rds_tcp or rds_rdma?\n"); 191 goto out; 192 } 193 194 rs->rs_transport = trans; 195 ret = 0; 196 197 out: 198 release_sock(sk); 199 200 /* we might have called rds_remove_bound on error */ 201 if (ret) 202 synchronize_rcu(); 203 return ret; 204 } 205