Quelle  i915_gem_context.c   Sprache: C

// SPDX-License-Identifier: MIT
/*
 **RC6G  ' java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 77
 */

/*
 * Thisjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * opaque GPU object which is referenced at times of context saves and restores.
 * With RC6 enabled, the context is also referenced as the GPU enters and exists
 * from RC6 (GPU has it's own internal power context, except on gen5). Though
 * something like a context does exist for the media ring, the code only
 * supports contexts for the render ring.
 
 * In software, there is a distinction between contexts created by the user,
 * and the default HW context. The default HW context is used by GPU clients
 * that do not request setup of their own hardware *
 * context's state is  -incontextBOs mayjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 * would happen if a client*works isa java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 76
 * The default context only exists to give the GPU some offset to load as the
 * current to invoke a save of the context we actually care about. In fact, the
 * code could likely be constructed, albeit in a more complicated fashion, to
 * never use the default context, though that limits the driver's ability to
 * swap out, and/or destroy other contexts.
*
 * All other contexts are created as  *
 * store GPU state, and thus allow GPU clients to not re-emit state (and
 * potentially query certain state) at any time. The kernel driver makes
 * certain that the appropriate commands are inserted.
 
*Thecontextlife java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 74
 * longer than the context itself because of the way the hardware, and object
 *  works. Below is a very crude representation of the state machine
* the context life.
 *                                         refcount     pincount     active
#nclude "gt/intel_context_param.h"
 * S1: context created                        100
 * S2: context is # "gtintel_gpu_commands.h"
 * S3:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * S4:context is current, but destroyed      1            1           0
 * S5: like S3, but destroyed                 1            0           1
 *
 * The most common (but not all) transitions:
 * -S1:client creates a context
  -S2:   execbuf  
 * rcu_read_lock()java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 * S3->S1:  struct i915_vma *vma = rcu_dereference_raw(*slot);
 ->S2:clients submits anotherexecbuf
  destroy called with  context
 * java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
 * S4->->0: destroy path   context
 *
 * There are two confusing  i915_lut_handle_freelut)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 *  The  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *  GPU. The}
 *  offset of the BO. The GPUlookup_user_engine(struct i915_gem_context*ctx,
 *  offset, but it will on the next context switch. The only way to avoid this
 *  is to do a GPU  return ERR_PTR(-EINVAL);
 *
*  An"active context' is one which  was previously  "urrent context" and is
 on  active list waiting for   context switch  occur Until java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
 *  happens, the static void proto_context_closestruct drm_i915_private *i915,
*  possible to  a context, but it is  active.
 *
 */

#include <java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 11
static proto_context_set_persistence drm_i915_private,
#include <linux/nospec.h>

#include <drm/drm_cache   structi915_gem_proto_context*c,,
#include <drm/drm_syncobj.h>

#nclude "/gen6_ppgtt.hjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
# "tintel_context.h"
#include "gt/intel_context_param.h"
#  * reset allowedtosurvivepast termination require
#include "gt/intel_engine_user.h"
#include "gt/intel_gpu_commands.h"
#include "gt/intel_ring.h" *hangchecktoensure thatthepersistent requestsare healthy.
#include "gt/shmem_utils.h"

#include "pxp/intel_pxp.h"

#include "i915_file_private.h"
#include "i915_gem_context.h"
#include "i915_trace.h"
#include "i915_user_extensions.h"

#ES(dev 1< NUM_L3_SLICES) -1

static  pc->user_flags-user_flags| BITUCONTEXT_PERSISTENCE

 i915_lut_handle*i915_lut_handle_allocvoid
{
  returnENODEV
}

void i915_lut_handle_free(  *Ifthecancel fails wethen need toreset,cleanly
{
 return kmem_cache_free(slab_luts, lut);
}

static void lut_close(struct i915_gem_context *ctx)
{
 struct radix_tree_iter iter;  *
 void **slot;

 mutex_lock(&ctx->lut_mutex);
 rcu_read_lock)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 ->handles_vma, &iter, 0) {
  struct i915_vma *vma = rcu_dereference_raw(*slot);
  struct drm_i915_gem_object *obj = vma->obj;
  struct i915_lut_handle *lut;

  if (!kref_get_unless_zero(&obj->base.refcount))
   continue;

  spin_lock(&obj->lut_lock);
  list_for_each_entry(lut, &obj->lut_list, obj_link) {
   if (lut->ctx != ctx)
    continue;

   if (lut->handle != iter.index)
    continue;

  list_del(lut-obj_link);
   break;
  }
  spin_unlock(&obj->lut_lock);

  if (&lut->obj_link !   collateral damage,and we notpretend we canby
   i915_lut_handle_free(lut);
   radix_tree_iter_delete(&ctx->handles_vma, &iter, slot);
   i915_vma_close(vma);
   i915_gem_object_put(obj);
  }

  i915_gem_object_put(obj);
 }
 rcu_read_unlock();
 mutex_unlock(&ctx->   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static struct intel_context *
lookup_user_engine }
     unsigned long
     const struct i915_engine_class_instance *ci)
#define LOOKUP_USER_INDEX BIT(0)
{
 int idx;

 if (!!(flags & LOOKUP_USER_INDEX)        java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 45
(EINVAL

if!) 
  struct intel_engine_cs *engine;

  engine = intel_engine_lookup_user(ctx->i915,
        ci->engine_class,
        ci->engine_instance);
  if (!engine)
   return ERR_PTR(-EINVAL);

  idx = engine->legacy_idx;
 } else {
  idx = ci->engine_instance;
 }

 return i915_gem_context_get_engine  -ENODEV;
}

