Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright © 2011-2012 Intel Corporation |
| 3 | * |
| 4 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 5 | * copy of this software and associated documentation files (the "Software"), |
| 6 | * to deal in the Software without restriction, including without limitation |
| 7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 8 | * and/or sell copies of the Software, and to permit persons to whom the |
| 9 | * Software is furnished to do so, subject to the following conditions: |
| 10 | * |
| 11 | * The above copyright notice and this permission notice (including the next |
| 12 | * paragraph) shall be included in all copies or substantial portions of the |
| 13 | * Software. |
| 14 | * |
| 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 18 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| 20 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| 21 | * IN THE SOFTWARE. |
| 22 | * |
| 23 | * Authors: |
| 24 | * Ben Widawsky <ben@bwidawsk.net> |
| 25 | * |
| 26 | */ |
| 27 | |
| 28 | /* |
| 29 | * This file implements HW context support. On gen5+ a HW context consists of an |
| 30 | * opaque GPU object which is referenced at times of context saves and restores. |
| 31 | * With RC6 enabled, the context is also referenced as the GPU enters and exists |
| 32 | * from RC6 (GPU has it's own internal power context, except on gen5). Though |
| 33 | * something like a context does exist for the media ring, the code only |
| 34 | * supports contexts for the render ring. |
| 35 | * |
| 36 | * In software, there is a distinction between contexts created by the user, |
| 37 | * and the default HW context. The default HW context is used by GPU clients |
| 38 | * that do not request setup of their own hardware context. The default |
| 39 | * context's state is never restored to help prevent programming errors. This |
| 40 | * would happen if a client ran and piggy-backed off another clients GPU state. |
| 41 | * The default context only exists to give the GPU some offset to load as the |
| 42 | * current to invoke a save of the context we actually care about. In fact, the |
| 43 | * code could likely be constructed, albeit in a more complicated fashion, to |
| 44 | * never use the default context, though that limits the driver's ability to |
| 45 | * swap out, and/or destroy other contexts. |
| 46 | * |
| 47 | * All other contexts are created as a request by the GPU client. These contexts |
| 48 | * store GPU state, and thus allow GPU clients to not re-emit state (and |
| 49 | * potentially query certain state) at any time. The kernel driver makes |
| 50 | * certain that the appropriate commands are inserted. |
| 51 | * |
| 52 | * The context life cycle is semi-complicated in that context BOs may live |
| 53 | * longer than the context itself because of the way the hardware, and object |
| 54 | * tracking works. Below is a very crude representation of the state machine |
| 55 | * describing the context life. |
| 56 | * refcount pincount active |
| 57 | * S0: initial state 0 0 0 |
| 58 | * S1: context created 1 0 0 |
| 59 | * S2: context is currently running 2 1 X |
| 60 | * S3: GPU referenced, but not current 2 0 1 |
| 61 | * S4: context is current, but destroyed 1 1 0 |
| 62 | * S5: like S3, but destroyed 1 0 1 |
| 63 | * |
| 64 | * The most common (but not all) transitions: |
| 65 | * S0->S1: client creates a context |
| 66 | * S1->S2: client submits execbuf with context |
| 67 | * S2->S3: other clients submits execbuf with context |
| 68 | * S3->S1: context object was retired |
| 69 | * S3->S2: clients submits another execbuf |
| 70 | * S2->S4: context destroy called with current context |
| 71 | * S3->S5->S0: destroy path |
| 72 | * S4->S5->S0: destroy path on current context |
| 73 | * |
| 74 | * There are two confusing terms used above: |
| 75 | * The "current context" means the context which is currently running on the |
Damien Lespiau | 508842a | 2013-08-30 14:40:26 +0100 | [diff] [blame] | 76 | * GPU. The GPU has loaded its state already and has stored away the gtt |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 77 | * offset of the BO. The GPU is not actively referencing the data at this |
| 78 | * offset, but it will on the next context switch. The only way to avoid this |
| 79 | * is to do a GPU reset. |
| 80 | * |
| 81 | * An "active context' is one which was previously the "current context" and is |
| 82 | * on the active list waiting for the next context switch to occur. Until this |
| 83 | * happens, the object must remain at the same gtt offset. It is therefore |
| 84 | * possible to destroy a context, but it is still active. |
| 85 | * |
| 86 | */ |
| 87 | |
Chris Wilson | 4ff4b44 | 2017-06-16 15:05:16 +0100 | [diff] [blame] | 88 | #include <linux/log2.h> |
David Howells | 760285e | 2012-10-02 18:01:07 +0100 | [diff] [blame] | 89 | #include <drm/drmP.h> |
| 90 | #include <drm/i915_drm.h> |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 91 | #include "i915_drv.h" |
Daniele Ceraolo Spurio | 198c974 | 2014-11-10 13:44:31 +0000 | [diff] [blame] | 92 | #include "i915_trace.h" |
Oscar Mateo | 59b449d | 2018-04-10 09:12:47 -0700 | [diff] [blame] | 93 | #include "intel_workarounds.h" |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 94 | |
Chris Wilson | b2e862d | 2016-04-28 09:56:41 +0100 | [diff] [blame] | 95 | #define ALL_L3_SLICES(dev) (1 << NUM_L3_SLICES(dev)) - 1 |
| 96 | |
Chris Wilson | d1b48c1 | 2017-08-16 09:52:08 +0100 | [diff] [blame] | 97 | static void lut_close(struct i915_gem_context *ctx) |
Chris Wilson | 4ff4b44 | 2017-06-16 15:05:16 +0100 | [diff] [blame] | 98 | { |
Chris Wilson | d1b48c1 | 2017-08-16 09:52:08 +0100 | [diff] [blame] | 99 | struct i915_lut_handle *lut, *ln; |
| 100 | struct radix_tree_iter iter; |
| 101 | void __rcu **slot; |
Chris Wilson | 4ff4b44 | 2017-06-16 15:05:16 +0100 | [diff] [blame] | 102 | |
Chris Wilson | d1b48c1 | 2017-08-16 09:52:08 +0100 | [diff] [blame] | 103 | list_for_each_entry_safe(lut, ln, &ctx->handles_list, ctx_link) { |
| 104 | list_del(&lut->obj_link); |
| 105 | kmem_cache_free(ctx->i915->luts, lut); |
Chris Wilson | 4ff4b44 | 2017-06-16 15:05:16 +0100 | [diff] [blame] | 106 | } |
Chris Wilson | 4ff4b44 | 2017-06-16 15:05:16 +0100 | [diff] [blame] | 107 | |
Chris Wilson | 547da76 | 2017-10-26 14:00:32 +0100 | [diff] [blame] | 108 | rcu_read_lock(); |
Chris Wilson | d1b48c1 | 2017-08-16 09:52:08 +0100 | [diff] [blame] | 109 | radix_tree_for_each_slot(slot, &ctx->handles_vma, &iter, 0) { |
| 110 | struct i915_vma *vma = rcu_dereference_raw(*slot); |
Chris Wilson | 4ff4b44 | 2017-06-16 15:05:16 +0100 | [diff] [blame] | 111 | |
Chris Wilson | d1b48c1 | 2017-08-16 09:52:08 +0100 | [diff] [blame] | 112 | radix_tree_iter_delete(&ctx->handles_vma, &iter, slot); |
Chris Wilson | 94dec87 | 2017-11-09 08:55:40 +0000 | [diff] [blame] | 113 | __i915_gem_object_release_unless_active(vma->obj); |
Chris Wilson | 4ff4b44 | 2017-06-16 15:05:16 +0100 | [diff] [blame] | 114 | } |
Chris Wilson | 547da76 | 2017-10-26 14:00:32 +0100 | [diff] [blame] | 115 | rcu_read_unlock(); |
Chris Wilson | 4ff4b44 | 2017-06-16 15:05:16 +0100 | [diff] [blame] | 116 | } |
| 117 | |
Chris Wilson | 5f09a9c | 2017-06-20 12:05:46 +0100 | [diff] [blame] | 118 | static void i915_gem_context_free(struct i915_gem_context *ctx) |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 119 | { |
Chris Wilson | ab82a06 | 2018-04-30 14:15:01 +0100 | [diff] [blame] | 120 | unsigned int n; |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 121 | |
Chris Wilson | 91c8a32 | 2016-07-05 10:40:23 +0100 | [diff] [blame] | 122 | lockdep_assert_held(&ctx->i915->drm.struct_mutex); |
Chris Wilson | 6095868 | 2016-12-31 11:20:11 +0000 | [diff] [blame] | 123 | GEM_BUG_ON(!i915_gem_context_is_closed(ctx)); |
Daniele Ceraolo Spurio | 198c974 | 2014-11-10 13:44:31 +0000 | [diff] [blame] | 124 | |
Daniel Vetter | ae6c480 | 2014-08-06 15:04:53 +0200 | [diff] [blame] | 125 | i915_ppgtt_put(ctx->ppgtt); |
| 126 | |
Chris Wilson | ab82a06 | 2018-04-30 14:15:01 +0100 | [diff] [blame] | 127 | for (n = 0; n < ARRAY_SIZE(ctx->__engine); n++) { |
| 128 | struct intel_context *ce = &ctx->__engine[n]; |
Chris Wilson | bca44d8 | 2016-05-24 14:53:41 +0100 | [diff] [blame] | 129 | |
| 130 | if (!ce->state) |
| 131 | continue; |
| 132 | |
| 133 | WARN_ON(ce->pin_count); |
Chris Wilson | dca33ec | 2016-08-02 22:50:20 +0100 | [diff] [blame] | 134 | if (ce->ring) |
Chris Wilson | 7e37f88 | 2016-08-02 22:50:21 +0100 | [diff] [blame] | 135 | intel_ring_free(ce->ring); |
Chris Wilson | bca44d8 | 2016-05-24 14:53:41 +0100 | [diff] [blame] | 136 | |
Chris Wilson | f8a7fde | 2016-10-28 13:58:29 +0100 | [diff] [blame] | 137 | __i915_gem_object_release_unless_active(ce->state->obj); |
Chris Wilson | bca44d8 | 2016-05-24 14:53:41 +0100 | [diff] [blame] | 138 | } |
| 139 | |
Chris Wilson | 562f5d4 | 2016-10-28 13:58:54 +0100 | [diff] [blame] | 140 | kfree(ctx->name); |
Chris Wilson | c84455b | 2016-08-15 10:49:08 +0100 | [diff] [blame] | 141 | put_pid(ctx->pid); |
Chris Wilson | 4ff4b44 | 2017-06-16 15:05:16 +0100 | [diff] [blame] | 142 | |
Ben Widawsky | c7c48df | 2013-12-06 14:11:15 -0800 | [diff] [blame] | 143 | list_del(&ctx->link); |
Chris Wilson | 5d1808e | 2016-04-28 09:56:51 +0100 | [diff] [blame] | 144 | |
Chris Wilson | 829a0af | 2017-06-20 12:05:45 +0100 | [diff] [blame] | 145 | ida_simple_remove(&ctx->i915->contexts.hw_ida, ctx->hw_id); |
Chris Wilson | 1acfc10 | 2017-06-20 12:05:47 +0100 | [diff] [blame] | 146 | kfree_rcu(ctx, rcu); |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 147 | } |
| 148 | |
Chris Wilson | 5f09a9c | 2017-06-20 12:05:46 +0100 | [diff] [blame] | 149 | static void contexts_free(struct drm_i915_private *i915) |
| 150 | { |
| 151 | struct llist_node *freed = llist_del_all(&i915->contexts.free_list); |
Chris Wilson | fad2083 | 2017-07-01 00:05:17 +0100 | [diff] [blame] | 152 | struct i915_gem_context *ctx, *cn; |
Chris Wilson | 5f09a9c | 2017-06-20 12:05:46 +0100 | [diff] [blame] | 153 | |
| 154 | lockdep_assert_held(&i915->drm.struct_mutex); |
| 155 | |
Chris Wilson | fad2083 | 2017-07-01 00:05:17 +0100 | [diff] [blame] | 156 | llist_for_each_entry_safe(ctx, cn, freed, free_link) |
Chris Wilson | 5f09a9c | 2017-06-20 12:05:46 +0100 | [diff] [blame] | 157 | i915_gem_context_free(ctx); |
| 158 | } |
| 159 | |
Chris Wilson | cb0aeaa | 2017-07-05 15:26:34 +0100 | [diff] [blame] | 160 | static void contexts_free_first(struct drm_i915_private *i915) |
| 161 | { |
| 162 | struct i915_gem_context *ctx; |
| 163 | struct llist_node *freed; |
| 164 | |
| 165 | lockdep_assert_held(&i915->drm.struct_mutex); |
| 166 | |
| 167 | freed = llist_del_first(&i915->contexts.free_list); |
| 168 | if (!freed) |
| 169 | return; |
| 170 | |
| 171 | ctx = container_of(freed, typeof(*ctx), free_link); |
| 172 | i915_gem_context_free(ctx); |
| 173 | } |
| 174 | |
Chris Wilson | 5f09a9c | 2017-06-20 12:05:46 +0100 | [diff] [blame] | 175 | static void contexts_free_worker(struct work_struct *work) |
| 176 | { |
| 177 | struct drm_i915_private *i915 = |
| 178 | container_of(work, typeof(*i915), contexts.free_work); |
| 179 | |
| 180 | mutex_lock(&i915->drm.struct_mutex); |
| 181 | contexts_free(i915); |
| 182 | mutex_unlock(&i915->drm.struct_mutex); |
| 183 | } |
| 184 | |
| 185 | void i915_gem_context_release(struct kref *ref) |
| 186 | { |
| 187 | struct i915_gem_context *ctx = container_of(ref, typeof(*ctx), ref); |
| 188 | struct drm_i915_private *i915 = ctx->i915; |
| 189 | |
| 190 | trace_i915_context_free(ctx); |
| 191 | if (llist_add(&ctx->free_link, &i915->contexts.free_list)) |
| 192 | queue_work(i915->wq, &i915->contexts.free_work); |
| 193 | } |
| 194 | |
Chris Wilson | 50e046b | 2016-08-04 07:52:46 +0100 | [diff] [blame] | 195 | static void context_close(struct i915_gem_context *ctx) |
| 196 | { |
Chris Wilson | 6095868 | 2016-12-31 11:20:11 +0000 | [diff] [blame] | 197 | i915_gem_context_set_closed(ctx); |
Chris Wilson | d1b48c1 | 2017-08-16 09:52:08 +0100 | [diff] [blame] | 198 | |
Chris Wilson | 94dec87 | 2017-11-09 08:55:40 +0000 | [diff] [blame] | 199 | /* |
| 200 | * The LUT uses the VMA as a backpointer to unref the object, |
| 201 | * so we need to clear the LUT before we close all the VMA (inside |
| 202 | * the ppgtt). |
| 203 | */ |
Chris Wilson | d1b48c1 | 2017-08-16 09:52:08 +0100 | [diff] [blame] | 204 | lut_close(ctx); |
Chris Wilson | 50e046b | 2016-08-04 07:52:46 +0100 | [diff] [blame] | 205 | if (ctx->ppgtt) |
| 206 | i915_ppgtt_close(&ctx->ppgtt->base); |
Chris Wilson | d1b48c1 | 2017-08-16 09:52:08 +0100 | [diff] [blame] | 207 | |
Chris Wilson | 50e046b | 2016-08-04 07:52:46 +0100 | [diff] [blame] | 208 | ctx->file_priv = ERR_PTR(-EBADF); |
| 209 | i915_gem_context_put(ctx); |
| 210 | } |
| 211 | |
Chris Wilson | 5d1808e | 2016-04-28 09:56:51 +0100 | [diff] [blame] | 212 | static int assign_hw_id(struct drm_i915_private *dev_priv, unsigned *out) |
| 213 | { |
| 214 | int ret; |
Daniele Ceraolo Spurio | ac52da6 | 2018-03-02 18:14:58 +0200 | [diff] [blame] | 215 | unsigned int max; |
| 216 | |
| 217 | if (INTEL_GEN(dev_priv) >= 11) |
| 218 | max = GEN11_MAX_CONTEXT_HW_ID; |
| 219 | else |
| 220 | max = MAX_CONTEXT_HW_ID; |
Chris Wilson | 5d1808e | 2016-04-28 09:56:51 +0100 | [diff] [blame] | 221 | |
Chris Wilson | 829a0af | 2017-06-20 12:05:45 +0100 | [diff] [blame] | 222 | ret = ida_simple_get(&dev_priv->contexts.hw_ida, |
Daniele Ceraolo Spurio | ac52da6 | 2018-03-02 18:14:58 +0200 | [diff] [blame] | 223 | 0, max, GFP_KERNEL); |
Chris Wilson | 5d1808e | 2016-04-28 09:56:51 +0100 | [diff] [blame] | 224 | if (ret < 0) { |
| 225 | /* Contexts are only released when no longer active. |
| 226 | * Flush any pending retires to hopefully release some |
| 227 | * stale contexts and try again. |
| 228 | */ |
Chris Wilson | e61e0f5 | 2018-02-21 09:56:36 +0000 | [diff] [blame] | 229 | i915_retire_requests(dev_priv); |
Chris Wilson | 829a0af | 2017-06-20 12:05:45 +0100 | [diff] [blame] | 230 | ret = ida_simple_get(&dev_priv->contexts.hw_ida, |
Daniele Ceraolo Spurio | ac52da6 | 2018-03-02 18:14:58 +0200 | [diff] [blame] | 231 | 0, max, GFP_KERNEL); |
Chris Wilson | 5d1808e | 2016-04-28 09:56:51 +0100 | [diff] [blame] | 232 | if (ret < 0) |
| 233 | return ret; |
| 234 | } |
| 235 | |
| 236 | *out = ret; |
| 237 | return 0; |
| 238 | } |
| 239 | |
Chris Wilson | 949e8ab | 2017-02-09 14:40:36 +0000 | [diff] [blame] | 240 | static u32 default_desc_template(const struct drm_i915_private *i915, |
| 241 | const struct i915_hw_ppgtt *ppgtt) |
Mika Kuoppala | 2355cf0 | 2017-01-27 15:03:09 +0200 | [diff] [blame] | 242 | { |
Chris Wilson | 949e8ab | 2017-02-09 14:40:36 +0000 | [diff] [blame] | 243 | u32 address_mode; |
Mika Kuoppala | 2355cf0 | 2017-01-27 15:03:09 +0200 | [diff] [blame] | 244 | u32 desc; |
| 245 | |
Chris Wilson | 949e8ab | 2017-02-09 14:40:36 +0000 | [diff] [blame] | 246 | desc = GEN8_CTX_VALID | GEN8_CTX_PRIVILEGE; |
Mika Kuoppala | 2355cf0 | 2017-01-27 15:03:09 +0200 | [diff] [blame] | 247 | |
Chris Wilson | 949e8ab | 2017-02-09 14:40:36 +0000 | [diff] [blame] | 248 | address_mode = INTEL_LEGACY_32B_CONTEXT; |
| 249 | if (ppgtt && i915_vm_is_48bit(&ppgtt->base)) |
| 250 | address_mode = INTEL_LEGACY_64B_CONTEXT; |
| 251 | desc |= address_mode << GEN8_CTX_ADDRESSING_MODE_SHIFT; |
| 252 | |
| 253 | if (IS_GEN8(i915)) |
Mika Kuoppala | 2355cf0 | 2017-01-27 15:03:09 +0200 | [diff] [blame] | 254 | desc |= GEN8_CTX_L3LLC_COHERENT; |
| 255 | |
| 256 | /* TODO: WaDisableLiteRestore when we start using semaphore |
| 257 | * signalling between Command Streamers |
| 258 | * ring->ctx_desc_template |= GEN8_CTX_FORCE_RESTORE; |
| 259 | */ |
| 260 | |
| 261 | return desc; |
| 262 | } |
| 263 | |
Chris Wilson | e2efd13 | 2016-05-24 14:53:34 +0100 | [diff] [blame] | 264 | static struct i915_gem_context * |
Tvrtko Ursulin | bf9e842 | 2016-12-01 14:16:38 +0000 | [diff] [blame] | 265 | __create_hw_context(struct drm_i915_private *dev_priv, |
Daniel Vetter | ee960be | 2014-08-06 15:04:45 +0200 | [diff] [blame] | 266 | struct drm_i915_file_private *file_priv) |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 267 | { |
Chris Wilson | e2efd13 | 2016-05-24 14:53:34 +0100 | [diff] [blame] | 268 | struct i915_gem_context *ctx; |
Tejun Heo | c8c470a | 2013-02-27 17:04:10 -0800 | [diff] [blame] | 269 | int ret; |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 270 | |
Ben Widawsky | f94982b | 2012-11-10 10:56:04 -0800 | [diff] [blame] | 271 | ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); |
Ben Widawsky | 146937e | 2012-06-29 10:30:39 -0700 | [diff] [blame] | 272 | if (ctx == NULL) |
| 273 | return ERR_PTR(-ENOMEM); |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 274 | |
Chris Wilson | 5d1808e | 2016-04-28 09:56:51 +0100 | [diff] [blame] | 275 | ret = assign_hw_id(dev_priv, &ctx->hw_id); |
| 276 | if (ret) { |
| 277 | kfree(ctx); |
| 278 | return ERR_PTR(ret); |
| 279 | } |
| 280 | |
Mika Kuoppala | dce3271 | 2013-04-30 13:30:33 +0300 | [diff] [blame] | 281 | kref_init(&ctx->ref); |
Chris Wilson | 829a0af | 2017-06-20 12:05:45 +0100 | [diff] [blame] | 282 | list_add_tail(&ctx->link, &dev_priv->contexts.list); |
Chris Wilson | 9ea4fee | 2015-05-05 09:17:29 +0100 | [diff] [blame] | 283 | ctx->i915 = dev_priv; |
Chris Wilson | b7268c5 | 2018-04-18 19:40:52 +0100 | [diff] [blame] | 284 | ctx->sched.priority = I915_PRIORITY_NORMAL; |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 285 | |
Chris Wilson | d1b48c1 | 2017-08-16 09:52:08 +0100 | [diff] [blame] | 286 | INIT_RADIX_TREE(&ctx->handles_vma, GFP_KERNEL); |
| 287 | INIT_LIST_HEAD(&ctx->handles_list); |
Chris Wilson | 4ff4b44 | 2017-06-16 15:05:16 +0100 | [diff] [blame] | 288 | |
Chris Wilson | 691e641 | 2014-04-09 09:07:36 +0100 | [diff] [blame] | 289 | /* Default context will never have a file_priv */ |
Chris Wilson | 562f5d4 | 2016-10-28 13:58:54 +0100 | [diff] [blame] | 290 | ret = DEFAULT_CONTEXT_HANDLE; |
| 291 | if (file_priv) { |
Chris Wilson | 691e641 | 2014-04-09 09:07:36 +0100 | [diff] [blame] | 292 | ret = idr_alloc(&file_priv->context_idr, ctx, |
Oscar Mateo | 821d66d | 2014-07-03 16:28:00 +0100 | [diff] [blame] | 293 | DEFAULT_CONTEXT_HANDLE, 0, GFP_KERNEL); |
Chris Wilson | 691e641 | 2014-04-09 09:07:36 +0100 | [diff] [blame] | 294 | if (ret < 0) |
Chris Wilson | 4ff4b44 | 2017-06-16 15:05:16 +0100 | [diff] [blame] | 295 | goto err_lut; |
Chris Wilson | 562f5d4 | 2016-10-28 13:58:54 +0100 | [diff] [blame] | 296 | } |
| 297 | ctx->user_handle = ret; |
Mika Kuoppala | dce3271 | 2013-04-30 13:30:33 +0300 | [diff] [blame] | 298 | |
| 299 | ctx->file_priv = file_priv; |
Chris Wilson | 562f5d4 | 2016-10-28 13:58:54 +0100 | [diff] [blame] | 300 | if (file_priv) { |
Chris Wilson | c84455b | 2016-08-15 10:49:08 +0100 | [diff] [blame] | 301 | ctx->pid = get_task_pid(current, PIDTYPE_PID); |
Chris Wilson | 562f5d4 | 2016-10-28 13:58:54 +0100 | [diff] [blame] | 302 | ctx->name = kasprintf(GFP_KERNEL, "%s[%d]/%x", |
| 303 | current->comm, |
| 304 | pid_nr(ctx->pid), |
| 305 | ctx->user_handle); |
| 306 | if (!ctx->name) { |
| 307 | ret = -ENOMEM; |
| 308 | goto err_pid; |
| 309 | } |
| 310 | } |
Chris Wilson | c84455b | 2016-08-15 10:49:08 +0100 | [diff] [blame] | 311 | |
Ben Widawsky | 3ccfd19 | 2013-09-18 19:03:18 -0700 | [diff] [blame] | 312 | /* NB: Mark all slices as needing a remap so that when the context first |
| 313 | * loads it will restore whatever remap state already exists. If there |
| 314 | * is no remap info, it will be a NOP. */ |
Chris Wilson | b2e862d | 2016-04-28 09:56:41 +0100 | [diff] [blame] | 315 | ctx->remap_slice = ALL_L3_SLICES(dev_priv); |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 316 | |
Chris Wilson | 6095868 | 2016-12-31 11:20:11 +0000 | [diff] [blame] | 317 | i915_gem_context_set_bannable(ctx); |
Zhi Wang | bcd794c | 2016-06-16 08:07:01 -0400 | [diff] [blame] | 318 | ctx->ring_size = 4 * PAGE_SIZE; |
Chris Wilson | 949e8ab | 2017-02-09 14:40:36 +0000 | [diff] [blame] | 319 | ctx->desc_template = |
| 320 | default_desc_template(dev_priv, dev_priv->mm.aliasing_ppgtt); |
Chris Wilson | 676fa57 | 2014-12-24 08:13:39 -0800 | [diff] [blame] | 321 | |
Jackie Li | 6b0478f | 2018-03-13 17:32:50 -0700 | [diff] [blame] | 322 | /* |
| 323 | * GuC requires the ring to be placed in Non-WOPCM memory. If GuC is not |
Daniele Ceraolo Spurio | d3ef1af | 2016-12-23 15:56:21 -0800 | [diff] [blame] | 324 | * present or not in use we still need a small bias as ring wraparound |
| 325 | * at offset 0 sometimes hangs. No idea why. |
| 326 | */ |
Michal Wajdeczko | 93ffbe8 | 2017-12-06 13:53:12 +0000 | [diff] [blame] | 327 | if (USES_GUC(dev_priv)) |
Jackie Li | 6b0478f | 2018-03-13 17:32:50 -0700 | [diff] [blame] | 328 | ctx->ggtt_offset_bias = dev_priv->guc.ggtt_pin_bias; |
Daniele Ceraolo Spurio | d3ef1af | 2016-12-23 15:56:21 -0800 | [diff] [blame] | 329 | else |
Chris Wilson | f51455d | 2017-01-10 14:47:34 +0000 | [diff] [blame] | 330 | ctx->ggtt_offset_bias = I915_GTT_PAGE_SIZE; |
Daniele Ceraolo Spurio | d3ef1af | 2016-12-23 15:56:21 -0800 | [diff] [blame] | 331 | |
Ben Widawsky | 146937e | 2012-06-29 10:30:39 -0700 | [diff] [blame] | 332 | return ctx; |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 333 | |
Chris Wilson | 562f5d4 | 2016-10-28 13:58:54 +0100 | [diff] [blame] | 334 | err_pid: |
| 335 | put_pid(ctx->pid); |
| 336 | idr_remove(&file_priv->context_idr, ctx->user_handle); |
Chris Wilson | 4ff4b44 | 2017-06-16 15:05:16 +0100 | [diff] [blame] | 337 | err_lut: |
Chris Wilson | 50e046b | 2016-08-04 07:52:46 +0100 | [diff] [blame] | 338 | context_close(ctx); |
Ben Widawsky | 146937e | 2012-06-29 10:30:39 -0700 | [diff] [blame] | 339 | return ERR_PTR(ret); |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 340 | } |
| 341 | |
Joonas Lahtinen | 6d1f9fb | 2017-02-09 13:34:25 +0200 | [diff] [blame] | 342 | static void __destroy_hw_context(struct i915_gem_context *ctx, |
| 343 | struct drm_i915_file_private *file_priv) |
| 344 | { |
| 345 | idr_remove(&file_priv->context_idr, ctx->user_handle); |
| 346 | context_close(ctx); |
| 347 | } |
| 348 | |
Chris Wilson | e2efd13 | 2016-05-24 14:53:34 +0100 | [diff] [blame] | 349 | static struct i915_gem_context * |
Tvrtko Ursulin | bf9e842 | 2016-12-01 14:16:38 +0000 | [diff] [blame] | 350 | i915_gem_create_context(struct drm_i915_private *dev_priv, |
Daniel Vetter | d624d86 | 2014-08-06 15:04:54 +0200 | [diff] [blame] | 351 | struct drm_i915_file_private *file_priv) |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 352 | { |
Chris Wilson | e2efd13 | 2016-05-24 14:53:34 +0100 | [diff] [blame] | 353 | struct i915_gem_context *ctx; |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 354 | |
Tvrtko Ursulin | bf9e842 | 2016-12-01 14:16:38 +0000 | [diff] [blame] | 355 | lockdep_assert_held(&dev_priv->drm.struct_mutex); |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 356 | |
Chris Wilson | cb0aeaa | 2017-07-05 15:26:34 +0100 | [diff] [blame] | 357 | /* Reap the most stale context */ |
| 358 | contexts_free_first(dev_priv); |
Chris Wilson | ddfc925 | 2017-07-05 15:26:32 +0100 | [diff] [blame] | 359 | |
Tvrtko Ursulin | bf9e842 | 2016-12-01 14:16:38 +0000 | [diff] [blame] | 360 | ctx = __create_hw_context(dev_priv, file_priv); |
Ben Widawsky | 146937e | 2012-06-29 10:30:39 -0700 | [diff] [blame] | 361 | if (IS_ERR(ctx)) |
Ben Widawsky | a45d0f6 | 2013-12-06 14:11:05 -0800 | [diff] [blame] | 362 | return ctx; |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 363 | |
Tvrtko Ursulin | bf9e842 | 2016-12-01 14:16:38 +0000 | [diff] [blame] | 364 | if (USES_FULL_PPGTT(dev_priv)) { |
Chris Wilson | 80b204b | 2016-10-28 13:58:58 +0100 | [diff] [blame] | 365 | struct i915_hw_ppgtt *ppgtt; |
Ben Widawsky | bdf4fd7 | 2013-12-06 14:11:18 -0800 | [diff] [blame] | 366 | |
Tvrtko Ursulin | bf9e842 | 2016-12-01 14:16:38 +0000 | [diff] [blame] | 367 | ppgtt = i915_ppgtt_create(dev_priv, file_priv, ctx->name); |
Chris Wilson | c6aab91 | 2016-05-24 14:53:38 +0100 | [diff] [blame] | 368 | if (IS_ERR(ppgtt)) { |
Ben Widawsky | 0eea67e | 2013-12-06 14:11:19 -0800 | [diff] [blame] | 369 | DRM_DEBUG_DRIVER("PPGTT setup failed (%ld)\n", |
| 370 | PTR_ERR(ppgtt)); |
Joonas Lahtinen | 6d1f9fb | 2017-02-09 13:34:25 +0200 | [diff] [blame] | 371 | __destroy_hw_context(ctx, file_priv); |
Chris Wilson | c6aab91 | 2016-05-24 14:53:38 +0100 | [diff] [blame] | 372 | return ERR_CAST(ppgtt); |
Daniel Vetter | ae6c480 | 2014-08-06 15:04:53 +0200 | [diff] [blame] | 373 | } |
| 374 | |
| 375 | ctx->ppgtt = ppgtt; |
Chris Wilson | 949e8ab | 2017-02-09 14:40:36 +0000 | [diff] [blame] | 376 | ctx->desc_template = default_desc_template(dev_priv, ppgtt); |
Daniel Vetter | ae6c480 | 2014-08-06 15:04:53 +0200 | [diff] [blame] | 377 | } |
Ben Widawsky | bdf4fd7 | 2013-12-06 14:11:18 -0800 | [diff] [blame] | 378 | |
Daniele Ceraolo Spurio | 198c974 | 2014-11-10 13:44:31 +0000 | [diff] [blame] | 379 | trace_i915_context_create(ctx); |
| 380 | |
Ben Widawsky | a45d0f6 | 2013-12-06 14:11:05 -0800 | [diff] [blame] | 381 | return ctx; |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 382 | } |
| 383 | |
Zhi Wang | c8c3579 | 2016-06-16 08:07:05 -0400 | [diff] [blame] | 384 | /** |
| 385 | * i915_gem_context_create_gvt - create a GVT GEM context |
| 386 | * @dev: drm device * |
| 387 | * |
| 388 | * This function is used to create a GVT specific GEM context. |
| 389 | * |
| 390 | * Returns: |
| 391 | * pointer to i915_gem_context on success, error pointer if failed |
| 392 | * |
| 393 | */ |
| 394 | struct i915_gem_context * |
| 395 | i915_gem_context_create_gvt(struct drm_device *dev) |
| 396 | { |
| 397 | struct i915_gem_context *ctx; |
| 398 | int ret; |
| 399 | |
| 400 | if (!IS_ENABLED(CONFIG_DRM_I915_GVT)) |
| 401 | return ERR_PTR(-ENODEV); |
| 402 | |
| 403 | ret = i915_mutex_lock_interruptible(dev); |
| 404 | if (ret) |
| 405 | return ERR_PTR(ret); |
| 406 | |
Chris Wilson | 984ff29f | 2017-01-06 15:20:13 +0000 | [diff] [blame] | 407 | ctx = __create_hw_context(to_i915(dev), NULL); |
Zhi Wang | c8c3579 | 2016-06-16 08:07:05 -0400 | [diff] [blame] | 408 | if (IS_ERR(ctx)) |
| 409 | goto out; |
| 410 | |
Chris Wilson | 984ff29f | 2017-01-06 15:20:13 +0000 | [diff] [blame] | 411 | ctx->file_priv = ERR_PTR(-EBADF); |
Chris Wilson | 6095868 | 2016-12-31 11:20:11 +0000 | [diff] [blame] | 412 | i915_gem_context_set_closed(ctx); /* not user accessible */ |
| 413 | i915_gem_context_clear_bannable(ctx); |
| 414 | i915_gem_context_set_force_single_submission(ctx); |
Michal Wajdeczko | 93ffbe8 | 2017-12-06 13:53:12 +0000 | [diff] [blame] | 415 | if (!USES_GUC_SUBMISSION(to_i915(dev))) |
Chuanxiao Dong | 718e884 | 2017-02-16 14:36:40 +0800 | [diff] [blame] | 416 | ctx->ring_size = 512 * PAGE_SIZE; /* Max ring buffer size */ |
Chris Wilson | 984ff29f | 2017-01-06 15:20:13 +0000 | [diff] [blame] | 417 | |
| 418 | GEM_BUG_ON(i915_gem_context_is_kernel(ctx)); |
Zhi Wang | c8c3579 | 2016-06-16 08:07:05 -0400 | [diff] [blame] | 419 | out: |
| 420 | mutex_unlock(&dev->struct_mutex); |
| 421 | return ctx; |
| 422 | } |
| 423 | |
Chris Wilson | d2b4b97 | 2017-11-10 14:26:33 +0000 | [diff] [blame] | 424 | struct i915_gem_context * |
| 425 | i915_gem_context_create_kernel(struct drm_i915_private *i915, int prio) |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 426 | { |
Chris Wilson | e2efd13 | 2016-05-24 14:53:34 +0100 | [diff] [blame] | 427 | struct i915_gem_context *ctx; |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 428 | |
Chris Wilson | e7af311 | 2017-10-03 21:34:48 +0100 | [diff] [blame] | 429 | ctx = i915_gem_create_context(i915, NULL); |
| 430 | if (IS_ERR(ctx)) |
| 431 | return ctx; |
| 432 | |
| 433 | i915_gem_context_clear_bannable(ctx); |
Chris Wilson | b7268c5 | 2018-04-18 19:40:52 +0100 | [diff] [blame] | 434 | ctx->sched.priority = prio; |
Chris Wilson | e7af311 | 2017-10-03 21:34:48 +0100 | [diff] [blame] | 435 | ctx->ring_size = PAGE_SIZE; |
| 436 | |
| 437 | GEM_BUG_ON(!i915_gem_context_is_kernel(ctx)); |
| 438 | |
| 439 | return ctx; |
| 440 | } |
| 441 | |
| 442 | static void |
| 443 | destroy_kernel_context(struct i915_gem_context **ctxp) |
| 444 | { |
| 445 | struct i915_gem_context *ctx; |
| 446 | |
| 447 | /* Keep the context ref so that we can free it immediately ourselves */ |
| 448 | ctx = i915_gem_context_get(fetch_and_zero(ctxp)); |
| 449 | GEM_BUG_ON(!i915_gem_context_is_kernel(ctx)); |
| 450 | |
| 451 | context_close(ctx); |
| 452 | i915_gem_context_free(ctx); |
| 453 | } |
| 454 | |
Chris Wilson | d637637 | 2018-02-07 21:05:44 +0000 | [diff] [blame] | 455 | static bool needs_preempt_context(struct drm_i915_private *i915) |
| 456 | { |
| 457 | return HAS_LOGICAL_RING_PREEMPTION(i915); |
| 458 | } |
| 459 | |
Chris Wilson | e7af311 | 2017-10-03 21:34:48 +0100 | [diff] [blame] | 460 | int i915_gem_contexts_init(struct drm_i915_private *dev_priv) |
| 461 | { |
| 462 | struct i915_gem_context *ctx; |
Oscar Mateo | 59b449d | 2018-04-10 09:12:47 -0700 | [diff] [blame] | 463 | int ret; |
Chris Wilson | e7af311 | 2017-10-03 21:34:48 +0100 | [diff] [blame] | 464 | |
Chris Wilson | d637637 | 2018-02-07 21:05:44 +0000 | [diff] [blame] | 465 | /* Reassure ourselves we are only called once */ |
Chris Wilson | e7af311 | 2017-10-03 21:34:48 +0100 | [diff] [blame] | 466 | GEM_BUG_ON(dev_priv->kernel_context); |
Chris Wilson | d637637 | 2018-02-07 21:05:44 +0000 | [diff] [blame] | 467 | GEM_BUG_ON(dev_priv->preempt_context); |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 468 | |
Oscar Mateo | 59b449d | 2018-04-10 09:12:47 -0700 | [diff] [blame] | 469 | ret = intel_ctx_workarounds_init(dev_priv); |
| 470 | if (ret) |
| 471 | return ret; |
| 472 | |
Chris Wilson | 829a0af | 2017-06-20 12:05:45 +0100 | [diff] [blame] | 473 | INIT_LIST_HEAD(&dev_priv->contexts.list); |
Chris Wilson | 5f09a9c | 2017-06-20 12:05:46 +0100 | [diff] [blame] | 474 | INIT_WORK(&dev_priv->contexts.free_work, contexts_free_worker); |
| 475 | init_llist_head(&dev_priv->contexts.free_list); |
Chris Wilson | 829a0af | 2017-06-20 12:05:45 +0100 | [diff] [blame] | 476 | |
Chris Wilson | 5d1808e | 2016-04-28 09:56:51 +0100 | [diff] [blame] | 477 | /* Using the simple ida interface, the max is limited by sizeof(int) */ |
| 478 | BUILD_BUG_ON(MAX_CONTEXT_HW_ID > INT_MAX); |
Daniele Ceraolo Spurio | ac52da6 | 2018-03-02 18:14:58 +0200 | [diff] [blame] | 479 | BUILD_BUG_ON(GEN11_MAX_CONTEXT_HW_ID > INT_MAX); |
Chris Wilson | 829a0af | 2017-06-20 12:05:45 +0100 | [diff] [blame] | 480 | ida_init(&dev_priv->contexts.hw_ida); |
Chris Wilson | 5d1808e | 2016-04-28 09:56:51 +0100 | [diff] [blame] | 481 | |
Chris Wilson | e7af311 | 2017-10-03 21:34:48 +0100 | [diff] [blame] | 482 | /* lowest priority; idle task */ |
Chris Wilson | d2b4b97 | 2017-11-10 14:26:33 +0000 | [diff] [blame] | 483 | ctx = i915_gem_context_create_kernel(dev_priv, I915_PRIORITY_MIN); |
Chris Wilson | 691e641 | 2014-04-09 09:07:36 +0100 | [diff] [blame] | 484 | if (IS_ERR(ctx)) { |
Chris Wilson | e7af311 | 2017-10-03 21:34:48 +0100 | [diff] [blame] | 485 | DRM_ERROR("Failed to create default global context\n"); |
Chris Wilson | d637637 | 2018-02-07 21:05:44 +0000 | [diff] [blame] | 486 | return PTR_ERR(ctx); |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 487 | } |
Chris Wilson | e7af311 | 2017-10-03 21:34:48 +0100 | [diff] [blame] | 488 | /* |
| 489 | * For easy recognisablity, we want the kernel context to be 0 and then |
Chris Wilson | 5d12fce | 2017-01-23 11:31:31 +0000 | [diff] [blame] | 490 | * all user contexts will have non-zero hw_id. |
| 491 | */ |
| 492 | GEM_BUG_ON(ctx->hw_id); |
Dave Gordon | ed54c1a | 2016-01-19 19:02:54 +0000 | [diff] [blame] | 493 | dev_priv->kernel_context = ctx; |
Oscar Mateo | ede7d42 | 2014-07-24 17:04:12 +0100 | [diff] [blame] | 494 | |
Chris Wilson | e7af311 | 2017-10-03 21:34:48 +0100 | [diff] [blame] | 495 | /* highest priority; preempting task */ |
Chris Wilson | d637637 | 2018-02-07 21:05:44 +0000 | [diff] [blame] | 496 | if (needs_preempt_context(dev_priv)) { |
| 497 | ctx = i915_gem_context_create_kernel(dev_priv, INT_MAX); |
| 498 | if (!IS_ERR(ctx)) |
| 499 | dev_priv->preempt_context = ctx; |
| 500 | else |
| 501 | DRM_ERROR("Failed to create preempt context; disabling preemption\n"); |
Chris Wilson | e7af311 | 2017-10-03 21:34:48 +0100 | [diff] [blame] | 502 | } |
Chris Wilson | 984ff29f | 2017-01-06 15:20:13 +0000 | [diff] [blame] | 503 | |
Oscar Mateo | ede7d42 | 2014-07-24 17:04:12 +0100 | [diff] [blame] | 504 | DRM_DEBUG_DRIVER("%s context support initialized\n", |
Joonas Lahtinen | 63ffbcd | 2017-04-28 10:53:36 +0300 | [diff] [blame] | 505 | dev_priv->engine[RCS]->context_size ? "logical" : |
| 506 | "fake"); |
Ben Widawsky | 8245be3 | 2013-11-06 13:56:29 -0200 | [diff] [blame] | 507 | return 0; |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 508 | } |
| 509 | |
Chris Wilson | 829a0af | 2017-06-20 12:05:45 +0100 | [diff] [blame] | 510 | void i915_gem_contexts_lost(struct drm_i915_private *dev_priv) |
Chris Wilson | b2e862d | 2016-04-28 09:56:41 +0100 | [diff] [blame] | 511 | { |
| 512 | struct intel_engine_cs *engine; |
Akash Goel | 3b3f165 | 2016-10-13 22:44:48 +0530 | [diff] [blame] | 513 | enum intel_engine_id id; |
Chris Wilson | b2e862d | 2016-04-28 09:56:41 +0100 | [diff] [blame] | 514 | |
Chris Wilson | 91c8a32 | 2016-07-05 10:40:23 +0100 | [diff] [blame] | 515 | lockdep_assert_held(&dev_priv->drm.struct_mutex); |
Chris Wilson | 499f269 | 2016-05-24 14:53:35 +0100 | [diff] [blame] | 516 | |
Akash Goel | 3b3f165 | 2016-10-13 22:44:48 +0530 | [diff] [blame] | 517 | for_each_engine(engine, dev_priv, id) { |
Chris Wilson | e8a9c58 | 2016-12-18 15:37:20 +0000 | [diff] [blame] | 518 | engine->legacy_active_context = NULL; |
Chris Wilson | b1c24a6 | 2017-11-23 15:26:30 +0000 | [diff] [blame] | 519 | engine->legacy_active_ppgtt = NULL; |
Chris Wilson | e8a9c58 | 2016-12-18 15:37:20 +0000 | [diff] [blame] | 520 | |
| 521 | if (!engine->last_retired_context) |
| 522 | continue; |
| 523 | |
Chris Wilson | ab82a06 | 2018-04-30 14:15:01 +0100 | [diff] [blame] | 524 | intel_context_unpin(engine->last_retired_context, engine); |
Chris Wilson | e8a9c58 | 2016-12-18 15:37:20 +0000 | [diff] [blame] | 525 | engine->last_retired_context = NULL; |
Chris Wilson | b2e862d | 2016-04-28 09:56:41 +0100 | [diff] [blame] | 526 | } |
Chris Wilson | b2e862d | 2016-04-28 09:56:41 +0100 | [diff] [blame] | 527 | } |
| 528 | |
Chris Wilson | 5f09a9c | 2017-06-20 12:05:46 +0100 | [diff] [blame] | 529 | void i915_gem_contexts_fini(struct drm_i915_private *i915) |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 530 | { |
Chris Wilson | 5f09a9c | 2017-06-20 12:05:46 +0100 | [diff] [blame] | 531 | lockdep_assert_held(&i915->drm.struct_mutex); |
Chris Wilson | 499f269 | 2016-05-24 14:53:35 +0100 | [diff] [blame] | 532 | |
Chris Wilson | d637637 | 2018-02-07 21:05:44 +0000 | [diff] [blame] | 533 | if (i915->preempt_context) |
| 534 | destroy_kernel_context(&i915->preempt_context); |
Chris Wilson | e7af311 | 2017-10-03 21:34:48 +0100 | [diff] [blame] | 535 | destroy_kernel_context(&i915->kernel_context); |
Chris Wilson | 984ff29f | 2017-01-06 15:20:13 +0000 | [diff] [blame] | 536 | |
Chris Wilson | 5f09a9c | 2017-06-20 12:05:46 +0100 | [diff] [blame] | 537 | /* Must free all deferred contexts (via flush_workqueue) first */ |
| 538 | ida_destroy(&i915->contexts.hw_ida); |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 539 | } |
| 540 | |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 541 | static int context_idr_cleanup(int id, void *p, void *data) |
| 542 | { |
Chris Wilson | e2efd13 | 2016-05-24 14:53:34 +0100 | [diff] [blame] | 543 | struct i915_gem_context *ctx = p; |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 544 | |
Chris Wilson | 50e046b | 2016-08-04 07:52:46 +0100 | [diff] [blame] | 545 | context_close(ctx); |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 546 | return 0; |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 547 | } |
| 548 | |
Chris Wilson | 829a0af | 2017-06-20 12:05:45 +0100 | [diff] [blame] | 549 | int i915_gem_context_open(struct drm_i915_private *i915, |
| 550 | struct drm_file *file) |
Ben Widawsky | e422b88 | 2013-12-06 14:10:58 -0800 | [diff] [blame] | 551 | { |
| 552 | struct drm_i915_file_private *file_priv = file->driver_priv; |
Chris Wilson | e2efd13 | 2016-05-24 14:53:34 +0100 | [diff] [blame] | 553 | struct i915_gem_context *ctx; |
Ben Widawsky | e422b88 | 2013-12-06 14:10:58 -0800 | [diff] [blame] | 554 | |
| 555 | idr_init(&file_priv->context_idr); |
| 556 | |
Chris Wilson | 829a0af | 2017-06-20 12:05:45 +0100 | [diff] [blame] | 557 | mutex_lock(&i915->drm.struct_mutex); |
| 558 | ctx = i915_gem_create_context(i915, file_priv); |
| 559 | mutex_unlock(&i915->drm.struct_mutex); |
Oscar Mateo | f83d651 | 2014-05-22 14:13:38 +0100 | [diff] [blame] | 560 | if (IS_ERR(ctx)) { |
Ben Widawsky | 0eea67e | 2013-12-06 14:11:19 -0800 | [diff] [blame] | 561 | idr_destroy(&file_priv->context_idr); |
Oscar Mateo | f83d651 | 2014-05-22 14:13:38 +0100 | [diff] [blame] | 562 | return PTR_ERR(ctx); |
Ben Widawsky | 0eea67e | 2013-12-06 14:11:19 -0800 | [diff] [blame] | 563 | } |
| 564 | |
Chris Wilson | e4d5dc2 | 2017-07-05 15:26:31 +0100 | [diff] [blame] | 565 | GEM_BUG_ON(i915_gem_context_is_kernel(ctx)); |
| 566 | |
Ben Widawsky | e422b88 | 2013-12-06 14:10:58 -0800 | [diff] [blame] | 567 | return 0; |
| 568 | } |
| 569 | |
Chris Wilson | 829a0af | 2017-06-20 12:05:45 +0100 | [diff] [blame] | 570 | void i915_gem_context_close(struct drm_file *file) |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 571 | { |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 572 | struct drm_i915_file_private *file_priv = file->driver_priv; |
Ben Widawsky | 254f965 | 2012-06-04 14:42:42 -0700 | [diff] [blame] | 573 | |
Chris Wilson | 829a0af | 2017-06-20 12:05:45 +0100 | [diff] [blame] | 574 | lockdep_assert_held(&file_priv->dev_priv->drm.struct_mutex); |
Chris Wilson | 499f269 | 2016-05-24 14:53:35 +0100 | [diff] [blame] | 575 | |
Daniel Vetter | 73c273e | 2012-06-19 20:27:39 +0200 | [diff] [blame] | 576 | idr_for_each(&file_priv->context_idr, context_idr_cleanup, NULL); |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 577 | idr_destroy(&file_priv->context_idr); |
Ben Widawsky | 4052105 | 2012-06-04 14:42:43 -0700 | [diff] [blame] | 578 | } |
| 579 | |
Chris Wilson | a89d1f9 | 2018-05-02 17:38:39 +0100 | [diff] [blame] | 580 | static struct i915_request * |
| 581 | last_request_on_engine(struct i915_timeline *timeline, |
| 582 | struct intel_engine_cs *engine) |
| 583 | { |
| 584 | struct i915_request *rq; |
| 585 | |
| 586 | if (timeline == &engine->timeline) |
| 587 | return NULL; |
| 588 | |
| 589 | rq = i915_gem_active_raw(&timeline->last_request, |
| 590 | &engine->i915->drm.struct_mutex); |
| 591 | if (rq && rq->engine == engine) |
| 592 | return rq; |
| 593 | |
| 594 | return NULL; |
| 595 | } |
| 596 | |
Chris Wilson | 20ccd4d | 2017-10-24 23:08:55 +0100 | [diff] [blame] | 597 | static bool engine_has_idle_kernel_context(struct intel_engine_cs *engine) |
Chris Wilson | f131e35 | 2016-12-29 14:40:37 +0000 | [diff] [blame] | 598 | { |
Chris Wilson | a89d1f9 | 2018-05-02 17:38:39 +0100 | [diff] [blame] | 599 | struct i915_timeline *timeline; |
Chris Wilson | f131e35 | 2016-12-29 14:40:37 +0000 | [diff] [blame] | 600 | |
| 601 | list_for_each_entry(timeline, &engine->i915->gt.timelines, link) { |
Chris Wilson | a89d1f9 | 2018-05-02 17:38:39 +0100 | [diff] [blame] | 602 | if (last_request_on_engine(timeline, engine)) |
Chris Wilson | f131e35 | 2016-12-29 14:40:37 +0000 | [diff] [blame] | 603 | return false; |
| 604 | } |
| 605 | |
Chris Wilson | 20ccd4d | 2017-10-24 23:08:55 +0100 | [diff] [blame] | 606 | return intel_engine_has_kernel_context(engine); |
Chris Wilson | f131e35 | 2016-12-29 14:40:37 +0000 | [diff] [blame] | 607 | } |
| 608 | |
Chris Wilson | 945657b | 2016-07-15 14:56:19 +0100 | [diff] [blame] | 609 | int i915_gem_switch_to_kernel_context(struct drm_i915_private *dev_priv) |
| 610 | { |
| 611 | struct intel_engine_cs *engine; |
Chris Wilson | a89d1f9 | 2018-05-02 17:38:39 +0100 | [diff] [blame] | 612 | struct i915_timeline *timeline; |
Akash Goel | 3b3f165 | 2016-10-13 22:44:48 +0530 | [diff] [blame] | 613 | enum intel_engine_id id; |
Chris Wilson | 945657b | 2016-07-15 14:56:19 +0100 | [diff] [blame] | 614 | |
Chris Wilson | 3033aca | 2016-10-28 13:58:47 +0100 | [diff] [blame] | 615 | lockdep_assert_held(&dev_priv->drm.struct_mutex); |
| 616 | |
Chris Wilson | e61e0f5 | 2018-02-21 09:56:36 +0000 | [diff] [blame] | 617 | i915_retire_requests(dev_priv); |
Chris Wilson | f131e35 | 2016-12-29 14:40:37 +0000 | [diff] [blame] | 618 | |
Akash Goel | 3b3f165 | 2016-10-13 22:44:48 +0530 | [diff] [blame] | 619 | for_each_engine(engine, dev_priv, id) { |
Chris Wilson | e61e0f5 | 2018-02-21 09:56:36 +0000 | [diff] [blame] | 620 | struct i915_request *rq; |
Chris Wilson | 945657b | 2016-07-15 14:56:19 +0100 | [diff] [blame] | 621 | |
Chris Wilson | 20ccd4d | 2017-10-24 23:08:55 +0100 | [diff] [blame] | 622 | if (engine_has_idle_kernel_context(engine)) |
Chris Wilson | f131e35 | 2016-12-29 14:40:37 +0000 | [diff] [blame] | 623 | continue; |
| 624 | |
Chris Wilson | e61e0f5 | 2018-02-21 09:56:36 +0000 | [diff] [blame] | 625 | rq = i915_request_alloc(engine, dev_priv->kernel_context); |
| 626 | if (IS_ERR(rq)) |
| 627 | return PTR_ERR(rq); |
Chris Wilson | 945657b | 2016-07-15 14:56:19 +0100 | [diff] [blame] | 628 | |
Chris Wilson | 3033aca | 2016-10-28 13:58:47 +0100 | [diff] [blame] | 629 | /* Queue this switch after all other activity */ |
| 630 | list_for_each_entry(timeline, &dev_priv->gt.timelines, link) { |
Chris Wilson | e61e0f5 | 2018-02-21 09:56:36 +0000 | [diff] [blame] | 631 | struct i915_request *prev; |
Chris Wilson | 3033aca | 2016-10-28 13:58:47 +0100 | [diff] [blame] | 632 | |
Chris Wilson | a89d1f9 | 2018-05-02 17:38:39 +0100 | [diff] [blame] | 633 | prev = last_request_on_engine(timeline, engine); |
Chris Wilson | 3033aca | 2016-10-28 13:58:47 +0100 | [diff] [blame] | 634 | if (prev) |
Chris Wilson | e61e0f5 | 2018-02-21 09:56:36 +0000 | [diff] [blame] | 635 | i915_sw_fence_await_sw_fence_gfp(&rq->submit, |
Chris Wilson | 3033aca | 2016-10-28 13:58:47 +0100 | [diff] [blame] | 636 | &prev->submit, |
Chris Wilson | 2abe2f8 | 2017-12-12 18:06:51 +0000 | [diff] [blame] | 637 | I915_FENCE_GFP); |
Chris Wilson | 3033aca | 2016-10-28 13:58:47 +0100 | [diff] [blame] | 638 | } |
| 639 | |
Chris Wilson | c82297f | 2017-11-26 21:48:56 +0000 | [diff] [blame] | 640 | /* |
| 641 | * Force a flush after the switch to ensure that all rendering |
| 642 | * and operations prior to switching to the kernel context hits |
| 643 | * memory. This should be guaranteed by the previous request, |
| 644 | * but an extra layer of paranoia before we declare the system |
| 645 | * idle (on suspend etc) is advisable! |
| 646 | */ |
Chris Wilson | e61e0f5 | 2018-02-21 09:56:36 +0000 | [diff] [blame] | 647 | __i915_request_add(rq, true); |
Chris Wilson | 945657b | 2016-07-15 14:56:19 +0100 | [diff] [blame] | 648 | } |
| 649 | |
| 650 | return 0; |
| 651 | } |
| 652 | |
Mika Kuoppala | b083a08 | 2016-11-18 15:10:47 +0200 | [diff] [blame] | 653 | static bool client_is_banned(struct drm_i915_file_private *file_priv) |
| 654 | { |
Chris Wilson | 77b25a9 | 2017-07-21 13:32:30 +0100 | [diff] [blame] | 655 | return atomic_read(&file_priv->context_bans) > I915_MAX_CLIENT_CONTEXT_BANS; |
Mika Kuoppala | b083a08 | 2016-11-18 15:10:47 +0200 | [diff] [blame] | 656 | } |
| 657 | |
Ben Widawsky | 8462481 | 2012-06-04 14:42:54 -0700 | [diff] [blame] | 658 | int i915_gem_context_create_ioctl(struct drm_device *dev, void *data, |
| 659 | struct drm_file *file) |
| 660 | { |
Joonas Lahtinen | 63ffbcd | 2017-04-28 10:53:36 +0300 | [diff] [blame] | 661 | struct drm_i915_private *dev_priv = to_i915(dev); |
Ben Widawsky | 8462481 | 2012-06-04 14:42:54 -0700 | [diff] [blame] | 662 | struct drm_i915_gem_context_create *args = data; |
| 663 | struct drm_i915_file_private *file_priv = file->driver_priv; |
Chris Wilson | e2efd13 | 2016-05-24 14:53:34 +0100 | [diff] [blame] | 664 | struct i915_gem_context *ctx; |
Ben Widawsky | 8462481 | 2012-06-04 14:42:54 -0700 | [diff] [blame] | 665 | int ret; |
| 666 | |
Joonas Lahtinen | 63ffbcd | 2017-04-28 10:53:36 +0300 | [diff] [blame] | 667 | if (!dev_priv->engine[RCS]->context_size) |
Daniel Vetter | 5fa8be6 | 2012-06-19 17:16:01 +0200 | [diff] [blame] | 668 | return -ENODEV; |
| 669 | |
Chris Wilson | b31e513 | 2016-02-05 16:45:59 +0000 | [diff] [blame] | 670 | if (args->pad != 0) |
| 671 | return -EINVAL; |
| 672 | |
Mika Kuoppala | b083a08 | 2016-11-18 15:10:47 +0200 | [diff] [blame] | 673 | if (client_is_banned(file_priv)) { |
| 674 | DRM_DEBUG("client %s[%d] banned from creating ctx\n", |
| 675 | current->comm, |
| 676 | pid_nr(get_task_pid(current, PIDTYPE_PID))); |
| 677 | |
| 678 | return -EIO; |
| 679 | } |
| 680 | |
Ben Widawsky | 8462481 | 2012-06-04 14:42:54 -0700 | [diff] [blame] | 681 | ret = i915_mutex_lock_interruptible(dev); |
| 682 | if (ret) |
| 683 | return ret; |
| 684 | |
Joonas Lahtinen | 63ffbcd | 2017-04-28 10:53:36 +0300 | [diff] [blame] | 685 | ctx = i915_gem_create_context(dev_priv, file_priv); |
Ben Widawsky | 8462481 | 2012-06-04 14:42:54 -0700 | [diff] [blame] | 686 | mutex_unlock(&dev->struct_mutex); |
Dan Carpenter | be63638 | 2012-07-17 09:44:49 +0300 | [diff] [blame] | 687 | if (IS_ERR(ctx)) |
| 688 | return PTR_ERR(ctx); |
Ben Widawsky | 8462481 | 2012-06-04 14:42:54 -0700 | [diff] [blame] | 689 | |
Chris Wilson | 984ff29f | 2017-01-06 15:20:13 +0000 | [diff] [blame] | 690 | GEM_BUG_ON(i915_gem_context_is_kernel(ctx)); |
| 691 | |
Oscar Mateo | 821d66d | 2014-07-03 16:28:00 +0100 | [diff] [blame] | 692 | args->ctx_id = ctx->user_handle; |
Chris Wilson | b84cf53 | 2016-11-21 11:31:09 +0000 | [diff] [blame] | 693 | DRM_DEBUG("HW context %d created\n", args->ctx_id); |
Ben Widawsky | 8462481 | 2012-06-04 14:42:54 -0700 | [diff] [blame] | 694 | |
Dan Carpenter | be63638 | 2012-07-17 09:44:49 +0300 | [diff] [blame] | 695 | return 0; |
Ben Widawsky | 8462481 | 2012-06-04 14:42:54 -0700 | [diff] [blame] | 696 | } |
| 697 | |
| 698 | int i915_gem_context_destroy_ioctl(struct drm_device *dev, void *data, |
| 699 | struct drm_file *file) |
| 700 | { |
| 701 | struct drm_i915_gem_context_destroy *args = data; |
| 702 | struct drm_i915_file_private *file_priv = file->driver_priv; |
Chris Wilson | e2efd13 | 2016-05-24 14:53:34 +0100 | [diff] [blame] | 703 | struct i915_gem_context *ctx; |
Ben Widawsky | 8462481 | 2012-06-04 14:42:54 -0700 | [diff] [blame] | 704 | int ret; |
| 705 | |
Chris Wilson | b31e513 | 2016-02-05 16:45:59 +0000 | [diff] [blame] | 706 | if (args->pad != 0) |
| 707 | return -EINVAL; |
| 708 | |
Oscar Mateo | 821d66d | 2014-07-03 16:28:00 +0100 | [diff] [blame] | 709 | if (args->ctx_id == DEFAULT_CONTEXT_HANDLE) |
Ben Widawsky | c2cf241 | 2013-12-24 16:02:54 -0800 | [diff] [blame] | 710 | return -ENOENT; |
Ben Widawsky | 0eea67e | 2013-12-06 14:11:19 -0800 | [diff] [blame] | 711 | |
Chris Wilson | ca585b5 | 2016-05-24 14:53:36 +0100 | [diff] [blame] | 712 | ctx = i915_gem_context_lookup(file_priv, args->ctx_id); |
Chris Wilson | 1acfc10 | 2017-06-20 12:05:47 +0100 | [diff] [blame] | 713 | if (!ctx) |
| 714 | return -ENOENT; |
| 715 | |
| 716 | ret = mutex_lock_interruptible(&dev->struct_mutex); |
| 717 | if (ret) |
| 718 | goto out; |
Ben Widawsky | 8462481 | 2012-06-04 14:42:54 -0700 | [diff] [blame] | 719 | |
Joonas Lahtinen | 6d1f9fb | 2017-02-09 13:34:25 +0200 | [diff] [blame] | 720 | __destroy_hw_context(ctx, file_priv); |
Ben Widawsky | 8462481 | 2012-06-04 14:42:54 -0700 | [diff] [blame] | 721 | mutex_unlock(&dev->struct_mutex); |
| 722 | |
Chris Wilson | 1acfc10 | 2017-06-20 12:05:47 +0100 | [diff] [blame] | 723 | out: |
| 724 | i915_gem_context_put(ctx); |
Ben Widawsky | 8462481 | 2012-06-04 14:42:54 -0700 | [diff] [blame] | 725 | return 0; |
| 726 | } |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 727 | |
| 728 | int i915_gem_context_getparam_ioctl(struct drm_device *dev, void *data, |
| 729 | struct drm_file *file) |
| 730 | { |
| 731 | struct drm_i915_file_private *file_priv = file->driver_priv; |
| 732 | struct drm_i915_gem_context_param *args = data; |
Chris Wilson | e2efd13 | 2016-05-24 14:53:34 +0100 | [diff] [blame] | 733 | struct i915_gem_context *ctx; |
Chris Wilson | 1acfc10 | 2017-06-20 12:05:47 +0100 | [diff] [blame] | 734 | int ret = 0; |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 735 | |
Chris Wilson | ca585b5 | 2016-05-24 14:53:36 +0100 | [diff] [blame] | 736 | ctx = i915_gem_context_lookup(file_priv, args->ctx_id); |
Chris Wilson | 1acfc10 | 2017-06-20 12:05:47 +0100 | [diff] [blame] | 737 | if (!ctx) |
| 738 | return -ENOENT; |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 739 | |
| 740 | args->size = 0; |
| 741 | switch (args->param) { |
| 742 | case I915_CONTEXT_PARAM_BAN_PERIOD: |
Mika Kuoppala | 8410217 | 2016-11-16 17:20:32 +0200 | [diff] [blame] | 743 | ret = -EINVAL; |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 744 | break; |
David Weinehall | b1b3827 | 2015-05-20 17:00:13 +0300 | [diff] [blame] | 745 | case I915_CONTEXT_PARAM_NO_ZEROMAP: |
| 746 | args->value = ctx->flags & CONTEXT_NO_ZEROMAP; |
| 747 | break; |
Chris Wilson | fa8848f | 2015-10-14 14:17:11 +0100 | [diff] [blame] | 748 | case I915_CONTEXT_PARAM_GTT_SIZE: |
| 749 | if (ctx->ppgtt) |
| 750 | args->value = ctx->ppgtt->base.total; |
| 751 | else if (to_i915(dev)->mm.aliasing_ppgtt) |
| 752 | args->value = to_i915(dev)->mm.aliasing_ppgtt->base.total; |
| 753 | else |
Joonas Lahtinen | 62106b4 | 2016-03-18 10:42:57 +0200 | [diff] [blame] | 754 | args->value = to_i915(dev)->ggtt.base.total; |
Chris Wilson | fa8848f | 2015-10-14 14:17:11 +0100 | [diff] [blame] | 755 | break; |
Chris Wilson | bc3d674 | 2016-07-04 08:08:39 +0100 | [diff] [blame] | 756 | case I915_CONTEXT_PARAM_NO_ERROR_CAPTURE: |
Chris Wilson | 6095868 | 2016-12-31 11:20:11 +0000 | [diff] [blame] | 757 | args->value = i915_gem_context_no_error_capture(ctx); |
Chris Wilson | bc3d674 | 2016-07-04 08:08:39 +0100 | [diff] [blame] | 758 | break; |
Mika Kuoppala | 8410217 | 2016-11-16 17:20:32 +0200 | [diff] [blame] | 759 | case I915_CONTEXT_PARAM_BANNABLE: |
Chris Wilson | 6095868 | 2016-12-31 11:20:11 +0000 | [diff] [blame] | 760 | args->value = i915_gem_context_is_bannable(ctx); |
Mika Kuoppala | 8410217 | 2016-11-16 17:20:32 +0200 | [diff] [blame] | 761 | break; |
Chris Wilson | ac14fbd | 2017-10-03 21:34:53 +0100 | [diff] [blame] | 762 | case I915_CONTEXT_PARAM_PRIORITY: |
Chris Wilson | b7268c5 | 2018-04-18 19:40:52 +0100 | [diff] [blame] | 763 | args->value = ctx->sched.priority; |
Chris Wilson | ac14fbd | 2017-10-03 21:34:53 +0100 | [diff] [blame] | 764 | break; |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 765 | default: |
| 766 | ret = -EINVAL; |
| 767 | break; |
| 768 | } |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 769 | |
Chris Wilson | 1acfc10 | 2017-06-20 12:05:47 +0100 | [diff] [blame] | 770 | i915_gem_context_put(ctx); |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 771 | return ret; |
| 772 | } |
| 773 | |
| 774 | int i915_gem_context_setparam_ioctl(struct drm_device *dev, void *data, |
| 775 | struct drm_file *file) |
| 776 | { |
| 777 | struct drm_i915_file_private *file_priv = file->driver_priv; |
| 778 | struct drm_i915_gem_context_param *args = data; |
Chris Wilson | e2efd13 | 2016-05-24 14:53:34 +0100 | [diff] [blame] | 779 | struct i915_gem_context *ctx; |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 780 | int ret; |
| 781 | |
Chris Wilson | 1acfc10 | 2017-06-20 12:05:47 +0100 | [diff] [blame] | 782 | ctx = i915_gem_context_lookup(file_priv, args->ctx_id); |
| 783 | if (!ctx) |
| 784 | return -ENOENT; |
| 785 | |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 786 | ret = i915_mutex_lock_interruptible(dev); |
| 787 | if (ret) |
Chris Wilson | 1acfc10 | 2017-06-20 12:05:47 +0100 | [diff] [blame] | 788 | goto out; |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 789 | |
| 790 | switch (args->param) { |
| 791 | case I915_CONTEXT_PARAM_BAN_PERIOD: |
Mika Kuoppala | 8410217 | 2016-11-16 17:20:32 +0200 | [diff] [blame] | 792 | ret = -EINVAL; |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 793 | break; |
David Weinehall | b1b3827 | 2015-05-20 17:00:13 +0300 | [diff] [blame] | 794 | case I915_CONTEXT_PARAM_NO_ZEROMAP: |
| 795 | if (args->size) { |
| 796 | ret = -EINVAL; |
| 797 | } else { |
| 798 | ctx->flags &= ~CONTEXT_NO_ZEROMAP; |
| 799 | ctx->flags |= args->value ? CONTEXT_NO_ZEROMAP : 0; |
| 800 | } |
| 801 | break; |
Chris Wilson | bc3d674 | 2016-07-04 08:08:39 +0100 | [diff] [blame] | 802 | case I915_CONTEXT_PARAM_NO_ERROR_CAPTURE: |
Chris Wilson | 6095868 | 2016-12-31 11:20:11 +0000 | [diff] [blame] | 803 | if (args->size) |
Chris Wilson | bc3d674 | 2016-07-04 08:08:39 +0100 | [diff] [blame] | 804 | ret = -EINVAL; |
Chris Wilson | 6095868 | 2016-12-31 11:20:11 +0000 | [diff] [blame] | 805 | else if (args->value) |
| 806 | i915_gem_context_set_no_error_capture(ctx); |
| 807 | else |
| 808 | i915_gem_context_clear_no_error_capture(ctx); |
Chris Wilson | bc3d674 | 2016-07-04 08:08:39 +0100 | [diff] [blame] | 809 | break; |
Mika Kuoppala | 8410217 | 2016-11-16 17:20:32 +0200 | [diff] [blame] | 810 | case I915_CONTEXT_PARAM_BANNABLE: |
| 811 | if (args->size) |
| 812 | ret = -EINVAL; |
| 813 | else if (!capable(CAP_SYS_ADMIN) && !args->value) |
| 814 | ret = -EPERM; |
Chris Wilson | 6095868 | 2016-12-31 11:20:11 +0000 | [diff] [blame] | 815 | else if (args->value) |
| 816 | i915_gem_context_set_bannable(ctx); |
Mika Kuoppala | 8410217 | 2016-11-16 17:20:32 +0200 | [diff] [blame] | 817 | else |
Chris Wilson | 6095868 | 2016-12-31 11:20:11 +0000 | [diff] [blame] | 818 | i915_gem_context_clear_bannable(ctx); |
Mika Kuoppala | 8410217 | 2016-11-16 17:20:32 +0200 | [diff] [blame] | 819 | break; |
Chris Wilson | ac14fbd | 2017-10-03 21:34:53 +0100 | [diff] [blame] | 820 | |
| 821 | case I915_CONTEXT_PARAM_PRIORITY: |
| 822 | { |
Chris Wilson | 11a18f6 | 2018-02-08 08:51:51 +0000 | [diff] [blame] | 823 | s64 priority = args->value; |
Chris Wilson | ac14fbd | 2017-10-03 21:34:53 +0100 | [diff] [blame] | 824 | |
| 825 | if (args->size) |
| 826 | ret = -EINVAL; |
Chris Wilson | 3fed180 | 2018-02-07 21:05:43 +0000 | [diff] [blame] | 827 | else if (!(to_i915(dev)->caps.scheduler & I915_SCHEDULER_CAP_PRIORITY)) |
Chris Wilson | ac14fbd | 2017-10-03 21:34:53 +0100 | [diff] [blame] | 828 | ret = -ENODEV; |
| 829 | else if (priority > I915_CONTEXT_MAX_USER_PRIORITY || |
| 830 | priority < I915_CONTEXT_MIN_USER_PRIORITY) |
| 831 | ret = -EINVAL; |
| 832 | else if (priority > I915_CONTEXT_DEFAULT_PRIORITY && |
| 833 | !capable(CAP_SYS_NICE)) |
| 834 | ret = -EPERM; |
| 835 | else |
Chris Wilson | b7268c5 | 2018-04-18 19:40:52 +0100 | [diff] [blame] | 836 | ctx->sched.priority = priority; |
Chris Wilson | ac14fbd | 2017-10-03 21:34:53 +0100 | [diff] [blame] | 837 | } |
| 838 | break; |
| 839 | |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 840 | default: |
| 841 | ret = -EINVAL; |
| 842 | break; |
| 843 | } |
| 844 | mutex_unlock(&dev->struct_mutex); |
| 845 | |
Chris Wilson | 1acfc10 | 2017-06-20 12:05:47 +0100 | [diff] [blame] | 846 | out: |
| 847 | i915_gem_context_put(ctx); |
Chris Wilson | c9dc0f3 | 2014-12-24 08:13:40 -0800 | [diff] [blame] | 848 | return ret; |
| 849 | } |
Chris Wilson | d538704 | 2016-05-13 11:57:19 +0100 | [diff] [blame] | 850 | |
| 851 | int i915_gem_context_reset_stats_ioctl(struct drm_device *dev, |
| 852 | void *data, struct drm_file *file) |
| 853 | { |
Chris Wilson | fac5e23 | 2016-07-04 11:34:36 +0100 | [diff] [blame] | 854 | struct drm_i915_private *dev_priv = to_i915(dev); |
Chris Wilson | d538704 | 2016-05-13 11:57:19 +0100 | [diff] [blame] | 855 | struct drm_i915_reset_stats *args = data; |
Chris Wilson | e2efd13 | 2016-05-24 14:53:34 +0100 | [diff] [blame] | 856 | struct i915_gem_context *ctx; |
Chris Wilson | d538704 | 2016-05-13 11:57:19 +0100 | [diff] [blame] | 857 | int ret; |
| 858 | |
| 859 | if (args->flags || args->pad) |
| 860 | return -EINVAL; |
| 861 | |
Chris Wilson | 1acfc10 | 2017-06-20 12:05:47 +0100 | [diff] [blame] | 862 | ret = -ENOENT; |
| 863 | rcu_read_lock(); |
| 864 | ctx = __i915_gem_context_lookup_rcu(file->driver_priv, args->ctx_id); |
| 865 | if (!ctx) |
| 866 | goto out; |
Chris Wilson | d538704 | 2016-05-13 11:57:19 +0100 | [diff] [blame] | 867 | |
Chris Wilson | 1acfc10 | 2017-06-20 12:05:47 +0100 | [diff] [blame] | 868 | /* |
| 869 | * We opt for unserialised reads here. This may result in tearing |
| 870 | * in the extremely unlikely event of a GPU hang on this context |
| 871 | * as we are querying them. If we need that extra layer of protection, |
| 872 | * we should wrap the hangstats with a seqlock. |
| 873 | */ |
Chris Wilson | d538704 | 2016-05-13 11:57:19 +0100 | [diff] [blame] | 874 | |
| 875 | if (capable(CAP_SYS_ADMIN)) |
| 876 | args->reset_count = i915_reset_count(&dev_priv->gpu_error); |
| 877 | else |
| 878 | args->reset_count = 0; |
| 879 | |
Chris Wilson | 77b25a9 | 2017-07-21 13:32:30 +0100 | [diff] [blame] | 880 | args->batch_active = atomic_read(&ctx->guilty_count); |
| 881 | args->batch_pending = atomic_read(&ctx->active_count); |
Chris Wilson | d538704 | 2016-05-13 11:57:19 +0100 | [diff] [blame] | 882 | |
Chris Wilson | 1acfc10 | 2017-06-20 12:05:47 +0100 | [diff] [blame] | 883 | ret = 0; |
| 884 | out: |
| 885 | rcu_read_unlock(); |
| 886 | return ret; |
Chris Wilson | d538704 | 2016-05-13 11:57:19 +0100 | [diff] [blame] | 887 | } |
Chris Wilson | 0daf011 | 2017-02-13 17:15:19 +0000 | [diff] [blame] | 888 | |
| 889 | #if IS_ENABLED(CONFIG_DRM_I915_SELFTEST) |
| 890 | #include "selftests/mock_context.c" |
Chris Wilson | 791ff39 | 2017-02-13 17:15:49 +0000 | [diff] [blame] | 891 | #include "selftests/i915_gem_context.c" |
Chris Wilson | 0daf011 | 2017-02-13 17:15:19 +0000 | [diff] [blame] | 892 | #endif |