1 /* 2 * Legacy: Generic DRM Contexts 3 * 4 * Copyright 1999, 2000 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 <linux/slab.h> 32 #include <linux/uaccess.h> 33 34 #include <drm/drm_drv.h> 35 #include <drm/drm_file.h> 36 #include <drm/drm_print.h> 37 38 #include "drm_legacy.h" 39 40 struct drm_ctx_list { 41 struct list_head head; 42 drm_context_t handle; 43 struct drm_file *tag; 44 }; 45 46 /******************************************************************/ 47 /** \name Context bitmap support */ 48 /*@{*/ 49 50 /* 51 * Free a handle from the context bitmap. 52 * 53 * \param dev DRM device. 54 * \param ctx_handle context handle. 55 * 56 * Clears the bit specified by \p ctx_handle in drm_device::ctx_bitmap and the entry 57 * in drm_device::ctx_idr, while holding the drm_device::struct_mutex 58 * lock. 59 */ 60 void drm_legacy_ctxbitmap_free(struct drm_device * dev, int ctx_handle) 61 { 62 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && 63 !drm_core_check_feature(dev, DRIVER_LEGACY)) 64 return; 65 66 mutex_lock(&dev->struct_mutex); 67 idr_remove(&dev->ctx_idr, ctx_handle); 68 mutex_unlock(&dev->struct_mutex); 69 } 70 71 /* 72 * Context bitmap allocation. 73 * 74 * \param dev DRM device. 75 * \return (non-negative) context handle on success or a negative number on failure. 76 * 77 * Allocate a new idr from drm_device::ctx_idr while holding the 78 * drm_device::struct_mutex lock. 79 */ 80 static int drm_legacy_ctxbitmap_next(struct drm_device * dev) 81 { 82 int ret; 83 84 mutex_lock(&dev->struct_mutex); 85 ret = idr_alloc(&dev->ctx_idr, NULL, DRM_RESERVED_CONTEXTS, 0, 86 GFP_KERNEL); 87 mutex_unlock(&dev->struct_mutex); 88 return ret; 89 } 90 91 /* 92 * Context bitmap initialization. 93 * 94 * \param dev DRM device. 95 * 96 * Initialise the drm_device::ctx_idr 97 */ 98 void drm_legacy_ctxbitmap_init(struct drm_device * dev) 99 { 100 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && 101 !drm_core_check_feature(dev, DRIVER_LEGACY)) 102 return; 103 104 idr_init(&dev->ctx_idr); 105 } 106 107 /* 108 * Context bitmap cleanup. 109 * 110 * \param dev DRM device. 111 * 112 * Free all idr members using drm_ctx_sarea_free helper function 113 * while holding the drm_device::struct_mutex lock. 114 */ 115 void drm_legacy_ctxbitmap_cleanup(struct drm_device * dev) 116 { 117 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && 118 !drm_core_check_feature(dev, DRIVER_LEGACY)) 119 return; 120 121 mutex_lock(&dev->struct_mutex); 122 idr_destroy(&dev->ctx_idr); 123 mutex_unlock(&dev->struct_mutex); 124 } 125 126 /** 127 * drm_legacy_ctxbitmap_flush() - Flush all contexts owned by a file 128 * @dev: DRM device to operate on 129 * @file: Open file to flush contexts for 130 * 131 * This iterates over all contexts on @dev and drops them if they're owned by 132 * @file. Note that after this call returns, new contexts might be added if 133 * the file is still alive. 134 */ 135 void drm_legacy_ctxbitmap_flush(struct drm_device *dev, struct drm_file *file) 136 { 137 struct drm_ctx_list *pos, *tmp; 138 139 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && 140 !drm_core_check_feature(dev, DRIVER_LEGACY)) 141 return; 142 143 mutex_lock(&dev->ctxlist_mutex); 144 145 list_for_each_entry_safe(pos, tmp, &dev->ctxlist, head) { 146 if (pos->tag == file && 147 pos->handle != DRM_KERNEL_CONTEXT) { 148 if (dev->driver->context_dtor) 149 dev->driver->context_dtor(dev, pos->handle); 150 151 drm_legacy_ctxbitmap_free(dev, pos->handle); 152 list_del(&pos->head); 153 kfree(pos); 154 } 155 } 156 157 mutex_unlock(&dev->ctxlist_mutex); 158 } 159 160 /*@}*/ 161 162 /******************************************************************/ 163 /** \name Per Context SAREA Support */ 164 /*@{*/ 165 166 /* 167 * Get per-context SAREA. 168 * 169 * \param inode device inode. 170 * \param file_priv DRM file private. 171 * \param cmd command. 172 * \param arg user argument pointing to a drm_ctx_priv_map structure. 173 * \return zero on success or a negative number on failure. 174 * 175 * Gets the map from drm_device::ctx_idr with the handle specified and 176 * returns its handle. 177 */ 178 int drm_legacy_getsareactx(struct drm_device *dev, void *data, 179 struct drm_file *file_priv) 180 { 181 struct drm_ctx_priv_map *request = data; 182 struct drm_local_map *map; 183 struct drm_map_list *_entry; 184 185 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && 186 !drm_core_check_feature(dev, DRIVER_LEGACY)) 187 return -EOPNOTSUPP; 188 189 mutex_lock(&dev->struct_mutex); 190 191 map = idr_find(&dev->ctx_idr, request->ctx_id); 192 if (!map) { 193 mutex_unlock(&dev->struct_mutex); 194 return -EINVAL; 195 } 196 197 request->handle = NULL; 198 list_for_each_entry(_entry, &dev->maplist, head) { 199 if (_entry->map == map) { 200 request->handle = 201 (void *)(unsigned long)_entry->user_token; 202 break; 203 } 204 } 205 206 mutex_unlock(&dev->struct_mutex); 207 208 if (request->handle == NULL) 209 return -EINVAL; 210 211 return 0; 212 } 213 214 /* 215 * Set per-context SAREA. 216 * 217 * \param inode device inode. 218 * \param file_priv DRM file private. 219 * \param cmd command. 220 * \param arg user argument pointing to a drm_ctx_priv_map structure. 221 * \return zero on success or a negative number on failure. 222 * 223 * Searches the mapping specified in \p arg and update the entry in 224 * drm_device::ctx_idr with it. 225 */ 226 int drm_legacy_setsareactx(struct drm_device *dev, void *data, 227 struct drm_file *file_priv) 228 { 229 struct drm_ctx_priv_map *request = data; 230 struct drm_local_map *map = NULL; 231 struct drm_map_list *r_list = NULL; 232 233 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && 234 !drm_core_check_feature(dev, DRIVER_LEGACY)) 235 return -EOPNOTSUPP; 236 237 mutex_lock(&dev->struct_mutex); 238 list_for_each_entry(r_list, &dev->maplist, head) { 239 if (r_list->map 240 && r_list->user_token == (unsigned long) request->handle) 241 goto found; 242 } 243 bad: 244 mutex_unlock(&dev->struct_mutex); 245 return -EINVAL; 246 247 found: 248 map = r_list->map; 249 if (!map) 250 goto bad; 251 252 if (IS_ERR(idr_replace(&dev->ctx_idr, map, request->ctx_id))) 253 goto bad; 254 255 mutex_unlock(&dev->struct_mutex); 256 257 return 0; 258 } 259 260 /*@}*/ 261 262 /******************************************************************/ 263 /** \name The actual DRM context handling routines */ 264 /*@{*/ 265 266 /* 267 * Switch context. 268 * 269 * \param dev DRM device. 270 * \param old old context handle. 271 * \param new new context handle. 272 * \return zero on success or a negative number on failure. 273 * 274 * Attempt to set drm_device::context_flag. 275 */ 276 static int drm_context_switch(struct drm_device * dev, int old, int new) 277 { 278 if (test_and_set_bit(0, &dev->context_flag)) { 279 DRM_ERROR("Reentering -- FIXME\n"); 280 return -EBUSY; 281 } 282 283 DRM_DEBUG("Context switch from %d to %d\n", old, new); 284 285 if (new == dev->last_context) { 286 clear_bit(0, &dev->context_flag); 287 return 0; 288 } 289 290 return 0; 291 } 292 293 /* 294 * Complete context switch. 295 * 296 * \param dev DRM device. 297 * \param new new context handle. 298 * \return zero on success or a negative number on failure. 299 * 300 * Updates drm_device::last_context and drm_device::last_switch. Verifies the 301 * hardware lock is held, clears the drm_device::context_flag and wakes up 302 * drm_device::context_wait. 303 */ 304 static int drm_context_switch_complete(struct drm_device *dev, 305 struct drm_file *file_priv, int new) 306 { 307 dev->last_context = new; /* PRE/POST: This is the _only_ writer. */ 308 309 if (!_DRM_LOCK_IS_HELD(file_priv->master->lock.hw_lock->lock)) { 310 DRM_ERROR("Lock isn't held after context switch\n"); 311 } 312 313 /* If a context switch is ever initiated 314 when the kernel holds the lock, release 315 that lock here. 316 */ 317 clear_bit(0, &dev->context_flag); 318 319 return 0; 320 } 321 322 /* 323 * Reserve contexts. 324 * 325 * \param inode device inode. 326 * \param file_priv DRM file private. 327 * \param cmd command. 328 * \param arg user argument pointing to a drm_ctx_res structure. 329 * \return zero on success or a negative number on failure. 330 */ 331 int drm_legacy_resctx(struct drm_device *dev, void *data, 332 struct drm_file *file_priv) 333 { 334 struct drm_ctx_res *res = data; 335 struct drm_ctx ctx; 336 int i; 337 338 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && 339 !drm_core_check_feature(dev, DRIVER_LEGACY)) 340 return -EOPNOTSUPP; 341 342 if (res->count >= DRM_RESERVED_CONTEXTS) { 343 memset(&ctx, 0, sizeof(ctx)); 344 for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) { 345 ctx.handle = i; 346 if (copy_to_user(&res->contexts[i], &ctx, sizeof(ctx))) 347 return -EFAULT; 348 } 349 } 350 res->count = DRM_RESERVED_CONTEXTS; 351 352 return 0; 353 } 354 355 /* 356 * Add context. 357 * 358 * \param inode device inode. 359 * \param file_priv DRM file private. 360 * \param cmd command. 361 * \param arg user argument pointing to a drm_ctx structure. 362 * \return zero on success or a negative number on failure. 363 * 364 * Get a new handle for the context and copy to userspace. 365 */ 366 int drm_legacy_addctx(struct drm_device *dev, void *data, 367 struct drm_file *file_priv) 368 { 369 struct drm_ctx_list *ctx_entry; 370 struct drm_ctx *ctx = data; 371 int tmp_handle; 372 373 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && 374 !drm_core_check_feature(dev, DRIVER_LEGACY)) 375 return -EOPNOTSUPP; 376 377 tmp_handle = drm_legacy_ctxbitmap_next(dev); 378 if (tmp_handle == DRM_KERNEL_CONTEXT) { 379 /* Skip kernel's context and get a new one. */ 380 tmp_handle = drm_legacy_ctxbitmap_next(dev); 381 } 382 DRM_DEBUG("%d\n", tmp_handle); 383 if (tmp_handle < 0) { 384 DRM_DEBUG("Not enough free contexts.\n"); 385 /* Should this return -EBUSY instead? */ 386 return tmp_handle; 387 } 388 389 ctx->handle = tmp_handle; 390 391 ctx_entry = kmalloc(sizeof(*ctx_entry), GFP_KERNEL); 392 if (!ctx_entry) { 393 DRM_DEBUG("out of memory\n"); 394 return -ENOMEM; 395 } 396 397 INIT_LIST_HEAD(&ctx_entry->head); 398 ctx_entry->handle = ctx->handle; 399 ctx_entry->tag = file_priv; 400 401 mutex_lock(&dev->ctxlist_mutex); 402 list_add(&ctx_entry->head, &dev->ctxlist); 403 mutex_unlock(&dev->ctxlist_mutex); 404 405 return 0; 406 } 407 408 /* 409 * Get context. 410 * 411 * \param inode device inode. 412 * \param file_priv DRM file private. 413 * \param cmd command. 414 * \param arg user argument pointing to a drm_ctx structure. 415 * \return zero on success or a negative number on failure. 416 */ 417 int drm_legacy_getctx(struct drm_device *dev, void *data, 418 struct drm_file *file_priv) 419 { 420 struct drm_ctx *ctx = data; 421 422 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && 423 !drm_core_check_feature(dev, DRIVER_LEGACY)) 424 return -EOPNOTSUPP; 425 426 /* This is 0, because we don't handle any context flags */ 427 ctx->flags = 0; 428 429 return 0; 430 } 431 432 /* 433 * Switch context. 434 * 435 * \param inode device inode. 436 * \param file_priv DRM file private. 437 * \param cmd command. 438 * \param arg user argument pointing to a drm_ctx structure. 439 * \return zero on success or a negative number on failure. 440 * 441 * Calls context_switch(). 442 */ 443 int drm_legacy_switchctx(struct drm_device *dev, void *data, 444 struct drm_file *file_priv) 445 { 446 struct drm_ctx *ctx = data; 447 448 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && 449 !drm_core_check_feature(dev, DRIVER_LEGACY)) 450 return -EOPNOTSUPP; 451 452 DRM_DEBUG("%d\n", ctx->handle); 453 return drm_context_switch(dev, dev->last_context, ctx->handle); 454 } 455 456 /* 457 * New context. 458 * 459 * \param inode device inode. 460 * \param file_priv DRM file private. 461 * \param cmd command. 462 * \param arg user argument pointing to a drm_ctx structure. 463 * \return zero on success or a negative number on failure. 464 * 465 * Calls context_switch_complete(). 466 */ 467 int drm_legacy_newctx(struct drm_device *dev, void *data, 468 struct drm_file *file_priv) 469 { 470 struct drm_ctx *ctx = data; 471 472 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && 473 !drm_core_check_feature(dev, DRIVER_LEGACY)) 474 return -EOPNOTSUPP; 475 476 DRM_DEBUG("%d\n", ctx->handle); 477 drm_context_switch_complete(dev, file_priv, ctx->handle); 478 479 return 0; 480 } 481 482 /* 483 * Remove context. 484 * 485 * \param inode device inode. 486 * \param file_priv DRM file private. 487 * \param cmd command. 488 * \param arg user argument pointing to a drm_ctx structure. 489 * \return zero on success or a negative number on failure. 490 * 491 * If not the special kernel context, calls ctxbitmap_free() to free the specified context. 492 */ 493 int drm_legacy_rmctx(struct drm_device *dev, void *data, 494 struct drm_file *file_priv) 495 { 496 struct drm_ctx *ctx = data; 497 498 if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && 499 !drm_core_check_feature(dev, DRIVER_LEGACY)) 500 return -EOPNOTSUPP; 501 502 DRM_DEBUG("%d\n", ctx->handle); 503 if (ctx->handle != DRM_KERNEL_CONTEXT) { 504 if (dev->driver->context_dtor) 505 dev->driver->context_dtor(dev, ctx->handle); 506 drm_legacy_ctxbitmap_free(dev, ctx->handle); 507 } 508 509 mutex_lock(&dev->ctxlist_mutex); 510 if (!list_empty(&dev->ctxlist)) { 511 struct drm_ctx_list *pos, *n; 512 513 list_for_each_entry_safe(pos, n, &dev->ctxlist, head) { 514 if (pos->handle == ctx->handle) { 515 list_del(&pos->head); 516 kfree(pos); 517 } 518 } 519 } 520 mutex_unlock(&dev->ctxlist_mutex); 521 522 return 0; 523 } 524 525 /*@}*/ 526