diff options
-rw-r--r-- | net/rds/rdma_transport.c | 214 | ||||
-rw-r--r-- | net/rds/rdma_transport.h | 28 |
2 files changed, 242 insertions, 0 deletions
diff --git a/net/rds/rdma_transport.c b/net/rds/rdma_transport.c new file mode 100644 index 000000000000..7b19024f9706 --- /dev/null +++ b/net/rds/rdma_transport.c | |||
@@ -0,0 +1,214 @@ | |||
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 <rdma/rdma_cm.h> | ||
34 | |||
35 | #include "rdma_transport.h" | ||
36 | |||
37 | static struct rdma_cm_id *rds_iw_listen_id; | ||
38 | |||
39 | int rds_rdma_cm_event_handler(struct rdma_cm_id *cm_id, | ||
40 | struct rdma_cm_event *event) | ||
41 | { | ||
42 | /* this can be null in the listening path */ | ||
43 | struct rds_connection *conn = cm_id->context; | ||
44 | struct rds_transport *trans; | ||
45 | int ret = 0; | ||
46 | |||
47 | rdsdebug("conn %p id %p handling event %u\n", conn, cm_id, | ||
48 | event->event); | ||
49 | |||
50 | if (cm_id->device->node_type == RDMA_NODE_RNIC) | ||
51 | trans = &rds_iw_transport; | ||
52 | else | ||
53 | trans = &rds_ib_transport; | ||
54 | |||
55 | /* Prevent shutdown from tearing down the connection | ||
56 | * while we're executing. */ | ||
57 | if (conn) { | ||
58 | mutex_lock(&conn->c_cm_lock); | ||
59 | |||
60 | /* If the connection is being shut down, bail out | ||
61 | * right away. We return 0 so cm_id doesn't get | ||
62 | * destroyed prematurely */ | ||
63 | if (rds_conn_state(conn) == RDS_CONN_DISCONNECTING) { | ||
64 | /* Reject incoming connections while we're tearing | ||
65 | * down an existing one. */ | ||
66 | if (event->event == RDMA_CM_EVENT_CONNECT_REQUEST) | ||
67 | ret = 1; | ||
68 | goto out; | ||
69 | } | ||
70 | } | ||
71 | |||
72 | switch (event->event) { | ||
73 | case RDMA_CM_EVENT_CONNECT_REQUEST: | ||
74 | ret = trans->cm_handle_connect(cm_id, event); | ||
75 | break; | ||
76 | |||
77 | case RDMA_CM_EVENT_ADDR_RESOLVED: | ||
78 | /* XXX do we need to clean up if this fails? */ | ||
79 | ret = rdma_resolve_route(cm_id, | ||
80 | RDS_RDMA_RESOLVE_TIMEOUT_MS); | ||
81 | break; | ||
82 | |||
83 | case RDMA_CM_EVENT_ROUTE_RESOLVED: | ||
84 | /* XXX worry about racing with listen acceptance */ | ||
85 | ret = trans->cm_initiate_connect(cm_id); | ||
86 | break; | ||
87 | |||
88 | case RDMA_CM_EVENT_ESTABLISHED: | ||
89 | trans->cm_connect_complete(conn, event); | ||
90 | break; | ||
91 | |||
92 | case RDMA_CM_EVENT_ADDR_ERROR: | ||
93 | case RDMA_CM_EVENT_ROUTE_ERROR: | ||
94 | case RDMA_CM_EVENT_CONNECT_ERROR: | ||
95 | case RDMA_CM_EVENT_UNREACHABLE: | ||
96 | case RDMA_CM_EVENT_REJECTED: | ||
97 | case RDMA_CM_EVENT_DEVICE_REMOVAL: | ||
98 | case RDMA_CM_EVENT_ADDR_CHANGE: | ||
99 | if (conn) | ||
100 | rds_conn_drop(conn); | ||
101 | break; | ||
102 | |||
103 | case RDMA_CM_EVENT_DISCONNECTED: | ||
104 | printk(KERN_WARNING "RDS/IW: DISCONNECT event - dropping connection " | ||
105 | "%pI4->%pI4\n", &conn->c_laddr, | ||
106 | &conn->c_faddr); | ||
107 | rds_conn_drop(conn); | ||
108 | break; | ||
109 | |||
110 | default: | ||
111 | /* things like device disconnect? */ | ||
112 | printk(KERN_ERR "unknown event %u\n", event->event); | ||
113 | BUG(); | ||
114 | break; | ||
115 | } | ||
116 | |||
117 | out: | ||
118 | if (conn) | ||
119 | mutex_unlock(&conn->c_cm_lock); | ||
120 | |||
121 | rdsdebug("id %p event %u handling ret %d\n", cm_id, event->event, ret); | ||
122 | |||
123 | return ret; | ||
124 | } | ||
125 | |||
126 | static int __init rds_rdma_listen_init(void) | ||
127 | { | ||
128 | struct sockaddr_in sin; | ||
129 | struct rdma_cm_id *cm_id; | ||
130 | int ret; | ||
131 | |||
132 | cm_id = rdma_create_id(rds_rdma_cm_event_handler, NULL, RDMA_PS_TCP); | ||
133 | if (IS_ERR(cm_id)) { | ||
134 | ret = PTR_ERR(cm_id); | ||
135 | printk(KERN_ERR "RDS/IW: failed to setup listener, " | ||
136 | "rdma_create_id() returned %d\n", ret); | ||
137 | goto out; | ||
138 | } | ||
139 | |||
140 | sin.sin_family = PF_INET, | ||
141 | sin.sin_addr.s_addr = (__force u32)htonl(INADDR_ANY); | ||
142 | sin.sin_port = (__force u16)htons(RDS_PORT); | ||
143 | |||
144 | /* | ||
145 | * XXX I bet this binds the cm_id to a device. If we want to support | ||
146 | * fail-over we'll have to take this into consideration. | ||
147 | */ | ||
148 | ret = rdma_bind_addr(cm_id, (struct sockaddr *)&sin); | ||
149 | if (ret) { | ||
150 | printk(KERN_ERR "RDS/IW: failed to setup listener, " | ||
151 | "rdma_bind_addr() returned %d\n", ret); | ||
152 | goto out; | ||
153 | } | ||
154 | |||
155 | ret = rdma_listen(cm_id, 128); | ||
156 | if (ret) { | ||
157 | printk(KERN_ERR "RDS/IW: failed to setup listener, " | ||
158 | "rdma_listen() returned %d\n", ret); | ||
159 | goto out; | ||
160 | } | ||
161 | |||
162 | rdsdebug("cm %p listening on port %u\n", cm_id, RDS_PORT); | ||
163 | |||
164 | rds_iw_listen_id = cm_id; | ||
165 | cm_id = NULL; | ||
166 | out: | ||
167 | if (cm_id) | ||
168 | rdma_destroy_id(cm_id); | ||
169 | return ret; | ||
170 | } | ||
171 | |||
172 | static void rds_rdma_listen_stop(void) | ||
173 | { | ||
174 | if (rds_iw_listen_id) { | ||
175 | rdsdebug("cm %p\n", rds_iw_listen_id); | ||
176 | rdma_destroy_id(rds_iw_listen_id); | ||
177 | rds_iw_listen_id = NULL; | ||
178 | } | ||
179 | } | ||
180 | |||
181 | int __init rds_rdma_init(void) | ||
182 | { | ||
183 | int ret; | ||
184 | |||
185 | ret = rds_rdma_listen_init(); | ||
186 | if (ret) | ||
187 | goto out; | ||
188 | |||
189 | ret = rds_iw_init(); | ||
190 | if (ret) | ||
191 | goto err_iw_init; | ||
192 | |||
193 | ret = rds_ib_init(); | ||
194 | if (ret) | ||
195 | goto err_ib_init; | ||
196 | |||
197 | goto out; | ||
198 | |||
199 | err_ib_init: | ||
200 | rds_iw_exit(); | ||
201 | err_iw_init: | ||
202 | rds_rdma_listen_stop(); | ||
203 | out: | ||
204 | return ret; | ||
205 | } | ||
206 | |||
207 | void rds_rdma_exit(void) | ||
208 | { | ||
209 | /* stop listening first to ensure no new connections are attempted */ | ||
210 | rds_rdma_listen_stop(); | ||
211 | rds_ib_exit(); | ||
212 | rds_iw_exit(); | ||
213 | } | ||
214 | |||
diff --git a/net/rds/rdma_transport.h b/net/rds/rdma_transport.h new file mode 100644 index 000000000000..2f2c7d976c21 --- /dev/null +++ b/net/rds/rdma_transport.h | |||
@@ -0,0 +1,28 @@ | |||
1 | #ifndef _RDMA_TRANSPORT_H | ||
2 | #define _RDMA_TRANSPORT_H | ||
3 | |||
4 | #include <rdma/ib_verbs.h> | ||
5 | #include <rdma/rdma_cm.h> | ||
6 | #include "rds.h" | ||
7 | |||
8 | #define RDS_RDMA_RESOLVE_TIMEOUT_MS 5000 | ||
9 | |||
10 | int rds_rdma_conn_connect(struct rds_connection *conn); | ||
11 | int rds_rdma_cm_event_handler(struct rdma_cm_id *cm_id, | ||
12 | struct rdma_cm_event *event); | ||
13 | |||
14 | /* from rdma_transport.c */ | ||
15 | int rds_rdma_init(void); | ||
16 | void rds_rdma_exit(void); | ||
17 | |||
18 | /* from ib.c */ | ||
19 | extern struct rds_transport rds_ib_transport; | ||
20 | int rds_ib_init(void); | ||
21 | void rds_ib_exit(void); | ||
22 | |||
23 | /* from iw.c */ | ||
24 | extern struct rds_transport rds_iw_transport; | ||
25 | int rds_iw_init(void); | ||
26 | void rds_iw_exit(void); | ||
27 | |||
28 | #endif | ||