drivers/gpu/drm/drm_managed.c

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