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 #include <drm/drm_lease.h> 35 36 /** 37 * DOC: master and authentication 38 * 39 * &struct drm_master is used to track groups of clients with open 40 * primary/legacy device nodes. For every &struct drm_file which has had at 41 * least once successfully became the device master (either through the 42 * SET_MASTER IOCTL, or implicitly through opening the primary device node when 43 * no one else is the current master that time) there exists one &drm_master. 44 * This is noted in &drm_file.is_master. All other clients have just a pointer 45 * to the &drm_master they are associated with. 46 * 47 * In addition only one &drm_master can be the current master for a &drm_device. 48 * It can be switched through the DROP_MASTER and SET_MASTER IOCTL, or 49 * implicitly through closing/openeing the primary device node. See also 50 * drm_is_current_master(). 51 * 52 * Clients can authenticate against the current master (if it matches their own) 53 * using the GETMAGIC and AUTHMAGIC IOCTLs. Together with exchanging masters, 54 * this allows controlled access to the device for an entire group of mutually 55 * trusted clients. 56 */ 57 58 int drm_getmagic(struct drm_device *dev, void *data, struct drm_file *file_priv) 59 { 60 struct drm_auth *auth = data; 61 int ret = 0; 62 63 mutex_lock(&dev->master_mutex); 64 if (!file_priv->magic) { 65 ret = idr_alloc(&file_priv->master->magic_map, file_priv, 66 1, 0, GFP_KERNEL); 67 if (ret >= 0) 68 file_priv->magic = ret; 69 } 70 auth->magic = file_priv->magic; 71 mutex_unlock(&dev->master_mutex); 72 73 DRM_DEBUG("%u\n", auth->magic); 74 75 return ret < 0 ? ret : 0; 76 } 77 78 int drm_authmagic(struct drm_device *dev, void *data, 79 struct drm_file *file_priv) 80 { 81 struct drm_auth *auth = data; 82 struct drm_file *file; 83 84 DRM_DEBUG("%u\n", auth->magic); 85 86 mutex_lock(&dev->master_mutex); 87 file = idr_find(&file_priv->master->magic_map, auth->magic); 88 if (file) { 89 file->authenticated = 1; 90 idr_replace(&file_priv->master->magic_map, NULL, auth->magic); 91 } 92 mutex_unlock(&dev->master_mutex); 93 94 return file ? 0 : -EINVAL; 95 } 96 97 struct drm_master *drm_master_create(struct drm_device *dev) 98 { 99 struct drm_master *master; 100 101 master = kzalloc(sizeof(*master), GFP_KERNEL); 102 if (!master) 103 return NULL; 104 105 kref_init(&master->refcount); 106 lockinit(&master->lock.spinlock, "drmmls", 0, 0); 107 init_waitqueue_head(&master->lock.lock_queue); 108 idr_init(&master->magic_map); 109 master->dev = dev; 110 111 /* initialize the tree of output resource lessees */ 112 master->lessor = NULL; 113 master->lessee_id = 0; 114 INIT_LIST_HEAD(&master->lessees); 115 INIT_LIST_HEAD(&master->lessee_list); 116 idr_init(&master->leases); 117 idr_init(&master->lessee_idr); 118 119 return master; 120 } 121 122 static int drm_set_master(struct drm_device *dev, struct drm_file *fpriv, 123 bool new_master) 124 { 125 int ret = 0; 126 127 dev->master = drm_master_get(fpriv->master); 128 if (dev->driver->master_set) { 129 ret = dev->driver->master_set(dev, fpriv, new_master); 130 if (unlikely(ret != 0)) { 131 drm_master_put(&dev->master); 132 } 133 } 134 135 return ret; 136 } 137 138 static int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv) 139 { 140 struct drm_master *old_master; 141 int ret; 142 143 #if 0 144 lockdep_assert_held_once(&dev->master_mutex); 145 #endif 146 147 old_master = fpriv->master; 148 fpriv->master = drm_master_create(dev); 149 if (!fpriv->master) { 150 fpriv->master = old_master; 151 return -ENOMEM; 152 } 153 154 if (dev->driver->master_create) { 155 ret = dev->driver->master_create(dev, fpriv->master); 156 if (ret) 157 goto out_err; 158 } 159 fpriv->is_master = 1; 160 fpriv->authenticated = 1; 161 162 ret = drm_set_master(dev, fpriv, true); 163 if (ret) 164 goto out_err; 165 166 if (old_master) 167 drm_master_put(&old_master); 168 169 return 0; 170 171 out_err: 172 /* drop references and restore old master on failure */ 173 drm_master_put(&fpriv->master); 174 fpriv->master = old_master; 175 176 return ret; 177 } 178 179 int drm_setmaster_ioctl(struct drm_device *dev, void *data, 180 struct drm_file *file_priv) 181 { 182 int ret = 0; 183 184 kprintf("drm_setmaster_ioctl\n"); 185 186 mutex_lock(&dev->master_mutex); 187 if (drm_is_current_master(file_priv)) 188 goto out_unlock; 189 190 /* 191 * dev->master is currently automatically set on first-open, which 192 * might or might not be what linux does. To avoid a later 193 * drm_setmaster ioctl failure, ignore the fact. 194 * 195 * XXX fixme 196 */ 197 if (dev->master) { 198 kprintf("drm_setmaster_ioctl: already has one XXX ignored\n"); 199 //ret = -EINVAL; 200 //goto out_unlock; 201 } 202 203 if (!file_priv->master) { 204 kprintf("drm_setmaster_ioctl: file_priv->master already\n"); 205 ret = -EINVAL; 206 goto out_unlock; 207 } 208 209 if (!file_priv->is_master) { 210 kprintf("drm_setmaster_ioctl: is_not master, set master"); 211 ret = drm_new_set_master(dev, file_priv); 212 goto out_unlock; 213 } 214 215 if (file_priv->master->lessor != NULL) { 216 DRM_DEBUG_LEASE("Attempt to set lessee %d as master\n", file_priv->master->lessee_id); 217 ret = -EINVAL; 218 goto out_unlock; 219 } 220 221 ret = drm_set_master(dev, file_priv, false); 222 kprintf("drm_setmaster_ioctl: fall-through set master ret=%d\n", ret); 223 out_unlock: 224 mutex_unlock(&dev->master_mutex); 225 return ret; 226 } 227 228 static void drm_drop_master(struct drm_device *dev, 229 struct drm_file *fpriv) 230 { 231 if (dev->driver->master_drop) 232 dev->driver->master_drop(dev, fpriv); 233 drm_master_put(&dev->master); 234 } 235 236 int drm_dropmaster_ioctl(struct drm_device *dev, void *data, 237 struct drm_file *file_priv) 238 { 239 int ret = -EINVAL; 240 241 kprintf("drm_dropmaster_ioctl\n"); 242 mutex_lock(&dev->master_mutex); 243 if (!drm_is_current_master(file_priv)) 244 goto out_unlock; 245 246 if (!dev->master) 247 goto out_unlock; 248 249 if (file_priv->master->lessor != NULL) { 250 DRM_DEBUG_LEASE("Attempt to drop lessee %d as master\n", file_priv->master->lessee_id); 251 ret = -EINVAL; 252 goto out_unlock; 253 } 254 255 ret = 0; 256 drm_drop_master(dev, file_priv); 257 out_unlock: 258 mutex_unlock(&dev->master_mutex); 259 return ret; 260 } 261 262 int drm_master_open(struct drm_file *file_priv) 263 { 264 struct drm_device *dev = file_priv->minor->dev; 265 int ret = 0; 266 267 /* if there is no current master make this fd it, but do not create 268 * any master object for render clients */ 269 mutex_lock(&dev->master_mutex); 270 if (!dev->master) 271 ret = drm_new_set_master(dev, file_priv); 272 else 273 file_priv->master = drm_master_get(dev->master); 274 mutex_unlock(&dev->master_mutex); 275 276 return ret; 277 } 278 279 void drm_master_release(struct drm_file *file_priv) 280 { 281 struct drm_device *dev = file_priv->minor->dev; 282 struct drm_master *master = file_priv->master; 283 284 mutex_lock(&dev->master_mutex); 285 if (file_priv->magic) 286 idr_remove(&file_priv->master->magic_map, file_priv->magic); 287 288 if (!drm_is_current_master(file_priv)) 289 goto out; 290 291 if (drm_core_check_feature(dev, DRIVER_LEGACY)) { 292 /* 293 * Since the master is disappearing, so is the 294 * possibility to lock. 295 */ 296 mutex_lock(&dev->struct_mutex); 297 if (master->lock.hw_lock) { 298 if (dev->sigdata.lock == master->lock.hw_lock) 299 dev->sigdata.lock = NULL; 300 master->lock.hw_lock = NULL; 301 master->lock.file_priv = NULL; 302 wake_up_interruptible_all(&master->lock.lock_queue); 303 } 304 mutex_unlock(&dev->struct_mutex); 305 } 306 307 if (dev->master == file_priv->master) 308 drm_drop_master(dev, file_priv); 309 out: 310 if (drm_core_check_feature(dev, DRIVER_MODESET) && file_priv->is_master) { 311 /* Revoke any leases held by this or lessees, but only if 312 * this is the "real" master 313 */ 314 drm_lease_revoke(master); 315 } 316 317 /* drop the master reference held by the file priv */ 318 if (file_priv->master) 319 drm_master_put(&file_priv->master); 320 mutex_unlock(&dev->master_mutex); 321 } 322 323 /** 324 * drm_is_current_master - checks whether @priv is the current master 325 * @fpriv: DRM file private 326 * 327 * Checks whether @fpriv is current master on its device. This decides whether a 328 * client is allowed to run DRM_MASTER IOCTLs. 329 * 330 * Most of the modern IOCTL which require DRM_MASTER are for kernel modesetting 331 * - the current master is assumed to own the non-shareable display hardware. 332 */ 333 bool drm_is_current_master(struct drm_file *fpriv) 334 { 335 return fpriv->is_master; 336 } 337 EXPORT_SYMBOL(drm_is_current_master); 338 339 /** 340 * drm_master_get - reference a master pointer 341 * @master: &struct drm_master 342 * 343 * Increments the reference count of @master and returns a pointer to @master. 344 */ 345 struct drm_master *drm_master_get(struct drm_master *master) 346 { 347 kref_get(&master->refcount); 348 return master; 349 } 350 EXPORT_SYMBOL(drm_master_get); 351 352 static void drm_master_destroy(struct kref *kref) 353 { 354 struct drm_master *master = container_of(kref, struct drm_master, refcount); 355 struct drm_device *dev = master->dev; 356 357 if (drm_core_check_feature(dev, DRIVER_MODESET)) 358 drm_lease_destroy(master); 359 360 if (dev->driver->master_destroy) 361 dev->driver->master_destroy(dev, master); 362 363 drm_legacy_master_rmmaps(dev, master); 364 365 idr_destroy(&master->magic_map); 366 idr_destroy(&master->leases); 367 idr_destroy(&master->lessee_idr); 368 369 kfree(master->unique); 370 kfree(master); 371 } 372 373 /** 374 * drm_master_put - unreference and clear a master pointer 375 * @master: pointer to a pointer of &struct drm_master 376 * 377 * This decrements the &drm_master behind @master and sets it to NULL. 378 */ 379 void drm_master_put(struct drm_master **master) 380 { 381 kref_put(&(*master)->refcount, drm_master_destroy); 382 *master = NULL; 383 } 384 EXPORT_SYMBOL(drm_master_put); 385