1// SPDX-License-Identifier: MIT
2/*
3 * Copyright © 2008-2015 Intel Corporation
4 */
5
6#include <linux/oom.h>
7#include <linux/sched/mm.h>
8#include <linux/shmem_fs.h>
9#include <linux/slab.h>
10#include <linux/swap.h>
11#include <linux/pci.h>
12#include <linux/dma-buf.h>
13#include <linux/vmalloc.h>
14
15#include <drm/drm_print.h>
16
17#include "gt/intel_gt_requests.h"
18#include "gt/intel_gt.h"
19
20#include "i915_trace.h"
21
22static bool swap_available(void)
23{
24 return get_nr_swap_pages() > 0;
25}
26
27static bool can_release_pages(struct drm_i915_gem_object *obj)
28{
29 /* Consider only shrinkable objects. */
30 if (!i915_gem_object_is_shrinkable(obj))
31 return false;
32
33 /*
34 * We can only return physical pages to the system if we can either
35 * discard the contents (because the user has marked them as being
36 * purgeable) or if we can move their contents out to swap.
37 */
38 return swap_available() || obj->mm.madv == I915_MADV_DONTNEED;
39}
40
41static bool drop_pages(struct drm_i915_gem_object *obj,
42 unsigned long shrink, bool trylock_vm)
43{
44 unsigned long flags;
45
46 flags = 0;
47 if (shrink & I915_SHRINK_ACTIVE)
48 flags |= I915_GEM_OBJECT_UNBIND_ACTIVE;
49 if (!(shrink & I915_SHRINK_BOUND))
50 flags |= I915_GEM_OBJECT_UNBIND_TEST;
51 if (trylock_vm)
52 flags |= I915_GEM_OBJECT_UNBIND_VM_TRYLOCK;
53
54 if (i915_gem_object_unbind(obj, flags) == 0)
55 return true;
56
57 return false;
58}
59
60static int try_to_writeback(struct drm_i915_gem_object *obj, unsigned int flags)
61{
62 if (obj->ops->shrink) {
63 unsigned int shrink_flags = 0;
64
65 if (!(flags & I915_SHRINK_ACTIVE))
66 shrink_flags |= I915_GEM_OBJECT_SHRINK_NO_GPU_WAIT;
67
68 if (flags & I915_SHRINK_WRITEBACK)
69 shrink_flags |= I915_GEM_OBJECT_SHRINK_WRITEBACK;
70
71 return obj->ops->shrink(obj, shrink_flags);
72 }
73
74 return 0;
75}
76
77/**
78 * i915_gem_shrink - Shrink buffer object caches
79 * @ww: i915 gem ww acquire ctx, or NULL
80 * @i915: i915 device
81 * @target: amount of memory to make available, in pages
82 * @nr_scanned: optional output for number of pages scanned (incremental)
83 * @shrink: control flags for selecting cache types
84 *
85 * This function is the main interface to the shrinker. It will try to release
86 * up to @target pages of main memory backing storage from buffer objects.
87 * Selection of the specific caches can be done with @flags. This is e.g. useful
88 * when purgeable objects should be removed from caches preferentially.
89 *
90 * Note that it's not guaranteed that released amount is actually available as
91 * free system memory - the pages might still be in-used to due to other reasons
92 * (like cpu mmaps) or the mm core has reused them before we could grab them.
93 * Therefore code that needs to explicitly shrink buffer objects caches (e.g. to
94 * avoid deadlocks in memory reclaim) must fall back to i915_gem_shrink_all().
95 *
96 * Also note that any kind of pinning (both per-vma address space pins and
97 * backing storage pins at the buffer object level) result in the shrinker code
98 * having to skip the object.
99 *
100 * Returns:
101 * The number of pages of backing storage actually released.
102 */
103unsigned long
104i915_gem_shrink(struct i915_gem_ww_ctx *ww,
105 struct drm_i915_private *i915,
106 unsigned long target,
107 unsigned long *nr_scanned,
108 unsigned int shrink)
109{
110 const struct {
111 struct list_head *list;
112 unsigned int bit;
113 } phases[] = {
114 { &i915->mm.purge_list, ~0u },
115 {
116 &i915->mm.shrink_list,
117 I915_SHRINK_BOUND | I915_SHRINK_UNBOUND
118 },
119 { NULL, 0 },
120 }, *phase;
121 intel_wakeref_t wakeref = NULL;
122 unsigned long count = 0;
123 unsigned long scanned = 0;
124 int err = 0, i = 0;
125 struct intel_gt *gt;
126
127 /* CHV + VTD workaround use stop_machine(); need to trylock vm->mutex */
128 bool trylock_vm = !ww && intel_vm_no_concurrent_access_wa(i915);
129
130 trace_i915_gem_shrink(i915, target, flags: shrink);
131
132 /*
133 * Unbinding of objects will require HW access; Let us not wake the
134 * device just to recover a little memory. If absolutely necessary,
135 * we will force the wake during oom-notifier.
136 */
137 if (shrink & I915_SHRINK_BOUND) {
138 wakeref = intel_runtime_pm_get_if_in_use(rpm: &i915->runtime_pm);
139 if (!wakeref)
140 shrink &= ~I915_SHRINK_BOUND;
141 }
142
143 /*
144 * When shrinking the active list, we should also consider active
145 * contexts. Active contexts are pinned until they are retired, and
146 * so can not be simply unbound to retire and unpin their pages. To
147 * shrink the contexts, we must wait until the gpu is idle and
148 * completed its switch to the kernel context. In short, we do
149 * not have a good mechanism for idling a specific context, but
150 * what we can do is give them a kick so that we do not keep idle
151 * contexts around longer than is necessary.
152 */
153 if (shrink & I915_SHRINK_ACTIVE) {
154 for_each_gt(gt, i915, i)
155 /* Retire requests to unpin all idle contexts */
156 intel_gt_retire_requests(gt);
157 }
158
159 /*
160 * As we may completely rewrite the (un)bound list whilst unbinding
161 * (due to retiring requests) we have to strictly process only
162 * one element of the list at the time, and recheck the list
163 * on every iteration.
164 *
165 * In particular, we must hold a reference whilst removing the
166 * object as we may end up waiting for and/or retiring the objects.
167 * This might release the final reference (held by the active list)
168 * and result in the object being freed from under us. This is
169 * similar to the precautions the eviction code must take whilst
170 * removing objects.
171 *
172 * Also note that although these lists do not hold a reference to
173 * the object we can safely grab one here: The final object
174 * unreferencing and the bound_list are both protected by the
175 * i915->mm.obj_lock and so we won't ever be able to observe an
176 * object on the bound_list with a reference count equals 0.
177 */
178 for (phase = phases; phase->list; phase++) {
179 struct list_head still_in_list;
180 struct drm_i915_gem_object *obj;
181 unsigned long flags;
182
183 if ((shrink & phase->bit) == 0)
184 continue;
185
186 INIT_LIST_HEAD(list: &still_in_list);
187
188 /*
189 * We serialize our access to unreferenced objects through
190 * the use of the obj_lock. While the objects are not
191 * yet freed (due to RCU then a workqueue) we still want
192 * to be able to shrink their pages, so they remain on
193 * the unbound/bound list until actually freed.
194 */
195 spin_lock_irqsave(&i915->mm.obj_lock, flags);
196 while (count < target &&
197 (obj = list_first_entry_or_null(phase->list,
198 typeof(*obj),
199 mm.link))) {
200 list_move_tail(list: &obj->mm.link, head: &still_in_list);
201
202 if (shrink & I915_SHRINK_VMAPS &&
203 !is_vmalloc_addr(x: obj->mm.mapping))
204 continue;
205
206 if (!(shrink & I915_SHRINK_ACTIVE) &&
207 i915_gem_object_is_framebuffer(obj))
208 continue;
209
210 if (!can_release_pages(obj))
211 continue;
212
213 if (!kref_get_unless_zero(kref: &obj->base.refcount))
214 continue;
215
216 spin_unlock_irqrestore(lock: &i915->mm.obj_lock, flags);
217
218 /* May arrive from get_pages on another bo */
219 if (!ww) {
220 if (!i915_gem_object_trylock(obj, NULL))
221 goto skip;
222 } else {
223 err = i915_gem_object_lock(obj, ww);
224 if (err)
225 goto skip;
226 }
227
228 if (drop_pages(obj, shrink, trylock_vm) &&
229 !__i915_gem_object_put_pages(obj) &&
230 !try_to_writeback(obj, flags: shrink))
231 count += obj->base.size >> PAGE_SHIFT;
232
233 if (!ww)
234 i915_gem_object_unlock(obj);
235
236 scanned += obj->base.size >> PAGE_SHIFT;
237skip:
238 i915_gem_object_put(obj);
239
240 spin_lock_irqsave(&i915->mm.obj_lock, flags);
241 if (err)
242 break;
243 }
244 list_splice_tail(list: &still_in_list, head: phase->list);
245 spin_unlock_irqrestore(lock: &i915->mm.obj_lock, flags);
246 if (err)
247 break;
248 }
249
250 if (shrink & I915_SHRINK_BOUND)
251 intel_runtime_pm_put(rpm: &i915->runtime_pm, wref: wakeref);
252
253 if (err)
254 return err;
255
256 if (nr_scanned)
257 *nr_scanned += scanned;
258 return count;
259}
260
261/**
262 * i915_gem_shrink_all - Shrink buffer object caches completely
263 * @i915: i915 device
264 *
265 * This is a simple wrapper around i915_gem_shrink() to aggressively shrink all
266 * caches completely. It also first waits for and retires all outstanding
267 * requests to also be able to release backing storage for active objects.
268 *
269 * This should only be used in code to intentionally quiescent the gpu or as a
270 * last-ditch effort when memory seems to have run out.
271 *
272 * Returns:
273 * The number of pages of backing storage actually released.
274 */
275unsigned long i915_gem_shrink_all(struct drm_i915_private *i915)
276{
277 intel_wakeref_t wakeref;
278 unsigned long freed = 0;
279
280 with_intel_runtime_pm(&i915->runtime_pm, wakeref) {
281 freed = i915_gem_shrink(NULL, i915, target: -1UL, NULL,
282 I915_SHRINK_BOUND |
283 I915_SHRINK_UNBOUND);
284 }
285
286 return freed;
287}
288
289static unsigned long
290i915_gem_shrinker_count(struct shrinker *shrinker, struct shrink_control *sc)
291{
292 struct drm_i915_private *i915 = shrinker->private_data;
293 unsigned long num_objects;
294 unsigned long count;
295
296 count = READ_ONCE(i915->mm.shrink_memory) >> PAGE_SHIFT;
297 num_objects = READ_ONCE(i915->mm.shrink_count);
298
299 /*
300 * Update our preferred vmscan batch size for the next pass.
301 * Our rough guess for an effective batch size is roughly 2
302 * available GEM objects worth of pages. That is we don't want
303 * the shrinker to fire, until it is worth the cost of freeing an
304 * entire GEM object.
305 */
306 if (num_objects) {
307 unsigned long avg = 2 * count / num_objects;
308
309 i915->mm.shrinker->batch =
310 max((i915->mm.shrinker->batch + avg) >> 1,
311 128ul /* default SHRINK_BATCH */);
312 }
313
314 return count;
315}
316
317static unsigned long
318i915_gem_shrinker_scan(struct shrinker *shrinker, struct shrink_control *sc)
319{
320 struct drm_i915_private *i915 = shrinker->private_data;
321 unsigned long freed;
322
323 sc->nr_scanned = 0;
324
325 freed = i915_gem_shrink(NULL, i915,
326 target: sc->nr_to_scan,
327 nr_scanned: &sc->nr_scanned,
328 I915_SHRINK_BOUND |
329 I915_SHRINK_UNBOUND);
330 if (sc->nr_scanned < sc->nr_to_scan && current_is_kswapd()) {
331 intel_wakeref_t wakeref;
332
333 with_intel_runtime_pm(&i915->runtime_pm, wakeref) {
334 freed += i915_gem_shrink(NULL, i915,
335 target: sc->nr_to_scan - sc->nr_scanned,
336 nr_scanned: &sc->nr_scanned,
337 I915_SHRINK_ACTIVE |
338 I915_SHRINK_BOUND |
339 I915_SHRINK_UNBOUND |
340 I915_SHRINK_WRITEBACK);
341 }
342 }
343
344 return sc->nr_scanned ? freed : SHRINK_STOP;
345}
346
347static int
348i915_gem_shrinker_oom(struct notifier_block *nb, unsigned long event, void *ptr)
349{
350 struct drm_i915_private *i915 =
351 container_of(nb, struct drm_i915_private, mm.oom_notifier);
352 struct drm_i915_gem_object *obj;
353 unsigned long unevictable, available, freed_pages;
354 intel_wakeref_t wakeref;
355 unsigned long flags;
356
357 freed_pages = 0;
358 with_intel_runtime_pm(&i915->runtime_pm, wakeref)
359 freed_pages += i915_gem_shrink(NULL, i915, target: -1UL, NULL,
360 I915_SHRINK_BOUND |
361 I915_SHRINK_UNBOUND |
362 I915_SHRINK_WRITEBACK);
363
364 /* Because we may be allocating inside our own driver, we cannot
365 * assert that there are no objects with pinned pages that are not
366 * being pointed to by hardware.
367 */
368 available = unevictable = 0;
369 spin_lock_irqsave(&i915->mm.obj_lock, flags);
370 list_for_each_entry(obj, &i915->mm.shrink_list, mm.link) {
371 if (!can_release_pages(obj))
372 unevictable += obj->base.size >> PAGE_SHIFT;
373 else
374 available += obj->base.size >> PAGE_SHIFT;
375 }
376 spin_unlock_irqrestore(lock: &i915->mm.obj_lock, flags);
377
378 if (freed_pages || available)
379 pr_info("Purging GPU memory, %lu pages freed, "
380 "%lu pages still pinned, %lu pages left available.\n",
381 freed_pages, unevictable, available);
382
383 *(unsigned long *)ptr += freed_pages;
384 return NOTIFY_DONE;
385}
386
387static int
388i915_gem_shrinker_vmap(struct notifier_block *nb, unsigned long event, void *ptr)
389{
390 struct drm_i915_private *i915 =
391 container_of(nb, struct drm_i915_private, mm.vmap_notifier);
392 struct i915_vma *vma, *next;
393 unsigned long freed_pages = 0;
394 intel_wakeref_t wakeref;
395 struct intel_gt *gt;
396 int i;
397
398 with_intel_runtime_pm(&i915->runtime_pm, wakeref)
399 freed_pages += i915_gem_shrink(NULL, i915, target: -1UL, NULL,
400 I915_SHRINK_BOUND |
401 I915_SHRINK_UNBOUND |
402 I915_SHRINK_VMAPS);
403
404 /* We also want to clear any cached iomaps as they wrap vmap */
405 for_each_gt(gt, i915, i) {
406 mutex_lock(&gt->ggtt->vm.mutex);
407 list_for_each_entry_safe(vma, next,
408 &gt->ggtt->vm.bound_list, vm_link) {
409 unsigned long count = i915_vma_size(vma) >> PAGE_SHIFT;
410 struct drm_i915_gem_object *obj = vma->obj;
411
412 if (!vma->iomap || i915_vma_is_active(vma))
413 continue;
414
415 if (!i915_gem_object_trylock(obj, NULL))
416 continue;
417
418 if (__i915_vma_unbind(vma) == 0)
419 freed_pages += count;
420
421 i915_gem_object_unlock(obj);
422 }
423 mutex_unlock(lock: &gt->ggtt->vm.mutex);
424 }
425
426 *(unsigned long *)ptr += freed_pages;
427 return NOTIFY_DONE;
428}
429
430void i915_gem_driver_register__shrinker(struct drm_i915_private *i915)
431{
432 i915->mm.shrinker = shrinker_alloc(flags: 0, fmt: "drm-i915_gem");
433 if (!i915->mm.shrinker) {
434 drm_WARN_ON(&i915->drm, 1);
435 } else {
436 i915->mm.shrinker->scan_objects = i915_gem_shrinker_scan;
437 i915->mm.shrinker->count_objects = i915_gem_shrinker_count;
438 i915->mm.shrinker->batch = 4096;
439 i915->mm.shrinker->private_data = i915;
440
441 shrinker_register(shrinker: i915->mm.shrinker);
442 }
443
444 i915->mm.oom_notifier.notifier_call = i915_gem_shrinker_oom;
445 drm_WARN_ON(&i915->drm, register_oom_notifier(&i915->mm.oom_notifier));
446
447 i915->mm.vmap_notifier.notifier_call = i915_gem_shrinker_vmap;
448 drm_WARN_ON(&i915->drm,
449 register_vmap_purge_notifier(&i915->mm.vmap_notifier));
450}
451
452void i915_gem_driver_unregister__shrinker(struct drm_i915_private *i915)
453{
454 drm_WARN_ON(&i915->drm,
455 unregister_vmap_purge_notifier(&i915->mm.vmap_notifier));
456 drm_WARN_ON(&i915->drm,
457 unregister_oom_notifier(&i915->mm.oom_notifier));
458 shrinker_free(shrinker: i915->mm.shrinker);
459}
460
461void i915_gem_shrinker_taints_mutex(struct drm_i915_private *i915,
462 struct mutex *mutex)
463{
464 if (!IS_ENABLED(CONFIG_LOCKDEP))
465 return;
466
467 fs_reclaim_acquire(GFP_KERNEL);
468
469 mutex_acquire(&mutex->dep_map, 0, 0, _RET_IP_);
470 mutex_release(&mutex->dep_map, _RET_IP_);
471
472 fs_reclaim_release(GFP_KERNEL);
473}
474
475/**
476 * i915_gem_object_make_unshrinkable - Hide the object from the shrinker. By
477 * default all object types that support shrinking(see IS_SHRINKABLE), will also
478 * make the object visible to the shrinker after allocating the system memory
479 * pages.
480 * @obj: The GEM object.
481 *
482 * This is typically used for special kernel internal objects that can't be
483 * easily processed by the shrinker, like if they are perma-pinned.
484 */
485void i915_gem_object_make_unshrinkable(struct drm_i915_gem_object *obj)
486{
487 struct drm_i915_private *i915 = obj_to_i915(obj);
488 unsigned long flags;
489
490 /*
491 * We can only be called while the pages are pinned or when
492 * the pages are released. If pinned, we should only be called
493 * from a single caller under controlled conditions; and on release
494 * only one caller may release us. Neither the two may cross.
495 */
496 if (atomic_add_unless(v: &obj->mm.shrink_pin, a: 1, u: 0))
497 return;
498
499 spin_lock_irqsave(&i915->mm.obj_lock, flags);
500 if (!atomic_fetch_inc(v: &obj->mm.shrink_pin) &&
501 !list_empty(head: &obj->mm.link)) {
502 list_del_init(entry: &obj->mm.link);
503 i915->mm.shrink_count--;
504 i915->mm.shrink_memory -= obj->base.size;
505 }
506 spin_unlock_irqrestore(lock: &i915->mm.obj_lock, flags);
507}
508
509static void ___i915_gem_object_make_shrinkable(struct drm_i915_gem_object *obj,
510 struct list_head *head)
511{
512 struct drm_i915_private *i915 = obj_to_i915(obj);
513 unsigned long flags;
514
515 if (!i915_gem_object_is_shrinkable(obj))
516 return;
517
518 if (atomic_add_unless(v: &obj->mm.shrink_pin, a: -1, u: 1))
519 return;
520
521 spin_lock_irqsave(&i915->mm.obj_lock, flags);
522 GEM_BUG_ON(!kref_read(&obj->base.refcount));
523 if (atomic_dec_and_test(v: &obj->mm.shrink_pin)) {
524 GEM_BUG_ON(!list_empty(&obj->mm.link));
525
526 list_add_tail(new: &obj->mm.link, head);
527 i915->mm.shrink_count++;
528 i915->mm.shrink_memory += obj->base.size;
529
530 }
531 spin_unlock_irqrestore(lock: &i915->mm.obj_lock, flags);
532}
533
534/**
535 * __i915_gem_object_make_shrinkable - Move the object to the tail of the
536 * shrinkable list. Objects on this list might be swapped out. Used with
537 * WILLNEED objects.
538 * @obj: The GEM object.
539 *
540 * DO NOT USE. This is intended to be called on very special objects that don't
541 * yet have mm.pages, but are guaranteed to have potentially reclaimable pages
542 * underneath.
543 */
544void __i915_gem_object_make_shrinkable(struct drm_i915_gem_object *obj)
545{
546 ___i915_gem_object_make_shrinkable(obj,
547 head: &obj_to_i915(obj)->mm.shrink_list);
548}
549
550/**
551 * __i915_gem_object_make_purgeable - Move the object to the tail of the
552 * purgeable list. Objects on this list might be swapped out. Used with
553 * DONTNEED objects.
554 * @obj: The GEM object.
555 *
556 * DO NOT USE. This is intended to be called on very special objects that don't
557 * yet have mm.pages, but are guaranteed to have potentially reclaimable pages
558 * underneath.
559 */
560void __i915_gem_object_make_purgeable(struct drm_i915_gem_object *obj)
561{
562 ___i915_gem_object_make_shrinkable(obj,
563 head: &obj_to_i915(obj)->mm.purge_list);
564}
565
566/**
567 * i915_gem_object_make_shrinkable - Move the object to the tail of the
568 * shrinkable list. Objects on this list might be swapped out. Used with
569 * WILLNEED objects.
570 * @obj: The GEM object.
571 *
572 * MUST only be called on objects which have backing pages.
573 *
574 * MUST be balanced with previous call to i915_gem_object_make_unshrinkable().
575 */
576void i915_gem_object_make_shrinkable(struct drm_i915_gem_object *obj)
577{
578 GEM_BUG_ON(!i915_gem_object_has_pages(obj));
579 __i915_gem_object_make_shrinkable(obj);
580}
581
582/**
583 * i915_gem_object_make_purgeable - Move the object to the tail of the purgeable
584 * list. Used with DONTNEED objects. Unlike with shrinkable objects, the
585 * shrinker will attempt to discard the backing pages, instead of trying to swap
586 * them out.
587 * @obj: The GEM object.
588 *
589 * MUST only be called on objects which have backing pages.
590 *
591 * MUST be balanced with previous call to i915_gem_object_make_unshrinkable().
592 */
593void i915_gem_object_make_purgeable(struct drm_i915_gem_object *obj)
594{
595 GEM_BUG_ON(!i915_gem_object_has_pages(obj));
596 __i915_gem_object_make_purgeable(obj);
597}
598

source code of linux/drivers/gpu/drm/i915/gem/i915_gem_shrinker.c