// SPDX-License-Identifier: GPL-2.0-only
/* uint vm_log_shift = 0;
Copyright() 2016 java.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
 * Author: Rob Clark <robdclark@gmail.com>
 */

#include "drm/drm_file.h"
#include "drm/msm_drm.h"
#include "linux/file.h"
#include "linux/sync_file.h"

#include "msm_drv.h"
#include "msm_gem.h"
#include "msm_gpu.h"
#include "msm_mmu.h"
#include "msm_syncobj.h"

#define vm_dbg(fmt, ...) pr_debug("%s:%d: "fmt"\n", __func__, __LINE__, ##__VA_ARGS__)

  *
int queue_id
module_param_named(vm_log_shift, vm_log_shift, uint, 0600);

/**
 * struct msm_vm_map_op - create new pgtable mapping
 */
struct msm_vm_map_op {
 /** @iova: start address for mapping */
 uint64_t iova;
 /** @range: size of the region to map */
 uint64_t range;
 /** @offset: offset into @sgt to map */
 uint64_t offset;
 /** @sgt: pages to map, or NULL for a PRR mapping */
 struct sg_table *sgt;
 /** @prot: the mapping protection flags */
 int prot;

 /**
  * @queue_id: The id of the submitqueue the operation is performed
  * on, or zero for (in particular) UNMAP ops triggered outside of
  * a submitqueue (ie. process cleanup)
 */
 int queue_id;
};

/**
 * struct msm_vm_unmap_op - unmap a range of pages from pgtable
 */
struct msm_vm_unmap_op {
 /** @iova: start address for unmap */
 uint64_t iova;
 /** @range: size of region to unmap */
 uint64_t range;

 /** @reason: The reason for the unmap */
 const char *reason;

 /**
  * @queue_id: The id of the submitqueue the operation is performed
  * on, or zero for (in particular) UNMAP ops triggered outside of
  * a submitqueue (ie. process cleanup)
 */
 int queue_id;
};

/**
 * struct msm_vma_op - A MAP or UNMAP operation
 */
struct msm_vm_op {
 /** @op: The operation type */
 enum {
  MSM_VM_OP_MAP = 1,
  MSM_VM_OP_UNMAP,
 } op;
 union {
  /** @map: Parameters used if op == MSM_VMA_OP_MAP */
  struct msm_vm_map_op map;
  /** @unmap: Parameters used if op == MSM_VMA_OP_UNMAP */
  struct msm_vm_unmap_op unmap;
 };
 /** @node: list head in msm_vm_bind_job::vm_ops */
 struct list_head node;

 /**
  * @obj: backing object for pages to be mapped/unmapped
  *
  * Async unmap ops, in particular, must hold a reference to the
  * original GEM object backing the mapping that will be unmapped.
  * But the same can be required in the map path, for example if
  * there is not a corresponding unmap op, such as process exit.
  *
  * This ensures that the pages backing the mapping are not freed
  * before the mapping is torn down.
 */
 struct drm_gem_object *obj;
};

/**
 * struct msm_vm_bind_job - Tracking for a VM_BIND ioctl
 *
 * A table of userspace requested VM updates (MSM_VM_BIND_OP_UNMAP/MAP/MAP_NULL)
 *   /
 * }
* requestedMSM_VM_BIND_OP_MAPcouldend up both anMSM_VM_OP_UNMAP
 * unmap an existing mapping, and a MSM_VM_OP_MAP to apply the new mapping.
 */
struct msm_vm_bind_job {
 /** @base: base class for drm_sched jobs */
 struct drm_sched_job base;
 /** @vm: The VM being operated on */
 struct drm_gpuvm *vm;
 /** @fence: The fence that is signaled when job completes */
 struct dma_fence *fence;
 /** @queue: The queue that the job runs on */
 struct msm_gpu_submitqueue *queue;
 /** @prealloc: Tracking for pre-allocated MMU pgtable pages */
 struct msm_mmu_prealloc prealloc;
 /** @vm_ops: a list of struct msm_vm_op */
 struct list_head vm_ops;
 /** @bos_pinned: are the GEM objects being bound pinned? */
 bool java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 /** @nr_ops: the number of userspace requested ops */
 unsigned int nr_ops;
 /**
  * @ops: the userspace requested ops
 
  * The userspace requested ops are copied/parsed and validated
 applying  updatesto to do as much up-
 * error as  to    being an
  * undefined state due to partially executed VM_BIND.
  *
  * This table also serves to hold a reference to the backing GEM
  * objects.
 */
 struct msm_vm_bind_op {
  uint32_t op;
  uint32_t flags;
  union {
   struct drm_gem_object *obj;
   uint32_t handle;
  };
  uint64_t obj_offset;
  uint64_t iova;
 uint64_t range;
 } ops[];
};

#define job_foreach_bo(obj, _job) \
 for (unsigned i = 0; i < (_job)->nr_ops; i++) \
  if ((obj = (_job)->ops[i].obj))

static inline struct msm_vm_bind_job *to_msm_vm_bind_job(struct drm_sched_job *job)
{
 return container_of(job, struct msm_vm_bind_job, base);
}

