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#include <linux/types.h>
29#include <linux/slab.h>
30#include <linux/mm.h>
31#include <linux/uaccess.h>
32#include <linux/fs.h>
33#include <linux/file.h>
34#include <linux/module.h>
35#include <linux/mman.h>
36#include <linux/pagemap.h>
37#include <linux/shmem_fs.h>
38#include <linux/dma-buf.h>
39#include <linux/dma-buf-map.h>
40#include <linux/mem_encrypt.h>
41#include <linux/pagevec.h>
42
43#include <drm/drm.h>
44#include <drm/drm_device.h>
45#include <drm/drm_drv.h>
46#include <drm/drm_file.h>
47#include <drm/drm_gem.h>
48#include <drm/drm_managed.h>
49#include <drm/drm_print.h>
50#include <drm/drm_vma_manager.h>
51
52#include "drm_internal.h"
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82static void
83drm_gem_init_release(struct drm_device *dev, void *ptr)
84{
85 drm_vma_offset_manager_destroy(dev->vma_offset_manager);
86}
87
88
89
90
91
92int
93drm_gem_init(struct drm_device *dev)
94{
95 struct drm_vma_offset_manager *vma_offset_manager;
96
97 mutex_init(&dev->object_name_lock);
98 idr_init_base(&dev->object_name_idr, 1);
99
100 vma_offset_manager = drmm_kzalloc(dev, sizeof(*vma_offset_manager),
101 GFP_KERNEL);
102 if (!vma_offset_manager) {
103 DRM_ERROR("out of memory\n");
104 return -ENOMEM;
105 }
106
107 dev->vma_offset_manager = vma_offset_manager;
108 drm_vma_offset_manager_init(vma_offset_manager,
109 DRM_FILE_PAGE_OFFSET_START,
110 DRM_FILE_PAGE_OFFSET_SIZE);
111
112 return drmm_add_action(dev, drm_gem_init_release, NULL);
113}
114
115
116
117
118
119
120
121
122
123
124int drm_gem_object_init(struct drm_device *dev,
125 struct drm_gem_object *obj, size_t size)
126{
127 struct file *filp;
128
129 drm_gem_private_object_init(dev, obj, size);
130
131 filp = shmem_file_setup("drm mm object", size, VM_NORESERVE);
132 if (IS_ERR(filp))
133 return PTR_ERR(filp);
134
135 obj->filp = filp;
136
137 return 0;
138}
139EXPORT_SYMBOL(drm_gem_object_init);
140
141
142
143
144
145
146
147
148
149
150
151void drm_gem_private_object_init(struct drm_device *dev,
152 struct drm_gem_object *obj, size_t size)
153{
154 BUG_ON((size & (PAGE_SIZE - 1)) != 0);
155
156 obj->dev = dev;
157 obj->filp = NULL;
158
159 kref_init(&obj->refcount);
160 obj->handle_count = 0;
161 obj->size = size;
162 dma_resv_init(&obj->_resv);
163 if (!obj->resv)
164 obj->resv = &obj->_resv;
165
166 drm_vma_node_reset(&obj->vma_node);
167}
168EXPORT_SYMBOL(drm_gem_private_object_init);
169
170static void
171drm_gem_remove_prime_handles(struct drm_gem_object *obj, struct drm_file *filp)
172{
173
174
175
176
177 mutex_lock(&filp->prime.lock);
178 if (obj->dma_buf) {
179 drm_prime_remove_buf_handle_locked(&filp->prime,
180 obj->dma_buf);
181 }
182 mutex_unlock(&filp->prime.lock);
183}
184
185
186
187
188
189
190
191
192
193
194
195static void drm_gem_object_handle_free(struct drm_gem_object *obj)
196{
197 struct drm_device *dev = obj->dev;
198
199
200 if (obj->name) {
201 idr_remove(&dev->object_name_idr, obj->name);
202 obj->name = 0;
203 }
204}
205
206static void drm_gem_object_exported_dma_buf_free(struct drm_gem_object *obj)
207{
208
209 if (obj->dma_buf) {
210 dma_buf_put(obj->dma_buf);
211 obj->dma_buf = NULL;
212 }
213}
214
215static void
216drm_gem_object_handle_put_unlocked(struct drm_gem_object *obj)
217{
218 struct drm_device *dev = obj->dev;
219 bool final = false;
220
221 if (WARN_ON(READ_ONCE(obj->handle_count) == 0))
222 return;
223
224
225
226
227
228
229
230 mutex_lock(&dev->object_name_lock);
231 if (--obj->handle_count == 0) {
232 drm_gem_object_handle_free(obj);
233 drm_gem_object_exported_dma_buf_free(obj);
234 final = true;
235 }
236 mutex_unlock(&dev->object_name_lock);
237
238 if (final)
239 drm_gem_object_put(obj);
240}
241
242
243
244
245
246static int
247drm_gem_object_release_handle(int id, void *ptr, void *data)
248{
249 struct drm_file *file_priv = data;
250 struct drm_gem_object *obj = ptr;
251
252 if (obj->funcs->close)
253 obj->funcs->close(obj, file_priv);
254
255 drm_gem_remove_prime_handles(obj, file_priv);
256 drm_vma_node_revoke(&obj->vma_node, file_priv);
257
258 drm_gem_object_handle_put_unlocked(obj);
259
260 return 0;
261}
262
263
264
265
266
267
268
269
270
271
272int
273drm_gem_handle_delete(struct drm_file *filp, u32 handle)
274{
275 struct drm_gem_object *obj;
276
277 spin_lock(&filp->table_lock);
278
279
280 obj = idr_replace(&filp->object_idr, NULL, handle);
281 spin_unlock(&filp->table_lock);
282 if (IS_ERR_OR_NULL(obj))
283 return -EINVAL;
284
285
286 drm_gem_object_release_handle(handle, obj, filp);
287
288
289 spin_lock(&filp->table_lock);
290 idr_remove(&filp->object_idr, handle);
291 spin_unlock(&filp->table_lock);
292
293 return 0;
294}
295EXPORT_SYMBOL(drm_gem_handle_delete);
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310int drm_gem_dumb_map_offset(struct drm_file *file, struct drm_device *dev,
311 u32 handle, u64 *offset)
312{
313 struct drm_gem_object *obj;
314 int ret;
315
316 obj = drm_gem_object_lookup(file, handle);
317 if (!obj)
318 return -ENOENT;
319
320
321 if (obj->import_attach) {
322 ret = -EINVAL;
323 goto out;
324 }
325
326 ret = drm_gem_create_mmap_offset(obj);
327 if (ret)
328 goto out;
329
330 *offset = drm_vma_node_offset_addr(&obj->vma_node);
331out:
332 drm_gem_object_put(obj);
333
334 return ret;
335}
336EXPORT_SYMBOL_GPL(drm_gem_dumb_map_offset);
337
338int drm_gem_dumb_destroy(struct drm_file *file,
339 struct drm_device *dev,
340 u32 handle)
341{
342 return drm_gem_handle_delete(file, handle);
343}
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359int
360drm_gem_handle_create_tail(struct drm_file *file_priv,
361 struct drm_gem_object *obj,
362 u32 *handlep)
363{
364 struct drm_device *dev = obj->dev;
365 u32 handle;
366 int ret;
367
368 WARN_ON(!mutex_is_locked(&dev->object_name_lock));
369 if (obj->handle_count++ == 0)
370 drm_gem_object_get(obj);
371
372
373
374
375
376 idr_preload(GFP_KERNEL);
377 spin_lock(&file_priv->table_lock);
378
379 ret = idr_alloc(&file_priv->object_idr, obj, 1, 0, GFP_NOWAIT);
380
381 spin_unlock(&file_priv->table_lock);
382 idr_preload_end();
383
384 mutex_unlock(&dev->object_name_lock);
385 if (ret < 0)
386 goto err_unref;
387
388 handle = ret;
389
390 ret = drm_vma_node_allow(&obj->vma_node, file_priv);
391 if (ret)
392 goto err_remove;
393
394 if (obj->funcs->open) {
395 ret = obj->funcs->open(obj, file_priv);
396 if (ret)
397 goto err_revoke;
398 }
399
400 *handlep = handle;
401 return 0;
402
403err_revoke:
404 drm_vma_node_revoke(&obj->vma_node, file_priv);
405err_remove:
406 spin_lock(&file_priv->table_lock);
407 idr_remove(&file_priv->object_idr, handle);
408 spin_unlock(&file_priv->table_lock);
409err_unref:
410 drm_gem_object_handle_put_unlocked(obj);
411 return ret;
412}
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427int drm_gem_handle_create(struct drm_file *file_priv,
428 struct drm_gem_object *obj,
429 u32 *handlep)
430{
431 mutex_lock(&obj->dev->object_name_lock);
432
433 return drm_gem_handle_create_tail(file_priv, obj, handlep);
434}
435EXPORT_SYMBOL(drm_gem_handle_create);
436
437
438
439
440
441
442
443
444
445
446
447
448void
449drm_gem_free_mmap_offset(struct drm_gem_object *obj)
450{
451 struct drm_device *dev = obj->dev;
452
453 drm_vma_offset_remove(dev->vma_offset_manager, &obj->vma_node);
454}
455EXPORT_SYMBOL(drm_gem_free_mmap_offset);
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474int
475drm_gem_create_mmap_offset_size(struct drm_gem_object *obj, size_t size)
476{
477 struct drm_device *dev = obj->dev;
478
479 return drm_vma_offset_add(dev->vma_offset_manager, &obj->vma_node,
480 size / PAGE_SIZE);
481}
482EXPORT_SYMBOL(drm_gem_create_mmap_offset_size);
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498int drm_gem_create_mmap_offset(struct drm_gem_object *obj)
499{
500 return drm_gem_create_mmap_offset_size(obj, obj->size);
501}
502EXPORT_SYMBOL(drm_gem_create_mmap_offset);
503
504
505
506
507
508static void drm_gem_check_release_pagevec(struct pagevec *pvec)
509{
510 check_move_unevictable_pages(pvec);
511 __pagevec_release(pvec);
512 cond_resched();
513}
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540struct page **drm_gem_get_pages(struct drm_gem_object *obj)
541{
542 struct address_space *mapping;
543 struct page *p, **pages;
544 struct pagevec pvec;
545 int i, npages;
546
547
548 if (WARN_ON(!obj->filp))
549 return ERR_PTR(-EINVAL);
550
551
552 mapping = obj->filp->f_mapping;
553
554
555
556
557
558 WARN_ON((obj->size & (PAGE_SIZE - 1)) != 0);
559
560 npages = obj->size >> PAGE_SHIFT;
561
562 pages = kvmalloc_array(npages, sizeof(struct page *), GFP_KERNEL);
563 if (pages == NULL)
564 return ERR_PTR(-ENOMEM);
565
566 mapping_set_unevictable(mapping);
567
568 for (i = 0; i < npages; i++) {
569 p = shmem_read_mapping_page(mapping, i);
570 if (IS_ERR(p))
571 goto fail;
572 pages[i] = p;
573
574
575
576
577
578
579 BUG_ON(mapping_gfp_constraint(mapping, __GFP_DMA32) &&
580 (page_to_pfn(p) >= 0x00100000UL));
581 }
582
583 return pages;
584
585fail:
586 mapping_clear_unevictable(mapping);
587 pagevec_init(&pvec);
588 while (i--) {
589 if (!pagevec_add(&pvec, pages[i]))
590 drm_gem_check_release_pagevec(&pvec);
591 }
592 if (pagevec_count(&pvec))
593 drm_gem_check_release_pagevec(&pvec);
594
595 kvfree(pages);
596 return ERR_CAST(p);
597}
598EXPORT_SYMBOL(drm_gem_get_pages);
599
600
601
602
603
604
605
606
607void drm_gem_put_pages(struct drm_gem_object *obj, struct page **pages,
608 bool dirty, bool accessed)
609{
610 int i, npages;
611 struct address_space *mapping;
612 struct pagevec pvec;
613
614 mapping = file_inode(obj->filp)->i_mapping;
615 mapping_clear_unevictable(mapping);
616
617
618
619
620
621 WARN_ON((obj->size & (PAGE_SIZE - 1)) != 0);
622
623 npages = obj->size >> PAGE_SHIFT;
624
625 pagevec_init(&pvec);
626 for (i = 0; i < npages; i++) {
627 if (!pages[i])
628 continue;
629
630 if (dirty)
631 set_page_dirty(pages[i]);
632
633 if (accessed)
634 mark_page_accessed(pages[i]);
635
636
637 if (!pagevec_add(&pvec, pages[i]))
638 drm_gem_check_release_pagevec(&pvec);
639 }
640 if (pagevec_count(&pvec))
641 drm_gem_check_release_pagevec(&pvec);
642
643 kvfree(pages);
644}
645EXPORT_SYMBOL(drm_gem_put_pages);
646
647static int objects_lookup(struct drm_file *filp, u32 *handle, int count,
648 struct drm_gem_object **objs)
649{
650 int i, ret = 0;
651 struct drm_gem_object *obj;
652
653 spin_lock(&filp->table_lock);
654
655 for (i = 0; i < count; i++) {
656
657 obj = idr_find(&filp->object_idr, handle[i]);
658 if (!obj) {
659 ret = -ENOENT;
660 break;
661 }
662 drm_gem_object_get(obj);
663 objs[i] = obj;
664 }
665 spin_unlock(&filp->table_lock);
666
667 return ret;
668}
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689int drm_gem_objects_lookup(struct drm_file *filp, void __user *bo_handles,
690 int count, struct drm_gem_object ***objs_out)
691{
692 int ret;
693 u32 *handles;
694 struct drm_gem_object **objs;
695
696 if (!count)
697 return 0;
698
699 objs = kvmalloc_array(count, sizeof(struct drm_gem_object *),
700 GFP_KERNEL | __GFP_ZERO);
701 if (!objs)
702 return -ENOMEM;
703
704 *objs_out = objs;
705
706 handles = kvmalloc_array(count, sizeof(u32), GFP_KERNEL);
707 if (!handles) {
708 ret = -ENOMEM;
709 goto out;
710 }
711
712 if (copy_from_user(handles, bo_handles, count * sizeof(u32))) {
713 ret = -EFAULT;
714 DRM_DEBUG("Failed to copy in GEM handles\n");
715 goto out;
716 }
717
718 ret = objects_lookup(filp, handles, count, objs);
719out:
720 kvfree(handles);
721 return ret;
722
723}
724EXPORT_SYMBOL(drm_gem_objects_lookup);
725
726
727
728
729
730
731
732
733
734
735
736
737
738struct drm_gem_object *
739drm_gem_object_lookup(struct drm_file *filp, u32 handle)
740{
741 struct drm_gem_object *obj = NULL;
742
743 objects_lookup(filp, &handle, 1, &obj);
744 return obj;
745}
746EXPORT_SYMBOL(drm_gem_object_lookup);
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761long drm_gem_dma_resv_wait(struct drm_file *filep, u32 handle,
762 bool wait_all, unsigned long timeout)
763{
764 long ret;
765 struct drm_gem_object *obj;
766
767 obj = drm_gem_object_lookup(filep, handle);
768 if (!obj) {
769 DRM_DEBUG("Failed to look up GEM BO %d\n", handle);
770 return -EINVAL;
771 }
772
773 ret = dma_resv_wait_timeout(obj->resv, wait_all, true, timeout);
774 if (ret == 0)
775 ret = -ETIME;
776 else if (ret > 0)
777 ret = 0;
778
779 drm_gem_object_put(obj);
780
781 return ret;
782}
783EXPORT_SYMBOL(drm_gem_dma_resv_wait);
784
785
786
787
788
789
790
791
792
793int
794drm_gem_close_ioctl(struct drm_device *dev, void *data,
795 struct drm_file *file_priv)
796{
797 struct drm_gem_close *args = data;
798 int ret;
799
800 if (!drm_core_check_feature(dev, DRIVER_GEM))
801 return -EOPNOTSUPP;
802
803 ret = drm_gem_handle_delete(file_priv, args->handle);
804
805 return ret;
806}
807
808
809
810
811
812
813
814
815
816
817
818
819int
820drm_gem_flink_ioctl(struct drm_device *dev, void *data,
821 struct drm_file *file_priv)
822{
823 struct drm_gem_flink *args = data;
824 struct drm_gem_object *obj;
825 int ret;
826
827 if (!drm_core_check_feature(dev, DRIVER_GEM))
828 return -EOPNOTSUPP;
829
830 obj = drm_gem_object_lookup(file_priv, args->handle);
831 if (obj == NULL)
832 return -ENOENT;
833
834 mutex_lock(&dev->object_name_lock);
835
836 if (obj->handle_count == 0) {
837 ret = -ENOENT;
838 goto err;
839 }
840
841 if (!obj->name) {
842 ret = idr_alloc(&dev->object_name_idr, obj, 1, 0, GFP_KERNEL);
843 if (ret < 0)
844 goto err;
845
846 obj->name = ret;
847 }
848
849 args->name = (uint64_t) obj->name;
850 ret = 0;
851
852err:
853 mutex_unlock(&dev->object_name_lock);
854 drm_gem_object_put(obj);
855 return ret;
856}
857
858
859
860
861
862
863
864
865
866
867
868
869int
870drm_gem_open_ioctl(struct drm_device *dev, void *data,
871 struct drm_file *file_priv)
872{
873 struct drm_gem_open *args = data;
874 struct drm_gem_object *obj;
875 int ret;
876 u32 handle;
877
878 if (!drm_core_check_feature(dev, DRIVER_GEM))
879 return -EOPNOTSUPP;
880
881 mutex_lock(&dev->object_name_lock);
882 obj = idr_find(&dev->object_name_idr, (int) args->name);
883 if (obj) {
884 drm_gem_object_get(obj);
885 } else {
886 mutex_unlock(&dev->object_name_lock);
887 return -ENOENT;
888 }
889
890
891 ret = drm_gem_handle_create_tail(file_priv, obj, &handle);
892 if (ret)
893 goto err;
894
895 args->handle = handle;
896 args->size = obj->size;
897
898err:
899 drm_gem_object_put(obj);
900 return ret;
901}
902
903
904
905
906
907
908
909
910
911void
912drm_gem_open(struct drm_device *dev, struct drm_file *file_private)
913{
914 idr_init_base(&file_private->object_idr, 1);
915 spin_lock_init(&file_private->table_lock);
916}
917
918
919
920
921
922
923
924
925
926
927void
928drm_gem_release(struct drm_device *dev, struct drm_file *file_private)
929{
930 idr_for_each(&file_private->object_idr,
931 &drm_gem_object_release_handle, file_private);
932 idr_destroy(&file_private->object_idr);
933}
934
935
936
937
938
939
940
941
942void
943drm_gem_object_release(struct drm_gem_object *obj)
944{
945 WARN_ON(obj->dma_buf);
946
947 if (obj->filp)
948 fput(obj->filp);
949
950 dma_resv_fini(&obj->_resv);
951 drm_gem_free_mmap_offset(obj);
952}
953EXPORT_SYMBOL(drm_gem_object_release);
954
955
956
957
958
959
960
961
962
963void
964drm_gem_object_free(struct kref *kref)
965{
966 struct drm_gem_object *obj =
967 container_of(kref, struct drm_gem_object, refcount);
968
969 if (WARN_ON(!obj->funcs->free))
970 return;
971
972 obj->funcs->free(obj);
973}
974EXPORT_SYMBOL(drm_gem_object_free);
975
976
977
978
979
980
981
982
983void drm_gem_vm_open(struct vm_area_struct *vma)
984{
985 struct drm_gem_object *obj = vma->vm_private_data;
986
987 drm_gem_object_get(obj);
988}
989EXPORT_SYMBOL(drm_gem_vm_open);
990
991
992
993
994
995
996
997
998void drm_gem_vm_close(struct vm_area_struct *vma)
999{
1000 struct drm_gem_object *obj = vma->vm_private_data;
1001
1002 drm_gem_object_put(obj);
1003}
1004EXPORT_SYMBOL(drm_gem_vm_close);
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030int drm_gem_mmap_obj(struct drm_gem_object *obj, unsigned long obj_size,
1031 struct vm_area_struct *vma)
1032{
1033 int ret;
1034
1035
1036 if (obj_size < vma->vm_end - vma->vm_start)
1037 return -EINVAL;
1038
1039
1040
1041
1042
1043
1044
1045 drm_gem_object_get(obj);
1046
1047 vma->vm_private_data = obj;
1048 vma->vm_ops = obj->funcs->vm_ops;
1049
1050 if (obj->funcs->mmap) {
1051 ret = obj->funcs->mmap(obj, vma);
1052 if (ret)
1053 goto err_drm_gem_object_put;
1054 WARN_ON(!(vma->vm_flags & VM_DONTEXPAND));
1055 } else {
1056 if (!vma->vm_ops) {
1057 ret = -EINVAL;
1058 goto err_drm_gem_object_put;
1059 }
1060
1061 vma->vm_flags |= VM_IO | VM_PFNMAP | VM_DONTEXPAND | VM_DONTDUMP;
1062 vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
1063 vma->vm_page_prot = pgprot_decrypted(vma->vm_page_prot);
1064 }
1065
1066 return 0;
1067
1068err_drm_gem_object_put:
1069 drm_gem_object_put(obj);
1070 return ret;
1071}
1072EXPORT_SYMBOL(drm_gem_mmap_obj);
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
1090{
1091 struct drm_file *priv = filp->private_data;
1092 struct drm_device *dev = priv->minor->dev;
1093 struct drm_gem_object *obj = NULL;
1094 struct drm_vma_offset_node *node;
1095 int ret;
1096
1097 if (drm_dev_is_unplugged(dev))
1098 return -ENODEV;
1099
1100 drm_vma_offset_lock_lookup(dev->vma_offset_manager);
1101 node = drm_vma_offset_exact_lookup_locked(dev->vma_offset_manager,
1102 vma->vm_pgoff,
1103 vma_pages(vma));
1104 if (likely(node)) {
1105 obj = container_of(node, struct drm_gem_object, vma_node);
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116 if (!kref_get_unless_zero(&obj->refcount))
1117 obj = NULL;
1118 }
1119 drm_vma_offset_unlock_lookup(dev->vma_offset_manager);
1120
1121 if (!obj)
1122 return -EINVAL;
1123
1124 if (!drm_vma_node_is_allowed(node, priv)) {
1125 drm_gem_object_put(obj);
1126 return -EACCES;
1127 }
1128
1129 ret = drm_gem_mmap_obj(obj, drm_vma_node_size(node) << PAGE_SHIFT,
1130 vma);
1131
1132 drm_gem_object_put(obj);
1133
1134 return ret;
1135}
1136EXPORT_SYMBOL(drm_gem_mmap);
1137
1138void drm_gem_print_info(struct drm_printer *p, unsigned int indent,
1139 const struct drm_gem_object *obj)
1140{
1141 drm_printf_indent(p, indent, "name=%d\n", obj->name);
1142 drm_printf_indent(p, indent, "refcount=%u\n",
1143 kref_read(&obj->refcount));
1144 drm_printf_indent(p, indent, "start=%08lx\n",
1145 drm_vma_node_start(&obj->vma_node));
1146 drm_printf_indent(p, indent, "size=%zu\n", obj->size);
1147 drm_printf_indent(p, indent, "imported=%s\n",
1148 obj->import_attach ? "yes" : "no");
1149
1150 if (obj->funcs->print_info)
1151 obj->funcs->print_info(p, indent, obj);
1152}
1153
1154int drm_gem_pin(struct drm_gem_object *obj)
1155{
1156 if (obj->funcs->pin)
1157 return obj->funcs->pin(obj);
1158 else
1159 return 0;
1160}
1161
1162void drm_gem_unpin(struct drm_gem_object *obj)
1163{
1164 if (obj->funcs->unpin)
1165 obj->funcs->unpin(obj);
1166}
1167
1168int drm_gem_vmap(struct drm_gem_object *obj, struct dma_buf_map *map)
1169{
1170 int ret;
1171
1172 if (!obj->funcs->vmap)
1173 return -EOPNOTSUPP;
1174
1175 ret = obj->funcs->vmap(obj, map);
1176 if (ret)
1177 return ret;
1178 else if (dma_buf_map_is_null(map))
1179 return -ENOMEM;
1180
1181 return 0;
1182}
1183EXPORT_SYMBOL(drm_gem_vmap);
1184
1185void drm_gem_vunmap(struct drm_gem_object *obj, struct dma_buf_map *map)
1186{
1187 if (dma_buf_map_is_null(map))
1188 return;
1189
1190 if (obj->funcs->vunmap)
1191 obj->funcs->vunmap(obj, map);
1192
1193
1194 dma_buf_map_clear(map);
1195}
1196EXPORT_SYMBOL(drm_gem_vunmap);
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211int
1212drm_gem_lock_reservations(struct drm_gem_object **objs, int count,
1213 struct ww_acquire_ctx *acquire_ctx)
1214{
1215 int contended = -1;
1216 int i, ret;
1217
1218 ww_acquire_init(acquire_ctx, &reservation_ww_class);
1219
1220retry:
1221 if (contended != -1) {
1222 struct drm_gem_object *obj = objs[contended];
1223
1224 ret = dma_resv_lock_slow_interruptible(obj->resv,
1225 acquire_ctx);
1226 if (ret) {
1227 ww_acquire_done(acquire_ctx);
1228 return ret;
1229 }
1230 }
1231
1232 for (i = 0; i < count; i++) {
1233 if (i == contended)
1234 continue;
1235
1236 ret = dma_resv_lock_interruptible(objs[i]->resv,
1237 acquire_ctx);
1238 if (ret) {
1239 int j;
1240
1241 for (j = 0; j < i; j++)
1242 dma_resv_unlock(objs[j]->resv);
1243
1244 if (contended != -1 && contended >= i)
1245 dma_resv_unlock(objs[contended]->resv);
1246
1247 if (ret == -EDEADLK) {
1248 contended = i;
1249 goto retry;
1250 }
1251
1252 ww_acquire_done(acquire_ctx);
1253 return ret;
1254 }
1255 }
1256
1257 ww_acquire_done(acquire_ctx);
1258
1259 return 0;
1260}
1261EXPORT_SYMBOL(drm_gem_lock_reservations);
1262
1263void
1264drm_gem_unlock_reservations(struct drm_gem_object **objs, int count,
1265 struct ww_acquire_ctx *acquire_ctx)
1266{
1267 int i;
1268
1269 for (i = 0; i < count; i++)
1270 dma_resv_unlock(objs[i]->resv);
1271
1272 ww_acquire_fini(acquire_ctx);
1273}
1274EXPORT_SYMBOL(drm_gem_unlock_reservations);
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289int drm_gem_fence_array_add(struct xarray *fence_array,
1290 struct dma_fence *fence)
1291{
1292 struct dma_fence *entry;
1293 unsigned long index;
1294 u32 id = 0;
1295 int ret;
1296
1297 if (!fence)
1298 return 0;
1299
1300
1301
1302
1303
1304 xa_for_each(fence_array, index, entry) {
1305 if (entry->context != fence->context)
1306 continue;
1307
1308 if (dma_fence_is_later(fence, entry)) {
1309 dma_fence_put(entry);
1310 xa_store(fence_array, index, fence, GFP_KERNEL);
1311 } else {
1312 dma_fence_put(fence);
1313 }
1314 return 0;
1315 }
1316
1317 ret = xa_alloc(fence_array, &id, fence, xa_limit_32b, GFP_KERNEL);
1318 if (ret != 0)
1319 dma_fence_put(fence);
1320
1321 return ret;
1322}
1323EXPORT_SYMBOL(drm_gem_fence_array_add);
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339int drm_gem_fence_array_add_implicit(struct xarray *fence_array,
1340 struct drm_gem_object *obj,
1341 bool write)
1342{
1343 int ret;
1344 struct dma_fence **fences;
1345 unsigned int i, fence_count;
1346
1347 if (!write) {
1348 struct dma_fence *fence =
1349 dma_resv_get_excl_unlocked(obj->resv);
1350
1351 return drm_gem_fence_array_add(fence_array, fence);
1352 }
1353
1354 ret = dma_resv_get_fences(obj->resv, NULL,
1355 &fence_count, &fences);
1356 if (ret || !fence_count)
1357 return ret;
1358
1359 for (i = 0; i < fence_count; i++) {
1360 ret = drm_gem_fence_array_add(fence_array, fences[i]);
1361 if (ret)
1362 break;
1363 }
1364
1365 for (; i < fence_count; i++)
1366 dma_fence_put(fences[i]);
1367 kfree(fences);
1368 return ret;
1369}
1370EXPORT_SYMBOL(drm_gem_fence_array_add_implicit);
1371