Merge tag 'drm-intel-next-2019-03-20' of git://anongit.freedesktop.org/drm/drm-intel...
[sfrench/cifs-2.6.git] / drivers / gpu / drm / i915 / i915_gem_context.c
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
76  *  GPU. The GPU has loaded its state already and has stored away the gtt
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
88 #include <linux/log2.h>
89 #include <drm/i915_drm.h>
90 #include "i915_drv.h"
91 #include "i915_globals.h"
92 #include "i915_trace.h"
93 #include "intel_lrc_reg.h"
94 #include "intel_workarounds.h"
95
96 #define ALL_L3_SLICES(dev) (1 << NUM_L3_SLICES(dev)) - 1
97
98 static struct i915_global_gem_context {
99         struct i915_global base;
100         struct kmem_cache *slab_luts;
101 } global;
102
103 struct i915_lut_handle *i915_lut_handle_alloc(void)
104 {
105         return kmem_cache_alloc(global.slab_luts, GFP_KERNEL);
106 }
107
108 void i915_lut_handle_free(struct i915_lut_handle *lut)
109 {
110         return kmem_cache_free(global.slab_luts, lut);
111 }
112
113 static void lut_close(struct i915_gem_context *ctx)
114 {
115         struct i915_lut_handle *lut, *ln;
116         struct radix_tree_iter iter;
117         void __rcu **slot;
118
119         list_for_each_entry_safe(lut, ln, &ctx->handles_list, ctx_link) {
120                 list_del(&lut->obj_link);
121                 i915_lut_handle_free(lut);
122         }
123
124         rcu_read_lock();
125         radix_tree_for_each_slot(slot, &ctx->handles_vma, &iter, 0) {
126                 struct i915_vma *vma = rcu_dereference_raw(*slot);
127
128                 radix_tree_iter_delete(&ctx->handles_vma, &iter, slot);
129                 __i915_gem_object_release_unless_active(vma->obj);
130         }
131         rcu_read_unlock();
132 }
133
134 static inline int new_hw_id(struct drm_i915_private *i915, gfp_t gfp)
135 {
136         unsigned int max;
137
138         lockdep_assert_held(&i915->contexts.mutex);
139
140         if (INTEL_GEN(i915) >= 11)
141                 max = GEN11_MAX_CONTEXT_HW_ID;
142         else if (USES_GUC_SUBMISSION(i915))
143                 /*
144                  * When using GuC in proxy submission, GuC consumes the
145                  * highest bit in the context id to indicate proxy submission.
146                  */
147                 max = MAX_GUC_CONTEXT_HW_ID;
148         else
149                 max = MAX_CONTEXT_HW_ID;
150
151         return ida_simple_get(&i915->contexts.hw_ida, 0, max, gfp);
152 }
153
154 static int steal_hw_id(struct drm_i915_private *i915)
155 {
156         struct i915_gem_context *ctx, *cn;
157         LIST_HEAD(pinned);
158         int id = -ENOSPC;
159
160         lockdep_assert_held(&i915->contexts.mutex);
161
162         list_for_each_entry_safe(ctx, cn,
163                                  &i915->contexts.hw_id_list, hw_id_link) {
164                 if (atomic_read(&ctx->hw_id_pin_count)) {
165                         list_move_tail(&ctx->hw_id_link, &pinned);
166                         continue;
167                 }
168
169                 GEM_BUG_ON(!ctx->hw_id); /* perma-pinned kernel context */
170                 list_del_init(&ctx->hw_id_link);
171                 id = ctx->hw_id;
172                 break;
173         }
174
175         /*
176          * Remember how far we got up on the last repossesion scan, so the
177          * list is kept in a "least recently scanned" order.
178          */
179         list_splice_tail(&pinned, &i915->contexts.hw_id_list);
180         return id;
181 }
182
183 static int assign_hw_id(struct drm_i915_private *i915, unsigned int *out)
184 {
185         int ret;
186
187         lockdep_assert_held(&i915->contexts.mutex);
188
189         /*
190          * We prefer to steal/stall ourselves and our users over that of the
191          * entire system. That may be a little unfair to our users, and
192          * even hurt high priority clients. The choice is whether to oomkill
193          * something else, or steal a context id.
194          */
195         ret = new_hw_id(i915, GFP_KERNEL | __GFP_RETRY_MAYFAIL | __GFP_NOWARN);
196         if (unlikely(ret < 0)) {
197                 ret = steal_hw_id(i915);
198                 if (ret < 0) /* once again for the correct errno code */
199                         ret = new_hw_id(i915, GFP_KERNEL);
200                 if (ret < 0)
201                         return ret;
202         }
203
204         *out = ret;
205         return 0;
206 }
207
208 static void release_hw_id(struct i915_gem_context *ctx)
209 {
210         struct drm_i915_private *i915 = ctx->i915;
211
212         if (list_empty(&ctx->hw_id_link))
213                 return;
214
215         mutex_lock(&i915->contexts.mutex);
216         if (!list_empty(&ctx->hw_id_link)) {
217                 ida_simple_remove(&i915->contexts.hw_ida, ctx->hw_id);
218                 list_del_init(&ctx->hw_id_link);
219         }
220         mutex_unlock(&i915->contexts.mutex);
221 }
222
223 static void i915_gem_context_free(struct i915_gem_context *ctx)
224 {
225         struct intel_context *it, *n;
226
227         lockdep_assert_held(&ctx->i915->drm.struct_mutex);
228         GEM_BUG_ON(!i915_gem_context_is_closed(ctx));
229         GEM_BUG_ON(!list_empty(&ctx->active_engines));
230
231         release_hw_id(ctx);
232         i915_ppgtt_put(ctx->ppgtt);
233
234         rbtree_postorder_for_each_entry_safe(it, n, &ctx->hw_contexts, node)
235                 intel_context_put(it);
236
237         kfree(ctx->name);
238         put_pid(ctx->pid);
239
240         list_del(&ctx->link);
241         mutex_destroy(&ctx->mutex);
242
243         kfree_rcu(ctx, rcu);
244 }
245
246 static void contexts_free(struct drm_i915_private *i915)
247 {
248         struct llist_node *freed = llist_del_all(&i915->contexts.free_list);
249         struct i915_gem_context *ctx, *cn;
250
251         lockdep_assert_held(&i915->drm.struct_mutex);
252
253         llist_for_each_entry_safe(ctx, cn, freed, free_link)
254                 i915_gem_context_free(ctx);
255 }
256
257 static void contexts_free_first(struct drm_i915_private *i915)
258 {
259         struct i915_gem_context *ctx;
260         struct llist_node *freed;
261
262         lockdep_assert_held(&i915->drm.struct_mutex);
263
264         freed = llist_del_first(&i915->contexts.free_list);
265         if (!freed)
266                 return;
267
268         ctx = container_of(freed, typeof(*ctx), free_link);
269         i915_gem_context_free(ctx);
270 }
271
272 static void contexts_free_worker(struct work_struct *work)
273 {
274         struct drm_i915_private *i915 =
275                 container_of(work, typeof(*i915), contexts.free_work);
276
277         mutex_lock(&i915->drm.struct_mutex);
278         contexts_free(i915);
279         mutex_unlock(&i915->drm.struct_mutex);
280 }
281
282 void i915_gem_context_release(struct kref *ref)
283 {
284         struct i915_gem_context *ctx = container_of(ref, typeof(*ctx), ref);
285         struct drm_i915_private *i915 = ctx->i915;
286
287         trace_i915_context_free(ctx);
288         if (llist_add(&ctx->free_link, &i915->contexts.free_list))
289                 queue_work(i915->wq, &i915->contexts.free_work);
290 }
291
292 static void context_close(struct i915_gem_context *ctx)
293 {
294         i915_gem_context_set_closed(ctx);
295
296         /*
297          * This context will never again be assinged to HW, so we can
298          * reuse its ID for the next context.
299          */
300         release_hw_id(ctx);
301
302         /*
303          * The LUT uses the VMA as a backpointer to unref the object,
304          * so we need to clear the LUT before we close all the VMA (inside
305          * the ppgtt).
306          */
307         lut_close(ctx);
308         if (ctx->ppgtt)
309                 i915_ppgtt_close(&ctx->ppgtt->vm);
310
311         ctx->file_priv = ERR_PTR(-EBADF);
312         i915_gem_context_put(ctx);
313 }
314
315 static u32 default_desc_template(const struct drm_i915_private *i915,
316                                  const struct i915_hw_ppgtt *ppgtt)
317 {
318         u32 address_mode;
319         u32 desc;
320
321         desc = GEN8_CTX_VALID | GEN8_CTX_PRIVILEGE;
322
323         address_mode = INTEL_LEGACY_32B_CONTEXT;
324         if (ppgtt && i915_vm_is_4lvl(&ppgtt->vm))
325                 address_mode = INTEL_LEGACY_64B_CONTEXT;
326         desc |= address_mode << GEN8_CTX_ADDRESSING_MODE_SHIFT;
327
328         if (IS_GEN(i915, 8))
329                 desc |= GEN8_CTX_L3LLC_COHERENT;
330
331         /* TODO: WaDisableLiteRestore when we start using semaphore
332          * signalling between Command Streamers
333          * ring->ctx_desc_template |= GEN8_CTX_FORCE_RESTORE;
334          */
335
336         return desc;
337 }
338
339 static struct i915_gem_context *
340 __create_hw_context(struct drm_i915_private *dev_priv,
341                     struct drm_i915_file_private *file_priv)
342 {
343         struct i915_gem_context *ctx;
344         int ret;
345         int i;
346
347         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
348         if (ctx == NULL)
349                 return ERR_PTR(-ENOMEM);
350
351         kref_init(&ctx->ref);
352         list_add_tail(&ctx->link, &dev_priv->contexts.list);
353         ctx->i915 = dev_priv;
354         ctx->sched.priority = I915_USER_PRIORITY(I915_PRIORITY_NORMAL);
355         INIT_LIST_HEAD(&ctx->active_engines);
356         mutex_init(&ctx->mutex);
357
358         ctx->hw_contexts = RB_ROOT;
359         spin_lock_init(&ctx->hw_contexts_lock);
360
361         INIT_RADIX_TREE(&ctx->handles_vma, GFP_KERNEL);
362         INIT_LIST_HEAD(&ctx->handles_list);
363         INIT_LIST_HEAD(&ctx->hw_id_link);
364
365         /* Default context will never have a file_priv */
366         ret = DEFAULT_CONTEXT_HANDLE;
367         if (file_priv) {
368                 ret = idr_alloc(&file_priv->context_idr, ctx,
369                                 DEFAULT_CONTEXT_HANDLE, 0, GFP_KERNEL);
370                 if (ret < 0)
371                         goto err_lut;
372         }
373         ctx->user_handle = ret;
374
375         ctx->file_priv = file_priv;
376         if (file_priv) {
377                 ctx->pid = get_task_pid(current, PIDTYPE_PID);
378                 ctx->name = kasprintf(GFP_KERNEL, "%s[%d]/%x",
379                                       current->comm,
380                                       pid_nr(ctx->pid),
381                                       ctx->user_handle);
382                 if (!ctx->name) {
383                         ret = -ENOMEM;
384                         goto err_pid;
385                 }
386         }
387
388         /* NB: Mark all slices as needing a remap so that when the context first
389          * loads it will restore whatever remap state already exists. If there
390          * is no remap info, it will be a NOP. */
391         ctx->remap_slice = ALL_L3_SLICES(dev_priv);
392
393         i915_gem_context_set_bannable(ctx);
394         i915_gem_context_set_recoverable(ctx);
395
396         ctx->ring_size = 4 * PAGE_SIZE;
397         ctx->desc_template =
398                 default_desc_template(dev_priv, dev_priv->mm.aliasing_ppgtt);
399
400         for (i = 0; i < ARRAY_SIZE(ctx->hang_timestamp); i++)
401                 ctx->hang_timestamp[i] = jiffies - CONTEXT_FAST_HANG_JIFFIES;
402
403         return ctx;
404
405 err_pid:
406         put_pid(ctx->pid);
407         idr_remove(&file_priv->context_idr, ctx->user_handle);
408 err_lut:
409         context_close(ctx);
410         return ERR_PTR(ret);
411 }
412
413 static void __destroy_hw_context(struct i915_gem_context *ctx,
414                                  struct drm_i915_file_private *file_priv)
415 {
416         idr_remove(&file_priv->context_idr, ctx->user_handle);
417         context_close(ctx);
418 }
419
420 static struct i915_gem_context *
421 i915_gem_create_context(struct drm_i915_private *dev_priv,
422                         struct drm_i915_file_private *file_priv)
423 {
424         struct i915_gem_context *ctx;
425
426         lockdep_assert_held(&dev_priv->drm.struct_mutex);
427
428         /* Reap the most stale context */
429         contexts_free_first(dev_priv);
430
431         ctx = __create_hw_context(dev_priv, file_priv);
432         if (IS_ERR(ctx))
433                 return ctx;
434
435         if (HAS_FULL_PPGTT(dev_priv)) {
436                 struct i915_hw_ppgtt *ppgtt;
437
438                 ppgtt = i915_ppgtt_create(dev_priv, file_priv);
439                 if (IS_ERR(ppgtt)) {
440                         DRM_DEBUG_DRIVER("PPGTT setup failed (%ld)\n",
441                                          PTR_ERR(ppgtt));
442                         __destroy_hw_context(ctx, file_priv);
443                         return ERR_CAST(ppgtt);
444                 }
445
446                 ctx->ppgtt = ppgtt;
447                 ctx->desc_template = default_desc_template(dev_priv, ppgtt);
448         }
449
450         trace_i915_context_create(ctx);
451
452         return ctx;
453 }
454
455 /**
456  * i915_gem_context_create_gvt - create a GVT GEM context
457  * @dev: drm device *
458  *
459  * This function is used to create a GVT specific GEM context.
460  *
461  * Returns:
462  * pointer to i915_gem_context on success, error pointer if failed
463  *
464  */
465 struct i915_gem_context *
466 i915_gem_context_create_gvt(struct drm_device *dev)
467 {
468         struct i915_gem_context *ctx;
469         int ret;
470
471         if (!IS_ENABLED(CONFIG_DRM_I915_GVT))
472                 return ERR_PTR(-ENODEV);
473
474         ret = i915_mutex_lock_interruptible(dev);
475         if (ret)
476                 return ERR_PTR(ret);
477
478         ctx = i915_gem_create_context(to_i915(dev), NULL);
479         if (IS_ERR(ctx))
480                 goto out;
481
482         ctx->file_priv = ERR_PTR(-EBADF);
483         i915_gem_context_set_closed(ctx); /* not user accessible */
484         i915_gem_context_clear_bannable(ctx);
485         i915_gem_context_set_force_single_submission(ctx);
486         if (!USES_GUC_SUBMISSION(to_i915(dev)))
487                 ctx->ring_size = 512 * PAGE_SIZE; /* Max ring buffer size */
488
489         GEM_BUG_ON(i915_gem_context_is_kernel(ctx));
490 out:
491         mutex_unlock(&dev->struct_mutex);
492         return ctx;
493 }
494
495 static void
496 destroy_kernel_context(struct i915_gem_context **ctxp)
497 {
498         struct i915_gem_context *ctx;
499
500         /* Keep the context ref so that we can free it immediately ourselves */
501         ctx = i915_gem_context_get(fetch_and_zero(ctxp));
502         GEM_BUG_ON(!i915_gem_context_is_kernel(ctx));
503
504         context_close(ctx);
505         i915_gem_context_free(ctx);
506 }
507
508 struct i915_gem_context *
509 i915_gem_context_create_kernel(struct drm_i915_private *i915, int prio)
510 {
511         struct i915_gem_context *ctx;
512         int err;
513
514         ctx = i915_gem_create_context(i915, NULL);
515         if (IS_ERR(ctx))
516                 return ctx;
517
518         err = i915_gem_context_pin_hw_id(ctx);
519         if (err) {
520                 destroy_kernel_context(&ctx);
521                 return ERR_PTR(err);
522         }
523
524         i915_gem_context_clear_bannable(ctx);
525         ctx->sched.priority = I915_USER_PRIORITY(prio);
526         ctx->ring_size = PAGE_SIZE;
527
528         GEM_BUG_ON(!i915_gem_context_is_kernel(ctx));
529
530         return ctx;
531 }
532
533 static void init_contexts(struct drm_i915_private *i915)
534 {
535         mutex_init(&i915->contexts.mutex);
536         INIT_LIST_HEAD(&i915->contexts.list);
537
538         /* Using the simple ida interface, the max is limited by sizeof(int) */
539         BUILD_BUG_ON(MAX_CONTEXT_HW_ID > INT_MAX);
540         BUILD_BUG_ON(GEN11_MAX_CONTEXT_HW_ID > INT_MAX);
541         ida_init(&i915->contexts.hw_ida);
542         INIT_LIST_HEAD(&i915->contexts.hw_id_list);
543
544         INIT_WORK(&i915->contexts.free_work, contexts_free_worker);
545         init_llist_head(&i915->contexts.free_list);
546 }
547
548 static bool needs_preempt_context(struct drm_i915_private *i915)
549 {
550         return HAS_LOGICAL_RING_PREEMPTION(i915);
551 }
552
553 int i915_gem_contexts_init(struct drm_i915_private *dev_priv)
554 {
555         struct i915_gem_context *ctx;
556
557         /* Reassure ourselves we are only called once */
558         GEM_BUG_ON(dev_priv->kernel_context);
559         GEM_BUG_ON(dev_priv->preempt_context);
560
561         intel_engine_init_ctx_wa(dev_priv->engine[RCS0]);
562         init_contexts(dev_priv);
563
564         /* lowest priority; idle task */
565         ctx = i915_gem_context_create_kernel(dev_priv, I915_PRIORITY_MIN);
566         if (IS_ERR(ctx)) {
567                 DRM_ERROR("Failed to create default global context\n");
568                 return PTR_ERR(ctx);
569         }
570         /*
571          * For easy recognisablity, we want the kernel context to be 0 and then
572          * all user contexts will have non-zero hw_id. Kernel contexts are
573          * permanently pinned, so that we never suffer a stall and can
574          * use them from any allocation context (e.g. for evicting other
575          * contexts and from inside the shrinker).
576          */
577         GEM_BUG_ON(ctx->hw_id);
578         GEM_BUG_ON(!atomic_read(&ctx->hw_id_pin_count));
579         dev_priv->kernel_context = ctx;
580
581         /* highest priority; preempting task */
582         if (needs_preempt_context(dev_priv)) {
583                 ctx = i915_gem_context_create_kernel(dev_priv, INT_MAX);
584                 if (!IS_ERR(ctx))
585                         dev_priv->preempt_context = ctx;
586                 else
587                         DRM_ERROR("Failed to create preempt context; disabling preemption\n");
588         }
589
590         DRM_DEBUG_DRIVER("%s context support initialized\n",
591                          DRIVER_CAPS(dev_priv)->has_logical_contexts ?
592                          "logical" : "fake");
593         return 0;
594 }
595
596 void i915_gem_contexts_lost(struct drm_i915_private *dev_priv)
597 {
598         struct intel_engine_cs *engine;
599         enum intel_engine_id id;
600
601         lockdep_assert_held(&dev_priv->drm.struct_mutex);
602
603         for_each_engine(engine, dev_priv, id)
604                 intel_engine_lost_context(engine);
605 }
606
607 void i915_gem_contexts_fini(struct drm_i915_private *i915)
608 {
609         lockdep_assert_held(&i915->drm.struct_mutex);
610
611         if (i915->preempt_context)
612                 destroy_kernel_context(&i915->preempt_context);
613         destroy_kernel_context(&i915->kernel_context);
614
615         /* Must free all deferred contexts (via flush_workqueue) first */
616         GEM_BUG_ON(!list_empty(&i915->contexts.hw_id_list));
617         ida_destroy(&i915->contexts.hw_ida);
618 }
619
620 static int context_idr_cleanup(int id, void *p, void *data)
621 {
622         struct i915_gem_context *ctx = p;
623
624         context_close(ctx);
625         return 0;
626 }
627
628 int i915_gem_context_open(struct drm_i915_private *i915,
629                           struct drm_file *file)
630 {
631         struct drm_i915_file_private *file_priv = file->driver_priv;
632         struct i915_gem_context *ctx;
633
634         idr_init(&file_priv->context_idr);
635
636         mutex_lock(&i915->drm.struct_mutex);
637         ctx = i915_gem_create_context(i915, file_priv);
638         mutex_unlock(&i915->drm.struct_mutex);
639         if (IS_ERR(ctx)) {
640                 idr_destroy(&file_priv->context_idr);
641                 return PTR_ERR(ctx);
642         }
643
644         GEM_BUG_ON(i915_gem_context_is_kernel(ctx));
645
646         return 0;
647 }
648
649 void i915_gem_context_close(struct drm_file *file)
650 {
651         struct drm_i915_file_private *file_priv = file->driver_priv;
652
653         lockdep_assert_held(&file_priv->dev_priv->drm.struct_mutex);
654
655         idr_for_each(&file_priv->context_idr, context_idr_cleanup, NULL);
656         idr_destroy(&file_priv->context_idr);
657 }
658
659 static struct i915_request *
660 last_request_on_engine(struct i915_timeline *timeline,
661                        struct intel_engine_cs *engine)
662 {
663         struct i915_request *rq;
664
665         GEM_BUG_ON(timeline == &engine->timeline);
666
667         rq = i915_active_request_raw(&timeline->last_request,
668                                      &engine->i915->drm.struct_mutex);
669         if (rq && rq->engine == engine) {
670                 GEM_TRACE("last request for %s on engine %s: %llx:%llu\n",
671                           timeline->name, engine->name,
672                           rq->fence.context, rq->fence.seqno);
673                 GEM_BUG_ON(rq->timeline != timeline);
674                 return rq;
675         }
676
677         return NULL;
678 }
679
680 struct context_barrier_task {
681         struct i915_active base;
682         void (*task)(void *data);
683         void *data;
684 };
685
686 static void cb_retire(struct i915_active *base)
687 {
688         struct context_barrier_task *cb = container_of(base, typeof(*cb), base);
689
690         if (cb->task)
691                 cb->task(cb->data);
692
693         i915_active_fini(&cb->base);
694         kfree(cb);
695 }
696
697 I915_SELFTEST_DECLARE(static unsigned long context_barrier_inject_fault);
698 static int context_barrier_task(struct i915_gem_context *ctx,
699                                 unsigned long engines,
700                                 void (*task)(void *data),
701                                 void *data)
702 {
703         struct drm_i915_private *i915 = ctx->i915;
704         struct context_barrier_task *cb;
705         struct intel_context *ce;
706         intel_wakeref_t wakeref;
707         int err = 0;
708
709         lockdep_assert_held(&i915->drm.struct_mutex);
710         GEM_BUG_ON(!task);
711
712         cb = kmalloc(sizeof(*cb), GFP_KERNEL);
713         if (!cb)
714                 return -ENOMEM;
715
716         i915_active_init(i915, &cb->base, cb_retire);
717         i915_active_acquire(&cb->base);
718
719         wakeref = intel_runtime_pm_get(i915);
720         list_for_each_entry(ce, &ctx->active_engines, active_link) {
721                 struct intel_engine_cs *engine = ce->engine;
722                 struct i915_request *rq;
723
724                 if (!(ce->engine->mask & engines))
725                         continue;
726
727                 if (I915_SELFTEST_ONLY(context_barrier_inject_fault &
728                                        engine->mask)) {
729                         err = -ENXIO;
730                         break;
731                 }
732
733                 rq = i915_request_alloc(engine, ctx);
734                 if (IS_ERR(rq)) {
735                         err = PTR_ERR(rq);
736                         break;
737                 }
738
739                 err = i915_active_ref(&cb->base, rq->fence.context, rq);
740                 i915_request_add(rq);
741                 if (err)
742                         break;
743         }
744         intel_runtime_pm_put(i915, wakeref);
745
746         cb->task = err ? NULL : task; /* caller needs to unwind instead */
747         cb->data = data;
748
749         i915_active_release(&cb->base);
750
751         return err;
752 }
753
754 int i915_gem_switch_to_kernel_context(struct drm_i915_private *i915,
755                                       unsigned long mask)
756 {
757         struct intel_engine_cs *engine;
758
759         GEM_TRACE("awake?=%s\n", yesno(i915->gt.awake));
760
761         lockdep_assert_held(&i915->drm.struct_mutex);
762         GEM_BUG_ON(!i915->kernel_context);
763
764         /* Inoperable, so presume the GPU is safely pointing into the void! */
765         if (i915_terminally_wedged(i915))
766                 return 0;
767
768         for_each_engine_masked(engine, i915, mask, mask) {
769                 struct intel_ring *ring;
770                 struct i915_request *rq;
771
772                 rq = i915_request_alloc(engine, i915->kernel_context);
773                 if (IS_ERR(rq))
774                         return PTR_ERR(rq);
775
776                 /* Queue this switch after all other activity */
777                 list_for_each_entry(ring, &i915->gt.active_rings, active_link) {
778                         struct i915_request *prev;
779
780                         prev = last_request_on_engine(ring->timeline, engine);
781                         if (!prev)
782                                 continue;
783
784                         if (prev->gem_context == i915->kernel_context)
785                                 continue;
786
787                         GEM_TRACE("add barrier on %s for %llx:%lld\n",
788                                   engine->name,
789                                   prev->fence.context,
790                                   prev->fence.seqno);
791                         i915_sw_fence_await_sw_fence_gfp(&rq->submit,
792                                                          &prev->submit,
793                                                          I915_FENCE_GFP);
794                 }
795
796                 i915_request_add(rq);
797         }
798
799         return 0;
800 }
801
802 static bool client_is_banned(struct drm_i915_file_private *file_priv)
803 {
804         return atomic_read(&file_priv->ban_score) >= I915_CLIENT_SCORE_BANNED;
805 }
806
807 int i915_gem_context_create_ioctl(struct drm_device *dev, void *data,
808                                   struct drm_file *file)
809 {
810         struct drm_i915_private *i915 = to_i915(dev);
811         struct drm_i915_gem_context_create *args = data;
812         struct drm_i915_file_private *file_priv = file->driver_priv;
813         struct i915_gem_context *ctx;
814         int ret;
815
816         if (!DRIVER_CAPS(i915)->has_logical_contexts)
817                 return -ENODEV;
818
819         if (args->pad != 0)
820                 return -EINVAL;
821
822         ret = i915_terminally_wedged(i915);
823         if (ret)
824                 return ret;
825
826         if (client_is_banned(file_priv)) {
827                 DRM_DEBUG("client %s[%d] banned from creating ctx\n",
828                           current->comm,
829                           pid_nr(get_task_pid(current, PIDTYPE_PID)));
830
831                 return -EIO;
832         }
833
834         ret = i915_mutex_lock_interruptible(dev);
835         if (ret)
836                 return ret;
837
838         ctx = i915_gem_create_context(i915, file_priv);
839         mutex_unlock(&dev->struct_mutex);
840         if (IS_ERR(ctx))
841                 return PTR_ERR(ctx);
842
843         GEM_BUG_ON(i915_gem_context_is_kernel(ctx));
844
845         args->ctx_id = ctx->user_handle;
846         DRM_DEBUG("HW context %d created\n", args->ctx_id);
847
848         return 0;
849 }
850
851 int i915_gem_context_destroy_ioctl(struct drm_device *dev, void *data,
852                                    struct drm_file *file)
853 {
854         struct drm_i915_gem_context_destroy *args = data;
855         struct drm_i915_file_private *file_priv = file->driver_priv;
856         struct i915_gem_context *ctx;
857         int ret;
858
859         if (args->pad != 0)
860                 return -EINVAL;
861
862         if (args->ctx_id == DEFAULT_CONTEXT_HANDLE)
863                 return -ENOENT;
864
865         ctx = i915_gem_context_lookup(file_priv, args->ctx_id);
866         if (!ctx)
867                 return -ENOENT;
868
869         ret = mutex_lock_interruptible(&dev->struct_mutex);
870         if (ret)
871                 goto out;
872
873         __destroy_hw_context(ctx, file_priv);
874         mutex_unlock(&dev->struct_mutex);
875
876 out:
877         i915_gem_context_put(ctx);
878         return 0;
879 }
880
881 static int get_sseu(struct i915_gem_context *ctx,
882                     struct drm_i915_gem_context_param *args)
883 {
884         struct drm_i915_gem_context_param_sseu user_sseu;
885         struct intel_engine_cs *engine;
886         struct intel_context *ce;
887
888         if (args->size == 0)
889                 goto out;
890         else if (args->size < sizeof(user_sseu))
891                 return -EINVAL;
892
893         if (copy_from_user(&user_sseu, u64_to_user_ptr(args->value),
894                            sizeof(user_sseu)))
895                 return -EFAULT;
896
897         if (user_sseu.flags || user_sseu.rsvd)
898                 return -EINVAL;
899
900         engine = intel_engine_lookup_user(ctx->i915,
901                                           user_sseu.engine_class,
902                                           user_sseu.engine_instance);
903         if (!engine)
904                 return -EINVAL;
905
906         ce = intel_context_pin_lock(ctx, engine); /* serialises with set_sseu */
907         if (IS_ERR(ce))
908                 return PTR_ERR(ce);
909
910         user_sseu.slice_mask = ce->sseu.slice_mask;
911         user_sseu.subslice_mask = ce->sseu.subslice_mask;
912         user_sseu.min_eus_per_subslice = ce->sseu.min_eus_per_subslice;
913         user_sseu.max_eus_per_subslice = ce->sseu.max_eus_per_subslice;
914
915         intel_context_pin_unlock(ce);
916
917         if (copy_to_user(u64_to_user_ptr(args->value), &user_sseu,
918                          sizeof(user_sseu)))
919                 return -EFAULT;
920
921 out:
922         args->size = sizeof(user_sseu);
923
924         return 0;
925 }
926
927 int i915_gem_context_getparam_ioctl(struct drm_device *dev, void *data,
928                                     struct drm_file *file)
929 {
930         struct drm_i915_file_private *file_priv = file->driver_priv;
931         struct drm_i915_gem_context_param *args = data;
932         struct i915_gem_context *ctx;
933         int ret = 0;
934
935         ctx = i915_gem_context_lookup(file_priv, args->ctx_id);
936         if (!ctx)
937                 return -ENOENT;
938
939         switch (args->param) {
940         case I915_CONTEXT_PARAM_BAN_PERIOD:
941                 ret = -EINVAL;
942                 break;
943         case I915_CONTEXT_PARAM_NO_ZEROMAP:
944                 args->size = 0;
945                 args->value = test_bit(UCONTEXT_NO_ZEROMAP, &ctx->user_flags);
946                 break;
947         case I915_CONTEXT_PARAM_GTT_SIZE:
948                 args->size = 0;
949
950                 if (ctx->ppgtt)
951                         args->value = ctx->ppgtt->vm.total;
952                 else if (to_i915(dev)->mm.aliasing_ppgtt)
953                         args->value = to_i915(dev)->mm.aliasing_ppgtt->vm.total;
954                 else
955                         args->value = to_i915(dev)->ggtt.vm.total;
956                 break;
957         case I915_CONTEXT_PARAM_NO_ERROR_CAPTURE:
958                 args->size = 0;
959                 args->value = i915_gem_context_no_error_capture(ctx);
960                 break;
961         case I915_CONTEXT_PARAM_BANNABLE:
962                 args->size = 0;
963                 args->value = i915_gem_context_is_bannable(ctx);
964                 break;
965         case I915_CONTEXT_PARAM_RECOVERABLE:
966                 args->size = 0;
967                 args->value = i915_gem_context_is_recoverable(ctx);
968                 break;
969         case I915_CONTEXT_PARAM_PRIORITY:
970                 args->size = 0;
971                 args->value = ctx->sched.priority >> I915_USER_PRIORITY_SHIFT;
972                 break;
973         case I915_CONTEXT_PARAM_SSEU:
974                 ret = get_sseu(ctx, args);
975                 break;
976         default:
977                 ret = -EINVAL;
978                 break;
979         }
980
981         i915_gem_context_put(ctx);
982         return ret;
983 }
984
985 static int gen8_emit_rpcs_config(struct i915_request *rq,
986                                  struct intel_context *ce,
987                                  struct intel_sseu sseu)
988 {
989         u64 offset;
990         u32 *cs;
991
992         cs = intel_ring_begin(rq, 4);
993         if (IS_ERR(cs))
994                 return PTR_ERR(cs);
995
996         offset = i915_ggtt_offset(ce->state) +
997                  LRC_STATE_PN * PAGE_SIZE +
998                  (CTX_R_PWR_CLK_STATE + 1) * 4;
999
1000         *cs++ = MI_STORE_DWORD_IMM_GEN4 | MI_USE_GGTT;
1001         *cs++ = lower_32_bits(offset);
1002         *cs++ = upper_32_bits(offset);
1003         *cs++ = gen8_make_rpcs(rq->i915, &sseu);
1004
1005         intel_ring_advance(rq, cs);
1006
1007         return 0;
1008 }
1009
1010 static int
1011 gen8_modify_rpcs(struct intel_context *ce, struct intel_sseu sseu)
1012 {
1013         struct drm_i915_private *i915 = ce->engine->i915;
1014         struct i915_request *rq, *prev;
1015         intel_wakeref_t wakeref;
1016         int ret;
1017
1018         lockdep_assert_held(&ce->pin_mutex);
1019
1020         /*
1021          * If the context is not idle, we have to submit an ordered request to
1022          * modify its context image via the kernel context (writing to our own
1023          * image, or into the registers directory, does not stick). Pristine
1024          * and idle contexts will be configured on pinning.
1025          */
1026         if (!intel_context_is_pinned(ce))
1027                 return 0;
1028
1029         /* Submitting requests etc needs the hw awake. */
1030         wakeref = intel_runtime_pm_get(i915);
1031
1032         rq = i915_request_alloc(ce->engine, i915->kernel_context);
1033         if (IS_ERR(rq)) {
1034                 ret = PTR_ERR(rq);
1035                 goto out_put;
1036         }
1037
1038         /* Queue this switch after all other activity by this context. */
1039         prev = i915_active_request_raw(&ce->ring->timeline->last_request,
1040                                        &i915->drm.struct_mutex);
1041         if (prev && !i915_request_completed(prev)) {
1042                 ret = i915_request_await_dma_fence(rq, &prev->fence);
1043                 if (ret < 0)
1044                         goto out_add;
1045         }
1046
1047         /* Order all following requests to be after. */
1048         ret = i915_timeline_set_barrier(ce->ring->timeline, rq);
1049         if (ret)
1050                 goto out_add;
1051
1052         ret = gen8_emit_rpcs_config(rq, ce, sseu);
1053         if (ret)
1054                 goto out_add;
1055
1056         /*
1057          * Guarantee context image and the timeline remains pinned until the
1058          * modifying request is retired by setting the ce activity tracker.
1059          *
1060          * But we only need to take one pin on the account of it. Or in other
1061          * words transfer the pinned ce object to tracked active request.
1062          */
1063         if (!i915_active_request_isset(&ce->active_tracker))
1064                 __intel_context_pin(ce);
1065         __i915_active_request_set(&ce->active_tracker, rq);
1066
1067 out_add:
1068         i915_request_add(rq);
1069 out_put:
1070         intel_runtime_pm_put(i915, wakeref);
1071
1072         return ret;
1073 }
1074
1075 static int
1076 __i915_gem_context_reconfigure_sseu(struct i915_gem_context *ctx,
1077                                     struct intel_engine_cs *engine,
1078                                     struct intel_sseu sseu)
1079 {
1080         struct intel_context *ce;
1081         int ret = 0;
1082
1083         GEM_BUG_ON(INTEL_GEN(ctx->i915) < 8);
1084         GEM_BUG_ON(engine->id != RCS0);
1085
1086         ce = intel_context_pin_lock(ctx, engine);
1087         if (IS_ERR(ce))
1088                 return PTR_ERR(ce);
1089
1090         /* Nothing to do if unmodified. */
1091         if (!memcmp(&ce->sseu, &sseu, sizeof(sseu)))
1092                 goto unlock;
1093
1094         ret = gen8_modify_rpcs(ce, sseu);
1095         if (!ret)
1096                 ce->sseu = sseu;
1097
1098 unlock:
1099         intel_context_pin_unlock(ce);
1100         return ret;
1101 }
1102
1103 static int
1104 i915_gem_context_reconfigure_sseu(struct i915_gem_context *ctx,
1105                                   struct intel_engine_cs *engine,
1106                                   struct intel_sseu sseu)
1107 {
1108         int ret;
1109
1110         ret = mutex_lock_interruptible(&ctx->i915->drm.struct_mutex);
1111         if (ret)
1112                 return ret;
1113
1114         ret = __i915_gem_context_reconfigure_sseu(ctx, engine, sseu);
1115
1116         mutex_unlock(&ctx->i915->drm.struct_mutex);
1117
1118         return ret;
1119 }
1120
1121 static int
1122 user_to_context_sseu(struct drm_i915_private *i915,
1123                      const struct drm_i915_gem_context_param_sseu *user,
1124                      struct intel_sseu *context)
1125 {
1126         const struct sseu_dev_info *device = &RUNTIME_INFO(i915)->sseu;
1127
1128         /* No zeros in any field. */
1129         if (!user->slice_mask || !user->subslice_mask ||
1130             !user->min_eus_per_subslice || !user->max_eus_per_subslice)
1131                 return -EINVAL;
1132
1133         /* Max > min. */
1134         if (user->max_eus_per_subslice < user->min_eus_per_subslice)
1135                 return -EINVAL;
1136
1137         /*
1138          * Some future proofing on the types since the uAPI is wider than the
1139          * current internal implementation.
1140          */
1141         if (overflows_type(user->slice_mask, context->slice_mask) ||
1142             overflows_type(user->subslice_mask, context->subslice_mask) ||
1143             overflows_type(user->min_eus_per_subslice,
1144                            context->min_eus_per_subslice) ||
1145             overflows_type(user->max_eus_per_subslice,
1146                            context->max_eus_per_subslice))
1147                 return -EINVAL;
1148
1149         /* Check validity against hardware. */
1150         if (user->slice_mask & ~device->slice_mask)
1151                 return -EINVAL;
1152
1153         if (user->subslice_mask & ~device->subslice_mask[0])
1154                 return -EINVAL;
1155
1156         if (user->max_eus_per_subslice > device->max_eus_per_subslice)
1157                 return -EINVAL;
1158
1159         context->slice_mask = user->slice_mask;
1160         context->subslice_mask = user->subslice_mask;
1161         context->min_eus_per_subslice = user->min_eus_per_subslice;
1162         context->max_eus_per_subslice = user->max_eus_per_subslice;
1163
1164         /* Part specific restrictions. */
1165         if (IS_GEN(i915, 11)) {
1166                 unsigned int hw_s = hweight8(device->slice_mask);
1167                 unsigned int hw_ss_per_s = hweight8(device->subslice_mask[0]);
1168                 unsigned int req_s = hweight8(context->slice_mask);
1169                 unsigned int req_ss = hweight8(context->subslice_mask);
1170
1171                 /*
1172                  * Only full subslice enablement is possible if more than one
1173                  * slice is turned on.
1174                  */
1175                 if (req_s > 1 && req_ss != hw_ss_per_s)
1176                         return -EINVAL;
1177
1178                 /*
1179                  * If more than four (SScount bitfield limit) subslices are
1180                  * requested then the number has to be even.
1181                  */
1182                 if (req_ss > 4 && (req_ss & 1))
1183                         return -EINVAL;
1184
1185                 /*
1186                  * If only one slice is enabled and subslice count is below the
1187                  * device full enablement, it must be at most half of the all
1188                  * available subslices.
1189                  */
1190                 if (req_s == 1 && req_ss < hw_ss_per_s &&
1191                     req_ss > (hw_ss_per_s / 2))
1192                         return -EINVAL;
1193
1194                 /* ABI restriction - VME use case only. */
1195
1196                 /* All slices or one slice only. */
1197                 if (req_s != 1 && req_s != hw_s)
1198                         return -EINVAL;
1199
1200                 /*
1201                  * Half subslices or full enablement only when one slice is
1202                  * enabled.
1203                  */
1204                 if (req_s == 1 &&
1205                     (req_ss != hw_ss_per_s && req_ss != (hw_ss_per_s / 2)))
1206                         return -EINVAL;
1207
1208                 /* No EU configuration changes. */
1209                 if ((user->min_eus_per_subslice !=
1210                      device->max_eus_per_subslice) ||
1211                     (user->max_eus_per_subslice !=
1212                      device->max_eus_per_subslice))
1213                         return -EINVAL;
1214         }
1215
1216         return 0;
1217 }
1218
1219 static int set_sseu(struct i915_gem_context *ctx,
1220                     struct drm_i915_gem_context_param *args)
1221 {
1222         struct drm_i915_private *i915 = ctx->i915;
1223         struct drm_i915_gem_context_param_sseu user_sseu;
1224         struct intel_engine_cs *engine;
1225         struct intel_sseu sseu;
1226         int ret;
1227
1228         if (args->size < sizeof(user_sseu))
1229                 return -EINVAL;
1230
1231         if (!IS_GEN(i915, 11))
1232                 return -ENODEV;
1233
1234         if (copy_from_user(&user_sseu, u64_to_user_ptr(args->value),
1235                            sizeof(user_sseu)))
1236                 return -EFAULT;
1237
1238         if (user_sseu.flags || user_sseu.rsvd)
1239                 return -EINVAL;
1240
1241         engine = intel_engine_lookup_user(i915,
1242                                           user_sseu.engine_class,
1243                                           user_sseu.engine_instance);
1244         if (!engine)
1245                 return -EINVAL;
1246
1247         /* Only render engine supports RPCS configuration. */
1248         if (engine->class != RENDER_CLASS)
1249                 return -ENODEV;
1250
1251         ret = user_to_context_sseu(i915, &user_sseu, &sseu);
1252         if (ret)
1253                 return ret;
1254
1255         ret = i915_gem_context_reconfigure_sseu(ctx, engine, sseu);
1256         if (ret)
1257                 return ret;
1258
1259         args->size = sizeof(user_sseu);
1260
1261         return 0;
1262 }
1263
1264 int i915_gem_context_setparam_ioctl(struct drm_device *dev, void *data,
1265                                     struct drm_file *file)
1266 {
1267         struct drm_i915_file_private *file_priv = file->driver_priv;
1268         struct drm_i915_gem_context_param *args = data;
1269         struct i915_gem_context *ctx;
1270         int ret = 0;
1271
1272         ctx = i915_gem_context_lookup(file_priv, args->ctx_id);
1273         if (!ctx)
1274                 return -ENOENT;
1275
1276         switch (args->param) {
1277         case I915_CONTEXT_PARAM_BAN_PERIOD:
1278                 ret = -EINVAL;
1279                 break;
1280         case I915_CONTEXT_PARAM_NO_ZEROMAP:
1281                 if (args->size)
1282                         ret = -EINVAL;
1283                 else if (args->value)
1284                         set_bit(UCONTEXT_NO_ZEROMAP, &ctx->user_flags);
1285                 else
1286                         clear_bit(UCONTEXT_NO_ZEROMAP, &ctx->user_flags);
1287                 break;
1288         case I915_CONTEXT_PARAM_NO_ERROR_CAPTURE:
1289                 if (args->size)
1290                         ret = -EINVAL;
1291                 else if (args->value)
1292                         i915_gem_context_set_no_error_capture(ctx);
1293                 else
1294                         i915_gem_context_clear_no_error_capture(ctx);
1295                 break;
1296         case I915_CONTEXT_PARAM_BANNABLE:
1297                 if (args->size)
1298                         ret = -EINVAL;
1299                 else if (!capable(CAP_SYS_ADMIN) && !args->value)
1300                         ret = -EPERM;
1301                 else if (args->value)
1302                         i915_gem_context_set_bannable(ctx);
1303                 else
1304                         i915_gem_context_clear_bannable(ctx);
1305                 break;
1306
1307         case I915_CONTEXT_PARAM_RECOVERABLE:
1308                 if (args->size)
1309                         ret = -EINVAL;
1310                 else if (args->value)
1311                         i915_gem_context_set_recoverable(ctx);
1312                 else
1313                         i915_gem_context_clear_recoverable(ctx);
1314                 break;
1315
1316         case I915_CONTEXT_PARAM_PRIORITY:
1317                 {
1318                         s64 priority = args->value;
1319
1320                         if (args->size)
1321                                 ret = -EINVAL;
1322                         else if (!(to_i915(dev)->caps.scheduler & I915_SCHEDULER_CAP_PRIORITY))
1323                                 ret = -ENODEV;
1324                         else if (priority > I915_CONTEXT_MAX_USER_PRIORITY ||
1325                                  priority < I915_CONTEXT_MIN_USER_PRIORITY)
1326                                 ret = -EINVAL;
1327                         else if (priority > I915_CONTEXT_DEFAULT_PRIORITY &&
1328                                  !capable(CAP_SYS_NICE))
1329                                 ret = -EPERM;
1330                         else
1331                                 ctx->sched.priority =
1332                                         I915_USER_PRIORITY(priority);
1333                 }
1334                 break;
1335         case I915_CONTEXT_PARAM_SSEU:
1336                 ret = set_sseu(ctx, args);
1337                 break;
1338         default:
1339                 ret = -EINVAL;
1340                 break;
1341         }
1342
1343         i915_gem_context_put(ctx);
1344         return ret;
1345 }
1346
1347 int i915_gem_context_reset_stats_ioctl(struct drm_device *dev,
1348                                        void *data, struct drm_file *file)
1349 {
1350         struct drm_i915_private *dev_priv = to_i915(dev);
1351         struct drm_i915_reset_stats *args = data;
1352         struct i915_gem_context *ctx;
1353         int ret;
1354
1355         if (args->flags || args->pad)
1356                 return -EINVAL;
1357
1358         ret = -ENOENT;
1359         rcu_read_lock();
1360         ctx = __i915_gem_context_lookup_rcu(file->driver_priv, args->ctx_id);
1361         if (!ctx)
1362                 goto out;
1363
1364         /*
1365          * We opt for unserialised reads here. This may result in tearing
1366          * in the extremely unlikely event of a GPU hang on this context
1367          * as we are querying them. If we need that extra layer of protection,
1368          * we should wrap the hangstats with a seqlock.
1369          */
1370
1371         if (capable(CAP_SYS_ADMIN))
1372                 args->reset_count = i915_reset_count(&dev_priv->gpu_error);
1373         else
1374                 args->reset_count = 0;
1375
1376         args->batch_active = atomic_read(&ctx->guilty_count);
1377         args->batch_pending = atomic_read(&ctx->active_count);
1378
1379         ret = 0;
1380 out:
1381         rcu_read_unlock();
1382         return ret;
1383 }
1384
1385 int __i915_gem_context_pin_hw_id(struct i915_gem_context *ctx)
1386 {
1387         struct drm_i915_private *i915 = ctx->i915;
1388         int err = 0;
1389
1390         mutex_lock(&i915->contexts.mutex);
1391
1392         GEM_BUG_ON(i915_gem_context_is_closed(ctx));
1393
1394         if (list_empty(&ctx->hw_id_link)) {
1395                 GEM_BUG_ON(atomic_read(&ctx->hw_id_pin_count));
1396
1397                 err = assign_hw_id(i915, &ctx->hw_id);
1398                 if (err)
1399                         goto out_unlock;
1400
1401                 list_add_tail(&ctx->hw_id_link, &i915->contexts.hw_id_list);
1402         }
1403
1404         GEM_BUG_ON(atomic_read(&ctx->hw_id_pin_count) == ~0u);
1405         atomic_inc(&ctx->hw_id_pin_count);
1406
1407 out_unlock:
1408         mutex_unlock(&i915->contexts.mutex);
1409         return err;
1410 }
1411
1412 #if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
1413 #include "selftests/mock_context.c"
1414 #include "selftests/i915_gem_context.c"
1415 #endif
1416
1417 static void i915_global_gem_context_shrink(void)
1418 {
1419         kmem_cache_shrink(global.slab_luts);
1420 }
1421
1422 static void i915_global_gem_context_exit(void)
1423 {
1424         kmem_cache_destroy(global.slab_luts);
1425 }
1426
1427 static struct i915_global_gem_context global = { {
1428         .shrink = i915_global_gem_context_shrink,
1429         .exit = i915_global_gem_context_exit,
1430 } };
1431
1432 int __init i915_global_gem_context_init(void)
1433 {
1434         global.slab_luts = KMEM_CACHE(i915_lut_handle, 0);
1435         if (!global.slab_luts)
1436                 return -ENOMEM;
1437
1438         i915_global_register(&global.base);
1439         return 0;
1440 }