1 /** 2 * \file drm_context.c 3 * IOCTLs for generic contexts 4 * 5 * \author Rickard E. (Rik) Faith <faith@valinux.com> 6 * \author Gareth Hughes <gareth@valinux.com> 7 */ 8 9 /* 10 * Created: Fri Nov 24 18:31:37 2000 by gareth@valinux.com 11 * 12 * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas. 13 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. 14 * All Rights Reserved. 15 * 16 * Permission is hereby granted, free of charge, to any person obtaining a 17 * copy of this software and associated documentation files (the "Software"), 18 * to deal in the Software without restriction, including without limitation 19 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 20 * and/or sell copies of the Software, and to permit persons to whom the 21 * Software is furnished to do so, subject to the following conditions: 22 * 23 * The above copyright notice and this permission notice (including the next 24 * paragraph) shall be included in all copies or substantial portions of the 25 * Software. 26 * 27 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 28 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 29 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 30 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 31 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 32 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 33 * OTHER DEALINGS IN THE SOFTWARE. 34 */ 35 36 /* 37 * ChangeLog: 38 * 2001-11-16 Torsten Duwe <duwe@caldera.de> 39 * added context constructor/destructor hooks, 40 * needed by SiS driver's memory management. 41 */ 42 43 #include "drmP.h" 44 45 /******************************************************************/ 46 /** \name Context bitmap support */ 47 /*@{*/ 48 49 /** 50 * Free a handle from the context bitmap. 51 * 52 * \param dev DRM device. 53 * \param ctx_handle context handle. 54 * 55 * Clears the bit specified by \p ctx_handle in drm_device::ctx_bitmap and the entry 56 * in drm_device::ctx_idr, while holding the drm_device::struct_mutex 57 * lock. 58 */ 59 void drm_ctxbitmap_free(struct drm_device * dev, int ctx_handle) 60 { 61 mutex_lock(&dev->struct_mutex); 62 idr_remove(&dev->ctx_idr, ctx_handle); 63 mutex_unlock(&dev->struct_mutex); 64 } 65 66 /** 67 * Context bitmap allocation. 68 * 69 * \param dev DRM device. 70 * \return (non-negative) context handle on success or a negative number on failure. 71 * 72 * Allocate a new idr from drm_device::ctx_idr while holding the 73 * drm_device::struct_mutex lock. 74 */ 75 static int drm_ctxbitmap_next(struct drm_device * dev) 76 { 77 int new_id; 78 int ret; 79 80 again: 81 if (idr_pre_get(&dev->ctx_idr, GFP_KERNEL) == 0) { 82 DRM_ERROR("Out of memory expanding drawable idr\n"); 83 return -ENOMEM; 84 } 85 mutex_lock(&dev->struct_mutex); 86 ret = idr_get_new_above(&dev->ctx_idr, NULL, 87 DRM_RESERVED_CONTEXTS, &new_id); 88 if (ret == -EAGAIN) { 89 mutex_unlock(&dev->struct_mutex); 90 goto again; 91 } 92 mutex_unlock(&dev->struct_mutex); 93 return new_id; 94 } 95 96 /** 97 * Context bitmap initialization. 98 * 99 * \param dev DRM device. 100 * 101 * Initialise the drm_device::ctx_idr 102 */ 103 int drm_ctxbitmap_init(struct drm_device * dev) 104 { 105 idr_init(&dev->ctx_idr); 106 return 0; 107 } 108 109 /** 110 * Context bitmap cleanup. 111 * 112 * \param dev DRM device. 113 * 114 * Free all idr members using drm_ctx_sarea_free helper function 115 * while holding the drm_device::struct_mutex lock. 116 */ 117 void drm_ctxbitmap_cleanup(struct drm_device * dev) 118 { 119 mutex_lock(&dev->struct_mutex); 120 idr_remove_all(&dev->ctx_idr); 121 mutex_unlock(&dev->struct_mutex); 122 } 123 124 /*@}*/ 125 126 /******************************************************************/ 127 /** \name Per Context SAREA Support */ 128 /*@{*/ 129 130 /** 131 * Get per-context SAREA. 132 * 133 * \param inode device inode. 134 * \param file_priv DRM file private. 135 * \param cmd command. 136 * \param arg user argument pointing to a drm_ctx_priv_map structure. 137 * \return zero on success or a negative number on failure. 138 * 139 * Gets the map from drm_device::ctx_idr with the handle specified and 140 * returns its handle. 141 */ 142 int drm_getsareactx(struct drm_device *dev, void *data, 143 struct drm_file *file_priv) 144 { 145 struct drm_ctx_priv_map *request = data; 146 struct drm_map *map; 147 struct drm_map_list *_entry; 148 149 mutex_lock(&dev->struct_mutex); 150 151 map = idr_find(&dev->ctx_idr, request->ctx_id); 152 if (!map) { 153 mutex_unlock(&dev->struct_mutex); 154 return -EINVAL; 155 } 156 157 mutex_unlock(&dev->struct_mutex); 158 159 request->handle = NULL; 160 list_for_each_entry(_entry, &dev->maplist, head) { 161 if (_entry->map == map) { 162 request->handle = 163 (void *)(unsigned long)_entry->user_token; 164 break; 165 } 166 } 167 if (request->handle == NULL) 168 return -EINVAL; 169 170 return 0; 171 } 172 173 /** 174 * Set per-context SAREA. 175 * 176 * \param inode device inode. 177 * \param file_priv DRM file private. 178 * \param cmd command. 179 * \param arg user argument pointing to a drm_ctx_priv_map structure. 180 * \return zero on success or a negative number on failure. 181 * 182 * Searches the mapping specified in \p arg and update the entry in 183 * drm_device::ctx_idr with it. 184 */ 185 int drm_setsareactx(struct drm_device *dev, void *data, 186 struct drm_file *file_priv) 187 { 188 struct drm_ctx_priv_map *request = data; 189 struct drm_map *map = NULL; 190 struct drm_map_list *r_list = NULL; 191 192 mutex_lock(&dev->struct_mutex); 193 list_for_each_entry(r_list, &dev->maplist, head) { 194 if (r_list->map 195 && r_list->user_token == (unsigned long) request->handle) 196 goto found; 197 } 198 bad: 199 mutex_unlock(&dev->struct_mutex); 200 return -EINVAL; 201 202 found: 203 map = r_list->map; 204 if (!map) 205 goto bad; 206 207 if (IS_ERR(idr_replace(&dev->ctx_idr, map, request->ctx_id))) 208 goto bad; 209 210 mutex_unlock(&dev->struct_mutex); 211 212 return 0; 213 } 214 215 /*@}*/ 216 217 /******************************************************************/ 218 /** \name The actual DRM context handling routines */ 219 /*@{*/ 220 221 /** 222 * Switch context. 223 * 224 * \param dev DRM device. 225 * \param old old context handle. 226 * \param new new context handle. 227 * \return zero on success or a negative number on failure. 228 * 229 * Attempt to set drm_device::context_flag. 230 */ 231 static int drm_context_switch(struct drm_device * dev, int old, int new) 232 { 233 if (test_and_set_bit(0, &dev->context_flag)) { 234 DRM_ERROR("Reentering -- FIXME\n"); 235 return -EBUSY; 236 } 237 238 DRM_DEBUG("Context switch from %d to %d\n", old, new); 239 240 if (new == dev->last_context) { 241 clear_bit(0, &dev->context_flag); 242 return 0; 243 } 244 245 return 0; 246 } 247 248 /** 249 * Complete context switch. 250 * 251 * \param dev DRM device. 252 * \param new new context handle. 253 * \return zero on success or a negative number on failure. 254 * 255 * Updates drm_device::last_context and drm_device::last_switch. Verifies the 256 * hardware lock is held, clears the drm_device::context_flag and wakes up 257 * drm_device::context_wait. 258 */ 259 static int drm_context_switch_complete(struct drm_device * dev, int new) 260 { 261 dev->last_context = new; /* PRE/POST: This is the _only_ writer. */ 262 dev->last_switch = jiffies; 263 264 if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) { 265 DRM_ERROR("Lock isn't held after context switch\n"); 266 } 267 268 /* If a context switch is ever initiated 269 when the kernel holds the lock, release 270 that lock here. */ 271 clear_bit(0, &dev->context_flag); 272 wake_up(&dev->context_wait); 273 274 return 0; 275 } 276 277 /** 278 * Reserve contexts. 279 * 280 * \param inode device inode. 281 * \param file_priv DRM file private. 282 * \param cmd command. 283 * \param arg user argument pointing to a drm_ctx_res structure. 284 * \return zero on success or a negative number on failure. 285 */ 286 int drm_resctx(struct drm_device *dev, void *data, 287 struct drm_file *file_priv) 288 { 289 struct drm_ctx_res *res = data; 290 struct drm_ctx ctx; 291 int i; 292 293 if (res->count >= DRM_RESERVED_CONTEXTS) { 294 memset(&ctx, 0, sizeof(ctx)); 295 for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) { 296 ctx.handle = i; 297 if (copy_to_user(&res->contexts[i], &ctx, sizeof(ctx))) 298 return -EFAULT; 299 } 300 } 301 res->count = DRM_RESERVED_CONTEXTS; 302 303 return 0; 304 } 305 306 /** 307 * Add context. 308 * 309 * \param inode device inode. 310 * \param file_priv DRM file private. 311 * \param cmd command. 312 * \param arg user argument pointing to a drm_ctx structure. 313 * \return zero on success or a negative number on failure. 314 * 315 * Get a new handle for the context and copy to userspace. 316 */ 317 int drm_addctx(struct drm_device *dev, void *data, 318 struct drm_file *file_priv) 319 { 320 struct drm_ctx_list *ctx_entry; 321 struct drm_ctx *ctx = data; 322 323 ctx->handle = drm_ctxbitmap_next(dev); 324 if (ctx->handle == DRM_KERNEL_CONTEXT) { 325 /* Skip kernel's context and get a new one. */ 326 ctx->handle = drm_ctxbitmap_next(dev); 327 } 328 DRM_DEBUG("%d\n", ctx->handle); 329 if (ctx->handle == -1) { 330 DRM_DEBUG("Not enough free contexts.\n"); 331 /* Should this return -EBUSY instead? */ 332 return -ENOMEM; 333 } 334 335 if (ctx->handle != DRM_KERNEL_CONTEXT) { 336 if (dev->driver->context_ctor) 337 if (!dev->driver->context_ctor(dev, ctx->handle)) { 338 DRM_DEBUG("Running out of ctxs or memory.\n"); 339 return -ENOMEM; 340 } 341 } 342 343 ctx_entry = drm_alloc(sizeof(*ctx_entry), DRM_MEM_CTXLIST); 344 if (!ctx_entry) { 345 DRM_DEBUG("out of memory\n"); 346 return -ENOMEM; 347 } 348 349 INIT_LIST_HEAD(&ctx_entry->head); 350 ctx_entry->handle = ctx->handle; 351 ctx_entry->tag = file_priv; 352 353 mutex_lock(&dev->ctxlist_mutex); 354 list_add(&ctx_entry->head, &dev->ctxlist); 355 ++dev->ctx_count; 356 mutex_unlock(&dev->ctxlist_mutex); 357 358 return 0; 359 } 360 361 int drm_modctx(struct drm_device *dev, void *data, struct drm_file *file_priv) 362 { 363 /* This does nothing */ 364 return 0; 365 } 366 367 /** 368 * Get context. 369 * 370 * \param inode device inode. 371 * \param file_priv DRM file private. 372 * \param cmd command. 373 * \param arg user argument pointing to a drm_ctx structure. 374 * \return zero on success or a negative number on failure. 375 */ 376 int drm_getctx(struct drm_device *dev, void *data, struct drm_file *file_priv) 377 { 378 struct drm_ctx *ctx = data; 379 380 /* This is 0, because we don't handle any context flags */ 381 ctx->flags = 0; 382 383 return 0; 384 } 385 386 /** 387 * Switch context. 388 * 389 * \param inode device inode. 390 * \param file_priv DRM file private. 391 * \param cmd command. 392 * \param arg user argument pointing to a drm_ctx structure. 393 * \return zero on success or a negative number on failure. 394 * 395 * Calls context_switch(). 396 */ 397 int drm_switchctx(struct drm_device *dev, void *data, 398 struct drm_file *file_priv) 399 { 400 struct drm_ctx *ctx = data; 401 402 DRM_DEBUG("%d\n", ctx->handle); 403 return drm_context_switch(dev, dev->last_context, ctx->handle); 404 } 405 406 /** 407 * New context. 408 * 409 * \param inode device inode. 410 * \param file_priv DRM file private. 411 * \param cmd command. 412 * \param arg user argument pointing to a drm_ctx structure. 413 * \return zero on success or a negative number on failure. 414 * 415 * Calls context_switch_complete(). 416 */ 417 int drm_newctx(struct drm_device *dev, void *data, 418 struct drm_file *file_priv) 419 { 420 struct drm_ctx *ctx = data; 421 422 DRM_DEBUG("%d\n", ctx->handle); 423 drm_context_switch_complete(dev, ctx->handle); 424 425 return 0; 426 } 427 428 /** 429 * Remove context. 430 * 431 * \param inode device inode. 432 * \param file_priv DRM file private. 433 * \param cmd command. 434 * \param arg user argument pointing to a drm_ctx structure. 435 * \return zero on success or a negative number on failure. 436 * 437 * If not the special kernel context, calls ctxbitmap_free() to free the specified context. 438 */ 439 int drm_rmctx(struct drm_device *dev, void *data, 440 struct drm_file *file_priv) 441 { 442 struct drm_ctx *ctx = data; 443 444 DRM_DEBUG("%d\n", ctx->handle); 445 if (ctx->handle == DRM_KERNEL_CONTEXT + 1) { 446 file_priv->remove_auth_on_close = 1; 447 } 448 if (ctx->handle != DRM_KERNEL_CONTEXT) { 449 if (dev->driver->context_dtor) 450 dev->driver->context_dtor(dev, ctx->handle); 451 drm_ctxbitmap_free(dev, ctx->handle); 452 } 453 454 mutex_lock(&dev->ctxlist_mutex); 455 if (!list_empty(&dev->ctxlist)) { 456 struct drm_ctx_list *pos, *n; 457 458 list_for_each_entry_safe(pos, n, &dev->ctxlist, head) { 459 if (pos->handle == ctx->handle) { 460 list_del(&pos->head); 461 drm_free(pos, sizeof(*pos), DRM_MEM_CTXLIST); 462 --dev->ctx_count; 463 } 464 } 465 } 466 mutex_unlock(&dev->ctxlist_mutex); 467 468 return 0; 469 } 470 471 /*@}*/ 472