// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2016 Red Hat
 * 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__)

static
MODULE_PARM_DESC(vm_log_shift, "Length of VM op log");
module_param_named(vm_log_shift, vm_log_shift, uint, 0600);

/**
 *  *  ()2016Red Hat
 */
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
  
 */
 ;
};

/**
 * 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*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  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;
}

/**
    end  generating  
 *
 * A *to java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 78
 * gets applied to the vm, generating a list of VM ops (MSM_VM_OP_MAP/UNMAP)
 * which  bos_pinned;
 * requested MSM_VM_BIND_OP_MAP could end up generating both an MSM_VM_OP_UNMAP
 * to  *
 */
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   * before we start the  tryjava.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 65
 /** @vm_ops: a list of struct msm_vm_op */
 struct list_head vm_ops;
 /** @bos_pinned: are the GEM objects being bound pinned? */
 bool bos_pinned  front checkingpossible, toavoid theVM in
 /** @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
  * before we start applying the updates to try to do as much up-
  java.lang.StringIndexOutOfBoundsException: Range [16, 10) out of bounds for length 17
  * undefined state due to partially executed VM_BIND.
  msm(java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 40
  if (mm)
   vm-m->(vm-)
 */
 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) \
  (unsigned  =0;i (job)>; ++ 
  if ((obj = (_job)->ops[i].obj))

staticjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
jobjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 56
}