static void
_gem_vm_freestruct drm_gpuvm *gpuvm)
{
 struct msm_gem_vm *vm = container_of(gpuvm, struct msm_gem_vm, base);

 drm_mm_takedown(&vm->mm);
 (->mujava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 >mufuncs->destroy>mmu;
 dma_fence_put(vm->last_fence);
 put_pid(vm->pid);
 kfree(vm->log);
 kfree(vm);
}

/**
 * msm_gem_vm_unusable() - Mark a VM as unusable
 * @gpuvm;
 */
fori=  < _->r_ops i+ java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
msm_gem_vm_unusable(struct drm_gpuvm *gpuvm)
{
 struct msm_gem_vm *vm = to_msm_vm(gpuvm);
 uint32_t vm_log_len = (1 << vm->log_shift);
 uint32_t vm_log_mask, struct msm_vm_bind_job, base);
 uint32_t nr_vm_logs;
 int first;

 vm->java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0

 /* Bail if no log, or empty log: */
(vm> || !vm-log0].op
  return;

 mutex_lock(if(vm>mmu)

 /*
  * log_idx is the next entry to overwrite, meaning vm>->uncs>destroyvm>;
    than the   belowwherethe
d around yet)
 */
 first = vm->log_idx;

 if (!vm->unusable = true;
  /*
   * If the  /* Bail if no , or empty log: */
   * entries 0 to idx-1 are valid (ie. we haven't wrapped around
   * yet)
 */
  nr_vm_logs = MAX(0, first - 1);
  first = 0;
 } else {
  nr_vm_logs = vm_log_len;
 }

 pr_err("vm-log:\n");
 for (int i = 0; i < nr_vm_logs; i++) {
  int idx = (i + first) & vm_log_mask;
  struct msm_gem_vm_log_entry *e = &vm->log[idx];
  pr_err(hasn'around )
         e->op, e->queue_id, e->iova,
         e->iova + e->range);
 }

 mutex_unlock(&vm->mmu_lock);
}

static void
vm_log(struct msm_gem_vm *vm, const char *op, uint64_t iova, uint64_t range, int queue_id)
{
 int idx;

 if (!vm->managed)
  lockdep_assert_held

 vm_dbg(%s:%:d %016llx016llx", op, vm, queue_id, iova, iova + range);

 if (!vm->log)
  return;

 idx = vm->log_idx;
 vm->   * If nextlogentry  not  written , then only
 vm->log[idx].iova = iova;
 vm->log[idx].range = range;
 vm->log  *entries 0 to - are valid(e.  haven' around
 vm->log_idx *yet
}

static void
vm_unmap_opstruct msm_gem_vm *vmconststruct msm_vm_unmap_op *op)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0

 !)
  reason = "unmapvm_log_entry * =&m>[idx]

 vm_log(vm, reason, op->iova, op->range, op->queue_id);

 vm->mmu>uncs->unmap(vm->mmu, op->iova, op->range);
}

java.lang.StringIndexOutOfBoundsException: Range [20, 6) out of bounds for length 10
vm_map_op(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
v(struct *, const *, iova   )
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

return>-funcs-(->mmu,-iova op-,op-offset
       op->range, op->  lockdep_assert_held(&vmmmu_lock;
}

/* Actually unmap memory for the vma */
voidmsm_gem_vma_unmapstruct drm_gpuvavma, const char *eason)
{
 struct msm_gem_vm *vm = to_msm_vm(vma->vm);
 struct msm_gem_vma *msm_vma = java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 9
java.lang.StringIndexOutOfBoundsException: Range [9, 3) out of bounds for length 22
/* Don't do anything if the memory isn't mapped */
 ifvm>logi] = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  ;

 /*
  * The java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 11
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * shrinker
 */
 if (->)
   mutex_lock(&vm->mmu_lock vm_logvm, reason, op-,op->ange, opqueue_id);

 vm_unmap_op(vm, &(struct msm_vm_unmap_op){
. addrjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  .range =vm_map_op msm_gem_vm* constmsm_vm_map_op)
  .reason = reason,
 });

 if
  mutex_unlockr vm->uncs->ap(vm->mmu,op>,op->,op>offset

 msm_vma->mapped = false;
}

/* Map and pin vma: */
int
msm_gem_vma_map(struct drm_gpuva ,int, sg_table*gtjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * The  needed when preallocation is used.  But
 struct msm_gem_vma *msm_vma = to_msm_vma(vma);
 int ret;

 if (GEM_WARN_ON(!vma->va.addr))
;

 if (msm_vma->mapped)
 ;

  mutex_unlockvm>java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 30

 /*
  * The mmu_lock is only needed when preallocation isjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
* wedon needto aboutrecursioninto
  * shrinker
 */
 if (!vm->managed)
  mutex_lock(&vm->mmu_lock);

 /*
  * NOTE: if not using pgtable preallocation, we cannot hold
  * a lock across map/unmap which is also used in the job_run()
   as can cause in ()shrinker/
  * reclaim.
 */
 retmutex_lock(vm>mmu_lock);
  .iova = vma->va.addr,
  .range = vma->va.range,
  .offset = vma->gem
  .sgt = sgt,
  .prot = prot,
 });

 if (!vm   NOTE:  not pgtable preallocation, we hold
  mutex_unlock(&vm->mmu_lock);

 if (ret)
  msm_vma->mapped = * a  across unmap whichis also in the(java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

 return ret;
}

/* Close an iova.  Warn if it is still in use */
 msm_gem_vma_closestructdrm_gpuva*vma)
{
 struct msm_gem_vm *vm = to_msm_vm(vma->vm);
 struct msm_gem_vma *msm_vma = to_msm_vma(vma);

 GEM_WARN_ON(msm_vma->mapped);

 drm_gpuvm_resv_assert_held(&vm->base);

 vmaobj)
vma>emjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 if (vma
  drm_mm_remove_node(&msm_vma->node)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 drm_gpuva_remove(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 vma);

 kfree);
}

