Linux Audio

Check our new training course

Loading...
v3.5.6
  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
 42static struct hlist_head bind_hash_table[BIND_HASH_SIZE];
 43static DEFINE_SPINLOCK(rds_bind_lock);
 44
 45static 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
 51static 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 */
 94struct 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 */
111static 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
144void 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
163int 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
197out:
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}
v4.17
  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
 41static struct rhashtable bind_hash_table;
 
 
 42
 43static const struct rhashtable_params ht_parms = {
 44	.nelem_hint = 768,
 45	.key_len = sizeof(u64),
 46	.key_offset = offsetof(struct rds_sock, rs_bound_key),
 47	.head_offset = offsetof(struct rds_sock, rs_bound_node),
 48	.max_size = 16384,
 49	.min_size = 1024,
 50};
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 51
 52/*
 53 * Return the rds_sock bound at the given local address.
 54 *
 55 * The rx path can race with rds_release.  We notice if rds_release() has
 56 * marked this socket and don't return a rs ref to the rx path.
 57 */
 58struct rds_sock *rds_find_bound(__be32 addr, __be16 port)
 59{
 60	u64 key = ((u64)addr << 32) | port;
 61	struct rds_sock *rs;
 62
 63	rs = rhashtable_lookup_fast(&bind_hash_table, &key, ht_parms);
 
 64	if (rs && !sock_flag(rds_rs_to_sk(rs), SOCK_DEAD))
 65		rds_sock_addref(rs);
 66	else
 67		rs = NULL;
 68
 69	rdsdebug("returning rs %p for %pI4:%u\n", rs, &addr,
 70		ntohs(port));
 71
 72	return rs;
 73}
 74
 75/* returns -ve errno or +ve port */
 76static int rds_add_bound(struct rds_sock *rs, __be32 addr, __be16 *port)
 77{
 
 78	int ret = -EADDRINUSE;
 79	u16 rover, last;
 80	u64 key;
 81
 82	if (*port != 0) {
 83		rover = be16_to_cpu(*port);
 84		if (rover == RDS_FLAG_PROBE_PORT)
 85			return -EINVAL;
 86		last = rover;
 87	} else {
 88		rover = max_t(u16, prandom_u32(), 2);
 89		last = rover - 1;
 90	}
 91
 
 
 92	do {
 93		if (rover == 0)
 94			rover++;
 95
 96		if (rover == RDS_FLAG_PROBE_PORT)
 97			continue;
 98		key = ((u64)addr << 32) | cpu_to_be16(rover);
 99		if (rhashtable_lookup_fast(&bind_hash_table, &key, ht_parms))
100			continue;
101
102		rs->rs_bound_key = key;
103		rs->rs_bound_addr = addr;
104		net_get_random_once(&rs->rs_hash_initval,
105				    sizeof(rs->rs_hash_initval));
106		rs->rs_bound_port = cpu_to_be16(rover);
107		rs->rs_bound_node.next = NULL;
108		rds_sock_addref(rs);
109		if (!rhashtable_insert_fast(&bind_hash_table,
110					    &rs->rs_bound_node, ht_parms)) {
111			*port = rs->rs_bound_port;
112			ret = 0;
113			rdsdebug("rs %p binding to %pI4:%d\n",
114			  rs, &addr, (int)ntohs(*port));
115			break;
116		} else {
117			rs->rs_bound_addr = 0;
118			rds_sock_put(rs);
119			ret = -ENOMEM;
120			break;
121		}
122	} while (rover++ != last);
123
 
 
124	return ret;
125}
126
127void rds_remove_bound(struct rds_sock *rs)
128{
 
129
130	if (!rs->rs_bound_addr)
131		return;
 
 
 
 
 
 
 
 
 
132
133	rdsdebug("rs %p unbinding from %pI4:%d\n",
134		 rs, &rs->rs_bound_addr,
135		 ntohs(rs->rs_bound_port));
136
137	rhashtable_remove_fast(&bind_hash_table, &rs->rs_bound_node, ht_parms);
138	rds_sock_put(rs);
139	rs->rs_bound_addr = 0;
140}
141
142int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
143{
144	struct sock *sk = sock->sk;
145	struct sockaddr_in *sin = (struct sockaddr_in *)uaddr;
146	struct rds_sock *rs = rds_sk_to_rs(sk);
147	struct rds_transport *trans;
148	int ret = 0;
149
150	lock_sock(sk);
151
152	if (addr_len != sizeof(struct sockaddr_in) ||
153	    sin->sin_family != AF_INET ||
154	    rs->rs_bound_addr ||
155	    sin->sin_addr.s_addr == htonl(INADDR_ANY)) {
156		ret = -EINVAL;
157		goto out;
158	}
159
160	ret = rds_add_bound(rs, sin->sin_addr.s_addr, &sin->sin_port);
161	if (ret)
162		goto out;
163
164	if (rs->rs_transport) { /* previously bound */
165		trans = rs->rs_transport;
166		if (trans->laddr_check(sock_net(sock->sk),
167				       sin->sin_addr.s_addr) != 0) {
168			ret = -ENOPROTOOPT;
169			rds_remove_bound(rs);
170		} else {
171			ret = 0;
172		}
173		goto out;
174	}
175	trans = rds_trans_get_preferred(sock_net(sock->sk),
176					sin->sin_addr.s_addr);
177	if (!trans) {
178		ret = -EADDRNOTAVAIL;
179		rds_remove_bound(rs);
180		pr_info_ratelimited("RDS: %s could not find a transport for %pI4, load rds_tcp or rds_rdma?\n",
181				    __func__, &sin->sin_addr.s_addr);
182		goto out;
183	}
184
185	rs->rs_transport = trans;
186	ret = 0;
187
188out:
189	release_sock(sk);
 
 
 
 
190	return ret;
191}
192
193void rds_bind_lock_destroy(void)
194{
195	rhashtable_destroy(&bind_hash_table);
196}
197
198int rds_bind_lock_init(void)
199{
200	return rhashtable_init(&bind_hash_table, &ht_parms);
201}