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