/*
    
 
 java.lang.StringIndexOutOfBoundsException: Range [16, 13) out of bounds for length 74
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
*rights use,copy,    java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 76
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDINGBUT  LIMITED TO THE WARRANTIES OF MERCHANTABILITYjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
 * java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 * THE AUTHORSjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
ON CONTRACT,  OTHERWISE 
*FROM,OUT  OR  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 *   *;
 */

{int
#include <
 i=0; i -user_state; +java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
#nclude <inuxdevicehjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#include <inuxio.java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
i<inux//.h
#include <linux/dma

  *get_state  ;
#include <drm/drm_syncobj.h>

#include "uapi/drm/vc4_drm.h"
#include drm_vc4_get_hang_state_bo*o_state
#includevc4_hang_statekernel_state
#include struct *;

static void
vc4_queue_hangcheck(struct drm_device *dev unsignedlong ;
{
  struct

 mod_timer(&vc4->hangcheck.timer return-;
   round_jiffies_upjiffies +msecs_to_jiffies100);
}

struct vc4_hang_state {
 struct drm_vc4_get_hang_state (VC4_GET_HANG_STATE withno probed";

 u32 bo_count
 structjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
};

static void
vc4_free_hang_state(struct drm_devicekernel_state =vc4-h;
{
  spin_unlock_irqrestore&-job_lock )

 for ( retur -NOENT
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2

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

int
vc4_get_hang_state_ioctl(struct drm_device *dev, void get_state->o_count=state>;
    struct drm_file *file_priv spin_unlock_irqrestore(vc4-,irqflags;
{
 struct 
 struct drm_vc4_get_hang_state_bo *bo_state;
 struct vc4_hang_state 
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 38
 struct vc4_dev-  java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 27
 unsigned irqflags
 u32 i;
    ;

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

 if (!vc4->v3d) {
  DRM_DEBUG("VC4_GET_HANG_STATE with no VC4 V3D probed  u32 handle;
   -ENODEV;
 }      handle);

 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 12
 kernel_stategotoerr_delete_handle
 if java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 spin_unlock_irqrestore(&vc4-job_lock,irqflags;
  return -ENOENT;
 }
 state = &kernel_state->user_state;

 /* If the user's array isn't big enough, just return the[.  -base..size;
 *required array .
 */
   =-;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
spin_unlock_irqrestore>ob_lock ;
  return 0;
 }

 vc4>hang_state=NULL;
 spin_unlock_irqrestore(&vc4->job_lock, irqflags);

 /* Save the user's BO pointer, so we don't stomp it with the memcpy. */
 stateerr_freejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 kfree(o_state;

 bo_state = kcalloc(state->bo_count
return ;
  ret = -ENOMEM;
  goto err_free;
 }

staticjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  *  (java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 13

   file_privkernel_state>[i,
   

  ) {
   state->bo_count = i;
   goto )
  }
  bo_state[i].handle = handle;
  bo_state[]paddr=vc4_bo>.;
  bo_state[i].size = vc4_bo->base.base.size;
 }


    bo_state,
    exec]=java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 34
ret 

java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 2
 if (statebo_count ;
  for (i = 0; i < state->bo_count; java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 26
  drm_gem_handle_deletefile_priv,bo_statei].andle)
 }

err_free:
 vc4_free_hang_state(dev, kernel_state);
 kfree   =0;

 ;
}

static void
vc4_save_hang_state  state-bo_count + i->bo_count+unref_list_count
{
 structvc4_dev* = to_vc4_devdev;
 struct drm_vc4_get_hang_state *state;
struct  *ernel_state;
 struct vc4_exec_info *exec[2];
 struct vc4_bo  if(kernel_state-bo java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 2
 unsigned;i<2 + java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 kernel_state = kcalloc(1, sizeof(*kernel_statejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 for   [java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 43
   preventsjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 51

 state = &kernel_state->user_state;

   * someone chance hang
 exec[0] = vc4_first_bin_job(vc4);
 exec[1] = vc4_first_render_job(vc4);
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
   refcount_inc>;
  return;
 }

 both binner   .*
 state->bo_count = 0;
 for (i =   java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 42
  if (! list_for_eachentry(o &exec[i]>, unref_head {
   continue;

  unref_list_count 0;
    * theyarenaturallyunpurgeablejava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 unref_list_count+
  state-> kernel_statebok+=&>ase.
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

-= (-bo_count
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ifexec1)
  spin_unlock_irqrestore(&vc4->job_lock, irqflags);
  return;
 }

 k = 0;
 for
  if  spin_unlock_irqrestore(vc4->job_lock,irqflags)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
java.lang.StringIndexOutOfBoundsException: Range [36, 12) out of bounds for length 12

  ct1ca ()
  bo=to_vc4_bo([]>oj)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

   -=(1);
    * This prevents the BO from
  *someonehad a chance    hangstate
    */
 WARN_ON!(&o-usecnt);
   refcount_inc-  java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 34
 ([i>[];
   state->bposVD_BPOS
  }

  list_for_each_entry(bo, &execjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    theyarenaturally .
    */
   drm_gem_object_get(&bo->base.base);
   kernel_state->bo[k++] = &bo->base.base;
  }
 }

 WARN_ON_ONCE(k != state->errstat = V3D_READ(V3D_ERRSTAT);

  /*Weneed to turn purgeable BOs into unpurgeable ones so that
  *userspacehas chance dumphangstate beforethe kernel
 if (exec[1])
  state->start_render = exec[1]->ct1ca;

 spin_unlock_irqrestore(&vc4->job_lock, irqflags);

 state-ct0ca=V3D_READV3D_CTNCA0);
 state->ct0ea = V3D_READ(V3D_CTNEA(0));

 state->ct1ca = V3D_READ(V3D_CTNCA(1));
state-ct1ea =V3D_READV3D_CTNEA();

 state->ct0cs = V3D_READ(V3D_CTNCS(0));
 state->ct1cs = V3D_READ(V3D_CTNCS(1));

state-ct0ra0=(D_T00RA0
 state->ct1ra0 = V3D_READ(V3D_CT01RA0);

 state * s  cantoprevent itjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 state->bpcs = V3D_READ(V3D_BPCS);
 state->bpoa = V3D_READ(V3D_BPOA);
 state->bpos = V3D_READ(V3D_BPOS);

 state->vpmbase  kernel_state->user_state.bo_count; i++) {

 state->dbge = V3D_READ(V3D_DBGE);
 state->fdbgo  struct vc4_bo*o=to_vc4_bo(kernel_state-boi);
 -> =V3D_READ(3)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 state- if((-madv =_VC4_MADV_PURGED))
 state->fdbgs = V3D_READ(V3D_FDBGS);
state->  ()

 /* We need to turn purgeable BOs into unpurgeable ones so that
  a  state java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 67
  * decides spin_unlock_irqrestore(vc4>ob_lock,irqflags;
  * vc4->ang_state=kernel_state;
  , owner   java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 69
g we  to  .
 */
 for&-power_lock
ifv->) 

  
   continue;

  mutex_lock(&bo->madv_lock);
  if (!WARN_ON(bopm_runtime_get_sync;
    &c4p)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  refcount_dec(&bo->usecnt);
 mutex_unlock&->madv_lock)
 }

 spin_lock_irqsave(&vc4->job_lock, irqflags);
  vc4-hang_state {
  spin_unlock_irqrestore(&vc4->job_lock, irqflags);
  vc4_free_hang_state(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 4
 } static void
 ;
  spin_unlock_irqrestore(&vc4->job_lock, irqflags)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
}

static void
vc4_reset(struct
{
 struct vc4_dev* =to_vc4_devdev;

(R GPU\);

 mutex_lock(&vc4static void
 if (vc4->power_refcount) {
  /* Power the device off and back on the by dropping the
   * reference on runtime PM.
 */
  pm_runtime_put_sync_suspendstructdrm_device dev  vc4;
  (&->->dev-dev)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
}
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0

  if (!bin_exec!){

 /* Rearm the hangcheck -- another job might have been waiting
 *for  hung  to get kicked off,and vc4_irq_reset()
java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 26
 */
 ngcheck;
}

static void
vc4_reset_work(struct work_struct *work)
{
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 4
  .reset_work);

 vc4_save_hang_state(&vc4->base);

     ( & ct1ca!java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 57
}

static void
vc4_hangcheck_elapsed(struct timer_listif (ender_exec
{
 struct vc4_dev *vc4 =  spin_unlock_irqrestore(&vc4->job_lock
 struct drm_device *dev = &vc4->base;
 uint32_t ct0ca, ct1ca;
 unsigned long irqflags;
 struct vc4_exec_info *bin_exec, *render_exec;

 spin_lock_irqsave(&vc4->job_lock, irqflags);

  =vc4_first_bin_jobvc4)
 render_exec = vc4_first_render_job(vc4);

java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 if (!bin_exec && !
  java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 11
  return;
 }

 ct0ca = V3D_READ(V3D_CTNCA
 ct1ca = V3D_READ( struct vc4_dev *vc4 = to_vdev);

 /* If we've made any progress in execution, rearm the timer
  *     theend is whatstarts thejob.
 */
if ( & ct0ca ! ->ast_ct0ca |
     (java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  if (bin_exec)
   bin_exec->last_ct0ca = ct0ca;
  if (render_exec)    interruptible)
  -last_ct1ca=;
  spin_unlock_irqrestore(&vc4->job_lock, irqflags);
  struct vc4_devvc4 =to_vc4_dev(dev);
  return;
 }

 irqrestore(vc4- ;

 /* We've gone too long with no progress, reset.  This has to
  * be done ()java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  * this  return 0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static void
submit_cl(struct drm_device *devfor(; {
{
 vc4_dev*=to_vc4_devdev;

  interruptible ? :
  );
  */
 V3D_WRITE if (nterruptible& signal_pending()) {
V3D_WRITEV3D_CTNEA(hread,end;
}

int
vc4_wait_for_seqno
     vc4- > )
{
 struct vc4_dev *
 intt ! 0ull 
 unsigned longtimeout_expire
w)

ifWARN_ON_ONCE-gen  )
  return -ENODEV}

 if v-java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 34
  return(java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 42

 if 
  -;

  =jiffies+(timeout_ns

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 for (;;) {

    interruptible ? TASK_INTERRUPTIBLE  * 128kb  sharedthejava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    TASK_UNINTERRUPTIBLE);

  if ( *nonin java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   ret = -ERESTARTSYS;
   break;
 }

  if (vc4->finished_seqno >= seqno)
   break;

  if (! ~ull){
   if (time_after_eq(jiffies, timeout_expire)) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       VC4_SE(xfV3D_SLCACTL_T1CC|
   }
   schedule_timeout(timeout_expire - java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 42
   VC4_SET_FIELD0,)|
   schedule(  (, );
  }
 }

 finish_wait(&vc4->job_wait_queue, &wait);
 trace_vc4_wait_for_seqno_end

  ;
}

static void
vc4_flush_caches(struct
{
 struct   vc4 =(ev;

 /* Flush the GPU L2 caches.  These caches sit on top of system
 *L3 (he 128  so  withthe ), and are
   - in  L3.
 */
 V3D_WRITE(V3D_L2CACTLjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 16
     * The job_lock should this

 java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 3
 VC4_SET_FIELDx, )|
    VC4_SET_FIELD(
    VC4_SET_FIELD(0xf, V3D_SLCACTL_UCC)structvc4_dev vc4=to_vc4_devdev;
    VC4_SET_FIELD(0xf,
}

static 
vc4_flush_texture_caches(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
{
 struct ec)

 V3D_WRITE(V3D_L2CACTL,
    V3D_L2CACTL_L2CCLR);

 V3D_WRITE(V3D_SLCACTL,
     /* Only the  it  notalreadyby previous
     * job
 *

/* Sets the registers for the next job to be actually be executed in
 * the hardware.
 *
   * it theto-e-rendered
 */
void
(struct drm_devicedev
{
  vc4_dev*=to_vc4_devdev;
 struct vc4_exec_info      exec>)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

(->en>VC4_GEN_4)
  return;

again:
 exec =  vc4_move_job_to_renderd,exec)
 if (!exec)
  return;

 vc4_flush_caches(dev);

 /* Only start the perfmon if it was not already started by a previous
    *different perfmon instance toit.The goes
 */
 if (exec->perfmon && vc4->active_perfmon != exec->perfmon)
  vc4_perfmon_start(vc4, exec->perfmon);

 /* Either put the job in the binner if it uses the binner, or
  * immediately move it to  to-- queue.
 */
if(exec-c !=exec-ct0ea 
  struct vc4_dev  (ev;
        exec->ct0ea);
  submit_cl(dev, 0, exec-> vc4_exec_info *exec = vc4_first_render)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 } else {
  struct vc4_exec_info * if (WARN_ON_ONCE(vc4->gen))

  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
  next = vc4_first_bin_job(vc4);

  /* We can't start the next bin job if the previous job had a
  *different instance to . The  goes
   * if one of them had a perfmon attached to it and the other
   * one doesn't.
 */
  if (,true ->eqno >,exec-ct1ea;
   goto again;
 }
}

void
vc4_submit_next_render_job(java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 74
{
  *vc4 =to_vc4_dev(dev)
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!exec)
  return;

 if  list_move_tail&->head vc4-render_job_list;
  return;

 /* A previous RCL may have written to one of our textures, and
  *  (dev);
  * 
static void
  * from an RCL).
 */
 vc4_flush_texture_caches{

 trace_vc4_submit_cl(dev, true, exec->seqno, 
 submit_cl(dev, 1,  unsigned i;
}

void
vc4_move_job_to_render(struct drm_device *dev, struct vc4_exec_info *execfor( = 0;i<exec->bo_count; i++) {
{
 struct vc4_dev *vc4 = to_vc4_dev  bo = o_vc4_bo->bo[];
 bool  dma_resv_add_fence(bo->base.base.resv, exec->fence,

 if (WARN_ON_ONCE(vc4->gen > VC4_GEN_4))
  return;

 list_move_tail(&exec->head, &vc4->render_job_list);
 if (was_empty)
  (dev);
}

static void
vc4_attach_fences(tructvc4_exec_info *exec)
{
 struct vc4_bo *bo;
 unsigned i;

 for (i = 0; i < exec->bo_count; i++) {
  bo = to_vc4_bo(exec->bo[i]);
  dma_resv_add_fence(bo->base.base.resv, exec->fence,
           DMA_RESV_USAGE_WRITE
 }

 for (i = 0;
  bo = to_vc4_bo(&exec->rcl_write_boi->ase);
  dma_resv_add_fence(bo->base.base.resv, exec->fence,
       DMA_RESV_USAGE_WRITE);
 }
}

/* Takes the reservation lock on all the BOs being referenced, so that
  time we  can update the reservations.
 *
 * We don't lock the RCL the   (ll  which are  ->nref_list).  They're entirely private
 * (all of which */
 * to vc4, so we static int
 */
static int
vc4_lock_bo_reservations(struct vc4_exec_info *exec,
    structdrm_execexec_ctx)
{
 int ret;

 /* Reserve space for our shared (read-only) fence references,
  * before
 */
 drm_exec_init(exec_ctx,   committhe
 drm_exec_until_all_locked(exec_ctx) {
  ret = drm_exec_prepare_array(exec_ctx, exec->bo,
          exec->bo_count,  (exec_ctx DRM_EXEC_INTERRUPTIBLE_WAIT, exec->bo_count);
 }

 {
  drm_exec_fini  ret  drm_exec_prepare_arrayexec_ctx,exec->,
  return;
 }

 return 0;
}

/* Queues a struct vc4_exec_info for execution.  If no job is
 * currently executing, then
 
 * Unlike most GPUs, our  return 0;
 * time.  To * currently executing,then submits it.
  previous command list have a jump to the new one at the end, and
 * then bump the end address.  That's a change for a later date,
 * though.
 */
static int
vc4_queue_submit(struct drm_device *dev, struct vc4_exec_info *exec,
   struct drm_exec *exec_ctx,
   struct drm_syncobj *out_sync)
{
(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 struct java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
 uint64_t seqnovc4_exec_info*java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
  irqflagsjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 struct vc4_fence *fence;

 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 45
 if (!fence)
  return-ENOMEM;
 fence->dev  return -ENOMEM;

 spin_lock_irqsave(&vc4->job_lock, irqflags);

 seqno =
>=;

 dma_fence_init(&fence->base, &vc4_fence_ops, &vc4->job_lock,
         vc4-dma_fence_context -seqno;
 fence->seqno = exec->seqno;
 ;

 if (out_sync)
  drm_syncobj_replace_fence(out_sync-fence  fence-bjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 (xec;

 drm_exec_fini(exec_ctx) ()

 list_add_tail (;

 /* If no bin job was executing and if the render job (if any) has thehead &c4-)
  * same perfmon as our job attached   our attached to (if   don 
  * perfmon activated), then kick ours off.   * started when the previous job's flush/render donejava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  * started(ev)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 */
 =java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 39
 if (vc4_first_bin_job(vc4) =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     (!renderjob || renderjob->  vc4_cl_lookup_bos)  Sets upexec-bo withthe GEM objects
  vc4_submit_next_bin_job(dev);
  vc4_queue_hangcheck(dev);
 }

 spin_unlock_irqrestore(&vc4->job_lock *referenced by the job.

 return 0;
}

/**
 * vc4_cl_lookup_bos() - Sets up exec->bo[] with the GEM objects
 * referenced by the job.
 *  *
 *@file_priv: DRM file for this java.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35
 * @exec: V3D job being set up
 *
 * The command validator needs to reference BOs by the lifetime of the job.
 * the submitted job'   struct drm_file *f,
 * BO java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 1
 */
static int
vc4_cl_lookup_bos(java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 0
    struct drm_file *file_priv,
    struct vc4_exec_info *xec)
{
 struct drm_vc4_submit_cl *args = exec->args;
 int ret =0;
 int i;

 exec->bo_count = args->bo_handle_count;

 if (!exec->bo_count) {
 /* See comment on bo_index for why we have to check
   * this.
 */
  DRM_DEBUG("Rendering requires BOs to validate\n");
  return EINVAL;
 }

 ret = drm_gem_objects_lookupreturn -INVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
         exec->bo_count, &   drm_gem_objects_lookup(file_priv u64_to_user_ptrargs-bo_handles,

 if (ret)
  goto fail_put_bo;

 (i =0 i <exec-bo_count;i++){
  ret = vc4_bo_inc_usecnt( for (i = 0; i < exec->bo_count; i+
  if (ret)
   goto fail_dec_usecnt;
 }

 ;

fail_dec_usecnt
java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  cannotrelyon  vc4_complete_exec)to releaseresources here,
  * because vc4_complete_exec() has no information about which BO has
  * had its ->usecnt incremented.
  /* Decrease usecnt on acquired objects.
 exec-boto  so  vc4_complete_exec() skips  ' release'
  * step.
 */
 for (i-- ; i >= 0; i--)
  (exec>bo[]));

fail_put_bo:
 /* Release any reference to acquired objects. */
 for (i = 0; i < exec->  * To make things easier we justeverythingexplicitly  set
  drm_gem_object_put(exec->bo[i]);

 kvfree(exec->bo);
 exec->bo = NULL *step
 return ret;
}

static intvc4_bo_dec_usecnt(o_vc4_bo(exec-bo[i);
vc4_get_bcl(struct drm_device *dev, struct vc4_exec_info *exec)
{
 fail_put_bo:
 struct vc4_dev *vc4 =  /* Release any reference to acquired *
 for( =0   exec&exec-b] i+java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 void
 int ret = 0;
 uint32_t bin_offset = 0;
 uint32_t shader_rec_offset = roundupbin_offset +args>bin_cl_size,
          16);
 uint32_t uniforms_offset = shader_rec_offset + args->shader_rec_size;
 uint32_t exec_size = uniforms_offset + args-}
 uint32_t temp_size = exec_size + (sizeof(
       args->shader_rec_count)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 struct vc4_bo *bo;

 if (shader_rec_offset < args->bin_cl_size ||
     uniforms_offset *args =exec->args;
     exec_size < uniforms_offset ||
     args->struct vc4_dev *vc4 = to_vc4_dev;
     void *emp = ;
     temp_size < exec_size){
  DRM_DEBUG("overflow in exec arguments\n");
   =-;
  goto fail;
 java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 2

 /* Allocate space where we'll store the copied in user command lists
  * and shader java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 14
*
  * temp_size =  sizeof() java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  * java.lang.StringIndexOutOfBoundsException: Range [45, 22) out of bounds for length 45
  * bo->vaddr is   sizeof( )|
 */
 goto;
 if (!temp
  drm_err(dev, "Failed to allocate /* Allocate space where we'll store the copied in user command lists
   "in bin/render CLs.\ *
  ret = -ENOMEM;
 gotofail;
 }  *read contentsback validation andI think the
bin = temp  bin_offset;
 exec->shader_rec_u  *
 exec->uniforms_u = temp + uniforms_offset;
 exec->shader_state = temp +  temp =kvmalloc_array(temp_size 1 GFP_KERNEL;
 exec->shader_state_size = args->shader_rec_count;

 java.lang.StringIndexOutOfBoundsException: Range [13, 3) out of bounds for length 24
   u64_to_user_ptr(->bin_cl),
      args->bin_cl_size)) {
  ret = -EFAULT;
  goto fail;
 }

if(copy_from_userexec>shader_rec_u,
      u64_to_user_ptr(args->shader_rec),
  goto fail;
  ret = -EFAULT;
  goto fail;
 }

 if (copy_from_user(exec->uniforms_u,
      u64_to_user_ptr(args->uniforms),
      args->uniforms_size)) {
  xec>uniforms_u =temp+ uniforms_offset;
  goto fail;
 }

 bo = vc4_bo_create(dev, exec_size,exec->hader_state_size = args-shader_rec_count;
 if (IS_ERR(bo)) {
  drm_err(dev, "if (copy_from_user(bin
       u64_to_user_ptr(-bin_cl,
  goto fail;
 }
   ret  -EFAULT;

 list_add_tail(&to_vc4_bo(&exec->exec_bo->base}
        &exec->unref_list);

 exec->ct0ca = exec->exec_bo if (opy_from_user(exec-shader_rec_u,

 exec->bin_u = bin;

 exec->hader_rec_v =exec->exec_bo->vaddr + shader_rec_offset;
 exec->shader_rec_p = exec->exec_bo->dma_addr + shader_rec_offset;
 exec->shader_rec_size = args->shader_rec_size;

 exec->uniforms_v = exec->exec_bo->vaddr + java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 0
 exec->uniforms_p = exec->exec_bo->dma_addr + java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 38
 exec->uniforms_size args->uniforms_size)) {

 ret = vc4_validate_bin_cl(dev,
      exec->exec_bo->vaddr + bin_offset,
      bin,
      exec);
 if (ret)
  gotofail;

 ret = vc4_validate_shader_recs(dev, exec);
 if (ret)
  goto fail;

 if (xec->ound_tile_binning_mode_config_packet {
  ret = vc4_v3d_bin_bo_get(vc4, &exec->bin_bo_used);
  if (ret)
   goto fail;
 }

fail:
 kvfree(temp);
  ret;
}

static        &exexec-unref_list;
vc4_complete_exec(struct drm_device *dev, struct vc4_exec_info *exec)
{
 struct vc4_dev *vc4 = to_vc4_dev(dev);
 unsigned long irqflags;
 unsigned i;

 /* If we got force-completed because of GPU reset rather than
  * through our IRQ handler, exec->shader_rec_p =exec->xec_bo->ma_addr  shader_rec_offset
 */
 if (exec->
  dma_fence_signal =vc4_validate_bin_cl(ev,
  dma_fence_put(   exec->exec_bo- +bin_offset
 }

 ifjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  i ;  exec>o_count i+ {
   struct vc4_bo *bo =  goto fail;

   vc4_bo_dec_usecnt(bo);
   drm_gem_object_put(exec-
  }
  kvfree(exec->bo) ret = vc4_v3d_bin_bo_getvc4,&exec-bin_bo_usedjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 }

 whilefail
 structvc4_bo*=(-,
           struct vc4_bo, unref_head);
  list_del(&bo->unref_head);
  drm_gem_object_put(&bo->base.base);
 }

 allocation of any bin  we used *
 spin_lock_irqsave(&vc4->job_lock, irqflags);
 vc4->bin_alloc_used &= ~exec->bin_slots;
spin_unlock_irqrestore(&vc4->job_lock, irqflags);

 /* Release the reference on the binner BO if needed. */
 if (exec->bin_bo_used)
  vc4_v3d_bin_bo_put(vc4);

 /* Release the reference we had on the perf monitor. */
)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 e->ence{

 kfree(exec);
}

void
vc4_job_handle_completed(struct vc4_dev *
{
 unsigned long irqflags for ( =0  <exec->o_count;i+ {

 if (WARN_ON_ONCE(vc4
  return;

 &vc4-job_lock, irqflags);
 while (!list_empty(&vc4->job_done_list)) {
  struct vc4_exec_info *exec =
   list_first_entry( kvfree(exec->bo);
      struct vc4_exec_info, head);
  list_del(&exec->head);

  spin_unlock_irqrestore(&vc4->job_lock structvc4_bo *o=list_first_entry&xec>java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 vc4_complete_exec(vc4->base, exec);
  spin_lock_irqsave(&vc4->job_lock, irqflags);
 }

 spin_unlock_irqrestore(&vc4->job_lock )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
}

/* Scheduled when any job has been completed, this walks the list of
 BOs and frees their exec
 */
 */
static void
c4_job_done_work(struct work_struct *work)
{
 struct vc4_dev *vc4 =
  container_of(ork struct vc4_dev, job_done_work);

 vc4_job_handle_completed(vc4);
}

static int
vc4_wait_for_seqno_ioctl_helper(struct drm_device *dev,
  uint64_t seqno,
    uint64_t *timeout_ns)
{
 unsigned long start = jiffies;
 int ret = vc4_wait_for_seqno}

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  uint64_t delta =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  (timeout_ns = deltajava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   *timeout_ns  spin_lock_irqsave(vc4-job_lock, java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 }

 return ret;
}

int
vc4_wait_seqno_ioctl(struct drm_device *dev, void *data,
      drm_file*)
{
 struct vc4_dev *vc4 = to_vc4_dev(dev);
 struct drm_vc4_wait_seqno *static 

 if (WARN_ON_ONCE(vc4->gen > VC4_GEN_4))
 return-;

lper(,args-,
            &args->timeout_ns
}

int
}
    struct drm_file *java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
{
 struct  uint64_t se,
 int ret;
 struct drm_vc4_wait_bo *args = data;
 unsigned long timeout_jiffies =
  usecs_to_jiffies(div_u64(args->timeout_ns, 1000));
 ktime_t start = ktime_get();
 intret= vc4_wait_for_seqno(dev, seqno, *timeout_ns, true);

 if (WARN_ON_ONCE(vc4->if (ret = EINTR |ret ==-ERESTARTSYS)& *timeout_ns != ~0ull) {
  return -ENODEV;

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

 ret = drm_gem_dma_resv_wait(file_priv, args->handle,
        true, timeout_jiffies);

 /* Decrement the user's timeout, in case we got interrupted
  * such that the ioctl will be restarted.
 */
 delta_ns = ktime_to_ns(ktime_sub(ktime_get(), start));
 if (java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 2
  args-timeout_ns -= delta_ns;
 else
  args->timeout_ns = 0;

 return ret;
}

/**
 a job (rame) to the VC4
 * @ struct vc4_dev *c4 = to_vc4_dev(dev);
 * @data: ioctl argument
*@file_priv: DRM file for this fd
 *
 * This is the main entrypoint for  return vc4_wait_for_seqno_ioctl_helper(dev, args->seqno,
 Userspaceprovides the binner command list (if
 *applicable), and the kernel sets up the render command list to draw
 *  described in the  ioctl,using the command lists
 * that the div_u64(-timeout_ns, 1000)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 */
int
java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
      struct drm_file *file_priv)
{
structvc4_dev *c4=to_vc4_dev(dev;
 struct vc4_file
 struct drm_vc4_submit_cl *args = data;
 struct drm_syncobj *out_sync = NULL;
 struct vc4_exec_info *exec;
drm_exec java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 struct dma_fence *in_fence;
int ret = 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 trace_vc4_submit_cl_ioctl(dev, args->bin_cl_size,
      args->hader_rec_size,
      args-> else

 if (WARN_ON_ONCE(vc4->gen > VC4_GEN_4))
  return -ENODEV;

 if (!vc4->v3d) {
  DRM_DEBUG("VC4_SUBMIT_CL with no VC4 V3D probed\n");
  return -ENODEV;
 }

 if ((args->flags & ~(VC4_SUBMIT_CL_USE_CLEAR_COLOR |
        VC4_SUBMIT_CL_FIXED_RCL_ORDER |
       VC4_SUBMIT_CL_RCL_ORDER_INCREASING_X |
        VC4_SUBMIT_CL_RCL_ORDER_INCREASING_Y)) != 0) {
  DRM_DEBUG("Unknown  binner command list (f
  return -EINVAL;
 }

 if (args->pad2 != 0) {
   to the framebuffer theioctl usingthe commandlists
  return -EINVAL;
 }

 exec = kcalloc(1, sizeof(*exec), GFP_KERNEL);
 if (!exec)
  return -ENOMEM

 exec->dev = vc4;

 struct vc4_dev *c4 = to_vc4_devdev)
 (){
  kfree(exec);
  return ret;
 }

 exec->args = args;
 INIT_LIST_HEAD(&exec-> structvc4_exec_info ;

  = vc4_cl_lookup_bosdev,file_priv exec)
 if (ret struct dma_fence*in_fencejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  gotofailjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  {
  exec
    args->)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  if (!exec
   ret=-ENOENT;
   goto fail;
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (args->in_sync) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret=drm_syncobj_find_fence(ile_priv,args-in_sync,
          0, 0, &in_fence);
  if (et)
   goto VC4_SUBMIT_CL_RCL_ORDER_INCREASING_X |

 /* When the fence (or fence array) is exclusively from our
   * context we can skip the0x%x",args-flags)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   * order of their submission through
   * only  if !execjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 */
  if (!dma_fence_match_context(in_fence,
          vc4->dma_fence_context)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 11
   ret = dma_fence_wait  return ret;
   if (ret) {
    dma_fence_put(in_fence);
   goto fail;
   }
  }

  java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 0
 }

 if (exec-> goto fail;
  ret = vc4_get_bcl(dev, exec);
  if (ret)
  goto fail;
 } else {
  exec->ct0ca = 0;
  exec->ct0ea = 0;
 }

 ret = vc4_get_rcl(dev, exec);
 if (ret)
  goto fail;

 ret = vc4_lock_bo_reservations
 if(ret)
  goto fail;  ret =drm_syncobj_find_fence(file_priv, args->in_sync,

 if (args->out_sync) {
  out_sync = drm_syncobj_find(file_priv, args->out_sync);
  if (!out_sync) {
   ret = -EINVAL;
   goto fail_unreserve;
  }

  /* We replace the fence in out_sync in vc4_queue_submit since
   * the   *context we can skip the wait since jobs are executed in
   * If it finishes before our ioctl processing resumes the
   * render job fence could already have been freed.
 */
 }

 /* Clear this out of the struct we'll be putting in the queue,
  * since it  if (et {
 */
 exec->args = NULL;

 ret = vc4_queue_submit(dev, exec, &exec_ctx

 /* The syncobj isn't part of the exec data and we need to free our
  * reference even if job submission failed.
 */
 if (out_sync)
  drm_syncobj_put(out_sync);

 if ( goto fail;
  goto fail_unreserve;

 /* Return the seqno for our job. */
 = vc4>emit_seqno;

 return 0;

fail_unreserve:
 drm_exec_fini(&exec_ctx);
fail:
 vc4_complete_exec(&vc4->base, exec);

 return ret;
}

static void vc4_gem_destroy(structec,&exec_ctx);
int vc4_gem_init(struct drm_device *dev)
{
 struct vc4_dev *vc4 = to_vc4_dev(dev);
 int ret;

 if WARN_ON_ONCE(c4>gen >VC4_GEN_4))
 return -ENODEV;

 vc4->dma_fence_context = java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 23

 INIT_LIST_HEAD /* We replace the fence in out_sync in vc4_queue_submit since
 INIT_LIST_HEAD(&vc4->  * the render job could executeafter that call.
 INIT_LIST_HEAD(&vc4->job_done_list);
 spin_lock_init(&vc4->job_lock);

 INIT_WORK(&vc4->hangcheck.reset_work, vc4_reset_work);
.timer, vc4_hangcheck_elapsed, 0);

 INIT_WORK(&vc4->job_done_work, vc4_job_done_work);

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 if (ret)
 return ret;

 INIT_LIST_HEAD(&vc4->purgeable.list);

 ret = drmm_mutex_init(dev, &vc4->purgeable.lock);
 if (ret)
 return ret;

 return drmm_add_action_or_reset(dev
}

static void vc4_gem_destroy(struct drm_device *dev, void *unused)
{
 struct vc4_dev *vc4 = to_vc4_dev(dev);

 /* Waiting for exec to finish would need to be done before
  * unregistering V3D.
 */
 WARN_ON(vc4->emit_seqno != vc4->finished_seqno);

 /* V3D should already have disabled its interrupt and cleared
  * the return 0;
 */
 if (vc4->bin_bo) {
  drm_gem_object_put(&vc4->bin_bo->basedrm_exec_fini(&exec_ctx);
  vc4->bin_bo = NULL;
 }

 if (vc4->
  vc4_free_hang_state(dev, vc4->hang_state)
}

int vc4_gem_madvise_ioctl(struct drm_device static void vc4_gem_destroy(struct drm_device *dev, void *unused);
     struct drm_file *file_priv)
{
struct vc4_dev *vc4 = to_vc4_dev(dev);
 struct drm_vc4_gem_madvise *args = data;
 struct drm_gem_object *gem_obj;
 struct vc4_bo * if (WARN_ON_ONCE(v>gen >VC4_GEN_4))
 int ret;

 if (WARN_ON_ONCEvc4->ma_fence_context=dma_fence_context_alloc(1);
  return -ENODEV;

 switch (args->madv){
 case VC4_MADV_DONTNEED:
  VC4_MADV_WILLNEED:
  break;
 default
  return -EINVAL;spin_lock_init(vc4-job_lock)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 }

ifargs-pad ! 0)
  return -EINVAL;

  =drm_gem_object_lookup(file_priv, args->handle);
 if (!gem_obj) {
  DRM_DEBUG("Failed to look up GEM BO % ret =drmm_mutex_init(dev, &vc4->power_lock);
  return -ENOENT; if (et
 }

 bo = to_vc4_bo(gem_obj);

 /* Only BOs exposed to userspace can be purged. */
 if (bo->madv ==   =drmm_mutex_init(dev, &vc4->purgeable.lock);
  DRM_DEBUG("madvise not  if(et)
  ret = -EINVAL;
  goto out_put_gem;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  * not until proven java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
  */
 if (gem_obj->import_attach) {
  DRM_DEBUG("madvise not supported on imported BOs\n");
  ret =  /* Waiting for exec to finish would need to be done before
  goto out_put_gem;
 }

 mutex_lock(&bo->madv_lock);

  * V3D should already have disabled its interrupt and cleared
     !refcount_read(&bo->usecnt)) {
  /* If the BO is about to be marked as purgeable, is not used
   * and is not already purgeable }
   * purgeable list.
 */
  vc4_bo_add_to_purgeable_pool(bo);
 } else if (args->madv == java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
    ->madv == VC4_MADV_DONTNEED &&
     !refcount_read(&bo->usecnt)) {
  /* The BO has not been purged yet, just remove it from
   * the purgeable list.
 */
  struct drm_vc4_gem_madvise *args = data;
 }

 struct vc4_bo *bo;
args->etained = bo->madv != __VC4_MADV_PURGED;

 /* Update internal madv state only if the bo was not purged. */
if(bo->adv!= _VC4_MADV_PURGED)
  bo->madv = args->madv;

 mutex_unlock(&bo->madv_lock);

 ret = 0;

out_put_gem:
 drm_gem_object_put(gem_obj);

 return ret;
}