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 <drm/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 mutex_unlock(&dev->struct_mutex); 89 if (ret == -EAGAIN) 90 goto again; 91 else if (ret) 92 return ret; 93 94 return new_id; 95 } 96 97 /** 98 * Context bitmap initialization. 99 * 100 * \param dev DRM device. 101 * 102 * Initialise the drm_device::ctx_idr 103 */ 104 int drm_ctxbitmap_init(struct drm_device * dev) 105 { 106 idr_init(&dev->ctx_idr); 107 return 0; 108 } 109 110 /** 111 * Context bitmap cleanup. 112 * 113 * \param dev DRM device. 114 * 115 * Free all idr members using drm_ctx_sarea_free helper function 116 * while holding the drm_device::struct_mutex lock. 117 */ 118 void drm_ctxbitmap_cleanup(struct drm_device * dev) 119 { 120 mutex_lock(&dev->struct_mutex); 121 idr_remove_all(&dev->ctx_idr); 122 mutex_unlock(&dev->struct_mutex); 123 } 124 125 /*@}*/ 126 127 /******************************************************************/ 128 /** \name Per Context SAREA Support */ 129 /*@{*/ 130 131 /** 132 * Get per-context SAREA. 133 * 134 * \param inode device inode. 135 * \param file_priv DRM file private. 136 * \param cmd command. 137 * \param arg user argument pointing to a drm_ctx_priv_map structure. 138 * \return zero on success or a negative number on failure. 139 * 140 * Gets the map from drm_device::ctx_idr with the handle specified and 141 * returns its handle. 142 */ 143 int drm_getsareactx(struct drm_device *dev, void *data, 144 struct drm_file *file_priv) 145 { 146 struct drm_ctx_priv_map *request = data; 147 struct drm_local_map *map; 148 struct drm_map_list *_entry; 149 150 mutex_lock(&dev->struct_mutex); 151 152 map = idr_find(&dev->ctx_idr, request->ctx_id); 153 if (!map) { 154 mutex_unlock(&dev->struct_mutex); 155 return -EINVAL; 156 } 157 158 request->handle = NULL; 159 list_for_each_entry(_entry, &dev->maplist, head) { 160 if (_entry->map == map) { 161 request->handle = 162 (void *)(unsigned long)_entry->user_token; 163 break; 164 } 165 } 166 167 mutex_unlock(&dev->struct_mutex); 168 169 if (request->handle == NULL) 170 return -EINVAL; 171 172 return 0; 173 } 174 175 /** 176 * Set per-context SAREA. 177 * 178 * \param inode device inode. 179 * \param file_priv DRM file private. 180 * \param cmd command. 181 * \param arg user argument pointing to a drm_ctx_priv_map structure. 182 * \return zero on success or a negative number on failure. 183 * 184 * Searches the mapping specified in \p arg and update the entry in 185 * drm_device::ctx_idr with it. 186 */ 187 int drm_setsareactx(struct drm_device *dev, void *data, 188 struct drm_file *file_priv) 189 { 190 struct drm_ctx_priv_map *request = data; 191 struct drm_local_map *map = NULL; 192 struct drm_map_list *r_list = NULL; 193 194 mutex_lock(&dev->struct_mutex); 195 list_for_each_entry(r_list, &dev->maplist, head) { 196 if (r_list->map 197 && r_list->user_token == (unsigned long) request->handle) 198 goto found; 199 } 200 bad: 201 mutex_unlock(&dev->struct_mutex); 202 return -EINVAL; 203 204 found: 205 map = r_list->map; 206 if (!map) 207 goto bad; 208 209 if (IS_ERR(idr_replace(&dev->ctx_idr, map, request->ctx_id))) 210 goto bad; 211 212 mutex_unlock(&dev->struct_mutex); 213 214 return 0; 215 } 216 217 /*@}*/ 218 219 /******************************************************************/ 220 /** \name The actual DRM context handling routines */ 221 /*@{*/ 222 223 /** 224 * Switch context. 225 * 226 * \param dev DRM device. 227 * \param old old context handle. 228 * \param new new context handle. 229 * \return zero on success or a negative number on failure. 230 * 231 * Attempt to set drm_device::context_flag. 232 */ 233 static int drm_context_switch(struct drm_device * dev, int old, int new) 234 { 235 if (test_and_set_bit(0, &dev->context_flag)) { 236 DRM_ERROR("Reentering -- FIXME\n"); 237 return -EBUSY; 238 } 239 240 DRM_DEBUG("Context switch from %d to %d\n", old, new); 241 242 if (new == dev->last_context) { 243 clear_bit(0, &dev->context_flag); 244 return 0; 245 } 246 247 return 0; 248 } 249 250 /** 251 * Complete context switch. 252 * 253 * \param dev DRM device. 254 * \param new new context handle. 255 * \return zero on success or a negative number on failure. 256 * 257 * Updates drm_device::last_context and drm_device::last_switch. Verifies the 258 * hardware lock is held, clears the drm_device::context_flag and wakes up 259 * drm_device::context_wait. 260 */ 261 static int drm_context_switch_complete(struct drm_device *dev, 262 struct drm_file *file_priv, int new) 263 { 264 dev->last_context = new; /* PRE/POST: This is the _only_ writer. */ 265 dev->last_switch = jiffies; 266 267 if (!_DRM_LOCK_IS_HELD(file_priv->master->lock.hw_lock->lock)) { 268 DRM_ERROR("Lock isn't held after context switch\n"); 269 } 270 271 /* If a context switch is ever initiated 272 when the kernel holds the lock, release 273 that lock here. */ 274 clear_bit(0, &dev->context_flag); 275 wake_up(&dev->context_wait); 276 277 return 0; 278 } 279 280 /** 281 * Reserve contexts. 282 * 283 * \param inode device inode. 284 * \param file_priv DRM file private. 285 * \param cmd command. 286 * \param arg user argument pointing to a drm_ctx_res structure. 287 * \return zero on success or a negative number on failure. 288 */ 289 int drm_resctx(struct drm_device *dev, void *data, 290 struct drm_file *file_priv) 291 { 292 struct drm_ctx_res *res = data; 293 struct drm_ctx ctx; 294 int i; 295 296 if (res->count >= DRM_RESERVED_CONTEXTS) { 297 memset(&ctx, 0, sizeof(ctx)); 298 for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) { 299 ctx.handle = i; 300 if (copy_to_user(&res->contexts[i], &ctx, sizeof(ctx))) 301 return -EFAULT; 302 } 303 } 304 res->count = DRM_RESERVED_CONTEXTS; 305 306 return 0; 307 } 308 309 /** 310 * Add context. 311 * 312 * \param inode device inode. 313 * \param file_priv DRM file private. 314 * \param cmd command. 315 * \param arg user argument pointing to a drm_ctx structure. 316 * \return zero on success or a negative number on failure. 317 * 318 * Get a new handle for the context and copy to userspace. 319 */ 320 int drm_addctx(struct drm_device *dev, void *data, 321 struct drm_file *file_priv) 322 { 323 struct drm_ctx_list *ctx_entry; 324 struct drm_ctx *ctx = data; 325 326 ctx->handle = drm_ctxbitmap_next(dev); 327 if (ctx->handle == DRM_KERNEL_CONTEXT) { 328 /* Skip kernel's context and get a new one. */ 329 ctx->handle = drm_ctxbitmap_next(dev); 330 } 331 DRM_DEBUG("%d\n", ctx->handle); 332 if (ctx->handle == -1) { 333 DRM_DEBUG("Not enough free contexts.\n"); 334 /* Should this return -EBUSY instead? */ 335 return -ENOMEM; 336 } 337 338 ctx_entry = kmalloc(sizeof(*ctx_entry), GFP_KERNEL); 339 if (!ctx_entry) { 340 DRM_DEBUG("out of memory\n"); 341 return -ENOMEM; 342 } 343 344 INIT_LIST_HEAD(&ctx_entry->head); 345 ctx_entry->handle = ctx->handle; 346 ctx_entry->tag = file_priv; 347 348 mutex_lock(&dev->ctxlist_mutex); 349 list_add(&ctx_entry->head, &dev->ctxlist); 350 ++dev->ctx_count; 351 mutex_unlock(&dev->ctxlist_mutex); 352 353 return 0; 354 } 355 356 int drm_modctx(struct drm_device *dev, void *data, struct drm_file *file_priv) 357 { 358 /* This does nothing */ 359 return 0; 360 } 361 362 /** 363 * Get context. 364 * 365 * \param inode device inode. 366 * \param file_priv DRM file private. 367 * \param cmd command. 368 * \param arg user argument pointing to a drm_ctx structure. 369 * \return zero on success or a negative number on failure. 370 */ 371 int drm_getctx(struct drm_device *dev, void *data, struct drm_file *file_priv) 372 { 373 struct drm_ctx *ctx = data; 374 375 /* This is 0, because we don't handle any context flags */ 376 ctx->flags = 0; 377 378 return 0; 379 } 380 381 /** 382 * Switch context. 383 * 384 * \param inode device inode. 385 * \param file_priv DRM file private. 386 * \param cmd command. 387 * \param arg user argument pointing to a drm_ctx structure. 388 * \return zero on success or a negative number on failure. 389 * 390 * Calls context_switch(). 391 */ 392 int drm_switchctx(struct drm_device *dev, void *data, 393 struct drm_file *file_priv) 394 { 395 struct drm_ctx *ctx = data; 396 397 DRM_DEBUG("%d\n", ctx->handle); 398 return drm_context_switch(dev, dev->last_context, ctx->handle); 399 } 400 401 /** 402 * New context. 403 * 404 * \param inode device inode. 405 * \param file_priv DRM file private. 406 * \param cmd command. 407 * \param arg user argument pointing to a drm_ctx structure. 408 * \return zero on success or a negative number on failure. 409 * 410 * Calls context_switch_complete(). 411 */ 412 int drm_newctx(struct drm_device *dev, void *data, 413 struct drm_file *file_priv) 414 { 415 struct drm_ctx *ctx = data; 416 417 DRM_DEBUG("%d\n", ctx->handle); 418 drm_context_switch_complete(dev, file_priv, ctx->handle); 419 420 return 0; 421 } 422 423 /** 424 * Remove context. 425 * 426 * \param inode device inode. 427 * \param file_priv DRM file private. 428 * \param cmd command. 429 * \param arg user argument pointing to a drm_ctx structure. 430 * \return zero on success or a negative number on failure. 431 * 432 * If not the special kernel context, calls ctxbitmap_free() to free the specified context. 433 */ 434 int drm_rmctx(struct drm_device *dev, void *data, 435 struct drm_file *file_priv) 436 { 437 struct drm_ctx *ctx = data; 438 439 DRM_DEBUG("%d\n", ctx->handle); 440 if (ctx->handle != DRM_KERNEL_CONTEXT) { 441 if (dev->driver->context_dtor) 442 dev->driver->context_dtor(dev, ctx->handle); 443 drm_ctxbitmap_free(dev, ctx->handle); 444 } 445 446 mutex_lock(&dev->ctxlist_mutex); 447 if (!list_empty(&dev->ctxlist)) { 448 struct drm_ctx_list *pos, *n; 449 450 list_for_each_entry_safe(pos, n, &dev->ctxlist, head) { 451 if (pos->handle == ctx->handle) { 452 list_del(&pos->head); 453 kfree(pos); 454 --dev->ctx_count; 455 } 456 } 457 } 458 mutex_unlock(&dev->ctxlist_mutex); 459 460 return 0; 461 } 462 463 /*@}*/ 464