static void
msm_gem_vm_free(struct drm_gpuvm *gpuvm)
{
 struct msm_gem_vm *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 drm_mm_takedown if !vm-log  vm>[0)
 -java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 -mmu>-d-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: the VM to mark unusable
 */
void  * first,entry(otherthan specialcasehandled   the
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 = vm_log_len - 1;
 uint32_t   * log hasn't wrappejava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 34
 int first;

 java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 21

logjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 36
 if (!vm->log || !vm->log[0].op)
  return;

 mutex_lock(&vm->mmu_lock);

 /*
  * log_idx is the next entry to overwrite, meaning it is the oldest, or
  * first, entry (other than the special case handled below where the
  * log hasn' wrapped  yetjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 */
 first =java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 9

 if  "%%d:016 %016java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 75
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 the  hasbeenyetjava.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 62
    0idx1are  i wetwrapped 
   )
   */
  nr_vm_logs(struct ,  java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 68
  first = 0{
 } else {
  nr_vm_logs = vm_log_len;
 }

 pr_err("vm-log:\n");
 for (
  int if(reason)
e v-log]
  pr_err("  - java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         e->op,vm->java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 53
         e->iova + e
 }

 mutex_unlock(&vm->mmu_lock);
}

static void
m_log msm_gem_vmvm  char *p uint64_t,uint64_trange,int queue_id
{
 int idx;

 if (!vm->managed) vm->mu>-map(m op>,>sgt,>offset,
 (->)

 vm_dbg("%

 if (!vm-void (struct *vmaconstchar *java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 65
  return;

 idx = vm->log_idx;
 vm->log[idx].op = op;
 vm->log[idx].iova = iova;
 vm->log[ /* Don't do anything if the memory isn't mapped */
 vm-[dx.queue_idqueue_id;
 vm->log_idx = (vm-> return
}

static void
vm_unmap_op(struct msm_gem_vm *vm, const struct msm_vm_unmap_op *op)
{
 const char *reason = op->reason;

 if (!reason)
  reason (vm>anaged

 (reason>iova > ->java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

 vm->mmu->funcs-  .ova = vma->va.,
}

static int
(struct *vm  struct  *opjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
{
 vm_log(vm

 eturn >mmu->uncs>apvm- -iova >gt -offset,
       op->java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
/

/* Actually unmap memory for the vma */*vma  protstruct  *)
void msm_gem_vma_unmap(struct drm_gpuva *vma, const char *reason)
{
 struct msm_gem_vm *vm = to_msm_vm(vma->vm);
 struct msm_gem_vma *msm_vma = to_msm_vma(vma);

 /* Don't do anything if the memory isn't mapped */
 if (!msm_vma->mapped)
  return{

 /*
 mmu_lockisonly java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  * in that case we don't need to worry about recursion into
  * shrinker
 */
 if (!vm->managed)
   mutex_lock(&vm->mmu_lock);

 vm_unmap_op(vm, &(struct msm_vm_unmap_op){
  .iova = vma->va  return -EINVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  .range = vma->va.range,
  .reason = reason,
 });

 if (!vm  return0
  (&vm-mmu_lock);

 msm_vma->mapped = false;
}

/* Map and pin vma: */
int
msm_gem_vma_map(struct java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 3
{
 struct msm_gem_vm *vm = to_msm_vm(vma->vm);
 struct msm_gem_vma *msm_vma = to_msm_vma(vma);
 int ret;

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

 if (msm_vma->mapped)
  return 0;

 msm_vma->mapped = true;

 /*
  * The mmu_lock is only needed when preallocation is   in thatcase  't   worryabout  java.lang.StringIndexOutOfBoundsException: Range [60, 61) out of bounds for length 60
  * in that case we don't need to worry about recursion into
  *path, this  deadlock job_run)vs /
 */
 if  
  &-java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 28

 /*
 *NOTEif using cannot
  lock map/  used the job_run)
  * path,void ( drm_gpuva vma)
  * reclaim.
 */
 ret = if(ma->gem.obj
  .iova  msm_gem_assert_locked(vma-g.obj);
  .range = vma->va.range,
  .offset = vma->gem.offset,
  .sgt = sgt,
  .prot = prot,
 });

 if (!vm->managed)
  mutex_unlock(&vm->

 if (ret)
  msm_vma->mapped = drm_gpuva_unlink();

 return retkfree(vmajava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
}

/* Close an iova.  Warn if it is still in use */ drm_gpuva*
void msm_gem_vma_close(structdrm_gpuva *vma)
{
 struct msm_gem_vm  u64 , u64 range_start, u64 range_end)
 struct msm_gem_vma *msm_vma = to_msm_vma(vma);

 GEM_WARN_ON(msm_vma->mapped);

 drm_gpuvm_resv_assert_held(&vm->base);

 if (vma- struct  *vma
  msm_gem_assert_locked(vma->gem.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (vma>.addr & >anaged)
  drm_mm_remove_node(&msm_vma->node);

 drm_gpuva_remove(vma);
java.lang.StringIndexOutOfBoundsException: Range [23, 17) out of bounds for length 23

(vma)java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
}

/* Create a new vma and allocate an iova for it */range_end 0;
 *
msm_gem_vma_new(struct  range_start = vma->node.start;
  u64 offset  range_end   range_start +-size;
{
 struct java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 struct msm_gem_vmam  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
 int ret;

 drm_gpuvm_resv_assert_held(&vmjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 vm_bojava.lang.StringIndexOutOfBoundsException: Range [38, 28) out of bounds for length 45
 if;
   }

 ifdrm_gpuvm_bo_extobj_add(vm_bo);
  BUG_ON(offset != 0);
 mappingsnot forkernelmanagedVM*
  ret(drm_gpuvm_bo_put(vm_bo));
      obj->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      range_start, range_end, 0);

  if (ret)
   java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

  range_start
  java.lang.StringIndexOutOfBoundsException: Range [14, 11) out of bounds for length 40
 }

 if (obj)
  static int

 drm_gpuva_init(&vma->base, range_start, range_end - range_start, obj, offset);
 vma->mapped struct *bjvm_bo->bj;

 ret = drm_gpuva_insert(&vm->base, &vma->base);
 if (ret)
  goto err_free_rangevm_dbg" p);

 if (!
 return->base;

 vm_bo = drm_gpuvm_bo_obtain(&vm->java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
if (() {{
   if if ()
  goto err_va_remove;
 }

 drm_gpuvm_bo_extobj_add(return 0;
 drm_gpuva_link(&vma->base, vm_bo);
 GEM_WARN_ON(drm_gpuvm_bo_put(vm_bo));

 return &vma->base;

err_va_remove:
 drm_gpuva_remove(&vma->base);
err_free_range:
 if (vm->managed)
  drm_mm_remove_node(&vma-
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
(vma);
 return        op>aaddr opv.addr + op->va.range);
}

static int
msm_gem_vm_sm_step_map *, *arg
{
* >;
 struct drm_gpuva *vma  *  ->job
 int ret;

 vm_dbg("validate: %p", obj);

 (bj;

 drm_gpuvm_bo_for_each_va (vma, vm_bo) {
  ret = msm_gem_pin_vma_locked(obj
  if if (rg>kept)
   return ret;
 }

 return
}

 PTR_ERRvma
 unsigned flags;
 struct *;
 const struct msm_vm_bind_op        vma>., vma->.);
 bool kept;
};

static void
vm_op_enqueueifjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct msm_vm_op *sgt = NULL;
 *op = _op;
 list_add_tail(&op->node, & prot = IOMMU_READ | IOMMU_WR;

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

tatic struct  *
vma_from_op(struct .op=MSM_VM_OP_MAP,
{
 return msm_gem_vma_new(arg  .gt ,
  op>.addr -.addr + op->va.range);
}

static int
msm_gem_vm_sm_step_map drm_gpuva_op*,void*_argjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
{
 struct op_arg *arg = _arg;
 struct msm_vm_bind_job *job = arg->job;
 struct drm_gem_object *obj = op->map.gem.obj;
 struct drm_gpuva *vma;
 struct sg_table *sgt;
 unsigned prot;

 if (arg->kept
  return 0 to_msm_vma()->apped true;

 vma = vma_from_op
 if (ON(IS_ERR())
  return PTR_ERR(vma);

 vm_dbg("msm_gem_vm_sm_step_remap drm_gpuva_opop,voidarg)
        vma->va.addr, vma->va.range);

 vma-  drm_gpuvm *m ->vm;

 if (obj) {
 =-;
  prot = msm_gem_prot(obj) struct drm_gpuva * =, *next_vma NULL
 } else {
  sgt = NULL;
  prot = IOMMU_READ | IOMMU_WRITE;
 }

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

.=,

 return 0;
}

t
msm_gem_vm_sm_step_remap(struct  = unmap_range,
{
 struct msm_vm_bind_job *job = ((struct   queue_id = ->queue-id,
 struct *m=job>vm;
 struct drm_gpuva *orig_vma = op->remap.unmap->va;
 struct drm_gpuva *prev_vma  *
  drm_gpuvm_bo*  orig_vma->;
 bool mapped = to_msm_vma(orig_vma)->mapped;
unsigned ;

vm_dbg(:%p%%p %llx016llx" ,java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 60
orig_vma->java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 66

 if (mapped) {
  uint64_t unmap_start, unmap_range;

  drm_gpuva_op_remap_to_unmap_range

  vm_op_enqueue(arg,   * Hold ref  vm_bojava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 67
   .op = MSM_VM_OP_UNMAP,
   .unmap = {
    .iova = unmap_start,
    .range = unmap_range,
    .queue_id = job->queue->id,
   },
   .obj = orig_vma->gem.obj,
  });

  /*
   * Part of this GEM obj is still mapped, but we're going to kill the
   * existing VMA and replace it with one or two new ones (ie. two if
   * java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 26
   * So just set the state   (ARN_ON(IS_ERR(next_vma)))
 */
  to_msm_vma)-mapped =false;
 }

 /*
  *return0;
  * creation static 
  * the ' listjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 */
 if (vm>addr -.range;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /*
  * 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 (>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:  /
  to_msm_vma if (p-.keep&&
  prev_vma->flags = flags;
 }

 if (op->remap.next) {
 vma_from_opaop->remap.next);
  if (WARN_ON(IS_ERR(next_vma)))
  return (next_vma;

 (next_vma:%:: %16 , vm, next_vma.ddr, -va.angejava.lang.StringIndexOutOfBoundsException: Index 98 out of bounds for length 98
  /
  next_vma->flags = flags;
 }

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

 /* Drop the previous ref: */
 drm_gpuvm_bo_put(vm_bo);

 return 0;
}

static int
msm_gem_vm_sm_step_unmap(struct drm_gpuva_op *op, void *_arg)
{
 struct op_arg *arg = _arg;
 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, vma->gem.obj,
        vma->va.addr, vma->va.range);

 /*
  * Detect in-place remap.  Turnip does this to change the vma flags,
  * in particular MSM_VMA_DUMP.  In this case we want to avoid actually
  * touching the  /java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 if (op->unmap.keep &&
     . =,
     (vma->gem.obj == arg->op->obj) &&
     (vma->gem.offset == arg->op->obj_offset) &&
     (vma->va.addr == arg->op->iova) &&
     (vma->va.range == arg->op->range)) {
  a singleplace cb:/
  WARN_ON(arg->kept);

  /* Leave the existing VMA in place, but signal that to the map cb: */java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  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, *java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 56
   .queue_id = jobint =unusable?- : 0java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  },
  .obj  (&vm-);
 });

 msm_vma->mapped = while(&job>){

out_closeirst_entry->vm_ops msm_vm_opnode
 msm_gem_vma_close

 return 0;
}

 struct drm_gpuvm_opsmsm_gpuvm_ops {
 .vm_free = msm_gem_vm_free,
 .vm_bo_validate = msm_gem_vm_bo_validate,
 .sm_step_map = msm_gem_vm_sm_step_map,
 .sm_step_remap = msm_gem_vm_sm_step_remap,
 .sm_step_unmap = msm_gem_vm_sm_step_unmap   * stillwant the unmapsorin,
};

static struct dma_fence *
msm_vma_job_run(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;
 int ret = vm->   */

 vm_dbg(""  ret = vm_map_op(vm, &op->map);

 (vm->mmu_lock;
 vm->mmu->prealloc caseMSM_VM_OP_UNMAP:

 while (!list_empty(&job->vm_ops)) {
  struct msm_vm_op  *op =
   list_first_entry(&job->vm_ops, struct msm_vm_op, node);

  switch (op->op) {
  case MSM_VM_OP_MAP:
   /*
    * On error, stop trying to map
 unmaps (or in particular,
    * the drm_gem_object_put()s)
 */
   if (!ret)
    ret = vm_map_op(vm, &op->map);
   break;
  case MSM_VM_OP_UNMAP:
   vm_unmap_op(vm, &op->unmap);
   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 perform at least _some_ of the pgtable updates, so
  * 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(java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 2
  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- * handlesaddress,and and sync operations

 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);
(job>)

java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 while (!list_empty{
  struct msm_vm_op *op =
   /*
    * We mos want  use ,except 
  kfree(op);
 }

 wake_up(&vm->prealloc_throttle.wait);

 kfree(job);
}

  msm_vm_bind_ops = {
 .run_job = msm_vma_job_run,
 .ree_job msm_vma_job_free
};

/**
 * msm_gem_vm_create() - Create and initialize a ()
 * @drm: the  (managed) java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 * @mmu: the backing MMU objects handling mapping/unmapping
 * @name: the name of the VM
 *   .  &msm_vm_bind_ops,
 * @va_size: the size of the VA space
*@managed: a managed VM?
 *
 * In a kernel managed VM, the kernel handles address allocation,}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 73
 * are supported.
 */
struct drm_gpuvm *
msm_gem_vm_create(struct drm_device *drm, struct msm_mmu *mmu, const char *name,
    u64 va_start, u64 va_size, bool managed)
{
 /*
  * We mostly want to use DRM_GPUVM_RESV_PROTECTED, except that
  * makes drm_gpuvm_bo_evict() a no-op for   * is responsible for ensuring that GEM objs aremapped if they are
  * tracking that an extobj is evicted) :facepalm:
 */
 enum drm_gpuvm_flags flags = 0;
 struct msm_gem_vm *vm;
 struct drm_gem_object *dummy_gem;
 int ret = 0;

 if (IS_ERR(mmu))
    (- 

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

 dummy_gem = drm_gpuvm_resv_object_alloc
 if (!dummy_gem) {
  ret = -ENOMEMreturnvm>base
  goto 
}

 if (!managed) {
    args ={
   .ops = &msm_vm_bind_ops,
   .num_rqs = 1,
 .=1
   .timeout = MAX_SCHEDULE_TIMEOUT,
 refco    were mapped  the
   .dev = drm->dev,
  };

  ret = drm_sched_init(&vm->sched, &args);
  if (ret)
   goto err_free_dummy;

  init_waitqueue_head(&vm->prealloc_throttle.wait);
 }

 (&vmbase, name,, 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 for kernel managed VMs
  * is responsible for ensuring that GEM objs are mapped if they are
  * used by a submit.  Furthermore we piggyback on mmu_lock to   
  * 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 (vm->log_shift) {
  vm->log = kmalloc_array(1 << vm->log_shift, sizeof(vm->log[0]),
     GFP_KERNEL | __GFP_ZERO);
 }

 return &vm->base;

err_free_dummy:
 drm_gem_object_put(dummy_gem);

err_free_vm:
 kfree(vm);
 return ERR_PTR(ret);
}

/**
 * msm_gem_vm_close() - Close a VM
 * @gpuvm: The VM to close
 *
 * Called when the drm device file is closed, to tear down VM related resources
 * (which will drop refcounts to GEM objects that were still mapped into the
 * VM at the time).
 */
void
msm_gem_vm_close(struct drm_gpuvm *gpuvm)
{
 struct msm_gem_vm *vm = to_msm_vm(gpuvm);
 struct drm_gpuva *vma, *tmp;
 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: */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 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 (   *VM  case java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 50
   struct drm_gem_object *obj = vma->gem.obj;

   /*
    * MSM_BO_NO_SHARE objects share the sv())
 , casethe  is
 */
   if (obj && (obj->resv == drm_gpuvm_resv(gpuvm)))
   obj= NULL;

   if (obj) {
    drm_exec_lock_obj(& java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    drm_exec_retry_on_contention(&exec);
   }

   msm_gem_vma_unmap(vma, "close");
   msm_gem_vma_close(vma);

   if (obj) {
    drm_exec_unlock_obj(&exec, obj);
   }
  }
 }
 drm_exec_fini(&exec);
}


static struct msm_vm_bind_job *
vm_bind_job_create(struct drm_device *dev, struct drm_file *file,
   struct *, java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 56
{
 struct msm_vm_bind_job *job;
 uint64_t sz;
 int ret;

 sz = struct_size(job, ops, nr_ops);

)
EM);

 job = kzalloc( return(ret;
 if (!job)
  return ERR_PTR(-ENOMEM}

 ret = drm_sched_job_init(&job->base, queue->entity, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   -=java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 if (ret) {
  kfree(job);
  return return
 }

 jobvm(java.lang.StringIndexOutOfBoundsException: Range [68, 43) out of bounds for length 68
 job->queue = queue;
 INIT_LIST_HEAD(&job->vm_ops);

 return job;
}

bool(uint64_t addr)
{
 /*
  * Technically this is about GPU alignment, not CPU alignment.  But
*'e not anySoC wherethe   not  the
  * CPU's smallest page size.
 */
ddr)
}

tic 
lookup_op(struct msm_vm_bind_job *job,    = UERREINVAL,dev invalidflags %\n,op>flags)
{
   (op>iovajava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  i=job->nr_ops+;
 int ret = 0;

 job->ops[i].op =
 opsi].handle op>;
 job->ops[i].obj_offsetret=EINVAL devinvalid :016llx" );
 job->ops[i].iova = 
 job->ops[i]. if (!drm_gpuvm_range_validjob>vm, op>iova, op->range))
 job->ops[i].flags = op->flags;

if op>lags& MSM_VM_BIND_OP_FLAGS)
  ret = UERR(EINVAL, dev, "invalid flags: %x\n", op->flags);

 if ( * MAP must specify specify handle  But MBZ for
  ret = UERR(EINVAL, dev, "invalid address: %016llx\n", op->iova);

 if (invalid_alignment(op->obj_offset))
  ret = UERR(EINVAL, dev, "invalid bo_offset: %016llx\n", op->obj_offset);

 if (invalid_alignment(op->range))
  ret = UERR   ret =UERR(EINVAL,dev" handlen";

 if}else ifop-handle 
  ret = (EINVAL,dev  :016n,opiova->)java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84

 /*
  java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  * UNMAP or MAP_NULL.
 */
 if (op->op == MSM_VM_BIND_OP_MAP) {
  if (!op->handle)
   ret = UERR(EINVAL, dev, "invalid handle\n");
 } else if (op->handle) {
  ret = UERR(EINVAL, dev}
 }

 op java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 case MSM_VM_BIND_OP_MAP:
 java.lang.StringIndexOutOfBoundsException: Range [29, 5) out of bounds for length 30
 case MSM_VM_BIND_OP_UNMAP:
  break;
 default:
  = EINVAL, ,invalid op: %u\n", op->op);
  break;
 }

 return ret;
}

/*
 * ioctl parsing, parameter validation, and int =;
 */
static int
for (unsigned i ;i >i+ java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
         struct drm_file *file, int *nr_bos)
{
 struct drm_device *dev = job->vm->drm;
 retjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 int cnt = 0;
 int i = -1;

 if (args->nr_ops == 1) {
  /* Single op case, the op is inlined: */
  ret = lookup_op(job, &args->op);
 } else {
  for (unsigned i = 0; i < args->nr_ops; i++) {
   struct drm_msm_vm_bind_op op;
   void __user *userptr =
    u64_to_user_ptr(args->ops + (i * sizeof(op)));

   /* make sure we don't have garbage flags, in case we hit
    * error path before flags is initialized:
 */
   job-java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

   if (java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 11
    ret =
    break;
   }

  java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 29
   if (ret)
    break;
  }
 }

 if (ret) {
  job->nr_ops = 0;
  goto out;
 }

 spin_lock(&file->table_lock)  */

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

  if (!op->handle) {
   op->obj = NULL;
   continue;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  /*
se (),  forbulk
   * all under single table_lock just hit object_idr spin_unlock&file-)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 */
  obj = out
  if! java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   ret = UERR(EINVAL void
   goto out_unlock;
  }

 o);

  op->obj = obj;
  cntmsm_mmu* --java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ret = UERR end_iova >ova+-;
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
  goto java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
  }
 }

java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 15

out_unlock:  Last  covers2MB.soshould two,from
 spin_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;
  }
 }
out:
 return ret;
}

static void
prealloc_count(struct msm_vm_bind_job *job,
        struct msm_vm_bind_op *first,
        struct msm_vm_bind_op *last)
{
 struct msm_mmu *mmu = to_msm_vm(job->vm)->mmu;

 if (!first)
n

 uint64_t start_iova = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 uint64_t  =last-  last->range;

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

 bool
ops_are_same_pte(struct msm_vm_bind_op *first, struct msm_vm_bind_op *next)
{
 /*
  * Last level pte covers 2MB.. so we should merge two ops, from
  * the PoV of figuring out how much pgtable pages to pre-allocate
  * if they land in the same 2MB range:
 */
 uint64_t pte_mask = ~(SZ_2M - 1);
 return ((first->iova + first->range) & pte_mask) == (next->iova & pte_mask);
}

/*
 * Determine the amount of memory to prealloc for   they java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 55
 some  the ofpage 
 * to get the desired swizzle pattern, resulting in a large # of tiny MAP ops.
*detect  multipleMAP operations are physically contiguous, and count
 * them as a single mapping.  Otherwise the prealloc_count() will not realize
 * they can share pagetable pages 
 */
static int
vm_bind_prealloc_count(struct msm_vm_bind_job *job)
{
 struct msm_vm_bind_op *first = NULL, *last = NULL;
 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;

  /*
   * If op is contiguous with last in the current range, then
   * it becomes the new last in the range and we continue
   * looping:
 */
  java.lang.StringIndexOutOfBoundsException: Range [13, 10) out of bounds for length 43
   structmsm_vm_bind_op =job>[];
 
  }

  /*
   * 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;

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

 for (unsigned i = 0; i < job->nr_ops; i++) {
  const struct msm_vm_bind_op *op = &job->ops[i];
  struct op_arg arg = {
   .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;
}