Linux Audio

Check our new training course

Loading...
v3.5.6
  1/*
  2 * Copyright (c) 2009 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/module.h>
 34#include <rdma/rdma_cm.h>
 35
 
 36#include "rdma_transport.h"
 
 37
 38static struct rdma_cm_id *rds_rdma_listen_id;
 39
 40static char *rds_cm_event_strings[] = {
 41#define RDS_CM_EVENT_STRING(foo) \
 42		[RDMA_CM_EVENT_##foo] = __stringify(RDMA_CM_EVENT_##foo)
 43	RDS_CM_EVENT_STRING(ADDR_RESOLVED),
 44	RDS_CM_EVENT_STRING(ADDR_ERROR),
 45	RDS_CM_EVENT_STRING(ROUTE_RESOLVED),
 46	RDS_CM_EVENT_STRING(ROUTE_ERROR),
 47	RDS_CM_EVENT_STRING(CONNECT_REQUEST),
 48	RDS_CM_EVENT_STRING(CONNECT_RESPONSE),
 49	RDS_CM_EVENT_STRING(CONNECT_ERROR),
 50	RDS_CM_EVENT_STRING(UNREACHABLE),
 51	RDS_CM_EVENT_STRING(REJECTED),
 52	RDS_CM_EVENT_STRING(ESTABLISHED),
 53	RDS_CM_EVENT_STRING(DISCONNECTED),
 54	RDS_CM_EVENT_STRING(DEVICE_REMOVAL),
 55	RDS_CM_EVENT_STRING(MULTICAST_JOIN),
 56	RDS_CM_EVENT_STRING(MULTICAST_ERROR),
 57	RDS_CM_EVENT_STRING(ADDR_CHANGE),
 58	RDS_CM_EVENT_STRING(TIMEWAIT_EXIT),
 59#undef RDS_CM_EVENT_STRING
 60};
 61
 62static char *rds_cm_event_str(enum rdma_cm_event_type type)
 63{
 64	return rds_str_array(rds_cm_event_strings,
 65			     ARRAY_SIZE(rds_cm_event_strings), type);
 66};
 67
 68int rds_rdma_cm_event_handler(struct rdma_cm_id *cm_id,
 69			      struct rdma_cm_event *event)
 70{
 71	/* this can be null in the listening path */
 72	struct rds_connection *conn = cm_id->context;
 73	struct rds_transport *trans;
 74	int ret = 0;
 75
 76	rdsdebug("conn %p id %p handling event %u (%s)\n", conn, cm_id,
 77		 event->event, rds_cm_event_str(event->event));
 78
 79	if (cm_id->device->node_type == RDMA_NODE_RNIC)
 80		trans = &rds_iw_transport;
 81	else
 82		trans = &rds_ib_transport;
 83
 84	/* Prevent shutdown from tearing down the connection
 85	 * while we're executing. */
 86	if (conn) {
 87		mutex_lock(&conn->c_cm_lock);
 88
 89		/* If the connection is being shut down, bail out
 90		 * right away. We return 0 so cm_id doesn't get
 91		 * destroyed prematurely */
 92		if (rds_conn_state(conn) == RDS_CONN_DISCONNECTING) {
 93			/* Reject incoming connections while we're tearing
 94			 * down an existing one. */
 95			if (event->event == RDMA_CM_EVENT_CONNECT_REQUEST)
 96				ret = 1;
 97			goto out;
 98		}
 99	}
