projects / deliverable / linux.git / blob
? search:


b81307b625a6d11c0618d2293121baee08029b05
[deliverable/linux.git] / drivers / infiniband / core / uverbs_cmd.c
1 /*
2 * Copyright (c) 2005 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005, 2006 Cisco Systems. All rights reserved.
4 * Copyright (c) 2005 PathScale, Inc. All rights reserved.
5 * Copyright (c) 2006 Mellanox Technologies. All rights reserved.
6 *
7 * This software is available to you under a choice of one of two
8 * licenses. You may choose to be licensed under the terms of the GNU
9 * General Public License (GPL) Version 2, available from the file
10 * COPYING in the main directory of this source tree, or the
11 * OpenIB.org BSD license below:
12 *
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
15 * conditions are met:
16 *
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
19 * disclaimer.
20 *
21 * - Redistributions in binary form must reproduce the above
22 * copyright notice, this list of conditions and the following
23 * disclaimer in the documentation and/or other materials
24 * provided with the distribution.
25 *
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 * SOFTWARE.
34 *
35 * $Id: uverbs_cmd.c 2708 2005-06-24 17:27:21Z roland $
36 */
37
38 #include <linux/file.h>
39 #include <linux/fs.h>
40
41 #include <asm/uaccess.h>
42
43 #include "uverbs.h"
44
45 static struct lock_class_key pd_lock_key;
46 static struct lock_class_key mr_lock_key;
47 static struct lock_class_key cq_lock_key;
48 static struct lock_class_key qp_lock_key;
49 static struct lock_class_key ah_lock_key;
50 static struct lock_class_key srq_lock_key;
51
52 #define INIT_UDATA(udata, ibuf, obuf, ilen, olen) \
53 do { \
54 (udata)->inbuf = (void __user *) (ibuf); \
55 (udata)->outbuf = (void __user *) (obuf); \
56 (udata)->inlen = (ilen); \
57 (udata)->outlen = (olen); \
58 } while (0)
59
60 /*
61 * The ib_uobject locking scheme is as follows:
62 *
63 * - ib_uverbs_idr_lock protects the uverbs idrs themselves, so it
64 * needs to be held during all idr operations. When an object is
65 * looked up, a reference must be taken on the object's kref before
66 * dropping this lock.
67 *
68 * - Each object also has an rwsem. This rwsem must be held for
69 * reading while an operation that uses the object is performed.
70 * For example, while registering an MR, the associated PD's
71 * uobject.mutex must be held for reading. The rwsem must be held
72 * for writing while initializing or destroying an object.
73 *
74 * - In addition, each object has a "live" flag. If this flag is not
75 * set, then lookups of the object will fail even if it is found in
76 * the idr. This handles a reader that blocks and does not acquire
77 * the rwsem until after the object is destroyed. The destroy
78 * operation will set the live flag to 0 and then drop the rwsem;
79 * this will allow the reader to acquire the rwsem, see that the
80 * live flag is 0, and then drop the rwsem and its reference to
81 * object. The underlying storage will not be freed until the last
82 * reference to the object is dropped.
83 */
84
85 static void init_uobj(struct ib_uobject *uobj, u64 user_handle,
86 struct ib_ucontext *context, struct lock_class_key *key)
87 {
88 uobj->user_handle = user_handle;
89 uobj->context = context;
90 kref_init(&uobj->ref);
91 init_rwsem(&uobj->mutex);
92 lockdep_set_class(&uobj->mutex, key);
93 uobj->live = 0;
94 }
95
96 static void release_uobj(struct kref *kref)
97 {
98 kfree(container_of(kref, struct ib_uobject, ref));
99 }
100
101 static void put_uobj(struct ib_uobject *uobj)
102 {
103 kref_put(&uobj->ref, release_uobj);
104 }
105
106 static void put_uobj_read(struct ib_uobject *uobj)
107 {
108 up_read(&uobj->mutex);
109 put_uobj(uobj);
110 }
111
112 static void put_uobj_write(struct ib_uobject *uobj)
113 {
114 up_write(&uobj->mutex);
115 put_uobj(uobj);
116 }
117
118 static int idr_add_uobj(struct idr *idr, struct ib_uobject *uobj)
119 {
120 int ret;
121
122 retry:
123 if (!idr_pre_get(idr, GFP_KERNEL))
124 return -ENOMEM;
125
126 spin_lock(&ib_uverbs_idr_lock);
127 ret = idr_get_new(idr, uobj, &uobj->id);
128 spin_unlock(&ib_uverbs_idr_lock);
129
130 if (ret == -EAGAIN)
131 goto retry;
132
133 return ret;
134 }
135
136 void idr_remove_uobj(struct idr *idr, struct ib_uobject *uobj)
137 {
138 spin_lock(&ib_uverbs_idr_lock);
139 idr_remove(idr, uobj->id);
140 spin_unlock(&ib_uverbs_idr_lock);
141 }
142
143 static struct ib_uobject *__idr_get_uobj(struct idr *idr, int id,
144 struct ib_ucontext *context)
145 {
146 struct ib_uobject *uobj;
147
148 spin_lock(&ib_uverbs_idr_lock);
149 uobj = idr_find(idr, id);
150 if (uobj)
151 kref_get(&uobj->ref);
152 spin_unlock(&ib_uverbs_idr_lock);
153
154 return uobj;
155 }
156
157 static struct ib_uobject *idr_read_uobj(struct idr *idr, int id,
158 struct ib_ucontext *context)
159 {
160 struct ib_uobject *uobj;
161
162 uobj = __idr_get_uobj(idr, id, context);
163 if (!uobj)
164 return NULL;
165
166 down_read(&uobj->mutex);
167 if (!uobj->live) {
168 put_uobj_read(uobj);
169 return NULL;
170 }
171
172 return uobj;
173 }
174
175 static struct ib_uobject *idr_write_uobj(struct idr *idr, int id,
176 struct ib_ucontext *context)
177 {
178 struct ib_uobject *uobj;
179
180 uobj = __idr_get_uobj(idr, id, context);
181 if (!uobj)
182 return NULL;
183
184 down_write(&uobj->mutex);
185 if (!uobj->live) {
186 put_uobj_write(uobj);
187 return NULL;
188 }
189
190 return uobj;
191 }
192
193 static void *idr_read_obj(struct idr *idr, int id, struct ib_ucontext *context)
194 {
195 struct ib_uobject *uobj;
196
197 uobj = idr_read_uobj(idr, id, context);
198 return uobj ? uobj->object : NULL;
199 }
200
201 static struct ib_pd *idr_read_pd(int pd_handle, struct ib_ucontext *context)
202 {
203 return idr_read_obj(&ib_uverbs_pd_idr, pd_handle, context);
204 }
205
206 static void put_pd_read(struct ib_pd *pd)
207 {
208 put_uobj_read(pd->uobject);
209 }
210
211 static struct ib_cq *idr_read_cq(int cq_handle, struct ib_ucontext *context)
212 {
213 return idr_read_obj(&ib_uverbs_cq_idr, cq_handle, context);
214 }
215
216 static void put_cq_read(struct ib_cq *cq)
217 {
218 put_uobj_read(cq->uobject);
219 }
220
221 static struct ib_ah *idr_read_ah(int ah_handle, struct ib_ucontext *context)
222 {
223 return idr_read_obj(&ib_uverbs_ah_idr, ah_handle, context);
224 }
225
226 static void put_ah_read(struct ib_ah *ah)
227 {
228 put_uobj_read(ah->uobject);
229 }
230
231 static struct ib_qp *idr_read_qp(int qp_handle, struct ib_ucontext *context)
232 {
233 return idr_read_obj(&ib_uverbs_qp_idr, qp_handle, context);
234 }
235
236 static void put_qp_read(struct ib_qp *qp)
237 {
238 put_uobj_read(qp->uobject);
239 }
240
241 static struct ib_srq *idr_read_srq(int srq_handle, struct ib_ucontext *context)
242 {
243 return idr_read_obj(&ib_uverbs_srq_idr, srq_handle, context);
244 }
245
246 static void put_srq_read(struct ib_srq *srq)
247 {
248 put_uobj_read(srq->uobject);
249 }
250
251 ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file,
252 const char __user *buf,
253 int in_len, int out_len)
254 {
255 struct ib_uverbs_get_context cmd;
256 struct ib_uverbs_get_context_resp resp;
257 struct ib_udata udata;
258 struct ib_device *ibdev = file->device->ib_dev;
259 struct ib_ucontext *ucontext;
260 struct file *filp;
261 int ret;
262
263 if (out_len < sizeof resp)
264 return -ENOSPC;
265
266 if (copy_from_user(&cmd, buf, sizeof cmd))
267 return -EFAULT;
268
269 mutex_lock(&file->mutex);
270
271 if (file->ucontext) {
272 ret = -EINVAL;
273 goto err;
274 }
275
276 INIT_UDATA(&udata, buf + sizeof cmd,
277 (unsigned long) cmd.response + sizeof resp,
278 in_len - sizeof cmd, out_len - sizeof resp);
279
280 ucontext = ibdev->alloc_ucontext(ibdev, &udata);
281 if (IS_ERR(ucontext)) {
282 ret = PTR_ERR(file->ucontext);
283 goto err;
284 }
285
286 ucontext->device = ibdev;
287 INIT_LIST_HEAD(&ucontext->pd_list);
288 INIT_LIST_HEAD(&ucontext->mr_list);
289 INIT_LIST_HEAD(&ucontext->mw_list);
290 INIT_LIST_HEAD(&ucontext->cq_list);
291 INIT_LIST_HEAD(&ucontext->qp_list);
292 INIT_LIST_HEAD(&ucontext->srq_list);
293 INIT_LIST_HEAD(&ucontext->ah_list);
294
295 resp.num_comp_vectors = file->device->num_comp_vectors;
296
297 filp = ib_uverbs_alloc_event_file(file, 1, &resp.async_fd);
298 if (IS_ERR(filp)) {
299 ret = PTR_ERR(filp);
300 goto err_free;
301 }
302
303 if (copy_to_user((void __user *) (unsigned long) cmd.response,
304 &resp, sizeof resp)) {
305 ret = -EFAULT;
306 goto err_file;
307 }
308
309 file->async_file = filp->private_data;
310
311 INIT_IB_EVENT_HANDLER(&file->event_handler, file->device->ib_dev,
312 ib_uverbs_event_handler);
313 ret = ib_register_event_handler(&file->event_handler);
314 if (ret)
315 goto err_file;
316
317 kref_get(&file->async_file->ref);
318 kref_get(&file->ref);
319 file->ucontext = ucontext;
320
321 fd_install(resp.async_fd, filp);
322
323 mutex_unlock(&file->mutex);
324
325 return in_len;
326
327 err_file:
328 put_unused_fd(resp.async_fd);
329 fput(filp);
330
331 err_free:
332 ibdev->dealloc_ucontext(ucontext);
333
334 err:
335 mutex_unlock(&file->mutex);
336 return ret;
337 }
338
339 ssize_t ib_uverbs_query_device(struct ib_uverbs_file *file,
340 const char __user *buf,
341 int in_len, int out_len)
342 {
343 struct ib_uverbs_query_device cmd;
344 struct ib_uverbs_query_device_resp resp;
345 struct ib_device_attr attr;
346 int ret;
347
348 if (out_len < sizeof resp)
349 return -ENOSPC;
350
351 if (copy_from_user(&cmd, buf, sizeof cmd))
352 return -EFAULT;
353
354 ret = ib_query_device(file->device->ib_dev, &attr);
355 if (ret)
356 return ret;
357
358 memset(&resp, 0, sizeof resp);
359
360 resp.fw_ver = attr.fw_ver;
361 resp.node_guid = file->device->ib_dev->node_guid;
362 resp.sys_image_guid = attr.sys_image_guid;
363 resp.max_mr_size = attr.max_mr_size;
364 resp.page_size_cap = attr.page_size_cap;
365 resp.vendor_id = attr.vendor_id;
366 resp.vendor_part_id = attr.vendor_part_id;
367 resp.hw_ver = attr.hw_ver;
368 resp.max_qp = attr.max_qp;
369 resp.max_qp_wr = attr.max_qp_wr;
370 resp.device_cap_flags = attr.device_cap_flags;
371 resp.max_sge = attr.max_sge;
372 resp.max_sge_rd = attr.max_sge_rd;
373 resp.max_cq = attr.max_cq;
374 resp.max_cqe = attr.max_cqe;
375 resp.max_mr = attr.max_mr;
376 resp.max_pd = attr.max_pd;
377 resp.max_qp_rd_atom = attr.max_qp_rd_atom;
378 resp.max_ee_rd_atom = attr.max_ee_rd_atom;
379 resp.max_res_rd_atom = attr.max_res_rd_atom;
380 resp.max_qp_init_rd_atom = attr.max_qp_init_rd_atom;
381 resp.max_ee_init_rd_atom = attr.max_ee_init_rd_atom;
382 resp.atomic_cap = attr.atomic_cap;
383 resp.max_ee = attr.max_ee;
384 resp.max_rdd = attr.max_rdd;
385 resp.max_mw = attr.max_mw;
386 resp.max_raw_ipv6_qp = attr.max_raw_ipv6_qp;
387 resp.max_raw_ethy_qp = attr.max_raw_ethy_qp;
388 resp.max_mcast_grp = attr.max_mcast_grp;
389 resp.max_mcast_qp_attach = attr.max_mcast_qp_attach;
390 resp.max_total_mcast_qp_attach = attr.max_total_mcast_qp_attach;
391 resp.max_ah = attr.max_ah;
392 resp.max_fmr = attr.max_fmr;
393 resp.max_map_per_fmr = attr.max_map_per_fmr;
394 resp.max_srq = attr.max_srq;
395 resp.max_srq_wr = attr.max_srq_wr;
396 resp.max_srq_sge = attr.max_srq_sge;
397 resp.max_pkeys = attr.max_pkeys;
398 resp.local_ca_ack_delay = attr.local_ca_ack_delay;
399 resp.phys_port_cnt = file->device->ib_dev->phys_port_cnt;
400
401 if (copy_to_user((void __user *) (unsigned long) cmd.response,
402 &resp, sizeof resp))
403 return -EFAULT;
404
405 return in_len;
406 }
407
408 ssize_t ib_uverbs_query_port(struct ib_uverbs_file *file,
409 const char __user *buf,
410 int in_len, int out_len)
411 {
412 struct ib_uverbs_query_port cmd;
413 struct ib_uverbs_query_port_resp resp;
414 struct ib_port_attr attr;
415 int ret;
416
417 if (out_len < sizeof resp)
418 return -ENOSPC;
419
420 if (copy_from_user(&cmd, buf, sizeof cmd))
421 return -EFAULT;
422
423 ret = ib_query_port(file->device->ib_dev, cmd.port_num, &attr);
424 if (ret)
425 return ret;
426
427 memset(&resp, 0, sizeof resp);
428
429 resp.state = attr.state;
430 resp.max_mtu = attr.max_mtu;
431 resp.active_mtu = attr.active_mtu;
432 resp.gid_tbl_len = attr.gid_tbl_len;
433 resp.port_cap_flags = attr.port_cap_flags;
434 resp.max_msg_sz = attr.max_msg_sz;
435 resp.bad_pkey_cntr = attr.bad_pkey_cntr;
436 resp.qkey_viol_cntr = attr.qkey_viol_cntr;
437 resp.pkey_tbl_len = attr.pkey_tbl_len;
438 resp.lid = attr.lid;
439 resp.sm_lid = attr.sm_lid;
440 resp.lmc = attr.lmc;
441 resp.max_vl_num = attr.max_vl_num;
442 resp.sm_sl = attr.sm_sl;
443 resp.subnet_timeout = attr.subnet_timeout;
444 resp.init_type_reply = attr.init_type_reply;
445 resp.active_width = attr.active_width;
446 resp.active_speed = attr.active_speed;
447 resp.phys_state = attr.phys_state;
448
449 if (copy_to_user((void __user *) (unsigned long) cmd.response,
450 &resp, sizeof resp))
451 return -EFAULT;
452
453 return in_len;
454 }
455
456 ssize_t ib_uverbs_alloc_pd(struct ib_uverbs_file *file,
457 const char __user *buf,
458 int in_len, int out_len)
459 {
460 struct ib_uverbs_alloc_pd cmd;
461 struct ib_uverbs_alloc_pd_resp resp;
462 struct ib_udata udata;
463 struct ib_uobject *uobj;
464 struct ib_pd *pd;
465 int ret;
466
467 if (out_len < sizeof resp)
468 return -ENOSPC;
469
470 if (copy_from_user(&cmd, buf, sizeof cmd))
471 return -EFAULT;
472
473 INIT_UDATA(&udata, buf + sizeof cmd,
474 (unsigned long) cmd.response + sizeof resp,
475 in_len - sizeof cmd, out_len - sizeof resp);
476
477 uobj = kmalloc(sizeof *uobj, GFP_KERNEL);
478 if (!uobj)
479 return -ENOMEM;
480
481 init_uobj(uobj, 0, file->ucontext, &pd_lock_key);
482 down_write(&uobj->mutex);
483
484 pd = file->device->ib_dev->alloc_pd(file->device->ib_dev,
485 file->ucontext, &udata);
486 if (IS_ERR(pd)) {
487 ret = PTR_ERR(pd);
488 goto err;
489 }
490
491 pd->device = file->device->ib_dev;
492 pd->uobject = uobj;
493 atomic_set(&pd->usecnt, 0);
494
495 uobj->object = pd;
496 ret = idr_add_uobj(&ib_uverbs_pd_idr, uobj);
497 if (ret)
498 goto err_idr;
499
500 memset(&resp, 0, sizeof resp);
501 resp.pd_handle = uobj->id;
502
503 if (copy_to_user((void __user *) (unsigned long) cmd.response,
504 &resp, sizeof resp)) {
505 ret = -EFAULT;
506 goto err_copy;
507 }
508
509 mutex_lock(&file->mutex);
510 list_add_tail(&uobj->list, &file->ucontext->pd_list);
511 mutex_unlock(&file->mutex);
512
513 uobj->live = 1;
514
515 up_write(&uobj->mutex);
516
517 return in_len;
518
519 err_copy:
520 idr_remove_uobj(&ib_uverbs_pd_idr, uobj);
521
522 err_idr:
523 ib_dealloc_pd(pd);
524
525 err:
526 put_uobj_write(uobj);
527 return ret;
528 }
529
530 ssize_t ib_uverbs_dealloc_pd(struct ib_uverbs_file *file,
531 const char __user *buf,
532 int in_len, int out_len)
533 {
534 struct ib_uverbs_dealloc_pd cmd;
535 struct ib_uobject *uobj;
536 int ret;
537
538 if (copy_from_user(&cmd, buf, sizeof cmd))
539 return -EFAULT;
540
541 uobj = idr_write_uobj(&ib_uverbs_pd_idr, cmd.pd_handle, file->ucontext);
542 if (!uobj)
543 return -EINVAL;
544
545 ret = ib_dealloc_pd(uobj->object);
546 if (!ret)
547 uobj->live = 0;
548
549 put_uobj_write(uobj);
550
551 if (ret)
552 return ret;
553
554 idr_remove_uobj(&ib_uverbs_pd_idr, uobj);
555
556 mutex_lock(&file->mutex);
557 list_del(&uobj->list);
558 mutex_unlock(&file->mutex);
559
560 put_uobj(uobj);
561
562 return in_len;
563 }
564
565 ssize_t ib_uverbs_reg_mr(struct ib_uverbs_file *file,
566 const char __user *buf, int in_len,
567 int out_len)
568 {
569 struct ib_uverbs_reg_mr cmd;
570 struct ib_uverbs_reg_mr_resp resp;
571 struct ib_udata udata;
572 struct ib_umem_object *obj;
573 struct ib_pd *pd;
574 struct ib_mr *mr;
575 int ret;
576
577 if (out_len < sizeof resp)
578 return -ENOSPC;
579
580 if (copy_from_user(&cmd, buf, sizeof cmd))
581 return -EFAULT;
582
583 INIT_UDATA(&udata, buf + sizeof cmd,
584 (unsigned long) cmd.response + sizeof resp,
585 in_len - sizeof cmd, out_len - sizeof resp);
586
587 if ((cmd.start & ~PAGE_MASK) != (cmd.hca_va & ~PAGE_MASK))
588 return -EINVAL;
589
590 /*
591 * Local write permission is required if remote write or
592 * remote atomic permission is also requested.
593 */
594 if (cmd.access_flags & (IB_ACCESS_REMOTE_ATOMIC | IB_ACCESS_REMOTE_WRITE) &&
595 !(cmd.access_flags & IB_ACCESS_LOCAL_WRITE))
596 return -EINVAL;
597
598 obj = kmalloc(sizeof *obj, GFP_KERNEL);
599 if (!obj)
600 return -ENOMEM;
601
602 init_uobj(&obj->uobject, 0, file->ucontext, &mr_lock_key);
603 down_write(&obj->uobject.mutex);
604
605 /*
606 * We ask for writable memory if any access flags other than
607 * "remote read" are set. "Local write" and "remote write"
608 * obviously require write access. "Remote atomic" can do
609 * things like fetch and add, which will modify memory, and
610 * "MW bind" can change permissions by binding a window.
611 */
612 ret = ib_umem_get(file->device->ib_dev, &obj->umem,
613 (void *) (unsigned long) cmd.start, cmd.length,
614 !!(cmd.access_flags & ~IB_ACCESS_REMOTE_READ));
615 if (ret)
616 goto err_free;
617
618 obj->umem.virt_base = cmd.hca_va;
619
620 pd = idr_read_pd(cmd.pd_handle, file->ucontext);
621 if (!pd)
622 goto err_release;
623
624 mr = pd->device->reg_user_mr(pd, &obj->umem, cmd.access_flags, &udata);
625 if (IS_ERR(mr)) {
626 ret = PTR_ERR(mr);
627 goto err_put;
628 }
629
630 mr->device = pd->device;
631 mr->pd = pd;
632 mr->uobject = &obj->uobject;
633 atomic_inc(&pd->usecnt);
634 atomic_set(&mr->usecnt, 0);
635
636 obj->uobject.object = mr;
637 ret = idr_add_uobj(&ib_uverbs_mr_idr, &obj->uobject);
638 if (ret)
639 goto err_unreg;
640
641 memset(&resp, 0, sizeof resp);
642 resp.lkey = mr->lkey;
643 resp.rkey = mr->rkey;
644 resp.mr_handle = obj->uobject.id;
645
646 if (copy_to_user((void __user *) (unsigned long) cmd.response,
647 &resp, sizeof resp)) {
648 ret = -EFAULT;
649 goto err_copy;
650 }
651
652 put_pd_read(pd);
653
654 mutex_lock(&file->mutex);
655 list_add_tail(&obj->uobject.list, &file->ucontext->mr_list);
656 mutex_unlock(&file->mutex);
657
658 obj->uobject.live = 1;
659
660 up_write(&obj->uobject.mutex);
661
662 return in_len;
663
664 err_copy:
665 idr_remove_uobj(&ib_uverbs_mr_idr, &obj->uobject);
666
667 err_unreg:
668 ib_dereg_mr(mr);
669
670 err_put:
671 put_pd_read(pd);
672
673 err_release:
674 ib_umem_release(file->device->ib_dev, &obj->umem);
675
676 err_free:
677 put_uobj_write(&obj->uobject);
678 return ret;
679 }
680
681 ssize_t ib_uverbs_dereg_mr(struct ib_uverbs_file *file,
682 const char __user *buf, int in_len,
683 int out_len)
684 {
685 struct ib_uverbs_dereg_mr cmd;
686 struct ib_mr *mr;
687 struct ib_uobject *uobj;
688 struct ib_umem_object *memobj;
689 int ret = -EINVAL;
690
691 if (copy_from_user(&cmd, buf, sizeof cmd))
692 return -EFAULT;
693
694 uobj = idr_write_uobj(&ib_uverbs_mr_idr, cmd.mr_handle, file->ucontext);
695 if (!uobj)
696 return -EINVAL;
697
698 memobj = container_of(uobj, struct ib_umem_object, uobject);
699 mr = uobj->object;
700
701 ret = ib_dereg_mr(mr);
702 if (!ret)
703 uobj->live = 0;
704
705 put_uobj_write(uobj);
706
707 if (ret)
708 return ret;
709
710 idr_remove_uobj(&ib_uverbs_mr_idr, uobj);
711
712 mutex_lock(&file->mutex);
713 list_del(&uobj->list);
714 mutex_unlock(&file->mutex);
715
716 ib_umem_release(file->device->ib_dev, &memobj->umem);
717
718 put_uobj(uobj);
719
720 return in_len;
721 }
722
723 ssize_t ib_uverbs_create_comp_channel(struct ib_uverbs_file *file,
724 const char __user *buf, int in_len,
725 int out_len)
726 {
727 struct ib_uverbs_create_comp_channel cmd;
728 struct ib_uverbs_create_comp_channel_resp resp;
729 struct file *filp;
730
731 if (out_len < sizeof resp)
732 return -ENOSPC;
733
734 if (copy_from_user(&cmd, buf, sizeof cmd))
735 return -EFAULT;
736
737 filp = ib_uverbs_alloc_event_file(file, 0, &resp.fd);
738 if (IS_ERR(filp))
739 return PTR_ERR(filp);
740
741 if (copy_to_user((void __user *) (unsigned long) cmd.response,
742 &resp, sizeof resp)) {
743 put_unused_fd(resp.fd);
744 fput(filp);
745 return -EFAULT;
746 }
747
748 fd_install(resp.fd, filp);
749 return in_len;
750 }
751
752 ssize_t ib_uverbs_create_cq(struct ib_uverbs_file *file,
753 const char __user *buf, int in_len,
754 int out_len)
755 {
756 struct ib_uverbs_create_cq cmd;
757 struct ib_uverbs_create_cq_resp resp;
758 struct ib_udata udata;
759 struct ib_ucq_object *obj;
760 struct ib_uverbs_event_file *ev_file = NULL;
761 struct ib_cq *cq;
762 int ret;
763
764 if (out_len < sizeof resp)
765 return -ENOSPC;
766
767 if (copy_from_user(&cmd, buf, sizeof cmd))
768 return -EFAULT;
769
770 INIT_UDATA(&udata, buf + sizeof cmd,
771 (unsigned long) cmd.response + sizeof resp,
772 in_len - sizeof cmd, out_len - sizeof resp);
773
774 if (cmd.comp_vector >= file->device->num_comp_vectors)
775 return -EINVAL;
776
777 obj = kmalloc(sizeof *obj, GFP_KERNEL);
778 if (!obj)
779 return -ENOMEM;
780
781 init_uobj(&obj->uobject, cmd.user_handle, file->ucontext, &cq_lock_key);
782 down_write(&obj->uobject.mutex);
783
784 if (cmd.comp_channel >= 0) {
785 ev_file = ib_uverbs_lookup_comp_file(cmd.comp_channel);
786 if (!ev_file) {
787 ret = -EINVAL;
788 goto err;
789 }
790 }
791
792 obj->uverbs_file = file;
793 obj->comp_events_reported = 0;
794 obj->async_events_reported = 0;
795 INIT_LIST_HEAD(&obj->comp_list);
796 INIT_LIST_HEAD(&obj->async_list);
797
798 cq = file->device->ib_dev->create_cq(file->device->ib_dev, cmd.cqe,
799 file->ucontext, &udata);
800 if (IS_ERR(cq)) {
801 ret = PTR_ERR(cq);
802 goto err_file;
803 }
804
805 cq->device = file->device->ib_dev;
806 cq->uobject = &obj->uobject;
807 cq->comp_handler = ib_uverbs_comp_handler;
808 cq->event_handler = ib_uverbs_cq_event_handler;
809 cq->cq_context = ev_file;
810 atomic_set(&cq->usecnt, 0);
811
812 obj->uobject.object = cq;
813 ret = idr_add_uobj(&ib_uverbs_cq_idr, &obj->uobject);
814 if (ret)
815 goto err_free;
816
817 memset(&resp, 0, sizeof resp);
818 resp.cq_handle = obj->uobject.id;
819 resp.cqe = cq->cqe;
820
821 if (copy_to_user((void __user *) (unsigned long) cmd.response,
822 &resp, sizeof resp)) {
823 ret = -EFAULT;
824 goto err_copy;
825 }
826
827 mutex_lock(&file->mutex);
828 list_add_tail(&obj->uobject.list, &file->ucontext->cq_list);
829 mutex_unlock(&file->mutex);
830
831 obj->uobject.live = 1;
832
833 up_write(&obj->uobject.mutex);
834
835 return in_len;
836
837 err_copy:
838 idr_remove_uobj(&ib_uverbs_cq_idr, &obj->uobject);
839
840
841 err_free:
842 ib_destroy_cq(cq);
843
844 err_file:
845 if (ev_file)
846 ib_uverbs_release_ucq(file, ev_file, obj);
847
848 err:
849 put_uobj_write(&obj->uobject);
850 return ret;
851 }
852
853 ssize_t ib_uverbs_resize_cq(struct ib_uverbs_file *file,
854 const char __user *buf, int in_len,
855 int out_len)
856 {
857 struct ib_uverbs_resize_cq cmd;
858 struct ib_uverbs_resize_cq_resp resp;
859 struct ib_udata udata;
860 struct ib_cq *cq;
861 int ret = -EINVAL;
862
863 if (copy_from_user(&cmd, buf, sizeof cmd))
864 return -EFAULT;
865
866 INIT_UDATA(&udata, buf + sizeof cmd,
867 (unsigned long) cmd.response + sizeof resp,
868 in_len - sizeof cmd, out_len - sizeof resp);
869
870 cq = idr_read_cq(cmd.cq_handle, file->ucontext);
871 if (!cq)
872 return -EINVAL;
873
874 ret = cq->device->resize_cq(cq, cmd.cqe, &udata);
875 if (ret)
876 goto out;
877
878 memset(&resp, 0, sizeof resp);
879 resp.cqe = cq->cqe;
880
881 if (copy_to_user((void __user *) (unsigned long) cmd.response,
882 &resp, sizeof resp))
883 ret = -EFAULT;
884
885 out:
886 put_cq_read(cq);
887
888 return ret ? ret : in_len;
889 }
890
891 ssize_t ib_uverbs_poll_cq(struct ib_uverbs_file *file,
892 const char __user *buf, int in_len,
893 int out_len)
894 {
895 struct ib_uverbs_poll_cq cmd;
896 struct ib_uverbs_poll_cq_resp *resp;
897 struct ib_cq *cq;
898 struct ib_wc *wc;
899 int ret = 0;
900 int i;
901 int rsize;
902
903 if (copy_from_user(&cmd, buf, sizeof cmd))
904 return -EFAULT;
905
906 wc = kmalloc(cmd.ne * sizeof *wc, GFP_KERNEL);
907 if (!wc)
908 return -ENOMEM;
909
910 rsize = sizeof *resp + cmd.ne * sizeof(struct ib_uverbs_wc);
911 resp = kmalloc(rsize, GFP_KERNEL);
912 if (!resp) {
913 ret = -ENOMEM;
914 goto out_wc;
915 }
916
917 cq = idr_read_cq(cmd.cq_handle, file->ucontext);
918 if (!cq) {
919 ret = -EINVAL;
920 goto out;
921 }
922
923 resp->count = ib_poll_cq(cq, cmd.ne, wc);
924
925 put_cq_read(cq);
926
927 for (i = 0; i < resp->count; i++) {
928 resp->wc[i].wr_id = wc[i].wr_id;
929 resp->wc[i].status = wc[i].status;
930 resp->wc[i].opcode = wc[i].opcode;
931 resp->wc[i].vendor_err = wc[i].vendor_err;
932 resp->wc[i].byte_len = wc[i].byte_len;
933 resp->wc[i].imm_data = (__u32 __force) wc[i].imm_data;
934 resp->wc[i].qp_num = wc[i].qp_num;
935 resp->wc[i].src_qp = wc[i].src_qp;
936 resp->wc[i].wc_flags = wc[i].wc_flags;
937 resp->wc[i].pkey_index = wc[i].pkey_index;
938 resp->wc[i].slid = wc[i].slid;
939 resp->wc[i].sl = wc[i].sl;
940 resp->wc[i].dlid_path_bits = wc[i].dlid_path_bits;
941 resp->wc[i].port_num = wc[i].port_num;
942 }
943
944 if (copy_to_user((void __user *) (unsigned long) cmd.response, resp, rsize))
945 ret = -EFAULT;
946
947 out:
948 kfree(resp);
949
950 out_wc:
951 kfree(wc);
952 return ret ? ret : in_len;
953 }
954
955 ssize_t ib_uverbs_req_notify_cq(struct ib_uverbs_file *file,
956 const char __user *buf, int in_len,
957 int out_len)
958 {
959 struct ib_uverbs_req_notify_cq cmd;
960 struct ib_cq *cq;
961
962 if (copy_from_user(&cmd, buf, sizeof cmd))
963 return -EFAULT;
964
965 cq = idr_read_cq(cmd.cq_handle, file->ucontext);
966 if (!cq)
967 return -EINVAL;
968
969 ib_req_notify_cq(cq, cmd.solicited_only ?
970 IB_CQ_SOLICITED : IB_CQ_NEXT_COMP);
971
972 put_cq_read(cq);
973
974 return in_len;
975 }
976
977 ssize_t ib_uverbs_destroy_cq(struct ib_uverbs_file *file,
978 const char __user *buf, int in_len,
979 int out_len)
980 {
981 struct ib_uverbs_destroy_cq cmd;
982 struct ib_uverbs_destroy_cq_resp resp;
983 struct ib_uobject *uobj;
984 struct ib_cq *cq;
985 struct ib_ucq_object *obj;
986 struct ib_uverbs_event_file *ev_file;
987 int ret = -EINVAL;
988
989 if (copy_from_user(&cmd, buf, sizeof cmd))
990 return -EFAULT;
991
992 uobj = idr_write_uobj(&ib_uverbs_cq_idr, cmd.cq_handle, file->ucontext);
993 if (!uobj)
994 return -EINVAL;
995 cq = uobj->object;
996 ev_file = cq->cq_context;
997 obj = container_of(cq->uobject, struct ib_ucq_object, uobject);
998
999 ret = ib_destroy_cq(cq);
1000 if (!ret)
1001 uobj->live = 0;
1002
1003 put_uobj_write(uobj);
1004
1005 if (ret)
1006 return ret;
1007
1008 idr_remove_uobj(&ib_uverbs_cq_idr, uobj);
1009
1010 mutex_lock(&file->mutex);
1011 list_del(&uobj->list);
1012 mutex_unlock(&file->mutex);
1013
1014 ib_uverbs_release_ucq(file, ev_file, obj);
1015
1016 memset(&resp, 0, sizeof resp);
1017 resp.comp_events_reported = obj->comp_events_reported;
1018 resp.async_events_reported = obj->async_events_reported;
1019
1020 put_uobj(uobj);
1021
1022 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1023 &resp, sizeof resp))
1024 return -EFAULT;
1025
1026 return in_len;
1027 }
1028
1029 ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file,
1030 const char __user *buf, int in_len,
1031 int out_len)
1032 {
1033 struct ib_uverbs_create_qp cmd;
1034 struct ib_uverbs_create_qp_resp resp;
1035 struct ib_udata udata;
1036 struct ib_uqp_object *obj;
1037 struct ib_pd *pd;
1038 struct ib_cq *scq, *rcq;
1039 struct ib_srq *srq;
1040 struct ib_qp *qp;
1041 struct ib_qp_init_attr attr;
1042 int ret;
1043
1044 if (out_len < sizeof resp)
1045 return -ENOSPC;
1046
1047 if (copy_from_user(&cmd, buf, sizeof cmd))
1048 return -EFAULT;
1049
1050 INIT_UDATA(&udata, buf + sizeof cmd,
1051 (unsigned long) cmd.response + sizeof resp,
1052 in_len - sizeof cmd, out_len - sizeof resp);
1053
1054 obj = kmalloc(sizeof *obj, GFP_KERNEL);
1055 if (!obj)
1056 return -ENOMEM;
1057
1058 init_uobj(&obj->uevent.uobject, cmd.user_handle, file->ucontext, &qp_lock_key);
1059 down_write(&obj->uevent.uobject.mutex);
1060
1061 srq = cmd.is_srq ? idr_read_srq(cmd.srq_handle, file->ucontext) : NULL;
1062 pd = idr_read_pd(cmd.pd_handle, file->ucontext);
1063 scq = idr_read_cq(cmd.send_cq_handle, file->ucontext);
1064 rcq = cmd.recv_cq_handle == cmd.send_cq_handle ?
1065 scq : idr_read_cq(cmd.recv_cq_handle, file->ucontext);
1066
1067 if (!pd || !scq || !rcq || (cmd.is_srq && !srq)) {
1068 ret = -EINVAL;
1069 goto err_put;
1070 }
1071
1072 attr.event_handler = ib_uverbs_qp_event_handler;
1073 attr.qp_context = file;
1074 attr.send_cq = scq;
1075 attr.recv_cq = rcq;
1076 attr.srq = srq;
1077 attr.sq_sig_type = cmd.sq_sig_all ? IB_SIGNAL_ALL_WR : IB_SIGNAL_REQ_WR;
1078 attr.qp_type = cmd.qp_type;
1079
1080 attr.cap.max_send_wr = cmd.max_send_wr;
1081 attr.cap.max_recv_wr = cmd.max_recv_wr;
1082 attr.cap.max_send_sge = cmd.max_send_sge;
1083 attr.cap.max_recv_sge = cmd.max_recv_sge;
1084 attr.cap.max_inline_data = cmd.max_inline_data;
1085
1086 obj->uevent.events_reported = 0;
1087 INIT_LIST_HEAD(&obj->uevent.event_list);
1088 INIT_LIST_HEAD(&obj->mcast_list);
1089
1090 qp = pd->device->create_qp(pd, &attr, &udata);
1091 if (IS_ERR(qp)) {
1092 ret = PTR_ERR(qp);
1093 goto err_put;
1094 }
1095
1096 qp->device = pd->device;
1097 qp->pd = pd;
1098 qp->send_cq = attr.send_cq;
1099 qp->recv_cq = attr.recv_cq;
1100 qp->srq = attr.srq;
1101 qp->uobject = &obj->uevent.uobject;
1102 qp->event_handler = attr.event_handler;
1103 qp->qp_context = attr.qp_context;
1104 qp->qp_type = attr.qp_type;
1105 atomic_inc(&pd->usecnt);
1106 atomic_inc(&attr.send_cq->usecnt);
1107 atomic_inc(&attr.recv_cq->usecnt);
1108 if (attr.srq)
1109 atomic_inc(&attr.srq->usecnt);
1110
1111 obj->uevent.uobject.object = qp;
1112 ret = idr_add_uobj(&ib_uverbs_qp_idr, &obj->uevent.uobject);
1113 if (ret)
1114 goto err_destroy;
1115
1116 memset(&resp, 0, sizeof resp);
1117 resp.qpn = qp->qp_num;
1118 resp.qp_handle = obj->uevent.uobject.id;
1119 resp.max_recv_sge = attr.cap.max_recv_sge;
1120 resp.max_send_sge = attr.cap.max_send_sge;
1121 resp.max_recv_wr = attr.cap.max_recv_wr;
1122 resp.max_send_wr = attr.cap.max_send_wr;
1123 resp.max_inline_data = attr.cap.max_inline_data;
1124
1125 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1126 &resp, sizeof resp)) {
1127 ret = -EFAULT;
1128 goto err_copy;
1129 }
1130
1131 put_pd_read(pd);
1132 put_cq_read(scq);
1133 if (rcq != scq)
1134 put_cq_read(rcq);
1135 if (srq)
1136 put_srq_read(srq);
1137
1138 mutex_lock(&file->mutex);
1139 list_add_tail(&obj->uevent.uobject.list, &file->ucontext->qp_list);
1140 mutex_unlock(&file->mutex);
1141
1142 obj->uevent.uobject.live = 1;
1143
1144 up_write(&obj->uevent.uobject.mutex);
1145
1146 return in_len;
1147
1148 err_copy:
1149 idr_remove_uobj(&ib_uverbs_qp_idr, &obj->uevent.uobject);
1150
1151 err_destroy:
1152 ib_destroy_qp(qp);
1153
1154 err_put:
1155 if (pd)
1156 put_pd_read(pd);
1157 if (scq)
1158 put_cq_read(scq);
1159 if (rcq && rcq != scq)
1160 put_cq_read(rcq);
1161 if (srq)
1162 put_srq_read(srq);
1163
1164 put_uobj_write(&obj->uevent.uobject);
1165 return ret;
1166 }
1167
1168 ssize_t ib_uverbs_query_qp(struct ib_uverbs_file *file,
1169 const char __user *buf, int in_len,
1170 int out_len)
1171 {
1172 struct ib_uverbs_query_qp cmd;
1173 struct ib_uverbs_query_qp_resp resp;
1174 struct ib_qp *qp;
1175 struct ib_qp_attr *attr;
1176 struct ib_qp_init_attr *init_attr;
1177 int ret;
1178
1179 if (copy_from_user(&cmd, buf, sizeof cmd))
1180 return -EFAULT;
1181
1182 attr = kmalloc(sizeof *attr, GFP_KERNEL);
1183 init_attr = kmalloc(sizeof *init_attr, GFP_KERNEL);
1184 if (!attr || !init_attr) {
1185 ret = -ENOMEM;
1186 goto out;
1187 }
1188
1189 qp = idr_read_qp(cmd.qp_handle, file->ucontext);
1190 if (!qp) {
1191 ret = -EINVAL;
1192 goto out;
1193 }
1194
1195 ret = ib_query_qp(qp, attr, cmd.attr_mask, init_attr);
1196
1197 put_qp_read(qp);
1198
1199 if (ret)
1200 goto out;
1201
1202 memset(&resp, 0, sizeof resp);
1203
1204 resp.qp_state = attr->qp_state;
1205 resp.cur_qp_state = attr->cur_qp_state;
1206 resp.path_mtu = attr->path_mtu;
1207 resp.path_mig_state = attr->path_mig_state;
1208 resp.qkey = attr->qkey;
1209 resp.rq_psn = attr->rq_psn;
1210 resp.sq_psn = attr->sq_psn;
1211 resp.dest_qp_num = attr->dest_qp_num;
1212 resp.qp_access_flags = attr->qp_access_flags;
1213 resp.pkey_index = attr->pkey_index;
1214 resp.alt_pkey_index = attr->alt_pkey_index;
1215 resp.en_sqd_async_notify = attr->en_sqd_async_notify;
1216 resp.max_rd_atomic = attr->max_rd_atomic;
1217 resp.max_dest_rd_atomic = attr->max_dest_rd_atomic;
1218 resp.min_rnr_timer = attr->min_rnr_timer;
1219 resp.port_num = attr->port_num;
1220 resp.timeout = attr->timeout;
1221 resp.retry_cnt = attr->retry_cnt;
1222 resp.rnr_retry = attr->rnr_retry;
1223 resp.alt_port_num = attr->alt_port_num;
1224 resp.alt_timeout = attr->alt_timeout;
1225
1226 memcpy(resp.dest.dgid, attr->ah_attr.grh.dgid.raw, 16);
1227 resp.dest.flow_label = attr->ah_attr.grh.flow_label;
1228 resp.dest.sgid_index = attr->ah_attr.grh.sgid_index;
1229 resp.dest.hop_limit = attr->ah_attr.grh.hop_limit;
1230 resp.dest.traffic_class = attr->ah_attr.grh.traffic_class;
1231 resp.dest.dlid = attr->ah_attr.dlid;
1232 resp.dest.sl = attr->ah_attr.sl;
1233 resp.dest.src_path_bits = attr->ah_attr.src_path_bits;
1234 resp.dest.static_rate = attr->ah_attr.static_rate;
1235 resp.dest.is_global = !!(attr->ah_attr.ah_flags & IB_AH_GRH);
1236 resp.dest.port_num = attr->ah_attr.port_num;
1237
1238 memcpy(resp.alt_dest.dgid, attr->alt_ah_attr.grh.dgid.raw, 16);
1239 resp.alt_dest.flow_label = attr->alt_ah_attr.grh.flow_label;
1240 resp.alt_dest.sgid_index = attr->alt_ah_attr.grh.sgid_index;
1241 resp.alt_dest.hop_limit = attr->alt_ah_attr.grh.hop_limit;
1242 resp.alt_dest.traffic_class = attr->alt_ah_attr.grh.traffic_class;
1243 resp.alt_dest.dlid = attr->alt_ah_attr.dlid;
1244 resp.alt_dest.sl = attr->alt_ah_attr.sl;
1245 resp.alt_dest.src_path_bits = attr->alt_ah_attr.src_path_bits;
1246 resp.alt_dest.static_rate = attr->alt_ah_attr.static_rate;
1247 resp.alt_dest.is_global = !!(attr->alt_ah_attr.ah_flags & IB_AH_GRH);
1248 resp.alt_dest.port_num = attr->alt_ah_attr.port_num;
1249
1250 resp.max_send_wr = init_attr->cap.max_send_wr;
1251 resp.max_recv_wr = init_attr->cap.max_recv_wr;
1252 resp.max_send_sge = init_attr->cap.max_send_sge;
1253 resp.max_recv_sge = init_attr->cap.max_recv_sge;
1254 resp.max_inline_data = init_attr->cap.max_inline_data;
1255 resp.sq_sig_all = init_attr->sq_sig_type == IB_SIGNAL_ALL_WR;
1256
1257 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1258 &resp, sizeof resp))
1259 ret = -EFAULT;
1260
1261 out:
1262 kfree(attr);
1263 kfree(init_attr);
1264
1265 return ret ? ret : in_len;
1266 }
1267
1268 ssize_t ib_uverbs_modify_qp(struct ib_uverbs_file *file,
1269 const char __user *buf, int in_len,
1270 int out_len)
1271 {
1272 struct ib_uverbs_modify_qp cmd;
1273 struct ib_qp *qp;
1274 struct ib_qp_attr *attr;
1275 int ret;
1276
1277 if (copy_from_user(&cmd, buf, sizeof cmd))
1278 return -EFAULT;
1279
1280 attr = kmalloc(sizeof *attr, GFP_KERNEL);
1281 if (!attr)
1282 return -ENOMEM;
1283
1284 qp = idr_read_qp(cmd.qp_handle, file->ucontext);
1285 if (!qp) {
1286 ret = -EINVAL;
1287 goto out;
1288 }
1289
1290 attr->qp_state = cmd.qp_state;
1291 attr->cur_qp_state = cmd.cur_qp_state;
1292 attr->path_mtu = cmd.path_mtu;
1293 attr->path_mig_state = cmd.path_mig_state;
1294 attr->qkey = cmd.qkey;
1295 attr->rq_psn = cmd.rq_psn;
1296 attr->sq_psn = cmd.sq_psn;
1297 attr->dest_qp_num = cmd.dest_qp_num;
1298 attr->qp_access_flags = cmd.qp_access_flags;
1299 attr->pkey_index = cmd.pkey_index;
1300 attr->alt_pkey_index = cmd.alt_pkey_index;
1301 attr->en_sqd_async_notify = cmd.en_sqd_async_notify;
1302 attr->max_rd_atomic = cmd.max_rd_atomic;
1303 attr->max_dest_rd_atomic = cmd.max_dest_rd_atomic;
1304 attr->min_rnr_timer = cmd.min_rnr_timer;
1305 attr->port_num = cmd.port_num;
1306 attr->timeout = cmd.timeout;
1307 attr->retry_cnt = cmd.retry_cnt;
1308 attr->rnr_retry = cmd.rnr_retry;
1309 attr->alt_port_num = cmd.alt_port_num;
1310 attr->alt_timeout = cmd.alt_timeout;
1311
1312 memcpy(attr->ah_attr.grh.dgid.raw, cmd.dest.dgid, 16);
1313 attr->ah_attr.grh.flow_label = cmd.dest.flow_label;
1314 attr->ah_attr.grh.sgid_index = cmd.dest.sgid_index;
1315 attr->ah_attr.grh.hop_limit = cmd.dest.hop_limit;
1316 attr->ah_attr.grh.traffic_class = cmd.dest.traffic_class;
1317 attr->ah_attr.dlid = cmd.dest.dlid;
1318 attr->ah_attr.sl = cmd.dest.sl;
1319 attr->ah_attr.src_path_bits = cmd.dest.src_path_bits;
1320 attr->ah_attr.static_rate = cmd.dest.static_rate;
1321 attr->ah_attr.ah_flags = cmd.dest.is_global ? IB_AH_GRH : 0;
1322 attr->ah_attr.port_num = cmd.dest.port_num;
1323
1324 memcpy(attr->alt_ah_attr.grh.dgid.raw, cmd.alt_dest.dgid, 16);
1325 attr->alt_ah_attr.grh.flow_label = cmd.alt_dest.flow_label;
1326 attr->alt_ah_attr.grh.sgid_index = cmd.alt_dest.sgid_index;
1327 attr->alt_ah_attr.grh.hop_limit = cmd.alt_dest.hop_limit;
1328 attr->alt_ah_attr.grh.traffic_class = cmd.alt_dest.traffic_class;
1329 attr->alt_ah_attr.dlid = cmd.alt_dest.dlid;
1330 attr->alt_ah_attr.sl = cmd.alt_dest.sl;
1331 attr->alt_ah_attr.src_path_bits = cmd.alt_dest.src_path_bits;
1332 attr->alt_ah_attr.static_rate = cmd.alt_dest.static_rate;
1333 attr->alt_ah_attr.ah_flags = cmd.alt_dest.is_global ? IB_AH_GRH : 0;
1334 attr->alt_ah_attr.port_num = cmd.alt_dest.port_num;
1335
1336 ret = ib_modify_qp(qp, attr, cmd.attr_mask);
1337
1338 put_qp_read(qp);
1339
1340 if (ret)
1341 goto out;
1342
1343 ret = in_len;
1344
1345 out:
1346 kfree(attr);
1347
1348 return ret;
1349 }
1350
1351 ssize_t ib_uverbs_destroy_qp(struct ib_uverbs_file *file,
1352 const char __user *buf, int in_len,
1353 int out_len)
1354 {
1355 struct ib_uverbs_destroy_qp cmd;
1356 struct ib_uverbs_destroy_qp_resp resp;
1357 struct ib_uobject *uobj;
1358 struct ib_qp *qp;
1359 struct ib_uqp_object *obj;
1360 int ret = -EINVAL;
1361
1362 if (copy_from_user(&cmd, buf, sizeof cmd))
1363 return -EFAULT;
1364
1365 memset(&resp, 0, sizeof resp);
1366
1367 uobj = idr_write_uobj(&ib_uverbs_qp_idr, cmd.qp_handle, file->ucontext);
1368 if (!uobj)
1369 return -EINVAL;
1370 qp = uobj->object;
1371 obj = container_of(uobj, struct ib_uqp_object, uevent.uobject);
1372
1373 if (!list_empty(&obj->mcast_list)) {
1374 put_uobj_write(uobj);
1375 return -EBUSY;
1376 }
1377
1378 ret = ib_destroy_qp(qp);
1379 if (!ret)
1380 uobj->live = 0;
1381
1382 put_uobj_write(uobj);
1383
1384 if (ret)
1385 return ret;
1386
1387 idr_remove_uobj(&ib_uverbs_qp_idr, uobj);
1388
1389 mutex_lock(&file->mutex);
1390 list_del(&uobj->list);
1391 mutex_unlock(&file->mutex);
1392
1393 ib_uverbs_release_uevent(file, &obj->uevent);
1394
1395 resp.events_reported = obj->uevent.events_reported;
1396
1397 put_uobj(uobj);
1398
1399 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1400 &resp, sizeof resp))
1401 return -EFAULT;
1402
1403 return in_len;
1404 }
1405
1406 ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file,
1407 const char __user *buf, int in_len,
1408 int out_len)
1409 {
1410 struct ib_uverbs_post_send cmd;
1411 struct ib_uverbs_post_send_resp resp;
1412 struct ib_uverbs_send_wr *user_wr;
1413 struct ib_send_wr *wr = NULL, *last, *next, *bad_wr;
1414 struct ib_qp *qp;
1415 int i, sg_ind;
1416 int is_ud;
1417 ssize_t ret = -EINVAL;
1418
1419 if (copy_from_user(&cmd, buf, sizeof cmd))
1420 return -EFAULT;
1421
1422 if (in_len < sizeof cmd + cmd.wqe_size * cmd.wr_count +
1423 cmd.sge_count * sizeof (struct ib_uverbs_sge))
1424 return -EINVAL;
1425
1426 if (cmd.wqe_size < sizeof (struct ib_uverbs_send_wr))
1427 return -EINVAL;
1428
1429 user_wr = kmalloc(cmd.wqe_size, GFP_KERNEL);
1430 if (!user_wr)
1431 return -ENOMEM;
1432
1433 qp = idr_read_qp(cmd.qp_handle, file->ucontext);
1434 if (!qp)
1435 goto out;
1436
1437 is_ud = qp->qp_type == IB_QPT_UD;
1438 sg_ind = 0;
1439 last = NULL;
1440 for (i = 0; i < cmd.wr_count; ++i) {
1441 if (copy_from_user(user_wr,
1442 buf + sizeof cmd + i * cmd.wqe_size,
1443 cmd.wqe_size)) {
1444 ret = -EFAULT;
1445 goto out_put;
1446 }
1447
1448 if (user_wr->num_sge + sg_ind > cmd.sge_count) {
1449 ret = -EINVAL;
1450 goto out_put;
1451 }
1452
1453 next = kmalloc(ALIGN(sizeof *next, sizeof (struct ib_sge)) +
1454 user_wr->num_sge * sizeof (struct ib_sge),
1455 GFP_KERNEL);
1456 if (!next) {
1457 ret = -ENOMEM;
1458 goto out_put;
1459 }
1460
1461 if (!last)
1462 wr = next;
1463 else
1464 last->next = next;
1465 last = next;
1466
1467 next->next = NULL;
1468 next->wr_id = user_wr->wr_id;
1469 next->num_sge = user_wr->num_sge;
1470 next->opcode = user_wr->opcode;
1471 next->send_flags = user_wr->send_flags;
1472 next->imm_data = (__be32 __force) user_wr->imm_data;
1473
1474 if (is_ud) {
1475 next->wr.ud.ah = idr_read_ah(user_wr->wr.ud.ah,
1476 file->ucontext);
1477 if (!next->wr.ud.ah) {
1478 ret = -EINVAL;
1479 goto out_put;
1480 }
1481 next->wr.ud.remote_qpn = user_wr->wr.ud.remote_qpn;
1482 next->wr.ud.remote_qkey = user_wr->wr.ud.remote_qkey;
1483 } else {
1484 switch (next->opcode) {
1485 case IB_WR_RDMA_WRITE:
1486 case IB_WR_RDMA_WRITE_WITH_IMM:
1487 case IB_WR_RDMA_READ:
1488 next->wr.rdma.remote_addr =
1489 user_wr->wr.rdma.remote_addr;
1490 next->wr.rdma.rkey =
1491 user_wr->wr.rdma.rkey;
1492 break;
1493 case IB_WR_ATOMIC_CMP_AND_SWP:
1494 case IB_WR_ATOMIC_FETCH_AND_ADD:
1495 next->wr.atomic.remote_addr =
1496 user_wr->wr.atomic.remote_addr;
1497 next->wr.atomic.compare_add =
1498 user_wr->wr.atomic.compare_add;
1499 next->wr.atomic.swap = user_wr->wr.atomic.swap;
1500 next->wr.atomic.rkey = user_wr->wr.atomic.rkey;
1501 break;
1502 default:
1503 break;
1504 }
1505 }
1506
1507 if (next->num_sge) {
1508 next->sg_list = (void *) next +
1509 ALIGN(sizeof *next, sizeof (struct ib_sge));
1510 if (copy_from_user(next->sg_list,
1511 buf + sizeof cmd +
1512 cmd.wr_count * cmd.wqe_size +
1513 sg_ind * sizeof (struct ib_sge),
1514 next->num_sge * sizeof (struct ib_sge))) {
1515 ret = -EFAULT;
1516 goto out_put;
1517 }
1518 sg_ind += next->num_sge;
1519 } else
1520 next->sg_list = NULL;
1521 }
1522
1523 resp.bad_wr = 0;
1524 ret = qp->device->post_send(qp, wr, &bad_wr);
1525 if (ret)
1526 for (next = wr; next; next = next->next) {
1527 ++resp.bad_wr;
1528 if (next == bad_wr)
1529 break;
1530 }
1531
1532 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1533 &resp, sizeof resp))
1534 ret = -EFAULT;
1535
1536 out_put:
1537 put_qp_read(qp);
1538
1539 while (wr) {
1540 if (is_ud && wr->wr.ud.ah)
1541 put_ah_read(wr->wr.ud.ah);
1542 next = wr->next;
1543 kfree(wr);
1544 wr = next;
1545 }
1546
1547 out:
1548 kfree(user_wr);
1549
1550 return ret ? ret : in_len;
1551 }
1552
1553 static struct ib_recv_wr *ib_uverbs_unmarshall_recv(const char __user *buf,
1554 int in_len,
1555 u32 wr_count,
1556 u32 sge_count,
1557 u32 wqe_size)
1558 {
1559 struct ib_uverbs_recv_wr *user_wr;
1560 struct ib_recv_wr *wr = NULL, *last, *next;
1561 int sg_ind;
1562 int i;
1563 int ret;
1564
1565 if (in_len < wqe_size * wr_count +
1566 sge_count * sizeof (struct ib_uverbs_sge))
1567 return ERR_PTR(-EINVAL);
1568
1569 if (wqe_size < sizeof (struct ib_uverbs_recv_wr))
1570 return ERR_PTR(-EINVAL);
1571
1572 user_wr = kmalloc(wqe_size, GFP_KERNEL);
1573 if (!user_wr)
1574 return ERR_PTR(-ENOMEM);
1575
1576 sg_ind = 0;
1577 last = NULL;
1578 for (i = 0; i < wr_count; ++i) {
1579 if (copy_from_user(user_wr, buf + i * wqe_size,
1580 wqe_size)) {
1581 ret = -EFAULT;
1582 goto err;
1583 }
1584
1585 if (user_wr->num_sge + sg_ind > sge_count) {
1586 ret = -EINVAL;
1587 goto err;
1588 }
1589
1590 next = kmalloc(ALIGN(sizeof *next, sizeof (struct ib_sge)) +
1591 user_wr->num_sge * sizeof (struct ib_sge),
1592 GFP_KERNEL);
1593 if (!next) {
1594 ret = -ENOMEM;
1595 goto err;
1596 }
1597
1598 if (!last)
1599 wr = next;
1600 else
1601 last->next = next;
1602 last = next;
1603
1604 next->next = NULL;
1605 next->wr_id = user_wr->wr_id;
1606 next->num_sge = user_wr->num_sge;
1607
1608 if (next->num_sge) {
1609 next->sg_list = (void *) next +
1610 ALIGN(sizeof *next, sizeof (struct ib_sge));
1611 if (copy_from_user(next->sg_list,
1612 buf + wr_count * wqe_size +
1613 sg_ind * sizeof (struct ib_sge),
1614 next->num_sge * sizeof (struct ib_sge))) {
1615 ret = -EFAULT;
1616 goto err;
1617 }
1618 sg_ind += next->num_sge;
1619 } else
1620 next->sg_list = NULL;
1621 }
1622
1623 kfree(user_wr);
1624 return wr;
1625
1626 err:
1627 kfree(user_wr);
1628
1629 while (wr) {
1630 next = wr->next;
1631 kfree(wr);
1632 wr = next;
1633 }
1634
1635 return ERR_PTR(ret);
1636 }
1637
1638 ssize_t ib_uverbs_post_recv(struct ib_uverbs_file *file,
1639 const char __user *buf, int in_len,
1640 int out_len)
1641 {
1642 struct ib_uverbs_post_recv cmd;
1643 struct ib_uverbs_post_recv_resp resp;
1644 struct ib_recv_wr *wr, *next, *bad_wr;
1645 struct ib_qp *qp;
1646 ssize_t ret = -EINVAL;
1647
1648 if (copy_from_user(&cmd, buf, sizeof cmd))
1649 return -EFAULT;
1650
1651 wr = ib_uverbs_unmarshall_recv(buf + sizeof cmd,
1652 in_len - sizeof cmd, cmd.wr_count,
1653 cmd.sge_count, cmd.wqe_size);
1654 if (IS_ERR(wr))
1655 return PTR_ERR(wr);
1656
1657 qp = idr_read_qp(cmd.qp_handle, file->ucontext);
1658 if (!qp)
1659 goto out;
1660
1661 resp.bad_wr = 0;
1662 ret = qp->device->post_recv(qp, wr, &bad_wr);
1663
1664 put_qp_read(qp);
1665
1666 if (ret)
1667 for (next = wr; next; next = next->next) {
1668 ++resp.bad_wr;
1669 if (next == bad_wr)
1670 break;
1671 }
1672
1673
1674 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1675 &resp, sizeof resp))
1676 ret = -EFAULT;
1677
1678 out:
1679 while (wr) {
1680 next = wr->next;
1681 kfree(wr);
1682 wr = next;
1683 }
1684
1685 return ret ? ret : in_len;
1686 }
1687
1688 ssize_t ib_uverbs_post_srq_recv(struct ib_uverbs_file *file,
1689 const char __user *buf, int in_len,
1690 int out_len)
1691 {
1692 struct ib_uverbs_post_srq_recv cmd;
1693 struct ib_uverbs_post_srq_recv_resp resp;
1694 struct ib_recv_wr *wr, *next, *bad_wr;
1695 struct ib_srq *srq;
1696 ssize_t ret = -EINVAL;
1697
1698 if (copy_from_user(&cmd, buf, sizeof cmd))
1699 return -EFAULT;
1700
1701 wr = ib_uverbs_unmarshall_recv(buf + sizeof cmd,
1702 in_len - sizeof cmd, cmd.wr_count,
1703 cmd.sge_count, cmd.wqe_size);
1704 if (IS_ERR(wr))
1705 return PTR_ERR(wr);
1706
1707 srq = idr_read_srq(cmd.srq_handle, file->ucontext);
1708 if (!srq)
1709 goto out;
1710
1711 resp.bad_wr = 0;
1712 ret = srq->device->post_srq_recv(srq, wr, &bad_wr);
1713
1714 put_srq_read(srq);
1715
1716 if (ret)
1717 for (next = wr; next; next = next->next) {
1718 ++resp.bad_wr;
1719 if (next == bad_wr)
1720 break;
1721 }
1722
1723
1724 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1725 &resp, sizeof resp))
1726 ret = -EFAULT;
1727
1728 out:
1729 while (wr) {
1730 next = wr->next;
1731 kfree(wr);
1732 wr = next;
1733 }
1734
1735 return ret ? ret : in_len;
1736 }
1737
1738 ssize_t ib_uverbs_create_ah(struct ib_uverbs_file *file,
1739 const char __user *buf, int in_len,
1740 int out_len)
1741 {
1742 struct ib_uverbs_create_ah cmd;
1743 struct ib_uverbs_create_ah_resp resp;
1744 struct ib_uobject *uobj;
1745 struct ib_pd *pd;
1746 struct ib_ah *ah;
1747 struct ib_ah_attr attr;
1748 int ret;
1749
1750 if (out_len < sizeof resp)
1751 return -ENOSPC;
1752
1753 if (copy_from_user(&cmd, buf, sizeof cmd))
1754 return -EFAULT;
1755
1756 uobj = kmalloc(sizeof *uobj, GFP_KERNEL);
1757 if (!uobj)
1758 return -ENOMEM;
1759
1760 init_uobj(uobj, cmd.user_handle, file->ucontext, &ah_lock_key);
1761 down_write(&uobj->mutex);
1762
1763 pd = idr_read_pd(cmd.pd_handle, file->ucontext);
1764 if (!pd) {
1765 ret = -EINVAL;
1766 goto err;
1767 }
1768
1769 attr.dlid = cmd.attr.dlid;
1770 attr.sl = cmd.attr.sl;
1771 attr.src_path_bits = cmd.attr.src_path_bits;
1772 attr.static_rate = cmd.attr.static_rate;
1773 attr.ah_flags = cmd.attr.is_global ? IB_AH_GRH : 0;
1774 attr.port_num = cmd.attr.port_num;
1775 attr.grh.flow_label = cmd.attr.grh.flow_label;
1776 attr.grh.sgid_index = cmd.attr.grh.sgid_index;
1777 attr.grh.hop_limit = cmd.attr.grh.hop_limit;
1778 attr.grh.traffic_class = cmd.attr.grh.traffic_class;
1779 memcpy(attr.grh.dgid.raw, cmd.attr.grh.dgid, 16);
1780
1781 ah = ib_create_ah(pd, &attr);
1782 if (IS_ERR(ah)) {
1783 ret = PTR_ERR(ah);
1784 goto err_put;
1785 }
1786
1787 ah->uobject = uobj;
1788 uobj->object = ah;
1789
1790 ret = idr_add_uobj(&ib_uverbs_ah_idr, uobj);
1791 if (ret)
1792 goto err_destroy;
1793
1794 resp.ah_handle = uobj->id;
1795
1796 if (copy_to_user((void __user *) (unsigned long) cmd.response,
1797 &resp, sizeof resp)) {
1798 ret = -EFAULT;
1799 goto err_copy;
1800 }
1801
1802 put_pd_read(pd);
1803
1804 mutex_lock(&file->mutex);
1805 list_add_tail(&uobj->list, &file->ucontext->ah_list);
1806 mutex_unlock(&file->mutex);
1807
1808 uobj->live = 1;
1809
1810 up_write(&uobj->mutex);
1811
1812 return in_len;
1813
1814 err_copy:
1815 idr_remove_uobj(&ib_uverbs_ah_idr, uobj);
1816
1817 err_destroy:
1818 ib_destroy_ah(ah);
1819
1820 err_put:
1821 put_pd_read(pd);
1822
1823 err:
1824 put_uobj_write(uobj);
1825 return ret;
1826 }
1827
1828 ssize_t ib_uverbs_destroy_ah(struct ib_uverbs_file *file,
1829 const char __user *buf, int in_len, int out_len)
1830 {
1831 struct ib_uverbs_destroy_ah cmd;
1832 struct ib_ah *ah;
1833 struct ib_uobject *uobj;
1834 int ret;
1835
1836 if (copy_from_user(&cmd, buf, sizeof cmd))
1837 return -EFAULT;
1838
1839 uobj = idr_write_uobj(&ib_uverbs_ah_idr, cmd.ah_handle, file->ucontext);
1840 if (!uobj)
1841 return -EINVAL;
1842 ah = uobj->object;
1843
1844 ret = ib_destroy_ah(ah);
1845 if (!ret)
1846 uobj->live = 0;
1847
1848 put_uobj_write(uobj);
1849
1850 if (ret)
1851 return ret;
1852
1853 idr_remove_uobj(&ib_uverbs_ah_idr, uobj);
1854
1855 mutex_lock(&file->mutex);
1856 list_del(&uobj->list);
1857 mutex_unlock(&file->mutex);
1858
1859 put_uobj(uobj);
1860
1861 return in_len;
1862 }
1863
1864 ssize_t ib_uverbs_attach_mcast(struct ib_uverbs_file *file,
1865 const char __user *buf, int in_len,
1866 int out_len)
1867 {
1868 struct ib_uverbs_attach_mcast cmd;
1869 struct ib_qp *qp;
1870 struct ib_uqp_object *obj;
1871 struct ib_uverbs_mcast_entry *mcast;
1872 int ret;
1873
1874 if (copy_from_user(&cmd, buf, sizeof cmd))
1875 return -EFAULT;
1876
1877 qp = idr_read_qp(cmd.qp_handle, file->ucontext);
1878 if (!qp)
1879 return -EINVAL;
1880
1881 obj = container_of(qp->uobject, struct ib_uqp_object, uevent.uobject);
1882
1883 list_for_each_entry(mcast, &obj->mcast_list, list)
1884 if (cmd.mlid == mcast->lid &&
1885 !memcmp(cmd.gid, mcast->gid.raw, sizeof mcast->gid.raw)) {
1886 ret = 0;
1887 goto out_put;
1888 }
1889
1890 mcast = kmalloc(sizeof *mcast, GFP_KERNEL);
1891 if (!mcast) {
1892 ret = -ENOMEM;
1893 goto out_put;
1894 }
1895
1896 mcast->lid = cmd.mlid;
1897 memcpy(mcast->gid.raw, cmd.gid, sizeof mcast->gid.raw);
1898
1899 ret = ib_attach_mcast(qp, &mcast->gid, cmd.mlid);
1900 if (!ret)
1901 list_add_tail(&mcast->list, &obj->mcast_list);
1902 else
1903 kfree(mcast);
1904
1905 out_put:
1906 put_qp_read(qp);
1907
1908 return ret ? ret : in_len;
1909 }
1910
1911 ssize_t ib_uverbs_detach_mcast(struct ib_uverbs_file *file,
1912 const char __user *buf, int in_len,
1913 int out_len)
1914 {
1915 struct ib_uverbs_detach_mcast cmd;
1916 struct ib_uqp_object *obj;
1917 struct ib_qp *qp;
1918 struct ib_uverbs_mcast_entry *mcast;
1919 int ret = -EINVAL;
1920
1921 if (copy_from_user(&cmd, buf, sizeof cmd))
1922 return -EFAULT;
1923
1924 qp = idr_read_qp(cmd.qp_handle, file->ucontext);
1925 if (!qp)
1926 return -EINVAL;
1927
1928 ret = ib_detach_mcast(qp, (union ib_gid *) cmd.gid, cmd.mlid);
1929 if (ret)
1930 goto out_put;
1931
1932 obj = container_of(qp->uobject, struct ib_uqp_object, uevent.uobject);
1933
1934 list_for_each_entry(mcast, &obj->mcast_list, list)
1935 if (cmd.mlid == mcast->lid &&
1936 !memcmp(cmd.gid, mcast->gid.raw, sizeof mcast->gid.raw)) {
1937 list_del(&mcast->list);
1938 kfree(mcast);
1939 break;
1940 }
1941
1942 out_put:
1943 put_qp_read(qp);
1944
1945 return ret ? ret : in_len;
1946 }
1947
1948 ssize_t ib_uverbs_create_srq(struct ib_uverbs_file *file,
1949 const char __user *buf, int in_len,
1950 int out_len)
1951 {
1952 struct ib_uverbs_create_srq cmd;
1953 struct ib_uverbs_create_srq_resp resp;
1954 struct ib_udata udata;
1955 struct ib_uevent_object *obj;
1956 struct ib_pd *pd;
1957 struct ib_srq *srq;
1958 struct ib_srq_init_attr attr;
1959 int ret;
1960
1961 if (out_len < sizeof resp)
1962 return -ENOSPC;
1963
1964 if (copy_from_user(&cmd, buf, sizeof cmd))
1965 return -EFAULT;
1966
1967 INIT_UDATA(&udata, buf + sizeof cmd,
1968 (unsigned long) cmd.response + sizeof resp,
1969 in_len - sizeof cmd, out_len - sizeof resp);
1970
1971 obj = kmalloc(sizeof *obj, GFP_KERNEL);
1972 if (!obj)
1973 return -ENOMEM;
1974
1975 init_uobj(&obj->uobject, cmd.user_handle, file->ucontext, &srq_lock_key);
1976 down_write(&obj->uobject.mutex);
1977
1978 pd = idr_read_pd(cmd.pd_handle, file->ucontext);
1979 if (!pd) {
1980 ret = -EINVAL;
1981 goto err;
1982 }
1983
1984 attr.event_handler = ib_uverbs_srq_event_handler;
1985 attr.srq_context = file;
1986 attr.attr.max_wr = cmd.max_wr;
1987 attr.attr.max_sge = cmd.max_sge;
1988 attr.attr.srq_limit = cmd.srq_limit;
1989
1990 obj->events_reported = 0;
1991 INIT_LIST_HEAD(&obj->event_list);
1992
1993 srq = pd->device->create_srq(pd, &attr, &udata);
1994 if (IS_ERR(srq)) {
1995 ret = PTR_ERR(srq);
1996 goto err_put;
1997 }
1998
1999 srq->device = pd->device;
2000 srq->pd = pd;
2001 srq->uobject = &obj->uobject;
2002 srq->event_handler = attr.event_handler;
2003 srq->srq_context = attr.srq_context;
2004 atomic_inc(&pd->usecnt);
2005 atomic_set(&srq->usecnt, 0);
2006
2007 obj->uobject.object = srq;
2008 ret = idr_add_uobj(&ib_uverbs_srq_idr, &obj->uobject);
2009 if (ret)
2010 goto err_destroy;
2011
2012 memset(&resp, 0, sizeof resp);
2013 resp.srq_handle = obj->uobject.id;
2014 resp.max_wr = attr.attr.max_wr;
2015 resp.max_sge = attr.attr.max_sge;
2016
2017 if (copy_to_user((void __user *) (unsigned long) cmd.response,
2018 &resp, sizeof resp)) {
2019 ret = -EFAULT;
2020 goto err_copy;
2021 }
2022
2023 put_pd_read(pd);
2024
2025 mutex_lock(&file->mutex);
2026 list_add_tail(&obj->uobject.list, &file->ucontext->srq_list);
2027 mutex_unlock(&file->mutex);
2028
2029 obj->uobject.live = 1;
2030
2031 up_write(&obj->uobject.mutex);
2032
2033 return in_len;
2034
2035 err_copy:
2036 idr_remove_uobj(&ib_uverbs_srq_idr, &obj->uobject);
2037
2038 err_destroy:
2039 ib_destroy_srq(srq);
2040
2041 err_put:
2042 put_pd_read(pd);
2043
2044 err:
2045 put_uobj_write(&obj->uobject);
2046 return ret;
2047 }
2048
2049 ssize_t ib_uverbs_modify_srq(struct ib_uverbs_file *file,
2050 const char __user *buf, int in_len,
2051 int out_len)
2052 {
2053 struct ib_uverbs_modify_srq cmd;
2054 struct ib_srq *srq;
2055 struct ib_srq_attr attr;
2056 int ret;
2057
2058 if (copy_from_user(&cmd, buf, sizeof cmd))
2059 return -EFAULT;
2060
2061 srq = idr_read_srq(cmd.srq_handle, file->ucontext);
2062 if (!srq)
2063 return -EINVAL;
2064
2065 attr.max_wr = cmd.max_wr;
2066 attr.srq_limit = cmd.srq_limit;
2067
2068 ret = ib_modify_srq(srq, &attr, cmd.attr_mask);
2069
2070 put_srq_read(srq);
2071
2072 return ret ? ret : in_len;
2073 }
2074
2075 ssize_t ib_uverbs_query_srq(struct ib_uverbs_file *file,
2076 const char __user *buf,
2077 int in_len, int out_len)
2078 {
2079 struct ib_uverbs_query_srq cmd;
2080 struct ib_uverbs_query_srq_resp resp;
2081 struct ib_srq_attr attr;
2082 struct ib_srq *srq;
2083 int ret;
2084
2085 if (out_len < sizeof resp)
2086 return -ENOSPC;
2087
2088 if (copy_from_user(&cmd, buf, sizeof cmd))
2089 return -EFAULT;
2090
2091 srq = idr_read_srq(cmd.srq_handle, file->ucontext);
2092 if (!srq)
2093 return -EINVAL;
2094
2095 ret = ib_query_srq(srq, &attr);
2096
2097 put_srq_read(srq);
2098
2099 if (ret)
2100 return ret;
2101
2102 memset(&resp, 0, sizeof resp);
2103
2104 resp.max_wr = attr.max_wr;
2105 resp.max_sge = attr.max_sge;
2106 resp.srq_limit = attr.srq_limit;
2107
2108 if (copy_to_user((void __user *) (unsigned long) cmd.response,
2109 &resp, sizeof resp))
2110 return -EFAULT;
2111
2112 return in_len;
2113 }
2114
2115 ssize_t ib_uverbs_destroy_srq(struct ib_uverbs_file *file,
2116 const char __user *buf, int in_len,
2117 int out_len)
2118 {
2119 struct ib_uverbs_destroy_srq cmd;
2120 struct ib_uverbs_destroy_srq_resp resp;
2121 struct ib_uobject *uobj;
2122 struct ib_srq *srq;
2123 struct ib_uevent_object *obj;
2124 int ret = -EINVAL;
2125
2126 if (copy_from_user(&cmd, buf, sizeof cmd))
2127 return -EFAULT;
2128
2129 uobj = idr_write_uobj(&ib_uverbs_srq_idr, cmd.srq_handle, file->ucontext);
2130 if (!uobj)
2131 return -EINVAL;
2132 srq = uobj->object;
2133 obj = container_of(uobj, struct ib_uevent_object, uobject);
2134
2135 ret = ib_destroy_srq(srq);
2136 if (!ret)
2137 uobj->live = 0;
2138
2139 put_uobj_write(uobj);
2140
2141 if (ret)
2142 return ret;
2143
2144 idr_remove_uobj(&ib_uverbs_srq_idr, uobj);
2145
2146 mutex_lock(&file->mutex);
2147 list_del(&uobj->list);
2148 mutex_unlock(&file->mutex);
2149
2150 ib_uverbs_release_uevent(file, obj);
2151
2152 memset(&resp, 0, sizeof resp);
2153 resp.events_reported = obj->events_reported;
2154
2155 put_uobj(uobj);
2156
2157 if (copy_to_user((void __user *) (unsigned long) cmd.response,
2158 &resp, sizeof resp))
2159 ret = -EFAULT;
2160
2161 return ret ? ret : in_len;
2162 }
Linux kernel - Deliverables
This page took 0.103807 seconds and 4 git commands to generate.