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 * 8 * Author Rickard E. (Rik) Faith <faith@valinux.com> 9 * Author Gareth Hughes <gareth@valinux.com> 10 * 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 31 #include <drm/drmP.h> 32 #include "drm_internal.h" 33 #include "drm_legacy.h" 34 35 /** 36 * DOC: master and authentication 37 * 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 &drm_file.is_master. All other clients have just a pointer 44 * to the &drm_master they are associated with. 45 * 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. 55 */ 56 57 int drm_getmagic(struct drm_device *dev, void *data, struct drm_file *file_priv) 58 { 59 struct drm_auth *auth = data; 60 int ret = 0; 61 62 mutex_lock(&dev->master_mutex); 63 if (!file_priv->magic) { 64 ret = idr_alloc(&dev->magic_map, file_priv, 65 1, 0, GFP_KERNEL); 66 if (ret >= 0) 67 file_priv->magic = ret; 68 } 69 auth->magic = file_priv->magic; 70 mutex_unlock(&dev->master_mutex); 71 72 DRM_DEBUG("%u\n", auth->magic); 73 74 return ret < 0 ? ret : 0; 75 } 76 77 int drm_authmagic(struct drm_device *dev, void *data, 78 struct drm_file *file_priv) 79 { 80 struct drm_auth *auth = data; 81 struct drm_file *file; 82 83 DRM_DEBUG("%u\n", auth->magic); 84 85 mutex_lock(&dev->master_mutex); 86 file = idr_find(&dev->magic_map, auth->magic); 87 if (file) { 88 file->authenticated = 1; 89 idr_replace(&dev->magic_map, NULL, auth->magic); 90 } 91 mutex_unlock(&dev->master_mutex); 92 93 return file ? 0 : -EINVAL; 94 } 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 lockinit(&master->lock.spinlock, "drmmls", 0, 0); 106 init_waitqueue_head(&master->lock.lock_queue); 107 idr_init(&master->magic_map); 108 master->dev = dev; 109 110 return master; 111 } 112 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); 119 if (dev->driver->master_set) { 120 ret = dev->driver->master_set(dev, fpriv, new_master); 121 if (unlikely(ret != 0)) { 122 drm_master_put(&dev->master); 123 } 124 } 125 126 return ret; 127 } 128 129 static int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv) 130 { 131 struct drm_master *old_master; 132 int ret; 133 134 #if 0 135 lockdep_assert_held_once(&dev->master_mutex); 136 #endif 137 138 old_master = fpriv->master; 139 fpriv->master = drm_master_create(dev); 140 if (!fpriv->master) { 141 fpriv->master = old_master; 142 return -ENOMEM; 143 } 144 145 if (dev->driver->master_create) { 146 ret = dev->driver->master_create(dev, fpriv->master); 147 if (ret) 148 goto out_err; 149 } 150 fpriv->is_master = 1; 151 fpriv->authenticated = 1; 152 153 ret = drm_set_master(dev, fpriv, true); 154 if (ret) 155 goto out_err; 156 157 if (old_master) 158 drm_master_put(&old_master); 159 160 return 0; 161 162 out_err: 163 /* drop references and restore old master on failure */ 164 drm_master_put(&fpriv->master); 165 fpriv->master = old_master; 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); 176 if (drm_is_current_master(file_priv)) 177 goto out_unlock; 178 179 if (dev->master) { 180 ret = -EINVAL; 181 goto out_unlock; 182 } 183 184 if (!file_priv->master) { 185 ret = -EINVAL; 186 goto out_unlock; 187 } 188 189 if (!file_priv->is_master) { 190 ret = drm_new_set_master(dev, file_priv); 191 goto out_unlock; 192 } 193 194 ret = drm_set_master(dev, file_priv, false); 195 out_unlock: 196 mutex_unlock(&dev->master_mutex); 197 return ret; 198 } 199 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); 206 } 207 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); 214 if (!drm_is_current_master(file_priv)) 215 goto out_unlock; 216 217 if (!dev->master) 218 goto out_unlock; 219 220 ret = 0; 221 drm_drop_master(dev, file_priv); 222 out_unlock: 223 mutex_unlock(&dev->master_mutex); 224 return ret; 225 } 226 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); 235 if (!dev->master) 236 ret = drm_new_set_master(dev, file_priv); 237 else 238 file_priv->master = drm_master_get(dev->master); 239 mutex_unlock(&dev->master_mutex); 240 241 return ret; 242 } 243 244 void drm_master_release(struct drm_file *file_priv) 245 { 246 struct drm_device *dev = file_priv->minor->dev; 247 struct drm_master *master = file_priv->master; 248 249 mutex_lock(&dev->master_mutex); 250 if (file_priv->magic) 251 idr_remove(&file_priv->master->magic_map, file_priv->magic); 252 253 if (!drm_is_current_master(file_priv)) 254 goto out; 255 256 if (drm_core_check_feature(dev, DRIVER_LEGACY)) { 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); 270 } 271 272 if (dev->master == file_priv->master) 273 drm_drop_master(dev, file_priv); 274 out: 275 /* drop the master reference held by the file priv */ 276 if (file_priv->master) 277 drm_master_put(&file_priv->master); 278 mutex_unlock(&dev->master_mutex); 279 } 280 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 */ 291 bool drm_is_current_master(struct drm_file *fpriv) 292 { 293 return fpriv->is_master; 294 } 295 EXPORT_SYMBOL(drm_is_current_master); 296 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 */ 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 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 */ 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); 337