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 57 static void free_dr(struct drmres *dr) 58 { 59 kfree_const(dr->node.name); 60 kfree(dr); 61 } 62 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 */ 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 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 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 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 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 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 */ 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 */ 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 */ 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