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 devm_drm_dev_alloc().
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 
38 struct drmres_node {
39 	struct list_head	entry;
40 	drmres_release_t	release;
41 	const char		*name;
42 	size_t			size;
43 };
44 
45 struct 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 
free_dr(struct drmres * dr)57 static void free_dr(struct drmres *dr)
58 {
59 	kfree_const(dr->node.name);
60 	kfree(dr);
61 }
62 
drm_managed_release(struct drm_device * dev)63 void 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  */
alloc_dr(drmres_release_t release,size_t size,gfp_t gfp,int nid)85 static __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 
del_dr(struct drm_device * dev,struct drmres * dr)108 static 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 
add_dr(struct drm_device * dev,struct drmres * dr)116 static 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 
drmm_add_final_kfree(struct drm_device * dev,void * container)128 void drmm_add_final_kfree(struct drm_device *dev, void *container)
129 {
130 	WARN_ON(dev->managed.final_kfree);
131 	WARN_ON(dev < (struct drm_device *) container);
132 	WARN_ON(dev + 1 > (struct drm_device *) (container + ksize(container)));
133 	dev->managed.final_kfree = container;
134 }
135 
__drmm_add_action(struct drm_device * dev,drmres_release_t action,void * data,const char * name)136 int __drmm_add_action(struct drm_device *dev,
137 		      drmres_release_t action,
138 		      void *data, const char *name)
139 {
140 	struct drmres *dr;
141 	void **void_ptr;
142 
143 	dr = alloc_dr(action, data ? sizeof(void*) : 0,
144 		      GFP_KERNEL | __GFP_ZERO,
145 		      dev_to_node(dev->dev));
146 	if (!dr) {
147 		drm_dbg_drmres(dev, "failed to add action %s for %p\n",
148 			       name, data);
149 		return -ENOMEM;
150 	}
151 
152 	dr->node.name = kstrdup_const(name, GFP_KERNEL);
153 	if (data) {
154 		void_ptr = (void **)&dr->data;
155 		*void_ptr = data;
156 	}
157 
158 	add_dr(dev, dr);
159 
160 	return 0;
161 }
162 EXPORT_SYMBOL(__drmm_add_action);
163 
__drmm_add_action_or_reset(struct drm_device * dev,drmres_release_t action,void * data,const char * name)164 int __drmm_add_action_or_reset(struct drm_device *dev,
165 			       drmres_release_t action,
166 			       void *data, const char *name)
167 {
168 	int ret;
169 
170 	ret = __drmm_add_action(dev, action, data, name);
171 	if (ret)
172 		action(dev, data);
173 
174 	return ret;
175 }
176 EXPORT_SYMBOL(__drmm_add_action_or_reset);
177 
178 /**
179  * drmm_kmalloc - &drm_device managed kmalloc()
180  * @dev: DRM device
181  * @size: size of the memory allocation
182  * @gfp: GFP allocation flags
183  *
184  * This is a &drm_device managed version of kmalloc(). The allocated memory is
185  * automatically freed on the final drm_dev_put(). Memory can also be freed
186  * before the final drm_dev_put() by calling drmm_kfree().
187  */
drmm_kmalloc(struct drm_device * dev,size_t size,gfp_t gfp)188 void *drmm_kmalloc(struct drm_device *dev, size_t size, gfp_t gfp)
189 {
190 	struct drmres *dr;
191 
192 	dr = alloc_dr(NULL, size, gfp, dev_to_node(dev->dev));
193 	if (!dr) {
194 		drm_dbg_drmres(dev, "failed to allocate %zu bytes, %u flags\n",
195 			       size, gfp);
196 		return NULL;
197 	}
198 	dr->node.name = kstrdup_const("kmalloc", GFP_KERNEL);
199 
200 	add_dr(dev, dr);
201 
202 	return dr->data;
203 }
204 EXPORT_SYMBOL(drmm_kmalloc);
205 
206 /**
207  * drmm_kstrdup - &drm_device managed kstrdup()
208  * @dev: DRM device
209  * @s: 0-terminated string to be duplicated
210  * @gfp: GFP allocation flags
211  *
212  * This is a &drm_device managed version of kstrdup(). The allocated memory is
213  * automatically freed on the final drm_dev_put() and works exactly like a
214  * memory allocation obtained by drmm_kmalloc().
215  */
drmm_kstrdup(struct drm_device * dev,const char * s,gfp_t gfp)216 char *drmm_kstrdup(struct drm_device *dev, const char *s, gfp_t gfp)
217 {
218 	size_t size;
219 	char *buf;
220 
221 	if (!s)
222 		return NULL;
223 
224 	size = strlen(s) + 1;
225 	buf = drmm_kmalloc(dev, size, gfp);
226 	if (buf)
227 		memcpy(buf, s, size);
228 	return buf;
229 }
230 EXPORT_SYMBOL_GPL(drmm_kstrdup);
231 
232 /**
233  * drmm_kfree - &drm_device managed kfree()
234  * @dev: DRM device
235  * @data: memory allocation to be freed
236  *
237  * This is a &drm_device managed version of kfree() which can be used to
238  * release memory allocated through drmm_kmalloc() or any of its related
239  * functions before the final drm_dev_put() of @dev.
240  */
drmm_kfree(struct drm_device * dev,void * data)241 void drmm_kfree(struct drm_device *dev, void *data)
242 {
243 	struct drmres *dr_match = NULL, *dr;
244 	unsigned long flags;
245 
246 	if (!data)
247 		return;
248 
249 	spin_lock_irqsave(&dev->managed.lock, flags);
250 	list_for_each_entry(dr, &dev->managed.resources, node.entry) {
251 		if (dr->data == data) {
252 			dr_match = dr;
253 			del_dr(dev, dr_match);
254 			break;
255 		}
256 	}
257 	spin_unlock_irqrestore(&dev->managed.lock, flags);
258 
259 	if (WARN_ON(!dr_match))
260 		return;
261 
262 	free_dr(dr_match);
263 }
264 EXPORT_SYMBOL(drmm_kfree);
265