Bug Summary

File:dev/pci/drm/drm_prime.c
Warning:line 1009, column 2
Value stored to 'ret' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name drm_prime.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/dev/pci/drm/drm_prime.c
1/*
2 * Copyright © 2012 Red Hat
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 *
23 * Authors:
24 * Dave Airlie <airlied@redhat.com>
25 * Rob Clark <rob.clark@linaro.org>
26 *
27 */
28
29#include <linux/export.h>
30#include <linux/dma-buf.h>
31#include <linux/rbtree.h>
32#include <linux/module.h>
33
34#include <drm/drm.h>
35#include <drm/drm_drv.h>
36#include <drm/drm_file.h>
37#include <drm/drm_framebuffer.h>
38#include <drm/drm_gem.h>
39#include <drm/drm_prime.h>
40
41#include "drm_internal.h"
42
43MODULE_IMPORT_NS(DMA_BUF);
44
45/**
46 * DOC: overview and lifetime rules
47 *
48 * Similar to GEM global names, PRIME file descriptors are also used to share
49 * buffer objects across processes. They offer additional security: as file
50 * descriptors must be explicitly sent over UNIX domain sockets to be shared
51 * between applications, they can't be guessed like the globally unique GEM
52 * names.
53 *
54 * Drivers that support the PRIME API implement the
55 * &drm_driver.prime_handle_to_fd and &drm_driver.prime_fd_to_handle operations.
56 * GEM based drivers must use drm_gem_prime_handle_to_fd() and
57 * drm_gem_prime_fd_to_handle() to implement these. For GEM based drivers the
58 * actual driver interfaces is provided through the &drm_gem_object_funcs.export
59 * and &drm_driver.gem_prime_import hooks.
60 *
61 * &dma_buf_ops implementations for GEM drivers are all individually exported
62 * for drivers which need to overwrite or reimplement some of them.
63 *
64 * Reference Counting for GEM Drivers
65 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
66 *
67 * On the export the &dma_buf holds a reference to the exported buffer object,
68 * usually a &drm_gem_object. It takes this reference in the PRIME_HANDLE_TO_FD
69 * IOCTL, when it first calls &drm_gem_object_funcs.export
70 * and stores the exporting GEM object in the &dma_buf.priv field. This
71 * reference needs to be released when the final reference to the &dma_buf
72 * itself is dropped and its &dma_buf_ops.release function is called. For
73 * GEM-based drivers, the &dma_buf should be exported using
74 * drm_gem_dmabuf_export() and then released by drm_gem_dmabuf_release().
75 *
76 * Thus the chain of references always flows in one direction, avoiding loops:
77 * importing GEM object -> dma-buf -> exported GEM bo. A further complication
78 * are the lookup caches for import and export. These are required to guarantee
79 * that any given object will always have only one unique userspace handle. This
80 * is required to allow userspace to detect duplicated imports, since some GEM
81 * drivers do fail command submissions if a given buffer object is listed more
82 * than once. These import and export caches in &drm_prime_file_private only
83 * retain a weak reference, which is cleaned up when the corresponding object is
84 * released.
85 *
86 * Self-importing: If userspace is using PRIME as a replacement for flink then
87 * it will get a fd->handle request for a GEM object that it created. Drivers
88 * should detect this situation and return back the underlying object from the
89 * dma-buf private. For GEM based drivers this is handled in
90 * drm_gem_prime_import() already.
91 */
92
93struct drm_prime_member {
94 struct dma_buf *dma_buf;
95 uint32_t handle;
96
97 struct rb_node dmabuf_rb;
98 struct rb_node handle_rb;
99};
100
101static int drm_prime_add_buf_handle(struct drm_prime_file_private *prime_fpriv,
102 struct dma_buf *dma_buf, uint32_t handle)
103{
104 struct drm_prime_member *member;
105 struct rb_node **p, *rb;
106
107 member = kmalloc(sizeof(*member), GFP_KERNEL(0x0001 | 0x0004));
108 if (!member)
109 return -ENOMEM12;
110
111 get_dma_buf(dma_buf);
112 member->dma_buf = dma_buf;
113 member->handle = handle;
114
115 rb = NULL((void *)0);
116 p = &prime_fpriv->dmabufs.rb_node;
117 while (*p) {
118 struct drm_prime_member *pos;
119
120 rb = *p;
121 pos = rb_entry(rb, struct drm_prime_member, dmabuf_rb)({ const __typeof( ((struct drm_prime_member *)0)->dmabuf_rb
) *__mptr = (rb); (struct drm_prime_member *)( (char *)__mptr
- __builtin_offsetof(struct drm_prime_member, dmabuf_rb) );}
);
122 if (dma_buf > pos->dma_buf)
123 p = &rb->rb_right__entry.rbe_right;
124 else
125 p = &rb->rb_left__entry.rbe_left;
126 }
127 rb_link_node(&member->dmabuf_rb, rb, p);
128 rb_insert_color(&member->dmabuf_rb, &prime_fpriv->dmabufs)linux_root_RB_INSERT_COLOR((struct linux_root *)(&prime_fpriv
->dmabufs), (&member->dmabuf_rb));
129
130 rb = NULL((void *)0);
131 p = &prime_fpriv->handles.rb_node;
132 while (*p) {
133 struct drm_prime_member *pos;
134
135 rb = *p;
136 pos = rb_entry(rb, struct drm_prime_member, handle_rb)({ const __typeof( ((struct drm_prime_member *)0)->handle_rb
) *__mptr = (rb); (struct drm_prime_member *)( (char *)__mptr
- __builtin_offsetof(struct drm_prime_member, handle_rb) );}
);
137 if (handle > pos->handle)
138 p = &rb->rb_right__entry.rbe_right;
139 else
140 p = &rb->rb_left__entry.rbe_left;
141 }
142 rb_link_node(&member->handle_rb, rb, p);
143 rb_insert_color(&member->handle_rb, &prime_fpriv->handles)linux_root_RB_INSERT_COLOR((struct linux_root *)(&prime_fpriv
->handles), (&member->handle_rb));
144
145 return 0;
146}
147
148static struct dma_buf *drm_prime_lookup_buf_by_handle(struct drm_prime_file_private *prime_fpriv,
149 uint32_t handle)
150{
151 struct rb_node *rb;
152
153 rb = prime_fpriv->handles.rb_node;
154 while (rb) {
155 struct drm_prime_member *member;
156
157 member = rb_entry(rb, struct drm_prime_member, handle_rb)({ const __typeof( ((struct drm_prime_member *)0)->handle_rb
) *__mptr = (rb); (struct drm_prime_member *)( (char *)__mptr
- __builtin_offsetof(struct drm_prime_member, handle_rb) );}
);
158 if (member->handle == handle)
159 return member->dma_buf;
160 else if (member->handle < handle)
161 rb = rb->rb_right__entry.rbe_right;
162 else
163 rb = rb->rb_left__entry.rbe_left;
164 }
165
166 return NULL((void *)0);
167}
168
169static int drm_prime_lookup_buf_handle(struct drm_prime_file_private *prime_fpriv,
170 struct dma_buf *dma_buf,
171 uint32_t *handle)
172{
173 struct rb_node *rb;
174
175 rb = prime_fpriv->dmabufs.rb_node;
176 while (rb) {
177 struct drm_prime_member *member;
178
179 member = rb_entry(rb, struct drm_prime_member, dmabuf_rb)({ const __typeof( ((struct drm_prime_member *)0)->dmabuf_rb
) *__mptr = (rb); (struct drm_prime_member *)( (char *)__mptr
- __builtin_offsetof(struct drm_prime_member, dmabuf_rb) );}
);
180 if (member->dma_buf == dma_buf) {
181 *handle = member->handle;
182 return 0;
183 } else if (member->dma_buf < dma_buf) {
184 rb = rb->rb_right__entry.rbe_right;
185 } else {
186 rb = rb->rb_left__entry.rbe_left;
187 }
188 }
189
190 return -ENOENT2;
191}
192
193void drm_prime_remove_buf_handle(struct drm_prime_file_private *prime_fpriv,
194 uint32_t handle)
195{
196 struct rb_node *rb;
197
198 mutex_lock(&prime_fpriv->lock)rw_enter_write(&prime_fpriv->lock);
199
200 rb = prime_fpriv->handles.rb_node;
201 while (rb) {
202 struct drm_prime_member *member;
203
204 member = rb_entry(rb, struct drm_prime_member, handle_rb)({ const __typeof( ((struct drm_prime_member *)0)->handle_rb
) *__mptr = (rb); (struct drm_prime_member *)( (char *)__mptr
- __builtin_offsetof(struct drm_prime_member, handle_rb) );}
);
205 if (member->handle == handle) {
206 rb_erase(&member->handle_rb, &prime_fpriv->handles)linux_root_RB_REMOVE((struct linux_root *)(&prime_fpriv->
handles), (&member->handle_rb));
207 rb_erase(&member->dmabuf_rb, &prime_fpriv->dmabufs)linux_root_RB_REMOVE((struct linux_root *)(&prime_fpriv->
dmabufs), (&member->dmabuf_rb));
208
209 dma_buf_put(member->dma_buf);
210 kfree(member);
211 break;
212 } else if (member->handle < handle) {
213 rb = rb->rb_right__entry.rbe_right;
214 } else {
215 rb = rb->rb_left__entry.rbe_left;
216 }
217 }
218
219 mutex_unlock(&prime_fpriv->lock)rw_exit_write(&prime_fpriv->lock);
220}
221
222void drm_prime_init_file_private(struct drm_prime_file_private *prime_fpriv)
223{
224 rw_init(&prime_fpriv->lock, "primlk")_rw_init_flags(&prime_fpriv->lock, "primlk", 0, ((void
*)0));
225 prime_fpriv->dmabufs = RB_ROOT(struct rb_root) { ((void *)0) };
226 prime_fpriv->handles = RB_ROOT(struct rb_root) { ((void *)0) };
227}
228
229void drm_prime_destroy_file_private(struct drm_prime_file_private *prime_fpriv)
230{
231 /* by now drm_gem_release should've made sure the list is empty */
232 WARN_ON(!RB_EMPTY_ROOT(&prime_fpriv->dmabufs))({ int __ret = !!(!((&prime_fpriv->dmabufs)->rb_node
== ((void *)0))); if (__ret) printf("WARNING %s failed at %s:%d\n"
, "!((&prime_fpriv->dmabufs)->rb_node == ((void *)0))"
, "/usr/src/sys/dev/pci/drm/drm_prime.c", 232); __builtin_expect
(!!(__ret), 0); });
233}
234
235/**
236 * drm_gem_dmabuf_export - &dma_buf export implementation for GEM
237 * @dev: parent device for the exported dmabuf
238 * @exp_info: the export information used by dma_buf_export()
239 *
240 * This wraps dma_buf_export() for use by generic GEM drivers that are using
241 * drm_gem_dmabuf_release(). In addition to calling dma_buf_export(), we take
242 * a reference to the &drm_device and the exported &drm_gem_object (stored in
243 * &dma_buf_export_info.priv) which is released by drm_gem_dmabuf_release().
244 *
245 * Returns the new dmabuf.
246 */
247struct dma_buf *drm_gem_dmabuf_export(struct drm_device *dev,
248 struct dma_buf_export_info *exp_info)
249{
250 struct drm_gem_object *obj = exp_info->priv;
251 struct dma_buf *dma_buf;
252
253 dma_buf = dma_buf_export(exp_info);
254 if (IS_ERR(dma_buf))
255 return dma_buf;
256
257 drm_dev_get(dev);
258 drm_gem_object_get(obj);
259#ifdef __linux__
260 dma_buf->file->f_mapping = obj->dev->anon_inode->i_mapping;
261#endif
262
263 return dma_buf;
264}
265EXPORT_SYMBOL(drm_gem_dmabuf_export);
266
267/**
268 * drm_gem_dmabuf_release - &dma_buf release implementation for GEM
269 * @dma_buf: buffer to be released
270 *
271 * Generic release function for dma_bufs exported as PRIME buffers. GEM drivers
272 * must use this in their &dma_buf_ops structure as the release callback.
273 * drm_gem_dmabuf_release() should be used in conjunction with
274 * drm_gem_dmabuf_export().
275 */
276void drm_gem_dmabuf_release(struct dma_buf *dma_buf)
277{
278 struct drm_gem_object *obj = dma_buf->priv;
279 struct drm_device *dev = obj->dev;
280
281 /* drop the reference on the export fd holds */
282 drm_gem_object_put(obj);
283
284 drm_dev_put(dev);
285}
286EXPORT_SYMBOL(drm_gem_dmabuf_release);
287
288/**
289 * drm_gem_prime_fd_to_handle - PRIME import function for GEM drivers
290 * @dev: dev to export the buffer from
291 * @file_priv: drm file-private structure
292 * @prime_fd: fd id of the dma-buf which should be imported
293 * @handle: pointer to storage for the handle of the imported buffer object
294 *
295 * This is the PRIME import function which must be used mandatorily by GEM
296 * drivers to ensure correct lifetime management of the underlying GEM object.
297 * The actual importing of GEM object from the dma-buf is done through the
298 * &drm_driver.gem_prime_import driver callback.
299 *
300 * Returns 0 on success or a negative error code on failure.
301 */
302int drm_gem_prime_fd_to_handle(struct drm_device *dev,
303 struct drm_file *file_priv, int prime_fd,
304 uint32_t *handle)
305{
306 struct dma_buf *dma_buf;
307 struct drm_gem_object *obj;
308 int ret;
309
310 dma_buf = dma_buf_get(prime_fd);
311 if (IS_ERR(dma_buf))
312 return PTR_ERR(dma_buf);
313
314 mutex_lock(&file_priv->prime.lock)rw_enter_write(&file_priv->prime.lock);
315
316 ret = drm_prime_lookup_buf_handle(&file_priv->prime,
317 dma_buf, handle);
318 if (ret == 0)
319 goto out_put;
320
321 /* never seen this one, need to import */
322 mutex_lock(&dev->object_name_lock)rw_enter_write(&dev->object_name_lock);
323 if (dev->driver->gem_prime_import)
324 obj = dev->driver->gem_prime_import(dev, dma_buf);
325 else
326 obj = drm_gem_prime_import(dev, dma_buf);
327 if (IS_ERR(obj)) {
328 ret = PTR_ERR(obj);
329 goto out_unlock;
330 }
331
332 if (obj->dma_buf) {
333 WARN_ON(obj->dma_buf != dma_buf)({ int __ret = !!(obj->dma_buf != dma_buf); if (__ret) printf
("WARNING %s failed at %s:%d\n", "obj->dma_buf != dma_buf"
, "/usr/src/sys/dev/pci/drm/drm_prime.c", 333); __builtin_expect
(!!(__ret), 0); });
334 } else {
335 obj->dma_buf = dma_buf;
336 get_dma_buf(dma_buf);
337 }
338
339 /* _handle_create_tail unconditionally unlocks dev->object_name_lock. */
340 ret = drm_gem_handle_create_tail(file_priv, obj, handle);
341 drm_gem_object_put(obj);
342 if (ret)
343 goto out_put;
344
345 ret = drm_prime_add_buf_handle(&file_priv->prime,
346 dma_buf, *handle);
347 mutex_unlock(&file_priv->prime.lock)rw_exit_write(&file_priv->prime.lock);
348 if (ret)
349 goto fail;
350
351 dma_buf_put(dma_buf);
352
353 return 0;
354
355fail:
356 /* hmm, if driver attached, we are relying on the free-object path
357 * to detach.. which seems ok..
358 */
359 drm_gem_handle_delete(file_priv, *handle);
360 dma_buf_put(dma_buf);
361 return ret;
362
363out_unlock:
364 mutex_unlock(&dev->object_name_lock)rw_exit_write(&dev->object_name_lock);
365out_put:
366 mutex_unlock(&file_priv->prime.lock)rw_exit_write(&file_priv->prime.lock);
367 dma_buf_put(dma_buf);
368 return ret;
369}
370EXPORT_SYMBOL(drm_gem_prime_fd_to_handle);
371
372int drm_prime_fd_to_handle_ioctl(struct drm_device *dev, void *data,
373 struct drm_file *file_priv)
374{
375 struct drm_prime_handle *args = data;
376
377 if (!dev->driver->prime_fd_to_handle)
378 return -ENOSYS78;
379
380 return dev->driver->prime_fd_to_handle(dev, file_priv,
381 args->fd, &args->handle);
382}
383
384static struct dma_buf *export_and_register_object(struct drm_device *dev,
385 struct drm_gem_object *obj,
386 uint32_t flags)
387{
388 struct dma_buf *dmabuf;
389
390 /* prevent races with concurrent gem_close. */
391 if (obj->handle_count == 0) {
392 dmabuf = ERR_PTR(-ENOENT2);
393 return dmabuf;
394 }
395
396 if (obj->funcs && obj->funcs->export)
397 dmabuf = obj->funcs->export(obj, flags);
398 else
399 dmabuf = drm_gem_prime_export(obj, flags);
400 if (IS_ERR(dmabuf)) {
401 /* normally the created dma-buf takes ownership of the ref,
402 * but if that fails then drop the ref
403 */
404 return dmabuf;
405 }
406
407 /*
408 * Note that callers do not need to clean up the export cache
409 * since the check for obj->handle_count guarantees that someone
410 * will clean it up.
411 */
412 obj->dma_buf = dmabuf;
413 get_dma_buf(obj->dma_buf);
414
415 return dmabuf;
416}
417
418/**
419 * drm_gem_prime_handle_to_fd - PRIME export function for GEM drivers
420 * @dev: dev to export the buffer from
421 * @file_priv: drm file-private structure
422 * @handle: buffer handle to export
423 * @flags: flags like DRM_CLOEXEC
424 * @prime_fd: pointer to storage for the fd id of the create dma-buf
425 *
426 * This is the PRIME export function which must be used mandatorily by GEM
427 * drivers to ensure correct lifetime management of the underlying GEM object.
428 * The actual exporting from GEM object to a dma-buf is done through the
429 * &drm_gem_object_funcs.export callback.
430 */
431int drm_gem_prime_handle_to_fd(struct drm_device *dev,
432 struct drm_file *file_priv, uint32_t handle,
433 uint32_t flags,
434 int *prime_fd)
435{
436 struct drm_gem_object *obj;
437 int ret = 0;
438 struct dma_buf *dmabuf;
439
440 mutex_lock(&file_priv->prime.lock)rw_enter_write(&file_priv->prime.lock);
441 obj = drm_gem_object_lookup(file_priv, handle);
442 if (!obj) {
443 ret = -ENOENT2;
444 goto out_unlock;
445 }
446
447 dmabuf = drm_prime_lookup_buf_by_handle(&file_priv->prime, handle);
448 if (dmabuf) {
449 get_dma_buf(dmabuf);
450 goto out_have_handle;
451 }
452
453 mutex_lock(&dev->object_name_lock)rw_enter_write(&dev->object_name_lock);
454#ifdef notyet
455 /* re-export the original imported object */
456 if (obj->import_attach) {
457 dmabuf = obj->import_attach->dmabuf;
458 get_dma_buf(dmabuf);
459 goto out_have_obj;
460 }
461#endif
462
463 if (obj->dma_buf) {
464 get_dma_buf(obj->dma_buf);
465 dmabuf = obj->dma_buf;
466 goto out_have_obj;
467 }
468
469 dmabuf = export_and_register_object(dev, obj, flags);
470 if (IS_ERR(dmabuf)) {
471 /* normally the created dma-buf takes ownership of the ref,
472 * but if that fails then drop the ref
473 */
474 ret = PTR_ERR(dmabuf);
475 mutex_unlock(&dev->object_name_lock)rw_exit_write(&dev->object_name_lock);
476 goto out;
477 }
478
479out_have_obj:
480 /*
481 * If we've exported this buffer then cheat and add it to the import list
482 * so we get the correct handle back. We must do this under the
483 * protection of dev->object_name_lock to ensure that a racing gem close
484 * ioctl doesn't miss to remove this buffer handle from the cache.
485 */
486 ret = drm_prime_add_buf_handle(&file_priv->prime,
487 dmabuf, handle);
488 mutex_unlock(&dev->object_name_lock)rw_exit_write(&dev->object_name_lock);
489 if (ret)
490 goto fail_put_dmabuf;
491
492out_have_handle:
493 ret = dma_buf_fd(dmabuf, flags);
494 /*
495 * We must _not_ remove the buffer from the handle cache since the newly
496 * created dma buf is already linked in the global obj->dma_buf pointer,
497 * and that is invariant as long as a userspace gem handle exists.
498 * Closing the handle will clean out the cache anyway, so we don't leak.
499 */
500 if (ret < 0) {
501 goto fail_put_dmabuf;
502 } else {
503 *prime_fd = ret;
504 ret = 0;
505 }
506
507 goto out;
508
509fail_put_dmabuf:
510 dma_buf_put(dmabuf);
511out:
512 drm_gem_object_put(obj);
513out_unlock:
514 mutex_unlock(&file_priv->prime.lock)rw_exit_write(&file_priv->prime.lock);
515
516 return ret;
517}
518EXPORT_SYMBOL(drm_gem_prime_handle_to_fd);
519
520int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data,
521 struct drm_file *file_priv)
522{
523 struct drm_prime_handle *args = data;
524
525 if (!dev->driver->prime_handle_to_fd)
526 return -ENOSYS78;
527
528 /* check flags are valid */
529 if (args->flags & ~(DRM_CLOEXEC0x10000 | DRM_RDWR0x0002))
530 return -EINVAL22;
531
532 return dev->driver->prime_handle_to_fd(dev, file_priv,
533 args->handle, args->flags, &args->fd);
534}
535
536/**
537 * DOC: PRIME Helpers
538 *
539 * Drivers can implement &drm_gem_object_funcs.export and
540 * &drm_driver.gem_prime_import in terms of simpler APIs by using the helper
541 * functions drm_gem_prime_export() and drm_gem_prime_import(). These functions
542 * implement dma-buf support in terms of some lower-level helpers, which are
543 * again exported for drivers to use individually:
544 *
545 * Exporting buffers
546 * ~~~~~~~~~~~~~~~~~
547 *
548 * Optional pinning of buffers is handled at dma-buf attach and detach time in
549 * drm_gem_map_attach() and drm_gem_map_detach(). Backing storage itself is
550 * handled by drm_gem_map_dma_buf() and drm_gem_unmap_dma_buf(), which relies on
551 * &drm_gem_object_funcs.get_sg_table.
552 *
553 * For kernel-internal access there's drm_gem_dmabuf_vmap() and
554 * drm_gem_dmabuf_vunmap(). Userspace mmap support is provided by
555 * drm_gem_dmabuf_mmap().
556 *
557 * Note that these export helpers can only be used if the underlying backing
558 * storage is fully coherent and either permanently pinned, or it is safe to pin
559 * it indefinitely.
560 *
561 * FIXME: The underlying helper functions are named rather inconsistently.
562 *
563 * Importing buffers
564 * ~~~~~~~~~~~~~~~~~
565 *
566 * Importing dma-bufs using drm_gem_prime_import() relies on
567 * &drm_driver.gem_prime_import_sg_table.
568 *
569 * Note that similarly to the export helpers this permanently pins the
570 * underlying backing storage. Which is ok for scanout, but is not the best
571 * option for sharing lots of buffers for rendering.
572 */
573
574/**
575 * drm_gem_map_attach - dma_buf attach implementation for GEM
576 * @dma_buf: buffer to attach device to
577 * @attach: buffer attachment data
578 *
579 * Calls &drm_gem_object_funcs.pin for device specific handling. This can be
580 * used as the &dma_buf_ops.attach callback. Must be used together with
581 * drm_gem_map_detach().
582 *
583 * Returns 0 on success, negative error code on failure.
584 */
585int drm_gem_map_attach(struct dma_buf *dma_buf,
586 struct dma_buf_attachment *attach)
587{
588 struct drm_gem_object *obj = dma_buf->priv;
589
590 return drm_gem_pin(obj);
591}
592EXPORT_SYMBOL(drm_gem_map_attach);
593
594/**
595 * drm_gem_map_detach - dma_buf detach implementation for GEM
596 * @dma_buf: buffer to detach from
597 * @attach: attachment to be detached
598 *
599 * Calls &drm_gem_object_funcs.pin for device specific handling. Cleans up
600 * &dma_buf_attachment from drm_gem_map_attach(). This can be used as the
601 * &dma_buf_ops.detach callback.
602 */
603void drm_gem_map_detach(struct dma_buf *dma_buf,
604 struct dma_buf_attachment *attach)
605{
606 struct drm_gem_object *obj = dma_buf->priv;
607
608 drm_gem_unpin(obj);
609}
610EXPORT_SYMBOL(drm_gem_map_detach);
611
612#ifdef notyet
613
614/**
615 * drm_gem_map_dma_buf - map_dma_buf implementation for GEM
616 * @attach: attachment whose scatterlist is to be returned
617 * @dir: direction of DMA transfer
618 *
619 * Calls &drm_gem_object_funcs.get_sg_table and then maps the scatterlist. This
620 * can be used as the &dma_buf_ops.map_dma_buf callback. Should be used together
621 * with drm_gem_unmap_dma_buf().
622 *
623 * Returns:sg_table containing the scatterlist to be returned; returns ERR_PTR
624 * on error. May return -EINTR if it is interrupted by a signal.
625 */
626struct sg_table *drm_gem_map_dma_buf(struct dma_buf_attachment *attach,
627 enum dma_data_direction dir)
628{
629 struct drm_gem_object *obj = attach->dmabuf->priv;
630 struct sg_table *sgt;
631 int ret;
632
633 if (WARN_ON(dir == DMA_NONE)({ int __ret = !!(dir == DMA_NONE); if (__ret) printf("WARNING %s failed at %s:%d\n"
, "dir == DMA_NONE", "/usr/src/sys/dev/pci/drm/drm_prime.c", 633
); __builtin_expect(!!(__ret), 0); }))
634 return ERR_PTR(-EINVAL22);
635
636 if (WARN_ON(!obj->funcs->get_sg_table)({ int __ret = !!(!obj->funcs->get_sg_table); if (__ret
) printf("WARNING %s failed at %s:%d\n", "!obj->funcs->get_sg_table"
, "/usr/src/sys/dev/pci/drm/drm_prime.c", 636); __builtin_expect
(!!(__ret), 0); }))
637 return ERR_PTR(-ENOSYS78);
638
639 sgt = obj->funcs->get_sg_table(obj);
640 if (IS_ERR(sgt))
641 return sgt;
642
643 ret = dma_map_sgtable(attach->dev, sgt, dir,
644 DMA_ATTR_SKIP_CPU_SYNC);
645 if (ret) {
646 sg_free_table(sgt);
647 kfree(sgt);
648 sgt = ERR_PTR(ret);
649 }
650
651 return sgt;
652}
653EXPORT_SYMBOL(drm_gem_map_dma_buf);
654
655/**
656 * drm_gem_unmap_dma_buf - unmap_dma_buf implementation for GEM
657 * @attach: attachment to unmap buffer from
658 * @sgt: scatterlist info of the buffer to unmap
659 * @dir: direction of DMA transfer
660 *
661 * This can be used as the &dma_buf_ops.unmap_dma_buf callback.
662 */
663void drm_gem_unmap_dma_buf(struct dma_buf_attachment *attach,
664 struct sg_table *sgt,
665 enum dma_data_direction dir)
666{
667 if (!sgt)
668 return;
669
670 dma_unmap_sgtable(attach->dev, sgt, dir, DMA_ATTR_SKIP_CPU_SYNC);
671 sg_free_table(sgt);
672 kfree(sgt);
673}
674EXPORT_SYMBOL(drm_gem_unmap_dma_buf);
675
676#endif /* notyet */
677
678/**
679 * drm_gem_dmabuf_vmap - dma_buf vmap implementation for GEM
680 * @dma_buf: buffer to be mapped
681 * @map: the virtual address of the buffer
682 *
683 * Sets up a kernel virtual mapping. This can be used as the &dma_buf_ops.vmap
684 * callback. Calls into &drm_gem_object_funcs.vmap for device specific handling.
685 * The kernel virtual address is returned in map.
686 *
687 * Returns 0 on success or a negative errno code otherwise.
688 */
689int drm_gem_dmabuf_vmap(struct dma_buf *dma_buf, struct iosys_map *map)
690{
691 struct drm_gem_object *obj = dma_buf->priv;
692
693 return drm_gem_vmap(obj, map);
694}
695EXPORT_SYMBOL(drm_gem_dmabuf_vmap);
696
697/**
698 * drm_gem_dmabuf_vunmap - dma_buf vunmap implementation for GEM
699 * @dma_buf: buffer to be unmapped
700 * @map: the virtual address of the buffer
701 *
702 * Releases a kernel virtual mapping. This can be used as the
703 * &dma_buf_ops.vunmap callback. Calls into &drm_gem_object_funcs.vunmap for device specific handling.
704 */
705void drm_gem_dmabuf_vunmap(struct dma_buf *dma_buf, struct iosys_map *map)
706{
707 struct drm_gem_object *obj = dma_buf->priv;
708
709 drm_gem_vunmap(obj, map);
710}
711EXPORT_SYMBOL(drm_gem_dmabuf_vunmap);
712
713#ifdef __linux__
714/**
715 * drm_gem_prime_mmap - PRIME mmap function for GEM drivers
716 * @obj: GEM object
717 * @vma: Virtual address range
718 *
719 * This function sets up a userspace mapping for PRIME exported buffers using
720 * the same codepath that is used for regular GEM buffer mapping on the DRM fd.
721 * The fake GEM offset is added to vma->vm_pgoff and &drm_driver->fops->mmap is
722 * called to set up the mapping.
723 *
724 * Drivers can use this as their &drm_driver.gem_prime_mmap callback.
725 */
726int drm_gem_prime_mmap(struct drm_gem_object *obj, struct vm_area_struct *vma)
727{
728 struct drm_file *priv;
729 struct file *fil;
730 int ret;
731
732 /* Add the fake offset */
733 vma->vm_pgoff += drm_vma_node_start(&obj->vma_node);
734
735 if (obj->funcs && obj->funcs->mmap) {
736 vma->vm_ops = obj->funcs->vm_ops;
737
738 drm_gem_object_get(obj);
739 ret = obj->funcs->mmap(obj, vma);
740 if (ret) {
741 drm_gem_object_put(obj);
742 return ret;
743 }
744 vma->vm_private_data = obj;
745 return 0;
746 }
747
748 priv = kzalloc(sizeof(*priv), GFP_KERNEL(0x0001 | 0x0004));
749 fil = kzalloc(sizeof(*fil), GFP_KERNEL(0x0001 | 0x0004));
750 if (!priv || !fil) {
751 ret = -ENOMEM12;
752 goto out;
753 }
754
755 /* Used by drm_gem_mmap() to lookup the GEM object */
756 priv->minor = obj->dev->primary;
757 fil->private_data = priv;
758
759 ret = drm_vma_node_allow(&obj->vma_node, priv);
760 if (ret)
761 goto out;
762
763 ret = obj->dev->driver->fops->mmap(fil, vma);
764
765 drm_vma_node_revoke(&obj->vma_node, priv);
766out:
767 kfree(priv);
768 kfree(fil);
769
770 return ret;
771}
772EXPORT_SYMBOL(drm_gem_prime_mmap);
773#else
774struct uvm_object *
775drm_gem_prime_mmap(struct file *filp, vm_prot_t accessprot, voff_t off,
776 vsize_t size)
777{
778 STUB()do { printf("%s: stub\n", __func__); } while(0);
779 return NULL((void *)0);
780}
781#endif
782
783#ifdef notyet
784
785/**
786 * drm_gem_dmabuf_mmap - dma_buf mmap implementation for GEM
787 * @dma_buf: buffer to be mapped
788 * @vma: virtual address range
789 *
790 * Provides memory mapping for the buffer. This can be used as the
791 * &dma_buf_ops.mmap callback. It just forwards to &drm_driver.gem_prime_mmap,
792 * which should be set to drm_gem_prime_mmap().
793 *
794 * FIXME: There's really no point to this wrapper, drivers which need anything
795 * else but drm_gem_prime_mmap can roll their own &dma_buf_ops.mmap callback.
796 *
797 * Returns 0 on success or a negative error code on failure.
798 */
799int drm_gem_dmabuf_mmap(struct dma_buf *dma_buf, struct vm_area_struct *vma)
800{
801 struct drm_gem_object *obj = dma_buf->priv;
802 struct drm_device *dev = obj->dev;
803
804 if (!dev->driver->gem_prime_mmap)
805 return -ENOSYS78;
806
807 return dev->driver->gem_prime_mmap(obj, vma);
808}
809EXPORT_SYMBOL(drm_gem_dmabuf_mmap);
810
811#endif /* notyet */
812
813static const struct dma_buf_ops drm_gem_prime_dmabuf_ops = {
814#ifdef notyet
815 .cache_sgt_mapping = true1,
816 .attach = drm_gem_map_attach,
817 .detach = drm_gem_map_detach,
818 .map_dma_buf = drm_gem_map_dma_buf,
819 .unmap_dma_buf = drm_gem_unmap_dma_buf,
820#endif
821 .release = drm_gem_dmabuf_release,
822#ifdef notyet
823 .mmap = drm_gem_dmabuf_mmap,
824 .vmap = drm_gem_dmabuf_vmap,
825 .vunmap = drm_gem_dmabuf_vunmap,
826#endif
827};
828
829/**
830 * drm_prime_pages_to_sg - converts a page array into an sg list
831 * @dev: DRM device
832 * @pages: pointer to the array of page pointers to convert
833 * @nr_pages: length of the page vector
834 *
835 * This helper creates an sg table object from a set of pages
836 * the driver is responsible for mapping the pages into the
837 * importers address space for use with dma_buf itself.
838 *
839 * This is useful for implementing &drm_gem_object_funcs.get_sg_table.
840 */
841struct sg_table *drm_prime_pages_to_sg(struct drm_device *dev,
842 struct vm_page **pages, unsigned int nr_pages)
843{
844 STUB()do { printf("%s: stub\n", __func__); } while(0);
845 return NULL((void *)0);
846#ifdef notyet
847 struct sg_table *sg;
848 size_t max_segment = 0;
849 int err;
850
851 sg = kmalloc(sizeof(struct sg_table), GFP_KERNEL(0x0001 | 0x0004));
852 if (!sg)
853 return ERR_PTR(-ENOMEM12);
854
855 if (dev)
856 max_segment = dma_max_mapping_size(dev->dev);
857 if (max_segment == 0)
858 max_segment = UINT_MAX0xffffffffU;
859 err = sg_alloc_table_from_pages_segment(sg, pages, nr_pages, 0,
860 nr_pages << PAGE_SHIFT12,
861 max_segment, GFP_KERNEL(0x0001 | 0x0004));
862 if (err) {
863 kfree(sg);
864 sg = ERR_PTR(err);
865 }
866 return sg;
867#endif
868}
869EXPORT_SYMBOL(drm_prime_pages_to_sg);
870
871/**
872 * drm_prime_get_contiguous_size - returns the contiguous size of the buffer
873 * @sgt: sg_table describing the buffer to check
874 *
875 * This helper calculates the contiguous size in the DMA address space
876 * of the buffer described by the provided sg_table.
877 *
878 * This is useful for implementing
879 * &drm_gem_object_funcs.gem_prime_import_sg_table.
880 */
881unsigned long drm_prime_get_contiguous_size(struct sg_table *sgt)
882{
883 STUB()do { printf("%s: stub\n", __func__); } while(0);
884 return 0;
885#ifdef notyet
886 dma_addr_t expected = sg_dma_address(sgt->sgl)((sgt->sgl)->dma_address);
887 struct scatterlist *sg;
888 unsigned long size = 0;
889 int i;
890
891 for_each_sgtable_dma_sg(sgt, sg, i) {
892 unsigned int len = sg_dma_len(sg)((sg)->length);
893
894 if (!len)
895 break;
896 if (sg_dma_address(sg)((sg)->dma_address) != expected)
897 break;
898 expected += len;
899 size += len;
900 }
901 return size;
902#endif
903}
904EXPORT_SYMBOL(drm_prime_get_contiguous_size);
905
906/**
907 * drm_gem_prime_export - helper library implementation of the export callback
908 * @obj: GEM object to export
909 * @flags: flags like DRM_CLOEXEC and DRM_RDWR
910 *
911 * This is the implementation of the &drm_gem_object_funcs.export functions for GEM drivers
912 * using the PRIME helpers. It is used as the default in
913 * drm_gem_prime_handle_to_fd().
914 */
915struct dma_buf *drm_gem_prime_export(struct drm_gem_object *obj,
916 int flags)
917{
918 struct drm_device *dev = obj->dev;
919 struct dma_buf_export_info exp_info = {
920#ifdef __linux__
921 .exp_name = KBUILD_MODNAME, /* white lie for debug */
922 .owner = dev->driver->fops->owner,
923#endif
924 .ops = &drm_gem_prime_dmabuf_ops,
925 .size = obj->size,
926 .flags = flags,
927 .priv = obj,
928 .resv = obj->resv,
929 };
930
931 return drm_gem_dmabuf_export(dev, &exp_info);
932}
933EXPORT_SYMBOL(drm_gem_prime_export);
934
935/**
936 * drm_gem_prime_import_dev - core implementation of the import callback
937 * @dev: drm_device to import into
938 * @dma_buf: dma-buf object to import
939 * @attach_dev: struct device to dma_buf attach
940 *
941 * This is the core of drm_gem_prime_import(). It's designed to be called by
942 * drivers who want to use a different device structure than &drm_device.dev for
943 * attaching via dma_buf. This function calls
944 * &drm_driver.gem_prime_import_sg_table internally.
945 *
946 * Drivers must arrange to call drm_prime_gem_destroy() from their
947 * &drm_gem_object_funcs.free hook when using this function.
948 */
949struct drm_gem_object *drm_gem_prime_import_dev(struct drm_device *dev,
950 struct dma_buf *dma_buf,
951 struct device *attach_dev)
952{
953 struct dma_buf_attachment *attach;
954#ifdef notyet
955 struct sg_table *sgt;
956#endif
957 struct drm_gem_object *obj;
958 int ret;
959
960 if (dma_buf->ops == &drm_gem_prime_dmabuf_ops) {
961 obj = dma_buf->priv;
962 if (obj->dev == dev) {
963 /*
964 * Importing dmabuf exported from out own gem increases
965 * refcount on gem itself instead of f_count of dmabuf.
966 */
967 drm_gem_object_get(obj);
968 return obj;
969 }
970 }
971
972#ifdef notyet
973 if (!dev->driver->gem_prime_import_sg_table)
974 return ERR_PTR(-EINVAL22);
975#endif
976
977 attach = dma_buf_attach(dma_buf, attach_dev);
978 if (IS_ERR(attach))
979 return ERR_CAST(attach);
980
981#ifdef notyet
982 get_dma_buf(dma_buf);
983
984 sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
985 if (IS_ERR(sgt)) {
986 ret = PTR_ERR(sgt);
987 goto fail_detach;
988 }
989
990 obj = dev->driver->gem_prime_import_sg_table(dev, attach, sgt);
991 if (IS_ERR(obj)) {
992 ret = PTR_ERR(obj);
993 goto fail_unmap;
994 }
995
996 obj->import_attach = attach;
997 obj->resv = dma_buf->resv;
998
999 return obj;
1000
1001fail_unmap:
1002 dma_buf_unmap_attachment(attach, sgt, DMA_BIDIRECTIONAL);
1003fail_detach:
1004 dma_buf_detach(dma_buf, attach);
1005 dma_buf_put(dma_buf);
1006
1007 return ERR_PTR(ret);
1008#else
1009 ret = 0;
Value stored to 'ret' is never read
1010 panic(__func__);
1011#endif
1012}
1013EXPORT_SYMBOL(drm_gem_prime_import_dev);
1014
1015/**
1016 * drm_gem_prime_import - helper library implementation of the import callback
1017 * @dev: drm_device to import into
1018 * @dma_buf: dma-buf object to import
1019 *
1020 * This is the implementation of the gem_prime_import functions for GEM drivers
1021 * using the PRIME helpers. Drivers can use this as their
1022 * &drm_driver.gem_prime_import implementation. It is used as the default
1023 * implementation in drm_gem_prime_fd_to_handle().
1024 *
1025 * Drivers must arrange to call drm_prime_gem_destroy() from their
1026 * &drm_gem_object_funcs.free hook when using this function.
1027 */
1028struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev,
1029 struct dma_buf *dma_buf)
1030{
1031 return drm_gem_prime_import_dev(dev, dma_buf, dev->dev);
1032}
1033EXPORT_SYMBOL(drm_gem_prime_import);
1034
1035/**
1036 * drm_prime_sg_to_page_array - convert an sg table into a page array
1037 * @sgt: scatter-gather table to convert
1038 * @pages: array of page pointers to store the pages in
1039 * @max_entries: size of the passed-in array
1040 *
1041 * Exports an sg table into an array of pages.
1042 *
1043 * This function is deprecated and strongly discouraged to be used.
1044 * The page array is only useful for page faults and those can corrupt fields
1045 * in the struct page if they are not handled by the exporting driver.
1046 */
1047int __deprecated drm_prime_sg_to_page_array(struct sg_table *sgt,
1048 struct vm_page **pages,
1049 int max_entries)
1050{
1051 STUB()do { printf("%s: stub\n", __func__); } while(0);
1052 return -ENOSYS78;
1053#ifdef notyet
1054 struct sg_page_iter page_iter;
1055 struct vm_page **p = pages;
1056
1057 for_each_sgtable_page(sgt, &page_iter, 0)__sg_page_iter_start((&page_iter), ((sgt)->sgl), ((sgt
)->orig_nents), (0)); while (__sg_page_iter_next(&page_iter
)) {
1058 if (WARN_ON(p - pages >= max_entries)({ int __ret = !!(p - pages >= max_entries); if (__ret) printf
("WARNING %s failed at %s:%d\n", "p - pages >= max_entries"
, "/usr/src/sys/dev/pci/drm/drm_prime.c", 1058); __builtin_expect
(!!(__ret), 0); }))
1059 return -1;
1060 *p++ = sg_page_iter_page(&page_iter);
1061 }
1062 return 0;
1063#endif
1064}
1065EXPORT_SYMBOL(drm_prime_sg_to_page_array);
1066
1067/**
1068 * drm_prime_sg_to_dma_addr_array - convert an sg table into a dma addr array
1069 * @sgt: scatter-gather table to convert
1070 * @addrs: array to store the dma bus address of each page
1071 * @max_entries: size of both the passed-in arrays
1072 *
1073 * Exports an sg table into an array of addresses.
1074 *
1075 * Drivers should use this in their &drm_driver.gem_prime_import_sg_table
1076 * implementation.
1077 */
1078int drm_prime_sg_to_dma_addr_array(struct sg_table *sgt, dma_addr_t *addrs,
1079 int max_entries)
1080{
1081 STUB()do { printf("%s: stub\n", __func__); } while(0);
1082 return -ENOSYS78;
1083#ifdef notyet
1084 struct sg_dma_page_iter dma_iter;
1085 dma_addr_t *a = addrs;
1086
1087 for_each_sgtable_dma_page(sgt, &dma_iter, 0) {
1088 if (WARN_ON(a - addrs >= max_entries)({ int __ret = !!(a - addrs >= max_entries); if (__ret) printf
("WARNING %s failed at %s:%d\n", "a - addrs >= max_entries"
, "/usr/src/sys/dev/pci/drm/drm_prime.c", 1088); __builtin_expect
(!!(__ret), 0); }))
1089 return -1;
1090 *a++ = sg_page_iter_dma_address(&dma_iter);
1091 }
1092 return 0;
1093#endif
1094}
1095EXPORT_SYMBOL(drm_prime_sg_to_dma_addr_array);
1096
1097/**
1098 * drm_prime_gem_destroy - helper to clean up a PRIME-imported GEM object
1099 * @obj: GEM object which was created from a dma-buf
1100 * @sg: the sg-table which was pinned at import time
1101 *
1102 * This is the cleanup functions which GEM drivers need to call when they use
1103 * drm_gem_prime_import() or drm_gem_prime_import_dev() to import dma-bufs.
1104 */
1105void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg)
1106{
1107 STUB()do { printf("%s: stub\n", __func__); } while(0);
1108#ifdef notyet
1109 struct dma_buf_attachment *attach;
1110 struct dma_buf *dma_buf;
1111
1112 attach = obj->import_attach;
1113 if (sg)
1114 dma_buf_unmap_attachment(attach, sg, DMA_BIDIRECTIONAL);
1115 dma_buf = attach->dmabuf;
1116 dma_buf_detach(attach->dmabuf, attach);
1117 /* remove the reference */
1118 dma_buf_put(dma_buf);
1119#endif
1120}
1121EXPORT_SYMBOL(drm_prime_gem_destroy);