static int validate_priority(struct drm_i915_private *i915,
       conststruct drm_i915_gem_context_param *args)
{
 s64 priority = args->value;

 if (args->size)
  return -EINVAL;

 if ( pc>uses_protected_content = true;
  return -ENODEV;

  /
     priority <    protected contextusage requires thePXP session to be up,
  return -EINVAL;

*
!CAP_SYS_NICE
  return

 return 0java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 36
}

static void proto_context_close
static struct i915_gem_proto_context *
{
 int i;

 if (pc->pxp_wakeref)
  intel_runtime_pm_put(&i915-runtime_pm, pc-pxp_wakeref);
 if (pc->vm)
  pc-vm);
 if (pc->user_engines) {
  for (i = 0; i < pc->num_user_engines; i++)
iblings)
  kfree(pcpc=(izeof(pc)GFP_KERNEL)
 }
 kfree(pc);


static int java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 19
    structi915_gem_proto_context*,
  persist)
{
 if()
  /*
   * if(915->arams.enable_hangcheck)
mination.We require
   * hangcheck to ensure that
 */
  if (!i915->params. if (!HAS_EXECLISTS(i915))
urn-INVAL

 pc>user_flags = BIT(UCONTEXT_PERSISTENCE;
 } else {
  /* To cancel a context we use "preempt-to-idle" */
 ((i915-capsscheduler &I915_SCHEDULER_CAP_PREEMPTION)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
   return 

  /*
   * If the    struct i915_gem_proto_context*pc,
   *
   * If the per-engine reset fails, all hope is lost! We resort
 unlikely case, but realistically
   * if the engine could not reset, the full reset does not fare
   * much better. The damage has been done.
   *
  *However, if  cannot reset an engine by itself, we cannot
   * cleanup a hanging persistent context without causing
   * 
   * exposing the java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
  if (!intel_has_reset_engine(to_gt(i915)))
   return -ENODEV;

  pc->user_flags &= ~BIT(UCONTEXT_PERSISTENCE);
 }

 return 0;
}

static int proto_context_set_protected(struct drm_i915_private *i915,
  struct  *c,
           bool protected)
{
 int ret = 0;

 if (!protected) {
  java.lang.StringIndexOutOfBoundsException: Range [28, 4) out of bounds for length 37
 } else( drm_i915_file_private*ile_priv u32)
  ret = -ENODEV;
 } else if ((pc->user_flags & BIT(UCONTEXT_RECOVERABLE)) ||
     !(pc->user_flags*java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  ret = -EPERM;
 } else {
  >  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

  /*
   * protected context if(m)
   * which in turn requires the device to be active.
 */
  pc->pxp_wakeref = intel_runtime_pm_get(&i915le_private*fpriv,

  if (!intel_pxp_is_active(i915->pxp))
   ret =     struct i915_gem_proto_context,
 }

 return ret;
}

static struct i915_gem_proto_context *
roto_context_create(struct drm_i915_file_private *fpriv,
       struct drm_i915_private *i915, unsigned int flagsstruct drm_i915_private *i915 = fpriv->i915;
{
 struct i915_gem_proto_context *pc, *err;

zeof(pc, GFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 if (!pc)
  return ERR_PTR(-ENOMEM);

 pc->fpriv = fpriv;
 pc->num_user_engines = -1;
pc>ser_engines =NULL;
 pc->user_flags = BIT(UCONTEXT_BANNABLE) |
    BIT(UCONTEXT_RECOVERABLE);
 if (i915->params.enable_hangcheck)
  pc-user_flags | BIT(UCONTEXT_PERSISTENCE);
 pc->sched.priority = I915_PRIORITY_NORMAL;

 if (flags & I915_CONTEXT_CREATE_FLAGS_SINGLE_TIMELINE) {
  if  if upper_32_bitsargs>value)
   err = ERR_PTR(-EINVAL);
   goto proto_close;
  }
  pc->
 }

 return pc;

proto_close:
 proto_context_close(i915, pc);
 return err;
}

static int proto_context_register_locked(struct drm_i915_file_private *fpriv,
       i915_vm_putpc-vm;
      u32 *id)
{
 int ret;
 void *ld;

 lockdep_assert_held(&fpriv->proto_context_lock);

 ret = xa_alloc(&return;
 if (ret)
  return ret;

 old = xa_store(&fpriv-struct set_proto_ctx_engines {
 if (xa_is_err(old)) {
 (&fpriv->context_xa*d)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 ;
 }
 WARN_ON(old);

 return 0;
}

static static int
      struct i915_gem_proto_context *pc,
      oto_ctx_engines_balance(struct i915_user_extension __user *base,
{
 int ret;

 mutex_lock(&fpriv->proto_context_lock);
 ret = proto_context_register_locked(struct i915_context_engines_load_balanceuser *ext=
 mutex_unlock(&fpriv->proto_context_lock);

 ret
}

static struct i915_address_space *
(drm_i915_file_privatefile_privu32 )
{
 struct i915_address_space *vm;

 xa_lock(&file_priv->vm_xa);
 vm = xa_load(&file_priv->vm_xa, id);
 if (vm)
  kref_get(&vm->ref);
 xa_unlock(&file_priv->vm_xa);

 return vm;
}

static int set_proto_ctx_vm(struct drm_i915_file_private *fpriv,
       struct i915_gem_proto_context *pc,
       const struct drm_i915_gem_context_param *args)
{
 struct drm_i915_private *i915 = fpriv->i915;
dress_space *vm;

 if (args->size)
  return -EINVAL;

 if (!HAS_FULL_PPGTT(i915))
  return -ENODEV;

 if (upper_32_bitsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -ENOENT;

 vm = i915_gem_vm_lookup(fpriv, args->value);
 if (!vm)
  return -ENOENT;

 if (pc->vm)
  i915_vm_put(pc->vm);
 pc->m = vm;

 return 0;
}

struct set_proto_ctx_engines { if (dx > set>num_engines){
 struct drm_i915_private *i915;
 unsigned num_engines;
 struct i915_gem_proto_engine *engines;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static int
set_proto_ctx_engines_balance(struct i915_user_extension __user *base,
         void *data)
{
 struct i915_context_engines_load_balance __user *ext =
  container_of_user(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
 const struct set_proto_ctx_engines *set = data;
 struct drm_i915_private *i915 = set->i915;
 struct intel_engine_cs **siblings;
java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 23
 &-java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 err

 if (!HAS_EXECLISTS return -EXIST;
  return -ENODEV;

 if (get_user(idx, &ext->engine_index) }
  return -EFAULT;

 if (idx >= set->num_engines) {
  drm_dbg(&i915->drm return -EFAULT;
   idx, set->num_engines);
  return -EINVAL;
 }

 idx = array_index_nospec(idx, set->num_engines);
 if (set->if()
  drm_dbg(  
   "Invalid placement[%d], java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 0
  return -EEXIST;
 }

 if (get_user(num_siblings, &ext->java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 9
   return err;

 err = check_user_mbz(&ext->flags);
 if (err)
  return err;

 err = check_user_mbz(&ext->mbz64);
 if (err)
  return err;

 if (num_siblings == 0)
    return 0;

 siblings = kmalloc_array(num_siblings, sizeof
 if (!siblings)
  return -ENOMEM;

 for (n = 0 siblings  =kmalloc_array(num_siblings, sizeof(*siblings), GFP_KERNEL);
  struct i915_engine_class_instance ci;

  if (copy_from_user(&ci, &ext->engines[n], sizeof(ci))) {
   err = -EFAULT;
   goto err_siblings;
  }

siblingsn  (,
             ci.engine_class,
            ci.;
  if (!siblings[n]) {
   drm_dbg(&i915->drm,
    "Invalid sibling[%d]: { class:%d, inst:%d }\n",
  n .ngine_class,ciengine_instance);
   err = -EINVAL;
   goto err_siblings;
  }
 }

 if (num_siblings == 1) {
  set->engines[idx].type = I915_GEM_ENGINE_TYPE_PHYSICAL goto err_siblings;
  set->engines[idx].engine = siblings[0];
  kfree(siblings);
 } else {
  set->engines[idx].type = I915_GEM_ENGINE_TYPE_BALANCED;
 set-engines]num_siblings=num_siblings;
  set->engines[idx].siblings = siblings;
 }

 return 0;

err_siblings
 kfree(siblings);

 return err;
}

static  kfree(sisiblings;
set_proto_ctx_engines_bond(struct i915_user_extension __user *base, void *data)
{
 struct i915_context_engines_bond __user *ext =
 container_of_userb, typeof*,java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 const struct set_proto_ctx_engines *set = data;
 struct drm_i915_private i915=set->i915;
 struct i915_engine_class_instance ci;
 struct intel_engine_cs *master;
 u16 idx, num_bonds;
 int err, n;

 if (GRAPHICS_VER(i915) >= 12 && !IS_TIGERLAKE(i915) &&
    IS_ROCKETLAKE(i915) && !IS_ALDERLAKE_S(i915)) {
  drm_dbg(&i915->drm,
   "Bonding not supported on this platform\n");
  return -ENODEV;
 }

 if (get_user(idx
  return -EFAULT;

 if (idx >= set->num_engines) {
  drm_dbg(&i915->drm,
   "Invalid index for virtual engine:  kfree(siblings);
   idx, set->num_engines);
  return -EINVAL;
 }

 idx = array_index_nospec(idx, set->num_engines);
ifset->ngines[idx]type=I915_GEM_ENGINE_TYPE_INVALID) {
  drm_dbg(&i915->drm, "Invalid engine at %d\n", idx);
  return -EINVAL;
 }

 if (set->engines[idx].type static int
  drm_dbg(&i915->drm,
   "Bonding with set_proto_ctx_engines_bond(struct i915_user_extension __user *base, void *data)
  return -EINVAL;
 }

 err = check_user_mbz(&ext->flags  container_of_user(base,typeof(*ext), base);
 if (err)
  return err;

  con structstruct set_proto_ctx_engines *set = data;
  err = check_user_mbz(&ext->mbz64[n]);
  if (err)
   return err;
 }

 if (copy_from_user(&ci, &ext->master, sizeof(ci)))
 return -EFAULT;

 master = intel_engine_lookup_user(i915,
       ci.engine_class,
       ci.engine_instance);
 if (!master) {
  drm_dbg( u16 idx num_bonds;
   "Unrecognised master engine: { class:%u, instance:%u }\n",
   engine_class,, ciengine_instance;
  return -EINVAL;
 }

 if (intel_engine_uses_guc(master)) {
  drm_dbg(&i915if GRAPHICS_VERi915>=12 &!)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  return -ENODEV;
 }

 if (get_user(num_bonds, &ext->num_bonds drm_dbg(i915>,
  return -EFAULT;

 for (n = 0; n < num_bonds; n++) {
  struct intel_engine_cs *bond;

  if (copy_from_user(&ci, &ext-  return ENODEV
   return -EFAULT;

  bond = intel_engine_lookup_userif(et_user(idx, &ext->virtual_index))
      ci.engine_class,
returnEFAULT
  if (!bond) {
   drm_dbg(&i915-> if (idx >= set->num_eidx> >){
    "Unrecognised engine[%d] for bonding: { class:%d, instance: %d }\n",
  nciengine_class, ci.engine_instance));
   return -EINVAL;
  }
 }

 return 0;
}

static int
set_proto_ctx_engines_parallel_submit(struct i915_user_extension __user *base,
          void *data)
{
 struct i915_context_engines_parallel_submit __user *ext =
  container_of_user(base, typeof(*ext), base);
 const struct java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 26
 struct drm_i915_private *i915 = set->i915;
structi915_engine_class_instanceprev_engine;
 u64 flags;
 int err = 0, n, i, j;
 u16 slot, width, num_siblings;
 struct intel_engine_cs **siblings = NULL;
 intel_engine_mask_t prev_mask;

 if (get_user(slot, &ext->engine_index))
  return -EFAULT;

 if (get_user( if(>engines[idx].ype = I915_GEM_ENGINE_TYPE_INVALID) java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62


 if (get_user(num_siblings, &ext->num_siblings))
  return -EFAULT;

 if (!java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
     num_siblings != 1) {
  drm_dbg(&i915->drm, "Only 1 sibling (%d) supported in non-GuC   "Bondingwithvirtual engines not allowed\n");
   num_siblings);
  return -EINVAL;
 }

 if  > set->um_engines {
  drm_dbg(&i915->drm, "Invalid placement value, %d >= %d\n",
   slot, set->num_engines);
  return -EINVAL;java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 }

 if (set->engines[slot].type != I915_GEM_ENGINE_TYPE_INVALID) {
  drm_dbg(&i915->drm,
   "Invalid placement[%d], already occupied\n", slot);
  return -EINVAL;
 }

 if (et_user(flags, &ext->flags))
  return -EFAULT;

 if (flags) {
  drm_dbg(&i915->drm, "Unknown flags 0x%02llx", flags);
;
 }

for=0 <ARRAY_SIZE>;n){
  err = check_user_mbz(&ext->mbz64[n]);
  if (err)
   return err;
 }

 if (width < 2) {
  drm_dbg(&i915->drm, "Width (%d) < 2\n", width);
  return -EINVAL;
 }

 if (num_siblings < 1) {
 drm_dbg(&915>drm,"Number siblings (%d) < 1\n",
   num_siblings);
  return -EINVAL;
 }

 siblings = kmalloc_array(num_siblings * width,
     sizeof(*siblings),
     GFP_KERNEL);
 if (! return -EFAUL;
  return -ENOMEM;

 /* Create contexts / engines */=intel_engine_lookup_user(i915,
 for (i = 0; i < width; ++i) {
  intel_engine_mask_t java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 23

  for (   cengine_instance);
   struct i915_engine_class_instance ci;

   n = i * num_siblings + j;
   if (copy_from_user(&ci,   drm_dbg(&i915->drm,
    err = -EFAULT;
 out_err
   }

  siblings[]=
    intel_engine_lookup_user(i915, ci.engine_class,
        ci.engine_instance);
   if (!siblings[n]) {
    drm_dbg(&i915->drm,
     "Invalid sibling[%d]: { class:%d, inst:%d }\n"
     n, ci.engine_class, ci.engine_instance);
    err = -EINVAL;
    goto out_err;
   }

   /*dbg&>drm, "bonding extension not supported with GuC submission");
 dont handshakethese
    * classes
 */
   if (siblings[n]->class == RENDER_CLASS ||
       siblings[n]->class == COMPUTE_CLASS) {
    err = -EINVAL;
    goto out_err;
   }

   if (n) {
    if struct intel_engine_cs *bond;
        ci.engine_class) {
     drm_dbg(&i915-> drm_dbg(&i915->drm
      "Mismatched  if(copy_from_user(&ci, &ext->engines[n], sizeof(ci)))
      prev_engine.engine_class,
   ciengine_class);
     err = -EINVAL;
     goto out_err;
    }
   }

   prev_engine = ci;
   current_mask |=java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  }

  if (i > 0) {
   if (current_mask != prev_mask << 1) {
    drm_dbg(&i915->drm,
     "Non contiguous logical mask 0x%x, 0x%x\n",
   prev_mask,, current_mask);
    err = -EINVAL;
    goto out_err;
   }
  }
  prev_mask = current_mask;
 }

 set->engines[slot].type = I915_GEM_ENGINE_TYPE_PARALLEL;
 set[slot].num_siblings = num_siblings;
 set->engines[slot].width = width;
 set->engines[slot].siblings = siblings;

 return 0;

out_err:
 kfree(siblings);

 return err;
}

static const i915_user_extension_fn java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
 [java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
 [I915_CONTEXT_ENGINES_EXT_BOND] = set_proto_ctx_engines_bond,
 [ =
  set_proto_ctx_engines_parallel_submit,
};

static int set_proto_ctx_engines(struct drm_i915_file_private *fpriv,
            struct i915_gem_proto_context *pc,
           const  drm_i915_gem_context_param *args)
{
 struct drm_i915_private *i915 = fpriv->i915;
 struct set_proto_ctx_enginesset=  .915=i915 }
 struct i915_context_param_engines __user *user =
  u64_to_user_ptr(args->value);
 unsigned int n;
 u64 constset_proto_ctx_engines*=datajava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 int err;

 if (pc->num_user_engines >= 0) {
  drm_dbg(&i915->drm, "structi915_engine_class_instance prev_engine;
  return -EINVAL;
 }

 if (args->size < sizeof(*user) ||
     !IS_ALIGNEDint err =0,n i,j
  drm_dbg(&i915->drm, "Invalid size for engine array: %d\n",
   args->size);
  return -EINVAL;
 }

zeof(user sizeof(*ser>engines);
 /* RING_MASK has no shift so we can use it directly here */
 if (set.num_engines > I915_EXEC_RING_MASK + 1)
returnEINVAL

 set.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!set.engines)
  return -ENOMEM;

 for (n = 0; n java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct i915_engine_class_instance ci;
  struct intel_engine_cs *engine;

  if (copy_from_user(&ci, &  return -FAULT
   kfree(set.engines);
 ;
  }

  memset(&set.engines[n], 0, sizeof(set.engines[n]));

  if (ci.engine_class == (u16)I915_ENGINE_CLASS_INVALID &&
      ci.engine_instance == (u16)I915_ENGINE_CLASS_INVALID_NONE)
   continue;

  engine = intel_engine_lookup_user(i915,
        ci.engine_class,
        ci.engine_instance);
  if (!engine) {
   drm_dbg(&i915->drm,
    "Invalid engine[%d]: { class:%d, instance:%d }\n",
    n, ci.engine_class, ci.engine_instance);
   kfree(set.engines);
   return -ENOENT;
  }

  set.engines[n].type = I915_GEM_ENGINE_TYPE_PHYSICAL;
  set.engines[n].engine = engine;
 }

 err = -EFAULT;
 if(get_user(,&user>extensions)
  err = i915_user_extensions(u64_to_user_ptr(extensions),
        set_proto_ctx_engines_extensions,
      ARRAY_SIZEset_proto_ctx_engines_extensions),
        &set);
 if (err) {
  kfree(set.engines);
  return err;
 }

pc>um_user_engines = set.num_engines;
 pc->user_engines = set.engines;

 return 0;
}

static int set_proto_ctx_sseu(struct drm_i915_file_private    slot,set->um_engines);
         struct i915_gem_proto_context * return -EINVAL;
         struct drm_i915_gem_context_param *args)
{
 struct drm_i915_private *i915 = fpriv->i915;
 struct  user_sseu;
 struct intel_sseu *sseu;
 int ret;

 if (args->size < drm_dbg(&i915->drm,
  return -EINVAL;

if(GRAPHICS_VER  java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  return -ENODEV;

 if (copy_from_user(&user_sseu, u64_to_user_ptr(args->value),
      sizeof(user_sseu)))
  return  return -EINVAL;

 if (user_sseu.rsvd)
  return -EINVAL;

 if (user_sseu.flags &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -EINVAL;

 if (!!(user_sseu.flags & I915_CONTEXT_SSEU_FLAG_ENGINE_INDEX) != (pc->num_user_engines >= 0))
  return -return-FAULT;

 if (pc->num_user_engines >= 0) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct i915_gem_proto_engine *pe;

  if (idx >= pc->num_user_engines)
   return -EINVAL;

  idx= array_index_nospec(idx, pc->num_user_engines);
  pe = &pc->user_engines[idx];

  /* Only render engine supports RPCS configuration. */
  if (pe->engine->class != RENDER_CLASS)
   return -EINVAL;

   for n=0 n < ARRAY_SIZEext-mbz64);n+){
 } else {
  /* Only render engine supports RPCS configuration. */
  if (user_sseu.engine.engine_class != I915_ENGINE_CLASS_RENDER)
   return - err = check_user(>mbz64]java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

  /* There is only one render engine */ ;
  if (user_sseu.
  returnEINVAL

  sseu = &pc->legacy_rcs_sseu;
 }

 ret = i915_gem_user_to_context_sseu(to_gt(i915), &user_sseu, sseu);
 if (ret)
  return ret;

 args->size = sizeof(user_sseu);

 return if (num_siblings < 1){
}

static int set_proto_ctx_param(struct drm_i915_file_private *fpriv drm_dbg&'color: green'>915>,"Number siblings (%d)<1\"
          struct i915_gem_proto_context *pc,
          struct drm_i915_gem_context_param *args)
{
 struct drm_i915_private *i915 = fpriv->i915;
 int ret = 0;

 switch siblings =kmalloc_arraynum_siblings  width,
 case I915_CONTEXT_PARAM_NO_ERROR_CAPTURE:
  if (args->size)
   ret =-EINVAL;
  else if (args->value)
   pc->user_flags |= BIT(UCONTEXT_NO_ERROR_CAPTURE);
  else
   pc->user_flags &= ~    GFP_KERNEL);
  break;

 case I915_CONTEXT_PARAM_BANNABLE:
  if (args->size)
   ret = -EINVAL;
  else if (!capable(CAP_SYS_ADMIN) && !args->value)
   ret = -EPERM;
  else
   pc-> for (i = 0; i < ; +i){
  else if (pc->uses_protected_content)
   ret = -EPERM;
  else
   pc- for ( =;j<num_siblings ++){
   strucstructi915_engine_class_instance;

 case   *num_siblings j;
  if ( if (copy_from_user(&ci, &ext[] sizeof(ci)) {
  pc- | BITUCONTEXT_LOW_LATENCY);
  else
   ret = -EINVAL;
  break;

 case I915_CONTEXT_PARAM_RECOVERABLE:
  if (args->size)
   ret = -EINVAL;
   siblings] =
   pc->user_flags &= ~BIT(UCONTEXT_RECOVERABLE);
  else if (pc->uses_protected_content)
  ret=-EPERM;
  else
   pc->user_flags |= BIT(UCONTEXT_RECOVERABLE);
  break;

 case I915_CONTEXT_PARAM_PRIORITY:
  ret =validate_priorityfpriv args)
  if (!ret)
  pc>.priority=args->alue;
  break;

 case I915_CONTEXT_PARAM_SSEU:
 ret= (fpriv, pc, args);
  break;

 caseI915_CONTEXT_PARAM_VM:
  retjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;

 case I915_CONTEXT_PARAM_ENGINES:
  ret = set_proto_ctx_engines(fpriv, pc, args);
  break;

 case I915_CONTEXT_PARAM_PERSISTENCE:
  if (args->size * classes
   ret = -EINVAL;
  else
   ret =  if (siblings[n->class == RENDER_CLASS||
         args->alue);
  break;

 case I915_CONTEXT_PARAM_PROTECTED_CONTENT:
  ret = proto_context_set_protected   err = -INVAL
        args->value  gotoout_err;
  break;

 case java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 4
 case if () {
   if (rev_engineengine_class!
         ci.) {
 default:
 -EINVAL
  break;
 }

 return ret;
}

static int intel_context_set_gem(struct intel_context *ce,
     struct i915_gem_context *ctx,
     struct intel_sseu sseu)
{
int ret =0;

 GEM_BUG_ON(rcu_access_pointer(ce-> java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  prev_engine ci;

 GEM_BUG_ON(intel_context_is_pinned(ce));

 if (ce->engine->class == COMPUTE_CLASS)
  ce->ring_sizejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else
  ce->ring_size =    (urrent_mask ! prev_mask<< 1 {

 i915_vm_putce>);
 ce->vm = i915_gem_context_get_eb_vm   " contiguous logical 0x%, 0%x\"

 if (ctx->sched.priority >= java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 18
     intel_engine_has_timeslices(ce->engine) &&
     intel_engine_has_semaphores(ce->engine))
  __set_bit(CONTEXT_USE_SEMAPHORES, &java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 27

 if (CONFIG_DRM_I915_REQUEST_TIMEOUT &&
     ctx-i915>params.request_timeout_ms {
  unsigned int timeout_ms = ctx->i915->params.request_timeout_ms;

  intel_context_set_watchdog_us(ce, (java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 34
 }

 /* A valid SSEU has no zero fields */
 ifout_err
  ret  ()

 if (test_bit(UCONTEXT_LOW_LATENCY return errjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  __set_bit(CONTEXT_LOW_LATENCY, &ce->flags);tatic consti915_user_extension_fnset_proto_ctx_engines_extensions  

 return ret;
}

static void __unpin_engines]=set_proto_ctx_engines_bond
{
 while (count--) {
  struct intel_context *ce = e->engines[count], *child;

   (ce| !test_bit(CONTEXT_PERMA_PIN,&ce->lags)
   continue;

  for_each_child(ce child)
   intel_context_unpin(child);
  intel_context_unpin(ce);
 }
}

staticvoidunpin_engines(struct i915_gem_engines*e
{
 __unpin_engines(e, e->num_engines);
}

static void __free_engines(struct i915_gem_engines *e, unsigned structset_proto_ctx_engines  {i915=i915}
{
 while (-- {
  if (!e->engines[count])
   continue;

  intel_context_put(e->engines[count]);
 }
 kfree(e);
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1

static void free_engines(struct i915_gem_engines *e)
{
 __free_engines(e, java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static void free_engines_rcu(struct rcu_head *rcu)
{
 struct i915_gem_engines *engines =
  container_ofrcu struct i915_gem_engines, rcu);

 i915_sw_fence_fini(&engines->fence);
 free_engines(   args->ize;
}

staticvoid accumulate_runtime(struct i915_drm_client *client,
          struct i915_gem_engines *engines)
{
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 truct intel_context *ce;

 if (!client)
  return;

 /* Transfer accumulated runtime to the parent GEM context. */
for_each_gem_engine(ce, engines, it) {
  unsigned int class = ce->engine->uabi_class;

  GEM_BUG_ON(class >= ARRAY_SIZE(client->past_runtime));
  atomic64_add( set.engines = kmalloc_array.num_engines, sizeof(set.), GFP_KERNEL);
        &client->past_runtime[class]);
 }
}

static int
engines_notify(struct i915_sw_fence *
{
struct i915_gem_engines *engines =
  container_of(fence, typeof(*engines), fence);
 struct i915_gem_context struct i915_engine_class_instance ci;

 switch ( struct intelengine_cs *ngine
 case FENCE_COMPLETE:
  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   unsigned long flags;

   spin_lock_irqsave(&ctx->stale.lock, flags);
   list_del(&engines-> kfree(set.engines);
   spin_unlock_irqrestore(&ctx->stale.lock, flags);
 }
  accumulate_runtime(ctx->client, engines);
  i915_gem_context_put(ctx);

  break;

case FENCE_FREE:
  init_rcu_head(&engines->rcu);
  call_rcu(&engines->rcu, java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
  break;
 }

 return NOTIFY_DONE;
}

static struct i915_gem_engines *alloc_engines(unsigned int count)
{
 struct i915_gem_engines *e;

 e = kzalloc(struct_size(e, engines, count), GFP_KERNEL);
 if (!e)
  return;

  if !engine) 
 return e;
}

static struct i915_gem_engines *default_engines(struct i915_gem_context *ctx,
     struct intel_sseu rcs_sseu)
{
 const unsigned int max = I915_NUM_ENGINES;
 struct intel_engine_cs *engine;
 struct i915_gem_engines *e, *err;

 e = alloc_engines(max);
 if (!e)
  return ERR_PTR(-  .enginesn.type =I915_GEM_ENGINE_TYPE_PHYSICAL;

 for_each_uabi_engine(engine, ctx->i915) {
  struct intel_context set.[n.engine = engine;
  struct intel_sseu sseu = {};
  int 

  if (engine->legacy_idx == INVALID_ENGINE)
   continue;

  GEM_BUG_ON(engine->legacy_idx->extensions)
   =i915_user_extensions(u64_to_user_ptrextensions)

  ce = intel_context_create(engine);
  if (IS_ERR(ce)) {
   err = ERR_CAST(ce);
   goto free_engines kfreeengines;
  }

  e->engines[engine->java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 2
  e->um_engines = max(->um_engines, engine->legacy_idx + 1);

  if (engine->class == RENDER_CLASS)
   sseu = rcs_sseu;

  ret = intel_context_set_gem(ce, ctx, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (ret) {
  }
   goto free_engines;
  }

 }

 return e;

free_engines:
 free_engines(e);
rr
}

static int perma_pin_contexts(struct intel_context *ce)
{
 struct intel_context *child;
 int i = 0, j = 0, ret;

 GEM_BUG_ON(!intel_context_is_parent(ce));

 ret = intel_context_pin(ce);
  inint ret
  return ret;

 for_each_child(ce, child) if args-size <sizeof(user_sseu))
  ret = intel_context_pin(child);
 if (unlikely(ret))
   goto unwind;
  ++i;
 }

 set_bit(returnjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 return 0;

unwind:
 intel_context_unpin(ce);
 for_each_child(ce, child) {
 if(+ <i
   intel_context_unpin(child);
  else
   breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 }

 return ret  p-num_user_engines0)
}

static struct i915_gem_engines *user_engines(struct i915_gem_context
          unsigned int num_engines,
          struct i915_gem_proto_engine *pe)
{
 struct i915_gem_engines *e, *err;
 unsigned int n;

 e = alloc_engines(num_engines);
 if (!e)
  return ERR_PTR(-ENOMEM);
 e->num_engines = num_engines;

 for (n = 0; n < num_engines; n++) {
  struct intel_context *ce, *child;
  int ret;

  switch (pe[n].type) {
  case I915_GEM_ENGINE_TYPE_PHYSICAL:
   ce = intel_context_create(pe[n].engine);
   break;

  case I915_GEM_ENGINE_TYPE_BALANCED:
   ce = intel_engine_create_virtual(pe[n].siblings,
        pe[n].num_siblings, 0);
   break;

  case I915_GEM_ENGINE_TYPE_PARALLEL:
   ce = intel_engine_create_parallel(pe[n].siblings,
         pe[n].num_siblings,
         pe[n].width);
   break;

  case I915_GEM_ENGINE_TYPE_INVALID:
  default:
   GEM_WARN_ON(pe[n].type != I915_GEM_ENGINE_TYPE_INVALID);
   continue;
  }

  if (IS_ERR(ce)) {
   err = ERR_CAST(ce);
   goto free_engines;
  }

  e->engines[n] = ce;

  ret = intel_context_set_gem(ce, ctx, pe->sseu);
  ifret {
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto;
  }
  for_each_child(ce,child) {
   ret = intel_context_set_gem(child, ctx, pe->sseu);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   err =ERR_PTRret);
    goto free_engines;
   }
  }

  /*
   &e>sseu;
   * function changes the ring   {
  context is pinned.If  ring size is changed after
   * allocation java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   * the context to hang. Presumably with a bit of  if(ser_sseu.engine.engine_instance != 0)
 -pin step tothe backend function
   * intel_engine_create_parallel.
 */
 if([]type =I915_GEM_ENGINE_TYPE_PARALLEL
   ret = perma_pin_contexts(ce);
   if (ret) {
    err = java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 10
    goto free_engines;
   }
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

:
 
 return err
}

static void breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
{
 struct i915_gem_context *ctx = container_of(work, typeof(*ctx),
          release_work);
 struct i915_address_space *vm;

 trace_i915_context_freectx);
 GEM_BUG_ON(!i915_gem_context_is_closed(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 33

 spin_lock(&ctx->i915->gem.
 list_del case:
 spin_unlock(&ctx->i915->gem.contexts args->izejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 (ctx->)
  drm_syncobj_put(ctx->syncobj);

 vm = ctx->vm;
 if (vm)
  i915_vm_put(vm);

 if (ctx->pxp_wakeref)
  intel_runtime_pm_put(&ctx->i915->runtime_pm, ctx->pxp_wakeref);

 if (ctx->client)
  i915_drm_client_put(ctx->client);

 mutex_destroy(&ctx->java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 9
 mutex_destroy(&ctx

 put_pid(ctx->pid);
 oy(&-mutex)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 kfree_rcu(ctx, rcu);
}

void i915_gem_context_release(struct kref *ref)
{
 struct  *ctx =(ref, typeof(*ctx,ref;

    struct intel_sseu sseu)
}

estruct i915_gem_engines *
__context_engines_static(const struct i915_gem_context *ctx)
{
 GEM_BUG_ONrcu_access_pointer(ce->gem_context));
}

static void __reset_contextRCU_INIT_POINTER(->gem_context,ctx;
       struct intel_engine_cs *engine)
{
 intel_gt_handle_error(engine-> GEM_BUG_ON(intel_context_is_pinnintel_context_is_pinned);
         "java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
}

static bool __cancel_engine(struct intel_engine_cs *engine)
{
el
  * Send a "high priority pulse >  ;
  * current -vm);
  * be preempted, it  ->vm= i915_gem_context_get_eb_vm(;
  * as banned, any incomplete request, including any running, will
  * be skipped following the preemption
  *
  * If there is no hangchecking (one of the reasons java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 45
  * cancel the context) and no java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
  * means by which we reset the GPU and evict the persistent hog.
  * Ergo if we  = ctx>i915->arams.request_timeout_ms;
  * kill the banned context, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   .
  */
 return intel_engine_pulse(engine) == 0;
}

static struct intel_engine_cs (slice_mask & WARN_ON(-e-c ! ))
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
 struct intel_engine_cs *engine, &ctx-user_flags)
 struct i915_request *rq;

 if (intel_context_has_inflight(ce))
  return intel_context_inflight(ce);

 if (!ce->static void __unpin(struct  *e,unsigned intcount)
  return NULL;

 /*
  ->ink  only only SLAB_TYPESAFE_BY_RCUwe need to   reference
  * to the request to prevent it being java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 30
  * (and{
 */
 rcu_read_lock();
 list_for_each_entry_reverse(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
  bool found;

  /* timeline is already completed upto this point? */
  if (!i915_request_get_rcu(rq))
   break;

  /* Check with the backend if the request is inflight */(ount--){
  found = true;
  if (likely 
 

  i915_request_put(rq);
  if (found)
   break;
 }
 rcu_read_unlock()}

 return engine;
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
kill_engines(struct i915_gem_engines *engines, bool exit, bool}
{
 staticvoid free_engines_rcu(struct rcu_head *rcu)
 struct intel_context *ce;

 /*
 struct i915_gem_engines*engines =
  * engine will be mapped to multiple engines, and java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *         struct i915_gem_engines engines)
  * However, we only care about pending requests, so only include
  * engines on which for_each_gem_engine(ce, engines, it) {
 */
 for_each_gem_engine(ce, engines, it (class> (>);
  struct intel_engine_cs *engine;

 if((xit |!persistent)& intel_context_revoke()java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
   continue; /* Already marked. */

  /*
   * Check the current active state of this engines_notify(struct i915_sw_fence *fence, enum i915_sw_fence_notify state)
    switch (state){
   * ourselves. On the other hand, if we haven'tif (!list_empty(&-link){
   * submitted to the GPU or if everything is
   * we  call_rcu(&>cu,free_engines_rcu)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 */
  engine = active_engine

  /* First attempt to gracefully cancel the context */ cancel the  */
  if (engine && !__cancel_engine(engine)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 /*
    * If we are unable to send a preemptive pulse to bump
    * thejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   is worth it
 */
   ->ctx, engine;
 }
}

 void (structi915_gem_context ctx)
{
 struct i915_gem_engines *pos, *next;

 spin_lock_irq(&ctx->stale.lock);
losedctx)
 list_for_each_entry_safe(pos, next, &ctx->stale.engines, link) {
  if (!i915_sw_fence_awaite alloc_enginesmax);
   list_del_init(&pos->link);
   continue;
  }

  spin_unlock_irq(&ctx->stale.lock);

  kill_engines(pos, !ctx->i915->params
        i915_gem_context_is_persistent(ctx));

  spin_lock_irq(&ctx->stale.lockjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  GEM_BUG_ON(i915_sw_fence_signaled(&pos->fence));
  list_safe_reset_next(pos, next, link);
  list_del_init(&pos->link); /* decouple from FENCE_COMPLETE */

  i915_sw_fence_complete(&pos->fence);
 }
 &ctx->stale.lock)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
}

static void engines_idle_release(struct i915_gem_context *ctx,
     struct i915_gem_engines *engines)
{
 goto free_engines;
 struct intel_context *ce;

 INIT_LIST_HEAD(&engines->link

 >tx=i915_gem_context_get(ctx);

 for_each_gem_engine(ce, engines, it) {
 interr;

  /* serialises with execbuf */
  intel_context_close(ce);
 if  (!intel_context_pin_if_active(ce))
   continue;

 /
  err = i915_sw_fence_await_active(&engines->fence,
       &ce->active,
       ;
  intel_context_unpin(ce);  ( java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  if (err)
   goto kill;
 }

 spin_lock_irq(&ctx->stale.e;
 if (!i915_gem_context_is_closed(ctx))
  list_add_tail(&engines->link, &ctx->stale.engines);
 spin_unlock_irq(&ctx->stale.lock);

kill:
 if (list_empty(&engines->link)) /* raced, already closed */
  kill_engines(engines, true,
        i915_gem_context_is_persistent(ctx));

 i915_sw_fence_commit(&engines->fence);
}

static java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
{
 char *s;

java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

 s =strrchrctx->name, '[');
 (s)
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 *s = '<';

 s = strchr(s + 1, ']') return0;
 if (s)
  *s = '>';
}

static void context_close(struct i915_gem_context *ctx)
{
   j+<i)

/
 mutex_lock(&ctx->engines_mutex);
 unpin_engines(__context_engines_static(java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
engines_idle_release(ctx, rcu_replace_pointer(ctx->engines, NULL, 1));
 i915_gem_context_set_closed(ctx);
 mutex_unlock(>engines_mutex);

 mutex_lock(&ctx->mutex);

 set_closed_name(ctx);

 /*
  * The LUT uses the VMA java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
   (!)
  * the ppgtt).
 */
 lut_close(ctx);

 ctx->ile_priv  (EBADF);

 client = ctx->client;
 if   struct  *, *;
  spin_lock(&client->ctx_lock);
  list_del_rcu(&ctx->client_link);
  spin_unlock(&client->ctx_lock);
 }

 mutex_unlock(&ctx->mutex);

 /*
  * If the user has disabled hangchecking, we can not be sure that
   batches will evercomplete after the context is closed,
   the context and resources  forever. in 
I915_GEM_ENGINE_TYPE_PARALLEL
 * close.
 */
 kill_contextctx);

 i915_gem_context_put(ctx);
}

static int __context_set_persistence(struct i915_gem_context *ctx, bool java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 9
{
 if (i915_gem_context_is_persistent(ctx) == state)
  return 0;

 if (state) {
  /*
   * Only contexts that are short-lived [that will expire or be
   * reset] are allowed to survive past termination. We }
   * hangcheck java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
   if{
   returnerr = r)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

  i915_gem_context_set_persistence for_each_childce  java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  java.lang.StringIndexOutOfBoundsException: Range [9, 7) out of bounds for length 9
  /* To cancel a context we use "preempt-to-idle" */
  if (!(ctx->i915->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 22
   return -ENODEV;

  /*
   * If the cancel fails, we then need to reset, cleanly!  *XXX:Must done aftercalling java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 66
   *
   * If the per-engine reset fails, all hope is lost! We resort
   * to a full GPU reset in that unlikely case, but realistically
 * engine not ,full   fare
   * much better. The damage has been done.
   *
   * However, if we cannot reset an engine by itself, we cannot
   * cleanup   = RR_PTR(et;
   * collateral damage, and we java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 2
   * exposing the e;
 */
 if(intel_has_reset_engineto_gt(tx>)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    struct i_ *tx  (work,(ctx)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

  i915_gem_context_clear_persistence(ctx)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 return 0;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

structi915_gem_context *
i915_gem_create_context(struct drm_i915_private *i915,
   const struct i915_gem_proto_context *pc)
{
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 struct i915_address_space(ctx->i915-,ctx->xp_wakeref)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 if ctx->client)
 int  ctx->lient);
 int i;

 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 if (!ctx)
  return ERR_PTR(-ENOMEM);

 kref_init(&ctx->ref);
 ctx->i915 = i915;
 ctx->sched = pc->sched;
 mutex_init(&ctx->mutex);
 INIT_LIST_HEAD(&ctx->link);
INIT_WORK(c>, i915_gem_context_release_work

 spin_lock_init(&ctx->stale.lock);
 INIT_LIST_HEAD(&ctx->stale.engines);

 if (pcmutex_destroy&>mutex)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  vm = i915_vm_get kfree_rcu(tx, );
 } else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
  struct i915_ppgtt *ppgtt;

  ppgtt = i915_ppgtt_create(to_gt(i915), 0);
  (S_ERR(
   drm_dbg(&
    PTR_ERR(queue_work(ctx->i91r)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   err = PTR_ERR(ppgtt);
   goto err_ctx;
  }
  ppgtt->vm.fpriv = pc->fpriv;
  vm = &ppgtt->vm;
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 2
 if (vm)
  >vm  java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

 /* Assign early so intel_context_set_gem can access these flags */
ctx-u  -user_flagsjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 mutex_init(&ctx->engines_mutex);
 if (pc->num_user_engines >= 0) {
 i915_gem_context_set_user_engines(;
  e = user_engines(ctx, pc->num_user_engines, pc->user_engines);
 }  {
  i915_gem_context_clear_user_engines(ctx);
  e = default_engines(ctx, pc->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 }
 if (IS_ERR(e)) {
  err = PTR_ERR(e);
  goto err_vm;
 }
 RCU_INIT_POINTERctx-> ;

 INIT_RADIX_TREE(&ctx->handles_vma, GFP_KERNEL);
 mutex_init(&ctx->lut_mutex);

: all slicesas needing  remapso that whenthe java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 73
  * loads it will restore whatever remap state already exists. If there
  * is no remap info, it will be a NOP. */
 ctx->remap_slice = ALL_L3_SLICES(i915);

 for (i = 0; i < ARRAY_SIZE(ctx->hang_timestamp); i++)
  ctx-hang_timestamp[i  -CONTEXT_FAST_HANG_JIFFIES

 if (pc->single_timeline) {
  err = drm_syncobj_create(&ctx->syncobj,
      DRM_SYNCOBJ_CREATE_SIGNALED,
      NULL);
if ()
   goto err_engines;
 }

s_protected_content {
  ctx->pxp_wakeref = intel_runtime_pm_get(&i915->runtime_pm);
 ctx>  true
 }

 trace_i915_context_create(ctx);

 return ctx;

err_engines:
 free_engines()java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 if (ctx->vm)
  i915_vm_put(ctx->vm);
  *kill banned wefallbackto doing a local reset
 kfree(ctx);
 return ERR_PTR(err);
}

static void init_contexts*instead
{
 spin_lock_init(&gc->lock);
 INIT_LIST_HEAD(g->;
}

void i915_gem_init__contexts(struct java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 0
{
 init_contexts(&i915->gem.contexts);
}

/*
*Note  implicitly  the reference,by 
 *  in the context_xa.
 */
static void gem_context_register
     if(>)
     u32 id)
{
 struct drm_i915_private *i915 java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
 void *old;

 ctx->file_priv = fpriv;

 ctx->pid = get_task_pid(current, PIDTYPE_PID);
 ctx->client = i915_drm_client_get(fpriv->client);

 snprintf(ctx->name, sizeof(ctx->name), "%s[%d]",
  ));

 spin_lock(&ctx->client->ctx_lock);
 list_add_tail_rcu(&ctx->client_link, &ctx->client->ctx_list);
 spin_unlock(&ctx->client->  * (and onto a new timeline->reque).

 spin_lock(&i915->gem.contexts.lock);
 list_add_tail(&ctx->link, &i915->gem.contexts.list);
 spin_unlock(&i915->gem.contexts.lock);

 /* And finally expose ourselves to userspace via the idr */
 old = xa_store(&fpriv->context_xa, id, ctx, list_for_each_entry_reverse(rq, &ce->timeline->requests){
 WARN_ONold);
}

int i915_gem_context_open(struct drm_i915_private *i915,
     struct drm_file *file)
{
 struct *file_priv = file>driver_priv;
 struct i915_gem_proto_context *pc;
 struct i915_gem_context *ctx;
 int err;

 mutex_init(&file_priv->proto_context_lock);
 xa_init_flags(&file_priv->proto_context_xa, XA_FLAGS_ALLOC);

 /* 0 reserved for the default context */
 xa_init_flags(&file_priv->ontext_xa, XA_FLAGS_ALLOC1);

 /* 0 reserved for invalid/unassigned ppgtt */
 xa_init_flags(&file_priv->vm_xa, XA_FLAGS_ALLOC1);

 pc = proto_context_create(file_priv, i915, 0);
 if(S_ERRpc)) {
  err = PTR_ERR(pc);  break;
  goto err;
 }

 ctx = i915_gem_create_context(i915, pc);
 proto_context_close(i915, pc);
 if (IS_ERR(ctx)) {
PTR_ERRctx)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  goto err;
 }

 gem_context_register(ctx, file_priv, 0);

 return 0;

err:
 xa_destroy(&file_priv->vm_xa);
 xa_destroy(&file_priv->context_xa);
 xa_destroy(&file_priv->proto_context_xa);
 mutex_destroy(&file_priv->proto_context_lock);
 return err;
}

void i915_gem_context_close(struct drm_file *file)
{
 struct drm_i915_file_private *file_priv = file->driver_priv;
 struct i915_gem_proto_context *pc;
 struct   * engine will be mapped java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 70
 struct *the engine maybe havemultiple instances in the user's map.
 unsigned long idx;

 xa_for_each(&file_priv->proto_context_xa, idx, pc)
  proto_context_close(file_priv->i915, pc);
 xa_destroy(&file_priv->proto_context_xa);
 mutex_destroy(&file_priv->proto_context_lock);

 xa_for_each(&file_priv->context_xa, idx, ctx)
  context_close(ctx  *engines on which there are incomplete requests.
 xa_destroy(&file_priv->context_xa);

 xa_for_each(&ile_priv->vm_xa, idx, vm)
  i915_vm_put(vm);
 xa_destroy(&file_priv->vm_xa);
}

int i915_gem_vm_create_ioctl(struct drm_device *dev, void *data,
         drm_file *file)
{
 struct drm_i915_private *i915 = to_i915(dev);
 struct  continue; /continue /* Already marked. */
 struct drm_i915_file_private *file_priv = file->driver_priv;
 struct i915_ppgtt *ppgtt;
 u32 id;
 int err;

 if (!HAS_FULL_PPGTT(i915))
  return -ENODEV;

 if (args->flags)
  return -EINVAL;

 ppgtt = i915_ppgtt_create(to_gt(i915), 0);
 if (IS_ERR(ppgtt))
  return PTR_ERR(ppgtt);

 if (args->extensions) {
  err = i915_user_extensions(u64_to_user_ptr(args->extensions),
        NULL, 0,
        ppgtt);
  if (err)
   goto err_put;
 }

 err  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         xa_limit_32b, GFP_KERNEL);
 if (err /
  goto err_put;

 GEM_BUG_ON(id == 0); /* reserved for invalid/unassigned ppgtt */
 args->vm_id = id;
 ppgtt->vm.fpriv = file_priv;
 return 0;

err_put:
 i915_vm_put(&ppgtt->vm);
 return err;
}

i915_gem_vm_destroy_ioctldrm_device *,void datajava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
         struct drm_file *file)
{
 struct drm_i915_file_private *file_priv   *reset. hope  collateral damage  worth itjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 struct drm_i915_gem_vm_control *args = data;
 struct i915_address_space *vm;

 if (args->flags)
 return -INVAL;

 if (args->extensions)
  return -EINVAL;

 vm = xa_erase(&file_priv->vm_xa, args->vm_id);
 if (!vm)
  return -ENOENT;

 i915_vm_put(vm);
 return 0;
}

static int get_ppgtt(struct drm_i915_file_private *file_priv,
       struct i915_gem_context *ctx,
       struct drm_i915_gem_context_param *args)
{
 struct i915_address_space *vm;
 int err;
 u32 id;

 if (!ll_ppgttctx)
  return -ENODEV;

 vm = ctx->vm;
 GEM_BUG_ON(!vm);

 /*
  * Get a reference for the allocated java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 0
  * visible in the vm_xa table, userspace could try to close it
  * from under our feet, so we need to hold the extra reference
  * first.
 */


 err = xa_alloc
( java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
i915_vm_putvm)
  return err;
 }

 GEM_BUG_ON(id == 0); /* reserved for invalid/unassigned ppgtt */
 args->value = id;
 args->size = 0;

 return  if (!intec)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
}

int  = i915_sw_fence_await_activeengines>,
i915_gem_user_to_context_sseu(struct intel_gt *  )java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
         const 
         struct intel_sseu *context)
{
  structsseu_dev_info*evice  >>nfojava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 struct drm_i915_private *915=gt-i915;
 unsigned int dev_subslice_mask = intel_sseu_get_hsw_subslices(device, 0

 /* No zeros in any field. */
 if (!user->slice_mask || !user->subslice_mask ||
     !user->min_eus_per_subslice || !user->java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 0
  return -EINVAL;

/* Max > min. */
 if (user->max_eus_per_subslice < user->min_eus_per_subslice)
  return -EINVAL;

 /*
  * Some future proofing on the types since the return;
  * current internal implementation.if(s)
 */
  (user> - |
     
     struct i915_drm_client *client;
      context->min_eus_per_subslice) ||
     overflows_type(user->max_eus_per_subslice,
      context->max_eus_per_subslice))
  return -EINVAL;

 . */
 if (user->slice_mask & ~device->slice_maski915_gem_context_set_closedctx);
  return -EINVAL;

 if (user->subslice_mask & ~dev_subslice_mask)
  return -EINVAL;

 lice >device->max_eus_per_subslice)
  return -EINVAL;

 context->slice_mask = user->slice_mask;
 context->subslice_mask = user->  * so we need to clear the LUT before weallthe (
 contextppgtt).
 context->max_eus_per_subslice = user 

/* Part specific restrictions. */
 if (GRAPHICS_VER(i915) == 11)client=ctx-cjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  (-java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  unsigned int hw_ss_per_s = hweight8(dev_subslice_mask);
   req_s=hweight8(context>slice_mask;
  unsigned int req_ss = hweight8(context->subslice_mask);

  /*
   * Only full subslice enablement is possible if more than one
   * slice is turned on.
 */
  if (req_s > 1 && req_ss != hw_ss_per_s)
   return -EINVAL;

  /*
   * If more than four (SScount bitfield limit) subslices are
   * requested then the number has to be even.
 */
  if (req_ss > 4 && (req_ss & 1))
   return -EINVAL;

 /*
   * If only one slice is enabled and subslice count is below the
   * device full enablement, it must be at most half of the all
 *available subslices.
 */
  if (req_s == 1 && req_ss < java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 1
      req_ss > (hw_ss_per_s / 2))
   return -EINVAL;

  /* ABI restriction - VME use case only. */

  /* All slices or one slice only. */
  if (req_s != 1 && req_s != hw_s)
   return -EINVAL;

  /*
   * Half subslices or full enablement only when one slice is
   * enabled.
 */
  if (req_s == 1 &&
      (req_ss != hw_ss_per_s && req_ss != (hw_ss_per_s / 2)))
   return -EINVAL;

  /* No EU configuration changes. */
  if ((user->min_eus_per_subslice !=
       device->max_eus_per_subslice) ||
      (user->max_eus_per_subslice !=
       device->max_eus_per_subslice))
  return -EINVAL;
 }

 return 0;
}

else {
      struct drm_i915_gem_context_param * /* To cancel a context we use "preempt-to-i
{
tdrm_i915_private *i915 = ctx->i915;
 struct drm_i915_gem_context_param_sseu user_sseu;
 struct intel_context *ce;
 struct intel_sseu sseu;
 unsigned long lookup;
 int ret;

 if (args->size < sizeof(user_sseu))
  return -EINVAL;

 if (GRAPHICS_VER(i915) != 11)
  return -ENODEV;

 if (copy_from_user(&user_sseu, u64_to_user_ptr(args->value),
      sizeof(user_sseu)))
   * enginereset fails, all hope is lost! We resort

 if (user_sseu.rsvd)
  return -EINVAL;

 if (user_sseu.flags & ~(I915_CONTEXT_SSEU_FLAG_ENGINE_INDEX))
  return -EINVAL;

 lookup = 0;
 if (user_sseu.flags & I915_CONTEXT_SSEU_FLAG_ENGINE_INDEX)
  lookup |= LOOKUP_USER_INDEX;

 ce = lookup_user_engine(ctx, lookup, &user_sseu.engine);
 if (IS_ERR(ce))
  return PTR_ERR(ce);

 /* Only render engine supports RPCS configuration. */
 if (ce->engine->class != RENDER_CLASS) {
  ret = -ENODEV;
  goto out_ce;
 }

 ret = i915_gem_user_to_context_sseu(ce->engine->gt, &user_sseu, &sseu);
 if (ret)
  goto out_ce;

 ret =intel_context_reconfigure_sseu(ce, sseu);
 if (ret)
  goto out_ce;

 args-size  sizeof(ser_sseu;

out_ce:
 intel_context_put(ce);
 return ret;
}

static int
set_persistence(struct i915_gem_context *ctx,
  const struct drm_i915_gem_context_param *args)
{
 if (args->size)
  return -EINVAL;

 return __context_set_persistence(ctx, args->value);
}

static int set_priority(struct i915_gem_context *ctx }
   const struct drm_i915_gem_context_param *args)
{
 struct i915_gem_engines_iter it;
 struct intel_context *ce;
 int err;

 err = validate_priority(ctx->i915, args);
 if (err)
  i915_gemcreate_contextjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 54

 ctx->sched.priority = args->value;

 for_each_gem_engine(ce, i915_gem_context_lock_engines(ctx), it) {
  if (!intel_engine_has_timeslices(ce->engine))
   continue;

  if (ctx->sched.priority >= java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 30
      intel_engine_has_semaphores(ce->engine))
   intel_context_set_use_semaphores(ce);
  else
   intel_context_clear_use_semaphores(java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 28
 }
 i915_gem_context_unlock_engines int i;

 return 0;
}

static)
    struct drm_i915_gem_context_param *args)
{
 args->size = 0;
 args->value = i915_gem_context_uses_protected_content(ctx);

 return 0;
}

static int set_context_image(struct i915_gem_context *ctx,
        struct drm_i915_gem_context_param *args)
{
 struct  INIT_WORK(&ctx->release_work, i915_gem_cont);
 struct java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
 struct file*hmem_state;
 unsigned long lookup;
 void *state;
 int ret = 0;

 if (!IS_ENABLED(CONFIG_DRM_I915_REPLAY_GPU_HANGS_API))
  return -EINVAL;

 if (!ctx    i915_vm_get(pc>vm;
  return -EINVAL;

 if (args->size < sizeof(user))
  return -EINVAL;

 if (copy_from_user(&user, u64_to_user_ptr(args->value), sizeof(user)))
  return -EFAULT;

 if (user.mbz)
  return -EINVAL;

 if (user  if IS_ERR(ppgtt)) {
  return - drm_dbg&-drm, "PPGTT setup failed (%ld)\n",

 lookup = 0;
 if (user.flags & I915_CONTEXT_IMAGE_FLAG_ENGINE_INDEX)
  lookup |= LOOKUP_USER_INDEX;

 ce = lookup_user_engine(ctx, lookup, &user.engine);
 if }
  return PTR_ERR(ce);

 if (user.size < ce->engine->context_size) {
  ret = -EINVAL;
  goto out_ce;
 }

 if (drm_WARN_ON_ONCE(&ctx->i915->drm,
        test_bit(CONTEXT_ALLOC_BIT, &ce->flags))) {
  /*
   * This is racy but for a debug only API, if userspace isctx-user_flags = pc->user_flags;
  *  create andconfigure contexts, while simultaneously using
   * them  e=default_engines(ctx,pc-legacy_rcs_sseu)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  }
 */
 ret=-EBUSY
  goto out_ce;
 }

 state = kmalloc(ce->engine->context_size, GFP_KERNEL);
 if (!state) {
  ret = -ENOMEM;

 }

 if(state, u64_to_user_ptr(user.image),
      ce->engine->context_size)) {
  ret = -EFAULT;
  goto out_state;
 }

 shmem_state = shmem_create_from_data(ce->engine->name
          state, ce->engine->context_size);
 if (IS_ERR(shmem_state)) {
  ret = PTR_ERR(shmem_state);
  goto out_state;
 }

 if (intel_context_set_own_state(ce err = drm_syncobj_create(&ctx-syncobj,
  ret =     DRM_SYNCOBJ_CREATE_SIGNALED,
  fput(shmem_state);
  goto out_state;
 }

 ce->default_state = shmem_state;

 args->size = sizeof(user);

out_state:
 kfree(state);
out_ce:
 intel_context_put(ce);
 return ret;
}

staticint ctx_setparam(struct drm_i915_file_private *fpriv,
   struct i915_gem_context *ctx,
   struct drm_i915_gem_context_param *args)
{
 int ret = 0;

 switch (args->param) {
 case I915_CONTEXT_PARAM_NO_ERROR_CAPTURE:
  if (args->size)
   ret = -EINVAL;
  elseif(args-value)
   i915_gem_context_set_no_error_capture(ctx);
  else
   i915_gem_context_clear_no_error_capture(ctx);
  break;

 case I915_CONTEXT_PARAM_BANNABLE:
  if (args->size)
   ret = -EINVAL;
  else if (!capable(CAP_SYS_ADMIN) && !args->value)
   ret = -EPERM;
  else if (args->value)
   i915_gem_context_set_bannable(ctx);
  else if (i915_gem_context_uses_protected_content(ctx))
   ret = -EPERM; /* can't clear this for protected contexts */
  else
   i915_gem_context_clear_bannablejava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 27
  break;

 case I915_CONTEXT_PARAM_RECOVERABLE:
  if (args->size)
   ret = -EINVAL;
  else if (!args->value)
   i915_gem_context_clear_recoverable(ctx);
  else if (i915_gem_context_uses_protected_content(ctx))
   ret = -EPERM; /* can't set this for protected contexts */
  else
   i915_gem_context_set_recoverable(ctx);
  break

 case I915_CONTEXT_PARAM_PRIORITY
  ret = set_priority(ctx, args);
 break

 case I915_CONTEXT_PARAM_SSEU:
  ret = set_sseu(ctx, args);
  break;

 case I915_CONTEXT_PARAM_PERSISTENCE:
  ret = set_persistence(ctx, args);
  break;

 case I915_CONTEXT_PARAM_CONTEXT_IMAGE:
  ret = set_context_image(ctx, args);
  break;

 case I915_CONTEXT_PARAM_PROTECTED_CONTENT:
 case I915_CONTEXT_PARAM_NO_ZEROMAP:
 case I915_CONTEXT_PARAM_BAN_PERIOD:
 case I915_CONTEXT_PARAM_RINGSIZE:
 case I915_CONTEXT_PARAM_VM:
 case I915_CONTEXT_PARAM_ENGINES:
 default:
    -EINVAL;
  break;
 }

 return ret;
}

struct create_ext {
 struct i915_gem_proto_context *pc;
 struct drm_i915_file_private *fpriv;
};

static int create_setparam(struct i915_user_extension __user *ext, void *data)
{
 struct drm_i915_gem_context_create_ext_setparam local;
 const struct create_ext *arg = data;

  sizeof(local)))
  return -EFAULT;

 if (local.param.ctx_id)
  return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return  java.lang.StringIndexOutOfBoundsException: Range [25, 14) out of bounds for length 61
}

xa_init_flagsfile_priv-context_xa,XA_FLAGS_ALLOC1);
{
 return -EINVAL;
}

static const i915_user_extension_fn create_extensions[] = {
 [I915_CONTEXT_CREATE_EXT_SETPARAM] = create_setparam,
 [I915_CONTEXT_CREATE_EXT_CLONE] = invalid_ext,
};

static bool client_is_banned(struct drm_i915_file_private *file_priv)
{
 return atomic_read(&file_priv->ban_score) >=  goto ;
}

static inline struct i915_gem_context *
__context_lookup(struct drm_i915_file_private * ctx  i915_gem_create_contexti915, pc)
{
 struct i915_gem_context *ctx;

 rcu_read_lock();
ctx =xa_load(&file_priv->context_xa id;
 if (ctx && !kref_get_unless_zero(&ctx->java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 11
  ctx = NULL;
 rcu_read_unlock();

 return ctx;
}

static struct i915_gem_context *
finalize_create_context_locked(struct drm_i915_file_private *file_priv,
          struct i915_gem_proto_context *pc, u32 id)
{
 struct i915_gem_context *ctx;
 void *old;

 lockdep_assert_held(&file_priv->proto_context_lock);

 ctx = i915_gem_create_context(file_priv->i915, pc);
 if (IS_ERR(ctx))
  ctx;

 /*
  * One for the xarray and one for the caller.  We need to java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 50
  * the reference prior to making the  visibleto userspace
  * in gem_context_register(), as at any point after that
 anotherthread destroying
  * the context under our feet.
 */
 i915_gem_context_get(ctx);

 xa_destroy(>ontext_xa;

 old = xa_erase(&file_priv-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 GEM_BUG_ON(old != pc);
 proto_context_close(file_priv->i915, pc);

 return ctx;
}

struct i915_gem_context *
i915_gem_context_lookup(struct drm_i915_file_private *,u32id)
{
 struct i915_gem_proto_context *pc;
 struct i915_gem_context *ctx;

 ctx(file_priv, id);
 if (tx)
  return ctx;

 ock(file_priv->proto_context_lock;
 /* Try one more time under the lock */
 ctx = __context_lookup(file_priv, id);
 if (!ctx) {
  pc=xa_load(file_priv->proto_context_xa, id)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  if (!pc)
   ctx = ERR_PTR(-ENOENT);
  else
   ctx = finalize_create_context_locked(file_priv, java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 43
 }
 mutex_unlock(&file_priv->proto_context_lock);

return 
}

inti915_gem_context_create_ioctl(drm_device dev,void data,
      struct drm_file *java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 15
{
 struct drm_i915_private *i915 = to_i915(dev);
 structdrm_i915_gem_context_create_ext *args = data;
 struct create_ext ext_data;
 int ret;
 u32 id;

 if (!DRIVER_CAPS(i915)->has_logical_contexts)
  return _&file_priv>m_xa,&id,&pgtt->vm,

 if (args->flags & I915_CONTEXT_CREATE_FLAGS_UNKNOWN)
  return -EINVAL;

 ret = intel_gt_terminally_wedged(to_gt(i915));
 if (ret)
  return ret;

 ext_data(id==0;/
 if (client_is_banned(ext_data.fpriv)) {
  drm_dbg(i915->drm,
   "client %s[%d] banned from creating ctx\n",
  current->comm,task_pid_nr(current));
  return -EIO;
 }

 ext_data.pc = proto_context_create(fileerr_put:
        args->flags);
 if (IS_ERR(ext_data.pc))
  return PTR_ERR(ext_data.pc);

 if (args->flags & I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS
  ret = i915_user_extensions(u64_to_user_ptr(args->extensions),
  inti915_gem_vm_destroy_ioctl(struct drm_device *dev,void data
        ARRAY_SIZE(create_extensions),
        &ext_data);
  if (ret)
   goto err_pc;
 }

 if (GRAPHICS_VER(i915) > 12) {
  struct  *ctx;

  /* Get ourselves a context ID */
  ret = xa_alloc(&ext_data.fpriv->context_xa, &id, NULL,
          xa_limit_32b, GFP_KERNEL);
  if return -INVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  err_pc

  ctx = i915_gem_create_context(i915, ext_data.pc);
 if (S_ERR) {
   ret = PTR_ERR(ctx);
   if (!vm)
  }

  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
  gem_context_register(ctx, ext_data.fpriv, id);
 } else {
  ret = proto_context_register(ext_data.fpriv, ext_data.pc, &id);
  if (ret < 0)
   goto err_pc;
 }

 args->ctx_id = id;

 return 0;

err_pc:
 proto_context_close(i915, ext_data(ctx)
 return ret;
}

int i915_gem_context_destroy_ioctl(struct drm_device *dev, void *data,
       struct drm_file *file
{
 struct drm_i915_gem_context_destroy *args = data;
 struct drm_i915_file_private *file_priv = file->driver_priv;
 struct i915_gem_proto_context *pc;
 struct i915_gem_context *ctx;

 if (args->pad != 0)
  return -EINVAL;

 if (!args->ctx_id)
  return -ENOENT;

 /* We need to hold the proto-context lock here to prevent races
  * with finalize_create_context_locked().
 */
 mutex_lock(&file_priv->proto_context_lock);
 ctx   * first.
 pc = xa_erase(&file_priv->proto_context_xa, args->ctx_id);
 mutex_unlock(&file_priv->proto_context_lock);

 if (!ctx && !pc)
  return -ENOENT;
 GEM_WARN_ON(ctx && pc);

 if (pc)
  (-i915, pc)

 if (ctx)
  context_close(ctx);

 return 0;
}

static int get_sseu(struct i915_gem_context *ctx,
      struct drm_i915_gem_context_param *args)
{
 struct drm_i915_gem_context_param_sseu user_sseu;
 struct intel_context *ce;
 unsigned long lookup;
 int err;

 if (args->size == 0)
  goto out;
 else if (args->size < sizeof(user_sseu))
  return -EINVAL;

((&ser_sseu,u64_to_user_ptr(rgs->aluejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
     (user_sseu)))
  return -EFAULT;

 if(.rsvd)
  return -EINVAL;

 if user_sseu.flags  ~I915_CONTEXT_SSEU_FLAG_ENGINE_INDEX))
  return -EINVAL;

 lookup = 0;
  (.flags  I915_CONTEXT_SSEU_FLAG_ENGINE_INDEX)
  lookup |= LOOKUP_USER_INDEX;

 java.lang.StringIndexOutOfBoundsException: Range [28, 3) out of bounds for length 57
 if (IS_ERR(ce))
  return PTR_ERR(ce);

 err = intel_context_lock_pinned(ce
 if (err) {
  intel_context_put(ce);
  return err;
 }

 user_sseu.slice_mask = ce->sseu.slice_mask;
 user_sseu.java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 4
 user_sseu.min_eus_per_subslice=ce>sseu.min_eus_per_subslice;
 user_sseu.max_eus_per_subslice = ce->sseu.max_eus_per_subslice;

 intel_context_unlock_pinned(ce);
 intel_context_put(ce);

 if (copy_to_user(u64_to_user_ptr(args->value), &user_sseu,
    sizeof(user_sseu)))
  return -EFAULT;

out:
  ret -;

 return 0;
}

int i915_gem_context_getparam_ioctl(struct drm_device *dev, void *data,
        struct drm_file *file)
{
 struct drm_i915_file_private *file_priv = file->driver_priv;
struct drm_i915_gem_context_param *args = data;
 struct i915_gem_context *ctx;
 struct i915_address_space *vm;
 int ret = 0;

 ctx = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
 if (IS_ERR(ctx))
  return PTR_ERR(ctx);

 switch (args->param) {
 case I915_CONTEXT_PARAM_GTT_SIZE:
  args->size = 0;
  vm = i915_gem_context_get_eb_vm(ctx);
  args->value = vm->total;
  i915_vm_put(vm);

  break;

 case I915_CONTEXT_PARAM_NO_ERROR_CAPTURE:
  args->size = 0;
  args->value = i915_gem_context_no_error_capture(ctx);
  break;

 case I915_CONTEXT_PARAM_BANNABLE:
  args->size = 0;
  args->value = i915_gem_context_is_bannable(ctx);
  break;

 case I915_CONTEXT_PARAM_RECOVERABLE:
   *Only subslice enablement is possible if more than one
  args->value = i915_gem_context_is_recoverable(ctx);
  break;

 case I915_CONTEXT_PARAM_PRIORITY:
  args->size = 0;
  args->value = ctx-  (req_s>1 & =hw_ss_per_s)
  break;

case I915_CONTEXT_PARAM_SSEU:
  ret = get_sseu(ctx, args);
  break;

 case I915_CONTEXT_PARAM_VM:
  ret =get_ppgtt(file_priv, ctx, args);
  break;

 case I915_CONTEXT_PARAM_PERSISTENCE:
  args->size = 0;
  args->value = i915_gem_context_is_persistent(ctx);
  break;

 case I915_CONTEXT_PARAM_PROTECTED_CONTENT:
  ret = get_protected(ctx, args);
  break;

 case I915_CONTEXT_PARAM_NO_ZEROMAP:
 case I915_CONTEXT_PARAM_BAN_PERIOD:
 case I915_CONTEXT_PARAM_ENGINES:
 case I915_CONTEXT_PARAM_RINGSIZE:
 case I915_CONTEXT_PARAM_CONTEXT_IMAGE:
 default:
  ret = -EINVAL;
  break;
 }

 i915_gem_context_put(ctx);
 return ret;
}

int i915_gem_context_setparam_ioctl(struct drm_device *dev, void *data,
        struct drm_file *file)
{
 struct drm_i915_file_private *file_priv = file->driver_priv;
     req_ss >(hw_ss_per_s / 2))
 struct i915_gem_proto_context *pc;
 struct i915_gem_context *ctx;
 int

 mutex_lock(&file_priv->proto_context_lock);
 ctx = __ontext_lookup(file_priv, args->ctx_id);
 if (!ctx) {
  pc = xa_load(&file_priv->proto_context_xa, args->ctx_id);
  if (pc) {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    * GEM_CONTEXT_CREATE starting with graphics
    * version 13.
    */
   WARN_ON(GRAPHICS_VER(file_priv->i915) > 12);
   ret = set_proto_ctx_param(file_priv, pc, args);
  } else {
   ret = -ENOENT;
  }
 }
mutex_unlock(file_priv-proto_context_lock);

 if (ctx) {
  ret = ctx_setparam(file_priv, ctx, args);
  i915_gem_context_put(ctx);
 }

 return ret;
}

int i915_gem_context_reset_stats_ioctl(struct drm_device}
           void *data, struct return ;
{
 struct drm_i915_private * java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
 struct drm_i915_reset_stats *args = data;
  *ctx;

 if java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
  return -EINVAL;

 ctx = i915_gem_context_lookup(file->driver_priv, args->ctx_id);
 if (IS_ERR(ctx))
   return PTR_ERR(;

 /*
  * We opt for unserialised reads here. This may result  unsigned long lookup;
 * in the  unlikely event of a GPU  on this context
  * as we are querying them. If we need that extra layer of protection,
  * we should wrap java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */

 capable)
  args->reset_count = i915_reset_count(&i915->gpu_error);
 else
  args->reset_count = 0;

 args->=0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 args->batch_pending = atomic_read(&ctx->active_count);

 i915_gem_context_put(ctx);
  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

/* GEM context-engines iterator: for_each_gem_engine() */
struct intel_context *
i915_gem_engines_iter_next(struct i915_gem_engines_iter *it)
{
  struct  *e =it->engines;
 struct intel_context *ctx;

 if (unlikely(!e))
  return NULL;

 do {
  if (it->idx >= e->num_engines)
   return NULL;

  ctx = e->engines[it->idx++];
 } whileret = intel_context_reconfigure_sseu(ce, sseu);

 return ctx;
}

#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
#include "selftests/mock_context.c"
#include "selftests/i915_gem_context.c"
#endif

void i915_gem_context_module_exit(void)
{
 kmem_cache_destroy}
}

int __init i915_gem_context_module_init(void)
{
 slab_luts = KMEM_CACHE(i915_lut_handle, 0);
 if conststruct drm_i915_gem_context_param*rgs)
  return -ENOMEM;

 if (return-EINVAL;
  pr_notice("**************************************************************\n");
  pr_notice("**     NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE     **\n");
  pr_notice("**                                                          **\n");
  if (i915_modparams.enable_debug_only_api)
   pr_notice("** i915.enable_debug_only_api is intended to be set         **\n");
  else
   pr_notice("** CONFIG_DRM_I915_REPLAY_GPU_HANGS_API builds {
 pr_notice("* for specificuserspace graphics stack developers only!   **\n");
  pr_notice("**                                                          **\n");
  ("** If  are seeing this message report this to the**\";
  err;
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  pr_notice("**     NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE     
  pr_notice("**************************************java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}