313 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Copyright (C) 2020 Intel4 *5 * Based on drivers/base/devres.c6 */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 resources22 *23 * Inspired by struct &device managed resources, but tied to the lifetime of24 * struct &drm_device, which can outlive the underlying physical device, usually25 * 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 can28 * be done directly with drmm_kmalloc() and the related functions. Everything29 * will be released on the final drm_dev_put() in reverse order of how the30 * release actions have been added and memory has been allocated since driver31 * loading started with devm_drm_dev_alloc().32 *33 * Note that release actions and managed memory can also be added and removed34 * during the lifetime of the driver, all the functions are fully concurrent35 * safe. But it is recommended to use managed resources only for resources that36 * 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 caches50 * and need a guaranteed alignment larger than51 * the alignment of a 64-bit integer.52 * Thus we use ARCH_DMA_MINALIGN for data[] which will force the same53 * alignment for struct drmres when allocated by kmalloc().54 */55 u8 __aligned(ARCH_DMA_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 interesting84 * 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_release_action - release a managed action from a &drm_device181 * @dev: DRM device182 * @action: function which would be called when @dev is released183 * @data: opaque pointer, passed to @action184 *185 * This function calls the @action previously added by drmm_add_action()186 * immediately.187 * The @action is removed from the list of cleanup actions for @dev,188 * which means that it won't be called in the final drm_dev_put().189 */190void drmm_release_action(struct drm_device *dev,191 drmres_release_t action,192 void *data)193{194 struct drmres *dr_match = NULL, *dr;195 unsigned long flags;196 197 spin_lock_irqsave(&dev->managed.lock, flags);198 list_for_each_entry_reverse(dr, &dev->managed.resources, node.entry) {199 if (dr->node.release == action) {200 if (!data || *(void **)dr->data == data) {201 dr_match = dr;202 del_dr(dev, dr_match);203 break;204 }205 }206 }207 spin_unlock_irqrestore(&dev->managed.lock, flags);208 209 if (WARN_ON(!dr_match))210 return;211 212 action(dev, data);213 214 free_dr(dr_match);215}216EXPORT_SYMBOL(drmm_release_action);217 218/**219 * drmm_kmalloc - &drm_device managed kmalloc()220 * @dev: DRM device221 * @size: size of the memory allocation222 * @gfp: GFP allocation flags223 *224 * This is a &drm_device managed version of kmalloc(). The allocated memory is225 * automatically freed on the final drm_dev_put(). Memory can also be freed226 * before the final drm_dev_put() by calling drmm_kfree().227 */228void *drmm_kmalloc(struct drm_device *dev, size_t size, gfp_t gfp)229{230 struct drmres *dr;231 232 dr = alloc_dr(NULL, size, gfp, dev_to_node(dev->dev));233 if (!dr) {234 drm_dbg_drmres(dev, "failed to allocate %zu bytes, %u flags\n",235 size, gfp);236 return NULL;237 }238 dr->node.name = kstrdup_const("kmalloc", gfp);239 240 add_dr(dev, dr);241 242 return dr->data;243}244EXPORT_SYMBOL(drmm_kmalloc);245 246/**247 * drmm_kstrdup - &drm_device managed kstrdup()248 * @dev: DRM device249 * @s: 0-terminated string to be duplicated250 * @gfp: GFP allocation flags251 *252 * This is a &drm_device managed version of kstrdup(). The allocated memory is253 * automatically freed on the final drm_dev_put() and works exactly like a254 * memory allocation obtained by drmm_kmalloc().255 */256char *drmm_kstrdup(struct drm_device *dev, const char *s, gfp_t gfp)257{258 size_t size;259 char *buf;260 261 if (!s)262 return NULL;263 264 size = strlen(s) + 1;265 buf = drmm_kmalloc(dev, size, gfp);266 if (buf)267 memcpy(buf, s, size);268 return buf;269}270EXPORT_SYMBOL_GPL(drmm_kstrdup);271 272/**273 * drmm_kfree - &drm_device managed kfree()274 * @dev: DRM device275 * @data: memory allocation to be freed276 *277 * This is a &drm_device managed version of kfree() which can be used to278 * release memory allocated through drmm_kmalloc() or any of its related279 * functions before the final drm_dev_put() of @dev.280 */281void drmm_kfree(struct drm_device *dev, void *data)282{283 struct drmres *dr_match = NULL, *dr;284 unsigned long flags;285 286 if (!data)287 return;288 289 spin_lock_irqsave(&dev->managed.lock, flags);290 list_for_each_entry(dr, &dev->managed.resources, node.entry) {291 if (dr->data == data) {292 dr_match = dr;293 del_dr(dev, dr_match);294 break;295 }296 }297 spin_unlock_irqrestore(&dev->managed.lock, flags);298 299 if (WARN_ON(!dr_match))300 return;301 302 free_dr(dr_match);303}304EXPORT_SYMBOL(drmm_kfree);305 306void __drmm_mutex_release(struct drm_device *dev, void *res)307{308 struct mutex *lock = res;309 310 mutex_destroy(lock);311}312EXPORT_SYMBOL(__drmm_mutex_release);313