Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Created: Tue Feb 2 08:37:54 1999 by faith@valinux.com |
| 3 | * |
| 4 | * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. |
| 5 | * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. |
| 6 | * All Rights Reserved. |
| 7 | * |
David Herrmann | 32e7b94 | 2015-05-04 21:01:30 +0200 | [diff] [blame] | 8 | * Author Rickard E. (Rik) Faith <faith@valinux.com> |
| 9 | * Author Gareth Hughes <gareth@valinux.com> |
| 10 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 12 | * copy of this software and associated documentation files (the "Software"), |
| 13 | * to deal in the Software without restriction, including without limitation |
| 14 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 15 | * and/or sell copies of the Software, and to permit persons to whom the |
| 16 | * Software is furnished to do so, subject to the following conditions: |
| 17 | * |
| 18 | * The above copyright notice and this permission notice (including the next |
| 19 | * paragraph) shall be included in all copies or substantial portions of the |
| 20 | * Software. |
| 21 | * |
| 22 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 23 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 24 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 25 | * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| 26 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| 27 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| 28 | * OTHER DEALINGS IN THE SOFTWARE. |
| 29 | */ |
| 30 | |
David Howells | 760285e | 2012-10-02 18:01:07 +0100 | [diff] [blame] | 31 | #include <drm/drmP.h> |
Daniel Vetter | 67d0ec4 | 2014-09-10 12:43:53 +0200 | [diff] [blame] | 32 | #include "drm_internal.h" |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 33 | #include "drm_legacy.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | |
| 35 | /** |
Daniel Vetter | 3b96a0b | 2016-06-21 10:54:22 +0200 | [diff] [blame] | 36 | * DOC: master and authentication |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | * |
Daniel Vetter | 3b96a0b | 2016-06-21 10:54:22 +0200 | [diff] [blame] | 38 | * struct &drm_master is used to track groups of clients with open |
| 39 | * primary/legacy device nodes. For every struct &drm_file which has had at |
| 40 | * least once successfully became the device master (either through the |
| 41 | * SET_MASTER IOCTL, or implicitly through opening the primary device node when |
| 42 | * no one else is the current master that time) there exists one &drm_master. |
| 43 | * This is noted in the is_master member of &drm_file. All other clients have |
| 44 | * just a pointer to the &drm_master they are associated with. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | * |
Daniel Vetter | 3b96a0b | 2016-06-21 10:54:22 +0200 | [diff] [blame] | 46 | * In addition only one &drm_master can be the current master for a &drm_device. |
| 47 | * It can be switched through the DROP_MASTER and SET_MASTER IOCTL, or |
| 48 | * implicitly through closing/openeing the primary device node. See also |
| 49 | * drm_is_current_master(). |
| 50 | * |
| 51 | * Clients can authenticate against the current master (if it matches their own) |
| 52 | * using the GETMAGIC and AUTHMAGIC IOCTLs. Together with exchanging masters, |
| 53 | * this allows controlled access to the device for an entire group of mutually |
| 54 | * trusted clients. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 55 | */ |
Daniel Vetter | 3b96a0b | 2016-06-21 10:54:22 +0200 | [diff] [blame] | 56 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 57 | int drm_getmagic(struct drm_device *dev, void *data, struct drm_file *file_priv) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | { |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 59 | struct drm_auth *auth = data; |
David Herrmann | 32e7b94 | 2015-05-04 21:01:30 +0200 | [diff] [blame] | 60 | int ret = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | |
Daniel Vetter | d2b34ee | 2016-06-17 09:33:21 +0200 | [diff] [blame] | 62 | mutex_lock(&dev->master_mutex); |
David Herrmann | 32e7b94 | 2015-05-04 21:01:30 +0200 | [diff] [blame] | 63 | if (!file_priv->magic) { |
| 64 | ret = idr_alloc(&file_priv->master->magic_map, file_priv, |
| 65 | 1, 0, GFP_KERNEL); |
| 66 | if (ret >= 0) |
| 67 | file_priv->magic = ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | } |
David Herrmann | 32e7b94 | 2015-05-04 21:01:30 +0200 | [diff] [blame] | 69 | auth->magic = file_priv->magic; |
Daniel Vetter | d2b34ee | 2016-06-17 09:33:21 +0200 | [diff] [blame] | 70 | mutex_unlock(&dev->master_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 72 | DRM_DEBUG("%u\n", auth->magic); |
| 73 | |
David Herrmann | 32e7b94 | 2015-05-04 21:01:30 +0200 | [diff] [blame] | 74 | return ret < 0 ? ret : 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 75 | } |
| 76 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 77 | int drm_authmagic(struct drm_device *dev, void *data, |
| 78 | struct drm_file *file_priv) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | { |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 80 | struct drm_auth *auth = data; |
Dave Airlie | 84b1fd1 | 2007-07-11 15:53:27 +1000 | [diff] [blame] | 81 | struct drm_file *file; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 82 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 83 | DRM_DEBUG("%u\n", auth->magic); |
David Herrmann | 32e7b94 | 2015-05-04 21:01:30 +0200 | [diff] [blame] | 84 | |
Daniel Vetter | d2b34ee | 2016-06-17 09:33:21 +0200 | [diff] [blame] | 85 | mutex_lock(&dev->master_mutex); |
David Herrmann | 32e7b94 | 2015-05-04 21:01:30 +0200 | [diff] [blame] | 86 | file = idr_find(&file_priv->master->magic_map, auth->magic); |
| 87 | if (file) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | file->authenticated = 1; |
David Herrmann | 32e7b94 | 2015-05-04 21:01:30 +0200 | [diff] [blame] | 89 | idr_replace(&file_priv->master->magic_map, NULL, auth->magic); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | } |
Daniel Vetter | d2b34ee | 2016-06-17 09:33:21 +0200 | [diff] [blame] | 91 | mutex_unlock(&dev->master_mutex); |
David Herrmann | 32e7b94 | 2015-05-04 21:01:30 +0200 | [diff] [blame] | 92 | |
| 93 | return file ? 0 : -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | } |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 95 | |
| 96 | static struct drm_master *drm_master_create(struct drm_device *dev) |
| 97 | { |
| 98 | struct drm_master *master; |
| 99 | |
| 100 | master = kzalloc(sizeof(*master), GFP_KERNEL); |
| 101 | if (!master) |
| 102 | return NULL; |
| 103 | |
| 104 | kref_init(&master->refcount); |
| 105 | spin_lock_init(&master->lock.spinlock); |
| 106 | init_waitqueue_head(&master->lock.lock_queue); |
| 107 | idr_init(&master->magic_map); |
| 108 | master->dev = dev; |
| 109 | |
| 110 | return master; |
| 111 | } |
| 112 | |
Daniel Vetter | d6ed682 | 2016-06-21 14:20:38 +0200 | [diff] [blame] | 113 | static int drm_set_master(struct drm_device *dev, struct drm_file *fpriv, |
| 114 | bool new_master) |
| 115 | { |
| 116 | int ret = 0; |
| 117 | |
| 118 | dev->master = drm_master_get(fpriv->master); |
Daniel Vetter | d6ed682 | 2016-06-21 14:20:38 +0200 | [diff] [blame] | 119 | if (dev->driver->master_set) { |
| 120 | ret = dev->driver->master_set(dev, fpriv, new_master); |
| 121 | if (unlikely(ret != 0)) { |
Daniel Vetter | d6ed682 | 2016-06-21 14:20:38 +0200 | [diff] [blame] | 122 | drm_master_put(&dev->master); |
| 123 | } |
| 124 | } |
| 125 | |
| 126 | return ret; |
| 127 | } |
| 128 | |
Daniel Vetter | 2cbae7e | 2016-06-14 20:51:00 +0200 | [diff] [blame] | 129 | static int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv) |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 130 | { |
| 131 | struct drm_master *old_master; |
| 132 | int ret; |
| 133 | |
| 134 | lockdep_assert_held_once(&dev->master_mutex); |
| 135 | |
Sergio Correia | de8268d | 2018-11-22 02:33:29 -0300 | [diff] [blame] | 136 | WARN_ON(fpriv->is_master); |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 137 | old_master = fpriv->master; |
Daniel Vetter | d6ed682 | 2016-06-21 14:20:38 +0200 | [diff] [blame] | 138 | fpriv->master = drm_master_create(dev); |
| 139 | if (!fpriv->master) { |
| 140 | fpriv->master = old_master; |
| 141 | return -ENOMEM; |
| 142 | } |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 143 | |
| 144 | if (dev->driver->master_create) { |
| 145 | ret = dev->driver->master_create(dev, fpriv->master); |
| 146 | if (ret) |
| 147 | goto out_err; |
| 148 | } |
Daniel Vetter | 0aae592 | 2016-06-21 10:54:21 +0200 | [diff] [blame] | 149 | fpriv->is_master = 1; |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 150 | fpriv->authenticated = 1; |
Daniel Vetter | d6ed682 | 2016-06-21 14:20:38 +0200 | [diff] [blame] | 151 | |
| 152 | ret = drm_set_master(dev, fpriv, true); |
| 153 | if (ret) |
| 154 | goto out_err; |
| 155 | |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 156 | if (old_master) |
| 157 | drm_master_put(&old_master); |
| 158 | |
| 159 | return 0; |
| 160 | |
| 161 | out_err: |
Daniel Vetter | d6ed682 | 2016-06-21 14:20:38 +0200 | [diff] [blame] | 162 | /* drop references and restore old master on failure */ |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 163 | drm_master_put(&fpriv->master); |
| 164 | fpriv->master = old_master; |
Sergio Correia | de8268d | 2018-11-22 02:33:29 -0300 | [diff] [blame] | 165 | fpriv->is_master = 0; |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 166 | |
| 167 | return ret; |
| 168 | } |
| 169 | |
| 170 | int drm_setmaster_ioctl(struct drm_device *dev, void *data, |
| 171 | struct drm_file *file_priv) |
| 172 | { |
| 173 | int ret = 0; |
| 174 | |
| 175 | mutex_lock(&dev->master_mutex); |
Daniel Vetter | b3ac9f2 | 2016-06-21 10:54:20 +0200 | [diff] [blame] | 176 | if (drm_is_current_master(file_priv)) |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 177 | goto out_unlock; |
| 178 | |
Daniel Vetter | 95c081c | 2016-06-21 10:54:12 +0200 | [diff] [blame] | 179 | if (dev->master) { |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 180 | ret = -EINVAL; |
| 181 | goto out_unlock; |
| 182 | } |
| 183 | |
| 184 | if (!file_priv->master) { |
| 185 | ret = -EINVAL; |
| 186 | goto out_unlock; |
| 187 | } |
| 188 | |
Daniel Vetter | 0aae592 | 2016-06-21 10:54:21 +0200 | [diff] [blame] | 189 | if (!file_priv->is_master) { |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 190 | ret = drm_new_set_master(dev, file_priv); |
| 191 | goto out_unlock; |
| 192 | } |
| 193 | |
Daniel Vetter | d6ed682 | 2016-06-21 14:20:38 +0200 | [diff] [blame] | 194 | ret = drm_set_master(dev, file_priv, false); |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 195 | out_unlock: |
| 196 | mutex_unlock(&dev->master_mutex); |
| 197 | return ret; |
| 198 | } |
| 199 | |
Daniel Vetter | d6ed682 | 2016-06-21 14:20:38 +0200 | [diff] [blame] | 200 | static void drm_drop_master(struct drm_device *dev, |
| 201 | struct drm_file *fpriv) |
| 202 | { |
| 203 | if (dev->driver->master_drop) |
| 204 | dev->driver->master_drop(dev, fpriv); |
| 205 | drm_master_put(&dev->master); |
Daniel Vetter | d6ed682 | 2016-06-21 14:20:38 +0200 | [diff] [blame] | 206 | } |
| 207 | |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 208 | int drm_dropmaster_ioctl(struct drm_device *dev, void *data, |
| 209 | struct drm_file *file_priv) |
| 210 | { |
| 211 | int ret = -EINVAL; |
| 212 | |
| 213 | mutex_lock(&dev->master_mutex); |
Daniel Vetter | b3ac9f2 | 2016-06-21 10:54:20 +0200 | [diff] [blame] | 214 | if (!drm_is_current_master(file_priv)) |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 215 | goto out_unlock; |
| 216 | |
Daniel Vetter | 95c081c | 2016-06-21 10:54:12 +0200 | [diff] [blame] | 217 | if (!dev->master) |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 218 | goto out_unlock; |
| 219 | |
| 220 | ret = 0; |
Daniel Vetter | d6ed682 | 2016-06-21 14:20:38 +0200 | [diff] [blame] | 221 | drm_drop_master(dev, file_priv); |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 222 | out_unlock: |
| 223 | mutex_unlock(&dev->master_mutex); |
| 224 | return ret; |
| 225 | } |
| 226 | |
Daniel Vetter | 2cbae7e | 2016-06-14 20:51:00 +0200 | [diff] [blame] | 227 | int drm_master_open(struct drm_file *file_priv) |
| 228 | { |
| 229 | struct drm_device *dev = file_priv->minor->dev; |
| 230 | int ret = 0; |
| 231 | |
| 232 | /* if there is no current master make this fd it, but do not create |
| 233 | * any master object for render clients */ |
| 234 | mutex_lock(&dev->master_mutex); |
Daniel Vetter | 95c081c | 2016-06-21 10:54:12 +0200 | [diff] [blame] | 235 | if (!dev->master) |
Daniel Vetter | 2cbae7e | 2016-06-14 20:51:00 +0200 | [diff] [blame] | 236 | ret = drm_new_set_master(dev, file_priv); |
| 237 | else |
Daniel Vetter | 95c081c | 2016-06-21 10:54:12 +0200 | [diff] [blame] | 238 | file_priv->master = drm_master_get(dev->master); |
Daniel Vetter | 2cbae7e | 2016-06-14 20:51:00 +0200 | [diff] [blame] | 239 | mutex_unlock(&dev->master_mutex); |
| 240 | |
| 241 | return ret; |
| 242 | } |
| 243 | |
Daniel Vetter | 14d71eb | 2016-06-14 20:51:01 +0200 | [diff] [blame] | 244 | void drm_master_release(struct drm_file *file_priv) |
| 245 | { |
| 246 | struct drm_device *dev = file_priv->minor->dev; |
Daniel Vetter | 0de4cc9 | 2016-06-17 09:33:19 +0200 | [diff] [blame] | 247 | struct drm_master *master = file_priv->master; |
Daniel Vetter | 14d71eb | 2016-06-14 20:51:01 +0200 | [diff] [blame] | 248 | |
Daniel Vetter | d2b34ee | 2016-06-17 09:33:21 +0200 | [diff] [blame] | 249 | mutex_lock(&dev->master_mutex); |
Daniel Vetter | a77316b | 2016-06-17 09:33:20 +0200 | [diff] [blame] | 250 | if (file_priv->magic) |
| 251 | idr_remove(&file_priv->master->magic_map, file_priv->magic); |
Daniel Vetter | a77316b | 2016-06-17 09:33:20 +0200 | [diff] [blame] | 252 | |
Daniel Vetter | b3ac9f2 | 2016-06-21 10:54:20 +0200 | [diff] [blame] | 253 | if (!drm_is_current_master(file_priv)) |
Daniel Vetter | 0de4cc9 | 2016-06-17 09:33:19 +0200 | [diff] [blame] | 254 | goto out; |
Daniel Vetter | 14d71eb | 2016-06-14 20:51:01 +0200 | [diff] [blame] | 255 | |
Daniel Vetter | fa53864 | 2016-08-03 21:11:10 +0200 | [diff] [blame] | 256 | if (drm_core_check_feature(dev, DRIVER_LEGACY)) { |
Daniel Vetter | 14d71eb | 2016-06-14 20:51:01 +0200 | [diff] [blame] | 257 | /* |
| 258 | * Since the master is disappearing, so is the |
| 259 | * possibility to lock. |
| 260 | */ |
| 261 | mutex_lock(&dev->struct_mutex); |
| 262 | if (master->lock.hw_lock) { |
| 263 | if (dev->sigdata.lock == master->lock.hw_lock) |
| 264 | dev->sigdata.lock = NULL; |
| 265 | master->lock.hw_lock = NULL; |
| 266 | master->lock.file_priv = NULL; |
| 267 | wake_up_interruptible_all(&master->lock.lock_queue); |
| 268 | } |
| 269 | mutex_unlock(&dev->struct_mutex); |
Daniel Vetter | 14d71eb | 2016-06-14 20:51:01 +0200 | [diff] [blame] | 270 | } |
| 271 | |
Daniel Vetter | d6ed682 | 2016-06-21 14:20:38 +0200 | [diff] [blame] | 272 | if (dev->master == file_priv->master) |
| 273 | drm_drop_master(dev, file_priv); |
Daniel Vetter | 0de4cc9 | 2016-06-17 09:33:19 +0200 | [diff] [blame] | 274 | out: |
Daniel Vetter | 14d71eb | 2016-06-14 20:51:01 +0200 | [diff] [blame] | 275 | /* drop the master reference held by the file priv */ |
| 276 | if (file_priv->master) |
| 277 | drm_master_put(&file_priv->master); |
Daniel Vetter | 14d71eb | 2016-06-14 20:51:01 +0200 | [diff] [blame] | 278 | mutex_unlock(&dev->master_mutex); |
| 279 | } |
| 280 | |
Daniel Vetter | 3b96a0b | 2016-06-21 10:54:22 +0200 | [diff] [blame] | 281 | /** |
| 282 | * drm_is_current_master - checks whether @priv is the current master |
| 283 | * @fpriv: DRM file private |
| 284 | * |
| 285 | * Checks whether @fpriv is current master on its device. This decides whether a |
| 286 | * client is allowed to run DRM_MASTER IOCTLs. |
| 287 | * |
| 288 | * Most of the modern IOCTL which require DRM_MASTER are for kernel modesetting |
| 289 | * - the current master is assumed to own the non-shareable display hardware. |
| 290 | */ |
Daniel Vetter | b3ac9f2 | 2016-06-21 10:54:20 +0200 | [diff] [blame] | 291 | bool drm_is_current_master(struct drm_file *fpriv) |
| 292 | { |
Daniel Vetter | 0aae592 | 2016-06-21 10:54:21 +0200 | [diff] [blame] | 293 | return fpriv->is_master && fpriv->master == fpriv->minor->dev->master; |
Daniel Vetter | b3ac9f2 | 2016-06-21 10:54:20 +0200 | [diff] [blame] | 294 | } |
| 295 | EXPORT_SYMBOL(drm_is_current_master); |
| 296 | |
Daniel Vetter | 3b96a0b | 2016-06-21 10:54:22 +0200 | [diff] [blame] | 297 | /** |
| 298 | * drm_master_get - reference a master pointer |
| 299 | * @master: struct &drm_master |
| 300 | * |
| 301 | * Increments the reference count of @master and returns a pointer to @master. |
| 302 | */ |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 303 | struct drm_master *drm_master_get(struct drm_master *master) |
| 304 | { |
| 305 | kref_get(&master->refcount); |
| 306 | return master; |
| 307 | } |
| 308 | EXPORT_SYMBOL(drm_master_get); |
| 309 | |
| 310 | static void drm_master_destroy(struct kref *kref) |
| 311 | { |
| 312 | struct drm_master *master = container_of(kref, struct drm_master, refcount); |
| 313 | struct drm_device *dev = master->dev; |
| 314 | |
| 315 | if (dev->driver->master_destroy) |
| 316 | dev->driver->master_destroy(dev, master); |
| 317 | |
| 318 | drm_legacy_master_rmmaps(dev, master); |
| 319 | |
| 320 | idr_destroy(&master->magic_map); |
| 321 | kfree(master->unique); |
| 322 | kfree(master); |
| 323 | } |
| 324 | |
Daniel Vetter | 3b96a0b | 2016-06-21 10:54:22 +0200 | [diff] [blame] | 325 | /** |
| 326 | * drm_master_put - unreference and clear a master pointer |
| 327 | * @master: pointer to a pointer of struct &drm_master |
| 328 | * |
| 329 | * This decrements the &drm_master behind @master and sets it to NULL. |
| 330 | */ |
Daniel Vetter | 6548f4e | 2016-06-14 20:50:59 +0200 | [diff] [blame] | 331 | void drm_master_put(struct drm_master **master) |
| 332 | { |
| 333 | kref_put(&(*master)->refcount, drm_master_destroy); |
| 334 | *master = NULL; |
| 335 | } |
| 336 | EXPORT_SYMBOL(drm_master_put); |