Branch data Line data Source code
1 : : /*
2 : : * Copyright © 2016 Intel Corporation
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 : : */
24 : :
25 : : #include <linux/sched/mm.h>
26 : : #include <drm/drm_gem.h>
27 : :
28 : : #include "display/intel_frontbuffer.h"
29 : :
30 : : #include "gt/intel_engine.h"
31 : : #include "gt/intel_engine_heartbeat.h"
32 : : #include "gt/intel_gt.h"
33 : : #include "gt/intel_gt_requests.h"
34 : :
35 : : #include "i915_drv.h"
36 : : #include "i915_globals.h"
37 : : #include "i915_sw_fence_work.h"
38 : : #include "i915_trace.h"
39 : : #include "i915_vma.h"
40 : :
41 : : static struct i915_global_vma {
42 : : struct i915_global base;
43 : : struct kmem_cache *slab_vmas;
44 : : } global;
45 : :
46 : 0 : struct i915_vma *i915_vma_alloc(void)
47 : : {
48 : 0 : return kmem_cache_zalloc(global.slab_vmas, GFP_KERNEL);
49 : : }
50 : :
51 : 0 : void i915_vma_free(struct i915_vma *vma)
52 : : {
53 : 0 : return kmem_cache_free(global.slab_vmas, vma);
54 : : }
55 : :
56 : : #if IS_ENABLED(CONFIG_DRM_I915_ERRLOG_GEM) && IS_ENABLED(CONFIG_DRM_DEBUG_MM)
57 : :
58 : : #include <linux/stackdepot.h>
59 : :
60 : : static void vma_print_allocator(struct i915_vma *vma, const char *reason)
61 : : {
62 : : unsigned long *entries;
63 : : unsigned int nr_entries;
64 : : char buf[512];
65 : :
66 : : if (!vma->node.stack) {
67 : : DRM_DEBUG_DRIVER("vma.node [%08llx + %08llx] %s: unknown owner\n",
68 : : vma->node.start, vma->node.size, reason);
69 : : return;
70 : : }
71 : :
72 : : nr_entries = stack_depot_fetch(vma->node.stack, &entries);
73 : : stack_trace_snprint(buf, sizeof(buf), entries, nr_entries, 0);
74 : : DRM_DEBUG_DRIVER("vma.node [%08llx + %08llx] %s: inserted at %s\n",
75 : : vma->node.start, vma->node.size, reason, buf);
76 : : }
77 : :
78 : : #else
79 : :
80 : : static void vma_print_allocator(struct i915_vma *vma, const char *reason)
81 : : {
82 : : }
83 : :
84 : : #endif
85 : :
86 : 0 : static inline struct i915_vma *active_to_vma(struct i915_active *ref)
87 : : {
88 : 0 : return container_of(ref, typeof(struct i915_vma), active);
89 : : }
90 : :
91 : 0 : static int __i915_vma_active(struct i915_active *ref)
92 : : {
93 [ # # ]: 0 : return i915_vma_tryget(active_to_vma(ref)) ? 0 : -ENOENT;
94 : : }
95 : :
96 : : __i915_active_call
97 : 0 : static void __i915_vma_retire(struct i915_active *ref)
98 : : {
99 : 0 : i915_vma_put(active_to_vma(ref));
100 : 0 : }
101 : :
102 : : static struct i915_vma *
103 : 0 : vma_create(struct drm_i915_gem_object *obj,
104 : : struct i915_address_space *vm,
105 : : const struct i915_ggtt_view *view)
106 : : {
107 : 0 : struct i915_vma *vma;
108 : 0 : struct rb_node *rb, **p;
109 : :
110 : : /* The aliasing_ppgtt should never be used directly! */
111 : 0 : GEM_BUG_ON(vm == &vm->gt->ggtt->alias->vm);
112 : :
113 : 0 : vma = i915_vma_alloc();
114 [ # # ]: 0 : if (vma == NULL)
115 : : return ERR_PTR(-ENOMEM);
116 : :
117 : 0 : kref_init(&vma->ref);
118 : 0 : mutex_init(&vma->pages_mutex);
119 : 0 : vma->vm = i915_vm_get(vm);
120 : 0 : vma->ops = &vm->vma_ops;
121 : 0 : vma->obj = obj;
122 : 0 : vma->resv = obj->base.resv;
123 : 0 : vma->size = obj->base.size;
124 : 0 : vma->display_alignment = I915_GTT_MIN_ALIGNMENT;
125 : :
126 : 0 : i915_active_init(&vma->active, __i915_vma_active, __i915_vma_retire);
127 : :
128 : : /* Declare ourselves safe for use inside shrinkers */
129 : 0 : if (IS_ENABLED(CONFIG_LOCKDEP)) {
130 : : fs_reclaim_acquire(GFP_KERNEL);
131 : : might_lock(&vma->active.mutex);
132 : : fs_reclaim_release(GFP_KERNEL);
133 : : }
134 : :
135 [ # # ]: 0 : INIT_LIST_HEAD(&vma->closed_link);
136 : :
137 [ # # # # ]: 0 : if (view && view->type != I915_GGTT_VIEW_NORMAL) {
138 : 0 : vma->ggtt_view = *view;
139 [ # # ]: 0 : if (view->type == I915_GGTT_VIEW_PARTIAL) {
140 : 0 : GEM_BUG_ON(range_overflows_t(u64,
141 : : view->partial.offset,
142 : : view->partial.size,
143 : : obj->base.size >> PAGE_SHIFT));
144 : 0 : vma->size = view->partial.size;
145 : 0 : vma->size <<= PAGE_SHIFT;
146 : 0 : GEM_BUG_ON(vma->size > obj->base.size);
147 [ # # ]: 0 : } else if (view->type == I915_GGTT_VIEW_ROTATED) {
148 : 0 : vma->size = intel_rotation_info_size(&view->rotated);
149 : 0 : vma->size <<= PAGE_SHIFT;
150 [ # # ]: 0 : } else if (view->type == I915_GGTT_VIEW_REMAPPED) {
151 : 0 : vma->size = intel_remapped_info_size(&view->remapped);
152 : 0 : vma->size <<= PAGE_SHIFT;
153 : : }
154 : : }
155 : :
156 [ # # ]: 0 : if (unlikely(vma->size > vm->total))
157 : 0 : goto err_vma;
158 : :
159 : 0 : GEM_BUG_ON(!IS_ALIGNED(vma->size, I915_GTT_PAGE_SIZE));
160 : :
161 [ # # ]: 0 : if (i915_is_ggtt(vm)) {
162 [ # # ]: 0 : if (unlikely(overflows_type(vma->size, u32)))
163 : 0 : goto err_vma;
164 : :
165 : 0 : vma->fence_size = i915_gem_fence_size(vm->i915, vma->size,
166 : : i915_gem_object_get_tiling(obj),
167 : : i915_gem_object_get_stride(obj));
168 [ # # # # ]: 0 : if (unlikely(vma->fence_size < vma->size || /* overflow */
169 : : vma->fence_size > vm->total))
170 : 0 : goto err_vma;
171 : :
172 : 0 : GEM_BUG_ON(!IS_ALIGNED(vma->fence_size, I915_GTT_MIN_ALIGNMENT));
173 : :
174 : 0 : vma->fence_alignment = i915_gem_fence_alignment(vm->i915, vma->size,
175 : : i915_gem_object_get_tiling(obj),
176 : : i915_gem_object_get_stride(obj));
177 : 0 : GEM_BUG_ON(!is_power_of_2(vma->fence_alignment));
178 : :
179 : 0 : __set_bit(I915_VMA_GGTT_BIT, __i915_vma_flags(vma));
180 : : }
181 : :
182 : 0 : spin_lock(&obj->vma.lock);
183 : :
184 : 0 : rb = NULL;
185 : 0 : p = &obj->vma.tree.rb_node;
186 [ # # ]: 0 : while (*p) {
187 : 0 : struct i915_vma *pos;
188 : 0 : long cmp;
189 : :
190 : 0 : rb = *p;
191 : 0 : pos = rb_entry(rb, struct i915_vma, obj_node);
192 : :
193 : : /*
194 : : * If the view already exists in the tree, another thread
195 : : * already created a matching vma, so return the older instance
196 : : * and dispose of ours.
197 : : */
198 : 0 : cmp = i915_vma_compare(pos, vm, view);
199 [ # # ]: 0 : if (cmp == 0) {
200 : 0 : spin_unlock(&obj->vma.lock);
201 : 0 : i915_vma_free(vma);
202 : 0 : return pos;
203 : : }
204 : :
205 [ # # ]: 0 : if (cmp < 0)
206 : 0 : p = &rb->rb_right;
207 : : else
208 : 0 : p = &rb->rb_left;
209 : : }
210 : 0 : rb_link_node(&vma->obj_node, rb, p);
211 : 0 : rb_insert_color(&vma->obj_node, &obj->vma.tree);
212 : :
213 [ # # ]: 0 : if (i915_vma_is_ggtt(vma))
214 : : /*
215 : : * We put the GGTT vma at the start of the vma-list, followed
216 : : * by the ppGGTT vma. This allows us to break early when
217 : : * iterating over only the GGTT vma for an object, see
218 : : * for_each_ggtt_vma()
219 : : */
220 : 0 : list_add(&vma->obj_link, &obj->vma.list);
221 : : else
222 : 0 : list_add_tail(&vma->obj_link, &obj->vma.list);
223 : :
224 : 0 : spin_unlock(&obj->vma.lock);
225 : :
226 : 0 : return vma;
227 : :
228 : 0 : err_vma:
229 : 0 : i915_vma_free(vma);
230 : 0 : return ERR_PTR(-E2BIG);
231 : : }
232 : :
233 : : static struct i915_vma *
234 : : vma_lookup(struct drm_i915_gem_object *obj,
235 : : struct i915_address_space *vm,
236 : : const struct i915_ggtt_view *view)
237 : : {
238 : : struct rb_node *rb;
239 : :
240 : : rb = obj->vma.tree.rb_node;
241 : : while (rb) {
242 : : struct i915_vma *vma = rb_entry(rb, struct i915_vma, obj_node);
243 : : long cmp;
244 : :
245 : : cmp = i915_vma_compare(vma, vm, view);
246 : : if (cmp == 0)
247 : : return vma;
248 : :
249 : : if (cmp < 0)
250 : : rb = rb->rb_right;
251 : : else
252 : : rb = rb->rb_left;
253 : : }
254 : :
255 : : return NULL;
256 : : }
257 : :
258 : : /**
259 : : * i915_vma_instance - return the singleton instance of the VMA
260 : : * @obj: parent &struct drm_i915_gem_object to be mapped
261 : : * @vm: address space in which the mapping is located
262 : : * @view: additional mapping requirements
263 : : *
264 : : * i915_vma_instance() looks up an existing VMA of the @obj in the @vm with
265 : : * the same @view characteristics. If a match is not found, one is created.
266 : : * Once created, the VMA is kept until either the object is freed, or the
267 : : * address space is closed.
268 : : *
269 : : * Returns the vma, or an error pointer.
270 : : */
271 : : struct i915_vma *
272 : 0 : i915_vma_instance(struct drm_i915_gem_object *obj,
273 : : struct i915_address_space *vm,
274 : : const struct i915_ggtt_view *view)
275 : : {
276 : 0 : struct i915_vma *vma;
277 : :
278 : 0 : GEM_BUG_ON(view && !i915_is_ggtt(vm));
279 : 0 : GEM_BUG_ON(!atomic_read(&vm->open));
280 : :
281 : 0 : spin_lock(&obj->vma.lock);
282 : 0 : vma = vma_lookup(obj, vm, view);
283 : 0 : spin_unlock(&obj->vma.lock);
284 : :
285 : : /* vma_create() will resolve the race if another creates the vma */
286 [ # # ]: 0 : if (unlikely(!vma))
287 : 0 : vma = vma_create(obj, vm, view);
288 : :
289 : 0 : GEM_BUG_ON(!IS_ERR(vma) && i915_vma_compare(vma, vm, view));
290 : 0 : return vma;
291 : : }
292 : :
293 : : struct i915_vma_work {
294 : : struct dma_fence_work base;
295 : : struct i915_vma *vma;
296 : : struct drm_i915_gem_object *pinned;
297 : : enum i915_cache_level cache_level;
298 : : unsigned int flags;
299 : : };
300 : :
301 : 0 : static int __vma_bind(struct dma_fence_work *work)
302 : : {
303 : 0 : struct i915_vma_work *vw = container_of(work, typeof(*vw), base);
304 : 0 : struct i915_vma *vma = vw->vma;
305 : 0 : int err;
306 : :
307 : 0 : err = vma->ops->bind_vma(vma, vw->cache_level, vw->flags);
308 [ # # ]: 0 : if (err)
309 : 0 : atomic_or(I915_VMA_ERROR, &vma->flags);
310 : :
311 : 0 : return err;
312 : : }
313 : :
314 : 0 : static void __vma_release(struct dma_fence_work *work)
315 : : {
316 : 0 : struct i915_vma_work *vw = container_of(work, typeof(*vw), base);
317 : :
318 [ # # ]: 0 : if (vw->pinned)
319 : 0 : __i915_gem_object_unpin_pages(vw->pinned);
320 : 0 : }
321 : :
322 : : static const struct dma_fence_work_ops bind_ops = {
323 : : .name = "bind",
324 : : .work = __vma_bind,
325 : : .release = __vma_release,
326 : : };
327 : :
328 : 0 : struct i915_vma_work *i915_vma_work(void)
329 : : {
330 : 0 : struct i915_vma_work *vw;
331 : :
332 : 0 : vw = kzalloc(sizeof(*vw), GFP_KERNEL);
333 [ # # ]: 0 : if (!vw)
334 : : return NULL;
335 : :
336 : 0 : dma_fence_work_init(&vw->base, &bind_ops);
337 : 0 : vw->base.dma.error = -EAGAIN; /* disable the worker by default */
338 : :
339 : 0 : return vw;
340 : : }
341 : :
342 : : /**
343 : : * i915_vma_bind - Sets up PTEs for an VMA in it's corresponding address space.
344 : : * @vma: VMA to map
345 : : * @cache_level: mapping cache level
346 : : * @flags: flags like global or local mapping
347 : : * @work: preallocated worker for allocating and binding the PTE
348 : : *
349 : : * DMA addresses are taken from the scatter-gather table of this object (or of
350 : : * this VMA in case of non-default GGTT views) and PTE entries set up.
351 : : * Note that DMA addresses are also the only part of the SG table we care about.
352 : : */
353 : 0 : int i915_vma_bind(struct i915_vma *vma,
354 : : enum i915_cache_level cache_level,
355 : : u32 flags,
356 : : struct i915_vma_work *work)
357 : : {
358 : 0 : u32 bind_flags;
359 : 0 : u32 vma_flags;
360 : 0 : int ret;
361 : :
362 : 0 : GEM_BUG_ON(!drm_mm_node_allocated(&vma->node));
363 : 0 : GEM_BUG_ON(vma->size > vma->node.size);
364 : :
365 : 0 : if (GEM_DEBUG_WARN_ON(range_overflows(vma->node.start,
366 : : vma->node.size,
367 : : vma->vm->total)))
368 : : return -ENODEV;
369 : :
370 : 0 : if (GEM_DEBUG_WARN_ON(!flags))
371 : : return -EINVAL;
372 : :
373 : 0 : bind_flags = flags;
374 : 0 : bind_flags &= I915_VMA_GLOBAL_BIND | I915_VMA_LOCAL_BIND;
375 : :
376 : 0 : vma_flags = atomic_read(&vma->flags);
377 : 0 : vma_flags &= I915_VMA_GLOBAL_BIND | I915_VMA_LOCAL_BIND;
378 [ # # ]: 0 : if (flags & PIN_UPDATE)
379 : 0 : bind_flags |= vma_flags;
380 : : else
381 : 0 : bind_flags &= ~vma_flags;
382 [ # # ]: 0 : if (bind_flags == 0)
383 : : return 0;
384 : :
385 : 0 : GEM_BUG_ON(!vma->pages);
386 : :
387 : 0 : trace_i915_vma_bind(vma, bind_flags);
388 [ # # # # ]: 0 : if (work && (bind_flags & ~vma_flags) & vma->vm->bind_async_flags) {
389 : 0 : work->vma = vma;
390 : 0 : work->cache_level = cache_level;
391 : 0 : work->flags = bind_flags | I915_VMA_ALLOC;
392 : :
393 : : /*
394 : : * Note we only want to chain up to the migration fence on
395 : : * the pages (not the object itself). As we don't track that,
396 : : * yet, we have to use the exclusive fence instead.
397 : : *
398 : : * Also note that we do not want to track the async vma as
399 : : * part of the obj->resv->excl_fence as it only affects
400 : : * execution and not content or object's backing store lifetime.
401 : : */
402 : 0 : GEM_BUG_ON(i915_active_has_exclusive(&vma->active));
403 : 0 : i915_active_set_exclusive(&vma->active, &work->base.dma);
404 : 0 : work->base.dma.error = 0; /* enable the queue_work() */
405 : :
406 [ # # ]: 0 : if (vma->obj) {
407 : 0 : __i915_gem_object_pin_pages(vma->obj);
408 : 0 : work->pinned = vma->obj;
409 : : }
410 : : } else {
411 : 0 : GEM_BUG_ON((bind_flags & ~vma_flags) & vma->vm->bind_async_flags);
412 : 0 : ret = vma->ops->bind_vma(vma, cache_level, bind_flags);
413 [ # # ]: 0 : if (ret)
414 : : return ret;
415 : : }
416 : :
417 : 0 : atomic_or(bind_flags, &vma->flags);
418 : 0 : return 0;
419 : : }
420 : :
421 : 0 : void __iomem *i915_vma_pin_iomap(struct i915_vma *vma)
422 : : {
423 : 0 : void __iomem *ptr;
424 : 0 : int err;
425 : :
426 [ # # ]: 0 : if (GEM_WARN_ON(!i915_vma_is_map_and_fenceable(vma))) {
427 : 0 : err = -ENODEV;
428 : 0 : goto err;
429 : : }
430 : :
431 : 0 : GEM_BUG_ON(!i915_vma_is_ggtt(vma));
432 : 0 : GEM_BUG_ON(!i915_vma_is_bound(vma, I915_VMA_GLOBAL_BIND));
433 : :
434 [ # # ]: 0 : ptr = READ_ONCE(vma->iomap);
435 [ # # ]: 0 : if (ptr == NULL) {
436 : 0 : ptr = io_mapping_map_wc(&i915_vm_to_ggtt(vma->vm)->iomap,
437 [ # # ]: 0 : vma->node.start,
438 : : vma->node.size);
439 [ # # ]: 0 : if (ptr == NULL) {
440 : 0 : err = -ENOMEM;
441 : 0 : goto err;
442 : : }
443 : :
444 [ # # ]: 0 : if (unlikely(cmpxchg(&vma->iomap, NULL, ptr))) {
445 : 0 : io_mapping_unmap(ptr);
446 : 0 : ptr = vma->iomap;
447 : : }
448 : : }
449 : :
450 : 0 : __i915_vma_pin(vma);
451 : :
452 : 0 : err = i915_vma_pin_fence(vma);
453 [ # # ]: 0 : if (err)
454 : 0 : goto err_unpin;
455 : :
456 : 0 : i915_vma_set_ggtt_write(vma);
457 : :
458 : : /* NB Access through the GTT requires the device to be awake. */
459 : 0 : return ptr;
460 : :
461 : : err_unpin:
462 : 0 : __i915_vma_unpin(vma);
463 : 0 : err:
464 : 0 : return IO_ERR_PTR(err);
465 : : }
466 : :
467 : 0 : void i915_vma_flush_writes(struct i915_vma *vma)
468 : : {
469 [ # # ]: 0 : if (i915_vma_unset_ggtt_write(vma))
470 : 0 : intel_gt_flush_ggtt_writes(vma->vm->gt);
471 : 0 : }
472 : :
473 : 0 : void i915_vma_unpin_iomap(struct i915_vma *vma)
474 : : {
475 : 0 : GEM_BUG_ON(vma->iomap == NULL);
476 : :
477 : 0 : i915_vma_flush_writes(vma);
478 : :
479 [ # # ]: 0 : i915_vma_unpin_fence(vma);
480 : 0 : i915_vma_unpin(vma);
481 : 0 : }
482 : :
483 : 0 : void i915_vma_unpin_and_release(struct i915_vma **p_vma, unsigned int flags)
484 : : {
485 : 0 : struct i915_vma *vma;
486 : 0 : struct drm_i915_gem_object *obj;
487 : :
488 : 0 : vma = fetch_and_zero(p_vma);
489 [ # # ]: 0 : if (!vma)
490 : : return;
491 : :
492 : 0 : obj = vma->obj;
493 : 0 : GEM_BUG_ON(!obj);
494 : :
495 : 0 : i915_vma_unpin(vma);
496 : 0 : i915_vma_close(vma);
497 : :
498 [ # # ]: 0 : if (flags & I915_VMA_RELEASE_MAP)
499 : 0 : i915_gem_object_unpin_map(obj);
500 : :
501 : 0 : i915_gem_object_put(obj);
502 : : }
503 : :
504 : 0 : bool i915_vma_misplaced(const struct i915_vma *vma,
505 : : u64 size, u64 alignment, u64 flags)
506 : : {
507 [ # # ]: 0 : if (!drm_mm_node_allocated(&vma->node))
508 : : return false;
509 : :
510 [ # # ]: 0 : if (test_bit(I915_VMA_ERROR_BIT, __i915_vma_flags(vma)))
511 : : return true;
512 : :
513 [ # # ]: 0 : if (vma->node.size < size)
514 : : return true;
515 : :
516 : 0 : GEM_BUG_ON(alignment && !is_power_of_2(alignment));
517 [ # # # # ]: 0 : if (alignment && !IS_ALIGNED(vma->node.start, alignment))
518 : : return true;
519 : :
520 [ # # # # ]: 0 : if (flags & PIN_MAPPABLE && !i915_vma_is_map_and_fenceable(vma))
521 : : return true;
522 : :
523 [ # # ]: 0 : if (flags & PIN_OFFSET_BIAS &&
524 [ # # ]: 0 : vma->node.start < (flags & PIN_OFFSET_MASK))
525 : : return true;
526 : :
527 [ # # ]: 0 : if (flags & PIN_OFFSET_FIXED &&
528 [ # # ]: 0 : vma->node.start != (flags & PIN_OFFSET_MASK))
529 : 0 : return true;
530 : :
531 : : return false;
532 : : }
533 : :
534 : 0 : void __i915_vma_set_map_and_fenceable(struct i915_vma *vma)
535 : : {
536 : 0 : bool mappable, fenceable;
537 : :
538 : 0 : GEM_BUG_ON(!i915_vma_is_ggtt(vma));
539 : 0 : GEM_BUG_ON(!vma->fence_size);
540 : :
541 [ # # ]: 0 : fenceable = (vma->node.size >= vma->fence_size &&
542 [ # # ]: 0 : IS_ALIGNED(vma->node.start, vma->fence_alignment));
543 : :
544 [ # # ]: 0 : mappable = vma->node.start + vma->fence_size <= i915_vm_to_ggtt(vma->vm)->mappable_end;
545 : :
546 [ # # ]: 0 : if (mappable && fenceable)
547 : 0 : set_bit(I915_VMA_CAN_FENCE_BIT, __i915_vma_flags(vma));
548 : : else
549 : 0 : clear_bit(I915_VMA_CAN_FENCE_BIT, __i915_vma_flags(vma));
550 : 0 : }
551 : :
552 : 0 : bool i915_gem_valid_gtt_space(struct i915_vma *vma, unsigned long color)
553 : : {
554 : 0 : struct drm_mm_node *node = &vma->node;
555 : 0 : struct drm_mm_node *other;
556 : :
557 : : /*
558 : : * On some machines we have to be careful when putting differing types
559 : : * of snoopable memory together to avoid the prefetcher crossing memory
560 : : * domains and dying. During vm initialisation, we decide whether or not
561 : : * these constraints apply and set the drm_mm.color_adjust
562 : : * appropriately.
563 : : */
564 [ # # # # ]: 0 : if (!i915_vm_has_cache_coloring(vma->vm))
565 : : return true;
566 : :
567 : : /* Only valid to be called on an already inserted vma */
568 : 0 : GEM_BUG_ON(!drm_mm_node_allocated(node));
569 : 0 : GEM_BUG_ON(list_empty(&node->node_list));
570 : :
571 : 0 : other = list_prev_entry(node, node_list);
572 [ # # # # ]: 0 : if (i915_node_color_differs(other, color) &&
573 [ # # ]: 0 : !drm_mm_hole_follows(other))
574 : : return false;
575 : :
576 : 0 : other = list_next_entry(node, node_list);
577 [ # # # # ]: 0 : if (i915_node_color_differs(other, color) &&
578 [ # # ]: 0 : !drm_mm_hole_follows(node))
579 : 0 : return false;
580 : :
581 : : return true;
582 : : }
583 : :
584 : 0 : static void assert_bind_count(const struct drm_i915_gem_object *obj)
585 : : {
586 : : /*
587 : : * Combine the assertion that the object is bound and that we have
588 : : * pinned its pages. But we should never have bound the object
589 : : * more than we have pinned its pages. (For complete accuracy, we
590 : : * assume that no else is pinning the pages, but as a rough assertion
591 : : * that we will not run into problems later, this will do!)
592 : : */
593 : 0 : GEM_BUG_ON(atomic_read(&obj->mm.pages_pin_count) < atomic_read(&obj->bind_count));
594 : : }
595 : :
596 : : /**
597 : : * i915_vma_insert - finds a slot for the vma in its address space
598 : : * @vma: the vma
599 : : * @size: requested size in bytes (can be larger than the VMA)
600 : : * @alignment: required alignment
601 : : * @flags: mask of PIN_* flags to use
602 : : *
603 : : * First we try to allocate some free space that meets the requirements for
604 : : * the VMA. Failiing that, if the flags permit, it will evict an old VMA,
605 : : * preferrably the oldest idle entry to make room for the new VMA.
606 : : *
607 : : * Returns:
608 : : * 0 on success, negative error code otherwise.
609 : : */
610 : : static int
611 : 0 : i915_vma_insert(struct i915_vma *vma, u64 size, u64 alignment, u64 flags)
612 : : {
613 : 0 : unsigned long color;
614 : 0 : u64 start, end;
615 : 0 : int ret;
616 : :
617 : 0 : GEM_BUG_ON(i915_vma_is_closed(vma));
618 : 0 : GEM_BUG_ON(i915_vma_is_bound(vma, I915_VMA_GLOBAL_BIND | I915_VMA_LOCAL_BIND));
619 : 0 : GEM_BUG_ON(drm_mm_node_allocated(&vma->node));
620 : :
621 : 0 : size = max(size, vma->size);
622 : 0 : alignment = max(alignment, vma->display_alignment);
623 [ # # ]: 0 : if (flags & PIN_MAPPABLE) {
624 : 0 : size = max_t(typeof(size), size, vma->fence_size);
625 : 0 : alignment = max_t(typeof(alignment),
626 : : alignment, vma->fence_alignment);
627 : : }
628 : :
629 : 0 : GEM_BUG_ON(!IS_ALIGNED(size, I915_GTT_PAGE_SIZE));
630 : 0 : GEM_BUG_ON(!IS_ALIGNED(alignment, I915_GTT_MIN_ALIGNMENT));
631 : 0 : GEM_BUG_ON(!is_power_of_2(alignment));
632 : :
633 [ # # ]: 0 : start = flags & PIN_OFFSET_BIAS ? flags & PIN_OFFSET_MASK : 0;
634 : 0 : GEM_BUG_ON(!IS_ALIGNED(start, I915_GTT_PAGE_SIZE));
635 : :
636 : 0 : end = vma->vm->total;
637 [ # # ]: 0 : if (flags & PIN_MAPPABLE)
638 : 0 : end = min_t(u64, end, i915_vm_to_ggtt(vma->vm)->mappable_end);
639 [ # # ]: 0 : if (flags & PIN_ZONE_4G)
640 : 0 : end = min_t(u64, end, (1ULL << 32) - I915_GTT_PAGE_SIZE);
641 : 0 : GEM_BUG_ON(!IS_ALIGNED(end, I915_GTT_PAGE_SIZE));
642 : :
643 : : /* If binding the object/GGTT view requires more space than the entire
644 : : * aperture has, reject it early before evicting everything in a vain
645 : : * attempt to find space.
646 : : */
647 [ # # ]: 0 : if (size > end) {
648 [ # # ]: 0 : DRM_DEBUG("Attempting to bind an object larger than the aperture: request=%llu > %s aperture=%llu\n",
649 : : size, flags & PIN_MAPPABLE ? "mappable" : "total",
650 : : end);
651 : 0 : return -ENOSPC;
652 : : }
653 : :
654 : 0 : color = 0;
655 [ # # # # ]: 0 : if (vma->obj && i915_vm_has_cache_coloring(vma->vm))
656 : 0 : color = vma->obj->cache_level;
657 : :
658 [ # # ]: 0 : if (flags & PIN_OFFSET_FIXED) {
659 : 0 : u64 offset = flags & PIN_OFFSET_MASK;
660 [ # # ]: 0 : if (!IS_ALIGNED(offset, alignment) ||
661 [ # # # # ]: 0 : range_overflows(offset, size, end))
662 : : return -EINVAL;
663 : :
664 : 0 : ret = i915_gem_gtt_reserve(vma->vm, &vma->node,
665 : : size, offset, color,
666 : : flags);
667 [ # # ]: 0 : if (ret)
668 : : return ret;
669 : : } else {
670 : : /*
671 : : * We only support huge gtt pages through the 48b PPGTT,
672 : : * however we also don't want to force any alignment for
673 : : * objects which need to be tightly packed into the low 32bits.
674 : : *
675 : : * Note that we assume that GGTT are limited to 4GiB for the
676 : : * forseeable future. See also i915_ggtt_offset().
677 : : */
678 [ # # ]: 0 : if (upper_32_bits(end - 1) &&
679 [ # # ]: 0 : vma->page_sizes.sg > I915_GTT_PAGE_SIZE) {
680 : : /*
681 : : * We can't mix 64K and 4K PTEs in the same page-table
682 : : * (2M block), and so to avoid the ugliness and
683 : : * complexity of coloring we opt for just aligning 64K
684 : : * objects to 2M.
685 : : */
686 : 0 : u64 page_alignment =
687 [ # # # # : 0 : rounddown_pow_of_two(vma->page_sizes.sg |
# # # # #
# # # # #
# # # # #
# # # ]
688 : : I915_GTT_PAGE_SIZE_2M);
689 : :
690 : : /*
691 : : * Check we don't expand for the limited Global GTT
692 : : * (mappable aperture is even more precious!). This
693 : : * also checks that we exclude the aliasing-ppgtt.
694 : : */
695 : 0 : GEM_BUG_ON(i915_vma_is_ggtt(vma));
696 : :
697 : 0 : alignment = max(alignment, page_alignment);
698 : :
699 [ # # ]: 0 : if (vma->page_sizes.sg & I915_GTT_PAGE_SIZE_64K)
700 : 0 : size = round_up(size, I915_GTT_PAGE_SIZE_2M);
701 : : }
702 : :
703 : 0 : ret = i915_gem_gtt_insert(vma->vm, &vma->node,
704 : : size, alignment, color,
705 : : start, end, flags);
706 [ # # ]: 0 : if (ret)
707 : : return ret;
708 : :
709 : 0 : GEM_BUG_ON(vma->node.start < start);
710 : 0 : GEM_BUG_ON(vma->node.start + vma->node.size > end);
711 : : }
712 : 0 : GEM_BUG_ON(!drm_mm_node_allocated(&vma->node));
713 : 0 : GEM_BUG_ON(!i915_gem_valid_gtt_space(vma, color));
714 : :
715 [ # # ]: 0 : if (vma->obj) {
716 : 0 : struct drm_i915_gem_object *obj = vma->obj;
717 : :
718 : 0 : atomic_inc(&obj->bind_count);
719 : 0 : assert_bind_count(obj);
720 : : }
721 : 0 : list_add_tail(&vma->vm_link, &vma->vm->bound_list);
722 : :
723 : 0 : return 0;
724 : : }
725 : :
726 : : static void
727 : 0 : i915_vma_detach(struct i915_vma *vma)
728 : : {
729 : 0 : GEM_BUG_ON(!drm_mm_node_allocated(&vma->node));
730 : 0 : GEM_BUG_ON(i915_vma_is_bound(vma, I915_VMA_GLOBAL_BIND | I915_VMA_LOCAL_BIND));
731 : :
732 : : /*
733 : : * And finally now the object is completely decoupled from this
734 : : * vma, we can drop its hold on the backing storage and allow
735 : : * it to be reaped by the shrinker.
736 : : */
737 : 0 : list_del(&vma->vm_link);
738 [ # # # # ]: 0 : if (vma->obj) {
739 : 0 : struct drm_i915_gem_object *obj = vma->obj;
740 : :
741 : 0 : assert_bind_count(obj);
742 : 0 : atomic_dec(&obj->bind_count);
743 : : }
744 : : }
745 : :
746 : 0 : static bool try_qad_pin(struct i915_vma *vma, unsigned int flags)
747 : : {
748 : 0 : unsigned int bound;
749 : 0 : bool pinned = true;
750 : :
751 : 0 : bound = atomic_read(&vma->flags);
752 : 0 : do {
753 [ # # ]: 0 : if (unlikely(flags & ~bound))
754 : : return false;
755 : :
756 [ # # ]: 0 : if (unlikely(bound & (I915_VMA_OVERFLOW | I915_VMA_ERROR)))
757 : : return false;
758 : :
759 [ # # ]: 0 : if (!(bound & I915_VMA_PIN_MASK))
760 : 0 : goto unpinned;
761 : :
762 : 0 : GEM_BUG_ON(((bound + 1) & I915_VMA_PIN_MASK) == 0);
763 [ # # ]: 0 : } while (!atomic_try_cmpxchg(&vma->flags, &bound, bound + 1));
764 : :
765 : : return true;
766 : :
767 : : unpinned:
768 : : /*
769 : : * If pin_count==0, but we are bound, check under the lock to avoid
770 : : * racing with a concurrent i915_vma_unbind().
771 : : */
772 : 0 : mutex_lock(&vma->vm->mutex);
773 : 0 : do {
774 [ # # ]: 0 : if (unlikely(bound & (I915_VMA_OVERFLOW | I915_VMA_ERROR))) {
775 : : pinned = false;
776 : : break;
777 : : }
778 : :
779 [ # # ]: 0 : if (unlikely(flags & ~bound)) {
780 : : pinned = false;
781 : : break;
782 : : }
783 [ # # ]: 0 : } while (!atomic_try_cmpxchg(&vma->flags, &bound, bound + 1));
784 : 0 : mutex_unlock(&vma->vm->mutex);
785 : :
786 : 0 : return pinned;
787 : : }
788 : :
789 : 0 : static int vma_get_pages(struct i915_vma *vma)
790 : : {
791 : 0 : int err = 0;
792 : :
793 [ # # ]: 0 : if (atomic_add_unless(&vma->pages_count, 1, 0))
794 : : return 0;
795 : :
796 : : /* Allocations ahoy! */
797 [ # # ]: 0 : if (mutex_lock_interruptible(&vma->pages_mutex))
798 : : return -EINTR;
799 : :
800 [ # # ]: 0 : if (!atomic_read(&vma->pages_count)) {
801 [ # # ]: 0 : if (vma->obj) {
802 : 0 : err = i915_gem_object_pin_pages(vma->obj);
803 [ # # ]: 0 : if (err)
804 : 0 : goto unlock;
805 : : }
806 : :
807 : 0 : err = vma->ops->set_pages(vma);
808 [ # # ]: 0 : if (err) {
809 [ # # ]: 0 : if (vma->obj)
810 : 0 : i915_gem_object_unpin_pages(vma->obj);
811 : 0 : goto unlock;
812 : : }
813 : : }
814 : 0 : atomic_inc(&vma->pages_count);
815 : :
816 : 0 : unlock:
817 : 0 : mutex_unlock(&vma->pages_mutex);
818 : :
819 : 0 : return err;
820 : : }
821 : :
822 : 0 : static void __vma_put_pages(struct i915_vma *vma, unsigned int count)
823 : : {
824 : : /* We allocate under vma_get_pages, so beware the shrinker */
825 : 0 : mutex_lock_nested(&vma->pages_mutex, SINGLE_DEPTH_NESTING);
826 : 0 : GEM_BUG_ON(atomic_read(&vma->pages_count) < count);
827 [ # # ]: 0 : if (atomic_sub_return(count, &vma->pages_count) == 0) {
828 : 0 : vma->ops->clear_pages(vma);
829 : 0 : GEM_BUG_ON(vma->pages);
830 [ # # ]: 0 : if (vma->obj)
831 : 0 : i915_gem_object_unpin_pages(vma->obj);
832 : : }
833 : 0 : mutex_unlock(&vma->pages_mutex);
834 : 0 : }
835 : :
836 : 0 : static void vma_put_pages(struct i915_vma *vma)
837 : : {
838 [ # # ]: 0 : if (atomic_add_unless(&vma->pages_count, -1, 1))
839 : : return;
840 : :
841 : 0 : __vma_put_pages(vma, 1);
842 : : }
843 : :
844 : 0 : static void vma_unbind_pages(struct i915_vma *vma)
845 : : {
846 : 0 : unsigned int count;
847 : :
848 : 0 : lockdep_assert_held(&vma->vm->mutex);
849 : :
850 : : /* The upper portion of pages_count is the number of bindings */
851 : 0 : count = atomic_read(&vma->pages_count);
852 : 0 : count >>= I915_VMA_PAGES_BIAS;
853 : 0 : GEM_BUG_ON(!count);
854 : :
855 : 0 : __vma_put_pages(vma, count | count << I915_VMA_PAGES_BIAS);
856 : 0 : }
857 : :
858 : 0 : int i915_vma_pin(struct i915_vma *vma, u64 size, u64 alignment, u64 flags)
859 : : {
860 : 0 : struct i915_vma_work *work = NULL;
861 : 0 : intel_wakeref_t wakeref = 0;
862 : 0 : unsigned int bound;
863 : 0 : int err;
864 : :
865 : 0 : BUILD_BUG_ON(PIN_GLOBAL != I915_VMA_GLOBAL_BIND);
866 : 0 : BUILD_BUG_ON(PIN_USER != I915_VMA_LOCAL_BIND);
867 : :
868 : 0 : GEM_BUG_ON(flags & PIN_UPDATE);
869 : 0 : GEM_BUG_ON(!(flags & (PIN_USER | PIN_GLOBAL)));
870 : :
871 : : /* First try and grab the pin without rebinding the vma */
872 [ # # ]: 0 : if (try_qad_pin(vma, flags & I915_VMA_BIND_MASK))
873 : : return 0;
874 : :
875 : 0 : err = vma_get_pages(vma);
876 [ # # ]: 0 : if (err)
877 : : return err;
878 : :
879 [ # # ]: 0 : if (flags & vma->vm->bind_async_flags) {
880 : 0 : work = i915_vma_work();
881 [ # # ]: 0 : if (!work) {
882 : 0 : err = -ENOMEM;
883 : 0 : goto err_pages;
884 : : }
885 : : }
886 : :
887 [ # # ]: 0 : if (flags & PIN_GLOBAL)
888 : 0 : wakeref = intel_runtime_pm_get(&vma->vm->i915->runtime_pm);
889 : :
890 : : /* No more allocations allowed once we hold vm->mutex */
891 : 0 : err = mutex_lock_interruptible(&vma->vm->mutex);
892 [ # # ]: 0 : if (err)
893 : 0 : goto err_fence;
894 : :
895 : 0 : bound = atomic_read(&vma->flags);
896 [ # # ]: 0 : if (unlikely(bound & I915_VMA_ERROR)) {
897 : 0 : err = -ENOMEM;
898 : 0 : goto err_unlock;
899 : : }
900 : :
901 [ # # ]: 0 : if (unlikely(!((bound + 1) & I915_VMA_PIN_MASK))) {
902 : 0 : err = -EAGAIN; /* pins are meant to be fairly temporary */
903 : 0 : goto err_unlock;
904 : : }
905 : :
906 [ # # ]: 0 : if (unlikely(!(flags & ~bound & I915_VMA_BIND_MASK))) {
907 : 0 : __i915_vma_pin(vma);
908 : 0 : goto err_unlock;
909 : : }
910 : :
911 : 0 : err = i915_active_acquire(&vma->active);
912 [ # # ]: 0 : if (err)
913 : 0 : goto err_unlock;
914 : :
915 [ # # ]: 0 : if (!(bound & I915_VMA_BIND_MASK)) {
916 : 0 : err = i915_vma_insert(vma, size, alignment, flags);
917 [ # # ]: 0 : if (err)
918 : 0 : goto err_active;
919 : :
920 [ # # ]: 0 : if (i915_is_ggtt(vma->vm))
921 : 0 : __i915_vma_set_map_and_fenceable(vma);
922 : : }
923 : :
924 : 0 : GEM_BUG_ON(!vma->pages);
925 : 0 : err = i915_vma_bind(vma,
926 [ # # ]: 0 : vma->obj ? vma->obj->cache_level : 0,
927 : : flags, work);
928 [ # # ]: 0 : if (err)
929 : 0 : goto err_remove;
930 : :
931 : : /* There should only be at most 2 active bindings (user, global) */
932 : 0 : GEM_BUG_ON(bound + I915_VMA_PAGES_ACTIVE < bound);
933 : 0 : atomic_add(I915_VMA_PAGES_ACTIVE, &vma->pages_count);
934 : 0 : list_move_tail(&vma->vm_link, &vma->vm->bound_list);
935 : :
936 : 0 : __i915_vma_pin(vma);
937 : 0 : GEM_BUG_ON(!i915_vma_is_pinned(vma));
938 : 0 : GEM_BUG_ON(!i915_vma_is_bound(vma, flags));
939 : 0 : GEM_BUG_ON(i915_vma_misplaced(vma, size, alignment, flags));
940 : :
941 : 0 : err_remove:
942 [ # # ]: 0 : if (!i915_vma_is_bound(vma, I915_VMA_BIND_MASK)) {
943 [ # # ]: 0 : i915_vma_detach(vma);
944 : 0 : drm_mm_remove_node(&vma->node);
945 : : }
946 : 0 : err_active:
947 : 0 : i915_active_release(&vma->active);
948 : 0 : err_unlock:
949 : 0 : mutex_unlock(&vma->vm->mutex);
950 : 0 : err_fence:
951 [ # # ]: 0 : if (work)
952 : 0 : dma_fence_work_commit(&work->base);
953 [ # # ]: 0 : if (wakeref)
954 : 0 : intel_runtime_pm_put(&vma->vm->i915->runtime_pm, wakeref);
955 : 0 : err_pages:
956 : 0 : vma_put_pages(vma);
957 : 0 : return err;
958 : : }
959 : :
960 : 0 : static void flush_idle_contexts(struct intel_gt *gt)
961 : : {
962 : 0 : struct intel_engine_cs *engine;
963 : 0 : enum intel_engine_id id;
964 : :
965 [ # # # # ]: 0 : for_each_engine(engine, gt, id)
966 : 0 : intel_engine_flush_barriers(engine);
967 : :
968 : 0 : intel_gt_wait_for_idle(gt, MAX_SCHEDULE_TIMEOUT);
969 : 0 : }
970 : :
971 : 0 : int i915_ggtt_pin(struct i915_vma *vma, u32 align, unsigned int flags)
972 : : {
973 : 0 : struct i915_address_space *vm = vma->vm;
974 : 0 : int err;
975 : :
976 : 0 : GEM_BUG_ON(!i915_vma_is_ggtt(vma));
977 : :
978 : 0 : do {
979 : 0 : err = i915_vma_pin(vma, 0, align, flags | PIN_GLOBAL);
980 [ # # ]: 0 : if (err != -ENOSPC)
981 : 0 : return err;
982 : :
983 : : /* Unlike i915_vma_pin, we don't take no for an answer! */
984 : 0 : flush_idle_contexts(vm->gt);
985 [ # # ]: 0 : if (mutex_lock_interruptible(&vm->mutex) == 0) {
986 : 0 : i915_gem_evict_vm(vm);
987 : 0 : mutex_unlock(&vm->mutex);
988 : : }
989 : : } while (1);
990 : : }
991 : :
992 : 0 : void i915_vma_close(struct i915_vma *vma)
993 : : {
994 : 0 : struct intel_gt *gt = vma->vm->gt;
995 : 0 : unsigned long flags;
996 : :
997 : 0 : GEM_BUG_ON(i915_vma_is_closed(vma));
998 : :
999 : : /*
1000 : : * We defer actually closing, unbinding and destroying the VMA until
1001 : : * the next idle point, or if the object is freed in the meantime. By
1002 : : * postponing the unbind, we allow for it to be resurrected by the
1003 : : * client, avoiding the work required to rebind the VMA. This is
1004 : : * advantageous for DRI, where the client/server pass objects
1005 : : * between themselves, temporarily opening a local VMA to the
1006 : : * object, and then closing it again. The same object is then reused
1007 : : * on the next frame (or two, depending on the depth of the swap queue)
1008 : : * causing us to rebind the VMA once more. This ends up being a lot
1009 : : * of wasted work for the steady state.
1010 : : */
1011 : 0 : spin_lock_irqsave(>->closed_lock, flags);
1012 : 0 : list_add(&vma->closed_link, >->closed_vma);
1013 : 0 : spin_unlock_irqrestore(>->closed_lock, flags);
1014 : 0 : }
1015 : :
1016 : 0 : static void __i915_vma_remove_closed(struct i915_vma *vma)
1017 : : {
1018 : 0 : struct intel_gt *gt = vma->vm->gt;
1019 : :
1020 : 0 : spin_lock_irq(>->closed_lock);
1021 : 0 : list_del_init(&vma->closed_link);
1022 : 0 : spin_unlock_irq(>->closed_lock);
1023 : 0 : }
1024 : :
1025 : 0 : void i915_vma_reopen(struct i915_vma *vma)
1026 : : {
1027 [ # # ]: 0 : if (i915_vma_is_closed(vma))
1028 : 0 : __i915_vma_remove_closed(vma);
1029 : 0 : }
1030 : :
1031 : 0 : void i915_vma_release(struct kref *ref)
1032 : : {
1033 : 0 : struct i915_vma *vma = container_of(ref, typeof(*vma), ref);
1034 : :
1035 [ # # ]: 0 : if (drm_mm_node_allocated(&vma->node)) {
1036 : 0 : mutex_lock(&vma->vm->mutex);
1037 : 0 : atomic_and(~I915_VMA_PIN_MASK, &vma->flags);
1038 [ # # ]: 0 : WARN_ON(__i915_vma_unbind(vma));
1039 : 0 : mutex_unlock(&vma->vm->mutex);
1040 : 0 : GEM_BUG_ON(drm_mm_node_allocated(&vma->node));
1041 : : }
1042 : 0 : GEM_BUG_ON(i915_vma_is_active(vma));
1043 : :
1044 [ # # ]: 0 : if (vma->obj) {
1045 : 0 : struct drm_i915_gem_object *obj = vma->obj;
1046 : :
1047 : 0 : spin_lock(&obj->vma.lock);
1048 : 0 : list_del(&vma->obj_link);
1049 : 0 : rb_erase(&vma->obj_node, &obj->vma.tree);
1050 : 0 : spin_unlock(&obj->vma.lock);
1051 : : }
1052 : :
1053 : 0 : __i915_vma_remove_closed(vma);
1054 : 0 : i915_vm_put(vma->vm);
1055 : :
1056 : 0 : i915_active_fini(&vma->active);
1057 : 0 : i915_vma_free(vma);
1058 : 0 : }
1059 : :
1060 : 0 : void i915_vma_parked(struct intel_gt *gt)
1061 : : {
1062 : 0 : struct i915_vma *vma, *next;
1063 : :
1064 : 0 : spin_lock_irq(>->closed_lock);
1065 [ # # ]: 0 : list_for_each_entry_safe(vma, next, >->closed_vma, closed_link) {
1066 : 0 : struct drm_i915_gem_object *obj = vma->obj;
1067 : 0 : struct i915_address_space *vm = vma->vm;
1068 : :
1069 : : /* XXX All to avoid keeping a reference on i915_vma itself */
1070 : :
1071 [ # # ]: 0 : if (!kref_get_unless_zero(&obj->base.refcount))
1072 : 0 : continue;
1073 : :
1074 [ # # ]: 0 : if (i915_vm_tryopen(vm)) {
1075 : 0 : list_del_init(&vma->closed_link);
1076 : : } else {
1077 : 0 : i915_gem_object_put(obj);
1078 : 0 : obj = NULL;
1079 : : }
1080 : :
1081 : 0 : spin_unlock_irq(>->closed_lock);
1082 : :
1083 [ # # ]: 0 : if (obj) {
1084 : 0 : __i915_vma_put(vma);
1085 : 0 : i915_gem_object_put(obj);
1086 : : }
1087 : :
1088 : 0 : i915_vm_close(vm);
1089 : :
1090 : : /* Restart after dropping lock */
1091 : 0 : spin_lock_irq(>->closed_lock);
1092 : 0 : next = list_first_entry(>->closed_vma,
1093 : : typeof(*next), closed_link);
1094 : : }
1095 : 0 : spin_unlock_irq(>->closed_lock);
1096 : 0 : }
1097 : :
1098 : 0 : static void __i915_vma_iounmap(struct i915_vma *vma)
1099 : : {
1100 : 0 : GEM_BUG_ON(i915_vma_is_pinned(vma));
1101 : :
1102 : 0 : if (vma->iomap == NULL)
1103 : : return;
1104 : :
1105 : 0 : io_mapping_unmap(vma->iomap);
1106 : 0 : vma->iomap = NULL;
1107 : : }
1108 : :
1109 : 0 : void i915_vma_revoke_mmap(struct i915_vma *vma)
1110 : : {
1111 : 0 : struct drm_vma_offset_node *node;
1112 : 0 : u64 vma_offset;
1113 : :
1114 [ # # ]: 0 : if (!i915_vma_has_userfault(vma))
1115 : : return;
1116 : :
1117 : 0 : GEM_BUG_ON(!i915_vma_is_map_and_fenceable(vma));
1118 : 0 : GEM_BUG_ON(!vma->obj->userfault_count);
1119 : :
1120 : 0 : node = &vma->mmo->vma_node;
1121 : 0 : vma_offset = vma->ggtt_view.partial.offset << PAGE_SHIFT;
1122 : 0 : unmap_mapping_range(vma->vm->i915->drm.anon_inode->i_mapping,
1123 : 0 : drm_vma_node_offset_addr(node) + vma_offset,
1124 : 0 : vma->size,
1125 : : 1);
1126 : :
1127 : 0 : i915_vma_unset_userfault(vma);
1128 [ # # ]: 0 : if (!--vma->obj->userfault_count)
1129 : 0 : list_del(&vma->obj->userfault_link);
1130 : : }
1131 : :
1132 : 0 : int __i915_vma_move_to_active(struct i915_vma *vma, struct i915_request *rq)
1133 : : {
1134 : 0 : int err;
1135 : :
1136 : 0 : GEM_BUG_ON(!i915_vma_is_pinned(vma));
1137 : :
1138 : : /* Wait for the vma to be bound before we start! */
1139 : 0 : err = i915_request_await_active(rq, &vma->active);
1140 [ # # ]: 0 : if (err)
1141 : : return err;
1142 : :
1143 : 0 : return i915_active_add_request(&vma->active, rq);
1144 : : }
1145 : :
1146 : 0 : int i915_vma_move_to_active(struct i915_vma *vma,
1147 : : struct i915_request *rq,
1148 : : unsigned int flags)
1149 : : {
1150 : 0 : struct drm_i915_gem_object *obj = vma->obj;
1151 : 0 : int err;
1152 : :
1153 : 0 : assert_object_held(obj);
1154 : :
1155 : 0 : err = __i915_vma_move_to_active(vma, rq);
1156 [ # # ]: 0 : if (unlikely(err))
1157 : : return err;
1158 : :
1159 [ # # ]: 0 : if (flags & EXEC_OBJECT_WRITE) {
1160 : 0 : struct intel_frontbuffer *front;
1161 : :
1162 : 0 : front = __intel_frontbuffer_get(obj);
1163 [ # # ]: 0 : if (unlikely(front)) {
1164 [ # # ]: 0 : if (intel_frontbuffer_invalidate(front, ORIGIN_CS))
1165 : 0 : i915_active_add_request(&front->write, rq);
1166 : 0 : intel_frontbuffer_put(front);
1167 : : }
1168 : :
1169 : 0 : dma_resv_add_excl_fence(vma->resv, &rq->fence);
1170 : 0 : obj->write_domain = I915_GEM_DOMAIN_RENDER;
1171 : 0 : obj->read_domains = 0;
1172 : : } else {
1173 : 0 : err = dma_resv_reserve_shared(vma->resv, 1);
1174 [ # # ]: 0 : if (unlikely(err))
1175 : : return err;
1176 : :
1177 : 0 : dma_resv_add_shared_fence(vma->resv, &rq->fence);
1178 : 0 : obj->write_domain = 0;
1179 : : }
1180 : 0 : obj->read_domains |= I915_GEM_GPU_DOMAINS;
1181 : 0 : obj->mm.dirty = true;
1182 : :
1183 : 0 : GEM_BUG_ON(!i915_vma_is_active(vma));
1184 : 0 : return 0;
1185 : : }
1186 : :
1187 : 0 : int __i915_vma_unbind(struct i915_vma *vma)
1188 : : {
1189 : 0 : int ret;
1190 : :
1191 : 0 : lockdep_assert_held(&vma->vm->mutex);
1192 : :
1193 : : /*
1194 : : * First wait upon any activity as retiring the request may
1195 : : * have side-effects such as unpinning or even unbinding this vma.
1196 : : *
1197 : : * XXX Actually waiting under the vm->mutex is a hinderance and
1198 : : * should be pipelined wherever possible. In cases where that is
1199 : : * unavoidable, we should lift the wait to before the mutex.
1200 : : */
1201 : 0 : ret = i915_vma_sync(vma);
1202 [ # # ]: 0 : if (ret)
1203 : : return ret;
1204 : :
1205 [ # # ]: 0 : if (i915_vma_is_pinned(vma)) {
1206 : : vma_print_allocator(vma, "is pinned");
1207 : : return -EAGAIN;
1208 : : }
1209 : :
1210 : : /*
1211 : : * After confirming that no one else is pinning this vma, wait for
1212 : : * any laggards who may have crept in during the wait (through
1213 : : * a residual pin skipping the vm->mutex) to complete.
1214 : : */
1215 : 0 : ret = i915_vma_sync(vma);
1216 [ # # ]: 0 : if (ret)
1217 : : return ret;
1218 : :
1219 [ # # ]: 0 : if (!drm_mm_node_allocated(&vma->node))
1220 : : return 0;
1221 : :
1222 : 0 : GEM_BUG_ON(i915_vma_is_pinned(vma));
1223 : 0 : GEM_BUG_ON(i915_vma_is_active(vma));
1224 : :
1225 [ # # ]: 0 : if (i915_vma_is_map_and_fenceable(vma)) {
1226 : : /*
1227 : : * Check that we have flushed all writes through the GGTT
1228 : : * before the unbind, other due to non-strict nature of those
1229 : : * indirect writes they may end up referencing the GGTT PTE
1230 : : * after the unbind.
1231 : : */
1232 : 0 : i915_vma_flush_writes(vma);
1233 : 0 : GEM_BUG_ON(i915_vma_has_ggtt_write(vma));
1234 : :
1235 : : /* release the fence reg _after_ flushing */
1236 : 0 : ret = i915_vma_revoke_fence(vma);
1237 [ # # ]: 0 : if (ret)
1238 : : return ret;
1239 : :
1240 : : /* Force a pagefault for domain tracking on next user access */
1241 : 0 : i915_vma_revoke_mmap(vma);
1242 : :
1243 [ # # ]: 0 : __i915_vma_iounmap(vma);
1244 : 0 : clear_bit(I915_VMA_CAN_FENCE_BIT, __i915_vma_flags(vma));
1245 : : }
1246 : 0 : GEM_BUG_ON(vma->fence);
1247 : 0 : GEM_BUG_ON(i915_vma_has_userfault(vma));
1248 : :
1249 [ # # ]: 0 : if (likely(atomic_read(&vma->vm->open))) {
1250 : 0 : trace_i915_vma_unbind(vma);
1251 : 0 : vma->ops->unbind_vma(vma);
1252 : : }
1253 : 0 : atomic_and(~(I915_VMA_BIND_MASK | I915_VMA_ERROR), &vma->flags);
1254 : :
1255 [ # # ]: 0 : i915_vma_detach(vma);
1256 : 0 : vma_unbind_pages(vma);
1257 : :
1258 : 0 : drm_mm_remove_node(&vma->node); /* pairs with i915_vma_release() */
1259 : 0 : return 0;
1260 : : }
1261 : :
1262 : 0 : int i915_vma_unbind(struct i915_vma *vma)
1263 : : {
1264 : 0 : struct i915_address_space *vm = vma->vm;
1265 : 0 : intel_wakeref_t wakeref = 0;
1266 : 0 : int err;
1267 : :
1268 [ # # ]: 0 : if (!drm_mm_node_allocated(&vma->node))
1269 : : return 0;
1270 : :
1271 [ # # ]: 0 : if (i915_vma_is_bound(vma, I915_VMA_GLOBAL_BIND))
1272 : : /* XXX not always required: nop_clear_range */
1273 : 0 : wakeref = intel_runtime_pm_get(&vm->i915->runtime_pm);
1274 : :
1275 : 0 : err = mutex_lock_interruptible(&vm->mutex);
1276 [ # # ]: 0 : if (err)
1277 : : return err;
1278 : :
1279 : 0 : err = __i915_vma_unbind(vma);
1280 : 0 : mutex_unlock(&vm->mutex);
1281 : :
1282 [ # # ]: 0 : if (wakeref)
1283 : 0 : intel_runtime_pm_put(&vm->i915->runtime_pm, wakeref);
1284 : :
1285 : : return err;
1286 : : }
1287 : :
1288 : 0 : struct i915_vma *i915_vma_make_unshrinkable(struct i915_vma *vma)
1289 : : {
1290 : 0 : i915_gem_object_make_unshrinkable(vma->obj);
1291 : 0 : return vma;
1292 : : }
1293 : :
1294 : 0 : void i915_vma_make_shrinkable(struct i915_vma *vma)
1295 : : {
1296 : 0 : i915_gem_object_make_shrinkable(vma->obj);
1297 : 0 : }
1298 : :
1299 : 0 : void i915_vma_make_purgeable(struct i915_vma *vma)
1300 : : {
1301 : 0 : i915_gem_object_make_purgeable(vma->obj);
1302 : 0 : }
1303 : :
1304 : : #if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
1305 : : #include "selftests/i915_vma.c"
1306 : : #endif
1307 : :
1308 : 0 : static void i915_global_vma_shrink(void)
1309 : : {
1310 : 0 : kmem_cache_shrink(global.slab_vmas);
1311 : 0 : }
1312 : :
1313 : 0 : static void i915_global_vma_exit(void)
1314 : : {
1315 : 0 : kmem_cache_destroy(global.slab_vmas);
1316 : 0 : }
1317 : :
1318 : : static struct i915_global_vma global = { {
1319 : : .shrink = i915_global_vma_shrink,
1320 : : .exit = i915_global_vma_exit,
1321 : : } };
1322 : :
1323 : 3 : int __init i915_global_vma_init(void)
1324 : : {
1325 : 3 : global.slab_vmas = KMEM_CACHE(i915_vma, SLAB_HWCACHE_ALIGN);
1326 [ + - ]: 3 : if (!global.slab_vmas)
1327 : : return -ENOMEM;
1328 : :
1329 : 3 : i915_global_register(&global.base);
1330 : 3 : return 0;
1331 : : }
|