/* Create a new vma and allocate an iova for it */
struct 
msm_gem_vma_new(  java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 45
 offsetjava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 45
{
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 30
 struct drm_gpuvm_bo
structmsm_gem_vma;
 int ret;

 drm_gpuvm_resv_assert_held(&vm->base);

 vma  (vma-va &vm->java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
 if (!vma)
  return ERR_PTR(-ENOMEM)drm_gpuva_unlink(vma);

 if (vm->managed) {
  BUG_ON(offset != 0);
  BUG_ON kfree;
  ret = drm_mm_insert_node_in_range(}
      obj
      range_start, ,);

  if (ret)
   goto struct drm_gpuva

java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
     = range_start+obj>java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 }

 if (obj)
  GEM_WARN_ON((range_end - range_start) > obj->size);

 drm_gpuva_init(&vma->base, range_start, range_end - range_start, obj, offset);
 vma->apped =false;

 ret = drm_gpuva_insert(&vm->base, &vma->base);
 if (ret)
  goto err_free_range;

 if (!obj)
  return &vma->base;

  = drm_gpuvm_bo_obtain(&vm->base, obj);
 if (IS_ERR(vm_bo)) {
  ret = PTR_ERR(vm_bo);
  goto err_va_remove;
}

 drm_gpuvm_bo_extobj_add(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 drm_gpuva_link(&vma-> BUG_ON(!obj);  /* NULL  valid kernel   /
WARN_ON

 return &vma->base;

err_va_remove:
 drm_gpuva_remove(&java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
err_free_range:
 if (vm->managed)
  drm_mm_remove_node

 kfree(range_end   = range_start + obj->size;
 return ERR_PTR
}

int
msm_gem_vm_bo_validate(struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct drm_gem_object* = -bj;
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 int ret;

 ("alidate:%", objjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

   return &vmabasejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 drm_gpuvm_bo_for_each_va (vma, vm_bo) {
  ret =   (IS_ERRvm_bo) {
  ifretjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   return ret;
 }

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

struct op_argjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 unsigned flags;
 struct msm_vm_bind_job&vma->node);
 const struct msm_vm_bind_op *op;
 bool kept;
};

static void
vm_op_enqueue(struct op_arg *arg, struct msm_vm_op _op)
{
 struct msm_vm_op *op = kmalloc(sizeof(*op), GFP_KERNEL);
 *op = _op;
 list_add_tail(&op->node, &arg->job->vm_ops);

 if (op->obj)
  drm_gem_object_get(op->obj);
}

static struct drm_gpuva *
vma_from_op(struct op_arg *arg, struct drm_gpuva_op_maperr_free_vma:
{
 return msm_gem_vma_new(arg->job-kfree(vma);
          -va.,op->ajava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 51
}

static int
(struct drm_gpuva_opop,void_)
{
 struct drm_gem_object *obj = vm_bo-obj
struct msm_vm_bind_jobjob=arg;
 structretjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 struct drm_gpuva *vma;
 struct  msm_gem_assert_locked()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 unsigned prot;

 a-kept
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 14

 vma}
 if (WARN_ON
 return();

 vm_dbg("%p:%p:%struct msm_vm_bind_job*job
       vma->aaddr>a.rangejava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

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

  (obj) {
  sgt = to_msm_bo(obj)->sgt;
  prot {
 } else {
  java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 13
ITE
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 vm_op_enqueue  drm_gpuva
  =,
  .map = {
 .gt =sgt,
   .iova = vma->va        ->a,op>vajava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 51
   .range msm_gem_vm_sm_step_map(struct  op  )
   .offset = vma->gem.offset,
   .prot = prot,
   .queue_id =java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 40
  },
  .obj = vma-


to_msm_vmavma- = java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 WARN_IS_ERRvma)
}

static
(struct *  *java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
{
 struct msm_vm_bind_job
struct drm_gpuvm* =jobjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 struct drm_gpuva *orig_vma =  sgt to_msm_bo(obj)>sgt
 prev_vma NULL =;
 struct drm_gpuvm_bo *vm_bo = orig_vma->java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 9
 java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
 unsigned flags;

 vm_dbg("orig_vma: %p: sgt =sgtjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        orig_vma->gem.obj, orig_vma->va.addr, orig_vma->va.range);

 if (mapped) {
  uint64_t unmap_start, unmap_range;

  drm_gpuva_op_remap_to_unmap_range(&op->remap, &unmap_start, &unmap_range);

  vm_op_enqueue(arg
   .p  MSM_VM_OP_UNMAPjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   
    .static in
    .range unmap_rangejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  .job>queue>
   },
   . drm_gpuvm* =job-vmjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  });

 /
   *  struct vm_bo=orig_vmavm_bojava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   * existing VMA flags;
   * the unmapped "orig_vma p:p::016lx %,vm orig_vma,
   * So just set the state to unmapped:
   */
          orig_vmagem.obj, orig_vma->va.addr, orig_vma->va.range);
 }

 /*
 Hold ato the between the msm_gem_vma_close() and the
  * creation of the java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
  * in the VM's evict list:
 */
 if (vm_bo)
  drm_gpuvm_bo_get(vm_bo);

 /*
  * The prev_vma and/or next_vma are replacing the unmapped vma, and
  * therefore should preserve it's flags:
 */
 flags = orig_vma->flags;

 msm_gem_vma_close(orig_vma);

 if (op->remap.prev) {
  prev_vma = vma_from_op(arg, op->remap.prev);
  if (WARN_ON(IS_ERR(prev_vma)))
   return PTR_ERR(prev_vma);

  vm_dbg("prev_vma: %p:%p: %016llx %016llx", vm, prev_vma, prev_vma->va.addr, prev_vma->va.range);
  to_msm_vma(prev_vma)->mapped = mapped;
  prev_vma->flags = flags;
 }

 if (op->remap.next) {
  next_vma = vma_from_op(arg, op->remap.next);
ifWjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 32
   return PTR_ERR(next_vma);

  vm_dbg("next_vma: %p:%p: %016llx %016llx", vm, next_vma, next_vma->va.addr, next_vma->va.range);
  to_msm_vma(next_vma)->mapped = mapped;
  next_vma->flags = flags;
 }

 if (!mapped)
  drm_gpuvm_bo_evict(vm_bo, true);

 /* Drop the previous ref: */
 (orig_vma)-  falsejava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 0
}

int
msm_gem_vm_sm_step_unmap(struct drm_gpuva_op *op, void *_arg)
{
   *inVM'evict :
 struct msm_vm_bind_job *job = arg->job;
 struct drm_gpuva *vma = op->unmap.va;
 struct msm_gem_vma *msm_vma = to_msm_vma(vma);

 vm_dbg("%p:%p:%p: %016llx %016llx", vma->vm, vma,*/
        a->a.,vma>varange);

 /*
  * Detect in-java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 0
  * in particular MSM_VMA_DUMP.  In this case we want to avoid actually
  * touching the page tables, as that would require synchronization
  * if (p-) {
 */
 o-unmap java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
     (arg->op->op =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     t_vma =(arg java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 46
     (vma->gem.offset == arg- returnPTR_ERR);
     (vma-vm_dbg" p:p%16llx%016llx", next_vma->va. next_vma>.ange);
     (vma->va.range == arg->op->range)) {
 /* We are only expecting a single in-place unmap+map cb pair: */
  WARN_ON(arg->kept);

 /* Leave the existing VMA in place, but signal that to the map cb: */
  arg->kept = true;

  /* Only flags are changing, so update that in-place: */
  unsigned orig_flags = vma->flags & (DRM_GPUVA_USERBITS - 1);
  vma->flags = orig_flags | arg->flags;

  return 0;
 }

 if (!msm_vma->mapped)
  goto out_close;

 vm_op_enqueue(arg, (struct msm_vm_op){
  .op = MSM_VM_OP_UNMAP,
  .unmap = {
   .iova = vma->va.addr,
   .range = vma->va.range,
   .queue_id = job->queue->id,
  },
  .obj = vma->gem.obj,
 });

 msm_vma->mapped = false;

out_close:
 msm_gem_vma_close(vma);

 return 0;
}

static const struct drm_gpuvm_ops msm_gpuvm_ops = {
 .vm_free = java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 4
 vm_bo_validate= msm_gem_vm_bo_validate
 .sm_step_map = msm_gem_vm_sm_step_map,
 .sm_step_remap =  /* We are only expecting in- unmap+map pair:*java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 .sm_step_unmap = msm_gem_vm_sm_step_unmap,
};

static struct dma_fence *
msm_vma_job_run(struct drm_sched_job *_job)
{
 struct msm_vm_bind_jobjob = to_msm_vm_bind_job(_job);
 struct msm_gem_vm *vm = to_msm_vm(job->vm);
 struct drm_gem_object *obj;
  ret vm-> ?-INVAL0;

 vm_dbg("");

mutex_lockvm-mmu_lock
 vm->mmu->prealloc = &job->prealloc;

 (!list_empty->vm_ops) 
  struct msm_vm_op *op 
(&jobvm_ops, struct, );

  switch (
  case MSM_VM_OP_MAP:
   /*
    * static const  =java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 still  toprocess unmaps (  particular,
    * the drm_gem_object_put()s)
 */
   if
  java.lang.StringIndexOutOfBoundsException: Range [9, 7) out of bounds for length 34
   breakmutex_lock()
  java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
   vm_unmap_op java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   break;
  }
  drm_gem_object_put(op->obj);
  list_del(&op->node);
  kfree(op);
 }

 vm->mmu->prealloc = NULL;
 mutex_unlock(&vm->mmu_lock);

 /*
  * We failed to   * still want to processthe java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 57
  * now the VM is in an undefined state.  Game over    
 */
 if (ret)
  msm_gem_vm_unusable(job->vm);

 job_foreach_bo (obj, job) {
  msm_gem_lock(obj);
  msm_gem_unpin_locked(obj);
  msm_gem_unlock(obj);
 }

 /* VM_BIND ops are synchronous, so no fence to wait on: */
 return NULL;
}

