Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
verbs.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2004 Mellanox Technologies Ltd. All rights reserved.
3  * Copyright (c) 2004 Infinicon Corporation. All rights reserved.
4  * Copyright (c) 2004 Intel Corporation. All rights reserved.
5  * Copyright (c) 2004 Topspin Corporation. All rights reserved.
6  * Copyright (c) 2004 Voltaire Corporation. All rights reserved.
7  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
8  * Copyright (c) 2005, 2006 Cisco Systems. All rights reserved.
9  *
10  * This software is available to you under a choice of one of two
11  * licenses. You may choose to be licensed under the terms of the GNU
12  * General Public License (GPL) Version 2, available from the file
13  * COPYING in the main directory of this source tree, or the
14  * OpenIB.org BSD license below:
15  *
16  * Redistribution and use in source and binary forms, with or
17  * without modification, are permitted provided that the following
18  * conditions are met:
19  *
20  * - Redistributions of source code must retain the above
21  * copyright notice, this list of conditions and the following
22  * disclaimer.
23  *
24  * - Redistributions in binary form must reproduce the above
25  * copyright notice, this list of conditions and the following
26  * disclaimer in the documentation and/or other materials
27  * provided with the distribution.
28  *
29  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
30  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
31  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
32  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
33  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
34  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
35  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
36  * SOFTWARE.
37  */
38 
39 #include <linux/errno.h>
40 #include <linux/err.h>
41 #include <linux/export.h>
42 #include <linux/string.h>
43 #include <linux/slab.h>
44 
45 #include <rdma/ib_verbs.h>
46 #include <rdma/ib_cache.h>
47 
48 int ib_rate_to_mult(enum ib_rate rate)
49 {
50  switch (rate) {
51  case IB_RATE_2_5_GBPS: return 1;
52  case IB_RATE_5_GBPS: return 2;
53  case IB_RATE_10_GBPS: return 4;
54  case IB_RATE_20_GBPS: return 8;
55  case IB_RATE_30_GBPS: return 12;
56  case IB_RATE_40_GBPS: return 16;
57  case IB_RATE_60_GBPS: return 24;
58  case IB_RATE_80_GBPS: return 32;
59  case IB_RATE_120_GBPS: return 48;
60  default: return -1;
61  }
62 }
63 EXPORT_SYMBOL(ib_rate_to_mult);
64 
65 enum ib_rate mult_to_ib_rate(int mult)
66 {
67  switch (mult) {
68  case 1: return IB_RATE_2_5_GBPS;
69  case 2: return IB_RATE_5_GBPS;
70  case 4: return IB_RATE_10_GBPS;
71  case 8: return IB_RATE_20_GBPS;
72  case 12: return IB_RATE_30_GBPS;
73  case 16: return IB_RATE_40_GBPS;
74  case 24: return IB_RATE_60_GBPS;
75  case 32: return IB_RATE_80_GBPS;
76  case 48: return IB_RATE_120_GBPS;
77  default: return IB_RATE_PORT_CURRENT;
78  }
79 }
80 EXPORT_SYMBOL(mult_to_ib_rate);
81 
82 int ib_rate_to_mbps(enum ib_rate rate)
83 {
84  switch (rate) {
85  case IB_RATE_2_5_GBPS: return 2500;
86  case IB_RATE_5_GBPS: return 5000;
87  case IB_RATE_10_GBPS: return 10000;
88  case IB_RATE_20_GBPS: return 20000;
89  case IB_RATE_30_GBPS: return 30000;
90  case IB_RATE_40_GBPS: return 40000;
91  case IB_RATE_60_GBPS: return 60000;
92  case IB_RATE_80_GBPS: return 80000;
93  case IB_RATE_120_GBPS: return 120000;
94  case IB_RATE_14_GBPS: return 14062;
95  case IB_RATE_56_GBPS: return 56250;
96  case IB_RATE_112_GBPS: return 112500;
97  case IB_RATE_168_GBPS: return 168750;
98  case IB_RATE_25_GBPS: return 25781;
99  case IB_RATE_100_GBPS: return 103125;
100  case IB_RATE_200_GBPS: return 206250;
101  case IB_RATE_300_GBPS: return 309375;
102  default: return -1;
103  }
104 }
105 EXPORT_SYMBOL(ib_rate_to_mbps);
106 
107 enum rdma_transport_type
108 rdma_node_get_transport(enum rdma_node_type node_type)
109 {
110  switch (node_type) {
111  case RDMA_NODE_IB_CA:
112  case RDMA_NODE_IB_SWITCH:
113  case RDMA_NODE_IB_ROUTER:
114  return RDMA_TRANSPORT_IB;
115  case RDMA_NODE_RNIC:
116  return RDMA_TRANSPORT_IWARP;
117  default:
118  BUG();
119  return 0;
120  }
121 }
122 EXPORT_SYMBOL(rdma_node_get_transport);
123 
124 enum rdma_link_layer rdma_port_get_link_layer(struct ib_device *device, u8 port_num)
125 {
126  if (device->get_link_layer)
127  return device->get_link_layer(device, port_num);
128 
129  switch (rdma_node_get_transport(device->node_type)) {
130  case RDMA_TRANSPORT_IB:
131  return IB_LINK_LAYER_INFINIBAND;
132  case RDMA_TRANSPORT_IWARP:
133  return IB_LINK_LAYER_ETHERNET;
134  default:
135  return IB_LINK_LAYER_UNSPECIFIED;
136  }
137 }
138 EXPORT_SYMBOL(rdma_port_get_link_layer);
139 
140 /* Protection domains */
141 
142 struct ib_pd *ib_alloc_pd(struct ib_device *device)
143 {
144  struct ib_pd *pd;
145 
146  pd = device->alloc_pd(device, NULL, NULL);
147 
148  if (!IS_ERR(pd)) {
149  pd->device = device;
150  pd->uobject = NULL;
151  atomic_set(&pd->usecnt, 0);
152  }
153 
154  return pd;
155 }
156 EXPORT_SYMBOL(ib_alloc_pd);
157 
158 int ib_dealloc_pd(struct ib_pd *pd)
159 {
160  if (atomic_read(&pd->usecnt))
161  return -EBUSY;
162 
163  return pd->device->dealloc_pd(pd);
164 }
165 EXPORT_SYMBOL(ib_dealloc_pd);
166 
167 /* Address handles */
168 
169 struct ib_ah *ib_create_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr)
170 {
171  struct ib_ah *ah;
172 
173  ah = pd->device->create_ah(pd, ah_attr);
174 
175  if (!IS_ERR(ah)) {
176  ah->device = pd->device;
177  ah->pd = pd;
178  ah->uobject = NULL;
179  atomic_inc(&pd->usecnt);
180  }
181 
182  return ah;
183 }
184 EXPORT_SYMBOL(ib_create_ah);
185 
186 int ib_init_ah_from_wc(struct ib_device *device, u8 port_num, struct ib_wc *wc,
187  struct ib_grh *grh, struct ib_ah_attr *ah_attr)
188 {
189  u32 flow_class;
190  u16 gid_index;
191  int ret;
192 
193  memset(ah_attr, 0, sizeof *ah_attr);
194  ah_attr->dlid = wc->slid;
195  ah_attr->sl = wc->sl;
196  ah_attr->src_path_bits = wc->dlid_path_bits;
197  ah_attr->port_num = port_num;
198 
199  if (wc->wc_flags & IB_WC_GRH) {
200  ah_attr->ah_flags = IB_AH_GRH;
201  ah_attr->grh.dgid = grh->sgid;
202 
203  ret = ib_find_cached_gid(device, &grh->dgid, &port_num,
204  &gid_index);
205  if (ret)
206  return ret;
207 
208  ah_attr->grh.sgid_index = (u8) gid_index;
209  flow_class = be32_to_cpu(grh->version_tclass_flow);
210  ah_attr->grh.flow_label = flow_class & 0xFFFFF;
211  ah_attr->grh.hop_limit = 0xFF;
212  ah_attr->grh.traffic_class = (flow_class >> 20) & 0xFF;
213  }
214  return 0;
215 }
216 EXPORT_SYMBOL(ib_init_ah_from_wc);
217 
218 struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, struct ib_wc *wc,
219  struct ib_grh *grh, u8 port_num)
220 {
221  struct ib_ah_attr ah_attr;
222  int ret;
223 
224  ret = ib_init_ah_from_wc(pd->device, port_num, wc, grh, &ah_attr);
225  if (ret)
226  return ERR_PTR(ret);
227 
228  return ib_create_ah(pd, &ah_attr);
229 }
230 EXPORT_SYMBOL(ib_create_ah_from_wc);
231 
232 int ib_modify_ah(struct ib_ah *ah, struct ib_ah_attr *ah_attr)
233 {
234  return ah->device->modify_ah ?
235  ah->device->modify_ah(ah, ah_attr) :
236  -ENOSYS;
237 }
238 EXPORT_SYMBOL(ib_modify_ah);
239 
240 int ib_query_ah(struct ib_ah *ah, struct ib_ah_attr *ah_attr)
241 {
242  return ah->device->query_ah ?
243  ah->device->query_ah(ah, ah_attr) :
244  -ENOSYS;
245 }
246 EXPORT_SYMBOL(ib_query_ah);
247 
248 int ib_destroy_ah(struct ib_ah *ah)
249 {
250  struct ib_pd *pd;
251  int ret;
252 
253  pd = ah->pd;
254  ret = ah->device->destroy_ah(ah);
255  if (!ret)
256  atomic_dec(&pd->usecnt);
257 
258  return ret;
259 }
260 EXPORT_SYMBOL(ib_destroy_ah);
261 
262 /* Shared receive queues */
263 
264 struct ib_srq *ib_create_srq(struct ib_pd *pd,
265  struct ib_srq_init_attr *srq_init_attr)
266 {
267  struct ib_srq *srq;
268 
269  if (!pd->device->create_srq)
270  return ERR_PTR(-ENOSYS);
271 
272  srq = pd->device->create_srq(pd, srq_init_attr, NULL);
273 
274  if (!IS_ERR(srq)) {
275  srq->device = pd->device;
276  srq->pd = pd;
277  srq->uobject = NULL;
278  srq->event_handler = srq_init_attr->event_handler;
279  srq->srq_context = srq_init_attr->srq_context;
280  srq->srq_type = srq_init_attr->srq_type;
281  if (srq->srq_type == IB_SRQT_XRC) {
282  srq->ext.xrc.xrcd = srq_init_attr->ext.xrc.xrcd;
283  srq->ext.xrc.cq = srq_init_attr->ext.xrc.cq;
284  atomic_inc(&srq->ext.xrc.xrcd->usecnt);
285  atomic_inc(&srq->ext.xrc.cq->usecnt);
286  }
287  atomic_inc(&pd->usecnt);
288  atomic_set(&srq->usecnt, 0);
289  }
290 
291  return srq;
292 }
293 EXPORT_SYMBOL(ib_create_srq);
294 
295 int ib_modify_srq(struct ib_srq *srq,
296  struct ib_srq_attr *srq_attr,
297  enum ib_srq_attr_mask srq_attr_mask)
298 {
299  return srq->device->modify_srq ?
300  srq->device->modify_srq(srq, srq_attr, srq_attr_mask, NULL) :
301  -ENOSYS;
302 }
303 EXPORT_SYMBOL(ib_modify_srq);
304 
305 int ib_query_srq(struct ib_srq *srq,
306  struct ib_srq_attr *srq_attr)
307 {
308  return srq->device->query_srq ?
309  srq->device->query_srq(srq, srq_attr) : -ENOSYS;
310 }
311 EXPORT_SYMBOL(ib_query_srq);
312 
313 int ib_destroy_srq(struct ib_srq *srq)
314 {
315  struct ib_pd *pd;
316  enum ib_srq_type srq_type;
317  struct ib_xrcd *uninitialized_var(xrcd);
318  struct ib_cq *uninitialized_var(cq);
319  int ret;
320 
321  if (atomic_read(&srq->usecnt))
322  return -EBUSY;
323 
324  pd = srq->pd;
325  srq_type = srq->srq_type;
326  if (srq_type == IB_SRQT_XRC) {
327  xrcd = srq->ext.xrc.xrcd;
328  cq = srq->ext.xrc.cq;
329  }
330 
331  ret = srq->device->destroy_srq(srq);
332  if (!ret) {
333  atomic_dec(&pd->usecnt);
334  if (srq_type == IB_SRQT_XRC) {
335  atomic_dec(&xrcd->usecnt);
336  atomic_dec(&cq->usecnt);
337  }
338  }
339 
340  return ret;
341 }
342 EXPORT_SYMBOL(ib_destroy_srq);
343 
344 /* Queue pairs */
345 
346 static void __ib_shared_qp_event_handler(struct ib_event *event, void *context)
347 {
348  struct ib_qp *qp = context;
349 
350  list_for_each_entry(event->element.qp, &qp->open_list, open_list)
351  event->element.qp->event_handler(event, event->element.qp->qp_context);
352 }
353 
354 static void __ib_insert_xrcd_qp(struct ib_xrcd *xrcd, struct ib_qp *qp)
355 {
356  mutex_lock(&xrcd->tgt_qp_mutex);
357  list_add(&qp->xrcd_list, &xrcd->tgt_qp_list);
358  mutex_unlock(&xrcd->tgt_qp_mutex);
359 }
360 
361 static struct ib_qp *__ib_open_qp(struct ib_qp *real_qp,
362  void (*event_handler)(struct ib_event *, void *),
363  void *qp_context)
364 {
365  struct ib_qp *qp;
366  unsigned long flags;
367 
368  qp = kzalloc(sizeof *qp, GFP_KERNEL);
369  if (!qp)
370  return ERR_PTR(-ENOMEM);
371 
372  qp->real_qp = real_qp;
373  atomic_inc(&real_qp->usecnt);
374  qp->device = real_qp->device;
375  qp->event_handler = event_handler;
376  qp->qp_context = qp_context;
377  qp->qp_num = real_qp->qp_num;
378  qp->qp_type = real_qp->qp_type;
379 
380  spin_lock_irqsave(&real_qp->device->event_handler_lock, flags);
381  list_add(&qp->open_list, &real_qp->open_list);
382  spin_unlock_irqrestore(&real_qp->device->event_handler_lock, flags);
383 
384  return qp;
385 }
386 
387 struct ib_qp *ib_open_qp(struct ib_xrcd *xrcd,
388  struct ib_qp_open_attr *qp_open_attr)
389 {
390  struct ib_qp *qp, *real_qp;
391 
392  if (qp_open_attr->qp_type != IB_QPT_XRC_TGT)
393  return ERR_PTR(-EINVAL);
394 
395  qp = ERR_PTR(-EINVAL);
396  mutex_lock(&xrcd->tgt_qp_mutex);
397  list_for_each_entry(real_qp, &xrcd->tgt_qp_list, xrcd_list) {
398  if (real_qp->qp_num == qp_open_attr->qp_num) {
399  qp = __ib_open_qp(real_qp, qp_open_attr->event_handler,
400  qp_open_attr->qp_context);
401  break;
402  }
403  }
404  mutex_unlock(&xrcd->tgt_qp_mutex);
405  return qp;
406 }
407 EXPORT_SYMBOL(ib_open_qp);
408 
409 struct ib_qp *ib_create_qp(struct ib_pd *pd,
410  struct ib_qp_init_attr *qp_init_attr)
411 {
412  struct ib_qp *qp, *real_qp;
413  struct ib_device *device;
414 
415  device = pd ? pd->device : qp_init_attr->xrcd->device;
416  qp = device->create_qp(pd, qp_init_attr, NULL);
417 
418  if (!IS_ERR(qp)) {
419  qp->device = device;
420  qp->real_qp = qp;
421  qp->uobject = NULL;
422  qp->qp_type = qp_init_attr->qp_type;
423 
424  atomic_set(&qp->usecnt, 0);
425  if (qp_init_attr->qp_type == IB_QPT_XRC_TGT) {
426  qp->event_handler = __ib_shared_qp_event_handler;
427  qp->qp_context = qp;
428  qp->pd = NULL;
429  qp->send_cq = qp->recv_cq = NULL;
430  qp->srq = NULL;
431  qp->xrcd = qp_init_attr->xrcd;
432  atomic_inc(&qp_init_attr->xrcd->usecnt);
433  INIT_LIST_HEAD(&qp->open_list);
434 
435  real_qp = qp;
436  qp = __ib_open_qp(real_qp, qp_init_attr->event_handler,
437  qp_init_attr->qp_context);
438  if (!IS_ERR(qp))
439  __ib_insert_xrcd_qp(qp_init_attr->xrcd, real_qp);
440  else
441  real_qp->device->destroy_qp(real_qp);
442  } else {
443  qp->event_handler = qp_init_attr->event_handler;
444  qp->qp_context = qp_init_attr->qp_context;
445  if (qp_init_attr->qp_type == IB_QPT_XRC_INI) {
446  qp->recv_cq = NULL;
447  qp->srq = NULL;
448  } else {
449  qp->recv_cq = qp_init_attr->recv_cq;
450  atomic_inc(&qp_init_attr->recv_cq->usecnt);
451  qp->srq = qp_init_attr->srq;
452  if (qp->srq)
453  atomic_inc(&qp_init_attr->srq->usecnt);
454  }
455 
456  qp->pd = pd;
457  qp->send_cq = qp_init_attr->send_cq;
458  qp->xrcd = NULL;
459 
460  atomic_inc(&pd->usecnt);
461  atomic_inc(&qp_init_attr->send_cq->usecnt);
462  }
463  }
464 
465  return qp;
466 }
467 EXPORT_SYMBOL(ib_create_qp);
468 
469 static const struct {
470  int valid;
471  enum ib_qp_attr_mask req_param[IB_QPT_MAX];
472  enum ib_qp_attr_mask opt_param[IB_QPT_MAX];
473 } qp_state_table[IB_QPS_ERR + 1][IB_QPS_ERR + 1] = {
474  [IB_QPS_RESET] = {
475  [IB_QPS_RESET] = { .valid = 1 },
476  [IB_QPS_INIT] = {
477  .valid = 1,
478  .req_param = {
479  [IB_QPT_UD] = (IB_QP_PKEY_INDEX |
480  IB_QP_PORT |
481  IB_QP_QKEY),
482  [IB_QPT_RAW_PACKET] = IB_QP_PORT,
483  [IB_QPT_UC] = (IB_QP_PKEY_INDEX |
484  IB_QP_PORT |
485  IB_QP_ACCESS_FLAGS),
486  [IB_QPT_RC] = (IB_QP_PKEY_INDEX |
487  IB_QP_PORT |
488  IB_QP_ACCESS_FLAGS),
489  [IB_QPT_XRC_INI] = (IB_QP_PKEY_INDEX |
490  IB_QP_PORT |
491  IB_QP_ACCESS_FLAGS),
492  [IB_QPT_XRC_TGT] = (IB_QP_PKEY_INDEX |
493  IB_QP_PORT |
494  IB_QP_ACCESS_FLAGS),
495  [IB_QPT_SMI] = (IB_QP_PKEY_INDEX |
496  IB_QP_QKEY),
497  [IB_QPT_GSI] = (IB_QP_PKEY_INDEX |
498  IB_QP_QKEY),
499  }
500  },
501  },
502  [IB_QPS_INIT] = {
503  [IB_QPS_RESET] = { .valid = 1 },
504  [IB_QPS_ERR] = { .valid = 1 },
505  [IB_QPS_INIT] = {
506  .valid = 1,
507  .opt_param = {
508  [IB_QPT_UD] = (IB_QP_PKEY_INDEX |
509  IB_QP_PORT |
510  IB_QP_QKEY),
511  [IB_QPT_UC] = (IB_QP_PKEY_INDEX |
512  IB_QP_PORT |
513  IB_QP_ACCESS_FLAGS),
514  [IB_QPT_RC] = (IB_QP_PKEY_INDEX |
515  IB_QP_PORT |
516  IB_QP_ACCESS_FLAGS),
517  [IB_QPT_XRC_INI] = (IB_QP_PKEY_INDEX |
518  IB_QP_PORT |
519  IB_QP_ACCESS_FLAGS),
520  [IB_QPT_XRC_TGT] = (IB_QP_PKEY_INDEX |
521  IB_QP_PORT |
522  IB_QP_ACCESS_FLAGS),
523  [IB_QPT_SMI] = (IB_QP_PKEY_INDEX |
524  IB_QP_QKEY),
525  [IB_QPT_GSI] = (IB_QP_PKEY_INDEX |
526  IB_QP_QKEY),
527  }
528  },
529  [IB_QPS_RTR] = {
530  .valid = 1,
531  .req_param = {
532  [IB_QPT_UC] = (IB_QP_AV |
533  IB_QP_PATH_MTU |
534  IB_QP_DEST_QPN |
535  IB_QP_RQ_PSN),
536  [IB_QPT_RC] = (IB_QP_AV |
537  IB_QP_PATH_MTU |
538  IB_QP_DEST_QPN |
539  IB_QP_RQ_PSN |
540  IB_QP_MAX_DEST_RD_ATOMIC |
541  IB_QP_MIN_RNR_TIMER),
542  [IB_QPT_XRC_INI] = (IB_QP_AV |
543  IB_QP_PATH_MTU |
544  IB_QP_DEST_QPN |
545  IB_QP_RQ_PSN),
546  [IB_QPT_XRC_TGT] = (IB_QP_AV |
547  IB_QP_PATH_MTU |
548  IB_QP_DEST_QPN |
549  IB_QP_RQ_PSN |
550  IB_QP_MAX_DEST_RD_ATOMIC |
551  IB_QP_MIN_RNR_TIMER),
552  },
553  .opt_param = {
554  [IB_QPT_UD] = (IB_QP_PKEY_INDEX |
555  IB_QP_QKEY),
556  [IB_QPT_UC] = (IB_QP_ALT_PATH |
557  IB_QP_ACCESS_FLAGS |
558  IB_QP_PKEY_INDEX),
559  [IB_QPT_RC] = (IB_QP_ALT_PATH |
560  IB_QP_ACCESS_FLAGS |
561  IB_QP_PKEY_INDEX),
562  [IB_QPT_XRC_INI] = (IB_QP_ALT_PATH |
563  IB_QP_ACCESS_FLAGS |
564  IB_QP_PKEY_INDEX),
565  [IB_QPT_XRC_TGT] = (IB_QP_ALT_PATH |
566  IB_QP_ACCESS_FLAGS |
567  IB_QP_PKEY_INDEX),
568  [IB_QPT_SMI] = (IB_QP_PKEY_INDEX |
569  IB_QP_QKEY),
570  [IB_QPT_GSI] = (IB_QP_PKEY_INDEX |
571  IB_QP_QKEY),
572  }
573  }
574  },
575  [IB_QPS_RTR] = {
576  [IB_QPS_RESET] = { .valid = 1 },
577  [IB_QPS_ERR] = { .valid = 1 },
578  [IB_QPS_RTS] = {
579  .valid = 1,
580  .req_param = {
581  [IB_QPT_UD] = IB_QP_SQ_PSN,
582  [IB_QPT_UC] = IB_QP_SQ_PSN,
583  [IB_QPT_RC] = (IB_QP_TIMEOUT |
584  IB_QP_RETRY_CNT |
585  IB_QP_RNR_RETRY |
586  IB_QP_SQ_PSN |
587  IB_QP_MAX_QP_RD_ATOMIC),
588  [IB_QPT_XRC_INI] = (IB_QP_TIMEOUT |
589  IB_QP_RETRY_CNT |
590  IB_QP_RNR_RETRY |
591  IB_QP_SQ_PSN |
592  IB_QP_MAX_QP_RD_ATOMIC),
593  [IB_QPT_XRC_TGT] = (IB_QP_TIMEOUT |
594  IB_QP_SQ_PSN),
595  [IB_QPT_SMI] = IB_QP_SQ_PSN,
596  [IB_QPT_GSI] = IB_QP_SQ_PSN,
597  },
598  .opt_param = {
599  [IB_QPT_UD] = (IB_QP_CUR_STATE |
600  IB_QP_QKEY),
601  [IB_QPT_UC] = (IB_QP_CUR_STATE |
602  IB_QP_ALT_PATH |
603  IB_QP_ACCESS_FLAGS |
604  IB_QP_PATH_MIG_STATE),
605  [IB_QPT_RC] = (IB_QP_CUR_STATE |
606  IB_QP_ALT_PATH |
607  IB_QP_ACCESS_FLAGS |
608  IB_QP_MIN_RNR_TIMER |
609  IB_QP_PATH_MIG_STATE),
610  [IB_QPT_XRC_INI] = (IB_QP_CUR_STATE |
611  IB_QP_ALT_PATH |
612  IB_QP_ACCESS_FLAGS |
613  IB_QP_PATH_MIG_STATE),
614  [IB_QPT_XRC_TGT] = (IB_QP_CUR_STATE |
615  IB_QP_ALT_PATH |
616  IB_QP_ACCESS_FLAGS |
617  IB_QP_MIN_RNR_TIMER |
618  IB_QP_PATH_MIG_STATE),
619  [IB_QPT_SMI] = (IB_QP_CUR_STATE |
620  IB_QP_QKEY),
621  [IB_QPT_GSI] = (IB_QP_CUR_STATE |
622  IB_QP_QKEY),
623  }
624  }
625  },
626  [IB_QPS_RTS] = {
627  [IB_QPS_RESET] = { .valid = 1 },
628  [IB_QPS_ERR] = { .valid = 1 },
629  [IB_QPS_RTS] = {
630  .valid = 1,
631  .opt_param = {
632  [IB_QPT_UD] = (IB_QP_CUR_STATE |
633  IB_QP_QKEY),
634  [IB_QPT_UC] = (IB_QP_CUR_STATE |
635  IB_QP_ACCESS_FLAGS |
636  IB_QP_ALT_PATH |
637  IB_QP_PATH_MIG_STATE),
638  [IB_QPT_RC] = (IB_QP_CUR_STATE |
639  IB_QP_ACCESS_FLAGS |
640  IB_QP_ALT_PATH |
641  IB_QP_PATH_MIG_STATE |
642  IB_QP_MIN_RNR_TIMER),
643  [IB_QPT_XRC_INI] = (IB_QP_CUR_STATE |
644  IB_QP_ACCESS_FLAGS |
645  IB_QP_ALT_PATH |
646  IB_QP_PATH_MIG_STATE),
647  [IB_QPT_XRC_TGT] = (IB_QP_CUR_STATE |
648  IB_QP_ACCESS_FLAGS |
649  IB_QP_ALT_PATH |
650  IB_QP_PATH_MIG_STATE |
651  IB_QP_MIN_RNR_TIMER),
652  [IB_QPT_SMI] = (IB_QP_CUR_STATE |
653  IB_QP_QKEY),
654  [IB_QPT_GSI] = (IB_QP_CUR_STATE |
655  IB_QP_QKEY),
656  }
657  },
658  [IB_QPS_SQD] = {
659  .valid = 1,
660  .opt_param = {
661  [IB_QPT_UD] = IB_QP_EN_SQD_ASYNC_NOTIFY,
662  [IB_QPT_UC] = IB_QP_EN_SQD_ASYNC_NOTIFY,
663  [IB_QPT_RC] = IB_QP_EN_SQD_ASYNC_NOTIFY,
664  [IB_QPT_XRC_INI] = IB_QP_EN_SQD_ASYNC_NOTIFY,
665  [IB_QPT_XRC_TGT] = IB_QP_EN_SQD_ASYNC_NOTIFY, /* ??? */
666  [IB_QPT_SMI] = IB_QP_EN_SQD_ASYNC_NOTIFY,
667  [IB_QPT_GSI] = IB_QP_EN_SQD_ASYNC_NOTIFY
668  }
669  },
670  },
671  [IB_QPS_SQD] = {
672  [IB_QPS_RESET] = { .valid = 1 },
673  [IB_QPS_ERR] = { .valid = 1 },
674  [IB_QPS_RTS] = {
675  .valid = 1,
676  .opt_param = {
677  [IB_QPT_UD] = (IB_QP_CUR_STATE |
678  IB_QP_QKEY),
679  [IB_QPT_UC] = (IB_QP_CUR_STATE |
680  IB_QP_ALT_PATH |
681  IB_QP_ACCESS_FLAGS |
682  IB_QP_PATH_MIG_STATE),
683  [IB_QPT_RC] = (IB_QP_CUR_STATE |
684  IB_QP_ALT_PATH |
685  IB_QP_ACCESS_FLAGS |
686  IB_QP_MIN_RNR_TIMER |
687  IB_QP_PATH_MIG_STATE),
688  [IB_QPT_XRC_INI] = (IB_QP_CUR_STATE |
689  IB_QP_ALT_PATH |
690  IB_QP_ACCESS_FLAGS |
691  IB_QP_PATH_MIG_STATE),
692  [IB_QPT_XRC_TGT] = (IB_QP_CUR_STATE |
693  IB_QP_ALT_PATH |
694  IB_QP_ACCESS_FLAGS |
695  IB_QP_MIN_RNR_TIMER |
696  IB_QP_PATH_MIG_STATE),
697  [IB_QPT_SMI] = (IB_QP_CUR_STATE |
698  IB_QP_QKEY),
699  [IB_QPT_GSI] = (IB_QP_CUR_STATE |
700  IB_QP_QKEY),
701  }
702  },
703  [IB_QPS_SQD] = {
704  .valid = 1,
705  .opt_param = {
706  [IB_QPT_UD] = (IB_QP_PKEY_INDEX |
707  IB_QP_QKEY),
708  [IB_QPT_UC] = (IB_QP_AV |
709  IB_QP_ALT_PATH |
710  IB_QP_ACCESS_FLAGS |
711  IB_QP_PKEY_INDEX |
712  IB_QP_PATH_MIG_STATE),
713  [IB_QPT_RC] = (IB_QP_PORT |
714  IB_QP_AV |
715  IB_QP_TIMEOUT |
716  IB_QP_RETRY_CNT |
717  IB_QP_RNR_RETRY |
718  IB_QP_MAX_QP_RD_ATOMIC |
719  IB_QP_MAX_DEST_RD_ATOMIC |
720  IB_QP_ALT_PATH |
721  IB_QP_ACCESS_FLAGS |
722  IB_QP_PKEY_INDEX |
723  IB_QP_MIN_RNR_TIMER |
724  IB_QP_PATH_MIG_STATE),
725  [IB_QPT_XRC_INI] = (IB_QP_PORT |
726  IB_QP_AV |
727  IB_QP_TIMEOUT |
728  IB_QP_RETRY_CNT |
729  IB_QP_RNR_RETRY |
730  IB_QP_MAX_QP_RD_ATOMIC |
731  IB_QP_ALT_PATH |
732  IB_QP_ACCESS_FLAGS |
733  IB_QP_PKEY_INDEX |
734  IB_QP_PATH_MIG_STATE),
735  [IB_QPT_XRC_TGT] = (IB_QP_PORT |
736  IB_QP_AV |
737  IB_QP_TIMEOUT |
738  IB_QP_MAX_DEST_RD_ATOMIC |
739  IB_QP_ALT_PATH |
740  IB_QP_ACCESS_FLAGS |
741  IB_QP_PKEY_INDEX |
742  IB_QP_MIN_RNR_TIMER |
743  IB_QP_PATH_MIG_STATE),
744  [IB_QPT_SMI] = (IB_QP_PKEY_INDEX |
745  IB_QP_QKEY),
746  [IB_QPT_GSI] = (IB_QP_PKEY_INDEX |
747  IB_QP_QKEY),
748  }
749  }
750  },
751  [IB_QPS_SQE] = {
752  [IB_QPS_RESET] = { .valid = 1 },
753  [IB_QPS_ERR] = { .valid = 1 },
754  [IB_QPS_RTS] = {
755  .valid = 1,
756  .opt_param = {
757  [IB_QPT_UD] = (IB_QP_CUR_STATE |
758  IB_QP_QKEY),
759  [IB_QPT_UC] = (IB_QP_CUR_STATE |
760  IB_QP_ACCESS_FLAGS),
761  [IB_QPT_SMI] = (IB_QP_CUR_STATE |
762  IB_QP_QKEY),
763  [IB_QPT_GSI] = (IB_QP_CUR_STATE |
764  IB_QP_QKEY),
765  }
766  }
767  },
768  [IB_QPS_ERR] = {
769  [IB_QPS_RESET] = { .valid = 1 },
770  [IB_QPS_ERR] = { .valid = 1 }
771  }
772 };
773 
774 int ib_modify_qp_is_ok(enum ib_qp_state cur_state, enum ib_qp_state next_state,
775  enum ib_qp_type type, enum ib_qp_attr_mask mask)
776 {
777  enum ib_qp_attr_mask req_param, opt_param;
778 
779  if (cur_state < 0 || cur_state > IB_QPS_ERR ||
780  next_state < 0 || next_state > IB_QPS_ERR)
781  return 0;
782 
783  if (mask & IB_QP_CUR_STATE &&
784  cur_state != IB_QPS_RTR && cur_state != IB_QPS_RTS &&
785  cur_state != IB_QPS_SQD && cur_state != IB_QPS_SQE)
786  return 0;
787 
788  if (!qp_state_table[cur_state][next_state].valid)
789  return 0;
790 
791  req_param = qp_state_table[cur_state][next_state].req_param[type];
792  opt_param = qp_state_table[cur_state][next_state].opt_param[type];
793 
794  if ((mask & req_param) != req_param)
795  return 0;
796 
797  if (mask & ~(req_param | opt_param | IB_QP_STATE))
798  return 0;
799 
800  return 1;
801 }
802 EXPORT_SYMBOL(ib_modify_qp_is_ok);
803 
804 int ib_modify_qp(struct ib_qp *qp,
805  struct ib_qp_attr *qp_attr,
806  int qp_attr_mask)
807 {
808  return qp->device->modify_qp(qp->real_qp, qp_attr, qp_attr_mask, NULL);
809 }
810 EXPORT_SYMBOL(ib_modify_qp);
811 
812 int ib_query_qp(struct ib_qp *qp,
813  struct ib_qp_attr *qp_attr,
814  int qp_attr_mask,
815  struct ib_qp_init_attr *qp_init_attr)
816 {
817  return qp->device->query_qp ?
818  qp->device->query_qp(qp->real_qp, qp_attr, qp_attr_mask, qp_init_attr) :
819  -ENOSYS;
820 }
821 EXPORT_SYMBOL(ib_query_qp);
822 
823 int ib_close_qp(struct ib_qp *qp)
824 {
825  struct ib_qp *real_qp;
826  unsigned long flags;
827 
828  real_qp = qp->real_qp;
829  if (real_qp == qp)
830  return -EINVAL;
831 
832  spin_lock_irqsave(&real_qp->device->event_handler_lock, flags);
833  list_del(&qp->open_list);
834  spin_unlock_irqrestore(&real_qp->device->event_handler_lock, flags);
835 
836  atomic_dec(&real_qp->usecnt);
837  kfree(qp);
838 
839  return 0;
840 }
841 EXPORT_SYMBOL(ib_close_qp);
842 
843 static int __ib_destroy_shared_qp(struct ib_qp *qp)
844 {
845  struct ib_xrcd *xrcd;
846  struct ib_qp *real_qp;
847  int ret;
848 
849  real_qp = qp->real_qp;
850  xrcd = real_qp->xrcd;
851 
852  mutex_lock(&xrcd->tgt_qp_mutex);
853  ib_close_qp(qp);
854  if (atomic_read(&real_qp->usecnt) == 0)
855  list_del(&real_qp->xrcd_list);
856  else
857  real_qp = NULL;
858  mutex_unlock(&xrcd->tgt_qp_mutex);
859 
860  if (real_qp) {
861  ret = ib_destroy_qp(real_qp);
862  if (!ret)
863  atomic_dec(&xrcd->usecnt);
864  else
865  __ib_insert_xrcd_qp(xrcd, real_qp);
866  }
867 
868  return 0;
869 }
870 
871 int ib_destroy_qp(struct ib_qp *qp)
872 {
873  struct ib_pd *pd;
874  struct ib_cq *scq, *rcq;
875  struct ib_srq *srq;
876  int ret;
877 
878  if (atomic_read(&qp->usecnt))
879  return -EBUSY;
880 
881  if (qp->real_qp != qp)
882  return __ib_destroy_shared_qp(qp);
883 
884  pd = qp->pd;
885  scq = qp->send_cq;
886  rcq = qp->recv_cq;
887  srq = qp->srq;
888 
889  ret = qp->device->destroy_qp(qp);
890  if (!ret) {
891  if (pd)
892  atomic_dec(&pd->usecnt);
893  if (scq)
894  atomic_dec(&scq->usecnt);
895  if (rcq)
896  atomic_dec(&rcq->usecnt);
897  if (srq)
898  atomic_dec(&srq->usecnt);
899  }
900 
901  return ret;
902 }
903 EXPORT_SYMBOL(ib_destroy_qp);
904 
905 /* Completion queues */
906 
907 struct ib_cq *ib_create_cq(struct ib_device *device,
908  ib_comp_handler comp_handler,
909  void (*event_handler)(struct ib_event *, void *),
910  void *cq_context, int cqe, int comp_vector)
911 {
912  struct ib_cq *cq;
913 
914  cq = device->create_cq(device, cqe, comp_vector, NULL, NULL);
915 
916  if (!IS_ERR(cq)) {
917  cq->device = device;
918  cq->uobject = NULL;
919  cq->comp_handler = comp_handler;
920  cq->event_handler = event_handler;
921  cq->cq_context = cq_context;
922  atomic_set(&cq->usecnt, 0);
923  }
924 
925  return cq;
926 }
927 EXPORT_SYMBOL(ib_create_cq);
928 
929 int ib_modify_cq(struct ib_cq *cq, u16 cq_count, u16 cq_period)
930 {
931  return cq->device->modify_cq ?
932  cq->device->modify_cq(cq, cq_count, cq_period) : -ENOSYS;
933 }
934 EXPORT_SYMBOL(ib_modify_cq);
935 
936 int ib_destroy_cq(struct ib_cq *cq)
937 {
938  if (atomic_read(&cq->usecnt))
939  return -EBUSY;
940 
941  return cq->device->destroy_cq(cq);
942 }
943 EXPORT_SYMBOL(ib_destroy_cq);
944 
945 int ib_resize_cq(struct ib_cq *cq, int cqe)
946 {
947  return cq->device->resize_cq ?
948  cq->device->resize_cq(cq, cqe, NULL) : -ENOSYS;
949 }
950 EXPORT_SYMBOL(ib_resize_cq);
951 
952 /* Memory regions */
953 
954 struct ib_mr *ib_get_dma_mr(struct ib_pd *pd, int mr_access_flags)
955 {
956  struct ib_mr *mr;
957 
958  mr = pd->device->get_dma_mr(pd, mr_access_flags);
959 
960  if (!IS_ERR(mr)) {
961  mr->device = pd->device;
962  mr->pd = pd;
963  mr->uobject = NULL;
964  atomic_inc(&pd->usecnt);
965  atomic_set(&mr->usecnt, 0);
966  }
967 
968  return mr;
969 }
970 EXPORT_SYMBOL(ib_get_dma_mr);
971 
972 struct ib_mr *ib_reg_phys_mr(struct ib_pd *pd,
973  struct ib_phys_buf *phys_buf_array,
974  int num_phys_buf,
975  int mr_access_flags,
976  u64 *iova_start)
977 {
978  struct ib_mr *mr;
979 
980  if (!pd->device->reg_phys_mr)
981  return ERR_PTR(-ENOSYS);
982 
983  mr = pd->device->reg_phys_mr(pd, phys_buf_array, num_phys_buf,
984  mr_access_flags, iova_start);
985 
986  if (!IS_ERR(mr)) {
987  mr->device = pd->device;
988  mr->pd = pd;
989  mr->uobject = NULL;
990  atomic_inc(&pd->usecnt);
991  atomic_set(&mr->usecnt, 0);
992  }
993 
994  return mr;
995 }
996 EXPORT_SYMBOL(ib_reg_phys_mr);
997 
998 int ib_rereg_phys_mr(struct ib_mr *mr,
999  int mr_rereg_mask,
1000  struct ib_pd *pd,
1001  struct ib_phys_buf *phys_buf_array,
1002  int num_phys_buf,
1003  int mr_access_flags,
1004  u64 *iova_start)
1005 {
1006  struct ib_pd *old_pd;
1007  int ret;
1008 
1009  if (!mr->device->rereg_phys_mr)
1010  return -ENOSYS;
1011 
1012  if (atomic_read(&mr->usecnt))
1013  return -EBUSY;
1014 
1015  old_pd = mr->pd;
1016 
1017  ret = mr->device->rereg_phys_mr(mr, mr_rereg_mask, pd,
1018  phys_buf_array, num_phys_buf,
1019  mr_access_flags, iova_start);
1020 
1021  if (!ret && (mr_rereg_mask & IB_MR_REREG_PD)) {
1022  atomic_dec(&old_pd->usecnt);
1023  atomic_inc(&pd->usecnt);
1024  }
1025 
1026  return ret;
1027 }
1028 EXPORT_SYMBOL(ib_rereg_phys_mr);
1029 
1030 int ib_query_mr(struct ib_mr *mr, struct ib_mr_attr *mr_attr)
1031 {
1032  return mr->device->query_mr ?
1033  mr->device->query_mr(mr, mr_attr) : -ENOSYS;
1034 }
1035 EXPORT_SYMBOL(ib_query_mr);
1036 
1037 int ib_dereg_mr(struct ib_mr *mr)
1038 {
1039  struct ib_pd *pd;
1040  int ret;
1041 
1042  if (atomic_read(&mr->usecnt))
1043  return -EBUSY;
1044 
1045  pd = mr->pd;
1046  ret = mr->device->dereg_mr(mr);
1047  if (!ret)
1048  atomic_dec(&pd->usecnt);
1049 
1050  return ret;
1051 }
1052 EXPORT_SYMBOL(ib_dereg_mr);
1053 
1054 struct ib_mr *ib_alloc_fast_reg_mr(struct ib_pd *pd, int max_page_list_len)
1055 {
1056  struct ib_mr *mr;
1057 
1058  if (!pd->device->alloc_fast_reg_mr)
1059  return ERR_PTR(-ENOSYS);
1060 
1061  mr = pd->device->alloc_fast_reg_mr(pd, max_page_list_len);
1062 
1063  if (!IS_ERR(mr)) {
1064  mr->device = pd->device;
1065  mr->pd = pd;
1066  mr->uobject = NULL;
1067  atomic_inc(&pd->usecnt);
1068  atomic_set(&mr->usecnt, 0);
1069  }
1070 
1071  return mr;
1072 }
1073 EXPORT_SYMBOL(ib_alloc_fast_reg_mr);
1074 
1075 struct ib_fast_reg_page_list *ib_alloc_fast_reg_page_list(struct ib_device *device,
1076  int max_page_list_len)
1077 {
1078  struct ib_fast_reg_page_list *page_list;
1079 
1080  if (!device->alloc_fast_reg_page_list)
1081  return ERR_PTR(-ENOSYS);
1082 
1083  page_list = device->alloc_fast_reg_page_list(device, max_page_list_len);
1084 
1085  if (!IS_ERR(page_list)) {
1086  page_list->device = device;
1087  page_list->max_page_list_len = max_page_list_len;
1088  }
1089 
1090  return page_list;
1091 }
1092 EXPORT_SYMBOL(ib_alloc_fast_reg_page_list);
1093 
1094 void ib_free_fast_reg_page_list(struct ib_fast_reg_page_list *page_list)
1095 {
1096  page_list->device->free_fast_reg_page_list(page_list);
1097 }
1098 EXPORT_SYMBOL(ib_free_fast_reg_page_list);
1099 
1100 /* Memory windows */
1101 
1102 struct ib_mw *ib_alloc_mw(struct ib_pd *pd)
1103 {
1104  struct ib_mw *mw;
1105 
1106  if (!pd->device->alloc_mw)
1107  return ERR_PTR(-ENOSYS);
1108 
1109  mw = pd->device->alloc_mw(pd);
1110  if (!IS_ERR(mw)) {
1111  mw->device = pd->device;
1112  mw->pd = pd;
1113  mw->uobject = NULL;
1114  atomic_inc(&pd->usecnt);
1115  }
1116 
1117  return mw;
1118 }
1119 EXPORT_SYMBOL(ib_alloc_mw);
1120 
1121 int ib_dealloc_mw(struct ib_mw *mw)
1122 {
1123  struct ib_pd *pd;
1124  int ret;
1125 
1126  pd = mw->pd;
1127  ret = mw->device->dealloc_mw(mw);
1128  if (!ret)
1129  atomic_dec(&pd->usecnt);
1130 
1131  return ret;
1132 }
1133 EXPORT_SYMBOL(ib_dealloc_mw);
1134 
1135 /* "Fast" memory regions */
1136 
1137 struct ib_fmr *ib_alloc_fmr(struct ib_pd *pd,
1138  int mr_access_flags,
1139  struct ib_fmr_attr *fmr_attr)
1140 {
1141  struct ib_fmr *fmr;
1142 
1143  if (!pd->device->alloc_fmr)
1144  return ERR_PTR(-ENOSYS);
1145 
1146  fmr = pd->device->alloc_fmr(pd, mr_access_flags, fmr_attr);
1147  if (!IS_ERR(fmr)) {
1148  fmr->device = pd->device;
1149  fmr->pd = pd;
1150  atomic_inc(&pd->usecnt);
1151  }
1152 
1153  return fmr;
1154 }
1155 EXPORT_SYMBOL(ib_alloc_fmr);
1156 
1157 int ib_unmap_fmr(struct list_head *fmr_list)
1158 {
1159  struct ib_fmr *fmr;
1160 
1161  if (list_empty(fmr_list))
1162  return 0;
1163 
1164  fmr = list_entry(fmr_list->next, struct ib_fmr, list);
1165  return fmr->device->unmap_fmr(fmr_list);
1166 }
1167 EXPORT_SYMBOL(ib_unmap_fmr);
1168 
1169 int ib_dealloc_fmr(struct ib_fmr *fmr)
1170 {
1171  struct ib_pd *pd;
1172  int ret;
1173 
1174  pd = fmr->pd;
1175  ret = fmr->device->dealloc_fmr(fmr);
1176  if (!ret)
1177  atomic_dec(&pd->usecnt);
1178 
1179  return ret;
1180 }
1181 EXPORT_SYMBOL(ib_dealloc_fmr);
1182 
1183 /* Multicast groups */
1184 
1185 int ib_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid)
1186 {
1187  int ret;
1188 
1189  if (!qp->device->attach_mcast)
1190  return -ENOSYS;
1191  if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
1192  return -EINVAL;
1193 
1194  ret = qp->device->attach_mcast(qp, gid, lid);
1195  if (!ret)
1196  atomic_inc(&qp->usecnt);
1197  return ret;
1198 }
1199 EXPORT_SYMBOL(ib_attach_mcast);
1200 
1201 int ib_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid)
1202 {
1203  int ret;
1204 
1205  if (!qp->device->detach_mcast)
1206  return -ENOSYS;
1207  if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
1208  return -EINVAL;
1209 
1210  ret = qp->device->detach_mcast(qp, gid, lid);
1211  if (!ret)
1212  atomic_dec(&qp->usecnt);
1213  return ret;
1214 }
1215 EXPORT_SYMBOL(ib_detach_mcast);
1216 
1217 struct ib_xrcd *ib_alloc_xrcd(struct ib_device *device)
1218 {
1219  struct ib_xrcd *xrcd;
1220 
1221  if (!device->alloc_xrcd)
1222  return ERR_PTR(-ENOSYS);
1223 
1224  xrcd = device->alloc_xrcd(device, NULL, NULL);
1225  if (!IS_ERR(xrcd)) {
1226  xrcd->device = device;
1227  xrcd->inode = NULL;
1228  atomic_set(&xrcd->usecnt, 0);
1229  mutex_init(&xrcd->tgt_qp_mutex);
1230  INIT_LIST_HEAD(&xrcd->tgt_qp_list);
1231  }
1232 
1233  return xrcd;
1234 }
1235 EXPORT_SYMBOL(ib_alloc_xrcd);
1236 
1237 int ib_dealloc_xrcd(struct ib_xrcd *xrcd)
1238 {
1239  struct ib_qp *qp;
1240  int ret;
1241 
1242  if (atomic_read(&xrcd->usecnt))
1243  return -EBUSY;
1244 
1245  while (!list_empty(&xrcd->tgt_qp_list)) {
1246  qp = list_entry(xrcd->tgt_qp_list.next, struct ib_qp, xrcd_list);
1247  ret = ib_destroy_qp(qp);
1248  if (ret)
1249  return ret;
1250  }
1251 
1252  return xrcd->device->dealloc_xrcd(xrcd);
1253 }
1254 EXPORT_SYMBOL(ib_dealloc_xrcd);
Generated on Thu Jan 10 2013 13:37:09 for Linux Kernel by   doxygen 1.8.2