100
101	switch (event->event) {
102	case RDMA_CM_EVENT_CONNECT_REQUEST:
103		ret = trans->cm_handle_connect(cm_id, event);
104		break;
105
106	case RDMA_CM_EVENT_ADDR_RESOLVED:
107		/* XXX do we need to clean up if this fails? */
108		ret = rdma_resolve_route(cm_id,
109					 RDS_RDMA_RESOLVE_TIMEOUT_MS);
110		break;
111
112	case RDMA_CM_EVENT_ROUTE_RESOLVED:
113		/* XXX worry about racing with listen acceptance */
114		ret = trans->cm_initiate_connect(cm_id);
 
 
 
 
 
 
 
 
 
 
115		break;
116
117	case RDMA_CM_EVENT_ESTABLISHED:
118		trans->cm_connect_complete(conn, event);
119		break;
120
 
 
 
 
121	case RDMA_CM_EVENT_ADDR_ERROR:
122	case RDMA_CM_EVENT_ROUTE_ERROR:
123	case RDMA_CM_EVENT_CONNECT_ERROR:
124	case RDMA_CM_EVENT_UNREACHABLE:
125	case RDMA_CM_EVENT_REJECTED:
126	case RDMA_CM_EVENT_DEVICE_REMOVAL:
127	case RDMA_CM_EVENT_ADDR_CHANGE:
128		if (conn)
129			rds_conn_drop(conn);
130		break;
131
132	case RDMA_CM_EVENT_DISCONNECTED:
133		rdsdebug("DISCONNECT event - dropping connection "
134			"%pI4->%pI4\n", &conn->c_laddr,
135			 &conn->c_faddr);
136		rds_conn_drop(conn);
137		break;
138
 
 
 
 
 
 
 
 
139	default:
140		/* things like device disconnect? */
141		printk(KERN_ERR "RDS: unknown event %u (%s)!\n",
142		       event->event, rds_cm_event_str(event->event));
143		break;
144	}
145
146out:
147	if (conn)
148		mutex_unlock(&conn->c_cm_lock);
149
150	rdsdebug("id %p event %u (%s) handling ret %d\n", cm_id, event->event,
151		 rds_cm_event_str(event->event), ret);
152
153	return ret;
154}
155
156static int rds_rdma_listen_init(void)
157{
158	struct sockaddr_in sin;
159	struct rdma_cm_id *cm_id;
160	int ret;
161
162	cm_id = rdma_create_id(rds_rdma_cm_event_handler, NULL, RDMA_PS_TCP,
163			       IB_QPT_RC);
164	if (IS_ERR(cm_id)) {
165		ret = PTR_ERR(cm_id);
166		printk(KERN_ERR "RDS/RDMA: failed to setup listener, "
167		       "rdma_create_id() returned %d\n", ret);
168		return ret;
169	}
170
171	sin.sin_family = AF_INET,
172	sin.sin_addr.s_addr = (__force u32)htonl(INADDR_ANY);
173	sin.sin_port = (__force u16)htons(RDS_PORT);
174
175	/*
176	 * XXX I bet this binds the cm_id to a device.  If we want to support
177	 * fail-over we'll have to take this into consideration.
178	 */
179	ret = rdma_bind_addr(cm_id, (struct sockaddr *)&sin);
180	if (ret) {
181		printk(KERN_ERR "RDS/RDMA: failed to setup listener, "
182		       "rdma_bind_addr() returned %d\n", ret);
183		goto out;
184	}
185
186	ret = rdma_listen(cm_id, 128);
187	if (ret) {
188		printk(KERN_ERR "RDS/RDMA: failed to setup listener, "
189		       "rdma_listen() returned %d\n", ret);
190		goto out;
191	}
192
193	rdsdebug("cm %p listening on port %u\n", cm_id, RDS_PORT);
194
195	rds_rdma_listen_id = cm_id;
196	cm_id = NULL;
197out:
198	if (cm_id)
199		rdma_destroy_id(cm_id);
200	return ret;
201}
202
203static void rds_rdma_listen_stop(void)
204{
205	if (rds_rdma_listen_id) {
206		rdsdebug("cm %p\n", rds_rdma_listen_id);
207		rdma_destroy_id(rds_rdma_listen_id);
208		rds_rdma_listen_id = NULL;
209	}
210}
211
212static int rds_rdma_init(void)
213{
214	int ret;
215
216	ret = rds_rdma_listen_init();
217	if (ret)
218		goto out;
219
220	ret = rds_iw_init();
221	if (ret)
222		goto err_iw_init;
223
224	ret = rds_ib_init();
225	if (ret)
226		goto err_ib_init;
227
228	goto out;
229
230err_ib_init:
231	rds_iw_exit();
232err_iw_init:
233	rds_rdma_listen_stop();
234out:
235	return ret;
236}
237module_init(rds_rdma_init);
238
239static void rds_rdma_exit(void)
240{
241	/* stop listening first to ensure no new connections are attempted */
242	rds_rdma_listen_stop();
243	rds_ib_exit();
244	rds_iw_exit();
245}
246module_exit(rds_rdma_exit);
247
248MODULE_AUTHOR("Oracle Corporation <rds-devel@oss.oracle.com>");
249MODULE_DESCRIPTION("RDS: IB/iWARP transport");
250MODULE_LICENSE("Dual BSD/GPL");
251
v4.17
  1/*
  2 * Copyright (c) 2009 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/module.h>
 34#include <rdma/rdma_cm.h>
 35
 36#include "rds_single_path.h"
 37#include "rdma_transport.h"
 38#include "ib.h"
 39
 40static struct rdma_cm_id *rds_rdma_listen_id;
 41
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 42int rds_rdma_cm_event_handler(struct rdma_cm_id *cm_id,
 43			      struct rdma_cm_event *event)
 44{
 45	/* this can be null in the listening path */
 46	struct rds_connection *conn = cm_id->context;
 47	struct rds_transport *trans;
 48	int ret = 0;
 49
 50	rdsdebug("conn %p id %p handling event %u (%s)\n", conn, cm_id,
 51		 event->event, rdma_event_msg(event->event));
 52
 53	if (cm_id->device->node_type == RDMA_NODE_IB_CA)
 
 
 54		trans = &rds_ib_transport;
 55
 56	/* Prevent shutdown from tearing down the connection
 57	 * while we're executing. */
 58	if (conn) {
 59		mutex_lock(&conn->c_cm_lock);
 60
 61		/* If the connection is being shut down, bail out
 62		 * right away. We return 0 so cm_id doesn't get
 63		 * destroyed prematurely */
 64		if (rds_conn_state(conn) == RDS_CONN_DISCONNECTING) {
 65			/* Reject incoming connections while we're tearing
 66			 * down an existing one. */
 67			if (event->event == RDMA_CM_EVENT_CONNECT_REQUEST)
 68				ret = 1;
 69			goto out;
 70		}
 71	}
 72
 73	switch (event->event) {
 74	case RDMA_CM_EVENT_CONNECT_REQUEST:
 75		ret = trans->cm_handle_connect(cm_id, event);
 76		break;
 77
 78	case RDMA_CM_EVENT_ADDR_RESOLVED:
 79		/* XXX do we need to clean up if this fails? */
 80		ret = rdma_resolve_route(cm_id,
 81					 RDS_RDMA_RESOLVE_TIMEOUT_MS);
 82		break;
 83
 84	case RDMA_CM_EVENT_ROUTE_RESOLVED:
 85		/* Connection could have been dropped so make sure the
 86		 * cm_id is valid before proceeding
 87		 */
 88		if (conn) {
 89			struct rds_ib_connection *ibic;
 90
 91			ibic = conn->c_transport_data;
 92			if (ibic && ibic->i_cm_id == cm_id)
 93				ret = trans->cm_initiate_connect(cm_id);
 94			else
 95				rds_conn_drop(conn);
 96		}
 97		break;
 98
 99	case RDMA_CM_EVENT_ESTABLISHED:
100		trans->cm_connect_complete(conn, event);
101		break;
102
103	case RDMA_CM_EVENT_REJECTED:
104		rdsdebug("Connection rejected: %s\n",
105			 rdma_reject_msg(cm_id, event->status));
106		/* FALLTHROUGH */
107	case RDMA_CM_EVENT_ADDR_ERROR:
108	case RDMA_CM_EVENT_ROUTE_ERROR:
109	case RDMA_CM_EVENT_CONNECT_ERROR:
110	case RDMA_CM_EVENT_UNREACHABLE:
 
111	case RDMA_CM_EVENT_DEVICE_REMOVAL:
112	case RDMA_CM_EVENT_ADDR_CHANGE:
113		if (conn)
114			rds_conn_drop(conn);
115		break;
116
117	case RDMA_CM_EVENT_DISCONNECTED:
118		rdsdebug("DISCONNECT event - dropping connection "
119			"%pI4->%pI4\n", &conn->c_laddr,
120			 &conn->c_faddr);
121		rds_conn_drop(conn);
122		break;
123
124	case RDMA_CM_EVENT_TIMEWAIT_EXIT:
125		if (conn) {
126			pr_info("RDS: RDMA_CM_EVENT_TIMEWAIT_EXIT event: dropping connection %pI4->%pI4\n",
127				&conn->c_laddr, &conn->c_faddr);
128			rds_conn_drop(conn);
129		}
130		break;
131
132	default:
133		/* things like device disconnect? */
134		printk(KERN_ERR "RDS: unknown event %u (%s)!\n",
135		       event->event, rdma_event_msg(event->event));
136		break;
137	}
138
139out:
140	if (conn)
141		mutex_unlock(&conn->c_cm_lock);
142
143	rdsdebug("id %p event %u (%s) handling ret %d\n", cm_id, event->event,
144		 rdma_event_msg(event->event), ret);
145
146	return ret;
147}
148
149static int rds_rdma_listen_init(void)
150{
151	struct sockaddr_in sin;
152	struct rdma_cm_id *cm_id;
153	int ret;
154
155	cm_id = rdma_create_id(&init_net, rds_rdma_cm_event_handler, NULL,
156			       RDMA_PS_TCP, IB_QPT_RC);
157	if (IS_ERR(cm_id)) {
158		ret = PTR_ERR(cm_id);
159		printk(KERN_ERR "RDS/RDMA: failed to setup listener, "
160		       "rdma_create_id() returned %d\n", ret);
161		return ret;
162	}
163
164	sin.sin_family = AF_INET;
165	sin.sin_addr.s_addr = (__force u32)htonl(INADDR_ANY);
166	sin.sin_port = (__force u16)htons(RDS_PORT);
167
168	/*
169	 * XXX I bet this binds the cm_id to a device.  If we want to support
170	 * fail-over we'll have to take this into consideration.
171	 */
172	ret = rdma_bind_addr(cm_id, (struct sockaddr *)&sin);
173	if (ret) {
174		printk(KERN_ERR "RDS/RDMA: failed to setup listener, "
175		       "rdma_bind_addr() returned %d\n", ret);
176		goto out;
177	}
178
179	ret = rdma_listen(cm_id, 128);
180	if (ret) {
181		printk(KERN_ERR "RDS/RDMA: failed to setup listener, "
182		       "rdma_listen() returned %d\n", ret);
183		goto out;
184	}
185
186	rdsdebug("cm %p listening on port %u\n", cm_id, RDS_PORT);
187
188	rds_rdma_listen_id = cm_id;
189	cm_id = NULL;
190out:
191	if (cm_id)
192		rdma_destroy_id(cm_id);
193	return ret;
194}
195
196static void rds_rdma_listen_stop(void)
197{
198	if (rds_rdma_listen_id) {
199		rdsdebug("cm %p\n", rds_rdma_listen_id);
200		rdma_destroy_id(rds_rdma_listen_id);
201		rds_rdma_listen_id = NULL;
202	}
203}
204
205static int rds_rdma_init(void)
206{
207	int ret;
208
209	ret = rds_ib_init();
210	if (ret)
211		goto out;
212
213	ret = rds_rdma_listen_init();
 
 
 
 
214	if (ret)
215		rds_ib_exit();
 
 
 
 
 
 
 
216out:
217	return ret;
218}
219module_init(rds_rdma_init);
220
221static void rds_rdma_exit(void)
222{
223	/* stop listening first to ensure no new connections are attempted */
224	rds_rdma_listen_stop();
225	rds_ib_exit();
 
226}
227module_exit(rds_rdma_exit);
228
229MODULE_AUTHOR("Oracle Corporation <rds-devel@oss.oracle.com>");
230MODULE_DESCRIPTION("RDS: IB transport");
231MODULE_LICENSE("Dual BSD/GPL");
232