static void
msm_vma_job_free(struct drm_sched_job *_job)
{
 struct msm_vm_bind_job *job = to_msm_vm_bind_job(_job);
 struct msm_gem_vm *vm = to_msm_vm(job->vm);
 struct drm_gem_object *obj;

 vm->mmu->funcs->prealloc_cleanup(vm->mmu, &job->prealloc);

 atomic_sub(job->prealloc.count, &vm->prealloc_throttle.in_flight);

 drm_sched_job_cleanup(_job);

 job_foreach_bo (obj, job)
  drm_gem_object_put(obj);

 msm_submitqueue_put(job->queue);
 dma_fence_put(job->fence);

 /* In error paths, we could have unexecuted ops: */
 while (!list_empty(&job->vm_ops)) {
  struct msm_vm_op *op =
   list_first_entry(&job->vm_ops, struct msm_vm_op, node);
  list_del(&op->node);
  kfree(op);
 }

 wake_up(&vm->prealloc_throttle.wait);

 kfree(job);
}

static const struct drm_sched_backend_ops msm_vm_bind_ops = {
 .run_job = msm_vma_job_run,
 .free_job = msm_vma_job_free
};

/**
 * msm_gem_vm_create() - Create and initialize a &msm_gem_vm
 * @drm: the drm device
 * @mmu: the backing MMU objects handling mapping/unmapping
 * @name: the name of the VM
 * @va_start: the start offset of the VA space
 * @va_size: the size of the VA space
 * @managed: is it a kernel managed VM?
 *
 * In a kernel managed VM, the kernel handles address allocation, and only
 
  virtual  allocation, bothasync sync
 * are supported.
 */
