Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
c2_cm.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2005 Ammasso, Inc. All rights reserved.
3  * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
4  *
5  * This software is available to you under a choice of one of two
6  * licenses. You may choose to be licensed under the terms of the GNU
7  * General Public License (GPL) Version 2, available from the file
8  * COPYING in the main directory of this source tree, or the
9  * OpenIB.org BSD license below:
10  *
11  * Redistribution and use in source and binary forms, with or
12  * without modification, are permitted provided that the following
13  * conditions are met:
14  *
15  * - Redistributions of source code must retain the above
16  * copyright notice, this list of conditions and the following
17  * disclaimer.
18  *
19  * - Redistributions in binary form must reproduce the above
20  * copyright notice, this list of conditions and the following
21  * disclaimer in the documentation and/or other materials
22  * provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  *
33  */
34 #include <linux/slab.h>
35 
36 #include "c2.h"
37 #include "c2_wr.h"
38 #include "c2_vq.h"
39 #include <rdma/iw_cm.h>
40 
42 {
43  struct c2_dev *c2dev = to_c2dev(cm_id->device);
44  struct ib_qp *ibqp;
45  struct c2_qp *qp;
46  struct c2wr_qp_connect_req *wr; /* variable size needs a malloc. */
47  struct c2_vq_req *vq_req;
48  int err;
49 
50  ibqp = c2_get_qp(cm_id->device, iw_param->qpn);
51  if (!ibqp)
52  return -EINVAL;
53  qp = to_c2qp(ibqp);
54 
55  /* Associate QP <--> CM_ID */
56  cm_id->provider_data = qp;
57  cm_id->add_ref(cm_id);
58  qp->cm_id = cm_id;
59 
60  /*
61  * only support the max private_data length
62  */
64  err = -EINVAL;
65  goto bail0;
66  }
67  /*
68  * Set the rdma read limits
69  */
70  err = c2_qp_set_read_limits(c2dev, qp, iw_param->ord, iw_param->ird);
71  if (err)
72  goto bail0;
73 
74  /*
75  * Create and send a WR_QP_CONNECT...
76  */
77  wr = kmalloc(c2dev->req_vq.msg_size, GFP_KERNEL);
78  if (!wr) {
79  err = -ENOMEM;
80  goto bail0;
81  }
82 
83  vq_req = vq_req_alloc(c2dev);
84  if (!vq_req) {
85  err = -ENOMEM;
86  goto bail1;
87  }
88 
89  c2_wr_set_id(wr, CCWR_QP_CONNECT);
90  wr->hdr.context = 0;
91  wr->rnic_handle = c2dev->adapter_handle;
92  wr->qp_handle = qp->adapter_handle;
93 
94  wr->remote_addr = cm_id->remote_addr.sin_addr.s_addr;
95  wr->remote_port = cm_id->remote_addr.sin_port;
96 
97  /*
98  * Move any private data from the callers's buf into
99  * the WR.
100  */
101  if (iw_param->private_data) {
102  wr->private_data_length =
103  cpu_to_be32(iw_param->private_data_len);
104  memcpy(&wr->private_data[0], iw_param->private_data,
105  iw_param->private_data_len);
106  } else
107  wr->private_data_length = 0;
108 
109  /*
110  * Send WR to adapter. NOTE: There is no synch reply from
111  * the adapter.
112  */
113  err = vq_send_wr(c2dev, (union c2wr *) wr);
114  vq_req_free(c2dev, vq_req);
115 
116  bail1:
117  kfree(wr);
118  bail0:
119  if (err) {
120  /*
121  * If we fail, release reference on QP and
122  * disassociate QP from CM_ID
123  */
124  cm_id->provider_data = NULL;
125  qp->cm_id = NULL;
126  cm_id->rem_ref(cm_id);
127  }
128  return err;
129 }
130 
132 {
133  struct c2_dev *c2dev;
134  struct c2wr_ep_listen_create_req wr;
135  struct c2wr_ep_listen_create_rep *reply;
136  struct c2_vq_req *vq_req;
137  int err;
138 
139  c2dev = to_c2dev(cm_id->device);
140  if (c2dev == NULL)
141  return -EINVAL;
142 
143  /*
144  * Allocate verbs request.
145  */
146  vq_req = vq_req_alloc(c2dev);
147  if (!vq_req)
148  return -ENOMEM;
149 
150  /*
151  * Build the WR
152  */
153  c2_wr_set_id(&wr, CCWR_EP_LISTEN_CREATE);
154  wr.hdr.context = (u64) (unsigned long) vq_req;
155  wr.rnic_handle = c2dev->adapter_handle;
156  wr.local_addr = cm_id->local_addr.sin_addr.s_addr;
157  wr.local_port = cm_id->local_addr.sin_port;
158  wr.backlog = cpu_to_be32(backlog);
159  wr.user_context = (u64) (unsigned long) cm_id;
160 
161  /*
162  * Reference the request struct. Dereferenced in the int handler.
163  */
164  vq_req_get(c2dev, vq_req);
165 
166  /*
167  * Send WR to adapter
168  */
169  err = vq_send_wr(c2dev, (union c2wr *) & wr);
170  if (err) {
171  vq_req_put(c2dev, vq_req);
172  goto bail0;
173  }
174 
175  /*
176  * Wait for reply from adapter
177  */
178  err = vq_wait_for_reply(c2dev, vq_req);
179  if (err)
180  goto bail0;
181 
182  /*
183  * Process reply
184  */
185  reply =
186  (struct c2wr_ep_listen_create_rep *) (unsigned long) vq_req->reply_msg;
187  if (!reply) {
188  err = -ENOMEM;
189  goto bail1;
190  }
191 
192  if ((err = c2_errno(reply)) != 0)
193  goto bail1;
194 
195  /*
196  * Keep the adapter handle. Used in subsequent destroy
197  */
198  cm_id->provider_data = (void*)(unsigned long) reply->ep_handle;
199 
200  /*
201  * free vq stuff
202  */
203  vq_repbuf_free(c2dev, reply);
204  vq_req_free(c2dev, vq_req);
205 
206  return 0;
207 
208  bail1:
209  vq_repbuf_free(c2dev, reply);
210  bail0:
211  vq_req_free(c2dev, vq_req);
212  return err;
213 }
214 
215 
217 {
218 
219  struct c2_dev *c2dev;
220  struct c2wr_ep_listen_destroy_req wr;
221  struct c2wr_ep_listen_destroy_rep *reply;
222  struct c2_vq_req *vq_req;
223  int err;
224 
225  c2dev = to_c2dev(cm_id->device);
226  if (c2dev == NULL)
227  return -EINVAL;
228 
229  /*
230  * Allocate verbs request.
231  */
232  vq_req = vq_req_alloc(c2dev);
233  if (!vq_req)
234  return -ENOMEM;
235 
236  /*
237  * Build the WR
238  */
239  c2_wr_set_id(&wr, CCWR_EP_LISTEN_DESTROY);
240  wr.hdr.context = (unsigned long) vq_req;
241  wr.rnic_handle = c2dev->adapter_handle;
242  wr.ep_handle = (u32)(unsigned long)cm_id->provider_data;
243 
244  /*
245  * reference the request struct. dereferenced in the int handler.
246  */
247  vq_req_get(c2dev, vq_req);
248 
249  /*
250  * Send WR to adapter
251  */
252  err = vq_send_wr(c2dev, (union c2wr *) & wr);
253  if (err) {
254  vq_req_put(c2dev, vq_req);
255  goto bail0;
256  }
257 
258  /*
259  * Wait for reply from adapter
260  */
261  err = vq_wait_for_reply(c2dev, vq_req);
262  if (err)
263  goto bail0;
264 
265  /*
266  * Process reply
267  */
268  reply=(struct c2wr_ep_listen_destroy_rep *)(unsigned long)vq_req->reply_msg;
269  if (!reply) {
270  err = -ENOMEM;
271  goto bail0;
272  }
273  if ((err = c2_errno(reply)) != 0)
274  goto bail1;
275 
276  bail1:
277  vq_repbuf_free(c2dev, reply);
278  bail0:
279  vq_req_free(c2dev, vq_req);
280  return err;
281 }
282 
284 {
285  struct c2_dev *c2dev = to_c2dev(cm_id->device);
286  struct c2_qp *qp;
287  struct ib_qp *ibqp;
288  struct c2wr_cr_accept_req *wr; /* variable length WR */
289  struct c2_vq_req *vq_req;
290  struct c2wr_cr_accept_rep *reply; /* VQ Reply msg ptr. */
291  int err;
292 
293  ibqp = c2_get_qp(cm_id->device, iw_param->qpn);
294  if (!ibqp)
295  return -EINVAL;
296  qp = to_c2qp(ibqp);
297 
298  /* Set the RDMA read limits */
299  err = c2_qp_set_read_limits(c2dev, qp, iw_param->ord, iw_param->ird);
300  if (err)
301  goto bail0;
302 
303  /* Allocate verbs request. */
304  vq_req = vq_req_alloc(c2dev);
305  if (!vq_req) {
306  err = -ENOMEM;
307  goto bail0;
308  }
309  vq_req->qp = qp;
310  vq_req->cm_id = cm_id;
311  vq_req->event = IW_CM_EVENT_ESTABLISHED;
312 
313  wr = kmalloc(c2dev->req_vq.msg_size, GFP_KERNEL);
314  if (!wr) {
315  err = -ENOMEM;
316  goto bail1;
317  }
318 
319  /* Build the WR */
320  c2_wr_set_id(wr, CCWR_CR_ACCEPT);
321  wr->hdr.context = (unsigned long) vq_req;
322  wr->rnic_handle = c2dev->adapter_handle;
323  wr->ep_handle = (u32) (unsigned long) cm_id->provider_data;
324  wr->qp_handle = qp->adapter_handle;
325 
326  /* Replace the cr_handle with the QP after accept */
327  cm_id->provider_data = qp;
328  cm_id->add_ref(cm_id);
329  qp->cm_id = cm_id;
330 
331  cm_id->provider_data = qp;
332 
333  /* Validate private_data length */
334  if (iw_param->private_data_len > C2_MAX_PRIVATE_DATA_SIZE) {
335  err = -EINVAL;
336  goto bail1;
337  }
338 
339  if (iw_param->private_data) {
341  memcpy(&wr->private_data[0],
342  iw_param->private_data, iw_param->private_data_len);
343  } else
344  wr->private_data_length = 0;
345 
346  /* Reference the request struct. Dereferenced in the int handler. */
347  vq_req_get(c2dev, vq_req);
348 
349  /* Send WR to adapter */
350  err = vq_send_wr(c2dev, (union c2wr *) wr);
351  if (err) {
352  vq_req_put(c2dev, vq_req);
353  goto bail1;
354  }
355 
356  /* Wait for reply from adapter */
357  err = vq_wait_for_reply(c2dev, vq_req);
358  if (err)
359  goto bail1;
360 
361  /* Check that reply is present */
362  reply = (struct c2wr_cr_accept_rep *) (unsigned long) vq_req->reply_msg;
363  if (!reply) {
364  err = -ENOMEM;
365  goto bail1;
366  }
367 
368  err = c2_errno(reply);
369  vq_repbuf_free(c2dev, reply);
370 
371  if (!err)
373  bail1:
374  kfree(wr);
375  vq_req_free(c2dev, vq_req);
376  bail0:
377  if (err) {
378  /*
379  * If we fail, release reference on QP and
380  * disassociate QP from CM_ID
381  */
382  cm_id->provider_data = NULL;
383  qp->cm_id = NULL;
384  cm_id->rem_ref(cm_id);
385  }
386  return err;
387 }
388 
389 int c2_llp_reject(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
390 {
391  struct c2_dev *c2dev;
392  struct c2wr_cr_reject_req wr;
393  struct c2_vq_req *vq_req;
394  struct c2wr_cr_reject_rep *reply;
395  int err;
396 
397  c2dev = to_c2dev(cm_id->device);
398 
399  /*
400  * Allocate verbs request.
401  */
402  vq_req = vq_req_alloc(c2dev);
403  if (!vq_req)
404  return -ENOMEM;
405 
406  /*
407  * Build the WR
408  */
409  c2_wr_set_id(&wr, CCWR_CR_REJECT);
410  wr.hdr.context = (unsigned long) vq_req;
411  wr.rnic_handle = c2dev->adapter_handle;
412  wr.ep_handle = (u32) (unsigned long) cm_id->provider_data;
413 
414  /*
415  * reference the request struct. dereferenced in the int handler.
416  */
417  vq_req_get(c2dev, vq_req);
418 
419  /*
420  * Send WR to adapter
421  */
422  err = vq_send_wr(c2dev, (union c2wr *) & wr);
423  if (err) {
424  vq_req_put(c2dev, vq_req);
425  goto bail0;
426  }
427 
428  /*
429  * Wait for reply from adapter
430  */
431  err = vq_wait_for_reply(c2dev, vq_req);
432  if (err)
433  goto bail0;
434 
435  /*
436  * Process reply
437  */
438  reply = (struct c2wr_cr_reject_rep *) (unsigned long)
439  vq_req->reply_msg;
440  if (!reply) {
441  err = -ENOMEM;
442  goto bail0;
443  }
444  err = c2_errno(reply);
445  /*
446  * free vq stuff
447  */
448  vq_repbuf_free(c2dev, reply);
449 
450  bail0:
451  vq_req_free(c2dev, vq_req);
452  return err;
453 }