1/* SPDX-License-Identifier: GPL-2.0 */
  2/* Copyright (C) 2019 Arm Ltd.
  3 *
  4 * Based on msm_gem_freedreno.c:
  5 * Copyright (C) 2016 Red Hat
  6 * Author: Rob Clark <robdclark@gmail.com>
  7 */
  8
  9#include <linux/list.h>
 10
 11#include <drm/drm_device.h>
 12#include <drm/drm_gem_shmem_helper.h>
 13
 14#include "panfrost_device.h"
 15#include "panfrost_gem.h"
 16#include "panfrost_mmu.h"
 17
 18static unsigned long
 19panfrost_gem_shrinker_count(struct shrinker *shrinker, struct shrink_control *sc)
 20{
 21	struct panfrost_device *pfdev =
 22		container_of(shrinker, struct panfrost_device, shrinker);
 23	struct drm_gem_shmem_object *shmem;
 24	unsigned long count = 0;
 25
 26	if (!mutex_trylock(&pfdev->shrinker_lock))
 27		return 0;
 28
 29	list_for_each_entry(shmem, &pfdev->shrinker_list, madv_list) {
 30		if (drm_gem_shmem_is_purgeable(shmem))
 31			count += shmem->base.size >> PAGE_SHIFT;
 32	}
 33
 34	mutex_unlock(&pfdev->shrinker_lock);
 35
 36	return count;
 37}
 38
 39static bool panfrost_gem_purge(struct drm_gem_object *obj)
 40{
 41	struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 
 
 42
 43	if (!mutex_trylock(&shmem->pages_lock))
 44		return false;
 45
 46	panfrost_mmu_unmap(to_panfrost_bo(obj));
 47	drm_gem_shmem_purge_locked(obj);
 
 
 
 48
 49	mutex_unlock(&shmem->pages_lock);
 50	return true;
 
 
 
 
 
 
 
 51}
 52
 53static unsigned long
 54panfrost_gem_shrinker_scan(struct shrinker *shrinker, struct shrink_control *sc)
 55{
 56	struct panfrost_device *pfdev =
 57		container_of(shrinker, struct panfrost_device, shrinker);
 58	struct drm_gem_shmem_object *shmem, *tmp;
 59	unsigned long freed = 0;
 60
 61	if (!mutex_trylock(&pfdev->shrinker_lock))
 62		return SHRINK_STOP;
 63
 64	list_for_each_entry_safe(shmem, tmp, &pfdev->shrinker_list, madv_list) {
 65		if (freed >= sc->nr_to_scan)
 66			break;
 67		if (drm_gem_shmem_is_purgeable(shmem) &&
 68		    panfrost_gem_purge(&shmem->base)) {
 69			freed += shmem->base.size >> PAGE_SHIFT;
 70			list_del_init(&shmem->madv_list);
 71		}
 72	}
 73
 74	mutex_unlock(&pfdev->shrinker_lock);
 75
 76	if (freed > 0)
 77		pr_info_ratelimited("Purging %lu bytes\n", freed << PAGE_SHIFT);
 78
 79	return freed;
 80}
 81
 82/**
 83 * panfrost_gem_shrinker_init - Initialize panfrost shrinker
 84 * @dev: DRM device
 85 *
 86 * This function registers and sets up the panfrost shrinker.
 87 */
 88void panfrost_gem_shrinker_init(struct drm_device *dev)
 89{
 90	struct panfrost_device *pfdev = dev->dev_private;
 91	pfdev->shrinker.count_objects = panfrost_gem_shrinker_count;
 92	pfdev->shrinker.scan_objects = panfrost_gem_shrinker_scan;
 93	pfdev->shrinker.seeks = DEFAULT_SEEKS;
 94	WARN_ON(register_shrinker(&pfdev->shrinker));
 
 
 
 
 
 
 
 
 95}
 96
 97/**
 98 * panfrost_gem_shrinker_cleanup - Clean up panfrost shrinker
 99 * @dev: DRM device
100 *
101 * This function unregisters the panfrost shrinker.
102 */
103void panfrost_gem_shrinker_cleanup(struct drm_device *dev)
104{
105	struct panfrost_device *pfdev = dev->dev_private;
106
107	if (pfdev->shrinker.nr_deferred) {
108		unregister_shrinker(&pfdev->shrinker);
109	}
110}

  1// SPDX-License-Identifier: GPL-2.0
  2/* Copyright (C) 2019 Arm Ltd.
  3 *
  4 * Based on msm_gem_freedreno.c:
  5 * Copyright (C) 2016 Red Hat
  6 * Author: Rob Clark <robdclark@gmail.com>
  7 */
  8
  9#include <linux/list.h>
 10
 11#include <drm/drm_device.h>
 12#include <drm/drm_gem_shmem_helper.h>
 13
 14#include "panfrost_device.h"
 15#include "panfrost_gem.h"
 16#include "panfrost_mmu.h"
 17
 18static unsigned long
 19panfrost_gem_shrinker_count(struct shrinker *shrinker, struct shrink_control *sc)
 20{
 21	struct panfrost_device *pfdev = shrinker->private_data;
 
 22	struct drm_gem_shmem_object *shmem;
 23	unsigned long count = 0;
 24
 25	if (!mutex_trylock(&pfdev->shrinker_lock))
 26		return 0;
 27
 28	list_for_each_entry(shmem, &pfdev->shrinker_list, madv_list) {
 29		if (drm_gem_shmem_is_purgeable(shmem))
 30			count += shmem->base.size >> PAGE_SHIFT;
 31	}
 32
 33	mutex_unlock(&pfdev->shrinker_lock);
 34
 35	return count;
 36}
 37
 38static bool panfrost_gem_purge(struct drm_gem_object *obj)
 39{
 40	struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(obj);
 41	struct panfrost_gem_object *bo = to_panfrost_bo(obj);
 42	bool ret = false;
 43
 44	if (atomic_read(&bo->gpu_usecount))
 45		return false;
 46
 47	if (!mutex_trylock(&bo->mappings.lock))
 48		return false;
 49
 50	if (!dma_resv_trylock(shmem->base.resv))
 51		goto unlock_mappings;
 52
 53	panfrost_gem_teardown_mappings_locked(bo);
 54	drm_gem_shmem_purge(&bo->base);
 55	ret = true;
 56
 57	dma_resv_unlock(shmem->base.resv);
 58
 59unlock_mappings:
 60	mutex_unlock(&bo->mappings.lock);
 61	return ret;
 62}
 63
 64static unsigned long
 65panfrost_gem_shrinker_scan(struct shrinker *shrinker, struct shrink_control *sc)
 66{
 67	struct panfrost_device *pfdev = shrinker->private_data;
 
 68	struct drm_gem_shmem_object *shmem, *tmp;
 69	unsigned long freed = 0;
 70
 71	if (!mutex_trylock(&pfdev->shrinker_lock))
 72		return SHRINK_STOP;
 73
 74	list_for_each_entry_safe(shmem, tmp, &pfdev->shrinker_list, madv_list) {
 75		if (freed >= sc->nr_to_scan)
 76			break;
 77		if (drm_gem_shmem_is_purgeable(shmem) &&
 78		    panfrost_gem_purge(&shmem->base)) {
 79			freed += shmem->base.size >> PAGE_SHIFT;
 80			list_del_init(&shmem->madv_list);
 81		}
 82	}
 83
 84	mutex_unlock(&pfdev->shrinker_lock);
 85
 86	if (freed > 0)
 87		pr_info_ratelimited("Purging %lu bytes\n", freed << PAGE_SHIFT);
 88
 89	return freed;
 90}
 91
 92/**
 93 * panfrost_gem_shrinker_init - Initialize panfrost shrinker
 94 * @dev: DRM device
 95 *
 96 * This function registers and sets up the panfrost shrinker.
 97 */
 98int panfrost_gem_shrinker_init(struct drm_device *dev)
 99{
100	struct panfrost_device *pfdev = dev->dev_private;
101
102	pfdev->shrinker = shrinker_alloc(0, "drm-panfrost");
103	if (!pfdev->shrinker)
104		return -ENOMEM;
105
106	pfdev->shrinker->count_objects = panfrost_gem_shrinker_count;
107	pfdev->shrinker->scan_objects = panfrost_gem_shrinker_scan;
108	pfdev->shrinker->private_data = pfdev;
109
110	shrinker_register(pfdev->shrinker);
111
112	return 0;
113}
114
115/**
116 * panfrost_gem_shrinker_cleanup - Clean up panfrost shrinker
117 * @dev: DRM device
118 *
119 * This function unregisters the panfrost shrinker.
120 */
121void panfrost_gem_shrinker_cleanup(struct drm_device *dev)
122{
123	struct panfrost_device *pfdev = dev->dev_private;
124
125	if (pfdev->shrinker)
126		shrinker_free(pfdev->shrinker);
 
127}