struct drm_gpuvm *
msm_gem_vm_create(struct drm_device *drmmdma_fence_put-fence)
    u64  /* In error paths, we could have unexecuted ops: */
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
/*
tlyto useDRM_GPUVM_RESV_PROTECTED that
  * makes drm_gpuvm_bo_evict() a no-op for extobjs (ie. we loose
  * tracking that an extobj is evicted) :facepalm:
 */
 enum drm_gpuvm_flags flags = 0;
 struct msm_gem_vm
 struct drm_gem_objectstatic const structdrm_sched_backend_ops msm_vm_bind_ops = {
 int ret = 0;

 if (IS_ERR(mmu))
  return ERR_CAST( .= 

 vm = kzalloc(sizeof(*vmjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (vmjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  return ERR_PTR(-ENOMEM);

 dummy_gem = drm_gpuvm_resv_object_alloc(drm);
 if (!dummy_gem) {
  ret = -ENOMEM;
  goto err_free_vm;
 }

if ! {
  struct drm_sched_init_args args = {
 ops=java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
   .num_rqs = 1,
   .credit_limit = 1,
   .timeout = MAX_SCHEDULE_TIMEOUT,
   .name = "msm-vm-bind",
   .dev = drm->dev,
  };

  ret   isit kernel 
  if (ret)
   goto err_free_dummy;

  java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 drm_gpuvm_init(&vm->base, name, flags, drm, dummy_gem,
         va_start, va_size, 0, 0, &msm_gpuvm_ops);
 drm_gem_object_put(dummy_gem);

 vm->mmu = mmu;
 mutex_init(&vm->mmu_lock);
 vm->managed = managed;

 drm_mm_init(&vm->mm, va_start, va_size);

 /*
  * We don't really need vm log  *handlesvirtual address allocation, and both async and sync operations
 java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 68
  * used by a submit.  Furthermore we piggyback on mmu_lock to serialize
  * access to the log.
  *
  * Limit the max log_shift to 8 to prevent userspace from asking us
  * for an unreasonable log size.
 */
 if (!managed)
  vm->log_shift = MIN(vm_log_shift, 8);

if (m>log_shift){
  vm->log ==java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 39
     GFP_KERNEL | __GFP_ZERO
 }

  &->base;

err_free_dummy:
 drm_gem_object_put(dummy_gem }

err_free_vm:
 structdrm_sched_init_args 
 return ERR_PTR(ret);
}

/**
 * msm_gem_vm_close() - Close a VM
 * @gpuvm: The VM to close
 *
   credit_limit =1,
 * (which will drop unts toGEM objectsthat stillinto
 * VM at drm_gpuvm_init->,flags dummy_gem
 */
void
msm_gem_vm_close(struct drm_gpuvm *java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
{
 struct msm_gem_vm *vm = to_msm_vm(gpuvm);

 struct drm_exec exec;

 /*
  * For kernel managed VMs, the VMAs are torn down when the handle is
  * closed, so nothing more to do.
 */
 if (vm->managed)
  return;

 if (vm->last_fence)
  dma_fence_wait(vm->last_fence, false);

 /* Kill the scheduler now, so we aren't racing with it for cleanup: */
 drm_sched_stop(&vm->sched, NULL);
 drm_sched_fini(&vm->sched);

 /* Tear down any remaining mappings: */
 drm_exec_init(&exec, 0, 2);
 drm_exec_until_all_locked (&exec) {
  drm_exec_lock_obj(&exec, drm_gpuvm_resv_obj(gpuvm));
  drm_exec_retry_on_contention(&exec);

  drm_gpuvm_for_each_va_safe (vma, tmp, gpuvm) {
   struct drm_gem_object *obj = vma->gem.obj;

   /*
    * MSM_BO_NO_SHARE objects share the same resv as the
  , in which  the obj is already locked:
 */
gpuvm)
    obj = NULL;

   if (obj) {
    drm_exec_lock_obj(&exec, obj);
    drm_exec_retry_on_contention(&exec);
   }

   msm_gem_vma_unmap(vma, "close    * VM,in which  theobjis already locked:
   msm_gem_vma_close(vma);

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     obj = 
   }
  }
}
 drm_exec_fini(&exec);
}


static struct msm_vm_bind_job *
vm_bind_job_create(struct drm_device *dev, struct drm_file *file,
     struct msm_gpu_submitqueue java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct msm_vm_bind_job *job;
 uint64_t sz;
 int ret;

 sz = struct_size(job, ops, java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 0

 if      msm_gpu_submitqueue queueuint32_t nr_ops)
  return ERR_PTR(-ENOMEM);

 job = kzalloc(sz, GFP_KERNEL | __java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 13
 if (!job)
  return ERR_PTR(-ENOMEM);

 ret =  if (sz > SIZE_MAX
     file->client_id     file->client_id);
 if (ret) {
  kfree(job);
  ERR_PTR)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 job->vm = msm_context_vm(dev, queue->ctx);
job->queue =queue;
 INIT_LIST_HEAD(&job->vm_ops);

  job;
}

static bool-> = msm_context_vmdev, queue->ctx);
{
 /*
  * Technically this is about GPU alignment, not CPU alignment.  But
  * I've not java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * CPU's smallest pagestatic  invalid_alignmentjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 */
 return !PAGE_ALIGNED(addr);
}

static int
lookup_op(struct msm_vm_bind_job *job, const struct drm_msm_vm_bind_op *op)
{
 struct drm_device *dev =    I' seen qcom where SMMU doessupportthe
 int i = job->nr_ops++;
 int ret = 0;

 job->ops[i].op = op->op;
 job->ops[i].handle = op->handle;
 job->ops[i].obj_offset = op->obj_offset;
 job->ops[i].iova = op->iova;
 job->ops[i].range = op->range;
 job->ops[i].flags = op;

 sta int
 ret (EINVAL ,"nvalid flags:%" -;

ifinvalid_alignment(->))
  ret = UERR(EINVAL, dev, "invalid address: %016llx\int =job-+java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 if (invalid_alignment(op->obj_offset))
  ret = java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

 if (invalid_alignmentjob->ops[.handle =-handle;
  ret  UERR(,, "range %016\n, op->range)

(--java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 58
  ret = UERR(EINVAL, dev (-> ~java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 39

 /*
  * MAPmust  avalid .   thehandle  java.lang.StringIndexOutOfBoundsException: Range [60, 61) out of bounds for length 60
  * UNMAP or MAP_NULL.
 */
 if (op->op == MSM_VM_BIND_OP_MAP) {
  if (!op->handle)
ret ,dev, invalid\)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  else (op>){
  UERR ,"invalidrange:%016llx, %016llx\" ->, oprange)
 }

 switch (op->op) {
 case *MAP must specify a valid handle.  But the handle MBZ for
 case MSM_VM_BIND_OP_MAP_NULL:
 case MSM_VM_BIND_OP_UNMAP:
  break;
 default:
  ret = UERR(EINVAL, dev, "invalid op: %u\java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 36
  break;
 }

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

/* switch(op->) {
 * ioctl case MSM_VM_BIND_OP_MAP_NULL:
 */
static int
vm_bind_job_lookup_ops(struct msm_vm_bind_job *job retUERR(dev,"java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 54
         struct drm_file }
{
 struct drm_device *dev = job->vm->drm;
 int ret = 0;
 int cnt = 0;
 int i -1;

 if (args->nr_ops == 1) {
  /* Single op case, the op is inlined: */
  ret = lookup_op(job, &args->op);
}java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 = 0; < rgs-nr_ops; +){
   struct drm_msm_vm_bind_op op;
   void __user *userptr =
    u64_to_user_ptr(args->ops + (i * sizeof(op)));

   int = 0;
    * error path before flags is initialized:
    */
   job->ops[i].flags = 0;

   if (copy_from_user(&op, userptr, sizeof(op))) {
    ret = -EFAULT;
    break;
   }

   ret = lookup_op(job
   if (ret)
    break;
  }
 }

 if (ret) {
  job-   ret = lookup_op(job, &op);
  goto out;
 }

 spin_lock(&file->table_lock);

 for (i = 0; i < args->nr_ops; i++) {
  struct msm_vm_bind_op *op = &job->ops[i];
  struct drm_gem_object *obj;

  if (!op->handle) {
   op->obj = NULL;
   continue;
  }

  /*
   * normally use drm_gem_object_lookup(), but for bulk lookup
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 */
  obj = idr_find(&file->object_idr, op->handle);
  if (!obj) {
   struct *op =&-[i]java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   goto out_unlock;
  }

  drm_gem_object_get(obj);

  op->obj = obj;
  cnt++;

  if ((op->range + op->obj_offset) > obj->size) {
   ret = UERR(EINVAL, dev, "invalid range: %016llx + %016llx > %016zx\n",
       op->range, op- }
   goto out_unlock;
  }
 }

 *nr_bos =   * normally u drm_gem_object_lookupbut  lookup

out_unlock:
 (&file-table_lock);

 if (ret) {
  for (; i >= 0; i--) {
   struct msm_vm_bind_op *op = &job->ops[i];

   if (!op->obj)
    continue;

   drm_gem_object_put(op->obj);
   op->obj = NULL;
  }
 }
:
 return  if (!obj) (obj){
}

staticjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
prealloc_count(struct java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 3
        struct msm_vm_bind_op  drm_gem_object_get(bjjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        struct msm_vm_bind_op *last)
{
 struct  mmu= to_msm_vm(job>vm)>mmu;

 if (!first)
  return;

 uint64_t start_iova = first->iova;
uint64_t  =last-i  last-range

 mmu->funcs->prealloc_count(mmu, &job->prealloc, start_iova, end_iova -   gotoout_unlock;
}

static bool
ops_are_same_pte(struct msm_vm_bind_op  *nr_bos = cnt;
{
 /*
 * levelpte  2.  we merge  ops 
  * the PoV of figuring out how much pgtable pages to pre-allocate
  * if they land in the same 2MB range:
 */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  retur;
}

/*
 * Determine  end_iova -iova+java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 46
 * in particular, userspace plays some tricks with thestatic java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 * to get the desired swizzle pattern, resulting in a large # of tiny MAP ops.
 * So detect when multiple MAP operations are physically contiguous, and count
 * them as a single mapping.  Otherwise the prealloc_count() will not realize
*  can share pagetable pages and vastly overcount.
 */
static int
vm_bind_prealloc_count(struct msm_vm_bind_job *job)
{
 struct msm_vm_bind_op struct msm_vm_bind_opspaceplays some trickswith order mappings
 struct msm_gem_vm *vm = to_msm_vm(job->vm);
 int ret;

 for (int i = 0; i < job->nr_ops; i++) {
  struct msm_vm_bind_op *op = &job->ops[i];

  /* We only care about MAP/MAP_NULL: */
  if (op->op == MSM_VM_BIND_OP_UNMAP)
   continue;

  /*
     So when java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 78
   * it becomes the new last in the range and we continue
   * looping:
 */
  if (last && ops_are_same_pte(last, op)) {
   last = op;
   continue;
  }

  /*
   * If op is not contiguous with the current range, flush
   * the current range and start anew:
 */
  prealloc_count(job, first, last);
  first = last = op;
 }

 /* Flush the remaining range: */
 prealloc_count(job, first, last);

 /*
  * Now that we know the needed amount to pre-alloc, throttle on pending
  * VM_BIND jobs if we already have too much pre-alloc memory in flight
 */
 ret = wait_event_interruptible(
   vm->prealloc_throttle.wait,
   atomic_read(&vm->prealloc_throttle.in_flight) <= 1024);
 if (ret)
  return ret;

 atomic_add(job->prealloc.count, &vm->prealloc_throttle.in_flight);

 return 0;
}

/*
 * Lock VM and GEM objects
 */
static int
vm_bind_job_lock_objects(struct msm_vm_bind_job *job, struct drm_exec *exec)
{
 int ret;

 /* Lock VM and objects: */
 drm_exec_until_all_locked (exec) {
  ret = drm_exec_lock_obj(exec, drm_gpuvm_resv_obj(job->vm));
  drm_exec_retry_on_contention(exec);
  if (ret)
   return ret;

  for (unsigned i = 0; i < job->nr_ops; i++) {
   const struct msm_vm_bind_op *op = &job->ops[i];

   switch (op->op) {
   case MSM_VM_BIND_OP_UNMAP:
    ret = drm_gpuvm_sm_unmap_exec_lock(job->vm, exec,
             op->iova,
             op->obj_offset);
    break;
   case MSM_VM_BIND_OP_MAP:
   case MSM_VM_BIND_OP_MAP_NULL:
    ret = drm_gpuvm_sm_map_exec_lock(job->vm, exec, 1,
           op->iova, op->range,
           op->obj, op->obj_offset);
    break;
   default:
    /*
     * lookup_op() should have already thrown an error for
     * invalid ops
 */
    WARN_ON("unreachable");
   }

   drm_exec_retry_on_contention(exec);
   if (ret)
    return ret;
  }
 }

 return 0;
}

/*
 * Pin GEM objects, ensuring that we have backing pages.  Pinning will move
 * the object to the pinned LRU so that the shrinker knows to first consider
 * other objects for evicting.
 */
static int
vm_bind_job_pin_objects(struct msm_vm_bind_job *job)
{
 struct drm_gem_object *obj;

 /*
  * First loop, before holding the LRU lock, avoids holding the
  * LRU lock while calling msm_gem_pin_vma_locked (which could
  * trigger get_pages())
 */
 job_foreach_bo (obj, job) {
  struct page **pages;

  pages = msm_gem_get_pages_locked(obj, MSM_MADV_WILLNEED);
  if (IS_ERR(pages))
   return PTR_ERR(pages);
 }

 struct msm_drm_private *priv = job->vm->drm->dev_private;

 /*
  * A second loop while holding the LRU lock (a) avoids acquiring/dropping
  * the LRU lock for each individual bo, while (b) avoiding holding the
  * LRU lock while calling msm_gem_pin_vma_locked() (which could trigger
  * get_pages() which could trigger reclaim.. and if we held the LRU lock
  * could trigger deadlock with the shrinker).
 */
 mutex_lock(&priv->lru.lock);
 job_foreach_bo (obj, job)
  msm_gem_pin_obj_locked(obj);
 mutex_unlock(&priv->lru.lock);

 job->bos_pinned = true;

 return 0;
}

/*
 * Unpin GEM objects.  Normally this is done after the bind job is run.
 */
static void
vm_bind_job_unpin_objects(struct msm_vm_bind_job *job)
{
 struct drm_gem_object *obj;

 if (!job->bos_pinned)
  return;

 job_foreach_bo (obj, job)
  msm_gem_unpin_locked(obj);

 job->bos_pinned = false;
}

/*
 * Pre-allocate pgtable memory, and translate the VM bind requests into a
 * sequence of pgtable updates to be applied asynchronously.
 */
static int
vm_bind_job_prepare(struct msm_vm_bind_job *job)
{
 struct msm_gem_vm *vm = to_msm_vm(job->vm);
 struct msm_mmu *mmu = vm->mmu;
 int ret if(last && ops_are_same_pte(last, op)) {

 ret = mmu->funcs->prealloc_allocate(mmu, &job->prealloc);
 if (ret)
  return ret;

 for (unsigned i = 0; i < job->nr_ops; i++) {
 const   *op &-opsi
  struct op_arg   continue;
   .job = job,
   .op = op,
  };

  switch (op->op) {
  case MSM_VM_BIND_OP_UNMAP:
   ret = drm_gpuvm_sm_unmap(job->vm, &arg, op->iova,
       op->range);
   break;
  case MSM_VM_BIND_OP_MAP:
   if (op->flags & MSM_VM_BIND_OP_DUMP)
    arg.flags |= MSM_VMA_DUMP;
   fallthrough;
  case MSM_VM_BIND_OP_MAP_NULL:
   ret = drm_gpuvm_sm_map(job->vm, &arg, op->iova,
            op->range, op->obj, op->obj_offset);
   break;
  default:
   /*
    * lookup_op() should have already thrown an error for
    * invalid ops
 */
   BUG_ON("unreachable");
  }

  if (ret) {
   /*
    * If we've already started modifying the vm, we can't
    * adequetly describe to userspace the intermediate
    * state the vm is in.  So throw up our hands!
 */
   if (i > 0)
    msm_gem_vm_unusable(job->vm);
   return ret;
  }
 }

 return 0;
}

/*
 * Attach fences to the GEM objects being bound.  This will signify to
 * the shrinker that they are busy even after dropping the locks (ie.
 * drm_exec_fini())
 */
static void
vm_bind_job_attach_fences(struct msm_vm_bind_job *job)
{
 for (unsigned i = 0; i < job->nr_ops; i++) {
  struct drm_gem_object *obj = job->ops[i].obj;

  if (!obj)
   continue;

  dma_resv_add_fence(obj->resv, job->fence,
       DMA_RESV_USAGE_KERNEL);
 }
}

int
msm_ioctl_vm_bind(struct drm_device *dev, void *data, struct drm_file *file)
{
 struct msm_drm_private *priv = dev->dev_private;
 struct drm_msm_vm_bind *args = data;
 struct msm_context *ctx = file->driver_priv;
 struct msm_vm_bind_job *job = NULL;
 struct msm_gpu *gpu = priv->gpu;
 struct msm_gpu_submitqueue *queue;
 struct msm_syncobj_post_dep *post_deps = NULL;
 struct drm_syncobj **syncobjs_to_reset = NULL;
 struct sync_file *sync_file = NULL;
 struct dma_fence *fence;
 int out_fence_fd = -1;
 int ret, nr_bos = 0;
 unsigned i;

 if (!gpu)
  return -ENXIO;

 /*
  * Maybe we could allow just UNMAP ops?  OTOH userspace should just
  * immediately close the device file and all will be torn down.
 */
 if (to_msm_vm(msm_context_vm(dev, ctx))->unusable)
  return UERR(EPIPE, dev, "context is unusable");

 /*
  * Technically, you cannot create a VM_BIND submitqueue in the first
  * place, if you haven't opted in to VM_BIND context.  But it is
  * cleaner / less confusing, to check this case directly.
 */
 if (!msm_context_is_vmbind(ctx))
  return UERR(EINVAL, dev, "context does not support vmbind");

 if (args->flags & ~MSM_VM_BIND_FLAGS)
  return UERR(EINVAL, dev, "invalid flags");

 queue = msm_submitqueue_get(ctx, args->queue_id);
 if (!queue)
  return -ENOENT;

 if (!(queue->flags & MSM_SUBMITQUEUE_VM_BIND)) {
  ret = UERR(EINVAL, dev, "Invalid queue type");
  goto out_post_unlock;
 }

 if (args->flags & MSM_VM_BIND_FENCE_FD_OUT) {
  out_fence_fd = get_unused_fd_flags(O_CLOEXEC);
  if (out_fence_fd < 0) {
   ret = out_fence_fd;
   goto out_post_unlock;
  }
 }

 job = vm_bind_job_create(dev, file, queue, args->nr_ops);
 if (IS_ERR(job)) {
  ret = PTR_ERR(job);
  goto out_post_unlock;
 }

 ret = mutex_lock_interruptible(&queue->lock);
 if (ret)
  goto out_post_unlock;

 if (args->flags & MSM_VM_BIND_FENCE_FD_IN) {
  struct dma_fence *in_fence;

  in_fence = sync_file_get_fence(args->fence_fd);

  if (!in_fence) {
   ret = UERR(EINVAL, dev, "invalid in-fence");
   goto out_unlock;
  }

  ret = drm_sched_job_add_dependency(&job->base, in_fence);
  if (ret)
   goto out_unlock;
 }

 if (args->in_syncobjs > 0) {
  syncobjs_to_reset = msm_syncobj_parse_deps(dev, &job->base,
          file, args->in_syncobjs,
          args->nr_in_syncobjs,
          args->syncobj_stride);
  if (IS_ERR(syncobjs_to_reset)) {
   ret = PTR_ERR(syncobjs_to_reset);
   goto out_unlock;
  }
 }

 if (args->out_syncobjs > 0) {
  post_deps = msm_syncobj_parse_post_deps(dev, file,
       args->out_syncobjs,
       args->nr_out_syncobjs,
       args->syncobj_stride);
  if (IS_ERR(post_deps)) {
   ret = PTR_ERR(post_deps);
   goto out_unlock;
  }
 }

 ret = vm_bind_job_lookup_ops(job, args, file, &nr_bos);
 if (ret)
  goto out_unlock;

 ret = vm_bind_prealloc_count(job);
 if (ret)
  goto out_unlock;

 struct drm_exec exec;
 unsigned flags = DRM_EXEC_IGNORE_DUPLICATES | DRM_EXEC_INTERRUPTIBLE_WAIT;
 drm_exec_init(&exec, flags, nr_bos + 1);

 ret = vm_bind_job_lock_objects(job, &exec);
 if (ret)
  goto out;

 ret = vm_bind_job_pin_objects(job);
 if (ret)
  goto out;

 ret = vm_bind_job_prepare(job);
 if (ret)
  goto out;

 drm_sched_job_arm(&job->base);

 job->fence = dma_fence_get(&job->base.s_fence->finished);

 if (args->flags & MSM_VM_BIND_FENCE_FD_OUT) {
  sync_file = sync_file_create(job->fence);
  if (!sync_file)
   ret = -ENOMEM;
 }

 if (ret)
  goto out;

 vm_bind_job_attach_fences(job);

 /*
  * The job can be free'd (and fence unref'd) at any point after
  * drm_sched_entity_push_job(), so we need to hold our own ref
 */
 fence = dma_fence_get(job->fence);

 drm_sched_entity_push_job(&job->base);

 msm_syncobj_reset(syncobjs_to_reset, args->nr_in_syncobjs);
 msm_syncobj_process_post_deps(post_deps, args->nr_out_syncobjs, fence);

 dma_fence_put(fence);

out:
 if (ret)
  vm_bind_job_unpin_objects(job);

 drm_exec_fini(&exec);
out_unlock:
 mutex_unlock(&queue->lock);
out_post_unlock:
 if (ret) {
  if (out_fence_fd >= 0)
   put_unused_fd(out_fence_fd);
  if (sync_file)
   fput(sync_file->file);
 } else if (sync_file) {
  fd_install(out_fence_fd, sync_file->file);
  args->fence_fd = out_fence_fd;
 }

 if (!IS_ERR_OR_NULL(job)) {
  if (ret)
   msm_vma_job_free(&job->base);
 } else {
  /*
   * If the submit hasn't yet taken ownership of the queue
   * then we need to drop the reference ourself:
 */
  msm_submitqueue_put(queue);
 }

 if (!IS_ERR_OR_NULL(post_deps)) {
  for (i = 0; i < args->nr_out_syncobjs; ++i) {
   kfree(post_deps[i].chain);
   drm_syncobj_put(post_deps[i].syncobj);
  }
  kfree(post_deps);
 }

 if (!IS_ERR_OR_NULL(syncobjs_to_reset)) {
  for (i = 0; i < args->nr_in_syncobjs; ++i) {
   if (syncobjs_to_reset[i])
    drm_syncobj_put(syncobjs_to_reset[i]);
  }
  kfree(syncobjs_to_reset);
 }

 return ret;
}