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

drm_managed.c (7473B)


      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 * Copyright (C) 2020 Intel
      4 *
      5 * Based on drivers/base/devres.c
      6 */
      7
      8#include <drm/drm_managed.h>
      9
     10#include <linux/list.h>
     11#include <linux/mutex.h>
     12#include <linux/slab.h>
     13#include <linux/spinlock.h>
     14
     15#include <drm/drm_device.h>
     16#include <drm/drm_print.h>
     17
     18#include "drm_internal.h"
     19
     20/**
     21 * DOC: managed resources
     22 *
     23 * Inspired by struct &device managed resources, but tied to the lifetime of
     24 * struct &drm_device, which can outlive the underlying physical device, usually
     25 * when userspace has some open files and other handles to resources still open.
     26 *
     27 * Release actions can be added with drmm_add_action(), memory allocations can
     28 * be done directly with drmm_kmalloc() and the related functions. Everything
     29 * will be released on the final drm_dev_put() in reverse order of how the
     30 * release actions have been added and memory has been allocated since driver
     31 * loading started with devm_drm_dev_alloc().
     32 *
     33 * Note that release actions and managed memory can also be added and removed
     34 * during the lifetime of the driver, all the functions are fully concurrent
     35 * safe. But it is recommended to use managed resources only for resources that
     36 * change rarely, if ever, during the lifetime of the &drm_device instance.
     37 */
     38
     39struct drmres_node {
     40	struct list_head	entry;
     41	drmres_release_t	release;
     42	const char		*name;
     43	size_t			size;
     44};
     45
     46struct drmres {
     47	struct drmres_node		node;
     48	/*
     49	 * Some archs want to perform DMA into kmalloc caches
     50	 * and need a guaranteed alignment larger than
     51	 * the alignment of a 64-bit integer.
     52	 * Thus we use ARCH_KMALLOC_MINALIGN here and get exactly the same
     53	 * buffer alignment as if it was allocated by plain kmalloc().
     54	 */
     55	u8 __aligned(ARCH_KMALLOC_MINALIGN) data[];
     56};
     57
     58static void free_dr(struct drmres *dr)
     59{
     60	kfree_const(dr->node.name);
     61	kfree(dr);
     62}
     63
     64void drm_managed_release(struct drm_device *dev)
     65{
     66	struct drmres *dr, *tmp;
     67
     68	drm_dbg_drmres(dev, "drmres release begin\n");
     69	list_for_each_entry_safe(dr, tmp, &dev->managed.resources, node.entry) {
     70		drm_dbg_drmres(dev, "REL %p %s (%zu bytes)\n",
     71			       dr, dr->node.name, dr->node.size);
     72
     73		if (dr->node.release)
     74			dr->node.release(dev, dr->node.size ? *(void **)&dr->data : NULL);
     75
     76		list_del(&dr->node.entry);
     77		free_dr(dr);
     78	}
     79	drm_dbg_drmres(dev, "drmres release end\n");
     80}
     81
     82/*
     83 * Always inline so that kmalloc_track_caller tracks the actual interesting
     84 * caller outside of drm_managed.c.
     85 */
     86static __always_inline struct drmres * alloc_dr(drmres_release_t release,
     87						size_t size, gfp_t gfp, int nid)
     88{
     89	size_t tot_size;
     90	struct drmres *dr;
     91
     92	/* We must catch any near-SIZE_MAX cases that could overflow. */
     93	if (unlikely(check_add_overflow(sizeof(*dr), size, &tot_size)))
     94		return NULL;
     95
     96	dr = kmalloc_node_track_caller(tot_size, gfp, nid);
     97	if (unlikely(!dr))
     98		return NULL;
     99
    100	memset(dr, 0, offsetof(struct drmres, data));
    101
    102	INIT_LIST_HEAD(&dr->node.entry);
    103	dr->node.release = release;
    104	dr->node.size = size;
    105
    106	return dr;
    107}
    108
    109static void del_dr(struct drm_device *dev, struct drmres *dr)
    110{
    111	list_del_init(&dr->node.entry);
    112
    113	drm_dbg_drmres(dev, "DEL %p %s (%lu bytes)\n",
    114		       dr, dr->node.name, (unsigned long) dr->node.size);
    115}
    116
    117static void add_dr(struct drm_device *dev, struct drmres *dr)
    118{
    119	unsigned long flags;
    120
    121	spin_lock_irqsave(&dev->managed.lock, flags);
    122	list_add(&dr->node.entry, &dev->managed.resources);
    123	spin_unlock_irqrestore(&dev->managed.lock, flags);
    124
    125	drm_dbg_drmres(dev, "ADD %p %s (%lu bytes)\n",
    126		       dr, dr->node.name, (unsigned long) dr->node.size);
    127}
    128
    129void drmm_add_final_kfree(struct drm_device *dev, void *container)
    130{
    131	WARN_ON(dev->managed.final_kfree);
    132	WARN_ON(dev < (struct drm_device *) container);
    133	WARN_ON(dev + 1 > (struct drm_device *) (container + ksize(container)));
    134	dev->managed.final_kfree = container;
    135}
    136
    137int __drmm_add_action(struct drm_device *dev,
    138		      drmres_release_t action,
    139		      void *data, const char *name)
    140{
    141	struct drmres *dr;
    142	void **void_ptr;
    143
    144	dr = alloc_dr(action, data ? sizeof(void*) : 0,
    145		      GFP_KERNEL | __GFP_ZERO,
    146		      dev_to_node(dev->dev));
    147	if (!dr) {
    148		drm_dbg_drmres(dev, "failed to add action %s for %p\n",
    149			       name, data);
    150		return -ENOMEM;
    151	}
    152
    153	dr->node.name = kstrdup_const(name, GFP_KERNEL);
    154	if (data) {
    155		void_ptr = (void **)&dr->data;
    156		*void_ptr = data;
    157	}
    158
    159	add_dr(dev, dr);
    160
    161	return 0;
    162}
    163EXPORT_SYMBOL(__drmm_add_action);
    164
    165int __drmm_add_action_or_reset(struct drm_device *dev,
    166			       drmres_release_t action,
    167			       void *data, const char *name)
    168{
    169	int ret;
    170
    171	ret = __drmm_add_action(dev, action, data, name);
    172	if (ret)
    173		action(dev, data);
    174
    175	return ret;
    176}
    177EXPORT_SYMBOL(__drmm_add_action_or_reset);
    178
    179/**
    180 * drmm_kmalloc - &drm_device managed kmalloc()
    181 * @dev: DRM device
    182 * @size: size of the memory allocation
    183 * @gfp: GFP allocation flags
    184 *
    185 * This is a &drm_device managed version of kmalloc(). The allocated memory is
    186 * automatically freed on the final drm_dev_put(). Memory can also be freed
    187 * before the final drm_dev_put() by calling drmm_kfree().
    188 */
    189void *drmm_kmalloc(struct drm_device *dev, size_t size, gfp_t gfp)
    190{
    191	struct drmres *dr;
    192
    193	dr = alloc_dr(NULL, size, gfp, dev_to_node(dev->dev));
    194	if (!dr) {
    195		drm_dbg_drmres(dev, "failed to allocate %zu bytes, %u flags\n",
    196			       size, gfp);
    197		return NULL;
    198	}
    199	dr->node.name = kstrdup_const("kmalloc", GFP_KERNEL);
    200
    201	add_dr(dev, dr);
    202
    203	return dr->data;
    204}
    205EXPORT_SYMBOL(drmm_kmalloc);
    206
    207/**
    208 * drmm_kstrdup - &drm_device managed kstrdup()
    209 * @dev: DRM device
    210 * @s: 0-terminated string to be duplicated
    211 * @gfp: GFP allocation flags
    212 *
    213 * This is a &drm_device managed version of kstrdup(). The allocated memory is
    214 * automatically freed on the final drm_dev_put() and works exactly like a
    215 * memory allocation obtained by drmm_kmalloc().
    216 */
    217char *drmm_kstrdup(struct drm_device *dev, const char *s, gfp_t gfp)
    218{
    219	size_t size;
    220	char *buf;
    221
    222	if (!s)
    223		return NULL;
    224
    225	size = strlen(s) + 1;
    226	buf = drmm_kmalloc(dev, size, gfp);
    227	if (buf)
    228		memcpy(buf, s, size);
    229	return buf;
    230}
    231EXPORT_SYMBOL_GPL(drmm_kstrdup);
    232
    233/**
    234 * drmm_kfree - &drm_device managed kfree()
    235 * @dev: DRM device
    236 * @data: memory allocation to be freed
    237 *
    238 * This is a &drm_device managed version of kfree() which can be used to
    239 * release memory allocated through drmm_kmalloc() or any of its related
    240 * functions before the final drm_dev_put() of @dev.
    241 */
    242void drmm_kfree(struct drm_device *dev, void *data)
    243{
    244	struct drmres *dr_match = NULL, *dr;
    245	unsigned long flags;
    246
    247	if (!data)
    248		return;
    249
    250	spin_lock_irqsave(&dev->managed.lock, flags);
    251	list_for_each_entry(dr, &dev->managed.resources, node.entry) {
    252		if (dr->data == data) {
    253			dr_match = dr;
    254			del_dr(dev, dr_match);
    255			break;
    256		}
    257	}
    258	spin_unlock_irqrestore(&dev->managed.lock, flags);
    259
    260	if (WARN_ON(!dr_match))
    261		return;
    262
    263	free_dr(dr_match);
    264}
    265EXPORT_SYMBOL(drmm_kfree);
    266
    267static void drmm_mutex_release(struct drm_device *dev, void *res)
    268{
    269	struct mutex *lock = res;
    270
    271	mutex_destroy(lock);
    272}
    273
    274/**
    275 * drmm_mutex_init - &drm_device-managed mutex_init()
    276 * @dev: DRM device
    277 * @lock: lock to be initialized
    278 *
    279 * Returns:
    280 * 0 on success, or a negative errno code otherwise.
    281 *
    282 * This is a &drm_device-managed version of mutex_init(). The initialized
    283 * lock is automatically destroyed on the final drm_dev_put().
    284 */
    285int drmm_mutex_init(struct drm_device *dev, struct mutex *lock)
    286{
    287	mutex_init(lock);
    288
    289	return drmm_add_action_or_reset(dev, drmm_mutex_release, lock);
    290}
    291EXPORT_SYMBOL(drmm_mutex_init);