1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33#include <linux/file.h>
34#include <linux/anon_inodes.h>
35#include <linux/sched/mm.h>
36#include <rdma/ib_verbs.h>
37#include <rdma/uverbs_types.h>
38#include <linux/rcupdate.h>
39#include <rdma/uverbs_ioctl.h>
40#include <rdma/rdma_user_ioctl.h>
41#include "uverbs.h"
42#include "core_priv.h"
43#include "rdma_core.h"
44
45void uverbs_uobject_get(struct ib_uobject *uobject)
46{
47 kref_get(&uobject->ref);
48}
49
50static void uverbs_uobject_free(struct kref *ref)
51{
52 struct ib_uobject *uobj =
53 container_of(ref, struct ib_uobject, ref);
54
55 if (uobj->uapi_object->type_class->needs_kfree_rcu)
56 kfree_rcu(uobj, rcu);
57 else
58 kfree(uobj);
59}
60
61void uverbs_uobject_put(struct ib_uobject *uobject)
62{
63 kref_put(&uobject->ref, uverbs_uobject_free);
64}
65
66static int uverbs_try_lock_object(struct ib_uobject *uobj,
67 enum rdma_lookup_mode mode)
68{
69
70
71
72
73
74
75
76
77
78
79
80 switch (mode) {
81 case UVERBS_LOOKUP_READ:
82 return atomic_fetch_add_unless(&uobj->usecnt, 1, -1) == -1 ?
83 -EBUSY : 0;
84 case UVERBS_LOOKUP_WRITE:
85
86 return atomic_cmpxchg(&uobj->usecnt, 0, -1) == 0 ? 0 : -EBUSY;
87 case UVERBS_LOOKUP_DESTROY:
88 return 0;
89 }
90 return 0;
91}
92
93static void assert_uverbs_usecnt(struct ib_uobject *uobj,
94 enum rdma_lookup_mode mode)
95{
96#ifdef CONFIG_LOCKDEP
97 switch (mode) {
98 case UVERBS_LOOKUP_READ:
99 WARN_ON(atomic_read(&uobj->usecnt) <= 0);
100 break;
101 case UVERBS_LOOKUP_WRITE:
102 WARN_ON(atomic_read(&uobj->usecnt) != -1);
103 break;
104 case UVERBS_LOOKUP_DESTROY:
105 break;
106 }
107#endif
108}
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127static int uverbs_destroy_uobject(struct ib_uobject *uobj,
128 enum rdma_remove_reason reason,
129 struct uverbs_attr_bundle *attrs)
130{
131 struct ib_uverbs_file *ufile = attrs->ufile;
132 unsigned long flags;
133 int ret;
134
135 lockdep_assert_held(&ufile->hw_destroy_rwsem);
136 assert_uverbs_usecnt(uobj, UVERBS_LOOKUP_WRITE);
137
138 if (uobj->object) {
139 ret = uobj->uapi_object->type_class->destroy_hw(uobj, reason,
140 attrs);
141 if (ret) {
142 if (ib_is_destroy_retryable(ret, reason, uobj))
143 return ret;
144
145
146 WARN(true,
147 "ib_uverbs: failed to remove uobject id %d, driver err=%d",
148 uobj->id, ret);
149 }
150
151 uobj->object = NULL;
152 }
153
154 if (reason == RDMA_REMOVE_ABORT) {
155 WARN_ON(!list_empty(&uobj->list));
156 WARN_ON(!uobj->context);
157 uobj->uapi_object->type_class->alloc_abort(uobj);
158 }
159
160 uobj->context = NULL;
161
162
163
164
165
166
167 if (reason != RDMA_REMOVE_DESTROY)
168 atomic_set(&uobj->usecnt, 0);
169 else
170 uobj->uapi_object->type_class->remove_handle(uobj);
171
172 if (!list_empty(&uobj->list)) {
173 spin_lock_irqsave(&ufile->uobjects_lock, flags);
174 list_del_init(&uobj->list);
175 spin_unlock_irqrestore(&ufile->uobjects_lock, flags);
176
177
178
179
180
181 uverbs_uobject_put(uobj);
182 }
183
184
185
186
187
188 if (reason == RDMA_REMOVE_ABORT)
189 uverbs_uobject_put(uobj);
190
191 return 0;
192}
193
194
195
196
197
198
199
200
201int uobj_destroy(struct ib_uobject *uobj, struct uverbs_attr_bundle *attrs)
202{
203 struct ib_uverbs_file *ufile = attrs->ufile;
204 int ret;
205
206 down_read(&ufile->hw_destroy_rwsem);
207
208 ret = uverbs_try_lock_object(uobj, UVERBS_LOOKUP_WRITE);
209 if (ret)
210 goto out_unlock;
211
212 ret = uverbs_destroy_uobject(uobj, RDMA_REMOVE_DESTROY, attrs);
213 if (ret) {
214 atomic_set(&uobj->usecnt, 0);
215 goto out_unlock;
216 }
217
218out_unlock:
219 up_read(&ufile->hw_destroy_rwsem);
220 return ret;
221}
222
223
224
225
226
227
228struct ib_uobject *__uobj_get_destroy(const struct uverbs_api_object *obj,
229 u32 id, struct uverbs_attr_bundle *attrs)
230{
231 struct ib_uobject *uobj;
232 int ret;
233
234 uobj = rdma_lookup_get_uobject(obj, attrs->ufile, id,
235 UVERBS_LOOKUP_DESTROY, attrs);
236 if (IS_ERR(uobj))
237 return uobj;
238
239 ret = uobj_destroy(uobj, attrs);
240 if (ret) {
241 rdma_lookup_put_uobject(uobj, UVERBS_LOOKUP_DESTROY);
242 return ERR_PTR(ret);
243 }
244
245 return uobj;
246}
247
248
249
250
251
252int __uobj_perform_destroy(const struct uverbs_api_object *obj, u32 id,
253 struct uverbs_attr_bundle *attrs)
254{
255 struct ib_uobject *uobj;
256
257 uobj = __uobj_get_destroy(obj, id, attrs);
258 if (IS_ERR(uobj))
259 return PTR_ERR(uobj);
260
261 rdma_lookup_put_uobject(uobj, UVERBS_LOOKUP_WRITE);
262 return 0;
263}
264
265
266static struct ib_uobject *alloc_uobj(struct ib_uverbs_file *ufile,
267 const struct uverbs_api_object *obj)
268{
269 struct ib_uobject *uobj;
270 struct ib_ucontext *ucontext;
271
272 ucontext = ib_uverbs_get_ucontext_file(ufile);
273 if (IS_ERR(ucontext))
274 return ERR_CAST(ucontext);
275
276 uobj = kzalloc(obj->type_attrs->obj_size, GFP_KERNEL);
277 if (!uobj)
278 return ERR_PTR(-ENOMEM);
279
280
281
282
283 uobj->ufile = ufile;
284 uobj->context = ucontext;
285 INIT_LIST_HEAD(&uobj->list);
286 uobj->uapi_object = obj;
287
288
289
290
291
292 atomic_set(&uobj->usecnt, -1);
293 kref_init(&uobj->ref);
294
295 return uobj;
296}
297
298static int idr_add_uobj(struct ib_uobject *uobj)
299{
300
301
302
303
304
305 return xa_alloc(&uobj->ufile->idr, &uobj->id, NULL, xa_limit_32b,
306 GFP_KERNEL);
307}
308
309
310static struct ib_uobject *
311lookup_get_idr_uobject(const struct uverbs_api_object *obj,
312 struct ib_uverbs_file *ufile, s64 id,
313 enum rdma_lookup_mode mode)
314{
315 struct ib_uobject *uobj;
316
317 if (id < 0 || id > ULONG_MAX)
318 return ERR_PTR(-EINVAL);
319
320 rcu_read_lock();
321
322
323
324
325
326
327 uobj = xa_load(&ufile->idr, id);
328 if (!uobj || !kref_get_unless_zero(&uobj->ref))
329 uobj = ERR_PTR(-ENOENT);
330 rcu_read_unlock();
331 return uobj;
332}
333
334static struct ib_uobject *
335lookup_get_fd_uobject(const struct uverbs_api_object *obj,
336 struct ib_uverbs_file *ufile, s64 id,
337 enum rdma_lookup_mode mode)
338{
339 const struct uverbs_obj_fd_type *fd_type;
340 struct file *f;
341 struct ib_uobject *uobject;
342 int fdno = id;
343
344 if (fdno != id)
345 return ERR_PTR(-EINVAL);
346
347 if (mode != UVERBS_LOOKUP_READ)
348 return ERR_PTR(-EOPNOTSUPP);
349
350 if (!obj->type_attrs)
351 return ERR_PTR(-EIO);
352 fd_type =
353 container_of(obj->type_attrs, struct uverbs_obj_fd_type, type);
354
355 f = fget(fdno);
356 if (!f)
357 return ERR_PTR(-EBADF);
358
359 uobject = f->private_data;
360
361
362
363
364
365 if (f->f_op != fd_type->fops) {
366 fput(f);
367 return ERR_PTR(-EBADF);
368 }
369
370 uverbs_uobject_get(uobject);
371 return uobject;
372}
373
374struct ib_uobject *rdma_lookup_get_uobject(const struct uverbs_api_object *obj,
375 struct ib_uverbs_file *ufile, s64 id,
376 enum rdma_lookup_mode mode,
377 struct uverbs_attr_bundle *attrs)
378{
379 struct ib_uobject *uobj;
380 int ret;
381
382 if (obj == ERR_PTR(-ENOMSG)) {
383
384 uobj = lookup_get_idr_uobject(NULL, ufile, id, mode);
385 if (IS_ERR(uobj))
386 return uobj;
387 } else {
388 if (IS_ERR(obj))
389 return ERR_PTR(-EINVAL);
390
391 uobj = obj->type_class->lookup_get(obj, ufile, id, mode);
392 if (IS_ERR(uobj))
393 return uobj;
394
395 if (uobj->uapi_object != obj) {
396 ret = -EINVAL;
397 goto free;
398 }
399 }
400
401
402
403
404
405 if (mode != UVERBS_LOOKUP_DESTROY &&
406 !srcu_dereference(ufile->device->ib_dev,
407 &ufile->device->disassociate_srcu)) {
408 ret = -EIO;
409 goto free;
410 }
411
412 ret = uverbs_try_lock_object(uobj, mode);
413 if (ret)
414 goto free;
415 if (attrs)
416 attrs->context = uobj->context;
417
418 return uobj;
419free:
420 uobj->uapi_object->type_class->lookup_put(uobj, mode);
421 uverbs_uobject_put(uobj);
422 return ERR_PTR(ret);
423}
424
425static struct ib_uobject *
426alloc_begin_idr_uobject(const struct uverbs_api_object *obj,
427 struct ib_uverbs_file *ufile)
428{
429 int ret;
430 struct ib_uobject *uobj;
431
432 uobj = alloc_uobj(ufile, obj);
433 if (IS_ERR(uobj))
434 return uobj;
435
436 ret = idr_add_uobj(uobj);
437 if (ret)
438 goto uobj_put;
439
440 ret = ib_rdmacg_try_charge(&uobj->cg_obj, uobj->context->device,
441 RDMACG_RESOURCE_HCA_OBJECT);
442 if (ret)
443 goto remove;
444
445 return uobj;
446
447remove:
448 xa_erase(&ufile->idr, uobj->id);
449uobj_put:
450 uverbs_uobject_put(uobj);
451 return ERR_PTR(ret);
452}
453
454static struct ib_uobject *
455alloc_begin_fd_uobject(const struct uverbs_api_object *obj,
456 struct ib_uverbs_file *ufile)
457{
458 int new_fd;
459 struct ib_uobject *uobj;
460
461 new_fd = get_unused_fd_flags(O_CLOEXEC);
462 if (new_fd < 0)
463 return ERR_PTR(new_fd);
464
465 uobj = alloc_uobj(ufile, obj);
466 if (IS_ERR(uobj)) {
467 put_unused_fd(new_fd);
468 return uobj;
469 }
470
471 uobj->id = new_fd;
472 uobj->ufile = ufile;
473
474 return uobj;
475}
476
477struct ib_uobject *rdma_alloc_begin_uobject(const struct uverbs_api_object *obj,
478 struct ib_uverbs_file *ufile,
479 struct uverbs_attr_bundle *attrs)
480{
481 struct ib_uobject *ret;
482
483 if (IS_ERR(obj))
484 return ERR_PTR(-EINVAL);
485
486
487
488
489
490
491 if (!down_read_trylock(&ufile->hw_destroy_rwsem))
492 return ERR_PTR(-EIO);
493
494 ret = obj->type_class->alloc_begin(obj, ufile);
495 if (IS_ERR(ret)) {
496 up_read(&ufile->hw_destroy_rwsem);
497 return ret;
498 }
499 if (attrs)
500 attrs->context = ret->context;
501 return ret;
502}
503
504static void alloc_abort_idr_uobject(struct ib_uobject *uobj)
505{
506 ib_rdmacg_uncharge(&uobj->cg_obj, uobj->context->device,
507 RDMACG_RESOURCE_HCA_OBJECT);
508
509 xa_erase(&uobj->ufile->idr, uobj->id);
510}
511
512static int __must_check destroy_hw_idr_uobject(struct ib_uobject *uobj,
513 enum rdma_remove_reason why,
514 struct uverbs_attr_bundle *attrs)
515{
516 const struct uverbs_obj_idr_type *idr_type =
517 container_of(uobj->uapi_object->type_attrs,
518 struct uverbs_obj_idr_type, type);
519 int ret = idr_type->destroy_object(uobj, why, attrs);
520
521
522
523
524
525
526 if (ib_is_destroy_retryable(ret, why, uobj))
527 return ret;
528
529 if (why == RDMA_REMOVE_ABORT)
530 return 0;
531
532 ib_rdmacg_uncharge(&uobj->cg_obj, uobj->context->device,
533 RDMACG_RESOURCE_HCA_OBJECT);
534
535 return 0;
536}
537
538static void remove_handle_idr_uobject(struct ib_uobject *uobj)
539{
540 xa_erase(&uobj->ufile->idr, uobj->id);
541
542 uverbs_uobject_put(uobj);
543}
544
545static void alloc_abort_fd_uobject(struct ib_uobject *uobj)
546{
547 put_unused_fd(uobj->id);
548}
549
550static int __must_check destroy_hw_fd_uobject(struct ib_uobject *uobj,
551 enum rdma_remove_reason why,
552 struct uverbs_attr_bundle *attrs)
553{
554 const struct uverbs_obj_fd_type *fd_type = container_of(
555 uobj->uapi_object->type_attrs, struct uverbs_obj_fd_type, type);
556 int ret = fd_type->context_closed(uobj, why);
557
558 if (ib_is_destroy_retryable(ret, why, uobj))
559 return ret;
560
561 return 0;
562}
563
564static void remove_handle_fd_uobject(struct ib_uobject *uobj)
565{
566}
567
568static int alloc_commit_idr_uobject(struct ib_uobject *uobj)
569{
570 struct ib_uverbs_file *ufile = uobj->ufile;
571 void *old;
572
573
574
575
576
577
578
579
580 old = xa_store(&ufile->idr, uobj->id, uobj, GFP_KERNEL);
581 WARN_ON(old != NULL);
582
583 return 0;
584}
585
586static int alloc_commit_fd_uobject(struct ib_uobject *uobj)
587{
588 const struct uverbs_obj_fd_type *fd_type = container_of(
589 uobj->uapi_object->type_attrs, struct uverbs_obj_fd_type, type);
590 int fd = uobj->id;
591 struct file *filp;
592
593
594
595
596
597
598
599 filp = anon_inode_getfile(fd_type->name,
600 fd_type->fops,
601 uobj,
602 fd_type->flags);
603 if (IS_ERR(filp))
604 return PTR_ERR(filp);
605
606 uobj->object = filp;
607
608
609 kref_get(&uobj->ufile->ref);
610
611
612 uobj->id = 0;
613
614
615
616
617
618 fd_install(fd, filp);
619
620 return 0;
621}
622
623
624
625
626
627
628int __must_check rdma_alloc_commit_uobject(struct ib_uobject *uobj,
629 struct uverbs_attr_bundle *attrs)
630{
631 struct ib_uverbs_file *ufile = attrs->ufile;
632 int ret;
633
634
635 ret = uobj->uapi_object->type_class->alloc_commit(uobj);
636 if (ret) {
637 uverbs_destroy_uobject(uobj, RDMA_REMOVE_ABORT, attrs);
638 up_read(&ufile->hw_destroy_rwsem);
639 return ret;
640 }
641
642
643 uverbs_uobject_get(uobj);
644 spin_lock_irq(&ufile->uobjects_lock);
645 list_add(&uobj->list, &ufile->uobjects);
646 spin_unlock_irq(&ufile->uobjects_lock);
647
648
649 atomic_set(&uobj->usecnt, 0);
650
651
652 up_read(&ufile->hw_destroy_rwsem);
653
654 return 0;
655}
656
657
658
659
660
661void rdma_alloc_abort_uobject(struct ib_uobject *uobj,
662 struct uverbs_attr_bundle *attrs)
663{
664 struct ib_uverbs_file *ufile = uobj->ufile;
665
666 uobj->object = NULL;
667 uverbs_destroy_uobject(uobj, RDMA_REMOVE_ABORT, attrs);
668
669
670 up_read(&ufile->hw_destroy_rwsem);
671}
672
673static void lookup_put_idr_uobject(struct ib_uobject *uobj,
674 enum rdma_lookup_mode mode)
675{
676}
677
678static void lookup_put_fd_uobject(struct ib_uobject *uobj,
679 enum rdma_lookup_mode mode)
680{
681 struct file *filp = uobj->object;
682
683 WARN_ON(mode != UVERBS_LOOKUP_READ);
684
685 fput(filp);
686}
687
688void rdma_lookup_put_uobject(struct ib_uobject *uobj,
689 enum rdma_lookup_mode mode)
690{
691 assert_uverbs_usecnt(uobj, mode);
692 uobj->uapi_object->type_class->lookup_put(uobj, mode);
693
694
695
696
697
698 switch (mode) {
699 case UVERBS_LOOKUP_READ:
700 atomic_dec(&uobj->usecnt);
701 break;
702 case UVERBS_LOOKUP_WRITE:
703 atomic_set(&uobj->usecnt, 0);
704 break;
705 case UVERBS_LOOKUP_DESTROY:
706 break;
707 }
708
709
710 uverbs_uobject_put(uobj);
711}
712
713void setup_ufile_idr_uobject(struct ib_uverbs_file *ufile)
714{
715 xa_init_flags(&ufile->idr, XA_FLAGS_ALLOC);
716}
717
718void release_ufile_idr_uobject(struct ib_uverbs_file *ufile)
719{
720 struct ib_uobject *entry;
721 unsigned long id;
722
723
724
725
726
727
728
729
730
731 xa_for_each(&ufile->idr, id, entry) {
732 WARN_ON(entry->object);
733 uverbs_uobject_put(entry);
734 }
735
736 xa_destroy(&ufile->idr);
737}
738
739const struct uverbs_obj_type_class uverbs_idr_class = {
740 .alloc_begin = alloc_begin_idr_uobject,
741 .lookup_get = lookup_get_idr_uobject,
742 .alloc_commit = alloc_commit_idr_uobject,
743 .alloc_abort = alloc_abort_idr_uobject,
744 .lookup_put = lookup_put_idr_uobject,
745 .destroy_hw = destroy_hw_idr_uobject,
746 .remove_handle = remove_handle_idr_uobject,
747
748
749
750
751
752
753
754
755
756
757
758
759
760 .needs_kfree_rcu = true,
761};
762EXPORT_SYMBOL(uverbs_idr_class);
763
764void uverbs_close_fd(struct file *f)
765{
766 struct ib_uobject *uobj = f->private_data;
767 struct ib_uverbs_file *ufile = uobj->ufile;
768 struct uverbs_attr_bundle attrs = {
769 .context = uobj->context,
770 .ufile = ufile,
771 };
772
773 if (down_read_trylock(&ufile->hw_destroy_rwsem)) {
774
775
776
777
778
779
780 WARN_ON(uverbs_try_lock_object(uobj, UVERBS_LOOKUP_WRITE));
781 uverbs_destroy_uobject(uobj, RDMA_REMOVE_CLOSE, &attrs);
782 up_read(&ufile->hw_destroy_rwsem);
783 }
784
785
786 kref_put(&ufile->ref, ib_uverbs_release_file);
787
788
789 uverbs_uobject_put(uobj);
790}
791EXPORT_SYMBOL(uverbs_close_fd);
792
793
794
795
796
797static void ufile_destroy_ucontext(struct ib_uverbs_file *ufile,
798 enum rdma_remove_reason reason)
799{
800 struct ib_ucontext *ucontext = ufile->ucontext;
801 struct ib_device *ib_dev = ucontext->device;
802
803
804
805
806
807
808 if (reason == RDMA_REMOVE_DRIVER_REMOVE) {
809 uverbs_user_mmap_disassociate(ufile);
810 if (ib_dev->ops.disassociate_ucontext)
811 ib_dev->ops.disassociate_ucontext(ucontext);
812 }
813
814 ib_rdmacg_uncharge(&ucontext->cg_obj, ib_dev,
815 RDMACG_RESOURCE_HCA_HANDLE);
816
817 rdma_restrack_del(&ucontext->res);
818
819 ib_dev->ops.dealloc_ucontext(ucontext);
820 kfree(ucontext);
821
822 ufile->ucontext = NULL;
823}
824
825static int __uverbs_cleanup_ufile(struct ib_uverbs_file *ufile,
826 enum rdma_remove_reason reason)
827{
828 struct ib_uobject *obj, *next_obj;
829 int ret = -EINVAL;
830 struct uverbs_attr_bundle attrs = { .ufile = ufile };
831
832
833
834
835
836
837
838
839
840
841 list_for_each_entry_safe(obj, next_obj, &ufile->uobjects, list) {
842 attrs.context = obj->context;
843
844
845
846
847 WARN_ON(uverbs_try_lock_object(obj, UVERBS_LOOKUP_WRITE));
848 if (!uverbs_destroy_uobject(obj, reason, &attrs))
849 ret = 0;
850 else
851 atomic_set(&obj->usecnt, 0);
852 }
853 return ret;
854}
855
856
857
858
859
860
861
862
863
864void uverbs_destroy_ufile_hw(struct ib_uverbs_file *ufile,
865 enum rdma_remove_reason reason)
866{
867 if (reason == RDMA_REMOVE_CLOSE) {
868
869
870
871
872
873
874
875
876 if (!mutex_trylock(&ufile->ucontext_lock))
877 return;
878
879 } else {
880 mutex_lock(&ufile->ucontext_lock);
881 }
882
883 down_write(&ufile->hw_destroy_rwsem);
884
885
886
887
888
889 if (!ufile->ucontext)
890 goto done;
891
892 ufile->ucontext->closing = true;
893 ufile->ucontext->cleanup_retryable = true;
894 while (!list_empty(&ufile->uobjects))
895 if (__uverbs_cleanup_ufile(ufile, reason)) {
896
897
898
899
900 break;
901 }
902
903 ufile->ucontext->cleanup_retryable = false;
904 if (!list_empty(&ufile->uobjects))
905 __uverbs_cleanup_ufile(ufile, reason);
906
907 ufile_destroy_ucontext(ufile, reason);
908
909done:
910 up_write(&ufile->hw_destroy_rwsem);
911 mutex_unlock(&ufile->ucontext_lock);
912}
913
914const struct uverbs_obj_type_class uverbs_fd_class = {
915 .alloc_begin = alloc_begin_fd_uobject,
916 .lookup_get = lookup_get_fd_uobject,
917 .alloc_commit = alloc_commit_fd_uobject,
918 .alloc_abort = alloc_abort_fd_uobject,
919 .lookup_put = lookup_put_fd_uobject,
920 .destroy_hw = destroy_hw_fd_uobject,
921 .remove_handle = remove_handle_fd_uobject,
922 .needs_kfree_rcu = false,
923};
924EXPORT_SYMBOL(uverbs_fd_class);
925
926struct ib_uobject *
927uverbs_get_uobject_from_file(u16 object_id, enum uverbs_obj_access access,
928 s64 id, struct uverbs_attr_bundle *attrs)
929{
930 const struct uverbs_api_object *obj =
931 uapi_get_object(attrs->ufile->device->uapi, object_id);
932
933 switch (access) {
934 case UVERBS_ACCESS_READ:
935 return rdma_lookup_get_uobject(obj, attrs->ufile, id,
936 UVERBS_LOOKUP_READ, attrs);
937 case UVERBS_ACCESS_DESTROY:
938
939 return rdma_lookup_get_uobject(obj, attrs->ufile, id,
940 UVERBS_LOOKUP_DESTROY, attrs);
941 case UVERBS_ACCESS_WRITE:
942 return rdma_lookup_get_uobject(obj, attrs->ufile, id,
943 UVERBS_LOOKUP_WRITE, attrs);
944 case UVERBS_ACCESS_NEW:
945 return rdma_alloc_begin_uobject(obj, attrs->ufile, attrs);
946 default:
947 WARN_ON(true);
948 return ERR_PTR(-EOPNOTSUPP);
949 }
950}
951
952int uverbs_finalize_object(struct ib_uobject *uobj,
953 enum uverbs_obj_access access, bool commit,
954 struct uverbs_attr_bundle *attrs)
955{
956 int ret = 0;
957
958
959
960
961
962
963
964 switch (access) {
965 case UVERBS_ACCESS_READ:
966 rdma_lookup_put_uobject(uobj, UVERBS_LOOKUP_READ);
967 break;
968 case UVERBS_ACCESS_WRITE:
969 rdma_lookup_put_uobject(uobj, UVERBS_LOOKUP_WRITE);
970 break;
971 case UVERBS_ACCESS_DESTROY:
972 if (uobj)
973 rdma_lookup_put_uobject(uobj, UVERBS_LOOKUP_DESTROY);
974 break;
975 case UVERBS_ACCESS_NEW:
976 if (commit)
977 ret = rdma_alloc_commit_uobject(uobj, attrs);
978 else
979 rdma_alloc_abort_uobject(uobj, attrs);
980 break;
981 default:
982 WARN_ON(true);
983 ret = -EOPNOTSUPP;
984 }
985
986 return ret;
987}
988