cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

i915_gem_evict.c (14732B)


      1/*
      2 * Copyright © 2008-2010 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 * Authors:
     24 *    Eric Anholt <eric@anholt.net>
     25 *    Chris Wilson <chris@chris-wilson.co.uuk>
     26 *
     27 */
     28
     29#include "gem/i915_gem_context.h"
     30#include "gt/intel_gt.h"
     31#include "gt/intel_gt_requests.h"
     32
     33#include "i915_drv.h"
     34#include "i915_gem_evict.h"
     35#include "i915_trace.h"
     36
     37I915_SELFTEST_DECLARE(static struct igt_evict_ctl {
     38	bool fail_if_busy:1;
     39} igt_evict_ctl;)
     40
     41static bool dying_vma(struct i915_vma *vma)
     42{
     43	return !kref_read(&vma->obj->base.refcount);
     44}
     45
     46static int ggtt_flush(struct intel_gt *gt)
     47{
     48	/*
     49	 * Not everything in the GGTT is tracked via vma (otherwise we
     50	 * could evict as required with minimal stalling) so we are forced
     51	 * to idle the GPU and explicitly retire outstanding requests in
     52	 * the hopes that we can then remove contexts and the like only
     53	 * bound by their active reference.
     54	 */
     55	return intel_gt_wait_for_idle(gt, MAX_SCHEDULE_TIMEOUT);
     56}
     57
     58static bool grab_vma(struct i915_vma *vma, struct i915_gem_ww_ctx *ww)
     59{
     60	/*
     61	 * We add the extra refcount so the object doesn't drop to zero until
     62	 * after ungrab_vma(), this way trylock is always paired with unlock.
     63	 */
     64	if (i915_gem_object_get_rcu(vma->obj)) {
     65		if (!i915_gem_object_trylock(vma->obj, ww)) {
     66			i915_gem_object_put(vma->obj);
     67			return false;
     68		}
     69	} else {
     70		/* Dead objects don't need pins */
     71		atomic_and(~I915_VMA_PIN_MASK, &vma->flags);
     72	}
     73
     74	return true;
     75}
     76
     77static void ungrab_vma(struct i915_vma *vma)
     78{
     79	if (dying_vma(vma))
     80		return;
     81
     82	i915_gem_object_unlock(vma->obj);
     83	i915_gem_object_put(vma->obj);
     84}
     85
     86static bool
     87mark_free(struct drm_mm_scan *scan,
     88	  struct i915_gem_ww_ctx *ww,
     89	  struct i915_vma *vma,
     90	  unsigned int flags,
     91	  struct list_head *unwind)
     92{
     93	if (i915_vma_is_pinned(vma))
     94		return false;
     95
     96	if (!grab_vma(vma, ww))
     97		return false;
     98
     99	list_add(&vma->evict_link, unwind);
    100	return drm_mm_scan_add_block(scan, &vma->node);
    101}
    102
    103static bool defer_evict(struct i915_vma *vma)
    104{
    105	if (i915_vma_is_active(vma))
    106		return true;
    107
    108	if (i915_vma_is_scanout(vma))
    109		return true;
    110
    111	return false;
    112}
    113
    114/**
    115 * i915_gem_evict_something - Evict vmas to make room for binding a new one
    116 * @vm: address space to evict from
    117 * @ww: An optional struct i915_gem_ww_ctx.
    118 * @min_size: size of the desired free space
    119 * @alignment: alignment constraint of the desired free space
    120 * @color: color for the desired space
    121 * @start: start (inclusive) of the range from which to evict objects
    122 * @end: end (exclusive) of the range from which to evict objects
    123 * @flags: additional flags to control the eviction algorithm
    124 *
    125 * This function will try to evict vmas until a free space satisfying the
    126 * requirements is found. Callers must check first whether any such hole exists
    127 * already before calling this function.
    128 *
    129 * This function is used by the object/vma binding code.
    130 *
    131 * Since this function is only used to free up virtual address space it only
    132 * ignores pinned vmas, and not object where the backing storage itself is
    133 * pinned. Hence obj->pages_pin_count does not protect against eviction.
    134 *
    135 * To clarify: This is for freeing up virtual address space, not for freeing
    136 * memory in e.g. the shrinker.
    137 */
    138int
    139i915_gem_evict_something(struct i915_address_space *vm,
    140			 struct i915_gem_ww_ctx *ww,
    141			 u64 min_size, u64 alignment,
    142			 unsigned long color,
    143			 u64 start, u64 end,
    144			 unsigned flags)
    145{
    146	struct drm_mm_scan scan;
    147	struct list_head eviction_list;
    148	struct i915_vma *vma, *next;
    149	struct drm_mm_node *node;
    150	enum drm_mm_insert_mode mode;
    151	struct i915_vma *active;
    152	int ret;
    153
    154	lockdep_assert_held(&vm->mutex);
    155	trace_i915_gem_evict(vm, min_size, alignment, flags);
    156
    157	/*
    158	 * The goal is to evict objects and amalgamate space in rough LRU order.
    159	 * Since both active and inactive objects reside on the same list,
    160	 * in a mix of creation and last scanned order, as we process the list
    161	 * we sort it into inactive/active, which keeps the active portion
    162	 * in a rough MRU order.
    163	 *
    164	 * The retirement sequence is thus:
    165	 *   1. Inactive objects (already retired, random order)
    166	 *   2. Active objects (will stall on unbinding, oldest scanned first)
    167	 */
    168	mode = DRM_MM_INSERT_BEST;
    169	if (flags & PIN_HIGH)
    170		mode = DRM_MM_INSERT_HIGH;
    171	if (flags & PIN_MAPPABLE)
    172		mode = DRM_MM_INSERT_LOW;
    173	drm_mm_scan_init_with_range(&scan, &vm->mm,
    174				    min_size, alignment, color,
    175				    start, end, mode);
    176
    177	intel_gt_retire_requests(vm->gt);
    178
    179search_again:
    180	active = NULL;
    181	INIT_LIST_HEAD(&eviction_list);
    182	list_for_each_entry_safe(vma, next, &vm->bound_list, vm_link) {
    183		if (vma == active) { /* now seen this vma twice */
    184			if (flags & PIN_NONBLOCK)
    185				break;
    186
    187			active = ERR_PTR(-EAGAIN);
    188		}
    189
    190		/*
    191		 * We keep this list in a rough least-recently scanned order
    192		 * of active elements (inactive elements are cheap to reap).
    193		 * New entries are added to the end, and we move anything we
    194		 * scan to the end. The assumption is that the working set
    195		 * of applications is either steady state (and thanks to the
    196		 * userspace bo cache it almost always is) or volatile and
    197		 * frequently replaced after a frame, which are self-evicting!
    198		 * Given that assumption, the MRU order of the scan list is
    199		 * fairly static, and keeping it in least-recently scan order
    200		 * is suitable.
    201		 *
    202		 * To notice when we complete one full cycle, we record the
    203		 * first active element seen, before moving it to the tail.
    204		 */
    205		if (active != ERR_PTR(-EAGAIN) && defer_evict(vma)) {
    206			if (!active)
    207				active = vma;
    208
    209			list_move_tail(&vma->vm_link, &vm->bound_list);
    210			continue;
    211		}
    212
    213		if (mark_free(&scan, ww, vma, flags, &eviction_list))
    214			goto found;
    215	}
    216
    217	/* Nothing found, clean up and bail out! */
    218	list_for_each_entry_safe(vma, next, &eviction_list, evict_link) {
    219		ret = drm_mm_scan_remove_block(&scan, &vma->node);
    220		BUG_ON(ret);
    221		ungrab_vma(vma);
    222	}
    223
    224	/*
    225	 * Can we unpin some objects such as idle hw contents,
    226	 * or pending flips? But since only the GGTT has global entries
    227	 * such as scanouts, rinbuffers and contexts, we can skip the
    228	 * purge when inspecting per-process local address spaces.
    229	 */
    230	if (!i915_is_ggtt(vm) || flags & PIN_NONBLOCK)
    231		return -ENOSPC;
    232
    233	/*
    234	 * Not everything in the GGTT is tracked via VMA using
    235	 * i915_vma_move_to_active(), otherwise we could evict as required
    236	 * with minimal stalling. Instead we are forced to idle the GPU and
    237	 * explicitly retire outstanding requests which will then remove
    238	 * the pinning for active objects such as contexts and ring,
    239	 * enabling us to evict them on the next iteration.
    240	 *
    241	 * To ensure that all user contexts are evictable, we perform
    242	 * a switch to the perma-pinned kernel context. This all also gives
    243	 * us a termination condition, when the last retired context is
    244	 * the kernel's there is no more we can evict.
    245	 */
    246	if (I915_SELFTEST_ONLY(igt_evict_ctl.fail_if_busy))
    247		return -EBUSY;
    248
    249	ret = ggtt_flush(vm->gt);
    250	if (ret)
    251		return ret;
    252
    253	cond_resched();
    254
    255	flags |= PIN_NONBLOCK;
    256	goto search_again;
    257
    258found:
    259	/* drm_mm doesn't allow any other other operations while
    260	 * scanning, therefore store to-be-evicted objects on a
    261	 * temporary list and take a reference for all before
    262	 * calling unbind (which may remove the active reference
    263	 * of any of our objects, thus corrupting the list).
    264	 */
    265	list_for_each_entry_safe(vma, next, &eviction_list, evict_link) {
    266		if (drm_mm_scan_remove_block(&scan, &vma->node)) {
    267			__i915_vma_pin(vma);
    268		} else {
    269			list_del(&vma->evict_link);
    270			ungrab_vma(vma);
    271		}
    272	}
    273
    274	/* Unbinding will emit any required flushes */
    275	ret = 0;
    276	list_for_each_entry_safe(vma, next, &eviction_list, evict_link) {
    277		__i915_vma_unpin(vma);
    278		if (ret == 0)
    279			ret = __i915_vma_unbind(vma);
    280		ungrab_vma(vma);
    281	}
    282
    283	while (ret == 0 && (node = drm_mm_scan_color_evict(&scan))) {
    284		vma = container_of(node, struct i915_vma, node);
    285
    286		/* If we find any non-objects (!vma), we cannot evict them */
    287		if (vma->node.color != I915_COLOR_UNEVICTABLE &&
    288		    grab_vma(vma, ww)) {
    289			ret = __i915_vma_unbind(vma);
    290			ungrab_vma(vma);
    291		} else {
    292			ret = -ENOSPC;
    293		}
    294	}
    295
    296	return ret;
    297}
    298
    299/**
    300 * i915_gem_evict_for_node - Evict vmas to make room for binding a new one
    301 * @vm: address space to evict from
    302 * @ww: An optional struct i915_gem_ww_ctx.
    303 * @target: range (and color) to evict for
    304 * @flags: additional flags to control the eviction algorithm
    305 *
    306 * This function will try to evict vmas that overlap the target node.
    307 *
    308 * To clarify: This is for freeing up virtual address space, not for freeing
    309 * memory in e.g. the shrinker.
    310 */
    311int i915_gem_evict_for_node(struct i915_address_space *vm,
    312			    struct i915_gem_ww_ctx *ww,
    313			    struct drm_mm_node *target,
    314			    unsigned int flags)
    315{
    316	LIST_HEAD(eviction_list);
    317	struct drm_mm_node *node;
    318	u64 start = target->start;
    319	u64 end = start + target->size;
    320	struct i915_vma *vma, *next;
    321	int ret = 0;
    322
    323	lockdep_assert_held(&vm->mutex);
    324	GEM_BUG_ON(!IS_ALIGNED(start, I915_GTT_PAGE_SIZE));
    325	GEM_BUG_ON(!IS_ALIGNED(end, I915_GTT_PAGE_SIZE));
    326
    327	trace_i915_gem_evict_node(vm, target, flags);
    328
    329	/*
    330	 * Retire before we search the active list. Although we have
    331	 * reasonable accuracy in our retirement lists, we may have
    332	 * a stray pin (preventing eviction) that can only be resolved by
    333	 * retiring.
    334	 */
    335	intel_gt_retire_requests(vm->gt);
    336
    337	if (i915_vm_has_cache_coloring(vm)) {
    338		/* Expand search to cover neighbouring guard pages (or lack!) */
    339		if (start)
    340			start -= I915_GTT_PAGE_SIZE;
    341
    342		/* Always look at the page afterwards to avoid the end-of-GTT */
    343		end += I915_GTT_PAGE_SIZE;
    344	}
    345	GEM_BUG_ON(start >= end);
    346
    347	drm_mm_for_each_node_in_range(node, &vm->mm, start, end) {
    348		/* If we find any non-objects (!vma), we cannot evict them */
    349		if (node->color == I915_COLOR_UNEVICTABLE) {
    350			ret = -ENOSPC;
    351			break;
    352		}
    353
    354		GEM_BUG_ON(!drm_mm_node_allocated(node));
    355		vma = container_of(node, typeof(*vma), node);
    356
    357		/*
    358		 * If we are using coloring to insert guard pages between
    359		 * different cache domains within the address space, we have
    360		 * to check whether the objects on either side of our range
    361		 * abutt and conflict. If they are in conflict, then we evict
    362		 * those as well to make room for our guard pages.
    363		 */
    364		if (i915_vm_has_cache_coloring(vm)) {
    365			if (node->start + node->size == target->start) {
    366				if (node->color == target->color)
    367					continue;
    368			}
    369			if (node->start == target->start + target->size) {
    370				if (node->color == target->color)
    371					continue;
    372			}
    373		}
    374
    375		if (i915_vma_is_pinned(vma)) {
    376			ret = -ENOSPC;
    377			break;
    378		}
    379
    380		if (flags & PIN_NONBLOCK && i915_vma_is_active(vma)) {
    381			ret = -ENOSPC;
    382			break;
    383		}
    384
    385		if (!grab_vma(vma, ww)) {
    386			ret = -ENOSPC;
    387			break;
    388		}
    389
    390		/*
    391		 * Never show fear in the face of dragons!
    392		 *
    393		 * We cannot directly remove this node from within this
    394		 * iterator and as with i915_gem_evict_something() we employ
    395		 * the vma pin_count in order to prevent the action of
    396		 * unbinding one vma from freeing (by dropping its active
    397		 * reference) another in our eviction list.
    398		 */
    399		__i915_vma_pin(vma);
    400		list_add(&vma->evict_link, &eviction_list);
    401	}
    402
    403	list_for_each_entry_safe(vma, next, &eviction_list, evict_link) {
    404		__i915_vma_unpin(vma);
    405		if (ret == 0)
    406			ret = __i915_vma_unbind(vma);
    407
    408		ungrab_vma(vma);
    409	}
    410
    411	return ret;
    412}
    413
    414/**
    415 * i915_gem_evict_vm - Evict all idle vmas from a vm
    416 * @vm: Address space to cleanse
    417 * @ww: An optional struct i915_gem_ww_ctx. If not NULL, i915_gem_evict_vm
    418 * will be able to evict vma's locked by the ww as well.
    419 *
    420 * This function evicts all vmas from a vm.
    421 *
    422 * This is used by the execbuf code as a last-ditch effort to defragment the
    423 * address space.
    424 *
    425 * To clarify: This is for freeing up virtual address space, not for freeing
    426 * memory in e.g. the shrinker.
    427 */
    428int i915_gem_evict_vm(struct i915_address_space *vm, struct i915_gem_ww_ctx *ww)
    429{
    430	int ret = 0;
    431
    432	lockdep_assert_held(&vm->mutex);
    433	trace_i915_gem_evict_vm(vm);
    434
    435	/* Switch back to the default context in order to unpin
    436	 * the existing context objects. However, such objects only
    437	 * pin themselves inside the global GTT and performing the
    438	 * switch otherwise is ineffective.
    439	 */
    440	if (i915_is_ggtt(vm)) {
    441		ret = ggtt_flush(vm->gt);
    442		if (ret)
    443			return ret;
    444	}
    445
    446	do {
    447		struct i915_vma *vma, *vn;
    448		LIST_HEAD(eviction_list);
    449		LIST_HEAD(locked_eviction_list);
    450
    451		list_for_each_entry(vma, &vm->bound_list, vm_link) {
    452			if (i915_vma_is_pinned(vma))
    453				continue;
    454
    455			/*
    456			 * If we already own the lock, trylock fails. In case
    457			 * the resv is shared among multiple objects, we still
    458			 * need the object ref.
    459			 */
    460			if (dying_vma(vma) ||
    461			    (ww && (dma_resv_locking_ctx(vma->obj->base.resv) == &ww->ctx))) {
    462				__i915_vma_pin(vma);
    463				list_add(&vma->evict_link, &locked_eviction_list);
    464				continue;
    465			}
    466
    467			if (!i915_gem_object_trylock(vma->obj, ww))
    468				continue;
    469
    470			__i915_vma_pin(vma);
    471			list_add(&vma->evict_link, &eviction_list);
    472		}
    473		if (list_empty(&eviction_list) && list_empty(&locked_eviction_list))
    474			break;
    475
    476		ret = 0;
    477		/* Unbind locked objects first, before unlocking the eviction_list */
    478		list_for_each_entry_safe(vma, vn, &locked_eviction_list, evict_link) {
    479			__i915_vma_unpin(vma);
    480
    481			if (ret == 0)
    482				ret = __i915_vma_unbind(vma);
    483			if (ret != -EINTR) /* "Get me out of here!" */
    484				ret = 0;
    485		}
    486
    487		list_for_each_entry_safe(vma, vn, &eviction_list, evict_link) {
    488			__i915_vma_unpin(vma);
    489			if (ret == 0)
    490				ret = __i915_vma_unbind(vma);
    491			if (ret != -EINTR) /* "Get me out of here!" */
    492				ret = 0;
    493
    494			i915_gem_object_unlock(vma->obj);
    495		}
    496	} while (ret == 0);
    497
    498	return ret;
    499}
    500
    501#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
    502#include "selftests/i915_gem_evict.c"
    503#endif