xref: /freebsd/sys/dev/drm2/drm_gem.c (revision 780fb4a2) 
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2011 The FreeBSD Foundation
5  * All rights reserved.
6  *
7  * This software was developed by Konstantin Belousov under sponsorship from
8  * the FreeBSD Foundation.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  */
31 
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
34 
35 #include "opt_vm.h"
36 
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/limits.h>
40 #include <sys/lock.h>
41 #include <sys/mutex.h>
42 
43 #include <vm/vm.h>
44 #include <vm/vm_page.h>
45 
46 #include <dev/drm2/drmP.h>
47 #include <dev/drm2/drm.h>
48 #include <dev/drm2/drm_sarea.h>
49 
50 /*
51  * We make up offsets for buffer objects so we can recognize them at
52  * mmap time.
53  */
54 
55 /* pgoff in mmap is an unsigned long, so we need to make sure that
56  * the faked up offset will fit
57  */
58 
59 #if BITS_PER_LONG == 64
60 #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFFUL >> PAGE_SHIFT) + 1)
61 #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFFUL >> PAGE_SHIFT) * 16)
62 #else
63 #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFUL >> PAGE_SHIFT) + 1)
64 #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFUL >> PAGE_SHIFT) * 16)
65 #endif
66 
67 /**
68  * Initialize the GEM device fields
69  */
70 
71 int
72 drm_gem_init(struct drm_device *dev)
73 {
74 	struct drm_gem_mm *mm;
75 
76 	drm_gem_names_init(&dev->object_names);
77 
78 	mm = malloc(sizeof(*mm), DRM_MEM_DRIVER, M_NOWAIT);
79 	if (!mm) {
80 		DRM_ERROR("out of memory\n");
81 		return -ENOMEM;
82 	}
83 
84 	dev->mm_private = mm;
85 
86 	if (drm_ht_create(&mm->offset_hash, 19)) {
87 		free(mm, DRM_MEM_DRIVER);
88 		return -ENOMEM;
89 	}
90 
91 	mm->idxunr = new_unrhdr(0, DRM_GEM_MAX_IDX, NULL);
92 
93 	return 0;
94 }
95 
96 void
97 drm_gem_destroy(struct drm_device *dev)
98 {
99 	struct drm_gem_mm *mm = dev->mm_private;
100 
101 	dev->mm_private = NULL;
102 	drm_ht_remove(&mm->offset_hash);
103 	delete_unrhdr(mm->idxunr);
104 	free(mm, DRM_MEM_DRIVER);
105 	drm_gem_names_fini(&dev->object_names);
106 }
107 
108 int drm_gem_object_init(struct drm_device *dev,
109 			struct drm_gem_object *obj, size_t size)
110 {
111 	KASSERT((size & (PAGE_SIZE - 1)) == 0,
112 	    ("Bad size %ju", (uintmax_t)size));
113 
114 	obj->dev = dev;
115 	obj->vm_obj = vm_pager_allocate(OBJT_DEFAULT, NULL, size,
116 	    VM_PROT_READ | VM_PROT_WRITE, 0, curthread->td_ucred);
117 
118 	obj->refcount = 1;
119 	obj->handle_count = 0;
120 	obj->size = size;
121 
122 	return 0;
123 }
124 EXPORT_SYMBOL(drm_gem_object_init);
125 
126 /**
127  * Initialize an already allocated GEM object of the specified size with
128  * no GEM provided backing store. Instead the caller is responsible for
129  * backing the object and handling it.
130  */
131 int drm_gem_private_object_init(struct drm_device *dev,
132 			struct drm_gem_object *obj, size_t size)
133 {
134 	MPASS((size & (PAGE_SIZE - 1)) == 0);
135 
136 	obj->dev = dev;
137 	obj->vm_obj = NULL;
138 
139 	obj->refcount = 1;
140 	atomic_store_rel_int(&obj->handle_count, 0);
141 	obj->size = size;
142 
143 	return 0;
144 }
145 EXPORT_SYMBOL(drm_gem_private_object_init);
146 
147 struct drm_gem_object *
148 drm_gem_object_alloc(struct drm_device *dev, size_t size)
149 {
150 	struct drm_gem_object *obj;
151 
152 	obj = malloc(sizeof(*obj), DRM_MEM_DRIVER, M_NOWAIT | M_ZERO);
153 	if (!obj)
154 		goto free;
155 
156 	if (drm_gem_object_init(dev, obj, size) != 0)
157 		goto free;
158 
159 	if (dev->driver->gem_init_object != NULL &&
160 	    dev->driver->gem_init_object(obj) != 0) {
161 		goto dealloc;
162 	}
163 	return obj;
164 dealloc:
165 	vm_object_deallocate(obj->vm_obj);
166 free:
167 	free(obj, DRM_MEM_DRIVER);
168 	return NULL;
169 }
170 EXPORT_SYMBOL(drm_gem_object_alloc);
171 
172 #if defined(FREEBSD_NOTYET)
173 static void
174 drm_gem_remove_prime_handles(struct drm_gem_object *obj, struct drm_file *filp)
175 {
176 	if (obj->import_attach) {
177 		drm_prime_remove_buf_handle(&filp->prime,
178 				obj->import_attach->dmabuf);
179 	}
180 	if (obj->export_dma_buf) {
181 		drm_prime_remove_buf_handle(&filp->prime,
182 				obj->export_dma_buf);
183 	}
184 }
185 #endif
186 
187 /**
188  * Removes the mapping from handle to filp for this object.
189  */
190 int
191 drm_gem_handle_delete(struct drm_file *filp, u32 handle)
192 {
193 	struct drm_device *dev;
194 	struct drm_gem_object *obj;
195 
196 	obj = drm_gem_names_remove(&filp->object_names, handle);
197 	if (obj == NULL) {
198 		return -EINVAL;
199 	}
200 	dev = obj->dev;
201 
202 #if defined(FREEBSD_NOTYET)
203 	drm_gem_remove_prime_handles(obj, filp);
204 #endif
205 
206 	if (dev->driver->gem_close_object)
207 		dev->driver->gem_close_object(obj, filp);
208 	drm_gem_object_handle_unreference_unlocked(obj);
209 
210 	return 0;
211 }
212 EXPORT_SYMBOL(drm_gem_handle_delete);
213 
214 /**
215  * Create a handle for this object. This adds a handle reference
216  * to the object, which includes a regular reference count. Callers
217  * will likely want to dereference the object afterwards.
218  */
219 int
220 drm_gem_handle_create(struct drm_file *file_priv,
221 		       struct drm_gem_object *obj,
222 		       u32 *handlep)
223 {
224 	struct drm_device *dev = obj->dev;
225 	int ret;
226 
227 	*handlep = 0;
228 	ret = drm_gem_name_create(&file_priv->object_names, obj, handlep);
229 	if (ret != 0)
230 		return ret;
231 
232 	drm_gem_object_handle_reference(obj);
233 
234 	if (dev->driver->gem_open_object) {
235 		ret = dev->driver->gem_open_object(obj, file_priv);
236 		if (ret) {
237 			drm_gem_handle_delete(file_priv, *handlep);
238 			return ret;
239 		}
240 	}
241 
242 	return 0;
243 }
244 EXPORT_SYMBOL(drm_gem_handle_create);
245 
246 void
247 drm_gem_free_mmap_offset(struct drm_gem_object *obj)
248 {
249 	struct drm_device *dev = obj->dev;
250 	struct drm_gem_mm *mm = dev->mm_private;
251 	struct drm_hash_item *list = &obj->map_list;
252 
253 	if (!obj->on_map)
254 		return;
255 
256 	drm_ht_remove_item(&mm->offset_hash, list);
257 	free_unr(mm->idxunr, list->key);
258 	obj->on_map = false;
259 }
260 EXPORT_SYMBOL(drm_gem_free_mmap_offset);
261 
262 int
263 drm_gem_create_mmap_offset(struct drm_gem_object *obj)
264 {
265 	struct drm_device *dev = obj->dev;
266 	struct drm_gem_mm *mm = dev->mm_private;
267 	int ret;
268 
269 	if (obj->on_map)
270 		return 0;
271 
272 	obj->map_list.key = alloc_unr(mm->idxunr);
273 	ret = drm_ht_insert_item(&mm->offset_hash, &obj->map_list);
274 	if (ret) {
275 		DRM_ERROR("failed to add to map hash\n");
276 		free_unr(mm->idxunr, obj->map_list.key);
277 		return ret;
278 	}
279 	obj->on_map = true;
280 
281 	return 0;
282 }
283 EXPORT_SYMBOL(drm_gem_create_mmap_offset);
284 
285 /** Returns a reference to the object named by the handle. */
286 struct drm_gem_object *
287 drm_gem_object_lookup(struct drm_device *dev, struct drm_file *filp,
288 		      u32 handle)
289 {
290 	struct drm_gem_object *obj;
291 
292 	obj = drm_gem_name_ref(&filp->object_names, handle,
293 	    (void (*)(void *))drm_gem_object_reference);
294 
295 	return obj;
296 }
297 EXPORT_SYMBOL(drm_gem_object_lookup);
298 
299 int
300 drm_gem_close_ioctl(struct drm_device *dev, void *data,
301 		    struct drm_file *file_priv)
302 {
303 	struct drm_gem_close *args = data;
304 	int ret;
305 
306 	if (!(dev->driver->driver_features & DRIVER_GEM))
307 		return -ENODEV;
308 
309 	ret = drm_gem_handle_delete(file_priv, args->handle);
310 
311 	return ret;
312 }
313 
314 int
315 drm_gem_flink_ioctl(struct drm_device *dev, void *data,
316 		    struct drm_file *file_priv)
317 {
318 	struct drm_gem_flink *args = data;
319 	struct drm_gem_object *obj;
320 	int ret;
321 
322 	if (!(dev->driver->driver_features & DRIVER_GEM))
323 		return -ENODEV;
324 
325 	obj = drm_gem_object_lookup(dev, file_priv, args->handle);
326 	if (obj == NULL)
327 		return -ENOENT;
328 
329 	ret = drm_gem_name_create(&dev->object_names, obj, &obj->name);
330 	if (ret != 0) {
331 		if (ret == -EALREADY)
332 			ret = 0;
333 		drm_gem_object_unreference_unlocked(obj);
334 	}
335 	if (ret == 0)
336 		args->name = obj->name;
337 	return ret;
338 }
339 
340 int
341 drm_gem_open_ioctl(struct drm_device *dev, void *data,
342 		   struct drm_file *file_priv)
343 {
344 	struct drm_gem_open *args = data;
345 	struct drm_gem_object *obj;
346 	int ret;
347 	u32 handle;
348 
349 	if (!(dev->driver->driver_features & DRIVER_GEM))
350 		return -ENODEV;
351 
352 	obj = drm_gem_name_ref(&dev->object_names, args->name,
353 	    (void (*)(void *))drm_gem_object_reference);
354 	if (!obj)
355 		return -ENOENT;
356 
357 	ret = drm_gem_handle_create(file_priv, obj, &handle);
358 	drm_gem_object_unreference_unlocked(obj);
359 	if (ret)
360 		return ret;
361 
362 	args->handle = handle;
363 	args->size = obj->size;
364 
365 	return 0;
366 }
367 
368 void
369 drm_gem_open(struct drm_device *dev, struct drm_file *file_private)
370 {
371 
372 	drm_gem_names_init(&file_private->object_names);
373 }
374 
375 static int
376 drm_gem_object_release_handle(uint32_t name, void *ptr, void *data)
377 {
378 	struct drm_file *file_priv = data;
379 	struct drm_gem_object *obj = ptr;
380 	struct drm_device *dev = obj->dev;
381 
382 #if defined(FREEBSD_NOTYET)
383 	drm_gem_remove_prime_handles(obj, file_priv);
384 #endif
385 
386 	if (dev->driver->gem_close_object)
387 		dev->driver->gem_close_object(obj, file_priv);
388 
389 	drm_gem_object_handle_unreference_unlocked(obj);
390 
391 	return 0;
392 }
393 
394 void
395 drm_gem_release(struct drm_device *dev, struct drm_file *file_private)
396 {
397 	drm_gem_names_foreach(&file_private->object_names,
398 	    drm_gem_object_release_handle, file_private);
399 
400 	drm_gem_names_fini(&file_private->object_names);
401 }
402 
403 void
404 drm_gem_object_release(struct drm_gem_object *obj)
405 {
406 
407 	/*
408 	 * obj->vm_obj can be NULL for private gem objects.
409 	 */
410 	vm_object_deallocate(obj->vm_obj);
411 }
412 EXPORT_SYMBOL(drm_gem_object_release);
413 
414 void
415 drm_gem_object_free(struct drm_gem_object *obj)
416 {
417 	struct drm_device *dev = obj->dev;
418 
419 	DRM_LOCK_ASSERT(dev);
420 	if (dev->driver->gem_free_object != NULL)
421 		dev->driver->gem_free_object(obj);
422 }
423 EXPORT_SYMBOL(drm_gem_object_free);
424 
425 void drm_gem_object_handle_free(struct drm_gem_object *obj)
426 {
427 	struct drm_device *dev = obj->dev;
428 	struct drm_gem_object *obj1;
429 
430 	if (obj->name) {
431 		obj1 = drm_gem_names_remove(&dev->object_names, obj->name);
432 		obj->name = 0;
433 		drm_gem_object_unreference(obj1);
434 	}
435 }
436 
437 static struct drm_gem_object *
438 drm_gem_object_from_offset(struct drm_device *dev, vm_ooffset_t offset)
439 {
440 	struct drm_gem_object *obj;
441 	struct drm_gem_mm *mm;
442 	struct drm_hash_item *map_list;
443 
444 	if ((offset & DRM_GEM_MAPPING_MASK) != DRM_GEM_MAPPING_KEY)
445 		return (NULL);
446 	offset &= ~DRM_GEM_MAPPING_KEY;
447 	mm = dev->mm_private;
448 	if (drm_ht_find_item(&mm->offset_hash, DRM_GEM_MAPPING_IDX(offset),
449 	    &map_list) != 0) {
450 	DRM_DEBUG("drm_gem_object_from_offset: offset 0x%jx obj not found\n",
451 		    (uintmax_t)offset);
452 		return (NULL);
453 	}
454 	obj = __containerof(map_list, struct drm_gem_object, map_list);
455 	return (obj);
456 }
457 
458 int
459 drm_gem_mmap_single(struct drm_device *dev, vm_ooffset_t *offset, vm_size_t size,
460     struct vm_object **obj_res, int nprot)
461 {
462 	struct drm_gem_object *gem_obj;
463 	struct vm_object *vm_obj;
464 
465 	DRM_LOCK(dev);
466 	gem_obj = drm_gem_object_from_offset(dev, *offset);
467 	if (gem_obj == NULL) {
468 		DRM_UNLOCK(dev);
469 		return (-ENODEV);
470 	}
471 	drm_gem_object_reference(gem_obj);
472 	DRM_UNLOCK(dev);
473 	vm_obj = cdev_pager_allocate(gem_obj, OBJT_MGTDEVICE,
474 	    dev->driver->gem_pager_ops, size, nprot,
475 	    DRM_GEM_MAPPING_MAPOFF(*offset), curthread->td_ucred);
476 	if (vm_obj == NULL) {
477 		drm_gem_object_unreference_unlocked(gem_obj);
478 		return (-EINVAL);
479 	}
480 	*offset = DRM_GEM_MAPPING_MAPOFF(*offset);
481 	*obj_res = vm_obj;
482 	return (0);
483 }
484 
485 void
486 drm_gem_pager_dtr(void *handle)
487 {
488 	struct drm_gem_object *obj;
489 	struct drm_device *dev;
490 
491 	obj = handle;
492 	dev = obj->dev;
493 
494 	DRM_LOCK(dev);
495 	drm_gem_free_mmap_offset(obj);
496 	drm_gem_object_unreference(obj);
497 	DRM_UNLOCK(dev);
498 }
499